FFmpeg
atrac9dec.c
Go to the documentation of this file.
1 /*
2  * ATRAC9 decoder
3  * Copyright (c) 2018 Rostislav Pehlivanov <atomnuker@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/channel_layout.h"
23 #include "libavutil/mem.h"
24 #include "libavutil/thread.h"
25 
26 #include "codec_internal.h"
27 #include "decode.h"
28 #include "get_bits.h"
29 #include "atrac9tab.h"
30 #include "libavutil/tx.h"
31 #include "libavutil/lfg.h"
32 #include "libavutil/float_dsp.h"
33 #include "libavutil/mem_internal.h"
34 
35 #define ATRAC9_SF_VLC_BITS 8
36 #define ATRAC9_COEFF_VLC_BITS 9
37 
38 typedef struct ATRAC9ChannelData {
39  int band_ext;
40  int q_unit_cnt;
41  int band_ext_data[4];
42  int32_t scalefactors[31];
43  int32_t scalefactors_prev[31];
44 
45  int precision_coarse[30];
46  int precision_fine[30];
47  int precision_mask[30];
48 
49  int codebookset[30];
50 
51  int32_t q_coeffs_coarse[256];
52  int32_t q_coeffs_fine[256];
53 
54  DECLARE_ALIGNED(32, float, coeffs )[256];
55  DECLARE_ALIGNED(32, float, prev_win)[128];
56 } ATRAC9ChannelData;
57 
58 typedef struct ATRAC9BlockData {
59  ATRAC9ChannelData channel[2];
60 
61  /* Base */
62  int band_count;
63  int q_unit_cnt;
64  int q_unit_cnt_prev;
65 
66  /* Stereo block only */
67  int stereo_q_unit;
68 
69  /* Band extension only */
70  int has_band_ext;
71  int has_band_ext_data;
72  int band_ext_q_unit;
73 
74  /* Gradient */
75  int grad_mode;
76  int grad_boundary;
77  int gradient[31];
78 
79  /* Stereo */
80  int cpe_base_channel;
81  int is_signs[30];
82 
83  int reuseable;
84 
85 } ATRAC9BlockData;
86 
87 typedef struct ATRAC9Context {
88  AVCodecContext *avctx;
89  AVFloatDSPContext *fdsp;
90  AVTXContext *tx;
91  av_tx_fn tx_fn;
92  ATRAC9BlockData block[5];
93  AVLFG lfg;
94 
95  /* Set on init */
96  int frame_log2;
97  int avg_frame_size;
98  int frame_count;
99  int samplerate_idx;
100  const ATRAC9BlockConfig *block_config;
101 
102  /* Generated on init */
103  uint8_t alloc_curve[48][48];
104  DECLARE_ALIGNED(32, float, imdct_win)[256];
105 
106  DECLARE_ALIGNED(32, float, temp)[2048];
107 } ATRAC9Context;
108 
109 static const VLCElem *sf_vlc[2][8]; /* Signed/unsigned, length */
110 static const VLCElem *coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */
111 
112 static inline int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b,
113  GetBitContext *gb)
114 {
115  int grad_range[2];
116  int grad_value[2];
117  int values, sign, base;
118  uint8_t *curve;
119  float scale;
120 
121  b->grad_mode = get_bits(gb, 2);
122  if (b->grad_mode) {
123  grad_range[0] = get_bits(gb, 5);
124  grad_range[1] = 31;
125  grad_value[0] = get_bits(gb, 5);
126  grad_value[1] = 31;
127  } else {
128  grad_range[0] = get_bits(gb, 6);
129  grad_range[1] = get_bits(gb, 6) + 1;
130  grad_value[0] = get_bits(gb, 5);
131  grad_value[1] = get_bits(gb, 5);
132  }
133  b->grad_boundary = get_bits(gb, 4);
134 
135  if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
136  return AVERROR_INVALIDDATA;
137 
138  if (b->grad_boundary > b->q_unit_cnt)
139  return AVERROR_INVALIDDATA;
140 
141  values = grad_value[1] - grad_value[0];
142  sign = 1 - 2*(values < 0);
143  base = grad_value[0] + sign;
144  scale = (FFABS(values) - 1) / 31.0f;
145  curve = s->alloc_curve[grad_range[1] - grad_range[0] - 1];
146 
147  for (int i = 0; i <= b->q_unit_cnt; i++)
148  b->gradient[i] = grad_value[i >= grad_range[0]];
149 
150  for (int i = grad_range[0]; i < grad_range[1]; i++)
151  b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));
152 
153  return 0;
154 }
155 
156 static inline void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b,
157  ATRAC9ChannelData *c)
158 {
159  memset(c->precision_mask, 0, sizeof(c->precision_mask));
160  for (int i = 1; i < b->q_unit_cnt; i++) {
161  const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;
162  if (delta > 0) {
163  const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
164  c->precision_mask[i - neg] += FFMIN(delta, 5);
165  }
166  }
167 
168  if (b->grad_mode) {
169  for (int i = 0; i < b->q_unit_cnt; i++) {
170  c->precision_coarse[i] = c->scalefactors[i];
171  c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];
172  if (c->precision_coarse[i] < 0)
173  continue;
174  switch (b->grad_mode) {
175  case 1:
176  c->precision_coarse[i] >>= 1;
177  break;
178  case 2:
179  c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
180  break;
181  case 3:
182  c->precision_coarse[i] >>= 2;
183  break;
184  }
185  }
186  } else {
187  for (int i = 0; i < b->q_unit_cnt; i++)
188  c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
189  }
190 
191 
192  for (int i = 0; i < b->q_unit_cnt; i++)
193  c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
194 
195  for (int i = 0; i < b->grad_boundary; i++)
196  c->precision_coarse[i]++;
197 
198  for (int i = 0; i < b->q_unit_cnt; i++) {
199  c->precision_fine[i] = 0;
200  if (c->precision_coarse[i] > 15) {
201  c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;
202  c->precision_coarse[i] = 15;
203  }
204  }
205 }
206 
207 static inline int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b,
208  GetBitContext *gb, int stereo)
209 {
210  int ext_band = 0;
211 
212  if (b->has_band_ext) {
213  if (b->q_unit_cnt < 13 || b->q_unit_cnt > 20)
214  return AVERROR_INVALIDDATA;
215  ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];
216  if (stereo) {
217  b->channel[1].band_ext = get_bits(gb, 2);
218  b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;
219  } else {
220  skip_bits1(gb);
221  }
222  }
223 
224  b->has_band_ext_data = get_bits1(gb);
225  if (!b->has_band_ext_data)
226  return 0;
227 
228  if (!b->has_band_ext) {
229  skip_bits(gb, 2);
230  skip_bits_long(gb, get_bits(gb, 5));
231  return 0;
232  }
233 
234  b->channel[0].band_ext = get_bits(gb, 2);
235  b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;
236 
237  if (!get_bits(gb, 5)) {
238  for (int i = 0; i <= stereo; i++) {
239  ATRAC9ChannelData *c = &b->channel[i];
240  const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
241  for (int j = 0; j < count; j++) {
242  int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
243  c->band_ext_data[j] = av_clip_uintp2_c(c->band_ext_data[j], len);
244  }
245  }
246 
247  return 0;
248  }
249 
250  for (int i = 0; i <= stereo; i++) {
251  ATRAC9ChannelData *c = &b->channel[i];
252  const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
253  for (int j = 0; j < count; j++) {
254  int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
255  c->band_ext_data[j] = get_bits(gb, len);
256  }
257  }
258 
259  return 0;
260 }
261 
262 static inline int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
263  ATRAC9ChannelData *c, GetBitContext *gb,
264  int channel_idx, int first_in_pkt)
265 {
266  static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };
267  const int mode = mode_map[channel_idx][get_bits(gb, 2)];
268 
269  memset(c->scalefactors, 0, sizeof(c->scalefactors));
270 
271  if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {
272  av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");
273  return AVERROR_INVALIDDATA;
274  }
275 
276  switch (mode) {
277  case 0: { /* VLC delta offset */
278  const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];
279  const int base = get_bits(gb, 5);
280  const int len = get_bits(gb, 2) + 3;
281  const VLCElem *tab = sf_vlc[0][len];
282 
283  c->scalefactors[0] = get_bits(gb, len);
284 
285  for (int i = 1; i < b->band_ext_q_unit; i++) {
286  int val = c->scalefactors[i - 1] + get_vlc2(gb, tab,
287  ATRAC9_SF_VLC_BITS, 1);
288  c->scalefactors[i] = val & ((1 << len) - 1);
289  }
290 
291  for (int i = 0; i < b->band_ext_q_unit; i++)
292  c->scalefactors[i] += base - sf_weights[i];
293 
294  break;
295  }
296  case 1: { /* CLC offset */
297  const int len = get_bits(gb, 2) + 2;
298  const int base = len < 5 ? get_bits(gb, 5) : 0;
299  for (int i = 0; i < b->band_ext_q_unit; i++)
300  c->scalefactors[i] = base + get_bits(gb, len);
301  break;
302  }
303  case 2:
304  case 4: { /* VLC dist to baseline */
305  const int *baseline = mode == 4 ? c->scalefactors_prev :
306  channel_idx ? b->channel[0].scalefactors :
307  c->scalefactors_prev;
308  const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :
309  channel_idx ? b->band_ext_q_unit :
310  b->q_unit_cnt_prev;
311 
312  const int len = get_bits(gb, 2) + 2;
313  const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
314  const VLCElem *tab = sf_vlc[1][len];
315 
316  for (int i = 0; i < unit_cnt; i++) {
317  int dist = get_vlc2(gb, tab, ATRAC9_SF_VLC_BITS, 1);
318  c->scalefactors[i] = baseline[i] + dist;
319  }
320 
321  for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
322  c->scalefactors[i] = get_bits(gb, 5);
323 
324  break;
325  }
326  case 3: { /* VLC offset with baseline */
327  const int *baseline = channel_idx ? b->channel[0].scalefactors :
328  c->scalefactors_prev;
329  const int baseline_len = channel_idx ? b->band_ext_q_unit :
330  b->q_unit_cnt_prev;
331 
332  const int base = get_bits(gb, 5) - (1 << (5 - 1));
333  const int len = get_bits(gb, 2) + 1;
334  const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
335  const VLCElem *tab = sf_vlc[0][len];
336 
337  c->scalefactors[0] = get_bits(gb, len);
338 
339  for (int i = 1; i < unit_cnt; i++) {
340  int val = c->scalefactors[i - 1] + get_vlc2(gb, tab,
341  ATRAC9_SF_VLC_BITS, 1);
342  c->scalefactors[i] = val & ((1 << len) - 1);
343  }
344 
345  for (int i = 0; i < unit_cnt; i++)
346  c->scalefactors[i] += base + baseline[i];
347 
348  for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
349  c->scalefactors[i] = get_bits(gb, 5);
350  break;
351  }
352  }
353 
354  for (int i = 0; i < b->band_ext_q_unit; i++)
355  if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)
356  return AVERROR_INVALIDDATA;
357 
358  memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
359 
360  return 0;
361 }
362 
363 static inline void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b,
364  ATRAC9ChannelData *c)
365 {
366  int avg = 0;
367  const int last_sf = c->scalefactors[c->q_unit_cnt];
368 
369  memset(c->codebookset, 0, sizeof(c->codebookset));
370 
371  if (c->q_unit_cnt <= 1)
372  return;
373  if (s->samplerate_idx > 7)
374  return;
375 
376  c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
377 
378  if (c->q_unit_cnt > 12) {
379  for (int i = 0; i < 12; i++)
380  avg += c->scalefactors[i];
381  avg = (avg + 6) / 12;
382  }
383 
384  for (int i = 8; i < c->q_unit_cnt; i++) {
385  const int prev = c->scalefactors[i - 1];
386  const int cur = c->scalefactors[i ];
387  const int next = c->scalefactors[i + 1];
388  const int min = FFMIN(prev, next);
389  if ((cur - min >= 3 || 2*cur - prev - next >= 3))
390  c->codebookset[i] = 1;
391  }
392 
393 
394  for (int i = 12; i < c->q_unit_cnt; i++) {
395  const int cur = c->scalefactors[i];
396  const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;
397  const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);
398  if (c->codebookset[i])
399  continue;
400 
401  c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
402  }
403 
404  c->scalefactors[c->q_unit_cnt] = last_sf;
405 }
406 
407 static inline void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b,
408  ATRAC9ChannelData *c, GetBitContext *gb)
409 {
410  const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
411 
412  memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
413 
414  for (int i = 0; i < c->q_unit_cnt; i++) {
415  int *coeffs = &c->q_coeffs_coarse[at9_q_unit_to_coeff_idx[i]];
416  const int bands = at9_q_unit_to_coeff_cnt[i];
417  const int prec = c->precision_coarse[i] + 1;
418 
419  if (prec <= max_prec) {
420  const int cb = c->codebookset[i];
421  const int cbi = at9_q_unit_to_codebookidx[i];
422  const VLCElem *tab = coeff_vlc[cb][prec][cbi];
423  const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];
424  const int groups = bands >> huff->value_cnt_pow;
425 
426  for (int j = 0; j < groups; j++) {
427  uint16_t val = get_vlc2(gb, tab, ATRAC9_COEFF_VLC_BITS, 2);
428 
429  for (int k = 0; k < huff->value_cnt; k++) {
430  coeffs[k] = sign_extend(val, huff->value_bits);
431  val >>= huff->value_bits;
432  }
433 
434  coeffs += huff->value_cnt;
435  }
436  } else {
437  for (int j = 0; j < bands; j++)
438  coeffs[j] = sign_extend(get_bits(gb, prec), prec);
439  }
440  }
441 }
442 
443 static inline void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b,
444  ATRAC9ChannelData *c, GetBitContext *gb)
445 {
446  memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
447 
448  for (int i = 0; i < c->q_unit_cnt; i++) {
449  const int start = at9_q_unit_to_coeff_idx[i + 0];
450  const int end = at9_q_unit_to_coeff_idx[i + 1];
451  const int len = c->precision_fine[i] + 1;
452 
453  if (c->precision_fine[i] <= 0)
454  continue;
455 
456  for (int j = start; j < end; j++)
457  c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
458  }
459 }
460 
461 static inline void dequantize(ATRAC9Context *s, ATRAC9BlockData *b,
462  ATRAC9ChannelData *c)
463 {
464  memset(c->coeffs, 0, sizeof(c->coeffs));
465 
466  for (int i = 0; i < c->q_unit_cnt; i++) {
467  const int start = at9_q_unit_to_coeff_idx[i + 0];
468  const int end = at9_q_unit_to_coeff_idx[i + 1];
469 
470  const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];
471  const float fine_c = at9_quant_step_fine[c->precision_fine[i]];
472 
473  for (int j = start; j < end; j++) {
474  const float vc = c->q_coeffs_coarse[j] * coarse_c;
475  const float vf = c->q_coeffs_fine[j] * fine_c;
476  c->coeffs[j] = vc + vf;
477  }
478  }
479 }
480 
481 static inline void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b,
482  const int stereo)
483 {
484  float *src = b->channel[ b->cpe_base_channel].coeffs;
485  float *dst = b->channel[!b->cpe_base_channel].coeffs;
486 
487  if (!stereo)
488  return;
489 
490  if (b->q_unit_cnt <= b->stereo_q_unit)
491  return;
492 
493  for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {
494  const int sign = b->is_signs[i];
495  const int start = at9_q_unit_to_coeff_idx[i + 0];
496  const int end = at9_q_unit_to_coeff_idx[i + 1];
497  for (int j = start; j < end; j++)
498  dst[j] = sign*src[j];
499  }
500 }
501 
502 static inline void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
503  const int stereo)
504 {
505  for (int i = 0; i <= stereo; i++) {
506  float *coeffs = b->channel[i].coeffs;
507  for (int j = 0; j < b->q_unit_cnt; j++) {
508  const int start = at9_q_unit_to_coeff_idx[j + 0];
509  const int end = at9_q_unit_to_coeff_idx[j + 1];
510  const int scalefactor = b->channel[i].scalefactors[j];
511  const float scale = at9_scalefactor_c[scalefactor];
512  for (int k = start; k < end; k++)
513  coeffs[k] *= scale;
514  }
515  }
516 }
517 
518 static inline void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c,
519  int start, int count)
520 {
521  float maxval = 0.0f;
522  for (int i = 0; i < count; i += 2) {
523  double tmp[2];
524  av_bmg_get(&s->lfg, tmp);
525  c->coeffs[start + i + 0] = tmp[0];
526  c->coeffs[start + i + 1] = tmp[1];
527  maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);
528  }
529  /* Normalize */
530  for (int i = 0; i < count; i++)
531  c->coeffs[start + i] /= maxval;
532 }
533 
534 static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
535  const int s_unit, const int e_unit)
536 {
537  for (int i = s_unit; i < e_unit; i++) {
538  const int start = at9_q_unit_to_coeff_idx[i + 0];
539  const int end = at9_q_unit_to_coeff_idx[i + 1];
540  for (int j = start; j < end; j++)
541  c->coeffs[j] *= sf[i - s_unit];
542  }
543 }
544 
545 static inline void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b,
546  const int stereo)
547 {
548  const int g_units[4] = { /* A, B, C, total units */
549  b->q_unit_cnt,
550  at9_tab_band_ext_group[b->q_unit_cnt - 13][0],
551  at9_tab_band_ext_group[b->q_unit_cnt - 13][1],
552  FFMAX(g_units[2], 22),
553  };
554 
555  const int g_bins[4] = { /* A, B, C, total bins */
556  at9_q_unit_to_coeff_idx[g_units[0]],
557  at9_q_unit_to_coeff_idx[g_units[1]],
558  at9_q_unit_to_coeff_idx[g_units[2]],
559  at9_q_unit_to_coeff_idx[g_units[3]],
560  };
561 
562  for (int ch = 0; ch <= stereo; ch++) {
563  ATRAC9ChannelData *c = &b->channel[ch];
564 
565  /* Mirror the spectrum */
566  for (int i = 0; i < 3; i++)
567  for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)
568  c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];
569 
570  switch (c->band_ext) {
571  case 0: {
572  float sf[6] = { 0.0f };
573  const int l = g_units[3] - g_units[0] - 1;
574  const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];
575  const int n_cnt = at9_q_unit_to_coeff_cnt[g_units[3] - 1];
576  switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {
577  case 3:
578  sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];
579  sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];
580  sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];
581  sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];
582  sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];
583  break;
584  case 4:
585  sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];
586  sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];
587  sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];
588  sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];
589  sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];
590  break;
591  case 5:
592  sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];
593  sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];
594  sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];
595  break;
596  }
597 
598  sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
599 
600  fill_with_noise(s, c, n_start, n_cnt);
601  scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
602  break;
603  }
604  case 1: {
605  float sf[6];
606  for (int i = g_units[0]; i < g_units[3]; i++)
607  sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
608 
609  fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);
610  scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
611  break;
612  }
613  case 2: {
614  const float g_sf[2] = {
615  at9_band_ext_scales_m2[c->band_ext_data[0]],
616  at9_band_ext_scales_m2[c->band_ext_data[1]],
617  };
618 
619  for (int i = 0; i < 2; i++)
620  for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
621  c->coeffs[j] *= g_sf[i];
622  break;
623  }
624  case 3: {
625  float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];
626  float rate = at9_band_ext_scales_m3[c->band_ext_data[1]][1];
627  rate = pow(2, rate);
628  for (int i = g_bins[0]; i < g_bins[3]; i++) {
629  scale *= rate;
630  c->coeffs[i] *= scale;
631  }
632  break;
633  }
634  case 4: {
635  const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];
636  const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };
637 
638  for (int i = 0; i < 3; i++)
639  for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
640  c->coeffs[j] *= g_sf[i];
641  break;
642  }
643  }
644  }
645 }
646 
647 static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb,
648  ATRAC9BlockData *b, AVFrame *frame,
649  int frame_idx, int block_idx)
650 {
651  const int first_in_pkt = !get_bits1(gb);
652  const int reuse_params = get_bits1(gb);
653  const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;
654 
655  if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {
656  ATRAC9ChannelData *c = &b->channel[0];
657  const int precision = reuse_params ? 8 : 4;
658  c->q_unit_cnt = b->q_unit_cnt = 2;
659 
660  memset(c->scalefactors, 0, sizeof(c->scalefactors));
661  memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
662  memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
663 
664  for (int i = 0; i < b->q_unit_cnt; i++) {
665  c->scalefactors[i] = get_bits(gb, 5);
666  c->precision_coarse[i] = precision;
667  c->precision_fine[i] = 0;
668  }
669 
670  for (int i = 0; i < c->q_unit_cnt; i++) {
671  const int start = at9_q_unit_to_coeff_idx[i + 0];
672  const int end = at9_q_unit_to_coeff_idx[i + 1];
673  for (int j = start; j < end; j++)
674  c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);
675  }
676 
677  dequantize (s, b, c);
678  apply_scalefactors(s, b, 0);
679 
680  goto imdct;
681  }
682 
683  if (first_in_pkt && reuse_params) {
684  av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
685  return AVERROR_INVALIDDATA;
686  }
687 
688  /* Band parameters */
689  if (!reuse_params) {
690  int stereo_band, ext_band;
691  const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
692  b->reuseable = 0;
693  b->band_count = get_bits(gb, 4) + min_band_count;
694  b->q_unit_cnt = at9_tab_band_q_unit_map[b->band_count];
695 
696  b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;
697 
698  if (b->band_count > at9_tab_sri_max_bands[s->samplerate_idx]) {
699  av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",
700  b->band_count);
701  return AVERROR_INVALIDDATA;
702  }
703 
704  if (stereo) {
705  stereo_band = get_bits(gb, 4) + min_band_count;
706  if (stereo_band > b->band_count) {
707  av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",
708  stereo_band);
709  return AVERROR_INVALIDDATA;
710  }
711  b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
712  }
713 
714  b->has_band_ext = get_bits1(gb);
715  if (b->has_band_ext) {
716  ext_band = get_bits(gb, 4) + min_band_count;
717  if (ext_band < b->band_count) {
718  av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",
719  ext_band);
720  return AVERROR_INVALIDDATA;
721  }
722  b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];
723  }
724  b->reuseable = 1;
725  }
726  if (!b->reuseable) {
727  av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
728  return AVERROR_INVALIDDATA;
729  }
730 
731  /* Calculate bit alloc gradient */
732  if (parse_gradient(s, b, gb))
733  return AVERROR_INVALIDDATA;
734 
735  /* IS data */
736  b->cpe_base_channel = 0;
737  if (stereo) {
738  b->cpe_base_channel = get_bits1(gb);
739  if (get_bits1(gb)) {
740  for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)
741  b->is_signs[i] = 1 - 2*get_bits1(gb);
742  } else {
743  for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
744  b->is_signs[i] = 1;
745  }
746  }
747 
748  /* Band extension */
749  if (parse_band_ext(s, b, gb, stereo))
750  return AVERROR_INVALIDDATA;
751 
752  /* Scalefactors */
753  for (int i = 0; i <= stereo; i++) {
754  ATRAC9ChannelData *c = &b->channel[i];
755  c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :
756  b->stereo_q_unit;
757  if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
758  return AVERROR_INVALIDDATA;
759 
760  calc_precision (s, b, c);
761  calc_codebook_idx (s, b, c);
762  read_coeffs_coarse(s, b, c, gb);
763  read_coeffs_fine (s, b, c, gb);
764  dequantize (s, b, c);
765  }
766 
767  b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;
768 
769  apply_intensity_stereo(s, b, stereo);
770  apply_scalefactors (s, b, stereo);
771 
772  if (b->has_band_ext && b->has_band_ext_data)
773  apply_band_extension (s, b, stereo);
774 
775 imdct:
776  for (int i = 0; i <= stereo; i++) {
777  ATRAC9ChannelData *c = &b->channel[i];
778  const int dst_idx = s->block_config->plane_map[block_idx][i];
779  const int wsize = 1 << s->frame_log2;
780  const ptrdiff_t offset = wsize*frame_idx*sizeof(float);
781  float *dst = (float *)(frame->extended_data[dst_idx] + offset);
782 
783  s->tx_fn(s->tx, s->temp, c->coeffs, sizeof(float));
784  s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,
785  s->imdct_win, wsize >> 1);
786  memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);
787  }
788 
789  return 0;
790 }
791 
792 static int atrac9_decode_frame(AVCodecContext *avctx, AVFrame *frame,
793  int *got_frame_ptr, AVPacket *avpkt)
794 {
795  int ret;
796  GetBitContext gb;
797  ATRAC9Context *s = avctx->priv_data;
798  const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
799 
800  frame->nb_samples = (1 << s->frame_log2) * frames;
801  ret = ff_get_buffer(avctx, frame, 0);
802  if (ret < 0)
803  return ret;
804 
805  init_get_bits8(&gb, avpkt->data, avpkt->size);
806 
807  for (int i = 0; i < frames; i++) {
808  for (int j = 0; j < s->block_config->count; j++) {
809  ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);
810  if (ret)
811  return ret;
812  align_get_bits(&gb);
813  }
814  }
815 
816  *got_frame_ptr = 1;
817 
818  return avctx->block_align;
819 }
820 
821 static void atrac9_decode_flush(AVCodecContext *avctx)
822 {
823  ATRAC9Context *s = avctx->priv_data;
824 
825  for (int j = 0; j < s->block_config->count; j++) {
826  ATRAC9BlockData *b = &s->block[j];
827  const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;
828  for (int i = 0; i <= stereo; i++) {
829  ATRAC9ChannelData *c = &b->channel[i];
830  memset(c->prev_win, 0, sizeof(c->prev_win));
831  }
832  }
833 }
834 
835 static av_cold int atrac9_decode_close(AVCodecContext *avctx)
836 {
837  ATRAC9Context *s = avctx->priv_data;
838 
839  av_tx_uninit(&s->tx);
840  av_freep(&s->fdsp);
841 
842  return 0;
843 }
844 
845 static av_cold const VLCElem *atrac9_init_vlc(VLCInitState *state,
846  int nb_bits, int nb_codes,
847  const uint8_t (**tab)[2], int offset)
848 {
849  const uint8_t (*table)[2] = *tab;
850 
851  *tab += nb_codes;
852  return ff_vlc_init_tables_from_lengths(state, nb_bits, nb_codes,
853  &table[0][1], 2, &table[0][0], 2, 1,
854  offset, 0);
855 }
856 
857 static av_cold void atrac9_init_static(void)
858 {
859  static VLCElem vlc_buf[24812];
860  VLCInitState state = VLC_INIT_STATE(vlc_buf);
861  const uint8_t (*tab)[2];
862 
863  /* Unsigned scalefactor VLCs */
864  tab = at9_sfb_a_tab;
865  for (int i = 1; i < 7; i++) {
866  const HuffmanCodebook *hf = &at9_huffman_sf_unsigned[i];
867 
868  sf_vlc[0][i] = atrac9_init_vlc(&state, ATRAC9_SF_VLC_BITS,
869  hf->size, &tab, 0);
870  }
871 
872  /* Signed scalefactor VLCs */
873  tab = at9_sfb_b_tab;
874  for (int i = 2; i < 6; i++) {
875  const HuffmanCodebook *hf = &at9_huffman_sf_signed[i];
876 
877  /* The symbols are signed integers in the range -16..15;
878  * the values in the source table are offset by 16 to make
879  * them fit into an uint8_t; the -16 reverses this shift. */
880  sf_vlc[1][i] = atrac9_init_vlc(&state, ATRAC9_SF_VLC_BITS,
881  hf->size, &tab, -16);
882  }
883 
884  /* Coefficient VLCs */
885  tab = at9_coeffs_tab;
886  for (int i = 0; i < 2; i++) {
887  for (int j = 2; j < 8; j++) {
888  for (int k = i; k < 4; k++) {
889  const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];
890  coeff_vlc[i][j][k] = atrac9_init_vlc(&state, ATRAC9_COEFF_VLC_BITS,
891  hf->size, &tab, 0);
892  }
893  }
894  }
895 }
896 
897 static av_cold int atrac9_decode_init(AVCodecContext *avctx)
898 {
899  float scale;
900  static AVOnce static_table_init = AV_ONCE_INIT;
901  GetBitContext gb;
902  ATRAC9Context *s = avctx->priv_data;
903  int err, version, block_config_idx, superframe_idx, alloc_c_len;
904 
905  s->avctx = avctx;
906 
907  av_lfg_init(&s->lfg, 0xFBADF00D);
908 
909  if (avctx->block_align <= 0) {
910  av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
911  return AVERROR_INVALIDDATA;
912  }
913 
914  if (avctx->extradata_size != 12) {
915  av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
916  return AVERROR_INVALIDDATA;
917  }
918 
919  version = AV_RL32(avctx->extradata);
920  if (version > 2) {
921  av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
922  return AVERROR_INVALIDDATA;
923  }
924 
925  init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
926 
927  if (get_bits(&gb, 8) != 0xFE) {
928  av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
929  return AVERROR_INVALIDDATA;
930  }
931 
932  s->samplerate_idx = get_bits(&gb, 4);
933  avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];
934 
935  block_config_idx = get_bits(&gb, 3);
936  if (block_config_idx > 5) {
937  av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");
938  return AVERROR_INVALIDDATA;
939  }
940  s->block_config = &at9_block_layout[block_config_idx];
941 
942  av_channel_layout_uninit(&avctx->ch_layout);
943  avctx->ch_layout = s->block_config->channel_layout;
944  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
945 
946  if (get_bits1(&gb)) {
947  av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
948  return AVERROR_INVALIDDATA;
949  }
950 
951  /* Average frame size in bytes */
952  s->avg_frame_size = get_bits(&gb, 11) + 1;
953 
954  superframe_idx = get_bits(&gb, 2);
955  if (superframe_idx & 1) {
956  av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");
957  return AVERROR_INVALIDDATA;
958  }
959 
960  s->frame_count = 1 << superframe_idx;
961  s->frame_log2 = at9_tab_sri_frame_log2[s->samplerate_idx];
962 
963  scale = 1.0f / 32768.0;
964  err = av_tx_init(&s->tx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1,
965  1 << s->frame_log2, &scale, 0);
966  if (err < 0)
967  return err;
968 
969  s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
970  if (!s->fdsp)
971  return AVERROR(ENOMEM);
972 
973  /* iMDCT window */
974  for (int i = 0; i < (1 << s->frame_log2); i++) {
975  const int len = 1 << s->frame_log2;
976  const float sidx = ( i + 0.5f) / len;
977  const float eidx = (len - i - 0.5f) / len;
978  const float s_c = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;
979  const float e_c = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;
980  s->imdct_win[i] = s_c / ((s_c * s_c) + (e_c * e_c));
981  }
982 
983  /* Allocation curve */
984  alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);
985  for (int i = 1; i <= alloc_c_len; i++)
986  for (int j = 0; j < i; j++)
987  s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];
988 
989  ff_thread_once(&static_table_init, atrac9_init_static);
990 
991  return 0;
992 }
993 
994 const FFCodec ff_atrac9_decoder = {
995  .p.name = "atrac9",
996  CODEC_LONG_NAME("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
997  .p.type = AVMEDIA_TYPE_AUDIO,
998  .p.id = AV_CODEC_ID_ATRAC9,
999  .priv_data_size = sizeof(ATRAC9Context),
1000  .init = atrac9_decode_init,
1001  .close = atrac9_decode_close,
1002  FF_CODEC_DECODE_CB(atrac9_decode_frame),
1003  .flush = atrac9_decode_flush,
1004  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1005  .p.capabilities =
1006 #if FF_API_SUBFRAMES
1007  AV_CODEC_CAP_SUBFRAMES |
1008 #endif
1009  AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1010 };
atrac9_decode_close
static av_cold int atrac9_decode_close(AVCodecContext *avctx)
Definition: atrac9dec.c:835
ATRAC9ChannelData::q_coeffs_coarse
int32_t q_coeffs_coarse[256]
Definition: atrac9dec.c:51
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ATRAC9ChannelData::coeffs
float coeffs[256]
Definition: atrac9dec.c:54
ATRAC9BlockData::is_signs
int is_signs[30]
Definition: atrac9dec.c:81
mem_internal.h
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
ATRAC9Context::temp
float temp[2048]
Definition: atrac9dec.c:106
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:242
HuffmanCodebook::size
const int size
Definition: atrac9tab.h:425
at9_band_ext_scales_m2
static const float at9_band_ext_scales_m2[]
Definition: atrac9tab.h:271
thread.h
read_scalefactors
static int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb, int channel_idx, int first_in_pkt)
Definition: atrac9dec.c:262
AVTXContext
Definition: tx_priv.h:235
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
atrac9_init_vlc
static const av_cold VLCElem * atrac9_init_vlc(VLCInitState *state, int nb_bits, int nb_codes, const uint8_t(**tab)[2], int offset)
Definition: atrac9dec.c:845
at9_tab_samplerates
static const int at9_tab_samplerates[]
Definition: atrac9tab.h:116
av_clip_uintp2_c
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
Clip a signed integer to an unsigned power of two range.
Definition: common.h:279
AVPacket::data
uint8_t * data
Definition: packet.h:524
M_PI_2
#define M_PI_2
Definition: mathematics.h:73
ATRAC9BlockData::has_band_ext
int has_band_ext
Definition: atrac9dec.c:70
calc_codebook_idx
static void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:363
b
#define b
Definition: input.c:41
ATRAC9ChannelData
Definition: atrac9dec.c:38
table
static const uint16_t table[]
Definition: prosumer.c:205
ATRAC9_COEFF_VLC_BITS
#define ATRAC9_COEFF_VLC_BITS
Definition: atrac9dec.c:36
at9_block_layout
static const ATRAC9BlockConfig at9_block_layout[]
Definition: atrac9tab.h:42
FFCodec
Definition: codec_internal.h:127
base
uint8_t base
Definition: vp3data.h:128
ATRAC9ChannelData::precision_fine
int precision_fine[30]
Definition: atrac9dec.c:46
HuffmanCodebook::value_cnt
const int value_cnt
Definition: atrac9tab.h:426
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ATRAC9Context::frame_count
int frame_count
Definition: atrac9dec.c:98
ATRAC9Context::avctx
AVCodecContext * avctx
Definition: atrac9dec.c:88
ATRAC9Context::lfg
AVLFG lfg
Definition: atrac9dec.c:93
ATRAC9ChannelData::precision_mask
int precision_mask[30]
Definition: atrac9dec.c:47
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:903
read_coeffs_fine
static void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:443
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
ATRAC9Context
Definition: atrac9dec.c:87
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
at9_tab_band_ext_cnt
static const uint8_t at9_tab_band_ext_cnt[][6]
Definition: atrac9tab.h:121
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
calc_precision
static void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:156
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
GetBitContext
Definition: get_bits.h:108
ATRAC9Context::block
ATRAC9BlockData block[5]
Definition: atrac9dec.c:92
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
ATRAC9BlockData::grad_mode
int grad_mode
Definition: atrac9dec.c:75
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
val
static double val(void *priv, double ch)
Definition: aeval.c:78
ATRAC9Context::alloc_curve
uint8_t alloc_curve[48][48]
Definition: atrac9dec.c:103
HuffmanCodebook::value_cnt_pow
const int value_cnt_pow
Definition: atrac9tab.h:427
scale_band_ext_coeffs
static void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6], const int s_unit, const int e_unit)
Definition: atrac9dec.c:534
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
ATRAC9_BLOCK_TYPE_LFE
@ ATRAC9_BLOCK_TYPE_LFE
Definition: atrac9tab.h:32
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
parse_band_ext
static int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb, int stereo)
Definition: atrac9dec.c:207
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:212
at9_tab_sri_max_bands
static const uint8_t at9_tab_sri_max_bands[]
Definition: atrac9tab.h:112
float
float
Definition: af_crystalizer.c:121
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:287
s
#define s(width, name)
Definition: cbs_vp9.c:198
at9_q_unit_to_codebookidx
static const uint8_t at9_q_unit_to_codebookidx[]
Definition: atrac9tab.h:107
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
lfg.h
fill_with_noise
static void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c, int start, int count)
Definition: atrac9dec.c:518
ATRAC9BlockConfig
Definition: atrac9tab.h:35
AV_CODEC_ID_ATRAC9
@ AV_CODEC_ID_ATRAC9
Definition: codec_id.h:528
av_bmg_get
void av_bmg_get(AVLFG *lfg, double out[2])
Get the next two numbers generated by a Box-Muller Gaussian generator using the random numbers issued...
Definition: lfg.c:49
HuffmanCodebook::value_bits
const int value_bits
Definition: atrac9tab.h:428
ATRAC9Context::avg_frame_size
int avg_frame_size
Definition: atrac9dec.c:97
decode.h
get_bits.h
ATRAC9BlockData::band_ext_q_unit
int band_ext_q_unit
Definition: atrac9dec.c:72
bands
static const float bands[]
Definition: af_superequalizer.c:57
at9_band_ext_scales_m0
static const float at9_band_ext_scales_m0[][5][32]
Definition: atrac9tab.h:184
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
at9_sfb_a_tab
static const uint8_t at9_sfb_a_tab[][2]
Definition: atrac9tab.h:376
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
ATRAC9_SF_VLC_BITS
#define ATRAC9_SF_VLC_BITS
Definition: atrac9dec.c:35
HuffmanCodebook
Definition: atrac9tab.h:424
ATRAC9Context::tx_fn
av_tx_fn tx_fn
Definition: atrac9dec.c:91
at9_huffman_sf_unsigned
static const HuffmanCodebook at9_huffman_sf_unsigned[]
Definition: atrac9tab.h:431
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
ATRAC9Context::frame_log2
int frame_log2
Definition: atrac9dec.c:96
atrac9_decode_init
static av_cold int atrac9_decode_init(AVCodecContext *avctx)
Definition: atrac9dec.c:897
ATRAC9ChannelData::q_coeffs_fine
int32_t q_coeffs_fine[256]
Definition: atrac9dec.c:52
parse_gradient
static int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb)
Definition: atrac9dec.c:112
ATRAC9BlockData::q_unit_cnt_prev
int q_unit_cnt_prev
Definition: atrac9dec.c:64
sinf
#define sinf(x)
Definition: libm.h:419
sf_vlc
static const VLCElem * sf_vlc[2][8]
Definition: atrac9dec.c:109
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
AVOnce
#define AVOnce
Definition: thread.h:202
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ATRAC9BlockData::gradient
int gradient[31]
Definition: atrac9dec.c:77
float_dsp.h
atrac9_init_static
static av_cold void atrac9_init_static(void)
Definition: atrac9dec.c:857
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
f
f
Definition: af_crystalizer.c:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1554
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:525
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
apply_band_extension
static void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:545
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
ATRAC9ChannelData::band_ext
int band_ext
Definition: atrac9dec.c:39
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
ATRAC9Context::fdsp
AVFloatDSPContext * fdsp
Definition: atrac9dec.c:89
VLCElem
Definition: vlc.h:32
ATRAC9_BLOCK_TYPE_CPE
@ ATRAC9_BLOCK_TYPE_CPE
Definition: atrac9tab.h:31
avg
#define avg(a, b, c, d)
Definition: colorspacedsp_template.c:28
AVFloatDSPContext
Definition: float_dsp.h:22
ATRAC9ChannelData::band_ext_data
int band_ext_data[4]
Definition: atrac9dec.c:41
dequantize
static void dequantize(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:461
ATRAC9BlockData::grad_boundary
int grad_boundary
Definition: atrac9dec.c:76
at9_tab_band_q_unit_map
static const uint8_t at9_tab_band_q_unit_map[]
Definition: atrac9tab.h:93
at9_huffman_sf_signed
static const HuffmanCodebook at9_huffman_sf_signed[]
Definition: atrac9tab.h:441
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
version
version
Definition: libkvazaar.c:321
ATRAC9ChannelData::scalefactors
int32_t scalefactors[31]
Definition: atrac9dec.c:42
at9_q_unit_to_coeff_idx
static const int at9_q_unit_to_coeff_idx[]
Definition: atrac9tab.h:102
M_PI
#define M_PI
Definition: mathematics.h:67
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:295
at9_quant_step_coarse
static const float at9_quant_step_coarse[]
Definition: atrac9tab.h:306
ATRAC9BlockData::stereo_q_unit
int stereo_q_unit
Definition: atrac9dec.c:67
ATRAC9ChannelData::scalefactors_prev
int32_t scalefactors_prev[31]
Definition: atrac9dec.c:43
ATRAC9BlockData::cpe_base_channel
int cpe_base_channel
Definition: atrac9dec.c:80
ATRAC9Context::block_config
const ATRAC9BlockConfig * block_config
Definition: atrac9dec.c:100
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
at9_tab_band_ext_lengths
static const uint8_t at9_tab_band_ext_lengths[][6][4]
Definition: atrac9tab.h:141
ATRAC9Context::imdct_win
float imdct_win[256]
Definition: atrac9dec.c:104
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
atrac9_decode_block
static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb, ATRAC9BlockData *b, AVFrame *frame, int frame_idx, int block_idx)
Definition: atrac9dec.c:647
delta
float delta
Definition: vorbis_enc_data.h:430
at9_band_ext_scales_m3
static const float at9_band_ext_scales_m3[][2]
Definition: atrac9tab.h:290
at9_scalefactor_c
static const float at9_scalefactor_c[]
Definition: atrac9tab.h:324
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
at9_band_ext_scales_m4
static const float at9_band_ext_scales_m4[]
Definition: atrac9tab.h:301
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
ATRAC9BlockData::reuseable
int reuseable
Definition: atrac9dec.c:83
ATRAC9ChannelData::precision_coarse
int precision_coarse[30]
Definition: atrac9dec.c:45
ATRAC9ChannelData::codebookset
int codebookset[30]
Definition: atrac9dec.c:49
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1083
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:561
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
at9_coeffs_tab
static const uint8_t at9_coeffs_tab[][2]
Definition: atrac9tab.h:450
coeff_vlc
static const VLCElem * coeff_vlc[2][8][4]
Definition: atrac9dec.c:110
ATRAC9BlockData
Definition: atrac9dec.c:58
state
static struct @399 state
AVCodecContext
main external API structure.
Definition: avcodec.h:445
ATRAC9BlockData::has_band_ext_data
int has_band_ext_data
Definition: atrac9dec.c:71
atrac9tab.h
channel_layout.h
mode
mode
Definition: ebur128.h:83
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:433
at9_quant_step_fine
static const float at9_quant_step_fine[]
Definition: atrac9tab.h:315
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
atrac9_decode_flush
static void atrac9_decode_flush(AVCodecContext *avctx)
Definition: atrac9dec.c:821
apply_scalefactors
static void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:502
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:263
atrac9_decode_frame
static int atrac9_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac9dec.c:792
ATRAC9Context::samplerate_idx
int samplerate_idx
Definition: atrac9dec.c:99
read_coeffs_coarse
static void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:407
at9_tab_sf_weights
static const uint8_t at9_tab_sf_weights[][32]
Definition: atrac9tab.h:335
ATRAC9ChannelData::q_unit_cnt
int q_unit_cnt
Definition: atrac9dec.c:40
ff_vlc_init_tables_from_lengths
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
Definition: vlc.c:366
ATRAC9Context::tx
AVTXContext * tx
Definition: atrac9dec.c:90
mem.h
at9_tab_band_ext_group
static const uint8_t at9_tab_band_ext_group[][3]
Definition: atrac9tab.h:130
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
ATRAC9BlockData::q_unit_cnt
int q_unit_cnt
Definition: atrac9dec.c:63
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:217
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
at9_sfb_b_tab
static const uint8_t at9_sfb_b_tab[][2]
Definition: atrac9tab.h:407
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ATRAC9BlockData::band_count
int band_count
Definition: atrac9dec.c:62
at9_tab_b_dist
static const uint8_t at9_tab_b_dist[]
Definition: atrac9tab.h:370
channel
channel
Definition: ebur128.h:39
ff_atrac9_decoder
const FFCodec ff_atrac9_decoder
Definition: atrac9dec.c:994
ATRAC9ChannelData::prev_win
float prev_win[128]
Definition: atrac9dec.c:55
tx.h
at9_huffman_coeffs
static const HuffmanCodebook at9_huffman_coeffs[][8][4]
Definition: atrac9tab.h:1293
at9_tab_sri_frame_log2
static const uint8_t at9_tab_sri_frame_log2[]
Definition: atrac9tab.h:89
apply_intensity_stereo
static void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:481
min
float min
Definition: vorbis_enc_data.h:429
at9_q_unit_to_coeff_cnt
static const uint8_t at9_q_unit_to_coeff_cnt[]
Definition: atrac9tab.h:97
Generated on Thu Apr 18 2024 19:21:19 for FFmpeg by   doxygen 1.8.17