. split the audio decoder into adec_generic, adec_layer1 and adec_layer2
    (no new code added)

Makefile.in

@@ -211,9 +211,11 @@ AC3_DECODER =	src/ac3_decoder/ac3_decoder_thread.o \
 LPCM_DECODER =	src/lpcm_decoder/lpcm_decoder_thread.o \
 		src/lpcm_decoder/lpcm_decoder.o
 
-AUDIO_DECODER =	src/audio_decoder/audio_decoder_thread.o \
-		src/audio_decoder/audio_decoder.o \
-		src/audio_decoder/audio_math.o
+AUDIO_DECODER =	src/audio_decoder/audio_decoder.o \
+		src/audio_decoder/adec_generic.o \
+		src/audio_decoder/adec_layer1.o \
+		src/audio_decoder/adec_layer2.o \
+		src/audio_decoder/adec_math.o
 
 SPU_DECODER =	src/spu_decoder/spu_decoder.o
 

src/audio_decoder/adec_generic.c

+/*****************************************************************************
+ * adec_generic.c: MPEG audio decoder
+ *****************************************************************************
+ * Copyright (C) 1999, 2000 VideoLAN
+ *
+ * Authors:
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include "int_types.h"
+
+#include "adec_generic.h"
+#include "adec_math.h"                                     /* DCT32(), PCM() */
+#include "adec_bit_stream.h"
+#include "adec_layer1.h"
+#include "adec_layer2.h"
+
+#define NULL ((void *)0)
+
+int adec_init (audiodec_t * p_adec)
+{
+    p_adec->bank_0.actual = p_adec->bank_0.v1;
+    p_adec->bank_0.pos = 0;
+    p_adec->bank_1.actual = p_adec->bank_1.v1;
+    p_adec->bank_1.pos = 0;
+    return 0;
+}
+
+int adec_sync_frame (audiodec_t * p_adec, adec_sync_info_t * p_sync_info)
+{
+    static int mpeg1_sample_rate[3] = {44100, 48000, 32000};
+    static int mpeg1_layer1_bit_rate[15] =
+    {
+        0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448
+    };
+    static int mpeg1_layer2_bit_rate[15] =
+    {
+        0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384
+    };
+    static int mpeg2_layer1_bit_rate[15] =
+    {
+        0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256
+    };
+    static int mpeg2_layer2_bit_rate[15] =
+    {
+        0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160
+    };
+    static int * bit_rate_table[8] =
+    {
+        NULL, NULL, mpeg2_layer2_bit_rate, mpeg2_layer1_bit_rate,
+        NULL, NULL, mpeg1_layer2_bit_rate, mpeg1_layer1_bit_rate
+    };
+
+    u32 header;
+    int index;
+    int * bit_rates;
+    int sample_rate;
+    int bit_rate;
+    int frame_size;
+
+    p_adec->bit_stream.total_bytes_read = 0;
+
+    header = GetByte (&p_adec->bit_stream) << 24;
+    header |= GetByte (&p_adec->bit_stream) << 16;
+    header |= GetByte (&p_adec->bit_stream) << 8;
+    header |= GetByte (&p_adec->bit_stream);
+    p_adec->header = header;
+
+    /* basic header check : sync word, no emphasis */
+    if ((header & 0xfff00003) != 0xfff00000)
+    {
+        return 1;
+    }
+
+    /* calculate bit rate */
+    index = (header >> 17) & 7; /* mpeg ID + layer */
+    bit_rates = bit_rate_table[index];
+    if (bit_rate_table == NULL)
+    {
+        return 1; /* invalid layer */
+    }
+
+    index = (header >> 12) & 15; /* bit rate index */
+    if (index > 14)
+    {
+        return 1;
+    }
+    bit_rate = bit_rates[index];
+
+    /* mpeg 1 layer 2 : check that bitrate per channel is valid */
+
+    if (bit_rates == mpeg1_layer2_bit_rate)
+    {
+        if ((header & 0xc0) == 0xc0)
+        {   /* mono */
+            if (index > 10)
+            {
+                return 1; /* invalid bitrate per channel */
+            }
+        }
+        else
+        {   /* stereo */
+            if ((1 << index) & 0x2e)
+            {
+                return 1; /* invalid bitrate per channel */
+            }
+        }
+    }
+
+    /* calculate sample rate */
+
+    index = (header >> 10) & 3; /* sample rate index */
+    if (index > 2)
+    {
+        return 1;
+    }
+
+    sample_rate = mpeg1_sample_rate[index];
+    if (!(header & 0x80000))
+    {
+        sample_rate >>= 1; /* half sample rate for mpeg2 */
+    }
+
+    /* calculate frame length */
+
+    if ((header & 0x60000) == 0x60000)
+    {   /* layer 1 */
+        frame_size = 48000 * bit_rate / sample_rate;
+        if (header & 0x200) /* padding */
+        {
+            frame_size += 4;
+        }
+    }
+    else
+    {   /* layer >1 */
+        frame_size = 144000 * bit_rate / sample_rate;
+        if (header & 0x200) /* padding */
+        {
+            frame_size ++;
+        }
+    }
+
+    p_sync_info->sample_rate = sample_rate;
+    p_sync_info->bit_rate = bit_rate;
+    p_sync_info->frame_size = frame_size;
+    p_adec->frame_size = frame_size;
+
+    return 0;
+}
+
+int adec_decode_frame (audiodec_t * p_adec, s16 * buffer)
+{
+    if (!(p_adec->header & 0x10000))
+    {   /* error check, skip it */
+        GetByte (&p_adec->bit_stream);
+        GetByte (&p_adec->bit_stream);
+    }
+
+    /* parse audio data */
+
+    p_adec->bit_stream.i_available = 0;
+
+    switch ((p_adec->header >> 17) & 3)
+    {
+        case 2: /* layer 2 */
+            if ((p_adec->header & 0xc0) == 0xc0)
+            {
+                if (adec_layer2_mono (p_adec, buffer))
+                {
+                    return 1;
+                }
+            }
+            else
+            {
+                if (adec_layer2_stereo (p_adec, buffer))
+                {
+                    return 1;
+                }
+            }
+        break;
+
+        case 3: /* layer 1 */
+            if ((p_adec->header & 0xc0) == 0xc0)
+            {
+                if (adec_layer1_mono (p_adec, buffer))
+                {
+                    return 1;
+                }
+            }
+            else
+            {
+                if (adec_layer1_stereo (p_adec, buffer))
+                {
+                    return 1;
+                }
+            }
+        break;
+    }
+
+    /* skip ancillary data */
+
+    if ((p_adec->header & 0xf000) == 0) /* free bitrate format */
+    {
+        return 0;
+    }
+
+    /* XXX rewrite the byte counting system to reduce overhead */
+
+#if 0
+    intf_DbgMsg ( "skip %d\n",
+            p_adec->frame_size - p_adec->bit_stream.total_bytes_read );
+#endif
+
+    if (p_adec->bit_stream.total_bytes_read > p_adec->frame_size)
+    {
+        return 1; /* overrun */
+    }
+
+    while (p_adec->bit_stream.total_bytes_read < p_adec->frame_size)
+    {
+        GetByte (&p_adec->bit_stream); /* skip ancillary data */
+    }
+
+    return 0;
+}
+

src/audio_decoder/adec_generic.h

+/*****************************************************************************
+ * audio_decoder.h : audio decoder interface
+ *****************************************************************************
+ * Copyright (C) 1999, 2000 VideoLAN
+ *
+ * Authors:
+ * Michel Kaempf <maxx@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/**** audio decoder API - public audio decoder structures */
+
+typedef struct audiodec_s audiodec_t;
+
+typedef struct adec_sync_info_s {
+    int sample_rate;	/* sample rate in Hz */
+    int frame_size;	/* frame size in bytes */
+    int bit_rate;	/* nominal bit rate in kbps */
+} adec_sync_info_t;
+
+typedef struct adec_byte_stream_s {
+    u8 * p_byte;
+    u8 * p_end;
+    void * info;
+} adec_byte_stream_t;
+
+/**** audio decoder API - functions publically provided by the audio dec. ****/
+
+int adec_init (audiodec_t * p_adec);
+int adec_sync_frame (audiodec_t * p_adec, adec_sync_info_t * p_sync_info);
+int adec_decode_frame (audiodec_t * p_adec, s16 * buffer);
+static adec_byte_stream_t * adec_byte_stream (audiodec_t * p_adec);
+
+/**** audio decoder API - user functions to be provided to the audio dec. ****/
+
+void adec_byte_stream_next (adec_byte_stream_t * p_byte_stream);
+
+/**** EVERYTHING AFTER THIS POINT IS PRIVATE ! DO NOT USE DIRECTLY ****/
+
+/**** audio decoder internal structures ****/
+
+typedef struct adec_bank_s {
+    float               v1[512];
+    float               v2[512];
+    float *             actual;
+    int                 pos;
+} adec_bank_t;
+
+typedef struct adec_bit_stream_s {
+    u32 buffer;
+    int i_available;
+    adec_byte_stream_t byte_stream;
+    int total_bytes_read;
+} adec_bit_stream_t;
+
+struct audiodec_s {
+    /*
+     * Input properties
+     */
+
+    /* The bit stream structure handles the PES stream at the bit level */
+    adec_bit_stream_t	bit_stream;
+
+    /*
+     * Decoder properties
+     */
+    u32			header;
+    int			frame_size;
+    adec_bank_t         bank_0;
+    adec_bank_t         bank_1;
+};
+
+/**** audio decoder inline functions ****/
+
+static adec_byte_stream_t * adec_byte_stream (audiodec_t * p_adec)
+{
+    return &(p_adec->bit_stream.byte_stream);
+}

src/audio_decoder/adec_layer1.c

+/*****************************************************************************
+ * adec_layer1.c: MPEG Layer I audio decoder
+ *****************************************************************************
+ * Copyright (C) 1999, 2000 VideoLAN
+ *
+ * Authors:
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/*
+ * TODO :
+ *
+ * - optimiser les NeedBits() et les GetBits() du code l o c'est possible ;
+ *
+ */
+
+#include "int_types.h"
+
+#include "adec_generic.h"
+#include "adec_math.h"                                     /* DCT32(), PCM() */
+#include "adec_bit_stream.h"
+
+#define NULL ((void *)0)
+
+/**** wkn ****/
+
+static float adec_scalefactor_table[64] =
+{   /* 2 ^ (1 - i/3) */
+    2.0000000000000000, 1.5874010519681994, 1.2599210498948732,
+    1.0000000000000000, 0.7937005259840998, 0.6299605249474366,
+    0.5000000000000000, 0.3968502629920499, 0.3149802624737183,
+    0.2500000000000000, 0.1984251314960249, 0.1574901312368591,
+    0.1250000000000000, 0.0992125657480125, 0.0787450656184296,
+    0.0625000000000000, 0.0496062828740062, 0.0393725328092148,
+    0.0312500000000000, 0.0248031414370031, 0.0196862664046074,
+    0.0156250000000000, 0.0124015707185016, 0.0098431332023037,
+    0.0078125000000000, 0.0062007853592508, 0.0049215666011518,
+    0.0039062500000000, 0.0031003926796254, 0.0024607833005759,
+    0.0019531250000000, 0.0015501963398127, 0.0012303916502880,
+    0.0009765625000000, 0.0007750981699063, 0.0006151958251440,
+    0.0004882812500000, 0.0003875490849532, 0.0003075979125720,
+    0.0002441406250000, 0.0001937745424766, 0.0001537989562860,
+    0.0001220703125000, 0.0000968872712383, 0.0000768994781430,
+    0.0000610351562500, 0.0000484436356191, 0.0000384497390715,
+    0.0000305175781250, 0.0000242218178096, 0.0000192248695357,
+    0.0000152587890625, 0.0000121109089048, 0.0000096124347679,
+    0.0000076293945312, 0.0000060554544524, 0.0000048062173839,
+    0.0000038146972656, 0.0000030277272262, 0.0000024031086920,
+    0.0000019073486328, 0.0000015138636131, 0.0000012015543460,
+    0.0000009536743164 /* last element is not in the standard... invalid ??? */
+};
+
+static float adec_slope_table[15] =
+{
+    0.6666666666666666, 0.2857142857142857, 0.1333333333333333,
+    0.0645161290322581, 0.0317460317460317, 0.0157480314960630,
+    0.0078431372549020, 0.0039138943248532, 0.0019550342130987,
+    0.0009770395701026, 0.0004884004884005, 0.0002441704309608,
+    0.0001220777635354, 0.0000610370189520, 0.0000305180437934
+};
+
+static float adec_offset_table[15] =
+{
+    -0.6666666666666666, -0.8571428571428571, -0.9333333333333333,
+    -0.9677419354838710, -0.9841269841269841, -0.9921259842519685,
+    -0.9960784313725490, -0.9980430528375733, -0.9990224828934506,
+    -0.9995114802149487, -0.9997557997557998, -0.9998779147845196,
+    -0.9999389611182323, -0.9999694814905240, -0.9999847409781033
+};
+
+static u8 adec_layer1_allocation_table[15] =
+{
+    0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+};
+
+static int adec_bound_table[4] = { 4, 8, 12, 16 };
+
+int adec_layer1_mono( audiodec_t * p_adec, s16 * buffer )
+{
+    u8 allocation[32];
+    float slope[32];
+    float offset[32];
+    float sample[32];
+
+    int sb;
+    int s;
+
+    /* parse allocation */
+
+    for (sb = 0; sb < 32; sb += 2)
+    {
+        u8 tmp;
+        tmp = GetByte ( &p_adec->bit_stream );
+
+        if ( (tmp >> 4) > 14 )
+        {
+            return 1;
+        }
+
+        allocation[sb] = adec_layer1_allocation_table [tmp >> 4];
+
+        if ((tmp & 15) > 14)
+        {
+            return 1;
+        }
+
+        allocation[sb+1] = adec_layer1_allocation_table [tmp & 15];
+    }
+
+    /* parse scalefactors */
+
+    for ( sb = 0; sb < 32; sb++ )
+    {
+        if ( allocation[sb] )
+        {
+            int index;
+            float scalefactor;
+
+            NeedBits ( &p_adec->bit_stream, 6 );
+            index = p_adec->bit_stream.buffer >> (32 - 6);
+            DumpBits ( &p_adec->bit_stream, 6 );
+
+            scalefactor = adec_scalefactor_table[index];
+
+            slope[sb] = adec_slope_table[allocation[sb]-2] * scalefactor;
+            offset[sb] = adec_offset_table[allocation[sb]-2] * scalefactor;
+        }
+    }
+
+    /* parse samples */
+
+    for (s = 0; s < 12; s++)
+    {
+        s16 * XXX_buf;
+
+        for (sb = 0; sb < 32; sb++)
+        {
+            if (!allocation[sb])
+            {
+                sample[sb] = 0;
+            }
+            else
+            {
+                int code;
+
+                NeedBits (&p_adec->bit_stream, allocation[sb]);
+                code = p_adec->bit_stream.buffer >> (32 - allocation[sb]);
+                DumpBits (&p_adec->bit_stream, allocation[sb]);
+
+                sample[sb] = slope[sb] * code + offset[sb];
+            }
+        }
+
+        DCT32 (sample, &p_adec->bank_0);
+        XXX_buf = buffer;
+        PCM (&p_adec->bank_0, &XXX_buf, 1);
+        buffer += 32;
+    }
+
+    return 0;
+}
+
+int adec_layer1_stereo (audiodec_t * p_adec, s16 * buffer)
+{
+    u8 allocation_0[32], allocation_1[32];
+    float slope_0[32], slope_1[32];
+    float offset_0[32], offset_1[32];
+    float sample_0[32], sample_1[32];
+
+    int bound;
+    int sb;
+    int s;
+
+    /* calculate bound */
+
+    bound = 32;
+    if ( (p_adec->header & 0xc0) == 0x40)
+    {   /* intensity stereo */
+        int index;
+        index = (p_adec->header >> 4) & 3;
+        bound = adec_bound_table[index];
+    }
+
+    /* parse allocation */
+
+    for (sb = 0; sb < bound; sb++)
+    {
+        u8 tmp;
+        tmp = GetByte (&p_adec->bit_stream);
+        if ((tmp >> 4) > 14)
+        {
+            return 1;
+        }
+        allocation_0[sb] = adec_layer1_allocation_table [tmp >> 4];
+        if ((tmp & 15) > 14)
+        {
+            return 1;
+        }
+        allocation_1[sb] = adec_layer1_allocation_table [tmp & 15];
+    }
+
+    for (; sb < 32; sb += 2)
+    {
+        u8 tmp;
+        tmp = GetByte (&p_adec->bit_stream);
+        if ((tmp >> 4) > 14)
+        {
+            return 1;
+        }
+        allocation_0[sb] = allocation_1[sb] = adec_layer1_allocation_table [tmp >> 4];
+        if ((tmp & 15) > 14)
+        {
+            return 1;
+        }
+        allocation_0[sb+1] = allocation_1[sb+1] = adec_layer1_allocation_table [tmp & 15];
+    }
+
+    /* parse scalefactors */
+
+    for ( sb = 0; sb < 32; sb++ )
+    {
+        if ( allocation_0[sb] )
+        {
+            int index;
+            float scalefactor;
+
+            NeedBits (&p_adec->bit_stream, 6);
+            index = p_adec->bit_stream.buffer >> (32 - 6);
+            DumpBits (&p_adec->bit_stream, 6);
+
+            scalefactor = adec_scalefactor_table[index];
+
+            slope_0[sb] = adec_slope_table[allocation_0[sb]-2] * scalefactor;
+            offset_0[sb] = adec_offset_table[allocation_0[sb]-2] * scalefactor;
+        }
+
+        if (allocation_1[sb])
+        {
+            int index;
+            float scalefactor;
+
+            NeedBits (&p_adec->bit_stream, 6);
+            index = p_adec->bit_stream.buffer >> (32 - 6);
+            DumpBits (&p_adec->bit_stream, 6);
+
+            scalefactor = adec_scalefactor_table[index];
+
+            slope_1[sb] = adec_slope_table[allocation_1[sb]-2] * scalefactor;
+            offset_1[sb] = adec_offset_table[allocation_1[sb]-2] * scalefactor;
+        }
+    }
+
+    /* parse samples */
+
+    for (s = 0; s < 12; s++)
+    {
+        s16 * XXX_buf;
+
+        for (sb = 0; sb < bound; sb++)
+        {
+            if (!allocation_0[sb])
+            {
+                sample_0[sb] = 0;
+            }
+            else
+            {
+                int code;
+
+                NeedBits (&p_adec->bit_stream, allocation_0[sb]);
+                code = p_adec->bit_stream.buffer >> (32 - allocation_0[sb]);
+                DumpBits (&p_adec->bit_stream, allocation_0[sb]);
+
+                sample_0[sb] = slope_0[sb] * code + offset_0[sb];
+            }
+
+            if ( !allocation_1[sb] )
+            {
+                sample_1[sb] = 0;
+            }
+            else
+            {
+                int code;
+
+                NeedBits (&p_adec->bit_stream, allocation_1[sb]);
+                code = p_adec->bit_stream.buffer >> (32 - allocation_1[sb]);
+                DumpBits (&p_adec->bit_stream, allocation_1[sb]);
+
+                sample_1[sb] = slope_1[sb] * code + offset_1[sb];
+            }
+        }
+
+        for (; sb < 32; sb++)
+        {
+            if (!allocation_0[sb])
+            {
+                sample_0[sb] = 0;
+                sample_1[sb] = 0;
+            }
+            else
+            {
+                int code;
+
+                NeedBits (&p_adec->bit_stream, allocation_0[sb]);
+                code = p_adec->bit_stream.buffer >> (32 - allocation_0[sb]);
+                DumpBits (&p_adec->bit_stream, allocation_0[sb]);
+
+                sample_0[sb] = slope_0[sb] * code + offset_0[sb];
+                sample_1[sb] = slope_1[sb] * code + offset_1[sb];
+            }
+        }
+
+        DCT32 (sample_0, &p_adec->bank_0);
+        XXX_buf = buffer;
+        PCM (&p_adec->bank_0, &XXX_buf, 2);
+        DCT32 (sample_1, &p_adec->bank_1);
+        XXX_buf = buffer+1;
+        PCM (&p_adec->bank_1, &XXX_buf, 2);
+        buffer += 64;
+    }
+
+    return 0;
+}
+

src/audio_decoder/audio_decoder_thread.h → src/audio_decoder/adec_layer1.h

 /*****************************************************************************
- * audio_decoder_thread.h : audio decoder thread interface
+ * adec_layer1.h: MPEG Layer I audio decoder
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
  *
  * Authors:
- * Michel Kaempf <maxx@via.ecp.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -21,40 +20,6 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  *****************************************************************************/
 
-/*****************************************************************************
- * adec_thread_t : audio decoder thread descriptor
- *****************************************************************************/
-typedef struct adec_thread_s
-{
-    /*
-     * Thread properties
-     */
-    vlc_thread_t        thread_id;                /* id for thread functions */
-    boolean_t           b_die;                                 /* `die' flag */
-    boolean_t           b_error;                             /* `error' flag */
-
-    /*
-     * Input properties
-     */
-    decoder_fifo_t *    p_fifo;                /* stores the PES stream data */
-    data_packet_t *     p_data;
-    adec_config_t *     p_config;
-
+int adec_layer1_mono( audiodec_t * p_adec, s16 * buffer );
+int adec_layer1_stereo (audiodec_t * p_adec, s16 * buffer);
 
-    /*
-     * Decoder properties
-     */
-    audiodec_t		audio_decoder;
-
-    /*
-     * Output properties
-     */
-    aout_fifo_t *       p_aout_fifo; /* stores the decompressed audio frames */
-    aout_thread_t *     p_aout;           /* needed to create the audio fifo */
-
-} adec_thread_t;
-
-/*****************************************************************************
- * Prototypes
- *****************************************************************************/
-vlc_thread_t adec_CreateThread       ( adec_config_t * p_config );

src/audio_decoder/adec_layer2.h

+/*****************************************************************************
+ * adec_layer2.h: MPEG Layer II audio decoder
+ *****************************************************************************
+ * Copyright (C) 1999, 2000 VideoLAN
+ *
+ * Authors:
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+int adec_layer2_mono( audiodec_t * p_adec, s16 * buffer );
+int adec_layer2_stereo (audiodec_t * p_adec, s16 * buffer);
+

src/audio_decoder/audio_math.c → src/audio_decoder/adec_math.c

 /*****************************************************************************
- * audio_math.c: Inverse Discrete Cosine Transform and Pulse Code Modulation
+ * adec_math.c: Inverse Discrete Cosine Transform and Pulse Code Modulation
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
  *
@@ -21,7 +21,7 @@
  *****************************************************************************/
 
 #include "int_types.h"
-#include "audio_decoder.h"                                    /* adec_bank_t */
+#include "adec_generic.h"                                     /* adec_bank_t */
 
 /*****************************************************************************
  * DCT32: Fast 32 points Discrete Cosine Transform

src/audio_decoder/audio_math.h → src/audio_decoder/adec_math.h

 /*****************************************************************************
- * audio_math.h : PCM and DCT
+ * adec_math.h : PCM and DCT
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
  *

src/audio_decoder/audio_test.c → src/audio_decoder/adec_test.c

 /*****************************************************************************
- * audio_test.c: MPEG1 Layer I-II audio decoder test program
+ * adec_test.c: MPEG Layer I-II audio decoder test program
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
  *
@@ -36,7 +36,7 @@
 #include <string.h>
 
 #include "int_types.h"
-#include "audio_decoder.h"
+#include "adec_generic.h"
 
 #define ADEC_FRAME_SIZE (2*1152)
 

src/audio_decoder/audio_decoder.h

 /*****************************************************************************
- * audio_decoder.h : audio decoder interface
+ * audio_decoder.h : audio decoder thread interface
  *****************************************************************************
  * Copyright (C) 1999, 2000 VideoLAN
  *
@@ -21,71 +21,40 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  *****************************************************************************/
 
-/**** audio decoder API - public audio decoder structures */
-
-typedef struct audiodec_s audiodec_t;
-
-typedef struct adec_sync_info_s {
-    int sample_rate;	/* sample rate in Hz */
-    int frame_size;	/* frame size in bytes */
-    int bit_rate;	/* nominal bit rate in kbps */
-} adec_sync_info_t;
-
-typedef struct adec_byte_stream_s {
-    u8 * p_byte;
-    u8 * p_end;
-    void * info;
-} adec_byte_stream_t;
-
-/**** audio decoder API - functions publically provided by the audio dec. ****/
-
-int adec_init (audiodec_t * p_adec);
-int adec_sync_frame (audiodec_t * p_adec, adec_sync_info_t * p_sync_info);
-int adec_decode_frame (audiodec_t * p_adec, s16 * buffer);
-static adec_byte_stream_t * adec_byte_stream (audiodec_t * p_adec);
-
-/**** audio decoder API - user functions to be provided to the audio dec. ****/
-
-void adec_byte_stream_next (adec_byte_stream_t * p_byte_stream);
-
-/**** EVERYTHING AFTER THIS POINT IS PRIVATE ! DO NOT USE DIRECTLY ****/
-
-/**** audio decoder internal structures ****/
-
-typedef struct adec_bank_s {
-    float               v1[512];
-    float               v2[512];
-    float *             actual;
-    int                 pos;
-} adec_bank_t;
-
-typedef struct adec_bit_stream_s {
-    u32 buffer;
-    int i_available;
-    adec_byte_stream_t byte_stream;
-    int total_bytes_read;
-} adec_bit_stream_t;
+/*****************************************************************************
+ * adec_thread_t : audio decoder thread descriptor
+ *****************************************************************************/
+typedef struct adec_thread_s
+{
+    /*
+     * Thread properties
+     */
+    vlc_thread_t        thread_id;                /* id for thread functions */
+    boolean_t           b_die;                                 /* `die' flag */
+    boolean_t           b_error;                             /* `error' flag */
 
-struct audiodec_s {
     /*
      * Input properties
      */
+    decoder_fifo_t *    p_fifo;                /* stores the PES stream data */
+    data_packet_t *     p_data;
+    adec_config_t *     p_config;
 
-    /* The bit stream structure handles the PES stream at the bit level */
-    adec_bit_stream_t	bit_stream;
 
     /*
      * Decoder properties
      */
-    u32			header;
-    int			frame_size;
-    adec_bank_t         bank_0;
-    adec_bank_t         bank_1;
-};
+    audiodec_t		audio_decoder;
 
-/**** audio decoder inline functions ****/
+    /*
+     * Output properties
+     */
+    aout_fifo_t *       p_aout_fifo; /* stores the decompressed audio frames */
+    aout_thread_t *     p_aout;           /* needed to create the audio fifo */
 
-static adec_byte_stream_t * adec_byte_stream (audiodec_t * p_adec)
-{
-    return &(p_adec->bit_stream.byte_stream);
-}
+} adec_thread_t;
+
+/*****************************************************************************
+ * Prototypes
+ *****************************************************************************/
+vlc_thread_t adec_CreateThread       ( adec_config_t * p_config );