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