FFmpeg  4.4.4
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/thread.h"
23 
24 #include "internal.h"
25 #include "get_bits.h"
26 #include "fft.h"
27 #include "atrac9tab.h"
28 #include "libavutil/lfg.h"
29 #include "libavutil/float_dsp.h"
30 #include "libavutil/mem_internal.h"
31 
32 #define ATRAC9_SF_VLC_BITS 8
33 #define ATRAC9_COEFF_VLC_BITS 9
34 
35 typedef struct ATRAC9ChannelData {
36  int band_ext;
38  int band_ext_data[4];
41 
43  int precision_fine[30];
44  int precision_mask[30];
45 
46  int codebookset[30];
47 
50 
51  DECLARE_ALIGNED(32, float, coeffs )[256];
52  DECLARE_ALIGNED(32, float, prev_win)[128];
54 
55 typedef struct ATRAC9BlockData {
57 
58  /* Base */
62 
63  /* Stereo block only */
65 
66  /* Band extension only */
70 
71  /* Gradient */
72  int grad_mode;
74  int gradient[31];
75 
76  /* Stereo */
78  int is_signs[30];
79 
80  int reuseable;
81 
83 
84 typedef struct ATRAC9Context {
90 
91  /* Set on init */
97 
98  /* Generated on init */
100  DECLARE_ALIGNED(32, float, imdct_win)[256];
101 
102  DECLARE_ALIGNED(32, float, temp)[256];
103 } ATRAC9Context;
104 
105 static VLC sf_vlc[2][8]; /* Signed/unsigned, length */
106 static VLC coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */
107 
109  GetBitContext *gb)
110 {
111  int grad_range[2];
112  int grad_value[2];
113  int values, sign, base;
114  uint8_t *curve;
115  float scale;
116 
117  b->grad_mode = get_bits(gb, 2);
118  if (b->grad_mode) {
119  grad_range[0] = get_bits(gb, 5);
120  grad_range[1] = 31;
121  grad_value[0] = get_bits(gb, 5);
122  grad_value[1] = 31;
123  } else {
124  grad_range[0] = get_bits(gb, 6);
125  grad_range[1] = get_bits(gb, 6) + 1;
126  grad_value[0] = get_bits(gb, 5);
127  grad_value[1] = get_bits(gb, 5);
128  }
129  b->grad_boundary = get_bits(gb, 4);
130 
131  if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
132  return AVERROR_INVALIDDATA;
133 
134  if (b->grad_boundary > b->q_unit_cnt)
135  return AVERROR_INVALIDDATA;
136 
137  values = grad_value[1] - grad_value[0];
138  sign = 1 - 2*(values < 0);
139  base = grad_value[0] + sign;
140  scale = (FFABS(values) - 1) / 31.0f;
141  curve = s->alloc_curve[grad_range[1] - grad_range[0] - 1];
142 
143  for (int i = 0; i <= b->q_unit_cnt; i++)
144  b->gradient[i] = grad_value[i >= grad_range[0]];
145 
146  for (int i = grad_range[0]; i < grad_range[1]; i++)
147  b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));
148 
149  return 0;
150 }
151 
154 {
155  memset(c->precision_mask, 0, sizeof(c->precision_mask));
156  for (int i = 1; i < b->q_unit_cnt; i++) {
157  const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;
158  if (delta > 0) {
159  const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
160  c->precision_mask[i - neg] += FFMIN(delta, 5);
161  }
162  }
163 
164  if (b->grad_mode) {
165  for (int i = 0; i < b->q_unit_cnt; i++) {
166  c->precision_coarse[i] = c->scalefactors[i];
167  c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];
168  if (c->precision_coarse[i] < 0)
169  continue;
170  switch (b->grad_mode) {
171  case 1:
172  c->precision_coarse[i] >>= 1;
173  break;
174  case 2:
175  c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
176  break;
177  case 3:
178  c->precision_coarse[i] >>= 2;
179  break;
180  }
181  }
182  } else {
183  for (int i = 0; i < b->q_unit_cnt; i++)
184  c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
185  }
186 
187 
188  for (int i = 0; i < b->q_unit_cnt; i++)
189  c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
190 
191  for (int i = 0; i < b->grad_boundary; i++)
192  c->precision_coarse[i]++;
193 
194  for (int i = 0; i < b->q_unit_cnt; i++) {
195  c->precision_fine[i] = 0;
196  if (c->precision_coarse[i] > 15) {
197  c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;
198  c->precision_coarse[i] = 15;
199  }
200  }
201 }
202 
204  GetBitContext *gb, int stereo)
205 {
206  int ext_band = 0;
207 
208  if (b->has_band_ext) {
209  if (b->q_unit_cnt < 13 || b->q_unit_cnt > 20)
210  return AVERROR_INVALIDDATA;
211  ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];
212  if (stereo) {
213  b->channel[1].band_ext = get_bits(gb, 2);
214  b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;
215  } else {
216  skip_bits1(gb);
217  }
218  }
219 
220  b->has_band_ext_data = get_bits1(gb);
221  if (!b->has_band_ext_data)
222  return 0;
223 
224  if (!b->has_band_ext) {
225  skip_bits(gb, 2);
226  skip_bits_long(gb, get_bits(gb, 5));
227  return 0;
228  }
229 
230  b->channel[0].band_ext = get_bits(gb, 2);
231  b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;
232 
233  if (!get_bits(gb, 5)) {
234  for (int i = 0; i <= stereo; i++) {
235  ATRAC9ChannelData *c = &b->channel[i];
236  const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
237  for (int j = 0; j < count; j++) {
238  int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
239  c->band_ext_data[j] = av_clip_uintp2_c(c->band_ext_data[j], len);
240  }
241  }
242 
243  return 0;
244  }
245 
246  for (int i = 0; i <= stereo; i++) {
247  ATRAC9ChannelData *c = &b->channel[i];
248  const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
249  for (int j = 0; j < count; j++) {
250  int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
251  c->band_ext_data[j] = get_bits(gb, len);
252  }
253  }
254 
255  return 0;
256 }
257 
260  int channel_idx, int first_in_pkt)
261 {
262  static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };
263  const int mode = mode_map[channel_idx][get_bits(gb, 2)];
264 
265  memset(c->scalefactors, 0, sizeof(c->scalefactors));
266 
267  if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {
268  av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");
269  return AVERROR_INVALIDDATA;
270  }
271 
272  switch (mode) {
273  case 0: { /* VLC delta offset */
274  const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];
275  const int base = get_bits(gb, 5);
276  const int len = get_bits(gb, 2) + 3;
277  const VLC *tab = &sf_vlc[0][len];
278 
279  c->scalefactors[0] = get_bits(gb, len);
280 
281  for (int i = 1; i < b->band_ext_q_unit; i++) {
282  int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,
283  ATRAC9_SF_VLC_BITS, 1);
284  c->scalefactors[i] = val & ((1 << len) - 1);
285  }
286 
287  for (int i = 0; i < b->band_ext_q_unit; i++)
288  c->scalefactors[i] += base - sf_weights[i];
289 
290  break;
291  }
292  case 1: { /* CLC offset */
293  const int len = get_bits(gb, 2) + 2;
294  const int base = len < 5 ? get_bits(gb, 5) : 0;
295  for (int i = 0; i < b->band_ext_q_unit; i++)
296  c->scalefactors[i] = base + get_bits(gb, len);
297  break;
298  }
299  case 2:
300  case 4: { /* VLC dist to baseline */
301  const int *baseline = mode == 4 ? c->scalefactors_prev :
302  channel_idx ? b->channel[0].scalefactors :
303  c->scalefactors_prev;
304  const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :
305  channel_idx ? b->band_ext_q_unit :
306  b->q_unit_cnt_prev;
307 
308  const int len = get_bits(gb, 2) + 2;
309  const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
310  const VLC *tab = &sf_vlc[1][len];
311 
312  for (int i = 0; i < unit_cnt; i++) {
313  int dist = get_vlc2(gb, tab->table, ATRAC9_SF_VLC_BITS, 1);
314  c->scalefactors[i] = baseline[i] + dist;
315  }
316 
317  for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
318  c->scalefactors[i] = get_bits(gb, 5);
319 
320  break;
321  }
322  case 3: { /* VLC offset with baseline */
323  const int *baseline = channel_idx ? b->channel[0].scalefactors :
324  c->scalefactors_prev;
325  const int baseline_len = channel_idx ? b->band_ext_q_unit :
326  b->q_unit_cnt_prev;
327 
328  const int base = get_bits(gb, 5) - (1 << (5 - 1));
329  const int len = get_bits(gb, 2) + 1;
330  const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
331  const VLC *tab = &sf_vlc[0][len];
332 
333  c->scalefactors[0] = get_bits(gb, len);
334 
335  for (int i = 1; i < unit_cnt; i++) {
336  int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,
337  ATRAC9_SF_VLC_BITS, 1);
338  c->scalefactors[i] = val & ((1 << len) - 1);
339  }
340 
341  for (int i = 0; i < unit_cnt; i++)
342  c->scalefactors[i] += base + baseline[i];
343 
344  for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
345  c->scalefactors[i] = get_bits(gb, 5);
346  break;
347  }
348  }
349 
350  for (int i = 0; i < b->band_ext_q_unit; i++)
351  if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)
352  return AVERROR_INVALIDDATA;
353 
354  memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
355 
356  return 0;
357 }
358 
361 {
362  int avg = 0;
363  const int last_sf = c->scalefactors[c->q_unit_cnt];
364 
365  memset(c->codebookset, 0, sizeof(c->codebookset));
366 
367  if (c->q_unit_cnt <= 1)
368  return;
369  if (s->samplerate_idx > 7)
370  return;
371 
372  c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
373 
374  if (c->q_unit_cnt > 12) {
375  for (int i = 0; i < 12; i++)
376  avg += c->scalefactors[i];
377  avg = (avg + 6) / 12;
378  }
379 
380  for (int i = 8; i < c->q_unit_cnt; i++) {
381  const int prev = c->scalefactors[i - 1];
382  const int cur = c->scalefactors[i ];
383  const int next = c->scalefactors[i + 1];
384  const int min = FFMIN(prev, next);
385  if ((cur - min >= 3 || 2*cur - prev - next >= 3))
386  c->codebookset[i] = 1;
387  }
388 
389 
390  for (int i = 12; i < c->q_unit_cnt; i++) {
391  const int cur = c->scalefactors[i];
392  const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;
393  const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);
394  if (c->codebookset[i])
395  continue;
396 
397  c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
398  }
399 
400  c->scalefactors[c->q_unit_cnt] = last_sf;
401 }
402 
405 {
406  const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
407 
408  memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
409 
410  for (int i = 0; i < c->q_unit_cnt; i++) {
411  int *coeffs = &c->q_coeffs_coarse[at9_q_unit_to_coeff_idx[i]];
412  const int bands = at9_q_unit_to_coeff_cnt[i];
413  const int prec = c->precision_coarse[i] + 1;
414 
415  if (prec <= max_prec) {
416  const int cb = c->codebookset[i];
417  const int cbi = at9_q_unit_to_codebookidx[i];
418  const VLC *tab = &coeff_vlc[cb][prec][cbi];
419  const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];
420  const int groups = bands >> huff->value_cnt_pow;
421 
422  for (int j = 0; j < groups; j++) {
423  uint16_t val = get_vlc2(gb, tab->table, ATRAC9_COEFF_VLC_BITS, 2);
424 
425  for (int k = 0; k < huff->value_cnt; k++) {
426  coeffs[k] = sign_extend(val, huff->value_bits);
427  val >>= huff->value_bits;
428  }
429 
430  coeffs += huff->value_cnt;
431  }
432  } else {
433  for (int j = 0; j < bands; j++)
434  coeffs[j] = sign_extend(get_bits(gb, prec), prec);
435  }
436  }
437 }
438 
441 {
442  memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
443 
444  for (int i = 0; i < c->q_unit_cnt; i++) {
445  const int start = at9_q_unit_to_coeff_idx[i + 0];
446  const int end = at9_q_unit_to_coeff_idx[i + 1];
447  const int len = c->precision_fine[i] + 1;
448 
449  if (c->precision_fine[i] <= 0)
450  continue;
451 
452  for (int j = start; j < end; j++)
453  c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
454  }
455 }
456 
459 {
460  memset(c->coeffs, 0, sizeof(c->coeffs));
461 
462  for (int i = 0; i < c->q_unit_cnt; i++) {
463  const int start = at9_q_unit_to_coeff_idx[i + 0];
464  const int end = at9_q_unit_to_coeff_idx[i + 1];
465 
466  const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];
467  const float fine_c = at9_quant_step_fine[c->precision_fine[i]];
468 
469  for (int j = start; j < end; j++) {
470  const float vc = c->q_coeffs_coarse[j] * coarse_c;
471  const float vf = c->q_coeffs_fine[j] * fine_c;
472  c->coeffs[j] = vc + vf;
473  }
474  }
475 }
476 
478  const int stereo)
479 {
480  float *src = b->channel[ b->cpe_base_channel].coeffs;
481  float *dst = b->channel[!b->cpe_base_channel].coeffs;
482 
483  if (!stereo)
484  return;
485 
486  if (b->q_unit_cnt <= b->stereo_q_unit)
487  return;
488 
489  for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {
490  const int sign = b->is_signs[i];
491  const int start = at9_q_unit_to_coeff_idx[i + 0];
492  const int end = at9_q_unit_to_coeff_idx[i + 1];
493  for (int j = start; j < end; j++)
494  dst[j] = sign*src[j];
495  }
496 }
497 
499  const int stereo)
500 {
501  for (int i = 0; i <= stereo; i++) {
502  float *coeffs = b->channel[i].coeffs;
503  for (int j = 0; j < b->q_unit_cnt; j++) {
504  const int start = at9_q_unit_to_coeff_idx[j + 0];
505  const int end = at9_q_unit_to_coeff_idx[j + 1];
506  const int scalefactor = b->channel[i].scalefactors[j];
507  const float scale = at9_scalefactor_c[scalefactor];
508  for (int k = start; k < end; k++)
509  coeffs[k] *= scale;
510  }
511  }
512 }
513 
515  int start, int count)
516 {
517  float maxval = 0.0f;
518  for (int i = 0; i < count; i += 2) {
519  double tmp[2];
520  av_bmg_get(&s->lfg, tmp);
521  c->coeffs[start + i + 0] = tmp[0];
522  c->coeffs[start + i + 1] = tmp[1];
523  maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);
524  }
525  /* Normalize */
526  for (int i = 0; i < count; i++)
527  c->coeffs[start + i] /= maxval;
528 }
529 
530 static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
531  const int s_unit, const int e_unit)
532 {
533  for (int i = s_unit; i < e_unit; i++) {
534  const int start = at9_q_unit_to_coeff_idx[i + 0];
535  const int end = at9_q_unit_to_coeff_idx[i + 1];
536  for (int j = start; j < end; j++)
537  c->coeffs[j] *= sf[i - s_unit];
538  }
539 }
540 
542  const int stereo)
543 {
544  const int g_units[4] = { /* A, B, C, total units */
545  b->q_unit_cnt,
546  at9_tab_band_ext_group[b->q_unit_cnt - 13][0],
547  at9_tab_band_ext_group[b->q_unit_cnt - 13][1],
548  FFMAX(g_units[2], 22),
549  };
550 
551  const int g_bins[4] = { /* A, B, C, total bins */
552  at9_q_unit_to_coeff_idx[g_units[0]],
553  at9_q_unit_to_coeff_idx[g_units[1]],
554  at9_q_unit_to_coeff_idx[g_units[2]],
555  at9_q_unit_to_coeff_idx[g_units[3]],
556  };
557 
558  for (int ch = 0; ch <= stereo; ch++) {
559  ATRAC9ChannelData *c = &b->channel[ch];
560 
561  /* Mirror the spectrum */
562  for (int i = 0; i < 3; i++)
563  for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)
564  c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];
565 
566  switch (c->band_ext) {
567  case 0: {
568  float sf[6] = { 0.0f };
569  const int l = g_units[3] - g_units[0] - 1;
570  const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];
571  const int n_cnt = at9_q_unit_to_coeff_cnt[g_units[3] - 1];
572  switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {
573  case 3:
574  sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];
575  sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];
576  sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];
577  sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];
578  sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];
579  break;
580  case 4:
581  sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];
582  sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];
583  sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];
584  sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];
585  sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];
586  break;
587  case 5:
588  sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];
589  sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];
590  sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];
591  break;
592  }
593 
594  sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
595 
596  fill_with_noise(s, c, n_start, n_cnt);
597  scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
598  break;
599  }
600  case 1: {
601  float sf[6];
602  for (int i = g_units[0]; i < g_units[3]; i++)
603  sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
604 
605  fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);
606  scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
607  break;
608  }
609  case 2: {
610  const float g_sf[2] = {
611  at9_band_ext_scales_m2[c->band_ext_data[0]],
612  at9_band_ext_scales_m2[c->band_ext_data[1]],
613  };
614 
615  for (int i = 0; i < 2; i++)
616  for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
617  c->coeffs[j] *= g_sf[i];
618  break;
619  }
620  case 3: {
621  float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];
622  float rate = at9_band_ext_scales_m3[c->band_ext_data[1]][1];
623  rate = pow(2, rate);
624  for (int i = g_bins[0]; i < g_bins[3]; i++) {
625  scale *= rate;
626  c->coeffs[i] *= scale;
627  }
628  break;
629  }
630  case 4: {
631  const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];
632  const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };
633 
634  for (int i = 0; i < 3; i++)
635  for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
636  c->coeffs[j] *= g_sf[i];
637  break;
638  }
639  }
640  }
641 }
642 
645  int frame_idx, int block_idx)
646 {
647  const int first_in_pkt = !get_bits1(gb);
648  const int reuse_params = get_bits1(gb);
649  const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;
650 
651  if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {
652  ATRAC9ChannelData *c = &b->channel[0];
653  const int precision = reuse_params ? 8 : 4;
654  c->q_unit_cnt = b->q_unit_cnt = 2;
655 
656  memset(c->scalefactors, 0, sizeof(c->scalefactors));
657  memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
658  memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
659 
660  for (int i = 0; i < b->q_unit_cnt; i++) {
661  c->scalefactors[i] = get_bits(gb, 5);
662  c->precision_coarse[i] = precision;
663  c->precision_fine[i] = 0;
664  }
665 
666  for (int i = 0; i < c->q_unit_cnt; i++) {
667  const int start = at9_q_unit_to_coeff_idx[i + 0];
668  const int end = at9_q_unit_to_coeff_idx[i + 1];
669  for (int j = start; j < end; j++)
670  c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);
671  }
672 
673  dequantize (s, b, c);
674  apply_scalefactors(s, b, 0);
675 
676  goto imdct;
677  }
678 
679  if (first_in_pkt && reuse_params) {
680  av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
681  return AVERROR_INVALIDDATA;
682  }
683 
684  /* Band parameters */
685  if (!reuse_params) {
686  int stereo_band, ext_band;
687  const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
688  b->reuseable = 0;
689  b->band_count = get_bits(gb, 4) + min_band_count;
690  b->q_unit_cnt = at9_tab_band_q_unit_map[b->band_count];
691 
692  b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;
693 
694  if (b->band_count > at9_tab_sri_max_bands[s->samplerate_idx]) {
695  av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",
696  b->band_count);
697  return AVERROR_INVALIDDATA;
698  }
699 
700  if (stereo) {
701  stereo_band = get_bits(gb, 4) + min_band_count;
702  if (stereo_band > b->band_count) {
703  av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",
704  stereo_band);
705  return AVERROR_INVALIDDATA;
706  }
707  b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
708  }
709 
710  b->has_band_ext = get_bits1(gb);
711  if (b->has_band_ext) {
712  ext_band = get_bits(gb, 4) + min_band_count;
713  if (ext_band < b->band_count) {
714  av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",
715  ext_band);
716  return AVERROR_INVALIDDATA;
717  }
718  b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];
719  }
720  b->reuseable = 1;
721  }
722  if (!b->reuseable) {
723  av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
724  return AVERROR_INVALIDDATA;
725  }
726 
727  /* Calculate bit alloc gradient */
728  if (parse_gradient(s, b, gb))
729  return AVERROR_INVALIDDATA;
730 
731  /* IS data */
732  b->cpe_base_channel = 0;
733  if (stereo) {
734  b->cpe_base_channel = get_bits1(gb);
735  if (get_bits1(gb)) {
736  for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)
737  b->is_signs[i] = 1 - 2*get_bits1(gb);
738  } else {
739  for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
740  b->is_signs[i] = 1;
741  }
742  }
743 
744  /* Band extension */
745  if (parse_band_ext(s, b, gb, stereo))
746  return AVERROR_INVALIDDATA;
747 
748  /* Scalefactors */
749  for (int i = 0; i <= stereo; i++) {
750  ATRAC9ChannelData *c = &b->channel[i];
751  c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :
752  b->stereo_q_unit;
753  if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
754  return AVERROR_INVALIDDATA;
755 
756  calc_precision (s, b, c);
757  calc_codebook_idx (s, b, c);
758  read_coeffs_coarse(s, b, c, gb);
759  read_coeffs_fine (s, b, c, gb);
760  dequantize (s, b, c);
761  }
762 
763  b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;
764 
765  apply_intensity_stereo(s, b, stereo);
766  apply_scalefactors (s, b, stereo);
767 
768  if (b->has_band_ext && b->has_band_ext_data)
769  apply_band_extension (s, b, stereo);
770 
771 imdct:
772  for (int i = 0; i <= stereo; i++) {
773  ATRAC9ChannelData *c = &b->channel[i];
774  const int dst_idx = s->block_config->plane_map[block_idx][i];
775  const int wsize = 1 << s->frame_log2;
776  const ptrdiff_t offset = wsize*frame_idx*sizeof(float);
777  float *dst = (float *)(frame->extended_data[dst_idx] + offset);
778 
779  s->imdct.imdct_half(&s->imdct, s->temp, c->coeffs);
780  s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,
781  s->imdct_win, wsize >> 1);
782  memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);
783  }
784 
785  return 0;
786 }
787 
788 static int atrac9_decode_frame(AVCodecContext *avctx, void *data,
789  int *got_frame_ptr, AVPacket *avpkt)
790 {
791  int ret;
792  GetBitContext gb;
793  AVFrame *frame = data;
794  ATRAC9Context *s = avctx->priv_data;
795  const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
796 
797  frame->nb_samples = (1 << s->frame_log2) * frames;
798  ret = ff_get_buffer(avctx, frame, 0);
799  if (ret < 0)
800  return ret;
801 
802  init_get_bits8(&gb, avpkt->data, avpkt->size);
803 
804  for (int i = 0; i < frames; i++) {
805  for (int j = 0; j < s->block_config->count; j++) {
806  ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);
807  if (ret)
808  return ret;
809  align_get_bits(&gb);
810  }
811  }
812 
813  *got_frame_ptr = 1;
814 
815  return avctx->block_align;
816 }
817 
819 {
820  ATRAC9Context *s = avctx->priv_data;
821 
822  for (int j = 0; j < s->block_config->count; j++) {
823  ATRAC9BlockData *b = &s->block[j];
824  const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;
825  for (int i = 0; i <= stereo; i++) {
826  ATRAC9ChannelData *c = &b->channel[i];
827  memset(c->prev_win, 0, sizeof(c->prev_win));
828  }
829  }
830 }
831 
833 {
834  ATRAC9Context *s = avctx->priv_data;
835 
836  ff_mdct_end(&s->imdct);
837  av_freep(&s->fdsp);
838 
839  return 0;
840 }
841 
842 static av_cold void atrac9_init_vlc(VLC *vlc, int nb_bits, int nb_codes,
843  const uint8_t (**tab)[2],
844  unsigned *buf_offset, int offset)
845 {
846  static VLC_TYPE vlc_buf[24812][2];
847 
848  vlc->table = &vlc_buf[*buf_offset];
849  vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *buf_offset;
850  ff_init_vlc_from_lengths(vlc, nb_bits, nb_codes,
851  &(*tab)[0][1], 2, &(*tab)[0][0], 2, 1,
853  *buf_offset += vlc->table_size;
854  *tab += nb_codes;
855 }
856 
857 static av_cold void atrac9_init_static(void)
858 {
859  const uint8_t (*tab)[2];
860  unsigned offset = 0;
861 
862  /* Unsigned scalefactor VLCs */
863  tab = at9_sfb_a_tab;
864  for (int i = 1; i < 7; i++) {
866 
868  hf->size, &tab, &offset, 0);
869  }
870 
871  /* Signed scalefactor VLCs */
872  tab = at9_sfb_b_tab;
873  for (int i = 2; i < 6; i++) {
875 
876  /* The symbols are signed integers in the range -16..15;
877  * the values in the source table are offset by 16 to make
878  * them fit into an uint8_t; the -16 reverses this shift. */
880  hf->size, &tab, &offset, -16);
881  }
882 
883  /* Coefficient VLCs */
885  for (int i = 0; i < 2; i++) {
886  for (int j = 2; j < 8; j++) {
887  for (int k = i; k < 4; k++) {
888  const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];
890  hf->size, &tab, &offset, 0);
891  }
892  }
893  }
894 }
895 
897 {
898  static AVOnce static_table_init = AV_ONCE_INIT;
899  GetBitContext gb;
900  ATRAC9Context *s = avctx->priv_data;
901  int version, block_config_idx, superframe_idx, alloc_c_len;
902 
903  s->avctx = avctx;
904 
905  av_lfg_init(&s->lfg, 0xFBADF00D);
906 
907  if (avctx->block_align <= 0) {
908  av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
909  return AVERROR_INVALIDDATA;
910  }
911 
912  if (avctx->extradata_size != 12) {
913  av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
914  return AVERROR_INVALIDDATA;
915  }
916 
917  version = AV_RL32(avctx->extradata);
918  if (version > 2) {
919  av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
920  return AVERROR_INVALIDDATA;
921  }
922 
923  init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
924 
925  if (get_bits(&gb, 8) != 0xFE) {
926  av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
927  return AVERROR_INVALIDDATA;
928  }
929 
930  s->samplerate_idx = get_bits(&gb, 4);
931  avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];
932 
933  block_config_idx = get_bits(&gb, 3);
934  if (block_config_idx > 5) {
935  av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");
936  return AVERROR_INVALIDDATA;
937  }
938  s->block_config = &at9_block_layout[block_config_idx];
939 
940  avctx->channel_layout = s->block_config->channel_layout;
943 
944  if (get_bits1(&gb)) {
945  av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
946  return AVERROR_INVALIDDATA;
947  }
948 
949  /* Average frame size in bytes */
950  s->avg_frame_size = get_bits(&gb, 11) + 1;
951 
952  superframe_idx = get_bits(&gb, 2);
953  if (superframe_idx & 1) {
954  av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");
955  return AVERROR_INVALIDDATA;
956  }
957 
958  s->frame_count = 1 << superframe_idx;
959  s->frame_log2 = at9_tab_sri_frame_log2[s->samplerate_idx];
960 
961  if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))
962  return AVERROR(ENOMEM);
963 
965  if (!s->fdsp)
966  return AVERROR(ENOMEM);
967 
968  /* iMDCT window */
969  for (int i = 0; i < (1 << s->frame_log2); i++) {
970  const int len = 1 << s->frame_log2;
971  const float sidx = ( i + 0.5f) / len;
972  const float eidx = (len - i - 0.5f) / len;
973  const float s_c = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;
974  const float e_c = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;
975  s->imdct_win[i] = s_c / ((s_c * s_c) + (e_c * e_c));
976  }
977 
978  /* Allocation curve */
979  alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);
980  for (int i = 1; i <= alloc_c_len; i++)
981  for (int j = 0; j < i; j++)
982  s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];
983 
984  ff_thread_once(&static_table_init, atrac9_init_static);
985 
986  return 0;
987 }
988 
990  .name = "atrac9",
991  .long_name = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
992  .type = AVMEDIA_TYPE_AUDIO,
993  .id = AV_CODEC_ID_ATRAC9,
994  .priv_data_size = sizeof(ATRAC9Context),
996  .close = atrac9_decode_close,
1001 };
static void flush(AVCodecContext *avctx)
static double val(void *priv, double ch)
Definition: aeval.c:76
static const float bands[]
static void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6], const int s_unit, const int e_unit)
Definition: atrac9dec.c:530
static int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb, int stereo)
Definition: atrac9dec.c:203
AVCodec ff_atrac9_decoder
Definition: atrac9dec.c:989
static av_cold int atrac9_decode_close(AVCodecContext *avctx)
Definition: atrac9dec.c:832
static VLC sf_vlc[2][8]
Definition: atrac9dec.c:105
static void atrac9_decode_flush(AVCodecContext *avctx)
Definition: atrac9dec.c:818
static void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:541
static void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:403
static av_cold void atrac9_init_static(void)
Definition: atrac9dec.c:857
static void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:152
static av_cold void atrac9_init_vlc(VLC *vlc, int nb_bits, int nb_codes, const uint8_t(**tab)[2], unsigned *buf_offset, int offset)
Definition: atrac9dec.c:842
#define ATRAC9_SF_VLC_BITS
Definition: atrac9dec.c:32
static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb, ATRAC9BlockData *b, AVFrame *frame, int frame_idx, int block_idx)
Definition: atrac9dec.c:643
static void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:477
static void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:359
static VLC coeff_vlc[2][8][4]
Definition: atrac9dec.c:106
static int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb)
Definition: atrac9dec.c:108
static void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:439
static void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c, int start, int count)
Definition: atrac9dec.c:514
static av_cold int atrac9_decode_init(AVCodecContext *avctx)
Definition: atrac9dec.c:896
static int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb, int channel_idx, int first_in_pkt)
Definition: atrac9dec.c:258
static int atrac9_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac9dec.c:788
static void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:498
#define ATRAC9_COEFF_VLC_BITS
Definition: atrac9dec.c:33
static void dequantize(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:457
static const ATRAC9BlockConfig at9_block_layout[]
Definition: atrac9tab.h:42
static const uint8_t at9_tab_band_ext_group[][3]
Definition: atrac9tab.h:130
@ ATRAC9_BLOCK_TYPE_LFE
Definition: atrac9tab.h:32
@ ATRAC9_BLOCK_TYPE_CPE
Definition: atrac9tab.h:31
static const HuffmanCodebook at9_huffman_coeffs[][8][4]
Definition: atrac9tab.h:1293
static const uint8_t at9_tab_sri_max_bands[]
Definition: atrac9tab.h:112
static const float at9_scalefactor_c[]
Definition: atrac9tab.h:324
static const uint8_t at9_tab_sf_weights[][32]
Definition: atrac9tab.h:335
static const uint8_t at9_tab_b_dist[]
Definition: atrac9tab.h:370
static const int at9_q_unit_to_coeff_idx[]
Definition: atrac9tab.h:102
static const uint8_t at9_tab_band_ext_lengths[][6][4]
Definition: atrac9tab.h:141
static const uint8_t at9_tab_band_ext_cnt[][6]
Definition: atrac9tab.h:121
static const uint8_t at9_tab_band_q_unit_map[]
Definition: atrac9tab.h:93
static const uint8_t at9_tab_sri_frame_log2[]
Definition: atrac9tab.h:89
static const int at9_tab_samplerates[]
Definition: atrac9tab.h:116
static const uint8_t at9_q_unit_to_coeff_cnt[]
Definition: atrac9tab.h:97
static const HuffmanCodebook at9_huffman_sf_signed[]
Definition: atrac9tab.h:441
static const float at9_band_ext_scales_m4[]
Definition: atrac9tab.h:301
static const uint8_t at9_q_unit_to_codebookidx[]
Definition: atrac9tab.h:107
static const float at9_band_ext_scales_m3[][2]
Definition: atrac9tab.h:290
static const float at9_band_ext_scales_m0[][5][32]
Definition: atrac9tab.h:184
static const uint8_t at9_sfb_b_tab[][2]
Definition: atrac9tab.h:407
static const HuffmanCodebook at9_huffman_sf_unsigned[]
Definition: atrac9tab.h:431
static const float at9_quant_step_coarse[]
Definition: atrac9tab.h:306
static const uint8_t at9_sfb_a_tab[][2]
Definition: atrac9tab.h:376
static const uint8_t at9_coeffs_tab[][2]
Definition: atrac9tab.h:450
static const float at9_band_ext_scales_m2[]
Definition: atrac9tab.h:271
static const float at9_quant_step_fine[]
Definition: atrac9tab.h:315
#define av_cold
Definition: attributes.h:88
uint8_t
int32_t
#define AV_RL32
Definition: intreadwrite.h:146
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
int ff_init_vlc_from_lengths(VLC *vlc_arg, 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, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:381
#define s(width, name)
Definition: cbs_vp9.c:257
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
#define avg(a, b, c, d)
#define FFMIN(a, b)
Definition: common.h:105
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:302
#define FFMAX(a, b)
Definition: common.h:103
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define NULL
Definition: coverity.c:32
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
#define ff_mdct_init
Definition: fft.h:161
#define ff_mdct_end
Definition: fft.h:162
bitstream reader API header.
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:797
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:95
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
@ AV_CODEC_ID_ATRAC9
Definition: codec_id.h:513
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
for(j=16;j >0;--j)
int i
Definition: input.c:407
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
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
version
Definition: libkvazaar.c:326
#define sinf(x)
Definition: libm.h:419
#define M_PI_2
Definition: mathematics.h:55
#define M_PI
Definition: mathematics.h:52
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
const char data[16]
Definition: mxf.c:142
#define FF_ARRAY_ELEMS(a)
int has_band_ext_data
Definition: atrac9dec.c:68
int q_unit_cnt_prev
Definition: atrac9dec.c:61
int cpe_base_channel
Definition: atrac9dec.c:77
int band_ext_q_unit
Definition: atrac9dec.c:69
int gradient[31]
Definition: atrac9dec.c:74
int is_signs[30]
Definition: atrac9dec.c:78
int32_t scalefactors[31]
Definition: atrac9dec.c:39
int32_t q_coeffs_coarse[256]
Definition: atrac9dec.c:48
int band_ext_data[4]
Definition: atrac9dec.c:38
int precision_coarse[30]
Definition: atrac9dec.c:42
float prev_win[128]
Definition: atrac9dec.c:52
int32_t q_coeffs_fine[256]
Definition: atrac9dec.c:49
float coeffs[256]
Definition: atrac9dec.c:51
int precision_mask[30]
Definition: atrac9dec.c:44
int32_t scalefactors_prev[31]
Definition: atrac9dec.c:40
int codebookset[30]
Definition: atrac9dec.c:46
int precision_fine[30]
Definition: atrac9dec.c:43
ATRAC9BlockData block[5]
Definition: atrac9dec.c:88
int samplerate_idx
Definition: atrac9dec.c:95
int avg_frame_size
Definition: atrac9dec.c:93
uint8_t alloc_curve[48][48]
Definition: atrac9dec.c:99
int frame_count
Definition: atrac9dec.c:94
AVFloatDSPContext * fdsp
Definition: atrac9dec.c:86
const ATRAC9BlockConfig * block_config
Definition: atrac9dec.c:96
FFTContext imdct
Definition: atrac9dec.c:87
AVCodecContext * avctx
Definition: atrac9dec.c:85
float temp[256]
Definition: atrac9dec.c:102
int frame_log2
Definition: atrac9dec.c:92
float imdct_win[256]
Definition: atrac9dec.c:100
main external API structure.
Definition: avcodec.h:536
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
int sample_rate
samples per second
Definition: avcodec.h:1196
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
int channels
number of audio channels
Definition: avcodec.h:1197
int extradata_size
Definition: avcodec.h:638
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1233
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
Definition: fft.h:83
const int value_cnt_pow
Definition: atrac9tab.h:427
const int size
Definition: atrac9tab.h:425
const int value_cnt
Definition: atrac9tab.h:426
const int value_bits
Definition: atrac9tab.h:428
Definition: vlc.h:26
int table_size
Definition: vlc.h:29
int table_allocated
Definition: vlc.h:29
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
#define src
Definition: vp8dsp.c:255
int frames
Definition: movenc.c:66
static const struct twinvq_data tab
const char * b
Definition: vf_curves.c:118
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
#define VLC_TYPE
Definition: vlc.h:24
float delta
float min
int len
uint8_t base
Definition: vp3data.h:141
static double c[64]