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