FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aacsbr.c
Go to the documentation of this file.
1 /*
2  * AAC Spectral Band Replication decoding functions
3  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
4  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * AAC Spectral Band Replication decoding functions
26  * @author Robert Swain ( rob opendot cl )
27  */
28 #define USE_FIXED 0
29 
30 #include "aac.h"
31 #include "sbr.h"
32 #include "aacsbr.h"
33 #include "aacsbrdata.h"
34 #include "aacsbr_tablegen.h"
35 #include "fft.h"
36 #include "internal.h"
37 #include "aacps.h"
38 #include "sbrdsp.h"
39 #include "libavutil/internal.h"
40 #include "libavutil/libm.h"
41 #include "libavutil/avassert.h"
42 
43 #include <stdint.h>
44 #include <float.h>
45 #include <math.h>
46 
47 #if ARCH_MIPS
48 #include "mips/aacsbr_mips.h"
49 #endif /* ARCH_MIPS */
50 
51 static VLC vlc_sbr[10];
53 
54 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
55 {
56  int k, previous, present;
57  float base, prod;
58 
59  base = powf((float)stop / start, 1.0f / num_bands);
60  prod = start;
61  previous = start;
62 
63  for (k = 0; k < num_bands-1; k++) {
64  prod *= base;
65  present = lrintf(prod);
66  bands[k] = present - previous;
67  previous = present;
68  }
69  bands[num_bands-1] = stop - previous;
70 }
71 
72 /// Dequantization and stereo decoding (14496-3 sp04 p203)
73 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
74 {
75  int k, e;
76  int ch;
77  static const double exp2_tab[2] = {1, M_SQRT2};
78  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
79  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
80  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
81  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
82  float temp1, temp2, fac;
83  if (sbr->data[0].bs_amp_res) {
84  temp1 = ff_exp2fi(sbr->data[0].env_facs_q[e][k] + 7);
85  temp2 = ff_exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]);
86  }
87  else {
88  temp1 = ff_exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) *
89  exp2_tab[sbr->data[0].env_facs_q[e][k] & 1];
90  temp2 = ff_exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) *
91  exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1];
92  }
93  if (temp1 > 1E20) {
94  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
95  temp1 = 1;
96  }
97  fac = temp1 / (1.0f + temp2);
98  sbr->data[0].env_facs[e][k] = fac;
99  sbr->data[1].env_facs[e][k] = fac * temp2;
100  }
101  }
102  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
103  for (k = 0; k < sbr->n_q; k++) {
104  float temp1 = ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1);
105  float temp2 = ff_exp2fi(12 - sbr->data[1].noise_facs_q[e][k]);
106  float fac;
107  av_assert0(temp1 <= 1E20);
108  fac = temp1 / (1.0f + temp2);
109  sbr->data[0].noise_facs[e][k] = fac;
110  sbr->data[1].noise_facs[e][k] = fac * temp2;
111  }
112  }
113  } else { // SCE or one non-coupled CPE
114  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
115  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
116  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
117  if (sbr->data[ch].bs_amp_res)
118  sbr->data[ch].env_facs[e][k] = ff_exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
119  else
120  sbr->data[ch].env_facs[e][k] = ff_exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
121  * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
122  if (sbr->data[ch].env_facs[e][k] > 1E20) {
123  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
124  sbr->data[ch].env_facs[e][k] = 1;
125  }
126  }
127 
128  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
129  for (k = 0; k < sbr->n_q; k++)
130  sbr->data[ch].noise_facs[e][k] =
131  ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
132  }
133  }
134 }
135 
136 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
137  * (14496-3 sp04 p214)
138  * Warning: This routine does not seem numerically stable.
139  */
141  float (*alpha0)[2], float (*alpha1)[2],
142  const float X_low[32][40][2], int k0)
143 {
144  int k;
145  for (k = 0; k < k0; k++) {
146  LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
147  float dk;
148 
149  dsp->autocorrelate(X_low[k], phi);
150 
151  dk = phi[2][1][0] * phi[1][0][0] -
152  (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
153 
154  if (!dk) {
155  alpha1[k][0] = 0;
156  alpha1[k][1] = 0;
157  } else {
158  float temp_real, temp_im;
159  temp_real = phi[0][0][0] * phi[1][1][0] -
160  phi[0][0][1] * phi[1][1][1] -
161  phi[0][1][0] * phi[1][0][0];
162  temp_im = phi[0][0][0] * phi[1][1][1] +
163  phi[0][0][1] * phi[1][1][0] -
164  phi[0][1][1] * phi[1][0][0];
165 
166  alpha1[k][0] = temp_real / dk;
167  alpha1[k][1] = temp_im / dk;
168  }
169 
170  if (!phi[1][0][0]) {
171  alpha0[k][0] = 0;
172  alpha0[k][1] = 0;
173  } else {
174  float temp_real, temp_im;
175  temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
176  alpha1[k][1] * phi[1][1][1];
177  temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
178  alpha1[k][0] * phi[1][1][1];
179 
180  alpha0[k][0] = -temp_real / phi[1][0][0];
181  alpha0[k][1] = -temp_im / phi[1][0][0];
182  }
183 
184  if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
185  alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
186  alpha1[k][0] = 0;
187  alpha1[k][1] = 0;
188  alpha0[k][0] = 0;
189  alpha0[k][1] = 0;
190  }
191  }
192 }
193 
194 /// Chirp Factors (14496-3 sp04 p214)
195 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
196 {
197  int i;
198  float new_bw;
199  static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
200 
201  for (i = 0; i < sbr->n_q; i++) {
202  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
203  new_bw = 0.6f;
204  } else
205  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
206 
207  if (new_bw < ch_data->bw_array[i]) {
208  new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i];
209  } else
210  new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
211  ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
212  }
213 }
214 
215 /**
216  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
217  * and Calculation of gain (14496-3 sp04 p219)
218  */
220  SBRData *ch_data, const int e_a[2])
221 {
222  int e, k, m;
223  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
224  static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
225 
226  for (e = 0; e < ch_data->bs_num_env; e++) {
227  int delta = !((e == e_a[1]) || (e == e_a[0]));
228  for (k = 0; k < sbr->n_lim; k++) {
229  float gain_boost, gain_max;
230  float sum[2] = { 0.0f, 0.0f };
231  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
232  const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
233  sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
234  sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
235  if (!sbr->s_mapped[e][m]) {
236  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
237  ((1.0f + sbr->e_curr[e][m]) *
238  (1.0f + sbr->q_mapped[e][m] * delta)));
239  } else {
240  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
241  ((1.0f + sbr->e_curr[e][m]) *
242  (1.0f + sbr->q_mapped[e][m])));
243  }
244  }
245  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
246  sum[0] += sbr->e_origmapped[e][m];
247  sum[1] += sbr->e_curr[e][m];
248  }
249  gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
250  gain_max = FFMIN(100000.f, gain_max);
251  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
252  float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
253  sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
254  sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
255  }
256  sum[0] = sum[1] = 0.0f;
257  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
258  sum[0] += sbr->e_origmapped[e][m];
259  sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
260  + sbr->s_m[e][m] * sbr->s_m[e][m]
261  + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
262  }
263  gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
264  gain_boost = FFMIN(1.584893192f, gain_boost);
265  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
266  sbr->gain[e][m] *= gain_boost;
267  sbr->q_m[e][m] *= gain_boost;
268  sbr->s_m[e][m] *= gain_boost;
269  }
270  }
271  }
272 }
273 
274 /// Assembling HF Signals (14496-3 sp04 p220)
275 static void sbr_hf_assemble(float Y1[38][64][2],
276  const float X_high[64][40][2],
277  SpectralBandReplication *sbr, SBRData *ch_data,
278  const int e_a[2])
279 {
280  int e, i, j, m;
281  const int h_SL = 4 * !sbr->bs_smoothing_mode;
282  const int kx = sbr->kx[1];
283  const int m_max = sbr->m[1];
284  static const float h_smooth[5] = {
285  0.33333333333333,
286  0.30150283239582,
287  0.21816949906249,
288  0.11516383427084,
289  0.03183050093751,
290  };
291  float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
292  int indexnoise = ch_data->f_indexnoise;
293  int indexsine = ch_data->f_indexsine;
294 
295  if (sbr->reset) {
296  for (i = 0; i < h_SL; i++) {
297  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
298  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
299  }
300  } else if (h_SL) {
301  for (i = 0; i < 4; i++) {
302  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
303  g_temp[i + 2 * ch_data->t_env_num_env_old],
304  sizeof(g_temp[0]));
305  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
306  q_temp[i + 2 * ch_data->t_env_num_env_old],
307  sizeof(q_temp[0]));
308  }
309  }
310 
311  for (e = 0; e < ch_data->bs_num_env; e++) {
312  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
313  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
314  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
315  }
316  }
317 
318  for (e = 0; e < ch_data->bs_num_env; e++) {
319  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
320  LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
321  LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
322  float *g_filt, *q_filt;
323 
324  if (h_SL && e != e_a[0] && e != e_a[1]) {
325  g_filt = g_filt_tab;
326  q_filt = q_filt_tab;
327  for (m = 0; m < m_max; m++) {
328  const int idx1 = i + h_SL;
329  g_filt[m] = 0.0f;
330  q_filt[m] = 0.0f;
331  for (j = 0; j <= h_SL; j++) {
332  g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
333  q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
334  }
335  }
336  } else {
337  g_filt = g_temp[i + h_SL];
338  q_filt = q_temp[i];
339  }
340 
341  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
343 
344  if (e != e_a[0] && e != e_a[1]) {
345  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
346  q_filt, indexnoise,
347  kx, m_max);
348  } else {
349  int idx = indexsine&1;
350  int A = (1-((indexsine+(kx & 1))&2));
351  int B = (A^(-idx)) + idx;
352  float *out = &Y1[i][kx][idx];
353  float *in = sbr->s_m[e];
354  for (m = 0; m+1 < m_max; m+=2) {
355  out[2*m ] += in[m ] * A;
356  out[2*m+2] += in[m+1] * B;
357  }
358  if(m_max&1)
359  out[2*m ] += in[m ] * A;
360  }
361  indexnoise = (indexnoise + m_max) & 0x1ff;
362  indexsine = (indexsine + 1) & 3;
363  }
364  }
365  ch_data->f_indexnoise = indexnoise;
366  ch_data->f_indexsine = indexsine;
367 }
368 
369 #include "aacsbr_template.c"
uint8_t s_indexmapped[8][48]
Definition: sbr.h:97
#define NULL
Definition: coverity.c:32
static void sbr_hf_assemble(float Y1[38][64][2], const float X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])
Assembling HF Signals (14496-3 sp04 p220)
Definition: aacsbr.c:275
unsigned bs_smoothing_mode
Definition: sbr.h:154
INTFLOAT bw_array[5]
Chirp factors.
Definition: sbr.h:89
else temp
Definition: vf_mcdeint.c:259
Definition: aac.h:57
static void aacsbr_func_ptr_init(AACSBRContext *c)
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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
Definition: vf_geq.c:46
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
#define lrintf(x)
Definition: libm_mips.h:70
SBRData data[2]
Definition: sbr.h:166
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void sbr_hf_inverse_filter(SBRDSPContext *dsp, float(*alpha0)[2], float(*alpha1)[2], const float 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.c:140
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_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr.c:73
AAC_FLOAT g_temp[42][48]
Definition: sbr.h:95
Spectral Band Replication definitions and structures.
simple assert() macros that are a bit more flexible than ISO C assert().
static av_always_inline float ff_exp2fi(int x)
2^(x) for integer x
Definition: internal.h:262
Reference: libavcodec/aacsbr.c.
Definition: vlc.h:26
uint8_t env_facs_q[6][48]
Envelope scalefactors.
Definition: sbr.h:99
#define powf(x, y)
Definition: libm.h:50
AAC Spectral Band Replication decoding functions.
unsigned f_indexnoise
Definition: sbr.h:110
common internal API header
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
#define FFMIN(a, b)
Definition: common.h:96
unsigned bs_limiter_gains
Definition: sbr.h:152
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
AAC definitions and structures.
uint8_t bs_freq_res[7]
Definition: sbr.h:70
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.c:219
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:96
AAC_SIGNE bs_num_env
Definition: sbr.h:69
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:200
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
Replacements for frequently missing libm functions.
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr.c:195
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
AAC_FLOAT e_curr[7][48]
Estimated envelope.
Definition: sbr.h:204
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:74
#define M_SQRT2
Definition: mathematics.h:61
common internal api header.
unsigned f_indexsine
Definition: sbr.h:111
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
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_YASM &&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
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 void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr.c:54
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 AVCodec * c
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
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:121
void INT64 start
Definition: avisynth_c.h:690
static VLC vlc_sbr[10]
Definition: aacsbr.c:51
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