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