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