| /* ----------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten |
| Forschung e.V. All rights reserved. |
| |
| 1. INTRODUCTION |
| The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software |
| that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding |
| scheme for digital audio. This FDK AAC Codec software is intended to be used on |
| a wide variety of Android devices. |
| |
| AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient |
| general perceptual audio codecs. AAC-ELD is considered the best-performing |
| full-bandwidth communications codec by independent studies and is widely |
| deployed. AAC has been standardized by ISO and IEC as part of the MPEG |
| specifications. |
| |
| Patent licenses for necessary patent claims for the FDK AAC Codec (including |
| those of Fraunhofer) may be obtained through Via Licensing |
| (www.vialicensing.com) or through the respective patent owners individually for |
| the purpose of encoding or decoding bit streams in products that are compliant |
| with the ISO/IEC MPEG audio standards. Please note that most manufacturers of |
| Android devices already license these patent claims through Via Licensing or |
| directly from the patent owners, and therefore FDK AAC Codec software may |
| already be covered under those patent licenses when it is used for those |
| licensed purposes only. |
| |
| Commercially-licensed AAC software libraries, including floating-point versions |
| with enhanced sound quality, are also available from Fraunhofer. Users are |
| encouraged to check the Fraunhofer website for additional applications |
| information and documentation. |
| |
| 2. COPYRIGHT LICENSE |
| |
| Redistribution and use in source and binary forms, with or without modification, |
| are permitted without payment of copyright license fees provided that you |
| satisfy the following conditions: |
| |
| You must retain the complete text of this software license in redistributions of |
| the FDK AAC Codec or your modifications thereto in source code form. |
| |
| You must retain the complete text of this software license in the documentation |
| and/or other materials provided with redistributions of the FDK AAC Codec or |
| your modifications thereto in binary form. You must make available free of |
| charge copies of the complete source code of the FDK AAC Codec and your |
| modifications thereto to recipients of copies in binary form. |
| |
| The name of Fraunhofer may not be used to endorse or promote products derived |
| from this library without prior written permission. |
| |
| You may not charge copyright license fees for anyone to use, copy or distribute |
| the FDK AAC Codec software or your modifications thereto. |
| |
| Your modified versions of the FDK AAC Codec must carry prominent notices stating |
| that you changed the software and the date of any change. For modified versions |
| of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" |
| must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK |
| AAC Codec Library for Android." |
| |
| 3. NO PATENT LICENSE |
| |
| NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without |
| limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. |
| Fraunhofer provides no warranty of patent non-infringement with respect to this |
| software. |
| |
| You may use this FDK AAC Codec software or modifications thereto only for |
| purposes that are authorized by appropriate patent licenses. |
| |
| 4. DISCLAIMER |
| |
| This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright |
| holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, |
| including but not limited to the implied warranties of merchantability and |
| fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, |
| or consequential damages, including but not limited to procurement of substitute |
| goods or services; loss of use, data, or profits, or business interruption, |
| however caused and on any theory of liability, whether in contract, strict |
| liability, or tort (including negligence), arising in any way out of the use of |
| this software, even if advised of the possibility of such damage. |
| |
| 5. CONTACT INFORMATION |
| |
| Fraunhofer Institute for Integrated Circuits IIS |
| Attention: Audio and Multimedia Departments - FDK AAC LL |
| Am Wolfsmantel 33 |
| 91058 Erlangen, Germany |
| |
| www.iis.fraunhofer.de/amm |
| amm-info@iis.fraunhofer.de |
| ----------------------------------------------------------------------------- */ |
| |
| /**************************** SBR decoder library ****************************** |
| |
| Author(s): |
| |
| Description: |
| |
| *******************************************************************************/ |
| |
| /*! |
| \file |
| \brief parametric stereo decoder |
| */ |
| |
| #include "psdec.h" |
| |
| #include "FDK_bitbuffer.h" |
| |
| #include "sbr_rom.h" |
| #include "sbr_ram.h" |
| |
| #include "FDK_tools_rom.h" |
| |
| #include "genericStds.h" |
| |
| #include "FDK_trigFcts.h" |
| |
| /********************************************************************/ |
| /* MLQUAL DEFINES */ |
| /********************************************************************/ |
| |
| #define FRACT_ZERO FRACT_BITS - 1 |
| /********************************************************************/ |
| |
| SBR_ERROR ResetPsDec(HANDLE_PS_DEC h_ps_d); |
| |
| /***** HELPERS *****/ |
| |
| /***************************************************************************/ |
| /*! |
| \brief Creates one instance of the PS_DEC struct |
| |
| \return Error info |
| |
| ****************************************************************************/ |
| int CreatePsDec(HANDLE_PS_DEC *h_PS_DEC, /*!< pointer to the module state */ |
| int aacSamplesPerFrame) { |
| SBR_ERROR errorInfo = SBRDEC_OK; |
| HANDLE_PS_DEC h_ps_d; |
| int i; |
| |
| if (*h_PS_DEC == NULL) { |
| /* Get ps dec ram */ |
| h_ps_d = GetRam_ps_dec(); |
| if (h_ps_d == NULL) { |
| goto bail; |
| } |
| } else { |
| /* Reset an open instance */ |
| h_ps_d = *h_PS_DEC; |
| } |
| |
| /* |
| * Create Analysis Hybrid filterbank. |
| */ |
| FDKhybridAnalysisOpen(&h_ps_d->specificTo.mpeg.hybridAnalysis, |
| h_ps_d->specificTo.mpeg.pHybridAnaStatesLFdmx, |
| sizeof(h_ps_d->specificTo.mpeg.pHybridAnaStatesLFdmx), |
| NULL, 0); |
| |
| /* initialisation */ |
| switch (aacSamplesPerFrame) { |
| case 960: |
| h_ps_d->noSubSamples = 30; /* col */ |
| break; |
| case 1024: |
| h_ps_d->noSubSamples = 32; /* col */ |
| break; |
| default: |
| h_ps_d->noSubSamples = -1; |
| break; |
| } |
| |
| if (h_ps_d->noSubSamples > MAX_NUM_COL || h_ps_d->noSubSamples <= 0) { |
| goto bail; |
| } |
| h_ps_d->noChannels = NO_QMF_CHANNELS; /* row */ |
| |
| h_ps_d->psDecodedPrv = 0; |
| h_ps_d->procFrameBased = -1; |
| for (i = 0; i < (1) + 1; i++) { |
| h_ps_d->bPsDataAvail[i] = ppt_none; |
| } |
| { |
| int error; |
| error = FDKdecorrelateOpen(&(h_ps_d->specificTo.mpeg.apDecor), |
| h_ps_d->specificTo.mpeg.decorrBufferCplx, |
| (2 * ((825) + (373)))); |
| if (error) goto bail; |
| } |
| |
| for (i = 0; i < (1) + 1; i++) { |
| FDKmemclear(&h_ps_d->bsData[i].mpeg, sizeof(MPEG_PS_BS_DATA)); |
| } |
| |
| errorInfo = ResetPsDec(h_ps_d); |
| |
| if (errorInfo != SBRDEC_OK) goto bail; |
| |
| *h_PS_DEC = h_ps_d; |
| |
| return 0; |
| |
| bail: |
| if (h_ps_d != NULL) { |
| DeletePsDec(&h_ps_d); |
| } |
| |
| return -1; |
| } /*END CreatePsDec */ |
| |
| /***************************************************************************/ |
| /*! |
| \brief Delete one instance of the PS_DEC struct |
| |
| \return Error info |
| |
| ****************************************************************************/ |
| int DeletePsDec(HANDLE_PS_DEC *h_PS_DEC) /*!< pointer to the module state */ |
| { |
| if (*h_PS_DEC == NULL) { |
| return -1; |
| } |
| |
| { |
| HANDLE_PS_DEC h_ps_d = *h_PS_DEC; |
| FDKdecorrelateClose(&(h_ps_d->specificTo.mpeg.apDecor)); |
| } |
| |
| FreeRam_ps_dec(h_PS_DEC); |
| |
| return 0; |
| } /*END DeletePsDec */ |
| |
| /***************************************************************************/ |
| /*! |
| \brief resets some values of the PS handle to default states |
| |
| \return |
| |
| ****************************************************************************/ |
| SBR_ERROR ResetPsDec(HANDLE_PS_DEC h_ps_d) /*!< pointer to the module state */ |
| { |
| SBR_ERROR errorInfo = SBRDEC_OK; |
| INT i; |
| |
| /* explicitly init state variables to safe values (until first ps header |
| * arrives) */ |
| |
| h_ps_d->specificTo.mpeg.lastUsb = 0; |
| |
| /* |
| * Initialize Analysis Hybrid filterbank. |
| */ |
| FDKhybridAnalysisInit(&h_ps_d->specificTo.mpeg.hybridAnalysis, THREE_TO_TEN, |
| NO_QMF_BANDS_HYBRID20, NO_QMF_BANDS_HYBRID20, 1); |
| |
| /* |
| * Initialize Synthesis Hybrid filterbank. |
| */ |
| for (i = 0; i < 2; i++) { |
| FDKhybridSynthesisInit(&h_ps_d->specificTo.mpeg.hybridSynthesis[i], |
| THREE_TO_TEN, NO_QMF_CHANNELS, NO_QMF_CHANNELS); |
| } |
| { |
| INT error; |
| error = FDKdecorrelateInit(&h_ps_d->specificTo.mpeg.apDecor, 71, DECORR_PS, |
| DUCKER_AUTOMATIC, 0, 0, 0, 0, 1, /* isLegacyPS */ |
| 1); |
| if (error) return SBRDEC_NOT_INITIALIZED; |
| } |
| |
| for (i = 0; i < NO_IID_GROUPS; i++) { |
| h_ps_d->specificTo.mpeg.h11rPrev[i] = FL2FXCONST_DBL(0.5f); |
| h_ps_d->specificTo.mpeg.h12rPrev[i] = FL2FXCONST_DBL(0.5f); |
| } |
| |
| FDKmemclear(h_ps_d->specificTo.mpeg.h21rPrev, |
| sizeof(h_ps_d->specificTo.mpeg.h21rPrev)); |
| FDKmemclear(h_ps_d->specificTo.mpeg.h22rPrev, |
| sizeof(h_ps_d->specificTo.mpeg.h22rPrev)); |
| |
| return errorInfo; |
| } |
| |
| /***************************************************************************/ |
| /*! |
| \brief Feed delaylines when parametric stereo is switched on. |
| \return |
| ****************************************************************************/ |
| void PreparePsProcessing(HANDLE_PS_DEC h_ps_d, |
| const FIXP_DBL *const *const rIntBufferLeft, |
| const FIXP_DBL *const *const iIntBufferLeft, |
| const int scaleFactorLowBand) { |
| if (h_ps_d->procFrameBased == |
| 1) /* If we have switched from frame to slot based processing */ |
| { /* fill hybrid delay buffer. */ |
| int i, j; |
| |
| for (i = 0; i < HYBRID_FILTER_DELAY; i++) { |
| FIXP_DBL qmfInputData[2][NO_QMF_BANDS_HYBRID20]; |
| FIXP_DBL hybridOutputData[2][NO_SUB_QMF_CHANNELS]; |
| |
| for (j = 0; j < NO_QMF_BANDS_HYBRID20; j++) { |
| qmfInputData[0][j] = |
| scaleValue(rIntBufferLeft[i][j], scaleFactorLowBand); |
| qmfInputData[1][j] = |
| scaleValue(iIntBufferLeft[i][j], scaleFactorLowBand); |
| } |
| |
| FDKhybridAnalysisApply(&h_ps_d->specificTo.mpeg.hybridAnalysis, |
| qmfInputData[0], qmfInputData[1], |
| hybridOutputData[0], hybridOutputData[1]); |
| } |
| h_ps_d->procFrameBased = 0; /* switch to slot based processing. */ |
| |
| } /* procFrameBased==1 */ |
| } |
| |
| void initSlotBasedRotation( |
| HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */ |
| int env, int usb) { |
| INT group = 0; |
| INT bin = 0; |
| INT noIidSteps; |
| |
| FIXP_SGL invL; |
| FIXP_DBL ScaleL, ScaleR; |
| FIXP_DBL Alpha, Beta; |
| FIXP_DBL h11r, h12r, h21r, h22r; |
| |
| const FIXP_DBL *PScaleFactors; |
| |
| if (h_ps_d->bsData[h_ps_d->processSlot].mpeg.bFineIidQ) { |
| PScaleFactors = ScaleFactorsFine; /* values are shiftet right by one */ |
| noIidSteps = NO_IID_STEPS_FINE; |
| } else { |
| PScaleFactors = ScaleFactors; /* values are shiftet right by one */ |
| noIidSteps = NO_IID_STEPS; |
| } |
| |
| /* dequantize and decode */ |
| for (group = 0; group < NO_IID_GROUPS; group++) { |
| bin = bins2groupMap20[group]; |
| |
| /*! |
| <h3> type 'A' rotation </h3> |
| mixing procedure R_a, used in baseline version<br> |
| |
| Scale-factor vectors c1 and c2 are precalculated in initPsTables () and |
| stored in scaleFactors[] and scaleFactorsFine[] = pScaleFactors []. From the |
| linearized IID parameters (intensity differences), two scale factors are |
| calculated. They are used to obtain the coefficients h11... h22. |
| */ |
| |
| /* ScaleR and ScaleL are scaled by 1 shift right */ |
| |
| ScaleR = PScaleFactors[noIidSteps + h_ps_d->specificTo.mpeg.pCoef |
| ->aaIidIndexMapped[env][bin]]; |
| ScaleL = PScaleFactors[noIidSteps - h_ps_d->specificTo.mpeg.pCoef |
| ->aaIidIndexMapped[env][bin]]; |
| |
| Beta = fMult( |
| fMult(Alphas[h_ps_d->specificTo.mpeg.pCoef->aaIccIndexMapped[env][bin]], |
| (ScaleR - ScaleL)), |
| FIXP_SQRT05); |
| Alpha = |
| Alphas[h_ps_d->specificTo.mpeg.pCoef->aaIccIndexMapped[env][bin]] >> 1; |
| |
| /* Alpha and Beta are now both scaled by 2 shifts right */ |
| |
| /* calculate the coefficients h11... h22 from scale-factors and ICC |
| * parameters */ |
| |
| /* h values are scaled by 1 shift right */ |
| { |
| FIXP_DBL trigData[4]; |
| |
| inline_fixp_cos_sin(Beta + Alpha, Beta - Alpha, 2, trigData); |
| h11r = fMult(ScaleL, trigData[0]); |
| h12r = fMult(ScaleR, trigData[2]); |
| h21r = fMult(ScaleL, trigData[1]); |
| h22r = fMult(ScaleR, trigData[3]); |
| } |
| /*****************************************************************************************/ |
| /* Interpolation of the matrices H11... H22: */ |
| /* */ |
| /* H11(k,n) = H11(k,n[e]) + (n-n[e]) * (H11(k,n[e+1] - H11(k,n[e])) / |
| * (n[e+1] - n[e]) */ |
| /* ... */ |
| /*****************************************************************************************/ |
| |
| /* invL = 1/(length of envelope) */ |
| invL = FX_DBL2FX_SGL(GetInvInt( |
| h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env + 1] - |
| h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env])); |
| |
| h_ps_d->specificTo.mpeg.pCoef->H11r[group] = |
| h_ps_d->specificTo.mpeg.h11rPrev[group]; |
| h_ps_d->specificTo.mpeg.pCoef->H12r[group] = |
| h_ps_d->specificTo.mpeg.h12rPrev[group]; |
| h_ps_d->specificTo.mpeg.pCoef->H21r[group] = |
| h_ps_d->specificTo.mpeg.h21rPrev[group]; |
| h_ps_d->specificTo.mpeg.pCoef->H22r[group] = |
| h_ps_d->specificTo.mpeg.h22rPrev[group]; |
| |
| h_ps_d->specificTo.mpeg.pCoef->DeltaH11r[group] = |
| fMult(h11r - h_ps_d->specificTo.mpeg.pCoef->H11r[group], invL); |
| h_ps_d->specificTo.mpeg.pCoef->DeltaH12r[group] = |
| fMult(h12r - h_ps_d->specificTo.mpeg.pCoef->H12r[group], invL); |
| h_ps_d->specificTo.mpeg.pCoef->DeltaH21r[group] = |
| fMult(h21r - h_ps_d->specificTo.mpeg.pCoef->H21r[group], invL); |
| h_ps_d->specificTo.mpeg.pCoef->DeltaH22r[group] = |
| fMult(h22r - h_ps_d->specificTo.mpeg.pCoef->H22r[group], invL); |
| |
| /* update prev coefficients for interpolation in next envelope */ |
| |
| h_ps_d->specificTo.mpeg.h11rPrev[group] = h11r; |
| h_ps_d->specificTo.mpeg.h12rPrev[group] = h12r; |
| h_ps_d->specificTo.mpeg.h21rPrev[group] = h21r; |
| h_ps_d->specificTo.mpeg.h22rPrev[group] = h22r; |
| |
| } /* group loop */ |
| } |
| |
| static const UCHAR groupTable[NO_IID_GROUPS + 1] = { |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, |
| 12, 13, 14, 15, 16, 18, 21, 25, 30, 42, 71}; |
| |
| static void applySlotBasedRotation( |
| HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */ |
| |
| FIXP_DBL *mHybridRealLeft, /*!< hybrid values real left */ |
| FIXP_DBL *mHybridImagLeft, /*!< hybrid values imag left */ |
| |
| FIXP_DBL *mHybridRealRight, /*!< hybrid values real right */ |
| FIXP_DBL *mHybridImagRight /*!< hybrid values imag right */ |
| ) { |
| INT group; |
| INT subband; |
| |
| /**********************************************************************************************/ |
| /*! |
| <h2> Mapping </h2> |
| |
| The number of stereo bands that is actually used depends on the number of |
| availble parameters for IID and ICC: <pre> nr. of IID para.| nr. of ICC para. |
| | nr. of Stereo bands |
| ----------------|------------------|------------------- |
| 10,20 | 10,20 | 20 |
| 10,20 | 34 | 34 |
| 34 | 10,20 | 34 |
| 34 | 34 | 34 |
| </pre> |
| In the case the number of parameters for IIS and ICC differs from the number |
| of stereo bands, a mapping from the lower number to the higher number of |
| parameters is applied. Index mapping of IID and ICC parameters is already done |
| in psbitdec.cpp. Further mapping is not needed here in baseline version. |
| **********************************************************************************************/ |
| |
| /************************************************************************************************/ |
| /*! |
| <h2> Mixing </h2> |
| |
| To generate the QMF subband signals for the subband samples n = n[e]+1 ,,, |
| n_[e+1] the parameters at position n[e] and n[e+1] are required as well as the |
| subband domain signals s_k(n) and d_k(n) for n = n[e]+1... n_[e+1]. n[e] |
| represents the start position for envelope e. The border positions n[e] are |
| handled in DecodePS(). |
| |
| The stereo sub subband signals are constructed as: |
| <pre> |
| l_k(n) = H11(k,n) s_k(n) + H21(k,n) d_k(n) |
| r_k(n) = H21(k,n) s_k(n) + H22(k,n) d_k(n) |
| </pre> |
| In order to obtain the matrices H11(k,n)... H22 (k,n), the vectors h11(b)... |
| h22(b) need to be calculated first (b: parameter index). Depending on ICC mode |
| either mixing procedure R_a or R_b is used for that. For both procedures, the |
| parameters for parameter position n[e+1] is used. |
| ************************************************************************************************/ |
| |
| /************************************************************************************************/ |
| /*! |
| <h2>Phase parameters </h2> |
| With disabled phase parameters (which is the case in baseline version), the |
| H-matrices are just calculated by: |
| |
| <pre> |
| H11(k,n[e+1] = h11(b(k)) |
| (...) |
| b(k): parameter index according to mapping table |
| </pre> |
| |
| <h2>Processing of the samples in the sub subbands </h2> |
| this loop includes the interpolation of the coefficients Hxx |
| ************************************************************************************************/ |
| |
| /******************************************************/ |
| /* construct stereo sub subband signals according to: */ |
| /* */ |
| /* l_k(n) = H11(k,n) s_k(n) + H21(k,n) d_k(n) */ |
| /* r_k(n) = H12(k,n) s_k(n) + H22(k,n) d_k(n) */ |
| /******************************************************/ |
| PS_DEC_COEFFICIENTS *pCoef = h_ps_d->specificTo.mpeg.pCoef; |
| |
| for (group = 0; group < NO_IID_GROUPS; group++) { |
| pCoef->H11r[group] += pCoef->DeltaH11r[group]; |
| pCoef->H12r[group] += pCoef->DeltaH12r[group]; |
| pCoef->H21r[group] += pCoef->DeltaH21r[group]; |
| pCoef->H22r[group] += pCoef->DeltaH22r[group]; |
| |
| const int start = groupTable[group]; |
| const int stop = groupTable[group + 1]; |
| for (subband = start; subband < stop; subband++) { |
| FIXP_DBL tmpLeft = |
| fMultAdd(fMultDiv2(pCoef->H11r[group], mHybridRealLeft[subband]), |
| pCoef->H21r[group], mHybridRealRight[subband]); |
| FIXP_DBL tmpRight = |
| fMultAdd(fMultDiv2(pCoef->H12r[group], mHybridRealLeft[subband]), |
| pCoef->H22r[group], mHybridRealRight[subband]); |
| mHybridRealLeft[subband] = tmpLeft; |
| mHybridRealRight[subband] = tmpRight; |
| |
| tmpLeft = |
| fMultAdd(fMultDiv2(pCoef->H11r[group], mHybridImagLeft[subband]), |
| pCoef->H21r[group], mHybridImagRight[subband]); |
| tmpRight = |
| fMultAdd(fMultDiv2(pCoef->H12r[group], mHybridImagLeft[subband]), |
| pCoef->H22r[group], mHybridImagRight[subband]); |
| mHybridImagLeft[subband] = tmpLeft; |
| mHybridImagRight[subband] = tmpRight; |
| } /* subband */ |
| } |
| } |
| |
| /***************************************************************************/ |
| /*! |
| \brief Applies IID, ICC, IPD and OPD parameters to the current frame. |
| |
| \return none |
| |
| ****************************************************************************/ |
| void ApplyPsSlot( |
| HANDLE_PS_DEC h_ps_d, /*!< handle PS_DEC*/ |
| FIXP_DBL **rIntBufferLeft, /*!< real bands left qmf channel (38x64) */ |
| FIXP_DBL **iIntBufferLeft, /*!< imag bands left qmf channel (38x64) */ |
| FIXP_DBL *rIntBufferRight, /*!< real bands right qmf channel (38x64) */ |
| FIXP_DBL *iIntBufferRight, /*!< imag bands right qmf channel (38x64) */ |
| const int scaleFactorLowBand_no_ov, const int scaleFactorLowBand, |
| const int scaleFactorHighBand, const int lsb, const int usb) { |
| /*! |
| The 64-band QMF representation of the monaural signal generated by the SBR tool |
| is used as input of the PS tool. After the PS processing, the outputs of the |
| left and right hybrid synthesis filterbanks are used to generate the stereo |
| output signal. |
| |
| <pre> |
| |
| ------------- ---------- ------------- |
| | Hybrid | M_n[k,m] | | L_n[k,m] | Hybrid | l[n] |
| m[n] --->| analysis |--------->| |--------->| synthesis |-----> |
| ------------- | Stereo | ------------- |
| | | recon- | |
| | | stuction | |
| \|/ | | |
| ------------- | | |
| | De- | D_n[k,m] | | |
| | correlation |--------->| | |
| ------------- | | ------------- |
| | | R_n[k,m] | Hybrid | r[n] |
| | |--------->| synthesis |-----> |
| IID, ICC ------------------------>| | | filter bank | |
| (IPD, OPD) ---------- ------------- |
| |
| m[n]: QMF represantation of the mono input |
| M_n[k,m]: (sub-)sub-band domain signals of the mono input |
| D_n[k,m]: decorrelated (sub-)sub-band domain signals |
| L_n[k,m]: (sub-)sub-band domain signals of the left output |
| R_n[k,m]: (sub-)sub-band domain signals of the right output |
| l[n],r[n]: left/right output signals |
| |
| </pre> |
| */ |
| #define NO_HYBRID_DATA_BANDS (71) |
| |
| int i; |
| FIXP_DBL qmfInputData[2][NO_QMF_BANDS_HYBRID20]; |
| FIXP_DBL *hybridData[2][2]; |
| C_ALLOC_SCRATCH_START(pHybridData, FIXP_DBL, 4 * NO_HYBRID_DATA_BANDS); |
| |
| hybridData[0][0] = |
| pHybridData + 0 * NO_HYBRID_DATA_BANDS; /* left real hybrid data */ |
| hybridData[0][1] = |
| pHybridData + 1 * NO_HYBRID_DATA_BANDS; /* left imag hybrid data */ |
| hybridData[1][0] = |
| pHybridData + 2 * NO_HYBRID_DATA_BANDS; /* right real hybrid data */ |
| hybridData[1][1] = |
| pHybridData + 3 * NO_HYBRID_DATA_BANDS; /* right imag hybrid data */ |
| |
| /*! |
| Hybrid analysis filterbank: |
| The lower 3 (5) of the 64 QMF subbands are further split to provide better |
| frequency resolution. for PS processing. For the 10 and 20 stereo bands |
| configuration, the QMF band H_0(w) is split up into 8 (sub-) sub-bands and the |
| QMF bands H_1(w) and H_2(w) are spit into 2 (sub-) 4th. (See figures 8.20 |
| and 8.22 of ISO/IEC 14496-3:2001/FDAM 2:2004(E) ) |
| */ |
| |
| /* |
| * Hybrid analysis. |
| */ |
| |
| /* Get qmf input data and apply descaling */ |
| for (i = 0; i < NO_QMF_BANDS_HYBRID20; i++) { |
| qmfInputData[0][i] = scaleValue(rIntBufferLeft[HYBRID_FILTER_DELAY][i], |
| scaleFactorLowBand_no_ov); |
| qmfInputData[1][i] = scaleValue(iIntBufferLeft[HYBRID_FILTER_DELAY][i], |
| scaleFactorLowBand_no_ov); |
| } |
| |
| /* LF - part */ |
| FDKhybridAnalysisApply(&h_ps_d->specificTo.mpeg.hybridAnalysis, |
| qmfInputData[0], qmfInputData[1], hybridData[0][0], |
| hybridData[0][1]); |
| |
| /* HF - part */ |
| /* bands up to lsb */ |
| scaleValues(&hybridData[0][0][NO_SUB_QMF_CHANNELS - 2], |
| &rIntBufferLeft[0][NO_QMF_BANDS_HYBRID20], |
| lsb - NO_QMF_BANDS_HYBRID20, scaleFactorLowBand); |
| scaleValues(&hybridData[0][1][NO_SUB_QMF_CHANNELS - 2], |
| &iIntBufferLeft[0][NO_QMF_BANDS_HYBRID20], |
| lsb - NO_QMF_BANDS_HYBRID20, scaleFactorLowBand); |
| |
| /* bands from lsb to usb */ |
| scaleValues(&hybridData[0][0][lsb + (NO_SUB_QMF_CHANNELS - 2 - |
| NO_QMF_BANDS_HYBRID20)], |
| &rIntBufferLeft[0][lsb], usb - lsb, scaleFactorHighBand); |
| scaleValues(&hybridData[0][1][lsb + (NO_SUB_QMF_CHANNELS - 2 - |
| NO_QMF_BANDS_HYBRID20)], |
| &iIntBufferLeft[0][lsb], usb - lsb, scaleFactorHighBand); |
| |
| /* bands from usb to NO_SUB_QMF_CHANNELS which should be zero for non-overlap |
| slots but can be non-zero for overlap slots */ |
| FDKmemcpy( |
| &hybridData[0][0] |
| [usb + (NO_SUB_QMF_CHANNELS - 2 - NO_QMF_BANDS_HYBRID20)], |
| &rIntBufferLeft[0][usb], sizeof(FIXP_DBL) * (NO_QMF_CHANNELS - usb)); |
| FDKmemcpy( |
| &hybridData[0][1] |
| [usb + (NO_SUB_QMF_CHANNELS - 2 - NO_QMF_BANDS_HYBRID20)], |
| &iIntBufferLeft[0][usb], sizeof(FIXP_DBL) * (NO_QMF_CHANNELS - usb)); |
| |
| /*! |
| Decorrelation: |
| By means of all-pass filtering and delaying, the (sub-)sub-band samples s_k(n) |
| are converted into de-correlated (sub-)sub-band samples d_k(n). |
| - k: frequency in hybrid spectrum |
| - n: time index |
| */ |
| |
| FDKdecorrelateApply(&h_ps_d->specificTo.mpeg.apDecor, |
| &hybridData[0][0][0], /* left real hybrid data */ |
| &hybridData[0][1][0], /* left imag hybrid data */ |
| &hybridData[1][0][0], /* right real hybrid data */ |
| &hybridData[1][1][0], /* right imag hybrid data */ |
| 0 /* startHybBand */ |
| ); |
| |
| /*! |
| Stereo Processing: |
| The sets of (sub-)sub-band samples s_k(n) and d_k(n) are processed according |
| to the stereo cues which are defined per stereo band. |
| */ |
| |
| applySlotBasedRotation(h_ps_d, |
| &hybridData[0][0][0], /* left real hybrid data */ |
| &hybridData[0][1][0], /* left imag hybrid data */ |
| &hybridData[1][0][0], /* right real hybrid data */ |
| &hybridData[1][1][0] /* right imag hybrid data */ |
| ); |
| |
| /*! |
| Hybrid synthesis filterbank: |
| The stereo processed hybrid subband signals l_k(n) and r_k(n) are fed into the |
| hybrid synthesis filterbanks which are identical to the 64 complex synthesis |
| filterbank of the SBR tool. The input to the filterbank are slots of 64 QMF |
| samples. For each slot the filterbank outputs one block of 64 samples of one |
| reconstructed stereo channel. The hybrid synthesis filterbank is computed |
| seperatly for the left and right channel. |
| */ |
| |
| /* |
| * Hybrid synthesis. |
| */ |
| for (i = 0; i < 2; i++) { |
| FDKhybridSynthesisApply( |
| &h_ps_d->specificTo.mpeg.hybridSynthesis[i], |
| hybridData[i][0], /* real hybrid data */ |
| hybridData[i][1], /* imag hybrid data */ |
| (i == 0) ? rIntBufferLeft[0] |
| : rIntBufferRight, /* output real qmf buffer */ |
| (i == 0) ? iIntBufferLeft[0] |
| : iIntBufferRight /* output imag qmf buffer */ |
| ); |
| } |
| |
| /* free temporary hybrid qmf values of one timeslot */ |
| C_ALLOC_SCRATCH_END(pHybridData, FIXP_DBL, 4 * NO_HYBRID_DATA_BANDS); |
| |
| } /* END ApplyPsSlot */ |
