56 int k, previous, present;
59 base =
powf((
float)stop / start, 1.0
f / num_bands);
63 for (k = 0; k < num_bands-1; k++) {
66 bands[k] = present - previous;
69 bands[num_bands-1] = stop - previous;
77 static const double exp2_tab[2] = {1,
M_SQRT2};
82 float temp1, temp2, fac;
97 fac = temp1 / (1.0f + temp2);
103 for (k = 0; k < sbr->
n_q; k++) {
108 fac = temp1 / (1.0f + temp2);
114 for (ch = 0; ch < (id_aac ==
TYPE_CPE) + 1; ch++) {
129 for (k = 0; k < sbr->
n_q; k++)
141 float (*alpha0)[2],
float (*alpha1)[2],
142 const float X_low[32][40][2],
int k0)
145 for (k = 0; k < k0; k++) {
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.000001
f;
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];
166 alpha1[k][0] = temp_real / dk;
167 alpha1[k][1] = temp_im / dk;
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];
180 alpha0[k][0] = -temp_real / phi[1][0][0];
181 alpha0[k][1] = -temp_im / phi[1][0][0];
184 if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0
f ||
185 alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0
f) {
199 static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
201 for (i = 0; i < sbr->
n_q; i++) {
207 if (new_bw < ch_data->bw_array[i]) {
208 new_bw = 0.75f * new_bw + 0.25f * ch_data->
bw_array[
i];
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;
220 SBRData *ch_data,
const int e_a[2])
224 static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
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++) {
233 sbr->
q_m[e][m] = sqrtf(temp * sbr->
q_mapped[e][m]);
237 ((1.0f + sbr->
e_curr[e][m]) *
238 (1.0f + sbr->
q_mapped[e][m] * delta)));
241 ((1.0f + sbr->
e_curr[e][m]) *
244 sbr->
gain[e][m] += FLT_MIN;
246 for (m = sbr->
f_tablelim[k] - sbr->
kx[1]; m < sbr->f_tablelim[k + 1] - sbr->
kx[1]; m++) {
248 sum[1] += sbr->
e_curr[e][m];
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];
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++) {
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];
264 gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
265 gain_boost =
FFMIN(1.584893192
f, 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;
277 const float X_high[64][40][2],
283 const int kx = sbr->
kx[1];
284 const int m_max = sbr->
m[1];
285 static const float h_smooth[5] = {
292 float (*g_temp)[48] = ch_data->
g_temp, (*q_temp)[48] = ch_data->
q_temp;
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]));
302 for (i = 0; i < 4; i++) {
303 memcpy(g_temp[i + 2 * ch_data->
t_env[0]],
306 memcpy(q_temp[i + 2 * ch_data->
t_env[0]],
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]));
320 for (i = 2 * ch_data->
t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
323 float *g_filt, *q_filt;
325 if (h_SL && e != e_a[0] && e != e_a[1]) {
328 for (m = 0; m < m_max; m++) {
329 const int idx1 = i + h_SL;
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];
338 g_filt = g_temp[i + h_SL];
342 sbr->
dsp.
hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
345 if (e != e_a[0] && e != e_a[1]) {
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;
360 out[2*m ] += in[m ] *
A;
362 indexnoise = (indexnoise + m_max) & 0x1ff;
363 indexsine = (indexsine + 1) & 3;
uint8_t s_indexmapped[8][48]
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)
unsigned bs_smoothing_mode
INTFLOAT bw_array[5]
Chirp factors.
static void aacsbr_func_ptr_init(AACSBRContext *c)
AAC_SIGNE kx[2]
kx', and kx respectively, kx is the first QMF subband where SBR is used.
uint8_t noise_facs_q[3][5]
Noise scalefactors.
#define LOCAL_ALIGNED_16(t, v,...)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
AAC_FLOAT noise_facs[3][5]
AAC_SIGNE n_lim
Number of limiter bands.
#define ENVELOPE_ADJUSTMENT_OFFSET
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
AAC Spectral Band Replication decoding data.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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...
AAC_SIGNE m[2]
M' and M respectively, M is the number of QMF subbands that use SBR.
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
Dequantization and stereo decoding (14496-3 sp04 p203)
Spectral Band Replication definitions and structures.
simple assert() macros that are a bit more flexible than ISO C assert().
static av_always_inline float ff_exp2fi(int x)
2^(x) for integer x
Reference: libavcodec/aacsbr.c.
uint8_t env_facs_q[6][48]
Envelope scalefactors.
AAC Spectral Band Replication decoding functions.
common internal API header
uint8_t t_env_num_env_old
Envelope time border of the last envelope of the previous frame.
AAC Spectral Band Replication function declarations.
unsigned bs_limiter_gains
AAC_FLOAT e_origmapped[7][48]
Dequantized envelope scalefactors, remapped.
uint8_t s_mapped[7][48]
Sinusoidal presence, remapped.
AAC definitions and structures.
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 ...
AAC_FLOAT q_mapped[7][48]
Dequantized noise scalefactors, remapped.
static const float bands[]
Replacements for frequently missing libm functions.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
Chirp Factors (14496-3 sp04 p214)
AAC_FLOAT q_m[7][48]
Amplitude adjusted noise scalefactors.
AAC_FLOAT env_facs[6][48]
#define NOISE_FLOOR_OFFSET
AAC_FLOAT e_curr[7][48]
Estimated envelope.
uint8_t bs_invf_mode[2][5]
void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])
common internal api header.
uint8_t t_env[8]
Envelope time borders.
aacsbr functions pointers
AAC_FLOAT s_m[7][48]
Sinusoidal levels.
uint16_t f_tablelim[30]
Frequency borders for the limiter.
Spectral Band Replication per channel data.
static void make_bands(int16_t *bands, int start, int stop, int num_bands)
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)
void(* hf_g_filt)(INTFLOAT(*Y)[2], const INTFLOAT(*X_high)[40][2], const AAC_FLOAT *g_filt, int m_max, intptr_t ixh)
AAC_SIGNE n_q
Number of noise floor bands.
Spectral Band Replication.
AAC_SIGNE n[2]
N_Low and N_High respectively, the number of frequency bands for low and high resolution.