2 * ATRAC3+ compatible decoder
4 * Copyright (c) 2010-2013 Maxim Poliakovski
6 * This file is part of FFmpeg.
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.
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.
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
25 * Bitstream parser for ATRAC3+ decoder.
28 #include "libavutil/avassert.h"
31 #include "atrac3plus.h"
32 #include "atrac3plus_data.h"
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];
43 * Generate canonical VLC table from given descriptor.
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
50 static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t *xlat,
51 int *tab_offset, VLC *out_vlc)
58 int min_len = *cb++; // get shortest codeword length
59 int max_len = *cb++; // get longest codeword length
61 for (b = min_len; b <= max_len; b++) {
62 for (i = *cb++; i > 0; i--) {
63 av_assert0(index < 256);
65 codes[index] = code++;
71 out_vlc->table = &tables_data[*tab_offset];
72 out_vlc->table_allocated = 1 << max_len;
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);
77 *tab_offset += 1 << max_len;
80 av_cold void ff_atrac3p_init_vlcs(void)
82 int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;
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
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
94 static const uint8_t * const wl_xlats[4] = {
95 atrac3p_wl_huff_xlat1, atrac3p_wl_huff_xlat2, NULL, NULL
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
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
108 static const uint8_t * const ct_xlats[4] = {
109 NULL, NULL, atrac3p_ct_huff_xlat1, NULL
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
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
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
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
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
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,
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
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];
163 ff_init_vlc_sparse(&wl_vlc_tabs[i], wl_nb_bits[i], wl_nb_codes[i],
167 INIT_VLC_USE_NEW_STATIC);
169 ff_init_vlc_sparse(&ct_vlc_tabs[i], ct_nb_bits[i], ct_nb_codes[i],
173 INIT_VLC_USE_NEW_STATIC);
175 wl_vlc_offs += wl_vlc_tabs[i].table_allocated;
176 ct_vlc_offs += ct_vlc_tabs[i].table_allocated;
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];
183 ff_init_vlc_sparse(&sf_vlc_tabs[i], sf_nb_bits[i], sf_nb_codes[i],
187 INIT_VLC_USE_NEW_STATIC);
188 sf_vlc_offs += sf_vlc_tabs[i].table_allocated;
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]);
200 spec_vlc_tabs[i].table = 0;
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]);
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]);
213 * Decode number of coded quantization units.
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
221 static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan,
222 Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)
224 chan->fill_mode = get_bits(gb, 2);
225 if (!chan->fill_mode) {
226 chan->num_coded_vals = ctx->num_quant_units;
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;
235 if (chan->fill_mode == 3)
236 chan->split_point = get_bits(gb, 2) + (chan->ch_num << 1) + 1;
243 * Add weighting coefficients to the decoded word-length information.
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
251 static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx,
252 Atrac3pChanParams *chan, int wtab_idx,
253 AVCodecContext *avctx)
256 const int8_t *weights_tab =
257 &atrac3p_wl_weights[chan->ch_num * 3 + wtab_idx - 1][0];
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;
273 * Subtract weighting coefficients from decoded scalefactors.
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
281 static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx,
282 Atrac3pChanParams *chan, int wtab_idx,
283 AVCodecContext *avctx)
286 const int8_t *weights_tab = &atrac3p_sf_weights[wtab_idx - 1][0];
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;
302 * Unpack vector quantization tables.
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
309 static inline void unpack_vq_shape(int start_val, const int8_t *shape_vec,
310 int *dst, int 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];
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], \
327 * Decode word length for each quantization unit of a channel.
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
335 static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
336 int ch_num, AVCodecContext *avctx)
338 int i, weight_idx = 0, delta, diff, pos, delta_bits, min_val, flag,
341 Atrac3pChanParams *chan = &ctx->channels[ch_num];
342 Atrac3pChanParams *ref_chan = &ctx->channels[0];
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);
353 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
356 if (chan->num_coded_vals) {
357 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
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;
365 weight_idx = get_bits(gb, 2);
366 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
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;
377 delta_bits = get_bits(gb, 2);
378 min_val = get_bits(gb, 3);
380 for (i = 0; i < pos; i++)
381 chan->qu_wordlen[i] = get_bits(gb, 3);
383 for (i = pos; i < chan->num_coded_vals; i++)
384 chan->qu_wordlen[i] = (min_val + get_bitsz(gb, delta_bits)) & 7;
389 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
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;
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;
402 } else if (chan->num_coded_vals) {
403 flag = get_bits(gb, 1);
404 vlc_tab = &wl_vlc_tabs[get_bits(gb, 1)];
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);
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;
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;
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;
435 weight_idx = get_bits(gb, 2);
436 if ((ret = num_coded_units(gb, chan, ctx, avctx)) < 0)
439 if (chan->num_coded_vals) {
440 vlc_tab = &wl_vlc_tabs[get_bits(gb, 2)];
442 /* first coefficient is coded directly */
443 chan->qu_wordlen[0] = get_bits(gb, 3);
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;
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 if (pos > FF_ARRAY_ELEMS(chan->qu_wordlen)) {
460 av_log(avctx, AV_LOG_ERROR, "Split point beyond array\n");
461 pos = FF_ARRAY_ELEMS(chan->qu_wordlen);
463 for (i = chan->num_coded_vals; i < pos; i++)
464 chan->qu_wordlen[i] = 1;
468 return add_wordlen_weights(ctx, chan, weight_idx, avctx);
474 * Decode scale factor indexes for each quant unit of a channel.
476 * @param[in] gb the GetBit context
477 * @param[in,out] ctx ptr to the channel unit context
478 * @param[in] ch_num channel to process
479 * @param[in] avctx ptr to the AVCodecContext
480 * @return result code: 0 = OK, otherwise - error code
482 static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
483 int ch_num, AVCodecContext *avctx)
485 int i, weight_idx = 0, delta, diff, num_long_vals,
486 delta_bits, min_val, vlc_sel, start_val;
488 Atrac3pChanParams *chan = &ctx->channels[ch_num];
489 Atrac3pChanParams *ref_chan = &ctx->channels[0];
491 switch (get_bits(gb, 2)) { /* switch according to coding mode */
492 case 0: /* coded using constant number of bits */
493 for (i = 0; i < ctx->used_quant_units; i++)
494 chan->qu_sf_idx[i] = get_bits(gb, 6);
498 vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
500 for (i = 0; i < ctx->used_quant_units; i++) {
501 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
502 chan->qu_sf_idx[i] = (ref_chan->qu_sf_idx[i] + delta) & 0x3F;
505 weight_idx = get_bits(gb, 2);
506 if (weight_idx == 3) {
507 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
509 num_long_vals = get_bits(gb, 5);
510 delta_bits = get_bits(gb, 2);
511 min_val = get_bits(gb, 4) - 7;
513 for (i = 0; i < num_long_vals; i++)
514 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
515 get_bits(gb, 4) - 7) & 0x3F;
517 /* all others are: min_val + delta */
518 for (i = num_long_vals; i < ctx->used_quant_units; i++)
519 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] + min_val +
520 get_bitsz(gb, delta_bits)) & 0x3F;
522 num_long_vals = get_bits(gb, 5);
523 delta_bits = get_bits(gb, 3);
524 min_val = get_bits(gb, 6);
525 if (num_long_vals > ctx->used_quant_units || delta_bits == 7) {
526 av_log(avctx, AV_LOG_ERROR,
527 "SF mode 1: invalid parameters!\n");
528 return AVERROR_INVALIDDATA;
531 /* read full-precision SF indexes */
532 for (i = 0; i < num_long_vals; i++)
533 chan->qu_sf_idx[i] = get_bits(gb, 6);
535 /* all others are: min_val + delta */
536 for (i = num_long_vals; i < ctx->used_quant_units; i++)
537 chan->qu_sf_idx[i] = (min_val +
538 get_bitsz(gb, delta_bits)) & 0x3F;
544 vlc_tab = &sf_vlc_tabs[get_bits(gb, 2)];
546 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
547 chan->qu_sf_idx[0] = (ref_chan->qu_sf_idx[0] + delta) & 0x3F;
549 for (i = 1; i < ctx->used_quant_units; i++) {
550 diff = ref_chan->qu_sf_idx[i] - ref_chan->qu_sf_idx[i - 1];
551 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
552 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + diff + delta) & 0x3F;
555 vlc_tab = &sf_vlc_tabs[get_bits(gb, 2) + 4];
557 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
559 for (i = 0; i < ctx->used_quant_units; i++) {
560 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
561 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i] +
562 sign_extend(delta, 4)) & 0x3F;
568 /* copy coefficients from reference channel */
569 for (i = 0; i < ctx->used_quant_units; i++)
570 chan->qu_sf_idx[i] = ref_chan->qu_sf_idx[i];
572 weight_idx = get_bits(gb, 2);
573 vlc_sel = get_bits(gb, 2);
574 vlc_tab = &sf_vlc_tabs[vlc_sel];
576 if (weight_idx == 3) {
577 vlc_tab = &sf_vlc_tabs[vlc_sel + 4];
579 UNPACK_SF_VQ_SHAPE(gb, chan->qu_sf_idx, ctx->used_quant_units);
581 diff = (get_bits(gb, 4) + 56) & 0x3F;
582 chan->qu_sf_idx[0] = (chan->qu_sf_idx[0] + diff) & 0x3F;
584 for (i = 1; i < ctx->used_quant_units; i++) {
585 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
586 diff = (diff + sign_extend(delta, 4)) & 0x3F;
587 chan->qu_sf_idx[i] = (diff + chan->qu_sf_idx[i]) & 0x3F;
590 /* 1st coefficient is coded directly */
591 chan->qu_sf_idx[0] = get_bits(gb, 6);
593 for (i = 1; i < ctx->used_quant_units; i++) {
594 delta = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
595 chan->qu_sf_idx[i] = (chan->qu_sf_idx[i - 1] + delta) & 0x3F;
602 if (weight_idx && weight_idx < 3)
603 return subtract_sf_weights(ctx, chan, weight_idx, avctx);
609 * Decode word length information for each channel.
611 * @param[in] gb the GetBit context
612 * @param[in,out] ctx ptr to the channel unit context
613 * @param[in] num_channels number of channels to process
614 * @param[in] avctx ptr to the AVCodecContext
615 * @return result code: 0 = OK, otherwise - error code
617 static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
618 int num_channels, AVCodecContext *avctx)
622 for (ch_num = 0; ch_num < num_channels; ch_num++) {
623 memset(ctx->channels[ch_num].qu_wordlen, 0,
624 sizeof(ctx->channels[ch_num].qu_wordlen));
626 if ((ret = decode_channel_wordlen(gb, ctx, ch_num, avctx)) < 0)
630 /* scan for last non-zero coeff in both channels and
631 * set number of quant units having coded spectrum */
632 for (i = ctx->num_quant_units - 1; i >= 0; i--)
633 if (ctx->channels[0].qu_wordlen[i] ||
634 (num_channels == 2 && ctx->channels[1].qu_wordlen[i]))
636 ctx->used_quant_units = i + 1;
642 * Decode scale factor indexes for each channel.
644 * @param[in] gb the GetBit context
645 * @param[in,out] ctx ptr to the channel unit context
646 * @param[in] num_channels number of channels to process
647 * @param[in] avctx ptr to the AVCodecContext
648 * @return result code: 0 = OK, otherwise - error code
650 static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
651 int num_channels, AVCodecContext *avctx)
655 if (!ctx->used_quant_units)
658 for (ch_num = 0; ch_num < num_channels; ch_num++) {
659 memset(ctx->channels[ch_num].qu_sf_idx, 0,
660 sizeof(ctx->channels[ch_num].qu_sf_idx));
662 if ((ret = decode_channel_sf_idx(gb, ctx, ch_num, avctx)) < 0)
670 * Decode number of code table values.
672 * @param[in] gb the GetBit context
673 * @param[in,out] ctx ptr to the channel unit context
674 * @param[in] avctx ptr to the AVCodecContext
675 * @return result code: 0 = OK, otherwise - error code
677 static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
678 AVCodecContext *avctx)
683 num_coded_vals = get_bits(gb, 5);
684 if (num_coded_vals > ctx->used_quant_units) {
685 av_log(avctx, AV_LOG_ERROR,
686 "Invalid number of code table indexes: %d!\n", num_coded_vals);
687 return AVERROR_INVALIDDATA;
689 return num_coded_vals;
691 return ctx->used_quant_units;
694 #define DEC_CT_IDX_COMMON(OP) \
695 num_vals = get_num_ct_values(gb, ctx, avctx); \
699 for (i = 0; i < num_vals; i++) { \
700 if (chan->qu_wordlen[i]) { \
701 chan->qu_tab_idx[i] = OP; \
702 } else if (ch_num && ref_chan->qu_wordlen[i]) \
703 /* get clone master flag */ \
704 chan->qu_tab_idx[i] = get_bits1(gb); \
707 #define CODING_DIRECT get_bits(gb, num_bits)
709 #define CODING_VLC get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)
711 #define CODING_VLC_DELTA \
713 : (pred + get_vlc2(gb, delta_vlc->table, \
714 delta_vlc->bits, 1)) & mask; \
715 pred = chan->qu_tab_idx[i]
717 #define CODING_VLC_DIFF \
718 (ref_chan->qu_tab_idx[i] + \
719 get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1)) & mask
722 * Decode code table indexes for each quant unit of a channel.
724 * @param[in] gb the GetBit context
725 * @param[in,out] ctx ptr to the channel unit context
726 * @param[in] ch_num channel to process
727 * @param[in] avctx ptr to the AVCodecContext
728 * @return result code: 0 = OK, otherwise - error code
730 static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
731 int ch_num, AVCodecContext *avctx)
733 int i, num_vals, num_bits, pred;
734 int mask = ctx->use_full_table ? 7 : 3; /* mask for modular arithmetic */
735 VLC *vlc_tab, *delta_vlc;
736 Atrac3pChanParams *chan = &ctx->channels[ch_num];
737 Atrac3pChanParams *ref_chan = &ctx->channels[0];
739 chan->table_type = get_bits1(gb);
741 switch (get_bits(gb, 2)) { /* switch according to coding mode */
742 case 0: /* directly coded */
743 num_bits = ctx->use_full_table + 2;
744 DEC_CT_IDX_COMMON(CODING_DIRECT);
746 case 1: /* entropy-coded */
747 vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1]
749 DEC_CT_IDX_COMMON(CODING_VLC);
751 case 2: /* entropy-coded delta */
752 if (ctx->use_full_table) {
753 vlc_tab = &ct_vlc_tabs[1];
754 delta_vlc = &ct_vlc_tabs[2];
756 vlc_tab = ct_vlc_tabs;
757 delta_vlc = ct_vlc_tabs;
760 DEC_CT_IDX_COMMON(CODING_VLC_DELTA);
762 case 3: /* entropy-coded difference to master */
764 vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[3]
766 DEC_CT_IDX_COMMON(CODING_VLC_DIFF);
775 * Decode code table indexes for each channel.
777 * @param[in] gb the GetBit context
778 * @param[in,out] ctx ptr to the channel unit context
779 * @param[in] num_channels number of channels to process
780 * @param[in] avctx ptr to the AVCodecContext
781 * @return result code: 0 = OK, otherwise - error code
783 static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
784 int num_channels, AVCodecContext *avctx)
788 if (!ctx->used_quant_units)
791 ctx->use_full_table = get_bits1(gb);
793 for (ch_num = 0; ch_num < num_channels; ch_num++) {
794 memset(ctx->channels[ch_num].qu_tab_idx, 0,
795 sizeof(ctx->channels[ch_num].qu_tab_idx));
797 if ((ret = decode_channel_code_tab(gb, ctx, ch_num, avctx)) < 0)
805 * Decode huffman-coded spectral lines for a given quant unit.
807 * This is a generalized version for all known coding modes.
808 * Its speed can be improved by creating separate functions for each mode.
810 * @param[in] gb the GetBit context
811 * @param[in] tab code table telling how to decode spectral lines
812 * @param[in] vlc_tab ptr to the huffman table associated with the code table
813 * @param[out] out pointer to buffer where decoded data should be stored
814 * @param[in] num_specs number of spectral lines to decode
816 static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab,
817 VLC *vlc_tab, int16_t *out, const int num_specs)
820 int group_size = tab->group_size;
821 int num_coeffs = tab->num_coeffs;
822 int bits = tab->bits;
823 int is_signed = tab->is_signed;
826 for (pos = 0; pos < num_specs;) {
827 if (group_size == 1 || get_bits1(gb)) {
828 for (j = 0; j < group_size; j++) {
829 val = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
831 for (i = 0; i < num_coeffs; i++) {
832 cf = av_mod_uintp2(val, bits);
834 cf = sign_extend(cf, bits);
835 else if (cf && get_bits1(gb))
842 } else /* group skipped */
843 pos += group_size * num_coeffs;
848 * Decode huffman-coded IMDCT spectrum for all channels.
850 * @param[in] gb the GetBit context
851 * @param[in,out] ctx ptr to the channel unit context
852 * @param[in] num_channels number of channels to process
853 * @param[in] avctx ptr to the AVCodecContext
855 static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
856 int num_channels, AVCodecContext *avctx)
858 int i, ch_num, qu, wordlen, codetab, tab_index, num_specs;
859 const Atrac3pSpecCodeTab *tab;
860 Atrac3pChanParams *chan;
862 for (ch_num = 0; ch_num < num_channels; ch_num++) {
863 chan = &ctx->channels[ch_num];
865 memset(chan->spectrum, 0, sizeof(chan->spectrum));
867 /* set power compensation level to disabled */
868 memset(chan->power_levs, ATRAC3P_POWER_COMP_OFF, sizeof(chan->power_levs));
870 for (qu = 0; qu < ctx->used_quant_units; qu++) {
871 num_specs = ff_atrac3p_qu_to_spec_pos[qu + 1] -
872 ff_atrac3p_qu_to_spec_pos[qu];
874 wordlen = chan->qu_wordlen[qu];
875 codetab = chan->qu_tab_idx[qu];
877 if (!ctx->use_full_table)
878 codetab = atrac3p_ct_restricted_to_full[chan->table_type][wordlen - 1][codetab];
880 tab_index = (chan->table_type * 8 + codetab) * 7 + wordlen - 1;
881 tab = &atrac3p_spectra_tabs[tab_index];
883 /* this allows reusing VLC tables */
884 if (tab->redirect >= 0)
885 tab_index = tab->redirect;
887 decode_qu_spectra(gb, tab, &spec_vlc_tabs[tab_index],
888 &chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
890 } else if (ch_num && ctx->channels[0].qu_wordlen[qu] && !codetab) {
891 /* copy coefficients from master */
892 memcpy(&chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
893 &ctx->channels[0].spectrum[ff_atrac3p_qu_to_spec_pos[qu]],
895 sizeof(chan->spectrum[ff_atrac3p_qu_to_spec_pos[qu]]));
896 chan->qu_wordlen[qu] = ctx->channels[0].qu_wordlen[qu];
900 /* Power compensation levels only present in the bitstream
901 * if there are more than 2 quant units. The lowest two units
902 * correspond to the frequencies 0...351 Hz, whose shouldn't
903 * be affected by the power compensation. */
904 if (ctx->used_quant_units > 2) {
905 num_specs = atrac3p_subband_to_num_powgrps[ctx->num_coded_subbands - 1];
906 for (i = 0; i < num_specs; i++)
907 chan->power_levs[i] = get_bits(gb, 4);
913 * Retrieve specified amount of flag bits from the input bitstream.
914 * The data can be shortened in the case of the following two common conditions:
915 * if all bits are zero then only one signal bit = 0 will be stored,
916 * if all bits are ones then two signal bits = 1,0 will be stored.
917 * Otherwise, all necessary bits will be directly stored
918 * prefixed by two signal bits = 1,1.
920 * @param[in] gb ptr to the GetBitContext
921 * @param[out] out where to place decoded flags
922 * @param[in] num_flags number of flags to process
923 * @return: 0 = all flag bits are zero, 1 = there is at least one non-zero flag bit
925 static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags)
929 memset(out, 0, num_flags);
931 result = get_bits1(gb);
934 for (i = 0; i < num_flags; i++)
935 out[i] = get_bits1(gb);
937 memset(out, 1, num_flags);
944 * Decode mdct window shape flags for all channels.
946 * @param[in] gb the GetBit context
947 * @param[in,out] ctx ptr to the channel unit context
948 * @param[in] num_channels number of channels to process
950 static void decode_window_shape(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
955 for (ch_num = 0; ch_num < num_channels; ch_num++)
956 get_subband_flags(gb, ctx->channels[ch_num].wnd_shape,
961 * Decode number of gain control points.
963 * @param[in] gb the GetBit context
964 * @param[in,out] ctx ptr to the channel unit context
965 * @param[in] ch_num channel to process
966 * @param[in] coded_subbands number of subbands to process
967 * @return result code: 0 = OK, otherwise - error code
969 static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
970 int ch_num, int coded_subbands)
972 int i, delta, delta_bits, min_val;
973 Atrac3pChanParams *chan = &ctx->channels[ch_num];
974 Atrac3pChanParams *ref_chan = &ctx->channels[0];
976 switch (get_bits(gb, 2)) { /* switch according to coding mode */
977 case 0: /* fixed-length coding */
978 for (i = 0; i < coded_subbands; i++)
979 chan->gain_data[i].num_points = get_bits(gb, 3);
981 case 1: /* variable-length coding */
982 for (i = 0; i < coded_subbands; i++)
983 chan->gain_data[i].num_points =
984 get_vlc2(gb, gain_vlc_tabs[0].table,
985 gain_vlc_tabs[0].bits, 1);
988 if (ch_num) { /* VLC modulo delta to master channel */
989 for (i = 0; i < coded_subbands; i++) {
990 delta = get_vlc2(gb, gain_vlc_tabs[1].table,
991 gain_vlc_tabs[1].bits, 1);
992 chan->gain_data[i].num_points =
993 (ref_chan->gain_data[i].num_points + delta) & 7;
995 } else { /* VLC modulo delta to previous */
996 chan->gain_data[0].num_points =
997 get_vlc2(gb, gain_vlc_tabs[0].table,
998 gain_vlc_tabs[0].bits, 1);
1000 for (i = 1; i < coded_subbands; i++) {
1001 delta = get_vlc2(gb, gain_vlc_tabs[1].table,
1002 gain_vlc_tabs[1].bits, 1);
1003 chan->gain_data[i].num_points =
1004 (chan->gain_data[i - 1].num_points + delta) & 7;
1009 if (ch_num) { /* copy data from master channel */
1010 for (i = 0; i < coded_subbands; i++)
1011 chan->gain_data[i].num_points =
1012 ref_chan->gain_data[i].num_points;
1013 } else { /* shorter delta to min */
1014 delta_bits = get_bits(gb, 2);
1015 min_val = get_bits(gb, 3);
1017 for (i = 0; i < coded_subbands; i++) {
1018 chan->gain_data[i].num_points = min_val + get_bitsz(gb, delta_bits);
1019 if (chan->gain_data[i].num_points > 7)
1020 return AVERROR_INVALIDDATA;
1029 * Implements coding mode 3 (slave) for gain compensation levels.
1031 * @param[out] dst ptr to the output array
1032 * @param[in] ref ptr to the reference channel
1034 static inline void gainc_level_mode3s(AtracGainInfo *dst, AtracGainInfo *ref)
1038 for (i = 0; i < dst->num_points; i++)
1039 dst->lev_code[i] = (i >= ref->num_points) ? 7 : ref->lev_code[i];
1043 * Implements coding mode 1 (master) for gain compensation levels.
1045 * @param[in] gb the GetBit context
1046 * @param[in] ctx ptr to the channel unit context
1047 * @param[out] dst ptr to the output array
1049 static inline void gainc_level_mode1m(GetBitContext *gb,
1050 Atrac3pChanUnitCtx *ctx,
1055 if (dst->num_points > 0)
1056 dst->lev_code[0] = get_vlc2(gb, gain_vlc_tabs[2].table,
1057 gain_vlc_tabs[2].bits, 1);
1059 for (i = 1; i < dst->num_points; i++) {
1060 delta = get_vlc2(gb, gain_vlc_tabs[3].table,
1061 gain_vlc_tabs[3].bits, 1);
1062 dst->lev_code[i] = (dst->lev_code[i - 1] + delta) & 0xF;
1067 * Decode level code for each gain control point.
1069 * @param[in] gb the GetBit context
1070 * @param[in,out] ctx ptr to the channel unit context
1071 * @param[in] ch_num channel to process
1072 * @param[in] coded_subbands number of subbands to process
1073 * @return result code: 0 = OK, otherwise - error code
1075 static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1076 int ch_num, int coded_subbands)
1078 int sb, i, delta, delta_bits, min_val, pred;
1079 Atrac3pChanParams *chan = &ctx->channels[ch_num];
1080 Atrac3pChanParams *ref_chan = &ctx->channels[0];
1082 switch (get_bits(gb, 2)) { /* switch according to coding mode */
1083 case 0: /* fixed-length coding */
1084 for (sb = 0; sb < coded_subbands; sb++)
1085 for (i = 0; i < chan->gain_data[sb].num_points; i++)
1086 chan->gain_data[sb].lev_code[i] = get_bits(gb, 4);
1089 if (ch_num) { /* VLC modulo delta to master channel */
1090 for (sb = 0; sb < coded_subbands; sb++)
1091 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
1092 delta = get_vlc2(gb, gain_vlc_tabs[5].table,
1093 gain_vlc_tabs[5].bits, 1);
1094 pred = (i >= ref_chan->gain_data[sb].num_points)
1095 ? 7 : ref_chan->gain_data[sb].lev_code[i];
1096 chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF;
1098 } else { /* VLC modulo delta to previous */
1099 for (sb = 0; sb < coded_subbands; sb++)
1100 gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]);
1104 if (ch_num) { /* VLC modulo delta to previous or clone master */
1105 for (sb = 0; sb < coded_subbands; sb++)
1106 if (chan->gain_data[sb].num_points > 0) {
1108 gainc_level_mode1m(gb, ctx, &chan->gain_data[sb]);
1110 gainc_level_mode3s(&chan->gain_data[sb],
1111 &ref_chan->gain_data[sb]);
1113 } else { /* VLC modulo delta to lev_codes of previous subband */
1114 if (chan->gain_data[0].num_points > 0)
1115 gainc_level_mode1m(gb, ctx, &chan->gain_data[0]);
1117 for (sb = 1; sb < coded_subbands; sb++)
1118 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
1119 delta = get_vlc2(gb, gain_vlc_tabs[4].table,
1120 gain_vlc_tabs[4].bits, 1);
1121 pred = (i >= chan->gain_data[sb - 1].num_points)
1122 ? 7 : chan->gain_data[sb - 1].lev_code[i];
1123 chan->gain_data[sb].lev_code[i] = (pred + delta) & 0xF;
1128 if (ch_num) { /* clone master */
1129 for (sb = 0; sb < coded_subbands; sb++)
1130 gainc_level_mode3s(&chan->gain_data[sb],
1131 &ref_chan->gain_data[sb]);
1132 } else { /* shorter delta to min */
1133 delta_bits = get_bits(gb, 2);
1134 min_val = get_bits(gb, 4);
1136 for (sb = 0; sb < coded_subbands; sb++)
1137 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
1138 chan->gain_data[sb].lev_code[i] = min_val + get_bitsz(gb, delta_bits);
1139 if (chan->gain_data[sb].lev_code[i] > 15)
1140 return AVERROR_INVALIDDATA;
1150 * Implements coding mode 0 for gain compensation locations.
1152 * @param[in] gb the GetBit context
1153 * @param[in] ctx ptr to the channel unit context
1154 * @param[out] dst ptr to the output array
1155 * @param[in] pos position of the value to be processed
1157 static inline void gainc_loc_mode0(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1158 AtracGainInfo *dst, int pos)
1162 if (!pos || dst->loc_code[pos - 1] < 15)
1163 dst->loc_code[pos] = get_bits(gb, 5);
1164 else if (dst->loc_code[pos - 1] >= 30)
1165 dst->loc_code[pos] = 31;
1167 delta_bits = av_log2(30 - dst->loc_code[pos - 1]) + 1;
1168 dst->loc_code[pos] = dst->loc_code[pos - 1] +
1169 get_bits(gb, delta_bits) + 1;
1174 * Implements coding mode 1 for gain compensation locations.
1176 * @param[in] gb the GetBit context
1177 * @param[in] ctx ptr to the channel unit context
1178 * @param[out] dst ptr to the output array
1180 static inline void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1186 if (dst->num_points > 0) {
1187 /* 1st coefficient is stored directly */
1188 dst->loc_code[0] = get_bits(gb, 5);
1190 for (i = 1; i < dst->num_points; i++) {
1191 /* switch VLC according to the curve direction
1192 * (ascending/descending) */
1193 tab = (dst->lev_code[i] <= dst->lev_code[i - 1])
1195 : &gain_vlc_tabs[9];
1196 dst->loc_code[i] = dst->loc_code[i - 1] +
1197 get_vlc2(gb, tab->table, tab->bits, 1);
1203 * Decode location code for each gain control point.
1205 * @param[in] gb the GetBit context
1206 * @param[in,out] ctx ptr to the channel unit context
1207 * @param[in] ch_num channel to process
1208 * @param[in] coded_subbands number of subbands to process
1209 * @param[in] avctx ptr to the AVCodecContext
1210 * @return result code: 0 = OK, otherwise - error code
1212 static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1213 int ch_num, int coded_subbands,
1214 AVCodecContext *avctx)
1216 int sb, i, delta, delta_bits, min_val, pred, more_than_ref;
1217 AtracGainInfo *dst, *ref;
1219 Atrac3pChanParams *chan = &ctx->channels[ch_num];
1220 Atrac3pChanParams *ref_chan = &ctx->channels[0];
1222 switch (get_bits(gb, 2)) { /* switch according to coding mode */
1223 case 0: /* sequence of numbers in ascending order */
1224 for (sb = 0; sb < coded_subbands; sb++)
1225 for (i = 0; i < chan->gain_data[sb].num_points; i++)
1226 gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i);
1230 for (sb = 0; sb < coded_subbands; sb++) {
1231 if (chan->gain_data[sb].num_points <= 0)
1233 dst = &chan->gain_data[sb];
1234 ref = &ref_chan->gain_data[sb];
1236 /* 1st value is vlc-coded modulo delta to master */
1237 delta = get_vlc2(gb, gain_vlc_tabs[10].table,
1238 gain_vlc_tabs[10].bits, 1);
1239 pred = ref->num_points > 0 ? ref->loc_code[0] : 0;
1240 dst->loc_code[0] = (pred + delta) & 0x1F;
1242 for (i = 1; i < dst->num_points; i++) {
1243 more_than_ref = i >= ref->num_points;
1244 if (dst->lev_code[i] > dst->lev_code[i - 1]) {
1245 /* ascending curve */
1246 if (more_than_ref) {
1248 get_vlc2(gb, gain_vlc_tabs[9].table,
1249 gain_vlc_tabs[9].bits, 1);
1250 dst->loc_code[i] = dst->loc_code[i - 1] + delta;
1253 gainc_loc_mode0(gb, ctx, dst, i); // direct coding
1255 dst->loc_code[i] = ref->loc_code[i]; // clone master
1257 } else { /* descending curve */
1258 tab = more_than_ref ? &gain_vlc_tabs[7]
1259 : &gain_vlc_tabs[10];
1260 delta = get_vlc2(gb, tab->table, tab->bits, 1);
1262 dst->loc_code[i] = dst->loc_code[i - 1] + delta;
1264 dst->loc_code[i] = (ref->loc_code[i] + delta) & 0x1F;
1268 } else /* VLC delta to previous */
1269 for (sb = 0; sb < coded_subbands; sb++)
1270 gainc_loc_mode1(gb, ctx, &chan->gain_data[sb]);
1274 for (sb = 0; sb < coded_subbands; sb++) {
1275 if (chan->gain_data[sb].num_points <= 0)
1277 dst = &chan->gain_data[sb];
1278 ref = &ref_chan->gain_data[sb];
1279 if (dst->num_points > ref->num_points || get_bits1(gb))
1280 gainc_loc_mode1(gb, ctx, dst);
1281 else /* clone master for the whole subband */
1282 for (i = 0; i < chan->gain_data[sb].num_points; i++)
1283 dst->loc_code[i] = ref->loc_code[i];
1286 /* data for the first subband is coded directly */
1287 for (i = 0; i < chan->gain_data[0].num_points; i++)
1288 gainc_loc_mode0(gb, ctx, &chan->gain_data[0], i);
1290 for (sb = 1; sb < coded_subbands; sb++) {
1291 if (chan->gain_data[sb].num_points <= 0)
1293 dst = &chan->gain_data[sb];
1295 /* 1st value is vlc-coded modulo delta to the corresponding
1296 * value of the previous subband if any or zero */
1297 delta = get_vlc2(gb, gain_vlc_tabs[6].table,
1298 gain_vlc_tabs[6].bits, 1);
1299 pred = dst[-1].num_points > 0
1300 ? dst[-1].loc_code[0] : 0;
1301 dst->loc_code[0] = (pred + delta) & 0x1F;
1303 for (i = 1; i < dst->num_points; i++) {
1304 more_than_ref = i >= dst[-1].num_points;
1305 /* Select VLC table according to curve direction and
1306 * presence of prediction. */
1307 tab = &gain_vlc_tabs[(dst->lev_code[i] > dst->lev_code[i - 1]) *
1308 2 + more_than_ref + 6];
1309 delta = get_vlc2(gb, tab->table, tab->bits, 1);
1311 dst->loc_code[i] = dst->loc_code[i - 1] + delta;
1313 dst->loc_code[i] = (dst[-1].loc_code[i] + delta) & 0x1F;
1319 if (ch_num) { /* clone master or direct or direct coding */
1320 for (sb = 0; sb < coded_subbands; sb++)
1321 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
1322 if (i >= ref_chan->gain_data[sb].num_points)
1323 gainc_loc_mode0(gb, ctx, &chan->gain_data[sb], i);
1325 chan->gain_data[sb].loc_code[i] =
1326 ref_chan->gain_data[sb].loc_code[i];
1328 } else { /* shorter delta to min */
1329 delta_bits = get_bits(gb, 2) + 1;
1330 min_val = get_bits(gb, 5);
1332 for (sb = 0; sb < coded_subbands; sb++)
1333 for (i = 0; i < chan->gain_data[sb].num_points; i++)
1334 chan->gain_data[sb].loc_code[i] = min_val + i +
1335 get_bits(gb, delta_bits);
1340 /* Validate decoded information */
1341 for (sb = 0; sb < coded_subbands; sb++) {
1342 dst = &chan->gain_data[sb];
1343 for (i = 0; i < chan->gain_data[sb].num_points; i++) {
1344 if (dst->loc_code[i] < 0 || dst->loc_code[i] > 31 ||
1345 (i && dst->loc_code[i] <= dst->loc_code[i - 1])) {
1346 av_log(avctx, AV_LOG_ERROR,
1347 "Invalid gain location: ch=%d, sb=%d, pos=%d, val=%d\n",
1348 ch_num, sb, i, dst->loc_code[i]);
1349 return AVERROR_INVALIDDATA;
1358 * Decode gain control data for all channels.
1360 * @param[in] gb the GetBit context
1361 * @param[in,out] ctx ptr to the channel unit context
1362 * @param[in] num_channels number of channels to process
1363 * @param[in] avctx ptr to the AVCodecContext
1364 * @return result code: 0 = OK, otherwise - error code
1366 static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1367 int num_channels, AVCodecContext *avctx)
1369 int ch_num, coded_subbands, sb, ret;
1371 for (ch_num = 0; ch_num < num_channels; ch_num++) {
1372 memset(ctx->channels[ch_num].gain_data, 0,
1373 sizeof(*ctx->channels[ch_num].gain_data) * ATRAC3P_SUBBANDS);
1375 if (get_bits1(gb)) { /* gain control data present? */
1376 coded_subbands = get_bits(gb, 4) + 1;
1377 if (get_bits1(gb)) /* is high band gain data replication on? */
1378 ctx->channels[ch_num].num_gain_subbands = get_bits(gb, 4) + 1;
1380 ctx->channels[ch_num].num_gain_subbands = coded_subbands;
1382 if ((ret = decode_gainc_npoints(gb, ctx, ch_num, coded_subbands)) < 0 ||
1383 (ret = decode_gainc_levels(gb, ctx, ch_num, coded_subbands)) < 0 ||
1384 (ret = decode_gainc_loc_codes(gb, ctx, ch_num, coded_subbands, avctx)) < 0)
1387 if (coded_subbands > 0) { /* propagate gain data if requested */
1388 for (sb = coded_subbands; sb < ctx->channels[ch_num].num_gain_subbands; sb++)
1389 ctx->channels[ch_num].gain_data[sb] =
1390 ctx->channels[ch_num].gain_data[sb - 1];
1393 ctx->channels[ch_num].num_gain_subbands = 0;
1401 * Decode envelope for all tones of a channel.
1403 * @param[in] gb the GetBit context
1404 * @param[in,out] ctx ptr to the channel unit context
1405 * @param[in] ch_num channel to process
1406 * @param[in] band_has_tones ptr to an array of per-band-flags:
1407 * 1 - tone data present
1409 static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1410 int ch_num, int band_has_tones[])
1413 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
1414 Atrac3pWavesData *ref = ctx->channels[0].tones_info;
1416 if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */
1417 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1418 if (!band_has_tones[sb])
1420 dst[sb].pend_env.has_start_point = get_bits1(gb);
1421 dst[sb].pend_env.start_pos = dst[sb].pend_env.has_start_point
1422 ? get_bits(gb, 5) : -1;
1423 dst[sb].pend_env.has_stop_point = get_bits1(gb);
1424 dst[sb].pend_env.stop_pos = dst[sb].pend_env.has_stop_point
1425 ? get_bits(gb, 5) : 32;
1427 } else { /* mode 1(slave only): copy master */
1428 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1429 if (!band_has_tones[sb])
1431 dst[sb].pend_env.has_start_point = ref[sb].pend_env.has_start_point;
1432 dst[sb].pend_env.has_stop_point = ref[sb].pend_env.has_stop_point;
1433 dst[sb].pend_env.start_pos = ref[sb].pend_env.start_pos;
1434 dst[sb].pend_env.stop_pos = ref[sb].pend_env.stop_pos;
1440 * Decode number of tones for each subband of a channel.
1442 * @param[in] gb the GetBit context
1443 * @param[in,out] ctx ptr to the channel unit context
1444 * @param[in] ch_num channel to process
1445 * @param[in] band_has_tones ptr to an array of per-band-flags:
1446 * 1 - tone data present
1447 * @param[in] avctx ptr to the AVCodecContext
1448 * @return result code: 0 = OK, otherwise - error code
1450 static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1451 int ch_num, int band_has_tones[],
1452 AVCodecContext *avctx)
1454 int mode, sb, delta;
1455 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
1456 Atrac3pWavesData *ref = ctx->channels[0].tones_info;
1458 mode = get_bits(gb, ch_num + 1);
1460 case 0: /** fixed-length coding */
1461 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
1462 if (band_has_tones[sb])
1463 dst[sb].num_wavs = get_bits(gb, 4);
1465 case 1: /** variable-length coding */
1466 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
1467 if (band_has_tones[sb])
1469 get_vlc2(gb, tone_vlc_tabs[1].table,
1470 tone_vlc_tabs[1].bits, 1);
1472 case 2: /** VLC modulo delta to master (slave only) */
1473 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
1474 if (band_has_tones[sb]) {
1475 delta = get_vlc2(gb, tone_vlc_tabs[2].table,
1476 tone_vlc_tabs[2].bits, 1);
1477 delta = sign_extend(delta, 3);
1478 dst[sb].num_wavs = (ref[sb].num_wavs + delta) & 0xF;
1481 case 3: /** copy master (slave only) */
1482 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
1483 if (band_has_tones[sb])
1484 dst[sb].num_wavs = ref[sb].num_wavs;
1488 /** initialize start tone index for each subband */
1489 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++)
1490 if (band_has_tones[sb]) {
1491 if (ctx->waves_info->tones_index + dst[sb].num_wavs > 48) {
1492 av_log(avctx, AV_LOG_ERROR,
1493 "Too many tones: %d (max. 48), frame: %d!\n",
1494 ctx->waves_info->tones_index + dst[sb].num_wavs,
1495 avctx->frame_number);
1496 return AVERROR_INVALIDDATA;
1498 dst[sb].start_index = ctx->waves_info->tones_index;
1499 ctx->waves_info->tones_index += dst[sb].num_wavs;
1506 * Decode frequency information for each subband of a channel.
1508 * @param[in] gb the GetBit context
1509 * @param[in,out] ctx ptr to the channel unit context
1510 * @param[in] ch_num channel to process
1511 * @param[in] band_has_tones ptr to an array of per-band-flags:
1512 * 1 - tone data present
1514 static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1515 int ch_num, int band_has_tones[])
1517 int sb, i, direction, nbits, pred, delta;
1518 Atrac3pWaveParam *iwav, *owav;
1519 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
1520 Atrac3pWavesData *ref = ctx->channels[0].tones_info;
1522 if (!ch_num || !get_bits1(gb)) { /* mode 0: fixed-length coding */
1523 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1524 if (!band_has_tones[sb] || !dst[sb].num_wavs)
1526 iwav = &ctx->waves_info->waves[dst[sb].start_index];
1527 direction = (dst[sb].num_wavs > 1) ? get_bits1(gb) : 0;
1528 if (direction) { /** packed numbers in descending order */
1529 if (dst[sb].num_wavs)
1530 iwav[dst[sb].num_wavs - 1].freq_index = get_bits(gb, 10);
1531 for (i = dst[sb].num_wavs - 2; i >= 0 ; i--) {
1532 nbits = av_log2(iwav[i+1].freq_index) + 1;
1533 iwav[i].freq_index = get_bits(gb, nbits);
1535 } else { /** packed numbers in ascending order */
1536 for (i = 0; i < dst[sb].num_wavs; i++) {
1537 if (!i || iwav[i - 1].freq_index < 512)
1538 iwav[i].freq_index = get_bits(gb, 10);
1540 nbits = av_log2(1023 - iwav[i - 1].freq_index) + 1;
1541 iwav[i].freq_index = get_bits(gb, nbits) +
1542 1024 - (1 << nbits);
1547 } else { /* mode 1: VLC modulo delta to master (slave only) */
1548 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1549 if (!band_has_tones[sb] || !dst[sb].num_wavs)
1551 iwav = &ctx->waves_info->waves[ref[sb].start_index];
1552 owav = &ctx->waves_info->waves[dst[sb].start_index];
1553 for (i = 0; i < dst[sb].num_wavs; i++) {
1554 delta = get_vlc2(gb, tone_vlc_tabs[6].table,
1555 tone_vlc_tabs[6].bits, 1);
1556 delta = sign_extend(delta, 8);
1557 pred = (i < ref[sb].num_wavs) ? iwav[i].freq_index :
1558 (ref[sb].num_wavs ? iwav[ref[sb].num_wavs - 1].freq_index : 0);
1559 owav[i].freq_index = (pred + delta) & 0x3FF;
1566 * Decode amplitude information for each subband of a channel.
1568 * @param[in] gb the GetBit context
1569 * @param[in,out] ctx ptr to the channel unit context
1570 * @param[in] ch_num channel to process
1571 * @param[in] band_has_tones ptr to an array of per-band-flags:
1572 * 1 - tone data present
1574 static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1575 int ch_num, int band_has_tones[])
1577 int mode, sb, j, i, diff, maxdiff, fi, delta, pred;
1578 Atrac3pWaveParam *wsrc, *wref;
1579 int refwaves[48] = { 0 };
1580 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
1581 Atrac3pWavesData *ref = ctx->channels[0].tones_info;
1584 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1585 if (!band_has_tones[sb] || !dst[sb].num_wavs)
1587 wsrc = &ctx->waves_info->waves[dst[sb].start_index];
1588 wref = &ctx->waves_info->waves[ref[sb].start_index];
1589 for (j = 0; j < dst[sb].num_wavs; j++) {
1590 for (i = 0, fi = 0, maxdiff = 1024; i < ref[sb].num_wavs; i++) {
1591 diff = FFABS(wsrc[j].freq_index - wref[i].freq_index);
1592 if (diff < maxdiff) {
1599 refwaves[dst[sb].start_index + j] = fi + ref[sb].start_index;
1600 else if (j < ref[sb].num_wavs)
1601 refwaves[dst[sb].start_index + j] = j + ref[sb].start_index;
1603 refwaves[dst[sb].start_index + j] = -1;
1608 mode = get_bits(gb, ch_num + 1);
1611 case 0: /** fixed-length coding */
1612 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1613 if (!band_has_tones[sb] || !dst[sb].num_wavs)
1615 if (ctx->waves_info->amplitude_mode)
1616 for (i = 0; i < dst[sb].num_wavs; i++)
1617 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = get_bits(gb, 6);
1619 ctx->waves_info->waves[dst[sb].start_index].amp_sf = get_bits(gb, 6);
1622 case 1: /** min + VLC delta */
1623 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1624 if (!band_has_tones[sb] || !dst[sb].num_wavs)
1626 if (ctx->waves_info->amplitude_mode)
1627 for (i = 0; i < dst[sb].num_wavs; i++)
1628 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf =
1629 get_vlc2(gb, tone_vlc_tabs[3].table,
1630 tone_vlc_tabs[3].bits, 1) + 20;
1632 ctx->waves_info->waves[dst[sb].start_index].amp_sf =
1633 get_vlc2(gb, tone_vlc_tabs[4].table,
1634 tone_vlc_tabs[4].bits, 1) + 24;
1637 case 2: /** VLC modulo delta to master (slave only) */
1638 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1639 if (!band_has_tones[sb] || !dst[sb].num_wavs)
1641 for (i = 0; i < dst[sb].num_wavs; i++) {
1642 delta = get_vlc2(gb, tone_vlc_tabs[5].table,
1643 tone_vlc_tabs[5].bits, 1);
1644 delta = sign_extend(delta, 5);
1645 pred = refwaves[dst[sb].start_index + i] >= 0 ?
1646 ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf : 34;
1647 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf = (pred + delta) & 0x3F;
1651 case 3: /** clone master (slave only) */
1652 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1653 if (!band_has_tones[sb])
1655 for (i = 0; i < dst[sb].num_wavs; i++)
1656 ctx->waves_info->waves[dst[sb].start_index + i].amp_sf =
1657 refwaves[dst[sb].start_index + i] >= 0
1658 ? ctx->waves_info->waves[refwaves[dst[sb].start_index + i]].amp_sf
1666 * Decode phase information for each subband of a channel.
1668 * @param[in] gb the GetBit context
1669 * @param[in,out] ctx ptr to the channel unit context
1670 * @param[in] ch_num channel to process
1671 * @param[in] band_has_tones ptr to an array of per-band-flags:
1672 * 1 - tone data present
1674 static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1675 int ch_num, int band_has_tones[])
1678 Atrac3pWaveParam *wparam;
1679 Atrac3pWavesData *dst = ctx->channels[ch_num].tones_info;
1681 for (sb = 0; sb < ctx->waves_info->num_tone_bands; sb++) {
1682 if (!band_has_tones[sb])
1684 wparam = &ctx->waves_info->waves[dst[sb].start_index];
1685 for (i = 0; i < dst[sb].num_wavs; i++)
1686 wparam[i].phase_index = get_bits(gb, 5);
1691 * Decode tones info for all channels.
1693 * @param[in] gb the GetBit context
1694 * @param[in,out] ctx ptr to the channel unit context
1695 * @param[in] num_channels number of channels to process
1696 * @param[in] avctx ptr to the AVCodecContext
1697 * @return result code: 0 = OK, otherwise - error code
1699 static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1700 int num_channels, AVCodecContext *avctx)
1703 int band_has_tones[16];
1705 for (ch_num = 0; ch_num < num_channels; ch_num++)
1706 memset(ctx->channels[ch_num].tones_info, 0,
1707 sizeof(*ctx->channels[ch_num].tones_info) * ATRAC3P_SUBBANDS);
1709 ctx->waves_info->tones_present = get_bits1(gb);
1710 if (!ctx->waves_info->tones_present)
1713 memset(ctx->waves_info->waves, 0, sizeof(ctx->waves_info->waves));
1715 ctx->waves_info->amplitude_mode = get_bits1(gb);
1716 if (!ctx->waves_info->amplitude_mode) {
1717 avpriv_report_missing_feature(avctx, "GHA amplitude mode 0");
1718 return AVERROR_PATCHWELCOME;
1721 ctx->waves_info->num_tone_bands =
1722 get_vlc2(gb, tone_vlc_tabs[0].table,
1723 tone_vlc_tabs[0].bits, 1) + 1;
1725 if (num_channels == 2) {
1726 get_subband_flags(gb, ctx->waves_info->tone_sharing, ctx->waves_info->num_tone_bands);
1727 get_subband_flags(gb, ctx->waves_info->tone_master, ctx->waves_info->num_tone_bands);
1728 get_subband_flags(gb, ctx->waves_info->invert_phase, ctx->waves_info->num_tone_bands);
1731 ctx->waves_info->tones_index = 0;
1733 for (ch_num = 0; ch_num < num_channels; ch_num++) {
1734 for (i = 0; i < ctx->waves_info->num_tone_bands; i++)
1735 band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i];
1737 decode_tones_envelope(gb, ctx, ch_num, band_has_tones);
1738 if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones,
1742 decode_tones_frequency(gb, ctx, ch_num, band_has_tones);
1743 decode_tones_amplitude(gb, ctx, ch_num, band_has_tones);
1744 decode_tones_phase(gb, ctx, ch_num, band_has_tones);
1747 if (num_channels == 2) {
1748 for (i = 0; i < ctx->waves_info->num_tone_bands; i++) {
1749 if (ctx->waves_info->tone_sharing[i])
1750 ctx->channels[1].tones_info[i] = ctx->channels[0].tones_info[i];
1752 if (ctx->waves_info->tone_master[i])
1753 FFSWAP(Atrac3pWavesData, ctx->channels[0].tones_info[i],
1754 ctx->channels[1].tones_info[i]);
1761 int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1762 int num_channels, AVCodecContext *avctx)
1766 /* parse sound header */
1767 ctx->num_quant_units = get_bits(gb, 5) + 1;
1768 if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) {
1769 av_log(avctx, AV_LOG_ERROR,
1770 "Invalid number of quantization units: %d!\n",
1771 ctx->num_quant_units);
1772 return AVERROR_INVALIDDATA;
1775 ctx->mute_flag = get_bits1(gb);
1777 /* decode various sound parameters */
1778 if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0)
1781 ctx->num_subbands = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1;
1782 ctx->num_coded_subbands = ctx->used_quant_units
1783 ? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1
1786 if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0)
1789 if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0)
1792 decode_spectrum(gb, ctx, num_channels, avctx);
1794 if (num_channels == 2) {
1795 get_subband_flags(gb, ctx->swap_channels, ctx->num_coded_subbands);
1796 get_subband_flags(gb, ctx->negate_coeffs, ctx->num_coded_subbands);
1799 decode_window_shape(gb, ctx, num_channels);
1801 if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0)
1804 if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0)
1807 /* decode global noise info */
1808 ctx->noise_present = get_bits1(gb);
1809 if (ctx->noise_present) {
1810 ctx->noise_level_index = get_bits(gb, 4);
1811 ctx->noise_table_index = get_bits(gb, 4);