git.sesse.net Git - vlc/blob - src/audio_decoder/audio_decoder.c

   1 /******************************************************************************
   2  * audio_decoder.c: MPEG1 Layer I-II audio decoder thread
   3  * (c)1999 VideoLAN
   4  ******************************************************************************/
   5
   6 /*
   7  * TODO :
   8  * - Optimiser les NeedBits() et les GetBits() du code là où c'est possible
   9  */
  10
  11 /******************************************************************************
  12  * Preamble
  13  ******************************************************************************/
  14 #include <unistd.h>
  15
  16 #include <pthread.h>
  17 #include <stdio.h>                                            /* "intf_msg.h" */
  18 #include <stdlib.h>                                       /* malloc(), free() */
  19 #include <netinet/in.h>                                            /* ntohl() */
  20 #include <sys/soundcard.h>                                /* "audio_output.h" */
  21 #include <sys/uio.h>                                             /* "input.h" */
  22
  23 #include "common.h"
  24 #include "config.h"
  25 #include "mtime.h"
  26 #include "debug.h"                                       /* "input_netlist.h" */
  27
  28 #include "intf_msg.h"                         /* intf_DbgMsg(), intf_ErrMsg() */
  29
  30 #include "input.h"                                            /* pes_packet_t */
  31 #include "input_netlist.h"                          /* input_NetlistFreePES() */
  32 #include "decoder_fifo.h"          /* DECODER_FIFO_(ISEMPTY|START|INCSTART)() */
  33
  34 #include "audio_output.h"
  35
  36 #include "audio_constants.h"
  37 #include "audio_decoder.h"
  38 #include "audio_math.h"
  39
  40 /******************************************************************************
  41  * Local prototypes
  42  ******************************************************************************/
  43 static int      InitThread              ( adec_thread_t * p_adec );
  44 static void     RunThread               ( adec_thread_t * p_adec );
  45 static void     ErrorThread             ( adec_thread_t * p_adec );
  46 static void     EndThread               ( adec_thread_t * p_adec );
  47
  48 static int      adec_Layer1_Mono        ( adec_thread_t * p_adec );
  49 static int      adec_Layer1_Stereo      ( adec_thread_t * p_adec );
  50 static int      adec_Layer2_Mono        ( adec_thread_t * p_adec );
  51 static int      adec_Layer2_Stereo      ( adec_thread_t * p_adec );
  52
  53 static byte_t   GetByte                 ( bit_stream_t * p_bit_stream );
  54 static void     NeedBits                ( bit_stream_t * p_bit_stream, int i_bits );
  55 static void     DumpBits                ( bit_stream_t * p_bit_stream, int i_bits );
  56 static int      FindHeader              ( adec_thread_t * p_adec );
  57
  58 /******************************************************************************
  59  * adec_CreateThread: creates an audio decoder thread
  60  ******************************************************************************
  61  * This function creates a new audio decoder thread, and returns a pointer to
  62  * its description. On error, it returns NULL.
  63  ******************************************************************************/
  64 adec_thread_t * adec_CreateThread( input_thread_t * p_input )
  65 {
  66     adec_thread_t *     p_adec;
  67
  68     intf_DbgMsg("adec debug: creating audio decoder thread\n");
  69
  70     /* Allocate the memory needed to store the thread's structure */
  71     if ( (p_adec = (adec_thread_t *)malloc( sizeof(adec_thread_t) )) == NULL )
  72     {
  73         intf_ErrMsg("adec error: not enough memory for adec_CreateThread() to create the new thread\n");
  74         return( NULL );
  75     }
  76
  77     /*
  78      * Initialize the thread properties
  79      */
  80     p_adec->b_die = 0;
  81     p_adec->b_error = 0;
  82
  83     /*
  84      * Initialize the input properties
  85      */
  86     /* Initialize the decoder fifo's data lock and conditional variable and set
  87      * its buffer as empty */
  88     pthread_mutex_init( &p_adec->fifo.data_lock, NULL );
  89     pthread_cond_init( &p_adec->fifo.data_wait, NULL );
  90     p_adec->fifo.i_start = 0;
  91     p_adec->fifo.i_end = 0;
  92     /* Initialize the bit stream structure */
  93     p_adec->bit_stream.p_input = p_input;
  94     p_adec->bit_stream.p_decoder_fifo = &p_adec->fifo;
  95     p_adec->bit_stream.fifo.buffer = 0;
  96     p_adec->bit_stream.fifo.i_available = 0;
  97
  98     /*
  99      * Initialize the decoder properties
 100      */
 101     p_adec->bank_0.actual = p_adec->bank_0.v1;
 102     p_adec->bank_0.pos = 0;
 103     p_adec->bank_1.actual = p_adec->bank_1.v1;
 104     p_adec->bank_1.pos = 0;
 105
 106     /*
 107      * Initialize the output properties
 108      */
 109     p_adec->p_aout = p_input->p_aout;
 110     p_adec->p_aout_fifo = NULL;
 111
 112     /* Spawn the audio decoder thread */
 113     if ( pthread_create(&p_adec->thread_id, NULL, (void *)RunThread, (void *)p_adec) )
 114     {
 115         intf_ErrMsg("adec error: can't spawn audio decoder thread\n");
 116         free( p_adec );
 117         return( NULL );
 118     }
 119
 120     intf_DbgMsg("adec debug: audio decoder thread (%p) created\n", p_adec);
 121     return( p_adec );
 122 }
 123
 124 /******************************************************************************
 125  * adec_DestroyThread: destroys an audio decoder thread
 126  ******************************************************************************
 127  * This function asks an audio decoder thread to terminate. This function has
 128  * not to wait until the decoder thread has really died, because the killer (ie
 129  * this function's caller) is the input thread, that's why we are sure that no
 130  * other thread will try to access to this thread's descriptor after its
 131  * destruction.
 132  ******************************************************************************/
 133 void adec_DestroyThread( adec_thread_t * p_adec )
 134 {
 135     intf_DbgMsg("adec debug: requesting termination of audio decoder thread %p\n", p_adec);
 136
 137     /* Ask thread to kill itself */
 138     p_adec->b_die = 1;
 139
 140     /* Remove this as soon as the "status" flag is implemented */
 141     pthread_join( p_adec->thread_id, NULL );         /* wait until it's done */
 142 }
 143
 144 /* Following functions are local */
 145
 146 /******************************************************************************
 147  * GetByte : reads the next byte in the input stream
 148  ******************************************************************************/
 149 static __inline__ byte_t GetByte( bit_stream_t * p_bit_stream )
 150 {
 151     /* Are there some bytes left in the current TS packet ? */
 152     if ( p_bit_stream->i_byte < p_bit_stream->p_ts->i_payload_end )
 153     {
 154         return( p_bit_stream->p_ts->buffer[ p_bit_stream->i_byte++ ] );
 155     }
 156     else
 157     {
 158         /* We are looking for the next TS packet that contains real data,
 159          * and not just a PES header */
 160         do
 161         {
 162             /* We were reading the last TS packet of this PES packet... It's
 163              * time to jump to the next PES packet */
 164             if ( p_bit_stream->p_ts->p_next_ts == NULL )
 165             {
 166                 /* We are going to read/write the start and end indexes of the
 167                  * decoder fifo and to use the fifo's conditional variable,
 168                  * that's why we need to take the lock before */
 169                 pthread_mutex_lock( &p_bit_stream->p_decoder_fifo->data_lock );
 170
 171                 /* We should increase the start index of the decoder fifo, but
 172                  * if we do this now, the input thread could overwrite the
 173                  * pointer to the current PES packet, and we weren't able to
 174                  * give it back to the netlist. That's why we free the PES
 175                  * packet first. */
 176                 input_NetlistFreePES( p_bit_stream->p_input, DECODER_FIFO_START(*p_bit_stream->p_decoder_fifo) );
 177                 DECODER_FIFO_INCSTART( *p_bit_stream->p_decoder_fifo );
 178
 179                 /* !! b_die !! */
 180                 while ( DECODER_FIFO_ISEMPTY(*p_bit_stream->p_decoder_fifo) )
 181                 {
 182                     pthread_cond_wait( &p_bit_stream->p_decoder_fifo->data_wait,
 183                                        &p_bit_stream->p_decoder_fifo->data_lock );
 184                 }
 185
 186                 /* The next byte could be found in the next PES packet */
 187 #ifdef DEBUG
 188 //                fprintf(stderr, "*");
 189 #endif
 190                 p_bit_stream->p_ts = DECODER_FIFO_START( *p_bit_stream->p_decoder_fifo )->p_first_ts;
 191
 192                 /* We can release the fifo's data lock */
 193                 pthread_mutex_unlock( &p_bit_stream->p_decoder_fifo->data_lock );
 194             }
 195             /* Perhaps the next TS packet of the current PES packet contains
 196              * real data (ie its payload's size is greater than 0) */
 197             else
 198             {
 199 #ifdef DEBUG
 200 //                fprintf(stderr, ".");
 201 #endif
 202                 p_bit_stream->p_ts = p_bit_stream->p_ts->p_next_ts;
 203             }
 204         } while ( p_bit_stream->p_ts->i_payload_start == p_bit_stream->p_ts->i_payload_end );
 205
 206         /* We've found a TS packet which contains interesting data... As we
 207          * return the payload's first byte, we set i_byte to the following
 208          * one */
 209         p_bit_stream->i_byte = p_bit_stream->p_ts->i_payload_start;
 210         return( p_bit_stream->p_ts->buffer[ p_bit_stream->i_byte++ ] );
 211     }
 212 }
 213
 214 /******************************************************************************
 215  * NeedBits : reads i_bits new bits in the bit stream and stores them in the
 216  *            bit buffer
 217  ******************************************************************************
 218  * - i_bits must be less or equal 32 !
 219  * - There is something important to notice with that function : if the number
 220  * of bits available in the bit buffer when calling NeedBits() is greater than
 221  * 24 (i_available > 24) but less than the number of needed bits
 222  * (i_available < i_bits), the byte returned by GetByte() will be shifted with
 223  * a negative value and the number of bits available in the bit buffer will be
 224  * set to more than 32 !
 225  ******************************************************************************/
 226 static __inline__ void NeedBits( bit_stream_t * p_bit_stream, int i_bits )
 227 {
 228     while ( p_bit_stream->fifo.i_available < i_bits )
 229     {
 230         p_bit_stream->fifo.buffer |= ((u32)GetByte( p_bit_stream )) << (24 - p_bit_stream->fifo.i_available);
 231         p_bit_stream->fifo.i_available += 8;
 232     }
 233 }
 234
 235 /******************************************************************************
 236  * DumpBits : removes i_bits bits from the bit buffer
 237  ******************************************************************************
 238  * - i_bits <= i_available
 239  * - i_bits < 32 (because (u32 << 32) <=> (u32 = u32))
 240  ******************************************************************************/
 241 static __inline__ void DumpBits( bit_stream_t * p_bit_stream, int i_bits )
 242 {
 243     p_bit_stream->fifo.buffer <<= i_bits;
 244     p_bit_stream->fifo.i_available -= i_bits;
 245 }
 246
 247 /******************************************************************************
 248  * FindHeader : parses an input stream until an audio frame header could be
 249  *              found
 250  ******************************************************************************
 251  * When this function returns successfully, the header can be found in the
 252  * buffer of the bit stream fifo.
 253  ******************************************************************************/
 254 static int FindHeader( adec_thread_t * p_adec )
 255 {
 256     while ( (!p_adec->b_die) && (!p_adec->b_error) )
 257     {
 258         NeedBits( &p_adec->bit_stream, 32 );
 259         if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_SYNCWORD_MASK) == ADEC_HEADER_SYNCWORD_MASK )
 260         {
 261 #ifdef DEBUG
 262 //            fprintf(stderr, "H");
 263 #endif
 264             return( 0 );
 265         }
 266 #ifdef DEBUG
 267 //        fprintf(stderr, "!");
 268 #endif
 269         DumpBits( &p_adec->bit_stream, 8 );
 270     }
 271
 272     return( -1 );
 273 }
 274
 275 /******************************************************************************
 276  * adec_Layer`L'_`M': decodes an mpeg 1, layer `L', mode `M', audio frame
 277  ******************************************************************************
 278  * These functions decode the audio frame which has already its header loaded
 279  * in the i_header member of the audio decoder thread structure and its first
 280  * byte of data described by the bit stream structure of the audio decoder
 281  * thread (there is no bit available in the bit buffer yet)
 282  ******************************************************************************/
 283
 284 /******************************************************************************
 285  * adec_Layer1_Mono
 286  ******************************************************************************/
 287 static __inline__ int adec_Layer1_Mono( adec_thread_t * p_adec )
 288 {
 289     p_adec->bit_stream.fifo.buffer = 0;
 290     p_adec->bit_stream.fifo.i_available = 0;
 291     return( 0 );
 292 }
 293
 294 /******************************************************************************
 295  * adec_Layer1_Stereo
 296  ******************************************************************************/
 297 static __inline__ int adec_Layer1_Stereo( adec_thread_t * p_adec )
 298 {
 299     p_adec->bit_stream.fifo.buffer = 0;
 300     p_adec->bit_stream.fifo.i_available = 0;
 301     return( 0 );
 302 }
 303
 304 /******************************************************************************
 305  * adec_Layer2_Mono
 306  ******************************************************************************/
 307 static __inline__ int adec_Layer2_Mono( adec_thread_t * p_adec )
 308 {
 309     p_adec->bit_stream.fifo.buffer = 0;
 310     p_adec->bit_stream.fifo.i_available = 0;
 311     return( 0 );
 312 }
 313
 314 /******************************************************************************
 315  * adec_Layer2_Stereo
 316  ******************************************************************************/
 317 static __inline__ int adec_Layer2_Stereo( adec_thread_t * p_adec )
 318 {
 319     typedef struct requantization_s
 320     {
 321         byte_t                          i_bits_per_codeword;
 322         const float *                   pf_ungroup;
 323         float                           f_slope;
 324         float                           f_offset;
 325     } requantization_t;
 326
 327     static const float                  pf_scalefactor[64] = ADEC_SCALE_FACTOR;
 328
 329     static u32                          i_header;
 330     static int                          i_sampling_frequency, i_mode, i_bound;
 331     static int                          pi_allocation_0[32], pi_allocation_1[32]; /* see ISO/IEC 11172-3 2.4.1.6 */
 332     int                                 i_sb, i_nbal;
 333     float                               f_scalefactor_0, f_scalefactor_1;
 334
 335     static const byte_t                 ppi_bitrate_per_channel_index[4][15] = ADEC_LAYER2_BITRATE_PER_CHANNEL_INDEX;
 336     static const byte_t                 ppi_sblimit[3][11] = ADEC_LAYER2_SBLIMIT;
 337     static const byte_t                 ppi_nbal[2][32] = ADEC_LAYER2_NBAL;
 338
 339     static const float                  pf_ungroup3[3*3*3 * 3] = ADEC_LAYER2_UNGROUP3;
 340     static const float                  pf_ungroup5[5*5*5 * 3] = ADEC_LAYER2_UNGROUP5;
 341     static const float                  pf_ungroup9[9*9*9 * 3] = ADEC_LAYER2_UNGROUP9;
 342
 343     static const requantization_t       p_requantization_cd[16] = ADEC_LAYER2_REQUANTIZATION_CD;
 344     static const requantization_t       p_requantization_ab1[16] = ADEC_LAYER2_REQUANTIZATION_AB1;
 345     static const requantization_t       p_requantization_ab2[16] = ADEC_LAYER2_REQUANTIZATION_AB2;
 346     static const requantization_t       p_requantization_ab3[16] = ADEC_LAYER2_REQUANTIZATION_AB3;
 347     static const requantization_t       p_requantization_ab4[16] = ADEC_LAYER2_REQUANTIZATION_AB4;
 348     static const requantization_t *     pp_requantization_ab[30] = ADEC_LAYER2_REQUANTIZATION_AB;
 349
 350     static int                          i_sblimit, i_bitrate_per_channel_index;
 351     static int                          pi_scfsi_0[30], pi_scfsi_1[30];
 352     static const byte_t *               pi_nbal;
 353     static float                        ppf_sample_0[3][32], ppf_sample_1[3][32];
 354     static const requantization_t *     pp_requantization_0[30];
 355     static const requantization_t *     pp_requantization_1[30];
 356     static requantization_t             requantization;
 357     static const float *                pf_ungroup;
 358
 359     static float                        pf_scalefactor_0_0[30], pf_scalefactor_0_1[30], pf_scalefactor_0_2[30];
 360     static float                        pf_scalefactor_1_0[30], pf_scalefactor_1_1[30], pf_scalefactor_1_2[30];
 361
 362     int                                 i_2nbal, i_gr;
 363     float                               f_dummy;
 364
 365     long                                l_end_frame;
 366     s16 *                               p_s16;
 367
 368     int                                 i_need = 0, i_dump = 0;
 369 //    static const int                    pi_framesize[512] = ADEC_FRAME_SIZE;
 370
 371     /* Read the audio frame header and flush the bit buffer */
 372     i_header = p_adec->bit_stream.fifo.buffer;
 373     p_adec->bit_stream.fifo.buffer = 0;
 374     p_adec->bit_stream.fifo.i_available = 0;
 375     /* Read the sampling frequency (see ISO/IEC 11172-3 2.4.2.3) */
 376     i_sampling_frequency = (int)((i_header & ADEC_HEADER_SAMPLING_FREQUENCY_MASK)
 377         >> ADEC_HEADER_SAMPLING_FREQUENCY_SHIFT);
 378     /* Read the mode (see ISO/IEC 11172-3 2.4.2.3) */
 379     i_mode = (int)((i_header & ADEC_HEADER_MODE_MASK) >> ADEC_HEADER_MODE_SHIFT);
 380     /* If a CRC can be found in the frame, get rid of it */
 381     if ( (i_header & ADEC_HEADER_PROTECTION_BIT_MASK) == 0 )
 382     {
 383         GetByte( &p_adec->bit_stream );
 384         GetByte( &p_adec->bit_stream );
 385     }
 386
 387     /* Find out the bitrate per channel index */
 388     i_bitrate_per_channel_index = (int)ppi_bitrate_per_channel_index[i_mode]
 389         [(i_header & ADEC_HEADER_BITRATE_INDEX_MASK) >> ADEC_HEADER_BITRATE_INDEX_SHIFT];
 390     /* Find out the number of subbands */
 391     i_sblimit = (int)ppi_sblimit[i_sampling_frequency][i_bitrate_per_channel_index];
 392     /* Check if the frame is valid or not */
 393     if ( i_sblimit == 0 )
 394     {
 395         return( 0 );                                  /* the frame is invalid */
 396     }
 397     /* Find out the number of bits allocated */
 398     pi_nbal = ppi_nbal[ (i_bitrate_per_channel_index <= 2) ? 0 : 1 ];
 399
 400     /* Find out the `bound' subband (see ISO/IEC 11172-3 2.4.2.3) */
 401     if ( i_mode == 1 )
 402     {
 403         i_bound = (int)(((i_header & ADEC_HEADER_MODE_EXTENSION_MASK) >> (ADEC_HEADER_MODE_EXTENSION_SHIFT - 2)) + 4);
 404         if ( i_bound > i_sblimit )
 405         {
 406             i_bound = i_sblimit;
 407         }
 408     }
 409     else
 410     {
 411         i_bound = i_sblimit;
 412     }
 413
 414     /* Read the allocation information (see ISO/IEC 11172-3 2.4.1.6) */
 415     for ( i_sb = 0; i_sb < i_bound; i_sb++ )
 416     {
 417         i_2nbal = 2 * (i_nbal = (int)pi_nbal[ i_sb ]);
 418         NeedBits( &p_adec->bit_stream, i_2nbal );
 419         i_need += i_2nbal;
 420         pi_allocation_0[ i_sb ] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - i_nbal));
 421         p_adec->bit_stream.fifo.buffer <<= i_nbal;
 422         pi_allocation_1[ i_sb ] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - i_nbal));
 423         p_adec->bit_stream.fifo.buffer <<= i_nbal;
 424         p_adec->bit_stream.fifo.i_available -= i_2nbal;
 425         i_dump += i_2nbal;
 426     }
 427     for ( ; i_sb < i_sblimit; i_sb++ )
 428     {
 429         i_nbal = (int)pi_nbal[ i_sb ];
 430         NeedBits( &p_adec->bit_stream, i_nbal );
 431         i_need += i_nbal;
 432         pi_allocation_0[ i_sb ] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - i_nbal));
 433         DumpBits( &p_adec->bit_stream, i_nbal );
 434         i_dump += i_nbal;
 435     }
 436
 437 #define MACRO( p_requantization ) \
 438     for ( i_sb = 0; i_sb < i_bound; i_sb++ ) \
 439     { \
 440         if ( pi_allocation_0[i_sb] ) \
 441         { \
 442             pp_requantization_0[i_sb] = &((p_requantization)[pi_allocation_0[i_sb]]); \
 443             NeedBits( &p_adec->bit_stream, 2 ); \
 444             i_need += 2; \
 445             pi_scfsi_0[i_sb] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - 2)); \
 446             DumpBits( &p_adec->bit_stream, 2 ); \
 447             i_dump += 2; \
 448         } \
 449         else \
 450         { \
 451             ppf_sample_0[0][i_sb] = .0; \
 452             ppf_sample_0[1][i_sb] = .0; \
 453             ppf_sample_0[2][i_sb] = .0; \
 454         } \
 455 \
 456         if ( pi_allocation_1[i_sb] ) \
 457         { \
 458             pp_requantization_1[i_sb] = &((p_requantization)[pi_allocation_1[i_sb]]); \
 459             NeedBits( &p_adec->bit_stream, 2 ); \
 460             i_need += 2; \
 461             pi_scfsi_1[i_sb] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - 2)); \
 462             DumpBits( &p_adec->bit_stream, 2 ); \
 463             i_dump += 2; \
 464         } \
 465         else \
 466         { \
 467             ppf_sample_1[0][i_sb] = .0; \
 468             ppf_sample_1[1][i_sb] = .0; \
 469             ppf_sample_1[2][i_sb] = .0; \
 470         } \
 471     } \
 472 \
 473     for ( ; i_sb < i_sblimit; i_sb++ ) \
 474     { \
 475         if ( pi_allocation_0[i_sb] ) \
 476         { \
 477             pp_requantization_0[i_sb] = &((p_requantization)[pi_allocation_0[i_sb]]); \
 478             NeedBits( &p_adec->bit_stream, 4 ); \
 479             i_need += 4; \
 480             pi_scfsi_0[i_sb] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - 2)); \
 481             p_adec->bit_stream.fifo.buffer <<= 2; \
 482             pi_scfsi_1[i_sb] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - 2)); \
 483             p_adec->bit_stream.fifo.buffer <<= 2; \
 484             p_adec->bit_stream.fifo.i_available -= 4; \
 485             i_dump += 4; \
 486         } \
 487         else \
 488         { \
 489             ppf_sample_0[0][i_sb] = .0; \
 490             ppf_sample_0[1][i_sb] = .0; \
 491             ppf_sample_0[2][i_sb] = .0; \
 492             ppf_sample_1[0][i_sb] = .0; \
 493             ppf_sample_1[1][i_sb] = .0; \
 494             ppf_sample_1[2][i_sb] = .0; \
 495         } \
 496     }
 497 /* #define MACRO */
 498
 499     if ( i_bitrate_per_channel_index <= 2 )
 500     {
 501         MACRO( p_requantization_cd )
 502     }
 503     else
 504     {
 505         MACRO( pp_requantization_ab[i_sb] )
 506     }
 507
 508 #define SWITCH( pi_scfsi, pf_scalefactor_0, pf_scalefactor_1, pf_scalefactor_2 ) \
 509     switch ( (pi_scfsi)[i_sb] ) \
 510     { \
 511         case 0: \
 512             NeedBits( &p_adec->bit_stream, (3*6) ); \
 513             i_need += 18; \
 514             (pf_scalefactor_0)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 515             p_adec->bit_stream.fifo.buffer <<= 6; \
 516             (pf_scalefactor_1)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 517             p_adec->bit_stream.fifo.buffer <<= 6; \
 518             (pf_scalefactor_2)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 519             p_adec->bit_stream.fifo.buffer <<= 6; \
 520             p_adec->bit_stream.fifo.i_available -= (3*6); \
 521             i_dump += 18; \
 522             break; \
 523 \
 524         case 1: \
 525             NeedBits( &p_adec->bit_stream, (2*6) ); \
 526             i_need += 12; \
 527             (pf_scalefactor_0)[i_sb] = \
 528                 (pf_scalefactor_1)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 529             p_adec->bit_stream.fifo.buffer <<= 6; \
 530             (pf_scalefactor_2)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 531             p_adec->bit_stream.fifo.buffer <<= 6; \
 532             p_adec->bit_stream.fifo.i_available -= (2*6); \
 533             i_dump += 12; \
 534             break; \
 535 \
 536         case 2: \
 537             NeedBits( &p_adec->bit_stream, (1*6) ); \
 538             i_need += 6; \
 539             (pf_scalefactor_0)[i_sb] = \
 540                 (pf_scalefactor_1)[i_sb] = \
 541                 (pf_scalefactor_2)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 542             DumpBits( &p_adec->bit_stream, (1*6) ); \
 543             i_dump += 6; \
 544             break; \
 545 \
 546         case 3: \
 547             NeedBits( &p_adec->bit_stream, (2*6) ); \
 548             i_need += 12; \
 549             (pf_scalefactor_0)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 550             p_adec->bit_stream.fifo.buffer <<= 6; \
 551             (pf_scalefactor_1)[i_sb] = \
 552                 (pf_scalefactor_2)[i_sb] = pf_scalefactor[p_adec->bit_stream.fifo.buffer >> (32 - 6)]; \
 553             p_adec->bit_stream.fifo.buffer <<= 6; \
 554             p_adec->bit_stream.fifo.i_available -= (2*6); \
 555             i_dump += 12; \
 556             break; \
 557     }
 558 /* #define SWITCH */
 559
 560     for ( i_sb = 0; i_sb < i_bound; i_sb++ )
 561     {
 562         if ( pi_allocation_0[i_sb] )
 563         {
 564             SWITCH( pi_scfsi_0, pf_scalefactor_0_0, pf_scalefactor_0_1, pf_scalefactor_0_2 )
 565         }
 566         if ( pi_allocation_1[i_sb] )
 567         {
 568             SWITCH( pi_scfsi_1, pf_scalefactor_1_0, pf_scalefactor_1_1, pf_scalefactor_1_2 )
 569         }
 570     }
 571     for ( ; i_sb < i_sblimit; i_sb++ )
 572     {
 573         if ( pi_allocation_0[i_sb] )
 574         {
 575             SWITCH( pi_scfsi_0, pf_scalefactor_0_0, pf_scalefactor_0_1, pf_scalefactor_0_2 )
 576             SWITCH( pi_scfsi_1, pf_scalefactor_1_0, pf_scalefactor_1_1, pf_scalefactor_1_2 )
 577         }
 578     }
 579     for ( ; i_sb < 32; i_sb++ )
 580     {
 581         ppf_sample_0[0][i_sb] = .0;
 582         ppf_sample_0[1][i_sb] = .0;
 583         ppf_sample_0[2][i_sb] = .0;
 584         ppf_sample_1[0][i_sb] = .0;
 585         ppf_sample_1[1][i_sb] = .0;
 586         ppf_sample_1[2][i_sb] = .0;
 587     }
 588
 589 #define NEXT_BUF \
 590 /* fprintf(stderr, "%p\n", p_adec->p_aout_fifo->buffer); */ \
 591 /* fprintf(stderr, "l_end_frame == %li, %p\n", l_end_frame, (aout_frame_t *)p_adec->p_aout_fifo->buffer + l_end_frame); */ \
 592     p_s16 = ((aout_frame_t *)p_adec->p_aout_fifo->buffer)[ l_end_frame ]; \
 593 /* fprintf(stderr, "p_s16 == %p\n", p_s16); */ \
 594     l_end_frame += 1; \
 595     l_end_frame &= AOUT_FIFO_SIZE;
 596 /* #define NEXT_BUF */
 597
 598 #define GROUPTEST( pp_requantization, ppf_sample, pf_sf ) \
 599     requantization = *((pp_requantization)[i_sb]); \
 600     if ( requantization.pf_ungroup == NULL ) \
 601     { \
 602         NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 603         i_need += requantization.i_bits_per_codeword; \
 604         (ppf_sample)[0][i_sb] = (f_scalefactor_0 = (pf_sf)[i_sb]) * (requantization.f_slope * \
 605             (p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword)) + requantization.f_offset); \
 606         DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 607         i_dump += requantization.i_bits_per_codeword; \
 608 \
 609         NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 610         i_need += requantization.i_bits_per_codeword; \
 611         (ppf_sample)[1][i_sb] = f_scalefactor_0 * (requantization.f_slope * \
 612             (p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword)) + requantization.f_offset); \
 613         DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 614         i_dump += requantization.i_bits_per_codeword; \
 615 \
 616         NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 617         i_need += requantization.i_bits_per_codeword; \
 618         (ppf_sample)[2][i_sb] = f_scalefactor_0 * (requantization.f_slope * \
 619             (p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword)) + requantization.f_offset); \
 620         DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 621         i_dump += requantization.i_bits_per_codeword; \
 622     } \
 623     else \
 624     { \
 625         NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 626         i_need += requantization.i_bits_per_codeword; \
 627         pf_ungroup = requantization.pf_ungroup + 3 * \
 628             (p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword)); \
 629         DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 630         i_dump += requantization.i_bits_per_codeword; \
 631         (ppf_sample)[0][i_sb] = (f_scalefactor_0 = (pf_sf)[i_sb]) * pf_ungroup[0]; \
 632         (ppf_sample)[1][i_sb] = f_scalefactor_0 * pf_ungroup[1]; \
 633         (ppf_sample)[2][i_sb] = f_scalefactor_0 * pf_ungroup[2]; \
 634     }
 635 /* #define GROUPTEST */
 636
 637 #define READ_SAMPLE_L2S( pf_scalefactor_0, pf_scalefactor_1, i_grlimit ) \
 638     for ( ; i_gr < (i_grlimit); i_gr++ ) \
 639     { \
 640         for ( i_sb = 0; i_sb < i_bound; i_sb++ ) \
 641         { \
 642             if ( pi_allocation_0[i_sb] ) \
 643             { \
 644                 GROUPTEST( pp_requantization_0, ppf_sample_0, (pf_scalefactor_0) ) \
 645             } \
 646             if ( pi_allocation_1[i_sb] ) \
 647             { \
 648                 GROUPTEST( pp_requantization_1, ppf_sample_1, (pf_scalefactor_1) ) \
 649             } \
 650         } \
 651         for ( ; i_sb < i_sblimit; i_sb++ ) \
 652         { \
 653             if ( pi_allocation_0[i_sb] ) \
 654             { \
 655                 requantization = *(pp_requantization_0[i_sb]); \
 656                 if ( requantization.pf_ungroup == NULL ) \
 657                 { \
 658                     NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 659                     i_need += requantization.i_bits_per_codeword; \
 660                     ppf_sample_0[0][i_sb] = (f_scalefactor_0 = (pf_scalefactor_0)[i_sb]) * \
 661                         (requantization.f_slope * (f_dummy = \
 662                         (float)(p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword))) + \
 663                         requantization.f_offset); \
 664                     DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 665                     i_dump += requantization.i_bits_per_codeword; \
 666                     ppf_sample_1[0][i_sb] = (f_scalefactor_1 = (pf_scalefactor_1)[i_sb]) * \
 667                         (requantization.f_slope * f_dummy + requantization.f_offset); \
 668 \
 669                     NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 670                     i_need += requantization.i_bits_per_codeword; \
 671                     ppf_sample_0[1][i_sb] = f_scalefactor_0 * \
 672                         (requantization.f_slope * (f_dummy = \
 673                         (float)(p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword))) + \
 674                         requantization.f_offset); \
 675                     DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 676                     i_dump += requantization.i_bits_per_codeword; \
 677                     ppf_sample_1[1][i_sb] = f_scalefactor_1 * \
 678                         (requantization.f_slope * f_dummy + requantization.f_offset); \
 679 \
 680                     NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 681                     i_need += requantization.i_bits_per_codeword; \
 682                     ppf_sample_0[2][i_sb] = f_scalefactor_0 * \
 683                         (requantization.f_slope * (f_dummy = \
 684                         (float)(p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword))) + \
 685                         requantization.f_offset); \
 686                     DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 687                     i_dump += requantization.i_bits_per_codeword; \
 688                     ppf_sample_1[2][i_sb] = f_scalefactor_1 * \
 689                         (requantization.f_slope * f_dummy + requantization.f_offset); \
 690                 } \
 691                 else \
 692                 { \
 693                     NeedBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 694                     i_need += requantization.i_bits_per_codeword; \
 695                     pf_ungroup = requantization.pf_ungroup + 3 * \
 696                         (p_adec->bit_stream.fifo.buffer >> (32 - requantization.i_bits_per_codeword)); \
 697                     DumpBits( &p_adec->bit_stream, requantization.i_bits_per_codeword ); \
 698                     i_dump += requantization.i_bits_per_codeword; \
 699 \
 700                     ppf_sample_0[0][i_sb] = (f_scalefactor_0 = (pf_scalefactor_0)[i_sb]) * pf_ungroup[0]; \
 701                     ppf_sample_0[1][i_sb] = f_scalefactor_0 * pf_ungroup[1]; \
 702                     ppf_sample_0[2][i_sb] = f_scalefactor_0 * pf_ungroup[2]; \
 703 \
 704                     ppf_sample_1[0][i_sb] = (f_scalefactor_1 = (pf_scalefactor_1)[i_sb]) * pf_ungroup[0]; \
 705                     ppf_sample_1[1][i_sb] = f_scalefactor_1 * pf_ungroup[1]; \
 706                     ppf_sample_1[2][i_sb] = f_scalefactor_1 * pf_ungroup[2]; \
 707                 } \
 708             } \
 709         } \
 710 \
 711 /* fprintf(stderr, "%p", p_s16); */ \
 712         DCT32( ppf_sample_0[0], &p_adec->bank_0 ); \
 713         PCM( &p_adec->bank_0, &p_s16, 2 ); \
 714 /* fprintf(stderr, " %p", p_s16); */ \
 715         p_s16 -= 63; \
 716 /* fprintf(stderr, " %p\n", p_s16); */ \
 717 \
 718 /* fprintf(stderr, "%p", p_s16); */ \
 719         DCT32( ppf_sample_1[0], &p_adec->bank_1 ); \
 720         PCM( &p_adec->bank_1, &p_s16, 2 ); \
 721 /* fprintf(stderr, " %p", p_s16); */ \
 722         p_s16 -= 1; \
 723 /* fprintf(stderr, " %p\n", p_s16); */ \
 724 \
 725 /* fprintf(stderr, "%p", p_s16); */ \
 726         DCT32( ppf_sample_0[1], &p_adec->bank_0 ); \
 727         PCM( &p_adec->bank_0, &p_s16, 2 ); \
 728 /* fprintf(stderr, " %p", p_s16); */ \
 729         p_s16 -= 63; \
 730 /* fprintf(stderr, " %p\n", p_s16); */ \
 731 \
 732 /* fprintf(stderr, "%p", p_s16); */ \
 733         DCT32( ppf_sample_1[1], &p_adec->bank_1 ); \
 734         PCM( &p_adec->bank_1, &p_s16, 2 ); \
 735 /* fprintf(stderr, " %p", p_s16); */ \
 736         p_s16 -= 1; \
 737 /* fprintf(stderr, " %p\n", p_s16); */ \
 738 \
 739 /* fprintf(stderr, "%p", p_s16); */ \
 740         DCT32( ppf_sample_0[2], &p_adec->bank_0 ); \
 741         PCM( &p_adec->bank_0, &p_s16, 2 ); \
 742 /* fprintf(stderr, " %p", p_s16); */ \
 743         p_s16 -= 63; \
 744 /* fprintf(stderr, " %p\n", p_s16); */ \
 745 \
 746 /* fprintf(stderr, "%p", p_s16); */ \
 747         DCT32( ppf_sample_1[2], &p_adec->bank_1 ); \
 748         PCM( &p_adec->bank_1, &p_s16, 2 ); \
 749 /* fprintf(stderr, " %p", p_s16); */ \
 750         p_s16 -= 1; \
 751 /* fprintf(stderr, " %p\n", p_s16); */ \
 752     }
 753 /* #define READ_SAMPLE_L2S */
 754
 755     l_end_frame = p_adec->p_aout_fifo->l_end_frame;
 756     i_gr = 0;
 757
 758     NEXT_BUF
 759     READ_SAMPLE_L2S( pf_scalefactor_0_0, pf_scalefactor_1_0, 2 )
 760
 761     NEXT_BUF
 762     READ_SAMPLE_L2S( pf_scalefactor_0_0, pf_scalefactor_1_0, 4 )
 763
 764     NEXT_BUF
 765     READ_SAMPLE_L2S( pf_scalefactor_0_1, pf_scalefactor_1_1, 6 )
 766
 767     NEXT_BUF
 768     READ_SAMPLE_L2S( pf_scalefactor_0_1, pf_scalefactor_1_1, 8 )
 769
 770     NEXT_BUF
 771     READ_SAMPLE_L2S( pf_scalefactor_0_2, pf_scalefactor_1_2, 10 )
 772
 773     NEXT_BUF
 774     READ_SAMPLE_L2S( pf_scalefactor_0_2, pf_scalefactor_1_2, 12 )
 775
 776 //    fprintf(stderr, "adec debug: layer == %i, padding_bit == %i, sampling_frequency == %i, bitrate_index == %i\n",
 777 //        (i_header & ADEC_HEADER_LAYER_MASK) >> ADEC_HEADER_LAYER_SHIFT,
 778 //        (i_header & ADEC_HEADER_PADDING_BIT_MASK) >> ADEC_HEADER_PADDING_BIT_SHIFT,
 779 //        (i_header & ADEC_HEADER_SAMPLING_FREQUENCY_MASK) >> ADEC_HEADER_SAMPLING_FREQUENCY_SHIFT,
 780 //        (i_header & ADEC_HEADER_BITRATE_INDEX_MASK) >> ADEC_HEADER_BITRATE_INDEX_SHIFT);
 781 //    fprintf(stderr, "adec debug: framesize == %i, i_need == %i, i_dump == %i\n",
 782 //        pi_framesize[ 128 * ((i_header & ADEC_HEADER_LAYER_MASK) >> ADEC_HEADER_LAYER_SHIFT) +
 783 //            64 * ((i_header & ADEC_HEADER_PADDING_BIT_MASK) >> ADEC_HEADER_PADDING_BIT_SHIFT) +
 784 //            16 * ((i_header & ADEC_HEADER_SAMPLING_FREQUENCY_MASK) >> ADEC_HEADER_SAMPLING_FREQUENCY_SHIFT) +
 785 //            1 * ((i_header & ADEC_HEADER_BITRATE_INDEX_MASK) >> ADEC_HEADER_BITRATE_INDEX_SHIFT) ],
 786 //        i_need,
 787 //        i_dump);
 788     p_adec->bit_stream.fifo.buffer = 0;
 789     p_adec->bit_stream.fifo.i_available = 0;
 790     return( 6 );
 791 }
 792
 793 /******************************************************************************
 794  * InitThread : initialize an audio decoder thread
 795  ******************************************************************************
 796  * This function is called from RunThread and performs the second step of the
 797  * initialization. It returns 0 on success.
 798  ******************************************************************************/
 799 static int InitThread( adec_thread_t * p_adec )
 800 {
 801     aout_fifo_t         aout_fifo;
 802
 803     intf_DbgMsg("adec debug: initializing audio decoder thread %p\n", p_adec);
 804
 805     /* Our first job is to initialize the bit stream structure with the
 806      * beginning of the input stream */
 807     pthread_mutex_lock( &p_adec->fifo.data_lock );
 808     while ( DECODER_FIFO_ISEMPTY(p_adec->fifo) )
 809     {
 810         pthread_cond_wait( &p_adec->fifo.data_wait, &p_adec->fifo.data_lock );
 811     }
 812     p_adec->bit_stream.p_ts = DECODER_FIFO_START( p_adec->fifo )->p_first_ts;
 813     p_adec->bit_stream.i_byte = p_adec->bit_stream.p_ts->i_payload_start;
 814     pthread_mutex_unlock( &p_adec->fifo.data_lock );
 815
 816     /* Now we look for an audio frame header in the input stream */
 817     if ( FindHeader(p_adec) )
 818     {
 819         return( -1 );                              /* b_die or b_error is set */
 820     }
 821
 822     /*
 823      * We have the header and all its informations : we must be able to create
 824      * the audio output fifo.
 825      */
 826
 827     /* Is the sound in mono mode or stereo mode ? */
 828     if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_MODE_MASK) == ADEC_HEADER_MODE_MASK )
 829     {
 830         intf_DbgMsg("adec debug: mode == mono\n");
 831         aout_fifo.i_type = AOUT_ADEC_MONO_FIFO;
 832         aout_fifo.b_stereo = 0;
 833     }
 834     else
 835     {
 836         intf_DbgMsg("adec debug: mode == stereo\n");
 837         aout_fifo.i_type = AOUT_ADEC_STEREO_FIFO;
 838         aout_fifo.b_stereo = 1;
 839     }
 840
 841     /* Checking the sampling frequency */
 842     switch ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_SAMPLING_FREQUENCY_MASK) \
 843              >> ADEC_HEADER_SAMPLING_FREQUENCY_SHIFT )
 844     {
 845         case 0:
 846             intf_DbgMsg("adec debug: sampling_frequency == 44100 Hz\n");
 847             aout_fifo.l_rate = 44100;
 848             break;
 849
 850         case 1:
 851             intf_DbgMsg("adec debug: sampling_frequency == 48000 Hz\n");
 852             aout_fifo.l_rate = 48000;
 853             break;
 854
 855         case 2:
 856             intf_DbgMsg("adec debug: sampling_frequency == 32000 Hz\n");
 857             aout_fifo.l_rate = 32000;
 858             break;
 859
 860         case 3:
 861             intf_ErrMsg("adec error: can't create audio output fifo (sampling_frequency == `reserved')\n");
 862             return( -1 );
 863     }
 864
 865     /* Creating the audio output fifo */
 866     if ( (p_adec->p_aout_fifo = aout_CreateFifo(p_adec->p_aout, &aout_fifo)) == NULL )
 867     {
 868         return( -1 );
 869     }
 870
 871     intf_DbgMsg("adec debug: audio decoder thread %p initialized\n", p_adec);
 872     return( 0 );
 873 }
 874
 875 /******************************************************************************
 876  * RunThread : audio decoder thread
 877  ******************************************************************************
 878  * Audio decoder thread. This function does only returns when the thread is
 879  * terminated.
 880  ******************************************************************************/
 881 static void RunThread( adec_thread_t * p_adec )
 882 {
 883 //    static const int    pi_framesize[512] = ADEC_FRAME_SIZE;
 884 //    int                 i_header;
 885 //    int                 i_framesize;
 886 //    int                 i_dummy;
 887     mtime_t             adec_date = 0;
 888
 889     intf_DbgMsg("adec debug: running audio decoder thread (%p) (pid == %i)\n", p_adec, getpid());
 890
 891     /* Initializing the audio decoder thread */
 892     if ( InitThread(p_adec) )
 893     {
 894         p_adec->b_error = 1;
 895     }
 896
 897     /* Audio decoder thread's main loop */
 898     while ( (!p_adec->b_die) && (!p_adec->b_error) )
 899     {
 900         switch ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_LAYER_MASK) >> ADEC_HEADER_LAYER_SHIFT )
 901         {
 902             case 0:
 903                 intf_DbgMsg("adec debug: layer == 0 (reserved)\n");
 904                 p_adec->bit_stream.fifo.buffer = 0;
 905                 p_adec->bit_stream.fifo.i_available = 0;
 906                 break;
 907
 908             case 1:
 909                 p_adec->bit_stream.fifo.buffer = 0;
 910                 p_adec->bit_stream.fifo.i_available = 0;
 911                 break;
 912
 913             case 2:
 914                 if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_MODE_MASK) == ADEC_HEADER_MODE_MASK )
 915                 {
 916                     adec_Layer2_Mono( p_adec );
 917                 }
 918                 else
 919                 {
 920 //                    i_header = p_adec->bit_stream.fifo.buffer;
 921 //                    i_framesize = pi_framesize[ 128*((i_header & ADEC_HEADER_LAYER_MASK) >> ADEC_HEADER_LAYER_SHIFT) +
 922 //                        64*((i_header & ADEC_HEADER_PADDING_BIT_MASK) >> ADEC_HEADER_PADDING_BIT_SHIFT) +
 923 //                        16*((i_header & ADEC_HEADER_SAMPLING_FREQUENCY_MASK) >> ADEC_HEADER_SAMPLING_FREQUENCY_SHIFT) +
 924 //                        1*((i_header & ADEC_HEADER_BITRATE_INDEX_MASK) >> ADEC_HEADER_BITRATE_INDEX_SHIFT) ];
 925 //                    for ( i_dummy = 0; i_dummy < i_framesize; i_dummy++ )
 926 //                    {
 927 //                        GetByte( &p_adec->bit_stream );
 928 //                    }
 929 //                    for ( i_dummy = 0; i_dummy < 512; i_dummy++ )
 930 //                    {
 931 //                        p_adec->bank_0.v1[ i_dummy ] = .0;
 932 //                        p_adec->bank_1.v1[ i_dummy ] = .0;
 933 //                        p_adec->bank_0.v2[ i_dummy ] = .0;
 934 //                        p_adec->bank_1.v2[ i_dummy ] = .0;
 935 //                    }
 936
 937                     pthread_mutex_lock( &p_adec->p_aout_fifo->data_lock );
 938                     while ( (((p_adec->p_aout_fifo->l_end_frame + 6) - p_adec->p_aout_fifo->l_start_frame) & AOUT_FIFO_SIZE) < 6 ) /* !! */
 939                     {
 940                         pthread_cond_wait( &p_adec->p_aout_fifo->data_wait, &p_adec->p_aout_fifo->data_lock );
 941                     }
 942                     pthread_mutex_unlock( &p_adec->p_aout_fifo->data_lock );
 943
 944                     if ( adec_Layer2_Stereo(p_adec) )
 945                     {
 946                         pthread_mutex_lock( &p_adec->p_aout_fifo->data_lock );
 947                         /* Frame 1 */
 948                         p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = adec_date;
 949                         p_adec->p_aout_fifo->l_end_frame += 1;
 950                         p_adec->p_aout_fifo->l_end_frame &= AOUT_FIFO_SIZE;
 951                         /* Frame 2 */
 952                         p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = LAST_MDATE;
 953                         p_adec->p_aout_fifo->l_end_frame += 1;
 954                         p_adec->p_aout_fifo->l_end_frame &= AOUT_FIFO_SIZE;
 955                         /* Frame 3 */
 956                         p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = LAST_MDATE;
 957                         p_adec->p_aout_fifo->l_end_frame += 1;
 958                         p_adec->p_aout_fifo->l_end_frame &= AOUT_FIFO_SIZE;
 959                         /* Frame 4 */
 960                         p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = LAST_MDATE;
 961                         p_adec->p_aout_fifo->l_end_frame += 1;
 962                         p_adec->p_aout_fifo->l_end_frame &= AOUT_FIFO_SIZE;
 963                         /* Frame 5 */
 964                         p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = LAST_MDATE;
 965                         p_adec->p_aout_fifo->l_end_frame += 1;
 966                         p_adec->p_aout_fifo->l_end_frame &= AOUT_FIFO_SIZE;
 967                         /* Frame 6 */
 968                         p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = LAST_MDATE;
 969                         p_adec->p_aout_fifo->l_end_frame += 1;
 970                         p_adec->p_aout_fifo->l_end_frame &= AOUT_FIFO_SIZE;
 971                         pthread_mutex_unlock( &p_adec->p_aout_fifo->data_lock );
 972                         adec_date += 24000; /* !! */
 973                     }
 974                 }
 975                 break;
 976
 977             case 3:
 978                 if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_MODE_MASK) == ADEC_HEADER_MODE_MASK )
 979                 {
 980                     adec_Layer1_Mono( p_adec );
 981                 }
 982                 else
 983                 {
 984                     adec_Layer1_Stereo( p_adec );
 985                 }
 986                 break;
 987
 988             default:
 989                 intf_DbgMsg("adec debug: layer == %i (unknown)\n",
 990                     (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_LAYER_MASK) >> ADEC_HEADER_LAYER_SHIFT);
 991                 p_adec->bit_stream.fifo.buffer = 0;
 992                 p_adec->bit_stream.fifo.i_available = 0;
 993                 break;
 994         }
 995         FindHeader( p_adec );
 996     }
 997
 998     /* If b_error is set, the audio decoder thread enters the error loop */
 999     if ( p_adec->b_error )
1000     {
1001         ErrorThread( p_adec );
1002     }
1003
1004     /* End of the audio decoder thread */
1005     EndThread( p_adec );
1006 }
1007
1008 /******************************************************************************
1009  * ErrorThread : audio decoder's RunThread() error loop
1010  ******************************************************************************
1011  * This function is called when an error occured during thread main's loop. The
1012  * thread can still receive feed, but must be ready to terminate as soon as
1013  * possible.
1014  ******************************************************************************/
1015 static void ErrorThread( adec_thread_t *p_adec )
1016 {
1017     /* We take the lock, because we are going to read/write the start/end
1018      * indexes of the decoder fifo */
1019     pthread_mutex_lock( &p_adec->fifo.data_lock );
1020
1021     /* Wait until a `die' order is sent */
1022     while( !p_adec->b_die )
1023     {
1024         /* Trash all received PES packets */
1025         while( !DECODER_FIFO_ISEMPTY(p_adec->fifo) )
1026         {
1027             input_NetlistFreePES( p_adec->bit_stream.p_input, DECODER_FIFO_START(p_adec->fifo) );
1028             DECODER_FIFO_INCSTART( p_adec->fifo );
1029 #ifdef DEBUG
1030 //            fprintf(stderr, "*");
1031 #endif
1032         }
1033
1034         /* Waiting for the input thread to put new PES packets in the fifo */
1035         pthread_cond_wait( &p_adec->fifo.data_wait, &p_adec->fifo.data_lock );
1036     }
1037
1038     /* We can release the lock before leaving */
1039     pthread_mutex_unlock( &p_adec->fifo.data_lock );
1040 }
1041
1042 /******************************************************************************
1043  * EndThread : audio decoder thread destruction
1044  ******************************************************************************
1045  * This function is called when the thread ends after a sucessfull
1046  * initialization.
1047  ******************************************************************************/
1048 static void EndThread( adec_thread_t *p_adec )
1049 {
1050     intf_DbgMsg("adec debug: destroying audio decoder thread %p\n", p_adec);
1051
1052     /* If the audio output fifo was created, we destroy it */
1053     if ( p_adec->p_aout_fifo != NULL )
1054     {
1055         aout_DestroyFifo( p_adec->p_aout_fifo );
1056     }
1057     /* Destroy descriptor */
1058     free( p_adec );
1059
1060     intf_DbgMsg("adec debug: audio decoder thread %p destroyed\n", p_adec);
1061 }