@@ -61,6 +61,7 @@ version <next>:

 - FFprobe tool

 - AMR-NB decoder

 - RTSP muxer

+- HE-AAC v1 decoder

@@ -41,7 +41,7 @@ OBJS-$(CONFIG_VAAPI)                   += vaapi.o

 OBJS-$(CONFIG_VDPAU)                   += vdpau.o

 # decoders/encoders/hardware accelerators

-OBJS-$(CONFIG_AAC_DECODER)             += aac.o aactab.o

+OBJS-$(CONFIG_AAC_DECODER)             += aac.o aactab.o aacsbr.o

 OBJS-$(CONFIG_AAC_ENCODER)             += aacenc.o aaccoder.o    \

                                           aacpsy.o aactab.o      \

                                           psymodel.o iirfilter.o \

@@ -62,7 +62,7 @@

  * N                    MIDI

  * N                    Harmonic and Individual Lines plus Noise

  * N                    Text-To-Speech Interface

- * N (in progress)      Spectral Band Replication

+ * Y                    Spectral Band Replication

  * Y (not in this code) Layer-1

  * Y (not in this code) Layer-2

  * Y (not in this code) Layer-3

@@ -86,6 +86,8 @@

 #include "aac.h"

 #include "aactab.h"

 #include "aacdectab.h"

+#include "sbr.h"

+#include "aacsbr.h"

 #include "mpeg4audio.h"

 #include "aac_parser.h"

@@ -180,14 +182,18 @@ static av_cold int che_configure(AACContext *ac,

     if (che_pos[type][id]) {

         if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))

             return AVERROR(ENOMEM);

+        ff_aac_sbr_ctx_init(&ac->che[type][id]->sbr);

         if (type != TYPE_CCE) {

             ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;

             if (type == TYPE_CPE) {

                 ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret;

             }

         }

-    } else

+    } else {

+        if (ac->che[type][id])

+            ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr);

         av_freep(&ac->che[type][id]);

+    }

     return 0;

 }

@@ -530,6 +536,8 @@ static av_cold int aac_decode_init(AVCodecContext *avccontext)

     AAC_INIT_VLC_STATIC( 9, 366);

     AAC_INIT_VLC_STATIC(10, 462);

+    ff_aac_sbr_init();

+

     dsputil_init(&ac->dsp, avccontext);

     ac->random_state = 0x1f2e3d4c;

@@ -1545,23 +1553,6 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)

 }

 /**

- * Decode Spectral Band Replication extension data; reference: table 4.55.

- *

- * @param   crc flag indicating the presence of CRC checksum

- * @param   cnt length of TYPE_FIL syntactic element in bytes

- *

- * @return  Returns number of bytes consumed from the TYPE_FIL element.

- */

-static int decode_sbr_extension(AACContext *ac, GetBitContext *gb,

-                                int crc, int cnt)

-{

-    // TODO : sbr_extension implementation

-    av_log_missing_feature(ac->avccontext, "SBR", 0);

-    skip_bits_long(gb, 8 * cnt - 4); // -4 due to reading extension type

-    return cnt;

-}

-

-/**

  * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53.

  *

  * @return  Returns number of bytes consumed.

@@ -1641,7 +1632,8 @@ static int decode_dynamic_range(DynamicRangeControl *che_drc,

  *

  * @return Returns number of bytes consumed

  */

-static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt)

+static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,

+                                    ChannelElement *che, enum RawDataBlockType elem_type)

 {

     int crc_flag = 0;

     int res = cnt;

@@ -1649,7 +1641,21 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt)

     case EXT_SBR_DATA_CRC:

         crc_flag++;

     case EXT_SBR_DATA:

-        res = decode_sbr_extension(ac, gb, crc_flag, cnt);

+        if (!che) {

+            av_log(ac->avccontext, AV_LOG_ERROR, "SBR was found before the first channel element.\n");

+            return res;

+        } else if (!ac->m4ac.sbr) {

+            av_log(ac->avccontext, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");

+            skip_bits_long(gb, 8 * cnt - 4);

+            return res;

+        } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) {

+            av_log(ac->avccontext, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");

+            skip_bits_long(gb, 8 * cnt - 4);

+            return res;

+        } else {

+            ac->m4ac.sbr = 1;

+        }

+        res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type);

         break;

     case EXT_DYNAMIC_RANGE:

         res = decode_dynamic_range(&ac->che_drc, gb, cnt);

@@ -1830,8 +1836,9 @@ static void apply_independent_coupling(AACContext *ac,

     const float bias = ac->add_bias;

     const float *src = cce->ch[0].ret;

     float *dest = target->ret;

+    const int len = 1024 << (ac->m4ac.sbr == 1);

-    for (i = 0; i < 1024; i++)

+    for (i = 0; i < len; i++)

         dest[i] += gain * (src[i] - bias);

 }

@@ -1889,10 +1896,18 @@ static void spectral_to_sample(AACContext *ac)

                     apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1);

                 if (type <= TYPE_CPE)

                     apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling);

-                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT)

+                if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) {

                     imdct_and_windowing(ac, &che->ch[0]);

-                if (type == TYPE_CPE)

+                    if (ac->m4ac.sbr > 0) {

+                        ff_sbr_dequant(ac, &che->sbr, type == TYPE_CPE ? TYPE_CPE : TYPE_SCE);

+                        ff_sbr_apply(ac, &che->sbr, 0, che->ch[0].ret, che->ch[0].ret);

+                    }

+                }

+                if (type == TYPE_CPE) {

                     imdct_and_windowing(ac, &che->ch[1]);

+                    if (ac->m4ac.sbr > 0)

+                        ff_sbr_apply(ac, &che->sbr, 1, che->ch[1].ret, che->ch[1].ret);

+                }

                 if (type <= TYPE_CCE)

                     apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling);

             }

@@ -1942,9 +1957,9 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

     AACContext *ac = avccontext->priv_data;

-    ChannelElement *che = NULL;

+    ChannelElement *che = NULL, *che_prev = NULL;

     GetBitContext gb;

-    enum RawDataBlockType elem_type;

+    enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;

     int err, elem_id, data_size_tmp;

     int buf_consumed;

     int samples = 1024, multiplier;

@@ -2014,7 +2029,7 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,

                     return -1;

             }

             while (elem_id > 0)

-                elem_id -= decode_extension_payload(ac, &gb, elem_id);

+                elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev);

             err = 0; /* FIXME */

             break;

@@ -2023,6 +2038,9 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,

             break;

         }

+        che_prev       = che;

+        elem_type_prev = elem_type;

+

         if (err)

             return err;

@@ -2034,14 +2052,14 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,

     spectral_to_sample(ac);

-    multiplier = 0;

+    multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0;

     samples <<= multiplier;

     if (ac->output_configured < OC_LOCKED) {

         avccontext->sample_rate = ac->m4ac.sample_rate << multiplier;

         avccontext->frame_size = samples;

     }

-    data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t);

+    data_size_tmp = samples * avccontext->channels * sizeof(int16_t);

     if (*data_size < data_size_tmp) {

         av_log(avccontext, AV_LOG_ERROR,

                "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",

@@ -2050,7 +2068,7 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,

     }

     *data_size = data_size_tmp;

-    ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, 1024, avccontext->channels);

+    ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avccontext->channels);

     if (ac->output_configured)

         ac->output_configured = OC_LOCKED;

@@ -2065,8 +2083,11 @@ static av_cold int aac_decode_close(AVCodecContext *avccontext)

     int i, type;

     for (i = 0; i < MAX_ELEM_ID; i++) {

-        for (type = 0; type < 4; type++)

+        for (type = 0; type < 4; type++) {

+            if (ac->che[type][i])

+                ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr);

             av_freep(&ac->che[type][i]);

+        }

     }

     ff_mdct_end(&ac->mdct);

@@ -34,6 +34,7 @@

 #include "dsputil.h"

 #include "fft.h"

 #include "mpeg4audio.h"

+#include "sbr.h"

 #include <stdint.h>

@@ -217,7 +218,7 @@ typedef struct {

     uint8_t zeroes[128];                      ///< band is not coded (used by encoder)

     DECLARE_ALIGNED(16, float, coeffs)[1024]; ///< coefficients for IMDCT

     DECLARE_ALIGNED(16, float, saved)[1024];  ///< overlap

-    DECLARE_ALIGNED(16, float, ret)[1024];    ///< PCM output

+    DECLARE_ALIGNED(16, float, ret)[2048];    ///< PCM output

     PredictorState predictor_state[MAX_PREDICTORS];

 } SingleChannelElement;

@@ -233,6 +234,7 @@ typedef struct {

     SingleChannelElement ch[2];

     // CCE specific

     ChannelCoupling coup;

+    SpectralBandReplication sbr;

 } ChannelElement;

 /**

new file mode 100644

@@ -0,0 +1,1759 @@

+/*

+ * AAC Spectral Band Replication decoding functions

+ * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )

+ * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file libavcodec/aacsbr.c

+ * AAC Spectral Band Replication decoding functions

+ * @author Robert Swain ( rob opendot cl )

+ */

+

+#include "aac.h"

+#include "sbr.h"

+#include "aacsbr.h"

+#include "aacsbrdata.h"

+

+#include <stdint.h>

+#include <float.h>

+

+#define ENVELOPE_ADJUSTMENT_OFFSET 2

+#define NOISE_FLOOR_OFFSET 6.0f

+

+/**

+ * SBR VLC tables

+ */

+enum {

+    T_HUFFMAN_ENV_1_5DB,

+    F_HUFFMAN_ENV_1_5DB,

+    T_HUFFMAN_ENV_BAL_1_5DB,

+    F_HUFFMAN_ENV_BAL_1_5DB,

+    T_HUFFMAN_ENV_3_0DB,

+    F_HUFFMAN_ENV_3_0DB,

+    T_HUFFMAN_ENV_BAL_3_0DB,

+    F_HUFFMAN_ENV_BAL_3_0DB,

+    T_HUFFMAN_NOISE_3_0DB,

+    T_HUFFMAN_NOISE_BAL_3_0DB,

+};

+

+/**

+ * bs_frame_class - frame class of current SBR frame (14496-3 sp04 p98)

+ */

+enum {

+    FIXFIX,

+    FIXVAR,

+    VARFIX,

+    VARVAR,

+};

+

+enum {

+    EXTENSION_ID_PS = 2,

+};

+

+static VLC vlc_sbr[10];

+static const int8_t vlc_sbr_lav[10] =

+    { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };

+static DECLARE_ALIGNED(16, float, analysis_cos_pre)[64];

+static DECLARE_ALIGNED(16, float, analysis_sin_pre)[64];

+static DECLARE_ALIGNED(16, float, analysis_cossin_post)[32][2];

+static const DECLARE_ALIGNED(16, float, zero64)[64];

+

+#define SBR_INIT_VLC_STATIC(num, size) \

+    INIT_VLC_STATIC(&vlc_sbr[num], 9, sbr_tmp[num].table_size / sbr_tmp[num].elem_size,     \

+                    sbr_tmp[num].sbr_bits ,                      1,                      1, \

+                    sbr_tmp[num].sbr_codes, sbr_tmp[num].elem_size, sbr_tmp[num].elem_size, \

+                    size)

+

+#define SBR_VLC_ROW(name) \

+    { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) }

+

+av_cold void ff_aac_sbr_init(void)

+{

+    int n, k;

+    static const struct {

+        const void *sbr_codes, *sbr_bits;

+        const unsigned int table_size, elem_size;

+    } sbr_tmp[] = {

+        SBR_VLC_ROW(t_huffman_env_1_5dB),

+        SBR_VLC_ROW(f_huffman_env_1_5dB),

+        SBR_VLC_ROW(t_huffman_env_bal_1_5dB),

+        SBR_VLC_ROW(f_huffman_env_bal_1_5dB),

+        SBR_VLC_ROW(t_huffman_env_3_0dB),

+        SBR_VLC_ROW(f_huffman_env_3_0dB),

+        SBR_VLC_ROW(t_huffman_env_bal_3_0dB),

+        SBR_VLC_ROW(f_huffman_env_bal_3_0dB),

+        SBR_VLC_ROW(t_huffman_noise_3_0dB),

+        SBR_VLC_ROW(t_huffman_noise_bal_3_0dB),

+    };

+

+    // SBR VLC table initialization

+    SBR_INIT_VLC_STATIC(0, 1098);

+    SBR_INIT_VLC_STATIC(1, 1092);

+    SBR_INIT_VLC_STATIC(2, 768);

+    SBR_INIT_VLC_STATIC(3, 1026);

+    SBR_INIT_VLC_STATIC(4, 1058);

+    SBR_INIT_VLC_STATIC(5, 1052);

+    SBR_INIT_VLC_STATIC(6, 544);

+    SBR_INIT_VLC_STATIC(7, 544);

+    SBR_INIT_VLC_STATIC(8, 592);

+    SBR_INIT_VLC_STATIC(9, 512);

+

+    for (n = 0; n < 64; n++) {

+        float pre = M_PI * n / 64;

+        analysis_cos_pre[n] = cosf(pre);

+        analysis_sin_pre[n] = sinf(pre);

+    }

+    for (k = 0; k < 32; k++) {

+        float post = M_PI * (k + 0.5) / 128;

+        analysis_cossin_post[k][0] =  4.0 * cosf(post);

+        analysis_cossin_post[k][1] = -4.0 * sinf(post);

+    }

+    for (n = 1; n < 320; n++)

+        sbr_qmf_window_us[320 + n] = sbr_qmf_window_us[320 - n];

+    sbr_qmf_window_us[384] = -sbr_qmf_window_us[384];

+    sbr_qmf_window_us[512] = -sbr_qmf_window_us[512];

+

+    for (n = 0; n < 320; n++)

+        sbr_qmf_window_ds[n] = sbr_qmf_window_us[2*n];

+}

+

+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].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);

+    ff_rdft_init(&sbr->rdft, 6, IDFT_R2C);

+}

+

+av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)

+{

+    ff_mdct_end(&sbr->mdct);

+    ff_rdft_end(&sbr->rdft);

+}

+

+static int qsort_comparison_function_int16(const void *a, const void *b)

+{

+    return *(const int16_t *)a - *(const int16_t *)b;

+}

+

+static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)

+{

+    int i;

+    for (i = 0; i <= last_el; i++)

+        if (table[i] == needle)

+            return 1;

+    return 0;

+}

+

+/// Limiter Frequency Band Table (14496-3 sp04 p198)

+static void sbr_make_f_tablelim(SpectralBandReplication *sbr)

+{

+    int k;

+    if (sbr->bs_limiter_bands > 0) {

+        static const float bands_warped[3] = { 1.32715174233856803909f,   //2^(0.49/1.2)

+                                               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];

+        uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;

+

+        patch_borders[0] = sbr->kx[1];

+        for (k = 1; k <= sbr->num_patches; k++)

+            patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];

+

+        memcpy(sbr->f_tablelim, sbr->f_tablelow,

+               (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));

+        if (sbr->num_patches > 1)

+            memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,

+                   (sbr->num_patches - 1) * sizeof(patch_borders[0]));

+

+        qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],

+              sizeof(sbr->f_tablelim[0]),

+              qsort_comparison_function_int16);

+

+        sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;

+        while (out < sbr->f_tablelim + sbr->n_lim) {

+            if (*in >= *out * lim_bands_per_octave_warped) {

+                *++out = *in++;

+            } else if (*in == *out ||

+                !in_table_int16(patch_borders, sbr->num_patches, *in)) {

+                in++;

+                sbr->n_lim--;

+            } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {

+                *out = *in++;

+                sbr->n_lim--;

+            } else {

+                *++out = *in++;

+            }

+        }

+    } else {

+        sbr->f_tablelim[0] = sbr->f_tablelow[0];

+        sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];

+        sbr->n_lim = 1;

+    }

+}

+

+static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)

+{

+    unsigned int cnt = get_bits_count(gb);

+    uint8_t bs_header_extra_1;

+    uint8_t bs_header_extra_2;

+    int old_bs_limiter_bands = sbr->bs_limiter_bands;

+    SpectrumParameters old_spectrum_params;

+

+    sbr->start = 1;

+

+    // 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);

+    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

+

+    bs_header_extra_1 = get_bits1(gb);

+    bs_header_extra_2 = get_bits1(gb);

+

+    if (bs_header_extra_1) {

+        sbr->spectrum_params.bs_freq_scale  = get_bits(gb, 2);

+        sbr->spectrum_params.bs_alter_scale = get_bits1(gb);

+        sbr->spectrum_params.bs_noise_bands = get_bits(gb, 2);

+    } else {

+        sbr->spectrum_params.bs_freq_scale  = 2;

+        sbr->spectrum_params.bs_alter_scale = 1;

+        sbr->spectrum_params.bs_noise_bands = 2;

+    }

+

+    // Check if spectrum parameters changed

+    if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))

+        sbr->reset = 1;

+

+    if (bs_header_extra_2) {

+        sbr->bs_limiter_bands  = get_bits(gb, 2);

+        sbr->bs_limiter_gains  = get_bits(gb, 2);

+        sbr->bs_interpol_freq  = get_bits1(gb);

+        sbr->bs_smoothing_mode = get_bits1(gb);

+    } else {

+        sbr->bs_limiter_bands  = 2;

+        sbr->bs_limiter_gains  = 2;

+        sbr->bs_interpol_freq  = 1;

+        sbr->bs_smoothing_mode = 1;

+    }

+

+    if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)

+        sbr_make_f_tablelim(sbr);

+

+    return get_bits_count(gb) - cnt;

+}

+

+static int array_min_int16(const int16_t *array, int nel)

+{

+    int i, min = array[0];

+    for (i = 1; i < nel; i++)

+        min = FFMIN(array[i], min);

+    return min;

+}

+

+static void make_bands(int16_t* bands, int start, int stop, int num_bands)

+{

+    int k, previous, present;

+    float base, prod;

+

+    base = powf((float)stop / start, 1.0f / num_bands);

+    prod = start;

+    previous = start;

+

+    for (k = 0; k < num_bands-1; k++) {

+        prod *= base;

+        present  = lrintf(prod);

+        bands[k] = present - previous;

+        previous = present;

+    }

+    bands[num_bands-1] = stop - previous;

+}

+

+static int check_n_master(AVCodecContext *avccontext, int n_master, int bs_xover_band)

+{

+    // Requirements (14496-3 sp04 p205)

+    if (n_master <= 0) {

+        av_log(avccontext, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);

+        return -1;

+    }

+    if (bs_xover_band >= n_master) {

+        av_log(avccontext, AV_LOG_ERROR,

+               "Invalid bitstream, crossover band index beyond array bounds: %d\n",

+               bs_xover_band);

+        return -1;

+    }

+    return 0;

+}

+

+/// Master Frequency Band Table (14496-3 sp04 p194)

+static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,

+                             SpectrumParameters *spectrum)

+{

+    unsigned int temp, max_qmf_subbands;

+    unsigned int start_min, stop_min;

+    int k;

+    const int8_t *sbr_offset_ptr;

+    int16_t stop_dk[13];

+

+    if (sbr->sample_rate < 32000) {

+        temp = 3000;

+    } else if (sbr->sample_rate < 64000) {

+        temp = 4000;

+    } else

+        temp = 5000;

+

+    start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;

+    stop_min  = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;

+

+    switch (sbr->sample_rate) {

+    case 16000:

+        sbr_offset_ptr = sbr_offset[0];

+        break;

+    case 22050:

+        sbr_offset_ptr = sbr_offset[1];

+        break;

+    case 24000:

+        sbr_offset_ptr = sbr_offset[2];

+        break;

+    case 32000:

+        sbr_offset_ptr = sbr_offset[3];

+        break;

+    case 44100: case 48000: case 64000:

+        sbr_offset_ptr = sbr_offset[4];

+        break;

+    case 88200: case 96000: case 128000: case 176400: case 192000:

+        sbr_offset_ptr = sbr_offset[5];

+        break;

+    default:

+        av_log(ac->avccontext, AV_LOG_ERROR,

+               "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);

+        return -1;

+    }

+

+    sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];

+

+    if (spectrum->bs_stop_freq < 14) {

+        sbr->k[2] = stop_min;

+        make_bands(stop_dk, stop_min, 64, 13);

+        qsort(stop_dk, 13, sizeof(stop_dk[0]), qsort_comparison_function_int16);

+        for (k = 0; k < spectrum->bs_stop_freq; k++)

+            sbr->k[2] += stop_dk[k];

+    } else if (spectrum->bs_stop_freq == 14) {

+        sbr->k[2] = 2*sbr->k[0];

+    } else if (spectrum->bs_stop_freq == 15) {

+        sbr->k[2] = 3*sbr->k[0];

+    } else {

+        av_log(ac->avccontext, AV_LOG_ERROR,

+               "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);

+        return -1;

+    }

+    sbr->k[2] = FFMIN(64, sbr->k[2]);

+

+    // Requirements (14496-3 sp04 p205)

+    if (sbr->sample_rate <= 32000) {

+        max_qmf_subbands = 48;

+    } else if (sbr->sample_rate == 44100) {

+        max_qmf_subbands = 35;

+    } else if (sbr->sample_rate >= 48000)

+        max_qmf_subbands = 32;

+

+    if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {

+        av_log(ac->avccontext, AV_LOG_ERROR,

+               "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);

+        return -1;

+    }

+

+    if (!spectrum->bs_freq_scale) {

+        unsigned int dk;

+        int k2diff;

+

+        dk = spectrum->bs_alter_scale + 1;

+        sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;

+        if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))

+            return -1;

+

+        for (k = 1; k <= sbr->n_master; k++)

+            sbr->f_master[k] = dk;

+

+        k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;

+        if (k2diff < 0) {

+            sbr->f_master[1]--;

+            sbr->f_master[2]-= (k2diff < 1);

+        } else if (k2diff) {

+            sbr->f_master[sbr->n_master]++;

+        }

+

+        sbr->f_master[0] = sbr->k[0];

+        for (k = 1; k <= sbr->n_master; k++)

+            sbr->f_master[k] += sbr->f_master[k - 1];

+

+    } else {

+        int half_bands = 7 - spectrum->bs_freq_scale;      // bs_freq_scale  = {1,2,3}

+        int two_regions, num_bands_0;

+        int vdk0_max, vdk1_min;

+        int16_t vk0[49];

+

+        if (49 * sbr->k[2] > 110 * sbr->k[0]) {

+            two_regions = 1;

+            sbr->k[1] = 2 * sbr->k[0];

+        } else {

+            two_regions = 0;

+            sbr->k[1] = sbr->k[2];

+        }

+

+        num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;

+

+        if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)

+            av_log(ac->avccontext, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);

+            return -1;

+        }

+

+        vk0[0] = 0;

+

+        make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);

+

+        qsort(vk0 + 1, num_bands_0, sizeof(vk0[1]), qsort_comparison_function_int16);

+        vdk0_max = vk0[num_bands_0];

+

+        vk0[0] = sbr->k[0];

+        for (k = 1; k <= num_bands_0; k++) {

+            if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)

+                av_log(ac->avccontext, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);

+                return -1;

+            }

+            vk0[k] += vk0[k-1];

+        }

+

+        if (two_regions) {

+            int16_t vk1[49];

+            float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f

+                                                     : 1.0f; // bs_alter_scale = {0,1}

+            int num_bands_1 = lrintf(half_bands * invwarp *

+                                     log2f(sbr->k[2] / (float)sbr->k[1])) * 2;

+

+            make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);

+

+            vdk1_min = array_min_int16(vk1 + 1, num_bands_1);

+

+            if (vdk1_min < vdk0_max) {

+                int change;

+                qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);

+                change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);

+                vk1[1]           += change;

+                vk1[num_bands_1] -= change;

+            }

+

+            qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);

+

+            vk1[0] = sbr->k[1];

+            for (k = 1; k <= num_bands_1; k++) {

+                if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)

+                    av_log(ac->avccontext, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);

+                    return -1;

+                }

+                vk1[k] += vk1[k-1];

+            }

+

+            sbr->n_master = num_bands_0 + num_bands_1;

+            if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))

+                return -1;

+            memcpy(&sbr->f_master[0],               vk0,

+                   (num_bands_0 + 1) * sizeof(sbr->f_master[0]));

+            memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,

+                    num_bands_1      * sizeof(sbr->f_master[0]));

+

+        } else {

+            sbr->n_master = num_bands_0;

+            if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))

+                return -1;

+            memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));

+        }

+    }

+

+    return 0;

+}

+

+/// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)

+static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)

+{

+    int i, k, sb = 0;

+    int msb = sbr->k[0];

+    int usb = sbr->kx[1];

+    int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;

+

+    sbr->num_patches = 0;

+

+    if (goal_sb < sbr->kx[1] + sbr->m[1]) {

+        for (k = 0; sbr->f_master[k] < goal_sb; k++) ;

+    } else

+        k = sbr->n_master;

+

+    do {

+        int odd = 0;

+        for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {

+            sb = sbr->f_master[i];

+            odd = (sb + sbr->k[0]) & 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] > 0) {

+            usb = sb;

+            msb = sb;

+            sbr->num_patches++;

+        } else

+            msb = sbr->kx[1];

+

+        if (sbr->f_master[k] - sb < 3)

+            k = sbr->n_master;

+    } while (sb != sbr->kx[1] + sbr->m[1]);

+

+    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;

+}

+

+/// Derived Frequency Band Tables (14496-3 sp04 p197)

+static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)

+{

+    int k, temp;

+

+    sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;

+    sbr->n[0] = (sbr->n[1] + 1) >> 1;

+

+    memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],

+           (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));

+    sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];

+    sbr->kx[1] = sbr->f_tablehigh[0];

+

+    // Requirements (14496-3 sp04 p205)

+    if (sbr->kx[1] + sbr->m[1] > 64) {

+        av_log(ac->avccontext, AV_LOG_ERROR,

+               "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);

+        return -1;

+    }

+    if (sbr->kx[1] > 32) {

+        av_log(ac->avccontext, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);

+        return -1;

+    }

+

+    sbr->f_tablelow[0] = sbr->f_tablehigh[0];

+    temp = sbr->n[1] & 1;

+    for (k = 1; k <= sbr->n[0]; k++)

+        sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];

+

+    sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands *

+                               log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3

+    if (sbr->n_q > 5) {

+        av_log(ac->avccontext, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);

+        return -1;

+    }

+

+    sbr->f_tablenoise[0] = sbr->f_tablelow[0];

+    temp = 0;

+    for (k = 1; k <= sbr->n_q; k++) {

+        temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);

+        sbr->f_tablenoise[k] = sbr->f_tablelow[temp];

+    }

+

+    if (sbr_hf_calc_npatches(ac, sbr) < 0)

+        return -1;

+

+    sbr_make_f_tablelim(sbr);

+

+    sbr->data[0].f_indexnoise = 0;

+    sbr->data[1].f_indexnoise = 0;

+

+    return 0;

+}

+

+static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec,

+                                              int elements)

+{

+    int i;

+    for (i = 0; i < elements; i++) {

+        vec[i] = get_bits1(gb);

+    }

+}

+

+/** ceil(log2(index+1)) */

+static const int8_t ceil_log2[] = {

+    0, 1, 2, 2, 3, 3,

+};

+

+static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,

+                         GetBitContext *gb, SBRData *ch_data)

+{

+    int i;

+

+    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_amp_res = sbr->bs_amp_res_header;

+

+    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_amp_res = 0;

+

+        ch_data->bs_freq_res[1] = get_bits1(gb);

+        for (i = 1; i < ch_data->bs_num_env[1]; i++)