| /* ----------------------------------------------------------------------------- | |
| Software License for The Fraunhofer FDK AAC Codec Library for Android | |
| © Copyright 1995 - 2019 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 | |
| ----------------------------------------------------------------------------- */ | |
| /******************* Library for basic calculation routines ******************** | |
| Author(s): M. Gayer | |
| Description: Fixed point specific mathematical functions | |
| *******************************************************************************/ | |
| #ifndef FIXPOINT_MATH_H | |
| #define FIXPOINT_MATH_H | |
| #include "common_fix.h" | |
| #include "scale.h" | |
| /* | |
| * Data definitions | |
| */ | |
| #define LD_DATA_SCALING (64.0f) | |
| #define LD_DATA_SHIFT 6 /* pow(2, LD_DATA_SHIFT) = LD_DATA_SCALING */ | |
| #define MAX_LD_PRECISION 10 | |
| #define LD_PRECISION 10 | |
| /* Taylor series coefficients for ln(1-x), centered at 0 (MacLaurin polynomial). | |
| */ | |
| #ifndef LDCOEFF_16BIT | |
| LNK_SECTION_CONSTDATA_L1 | |
| static const FIXP_DBL ldCoeff[MAX_LD_PRECISION] = { | |
| FL2FXCONST_DBL(-1.0), FL2FXCONST_DBL(-1.0 / 2.0), | |
| FL2FXCONST_DBL(-1.0 / 3.0), FL2FXCONST_DBL(-1.0 / 4.0), | |
| FL2FXCONST_DBL(-1.0 / 5.0), FL2FXCONST_DBL(-1.0 / 6.0), | |
| FL2FXCONST_DBL(-1.0 / 7.0), FL2FXCONST_DBL(-1.0 / 8.0), | |
| FL2FXCONST_DBL(-1.0 / 9.0), FL2FXCONST_DBL(-1.0 / 10.0)}; | |
| #else /* LDCOEFF_16BIT */ | |
| LNK_SECTION_CONSTDATA_L1 | |
| static const FIXP_SGL ldCoeff[MAX_LD_PRECISION] = { | |
| FL2FXCONST_SGL(-1.0), FL2FXCONST_SGL(-1.0 / 2.0), | |
| FL2FXCONST_SGL(-1.0 / 3.0), FL2FXCONST_SGL(-1.0 / 4.0), | |
| FL2FXCONST_SGL(-1.0 / 5.0), FL2FXCONST_SGL(-1.0 / 6.0), | |
| FL2FXCONST_SGL(-1.0 / 7.0), FL2FXCONST_SGL(-1.0 / 8.0), | |
| FL2FXCONST_SGL(-1.0 / 9.0), FL2FXCONST_SGL(-1.0 / 10.0)}; | |
| #endif /* LDCOEFF_16BIT */ | |
| /***************************************************************************** | |
| functionname: invSqrtNorm2 | |
| description: delivers 1/sqrt(op) normalized to .5...1 and the shift value | |
| of the OUTPUT | |
| *****************************************************************************/ | |
| #define SQRT_BITS 7 | |
| #define SQRT_VALUES (128 + 2) | |
| #define SQRT_BITS_MASK 0x7f | |
| #define SQRT_FRACT_BITS_MASK 0x007FFFFF | |
| extern const FIXP_DBL invSqrtTab[SQRT_VALUES]; | |
| /* | |
| * Hardware specific implementations | |
| */ | |
| #if defined(__x86__) | |
| #include "x86/fixpoint_math_x86.h" | |
| #endif /* target architecture selector */ | |
| /* | |
| * Fallback implementations | |
| */ | |
| #if !defined(FUNCTION_fIsLessThan) | |
| /** | |
| * \brief Compares two fixpoint values incl. scaling. | |
| * \param a_m mantissa of the first input value. | |
| * \param a_e exponent of the first input value. | |
| * \param b_m mantissa of the second input value. | |
| * \param b_e exponent of the second input value. | |
| * \return non-zero if (a_m*2^a_e) < (b_m*2^b_e), 0 otherwise | |
| */ | |
| FDK_INLINE INT fIsLessThan(FIXP_DBL a_m, INT a_e, FIXP_DBL b_m, INT b_e) { | |
| INT n; | |
| n = fixnorm_D(a_m); | |
| a_m <<= n; | |
| a_e -= n; | |
| n = fixnorm_D(b_m); | |
| b_m <<= n; | |
| b_e -= n; | |
| if (a_m == (FIXP_DBL)0) a_e = b_e; | |
| if (b_m == (FIXP_DBL)0) b_e = a_e; | |
| if (a_e > b_e) { | |
| return ((b_m >> fMin(a_e - b_e, DFRACT_BITS - 1)) > a_m); | |
| } else { | |
| return ((a_m >> fMin(b_e - a_e, DFRACT_BITS - 1)) < b_m); | |
| } | |
| } | |
| FDK_INLINE INT fIsLessThan(FIXP_SGL a_m, INT a_e, FIXP_SGL b_m, INT b_e) { | |
| INT n; | |
| n = fixnorm_S(a_m); | |
| a_m <<= n; | |
| a_e -= n; | |
| n = fixnorm_S(b_m); | |
| b_m <<= n; | |
| b_e -= n; | |
| if (a_m == (FIXP_SGL)0) a_e = b_e; | |
| if (b_m == (FIXP_SGL)0) b_e = a_e; | |
| if (a_e > b_e) { | |
| return ((b_m >> fMin(a_e - b_e, FRACT_BITS - 1)) > a_m); | |
| } else { | |
| return ((a_m >> fMin(b_e - a_e, FRACT_BITS - 1)) < b_m); | |
| } | |
| } | |
| #endif | |
| /** | |
| * \brief deprecated. Use fLog2() instead. | |
| */ | |
| #define CalcLdData(op) fLog2(op, 0) | |
| void LdDataVector(FIXP_DBL *srcVector, FIXP_DBL *destVector, INT number); | |
| extern const UINT exp2_tab_long[32]; | |
| extern const UINT exp2w_tab_long[32]; | |
| extern const UINT exp2x_tab_long[32]; | |
| LNK_SECTION_CODE_L1 | |
| FDK_INLINE FIXP_DBL CalcInvLdData(const FIXP_DBL x) { | |
| int set_zero = (x < FL2FXCONST_DBL(-31.0 / 64.0)) ? 0 : 1; | |
| int set_max = (x >= FL2FXCONST_DBL(31.0 / 64.0)) | (x == FL2FXCONST_DBL(0.0)); | |
| FIXP_SGL frac = (FIXP_SGL)((LONG)x & 0x3FF); | |
| UINT index3 = (UINT)(LONG)(x >> 10) & 0x1F; | |
| UINT index2 = (UINT)(LONG)(x >> 15) & 0x1F; | |
| UINT index1 = (UINT)(LONG)(x >> 20) & 0x1F; | |
| int exp = fMin(31, ((x > FL2FXCONST_DBL(0.0f)) ? (31 - (int)(x >> 25)) | |
| : (int)(-(x >> 25)))); | |
| UINT lookup1 = exp2_tab_long[index1] * set_zero; | |
| UINT lookup2 = exp2w_tab_long[index2]; | |
| UINT lookup3 = exp2x_tab_long[index3]; | |
| UINT lookup3f = | |
| lookup3 + (UINT)(LONG)fMultDiv2((FIXP_DBL)(0x0016302F), (FIXP_SGL)frac); | |
| UINT lookup12 = (UINT)(LONG)fMult((FIXP_DBL)lookup1, (FIXP_DBL)lookup2); | |
| UINT lookup = (UINT)(LONG)fMult((FIXP_DBL)lookup12, (FIXP_DBL)lookup3f); | |
| FIXP_DBL retVal = (lookup << 3) >> exp; | |
| if (set_max) { | |
| retVal = (FIXP_DBL)MAXVAL_DBL; | |
| } | |
| return retVal; | |
| } | |
| void InitLdInt(); | |
| FIXP_DBL CalcLdInt(INT i); | |
| extern const USHORT sqrt_tab[49]; | |
| inline FIXP_DBL sqrtFixp_lookup(FIXP_DBL x) { | |
| UINT y = (INT)x; | |
| UCHAR is_zero = (y == 0); | |
| INT zeros = fixnormz_D(y) & 0x1e; | |
| y <<= zeros; | |
| UINT idx = (y >> 26) - 16; | |
| USHORT frac = (y >> 10) & 0xffff; | |
| USHORT nfrac = 0xffff ^ frac; | |
| UINT t = (UINT)nfrac * sqrt_tab[idx] + (UINT)frac * sqrt_tab[idx + 1]; | |
| t = t >> (zeros >> 1); | |
| return (is_zero ? 0 : t); | |
| } | |
| inline FIXP_DBL sqrtFixp_lookup(FIXP_DBL x, INT *x_e) { | |
| UINT y = (INT)x; | |
| INT e; | |
| if (x == (FIXP_DBL)0) { | |
| return x; | |
| } | |
| /* Normalize */ | |
| e = fixnormz_D(y); | |
| y <<= e; | |
| e = *x_e - e + 2; | |
| /* Correct odd exponent. */ | |
| if (e & 1) { | |
| y >>= 1; | |
| e++; | |
| } | |
| /* Get square root */ | |
| UINT idx = (y >> 26) - 16; | |
| USHORT frac = (y >> 10) & 0xffff; | |
| USHORT nfrac = 0xffff ^ frac; | |
| UINT t = (UINT)nfrac * sqrt_tab[idx] + (UINT)frac * sqrt_tab[idx + 1]; | |
| /* Write back exponent */ | |
| *x_e = e >> 1; | |
| return (FIXP_DBL)(LONG)(t >> 1); | |
| } | |
| void InitInvSqrtTab(); | |
| #ifndef FUNCTION_invSqrtNorm2 | |
| /** | |
| * \brief calculate 1.0/sqrt(op) | |
| * \param op_m mantissa of input value. | |
| * \param result_e pointer to return the exponent of the result | |
| * \return mantissa of the result | |
| */ | |
| /***************************************************************************** | |
| delivers 1/sqrt(op) normalized to .5...1 and the shift value of the OUTPUT, | |
| i.e. the denormalized result is 1/sqrt(op) = invSqrtNorm(op) * 2^(shift) | |
| uses Newton-iteration for approximation | |
| Q(n+1) = Q(n) + Q(n) * (0.5 - 2 * V * Q(n)^2) | |
| with Q = 0.5* V ^-0.5; 0.5 <= V < 1.0 | |
| *****************************************************************************/ | |
| static FDK_FORCEINLINE FIXP_DBL invSqrtNorm2(FIXP_DBL op, INT *shift) { | |
| FIXP_DBL val = op; | |
| FIXP_DBL reg1, reg2; | |
| if (val == FL2FXCONST_DBL(0.0)) { | |
| *shift = 16; | |
| return ((LONG)MAXVAL_DBL); /* maximum positive value */ | |
| } | |
| #define INVSQRTNORM2_LINEAR_INTERPOLATE | |
| #define INVSQRTNORM2_LINEAR_INTERPOLATE_HQ | |
| /* normalize input, calculate shift value */ | |
| FDK_ASSERT(val > FL2FXCONST_DBL(0.0)); | |
| *shift = fNormz(val) - 1; /* CountLeadingBits() is not necessary here since | |
| test value is always > 0 */ | |
| val <<= *shift; /* normalized input V */ | |
| *shift += 2; /* bias for exponent */ | |
| #if defined(INVSQRTNORM2_LINEAR_INTERPOLATE) | |
| INT index = | |
| (INT)(val >> (DFRACT_BITS - 1 - (SQRT_BITS + 1))) & SQRT_BITS_MASK; | |
| FIXP_DBL Fract = | |
| (FIXP_DBL)(((INT)val & SQRT_FRACT_BITS_MASK) << (SQRT_BITS + 1)); | |
| FIXP_DBL diff = invSqrtTab[index + 1] - invSqrtTab[index]; | |
| reg1 = invSqrtTab[index] + (fMultDiv2(diff, Fract) << 1); | |
| #if defined(INVSQRTNORM2_LINEAR_INTERPOLATE_HQ) | |
| /* reg1 = t[i] + (t[i+1]-t[i])*fract ... already computed ... | |
| + (1-fract)fract*(t[i+2]-t[i+1])/2 */ | |
| if (Fract != (FIXP_DBL)0) { | |
| /* fract = fract * (1 - fract) */ | |
| Fract = fMultDiv2(Fract, (FIXP_DBL)((ULONG)0x80000000 - (ULONG)Fract)) << 1; | |
| diff = diff - (invSqrtTab[index + 2] - invSqrtTab[index + 1]); | |
| reg1 = fMultAddDiv2(reg1, Fract, diff); | |
| } | |
| #endif /* INVSQRTNORM2_LINEAR_INTERPOLATE_HQ */ | |
| #else | |
| #error \ | |
| "Either define INVSQRTNORM2_NEWTON_ITERATE or INVSQRTNORM2_LINEAR_INTERPOLATE" | |
| #endif | |
| /* calculate the output exponent = input exp/2 */ | |
| if (*shift & 0x00000001) { /* odd shift values ? */ | |
| /* Note: Do not use rounded value 0x5A82799A to avoid overflow with | |
| * shift-by-2 */ | |
| reg2 = (FIXP_DBL)0x5A827999; | |
| /* FL2FXCONST_DBL(0.707106781186547524400844362104849f);*/ /* 1/sqrt(2); | |
| */ | |
| reg1 = fMultDiv2(reg1, reg2) << 2; | |
| } | |
| *shift = *shift >> 1; | |
| return (reg1); | |
| } | |
| #endif /* FUNCTION_invSqrtNorm2 */ | |
| #ifndef FUNCTION_sqrtFixp | |
| static FDK_FORCEINLINE FIXP_DBL sqrtFixp(FIXP_DBL op) { | |
| INT tmp_exp = 0; | |
| FIXP_DBL tmp_inv = invSqrtNorm2(op, &tmp_exp); | |
| FDK_ASSERT(tmp_exp > 0); | |
| return ((FIXP_DBL)(fMultDiv2((op << (tmp_exp - 1)), tmp_inv) << 2)); | |
| } | |
| #endif /* FUNCTION_sqrtFixp */ | |
| #ifndef FUNCTION_invFixp | |
| /** | |
| * \brief calculate 1.0/op | |
| * \param op mantissa of the input value. | |
| * \return mantissa of the result with implicit exponent of 31 | |
| * \exceptions are provided for op=0,1 setting max. positive value | |
| */ | |
| static inline FIXP_DBL invFixp(FIXP_DBL op) { | |
| if ((op == (FIXP_DBL)0x00000000) || (op == (FIXP_DBL)0x00000001)) { | |
| return ((LONG)MAXVAL_DBL); | |
| } | |
| INT tmp_exp; | |
| FIXP_DBL tmp_inv = invSqrtNorm2(op, &tmp_exp); | |
| FDK_ASSERT((31 - (2 * tmp_exp + 1)) >= 0); | |
| int shift = 31 - (2 * tmp_exp + 1); | |
| tmp_inv = fPow2Div2(tmp_inv); | |
| if (shift) { | |
| tmp_inv = ((tmp_inv >> (shift - 1)) + (FIXP_DBL)1) >> 1; | |
| } | |
| return tmp_inv; | |
| } | |
| /** | |
| * \brief calculate 1.0/(op_m * 2^op_e) | |
| * \param op_m mantissa of the input value. | |
| * \param op_e pointer into were the exponent of the input value is stored, and | |
| * the result will be stored into. | |
| * \return mantissa of the result | |
| */ | |
| static inline FIXP_DBL invFixp(FIXP_DBL op_m, int *op_e) { | |
| if ((op_m == (FIXP_DBL)0x00000000) || (op_m == (FIXP_DBL)0x00000001)) { | |
| *op_e = 31 - *op_e; | |
| return ((LONG)MAXVAL_DBL); | |
| } | |
| INT tmp_exp; | |
| FIXP_DBL tmp_inv = invSqrtNorm2(op_m, &tmp_exp); | |
| *op_e = (tmp_exp << 1) - *op_e + 1; | |
| return fPow2Div2(tmp_inv); | |
| } | |
| #endif /* FUNCTION_invFixp */ | |
| #ifndef FUNCTION_schur_div | |
| /** | |
| * \brief Divide two FIXP_DBL values with given precision. | |
| * \param num dividend | |
| * \param denum divisor | |
| * \param count amount of significant bits of the result (starting to the MSB) | |
| * \return num/divisor | |
| */ | |
| FIXP_DBL schur_div(FIXP_DBL num, FIXP_DBL denum, INT count); | |
| #endif /* FUNCTION_schur_div */ | |
| FIXP_DBL mul_dbl_sgl_rnd(const FIXP_DBL op1, const FIXP_SGL op2); | |
| #ifndef FUNCTION_fMultNorm | |
| /** | |
| * \brief multiply two values with normalization, thus max precision. | |
| * Author: Robert Weidner | |
| * | |
| * \param f1 first factor | |
| * \param f2 second factor | |
| * \param result_e pointer to an INT where the exponent of the result is stored | |
| * into | |
| * \return mantissa of the product f1*f2 | |
| */ | |
| FIXP_DBL fMultNorm(FIXP_DBL f1, FIXP_DBL f2, INT *result_e); | |
| /** | |
| * \brief Multiply 2 values using maximum precision. The exponent of the result | |
| * is 0. | |
| * \param f1_m mantissa of factor 1 | |
| * \param f2_m mantissa of factor 2 | |
| * \return mantissa of the result with exponent equal to 0 | |
| */ | |
| inline FIXP_DBL fMultNorm(FIXP_DBL f1, FIXP_DBL f2) { | |
| FIXP_DBL m; | |
| INT e; | |
| m = fMultNorm(f1, f2, &e); | |
| m = scaleValueSaturate(m, e); | |
| return m; | |
| } | |
| /** | |
| * \brief Multiply 2 values with exponent and use given exponent for the | |
| * mantissa of the result. | |
| * \param f1_m mantissa of factor 1 | |
| * \param f1_e exponent of factor 1 | |
| * \param f2_m mantissa of factor 2 | |
| * \param f2_e exponent of factor 2 | |
| * \param result_e exponent for the returned mantissa of the result | |
| * \return mantissa of the result with exponent equal to result_e | |
| */ | |
| inline FIXP_DBL fMultNorm(FIXP_DBL f1_m, INT f1_e, FIXP_DBL f2_m, INT f2_e, | |
| INT result_e) { | |
| FIXP_DBL m; | |
| INT e; | |
| m = fMultNorm(f1_m, f2_m, &e); | |
| m = scaleValueSaturate(m, e + f1_e + f2_e - result_e); | |
| return m; | |
| } | |
| #endif /* FUNCTION_fMultNorm */ | |
| #ifndef FUNCTION_fMultI | |
| /** | |
| * \brief Multiplies a fractional value and a integer value and performs | |
| * rounding to nearest | |
| * \param a fractional value | |
| * \param b integer value | |
| * \return integer value | |
| */ | |
| inline INT fMultI(FIXP_DBL a, INT b) { | |
| FIXP_DBL m, mi; | |
| INT m_e; | |
| m = fMultNorm(a, (FIXP_DBL)b, &m_e); | |
| if (m_e < (INT)0) { | |
| if (m_e > (INT)-DFRACT_BITS) { | |
| m = m >> ((-m_e) - 1); | |
| mi = (m + (FIXP_DBL)1) >> 1; | |
| } else { | |
| mi = (FIXP_DBL)0; | |
| } | |
| } else { | |
| mi = scaleValueSaturate(m, m_e); | |
| } | |
| return ((INT)mi); | |
| } | |
| #endif /* FUNCTION_fMultI */ | |
| #ifndef FUNCTION_fMultIfloor | |
| /** | |
| * \brief Multiplies a fractional value and a integer value and performs floor | |
| * rounding | |
| * \param a fractional value | |
| * \param b integer value | |
| * \return integer value | |
| */ | |
| inline INT fMultIfloor(FIXP_DBL a, INT b) { | |
| FIXP_DBL m, mi; | |
| INT m_e; | |
| m = fMultNorm(a, (FIXP_DBL)b, &m_e); | |
| if (m_e < (INT)0) { | |
| if (m_e > (INT)-DFRACT_BITS) { | |
| mi = m >> (-m_e); | |
| } else { | |
| mi = (FIXP_DBL)0; | |
| if (m < (FIXP_DBL)0) { | |
| mi = (FIXP_DBL)-1; | |
| } | |
| } | |
| } else { | |
| mi = scaleValueSaturate(m, m_e); | |
| } | |
| return ((INT)mi); | |
| } | |
| #endif /* FUNCTION_fMultIfloor */ | |
| #ifndef FUNCTION_fMultIceil | |
| /** | |
| * \brief Multiplies a fractional value and a integer value and performs ceil | |
| * rounding | |
| * \param a fractional value | |
| * \param b integer value | |
| * \return integer value | |
| */ | |
| inline INT fMultIceil(FIXP_DBL a, INT b) { | |
| FIXP_DBL m, mi; | |
| INT m_e; | |
| m = fMultNorm(a, (FIXP_DBL)b, &m_e); | |
| if (m_e < (INT)0) { | |
| if (m_e > (INT) - (DFRACT_BITS - 1)) { | |
| mi = (m >> (-m_e)); | |
| if ((LONG)m & ((1 << (-m_e)) - 1)) { | |
| mi = mi + (FIXP_DBL)1; | |
| } | |
| } else { | |
| if (m > (FIXP_DBL)0) { | |
| mi = (FIXP_DBL)1; | |
| } else { | |
| if ((m_e == -(DFRACT_BITS - 1)) && (m == (FIXP_DBL)MINVAL_DBL)) { | |
| mi = (FIXP_DBL)-1; | |
| } else { | |
| mi = (FIXP_DBL)0; | |
| } | |
| } | |
| } | |
| } else { | |
| mi = scaleValueSaturate(m, m_e); | |
| } | |
| return ((INT)mi); | |
| } | |
| #endif /* FUNCTION_fMultIceil */ | |
| #ifndef FUNCTION_fDivNorm | |
| /** | |
| * \brief Divide 2 FIXP_DBL values with normalization of input values. | |
| * \param num numerator | |
| * \param denum denominator | |
| * \param result_e pointer to an INT where the exponent of the result is stored | |
| * into | |
| * \return num/denum with exponent = *result_e | |
| */ | |
| FIXP_DBL fDivNorm(FIXP_DBL num, FIXP_DBL denom, INT *result_e); | |
| /** | |
| * \brief Divide 2 positive FIXP_DBL values with normalization of input values. | |
| * \param num numerator | |
| * \param denum denominator | |
| * \return num/denum with exponent = 0 | |
| */ | |
| FIXP_DBL fDivNorm(FIXP_DBL num, FIXP_DBL denom); | |
| /** | |
| * \brief Divide 2 signed FIXP_DBL values with normalization of input values. | |
| * \param num numerator | |
| * \param denum denominator | |
| * \param result_e pointer to an INT where the exponent of the result is stored | |
| * into | |
| * \return num/denum with exponent = *result_e | |
| */ | |
| FIXP_DBL fDivNormSigned(FIXP_DBL L_num, FIXP_DBL L_denum, INT *result_e); | |
| /** | |
| * \brief Divide 2 signed FIXP_DBL values with normalization of input values. | |
| * \param num numerator | |
| * \param denum denominator | |
| * \return num/denum with exponent = 0 | |
| */ | |
| FIXP_DBL fDivNormSigned(FIXP_DBL num, FIXP_DBL denom); | |
| #endif /* FUNCTION_fDivNorm */ | |
| /** | |
| * \brief Adjust mantissa to exponent -1 | |
| * \param a_m mantissa of value to be adjusted | |
| * \param pA_e pointer to the exponen of a_m | |
| * \return adjusted mantissa | |
| */ | |
| inline FIXP_DBL fAdjust(FIXP_DBL a_m, INT *pA_e) { | |
| INT shift; | |
| shift = fNorm(a_m) - 1; | |
| *pA_e -= shift; | |
| return scaleValue(a_m, shift); | |
| } | |
| #ifndef FUNCTION_fAddNorm | |
| /** | |
| * \brief Add two values with normalization | |
| * \param a_m mantissa of first summand | |
| * \param a_e exponent of first summand | |
| * \param a_m mantissa of second summand | |
| * \param a_e exponent of second summand | |
| * \param pResult_e pointer to where the exponent of the result will be stored | |
| * to. | |
| * \return mantissa of result | |
| */ | |
| inline FIXP_DBL fAddNorm(FIXP_DBL a_m, INT a_e, FIXP_DBL b_m, INT b_e, | |
| INT *pResult_e) { | |
| INT result_e; | |
| FIXP_DBL result_m; | |
| /* If one of the summands is zero, return the other. | |
| This is necessary for the summation of a very small number to zero */ | |
| if (a_m == (FIXP_DBL)0) { | |
| *pResult_e = b_e; | |
| return b_m; | |
| } | |
| if (b_m == (FIXP_DBL)0) { | |
| *pResult_e = a_e; | |
| return a_m; | |
| } | |
| a_m = fAdjust(a_m, &a_e); | |
| b_m = fAdjust(b_m, &b_e); | |
| if (a_e > b_e) { | |
| result_m = a_m + (b_m >> fMin(a_e - b_e, DFRACT_BITS - 1)); | |
| result_e = a_e; | |
| } else { | |
| result_m = (a_m >> fMin(b_e - a_e, DFRACT_BITS - 1)) + b_m; | |
| result_e = b_e; | |
| } | |
| *pResult_e = result_e; | |
| return result_m; | |
| } | |
| inline FIXP_DBL fAddNorm(FIXP_DBL a_m, INT a_e, FIXP_DBL b_m, INT b_e, | |
| INT result_e) { | |
| FIXP_DBL result_m; | |
| a_m = scaleValue(a_m, a_e - result_e); | |
| b_m = scaleValue(b_m, b_e - result_e); | |
| result_m = a_m + b_m; | |
| return result_m; | |
| } | |
| #endif /* FUNCTION_fAddNorm */ | |
| /** | |
| * \brief Divide 2 FIXP_DBL values with normalization of input values. | |
| * \param num numerator | |
| * \param denum denomintator | |
| * \return num/denum with exponent = 0 | |
| */ | |
| FIXP_DBL fDivNormHighPrec(FIXP_DBL L_num, FIXP_DBL L_denum, INT *result_e); | |
| #ifndef FUNCTION_fPow | |
| /** | |
| * \brief return 2 ^ (exp_m * 2^exp_e) | |
| * \param exp_m mantissa of the exponent to 2.0f | |
| * \param exp_e exponent of the exponent to 2.0f | |
| * \param result_e pointer to a INT where the exponent of the result will be | |
| * stored into | |
| * \return mantissa of the result | |
| */ | |
| FIXP_DBL f2Pow(const FIXP_DBL exp_m, const INT exp_e, INT *result_e); | |
| /** | |
| * \brief return 2 ^ (exp_m * 2^exp_e). This version returns only the mantissa | |
| * with implicit exponent of zero. | |
| * \param exp_m mantissa of the exponent to 2.0f | |
| * \param exp_e exponent of the exponent to 2.0f | |
| * \return mantissa of the result | |
| */ | |
| FIXP_DBL f2Pow(const FIXP_DBL exp_m, const INT exp_e); | |
| /** | |
| * \brief return x ^ (exp_m * 2^exp_e), where log2(x) = baseLd_m * 2^(baseLd_e). | |
| * This saves the need to compute log2() of constant values (when x is a | |
| * constant). | |
| * \param baseLd_m mantissa of log2() of x. | |
| * \param baseLd_e exponent of log2() of x. | |
| * \param exp_m mantissa of the exponent to 2.0f | |
| * \param exp_e exponent of the exponent to 2.0f | |
| * \param result_e pointer to a INT where the exponent of the result will be | |
| * stored into | |
| * \return mantissa of the result | |
| */ | |
| FIXP_DBL fLdPow(FIXP_DBL baseLd_m, INT baseLd_e, FIXP_DBL exp_m, INT exp_e, | |
| INT *result_e); | |
| /** | |
| * \brief return x ^ (exp_m * 2^exp_e), where log2(x) = baseLd_m * 2^(baseLd_e). | |
| * This saves the need to compute log2() of constant values (when x is a | |
| * constant). This version does not return an exponent, which is | |
| * implicitly 0. | |
| * \param baseLd_m mantissa of log2() of x. | |
| * \param baseLd_e exponent of log2() of x. | |
| * \param exp_m mantissa of the exponent to 2.0f | |
| * \param exp_e exponent of the exponent to 2.0f | |
| * \return mantissa of the result | |
| */ | |
| FIXP_DBL fLdPow(FIXP_DBL baseLd_m, INT baseLd_e, FIXP_DBL exp_m, INT exp_e); | |
| /** | |
| * \brief return (base_m * 2^base_e) ^ (exp * 2^exp_e). Use fLdPow() instead | |
| * whenever possible. | |
| * \param base_m mantissa of the base. | |
| * \param base_e exponent of the base. | |
| * \param exp_m mantissa of power to be calculated of the base. | |
| * \param exp_e exponent of power to be calculated of the base. | |
| * \param result_e pointer to a INT where the exponent of the result will be | |
| * stored into. | |
| * \return mantissa of the result. | |
| */ | |
| FIXP_DBL fPow(FIXP_DBL base_m, INT base_e, FIXP_DBL exp_m, INT exp_e, | |
| INT *result_e); | |
| /** | |
| * \brief return (base_m * 2^base_e) ^ N | |
| * \param base_m mantissa of the base. Must not be negative. | |
| * \param base_e exponent of the base | |
| * \param N power to be calculated of the base | |
| * \param result_e pointer to a INT where the exponent of the result will be | |
| * stored into | |
| * \return mantissa of the result | |
| */ | |
| FIXP_DBL fPowInt(FIXP_DBL base_m, INT base_e, INT N, INT *result_e); | |
| #endif /* #ifndef FUNCTION_fPow */ | |
| #ifndef FUNCTION_fLog2 | |
| /** | |
| * \brief Calculate log(argument)/log(2) (logarithm with base 2). deprecated. | |
| * Use fLog2() instead. | |
| * \param arg mantissa of the argument | |
| * \param arg_e exponent of the argument | |
| * \param result_e pointer to an INT to store the exponent of the result | |
| * \return the mantissa of the result. | |
| * \param | |
| */ | |
| FIXP_DBL CalcLog2(FIXP_DBL arg, INT arg_e, INT *result_e); | |
| /** | |
| * \brief calculate logarithm of base 2 of x_m * 2^(x_e) | |
| * \param x_m mantissa of the input value. | |
| * \param x_e exponent of the input value. | |
| * \param pointer to an INT where the exponent of the result is returned into. | |
| * \return mantissa of the result. | |
| */ | |
| FDK_INLINE FIXP_DBL fLog2(FIXP_DBL x_m, INT x_e, INT *result_e) { | |
| FIXP_DBL result_m; | |
| /* Short cut for zero and negative numbers. */ | |
| if (x_m <= FL2FXCONST_DBL(0.0f)) { | |
| *result_e = DFRACT_BITS - 1; | |
| return FL2FXCONST_DBL(-1.0f); | |
| } | |
| /* Calculate log2() */ | |
| { | |
| FIXP_DBL x2_m; | |
| /* Move input value x_m * 2^x_e toward 1.0, where the taylor approximation | |
| of the function log(1-x) centered at 0 is most accurate. */ | |
| { | |
| INT b_norm; | |
| b_norm = fNormz(x_m) - 1; | |
| x2_m = x_m << b_norm; | |
| x_e = x_e - b_norm; | |
| } | |
| /* map x from log(x) domain to log(1-x) domain. */ | |
| x2_m = -(x2_m + FL2FXCONST_DBL(-1.0)); | |
| /* Taylor polynomial approximation of ln(1-x) */ | |
| { | |
| FIXP_DBL px2_m; | |
| result_m = FL2FXCONST_DBL(0.0); | |
| px2_m = x2_m; | |
| for (int i = 0; i < LD_PRECISION; i++) { | |
| result_m = fMultAddDiv2(result_m, ldCoeff[i], px2_m); | |
| px2_m = fMult(px2_m, x2_m); | |
| } | |
| } | |
| /* Multiply result with 1/ln(2) = 1.0 + 0.442695040888 (get log2(x) from | |
| * ln(x) result). */ | |
| result_m = | |
| fMultAddDiv2(result_m, result_m, | |
| FL2FXCONST_DBL(2.0 * 0.4426950408889634073599246810019)); | |
| /* Add exponent part. log2(x_m * 2^x_e) = log2(x_m) + x_e */ | |
| if (x_e != 0) { | |
| int enorm; | |
| enorm = DFRACT_BITS - fNorm((FIXP_DBL)x_e); | |
| /* The -1 in the right shift of result_m compensates the fMultDiv2() above | |
| * in the taylor polynomial evaluation loop.*/ | |
| result_m = (result_m >> (enorm - 1)) + | |
| ((FIXP_DBL)x_e << (DFRACT_BITS - 1 - enorm)); | |
| *result_e = enorm; | |
| } else { | |
| /* 1 compensates the fMultDiv2() above in the taylor polynomial evaluation | |
| * loop.*/ | |
| *result_e = 1; | |
| } | |
| } | |
| return result_m; | |
| } | |
| /** | |
| * \brief calculate logarithm of base 2 of x_m * 2^(x_e) | |
| * \param x_m mantissa of the input value. | |
| * \param x_e exponent of the input value. | |
| * \return mantissa of the result with implicit exponent of LD_DATA_SHIFT. | |
| */ | |
| FDK_INLINE FIXP_DBL fLog2(FIXP_DBL x_m, INT x_e) { | |
| if (x_m <= FL2FXCONST_DBL(0.0f)) { | |
| x_m = FL2FXCONST_DBL(-1.0f); | |
| } else { | |
| INT result_e; | |
| x_m = fLog2(x_m, x_e, &result_e); | |
| x_m = scaleValue(x_m, result_e - LD_DATA_SHIFT); | |
| } | |
| return x_m; | |
| } | |
| #endif /* FUNCTION_fLog2 */ | |
| #ifndef FUNCTION_fAddSaturate | |
| /** | |
| * \brief Add with saturation of the result. | |
| * \param a first summand | |
| * \param b second summand | |
| * \return saturated sum of a and b. | |
| */ | |
| inline FIXP_SGL fAddSaturate(const FIXP_SGL a, const FIXP_SGL b) { | |
| LONG sum; | |
| sum = (LONG)(SHORT)a + (LONG)(SHORT)b; | |
| sum = fMax(fMin((INT)sum, (INT)MAXVAL_SGL), (INT)MINVAL_SGL); | |
| return (FIXP_SGL)(SHORT)sum; | |
| } | |
| /** | |
| * \brief Add with saturation of the result. | |
| * \param a first summand | |
| * \param b second summand | |
| * \return saturated sum of a and b. | |
| */ | |
| inline FIXP_DBL fAddSaturate(const FIXP_DBL a, const FIXP_DBL b) { | |
| LONG sum; | |
| sum = (LONG)(a >> 1) + (LONG)(b >> 1); | |
| sum = fMax(fMin((INT)sum, (INT)(MAXVAL_DBL >> 1)), (INT)(MINVAL_DBL >> 1)); | |
| return (FIXP_DBL)(LONG)(sum << 1); | |
| } | |
| #endif /* FUNCTION_fAddSaturate */ | |
| INT fixp_floorToInt(FIXP_DBL f_inp, INT sf); | |
| FIXP_DBL fixp_floor(FIXP_DBL f_inp, INT sf); | |
| INT fixp_ceilToInt(FIXP_DBL f_inp, INT sf); | |
| FIXP_DBL fixp_ceil(FIXP_DBL f_inp, INT sf); | |
| INT fixp_truncateToInt(FIXP_DBL f_inp, INT sf); | |
| FIXP_DBL fixp_truncate(FIXP_DBL f_inp, INT sf); | |
| INT fixp_roundToInt(FIXP_DBL f_inp, INT sf); | |
| FIXP_DBL fixp_round(FIXP_DBL f_inp, INT sf); | |
| /***************************************************************************** | |
| array for 1/n, n=1..80 | |
| ****************************************************************************/ | |
| extern const FIXP_DBL invCount[80]; | |
| LNK_SECTION_INITCODE | |
| inline void InitInvInt(void) {} | |
| /** | |
| * \brief Calculate the value of 1/i where i is a integer value. It supports | |
| * input values from 1 upto (80-1). | |
| * \param intValue Integer input value. | |
| * \param FIXP_DBL representation of 1/intValue | |
| */ | |
| inline FIXP_DBL GetInvInt(int intValue) { | |
| return invCount[fMin(fMax(intValue, 0), 80 - 1)]; | |
| } | |
| #endif /* FIXPOINT_MATH_H */ |