FFmpeg
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 "aacps.h"
35 #include "sbrdsp.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/intfloat.h"
38 #include "libavutil/libm.h"
39 #include "libavutil/avassert.h"
40 #include "libavutil/mem_internal.h"
41 
42 #include <stdint.h>
43 #include <float.h>
44 #include <math.h>
45 
46 /**
47  * 2^(x) for integer x
48  * @return correctly rounded float
49  */
50 static av_always_inline float exp2fi(int x) {
51  /* Normal range */
52  if (-126 <= x && x <= 128)
53  return av_int2float((x+127) << 23);
54  /* Too large */
55  else if (x > 128)
56  return INFINITY;
57  /* Subnormal numbers */
58  else if (x > -150)
59  return av_int2float(1 << (x+149));
60  /* Negligibly small */
61  else
62  return 0;
63 }
64 
66 
67 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
68 {
69  int k, previous, present;
70  float base, prod;
71 
72  base = powf((float)stop / start, 1.0f / num_bands);
73  prod = start;
74  previous = start;
75 
76  for (k = 0; k < num_bands-1; k++) {
77  prod *= base;
78  present = lrintf(prod);
79  bands[k] = present - previous;
80  previous = present;
81  }
82  bands[num_bands-1] = stop - previous;
83 }
84 
85 /// Dequantization and stereo decoding (14496-3 sp04 p203)
86 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
87 {
88  int k, e;
89  int ch;
90  static const double exp2_tab[2] = {1, M_SQRT2};
91  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
92  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
93  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
94  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
95  float temp1, temp2, fac;
96  if (sbr->data[0].bs_amp_res) {
97  temp1 = exp2fi(sbr->data[0].env_facs_q[e][k] + 7);
98  temp2 = exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]);
99  }
100  else {
101  temp1 = exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) *
102  exp2_tab[sbr->data[0].env_facs_q[e][k] & 1];
103  temp2 = exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) *
104  exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1];
105  }
106  if (temp1 > 1E20) {
107  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
108  temp1 = 1;
109  }
110  fac = temp1 / (1.0f + temp2);
111  sbr->data[0].env_facs[e][k] = fac;
112  sbr->data[1].env_facs[e][k] = fac * temp2;
113  }
114  }
115  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
116  for (k = 0; k < sbr->n_q; k++) {
117  float temp1 = exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1);
118  float temp2 = exp2fi(12 - sbr->data[1].noise_facs_q[e][k]);
119  float fac;
120  av_assert0(temp1 <= 1E20);
121  fac = temp1 / (1.0f + temp2);
122  sbr->data[0].noise_facs[e][k] = fac;
123  sbr->data[1].noise_facs[e][k] = fac * temp2;
124  }
125  }
126  } else { // SCE or one non-coupled CPE
127  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
128  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
129  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
130  if (sbr->data[ch].bs_amp_res)
131  sbr->data[ch].env_facs[e][k] = exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
132  else
133  sbr->data[ch].env_facs[e][k] = exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
134  * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
135  if (sbr->data[ch].env_facs[e][k] > 1E20) {
136  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
137  sbr->data[ch].env_facs[e][k] = 1;
138  }
139  }
140 
141  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
142  for (k = 0; k < sbr->n_q; k++)
143  sbr->data[ch].noise_facs[e][k] =
144  exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
145  }
146  }
147 }
148 
149 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
150  * (14496-3 sp04 p214)
151  * Warning: This routine does not seem numerically stable.
152  */
154  float (*alpha0)[2], float (*alpha1)[2],
155  const float X_low[32][40][2], int k0)
156 {
157  int k;
158  for (k = 0; k < k0; k++) {
159  LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
160  float dk;
161 
162  dsp->autocorrelate(X_low[k], phi);
163 
164  dk = phi[2][1][0] * phi[1][0][0] -
165  (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
166 
167  if (!dk) {
168  alpha1[k][0] = 0;
169  alpha1[k][1] = 0;
170  } else {
171  float temp_real, temp_im;
172  temp_real = phi[0][0][0] * phi[1][1][0] -
173  phi[0][0][1] * phi[1][1][1] -
174  phi[0][1][0] * phi[1][0][0];
175  temp_im = phi[0][0][0] * phi[1][1][1] +
176  phi[0][0][1] * phi[1][1][0] -
177  phi[0][1][1] * phi[1][0][0];
178 
179  alpha1[k][0] = temp_real / dk;
180  alpha1[k][1] = temp_im / dk;
181  }
182 
183  if (!phi[1][0][0]) {
184  alpha0[k][0] = 0;
185  alpha0[k][1] = 0;
186  } else {
187  float temp_real, temp_im;
188  temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
189  alpha1[k][1] * phi[1][1][1];
190  temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
191  alpha1[k][0] * phi[1][1][1];
192 
193  alpha0[k][0] = -temp_real / phi[1][0][0];
194  alpha0[k][1] = -temp_im / phi[1][0][0];
195  }
196 
197  if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
198  alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
199  alpha1[k][0] = 0;
200  alpha1[k][1] = 0;
201  alpha0[k][0] = 0;
202  alpha0[k][1] = 0;
203  }
204  }
205 }
206 
207 /// Chirp Factors (14496-3 sp04 p214)
208 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
209 {
210  int i;
211  float new_bw;
212  static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
213 
214  for (i = 0; i < sbr->n_q; i++) {
215  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
216  new_bw = 0.6f;
217  } else
218  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
219 
220  if (new_bw < ch_data->bw_array[i]) {
221  new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i];
222  } else
223  new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
224  ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
225  }
226 }
227 
228 /**
229  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
230  * and Calculation of gain (14496-3 sp04 p219)
231  */
233  SBRData *ch_data, const int e_a[2])
234 {
235  int e, k, m;
236  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
237  static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
238 
239  for (e = 0; e < ch_data->bs_num_env; e++) {
240  int delta = !((e == e_a[1]) || (e == e_a[0]));
241  for (k = 0; k < sbr->n_lim; k++) {
242  float gain_boost, gain_max;
243  float sum[2] = { 0.0f, 0.0f };
244  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
245  const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
246  sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
247  sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
248  if (!sbr->s_mapped[e][m]) {
249  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
250  ((1.0f + sbr->e_curr[e][m]) *
251  (1.0f + sbr->q_mapped[e][m] * delta)));
252  } else {
253  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
254  ((1.0f + sbr->e_curr[e][m]) *
255  (1.0f + sbr->q_mapped[e][m])));
256  }
257  sbr->gain[e][m] += FLT_MIN;
258  }
259  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
260  sum[0] += sbr->e_origmapped[e][m];
261  sum[1] += sbr->e_curr[e][m];
262  }
263  gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
264  gain_max = FFMIN(100000.f, gain_max);
265  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
266  float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
267  sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
268  sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
269  }
270  sum[0] = sum[1] = 0.0f;
271  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
272  sum[0] += sbr->e_origmapped[e][m];
273  sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
274  + sbr->s_m[e][m] * sbr->s_m[e][m]
275  + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
276  }
277  gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
278  gain_boost = FFMIN(1.584893192f, gain_boost);
279  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
280  sbr->gain[e][m] *= gain_boost;
281  sbr->q_m[e][m] *= gain_boost;
282  sbr->s_m[e][m] *= gain_boost;
283  }
284  }
285  }
286 }
287 
288 /// Assembling HF Signals (14496-3 sp04 p220)
289 static void sbr_hf_assemble(float Y1[38][64][2],
290  const float X_high[64][40][2],
291  SpectralBandReplication *sbr, SBRData *ch_data,
292  const int e_a[2])
293 {
294  int e, i, j, m;
295  const int h_SL = 4 * !sbr->bs_smoothing_mode;
296  const int kx = sbr->kx[1];
297  const int m_max = sbr->m[1];
298  static const float h_smooth[5] = {
299  0.33333333333333,
300  0.30150283239582,
301  0.21816949906249,
302  0.11516383427084,
303  0.03183050093751,
304  };
305  float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
306  int indexnoise = ch_data->f_indexnoise;
307  int indexsine = ch_data->f_indexsine;
308 
309  if (sbr->reset) {
310  for (i = 0; i < h_SL; i++) {
311  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
312  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
313  }
314  } else if (h_SL) {
315  for (i = 0; i < 4; i++) {
316  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
317  g_temp[i + 2 * ch_data->t_env_num_env_old],
318  sizeof(g_temp[0]));
319  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
320  q_temp[i + 2 * ch_data->t_env_num_env_old],
321  sizeof(q_temp[0]));
322  }
323  }
324 
325  for (e = 0; e < ch_data->bs_num_env; e++) {
326  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
327  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
328  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
329  }
330  }
331 
332  for (e = 0; e < ch_data->bs_num_env; e++) {
333  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
334  LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
335  LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
336  float *g_filt, *q_filt;
337 
338  if (h_SL && e != e_a[0] && e != e_a[1]) {
339  g_filt = g_filt_tab;
340  q_filt = q_filt_tab;
341  for (m = 0; m < m_max; m++) {
342  const int idx1 = i + h_SL;
343  g_filt[m] = 0.0f;
344  q_filt[m] = 0.0f;
345  for (j = 0; j <= h_SL; j++) {
346  g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
347  q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
348  }
349  }
350  } else {
351  g_filt = g_temp[i + h_SL];
352  q_filt = q_temp[i];
353  }
354 
355  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
357 
358  if (e != e_a[0] && e != e_a[1]) {
359  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
360  q_filt, indexnoise,
361  kx, m_max);
362  } else {
363  int idx = indexsine&1;
364  int A = (1-((indexsine+(kx & 1))&2));
365  int B = (A^(-idx)) + idx;
366  float *out = &Y1[i][kx][idx];
367  float *in = sbr->s_m[e];
368  for (m = 0; m+1 < m_max; m+=2) {
369  out[2*m ] += in[m ] * A;
370  out[2*m+2] += in[m+1] * B;
371  }
372  if(m_max&1)
373  out[2*m ] += in[m ] * A;
374  }
375  indexnoise = (indexnoise + m_max) & 0x1ff;
376  indexsine = (indexsine + 1) & 3;
377  }
378  }
379  ch_data->f_indexnoise = indexnoise;
380  ch_data->f_indexsine = indexsine;
381 }
382 
383 #include "aacsbr_template.c"
A
#define A(x)
Definition: vpx_arith.h:28
SpectralBandReplication::bs_coupling
unsigned bs_coupling
Definition: sbr.h:163
SBRData::bs_freq_res
uint8_t bs_freq_res[9]
Definition: sbr.h:71
INFINITY
#define INFINITY
Definition: mathematics.h:118
SpectralBandReplication::data
SBRData data[2]
Definition: sbr.h:173
SpectralBandReplication::bs_limiter_gains
unsigned bs_limiter_gains
Definition: sbr.h:159
libm.h
mem_internal.h
SBRDSPContext
Definition: sbrdsp.h:27
out
FILE * out
Definition: movenc.c:55
sbr_chirp
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr.c:208
sbr_hf_inverse_filter
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:153
aacsbr.h
SpectralBandReplication::m
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:169
SBRData::t_env_num_env_old
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
Definition: sbr.h:108
SBRData::env_facs_q
uint8_t env_facs_q[9][48]
Envelope scalefactors.
Definition: sbr.h:100
base
uint8_t base
Definition: vp3data.h:128
float.h
intfloat.h
SpectralBandReplication::s_mapped
uint8_t s_mapped[8][48]
Sinusoidal presence, remapped.
Definition: sbr.h:209
sbr_gain_calc
static void sbr_gain_calc(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:232
sbr.h
SBRData::t_env
uint8_t t_env[9]
Envelope time borders.
Definition: sbr.h:106
aacps.h
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:41
SpectralBandReplication::reset
int reset
Definition: sbr.h:150
SBRData::noise_facs
AAC_FLOAT noise_facs[3][5]
Definition: sbr.h:104
sbr_hf_assemble
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:289
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
float
float
Definition: af_crystalizer.c:122
SBRData::env_facs
AAC_FLOAT env_facs[9][48]
Definition: sbr.h:101
SBRData::bs_num_noise
AAC_SIGNE bs_num_noise
Definition: sbr.h:72
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
B
#define B
Definition: huffyuv.h:42
NOISE_FLOOR_OFFSET
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.h:38
SBRData::g_temp
AAC_FLOAT g_temp[42][48]
Definition: sbr.h:96
SBRDSPContext::autocorrelate
void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])
Definition: sbrdsp.h:35
SpectralBandReplication::e_origmapped
AAC_FLOAT e_origmapped[8][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:205
bands
static const float bands[]
Definition: af_superequalizer.c:56
SpectralBandReplication::n_lim
AAC_SIGNE n_lim
Number of limiter bands.
Definition: sbr.h:180
NULL
#define NULL
Definition: coverity.c:32
SBRData::f_indexnoise
unsigned f_indexnoise
Definition: sbr.h:111
SpectralBandReplication::f_tablelim
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:190
AACSBRContext
aacsbr functions pointers
Definition: sbr.h:124
aac.h
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
SBRDSPContext::hf_g_filt
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:39
make_bands
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr.c:67
SpectralBandReplication::n
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.
Definition: sbr.h:176
SBRData::bs_num_env
AAC_SIGNE bs_num_env
Definition: sbr.h:70
SBRData::bs_amp_res
unsigned bs_amp_res
Definition: sbr.h:77
SpectralBandReplication::bs_smoothing_mode
unsigned bs_smoothing_mode
Definition: sbr.h:161
c
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
f
f
Definition: af_crystalizer.c:122
powf
#define powf(x, y)
Definition: libm.h:50
SpectralBandReplication::q_m
AAC_FLOAT q_m[8][48]
Amplitude adjusted noise scalefactors.
Definition: sbr.h:213
sbrdsp.h
SpectralBandReplication
Spectral Band Replication.
Definition: sbr.h:143
SBRData::bs_invf_mode
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:75
SBRDSPContext::hf_apply_noise
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:41
SpectralBandReplication::n_q
AAC_SIGNE n_q
Number of noise floor bands.
Definition: sbr.h:178
SpectralBandReplication::q_mapped
AAC_FLOAT q_mapped[8][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:207
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
internal.h
SBRData
Spectral Band Replication per channel data.
Definition: sbr.h:63
SBRData::bw_array
INTFLOAT bw_array[5]
Chirp factors.
Definition: sbr.h:90
delta
float delta
Definition: vorbis_enc_data.h:430
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SBRData::f_indexsine
unsigned f_indexsine
Definition: sbr.h:112
aacsbr_template.c
aacsbr_func_ptr_init
static void aacsbr_func_ptr_init(AACSBRContext *c)
sbr_dequant
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Definition: aacsbr.c:86
SBRData::q_temp
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:97
SpectralBandReplication::gain
AAC_FLOAT gain[8][48]
Definition: sbr.h:216
temp
else temp
Definition: vf_mcdeint.c:263
SBRData::noise_facs_q
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition: sbr.h:103
aacsbrdata.h
exp2fi
static av_always_inline float exp2fi(int x)
2^(x) for integer x
Definition: aacsbr.c:50
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:109
ENVELOPE_ADJUSTMENT_OFFSET
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.h:37
SpectralBandReplication::s_m
AAC_FLOAT s_m[8][48]
Sinusoidal levels.
Definition: sbr.h:215
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SBRData::s_indexmapped
uint8_t s_indexmapped[9][48]
Definition: sbr.h:98
SpectralBandReplication::kx
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:167
SpectralBandReplication::e_curr
AAC_FLOAT e_curr[8][48]
Estimated envelope.
Definition: sbr.h:211
SpectralBandReplication::dsp
SBRDSPContext dsp
Definition: sbr.h:222