FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
atrac3plus.c
Go to the documentation of this file.
1 /*
2  * ATRAC3+ compatible decoder
3  *
4  * Copyright (c) 2010-2013 Maxim Poliakovski
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Bitstream parser for ATRAC3+ decoder.
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "avcodec.h"
30 #include "get_bits.h"
31 #include "atrac3plus.h"
32 #include "atrac3plus_data.h"
33 
34 static VLC_TYPE tables_data[154276][2];
35 static VLC wl_vlc_tabs[4];
36 static VLC sf_vlc_tabs[8];
37 static VLC ct_vlc_tabs[4];
38 static VLC spec_vlc_tabs[112];
39 static VLC gain_vlc_tabs[11];
40 static VLC tone_vlc_tabs[7];
41 
42 /**
43  * Generate canonical VLC table from given descriptor.
44  *
45  * @param[in] cb ptr to codebook descriptor
46  * @param[in] xlat ptr to translation table or NULL
47  * @param[in,out] tab_offset starting offset to the generated vlc table
48  * @param[out] out_vlc ptr to vlc table to be generated
49  */
50 static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t *xlat,
51  int *tab_offset, VLC *out_vlc)
52 {
53  int i, b;
54  uint16_t codes[256];
55  uint8_t bits[256];
56  unsigned code = 0;
57  int index = 0;
58  int min_len = *cb++; // get shortest codeword length
59  int max_len = *cb++; // get longest codeword length
60 
61  for (b = min_len; b <= max_len; b++) {
62  for (i = *cb++; i > 0; i--) {
63  av_assert0(index < 256);
64  bits[index] = b;
65  codes[index] = code++;
66  index++;
67  }
68  code <<= 1;
69  }
70 
71  out_vlc->table = &tables_data[*tab_offset];
72  out_vlc->table_allocated = 1 << max_len;
73 
74  ff_init_vlc_sparse(out_vlc, max_len, index, bits, 1, 1, codes, 2, 2,
75  xlat, 1, 1, INIT_VLC_USE_NEW_STATIC);
76 
77  *tab_offset += 1 << max_len;
78 }
79 
81 {
82  int i, wl_vlc_offs, ct_vlc_offs, sf_vlc_offs, tab_offset;
83 
84  static const int wl_nb_bits[4] = { 2, 3, 5, 5 };
85  static const int wl_nb_codes[4] = { 3, 5, 8, 8 };
86  static const uint8_t * const wl_bits[4] = {
89  };
90  static const uint8_t * const wl_codes[4] = {
93  };
94  static const uint8_t * const wl_xlats[4] = {
96  };
97 
98  static const int ct_nb_bits[4] = { 3, 4, 4, 4 };
99  static const int ct_nb_codes[4] = { 4, 8, 8, 8 };
100  static const uint8_t * const ct_bits[4] = {
103  };
104  static const uint8_t * const ct_codes[4] = {
107  };
108  static const uint8_t * const ct_xlats[4] = {
110  };
111 
112  static const int sf_nb_bits[8] = { 9, 9, 9, 9, 6, 6, 7, 7 };
113  static const int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };
114  static const uint8_t * const sf_bits[8] = {
118  };
119  static const uint16_t * const sf_codes[8] = {
123  };
124  static const uint8_t * const sf_xlats[8] = {
127  };
128 
129  static const uint8_t * const gain_cbs[11] = {
136  };
137  static const uint8_t * const gain_xlats[11] = {
143  };
144 
145  static const uint8_t * const tone_cbs[7] = {
150  };
151  static const uint8_t * const tone_xlats[7] = {
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,
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,
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,
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)
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  */
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  */
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  */
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  */
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  */
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) {
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 
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 
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  */
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  */
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  */
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  */
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;
741  break;
742  case 1: /* entropy-coded */
743  vlc_tab = ctx->use_full_table ? &ct_vlc_tabs[1]
744  : ct_vlc_tabs;
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;
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;
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  */
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  */
813  VLC *vlc_tab, int16_t *out, const int num_specs)
814 {
815  int i, j, pos, cf;
816  int group_size = tab->group_size;
817  int num_coeffs = tab->num_coeffs;
818  int bits = tab->bits;
819  int is_signed = tab->is_signed;
820  unsigned val;
821 
822  for (pos = 0; pos < num_specs;) {
823  if (group_size == 1 || get_bits1(gb)) {
824  for (j = 0; j < group_size; j++) {
825  val = get_vlc2(gb, vlc_tab->table, vlc_tab->bits, 1);
826 
827  for (i = 0; i < num_coeffs; i++) {
828  cf = av_mod_uintp2(val, bits);
829  if (is_signed)
830  cf = sign_extend(cf, bits);
831  else if (cf && get_bits1(gb))
832  cf = -cf;
833 
834  out[pos++] = cf;
835  val >>= bits;
836  }
837  }
838  } else /* group skipped */
839  pos += group_size * num_coeffs;
840  }
841 }
842 
843 /**
844  * Decode huffman-coded IMDCT spectrum for all channels.
845  *
846  * @param[in] gb the GetBit context
847  * @param[in,out] ctx ptr to the channel unit context
848  * @param[in] num_channels number of channels to process
849  * @param[in] avctx ptr to the AVCodecContext
850  */
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] -
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) {
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  */
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  */
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  */
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,
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  */
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  */
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  */
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  */
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  */
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  */
1406  int ch_num, int band_has_tones[])
1407 {
1408  int sb;
1409  Atrac3pWavesData *dst = ctx->channels[ch_num].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;
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  */
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;
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  */
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;
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  */
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;
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  */
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  */
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) {
1725  }
1726 
1727  ctx->waves_info->tones_index = 0;
1728 
1729  for (ch_num = 0; ch_num < num_channels; ch_num++) {
1730  for (i = 0; i < ctx->waves_info->num_tone_bands; i++)
1731  band_has_tones[i] = !ch_num ? 1 : !ctx->waves_info->tone_sharing[i];
1732 
1733  decode_tones_envelope(gb, ctx, ch_num, band_has_tones);
1734  if ((ret = decode_band_numwavs(gb, ctx, ch_num, band_has_tones,
1735  avctx)) < 0)
1736  return ret;
1737 
1738  decode_tones_frequency(gb, ctx, ch_num, band_has_tones);
1739  decode_tones_amplitude(gb, ctx, ch_num, band_has_tones);
1740  decode_tones_phase(gb, ctx, ch_num, band_has_tones);
1741  }
1742 
1743  if (num_channels == 2) {
1744  for (i = 0; i < ctx->waves_info->num_tone_bands; i++) {
1745  if (ctx->waves_info->tone_sharing[i])
1746  ctx->channels[1].tones_info[i] = ctx->channels[0].tones_info[i];
1747 
1748  if (ctx->waves_info->tone_master[i])
1750  ctx->channels[1].tones_info[i]);
1751  }
1752  }
1753 
1754  return 0;
1755 }
1756 
1758  int num_channels, AVCodecContext *avctx)
1759 {
1760  int ret;
1761 
1762  /* parse sound header */
1763  ctx->num_quant_units = get_bits(gb, 5) + 1;
1764  if (ctx->num_quant_units > 28 && ctx->num_quant_units < 32) {
1765  av_log(avctx, AV_LOG_ERROR,
1766  "Invalid number of quantization units: %d!\n",
1767  ctx->num_quant_units);
1768  return AVERROR_INVALIDDATA;
1769  }
1770 
1771  ctx->mute_flag = get_bits1(gb);
1772 
1773  /* decode various sound parameters */
1774  if ((ret = decode_quant_wordlen(gb, ctx, num_channels, avctx)) < 0)
1775  return ret;
1776 
1777  ctx->num_subbands = atrac3p_qu_to_subband[ctx->num_quant_units - 1] + 1;
1779  ? atrac3p_qu_to_subband[ctx->used_quant_units - 1] + 1
1780  : 0;
1781 
1782  if ((ret = decode_scale_factors(gb, ctx, num_channels, avctx)) < 0)
1783  return ret;
1784 
1785  if ((ret = decode_code_table_indexes(gb, ctx, num_channels, avctx)) < 0)
1786  return ret;
1787 
1788  decode_spectrum(gb, ctx, num_channels, avctx);
1789 
1790  if (num_channels == 2) {
1793  }
1794 
1795  decode_window_shape(gb, ctx, num_channels);
1796 
1797  if ((ret = decode_gainc_data(gb, ctx, num_channels, avctx)) < 0)
1798  return ret;
1799 
1800  if ((ret = decode_tones_info(gb, ctx, num_channels, avctx)) < 0)
1801  return ret;
1802 
1803  /* decode global noise info */
1804  ctx->noise_present = get_bits1(gb);
1805  if (ctx->noise_present) {
1806  ctx->noise_level_index = get_bits(gb, 4);
1807  ctx->noise_table_index = get_bits(gb, 4);
1808  }
1809 
1810  return 0;
1811 }
static void unpack_vq_shape(int start_val, const int8_t *shape_vec, int *dst, int num_values)
Unpack vector quantization tables.
Definition: atrac3plus.c:309
static av_cold void build_canonical_huff(const uint8_t *cb, const uint8_t *xlat, int *tab_offset, VLC *out_vlc)
Generate canonical VLC table from given descriptor.
Definition: atrac3plus.c:50
static int get_num_ct_values(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)
Decode number of code table values.
Definition: atrac3plus.c:673
static const uint8_t atrac3p_ct_huff_bits2[8]
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static void decode_tones_phase(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int band_has_tones[])
Decode phase information for each subband of a channel.
Definition: atrac3plus.c:1670
uint8_t bits
number of bits a single coefficient occupy
Atrac3pWaveParam waves[48]
Definition: atrac3plus.h:127
static const uint8_t atrac3p_huff_gain_loc2_xlat[31]
#define flag(name)
Definition: cbs_h2645.c:346
static const uint8_t atrac3p_huff_freq_cb[13]
const uint16_t ff_atrac3p_qu_to_spec_pos[33]
Map quant unit number to its position in the spectrum.
Definition: atrac3plusdsp.c:42
static int decode_gainc_loc_codes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int coded_subbands, AVCodecContext *avctx)
Decode location code for each gain control point.
Definition: atrac3plus.c:1208
uint8_t is_signed
1 - values in that table are signed ones, otherwise - absolute ones
static const uint8_t atrac3p_huff_wav_ampsf2_cb[7]
static const uint8_t atrac3p_ct_huff_code2[8]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
static const Atrac3pSpecCodeTab atrac3p_spectra_tabs[112]
static const uint8_t atrac3p_sf_huff_bits2[64]
static int decode_code_table_indexes(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode code table indexes for each channel.
Definition: atrac3plus.c:779
int num_tone_bands
number of PQF bands with tones
Definition: atrac3plus.h:122
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:268
static const uint8_t atrac3p_ct_huff_bits3[8]
int num_coded_subbands
number of subbands with coded spectrum
Definition: atrac3plus.h:137
int table_type
table type: 0 - tone?, 1- noise?
Definition: atrac3plus.h:94
const char * b
Definition: vf_curves.c:113
int av_log2(unsigned v)
Definition: intmath.c:26
static const uint8_t atrac3p_huff_gain_loc2_cb[8]
int num_wavs
number of sine waves in the group
Definition: atrac3plus.h:76
static const uint8_t atrac3p_huff_gain_loc1_xlat[31]
int used_quant_units
number of quant units with coded spectrum
Definition: atrac3plus.h:136
static const uint8_t atrac3p_huff_gain_npoints2_xlat[8]
static const uint8_t atrac3p_huff_gain_lev4_cb[11]
int lev_code[7]
level at corresponding control point
Definition: atrac.h:37
uint8_t negate_coeffs[ATRAC3P_SUBBANDS]
1 - subband-wise IMDCT coefficients negation
Definition: atrac3plus.h:144
static const uint8_t atrac3p_ct_huff_xlat1[8]
#define ATRAC3P_SUBBANDS
Global unit sizes.
Definition: atrac3plus.h:40
static const uint8_t atrac3p_wl_huff_code4[8]
#define CODING_VLC_DIFF
Definition: atrac3plus.c:713
static const uint16_t atrac3p_sf_huff_code2[64]
static VLC_TYPE tables_data[154276][2]
Definition: atrac3plus.c:34
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static const uint8_t atrac3p_sf_huff_xlat2[64]
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
static const uint8_t atrac3p_huff_gain_loc4_xlat[32]
uint8_t
static const uint8_t atrac3p_wl_huff_xlat2[5]
#define av_cold
Definition: attributes.h:82
static const uint8_t atrac3p_huff_wav_ampsf2_xlat[32]
static const uint8_t atrac3p_huff_gain_loc4_cb[5]
static void gainc_level_mode3s(AtracGainInfo *dst, AtracGainInfo *ref)
Implements coding mode 3 (slave) for gain compensation levels.
Definition: atrac3plus.c:1030
int16_t spectrum[2048]
decoded IMDCT spectrum
Definition: atrac3plus.h:98
static const uint8_t atrac3p_wl_huff_bits1[3]
float delta
static const uint8_t atrac3p_huff_gain_lev1_cb[9]
int stop_pos
stop position expressed in n*4 samples
Definition: atrac3plus.h:69
static void decode_window_shape(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels)
Decode mdct window shape flags for all channels.
Definition: atrac3plus.c:946
static const uint8_t atrac3p_wl_huff_bits3[8]
static int decode_gainc_levels(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int coded_subbands)
Decode level code for each gain control point.
Definition: atrac3plus.c:1071
int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode bitstream data of a channel unit.
Definition: atrac3plus.c:1757
uint8_t num_coeffs
1 - map index to a single value, > 1 - map index to a vector of values
Parameters of a single sine wave.
Definition: atrac3plus.h:81
Atrac3pWaveEnvelope pend_env
pending envelope from the previous frame
Definition: atrac3plus.h:74
static const int atrac3p_subband_to_num_powgrps[16]
Map subband number to number of power compensation groups.
int qu_sf_idx[32]
array of scale factor indexes for each quant unit
Definition: atrac3plus.h:96
bitstream reader API header.
static void decode_spectrum(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode huffman-coded IMDCT spectrum for all channels.
Definition: atrac3plus.c:851
int tones_index
total sum of tones in this unit
Definition: atrac3plus.h:126
static const uint8_t atrac3p_huff_gain_lev3_cb[11]
int loc_code[7]
location of gain control points
Definition: atrac.h:38
static const uint8_t atrac3p_sf_huff_bits6[16]
uint8_t invert_phase[ATRAC3P_SUBBANDS]
1 - subband-wise phase inversion
Definition: atrac3plus.h:125
static const uint16_t atrac3p_sf_huff_code1[64]
VLC tables for scale factor indexes.
uint8_t * wnd_shape
IMDCT window shape for current frame.
Definition: atrac3plus.h:103
#define av_log(a,...)
int noise_level_index
global noise level index
Definition: atrac3plus.h:141
static const uint8_t atrac3p_qu_to_subband[32]
Map quant unit number to subband number.
AVS_FilterInfo ** fi
Definition: avisynth_c.h:731
static const uint8_t atrac3p_huff_freq_xlat[256]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static const uint16_t mask[17]
Definition: lzw.c:38
static const int8_t atrac3p_sf_weights[2][32]
static void decode_tones_envelope(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int band_has_tones[])
Decode envelope for all tones of a channel.
Definition: atrac3plus.c:1405
static const uint8_t atrac3p_ct_huff_code1[4]
VLC tables for code table indexes.
static const uint8_t atrac3p_huff_gain_loc1_cb[9]
static const uint16_t atrac3p_sf_huff_code4[16]
static const struct endianess table[]
static const uint8_t atrac3p_huff_wav_ampsf3_cb[9]
#define CODING_VLC_DELTA
Definition: atrac3plus.c:707
Tables for spectrum coding.
Parameters of a group of sine waves.
Definition: atrac3plus.h:73
static const uint8_t atrac3p_huff_gain_loc3_cb[7]
int noise_table_index
global noise RNG table index
Definition: atrac3plus.h:142
static VLC wl_vlc_tabs[4]
Definition: atrac3plus.c:35
simple assert() macros that are a bit more flexible than ISO C assert().
static VLC tone_vlc_tabs[7]
Definition: atrac3plus.c:40
static const float qu[2]
Definition: sipr16kdata.h:28
int qu_wordlen[32]
array of word lengths for each quant unit
Definition: atrac3plus.h:95
static void gainc_level_mode1m(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, AtracGainInfo *dst)
Implements coding mode 1 (master) for gain compensation levels.
Definition: atrac3plus.c:1045
int amplitude_mode
1 - low range, 0 - high range
Definition: atrac3plus.h:121
Definition: vlc.h:26
static const uint8_t atrac3p_sf_huff_xlat1[64]
#define ATRAC3P_POWER_COMP_OFF
Global constants.
Definition: atrac3plus.h:47
static int decode_band_numwavs(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int band_has_tones[], AVCodecContext *avctx)
Decode number of tones for each subband of a channel.
Definition: atrac3plus.c:1446
static int get_subband_flags(GetBitContext *gb, uint8_t *out, int num_flags)
Retrieve specified amount of flag bits from the input bitstream.
Definition: atrac3plus.c:921
static const uint8_t atrac3p_huff_gain_npoints1_cb[9]
static int decode_quant_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode word length information for each channel.
Definition: atrac3plus.c:613
uint8_t group_size
number of coefficients grouped together
static const uint8_t atrac3p_sf_huff_xlat5[16]
static void decode_qu_spectra(GetBitContext *gb, const Atrac3pSpecCodeTab *tab, VLC *vlc_tab, int16_t *out, const int num_specs)
Decode huffman-coded spectral lines for a given quant unit.
Definition: atrac3plus.c:812
static const uint8_t atrac3p_qu_num_to_seg[32]
Ungroup table for word length segments.
static const uint8_t atrac3p_huff_gain_lev3_xlat[16]
static VLC ct_vlc_tabs[4]
Definition: atrac3plus.c:37
static const uint8_t atrac3p_wl_huff_xlat1[3]
Atrac3pWavesData * tones_info
Definition: atrac3plus.h:114
#define DEC_CT_IDX_COMMON(OP)
Definition: atrac3plus.c:690
AVFormatContext * ctx
Definition: movenc.c:48
int use_full_table
1 - full table list, 0 - restricted one
Definition: atrac3plus.h:139
static const uint8_t atrac3p_wl_huff_code1[3]
VLC tables for wordlen.
static const uint8_t atrac3p_ct_restricted_to_full[2][7][4]
static const uint8_t atrac3p_huff_numwavs1_cb[9]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int num_gain_subbands
number of subbands with gain control data
Definition: atrac3plus.h:110
uint8_t swap_channels[ATRAC3P_SUBBANDS]
1 - perform subband-wise channel swapping
Definition: atrac3plus.h:143
uint8_t tone_sharing[ATRAC3P_SUBBANDS]
1 - subband-wise tone sharing flags
Definition: atrac3plus.h:123
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:563
int num_coded_vals
number of transmitted quant unit values
Definition: atrac3plus.h:91
static const uint8_t atrac3p_sf_huff_bits1[64]
static const uint8_t atrac3p_huff_gain_loc5_xlat[32]
static const uint8_t atrac3p_huff_wav_ampsf1_xlat[32]
av_cold void ff_atrac3p_init_vlcs(void)
Initialize VLC tables for bitstream parsing.
Definition: atrac3plus.c:80
static const uint8_t atrac3p_huff_gain_lev2_xlat[15]
#define CODING_VLC
Definition: atrac3plus.c:705
static VLC sf_vlc_tabs[8]
Definition: atrac3plus.c:36
static int decode_gainc_data(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode gain control data for all channels.
Definition: atrac3plus.c:1362
int bits
Definition: vlc.h:27
static const float pred[4]
Definition: siprdata.h:259
static const uint8_t atrac3p_huff_gain_loc5_cb[9]
static const uint8_t atrac3p_huff_gain_lev2_cb[11]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int table_allocated
Definition: vlc.h:29
static const uint8_t atrac3p_sf_huff_bits5[16]
int start_index
start index into global tones table for that subband
Definition: atrac3plus.h:77
int freq_index
wave frequency index
Definition: atrac3plus.h:82
Gain control parameters for one subband.
Definition: atrac.h:35
Libavcodec external API header.
static void gainc_loc_mode1(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, AtracGainInfo *dst)
Implements coding mode 1 for gain compensation locations.
Definition: atrac3plus.c:1176
static const uint8_t atrac3p_huff_wav_ampsf3_xlat[32]
main external API structure.
Definition: avcodec.h:1518
Channel unit parameters.
Definition: atrac3plus.h:131
static const uint8_t atrac3p_sf_huff_xlat4[16]
static const int8_t atrac3p_wl_weights[6][32]
static const uint8_t atrac3p_ct_huff_code3[8]
int amp_sf
quantized amplitude scale factor
Definition: atrac3plus.h:83
Sound channel parameters.
Definition: atrac3plus.h:89
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
int index
Definition: gxfenc.c:89
static const uint16_t atrac3p_sf_huff_code6[16]
static const uint8_t atrac3p_huff_gain_lev4_xlat[16]
#define UNPACK_SF_VQ_SHAPE(gb, dst, num_vals)
Definition: atrac3plus.c:321
static int decode_channel_code_tab(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, AVCodecContext *avctx)
Decode code table indexes for each quant unit of a channel.
Definition: atrac3plus.c:726
static int subtract_sf_weights(Atrac3pChanUnitCtx *ctx, Atrac3pChanParams *chan, int wtab_idx, AVCodecContext *avctx)
Subtract weighting coefficients from decoded scalefactors.
Definition: atrac3plus.c:281
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, AVCodecContext *avctx)
Decode word length for each quantization unit of a channel.
Definition: atrac3plus.c:335
static int decode_channel_sf_idx(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, AVCodecContext *avctx)
Decode scale factor indexes for each quant unit of a channel.
Definition: atrac3plus.c:478
int num_points
number of gain control points
Definition: atrac.h:36
static int num_coded_units(GetBitContext *gb, Atrac3pChanParams *chan, Atrac3pChanUnitCtx *ctx, AVCodecContext *avctx)
Decode number of coded quantization units.
Definition: atrac3plus.c:221
static const uint8_t atrac3p_huff_tonebands_cb[8]
static const uint8_t atrac3p_huff_numwavs2_cb[8]
int redirect
if >= 0: tells which huffman table must be reused
int has_start_point
indicates start point within the GHA window
Definition: atrac3plus.h:66
static const uint8_t atrac3p_huff_gain_loc3_xlat[32]
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AtracGainInfo * gain_data
gain control data for next frame
Definition: atrac3plus.h:108
static void decode_tones_frequency(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int band_has_tones[])
Decode frequency information for each subband of a channel.
Definition: atrac3plus.c:1510
int has_stop_point
indicates stop point within the GHA window
Definition: atrac3plus.h:67
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
static VLC spec_vlc_tabs[112]
Definition: atrac3plus.c:38
Atrac3pWaveSynthParams * waves_info
Definition: atrac3plus.h:149
int qu_tab_idx[32]
array of code table indexes for each quant unit
Definition: atrac3plus.h:97
int noise_present
1 - global noise info present
Definition: atrac3plus.h:140
static const uint8_t atrac3p_wl_huff_bits2[5]
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const uint8_t atrac3p_huff_numwavs2_xlat[8]
static const int8_t atrac3p_wl_shapes[8][16][9]
3D base shape tables.
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
Atrac3pChanParams channels[2]
Definition: atrac3plus.h:145
static int decode_scale_factors(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode scale factor indexes for each channel.
Definition: atrac3plus.c:646
static const uint8_t atrac3p_sf_huff_bits4[16]
static const uint8_t atrac3p_sf_huff_bits3[64]
int start_pos
start position expressed in n*4 samples
Definition: atrac3plus.h:68
static const struct twinvq_data tab
static const uint8_t atrac3p_huff_wav_ampsf1_cb[7]
static const uint16_t atrac3p_sf_huff_code5[16]
static int decode_tones_info(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int num_channels, AVCodecContext *avctx)
Decode tones info for all channels.
Definition: atrac3plus.c:1695
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2204
FILE * out
Definition: movenc.c:54
static const uint8_t atrac3p_ct_huff_bits1[4]
static const uint8_t atrac3p_huff_gain_lev1_xlat[16]
static void gainc_loc_mode0(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, AtracGainInfo *dst, int pos)
Implements coding mode 0 for gain compensation locations.
Definition: atrac3plus.c:1153
int mute_flag
mute flag
Definition: atrac3plus.h:138
#define VLC_TYPE
Definition: vlc.h:24
#define FFSWAP(type, a, b)
Definition: common.h:99
static const uint8_t atrac3p_wl_huff_code2[5]
int tones_present
1 - tones info present
Definition: atrac3plus.h:120
static int decode_gainc_npoints(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int coded_subbands)
Decode number of gain control points.
Definition: atrac3plus.c:965
#define CODING_DIRECT
Definition: atrac3plus.c:703
uint8_t tone_master[ATRAC3P_SUBBANDS]
1 - subband-wise tone channel swapping
Definition: atrac3plus.h:124
static const uint8_t atrac3p_wl_huff_code3[8]
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
Global structures, constants and data for ATRAC3+ decoder.
static VLC gain_vlc_tabs[11]
Definition: atrac3plus.c:39
static int add_wordlen_weights(Atrac3pChanUnitCtx *ctx, Atrac3pChanParams *chan, int wtab_idx, AVCodecContext *avctx)
Add weighting coefficients to the decoded word-length information.
Definition: atrac3plus.c:251
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:284
static void decode_tones_amplitude(GetBitContext *gb, Atrac3pChanUnitCtx *ctx, int ch_num, int band_has_tones[])
Decode amplitude information for each subband of a channel.
Definition: atrac3plus.c:1570
static const uint16_t atrac3p_sf_huff_code3[64]
uint8_t power_levs[5]
power compensation levels
Definition: atrac3plus.h:99
static const uint8_t atrac3p_wl_huff_bits4[8]