@@ -15,6 +15,7 @@ version <next>

 - aeval filter

 - stereoscopic 3d metadata handling

 - WebP encoding via libwebp

+- ATRAC3+ decoder

 version 2.1:

@@ -139,6 +139,7 @@ Codecs:

   ass*                                  Aurelien Jacobs

   asv*                                  Michael Niedermayer

   atrac3*                               Benjamin Larsson

+  atrac3plus*                           Maxim Poliakovski

   bgmc.c, bgmc.h                        Thilo Borgmann

   bink.c                                Kostya Shishkov

   binkaudio.c                           Peter Ross

@@ -1865,6 +1865,7 @@ asv2_decoder_select="dsputil"

 asv2_encoder_select="dsputil"

 atrac1_decoder_select="mdct sinewin"

 atrac3_decoder_select="mdct"

+atrac3p_decoder_select="mdct sinewin"

 avrn_decoder_select="exif"

 bink_decoder_select="dsputil hpeldsp"

 binkaudio_dct_decoder_select="mdct rdft dct sinewin"

@@ -833,6 +833,7 @@ following image formats are supported:

     @tab QuickTime fourcc 'alac'

 @item ATRAC1                 @tab     @tab  X

 @item ATRAC3                 @tab     @tab  X

+@item ATRAC3+                @tab     @tab  X

 @item Bink Audio             @tab     @tab  X

     @tab Used in Bink and Smacker files in many games.

 @item CELT                   @tab     @tab  E

@@ -124,6 +124,8 @@ OBJS-$(CONFIG_ASV2_DECODER)            += asvdec.o asv.o mpeg12data.o

 OBJS-$(CONFIG_ASV2_ENCODER)            += asvenc.o asv.o mpeg12data.o

 OBJS-$(CONFIG_ATRAC1_DECODER)          += atrac1.o atrac.o

 OBJS-$(CONFIG_ATRAC3_DECODER)          += atrac3.o atrac.o

+OBJS-$(CONFIG_ATRAC3P_DECODER)         += atrac3plusdec.o atrac3plus.o \

+                                          atrac3plusdsp.o atrac.o

 OBJS-$(CONFIG_AURA_DECODER)            += cyuv.o

 OBJS-$(CONFIG_AURA2_DECODER)           += aura.o

 OBJS-$(CONFIG_AVRN_DECODER)            += avrndec.o mjpegdec.o mjpeg.o

@@ -328,6 +328,7 @@ void avcodec_register_all(void)

     REGISTER_DECODER(APE,               ape);

     REGISTER_DECODER(ATRAC1,            atrac1);

     REGISTER_DECODER(ATRAC3,            atrac3);

+    REGISTER_DECODER(ATRAC3P,           atrac3p);

     REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);

     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);

     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);

new file mode 100644

@@ -0,0 +1,1813 @@

+/*

+ * ATRAC3+ compatible decoder

+ *

+ * Copyright (c) 2010-2013 Maxim Poliakovski

+ *

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

+ * Bitstream parser for ATRAC3+ decoder.

+ */

+

+#include "libavutil/avassert.h"

+#include "avcodec.h"

+#include "get_bits.h"

+#include "atrac3plus.h"

+#include "atrac3plus_data.h"

+

+static VLC_TYPE tables_data[154276][2];

+static VLC wl_vlc_tabs[4];

+static VLC sf_vlc_tabs[8];

+static VLC ct_vlc_tabs[4];

+static VLC spec_vlc_tabs[112];

+static VLC gain_vlc_tabs[11];

+static VLC tone_vlc_tabs[7];

+

+#define GET_DELTA(gb, delta_bits) \

+    ((delta_bits) ? get_bits((gb), (delta_bits)) : 0)

+

+/**

+ * Generate canonical VLC table from given descriptor.

+ *

+ * @param[in]     cb          ptr to codebook descriptor

+ * @param[in]     xlat        ptr to translation table or NULL

+ * @param[in,out] tab_offset  starting offset to the generated vlc table

+ * @param[out]    out_vlc     ptr to vlc table to be generated

+ */

+static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t *xlat,

+                                         int *tab_offset, VLC *out_vlc)

+{

+    int i, b;

+    uint16_t codes[256];

+    uint8_t bits[256];

+    unsigned code = 0;

+    int index = 0;

+    int min_len = *cb++; // get shortest codeword length

+    int max_len = *cb++; // get longest  codeword length

+

+    for (b = min_len; b <= max_len; b++) {

+        for (i = *cb++; i > 0; i--) {

+            av_assert0(index < 256);

+            bits[index]  = b;

+            codes[index] = code++;

+            index++;

+        }

+        code <<= 1;

+    }

+

+    out_vlc->table = &tables_data[*tab_offset];

+    out_vlc->table_allocated = 1 << max_len;

+

+    ff_init_vlc_sparse(out_vlc, max_len, index, bits, 1, 1, codes, 2, 2,

+                       xlat, 1, 1, INIT_VLC_USE_NEW_STATIC);

+

+    *tab_offset += 1 << max_len;

+}

+

+av_cold void ff_atrac3p_init_vlcs(void)

+{

+    int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;

+

+    static int wl_nb_bits[4]  = { 2, 3, 5, 5 };

+    static int wl_nb_codes[4] = { 3, 5, 8, 8 };

+    static const uint8_t *wl_bits[4] = {

+        atrac3p_wl_huff_bits1, atrac3p_wl_huff_bits2,

+        atrac3p_wl_huff_bits3, atrac3p_wl_huff_bits4

+    };

+    static const uint8_t *wl_codes[4] = {

+        atrac3p_wl_huff_code1, atrac3p_wl_huff_code2,

+        atrac3p_wl_huff_code3, atrac3p_wl_huff_code4

+    };

+    static const uint8_t *wl_xlats[4] = {

+        atrac3p_wl_huff_xlat1, atrac3p_wl_huff_xlat2, NULL, NULL

+    };

+

+    static int ct_nb_bits[4]  = { 3, 4, 4, 4 };

+    static int ct_nb_codes[4] = { 4, 8, 8, 8 };

+    static const uint8_t *ct_bits[4]  = {

+        atrac3p_ct_huff_bits1, atrac3p_ct_huff_bits2,

+        atrac3p_ct_huff_bits2, atrac3p_ct_huff_bits3

+    };

+    static const uint8_t *ct_codes[4] = {

+        atrac3p_ct_huff_code1, atrac3p_ct_huff_code2,

+        atrac3p_ct_huff_code2, atrac3p_ct_huff_code3

+    };

+    static const uint8_t *ct_xlats[4] = {

+        NULL, NULL, atrac3p_ct_huff_xlat1, NULL

+    };

+

+    static int sf_nb_bits[8]  = {  9,  9,  9,  9,  6,  6,  7,  7 };

+    static int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };

+    static const uint8_t  *sf_bits[8]  = {

+        atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits2,

+        atrac3p_sf_huff_bits3, atrac3p_sf_huff_bits4, atrac3p_sf_huff_bits4,

+        atrac3p_sf_huff_bits5, atrac3p_sf_huff_bits6

+    };

+    static const uint16_t *sf_codes[8] = {

+        atrac3p_sf_huff_code1, atrac3p_sf_huff_code1, atrac3p_sf_huff_code2,

+        atrac3p_sf_huff_code3, atrac3p_sf_huff_code4, atrac3p_sf_huff_code4,

+        atrac3p_sf_huff_code5, atrac3p_sf_huff_code6

+    };

+    static const uint8_t  *sf_xlats[8] = {

+        atrac3p_sf_huff_xlat1, atrac3p_sf_huff_xlat2, NULL, NULL,

+        atrac3p_sf_huff_xlat4, atrac3p_sf_huff_xlat5, NULL, NULL

+    };

+

+    static const uint8_t *gain_cbs[11] = {

+        atrac3p_huff_gain_npoints1_cb, atrac3p_huff_gain_npoints1_cb,

+        atrac3p_huff_gain_lev1_cb, atrac3p_huff_gain_lev2_cb,

+        atrac3p_huff_gain_lev3_cb, atrac3p_huff_gain_lev4_cb,

+        atrac3p_huff_gain_loc3_cb, atrac3p_huff_gain_loc1_cb,

+        atrac3p_huff_gain_loc4_cb, atrac3p_huff_gain_loc2_cb,

+        atrac3p_huff_gain_loc5_cb

+    };

+    static const uint8_t *gain_xlats[11] = {

+        NULL, atrac3p_huff_gain_npoints2_xlat, atrac3p_huff_gain_lev1_xlat,

+        atrac3p_huff_gain_lev2_xlat, atrac3p_huff_gain_lev3_xlat,

+        atrac3p_huff_gain_lev4_xlat, atrac3p_huff_gain_loc3_xlat,

+        atrac3p_huff_gain_loc1_xlat, atrac3p_huff_gain_loc4_xlat,

+        atrac3p_huff_gain_loc2_xlat, atrac3p_huff_gain_loc5_xlat

+    };

+

+    static const uint8_t *tone_cbs[7] = {

+        atrac3p_huff_tonebands_cb,  atrac3p_huff_numwavs1_cb,

+        atrac3p_huff_numwavs2_cb,   atrac3p_huff_wav_ampsf1_cb,

+        atrac3p_huff_wav_ampsf2_cb, atrac3p_huff_wav_ampsf3_cb,

+        atrac3p_huff_freq_cb

+    };

+    static const uint8_t *tone_xlats[7] = {

+        NULL, NULL, atrac3p_huff_numwavs2_xlat, atrac3p_huff_wav_ampsf1_xlat,

+        atrac3p_huff_wav_ampsf2_xlat, atrac3p_huff_wav_ampsf3_xlat,

+        atrac3p_huff_freq_xlat

+    };

+

+    for (i = 0, wl_vlc_offs = 0, ct_vlc_offs = 2508; i < 4; i++) {

+        wl_vlc_tabs[i].table = &tables_data[wl_vlc_offs];

+        wl_vlc_tabs[i].table_allocated = 1 << wl_nb_bits[i];

+        ct_vlc_tabs[i].table = &tables_data[ct_vlc_offs];

+        ct_vlc_tabs[i].table_allocated = 1 << ct_nb_bits[i];

+

+        ff_init_vlc_sparse(&wl_vlc_tabs[i], wl_nb_bits[i], wl_nb_codes[i],

+                           wl_bits[i],  1, 1,

+                           wl_codes[i], 1, 1,

+                           wl_xlats[i], 1, 1,

+                           INIT_VLC_USE_NEW_STATIC);

+

+        ff_init_vlc_sparse(&ct_vlc_tabs[i], ct_nb_bits[i], ct_nb_codes[i],

+                           ct_bits[i],  1, 1,

+                           ct_codes[i], 1, 1,

+                           ct_xlats[i], 1, 1,

+                           INIT_VLC_USE_NEW_STATIC);

+

+        wl_vlc_offs += wl_vlc_tabs[i].table_allocated;

+        ct_vlc_offs += ct_vlc_tabs[i].table_allocated;

+    }

+

+    for (i = 0, sf_vlc_offs = 76; i < 8; i++) {

+        sf_vlc_tabs[i].table = &tables_data[sf_vlc_offs];

+        sf_vlc_tabs[i].table_allocated = 1 << sf_nb_bits[i];

+

+        ff_init_vlc_sparse(&sf_vlc_tabs[i], sf_nb_bits[i], sf_nb_codes[i],

+                           sf_bits[i],  1, 1,

+                           sf_codes[i], 2, 2,

+                           sf_xlats[i], 1, 1,

+                           INIT_VLC_USE_NEW_STATIC);

+        sf_vlc_offs += sf_vlc_tabs[i].table_allocated;

+    }

+

+    tab_offset = 2564;

+

+    /* build huffman tables for spectrum decoding */

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

+        if (atrac3p_spectra_tabs[i].cb)

+            build_canonical_huff(atrac3p_spectra_tabs[i].cb,

+                                 atrac3p_spectra_tabs[i].xlat,

+                                 &tab_offset, &spec_vlc_tabs[i]);

+        else

+            spec_vlc_tabs[i].table = 0;

+    }

+

+    /* build huffman tables for gain data decoding */

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

+        build_canonical_huff(gain_cbs[i], gain_xlats[i], &tab_offset, &gain_vlc_tabs[i]);

+

+    /* build huffman tables for tone decoding */

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

+        build_canonical_huff(tone_cbs[i], tone_xlats[i], &tab_offset, &tone_vlc_tabs[i]);

+}

+

+/**

+ * Decode number of coded quantization units.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] chan          ptr to the channel parameters

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan,

+                           Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)

+{

+    chan->fill_mode = get_bits(gb, 2);

+    if (!chan->fill_mode) {

+        chan->num_coded_vals = ctx->num_quant_units;

+    } else {

+        chan->num_coded_vals = get_bits(gb, 5);

+        if (chan->num_coded_vals > ctx->num_quant_units) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "Invalid number of transmitted units!\n");

+            return AVERROR_INVALIDDATA;

+        }

+

+        if (chan->fill_mode == 3)

+            chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1;

+    }

+

+    return 0;

+}

+

+/**

+ * Add weighting coefficients to the decoded word-length information.

+ *

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in,out] chan          ptr to the channel parameters

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx,

+                               Atrac3pChanParams *chan, int wtab_idx,

+                               AVCodecContext *avctx)

+{

+    int i;

+    const int8_t *weights_tab =

+        &atrac3p_wl_weights[chan->ch_num * 3 + wtab_idx - 1][0];

+

+    for (i = 0; i < ctx->num_quant_units; i++) {

+        chan->qu_wordlen[i] += weights_tab[i];

+        if (chan->qu_wordlen[i] < 0 || chan->qu_wordlen[i] > 7) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "WL index out of range: pos=%d, val=%d!\n",

+                   i, chan->qu_wordlen[i]);

+            return AVERROR_INVALIDDATA;

+        }

+    }

+

+    return 0;

+}

+

+/**

+ * Subtract weighting coefficients from decoded scalefactors.

+ *

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in,out] chan          ptr to the channel parameters

+ * @param[in]     wtab_idx      index of table of weights

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx,

+                               Atrac3pChanParams *chan, int wtab_idx,

+                               AVCodecContext *avctx)

+{

+    int i;

+    const int8_t *weights_tab = &atrac3p_sf_weights[wtab_idx - 1][0];

+

+    for (i = 0; i < ctx->used_quant_units; i++) {

+        chan->qu_sf_idx[i] -= weights_tab[i];

+        if (chan->qu_sf_idx[i] < 0 || chan->qu_sf_idx[i] > 63) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "SF index out of range: pos=%d, val=%d!\n",

+                   i, chan->qu_sf_idx[i]);

+            return AVERROR_INVALIDDATA;

+        }

+    }

+

+    return 0;

+}

+

+/**

+ * Unpack vector quantization tables.

+ *

+ * @param[in]    start_val    start value for the unpacked table

+ * @param[in]    shape_vec    ptr to table to unpack

+ * @param[out]   dst          ptr to output array

+ * @param[in]    num_values   number of values to unpack

+ */

+static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec,

+                                   int *dst, int num_values)

+{

+    int i;

+

+    if (num_values) {

+        dst[0] = dst[1] = dst[2] = start_val;

+        for (i = 3; i < num_values; i++)

+            dst[i] = start_val - shape_vec[atrac3p_qu_num_to_seg[i] - 1];

+    }

+}

+

+#define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals)                            \

+    start_val = get_bits((gb), 6);                                       \

+    unpack_vq_shape(start_val, &atrac3p_sf_shapes[get_bits((gb), 6)][0], \

+                    (dst), (num_vals))

+

+/**

+ * Decode word length for each quantization unit of a channel.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     ch_num        channel to process

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                                  int ch_num, AVCodecContext *avctx)

+{

+    int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag,

+        ret, start_val;

+    VLC *vlc_tab;

+    Atrac3pChanParams *chan     = &ctx->channels[ch_num];

+    Atrac3pChanParams *ref_chan = &ctx->channels[0];

+

+    chan->fill_mode = 0;

+

+    switch (get_bits(gb, 2)) { /* switch according to coding mode */

+    case 0: /* coded using constant number of bits */

+        for (i = 0; i < ctx->num_quant_units; i++)

+            chan->qu_wordlen[i] = get_bits(gb, 3);

+        break;

+    case 1:

+        if (ch_num) {

+            if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)

+                return ret;

+

+            if (chan->num_coded_vals) {

+                vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];

+

+                for (i = 0; i < chan->num_coded_vals; i++) {

+                    delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                    chan->qu_wordlen[i] = (ref_chan->qu_wordlen[i] + delta) & 7;

+                }

+            }

+        } else {

+            weight_idx = get_bits(gb, 2);

+            if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)

+                return ret;

+

+            if (chan->num_coded_vals) {

+                pos = get_bits(gb, 5);

+                if (pos > chan->num_coded_vals) {

+                    av_log(avctx, AV_LOG_ERROR,

+                           "WL mode 1: invalid position!\n");

+                    return AVERROR_INVALIDDATA;

+                }

+

+                delta_bits = get_bits(gb, 2);

+                min_val    = get_bits(gb, 3);

+

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

+                    chan->qu_wordlen[i] = get_bits(gb, 3);

+

+                for (i = pos; i < chan->num_coded_vals; i++)

+                    chan->qu_wordlen[i] = (min_val + GET_DELTA(gb, delta_bits)) & 7;

+            }

+        }

+        break;

+    case 2:

+        if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)

+            return ret;

+

+        if (ch_num && chan->num_coded_vals) {

+            vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];

+            delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+            chan->qu_wordlen[0] = (ref_chan->qu_wordlen[0] + delta) & 7;

+

+            for (i = 1; i < chan->num_coded_vals; i++) {

+                diff = ref_chan->qu_wordlen[i] - ref_chan->qu_wordlen[i - 1];

+                delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + diff + delta) & 7;

+            }

+        } else if (chan->num_coded_vals) {

+            flag    = get_bits(gb, 1);

+            vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)];

+

+            start_val = get_bits(gb, 3);

+            unpack_vq_shape(start_val,

+                            &atrac3p_wl_shapes[start_val][get_bits(gb, 4)][0],

+                            chan->qu_wordlen, chan->num_coded_vals);

+

+            if (!flag) {

+                for (i = 0; i < chan->num_coded_vals; i++) {

+                    delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                    chan->qu_wordlen[i] = (chan->qu_wordlen[i] + delta) & 7;

+                }

+            } else {

+                for (i = 0; i < (chan->num_coded_vals & - 2); i += 2)

+                    if (!get_bits1(gb)) {

+                        chan->qu_wordlen[i]     = (chan->qu_wordlen[i] +

+                                                   get_vlc2(gb, vlc_tab->table,

+                                                            vlc_tab->bits, 1)) & 7;

+                        chan->qu_wordlen[i + 1] = (chan->qu_wordlen[i + 1] +

+                                                   get_vlc2(gb, vlc_tab->table,

+                                                            vlc_tab->bits, 1)) & 7;

+                    }

+

+                if (chan->num_coded_vals & 1)

+                    chan->qu_wordlen[i] = (chan->qu_wordlen[i] +

+                                           get_vlc2(gb, vlc_tab->table,

+                                                    vlc_tab->bits, 1)) & 7;

+            }

+        }

+        break;

+    case 3:

+        weight_idx = get_bits(gb, 2);

+        if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)

+            return ret;

+

+        if (chan->num_coded_vals) {

+            vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];

+

+            /* first coefficient is coded directly */

+            chan->qu_wordlen[0] = get_bits(gb, 3);

+

+            for (i = 1; i < chan->num_coded_vals; i++) {

+                delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + delta) & 7;

+            }

+        }

+        break;

+    }

+

+    if (chan->fill_mode == 2) {

+        for (i = chan->num_coded_vals; i < ctx->num_quant_units; i++)

+            chan->qu_wordlen[i] = ch_num ? get_bits1(gb) : 1;

+    } else if (chan->fill_mode == 3) {

+        pos = ch_num ? chan->num_coded_vals + chan->split_point

+                     : ctx->num_quant_units - chan->split_point;

+        for (i = chan->num_coded_vals; i < pos; i++)

+            chan->qu_wordlen[i] = 1;

+    }

+

+    if (weight_idx)

+        return add_wordlen_weights(ctx, chan, weight_idx, avctx);

+

+    return 0;

+}

+

+/**

+ * Decode scale factor indexes for each quant unit of a channel.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     ch_num        channel to process

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                                 int ch_num, AVCodecContext *avctx)

+{

+    int i, weight_idx = 0, delta, diff, num_long_vals,

+        delta_bits, min_val, vlc_sel, start_val;

+    VLC *vlc_tab;

+    Atrac3pChanParams *chan     = &ctx->channels[ch_num];

+    Atrac3pChanParams *ref_chan = &ctx->channels[0];

+

+    switch (get_bits(gb, 2)) { /* switch according to coding mode */

+    case 0: /* coded using constant number of bits */

+        for (i = 0; i < ctx->used_quant_units; i++)

+            chan->qu_sf_idx[i] = get_bits(gb, 6);

+        break;

+    case 1:

+        if (ch_num) {

+            vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];

+

+            for (i = 0; i < ctx->used_quant_units; i++) {

+                delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F;

+            }

+        } else {

+            weight_idx = get_bits(gb, 2);

+            if (weight_idx == 3) {

+                UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);

+

+                num_long_vals = get_bits(gb, 5);

+                delta_bits    = get_bits(gb, 2);

+                min_val       = get_bits(gb, 4) - 7;

+

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

+                    chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +

+                                          get_bits(gb, 4) - 7) & 0x3F;

+

+                /* all others are: min_val + delta */

+                for (i = num_long_vals; i < ctx->used_quant_units; i++)

+                    chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val +

+                                          GET_DELTA(gb, delta_bits)) & 0x3F;

+            } else {

+                num_long_vals = get_bits(gb, 5);

+                delta_bits    = get_bits(gb, 3);

+                min_val       = get_bits(gb, 6);

+                if (num_long_vals > ctx->used_quant_units || delta_bits == 7) {

+                    av_log(avctx, AV_LOG_ERROR,

+                           "SF mode 1: invalid parameters!\n");

+                    return AVERROR_INVALIDDATA;

+                }

+

+                /* read full-precision SF indexes */

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

+                    chan->qu_sf_idx[i] = get_bits(gb, 6);

+

+                /* all others are: min_val + delta */

+                for (i = num_long_vals; i < ctx->used_quant_units; i++)

+                    chan->qu_sf_idx[i] = (min_val +

+                                          GET_DELTA(gb, delta_bits)) & 0x3F;

+            }

+        }

+        break;

+    case 2:

+        if (ch_num) {

+            vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];

+

+            delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+            chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F;

+

+            for (i = 1; i < ctx->used_quant_units; i++) {

+                diff  = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1];

+                delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F;

+            }

+        } else {

+            vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4];

+

+            UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);

+

+            for (i = 0; i < ctx->used_quant_units; i++) {

+                delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +

+                                      sign_extend(delta, 4)) & 0x3F;

+            }

+        }

+        break;

+    case 3:

+        if (ch_num) {

+            /* copy coefficients from reference channel */

+            for (i = 0; i < ctx->used_quant_units; i++)

+                chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i];

+        } else {

+            weight_idx = get_bits(gb, 2);

+            vlc_sel    = get_bits(gb, 2);

+            vlc_tab    = &sf_vlc_tabs[vlc_sel];

+

+            if (weight_idx == 3) {

+                vlc_tab = &sf_vlc_tabs[vlc_sel + 4];

+

+                UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);

+

+                diff               = (get_bits(gb, 4)    + 56)   & 0x3F;

+                chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F;

+

+                for (i = 1; i < ctx->used_quant_units; i++) {

+                    delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                    diff               = (diff + sign_extend(delta, 4)) & 0x3F;

+                    chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i])    & 0x3F;

+                }

+            } else {

+                /* 1st coefficient is coded directly */

+                chan->qu_sf_idx[0] = get_bits(gb, 6);

+

+                for (i = 1; i < ctx->used_quant_units; i++) {

+                    delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);

+                    chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F;

+                }

+            }

+        }

+        break;

+    }

+

+    if (weight_idx && weight_idx < 3)

+        return subtract_sf_weights(ctx, chan, weight_idx, avctx);

+

+    return 0;

+}

+

+/**

+ * Decode word length information for each channel.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     num_channels  number of channels to process

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                                int num_channels, AVCodecContext *avctx)

+{

+    int ch_num, i, ret;

+

+    for (ch_num = 0; ch_num < num_channels; ch_num++) {

+        memset(ctx->channels[ch_num].qu_wordlen, 0,

+               sizeof(ctx->channels[ch_num].qu_wordlen));

+

+        if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0)

+            return ret;

+    }

+

+    /* scan for last non-zero coeff in both channels and

+     * set number of quant units having coded spectrum */

+    for (i = ctx->num_quant_units - 1; i >= 0; i--)

+        if (ctx->channels[0].qu_wordlen[i] ||

+            (num_channels == 2 && ctx->channels[1].qu_wordlen[i]))

+            break;

+    ctx->used_quant_units = i + 1;

+

+    return 0;

+}

+

+/**

+ * Decode scale factor indexes for each channel.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     num_channels  number of channels to process

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                                int num_channels, AVCodecContext *avctx)

+{

+    int ch_num, ret;

+

+    if (!ctx->used_quant_units)

+        return 0;

+

+    for (ch_num = 0; ch_num < num_channels; ch_num++) {

+        memset(ctx->channels[ch_num].qu_sf_idx, 0,

+               sizeof(ctx->channels[ch_num].qu_sf_idx));

+

+        if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0)

+            return ret;

+    }

+

+    return 0;

+}

+

+/**

+ * Decode number of code table values.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                             AVCodecContext *avctx)

+{

+    int num_coded_vals;

+

+    if (get_bits1(gb)) {

+        num_coded_vals = get_bits(gb, 5);

+        if (num_coded_vals > ctx->used_quant_units) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "Invalid number of code table indexes: %d!\n", num_coded_vals);

+            return AVERROR_INVALIDDATA;

+        }

+        return num_coded_vals;

+    } else

+        return ctx->used_quant_units;

+}

+

+#define DEC_CT_IDX_COMMON(OP)                                           \

+    num_vals = get_num_ct_values(gb, ctx, avctx);                       \

+    if (num_vals < 0)                                                   \

+        return num_vals;                                                \

+                                                                        \

+    for (i = 0; i < num_vals; i++) {                                    \

+        if (chan->qu_wordlen[i]) {                                      \

+            chan->qu_tab_idx[i] = OP;                                   \

+        } else if (ch_num && ref_chan->qu_wordlen[i])                   \

+            /* get clone master flag */                                 \

+            chan->qu_tab_idx[i] = get_bits1(gb);                        \

+    }

+

+#define CODING_DIRECT get_bits(gb, num_bits)

+

+#define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)

+

+#define CODING_VLC_DELTA                                                \

+    (!i) ? CODING_VLC                                                   \

+         : (pred + get_vlc2(gb, delta_vlc->table,                       \

+                            delta_vlc->bits, 1)) & mask;                \

+    pred = chan->qu_tab_idx[i]

+

+#define CODING_VLC_DIFF                                                 \

+    (ref_chan->qu_tab_idx[i] +                                          \

+     get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask

+

+/**

+ * Decode code table indexes for each quant unit of a channel.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     ch_num        channel to process

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                                   int ch_num, AVCodecContext *avctx)

+{

+    int i, num_vals, num_bits, pred;

+    int mask = ctx->use_full_table ? 7 : 3; /* mask for modular arithmetic */

+    VLC *vlc_tab, *delta_vlc;

+    Atrac3pChanParams *chan     = &ctx->channels[ch_num];

+    Atrac3pChanParams *ref_chan = &ctx->channels[0];

+

+    chan->table_type = get_bits1(gb);

+

+    switch (get_bits(gb, 2)) { /* switch according to coding mode */

+    case 0: /* directly coded */

+        num_bits = ctx->use_full_table + 2;

+        DEC_CT_IDX_COMMON(CODING_DIRECT);

+        break;

+    case 1: /* entropy-coded */

+        vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1]

+                                      : ct_vlc_tabs;

+        DEC_CT_IDX_COMMON(CODING_VLC);

+        break;

+    case 2: /* entropy-coded delta */

+        if (ctx->use_full_table) {

+            vlc_tab   = &ct_vlc_tabs[1];

+            delta_vlc = &ct_vlc_tabs[2];

+        } else {

+            vlc_tab   = ct_vlc_tabs;

+            delta_vlc = ct_vlc_tabs;

+        }

+        pred = 0;

+        DEC_CT_IDX_COMMON(CODING_VLC_DELTA);

+        break;

+    case 3: /* entropy-coded difference to master */

+        if (ch_num) {

+            vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[3]

+                                          : ct_vlc_tabs;

+            DEC_CT_IDX_COMMON(CODING_VLC_DIFF);

+        }

+        break;

+    }

+

+    return 0;

+}

+

+/**

+ * Decode code table indexes for each channel.

+ *

+ * @param[in]     gb            the GetBit context

+ * @param[in,out] ctx           ptr to the channel unit context

+ * @param[in]     num_channels  number of channels to process

+ * @param[in]     avctx         ptr to the AVCodecContext

+ * @return result code: 0 = OK, otherwise - error code

+ */

+static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

+                                     int num_channels, AVCodecContext *avctx)

+{

+    int ch_num, ret;

+

+    if (!ctx->used_quant_units)

+        return 0;

+

+    ctx->use_full_table = get_bits1(gb);

+

+    for (ch_num = 0; ch_num < num_channels; ch_num++) {

+        memset(ctx->channels[ch_num].qu_tab_idx, 0,

+               sizeof(ctx->channels[ch_num].qu_tab_idx));

+

+        if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0)

+            return ret;

+    }

+

+    return 0;

+}

+

+/**

+ * Decode huffman-coded spectral lines for a given quant unit.

+ *

+ * This is a generalized version for all known coding modes.

+ * Its speed can be improved by creating separate functions for each mode.

+ *

+ * @param[in]   gb          the GetBit context

+ * @param[in]   tab         code table telling how to decode spectral lines

+ * @param[in]   vlc_tab     ptr to the huffman table associated with the code table

+ * @param[out]  out         pointer to buffer where decoded data should be stored

+ * @param[in]   num_specs   number of spectral lines to decode

+ */

+static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,

+                              VLC *vlc_tab, int16_t *out, const int num_specs)

+{

+    int i, j, pos, cf;

+    int group_size = tab->group_size;

+    int num_coeffs = tab->num_coeffs;

+    int bits       = tab->bits;

+    int is_signed  = tab->is_signed;