FFmpeg  2.8.15
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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[e][k].mant * 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[e][k].mant) * 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[e][k].mant + 2;
194  temp1.mant = 0x20000000;
195  if (temp1.exp > 66) { // temp1 > 1E20
196  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
197  temp1 = FLOAT_1;
198  }
199  temp2.exp = 12 - sbr->data[1].noise_facs[e][k].mant + 1;
200  temp2.mant = 0x20000000;
201  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
202  sbr->data[0].noise_facs[e][k] = fac;
203  sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
204  }
205  }
206  } else { // SCE or one non-coupled CPE
207  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
208  int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
209  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
210  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
211  SoftFloat temp1;
212 
213  temp1.exp = alpha * sbr->data[ch].env_facs[e][k].mant + 12;
214  if (temp1.exp & 1)
215  temp1.mant = 759250125;
216  else
217  temp1.mant = 0x20000000;
218  temp1.exp = (temp1.exp >> 1) + 1;
219  if (temp1.exp > 66) { // temp1 > 1E20
220  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
221  temp1 = FLOAT_1;
222  }
223  sbr->data[ch].env_facs[e][k] = temp1;
224  }
225  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
226  for (k = 0; k < sbr->n_q; k++){
227  sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
228  sbr->data[ch].noise_facs[e][k].mant + 1;
229  sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
230  }
231  }
232  }
233 }
234 
235 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
236  * (14496-3 sp04 p214)
237  * Warning: This routine does not seem numerically stable.
238  */
240  int (*alpha0)[2], int (*alpha1)[2],
241  const int X_low[32][40][2], int k0)
242 {
243  int k;
244  int shift, round;
245 
246  for (k = 0; k < k0; k++) {
247  SoftFloat phi[3][2][2];
248  SoftFloat a00, a01, a10, a11;
249  SoftFloat dk;
250 
251  dsp->autocorrelate(X_low[k], phi);
252 
253  dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
254  av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
255  av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
256 
257  if (!dk.mant) {
258  a10 = FLOAT_0;
259  a11 = FLOAT_0;
260  } else {
261  SoftFloat temp_real, temp_im;
262  temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
263  av_mul_sf(phi[0][0][1], phi[1][1][1])),
264  av_mul_sf(phi[0][1][0], phi[1][0][0]));
265  temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
266  av_mul_sf(phi[0][0][1], phi[1][1][0])),
267  av_mul_sf(phi[0][1][1], phi[1][0][0]));
268 
269  a10 = av_div_sf(temp_real, dk);
270  a11 = av_div_sf(temp_im, dk);
271  }
272 
273  if (!phi[1][0][0].mant) {
274  a00 = FLOAT_0;
275  a01 = FLOAT_0;
276  } else {
277  SoftFloat temp_real, temp_im;
278  temp_real = av_add_sf(phi[0][0][0],
279  av_add_sf(av_mul_sf(a10, phi[1][1][0]),
280  av_mul_sf(a11, phi[1][1][1])));
281  temp_im = av_add_sf(phi[0][0][1],
282  av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
283  av_mul_sf(a10, phi[1][1][1])));
284 
285  temp_real.mant = -temp_real.mant;
286  temp_im.mant = -temp_im.mant;
287  a00 = av_div_sf(temp_real, phi[1][0][0]);
288  a01 = av_div_sf(temp_im, phi[1][0][0]);
289  }
290 
291  shift = a00.exp;
292  if (shift >= 3)
293  alpha0[k][0] = 0x7fffffff;
294  else if (shift <= -30)
295  alpha0[k][0] = 0;
296  else {
297  a00.mant <<= 1;
298  shift = 2-shift;
299  if (shift == 0)
300  alpha0[k][0] = a00.mant;
301  else {
302  round = 1 << (shift-1);
303  alpha0[k][0] = (a00.mant + round) >> shift;
304  }
305  }
306 
307  shift = a01.exp;
308  if (shift >= 3)
309  alpha0[k][1] = 0x7fffffff;
310  else if (shift <= -30)
311  alpha0[k][1] = 0;
312  else {
313  a01.mant <<= 1;
314  shift = 2-shift;
315  if (shift == 0)
316  alpha0[k][1] = a01.mant;
317  else {
318  round = 1 << (shift-1);
319  alpha0[k][1] = (a01.mant + round) >> shift;
320  }
321  }
322  shift = a10.exp;
323  if (shift >= 3)
324  alpha1[k][0] = 0x7fffffff;
325  else if (shift <= -30)
326  alpha1[k][0] = 0;
327  else {
328  a10.mant <<= 1;
329  shift = 2-shift;
330  if (shift == 0)
331  alpha1[k][0] = a10.mant;
332  else {
333  round = 1 << (shift-1);
334  alpha1[k][0] = (a10.mant + round) >> shift;
335  }
336  }
337 
338  shift = a11.exp;
339  if (shift >= 3)
340  alpha1[k][1] = 0x7fffffff;
341  else if (shift <= -30)
342  alpha1[k][1] = 0;
343  else {
344  a11.mant <<= 1;
345  shift = 2-shift;
346  if (shift == 0)
347  alpha1[k][1] = a11.mant;
348  else {
349  round = 1 << (shift-1);
350  alpha1[k][1] = (a11.mant + round) >> shift;
351  }
352  }
353 
354  shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
355  (int64_t)(alpha1[k][1]>>1) * (alpha1[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  shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
365  (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
366  0x40000000) >> 31);
367  if (shift >= 0x20000000){
368  alpha1[k][0] = 0;
369  alpha1[k][1] = 0;
370  alpha0[k][0] = 0;
371  alpha0[k][1] = 0;
372  }
373  }
374 }
375 
376 /// Chirp Factors (14496-3 sp04 p214)
377 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
378 {
379  int i;
380  int new_bw;
381  static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
382  int64_t accu;
383 
384  for (i = 0; i < sbr->n_q; i++) {
385  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
386  new_bw = 1288490189;
387  else
388  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
389 
390  if (new_bw < ch_data->bw_array[i]){
391  accu = (int64_t)new_bw * 1610612736;
392  accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
393  new_bw = (int)((accu + 0x40000000) >> 31);
394  } else {
395  accu = (int64_t)new_bw * 1946157056;
396  accu += (int64_t)ch_data->bw_array[i] * 201326592;
397  new_bw = (int)((accu + 0x40000000) >> 31);
398  }
399  ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
400  }
401 }
402 
403 /**
404  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
405  * and Calculation of gain (14496-3 sp04 p219)
406  */
408  SBRData *ch_data, const int e_a[2])
409 {
410  int e, k, m;
411  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
412  static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 },
413  { 758351638, 1 }, { 625000000, 34 } };
414 
415  for (e = 0; e < ch_data->bs_num_env; e++) {
416  int delta = !((e == e_a[1]) || (e == e_a[0]));
417  for (k = 0; k < sbr->n_lim; k++) {
418  SoftFloat gain_boost, gain_max;
419  SoftFloat sum[2];
420  sum[0] = sum[1] = FLOAT_0;
421  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
422  const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
423  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
424  sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
425  sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
426  if (!sbr->s_mapped[e][m]) {
427  if (delta) {
428  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
429  av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
430  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
431  } else {
432  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
433  av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
434  }
435  } else {
436  sbr->gain[e][m] = av_sqrt_sf(
437  av_div_sf(
438  av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
439  av_mul_sf(
440  av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
441  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
442  }
443  sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);
444  }
445  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
446  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
447  sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
448  }
449  gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
450  av_sqrt_sf(
451  av_div_sf(
452  av_add_sf(FLOAT_EPSILON, sum[0]),
453  av_add_sf(FLOAT_EPSILON, sum[1]))));
454  if (av_gt_sf(gain_max, FLOAT_100000))
455  gain_max = FLOAT_100000;
456  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
457  SoftFloat q_m_max = av_div_sf(
458  av_mul_sf(sbr->q_m[e][m], gain_max),
459  sbr->gain[e][m]);
460  if (av_gt_sf(sbr->q_m[e][m], q_m_max))
461  sbr->q_m[e][m] = q_m_max;
462  if (av_gt_sf(sbr->gain[e][m], gain_max))
463  sbr->gain[e][m] = gain_max;
464  }
465  sum[0] = sum[1] = FLOAT_0;
466  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
467  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
468  sum[1] = av_add_sf(sum[1],
469  av_mul_sf(
470  av_mul_sf(sbr->e_curr[e][m],
471  sbr->gain[e][m]),
472  sbr->gain[e][m]));
473  sum[1] = av_add_sf(sum[1],
474  av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
475  if (delta && !sbr->s_m[e][m].mant)
476  sum[1] = av_add_sf(sum[1],
477  av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
478  }
479  gain_boost = av_sqrt_sf(
480  av_div_sf(
481  av_add_sf(FLOAT_EPSILON, sum[0]),
482  av_add_sf(FLOAT_EPSILON, sum[1])));
483  if (av_gt_sf(gain_boost, FLOAT_1584893192))
484  gain_boost = FLOAT_1584893192;
485 
486  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
487  sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
488  sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost);
489  sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost);
490  }
491  }
492  }
493 }
494 
495 /// Assembling HF Signals (14496-3 sp04 p220)
496 static void sbr_hf_assemble(int Y1[38][64][2],
497  const int X_high[64][40][2],
498  SpectralBandReplication *sbr, SBRData *ch_data,
499  const int e_a[2])
500 {
501  int e, i, j, m;
502  const int h_SL = 4 * !sbr->bs_smoothing_mode;
503  const int kx = sbr->kx[1];
504  const int m_max = sbr->m[1];
505  static const SoftFloat h_smooth[5] = {
506  { 715827883, -1 },
507  { 647472402, -1 },
508  { 937030863, -2 },
509  { 989249804, -3 },
510  { 546843842, -4 },
511  };
512  SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
513  int indexnoise = ch_data->f_indexnoise;
514  int indexsine = ch_data->f_indexsine;
515 
516  if (sbr->reset) {
517  for (i = 0; i < h_SL; i++) {
518  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
519  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
520  }
521  } else if (h_SL) {
522  for (i = 0; i < 4; i++) {
523  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
524  g_temp[i + 2 * ch_data->t_env_num_env_old],
525  sizeof(g_temp[0]));
526  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
527  q_temp[i + 2 * ch_data->t_env_num_env_old],
528  sizeof(q_temp[0]));
529  }
530  }
531 
532  for (e = 0; e < ch_data->bs_num_env; e++) {
533  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
534  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
535  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
536  }
537  }
538 
539  for (e = 0; e < ch_data->bs_num_env; e++) {
540  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
541  SoftFloat g_filt_tab[48];
542  SoftFloat q_filt_tab[48];
543  SoftFloat *g_filt, *q_filt;
544 
545  if (h_SL && e != e_a[0] && e != e_a[1]) {
546  g_filt = g_filt_tab;
547  q_filt = q_filt_tab;
548  for (m = 0; m < m_max; m++) {
549  const int idx1 = i + h_SL;
550  g_filt[m].mant = g_filt[m].exp = 0;
551  q_filt[m].mant = q_filt[m].exp = 0;
552  for (j = 0; j <= h_SL; j++) {
553  g_filt[m] = av_add_sf(g_filt[m],
554  av_mul_sf(g_temp[idx1 - j][m],
555  h_smooth[j]));
556  q_filt[m] = av_add_sf(q_filt[m],
557  av_mul_sf(q_temp[idx1 - j][m],
558  h_smooth[j]));
559  }
560  }
561  } else {
562  g_filt = g_temp[i + h_SL];
563  q_filt = q_temp[i];
564  }
565 
566  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
568 
569  if (e != e_a[0] && e != e_a[1]) {
570  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
571  q_filt, indexnoise,
572  kx, m_max);
573  } else {
574  int idx = indexsine&1;
575  int A = (1-((indexsine+(kx & 1))&2));
576  int B = (A^(-idx)) + idx;
577  unsigned *out = &Y1[i][kx][idx];
578  int shift;
579  unsigned round;
580 
581  SoftFloat *in = sbr->s_m[e];
582  for (m = 0; m+1 < m_max; m+=2) {
583  int shift2;
584  shift = 22 - in[m ].exp;
585  shift2= 22 - in[m+1].exp;
586  if (shift < 1 || shift2 < 1) {
587  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
588  return;
589  }
590  if (shift < 32) {
591  round = 1 << (shift-1);
592  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
593  }
594 
595  if (shift2 < 32) {
596  round = 1 << (shift2-1);
597  out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2;
598  }
599  }
600  if(m_max&1)
601  {
602  shift = 22 - in[m ].exp;
603  if (shift < 1) {
604  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
605  return;
606  } else if (shift < 32) {
607  round = 1 << (shift-1);
608  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
609  }
610  }
611  }
612  indexnoise = (indexnoise + m_max) & 0x1ff;
613  indexsine = (indexsine + 1) & 3;
614  }
615  }
616  ch_data->f_indexnoise = indexnoise;
617  ch_data->f_indexsine = indexsine;
618 }
619 
620 #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:186
#define NULL
Definition: coverity.c:32
static int shift(int a, int b)
Definition: sonic.c:82
unsigned bs_smoothing_mode
Definition: sbr.h:152
INTFLOAT bw_array[5]
Chirp factors.
Definition: sbr.h:89
else temp
Definition: vf_mcdeint.c:257
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:377
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:158
AAC_FLOAT gain[7][48]
Definition: sbr.h:207
static const SoftFloat FLOAT_0
Definition: softfloat.h:39
static VLC vlc_sbr[10]
Definition: aacsbr_fixed.c:75
AAC_FLOAT noise_facs[3][5]
Noise scalefactors.
Definition: sbr.h:101
float delta
AAC_SIGNE n_lim
Number of limiter bands.
Definition: sbr.h:171
#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:164
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:239
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:160
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:496
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:162
Definition: get_bits.h:64
AAC Spectral Band Replication decoding functions.
unsigned f_indexnoise
Definition: sbr.h:108
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:105
AAC Spectral Band Replication function declarations.
unsigned bs_amp_res
Definition: sbr.h:76
unsigned bs_limiter_gains
Definition: sbr.h:150
static const int CONST_RECIP_LN2
Definition: aacsbr_fixed.c:78
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:196
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
Definition: sbr.h:200
static av_const int av_gt_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:136
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:407
AAC_SIGNE bs_num_env
Definition: sbr.h:69
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:198
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:204
AAC_FLOAT env_facs[6][48]
Envelope scalefactors.
Definition: sbr.h:99
main AAC context
Definition: aac.h:288
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.h:37
static av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:153
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:202
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:145
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:109
static const int shift2[6]
Definition: dxa.c:51
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:103
aacsbr functions pointers
Definition: sbr.h:118
AAC_FLOAT s_m[7][48]
Sinusoidal levels.
Definition: sbr.h:206
int32_t exp
Definition: softfloat.h:36
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:181
Spectral Band Replication per channel data.
Definition: sbr.h:62
static const SoftFloat FLOAT_EPSILON
Definition: softfloat.h:42
Definition: vf_geq.c:46
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 const SoftFloat FLOAT_MIN
Definition: softfloat.h:46
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr_fixed.c:154
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-> out
SBRDSPContext dsp
Definition: sbr.h:211
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:165
void INT64 start
Definition: avisynth_c.h:553
static void aacsbr_func_ptr_init(AACSBRContext *c)
float g_temp[42][48]
Definition: sbr.h:95
AAC_SIGNE n_q
Number of noise floor bands.
Definition: sbr.h:169
unsigned bs_coupling
Definition: sbr.h:154
Spectral Band Replication.
Definition: sbr.h:137
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition: sbr.h:167