git.sesse.net Git - ffmpeg/blob - libavcodec/atrac3plus.c

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