| /* ----------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten |
| Forschung e.V. All rights reserved. |
| |
| 1. INTRODUCTION |
| The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software |
| that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding |
| scheme for digital audio. This FDK AAC Codec software is intended to be used on |
| a wide variety of Android devices. |
| |
| AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient |
| general perceptual audio codecs. AAC-ELD is considered the best-performing |
| full-bandwidth communications codec by independent studies and is widely |
| deployed. AAC has been standardized by ISO and IEC as part of the MPEG |
| specifications. |
| |
| Patent licenses for necessary patent claims for the FDK AAC Codec (including |
| those of Fraunhofer) may be obtained through Via Licensing |
| (www.vialicensing.com) or through the respective patent owners individually for |
| the purpose of encoding or decoding bit streams in products that are compliant |
| with the ISO/IEC MPEG audio standards. Please note that most manufacturers of |
| Android devices already license these patent claims through Via Licensing or |
| directly from the patent owners, and therefore FDK AAC Codec software may |
| already be covered under those patent licenses when it is used for those |
| licensed purposes only. |
| |
| Commercially-licensed AAC software libraries, including floating-point versions |
| with enhanced sound quality, are also available from Fraunhofer. Users are |
| encouraged to check the Fraunhofer website for additional applications |
| information and documentation. |
| |
| 2. COPYRIGHT LICENSE |
| |
| Redistribution and use in source and binary forms, with or without modification, |
| are permitted without payment of copyright license fees provided that you |
| satisfy the following conditions: |
| |
| You must retain the complete text of this software license in redistributions of |
| the FDK AAC Codec or your modifications thereto in source code form. |
| |
| You must retain the complete text of this software license in the documentation |
| and/or other materials provided with redistributions of the FDK AAC Codec or |
| your modifications thereto in binary form. You must make available free of |
| charge copies of the complete source code of the FDK AAC Codec and your |
| modifications thereto to recipients of copies in binary form. |
| |
| The name of Fraunhofer may not be used to endorse or promote products derived |
| from this library without prior written permission. |
| |
| You may not charge copyright license fees for anyone to use, copy or distribute |
| the FDK AAC Codec software or your modifications thereto. |
| |
| Your modified versions of the FDK AAC Codec must carry prominent notices stating |
| that you changed the software and the date of any change. For modified versions |
| of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" |
| must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK |
| AAC Codec Library for Android." |
| |
| 3. NO PATENT LICENSE |
| |
| NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without |
| limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. |
| Fraunhofer provides no warranty of patent non-infringement with respect to this |
| software. |
| |
| You may use this FDK AAC Codec software or modifications thereto only for |
| purposes that are authorized by appropriate patent licenses. |
| |
| 4. DISCLAIMER |
| |
| This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright |
| holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, |
| including but not limited to the implied warranties of merchantability and |
| fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, |
| or consequential damages, including but not limited to procurement of substitute |
| goods or services; loss of use, data, or profits, or business interruption, |
| however caused and on any theory of liability, whether in contract, strict |
| liability, or tort (including negligence), arising in any way out of the use of |
| this software, even if advised of the possibility of such damage. |
| |
| 5. CONTACT INFORMATION |
| |
| Fraunhofer Institute for Integrated Circuits IIS |
| Attention: Audio and Multimedia Departments - FDK AAC LL |
| Am Wolfsmantel 33 |
| 91058 Erlangen, Germany |
| |
| www.iis.fraunhofer.de/amm |
| amm-info@iis.fraunhofer.de |
| ----------------------------------------------------------------------------- */ |
| |
| /*********************** MPEG surround encoder library ************************* |
| |
| Author(s): M. Multrus |
| |
| Description: Parameter Extraction |
| |
| *******************************************************************************/ |
| |
| /* Includes ******************************************************************/ |
| #include "sacenc_paramextract.h" |
| #include "sacenc_tree.h" |
| #include "sacenc_vectorfunctions.h" |
| |
| /* Defines *******************************************************************/ |
| #define LOG10_2_10 (3.01029995664f) /* 10.0f*log10(2.f) */ |
| #define SCALE_CLDE_SF (7) /* maxVal in Quant tab is +/- 50 */ |
| #define SCALE_CLDD_SF (8) /* maxVal in Quant tab is +/- 150 */ |
| |
| /* Data Types ****************************************************************/ |
| typedef struct T_TTO_BOX { |
| FIXP_DBL pCld__FDK[MAX_NUM_PARAM_BANDS]; |
| FIXP_DBL pIcc__FDK[MAX_NUM_PARAM_BANDS]; |
| FIXP_DBL pCldQuant__FDK[MAX_NUM_PARAM_BANDS]; |
| |
| const FIXP_DBL *pIccQuantTable__FDK; |
| const FIXP_DBL *pCldQuantTableDec__FDK; |
| const FIXP_DBL *pCldQuantTableEnc__FDK; |
| |
| SCHAR pCldEbQIdx[MAX_NUM_PARAM_BANDS]; |
| SCHAR pIccDownmixIdx[MAX_NUM_PARAM_BANDS]; |
| |
| UCHAR *pParameterBand2HybridBandOffset; |
| const INT *pSubbandImagSign; |
| UCHAR nHybridBandsMax; |
| UCHAR nParameterBands; |
| UCHAR bFrameKeep; |
| |
| UCHAR iccCorrelationCoherenceBorder; |
| BOX_QUANTMODE boxQuantMode; |
| |
| UCHAR nIccQuantSteps; |
| UCHAR nIccQuantOffset; |
| |
| UCHAR nCldQuantSteps; |
| UCHAR nCldQuantOffset; |
| |
| UCHAR bUseCoarseQuantCld; |
| UCHAR bUseCoarseQuantIcc; |
| |
| } TTO_BOX; |
| |
| struct BOX_SUBBAND_SETUP { |
| BOX_SUBBAND_CONFIG subbandConfig; |
| UCHAR nParameterBands; |
| const UCHAR *pSubband2ParameterIndexLd; |
| UCHAR iccCorrelationCoherenceBorder; |
| }; |
| |
| /* Constants *****************************************************************/ |
| static const UCHAR subband2Parameter4_Ld[NUM_QMF_BANDS] = { |
| 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
| 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}; |
| |
| static const UCHAR subband2Parameter5_Ld[NUM_QMF_BANDS] = { |
| 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
| 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, |
| 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; |
| |
| static const UCHAR subband2Parameter7_Ld[NUM_QMF_BANDS] = { |
| 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, |
| 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, |
| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6}; |
| |
| static const UCHAR subband2Parameter9_Ld[NUM_QMF_BANDS] = { |
| 0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, |
| 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, |
| 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8}; |
| |
| static const UCHAR subband2Parameter12_Ld[NUM_QMF_BANDS] = { |
| 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, |
| 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
| 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, |
| 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11}; |
| |
| static const UCHAR subband2Parameter15_Ld[NUM_QMF_BANDS] = { |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 10, 10, 11, 11, |
| 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, |
| 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, |
| 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14}; |
| |
| static const UCHAR subband2Parameter23_Ld[NUM_QMF_BANDS] = { |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 12, 13, 13, |
| 14, 14, 15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 18, 18, 19, 19, |
| 19, 19, 19, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, |
| 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22}; |
| |
| static const INT subbandImagSign_Ld[NUM_QMF_BANDS] = { |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| }; |
| |
| #define SCALE_CLDE(a) (FL2FXCONST_DBL(a / (float)(1 << SCALE_CLDE_SF))) |
| static const FIXP_DBL cldQuantTableFineEnc__FDK[MAX_CLD_QUANT_FINE] = { |
| SCALE_CLDE(-50.0), SCALE_CLDE(-45.0), SCALE_CLDE(-40.0), SCALE_CLDE(-35.0), |
| SCALE_CLDE(-30.0), SCALE_CLDE(-25.0), SCALE_CLDE(-22.0), SCALE_CLDE(-19.0), |
| SCALE_CLDE(-16.0), SCALE_CLDE(-13.0), SCALE_CLDE(-10.0), SCALE_CLDE(-8.0), |
| SCALE_CLDE(-6.0), SCALE_CLDE(-4.0), SCALE_CLDE(-2.0), SCALE_CLDE(0.0), |
| SCALE_CLDE(2.0), SCALE_CLDE(4.0), SCALE_CLDE(6.0), SCALE_CLDE(8.0), |
| SCALE_CLDE(10.0), SCALE_CLDE(13.0), SCALE_CLDE(16.0), SCALE_CLDE(19.0), |
| SCALE_CLDE(22.0), SCALE_CLDE(25.0), SCALE_CLDE(30.0), SCALE_CLDE(35.0), |
| SCALE_CLDE(40.0), SCALE_CLDE(45.0), SCALE_CLDE(50.0)}; |
| |
| static const FIXP_DBL cldQuantTableCoarseEnc__FDK[MAX_CLD_QUANT_COARSE] = { |
| SCALE_CLDE(-50.0), SCALE_CLDE(-35.0), SCALE_CLDE(-25.0), SCALE_CLDE(-19.0), |
| SCALE_CLDE(-13.0), SCALE_CLDE(-8.0), SCALE_CLDE(-4.0), SCALE_CLDE(0.0), |
| SCALE_CLDE(4.0), SCALE_CLDE(8.0), SCALE_CLDE(13.0), SCALE_CLDE(19.0), |
| SCALE_CLDE(25.0), SCALE_CLDE(35.0), SCALE_CLDE(50.0)}; |
| |
| #define SCALE_CLDD(a) (FL2FXCONST_DBL(a / (float)(1 << SCALE_CLDD_SF))) |
| static const FIXP_DBL cldQuantTableFineDec__FDK[MAX_CLD_QUANT_FINE] = { |
| SCALE_CLDD(-150.0), SCALE_CLDD(-45.0), SCALE_CLDD(-40.0), SCALE_CLDD(-35.0), |
| SCALE_CLDD(-30.0), SCALE_CLDD(-25.0), SCALE_CLDD(-22.0), SCALE_CLDD(-19.0), |
| SCALE_CLDD(-16.0), SCALE_CLDD(-13.0), SCALE_CLDD(-10.0), SCALE_CLDD(-8.0), |
| SCALE_CLDD(-6.0), SCALE_CLDD(-4.0), SCALE_CLDD(-2.0), SCALE_CLDD(0.0), |
| SCALE_CLDD(2.0), SCALE_CLDD(4.0), SCALE_CLDD(6.0), SCALE_CLDD(8.0), |
| SCALE_CLDD(10.0), SCALE_CLDD(13.0), SCALE_CLDD(16.0), SCALE_CLDD(19.0), |
| SCALE_CLDD(22.0), SCALE_CLDD(25.0), SCALE_CLDD(30.0), SCALE_CLDD(35.0), |
| SCALE_CLDD(40.0), SCALE_CLDD(45.0), SCALE_CLDD(150.0)}; |
| |
| static const FIXP_DBL cldQuantTableCoarseDec__FDK[MAX_CLD_QUANT_COARSE] = { |
| SCALE_CLDD(-150.0), SCALE_CLDD(-35.0), SCALE_CLDD(-25.0), SCALE_CLDD(-19.0), |
| SCALE_CLDD(-13.0), SCALE_CLDD(-8.0), SCALE_CLDD(-4.0), SCALE_CLDD(0.0), |
| SCALE_CLDD(4.0), SCALE_CLDD(8.0), SCALE_CLDD(13.0), SCALE_CLDD(19.0), |
| SCALE_CLDD(25.0), SCALE_CLDD(35.0), SCALE_CLDD(150.0)}; |
| |
| #define SCALE_ICC(a) (FL2FXCONST_DBL(a)) |
| static const FIXP_DBL iccQuantTableFine__FDK[MAX_ICC_QUANT_FINE] = { |
| SCALE_ICC(0.99999999953), SCALE_ICC(0.937f), SCALE_ICC(0.84118f), |
| SCALE_ICC(0.60092f), SCALE_ICC(0.36764f), SCALE_ICC(0.0f), |
| SCALE_ICC(-0.589f), SCALE_ICC(-0.99f)}; |
| |
| static const FIXP_DBL iccQuantTableCoarse__FDK[MAX_ICC_QUANT_COARSE] = { |
| SCALE_ICC(0.99999999953), SCALE_ICC(0.84118f), SCALE_ICC(0.36764f), |
| SCALE_ICC(-0.5890f)}; |
| |
| static const BOX_SUBBAND_SETUP boxSubbandSetup[] = { |
| {BOX_SUBBANDS_4, 4, subband2Parameter4_Ld, 1}, |
| {BOX_SUBBANDS_5, 5, subband2Parameter5_Ld, 2}, |
| {BOX_SUBBANDS_7, 7, subband2Parameter7_Ld, 3}, |
| {BOX_SUBBANDS_9, 9, subband2Parameter9_Ld, 4}, |
| {BOX_SUBBANDS_12, 12, subband2Parameter12_Ld, 4}, |
| {BOX_SUBBANDS_15, 15, subband2Parameter15_Ld, 5}, |
| {BOX_SUBBANDS_23, 23, subband2Parameter23_Ld, 8}}; |
| |
| /* Function / Class Declarations *********************************************/ |
| |
| /* Function / Class Definition ***********************************************/ |
| static const BOX_SUBBAND_SETUP *getBoxSubbandSetup( |
| const BOX_SUBBAND_CONFIG subbandConfig) { |
| int i; |
| const BOX_SUBBAND_SETUP *setup = NULL; |
| |
| for (i = 0; i < (int)(sizeof(boxSubbandSetup) / sizeof(BOX_SUBBAND_SETUP)); |
| i++) { |
| if (boxSubbandSetup[i].subbandConfig == subbandConfig) { |
| setup = &boxSubbandSetup[i]; |
| break; |
| } |
| } |
| return setup; |
| } |
| |
| static inline void ApplyBBCuesFDK(FIXP_DBL *const pData, |
| const INT nParamBands) { |
| int i, s; |
| FIXP_DBL tmp, invParamBands; |
| |
| invParamBands = fDivNormHighPrec((FIXP_DBL)1, (FIXP_DBL)nParamBands, &s); |
| s = -s; |
| |
| tmp = fMult(pData[0], invParamBands) >> s; |
| for (i = 1; i < nParamBands; i++) { |
| tmp += fMult(pData[i], invParamBands) >> s; |
| } |
| |
| for (i = 0; i < nParamBands; i++) { |
| pData[i] = tmp; |
| } |
| } |
| |
| static INT getNumberParameterBands(const BOX_SUBBAND_CONFIG subbandConfig) { |
| const BOX_SUBBAND_SETUP *setup = getBoxSubbandSetup(subbandConfig); |
| return ((setup == NULL) ? 0 : setup->nParameterBands); |
| } |
| |
| static const UCHAR *getSubband2ParameterIndex( |
| const BOX_SUBBAND_CONFIG subbandConfig) { |
| const BOX_SUBBAND_SETUP *setup = getBoxSubbandSetup(subbandConfig); |
| |
| return ((setup == NULL) ? NULL : (setup->pSubband2ParameterIndexLd)); |
| } |
| |
| void fdk_sacenc_calcParameterBand2HybridBandOffset( |
| const BOX_SUBBAND_CONFIG subbandConfig, const INT nHybridBands, |
| UCHAR *pParameterBand2HybridBandOffset) { |
| const BOX_SUBBAND_SETUP *setup = getBoxSubbandSetup(subbandConfig); |
| const UCHAR *pSubband2ParameterIndex; |
| |
| int i, pb; |
| |
| pSubband2ParameterIndex = setup->pSubband2ParameterIndexLd; |
| |
| for (pb = 0, i = 0; i < nHybridBands - 1; i++) { |
| if (pSubband2ParameterIndex[i + 1] - pSubband2ParameterIndex[i]) { |
| pParameterBand2HybridBandOffset[pb++] = (i + 1); |
| } |
| } |
| pParameterBand2HybridBandOffset[pb++] = (i + 1); |
| } |
| |
| const INT *fdk_sacenc_getSubbandImagSign() { |
| const INT *pImagSign = NULL; |
| |
| pImagSign = subbandImagSign_Ld; |
| |
| return (pImagSign); |
| } |
| |
| static INT getIccCorrelationCoherenceBorder( |
| const BOX_SUBBAND_CONFIG subbandConfig, const INT bUseCoherenceOnly) { |
| const BOX_SUBBAND_SETUP *setup = getBoxSubbandSetup(subbandConfig); |
| return ( |
| (setup == NULL) |
| ? 0 |
| : ((bUseCoherenceOnly) ? 0 : setup->iccCorrelationCoherenceBorder)); |
| } |
| |
| FDK_SACENC_ERROR fdk_sacenc_createTtoBox(HANDLE_TTO_BOX *hTtoBox) { |
| FDK_SACENC_ERROR error = SACENC_OK; |
| |
| if (NULL == hTtoBox) { |
| error = SACENC_INVALID_HANDLE; |
| } else { |
| FDK_ALLOCATE_MEMORY_1D(*hTtoBox, 1, TTO_BOX); |
| } |
| return error; |
| |
| bail: |
| fdk_sacenc_destroyTtoBox(hTtoBox); |
| return ((SACENC_OK == error) ? SACENC_MEMORY_ERROR : error); |
| } |
| |
| FDK_SACENC_ERROR fdk_sacenc_initTtoBox(HANDLE_TTO_BOX hTtoBox, |
| const TTO_BOX_CONFIG *const ttoBoxConfig, |
| UCHAR *pParameterBand2HybridBandOffset) { |
| FDK_SACENC_ERROR error = SACENC_OK; |
| |
| if ((hTtoBox == NULL) || (ttoBoxConfig == NULL) || |
| (pParameterBand2HybridBandOffset == NULL)) { |
| error = SACENC_INVALID_HANDLE; |
| } else { |
| FDKmemclear(hTtoBox, sizeof(TTO_BOX)); |
| |
| hTtoBox->bUseCoarseQuantCld = ttoBoxConfig->bUseCoarseQuantCld; |
| hTtoBox->bUseCoarseQuantIcc = ttoBoxConfig->bUseCoarseQuantIcc; |
| hTtoBox->boxQuantMode = ttoBoxConfig->boxQuantMode; |
| hTtoBox->iccCorrelationCoherenceBorder = getIccCorrelationCoherenceBorder( |
| ttoBoxConfig->subbandConfig, ttoBoxConfig->bUseCoherenceIccOnly); |
| hTtoBox->nHybridBandsMax = ttoBoxConfig->nHybridBandsMax; |
| hTtoBox->nParameterBands = |
| getNumberParameterBands(ttoBoxConfig->subbandConfig); |
| hTtoBox->bFrameKeep = ttoBoxConfig->bFrameKeep; |
| |
| hTtoBox->nIccQuantSteps = |
| fdk_sacenc_getNumberIccQuantLevels(hTtoBox->bUseCoarseQuantIcc); |
| hTtoBox->nIccQuantOffset = |
| fdk_sacenc_getIccQuantOffset(hTtoBox->bUseCoarseQuantIcc); |
| |
| hTtoBox->pIccQuantTable__FDK = hTtoBox->bUseCoarseQuantIcc |
| ? iccQuantTableCoarse__FDK |
| : iccQuantTableFine__FDK; |
| hTtoBox->pCldQuantTableDec__FDK = hTtoBox->bUseCoarseQuantCld |
| ? cldQuantTableCoarseDec__FDK |
| : cldQuantTableFineDec__FDK; |
| hTtoBox->pCldQuantTableEnc__FDK = hTtoBox->bUseCoarseQuantCld |
| ? cldQuantTableCoarseEnc__FDK |
| : cldQuantTableFineEnc__FDK; |
| |
| hTtoBox->nCldQuantSteps = |
| fdk_sacenc_getNumberCldQuantLevels(hTtoBox->bUseCoarseQuantCld); |
| hTtoBox->nCldQuantOffset = |
| fdk_sacenc_getCldQuantOffset(hTtoBox->bUseCoarseQuantCld); |
| |
| /* sanity */ |
| if (NULL == (hTtoBox->pParameterBand2HybridBandOffset = |
| pParameterBand2HybridBandOffset)) { |
| error = SACENC_INIT_ERROR; |
| goto bail; |
| } |
| |
| if (NULL == (hTtoBox->pSubbandImagSign = fdk_sacenc_getSubbandImagSign())) { |
| error = SACENC_INIT_ERROR; |
| } |
| |
| if ((hTtoBox->boxQuantMode != BOX_QUANTMODE_FINE) && |
| (hTtoBox->boxQuantMode != BOX_QUANTMODE_EBQ1) && |
| (hTtoBox->boxQuantMode != BOX_QUANTMODE_EBQ2)) { |
| error = SACENC_INIT_ERROR; |
| goto bail; |
| } |
| } |
| bail: |
| return error; |
| } |
| |
| FDK_SACENC_ERROR fdk_sacenc_destroyTtoBox(HANDLE_TTO_BOX *hTtoBox) { |
| FDK_SACENC_ERROR error = SACENC_OK; |
| |
| if (*hTtoBox != NULL) { |
| FDKfree(*hTtoBox); |
| *hTtoBox = NULL; |
| } |
| |
| return error; |
| } |
| |
| static FDK_SACENC_ERROR calculateIccFDK(const INT nParamBand, |
| const INT correlationCoherenceBorder, |
| const FIXP_DBL *const pPwr1, |
| const FIXP_DBL *const pPwr2, |
| const FIXP_DBL *const pProdReal, |
| FIXP_DBL const *const pProdImag, |
| FIXP_DBL *const pIcc) { |
| FDK_SACENC_ERROR error = SACENC_OK; |
| |
| if ((pPwr1 == NULL) || (pPwr2 == NULL) || (pProdReal == NULL) || |
| (pProdImag == NULL) || (pIcc == NULL)) { |
| error = SACENC_INVALID_HANDLE; |
| } else { |
| /* sanity check border */ |
| if (correlationCoherenceBorder > nParamBand) { |
| error = SACENC_INVALID_CONFIG; |
| } else { |
| /* correlation */ |
| FDKcalcCorrelationVec(pIcc, pProdReal, pPwr1, pPwr2, |
| correlationCoherenceBorder); |
| |
| /* coherence */ |
| calcCoherenceVec(&pIcc[correlationCoherenceBorder], |
| &pProdReal[correlationCoherenceBorder], |
| &pProdImag[correlationCoherenceBorder], |
| &pPwr1[correlationCoherenceBorder], |
| &pPwr2[correlationCoherenceBorder], 0, 0, |
| nParamBand - correlationCoherenceBorder); |
| |
| } /* valid configuration */ |
| } /* valid handle */ |
| |
| return error; |
| } |
| |
| static void QuantizeCoefFDK(const FIXP_DBL *const input, const INT nBands, |
| const FIXP_DBL *const quantTable, |
| const INT idxOffset, const INT nQuantSteps, |
| SCHAR *const quantOut) { |
| int band; |
| const int reverse = (quantTable[0] > quantTable[1]); |
| |
| for (band = 0; band < nBands; band++) { |
| FIXP_DBL qVal; |
| FIXP_DBL curVal = input[band]; |
| |
| int lower = 0; |
| int upper = nQuantSteps - 1; |
| |
| if (reverse) { |
| while (upper - lower > 1) { |
| int idx = (lower + upper) >> 1; |
| qVal = quantTable[idx]; |
| if (curVal >= qVal) { |
| upper = idx; |
| } else { |
| lower = idx; |
| } |
| } /* while */ |
| |
| if ((curVal - quantTable[lower]) >= (quantTable[upper] - curVal)) { |
| quantOut[band] = lower - idxOffset; |
| } else { |
| quantOut[band] = upper - idxOffset; |
| } |
| } /* if reverse */ |
| else { |
| while (upper - lower > 1) { |
| int idx = (lower + upper) >> 1; |
| qVal = quantTable[idx]; |
| if (curVal <= qVal) { |
| upper = idx; |
| } else { |
| lower = idx; |
| } |
| } /* while */ |
| |
| if ((curVal - quantTable[lower]) <= (quantTable[upper] - curVal)) { |
| quantOut[band] = lower - idxOffset; |
| } else { |
| quantOut[band] = upper - idxOffset; |
| } |
| } /* else reverse */ |
| } /* for band */ |
| } |
| |
| static void deQuantizeCoefFDK(const SCHAR *const input, const INT nBands, |
| const FIXP_DBL *const quantTable, |
| const INT idxOffset, FIXP_DBL *const dequantOut) { |
| int band; |
| |
| for (band = 0; band < nBands; band++) { |
| dequantOut[band] = quantTable[input[band] + idxOffset]; |
| } |
| } |
| |
| static void CalculateCldFDK(FIXP_DBL *const pCld, const FIXP_DBL *const pPwr1, |
| const FIXP_DBL *const pPwr2, const INT scaleCh1, |
| const INT *const pbScaleCh1, const INT scaleCh2, |
| const INT *const pbScaleCh2, const int nParamBand) { |
| INT i; |
| FIXP_DBL ldPwr1, ldPwr2, cld; |
| FIXP_DBL maxPwr = FL2FXCONST_DBL( |
| 30.0f / |
| (1 << (LD_DATA_SHIFT + |
| 1))); /* consider SACENC_FLOAT_EPSILON in power calculation */ |
| |
| for (i = 0; i < nParamBand; i++) { |
| ldPwr1 = |
| (CalcLdData(pPwr1[i]) >> 1) + ((FIXP_DBL)(scaleCh1 + pbScaleCh1[i]) |
| << (DFRACT_BITS - 1 - LD_DATA_SHIFT)); |
| ldPwr2 = |
| (CalcLdData(pPwr2[i]) >> 1) + ((FIXP_DBL)(scaleCh2 + pbScaleCh2[i]) |
| << (DFRACT_BITS - 1 - LD_DATA_SHIFT)); |
| |
| ldPwr1 = fixMax(fixMin(ldPwr1, maxPwr), -maxPwr); |
| ldPwr2 = fixMax(fixMin(ldPwr2, maxPwr), -maxPwr); |
| |
| /* ldPwr1 and ldPwr2 are scaled by LD_DATA_SHIFT and additional 1 bit; 1 bit |
| * scale by fMultDiv2() */ |
| cld = fMultDiv2(FL2FXCONST_DBL(LOG10_2_10 / (1 << SCALE_CLDE_SF)), |
| ldPwr1 - ldPwr2); |
| |
| cld = |
| fixMin(cld, (FIXP_DBL)(((FIXP_DBL)MAXVAL_DBL) >> (LD_DATA_SHIFT + 2))); |
| cld = |
| fixMax(cld, (FIXP_DBL)(((FIXP_DBL)MINVAL_DBL) >> (LD_DATA_SHIFT + 2))); |
| pCld[i] = cld << (LD_DATA_SHIFT + 2); |
| } |
| } |
| |
| FDK_SACENC_ERROR fdk_sacenc_applyTtoBox( |
| HANDLE_TTO_BOX hTtoBox, const INT nTimeSlots, const INT startTimeSlot, |
| const INT nHybridBands, const FIXP_DPK *const *const ppHybridData1__FDK, |
| const FIXP_DPK *const *const ppHybridData2__FDK, SCHAR *const pIccIdx, |
| UCHAR *const pbIccQuantCoarse, SCHAR *const pCldIdx, |
| UCHAR *const pbCldQuantCoarse, const INT bUseBBCues, INT *scaleCh1, |
| INT *scaleCh2) { |
| FDK_SACENC_ERROR error = SACENC_OK; |
| |
| C_ALLOC_SCRATCH_START(powerHybridData1__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_START(powerHybridData2__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_START(prodHybridDataReal__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_START(prodHybridDataImag__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| |
| C_ALLOC_SCRATCH_START(IccDownmix__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_START(IccDownmixQuant__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_START(pbScaleCh1, INT, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_START(pbScaleCh2, INT, MAX_NUM_PARAM_BANDS) |
| |
| if ((hTtoBox == NULL) || (pCldIdx == NULL) || (pbCldQuantCoarse == NULL) || |
| (ppHybridData1__FDK == NULL) || (ppHybridData2__FDK == NULL) || |
| (pIccIdx == NULL) || (pbIccQuantCoarse == NULL)) { |
| error = SACENC_INVALID_HANDLE; |
| } else { |
| int j, pb; |
| const int nParamBands = hTtoBox->nParameterBands; |
| const int bUseEbQ = (hTtoBox->boxQuantMode == BOX_QUANTMODE_EBQ1) || |
| (hTtoBox->boxQuantMode == BOX_QUANTMODE_EBQ2); |
| |
| /* sanity check */ |
| if ((nHybridBands < 0) || (nHybridBands > hTtoBox->nHybridBandsMax)) { |
| error = SACENC_INVALID_CONFIG; |
| goto bail; |
| } |
| |
| int outScale; /* scalefactor will not be evaluated */ |
| int inScale = 5; /* scale factor determined empirically */ |
| |
| /* calculate the headroom of the hybrid data for each parameter band */ |
| FDKcalcPbScaleFactor(ppHybridData1__FDK, |
| hTtoBox->pParameterBand2HybridBandOffset, pbScaleCh1, |
| startTimeSlot, nTimeSlots, nParamBands); |
| FDKcalcPbScaleFactor(ppHybridData2__FDK, |
| hTtoBox->pParameterBand2HybridBandOffset, pbScaleCh2, |
| startTimeSlot, nTimeSlots, nParamBands); |
| |
| for (j = 0, pb = 0; pb < nParamBands; pb++) { |
| FIXP_DBL data1, data2; |
| data1 = data2 = (FIXP_DBL)0; |
| for (; j < hTtoBox->pParameterBand2HybridBandOffset[pb]; j++) { |
| data1 += sumUpCplxPow2Dim2(ppHybridData1__FDK, SUM_UP_STATIC_SCALE, |
| inScale + pbScaleCh1[pb], &outScale, |
| startTimeSlot, nTimeSlots, j, j + 1); |
| data2 += sumUpCplxPow2Dim2(ppHybridData2__FDK, SUM_UP_STATIC_SCALE, |
| inScale + pbScaleCh2[pb], &outScale, |
| startTimeSlot, nTimeSlots, j, j + 1); |
| } /* for j */ |
| powerHybridData1__FDK[pb] = data1; |
| powerHybridData2__FDK[pb] = data2; |
| } /* pb */ |
| |
| { |
| for (j = 0, pb = 0; pb < nParamBands; pb++) { |
| FIXP_DBL dataReal, dataImag; |
| dataReal = dataImag = (FIXP_DBL)0; |
| for (; j < hTtoBox->pParameterBand2HybridBandOffset[pb]; j++) { |
| FIXP_DPK scalarProd; |
| cplx_cplxScalarProduct(&scalarProd, ppHybridData1__FDK, |
| ppHybridData2__FDK, inScale + pbScaleCh1[pb], |
| inScale + pbScaleCh2[pb], &outScale, |
| startTimeSlot, nTimeSlots, j, j + 1); |
| dataReal += scalarProd.v.re; |
| if (hTtoBox->pSubbandImagSign[j] < 0) { |
| dataImag -= scalarProd.v.im; |
| } else { |
| dataImag += scalarProd.v.im; |
| } |
| } /* for j */ |
| prodHybridDataReal__FDK[pb] = dataReal; |
| prodHybridDataImag__FDK[pb] = dataImag; |
| } /* pb */ |
| |
| if (SACENC_OK != (error = calculateIccFDK( |
| nParamBands, hTtoBox->iccCorrelationCoherenceBorder, |
| powerHybridData1__FDK, powerHybridData2__FDK, |
| prodHybridDataReal__FDK, prodHybridDataImag__FDK, |
| hTtoBox->pIcc__FDK))) { |
| goto bail; |
| } |
| |
| /* calculate correlation based Icc for downmix */ |
| if (SACENC_OK != (error = calculateIccFDK( |
| nParamBands, nParamBands, powerHybridData1__FDK, |
| powerHybridData2__FDK, prodHybridDataReal__FDK, |
| prodHybridDataImag__FDK, IccDownmix__FDK))) { |
| goto bail; |
| } |
| } |
| |
| if (!bUseEbQ) { |
| CalculateCldFDK(hTtoBox->pCld__FDK, powerHybridData1__FDK, |
| powerHybridData2__FDK, *scaleCh1 + inScale + 1, |
| pbScaleCh1, *scaleCh2 + inScale + 1, pbScaleCh2, |
| nParamBands); |
| } |
| |
| if (bUseBBCues) { |
| ApplyBBCuesFDK(&hTtoBox->pCld__FDK[0], nParamBands); |
| |
| { ApplyBBCuesFDK(&hTtoBox->pIcc__FDK[0], nParamBands); } |
| |
| } /* bUseBBCues */ |
| |
| /* quantize/de-quantize icc */ |
| { |
| QuantizeCoefFDK(hTtoBox->pIcc__FDK, nParamBands, |
| hTtoBox->pIccQuantTable__FDK, hTtoBox->nIccQuantOffset, |
| hTtoBox->nIccQuantSteps, pIccIdx); |
| QuantizeCoefFDK(IccDownmix__FDK, nParamBands, |
| hTtoBox->pIccQuantTable__FDK, hTtoBox->nIccQuantOffset, |
| hTtoBox->nIccQuantSteps, hTtoBox->pIccDownmixIdx); |
| deQuantizeCoefFDK(hTtoBox->pIccDownmixIdx, nParamBands, |
| hTtoBox->pIccQuantTable__FDK, hTtoBox->nIccQuantOffset, |
| IccDownmixQuant__FDK); |
| |
| *pbIccQuantCoarse = hTtoBox->bUseCoarseQuantIcc; |
| } |
| |
| /* quantize/de-quantize cld */ |
| if (!bUseEbQ) { |
| QuantizeCoefFDK(hTtoBox->pCld__FDK, nParamBands, |
| hTtoBox->pCldQuantTableEnc__FDK, hTtoBox->nCldQuantOffset, |
| hTtoBox->nCldQuantSteps, pCldIdx); |
| deQuantizeCoefFDK(pCldIdx, nParamBands, hTtoBox->pCldQuantTableDec__FDK, |
| hTtoBox->nCldQuantOffset, hTtoBox->pCldQuant__FDK); |
| } else { |
| FDKmemcpy(pCldIdx, hTtoBox->pCldEbQIdx, nParamBands * sizeof(SCHAR)); |
| } |
| *pbCldQuantCoarse = hTtoBox->bUseCoarseQuantCld; |
| |
| } /* valid handle */ |
| |
| bail: |
| C_ALLOC_SCRATCH_END(pbScaleCh2, INT, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_END(pbScaleCh1, INT, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_END(IccDownmixQuant__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_END(IccDownmix__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| |
| C_ALLOC_SCRATCH_END(prodHybridDataImag__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_END(prodHybridDataReal__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_END(powerHybridData2__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| C_ALLOC_SCRATCH_END(powerHybridData1__FDK, FIXP_DBL, MAX_NUM_PARAM_BANDS) |
| |
| return error; |
| } |
| |
| INT fdk_sacenc_subband2ParamBand(const BOX_SUBBAND_CONFIG boxSubbandConfig, |
| const INT nSubband) { |
| INT nParamBand = -1; |
| const UCHAR *pSubband2ParameterIndex = |
| getSubband2ParameterIndex(boxSubbandConfig); |
| |
| if (pSubband2ParameterIndex != NULL) { |
| const int hybrid_resolution = 64; |
| |
| if ((nSubband > -1) && (nSubband < hybrid_resolution)) { |
| nParamBand = pSubband2ParameterIndex[nSubband]; |
| } |
| } |
| |
| return nParamBand; |
| } |
