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): Andreas Ehret, Tobias Chalupka 98 99 Description: SBR encoder top level processing. 100 101 *******************************************************************************/ 102 103 #include "sbr_encoder.h" 104 105 #include "sbrenc_ram.h" 106 #include "sbrenc_rom.h" 107 #include "sbrenc_freq_sca.h" 108 #include "env_bit.h" 109 #include "cmondata.h" 110 #include "sbr_misc.h" 111 #include "sbr.h" 112 #include "qmf.h" 113 114 #include "ps_main.h" 115 116 #define SBRENCODER_LIB_VL0 4 117 #define SBRENCODER_LIB_VL1 0 118 #define SBRENCODER_LIB_VL2 0 119 120 /***************************************************************************/ 121 /* 122 * SBR Delay balancing definitions. 123 */ 124 125 /* 126 input buffer (1ch) 127 128 |------------ 1537 -------------|-----|---------- 2048 -------------| 129 (core2sbr delay ) ds (read, core and ds area) 130 */ 131 132 #define SFB(dwnsmp) \ 133 (32 << (dwnsmp - \ 134 1)) /* SBR Frequency bands: 64 for dual-rate, 32 for single-rate */ 135 #define STS(fl) \ 136 (((fl) == 1024) ? 32 \ 137 : 30) /* SBR Time Slots: 32 for core frame length 1024, 30 \ 138 for core frame length 960 */ 139 140 #define DELAY_QMF_ANA(dwnsmp) \ 141 ((320 << ((dwnsmp)-1)) - (32 << ((dwnsmp)-1))) /* Full bandwidth */ 142 #define DELAY_HYB_ANA (10 * 64) /* + 0.5 */ /* */ 143 #define DELAY_HYB_SYN (6 * 64 - 32) /* */ 144 #define DELAY_QMF_POSTPROC(dwnsmp) \ 145 (32 * (dwnsmp)) /* QMF postprocessing delay */ 146 #define DELAY_DEC_QMF(dwnsmp) (6 * SFB(dwnsmp)) /* Decoder QMF overlap */ 147 #define DELAY_QMF_SYN(dwnsmp) \ 148 (1 << (dwnsmp - \ 149 1)) /* QMF_NO_POLY/2=2.5, rounded down to 2, half for single-rate */ 150 #define DELAY_QMF_DS (32) /* QMF synthesis for downsampled time signal */ 151 152 /* Delay in QMF paths */ 153 #define DELAY_SBR(fl, dwnsmp) \ 154 (DELAY_QMF_ANA(dwnsmp) + (SFB(dwnsmp) * STS(fl) - 1) + DELAY_QMF_SYN(dwnsmp)) 155 #define DELAY_PS(fl, dwnsmp) \ 156 (DELAY_QMF_ANA(dwnsmp) + DELAY_HYB_ANA + DELAY_DEC_QMF(dwnsmp) + \ 157 (SFB(dwnsmp) * STS(fl) - 1) + DELAY_HYB_SYN + DELAY_QMF_SYN(dwnsmp)) 158 #define DELAY_ELDSBR(fl, dwnsmp) \ 159 ((((fl) / 2) * (dwnsmp)) - 1 + DELAY_QMF_POSTPROC(dwnsmp)) 160 #define DELAY_ELDv2SBR(fl, dwnsmp) \ 161 ((((fl) / 2) * (dwnsmp)) - 1 + 80 * (dwnsmp)) /* 80 is the delay caused \ 162 by the sum of the CLD \ 163 analysis and the MPSLD \ 164 synthesis filterbank */ 165 166 /* Delay in core path (core and downsampler not taken into account) */ 167 #define DELAY_COREPATH_SBR(fl, dwnsmp) \ 168 ((DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + DELAY_QMF_SYN(dwnsmp))) 169 #define DELAY_COREPATH_ELDSBR(fl, dwnsmp) ((DELAY_QMF_POSTPROC(dwnsmp))) 170 #define DELAY_COREPATH_ELDv2SBR(fl, dwnsmp) (128 * (dwnsmp)) /* 4 slots */ 171 #define DELAY_COREPATH_PS(fl, dwnsmp) \ 172 ((DELAY_QMF_ANA(dwnsmp) + DELAY_QMF_DS + \ 173 /*(DELAY_AAC(fl)*2) + */ DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + \ 174 DELAY_HYB_SYN + DELAY_QMF_SYN(dwnsmp))) /* 2048 - 463*2 */ 175 176 /* Delay differences between SBR- and downsampled path for SBR and SBR+PS */ 177 #define DELAY_AAC2SBR(fl, dwnsmp) \ 178 ((DELAY_COREPATH_SBR(fl, dwnsmp)) - DELAY_SBR((fl), (dwnsmp))) 179 #define DELAY_ELD2SBR(fl, dwnsmp) \ 180 ((DELAY_COREPATH_ELDSBR(fl, dwnsmp)) - DELAY_ELDSBR(fl, dwnsmp)) 181 #define DELAY_AAC2PS(fl, dwnsmp) \ 182 ((DELAY_COREPATH_PS(fl, dwnsmp)) - DELAY_PS(fl, dwnsmp)) /* 2048 - 463*2 */ 183 184 /* Assumption: The sample delay resulting of of DELAY_AAC2PS is always smaller 185 * than the sample delay implied by DELAY_AAC2SBR */ 186 #define MAX_DS_FILTER_DELAY \ 187 (5) /* the additional max downsampler filter delay (source fs) */ 188 #define MAX_SAMPLE_DELAY \ 189 (DELAY_AAC2SBR(1024, 2) + MAX_DS_FILTER_DELAY) /* maximum delay: frame \ 190 length of 1024 and \ 191 dual-rate sbr */ 192 193 /***************************************************************************/ 194 195 /*************** Delay parameters for sbrEncoder_Init_delay() **************/ 196 typedef struct { 197 int dsDelay; /* the delay of the (time-domain) downsampler itself */ 198 int delay; /* overall delay / samples */ 199 int sbrDecDelay; /* SBR decoder's delay */ 200 int corePathOffset; /* core path offset / samples; added by 201 sbrEncoder_Init_delay() */ 202 int sbrPathOffset; /* SBR path offset / samples; added by 203 sbrEncoder_Init_delay() */ 204 int bitstrDelay; /* bitstream delay / frames; added by sbrEncoder_Init_delay() 205 */ 206 int delayInput2Core; /* delay of the input to the core / samples */ 207 } DELAY_PARAM; 208 /***************************************************************************/ 209 210 #define INVALID_TABLE_IDX -1 211 212 /***************************************************************************/ 213 /*! 214 215 \brief Selects the SBR tuning settings to use dependent on number of 216 channels, bitrate, sample rate and core coder 217 218 \return Index to the appropriate table 219 220 ****************************************************************************/ 221 #define DISTANCE_CEIL_VALUE 5000000 222 static INT getSbrTuningTableIndex( 223 UINT bitrate, /*! the total bitrate in bits/sec */ 224 UINT numChannels, /*! the number of channels for the core coder */ 225 UINT sampleRate, /*! the sampling rate of the core coder */ 226 AUDIO_OBJECT_TYPE core, UINT *pBitRateClosest) { 227 int i, bitRateClosestLowerIndex = -1, bitRateClosestUpperIndex = -1, 228 found = 0; 229 UINT bitRateClosestUpper = 0, bitRateClosestLower = DISTANCE_CEIL_VALUE; 230 231 #define isForThisCore(i) \ 232 ((sbrTuningTable[i].coreCoder == CODEC_AACLD && core == AOT_ER_AAC_ELD) || \ 233 (sbrTuningTable[i].coreCoder == CODEC_AAC && core != AOT_ER_AAC_ELD)) 234 235 for (i = 0; i < sbrTuningTableSize; i++) { 236 if (isForThisCore(i)) /* tuning table is for this core codec */ 237 { 238 if (numChannels == sbrTuningTable[i].numChannels && 239 sampleRate == sbrTuningTable[i].sampleRate) { 240 found = 1; 241 if ((bitrate >= sbrTuningTable[i].bitrateFrom) && 242 (bitrate < sbrTuningTable[i].bitrateTo)) { 243 return i; 244 } else { 245 if (sbrTuningTable[i].bitrateFrom > bitrate) { 246 if (sbrTuningTable[i].bitrateFrom < bitRateClosestLower) { 247 bitRateClosestLower = sbrTuningTable[i].bitrateFrom; 248 bitRateClosestLowerIndex = i; 249 } 250 } 251 if (sbrTuningTable[i].bitrateTo <= bitrate) { 252 if (sbrTuningTable[i].bitrateTo > bitRateClosestUpper) { 253 bitRateClosestUpper = sbrTuningTable[i].bitrateTo - 1; 254 bitRateClosestUpperIndex = i; 255 } 256 } 257 } 258 } 259 } 260 } 261 262 if (bitRateClosestUpperIndex >= 0) { 263 return bitRateClosestUpperIndex; 264 } 265 266 if (pBitRateClosest != NULL) { 267 /* If there was at least one matching tuning entry pick the least distance 268 * bit rate */ 269 if (found) { 270 int distanceUpper = DISTANCE_CEIL_VALUE, 271 distanceLower = DISTANCE_CEIL_VALUE; 272 if (bitRateClosestLowerIndex >= 0) { 273 distanceLower = 274 sbrTuningTable[bitRateClosestLowerIndex].bitrateFrom - bitrate; 275 } 276 if (bitRateClosestUpperIndex >= 0) { 277 distanceUpper = 278 bitrate - sbrTuningTable[bitRateClosestUpperIndex].bitrateTo; 279 } 280 if (distanceUpper < distanceLower) { 281 *pBitRateClosest = bitRateClosestUpper; 282 } else { 283 *pBitRateClosest = bitRateClosestLower; 284 } 285 } else { 286 *pBitRateClosest = 0; 287 } 288 } 289 290 return INVALID_TABLE_IDX; 291 } 292 293 /***************************************************************************/ 294 /*! 295 296 \brief Selects the PS tuning settings to use dependent on bitrate 297 and core coder 298 299 \return Index to the appropriate table 300 301 ****************************************************************************/ 302 static INT getPsTuningTableIndex(UINT bitrate, UINT *pBitRateClosest) { 303 INT i, paramSets = sizeof(psTuningTable) / sizeof(psTuningTable[0]); 304 int bitRateClosestLowerIndex = -1, bitRateClosestUpperIndex = -1; 305 UINT bitRateClosestUpper = 0, bitRateClosestLower = DISTANCE_CEIL_VALUE; 306 307 for (i = 0; i < paramSets; i++) { 308 if ((bitrate >= psTuningTable[i].bitrateFrom) && 309 (bitrate < psTuningTable[i].bitrateTo)) { 310 return i; 311 } else { 312 if (psTuningTable[i].bitrateFrom > bitrate) { 313 if (psTuningTable[i].bitrateFrom < bitRateClosestLower) { 314 bitRateClosestLower = psTuningTable[i].bitrateFrom; 315 bitRateClosestLowerIndex = i; 316 } 317 } 318 if (psTuningTable[i].bitrateTo <= bitrate) { 319 if (psTuningTable[i].bitrateTo > bitRateClosestUpper) { 320 bitRateClosestUpper = psTuningTable[i].bitrateTo - 1; 321 bitRateClosestUpperIndex = i; 322 } 323 } 324 } 325 } 326 327 if (bitRateClosestUpperIndex >= 0) { 328 return bitRateClosestUpperIndex; 329 } 330 331 if (pBitRateClosest != NULL) { 332 int distanceUpper = DISTANCE_CEIL_VALUE, 333 distanceLower = DISTANCE_CEIL_VALUE; 334 if (bitRateClosestLowerIndex >= 0) { 335 distanceLower = 336 sbrTuningTable[bitRateClosestLowerIndex].bitrateFrom - bitrate; 337 } 338 if (bitRateClosestUpperIndex >= 0) { 339 distanceUpper = 340 bitrate - sbrTuningTable[bitRateClosestUpperIndex].bitrateTo; 341 } 342 if (distanceUpper < distanceLower) { 343 *pBitRateClosest = bitRateClosestUpper; 344 } else { 345 *pBitRateClosest = bitRateClosestLower; 346 } 347 } 348 349 return INVALID_TABLE_IDX; 350 } 351 352 /***************************************************************************/ 353 /*! 354 355 \brief In case of downsampled SBR we may need to lower the stop freq 356 of a tuning setting to fit into the lower half of the 357 spectrum ( which is sampleRate/4 ) 358 359 \return the adapted stop frequency index (-1 -> error) 360 361 \ingroup SbrEncCfg 362 363 ****************************************************************************/ 364 static INT FDKsbrEnc_GetDownsampledStopFreq(const INT sampleRateCore, 365 const INT startFreq, INT stopFreq, 366 const INT downSampleFactor) { 367 INT maxStopFreqRaw = sampleRateCore / 2; 368 INT startBand, stopBand; 369 HANDLE_ERROR_INFO err; 370 371 while (stopFreq > 0 && FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) > 372 maxStopFreqRaw) { 373 stopFreq--; 374 } 375 376 if (FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) > maxStopFreqRaw) 377 return -1; 378 379 err = FDKsbrEnc_FindStartAndStopBand( 380 sampleRateCore << (downSampleFactor - 1), sampleRateCore, 381 32 << (downSampleFactor - 1), startFreq, stopFreq, &startBand, &stopBand); 382 if (err) return -1; 383 384 return stopFreq; 385 } 386 387 /***************************************************************************/ 388 /*! 389 390 \brief tells us, if for the given coreCoder, bitrate, number of channels 391 and input sampling rate an SBR setting is available. If yes, it 392 tells us also the core sampling rate we would need to run with 393 394 \return a flag indicating success: yes (1) or no (0) 395 396 ****************************************************************************/ 397 static UINT FDKsbrEnc_IsSbrSettingAvail( 398 UINT bitrate, /*! the total bitrate in bits/sec */ 399 UINT vbrMode, /*! the vbr paramter, 0 means constant bitrate */ 400 UINT numOutputChannels, /*! the number of channels for the core coder */ 401 UINT sampleRateInput, /*! the input sample rate [in Hz] */ 402 UINT sampleRateCore, /*! the core's sampling rate */ 403 AUDIO_OBJECT_TYPE core) { 404 INT idx = INVALID_TABLE_IDX; 405 406 if (sampleRateInput < 16000) return 0; 407 408 if (bitrate == 0) { 409 /* map vbr quality to bitrate */ 410 if (vbrMode < 30) 411 bitrate = 24000; 412 else if (vbrMode < 40) 413 bitrate = 28000; 414 else if (vbrMode < 60) 415 bitrate = 32000; 416 else if (vbrMode < 75) 417 bitrate = 40000; 418 else 419 bitrate = 48000; 420 bitrate *= numOutputChannels; 421 } 422 423 idx = getSbrTuningTableIndex(bitrate, numOutputChannels, sampleRateCore, core, 424 NULL); 425 426 return (idx == INVALID_TABLE_IDX ? 0 : 1); 427 } 428 429 /***************************************************************************/ 430 /*! 431 432 \brief Adjusts the SBR settings according to the chosen core coder 433 settings which are accessible via config->codecSettings 434 435 \return A flag indicating success: yes (1) or no (0) 436 437 ****************************************************************************/ 438 static UINT FDKsbrEnc_AdjustSbrSettings( 439 const sbrConfigurationPtr config, /*! output, modified */ 440 UINT bitRate, /*! the total bitrate in bits/sec */ 441 UINT numChannels, /*! the core coder number of channels */ 442 UINT sampleRateCore, /*! the core coder sampling rate in Hz */ 443 UINT sampleRateSbr, /*! the sbr coder sampling rate in Hz */ 444 UINT transFac, /*! the short block to long block ratio */ 445 UINT standardBitrate, /*! the standard bitrate per channel in bits/sec */ 446 UINT vbrMode, /*! the vbr paramter, 0 poor quality .. 100 high quality*/ 447 UINT useSpeechConfig, /*!< adapt tuning parameters for speech ? */ 448 UINT lcsMode, /*! the low complexity stereo mode */ 449 UINT bParametricStereo, /*!< use parametric stereo */ 450 AUDIO_OBJECT_TYPE core) /* Core audio codec object type */ 451 { 452 INT idx = INVALID_TABLE_IDX; 453 /* set the core codec settings */ 454 config->codecSettings.bitRate = bitRate; 455 config->codecSettings.nChannels = numChannels; 456 config->codecSettings.sampleFreq = sampleRateCore; 457 config->codecSettings.transFac = transFac; 458 config->codecSettings.standardBitrate = standardBitrate; 459 460 if (bitRate < 28000) { 461 config->threshold_AmpRes_FF_m = (FIXP_DBL)MAXVAL_DBL; 462 config->threshold_AmpRes_FF_e = 7; 463 } else if (bitRate >= 28000 && bitRate <= 48000) { 464 /* The float threshold is 75 465 0.524288f is fractional part of RELAXATION, the quotaMatrix and therefore 466 tonality are scaled by this 2/3 is because the original implementation 467 divides the tonality values by 3, here it's divided by 2 128 compensates 468 the necessary shiftfactor of 7 */ 469 config->threshold_AmpRes_FF_m = 470 FL2FXCONST_DBL(75.0f * 0.524288f / (2.0f / 3.0f) / 128.0f); 471 config->threshold_AmpRes_FF_e = 7; 472 } else if (bitRate > 48000) { 473 config->threshold_AmpRes_FF_m = FL2FXCONST_DBL(0); 474 config->threshold_AmpRes_FF_e = 0; 475 } 476 477 if (bitRate == 0) { 478 /* map vbr quality to bitrate */ 479 if (vbrMode < 30) 480 bitRate = 24000; 481 else if (vbrMode < 40) 482 bitRate = 28000; 483 else if (vbrMode < 60) 484 bitRate = 32000; 485 else if (vbrMode < 75) 486 bitRate = 40000; 487 else 488 bitRate = 48000; 489 bitRate *= numChannels; 490 /* fix to enable mono vbrMode<40 @ 44.1 of 48kHz */ 491 if (numChannels == 1) { 492 if (sampleRateSbr == 44100 || sampleRateSbr == 48000) { 493 if (vbrMode < 40) bitRate = 32000; 494 } 495 } 496 } 497 498 idx = 499 getSbrTuningTableIndex(bitRate, numChannels, sampleRateCore, core, NULL); 500 501 if (idx != INVALID_TABLE_IDX) { 502 config->startFreq = sbrTuningTable[idx].startFreq; 503 config->stopFreq = sbrTuningTable[idx].stopFreq; 504 if (useSpeechConfig) { 505 config->startFreq = sbrTuningTable[idx].startFreqSpeech; 506 config->stopFreq = sbrTuningTable[idx].stopFreqSpeech; 507 } 508 509 /* Adapt stop frequency in case of downsampled SBR - only 32 bands then */ 510 if (1 == config->downSampleFactor) { 511 INT dsStopFreq = FDKsbrEnc_GetDownsampledStopFreq( 512 sampleRateCore, config->startFreq, config->stopFreq, 513 config->downSampleFactor); 514 if (dsStopFreq < 0) { 515 return 0; 516 } 517 518 config->stopFreq = dsStopFreq; 519 } 520 521 config->sbr_noise_bands = sbrTuningTable[idx].numNoiseBands; 522 if (core == AOT_ER_AAC_ELD) config->init_amp_res_FF = SBR_AMP_RES_1_5; 523 config->noiseFloorOffset = sbrTuningTable[idx].noiseFloorOffset; 524 525 config->ana_max_level = sbrTuningTable[idx].noiseMaxLevel; 526 config->stereoMode = sbrTuningTable[idx].stereoMode; 527 config->freqScale = sbrTuningTable[idx].freqScale; 528 529 if (numChannels == 1) { 530 /* stereo case */ 531 switch (core) { 532 case AOT_AAC_LC: 533 if (bitRate <= (useSpeechConfig ? 24000U : 20000U)) { 534 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency 535 resolution for 536 non-split frames */ 537 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency 538 resolution for split 539 frames */ 540 } 541 break; 542 case AOT_ER_AAC_ELD: 543 if (bitRate < 36000) 544 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency 545 resolution for split 546 frames */ 547 if (bitRate < 26000) { 548 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency 549 resolution for 550 non-split frames */ 551 config->fResTransIsLow = 552 1; /* for transient frames, set low frequency resolution */ 553 } 554 break; 555 default: 556 break; 557 } 558 } else { 559 /* stereo case */ 560 switch (core) { 561 case AOT_AAC_LC: 562 if (bitRate <= 28000) { 563 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency 564 resolution for 565 non-split frames */ 566 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency 567 resolution for split 568 frames */ 569 } 570 break; 571 case AOT_ER_AAC_ELD: 572 if (bitRate < 72000) { 573 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency 574 resolution for split 575 frames */ 576 } 577 if (bitRate < 52000) { 578 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency 579 resolution for 580 non-split frames */ 581 config->fResTransIsLow = 582 1; /* for transient frames, set low frequency resolution */ 583 } 584 break; 585 default: 586 break; 587 } 588 if (bitRate <= 28000) { 589 /* 590 additionally restrict frequency resolution in FIXFIX frames 591 to further reduce SBR payload size */ 592 config->freq_res_fixfix[0] = FREQ_RES_LOW; 593 config->freq_res_fixfix[1] = FREQ_RES_LOW; 594 } 595 } 596 597 /* adjust usage of parametric coding dependent on bitrate and speech config 598 * flag */ 599 if (useSpeechConfig) config->parametricCoding = 0; 600 601 if (core == AOT_ER_AAC_ELD) { 602 if (bitRate < 28000) config->init_amp_res_FF = SBR_AMP_RES_3_0; 603 config->SendHeaderDataTime = -1; 604 } 605 606 if (numChannels == 1) { 607 if (bitRate < 16000) { 608 config->parametricCoding = 0; 609 } 610 } else { 611 if (bitRate < 20000) { 612 config->parametricCoding = 0; 613 } 614 } 615 616 config->useSpeechConfig = useSpeechConfig; 617 618 /* PS settings */ 619 config->bParametricStereo = bParametricStereo; 620 621 return 1; 622 } else { 623 return 0; 624 } 625 } 626 627 /***************************************************************************** 628 629 functionname: FDKsbrEnc_InitializeSbrDefaults 630 description: initializes the SBR configuration 631 returns: error status 632 input: - core codec type, 633 - factor of SBR to core frame length, 634 - core frame length 635 output: initialized SBR configuration 636 637 *****************************************************************************/ 638 static UINT FDKsbrEnc_InitializeSbrDefaults(sbrConfigurationPtr config, 639 INT downSampleFactor, 640 UINT codecGranuleLen, 641 const INT isLowDelay) { 642 if ((downSampleFactor < 1 || downSampleFactor > 2) || 643 (codecGranuleLen * downSampleFactor > 64 * 32)) 644 return (0); /* error */ 645 646 config->SendHeaderDataTime = 1000; 647 config->useWaveCoding = 0; 648 config->crcSbr = 0; 649 config->dynBwSupported = 1; 650 if (isLowDelay) 651 config->tran_thr = 6000; 652 else 653 config->tran_thr = 13000; 654 655 config->parametricCoding = 1; 656 657 config->sbrFrameSize = codecGranuleLen * downSampleFactor; 658 config->downSampleFactor = downSampleFactor; 659 660 /* sbr default parameters */ 661 config->sbr_data_extra = 0; 662 config->amp_res = SBR_AMP_RES_3_0; 663 config->tran_fc = 0; 664 config->tran_det_mode = 1; 665 config->spread = 1; 666 config->stat = 0; 667 config->e = 1; 668 config->deltaTAcrossFrames = 1; 669 config->dF_edge_1stEnv = FL2FXCONST_DBL(0.3f); 670 config->dF_edge_incr = FL2FXCONST_DBL(0.3f); 671 672 config->sbr_invf_mode = INVF_SWITCHED; 673 config->sbr_xpos_mode = XPOS_LC; 674 config->sbr_xpos_ctrl = SBR_XPOS_CTRL_DEFAULT; 675 config->sbr_xpos_level = 0; 676 config->useSaPan = 0; 677 config->dynBwEnabled = 0; 678 679 /* the following parameters are overwritten by the 680 FDKsbrEnc_AdjustSbrSettings() function since they are included in the 681 tuning table */ 682 config->stereoMode = SBR_SWITCH_LRC; 683 config->ana_max_level = 6; 684 config->noiseFloorOffset = 0; 685 config->startFreq = 5; /* 5.9 respectively 6.0 kHz at fs = 44.1/48 kHz */ 686 config->stopFreq = 9; /* 16.2 respectively 16.8 kHz at fs = 44.1/48 kHz */ 687 config->freq_res_fixfix[0] = FREQ_RES_HIGH; /* non-split case */ 688 config->freq_res_fixfix[1] = FREQ_RES_HIGH; /* split case */ 689 config->fResTransIsLow = 0; /* for transient frames, set variable frequency 690 resolution according to freqResTable */ 691 692 /* header_extra_1 */ 693 config->freqScale = SBR_FREQ_SCALE_DEFAULT; 694 config->alterScale = SBR_ALTER_SCALE_DEFAULT; 695 config->sbr_noise_bands = SBR_NOISE_BANDS_DEFAULT; 696 697 /* header_extra_2 */ 698 config->sbr_limiter_bands = SBR_LIMITER_BANDS_DEFAULT; 699 config->sbr_limiter_gains = SBR_LIMITER_GAINS_DEFAULT; 700 config->sbr_interpol_freq = SBR_INTERPOL_FREQ_DEFAULT; 701 config->sbr_smoothing_length = SBR_SMOOTHING_LENGTH_DEFAULT; 702 703 return 1; 704 } 705 706 /***************************************************************************** 707 708 functionname: DeleteEnvChannel 709 description: frees memory of one SBR channel 710 returns: - 711 input: handle of channel 712 output: released handle 713 714 *****************************************************************************/ 715 static void deleteEnvChannel(HANDLE_ENV_CHANNEL hEnvCut) { 716 if (hEnvCut) { 717 FDKsbrEnc_DeleteTonCorrParamExtr(&hEnvCut->TonCorr); 718 719 FDKsbrEnc_deleteExtractSbrEnvelope(&hEnvCut->sbrExtractEnvelope); 720 } 721 } 722 723 /***************************************************************************** 724 725 functionname: sbrEncoder_ChannelClose 726 description: close the channel coding handle 727 returns: 728 input: phSbrChannel 729 output: 730 731 *****************************************************************************/ 732 static void sbrEncoder_ChannelClose(HANDLE_SBR_CHANNEL hSbrChannel) { 733 if (hSbrChannel != NULL) { 734 deleteEnvChannel(&hSbrChannel->hEnvChannel); 735 } 736 } 737 738 /***************************************************************************** 739 740 functionname: sbrEncoder_ElementClose 741 description: close the channel coding handle 742 returns: 743 input: phSbrChannel 744 output: 745 746 *****************************************************************************/ 747 static void sbrEncoder_ElementClose(HANDLE_SBR_ELEMENT *phSbrElement) { 748 HANDLE_SBR_ELEMENT hSbrElement = *phSbrElement; 749 750 if (hSbrElement != NULL) { 751 if (hSbrElement->sbrConfigData.v_k_master) 752 FreeRam_Sbr_v_k_master(&hSbrElement->sbrConfigData.v_k_master); 753 if (hSbrElement->sbrConfigData.freqBandTable[LO]) 754 FreeRam_Sbr_freqBandTableLO( 755 &hSbrElement->sbrConfigData.freqBandTable[LO]); 756 if (hSbrElement->sbrConfigData.freqBandTable[HI]) 757 FreeRam_Sbr_freqBandTableHI( 758 &hSbrElement->sbrConfigData.freqBandTable[HI]); 759 760 FreeRam_SbrElement(phSbrElement); 761 } 762 return; 763 } 764 765 void sbrEncoder_Close(HANDLE_SBR_ENCODER *phSbrEncoder) { 766 HANDLE_SBR_ENCODER hSbrEncoder = *phSbrEncoder; 767 768 if (hSbrEncoder != NULL) { 769 int el, ch; 770 771 for (el = 0; el < (8); el++) { 772 if (hSbrEncoder->sbrElement[el] != NULL) { 773 sbrEncoder_ElementClose(&hSbrEncoder->sbrElement[el]); 774 } 775 } 776 777 /* Close sbr Channels */ 778 for (ch = 0; ch < (8); ch++) { 779 if (hSbrEncoder->pSbrChannel[ch]) { 780 sbrEncoder_ChannelClose(hSbrEncoder->pSbrChannel[ch]); 781 FreeRam_SbrChannel(&hSbrEncoder->pSbrChannel[ch]); 782 } 783 784 if (hSbrEncoder->QmfAnalysis[ch].FilterStates) 785 FreeRam_Sbr_QmfStatesAnalysis( 786 (FIXP_QAS **)&hSbrEncoder->QmfAnalysis[ch].FilterStates); 787 } 788 789 if (hSbrEncoder->hParametricStereo) 790 PSEnc_Destroy(&hSbrEncoder->hParametricStereo); 791 if (hSbrEncoder->qmfSynthesisPS.FilterStates) 792 FreeRam_PsQmfStatesSynthesis( 793 (FIXP_DBL **)&hSbrEncoder->qmfSynthesisPS.FilterStates); 794 795 /* Release Overlay */ 796 if (hSbrEncoder->pSBRdynamic_RAM) 797 FreeRam_SbrDynamic_RAM((FIXP_DBL **)&hSbrEncoder->pSBRdynamic_RAM); 798 799 FreeRam_SbrEncoder(phSbrEncoder); 800 } 801 } 802 803 /***************************************************************************** 804 805 functionname: updateFreqBandTable 806 description: updates vk_master 807 returns: - 808 input: config handle 809 output: error info 810 811 *****************************************************************************/ 812 static INT updateFreqBandTable(HANDLE_SBR_CONFIG_DATA sbrConfigData, 813 HANDLE_SBR_HEADER_DATA sbrHeaderData, 814 const INT downSampleFactor) { 815 INT k0, k2; 816 817 if (FDKsbrEnc_FindStartAndStopBand( 818 sbrConfigData->sampleFreq, 819 sbrConfigData->sampleFreq >> (downSampleFactor - 1), 820 sbrConfigData->noQmfBands, sbrHeaderData->sbr_start_frequency, 821 sbrHeaderData->sbr_stop_frequency, &k0, &k2)) 822 return (1); 823 824 if (FDKsbrEnc_UpdateFreqScale( 825 sbrConfigData->v_k_master, &sbrConfigData->num_Master, k0, k2, 826 sbrHeaderData->freqScale, sbrHeaderData->alterScale)) 827 return (1); 828 829 sbrHeaderData->sbr_xover_band = 0; 830 831 if (FDKsbrEnc_UpdateHiRes(sbrConfigData->freqBandTable[HI], 832 &sbrConfigData->nSfb[HI], sbrConfigData->v_k_master, 833 sbrConfigData->num_Master, 834 &sbrHeaderData->sbr_xover_band)) 835 return (1); 836 837 FDKsbrEnc_UpdateLoRes( 838 sbrConfigData->freqBandTable[LO], &sbrConfigData->nSfb[LO], 839 sbrConfigData->freqBandTable[HI], sbrConfigData->nSfb[HI]); 840 841 sbrConfigData->xOverFreq = 842 (sbrConfigData->freqBandTable[LOW_RES][0] * sbrConfigData->sampleFreq / 843 sbrConfigData->noQmfBands + 844 1) >> 845 1; 846 847 return (0); 848 } 849 850 /***************************************************************************** 851 852 functionname: resetEnvChannel 853 description: resets parameters and allocates memory 854 returns: error status 855 input: 856 output: hEnv 857 858 *****************************************************************************/ 859 static INT resetEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData, 860 HANDLE_SBR_HEADER_DATA sbrHeaderData, 861 HANDLE_ENV_CHANNEL hEnv) { 862 /* note !!! hEnv->encEnvData.noOfnoisebands will be updated later in function 863 * FDKsbrEnc_extractSbrEnvelope !!!*/ 864 hEnv->TonCorr.sbrNoiseFloorEstimate.noiseBands = 865 sbrHeaderData->sbr_noise_bands; 866 867 if (FDKsbrEnc_ResetTonCorrParamExtr( 868 &hEnv->TonCorr, sbrConfigData->xposCtrlSwitch, 869 sbrConfigData->freqBandTable[HI][0], sbrConfigData->v_k_master, 870 sbrConfigData->num_Master, sbrConfigData->sampleFreq, 871 sbrConfigData->freqBandTable, sbrConfigData->nSfb, 872 sbrConfigData->noQmfBands)) 873 return (1); 874 875 hEnv->sbrCodeNoiseFloor.nSfb[LO] = 876 hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands; 877 hEnv->sbrCodeNoiseFloor.nSfb[HI] = 878 hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands; 879 880 hEnv->sbrCodeEnvelope.nSfb[LO] = sbrConfigData->nSfb[LO]; 881 hEnv->sbrCodeEnvelope.nSfb[HI] = sbrConfigData->nSfb[HI]; 882 883 hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI]; 884 885 hEnv->sbrCodeEnvelope.upDate = 0; 886 hEnv->sbrCodeNoiseFloor.upDate = 0; 887 888 return (0); 889 } 890 891 /* ****************************** FDKsbrEnc_SbrGetXOverFreq 892 * ******************************/ 893 /** 894 * @fn 895 * @brief calculates the closest possible crossover frequency 896 * @return the crossover frequency SBR accepts 897 * 898 */ 899 static INT FDKsbrEnc_SbrGetXOverFreq( 900 HANDLE_SBR_ELEMENT hEnv, /*!< handle to SBR encoder instance */ 901 INT xoverFreq) /*!< from core coder suggested crossover frequency */ 902 { 903 INT band; 904 INT lastDiff, newDiff; 905 INT cutoffSb; 906 907 UCHAR *RESTRICT pVKMaster = hEnv->sbrConfigData.v_k_master; 908 909 /* Check if there is a matching cutoff frequency in the master table */ 910 cutoffSb = (4 * xoverFreq * hEnv->sbrConfigData.noQmfBands / 911 hEnv->sbrConfigData.sampleFreq + 912 1) >> 913 1; 914 lastDiff = cutoffSb; 915 for (band = 0; band < hEnv->sbrConfigData.num_Master; band++) { 916 newDiff = fixp_abs((INT)pVKMaster[band] - cutoffSb); 917 918 if (newDiff >= lastDiff) { 919 band--; 920 break; 921 } 922 923 lastDiff = newDiff; 924 } 925 926 return ((pVKMaster[band] * hEnv->sbrConfigData.sampleFreq / 927 hEnv->sbrConfigData.noQmfBands + 928 1) >> 929 1); 930 } 931 932 /***************************************************************************** 933 934 functionname: FDKsbrEnc_EnvEncodeFrame 935 description: performs the sbr envelope calculation for one element 936 returns: 937 input: 938 output: 939 940 *****************************************************************************/ 941 INT FDKsbrEnc_EnvEncodeFrame( 942 HANDLE_SBR_ENCODER hEnvEncoder, int iElement, 943 INT_PCM *samples, /*!< time samples, always deinterleaved */ 944 UINT samplesBufSize, /*!< time buffer channel stride */ 945 UINT *sbrDataBits, /*!< Size of SBR payload */ 946 UCHAR *sbrData, /*!< SBR payload */ 947 int clearOutput /*!< Do not consider any input signal */ 948 ) { 949 HANDLE_SBR_ELEMENT hSbrElement = NULL; 950 FDK_CRCINFO crcInfo; 951 INT crcReg; 952 INT ch; 953 INT band; 954 INT cutoffSb; 955 INT newXOver; 956 957 if (hEnvEncoder == NULL) return -1; 958 959 hSbrElement = hEnvEncoder->sbrElement[iElement]; 960 961 if (hSbrElement == NULL) return -1; 962 963 /* header bitstream handling */ 964 HANDLE_SBR_BITSTREAM_DATA sbrBitstreamData = &hSbrElement->sbrBitstreamData; 965 966 INT psHeaderActive = 0; 967 sbrBitstreamData->HeaderActive = 0; 968 969 /* Anticipate PS header because of internal PS bitstream delay in order to be 970 * in sync with SBR header. */ 971 if (sbrBitstreamData->CountSendHeaderData == 972 (sbrBitstreamData->NrSendHeaderData - 1)) { 973 psHeaderActive = 1; 974 } 975 976 /* Signal SBR header to be written into bitstream */ 977 if (sbrBitstreamData->CountSendHeaderData == 0) { 978 sbrBitstreamData->HeaderActive = 1; 979 } 980 981 /* Increment header interval counter */ 982 if (sbrBitstreamData->NrSendHeaderData == 0) { 983 sbrBitstreamData->CountSendHeaderData = 1; 984 } else { 985 if (sbrBitstreamData->CountSendHeaderData >= 0) { 986 sbrBitstreamData->CountSendHeaderData++; 987 sbrBitstreamData->CountSendHeaderData %= 988 sbrBitstreamData->NrSendHeaderData; 989 } 990 } 991 992 if (hSbrElement->CmonData.dynBwEnabled) { 993 INT i; 994 for (i = 4; i > 0; i--) 995 hSbrElement->dynXOverFreqDelay[i] = hSbrElement->dynXOverFreqDelay[i - 1]; 996 997 hSbrElement->dynXOverFreqDelay[0] = hSbrElement->CmonData.dynXOverFreqEnc; 998 if (hSbrElement->dynXOverFreqDelay[1] > hSbrElement->dynXOverFreqDelay[2]) 999 newXOver = hSbrElement->dynXOverFreqDelay[2]; 1000 else 1001 newXOver = hSbrElement->dynXOverFreqDelay[1]; 1002 1003 /* has the crossover frequency changed? */ 1004 if (hSbrElement->sbrConfigData.dynXOverFreq != newXOver) { 1005 /* get corresponding master band */ 1006 cutoffSb = ((4 * newXOver * hSbrElement->sbrConfigData.noQmfBands / 1007 hSbrElement->sbrConfigData.sampleFreq) + 1008 1) >> 1009 1; 1010 1011 for (band = 0; band < hSbrElement->sbrConfigData.num_Master; band++) { 1012 if (cutoffSb == hSbrElement->sbrConfigData.v_k_master[band]) break; 1013 } 1014 FDK_ASSERT(band < hSbrElement->sbrConfigData.num_Master); 1015 1016 hSbrElement->sbrConfigData.dynXOverFreq = newXOver; 1017 hSbrElement->sbrHeaderData.sbr_xover_band = band; 1018 hSbrElement->sbrBitstreamData.HeaderActive = 1; 1019 psHeaderActive = 1; /* ps header is one frame delayed */ 1020 1021 /* 1022 update vk_master table 1023 */ 1024 if (updateFreqBandTable(&hSbrElement->sbrConfigData, 1025 &hSbrElement->sbrHeaderData, 1026 hEnvEncoder->downSampleFactor)) 1027 return (1); 1028 1029 /* reset SBR channels */ 1030 INT nEnvCh = hSbrElement->sbrConfigData.nChannels; 1031 for (ch = 0; ch < nEnvCh; ch++) { 1032 if (resetEnvChannel(&hSbrElement->sbrConfigData, 1033 &hSbrElement->sbrHeaderData, 1034 &hSbrElement->sbrChannel[ch]->hEnvChannel)) 1035 return (1); 1036 } 1037 } 1038 } 1039 1040 /* 1041 allocate space for dummy header and crc 1042 */ 1043 crcReg = FDKsbrEnc_InitSbrBitstream( 1044 &hSbrElement->CmonData, 1045 hSbrElement->payloadDelayLine[hEnvEncoder->nBitstrDelay], 1046 MAX_PAYLOAD_SIZE * sizeof(UCHAR), &crcInfo, 1047 hSbrElement->sbrConfigData.sbrSyntaxFlags); 1048 1049 /* Temporal Envelope Data */ 1050 SBR_FRAME_TEMP_DATA _fData; 1051 SBR_FRAME_TEMP_DATA *fData = &_fData; 1052 SBR_ENV_TEMP_DATA eData[MAX_NUM_CHANNELS]; 1053 1054 /* Init Temporal Envelope Data */ 1055 { 1056 int i; 1057 1058 FDKmemclear(&eData[0], sizeof(SBR_ENV_TEMP_DATA)); 1059 FDKmemclear(&eData[1], sizeof(SBR_ENV_TEMP_DATA)); 1060 FDKmemclear(fData, sizeof(SBR_FRAME_TEMP_DATA)); 1061 1062 for (i = 0; i < MAX_NUM_NOISE_VALUES; i++) fData->res[i] = FREQ_RES_HIGH; 1063 } 1064 1065 if (!clearOutput) { 1066 /* 1067 * Transform audio data into QMF domain 1068 */ 1069 for (ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++) { 1070 HANDLE_ENV_CHANNEL h_envChan = &hSbrElement->sbrChannel[ch]->hEnvChannel; 1071 HANDLE_SBR_EXTRACT_ENVELOPE sbrExtrEnv = &h_envChan->sbrExtractEnvelope; 1072 1073 if (hSbrElement->elInfo.fParametricStereo == 0) { 1074 QMF_SCALE_FACTOR tmpScale; 1075 FIXP_DBL **pQmfReal, **pQmfImag; 1076 C_AALLOC_SCRATCH_START(qmfWorkBuffer, FIXP_DBL, 64 * 2) 1077 1078 /* Obtain pointers to QMF buffers. */ 1079 pQmfReal = sbrExtrEnv->rBuffer; 1080 pQmfImag = sbrExtrEnv->iBuffer; 1081 1082 qmfAnalysisFiltering( 1083 hSbrElement->hQmfAnalysis[ch], pQmfReal, pQmfImag, &tmpScale, 1084 samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize, 0, 1085 1, qmfWorkBuffer); 1086 1087 h_envChan->qmfScale = tmpScale.lb_scale + 7; 1088 1089 C_AALLOC_SCRATCH_END(qmfWorkBuffer, FIXP_DBL, 64 * 2) 1090 1091 } /* fParametricStereo == 0 */ 1092 1093 /* 1094 Parametric Stereo processing 1095 */ 1096 if (hSbrElement->elInfo.fParametricStereo) { 1097 INT error = noError; 1098 1099 /* Limit Parametric Stereo to one instance */ 1100 FDK_ASSERT(ch == 0); 1101 1102 if (error == noError) { 1103 /* parametric stereo processing: 1104 - input: 1105 o left and right time domain samples 1106 - processing: 1107 o stereo qmf analysis 1108 o stereo hybrid analysis 1109 o ps parameter extraction 1110 o downmix + hybrid synthesis 1111 - output: 1112 o downmixed qmf data is written to sbrExtrEnv->rBuffer and 1113 sbrExtrEnv->iBuffer 1114 */ 1115 SCHAR qmfScale; 1116 INT_PCM *pSamples[2] = { 1117 samples + hSbrElement->elInfo.ChannelIndex[0] * samplesBufSize, 1118 samples + hSbrElement->elInfo.ChannelIndex[1] * samplesBufSize}; 1119 error = FDKsbrEnc_PSEnc_ParametricStereoProcessing( 1120 hEnvEncoder->hParametricStereo, pSamples, samplesBufSize, 1121 hSbrElement->hQmfAnalysis, sbrExtrEnv->rBuffer, 1122 sbrExtrEnv->iBuffer, 1123 samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize, 1124 &hEnvEncoder->qmfSynthesisPS, &qmfScale, psHeaderActive); 1125 h_envChan->qmfScale = (int)qmfScale; 1126 } 1127 1128 } /* if (hEnvEncoder->hParametricStereo) */ 1129 1130 /* 1131 1132 Extract Envelope relevant things from QMF data 1133 1134 */ 1135 FDKsbrEnc_extractSbrEnvelope1(&hSbrElement->sbrConfigData, 1136 &hSbrElement->sbrHeaderData, 1137 &hSbrElement->sbrBitstreamData, h_envChan, 1138 &hSbrElement->CmonData, &eData[ch], fData); 1139 1140 } /* hEnvEncoder->sbrConfigData.nChannels */ 1141 } 1142 1143 /* 1144 Process Envelope relevant things and calculate envelope data and write 1145 payload 1146 */ 1147 FDKsbrEnc_extractSbrEnvelope2( 1148 &hSbrElement->sbrConfigData, &hSbrElement->sbrHeaderData, 1149 (hSbrElement->elInfo.fParametricStereo) ? hEnvEncoder->hParametricStereo 1150 : NULL, 1151 &hSbrElement->sbrBitstreamData, &hSbrElement->sbrChannel[0]->hEnvChannel, 1152 (hSbrElement->sbrConfigData.stereoMode != SBR_MONO) 1153 ? &hSbrElement->sbrChannel[1]->hEnvChannel 1154 : NULL, 1155 &hSbrElement->CmonData, eData, fData, clearOutput); 1156 1157 hSbrElement->sbrBitstreamData.rightBorderFIX = 0; 1158 1159 /* 1160 format payload, calculate crc 1161 */ 1162 FDKsbrEnc_AssembleSbrBitstream(&hSbrElement->CmonData, &crcInfo, crcReg, 1163 hSbrElement->sbrConfigData.sbrSyntaxFlags); 1164 1165 /* 1166 save new payload, set to zero length if greater than MAX_PAYLOAD_SIZE 1167 */ 1168 hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] = 1169 FDKgetValidBits(&hSbrElement->CmonData.sbrBitbuf); 1170 1171 if (hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] > 1172 (MAX_PAYLOAD_SIZE << 3)) 1173 hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] = 0; 1174 1175 /* While filling the Delay lines, sbrData is NULL */ 1176 if (sbrData) { 1177 *sbrDataBits = hSbrElement->payloadDelayLineSize[0]; 1178 FDKmemcpy(sbrData, hSbrElement->payloadDelayLine[0], 1179 (hSbrElement->payloadDelayLineSize[0] + 7) >> 3); 1180 } 1181 1182 /* delay header active flag */ 1183 if (hSbrElement->sbrBitstreamData.HeaderActive == 1) { 1184 hSbrElement->sbrBitstreamData.HeaderActiveDelay = 1185 1 + hEnvEncoder->nBitstrDelay; 1186 } else { 1187 if (hSbrElement->sbrBitstreamData.HeaderActiveDelay > 0) { 1188 hSbrElement->sbrBitstreamData.HeaderActiveDelay--; 1189 } 1190 } 1191 1192 return (0); 1193 } 1194 1195 /***************************************************************************** 1196 1197 functionname: FDKsbrEnc_Downsample 1198 description: performs downsampling and delay compensation of the core path 1199 returns: 1200 input: 1201 output: 1202 1203 *****************************************************************************/ 1204 INT FDKsbrEnc_Downsample( 1205 HANDLE_SBR_ENCODER hSbrEncoder, 1206 INT_PCM *samples, /*!< time samples, always deinterleaved */ 1207 UINT samplesBufSize, /*!< time buffer size per channel */ 1208 UINT numChannels, /*!< number of channels */ 1209 UINT *sbrDataBits, /*!< Size of SBR payload */ 1210 UCHAR *sbrData, /*!< SBR payload */ 1211 int clearOutput /*!< Do not consider any input signal */ 1212 ) { 1213 HANDLE_SBR_ELEMENT hSbrElement = NULL; 1214 INT nOutSamples; 1215 int el; 1216 if (hSbrEncoder->downSampleFactor > 1) { 1217 /* Do downsampling */ 1218 1219 /* Loop over elements (LFE is handled later) */ 1220 for (el = 0; el < hSbrEncoder->noElements; el++) { 1221 hSbrElement = hSbrEncoder->sbrElement[el]; 1222 if (hSbrEncoder->sbrElement[el] != NULL) { 1223 if (hSbrEncoder->downsamplingMethod == SBRENC_DS_TIME) { 1224 int ch; 1225 int nChannels = hSbrElement->sbrConfigData.nChannels; 1226 1227 for (ch = 0; ch < nChannels; ch++) { 1228 FDKaacEnc_Downsample( 1229 &hSbrElement->sbrChannel[ch]->downSampler, 1230 samples + 1231 hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize + 1232 hSbrEncoder->bufferOffset / numChannels, 1233 hSbrElement->sbrConfigData.frameSize, 1234 samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize, 1235 &nOutSamples); 1236 } 1237 } 1238 } 1239 } 1240 1241 /* Handle LFE (if existing) */ 1242 if (hSbrEncoder->lfeChIdx != -1) { /* lfe downsampler */ 1243 FDKaacEnc_Downsample(&hSbrEncoder->lfeDownSampler, 1244 samples + hSbrEncoder->lfeChIdx * samplesBufSize + 1245 hSbrEncoder->bufferOffset / numChannels, 1246 hSbrEncoder->frameSize, 1247 samples + hSbrEncoder->lfeChIdx * samplesBufSize, 1248 &nOutSamples); 1249 } 1250 } else { 1251 /* No downsampling. Still, some buffer shifting for correct delay */ 1252 int samples2Copy = hSbrEncoder->frameSize; 1253 if (hSbrEncoder->bufferOffset / (int)numChannels < samples2Copy) { 1254 for (int c = 0; c < (int)numChannels; c++) { 1255 /* Do memmove while taking care of overlapping memory areas. (memcpy 1256 does not necessarily take care) Distinguish between oeverlapping and 1257 non overlapping version due to reasons of complexity. */ 1258 FDKmemmove(samples + c * samplesBufSize, 1259 samples + c * samplesBufSize + 1260 hSbrEncoder->bufferOffset / numChannels, 1261 samples2Copy * sizeof(INT_PCM)); 1262 } 1263 } else { 1264 for (int c = 0; c < (int)numChannels; c++) { 1265 /* Simple memcpy since the memory areas are not overlapping */ 1266 FDKmemcpy(samples + c * samplesBufSize, 1267 samples + c * samplesBufSize + 1268 hSbrEncoder->bufferOffset / numChannels, 1269 samples2Copy * sizeof(INT_PCM)); 1270 } 1271 } 1272 } 1273 1274 return 0; 1275 } 1276 1277 /***************************************************************************** 1278 1279 functionname: createEnvChannel 1280 description: initializes parameters and allocates memory 1281 returns: error status 1282 input: 1283 output: hEnv 1284 1285 *****************************************************************************/ 1286 1287 static INT createEnvChannel(HANDLE_ENV_CHANNEL hEnv, INT channel, 1288 UCHAR *dynamic_RAM) { 1289 FDKmemclear(hEnv, sizeof(struct ENV_CHANNEL)); 1290 1291 if (FDKsbrEnc_CreateTonCorrParamExtr(&hEnv->TonCorr, channel)) { 1292 return (1); 1293 } 1294 1295 if (FDKsbrEnc_CreateExtractSbrEnvelope(&hEnv->sbrExtractEnvelope, channel, 1296 /*chan*/ 0, dynamic_RAM)) { 1297 return (1); 1298 } 1299 1300 return 0; 1301 } 1302 1303 /***************************************************************************** 1304 1305 functionname: initEnvChannel 1306 description: initializes parameters 1307 returns: error status 1308 input: 1309 output: 1310 1311 *****************************************************************************/ 1312 static INT initEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData, 1313 HANDLE_SBR_HEADER_DATA sbrHeaderData, 1314 HANDLE_ENV_CHANNEL hEnv, sbrConfigurationPtr params, 1315 ULONG statesInitFlag, INT chanInEl, 1316 UCHAR *dynamic_RAM) { 1317 int frameShift, tran_off = 0; 1318 INT e; 1319 INT tran_fc; 1320 INT timeSlots, timeStep, startIndex; 1321 INT noiseBands[2] = {3, 3}; 1322 1323 e = 1 << params->e; 1324 1325 FDK_ASSERT(params->e >= 0); 1326 1327 hEnv->encEnvData.freq_res_fixfix[0] = params->freq_res_fixfix[0]; 1328 hEnv->encEnvData.freq_res_fixfix[1] = params->freq_res_fixfix[1]; 1329 hEnv->encEnvData.fResTransIsLow = params->fResTransIsLow; 1330 1331 hEnv->fLevelProtect = 0; 1332 1333 hEnv->encEnvData.ldGrid = 1334 (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) ? 1 : 0; 1335 1336 hEnv->encEnvData.sbr_xpos_mode = (XPOS_MODE)params->sbr_xpos_mode; 1337 1338 if (hEnv->encEnvData.sbr_xpos_mode == XPOS_SWITCHED) { 1339 /* 1340 no other type than XPOS_MDCT or XPOS_SPEECH allowed, 1341 but enable switching 1342 */ 1343 sbrConfigData->switchTransposers = TRUE; 1344 hEnv->encEnvData.sbr_xpos_mode = XPOS_MDCT; 1345 } else { 1346 sbrConfigData->switchTransposers = FALSE; 1347 } 1348 1349 hEnv->encEnvData.sbr_xpos_ctrl = params->sbr_xpos_ctrl; 1350 1351 /* extended data */ 1352 if (params->parametricCoding) { 1353 hEnv->encEnvData.extended_data = 1; 1354 } else { 1355 hEnv->encEnvData.extended_data = 0; 1356 } 1357 1358 hEnv->encEnvData.extension_size = 0; 1359 1360 startIndex = QMF_FILTER_PROTOTYPE_SIZE - sbrConfigData->noQmfBands; 1361 1362 switch (params->sbrFrameSize) { 1363 case 2304: 1364 timeSlots = 18; 1365 break; 1366 case 2048: 1367 case 1024: 1368 case 512: 1369 timeSlots = 16; 1370 break; 1371 case 1920: 1372 case 960: 1373 case 480: 1374 timeSlots = 15; 1375 break; 1376 case 1152: 1377 timeSlots = 9; 1378 break; 1379 default: 1380 return (1); /* Illegal frame size */ 1381 } 1382 1383 timeStep = sbrConfigData->noQmfSlots / timeSlots; 1384 1385 if (FDKsbrEnc_InitTonCorrParamExtr( 1386 params->sbrFrameSize, &hEnv->TonCorr, sbrConfigData, timeSlots, 1387 params->sbr_xpos_ctrl, params->ana_max_level, 1388 sbrHeaderData->sbr_noise_bands, params->noiseFloorOffset, 1389 params->useSpeechConfig)) 1390 return (1); 1391 1392 hEnv->encEnvData.noOfnoisebands = 1393 hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands; 1394 1395 noiseBands[0] = hEnv->encEnvData.noOfnoisebands; 1396 noiseBands[1] = hEnv->encEnvData.noOfnoisebands; 1397 1398 hEnv->encEnvData.sbr_invf_mode = (INVF_MODE)params->sbr_invf_mode; 1399 1400 if (hEnv->encEnvData.sbr_invf_mode == INVF_SWITCHED) { 1401 hEnv->encEnvData.sbr_invf_mode = INVF_MID_LEVEL; 1402 hEnv->TonCorr.switchInverseFilt = TRUE; 1403 } else { 1404 hEnv->TonCorr.switchInverseFilt = FALSE; 1405 } 1406 1407 tran_fc = params->tran_fc; 1408 1409 if (tran_fc == 0) { 1410 tran_fc = fixMin( 1411 5000, FDKsbrEnc_getSbrStartFreqRAW(sbrHeaderData->sbr_start_frequency, 1412 params->codecSettings.sampleFreq)); 1413 } 1414 1415 tran_fc = 1416 (tran_fc * 4 * sbrConfigData->noQmfBands / sbrConfigData->sampleFreq + 1417 1) >> 1418 1; 1419 1420 if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) { 1421 frameShift = LD_PRETRAN_OFF; 1422 tran_off = LD_PRETRAN_OFF + FRAME_MIDDLE_SLOT_512LD * timeStep; 1423 } else { 1424 frameShift = 0; 1425 switch (timeSlots) { 1426 /* The factor of 2 is by definition. */ 1427 case NUMBER_TIME_SLOTS_2048: 1428 tran_off = 8 + FRAME_MIDDLE_SLOT_2048 * timeStep; 1429 break; 1430 case NUMBER_TIME_SLOTS_1920: 1431 tran_off = 7 + FRAME_MIDDLE_SLOT_1920 * timeStep; 1432 break; 1433 default: 1434 return 1; 1435 } 1436 } 1437 if (FDKsbrEnc_InitExtractSbrEnvelope( 1438 &hEnv->sbrExtractEnvelope, sbrConfigData->noQmfSlots, 1439 sbrConfigData->noQmfBands, startIndex, timeSlots, timeStep, tran_off, 1440 statesInitFlag, chanInEl, dynamic_RAM, sbrConfigData->sbrSyntaxFlags)) 1441 return (1); 1442 1443 if (FDKsbrEnc_InitSbrCodeEnvelope(&hEnv->sbrCodeEnvelope, sbrConfigData->nSfb, 1444 params->deltaTAcrossFrames, 1445 params->dF_edge_1stEnv, 1446 params->dF_edge_incr)) 1447 return (1); 1448 1449 if (FDKsbrEnc_InitSbrCodeEnvelope(&hEnv->sbrCodeNoiseFloor, noiseBands, 1450 params->deltaTAcrossFrames, 0, 0)) 1451 return (1); 1452 1453 sbrConfigData->initAmpResFF = params->init_amp_res_FF; 1454 1455 if (FDKsbrEnc_InitSbrHuffmanTables(&hEnv->encEnvData, &hEnv->sbrCodeEnvelope, 1456 &hEnv->sbrCodeNoiseFloor, 1457 sbrHeaderData->sbr_amp_res)) 1458 return (1); 1459 1460 FDKsbrEnc_initFrameInfoGenerator( 1461 &hEnv->SbrEnvFrame, params->spread, e, params->stat, timeSlots, 1462 hEnv->encEnvData.freq_res_fixfix, hEnv->encEnvData.fResTransIsLow, 1463 hEnv->encEnvData.ldGrid); 1464 1465 if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) 1466 1467 { 1468 INT bandwidth_qmf_slot = 1469 (sbrConfigData->sampleFreq >> 1) / (sbrConfigData->noQmfBands); 1470 if (FDKsbrEnc_InitSbrFastTransientDetector( 1471 &hEnv->sbrFastTransientDetector, sbrConfigData->noQmfSlots, 1472 bandwidth_qmf_slot, sbrConfigData->noQmfBands, 1473 sbrConfigData->freqBandTable[0][0])) 1474 return (1); 1475 } 1476 1477 /* The transient detector has to be initialized also if the fast transient 1478 detector was active, because the values from the transient detector 1479 structure are used. */ 1480 if (FDKsbrEnc_InitSbrTransientDetector( 1481 &hEnv->sbrTransientDetector, sbrConfigData->sbrSyntaxFlags, 1482 sbrConfigData->frameSize, sbrConfigData->sampleFreq, params, tran_fc, 1483 sbrConfigData->noQmfSlots, sbrConfigData->noQmfBands, 1484 hEnv->sbrExtractEnvelope.YBufferWriteOffset, 1485 hEnv->sbrExtractEnvelope.YBufferSzShift, frameShift, tran_off)) 1486 return (1); 1487 1488 sbrConfigData->xposCtrlSwitch = params->sbr_xpos_ctrl; 1489 1490 hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI]; 1491 hEnv->encEnvData.addHarmonicFlag = 0; 1492 1493 return (0); 1494 } 1495 1496 INT sbrEncoder_Open(HANDLE_SBR_ENCODER *phSbrEncoder, INT nElements, 1497 INT nChannels, INT supportPS) { 1498 INT i; 1499 INT errorStatus = 1; 1500 HANDLE_SBR_ENCODER hSbrEncoder = NULL; 1501 1502 if (phSbrEncoder == NULL) { 1503 goto bail; 1504 } 1505 1506 hSbrEncoder = GetRam_SbrEncoder(); 1507 if (hSbrEncoder == NULL) { 1508 goto bail; 1509 } 1510 FDKmemclear(hSbrEncoder, sizeof(SBR_ENCODER)); 1511 1512 if (NULL == 1513 (hSbrEncoder->pSBRdynamic_RAM = (UCHAR *)GetRam_SbrDynamic_RAM())) { 1514 goto bail; 1515 } 1516 hSbrEncoder->dynamicRam = hSbrEncoder->pSBRdynamic_RAM; 1517 1518 /* Create SBR elements */ 1519 for (i = 0; i < nElements; i++) { 1520 hSbrEncoder->sbrElement[i] = GetRam_SbrElement(i); 1521 if (hSbrEncoder->sbrElement[i] == NULL) { 1522 goto bail; 1523 } 1524 FDKmemclear(hSbrEncoder->sbrElement[i], sizeof(SBR_ELEMENT)); 1525 hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] = 1526 GetRam_Sbr_freqBandTableLO(i); 1527 hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] = 1528 GetRam_Sbr_freqBandTableHI(i); 1529 hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master = 1530 GetRam_Sbr_v_k_master(i); 1531 if ((hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] == NULL) || 1532 (hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] == NULL) || 1533 (hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master == NULL)) { 1534 goto bail; 1535 } 1536 } 1537 1538 /* Create SBR channels */ 1539 for (i = 0; i < nChannels; i++) { 1540 hSbrEncoder->pSbrChannel[i] = GetRam_SbrChannel(i); 1541 if (hSbrEncoder->pSbrChannel[i] == NULL) { 1542 goto bail; 1543 } 1544 1545 if (createEnvChannel(&hSbrEncoder->pSbrChannel[i]->hEnvChannel, i, 1546 hSbrEncoder->dynamicRam)) { 1547 goto bail; 1548 } 1549 } 1550 1551 /* Create QMF States */ 1552 for (i = 0; i < fixMax(nChannels, (supportPS) ? 2 : 0); i++) { 1553 hSbrEncoder->QmfAnalysis[i].FilterStates = GetRam_Sbr_QmfStatesAnalysis(i); 1554 if (hSbrEncoder->QmfAnalysis[i].FilterStates == NULL) { 1555 goto bail; 1556 } 1557 } 1558 1559 /* Create Parametric Stereo handle */ 1560 if (supportPS) { 1561 if (PSEnc_Create(&hSbrEncoder->hParametricStereo)) { 1562 goto bail; 1563 } 1564 1565 hSbrEncoder->qmfSynthesisPS.FilterStates = GetRam_PsQmfStatesSynthesis(); 1566 if (hSbrEncoder->qmfSynthesisPS.FilterStates == NULL) { 1567 goto bail; 1568 } 1569 } /* supportPS */ 1570 1571 *phSbrEncoder = hSbrEncoder; 1572 1573 errorStatus = 0; 1574 return errorStatus; 1575 1576 bail: 1577 /* Close SBR encoder instance */ 1578 sbrEncoder_Close(&hSbrEncoder); 1579 return errorStatus; 1580 } 1581 1582 static INT FDKsbrEnc_Reallocate(HANDLE_SBR_ENCODER hSbrEncoder, 1583 SBR_ELEMENT_INFO elInfo[(8)], 1584 const INT noElements) { 1585 INT totalCh = 0; 1586 INT totalQmf = 0; 1587 INT coreEl; 1588 INT el = -1; 1589 1590 hSbrEncoder->lfeChIdx = -1; /* default value, until lfe found */ 1591 1592 for (coreEl = 0; coreEl < noElements; coreEl++) { 1593 /* SBR only handles SCE and CPE's */ 1594 if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) { 1595 el++; 1596 } else { 1597 if (elInfo[coreEl].elType == ID_LFE) { 1598 hSbrEncoder->lfeChIdx = elInfo[coreEl].ChannelIndex[0]; 1599 } 1600 continue; 1601 } 1602 1603 SBR_ELEMENT_INFO *pelInfo = &elInfo[coreEl]; 1604 HANDLE_SBR_ELEMENT hSbrElement = hSbrEncoder->sbrElement[el]; 1605 1606 int ch; 1607 for (ch = 0; ch < pelInfo->nChannelsInEl; ch++) { 1608 hSbrElement->sbrChannel[ch] = hSbrEncoder->pSbrChannel[totalCh]; 1609 totalCh++; 1610 } 1611 /* analysis QMF */ 1612 for (ch = 0; 1613 ch < ((pelInfo->fParametricStereo) ? 2 : pelInfo->nChannelsInEl); 1614 ch++) { 1615 hSbrElement->elInfo.ChannelIndex[ch] = pelInfo->ChannelIndex[ch]; 1616 hSbrElement->hQmfAnalysis[ch] = &hSbrEncoder->QmfAnalysis[totalQmf++]; 1617 } 1618 1619 /* Copy Element info */ 1620 hSbrElement->elInfo.elType = pelInfo->elType; 1621 hSbrElement->elInfo.instanceTag = pelInfo->instanceTag; 1622 hSbrElement->elInfo.nChannelsInEl = pelInfo->nChannelsInEl; 1623 hSbrElement->elInfo.fParametricStereo = pelInfo->fParametricStereo; 1624 hSbrElement->elInfo.fDualMono = pelInfo->fDualMono; 1625 } /* coreEl */ 1626 1627 return 0; 1628 } 1629 1630 /***************************************************************************** 1631 1632 functionname: FDKsbrEnc_bsBufInit 1633 description: initializes bitstream buffer 1634 returns: initialized bitstream buffer in env encoder 1635 input: 1636 output: hEnv 1637 1638 *****************************************************************************/ 1639 static INT FDKsbrEnc_bsBufInit(HANDLE_SBR_ELEMENT hSbrElement, 1640 int nBitstrDelay) { 1641 UCHAR *bitstreamBuffer; 1642 1643 /* initialize the bitstream buffer */ 1644 bitstreamBuffer = hSbrElement->payloadDelayLine[nBitstrDelay]; 1645 FDKinitBitStream(&hSbrElement->CmonData.sbrBitbuf, bitstreamBuffer, 1646 MAX_PAYLOAD_SIZE * sizeof(UCHAR), 0, BS_WRITER); 1647 1648 return (0); 1649 } 1650 1651 /***************************************************************************** 1652 1653 functionname: FDKsbrEnc_EnvInit 1654 description: initializes parameters 1655 returns: error status 1656 input: 1657 output: hEnv 1658 1659 *****************************************************************************/ 1660 static INT FDKsbrEnc_EnvInit(HANDLE_SBR_ELEMENT hSbrElement, 1661 sbrConfigurationPtr params, INT *coreBandWith, 1662 AUDIO_OBJECT_TYPE aot, int nElement, 1663 const int headerPeriod, ULONG statesInitFlag, 1664 const SBRENC_DS_TYPE downsamplingMethod, 1665 UCHAR *dynamic_RAM) { 1666 int ch, i; 1667 1668 if ((params->codecSettings.nChannels < 1) || 1669 (params->codecSettings.nChannels > MAX_NUM_CHANNELS)) { 1670 return (1); 1671 } 1672 1673 /* init and set syntax flags */ 1674 hSbrElement->sbrConfigData.sbrSyntaxFlags = 0; 1675 1676 switch (aot) { 1677 case AOT_ER_AAC_ELD: 1678 hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_LOW_DELAY; 1679 break; 1680 default: 1681 break; 1682 } 1683 if (params->crcSbr) { 1684 hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_CRC; 1685 } 1686 1687 hSbrElement->sbrConfigData.noQmfBands = 64 >> (2 - params->downSampleFactor); 1688 switch (hSbrElement->sbrConfigData.noQmfBands) { 1689 case 64: 1690 hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 6; 1691 break; 1692 case 32: 1693 hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 5; 1694 break; 1695 default: 1696 hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 6; 1697 return (2); 1698 } 1699 1700 /* 1701 now initialize sbrConfigData, sbrHeaderData and sbrBitstreamData, 1702 */ 1703 hSbrElement->sbrConfigData.nChannels = params->codecSettings.nChannels; 1704 1705 if (params->codecSettings.nChannels == 2) { 1706 if ((hSbrElement->elInfo.elType == ID_CPE) && 1707 ((hSbrElement->elInfo.fDualMono == 1))) { 1708 hSbrElement->sbrConfigData.stereoMode = SBR_LEFT_RIGHT; 1709 } else { 1710 hSbrElement->sbrConfigData.stereoMode = params->stereoMode; 1711 } 1712 } else { 1713 hSbrElement->sbrConfigData.stereoMode = SBR_MONO; 1714 } 1715 1716 hSbrElement->sbrConfigData.frameSize = params->sbrFrameSize; 1717 1718 hSbrElement->sbrConfigData.sampleFreq = 1719 params->downSampleFactor * params->codecSettings.sampleFreq; 1720 1721 hSbrElement->sbrBitstreamData.CountSendHeaderData = 0; 1722 if (params->SendHeaderDataTime > 0) { 1723 if (headerPeriod == -1) { 1724 hSbrElement->sbrBitstreamData.NrSendHeaderData = (INT)( 1725 params->SendHeaderDataTime * hSbrElement->sbrConfigData.sampleFreq / 1726 (1000 * hSbrElement->sbrConfigData.frameSize)); 1727 hSbrElement->sbrBitstreamData.NrSendHeaderData = 1728 fixMax(hSbrElement->sbrBitstreamData.NrSendHeaderData, 1); 1729 } else { 1730 /* assure header period at least once per second */ 1731 hSbrElement->sbrBitstreamData.NrSendHeaderData = fixMin( 1732 fixMax(headerPeriod, 1), (hSbrElement->sbrConfigData.sampleFreq / 1733 hSbrElement->sbrConfigData.frameSize)); 1734 } 1735 } else { 1736 hSbrElement->sbrBitstreamData.NrSendHeaderData = 0; 1737 } 1738 1739 hSbrElement->sbrHeaderData.sbr_data_extra = params->sbr_data_extra; 1740 hSbrElement->sbrBitstreamData.HeaderActive = 0; 1741 hSbrElement->sbrBitstreamData.rightBorderFIX = 0; 1742 hSbrElement->sbrHeaderData.sbr_start_frequency = params->startFreq; 1743 hSbrElement->sbrHeaderData.sbr_stop_frequency = params->stopFreq; 1744 hSbrElement->sbrHeaderData.sbr_xover_band = 0; 1745 hSbrElement->sbrHeaderData.sbr_lc_stereo_mode = 0; 1746 1747 /* data_extra */ 1748 if (params->sbr_xpos_ctrl != SBR_XPOS_CTRL_DEFAULT) 1749 hSbrElement->sbrHeaderData.sbr_data_extra = 1; 1750 1751 hSbrElement->sbrHeaderData.sbr_amp_res = (AMP_RES)params->amp_res; 1752 1753 /* header_extra_1 */ 1754 hSbrElement->sbrHeaderData.freqScale = params->freqScale; 1755 hSbrElement->sbrHeaderData.alterScale = params->alterScale; 1756 hSbrElement->sbrHeaderData.sbr_noise_bands = params->sbr_noise_bands; 1757 hSbrElement->sbrHeaderData.header_extra_1 = 0; 1758 1759 if ((params->freqScale != SBR_FREQ_SCALE_DEFAULT) || 1760 (params->alterScale != SBR_ALTER_SCALE_DEFAULT) || 1761 (params->sbr_noise_bands != SBR_NOISE_BANDS_DEFAULT)) { 1762 hSbrElement->sbrHeaderData.header_extra_1 = 1; 1763 } 1764 1765 /* header_extra_2 */ 1766 hSbrElement->sbrHeaderData.sbr_limiter_bands = params->sbr_limiter_bands; 1767 hSbrElement->sbrHeaderData.sbr_limiter_gains = params->sbr_limiter_gains; 1768 1769 if ((hSbrElement->sbrConfigData.sampleFreq > 48000) && 1770 (hSbrElement->sbrHeaderData.sbr_start_frequency >= 9)) { 1771 hSbrElement->sbrHeaderData.sbr_limiter_gains = SBR_LIMITER_GAINS_INFINITE; 1772 } 1773 1774 hSbrElement->sbrHeaderData.sbr_interpol_freq = params->sbr_interpol_freq; 1775 hSbrElement->sbrHeaderData.sbr_smoothing_length = 1776 params->sbr_smoothing_length; 1777 hSbrElement->sbrHeaderData.header_extra_2 = 0; 1778 1779 if ((params->sbr_limiter_bands != SBR_LIMITER_BANDS_DEFAULT) || 1780 (params->sbr_limiter_gains != SBR_LIMITER_GAINS_DEFAULT) || 1781 (params->sbr_interpol_freq != SBR_INTERPOL_FREQ_DEFAULT) || 1782 (params->sbr_smoothing_length != SBR_SMOOTHING_LENGTH_DEFAULT)) { 1783 hSbrElement->sbrHeaderData.header_extra_2 = 1; 1784 } 1785 1786 /* other switches */ 1787 hSbrElement->sbrConfigData.useWaveCoding = params->useWaveCoding; 1788 hSbrElement->sbrConfigData.useParametricCoding = params->parametricCoding; 1789 hSbrElement->sbrConfigData.thresholdAmpResFF_m = 1790 params->threshold_AmpRes_FF_m; 1791 hSbrElement->sbrConfigData.thresholdAmpResFF_e = 1792 params->threshold_AmpRes_FF_e; 1793 1794 /* init freq band table */ 1795 if (updateFreqBandTable(&hSbrElement->sbrConfigData, 1796 &hSbrElement->sbrHeaderData, 1797 params->downSampleFactor)) { 1798 return (1); 1799 } 1800 1801 /* now create envelope ext and QMF for each available channel */ 1802 for (ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++) { 1803 if (initEnvChannel(&hSbrElement->sbrConfigData, &hSbrElement->sbrHeaderData, 1804 &hSbrElement->sbrChannel[ch]->hEnvChannel, params, 1805 statesInitFlag, ch, dynamic_RAM)) { 1806 return (1); 1807 } 1808 1809 } /* nChannels */ 1810 1811 /* reset and intialize analysis qmf */ 1812 for (ch = 0; ch < ((hSbrElement->elInfo.fParametricStereo) 1813 ? 2 1814 : hSbrElement->sbrConfigData.nChannels); 1815 ch++) { 1816 int err; 1817 UINT qmfFlags = 1818 (hSbrElement->sbrConfigData.sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) 1819 ? QMF_FLAG_CLDFB 1820 : 0; 1821 if (statesInitFlag) 1822 qmfFlags &= ~QMF_FLAG_KEEP_STATES; 1823 else 1824 qmfFlags |= QMF_FLAG_KEEP_STATES; 1825 1826 err = qmfInitAnalysisFilterBank( 1827 hSbrElement->hQmfAnalysis[ch], 1828 (FIXP_QAS *)hSbrElement->hQmfAnalysis[ch]->FilterStates, 1829 hSbrElement->sbrConfigData.noQmfSlots, 1830 hSbrElement->sbrConfigData.noQmfBands, 1831 hSbrElement->sbrConfigData.noQmfBands, 1832 hSbrElement->sbrConfigData.noQmfBands, qmfFlags); 1833 if (0 != err) { 1834 return err; 1835 } 1836 } 1837 1838 /* */ 1839 hSbrElement->CmonData.xOverFreq = hSbrElement->sbrConfigData.xOverFreq; 1840 hSbrElement->CmonData.dynBwEnabled = 1841 (params->dynBwSupported && params->dynBwEnabled); 1842 hSbrElement->CmonData.dynXOverFreqEnc = 1843 FDKsbrEnc_SbrGetXOverFreq(hSbrElement, hSbrElement->CmonData.xOverFreq); 1844 for (i = 0; i < 5; i++) 1845 hSbrElement->dynXOverFreqDelay[i] = hSbrElement->CmonData.dynXOverFreqEnc; 1846 hSbrElement->CmonData.sbrNumChannels = hSbrElement->sbrConfigData.nChannels; 1847 hSbrElement->sbrConfigData.dynXOverFreq = hSbrElement->CmonData.xOverFreq; 1848 1849 /* Update Bandwith to be passed to the core encoder */ 1850 *coreBandWith = hSbrElement->CmonData.xOverFreq; 1851 1852 return (0); 1853 } 1854 1855 INT sbrEncoder_GetInBufferSize(int noChannels) { 1856 INT temp; 1857 1858 temp = (2048); 1859 temp += 1024 + MAX_SAMPLE_DELAY; 1860 temp *= noChannels; 1861 temp *= sizeof(INT_PCM); 1862 return temp; 1863 } 1864 1865 /* 1866 * Encode Dummy SBR payload frames to fill the delay lines. 1867 */ 1868 static INT FDKsbrEnc_DelayCompensation(HANDLE_SBR_ENCODER hEnvEnc, 1869 INT_PCM *timeBuffer, 1870 UINT timeBufferBufSize) { 1871 int n, el; 1872 1873 for (n = hEnvEnc->nBitstrDelay; n > 0; n--) { 1874 for (el = 0; el < hEnvEnc->noElements; el++) { 1875 if (FDKsbrEnc_EnvEncodeFrame( 1876 hEnvEnc, el, 1877 timeBuffer + hEnvEnc->downsampledOffset / hEnvEnc->nChannels, 1878 timeBufferBufSize, NULL, NULL, 1)) 1879 return -1; 1880 } 1881 sbrEncoder_UpdateBuffers(hEnvEnc, timeBuffer, timeBufferBufSize); 1882 } 1883 return 0; 1884 } 1885 1886 UINT sbrEncoder_LimitBitRate(UINT bitRate, UINT numChannels, 1887 UINT coreSampleRate, AUDIO_OBJECT_TYPE aot) { 1888 UINT newBitRate = bitRate; 1889 INT index; 1890 1891 FDK_ASSERT(numChannels > 0 && numChannels <= 2); 1892 if (aot == AOT_PS) { 1893 if (numChannels == 1) { 1894 index = getPsTuningTableIndex(bitRate, &newBitRate); 1895 if (index == INVALID_TABLE_IDX) { 1896 bitRate = newBitRate; 1897 } 1898 } else { 1899 return 0; 1900 } 1901 } 1902 index = getSbrTuningTableIndex(bitRate, numChannels, coreSampleRate, aot, 1903 &newBitRate); 1904 if (index != INVALID_TABLE_IDX) { 1905 newBitRate = bitRate; 1906 } 1907 1908 return newBitRate; 1909 } 1910 1911 UINT sbrEncoder_IsSingleRatePossible(AUDIO_OBJECT_TYPE aot) { 1912 UINT isPossible = (AOT_PS == aot) ? 0 : 1; 1913 return isPossible; 1914 } 1915 1916 /*****************************************************************************/ 1917 /* */ 1918 /*functionname: sbrEncoder_Init_delay */ 1919 /*description: Determine Delay balancing and new encoder delay */ 1920 /* */ 1921 /*returns: - error status */ 1922 /*input: - frame length of the core (i.e. e.g. AAC) */ 1923 /* - number of channels */ 1924 /* - downsample factor (1 for downsampled, 2 for dual-rate SBR) */ 1925 /* - low delay presence */ 1926 /* - ps presence */ 1927 /* - downsampling method: QMF-, time domain or no downsampling */ 1928 /* - various delay values (see DELAY_PARAM struct description) */ 1929 /* */ 1930 /*Example: Delay balancing for a HE-AACv1 encoder (time-domain downsampling) */ 1931 /*========================================================================== */ 1932 /* */ 1933 /* +--------+ +--------+ +--------+ +--------+ +--------+ */ 1934 /* |core | |ds 2:1 | |AAC | |QMF | |QMF | */ 1935 /* +-+path +------------+ +-+core +-+analysis+-+overlap +-+ */ 1936 /* | |offset | | | | | |32 bands| | | | */ 1937 /* | +--------+ +--------+ +--------+ +--------+ +--------+ | */ 1938 /* | core path +-------++ */ 1939 /* | |QMF | */ 1940 /*->+ +synth. +-> */ 1941 /* | |64 bands| */ 1942 /* | +-------++ */ 1943 /* | +--------+ +--------+ +--------+ +--------+ | */ 1944 /* | |SBR path| |QMF | |subband | |bs delay| | */ 1945 /* +-+offset +-+analysis+-+sample +-+(full +-----------------------+ */ 1946 /* | | |64 bands| |buffer | | frames)| */ 1947 /* +--------+ +--------+ +--------+ +--------+ */ 1948 /* SBR path */ 1949 /* */ 1950 /*****************************************************************************/ 1951 static INT sbrEncoder_Init_delay( 1952 const int coreFrameLength, /* input */ 1953 const int numChannels, /* input */ 1954 const int downSampleFactor, /* input */ 1955 const int lowDelay, /* input */ 1956 const int usePs, /* input */ 1957 const int is212, /* input */ 1958 const SBRENC_DS_TYPE downsamplingMethod, /* input */ 1959 DELAY_PARAM *hDelayParam /* input/output */ 1960 ) { 1961 int delayCorePath = 0; /* delay in core path */ 1962 int delaySbrPath = 0; /* delay difference in QMF aka SBR path */ 1963 int delayInput2Core = 0; /* delay from the input to the core */ 1964 int delaySbrDec = 0; /* delay of the decoder's SBR module */ 1965 1966 int delayCore = hDelayParam->delay; /* delay of the core */ 1967 1968 /* Added delay by the SBR delay initialization */ 1969 int corePathOffset = 0; /* core path */ 1970 int sbrPathOffset = 0; /* sbr path */ 1971 int bitstreamDelay = 0; /* sbr path, framewise */ 1972 1973 int flCore = coreFrameLength; /* core frame length */ 1974 1975 int returnValue = 0; /* return value - 0 means: no error */ 1976 1977 /* 1) Calculate actual delay for core and SBR path */ 1978 if (is212) { 1979 delayCorePath = DELAY_COREPATH_ELDv2SBR(flCore, downSampleFactor); 1980 delaySbrPath = DELAY_ELDv2SBR(flCore, downSampleFactor); 1981 delaySbrDec = ((flCore) / 2) * (downSampleFactor); 1982 } else if (lowDelay) { 1983 delayCorePath = DELAY_COREPATH_ELDSBR(flCore, downSampleFactor); 1984 delaySbrPath = DELAY_ELDSBR(flCore, downSampleFactor); 1985 delaySbrDec = DELAY_QMF_POSTPROC(downSampleFactor); 1986 } else if (usePs) { 1987 delayCorePath = DELAY_COREPATH_PS(flCore, downSampleFactor); 1988 delaySbrPath = DELAY_PS(flCore, downSampleFactor); 1989 delaySbrDec = DELAY_COREPATH_SBR(flCore, downSampleFactor); 1990 } else { 1991 delayCorePath = DELAY_COREPATH_SBR(flCore, downSampleFactor); 1992 delaySbrPath = DELAY_SBR(flCore, downSampleFactor); 1993 delaySbrDec = DELAY_COREPATH_SBR(flCore, downSampleFactor); 1994 } 1995 delayCorePath += delayCore * downSampleFactor; 1996 delayCorePath += 1997 (downsamplingMethod == SBRENC_DS_TIME) ? hDelayParam->dsDelay : 0; 1998 1999 /* 2) Manage coupling of paths */ 2000 if (downsamplingMethod == SBRENC_DS_QMF && delayCorePath > delaySbrPath) { 2001 /* In case of QMF downsampling, both paths are coupled, i.e. the SBR path 2002 offset would be added to both the SBR path and to the core path 2003 as well, thus making it impossible to achieve delay balancing. 2004 To overcome that problem, a framewise delay is added to the SBR path 2005 first, until the overall delay of the core path is shorter than 2006 the delay of the SBR path. When this is achieved, the missing delay 2007 difference can be added as downsampled offset to the core path. 2008 */ 2009 while (delayCorePath > delaySbrPath) { 2010 /* Add one frame delay to SBR path */ 2011 delaySbrPath += flCore * downSampleFactor; 2012 bitstreamDelay += 1; 2013 } 2014 } 2015 2016 /* 3) Calculate necessary additional delay to balance the paths */ 2017 if (delayCorePath > delaySbrPath) { 2018 /* Delay QMF input */ 2019 while (delayCorePath > delaySbrPath + (int)flCore * (int)downSampleFactor) { 2020 /* Do bitstream frame-wise delay balancing if there are 2021 more than SBR framelength samples delay difference */ 2022 delaySbrPath += flCore * downSampleFactor; 2023 bitstreamDelay += 1; 2024 } 2025 /* Multiply input offset by input channels */ 2026 corePathOffset = 0; 2027 sbrPathOffset = (delayCorePath - delaySbrPath) * numChannels; 2028 } else { 2029 /* Delay AAC data */ 2030 /* Multiply downsampled offset by AAC core channels. Divide by 2 because of 2031 half samplerate of downsampled data. */ 2032 corePathOffset = ((delaySbrPath - delayCorePath) * numChannels) >> 2033 (downSampleFactor - 1); 2034 sbrPathOffset = 0; 2035 } 2036 2037 /* 4) Calculate delay from input to core */ 2038 if (usePs) { 2039 delayInput2Core = 2040 (DELAY_QMF_ANA(downSampleFactor) + DELAY_QMF_DS + DELAY_HYB_SYN) + 2041 (downSampleFactor * corePathOffset) + 1; 2042 } else if (downsamplingMethod == SBRENC_DS_TIME) { 2043 delayInput2Core = corePathOffset + hDelayParam->dsDelay; 2044 } else { 2045 delayInput2Core = corePathOffset; 2046 } 2047 2048 /* 6) Set output parameters */ 2049 hDelayParam->delay = FDKmax(delayCorePath, delaySbrPath); /* overall delay */ 2050 hDelayParam->sbrDecDelay = delaySbrDec; /* SBR decoder delay */ 2051 hDelayParam->delayInput2Core = delayInput2Core; /* delay input - core */ 2052 hDelayParam->bitstrDelay = bitstreamDelay; /* bitstream delay, in frames */ 2053 hDelayParam->corePathOffset = corePathOffset; /* offset added to core path */ 2054 hDelayParam->sbrPathOffset = sbrPathOffset; /* offset added to SBR path */ 2055 2056 return returnValue; 2057 } 2058 2059 /***************************************************************************** 2060 2061 functionname: sbrEncoder_Init 2062 description: initializes the SBR encoder 2063 returns: error status 2064 2065 *****************************************************************************/ 2066 INT sbrEncoder_Init(HANDLE_SBR_ENCODER hSbrEncoder, 2067 SBR_ELEMENT_INFO elInfo[(8)], int noElements, 2068 INT_PCM *inputBuffer, UINT inputBufferBufSize, 2069 INT *coreBandwidth, INT *inputBufferOffset, 2070 INT *numChannels, const UINT syntaxFlags, 2071 INT *coreSampleRate, UINT *downSampleFactor, 2072 INT *frameLength, AUDIO_OBJECT_TYPE aot, int *delay, 2073 int transformFactor, const int headerPeriod, 2074 ULONG statesInitFlag) { 2075 HANDLE_ERROR_INFO errorInfo = noError; 2076 sbrConfiguration sbrConfig[(8)]; 2077 INT error = 0; 2078 INT lowestBandwidth; 2079 /* Save input parameters */ 2080 INT inputSampleRate = *coreSampleRate; 2081 int coreFrameLength = *frameLength; 2082 int inputBandWidth = *coreBandwidth; 2083 int inputChannels = *numChannels; 2084 2085 SBRENC_DS_TYPE downsamplingMethod = SBRENC_DS_NONE; 2086 int highestSbrStartFreq, highestSbrStopFreq; 2087 int lowDelay = 0; 2088 int usePs = 0; 2089 int is212 = 0; 2090 2091 DELAY_PARAM delayParam; 2092 2093 /* check whether SBR setting is available for the current encoder 2094 * configuration (bitrate, samplerate) */ 2095 if (!sbrEncoder_IsSingleRatePossible(aot)) { 2096 *downSampleFactor = 2; 2097 } 2098 2099 if (aot == AOT_PS) { 2100 usePs = 1; 2101 } 2102 if (aot == AOT_ER_AAC_ELD) { 2103 lowDelay = 1; 2104 } else if (aot == AOT_ER_AAC_LD) { 2105 error = 1; 2106 goto bail; 2107 } 2108 2109 /* Parametric Stereo */ 2110 if (usePs) { 2111 if (*numChannels == 2 && noElements == 1) { 2112 /* Override Element type in case of Parametric stereo */ 2113 elInfo[0].elType = ID_SCE; 2114 elInfo[0].fParametricStereo = 1; 2115 elInfo[0].nChannelsInEl = 1; 2116 /* core encoder gets downmixed mono signal */ 2117 *numChannels = 1; 2118 } else { 2119 error = 1; 2120 goto bail; 2121 } 2122 } /* usePs */ 2123 2124 /* set the core's sample rate */ 2125 switch (*downSampleFactor) { 2126 case 1: 2127 *coreSampleRate = inputSampleRate; 2128 downsamplingMethod = SBRENC_DS_NONE; 2129 break; 2130 case 2: 2131 *coreSampleRate = inputSampleRate >> 1; 2132 downsamplingMethod = usePs ? SBRENC_DS_QMF : SBRENC_DS_TIME; 2133 break; 2134 default: 2135 *coreSampleRate = inputSampleRate >> 1; 2136 return 0; /* return error */ 2137 } 2138 2139 /* check whether SBR setting is available for the current encoder 2140 * configuration (bitrate, coreSampleRate) */ 2141 { 2142 int el, coreEl; 2143 2144 /* Check if every element config is feasible */ 2145 for (coreEl = 0; coreEl < noElements; coreEl++) { 2146 /* SBR only handles SCE and CPE's */ 2147 if (elInfo[coreEl].elType != ID_SCE && elInfo[coreEl].elType != ID_CPE) { 2148 continue; 2149 } 2150 /* check if desired configuration is available */ 2151 if (!FDKsbrEnc_IsSbrSettingAvail(elInfo[coreEl].bitRate, 0, 2152 elInfo[coreEl].nChannelsInEl, 2153 inputSampleRate, *coreSampleRate, aot)) { 2154 error = 1; 2155 goto bail; 2156 } 2157 } 2158 2159 hSbrEncoder->nChannels = *numChannels; 2160 hSbrEncoder->frameSize = coreFrameLength * *downSampleFactor; 2161 hSbrEncoder->downsamplingMethod = downsamplingMethod; 2162 hSbrEncoder->downSampleFactor = *downSampleFactor; 2163 hSbrEncoder->estimateBitrate = 0; 2164 hSbrEncoder->inputDataDelay = 0; 2165 is212 = ((aot == AOT_ER_AAC_ELD) && (syntaxFlags & AC_LD_MPS)) ? 1 : 0; 2166 2167 /* Open SBR elements */ 2168 el = -1; 2169 highestSbrStartFreq = highestSbrStopFreq = 0; 2170 lowestBandwidth = 99999; 2171 2172 /* Loop through each core encoder element and get a matching SBR element 2173 * config */ 2174 for (coreEl = 0; coreEl < noElements; coreEl++) { 2175 /* SBR only handles SCE and CPE's */ 2176 if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) { 2177 el++; 2178 } else { 2179 continue; 2180 } 2181 2182 /* Set parametric Stereo Flag. */ 2183 if (usePs) { 2184 elInfo[coreEl].fParametricStereo = 1; 2185 } else { 2186 elInfo[coreEl].fParametricStereo = 0; 2187 } 2188 2189 /* 2190 * Init sbrConfig structure 2191 */ 2192 if (!FDKsbrEnc_InitializeSbrDefaults(&sbrConfig[el], *downSampleFactor, 2193 coreFrameLength, IS_LOWDELAY(aot))) { 2194 error = 1; 2195 goto bail; 2196 } 2197 2198 /* 2199 * Modify sbrConfig structure according to Element parameters 2200 */ 2201 if (!FDKsbrEnc_AdjustSbrSettings( 2202 &sbrConfig[el], elInfo[coreEl].bitRate, 2203 elInfo[coreEl].nChannelsInEl, *coreSampleRate, inputSampleRate, 2204 transformFactor, 24000, 0, 0, /* useSpeechConfig */ 2205 0, /* lcsMode */ 2206 usePs, /* bParametricStereo */ 2207 aot)) { 2208 error = 1; 2209 goto bail; 2210 } 2211 2212 /* Find common frequency border for all SBR elements */ 2213 highestSbrStartFreq = 2214 fixMax(highestSbrStartFreq, sbrConfig[el].startFreq); 2215 highestSbrStopFreq = fixMax(highestSbrStopFreq, sbrConfig[el].stopFreq); 2216 2217 } /* first element loop */ 2218 2219 /* Set element count (can be less than core encoder element count) */ 2220 hSbrEncoder->noElements = el + 1; 2221 2222 FDKsbrEnc_Reallocate(hSbrEncoder, elInfo, noElements); 2223 2224 for (el = 0; el < hSbrEncoder->noElements; el++) { 2225 int bandwidth = *coreBandwidth; 2226 2227 /* Use lowest common bandwidth */ 2228 sbrConfig[el].startFreq = highestSbrStartFreq; 2229 sbrConfig[el].stopFreq = highestSbrStopFreq; 2230 2231 /* initialize SBR element, and get core bandwidth */ 2232 error = FDKsbrEnc_EnvInit(hSbrEncoder->sbrElement[el], &sbrConfig[el], 2233 &bandwidth, aot, el, headerPeriod, 2234 statesInitFlag, hSbrEncoder->downsamplingMethod, 2235 hSbrEncoder->dynamicRam); 2236 2237 if (error != 0) { 2238 error = 2; 2239 goto bail; 2240 } 2241 2242 /* Get lowest core encoder bandwidth to be returned later. */ 2243 lowestBandwidth = fixMin(lowestBandwidth, bandwidth); 2244 2245 } /* second element loop */ 2246 2247 /* Initialize a downsampler for each channel in each SBR element */ 2248 if (hSbrEncoder->downsamplingMethod == SBRENC_DS_TIME) { 2249 for (el = 0; el < hSbrEncoder->noElements; el++) { 2250 HANDLE_SBR_ELEMENT hSbrEl = hSbrEncoder->sbrElement[el]; 2251 INT Wc, ch; 2252 2253 Wc = 500; /* Cutoff frequency with full bandwidth */ 2254 2255 for (ch = 0; ch < hSbrEl->elInfo.nChannelsInEl; ch++) { 2256 FDKaacEnc_InitDownsampler(&hSbrEl->sbrChannel[ch]->downSampler, Wc, 2257 *downSampleFactor); 2258 FDK_ASSERT(hSbrEl->sbrChannel[ch]->downSampler.delay <= 2259 MAX_DS_FILTER_DELAY); 2260 } 2261 } /* third element loop */ 2262 2263 /* lfe */ 2264 FDKaacEnc_InitDownsampler(&hSbrEncoder->lfeDownSampler, 0, 2265 *downSampleFactor); 2266 } 2267 2268 /* Get delay information */ 2269 delayParam.dsDelay = 2270 hSbrEncoder->sbrElement[0]->sbrChannel[0]->downSampler.delay; 2271 delayParam.delay = *delay; 2272 2273 error = sbrEncoder_Init_delay(coreFrameLength, *numChannels, 2274 *downSampleFactor, lowDelay, usePs, is212, 2275 downsamplingMethod, &delayParam); 2276 2277 if (error != 0) { 2278 error = 3; 2279 goto bail; 2280 } 2281 2282 hSbrEncoder->nBitstrDelay = delayParam.bitstrDelay; 2283 hSbrEncoder->sbrDecDelay = delayParam.sbrDecDelay; 2284 hSbrEncoder->inputDataDelay = delayParam.delayInput2Core; 2285 2286 /* Assign core encoder Bandwidth */ 2287 *coreBandwidth = lowestBandwidth; 2288 2289 /* Estimate sbr bitrate, 2.5 kBit/s per sbr channel */ 2290 hSbrEncoder->estimateBitrate += 2500 * (*numChannels); 2291 2292 /* Initialize bitstream buffer for each element */ 2293 for (el = 0; el < hSbrEncoder->noElements; el++) { 2294 FDKsbrEnc_bsBufInit(hSbrEncoder->sbrElement[el], delayParam.bitstrDelay); 2295 } 2296 2297 /* initialize parametric stereo */ 2298 if (usePs) { 2299 PSENC_CONFIG psEncConfig; 2300 FDK_ASSERT(hSbrEncoder->noElements == 1); 2301 INT psTuningTableIdx = getPsTuningTableIndex(elInfo[0].bitRate, NULL); 2302 2303 psEncConfig.frameSize = coreFrameLength; // sbrConfig.sbrFrameSize; 2304 psEncConfig.qmfFilterMode = 0; 2305 psEncConfig.sbrPsDelay = 0; 2306 2307 /* tuning parameters */ 2308 if (psTuningTableIdx != INVALID_TABLE_IDX) { 2309 psEncConfig.nStereoBands = psTuningTable[psTuningTableIdx].nStereoBands; 2310 psEncConfig.maxEnvelopes = psTuningTable[psTuningTableIdx].nEnvelopes; 2311 psEncConfig.iidQuantErrorThreshold = 2312 (FIXP_DBL)psTuningTable[psTuningTableIdx].iidQuantErrorThreshold; 2313 2314 /* calculation is not quite linear, increased number of envelopes causes 2315 * more bits */ 2316 /* assume avg. 50 bits per frame for 10 stereo bands / 1 envelope 2317 * configuration */ 2318 hSbrEncoder->estimateBitrate += 2319 ((((*coreSampleRate) * 5 * psEncConfig.nStereoBands * 2320 psEncConfig.maxEnvelopes) / 2321 hSbrEncoder->frameSize)); 2322 2323 } else { 2324 error = ERROR(CDI, "Invalid ps tuning table index."); 2325 goto bail; 2326 } 2327 2328 qmfInitSynthesisFilterBank( 2329 &hSbrEncoder->qmfSynthesisPS, 2330 (FIXP_DBL *)hSbrEncoder->qmfSynthesisPS.FilterStates, 2331 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots, 2332 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1, 2333 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1, 2334 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1, 2335 (statesInitFlag) ? 0 : QMF_FLAG_KEEP_STATES); 2336 2337 if (errorInfo == noError) { 2338 /* update delay */ 2339 psEncConfig.sbrPsDelay = 2340 FDKsbrEnc_GetEnvEstDelay(&hSbrEncoder->sbrElement[0] 2341 ->sbrChannel[0] 2342 ->hEnvChannel.sbrExtractEnvelope); 2343 2344 errorInfo = 2345 PSEnc_Init(hSbrEncoder->hParametricStereo, &psEncConfig, 2346 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots, 2347 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands, 2348 hSbrEncoder->dynamicRam); 2349 } 2350 } 2351 2352 hSbrEncoder->downsampledOffset = delayParam.corePathOffset; 2353 hSbrEncoder->bufferOffset = delayParam.sbrPathOffset; 2354 *delay = delayParam.delay; 2355 2356 { hSbrEncoder->downmixSize = coreFrameLength * (*numChannels); } 2357 2358 /* Delay Compensation: fill bitstream delay buffer with zero input signal */ 2359 if (hSbrEncoder->nBitstrDelay > 0) { 2360 error = FDKsbrEnc_DelayCompensation(hSbrEncoder, inputBuffer, 2361 inputBufferBufSize); 2362 if (error != 0) goto bail; 2363 } 2364 2365 /* Set Output frame length */ 2366 *frameLength = coreFrameLength * *downSampleFactor; 2367 /* Input buffer offset */ 2368 *inputBufferOffset = 2369 fixMax(delayParam.sbrPathOffset, delayParam.corePathOffset); 2370 } 2371 2372 return error; 2373 2374 bail: 2375 /* Restore input settings */ 2376 *coreSampleRate = inputSampleRate; 2377 *frameLength = coreFrameLength; 2378 *numChannels = inputChannels; 2379 *coreBandwidth = inputBandWidth; 2380 2381 return error; 2382 } 2383 2384 INT sbrEncoder_EncodeFrame(HANDLE_SBR_ENCODER hSbrEncoder, INT_PCM *samples, 2385 UINT samplesBufSize, UINT sbrDataBits[(8)], 2386 UCHAR sbrData[(8)][MAX_PAYLOAD_SIZE]) { 2387 INT error; 2388 int el; 2389 2390 for (el = 0; el < hSbrEncoder->noElements; el++) { 2391 if (hSbrEncoder->sbrElement[el] != NULL) { 2392 error = FDKsbrEnc_EnvEncodeFrame( 2393 hSbrEncoder, el, 2394 samples + hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels, 2395 samplesBufSize, &sbrDataBits[el], sbrData[el], 0); 2396 if (error) return error; 2397 } 2398 } 2399 2400 error = FDKsbrEnc_Downsample( 2401 hSbrEncoder, 2402 samples + hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels, 2403 samplesBufSize, hSbrEncoder->nChannels, &sbrDataBits[el], sbrData[el], 0); 2404 if (error) return error; 2405 2406 return 0; 2407 } 2408 2409 INT sbrEncoder_UpdateBuffers(HANDLE_SBR_ENCODER hSbrEncoder, 2410 INT_PCM *timeBuffer, UINT timeBufferBufSize) { 2411 if (hSbrEncoder->downsampledOffset > 0) { 2412 int c; 2413 int nd = hSbrEncoder->downmixSize / hSbrEncoder->nChannels; 2414 2415 for (c = 0; c < hSbrEncoder->nChannels; c++) { 2416 /* Move delayed downsampled data */ 2417 FDKmemcpy(timeBuffer + timeBufferBufSize * c, 2418 timeBuffer + timeBufferBufSize * c + nd, 2419 sizeof(INT_PCM) * 2420 (hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels)); 2421 } 2422 } else { 2423 int c; 2424 2425 for (c = 0; c < hSbrEncoder->nChannels; c++) { 2426 /* Move delayed input data */ 2427 FDKmemcpy( 2428 timeBuffer + timeBufferBufSize * c, 2429 timeBuffer + timeBufferBufSize * c + hSbrEncoder->frameSize, 2430 sizeof(INT_PCM) * hSbrEncoder->bufferOffset / hSbrEncoder->nChannels); 2431 } 2432 } 2433 if (hSbrEncoder->nBitstrDelay > 0) { 2434 int el; 2435 2436 for (el = 0; el < hSbrEncoder->noElements; el++) { 2437 FDKmemmove( 2438 hSbrEncoder->sbrElement[el]->payloadDelayLine[0], 2439 hSbrEncoder->sbrElement[el]->payloadDelayLine[1], 2440 sizeof(UCHAR) * (hSbrEncoder->nBitstrDelay * MAX_PAYLOAD_SIZE)); 2441 2442 FDKmemmove(&hSbrEncoder->sbrElement[el]->payloadDelayLineSize[0], 2443 &hSbrEncoder->sbrElement[el]->payloadDelayLineSize[1], 2444 sizeof(UINT) * (hSbrEncoder->nBitstrDelay)); 2445 } 2446 } 2447 return 0; 2448 } 2449 2450 INT sbrEncoder_SendHeader(HANDLE_SBR_ENCODER hSbrEncoder) { 2451 INT error = -1; 2452 if (hSbrEncoder) { 2453 int el; 2454 for (el = 0; el < hSbrEncoder->noElements; el++) { 2455 if ((hSbrEncoder->noElements == 1) && 2456 (hSbrEncoder->sbrElement[0]->elInfo.fParametricStereo == 1)) { 2457 hSbrEncoder->sbrElement[el]->sbrBitstreamData.CountSendHeaderData = 2458 hSbrEncoder->sbrElement[el]->sbrBitstreamData.NrSendHeaderData - 1; 2459 } else { 2460 hSbrEncoder->sbrElement[el]->sbrBitstreamData.CountSendHeaderData = 0; 2461 } 2462 } 2463 error = 0; 2464 } 2465 return error; 2466 } 2467 2468 INT sbrEncoder_ContainsHeader(HANDLE_SBR_ENCODER hSbrEncoder) { 2469 INT sbrHeader = 1; 2470 if (hSbrEncoder) { 2471 int el; 2472 for (el = 0; el < hSbrEncoder->noElements; el++) { 2473 sbrHeader &= 2474 (hSbrEncoder->sbrElement[el]->sbrBitstreamData.HeaderActiveDelay == 1) 2475 ? 1 2476 : 0; 2477 } 2478 } 2479 return sbrHeader; 2480 } 2481 2482 INT sbrEncoder_GetHeaderDelay(HANDLE_SBR_ENCODER hSbrEncoder) { 2483 INT delay = -1; 2484 2485 if (hSbrEncoder) { 2486 if ((hSbrEncoder->noElements == 1) && 2487 (hSbrEncoder->sbrElement[0]->elInfo.fParametricStereo == 1)) { 2488 delay = hSbrEncoder->nBitstrDelay + 1; 2489 } else { 2490 delay = hSbrEncoder->nBitstrDelay; 2491 } 2492 } 2493 return delay; 2494 } 2495 INT sbrEncoder_GetBsDelay(HANDLE_SBR_ENCODER hSbrEncoder) { 2496 INT delay = -1; 2497 2498 if (hSbrEncoder) { 2499 delay = hSbrEncoder->nBitstrDelay; 2500 } 2501 return delay; 2502 } 2503 2504 INT sbrEncoder_SAPPrepare(HANDLE_SBR_ENCODER hSbrEncoder) { 2505 INT error = -1; 2506 if (hSbrEncoder) { 2507 int el; 2508 for (el = 0; el < hSbrEncoder->noElements; el++) { 2509 hSbrEncoder->sbrElement[el]->sbrBitstreamData.rightBorderFIX = 1; 2510 } 2511 error = 0; 2512 } 2513 return error; 2514 } 2515 2516 INT sbrEncoder_GetEstimateBitrate(HANDLE_SBR_ENCODER hSbrEncoder) { 2517 INT estimateBitrate = 0; 2518 2519 if (hSbrEncoder) { 2520 estimateBitrate += hSbrEncoder->estimateBitrate; 2521 } 2522 2523 return estimateBitrate; 2524 } 2525 2526 INT sbrEncoder_GetInputDataDelay(HANDLE_SBR_ENCODER hSbrEncoder) { 2527 INT delay = -1; 2528 2529 if (hSbrEncoder) { 2530 delay = hSbrEncoder->inputDataDelay; 2531 } 2532 return delay; 2533 } 2534 2535 INT sbrEncoder_GetSbrDecDelay(HANDLE_SBR_ENCODER hSbrEncoder) { 2536 INT delay = -1; 2537 2538 if (hSbrEncoder) { 2539 delay = hSbrEncoder->sbrDecDelay; 2540 } 2541 return delay; 2542 } 2543 2544 INT sbrEncoder_GetLibInfo(LIB_INFO *info) { 2545 int i; 2546 2547 if (info == NULL) { 2548 return -1; 2549 } 2550 /* search for next free tab */ 2551 for (i = 0; i < FDK_MODULE_LAST; i++) { 2552 if (info[i].module_id == FDK_NONE) break; 2553 } 2554 if (i == FDK_MODULE_LAST) { 2555 return -1; 2556 } 2557 info += i; 2558 2559 info->module_id = FDK_SBRENC; 2560 info->version = 2561 LIB_VERSION(SBRENCODER_LIB_VL0, SBRENCODER_LIB_VL1, SBRENCODER_LIB_VL2); 2562 LIB_VERSION_STRING(info); 2563 #ifdef __ANDROID__ 2564 info->build_date = ""; 2565 info->build_time = ""; 2566 #else 2567 info->build_date = __DATE__; 2568 info->build_time = __TIME__; 2569 #endif 2570 info->title = "SBR Encoder"; 2571 2572 /* Set flags */ 2573 info->flags = 0 | CAPF_SBR_HQ | CAPF_SBR_PS_MPEG; 2574 /* End of flags */ 2575 2576 return 0; 2577 } 2578
