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 "libavutil/libm.h"
36 
37 #include <stdint.h>
38 #include <float.h>
39 
40 #define ENVELOPE_ADJUSTMENT_OFFSET 2
41 #define NOISE_FLOOR_OFFSET 6.0f
42 
46 enum {
57 };
58 
62 enum {
67 };
68 
69 enum {
71 };
72 
73 static VLC vlc_sbr[10];
74 static const int8_t vlc_sbr_lav[10] =
75  { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };
76 static const DECLARE_ALIGNED(16, float, zero64)[64];
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 
130 {
131  float mdct_scale;
132  sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
133  sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
136  /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
137  * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
138  * and scale back down at synthesis. */
139  mdct_scale = ac->avctx->sample_fmt == AV_SAMPLE_FMT_FLT ? 32768.0f : 1.0f;
140  ff_mdct_init(&sbr->mdct, 7, 1, 1.0 / (64 * mdct_scale));
141  ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * mdct_scale);
142  ff_ps_ctx_init(&sbr->ps);
143 }
144 
146 {
147  ff_mdct_end(&sbr->mdct);
148  ff_mdct_end(&sbr->mdct_ana);
149 }
150 
151 static int qsort_comparison_function_int16(const void *a, const void *b)
152 {
153  return *(const int16_t *)a - *(const int16_t *)b;
154 }
155 
156 static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)
157 {
158  int i;
159  for (i = 0; i <= last_el; i++)
160  if (table[i] == needle)
161  return 1;
162  return 0;
163 }
164 
167 {
168  int k;
169  if (sbr->bs_limiter_bands > 0) {
170  static const float bands_warped[3] = { 1.32715174233856803909f, //2^(0.49/1.2)
171  1.18509277094158210129f, //2^(0.49/2)
172  1.11987160404675912501f }; //2^(0.49/3)
173  const float lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
174  int16_t patch_borders[7];
175  uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
176 
177  patch_borders[0] = sbr->kx[1];
178  for (k = 1; k <= sbr->num_patches; k++)
179  patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
180 
181  memcpy(sbr->f_tablelim, sbr->f_tablelow,
182  (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
183  if (sbr->num_patches > 1)
184  memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
185  (sbr->num_patches - 1) * sizeof(patch_borders[0]));
186 
187  qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
188  sizeof(sbr->f_tablelim[0]),
190 
191  sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
192  while (out < sbr->f_tablelim + sbr->n_lim) {
193  if (*in >= *out * lim_bands_per_octave_warped) {
194  *++out = *in++;
195  } else if (*in == *out ||
196  !in_table_int16(patch_borders, sbr->num_patches, *in)) {
197  in++;
198  sbr->n_lim--;
199  } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
200  *out = *in++;
201  sbr->n_lim--;
202  } else {
203  *++out = *in++;
204  }
205  }
206  } else {
207  sbr->f_tablelim[0] = sbr->f_tablelow[0];
208  sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
209  sbr->n_lim = 1;
210  }
211 }
212 
214 {
215  unsigned int cnt = get_bits_count(gb);
216  uint8_t bs_header_extra_1;
217  uint8_t bs_header_extra_2;
218  int old_bs_limiter_bands = sbr->bs_limiter_bands;
219  SpectrumParameters old_spectrum_params;
220 
221  sbr->start = 1;
222 
223  // Save last spectrum parameters variables to compare to new ones
224  memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
225 
226  sbr->bs_amp_res_header = get_bits1(gb);
227  sbr->spectrum_params.bs_start_freq = get_bits(gb, 4);
228  sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4);
229  sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
230  skip_bits(gb, 2); // bs_reserved
231 
232  bs_header_extra_1 = get_bits1(gb);
233  bs_header_extra_2 = get_bits1(gb);
234 
235  if (bs_header_extra_1) {
236  sbr->spectrum_params.bs_freq_scale = get_bits(gb, 2);
239  } else {
243  }
244 
245  // Check if spectrum parameters changed
246  if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
247  sbr->reset = 1;
248 
249  if (bs_header_extra_2) {
250  sbr->bs_limiter_bands = get_bits(gb, 2);
251  sbr->bs_limiter_gains = get_bits(gb, 2);
252  sbr->bs_interpol_freq = get_bits1(gb);
253  sbr->bs_smoothing_mode = get_bits1(gb);
254  } else {
255  sbr->bs_limiter_bands = 2;
256  sbr->bs_limiter_gains = 2;
257  sbr->bs_interpol_freq = 1;
258  sbr->bs_smoothing_mode = 1;
259  }
260 
261  if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
262  sbr_make_f_tablelim(sbr);
263 
264  return get_bits_count(gb) - cnt;
265 }
266 
267 static int array_min_int16(const int16_t *array, int nel)
268 {
269  int i, min = array[0];
270  for (i = 1; i < nel; i++)
271  min = FFMIN(array[i], min);
272  return min;
273 }
274 
275 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
276 {
277  int k, previous, present;
278  float base, prod;
279 
280  base = powf((float)stop / start, 1.0f / num_bands);
281  prod = start;
282  previous = start;
283 
284  for (k = 0; k < num_bands-1; k++) {
285  prod *= base;
286  present = lrintf(prod);
287  bands[k] = present - previous;
288  previous = present;
289  }
290  bands[num_bands-1] = stop - previous;
291 }
292 
293 static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
294 {
295  // Requirements (14496-3 sp04 p205)
296  if (n_master <= 0) {
297  av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
298  return -1;
299  }
300  if (bs_xover_band >= n_master) {
301  av_log(avctx, AV_LOG_ERROR,
302  "Invalid bitstream, crossover band index beyond array bounds: %d\n",
303  bs_xover_band);
304  return -1;
305  }
306  return 0;
307 }
308 
311  SpectrumParameters *spectrum)
312 {
313  unsigned int temp, max_qmf_subbands;
314  unsigned int start_min, stop_min;
315  int k;
316  const int8_t *sbr_offset_ptr;
317  int16_t stop_dk[13];
318 
319  if (sbr->sample_rate < 32000) {
320  temp = 3000;
321  } else if (sbr->sample_rate < 64000) {
322  temp = 4000;
323  } else
324  temp = 5000;
325 
326  start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
327  stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
328 
329  switch (sbr->sample_rate) {
330  case 16000:
331  sbr_offset_ptr = sbr_offset[0];
332  break;
333  case 22050:
334  sbr_offset_ptr = sbr_offset[1];
335  break;
336  case 24000:
337  sbr_offset_ptr = sbr_offset[2];
338  break;
339  case 32000:
340  sbr_offset_ptr = sbr_offset[3];
341  break;
342  case 44100: case 48000: case 64000:
343  sbr_offset_ptr = sbr_offset[4];
344  break;
345  case 88200: case 96000: case 128000: case 176400: case 192000:
346  sbr_offset_ptr = sbr_offset[5];
347  break;
348  default:
350  "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
351  return -1;
352  }
353 
354  sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
355 
356  if (spectrum->bs_stop_freq < 14) {
357  sbr->k[2] = stop_min;
358  make_bands(stop_dk, stop_min, 64, 13);
359  qsort(stop_dk, 13, sizeof(stop_dk[0]), qsort_comparison_function_int16);
360  for (k = 0; k < spectrum->bs_stop_freq; k++)
361  sbr->k[2] += stop_dk[k];
362  } else if (spectrum->bs_stop_freq == 14) {
363  sbr->k[2] = 2*sbr->k[0];
364  } else if (spectrum->bs_stop_freq == 15) {
365  sbr->k[2] = 3*sbr->k[0];
366  } else {
368  "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
369  return -1;
370  }
371  sbr->k[2] = FFMIN(64, sbr->k[2]);
372 
373  // Requirements (14496-3 sp04 p205)
374  if (sbr->sample_rate <= 32000) {
375  max_qmf_subbands = 48;
376  } else if (sbr->sample_rate == 44100) {
377  max_qmf_subbands = 35;
378  } else if (sbr->sample_rate >= 48000)
379  max_qmf_subbands = 32;
380 
381  if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
383  "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
384  return -1;
385  }
386 
387  if (!spectrum->bs_freq_scale) {
388  int dk, k2diff;
389 
390  dk = spectrum->bs_alter_scale + 1;
391  sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
393  return -1;
394 
395  for (k = 1; k <= sbr->n_master; k++)
396  sbr->f_master[k] = dk;
397 
398  k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
399  if (k2diff < 0) {
400  sbr->f_master[1]--;
401  sbr->f_master[2]-= (k2diff < -1);
402  } else if (k2diff) {
403  sbr->f_master[sbr->n_master]++;
404  }
405 
406  sbr->f_master[0] = sbr->k[0];
407  for (k = 1; k <= sbr->n_master; k++)
408  sbr->f_master[k] += sbr->f_master[k - 1];
409 
410  } else {
411  int half_bands = 7 - spectrum->bs_freq_scale; // bs_freq_scale = {1,2,3}
412  int two_regions, num_bands_0;
413  int vdk0_max, vdk1_min;
414  int16_t vk0[49];
415 
416  if (49 * sbr->k[2] > 110 * sbr->k[0]) {
417  two_regions = 1;
418  sbr->k[1] = 2 * sbr->k[0];
419  } else {
420  two_regions = 0;
421  sbr->k[1] = sbr->k[2];
422  }
423 
424  num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
425 
426  if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
427  av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
428  return -1;
429  }
430 
431  vk0[0] = 0;
432 
433  make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
434 
435  qsort(vk0 + 1, num_bands_0, sizeof(vk0[1]), qsort_comparison_function_int16);
436  vdk0_max = vk0[num_bands_0];
437 
438  vk0[0] = sbr->k[0];
439  for (k = 1; k <= num_bands_0; k++) {
440  if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
441  av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
442  return -1;
443  }
444  vk0[k] += vk0[k-1];
445  }
446 
447  if (two_regions) {
448  int16_t vk1[49];
449  float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f
450  : 1.0f; // bs_alter_scale = {0,1}
451  int num_bands_1 = lrintf(half_bands * invwarp *
452  log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
453 
454  make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
455 
456  vdk1_min = array_min_int16(vk1 + 1, num_bands_1);
457 
458  if (vdk1_min < vdk0_max) {
459  int change;
460  qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
461  change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
462  vk1[1] += change;
463  vk1[num_bands_1] -= change;
464  }
465 
466  qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
467 
468  vk1[0] = sbr->k[1];
469  for (k = 1; k <= num_bands_1; k++) {
470  if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
471  av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
472  return -1;
473  }
474  vk1[k] += vk1[k-1];
475  }
476 
477  sbr->n_master = num_bands_0 + num_bands_1;
479  return -1;
480  memcpy(&sbr->f_master[0], vk0,
481  (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
482  memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
483  num_bands_1 * sizeof(sbr->f_master[0]));
484 
485  } else {
486  sbr->n_master = num_bands_0;
488  return -1;
489  memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
490  }
491  }
492 
493  return 0;
494 }
495 
498 {
499  int i, k, sb = 0;
500  int msb = sbr->k[0];
501  int usb = sbr->kx[1];
502  int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
503 
504  sbr->num_patches = 0;
505 
506  if (goal_sb < sbr->kx[1] + sbr->m[1]) {
507  for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
508  } else
509  k = sbr->n_master;
510 
511  do {
512  int odd = 0;
513  for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
514  sb = sbr->f_master[i];
515  odd = (sb + sbr->k[0]) & 1;
516  }
517 
518  // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
519  // After this check the final number of patches can still be six which is
520  // illegal however the Coding Technologies decoder check stream has a final
521  // count of 6 patches
522  if (sbr->num_patches > 5) {
523  av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
524  return -1;
525  }
526 
527  sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
528  sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
529 
530  if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
531  usb = sb;
532  msb = sb;
533  sbr->num_patches++;
534  } else
535  msb = sbr->kx[1];
536 
537  if (sbr->f_master[k] - sb < 3)
538  k = sbr->n_master;
539  } while (sb != sbr->kx[1] + sbr->m[1]);
540 
541  if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
542  sbr->num_patches--;
543 
544  return 0;
545 }
546 
549 {
550  int k, temp;
551 
552  sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
553  sbr->n[0] = (sbr->n[1] + 1) >> 1;
554 
555  memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
556  (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
557  sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
558  sbr->kx[1] = sbr->f_tablehigh[0];
559 
560  // Requirements (14496-3 sp04 p205)
561  if (sbr->kx[1] + sbr->m[1] > 64) {
563  "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
564  return -1;
565  }
566  if (sbr->kx[1] > 32) {
567  av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
568  return -1;
569  }
570 
571  sbr->f_tablelow[0] = sbr->f_tablehigh[0];
572  temp = sbr->n[1] & 1;
573  for (k = 1; k <= sbr->n[0]; k++)
574  sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
575 
577  log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
578  if (sbr->n_q > 5) {
579  av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
580  return -1;
581  }
582 
583  sbr->f_tablenoise[0] = sbr->f_tablelow[0];
584  temp = 0;
585  for (k = 1; k <= sbr->n_q; k++) {
586  temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
587  sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
588  }
589 
590  if (sbr_hf_calc_npatches(ac, sbr) < 0)
591  return -1;
592 
593  sbr_make_f_tablelim(sbr);
594 
595  sbr->data[0].f_indexnoise = 0;
596  sbr->data[1].f_indexnoise = 0;
597 
598  return 0;
599 }
600 
601 static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec,
602  int elements)
603 {
604  int i;
605  for (i = 0; i < elements; i++) {
606  vec[i] = get_bits1(gb);
607  }
608 }
609 
611 static const int8_t ceil_log2[] = {
612  0, 1, 2, 2, 3, 3,
613 };
614 
616  GetBitContext *gb, SBRData *ch_data)
617 {
618  int i;
619  unsigned bs_pointer = 0;
620  // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
621  int abs_bord_trail = 16;
622  int num_rel_lead, num_rel_trail;
623  unsigned bs_num_env_old = ch_data->bs_num_env;
624 
625  ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
626  ch_data->bs_amp_res = sbr->bs_amp_res_header;
627  ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
628 
629  switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
630  case FIXFIX:
631  ch_data->bs_num_env = 1 << get_bits(gb, 2);
632  num_rel_lead = ch_data->bs_num_env - 1;
633  if (ch_data->bs_num_env == 1)
634  ch_data->bs_amp_res = 0;
635 
636  if (ch_data->bs_num_env > 4) {
638  "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
639  ch_data->bs_num_env);
640  return -1;
641  }
642 
643  ch_data->t_env[0] = 0;
644  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
645 
646  abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
647  ch_data->bs_num_env;
648  for (i = 0; i < num_rel_lead; i++)
649  ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
650 
651  ch_data->bs_freq_res[1] = get_bits1(gb);
652  for (i = 1; i < ch_data->bs_num_env; i++)
653  ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
654  break;
655  case FIXVAR:
656  abs_bord_trail += get_bits(gb, 2);
657  num_rel_trail = get_bits(gb, 2);
658  ch_data->bs_num_env = num_rel_trail + 1;
659  ch_data->t_env[0] = 0;
660  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
661 
662  for (i = 0; i < num_rel_trail; i++)
663  ch_data->t_env[ch_data->bs_num_env - 1 - i] =
664  ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
665 
666  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
667 
668  for (i = 0; i < ch_data->bs_num_env; i++)
669  ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
670  break;
671  case VARFIX:
672  ch_data->t_env[0] = get_bits(gb, 2);
673  num_rel_lead = get_bits(gb, 2);
674  ch_data->bs_num_env = num_rel_lead + 1;
675  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
676 
677  for (i = 0; i < num_rel_lead; i++)
678  ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
679 
680  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
681 
682  get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
683  break;
684  case VARVAR:
685  ch_data->t_env[0] = get_bits(gb, 2);
686  abs_bord_trail += get_bits(gb, 2);
687  num_rel_lead = get_bits(gb, 2);
688  num_rel_trail = get_bits(gb, 2);
689  ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1;
690 
691  if (ch_data->bs_num_env > 5) {
693  "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
694  ch_data->bs_num_env);
695  return -1;
696  }
697 
698  ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
699 
700  for (i = 0; i < num_rel_lead; i++)
701  ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
702  for (i = 0; i < num_rel_trail; i++)
703  ch_data->t_env[ch_data->bs_num_env - 1 - i] =
704  ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
705 
706  bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
707 
708  get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
709  break;
710  }
711 
712  if (bs_pointer > ch_data->bs_num_env + 1) {
714  "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
715  bs_pointer);
716  return -1;
717  }
718 
719  for (i = 1; i <= ch_data->bs_num_env; i++) {
720  if (ch_data->t_env[i-1] > ch_data->t_env[i]) {
721  av_log(ac->avctx, AV_LOG_ERROR, "Non monotone time borders\n");
722  return -1;
723  }
724  }
725 
726  ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1;
727 
728  ch_data->t_q[0] = ch_data->t_env[0];
729  ch_data->t_q[ch_data->bs_num_noise] = ch_data->t_env[ch_data->bs_num_env];
730  if (ch_data->bs_num_noise > 1) {
731  unsigned int idx;
732  if (ch_data->bs_frame_class == FIXFIX) {
733  idx = ch_data->bs_num_env >> 1;
734  } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
735  idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
736  } else { // VARFIX
737  if (!bs_pointer)
738  idx = 1;
739  else if (bs_pointer == 1)
740  idx = ch_data->bs_num_env - 1;
741  else // bs_pointer > 1
742  idx = bs_pointer - 1;
743  }
744  ch_data->t_q[1] = ch_data->t_env[idx];
745  }
746 
747  ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev
748  ch_data->e_a[1] = -1;
749  if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
750  ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer;
751  } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1
752  ch_data->e_a[1] = bs_pointer - 1;
753 
754  return 0;
755 }
756 
757 static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
758  //These variables are saved from the previous frame rather than copied
759  dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env];
760  dst->t_env_num_env_old = dst->t_env[dst->bs_num_env];
761  dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env);
762 
763  //These variables are read from the bitstream and therefore copied
764  memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res));
765  memcpy(dst->t_env, src->t_env, sizeof(dst->t_env));
766  memcpy(dst->t_q, src->t_q, sizeof(dst->t_q));
767  dst->bs_num_env = src->bs_num_env;
768  dst->bs_amp_res = src->bs_amp_res;
769  dst->bs_num_noise = src->bs_num_noise;
770  dst->bs_frame_class = src->bs_frame_class;
771  dst->e_a[1] = src->e_a[1];
772 }
773 
776  SBRData *ch_data)
777 {
778  get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env);
779  get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
780 }
781 
784  SBRData *ch_data)
785 {
786  int i;
787 
788  memcpy(ch_data->bs_invf_mode[1], ch_data->bs_invf_mode[0], 5 * sizeof(uint8_t));
789  for (i = 0; i < sbr->n_q; i++)
790  ch_data->bs_invf_mode[0][i] = get_bits(gb, 2);
791 }
792 
794  SBRData *ch_data, int ch)
795 {
796  int bits;
797  int i, j, k;
798  VLC_TYPE (*t_huff)[2], (*f_huff)[2];
799  int t_lav, f_lav;
800  const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
801  const int odd = sbr->n[1] & 1;
802 
803  if (sbr->bs_coupling && ch) {
804  if (ch_data->bs_amp_res) {
805  bits = 5;
806  t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_3_0DB].table;
808  f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
810  } else {
811  bits = 6;
812  t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_1_5DB].table;
814  f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_1_5DB].table;
816  }
817  } else {
818  if (ch_data->bs_amp_res) {
819  bits = 6;
820  t_huff = vlc_sbr[T_HUFFMAN_ENV_3_0DB].table;
822  f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
824  } else {
825  bits = 7;
826  t_huff = vlc_sbr[T_HUFFMAN_ENV_1_5DB].table;
828  f_huff = vlc_sbr[F_HUFFMAN_ENV_1_5DB].table;
830  }
831  }
832 
833  for (i = 0; i < ch_data->bs_num_env; i++) {
834  if (ch_data->bs_df_env[i]) {
835  // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
836  if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
837  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
838  ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
839  } else if (ch_data->bs_freq_res[i + 1]) {
840  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
841  k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
842  ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
843  }
844  } else {
845  for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
846  k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j]
847  ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
848  }
849  }
850  } else {
851  ch_data->env_facs[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance
852  for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
853  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);
854  }
855  }
856 
857  //assign 0th elements of env_facs from last elements
858  memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env],
859  sizeof(ch_data->env_facs[0]));
860 }
861 
863  SBRData *ch_data, int ch)
864 {
865  int i, j;
866  VLC_TYPE (*t_huff)[2], (*f_huff)[2];
867  int t_lav, f_lav;
868  int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
869 
870  if (sbr->bs_coupling && ch) {
871  t_huff = vlc_sbr[T_HUFFMAN_NOISE_BAL_3_0DB].table;
873  f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
875  } else {
876  t_huff = vlc_sbr[T_HUFFMAN_NOISE_3_0DB].table;
878  f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
880  }
881 
882  for (i = 0; i < ch_data->bs_num_noise; i++) {
883  if (ch_data->bs_df_noise[i]) {
884  for (j = 0; j < sbr->n_q; j++)
885  ch_data->noise_facs[i + 1][j] = ch_data->noise_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 2) - t_lav);
886  } else {
887  ch_data->noise_facs[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
888  for (j = 1; j < sbr->n_q; j++)
889  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);
890  }
891  }
892 
893  //assign 0th elements of noise_facs from last elements
894  memcpy(ch_data->noise_facs[0], ch_data->noise_facs[ch_data->bs_num_noise],
895  sizeof(ch_data->noise_facs[0]));
896 }
897 
899  GetBitContext *gb,
900  int bs_extension_id, int *num_bits_left)
901 {
902  switch (bs_extension_id) {
903  case EXTENSION_ID_PS:
904  if (!ac->m4ac.ps) {
905  av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
906  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
907  *num_bits_left = 0;
908  } else {
909 #if 1
910  *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps, *num_bits_left);
911 #else
912  av_log_missing_feature(ac->avctx, "Parametric Stereo is", 0);
913  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
914  *num_bits_left = 0;
915 #endif
916  }
917  break;
918  default:
919  av_log_missing_feature(ac->avctx, "Reserved SBR extensions are", 1);
920  skip_bits_long(gb, *num_bits_left); // bs_fill_bits
921  *num_bits_left = 0;
922  break;
923  }
924 }
925 
928  GetBitContext *gb)
929 {
930  if (get_bits1(gb)) // bs_data_extra
931  skip_bits(gb, 4); // bs_reserved
932 
933  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
934  return -1;
935  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
936  read_sbr_invf(sbr, gb, &sbr->data[0]);
937  read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
938  read_sbr_noise(sbr, gb, &sbr->data[0], 0);
939 
940  if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
941  get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
942 
943  return 0;
944 }
945 
948  GetBitContext *gb)
949 {
950  if (get_bits1(gb)) // bs_data_extra
951  skip_bits(gb, 8); // bs_reserved
952 
953  if ((sbr->bs_coupling = get_bits1(gb))) {
954  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
955  return -1;
956  copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
957  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
958  read_sbr_dtdf(sbr, gb, &sbr->data[1]);
959  read_sbr_invf(sbr, gb, &sbr->data[0]);
960  memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
961  memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
962  read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
963  read_sbr_noise(sbr, gb, &sbr->data[0], 0);
964  read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
965  read_sbr_noise(sbr, gb, &sbr->data[1], 1);
966  } else {
967  if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
968  read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
969  return -1;
970  read_sbr_dtdf(sbr, gb, &sbr->data[0]);
971  read_sbr_dtdf(sbr, gb, &sbr->data[1]);
972  read_sbr_invf(sbr, gb, &sbr->data[0]);
973  read_sbr_invf(sbr, gb, &sbr->data[1]);
974  read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
975  read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
976  read_sbr_noise(sbr, gb, &sbr->data[0], 0);
977  read_sbr_noise(sbr, gb, &sbr->data[1], 1);
978  }
979 
980  if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
981  get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
982  if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
983  get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
984 
985  return 0;
986 }
987 
988 static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
989  GetBitContext *gb, int id_aac)
990 {
991  unsigned int cnt = get_bits_count(gb);
992 
993  if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
994  if (read_sbr_single_channel_element(ac, sbr, gb)) {
995  sbr->start = 0;
996  return get_bits_count(gb) - cnt;
997  }
998  } else if (id_aac == TYPE_CPE) {
999  if (read_sbr_channel_pair_element(ac, sbr, gb)) {
1000  sbr->start = 0;
1001  return get_bits_count(gb) - cnt;
1002  }
1003  } else {
1004  av_log(ac->avctx, AV_LOG_ERROR,
1005  "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
1006  sbr->start = 0;
1007  return get_bits_count(gb) - cnt;
1008  }
1009  if (get_bits1(gb)) { // bs_extended_data
1010  int num_bits_left = get_bits(gb, 4); // bs_extension_size
1011  if (num_bits_left == 15)
1012  num_bits_left += get_bits(gb, 8); // bs_esc_count
1013 
1014  num_bits_left <<= 3;
1015  while (num_bits_left > 7) {
1016  num_bits_left -= 2;
1017  read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
1018  }
1019  if (num_bits_left < 0) {
1020  av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");
1021  }
1022  if (num_bits_left > 0)
1023  skip_bits(gb, num_bits_left);
1024  }
1025 
1026  return get_bits_count(gb) - cnt;
1027 }
1028 
1030 {
1031  int err;
1032  err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
1033  if (err >= 0)
1034  err = sbr_make_f_derived(ac, sbr);
1035  if (err < 0) {
1036  av_log(ac->avctx, AV_LOG_ERROR,
1037  "SBR reset failed. Switching SBR to pure upsampling mode.\n");
1038  sbr->start = 0;
1039  }
1040 }
1041 
1051  GetBitContext *gb_host, int crc, int cnt, int id_aac)
1052 {
1053  unsigned int num_sbr_bits = 0, num_align_bits;
1054  unsigned bytes_read;
1055  GetBitContext gbc = *gb_host, *gb = &gbc;
1056  skip_bits_long(gb_host, cnt*8 - 4);
1057 
1058  sbr->reset = 0;
1059 
1060  if (!sbr->sample_rate)
1061  sbr->sample_rate = 2 * ac->m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
1062  if (!ac->m4ac.ext_sample_rate)
1063  ac->m4ac.ext_sample_rate = 2 * ac->m4ac.sample_rate;
1064 
1065  if (crc) {
1066  skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
1067  num_sbr_bits += 10;
1068  }
1069 
1070  //Save some state from the previous frame.
1071  sbr->kx[0] = sbr->kx[1];
1072  sbr->m[0] = sbr->m[1];
1073 
1074  num_sbr_bits++;
1075  if (get_bits1(gb)) // bs_header_flag
1076  num_sbr_bits += read_sbr_header(sbr, gb);
1077 
1078  if (sbr->reset)
1079  sbr_reset(ac, sbr);
1080 
1081  if (sbr->start)
1082  num_sbr_bits += read_sbr_data(ac, sbr, gb, id_aac);
1083 
1084  num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
1085  bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
1086 
1087  if (bytes_read > cnt) {
1088  av_log(ac->avctx, AV_LOG_ERROR,
1089  "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
1090  }
1091  return cnt;
1092 }
1093 
1095 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
1096 {
1097  int k, e;
1098  int ch;
1099 
1100  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
1101  float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f;
1102  float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f;
1103  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
1104  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
1105  float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f);
1106  float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha);
1107  float fac = temp1 / (1.0f + temp2);
1108  sbr->data[0].env_facs[e][k] = fac;
1109  sbr->data[1].env_facs[e][k] = fac * temp2;
1110  }
1111  }
1112  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
1113  for (k = 0; k < sbr->n_q; k++) {
1114  float temp1 = exp2f(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs[e][k] + 1);
1115  float temp2 = exp2f(12 - sbr->data[1].noise_facs[e][k]);
1116  float fac = temp1 / (1.0f + temp2);
1117  sbr->data[0].noise_facs[e][k] = fac;
1118  sbr->data[1].noise_facs[e][k] = fac * temp2;
1119  }
1120  }
1121  } else { // SCE or one non-coupled CPE
1122  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
1123  float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f;
1124  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
1125  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++)
1126  sbr->data[ch].env_facs[e][k] =
1127  exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f);
1128  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
1129  for (k = 0; k < sbr->n_q; k++)
1130  sbr->data[ch].noise_facs[e][k] =
1131  exp2f(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs[e][k]);
1132  }
1133  }
1134 }
1135 
1142 static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in, float *x,
1143  float z[320], float W[2][32][32][2])
1144 {
1145  int i, k;
1146  memcpy(W[0], W[1], sizeof(W[0]));
1147  memcpy(x , x+1024, (320-32)*sizeof(x[0]));
1148  memcpy(x+288, in, 1024*sizeof(x[0]));
1149  for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
1150  // are not supported
1151  dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
1152  for (k = 0; k < 64; k++) {
1153  float f = z[k] + z[k + 64] + z[k + 128] + z[k + 192] + z[k + 256];
1154  z[k] = f;
1155  }
1156  //Shuffle to IMDCT
1157  z[64] = z[0];
1158  for (k = 1; k < 32; k++) {
1159  z[64+2*k-1] = z[ k];
1160  z[64+2*k ] = -z[64-k];
1161  }
1162  z[64+63] = z[32];
1163 
1164  mdct->imdct_half(mdct, z, z+64);
1165  for (k = 0; k < 32; k++) {
1166  W[1][i][k][0] = -z[63-k];
1167  W[1][i][k][1] = z[k];
1168  }
1169  x += 32;
1170  }
1171 }
1172 
1178  float *out, float X[2][38][64],
1179  float mdct_buf[2][64],
1180  float *v0, int *v_off, const unsigned int div)
1181 {
1182  int i, n;
1183  const float *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us;
1184  const int step = 128 >> div;
1185  float *v;
1186  for (i = 0; i < 32; i++) {
1187  if (*v_off < step) {
1188  int saved_samples = (1280 - 128) >> div;
1189  memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(float));
1190  *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - step;
1191  } else {
1192  *v_off -= step;
1193  }
1194  v = v0 + *v_off;
1195  if (div) {
1196  for (n = 0; n < 32; n++) {
1197  X[0][i][ n] = -X[0][i][n];
1198  X[0][i][32+n] = X[1][i][31-n];
1199  }
1200  mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
1201  for (n = 0; n < 32; n++) {
1202  v[ n] = mdct_buf[0][63 - 2*n];
1203  v[63 - n] = -mdct_buf[0][62 - 2*n];
1204  }
1205  } else {
1206  for (n = 1; n < 64; n+=2) {
1207  X[1][i][n] = -X[1][i][n];
1208  }
1209  mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
1210  mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
1211  for (n = 0; n < 64; n++) {
1212  v[ n] = -mdct_buf[0][63 - n] + mdct_buf[1][ n ];
1213  v[127 - n] = mdct_buf[0][63 - n] + mdct_buf[1][ n ];
1214  }
1215  }
1216  dsp->vector_fmul_add(out, v , sbr_qmf_window , zero64, 64 >> div);
1217  dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out , 64 >> div);
1218  dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out , 64 >> div);
1219  dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out , 64 >> div);
1220  dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out , 64 >> div);
1221  dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out , 64 >> div);
1222  dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out , 64 >> div);
1223  dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out , 64 >> div);
1224  dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out , 64 >> div);
1225  dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out , 64 >> div);
1226  out += 64 >> div;
1227  }
1228 }
1229 
1230 static void autocorrelate(const float x[40][2], float phi[3][2][2], int lag)
1231 {
1232  int i;
1233  float real_sum = 0.0f;
1234  float imag_sum = 0.0f;
1235  if (lag) {
1236  for (i = 1; i < 38; i++) {
1237  real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
1238  imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
1239  }
1240  phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
1241  phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
1242  if (lag == 1) {
1243  phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
1244  phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
1245  }
1246  } else {
1247  for (i = 1; i < 38; i++) {
1248  real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
1249  }
1250  phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
1251  phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
1252  }
1253 }
1254 
1259 static void sbr_hf_inverse_filter(float (*alpha0)[2], float (*alpha1)[2],
1260  const float X_low[32][40][2], int k0)
1261 {
1262  int k;
1263  for (k = 0; k < k0; k++) {
1264  float phi[3][2][2], dk;
1265 
1266  autocorrelate(X_low[k], phi, 0);
1267  autocorrelate(X_low[k], phi, 1);
1268  autocorrelate(X_low[k], phi, 2);
1269 
1270  dk = phi[2][1][0] * phi[1][0][0] -
1271  (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
1272 
1273  if (!dk) {
1274  alpha1[k][0] = 0;
1275  alpha1[k][1] = 0;
1276  } else {
1277  float temp_real, temp_im;
1278  temp_real = phi[0][0][0] * phi[1][1][0] -
1279  phi[0][0][1] * phi[1][1][1] -
1280  phi[0][1][0] * phi[1][0][0];
1281  temp_im = phi[0][0][0] * phi[1][1][1] +
1282  phi[0][0][1] * phi[1][1][0] -
1283  phi[0][1][1] * phi[1][0][0];
1284 
1285  alpha1[k][0] = temp_real / dk;
1286  alpha1[k][1] = temp_im / dk;
1287  }
1288 
1289  if (!phi[1][0][0]) {
1290  alpha0[k][0] = 0;
1291  alpha0[k][1] = 0;
1292  } else {
1293  float temp_real, temp_im;
1294  temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
1295  alpha1[k][1] * phi[1][1][1];
1296  temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
1297  alpha1[k][0] * phi[1][1][1];
1298 
1299  alpha0[k][0] = -temp_real / phi[1][0][0];
1300  alpha0[k][1] = -temp_im / phi[1][0][0];
1301  }
1302 
1303  if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
1304  alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
1305  alpha1[k][0] = 0;
1306  alpha1[k][1] = 0;
1307  alpha0[k][0] = 0;
1308  alpha0[k][1] = 0;
1309  }
1310  }
1311 }
1312 
1314 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
1315 {
1316  int i;
1317  float new_bw;
1318  static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
1319 
1320  for (i = 0; i < sbr->n_q; i++) {
1321  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
1322  new_bw = 0.6f;
1323  } else
1324  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
1325 
1326  if (new_bw < ch_data->bw_array[i]) {
1327  new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i];
1328  } else
1329  new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
1330  ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
1331  }
1332 }
1333 
1336  float X_low[32][40][2], const float W[2][32][32][2])
1337 {
1338  int i, k;
1339  const int t_HFGen = 8;
1340  const int i_f = 32;
1341  memset(X_low, 0, 32*sizeof(*X_low));
1342  for (k = 0; k < sbr->kx[1]; k++) {
1343  for (i = t_HFGen; i < i_f + t_HFGen; i++) {
1344  X_low[k][i][0] = W[1][i - t_HFGen][k][0];
1345  X_low[k][i][1] = W[1][i - t_HFGen][k][1];
1346  }
1347  }
1348  for (k = 0; k < sbr->kx[0]; k++) {
1349  for (i = 0; i < t_HFGen; i++) {
1350  X_low[k][i][0] = W[0][i + i_f - t_HFGen][k][0];
1351  X_low[k][i][1] = W[0][i + i_f - t_HFGen][k][1];
1352  }
1353  }
1354  return 0;
1355 }
1356 
1359  float X_high[64][40][2], const float X_low[32][40][2],
1360  const float (*alpha0)[2], const float (*alpha1)[2],
1361  const float bw_array[5], const uint8_t *t_env,
1362  int bs_num_env)
1363 {
1364  int i, j, x;
1365  int g = 0;
1366  int k = sbr->kx[1];
1367  for (j = 0; j < sbr->num_patches; j++) {
1368  for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1369  float alpha[4];
1370  const int p = sbr->patch_start_subband[j] + x;
1371  while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1372  g++;
1373  g--;
1374 
1375  if (g < 0) {
1376  av_log(ac->avctx, AV_LOG_ERROR,
1377  "ERROR : no subband found for frequency %d\n", k);
1378  return -1;
1379  }
1380 
1381  alpha[0] = alpha1[p][0] * bw_array[g] * bw_array[g];
1382  alpha[1] = alpha1[p][1] * bw_array[g] * bw_array[g];
1383  alpha[2] = alpha0[p][0] * bw_array[g];
1384  alpha[3] = alpha0[p][1] * bw_array[g];
1385 
1386  for (i = 2 * t_env[0]; i < 2 * t_env[bs_num_env]; i++) {
1387  const int idx = i + ENVELOPE_ADJUSTMENT_OFFSET;
1388  X_high[k][idx][0] =
1389  X_low[p][idx - 2][0] * alpha[0] -
1390  X_low[p][idx - 2][1] * alpha[1] +
1391  X_low[p][idx - 1][0] * alpha[2] -
1392  X_low[p][idx - 1][1] * alpha[3] +
1393  X_low[p][idx][0];
1394  X_high[k][idx][1] =
1395  X_low[p][idx - 2][1] * alpha[0] +
1396  X_low[p][idx - 2][0] * alpha[1] +
1397  X_low[p][idx - 1][1] * alpha[2] +
1398  X_low[p][idx - 1][0] * alpha[3] +
1399  X_low[p][idx][1];
1400  }
1401  }
1402  }
1403  if (k < sbr->m[1] + sbr->kx[1])
1404  memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
1405 
1406  return 0;
1407 }
1408 
1410 static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64],
1411  const float X_low[32][40][2], const float Y[2][38][64][2],
1412  int ch)
1413 {
1414  int k, i;
1415  const int i_f = 32;
1416  const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
1417  memset(X, 0, 2*sizeof(*X));
1418  for (k = 0; k < sbr->kx[0]; k++) {
1419  for (i = 0; i < i_Temp; i++) {
1420  X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1421  X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1422  }
1423  }
1424  for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1425  for (i = 0; i < i_Temp; i++) {
1426  X[0][i][k] = Y[0][i + i_f][k][0];
1427  X[1][i][k] = Y[0][i + i_f][k][1];
1428  }
1429  }
1430 
1431  for (k = 0; k < sbr->kx[1]; k++) {
1432  for (i = i_Temp; i < 38; i++) {
1433  X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
1434  X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
1435  }
1436  }
1437  for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1438  for (i = i_Temp; i < i_f; i++) {
1439  X[0][i][k] = Y[1][i][k][0];
1440  X[1][i][k] = Y[1][i][k][1];
1441  }
1442  }
1443  return 0;
1444 }
1445 
1450  SBRData *ch_data, int e_a[2])
1451 {
1452  int e, i, m;
1453 
1454  memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
1455  for (e = 0; e < ch_data->bs_num_env; e++) {
1456  const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
1457  uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1458  int k;
1459 
1460  for (i = 0; i < ilim; i++)
1461  for (m = table[i]; m < table[i + 1]; m++)
1462  sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1463 
1464  // ch_data->bs_num_noise > 1 => 2 noise floors
1465  k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
1466  for (i = 0; i < sbr->n_q; i++)
1467  for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1468  sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
1469 
1470  for (i = 0; i < sbr->n[1]; i++) {
1471  if (ch_data->bs_add_harmonic_flag) {
1472  const unsigned int m_midpoint =
1473  (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
1474 
1475  ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
1476  (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
1477  }
1478  }
1479 
1480  for (i = 0; i < ilim; i++) {
1481  int additional_sinusoid_present = 0;
1482  for (m = table[i]; m < table[i + 1]; m++) {
1483  if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
1484  additional_sinusoid_present = 1;
1485  break;
1486  }
1487  }
1488  memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
1489  (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
1490  }
1491  }
1492 
1493  memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
1494 }
1495 
1497 static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
1498  SpectralBandReplication *sbr, SBRData *ch_data)
1499 {
1500  int e, i, m;
1501 
1502  if (sbr->bs_interpol_freq) {
1503  for (e = 0; e < ch_data->bs_num_env; e++) {
1504  const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1505  int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1506  int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1507 
1508  for (m = 0; m < sbr->m[1]; m++) {
1509  float sum = 0.0f;
1510 
1511  for (i = ilb; i < iub; i++) {
1512  sum += X_high[m + sbr->kx[1]][i][0] * X_high[m + sbr->kx[1]][i][0] +
1513  X_high[m + sbr->kx[1]][i][1] * X_high[m + sbr->kx[1]][i][1];
1514  }
1515  e_curr[e][m] = sum * recip_env_size;
1516  }
1517  }
1518  } else {
1519  int k, p;
1520 
1521  for (e = 0; e < ch_data->bs_num_env; e++) {
1522  const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
1523  int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1524  int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
1525  const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1526 
1527  for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
1528  float sum = 0.0f;
1529  const int den = env_size * (table[p + 1] - table[p]);
1530 
1531  for (k = table[p]; k < table[p + 1]; k++) {
1532  for (i = ilb; i < iub; i++) {
1533  sum += X_high[k][i][0] * X_high[k][i][0] +
1534  X_high[k][i][1] * X_high[k][i][1];
1535  }
1536  }
1537  sum /= den;
1538  for (k = table[p]; k < table[p + 1]; k++) {
1539  e_curr[e][k - sbr->kx[1]] = sum;
1540  }
1541  }
1542  }
1543  }
1544 }
1545 
1551  SBRData *ch_data, const int e_a[2])
1552 {
1553  int e, k, m;
1554  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
1555  static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
1556 
1557  for (e = 0; e < ch_data->bs_num_env; e++) {
1558  int delta = !((e == e_a[1]) || (e == e_a[0]));
1559  for (k = 0; k < sbr->n_lim; k++) {
1560  float gain_boost, gain_max;
1561  float sum[2] = { 0.0f, 0.0f };
1562  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1563  const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
1564  sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
1565  sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
1566  if (!sbr->s_mapped[e][m]) {
1567  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
1568  ((1.0f + sbr->e_curr[e][m]) *
1569  (1.0f + sbr->q_mapped[e][m] * delta)));
1570  } else {
1571  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
1572  ((1.0f + sbr->e_curr[e][m]) *
1573  (1.0f + sbr->q_mapped[e][m])));
1574  }
1575  }
1576  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1577  sum[0] += sbr->e_origmapped[e][m];
1578  sum[1] += sbr->e_curr[e][m];
1579  }
1580  gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
1581  gain_max = FFMIN(100000.f, gain_max);
1582  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1583  float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
1584  sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
1585  sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
1586  }
1587  sum[0] = sum[1] = 0.0f;
1588  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1589  sum[0] += sbr->e_origmapped[e][m];
1590  sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
1591  + sbr->s_m[e][m] * sbr->s_m[e][m]
1592  + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
1593  }
1594  gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
1595  gain_boost = FFMIN(1.584893192f, gain_boost);
1596  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1597  sbr->gain[e][m] *= gain_boost;
1598  sbr->q_m[e][m] *= gain_boost;
1599  sbr->s_m[e][m] *= gain_boost;
1600  }
1601  }
1602  }
1603 }
1604 
1606 static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2],
1607  SpectralBandReplication *sbr, SBRData *ch_data,
1608  const int e_a[2])
1609 {
1610  int e, i, j, m;
1611  const int h_SL = 4 * !sbr->bs_smoothing_mode;
1612  const int kx = sbr->kx[1];
1613  const int m_max = sbr->m[1];
1614  static const float h_smooth[5] = {
1615  0.33333333333333,
1616  0.30150283239582,
1617  0.21816949906249,
1618  0.11516383427084,
1619  0.03183050093751,
1620  };
1621  static const int8_t phi[2][4] = {
1622  { 1, 0, -1, 0}, // real
1623  { 0, 1, 0, -1}, // imaginary
1624  };
1625  float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
1626  int indexnoise = ch_data->f_indexnoise;
1627  int indexsine = ch_data->f_indexsine;
1628  memcpy(Y[0], Y[1], sizeof(Y[0]));
1629 
1630  if (sbr->reset) {
1631  for (i = 0; i < h_SL; i++) {
1632  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
1633  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
1634  }
1635  } else if (h_SL) {
1636  memcpy(g_temp[2*ch_data->t_env[0]], g_temp[2*ch_data->t_env_num_env_old], 4*sizeof(g_temp[0]));
1637  memcpy(q_temp[2*ch_data->t_env[0]], q_temp[2*ch_data->t_env_num_env_old], 4*sizeof(q_temp[0]));
1638  }
1639 
1640  for (e = 0; e < ch_data->bs_num_env; e++) {
1641  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
1642  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
1643  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
1644  }
1645  }
1646 
1647  for (e = 0; e < ch_data->bs_num_env; e++) {
1648  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
1649  int phi_sign = (1 - 2*(kx & 1));
1650 
1651  if (h_SL && e != e_a[0] && e != e_a[1]) {
1652  for (m = 0; m < m_max; m++) {
1653  const int idx1 = i + h_SL;
1654  float g_filt = 0.0f;
1655  for (j = 0; j <= h_SL; j++)
1656  g_filt += g_temp[idx1 - j][m] * h_smooth[j];
1657  Y[1][i][m + kx][0] =
1658  X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
1659  Y[1][i][m + kx][1] =
1660  X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
1661  }
1662  } else {
1663  for (m = 0; m < m_max; m++) {
1664  const float g_filt = g_temp[i + h_SL][m];
1665  Y[1][i][m + kx][0] =
1666  X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
1667  Y[1][i][m + kx][1] =
1668  X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
1669  }
1670  }
1671 
1672  if (e != e_a[0] && e != e_a[1]) {
1673  for (m = 0; m < m_max; m++) {
1674  indexnoise = (indexnoise + 1) & 0x1ff;
1675  if (sbr->s_m[e][m]) {
1676  Y[1][i][m + kx][0] +=
1677  sbr->s_m[e][m] * phi[0][indexsine];
1678  Y[1][i][m + kx][1] +=
1679  sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1680  } else {
1681  float q_filt;
1682  if (h_SL) {
1683  const int idx1 = i + h_SL;
1684  q_filt = 0.0f;
1685  for (j = 0; j <= h_SL; j++)
1686  q_filt += q_temp[idx1 - j][m] * h_smooth[j];
1687  } else {
1688  q_filt = q_temp[i][m];
1689  }
1690  Y[1][i][m + kx][0] +=
1691  q_filt * sbr_noise_table[indexnoise][0];
1692  Y[1][i][m + kx][1] +=
1693  q_filt * sbr_noise_table[indexnoise][1];
1694  }
1695  phi_sign = -phi_sign;
1696  }
1697  } else {
1698  indexnoise = (indexnoise + m_max) & 0x1ff;
1699  for (m = 0; m < m_max; m++) {
1700  Y[1][i][m + kx][0] +=
1701  sbr->s_m[e][m] * phi[0][indexsine];
1702  Y[1][i][m + kx][1] +=
1703  sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1704  phi_sign = -phi_sign;
1705  }
1706  }
1707  indexsine = (indexsine + 1) & 3;
1708  }
1709  }
1710  ch_data->f_indexnoise = indexnoise;
1711  ch_data->f_indexsine = indexsine;
1712 }
1713 
1715  float* L, float* R)
1716 {
1717  int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
1718  int ch;
1719  int nch = (id_aac == TYPE_CPE) ? 2 : 1;
1720 
1721  if (sbr->start) {
1722  sbr_dequant(sbr, id_aac);
1723  }
1724  for (ch = 0; ch < nch; ch++) {
1725  /* decode channel */
1726  sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1727  (float*)sbr->qmf_filter_scratch,
1728  sbr->data[ch].W);
1729  sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
1730  if (sbr->start) {
1731  sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
1732  sbr_chirp(sbr, &sbr->data[ch]);
1733  sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
1734  sbr->data[ch].bw_array, sbr->data[ch].t_env,
1735  sbr->data[ch].bs_num_env);
1736 
1737  // hf_adj
1738  sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1739  sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1740  sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1741  sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
1742  sbr->data[ch].e_a);
1743  }
1744 
1745  /* synthesis */
1746  sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);
1747  }
1748 
1749  if (ac->m4ac.ps == 1) {
1750  if (sbr->ps.start) {
1751  ff_ps_apply(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
1752  } else {
1753  memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
1754  }
1755  nch = 2;
1756  }
1757 
1758  sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
1761  downsampled);
1762  if (nch == 2)
1763  sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
1766  downsampled);
1767 }