1 /*****************************************************************************
2 * audio_decoder.c: MPEG1 Layer I-II audio decoder thread
4 *****************************************************************************/
9 * - optimiser les NeedBits() et les GetBits() du code là où c'est possible ;
10 * - vlc_cond_signal() / vlc_cond_wait() ;
14 /*****************************************************************************
16 *****************************************************************************/
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" */
30 #include "vlc_thread.h"
31 #include "debug.h" /* "input_netlist.h" */
33 #include "intf_msg.h" /* intf_DbgMsg(), intf_ErrMsg() */
35 #include "input.h" /* pes_packet_t */
36 #include "input_netlist.h" /* input_NetlistFreePES() */
37 #include "decoder_fifo.h" /* DECODER_FIFO_(ISEMPTY|START|INCSTART)() */
39 #include "audio_output.h"
41 #include "audio_constants.h"
42 #include "audio_decoder.h"
43 #include "audio_math.h"
45 /*****************************************************************************
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 );
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 );
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 );
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 )
73 adec_thread_t * p_adec;
75 intf_DbgMsg("adec debug: creating audio decoder thread\n");
77 /* Allocate the memory needed to store the thread's structure */
78 if ( (p_adec = (adec_thread_t *)malloc( sizeof(adec_thread_t) )) == NULL )
80 intf_ErrMsg("adec error: not enough memory for adec_CreateThread() to create the new thread\n");
85 * Initialize the thread properties
91 * Initialize the input properties
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;
106 * Initialize the decoder properties
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;
114 * Initialize the output properties
116 p_adec->p_aout = p_input->p_aout;
117 p_adec->p_aout_fifo = NULL;
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) )
122 intf_ErrMsg("adec error: can't spawn audio decoder thread\n");
127 intf_DbgMsg("adec debug: audio decoder thread (%p) created\n", p_adec);
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
139 *****************************************************************************/
140 void adec_DestroyThread( adec_thread_t * p_adec )
142 intf_DbgMsg("adec debug: requesting termination of audio decoder thread %p\n", p_adec);
144 /* Ask thread to kill itself */
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) );
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 );
157 /* Following functions are local */
159 /*****************************************************************************
160 * FindHeader : parses an input stream until an audio frame header could be
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 )
168 while ( (!p_adec->b_die) && (!p_adec->b_error) )
170 NeedBits( &p_adec->bit_stream, 32 );
171 if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_SYNCWORD_MASK) == ADEC_HEADER_SYNCWORD_MASK )
175 DumpBits( &p_adec->bit_stream, 8 );
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 *****************************************************************************/
190 /*****************************************************************************
192 *****************************************************************************/
193 static __inline__ int adec_Layer1_Mono( adec_thread_t * p_adec )
195 p_adec->bit_stream.fifo.buffer = 0;
196 p_adec->bit_stream.fifo.i_available = 0;
200 /*****************************************************************************
202 *****************************************************************************/
203 static __inline__ int adec_Layer1_Stereo( adec_thread_t * p_adec )
205 p_adec->bit_stream.fifo.buffer = 0;
206 p_adec->bit_stream.fifo.i_available = 0;
210 /*****************************************************************************
212 *****************************************************************************/
213 static __inline__ int adec_Layer2_Mono( adec_thread_t * p_adec )
215 p_adec->bit_stream.fifo.buffer = 0;
216 p_adec->bit_stream.fifo.i_available = 0;
220 /*****************************************************************************
222 *****************************************************************************/
223 static __inline__ int adec_Layer2_Stereo( adec_thread_t * p_adec )
225 typedef struct requantization_s
227 byte_t i_bits_per_codeword;
228 const float * pf_ungroup;
233 static const float pf_scalefactor[64] = ADEC_SCALE_FACTOR;
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 */
239 float f_scalefactor_0, f_scalefactor_1;
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;
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;
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;
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;
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];
274 int i_need = 0, i_dump = 0;
276 static const int pi_framesize[512] = ADEC_FRAME_SIZE;
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 )
291 GetByte( &p_adec->bit_stream );
292 GetByte( &p_adec->bit_stream );
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 )
303 return( 0 ); /* the frame is invalid */
305 /* Find out the number of bits allocated */
306 pi_nbal = ppi_nbal[ (i_bitrate_per_channel_index <= 2) ? 0 : 1 ];
308 /* Find out the `bound' subband (see ISO/IEC 11172-3 2.4.2.3) */
311 i_bound = (int)(((i_header & ADEC_HEADER_MODE_EXTENSION_MASK) >> (ADEC_HEADER_MODE_EXTENSION_SHIFT - 2)) + 4);
312 if ( i_bound > i_sblimit )
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++ )
325 i_2nbal = 2 * (i_nbal = (int)pi_nbal[ i_sb ]);
326 NeedBits( &p_adec->bit_stream, 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;
335 for ( ; i_sb < i_sblimit; i_sb++ )
337 i_nbal = (int)pi_nbal[ i_sb ];
338 NeedBits( &p_adec->bit_stream, 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 );
345 #define MACRO( p_requantization ) \
346 for ( i_sb = 0; i_sb < i_bound; i_sb++ ) \
348 if ( pi_allocation_0[i_sb] ) \
350 pp_requantization_0[i_sb] = &((p_requantization)[pi_allocation_0[i_sb]]); \
351 NeedBits( &p_adec->bit_stream, 2 ); \
353 pi_scfsi_0[i_sb] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - 2)); \
354 DumpBits( &p_adec->bit_stream, 2 ); \
359 ppf_sample_0[0][i_sb] = .0; \
360 ppf_sample_0[1][i_sb] = .0; \
361 ppf_sample_0[2][i_sb] = .0; \
364 if ( pi_allocation_1[i_sb] ) \
366 pp_requantization_1[i_sb] = &((p_requantization)[pi_allocation_1[i_sb]]); \
367 NeedBits( &p_adec->bit_stream, 2 ); \
369 pi_scfsi_1[i_sb] = (int)(p_adec->bit_stream.fifo.buffer >> (32 - 2)); \
370 DumpBits( &p_adec->bit_stream, 2 ); \
375 ppf_sample_1[0][i_sb] = .0; \
376 ppf_sample_1[1][i_sb] = .0; \
377 ppf_sample_1[2][i_sb] = .0; \
381 for ( ; i_sb < i_sblimit; i_sb++ ) \
383 if ( pi_allocation_0[i_sb] ) \
385 pp_requantization_0[i_sb] = &((p_requantization)[pi_allocation_0[i_sb]]); \
386 NeedBits( &p_adec->bit_stream, 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; \
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; \
407 if ( i_bitrate_per_channel_index <= 2 )
409 MACRO( p_requantization_cd )
413 MACRO( pp_requantization_ab[i_sb] )
416 #define SWITCH( pi_scfsi, pf_scalefactor_0, pf_scalefactor_1, pf_scalefactor_2 )\
417 switch ( (pi_scfsi)[i_sb] ) \
420 NeedBits( &p_adec->bit_stream, (3*6) ); \
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); \
433 NeedBits( &p_adec->bit_stream, (2*6) ); \
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); \
445 NeedBits( &p_adec->bit_stream, (1*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) ); \
455 NeedBits( &p_adec->bit_stream, (2*6) ); \
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); \
468 for ( i_sb = 0; i_sb < i_bound; i_sb++ )
470 if ( pi_allocation_0[i_sb] )
472 SWITCH( pi_scfsi_0, pf_scalefactor_0_0, pf_scalefactor_0_1, pf_scalefactor_0_2 )
474 if ( pi_allocation_1[i_sb] )
476 SWITCH( pi_scfsi_1, pf_scalefactor_1_0, pf_scalefactor_1_1, pf_scalefactor_1_2 )
479 for ( ; i_sb < i_sblimit; i_sb++ )
481 if ( pi_allocation_0[i_sb] )
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 )
487 for ( ; i_sb < 32; i_sb++ )
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;
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); */ \
503 l_end_frame &= AOUT_FIFO_SIZE;
504 /* #define NEXT_BUF */
506 #define GROUPTEST( pp_requantization, ppf_sample, pf_sf ) \
507 requantization = *((pp_requantization)[i_sb]); \
508 if ( requantization.pf_ungroup == NULL ) \
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; \
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; \
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; \
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]; \
543 /* #define GROUPTEST */
545 #define READ_SAMPLE_L2S( pf_scalefactor_0, pf_scalefactor_1, i_grlimit ) \
546 for ( ; i_gr < (i_grlimit); i_gr++ ) \
548 for ( i_sb = 0; i_sb < i_bound; i_sb++ ) \
550 if ( pi_allocation_0[i_sb] ) \
552 GROUPTEST( pp_requantization_0, ppf_sample_0, (pf_scalefactor_0) ) \
554 if ( pi_allocation_1[i_sb] ) \
556 GROUPTEST( pp_requantization_1, ppf_sample_1, (pf_scalefactor_1) ) \
559 for ( ; i_sb < i_sblimit; i_sb++ ) \
561 if ( pi_allocation_0[i_sb] ) \
563 requantization = *(pp_requantization_0[i_sb]); \
564 if ( requantization.pf_ungroup == NULL ) \
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); \
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); \
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); \
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; \
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]; \
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]; \
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); */ \
624 /* fprintf(stderr, " %p\n", p_s16); */ \
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); */ \
631 /* fprintf(stderr, " %p\n", p_s16); */ \
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); */ \
638 /* fprintf(stderr, " %p\n", p_s16); */ \
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); */ \
645 /* fprintf(stderr, " %p\n", p_s16); */ \
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); */ \
652 /* fprintf(stderr, " %p\n", p_s16); */ \
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); */ \
659 /* fprintf(stderr, " %p\n", p_s16); */ \
661 /* #define READ_SAMPLE_L2S */
663 l_end_frame = p_adec->p_aout_fifo->l_end_frame;
667 READ_SAMPLE_L2S( pf_scalefactor_0_0, pf_scalefactor_1_0, 2 )
670 READ_SAMPLE_L2S( pf_scalefactor_0_0, pf_scalefactor_1_0, 4 )
673 READ_SAMPLE_L2S( pf_scalefactor_0_1, pf_scalefactor_1_1, 6 )
676 READ_SAMPLE_L2S( pf_scalefactor_0_1, pf_scalefactor_1_1, 8 )
679 READ_SAMPLE_L2S( pf_scalefactor_0_2, pf_scalefactor_1_2, 10 )
682 READ_SAMPLE_L2S( pf_scalefactor_0_2, pf_scalefactor_1_2, 12 )
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) ],
698 p_adec->bit_stream.fifo.buffer = 0;
699 p_adec->bit_stream.fifo.i_available = 0;
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 )
711 aout_fifo_t aout_fifo;
713 intf_DbgMsg("adec debug: initializing audio decoder thread %p\n", p_adec);
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) )
722 vlc_mutex_unlock( &p_adec->fifo.data_lock );
725 vlc_cond_wait( &p_adec->fifo.data_wait, &p_adec->fifo.data_lock );
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 );
732 /* Now we look for an audio frame header in the input stream */
733 if ( FindHeader(p_adec) )
735 return( -1 ); /* b_die or b_error is set */
739 * We have the header and all its informations : we must be able to create
740 * the audio output fifo.
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 )
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;
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;
759 /* Checking the sampling frequency */
760 switch ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_SAMPLING_FREQUENCY_MASK) \
761 >> ADEC_HEADER_SAMPLING_FREQUENCY_SHIFT )
764 intf_DbgMsg("adec debug: sampling_frequency == 44100 Hz\n");
765 aout_fifo.l_rate = 44100;
769 intf_DbgMsg("adec debug: sampling_frequency == 48000 Hz\n");
770 aout_fifo.l_rate = 48000;
774 intf_DbgMsg("adec debug: sampling_frequency == 32000 Hz\n");
775 aout_fifo.l_rate = 32000;
779 intf_ErrMsg("adec error: can't create audio output fifo (sampling_frequency == `reserved')\n");
783 aout_fifo.l_frame_size = ADEC_FRAME_SIZE;
785 /* Creating the audio output fifo */
786 if ( (p_adec->p_aout_fifo = aout_CreateFifo(p_adec->p_aout, &aout_fifo)) == NULL )
791 intf_DbgMsg("adec debug: audio decoder thread %p initialized\n", p_adec);
795 /*****************************************************************************
796 * RunThread : audio decoder thread
797 *****************************************************************************
798 * Audio decoder thread. This function does only returns when the thread is
800 *****************************************************************************/
801 static void RunThread( adec_thread_t * p_adec )
804 static const int pi_framesize[512] = ADEC_FRAME_SIZE;
810 intf_DbgMsg("adec debug: running audio decoder thread (%p) (pid == %i)\n", p_adec, getpid());
812 msleep( INPUT_PTS_DELAY );
814 /* Initializing the audio decoder thread */
815 if ( InitThread(p_adec) )
820 /* Audio decoder thread's main loop */
821 while ( (!p_adec->b_die) && (!p_adec->b_error) )
823 switch ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_LAYER_MASK) >> ADEC_HEADER_LAYER_SHIFT )
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;
834 p_adec->bit_stream.fifo.buffer = 0;
835 p_adec->bit_stream.fifo.i_available = 0;
840 if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_MODE_MASK) == ADEC_HEADER_MODE_MASK )
842 adec_Layer2_Mono( p_adec );
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?? */
856 vlc_cond_wait( &p_adec->p_aout_fifo->data_wait, &p_adec->p_aout_fifo->data_lock );
858 if ( DECODER_FIFO_START(p_adec->fifo)->b_has_pts )
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;
865 p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = LAST_MDATE;
867 vlc_mutex_unlock( &p_adec->p_aout_fifo->data_lock );
869 /* Decoding the frames */
870 if ( adec_Layer2_Stereo(p_adec) )
872 vlc_mutex_lock( &p_adec->p_aout_fifo->data_lock );
875 p_adec->p_aout_fifo->l_end_frame = (p_adec->p_aout_fifo->l_end_frame + 1) & AOUT_FIFO_SIZE;
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;
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;
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;
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;
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;
897 vlc_cond_signal( &p_adec->p_aout_fifo->data_wait );
899 vlc_mutex_unlock( &p_adec->p_aout_fifo->data_lock );
906 if ( (p_adec->bit_stream.fifo.buffer & ADEC_HEADER_MODE_MASK) == ADEC_HEADER_MODE_MASK )
908 adec_Layer1_Mono( p_adec );
912 adec_Layer1_Stereo( p_adec );
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;
923 FindHeader( p_adec );
926 /* If b_error is set, the audio decoder thread enters the error loop */
927 if ( p_adec->b_error )
929 ErrorThread( p_adec );
932 /* End of the audio decoder thread */
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
942 *****************************************************************************/
943 static void ErrorThread( adec_thread_t *p_adec )
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 );
949 /* Wait until a `die' order is sent */
950 while( !p_adec->b_die )
952 /* Trash all received PES packets */
953 while( !DECODER_FIFO_ISEMPTY(p_adec->fifo) )
955 input_NetlistFreePES( p_adec->bit_stream.p_input, DECODER_FIFO_START(p_adec->fifo) );
956 DECODER_FIFO_INCSTART( p_adec->fifo );
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 );
963 /* We can release the lock before leaving */
964 vlc_mutex_unlock( &p_adec->fifo.data_lock );
967 /*****************************************************************************
968 * EndThread : audio decoder thread destruction
969 *****************************************************************************
970 * This function is called when the thread ends after a sucessfull
972 *****************************************************************************/
973 static void EndThread( adec_thread_t *p_adec )
975 intf_DbgMsg("adec debug: destroying audio decoder thread %p\n", p_adec);
977 /* If the audio output fifo was created, we destroy it */
978 if ( p_adec->p_aout_fifo != NULL )
980 aout_DestroyFifo( p_adec->p_aout_fifo );
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) );
987 /* Destroy descriptor */
990 intf_DbgMsg("adec debug: audio decoder thread %p destroyed\n", p_adec);