falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
39979 Commits
32 Branches
821MB
Tree: 593886b5dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '593886b5dd'
${ noResults }
FFmpeg/libavcodec/atrac3plus.c

1819 lines
70KB
Raw Blame History 

  1. /*

  2.  * ATRAC3+ compatible decoder

  3.  *

  4.  * Copyright (c) 2010-2013 Maxim Poliakovski

  5.  *

  6.  * This file is part of Libav.

  7.  *

  8.  * Libav 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.  * Libav 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 Libav; 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(AVCodec *codec)

  84. {

  85.     int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;

  86. 

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

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

  89.     static const uint8_t *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 *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 *wl_xlats[4] = {

  98.         atrac3p_wl_huff_xlat1, atrac3p_wl_huff_xlat2, NULL, NULL

  99.     };

  100. 

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

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

  103.     static const uint8_t *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 *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 *ct_xlats[4] = {

  112.         NULL, NULL, atrac3p_ct_huff_xlat1, NULL

  113.     };

  114. 

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

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

  117.     static const uint8_t  *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 *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  *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 *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 *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 *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 *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, mask = (1 << bits) - 1;

  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 = val & mask;

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

  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.         if (get_subband_flags(gb, ctx->waves_info->phase_shift,

  1728.                               ctx->waves_info->num_tone_bands)) {

  1729.             avpriv_report_missing_feature(avctx, "GHA Phase shifting");

  1730.             return AVERROR_PATCHWELCOME;

  1731.         }

  1732.     }

  1733. 

  1734.     ctx->waves_info->tones_index = 0;

  1735. 

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

  1737.         for (i = 0; i < ctx->waves_info->num_tone_bands; i++)

  1738.             band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i];

  1739. 

  1740.         decode_tones_envelope(gb, ctx, ch_num, band_has_tones);

  1741.         if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones,

  1742.                                        avctx)) < 0)

  1743.             return ret;

  1744. 

  1745.         decode_tones_frequency(gb, ctx, ch_num, band_has_tones);

  1746.         decode_tones_amplitude(gb, ctx, ch_num, band_has_tones);

  1747.         decode_tones_phase(gb, ctx, ch_num, band_has_tones);

  1748.     }

  1749. 

  1750.     if (num_channels == 2) {

  1751.         for (i = 0; i < ctx->waves_info->num_tone_bands; i++) {

  1752.             if (ctx->waves_info->tone_sharing[i])

  1753.                 ctx->channels[1].tones_info[i] = ctx->channels[0].tones_info[i];

  1754. 

  1755.             if (ctx->waves_info->tone_master[i])

  1756.                 FFSWAP(Atrac3pWavesData, ctx->channels[0].tones_info[i],

  1757.                        ctx->channels[1].tones_info[i]);

  1758.         }

  1759.     }

  1760. 

  1761.     return 0;

  1762. }

  1763. 

  1764. int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,

  1765.                                    int num_channels, AVCodecContext *avctx)

  1766. {

  1767.     int ret;

  1768. 

  1769.     /* parse sound header */

  1770.     ctx->num_quant_units = get_bits(gb, 5) + 1;

  1771.     if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) {

  1772.         av_log(avctx, AV_LOG_ERROR,

  1773.                "Invalid number of quantization units: %d!\n",

  1774.                ctx->num_quant_units);

  1775.         return AVERROR_INVALIDDATA;

  1776.     }

  1777. 

  1778.     ctx->mute_flag = get_bits1(gb);

  1779. 

  1780.     /* decode various sound parameters */

  1781.     if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0)

  1782.         return ret;

  1783. 

  1784.     ctx->num_subbands       = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1;

  1785.     ctx->num_coded_subbands = ctx->used_quant_units

  1786.                               ? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1

  1787.                               : 0;

  1788. 

  1789.     if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0)

  1790.         return ret;

  1791. 

  1792.     if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0)

  1793.         return ret;

  1794. 

  1795.     decode_spectrum(gb, ctx, num_channels, avctx);

  1796. 

  1797.     if (num_channels == 2) {

  1798.         get_subband_flags(gb, ctx->swap_channels, ctx->num_coded_subbands);

  1799.         get_subband_flags(gb, ctx->negate_coeffs, ctx->num_coded_subbands);

  1800.     }

  1801. 

  1802.     decode_window_shape(gb, ctx, num_channels);

  1803. 

  1804.     if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0)

  1805.         return ret;

  1806. 

  1807.     if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0)

  1808.         return ret;

  1809. 

  1810.     /* decode global noise info */

  1811.     ctx->noise_present = get_bits1(gb);

  1812.     if (ctx->noise_present) {

  1813.         ctx->noise_level_index = get_bits(gb, 4);

  1814.         ctx->noise_table_index = get_bits(gb, 4);

  1815.     }

  1816. 

  1817.     return 0;

  1818. }