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