| /* ----------------------------------------------------------------------------- | |
| 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): Markus Lohwasser, Josef Hoepfl, Manuel Jander | |
| Description: QMF filterbank | |
| *******************************************************************************/ | |
| /*! | |
| \file | |
| \brief Complex qmf analysis/synthesis | |
| This module contains the qmf filterbank for analysis [ | |
| cplxAnalysisQmfFiltering() ] and synthesis [ cplxSynthesisQmfFiltering() ]. It | |
| is a polyphase implementation of a complex exponential modulated filter bank. | |
| The analysis part usually runs at half the sample rate than the synthesis | |
| part. (So called "dual-rate" mode.) | |
| The coefficients of the prototype filter are specified in #qmf_pfilt640 (in | |
| sbr_rom.cpp). Thus only a 64 channel version (32 on the analysis side) with a | |
| 640 tap prototype filter are used. | |
| \anchor PolyphaseFiltering <h2>About polyphase filtering</h2> | |
| The polyphase implementation of a filterbank requires filtering at the input | |
| and output. This is implemented as part of cplxAnalysisQmfFiltering() and | |
| cplxSynthesisQmfFiltering(). The implementation requires the filter | |
| coefficients in a specific structure as described in #sbr_qmf_64_640_qmf (in | |
| sbr_rom.cpp). | |
| This module comprises the computationally most expensive functions of the SBR | |
| decoder. The accuracy of computations is also important and has a direct | |
| impact on the overall sound quality. Therefore a special test program is | |
| available which can be used to only test the filterbank: main_audio.cpp | |
| This modules also uses scaling of data to provide better SNR on fixed-point | |
| processors. See #QMF_SCALE_FACTOR (in sbr_scale.h) for details. An interesting | |
| note: The function getScalefactor() can constitute a significant amount of | |
| computational complexity - very much depending on the bitrate. Since it is a | |
| rather small function, effective assembler optimization might be possible. | |
| */ | |
| #include "qmf.h" | |
| #include "FDK_trigFcts.h" | |
| #include "fixpoint_math.h" | |
| #include "dct.h" | |
| #define QSSCALE (0) | |
| #define FX_DBL2FX_QSS(x) (x) | |
| #define FX_QSS2FX_DBL(x) (x) | |
| /* moved to qmf_pcm.h: -> qmfSynPrototypeFirSlot */ | |
| /* moved to qmf_pcm.h: -> qmfSynPrototypeFirSlot_NonSymmetric */ | |
| /* moved to qmf_pcm.h: -> qmfSynthesisFilteringSlot */ | |
| /*! | |
| * | |
| * \brief Perform real-valued forward modulation of the time domain | |
| * data of timeIn and stores the real part of the subband | |
| * samples in rSubband | |
| * | |
| */ | |
| static void qmfForwardModulationLP_even( | |
| HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */ | |
| FIXP_DBL *timeIn, /*!< Time Signal */ | |
| FIXP_DBL *rSubband) /*!< Real Output */ | |
| { | |
| int i; | |
| int L = anaQmf->no_channels; | |
| int M = L >> 1; | |
| int scale = 0; | |
| FIXP_DBL accu; | |
| const FIXP_DBL *timeInTmp1 = (FIXP_DBL *)&timeIn[3 * M]; | |
| const FIXP_DBL *timeInTmp2 = timeInTmp1; | |
| FIXP_DBL *rSubbandTmp = rSubband; | |
| rSubband[0] = timeIn[3 * M] >> 1; | |
| for (i = M - 1; i != 0; i--) { | |
| accu = ((*--timeInTmp1) >> 1) + ((*++timeInTmp2) >> 1); | |
| *++rSubbandTmp = accu; | |
| } | |
| timeInTmp1 = &timeIn[2 * M]; | |
| timeInTmp2 = &timeIn[0]; | |
| rSubbandTmp = &rSubband[M]; | |
| for (i = L - M; i != 0; i--) { | |
| accu = ((*timeInTmp1--) >> 1) - ((*timeInTmp2++) >> 1); | |
| *rSubbandTmp++ = accu; | |
| } | |
| dct_III(rSubband, timeIn, L, &scale); | |
| } | |
| #if !defined(FUNCTION_qmfForwardModulationLP_odd) | |
| static void qmfForwardModulationLP_odd( | |
| HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */ | |
| const FIXP_DBL *timeIn, /*!< Time Signal */ | |
| FIXP_DBL *rSubband) /*!< Real Output */ | |
| { | |
| int i; | |
| int L = anaQmf->no_channels; | |
| int M = L >> 1; | |
| int shift = (anaQmf->no_channels >> 6) + 1; | |
| for (i = 0; i < M; i++) { | |
| rSubband[M + i] = (timeIn[L - 1 - i] >> 1) - (timeIn[i] >> shift); | |
| rSubband[M - 1 - i] = | |
| (timeIn[L + i] >> 1) + (timeIn[2 * L - 1 - i] >> shift); | |
| } | |
| dct_IV(rSubband, L, &shift); | |
| } | |
| #endif /* !defined(FUNCTION_qmfForwardModulationLP_odd) */ | |
| /*! | |
| * | |
| * \brief Perform complex-valued forward modulation of the time domain | |
| * data of timeIn and stores the real part of the subband | |
| * samples in rSubband, and the imaginary part in iSubband | |
| * | |
| * | |
| */ | |
| #if !defined(FUNCTION_qmfForwardModulationHQ) | |
| static void qmfForwardModulationHQ( | |
| HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */ | |
| const FIXP_DBL *RESTRICT timeIn, /*!< Time Signal */ | |
| FIXP_DBL *RESTRICT rSubband, /*!< Real Output */ | |
| FIXP_DBL *RESTRICT iSubband /*!< Imaginary Output */ | |
| ) { | |
| int i; | |
| int L = anaQmf->no_channels; | |
| int L2 = L << 1; | |
| int shift = 0; | |
| /* Time advance by one sample, which is equivalent to the complex | |
| rotation at the end of the analysis. Works only for STD mode. */ | |
| if ((L == 64) && !(anaQmf->flags & (QMF_FLAG_CLDFB | QMF_FLAG_MPSLDFB))) { | |
| FIXP_DBL x, y; | |
| /*rSubband[0] = u[1] + u[0]*/ | |
| /*iSubband[0] = u[1] - u[0]*/ | |
| x = timeIn[1] >> 1; | |
| y = timeIn[0]; | |
| rSubband[0] = x + (y >> 1); | |
| iSubband[0] = x - (y >> 1); | |
| /*rSubband[n] = u[n+1] - u[2M-n], n=1,...,M-1*/ | |
| /*iSubband[n] = u[n+1] + u[2M-n], n=1,...,M-1*/ | |
| for (i = 1; i < L; i++) { | |
| x = timeIn[i + 1] >> 1; /*u[n+1] */ | |
| y = timeIn[L2 - i]; /*u[2M-n] */ | |
| rSubband[i] = x - (y >> 1); | |
| iSubband[i] = x + (y >> 1); | |
| } | |
| } else { | |
| for (i = 0; i < L; i += 2) { | |
| FIXP_DBL x0, x1, y0, y1; | |
| x0 = timeIn[i + 0] >> 1; | |
| x1 = timeIn[i + 1] >> 1; | |
| y0 = timeIn[L2 - 1 - i]; | |
| y1 = timeIn[L2 - 2 - i]; | |
| rSubband[i + 0] = x0 - (y0 >> 1); | |
| rSubband[i + 1] = x1 - (y1 >> 1); | |
| iSubband[i + 0] = x0 + (y0 >> 1); | |
| iSubband[i + 1] = x1 + (y1 >> 1); | |
| } | |
| } | |
| dct_IV(rSubband, L, &shift); | |
| dst_IV(iSubband, L, &shift); | |
| /* Do the complex rotation except for the case of 64 bands (in STD mode). */ | |
| if ((L != 64) || (anaQmf->flags & (QMF_FLAG_CLDFB | QMF_FLAG_MPSLDFB))) { | |
| if (anaQmf->flags & QMF_FLAG_MPSLDFB_OPTIMIZE_MODULATION) { | |
| FIXP_DBL iBand; | |
| for (i = 0; i < fMin(anaQmf->lsb, L); i += 2) { | |
| iBand = rSubband[i]; | |
| rSubband[i] = -iSubband[i]; | |
| iSubband[i] = iBand; | |
| iBand = -rSubband[i + 1]; | |
| rSubband[i + 1] = iSubband[i + 1]; | |
| iSubband[i + 1] = iBand; | |
| } | |
| } else { | |
| const FIXP_QTW *sbr_t_cos; | |
| const FIXP_QTW *sbr_t_sin; | |
| const int len = L; /* was len = fMin(anaQmf->lsb, L) but in case of USAC | |
| the signal above lsb is actually needed in some | |
| cases (HBE?) */ | |
| sbr_t_cos = anaQmf->t_cos; | |
| sbr_t_sin = anaQmf->t_sin; | |
| for (i = 0; i < len; i++) { | |
| cplxMult(&iSubband[i], &rSubband[i], iSubband[i], rSubband[i], | |
| sbr_t_cos[i], sbr_t_sin[i]); | |
| } | |
| } | |
| } | |
| } | |
| #endif /* FUNCTION_qmfForwardModulationHQ */ | |
| /*! | |
| * | |
| * \brief Perform low power inverse modulation of the subband | |
| * samples stored in rSubband (real part) and iSubband (imaginary | |
| * part) and stores the result in pWorkBuffer. | |
| * | |
| */ | |
| inline static void qmfInverseModulationLP_even( | |
| HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */ | |
| const FIXP_DBL *qmfReal, /*!< Pointer to qmf real subband slot (input) */ | |
| const int scaleFactorLowBand, /*!< Scalefactor for Low band */ | |
| const int scaleFactorHighBand, /*!< Scalefactor for High band */ | |
| FIXP_DBL *pTimeOut /*!< Pointer to qmf subband slot (output)*/ | |
| ) { | |
| int i; | |
| int L = synQmf->no_channels; | |
| int M = L >> 1; | |
| int scale = 0; | |
| FIXP_DBL tmp; | |
| FIXP_DBL *RESTRICT tReal = pTimeOut; | |
| FIXP_DBL *RESTRICT tImag = pTimeOut + L; | |
| /* Move input to output vector with offset */ | |
| scaleValuesSaturate(&tReal[0], &qmfReal[0], synQmf->lsb, scaleFactorLowBand); | |
| scaleValuesSaturate(&tReal[0 + synQmf->lsb], &qmfReal[0 + synQmf->lsb], | |
| synQmf->usb - synQmf->lsb, scaleFactorHighBand); | |
| FDKmemclear(&tReal[0 + synQmf->usb], (L - synQmf->usb) * sizeof(FIXP_DBL)); | |
| /* Dct type-2 transform */ | |
| dct_II(tReal, tImag, L, &scale); | |
| /* Expand output and replace inplace the output buffers */ | |
| tImag[0] = tReal[M]; | |
| tImag[M] = (FIXP_DBL)0; | |
| tmp = tReal[0]; | |
| tReal[0] = tReal[M]; | |
| tReal[M] = tmp; | |
| for (i = 1; i < M / 2; i++) { | |
| /* Imag */ | |
| tmp = tReal[L - i]; | |
| tImag[M - i] = tmp; | |
| tImag[i + M] = -tmp; | |
| tmp = tReal[M + i]; | |
| tImag[i] = tmp; | |
| tImag[L - i] = -tmp; | |
| /* Real */ | |
| tReal[M + i] = tReal[i]; | |
| tReal[L - i] = tReal[M - i]; | |
| tmp = tReal[i]; | |
| tReal[i] = tReal[M - i]; | |
| tReal[M - i] = tmp; | |
| } | |
| /* Remaining odd terms */ | |
| tmp = tReal[M + M / 2]; | |
| tImag[M / 2] = tmp; | |
| tImag[M / 2 + M] = -tmp; | |
| tReal[M + M / 2] = tReal[M / 2]; | |
| } | |
| inline static void qmfInverseModulationLP_odd( | |
| HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */ | |
| const FIXP_DBL *qmfReal, /*!< Pointer to qmf real subband slot (input) */ | |
| const int scaleFactorLowBand, /*!< Scalefactor for Low band */ | |
| const int scaleFactorHighBand, /*!< Scalefactor for High band */ | |
| FIXP_DBL *pTimeOut /*!< Pointer to qmf subband slot (output)*/ | |
| ) { | |
| int i; | |
| int L = synQmf->no_channels; | |
| int M = L >> 1; | |
| int shift = 0; | |
| /* Move input to output vector with offset */ | |
| scaleValuesSaturate(pTimeOut + M, qmfReal, synQmf->lsb, scaleFactorLowBand); | |
| scaleValuesSaturate(pTimeOut + M + synQmf->lsb, qmfReal + synQmf->lsb, | |
| synQmf->usb - synQmf->lsb, scaleFactorHighBand); | |
| FDKmemclear(pTimeOut + M + synQmf->usb, (L - synQmf->usb) * sizeof(FIXP_DBL)); | |
| dct_IV(pTimeOut + M, L, &shift); | |
| for (i = 0; i < M; i++) { | |
| pTimeOut[i] = pTimeOut[L - 1 - i]; | |
| pTimeOut[2 * L - 1 - i] = -pTimeOut[L + i]; | |
| } | |
| } | |
| #ifndef FUNCTION_qmfInverseModulationHQ | |
| /*! | |
| * | |
| * \brief Perform complex-valued inverse modulation of the subband | |
| * samples stored in rSubband (real part) and iSubband (imaginary | |
| * part) and stores the result in pWorkBuffer. | |
| * | |
| */ | |
| inline static void qmfInverseModulationHQ( | |
| HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */ | |
| const FIXP_DBL *qmfReal, /*!< Pointer to qmf real subband slot */ | |
| const FIXP_DBL *qmfImag, /*!< Pointer to qmf imag subband slot */ | |
| const int scaleFactorLowBand, /*!< Scalefactor for Low band */ | |
| const int scaleFactorHighBand, /*!< Scalefactor for High band */ | |
| FIXP_DBL *pWorkBuffer /*!< WorkBuffer (output) */ | |
| ) { | |
| int i; | |
| int L = synQmf->no_channels; | |
| int M = L >> 1; | |
| int shift = 0; | |
| FIXP_DBL *RESTRICT tReal = pWorkBuffer; | |
| FIXP_DBL *RESTRICT tImag = pWorkBuffer + L; | |
| if (synQmf->flags & QMF_FLAG_CLDFB) { | |
| for (i = 0; i < synQmf->usb; i++) { | |
| cplxMultDiv2(&tImag[i], &tReal[i], qmfImag[i], qmfReal[i], | |
| synQmf->t_cos[i], synQmf->t_sin[i]); | |
| } | |
| scaleValuesSaturate(&tReal[0], synQmf->lsb, scaleFactorLowBand + 1); | |
| scaleValuesSaturate(&tReal[0 + synQmf->lsb], synQmf->usb - synQmf->lsb, | |
| scaleFactorHighBand + 1); | |
| scaleValuesSaturate(&tImag[0], synQmf->lsb, scaleFactorLowBand + 1); | |
| scaleValuesSaturate(&tImag[0 + synQmf->lsb], synQmf->usb - synQmf->lsb, | |
| scaleFactorHighBand + 1); | |
| } | |
| if ((synQmf->flags & QMF_FLAG_CLDFB) == 0) { | |
| scaleValuesSaturate(&tReal[0], &qmfReal[0], synQmf->lsb, | |
| scaleFactorLowBand); | |
| scaleValuesSaturate(&tReal[0 + synQmf->lsb], &qmfReal[0 + synQmf->lsb], | |
| synQmf->usb - synQmf->lsb, scaleFactorHighBand); | |
| scaleValuesSaturate(&tImag[0], &qmfImag[0], synQmf->lsb, | |
| scaleFactorLowBand); | |
| scaleValuesSaturate(&tImag[0 + synQmf->lsb], &qmfImag[0 + synQmf->lsb], | |
| synQmf->usb - synQmf->lsb, scaleFactorHighBand); | |
| } | |
| FDKmemclear(&tReal[synQmf->usb], | |
| (synQmf->no_channels - synQmf->usb) * sizeof(FIXP_DBL)); | |
| FDKmemclear(&tImag[synQmf->usb], | |
| (synQmf->no_channels - synQmf->usb) * sizeof(FIXP_DBL)); | |
| dct_IV(tReal, L, &shift); | |
| dst_IV(tImag, L, &shift); | |
| if (synQmf->flags & QMF_FLAG_CLDFB) { | |
| for (i = 0; i < M; i++) { | |
| FIXP_DBL r1, i1, r2, i2; | |
| r1 = tReal[i]; | |
| i2 = tImag[L - 1 - i]; | |
| r2 = tReal[L - i - 1]; | |
| i1 = tImag[i]; | |
| tReal[i] = (r1 - i1) >> 1; | |
| tImag[L - 1 - i] = -(r1 + i1) >> 1; | |
| tReal[L - i - 1] = (r2 - i2) >> 1; | |
| tImag[i] = -(r2 + i2) >> 1; | |
| } | |
| } else { | |
| /* The array accesses are negative to compensate the missing minus sign in | |
| * the low and hi band gain. */ | |
| /* 26 cycles on ARM926 */ | |
| for (i = 0; i < M; i++) { | |
| FIXP_DBL r1, i1, r2, i2; | |
| r1 = -tReal[i]; | |
| i2 = -tImag[L - 1 - i]; | |
| r2 = -tReal[L - i - 1]; | |
| i1 = -tImag[i]; | |
| tReal[i] = (r1 - i1) >> 1; | |
| tImag[L - 1 - i] = -(r1 + i1) >> 1; | |
| tReal[L - i - 1] = (r2 - i2) >> 1; | |
| tImag[i] = -(r2 + i2) >> 1; | |
| } | |
| } | |
| } | |
| #endif /* #ifndef FUNCTION_qmfInverseModulationHQ */ | |
| /*! | |
| * | |
| * \brief Create QMF filter bank instance | |
| * | |
| * \return 0 if successful | |
| * | |
| */ | |
| static int qmfInitFilterBank( | |
| HANDLE_QMF_FILTER_BANK h_Qmf, /*!< Handle to return */ | |
| void *pFilterStates, /*!< Handle to filter states */ | |
| int noCols, /*!< Number of timeslots per frame */ | |
| int lsb, /*!< Lower end of QMF frequency range */ | |
| int usb, /*!< Upper end of QMF frequency range */ | |
| int no_channels, /*!< Number of channels (bands) */ | |
| UINT flags, /*!< flags */ | |
| int synflag) /*!< 1: synthesis; 0: analysis */ | |
| { | |
| FDKmemclear(h_Qmf, sizeof(QMF_FILTER_BANK)); | |
| if (flags & QMF_FLAG_MPSLDFB) { | |
| flags |= QMF_FLAG_NONSYMMETRIC; | |
| flags |= QMF_FLAG_MPSLDFB_OPTIMIZE_MODULATION; | |
| h_Qmf->t_cos = NULL; | |
| h_Qmf->t_sin = NULL; | |
| h_Qmf->filterScale = QMF_MPSLDFB_PFT_SCALE; | |
| h_Qmf->p_stride = 1; | |
| switch (no_channels) { | |
| case 64: | |
| h_Qmf->p_filter = qmf_mpsldfb_640; | |
| h_Qmf->FilterSize = 640; | |
| break; | |
| case 32: | |
| h_Qmf->p_filter = qmf_mpsldfb_320; | |
| h_Qmf->FilterSize = 320; | |
| break; | |
| default: | |
| return -1; | |
| } | |
| } | |
| if (!(flags & QMF_FLAG_MPSLDFB) && (flags & QMF_FLAG_CLDFB)) { | |
| flags |= QMF_FLAG_NONSYMMETRIC; | |
| h_Qmf->filterScale = QMF_CLDFB_PFT_SCALE; | |
| h_Qmf->p_stride = 1; | |
| switch (no_channels) { | |
| case 64: | |
| h_Qmf->t_cos = qmf_phaseshift_cos64_cldfb; | |
| h_Qmf->t_sin = qmf_phaseshift_sin64_cldfb; | |
| h_Qmf->p_filter = qmf_cldfb_640; | |
| h_Qmf->FilterSize = 640; | |
| break; | |
| case 32: | |
| h_Qmf->t_cos = (synflag) ? qmf_phaseshift_cos32_cldfb_syn | |
| : qmf_phaseshift_cos32_cldfb_ana; | |
| h_Qmf->t_sin = qmf_phaseshift_sin32_cldfb; | |
| h_Qmf->p_filter = qmf_cldfb_320; | |
| h_Qmf->FilterSize = 320; | |
| break; | |
| case 16: | |
| h_Qmf->t_cos = (synflag) ? qmf_phaseshift_cos16_cldfb_syn | |
| : qmf_phaseshift_cos16_cldfb_ana; | |
| h_Qmf->t_sin = qmf_phaseshift_sin16_cldfb; | |
| h_Qmf->p_filter = qmf_cldfb_160; | |
| h_Qmf->FilterSize = 160; | |
| break; | |
| case 8: | |
| h_Qmf->t_cos = (synflag) ? qmf_phaseshift_cos8_cldfb_syn | |
| : qmf_phaseshift_cos8_cldfb_ana; | |
| h_Qmf->t_sin = qmf_phaseshift_sin8_cldfb; | |
| h_Qmf->p_filter = qmf_cldfb_80; | |
| h_Qmf->FilterSize = 80; | |
| break; | |
| default: | |
| return -1; | |
| } | |
| } | |
| if (!(flags & QMF_FLAG_MPSLDFB) && ((flags & QMF_FLAG_CLDFB) == 0)) { | |
| switch (no_channels) { | |
| case 64: | |
| h_Qmf->p_filter = qmf_pfilt640; | |
| h_Qmf->t_cos = qmf_phaseshift_cos64; | |
| h_Qmf->t_sin = qmf_phaseshift_sin64; | |
| h_Qmf->p_stride = 1; | |
| h_Qmf->FilterSize = 640; | |
| h_Qmf->filterScale = 0; | |
| break; | |
| case 40: | |
| if (synflag) { | |
| break; | |
| } else { | |
| h_Qmf->p_filter = qmf_pfilt400; /* Scaling factor 0.8 */ | |
| h_Qmf->t_cos = qmf_phaseshift_cos40; | |
| h_Qmf->t_sin = qmf_phaseshift_sin40; | |
| h_Qmf->filterScale = 1; | |
| h_Qmf->p_stride = 1; | |
| h_Qmf->FilterSize = no_channels * 10; | |
| } | |
| break; | |
| case 32: | |
| h_Qmf->p_filter = qmf_pfilt640; | |
| if (flags & QMF_FLAG_DOWNSAMPLED) { | |
| h_Qmf->t_cos = qmf_phaseshift_cos_downsamp32; | |
| h_Qmf->t_sin = qmf_phaseshift_sin_downsamp32; | |
| } else { | |
| h_Qmf->t_cos = qmf_phaseshift_cos32; | |
| h_Qmf->t_sin = qmf_phaseshift_sin32; | |
| } | |
| h_Qmf->p_stride = 2; | |
| h_Qmf->FilterSize = 640; | |
| h_Qmf->filterScale = 0; | |
| break; | |
| case 20: | |
| h_Qmf->p_filter = qmf_pfilt200; | |
| h_Qmf->p_stride = 1; | |
| h_Qmf->FilterSize = 200; | |
| h_Qmf->filterScale = 0; | |
| break; | |
| case 12: | |
| h_Qmf->p_filter = qmf_pfilt120; | |
| h_Qmf->p_stride = 1; | |
| h_Qmf->FilterSize = 120; | |
| h_Qmf->filterScale = 0; | |
| break; | |
| case 8: | |
| h_Qmf->p_filter = qmf_pfilt640; | |
| h_Qmf->p_stride = 8; | |
| h_Qmf->FilterSize = 640; | |
| h_Qmf->filterScale = 0; | |
| break; | |
| case 16: | |
| h_Qmf->p_filter = qmf_pfilt640; | |
| h_Qmf->t_cos = qmf_phaseshift_cos16; | |
| h_Qmf->t_sin = qmf_phaseshift_sin16; | |
| h_Qmf->p_stride = 4; | |
| h_Qmf->FilterSize = 640; | |
| h_Qmf->filterScale = 0; | |
| break; | |
| case 24: | |
| h_Qmf->p_filter = qmf_pfilt240; | |
| h_Qmf->t_cos = qmf_phaseshift_cos24; | |
| h_Qmf->t_sin = qmf_phaseshift_sin24; | |
| h_Qmf->p_stride = 1; | |
| h_Qmf->FilterSize = 240; | |
| h_Qmf->filterScale = 1; | |
| break; | |
| default: | |
| return -1; | |
| } | |
| } | |
| h_Qmf->synScalefactor = h_Qmf->filterScale; | |
| // DCT|DST dependency | |
| switch (no_channels) { | |
| case 128: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK + 1; | |
| break; | |
| case 40: { | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 1; | |
| } break; | |
| case 64: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK; | |
| break; | |
| case 8: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 3; | |
| break; | |
| case 12: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK; | |
| break; | |
| case 20: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK + 1; | |
| break; | |
| case 32: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 1; | |
| break; | |
| case 16: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 2; | |
| break; | |
| case 24: | |
| h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 1; | |
| break; | |
| default: | |
| return -1; | |
| } | |
| h_Qmf->flags = flags; | |
| h_Qmf->no_channels = no_channels; | |
| h_Qmf->no_col = noCols; | |
| h_Qmf->lsb = fMin(lsb, h_Qmf->no_channels); | |
| h_Qmf->usb = synflag | |
| ? fMin(usb, h_Qmf->no_channels) | |
| : usb; /* was: h_Qmf->usb = fMin(usb, h_Qmf->no_channels); */ | |
| h_Qmf->FilterStates = (void *)pFilterStates; | |
| h_Qmf->outScalefactor = | |
| (ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + h_Qmf->filterScale) + | |
| h_Qmf->synScalefactor; | |
| h_Qmf->outGain_m = | |
| (FIXP_DBL)0x80000000; /* default init value will be not applied */ | |
| h_Qmf->outGain_e = 0; | |
| return (0); | |
| } | |
| /*! | |
| * | |
| * \brief Adjust synthesis qmf filter states | |
| * | |
| * \return void | |
| * | |
| */ | |
| static inline void qmfAdaptFilterStates( | |
| HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Filter Bank */ | |
| int scaleFactorDiff) /*!< Scale factor difference to be applied */ | |
| { | |
| if (synQmf == NULL || synQmf->FilterStates == NULL) { | |
| return; | |
| } | |
| if (scaleFactorDiff > 0) { | |
| scaleValuesSaturate((FIXP_QSS *)synQmf->FilterStates, | |
| synQmf->no_channels * (QMF_NO_POLY * 2 - 1), | |
| scaleFactorDiff); | |
| } else { | |
| scaleValues((FIXP_QSS *)synQmf->FilterStates, | |
| synQmf->no_channels * (QMF_NO_POLY * 2 - 1), scaleFactorDiff); | |
| } | |
| } | |
| /*! | |
| * | |
| * \brief Create QMF filter bank instance | |
| * | |
| * | |
| * \return 0 if succesful | |
| * | |
| */ | |
| int qmfInitSynthesisFilterBank( | |
| HANDLE_QMF_FILTER_BANK h_Qmf, /*!< Returns handle */ | |
| FIXP_QSS *pFilterStates, /*!< Handle to filter states */ | |
| int noCols, /*!< Number of timeslots per frame */ | |
| int lsb, /*!< lower end of QMF */ | |
| int usb, /*!< upper end of QMF */ | |
| int no_channels, /*!< Number of channels (bands) */ | |
| int flags) /*!< Low Power flag */ | |
| { | |
| int oldOutScale = h_Qmf->outScalefactor; | |
| int err = qmfInitFilterBank(h_Qmf, pFilterStates, noCols, lsb, usb, | |
| no_channels, flags, 1); | |
| if (h_Qmf->FilterStates != NULL) { | |
| if (!(flags & QMF_FLAG_KEEP_STATES)) { | |
| FDKmemclear( | |
| h_Qmf->FilterStates, | |
| (2 * QMF_NO_POLY - 1) * h_Qmf->no_channels * sizeof(FIXP_QSS)); | |
| } else { | |
| qmfAdaptFilterStates(h_Qmf, oldOutScale - h_Qmf->outScalefactor); | |
| } | |
| } | |
| FDK_ASSERT(h_Qmf->no_channels >= h_Qmf->lsb); | |
| FDK_ASSERT(h_Qmf->no_channels >= h_Qmf->usb); | |
| return err; | |
| } | |
| /*! | |
| * | |
| * \brief Change scale factor for output data and adjust qmf filter states | |
| * | |
| * \return void | |
| * | |
| */ | |
| void qmfChangeOutScalefactor( | |
| HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */ | |
| int outScalefactor /*!< New scaling factor for output data */ | |
| ) { | |
| if (synQmf == NULL) { | |
| return; | |
| } | |
| /* Add internal filterbank scale */ | |
| outScalefactor += | |
| (ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + synQmf->filterScale) + | |
| synQmf->synScalefactor; | |
| /* adjust filter states when scale factor has been changed */ | |
| if (synQmf->outScalefactor != outScalefactor) { | |
| int diff; | |
| diff = synQmf->outScalefactor - outScalefactor; | |
| qmfAdaptFilterStates(synQmf, diff); | |
| /* save new scale factor */ | |
| synQmf->outScalefactor = outScalefactor; | |
| } | |
| } | |
| /*! | |
| * | |
| * \brief Get scale factor change which was set by qmfChangeOutScalefactor() | |
| * | |
| * \return scaleFactor | |
| * | |
| */ | |
| int qmfGetOutScalefactor( | |
| HANDLE_QMF_FILTER_BANK synQmf) /*!< Handle of Qmf Synthesis Bank */ | |
| { | |
| int scaleFactor = synQmf->outScalefactor | |
| ? (synQmf->outScalefactor - | |
| (ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + | |
| synQmf->filterScale + synQmf->synScalefactor)) | |
| : 0; | |
| return scaleFactor; | |
| } | |
| /*! | |
| * | |
| * \brief Change gain for output data | |
| * | |
| * \return void | |
| * | |
| */ | |
| void qmfChangeOutGain( | |
| HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */ | |
| FIXP_DBL outputGain, /*!< New gain for output data (mantissa) */ | |
| int outputGainScale /*!< New gain for output data (exponent) */ | |
| ) { | |
| synQmf->outGain_m = outputGain; | |
| synQmf->outGain_e = outputGainScale; | |
| } | |
| #define INT_PCM_QMFOUT INT_PCM | |
| #define SAMPLE_BITS_QMFOUT SAMPLE_BITS | |
| #include "qmf_pcm.h" | |
| #if SAMPLE_BITS == 16 | |
| /* also create a 32 bit output version */ | |
| #undef INT_PCM_QMFOUT | |
| #undef SAMPLE_BITS_QMFOUT | |
| #undef QMF_PCM_H | |
| #undef FIXP_QAS | |
| #undef QAS_BITS | |
| #undef INT_PCM_QMFIN | |
| #define INT_PCM_QMFOUT LONG | |
| #define SAMPLE_BITS_QMFOUT 32 | |
| #define FIXP_QAS FIXP_DBL | |
| #define QAS_BITS 32 | |
| #define INT_PCM_QMFIN LONG | |
| #include "qmf_pcm.h" | |
| #endif |