FFmpeg
aacsbr_fixed.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013
3  * MIPS Technologies, Inc., California.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * AAC Spectral Band Replication decoding functions (fixed-point)
30  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
31  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
32  *
33  * This file is part of FFmpeg.
34  *
35  * FFmpeg is free software; you can redistribute it and/or
36  * modify it under the terms of the GNU Lesser General Public
37  * License as published by the Free Software Foundation; either
38  * version 2.1 of the License, or (at your option) any later version.
39  *
40  * FFmpeg is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43  * Lesser General Public License for more details.
44  *
45  * You should have received a copy of the GNU Lesser General Public
46  * License along with FFmpeg; if not, write to the Free Software
47  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48  */
49 
50 /**
51  * @file
52  * AAC Spectral Band Replication decoding functions (fixed-point)
53  * Note: Rounding-to-nearest used unless otherwise stated
54  * @author Robert Swain ( rob opendot cl )
55  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
56  */
57 #define USE_FIXED 1
58 
59 #include "aac.h"
60 #include "sbr.h"
61 #include "aacsbr.h"
62 #include "aacsbrdata.h"
63 #include "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 if (shift <= -30)
292  alpha0[k][0] = 0;
293  else {
294  shift = 1-shift;
295  if (shift <= 0)
296  alpha0[k][0] = a00.mant * (1<<-shift);
297  else {
298  round = 1 << (shift-1);
299  alpha0[k][0] = (a00.mant + round) >> shift;
300  }
301  }
302 
303  shift = a01.exp;
304  if (shift >= 3)
305  alpha0[k][1] = 0x7fffffff;
306  else if (shift <= -30)
307  alpha0[k][1] = 0;
308  else {
309  shift = 1-shift;
310  if (shift <= 0)
311  alpha0[k][1] = a01.mant * (1<<-shift);
312  else {
313  round = 1 << (shift-1);
314  alpha0[k][1] = (a01.mant + round) >> shift;
315  }
316  }
317  shift = a10.exp;
318  if (shift >= 3)
319  alpha1[k][0] = 0x7fffffff;
320  else if (shift <= -30)
321  alpha1[k][0] = 0;
322  else {
323  shift = 1-shift;
324  if (shift <= 0)
325  alpha1[k][0] = a10.mant * (1<<-shift);
326  else {
327  round = 1 << (shift-1);
328  alpha1[k][0] = (a10.mant + round) >> shift;
329  }
330  }
331 
332  shift = a11.exp;
333  if (shift >= 3)
334  alpha1[k][1] = 0x7fffffff;
335  else if (shift <= -30)
336  alpha1[k][1] = 0;
337  else {
338  shift = 1-shift;
339  if (shift <= 0)
340  alpha1[k][1] = a11.mant * (1<<-shift);
341  else {
342  round = 1 << (shift-1);
343  alpha1[k][1] = (a11.mant + round) >> shift;
344  }
345  }
346 
347  shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
348  (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
349  0x40000000) >> 31);
350  if (shift >= 0x20000000){
351  alpha1[k][0] = 0;
352  alpha1[k][1] = 0;
353  alpha0[k][0] = 0;
354  alpha0[k][1] = 0;
355  }
356 
357  shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
358  (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
359  0x40000000) >> 31);
360  if (shift >= 0x20000000){
361  alpha1[k][0] = 0;
362  alpha1[k][1] = 0;
363  alpha0[k][0] = 0;
364  alpha0[k][1] = 0;
365  }
366  }
367 }
368 
369 /// Chirp Factors (14496-3 sp04 p214)
370 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
371 {
372  int i;
373  int new_bw;
374  static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
375  int64_t accu;
376 
377  for (i = 0; i < sbr->n_q; i++) {
378  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
379  new_bw = 1288490189;
380  else
381  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
382 
383  if (new_bw < ch_data->bw_array[i]){
384  accu = (int64_t)new_bw * 1610612736;
385  accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
386  new_bw = (int)((accu + 0x40000000) >> 31);
387  } else {
388  accu = (int64_t)new_bw * 1946157056;
389  accu += (int64_t)ch_data->bw_array[i] * 201326592;
390  new_bw = (int)((accu + 0x40000000) >> 31);
391  }
392  ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
393  }
394 }
395 
396 /**
397  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
398  * and Calculation of gain (14496-3 sp04 p219)
399  */
401  SBRData *ch_data, const int e_a[2])
402 {
403  int e, k, m;
404  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
405  static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 },
406  { 758351638, 1 }, { 625000000, 34 } };
407 
408  for (e = 0; e < ch_data->bs_num_env; e++) {
409  int delta = !((e == e_a[1]) || (e == e_a[0]));
410  for (k = 0; k < sbr->n_lim; k++) {
411  SoftFloat gain_boost, gain_max;
412  SoftFloat sum[2];
413  sum[0] = sum[1] = FLOAT_0;
414  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
415  const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
416  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
417  sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
418  sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
419  if (!sbr->s_mapped[e][m]) {
420  if (delta) {
421  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
422  av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
423  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
424  } else {
425  sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
426  av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
427  }
428  } else {
429  sbr->gain[e][m] = av_sqrt_sf(
430  av_div_sf(
431  av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
432  av_mul_sf(
433  av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
434  av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
435  }
436  sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);
437  }
438  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
439  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
440  sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
441  }
442  gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
443  av_sqrt_sf(
444  av_div_sf(
445  av_add_sf(FLOAT_EPSILON, sum[0]),
446  av_add_sf(FLOAT_EPSILON, sum[1]))));
447  if (av_gt_sf(gain_max, FLOAT_100000))
448  gain_max = FLOAT_100000;
449  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
450  SoftFloat q_m_max = av_div_sf(
451  av_mul_sf(sbr->q_m[e][m], gain_max),
452  sbr->gain[e][m]);
453  if (av_gt_sf(sbr->q_m[e][m], q_m_max))
454  sbr->q_m[e][m] = q_m_max;
455  if (av_gt_sf(sbr->gain[e][m], gain_max))
456  sbr->gain[e][m] = gain_max;
457  }
458  sum[0] = sum[1] = FLOAT_0;
459  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
460  sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
461  sum[1] = av_add_sf(sum[1],
462  av_mul_sf(
463  av_mul_sf(sbr->e_curr[e][m],
464  sbr->gain[e][m]),
465  sbr->gain[e][m]));
466  sum[1] = av_add_sf(sum[1],
467  av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
468  if (delta && !sbr->s_m[e][m].mant)
469  sum[1] = av_add_sf(sum[1],
470  av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
471  }
472  gain_boost = av_sqrt_sf(
473  av_div_sf(
474  av_add_sf(FLOAT_EPSILON, sum[0]),
475  av_add_sf(FLOAT_EPSILON, sum[1])));
476  if (av_gt_sf(gain_boost, FLOAT_1584893192))
477  gain_boost = FLOAT_1584893192;
478 
479  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
480  sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
481  sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost);
482  sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost);
483  }
484  }
485  }
486 }
487 
488 /// Assembling HF Signals (14496-3 sp04 p220)
489 static void sbr_hf_assemble(int Y1[38][64][2],
490  const int X_high[64][40][2],
491  SpectralBandReplication *sbr, SBRData *ch_data,
492  const int e_a[2])
493 {
494  int e, i, j, m;
495  const int h_SL = 4 * !sbr->bs_smoothing_mode;
496  const int kx = sbr->kx[1];
497  const int m_max = sbr->m[1];
498  static const SoftFloat h_smooth[5] = {
499  { 715827883, -1 },
500  { 647472402, -1 },
501  { 937030863, -2 },
502  { 989249804, -3 },
503  { 546843842, -4 },
504  };
505  SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
506  int indexnoise = ch_data->f_indexnoise;
507  int indexsine = ch_data->f_indexsine;
508 
509  if (sbr->reset) {
510  for (i = 0; i < h_SL; i++) {
511  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
512  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
513  }
514  } else if (h_SL) {
515  for (i = 0; i < 4; i++) {
516  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
517  g_temp[i + 2 * ch_data->t_env_num_env_old],
518  sizeof(g_temp[0]));
519  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
520  q_temp[i + 2 * ch_data->t_env_num_env_old],
521  sizeof(q_temp[0]));
522  }
523  }
524 
525  for (e = 0; e < ch_data->bs_num_env; e++) {
526  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
527  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
528  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][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  SoftFloat g_filt_tab[48];
535  SoftFloat q_filt_tab[48];
536  SoftFloat *g_filt, *q_filt;
537 
538  if (h_SL && e != e_a[0] && e != e_a[1]) {
539  g_filt = g_filt_tab;
540  q_filt = q_filt_tab;
541  for (m = 0; m < m_max; m++) {
542  const int idx1 = i + h_SL;
543  g_filt[m].mant = g_filt[m].exp = 0;
544  q_filt[m].mant = q_filt[m].exp = 0;
545  for (j = 0; j <= h_SL; j++) {
546  g_filt[m] = av_add_sf(g_filt[m],
547  av_mul_sf(g_temp[idx1 - j][m],
548  h_smooth[j]));
549  q_filt[m] = av_add_sf(q_filt[m],
550  av_mul_sf(q_temp[idx1 - j][m],
551  h_smooth[j]));
552  }
553  }
554  } else {
555  g_filt = g_temp[i + h_SL];
556  q_filt = q_temp[i];
557  }
558 
559  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
561 
562  if (e != e_a[0] && e != e_a[1]) {
563  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
564  q_filt, indexnoise,
565  kx, m_max);
566  } else {
567  int idx = indexsine&1;
568  int A = (1-((indexsine+(kx & 1))&2));
569  int B = (A^(-idx)) + idx;
570  unsigned *out = &Y1[i][kx][idx];
571  int shift;
572  unsigned round;
573 
574  SoftFloat *in = sbr->s_m[e];
575  for (m = 0; m+1 < m_max; m+=2) {
576  int shift2;
577  shift = 22 - in[m ].exp;
578  shift2= 22 - in[m+1].exp;
579  if (shift < 1 || shift2 < 1) {
580  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
581  return;
582  }
583  if (shift < 32) {
584  round = 1 << (shift-1);
585  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
586  }
587 
588  if (shift2 < 32) {
589  round = 1 << (shift2-1);
590  out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2;
591  }
592  }
593  if(m_max&1)
594  {
595  shift = 22 - in[m ].exp;
596  if (shift < 1) {
597  av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
598  return;
599  } else if (shift < 32) {
600  round = 1 << (shift-1);
601  out[2*m ] += (int)(in[m ].mant * A + round) >> shift;
602  }
603  }
604  }
605  indexnoise = (indexnoise + m_max) & 0x1ff;
606  indexsine = (indexsine + 1) & 3;
607  }
608  }
609  ch_data->f_indexnoise = indexnoise;
610  ch_data->f_indexsine = indexsine;
611 }
612 
613 #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:207
#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:256
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 int fixed_log_table[10]
Definition: aacsbr_fixed.c:81
Definition: aac.h:57
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr_fixed.c:370
AAC_SIGNE kx[2]
kx&#39;, 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
uint8_t base
Definition: vp3data.h:202
static const SoftFloat FLOAT_0
0.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
#define f(width, name)
Definition: cbs_vp9.c:255
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
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
100000
Definition: softfloat.h:44
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AAC_SIGNE m[2]
M&#39; 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:489
#define B
Definition: huffyuvdsp.h:32
AAC_FLOAT g_temp[42][48]
Definition: sbr.h:95
static const SoftFloat FLOAT_1
1.0
Definition: softfloat.h:41
static const SoftFloat FLOAT_0999999
0.999999
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: vlc.h:26
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:96
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)
Compares two SoftFloats.
Definition: softfloat.h:150
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:400
AAC_SIGNE bs_num_env
Definition: sbr.h:69
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:200
static const int16_t alpha[]
Definition: ilbcdata.h:55
static const float bands[]
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
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
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:173
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:204
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:74
void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])
Definition: sbrdsp.h:36
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:162
int
static const int CONST_LN2
Definition: aacsbr_fixed.c:77
static const SoftFloat FLOAT_1584893192
1.584893192 (10^.2)
Definition: softfloat.h:43
unsigned f_indexsine
Definition: sbr.h:111
static const int shift2[6]
Definition: dxa.c:51
static av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:102
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
A small value.
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 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
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
SBRDSPContext dsp
Definition: sbr.h:213
FILE * out
Definition: movenc.c:54
static av_const SoftFloat av_int2sf(int v, int frac_bits)
Converts a mantisse and exponent to a SoftFloat.
Definition: softfloat.h:185
void INT64 start
Definition: avisynth_c.h:766
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
static uint8_t tmp[11]
Definition: aes_ctr.c:26