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