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 "aacps.h"
64 #include "sbrdsp.h"
65 #include "libavutil/internal.h"
66 #include "libavutil/libm.h"
67 #include "libavutil/avassert.h"
68 
69 #include <stdint.h>
70 #include <float.h>
71 #include <math.h>
72 
74 static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256
75 static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2)
76 static const int CONST_076923 = Q31(0.76923076923076923077f);
77 
78 static const int fixed_log_table[10] =
79 {
80  Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),
81  Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)
82 };
83 
84 static int fixed_log(int x)
85 {
86  int i, ret, xpow, tmp;
87 
88  ret = x;
89  xpow = x;
90  for (i=0; i<10; i+=2){
91  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
92  tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);
93  ret -= tmp;
94 
95  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
96  tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);
97  ret += tmp;
98  }
99 
100  return ret;
101 }
102 
103 static const int fixed_exp_table[7] =
104 {
105  Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),
106  Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)
107 };
108 
109 static int fixed_exp(int x)
110 {
111  int i, ret, xpow, tmp;
112 
113  ret = 0x800000 + x;
114  xpow = x;
115  for (i=0; i<7; i++){
116  xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);
117  tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);
118  ret += tmp;
119  }
120 
121  return ret;
122 }
123 
124 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
125 {
126  int k, previous, present;
127  int base, prod, nz = 0;
128 
129  base = (stop << 23) / start;
130  while (base < 0x40000000){
131  base <<= 1;
132  nz++;
133  }
134  base = fixed_log(base - 0x80000000);
135  base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;
136  base = fixed_exp(base);
137 
138  previous = start;
139  prod = start << 23;
140 
141  for (k = 0; k < num_bands-1; k++) {
142  prod = (int)(((int64_t)prod * base + 0x400000) >> 23);
143  present = (prod + 0x400000) >> 23;
144  bands[k] = present - previous;
145  previous = present;
146  }
147  bands[num_bands-1] = stop - previous;
148 }
149 
150 /// Dequantization and stereo decoding (14496-3 sp04 p203)
151 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
152 {
153  int k, e;
154  int ch;
155 
156  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
157  int alpha = sbr->data[0].bs_amp_res ? 2 : 1;
158  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
159  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
160  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
161  SoftFloat temp1, temp2, fac;
162 
163  temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;
164  if (temp1.exp & 1)
165  temp1.mant = 759250125;
166  else
167  temp1.mant = 0x20000000;
168  temp1.exp = (temp1.exp >> 1) + 1;
169  if (temp1.exp > 66) { // temp1 > 1E20
170  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
171  temp1 = FLOAT_1;
172  }
173 
174  temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;
175  if (temp2.exp & 1)
176  temp2.mant = 759250125;
177  else
178  temp2.mant = 0x20000000;
179  temp2.exp = (temp2.exp >> 1) + 1;
180  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
181  sbr->data[0].env_facs[e][k] = fac;
182  sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);
183  }
184  }
185  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
186  for (k = 0; k < sbr->n_q; k++) {
187  SoftFloat temp1, temp2, fac;
188 
189  temp1.exp = NOISE_FLOOR_OFFSET - \
190  sbr->data[0].noise_facs_q[e][k] + 2;
191  temp1.mant = 0x20000000;
192  av_assert0(temp1.exp <= 66);
193  temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;
194  temp2.mant = 0x20000000;
195  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
196  sbr->data[0].noise_facs[e][k] = fac;
197  sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
198  }
199  }
200  } else { // SCE or one non-coupled CPE
201  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
202  int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
203  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
204  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
205  SoftFloat temp1;
206 
207  temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;
208  if (temp1.exp & 1)
209  temp1.mant = 759250125;
210  else
211  temp1.mant = 0x20000000;
212  temp1.exp = (temp1.exp >> 1) + 1;
213  if (temp1.exp > 66) { // temp1 > 1E20
214  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
215  temp1 = FLOAT_1;
216  }
217  sbr->data[ch].env_facs[e][k] = temp1;
218  }
219  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
220  for (k = 0; k < sbr->n_q; k++){
221  sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
222  sbr->data[ch].noise_facs_q[e][k] + 1;
223  sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
224  }
225  }
226  }
227 }
228 
229 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
230  * (14496-3 sp04 p214)
231  * Warning: This routine does not seem numerically stable.
232  */
234  int (*alpha0)[2], int (*alpha1)[2],
235  const int X_low[32][40][2], int k0)
236 {
237  int k;
238  int shift, round;
239 
240  for (k = 0; k < k0; k++) {
241  SoftFloat phi[3][2][2];
242  SoftFloat a00, a01, a10, a11;
243  SoftFloat dk;
244 
245  dsp->autocorrelate(X_low[k], phi);
246 
247  dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
248  av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
249  av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
250 
251  if (!dk.mant) {
252  a10 = FLOAT_0;
253  a11 = FLOAT_0;
254  } else {
255  SoftFloat temp_real, temp_im;
256  temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
257  av_mul_sf(phi[0][0][1], phi[1][1][1])),
258  av_mul_sf(phi[0][1][0], phi[1][0][0]));
259  temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
260  av_mul_sf(phi[0][0][1], phi[1][1][0])),
261  av_mul_sf(phi[0][1][1], phi[1][0][0]));
262 
263  a10 = av_div_sf(temp_real, dk);
264  a11 = av_div_sf(temp_im, dk);
265  }
266 
267  if (!phi[1][0][0].mant) {
268  a00 = FLOAT_0;
269  a01 = FLOAT_0;
270  } else {
271  SoftFloat temp_real, temp_im;
272  temp_real = av_add_sf(phi[0][0][0],
273  av_add_sf(av_mul_sf(a10, phi[1][1][0]),
274  av_mul_sf(a11, phi[1][1][1])));
275  temp_im = av_add_sf(phi[0][0][1],
276  av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
277  av_mul_sf(a10, phi[1][1][1])));
278 
279  temp_real.mant = -temp_real.mant;
280  temp_im.mant = -temp_im.mant;
281  a00 = av_div_sf(temp_real, phi[1][0][0]);
282  a01 = av_div_sf(temp_im, phi[1][0][0]);
283  }
284 
285  shift = a00.exp;
286  if (shift >= 3)
287  alpha0[k][0] = 0x7fffffff;
288  else if (shift <= -30)
289  alpha0[k][0] = 0;
290  else {
291  shift = 1-shift;
292  if (shift <= 0)
293  alpha0[k][0] = a00.mant * (1<<-shift);
294  else {
295  round = 1 << (shift-1);
296  alpha0[k][0] = (a00.mant + round) >> shift;
297  }
298  }
299 
300  shift = a01.exp;
301  if (shift >= 3)
302  alpha0[k][1] = 0x7fffffff;
303  else if (shift <= -30)
304  alpha0[k][1] = 0;
305  else {
306  shift = 1-shift;
307  if (shift <= 0)
308  alpha0[k][1] = a01.mant * (1<<-shift);
309  else {
310  round = 1 << (shift-1);
311  alpha0[k][1] = (a01.mant + round) >> shift;
312  }
313  }
314  shift = a10.exp;
315  if (shift >= 3)
316  alpha1[k][0] = 0x7fffffff;
317  else if (shift <= -30)
318  alpha1[k][0] = 0;
319  else {
320  shift = 1-shift;
321  if (shift <= 0)
322  alpha1[k][0] = a10.mant * (1<<-shift);
323  else {
324  round = 1 << (shift-1);
325  alpha1[k][0] = (a10.mant + round) >> shift;
326  }
327  }
328 
329  shift = a11.exp;
330  if (shift >= 3)
331  alpha1[k][1] = 0x7fffffff;
332  else if (shift <= -30)
333  alpha1[k][1] = 0;
334  else {
335  shift = 1-shift;
336  if (shift <= 0)
337  alpha1[k][1] = a11.mant * (1<<-shift);
338  else {
339  round = 1 << (shift-1);
340  alpha1[k][1] = (a11.mant + round) >> shift;
341  }
342  }
343 
344  shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
345  (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
346  0x40000000) >> 31);
347  if (shift >= 0x20000000){
348  alpha1[k][0] = 0;
349  alpha1[k][1] = 0;
350  alpha0[k][0] = 0;
351  alpha0[k][1] = 0;
352  }
353 
354  shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
355  (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
356  0x40000000) >> 31);
357  if (shift >= 0x20000000){
358  alpha1[k][0] = 0;
359  alpha1[k][1] = 0;
360  alpha0[k][0] = 0;
361  alpha0[k][1] = 0;
362  }
363  }
364 }
365 
366 /// Chirp Factors (14496-3 sp04 p214)
367 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
368 {
369  int i;
370  int new_bw;
371  static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
372  int64_t accu;
373 
374  for (i = 0; i < sbr->n_q; i++) {
375  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
376  new_bw = 1288490189;
377  else
378  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
379 
380  if (new_bw < ch_data->bw_array[i]){
381  accu = (int64_t)new_bw * 1610612736;
382  accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
383  new_bw = (int)((accu + 0x40000000) >> 31);
384  } else {
385  accu = (int64_t)new_bw * 1946157056;
386  accu += (int64_t)ch_data->bw_array[i] * 201326592;
387  new_bw = (int)((accu + 0x40000000) >> 31);
388  }
389  ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
390  }
391 }
392 
393 /**
394  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
395  * and Calculation of gain (14496-3 sp04 p219)
396  */
398  SBRData *ch_data, const int e_a[2])
399 {
400  int e, k, m;
401  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
402  static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 },
403  { 758351638, 1 }, { 625000000, 34 } };
404 
405  for (e = 0; e < ch_data->bs_num_env; e++) {
406  int delta = !((e == e_a[1]) || (e == e_a[0]));
407  for (k = 0; k < sbr->n_lim; k++) {
408  SoftFloat gain_boost, gain_max;
409  SoftFloat sum[2];
410  sum[0] = sum[1] = FLOAT_0;
411  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
412  const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
413  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
414  sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
415  sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
416  if (!sbr->s_mapped[e][m]) {
417  if (delta) {
418  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
419  av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
420  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
421  } else {
422  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
423  av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
424  }
425  } else {
426  sbr->gain[e][m] = av_sqrt_sf(
427  av_div_sf(
428  av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
429  av_mul_sf(
430  av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
431  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
432  }
433  sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);
434  }
435  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
436  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
437  sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
438  }
439  gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
440  av_sqrt_sf(
441  av_div_sf(
442  av_add_sf(FLOAT_EPSILON, sum[0]),
443  av_add_sf(FLOAT_EPSILON, sum[1]))));
444  if (av_gt_sf(gain_max, FLOAT_100000))
445  gain_max = FLOAT_100000;
446  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
447  SoftFloat q_m_max = av_div_sf(
448  av_mul_sf(sbr->q_m[e][m], gain_max),
449  sbr->gain[e][m]);
450  if (av_gt_sf(sbr->q_m[e][m], q_m_max))
451  sbr->q_m[e][m] = q_m_max;
452  if (av_gt_sf(sbr->gain[e][m], gain_max))
453  sbr->gain[e][m] = gain_max;
454  }
455  sum[0] = sum[1] = FLOAT_0;
456  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
457  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
458  sum[1] = av_add_sf(sum[1],
459  av_mul_sf(
460  av_mul_sf(sbr->e_curr[e][m],
461  sbr->gain[e][m]),
462  sbr->gain[e][m]));
463  sum[1] = av_add_sf(sum[1],
464  av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
465  if (delta && !sbr->s_m[e][m].mant)
466  sum[1] = av_add_sf(sum[1],
467  av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
468  }
469  gain_boost = av_sqrt_sf(
470  av_div_sf(
471  av_add_sf(FLOAT_EPSILON, sum[0]),
472  av_add_sf(FLOAT_EPSILON, sum[1])));
473  if (av_gt_sf(gain_boost, FLOAT_1584893192))
474  gain_boost = FLOAT_1584893192;
475 
476  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
477  sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
478  sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost);
479  sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost);
480  }
481  }
482  }
483 }
484 
485 /// Assembling HF Signals (14496-3 sp04 p220)
486 static void sbr_hf_assemble(int Y1[38][64][2],
487  const int X_high[64][40][2],
488  SpectralBandReplication *sbr, SBRData *ch_data,
489  const int e_a[2])
490 {
491  int e, i, j, m;
492  const int h_SL = 4 * !sbr->bs_smoothing_mode;
493  const int kx = sbr->kx[1];
494  const int m_max = sbr->m[1];
495  static const SoftFloat h_smooth[5] = {
496  { 715827883, -1 },
497  { 647472402, -1 },
498  { 937030863, -2 },
499  { 989249804, -3 },
500  { 546843842, -4 },
501  };
502  SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
503  int indexnoise = ch_data->f_indexnoise;
504  int indexsine = ch_data->f_indexsine;
505 
506  if (sbr->reset) {
507  for (i = 0; i < h_SL; i++) {
508  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
509  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
510  }
511  } else if (h_SL) {
512  for (i = 0; i < 4; i++) {
513  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
514  g_temp[i + 2 * ch_data->t_env_num_env_old],
515  sizeof(g_temp[0]));
516  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
517  q_temp[i + 2 * ch_data->t_env_num_env_old],
518  sizeof(q_temp[0]));
519  }
520  }
521 
522  for (e = 0; e < ch_data->bs_num_env; e++) {
523  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
524  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
525  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
526  }
527  }
528 
529  for (e = 0; e < ch_data->bs_num_env; e++) {
530  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
531  SoftFloat g_filt_tab[48];
532  SoftFloat q_filt_tab[48];
533  SoftFloat *g_filt, *q_filt;
534 
535  if (h_SL && e != e_a[0] && e != e_a[1]) {
536  g_filt = g_filt_tab;
537  q_filt = q_filt_tab;
538  for (m = 0; m < m_max; m++) {
539  const int idx1 = i + h_SL;
540  g_filt[m].mant = g_filt[m].exp = 0;
541  q_filt[m].mant = q_filt[m].exp = 0;
542  for (j = 0; j <= h_SL; j++) {
543  g_filt[m] = av_add_sf(g_filt[m],
544  av_mul_sf(g_temp[idx1 - j][m],
545  h_smooth[j]));
546  q_filt[m] = av_add_sf(q_filt[m],
547  av_mul_sf(q_temp[idx1 - j][m],
548  h_smooth[j]));
549  }
550  }
551  } else {
552  g_filt = g_temp[i + h_SL];
553  q_filt = q_temp[i];
554  }
555 
556  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
558 
559  if (e != e_a[0] && e != e_a[1]) {
560  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
561  q_filt, indexnoise,
562  kx, m_max);
563  } else {
564  int idx = indexsine&1;
565  int A = (1-((indexsine+(kx & 1))&2));
566  int B = (A^(-idx)) + idx;
567  unsigned *out = &Y1[i][kx][idx];
568  int shift;
569  unsigned round;
570 
571  SoftFloat *in = sbr->s_m[e];
572  for (m = 0; m+1 < m_max; m+=2) {
573  int shift2;
574  shift = 22 - in[m ].exp;
575  shift2= 22 - in[m+1].exp;
576  if (shift < 1 || shift2 < 1) {
577  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
578  return;
579  }
580  if (shift < 32) {
581  round = 1 << (shift-1);
582  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
583  }
584 
585  if (shift2 < 32) {
586  round = 1 << (shift2-1);
587  out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2;
588  }
589  }
590  if(m_max&1)
591  {
592  shift = 22 - in[m ].exp;
593  if (shift < 1) {
594  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
595  return;
596  } else if (shift < 32) {
597  round = 1 << (shift-1);
598  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
599  }
600  }
601  }
602  indexnoise = (indexnoise + m_max) & 0x1ff;
603  indexsine = (indexsine + 1) & 3;
604  }
605  }
606  ch_data->f_indexnoise = indexnoise;
607  ch_data->f_indexsine = indexsine;
608 }
609 
610 #include "aacsbr_template.c"
A
#define A(x)
Definition: vpx_arith.h:28
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:27
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:28
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:128
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:367
FLOAT_1
static const SoftFloat FLOAT_1
1.0
Definition: softfloat.h:41
sbr.h
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:486
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:56
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:233
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:40
B
#define B
Definition: huffyuv.h:42
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:35
bands
static const float bands[]
Definition: af_superequalizer.c:56
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:84
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:39
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
f
f
Definition: af_crystalizer.c:121
FLOAT_0999999
static const SoftFloat FLOAT_0999999
0.999999
Definition: softfloat.h:45
shift
static int shift(int a, int b)
Definition: bonk.c:262
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:41
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:109
CONST_076923
static const int CONST_076923
Definition: aacsbr_fixed.c:76
SpectralBandReplication::e_curr
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:207
SoftFloat
Definition: softfloat.h:34
CONST_RECIP_LN2
static const int CONST_RECIP_LN2
Definition: aacsbr_fixed.c:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
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:430
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
shift2
static const uint8_t shift2[6]
Definition: dxa.c:49
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:397
ret
ret
Definition: filter_design.txt:187
SBRData::q_temp
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:99
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:103
temp
else temp
Definition: vf_mcdeint.c:263
make_bands
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr_fixed.c:124
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:92
sbr_dequant
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr_fixed.c:151
aacsbrdata.h
CONST_LN2
static const int CONST_LN2
Definition: aacsbr_fixed.c:74
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:296
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
fixed_log_table
static const int fixed_log_table[10]
Definition: aacsbr_fixed.c:78
SpectralBandReplication::q_mapped
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:203
int
int
Definition: ffmpeg_filter.c:368
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:218