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 :
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 };
atrac9_decode_close
static av_cold int atrac9_decode_close(AVCodecContext *avctx)
Definition: atrac9dec.c:832
ATRAC9ChannelData::q_coeffs_coarse
int32_t q_coeffs_coarse[256]
Definition: atrac9dec.c:48
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
FF_CODEC_CAP_INIT_THREADSAFE
#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
coeff_vlc
static VLC coeff_vlc[2][8][4]
Definition: atrac9dec.c:106
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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:51
ATRAC9BlockData::is_signs
int is_signs[30]
Definition: atrac9dec.c:78
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1149
mem_internal.h
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1098
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
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:258
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
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:302
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
M_PI_2
#define M_PI_2
Definition: mathematics.h:55
ATRAC9BlockData::has_band_ext
int has_band_ext
Definition: atrac9dec.c:67
calc_codebook_idx
static void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:359
b
#define b
Definition: input.c:41
ATRAC9ChannelData
Definition: atrac9dec.c:35
data
const char data[16]
Definition: mxf.c:142
ATRAC9_COEFF_VLC_BITS
#define ATRAC9_COEFF_VLC_BITS
Definition: atrac9dec.c:33
at9_block_layout
static const ATRAC9BlockConfig at9_block_layout[]
Definition: atrac9tab.h:42
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
get_vlc2
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
base
uint8_t base
Definition: vp3data.h:141
ATRAC9ChannelData::precision_fine
int precision_fine[30]
Definition: atrac9dec.c:43
HuffmanCodebook::value_cnt
const int value_cnt
Definition: atrac9tab.h:426
ATRAC9Context::frame_count
int frame_count
Definition: atrac9dec.c:94
ATRAC9Context::avctx
AVCodecContext * avctx
Definition: atrac9dec.c:85
ATRAC9Context::lfg
AVLFG lfg
Definition: atrac9dec.c:89
ATRAC9ChannelData::precision_mask
int precision_mask[30]
Definition: atrac9dec.c:44
read_coeffs_fine
static void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:439
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
ATRAC9Context
Definition: atrac9dec.c:84
ATRAC9Context::imdct
FFTContext imdct
Definition: atrac9dec.c:87
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
at9_tab_band_ext_cnt
static const uint8_t at9_tab_band_ext_cnt[][6]
Definition: atrac9tab.h:121
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
calc_precision
static void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:152
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
GetBitContext
Definition: get_bits.h:61
ATRAC9Context::block
ATRAC9BlockData block[5]
Definition: atrac9dec.c:88
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
ATRAC9BlockData::grad_mode
int grad_mode
Definition: atrac9dec.c:72
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:581
val
static double val(void *priv, double ch)
Definition: aeval.c:76
ATRAC9Context::alloc_curve
uint8_t alloc_curve[48][48]
Definition: atrac9dec.c:99
HuffmanCodebook::value_cnt_pow
const int value_cnt_pow
Definition: atrac9tab.h:427
ff_init_vlc_from_lengths
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:370
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:530
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
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:181
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:203
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
at9_tab_sri_max_bands
static const uint8_t at9_tab_sri_max_bands[]
Definition: atrac9tab.h:112
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:603
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:514
ATRAC9BlockConfig
Definition: atrac9tab.h:35
AV_CODEC_ID_ATRAC9
@ AV_CODEC_ID_ATRAC9
Definition: codec_id.h:508
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
ff_atrac9_decoder
const AVCodec ff_atrac9_decoder
Definition: atrac9dec.c:989
ATRAC9Context::avg_frame_size
int avg_frame_size
Definition: atrac9dec.c:93
get_bits.h
ATRAC9BlockData::band_ext_q_unit
int band_ext_q_unit
Definition: atrac9dec.c:69
bands
static const float bands[]
Definition: af_superequalizer.c:56
at9_band_ext_scales_m0
static const float at9_band_ext_scales_m0[][5][32]
Definition: atrac9tab.h:184
f
#define f(width, name)
Definition: cbs_vp9.c:255
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:72
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
ATRAC9_SF_VLC_BITS
#define ATRAC9_SF_VLC_BITS
Definition: atrac9dec.c:32
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
NULL
#define NULL
Definition: coverity.c:32
HuffmanCodebook
Definition: atrac9tab.h:424
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:498
src
#define src
Definition: vp8dsp.c:255
ATRAC9Context::frame_log2
int frame_log2
Definition: atrac9dec.c:92
atrac9_decode_init
static av_cold int atrac9_decode_init(AVCodecContext *avctx)
Definition: atrac9dec.c:896
ATRAC9ChannelData::q_coeffs_fine
int32_t q_coeffs_fine[256]
Definition: atrac9dec.c:49
parse_gradient
static int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb)
Definition: atrac9dec.c:108
ATRAC9BlockData::q_unit_cnt_prev
int q_unit_cnt_prev
Definition: atrac9dec.c:61
sinf
#define sinf(x)
Definition: libm.h:419
AVOnce
#define AVOnce
Definition: thread.h:172
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:74
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
float_dsp.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
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:104
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1638
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:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
apply_band_extension
static void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:541
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
ATRAC9ChannelData::band_ext
int band_ext
Definition: atrac9dec.c:36
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1106
ATRAC9Context::fdsp
AVFloatDSPContext * fdsp
Definition: atrac9dec.c:86
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:162
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:24
ATRAC9ChannelData::band_ext_data
int band_ext_data[4]
Definition: atrac9dec.c:38
dequantize
static void dequantize(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:457
ATRAC9BlockData::grad_boundary
int grad_boundary
Definition: atrac9dec.c:73
at9_tab_band_q_unit_map
static const uint8_t at9_tab_band_q_unit_map[]
Definition: atrac9tab.h:93
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
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:538
version
version
Definition: libkvazaar.c:306
atrac9_decode_frame
static int atrac9_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac9dec.c:788
ATRAC9ChannelData::scalefactors
int32_t scalefactors[31]
Definition: atrac9dec.c:39
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:52
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1099
at9_quant_step_coarse
static const float at9_quant_step_coarse[]
Definition: atrac9tab.h:306
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:117
ATRAC9BlockData::stereo_q_unit
int stereo_q_unit
Definition: atrac9dec.c:64
ATRAC9ChannelData::scalefactors_prev
int32_t scalefactors_prev[31]
Definition: atrac9dec.c:40
ATRAC9BlockData::cpe_base_channel
int cpe_base_channel
Definition: atrac9dec.c:77
ATRAC9Context::block_config
const ATRAC9BlockConfig * block_config
Definition: atrac9dec.c:96
FFTContext
Definition: fft.h:83
i
int i
Definition: input.c:407
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:100
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:602
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: internal.h:49
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:643
ATRAC9Context::temp
float temp[256]
Definition: atrac9dec.c:102
delta
float delta
Definition: vorbis_enc_data.h:457
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
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:204
len
int len
Definition: vorbis_enc_data.h:452
atrac9_init_vlc
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
ATRAC9BlockData::reuseable
int reuseable
Definition: atrac9dec.c:80
ATRAC9ChannelData::precision_coarse
int precision_coarse[30]
Definition: atrac9dec.c:42
ATRAC9ChannelData::codebookset
int codebookset[30]
Definition: atrac9dec.c:46
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
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:1135
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:693
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
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
ATRAC9BlockData
Definition: atrac9dec.c:55
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:501
ATRAC9BlockData::has_band_ext_data
int has_band_ext_data
Definition: atrac9dec.c:68
atrac9tab.h
sf_vlc
static VLC sf_vlc[2][8]
Definition: atrac9dec.c:105
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:26
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:130
atrac9_decode_flush
static void atrac9_decode_flush(AVCodecContext *avctx)
Definition: atrac9dec.c:818
apply_scalefactors
static void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:498
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
ATRAC9Context::samplerate_idx
int samplerate_idx
Definition: atrac9dec.c:95
read_coeffs_coarse
static void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:403
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:37
VLC::table_size
int table_size
Definition: vlc.h:29
at9_tab_band_ext_group
static const uint8_t at9_tab_band_ext_group[][3]
Definition: atrac9tab.h:130
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:95
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:310
ATRAC9BlockData::q_unit_cnt
int q_unit_cnt
Definition: atrac9dec.c:60
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
AVPacket
This structure stores compressed data.
Definition: packet.h:342
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ATRAC9BlockData::band_count
int band_count
Definition: atrac9dec.c:59
at9_tab_b_dist
static const uint8_t at9_tab_b_dist[]
Definition: atrac9tab.h:370
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
channel
channel
Definition: ebur128.h:39
ATRAC9ChannelData::prev_win
float prev_win[128]
Definition: atrac9dec.c:52
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:477
min
float min
Definition: vorbis_enc_data.h:456
at9_q_unit_to_coeff_cnt
static const uint8_t at9_q_unit_to_coeff_cnt[]
Definition: atrac9tab.h:97