Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * ATRAC3+ compatible decoder
  3.  *
  4.  * Copyright (c) 2010-2013 Maxim Poliakovski
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. /**
  24.  * @file
  25.  * Bitstream parser for ATRAC3+ decoder.
  26.  */
  27.  
  28. #include "libavutil/avassert.h"
  29. #include "avcodec.h"
  30. #include "get_bits.h"
  31. #include "atrac3plus.h"
  32. #include "atrac3plus_data.h"
  33.  
  34. static VLC_TYPE tables_data[154276][2];
  35. static VLC wl_vlc_tabs[4];
  36. static VLC sf_vlc_tabs[8];
  37. static VLC ct_vlc_tabs[4];
  38. static VLC spec_vlc_tabs[112];
  39. static VLC gain_vlc_tabs[11];
  40. static VLC tone_vlc_tabs[7];
  41.  
  42. #define GET_DELTA(gb, delta_bits) \
  43.     ((delta_bits) ? get_bits((gb), (delta_bits)) : 0)
  44.  
  45. /**
  46.  * Generate canonical VLC table from given descriptor.
  47.  *
  48.  * @param[in]     cb          ptr to codebook descriptor
  49.  * @param[in]     xlat        ptr to translation table or NULL
  50.  * @param[in,out] tab_offset  starting offset to the generated vlc table
  51.  * @param[out]    out_vlc     ptr to vlc table to be generated
  52.  */
  53. static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t *xlat,
  54.                                          int *tab_offset, VLC *out_vlc)
  55. {
  56.     int i, b;
  57.     uint16_t codes[256];
  58.     uint8_t bits[256];
  59.     unsigned code = 0;
  60.     int index = 0;
  61.     int min_len = *cb++; // get shortest codeword length
  62.     int max_len = *cb++; // get longest  codeword length
  63.  
  64.     for (b = min_len; b <= max_len; b++) {
  65.         for (i = *cb++; i > 0; i--) {
  66.             av_assert0(index < 256);
  67.             bits[index]  = b;
  68.             codes[index] = code++;
  69.             index++;
  70.         }
  71.         code <<= 1;
  72.     }
  73.  
  74.     out_vlc->table = &tables_data[*tab_offset];
  75.     out_vlc->table_allocated = 1 << max_len;
  76.  
  77.     ff_init_vlc_sparse(out_vlc, max_len, index, bits, 1, 1, codes, 2, 2,
  78.                        xlat, 1, 1, INIT_VLC_USE_NEW_STATIC);
  79.  
  80.     *tab_offset += 1 << max_len;
  81. }
  82.  
  83. av_cold void ff_atrac3p_init_vlcs(void)
  84. {
  85.     int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;
  86.  
  87.     static const int wl_nb_bits[4]  = { 2, 3, 5, 5 };
  88.     static const int wl_nb_codes[4] = { 3, 5, 8, 8 };
  89.     static const uint8_t * const wl_bits[4] = {
  90.         atrac3p_wl_huff_bits1, atrac3p_wl_huff_bits2,
  91.         atrac3p_wl_huff_bits3, atrac3p_wl_huff_bits4
  92.     };
  93.     static const uint8_t * const wl_codes[4] = {
  94.         atrac3p_wl_huff_code1, atrac3p_wl_huff_code2,
  95.         atrac3p_wl_huff_code3, atrac3p_wl_huff_code4
  96.     };
  97.     static const uint8_t * const wl_xlats[4] = {
  98.         atrac3p_wl_huff_xlat1, atrac3p_wl_huff_xlat2, NULL, NULL
  99.     };
  100.  
  101.     static const int ct_nb_bits[4]  = { 3, 4, 4, 4 };
  102.     static const int ct_nb_codes[4] = { 4, 8, 8, 8 };
  103.     static const uint8_t * const ct_bits[4]  = {
  104.         atrac3p_ct_huff_bits1, atrac3p_ct_huff_bits2,
  105.         atrac3p_ct_huff_bits2, atrac3p_ct_huff_bits3
  106.     };
  107.     static const uint8_t * const ct_codes[4] = {
  108.         atrac3p_ct_huff_code1, atrac3p_ct_huff_code2,
  109.         atrac3p_ct_huff_code2, atrac3p_ct_huff_code3
  110.     };
  111.     static const uint8_t * const ct_xlats[4] = {
  112.         NULL, NULL, atrac3p_ct_huff_xlat1, NULL
  113.     };
  114.  
  115.     static const  int sf_nb_bits[8]  = {  9,  9,  9,  9,  6,  6,  7,  7 };
  116.     static const  int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };
  117.     static const uint8_t  * const sf_bits[8]  = {
  118.         atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits2,
  119.         atrac3p_sf_huff_bits3, atrac3p_sf_huff_bits4, atrac3p_sf_huff_bits4,
  120.         atrac3p_sf_huff_bits5, atrac3p_sf_huff_bits6
  121.     };
  122.     static const uint16_t * const sf_codes[8] = {
  123.         atrac3p_sf_huff_code1, atrac3p_sf_huff_code1, atrac3p_sf_huff_code2,
  124.         atrac3p_sf_huff_code3, atrac3p_sf_huff_code4, atrac3p_sf_huff_code4,
  125.         atrac3p_sf_huff_code5, atrac3p_sf_huff_code6
  126.     };
  127.     static const uint8_t  * const sf_xlats[8] = {
  128.         atrac3p_sf_huff_xlat1, atrac3p_sf_huff_xlat2, NULL, NULL,
  129.         atrac3p_sf_huff_xlat4, atrac3p_sf_huff_xlat5, NULL, NULL
  130.     };
  131.  
  132.     static const uint8_t * const gain_cbs[11] = {
  133.         atrac3p_huff_gain_npoints1_cb, atrac3p_huff_gain_npoints1_cb,
  134.         atrac3p_huff_gain_lev1_cb, atrac3p_huff_gain_lev2_cb,
  135.         atrac3p_huff_gain_lev3_cb, atrac3p_huff_gain_lev4_cb,
  136.         atrac3p_huff_gain_loc3_cb, atrac3p_huff_gain_loc1_cb,
  137.         atrac3p_huff_gain_loc4_cb, atrac3p_huff_gain_loc2_cb,
  138.         atrac3p_huff_gain_loc5_cb
  139.     };
  140.     static const uint8_t * const gain_xlats[11] = {
  141.         NULL, atrac3p_huff_gain_npoints2_xlat, atrac3p_huff_gain_lev1_xlat,
  142.         atrac3p_huff_gain_lev2_xlat, atrac3p_huff_gain_lev3_xlat,
  143.         atrac3p_huff_gain_lev4_xlat, atrac3p_huff_gain_loc3_xlat,
  144.         atrac3p_huff_gain_loc1_xlat, atrac3p_huff_gain_loc4_xlat,
  145.         atrac3p_huff_gain_loc2_xlat, atrac3p_huff_gain_loc5_xlat
  146.     };
  147.  
  148.     static const uint8_t * const tone_cbs[7] = {
  149.         atrac3p_huff_tonebands_cb,  atrac3p_huff_numwavs1_cb,
  150.         atrac3p_huff_numwavs2_cb,   atrac3p_huff_wav_ampsf1_cb,
  151.         atrac3p_huff_wav_ampsf2_cb, atrac3p_huff_wav_ampsf3_cb,
  152.         atrac3p_huff_freq_cb
  153.     };
  154.     static const uint8_t * const tone_xlats[7] = {
  155.         NULL, NULL, atrac3p_huff_numwavs2_xlat, atrac3p_huff_wav_ampsf1_xlat,
  156.         atrac3p_huff_wav_ampsf2_xlat, atrac3p_huff_wav_ampsf3_xlat,
  157.         atrac3p_huff_freq_xlat
  158.     };
  159.  
  160.     for (i = 0, wl_vlc_offs = 0, ct_vlc_offs = 2508; i < 4; i++) {
  161.         wl_vlc_tabs[i].table = &tables_data[wl_vlc_offs];
  162.         wl_vlc_tabs[i].table_allocated = 1 << wl_nb_bits[i];
  163.         ct_vlc_tabs[i].table = &tables_data[ct_vlc_offs];
  164.         ct_vlc_tabs[i].table_allocated = 1 << ct_nb_bits[i];
  165.  
  166.         ff_init_vlc_sparse(&wl_vlc_tabs[i], wl_nb_bits[i], wl_nb_codes[i],
  167.                            wl_bits[i],  1, 1,
  168.                            wl_codes[i], 1, 1,
  169.                            wl_xlats[i], 1, 1,
  170.                            INIT_VLC_USE_NEW_STATIC);
  171.  
  172.         ff_init_vlc_sparse(&ct_vlc_tabs[i], ct_nb_bits[i], ct_nb_codes[i],
  173.                            ct_bits[i],  1, 1,
  174.                            ct_codes[i], 1, 1,
  175.                            ct_xlats[i], 1, 1,
  176.                            INIT_VLC_USE_NEW_STATIC);
  177.  
  178.         wl_vlc_offs += wl_vlc_tabs[i].table_allocated;
  179.         ct_vlc_offs += ct_vlc_tabs[i].table_allocated;
  180.     }
  181.  
  182.     for (i = 0, sf_vlc_offs = 76; i < 8; i++) {
  183.         sf_vlc_tabs[i].table = &tables_data[sf_vlc_offs];
  184.         sf_vlc_tabs[i].table_allocated = 1 << sf_nb_bits[i];
  185.  
  186.         ff_init_vlc_sparse(&sf_vlc_tabs[i], sf_nb_bits[i], sf_nb_codes[i],
  187.                            sf_bits[i],  1, 1,
  188.                            sf_codes[i], 2, 2,
  189.                            sf_xlats[i], 1, 1,
  190.                            INIT_VLC_USE_NEW_STATIC);
  191.         sf_vlc_offs += sf_vlc_tabs[i].table_allocated;
  192.     }
  193.  
  194.     tab_offset = 2564;
  195.  
  196.     /* build huffman tables for spectrum decoding */
  197.     for (i = 0; i < 112; i++) {
  198.         if (atrac3p_spectra_tabs[i].cb)
  199.             build_canonical_huff(atrac3p_spectra_tabs[i].cb,
  200.                                  atrac3p_spectra_tabs[i].xlat,
  201.                                  &tab_offset, &spec_vlc_tabs[i]);
  202.         else
  203.             spec_vlc_tabs[i].table = 0;
  204.     }
  205.  
  206.     /* build huffman tables for gain data decoding */
  207.     for (i = 0; i < 11; i++)
  208.         build_canonical_huff(gain_cbs[i], gain_xlats[i], &tab_offset, &gain_vlc_tabs[i]);
  209.  
  210.     /* build huffman tables for tone decoding */
  211.     for (i = 0; i < 7; i++)
  212.         build_canonical_huff(tone_cbs[i], tone_xlats[i], &tab_offset, &tone_vlc_tabs[i]);
  213. }
  214.  
  215. /**
  216.  * Decode number of coded quantization units.
  217.  *
  218.  * @param[in]     gb            the GetBit context
  219.  * @param[in,out] chan          ptr to the channel parameters
  220.  * @param[in,out] ctx           ptr to the channel unit context
  221.  * @param[in]     avctx         ptr to the AVCodecContext
  222.  * @return result code: 0 = OK, otherwise - error code
  223.  */
  224. static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan,
  225.                            Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)
  226. {
  227.     chan->fill_mode = get_bits(gb, 2);
  228.     if (!chan->fill_mode) {
  229.         chan->num_coded_vals = ctx->num_quant_units;
  230.     } else {
  231.         chan->num_coded_vals = get_bits(gb, 5);
  232.         if (chan->num_coded_vals > ctx->num_quant_units) {
  233.             av_log(avctx, AV_LOG_ERROR,
  234.                    "Invalid number of transmitted units!\n");
  235.             return AVERROR_INVALIDDATA;
  236.         }
  237.  
  238.         if (chan->fill_mode == 3)
  239.             chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1;
  240.     }
  241.  
  242.     return 0;
  243. }
  244.  
  245. /**
  246.  * Add weighting coefficients to the decoded word-length information.
  247.  *
  248.  * @param[in,out] ctx           ptr to the channel unit context
  249.  * @param[in,out] chan          ptr to the channel parameters
  250.  * @param[in]     wtab_idx      index of the table of weights
  251.  * @param[in]     avctx         ptr to the AVCodecContext
  252.  * @return result code: 0 = OK, otherwise - error code
  253.  */
  254. static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx,
  255.                                Atrac3pChanParams *chan, int wtab_idx,
  256.                                AVCodecContext *avctx)
  257. {
  258.     int i;
  259.     const int8_t *weights_tab =
  260.         &atrac3p_wl_weights[chan->ch_num * 3 + wtab_idx - 1][0];
  261.  
  262.     for (i = 0; i < ctx->num_quant_units; i++) {
  263.         chan->qu_wordlen[i] += weights_tab[i];
  264.         if (chan->qu_wordlen[i] < 0 || chan->qu_wordlen[i] > 7) {
  265.             av_log(avctx, AV_LOG_ERROR,
  266.                    "WL index out of range: pos=%d, val=%d!\n",
  267.                    i, chan->qu_wordlen[i]);
  268.             return AVERROR_INVALIDDATA;
  269.         }
  270.     }
  271.  
  272.     return 0;
  273. }
  274.  
  275. /**
  276.  * Subtract weighting coefficients from decoded scalefactors.
  277.  *
  278.  * @param[in,out] ctx           ptr to the channel unit context
  279.  * @param[in,out] chan          ptr to the channel parameters
  280.  * @param[in]     wtab_idx      index of table of weights
  281.  * @param[in]     avctx         ptr to the AVCodecContext
  282.  * @return result code: 0 = OK, otherwise - error code
  283.  */
  284. static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx,
  285.                                Atrac3pChanParams *chan, int wtab_idx,
  286.                                AVCodecContext *avctx)
  287. {
  288.     int i;
  289.     const int8_t *weights_tab = &atrac3p_sf_weights[wtab_idx - 1][0];
  290.  
  291.     for (i = 0; i < ctx->used_quant_units; i++) {
  292.         chan->qu_sf_idx[i] -= weights_tab[i];
  293.         if (chan->qu_sf_idx[i] < 0 || chan->qu_sf_idx[i] > 63) {
  294.             av_log(avctx, AV_LOG_ERROR,
  295.                    "SF index out of range: pos=%d, val=%d!\n",
  296.                    i, chan->qu_sf_idx[i]);
  297.             return AVERROR_INVALIDDATA;
  298.         }
  299.     }
  300.  
  301.     return 0;
  302. }
  303.  
  304. /**
  305.  * Unpack vector quantization tables.
  306.  *
  307.  * @param[in]    start_val    start value for the unpacked table
  308.  * @param[in]    shape_vec    ptr to table to unpack
  309.  * @param[out]   dst          ptr to output array
  310.  * @param[in]    num_values   number of values to unpack
  311.  */
  312. static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec,
  313.                                    int *dst, int num_values)
  314. {
  315.     int i;
  316.  
  317.     if (num_values) {
  318.         dst[0] = dst[1] = dst[2] = start_val;
  319.         for (i = 3; i < num_values; i++)
  320.             dst[i] = start_val - shape_vec[atrac3p_qu_num_to_seg[i] - 1];
  321.     }
  322. }
  323.  
  324. #define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals)                            \
  325.     start_val = get_bits((gb), 6);                                       \
  326.     unpack_vq_shape(start_val, &atrac3p_sf_shapes[get_bits((gb), 6)][0], \
  327.                     (dst), (num_vals))
  328.  
  329. /**
  330.  * Decode word length for each quantization unit of a channel.
  331.  *
  332.  * @param[in]     gb            the GetBit context
  333.  * @param[in,out] ctx           ptr to the channel unit context
  334.  * @param[in]     ch_num        channel to process
  335.  * @param[in]     avctx         ptr to the AVCodecContext
  336.  * @return result code: 0 = OK, otherwise - error code
  337.  */
  338. static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  339.                                   int ch_num, AVCodecContext *avctx)
  340. {
  341.     int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag,
  342.         ret, start_val;
  343.     VLC *vlc_tab;
  344.     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
  345.     Atrac3pChanParams *ref_chan = &ctx->channels[0];
  346.  
  347.     chan->fill_mode = 0;
  348.  
  349.     switch (get_bits(gb, 2)) { /* switch according to coding mode */
  350.     case 0: /* coded using constant number of bits */
  351.         for (i = 0; i < ctx->num_quant_units; i++)
  352.             chan->qu_wordlen[i] = get_bits(gb, 3);
  353.         break;
  354.     case 1:
  355.         if (ch_num) {
  356.             if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
  357.                 return ret;
  358.  
  359.             if (chan->num_coded_vals) {
  360.                 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
  361.  
  362.                 for (i = 0; i < chan->num_coded_vals; i++) {
  363.                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  364.                     chan->qu_wordlen[i] = (ref_chan->qu_wordlen[i] + delta) & 7;
  365.                 }
  366.             }
  367.         } else {
  368.             weight_idx = get_bits(gb, 2);
  369.             if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
  370.                 return ret;
  371.  
  372.             if (chan->num_coded_vals) {
  373.                 pos = get_bits(gb, 5);
  374.                 if (pos > chan->num_coded_vals) {
  375.                     av_log(avctx, AV_LOG_ERROR,
  376.                            "WL mode 1: invalid position!\n");
  377.                     return AVERROR_INVALIDDATA;
  378.                 }
  379.  
  380.                 delta_bits = get_bits(gb, 2);
  381.                 min_val    = get_bits(gb, 3);
  382.  
  383.                 for (i = 0; i < pos; i++)
  384.                     chan->qu_wordlen[i] = get_bits(gb, 3);
  385.  
  386.                 for (i = pos; i < chan->num_coded_vals; i++)
  387.                     chan->qu_wordlen[i] = (min_val + GET_DELTA(gb, delta_bits)) & 7;
  388.             }
  389.         }
  390.         break;
  391.     case 2:
  392.         if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
  393.             return ret;
  394.  
  395.         if (ch_num && chan->num_coded_vals) {
  396.             vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
  397.             delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  398.             chan->qu_wordlen[0] = (ref_chan->qu_wordlen[0] + delta) & 7;
  399.  
  400.             for (i = 1; i < chan->num_coded_vals; i++) {
  401.                 diff = ref_chan->qu_wordlen[i] - ref_chan->qu_wordlen[i - 1];
  402.                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  403.                 chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + diff + delta) & 7;
  404.             }
  405.         } else if (chan->num_coded_vals) {
  406.             flag    = get_bits(gb, 1);
  407.             vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)];
  408.  
  409.             start_val = get_bits(gb, 3);
  410.             unpack_vq_shape(start_val,
  411.                             &atrac3p_wl_shapes[start_val][get_bits(gb, 4)][0],
  412.                             chan->qu_wordlen, chan->num_coded_vals);
  413.  
  414.             if (!flag) {
  415.                 for (i = 0; i < chan->num_coded_vals; i++) {
  416.                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  417.                     chan->qu_wordlen[i] = (chan->qu_wordlen[i] + delta) & 7;
  418.                 }
  419.             } else {
  420.                 for (i = 0; i < (chan->num_coded_vals & - 2); i += 2)
  421.                     if (!get_bits1(gb)) {
  422.                         chan->qu_wordlen[i]     = (chan->qu_wordlen[i] +
  423.                                                    get_vlc2(gb, vlc_tab->table,
  424.                                                             vlc_tab->bits, 1)) & 7;
  425.                         chan->qu_wordlen[i + 1] = (chan->qu_wordlen[i + 1] +
  426.                                                    get_vlc2(gb, vlc_tab->table,
  427.                                                             vlc_tab->bits, 1)) & 7;
  428.                     }
  429.  
  430.                 if (chan->num_coded_vals & 1)
  431.                     chan->qu_wordlen[i] = (chan->qu_wordlen[i] +
  432.                                            get_vlc2(gb, vlc_tab->table,
  433.                                                     vlc_tab->bits, 1)) & 7;
  434.             }
  435.         }
  436.         break;
  437.     case 3:
  438.         weight_idx = get_bits(gb, 2);
  439.         if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
  440.             return ret;
  441.  
  442.         if (chan->num_coded_vals) {
  443.             vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
  444.  
  445.             /* first coefficient is coded directly */
  446.             chan->qu_wordlen[0] = get_bits(gb, 3);
  447.  
  448.             for (i = 1; i < chan->num_coded_vals; i++) {
  449.                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  450.                 chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + delta) & 7;
  451.             }
  452.         }
  453.         break;
  454.     }
  455.  
  456.     if (chan->fill_mode == 2) {
  457.         for (i = chan->num_coded_vals; i < ctx->num_quant_units; i++)
  458.             chan->qu_wordlen[i] = ch_num ? get_bits1(gb) : 1;
  459.     } else if (chan->fill_mode == 3) {
  460.         pos = ch_num ? chan->num_coded_vals + chan->split_point
  461.                      : ctx->num_quant_units - chan->split_point;
  462.         for (i = chan->num_coded_vals; i < pos; i++)
  463.             chan->qu_wordlen[i] = 1;
  464.     }
  465.  
  466.     if (weight_idx)
  467.         return add_wordlen_weights(ctx, chan, weight_idx, avctx);
  468.  
  469.     return 0;
  470. }
  471.  
  472. /**
  473.  * Decode scale factor indexes for each quant unit of a channel.
  474.  *
  475.  * @param[in]     gb            the GetBit context
  476.  * @param[in,out] ctx           ptr to the channel unit context
  477.  * @param[in]     ch_num        channel to process
  478.  * @param[in]     avctx         ptr to the AVCodecContext
  479.  * @return result code: 0 = OK, otherwise - error code
  480.  */
  481. static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  482.                                  int ch_num, AVCodecContext *avctx)
  483. {
  484.     int i, weight_idx = 0, delta, diff, num_long_vals,
  485.         delta_bits, min_val, vlc_sel, start_val;
  486.     VLC *vlc_tab;
  487.     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
  488.     Atrac3pChanParams *ref_chan = &ctx->channels[0];
  489.  
  490.     switch (get_bits(gb, 2)) { /* switch according to coding mode */
  491.     case 0: /* coded using constant number of bits */
  492.         for (i = 0; i < ctx->used_quant_units; i++)
  493.             chan->qu_sf_idx[i] = get_bits(gb, 6);
  494.         break;
  495.     case 1:
  496.         if (ch_num) {
  497.             vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
  498.  
  499.             for (i = 0; i < ctx->used_quant_units; i++) {
  500.                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  501.                 chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F;
  502.             }
  503.         } else {
  504.             weight_idx = get_bits(gb, 2);
  505.             if (weight_idx == 3) {
  506.                 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
  507.  
  508.                 num_long_vals = get_bits(gb, 5);
  509.                 delta_bits    = get_bits(gb, 2);
  510.                 min_val       = get_bits(gb, 4) - 7;
  511.  
  512.                 for (i = 0; i < num_long_vals; i++)
  513.                     chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
  514.                                           get_bits(gb, 4) - 7) & 0x3F;
  515.  
  516.                 /* all others are: min_val + delta */
  517.                 for (i = num_long_vals; i < ctx->used_quant_units; i++)
  518.                     chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val +
  519.                                           GET_DELTA(gb, delta_bits)) & 0x3F;
  520.             } else {
  521.                 num_long_vals = get_bits(gb, 5);
  522.                 delta_bits    = get_bits(gb, 3);
  523.                 min_val       = get_bits(gb, 6);
  524.                 if (num_long_vals > ctx->used_quant_units || delta_bits == 7) {
  525.                     av_log(avctx, AV_LOG_ERROR,
  526.                            "SF mode 1: invalid parameters!\n");
  527.                     return AVERROR_INVALIDDATA;
  528.                 }
  529.  
  530.                 /* read full-precision SF indexes */
  531.                 for (i = 0; i < num_long_vals; i++)
  532.                     chan->qu_sf_idx[i] = get_bits(gb, 6);
  533.  
  534.                 /* all others are: min_val + delta */
  535.                 for (i = num_long_vals; i < ctx->used_quant_units; i++)
  536.                     chan->qu_sf_idx[i] = (min_val +
  537.                                           GET_DELTA(gb, delta_bits)) & 0x3F;
  538.             }
  539.         }
  540.         break;
  541.     case 2:
  542.         if (ch_num) {
  543.             vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
  544.  
  545.             delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  546.             chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F;
  547.  
  548.             for (i = 1; i < ctx->used_quant_units; i++) {
  549.                 diff  = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1];
  550.                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  551.                 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F;
  552.             }
  553.         } else {
  554.             vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4];
  555.  
  556.             UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
  557.  
  558.             for (i = 0; i < ctx->used_quant_units; i++) {
  559.                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  560.                 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
  561.                                       sign_extend(delta, 4)) & 0x3F;
  562.             }
  563.         }
  564.         break;
  565.     case 3:
  566.         if (ch_num) {
  567.             /* copy coefficients from reference channel */
  568.             for (i = 0; i < ctx->used_quant_units; i++)
  569.                 chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i];
  570.         } else {
  571.             weight_idx = get_bits(gb, 2);
  572.             vlc_sel    = get_bits(gb, 2);
  573.             vlc_tab    = &sf_vlc_tabs[vlc_sel];
  574.  
  575.             if (weight_idx == 3) {
  576.                 vlc_tab = &sf_vlc_tabs[vlc_sel + 4];
  577.  
  578.                 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
  579.  
  580.                 diff               = (get_bits(gb, 4)    + 56)   & 0x3F;
  581.                 chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F;
  582.  
  583.                 for (i = 1; i < ctx->used_quant_units; i++) {
  584.                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  585.                     diff               = (diff + sign_extend(delta, 4)) & 0x3F;
  586.                     chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i])    & 0x3F;
  587.                 }
  588.             } else {
  589.                 /* 1st coefficient is coded directly */
  590.                 chan->qu_sf_idx[0] = get_bits(gb, 6);
  591.  
  592.                 for (i = 1; i < ctx->used_quant_units; i++) {
  593.                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  594.                     chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F;
  595.                 }
  596.             }
  597.         }
  598.         break;
  599.     }
  600.  
  601.     if (weight_idx && weight_idx < 3)
  602.         return subtract_sf_weights(ctx, chan, weight_idx, avctx);
  603.  
  604.     return 0;
  605. }
  606.  
  607. /**
  608.  * Decode word length information for each channel.
  609.  *
  610.  * @param[in]     gb            the GetBit context
  611.  * @param[in,out] ctx           ptr to the channel unit context
  612.  * @param[in]     num_channels  number of channels to process
  613.  * @param[in]     avctx         ptr to the AVCodecContext
  614.  * @return result code: 0 = OK, otherwise - error code
  615.  */
  616. static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  617.                                 int num_channels, AVCodecContext *avctx)
  618. {
  619.     int ch_num, i, ret;
  620.  
  621.     for (ch_num = 0; ch_num < num_channels; ch_num++) {
  622.         memset(ctx->channels[ch_num].qu_wordlen, 0,
  623.                sizeof(ctx->channels[ch_num].qu_wordlen));
  624.  
  625.         if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0)
  626.             return ret;
  627.     }
  628.  
  629.     /* scan for last non-zero coeff in both channels and
  630.      * set number of quant units having coded spectrum */
  631.     for (i = ctx->num_quant_units - 1; i >= 0; i--)
  632.         if (ctx->channels[0].qu_wordlen[i] ||
  633.             (num_channels == 2 && ctx->channels[1].qu_wordlen[i]))
  634.             break;
  635.     ctx->used_quant_units = i + 1;
  636.  
  637.     return 0;
  638. }
  639.  
  640. /**
  641.  * Decode scale factor indexes for each channel.
  642.  *
  643.  * @param[in]     gb            the GetBit context
  644.  * @param[in,out] ctx           ptr to the channel unit context
  645.  * @param[in]     num_channels  number of channels to process
  646.  * @param[in]     avctx         ptr to the AVCodecContext
  647.  * @return result code: 0 = OK, otherwise - error code
  648.  */
  649. static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  650.                                 int num_channels, AVCodecContext *avctx)
  651. {
  652.     int ch_num, ret;
  653.  
  654.     if (!ctx->used_quant_units)
  655.         return 0;
  656.  
  657.     for (ch_num = 0; ch_num < num_channels; ch_num++) {
  658.         memset(ctx->channels[ch_num].qu_sf_idx, 0,
  659.                sizeof(ctx->channels[ch_num].qu_sf_idx));
  660.  
  661.         if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0)
  662.             return ret;
  663.     }
  664.  
  665.     return 0;
  666. }
  667.  
  668. /**
  669.  * Decode number of code table values.
  670.  *
  671.  * @param[in]     gb            the GetBit context
  672.  * @param[in,out] ctx           ptr to the channel unit context
  673.  * @param[in]     avctx         ptr to the AVCodecContext
  674.  * @return result code: 0 = OK, otherwise - error code
  675.  */
  676. static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  677.                              AVCodecContext *avctx)
  678. {
  679.     int num_coded_vals;
  680.  
  681.     if (get_bits1(gb)) {
  682.         num_coded_vals = get_bits(gb, 5);
  683.         if (num_coded_vals > ctx->used_quant_units) {
  684.             av_log(avctx, AV_LOG_ERROR,
  685.                    "Invalid number of code table indexes: %d!\n", num_coded_vals);
  686.             return AVERROR_INVALIDDATA;
  687.         }
  688.         return num_coded_vals;
  689.     } else
  690.         return ctx->used_quant_units;
  691. }
  692.  
  693. #define DEC_CT_IDX_COMMON(OP)                                           \
  694.     num_vals = get_num_ct_values(gb, ctx, avctx);                       \
  695.     if (num_vals < 0)                                                   \
  696.         return num_vals;                                                \
  697.                                                                         \
  698.     for (i = 0; i < num_vals; i++) {                                    \
  699.         if (chan->qu_wordlen[i]) {                                      \
  700.             chan->qu_tab_idx[i] = OP;                                   \
  701.         } else if (ch_num && ref_chan->qu_wordlen[i])                   \
  702.             /* get clone master flag */                                 \
  703.             chan->qu_tab_idx[i] = get_bits1(gb);                        \
  704.     }
  705.  
  706. #define CODING_DIRECT get_bits(gb, num_bits)
  707.  
  708. #define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)
  709.  
  710. #define CODING_VLC_DELTA                                                \
  711.     (!i) ? CODING_VLC                                                   \
  712.          : (pred + get_vlc2(gb, delta_vlc->table,                       \
  713.                             delta_vlc->bits, 1)) & mask;                \
  714.     pred = chan->qu_tab_idx[i]
  715.  
  716. #define CODING_VLC_DIFF                                                 \
  717.     (ref_chan->qu_tab_idx[i] +                                          \
  718.      get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask
  719.  
  720. /**
  721.  * Decode code table indexes for each quant unit of a channel.
  722.  *
  723.  * @param[in]     gb            the GetBit context
  724.  * @param[in,out] ctx           ptr to the channel unit context
  725.  * @param[in]     ch_num        channel to process
  726.  * @param[in]     avctx         ptr to the AVCodecContext
  727.  * @return result code: 0 = OK, otherwise - error code
  728.  */
  729. static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  730.                                    int ch_num, AVCodecContext *avctx)
  731. {
  732.     int i, num_vals, num_bits, pred;
  733.     int mask = ctx->use_full_table ? 7 : 3; /* mask for modular arithmetic */
  734.     VLC *vlc_tab, *delta_vlc;
  735.     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
  736.     Atrac3pChanParams *ref_chan = &ctx->channels[0];
  737.  
  738.     chan->table_type = get_bits1(gb);
  739.  
  740.     switch (get_bits(gb, 2)) { /* switch according to coding mode */
  741.     case 0: /* directly coded */
  742.         num_bits = ctx->use_full_table + 2;
  743.         DEC_CT_IDX_COMMON(CODING_DIRECT);
  744.         break;
  745.     case 1: /* entropy-coded */
  746.         vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1]
  747.                                       : ct_vlc_tabs;
  748.         DEC_CT_IDX_COMMON(CODING_VLC);
  749.         break;
  750.     case 2: /* entropy-coded delta */
  751.         if (ctx->use_full_table) {
  752.             vlc_tab   = &ct_vlc_tabs[1];
  753.             delta_vlc = &ct_vlc_tabs[2];
  754.         } else {
  755.             vlc_tab   = ct_vlc_tabs;
  756.             delta_vlc = ct_vlc_tabs;
  757.         }
  758.         pred = 0;
  759.         DEC_CT_IDX_COMMON(CODING_VLC_DELTA);
  760.         break;
  761.     case 3: /* entropy-coded difference to master */
  762.         if (ch_num) {
  763.             vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[3]
  764.                                           : ct_vlc_tabs;
  765.             DEC_CT_IDX_COMMON(CODING_VLC_DIFF);
  766.         }
  767.         break;
  768.     }
  769.  
  770.     return 0;
  771. }
  772.  
  773. /**
  774.  * Decode code table indexes for each channel.
  775.  *
  776.  * @param[in]     gb            the GetBit context
  777.  * @param[in,out] ctx           ptr to the channel unit context
  778.  * @param[in]     num_channels  number of channels to process
  779.  * @param[in]     avctx         ptr to the AVCodecContext
  780.  * @return result code: 0 = OK, otherwise - error code
  781.  */
  782. static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  783.                                      int num_channels, AVCodecContext *avctx)
  784. {
  785.     int ch_num, ret;
  786.  
  787.     if (!ctx->used_quant_units)
  788.         return 0;
  789.  
  790.     ctx->use_full_table = get_bits1(gb);
  791.  
  792.     for (ch_num = 0; ch_num < num_channels; ch_num++) {
  793.         memset(ctx->channels[ch_num].qu_tab_idx, 0,
  794.                sizeof(ctx->channels[ch_num].qu_tab_idx));
  795.  
  796.         if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0)
  797.             return ret;
  798.     }
  799.  
  800.     return 0;
  801. }
  802.  
  803. /**
  804.  * Decode huffman-coded spectral lines for a given quant unit.
  805.  *
  806.  * This is a generalized version for all known coding modes.
  807.  * Its speed can be improved by creating separate functions for each mode.
  808.  *
  809.  * @param[in]   gb          the GetBit context
  810.  * @param[in]   tab         code table telling how to decode spectral lines
  811.  * @param[in]   vlc_tab     ptr to the huffman table associated with the code table
  812.  * @param[out]  out         pointer to buffer where decoded data should be stored
  813.  * @param[in]   num_specs   number of spectral lines to decode
  814.  */
  815. static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,
  816.                               VLC *vlc_tab, int16_t *out, const int num_specs)
  817. {
  818.     int i, j, pos, cf;
  819.     int group_size = tab->group_size;
  820.     int num_coeffs = tab->num_coeffs;
  821.     int bits       = tab->bits;
  822.     int is_signed  = tab->is_signed;
  823.     unsigned val;
  824.  
  825.     for (pos = 0; pos < num_specs;) {
  826.         if (group_size == 1 || get_bits1(gb)) {
  827.             for (j = 0; j < group_size; j++) {
  828.                 val = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
  829.  
  830.                 for (i = 0; i < num_coeffs; i++) {
  831.                     cf = av_mod_uintp2(val, bits);
  832.                     if (is_signed)
  833.                         cf = sign_extend(cf, bits);
  834.                     else if (cf && get_bits1(gb))
  835.                         cf = -cf;
  836.  
  837.                     out[pos++] = cf;
  838.                     val      >>= bits;
  839.                 }
  840.             }
  841.         } else /* group skipped */
  842.             pos += group_size * num_coeffs;
  843.     }
  844. }
  845.  
  846. /**
  847.  * Decode huffman-coded IMDCT spectrum for all channels.
  848.  *
  849.  * @param[in]     gb            the GetBit context
  850.  * @param[in,out] ctx           ptr to the channel unit context
  851.  * @param[in]     num_channels  number of channels to process
  852.  * @param[in]     avctx         ptr to the AVCodecContext
  853.  */
  854. static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  855.                             int num_channels, AVCodecContext *avctx)
  856. {
  857.     int i, ch_num, qu, wordlen, codetab, tab_index, num_specs;
  858.     const Atrac3pSpecCodeTab *tab;
  859.     Atrac3pChanParams *chan;
  860.  
  861.     for (ch_num = 0; ch_num < num_channels; ch_num++) {
  862.         chan = &ctx->channels[ch_num];
  863.  
  864.         memset(chan->spectrum, 0, sizeof(chan->spectrum));
  865.  
  866.         /* set power compensation level to disabled */
  867.         memset(chan->power_levs, ATRAC3P_POWER_COMP_OFF, sizeof(chan->power_levs));
  868.  
  869.         for (qu = 0; qu < ctx->used_quant_units; qu++) {
  870.             num_specs = ff_atrac3p_qu_to_spec_pos[qu + 1] -
  871.                         ff_atrac3p_qu_to_spec_pos[qu];
  872.  
  873.             wordlen = chan->qu_wordlen[qu];
  874.             codetab = chan->qu_tab_idx[qu];
  875.             if (wordlen) {
  876.                 if (!ctx->use_full_table)
  877.                     codetab = atrac3p_ct_restricted_to_full[chan->table_type][wordlen - 1][codetab];
  878.  
  879.                 tab_index = (chan->table_type * 8 + codetab) * 7 + wordlen - 1;
  880.                 tab       = &atrac3p_spectra_tabs[tab_index];
  881.  
  882.                 /* this allows reusing VLC tables */
  883.                 if (tab->redirect >= 0)
  884.                     tab_index = tab->redirect;
  885.  
  886.                 decode_qu_spectra(gb, tab, &spec_vlc_tabs[tab_index],
  887.                                   &chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
  888.                                   num_specs);
  889.             } else if (ch_num && ctx->channels[0].qu_wordlen[qu] && !codetab) {
  890.                 /* copy coefficients from master */
  891.                 memcpy(&chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
  892.                        &ctx->channels[0].spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
  893.                        num_specs *
  894.                        sizeof(chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]]));
  895.                 chan->qu_wordlen[qu] = ctx->channels[0].qu_wordlen[qu];
  896.             }
  897.         }
  898.  
  899.         /* Power compensation levels only present in the bitstream
  900.          * if there are more than 2 quant units. The lowest two units
  901.          * correspond to the frequencies 0...351 Hz, whose shouldn't
  902.          * be affected by the power compensation. */
  903.         if (ctx->used_quant_units > 2) {
  904.             num_specs = atrac3p_subband_to_num_powgrps[ctx->num_coded_subbands - 1];
  905.             for (i = 0; i < num_specs; i++)
  906.                 chan->power_levs[i] = get_bits(gb, 4);
  907.         }
  908.     }
  909. }
  910.  
  911. /**
  912.  * Retrieve specified amount of flag bits from the input bitstream.
  913.  * The data can be shortened in the case of the following two common conditions:
  914.  * if all bits are zero then only one signal bit = 0 will be stored,
  915.  * if all bits are ones then two signal bits = 1,0 will be stored.
  916.  * Otherwise, all necessary bits will be directly stored
  917.  * prefixed by two signal bits = 1,1.
  918.  *
  919.  * @param[in]   gb              ptr to the GetBitContext
  920.  * @param[out]  out             where to place decoded flags
  921.  * @param[in]   num_flags       number of flags to process
  922.  * @return: 0 = all flag bits are zero, 1 = there is at least one non-zero flag bit
  923.  */
  924. static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags)
  925. {
  926.     int i, result;
  927.  
  928.     memset(out, 0, num_flags);
  929.  
  930.     result = get_bits1(gb);
  931.     if (result) {
  932.         if (get_bits1(gb))
  933.             for (i = 0; i < num_flags; i++)
  934.                 out[i] = get_bits1(gb);
  935.         else
  936.             memset(out, 1, num_flags);
  937.     }
  938.  
  939.     return result;
  940. }
  941.  
  942. /**
  943.  * Decode mdct window shape flags for all channels.
  944.  *
  945.  * @param[in]     gb            the GetBit context
  946.  * @param[in,out] ctx           ptr to the channel unit context
  947.  * @param[in]     num_channels  number of channels to process
  948.  */
  949. static void decode_window_shape(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  950.                                 int num_channels)
  951. {
  952.     int ch_num;
  953.  
  954.     for (ch_num = 0; ch_num < num_channels; ch_num++)
  955.         get_subband_flags(gb, ctx->channels[ch_num].wnd_shape,
  956.                           ctx->num_subbands);
  957. }
  958.  
  959. /**
  960.  * Decode number of gain control points.
  961.  *
  962.  * @param[in]     gb              the GetBit context
  963.  * @param[in,out] ctx             ptr to the channel unit context
  964.  * @param[in]     ch_num          channel to process
  965.  * @param[in]     coded_subbands  number of subbands to process
  966.  * @return result code: 0 = OK, otherwise - error code
  967.  */
  968. static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  969.                                 int ch_num, int coded_subbands)
  970. {
  971.     int i, delta, delta_bits, min_val;
  972.     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
  973.     Atrac3pChanParams *ref_chan = &ctx->channels[0];
  974.  
  975.     switch (get_bits(gb, 2)) { /* switch according to coding mode */
  976.     case 0: /* fixed-length coding */
  977.         for (i = 0; i < coded_subbands; i++)
  978.             chan->gain_data[i].num_points = get_bits(gb, 3);
  979.         break;
  980.     case 1: /* variable-length coding */
  981.         for (i = 0; i < coded_subbands; i++)
  982.             chan->gain_data[i].num_points =
  983.                 get_vlc2(gb, gain_vlc_tabs[0].table,
  984.                          gain_vlc_tabs[0].bits, 1);
  985.         break;
  986.     case 2:
  987.         if (ch_num) { /* VLC modulo delta to master channel */
  988.             for (i = 0; i < coded_subbands; i++) {
  989.                 delta = get_vlc2(gb, gain_vlc_tabs[1].table,
  990.                                  gain_vlc_tabs[1].bits, 1);
  991.                 chan->gain_data[i].num_points =
  992.                     (ref_chan->gain_data[i].num_points + delta) & 7;
  993.             }
  994.         } else { /* VLC modulo delta to previous */
  995.             chan->gain_data[0].num_points =
  996.                 get_vlc2(gb, gain_vlc_tabs[0].table,
  997.                          gain_vlc_tabs[0].bits, 1);
  998.  
  999.             for (i = 1; i < coded_subbands; i++) {
  1000.                 delta = get_vlc2(gb, gain_vlc_tabs[1].table,
  1001.                                  gain_vlc_tabs[1].bits, 1);
  1002.                 chan->gain_data[i].num_points =
  1003.                     (chan->gain_data[i - 1].num_points + delta) & 7;
  1004.             }
  1005.         }
  1006.         break;
  1007.     case 3:
  1008.         if (ch_num) { /* copy data from master channel */
  1009.             for (i = 0; i < coded_subbands; i++)
  1010.                 chan->gain_data[i].num_points =
  1011.                     ref_chan->gain_data[i].num_points;
  1012.         } else { /* shorter delta to min */
  1013.             delta_bits = get_bits(gb, 2);
  1014.             min_val    = get_bits(gb, 3);
  1015.  
  1016.             for (i = 0; i < coded_subbands; i++) {
  1017.                 chan->gain_data[i].num_points = min_val + GET_DELTA(gb, delta_bits);
  1018.                 if (chan->gain_data[i].num_points > 7)
  1019.                     return AVERROR_INVALIDDATA;
  1020.             }
  1021.         }
  1022.     }
  1023.  
  1024.     return 0;
  1025. }
  1026.  
  1027. /**
  1028.  * Implements coding mode 3 (slave) for gain compensation levels.
  1029.  *
  1030.  * @param[out]   dst   ptr to the output array
  1031.  * @param[in]    ref   ptr to the reference channel
  1032.  */
  1033. static inline void gainc_level_mode3s(AtracGainInfo *dst, AtracGainInfo *ref)
  1034. {
  1035.     int i;
  1036.  
  1037.     for (i = 0; i < dst->num_points; i++)
  1038.         dst->lev_code[i] = (i >= ref->num_points) ? 7 : ref->lev_code[i];
  1039. }
  1040.  
  1041. /**
  1042.  * Implements coding mode 1 (master) for gain compensation levels.
  1043.  *
  1044.  * @param[in]     gb     the GetBit context
  1045.  * @param[in]     ctx    ptr to the channel unit context
  1046.  * @param[out]    dst    ptr to the output array
  1047.  */
  1048. static inline void gainc_level_mode1m(GetBitContext *gb,
  1049.                                       Atrac3pChanUnitCtx *ctx,
  1050.                                       AtracGainInfo *dst)
  1051. {
  1052.     int i, delta;
  1053.  
  1054.     if (dst->num_points > 0)
  1055.         dst->lev_code[0] = get_vlc2(gb, gain_vlc_tabs[2].table,
  1056.                                     gain_vlc_tabs[2].bits, 1);
  1057.  
  1058.     for (i = 1; i < dst->num_points; i++) {
  1059.         delta = get_vlc2(gb, gain_vlc_tabs[3].table,
  1060.                          gain_vlc_tabs[3].bits, 1);
  1061.         dst->lev_code[i] = (dst->lev_code[i - 1] + delta) & 0xF;
  1062.     }
  1063. }
  1064.  
  1065. /**
  1066.  * Decode level code for each gain control point.
  1067.  *
  1068.  * @param[in]     gb              the GetBit context
  1069.  * @param[in,out] ctx             ptr to the channel unit context
  1070.  * @param[in]     ch_num          channel to process
  1071.  * @param[in]     coded_subbands  number of subbands to process
  1072.  * @return result code: 0 = OK, otherwise - error code
  1073.  */
  1074. static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1075.                                int ch_num, int coded_subbands)
  1076. {
  1077.     int sb, i, delta, delta_bits, min_val, pred;
  1078.     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
  1079.     Atrac3pChanParams *ref_chan = &ctx->channels[0];
  1080.  
  1081.     switch (get_bits(gb, 2)) { /* switch according to coding mode */
  1082.     case 0: /* fixed-length coding */
  1083.         for (sb = 0; sb < coded_subbands; sb++)
  1084.             for (i = 0; i < chan->gain_data[sb].num_points; i++)
  1085.                 chan->gain_data[sb].lev_code[i] = get_bits(gb, 4);
  1086.         break;
  1087.     case 1:
  1088.         if (ch_num) { /* VLC modulo delta to master channel */
  1089.             for (sb = 0; sb < coded_subbands; sb++)
  1090.                 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
  1091.                     delta = get_vlc2(gb, gain_vlc_tabs[5].table,
  1092.                                      gain_vlc_tabs[5].bits, 1);
  1093.                     pred = (i >= ref_chan->gain_data[sb].num_points)
  1094.                            ? 7 : ref_chan->gain_data[sb].lev_code[i];
  1095.                     chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF;
  1096.                 }
  1097.         } else { /* VLC modulo delta to previous */
  1098.             for (sb = 0; sb < coded_subbands; sb++)
  1099.                 gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]);
  1100.         }
  1101.         break;
  1102.     case 2:
  1103.         if (ch_num) { /* VLC modulo delta to previous or clone master */
  1104.             for (sb = 0; sb < coded_subbands; sb++)
  1105.                 if (chan->gain_data[sb].num_points > 0) {
  1106.                     if (get_bits1(gb))
  1107.                         gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]);
  1108.                     else
  1109.                         gainc_level_mode3s(&chan->gain_data[sb],
  1110.                                            &ref_chan->gain_data[sb]);
  1111.                 }
  1112.         } else { /* VLC modulo delta to lev_codes of previous subband */
  1113.             if (chan->gain_data[0].num_points > 0)
  1114.                 gainc_level_mode1m(gb, ctx, &chan->gain_data[0]);
  1115.  
  1116.             for (sb = 1; sb < coded_subbands; sb++)
  1117.                 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
  1118.                     delta = get_vlc2(gb, gain_vlc_tabs[4].table,
  1119.                                      gain_vlc_tabs[4].bits, 1);
  1120.                     pred = (i >= chan->gain_data[sb - 1].num_points)
  1121.                            ? 7 : chan->gain_data[sb - 1].lev_code[i];
  1122.                     chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF;
  1123.                 }
  1124.         }
  1125.         break;
  1126.     case 3:
  1127.         if (ch_num) { /* clone master */
  1128.             for (sb = 0; sb < coded_subbands; sb++)
  1129.                 gainc_level_mode3s(&chan->gain_data[sb],
  1130.                                    &ref_chan->gain_data[sb]);
  1131.         } else { /* shorter delta to min */
  1132.             delta_bits = get_bits(gb, 2);
  1133.             min_val    = get_bits(gb, 4);
  1134.  
  1135.             for (sb = 0; sb < coded_subbands; sb++)
  1136.                 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
  1137.                     chan->gain_data[sb].lev_code[i] = min_val + GET_DELTA(gb, delta_bits);
  1138.                     if (chan->gain_data[sb].lev_code[i] > 15)
  1139.                         return AVERROR_INVALIDDATA;
  1140.                 }
  1141.         }
  1142.         break;
  1143.     }
  1144.  
  1145.     return 0;
  1146. }
  1147.  
  1148. /**
  1149.  * Implements coding mode 0 for gain compensation locations.
  1150.  *
  1151.  * @param[in]     gb     the GetBit context
  1152.  * @param[in]     ctx    ptr to the channel unit context
  1153.  * @param[out]    dst    ptr to the output array
  1154.  * @param[in]     pos    position of the value to be processed
  1155.  */
  1156. static inline void gainc_loc_mode0(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1157.                                    AtracGainInfo *dst, int pos)
  1158. {
  1159.     int delta_bits;
  1160.  
  1161.     if (!pos || dst->loc_code[pos - 1] < 15)
  1162.         dst->loc_code[pos] = get_bits(gb, 5);
  1163.     else if (dst->loc_code[pos - 1] >= 30)
  1164.         dst->loc_code[pos] = 31;
  1165.     else {
  1166.         delta_bits         = av_log2(30 - dst->loc_code[pos - 1]) + 1;
  1167.         dst->loc_code[pos] = dst->loc_code[pos - 1] +
  1168.                              get_bits(gb, delta_bits) + 1;
  1169.     }
  1170. }
  1171.  
  1172. /**
  1173.  * Implements coding mode 1 for gain compensation locations.
  1174.  *
  1175.  * @param[in]     gb     the GetBit context
  1176.  * @param[in]     ctx    ptr to the channel unit context
  1177.  * @param[out]    dst    ptr to the output array
  1178.  */
  1179. static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1180.                                    AtracGainInfo *dst)
  1181. {
  1182.     int i;
  1183.     VLC *tab;
  1184.  
  1185.     if (dst->num_points > 0) {
  1186.         /* 1st coefficient is stored directly */
  1187.         dst->loc_code[0] = get_bits(gb, 5);
  1188.  
  1189.         for (i = 1; i < dst->num_points; i++) {
  1190.             /* switch VLC according to the curve direction
  1191.              * (ascending/descending) */
  1192.             tab              = (dst->lev_code[i] <= dst->lev_code[i - 1])
  1193.                                ? &gain_vlc_tabs[7]
  1194.                                : &gain_vlc_tabs[9];
  1195.             dst->loc_code[i] = dst->loc_code[i - 1] +
  1196.                                get_vlc2(gb, tab->table, tab->bits, 1);
  1197.         }
  1198.     }
  1199. }
  1200.  
  1201. /**
  1202.  * Decode location code for each gain control point.
  1203.  *
  1204.  * @param[in]     gb              the GetBit context
  1205.  * @param[in,out] ctx             ptr to the channel unit context
  1206.  * @param[in]     ch_num          channel to process
  1207.  * @param[in]     coded_subbands  number of subbands to process
  1208.  * @param[in]     avctx           ptr to the AVCodecContext
  1209.  * @return result code: 0 = OK, otherwise - error code
  1210.  */
  1211. static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1212.                                   int ch_num, int coded_subbands,
  1213.                                   AVCodecContext *avctx)
  1214. {
  1215.     int sb, i, delta, delta_bits, min_val, pred, more_than_ref;
  1216.     AtracGainInfo *dst, *ref;
  1217.     VLC *tab;
  1218.     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
  1219.     Atrac3pChanParams *ref_chan = &ctx->channels[0];
  1220.  
  1221.     switch (get_bits(gb, 2)) { /* switch according to coding mode */
  1222.     case 0: /* sequence of numbers in ascending order */
  1223.         for (sb = 0; sb < coded_subbands; sb++)
  1224.             for (i = 0; i < chan->gain_data[sb].num_points; i++)
  1225.                 gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i);
  1226.         break;
  1227.     case 1:
  1228.         if (ch_num) {
  1229.             for (sb = 0; sb < coded_subbands; sb++) {
  1230.                 if (chan->gain_data[sb].num_points <= 0)
  1231.                     continue;
  1232.                 dst = &chan->gain_data[sb];
  1233.                 ref = &ref_chan->gain_data[sb];
  1234.  
  1235.                 /* 1st value is vlc-coded modulo delta to master */
  1236.                 delta = get_vlc2(gb, gain_vlc_tabs[10].table,
  1237.                                  gain_vlc_tabs[10].bits, 1);
  1238.                 pred = ref->num_points > 0 ? ref->loc_code[0] : 0;
  1239.                 dst->loc_code[0] = (pred + delta) & 0x1F;
  1240.  
  1241.                 for (i = 1; i < dst->num_points; i++) {
  1242.                     more_than_ref = i >= ref->num_points;
  1243.                     if (dst->lev_code[i] > dst->lev_code[i - 1]) {
  1244.                         /* ascending curve */
  1245.                         if (more_than_ref) {
  1246.                             delta =
  1247.                                 get_vlc2(gb, gain_vlc_tabs[9].table,
  1248.                                          gain_vlc_tabs[9].bits, 1);
  1249.                             dst->loc_code[i] = dst->loc_code[i - 1] + delta;
  1250.                         } else {
  1251.                             if (get_bits1(gb))
  1252.                                 gainc_loc_mode0(gb, ctx, dst, i);  // direct coding
  1253.                             else
  1254.                                 dst->loc_code[i] = ref->loc_code[i];  // clone master
  1255.                         }
  1256.                     } else { /* descending curve */
  1257.                         tab   = more_than_ref ? &gain_vlc_tabs[7]
  1258.                                               : &gain_vlc_tabs[10];
  1259.                         delta = get_vlc2(gb, tab->table, tab->bits, 1);
  1260.                         if (more_than_ref)
  1261.                             dst->loc_code[i] = dst->loc_code[i - 1] + delta;
  1262.                         else
  1263.                             dst->loc_code[i] = (ref->loc_code[i] + delta) & 0x1F;
  1264.                     }
  1265.                 }
  1266.             }
  1267.         } else /* VLC delta to previous */
  1268.             for (sb = 0; sb < coded_subbands; sb++)
  1269.                 gainc_loc_mode1(gb, ctx, &chan->gain_data[sb]);
  1270.         break;
  1271.     case 2:
  1272.         if (ch_num) {
  1273.             for (sb = 0; sb < coded_subbands; sb++) {
  1274.                 if (chan->gain_data[sb].num_points <= 0)
  1275.                     continue;
  1276.                 dst = &chan->gain_data[sb];
  1277.                 ref = &ref_chan->gain_data[sb];
  1278.                 if (dst->num_points > ref->num_points || get_bits1(gb))
  1279.                     gainc_loc_mode1(gb, ctx, dst);
  1280.                 else /* clone master for the whole subband */
  1281.                     for (i = 0; i < chan->gain_data[sb].num_points; i++)
  1282.                         dst->loc_code[i] = ref->loc_code[i];
  1283.             }
  1284.         } else {
  1285.             /* data for the first subband is coded directly */
  1286.             for (i = 0; i < chan->gain_data[0].num_points; i++)
  1287.                 gainc_loc_mode0(gb, ctx, &chan->gain_data[0], i);
  1288.  
  1289.             for (sb = 1; sb < coded_subbands; sb++) {
  1290.                 if (chan->gain_data[sb].num_points <= 0)
  1291.                     continue;
  1292.                 dst = &chan->gain_data[sb];
  1293.  
  1294.                 /* 1st value is vlc-coded modulo delta to the corresponding
  1295.                  * value of the previous subband if any or zero */
  1296.                 delta = get_vlc2(gb, gain_vlc_tabs[6].table,
  1297.                                  gain_vlc_tabs[6].bits, 1);
  1298.                 pred             = dst[-1].num_points > 0
  1299.                                    ? dst[-1].loc_code[0] : 0;
  1300.                 dst->loc_code[0] = (pred + delta) & 0x1F;
  1301.  
  1302.                 for (i = 1; i < dst->num_points; i++) {
  1303.                     more_than_ref = i >= dst[-1].num_points;
  1304.                     /* Select VLC table according to curve direction and
  1305.                      * presence of prediction. */
  1306.                     tab = &gain_vlc_tabs[(dst->lev_code[i] > dst->lev_code[i - 1]) *
  1307.                                                    2 + more_than_ref + 6];
  1308.                     delta = get_vlc2(gb, tab->table, tab->bits, 1);
  1309.                     if (more_than_ref)
  1310.                         dst->loc_code[i] = dst->loc_code[i - 1] + delta;
  1311.                     else
  1312.                         dst->loc_code[i] = (dst[-1].loc_code[i] + delta) & 0x1F;
  1313.                 }
  1314.             }
  1315.         }
  1316.         break;
  1317.     case 3:
  1318.         if (ch_num) { /* clone master or direct or direct coding */
  1319.             for (sb = 0; sb < coded_subbands; sb++)
  1320.                 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
  1321.                     if (i >= ref_chan->gain_data[sb].num_points)
  1322.                         gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i);
  1323.                     else
  1324.                         chan->gain_data[sb].loc_code[i] =
  1325.                             ref_chan->gain_data[sb].loc_code[i];
  1326.                 }
  1327.         } else { /* shorter delta to min */
  1328.             delta_bits = get_bits(gb, 2) + 1;
  1329.             min_val    = get_bits(gb, 5);
  1330.  
  1331.             for (sb = 0; sb < coded_subbands; sb++)
  1332.                 for (i = 0; i < chan->gain_data[sb].num_points; i++)
  1333.                     chan->gain_data[sb].loc_code[i] = min_val + i +
  1334.                                                       get_bits(gb, delta_bits);
  1335.         }
  1336.         break;
  1337.     }
  1338.  
  1339.     /* Validate decoded information */
  1340.     for (sb = 0; sb < coded_subbands; sb++) {
  1341.         dst = &chan->gain_data[sb];
  1342.         for (i = 0; i < chan->gain_data[sb].num_points; i++) {
  1343.             if (dst->loc_code[i] < 0 || dst->loc_code[i] > 31 ||
  1344.                 (i && dst->loc_code[i] <= dst->loc_code[i - 1])) {
  1345.                 av_log(avctx, AV_LOG_ERROR,
  1346.                        "Invalid gain location: ch=%d, sb=%d, pos=%d, val=%d\n",
  1347.                        ch_num, sb, i, dst->loc_code[i]);
  1348.                 return AVERROR_INVALIDDATA;
  1349.             }
  1350.         }
  1351.     }
  1352.  
  1353.     return 0;
  1354. }
  1355.  
  1356. /**
  1357.  * Decode gain control data for all channels.
  1358.  *
  1359.  * @param[in]     gb            the GetBit context
  1360.  * @param[in,out] ctx           ptr to the channel unit context
  1361.  * @param[in]     num_channels  number of channels to process
  1362.  * @param[in]     avctx         ptr to the AVCodecContext
  1363.  * @return result code: 0 = OK, otherwise - error code
  1364.  */
  1365. static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1366.                              int num_channels, AVCodecContext *avctx)
  1367. {
  1368.     int ch_num, coded_subbands, sb, ret;
  1369.  
  1370.     for (ch_num = 0; ch_num < num_channels; ch_num++) {
  1371.         memset(ctx->channels[ch_num].gain_data, 0,
  1372.                sizeof(*ctx->channels[ch_num].gain_data) * ATRAC3P_SUBBANDS);
  1373.  
  1374.         if (get_bits1(gb)) { /* gain control data present? */
  1375.             coded_subbands = get_bits(gb, 4) + 1;
  1376.             if (get_bits1(gb)) /* is high band gain data replication on? */
  1377.                 ctx->channels[ch_num].num_gain_subbands = get_bits(gb, 4) + 1;
  1378.             else
  1379.                 ctx->channels[ch_num].num_gain_subbands = coded_subbands;
  1380.  
  1381.             if ((ret = decode_gainc_npoints(gb, ctx, ch_num, coded_subbands)) < 0 ||
  1382.                 (ret = decode_gainc_levels(gb, ctx, ch_num, coded_subbands))  < 0 ||
  1383.                 (ret = decode_gainc_loc_codes(gb, ctx, ch_num, coded_subbands, avctx)) < 0)
  1384.                 return ret;
  1385.  
  1386.             if (coded_subbands > 0) { /* propagate gain data if requested */
  1387.                 for (sb = coded_subbands; sb < ctx->channels[ch_num].num_gain_subbands; sb++)
  1388.                     ctx->channels[ch_num].gain_data[sb] =
  1389.                         ctx->channels[ch_num].gain_data[sb - 1];
  1390.             }
  1391.         } else {
  1392.             ctx->channels[ch_num].num_gain_subbands = 0;
  1393.         }
  1394.     }
  1395.  
  1396.     return 0;
  1397. }
  1398.  
  1399. /**
  1400.  * Decode envelope for all tones of a channel.
  1401.  *
  1402.  * @param[in]     gb                the GetBit context
  1403.  * @param[in,out] ctx               ptr to the channel unit context
  1404.  * @param[in]     ch_num            channel to process
  1405.  * @param[in]     band_has_tones    ptr to an array of per-band-flags:
  1406.  *                                  1 - tone data present
  1407.  */
  1408. static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1409.                                   int ch_num, int band_has_tones[])
  1410. {
  1411.     int sb;
  1412.     Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
  1413.     Atrac3pWavesData *ref = ctx->channels[0].tones_info;
  1414.  
  1415.     if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */
  1416.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1417.             if (!band_has_tones[sb])
  1418.                 continue;
  1419.             dst[sb].pend_env.has_start_point = get_bits1(gb);
  1420.             dst[sb].pend_env.start_pos       = dst[sb].pend_env.has_start_point
  1421.                                                ? get_bits(gb, 5) : -1;
  1422.             dst[sb].pend_env.has_stop_point  = get_bits1(gb);
  1423.             dst[sb].pend_env.stop_pos        = dst[sb].pend_env.has_stop_point
  1424.                                                ? get_bits(gb, 5) : 32;
  1425.         }
  1426.     } else { /* mode 1(slave only): copy master */
  1427.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1428.             if (!band_has_tones[sb])
  1429.                 continue;
  1430.             dst[sb].pend_env.has_start_point = ref[sb].pend_env.has_start_point;
  1431.             dst[sb].pend_env.has_stop_point  = ref[sb].pend_env.has_stop_point;
  1432.             dst[sb].pend_env.start_pos       = ref[sb].pend_env.start_pos;
  1433.             dst[sb].pend_env.stop_pos        = ref[sb].pend_env.stop_pos;
  1434.         }
  1435.     }
  1436. }
  1437.  
  1438. /**
  1439.  * Decode number of tones for each subband of a channel.
  1440.  *
  1441.  * @param[in]     gb                the GetBit context
  1442.  * @param[in,out] ctx               ptr to the channel unit context
  1443.  * @param[in]     ch_num            channel to process
  1444.  * @param[in]     band_has_tones    ptr to an array of per-band-flags:
  1445.  *                                  1 - tone data present
  1446.  * @param[in]     avctx             ptr to the AVCodecContext
  1447.  * @return result code: 0 = OK, otherwise - error code
  1448.  */
  1449. static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1450.                                int ch_num, int band_has_tones[],
  1451.                                AVCodecContext *avctx)
  1452. {
  1453.     int mode, sb, delta;
  1454.     Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
  1455.     Atrac3pWavesData *ref = ctx->channels[0].tones_info;
  1456.  
  1457.     mode = get_bits(gb, ch_num + 1);
  1458.     switch (mode) {
  1459.     case 0: /** fixed-length coding */
  1460.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
  1461.             if (band_has_tones[sb])
  1462.                 dst[sb].num_wavs = get_bits(gb, 4);
  1463.         break;
  1464.     case 1: /** variable-length coding */
  1465.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
  1466.             if (band_has_tones[sb])
  1467.                 dst[sb].num_wavs =
  1468.                     get_vlc2(gb, tone_vlc_tabs[1].table,
  1469.                              tone_vlc_tabs[1].bits, 1);
  1470.         break;
  1471.     case 2: /** VLC modulo delta to master (slave only) */
  1472.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
  1473.             if (band_has_tones[sb]) {
  1474.                 delta = get_vlc2(gb, tone_vlc_tabs[2].table,
  1475.                                  tone_vlc_tabs[2].bits, 1);
  1476.                 delta = sign_extend(delta, 3);
  1477.                 dst[sb].num_wavs = (ref[sb].num_wavs + delta) & 0xF;
  1478.             }
  1479.         break;
  1480.     case 3: /** copy master (slave only) */
  1481.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
  1482.             if (band_has_tones[sb])
  1483.                 dst[sb].num_wavs = ref[sb].num_wavs;
  1484.         break;
  1485.     }
  1486.  
  1487.     /** initialize start tone index for each subband */
  1488.     for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
  1489.         if (band_has_tones[sb]) {
  1490.             if (ctx->waves_info->tones_index + dst[sb].num_wavs > 48) {
  1491.                 av_log(avctx, AV_LOG_ERROR,
  1492.                        "Too many tones: %d (max. 48), frame: %d!\n",
  1493.                        ctx->waves_info->tones_index + dst[sb].num_wavs,
  1494.                        avctx->frame_number);
  1495.                 return AVERROR_INVALIDDATA;
  1496.             }
  1497.             dst[sb].start_index           = ctx->waves_info->tones_index;
  1498.             ctx->waves_info->tones_index += dst[sb].num_wavs;
  1499.         }
  1500.  
  1501.     return 0;
  1502. }
  1503.  
  1504. /**
  1505.  * Decode frequency information for each subband of a channel.
  1506.  *
  1507.  * @param[in]     gb                the GetBit context
  1508.  * @param[in,out] ctx               ptr to the channel unit context
  1509.  * @param[in]     ch_num            channel to process
  1510.  * @param[in]     band_has_tones    ptr to an array of per-band-flags:
  1511.  *                                  1 - tone data present
  1512.  */
  1513. static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1514.                                    int ch_num, int band_has_tones[])
  1515. {
  1516.     int sb, i, direction, nbits, pred, delta;
  1517.     Atrac3pWaveParam *iwav, *owav;
  1518.     Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
  1519.     Atrac3pWavesData *ref = ctx->channels[0].tones_info;
  1520.  
  1521.     if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */
  1522.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1523.             if (!band_has_tones[sb] || !dst[sb].num_wavs)
  1524.                 continue;
  1525.             iwav      = &ctx->waves_info->waves[dst[sb].start_index];
  1526.             direction = (dst[sb].num_wavs > 1) ? get_bits1(gb) : 0;
  1527.             if (direction) { /** packed numbers in descending order */
  1528.                 if (dst[sb].num_wavs)
  1529.                     iwav[dst[sb].num_wavs - 1].freq_index = get_bits(gb, 10);
  1530.                 for (i = dst[sb].num_wavs - 2; i >= 0 ; i--) {
  1531.                     nbits = av_log2(iwav[i+1].freq_index) + 1;
  1532.                     iwav[i].freq_index = get_bits(gb, nbits);
  1533.                 }
  1534.             } else { /** packed numbers in ascending order */
  1535.                 for (i = 0; i < dst[sb].num_wavs; i++) {
  1536.                     if (!i || iwav[i - 1].freq_index < 512)
  1537.                         iwav[i].freq_index = get_bits(gb, 10);
  1538.                     else {
  1539.                         nbits = av_log2(1023 - iwav[i - 1].freq_index) + 1;
  1540.                         iwav[i].freq_index = get_bits(gb, nbits) +
  1541.                                              1024 - (1 << nbits);
  1542.                     }
  1543.                 }
  1544.             }
  1545.         }
  1546.     } else { /* mode 1: VLC modulo delta to master (slave only) */
  1547.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1548.             if (!band_has_tones[sb] || !dst[sb].num_wavs)
  1549.                 continue;
  1550.             iwav = &ctx->waves_info->waves[ref[sb].start_index];
  1551.             owav = &ctx->waves_info->waves[dst[sb].start_index];
  1552.             for (i = 0; i < dst[sb].num_wavs; i++) {
  1553.                 delta = get_vlc2(gb, tone_vlc_tabs[6].table,
  1554.                                  tone_vlc_tabs[6].bits, 1);
  1555.                 delta = sign_extend(delta, 8);
  1556.                 pred  = (i < ref[sb].num_wavs) ? iwav[i].freq_index :
  1557.                         (ref[sb].num_wavs ? iwav[ref[sb].num_wavs - 1].freq_index : 0);
  1558.                 owav[i].freq_index = (pred + delta) & 0x3FF;
  1559.             }
  1560.         }
  1561.     }
  1562. }
  1563.  
  1564. /**
  1565.  * Decode amplitude information for each subband of a channel.
  1566.  *
  1567.  * @param[in]     gb                the GetBit context
  1568.  * @param[in,out] ctx               ptr to the channel unit context
  1569.  * @param[in]     ch_num            channel to process
  1570.  * @param[in]     band_has_tones    ptr to an array of per-band-flags:
  1571.  *                                  1 - tone data present
  1572.  */
  1573. static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1574.                                    int ch_num, int band_has_tones[])
  1575. {
  1576.     int mode, sb, j, i, diff, maxdiff, fi, delta, pred;
  1577.     Atrac3pWaveParam *wsrc, *wref;
  1578.     int refwaves[48] = { 0 };
  1579.     Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
  1580.     Atrac3pWavesData *ref = ctx->channels[0].tones_info;
  1581.  
  1582.     if (ch_num) {
  1583.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1584.             if (!band_has_tones[sb] || !dst[sb].num_wavs)
  1585.                 continue;
  1586.             wsrc = &ctx->waves_info->waves[dst[sb].start_index];
  1587.             wref = &ctx->waves_info->waves[ref[sb].start_index];
  1588.             for (j = 0; j < dst[sb].num_wavs; j++) {
  1589.                 for (i = 0, fi = 0, maxdiff = 1024; i < ref[sb].num_wavs; i++) {
  1590.                     diff = FFABS(wsrc[j].freq_index - wref[i].freq_index);
  1591.                     if (diff < maxdiff) {
  1592.                         maxdiff = diff;
  1593.                         fi      = i;
  1594.                     }
  1595.                 }
  1596.  
  1597.                 if (maxdiff < 8)
  1598.                     refwaves[dst[sb].start_index + j] = fi + ref[sb].start_index;
  1599.                 else if (j < ref[sb].num_wavs)
  1600.                     refwaves[dst[sb].start_index + j] = j + ref[sb].start_index;
  1601.                 else
  1602.                     refwaves[dst[sb].start_index + j] = -1;
  1603.             }
  1604.         }
  1605.     }
  1606.  
  1607.     mode = get_bits(gb, ch_num + 1);
  1608.  
  1609.     switch (mode) {
  1610.     case 0: /** fixed-length coding */
  1611.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1612.             if (!band_has_tones[sb] || !dst[sb].num_wavs)
  1613.                 continue;
  1614.             if (ctx->waves_info->amplitude_mode)
  1615.                 for (i = 0; i < dst[sb].num_wavs; i++)
  1616.                     ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = get_bits(gb, 6);
  1617.             else
  1618.                 ctx->waves_info->waves[dst[sb].start_index].amp_sf = get_bits(gb, 6);
  1619.         }
  1620.         break;
  1621.     case 1: /** min + VLC delta */
  1622.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1623.             if (!band_has_tones[sb] || !dst[sb].num_wavs)
  1624.                 continue;
  1625.             if (ctx->waves_info->amplitude_mode)
  1626.                 for (i = 0; i < dst[sb].num_wavs; i++)
  1627.                     ctx->waves_info->waves[dst[sb].start_index + i].amp_sf =
  1628.                         get_vlc2(gb, tone_vlc_tabs[3].table,
  1629.                                  tone_vlc_tabs[3].bits, 1) + 20;
  1630.             else
  1631.                 ctx->waves_info->waves[dst[sb].start_index].amp_sf =
  1632.                     get_vlc2(gb, tone_vlc_tabs[4].table,
  1633.                              tone_vlc_tabs[4].bits, 1) + 24;
  1634.         }
  1635.         break;
  1636.     case 2: /** VLC modulo delta to master (slave only) */
  1637.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1638.             if (!band_has_tones[sb] || !dst[sb].num_wavs)
  1639.                 continue;
  1640.             for (i = 0; i < dst[sb].num_wavs; i++) {
  1641.                 delta = get_vlc2(gb, tone_vlc_tabs[5].table,
  1642.                                  tone_vlc_tabs[5].bits, 1);
  1643.                 delta = sign_extend(delta, 5);
  1644.                 pred  = refwaves[dst[sb].start_index + i] >= 0 ?
  1645.                         ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf : 34;
  1646.                 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = (pred + delta) & 0x3F;
  1647.             }
  1648.         }
  1649.         break;
  1650.     case 3: /** clone master (slave only) */
  1651.         for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1652.             if (!band_has_tones[sb])
  1653.                 continue;
  1654.             for (i = 0; i < dst[sb].num_wavs; i++)
  1655.                 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf =
  1656.                     refwaves[dst[sb].start_index + i] >= 0
  1657.                     ? ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf
  1658.                     : 32;
  1659.         }
  1660.         break;
  1661.     }
  1662. }
  1663.  
  1664. /**
  1665.  * Decode phase information for each subband of a channel.
  1666.  *
  1667.  * @param[in]     gb                the GetBit context
  1668.  * @param[in,out] ctx               ptr to the channel unit context
  1669.  * @param[in]     ch_num            channel to process
  1670.  * @param[in]     band_has_tones    ptr to an array of per-band-flags:
  1671.  *                                  1 - tone data present
  1672.  */
  1673. static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1674.                                int ch_num, int band_has_tones[])
  1675. {
  1676.     int sb, i;
  1677.     Atrac3pWaveParam *wparam;
  1678.     Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
  1679.  
  1680.     for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
  1681.         if (!band_has_tones[sb])
  1682.             continue;
  1683.         wparam = &ctx->waves_info->waves[dst[sb].start_index];
  1684.         for (i = 0; i < dst[sb].num_wavs; i++)
  1685.             wparam[i].phase_index = get_bits(gb, 5);
  1686.     }
  1687. }
  1688.  
  1689. /**
  1690.  * Decode tones info for all channels.
  1691.  *
  1692.  * @param[in]     gb            the GetBit context
  1693.  * @param[in,out] ctx           ptr to the channel unit context
  1694.  * @param[in]     num_channels  number of channels to process
  1695.  * @param[in]     avctx         ptr to the AVCodecContext
  1696.  * @return result code: 0 = OK, otherwise - error code
  1697.  */
  1698. static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1699.                              int num_channels, AVCodecContext *avctx)
  1700. {
  1701.     int ch_num, i, ret;
  1702.     int band_has_tones[16];
  1703.  
  1704.     for (ch_num = 0; ch_num < num_channels; ch_num++)
  1705.         memset(ctx->channels[ch_num].tones_info, 0,
  1706.                sizeof(*ctx->channels[ch_num].tones_info) * ATRAC3P_SUBBANDS);
  1707.  
  1708.     ctx->waves_info->tones_present = get_bits1(gb);
  1709.     if (!ctx->waves_info->tones_present)
  1710.         return 0;
  1711.  
  1712.     memset(ctx->waves_info->waves, 0, sizeof(ctx->waves_info->waves));
  1713.  
  1714.     ctx->waves_info->amplitude_mode = get_bits1(gb);
  1715.     if (!ctx->waves_info->amplitude_mode) {
  1716.         avpriv_report_missing_feature(avctx, "GHA amplitude mode 0");
  1717.         return AVERROR_PATCHWELCOME;
  1718.     }
  1719.  
  1720.     ctx->waves_info->num_tone_bands =
  1721.         get_vlc2(gb, tone_vlc_tabs[0].table,
  1722.                  tone_vlc_tabs[0].bits, 1) + 1;
  1723.  
  1724.     if (num_channels == 2) {
  1725.         get_subband_flags(gb, ctx->waves_info->tone_sharing, ctx->waves_info->num_tone_bands);
  1726.         get_subband_flags(gb, ctx->waves_info->tone_master,  ctx->waves_info->num_tone_bands);
  1727.         get_subband_flags(gb, ctx->waves_info->invert_phase, ctx->waves_info->num_tone_bands);
  1728.     }
  1729.  
  1730.     ctx->waves_info->tones_index = 0;
  1731.  
  1732.     for (ch_num = 0; ch_num < num_channels; ch_num++) {
  1733.         for (i = 0; i < ctx->waves_info->num_tone_bands; i++)
  1734.             band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i];
  1735.  
  1736.         decode_tones_envelope(gb, ctx, ch_num, band_has_tones);
  1737.         if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones,
  1738.                                        avctx)) < 0)
  1739.             return ret;
  1740.  
  1741.         decode_tones_frequency(gb, ctx, ch_num, band_has_tones);
  1742.         decode_tones_amplitude(gb, ctx, ch_num, band_has_tones);
  1743.         decode_tones_phase(gb, ctx, ch_num, band_has_tones);
  1744.     }
  1745.  
  1746.     if (num_channels == 2) {
  1747.         for (i = 0; i < ctx->waves_info->num_tone_bands; i++) {
  1748.             if (ctx->waves_info->tone_sharing[i])
  1749.                 ctx->channels[1].tones_info[i] = ctx->channels[0].tones_info[i];
  1750.  
  1751.             if (ctx->waves_info->tone_master[i])
  1752.                 FFSWAP(Atrac3pWavesData, ctx->channels[0].tones_info[i],
  1753.                        ctx->channels[1].tones_info[i]);
  1754.         }
  1755.     }
  1756.  
  1757.     return 0;
  1758. }
  1759.  
  1760. int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
  1761.                                    int num_channels, AVCodecContext *avctx)
  1762. {
  1763.     int ret;
  1764.  
  1765.     /* parse sound header */
  1766.     ctx->num_quant_units = get_bits(gb, 5) + 1;
  1767.     if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) {
  1768.         av_log(avctx, AV_LOG_ERROR,
  1769.                "Invalid number of quantization units: %d!\n",
  1770.                ctx->num_quant_units);
  1771.         return AVERROR_INVALIDDATA;
  1772.     }
  1773.  
  1774.     ctx->mute_flag = get_bits1(gb);
  1775.  
  1776.     /* decode various sound parameters */
  1777.     if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0)
  1778.         return ret;
  1779.  
  1780.     ctx->num_subbands       = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1;
  1781.     ctx->num_coded_subbands = ctx->used_quant_units
  1782.                               ? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1
  1783.                               : 0;
  1784.  
  1785.     if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0)
  1786.         return ret;
  1787.  
  1788.     if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0)
  1789.         return ret;
  1790.  
  1791.     decode_spectrum(gb, ctx, num_channels, avctx);
  1792.  
  1793.     if (num_channels == 2) {
  1794.         get_subband_flags(gb, ctx->swap_channels, ctx->num_coded_subbands);
  1795.         get_subband_flags(gb, ctx->negate_coeffs, ctx->num_coded_subbands);
  1796.     }
  1797.  
  1798.     decode_window_shape(gb, ctx, num_channels);
  1799.  
  1800.     if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0)
  1801.         return ret;
  1802.  
  1803.     if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0)
  1804.         return ret;
  1805.  
  1806.     /* decode global noise info */
  1807.     ctx->noise_present = get_bits1(gb);
  1808.     if (ctx->noise_present) {
  1809.         ctx->noise_level_index = get_bits(gb, 4);
  1810.         ctx->noise_table_index = get_bits(gb, 4);
  1811.     }
  1812.  
  1813.     return 0;
  1814. }
  1815.