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