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 "fft.h"
35 #include "internal.h"
36 #include "aacps.h"
37 #include "sbrdsp.h"
38 #include "libavutil/internal.h"
39 #include "libavutil/libm.h"
40 #include "libavutil/avassert.h"
41 #include "libavutil/mem_internal.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];
52 static void aacsbr_func_ptr_init(AACSBRContext *c);
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  */
140 static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
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  */
219 static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
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  sbr->gain[e][m] += FLT_MIN;
245  }
246  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
247  sum[0] += sbr->e_origmapped[e][m];
248  sum[1] += sbr->e_curr[e][m];
249  }
250  gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
251  gain_max = FFMIN(100000.f, gain_max);
252  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
253  float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
254  sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
255  sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
256  }
257  sum[0] = sum[1] = 0.0f;
258  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
259  sum[0] += sbr->e_origmapped[e][m];
260  sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
261  + sbr->s_m[e][m] * sbr->s_m[e][m]
262  + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
263  }
264  gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
265  gain_boost = FFMIN(1.584893192f, gain_boost);
266  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
267  sbr->gain[e][m] *= gain_boost;
268  sbr->q_m[e][m] *= gain_boost;
269  sbr->s_m[e][m] *= gain_boost;
270  }
271  }
272  }
273 }
274 
275 /// Assembling HF Signals (14496-3 sp04 p220)
276 static void sbr_hf_assemble(float Y1[38][64][2],
277  const float X_high[64][40][2],
278  SpectralBandReplication *sbr, SBRData *ch_data,
279  const int e_a[2])
280 {
281  int e, i, j, m;
282  const int h_SL = 4 * !sbr->bs_smoothing_mode;
283  const int kx = sbr->kx[1];
284  const int m_max = sbr->m[1];
285  static const float h_smooth[5] = {
286  0.33333333333333,
287  0.30150283239582,
288  0.21816949906249,
289  0.11516383427084,
290  0.03183050093751,
291  };
292  float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
293  int indexnoise = ch_data->f_indexnoise;
294  int indexsine = ch_data->f_indexsine;
295 
296  if (sbr->reset) {
297  for (i = 0; i < h_SL; i++) {
298  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
299  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
300  }
301  } else if (h_SL) {
302  for (i = 0; i < 4; i++) {
303  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
304  g_temp[i + 2 * ch_data->t_env_num_env_old],
305  sizeof(g_temp[0]));
306  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
307  q_temp[i + 2 * ch_data->t_env_num_env_old],
308  sizeof(q_temp[0]));
309  }
310  }
311 
312  for (e = 0; e < ch_data->bs_num_env; e++) {
313  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
314  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
315  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
316  }
317  }
318 
319  for (e = 0; e < ch_data->bs_num_env; e++) {
320  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
321  LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
322  LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
323  float *g_filt, *q_filt;
324 
325  if (h_SL && e != e_a[0] && e != e_a[1]) {
326  g_filt = g_filt_tab;
327  q_filt = q_filt_tab;
328  for (m = 0; m < m_max; m++) {
329  const int idx1 = i + h_SL;
330  g_filt[m] = 0.0f;
331  q_filt[m] = 0.0f;
332  for (j = 0; j <= h_SL; j++) {
333  g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
334  q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
335  }
336  }
337  } else {
338  g_filt = g_temp[i + h_SL];
339  q_filt = q_temp[i];
340  }
341 
342  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
343  i + ENVELOPE_ADJUSTMENT_OFFSET);
344 
345  if (e != e_a[0] && e != e_a[1]) {
346  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
347  q_filt, indexnoise,
348  kx, m_max);
349  } else {
350  int idx = indexsine&1;
351  int A = (1-((indexsine+(kx & 1))&2));
352  int B = (A^(-idx)) + idx;
353  float *out = &Y1[i][kx][idx];
354  float *in = sbr->s_m[e];
355  for (m = 0; m+1 < m_max; m+=2) {
356  out[2*m ] += in[m ] * A;
357  out[2*m+2] += in[m+1] * B;
358  }
359  if(m_max&1)
360  out[2*m ] += in[m ] * A;
361  }
362  indexnoise = (indexnoise + m_max) & 0x1ff;
363  indexsine = (indexsine + 1) & 3;
364  }
365  }
366  ch_data->f_indexnoise = indexnoise;
367  ch_data->f_indexsine = indexsine;
368 }
369 
370 #include "aacsbr_template.c"
SpectralBandReplication::bs_coupling
unsigned bs_coupling
Definition: sbr.h:159
SpectralBandReplication::data
SBRData data[2]
Definition: sbr.h:169
SpectralBandReplication::bs_limiter_gains
unsigned bs_limiter_gains
Definition: sbr.h:155
libm.h
mem_internal.h
SBRDSPContext
Definition: sbrdsp.h:28
out
FILE * out
Definition: movenc.c:54
SpectralBandReplication::e_origmapped
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
Definition: sbr.h:201
SBRData::env_facs
AAC_FLOAT env_facs[6][48]
Definition: sbr.h:103
sbr_chirp
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
Definition: aacsbr.c:195
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:140
aacsbr.h
internal.h
SpectralBandReplication::m
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
Definition: sbr.h:165
SpectralBandReplication::q_m
AAC_FLOAT q_m[7][48]
Amplitude adjusted noise scalefactors.
Definition: sbr.h:209
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:110
base
uint8_t base
Definition: vp3data.h:141
float.h
SBRData::t_env
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:108
vlc_sbr
static VLC vlc_sbr[10]
Definition: aacsbr.c:51
sbr.h
A
#define A(x)
Definition: vp56_arith.h:28
aacps.h
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:58
SpectralBandReplication::reset
int reset
Definition: sbr.h:147
SBRData::noise_facs
AAC_FLOAT noise_facs[3][5]
Definition: sbr.h:106
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:276
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_exp2fi
static av_always_inline float ff_exp2fi(int x)
2^(x) for integer x
Definition: internal.h:255
SBRData::bs_num_noise
AAC_SIGNE bs_num_noise
Definition: sbr.h:74
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
NOISE_FLOOR_OFFSET
#define NOISE_FLOOR_OFFSET
Definition: aacsbr.h:37
SBRData::g_temp
AAC_FLOAT g_temp[42][48]
Definition: sbr.h:98
SBRDSPContext::autocorrelate
void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])
Definition: sbrdsp.h:36
bands
static const float bands[]
Definition: af_superequalizer.c:56
f
#define f(width, name)
Definition: cbs_vp9.c:255
SpectralBandReplication::s_m
AAC_FLOAT s_m[7][48]
Sinusoidal levels.
Definition: sbr.h:211
SpectralBandReplication::n_lim
AAC_SIGNE n_lim
Number of limiter bands.
Definition: sbr.h:176
SBRData::env_facs_q
uint8_t env_facs_q[6][48]
Envelope scalefactors.
Definition: sbr.h:102
NULL
#define NULL
Definition: coverity.c:32
SBRData::f_indexnoise
unsigned f_indexnoise
Definition: sbr.h:113
SpectralBandReplication::f_tablelim
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Definition: sbr.h:186
AACSBRContext
aacsbr functions pointers
Definition: sbr.h:123
aac.h
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:40
make_bands
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
Definition: aacsbr.c:54
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:172
SBRData::bs_num_env
AAC_SIGNE bs_num_env
Definition: sbr.h:72
SBRData::bs_amp_res
unsigned bs_amp_res
Definition: sbr.h:79
SBRData::s_indexmapped
uint8_t s_indexmapped[8][48]
Definition: sbr.h:100
SpectralBandReplication::bs_smoothing_mode
unsigned bs_smoothing_mode
Definition: sbr.h:157
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
powf
#define powf(x, y)
Definition: libm.h:50
sbrdsp.h
SpectralBandReplication::gain
AAC_FLOAT gain[7][48]
Definition: sbr.h:212
SpectralBandReplication
Spectral Band Replication.
Definition: sbr.h:142
SBRData::bs_invf_mode
uint8_t bs_invf_mode[2][5]
Definition: sbr.h:77
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:42
SBRData::bs_freq_res
uint8_t bs_freq_res[7]
Definition: sbr.h:73
SpectralBandReplication::n_q
AAC_SIGNE n_q
Number of noise floor bands.
Definition: sbr.h:174
SpectralBandReplication::e_curr
AAC_FLOAT e_curr[7][48]
Estimated envelope.
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:271
internal.h
SBRData
Spectral Band Replication per channel data.
Definition: sbr.h:65
SBRData::bw_array
INTFLOAT bw_array[5]
Chirp factors.
Definition: sbr.h:92
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SBRData::f_indexsine
unsigned f_indexsine
Definition: sbr.h:114
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:73
SBRData::q_temp
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:99
B
#define B
Definition: huffyuvdsp.h:32
fft.h
VLC
Definition: vlc.h:26
temp
else temp
Definition: vf_mcdeint.c:248
SBRData::noise_facs_q
uint8_t noise_facs_q[3][5]
Noise scalefactors.
Definition: sbr.h:105
sbr_gain_calc
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
aacsbrdata.h
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:61
aacsbr_mips.h
ENVELOPE_ADJUSTMENT_OFFSET
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.h:36
AACContext
main AAC context
Definition: aac.h:294
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
SpectralBandReplication::q_mapped
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
Definition: sbr.h:203
SpectralBandReplication::kx
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
Definition: sbr.h:163
SpectralBandReplication::s_mapped
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
Definition: sbr.h:205
SpectralBandReplication::dsp
SBRDSPContext dsp
Definition: sbr.h:216
Generated on Wed Aug 24 2022 21:37:24 for FFmpeg by   doxygen 1.8.17