Enforce time border monotonicity.
[libav.git] / libavcodec / aacsbr.c
index e00d55c..130e3ed 100644 (file)
@@ -21,7 +21,7 @@
  */
 
 /**
- * @file libavcodec/aacsbr.c
+ * @file
  * AAC Spectral Band Replication decoding functions
  * @author Robert Swain ( rob opendot cl )
  */
@@ -138,6 +138,7 @@ av_cold void ff_aac_sbr_init(void)
 av_cold void ff_aac_sbr_ctx_init(SpectralBandReplication *sbr)
 {
     sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
+    sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
     sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
     sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
     ff_mdct_init(&sbr->mdct, 7, 1, 1.0/64);
@@ -173,7 +174,7 @@ static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
                                                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];
@@ -518,6 +519,15 @@ static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
             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];
 
@@ -535,13 +545,6 @@ static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
     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;
 }
 
@@ -617,104 +620,166 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
                          GetBitContext *gb, SBRData *ch_data)
 {
     int i;
+    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;
+    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);
-        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 > 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);
+            return -1;
+        }
+
+        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:
-        ch_data->bs_var_bord[1] = get_bits(gb, 2);
-        ch_data->bs_num_rel[1]  = get_bits(gb, 2);
-        ch_data->bs_num_env[1]  = ch_data->bs_num_rel[1] + 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 < ch_data->bs_num_rel[1]; i++)
-            ch_data->bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2;
+        for (i = 0; i < num_rel_trail; i++)
+            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;
 
-        ch_data->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:
-        ch_data->bs_var_bord[0] = get_bits(gb, 2);
-        ch_data->bs_num_rel[0]  = get_bits(gb, 2);
-        ch_data->bs_num_env[1]  = ch_data->bs_num_rel[0] + 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 < ch_data->bs_num_rel[0]; i++)
-            ch_data->bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2;
+        for (i = 0; i < num_rel_lead; i++)
+            ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
 
-        ch_data->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:
-        ch_data->bs_var_bord[0] = get_bits(gb, 2);
-        ch_data->bs_var_bord[1] = get_bits(gb, 2);
-        ch_data->bs_num_rel[0]  = get_bits(gb, 2);
-        ch_data->bs_num_rel[1]  = get_bits(gb, 2);
-        ch_data->bs_num_env[1]  = ch_data->bs_num_rel[0] + ch_data->bs_num_rel[1] + 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 > 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);
+            return -1;
+        }
+
+        ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
 
-        for (i = 0; i < ch_data->bs_num_rel[0]; i++)
-            ch_data->bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2;
-        for (i = 0; i < ch_data->bs_num_rel[1]; i++)
-            ch_data->bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2;
+        for (i = 0; i < num_rel_lead; i++)
+            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++)
+            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;
 
-        ch_data->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 (ch_data->bs_frame_class == FIXFIX && ch_data->bs_num_env[1] > 4) {
+    if (bs_pointer > ch_data->bs_num_env + 1) {
         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]);
+               "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
+               bs_pointer);
         return -1;
     }
-    if (ch_data->bs_frame_class == VARVAR && ch_data->bs_num_env[1] > 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]);
-        return -1;
+
+    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;
+
+    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;
+        } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
+            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;
+            else // bs_pointer > 1
+                idx = bs_pointer - 1;
+        }
+        ch_data->t_q[1] = ch_data->t_env[idx];
     }
 
-    ch_data->bs_num_noise = (ch_data->bs_num_env[1] > 1) + 1;
+    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 - 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;
 
     return 0;
 }
 
 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->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->bs_var_bord,   src->bs_var_bord,   sizeof(dst->bs_var_bord));
-    memcpy(dst->bs_rel_bord,   src->bs_rel_bord,   sizeof(dst->bs_rel_bord));
-    memcpy(dst->bs_num_rel,    src->bs_num_rel,    sizeof(dst->bs_rel_bord));
-    dst->bs_amp_res     = src->bs_amp_res;
-    dst->bs_num_noise   = src->bs_num_noise;
-    dst->bs_pointer     = src->bs_pointer;
-    dst->bs_frame_class = src->bs_frame_class;
+    memcpy(dst->t_env,         src->t_env,         sizeof(dst->t_env));
+    memcpy(dst->t_q,           src->t_q,           sizeof(dst->t_q));
+    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);
 }
 
@@ -769,9 +834,9 @@ static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb,
         }
     }
 
-    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);
@@ -794,7 +859,7 @@ static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb,
     }
 
     //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]));
 }
 
@@ -836,18 +901,24 @@ static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb,
 
 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);
@@ -1020,77 +1091,6 @@ int ff_decode_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
     return cnt;
 }
 
-/// Time/frequency Grid (14496-3 sp04 p200)
-static int sbr_time_freq_grid(AACContext *ac, SpectralBandReplication *sbr,
-                              SBRData *ch_data, int ch)
-{
-    int abs_bord_lead  =  ch_data->bs_frame_class >= 2 ? ch_data->bs_var_bord[0] : 0;
-    // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
-    int abs_bord_trail = (ch_data->bs_frame_class & 1 ? ch_data->bs_var_bord[1] : 0) + 16;
-    int n_rel_lead;
-    int i;
-
-    if (ch_data->bs_frame_class == FIXFIX) {
-        n_rel_lead = ch_data->bs_num_env[1] - 1;
-    } else if (ch_data->bs_frame_class == FIXVAR) {
-        n_rel_lead = 0;
-    } else if (ch_data->bs_frame_class < 4) { // VARFIX or VARVAR
-        n_rel_lead = ch_data->bs_num_rel[0];
-    } else {
-        av_log(ac->avccontext, AV_LOG_ERROR,
-               "Invalid bs_frame_class for SBR: %d\n", ch_data->bs_frame_class);
-        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 < n_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 < n_rel_lead; i++)
-            ch_data->t_env[i + 1] = ch_data->t_env[i] + ch_data->bs_rel_bord[0][i];
-    } else { // FIXVAR
-        for (i = 0; i < n_rel_lead; i++)
-            ch_data->t_env[i + 1] = abs_bord_lead;
-    }
-
-    if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
-        for (i = ch_data->bs_num_env[1] - 1; i > n_rel_lead; i--)
-            ch_data->t_env[i] = ch_data->t_env[i + 1] -
-                                ch_data->bs_rel_bord[1][ch_data->bs_num_env[1] - 1 - i];
-    } else { // FIXFIX or VARFIX
-        for (i = n_rel_lead; i < ch_data->bs_num_env[1]; i++)
-            ch_data->t_env[i + 1] = abs_bord_trail;
-    }
-
-    ch_data->t_q[0] = ch_data->t_env[0];
-    if (ch_data->bs_num_noise > 1) { // typo in spec bases this on bs_num_env...
-        unsigned int idx;
-        if (ch_data->bs_frame_class == FIXFIX) {
-            idx = ch_data->bs_num_env[1] >> 1;
-        } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
-            idx = ch_data->bs_num_env[1] - FFMAX(ch_data->bs_pointer - 1, 1);
-        } else { // VARFIX
-            if (!ch_data->bs_pointer)
-                idx = 1;
-            else if (ch_data->bs_pointer == 1)
-                idx = ch_data->bs_num_env[1] - 1;
-            else // bs_pointer > 1
-                idx = ch_data->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]];
-
-    return 0;
-}
-
 /// Dequantization and stereo decoding (14496-3 sp04 p203)
 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
 {
@@ -1100,7 +1100,7 @@ static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
     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);
@@ -1121,7 +1121,7 @@ static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
     } 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);
@@ -1141,14 +1141,13 @@ static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
  */
 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
@@ -1459,15 +1458,8 @@ static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
 {
     int e, i, m;
 
-    e_a[0] = -(e_a[1] != ch_data->bs_num_env[0]); // l_APrev
-    e_a[1] = -1;
-    if ((ch_data->bs_frame_class & 1) && ch_data->bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
-        e_a[1] = ch_data->bs_num_env[1] + 1 - ch_data->bs_pointer;
-    } else if ((ch_data->bs_frame_class == 2) && (ch_data->bs_pointer > 1)) // VARFIX and bs_pointer > 1
-        e_a[1] = ch_data->bs_pointer - 1;
-
     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;
@@ -1505,7 +1497,7 @@ static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
         }
     }
 
-    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)
@@ -1515,7 +1507,7 @@ static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
     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;
@@ -1533,7 +1525,7 @@ static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
     } 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;
@@ -1569,7 +1561,7 @@ static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
     // 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;
@@ -1652,14 +1644,14 @@ static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2]
         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));
 
@@ -1726,48 +1718,49 @@ static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2]
     ch_data->f_indexsine  = indexsine;
 }
 
-void ff_sbr_dequant(AACContext *ac, SpectralBandReplication *sbr, int id_aac)
+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;
 
     if (sbr->start) {
-        for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
-            sbr_time_freq_grid(ac, sbr, &sbr->data[ch], ch);
-        }
         sbr_dequant(sbr, id_aac);
     }
-}
-
-void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int ch,
-                  const float* in, float* out)
-{
-    int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
+    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);
+        }
 
-    /* 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);
+        /* synthesis */
+        sbr_x_gen(sbr, sbr->X, sbr->X_low, sbr->data[ch].Y, ch);
     }
-
-    /* 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,
+    sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X, 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, 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);
 }