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 
50 static VLC vlc_sbr[10];
52 
53 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
54 {
55  int k, previous, present;
56  float base, prod;
57 
58  base = powf((float)stop / start, 1.0f / num_bands);
59  prod = start;
60  previous = start;
61 
62  for (k = 0; k < num_bands-1; k++) {
63  prod *= base;
64  present = lrintf(prod);
65  bands[k] = present - previous;
66  previous = present;
67  }
68  bands[num_bands-1] = stop - previous;
69 }
70 
71 /// Dequantization and stereo decoding (14496-3 sp04 p203)
72 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
73 {
74  int k, e;
75  int ch;
76  static const double exp2_tab[2] = {1, M_SQRT2};
77  if (id_aac == TYPE_CPE && sbr->bs_coupling) {
78  int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
79  for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
80  for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
81  float temp1, temp2, fac;
82  if (sbr->data[0].bs_amp_res) {
83  temp1 = ff_exp2fi(sbr->data[0].env_facs_q[e][k] + 7);
84  temp2 = ff_exp2fi(pan_offset - sbr->data[1].env_facs_q[e][k]);
85  }
86  else {
87  temp1 = ff_exp2fi((sbr->data[0].env_facs_q[e][k]>>1) + 7) *
88  exp2_tab[sbr->data[0].env_facs_q[e][k] & 1];
89  temp2 = ff_exp2fi((pan_offset - sbr->data[1].env_facs_q[e][k])>>1) *
90  exp2_tab[(pan_offset - sbr->data[1].env_facs_q[e][k]) & 1];
91  }
92  if (temp1 > 1E20) {
93  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
94  temp1 = 1;
95  }
96  fac = temp1 / (1.0f + temp2);
97  sbr->data[0].env_facs[e][k] = fac;
98  sbr->data[1].env_facs[e][k] = fac * temp2;
99  }
100  }
101  for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
102  for (k = 0; k < sbr->n_q; k++) {
103  float temp1 = ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs_q[e][k] + 1);
104  float temp2 = ff_exp2fi(12 - sbr->data[1].noise_facs_q[e][k]);
105  float fac;
106  av_assert0(temp1 <= 1E20);
107  fac = temp1 / (1.0f + temp2);
108  sbr->data[0].noise_facs[e][k] = fac;
109  sbr->data[1].noise_facs[e][k] = fac * temp2;
110  }
111  }
112  } else { // SCE or one non-coupled CPE
113  for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
114  for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
115  for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
116  if (sbr->data[ch].bs_amp_res)
117  sbr->data[ch].env_facs[e][k] = ff_exp2fi(sbr->data[ch].env_facs_q[e][k] + 6);
118  else
119  sbr->data[ch].env_facs[e][k] = ff_exp2fi((sbr->data[ch].env_facs_q[e][k]>>1) + 6)
120  * exp2_tab[sbr->data[ch].env_facs_q[e][k] & 1];
121  if (sbr->data[ch].env_facs[e][k] > 1E20) {
122  av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
123  sbr->data[ch].env_facs[e][k] = 1;
124  }
125  }
126 
127  for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
128  for (k = 0; k < sbr->n_q; k++)
129  sbr->data[ch].noise_facs[e][k] =
130  ff_exp2fi(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs_q[e][k]);
131  }
132  }
133 }
134 
135 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
136  * (14496-3 sp04 p214)
137  * Warning: This routine does not seem numerically stable.
138  */
140  float (*alpha0)[2], float (*alpha1)[2],
141  const float X_low[32][40][2], int k0)
142 {
143  int k;
144  for (k = 0; k < k0; k++) {
145  LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
146  float dk;
147 
148  dsp->autocorrelate(X_low[k], phi);
149 
150  dk = phi[2][1][0] * phi[1][0][0] -
151  (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
152 
153  if (!dk) {
154  alpha1[k][0] = 0;
155  alpha1[k][1] = 0;
156  } else {
157  float temp_real, temp_im;
158  temp_real = phi[0][0][0] * phi[1][1][0] -
159  phi[0][0][1] * phi[1][1][1] -
160  phi[0][1][0] * phi[1][0][0];
161  temp_im = phi[0][0][0] * phi[1][1][1] +
162  phi[0][0][1] * phi[1][1][0] -
163  phi[0][1][1] * phi[1][0][0];
164 
165  alpha1[k][0] = temp_real / dk;
166  alpha1[k][1] = temp_im / dk;
167  }
168 
169  if (!phi[1][0][0]) {
170  alpha0[k][0] = 0;
171  alpha0[k][1] = 0;
172  } else {
173  float temp_real, temp_im;
174  temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
175  alpha1[k][1] * phi[1][1][1];
176  temp_im = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
177  alpha1[k][0] * phi[1][1][1];
178 
179  alpha0[k][0] = -temp_real / phi[1][0][0];
180  alpha0[k][1] = -temp_im / phi[1][0][0];
181  }
182 
183  if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
184  alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
185  alpha1[k][0] = 0;
186  alpha1[k][1] = 0;
187  alpha0[k][0] = 0;
188  alpha0[k][1] = 0;
189  }
190  }
191 }
192 
193 /// Chirp Factors (14496-3 sp04 p214)
194 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
195 {
196  int i;
197  float new_bw;
198  static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
199 
200  for (i = 0; i < sbr->n_q; i++) {
201  if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
202  new_bw = 0.6f;
203  } else
204  new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
205 
206  if (new_bw < ch_data->bw_array[i]) {
207  new_bw = 0.75f * new_bw + 0.25f * ch_data->bw_array[i];
208  } else
209  new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
210  ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
211  }
212 }
213 
214 /**
215  * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
216  * and Calculation of gain (14496-3 sp04 p219)
217  */
219  SBRData *ch_data, const int e_a[2])
220 {
221  int e, k, m;
222  // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
223  static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
224 
225  for (e = 0; e < ch_data->bs_num_env; e++) {
226  int delta = !((e == e_a[1]) || (e == e_a[0]));
227  for (k = 0; k < sbr->n_lim; k++) {
228  float gain_boost, gain_max;
229  float sum[2] = { 0.0f, 0.0f };
230  for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
231  const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
232  sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
233  sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
234  if (!sbr->s_mapped[e][m]) {
235  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
236  ((1.0f + sbr->e_curr[e][m]) *
237  (1.0f + sbr->q_mapped[e][m] * delta)));
238  } else {
239  sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
240  ((1.0f + sbr->e_curr[e][m]) *
241  (1.0f + sbr->q_mapped[e][m])));
242  }
243  sbr->gain[e][m] += FLT_MIN;
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"
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:194
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:139
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
vlc_sbr
static VLC vlc_sbr[10]
Definition: aacsbr.c:50
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:275
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:190
float
float
Definition: af_crystalizer.c:122
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:131
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:53
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:122
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:269
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:72
SBRData::q_temp
AAC_FLOAT q_temp[42][48]
Definition: sbr.h:99
VLC
Definition: vlc.h:31
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:218
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: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