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/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 */
99  uint8_t alloc_curve[48][48];
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 :
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 :
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++) {
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,
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] = {
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;
691 
693 
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  }
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 
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,
852  offset, INIT_VLC_STATIC_OVERLONG, NULL);
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 
867  atrac9_init_vlc(&sf_vlc[0][i], ATRAC9_SF_VLC_BITS,
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. */
879  atrac9_init_vlc(&sf_vlc[1][i], ATRAC9_SF_VLC_BITS,
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];
889  atrac9_init_vlc(&coeff_vlc[i][j][k], ATRAC9_COEFF_VLC_BITS,
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);
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 
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;
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 };
#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:48
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
static const uint8_t at9_tab_sri_max_bands[]
Definition: atrac9tab.h:112
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
int table_size
Definition: vlc.h:29
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
version
Definition: libkvazaar.c:320
AVCodec ff_atrac9_decoder
Definition: atrac9dec.c:989
int precision_mask[30]
Definition: atrac9dec.c:44
static const uint8_t at9_coeffs_tab[][2]
Definition: atrac9tab.h:450
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
int precision_coarse[30]
Definition: atrac9dec.c:42
static void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:541
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static void dequantize(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:457
else temp
Definition: vf_mcdeint.c:256
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
int band_ext_data[4]
Definition: atrac9dec.c:38
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define ATRAC9_SF_VLC_BITS
Definition: atrac9dec.c:32
int size
Definition: packet.h:364
static const uint8_t at9_sfb_a_tab[][2]
Definition: atrac9tab.h:376
int q_unit_cnt_prev
Definition: atrac9dec.c:61
float prev_win[128]
Definition: atrac9dec.c:52
static const uint8_t at9_sfb_b_tab[][2]
Definition: atrac9tab.h:407
static void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:403
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:102
#define FF_ARRAY_ELEMS(a)
static av_cold void atrac9_init_static(void)
Definition: atrac9dec.c:857
float coeffs[256]
Definition: atrac9dec.c:51
AVCodec.
Definition: codec.h:190
if it could not because there are no more frames
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1228
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int is_signs[30]
Definition: atrac9dec.c:78
AVCodecContext * avctx
Definition: atrac9dec.c:85
uint8_t base
Definition: vp3data.h:141
static const float at9_band_ext_scales_m4[]
Definition: atrac9tab.h:301
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
uint64_t channel_layout
Definition: atrac9tab.h:36
static const HuffmanCodebook at9_huffman_coeffs[][8][4]
Definition: atrac9tab.h:1293
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
static const int at9_tab_samplerates[]
Definition: atrac9tab.h:116
#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:40
ATRAC9ChannelData channel[2]
Definition: atrac9dec.c:56
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
float delta
int avg_frame_size
Definition: atrac9dec.c:93
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3309
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
#define f(width, name)
Definition: cbs_vp9.c:255
float imdct_win[256]
Definition: atrac9dec.c:100
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
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:363
bitstream reader API header.
static void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c, int start, int count)
Definition: atrac9dec.c:514
int frame_count
Definition: atrac9dec.c:94
static int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb, int channel_idx, int first_in_pkt)
Definition: atrac9dec.c:258
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
static void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:498
static const uint8_t at9_tab_sf_weights[][32]
Definition: atrac9tab.h:335
#define AVOnce
Definition: thread.h:172
int32_t q_coeffs_coarse[256]
Definition: atrac9dec.c:48
#define av_log(a,...)
static void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:152
static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb, ATRAC9BlockData *b, AVFrame *frame, int frame_idx, int block_idx)
Definition: atrac9dec.c:643
static const float at9_quant_step_fine[]
Definition: atrac9tab.h:315
#define src
Definition: vp8dsp.c:255
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:439
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
static const uint8_t at9_tab_band_q_unit_map[]
Definition: atrac9tab.h:93
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
static const uint8_t at9_q_unit_to_codebookidx[]
Definition: atrac9tab.h:107
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
static int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb, int stereo)
Definition: atrac9dec.c:203
const char * name
Name of the codec implementation.
Definition: codec.h:197
const int size
Definition: atrac9tab.h:425
static void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:359
#define ff_mdct_init
Definition: fft.h:161
int has_band_ext_data
Definition: atrac9dec.c:68
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:103
FFTContext imdct
Definition: atrac9dec.c:87
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
enum ATRAC9BlockType type[5]
Definition: atrac9tab.h:37
int frame_log2
Definition: atrac9dec.c:92
#define b
Definition: input.c:41
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
Definition: fft.h:83
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define FFMIN(a, b)
Definition: common.h:105
int32_t scalefactors_prev[31]
Definition: atrac9dec.c:40
int band_ext_q_unit
Definition: atrac9dec.c:69
static VLC coeff_vlc[2][8][4]
Definition: atrac9dec.c:106
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
#define M_PI_2
Definition: mathematics.h:55
int32_t
static const float at9_band_ext_scales_m0[][5][32]
Definition: atrac9tab.h:184
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
ATRAC9BlockData block[5]
Definition: atrac9dec.c:88
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
static const float at9_scalefactor_c[]
Definition: atrac9tab.h:324
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
int table_allocated
Definition: vlc.h:29
static int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb)
Definition: atrac9dec.c:108
static av_cold int atrac9_decode_init(AVCodecContext *avctx)
Definition: atrac9dec.c:896
#define sinf(x)
Definition: libm.h:419
#define AV_ONCE_INIT
Definition: thread.h:173
const int value_bits
Definition: atrac9tab.h:428
int sample_rate
samples per second
Definition: avcodec.h:1191
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int cpe_base_channel
Definition: atrac9dec.c:77
main external API structure.
Definition: avcodec.h:531
const int value_cnt_pow
Definition: atrac9tab.h:427
static const float bands[]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1884
int extradata_size
Definition: avcodec.h:633
static void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:477
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static const uint8_t at9_q_unit_to_coeff_cnt[]
Definition: atrac9tab.h:97
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
int precision_fine[30]
Definition: atrac9dec.c:43
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: codec.h:93
uint8_t alloc_curve[48][48]
Definition: atrac9dec.c:99
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
int samplerate_idx
Definition: atrac9dec.c:95
static av_cold int atrac9_decode_close(AVCodecContext *avctx)
Definition: atrac9dec.c:832
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
static const uint8_t at9_tab_band_ext_group[][3]
Definition: atrac9tab.h:130
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:103
static const uint8_t at9_tab_band_ext_cnt[][6]
Definition: atrac9tab.h:121
#define ATRAC9_COEFF_VLC_BITS
Definition: atrac9dec.c:33
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
static const float at9_band_ext_scales_m2[]
Definition: atrac9tab.h:271
static void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6], const int s_unit, const int e_unit)
Definition: atrac9dec.c:530
AVFloatDSPContext * fdsp
Definition: atrac9dec.c:86
static const float at9_quant_step_coarse[]
Definition: atrac9tab.h:306
#define avg(a, b, c, d)
static int atrac9_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac9dec.c:788
static const HuffmanCodebook at9_huffman_sf_unsigned[]
Definition: atrac9tab.h:431
static VLC sf_vlc[2][8]
Definition: atrac9dec.c:105
common internal api header.
const ATRAC9BlockConfig * block_config
Definition: atrac9dec.c:96
#define ff_mdct_end
Definition: fft.h:162
const int value_cnt
Definition: atrac9tab.h:426
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
static const uint8_t at9_tab_sri_frame_log2[]
Definition: atrac9tab.h:89
int codebookset[30]
Definition: atrac9dec.c:46
int plane_map[5][2]
Definition: atrac9tab.h:38
static const float at9_band_ext_scales_m3[][2]
Definition: atrac9tab.h:290
void * priv_data
Definition: avcodec.h:558
static const HuffmanCodebook at9_huffman_sf_signed[]
Definition: atrac9tab.h:441
int gradient[31]
Definition: atrac9dec.c:74
int len
int channels
number of audio channels
Definition: avcodec.h:1192
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
static const struct twinvq_data tab
int32_t scalefactors[31]
Definition: atrac9dec.c:39
static const ATRAC9BlockConfig at9_block_layout[]
Definition: atrac9tab.h:42
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
static const uint8_t at9_tab_b_dist[]
Definition: atrac9tab.h:370
static void atrac9_decode_flush(AVCodecContext *avctx)
Definition: atrac9dec.c:818
#define av_freep(p)
#define M_PI
Definition: mathematics.h:52
#define VLC_TYPE
Definition: vlc.h:24
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:361
float min
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
static const int at9_q_unit_to_coeff_idx[]
Definition: atrac9tab.h:102
int32_t q_coeffs_fine[256]
Definition: atrac9dec.c:49
for(j=16;j >0;--j)
int i
Definition: input.c:407
static const uint8_t at9_tab_band_ext_lengths[][6][4]
Definition: atrac9tab.h:141
float temp[256]
Definition: atrac9dec.c:102
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
static uint8_t tmp[11]
Definition: aes_ctr.c:27