1 /* ----------------------------------------------------------------------------- 2 Software License for The Fraunhofer FDK AAC Codec Library for Android 3 4 Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Frderung der angewandten 5 Forschung e.V. All rights reserved. 6 7 1. INTRODUCTION 8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software 9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding 10 scheme for digital audio. This FDK AAC Codec software is intended to be used on 11 a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient 14 general perceptual audio codecs. AAC-ELD is considered the best-performing 15 full-bandwidth communications codec by independent studies and is widely 16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG 17 specifications. 18 19 Patent licenses for necessary patent claims for the FDK AAC Codec (including 20 those of Fraunhofer) may be obtained through Via Licensing 21 (www.vialicensing.com) or through the respective patent owners individually for 22 the purpose of encoding or decoding bit streams in products that are compliant 23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of 24 Android devices already license these patent claims through Via Licensing or 25 directly from the patent owners, and therefore FDK AAC Codec software may 26 already be covered under those patent licenses when it is used for those 27 licensed purposes only. 28 29 Commercially-licensed AAC software libraries, including floating-point versions 30 with enhanced sound quality, are also available from Fraunhofer. Users are 31 encouraged to check the Fraunhofer website for additional applications 32 information and documentation. 33 34 2. COPYRIGHT LICENSE 35 36 Redistribution and use in source and binary forms, with or without modification, 37 are permitted without payment of copyright license fees provided that you 38 satisfy the following conditions: 39 40 You must retain the complete text of this software license in redistributions of 41 the FDK AAC Codec or your modifications thereto in source code form. 42 43 You must retain the complete text of this software license in the documentation 44 and/or other materials provided with redistributions of the FDK AAC Codec or 45 your modifications thereto in binary form. You must make available free of 46 charge copies of the complete source code of the FDK AAC Codec and your 47 modifications thereto to recipients of copies in binary form. 48 49 The name of Fraunhofer may not be used to endorse or promote products derived 50 from this library without prior written permission. 51 52 You may not charge copyright license fees for anyone to use, copy or distribute 53 the FDK AAC Codec software or your modifications thereto. 54 55 Your modified versions of the FDK AAC Codec must carry prominent notices stating 56 that you changed the software and the date of any change. For modified versions 57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" 58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK 59 AAC Codec Library for Android." 60 61 3. NO PATENT LICENSE 62 63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without 64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. 65 Fraunhofer provides no warranty of patent non-infringement with respect to this 66 software. 67 68 You may use this FDK AAC Codec software or modifications thereto only for 69 purposes that are authorized by appropriate patent licenses. 70 71 4. DISCLAIMER 72 73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright 74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, 75 including but not limited to the implied warranties of merchantability and 76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, 78 or consequential damages, including but not limited to procurement of substitute 79 goods or services; loss of use, data, or profits, or business interruption, 80 however caused and on any theory of liability, whether in contract, strict 81 liability, or tort (including negligence), arising in any way out of the use of 82 this software, even if advised of the possibility of such damage. 83 84 5. CONTACT INFORMATION 85 86 Fraunhofer Institute for Integrated Circuits IIS 87 Attention: Audio and Multimedia Departments - FDK AAC LL 88 Am Wolfsmantel 33 89 91058 Erlangen, Germany 90 91 www.iis.fraunhofer.de/amm 92 amm-info (at) iis.fraunhofer.de 93 ----------------------------------------------------------------------------- */ 94 95 /**************************** SBR encoder library ****************************** 96 97 Author(s): 98 99 Description: 100 101 *******************************************************************************/ 102 103 #include "code_env.h" 104 #include "sbrenc_rom.h" 105 106 /***************************************************************************** 107 108 functionname: FDKsbrEnc_InitSbrHuffmanTables 109 description: initializes Huffman Tables dependent on chosen amp_res 110 returns: error handle 111 input: 112 output: 113 114 *****************************************************************************/ 115 INT FDKsbrEnc_InitSbrHuffmanTables(HANDLE_SBR_ENV_DATA sbrEnvData, 116 HANDLE_SBR_CODE_ENVELOPE henv, 117 HANDLE_SBR_CODE_ENVELOPE hnoise, 118 AMP_RES amp_res) { 119 if ((!henv) || (!hnoise) || (!sbrEnvData)) return (1); /* not init. */ 120 121 sbrEnvData->init_sbr_amp_res = amp_res; 122 123 switch (amp_res) { 124 case SBR_AMP_RES_3_0: 125 /*envelope data*/ 126 127 /*Level/Pan - coding */ 128 sbrEnvData->hufftableLevelTimeC = v_Huff_envelopeLevelC11T; 129 sbrEnvData->hufftableLevelTimeL = v_Huff_envelopeLevelL11T; 130 sbrEnvData->hufftableBalanceTimeC = bookSbrEnvBalanceC11T; 131 sbrEnvData->hufftableBalanceTimeL = bookSbrEnvBalanceL11T; 132 133 sbrEnvData->hufftableLevelFreqC = v_Huff_envelopeLevelC11F; 134 sbrEnvData->hufftableLevelFreqL = v_Huff_envelopeLevelL11F; 135 sbrEnvData->hufftableBalanceFreqC = bookSbrEnvBalanceC11F; 136 sbrEnvData->hufftableBalanceFreqL = bookSbrEnvBalanceL11F; 137 138 /*Right/Left - coding */ 139 sbrEnvData->hufftableTimeC = v_Huff_envelopeLevelC11T; 140 sbrEnvData->hufftableTimeL = v_Huff_envelopeLevelL11T; 141 sbrEnvData->hufftableFreqC = v_Huff_envelopeLevelC11F; 142 sbrEnvData->hufftableFreqL = v_Huff_envelopeLevelL11F; 143 144 sbrEnvData->codeBookScfLavBalance = CODE_BOOK_SCF_LAV_BALANCE11; 145 sbrEnvData->codeBookScfLav = CODE_BOOK_SCF_LAV11; 146 147 sbrEnvData->si_sbr_start_env_bits = SI_SBR_START_ENV_BITS_AMP_RES_3_0; 148 sbrEnvData->si_sbr_start_env_bits_balance = 149 SI_SBR_START_ENV_BITS_BALANCE_AMP_RES_3_0; 150 break; 151 152 case SBR_AMP_RES_1_5: 153 /*envelope data*/ 154 155 /*Level/Pan - coding */ 156 sbrEnvData->hufftableLevelTimeC = v_Huff_envelopeLevelC10T; 157 sbrEnvData->hufftableLevelTimeL = v_Huff_envelopeLevelL10T; 158 sbrEnvData->hufftableBalanceTimeC = bookSbrEnvBalanceC10T; 159 sbrEnvData->hufftableBalanceTimeL = bookSbrEnvBalanceL10T; 160 161 sbrEnvData->hufftableLevelFreqC = v_Huff_envelopeLevelC10F; 162 sbrEnvData->hufftableLevelFreqL = v_Huff_envelopeLevelL10F; 163 sbrEnvData->hufftableBalanceFreqC = bookSbrEnvBalanceC10F; 164 sbrEnvData->hufftableBalanceFreqL = bookSbrEnvBalanceL10F; 165 166 /*Right/Left - coding */ 167 sbrEnvData->hufftableTimeC = v_Huff_envelopeLevelC10T; 168 sbrEnvData->hufftableTimeL = v_Huff_envelopeLevelL10T; 169 sbrEnvData->hufftableFreqC = v_Huff_envelopeLevelC10F; 170 sbrEnvData->hufftableFreqL = v_Huff_envelopeLevelL10F; 171 172 sbrEnvData->codeBookScfLavBalance = CODE_BOOK_SCF_LAV_BALANCE10; 173 sbrEnvData->codeBookScfLav = CODE_BOOK_SCF_LAV10; 174 175 sbrEnvData->si_sbr_start_env_bits = SI_SBR_START_ENV_BITS_AMP_RES_1_5; 176 sbrEnvData->si_sbr_start_env_bits_balance = 177 SI_SBR_START_ENV_BITS_BALANCE_AMP_RES_1_5; 178 break; 179 180 default: 181 return (1); /* undefined amp_res mode */ 182 } 183 184 /* these are common to both amp_res values */ 185 /*Noise data*/ 186 187 /*Level/Pan - coding */ 188 sbrEnvData->hufftableNoiseLevelTimeC = v_Huff_NoiseLevelC11T; 189 sbrEnvData->hufftableNoiseLevelTimeL = v_Huff_NoiseLevelL11T; 190 sbrEnvData->hufftableNoiseBalanceTimeC = bookSbrNoiseBalanceC11T; 191 sbrEnvData->hufftableNoiseBalanceTimeL = bookSbrNoiseBalanceL11T; 192 193 sbrEnvData->hufftableNoiseLevelFreqC = v_Huff_envelopeLevelC11F; 194 sbrEnvData->hufftableNoiseLevelFreqL = v_Huff_envelopeLevelL11F; 195 sbrEnvData->hufftableNoiseBalanceFreqC = bookSbrEnvBalanceC11F; 196 sbrEnvData->hufftableNoiseBalanceFreqL = bookSbrEnvBalanceL11F; 197 198 /*Right/Left - coding */ 199 sbrEnvData->hufftableNoiseTimeC = v_Huff_NoiseLevelC11T; 200 sbrEnvData->hufftableNoiseTimeL = v_Huff_NoiseLevelL11T; 201 sbrEnvData->hufftableNoiseFreqC = v_Huff_envelopeLevelC11F; 202 sbrEnvData->hufftableNoiseFreqL = v_Huff_envelopeLevelL11F; 203 204 sbrEnvData->si_sbr_start_noise_bits = SI_SBR_START_NOISE_BITS_AMP_RES_3_0; 205 sbrEnvData->si_sbr_start_noise_bits_balance = 206 SI_SBR_START_NOISE_BITS_BALANCE_AMP_RES_3_0; 207 208 /* init envelope tables and codebooks */ 209 henv->codeBookScfLavBalanceTime = sbrEnvData->codeBookScfLavBalance; 210 henv->codeBookScfLavBalanceFreq = sbrEnvData->codeBookScfLavBalance; 211 henv->codeBookScfLavLevelTime = sbrEnvData->codeBookScfLav; 212 henv->codeBookScfLavLevelFreq = sbrEnvData->codeBookScfLav; 213 henv->codeBookScfLavTime = sbrEnvData->codeBookScfLav; 214 henv->codeBookScfLavFreq = sbrEnvData->codeBookScfLav; 215 216 henv->hufftableLevelTimeL = sbrEnvData->hufftableLevelTimeL; 217 henv->hufftableBalanceTimeL = sbrEnvData->hufftableBalanceTimeL; 218 henv->hufftableTimeL = sbrEnvData->hufftableTimeL; 219 henv->hufftableLevelFreqL = sbrEnvData->hufftableLevelFreqL; 220 henv->hufftableBalanceFreqL = sbrEnvData->hufftableBalanceFreqL; 221 henv->hufftableFreqL = sbrEnvData->hufftableFreqL; 222 223 henv->codeBookScfLavFreq = sbrEnvData->codeBookScfLav; 224 henv->codeBookScfLavTime = sbrEnvData->codeBookScfLav; 225 226 henv->start_bits = sbrEnvData->si_sbr_start_env_bits; 227 henv->start_bits_balance = sbrEnvData->si_sbr_start_env_bits_balance; 228 229 /* init noise tables and codebooks */ 230 231 hnoise->codeBookScfLavBalanceTime = CODE_BOOK_SCF_LAV_BALANCE11; 232 hnoise->codeBookScfLavBalanceFreq = CODE_BOOK_SCF_LAV_BALANCE11; 233 hnoise->codeBookScfLavLevelTime = CODE_BOOK_SCF_LAV11; 234 hnoise->codeBookScfLavLevelFreq = CODE_BOOK_SCF_LAV11; 235 hnoise->codeBookScfLavTime = CODE_BOOK_SCF_LAV11; 236 hnoise->codeBookScfLavFreq = CODE_BOOK_SCF_LAV11; 237 238 hnoise->hufftableLevelTimeL = sbrEnvData->hufftableNoiseLevelTimeL; 239 hnoise->hufftableBalanceTimeL = sbrEnvData->hufftableNoiseBalanceTimeL; 240 hnoise->hufftableTimeL = sbrEnvData->hufftableNoiseTimeL; 241 hnoise->hufftableLevelFreqL = sbrEnvData->hufftableNoiseLevelFreqL; 242 hnoise->hufftableBalanceFreqL = sbrEnvData->hufftableNoiseBalanceFreqL; 243 hnoise->hufftableFreqL = sbrEnvData->hufftableNoiseFreqL; 244 245 hnoise->start_bits = sbrEnvData->si_sbr_start_noise_bits; 246 hnoise->start_bits_balance = sbrEnvData->si_sbr_start_noise_bits_balance; 247 248 /* No delta coding in time from the previous frame due to 1.5dB FIx-FIX rule 249 */ 250 henv->upDate = 0; 251 hnoise->upDate = 0; 252 return (0); 253 } 254 255 /******************************************************************************* 256 Functionname: indexLow2High 257 ******************************************************************************* 258 259 Description: Nice small patch-functions in order to cope with non-factor-2 260 ratios between high-res and low-res 261 262 Arguments: INT offset, INT index, FREQ_RES res 263 264 Return: INT 265 266 *******************************************************************************/ 267 static INT indexLow2High(INT offset, INT index, FREQ_RES res) { 268 if (res == FREQ_RES_LOW) { 269 if (offset >= 0) { 270 if (index < offset) 271 return (index); 272 else 273 return (2 * index - offset); 274 } else { 275 offset = -offset; 276 if (index < offset) 277 return (2 * index + index); 278 else 279 return (2 * index + offset); 280 } 281 } else 282 return (index); 283 } 284 285 /******************************************************************************* 286 Functionname: mapLowResEnergyVal 287 ******************************************************************************* 288 289 Description: 290 291 Arguments: INT currVal,INT* prevData, INT offset, INT index, FREQ_RES res 292 293 Return: none 294 295 *******************************************************************************/ 296 static void mapLowResEnergyVal(SCHAR currVal, SCHAR *prevData, INT offset, 297 INT index, FREQ_RES res) { 298 if (res == FREQ_RES_LOW) { 299 if (offset >= 0) { 300 if (index < offset) 301 prevData[index] = currVal; 302 else { 303 prevData[2 * index - offset] = currVal; 304 prevData[2 * index + 1 - offset] = currVal; 305 } 306 } else { 307 offset = -offset; 308 if (index < offset) { 309 prevData[3 * index] = currVal; 310 prevData[3 * index + 1] = currVal; 311 prevData[3 * index + 2] = currVal; 312 } else { 313 prevData[2 * index + offset] = currVal; 314 prevData[2 * index + 1 + offset] = currVal; 315 } 316 } 317 } else 318 prevData[index] = currVal; 319 } 320 321 /******************************************************************************* 322 Functionname: computeBits 323 ******************************************************************************* 324 325 Description: 326 327 Arguments: INT delta, 328 INT codeBookScfLavLevel, 329 INT codeBookScfLavBalance, 330 const UCHAR * hufftableLevel, 331 const UCHAR * hufftableBalance, INT coupling, INT channel) 332 333 Return: INT 334 335 *******************************************************************************/ 336 static INT computeBits(SCHAR *delta, INT codeBookScfLavLevel, 337 INT codeBookScfLavBalance, const UCHAR *hufftableLevel, 338 const UCHAR *hufftableBalance, INT coupling, 339 INT channel) { 340 INT index; 341 INT delta_bits = 0; 342 343 if (coupling) { 344 if (channel == 1) { 345 if (*delta < 0) 346 index = fixMax(*delta, -codeBookScfLavBalance); 347 else 348 index = fixMin(*delta, codeBookScfLavBalance); 349 350 if (index != *delta) { 351 *delta = index; 352 return (10000); 353 } 354 355 delta_bits = hufftableBalance[index + codeBookScfLavBalance]; 356 } else { 357 if (*delta < 0) 358 index = fixMax(*delta, -codeBookScfLavLevel); 359 else 360 index = fixMin(*delta, codeBookScfLavLevel); 361 362 if (index != *delta) { 363 *delta = index; 364 return (10000); 365 } 366 delta_bits = hufftableLevel[index + codeBookScfLavLevel]; 367 } 368 } else { 369 if (*delta < 0) 370 index = fixMax(*delta, -codeBookScfLavLevel); 371 else 372 index = fixMin(*delta, codeBookScfLavLevel); 373 374 if (index != *delta) { 375 *delta = index; 376 return (10000); 377 } 378 delta_bits = hufftableLevel[index + codeBookScfLavLevel]; 379 } 380 381 return (delta_bits); 382 } 383 384 /******************************************************************************* 385 Functionname: FDKsbrEnc_codeEnvelope 386 ******************************************************************************* 387 388 Description: 389 390 Arguments: INT *sfb_nrg, 391 const FREQ_RES *freq_res, 392 SBR_CODE_ENVELOPE * h_sbrCodeEnvelope, 393 INT *directionVec, INT scalable, INT nEnvelopes, INT channel, 394 INT headerActive) 395 396 Return: none 397 h_sbrCodeEnvelope->sfb_nrg_prev is modified ! 398 sfb_nrg is modified 399 h_sbrCodeEnvelope->update is modfied ! 400 *directionVec is modified 401 402 *******************************************************************************/ 403 void FDKsbrEnc_codeEnvelope(SCHAR *sfb_nrg, const FREQ_RES *freq_res, 404 SBR_CODE_ENVELOPE *h_sbrCodeEnvelope, 405 INT *directionVec, INT coupling, INT nEnvelopes, 406 INT channel, INT headerActive) { 407 INT i, no_of_bands, band; 408 FIXP_DBL tmp1, tmp2, tmp3, dF_edge_1stEnv; 409 SCHAR *ptr_nrg; 410 411 INT codeBookScfLavLevelTime; 412 INT codeBookScfLavLevelFreq; 413 INT codeBookScfLavBalanceTime; 414 INT codeBookScfLavBalanceFreq; 415 const UCHAR *hufftableLevelTimeL; 416 const UCHAR *hufftableBalanceTimeL; 417 const UCHAR *hufftableLevelFreqL; 418 const UCHAR *hufftableBalanceFreqL; 419 420 INT offset = h_sbrCodeEnvelope->offset; 421 INT envDataTableCompFactor; 422 423 INT delta_F_bits = 0, delta_T_bits = 0; 424 INT use_dT; 425 426 SCHAR delta_F[MAX_FREQ_COEFFS]; 427 SCHAR delta_T[MAX_FREQ_COEFFS]; 428 SCHAR last_nrg, curr_nrg; 429 430 tmp1 = FL2FXCONST_DBL(0.5f) >> (DFRACT_BITS - 16 - 1); 431 tmp2 = h_sbrCodeEnvelope->dF_edge_1stEnv >> (DFRACT_BITS - 16); 432 tmp3 = (FIXP_DBL)fMult(h_sbrCodeEnvelope->dF_edge_incr, 433 ((FIXP_DBL)h_sbrCodeEnvelope->dF_edge_incr_fac) << 15); 434 435 dF_edge_1stEnv = tmp1 + tmp2 + tmp3; 436 437 if (coupling) { 438 codeBookScfLavLevelTime = h_sbrCodeEnvelope->codeBookScfLavLevelTime; 439 codeBookScfLavLevelFreq = h_sbrCodeEnvelope->codeBookScfLavLevelFreq; 440 codeBookScfLavBalanceTime = h_sbrCodeEnvelope->codeBookScfLavBalanceTime; 441 codeBookScfLavBalanceFreq = h_sbrCodeEnvelope->codeBookScfLavBalanceFreq; 442 hufftableLevelTimeL = h_sbrCodeEnvelope->hufftableLevelTimeL; 443 hufftableBalanceTimeL = h_sbrCodeEnvelope->hufftableBalanceTimeL; 444 hufftableLevelFreqL = h_sbrCodeEnvelope->hufftableLevelFreqL; 445 hufftableBalanceFreqL = h_sbrCodeEnvelope->hufftableBalanceFreqL; 446 } else { 447 codeBookScfLavLevelTime = h_sbrCodeEnvelope->codeBookScfLavTime; 448 codeBookScfLavLevelFreq = h_sbrCodeEnvelope->codeBookScfLavFreq; 449 codeBookScfLavBalanceTime = h_sbrCodeEnvelope->codeBookScfLavTime; 450 codeBookScfLavBalanceFreq = h_sbrCodeEnvelope->codeBookScfLavFreq; 451 hufftableLevelTimeL = h_sbrCodeEnvelope->hufftableTimeL; 452 hufftableBalanceTimeL = h_sbrCodeEnvelope->hufftableTimeL; 453 hufftableLevelFreqL = h_sbrCodeEnvelope->hufftableFreqL; 454 hufftableBalanceFreqL = h_sbrCodeEnvelope->hufftableFreqL; 455 } 456 457 if (coupling == 1 && channel == 1) 458 envDataTableCompFactor = 459 1; /*should be one when the new huffman-tables are ready*/ 460 else 461 envDataTableCompFactor = 0; 462 463 if (h_sbrCodeEnvelope->deltaTAcrossFrames == 0) h_sbrCodeEnvelope->upDate = 0; 464 465 /* no delta coding in time in case of a header */ 466 if (headerActive) h_sbrCodeEnvelope->upDate = 0; 467 468 for (i = 0; i < nEnvelopes; i++) { 469 if (freq_res[i] == FREQ_RES_HIGH) 470 no_of_bands = h_sbrCodeEnvelope->nSfb[FREQ_RES_HIGH]; 471 else 472 no_of_bands = h_sbrCodeEnvelope->nSfb[FREQ_RES_LOW]; 473 474 ptr_nrg = sfb_nrg; 475 curr_nrg = *ptr_nrg; 476 477 delta_F[0] = curr_nrg >> envDataTableCompFactor; 478 479 if (coupling && channel == 1) 480 delta_F_bits = h_sbrCodeEnvelope->start_bits_balance; 481 else 482 delta_F_bits = h_sbrCodeEnvelope->start_bits; 483 484 if (h_sbrCodeEnvelope->upDate != 0) { 485 delta_T[0] = (curr_nrg - h_sbrCodeEnvelope->sfb_nrg_prev[0]) >> 486 envDataTableCompFactor; 487 488 delta_T_bits = computeBits(&delta_T[0], codeBookScfLavLevelTime, 489 codeBookScfLavBalanceTime, hufftableLevelTimeL, 490 hufftableBalanceTimeL, coupling, channel); 491 } 492 493 mapLowResEnergyVal(curr_nrg, h_sbrCodeEnvelope->sfb_nrg_prev, offset, 0, 494 freq_res[i]); 495 496 /* ensure that nrg difference is not higher than codeBookScfLavXXXFreq */ 497 if (coupling && channel == 1) { 498 for (band = no_of_bands - 1; band > 0; band--) { 499 if (ptr_nrg[band] - ptr_nrg[band - 1] > codeBookScfLavBalanceFreq) { 500 ptr_nrg[band - 1] = ptr_nrg[band] - codeBookScfLavBalanceFreq; 501 } 502 } 503 for (band = 1; band < no_of_bands; band++) { 504 if (ptr_nrg[band - 1] - ptr_nrg[band] > codeBookScfLavBalanceFreq) { 505 ptr_nrg[band] = ptr_nrg[band - 1] - codeBookScfLavBalanceFreq; 506 } 507 } 508 } else { 509 for (band = no_of_bands - 1; band > 0; band--) { 510 if (ptr_nrg[band] - ptr_nrg[band - 1] > codeBookScfLavLevelFreq) { 511 ptr_nrg[band - 1] = ptr_nrg[band] - codeBookScfLavLevelFreq; 512 } 513 } 514 for (band = 1; band < no_of_bands; band++) { 515 if (ptr_nrg[band - 1] - ptr_nrg[band] > codeBookScfLavLevelFreq) { 516 ptr_nrg[band] = ptr_nrg[band - 1] - codeBookScfLavLevelFreq; 517 } 518 } 519 } 520 521 /* Coding loop*/ 522 for (band = 1; band < no_of_bands; band++) { 523 last_nrg = (*ptr_nrg); 524 ptr_nrg++; 525 curr_nrg = (*ptr_nrg); 526 527 delta_F[band] = (curr_nrg - last_nrg) >> envDataTableCompFactor; 528 529 delta_F_bits += computeBits( 530 &delta_F[band], codeBookScfLavLevelFreq, codeBookScfLavBalanceFreq, 531 hufftableLevelFreqL, hufftableBalanceFreqL, coupling, channel); 532 533 if (h_sbrCodeEnvelope->upDate != 0) { 534 delta_T[band] = 535 curr_nrg - 536 h_sbrCodeEnvelope 537 ->sfb_nrg_prev[indexLow2High(offset, band, freq_res[i])]; 538 delta_T[band] = delta_T[band] >> envDataTableCompFactor; 539 } 540 541 mapLowResEnergyVal(curr_nrg, h_sbrCodeEnvelope->sfb_nrg_prev, offset, 542 band, freq_res[i]); 543 544 if (h_sbrCodeEnvelope->upDate != 0) { 545 delta_T_bits += computeBits( 546 &delta_T[band], codeBookScfLavLevelTime, codeBookScfLavBalanceTime, 547 hufftableLevelTimeL, hufftableBalanceTimeL, coupling, channel); 548 } 549 } 550 551 /* Replace sfb_nrg with deltacoded samples and set flag */ 552 if (i == 0) { 553 INT tmp_bits; 554 tmp_bits = (((delta_T_bits * dF_edge_1stEnv) >> (DFRACT_BITS - 18)) + 555 (FIXP_DBL)1) >> 556 1; 557 use_dT = (h_sbrCodeEnvelope->upDate != 0 && (delta_F_bits > tmp_bits)); 558 } else 559 use_dT = (delta_T_bits < delta_F_bits && h_sbrCodeEnvelope->upDate != 0); 560 561 if (use_dT) { 562 directionVec[i] = TIME; 563 FDKmemcpy(sfb_nrg, delta_T, no_of_bands * sizeof(SCHAR)); 564 } else { 565 h_sbrCodeEnvelope->upDate = 0; 566 directionVec[i] = FREQ; 567 FDKmemcpy(sfb_nrg, delta_F, no_of_bands * sizeof(SCHAR)); 568 } 569 sfb_nrg += no_of_bands; 570 h_sbrCodeEnvelope->upDate = 1; 571 } 572 } 573 574 /******************************************************************************* 575 Functionname: FDKsbrEnc_InitSbrCodeEnvelope 576 ******************************************************************************* 577 578 Description: 579 580 Arguments: 581 582 Return: 583 584 *******************************************************************************/ 585 INT FDKsbrEnc_InitSbrCodeEnvelope(HANDLE_SBR_CODE_ENVELOPE h_sbrCodeEnvelope, 586 INT *nSfb, INT deltaTAcrossFrames, 587 FIXP_DBL dF_edge_1stEnv, 588 FIXP_DBL dF_edge_incr) { 589 FDKmemclear(h_sbrCodeEnvelope, sizeof(SBR_CODE_ENVELOPE)); 590 591 h_sbrCodeEnvelope->deltaTAcrossFrames = deltaTAcrossFrames; 592 h_sbrCodeEnvelope->dF_edge_1stEnv = dF_edge_1stEnv; 593 h_sbrCodeEnvelope->dF_edge_incr = dF_edge_incr; 594 h_sbrCodeEnvelope->dF_edge_incr_fac = 0; 595 h_sbrCodeEnvelope->upDate = 0; 596 h_sbrCodeEnvelope->nSfb[FREQ_RES_LOW] = nSfb[FREQ_RES_LOW]; 597 h_sbrCodeEnvelope->nSfb[FREQ_RES_HIGH] = nSfb[FREQ_RES_HIGH]; 598 h_sbrCodeEnvelope->offset = 2 * h_sbrCodeEnvelope->nSfb[FREQ_RES_LOW] - 599 h_sbrCodeEnvelope->nSfb[FREQ_RES_HIGH]; 600 601 return (0); 602 } 603
