1/* 2 * Copyright (c) 2013 3 * MIPS Technologies, Inc., California. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its 14 * contributors may be used to endorse or promote products derived from 15 * this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * AAC Spectral Band Replication decoding functions (fixed-point) 30 * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl ) 31 * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com> 32 * 33 * This file is part of FFmpeg. 34 * 35 * FFmpeg is free software; you can redistribute it and/or 36 * modify it under the terms of the GNU Lesser General Public 37 * License as published by the Free Software Foundation; either 38 * version 2.1 of the License, or (at your option) any later version. 39 * 40 * FFmpeg is distributed in the hope that it will be useful, 41 * but WITHOUT ANY WARRANTY; without even the implied warranty of 42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 43 * Lesser General Public License for more details. 44 * 45 * You should have received a copy of the GNU Lesser General Public 46 * License along with FFmpeg; if not, write to the Free Software 47 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 48 */ 49 50/** 51 * @file 52 * AAC Spectral Band Replication decoding functions (fixed-point) 53 * Note: Rounding-to-nearest used unless otherwise stated 54 * @author Robert Swain ( rob opendot cl ) 55 * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com ) 56 */ 57#define USE_FIXED 1 58 59#include "aac.h" 60#include "sbr.h" 61#include "aacsbr.h" 62#include "aacsbrdata.h" 63#include "fft.h" 64#include "aacps.h" 65#include "sbrdsp.h" 66#include "libavutil/internal.h" 67#include "libavutil/libm.h" 68#include "libavutil/avassert.h" 69 70#include <stdint.h> 71#include <float.h> 72#include <math.h> 73 74static VLC vlc_sbr[10]; 75static void aacsbr_func_ptr_init(AACSBRContext *c); 76static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256 77static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2) 78static const int CONST_076923 = Q31(0.76923076923076923077f); 79 80static const int fixed_log_table[10] = 81{ 82 Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6), 83 Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11) 84}; 85 86static int fixed_log(int x) 87{ 88 int i, ret, xpow, tmp; 89 90 ret = x; 91 xpow = x; 92 for (i=0; i<10; i+=2){ 93 xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31); 94 tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31); 95 ret -= tmp; 96 97 xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31); 98 tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31); 99 ret += tmp; 100 } 101 102 return ret; 103} 104 105static const int fixed_exp_table[7] = 106{ 107 Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120), 108 Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320) 109}; 110 111static int fixed_exp(int x) 112{ 113 int i, ret, xpow, tmp; 114 115 ret = 0x800000 + x; 116 xpow = x; 117 for (i=0; i<7; i++){ 118 xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23); 119 tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31); 120 ret += tmp; 121 } 122 123 return ret; 124} 125 126static void make_bands(int16_t* bands, int start, int stop, int num_bands) 127{ 128 int k, previous, present; 129 int base, prod, nz = 0; 130 131 base = (stop << 23) / start; 132 while (base < 0x40000000){ 133 base <<= 1; 134 nz++; 135 } 136 base = fixed_log(base - 0x80000000); 137 base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands; 138 base = fixed_exp(base); 139 140 previous = start; 141 prod = start << 23; 142 143 for (k = 0; k < num_bands-1; k++) { 144 prod = (int)(((int64_t)prod * base + 0x400000) >> 23); 145 present = (prod + 0x400000) >> 23; 146 bands[k] = present - previous; 147 previous = present; 148 } 149 bands[num_bands-1] = stop - previous; 150} 151 152/// Dequantization and stereo decoding (14496-3 sp04 p203) 153static void sbr_dequant(SpectralBandReplication *sbr, int id_aac) 154{ 155 int k, e; 156 int ch; 157 158 if (id_aac == TYPE_CPE && sbr->bs_coupling) { 159 int alpha = sbr->data[0].bs_amp_res ? 2 : 1; 160 int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24; 161 for (e = 1; e <= sbr->data[0].bs_num_env; e++) { 162 for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) { 163 SoftFloat temp1, temp2, fac; 164 165 temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14; 166 if (temp1.exp & 1) 167 temp1.mant = 759250125; 168 else 169 temp1.mant = 0x20000000; 170 temp1.exp = (temp1.exp >> 1) + 1; 171 if (temp1.exp > 66) { // temp1 > 1E20 172 av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n"); 173 temp1 = FLOAT_1; 174 } 175 176 temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha; 177 if (temp2.exp & 1) 178 temp2.mant = 759250125; 179 else 180 temp2.mant = 0x20000000; 181 temp2.exp = (temp2.exp >> 1) + 1; 182 fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2)); 183 sbr->data[0].env_facs[e][k] = fac; 184 sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2); 185 } 186 } 187 for (e = 1; e <= sbr->data[0].bs_num_noise; e++) { 188 for (k = 0; k < sbr->n_q; k++) { 189 SoftFloat temp1, temp2, fac; 190 191 temp1.exp = NOISE_FLOOR_OFFSET - \ 192 sbr->data[0].noise_facs_q[e][k] + 2; 193 temp1.mant = 0x20000000; 194 av_assert0(temp1.exp <= 66); 195 temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1; 196 temp2.mant = 0x20000000; 197 fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2)); 198 sbr->data[0].noise_facs[e][k] = fac; 199 sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2); 200 } 201 } 202 } else { // SCE or one non-coupled CPE 203 for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) { 204 int alpha = sbr->data[ch].bs_amp_res ? 2 : 1; 205 for (e = 1; e <= sbr->data[ch].bs_num_env; e++) 206 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){ 207 SoftFloat temp1; 208 209 temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12; 210 if (temp1.exp & 1) 211 temp1.mant = 759250125; 212 else 213 temp1.mant = 0x20000000; 214 temp1.exp = (temp1.exp >> 1) + 1; 215 if (temp1.exp > 66) { // temp1 > 1E20 216 av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n"); 217 temp1 = FLOAT_1; 218 } 219 sbr->data[ch].env_facs[e][k] = temp1; 220 } 221 for (e = 1; e <= sbr->data[ch].bs_num_noise; e++) 222 for (k = 0; k < sbr->n_q; k++){ 223 sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \ 224 sbr->data[ch].noise_facs_q[e][k] + 1; 225 sbr->data[ch].noise_facs[e][k].mant = 0x20000000; 226 } 227 } 228 } 229} 230 231/** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering 232 * (14496-3 sp04 p214) 233 * Warning: This routine does not seem numerically stable. 234 */ 235static void sbr_hf_inverse_filter(SBRDSPContext *dsp, 236 int (*alpha0)[2], int (*alpha1)[2], 237 const int X_low[32][40][2], int k0) 238{ 239 int k; 240 int shift, round; 241 242 for (k = 0; k < k0; k++) { 243 SoftFloat phi[3][2][2]; 244 SoftFloat a00, a01, a10, a11; 245 SoftFloat dk; 246 247 dsp->autocorrelate(X_low[k], phi); 248 249 dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]), 250 av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]), 251 av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999)); 252 253 if (!dk.mant) { 254 a10 = FLOAT_0; 255 a11 = FLOAT_0; 256 } else { 257 SoftFloat temp_real, temp_im; 258 temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]), 259 av_mul_sf(phi[0][0][1], phi[1][1][1])), 260 av_mul_sf(phi[0][1][0], phi[1][0][0])); 261 temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]), 262 av_mul_sf(phi[0][0][1], phi[1][1][0])), 263 av_mul_sf(phi[0][1][1], phi[1][0][0])); 264 265 a10 = av_div_sf(temp_real, dk); 266 a11 = av_div_sf(temp_im, dk); 267 } 268 269 if (!phi[1][0][0].mant) { 270 a00 = FLOAT_0; 271 a01 = FLOAT_0; 272 } else { 273 SoftFloat temp_real, temp_im; 274 temp_real = av_add_sf(phi[0][0][0], 275 av_add_sf(av_mul_sf(a10, phi[1][1][0]), 276 av_mul_sf(a11, phi[1][1][1]))); 277 temp_im = av_add_sf(phi[0][0][1], 278 av_sub_sf(av_mul_sf(a11, phi[1][1][0]), 279 av_mul_sf(a10, phi[1][1][1]))); 280 281 temp_real.mant = -temp_real.mant; 282 temp_im.mant = -temp_im.mant; 283 a00 = av_div_sf(temp_real, phi[1][0][0]); 284 a01 = av_div_sf(temp_im, phi[1][0][0]); 285 } 286 287 shift = a00.exp; 288 if (shift >= 3) 289 alpha0[k][0] = 0x7fffffff; 290 else if (shift <= -30) 291 alpha0[k][0] = 0; 292 else { 293 shift = 1-shift; 294 if (shift <= 0) 295 alpha0[k][0] = a00.mant * (1<<-shift); 296 else { 297 round = 1 << (shift-1); 298 alpha0[k][0] = (a00.mant + round) >> shift; 299 } 300 } 301 302 shift = a01.exp; 303 if (shift >= 3) 304 alpha0[k][1] = 0x7fffffff; 305 else if (shift <= -30) 306 alpha0[k][1] = 0; 307 else { 308 shift = 1-shift; 309 if (shift <= 0) 310 alpha0[k][1] = a01.mant * (1<<-shift); 311 else { 312 round = 1 << (shift-1); 313 alpha0[k][1] = (a01.mant + round) >> shift; 314 } 315 } 316 shift = a10.exp; 317 if (shift >= 3) 318 alpha1[k][0] = 0x7fffffff; 319 else if (shift <= -30) 320 alpha1[k][0] = 0; 321 else { 322 shift = 1-shift; 323 if (shift <= 0) 324 alpha1[k][0] = a10.mant * (1<<-shift); 325 else { 326 round = 1 << (shift-1); 327 alpha1[k][0] = (a10.mant + round) >> shift; 328 } 329 } 330 331 shift = a11.exp; 332 if (shift >= 3) 333 alpha1[k][1] = 0x7fffffff; 334 else if (shift <= -30) 335 alpha1[k][1] = 0; 336 else { 337 shift = 1-shift; 338 if (shift <= 0) 339 alpha1[k][1] = a11.mant * (1<<-shift); 340 else { 341 round = 1 << (shift-1); 342 alpha1[k][1] = (a11.mant + round) >> shift; 343 } 344 } 345 346 shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \ 347 (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \ 348 0x40000000) >> 31); 349 if (shift >= 0x20000000){ 350 alpha1[k][0] = 0; 351 alpha1[k][1] = 0; 352 alpha0[k][0] = 0; 353 alpha0[k][1] = 0; 354 } 355 356 shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \ 357 (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \ 358 0x40000000) >> 31); 359 if (shift >= 0x20000000){ 360 alpha1[k][0] = 0; 361 alpha1[k][1] = 0; 362 alpha0[k][0] = 0; 363 alpha0[k][1] = 0; 364 } 365 } 366} 367 368/// Chirp Factors (14496-3 sp04 p214) 369static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data) 370{ 371 int i; 372 int new_bw; 373 static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 }; 374 int64_t accu; 375 376 for (i = 0; i < sbr->n_q; i++) { 377 if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) 378 new_bw = 1288490189; 379 else 380 new_bw = bw_tab[ch_data->bs_invf_mode[0][i]]; 381 382 if (new_bw < ch_data->bw_array[i]){ 383 accu = (int64_t)new_bw * 1610612736; 384 accu += (int64_t)ch_data->bw_array[i] * 0x20000000; 385 new_bw = (int)((accu + 0x40000000) >> 31); 386 } else { 387 accu = (int64_t)new_bw * 1946157056; 388 accu += (int64_t)ch_data->bw_array[i] * 201326592; 389 new_bw = (int)((accu + 0x40000000) >> 31); 390 } 391 ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw; 392 } 393} 394 395/** 396 * Calculation of levels of additional HF signal components (14496-3 sp04 p219) 397 * and Calculation of gain (14496-3 sp04 p219) 398 */ 399static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr, 400 SBRData *ch_data, const int e_a[2]) 401{ 402 int e, k, m; 403 // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off) 404 static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 }, 405 { 758351638, 1 }, { 625000000, 34 } }; 406 407 for (e = 0; e < ch_data->bs_num_env; e++) { 408 int delta = !((e == e_a[1]) || (e == e_a[0])); 409 for (k = 0; k < sbr->n_lim; k++) { 410 SoftFloat gain_boost, gain_max; 411 SoftFloat sum[2]; 412 sum[0] = sum[1] = FLOAT_0; 413 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { 414 const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m], 415 av_add_sf(FLOAT_1, sbr->q_mapped[e][m])); 416 sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m])); 417 sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0))); 418 if (!sbr->s_mapped[e][m]) { 419 if (delta) { 420 sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m], 421 av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]), 422 av_add_sf(FLOAT_1, sbr->q_mapped[e][m])))); 423 } else { 424 sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m], 425 av_add_sf(FLOAT_1, sbr->e_curr[e][m]))); 426 } 427 } else { 428 sbr->gain[e][m] = av_sqrt_sf( 429 av_div_sf( 430 av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]), 431 av_mul_sf( 432 av_add_sf(FLOAT_1, sbr->e_curr[e][m]), 433 av_add_sf(FLOAT_1, sbr->q_mapped[e][m])))); 434 } 435 sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN); 436 } 437 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { 438 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]); 439 sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]); 440 } 441 gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains], 442 av_sqrt_sf( 443 av_div_sf( 444 av_add_sf(FLOAT_EPSILON, sum[0]), 445 av_add_sf(FLOAT_EPSILON, sum[1])))); 446 if (av_gt_sf(gain_max, FLOAT_100000)) 447 gain_max = FLOAT_100000; 448 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { 449 SoftFloat q_m_max = av_div_sf( 450 av_mul_sf(sbr->q_m[e][m], gain_max), 451 sbr->gain[e][m]); 452 if (av_gt_sf(sbr->q_m[e][m], q_m_max)) 453 sbr->q_m[e][m] = q_m_max; 454 if (av_gt_sf(sbr->gain[e][m], gain_max)) 455 sbr->gain[e][m] = gain_max; 456 } 457 sum[0] = sum[1] = FLOAT_0; 458 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { 459 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]); 460 sum[1] = av_add_sf(sum[1], 461 av_mul_sf( 462 av_mul_sf(sbr->e_curr[e][m], 463 sbr->gain[e][m]), 464 sbr->gain[e][m])); 465 sum[1] = av_add_sf(sum[1], 466 av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m])); 467 if (delta && !sbr->s_m[e][m].mant) 468 sum[1] = av_add_sf(sum[1], 469 av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m])); 470 } 471 gain_boost = av_sqrt_sf( 472 av_div_sf( 473 av_add_sf(FLOAT_EPSILON, sum[0]), 474 av_add_sf(FLOAT_EPSILON, sum[1]))); 475 if (av_gt_sf(gain_boost, FLOAT_1584893192)) 476 gain_boost = FLOAT_1584893192; 477 478 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { 479 sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost); 480 sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost); 481 sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost); 482 } 483 } 484 } 485} 486 487/// Assembling HF Signals (14496-3 sp04 p220) 488static void sbr_hf_assemble(int Y1[38][64][2], 489 const int X_high[64][40][2], 490 SpectralBandReplication *sbr, SBRData *ch_data, 491 const int e_a[2]) 492{ 493 int e, i, j, m; 494 const int h_SL = 4 * !sbr->bs_smoothing_mode; 495 const int kx = sbr->kx[1]; 496 const int m_max = sbr->m[1]; 497 static const SoftFloat h_smooth[5] = { 498 { 715827883, -1 }, 499 { 647472402, -1 }, 500 { 937030863, -2 }, 501 { 989249804, -3 }, 502 { 546843842, -4 }, 503 }; 504 SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp; 505 int indexnoise = ch_data->f_indexnoise; 506 int indexsine = ch_data->f_indexsine; 507 508 if (sbr->reset) { 509 for (i = 0; i < h_SL; i++) { 510 memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0])); 511 memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0])); 512 } 513 } else if (h_SL) { 514 for (i = 0; i < 4; i++) { 515 memcpy(g_temp[i + 2 * ch_data->t_env[0]], 516 g_temp[i + 2 * ch_data->t_env_num_env_old], 517 sizeof(g_temp[0])); 518 memcpy(q_temp[i + 2 * ch_data->t_env[0]], 519 q_temp[i + 2 * ch_data->t_env_num_env_old], 520 sizeof(q_temp[0])); 521 } 522 } 523 524 for (e = 0; e < ch_data->bs_num_env; e++) { 525 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { 526 memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0])); 527 memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0])); 528 } 529 } 530 531 for (e = 0; e < ch_data->bs_num_env; e++) { 532 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { 533 SoftFloat g_filt_tab[48]; 534 SoftFloat q_filt_tab[48]; 535 SoftFloat *g_filt, *q_filt; 536 537 if (h_SL && e != e_a[0] && e != e_a[1]) { 538 g_filt = g_filt_tab; 539 q_filt = q_filt_tab; 540 for (m = 0; m < m_max; m++) { 541 const int idx1 = i + h_SL; 542 g_filt[m].mant = g_filt[m].exp = 0; 543 q_filt[m].mant = q_filt[m].exp = 0; 544 for (j = 0; j <= h_SL; j++) { 545 g_filt[m] = av_add_sf(g_filt[m], 546 av_mul_sf(g_temp[idx1 - j][m], 547 h_smooth[j])); 548 q_filt[m] = av_add_sf(q_filt[m], 549 av_mul_sf(q_temp[idx1 - j][m], 550 h_smooth[j])); 551 } 552 } 553 } else { 554 g_filt = g_temp[i + h_SL]; 555 q_filt = q_temp[i]; 556 } 557 558 sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max, 559 i + ENVELOPE_ADJUSTMENT_OFFSET); 560 561 if (e != e_a[0] && e != e_a[1]) { 562 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e], 563 q_filt, indexnoise, 564 kx, m_max); 565 } else { 566 int idx = indexsine&1; 567 int A = (1-((indexsine+(kx & 1))&2)); 568 int B = (A^(-idx)) + idx; 569 unsigned *out = &Y1[i][kx][idx]; 570 int shift; 571 unsigned round; 572 573 SoftFloat *in = sbr->s_m[e]; 574 for (m = 0; m+1 < m_max; m+=2) { 575 int shift2; 576 shift = 22 - in[m ].exp; 577 shift2= 22 - in[m+1].exp; 578 if (shift < 1 || shift2 < 1) { 579 av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2); 580 return; 581 } 582 if (shift < 32) { 583 round = 1 << (shift-1); 584 out[2*m ] += (int)(in[m ].mant * A + round) >> shift; 585 } 586 587 if (shift2 < 32) { 588 round = 1 << (shift2-1); 589 out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2; 590 } 591 } 592 if(m_max&1) 593 { 594 shift = 22 - in[m ].exp; 595 if (shift < 1) { 596 av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift); 597 return; 598 } else if (shift < 32) { 599 round = 1 << (shift-1); 600 out[2*m ] += (int)(in[m ].mant * A + round) >> shift; 601 } 602 } 603 } 604 indexnoise = (indexnoise + m_max) & 0x1ff; 605 indexsine = (indexsine + 1) & 3; 606 } 607 } 608 ch_data->f_indexnoise = indexnoise; 609 ch_data->f_indexsine = indexsine; 610} 611 612#include "aacsbr_template.c" 613