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

 - CODEC_CAP_EXPERIMENTAL added

 - Demuxer for On2's IVF format

 - Pictor/PC Paint decoder

+- HE-AAC v2 decoder

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

 OBJS-$(CONFIG_VDPAU)                   += vdpau.o

 # decoders/encoders/hardware accelerators

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

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

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

                                           aacpsy.o aactab.o      \

                                           psymodel.o iirfilter.o \

@@ -667,5 +667,6 @@ $(SUBDIR)mpegaudiodec.o: $(SUBDIR)mpegaudio_tables.h

 $(SUBDIR)mpegaudiodec_float.o: $(SUBDIR)mpegaudio_tables.h

 $(SUBDIR)motionpixels.o: $(SUBDIR)motionpixels_tables.h

 $(SUBDIR)pcm.o: $(SUBDIR)pcm_tables.h

+$(SUBDIR)ps.o: $(SUBDIR)ps_tables.h

 $(SUBDIR)qdm2.o: $(SUBDIR)qdm2_tables.h

 endif

@@ -67,7 +67,7 @@

  * Y (not in this code) Layer-2

  * Y (not in this code) Layer-3

  * N                    SinuSoidal Coding (Transient, Sinusoid, Noise)

- * N (planned)          Parametric Stereo

+ * Y                    Parametric Stereo

  * N                    Direct Stream Transfer

  *

  * Note: - HE AAC v1 comprises LC AAC with Spectral Band Replication.

@@ -200,7 +200,8 @@ static av_cold int che_configure(AACContext *ac,

         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) {

+            if (type == TYPE_CPE ||

+                (type == TYPE_SCE && ac->m4ac.ps == 1)) {

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

             }

         }

@@ -228,6 +229,7 @@ static av_cold int output_configure(AACContext *ac,

     AVCodecContext *avctx = ac->avctx;

     int i, type, channels = 0, ret;

+    if (new_che_pos != che_pos)

     memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));

     if (channel_config) {

@@ -471,6 +473,8 @@ static int decode_audio_specific_config(AACContext *ac, void *data,

         av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);

         return -1;

     }

+    if (ac->m4ac.sbr == 1 && ac->m4ac.ps == -1)

+        ac->m4ac.ps = 1;

     skip_bits_long(&gb, i);

@@ -1667,6 +1671,10 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,

             av_log(ac->avctx, 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 if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) {

+            ac->m4ac.sbr = 1;

+            ac->m4ac.ps = 1;

+            output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured);

         } else {

             ac->m4ac.sbr = 1;

         }

@@ -1946,8 +1954,10 @@ static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)

         } else if (ac->output_configured != OC_LOCKED) {

             ac->output_configured = OC_NONE;

         }

-        if (ac->output_configured != OC_LOCKED)

+        if (ac->output_configured != OC_LOCKED) {

             ac->m4ac.sbr = -1;

+            ac->m4ac.ps  = -1;

+        }

         ac->m4ac.sample_rate     = hdr_info.sample_rate;

         ac->m4ac.sampling_index  = hdr_info.sampling_index;

         ac->m4ac.object_type     = hdr_info.object_type;

@@ -31,6 +31,7 @@

 #include "aacsbr.h"

 #include "aacsbrdata.h"

 #include "fft.h"

+#include "ps.h"

 #include <stdint.h>

 #include <float.h>

@@ -120,6 +121,8 @@ av_cold void ff_aac_sbr_init(void)

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

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

+

+    ff_ps_init();

 }

 av_cold void ff_aac_sbr_ctx_init(SpectralBandReplication *sbr)

@@ -130,6 +133,7 @@ av_cold void ff_aac_sbr_ctx_init(SpectralBandReplication *sbr)

     sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);

     ff_mdct_init(&sbr->mdct, 7, 1, 1.0/64);

     ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0);

+    ff_ps_ctx_init(&sbr->ps);

 }

 av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)

@@ -890,7 +894,6 @@ static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,

                                GetBitContext *gb,

                                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) {

@@ -898,8 +901,8 @@ static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,

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

+#if 1

+            *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps, *num_bits_left);

 #else

             av_log_missing_feature(ac->avctx, "Parametric Stereo is", 0);

             skip_bits_long(gb, *num_bits_left); // bs_fill_bits

@@ -1008,6 +1011,11 @@ static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,

             num_bits_left -= 2;

             read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id

         }

+        if (num_bits_left < 0) {

+            av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");

+        }

+        if (num_bits_left > 0)

+            skip_bits(gb, num_bits_left);

     }

     return get_bits_count(gb) - cnt;

@@ -1166,7 +1174,7 @@ static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in,

  * (14496-3 sp04 p206)

  */

 static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,

-                              float *out, float X[2][32][64],

+                              float *out, float X[2][38][64],

                               float mdct_buf[2][64],

                               float *v0, int *v_off, const unsigned int div,

                               float bias, float scale)

@@ -1402,7 +1410,7 @@ static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,

 }

 /// Generate the subband filtered lowband

-static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][32][64],

+static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64],

                      const float X_low[32][40][2], const float Y[2][38][64][2],

                      int ch)

 {

@@ -1424,7 +1432,7 @@ static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][32][64],

     }

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

-        for (i = i_Temp; i < i_f; i++) {

+        for (i = i_Temp; i < 38; i++) {

             X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];

             X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];

         }

@@ -1740,6 +1748,16 @@ void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,

         /* synthesis */

         sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);

     }

+

+    if (ac->m4ac.ps == 1) {

+        if (sbr->ps.start) {

+            ff_ps_apply(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);

+        } else {

+            memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));

+        }

+        nch = 2;

+    }

+

     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,

@@ -30,7 +30,7 @@

 #include "libavutil/avutil.h"

 #define LIBAVCODEC_VERSION_MAJOR 52

-#define LIBAVCODEC_VERSION_MINOR 76

+#define LIBAVCODEC_VERSION_MINOR 77

 #define LIBAVCODEC_VERSION_MICRO  0

 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

@@ -131,6 +131,14 @@ int ff_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int buf_si

                 get_bits1(&gb); // skip 1 bit

         }

     }

+

+    //PS requires SBR

+    if (!c->sbr)

+        c->ps = 0;

+    //Limit implicit PS to the HE-AACv2 Profile

+    if ((c->ps == -1 && c->object_type != AOT_AAC_LC) || c->channels & ~0x01)

+        c->ps = 0;

+

     return specific_config_bitindex;

 }

new file mode 100644

@@ -0,0 +1,1124 @@

+/*

+ * MPEG-4 Parametric Stereo decoding functions

+ * Copyright (c) 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

+ */

+

+#include <stdint.h>

+#include "libavutil/mathematics.h"

+#include "avcodec.h"

+#include "get_bits.h"

+#include "ps.h"

+#include "ps_tablegen.h"

+#include "psdata.c"

+

+#define PS_BASELINE 0

+

+#define numQMFSlots 32 //numTimeSlots * RATE

+

+static const int8_t num_env_tab[2][4] = {

+    { 0, 1, 2, 4, },

+    { 1, 2, 3, 4, },

+};

+

+static const int8_t nr_iidicc_par_tab[] = {

+    10, 20, 34, 10, 20, 34,

+};

+

+static const int8_t nr_iidopd_par_tab[] = {

+     5, 11, 17,  5, 11, 17,

+};

+

+enum {

+    huff_iid_df1,

+    huff_iid_dt1,

+    huff_iid_df0,

+    huff_iid_dt0,

+    huff_icc_df,

+    huff_icc_dt,

+    huff_ipd_df,

+    huff_ipd_dt,

+    huff_opd_df,

+    huff_opd_dt,

+};

+

+static const int huff_iid[] = {

+    huff_iid_df0,

+    huff_iid_df1,

+    huff_iid_dt0,

+    huff_iid_dt1,

+};

+

+static VLC vlc_ps[10];

+

+/**

+ * Read Inter-channel Intensity Difference parameters from the bitstream.

+ *

+ * @param avctx contains the current codec context

+ * @param gb    pointer to the input bitstream

+ * @param ps    pointer to the Parametric Stereo context

+ * @param e     envelope to decode

+ * @param dt    1: time delta-coded, 0: frequency delta-coded

+ */

+static int iid_data(AVCodecContext *avctx, GetBitContext *gb, PSContext *ps, int e, int dt)

+{

+    int b;

+    int table_idx = huff_iid[2*dt+ps->iid_quant];

+    VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table;

+    if (dt) {

+        int e_prev = e ? e - 1 : ps->num_env_old - 1;

+        e_prev = FFMAX(e_prev, 0);

+        for (b = 0; b < ps->nr_iid_par; b++) {

+            ps->iid_par[e][b] = ps->iid_par[e_prev][b] +

+                                get_vlc2(gb, vlc_table, 9, 3) -

+                                huff_offset[table_idx];

+            if (FFABS(ps->iid_par[e][b]) > 7 + 8 * ps->iid_quant)

+                goto err;

+        }

+    } else {

+        int prev = 0;

+        for (b = 0; b < ps->nr_iid_par; b++) {

+            prev += get_vlc2(gb, vlc_table, 9, 3) -

+                    huff_offset[table_idx];

+            ps->iid_par[e][b] = prev;

+            if (FFABS(ps->iid_par[e][b]) > 7 + 8 * ps->iid_quant)

+                goto err;

+        }

+    }

+    return 0;

+err:

+    av_log(avctx, AV_LOG_ERROR, "illegal iid\n");

+    return -1;

+}

+

+/**

+ * Read Inter-Channel Coherence parameters from the bitstream.

+ *

+ * @param avctx contains the current codec context

+ * @param gb    pointer to the input bitstream

+ * @param ps    pointer to the Parametric Stereo context

+ * @param e     envelope to decode

+ * @param dt    1: time delta-coded, 0: frequency delta-coded

+ */

+static int icc_data(AVCodecContext *avctx, GetBitContext *gb, PSContext *ps, int e, int dt)

+{

+    int b;

+    int table_idx = dt ? huff_icc_dt : huff_icc_df;

+    VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table;

+    if (dt) {

+        int e_prev = e ? e - 1 : ps->num_env_old - 1;

+        e_prev = FFMAX(e_prev, 0);

+        for (b = 0; b < ps->nr_icc_par; b++) {

+            ps->icc_par[e][b] = ps->icc_par[e_prev][b] + get_vlc2(gb, vlc_table, 9, 3) - huff_offset[table_idx];

+            if (ps->icc_par[e][b] > 7U)

+                goto err;

+        }

+    } else {

+        int prev = 0;

+        for (b = 0; b < ps->nr_icc_par; b++) {

+            prev += get_vlc2(gb, vlc_table, 9, 3) - huff_offset[table_idx];

+            ps->icc_par[e][b] = prev;

+            if (ps->icc_par[e][b] > 7U)

+                goto err;

+        }

+    }

+    return 0;

+err:

+    av_log(avctx, AV_LOG_ERROR, "illegal icc\n");

+    return -1;

+}

+

+/**

+ * Read Inter-channel Phase Difference parameters from the bitstream.

+ *

+ * @param gb    pointer to the input bitstream

+ * @param ps    pointer to the Parametric Stereo context

+ * @param e     envelope to decode

+ * @param dt    1: time delta-coded, 0: frequency delta-coded

+ */

+static void ipd_data(GetBitContext *gb, PSContext *ps, int e, int dt)

+{

+    int b;

+    int table_idx = dt ? huff_ipd_dt : huff_ipd_df;

+    VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table;

+    if (dt) {

+        int e_prev = e ? e - 1 : ps->num_env_old - 1;

+        e_prev = FFMAX(e_prev, 0);

+        for (b = 0; b < ps->nr_ipdopd_par; b++) {

+            ps->ipd_par[e][b] = (ps->ipd_par[e_prev][b] + get_vlc2(gb, vlc_table, 9, 1)) & 0x07;

+        }

+    } else {

+        int prev = 0;

+        for (b = 0; b < ps->nr_ipdopd_par; b++) {

+            prev += get_vlc2(gb, vlc_table, 9, 3);

+            prev &= 0x07;

+            ps->ipd_par[e][b] = prev;

+        }

+    }

+}

+

+/**

+ * Read Overall Phase Difference parameters from the bitstream.

+ *

+ * @param gb    pointer to the input bitstream

+ * @param ps    pointer to the Parametric Stereo context

+ * @param e     envelope to decode

+ * @param dt    1: time delta-coded, 0: frequency delta-coded

+ */

+static void opd_data(GetBitContext *gb, PSContext *ps, int e, int dt)

+{

+    int b;

+    int table_idx = dt ? huff_opd_dt : huff_opd_df;

+    VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table;

+    if (dt) {

+        int e_prev = e ? e - 1 : ps->num_env_old - 1;

+        e_prev = FFMAX(e_prev, 0);

+        for (b = 0; b < ps->nr_ipdopd_par; b++) {

+            ps->opd_par[e][b] = (ps->opd_par[e_prev][b] + get_vlc2(gb, vlc_table, 9, 1)) & 0x07;

+        }

+    } else {

+        int prev = 0;

+        for (b = 0; b < ps->nr_ipdopd_par; b++) {

+            prev += get_vlc2(gb, vlc_table, 9, 3);

+            prev &= 0x07;

+            ps->opd_par[e][b] = prev;

+        }

+    }

+}

+

+static int ps_extension(GetBitContext *gb, PSContext *ps, int ps_extension_id)

+{

+    int e;

+    int count = get_bits_count(gb);

+

+    if (ps_extension_id)

+        return 0;

+

+    ps->enable_ipdopd = get_bits1(gb);

+    if (ps->enable_ipdopd) {

+        for (e = 0; e < ps->num_env; e++) {

+            int dt = get_bits1(gb);

+            ipd_data(gb, ps, e, dt);

+            dt = get_bits1(gb);

+            opd_data(gb, ps, e, dt);

+        }

+    }

+    skip_bits1(gb);      //reserved_ps

+    return get_bits_count(gb) - count;

+}

+

+static void ipdopd_reset(int8_t *opd_hist, int8_t *ipd_hist)

+{

+    int i;

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

+        opd_hist[i] = 0;

+        ipd_hist[i] = 0;

+    }

+}

+

+int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps, int bits_left)

+{

+    int e;

+    int bit_count_start = get_bits_count(gb_host);

+    int header;

+    int bits_consumed;

+    GetBitContext gbc = *gb_host, *gb = &gbc;

+

+    header = get_bits1(gb);

+    if (header) {     //enable_ps_header

+        ps->enable_iid = get_bits1(gb);

+        if (ps->enable_iid) {

+            ps->iid_mode = get_bits(gb, 3);

+            if (ps->iid_mode > 5) {

+                av_log(avctx, AV_LOG_ERROR, "iid_mode %d is reserved.\n",

+                       ps->iid_mode);

+                goto err;

+            }

+            ps->nr_iid_par    = nr_iidicc_par_tab[ps->iid_mode];

+            ps->iid_quant     = ps->iid_mode > 2;

+            ps->nr_ipdopd_par = nr_iidopd_par_tab[ps->iid_mode];

+        }

+        ps->enable_icc = get_bits1(gb);

+        if (ps->enable_icc) {

+            ps->icc_mode = get_bits(gb, 3);

+            if (ps->icc_mode > 5) {

+                av_log(avctx, AV_LOG_ERROR, "icc_mode %d is reserved.\n",

+                       ps->icc_mode);

+                goto err;

+            }

+            ps->nr_icc_par = nr_iidicc_par_tab[ps->icc_mode];

+        }

+        ps->enable_ext = get_bits1(gb);

+    }

+

+    ps->frame_class = get_bits1(gb);

+    ps->num_env_old = ps->num_env;

+    ps->num_env     = num_env_tab[ps->frame_class][get_bits(gb, 2)];

+

+    ps->border_position[0] = -1;

+    if (ps->frame_class) {

+        for (e = 1; e <= ps->num_env; e++)

+            ps->border_position[e] = get_bits(gb, 5);

+    } else

+        for (e = 1; e <= ps->num_env; e++)

+            ps->border_position[e] = e * numQMFSlots / ps->num_env - 1;

+

+    if (ps->enable_iid) {

+        for (e = 0; e < ps->num_env; e++) {

+            int dt = get_bits1(gb);

+            if (iid_data(avctx, gb, ps, e, dt))

+                goto err;

+        }

+    } else

+        memset(ps->iid_par, 0, sizeof(ps->iid_par));

+

+    if (ps->enable_icc)

+        for (e = 0; e < ps->num_env; e++) {

+            int dt = get_bits1(gb);

+            if (icc_data(avctx, gb, ps, e, dt))

+                goto err;

+        }

+    else

+        memset(ps->icc_par, 0, sizeof(ps->icc_par));

+

+    if (ps->enable_ext) {

+        int cnt = get_bits(gb, 4);

+        if (cnt == 15) {

+            cnt += get_bits(gb, 8);

+        }

+        cnt *= 8;

+        while (cnt > 7) {

+            int ps_extension_id = get_bits(gb, 2);

+            cnt -= 2 + ps_extension(gb, ps, ps_extension_id);

+        }

+        if (cnt < 0) {

+            av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d", cnt);

+            goto err;

+        }

+        skip_bits(gb, cnt);

+    }

+

+    ps->enable_ipdopd &= !PS_BASELINE;

+

+    //Fix up envelopes

+    if (!ps->num_env || ps->border_position[ps->num_env] < numQMFSlots - 1) {

+        //Create a fake envelope

+        int source = ps->num_env ? ps->num_env - 1 : ps->num_env_old - 1;

+        if (source >= 0 && source != ps->num_env) {

+            if (ps->enable_iid && ps->num_env_old > 1) {

+                memcpy(ps->iid_par+ps->num_env, ps->iid_par+source, sizeof(ps->iid_par[0]));

+            }

+            if (ps->enable_icc && ps->num_env_old > 1) {

+                memcpy(ps->icc_par+ps->num_env, ps->icc_par+source, sizeof(ps->icc_par[0]));

+            }

+            if (ps->enable_ipdopd && ps->num_env_old > 1) {

+                memcpy(ps->ipd_par+ps->num_env, ps->ipd_par+source, sizeof(ps->ipd_par[0]));

+                memcpy(ps->opd_par+ps->num_env, ps->opd_par+source, sizeof(ps->opd_par[0]));

+            }

+        }

+        ps->num_env++;

+        ps->border_position[ps->num_env] = numQMFSlots - 1;

+    }

+

+

+    ps->is34bands_old = ps->is34bands;

+    if (!PS_BASELINE && (ps->enable_iid || ps->enable_icc))

+        ps->is34bands = (ps->enable_iid && ps->nr_iid_par == 34) ||

+                        (ps->enable_icc && ps->nr_icc_par == 34);

+

+    //Baseline

+    if (!ps->enable_ipdopd) {

+        memset(ps->ipd_par, 0, sizeof(ps->ipd_par));

+        memset(ps->opd_par, 0, sizeof(ps->opd_par));

+    }

+

+    if (header)

+        ps->start = 1;

+

+    bits_consumed = get_bits_count(gb) - bit_count_start;

+    if (bits_consumed <= bits_left) {

+        skip_bits_long(gb_host, bits_consumed);

+        return bits_consumed;

+    }

+    av_log(avctx, AV_LOG_ERROR, "Expected to read %d PS bits actually read %d.\n", bits_left, bits_consumed);

+err:

+    ps->start = 0;

+    skip_bits_long(gb_host, bits_left);

+    return bits_left;

+}

+

+/** Split one subband into 2 subsubbands with a symmetric real filter.

+ * The filter must have its non-center even coefficients equal to zero. */

+static void hybrid2_re(float (*in)[2], float (*out)[32][2], const float filter[7], int len, int reverse)

+{

+    int i, j;

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

+        float re_in = filter[6] * in[6+i][0];        //real inphase

+        float re_op = 0.0f;                          //real out of phase

+        float im_in = filter[6] * in[6+i][1];        //imag inphase

+        float im_op = 0.0f;                          //imag out of phase

+        for (j = 0; j < 6; j += 2) {

+            re_op += filter[j+1] * (in[i+j+1][0] + in[12-j-1+i][0]);

+            im_op += filter[j+1] * (in[i+j+1][1] + in[12-j-1+i][1]);

+        }

+        out[ reverse][i][0] = re_in + re_op;

+        out[ reverse][i][1] = im_in + im_op;

+        out[!reverse][i][0] = re_in - re_op;

+        out[!reverse][i][1] = im_in - im_op;

+    }

+}

+

+/** Split one subband into 6 subsubbands with a complex filter */

+static void hybrid6_cx(float (*in)[2], float (*out)[32][2], const float (*filter)[7][2], int len)

+{

+    int i, j, ssb;

+    int N = 8;

+    float temp[8][2];

+

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

+        for (ssb = 0; ssb < N; ssb++) {

+            float sum_re = filter[ssb][6][0] * in[i+6][0], sum_im = filter[ssb][6][0] * in[i+6][1];

+            for (j = 0; j < 6; j++) {

+                float in0_re = in[i+j][0];

+                float in0_im = in[i+j][1];

+                float in1_re = in[i+12-j][0];

+                float in1_im = in[i+12-j][1];

+                sum_re += filter[ssb][j][0] * (in0_re + in1_re) - filter[ssb][j][1] * (in0_im - in1_im);

+                sum_im += filter[ssb][j][0] * (in0_im + in1_im) + filter[ssb][j][1] * (in0_re - in1_re);

+            }

+            temp[ssb][0] = sum_re;

+            temp[ssb][1] = sum_im;

+        }

+        out[0][i][0] = temp[6][0];

+        out[0][i][1] = temp[6][1];

+        out[1][i][0] = temp[7][0];

+        out[1][i][1] = temp[7][1];

+        out[2][i][0] = temp[0][0];

+        out[2][i][1] = temp[0][1];

+        out[3][i][0] = temp[1][0];

+        out[3][i][1] = temp[1][1];

+        out[4][i][0] = temp[2][0] + temp[5][0];

+        out[4][i][1] = temp[2][1] + temp[5][1];

+        out[5][i][0] = temp[3][0] + temp[4][0];

+        out[5][i][1] = temp[3][1] + temp[4][1];

+    }

+}

+

+static void hybrid4_8_12_cx(float (*in)[2], float (*out)[32][2], const float (*filter)[7][2], int N, int len)

+{

+    int i, j, ssb;

+

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

+        for (ssb = 0; ssb < N; ssb++) {

+            float sum_re = filter[ssb][6][0] * in[i+6][0], sum_im = filter[ssb][6][0] * in[i+6][1];

+            for (j = 0; j < 6; j++) {

+                float in0_re = in[i+j][0];

+                float in0_im = in[i+j][1];

+                float in1_re = in[i+12-j][0];

+                float in1_im = in[i+12-j][1];

+                sum_re += filter[ssb][j][0] * (in0_re + in1_re) - filter[ssb][j][1] * (in0_im - in1_im);

+                sum_im += filter[ssb][j][0] * (in0_im + in1_im) + filter[ssb][j][1] * (in0_re - in1_re);

+            }

+            out[ssb][i][0] = sum_re;

+            out[ssb][i][1] = sum_im;

+        }

+    }

+}

+

+static void hybrid_analysis(float out[91][32][2], float in[5][44][2], float L[2][38][64], int is34, int len)

+{

+    int i, j;

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

+        for (j = 0; j < 38; j++) {

+            in[i][j+6][0] = L[0][j][i];

+            in[i][j+6][1] = L[1][j][i];

+        }

+    }

+    if(is34) {

+        hybrid4_8_12_cx(in[0], out,    f34_0_12, 12, len);

+        hybrid4_8_12_cx(in[1], out+12, f34_1_8,   8, len);

+        hybrid4_8_12_cx(in[2], out+20, f34_2_4,   4, len);

+        hybrid4_8_12_cx(in[3], out+24, f34_2_4,   4, len);

+        hybrid4_8_12_cx(in[4], out+28, f34_2_4,   4, len);

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

+            for (j = 0; j < len; j++) {

+                out[i+32][j][0] = L[0][j][i+5];

+                out[i+32][j][1] = L[1][j][i+5];

+            }

+        }

+    } else {

+        hybrid6_cx(in[0], out, f20_0_8, len);

+        hybrid2_re(in[1], out+6, g1_Q2, len, 1);

+        hybrid2_re(in[2], out+8, g1_Q2, len, 0);

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

+            for (j = 0; j < len; j++) {

+                out[i+10][j][0] = L[0][j][i+3];

+                out[i+10][j][1] = L[1][j][i+3];

+            }

+        }

+    }

+    //update in_buf

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

+        memcpy(in[i], in[i]+32, 6 * sizeof(in[i][0]));

+    }

+}

+

+static void hybrid_synthesis(float out[2][38][64], float in[91][32][2], int is34, int len)

+{

+    int i, n;

+    if(is34) {

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

+            memset(out[0][n], 0, 5*sizeof(out[0][n][0]));

+            memset(out[1][n], 0, 5*sizeof(out[1][n][0]));

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

+                out[0][n][0] += in[   i][n][0];

+                out[1][n][0] += in[   i][n][1];

+            }

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

+                out[0][n][1] += in[12+i][n][0];

+                out[1][n][1] += in[12+i][n][1];

+            }

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

+                out[0][n][2] += in[20+i][n][0];

+                out[1][n][2] += in[20+i][n][1];

+                out[0][n][3] += in[24+i][n][0];

+                out[1][n][3] += in[24+i][n][1];

+                out[0][n][4] += in[28+i][n][0];

+                out[1][n][4] += in[28+i][n][1];

+            }

+        }

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

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

+                out[0][n][i+5] = in[i+32][n][0];

+                out[1][n][i+5] = in[i+32][n][1];

+            }

+        }

+    } else {

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

+            out[0][n][0] = in[0][n][0] + in[1][n][0] + in[2][n][0] +

+                           in[3][n][0] + in[4][n][0] + in[5][n][0];

+            out[1][n][0] = in[0][n][1] + in[1][n][1] + in[2][n][1] +

+                           in[3][n][1] + in[4][n][1] + in[5][n][1];

+            out[0][n][1] = in[6][n][0] + in[7][n][0];

+            out[1][n][1] = in[6][n][1] + in[7][n][1];

+            out[0][n][2] = in[8][n][0] + in[9][n][0];

+            out[1][n][2] = in[8][n][1] + in[9][n][1];

+        }

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

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

+                out[0][n][i+3] = in[i+10][n][0];

+                out[1][n][i+3] = in[i+10][n][1];

+            }

+        }

+    }

+}

+

+/// All-pass filter decay slope

+#define DECAY_SLOPE      0.05f

+/// Number of frequency bands that can be addressed by the parameter index, b(k)

+static const int   NR_PAR_BANDS[]      = { 20, 34 };

+/// Number of frequency bands that can be addressed by the sub subband index, k

+static const int   NR_BANDS[]          = { 71, 91 };

+/// Start frequency band for the all-pass filter decay slope

+static const int   DECAY_CUTOFF[]      = { 10, 32 };

+/// Number of all-pass filer bands

+static const int   NR_ALLPASS_BANDS[]  = { 30, 50 };

+/// First stereo band using the short one sample delay

+static const int   SHORT_DELAY_BAND[]  = { 42, 62 };

+

+/** Table 8.46 */

+static void map_idx_10_to_20(int8_t *par_mapped, const int8_t *par, int full)

+{

+    int b;

+    if (full)

+        b = 9;

+    else {

+        b = 4;

+        par_mapped[10] = 0;

+    }

+    for (; b >= 0; b--) {

+        par_mapped[2*b+1] = par_mapped[2*b] = par[b];

+    }

+}

+

+static void map_idx_34_to_20(int8_t *par_mapped, const int8_t *par, int full)

+{

+    par_mapped[ 0] = (2*par[ 0] +   par[ 1]) / 3;

+    par_mapped[ 1] = (  par[ 1] + 2*par[ 2]) / 3;

+    par_mapped[ 2] = (2*par[ 3] +   par[ 4]) / 3;

+    par_mapped[ 3] = (  par[ 4] + 2*par[ 5]) / 3;

+    par_mapped[ 4] = (  par[ 6] +   par[ 7]) / 2;

+    par_mapped[ 5] = (  par[ 8] +   par[ 9]) / 2;

+    par_mapped[ 6] =    par[10];

+    par_mapped[ 7] =    par[11];

+    par_mapped[ 8] = (  par[12] +   par[13]) / 2;

+    par_mapped[ 9] = (  par[14] +   par[15]) / 2;

+    par_mapped[10] =    par[16];

+    if (full) {

+        par_mapped[11] =    par[17];

+        par_mapped[12] =    par[18];

+        par_mapped[13] =    par[19];

+        par_mapped[14] = (  par[20] +   par[21]) / 2;

+        par_mapped[15] = (  par[22] +   par[23]) / 2;

+        par_mapped[16] = (  par[24] +   par[25]) / 2;

+        par_mapped[17] = (  par[26] +   par[27]) / 2;

+        par_mapped[18] = (  par[28] +   par[29] +   par[30] +   par[31]) / 4;

+        par_mapped[19] = (  par[32] +   par[33]) / 2;

+    }

+}

+

+static void map_val_34_to_20(float par[PS_MAX_NR_IIDICC])

+{

+    par[ 0] = (2*par[ 0] +   par[ 1]) * 0.33333333f;

+    par[ 1] = (  par[ 1] + 2*par[ 2]) * 0.33333333f;

+    par[ 2] = (2*par[ 3] +   par[ 4]) * 0.33333333f;

+    par[ 3] = (  par[ 4] + 2*par[ 5]) * 0.33333333f;

+    par[ 4] = (  par[ 6] +   par[ 7]) * 0.5f;

+    par[ 5] = (  par[ 8] +   par[ 9]) * 0.5f;

+    par[ 6] =    par[10];

+    par[ 7] =    par[11];

+    par[ 8] = (  par[12] +   par[13]) * 0.5f;

+    par[ 9] = (  par[14] +   par[15]) * 0.5f;

+    par[10] =    par[16];

+    par[11] =    par[17];

+    par[12] =    par[18];

+    par[13] =    par[19];

+    par[14] = (  par[20] +   par[21]) * 0.5f;

+    par[15] = (  par[22] +   par[23]) * 0.5f;

+    par[16] = (  par[24] +   par[25]) * 0.5f;

+    par[17] = (  par[26] +   par[27]) * 0.5f;

+    par[18] = (  par[28] +   par[29] +   par[30] +   par[31]) * 0.25f;

+    par[19] = (  par[32] +   par[33]) * 0.5f;

+}

+

+static void map_idx_10_to_34(int8_t *par_mapped, const int8_t *par, int full)

+{

+    if (full) {

+        par_mapped[33] = par[9];

+        par_mapped[32] = par[9];

+        par_mapped[31] = par[9];

+        par_mapped[30] = par[9];

+        par_mapped[29] = par[9];

+        par_mapped[28] = par[9];

+        par_mapped[27] = par[8];

+        par_mapped[26] = par[8];

+        par_mapped[25] = par[8];

+        par_mapped[24] = par[8];

+        par_mapped[23] = par[7];

+        par_mapped[22] = par[7];

+        par_mapped[21] = par[7];

+        par_mapped[20] = par[7];

+        par_mapped[19] = par[6];

+        par_mapped[18] = par[6];

+        par_mapped[17] = par[5];

+        par_mapped[16] = par[5];

+    } else {

+        par_mapped[16] =      0;

+    }

+    par_mapped[15] = par[4];

+    par_mapped[14] = par[4];

+    par_mapped[13] = par[4];

+    par_mapped[12] = par[4];

+    par_mapped[11] = par[3];

+    par_mapped[10] = par[3];

+    par_mapped[ 9] = par[2];

+    par_mapped[ 8] = par[2];

+    par_mapped[ 7] = par[2];

+    par_mapped[ 6] = par[2];

+    par_mapped[ 5] = par[1];

+    par_mapped[ 4] = par[1];

+    par_mapped[ 3] = par[1];

+    par_mapped[ 2] = par[0];

+    par_mapped[ 1] = par[0];

+    par_mapped[ 0] = par[0];

+}

+

+static void map_idx_20_to_34(int8_t *par_mapped, const int8_t *par, int full)

+{

+    if (full) {

+        par_mapped[33] =  par[19];

+        par_mapped[32] =  par[19];

+        par_mapped[31] =  par[18];

+        par_mapped[30] =  par[18];

+        par_mapped[29] =  par[18];

+        par_mapped[28] =  par[18];

+        par_mapped[27] =  par[17];

+        par_mapped[26] =  par[17];

+        par_mapped[25] =  par[16];

+        par_mapped[24] =  par[16];

+        par_mapped[23] =  par[15];

+        par_mapped[22] =  par[15];

+        par_mapped[21] =  par[14];

+        par_mapped[20] =  par[14];

+        par_mapped[19] =  par[13];

+        par_mapped[18] =  par[12];