static int dca_subsubframe (dca_state_t * state)
{
int k, l;
int subsubframe = state->current_subsubframe;
const double *quant_step_table;
/* FIXME */
double subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
/*
* Audio data
*/
/* Select quantization step size table */
if (state->bit_rate == 0x1f)
quant_step_table = lossless_quant_d;
else
quant_step_table = lossy_quant_d;
for (k = 0; k < state->prim_channels; k++)
{
for (l = 0; l < state->vq_start_subband[k] ; l++)
{
int m;
/* Select the mid-tread linear quantizer */
int abits = state->bitalloc[k][l];
double quant_step_size = quant_step_table[abits];
double rscale;
/*
* Determine quantization index code book and its type
*/
/* Select quantization index code book */
int sel = state->quant_index_huffman[k][abits];
/* Determine its type */
int q_type = 1; /* (Assume Huffman type by default) */
if (abits >= 11 || !bitalloc_select[abits][sel])
{
/* Not Huffman type */
if (abits <= 7) q_type = 3; /* Block code */
else q_type = 2; /* No further encoding */
}
if (abits == 0) q_type = 0; /* No bits allocated */
/*
* Extract bits from the bit stream
*/
switch (q_type)
{
case 0: /* No bits allocated */
for (m=0; m<8; m++)
subband_samples[k][l][m] = 0;
break;
case 1: /* Huffman code */
for (m=0; m<8; m++)
subband_samples[k][l][m] =
InverseQ (state, bitalloc_select[abits][sel]);
break;
case 2: /* No further encoding */
for (m=0; m<8; m++)
{
/* Extract (signed) quantization index */
int q_index = bitstream_get (state, abits - 3);
if( q_index & (1 << (abits - 4)) )
{
q_index = (1 << (abits - 3)) - q_index;
q_index = -q_index;
}
subband_samples[k][l][m] = q_index;
}
break;
case 3: /* Block code */
{
int block_code1, block_code2, size, levels;
int block[8];
switch (abits)
{
case 1:
size = 7;
levels = 3;
break;
case 2:
size = 10;
levels = 5;
break;
case 3:
size = 12;
levels = 7;
break;
case 4:
size = 13;
levels = 9;
break;
case 5:
size = 15;
levels = 13;
break;
case 6:
size = 17;
levels = 17;
break;
case 7:
default:
size = 19;
levels = 25;
break;
}
block_code1 = bitstream_get (state, size);
/* Should test return value */
decode_blockcode (block_code1, levels, block);
block_code2 = bitstream_get (state, size);
decode_blockcode (block_code2, levels, &block[4]);
for (m=0; m<8; m++)
subband_samples[k][l][m] = block[m];
}
break;
default: /* Undefined */
fprintf (stderr, "Unknown quantization index codebook");
return -1;
}
/*
* Account for quantization step and scale factor
*/
/* Deal with transients */
if (state->transition_mode[k][l] &&
subsubframe >= state->transition_mode[k][l])
rscale = quant_step_size * state->scale_factor[k][l][1];
else
rscale = quant_step_size * state->scale_factor[k][l][0];
/* Adjustment */
rscale *= state->scalefactor_adj[k][sel];
for (m=0; m<8; m++) subband_samples[k][l][m] *= rscale;
/*
* Inverse ADPCM if in prediction mode
*/
if (state->prediction_mode[k][l])
{
int n;
for (m=0; m<8; m++)
{
for (n=1; n<=4; n++)
if (m-n >= 0)
subband_samples[k][l][m] +=
(adpcm_vb[state->prediction_vq[k][l]][n-1] *
subband_samples[k][l][m-n]/8192);
else if (state->predictor_history)
subband_samples[k][l][m] +=
(adpcm_vb[state->prediction_vq[k][l]][n-1] *
state->subband_samples_hist[k][l][m-n+4]/8192);
}
}
}
/*
* Decode VQ encoded high frequencies
*/
for (l = state->vq_start_subband[k];
l < state->subband_activity[k]; l++)
{
/* 1 vector -> 32 samples but we only need the 8 samples
* for this subsubframe. */
int m;
if (!state->debug_flag & 0x01)
{
trace ("Stream with high frequencies VQ coding\n");
state->debug_flag |= 0x01;
}
for (m=0; m<8; m++)
{
subband_samples[k][l][m] =
high_freq_vq[state->high_freq_vq[k][l]][subsubframe*8+m]
* (double)state->scale_factor[k][l][0] / 16.0;
}
}
}
/* Check for DSYNC after subsubframe */
if (state->aspf || subsubframe == state->subsubframes - 1)
{
if (0xFFFF == bitstream_get (state, 16)) /* 0xFFFF */
{
#ifdef DEBUG
fprintf( stderr, "Got subframe DSYNC\n" );
#endif
}
else
{
trace( "Didn't get subframe DSYNC\n" );
}
}
/* Backup predictor history for adpcm */
for (k = 0; k < state->prim_channels; k++)
{
for (l = 0; l < state->vq_start_subband[k] ; l++)
{
int m;
for (m = 0; m < 4; m++)
state->subband_samples_hist[k][l][m] =
subband_samples[k][l][4+m];
}
}
/* 32 subbands QMF */
for (k = 0; k < state->prim_channels; k++)
{
qmf_32_subbands (state, k, subband_samples[k], &state->samples[256*k]);
}
/* Down/Up mixing */
if (state->prim_channels < dca_channels[state->output & DCA_CHANNEL_MASK])
{
dca_upmix (state->samples, state->amode, state->output);
} else
if (state->prim_channels > dca_channels[state->output & DCA_CHANNEL_MASK])
{
dca_downmix (state->samples, state->amode, state->output, state->bias,
state->clev, state->slev);
} else if (state->bias)
{
for ( k = 0; k < 256*state->prim_channels; k++ )
state->samples[k] += state->bias;
}
/* Generate LFE samples for this subsubframe FIXME!!! */
if (state->output & DCA_LFE)
{
int lfe_samples = 2 * state->lfe * state->subsubframes;
int i_channels = dca_channels[state->output & DCA_CHANNEL_MASK];
lfe_interpolation_fir (state->lfe, 2 * state->lfe,
state->lfe_data + lfe_samples +
2 * state->lfe * subsubframe,
&state->samples[256*i_channels], state->bias);
/* Outputs 20bits pcm samples */
}
return 0;
}
static int dca_subsubframe(DCAContext * s)
{
int k, l;
int subsubframe = s->current_subsubframe;
const float *quant_step_table;
/* FIXME */
float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
/*
* Audio data
*/
/* Select quantization step size table */
if (s->bit_rate_index == 0x1f)
quant_step_table = lossless_quant_d;
else
quant_step_table = lossy_quant_d;
for (k = 0; k < s->prim_channels; k++) {
for (l = 0; l < s->vq_start_subband[k]; l++) {
int m;
/* Select the mid-tread linear quantizer */
int abits = s->bitalloc[k][l];
float quant_step_size = quant_step_table[abits];
float rscale;
/*
* Determine quantization index code book and its type
*/
/* Select quantization index code book */
int sel = s->quant_index_huffman[k][abits];
/*
* Extract bits from the bit stream
*/
if(!abits){
memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
}else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
if(abits <= 7){
/* Block code */
int block_code1, block_code2, size, levels;
int block[8];
size = abits_sizes[abits-1];
levels = abits_levels[abits-1];
block_code1 = get_bits(&s->gb, size);
/* FIXME Should test return value */
decode_blockcode(block_code1, levels, block);
block_code2 = get_bits(&s->gb, size);
decode_blockcode(block_code2, levels, &block[4]);
for (m = 0; m < 8; m++)
subband_samples[k][l][m] = block[m];
}else{
/* no coding */
for (m = 0; m < 8; m++)
subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
}
}else{
/* Huffman coded */
for (m = 0; m < 8; m++)
subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
}
/* Deal with transients */
if (s->transition_mode[k][l] &&
subsubframe >= s->transition_mode[k][l])
rscale = quant_step_size * s->scale_factor[k][l][1];
else
rscale = quant_step_size * s->scale_factor[k][l][0];
rscale *= s->scalefactor_adj[k][sel];
for (m = 0; m < 8; m++)
subband_samples[k][l][m] *= rscale;
/*
* Inverse ADPCM if in prediction mode
*/
if (s->prediction_mode[k][l]) {
int n;
for (m = 0; m < 8; m++) {
for (n = 1; n <= 4; n++)
if (m >= n)
subband_samples[k][l][m] +=
(adpcm_vb[s->prediction_vq[k][l]][n - 1] *
subband_samples[k][l][m - n] / 8192);
else if (s->predictor_history)
subband_samples[k][l][m] +=
(adpcm_vb[s->prediction_vq[k][l]][n - 1] *
s->subband_samples_hist[k][l][m - n +
4] / 8192);
}
}
}
/*
* Decode VQ encoded high frequencies
*/
for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
/* 1 vector -> 32 samples but we only need the 8 samples
* for this subsubframe. */
int m;
if (!s->debug_flag & 0x01) {
av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
s->debug_flag |= 0x01;
}
for (m = 0; m < 8; m++) {
subband_samples[k][l][m] =
high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
m]
* (float) s->scale_factor[k][l][0] / 16.0;
}
}
}
/* Check for DSYNC after subsubframe */
if (s->aspf || subsubframe == s->subsubframes - 1) {
if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
#ifdef TRACE
av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
#endif
} else {
av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
}
}
/* Backup predictor history for adpcm */
for (k = 0; k < s->prim_channels; k++)
for (l = 0; l < s->vq_start_subband[k]; l++)
memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
4 * sizeof(subband_samples[0][0][0]));
/* 32 subbands QMF */
for (k = 0; k < s->prim_channels; k++) {
/* static float pcm_to_double[8] =
{32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
s->add_bias );
}
/* Down mixing */
if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
dca_downmix(s->samples, s->amode, s->downmix_coef);
}
/* Generate LFE samples for this subsubframe FIXME!!! */
if (s->output & DCA_LFE) {
int lfe_samples = 2 * s->lfe * s->subsubframes;
lfe_interpolation_fir(s->lfe, 2 * s->lfe,
s->lfe_data + lfe_samples +
2 * s->lfe * subsubframe,
&s->samples[256 * dca_lfe_index[s->amode]],
(1.0/256.0)*s->scale_bias, s->add_bias);
/* Outputs 20bits pcm samples */
}
return 0;
}
