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 51static VLC vlc_sbr[10]; 52static void aacsbr_func_ptr_init(AACSBRContext *c); 53 54static 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) 73static 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 */ 140static 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) 195static 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 */ 219static 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) 276static 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" 371