Skip to content

V
vlc-1.1
Commit 3efee782 authored by Henri Fallon's avatar Henri Fallon
Browse files
Options 

Ajout du layer II mono (non test�) et d�but de mise en conformit� avec
les r�gles de formattage du code
parent e6f64322
Hide whitespace changes
Inline Side-by-side
Showing with 535 additions and 178 deletions
src/audio_decoder/audio_decoder.c
View file @ 3efee782
......@@ -97,10 +97,11 @@ static int adec_layer1_mono (audiodec_t * p_adec, s16 * buffer)
/* 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)
......@@ -110,45 +111,52 @@ static int adec_layer1_mono (audiodec_t * p_adec, s16 * buffer)
/* 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;
......@@ -168,118 +176,132 @@ static int adec_layer1_stereo (audiodec_t * p_adec, s16 * buffer)
/* 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;
......@@ -375,7 +397,327 @@ static void adec_layer2_get_table (u32 header, u8 freq_table[15],
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)
......@@ -457,7 +799,8 @@ 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;
......
src/audio_decoder/audio_decoder_thread.c
View file @ 3efee782
......@@ -76,15 +76,16 @@ static void EndThread (adec_thread_t * p_adec);
* 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;
}
......@@ -99,8 +100,8 @@ adec_thread_t * adec_CreateThread (input_thread_t * p_input)
*/
/* 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;
......@@ -110,7 +111,7 @@ adec_thread_t * adec_CreateThread (input_thread_t * p_input)
/*
* Initialize the decoder properties
*/
adec_init (&p_adec->audio_decoder);
adec_init ( &p_adec->audio_decoder );
/*
* Initialize the output properties
......@@ -119,7 +120,8 @@ adec_thread_t * adec_CreateThread (input_thread_t * p_input)
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;
......@@ -170,22 +172,24 @@ static int InitThread (adec_thread_t * p_adec)
/* 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;
......@@ -193,11 +197,12 @@ static int InitThread (adec_thread_t * p_adec)
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;
}
......@@ -211,9 +216,9 @@ static void RunThread (adec_thread_t * p_adec)
{
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) )
......@@ -229,26 +234,26 @@ static void RunThread (adec_thread_t * 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
......@@ -298,26 +303,28 @@ static void RunThread (adec_thread_t * p_adec)
* 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 );
}
/*****************************************************************************
......@@ -326,13 +333,14 @@ static void ErrorThread (adec_thread_t *p_adec)
* 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));
......@@ -345,23 +353,26 @@ static void EndThread (adec_thread_t *p_adec)
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;
}
......@@ -374,9 +385,11 @@ void adec_byte_stream_next (adec_byte_stream_t * p_byte_stream)
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;
}
......@@ -392,7 +405,8 @@ void adec_byte_stream_next (adec_byte_stream_t * p_byte_stream)
}
/* 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);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment