aacsbr.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  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
29 #include "aac.h"
30 #include "sbr.h"
31 #include "aacsbr.h"
32 #include "aacsbrdata.h"
33 #include "fft.h"
34 #include "aacps.h"
35 #include "sbrdsp.h"
36 #include "libavutil/libm.h"
37 
38 #include <stdint.h>
39 #include <float.h>
40 
41 #define ENVELOPE_ADJUSTMENT_OFFSET 2
42 #define NOISE_FLOOR_OFFSET 6.0f
43 
47 enum {
58 };
59 
63 enum {
68 };
69 
70 enum {
72 };
73 
74 static VLC vlc_sbr[10];
75 static const int8_t vlc_sbr_lav[10] =
76  { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };
77 
78 #define SBR_INIT_VLC_STATIC(num, size) \
79  INIT_VLC_STATIC(&vlc_sbr[num], 9, sbr_tmp[num].table_size / sbr_tmp[num].elem_size, \
80  sbr_tmp[num].sbr_bits , 1, 1, \
81  sbr_tmp[num].sbr_codes, sbr_tmp[num].elem_size, sbr_tmp[num].elem_size, \
82  size)
83 
84 #define SBR_VLC_ROW(name) \
85  { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) }
86 
88 {
89  int n;
90  static const struct {
91  const void *sbr_codes, *sbr_bits;
92  const unsigned int table_size, elem_size;
93  } sbr_tmp[] = {
94  SBR_VLC_ROW(t_huffman_env_1_5dB),
95  SBR_VLC_ROW(f_huffman_env_1_5dB),
96  SBR_VLC_ROW(t_huffman_env_bal_1_5dB),
97  SBR_VLC_ROW(f_huffman_env_bal_1_5dB),
98  SBR_VLC_ROW(t_huffman_env_3_0dB),
99  SBR_VLC_ROW(f_huffman_env_3_0dB),
100  SBR_VLC_ROW(t_huffman_env_bal_3_0dB),
101  SBR_VLC_ROW(f_huffman_env_bal_3_0dB),
102  SBR_VLC_ROW(t_huffman_noise_3_0dB),
103  SBR_VLC_ROW(t_huffman_noise_bal_3_0dB),
104  };
105 
106  // SBR VLC table initialization
107  SBR_INIT_VLC_STATIC(0, 1098);
108  SBR_INIT_VLC_STATIC(1, 1092);
109  SBR_INIT_VLC_STATIC(2, 768);
110  SBR_INIT_VLC_STATIC(3, 1026);
111  SBR_INIT_VLC_STATIC(4, 1058);
112  SBR_INIT_VLC_STATIC(5, 1052);
113  SBR_INIT_VLC_STATIC(6, 544);
114  SBR_INIT_VLC_STATIC(7, 544);
115  SBR_INIT_VLC_STATIC(8, 592);
116  SBR_INIT_VLC_STATIC(9, 512);
117 
118  for (n = 1; n < 320; n++)
119  sbr_qmf_window_us[320 + n] = sbr_qmf_window_us[320 - n];
122 
123  for (n = 0; n < 320; n++)
125 
126  ff_ps_init();
127 }
128 
131  sbr->start = 0;
132  // Init defults used in pure upsampling mode
133  sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
134  sbr->m[1] = 0;
135  // Reset values for first SBR header
136  sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
137  memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters));
138 }
139 
141 {
142  sbr->kx[0] = sbr->kx[1];
143  sbr_turnoff(sbr);
146  /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
147  * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
148  * and scale back down at synthesis. */
149  ff_mdct_init(&sbr->mdct, 7, 1, 1.0 / (64 * 32768.0));
150  ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * 32768.0);
151  ff_ps_ctx_init(&sbr->ps);
152  ff_sbrdsp_init(&sbr->dsp);
153 }
154 
156 {
157  ff_mdct_end(&sbr->mdct);
158  ff_mdct_end(&sbr->mdct_ana);
159 }
160 
161 static int qsort_comparison_function_int16(const void *a, const void *b)
162 {
163  return *(const int16_t *)a - *(const int16_t *)b;
164 }
165 
166 static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)
167 {
168  int i;
169  for (i = 0; i <= last_el; i++)
170  if (table[i] == needle)
171  return 1;
172  return 0;
173 }
174 
177 {
178  int k;
179  if (sbr->bs_limiter_bands > 0) {
180  static const float bands_warped[3] = { 1.32715174233856803909f, //2^(0.49/1.2)
181  1.18509277094158210129f, //2^(0.49/2)
182  1.11987160404675912501f }; //2^(0.49/3)
183  const float lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
184  int16_t patch_borders[7];
185  uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
186 
187  patch_borders[0] = sbr->kx[1];
188  for (k = 1; k <= sbr->num_patches; k++)
189  patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
190 
191  memcpy(sbr->f_tablelim, sbr->f_tablelow,
192  (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
193  if (sbr->num_patches > 1)
194  memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
195  (sbr->num_patches - 1) * sizeof(patch_borders[0]));
196 
197  qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
198  sizeof(sbr->f_tablelim[0]),
200 
201  sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
202  while (out < sbr->f_tablelim + sbr->n_lim) {
203  if (*in >= *out * lim_bands_per_octave_warped) {
204  *++out = *in++;
205  } else if (*in == *out ||
206  !in_table_int16(patch_borders, sbr->num_patches, *in)) {
207  in++;
208  sbr->n_lim--;
209  } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
210  *out = *in++;
211  sbr->n_lim--;
212  } else {
213  *++out = *in++;
214  }
215  }
216  } else {
217  sbr->f_tablelim[0] = sbr->f_tablelow[0];
218  sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
219  sbr->n_lim = 1;
220  }
221 }
222 
224 {
225  unsigned int cnt = get_bits_count(gb);
226  uint8_t bs_header_extra_1;
227  uint8_t bs_header_extra_2;
228  int old_bs_limiter_bands = sbr->bs_limiter_bands;
229  SpectrumParameters old_spectrum_params;
230 
231  sbr->start = 1;
232 
233  // Save last spectrum parameters variables to compare to new ones
234  memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
235 
236  sbr->bs_amp_res_header = get_bits1(gb);
237  sbr->spectrum_params.bs_start_freq = get_bits(gb, 4);
238  sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4);
239  sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
240  skip_bits(gb, 2); // bs_reserved
241 
242  bs_header_extra_1 = get_bits1(gb);
243  bs_header_extra_2 = get_bits1(gb);
244 
245  if (bs_header_extra_1) {
246  sbr->spectrum_params.bs_freq_scale = get_bits(gb, 2);
249  } else {
253  }
254 
255  // Check if spectrum parameters changed
256  if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
257  sbr->reset = 1;
258 
259  if (bs_header_extra_2) {
260  sbr->bs_limiter_bands = get_bits(gb, 2);
261  sbr->bs_limiter_gains = get_bits(gb, 2);
262  sbr->bs_interpol_freq = get_bits1(gb);
263  sbr->bs_smoothing_mode = get_bits1(gb);
264  } else {
265  sbr->bs_limiter_bands = 2;
266  sbr->bs_limiter_gains = 2;
267  sbr->bs_interpol_freq = 1;
268  sbr->bs_smoothing_mode = 1;
269  }
270 
271  if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
272  sbr_make_f_tablelim(sbr);
273 
274  return get_bits_count(gb) - cnt;
275 }
276 
277 static int array_min_int16(const int16_t *array, int nel)
278 {
279  int i, min = array[0];
280  for (i = 1; i < nel; i++)
281  min = FFMIN(array[i], min);
282  return min;
283 }
284 
285 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
286 {
287  int k, previous, present;
288  float base, prod;
289 
290  base = powf((float)stop / start, 1.0f / num_bands);
291  prod = start;
292  previous = start;
293 
294  for (k = 0; k < num_bands-1; k++) {
295  prod *= base;
296  present = lrintf(prod);
297  bands[k] = present - previous;
298  previous = present;
299  }
300  bands[num_bands-1] = stop - previous;
301 }
302 
303 static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
304 {
305  // Requirements (14496-3 sp04 p205)
306  if (n_master <= 0) {
307  av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
308  return -1;
309  }
310  if (bs_xover_band >= n_master) {
311  av_log(avctx, AV_LOG_ERROR,
312  "Invalid bitstream, crossover band index beyond array bounds: %d\n",
313  bs_xover_band);
314  return -1;
315  }
316  return 0;
317 }
318 
321  SpectrumParameters *spectrum)
322 {
323  unsigned int temp, max_qmf_subbands;
324  unsigned int start_min, stop_min;
325  int k;
326  const int8_t *sbr_offset_ptr;
327  int16_t stop_dk[13];
328 
329  if (sbr->sample_rate < 32000) {
330  temp = 3000;
331  } else if (sbr->sample_rate < 64000) {
332  temp = 4000;
333  } else
334  temp = 5000;
335 
336  start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
337  stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
338 
339  switch (sbr->sample_rate) {
340  case 16000:
341  sbr_offset_ptr = sbr_offset[0];
342  break;
343  case 22050:
344  sbr_offset_ptr = sbr_offset[1];
345  break;
346  case 24000:
347  sbr_offset_ptr = sbr_offset[2];
348  break;
349  case 32000:
350  sbr_offset_ptr = sbr_offset[3];
351  break;
352  case 44100: case 48000: case 64000:
353  sbr_offset_ptr = sbr_offset[4];
354  break;
355  case 88200: case 96000: case 128000: case 176400: case 192000:
356  sbr_offset_ptr = sbr_offset[5];
357  break;
358  default:
360  "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
361  return -1;
362  }
363 
364  sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
365 
366  if (spectrum->bs_stop_freq < 14) {
367  sbr->k[2] = stop_min;
368  make_bands(stop_dk, stop_min, 64, 13);
369  qsort(stop_dk, 13, sizeof(stop_dk[0]), qsort_comparison_function_int16);
370  for (k = 0; k < spectrum->bs_stop_freq; k++)
371  sbr->k[2] += stop_dk[k];
372  } else if (spectrum->bs_stop_freq == 14) {
373  sbr->k[2] = 2*sbr->k[0];
374  } else if (spectrum->bs_stop_freq == 15) {
375  sbr->k[2] = 3*sbr->k[0];
376  } else {
378  "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
379  return -1;
380  }
381  sbr->k[2] = FFMIN(64, sbr->k[2]);
382 
383  // Requirements (14496-3 sp04 p205)
384  if (sbr->sample_rate <= 32000) {
385  max_qmf_subbands = 48;
386  } else if (sbr->sample_rate == 44100) {
387  max_qmf_subbands = 35;
388  } else if (sbr->sample_rate >= 48000)
389  max_qmf_subbands = 32;
390 
391  if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
393  "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
394  return -1;
395  }
396 
397  if (!spectrum->bs_freq_scale) {
398  int dk, k2diff;
399 
400  dk = spectrum->bs_alter_scale + 1;
401  sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
403  return -1;
404 
405  for (k = 1; k <= sbr->n_master; k++)
406  sbr->f_master[k] = dk;
407 
408  k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
409  if (k2diff < 0) {
410  sbr->f_master[1]--;
411  sbr->f_master[2]-= (k2diff < -1);
412  } else if (k2diff) {
413  sbr->f_master[sbr->n_master]++;
414  }
415 
416  sbr->f_master[0] = sbr->k[0];
417  for (k = 1; k <= sbr->n_master; k++)
418  sbr->f_master[k] += sbr->f_master[k - 1];
419 
420  } else {
421  int half_bands = 7 - spectrum->bs_freq_scale; // bs_freq_scale = {1,2,3}
422  int two_regions, num_bands_0;
423  int vdk0_max, vdk1_min;
424  int16_t vk0[49];
425 
426  if (49 * sbr->k[2] > 110 * sbr->k[0]) {
427  two_regions = 1;
428  sbr->k[1] = 2 * sbr->k[0];
429  } else {
430  two_regions = 0;
431  sbr->k[1] = sbr->k[2];
432  }
433 
434  num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
435 
436  if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
437  av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
438  return -1;
439  }
440 
441  vk0[0] = 0;
442 
443  make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
444 
445  qsort(vk0 + 1, num_bands_0, sizeof(vk0[1]), qsort_comparison_function_int16);
446  vdk0_max = vk0[num_bands_0];
447 
448  vk0[0] = sbr->k[0];
449  for (k = 1; k <= num_bands_0; k++) {
450  if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
451  av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
452  return -1;
453  }
454  vk0[k] += vk0[k-1];
455  }
456 
457  if (two_regions) {
458  int16_t vk1[49];
459  float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f
460  : 1.0f; // bs_alter_scale = {0,1}
461  int num_bands_1 = lrintf(half_bands * invwarp *
462  log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
463 
464  make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
465 
466  vdk1_min = array_min_int16(vk1 + 1, num_bands_1);
467 
468  if (vdk1_min < vdk0_max) {
469  int change;
470  qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
471  change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
472  vk1[1] += change;
473  vk1[num_bands_1] -= change;
474  }
475 
476  qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
477 
478  vk1[0] = sbr->k[1];
479  for (k = 1; k <= num_bands_1; k++) {
480  if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
481  av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
482  return -1;
483  }
484  vk1[k] += vk1[k-1];
485  }
486 
487  sbr->n_master = num_bands_0 + num_bands_1;
489  return -1;
490  memcpy(&sbr->f_master[0], vk0,
491  (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
492  memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
493  num_bands_1 * sizeof(sbr->f_master[0]));
494 
495  } else {
496  sbr->n_master = num_bands_0;
498  return -1;
499  memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
500  }
501  }
502 
503  return 0;
504 }
505 
508 {
509  int i, k, sb = 0;
510  int msb = sbr->k[0];
511  int usb = sbr->kx[1];
512  int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
513 
514  sbr->num_patches = 0;
515 
516  if (goal_sb < sbr->kx[1] + sbr->m[1]) {
517  for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
518  } else
519  k = sbr->n_master;
520 
521  do {
522  int odd = 0;
523  for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
524  sb = sbr->f_master[i];
525  odd = (sb + sbr->k[0]) & 1;
526  }
527 
528  // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
529  // After this check the final number of patches can still be six which is
530  // illegal however the Coding Technologies decoder check stream has a final
531  // count of 6 patches
532  if (sbr->num_patches > 5) {
533  av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
534  return -1;
535  }
536 
537  sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
538  sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
539 
540  if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
541  usb = sb;
542  msb = sb;
543  sbr->num_patches++;
544  } else
545  msb = sbr->kx[1];
546 
547  if (sbr->f_master[k] - sb < 3)
548  k = sbr->n_master;
549  } while (sb != sbr->kx[1] + sbr->m[1]);
550 
551  if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
552  sbr->num_patches--;
553 
554  return 0;
555 }
556 
559 {
560  int k, temp;
561 
562  sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
563  sbr->n[0] = (sbr->n[1] + 1) >> 1;
564 
565  memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
566  (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
567  sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
568  sbr->kx[1] = sbr->f_tablehigh[0];
569 
570  // Requirements (14496-3 sp04 p205)
571  if (sbr->kx[1] + sbr->m[1] > 64) {
573  "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
574  return -1;
575  }
576  if (sbr->kx[1] > 32) {
577  av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
578  return -1;
579  }
580 
581  sbr->f_tablelow[0] = sbr->f_tablehigh[0];
582  temp = sbr->n[1] & 1;
583  for (k = 1; k <= sbr->n[0]; k++)
584  sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
585 
587  log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
588  if (sbr->n_q > 5) {
589  av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
590  return -1;
591  }
592 
593  sbr->f_tablenoise[0] = sbr->f_tablelow[0];
594  temp = 0;
595  for (k = 1; k <= sbr->n_q; k++) {
596  temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
597  sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
598  }
599 
600  if (sbr_hf_calc_npatches(ac, sbr) < 0)
601  return -1;
602 
603  sbr_make_f_tablelim(sbr);
604 
605  sbr->data[0].f_indexnoise = 0;
606  sbr->data[1].f_indexnoise = 0;
607 
608  return 0;
609 }
610 
612  int elements)
613 {
614  int i;
615  for (i = 0; i < elements; i++) {
616  vec[i] = get_bits1(gb);
617  }
618 }
619 
621 static const int8_t ceil_log2[] = {
622  0, 1, 2, 2, 3, 3,
623 };
624 
626  GetBitContext *gb, SBRData *ch_data)
627 {
628  int i;
629  unsigned bs_pointer = 0;
630  // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
631  int abs_bord_trail = 16;
632  int num_rel_lead, num_rel_trail;
633  unsigned bs_num_env_old = ch_data->bs_num_env;
634 
635  ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
636  ch_data->bs_amp_res = sbr->bs_amp_res_header;
637  ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
638 
639  switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
640  case FIXFIX:
641  ch_data->bs_num_env = 1 << get_bits(gb, 2);
642  num_rel_lead = ch_data->bs_num_env - 1;
643  if (ch_data->bs_num_env == 1)
644  ch_data->bs_amp_res = 0;
645 
646  if (ch_data->bs_num_env > 4) {
648  "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
649  ch_data->bs_num_env);
650  return -1;
651  }
652 
653  ch_data->t_env[0] = 0;
654  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
655 
656  abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
657  ch_data->bs_num_env;
658  for (i = 0; i < num_rel_lead; i++)
659  ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
660 
661  ch_data->bs_freq_res[1] = get_bits1(gb);
662  for (i = 1; i < ch_data->bs_num_env; i++)
663  ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
664  break;
665  case FIXVAR:
666  abs_bord_trail += get_bits(gb, 2);
667  num_rel_trail = get_bits(gb, 2);
668  ch_data->bs_num_env = num_rel_trail + 1;
669  ch_data->t_env[0] = 0;
670  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
671 
672  for (i = 0; i < num_rel_trail; i++)
673  ch_data->t_env[ch_data->bs_num_env - 1 - i] =
674  ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
675 
676  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
677 
678  for (i = 0; i < ch_data->bs_num_env; i++)
679  ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
680  break;
681  case VARFIX:
682  ch_data->t_env[0] = get_bits(gb, 2);
683  num_rel_lead = get_bits(gb, 2);
684  ch_data->bs_num_env = num_rel_lead + 1;
685  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
686 
687  for (i = 0; i < num_rel_lead; i++)
688  ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
689 
690  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
691 
692  get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
693  break;
694  case VARVAR:
695  ch_data->t_env[0] = get_bits(gb, 2);
696  abs_bord_trail += get_bits(gb, 2);
697  num_rel_lead = get_bits(gb, 2);
698  num_rel_trail = get_bits(gb, 2);
699  ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1;
700 
701  if (ch_data->bs_num_env > 5) {
703  "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
704  ch_data->bs_num_env);
705  return -1;
706  }
707 
708  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
709 
710  for (i = 0; i < num_rel_lead; i++)
711  ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
712  for (i = 0; i < num_rel_trail; i++)
713  ch_data->t_env[ch_data->bs_num_env - 1 - i] =
714  ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
715 
716  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
717 
718  get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
719  break;
720  }
721 
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, "Non 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  unsigned 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 
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 
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  VLC_TYPE (*t_huff)[2], (*f_huff)[2];
809  int t_lav, f_lav;
810  const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
811  const int odd = sbr->n[1] & 1;
812 
813  if (sbr->bs_coupling && ch) {
814  if (ch_data->bs_amp_res) {
815  bits = 5;
816  t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_3_0DB].table;
818  f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
820  } else {
821  bits = 6;
822  t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_1_5DB].table;
824  f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_1_5DB].table;
826  }
827  } else {
828  if (ch_data->bs_amp_res) {
829  bits = 6;
830  t_huff = vlc_sbr[T_HUFFMAN_ENV_3_0DB].table;
832  f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
834  } else {
835  bits = 7;
836  t_huff = vlc_sbr[T_HUFFMAN_ENV_1_5DB].table;
838  f_huff = vlc_sbr[F_HUFFMAN_ENV_1_5DB].table;
840  }
841  }
842 
843  for (i = 0; i < ch_data->bs_num_env; i++) {
844  if (ch_data->bs_df_env[i]) {
845  // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
846  if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
847  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
848  ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
849  } else if (ch_data->bs_freq_res[i + 1]) {
850  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
851  k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
852  ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
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[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
858  }
859  }
860  } else {
861  ch_data->env_facs[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance
862  for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
863  ch_data->env_facs[i + 1][j] = ch_data->env_facs[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav);
864  }
865  }
866 
867  //assign 0th elements of env_facs from last elements
868  memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env],
869  sizeof(ch_data->env_facs[0]));
870 }
871 
873  SBRData *ch_data, int ch)
874 {
875  int i, j;
876  VLC_TYPE (*t_huff)[2], (*f_huff)[2];
877  int t_lav, f_lav;
878  int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
879 
880  if (sbr->bs_coupling && ch) {
881  t_huff = vlc_sbr[T_HUFFMAN_NOISE_BAL_3_0DB].table;
883  f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
885  } else {
886  t_huff = vlc_sbr[T_HUFFMAN_NOISE_3_0DB].table;
888  f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
890  }
891 
892  for (i = 0; i < ch_data->bs_num_noise; i++) {
893  if (ch_data->bs_df_noise[i]) {
894  for (j = 0; j < sbr->n_q; j++)
895  ch_data->noise_facs[i + 1][j] = ch_data->noise_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 2) - t_lav);
896  } else {
897  ch_data->noise_facs[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
898  for (j = 1; j < sbr->n_q; j++)
899  ch_data->noise_facs[i + 1][j] = ch_data->noise_facs[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav);
900  }
901  }
902 
903  //assign 0th elements of noise_facs from last elements
904  memcpy(ch_data->noise_facs[0], ch_data->noise_facs[ch_data->bs_num_noise],
905  sizeof(ch_data->noise_facs[0]));
906 }
907 
909  GetBitContext *gb,
910  int bs_extension_id, int *num_bits_left)
911 {
912  switch (bs_extension_id) {
913  case EXTENSION_ID_PS:
914  if (!ac->oc[1].m4ac.ps) {
915  av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
916  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
917  *num_bits_left = 0;
918  } else {
919 #if 1
920  *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps, *num_bits_left);
921 #else
922  av_log_missing_feature(ac->avctx, "Parametric Stereo", 0);
923  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
924  *num_bits_left = 0;
925 #endif
926  }
927  break;
928  default:
929  av_log_missing_feature(ac->avctx, "Reserved SBR extensions", 1);
930  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
931  *num_bits_left = 0;
932  break;
933  }
934 }
935 
938  GetBitContext *gb)
939 {
940  if (get_bits1(gb)) // bs_data_extra
941  skip_bits(gb, 4); // bs_reserved
942 
943  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
944  return -1;
945  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
946  read_sbr_invf(sbr, gb, &sbr->data[0]);
947  read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
948  read_sbr_noise(sbr, gb, &sbr->data[0], 0);
949 
950  if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
951  get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
952 
953  return 0;
954 }
955 
958  GetBitContext *gb)
959 {
960  if (get_bits1(gb)) // bs_data_extra
961  skip_bits(gb, 8); // bs_reserved
962 
963  if ((sbr->bs_coupling = get_bits1(gb))) {
964  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
965  return -1;
966  copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
967  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
968  read_sbr_dtdf(sbr, gb, &sbr->data[1]);
969  read_sbr_invf(sbr, gb, &sbr->data[0]);
970  memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
971  memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
972  read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
973  read_sbr_noise(sbr, gb, &sbr->data[0], 0);
974  read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
975  read_sbr_noise(sbr, gb, &sbr->data[1], 1);
976  } else {
977  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
978  read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
979  return -1;
980  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
981  read_sbr_dtdf(sbr, gb, &sbr->data[1]);
982  read_sbr_invf(sbr, gb, &sbr->data[0]);
983  read_sbr_invf(sbr, gb, &sbr->data[1]);
984  read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
985  read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
986  read_sbr_noise(sbr, gb, &sbr->data[0], 0);
987  read_sbr_noise(sbr, gb, &sbr->data[1], 1);
988  }
989 
990  if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
991  get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
992  if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
993  get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
994 
995  return 0;
996 }
997 
998 static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
999  GetBitContext *gb, int id_aac)
1000 {
1001  unsigned int cnt = get_bits_count(gb);
1002 
1003  if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
1004  if (read_sbr_single_channel_element(ac, sbr, gb)) {
1005  sbr_turnoff(sbr);
1006  return get_bits_count(gb) - cnt;
1007  }
1008  } else if (id_aac == TYPE_CPE) {
1009  if (read_sbr_channel_pair_element(ac, sbr, gb)) {
1010  sbr_turnoff(sbr);
1011  return get_bits_count(gb) - cnt;
1012  }
1013  } else {
1014  av_log(ac->avctx, AV_LOG_ERROR,
1015  "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1016  sbr_turnoff(sbr);
1017  return get_bits_count(gb) - cnt;
1018  }
1019  if (get_bits1(gb)) { // bs_extended_data
1020  int num_bits_left = get_bits(gb, 4); // bs_extension_size
1021  if (num_bits_left == 15)
1022  num_bits_left += get_bits(gb, 8); // bs_esc_count
1023 
1024  num_bits_left <<= 3;
1025  while (num_bits_left > 7) {
1026  num_bits_left -= 2;
1027  read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
1028  }
1029  if (num_bits_left < 0) {
1030  av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");
1031  }
1032  if (num_bits_left > 0)
1033  skip_bits(gb, num_bits_left);
1034  }
1035 
1036  return get_bits_count(gb) - cnt;
1037 }
1038 
1040 {
1041  int err;
1042  err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
1043  if (err >= 0)
1044  err = sbr_make_f_derived(ac, sbr);
1045  if (err < 0) {
1046  av_log(ac->avctx, AV_LOG_ERROR,
1047  "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1048  sbr_turnoff(sbr);
1049  }
1050 }
1051 
1061  GetBitContext *gb_host, int crc, int cnt, int id_aac)
1062 {
1063  unsigned int num_sbr_bits = 0, num_align_bits;
1064  unsigned bytes_read;
1065  GetBitContext gbc = *gb_host, *gb = &gbc;
1066  skip_bits_long(gb_host, cnt*8 - 4);
1067 
1068  sbr->reset = 0;
1069 
1070  if (!sbr->sample_rate)
1071  sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
1072  if (!ac->oc[1].m4ac.ext_sample_rate)
1073  ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
1074 
1075  if (crc) {
1076  skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1077  num_sbr_bits += 10;
1078  }
1079 
1080  //Save some state from the previous frame.
1081  sbr->kx[0] = sbr->kx[1];
1082  sbr->m[0] = sbr->m[1];
1083  sbr->kx_and_m_pushed = 1;
1084 
1085  num_sbr_bits++;
1086  if (get_bits1(gb)) // bs_header_flag
1087  num_sbr_bits += read_sbr_header(sbr, gb);
1088 
1089  if (sbr->reset)
1090  sbr_reset(ac, sbr);
1091 
1092  if (sbr->start)
1093  num_sbr_bits += read_sbr_data(ac, sbr, gb, id_aac);
1094 
1095  num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1096  bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1097 
1098  if (bytes_read > cnt) {
1099  av_log(ac->avctx, AV_LOG_ERROR,
1100  "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1101  }
1102  return cnt;
1103 }
1104 
1106 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
1107 {
1108  int k, e;
1109  int ch;
1110 
1111  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
1112  float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f;
1113  float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f;
1114  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
1115  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
1116  float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f);
1117  float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha);
1118  float fac = temp1 / (1.0f + temp2);
1119  sbr->data[0].env_facs[e][k] = fac;
1120  sbr->data[1].env_facs[e][k] = fac * temp2;
1121  }
1122  }
1123  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
1124  for (k = 0; k < sbr->n_q; k++) {
1125  float temp1 = exp2f(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs[e][k] + 1);
1126  float temp2 = exp2f(12 - sbr->data[1].noise_facs[e][k]);
1127  float fac = temp1 / (1.0f + temp2);
1128  sbr->data[0].noise_facs[e][k] = fac;
1129  sbr->data[1].noise_facs[e][k] = fac * temp2;
1130  }
1131  }
1132  } else { // SCE or one non-coupled CPE
1133  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
1134  float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f;
1135  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
1136  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++)
1137  sbr->data[ch].env_facs[e][k] =
1138  exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f);
1139  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
1140  for (k = 0; k < sbr->n_q; k++)
1141  sbr->data[ch].noise_facs[e][k] =
1142  exp2f(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs[e][k]);
1143  }
1144  }
1145 }
1146 
1153 static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct,
1154  SBRDSPContext *sbrdsp, const float *in, float *x,
1155  float z[320], float W[2][32][32][2], int buf_idx)
1156 {
1157  int i;
1158  memcpy(x , x+1024, (320-32)*sizeof(x[0]));
1159  memcpy(x+288, in, 1024*sizeof(x[0]));
1160  for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
1161  // are not supported
1162  dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
1163  sbrdsp->sum64x5(z);
1164  sbrdsp->qmf_pre_shuffle(z);
1165  mdct->imdct_half(mdct, z, z+64);
1166  sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
1167  x += 32;
1168  }
1169 }
1170 
1175 static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
1176  SBRDSPContext *sbrdsp, AVFloatDSPContext *fdsp,
1177  float *out, float X[2][38][64],
1178  float mdct_buf[2][64],
1179  float *v0, int *v_off, const unsigned int div)
1180 {
1181  int i, n;
1182  const float *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us;
1183  const int step = 128 >> div;
1184  float *v;
1185  for (i = 0; i < 32; i++) {
1186  if (*v_off < step) {
1187  int saved_samples = (1280 - 128) >> div;
1188  memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(float));
1189  *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - step;
1190  } else {
1191  *v_off -= step;
1192  }
1193  v = v0 + *v_off;
1194  if (div) {
1195  for (n = 0; n < 32; n++) {
1196  X[0][i][ n] = -X[0][i][n];
1197  X[0][i][32+n] = X[1][i][31-n];
1198  }
1199  mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
1200  sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
1201  } else {
1202  sbrdsp->neg_odd_64(X[1][i]);
1203  mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
1204  mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
1205  sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
1206  }
1207  fdsp->vector_fmul (out, v , sbr_qmf_window , 64 >> div);
1208  dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1209  dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1210  dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1211  dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1212  dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1213  dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1214  dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1215  dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1216  dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1217  out += 64 >> div;
1218  }
1219 }
1220 
1226  float (*alpha0)[2], float (*alpha1)[2],
1227  const float X_low[32][40][2], int k0)
1228 {
1229  int k;
1230  for (k = 0; k < k0; k++) {
1231  LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
1232  float dk;
1233 
1234  dsp->autocorrelate(X_low[k], phi);
1235 
1236  dk = phi[2][1][0] * phi[1][0][0] -
1237  (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
1238 
1239  if (!dk) {
1240  alpha1[k][0] = 0;
1241  alpha1[k][1] = 0;
1242  } else {
1243  float temp_real, temp_im;
1244  temp_real = phi[0][0][0] * phi[1][1][0] -
1245  phi[0][0][1] * phi[1][1][1] -
1246  phi[0][1][0] * phi[1][0][0];
1247  temp_im = phi[0][0][0] * phi[1][1][1] +
1248  phi[0][0][1] * phi[1][1][0] -
1249  phi[0][1][1] * phi[1][0][0];
1250 
1251  alpha1[k][0] = temp_real / dk;
1252  alpha1[k][1] = temp_im / dk;
1253  }
1254 
1255  if (!phi[1][0][0]) {
1256  alpha0[k][0] = 0;
1257  alpha0[k][1] = 0;
1258  } else {
1259  float temp_real, temp_im;
1260  temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
1261  alpha1[k][1] * phi[1][1][1];
1262  temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
1263  alpha1[k][0] * phi[1][1][1];
1264 
1265  alpha0[k][0] = -temp_real / phi[1][0][0];
1266  alpha0[k][1] = -temp_im / phi[1][0][0];
1267  }
1268 
1269  if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
1270  alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
1271  alpha1[k][0] = 0;
1272  alpha1[k][1] = 0;
1273  alpha0[k][0] = 0;
1274  alpha0[k][1] = 0;
1275  }
1276  }
1277 }
1278 
1280 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
1281 {
1282  int i;
1283  float new_bw;
1284  static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
1285 
1286  for (i = 0; i < sbr->n_q; i++) {
1287  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
1288  new_bw = 0.6f;
1289  } else
1290  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
1291 
1292  if (new_bw < ch_data->bw_array[i]) {
1293  new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i];
1294  } else
1295  new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
1296  ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
1297  }
1298 }
1299 
1302  float X_low[32][40][2], const float W[2][32][32][2],
1303  int buf_idx)
1304 {
1305  int i, k;
1306  const int t_HFGen = 8;
1307  const int i_f = 32;
1308  memset(X_low, 0, 32*sizeof(*X_low));
1309  for (k = 0; k < sbr->kx[1]; k++) {
1310  for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1311  X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
1312  X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
1313  }
1314  }
1315  buf_idx = 1-buf_idx;
1316  for (k = 0; k < sbr->kx[0]; k++) {
1317  for (i = 0; i < t_HFGen; i++) {
1318  X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
1319  X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
1320  }
1321  }
1322  return 0;
1323 }
1324 
1327  float X_high[64][40][2], const float X_low[32][40][2],
1328  const float (*alpha0)[2], const float (*alpha1)[2],
1329  const float bw_array[5], const uint8_t *t_env,
1330  int bs_num_env)
1331 {
1332  int j, x;
1333  int g = 0;
1334  int k = sbr->kx[1];
1335  for (j = 0; j < sbr->num_patches; j++) {
1336  for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1337  const int p = sbr->patch_start_subband[j] + x;
1338  while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1339  g++;
1340  g--;
1341 
1342  if (g < 0) {
1343  av_log(ac->avctx, AV_LOG_ERROR,
1344  "ERROR : no subband found for frequency %d\n", k);
1345  return -1;
1346  }
1347 
1348  sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET,
1349  X_low[p] + ENVELOPE_ADJUSTMENT_OFFSET,
1350  alpha0[p], alpha1[p], bw_array[g],
1351  2 * t_env[0], 2 * t_env[bs_num_env]);
1352  }
1353  }
1354  if (k < sbr->m[1] + sbr->kx[1])
1355  memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
1356 
1357  return 0;
1358 }
1359 
1361 static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64],
1362  const float Y0[38][64][2], const float Y1[38][64][2],
1363  const float X_low[32][40][2], int ch)
1364 {
1365  int k, i;
1366  const int i_f = 32;
1367  const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
1368  memset(X, 0, 2*sizeof(*X));
1369  for (k = 0; k < sbr->kx[0]; k++) {
1370  for (i = 0; i < i_Temp; i++) {
1371  X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1372  X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1373  }
1374  }
1375  for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1376  for (i = 0; i < i_Temp; i++) {
1377  X[0][i][k] = Y0[i + i_f][k][0];
1378  X[1][i][k] = Y0[i + i_f][k][1];
1379  }
1380  }
1381 
1382  for (k = 0; k < sbr->kx[1]; k++) {
1383  for (i = i_Temp; i < 38; i++) {
1384  X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1385  X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1386  }
1387  }
1388  for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1389  for (i = i_Temp; i < i_f; i++) {
1390  X[0][i][k] = Y1[i][k][0];
1391  X[1][i][k] = Y1[i][k][1];
1392  }
1393  }
1394  return 0;
1395 }
1396 
1401  SBRData *ch_data, int e_a[2])
1402 {
1403  int e, i, m;
1404 
1405  memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
1406  for (e = 0; e < ch_data->bs_num_env; e++) {
1407  const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
1408  uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1409  int k;
1410 
1411  if (sbr->kx[1] != table[0]) {
1412  av_log(ac->avctx, AV_LOG_ERROR, "kx != f_table{high,low}[0]. "
1413  "Derived frequency tables were not regenerated.\n");
1414  sbr_turnoff(sbr);
1415  return AVERROR_BUG;
1416  }
1417  for (i = 0; i < ilim; i++)
1418  for (m = table[i]; m < table[i + 1]; m++)
1419  sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1420 
1421  // ch_data->bs_num_noise > 1 => 2 noise floors
1422  k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
1423  for (i = 0; i < sbr->n_q; i++)
1424  for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1425  sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
1426 
1427  for (i = 0; i < sbr->n[1]; i++) {
1428  if (ch_data->bs_add_harmonic_flag) {
1429  const unsigned int m_midpoint =
1430  (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
1431 
1432  ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
1433  (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
1434  }
1435  }
1436 
1437  for (i = 0; i < ilim; i++) {
1438  int additional_sinusoid_present = 0;
1439  for (m = table[i]; m < table[i + 1]; m++) {
1440  if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
1441  additional_sinusoid_present = 1;
1442  break;
1443  }
1444  }
1445  memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
1446  (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
1447  }
1448  }
1449 
1450  memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
1451  return 0;
1452 }
1453 
1455 static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
1456  SpectralBandReplication *sbr, SBRData *ch_data)
1457 {
1458  int e, m;
1459  int kx1 = sbr->kx[1];
1460 
1461  if (sbr->bs_interpol_freq) {
1462  for (e = 0; e < ch_data->bs_num_env; e++) {
1463  const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1464  int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1465  int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1466 
1467  for (m = 0; m < sbr->m[1]; m++) {
1468  float sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb);
1469  e_curr[e][m] = sum * recip_env_size;
1470  }
1471  }
1472  } else {
1473  int k, p;
1474 
1475  for (e = 0; e < ch_data->bs_num_env; e++) {
1476  const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1477  int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1478  int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1479  const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1480 
1481  for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
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  for (k = table[p]; k < table[p + 1]; k++) {
1490  e_curr[e][k - kx1] = sum;
1491  }
1492  }
1493  }
1494  }
1495 }
1496 
1502  SBRData *ch_data, const int e_a[2])
1503 {
1504  int e, k, m;
1505  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
1506  static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
1507 
1508  for (e = 0; e < ch_data->bs_num_env; e++) {
1509  int delta = !((e == e_a[1]) || (e == e_a[0]));
1510  for (k = 0; k < sbr->n_lim; k++) {
1511  float gain_boost, gain_max;
1512  float sum[2] = { 0.0f, 0.0f };
1513  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1514  const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
1515  sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
1516  sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
1517  if (!sbr->s_mapped[e][m]) {
1518  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
1519  ((1.0f + sbr->e_curr[e][m]) *
1520  (1.0f + sbr->q_mapped[e][m] * delta)));
1521  } else {
1522  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
1523  ((1.0f + sbr->e_curr[e][m]) *
1524  (1.0f + sbr->q_mapped[e][m])));
1525  }
1526  }
1527  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1528  sum[0] += sbr->e_origmapped[e][m];
1529  sum[1] += sbr->e_curr[e][m];
1530  }
1531  gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
1532  gain_max = FFMIN(100000.f, gain_max);
1533  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1534  float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
1535  sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
1536  sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
1537  }
1538  sum[0] = sum[1] = 0.0f;
1539  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1540  sum[0] += sbr->e_origmapped[e][m];
1541  sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
1542  + sbr->s_m[e][m] * sbr->s_m[e][m]
1543  + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
1544  }
1545  gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
1546  gain_boost = FFMIN(1.584893192f, gain_boost);
1547  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1548  sbr->gain[e][m] *= gain_boost;
1549  sbr->q_m[e][m] *= gain_boost;
1550  sbr->s_m[e][m] *= gain_boost;
1551  }
1552  }
1553  }
1554 }
1555 
1557 static void sbr_hf_assemble(float Y1[38][64][2],
1558  const float X_high[64][40][2],
1559  SpectralBandReplication *sbr, SBRData *ch_data,
1560  const int e_a[2])
1561 {
1562  int e, i, j, m;
1563  const int h_SL = 4 * !sbr->bs_smoothing_mode;
1564  const int kx = sbr->kx[1];
1565  const int m_max = sbr->m[1];
1566  static const float h_smooth[5] = {
1567  0.33333333333333,
1568  0.30150283239582,
1569  0.21816949906249,
1570  0.11516383427084,
1571  0.03183050093751,
1572  };
1573  static const int8_t phi[2][4] = {
1574  { 1, 0, -1, 0}, // real
1575  { 0, 1, 0, -1}, // imaginary
1576  };
1577  float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
1578  int indexnoise = ch_data->f_indexnoise;
1579  int indexsine = ch_data->f_indexsine;
1580 
1581  if (sbr->reset) {
1582  for (i = 0; i < h_SL; i++) {
1583  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
1584  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
1585  }
1586  } else if (h_SL) {
1587  memcpy(g_temp[2*ch_data->t_env[0]], g_temp[2*ch_data->t_env_num_env_old], 4*sizeof(g_temp[0]));
1588  memcpy(q_temp[2*ch_data->t_env[0]], q_temp[2*ch_data->t_env_num_env_old], 4*sizeof(q_temp[0]));
1589  }
1590 
1591  for (e = 0; e < ch_data->bs_num_env; e++) {
1592  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
1593  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
1594  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
1595  }
1596  }
1597 
1598  for (e = 0; e < ch_data->bs_num_env; e++) {
1599  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
1600  int phi_sign = (1 - 2*(kx & 1));
1601  LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
1602  LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
1603  float *g_filt, *q_filt;
1604 
1605  if (h_SL && e != e_a[0] && e != e_a[1]) {
1606  g_filt = g_filt_tab;
1607  q_filt = q_filt_tab;
1608  for (m = 0; m < m_max; m++) {
1609  const int idx1 = i + h_SL;
1610  g_filt[m] = 0.0f;
1611  q_filt[m] = 0.0f;
1612  for (j = 0; j <= h_SL; j++) {
1613  g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
1614  q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
1615  }
1616  }
1617  } else {
1618  g_filt = g_temp[i + h_SL];
1619  q_filt = q_temp[i];
1620  }
1621 
1622  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
1624 
1625  if (e != e_a[0] && e != e_a[1]) {
1626  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
1627  q_filt, indexnoise,
1628  kx, m_max);
1629  } else {
1630  for (m = 0; m < m_max; m++) {
1631  Y1[i][m + kx][0] +=
1632  sbr->s_m[e][m] * phi[0][indexsine];
1633  Y1[i][m + kx][1] +=
1634  sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1635  phi_sign = -phi_sign;
1636  }
1637  }
1638  indexnoise = (indexnoise + m_max) & 0x1ff;
1639  indexsine = (indexsine + 1) & 3;
1640  }
1641  }
1642  ch_data->f_indexnoise = indexnoise;
1643  ch_data->f_indexsine = indexsine;
1644 }
1645 
1647  float* L, float* R)
1648 {
1649  int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
1650  int ch;
1651  int nch = (id_aac == TYPE_CPE) ? 2 : 1;
1652  int err;
1653 
1654  if (!sbr->kx_and_m_pushed) {
1655  sbr->kx[0] = sbr->kx[1];
1656  sbr->m[0] = sbr->m[1];
1657  } else {
1658  sbr->kx_and_m_pushed = 0;
1659  }
1660 
1661  if (sbr->start) {
1662  sbr_dequant(sbr, id_aac);
1663  }
1664  for (ch = 0; ch < nch; ch++) {
1665  /* decode channel */
1666  sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, &sbr->dsp, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1667  (float*)sbr->qmf_filter_scratch,
1668  sbr->data[ch].W, sbr->data[ch].Ypos);
1669  sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W, sbr->data[ch].Ypos);
1670  sbr->data[ch].Ypos ^= 1;
1671  if (sbr->start) {
1672  sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
1673  sbr_chirp(sbr, &sbr->data[ch]);
1674  sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
1675  sbr->data[ch].bw_array, sbr->data[ch].t_env,
1676  sbr->data[ch].bs_num_env);
1677 
1678  // hf_adj
1679  err = sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1680  if (!err) {
1681  sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1682  sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1683  sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
1684  sbr->X_high, sbr, &sbr->data[ch],
1685  sbr->data[ch].e_a);
1686  }
1687  }
1688 
1689  /* synthesis */
1690  sbr_x_gen(sbr, sbr->X[ch],
1691  sbr->data[ch].Y[1-sbr->data[ch].Ypos],
1692  sbr->data[ch].Y[ sbr->data[ch].Ypos],
1693  sbr->X_low, ch);
1694  }
1695 
1696  if (ac->oc[1].m4ac.ps == 1) {
1697  if (sbr->ps.start) {
1698  ff_ps_apply(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
1699  } else {
1700  memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
1701  }
1702  nch = 2;
1703  }
1704 
1705  sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, &sbr->dsp, &ac->fdsp,
1706  L, sbr->X[0], sbr->qmf_filter_scratch,
1709  downsampled);
1710  if (nch == 2)
1711  sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, &sbr->dsp, &ac->fdsp,
1712  R, sbr->X[1], sbr->qmf_filter_scratch,
1715  downsampled);
1716 }
uint8_t s_indexmapped[8][48]
Definition: sbr.h:95
unsigned bs_add_harmonic_flag
Definition: sbr.h:66
float alpha1[64][2]
First coefficient used to filter the subband signals.
Definition: sbr.h:169
float e_curr[7][48]
Estimated envelope.
Definition: sbr.h:177
static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
Derived Frequency Band Tables (14496-3 sp04 p197)
Definition: aacsbr.c:558
int ff_ps_apply(AVCodecContext *avctx, PSContext *ps, float L[2][38][64], float R[2][38][64], int top)
Definition: aacps.c:887
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:1557
unsigned bs_smoothing_mode
Definition: sbr.h:127
static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
Definition: aacsbr.c:872
AVCodecContext * avctx
Definition: aac.h:264
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:197
float Y[2][38][64][2]
Definition: sbr.h:92
static void copy_sbr_grid(SBRData *dst, const SBRData *src)
Definition: aacsbr.c:767
void(* sum64x5)(float *z)
Definition: sbrdsp.h:27
float X[2][2][38][64]
QMF values of the reconstructed signal.
Definition: sbr.h:165
float(* sum_square)(float(*x)[2], int n)
Definition: sbrdsp.h:28
Definition: aac.h:50
Definition: aac.h:51
void(* qmf_deint_neg)(float *v, const float *src)
Definition: sbrdsp.h:32
int e_a[2]
l_APrev and l_A
Definition: sbr.h:85
av_cold void ff_aac_sbr_init(void)
Initialize SBR.
Definition: aacsbr.c:87
unsigned kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:133
float q_m[7][48]
Amplitude adjusted noise scalefactors.
Definition: sbr.h:179
float q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:173
unsigned n_lim
Number of limiter bands.
Definition: sbr.h:146
static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr, float X_high[64][40][2], const float X_low[32][40][2], const float(*alpha0)[2], const float(*alpha1)[2], const float bw_array[5], const uint8_t *t_env, int bs_num_env)
High Frequency Generator (14496-3 sp04 p215)
Definition: aacsbr.c:1326
static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Definition: aacsbr.c:625
#define VLC_TYPE
Definition: get_bits.h:61
float e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:171
FFTContext mdct
Definition: sbr.h:185
uint8_t bs_xover_band
Definition: sbr.h:43
SpectrumParameters spectrum_params
Definition: sbr.h:118
Definition: aac.h:52
av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
Close one SBR context.
Definition: aacsbr.c:155
float bw_array[5]
Chirp factors.
Definition: sbr.h:87
float qmf_filter_scratch[5][64]
Definition: sbr.h:183
unsigned kx_and_m_pushed
Definition: sbr.h:136
unsigned n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition: sbr.h:142
static const int8_t sbr_offset[6][16]
window coefficients for analysis/synthesis QMF banks
Definition: aacsbrdata.h:260
uint8_t bits
Definition: crc.c:31
uint8_t
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
Definition: aacsbr.c:303
Definition: aacsbr.c:65
float delta
uint16_t f_tablehigh[49]
Frequency borders for high resolution SBR.
Definition: sbr.h:152
#define b
Definition: input.c:52
static float sbr_qmf_window_us[640]
Definition: aacsbrdata.h:271
static int qsort_comparison_function_int16(const void *a, const void *b)
Definition: aacsbr.c:161
int 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.c:1060
#define R
Definition: dsputil.c:1899
#define SBR_INIT_VLC_STATIC(num, size)
Definition: aacsbr.c:78
float env_facs[6][48]
Envelope scalefactors.
Definition: sbr.h:97
AAC Spectral Band Replication decoding data.
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.c:41
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
void(* qmf_deint_bfly)(float *v, const float *src0, const float *src1)
Definition: sbrdsp.h:33
SBRData data[2]
Definition: sbr.h:139
static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
Definition: aacsbr.c:223
DSPContext dsp
Definition: aac.h:294
uint8_t bs_df_noise[2]
Definition: sbr.h:71
#define LOCAL_ALIGNED_16(t, v,...)
Definition: dsputil.h:602
static void sbr_env_estimate(float(*e_curr)[48], float X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data)
Estimation of current envelope (14496-3 sp04 p218)
Definition: aacsbr.c:1455
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.c:1400
static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec, int elements)
Definition: aacsbr.c:611
static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr, SpectrumParameters *spectrum)
Master Frequency Band Table (14496-3 sp04 p194)
Definition: aacsbr.c:320
uint8_t patch_num_subbands[6]
Definition: sbr.h:158
static int array_min_int16(const int16_t *array, int nel)
Definition: aacsbr.c:277
uint16_t f_tablenoise[6]
Frequency borders for noise floors.
Definition: sbr.h:154
Definition: aacsbr.c:64
float gain[7][48]
Definition: sbr.h:182
void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)
Definition: dsputil.h:356
MPEG4AudioConfig m4ac
Definition: aac.h:117
uint8_t t_q[3]
Noise time borders.
Definition: sbr.h:105
uint16_t f_tablelow[25]
Frequency borders for low resolution SBR.
Definition: sbr.h:150
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:1225
Definition: aacsbr.c:67
Spectral Band Replication header - spectrum parameters that invoke a reset if they differ from the pr...
Definition: sbr.h:40
static int read_sbr_channel_pair_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
Definition: aacsbr.c:956
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:36
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr.c:1106
unsigned num_patches
Definition: sbr.h:157
av_cold void ff_ps_ctx_init(PSContext *ps)
Definition: aacps.c:949
static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64], const float Y0[38][64][2], const float Y1[38][64][2], const float X_low[32][40][2], int ch)
Generate the subband filtered lowband.
Definition: aacsbr.c:1361
g
Definition: yuv2rgb.c:540
float alpha0[64][2]
Zeroth coefficient used to filter the subband signals.
Definition: sbr.h:167
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.c:42
Spectral Band Replication definitions and structures.
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
Definition: aacsbr.c:507
void(* hf_apply_noise[4])(float(*Y)[2], const float *s_m, const float *q_filt, int noise, int kx, int m_max)
Definition: sbrdsp.h:40
void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac, float *L, float *R)
Apply one SBR element to one AAC element.
Definition: aacsbr.c:1646
#define ff_mdct_init
Definition: fft.h:146
unsigned n_master
The number of frequency bands in f_master.
Definition: sbr.h:138
float q_temp[42][48]
Definition: sbr.h:94
unsigned bs_interpol_freq
Definition: sbr.h:126
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.c:785
FFTContext mdct_ana
Definition: sbr.h:184
Definition: get_bits.h:63
#define powf(x, y)
Definition: libm.h:44
float synthesis_filterbank_samples[SBR_SYNTHESIS_BUF_SIZE]
Definition: sbr.h:81
unsigned f_indexnoise
Definition: sbr.h:106
av_cold void ff_sbrdsp_init(SBRDSPContext *s)
Definition: sbrdsp.c:226
AVFloatDSPContext fdsp
Definition: aac.h:296
static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac)
Definition: aacsbr.c:998
static void sbr_turnoff(SpectralBandReplication *sbr)
Places SBR in pure upsampling mode.
Definition: aacsbr.c:130
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
Definition: sbr.h:103
AAC Spectral Band Replication function declarations.
Definition: fft.h:62
unsigned bs_amp_res
Definition: sbr.h:74
static float sbr_qmf_window_ds[320]
Definition: aacsbrdata.h:270
uint8_t bs_freq_scale
Definition: sbr.h:49
static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data, int ch)
Definition: aacsbr.c:803
static int read_sbr_single_channel_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb)
Definition: aacsbr.c:936
unsigned bs_limiter_gains
Definition: sbr.h:125
static av_always_inline av_const long int lrintf(float x)
Definition: libm.h:144
float W[2][32][32][2]
QMF values of the original signal.
Definition: sbr.h:89
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
Definition: sbr.h:175
#define SBR_VLC_ROW(name)
Definition: aacsbr.c:84
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:515
AAC definitions and structures.
float X_low[32][40][2]
QMF low frequency input to the HF generator.
Definition: sbr.h:161
void(* neg_odd_64)(float *x)
Definition: sbrdsp.h:29
uint8_t bs_freq_res[7]
Definition: sbr.h:68
#define L(x)
Definition: vp56_arith.h:36
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:1501
av_cold void ff_ps_init(void)
Definition: aacps.c:917
int start
Definition: aacps.h:42
#define SBR_SYNTHESIS_BUF_SIZE
Definition: sbr.h:55
float s_m[7][48]
Sinusoidal levels.
Definition: sbr.h:181
#define exp2f(x)
Definition: libm.h:71
float X_high[64][40][2]
QMF output of the HF generator.
Definition: sbr.h:163
static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
Limiter Frequency Band Table (14496-3 sp04 p198)
Definition: aacsbr.c:176
main external API structure.
Definition: avcodec.h:1339
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:82
unsigned m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:135
Replacements for frequently missing libm functions.
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
#define W(a, i, v)
Definition: jpegls.h:110
int synthesis_filterbank_samples_offset
Definition: sbr.h:83
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:2005
unsigned k[5]
k0, k1, k2
Definition: sbr.h:130
static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr, float X_low[32][40][2], const float W[2][32][32][2], int buf_idx)
Generate the subband filtered lowband.
Definition: aacsbr.c:1301
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr.c:1280
static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, SBRDSPContext *sbrdsp, const float *in, float *x, float z[320], float W[2][32][32][2], int buf_idx)
Analysis QMF Bank (14496-3 sp04 p206)
Definition: aacsbr.c:1153
uint8_t bs_noise_bands
Definition: sbr.h:51
av_cold void ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr)
Initialize one SBR context.
Definition: aacsbr.c:140
static int step
Definition: avplay.c:252
main AAC context
Definition: aac.h:263
void(* qmf_post_shuffle)(float W[32][2], const float *z)
Definition: sbrdsp.h:31
uint8_t bs_stop_freq
Definition: sbr.h:42
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Definition: dsputil.h:354
static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int bs_extension_id, int *num_bits_left)
Definition: aacsbr.c:908
uint16_t f_master[49]
The master QMF frequency grouping.
Definition: sbr.h:148
void(* autocorrelate)(const float x[40][2], float phi[3][2][2])
Definition: sbrdsp.h:34
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:72
static int in_table_int16(const int16_t *table, int last_el, int16_t needle)
Definition: aacsbr.c:166
void(* qmf_pre_shuffle)(float *z)
Definition: sbrdsp.h:30
#define v0
Definition: regdef.h:26
float noise_facs[3][5]
Noise scalefactors.
Definition: sbr.h:99
static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
Definition: aacsbr.c:1039
OutputConfiguration oc[2]
Definition: aac.h:309
static const int8_t ceil_log2[]
ceil(log2(index+1))
Definition: aacsbr.c:621
float analysis_filterbank_samples[1312]
Definition: sbr.h:82
#define log2f(x)
Definition: libm.h:116
unsigned f_indexsine
Definition: sbr.h:107
#define ff_mdct_end
Definition: fft.h:147
uint8_t patch_start_subband[6]
Definition: sbr.h:159
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:101
void(* hf_gen)(float(*X_high)[2], const float(*X_low)[2], const float alpha0[2], const float alpha1[2], float bw, int start, int end)
Definition: sbrdsp.h:35
Spectral Band Replication per channel data.
Definition: sbr.h:60
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr.c:285
unsigned bs_limiter_bands
Definition: sbr.h:124
int Ypos
QMF output of the HF adjustor.
Definition: sbr.h:91
uint8_t bs_alter_scale
Definition: sbr.h:50
uint16_t f_tablelim[29]
Frequency borders for the limiter.
Definition: sbr.h:156
unsigned bs_frame_class
Definition: sbr.h:65
uint8_t bs_df_env[5]
Definition: sbr.h:70
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
unsigned bs_num_noise
Definition: sbr.h:69
static const int8_t vlc_sbr_lav[10]
Definition: aacsbr.c:75
unsigned n_q
Number of noise floor bands.
Definition: sbr.h:144
SBRDSPContext dsp
Definition: sbr.h:186
float g_temp[42][48]
Definition: sbr.h:93
static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct, SBRDSPContext *sbrdsp, AVFloatDSPContext *fdsp, float *out, float X[2][38][64], float mdct_buf[2][64], float *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.c:1175
int ps
-1 implicit, 1 presence
Definition: mpeg4audio.h:40
static VLC vlc_sbr[10]
Definition: aacsbr.c:74
unsigned bs_coupling
Definition: sbr.h:129
Spectral Band Replication.
Definition: sbr.h:114
unsigned bs_num_env
Definition: sbr.h:67
float min
uint8_t bs_add_harmonic[48]
Definition: sbr.h:73
int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps, int bits_left)
Definition: aacps.c:151
static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data)
Read inverse filtering data.
Definition: aacsbr.c:793
Definition: aacsbr.c:66
PSContext ps
Definition: sbr.h:140
uint8_t bs_start_freq
Definition: sbr.h:41
DSPContext.
Definition: dsputil.h:194
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
void(* hf_g_filt)(float(*Y)[2], const float(*X_high)[40][2], const float *g_filt, int m_max, intptr_t ixh)
Definition: sbrdsp.h:38