FFmpeg
aacsbr_template.c
Go to the documentation of this file.
1 /*
2  * AAC Spectral Band Replication decoding functions
3  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
4  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
5  *
6  * Fixed point code
7  * Copyright (c) 2013
8  * MIPS Technologies, Inc., California.
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 /**
28  * @file
29  * AAC Spectral Band Replication decoding functions
30  * @author Robert Swain ( rob opendot cl )
31  * @author Stanislav Ocovaj ( stanislav.ocovaj@imgtec.com )
32  * @author Zoran Basaric ( zoran.basaric@imgtec.com )
33  */
34 
35 #include "aacdec.h"
36 #include "aacdectab.h"
37 #include "avcodec.h"
38 #include "libavutil/qsort.h"
39 
40 static av_cold void aacsbr_tableinit(void)
41 {
42  int n;
43 
44  for (n = 0; n < 320; n++)
46 }
47 
49 {
51 
53 }
54 
55 /** Places SBR in pure upsampling mode. */
57  sbr->start = 0;
58  sbr->ready_for_dequant = 0;
59  // Init defults used in pure upsampling mode
60  sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
61  sbr->m[1] = 0;
62  // Reset values for first SBR header
63  sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
64  memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters));
65 }
66 
68 {
69  int ret;
70  float scale;
71 
72  if (sbr->mdct)
73  return 0;
74 
75  sbr->kx[0] = sbr->kx[1];
76  sbr->id_aac = id_aac;
77  sbr_turnoff(sbr);
78  sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
79  sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
80  /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
81  * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
82  * and scale back down at synthesis. */
83 
84  scale = USE_FIXED ? 1 : 1.0 / (64 * 32768);
85  ret = av_tx_init(&sbr->mdct, &sbr->mdct_fn,
87  1, 64, &scale, 0);
88  if (ret < 0)
89  return ret;
90 
91  scale = USE_FIXED ? -1.0 : -2.0 * 32768;
92  ret = av_tx_init(&sbr->mdct_ana, &sbr->mdct_ana_fn,
94  1, 64, &scale, 0);
95  if (ret < 0)
96  return ret;
97 
98  AAC_RENAME(ff_ps_ctx_init)(&sbr->ps);
99  AAC_RENAME(ff_sbrdsp_init)(&sbr->dsp);
100  aacsbr_func_ptr_init(&sbr->c);
101 
102  return 0;
103 }
104 
106 {
107  av_tx_uninit(&sbr->mdct);
108  av_tx_uninit(&sbr->mdct_ana);
109 }
110 
111 static int qsort_comparison_function_int16(const void *a, const void *b)
112 {
113  return *(const int16_t *)a - *(const int16_t *)b;
114 }
115 
116 static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)
117 {
118  int i;
119  for (i = 0; i <= last_el; i++)
120  if (table[i] == needle)
121  return 1;
122  return 0;
123 }
124 
125 /// Limiter Frequency Band Table (14496-3 sp04 p198)
127 {
128  int k;
129  if (sbr->bs_limiter_bands > 0) {
130  static const INTFLOAT bands_warped[3] = { Q23(1.32715174233856803909f), //2^(0.49/1.2)
131  Q23(1.18509277094158210129f), //2^(0.49/2)
132  Q23(1.11987160404675912501f) }; //2^(0.49/3)
133  const INTFLOAT lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
134  int16_t patch_borders[7];
135  uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
136 
137  patch_borders[0] = sbr->kx[1];
138  for (k = 1; k <= sbr->num_patches; k++)
139  patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
140 
141  memcpy(sbr->f_tablelim, sbr->f_tablelow,
142  (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
143  if (sbr->num_patches > 1)
144  memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
145  (sbr->num_patches - 1) * sizeof(patch_borders[0]));
146 
147  AV_QSORT(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
148  uint16_t,
150 
151  sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
152  while (out < sbr->f_tablelim + sbr->n_lim) {
153 #if USE_FIXED
154  if ((*in << 23) >= *out * lim_bands_per_octave_warped) {
155 #else
156  if (*in >= *out * lim_bands_per_octave_warped) {
157 #endif /* USE_FIXED */
158  *++out = *in++;
159  } else if (*in == *out ||
160  !in_table_int16(patch_borders, sbr->num_patches, *in)) {
161  in++;
162  sbr->n_lim--;
163  } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
164  *out = *in++;
165  sbr->n_lim--;
166  } else {
167  *++out = *in++;
168  }
169  }
170  } else {
171  sbr->f_tablelim[0] = sbr->f_tablelow[0];
172  sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
173  sbr->n_lim = 1;
174  }
175 }
176 
178 {
179  unsigned int cnt = get_bits_count(gb);
180  uint8_t bs_header_extra_1;
181  uint8_t bs_header_extra_2;
182  int old_bs_limiter_bands = sbr->bs_limiter_bands;
183  SpectrumParameters old_spectrum_params;
184 
185  sbr->start = 1;
186  sbr->ready_for_dequant = 0;
187 
188  // Save last spectrum parameters variables to compare to new ones
189  memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
190 
191  sbr->bs_amp_res_header = get_bits1(gb);
192  sbr->spectrum_params.bs_start_freq = get_bits(gb, 4);
193  sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4);
194  sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
195  skip_bits(gb, 2); // bs_reserved
196 
197  bs_header_extra_1 = get_bits1(gb);
198  bs_header_extra_2 = get_bits1(gb);
199 
200  if (bs_header_extra_1) {
201  sbr->spectrum_params.bs_freq_scale = get_bits(gb, 2);
204  } else {
208  }
209 
210  // Check if spectrum parameters changed
211  if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
212  sbr->reset = 1;
213 
214  if (bs_header_extra_2) {
215  sbr->bs_limiter_bands = get_bits(gb, 2);
216  sbr->bs_limiter_gains = get_bits(gb, 2);
217  sbr->bs_interpol_freq = get_bits1(gb);
218  sbr->bs_smoothing_mode = get_bits1(gb);
219  } else {
220  sbr->bs_limiter_bands = 2;
221  sbr->bs_limiter_gains = 2;
222  sbr->bs_interpol_freq = 1;
223  sbr->bs_smoothing_mode = 1;
224  }
225 
226  if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
227  sbr_make_f_tablelim(sbr);
228 
229  return get_bits_count(gb) - cnt;
230 }
231 
232 static int array_min_int16(const int16_t *array, int nel)
233 {
234  int i, min = array[0];
235  for (i = 1; i < nel; i++)
236  min = FFMIN(array[i], min);
237  return min;
238 }
239 
240 static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
241 {
242  // Requirements (14496-3 sp04 p205)
243  if (n_master <= 0) {
244  av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
245  return -1;
246  }
247  if (bs_xover_band >= n_master) {
249  "Invalid bitstream, crossover band index beyond array bounds: %d\n",
250  bs_xover_band);
251  return -1;
252  }
253  return 0;
254 }
255 
256 /// Master Frequency Band Table (14496-3 sp04 p194)
258  SpectrumParameters *spectrum)
259 {
260  unsigned int temp, max_qmf_subbands = 0;
261  unsigned int start_min, stop_min;
262  int k;
263  const int8_t *sbr_offset_ptr;
264  int16_t stop_dk[13];
265 
266  switch (sbr->sample_rate) {
267  case 16000:
268  sbr_offset_ptr = sbr_offset[0];
269  break;
270  case 22050:
271  sbr_offset_ptr = sbr_offset[1];
272  break;
273  case 24000:
274  sbr_offset_ptr = sbr_offset[2];
275  break;
276  case 32000:
277  sbr_offset_ptr = sbr_offset[3];
278  break;
279  case 44100: case 48000: case 64000:
280  sbr_offset_ptr = sbr_offset[4];
281  break;
282  case 88200: case 96000: case 128000: case 176400: case 192000:
283  sbr_offset_ptr = sbr_offset[5];
284  break;
285  default:
287  "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
288  return -1;
289  }
290 
291  if (sbr->sample_rate < 32000) {
292  temp = 3000;
293  } else if (sbr->sample_rate < 64000) {
294  temp = 4000;
295  } else
296  temp = 5000;
297 
298  start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
299  stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
300 
301  sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
302 
303  if (spectrum->bs_stop_freq < 14) {
304  sbr->k[2] = stop_min;
305  make_bands(stop_dk, stop_min, 64, 13);
306  AV_QSORT(stop_dk, 13, int16_t, qsort_comparison_function_int16);
307  for (k = 0; k < spectrum->bs_stop_freq; k++)
308  sbr->k[2] += stop_dk[k];
309  } else if (spectrum->bs_stop_freq == 14) {
310  sbr->k[2] = 2*sbr->k[0];
311  } else if (spectrum->bs_stop_freq == 15) {
312  sbr->k[2] = 3*sbr->k[0];
313  } else {
315  "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
316  return -1;
317  }
318  sbr->k[2] = FFMIN(64, sbr->k[2]);
319 
320  // Requirements (14496-3 sp04 p205)
321  if (sbr->sample_rate <= 32000) {
322  max_qmf_subbands = 48;
323  } else if (sbr->sample_rate == 44100) {
324  max_qmf_subbands = 35;
325  } else if (sbr->sample_rate >= 48000)
326  max_qmf_subbands = 32;
327  else
328  av_assert0(0);
329 
330  if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
332  "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
333  return -1;
334  }
335 
336  if (!spectrum->bs_freq_scale) {
337  int dk, k2diff;
338 
339  dk = spectrum->bs_alter_scale + 1;
340  sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
342  return -1;
343 
344  for (k = 1; k <= sbr->n_master; k++)
345  sbr->f_master[k] = dk;
346 
347  k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
348  if (k2diff < 0) {
349  sbr->f_master[1]--;
350  sbr->f_master[2]-= (k2diff < -1);
351  } else if (k2diff) {
352  sbr->f_master[sbr->n_master]++;
353  }
354 
355  sbr->f_master[0] = sbr->k[0];
356  for (k = 1; k <= sbr->n_master; k++)
357  sbr->f_master[k] += sbr->f_master[k - 1];
358 
359  } else {
360  int half_bands = 7 - spectrum->bs_freq_scale; // bs_freq_scale = {1,2,3}
361  int two_regions, num_bands_0;
362  int vdk0_max, vdk1_min;
363  int16_t vk0[49];
364 #if USE_FIXED
365  int tmp, nz = 0;
366 #endif /* USE_FIXED */
367 
368  if (49 * sbr->k[2] > 110 * sbr->k[0]) {
369  two_regions = 1;
370  sbr->k[1] = 2 * sbr->k[0];
371  } else {
372  two_regions = 0;
373  sbr->k[1] = sbr->k[2];
374  }
375 
376 #if USE_FIXED
377  tmp = (sbr->k[1] << 23) / sbr->k[0];
378  while (tmp < 0x40000000) {
379  tmp <<= 1;
380  nz++;
381  }
382  tmp = fixed_log(tmp - 0x80000000);
383  tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30);
384  tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
385  num_bands_0 = ((tmp + 0x400000) >> 23) * 2;
386 #else
387  num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
388 #endif /* USE_FIXED */
389 
390  if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
391  av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
392  return -1;
393  }
394 
395  vk0[0] = 0;
396 
397  make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
398 
399  AV_QSORT(vk0 + 1, num_bands_0, int16_t, qsort_comparison_function_int16);
400  vdk0_max = vk0[num_bands_0];
401 
402  vk0[0] = sbr->k[0];
403  for (k = 1; k <= num_bands_0; k++) {
404  if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
405  av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
406  return -1;
407  }
408  vk0[k] += vk0[k-1];
409  }
410 
411  if (two_regions) {
412  int16_t vk1[49];
413 #if USE_FIXED
414  int num_bands_1;
415 
416  tmp = (sbr->k[2] << 23) / sbr->k[1];
417  nz = 0;
418  while (tmp < 0x40000000) {
419  tmp <<= 1;
420  nz++;
421  }
422  tmp = fixed_log(tmp - 0x80000000);
423  tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30);
424  tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
425  if (spectrum->bs_alter_scale)
426  tmp = (int)(((int64_t)tmp * CONST_076923 + 0x40000000) >> 31);
427  num_bands_1 = ((tmp + 0x400000) >> 23) * 2;
428 #else
429  float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f
430  : 1.0f; // bs_alter_scale = {0,1}
431  int num_bands_1 = lrintf(half_bands * invwarp *
432  log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
433 #endif /* USE_FIXED */
434  make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
435 
436  vdk1_min = array_min_int16(vk1 + 1, num_bands_1);
437 
438  if (vdk1_min < vdk0_max) {
439  int change;
440  AV_QSORT(vk1 + 1, num_bands_1, int16_t, qsort_comparison_function_int16);
441  change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
442  vk1[1] += change;
443  vk1[num_bands_1] -= change;
444  }
445 
446  AV_QSORT(vk1 + 1, num_bands_1, int16_t, qsort_comparison_function_int16);
447 
448  vk1[0] = sbr->k[1];
449  for (k = 1; k <= num_bands_1; k++) {
450  if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
451  av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
452  return -1;
453  }
454  vk1[k] += vk1[k-1];
455  }
456 
457  sbr->n_master = num_bands_0 + num_bands_1;
459  return -1;
460  memcpy(&sbr->f_master[0], vk0,
461  (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
462  memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
463  num_bands_1 * sizeof(sbr->f_master[0]));
464 
465  } else {
466  sbr->n_master = num_bands_0;
468  return -1;
469  memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
470  }
471  }
472 
473  return 0;
474 }
475 
476 /// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
478 {
479  int i, k, last_k = -1, last_msb = -1, sb = 0;
480  int msb = sbr->k[0];
481  int usb = sbr->kx[1];
482  int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
483 
484  sbr->num_patches = 0;
485 
486  if (goal_sb < sbr->kx[1] + sbr->m[1]) {
487  for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
488  } else
489  k = sbr->n_master;
490 
491  do {
492  int odd = 0;
493  if (k == last_k && msb == last_msb) {
494  av_log(ac->avctx, AV_LOG_ERROR, "patch construction failed\n");
495  return AVERROR_INVALIDDATA;
496  }
497  last_k = k;
498  last_msb = msb;
499  for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
500  sb = sbr->f_master[i];
501  odd = (sb + sbr->k[0]) & 1;
502  }
503 
504  // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
505  // After this check the final number of patches can still be six which is
506  // illegal however the Coding Technologies decoder check stream has a final
507  // count of 6 patches
508  if (sbr->num_patches > 5) {
509  av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
510  return -1;
511  }
512 
513  sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
514  sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
515 
516  if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
517  usb = sb;
518  msb = sb;
519  sbr->num_patches++;
520  } else
521  msb = sbr->kx[1];
522 
523  if (sbr->f_master[k] - sb < 3)
524  k = sbr->n_master;
525  } while (sb != sbr->kx[1] + sbr->m[1]);
526 
527  if (sbr->num_patches > 1 &&
528  sbr->patch_num_subbands[sbr->num_patches - 1] < 3)
529  sbr->num_patches--;
530 
531  return 0;
532 }
533 
534 /// Derived Frequency Band Tables (14496-3 sp04 p197)
536 {
537  int k, temp;
538 #if USE_FIXED
539  int nz = 0;
540 #endif /* USE_FIXED */
541 
542  sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
543  sbr->n[0] = (sbr->n[1] + 1) >> 1;
544 
545  memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
546  (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
547  sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
548  sbr->kx[1] = sbr->f_tablehigh[0];
549 
550  // Requirements (14496-3 sp04 p205)
551  if (sbr->kx[1] + sbr->m[1] > 64) {
553  "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
554  return -1;
555  }
556  if (sbr->kx[1] > 32) {
557  av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
558  return -1;
559  }
560 
561  sbr->f_tablelow[0] = sbr->f_tablehigh[0];
562  temp = sbr->n[1] & 1;
563  for (k = 1; k <= sbr->n[0]; k++)
564  sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
565 #if USE_FIXED
566  temp = (sbr->k[2] << 23) / sbr->kx[1];
567  while (temp < 0x40000000) {
568  temp <<= 1;
569  nz++;
570  }
571  temp = fixed_log(temp - 0x80000000);
572  temp = (int)(((int64_t)temp * CONST_RECIP_LN2 + 0x20000000) >> 30);
573  temp = (((temp + 0x80) >> 8) + ((8 - nz) << 23)) * sbr->spectrum_params.bs_noise_bands;
574 
575  sbr->n_q = (temp + 0x400000) >> 23;
576  if (sbr->n_q < 1)
577  sbr->n_q = 1;
578 #else
580  log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
581 #endif /* USE_FIXED */
582 
583  if (sbr->n_q > 5) {
584  av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
585  return -1;
586  }
587 
588  sbr->f_tablenoise[0] = sbr->f_tablelow[0];
589  temp = 0;
590  for (k = 1; k <= sbr->n_q; k++) {
591  temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
592  sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
593  }
594 
595  if (sbr_hf_calc_npatches(ac, sbr) < 0)
596  return -1;
597 
598  sbr_make_f_tablelim(sbr);
599 
600  sbr->data[0].f_indexnoise = 0;
601  sbr->data[1].f_indexnoise = 0;
602 
603  return 0;
604 }
605 
606 static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec,
607  int elements)
608 {
609  int i;
610  for (i = 0; i < elements; i++) {
611  vec[i] = get_bits1(gb);
612  }
613 }
614 
615 /** ceil(log2(index+1)) */
616 static const int8_t ceil_log2[] = {
617  0, 1, 2, 2, 3, 3,
618 };
619 
621  GetBitContext *gb, SBRData *ch_data)
622 {
623  int i;
624  int bs_pointer = 0;
625  // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
626  int abs_bord_trail = 16;
627  int num_rel_lead, num_rel_trail;
628  unsigned bs_num_env_old = ch_data->bs_num_env;
629  int bs_frame_class, bs_num_env;
630 
631  ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
632  ch_data->bs_amp_res = sbr->bs_amp_res_header;
633  ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
634 
635  switch (bs_frame_class = get_bits(gb, 2)) {
636  case FIXFIX:
637  bs_num_env = 1 << get_bits(gb, 2);
638  if (bs_num_env > 4) {
640  "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
641  bs_num_env);
642  return -1;
643  }
644  ch_data->bs_num_env = bs_num_env;
645  num_rel_lead = ch_data->bs_num_env - 1;
646  if (ch_data->bs_num_env == 1)
647  ch_data->bs_amp_res = 0;
648 
649 
650  ch_data->t_env[0] = 0;
651  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
652 
653  abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
654  ch_data->bs_num_env;
655  for (i = 0; i < num_rel_lead; i++)
656  ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
657 
658  ch_data->bs_freq_res[1] = get_bits1(gb);
659  for (i = 1; i < ch_data->bs_num_env; i++)
660  ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
661  break;
662  case FIXVAR:
663  abs_bord_trail += get_bits(gb, 2);
664  num_rel_trail = get_bits(gb, 2);
665  ch_data->bs_num_env = num_rel_trail + 1;
666  ch_data->t_env[0] = 0;
667  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
668 
669  for (i = 0; i < num_rel_trail; i++)
670  ch_data->t_env[ch_data->bs_num_env - 1 - i] =
671  ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
672 
673  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
674 
675  for (i = 0; i < ch_data->bs_num_env; i++)
676  ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
677  break;
678  case VARFIX:
679  ch_data->t_env[0] = get_bits(gb, 2);
680  num_rel_lead = get_bits(gb, 2);
681  ch_data->bs_num_env = num_rel_lead + 1;
682  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
683 
684  for (i = 0; i < num_rel_lead; i++)
685  ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
686 
687  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
688 
689  get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
690  break;
691  case VARVAR:
692  ch_data->t_env[0] = get_bits(gb, 2);
693  abs_bord_trail += get_bits(gb, 2);
694  num_rel_lead = get_bits(gb, 2);
695  num_rel_trail = get_bits(gb, 2);
696  bs_num_env = num_rel_lead + num_rel_trail + 1;
697 
698  if (bs_num_env > 5) {
700  "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
701  bs_num_env);
702  return -1;
703  }
704  ch_data->bs_num_env = bs_num_env;
705 
706  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
707 
708  for (i = 0; i < num_rel_lead; i++)
709  ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
710  for (i = 0; i < num_rel_trail; i++)
711  ch_data->t_env[ch_data->bs_num_env - 1 - i] =
712  ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
713 
714  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
715 
716  get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
717  break;
718  }
719  ch_data->bs_frame_class = bs_frame_class;
720 
721  av_assert0(bs_pointer >= 0);
722  if (bs_pointer > ch_data->bs_num_env + 1) {
724  "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
725  bs_pointer);
726  return -1;
727  }
728 
729  for (i = 1; i <= ch_data->bs_num_env; i++) {
730  if (ch_data->t_env[i-1] >= ch_data->t_env[i]) {
731  av_log(ac->avctx, AV_LOG_ERROR, "Not strictly monotone time borders\n");
732  return -1;
733  }
734  }
735 
736  ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1;
737 
738  ch_data->t_q[0] = ch_data->t_env[0];
739  ch_data->t_q[ch_data->bs_num_noise] = ch_data->t_env[ch_data->bs_num_env];
740  if (ch_data->bs_num_noise > 1) {
741  int idx;
742  if (ch_data->bs_frame_class == FIXFIX) {
743  idx = ch_data->bs_num_env >> 1;
744  } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
745  idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
746  } else { // VARFIX
747  if (!bs_pointer)
748  idx = 1;
749  else if (bs_pointer == 1)
750  idx = ch_data->bs_num_env - 1;
751  else // bs_pointer > 1
752  idx = bs_pointer - 1;
753  }
754  ch_data->t_q[1] = ch_data->t_env[idx];
755  }
756 
757  ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev
758  ch_data->e_a[1] = -1;
759  if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
760  ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer;
761  } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1
762  ch_data->e_a[1] = bs_pointer - 1;
763 
764  return 0;
765 }
766 
767 static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
768  //These variables are saved from the previous frame rather than copied
769  dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env];
770  dst->t_env_num_env_old = dst->t_env[dst->bs_num_env];
771  dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env);
772 
773  //These variables are read from the bitstream and therefore copied
774  memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res));
775  memcpy(dst->t_env, src->t_env, sizeof(dst->t_env));
776  memcpy(dst->t_q, src->t_q, sizeof(dst->t_q));
777  dst->bs_num_env = src->bs_num_env;
778  dst->bs_amp_res = src->bs_amp_res;
779  dst->bs_num_noise = src->bs_num_noise;
780  dst->bs_frame_class = src->bs_frame_class;
781  dst->e_a[1] = src->e_a[1];
782 }
783 
784 /// Read how the envelope and noise floor data is delta coded
786  SBRData *ch_data)
787 {
788  get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
789  get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
790 }
791 
792 /// Read inverse filtering data
794  SBRData *ch_data)
795 {
796  int i;
797 
798  memcpy(ch_data->bs_invf_mode[1], ch_data->bs_invf_mode[0], 5 * sizeof(uint8_t));
799  for (i = 0; i < sbr->n_q; i++)
800  ch_data->bs_invf_mode[0][i] = get_bits(gb, 2);
801 }
802 
804  SBRData *ch_data, int ch)
805 {
806  int bits;
807  int i, j, k;
808  const VLCElem *t_huff, *f_huff;
809  const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
810  const int odd = sbr->n[1] & 1;
811 
812  if (sbr->bs_coupling && ch) {
813  if (ch_data->bs_amp_res) {
814  bits = 5;
817  } else {
818  bits = 6;
821  }
822  } else {
823  if (ch_data->bs_amp_res) {
824  bits = 6;
827  } else {
828  bits = 7;
831  }
832  }
833 
834  for (i = 0; i < ch_data->bs_num_env; i++) {
835  if (ch_data->bs_df_env[i]) {
836  // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
837  if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
838  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
839  ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][j] + delta * get_vlc2(gb, t_huff, 9, 3);
840  if (ch_data->env_facs_q[i + 1][j] > 127U) {
841  av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
842  return AVERROR_INVALIDDATA;
843  }
844  }
845  } else if (ch_data->bs_freq_res[i + 1]) {
846  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
847  k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
848  ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][k] + delta * get_vlc2(gb, t_huff, 9, 3);
849  if (ch_data->env_facs_q[i + 1][j] > 127U) {
850  av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
851  return AVERROR_INVALIDDATA;
852  }
853  }
854  } else {
855  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
856  k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j]
857  ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i][k] + delta * get_vlc2(gb, t_huff, 9, 3);
858  if (ch_data->env_facs_q[i + 1][j] > 127U) {
859  av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
860  return AVERROR_INVALIDDATA;
861  }
862  }
863  }
864  } else {
865  ch_data->env_facs_q[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance
866  for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
867  ch_data->env_facs_q[i + 1][j] = ch_data->env_facs_q[i + 1][j - 1] + delta * get_vlc2(gb, f_huff, 9, 3);
868  if (ch_data->env_facs_q[i + 1][j] > 127U) {
869  av_log(ac->avctx, AV_LOG_ERROR, "env_facs_q %d is invalid\n", ch_data->env_facs_q[i + 1][j]);
870  return AVERROR_INVALIDDATA;
871  }
872  }
873  }
874  }
875 
876  //assign 0th elements of env_facs_q from last elements
877  memcpy(ch_data->env_facs_q[0], ch_data->env_facs_q[ch_data->bs_num_env],
878  sizeof(ch_data->env_facs_q[0]));
879 
880  return 0;
881 }
882 
884  SBRData *ch_data, int ch)
885 {
886  int i, j;
887  const VLCElem *t_huff, *f_huff;
888  int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
889 
890  if (sbr->bs_coupling && ch) {
893  } else {
896  }
897 
898  for (i = 0; i < ch_data->bs_num_noise; i++) {
899  if (ch_data->bs_df_noise[i]) {
900  for (j = 0; j < sbr->n_q; j++) {
901  ch_data->noise_facs_q[i + 1][j] = ch_data->noise_facs_q[i][j] + delta * get_vlc2(gb, t_huff, 9, 2);
902  if (ch_data->noise_facs_q[i + 1][j] > 30U) {
903  av_log(ac->avctx, AV_LOG_ERROR, "noise_facs_q %d is invalid\n", ch_data->noise_facs_q[i + 1][j]);
904  return AVERROR_INVALIDDATA;
905  }
906  }
907  } else {
908  ch_data->noise_facs_q[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
909  for (j = 1; j < sbr->n_q; j++) {
910  ch_data->noise_facs_q[i + 1][j] = ch_data->noise_facs_q[i + 1][j - 1] + delta * get_vlc2(gb, f_huff, 9, 3);
911  if (ch_data->noise_facs_q[i + 1][j] > 30U) {
912  av_log(ac->avctx, AV_LOG_ERROR, "noise_facs_q %d is invalid\n", ch_data->noise_facs_q[i + 1][j]);
913  return AVERROR_INVALIDDATA;
914  }
915  }
916  }
917  }
918 
919  //assign 0th elements of noise_facs_q from last elements
920  memcpy(ch_data->noise_facs_q[0], ch_data->noise_facs_q[ch_data->bs_num_noise],
921  sizeof(ch_data->noise_facs_q[0]));
922  return 0;
923 }
924 
926  GetBitContext *gb,
927  int bs_extension_id, int *num_bits_left)
928 {
929  switch (bs_extension_id) {
930  case EXTENSION_ID_PS:
931  if (!ac->oc[1].m4ac.ps) {
932  av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
933  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
934  *num_bits_left = 0;
935  } else {
936  *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps.common, *num_bits_left);
938  // ensure the warning is not printed if PS extension is present
939  ac->warned_he_aac_mono = 1;
940  }
941  break;
942  default:
943  // some files contain 0-padding
944  if (bs_extension_id || *num_bits_left > 16 || show_bits(gb, *num_bits_left))
945  avpriv_request_sample(ac->avctx, "Reserved SBR extensions");
946  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
947  *num_bits_left = 0;
948  break;
949  }
950 }
951 
954  GetBitContext *gb)
955 {
956  int ret;
957 
958  if (get_bits1(gb)) // bs_data_extra
959  skip_bits(gb, 4); // bs_reserved
960 
961  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
962  return -1;
963  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
964  read_sbr_invf(sbr, gb, &sbr->data[0]);
965  if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
966  return ret;
967  if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
968  return ret;
969 
970  if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
971  get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
972 
973  return 0;
974 }
975 
978  GetBitContext *gb)
979 {
980  int ret;
981 
982  if (get_bits1(gb)) // bs_data_extra
983  skip_bits(gb, 8); // bs_reserved
984 
985  if ((sbr->bs_coupling = get_bits1(gb))) {
986  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
987  return -1;
988  copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
989  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
990  read_sbr_dtdf(sbr, gb, &sbr->data[1]);
991  read_sbr_invf(sbr, gb, &sbr->data[0]);
992  memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
993  memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
994  if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
995  return ret;
996  if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
997  return ret;
998  if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
999  return ret;
1000  if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1001  return ret;
1002  } else {
1003  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
1004  read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
1005  return -1;
1006  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
1007  read_sbr_dtdf(sbr, gb, &sbr->data[1]);
1008  read_sbr_invf(sbr, gb, &sbr->data[0]);
1009  read_sbr_invf(sbr, gb, &sbr->data[1]);
1010  if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1011  return ret;
1012  if((ret = read_sbr_envelope(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1013  return ret;
1014  if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[0], 0)) < 0)
1015  return ret;
1016  if((ret = read_sbr_noise(ac, sbr, gb, &sbr->data[1], 1)) < 0)
1017  return ret;
1018  }
1019 
1020  if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
1021  get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
1022  if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
1023  get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
1024 
1025  return 0;
1026 }
1027 
1029  GetBitContext *gb, int id_aac)
1030 {
1031  unsigned int cnt = get_bits_count(gb);
1032 
1033  sbr->id_aac = id_aac;
1034  sbr->ready_for_dequant = 1;
1035 
1036  if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
1037  if (read_sbr_single_channel_element(ac, sbr, gb)) {
1038  sbr_turnoff(sbr);
1039  return get_bits_count(gb) - cnt;
1040  }
1041  } else if (id_aac == TYPE_CPE) {
1042  if (read_sbr_channel_pair_element(ac, sbr, gb)) {
1043  sbr_turnoff(sbr);
1044  return get_bits_count(gb) - cnt;
1045  }
1046  } else {
1047  av_log(ac->avctx, AV_LOG_ERROR,
1048  "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1049  sbr_turnoff(sbr);
1050  return get_bits_count(gb) - cnt;
1051  }
1052  if (get_bits1(gb)) { // bs_extended_data
1053  int num_bits_left = get_bits(gb, 4); // bs_extension_size
1054  if (num_bits_left == 15)
1055  num_bits_left += get_bits(gb, 8); // bs_esc_count
1056 
1057  num_bits_left <<= 3;
1058  while (num_bits_left > 7) {
1059  num_bits_left -= 2;
1060  read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
1061  }
1062  if (num_bits_left < 0) {
1063  av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");
1064  }
1065  if (num_bits_left > 0)
1066  skip_bits(gb, num_bits_left);
1067  }
1068 
1069  return get_bits_count(gb) - cnt;
1070 }
1071 
1073 {
1074  int err;
1075  err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
1076  if (err >= 0)
1077  err = sbr_make_f_derived(ac, sbr);
1078  if (err < 0) {
1079  av_log(ac->avctx, AV_LOG_ERROR,
1080  "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1081  sbr_turnoff(sbr);
1082  }
1083 }
1084 
1085 /**
1086  * Decode Spectral Band Replication extension data; reference: table 4.55.
1087  *
1088  * @param crc flag indicating the presence of CRC checksum
1089  * @param cnt length of TYPE_FIL syntactic element in bytes
1090  *
1091  * @return Returns number of bytes consumed from the TYPE_FIL element.
1092  */
1094  GetBitContext *gb_host, int crc, int cnt, int id_aac)
1095 {
1096  unsigned int num_sbr_bits = 0, num_align_bits;
1097  unsigned bytes_read;
1098  GetBitContext gbc = *gb_host, *gb = &gbc;
1099  skip_bits_long(gb_host, cnt*8 - 4);
1100 
1101  sbr->reset = 0;
1102 
1103  if (!sbr->sample_rate)
1104  sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
1105  if (!ac->oc[1].m4ac.ext_sample_rate)
1106  ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1107 
1108  if (crc) {
1109  skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1110  num_sbr_bits += 10;
1111  }
1112 
1113  //Save some state from the previous frame.
1114  sbr->kx[0] = sbr->kx[1];
1115  sbr->m[0] = sbr->m[1];
1116  sbr->kx_and_m_pushed = 1;
1117 
1118  num_sbr_bits++;
1119  if (get_bits1(gb)) // bs_header_flag
1120  num_sbr_bits += read_sbr_header(sbr, gb);
1121 
1122  if (sbr->reset)
1123  sbr_reset(ac, sbr);
1124 
1125  if (sbr->start)
1126  num_sbr_bits += read_sbr_data(ac, sbr, gb, id_aac);
1127 
1128  num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1129  bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1130 
1131  if (bytes_read > cnt) {
1132  av_log(ac->avctx, AV_LOG_ERROR,
1133  "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1134  sbr_turnoff(sbr);
1135  }
1136  return cnt;
1137 }
1138 
1139 /**
1140  * Analysis QMF Bank (14496-3 sp04 p206)
1141  *
1142  * @param x pointer to the beginning of the first sample window
1143  * @param W array of complex-valued samples split into subbands
1144  */
1145 #ifndef sbr_qmf_analysis
1146 #if USE_FIXED
1147 static void sbr_qmf_analysis(AVFixedDSPContext *dsp, AVTXContext *mdct,
1148  av_tx_fn mdct_fn,
1149 #else
1151  av_tx_fn mdct_fn,
1152 #endif /* USE_FIXED */
1153  SBRDSPContext *sbrdsp, const INTFLOAT *in, INTFLOAT *x,
1154  INTFLOAT z[320], INTFLOAT W[2][32][32][2], int buf_idx)
1155 {
1156  int i;
1157 #if USE_FIXED
1158  int j;
1159 #endif
1160  memcpy(x , x+1024, (320-32)*sizeof(x[0]));
1161  memcpy(x+288, in, 1024*sizeof(x[0]));
1162  for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
1163  // are not supported
1164  dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
1165  sbrdsp->sum64x5(z);
1166  sbrdsp->qmf_pre_shuffle(z);
1167 #if USE_FIXED
1168  for (j = 64; j < 128; j++) {
1169  if (z[j] > 1<<24) {
1171  "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
1172  z[j], 1<<24);
1173  z[j] = 1<<24;
1174  } else if (z[j] < -(1<<24)) {
1176  "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
1177  z[j], -(1<<24));
1178  z[j] = -(1<<24);
1179  }
1180  }
1181 #endif
1182  mdct_fn(mdct, z, z + 64, sizeof(INTFLOAT));
1183  sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1184  x += 32;
1185  }
1186 }
1187 #endif
1188 
1189 /**
1190  * Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank
1191  * (14496-3 sp04 p206)
1192  */
1193 #ifndef sbr_qmf_synthesis
1194 static void sbr_qmf_synthesis(AVTXContext *mdct, av_tx_fn mdct_fn,
1195 #if USE_FIXED
1196  SBRDSPContext *sbrdsp, AVFixedDSPContext *dsp,
1197 #else
1198  SBRDSPContext *sbrdsp, AVFloatDSPContext *dsp,
1199 #endif /* USE_FIXED */
1200  INTFLOAT *out, INTFLOAT X[2][38][64],
1201  INTFLOAT mdct_buf[2][64],
1202  INTFLOAT *v0, int *v_off, const unsigned int div)
1203 {
1204  int i, n;
1205  const INTFLOAT *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us;
1206  const int step = 128 >> div;
1207  INTFLOAT *v;
1208  for (i = 0; i < 32; i++) {
1209  if (*v_off < step) {
1210  int saved_samples = (1280 - 128) >> div;
1211  memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(INTFLOAT));
1212  *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - step;
1213  } else {
1214  *v_off -= step;
1215  }
1216  v = v0 + *v_off;
1217  if (div) {
1218  for (n = 0; n < 32; n++) {
1219  X[0][i][ n] = -X[0][i][n];
1220  X[0][i][32+n] = X[1][i][31-n];
1221  }
1222  mdct_fn(mdct, mdct_buf[0], X[0][i], sizeof(INTFLOAT));
1223  sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1224  } else {
1225  sbrdsp->neg_odd_64(X[1][i]);
1226  mdct_fn(mdct, mdct_buf[0], X[0][i], sizeof(INTFLOAT));
1227  mdct_fn(mdct, mdct_buf[1], X[1][i], sizeof(INTFLOAT));
1228  sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1229  }
1230  dsp->vector_fmul (out, v , sbr_qmf_window , 64 >> div);
1231  dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1232  dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1233  dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1234  dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1235  dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1236  dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1237  dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1238  dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1239  dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1240  out += 64 >> div;
1241  }
1242 }
1243 #endif
1244 
1245 /// Generate the subband filtered lowband
1247  INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2],
1248  int buf_idx)
1249 {
1250  int i, k;
1251  const int t_HFGen = 8;
1252  const int i_f = 32;
1253  memset(X_low, 0, 32*sizeof(*X_low));
1254  for (k = 0; k < sbr->kx[1]; k++) {
1255  for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1256  X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
1257  X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
1258  }
1259  }
1260  buf_idx = 1-buf_idx;
1261  for (k = 0; k < sbr->kx[0]; k++) {
1262  for (i = 0; i < t_HFGen; i++) {
1263  X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
1264  X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1265  }
1266  }
1267  return 0;
1268 }
1269 
1270 /// High Frequency Generator (14496-3 sp04 p215)
1272  INTFLOAT X_high[64][40][2], const INTFLOAT X_low[32][40][2],
1273  const INTFLOAT (*alpha0)[2], const INTFLOAT (*alpha1)[2],
1274  const INTFLOAT bw_array[5], const uint8_t *t_env,
1275  int bs_num_env)
1276 {
1277  int j, x;
1278  int g = 0;
1279  int k = sbr->kx[1];
1280  for (j = 0; j < sbr->num_patches; j++) {
1281  for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1282  const int p = sbr->patch_start_subband[j] + x;
1283  while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1284  g++;
1285  g--;
1286 
1287  if (g < 0) {
1288  av_log(ac->avctx, AV_LOG_ERROR,
1289  "ERROR : no subband found for frequency %d\n", k);
1290  return -1;
1291  }
1292 
1293  sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET,
1294  X_low[p] + ENVELOPE_ADJUSTMENT_OFFSET,
1295  alpha0[p], alpha1[p], bw_array[g],
1296  2 * t_env[0], 2 * t_env[bs_num_env]);
1297  }
1298  }
1299  if (k < sbr->m[1] + sbr->kx[1])
1300  memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
1301 
1302  return 0;
1303 }
1304 
1305 /// Generate the subband filtered lowband
1306 static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64],
1307  const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2],
1308  const INTFLOAT X_low[32][40][2], int ch)
1309 {
1310  int k, i;
1311  const int i_f = 32;
1312  const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
1313  memset(X, 0, 2*sizeof(*X));
1314  for (k = 0; k < sbr->kx[0]; k++) {
1315  for (i = 0; i < i_Temp; i++) {
1316  X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1317  X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1318  }
1319  }
1320  for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1321  for (i = 0; i < i_Temp; i++) {
1322  X[0][i][k] = Y0[i + i_f][k][0];
1323  X[1][i][k] = Y0[i + i_f][k][1];
1324  }
1325  }
1326 
1327  for (k = 0; k < sbr->kx[1]; k++) {
1328  for (i = i_Temp; i < 38; i++) {
1329  X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1330  X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1331  }
1332  }
1333  for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1334  for (i = i_Temp; i < i_f; i++) {
1335  X[0][i][k] = Y1[i][k][0];
1336  X[1][i][k] = Y1[i][k][1];
1337  }
1338  }
1339  return 0;
1340 }
1341 
1342 /** High Frequency Adjustment (14496-3 sp04 p217) and Mapping
1343  * (14496-3 sp04 p217)
1344  */
1346  SBRData *ch_data, int e_a[2])
1347 {
1348  int e, i, m;
1349 
1350  memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
1351  for (e = 0; e < ch_data->bs_num_env; e++) {
1352  const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
1353  uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1354  int k;
1355 
1356  if (sbr->kx[1] != table[0]) {
1357  av_log(ac->avctx, AV_LOG_ERROR, "kx != f_table{high,low}[0]. "
1358  "Derived frequency tables were not regenerated.\n");
1359  sbr_turnoff(sbr);
1360  return AVERROR_BUG;
1361  }
1362  for (i = 0; i < ilim; i++)
1363  for (m = table[i]; m < table[i + 1]; m++)
1364  sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1365 
1366  // ch_data->bs_num_noise > 1 => 2 noise floors
1367  k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
1368  for (i = 0; i < sbr->n_q; i++)
1369  for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1370  sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
1371 
1372  for (i = 0; i < sbr->n[1]; i++) {
1373  if (ch_data->bs_add_harmonic_flag) {
1374  const unsigned int m_midpoint =
1375  (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
1376 
1377  ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
1378  (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
1379  }
1380  }
1381 
1382  for (i = 0; i < ilim; i++) {
1383  int additional_sinusoid_present = 0;
1384  for (m = table[i]; m < table[i + 1]; m++) {
1385  if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
1386  additional_sinusoid_present = 1;
1387  break;
1388  }
1389  }
1390  memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
1391  (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
1392  }
1393  }
1394 
1395  memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
1396  return 0;
1397 }
1398 
1399 /// Estimation of current envelope (14496-3 sp04 p218)
1400 static void sbr_env_estimate(AAC_FLOAT (*e_curr)[48], INTFLOAT X_high[64][40][2],
1401  SpectralBandReplication *sbr, SBRData *ch_data)
1402 {
1403  int e, m;
1404  int kx1 = sbr->kx[1];
1405 
1406  if (sbr->bs_interpol_freq) {
1407  for (e = 0; e < ch_data->bs_num_env; e++) {
1408 #if USE_FIXED
1409  const SoftFloat recip_env_size = av_int2sf(0x20000000 / (ch_data->t_env[e + 1] - ch_data->t_env[e]), 30);
1410 #else
1411  const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1412 #endif /* USE_FIXED */
1413  int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1414  int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1415 
1416  for (m = 0; m < sbr->m[1]; m++) {
1417  AAC_FLOAT sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb);
1418 #if USE_FIXED
1419  e_curr[e][m] = av_mul_sf(sum, recip_env_size);
1420 #else
1421  e_curr[e][m] = sum * recip_env_size;
1422 #endif /* USE_FIXED */
1423  }
1424  }
1425  } else {
1426  int k, p;
1427 
1428  for (e = 0; e < ch_data->bs_num_env; e++) {
1429  const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1430  int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1431  int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1432  const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1433 
1434  for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
1435 #if USE_FIXED
1436  SoftFloat sum = FLOAT_0;
1437  const SoftFloat den = av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29);
1438  for (k = table[p]; k < table[p + 1]; k++) {
1439  sum = av_add_sf(sum, sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb));
1440  }
1441  sum = av_mul_sf(sum, den);
1442 #else
1443  float sum = 0.0f;
1444  const int den = env_size * (table[p + 1] - table[p]);
1445 
1446  for (k = table[p]; k < table[p + 1]; k++) {
1447  sum += sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb);
1448  }
1449  sum /= den;
1450 #endif /* USE_FIXED */
1451  for (k = table[p]; k < table[p + 1]; k++) {
1452  e_curr[e][k - kx1] = sum;
1453  }
1454  }
1455  }
1456  }
1457 }
1458 
1460  INTFLOAT* L, INTFLOAT* R)
1461 {
1462  int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1463  int ch;
1464  int nch = (id_aac == TYPE_CPE) ? 2 : 1;
1465  int err;
1466 
1467  if (id_aac != sbr->id_aac) {
1468  av_log(ac->avctx, id_aac == TYPE_LFE ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1469  "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
1470  sbr_turnoff(sbr);
1471  }
1472 
1473  if (sbr->start && !sbr->ready_for_dequant) {
1474  av_log(ac->avctx, AV_LOG_ERROR,
1475  "No quantized data read for sbr_dequant.\n");
1476  sbr_turnoff(sbr);
1477  }
1478 
1479  if (!sbr->kx_and_m_pushed) {
1480  sbr->kx[0] = sbr->kx[1];
1481  sbr->m[0] = sbr->m[1];
1482  } else {
1483  sbr->kx_and_m_pushed = 0;
1484  }
1485 
1486  if (sbr->start) {
1487  sbr_dequant(sbr, id_aac);
1488  sbr->ready_for_dequant = 0;
1489  }
1490  for (ch = 0; ch < nch; ch++) {
1491  /* decode channel */
1492  sbr_qmf_analysis(ac->fdsp, sbr->mdct_ana, sbr->mdct_ana_fn, &sbr->dsp,
1493  ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1494  (INTFLOAT*)sbr->qmf_filter_scratch,
1495  sbr->data[ch].W, sbr->data[ch].Ypos);
1496  sbr->c.sbr_lf_gen(sbr, sbr->X_low,
1497  (const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
1498  sbr->data[ch].Ypos);
1499  sbr->data[ch].Ypos ^= 1;
1500  if (sbr->start) {
1501  sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
1502  (const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
1503  sbr_chirp(sbr, &sbr->data[ch]);
1504  av_assert0(sbr->data[ch].bs_num_env > 0);
1505  sbr_hf_gen(ac, sbr, sbr->X_high,
1506  (const INTFLOAT (*)[40][2]) sbr->X_low,
1507  (const INTFLOAT (*)[2]) sbr->alpha0,
1508  (const INTFLOAT (*)[2]) sbr->alpha1,
1509  sbr->data[ch].bw_array, sbr->data[ch].t_env,
1510  sbr->data[ch].bs_num_env);
1511 
1512  // hf_adj
1513  err = sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1514  if (!err) {
1515  sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1516  sbr_gain_calc(sbr, &sbr->data[ch], sbr->data[ch].e_a);
1517  sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1518  (const INTFLOAT (*)[40][2]) sbr->X_high,
1519  sbr, &sbr->data[ch],
1520  sbr->data[ch].e_a);
1521  }
1522  }
1523 
1524  /* synthesis */
1525  sbr->c.sbr_x_gen(sbr, sbr->X[ch],
1526  (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1527  (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[ sbr->data[ch].Ypos],
1528  (const INTFLOAT (*)[40][2]) sbr->X_low, ch);
1529  }
1530 
1531  if (ac->oc[1].m4ac.ps == 1) {
1532  if (sbr->ps.common.start) {
1533  AAC_RENAME(ff_ps_apply)(&sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
1534  } else {
1535  memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
1536  }
1537  nch = 2;
1538  }
1539 
1540  sbr_qmf_synthesis(sbr->mdct, sbr->mdct_fn, &sbr->dsp, ac->fdsp,
1541  L, sbr->X[0], sbr->qmf_filter_scratch,
1542  sbr->data[0].synthesis_filterbank_samples,
1543  &sbr->data[0].synthesis_filterbank_samples_offset,
1544  downsampled);
1545  if (nch == 2)
1546  sbr_qmf_synthesis(sbr->mdct, sbr->mdct_fn, &sbr->dsp, ac->fdsp,
1547  R, sbr->X[1], sbr->qmf_filter_scratch,
1548  sbr->data[1].synthesis_filterbank_samples,
1549  &sbr->data[1].synthesis_filterbank_samples_offset,
1550  downsampled);
1551 }
1552 
1554 {
1555  c->sbr_lf_gen = sbr_lf_gen;
1556  c->sbr_hf_assemble = sbr_hf_assemble;
1557  c->sbr_x_gen = sbr_x_gen;
1558  c->sbr_hf_inverse_filter = sbr_hf_inverse_filter;
1559 
1560 #if !USE_FIXED
1561 #if ARCH_MIPS
1563 #endif
1564 #endif
1565 }
SBRDSPContext::hf_gen
void(* hf_gen)(INTFLOAT(*X_high)[2], const INTFLOAT(*X_low)[2], const INTFLOAT alpha0[2], const INTFLOAT alpha1[2], INTFLOAT bw, int start, int end)
Definition: sbrdsp.h:36
SpectralBandReplication::bs_coupling
unsigned bs_coupling
Definition: sbr.h:157
F_HUFFMAN_ENV_1_5DB
@ F_HUFFMAN_ENV_1_5DB
Definition: aacsbr.h:46
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
sbr_hf_gen
static int sbr_hf_gen(AACDecContext *ac, SpectralBandReplication *sbr, INTFLOAT X_high[64][40][2], const INTFLOAT X_low[32][40][2], const INTFLOAT(*alpha0)[2], const INTFLOAT(*alpha1)[2], const INTFLOAT bw_array[5], const uint8_t *t_env, int bs_num_env)
High Frequency Generator (14496-3 sp04 p215)
Definition: aacsbr_template.c:1271
ff_aac_sbr_init
av_cold void AAC_RENAME() ff_aac_sbr_init(void)
Initialize SBR.
Definition: aacsbr_template.c:48
SpectralBandReplication::data
SBRData data[2]
Definition: sbr.h:167
SpectralBandReplication::bs_limiter_gains
unsigned bs_limiter_gains
Definition: sbr.h:153
Q23
#define Q23(x)
Definition: aac_defines.h:96
SBRDSPContext
Definition: sbrdsp.h:27
out
FILE * out
Definition: movenc.c:55
elements
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
AACDecContext::warned_he_aac_mono
int warned_he_aac_mono
Definition: aacdec.h:263
SpectralBandReplication::e_origmapped
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:199
log2f
#define log2f(x)
Definition: libm.h:409
SBRData::env_facs
AAC_FLOAT env_facs[6][48]
Definition: sbr.h:101
sbr_chirp
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr.c:212
ff_aac_sbr_ctx_init
av_cold int AAC_RENAME() ff_aac_sbr_ctx_init(AACDecContext *ac, SpectralBandReplication *sbr, int id_aac)
Initialize one SBR context.
Definition: aacsbr_template.c:67
AVTXContext
Definition: tx_priv.h:235
ff_aac_sbr_ctx_close
av_cold void AAC_RENAME() ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
Close one SBR context.
Definition: aacsbr_template.c:105
AVFloatDSPContext::vector_fmul_reverse
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:152
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
ff_ps_apply
int AAC_RENAME() ff_ps_apply(PSContext *ps, INTFLOAT L[2][38][64], INTFLOAT R[2][38][64], int top)
Definition: aacps.c:719
sbr_hf_inverse_filter
static void sbr_hf_inverse_filter(SBRDSPContext *dsp, float(*alpha0)[2], float(*alpha1)[2], const float X_low[32][40][2], int k0)
High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering (14496-3 sp04 p214) Warning: Thi...
Definition: aacsbr.c:157
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
ff_ps_read_data
int ff_ps_read_data(void *logctx, GetBitContext *gb, PSCommonContext *ps, int bits_left)
Definition: aacps_common.c:122
SpectralBandReplication::m
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:163
aacdectab.h
b
#define b
Definition: input.c:41
read_sbr_noise
static int read_sbr_noise(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
Definition: aacsbr_template.c:883
table
static const uint16_t table[]
Definition: prosumer.c:205
SBRData::t_env_num_env_old
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
Definition: sbr.h:108
SpectrumParameters::bs_alter_scale
uint8_t bs_alter_scale
Definition: sbr.h:53
R
#define R
Definition: huffyuv.h:44
copy_sbr_grid
static void copy_sbr_grid(SBRData *dst, const SBRData *src)
Definition: aacsbr_template.c:767
SpectrumParameters::bs_start_freq
uint8_t bs_start_freq
Definition: sbr.h:44
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
ff_ps_init
av_cold void AAC_RENAME() ff_ps_init(void)
Definition: aacps.c:740
AVFixedDSPContext
Definition: fixed_dsp.h:55
SBRData::t_env
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:106
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
qsort_comparison_function_int16
static int qsort_comparison_function_int16(const void *a, const void *b)
Definition: aacsbr_template.c:111
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:903
sbr_qmf_analysis
static void sbr_qmf_analysis(AVFloatDSPContext *dsp, AVTXContext *mdct, av_tx_fn mdct_fn, SBRDSPContext *sbrdsp, const INTFLOAT *in, INTFLOAT *x, INTFLOAT z[320], INTFLOAT W[2][32][32][2], int buf_idx)
Analysis QMF Bank (14496-3 sp04 p206)
Definition: aacsbr_template.c:1150
SpectralBandReplication::ready_for_dequant
int ready_for_dequant
Definition: sbr.h:143
sbr_gain_calc
static void sbr_gain_calc(SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Calculation of levels of additional HF signal components (14496-3 sp04 p219) and Calculation of gain ...
Definition: aacsbr.c:236
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
SBRData::e_a
int e_a[2]
l_APrev and l_A
Definition: sbr.h:88
FIXVAR
@ FIXVAR
Definition: aacsbr.h:62
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
SpectralBandReplication::bs_interpol_freq
unsigned bs_interpol_freq
Definition: sbr.h:154
v0
#define v0
Definition: regdef.h:26
sbr_make_f_master
static int sbr_make_f_master(AACDecContext *ac, SpectralBandReplication *sbr, SpectrumParameters *spectrum)
Master Frequency Band Table (14496-3 sp04 p194)
Definition: aacsbr_template.c:257
SpectralBandReplication::n_master
AAC_SIGNE n_master
The number of frequency bands in f_master.
Definition: sbr.h:166
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:44
GetBitContext
Definition: get_bits.h:108
SBRData::bs_add_harmonic_flag
unsigned bs_add_harmonic_flag
Definition: sbr.h:69
SpectralBandReplication::reset
int reset
Definition: sbr.h:145
PSContext::common
PSCommonContext common
Definition: aacps.h:72
T_HUFFMAN_NOISE_3_0DB
@ T_HUFFMAN_NOISE_3_0DB
Definition: aacsbr.h:53
sbr_lf_gen
static int sbr_lf_gen(SpectralBandReplication *sbr, INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2], int buf_idx)
Generate the subband filtered lowband.
Definition: aacsbr_template.c:1246
SBRData::noise_facs
AAC_FLOAT noise_facs[3][5]
Definition: sbr.h:104
sbr_hf_assemble
static void sbr_hf_assemble(float Y1[38][64][2], const float X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Assembling HF Signals (14496-3 sp04 p220)
Definition: aacsbr.c:293
read_sbr_single_channel_element
static int read_sbr_single_channel_element(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
Definition: aacsbr_template.c:952
sbr_qmf_window_ds
static INTFLOAT sbr_qmf_window_ds[320]
Definition: aacsbrdata.h:45
USE_FIXED
#define USE_FIXED
Definition: aac_defines.h:25
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
SpectrumParameters::bs_stop_freq
uint8_t bs_stop_freq
Definition: sbr.h:45
av_cold
#define av_cold
Definition: attributes.h:90
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
SBRData::bs_df_noise
uint8_t bs_df_noise[2]
Definition: sbr.h:74
read_sbr_grid
static int read_sbr_grid(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Definition: aacsbr_template.c:620
ff_decode_sbr_extension
int AAC_RENAME() ff_decode_sbr_extension(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb_host, int crc, int cnt, int id_aac)
Decode Spectral Band Replication extension data; reference: table 4.55.
Definition: aacsbr_template.c:1093
AV_TX_INT32_MDCT
@ AV_TX_INT32_MDCT
Definition: tx.h:70
g
const char * g
Definition: vf_curves.c:128
SBRData::bs_num_noise
AAC_SIGNE bs_num_noise
Definition: sbr.h:72
VARFIX
@ VARFIX
Definition: aacsbr.h:63
bits
uint8_t bits
Definition: vp3data.h:128
read_sbr_header
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
Definition: aacsbr_template.c:177
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
read_sbr_extension
static void read_sbr_extension(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int bs_extension_id, int *num_bits_left)
Definition: aacsbr_template.c:925
sbr_offset
static const int8_t sbr_offset[6][16]
window coefficients for analysis/synthesis QMF banks
Definition: aacsbrdata.h:35
T_HUFFMAN_ENV_3_0DB
@ T_HUFFMAN_ENV_3_0DB
Definition: aacsbr.h:49
SpectrumParameters::bs_xover_band
uint8_t bs_xover_band
Definition: sbr.h:46
SpectralBandReplication::f_tablenoise
uint16_t f_tablenoise[6]
Frequency borders for noise floors.
Definition: sbr.h:182
VARVAR
@ VARVAR
Definition: aacsbr.h:64
if
if(ret)
Definition: filter_design.txt:179
SpectralBandReplication::n_lim
AAC_SIGNE n_lim
Number of limiter bands.
Definition: sbr.h:174
SBRData::env_facs_q
uint8_t env_facs_q[6][48]
Envelope scalefactors.
Definition: sbr.h:100
NULL
#define NULL
Definition: coverity.c:32
SpectralBandReplication::f_tablelow
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
Definition: sbr.h:178
FLOAT_0
static const SoftFloat FLOAT_0
0.0
Definition: softfloat.h:39
SBRData::f_indexnoise
unsigned f_indexnoise
Definition: sbr.h:111
SBRData::bs_df_env
uint8_t bs_df_env[5]
Definition: sbr.h:73
check_n_master
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
Definition: aacsbr_template.c:240
SpectrumParameters::bs_freq_scale
uint8_t bs_freq_scale
Definition: sbr.h:52
SpectralBandReplication::f_tablelim
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:184
F_HUFFMAN_ENV_3_0DB
@ F_HUFFMAN_ENV_3_0DB
Definition: aacsbr.h:50
SBRData::bs_add_harmonic
uint8_t bs_add_harmonic[48]
Definition: sbr.h:76
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
AACSBRContext
aacsbr functions pointers
Definition: sbr.h:121
fixed_log
static int fixed_log(int x)
Definition: aacsbr_fixed.c:84
ff_sbr_apply
void AAC_RENAME() ff_sbr_apply(AACDecContext *ac, SpectralBandReplication *sbr, int id_aac, INTFLOAT *L, INTFLOAT *R)
Apply one SBR element to one AAC element.
Definition: aacsbr_template.c:1459
SBR_SYNTHESIS_BUF_SIZE
#define SBR_SYNTHESIS_BUF_SIZE
Definition: sbr.h:58
make_bands
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr.c:71
SpectralBandReplication::n
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition: sbr.h:170
SBRData::bs_num_env
AAC_SIGNE bs_num_env
Definition: sbr.h:70
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:652
SBRData::bs_amp_res
unsigned bs_amp_res
Definition: sbr.h:77
SBRData::s_indexmapped
uint8_t s_indexmapped[8][48]
Definition: sbr.h:98
read_sbr_dtdf
static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read how the envelope and noise floor data is delta coded.
Definition: aacsbr_template.c:785
SpectralBandReplication::bs_smoothing_mode
unsigned bs_smoothing_mode
Definition: sbr.h:155
sbr_x_gen
static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64], const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2], const INTFLOAT X_low[32][40][2], int ch)
Generate the subband filtered lowband.
Definition: aacsbr_template.c:1306
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
SpectrumParameters
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
Definition: sbr.h:43
sbr_qmf_synthesis
static void sbr_qmf_synthesis(AVTXContext *mdct, av_tx_fn mdct_fn, SBRDSPContext *sbrdsp, AVFloatDSPContext *dsp, INTFLOAT *out, INTFLOAT X[2][38][64], INTFLOAT mdct_buf[2][64], INTFLOAT *v0, int *v_off, const unsigned int div)
Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank (14496-3 sp04 p206)
Definition: aacsbr_template.c:1194
SpectralBandReplication::f_master
uint16_t f_master[49]
The master QMF frequency grouping.
Definition: sbr.h:176
qsort.h
f
f
Definition: af_crystalizer.c:121
sbr_mapping
static int sbr_mapping(AACDecContext *ac, SpectralBandReplication *sbr, SBRData *ch_data, int e_a[2])
High Frequency Adjustment (14496-3 sp04 p217) and Mapping (14496-3 sp04 p217)
Definition: aacsbr_template.c:1345
AVFloatDSPContext::vector_fmul
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats.
Definition: float_dsp.h:36
SpectralBandReplication::sample_rate
int sample_rate
Definition: sbr.h:141
VLCElem
Definition: vlc.h:32
sbr_turnoff
static void sbr_turnoff(SpectralBandReplication *sbr)
Places SBR in pure upsampling mode.
Definition: aacsbr_template.c:56
SpectralBandReplication
Spectral Band Replication.
Definition: sbr.h:140
AVFloatDSPContext
Definition: float_dsp.h:22
SpectralBandReplication::bs_amp_res_header
int bs_amp_res_header
Definition: sbr.h:147
SBRData::bs_invf_mode
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:75
read_sbr_envelope
static int read_sbr_envelope(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
Definition: aacsbr_template.c:803
T_HUFFMAN_NOISE_BAL_3_0DB
@ T_HUFFMAN_NOISE_BAL_3_0DB
Definition: aacsbr.h:54
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
ff_aacsbr_func_ptr_init_mips
void ff_aacsbr_func_ptr_init_mips(AACSBRContext *c)
Definition: aacsbr_mips.c:612
SBRData::bs_freq_res
uint8_t bs_freq_res[7]
Definition: sbr.h:71
SpectralBandReplication::n_q
AAC_SIGNE n_q
Number of noise floor bands.
Definition: sbr.h:172
SpectralBandReplication::patch_start_subband
uint8_t patch_start_subband[6]
Definition: sbr.h:187
CONST_076923
static const int CONST_076923
Definition: aacsbr_fixed.c:76
EXTENSION_ID_PS
@ EXTENSION_ID_PS
Definition: aacsbr.h:68
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:295
ff_sbrdsp_init
void AAC_RENAME() ff_sbrdsp_init(SBRDSPContext *s)
Definition: sbrdsp_template.c:80
aacsbr_func_ptr_init
static void aacsbr_func_ptr_init(AACSBRContext *c)
Definition: aacsbr_template.c:1553
X
@ X
Definition: vf_addroi.c:27
SpectralBandReplication::id_aac
int id_aac
Definition: sbr.h:144
SoftFloat
Definition: softfloat.h:34
CONST_RECIP_LN2
static const int CONST_RECIP_LN2
Definition: aacsbr_fixed.c:75
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ceil_log2
static const int8_t ceil_log2[]
ceil(log2(index+1))
Definition: aacsbr_template.c:616
AV_QSORT
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
Definition: qsort.h:33
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
SBRData
Spectral Band Replication per channel data.
Definition: sbr.h:63
SpectralBandReplication::k
AAC_SIGNE k[5]
k0, k1, k2
Definition: sbr.h:158
FIXFIX
@ FIXFIX
Definition: aacsbr.h:61
AVFloatDSPContext::vector_fmul_add
void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)
Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the...
Definition: float_dsp.h:135
delta
float delta
Definition: vorbis_enc_data.h:430
in_table_int16
static int in_table_int16(const int16_t *table, int last_el, int16_t needle)
Definition: aacsbr_template.c:116
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_int2sf
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
Definition: softfloat.h:185
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:46
F_HUFFMAN_ENV_BAL_1_5DB
@ F_HUFFMAN_ENV_BAL_1_5DB
Definition: aacsbr.h:48
SBRData::bs_frame_class
unsigned bs_frame_class
Definition: sbr.h:68
AAC_RENAME
#define AAC_RENAME(x)
Definition: aac_defines.h:86
sbr_make_f_tablelim
static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
Limiter Frequency Band Table (14496-3 sp04 p198)
Definition: aacsbr_template.c:126
TYPE_SCE
@ TYPE_SCE
Definition: aac.h:43
AACDecContext::oc
OutputConfiguration oc[2]
Definition: aacdec.h:258
sbr_make_f_derived
static int sbr_make_f_derived(AACDecContext *ac, SpectralBandReplication *sbr)
Derived Frequency Band Tables (14496-3 sp04 p197)
Definition: aacsbr_template.c:535
avcodec.h
read_sbr_invf
static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read inverse filtering data.
Definition: aacsbr_template.c:793
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:111
ret
ret
Definition: filter_design.txt:187
sbr_dequant
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr.c:90
array_min_int16
static int array_min_int16(const int16_t *array, int nel)
Definition: aacsbr_template.c:232
U
#define U(x)
Definition: vpx_arith.h:37
aacdec.h
AACDecContext
main AAC decoding context
Definition: aacdec.h:186
sbr_hf_calc_npatches
static int sbr_hf_calc_npatches(AACDecContext *ac, SpectralBandReplication *sbr)
High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
Definition: aacsbr_template.c:477
aacsbr_tableinit
static av_cold void aacsbr_tableinit(void)
Definition: aacsbr_template.c:40
AVCodecContext
main external API structure.
Definition: avcodec.h:445
T_HUFFMAN_ENV_BAL_1_5DB
@ T_HUFFMAN_ENV_BAL_1_5DB
Definition: aacsbr.h:47
AV_PROFILE_AAC_HE_V2
#define AV_PROFILE_AAC_HE_V2
Definition: defs.h:73
AACDecContext::avctx
struct AVCodecContext * avctx
Definition: aacdec.h:188
MPEG4AudioConfig::ps
int ps
-1 implicit, 1 presence
Definition: mpeg4audio.h:40
T_HUFFMAN_ENV_1_5DB
@ T_HUFFMAN_ENV_1_5DB
Definition: aacsbr.h:45
sbr_env_estimate
static void sbr_env_estimate(AAC_FLOAT(*e_curr)[48], INTFLOAT X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data)
Estimation of current envelope (14496-3 sp04 p218)
Definition: aacsbr_template.c:1400
T_HUFFMAN_ENV_BAL_3_0DB
@ T_HUFFMAN_ENV_BAL_3_0DB
Definition: aacsbr.h:51
SBRData::t_q
uint8_t t_q[3]
Noise time borders.
Definition: sbr.h:110
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
SpectralBandReplication::spectrum_params
SpectrumParameters spectrum_params
Definition: sbr.h:146
av_add_sf
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:162
W
@ W
Definition: vf_addroi.c:27
temp
else temp
Definition: vf_mcdeint.c:263
sbr_qmf_window_us
static const INTFLOAT sbr_qmf_window_us[640]
Definition: aacsbrdata.h:48
L
#define L(x)
Definition: vpx_arith.h:36
SpectralBandReplication::f_tablehigh
uint16_t f_tablehigh[49]
Frequency borders for high resolution SBR.
Definition: sbr.h:180
SBRData::noise_facs_q
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition: sbr.h:103
sbr_reset
static void sbr_reset(AACDecContext *ac, SpectralBandReplication *sbr)
Definition: aacsbr_template.c:1072
SpectralBandReplication::bs_limiter_bands
unsigned bs_limiter_bands
Definition: sbr.h:152
SpectralBandReplication::patch_num_subbands
uint8_t patch_num_subbands[6]
Definition: sbr.h:186
OutputConfiguration::m4ac
MPEG4AudioConfig m4ac
Definition: aacdec.h:160
TYPE_CCE
@ TYPE_CCE
Definition: aac.h:45
SpectralBandReplication::start
int start
Definition: sbr.h:142
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
SBRDSPContext::sum_square
AAC_FLOAT(* sum_square)(INTFLOAT(*x)[2], int n)
Definition: sbrdsp.h:29
ff_ps_ctx_init
static void AAC_RENAME() ff_ps_ctx_init(PSContext *ps)
Definition: aacps.h:97
ENVELOPE_ADJUSTMENT_OFFSET
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.h:36
ff_aac_sbr_vlc
const VLCElem * ff_aac_sbr_vlc[10]
Definition: aacdec_common.c:260
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AAC_FLOAT
float AAC_FLOAT
Definition: aac_defines.h:92
read_sbr_channel_pair_element
static int read_sbr_channel_pair_element(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
Definition: aacsbr_template.c:976
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
SpectrumParameters::bs_noise_bands
uint8_t bs_noise_bands
Definition: sbr.h:54
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
read_sbr_data
static unsigned int read_sbr_data(AACDecContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac)
Definition: aacsbr_template.c:1028
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
SpectralBandReplication::q_mapped
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:201
get_bits1_vector
static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, int elements)
Definition: aacsbr_template.c:606
int
int
Definition: ffmpeg_filter.c:424
SpectralBandReplication::kx
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:161
av_mul_sf
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:102
INTFLOAT
float INTFLOAT
Definition: aac_defines.h:88
SpectralBandReplication::s_mapped
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
Definition: sbr.h:203
F_HUFFMAN_ENV_BAL_3_0DB
@ F_HUFFMAN_ENV_BAL_3_0DB
Definition: aacsbr.h:52
SpectralBandReplication::ps
PSContext ps
Definition: sbr.h:168
min
float min
Definition: vorbis_enc_data.h:429
SpectralBandReplication::num_patches
AAC_SIGNE num_patches
Definition: sbr.h:185
SpectralBandReplication::dsp
SBRDSPContext dsp
Definition: sbr.h:216