src/third_party/ffmpeg/libavcodec/atrac3plus.c

   1 /*
   2  * ATRAC3+ compatible decoder
   3  *
   4  * Copyright (c) 2010-2013 Maxim Poliakovski
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * Bitstream parser for ATRAC3+ decoder.
  26  */
  27
  28 #include "libavutil/avassert.h"
  29 #include "avcodec.h"
  30 #include "get_bits.h"
  31 #include "atrac3plus.h"
  32 #include "atrac3plus_data.h"
  33
  34 static VLC_TYPE tables_data[154276][2];
  35 static VLC wl_vlc_tabs[4];
  36 static VLC sf_vlc_tabs[8];
  37 static VLC ct_vlc_tabs[4];
  38 static VLC spec_vlc_tabs[112];
  39 static VLC gain_vlc_tabs[11];
  40 static VLC tone_vlc_tabs[7];
  41
  42 #define GET_DELTA(gb, delta_bits) \
  43     ((delta_bits) ? get_bits((gb), (delta_bits)) : 0)
  44
  45 /**
  46  * Generate canonical VLC table from given descriptor.
  47  *
  48  * @param[in]     cb          ptr to codebook descriptor
  49  * @param[in]     xlat        ptr to translation table or NULL
  50  * @param[in,out] tab_offset  starting offset to the generated vlc table
  51  * @param[out]    out_vlc     ptr to vlc table to be generated
  52  */
  53 static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t *xlat,
  54                                          int *tab_offset, VLC *out_vlc)
  55 {
  56     int i, b;
  57     uint16_t codes[256];
  58     uint8_t bits[256];
  59     unsigned code = 0;
  60     int index = 0;
  61     int min_len = *cb++; // get shortest codeword length
  62     int max_len = *cb++; // get longest  codeword length
  63
  64     for (b = min_len; b <= max_len; b++) {
  65         for (i = *cb++; i > 0; i--) {
  66             av_assert0(index < 256);
  67             bits[index]  = b;
  68             codes[index] = code++;
  69             index++;
  70         }
  71         code <<= 1;
  72     }
  73
  74     out_vlc->table = &tables_data[*tab_offset];
  75     out_vlc->table_allocated = 1 << max_len;
  76
  77     ff_init_vlc_sparse(out_vlc, max_len, index, bits, 1, 1, codes, 2, 2,
  78                        xlat, 1, 1, INIT_VLC_USE_NEW_STATIC);
  79
  80     *tab_offset += 1 << max_len;
  81 }
  82
  83 av_cold void ff_atrac3p_init_vlcs(void)
  84 {
  85     int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;
  86
  87     static const int wl_nb_bits[4]  = { 2, 3, 5, 5 };
  88     static const int wl_nb_codes[4] = { 3, 5, 8, 8 };
  89     static const uint8_t * const wl_bits[4] = {
  90         atrac3p_wl_huff_bits1, atrac3p_wl_huff_bits2,
  91         atrac3p_wl_huff_bits3, atrac3p_wl_huff_bits4
  92     };
  93     static const uint8_t * const wl_codes[4] = {
  94         atrac3p_wl_huff_code1, atrac3p_wl_huff_code2,
  95         atrac3p_wl_huff_code3, atrac3p_wl_huff_code4
  96     };
  97     static const uint8_t * const wl_xlats[4] = {
  98         atrac3p_wl_huff_xlat1, atrac3p_wl_huff_xlat2, NULL, NULL
  99     };
 100
 101     static const int ct_nb_bits[4]  = { 3, 4, 4, 4 };
 102     static const int ct_nb_codes[4] = { 4, 8, 8, 8 };
 103     static const uint8_t * const ct_bits[4]  = {
 104         atrac3p_ct_huff_bits1, atrac3p_ct_huff_bits2,
 105         atrac3p_ct_huff_bits2, atrac3p_ct_huff_bits3
 106     };
 107     static const uint8_t * const ct_codes[4] = {
 108         atrac3p_ct_huff_code1, atrac3p_ct_huff_code2,
 109         atrac3p_ct_huff_code2, atrac3p_ct_huff_code3
 110     };
 111     static const uint8_t * const ct_xlats[4] = {
 112         NULL, NULL, atrac3p_ct_huff_xlat1, NULL
 113     };
 114
 115     static const  int sf_nb_bits[8]  = {  9,  9,  9,  9,  6,  6,  7,  7 };
 116     static const  int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };
 117     static const uint8_t  * const sf_bits[8]  = {
 118         atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits2,
 119         atrac3p_sf_huff_bits3, atrac3p_sf_huff_bits4, atrac3p_sf_huff_bits4,
 120         atrac3p_sf_huff_bits5, atrac3p_sf_huff_bits6
 121     };
 122     static const uint16_t * const sf_codes[8] = {
 123         atrac3p_sf_huff_code1, atrac3p_sf_huff_code1, atrac3p_sf_huff_code2,
 124         atrac3p_sf_huff_code3, atrac3p_sf_huff_code4, atrac3p_sf_huff_code4,
 125         atrac3p_sf_huff_code5, atrac3p_sf_huff_code6
 126     };
 127     static const uint8_t  * const sf_xlats[8] = {
 128         atrac3p_sf_huff_xlat1, atrac3p_sf_huff_xlat2, NULL, NULL,
 129         atrac3p_sf_huff_xlat4, atrac3p_sf_huff_xlat5, NULL, NULL
 130     };
 131
 132     static const uint8_t * const gain_cbs[11] = {
 133         atrac3p_huff_gain_npoints1_cb, atrac3p_huff_gain_npoints1_cb,
 134         atrac3p_huff_gain_lev1_cb, atrac3p_huff_gain_lev2_cb,
 135         atrac3p_huff_gain_lev3_cb, atrac3p_huff_gain_lev4_cb,
 136         atrac3p_huff_gain_loc3_cb, atrac3p_huff_gain_loc1_cb,
 137         atrac3p_huff_gain_loc4_cb, atrac3p_huff_gain_loc2_cb,
 138         atrac3p_huff_gain_loc5_cb
 139     };
 140     static const uint8_t * const gain_xlats[11] = {
 141         NULL, atrac3p_huff_gain_npoints2_xlat, atrac3p_huff_gain_lev1_xlat,
 142         atrac3p_huff_gain_lev2_xlat, atrac3p_huff_gain_lev3_xlat,
 143         atrac3p_huff_gain_lev4_xlat, atrac3p_huff_gain_loc3_xlat,
 144         atrac3p_huff_gain_loc1_xlat, atrac3p_huff_gain_loc4_xlat,
 145         atrac3p_huff_gain_loc2_xlat, atrac3p_huff_gain_loc5_xlat
 146     };
 147
 148     static const uint8_t * const tone_cbs[7] = {
 149         atrac3p_huff_tonebands_cb,  atrac3p_huff_numwavs1_cb,
 150         atrac3p_huff_numwavs2_cb,   atrac3p_huff_wav_ampsf1_cb,
 151         atrac3p_huff_wav_ampsf2_cb, atrac3p_huff_wav_ampsf3_cb,
 152         atrac3p_huff_freq_cb
 153     };
 154     static const uint8_t * const tone_xlats[7] = {
 155         NULL, NULL, atrac3p_huff_numwavs2_xlat, atrac3p_huff_wav_ampsf1_xlat,
 156         atrac3p_huff_wav_ampsf2_xlat, atrac3p_huff_wav_ampsf3_xlat,
 157         atrac3p_huff_freq_xlat
 158     };
 159
 160     for (i = 0, wl_vlc_offs = 0, ct_vlc_offs = 2508; i < 4; i++) {
 161         wl_vlc_tabs[i].table = &tables_data[wl_vlc_offs];
 162         wl_vlc_tabs[i].table_allocated = 1 << wl_nb_bits[i];
 163         ct_vlc_tabs[i].table = &tables_data[ct_vlc_offs];
 164         ct_vlc_tabs[i].table_allocated = 1 << ct_nb_bits[i];
 165
 166         ff_init_vlc_sparse(&wl_vlc_tabs[i], wl_nb_bits[i], wl_nb_codes[i],
 167                            wl_bits[i],  1, 1,
 168                            wl_codes[i], 1, 1,
 169                            wl_xlats[i], 1, 1,
 170                            INIT_VLC_USE_NEW_STATIC);
 171
 172         ff_init_vlc_sparse(&ct_vlc_tabs[i], ct_nb_bits[i], ct_nb_codes[i],
 173                            ct_bits[i],  1, 1,
 174                            ct_codes[i], 1, 1,
 175                            ct_xlats[i], 1, 1,
 176                            INIT_VLC_USE_NEW_STATIC);
 177
 178         wl_vlc_offs += wl_vlc_tabs[i].table_allocated;
 179         ct_vlc_offs += ct_vlc_tabs[i].table_allocated;
 180     }
 181
 182     for (i = 0, sf_vlc_offs = 76; i < 8; i++) {
 183         sf_vlc_tabs[i].table = &tables_data[sf_vlc_offs];
 184         sf_vlc_tabs[i].table_allocated = 1 << sf_nb_bits[i];
 185
 186         ff_init_vlc_sparse(&sf_vlc_tabs[i], sf_nb_bits[i], sf_nb_codes[i],
 187                            sf_bits[i],  1, 1,
 188                            sf_codes[i], 2, 2,
 189                            sf_xlats[i], 1, 1,
 190                            INIT_VLC_USE_NEW_STATIC);
 191         sf_vlc_offs += sf_vlc_tabs[i].table_allocated;
 192     }
 193
 194     tab_offset = 2564;
 195
 196     /* build huffman tables for spectrum decoding */
 197     for (i = 0; i < 112; i++) {
 198         if (atrac3p_spectra_tabs[i].cb)
 199             build_canonical_huff(atrac3p_spectra_tabs[i].cb,
 200                                  atrac3p_spectra_tabs[i].xlat,
 201                                  &tab_offset, &spec_vlc_tabs[i]);
 202         else
 203             spec_vlc_tabs[i].table = 0;
 204     }
 205
 206     /* build huffman tables for gain data decoding */
 207     for (i = 0; i < 11; i++)
 208         build_canonical_huff(gain_cbs[i], gain_xlats[i], &tab_offset, &gain_vlc_tabs[i]);
 209
 210     /* build huffman tables for tone decoding */
 211     for (i = 0; i < 7; i++)
 212         build_canonical_huff(tone_cbs[i], tone_xlats[i], &tab_offset, &tone_vlc_tabs[i]);
 213 }
 214
 215 /**
 216  * Decode number of coded quantization units.
 217  *
 218  * @param[in]     gb            the GetBit context
 219  * @param[in,out] chan          ptr to the channel parameters
 220  * @param[in,out] ctx           ptr to the channel unit context
 221  * @param[in]     avctx         ptr to the AVCodecContext
 222  * @return result code: 0 = OK, otherwise - error code
 223  */
 224 static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan,
 225                            Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)
 226 {
 227     chan->fill_mode = get_bits(gb, 2);
 228     if (!chan->fill_mode) {
 229         chan->num_coded_vals = ctx->num_quant_units;
 230     } else {
 231         chan->num_coded_vals = get_bits(gb, 5);
 232         if (chan->num_coded_vals > ctx->num_quant_units) {
 233             av_log(avctx, AV_LOG_ERROR,
 234                    "Invalid number of transmitted units!\n");
 235             return AVERROR_INVALIDDATA;
 236         }
 237
 238         if (chan->fill_mode == 3)
 239             chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1;
 240     }
 241
 242     return 0;
 243 }
 244
 245 /**
 246  * Add weighting coefficients to the decoded word-length information.
 247  *
 248  * @param[in,out] ctx           ptr to the channel unit context
 249  * @param[in,out] chan          ptr to the channel parameters
 250  * @param[in]     wtab_idx      index of the table of weights
 251  * @param[in]     avctx         ptr to the AVCodecContext
 252  * @return result code: 0 = OK, otherwise - error code
 253  */
 254 static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx,
 255                                Atrac3pChanParams *chan, int wtab_idx,
 256                                AVCodecContext *avctx)
 257 {
 258     int i;
 259     const int8_t *weights_tab =
 260         &atrac3p_wl_weights[chan->ch_num * 3 + wtab_idx - 1][0];
 261
 262     for (i = 0; i < ctx->num_quant_units; i++) {
 263         chan->qu_wordlen[i] += weights_tab[i];
 264         if (chan->qu_wordlen[i] < 0 || chan->qu_wordlen[i] > 7) {
 265             av_log(avctx, AV_LOG_ERROR,
 266                    "WL index out of range: pos=%d, val=%d!\n",
 267                    i, chan->qu_wordlen[i]);
 268             return AVERROR_INVALIDDATA;
 269         }
 270     }
 271
 272     return 0;
 273 }
 274
 275 /**
 276  * Subtract weighting coefficients from decoded scalefactors.
 277  *
 278  * @param[in,out] ctx           ptr to the channel unit context
 279  * @param[in,out] chan          ptr to the channel parameters
 280  * @param[in]     wtab_idx      index of table of weights
 281  * @param[in]     avctx         ptr to the AVCodecContext
 282  * @return result code: 0 = OK, otherwise - error code
 283  */
 284 static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx,
 285                                Atrac3pChanParams *chan, int wtab_idx,
 286                                AVCodecContext *avctx)
 287 {
 288     int i;
 289     const int8_t *weights_tab = &atrac3p_sf_weights[wtab_idx - 1][0];
 290
 291     for (i = 0; i < ctx->used_quant_units; i++) {
 292         chan->qu_sf_idx[i] -= weights_tab[i];
 293         if (chan->qu_sf_idx[i] < 0 || chan->qu_sf_idx[i] > 63) {
 294             av_log(avctx, AV_LOG_ERROR,
 295                    "SF index out of range: pos=%d, val=%d!\n",
 296                    i, chan->qu_sf_idx[i]);
 297             return AVERROR_INVALIDDATA;
 298         }
 299     }
 300
 301     return 0;
 302 }
 303
 304 /**
 305  * Unpack vector quantization tables.
 306  *
 307  * @param[in]    start_val    start value for the unpacked table
 308  * @param[in]    shape_vec    ptr to table to unpack
 309  * @param[out]   dst          ptr to output array
 310  * @param[in]    num_values   number of values to unpack
 311  */
 312 static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec,
 313                                    int *dst, int num_values)
 314 {
 315     int i;
 316
 317     if (num_values) {
 318         dst[0] = dst[1] = dst[2] = start_val;
 319         for (i = 3; i < num_values; i++)
 320             dst[i] = start_val - shape_vec[atrac3p_qu_num_to_seg[i] - 1];
 321     }
 322 }
 323
 324 #define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals)                            \
 325     start_val = get_bits((gb), 6);                                       \
 326     unpack_vq_shape(start_val, &atrac3p_sf_shapes[get_bits((gb), 6)][0], \
 327                     (dst), (num_vals))
 328
 329 /**
 330  * Decode word length for each quantization unit of a channel.
 331  *
 332  * @param[in]     gb            the GetBit context
 333  * @param[in,out] ctx           ptr to the channel unit context
 334  * @param[in]     ch_num        channel to process
 335  * @param[in]     avctx         ptr to the AVCodecContext
 336  * @return result code: 0 = OK, otherwise - error code
 337  */
 338 static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 339                                   int ch_num, AVCodecContext *avctx)
 340 {
 341     int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag,
 342         ret, start_val;
 343     VLC *vlc_tab;
 344     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
 345     Atrac3pChanParams *ref_chan = &ctx->channels[0];
 346
 347     chan->fill_mode = 0;
 348
 349     switch (get_bits(gb, 2)) { /* switch according to coding mode */
 350     case 0: /* coded using constant number of bits */
 351         for (i = 0; i < ctx->num_quant_units; i++)
 352             chan->qu_wordlen[i] = get_bits(gb, 3);
 353         break;
 354     case 1:
 355         if (ch_num) {
 356             if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
 357                 return ret;
 358
 359             if (chan->num_coded_vals) {
 360                 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
 361
 362                 for (i = 0; i < chan->num_coded_vals; i++) {
 363                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 364                     chan->qu_wordlen[i] = (ref_chan->qu_wordlen[i] + delta) & 7;
 365                 }
 366             }
 367         } else {
 368             weight_idx = get_bits(gb, 2);
 369             if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
 370                 return ret;
 371
 372             if (chan->num_coded_vals) {
 373                 pos = get_bits(gb, 5);
 374                 if (pos > chan->num_coded_vals) {
 375                     av_log(avctx, AV_LOG_ERROR,
 376                            "WL mode 1: invalid position!\n");
 377                     return AVERROR_INVALIDDATA;
 378                 }
 379
 380                 delta_bits = get_bits(gb, 2);
 381                 min_val    = get_bits(gb, 3);
 382
 383                 for (i = 0; i < pos; i++)
 384                     chan->qu_wordlen[i] = get_bits(gb, 3);
 385
 386                 for (i = pos; i < chan->num_coded_vals; i++)
 387                     chan->qu_wordlen[i] = (min_val + GET_DELTA(gb, delta_bits)) & 7;
 388             }
 389         }
 390         break;
 391     case 2:
 392         if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
 393             return ret;
 394
 395         if (ch_num && chan->num_coded_vals) {
 396             vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
 397             delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 398             chan->qu_wordlen[0] = (ref_chan->qu_wordlen[0] + delta) & 7;
 399
 400             for (i = 1; i < chan->num_coded_vals; i++) {
 401                 diff = ref_chan->qu_wordlen[i] - ref_chan->qu_wordlen[i - 1];
 402                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 403                 chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + diff + delta) & 7;
 404             }
 405         } else if (chan->num_coded_vals) {
 406             flag    = get_bits(gb, 1);
 407             vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)];
 408
 409             start_val = get_bits(gb, 3);
 410             unpack_vq_shape(start_val,
 411                             &atrac3p_wl_shapes[start_val][get_bits(gb, 4)][0],
 412                             chan->qu_wordlen, chan->num_coded_vals);
 413
 414             if (!flag) {
 415                 for (i = 0; i < chan->num_coded_vals; i++) {
 416                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 417                     chan->qu_wordlen[i] = (chan->qu_wordlen[i] + delta) & 7;
 418                 }
 419             } else {
 420                 for (i = 0; i < (chan->num_coded_vals & - 2); i += 2)
 421                     if (!get_bits1(gb)) {
 422                         chan->qu_wordlen[i]     = (chan->qu_wordlen[i] +
 423                                                    get_vlc2(gb, vlc_tab->table,
 424                                                             vlc_tab->bits, 1)) & 7;
 425                         chan->qu_wordlen[i + 1] = (chan->qu_wordlen[i + 1] +
 426                                                    get_vlc2(gb, vlc_tab->table,
 427                                                             vlc_tab->bits, 1)) & 7;
 428                     }
 429
 430                 if (chan->num_coded_vals & 1)
 431                     chan->qu_wordlen[i] = (chan->qu_wordlen[i] +
 432                                            get_vlc2(gb, vlc_tab->table,
 433                                                     vlc_tab->bits, 1)) & 7;
 434             }
 435         }
 436         break;
 437     case 3:
 438         weight_idx = get_bits(gb, 2);
 439         if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
 440             return ret;
 441
 442         if (chan->num_coded_vals) {
 443             vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
 444
 445             /* first coefficient is coded directly */
 446             chan->qu_wordlen[0] = get_bits(gb, 3);
 447
 448             for (i = 1; i < chan->num_coded_vals; i++) {
 449                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 450                 chan->qu_wordlen[i] = (chan->qu_wordlen[i - 1] + delta) & 7;
 451             }
 452         }
 453         break;
 454     }
 455
 456     if (chan->fill_mode == 2) {
 457         for (i = chan->num_coded_vals; i < ctx->num_quant_units; i++)
 458             chan->qu_wordlen[i] = ch_num ? get_bits1(gb) : 1;
 459     } else if (chan->fill_mode == 3) {
 460         pos = ch_num ? chan->num_coded_vals + chan->split_point
 461                      : ctx->num_quant_units - chan->split_point;
 462         for (i = chan->num_coded_vals; i < pos; i++)
 463             chan->qu_wordlen[i] = 1;
 464     }
 465
 466     if (weight_idx)
 467         return add_wordlen_weights(ctx, chan, weight_idx, avctx);
 468
 469     return 0;
 470 }
 471
 472 /**
 473  * Decode scale factor indexes for each quant unit of a channel.
 474  *
 475  * @param[in]     gb            the GetBit context
 476  * @param[in,out] ctx           ptr to the channel unit context
 477  * @param[in]     ch_num        channel to process
 478  * @param[in]     avctx         ptr to the AVCodecContext
 479  * @return result code: 0 = OK, otherwise - error code
 480  */
 481 static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 482                                  int ch_num, AVCodecContext *avctx)
 483 {
 484     int i, weight_idx = 0, delta, diff, num_long_vals,
 485         delta_bits, min_val, vlc_sel, start_val;
 486     VLC *vlc_tab;
 487     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
 488     Atrac3pChanParams *ref_chan = &ctx->channels[0];
 489
 490     switch (get_bits(gb, 2)) { /* switch according to coding mode */
 491     case 0: /* coded using constant number of bits */
 492         for (i = 0; i < ctx->used_quant_units; i++)
 493             chan->qu_sf_idx[i] = get_bits(gb, 6);
 494         break;
 495     case 1:
 496         if (ch_num) {
 497             vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
 498
 499             for (i = 0; i < ctx->used_quant_units; i++) {
 500                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 501                 chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F;
 502             }
 503         } else {
 504             weight_idx = get_bits(gb, 2);
 505             if (weight_idx == 3) {
 506                 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
 507
 508                 num_long_vals = get_bits(gb, 5);
 509                 delta_bits    = get_bits(gb, 2);
 510                 min_val       = get_bits(gb, 4) - 7;
 511
 512                 for (i = 0; i < num_long_vals; i++)
 513                     chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
 514                                           get_bits(gb, 4) - 7) & 0x3F;
 515
 516                 /* all others are: min_val + delta */
 517                 for (i = num_long_vals; i < ctx->used_quant_units; i++)
 518                     chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val +
 519                                           GET_DELTA(gb, delta_bits)) & 0x3F;
 520             } else {
 521                 num_long_vals = get_bits(gb, 5);
 522                 delta_bits    = get_bits(gb, 3);
 523                 min_val       = get_bits(gb, 6);
 524                 if (num_long_vals > ctx->used_quant_units || delta_bits == 7) {
 525                     av_log(avctx, AV_LOG_ERROR,
 526                            "SF mode 1: invalid parameters!\n");
 527                     return AVERROR_INVALIDDATA;
 528                 }
 529
 530                 /* read full-precision SF indexes */
 531                 for (i = 0; i < num_long_vals; i++)
 532                     chan->qu_sf_idx[i] = get_bits(gb, 6);
 533
 534                 /* all others are: min_val + delta */
 535                 for (i = num_long_vals; i < ctx->used_quant_units; i++)
 536                     chan->qu_sf_idx[i] = (min_val +
 537                                           GET_DELTA(gb, delta_bits)) & 0x3F;
 538             }
 539         }
 540         break;
 541     case 2:
 542         if (ch_num) {
 543             vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
 544
 545             delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 546             chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F;
 547
 548             for (i = 1; i < ctx->used_quant_units; i++) {
 549                 diff  = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1];
 550                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 551                 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F;
 552             }
 553         } else {
 554             vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4];
 555
 556             UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
 557
 558             for (i = 0; i < ctx->used_quant_units; i++) {
 559                 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 560                 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
 561                                       sign_extend(delta, 4)) & 0x3F;
 562             }
 563         }
 564         break;
 565     case 3:
 566         if (ch_num) {
 567             /* copy coefficients from reference channel */
 568             for (i = 0; i < ctx->used_quant_units; i++)
 569                 chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i];
 570         } else {
 571             weight_idx = get_bits(gb, 2);
 572             vlc_sel    = get_bits(gb, 2);
 573             vlc_tab    = &sf_vlc_tabs[vlc_sel];
 574
 575             if (weight_idx == 3) {
 576                 vlc_tab = &sf_vlc_tabs[vlc_sel + 4];
 577
 578                 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
 579
 580                 diff               = (get_bits(gb, 4)    + 56)   & 0x3F;
 581                 chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F;
 582
 583                 for (i = 1; i < ctx->used_quant_units; i++) {
 584                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 585                     diff               = (diff + sign_extend(delta, 4)) & 0x3F;
 586                     chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i])    & 0x3F;
 587                 }
 588             } else {
 589                 /* 1st coefficient is coded directly */
 590                 chan->qu_sf_idx[0] = get_bits(gb, 6);
 591
 592                 for (i = 1; i < ctx->used_quant_units; i++) {
 593                     delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
 594                     chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F;
 595                 }
 596             }
 597         }
 598         break;
 599     }
 600
 601     if (weight_idx && weight_idx < 3)
 602         return subtract_sf_weights(ctx, chan, weight_idx, avctx);
 603
 604     return 0;
 605 }
 606
 607 /**
 608  * Decode word length information for each channel.
 609  *
 610  * @param[in]     gb            the GetBit context
 611  * @param[in,out] ctx           ptr to the channel unit context
 612  * @param[in]     num_channels  number of channels to process
 613  * @param[in]     avctx         ptr to the AVCodecContext
 614  * @return result code: 0 = OK, otherwise - error code
 615  */
 616 static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 617                                 int num_channels, AVCodecContext *avctx)
 618 {
 619     int ch_num, i, ret;
 620
 621     for (ch_num = 0; ch_num < num_channels; ch_num++) {
 622         memset(ctx->channels[ch_num].qu_wordlen, 0,
 623                sizeof(ctx->channels[ch_num].qu_wordlen));
 624
 625         if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0)
 626             return ret;
 627     }
 628
 629     /* scan for last non-zero coeff in both channels and
 630      * set number of quant units having coded spectrum */
 631     for (i = ctx->num_quant_units - 1; i >= 0; i--)
 632         if (ctx->channels[0].qu_wordlen[i] ||
 633             (num_channels == 2 && ctx->channels[1].qu_wordlen[i]))
 634             break;
 635     ctx->used_quant_units = i + 1;
 636
 637     return 0;
 638 }
 639
 640 /**
 641  * Decode scale factor indexes for each channel.
 642  *
 643  * @param[in]     gb            the GetBit context
 644  * @param[in,out] ctx           ptr to the channel unit context
 645  * @param[in]     num_channels  number of channels to process
 646  * @param[in]     avctx         ptr to the AVCodecContext
 647  * @return result code: 0 = OK, otherwise - error code
 648  */
 649 static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 650                                 int num_channels, AVCodecContext *avctx)
 651 {
 652     int ch_num, ret;
 653
 654     if (!ctx->used_quant_units)
 655         return 0;
 656
 657     for (ch_num = 0; ch_num < num_channels; ch_num++) {
 658         memset(ctx->channels[ch_num].qu_sf_idx, 0,
 659                sizeof(ctx->channels[ch_num].qu_sf_idx));
 660
 661         if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0)
 662             return ret;
 663     }
 664
 665     return 0;
 666 }
 667
 668 /**
 669  * Decode number of code table values.
 670  *
 671  * @param[in]     gb            the GetBit context
 672  * @param[in,out] ctx           ptr to the channel unit context
 673  * @param[in]     avctx         ptr to the AVCodecContext
 674  * @return result code: 0 = OK, otherwise - error code
 675  */
 676 static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 677                              AVCodecContext *avctx)
 678 {
 679     int num_coded_vals;
 680
 681     if (get_bits1(gb)) {
 682         num_coded_vals = get_bits(gb, 5);
 683         if (num_coded_vals > ctx->used_quant_units) {
 684             av_log(avctx, AV_LOG_ERROR,
 685                    "Invalid number of code table indexes: %d!\n", num_coded_vals);
 686             return AVERROR_INVALIDDATA;
 687         }
 688         return num_coded_vals;
 689     } else
 690         return ctx->used_quant_units;
 691 }
 692
 693 #define DEC_CT_IDX_COMMON(OP)                                           \
 694     num_vals = get_num_ct_values(gb, ctx, avctx);                       \
 695     if (num_vals < 0)                                                   \
 696         return num_vals;                                                \
 697                                                                         \
 698     for (i = 0; i < num_vals; i++) {                                    \
 699         if (chan->qu_wordlen[i]) {                                      \
 700             chan->qu_tab_idx[i] = OP;                                   \
 701         } else if (ch_num && ref_chan->qu_wordlen[i])                   \
 702             /* get clone master flag */                                 \
 703             chan->qu_tab_idx[i] = get_bits1(gb);                        \
 704     }
 705
 706 #define CODING_DIRECT get_bits(gb, num_bits)
 707
 708 #define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)
 709
 710 #define CODING_VLC_DELTA                                                \
 711     (!i) ? CODING_VLC                                                   \
 712          : (pred + get_vlc2(gb, delta_vlc->table,                       \
 713                             delta_vlc->bits, 1)) & mask;                \
 714     pred = chan->qu_tab_idx[i]
 715
 716 #define CODING_VLC_DIFF                                                 \
 717     (ref_chan->qu_tab_idx[i] +                                          \
 718      get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask
 719
 720 /**
 721  * Decode code table indexes for each quant unit of a channel.
 722  *
 723  * @param[in]     gb            the GetBit context
 724  * @param[in,out] ctx           ptr to the channel unit context
 725  * @param[in]     ch_num        channel to process
 726  * @param[in]     avctx         ptr to the AVCodecContext
 727  * @return result code: 0 = OK, otherwise - error code
 728  */
 729 static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 730                                    int ch_num, AVCodecContext *avctx)
 731 {
 732     int i, num_vals, num_bits, pred;
 733     int mask = ctx->use_full_table ? 7 : 3; /* mask for modular arithmetic */
 734     VLC *vlc_tab, *delta_vlc;
 735     Atrac3pChanParams *chan     = &ctx->channels[ch_num];
 736     Atrac3pChanParams *ref_chan = &ctx->channels[0];
 737
 738     chan->table_type = get_bits1(gb);
 739
 740     switch (get_bits(gb, 2)) { /* switch according to coding mode */
 741     case 0: /* directly coded */
 742         num_bits = ctx->use_full_table + 2;
 743         DEC_CT_IDX_COMMON(CODING_DIRECT);
 744         break;
 745     case 1: /* entropy-coded */
 746         vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1]
 747                                       : ct_vlc_tabs;
 748         DEC_CT_IDX_COMMON(CODING_VLC);
 749         break;
 750     case 2: /* entropy-coded delta */
 751         if (ctx->use_full_table) {
 752             vlc_tab   = &ct_vlc_tabs[1];
 753             delta_vlc = &ct_vlc_tabs[2];
 754         } else {
 755             vlc_tab   = ct_vlc_tabs;
 756             delta_vlc = ct_vlc_tabs;
 757         }
 758         pred = 0;
 759         DEC_CT_IDX_COMMON(CODING_VLC_DELTA);
 760         break;
 761     case 3: /* entropy-coded difference to master */
 762         if (ch_num) {
 763             vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[3]
 764                                           : ct_vlc_tabs;
 765             DEC_CT_IDX_COMMON(CODING_VLC_DIFF);
 766         }
 767         break;
 768     }
 769
 770     return 0;
 771 }
 772
 773 /**
 774  * Decode code table indexes for each channel.
 775  *
 776  * @param[in]     gb            the GetBit context
 777  * @param[in,out] ctx           ptr to the channel unit context
 778  * @param[in]     num_channels  number of channels to process
 779  * @param[in]     avctx         ptr to the AVCodecContext
 780  * @return result code: 0 = OK, otherwise - error code
 781  */
 782 static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
 783                                      int num_channels, AVCodecContext *avctx)
 784 {
 785     int ch_num, ret;
 786
 787     if (!ctx->used_quant_units)
 788         return 0;
 789
 790     ctx->use_full_table = get_bits1(gb);
 791
 792     for (ch_num = 0; ch_num < num_channels; ch_num++) {
 793         memset(ctx->channels[ch_num].qu_tab_idx, 0,
 794                sizeof(ctx->channels[ch_num].qu_tab_idx));
 795
 796         if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0)
 797             return ret;
 798     }
 799
 800     return 0;
 801 }
 802
 803 /**
 804  * Decode huffman-coded spectral lines for a given quant unit.
 805  *
 806  * This is a generalized version for all known coding modes.
 807  * Its speed can be improved by creating separate functions for each mode.
 808  *
 809  * @param[in]   gb          the GetBit context
 810  * @param[in]   tab         code table telling how to decode spectral lines
 811  * @param[in]   vlc_tab     ptr to the huffman table associated with the code table
 812  * @param[out]  out         pointer to buffer where decoded data should be stored
 813  * @param[in]   num_specs   number of spectral lines to decode
 814  */
 815 static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,
 816                               VLC *vlc_tab, int16_t *out, const int num_specs)
 817 {
 818     int i, j, pos, cf;
 819     int group_size = tab->group_size;
 820     int num_coeffs = tab->num_coeffs;
 821     int bits       = tab->bits;
 822     int is_signed  = tab->is_signed;
 823     unsigned val, 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 }