FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aacsbr_fixed.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013
3  * MIPS Technologies, Inc., California.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * AAC Spectral Band Replication decoding functions (fixed-point)
30  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
31  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
32  *
33  * This file is part of FFmpeg.
34  *
35  * FFmpeg is free software; you can redistribute it and/or
36  * modify it under the terms of the GNU Lesser General Public
37  * License as published by the Free Software Foundation; either
38  * version 2.1 of the License, or (at your option) any later version.
39  *
40  * FFmpeg is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43  * Lesser General Public License for more details.
44  *
45  * You should have received a copy of the GNU Lesser General Public
46  * License along with FFmpeg; if not, write to the Free Software
47  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48  */
49 
50 /**
51  * @file
52  * AAC Spectral Band Replication decoding functions (fixed-point)
53  * Note: Rounding-to-nearest used unless otherwise stated
54  * @author Robert Swain ( rob opendot cl )
55  * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
56  */
57 #define USE_FIXED 1
58 
59 #include "aac.h"
60 #include "sbr.h"
61 #include "aacsbr.h"
62 #include "aacsbrdata.h"
63 #include "aacsbr_fixed_tablegen.h"
64 #include "fft.h"
65 #include "aacps.h"
66 #include "sbrdsp.h"
67 #include "libavutil/internal.h"
68 #include "libavutil/libm.h"
69 #include "libavutil/avassert.h"
70 
71 #include <stdint.h>
72 #include <float.h>
73 #include <math.h>
74 
75 static VLC vlc_sbr[10];
77 static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256
78 static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2)
79 static const int CONST_076923 = Q31(0.76923076923076923077f);
80 
81 static const int fixed_log_table[10] =
82 {
83  Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),
84  Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)
85 };
86 
87 static int fixed_log(int x)
88 {
89  int i, ret, xpow, tmp;
90 
91  ret = x;
92  xpow = x;
93  for (i=0; i<10; i+=2){
94  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
95  tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);
96  ret -= tmp;
97 
98  xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
99  tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);
100  ret += tmp;
101  }
102 
103  return ret;
104 }
105 
106 static const int fixed_exp_table[7] =
107 {
108  Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),
109  Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)
110 };
111 
112 static int fixed_exp(int x)
113 {
114  int i, ret, xpow, tmp;
115 
116  ret = 0x800000 + x;
117  xpow = x;
118  for (i=0; i<7; i++){
119  xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);
120  tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);
121  ret += tmp;
122  }
123 
124  return ret;
125 }
126 
127 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
128 {
129  int k, previous, present;
130  int base, prod, nz = 0;
131 
132  base = (stop << 23) / start;
133  while (base < 0x40000000){
134  base <<= 1;
135  nz++;
136  }
137  base = fixed_log(base - 0x80000000);
138  base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;
139  base = fixed_exp(base);
140 
141  previous = start;
142  prod = start << 23;
143 
144  for (k = 0; k < num_bands-1; k++) {
145  prod = (int)(((int64_t)prod * base + 0x400000) >> 23);
146  present = (prod + 0x400000) >> 23;
147  bands[k] = present - previous;
148  previous = present;
149  }
150  bands[num_bands-1] = stop - previous;
151 }
152 
153 /// Dequantization and stereo decoding (14496-3 sp04 p203)
154 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
155 {
156  int k, e;
157  int ch;
158 
159  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
160  int alpha = sbr->data[0].bs_amp_res ? 2 : 1;
161  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
162  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
163  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
164  SoftFloat temp1, temp2, fac;
165 
166  temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;
167  if (temp1.exp & 1)
168  temp1.mant = 759250125;
169  else
170  temp1.mant = 0x20000000;
171  temp1.exp = (temp1.exp >> 1) + 1;
172  if (temp1.exp > 66) { // temp1 > 1E20
173  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
174  temp1 = FLOAT_1;
175  }
176 
177  temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;
178  if (temp2.exp & 1)
179  temp2.mant = 759250125;
180  else
181  temp2.mant = 0x20000000;
182  temp2.exp = (temp2.exp >> 1) + 1;
183  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
184  sbr->data[0].env_facs[e][k] = fac;
185  sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);
186  }
187  }
188  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
189  for (k = 0; k < sbr->n_q; k++) {
190  SoftFloat temp1, temp2, fac;
191 
192  temp1.exp = NOISE_FLOOR_OFFSET - \
193  sbr->data[0].noise_facs_q[e][k] + 2;
194  temp1.mant = 0x20000000;
195  av_assert0(temp1.exp <= 66);
196  temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;
197  temp2.mant = 0x20000000;
198  fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
199  sbr->data[0].noise_facs[e][k] = fac;
200  sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
201  }
202  }
203  } else { // SCE or one non-coupled CPE
204  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
205  int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
206  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
207  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
208  SoftFloat temp1;
209 
210  temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;
211  if (temp1.exp & 1)
212  temp1.mant = 759250125;
213  else
214  temp1.mant = 0x20000000;
215  temp1.exp = (temp1.exp >> 1) + 1;
216  if (temp1.exp > 66) { // temp1 > 1E20
217  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
218  temp1 = FLOAT_1;
219  }
220  sbr->data[ch].env_facs[e][k] = temp1;
221  }
222  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
223  for (k = 0; k < sbr->n_q; k++){
224  sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
225  sbr->data[ch].noise_facs_q[e][k] + 1;
226  sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
227  }
228  }
229  }
230 }
231 
232 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
233  * (14496-3 sp04 p214)
234  * Warning: This routine does not seem numerically stable.
235  */
237  int (*alpha0)[2], int (*alpha1)[2],
238  const int X_low[32][40][2], int k0)
239 {
240  int k;
241  int shift, round;
242 
243  for (k = 0; k < k0; k++) {
244  SoftFloat phi[3][2][2];
245  SoftFloat a00, a01, a10, a11;
246  SoftFloat dk;
247 
248  dsp->autocorrelate(X_low[k], phi);
249 
250  dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
251  av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
252  av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
253 
254  if (!dk.mant) {
255  a10 = FLOAT_0;
256  a11 = FLOAT_0;
257  } else {
258  SoftFloat temp_real, temp_im;
259  temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
260  av_mul_sf(phi[0][0][1], phi[1][1][1])),
261  av_mul_sf(phi[0][1][0], phi[1][0][0]));
262  temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
263  av_mul_sf(phi[0][0][1], phi[1][1][0])),
264  av_mul_sf(phi[0][1][1], phi[1][0][0]));
265 
266  a10 = av_div_sf(temp_real, dk);
267  a11 = av_div_sf(temp_im, dk);
268  }
269 
270  if (!phi[1][0][0].mant) {
271  a00 = FLOAT_0;
272  a01 = FLOAT_0;
273  } else {
274  SoftFloat temp_real, temp_im;
275  temp_real = av_add_sf(phi[0][0][0],
276  av_add_sf(av_mul_sf(a10, phi[1][1][0]),
277  av_mul_sf(a11, phi[1][1][1])));
278  temp_im = av_add_sf(phi[0][0][1],
279  av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
280  av_mul_sf(a10, phi[1][1][1])));
281 
282  temp_real.mant = -temp_real.mant;
283  temp_im.mant = -temp_im.mant;
284  a00 = av_div_sf(temp_real, phi[1][0][0]);
285  a01 = av_div_sf(temp_im, phi[1][0][0]);
286  }
287 
288  shift = a00.exp;
289  if (shift >= 3)
290  alpha0[k][0] = 0x7fffffff;
291  else 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  int *out = &Y1[i][kx][idx];
571  int shift, 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 ] += (in[m ].mant * A + round) >> shift;
585  }
586 
587  if (shift2 < 32) {
588  round = 1 << (shift2-1);
589  out[2*m+2] += (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 ] += (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"
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
static float alpha(float a)
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
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', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:160
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition: sbr.h:102
AAC_FLOAT gain[7][48]
Definition: sbr.h:209
static const SoftFloat FLOAT_0
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
void(* hf_g_filt)(INTFLOAT(*Y)[2], const INTFLOAT(*X_high)[40][2], const AAC_FLOAT *g_filt, int m_max, intptr_t ixh)
Definition: sbrdsp.h:40
AAC Spectral Band Replication decoding data.
AAC_SIGNE bs_num_noise
Definition: sbr.h:71
int32_t mant
Definition: softfloat.h:35
SBRData data[2]
Definition: sbr.h:166
static int fixed_log(int x)
Definition: aacsbr_fixed.c:87
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
static const SoftFloat FLOAT_100000
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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:162
static void sbr_hf_assemble(int Y1[38][64][2], const int X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Assembling HF Signals (14496-3 sp04 p220)
Definition: aacsbr_fixed.c: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 float bands[]
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
Replacements for frequently missing libm functions.
static int fixed_exp(int x)
Definition: aacsbr_fixed.c:112
static const int CONST_076923
Definition: aacsbr_fixed.c:79
AAC_FLOAT q_m[7][48]
Amplitude adjusted noise scalefactors.
Definition: sbr.h:206
AAC_FLOAT env_facs[6][48]
Definition: sbr.h:100
main AAC context
Definition: aac.h:293
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.h:37
static av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h:173
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:204
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:74
static av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b)
Definition: softfloat.h: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
static double c[64]
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:105
aacsbr functions pointers
Definition: sbr.h:120
AAC_FLOAT s_m[7][48]
Sinusoidal levels.
Definition: sbr.h:208
int32_t exp
Definition: softfloat.h:36
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:183
Spectral Band Replication per channel data.
Definition: sbr.h:62
static const SoftFloat FLOAT_EPSILON
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
SBRDSPContext dsp
Definition: sbr.h:213
FILE * out
Definition: movenc.c:54
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:185
void INT64 start
Definition: avisynth_c.h:690
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
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8: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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static uint8_t tmp[11]
Definition: aes_ctr.c:26