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 "internal.h"
35 #include "aacps.h"
36 #include "sbrdsp.h"
37 #include "libavutil/internal.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 #if ARCH_MIPS
47 #include "mips/aacsbr_mips.h"
48 #endif /* ARCH_MIPS */
49 
51 
52 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
53 {
54  int k, previous, present;
55  float base, prod;
56 
57  base = powf((float)stop / start, 1.0f / num_bands);
58  prod = start;
59  previous = start;
60 
61  for (k = 0; k < num_bands-1; k++) {
62  prod *= base;
63  present = lrintf(prod);
64  bands[k] = present - previous;
65  previous = present;
66  }
67  bands[num_bands-1] = stop - previous;
68 }
69 
70 /// Dequantization and stereo decoding (14496-3 sp04 p203)
71 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
72 {
73  int k, e;
74  int ch;
75  static const double exp2_tab[2] = {1, M_SQRT2};
76  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
77  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
78  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
79  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
80  float temp1, temp2, fac;
81  if (sbr->data[0].bs_amp_res) {
82  temp1 = ff_exp2fi(sbr->data[0].env_facs_q[e][k] + 7);
83  temp2 = ff_exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]);
84  }
85  else {
86  temp1 = ff_exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) *
87  exp2_tab[sbr->data[0].env_facs_q[e][k] & 1];
88  temp2 = ff_exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) *
89  exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1];
90  }
91  if (temp1 > 1E20) {
92  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
93  temp1 = 1;
94  }
95  fac = temp1 / (1.0f + temp2);
96  sbr->data[0].env_facs[e][k] = fac;
97  sbr->data[1].env_facs[e][k] = fac * temp2;
98  }
99  }
100  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
101  for (k = 0; k < sbr->n_q; k++) {
102  float temp1 = ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1);
103  float temp2 = ff_exp2fi(12 - sbr->data[1].noise_facs_q[e][k]);
104  float fac;
105  av_assert0(temp1 <= 1E20);
106  fac = temp1 / (1.0f + temp2);
107  sbr->data[0].noise_facs[e][k] = fac;
108  sbr->data[1].noise_facs[e][k] = fac * temp2;
109  }
110  }
111  } else { // SCE or one non-coupled CPE
112  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
113  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
114  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
115  if (sbr->data[ch].bs_amp_res)
116  sbr->data[ch].env_facs[e][k] = ff_exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
117  else
118  sbr->data[ch].env_facs[e][k] = ff_exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
119  * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
120  if (sbr->data[ch].env_facs[e][k] > 1E20) {
121  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
122  sbr->data[ch].env_facs[e][k] = 1;
123  }
124  }
125 
126  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
127  for (k = 0; k < sbr->n_q; k++)
128  sbr->data[ch].noise_facs[e][k] =
129  ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
130  }
131  }
132 }
133 
134 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
135  * (14496-3 sp04 p214)
136  * Warning: This routine does not seem numerically stable.
137  */
139  float (*alpha0)[2], float (*alpha1)[2],
140  const float X_low[32][40][2], int k0)
141 {
142  int k;
143  for (k = 0; k < k0; k++) {
144  LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
145  float dk;
146 
147  dsp->autocorrelate(X_low[k], phi);
148 
149  dk = phi[2][1][0] * phi[1][0][0] -
150  (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
151 
152  if (!dk) {
153  alpha1[k][0] = 0;
154  alpha1[k][1] = 0;
155  } else {
156  float temp_real, temp_im;
157  temp_real = phi[0][0][0] * phi[1][1][0] -
158  phi[0][0][1] * phi[1][1][1] -
159  phi[0][1][0] * phi[1][0][0];
160  temp_im = phi[0][0][0] * phi[1][1][1] +
161  phi[0][0][1] * phi[1][1][0] -
162  phi[0][1][1] * phi[1][0][0];
163 
164  alpha1[k][0] = temp_real / dk;
165  alpha1[k][1] = temp_im / dk;
166  }
167 
168  if (!phi[1][0][0]) {
169  alpha0[k][0] = 0;
170  alpha0[k][1] = 0;
171  } else {
172  float temp_real, temp_im;
173  temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
174  alpha1[k][1] * phi[1][1][1];
175  temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
176  alpha1[k][0] * phi[1][1][1];
177 
178  alpha0[k][0] = -temp_real / phi[1][0][0];
179  alpha0[k][1] = -temp_im / phi[1][0][0];
180  }
181 
182  if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
183  alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
184  alpha1[k][0] = 0;
185  alpha1[k][1] = 0;
186  alpha0[k][0] = 0;
187  alpha0[k][1] = 0;
188  }
189  }
190 }
191 
192 /// Chirp Factors (14496-3 sp04 p214)
193 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
194 {
195  int i;
196  float new_bw;
197  static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
198 
199  for (i = 0; i < sbr->n_q; i++) {
200  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
201  new_bw = 0.6f;
202  } else
203  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
204 
205  if (new_bw < ch_data->bw_array[i]) {
206  new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i];
207  } else
208  new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
209  ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
210  }
211 }
212 
213 /**
214  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
215  * and Calculation of gain (14496-3 sp04 p219)
216  */
218  SBRData *ch_data, const int e_a[2])
219 {
220  int e, k, m;
221  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
222  static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
223 
224  for (e = 0; e < ch_data->bs_num_env; e++) {
225  int delta = !((e == e_a[1]) || (e == e_a[0]));
226  for (k = 0; k < sbr->n_lim; k++) {
227  float gain_boost, gain_max;
228  float sum[2] = { 0.0f, 0.0f };
229  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
230  const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
231  sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
232  sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
233  if (!sbr->s_mapped[e][m]) {
234  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
235  ((1.0f + sbr->e_curr[e][m]) *
236  (1.0f + sbr->q_mapped[e][m] * delta)));
237  } else {
238  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
239  ((1.0f + sbr->e_curr[e][m]) *
240  (1.0f + sbr->q_mapped[e][m])));
241  }
242  sbr->gain[e][m] += FLT_MIN;
243  }
244  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
245  sum[0] += sbr->e_origmapped[e][m];
246  sum[1] += sbr->e_curr[e][m];
247  }
248  gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
249  gain_max = FFMIN(100000.f, gain_max);
250  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
251  float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
252  sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
253  sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
254  }
255  sum[0] = sum[1] = 0.0f;
256  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
257  sum[0] += sbr->e_origmapped[e][m];
258  sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
259  + sbr->s_m[e][m] * sbr->s_m[e][m]
260  + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
261  }
262  gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
263  gain_boost = FFMIN(1.584893192f, gain_boost);
264  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
265  sbr->gain[e][m] *= gain_boost;
266  sbr->q_m[e][m] *= gain_boost;
267  sbr->s_m[e][m] *= gain_boost;
268  }
269  }
270  }
271 }
272 
273 /// Assembling HF Signals (14496-3 sp04 p220)
274 static void sbr_hf_assemble(float Y1[38][64][2],
275  const float X_high[64][40][2],
276  SpectralBandReplication *sbr, SBRData *ch_data,
277  const int e_a[2])
278 {
279  int e, i, j, m;
280  const int h_SL = 4 * !sbr->bs_smoothing_mode;
281  const int kx = sbr->kx[1];
282  const int m_max = sbr->m[1];
283  static const float h_smooth[5] = {
284  0.33333333333333,
285  0.30150283239582,
286  0.21816949906249,
287  0.11516383427084,
288  0.03183050093751,
289  };
290  float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
291  int indexnoise = ch_data->f_indexnoise;
292  int indexsine = ch_data->f_indexsine;
293 
294  if (sbr->reset) {
295  for (i = 0; i < h_SL; i++) {
296  memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
297  memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
298  }
299  } else if (h_SL) {
300  for (i = 0; i < 4; i++) {
301  memcpy(g_temp[i + 2 * ch_data->t_env[0]],
302  g_temp[i + 2 * ch_data->t_env_num_env_old],
303  sizeof(g_temp[0]));
304  memcpy(q_temp[i + 2 * ch_data->t_env[0]],
305  q_temp[i + 2 * ch_data->t_env_num_env_old],
306  sizeof(q_temp[0]));
307  }
308  }
309 
310  for (e = 0; e < ch_data->bs_num_env; e++) {
311  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
312  memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
313  memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
314  }
315  }
316 
317  for (e = 0; e < ch_data->bs_num_env; e++) {
318  for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
319  LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
320  LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
321  float *g_filt, *q_filt;
322 
323  if (h_SL && e != e_a[0] && e != e_a[1]) {
324  g_filt = g_filt_tab;
325  q_filt = q_filt_tab;
326  for (m = 0; m < m_max; m++) {
327  const int idx1 = i + h_SL;
328  g_filt[m] = 0.0f;
329  q_filt[m] = 0.0f;
330  for (j = 0; j <= h_SL; j++) {
331  g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
332  q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
333  }
334  }
335  } else {
336  g_filt = g_temp[i + h_SL];
337  q_filt = q_temp[i];
338  }
339 
340  sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
342 
343  if (e != e_a[0] && e != e_a[1]) {
344  sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
345  q_filt, indexnoise,
346  kx, m_max);
347  } else {
348  int idx = indexsine&1;
349  int A = (1-((indexsine+(kx & 1))&2));
350  int B = (A^(-idx)) + idx;
351  float *out = &Y1[i][kx][idx];
352  float *in = sbr->s_m[e];
353  for (m = 0; m+1 < m_max; m+=2) {
354  out[2*m ] += in[m ] * A;
355  out[2*m+2] += in[m+1] * B;
356  }
357  if(m_max&1)
358  out[2*m ] += in[m ] * A;
359  }
360  indexnoise = (indexnoise + m_max) & 0x1ff;
361  indexsine = (indexsine + 1) & 3;
362  }
363  }
364  ch_data->f_indexnoise = indexnoise;
365  ch_data->f_indexsine = indexsine;
366 }
367 
368 #include "aacsbr_template.c"
A
#define A(x)
Definition: vpx_arith.h:28
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:27
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:193
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:138
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:128
float.h
SBRData::t_env
uint8_t t_env[8]
Envelope time borders.
Definition: sbr.h:108
sbr.h
aacps.h
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:56
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:274
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:164
float
float
Definition: af_crystalizer.c:121
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:129
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: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:35
bands
static const float bands[]
Definition: af_superequalizer.c:56
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
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:52
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
f
f
Definition: af_crystalizer.c:121
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:41
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:245
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:71
SBRData::q_temp
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:99
temp
else temp
Definition: vf_mcdeint.c:263
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:217
aacsbrdata.h
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:109
aacsbr_mips.h
ENVELOPE_ADJUSTMENT_OFFSET
#define ENVELOPE_ADJUSTMENT_OFFSET
Definition: aacsbr.h:36
AACContext
main AAC context
Definition: aac.h:296
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:218