/* parse allocation */
- for (sb = 0; sb < 32; sb += 2) {
+ for (sb = 0; sb < 32; sb += 2)
+ {
u8 tmp;
- tmp = GetByte (&p_adec->bit_stream);
- if ((tmp >> 4) > 14)
+ tmp = GetByte ( &p_adec->bit_stream );
+ if ( (tmp >> 4) > 14 )
return 1;
allocation[sb] = adec_layer1_allocation_table [tmp >> 4];
if ((tmp & 15) > 14)
/* parse scalefactors */
- for (sb = 0; sb < 32; sb++) {
- if (allocation[sb]) {
- int index;
- float scalefactor;
-
- NeedBits (&p_adec->bit_stream, 6);
- index = p_adec->bit_stream.buffer >> (32 - 6);
- DumpBits (&p_adec->bit_stream, 6);
-
- scalefactor = adec_scalefactor_table[index];
-
- slope[sb] = adec_slope_table[allocation[sb]-2] * scalefactor;
- offset[sb] = adec_offset_table[allocation[sb]-2] * scalefactor;
- }
+ for (sb = 0; sb < 32; sb++)
+ {
+ if ( allocation[sb] )
+ {
+ int index;
+ float scalefactor;
+
+ NeedBits ( &p_adec->bit_stream, 6 );
+ index = p_adec->bit_stream.buffer >> (32 - 6);
+ DumpBits ( &p_adec->bit_stream, 6 );
+
+ scalefactor = adec_scalefactor_table[index];
+
+ slope[sb] = adec_slope_table[allocation[sb]-2] * scalefactor;
+ offset[sb] = adec_offset_table[allocation[sb]-2] * scalefactor;
+ }
}
/* parse samples */
- for (s = 0; s < 12; s++) {
- s16 * XXX_buf;
-
- for (sb = 0; sb < 32; sb++) {
- if (!allocation[sb]) {
- sample[sb] = 0;
- } else {
- int code;
-
- NeedBits (&p_adec->bit_stream, allocation[sb]);
- code = p_adec->bit_stream.buffer >> (32 - allocation[sb]);
- DumpBits (&p_adec->bit_stream, allocation[sb]);
-
- sample[sb] = slope[sb] * code + offset[sb];
- }
- }
+ for (s = 0; s < 12; s++)
+ {
+ s16 * XXX_buf;
- DCT32 (sample, &p_adec->bank_0);
- XXX_buf = buffer;
- PCM (&p_adec->bank_0, &XXX_buf, 1);
- buffer += 32;
+ for (sb = 0; sb < 32; sb++)
+ {
+ if (!allocation[sb])
+ {
+ sample[sb] = 0;
+ }
+ else
+ {
+ int code;
+
+ NeedBits (&p_adec->bit_stream, allocation[sb]);
+ code = p_adec->bit_stream.buffer >> (32 - allocation[sb]);
+ DumpBits (&p_adec->bit_stream, allocation[sb]);
+
+ sample[sb] = slope[sb] * code + offset[sb];
+ }
+ }
+
+ DCT32 (sample, &p_adec->bank_0);
+ XXX_buf = buffer;
+ PCM (&p_adec->bank_0, &XXX_buf, 1);
+ buffer += 32;
}
return 0;
/* calculate bound */
bound = 32;
- if ((p_adec->header & 0xc0) == 0x40) { /* intensity stereo */
- int index;
- index = (p_adec->header >> 4) & 3;
- bound = adec_bound_table[index];
+ if ( (p_adec->header & 0xc0) == 0x40)
+ { /* intensity stereo */
+ int index;
+ index = (p_adec->header >> 4) & 3;
+ bound = adec_bound_table[index];
}
/* parse allocation */
- for (sb = 0; sb < bound; sb++) {
- u8 tmp;
- tmp = GetByte (&p_adec->bit_stream);
- if ((tmp >> 4) > 14)
- return 1;
- allocation_0[sb] = adec_layer1_allocation_table [tmp >> 4];
- if ((tmp & 15) > 14)
- return 1;
- allocation_1[sb] = adec_layer1_allocation_table [tmp & 15];
+ for (sb = 0; sb < bound; sb++)
+ {
+ u8 tmp;
+ tmp = GetByte (&p_adec->bit_stream);
+ if ((tmp >> 4) > 14)
+ return 1;
+ allocation_0[sb] = adec_layer1_allocation_table [tmp >> 4];
+ if ((tmp & 15) > 14)
+ return 1;
+ allocation_1[sb] = adec_layer1_allocation_table [tmp & 15];
}
- for (; sb < 32; sb += 2) {
- u8 tmp;
- tmp = GetByte (&p_adec->bit_stream);
- if ((tmp >> 4) > 14)
- return 1;
- allocation_0[sb] = allocation_1[sb] = adec_layer1_allocation_table [tmp >> 4];
- if ((tmp & 15) > 14)
- return 1;
- allocation_0[sb+1] = allocation_1[sb+1] = adec_layer1_allocation_table [tmp & 15];
+ for (; sb < 32; sb += 2)
+ {
+ u8 tmp;
+ tmp = GetByte (&p_adec->bit_stream);
+ if ((tmp >> 4) > 14)
+ return 1;
+ allocation_0[sb] = allocation_1[sb] = adec_layer1_allocation_table [tmp >> 4];
+ if ((tmp & 15) > 14)
+ return 1;
+ allocation_0[sb+1] = allocation_1[sb+1] = adec_layer1_allocation_table [tmp & 15];
}
/* parse scalefactors */
- for (sb = 0; sb < 32; sb++) {
- if (allocation_0[sb]) {
- int index;
- float scalefactor;
+ for ( sb = 0; sb < 32; sb++ )
+ {
+ if ( allocation_0[sb] )
+ {
+ int index;
+ float scalefactor;
- NeedBits (&p_adec->bit_stream, 6);
- index = p_adec->bit_stream.buffer >> (32 - 6);
- DumpBits (&p_adec->bit_stream, 6);
+ NeedBits (&p_adec->bit_stream, 6);
+ index = p_adec->bit_stream.buffer >> (32 - 6);
+ DumpBits (&p_adec->bit_stream, 6);
- scalefactor = adec_scalefactor_table[index];
+ scalefactor = adec_scalefactor_table[index];
- slope_0[sb] = adec_slope_table[allocation_0[sb]-2] * scalefactor;
- offset_0[sb] = adec_offset_table[allocation_0[sb]-2] * scalefactor;
- }
- if (allocation_1[sb]) {
- int index;
- float scalefactor;
+ slope_0[sb] = adec_slope_table[allocation_0[sb]-2] * scalefactor;
+ offset_0[sb] = adec_offset_table[allocation_0[sb]-2] * scalefactor;
+ }
+ if (allocation_1[sb])
+ {
+ int index;
+ float scalefactor;
- NeedBits (&p_adec->bit_stream, 6);
- index = p_adec->bit_stream.buffer >> (32 - 6);
- DumpBits (&p_adec->bit_stream, 6);
+ NeedBits (&p_adec->bit_stream, 6);
+ index = p_adec->bit_stream.buffer >> (32 - 6);
+ DumpBits (&p_adec->bit_stream, 6);
- scalefactor = adec_scalefactor_table[index];
+ scalefactor = adec_scalefactor_table[index];
- slope_1[sb] = adec_slope_table[allocation_1[sb]-2] * scalefactor;
- offset_1[sb] = adec_offset_table[allocation_1[sb]-2] * scalefactor;
- }
+ slope_1[sb] = adec_slope_table[allocation_1[sb]-2] * scalefactor;
+ offset_1[sb] = adec_offset_table[allocation_1[sb]-2] * scalefactor;
+ }
}
/* parse samples */
- for (s = 0; s < 12; s++) {
- s16 * XXX_buf;
-
- for (sb = 0; sb < bound; sb++) {
- if (!allocation_0[sb])
- sample_0[sb] = 0;
- else {
- int code;
-
- NeedBits (&p_adec->bit_stream, allocation_0[sb]);
- code = p_adec->bit_stream.buffer >> (32 - allocation_0[sb]);
- DumpBits (&p_adec->bit_stream, allocation_0[sb]);
-
- sample_0[sb] = slope_0[sb] * code + offset_0[sb];
- }
- if (!allocation_1[sb])
- sample_1[sb] = 0;
- else {
- int code;
-
- NeedBits (&p_adec->bit_stream, allocation_1[sb]);
- code = p_adec->bit_stream.buffer >> (32 - allocation_1[sb]);
- DumpBits (&p_adec->bit_stream, allocation_1[sb]);
-
- sample_1[sb] = slope_1[sb] * code + offset_1[sb];
- }
- }
- for (; sb < 32; sb++) {
- if (!allocation_0[sb]) {
- sample_0[sb] = 0;
- sample_1[sb] = 0;
- } else {
- int sample;
-
- NeedBits (&p_adec->bit_stream, allocation_0[sb]);
- sample = p_adec->bit_stream.buffer >> (32 - allocation_0[sb]);
- DumpBits (&p_adec->bit_stream, allocation_0[sb]);
-
- sample_0[sb] = slope_0[sb] * sample + offset_0[sb];
- sample_1[sb] = slope_1[sb] * sample + offset_1[sb];
- }
- }
-
- DCT32 (sample_0, &p_adec->bank_0);
- XXX_buf = buffer;
- PCM (&p_adec->bank_0, &XXX_buf, 2);
- DCT32 (sample_1, &p_adec->bank_1);
- XXX_buf = buffer+1;
- PCM (&p_adec->bank_1, &XXX_buf, 2);
- buffer += 64;
+ for (s = 0; s < 12; s++)
+ {
+ s16 * XXX_buf;
+
+ for (sb = 0; sb < bound; sb++)
+ {
+ if (!allocation_0[sb])
+ sample_0[sb] = 0;
+ else
+ {
+ int code;
+
+ NeedBits (&p_adec->bit_stream, allocation_0[sb]);
+ code = p_adec->bit_stream.buffer >> (32 - allocation_0[sb]);
+ DumpBits (&p_adec->bit_stream, allocation_0[sb]);
+
+ sample_0[sb] = slope_0[sb] * code + offset_0[sb];
+ }
+ if ( !allocation_1[sb] )
+ sample_1[sb] = 0;
+ else
+ {
+ int code;
+
+ NeedBits (&p_adec->bit_stream, allocation_1[sb]);
+ code = p_adec->bit_stream.buffer >> (32 - allocation_1[sb]);
+ DumpBits (&p_adec->bit_stream, allocation_1[sb]);
+
+ sample_1[sb] = slope_1[sb] * code + offset_1[sb];
+ }
+ }
+ for (; sb < 32; sb++)
+ {
+ if (!allocation_0[sb])
+ {
+ sample_0[sb] = 0;
+ sample_1[sb] = 0;
+ }
+ else
+ {
+ int sample;
+
+ NeedBits (&p_adec->bit_stream, allocation_0[sb]);
+ sample = p_adec->bit_stream.buffer >> (32 - allocation_0[sb]);
+ DumpBits (&p_adec->bit_stream, allocation_0[sb]);
+
+ sample_0[sb] = slope_0[sb] * sample + offset_0[sb];
+ sample_1[sb] = slope_1[sb] * sample + offset_1[sb];
+ }
+ }
+
+ DCT32 (sample_0, &p_adec->bank_0);
+ XXX_buf = buffer;
+ PCM (&p_adec->bank_0, &XXX_buf, 2);
+ DCT32 (sample_1, &p_adec->bank_1);
+ XXX_buf = buffer+1;
+ PCM (&p_adec->bank_1, &XXX_buf, 2);
+ buffer += 64;
}
return 0;
static int adec_layer2_mono (audiodec_t * p_adec, s16 * buffer)
{
- return 1;
+ static u8 freq_table[15] = {3, 0, 0, 0, 1, 0, 1, 2, 2, 2, 3, 3, 3, 3, 3};
+ static float L3_table[3] = {-2/3.0, 0, 2/3.0};
+ static float L5_table[5] = {-4/5.0, -2/5.0, 0, 2/5.0, 4/5.0};
+ static float L9_table[9] = {-8/9.0, -6/9.0, -4/9.0, -2/9.0, 0,
+ 2/9.0, 4/9.0, 6/9.0, 8/9.0};
+
+ s8 allocation[32];
+ u8 scfsi[32];
+ float slope[3][32];
+ float offset[3][32];
+ float sample[3][32];
+ alloc_table_t * alloc_table;
+
+ int sblimit;
+ int bound;
+ int sb;
+ int gr0, gr1;
+ int s;
+
+
+ /* get the right allocation table */
+
+ adec_layer2_get_table (p_adec->header, freq_table, &alloc_table, &sblimit);
+
+ /* bound -- not required for mono ! */
+
+ bound = sblimit;
+
+ /* parse allocation table */
+
+ for ( sb=0 ; sb < sblimit ; sb++ )
+ {
+ int index;
+
+ NeedBits (&p_adec->bit_stream, alloc_table->nbal[sb]);
+ index = p_adec->bit_stream.buffer >> (32 - alloc_table->nbal[sb]);
+ DumpBits (&p_adec->bit_stream, alloc_table->nbal[sb]);
+
+ allocation[sb] = alloc_table->alloc[sb][index];
+ }
+
+ /* parse scfsi */
+
+ for ( sb = 0 ; sb < sblimit ; sb++ )
+ {
+ if (allocation[sb])
+ {
+ NeedBits (&p_adec->bit_stream, 2);
+ scfsi[sb] = p_adec->bit_stream.buffer >> (32 - 2);
+ DumpBits (&p_adec->bit_stream, 2);
+ }
+ }
+
+ /* Parse scalefactors */
+
+ for ( sb = 0 ; sb < sblimit ; sb++ )
+ {
+ if ( allocation[sb] )
+ {
+ int index_0, index_1, index_2;
+ float r_slope,r_offset;
+ switch ( scfsi[sb] )
+ {
+ case 0 :
+ NeedBits (&p_adec->bit_stream, 18);
+ index_0 = p_adec->bit_stream.buffer >> (32 - 6);
+ index_1 = (p_adec->bit_stream.buffer >> (32 - 12)) & 63;
+ index_2 = (p_adec->bit_stream.buffer >> (32 - 18)) & 63;
+ DumpBits (&p_adec->bit_stream, 18);
+
+ if (allocation[sb] < 0)
+ {
+ slope[0][sb] = adec_scalefactor_table[index_0];
+ slope[1][sb] = adec_scalefactor_table[index_1];
+ slope[2][sb] = adec_scalefactor_table[index_2];
+ }
+ else
+ {
+ float scalefactor;
+
+ r_slope = adec_slope_table[allocation[sb]-2];
+ r_offset = adec_offset_table[allocation[sb]-2];
+
+ scalefactor = adec_scalefactor_table[index_0];
+ slope[0][sb] = r_slope * scalefactor;
+ offset[0][sb] = r_offset * scalefactor;
+
+ scalefactor = adec_scalefactor_table[index_1];
+ slope[1][sb] = r_slope * scalefactor;
+ offset[1][sb] = r_offset * scalefactor;
+
+ scalefactor = adec_scalefactor_table[index_2];
+ slope[2][sb] = r_slope * scalefactor;
+ offset[2][sb] = r_offset * scalefactor;
+ }
+ break;
+
+ case 1 :
+ NeedBits ( &p_adec->bit_stream, 12 );
+ index_0 = p_adec->bit_stream.buffer >> (32-6);
+ index_2 = ( p_adec->bit_stream.buffer >> (32-12) ) & 63;
+
+ if ( allocation[sb] < 0 )
+ {
+ slope[0][sb] = slope[1][sb] =
+ adec_scalefactor_table[index_0];
+ slope[2][sb] = adec_scalefactor_table[index_2];
+ }
+ else
+ {
+ float scalefactor;
+
+ r_slope = adec_slope_table[allocation[sb]-2];
+ r_offset = adec_offset_table[allocation[sb]-2];
+
+ scalefactor = adec_scalefactor_table[index_0];
+ slope[0][sb] = slope[1][sb] = r_slope * scalefactor;
+ offset[0][sb] = offset[1][sb] = r_offset * scalefactor;
+
+ scalefactor = adec_scalefactor_table[index_2];
+ slope[2][sb] = r_slope * scalefactor;
+ offset[2][sb] = r_offset * scalefactor;
+ }
+ break;
+
+ case 2:
+ NeedBits ( &p_adec->bit_stream, 6);
+ index_0 = p_adec->bit_stream.buffer >> (32 - 6);
+ if ( allocation[sb] < 0 )
+ {
+ slope[0][sb] = slope[1][sb] = slope[2][sb] =
+ adec_scalefactor_table[index_0];
+ }
+ else
+ {
+ float scalefactor;
+
+ r_slope = adec_slope_table[allocation[sb]-2];
+ r_offset = adec_offset_table[allocation[sb]-2];
+
+ scalefactor = adec_scalefactor_table[index_0];
+ slope[0][sb] = slope[1][sb] = slope[2][sb] =
+ r_slope * scalefactor;
+ offset[0][sb] = offset[1][sb] = offset[2][sb] =
+ r_offset * scalefactor;
+ }
+ break;
+
+ case 3 :
+ NeedBits ( &p_adec->bit_stream, 12 );
+ index_0 = p_adec->bit_stream.buffer >> (32-6);
+ index_2 = ( p_adec->bit_stream.buffer >> (32-12) ) & 63;
+
+ if ( allocation[sb] < 0 )
+ {
+ slope[0][sb] = adec_scalefactor_table[index_0];
+ slope[2][sb] = slope[1][sb] =
+ adec_scalefactor_table[index_2];
+ }
+ else
+ {
+ float scalefactor;
+
+ r_slope = adec_slope_table[allocation[sb]-2];
+ r_offset = adec_offset_table[allocation[sb]-2];
+
+ scalefactor = adec_scalefactor_table[index_0];
+ slope[0][sb] = r_slope * scalefactor;
+ offset[0][sb] = r_offset * scalefactor;
+
+ scalefactor = adec_scalefactor_table[index_2];
+ slope[2][sb] = slope[1][sb] = r_slope * scalefactor;
+ offset[2][sb] = offset[1][sb] = r_offset * scalefactor;
+ }
+ break;
+ }
+ }
+ }
+
+
+ /* parse samples */
+
+ for (gr0 = 0; gr0 < 3; gr0++)
+ for (gr1 = 0; gr1 < 4; gr1++)
+ {
+ s16 * XXX_buf;
+
+ for (sb = 0; sb < bound; sb++)
+ {
+ int code;
+
+ switch (allocation[sb])
+ {
+ case 0:
+ sample[0][sb] = sample[1][sb] = sample[2][sb] = 0;
+ break;
+ case L3:
+ NeedBits (&p_adec->bit_stream, 5);
+ code = p_adec->bit_stream.buffer >> (32 - 5);
+ DumpBits (&p_adec->bit_stream, 5);
+
+ sample[0][sb] = slope[gr0][sb] * L3_table[code % 3];
+ code /= 3;
+ sample[1][sb] = slope[gr0][sb] * L3_table[code % 3];
+ code /= 3;
+ sample[2][sb] = slope[gr0][sb] * L3_table[code];
+
+ break;
+ case L5:
+ NeedBits (&p_adec->bit_stream, 7);
+ code = p_adec->bit_stream.buffer >> (32 - 7);
+ DumpBits (&p_adec->bit_stream, 7);
+
+ sample[0][sb] = slope[gr0][sb] * L5_table[code % 5];
+ code /= 5;
+ sample[1][sb] = slope[gr0][sb] * L5_table[code % 5];
+ code /= 5;
+ sample[2][sb] = slope[gr0][sb] * L5_table[code];
+
+ break;
+ case L9:
+ NeedBits (&p_adec->bit_stream, 10);
+ code = p_adec->bit_stream.buffer >> (32 - 10);
+ DumpBits (&p_adec->bit_stream, 10);
+
+ sample[0][sb] = slope[gr0][sb] * L9_table[code % 9];
+ code /= 9;
+ sample[1][sb] = slope[gr0][sb] * L9_table[code % 9];
+ code /= 9;
+ sample[2][sb] = slope[gr0][sb] * L9_table[code];
+
+ break;
+ default:
+ for (s = 0; s < 3; s++) {
+ NeedBits (&p_adec->bit_stream, allocation[sb]);
+ code = (p_adec->bit_stream.buffer >>
+ (32 - allocation[sb]));
+ DumpBits (&p_adec->bit_stream, allocation[sb]);
+
+ sample[s][sb] =
+ slope[gr0][sb] * code + offset[gr0][sb];
+ }
+ }
+ }
+
+
+ for (; sb < sblimit; sb++) {
+ int code;
+
+ switch (allocation[sb]) {
+ case 0:
+ sample[0][sb] = sample[1][sb] = sample[2][sb] = 0;
+ break;
+ case L3:
+ NeedBits (&p_adec->bit_stream, 5);
+ code = p_adec->bit_stream.buffer >> (32 - 5);
+ DumpBits (&p_adec->bit_stream, 5);
+
+ sample[0][sb] = slope[gr0][sb] * L3_table[code % 3];
+ code /= 3;
+ sample[1][sb] = slope[gr0][sb] * L3_table[code % 3];
+ code /= 3;
+ sample[2][sb] = slope[gr0][sb] * L3_table[code];
+
+ break;
+ case L5:
+ NeedBits (&p_adec->bit_stream, 7);
+ code = p_adec->bit_stream.buffer >> (32 - 7);
+ DumpBits (&p_adec->bit_stream, 7);
+
+ sample[0][sb] = slope[gr0][sb] * L5_table[code % 5];
+ code /= 5;
+ sample[1][sb] = slope[gr0][sb] * L5_table[code % 5];
+ code /= 5;
+ sample[2][sb] = slope[gr0][sb] * L5_table[code];
+
+ break;
+ case L9:
+ NeedBits (&p_adec->bit_stream, 10);
+ code = p_adec->bit_stream.buffer >> (32 - 10);
+ DumpBits (&p_adec->bit_stream, 10);
+
+ sample[0][sb] = slope[gr0][sb] * L9_table[code % 9];
+ code /= 9;
+ sample[1][sb] = slope[gr0][sb] * L9_table[code % 9];
+ code /= 9;
+ sample[2][sb] = slope[gr0][sb] * L9_table[code];
+
+ break;
+ default:
+ for (s = 0; s < 3; s++) {
+ NeedBits (&p_adec->bit_stream, allocation[sb]);
+ code = (p_adec->bit_stream.buffer >>
+ (32 - allocation[sb]));
+ DumpBits (&p_adec->bit_stream, allocation[sb]);
+
+ sample[s][sb] =
+ slope[gr0][sb] * code + offset[gr0][sb];
+ }
+ }
+ }
+ for (; sb < 32; sb++)
+ {
+ sample[0][sb] = sample[1][sb] = sample[2][sb] = 0;
+ }
+
+ for (s = 0; s < 3; s++)
+ {
+ DCT32 (sample[s], &p_adec->bank_0);
+ XXX_buf = buffer;
+ PCM (&p_adec->bank_0, &XXX_buf, 1);
+ buffer += 32;
+ }
+
+
+
+ }
+
+
+return 0;
+
}
static int adec_layer2_stereo (audiodec_t * p_adec, s16 * buffer)
/* parse scalefactors */
- for (sb = 0; sb < sblimit; sb++) {
+ for (sb = 0; sb < sblimit; sb++)
+ {
if (allocation_0[sb]) {
int index_0, index_1, index_2;
* This function creates a new audio decoder thread, and returns a pointer to
* its description. On error, it returns NULL.
*****************************************************************************/
-adec_thread_t * adec_CreateThread (input_thread_t * p_input)
+adec_thread_t * adec_CreateThread ( input_thread_t * p_input )
{
adec_thread_t * p_adec;
- intf_DbgMsg ("adec debug: creating audio decoder thread\n");
+ intf_DbgMsg ( "adec debug: creating audio decoder thread\n" );
/* Allocate the memory needed to store the thread's structure */
- if ((p_adec = (adec_thread_t *)malloc (sizeof(adec_thread_t))) == NULL) {
- intf_ErrMsg ("adec error: not enough memory for adec_CreateThread() to create the new thread\n");
+ if ( (p_adec = (adec_thread_t *)malloc (sizeof(adec_thread_t))) == NULL )
+ {
+ intf_ErrMsg ( "adec error: not enough memory for adec_CreateThread() to create the new thread\n" );
return NULL;
}
*/
/* Initialize the decoder fifo's data lock and conditional variable and set
* its buffer as empty */
- vlc_mutex_init (&p_adec->fifo.data_lock);
- vlc_cond_init (&p_adec->fifo.data_wait);
+ vlc_mutex_init ( &p_adec->fifo.data_lock );
+ vlc_cond_init ( &p_adec->fifo.data_wait );
p_adec->fifo.i_start = 0;
p_adec->fifo.i_end = 0;
/*
* Initialize the decoder properties
*/
- adec_init (&p_adec->audio_decoder);
+ adec_init ( &p_adec->audio_decoder );
/*
* Initialize the output properties
p_adec->p_aout_fifo = NULL;
/* Spawn the audio decoder thread */
- if (vlc_thread_create(&p_adec->thread_id, "audio decoder", (vlc_thread_func_t)RunThread, (void *)p_adec)) {
+ if ( vlc_thread_create(&p_adec->thread_id, "audio decoder", (vlc_thread_func_t)RunThread, (void *)p_adec) )
+ {
intf_ErrMsg ("adec error: can't spawn audio decoder thread\n");
free (p_adec);
return NULL;
/* Our first job is to initialize the bit stream structure with the
* beginning of the input stream */
- vlc_mutex_lock (&p_adec->fifo.data_lock);
- while (DECODER_FIFO_ISEMPTY(p_adec->fifo)) {
- if (p_adec->b_die) {
- vlc_mutex_unlock (&p_adec->fifo.data_lock);
+ vlc_mutex_lock ( &p_adec->fifo.data_lock );
+ while ( DECODER_FIFO_ISEMPTY(p_adec->fifo) )
+ {
+ if (p_adec->b_die)
+ {
+ vlc_mutex_unlock ( &p_adec->fifo.data_lock );
return -1;
}
- vlc_cond_wait (&p_adec->fifo.data_wait, &p_adec->fifo.data_lock);
+ vlc_cond_wait ( &p_adec->fifo.data_wait, &p_adec->fifo.data_lock );
}
- p_adec->p_ts = DECODER_FIFO_START (p_adec->fifo)->p_first_ts;
- byte_stream = adec_byte_stream (&p_adec->audio_decoder);
+ p_adec->p_ts = DECODER_FIFO_START ( p_adec->fifo )->p_first_ts;
+ byte_stream = adec_byte_stream ( &p_adec->audio_decoder );
byte_stream->p_byte =
p_adec->p_ts->buffer + p_adec->p_ts->i_payload_start;
byte_stream->p_end =
p_adec->p_ts->buffer + p_adec->p_ts->i_payload_end;
byte_stream->info = p_adec;
- vlc_mutex_unlock (&p_adec->fifo.data_lock);
+ vlc_mutex_unlock ( &p_adec->fifo.data_lock );
aout_fifo.i_type = AOUT_ADEC_STEREO_FIFO;
aout_fifo.i_channels = 2;
aout_fifo.l_frame_size = ADEC_FRAME_SIZE;
/* Creating the audio output fifo */
- if ((p_adec->p_aout_fifo = aout_CreateFifo(p_adec->p_aout, &aout_fifo)) == NULL) {
+ if ( (p_adec->p_aout_fifo = aout_CreateFifo(p_adec->p_aout, &aout_fifo)) == NULL )
+ {
return -1;
}
- intf_DbgMsg ("adec debug: audio decoder thread %p initialized\n", p_adec);
+ intf_DbgMsg ( "adec debug: audio decoder thread %p initialized\n", p_adec );
return 0;
}
{
int sync;
- intf_DbgMsg ("adec debug: running audio decoder thread (%p) (pid == %i)\n", p_adec, getpid());
+ intf_DbgMsg ( "adec debug: running audio decoder thread (%p) (pid == %i)\n", p_adec, getpid() );
- msleep (INPUT_PTS_DELAY);
+ msleep ( INPUT_PTS_DELAY );
/* Initializing the audio decoder thread */
if( InitThread (p_adec) )
s16 * buffer;
adec_sync_info_t sync_info;
- if (!sync)
+ if ( !sync )
{
/* have to find a synchro point */
adec_byte_stream_t * p_byte_stream;
- printf ("sync\n");
+ printf ( "sync\n" );
p_adec->align = 0;
- p_byte_stream = adec_byte_stream (&p_adec->audio_decoder);
+ p_byte_stream = adec_byte_stream ( &p_adec->audio_decoder );
do
{
- adec_byte_stream_next (p_byte_stream);
- } while ((!p_adec->align) && (!p_adec->b_die) && (!p_adec->b_error));
+ adec_byte_stream_next ( p_byte_stream );
+ } while ( (!p_adec->align) && (!p_adec->b_die) && (!p_adec->b_error) );
sync = 1;
}
- if( DECODER_FIFO_START(p_adec->fifo)->b_has_pts )
+ if( DECODER_FIFO_START( p_adec->fifo)->b_has_pts )
{
- p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = DECODER_FIFO_START(p_adec->fifo)->i_pts;
+ p_adec->p_aout_fifo->date[p_adec->p_aout_fifo->l_end_frame] = DECODER_FIFO_START( p_adec->fifo )->i_pts;
DECODER_FIFO_START(p_adec->fifo)->b_has_pts = 0;
}
else
* thread can still receive feed, but must be ready to terminate as soon as
* possible.
*****************************************************************************/
-static void ErrorThread (adec_thread_t *p_adec)
+static void ErrorThread ( adec_thread_t *p_adec )
{
/* We take the lock, because we are going to read/write the start/end
* indexes of the decoder fifo */
- vlc_mutex_lock (&p_adec->fifo.data_lock);
+ vlc_mutex_lock ( &p_adec->fifo.data_lock );
/* Wait until a `die' order is sent */
- while (!p_adec->b_die) {
+ while ( !p_adec->b_die )
+ {
/* Trash all received PES packets */
- while (!DECODER_FIFO_ISEMPTY(p_adec->fifo)) {
- input_NetlistFreePES (p_adec->p_input, DECODER_FIFO_START(p_adec->fifo));
- DECODER_FIFO_INCSTART (p_adec->fifo);
+ while ( !DECODER_FIFO_ISEMPTY(p_adec->fifo) )
+ {
+ input_NetlistFreePES ( p_adec->p_input, DECODER_FIFO_START(p_adec->fifo) );
+ DECODER_FIFO_INCSTART ( p_adec->fifo );
}
/* Waiting for the input thread to put new PES packets in the fifo */
- vlc_cond_wait (&p_adec->fifo.data_wait, &p_adec->fifo.data_lock);
+ vlc_cond_wait ( &p_adec->fifo.data_wait, &p_adec->fifo.data_lock );
}
/* We can release the lock before leaving */
- vlc_mutex_unlock (&p_adec->fifo.data_lock);
+ vlc_mutex_unlock ( &p_adec->fifo.data_lock );
}
/*****************************************************************************
* This function is called when the thread ends after a sucessful
* initialization.
*****************************************************************************/
-static void EndThread (adec_thread_t *p_adec)
+static void EndThread ( adec_thread_t *p_adec )
{
- intf_DbgMsg ("adec debug: destroying audio decoder thread %p\n", p_adec);
+ intf_DbgMsg ( "adec debug: destroying audio decoder thread %p\n", p_adec );
/* If the audio output fifo was created, we destroy it */
- if (p_adec->p_aout_fifo != NULL) {
- aout_DestroyFifo (p_adec->p_aout_fifo);
+ if ( p_adec->p_aout_fifo != NULL )
+ {
+ aout_DestroyFifo ( p_adec->p_aout_fifo );
/* Make sure the output thread leaves the NextFrame() function */
vlc_mutex_lock (&(p_adec->p_aout_fifo->data_lock));
intf_DbgMsg ("adec debug: audio decoder thread %p destroyed\n", p_adec);
}
-void adec_byte_stream_next (adec_byte_stream_t * p_byte_stream)
+void adec_byte_stream_next ( adec_byte_stream_t * p_byte_stream )
{
adec_thread_t * p_adec = p_byte_stream->info;
/* We are looking for the next TS packet that contains real data,
* and not just a PES header */
- do {
+ do
+ {
/* We were reading the last TS packet of this PES packet... It's
* time to jump to the next PES packet */
- if (p_adec->p_ts->p_next_ts == NULL) {
+ if (p_adec->p_ts->p_next_ts == NULL)
+ {
/* We are going to read/write the start and end indexes of the
* decoder fifo and to use the fifo's conditional variable,
* that's why we need to take the lock before */
vlc_mutex_lock (&p_adec->fifo.data_lock);
/* Is the input thread dying ? */
- if (p_adec->p_input->b_die) {
+ if (p_adec->p_input->b_die)
+ {
vlc_mutex_unlock (&(p_adec->fifo.data_lock));
return;
}
input_NetlistFreePES (p_adec->p_input, DECODER_FIFO_START(p_adec->fifo));
DECODER_FIFO_INCSTART (p_adec->fifo);
- while (DECODER_FIFO_ISEMPTY(p_adec->fifo)) {
+ while (DECODER_FIFO_ISEMPTY(p_adec->fifo))
+ {
vlc_cond_wait (&p_adec->fifo.data_wait, &p_adec->fifo.data_lock);
- if (p_adec->p_input->b_die) {
+ if (p_adec->p_input->b_die)
+ {
vlc_mutex_unlock (&(p_adec->fifo.data_lock));
return;
}
}
/* Perhaps the next TS packet of the current PES packet contains
* real data (ie its payload's size is greater than 0) */
- else {
+ else
+ {
p_adec->p_ts = p_adec->p_ts->p_next_ts;
}
} while (p_adec->p_ts->i_payload_start == p_adec->p_ts->i_payload_end);
projects / vlc / commitdiff