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 "internal.h"
23 #include "get_bits.h"
24 #include "fft.h"
25 #include "atrac9tab.h"
26 #include "libavutil/lfg.h"
27 #include "libavutil/float_dsp.h"
28 
29 typedef struct ATRAC9ChannelData {
30  int band_ext;
32  int band_ext_data[4];
35 
37  int precision_fine[30];
38  int precision_mask[30];
39 
40  int codebookset[30];
41 
44 
45  DECLARE_ALIGNED(32, float, coeffs )[256];
46  DECLARE_ALIGNED(32, float, prev_win)[128];
48 
49 typedef struct ATRAC9BlockData {
51 
52  /* Base */
56 
57  /* Stereo block only */
59 
60  /* Band extension only */
64 
65  /* Gradient */
66  int grad_mode;
68  int gradient[31];
69 
70  /* Stereo */
72  int is_signs[30];
73 
74  int reuseable;
75 
77 
78 typedef struct ATRAC9Context {
84 
85  /* Set on init */
91 
92  /* Generated on init */
93  VLC sf_vlc[2][8]; /* Signed/unsigned, length */
94  VLC coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */
95  uint8_t alloc_curve[48][48];
96  DECLARE_ALIGNED(32, float, imdct_win)[256];
97 
98  DECLARE_ALIGNED(32, float, temp)[256];
100 
102  GetBitContext *gb)
103 {
104  int grad_range[2];
105  int grad_value[2];
106  int values, sign, base;
107  uint8_t *curve;
108  float scale;
109 
110  b->grad_mode = get_bits(gb, 2);
111  if (b->grad_mode) {
112  grad_range[0] = get_bits(gb, 5);
113  grad_range[1] = 31;
114  grad_value[0] = get_bits(gb, 5);
115  grad_value[1] = 31;
116  } else {
117  grad_range[0] = get_bits(gb, 6);
118  grad_range[1] = get_bits(gb, 6) + 1;
119  grad_value[0] = get_bits(gb, 5);
120  grad_value[1] = get_bits(gb, 5);
121  }
122  b->grad_boundary = get_bits(gb, 4);
123 
124  if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
125  return AVERROR_INVALIDDATA;
126 
127  if (b->grad_boundary > b->q_unit_cnt)
128  return AVERROR_INVALIDDATA;
129 
130  values = grad_value[1] - grad_value[0];
131  sign = 1 - 2*(values < 0);
132  base = grad_value[0] + sign;
133  scale = (FFABS(values) - 1) / 31.0f;
134  curve = s->alloc_curve[grad_range[1] - grad_range[0] - 1];
135 
136  for (int i = 0; i <= b->q_unit_cnt; i++)
137  b->gradient[i] = grad_value[i >= grad_range[0]];
138 
139  for (int i = grad_range[0]; i < grad_range[1]; i++)
140  b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));
141 
142  return 0;
143 }
144 
147 {
148  memset(c->precision_mask, 0, sizeof(c->precision_mask));
149  for (int i = 1; i < b->q_unit_cnt; i++) {
150  const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;
151  if (delta > 0) {
152  const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
153  c->precision_mask[i - neg] += FFMIN(delta, 5);
154  }
155  }
156 
157  if (b->grad_mode) {
158  for (int i = 0; i < b->q_unit_cnt; i++) {
159  c->precision_coarse[i] = c->scalefactors[i];
160  c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];
161  if (c->precision_coarse[i] < 0)
162  continue;
163  switch (b->grad_mode) {
164  case 1:
165  c->precision_coarse[i] >>= 1;
166  break;
167  case 2:
168  c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
169  break;
170  case 3:
171  c->precision_coarse[i] >>= 2;
172  break;
173  }
174  }
175  } else {
176  for (int i = 0; i < b->q_unit_cnt; i++)
177  c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
178  }
179 
180 
181  for (int i = 0; i < b->q_unit_cnt; i++)
182  c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
183 
184  for (int i = 0; i < b->grad_boundary; i++)
185  c->precision_coarse[i]++;
186 
187  for (int i = 0; i < b->q_unit_cnt; i++) {
188  c->precision_fine[i] = 0;
189  if (c->precision_coarse[i] > 15) {
190  c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;
191  c->precision_coarse[i] = 15;
192  }
193  }
194 }
195 
197  GetBitContext *gb, int stereo)
198 {
199  int ext_band = 0;
200 
201  if (b->has_band_ext) {
202  if (b->q_unit_cnt < 13)
203  return AVERROR_INVALIDDATA;
204  ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];
205  if (stereo) {
206  b->channel[1].band_ext = get_bits(gb, 2);
207  b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;
208  } else {
209  skip_bits1(gb);
210  }
211  }
212 
213  b->has_band_ext_data = get_bits1(gb);
214  if (!b->has_band_ext_data)
215  return 0;
216 
217  if (!b->has_band_ext) {
218  skip_bits(gb, 2);
219  skip_bits_long(gb, get_bits(gb, 5));
220  return 0;
221  }
222 
223  b->channel[0].band_ext = get_bits(gb, 2);
224  b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;
225 
226  if (!get_bits(gb, 5))
227  return 0;
228 
229  for (int i = 0; i <= stereo; i++) {
230  ATRAC9ChannelData *c = &b->channel[i];
231  const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
232  for (int j = 0; j < count; j++) {
233  int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
234  c->band_ext_data[j] = get_bits(gb, len);
235  }
236  }
237 
238  return 0;
239 }
240 
243  int channel_idx, int first_in_pkt)
244 {
245  static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };
246  const int mode = mode_map[channel_idx][get_bits(gb, 2)];
247 
248  memset(c->scalefactors, 0, sizeof(c->scalefactors));
249 
250  if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {
251  av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");
252  return AVERROR_INVALIDDATA;
253  }
254 
255  switch (mode) {
256  case 0: { /* VLC delta offset */
257  const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];
258  const int base = get_bits(gb, 5);
259  const int len = get_bits(gb, 2) + 3;
260  const VLC *tab = &s->sf_vlc[0][len];
261 
262  c->scalefactors[0] = get_bits(gb, len);
263 
264  for (int i = 1; i < b->band_ext_q_unit; i++) {
265  int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table, 9, 2);
266  c->scalefactors[i] = val & ((1 << len) - 1);
267  }
268 
269  for (int i = 0; i < b->band_ext_q_unit; i++)
270  c->scalefactors[i] += base - sf_weights[i];
271 
272  break;
273  }
274  case 1: { /* CLC offset */
275  const int len = get_bits(gb, 2) + 2;
276  const int base = len < 5 ? get_bits(gb, 5) : 0;
277  for (int i = 0; i < b->band_ext_q_unit; i++)
278  c->scalefactors[i] = base + get_bits(gb, len);
279  break;
280  }
281  case 2:
282  case 4: { /* VLC dist to baseline */
283  const int *baseline = mode == 4 ? c->scalefactors_prev :
284  channel_idx ? b->channel[0].scalefactors :
286  const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :
287  channel_idx ? b->band_ext_q_unit :
288  b->q_unit_cnt_prev;
289 
290  const int len = get_bits(gb, 2) + 2;
291  const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
292  const VLC *tab = &s->sf_vlc[1][len];
293 
294  for (int i = 0; i < unit_cnt; i++) {
295  int dist = get_vlc2(gb, tab->table, 9, 2);
296  c->scalefactors[i] = baseline[i] + dist;
297  }
298 
299  for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
300  c->scalefactors[i] = get_bits(gb, 5);
301 
302  break;
303  }
304  case 3: { /* VLC offset with baseline */
305  const int *baseline = channel_idx ? b->channel[0].scalefactors :
307  const int baseline_len = channel_idx ? b->band_ext_q_unit :
308  b->q_unit_cnt_prev;
309 
310  const int base = get_bits(gb, 5) - (1 << (5 - 1));
311  const int len = get_bits(gb, 2) + 1;
312  const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
313  const VLC *tab = &s->sf_vlc[0][len];
314 
315  c->scalefactors[0] = get_bits(gb, len);
316 
317  for (int i = 1; i < unit_cnt; i++) {
318  int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table, 9, 2);
319  c->scalefactors[i] = val & ((1 << len) - 1);
320  }
321 
322  for (int i = 0; i < unit_cnt; i++)
323  c->scalefactors[i] += base + baseline[i];
324 
325  for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
326  c->scalefactors[i] = get_bits(gb, 5);
327  break;
328  }
329  }
330 
331  for (int i = 0; i < b->band_ext_q_unit; i++)
332  if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)
333  return AVERROR_INVALIDDATA;
334 
335  memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
336 
337  return 0;
338 }
339 
342 {
343  int avg = 0;
344  const int last_sf = c->scalefactors[c->q_unit_cnt];
345 
346  memset(c->codebookset, 0, sizeof(c->codebookset));
347 
348  if (c->q_unit_cnt <= 1)
349  return;
350  if (s->samplerate_idx > 7)
351  return;
352 
353  c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
354 
355  if (c->q_unit_cnt > 12) {
356  for (int i = 0; i < 12; i++)
357  avg += c->scalefactors[i];
358  avg = (avg + 6) / 12;
359  }
360 
361  for (int i = 8; i < c->q_unit_cnt; i++) {
362  const int prev = c->scalefactors[i - 1];
363  const int cur = c->scalefactors[i ];
364  const int next = c->scalefactors[i + 1];
365  const int min = FFMIN(prev, next);
366  if ((cur - min >= 3 || 2*cur - prev - next >= 3))
367  c->codebookset[i] = 1;
368  }
369 
370 
371  for (int i = 12; i < c->q_unit_cnt; i++) {
372  const int cur = c->scalefactors[i];
373  const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;
374  const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);
375  if (c->codebookset[i])
376  continue;
377 
378  c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
379  }
380 
381  c->scalefactors[c->q_unit_cnt] = last_sf;
382 }
383 
386 {
387  const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
388 
389  memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
390 
391  for (int i = 0; i < c->q_unit_cnt; i++) {
393  const int bands = at9_q_unit_to_coeff_cnt[i];
394  const int prec = c->precision_coarse[i] + 1;
395 
396  if (prec <= max_prec) {
397  const int cb = c->codebookset[i];
398  const int cbi = at9_q_unit_to_codebookidx[i];
399  const VLC *tab = &s->coeff_vlc[cb][prec][cbi];
400  const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];
401  const int groups = bands >> huff->value_cnt_pow;
402 
403  for (int j = 0; j < groups; j++) {
404  uint16_t val = get_vlc2(gb, tab->table, 9, huff->max_bit_size);
405 
406  for (int k = 0; k < huff->value_cnt; k++) {
407  coeffs[k] = sign_extend(val, huff->value_bits);
408  val >>= huff->value_bits;
409  }
410 
411  coeffs += huff->value_cnt;
412  }
413  } else {
414  for (int j = 0; j < bands; j++)
415  coeffs[j] = sign_extend(get_bits(gb, prec), prec);
416  }
417  }
418 }
419 
422 {
423  memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
424 
425  for (int i = 0; i < c->q_unit_cnt; i++) {
426  const int start = at9_q_unit_to_coeff_idx[i + 0];
427  const int end = at9_q_unit_to_coeff_idx[i + 1];
428  const int len = c->precision_fine[i] + 1;
429 
430  if (c->precision_fine[i] <= 0)
431  continue;
432 
433  for (int j = start; j < end; j++)
434  c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
435  }
436 }
437 
440 {
441  memset(c->coeffs, 0, sizeof(c->coeffs));
442 
443  for (int i = 0; i < c->q_unit_cnt; i++) {
444  const int start = at9_q_unit_to_coeff_idx[i + 0];
445  const int end = at9_q_unit_to_coeff_idx[i + 1];
446 
447  const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];
448  const float fine_c = at9_quant_step_fine[c->precision_fine[i]];
449 
450  for (int j = start; j < end; j++) {
451  const float vc = c->q_coeffs_coarse[j] * coarse_c;
452  const float vf = c->q_coeffs_fine[j] * fine_c;
453  c->coeffs[j] = vc + vf;
454  }
455  }
456 }
457 
459  const int stereo)
460 {
461  float *src = b->channel[ b->cpe_base_channel].coeffs;
462  float *dst = b->channel[!b->cpe_base_channel].coeffs;
463 
464  if (!stereo)
465  return;
466 
467  if (b->q_unit_cnt <= b->stereo_q_unit)
468  return;
469 
470  for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {
471  const int sign = b->is_signs[i];
472  const int start = at9_q_unit_to_coeff_idx[i + 0];
473  const int end = at9_q_unit_to_coeff_idx[i + 1];
474  for (int j = start; j < end; j++)
475  dst[j] = sign*src[j];
476  }
477 }
478 
480  const int stereo)
481 {
482  for (int i = 0; i <= stereo; i++) {
483  float *coeffs = b->channel[i].coeffs;
484  for (int j = 0; j < b->q_unit_cnt; j++) {
485  const int start = at9_q_unit_to_coeff_idx[j + 0];
486  const int end = at9_q_unit_to_coeff_idx[j + 1];
487  const int scalefactor = b->channel[i].scalefactors[j];
488  const float scale = at9_scalefactor_c[scalefactor];
489  for (int k = start; k < end; k++)
490  coeffs[k] *= scale;
491  }
492  }
493 }
494 
496  int start, int count)
497 {
498  float maxval = 0.0f;
499  for (int i = 0; i < count; i += 2) {
500  double tmp[2];
501  av_bmg_get(&s->lfg, tmp);
502  c->coeffs[start + i + 0] = tmp[0];
503  c->coeffs[start + i + 1] = tmp[1];
504  maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);
505  }
506  /* Normalize */
507  for (int i = 0; i < count; i++)
508  c->coeffs[start + i] /= maxval;
509 }
510 
511 static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
512  const int s_unit, const int e_unit)
513 {
514  for (int i = s_unit; i < e_unit; i++) {
515  const int start = at9_q_unit_to_coeff_idx[i + 0];
516  const int end = at9_q_unit_to_coeff_idx[i + 1];
517  for (int j = start; j < end; j++)
518  c->coeffs[j] *= sf[i - s_unit];
519  }
520 }
521 
523  const int stereo)
524 {
525  const int g_units[4] = { /* A, B, C, total units */
526  b->q_unit_cnt,
529  FFMAX(g_units[2], 22),
530  };
531 
532  const int g_bins[4] = { /* A, B, C, total bins */
533  at9_q_unit_to_coeff_idx[g_units[0]],
534  at9_q_unit_to_coeff_idx[g_units[1]],
535  at9_q_unit_to_coeff_idx[g_units[2]],
536  at9_q_unit_to_coeff_idx[g_units[3]],
537  };
538 
539  for (int ch = 0; ch <= stereo; ch++) {
540  ATRAC9ChannelData *c = &b->channel[ch];
541 
542  /* Mirror the spectrum */
543  for (int i = 0; i < 3; i++)
544  for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)
545  c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];
546 
547  switch (c->band_ext) {
548  case 0: {
549  float sf[6] = { 0.0f };
550  const int l = g_units[3] - g_units[0] - 1;
551  const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];
552  const int n_cnt = at9_q_unit_to_coeff_cnt[g_units[3] - 1];
553  switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {
554  case 3:
555  sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];
556  sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];
557  sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];
558  sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];
559  sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];
560  break;
561  case 4:
562  sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];
563  sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];
564  sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];
565  sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];
566  sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];
567  break;
568  case 5:
569  sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];
570  sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];
571  sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];
572  break;
573  }
574 
575  sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
576 
577  fill_with_noise(s, c, n_start, n_cnt);
578  scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
579  break;
580  }
581  case 1: {
582  float sf[6];
583  for (int i = g_units[0]; i < g_units[3]; i++)
584  sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
585 
586  fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);
587  scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
588  break;
589  }
590  case 2: {
591  const float g_sf[2] = {
594  };
595 
596  for (int i = 0; i < 2; i++)
597  for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
598  c->coeffs[j] *= g_sf[i];
599  break;
600  }
601  case 3: {
602  float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];
603  float rate = at9_band_ext_scales_m3[c->band_ext_data[1]][1];
604  rate = pow(2, rate);
605  for (int i = g_bins[0]; i < g_bins[3]; i++) {
606  scale *= rate;
607  c->coeffs[i] *= scale;
608  }
609  break;
610  }
611  case 4: {
612  const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];
613  const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };
614 
615  for (int i = 0; i < 3; 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  }
621  }
622 }
623 
626  int frame_idx, int block_idx)
627 {
628  const int first_in_pkt = !get_bits1(gb);
629  const int reuse_params = get_bits1(gb);
630  const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;
631 
632  if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {
633  ATRAC9ChannelData *c = &b->channel[0];
634  const int precision = reuse_params ? 8 : 4;
635  c->q_unit_cnt = b->q_unit_cnt = 2;
636 
637  memset(c->scalefactors, 0, sizeof(c->scalefactors));
638  memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
639  memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
640 
641  for (int i = 0; i < b->q_unit_cnt; i++) {
642  c->scalefactors[i] = get_bits(gb, 5);
643  c->precision_coarse[i] = precision;
644  c->precision_fine[i] = 0;
645  }
646 
647  for (int i = 0; i < c->q_unit_cnt; i++) {
648  const int start = at9_q_unit_to_coeff_idx[i + 0];
649  const int end = at9_q_unit_to_coeff_idx[i + 1];
650  for (int j = start; j < end; j++)
651  c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);
652  }
653 
654  dequantize (s, b, c);
655  apply_scalefactors(s, b, 0);
656 
657  goto imdct;
658  }
659 
660  if (first_in_pkt && reuse_params) {
661  av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
662  return AVERROR_INVALIDDATA;
663  }
664 
665  /* Band parameters */
666  if (!reuse_params) {
667  int stereo_band, ext_band;
668  const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
669  b->reuseable = 0;
670  b->band_count = get_bits(gb, 4) + min_band_count;
672 
674 
676  av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",
677  b->band_count);
678  return AVERROR_INVALIDDATA;
679  }
680 
681  if (stereo) {
682  stereo_band = get_bits(gb, 4) + min_band_count;
683  if (stereo_band > b->band_count) {
684  av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",
685  stereo_band);
686  return AVERROR_INVALIDDATA;
687  }
688  b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
689  }
690 
691  b->has_band_ext = get_bits1(gb);
692  if (b->has_band_ext) {
693  ext_band = get_bits(gb, 4) + min_band_count;
694  if (ext_band < b->band_count) {
695  av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",
696  ext_band);
697  return AVERROR_INVALIDDATA;
698  }
700  }
701  b->reuseable = 1;
702  }
703  if (!b->reuseable) {
704  av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
705  return AVERROR_INVALIDDATA;
706  }
707 
708  /* Calculate bit alloc gradient */
709  if (parse_gradient(s, b, gb))
710  return AVERROR_INVALIDDATA;
711 
712  /* IS data */
713  b->cpe_base_channel = 0;
714  if (stereo) {
715  b->cpe_base_channel = get_bits1(gb);
716  if (get_bits1(gb)) {
717  for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)
718  b->is_signs[i] = 1 - 2*get_bits1(gb);
719  } else {
720  for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
721  b->is_signs[i] = 1;
722  }
723  }
724 
725  /* Band extension */
726  if (parse_band_ext(s, b, gb, stereo))
727  return AVERROR_INVALIDDATA;
728 
729  /* Scalefactors */
730  for (int i = 0; i <= stereo; i++) {
731  ATRAC9ChannelData *c = &b->channel[i];
732  c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :
733  b->stereo_q_unit;
734  if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
735  return AVERROR_INVALIDDATA;
736 
737  calc_precision (s, b, c);
738  calc_codebook_idx (s, b, c);
739  read_coeffs_coarse(s, b, c, gb);
740  read_coeffs_fine (s, b, c, gb);
741  dequantize (s, b, c);
742  }
743 
745 
746  apply_intensity_stereo(s, b, stereo);
747  apply_scalefactors (s, b, stereo);
748 
749  if (b->has_band_ext && b->has_band_ext_data)
750  apply_band_extension (s, b, stereo);
751 
752 imdct:
753  for (int i = 0; i <= stereo; i++) {
754  ATRAC9ChannelData *c = &b->channel[i];
755  const int dst_idx = s->block_config->plane_map[block_idx][i];
756  const int wsize = 1 << s->frame_log2;
757  const ptrdiff_t offset = wsize*frame_idx*sizeof(float);
758  float *dst = (float *)(frame->extended_data[dst_idx] + offset);
759 
760  s->imdct.imdct_half(&s->imdct, s->temp, c->coeffs);
761  s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,
762  s->imdct_win, wsize >> 1);
763  memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);
764  }
765 
766  return 0;
767 }
768 
769 static int atrac9_decode_frame(AVCodecContext *avctx, void *data,
770  int *got_frame_ptr, AVPacket *avpkt)
771 {
772  int ret;
773  GetBitContext gb;
774  AVFrame *frame = data;
775  ATRAC9Context *s = avctx->priv_data;
776  const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
777 
778  frame->nb_samples = (1 << s->frame_log2) * frames;
779  ret = ff_get_buffer(avctx, frame, 0);
780  if (ret < 0)
781  return ret;
782 
783  init_get_bits8(&gb, avpkt->data, avpkt->size);
784 
785  for (int i = 0; i < frames; i++) {
786  for (int j = 0; j < s->block_config->count; j++) {
787  ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);
788  if (ret)
789  return ret;
790  align_get_bits(&gb);
791  }
792  }
793 
794  *got_frame_ptr = 1;
795 
796  return avctx->block_align;
797 }
798 
800 {
801  ATRAC9Context *s = avctx->priv_data;
802 
803  for (int j = 0; j < s->block_config->count; j++) {
804  ATRAC9BlockData *b = &s->block[j];
805  const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;
806  for (int i = 0; i <= stereo; i++) {
807  ATRAC9ChannelData *c = &b->channel[i];
808  memset(c->prev_win, 0, sizeof(c->prev_win));
809  }
810  }
811 }
812 
814 {
815  ATRAC9Context *s = avctx->priv_data;
816 
817  for (int i = 1; i < 7; i++)
818  ff_free_vlc(&s->sf_vlc[0][i]);
819  for (int i = 2; i < 6; i++)
820  ff_free_vlc(&s->sf_vlc[1][i]);
821  for (int i = 0; i < 2; i++)
822  for (int j = 0; j < 8; j++)
823  for (int k = 0; k < 4; k++)
824  ff_free_vlc(&s->coeff_vlc[i][j][k]);
825 
826  ff_mdct_end(&s->imdct);
827  av_free(s->fdsp);
828 
829  return 0;
830 }
831 
833 {
834  GetBitContext gb;
835  ATRAC9Context *s = avctx->priv_data;
836  int version, block_config_idx, superframe_idx, alloc_c_len;
837 
838  s->avctx = avctx;
839 
840  av_lfg_init(&s->lfg, 0xFBADF00D);
841 
842  if (avctx->block_align <= 0) {
843  av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
844  return AVERROR_INVALIDDATA;
845  }
846 
847  if (avctx->extradata_size != 12) {
848  av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
849  return AVERROR_INVALIDDATA;
850  }
851 
852  version = AV_RL32(avctx->extradata);
853  if (version > 2) {
854  av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
855  return AVERROR_INVALIDDATA;
856  }
857 
858  init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
859 
860  if (get_bits(&gb, 8) != 0xFE) {
861  av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
862  return AVERROR_INVALIDDATA;
863  }
864 
865  s->samplerate_idx = get_bits(&gb, 4);
867 
868  block_config_idx = get_bits(&gb, 3);
869  if (block_config_idx > 5) {
870  av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");
871  return AVERROR_INVALIDDATA;
872  }
873  s->block_config = &at9_block_layout[block_config_idx];
874 
878 
879  if (get_bits1(&gb)) {
880  av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
881  return AVERROR_INVALIDDATA;
882  }
883 
884  /* Average frame size in bytes */
885  s->avg_frame_size = get_bits(&gb, 11) + 1;
886 
887  superframe_idx = get_bits(&gb, 2);
888  if (superframe_idx & 1) {
889  av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");
890  return AVERROR_INVALIDDATA;
891  }
892 
893  s->frame_count = 1 << superframe_idx;
895 
896  if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))
897  return AVERROR(ENOMEM);
898 
900  if (!s->fdsp)
901  return AVERROR(ENOMEM);
902 
903  /* iMDCT window */
904  for (int i = 0; i < (1 << s->frame_log2); i++) {
905  const int len = 1 << s->frame_log2;
906  const float sidx = ( i + 0.5f) / len;
907  const float eidx = (len - i - 0.5f) / len;
908  const float s_c = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;
909  const float e_c = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;
910  s->imdct_win[i] = s_c / ((s_c * s_c) + (e_c * e_c));
911  }
912 
913  /* Allocation curve */
914  alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);
915  for (int i = 1; i <= alloc_c_len; i++)
916  for (int j = 0; j < i; j++)
917  s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];
918 
919  /* Unsigned scalefactor VLCs */
920  for (int i = 1; i < 7; i++) {
922 
923  init_vlc(&s->sf_vlc[0][i], 9, hf->size, hf->bits, 1, 1, hf->codes,
924  2, 2, 0);
925  }
926 
927  /* Signed scalefactor VLCs */
928  for (int i = 2; i < 6; i++) {
930 
931  int nums = hf->size;
932  int16_t sym[32];
933  for (int j = 0; j < nums; j++)
934  sym[j] = sign_extend(j, hf->value_bits);
935 
936  ff_init_vlc_sparse(&s->sf_vlc[1][i], 9, hf->size, hf->bits, 1, 1,
937  hf->codes, 2, 2, sym, sizeof(*sym), sizeof(*sym), 0);
938  }
939 
940  /* Coefficient VLCs */
941  for (int i = 0; i < 2; i++) {
942  for (int j = 0; j < 8; j++) {
943  for (int k = 0; k < 4; k++) {
944  const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];
945  init_vlc(&s->coeff_vlc[i][j][k], 9, hf->size, hf->bits, 1, 1,
946  hf->codes, 2, 2, 0);
947  }
948  }
949  }
950 
951  return 0;
952 }
953 
955  .name = "atrac9",
956  .long_name = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
957  .type = AVMEDIA_TYPE_AUDIO,
958  .id = AV_CODEC_ID_ATRAC9,
959  .priv_data_size = sizeof(ATRAC9Context),
961  .close = atrac9_decode_close,
965  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
966 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
static const uint8_t at9_tab_sri_max_bands[]
Definition: atrac9tab.h:112
float, planar
Definition: samplefmt.h:69
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodec ff_atrac9_decoder
Definition: atrac9dec.c:954
int precision_mask[30]
Definition: atrac9dec.c:38
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int precision_coarse[30]
Definition: atrac9dec.c:36
static void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:522
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static void dequantize(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:438
else temp
Definition: vf_mcdeint.c:256
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
int band_ext_data[4]
Definition: atrac9dec.c:32
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:273
int size
Definition: avcodec.h:1483
int q_unit_cnt_prev
Definition: atrac9dec.c:55
float prev_win[128]
Definition: atrac9dec.c:46
static void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:384
VLC coeff_vlc[2][8][4]
Definition: atrac9dec.c:94
int version
Definition: avisynth_c.h:858
float coeffs[256]
Definition: atrac9dec.c:45
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3494
if it could not because there are no more frames
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2267
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int is_signs[30]
Definition: atrac9dec.c:72
AVCodecContext * avctx
Definition: atrac9dec.c:79
uint8_t base
Definition: vp3data.h:202
static const float at9_band_ext_scales_m4[]
Definition: atrac9tab.h:301
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
uint64_t channel_layout
Definition: atrac9tab.h:36
const int max_bit_size
Definition: atrac9tab.h:479
static const HuffmanCodebook at9_huffman_coeffs[][8][4]
Definition: atrac9tab.h:1537
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:139
static const int at9_tab_samplerates[]
Definition: atrac9tab.h:116
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
ATRAC9ChannelData channel[2]
Definition: atrac9dec.c:50
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2238
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
float delta
int avg_frame_size
Definition: atrac9dec.c:87
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3260
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define f(width, name)
Definition: cbs_vp9.c:255
float imdct_win[256]
Definition: atrac9dec.c:96
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1671
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1482
bitstream reader API header.
static void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c, int start, int count)
Definition: atrac9dec.c:495
int frame_count
Definition: atrac9dec.c:88
static int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb, int channel_idx, int first_in_pkt)
Definition: atrac9dec.c:241
void av_bmg_get(AVLFG *lfg, double out[2])
Get the next two numbers generated by a Box-Muller Gaussian generator using the random numbers issued...
Definition: lfg.c:49
static void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:479
static const uint8_t at9_tab_sf_weights[][32]
Definition: atrac9tab.h:335
int32_t q_coeffs_coarse[256]
Definition: atrac9dec.c:42
#define av_log(a,...)
static void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:145
static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb, ATRAC9BlockData *b, AVFrame *frame, int frame_idx, int block_idx)
Definition: atrac9dec.c:624
static const float at9_quant_step_fine[]
Definition: atrac9tab.h:315
const uint8_t * bits
Definition: atrac9tab.h:473
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c, GetBitContext *gb)
Definition: atrac9dec.c:420
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
static const uint8_t at9_tab_band_q_unit_map[]
Definition: atrac9tab.h:93
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const uint8_t at9_q_unit_to_codebookidx[]
Definition: atrac9tab.h:107
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1650
static int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb, int stereo)
Definition: atrac9dec.c:196
const char * name
Name of the codec implementation.
Definition: avcodec.h:3501
const int size
Definition: atrac9tab.h:475
static void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b, ATRAC9ChannelData *c)
Definition: atrac9dec.c:340
#define ff_mdct_init
Definition: fft.h:169
int has_band_ext_data
Definition: atrac9dec.c:62
GLsizei count
Definition: opengl_enc.c:108
VLC sf_vlc[2][8]
Definition: atrac9dec.c:93
#define FFMAX(a, b)
Definition: common.h:94
FFTContext imdct
Definition: atrac9dec.c:81
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2281
enum ATRAC9BlockType type[5]
Definition: atrac9tab.h:37
static VLC sf_vlc
scale factor DPCM vlc
Definition: wmaprodec.c:128
int frame_log2
Definition: atrac9dec.c:86
#define b
Definition: input.c:41
Definition: fft.h:88
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:913
#define FFMIN(a, b)
Definition: common.h:96
int32_t scalefactors_prev[31]
Definition: atrac9dec.c:34
int band_ext_q_unit
Definition: atrac9dec.c:63
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
#define M_PI_2
Definition: mathematics.h:55
int32_t
static const float at9_band_ext_scales_m0[][5][32]
Definition: atrac9tab.h:184
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
ATRAC9BlockData block[5]
Definition: atrac9dec.c:82
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
static const float at9_scalefactor_c[]
Definition: atrac9tab.h:324
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
#define FF_ARRAY_ELEMS(a)
static int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b, GetBitContext *gb)
Definition: atrac9dec.c:101
static av_cold int atrac9_decode_init(AVCodecContext *avctx)
Definition: atrac9dec.c:832
#define sinf(x)
Definition: libm.h:419
const int value_bits
Definition: atrac9tab.h:478
int sample_rate
samples per second
Definition: avcodec.h:2230
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int cpe_base_channel
Definition: atrac9dec.c:71
main external API structure.
Definition: avcodec.h:1570
const int value_cnt_pow
Definition: atrac9tab.h:477
static const float bands[]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
int extradata_size
Definition: avcodec.h:1672
static void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b, const int stereo)
Definition: atrac9dec.c:458
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static const uint8_t at9_q_unit_to_coeff_cnt[]
Definition: atrac9tab.h:97
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
int precision_fine[30]
Definition: atrac9dec.c:37
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: avcodec.h:1029
uint8_t alloc_curve[48][48]
Definition: atrac9dec.c:95
int samplerate_idx
Definition: atrac9dec.c:89
static av_cold int atrac9_decode_close(AVCodecContext *avctx)
Definition: atrac9dec.c:813
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
static const uint8_t at9_tab_band_ext_group[][3]
Definition: atrac9tab.h:130
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static const uint8_t at9_tab_band_ext_cnt[][6]
Definition: atrac9tab.h:121
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
static const float at9_band_ext_scales_m2[]
Definition: atrac9tab.h:271
static void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6], const int s_unit, const int e_unit)
Definition: atrac9dec.c:511
AVFloatDSPContext * fdsp
Definition: atrac9dec.c:80
static const float at9_quant_step_coarse[]
Definition: atrac9tab.h:306
#define avg(a, b, c, d)
static int atrac9_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: atrac9dec.c:769
static const HuffmanCodebook at9_huffman_sf_unsigned[]
Definition: atrac9tab.h:482
common internal api header.
const ATRAC9BlockConfig * block_config
Definition: atrac9dec.c:90
#define ff_mdct_end
Definition: fft.h:170
const int value_cnt
Definition: atrac9tab.h:476
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
static const uint8_t at9_tab_sri_frame_log2[]
Definition: atrac9tab.h:89
int codebookset[30]
Definition: atrac9dec.c:40
int plane_map[5][2]
Definition: atrac9tab.h:38
static const float at9_band_ext_scales_m3[][2]
Definition: atrac9tab.h:290
const uint16_t * codes
Definition: atrac9tab.h:474
void * priv_data
Definition: avcodec.h:1597
#define av_free(p)
static const HuffmanCodebook at9_huffman_sf_signed[]
Definition: atrac9tab.h:492
int gradient[31]
Definition: atrac9dec.c:68
int len
int channels
number of audio channels
Definition: avcodec.h:2231
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
static const struct twinvq_data tab
int32_t scalefactors[31]
Definition: atrac9dec.c:33
static const ATRAC9BlockConfig at9_block_layout[]
Definition: atrac9tab.h:42
static const uint8_t at9_tab_b_dist[]
Definition: atrac9tab.h:370
static void atrac9_decode_flush(AVCodecContext *avctx)
Definition: atrac9dec.c:799
void INT64 start
Definition: avisynth_c.h:766
#define M_PI
Definition: mathematics.h:52
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
float min
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1459
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:986
static const int at9_q_unit_to_coeff_idx[]
Definition: atrac9tab.h:102
int32_t q_coeffs_fine[256]
Definition: atrac9dec.c:43
for(j=16;j >0;--j)
static const uint8_t at9_tab_band_ext_lengths[][6][4]
Definition: atrac9tab.h:141
float temp[256]
Definition: atrac9dec.c:98
static uint8_t tmp[11]
Definition: aes_ctr.c:26