aacdec_usac, aacsbr: implement SBR support for USAC

Currently, no eSBR features are supported.
Thankfully, no encoders exist for it yet.

4 files changed, 351 insertions, 43 deletions

diff --git a/libavcodec/aac/aacdec_usac.c b/libavcodec/aac/aacdec_usac.c
index e5504117d0..132ffee9c2 100644
--- a/libavcodec/aac/aacdec_usac.c
+++ b/libavcodec/aac/aacdec_usac.c
@@ -23,6 +23,8 @@
 #include "aacdec_lpd.h"
 #include "aacdec_ac.h"
 
+#include "libavcodec/aacsbr.h"
+
 #include "libavcodec/aactab.h"
 #include "libavutil/mem.h"
 #include "libavcodec/mpeg4audio.h"
@@ -145,7 +147,8 @@ static int decode_loudness_set(AACDecContext *ac, AACUSACConfig *usac,
     return 0;
 }
 
-static void decode_usac_sbr_data(AACUsacElemConfig *e, GetBitContext *gb)
+static int decode_usac_sbr_data(AACDecContext *ac,
+                                AACUsacElemConfig *e, GetBitContext *gb)
 {
     uint8_t header_extra1;
     uint8_t header_extra2;
@@ -153,6 +156,10 @@ static void decode_usac_sbr_data(AACUsacElemConfig *e, GetBitContext *gb)
     e->sbr.harmonic_sbr = get_bits1(gb); /* harmonicSBR */
     e->sbr.bs_intertes = get_bits1(gb); /* bs_interTes */
     e->sbr.bs_pvc = get_bits1(gb); /* bs_pvc */
+    if (e->sbr.harmonic_sbr || e->sbr.bs_intertes || e->sbr.bs_pvc) {
+        avpriv_report_missing_feature(ac->avctx, "AAC USAC eSBR");
+        return AVERROR_PATCHWELCOME;
+    }
 
     e->sbr.dflt.start_freq = get_bits(gb, 4); /* dflt_start_freq */
     e->sbr.dflt.stop_freq = get_bits(gb, 4); /* dflt_stop_freq */
@@ -179,6 +186,8 @@ static void decode_usac_sbr_data(AACUsacElemConfig *e, GetBitContext *gb)
         e->sbr.dflt.interpol_freq = get_bits1(gb); /* dflt_interpol_freq */
         e->sbr.dflt.smoothing_mode = get_bits1(gb); /* dflt_smoothing_mode */
     }
+
+    return 0;
 }
 
 static void decode_usac_element_core(AACUsacElemConfig *e,
@@ -190,13 +199,17 @@ static void decode_usac_element_core(AACUsacElemConfig *e,
     e->sbr.ratio = sbr_ratio;
 }
 
-static void decode_usac_element_pair(AACUsacElemConfig *e, GetBitContext *gb)
+static int decode_usac_element_pair(AACDecContext *ac,
+                                    AACUsacElemConfig *e, GetBitContext *gb)
 {
     e->stereo_config_index = 0;
     if (e->sbr.ratio) {
-        decode_usac_sbr_data(e, gb);
+        int ret = decode_usac_sbr_data(ac, e, gb);
+        if (ret < 0)
+            return ret;
         e->stereo_config_index = get_bits(gb, 2);
     }
+
     if (e->stereo_config_index) {
         e->mps.freq_res = get_bits(gb, 3); /* bsFreqRes */
         e->mps.fixed_gain = get_bits(gb, 3); /* bsFixedGainDMX */
@@ -216,6 +229,8 @@ static void decode_usac_element_pair(AACUsacElemConfig *e, GetBitContext *gb)
         if (e->mps.temp_shape_config == 2)
             e->mps.env_quant_mode = get_bits1(gb); /* bsEnvQuantMode */
     }
+
+    return 0;
 }
 
 static int decode_usac_extension(AACDecContext *ac, AACUsacElemConfig *e,
@@ -294,6 +309,9 @@ int ff_aac_usac_reset_state(AACDecContext *ac, OutputConfiguration *oc)
             AACUsacStereo *us = &che->us;
             memset(us, 0, sizeof(*us));
 
+            if (e->sbr.ratio)
+                ff_aac_sbr_config_usac(ac, che, e);
+
             for (int j = 0; j < ch; j++) {
                 SingleChannelElement *sce = &che->ch[ch];
                 AACUsacElemData *ue = &sce->ue;
@@ -320,6 +338,7 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
     uint8_t freq_idx;
     uint8_t channel_config_idx;
     int nb_channels = 0;
+    int ratio_mult, ratio_dec;
     int samplerate;
     int sbr_ratio;
     MPEG4AudioConfig *m4ac = &oc->m4ac;
@@ -340,8 +359,6 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
             return AVERROR(EINVAL);
     }
 
-    m4ac->sample_rate = avctx->sample_rate = samplerate;
-
     usac->core_sbr_frame_len_idx = get_bits(gb, 3); /* coreSbrFrameLengthIndex */
     m4ac->frame_length_short = usac->core_sbr_frame_len_idx == 0 ||
                                usac->core_sbr_frame_len_idx == 2;
@@ -354,7 +371,26 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
                 usac->core_sbr_frame_len_idx == 4 ? 1 :
                 0;
 
+    if (sbr_ratio == 2) {
+        ratio_mult = 8;
+        ratio_dec = 3;
+    } else if (sbr_ratio == 3) {
+        ratio_mult = 2;
+        ratio_dec = 1;
+    } else if (sbr_ratio == 4) {
+        ratio_mult = 4;
+        ratio_dec = 1;
+    } else {
+        ratio_mult = 1;
+        ratio_dec = 1;
+    }
+
+    avctx->sample_rate = samplerate;
+    m4ac->ext_sample_rate = samplerate;
+    m4ac->sample_rate = (samplerate * ratio_dec) / ratio_mult;
+
     m4ac->sampling_index = ff_aac_sample_rate_idx(m4ac->sample_rate);
+    m4ac->sbr = sbr_ratio > 0;
 
     channel_config_idx = get_bits(gb, 5); /* channelConfigurationIndex */
     if (!channel_config_idx) {
@@ -426,8 +462,11 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
         case ID_USAC_SCE: /* SCE */
             /* UsacCoreConfig */
             decode_usac_element_core(e, gb, sbr_ratio);
-            if (e->sbr.ratio > 0)
-                decode_usac_sbr_data(e, gb);
+            if (e->sbr.ratio > 0) {
+                ret = decode_usac_sbr_data(ac, e, gb);
+                if (ret < 0)
+                    return ret;
+            }
             layout_map[map_count][0] = TYPE_SCE;
             layout_map[map_count][1] = elem_id[0]++;
             if (!map_pos_set)
@@ -437,7 +476,9 @@ int ff_aac_usac_config_decode(AACDecContext *ac, AVCodecContext *avctx,
         case ID_USAC_CPE: /* UsacChannelPairElementConf */
             /* UsacCoreConfig */
             decode_usac_element_core(e, gb, sbr_ratio);
-            decode_usac_element_pair(e, gb);
+            ret = decode_usac_element_pair(ac, e, gb);
+            if (ret < 0)
+                return ret;
             layout_map[map_count][0] = TYPE_CPE;
             layout_map[map_count][1] = elem_id[1]++;
             if (!map_pos_set)
@@ -1307,13 +1348,14 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
     int ret;
     int arith_reset_flag;
     AACUsacStereo *us = &che->us;
+    int core_nb_channels = nb_channels;
 
     /* Local symbols */
     uint8_t global_gain;
 
     us->common_window = 0;
 
-    for (int ch = 0; ch < nb_channels; ch++) {
+    for (int ch = 0; ch < core_nb_channels; ch++) {
         SingleChannelElement *sce = &che->ch[ch];
         AACUsacElemData *ue = &sce->ue;
 
@@ -1323,13 +1365,16 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
         ue->core_mode = get_bits1(gb);
     }
 
-    if (nb_channels == 2) {
+    if (nb_channels > 1 && ec->stereo_config_index == 1)
+        core_nb_channels = 1;
+
+    if (core_nb_channels == 2) {
         ret = decode_usac_stereo_info(ac, usac, ec, che, gb, indep_flag);
         if (ret)
             return ret;
     }
 
-    for (int ch = 0; ch < nb_channels; ch++) {
+    for (int ch = 0; ch < core_nb_channels; ch++) {
         SingleChannelElement *sce = &che->ch[ch];
         IndividualChannelStream *ics = &sce->ics;
         AACUsacElemData *ue = &sce->ue;
@@ -1341,7 +1386,7 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
             continue;
         }
 
-        if ((nb_channels == 1) ||
+        if ((core_nb_channels == 1) ||
             (che->ch[0].ue.core_mode != che->ch[1].ue.core_mode))
             ue->tns_data_present = get_bits1(gb);
 
@@ -1424,7 +1469,29 @@ static int decode_usac_core_coder(AACDecContext *ac, AACUSACConfig *usac,
         }
     }
 
-    spectrum_decode(ac, usac, che, nb_channels);
+    if (ec->sbr.ratio) {
+        int sbr_ch = nb_channels;
+        if (nb_channels == 2 &&
+            !(ec->stereo_config_index == 0 || ec->stereo_config_index == 3))
+            sbr_ch = 1;
+
+        ret = ff_aac_sbr_decode_usac_data(ac, che, ec, gb, sbr_ch, indep_flag);
+        if (ret < 0)
+            return ret;
+
+        if (ec->stereo_config_index) {
+            avpriv_report_missing_feature(ac->avctx, "AAC USAC Mps212");
+            return AVERROR_PATCHWELCOME;
+        }
+    }
+
+    spectrum_decode(ac, usac, che, core_nb_channels);
+
+    if (ac->oc[1].m4ac.sbr > 0) {
+        ac->proc.sbr_apply(ac, che, nb_channels == 2 ? TYPE_CPE : TYPE_SCE,
+                           che->ch[0].output,
+                           che->ch[1].output);
+    }
 
     return 0;
 }
@@ -1591,9 +1658,29 @@ int ff_aac_usac_decode_frame(AVCodecContext *avctx, AACDecContext *ac,
     int indep_flag, samples = 0;
     int audio_found = 0;
     int elem_id[3 /* SCE, CPE, LFE */] = { 0, 0, 0 };
-
     AVFrame *frame = ac->frame;
 
+    int ratio_mult, ratio_dec;
+    AACUSACConfig *usac = &ac->oc[1].usac;
+    int sbr_ratio = usac->core_sbr_frame_len_idx == 2 ? 2 :
+                    usac->core_sbr_frame_len_idx == 3 ? 3 :
+                    usac->core_sbr_frame_len_idx == 4 ? 1 :
+                    0;
+
+    if (sbr_ratio == 2) {
+        ratio_mult = 8;
+        ratio_dec = 3;
+    } else if (sbr_ratio == 3) {
+        ratio_mult = 2;
+        ratio_dec = 1;
+    } else if (sbr_ratio == 4) {
+        ratio_mult = 4;
+        ratio_dec = 1;
+    } else {
+        ratio_mult = 1;
+        ratio_dec = 1;
+    }
+
     ff_aac_output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
                             ac->oc[1].status, 0);
 
@@ -1660,8 +1747,10 @@ int ff_aac_usac_decode_frame(AVCodecContext *avctx, AACDecContext *ac,
     if (audio_found)
         samples = ac->oc[1].m4ac.frame_length_short ? 768 : 1024;
 
+    samples = (samples * ratio_mult) / ratio_dec;
+
     if (ac->oc[1].status && audio_found) {
-        avctx->sample_rate = ac->oc[1].m4ac.sample_rate;
+        avctx->sample_rate = ac->oc[1].m4ac.ext_sample_rate;
         avctx->frame_size = samples;
         ac->oc[1].status = OC_LOCKED;
     }
diff --git a/libavcodec/aacsbr.h b/libavcodec/aacsbr.h
index d4582d1100..3958b43b91 100644
--- a/libavcodec/aacsbr.h
+++ b/libavcodec/aacsbr.h
@@ -88,6 +88,17 @@ int ff_aac_sbr_decode_extension(AACDecContext *ac, ChannelElement *che,
 int ff_aac_sbr_decode_extension_fixed(AACDecContext *ac, ChannelElement *che,
                                       GetBitContext *gb, int crc, int cnt, int id_aac);
 
+/** Due to channel allocation not being known upon SBR parameter transmission,
+ * supply the parameters separately.
+ * Functionally identical to ff_aac_sbr_decode_extension() */
+int ff_aac_sbr_config_usac(AACDecContext *ac, ChannelElement *che,
+                           AACUsacElemConfig *ue);
+
+/** Decode frame SBR data, USAC. */
+int ff_aac_sbr_decode_usac_data(AACDecContext *ac, ChannelElement *che,
+                                AACUsacElemConfig *ue, GetBitContext *gb,
+                                int sbr_ch, int indep_flag);
+
 /** Apply one SBR element to one AAC element. */
 void ff_aac_sbr_apply(AACDecContext *ac, ChannelElement *che,
                       int id_aac, void /* float */ *L, void /* float */ *R);
diff --git a/libavcodec/aacsbr_template.c b/libavcodec/aacsbr_template.c
index 86f4d8c26e..e5bc4d4659 100644
--- a/libavcodec/aacsbr_template.c
+++ b/libavcodec/aacsbr_template.c
@@ -57,6 +57,7 @@ av_cold void AAC_RENAME(ff_aac_sbr_init)(void)
 /** Places SBR in pure upsampling mode. */
 static void sbr_turnoff(SpectralBandReplication *sbr) {
     sbr->start = 0;
+    sbr->usac = 0;
     sbr->ready_for_dequant = 0;
     // Init defults used in pure upsampling mode
     sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
@@ -184,7 +185,8 @@ static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
     }
 }
 
-static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
+static unsigned int read_sbr_header(SpectralBandReplication *sbr,
+                                    GetBitContext *gb, int is_usac)
 {
     unsigned int cnt = get_bits_count(gb);
     uint8_t bs_header_extra_1;
@@ -194,15 +196,20 @@ static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext
 
     sbr->start = 1;
     sbr->ready_for_dequant = 0;
+    sbr->usac = is_usac;
 
     // Save last spectrum parameters variables to compare to new ones
     memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
 
-    sbr->bs_amp_res_header              = get_bits1(gb);
+    if (!is_usac)
+        sbr->bs_amp_res_header          = get_bits1(gb);
+
     sbr->spectrum_params.bs_start_freq  = get_bits(gb, 4);
     sbr->spectrum_params.bs_stop_freq   = get_bits(gb, 4);
-    sbr->spectrum_params.bs_xover_band  = get_bits(gb, 3);
-                                          skip_bits(gb, 2); // bs_reserved
+
+    if (!is_usac)
+        sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
+                                             skip_bits(gb, 2); // bs_reserved
 
     bs_header_extra_1 = get_bits1(gb);
     bs_header_extra_2 = get_bits1(gb);
@@ -645,7 +652,7 @@ static int read_sbr_grid(AACDecContext *ac, SpectralBandReplication *sbr,
     switch (bs_frame_class = get_bits(gb, 2)) {
     case FIXFIX:
         bs_num_env = 1 << get_bits(gb, 2);
-        if (bs_num_env > 4) {
+        if (bs_num_env > (sbr->usac ? 8 : 5)) {
             av_log(ac->avctx, AV_LOG_ERROR,
                    "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
                    bs_num_env);
@@ -793,10 +800,26 @@ static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
 
 /// Read how the envelope and noise floor data is delta coded
 static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
-                          SBRData *ch_data)
+                          SBRData *ch_data, int indep_flag)
 {
-    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);
+    if (sbr->usac) {
+        if (indep_flag) {
+            ch_data->bs_df_env[0] = 0;
+            get_bits1_vector(gb, &ch_data->bs_df_env[1], ch_data->bs_num_env - 1);
+        } else {
+            get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
+        }
+
+        if (indep_flag) {
+            ch_data->bs_df_noise[0] = 0;
+            get_bits1_vector(gb, &ch_data->bs_df_noise[1], ch_data->bs_num_noise - 1);
+        } else {
+            get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
+        }
+    } else {
+        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);
+    }
 }
 
 /// Read inverse filtering data
@@ -811,7 +834,7 @@ static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb,
 }
 
 static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb,
-                              SBRData *ch_data, int ch)
+                             SBRData *ch_data, int ch)
 {
     int bits;
     int i, j, k;
@@ -881,6 +904,13 @@ static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, Ge
                 }
             }
         }
+        if (sbr->usac) {
+            if (sbr->inter_tes) {
+                ch_data->temp_shape[i] = get_bits(gb, 1);
+                if (ch_data->temp_shape[i])
+                    ch_data->temp_shape_mode[i] = get_bits(gb, 2);
+            }
+        }
     }
 
     //assign 0th elements of env_facs_q from last elements
@@ -970,7 +1000,7 @@ static int read_sbr_single_channel_element(AACDecContext *ac,
 
     if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
         return -1;
-    read_sbr_dtdf(sbr, gb, &sbr->data[0]);
+    read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
     read_sbr_invf(sbr, gb, &sbr->data[0]);
     if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
         return ret;
@@ -996,8 +1026,8 @@ static int read_sbr_channel_pair_element(AACDecContext *ac,
         if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
             return -1;
         copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
-        read_sbr_dtdf(sbr, gb, &sbr->data[0]);
-        read_sbr_dtdf(sbr, gb, &sbr->data[1]);
+        read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
+        read_sbr_dtdf(sbr, gb, &sbr->data[1], 0);
         read_sbr_invf(sbr, gb, &sbr->data[0]);
         memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
         memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
@@ -1013,8 +1043,8 @@ static int read_sbr_channel_pair_element(AACDecContext *ac,
         if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
             read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
             return -1;
-        read_sbr_dtdf(sbr, gb, &sbr->data[0]);
-        read_sbr_dtdf(sbr, gb, &sbr->data[1]);
+        read_sbr_dtdf(sbr, gb, &sbr->data[0], 0);
+        read_sbr_dtdf(sbr, gb, &sbr->data[1], 0);
         read_sbr_invf(sbr, gb, &sbr->data[0]);
         read_sbr_invf(sbr, gb, &sbr->data[1]);
         if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
@@ -1129,7 +1159,7 @@ int AAC_RENAME(ff_aac_sbr_decode_extension)(AACDecContext *ac, ChannelElement *c
 
     num_sbr_bits++;
     if (get_bits1(gb)) // bs_header_flag
-        num_sbr_bits += read_sbr_header(sbr, gb);
+        num_sbr_bits += read_sbr_header(sbr, gb, 0);
 
     if (sbr->reset)
         sbr_reset(ac, sbr);
@@ -1148,6 +1178,178 @@ int AAC_RENAME(ff_aac_sbr_decode_extension)(AACDecContext *ac, ChannelElement *c
     return cnt;
 }
 
+#if !USE_FIXED
+static void copy_usac_default_header(SpectralBandReplication *sbr,
+                                     AACUsacElemConfig *ue)
+{
+    sbr->inter_tes = ue->sbr.bs_intertes;
+
+    sbr->spectrum_params.bs_start_freq = ue->sbr.dflt.start_freq;
+    sbr->spectrum_params.bs_stop_freq = ue->sbr.dflt.stop_freq;
+
+    sbr->spectrum_params.bs_freq_scale = ue->sbr.dflt.freq_scale;
+    sbr->spectrum_params.bs_alter_scale = ue->sbr.dflt.alter_scale;
+    sbr->spectrum_params.bs_noise_bands = ue->sbr.dflt.noise_bands;
+
+    sbr->bs_limiter_bands = ue->sbr.dflt.limiter_bands;
+    sbr->bs_limiter_gains = ue->sbr.dflt.limiter_gains;
+    sbr->bs_interpol_freq = ue->sbr.dflt.interpol_freq;
+    sbr->bs_smoothing_mode = ue->sbr.dflt.smoothing_mode;
+}
+
+int ff_aac_sbr_config_usac(AACDecContext *ac, ChannelElement *che,
+                           AACUsacElemConfig *ue)
+{
+    SpectralBandReplication *sbr = get_sbr(che);
+    sbr_turnoff(sbr);
+    return 0;
+}
+
+int ff_aac_sbr_decode_usac_data(AACDecContext *ac, ChannelElement *che,
+                                AACUsacElemConfig *ue, GetBitContext *gb,
+                                int sbr_ch, int indep_flag)
+{
+    int ret;
+    SpectralBandReplication *sbr = get_sbr(che);
+    int info_present = 1;
+    int header_present = 1;
+
+    sbr->reset = 0;
+    sbr->usac = 1;
+
+    sbr->sample_rate = ac->oc[1].m4ac.ext_sample_rate;
+    sbr->id_aac = sbr_ch == 2 ? TYPE_CPE : TYPE_SCE;
+
+    if (!indep_flag) {
+        info_present = get_bits1(gb);
+        if (info_present)
+            header_present = get_bits1(gb);
+        else
+            header_present = 0;
+    }
+
+    if (info_present) {
+        /* SbrInfo() */
+        sbr->bs_amp_res_header = get_bits1(gb);
+        sbr->spectrum_params.bs_xover_band = get_bits(gb, 4);
+        sbr->bs_sbr_preprocessing = get_bits1(gb);
+        /* if (bs_pvc) ... */
+    }
+
+    if (header_present) {
+        if (get_bits1(gb)) {
+            int old_bs_limiter_bands = sbr->bs_limiter_bands;
+            SpectrumParameters old_spectrum_params;
+            memcpy(&old_spectrum_params, &sbr->spectrum_params,
+                   sizeof(SpectrumParameters));
+
+            copy_usac_default_header(sbr, ue);
+            // Check if spectrum parameters changed
+            if (memcmp(&old_spectrum_params, &sbr->spectrum_params,
+                       sizeof(SpectrumParameters)))
+                sbr->reset = 1;
+
+            if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
+                sbr_make_f_tablelim(sbr);
+        } else {
+            read_sbr_header(sbr, gb, 1);
+        }
+
+        sbr->start = 1;
+    }
+
+    //Save some state from the previous frame.
+    sbr->kx[0] = sbr->kx[1];
+    sbr->m[0] = sbr->m[1];
+    sbr->kx_and_m_pushed = 1;
+
+    if (sbr->reset)
+        sbr_reset(ac, sbr);
+
+    sbr->ready_for_dequant = 1;
+
+    int start = get_bits_count(gb);
+
+    if (sbr_ch == 1) { /* sbr_single_channel_element */
+        /* if (harmonicSBR) ... */
+
+        if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
+            return -1;
+
+        read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
+        read_sbr_invf(sbr, gb, &sbr->data[0]);
+
+        if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+            return ret;
+
+        if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+            return ret;
+
+        if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
+            get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
+    } else if (get_bits1(gb)) { /* bs_coupling == 1 */
+        /* if (harmonicSBR) ... */
+
+        if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
+            return -1;
+        copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
+
+        read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
+        read_sbr_dtdf(sbr, gb, &sbr->data[1], indep_flag);
+
+        read_sbr_invf(sbr, gb, &sbr->data[0]);
+        memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0],
+               sizeof(sbr->data[1].bs_invf_mode[0]));
+        memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0],
+               sizeof(sbr->data[1].bs_invf_mode[0]));
+
+        if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+            return ret;
+        if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+            return ret;
+
+        if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+            return ret;
+        if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+            return ret;
+
+        if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
+            get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
+        if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
+            get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
+    } else { /* bs_coupling == 0 */
+        /* if (harmonicSBR) ... */
+        if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
+            return -1;
+        if (read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
+            return -1;
+
+        read_sbr_dtdf(sbr, gb, &sbr->data[0], indep_flag);
+        read_sbr_dtdf(sbr, gb, &sbr->data[1], indep_flag);
+
+        read_sbr_invf(sbr, gb, &sbr->data[0]);
+        read_sbr_invf(sbr, gb, &sbr->data[1]);
+
+        if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+            return ret;
+        if ((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+            return ret;
+
+        if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
+            return ret;
+        if ((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
+            return ret;
+
+        if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
+            get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
+        if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
+            get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
+    }
+
+    return 0;
+}
+#endif
+
 /**
  * Analysis QMF Bank (14496-3 sp04 p206)
  *
diff --git a/libavcodec/sbr.h b/libavcodec/sbr.h
index fe3a39603a..40bb30e04d 100644
--- a/libavcodec/sbr.h
+++ b/libavcodec/sbr.h
@@ -68,9 +68,9 @@ typedef struct SBRData {
     unsigned           bs_frame_class;
     unsigned           bs_add_harmonic_flag;
     AAC_SIGNE          bs_num_env;
-    uint8_t            bs_freq_res[7];
+    uint8_t            bs_freq_res[9];
     AAC_SIGNE          bs_num_noise;
-    uint8_t            bs_df_env[5];
+    uint8_t            bs_df_env[9];
     uint8_t            bs_df_noise[2];
     uint8_t            bs_invf_mode[2][5];
     uint8_t            bs_add_harmonic[48];
@@ -95,21 +95,24 @@ typedef struct SBRData {
     DECLARE_ALIGNED(16, INTFLOAT, Y)[2][38][64][2];
     DECLARE_ALIGNED(16, AAC_FLOAT, g_temp)[42][48];
     AAC_FLOAT          q_temp[42][48];
-    uint8_t            s_indexmapped[8][48];
+    uint8_t            s_indexmapped[9][48];
     ///Envelope scalefactors
-    uint8_t            env_facs_q[6][48];
-    AAC_FLOAT          env_facs[6][48];
+    uint8_t            env_facs_q[9][48];
+    AAC_FLOAT          env_facs[9][48];
     ///Noise scalefactors
     uint8_t            noise_facs_q[3][5];
     AAC_FLOAT          noise_facs[3][5];
     ///Envelope time borders
-    uint8_t            t_env[8];
+    uint8_t            t_env[9];
     ///Envelope time border of the last envelope of the previous frame
     uint8_t            t_env_num_env_old;
     ///Noise time borders
     uint8_t            t_q[3];
     unsigned           f_indexnoise;
     unsigned           f_indexsine;
+    //inter_tes (USAC)
+    uint8_t            temp_shape[6];
+    uint8_t            temp_shape_mode[6];
     /** @} */
 } SBRData;
 
@@ -142,9 +145,12 @@ struct SpectralBandReplication {
     int                start;
     int                ready_for_dequant;
     int                id_aac;
+    int                usac;
+    int                inter_tes; // USAC-only
     int                reset;
     SpectrumParameters spectrum_params;
     int                bs_amp_res_header;
+    int                bs_sbr_preprocessing; // USAC-only
     /**
      * @name Variables associated with bs_header_extra_2
      * @{
@@ -196,18 +202,18 @@ struct SpectralBandReplication {
     ///First coefficient used to filter the subband signals
     DECLARE_ALIGNED(16, INTFLOAT, alpha1)[64][2];
     ///Dequantized envelope scalefactors, remapped
-    AAC_FLOAT          e_origmapped[7][48];
+    AAC_FLOAT          e_origmapped[8][48];
     ///Dequantized noise scalefactors, remapped
-    AAC_FLOAT          q_mapped[7][48];
+    AAC_FLOAT          q_mapped[8][48];
     ///Sinusoidal presence, remapped
-    uint8_t            s_mapped[7][48];
+    uint8_t            s_mapped[8][48];
     ///Estimated envelope
-    AAC_FLOAT          e_curr[7][48];
+    AAC_FLOAT          e_curr[8][48];
     ///Amplitude adjusted noise scalefactors
-    AAC_FLOAT          q_m[7][48];
+    AAC_FLOAT          q_m[8][48];
     ///Sinusoidal levels
-    AAC_FLOAT          s_m[7][48];
-    AAC_FLOAT          gain[7][48];
+    AAC_FLOAT          s_m[8][48];
+    AAC_FLOAT          gain[8][48];
     DECLARE_ALIGNED(32, INTFLOAT, qmf_filter_scratch)[5][64];
     AVTXContext       *mdct_ana;
     av_tx_fn           mdct_ana_fn;