| |
| /* ----------------------------------------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2013 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 |
| ----------------------------------------------------------------------------------------------------------- */ |
| |
| /******************************** Fraunhofer IIS *************************** |
| |
| 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 #sbr_qmf_64_640 (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 "fixpoint_math.h" |
| #include "dct.h" |
| |
| #ifdef QMFSYN_STATES_16BIT |
| #define QSSCALE (7) |
| #define FX_DBL2FX_QSS(x) ((FIXP_QSS) ((x)>>(DFRACT_BITS-QSS_BITS-QSSCALE) )) |
| #define FX_QSS2FX_DBL(x) ((FIXP_DBL)((LONG)x)<<(DFRACT_BITS-QSS_BITS-QSSCALE)) |
| #else |
| #define QSSCALE (0) |
| #define FX_DBL2FX_QSS(x) (x) |
| #define FX_QSS2FX_DBL(x) (x) |
| #endif |
| |
| |
| #if defined(__arm__) |
| #include "arm/qmf_arm.cpp" |
| |
| #endif |
| |
| /*! |
| * \brief Algorithmic scaling in sbrForwardModulation() |
| * |
| * The scaling in sbrForwardModulation() is caused by: |
| * |
| * \li 1 R_SHIFT in sbrForwardModulation() |
| * \li 5/6 R_SHIFT in dct3() if using 32/64 Bands |
| * \li 1 ommited gain of 2.0 in qmfForwardModulation() |
| */ |
| #define ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK 7 |
| |
| /*! |
| * \brief Algorithmic scaling in cplxSynthesisQmfFiltering() |
| * |
| * The scaling in cplxSynthesisQmfFiltering() is caused by: |
| * |
| * \li 5/6 R_SHIFT in dct2() if using 32/64 Bands |
| * \li 1 ommited gain of 2.0 in qmfInverseModulation() |
| * \li -6 division by 64 in synthesis filterbank |
| * \li x bits external influence |
| */ |
| #define ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK 1 |
| |
| |
| /*! |
| \brief Perform Synthesis Prototype Filtering on a single slot of input data. |
| |
| The filter takes 2 * qmf->no_channels of input data and |
| generates qmf->no_channels time domain output samples. |
| */ |
| static |
| #ifndef FUNCTION_qmfSynPrototypeFirSlot |
| void qmfSynPrototypeFirSlot( |
| #else |
| void qmfSynPrototypeFirSlot_fallback( |
| #endif |
| HANDLE_QMF_FILTER_BANK qmf, |
| FIXP_QMF *RESTRICT realSlot, /*!< Input: Pointer to real Slot */ |
| FIXP_QMF *RESTRICT imagSlot, /*!< Input: Pointer to imag Slot */ |
| INT_PCM *RESTRICT timeOut, /*!< Time domain data */ |
| int stride |
| ) |
| { |
| FIXP_QSS* FilterStates = (FIXP_QSS*)qmf->FilterStates; |
| int no_channels = qmf->no_channels; |
| const FIXP_PFT *p_Filter = qmf->p_filter; |
| int p_stride = qmf->p_stride; |
| int j; |
| FIXP_QSS *RESTRICT sta = FilterStates; |
| const FIXP_PFT *RESTRICT p_flt, *RESTRICT p_fltm; |
| int scale = ((DFRACT_BITS-SAMPLE_BITS)-1-qmf->outScalefactor); |
| |
| p_flt = p_Filter+p_stride*QMF_NO_POLY; /* 5-ter von 330 */ |
| p_fltm = p_Filter+(qmf->FilterSize/2)-p_stride*QMF_NO_POLY; /* 5 + (320 - 2*5) = 315-ter von 330 */ |
| |
| FDK_ASSERT(SAMPLE_BITS-1-qmf->outScalefactor >= 0); // (DFRACT_BITS-SAMPLE_BITS)-1-qmf->outScalefactor >= 0); |
| |
| for (j = no_channels-1; j >= 0; j--) { /* ---- läuft ueber alle Linien eines Slots ---- */ |
| FIXP_QMF imag = imagSlot[j]; // no_channels-1 .. 0 |
| FIXP_QMF real = realSlot[j]; // ~~"~~ |
| { |
| INT_PCM tmp; |
| FIXP_DBL Are = FX_QSS2FX_DBL(sta[0]) + fMultDiv2( p_fltm[0] , real); |
| |
| if (qmf->outGain!=(FIXP_DBL)0x80000000) { |
| Are = fMult(Are,qmf->outGain); |
| } |
| |
| #if SAMPLE_BITS > 16 |
| tmp = (INT_PCM)(SATURATE_SHIFT(fAbs(Are), scale, SAMPLE_BITS)); |
| #else |
| tmp = (INT_PCM)(SATURATE_RIGHT_SHIFT(fAbs(Are), scale, SAMPLE_BITS)); |
| #endif |
| if (Are < (FIXP_QMF)0) { |
| tmp = -tmp; |
| } |
| timeOut[ (j)*stride ] = tmp; |
| } |
| |
| sta[0] = sta[1] + FX_DBL2FX_QSS(fMultDiv2( p_flt [4] , imag )); |
| sta[1] = sta[2] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[1] , real )); |
| sta[2] = sta[3] + FX_DBL2FX_QSS(fMultDiv2( p_flt [3] , imag )); |
| sta[3] = sta[4] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[2] , real )); |
| sta[4] = sta[5] + FX_DBL2FX_QSS(fMultDiv2( p_flt [2] , imag )); |
| sta[5] = sta[6] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[3] , real )); |
| sta[6] = sta[7] + FX_DBL2FX_QSS(fMultDiv2( p_flt [1] , imag )); |
| sta[7] = sta[8] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[4] , real )); |
| sta[8] = FX_DBL2FX_QSS(fMultDiv2( p_flt [0] , imag )); |
| |
| p_flt += (p_stride*QMF_NO_POLY); |
| p_fltm -= (p_stride*QMF_NO_POLY); |
| sta += 9; // = (2*QMF_NO_POLY-1); |
| } |
| } |
| |
| #ifndef FUNCTION_qmfSynPrototypeFirSlot_NonSymmetric |
| /*! |
| \brief Perform Synthesis Prototype Filtering on a single slot of input data. |
| |
| The filter takes 2 * qmf->no_channels of input data and |
| generates qmf->no_channels time domain output samples. |
| */ |
| static |
| void qmfSynPrototypeFirSlot_NonSymmetric( |
| HANDLE_QMF_FILTER_BANK qmf, |
| FIXP_QMF *RESTRICT realSlot, /*!< Input: Pointer to real Slot */ |
| FIXP_QMF *RESTRICT imagSlot, /*!< Input: Pointer to imag Slot */ |
| INT_PCM *RESTRICT timeOut, /*!< Time domain data */ |
| int stride |
| ) |
| { |
| FIXP_QSS* FilterStates = (FIXP_QSS*)qmf->FilterStates; |
| int no_channels = qmf->no_channels; |
| const FIXP_PFT *p_Filter = qmf->p_filter; |
| int p_stride = qmf->p_stride; |
| int j; |
| FIXP_QSS *RESTRICT sta = FilterStates; |
| const FIXP_PFT *RESTRICT p_flt, *RESTRICT p_fltm; |
| int scale = ((DFRACT_BITS-SAMPLE_BITS)-1-qmf->outScalefactor); |
| |
| p_flt = p_Filter; /*!< Pointer to first half of filter coefficients */ |
| p_fltm = &p_flt[qmf->FilterSize/2]; /* at index 320, overall 640 coefficients */ |
| |
| FDK_ASSERT(SAMPLE_BITS-1-qmf->outScalefactor >= 0); // (DFRACT_BITS-SAMPLE_BITS)-1-qmf->outScalefactor >= 0); |
| |
| for (j = no_channels-1; j >= 0; j--) { /* ---- läuft ueber alle Linien eines Slots ---- */ |
| |
| FIXP_QMF imag = imagSlot[j]; // no_channels-1 .. 0 |
| FIXP_QMF real = realSlot[j]; // ~~"~~ |
| { |
| INT_PCM tmp; |
| FIXP_QMF Are = sta[0] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[4] , real )); |
| |
| #if SAMPLE_BITS > 16 |
| tmp = (INT_PCM)(SATURATE_SHIFT(fAbs(Are), scale, SAMPLE_BITS)); |
| #else |
| tmp = (INT_PCM)(SATURATE_RIGHT_SHIFT(fAbs(Are), scale, SAMPLE_BITS)); |
| #endif |
| if (Are < (FIXP_QMF)0) { |
| tmp = -tmp; |
| } |
| timeOut[j*stride] = tmp; |
| } |
| |
| sta[0] = sta[1] + FX_DBL2FX_QSS(fMultDiv2( p_flt [4] , imag )); |
| sta[1] = sta[2] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[3] , real )); |
| sta[2] = sta[3] + FX_DBL2FX_QSS(fMultDiv2( p_flt [3] , imag )); |
| |
| sta[3] = sta[4] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[2] , real )); |
| sta[4] = sta[5] + FX_DBL2FX_QSS(fMultDiv2( p_flt [2] , imag )); |
| sta[5] = sta[6] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[1] , real )); |
| sta[6] = sta[7] + FX_DBL2FX_QSS(fMultDiv2( p_flt [1] , imag )); |
| |
| sta[7] = sta[8] + FX_DBL2FX_QSS(fMultDiv2( p_fltm[0] , real )); |
| sta[8] = FX_DBL2FX_QSS(fMultDiv2( p_flt [0] , imag )); |
| |
| p_flt += (p_stride*QMF_NO_POLY); |
| p_fltm += (p_stride*QMF_NO_POLY); |
| sta += 9; // = (2*QMF_NO_POLY-1); |
| } |
| |
| } |
| #endif /* FUNCTION_qmfSynPrototypeFirSlot_NonSymmetric */ |
| |
| #ifndef FUNCTION_qmfAnaPrototypeFirSlot |
| /*! |
| \brief Perform Analysis Prototype Filtering on a single slot of input data. |
| */ |
| static |
| void qmfAnaPrototypeFirSlot( FIXP_QMF *analysisBuffer, |
| int no_channels, /*!< Number channels of analysis filter */ |
| const FIXP_PFT *p_filter, |
| int p_stride, /*!< Stide of analysis filter */ |
| FIXP_QAS *RESTRICT pFilterStates |
| ) |
| { |
| int k; |
| |
| FIXP_DBL accu; |
| const FIXP_PFT *RESTRICT p_flt = p_filter; |
| FIXP_QMF *RESTRICT pData_0 = analysisBuffer + 2*no_channels - 1; |
| FIXP_QMF *RESTRICT pData_1 = analysisBuffer; |
| |
| FIXP_QAS *RESTRICT sta_0 = (FIXP_QAS *)pFilterStates; |
| FIXP_QAS *RESTRICT sta_1 = (FIXP_QAS *)pFilterStates + (2*QMF_NO_POLY*no_channels) - 1; |
| int pfltStep = QMF_NO_POLY * (p_stride); |
| int staStep1 = no_channels<<1; |
| int staStep2 = (no_channels<<3) - 1; /* Rewind one less */ |
| |
| /* FIR filter 0 */ |
| accu = fMultDiv2( p_flt[0], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[1], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[2], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[3], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[4], *sta_1); |
| *pData_1++ = FX_DBL2FX_QMF(accu<<1); |
| sta_1 += staStep2; |
| |
| p_flt += pfltStep; |
| |
| /* FIR filters 1..63 127..65 */ |
| for (k=0; k<no_channels-1; k++) |
| { |
| accu = fMultDiv2( p_flt[0], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[1], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[2], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[3], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[4], *sta_0); |
| *pData_0-- = FX_DBL2FX_QMF(accu<<1); |
| sta_0 -= staStep2; |
| |
| accu = fMultDiv2( p_flt[0], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[1], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[2], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[3], *sta_1); sta_1 -= staStep1; |
| accu += fMultDiv2( p_flt[4], *sta_1); |
| *pData_1++ = FX_DBL2FX_QMF(accu<<1); |
| sta_1 += staStep2; |
| |
| p_flt += pfltStep; |
| } |
| |
| /* FIR filter 64 */ |
| accu = fMultDiv2( p_flt[0], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[1], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[2], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[3], *sta_0); sta_0 += staStep1; |
| accu += fMultDiv2( p_flt[4], *sta_0); |
| *pData_0-- = FX_DBL2FX_QMF(accu<<1); |
| sta_0 -= staStep2; |
| } |
| #endif /* !defined(FUNCTION_qmfAnaPrototypeFirSlot) */ |
| |
| |
| #ifndef FUNCTION_qmfAnaPrototypeFirSlot_NonSymmetric |
| /*! |
| \brief Perform Analysis Prototype Filtering on a single slot of input data. |
| */ |
| static |
| void qmfAnaPrototypeFirSlot_NonSymmetric( |
| FIXP_QMF *analysisBuffer, |
| int no_channels, /*!< Number channels of analysis filter */ |
| const FIXP_PFT *p_filter, |
| int p_stride, /*!< Stide of analysis filter */ |
| FIXP_QAS *RESTRICT pFilterStates |
| ) |
| { |
| const FIXP_PFT *RESTRICT p_flt = p_filter; |
| int p, k; |
| |
| for (k = 0; k < 2*no_channels; k++) |
| { |
| FIXP_DBL accu = (FIXP_DBL)0; |
| |
| p_flt += QMF_NO_POLY * (p_stride - 1); |
| |
| /* |
| Perform FIR-Filter |
| */ |
| for (p = 0; p < QMF_NO_POLY; p++) { |
| accu += fMultDiv2(*p_flt++, pFilterStates[2*no_channels * p]); |
| } |
| analysisBuffer[2*no_channels - 1 - k] = FX_DBL2FX_QMF(accu<<1); |
| pFilterStates++; |
| } |
| } |
| #endif /* FUNCTION_qmfAnaPrototypeFirSlot_NonSymmetric */ |
| |
| /*! |
| * |
| * \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_QMF *timeIn, /*!< Time Signal */ |
| FIXP_QMF *rSubband ) /*!< Real Output */ |
| { |
| int i; |
| int L = anaQmf->no_channels; |
| int M = L>>1; |
| int scale; |
| FIXP_QMF accu; |
| |
| const FIXP_QMF *timeInTmp1 = (FIXP_QMF *) &timeIn[3 * M]; |
| const FIXP_QMF *timeInTmp2 = timeInTmp1; |
| FIXP_QMF *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_QMF *timeIn, /*!< Time Signal */ |
| FIXP_QMF *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 |
| * |
| * Only the lower bands are obtained (upto anaQmf->lsb). For |
| * a full bandwidth analysis it is required to set both anaQmf->lsb |
| * and anaQmf->usb to the amount of QMF bands. |
| * |
| */ |
| static void |
| qmfForwardModulationHQ( HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */ |
| const FIXP_QMF *RESTRICT timeIn, /*!< Time Signal */ |
| FIXP_QMF *RESTRICT rSubband, /*!< Real Output */ |
| FIXP_QMF *RESTRICT iSubband /*!< Imaginary Output */ |
| ) |
| { |
| int i; |
| int L = anaQmf->no_channels; |
| int L2 = L<<1; |
| int shift = 0; |
| |
| for (i = 0; i < L; i+=2) { |
| FIXP_QMF x0, x1, y0, y1; |
| |
| x0 = timeIn[i] >> 1; |
| x1 = timeIn[i+1] >> 1; |
| y0 = timeIn[L2 - 1 - i] >> 1; |
| y1 = timeIn[L2 - 2 - i] >> 1; |
| |
| rSubband[i] = x0 - y0; |
| rSubband[i+1] = x1 - y1; |
| iSubband[i] = x0 + y0; |
| iSubband[i+1] = x1 + y1; |
| } |
| |
| dct_IV(rSubband, L, &shift); |
| dst_IV(iSubband, L, &shift); |
| |
| { |
| { |
| const FIXP_QTW *RESTRICT sbr_t_cos; |
| const FIXP_QTW *RESTRICT sbr_t_sin; |
| sbr_t_cos = anaQmf->t_cos; |
| sbr_t_sin = anaQmf->t_sin; |
| |
| for (i = 0; i < anaQmf->lsb; i++) { |
| cplxMult(&iSubband[i], &rSubband[i], iSubband[i], rSubband[i], sbr_t_cos[i], sbr_t_sin[i]); |
| } |
| } |
| } |
| } |
| |
| /* |
| * \brief Perform one QMF slot analysis of the time domain data of timeIn |
| * with specified stride and stores the real part of the subband |
| * samples in rSubband, and the imaginary part in iSubband |
| * |
| * Only the lower bands are obtained (upto anaQmf->lsb). For |
| * a full bandwidth analysis it is required to set both anaQmf->lsb |
| * and anaQmf->usb to the amount of QMF bands. |
| */ |
| void |
| qmfAnalysisFilteringSlot( HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Synthesis Bank */ |
| FIXP_QMF *qmfReal, /*!< Low and High band, real */ |
| FIXP_QMF *qmfImag, /*!< Low and High band, imag */ |
| const INT_PCM *RESTRICT timeIn, /*!< Pointer to input */ |
| const int stride, /*!< stride factor of input */ |
| FIXP_QMF *pWorkBuffer /*!< pointer to temporal working buffer */ |
| ) |
| { |
| int i; |
| int offset = anaQmf->no_channels*(QMF_NO_POLY*2-1); |
| /* |
| Feed time signal into oldest anaQmf->no_channels states |
| */ |
| { |
| FIXP_QAS *RESTRICT FilterStatesAnaTmp = ((FIXP_QAS*)anaQmf->FilterStates)+offset; |
| |
| /* Feed and scale actual time in slot */ |
| for(i=anaQmf->no_channels>>1; i!=0; i--) { |
| /* Place INT_PCM value left aligned in scaledTimeIn */ |
| #if (QAS_BITS==SAMPLE_BITS) |
| *FilterStatesAnaTmp++ = (FIXP_QAS)*timeIn; timeIn += stride; |
| *FilterStatesAnaTmp++ = (FIXP_QAS)*timeIn; timeIn += stride; |
| #elif (QAS_BITS>SAMPLE_BITS) |
| *FilterStatesAnaTmp++ = (FIXP_QAS)((*timeIn)<<(QAS_BITS-SAMPLE_BITS)); timeIn += stride; |
| *FilterStatesAnaTmp++ = (FIXP_QAS)((*timeIn)<<(QAS_BITS-SAMPLE_BITS)); timeIn += stride; |
| #else |
| *FilterStatesAnaTmp++ = (FIXP_QAS)((*timeIn)>>(SAMPLE_BITS-QAS_BITS)); timeIn += stride; |
| *FilterStatesAnaTmp++ = (FIXP_QAS)((*timeIn)>>(SAMPLE_BITS-QAS_BITS)); timeIn += stride; |
| #endif |
| } |
| } |
| |
| if (anaQmf->flags & QMF_FLAG_NONSYMMETRIC) { |
| qmfAnaPrototypeFirSlot_NonSymmetric( |
| pWorkBuffer, |
| anaQmf->no_channels, |
| anaQmf->p_filter, |
| anaQmf->p_stride, |
| (FIXP_QAS*)anaQmf->FilterStates |
| ); |
| } else { |
| qmfAnaPrototypeFirSlot( pWorkBuffer, |
| anaQmf->no_channels, |
| anaQmf->p_filter, |
| anaQmf->p_stride, |
| (FIXP_QAS*)anaQmf->FilterStates |
| ); |
| } |
| |
| if (anaQmf->flags & QMF_FLAG_LP) { |
| if (anaQmf->flags & QMF_FLAG_CLDFB) |
| qmfForwardModulationLP_odd( anaQmf, |
| pWorkBuffer, |
| qmfReal ); |
| else |
| qmfForwardModulationLP_even( anaQmf, |
| pWorkBuffer, |
| qmfReal ); |
| |
| } else { |
| qmfForwardModulationHQ( anaQmf, |
| pWorkBuffer, |
| qmfReal, |
| qmfImag |
| ); |
| } |
| /* |
| Shift filter states |
| |
| Should be realized with modulo adressing on a DSP instead of a true buffer shift |
| */ |
| FDKmemmove ((FIXP_QAS*)anaQmf->FilterStates, (FIXP_QAS*)anaQmf->FilterStates+anaQmf->no_channels, offset*sizeof(FIXP_QAS)); |
| } |
| |
| |
| /*! |
| * |
| * \brief Perform complex-valued subband filtering of the time domain |
| * data of timeIn and stores the real part of the subband |
| * samples in rAnalysis, and the imaginary part in iAnalysis |
| * The qmf coefficient table is symmetric. The symmetry is expoited by |
| * shrinking the coefficient table to half the size. The addressing mode |
| * takes care of the symmetries. |
| * |
| * Only the lower bands are obtained (upto anaQmf->lsb). For |
| * a full bandwidth analysis it is required to set both anaQmf->lsb |
| * and anaQmf->usb to the amount of QMF bands. |
| * |
| * \sa PolyphaseFiltering |
| */ |
| |
| void |
| qmfAnalysisFiltering( HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */ |
| FIXP_QMF **qmfReal, /*!< Pointer to real subband slots */ |
| FIXP_QMF **qmfImag, /*!< Pointer to imag subband slots */ |
| QMF_SCALE_FACTOR *scaleFactor, |
| const INT_PCM *timeIn, /*!< Time signal */ |
| const int stride, |
| FIXP_QMF *pWorkBuffer /*!< pointer to temporal working buffer */ |
| ) |
| { |
| int i; |
| int no_channels = anaQmf->no_channels; |
| |
| scaleFactor->lb_scale = -ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK; |
| scaleFactor->lb_scale -= anaQmf->filterScale; |
| |
| for (i = 0; i < anaQmf->no_col; i++) |
| { |
| FIXP_QMF *qmfImagSlot = NULL; |
| |
| if (!(anaQmf->flags & QMF_FLAG_LP)) { |
| qmfImagSlot = qmfImag[i]; |
| } |
| |
| qmfAnalysisFilteringSlot( anaQmf, qmfReal[i], qmfImagSlot, timeIn , stride, pWorkBuffer ); |
| |
| timeIn += no_channels*stride; |
| |
| } /* no_col loop i */ |
| } |
| |
| /*! |
| * |
| * \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_QMF *qmfReal, /*!< Pointer to qmf real subband slot (input) */ |
| const int scaleFactorLowBand, /*!< Scalefactor for Low band */ |
| const int scaleFactorHighBand, /*!< Scalefactor for High band */ |
| FIXP_QMF *pTimeOut /*!< Pointer to qmf subband slot (output)*/ |
| ) |
| { |
| int i; |
| int L = synQmf->no_channels; |
| int M = L>>1; |
| int scale; |
| FIXP_QMF tmp; |
| FIXP_QMF *RESTRICT tReal = pTimeOut; |
| FIXP_QMF *RESTRICT tImag = pTimeOut + L; |
| |
| /* Move input to output vector with offset */ |
| scaleValues(&tReal[0], &qmfReal[0], synQmf->lsb, scaleFactorLowBand); |
| scaleValues(&tReal[0+synQmf->lsb], &qmfReal[0+synQmf->lsb], synQmf->usb-synQmf->lsb, scaleFactorHighBand); |
| FDKmemclear(&tReal[0+synQmf->usb], (L-synQmf->usb)*sizeof(FIXP_QMF)); |
| |
| /* 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_QMF)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_QMF *qmfReal, /*!< Pointer to qmf real subband slot (input) */ |
| const int scaleFactorLowBand, /*!< Scalefactor for Low band */ |
| const int scaleFactorHighBand, /*!< Scalefactor for High band */ |
| FIXP_QMF *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 */ |
| scaleValues(pTimeOut+M, qmfReal, synQmf->lsb, scaleFactorLowBand); |
| scaleValues(pTimeOut+M+synQmf->lsb, qmfReal+synQmf->lsb, synQmf->usb-synQmf->lsb, scaleFactorHighBand); |
| FDKmemclear(pTimeOut+M+synQmf->usb, (L-synQmf->usb)*sizeof(FIXP_QMF)); |
| |
| 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]; |
| } |
| } |
| |
| |
| /*! |
| * |
| * \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_QMF *qmfReal, /*!< Pointer to qmf real subband slot */ |
| const FIXP_QMF *qmfImag, /*!< Pointer to qmf imag subband slot */ |
| const int scaleFactorLowBand, /*!< Scalefactor for Low band */ |
| const int scaleFactorHighBand,/*!< Scalefactor for High band */ |
| FIXP_QMF *pWorkBuffer /*!< WorkBuffer (output) */ |
| ) |
| { |
| int i; |
| int L = synQmf->no_channels; |
| int M = L>>1; |
| int shift = 0; |
| FIXP_QMF *RESTRICT tReal = pWorkBuffer; |
| FIXP_QMF *RESTRICT tImag = pWorkBuffer+L; |
| |
| if (synQmf->flags & QMF_FLAG_CLDFB){ |
| for (i = 0; i < synQmf->lsb; i++) { |
| cplxMult(&tImag[i], &tReal[i], |
| scaleValue(qmfImag[i],scaleFactorLowBand), scaleValue(qmfReal[i],scaleFactorLowBand), |
| synQmf->t_cos[i], synQmf->t_sin[i]); |
| } |
| for (; i < synQmf->usb; i++) { |
| cplxMult(&tImag[i], &tReal[i], |
| scaleValue(qmfImag[i],scaleFactorHighBand), scaleValue(qmfReal[i],scaleFactorHighBand), |
| synQmf->t_cos[i], synQmf->t_sin[i]); |
| } |
| } |
| |
| if ( (synQmf->flags & QMF_FLAG_CLDFB) == 0) { |
| scaleValues(&tReal[0], &qmfReal[0], synQmf->lsb, scaleFactorLowBand); |
| scaleValues(&tReal[0+synQmf->lsb], &qmfReal[0+synQmf->lsb], synQmf->usb-synQmf->lsb, scaleFactorHighBand); |
| scaleValues(&tImag[0], &qmfImag[0], synQmf->lsb, scaleFactorLowBand); |
| scaleValues(&tImag[0+synQmf->lsb], &qmfImag[0+synQmf->lsb], synQmf->usb-synQmf->lsb, scaleFactorHighBand); |
| } |
| |
| FDKmemclear(&tReal[synQmf->usb], (synQmf->no_channels-synQmf->usb)*sizeof(FIXP_QMF)); |
| FDKmemclear(&tImag[synQmf->usb], (synQmf->no_channels-synQmf->usb)*sizeof(FIXP_QMF)); |
| |
| dct_IV(tReal, L, &shift); |
| dst_IV(tImag, L, &shift); |
| |
| if (synQmf->flags & QMF_FLAG_CLDFB){ |
| for (i = 0; i < M; i++) { |
| FIXP_QMF 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_QMF 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; |
| } |
| } |
| } |
| |
| void qmfSynthesisFilteringSlot( HANDLE_QMF_FILTER_BANK synQmf, |
| const FIXP_QMF *realSlot, |
| const FIXP_QMF *imagSlot, |
| const int scaleFactorLowBand, |
| const int scaleFactorHighBand, |
| INT_PCM *timeOut, |
| const int stride, |
| FIXP_QMF *pWorkBuffer) |
| { |
| if (!(synQmf->flags & QMF_FLAG_LP)) |
| qmfInverseModulationHQ ( synQmf, |
| realSlot, |
| imagSlot, |
| scaleFactorLowBand, |
| scaleFactorHighBand, |
| pWorkBuffer |
| ); |
| else |
| { |
| if (synQmf->flags & QMF_FLAG_CLDFB) { |
| qmfInverseModulationLP_odd ( synQmf, |
| realSlot, |
| scaleFactorLowBand, |
| scaleFactorHighBand, |
| pWorkBuffer |
| ); |
| } else { |
| qmfInverseModulationLP_even ( synQmf, |
| realSlot, |
| scaleFactorLowBand, |
| scaleFactorHighBand, |
| pWorkBuffer |
| ); |
| } |
| } |
| |
| if (synQmf->flags & QMF_FLAG_NONSYMMETRIC) { |
| qmfSynPrototypeFirSlot_NonSymmetric ( |
| synQmf, |
| pWorkBuffer, |
| pWorkBuffer+synQmf->no_channels, |
| timeOut, |
| stride |
| ); |
| } else { |
| qmfSynPrototypeFirSlot ( synQmf, |
| pWorkBuffer, |
| pWorkBuffer+synQmf->no_channels, |
| timeOut, |
| stride |
| ); |
| } |
| } |
| |
| |
| /*! |
| * |
| * |
| * \brief Perform complex-valued subband synthesis of the |
| * low band and the high band and store the |
| * time domain data in timeOut |
| * |
| * First step: Calculate the proper scaling factor of current |
| * spectral data in qmfReal/qmfImag, old spectral data in the overlap |
| * range and filter states. |
| * |
| * Second step: Perform Frequency-to-Time mapping with inverse |
| * Modulation slot-wise. |
| * |
| * Third step: Perform FIR-filter slot-wise. To save space for filter |
| * states, the MAC operations are executed directly on the filter states |
| * instead of accumulating several products in the accumulator. The |
| * buffer shift at the end of the function should be replaced by a |
| * modulo operation, which is available on some DSPs. |
| * |
| * Last step: Copy the upper part of the spectral data to the overlap buffer. |
| * |
| * The qmf coefficient table is symmetric. The symmetry is exploited by |
| * shrinking the coefficient table to half the size. The addressing mode |
| * takes care of the symmetries. If the #define #QMFTABLE_FULL is set, |
| * coefficient addressing works on the full table size. The code will be |
| * slightly faster and slightly more compact. |
| * |
| * Workbuffer requirement: 2 x sizeof(**QmfBufferReal) * synQmf->no_channels |
| */ |
| void |
| qmfSynthesisFiltering( HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */ |
| FIXP_QMF **QmfBufferReal, /*!< Low and High band, real */ |
| FIXP_QMF **QmfBufferImag, /*!< Low and High band, imag */ |
| const QMF_SCALE_FACTOR *scaleFactor, |
| const INT ov_len, /*!< split Slot of overlap and actual slots */ |
| INT_PCM *timeOut, /*!< Pointer to output */ |
| const INT stride, /*!< stride factor of output */ |
| FIXP_QMF *pWorkBuffer /*!< pointer to temporal working buffer */ |
| ) |
| { |
| int i; |
| int L = synQmf->no_channels; |
| SCHAR scaleFactorHighBand; |
| SCHAR scaleFactorLowBand_ov, scaleFactorLowBand_no_ov; |
| |
| /* adapt scaling */ |
| scaleFactorHighBand = -ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK - scaleFactor->hb_scale; |
| scaleFactorLowBand_ov = - ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK - scaleFactor->ov_lb_scale; |
| scaleFactorLowBand_no_ov = - ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK - scaleFactor->lb_scale; |
| |
| for (i = 0; i < synQmf->no_col; i++) /* ----- no_col loop ----- */ |
| { |
| const FIXP_DBL *QmfBufferImagSlot = NULL; |
| |
| SCHAR scaleFactorLowBand = (i<ov_len) ? scaleFactorLowBand_ov : scaleFactorLowBand_no_ov; |
| |
| if (!(synQmf->flags & QMF_FLAG_LP)) |
| QmfBufferImagSlot = QmfBufferImag[i]; |
| |
| qmfSynthesisFilteringSlot( synQmf, |
| QmfBufferReal[i], |
| QmfBufferImagSlot, |
| scaleFactorLowBand, |
| scaleFactorHighBand, |
| timeOut+(i*L*stride), |
| stride, |
| pWorkBuffer); |
| } /* no_col loop i */ |
| |
| } |
| |
| |
| /*! |
| * |
| * \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 */ |
| { |
| FDKmemclear(h_Qmf,sizeof(QMF_FILTER_BANK)); |
| |
| if (flags & QMF_FLAG_MPSLDFB) |
| { |
| 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 = qmf_phaseshift_cos32_cldfb; |
| h_Qmf->t_sin = qmf_phaseshift_sin32_cldfb; |
| h_Qmf->p_filter = qmf_cldfb_320; |
| h_Qmf->FilterSize = 320; |
| break; |
| default: |
| return -1; |
| } |
| } |
| |
| if ( !(flags & QMF_FLAG_MPSLDFB) && ((flags & QMF_FLAG_CLDFB) == 0) ) |
| { |
| switch (no_channels) { |
| case 64: |
| h_Qmf->p_filter = qmf_64; |
| 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 32: |
| h_Qmf->p_filter = qmf_64; |
| 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; |
| default: |
| return -1; |
| } |
| } |
| |
| h_Qmf->flags = flags; |
| |
| h_Qmf->no_channels = no_channels; |
| h_Qmf->no_col = noCols; |
| |
| h_Qmf->lsb = lsb; |
| h_Qmf->usb = fMin(usb, h_Qmf->no_channels); |
| |
| h_Qmf->FilterStates = (void*)pFilterStates; |
| |
| h_Qmf->outScalefactor = ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK + h_Qmf->filterScale; |
| |
| if ( (h_Qmf->p_stride == 2) |
| || ((flags & QMF_FLAG_CLDFB) && (no_channels == 32)) ) { |
| h_Qmf->outScalefactor -= 1; |
| } |
| h_Qmf->outGain = (FIXP_DBL)0x80000000; /* default init value will be not applied */ |
| |
| 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; |
| } |
| scaleValues((FIXP_QSS*)synQmf->FilterStates, synQmf->no_channels*(QMF_NO_POLY*2 - 1), scaleFactorDiff); |
| } |
| |
| /*! |
| * |
| * \brief Create QMF filter bank instance |
| * |
| * Only the lower bands are obtained (upto anaQmf->lsb). For |
| * a full bandwidth analysis it is required to set both anaQmf->lsb |
| * and anaQmf->usb to the amount of QMF bands. |
| * |
| * \return 0 if succesful |
| * |
| */ |
| int |
| qmfInitAnalysisFilterBank (HANDLE_QMF_FILTER_BANK h_Qmf, /*!< Returns handle */ |
| FIXP_QAS *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 err = qmfInitFilterBank(h_Qmf, pFilterStates, noCols, lsb, usb, no_channels, flags); |
| if ( !(flags & QMF_FLAG_KEEP_STATES) && (h_Qmf->FilterStates != NULL) ) { |
| FDKmemclear(h_Qmf->FilterStates, (2*QMF_NO_POLY-1)*h_Qmf->no_channels*sizeof(FIXP_QAS)); |
| } |
| |
| return err; |
| } |
| |
| /*! |
| * |
| * \brief Create QMF filter bank instance |
| * |
| * Only the lower bands are obtained (upto anaQmf->lsb). For |
| * a full bandwidth analysis it is required to set both anaQmf->lsb |
| * and anaQmf->usb to the amount of QMF bands. |
| * |
| * \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); |
| 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); |
| } |
| } |
| 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 || synQmf->FilterStates == NULL) { |
| return; |
| } |
| |
| /* Add internal filterbank scale */ |
| outScalefactor += ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK + synQmf->filterScale; |
| |
| if ( (synQmf->p_stride == 2) |
| || ((synQmf->flags & QMF_FLAG_CLDFB) && (synQmf->no_channels == 32)) ) { |
| outScalefactor -= 1; |
| } |
| |
| /* adjust filter states when scale factor has been changed */ |
| if (synQmf->outScalefactor != outScalefactor) |
| { |
| int diff; |
| |
| if (outScalefactor > (SAMPLE_BITS - 1)) { |
| outScalefactor = SAMPLE_BITS - 1; |
| } else if (outScalefactor < (1 - SAMPLE_BITS)) { |
| outScalefactor = 1 - SAMPLE_BITS; |
| } |
| |
| diff = synQmf->outScalefactor - outScalefactor; |
| |
| qmfAdaptFilterStates(synQmf, diff); |
| |
| /* save new scale factor */ |
| synQmf->outScalefactor = outScalefactor; |
| } |
| } |
| |
| /*! |
| * |
| * \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 */ |
| ) |
| { |
| synQmf->outGain = outputGain; |
| } |
| |
