FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "aacsbr_fixed_tablegen.h"
64 #include "fft.h"
65 #include "aacps.h"
66 #include "sbrdsp.h"
67 #include "libavutil/internal.h"
68 #include "libavutil/libm.h"
69 #include "libavutil/avassert.h"
70 
71 #include <stdint.h>
72 #include <float.h>
73 #include <math.h>
74 
75 static VLC vlc_sbr[10];
77 static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256
78 static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2)
79 static const int CONST_076923 = Q31(0.76923076923076923077f);
80 
81 static const int fixed_log_table[10] =
82 {
83  Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),
84  Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)
85 };
86 
87 static int fixed_log(int x)
88 {
89  int i, ret, xpow, tmp;
90 
91  ret = x;
92  xpow = x;
93  for (i=0; i<10; i+=2){
94  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
95  tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);
96  ret -= tmp;
97 
98  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
99  tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);
100  ret += tmp;
101  }
102 
103  return ret;
104 }
105 
106 static const int fixed_exp_table[7] =
107 {
108  Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),
109  Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)
110 };
111 
112 static int fixed_exp(int x)
113 {
114  int i, ret, xpow, tmp;
115 
116  ret = 0x800000 + x;
117  xpow = x;
118  for (i=0; i<7; i++){
119  xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);
120  tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);
121  ret += tmp;
122  }
123 
124  return ret;
125 }
126 
127 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
128 {
129  int k, previous, present;
130  int base, prod, nz = 0;
131 
132  base = (stop << 23) / start;
133  while (base < 0x40000000){
134  base <<= 1;
135  nz++;
136  }
137  base = fixed_log(base - 0x80000000);
138  base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;
139  base = fixed_exp(base);
140 
141  previous = start;
142  prod = start << 23;
143 
144  for (k = 0; k < num_bands-1; k++) {
145  prod = (int)(((int64_t)prod * base + 0x400000) >> 23);
146  present = (prod + 0x400000) >> 23;
147  bands[k] = present - previous;
148  previous = present;
149  }
150  bands[num_bands-1] = stop - previous;
151 }
152 
153 /// Dequantization and stereo decoding (14496-3 sp04 p203)
154 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
155 {
156  int k, e;
157  int ch;
158 
159  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
160  int alpha = sbr->data[0].bs_amp_res ? 2 : 1;
161  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
162  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
163  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
164  SoftFloat temp1, temp2, fac;
165 
166  temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;
167  if (temp1.exp & 1)
168  temp1.mant = 759250125;
169  else
170  temp1.mant = 0x20000000;
171  temp1.exp = (temp1.exp >> 1) + 1;
172  if (temp1.exp > 66) { // temp1 > 1E20
173  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
174  temp1 = FLOAT_1;
175  }
176 
177  temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;
178  if (temp2.exp & 1)
179  temp2.mant = 759250125;
180  else
181  temp2.mant = 0x20000000;
182  temp2.exp = (temp2.exp >> 1) + 1;
183  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
184  sbr->data[0].env_facs[e][k] = fac;
185  sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);
186  }
187  }
188  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
189  for (k = 0; k < sbr->n_q; k++) {
190  SoftFloat temp1, temp2, fac;
191 
192  temp1.exp = NOISE_FLOOR_OFFSET - \
193  sbr->data[0].noise_facs_q[e][k] + 2;
194  temp1.mant = 0x20000000;
195  av_assert0(temp1.exp <= 66);
196  temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;
197  temp2.mant = 0x20000000;
198  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
199  sbr->data[0].noise_facs[e][k] = fac;
200  sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
201  }
202  }
203  } else { // SCE or one non-coupled CPE
204  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
205  int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
206  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
207  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
208  SoftFloat temp1;
209 
210  temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;
211  if (temp1.exp & 1)
212  temp1.mant = 759250125;
213  else
214  temp1.mant = 0x20000000;
215  temp1.exp = (temp1.exp >> 1) + 1;
216  if (temp1.exp > 66) { // temp1 > 1E20
217  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
218  temp1 = FLOAT_1;
219  }
220  sbr->data[ch].env_facs[e][k] = temp1;
221  }
222  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
223  for (k = 0; k < sbr->n_q; k++){
224  sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
225  sbr->data[ch].noise_facs_q[e][k] + 1;
226  sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
227  }
228  }
229  }
230 }
231 
232 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
233  * (14496-3 sp04 p214)
234  * Warning: This routine does not seem numerically stable.
235  */
237  int (*alpha0)[2], int (*alpha1)[2],
238  const int X_low[32][40][2], int k0)
239 {
240  int k;
241  int shift, round;
242 
243  for (k = 0; k < k0; k++) {
244  SoftFloat phi[3][2][2];
245  SoftFloat a00, a01, a10, a11;
246  SoftFloat dk;
247 
248  dsp->autocorrelate(X_low[k], phi);
249 
250  dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
251  av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
252  av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
253 
254  if (!dk.mant) {
255  a10 = FLOAT_0;
256  a11 = FLOAT_0;
257  } else {
258  SoftFloat temp_real, temp_im;
259  temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
260  av_mul_sf(phi[0][0][1], phi[1][1][1])),
261  av_mul_sf(phi[0][1][0], phi[1][0][0]));
262  temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
263  av_mul_sf(phi[0][0][1], phi[1][1][0])),
264  av_mul_sf(phi[0][1][1], phi[1][0][0]));
265 
266  a10 = av_div_sf(temp_real, dk);
267  a11 = av_div_sf(temp_im, dk);
268  }
269 
270  if (!phi[1][0][0].mant) {
271  a00 = FLOAT_0;
272  a01 = FLOAT_0;
273  } else {
274  SoftFloat temp_real, temp_im;
275  temp_real = av_add_sf(phi[0][0][0],
276  av_add_sf(av_mul_sf(a10, phi[1][1][0]),
277  av_mul_sf(a11, phi[1][1][1])));
278  temp_im = av_add_sf(phi[0][0][1],
279  av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
280  av_mul_sf(a10, phi[1][1][1])));
281 
282  temp_real.mant = -temp_real.mant;
283  temp_im.mant = -temp_im.mant;
284  a00 = av_div_sf(temp_real, phi[1][0][0]);
285  a01 = av_div_sf(temp_im, phi[1][0][0]);
286  }
287 
288  shift = a00.exp;
289  if (shift >= 3)
290  alpha0[k][0] = 0x7fffffff;
291  else {
292  a00.mant <<= 1;
293  shift = 2-shift;
294  if (shift == 0)
295  alpha0[k][0] = a00.mant;
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 {
306  a01.mant <<= 1;
307  shift = 2-shift;
308  if (shift == 0)
309  alpha0[k][1] = a01.mant;
310  else {
311  round = 1 << (shift-1);
312  alpha0[k][1] = (a01.mant + round) >> shift;
313  }
314  }
315  shift = a10.exp;
316  if (shift >= 3)
317  alpha1[k][0] = 0x7fffffff;
318  else {
319  a10.mant <<= 1;
320  shift = 2-shift;
321  if (shift == 0)
322  alpha1[k][0] = a10.mant;
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 {
333  a11.mant <<= 1;
334  shift = 2-shift;
335  if (shift == 0)
336  alpha1[k][1] = a11.mant;
337  else {
338  round = 1 << (shift-1);
339  alpha1[k][1] = (a11.mant + round) >> shift;
340  }
341  }
342 
343  shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
344  (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
345  0x40000000) >> 31);
346  if (shift >= 0x20000000){
347  alpha1[k][0] = 0;
348  alpha1[k][1] = 0;
349  alpha0[k][0] = 0;
350  alpha0[k][1] = 0;
351  }
352 
353  shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
354  (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
355  0x40000000) >> 31);
356  if (shift >= 0x20000000){
357  alpha1[k][0] = 0;
358  alpha1[k][1] = 0;
359  alpha0[k][0] = 0;
360  alpha0[k][1] = 0;
361  }
362  }
363 }
364 
365 /// Chirp Factors (14496-3 sp04 p214)
366 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
367 {
368  int i;
369  int new_bw;
370  static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
371  int64_t accu;
372 
373  for (i = 0; i < sbr->n_q; i++) {
374  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
375  new_bw = 1288490189;
376  else
377  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
378 
379  if (new_bw < ch_data->bw_array[i]){
380  accu = (int64_t)new_bw * 1610612736;
381  accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
382  new_bw = (int)((accu + 0x40000000) >> 31);
383  } else {
384  accu = (int64_t)new_bw * 1946157056;
385  accu += (int64_t)ch_data->bw_array[i] * 201326592;
386  new_bw = (int)((accu + 0x40000000) >> 31);
387  }
388  ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
389  }
390 }
391 
392 /**
393  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
394  * and Calculation of gain (14496-3 sp04 p219)
395  */
397  SBRData *ch_data, const int e_a[2])
398 {
399  int e, k, m;
400  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
401  static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 },
402  { 758351638, 1 }, { 625000000, 34 } };
403 
404  for (e = 0; e < ch_data->bs_num_env; e++) {
405  int delta = !((e == e_a[1]) || (e == e_a[0]));
406  for (k = 0; k < sbr->n_lim; k++) {
407  SoftFloat gain_boost, gain_max;
408  SoftFloat sum[2];
409  sum[0] = sum[1] = FLOAT_0;
410  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
411  const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
412  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
413  sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
414  sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
415  if (!sbr->s_mapped[e][m]) {
416  if (delta) {
417  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
418  av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
419  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
420  } else {
421  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
422  av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
423  }
424  } else {
425  sbr->gain[e][m] = av_sqrt_sf(
426  av_div_sf(
427  av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
428  av_mul_sf(
429  av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
430  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
431  }
432  }
433  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
434  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
435  sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
436  }
437  gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
438  av_sqrt_sf(
439  av_div_sf(
440  av_add_sf(FLOAT_EPSILON, sum[0]),
441  av_add_sf(FLOAT_EPSILON, sum[1]))));
442  if (av_gt_sf(gain_max, FLOAT_100000))
443  gain_max = FLOAT_100000;
444  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
445  SoftFloat q_m_max = av_div_sf(
446  av_mul_sf(sbr->q_m[e][m], gain_max),
447  sbr->gain[e][m]);
448  if (av_gt_sf(sbr->q_m[e][m], q_m_max))
449  sbr->q_m[e][m] = q_m_max;
450  if (av_gt_sf(sbr->gain[e][m], gain_max))
451  sbr->gain[e][m] = gain_max;
452  }
453  sum[0] = sum[1] = FLOAT_0;
454  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
455  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
456  sum[1] = av_add_sf(sum[1],
457  av_mul_sf(
458  av_mul_sf(sbr->e_curr[e][m],
459  sbr->gain[e][m]),
460  sbr->gain[e][m]));
461  sum[1] = av_add_sf(sum[1],
462  av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
463  if (delta && !sbr->s_m[e][m].mant)
464  sum[1] = av_add_sf(sum[1],
465  av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
466  }
467  gain_boost = av_sqrt_sf(
468  av_div_sf(
469  av_add_sf(FLOAT_EPSILON, sum[0]),
470  av_add_sf(FLOAT_EPSILON, sum[1])));
471  if (av_gt_sf(gain_boost, FLOAT_1584893192))
472  gain_boost = FLOAT_1584893192;
473 
474  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
475  sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
476  sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost);
477  sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost);
478  }
479  }
480  }
481 }
482 
483 /// Assembling HF Signals (14496-3 sp04 p220)
484 static void sbr_hf_assemble(int Y1[38][64][2],
485  const int X_high[64][40][2],
486  SpectralBandReplication *sbr, SBRData *ch_data,
487  const int e_a[2])
488 {
489  int e, i, j, m;
490  const int h_SL = 4 * !sbr->bs_smoothing_mode;
491  const int kx = sbr->kx[1];
492  const int m_max = sbr->m[1];
493  static const SoftFloat h_smooth[5] = {
494  { 715827883, -1 },
495  { 647472402, -1 },
496  { 937030863, -2 },
497  { 989249804, -3 },
498  { 546843842, -4 },
499  };
500  SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
501  int indexnoise = ch_data->f_indexnoise;
502  int indexsine = ch_data->f_indexsine;
503 
504  if (sbr->reset) {
505  for (i = 0; i < h_SL; i++) {
506  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
507  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
508  }
509  } else if (h_SL) {
510  for (i = 0; i < 4; i++) {
511  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
512  g_temp[i + 2 * ch_data->t_env_num_env_old],
513  sizeof(g_temp[0]));
514  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
515  q_temp[i + 2 * ch_data->t_env_num_env_old],
516  sizeof(q_temp[0]));
517  }
518  }
519 
520  for (e = 0; e < ch_data->bs_num_env; e++) {
521  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
522  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
523  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
524  }
525  }
526 
527  for (e = 0; e < ch_data->bs_num_env; e++) {
528  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
529  SoftFloat g_filt_tab[48];
530  SoftFloat q_filt_tab[48];
531  SoftFloat *g_filt, *q_filt;
532 
533  if (h_SL && e != e_a[0] && e != e_a[1]) {
534  g_filt = g_filt_tab;
535  q_filt = q_filt_tab;
536  for (m = 0; m < m_max; m++) {
537  const int idx1 = i + h_SL;
538  g_filt[m].mant = g_filt[m].exp = 0;
539  q_filt[m].mant = q_filt[m].exp = 0;
540  for (j = 0; j <= h_SL; j++) {
541  g_filt[m] = av_add_sf(g_filt[m],
542  av_mul_sf(g_temp[idx1 - j][m],
543  h_smooth[j]));
544  q_filt[m] = av_add_sf(q_filt[m],
545  av_mul_sf(q_temp[idx1 - j][m],
546  h_smooth[j]));
547  }
548  }
549  } else {
550  g_filt = g_temp[i + h_SL];
551  q_filt = q_temp[i];
552  }
553 
554  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
556 
557  if (e != e_a[0] && e != e_a[1]) {
558  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
559  q_filt, indexnoise,
560  kx, m_max);
561  } else {
562  int idx = indexsine&1;
563  int A = (1-((indexsine+(kx & 1))&2));
564  int B = (A^(-idx)) + idx;
565  int *out = &Y1[i][kx][idx];
566  int shift, round;
567 
568  SoftFloat *in = sbr->s_m[e];
569  for (m = 0; m+1 < m_max; m+=2) {
570  shift = 22 - in[m ].exp;
571  round = 1 << (shift-1);
572  out[2*m ] += (in[m ].mant * A + round) >> shift;
573 
574  shift = 22 - in[m+1].exp;
575  round = 1 << (shift-1);
576  out[2*m+2] += (in[m+1].mant * B + round) >> shift;
577  }
578  if(m_max&1)
579  {
580  shift = 22 - in[m ].exp;
581  round = 1 << (shift-1);
582 
583  out[2*m ] += (in[m ].mant * A + round) >> shift;
584  }
585  }
586  indexnoise = (indexnoise + m_max) & 0x1ff;
587  indexsine = (indexsine + 1) & 3;
588  }
589  }
590  ch_data->f_indexnoise = indexnoise;
591  ch_data->f_indexsine = indexsine;
592 }
593 
594 #include "aacsbr_template.c"
uint8_t s_indexmapped[8][48]
Definition: sbr.h:97
static av_always_inline SoftFloat av_sqrt_sf(SoftFloat val)
Rounding-to-nearest used.
Definition: softfloat.h:177
#define NULL
Definition: coverity.c:32
static int shift(int a, int b)
Definition: sonic.c:82
unsigned bs_smoothing_mode
Definition: sbr.h:154
INTFLOAT bw_array[5]
Chirp factors.
Definition: sbr.h:89
else temp
Definition: vf_mcdeint.c:259
static av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b)
b has to be normalized and not zero.
Definition: softfloat.h:112
static const int fixed_log_table[10]
Definition: aacsbr_fixed.c:81
Definition: aac.h:57
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr_fixed.c:366
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:160
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition: sbr.h:102
AAC_FLOAT gain[7][48]
Definition: sbr.h:209
static const SoftFloat FLOAT_0
Definition: softfloat.h:39
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static VLC vlc_sbr[10]
Definition: aacsbr_fixed.c:75
AAC_FLOAT noise_facs[3][5]
Definition: sbr.h:103
float delta
AAC_SIGNE n_lim
Number of limiter bands.
Definition: sbr.h:173
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.h:36
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
AAC Spectral Band Replication decoding data.
AAC_SIGNE bs_num_noise
Definition: sbr.h:71
int32_t mant
Definition: softfloat.h:35
SBRData data[2]
Definition: sbr.h:166
static int fixed_log(int x)
Definition: aacsbr_fixed.c:87
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
static const SoftFloat FLOAT_100000
Definition: softfloat.h:44
unsigned m
Definition: audioconvert.c:187
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:236
static double alpha(void *priv, double x, double y)
Definition: vf_geq.c:99
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:162
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:484
AAC_FLOAT g_temp[42][48]
Definition: sbr.h:95
static const SoftFloat FLOAT_1
Definition: softfloat.h:41
static const SoftFloat FLOAT_0999999
Definition: softfloat.h:45
Spectral Band Replication definitions and structures.
simple assert() macros that are a bit more flexible than ISO C assert().
static av_always_inline av_const double round(double x)
Definition: libm.h:444
Definition: get_bits.h:63
uint8_t env_facs_q[6][48]
Envelope scalefactors.
Definition: sbr.h:99
AAC Spectral Band Replication decoding functions.
unsigned f_indexnoise
Definition: sbr.h:110
common internal API header
#define Q31(x)
Definition: aac_defines.h:94
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
Definition: sbr.h:107
AAC Spectral Band Replication function declarations.
unsigned bs_amp_res
Definition: sbr.h:76
unsigned bs_limiter_gains
Definition: sbr.h:152
static const int CONST_RECIP_LN2
Definition: aacsbr_fixed.c:78
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:198
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
Definition: sbr.h:202
static av_const int av_gt_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:129
AAC definitions and structures.
uint8_t bs_freq_res[7]
Definition: sbr.h:70
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:96
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:396
FILE * out
Definition: movenc-test.c:54
AAC_SIGNE bs_num_env
Definition: sbr.h:69
Definition: vf_geq.c:46
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:200
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
Replacements for frequently missing libm functions.
static int fixed_exp(int x)
Definition: aacsbr_fixed.c:112
static const int CONST_076923
Definition: aacsbr_fixed.c:79
AAC_FLOAT q_m[7][48]
Amplitude adjusted noise scalefactors.
Definition: sbr.h:206
AAC_FLOAT env_facs[6][48]
Definition: sbr.h:100
main AAC context
Definition: aac.h:293
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.h:37
static av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:146
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:204
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:74
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:138
static const int CONST_LN2
Definition: aacsbr_fixed.c:77
static const SoftFloat FLOAT_1584893192
Definition: softfloat.h:43
unsigned f_indexsine
Definition: sbr.h:111
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:98
static double c[64]
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:105
aacsbr functions pointers
Definition: sbr.h:120
AAC_FLOAT s_m[7][48]
Sinusoidal levels.
Definition: sbr.h:208
int32_t exp
Definition: softfloat.h:36
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:183
Spectral Band Replication per channel data.
Definition: sbr.h:62
static const SoftFloat FLOAT_EPSILON
Definition: softfloat.h:42
static const int fixed_exp_table[7]
Definition: aacsbr_fixed.c:106
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
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr_fixed.c:127
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr_fixed.c:154
SBRDSPContext dsp
Definition: sbr.h:213
void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])
Definition: sbrdsp.h:36
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
Definition: softfloat.h:156
void INT64 start
Definition: avisynth_c.h:553
static void aacsbr_func_ptr_init(AACSBRContext *c)
AAC_SIGNE n_q
Number of noise floor bands.
Definition: sbr.h:171
unsigned bs_coupling
Definition: sbr.h:156
Spectral Band Replication.
Definition: sbr.h:139
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition: sbr.h:169