FFmpeg
aacsbr_fixed.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013
3  * MIPS Technologies, Inc., California.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * AAC Spectral Band Replication decoding functions (fixed-point)
30  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
31  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
32  *
33  * This file is part of FFmpeg.
34  *
35  * FFmpeg is free software; you can redistribute it and/or
36  * modify it under the terms of the GNU Lesser General Public
37  * License as published by the Free Software Foundation; either
38  * version 2.1 of the License, or (at your option) any later version.
39  *
40  * FFmpeg is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43  * Lesser General Public License for more details.
44  *
45  * You should have received a copy of the GNU Lesser General Public
46  * License along with FFmpeg; if not, write to the Free Software
47  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48  */
49 
50 /**
51  * @file
52  * AAC Spectral Band Replication decoding functions (fixed-point)
53  * Note: Rounding-to-nearest used unless otherwise stated
54  * @author Robert Swain ( rob opendot cl )
55  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
56  */
57 #define USE_FIXED 1
58 
59 #include "aac.h"
60 #include "sbr.h"
61 #include "aacsbr.h"
62 #include "aacsbrdata.h"
63 #include "fft.h"
64 #include "aacps.h"
65 #include "sbrdsp.h"
66 #include "libavutil/internal.h"
67 #include "libavutil/libm.h"
68 #include "libavutil/avassert.h"
69 
70 #include <stdint.h>
71 #include <float.h>
72 #include <math.h>
73 
74 static VLC vlc_sbr[10];
76 static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256
77 static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2)
78 static const int CONST_076923 = Q31(0.76923076923076923077f);
79 
80 static const int fixed_log_table[10] =
81 {
82  Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),
83  Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)
84 };
85 
86 static int fixed_log(int x)
87 {
88  int i, ret, xpow, tmp;
89 
90  ret = x;
91  xpow = x;
92  for (i=0; i<10; i+=2){
93  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
94  tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);
95  ret -= tmp;
96 
97  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
98  tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);
99  ret += tmp;
100  }
101 
102  return ret;
103 }
104 
105 static const int fixed_exp_table[7] =
106 {
107  Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),
108  Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)
109 };
110 
111 static int fixed_exp(int x)
112 {
113  int i, ret, xpow, tmp;
114 
115  ret = 0x800000 + x;
116  xpow = x;
117  for (i=0; i<7; i++){
118  xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);
119  tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);
120  ret += tmp;
121  }
122 
123  return ret;
124 }
125 
126 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
127 {
128  int k, previous, present;
129  int base, prod, nz = 0;
130 
131  base = (stop << 23) / start;
132  while (base < 0x40000000){
133  base <<= 1;
134  nz++;
135  }
136  base = fixed_log(base - 0x80000000);
137  base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;
138  base = fixed_exp(base);
139 
140  previous = start;
141  prod = start << 23;
142 
143  for (k = 0; k < num_bands-1; k++) {
144  prod = (int)(((int64_t)prod * base + 0x400000) >> 23);
145  present = (prod + 0x400000) >> 23;
146  bands[k] = present - previous;
147  previous = present;
148  }
149  bands[num_bands-1] = stop - previous;
150 }
151 
152 /// Dequantization and stereo decoding (14496-3 sp04 p203)
153 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
154 {
155  int k, e;
156  int ch;
157 
158  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
159  int alpha = sbr->data[0].bs_amp_res ? 2 : 1;
160  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
161  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
162  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
163  SoftFloat temp1, temp2, fac;
164 
165  temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;
166  if (temp1.exp & 1)
167  temp1.mant = 759250125;
168  else
169  temp1.mant = 0x20000000;
170  temp1.exp = (temp1.exp >> 1) + 1;
171  if (temp1.exp > 66) { // temp1 > 1E20
172  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
173  temp1 = FLOAT_1;
174  }
175 
176  temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;
177  if (temp2.exp & 1)
178  temp2.mant = 759250125;
179  else
180  temp2.mant = 0x20000000;
181  temp2.exp = (temp2.exp >> 1) + 1;
182  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
183  sbr->data[0].env_facs[e][k] = fac;
184  sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);
185  }
186  }
187  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
188  for (k = 0; k < sbr->n_q; k++) {
189  SoftFloat temp1, temp2, fac;
190 
191  temp1.exp = NOISE_FLOOR_OFFSET - \
192  sbr->data[0].noise_facs_q[e][k] + 2;
193  temp1.mant = 0x20000000;
194  av_assert0(temp1.exp <= 66);
195  temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;
196  temp2.mant = 0x20000000;
197  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
198  sbr->data[0].noise_facs[e][k] = fac;
199  sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
200  }
201  }
202  } else { // SCE or one non-coupled CPE
203  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
204  int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
205  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
206  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
207  SoftFloat temp1;
208 
209  temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;
210  if (temp1.exp & 1)
211  temp1.mant = 759250125;
212  else
213  temp1.mant = 0x20000000;
214  temp1.exp = (temp1.exp >> 1) + 1;
215  if (temp1.exp > 66) { // temp1 > 1E20
216  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
217  temp1 = FLOAT_1;
218  }
219  sbr->data[ch].env_facs[e][k] = temp1;
220  }
221  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
222  for (k = 0; k < sbr->n_q; k++){
223  sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
224  sbr->data[ch].noise_facs_q[e][k] + 1;
225  sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
226  }
227  }
228  }
229 }
230 
231 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
232  * (14496-3 sp04 p214)
233  * Warning: This routine does not seem numerically stable.
234  */
236  int (*alpha0)[2], int (*alpha1)[2],
237  const int X_low[32][40][2], int k0)
238 {
239  int k;
240  int shift, round;
241 
242  for (k = 0; k < k0; k++) {
243  SoftFloat phi[3][2][2];
244  SoftFloat a00, a01, a10, a11;
245  SoftFloat dk;
246 
247  dsp->autocorrelate(X_low[k], phi);
248 
249  dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
250  av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
251  av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
252 
253  if (!dk.mant) {
254  a10 = FLOAT_0;
255  a11 = FLOAT_0;
256  } else {
257  SoftFloat temp_real, temp_im;
258  temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
259  av_mul_sf(phi[0][0][1], phi[1][1][1])),
260  av_mul_sf(phi[0][1][0], phi[1][0][0]));
261  temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
262  av_mul_sf(phi[0][0][1], phi[1][1][0])),
263  av_mul_sf(phi[0][1][1], phi[1][0][0]));
264 
265  a10 = av_div_sf(temp_real, dk);
266  a11 = av_div_sf(temp_im, dk);
267  }
268 
269  if (!phi[1][0][0].mant) {
270  a00 = FLOAT_0;
271  a01 = FLOAT_0;
272  } else {
273  SoftFloat temp_real, temp_im;
274  temp_real = av_add_sf(phi[0][0][0],
275  av_add_sf(av_mul_sf(a10, phi[1][1][0]),
276  av_mul_sf(a11, phi[1][1][1])));
277  temp_im = av_add_sf(phi[0][0][1],
278  av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
279  av_mul_sf(a10, phi[1][1][1])));
280 
281  temp_real.mant = -temp_real.mant;
282  temp_im.mant = -temp_im.mant;
283  a00 = av_div_sf(temp_real, phi[1][0][0]);
284  a01 = av_div_sf(temp_im, phi[1][0][0]);
285  }
286 
287  shift = a00.exp;
288  if (shift >= 3)
289  alpha0[k][0] = 0x7fffffff;
290  else if (shift <= -30)
291  alpha0[k][0] = 0;
292  else {
293  shift = 1-shift;
294  if (shift <= 0)
295  alpha0[k][0] = a00.mant * (1<<-shift);
296  else {
297  round = 1 << (shift-1);
298  alpha0[k][0] = (a00.mant + round) >> shift;
299  }
300  }
301 
302  shift = a01.exp;
303  if (shift >= 3)
304  alpha0[k][1] = 0x7fffffff;
305  else if (shift <= -30)
306  alpha0[k][1] = 0;
307  else {
308  shift = 1-shift;
309  if (shift <= 0)
310  alpha0[k][1] = a01.mant * (1<<-shift);
311  else {
312  round = 1 << (shift-1);
313  alpha0[k][1] = (a01.mant + round) >> shift;
314  }
315  }
316  shift = a10.exp;
317  if (shift >= 3)
318  alpha1[k][0] = 0x7fffffff;
319  else if (shift <= -30)
320  alpha1[k][0] = 0;
321  else {
322  shift = 1-shift;
323  if (shift <= 0)
324  alpha1[k][0] = a10.mant * (1<<-shift);
325  else {
326  round = 1 << (shift-1);
327  alpha1[k][0] = (a10.mant + round) >> shift;
328  }
329  }
330 
331  shift = a11.exp;
332  if (shift >= 3)
333  alpha1[k][1] = 0x7fffffff;
334  else if (shift <= -30)
335  alpha1[k][1] = 0;
336  else {
337  shift = 1-shift;
338  if (shift <= 0)
339  alpha1[k][1] = a11.mant * (1<<-shift);
340  else {
341  round = 1 << (shift-1);
342  alpha1[k][1] = (a11.mant + round) >> shift;
343  }
344  }
345 
346  shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
347  (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
348  0x40000000) >> 31);
349  if (shift >= 0x20000000){
350  alpha1[k][0] = 0;
351  alpha1[k][1] = 0;
352  alpha0[k][0] = 0;
353  alpha0[k][1] = 0;
354  }
355 
356  shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
357  (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
358  0x40000000) >> 31);
359  if (shift >= 0x20000000){
360  alpha1[k][0] = 0;
361  alpha1[k][1] = 0;
362  alpha0[k][0] = 0;
363  alpha0[k][1] = 0;
364  }
365  }
366 }
367 
368 /// Chirp Factors (14496-3 sp04 p214)
369 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
370 {
371  int i;
372  int new_bw;
373  static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
374  int64_t accu;
375 
376  for (i = 0; i < sbr->n_q; i++) {
377  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
378  new_bw = 1288490189;
379  else
380  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
381 
382  if (new_bw < ch_data->bw_array[i]){
383  accu = (int64_t)new_bw * 1610612736;
384  accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
385  new_bw = (int)((accu + 0x40000000) >> 31);
386  } else {
387  accu = (int64_t)new_bw * 1946157056;
388  accu += (int64_t)ch_data->bw_array[i] * 201326592;
389  new_bw = (int)((accu + 0x40000000) >> 31);
390  }
391  ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
392  }
393 }
394 
395 /**
396  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
397  * and Calculation of gain (14496-3 sp04 p219)
398  */
400  SBRData *ch_data, const int e_a[2])
401 {
402  int e, k, m;
403  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
404  static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 },
405  { 758351638, 1 }, { 625000000, 34 } };
406 
407  for (e = 0; e < ch_data->bs_num_env; e++) {
408  int delta = !((e == e_a[1]) || (e == e_a[0]));
409  for (k = 0; k < sbr->n_lim; k++) {
410  SoftFloat gain_boost, gain_max;
411  SoftFloat sum[2];
412  sum[0] = sum[1] = FLOAT_0;
413  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
414  const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
415  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
416  sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
417  sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
418  if (!sbr->s_mapped[e][m]) {
419  if (delta) {
420  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
421  av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
422  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
423  } else {
424  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
425  av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
426  }
427  } else {
428  sbr->gain[e][m] = av_sqrt_sf(
429  av_div_sf(
430  av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
431  av_mul_sf(
432  av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
433  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
434  }
435  sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);
436  }
437  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
438  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
439  sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
440  }
441  gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
442  av_sqrt_sf(
443  av_div_sf(
444  av_add_sf(FLOAT_EPSILON, sum[0]),
445  av_add_sf(FLOAT_EPSILON, sum[1]))));
446  if (av_gt_sf(gain_max, FLOAT_100000))
447  gain_max = FLOAT_100000;
448  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
449  SoftFloat q_m_max = av_div_sf(
450  av_mul_sf(sbr->q_m[e][m], gain_max),
451  sbr->gain[e][m]);
452  if (av_gt_sf(sbr->q_m[e][m], q_m_max))
453  sbr->q_m[e][m] = q_m_max;
454  if (av_gt_sf(sbr->gain[e][m], gain_max))
455  sbr->gain[e][m] = gain_max;
456  }
457  sum[0] = sum[1] = FLOAT_0;
458  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
459  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
460  sum[1] = av_add_sf(sum[1],
461  av_mul_sf(
462  av_mul_sf(sbr->e_curr[e][m],
463  sbr->gain[e][m]),
464  sbr->gain[e][m]));
465  sum[1] = av_add_sf(sum[1],
466  av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
467  if (delta && !sbr->s_m[e][m].mant)
468  sum[1] = av_add_sf(sum[1],
469  av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
470  }
471  gain_boost = av_sqrt_sf(
472  av_div_sf(
473  av_add_sf(FLOAT_EPSILON, sum[0]),
474  av_add_sf(FLOAT_EPSILON, sum[1])));
475  if (av_gt_sf(gain_boost, FLOAT_1584893192))
476  gain_boost = FLOAT_1584893192;
477 
478  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
479  sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
480  sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost);
481  sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost);
482  }
483  }
484  }
485 }
486 
487 /// Assembling HF Signals (14496-3 sp04 p220)
488 static void sbr_hf_assemble(int Y1[38][64][2],
489  const int X_high[64][40][2],
490  SpectralBandReplication *sbr, SBRData *ch_data,
491  const int e_a[2])
492 {
493  int e, i, j, m;
494  const int h_SL = 4 * !sbr->bs_smoothing_mode;
495  const int kx = sbr->kx[1];
496  const int m_max = sbr->m[1];
497  static const SoftFloat h_smooth[5] = {
498  { 715827883, -1 },
499  { 647472402, -1 },
500  { 937030863, -2 },
501  { 989249804, -3 },
502  { 546843842, -4 },
503  };
504  SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
505  int indexnoise = ch_data->f_indexnoise;
506  int indexsine = ch_data->f_indexsine;
507 
508  if (sbr->reset) {
509  for (i = 0; i < h_SL; i++) {
510  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
511  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
512  }
513  } else if (h_SL) {
514  for (i = 0; i < 4; i++) {
515  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
516  g_temp[i + 2 * ch_data->t_env_num_env_old],
517  sizeof(g_temp[0]));
518  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
519  q_temp[i + 2 * ch_data->t_env_num_env_old],
520  sizeof(q_temp[0]));
521  }
522  }
523 
524  for (e = 0; e < ch_data->bs_num_env; e++) {
525  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
526  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
527  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
528  }
529  }
530 
531  for (e = 0; e < ch_data->bs_num_env; e++) {
532  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
533  SoftFloat g_filt_tab[48];
534  SoftFloat q_filt_tab[48];
535  SoftFloat *g_filt, *q_filt;
536 
537  if (h_SL && e != e_a[0] && e != e_a[1]) {
538  g_filt = g_filt_tab;
539  q_filt = q_filt_tab;
540  for (m = 0; m < m_max; m++) {
541  const int idx1 = i + h_SL;
542  g_filt[m].mant = g_filt[m].exp = 0;
543  q_filt[m].mant = q_filt[m].exp = 0;
544  for (j = 0; j <= h_SL; j++) {
545  g_filt[m] = av_add_sf(g_filt[m],
546  av_mul_sf(g_temp[idx1 - j][m],
547  h_smooth[j]));
548  q_filt[m] = av_add_sf(q_filt[m],
549  av_mul_sf(q_temp[idx1 - j][m],
550  h_smooth[j]));
551  }
552  }
553  } else {
554  g_filt = g_temp[i + h_SL];
555  q_filt = q_temp[i];
556  }
557 
558  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
560 
561  if (e != e_a[0] && e != e_a[1]) {
562  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
563  q_filt, indexnoise,
564  kx, m_max);
565  } else {
566  int idx = indexsine&1;
567  int A = (1-((indexsine+(kx & 1))&2));
568  int B = (A^(-idx)) + idx;
569  unsigned *out = &Y1[i][kx][idx];
570  int shift;
571  unsigned round;
572 
573  SoftFloat *in = sbr->s_m[e];
574  for (m = 0; m+1 < m_max; m+=2) {
575  int shift2;
576  shift = 22 - in[m ].exp;
577  shift2= 22 - in[m+1].exp;
578  if (shift < 1 || shift2 < 1) {
579  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
580  return;
581  }
582  if (shift < 32) {
583  round = 1 << (shift-1);
584  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
585  }
586 
587  if (shift2 < 32) {
588  round = 1 << (shift2-1);
589  out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2;
590  }
591  }
592  if(m_max&1)
593  {
594  shift = 22 - in[m ].exp;
595  if (shift < 1) {
596  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
597  return;
598  } else if (shift < 32) {
599  round = 1 << (shift-1);
600  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
601  }
602  }
603  }
604  indexnoise = (indexnoise + m_max) & 0x1ff;
605  indexsine = (indexsine + 1) & 3;
606  }
607  }
608  ch_data->f_indexnoise = indexnoise;
609  ch_data->f_indexsine = indexsine;
610 }
611 
612 #include "aacsbr_template.c"
SpectralBandReplication::bs_coupling
unsigned bs_coupling
Definition: sbr.h:159
SpectralBandReplication::data
SBRData data[2]
Definition: sbr.h:169
SpectralBandReplication::bs_limiter_gains
unsigned bs_limiter_gains
Definition: sbr.h:155
libm.h
SBRDSPContext
Definition: sbrdsp.h:28
out
FILE * out
Definition: movenc.c:54
SpectralBandReplication::e_origmapped
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:201
FLOAT_EPSILON
static const SoftFloat FLOAT_EPSILON
A small value.
Definition: softfloat.h:42
SBRData::env_facs
AAC_FLOAT env_facs[6][48]
Definition: sbr.h:103
aacsbr_func_ptr_init
static void aacsbr_func_ptr_init(AACSBRContext *c)
aacsbr.h
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
SpectralBandReplication::m
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:165
av_sub_sf
static av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:173
SpectralBandReplication::q_m
AAC_FLOAT q_m[7][48]
Amplitude adjusted noise scalefactors.
Definition: sbr.h:209
SBRData::t_env_num_env_old
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
Definition: sbr.h:110
SoftFloat::mant
int32_t mant
Definition: softfloat.h:35
base
uint8_t base
Definition: vp3data.h:141
float.h
SBRData::t_env
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:108
sbr_chirp
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr_fixed.c:369
FLOAT_1
static const SoftFloat FLOAT_1
1.0
Definition: softfloat.h:41
sbr.h
A
#define A(x)
Definition: vp56_arith.h:28
av_gt_sf
static av_const int av_gt_sf(SoftFloat a, SoftFloat b)
Compares two SoftFloats.
Definition: softfloat.h:150
aacps.h
av_sqrt_sf
static av_always_inline SoftFloat av_sqrt_sf(SoftFloat val)
Rounding-to-nearest used.
Definition: softfloat.h:207
av_div_sf
static av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b)
b has to be normalized and not zero.
Definition: softfloat.h:116
sbr_hf_assemble
static void sbr_hf_assemble(int Y1[38][64][2], const int X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Assembling HF Signals (14496-3 sp04 p220)
Definition: aacsbr_fixed.c:488
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:58
SpectralBandReplication::reset
int reset
Definition: sbr.h:147
SBRData::noise_facs
AAC_FLOAT noise_facs[3][5]
Definition: sbr.h:106
sbr_hf_inverse_filter
static void sbr_hf_inverse_filter(SBRDSPContext *dsp, int(*alpha0)[2], int(*alpha1)[2], const int 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_fixed.c:235
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
FLOAT_MIN
static const SoftFloat FLOAT_MIN
Definition: softfloat.h:46
SBRData::bs_num_noise
AAC_SIGNE bs_num_noise
Definition: sbr.h:74
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
NOISE_FLOOR_OFFSET
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.h:37
SBRData::g_temp
AAC_FLOAT g_temp[42][48]
Definition: sbr.h:98
SBRDSPContext::autocorrelate
void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])
Definition: sbrdsp.h:36
vlc_sbr
static VLC vlc_sbr[10]
Definition: aacsbr_fixed.c:74
bands
static const float bands[]
Definition: af_superequalizer.c:56
f
#define f(width, name)
Definition: cbs_vp9.c:255
SpectralBandReplication::s_m
AAC_FLOAT s_m[7][48]
Sinusoidal levels.
Definition: sbr.h:211
SpectralBandReplication::n_lim
AAC_SIGNE n_lim
Number of limiter bands.
Definition: sbr.h:176
SBRData::env_facs_q
uint8_t env_facs_q[6][48]
Envelope scalefactors.
Definition: sbr.h:102
NULL
#define NULL
Definition: coverity.c:32
FLOAT_0
static const SoftFloat FLOAT_0
0.0
Definition: softfloat.h:39
SBRData::f_indexnoise
unsigned f_indexnoise
Definition: sbr.h:113
SpectralBandReplication::f_tablelim
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:186
AACSBRContext
aacsbr functions pointers
Definition: sbr.h:123
fixed_log
static int fixed_log(int x)
Definition: aacsbr_fixed.c:86
aac.h
SBRDSPContext::hf_g_filt
void(* hf_g_filt)(INTFLOAT(*Y)[2], const INTFLOAT(*X_high)[40][2], const AAC_FLOAT *g_filt, int m_max, intptr_t ixh)
Definition: sbrdsp.h:40
SoftFloat::exp
int32_t exp
Definition: softfloat.h:36
SpectralBandReplication::n
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition: sbr.h:172
SBRData::bs_num_env
AAC_SIGNE bs_num_env
Definition: sbr.h:72
SBRData::bs_amp_res
unsigned bs_amp_res
Definition: sbr.h:79
SBRData::s_indexmapped
uint8_t s_indexmapped[8][48]
Definition: sbr.h:100
SpectralBandReplication::bs_smoothing_mode
unsigned bs_smoothing_mode
Definition: sbr.h:157
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
FLOAT_0999999
static const SoftFloat FLOAT_0999999
0.999999
Definition: softfloat.h:45
FLOAT_1584893192
static const SoftFloat FLOAT_1584893192
1.584893192 (10^.2)
Definition: softfloat.h:43
FLOAT_100000
static const SoftFloat FLOAT_100000
100000
Definition: softfloat.h:44
sbrdsp.h
SpectralBandReplication::gain
AAC_FLOAT gain[7][48]
Definition: sbr.h:212
SpectralBandReplication
Spectral Band Replication.
Definition: sbr.h:142
SBRData::bs_invf_mode
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:77
SBRDSPContext::hf_apply_noise
void(* hf_apply_noise[4])(INTFLOAT(*Y)[2], const AAC_FLOAT *s_m, const AAC_FLOAT *q_filt, int noise, int kx, int m_max)
Definition: sbrdsp.h:42
SBRData::bs_freq_res
uint8_t bs_freq_res[7]
Definition: sbr.h:73
SpectralBandReplication::n_q
AAC_SIGNE n_q
Number of noise floor bands.
Definition: sbr.h:174
fixed_exp
static int fixed_exp(int x)
Definition: aacsbr_fixed.c:111
CONST_076923
static const int CONST_076923
Definition: aacsbr_fixed.c:78
shift2
static const int shift2[6]
Definition: dxa.c:51
SpectralBandReplication::e_curr
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:207
i
int i
Definition: input.c:407
SoftFloat
Definition: softfloat.h:34
CONST_RECIP_LN2
static const int CONST_RECIP_LN2
Definition: aacsbr_fixed.c:77
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
internal.h
SBRData
Spectral Band Replication per channel data.
Definition: sbr.h:65
SBRData::bw_array
INTFLOAT bw_array[5]
Chirp factors.
Definition: sbr.h:92
delta
float delta
Definition: vorbis_enc_data.h:457
av_int2sf
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
Definition: softfloat.h:185
SBRData::f_indexsine
unsigned f_indexsine
Definition: sbr.h:114
aacsbr_template.c
sbr_gain_calc
static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Calculation of levels of additional HF signal components (14496-3 sp04 p219) and Calculation of gain ...
Definition: aacsbr_fixed.c:399
ret
ret
Definition: filter_design.txt:187
SBRData::q_temp
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:99
B
#define B
Definition: huffyuvdsp.h:32
fft.h
VLC
Definition: vlc.h:26
av_add_sf
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:162
fixed_exp_table
static const int fixed_exp_table[7]
Definition: aacsbr_fixed.c:105
temp
else temp
Definition: vf_mcdeint.c:259
make_bands
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr_fixed.c:126
SBRData::noise_facs_q
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition: sbr.h:105
Q31
#define Q31(x)
Definition: aac_defines.h:98
sbr_dequant
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr_fixed.c:153
aacsbrdata.h
CONST_LN2
static const int CONST_LN2
Definition: aacsbr_fixed.c:76
shift
static int shift(int a, int b)
Definition: sonic.c:82
ENVELOPE_ADJUSTMENT_OFFSET
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.h:36
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AACContext
main AAC context
Definition: aac.h:294
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
fixed_log_table
static const int fixed_log_table[10]
Definition: aacsbr_fixed.c:80
SpectralBandReplication::q_mapped
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:203
int
int
Definition: ffmpeg_filter.c:156
SpectralBandReplication::kx
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:163
av_mul_sf
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:102
SpectralBandReplication::s_mapped
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
Definition: sbr.h:205
SpectralBandReplication::dsp
SBRDSPContext dsp
Definition: sbr.h:216