projects / libav.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lavc: Use get_bitsz where needed
[libav.git] / libavcodec / atrac3plus.c
1 /*
2 * ATRAC3+ compatible decoder
3 *
4 * Copyright (c) 2010-2013 Maxim Poliakovski
5 *
6 * This file is part of Libav.
7 *
8 * Libav is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * Libav is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 /**
24 * @file
25 * Bitstream parser for ATRAC3+ decoder.
26 */
27
28 #include "libavutil/avassert.h"
29 #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(AVCodec *codec)
81 {
82 int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;
83
84 static int wl_nb_bits[4] = { 2, 3, 5, 5 };
85 static int wl_nb_codes[4] = { 3, 5, 8, 8 };
86 static const uint8_t *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 *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 *wl_xlats[4] = {
95 atrac3p_wl_huff_xlat1, atrac3p_wl_huff_xlat2, NULL, NULL
96 };
97
98 static int ct_nb_bits[4] = { 3, 4, 4, 4 };
99 static int ct_nb_codes[4] = { 4, 8, 8, 8 };
100 static const uint8_t *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 *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 *ct_xlats[4] = {
109 NULL, NULL, atrac3p_ct_huff_xlat1, NULL
110 };
111
112 static int sf_nb_bits[8] = { 9, 9, 9, 9, 6, 6, 7, 7 };
113 static int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };
114 static const uint8_t *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 *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 *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 *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 *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 *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 *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, mask = (1 << bits) - 1;
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 = val & mask;
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 if (get_subband_flags(gb, ctx->waves_info->phase_shift,
1725 ctx->waves_info->num_tone_bands)) {
1726 avpriv_report_missing_feature(avctx, "GHA Phase shifting");
1727 return AVERROR_PATCHWELCOME;
1728 }
1729 }
1730
1731 ctx->waves_info->tones_index = 0;
1732
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];
1736
1737 decode_tones_envelope(gb, ctx, ch_num, band_has_tones);
1738 if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones,
1739 avctx)) < 0)
1740 return ret;
1741
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);
1745 }
1746
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];
1751
1752 if (ctx->waves_info->tone_master[i])
1753 FFSWAP(Atrac3pWavesData, ctx->channels[0].tones_info[i],
1754 ctx->channels[1].tones_info[i]);
1755 }
1756 }
1757
1758 return 0;
1759 }
1760
1761 int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
1762 int num_channels, AVCodecContext *avctx)
1763 {
1764 int ret;
1765
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;
1773 }
1774
1775 ctx->mute_flag = get_bits1(gb);
1776
1777 /* decode various sound parameters */
1778 if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0)
1779 return ret;
1780
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
1784 : 0;
1785
1786 if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0)
1787 return ret;
1788
1789 if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0)
1790 return ret;
1791
1792 decode_spectrum(gb, ctx, num_channels, avctx);
1793
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);
1797 }
1798
1799 decode_window_shape(gb, ctx, num_channels);
1800
1801 if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0)
1802 return ret;
1803
1804 if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0)
1805 return ret;
1806
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);
1812 }
1813
1814 return 0;
1815 }
Libav master