*/
/**
- * @file libavcodec/aacsbr.c
+ * @file
* AAC Spectral Band Replication decoding functions
* @author Robert Swain ( rob opendot cl )
*/
1.18509277094158210129f, //2^(0.49/2)
1.11987160404675912501f }; //2^(0.49/3)
const float lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
- int16_t patch_borders[5];
+ int16_t patch_borders[7];
uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
patch_borders[0] = sbr->kx[1];
odd = (sb + sbr->k[0]) & 1;
}
+ // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
+ // After this check the final number of patches can still be six which is
+ // illegal however the Coding Technologies decoder check stream has a final
+ // count of 6 patches
+ if (sbr->num_patches > 5) {
+ av_log(ac->avccontext, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
+ return -1;
+ }
+
sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
sbr->num_patches--;
- // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5
- // However the Coding Technologies decoder check uses 6 patches
- if (sbr->num_patches > 6) {
- av_log(ac->avccontext, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
- return -1;
- }
-
return 0;
}
GetBitContext *gb, SBRData *ch_data)
{
int i;
- unsigned bs_pointer;
- int abs_bord_lead = 0;
+ unsigned bs_pointer = 0;
// frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
int abs_bord_trail = 16;
int num_rel_lead, num_rel_trail;
- uint8_t bs_rel_bord[2][3];
+ unsigned bs_num_env_old = ch_data->bs_num_env;
- ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env[1]];
- ch_data->bs_num_env[0] = ch_data->bs_num_env[1];
+ ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
ch_data->bs_amp_res = sbr->bs_amp_res_header;
+ ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
case FIXFIX:
- ch_data->bs_num_env[1] = 1 << get_bits(gb, 2);
- num_rel_lead = ch_data->bs_num_env[1] - 1;
- if (ch_data->bs_num_env[1] == 1)
+ ch_data->bs_num_env = 1 << get_bits(gb, 2);
+ num_rel_lead = ch_data->bs_num_env - 1;
+ if (ch_data->bs_num_env == 1)
ch_data->bs_amp_res = 0;
- if (ch_data->bs_num_env[1] > 4) {
+ if (ch_data->bs_num_env > 4) {
av_log(ac->avccontext, AV_LOG_ERROR,
"Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
- ch_data->bs_num_env[1]);
+ ch_data->bs_num_env);
return -1;
}
- bs_pointer = 0;
+ ch_data->t_env[0] = 0;
+ ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
+
+ abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
+ ch_data->bs_num_env;
+ for (i = 0; i < num_rel_lead; i++)
+ ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
ch_data->bs_freq_res[1] = get_bits1(gb);
- for (i = 1; i < ch_data->bs_num_env[1]; i++)
+ for (i = 1; i < ch_data->bs_num_env; i++)
ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
break;
case FIXVAR:
- abs_bord_trail += get_bits(gb, 2);
- num_rel_trail = get_bits(gb, 2);
- num_rel_lead = 0;
- ch_data->bs_num_env[1] = num_rel_trail + 1;
+ abs_bord_trail += get_bits(gb, 2);
+ num_rel_trail = get_bits(gb, 2);
+ ch_data->bs_num_env = num_rel_trail + 1;
+ ch_data->t_env[0] = 0;
+ ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
for (i = 0; i < num_rel_trail; i++)
- bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2;
+ ch_data->t_env[ch_data->bs_num_env - 1 - i] =
+ ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
- bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env[1]]);
+ bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
- for (i = 0; i < ch_data->bs_num_env[1]; i++)
- ch_data->bs_freq_res[ch_data->bs_num_env[1] - i] = get_bits1(gb);
+ for (i = 0; i < ch_data->bs_num_env; i++)
+ ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
break;
case VARFIX:
- abs_bord_lead = get_bits(gb, 2);
- num_rel_lead = get_bits(gb, 2);
- ch_data->bs_num_env[1] = num_rel_lead + 1;
+ ch_data->t_env[0] = get_bits(gb, 2);
+ num_rel_lead = get_bits(gb, 2);
+ ch_data->bs_num_env = num_rel_lead + 1;
+ ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
for (i = 0; i < num_rel_lead; i++)
- bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2;
+ ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
- bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env[1]]);
+ bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
- get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env[1]);
+ get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
break;
case VARVAR:
- abs_bord_lead = get_bits(gb, 2);
- abs_bord_trail += get_bits(gb, 2);
- num_rel_lead = get_bits(gb, 2);
- num_rel_trail = get_bits(gb, 2);
- ch_data->bs_num_env[1] = num_rel_lead + num_rel_trail + 1;
+ ch_data->t_env[0] = get_bits(gb, 2);
+ abs_bord_trail += get_bits(gb, 2);
+ num_rel_lead = get_bits(gb, 2);
+ num_rel_trail = get_bits(gb, 2);
+ ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1;
- if (ch_data->bs_num_env[1] > 5) {
+ if (ch_data->bs_num_env > 5) {
av_log(ac->avccontext, AV_LOG_ERROR,
"Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
- ch_data->bs_num_env[1]);
+ ch_data->bs_num_env);
return -1;
}
+ ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
+
for (i = 0; i < num_rel_lead; i++)
- bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2;
+ ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
for (i = 0; i < num_rel_trail; i++)
- bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2;
+ ch_data->t_env[ch_data->bs_num_env - 1 - i] =
+ ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
- bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env[1]]);
+ bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
- get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env[1]);
+ get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
break;
}
- if (bs_pointer > ch_data->bs_num_env[1] + 1) {
+ if (bs_pointer > ch_data->bs_num_env + 1) {
av_log(ac->avccontext, AV_LOG_ERROR,
"Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
bs_pointer);
return -1;
}
- ch_data->t_env_num_env_old = ch_data->t_env[ch_data->bs_num_env[0]];
- ch_data->t_env[0] = abs_bord_lead;
- ch_data->t_env[ch_data->bs_num_env[1]] = abs_bord_trail;
-
- if (ch_data->bs_frame_class == FIXFIX) {
- int temp = (abs_bord_trail + (ch_data->bs_num_env[1] >> 1)) /
- ch_data->bs_num_env[1];
- for (i = 0; i < num_rel_lead; i++)
- ch_data->t_env[i + 1] = ch_data->t_env[i] + temp;
- } else if (ch_data->bs_frame_class > 1) { // VARFIX or VARVAR
- for (i = 0; i < num_rel_lead; i++)
- ch_data->t_env[i + 1] = ch_data->t_env[i] + bs_rel_bord[0][i];
- }
-
- if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
- for (i = ch_data->bs_num_env[1] - 1; i > num_rel_lead; i--)
- ch_data->t_env[i] = ch_data->t_env[i + 1] -
- bs_rel_bord[1][ch_data->bs_num_env[1] - 1 - i];
+ for (i = 1; i <= ch_data->bs_num_env; i++) {
+ if (ch_data->t_env[i-1] > ch_data->t_env[i]) {
+ av_log(ac->avccontext, AV_LOG_ERROR, "Non monotone time borders\n");
+ return -1;
+ }
}
- ch_data->bs_num_noise = (ch_data->bs_num_env[1] > 1) + 1;
+ ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1;
- ch_data->t_q[0] = ch_data->t_env[0];
+ ch_data->t_q[0] = ch_data->t_env[0];
+ ch_data->t_q[ch_data->bs_num_noise] = ch_data->t_env[ch_data->bs_num_env];
if (ch_data->bs_num_noise > 1) {
unsigned int idx;
if (ch_data->bs_frame_class == FIXFIX) {
- idx = ch_data->bs_num_env[1] >> 1;
+ idx = ch_data->bs_num_env >> 1;
} else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
- idx = ch_data->bs_num_env[1] - FFMAX(bs_pointer - 1, 1);
+ idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
} else { // VARFIX
if (!bs_pointer)
idx = 1;
else if (bs_pointer == 1)
- idx = ch_data->bs_num_env[1] - 1;
+ idx = ch_data->bs_num_env - 1;
else // bs_pointer > 1
idx = bs_pointer - 1;
}
ch_data->t_q[1] = ch_data->t_env[idx];
- ch_data->t_q[2] = ch_data->t_env[ch_data->bs_num_env[1]];
- } else
- ch_data->t_q[1] = ch_data->t_env[ch_data->bs_num_env[1]];
+ }
- ch_data->e_a[0] = -(ch_data->e_a[1] != ch_data->bs_num_env[0]); // l_APrev
+ ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev
ch_data->e_a[1] = -1;
if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
- ch_data->e_a[1] = ch_data->bs_num_env[1] + 1 - bs_pointer;
+ ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer;
} else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1
ch_data->e_a[1] = bs_pointer - 1;
static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
//These variables are saved from the previous frame rather than copied
- dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env[1]];
- dst->bs_num_env[0] = dst->bs_num_env[1];
- dst->t_env_num_env_old = dst->t_env[dst->bs_num_env[0]];
- dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env[0]);
+ dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env];
+ dst->t_env_num_env_old = dst->t_env[dst->bs_num_env];
+ dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env);
//These variables are read from the bitstream and therefore copied
memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res));
- memcpy(dst->bs_num_env+1, src->bs_num_env+1, sizeof(dst->bs_num_env)- sizeof(*dst->bs_num_env));
memcpy(dst->t_env, src->t_env, sizeof(dst->t_env));
memcpy(dst->t_q, src->t_q, sizeof(dst->t_q));
- dst->bs_amp_res = src->bs_amp_res;
- dst->bs_num_noise = src->bs_num_noise;
- dst->bs_frame_class = src->bs_frame_class;
- dst->e_a[1] = src->e_a[1];
+ dst->bs_num_env = src->bs_num_env;
+ dst->bs_amp_res = src->bs_amp_res;
+ dst->bs_num_noise = src->bs_num_noise;
+ dst->bs_frame_class = src->bs_frame_class;
+ dst->e_a[1] = src->e_a[1];
}
/// Read how the envelope and noise floor data is delta coded
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
SBRData *ch_data)
{
- get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env[1]);
+ get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
}
}
}
- for (i = 0; i < ch_data->bs_num_env[1]; i++) {
+ for (i = 0; i < ch_data->bs_num_env; i++) {
if (ch_data->bs_df_env[i]) {
- // bs_freq_res[0] == bs_freq_res[bs_num_env[1]] from prev frame
+ // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
}
//assign 0th elements of env_facs from last elements
- memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env[1]],
+ memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env],
sizeof(ch_data->env_facs[0]));
}
static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
GetBitContext *gb,
- int bs_extension_id, int *num_bits_left)
+ int bs_extension_id, int *num_bits_left)
{
//TODO - implement ps_data for parametric stereo parsing
switch (bs_extension_id) {
case EXTENSION_ID_PS:
+ if (!ac->m4ac.ps) {
+ av_log(ac->avccontext, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
+ skip_bits_long(gb, *num_bits_left); // bs_fill_bits
+ *num_bits_left = 0;
+ } else {
#if 0
- *num_bits_left -= ff_ps_data(gb, ps);
+ *num_bits_left -= ff_ps_data(gb, ps);
#else
- av_log_missing_feature(ac->avccontext, "Parametric Stereo is", 0);
- skip_bits_long(gb, *num_bits_left); // bs_fill_bits
- *num_bits_left = 0;
+ av_log_missing_feature(ac->avccontext, "Parametric Stereo is", 0);
+ skip_bits_long(gb, *num_bits_left); // bs_fill_bits
+ *num_bits_left = 0;
#endif
+ }
break;
default:
av_log_missing_feature(ac->avccontext, "Reserved SBR extensions are", 1);
if (id_aac == TYPE_CPE && sbr->bs_coupling) {
float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f;
float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f;
- for (e = 1; e <= sbr->data[0].bs_num_env[1]; e++) {
+ for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f);
float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha);
} else { // SCE or one non-coupled CPE
for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f;
- for (e = 1; e <= sbr->data[ch].bs_num_env[1]; e++)
+ for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++)
sbr->data[ch].env_facs[e][k] =
exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f);
*/
static void sbr_qmf_analysis(DSPContext *dsp, RDFTContext *rdft, const float *in, float *x,
float z[320], float W[2][32][32][2],
- float bias, float scale)
+ float scale)
{
int i, k;
memcpy(W[0], W[1], sizeof(W[0]));
memcpy(x , x+1024, (320-32)*sizeof(x[0]));
- if (scale != 1.0f || bias != 0.0f)
- for (i = 0; i < 1024; i++)
- x[288 + i] = (in[i] - bias) * scale;
+ if (scale != 1.0f)
+ dsp->vector_fmul_scalar(x+288, in, scale, 1024);
else
memcpy(x+288, in, 1024*sizeof(*x));
for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
int e, i, m;
memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
- for (e = 0; e < ch_data->bs_num_env[1]; e++) {
+ for (e = 0; e < ch_data->bs_num_env; e++) {
const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
int k;
}
}
- memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env[1]], sizeof(ch_data->s_indexmapped[0]));
+ memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
}
/// Estimation of current envelope (14496-3 sp04 p218)
int e, i, m;
if (sbr->bs_interpol_freq) {
- for (e = 0; e < ch_data->bs_num_env[1]; e++) {
+ for (e = 0; e < ch_data->bs_num_env; e++) {
const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
} else {
int k, p;
- for (e = 0; e < ch_data->bs_num_env[1]; e++) {
+ for (e = 0; e < ch_data->bs_num_env; e++) {
const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
// max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
- for (e = 0; e < ch_data->bs_num_env[1]; e++) {
+ for (e = 0; e < ch_data->bs_num_env; e++) {
int delta = !((e == e_a[1]) || (e == e_a[0]));
for (k = 0; k < sbr->n_lim; k++) {
float gain_boost, gain_max;
memcpy(q_temp[2*ch_data->t_env[0]], q_temp[2*ch_data->t_env_num_env_old], 4*sizeof(q_temp[0]));
}
- for (e = 0; e < ch_data->bs_num_env[1]; e++) {
+ for (e = 0; e < ch_data->bs_num_env; e++) {
for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
}
}
- for (e = 0; e < ch_data->bs_num_env[1]; e++) {
+ for (e = 0; e < ch_data->bs_num_env; e++) {
for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
int phi_sign = (1 - 2*(kx & 1));
ch_data->f_indexsine = indexsine;
}
-void ff_sbr_dequant(AACContext *ac, SpectralBandReplication *sbr, int id_aac)
-{
- if (sbr->start) {
- sbr_dequant(sbr, id_aac);
- }
-}
-
-void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int ch,
- const float* in, float* out)
+void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
+ float* L, float* R)
{
int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
+ int ch;
+ int nch = (id_aac == TYPE_CPE) ? 2 : 1;
- /* decode channel */
- sbr_qmf_analysis(&ac->dsp, &sbr->rdft, in, sbr->data[ch].analysis_filterbank_samples,
- (float*)sbr->qmf_filter_scratch,
- sbr->data[ch].W, ac->add_bias, 1/(-1024 * ac->sf_scale));
- sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
if (sbr->start) {
- sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
- sbr_chirp(sbr, &sbr->data[ch]);
- sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
- sbr->data[ch].bw_array, sbr->data[ch].t_env,
- sbr->data[ch].bs_num_env[1]);
-
- // hf_adj
- sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
- sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
- sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
- sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
- sbr->data[ch].e_a);
+ sbr_dequant(sbr, id_aac);
}
+ for (ch = 0; ch < nch; ch++) {
+ /* decode channel */
+ sbr_qmf_analysis(&ac->dsp, &sbr->rdft, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
+ (float*)sbr->qmf_filter_scratch,
+ sbr->data[ch].W, 1/(-1024 * ac->sf_scale));
+ sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
+ if (sbr->start) {
+ sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
+ sbr_chirp(sbr, &sbr->data[ch]);
+ sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
+ sbr->data[ch].bw_array, sbr->data[ch].t_env,
+ sbr->data[ch].bs_num_env);
+
+ // hf_adj
+ sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
+ sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
+ sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
+ sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
+ sbr->data[ch].e_a);
+ }
- /* synthesis */
- sbr_x_gen(sbr, sbr->X, sbr->X_low, sbr->data[ch].Y, ch);
- sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, out, sbr->X, sbr->qmf_filter_scratch,
- sbr->data[ch].synthesis_filterbank_samples,
- &sbr->data[ch].synthesis_filterbank_samples_offset,
+ /* synthesis */
+ sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);
+ }
+ sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
+ sbr->data[0].synthesis_filterbank_samples,
+ &sbr->data[0].synthesis_filterbank_samples_offset,
downsampled,
ac->add_bias, -1024 * ac->sf_scale);
+ if (nch == 2)
+ sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
+ sbr->data[1].synthesis_filterbank_samples,
+ &sbr->data[1].synthesis_filterbank_samples_offset,
+ downsampled,
+ ac->add_bias, -1024 * ac->sf_scale);
}