summaryrefslogtreecommitdiffstats
path: root/libSBRdec/src/psdec.cpp
diff options
context:
space:
mode:
authorDave Burke <daveburke@google.com>2012-04-17 09:51:45 -0700
committerDave Burke <daveburke@google.com>2012-04-17 23:04:43 -0700
commit9bf37cc9712506b2483650c82d3c41152337ef7e (patch)
tree77db44e2bae06e3d144b255628be2b7a55c581d3 /libSBRdec/src/psdec.cpp
parenta37315fe10ee143d6d0b28c19d41a476a23e63ea (diff)
downloadODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.gz
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.bz2
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.zip
Fraunhofer AAC codec.
License boilerplate update to follow. Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5
Diffstat (limited to 'libSBRdec/src/psdec.cpp')
-rw-r--r--libSBRdec/src/psdec.cpp1356
1 files changed, 1356 insertions, 0 deletions
diff --git a/libSBRdec/src/psdec.cpp b/libSBRdec/src/psdec.cpp
new file mode 100644
index 0000000..86ccdc4
--- /dev/null
+++ b/libSBRdec/src/psdec.cpp
@@ -0,0 +1,1356 @@
+/****************************************************************************
+
+ (C) Copyright Fraunhofer IIS (2005)
+ All Rights Reserved
+
+ Please be advised that this software and/or program delivery is
+ Confidential Information of Fraunhofer and subject to and covered by the
+
+ Fraunhofer IIS Software Evaluation Agreement
+ between Google Inc. and Fraunhofer
+ effective and in full force since March 1, 2012.
+
+ You may use this software and/or program only under the terms and
+ conditions described in the above mentioned Fraunhofer IIS Software
+ Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+ This software and/or program is protected by copyright law and international
+ treaties. Any reproduction or distribution of this software and/or program,
+ or any portion of it, may result in severe civil and criminal penalties, and
+ will be prosecuted to the maximum extent possible under law.
+
+ $Id$
+
+*******************************************************************************/
+/*!
+ \file
+ \brief parametric stereo decoder $Revision: 36841 $
+*/
+
+#include "psdec.h"
+
+
+
+#include "FDK_bitbuffer.h"
+#include "psdec_hybrid.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 );
+
+void ResetPsDeCor( HANDLE_PS_DEC h_ps_d );
+
+
+/***** HELPERS *****/
+
+static void assignTimeSlotsPS (FIXP_DBL *bufAdr, FIXP_DBL **bufPtr, const int numSlots, const int numChan);
+
+
+
+/*******************/
+
+#define DIV3 FL2FXCONST_DBL(1.f/3.f) /* division 3.0 */
+#define DIV1_5 FL2FXCONST_DBL(2.f/3.f) /* division 1.5 */
+
+/***************************************************************************/
+/*!
+ \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) {
+ errorInfo = SBRDEC_MEM_ALLOC_FAILED;
+ goto bail;
+ }
+ } else {
+ /* Reset an open instance */
+ h_ps_d = *h_PS_DEC;
+ }
+
+ /* 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;
+ }
+
+
+ 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;
+
+ ResetPsDeCor( h_ps_d );
+
+ *h_PS_DEC = h_ps_d;
+
+
+
+ return 0;
+
+bail:
+ 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;
+ }
+
+
+ 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;
+
+ const UCHAR noQmfBandsInHybrid20 = 3;
+ /* const UCHAR noQmfBandsInHybrid34 = 5; */
+
+ const UCHAR aHybridResolution20[] = { HYBRID_8_CPLX,
+ HYBRID_2_REAL,
+ HYBRID_2_REAL };
+
+ h_ps_d->specificTo.mpeg.delayBufIndex = 0;
+
+ /* explicitly init state variables to safe values (until first ps header arrives) */
+
+ h_ps_d->specificTo.mpeg.lastUsb = 0;
+
+ h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer = -(DFRACT_BITS-1);
+
+ FDKmemclear(h_ps_d->specificTo.mpeg.aDelayBufIndexDelayQmf, (NO_QMF_CHANNELS-FIRST_DELAY_SB)*sizeof(UCHAR));
+ h_ps_d->specificTo.mpeg.noSampleDelay = delayIndexQmf[0];
+
+ for (i=0 ; i < NO_SERIAL_ALLPASS_LINKS; i++) {
+ h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[i] = 0;
+ }
+
+ h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0] = h_ps_d->specificTo.mpeg.aaQmfDelayBufReal;
+
+ assignTimeSlotsPS ( h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0] + (NO_QMF_CHANNELS-FIRST_DELAY_SB),
+ &h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[1],
+ h_ps_d->specificTo.mpeg.noSampleDelay-1,
+ (NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB));
+
+ h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0] = h_ps_d->specificTo.mpeg.aaQmfDelayBufImag;
+
+ assignTimeSlotsPS ( h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0] + (NO_QMF_CHANNELS-FIRST_DELAY_SB),
+ &h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[1],
+ h_ps_d->specificTo.mpeg.noSampleDelay-1,
+ (NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB));
+
+ /* Hybrid Filter Bank 1 creation. */
+ errorInfo = InitHybridFilterBank ( &h_ps_d->specificTo.mpeg.hybrid,
+ h_ps_d->noSubSamples,
+ noQmfBandsInHybrid20,
+ aHybridResolution20 );
+
+ 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 clear some buffers used in decorrelation process
+
+ \return
+
+****************************************************************************/
+void ResetPsDeCor( HANDLE_PS_DEC h_ps_d ) /*!< pointer to the module state */
+{
+ INT i;
+
+ FDKmemclear(h_ps_d->specificTo.mpeg.aPeakDecayFastBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
+ FDKmemclear(h_ps_d->specificTo.mpeg.aPrevNrgBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
+ FDKmemclear(h_ps_d->specificTo.mpeg.aPrevPeakDiffBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
+ FDKmemclear(h_ps_d->specificTo.mpeg.aPowerPrevScal, NO_MID_RES_BINS*sizeof(SCHAR));
+
+ for (i=0 ; i < FIRST_DELAY_SB ; i++) {
+ FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
+ FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
+ }
+ for (i=0 ; i < NO_SUB_QMF_CHANNELS ; i++) {
+ FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
+ FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
+ }
+
+}
+
+/*******************************************************************************/
+
+/* slot based funcion prototypes */
+
+static void deCorrelateSlotBased( HANDLE_PS_DEC h_ps_d,
+
+ FIXP_DBL *mHybridRealLeft,
+ FIXP_DBL *mHybridImagLeft,
+ SCHAR sf_mHybridLeft,
+
+ FIXP_DBL *rIntBufferLeft,
+ FIXP_DBL *iIntBufferLeft,
+ SCHAR sf_IntBuffer,
+
+ FIXP_DBL *mHybridRealRight,
+ FIXP_DBL *mHybridImagRight,
+
+ FIXP_DBL *rIntBufferRight,
+ FIXP_DBL *iIntBufferRight );
+
+static void applySlotBasedRotation( HANDLE_PS_DEC h_ps_d,
+
+ FIXP_DBL *mHybridRealLeft,
+ FIXP_DBL *mHybridImagLeft,
+
+ FIXP_DBL *QmfLeftReal,
+ FIXP_DBL *QmfLeftImag,
+
+ FIXP_DBL *mHybridRealRight,
+ FIXP_DBL *mHybridImagRight,
+
+ FIXP_DBL *QmfRightReal,
+ FIXP_DBL *QmfRightImag
+ );
+
+
+/***************************************************************************/
+/*!
+ \brief Get scale factor for all ps delay buffer.
+
+ \return
+
+****************************************************************************/
+static
+int getScaleFactorPsStatesBuffer(HANDLE_PS_DEC h_ps_d)
+{
+ INT i;
+ int scale = DFRACT_BITS-1;
+
+ for (i=0; i<NO_QMF_BANDS_HYBRID20; i++) {
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.hybrid.mQmfBufferRealSlot[i], NO_SUB_QMF_CHANNELS));
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.hybrid.mQmfBufferImagSlot[i], NO_SUB_QMF_CHANNELS));
+ }
+
+ for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[i], FIRST_DELAY_SB));
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[i], FIRST_DELAY_SB));
+ }
+
+ for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS));
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS));
+ }
+
+ for (i=0; i<FIRST_DELAY_SB; i++) {
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS));
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS));
+ }
+
+ for (i=0; i<NO_SUB_QMF_CHANNELS; i++) {
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS));
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS));
+ }
+
+ for (i=0; i<MAX_DELAY_BUFFER_SIZE; i++)
+ {
+ INT len;
+ if (i==0)
+ len = NO_QMF_CHANNELS-FIRST_DELAY_SB;
+ else
+ len = NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB;
+
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[i], len));
+ scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[i], len));
+ }
+
+ return (scale);
+}
+
+/***************************************************************************/
+/*!
+ \brief Rescale all ps delay buffer.
+
+ \return
+
+****************************************************************************/
+static
+void scalePsStatesBuffer(HANDLE_PS_DEC h_ps_d,
+ int scale)
+{
+ INT i;
+
+ if (scale < 0)
+ scale = fixMax((INT)scale,(INT)-(DFRACT_BITS-1));
+ else
+ scale = fixMin((INT)scale,(INT)DFRACT_BITS-1);
+
+ for (i=0; i<NO_QMF_BANDS_HYBRID20; i++) {
+ scaleValues( h_ps_d->specificTo.mpeg.hybrid.mQmfBufferRealSlot[i], NO_SUB_QMF_CHANNELS, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.hybrid.mQmfBufferImagSlot[i], NO_SUB_QMF_CHANNELS, scale );
+ }
+
+ for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
+ scaleValues( h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[i], FIRST_DELAY_SB, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[i], FIRST_DELAY_SB, scale );
+ }
+
+ for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
+ scaleValues( h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS, scale );
+ }
+
+ for (i=0; i<FIRST_DELAY_SB; i++) {
+ scaleValues( h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
+ }
+
+ for (i=0; i<NO_SUB_QMF_CHANNELS; i++) {
+ scaleValues( h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
+ }
+
+ for (i=0; i<MAX_DELAY_BUFFER_SIZE; i++) {
+ INT len;
+ if (i==0)
+ len = NO_QMF_CHANNELS-FIRST_DELAY_SB;
+ else
+ len = NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB;
+
+ scaleValues( h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[i], len, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[i], len, scale );
+ }
+
+ scale <<= 1;
+
+ scaleValues( h_ps_d->specificTo.mpeg.aPeakDecayFastBin, NO_MID_RES_BINS, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.aPrevPeakDiffBin, NO_MID_RES_BINS, scale );
+ scaleValues( h_ps_d->specificTo.mpeg.aPrevNrgBin, NO_MID_RES_BINS, scale );
+}
+
+/***************************************************************************/
+/*!
+ \brief Scale input channel to the same scalefactor and rescale hybrid
+ filterbank values
+
+ \return
+
+****************************************************************************/
+
+void scalFilterBankValues( HANDLE_PS_DEC h_ps_d,
+ FIXP_DBL **fixpQmfReal,
+ FIXP_DBL **fixpQmfImag,
+ int lsb,
+ int scaleFactorLowBandSplitLow,
+ int scaleFactorLowBandSplitHigh,
+ SCHAR *scaleFactorLowBand_lb,
+ SCHAR *scaleFactorLowBand_hb,
+ int scaleFactorHighBands,
+ INT *scaleFactorHighBand,
+ INT noCols
+ )
+{
+ INT maxScal;
+
+ INT i;
+
+ scaleFactorHighBands = -scaleFactorHighBands;
+ scaleFactorLowBandSplitLow = -scaleFactorLowBandSplitLow;
+ scaleFactorLowBandSplitHigh = -scaleFactorLowBandSplitHigh;
+
+ /* get max scale factor */
+ maxScal = fixMax(scaleFactorHighBands,fixMax(scaleFactorLowBandSplitLow, scaleFactorLowBandSplitHigh ));
+
+ {
+ int headroom = getScaleFactorPsStatesBuffer(h_ps_d);
+ maxScal = fixMax(maxScal,(INT)(h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer-headroom));
+ maxScal += 1;
+ }
+
+ /* scale whole left channel to the same scale factor */
+
+ /* low band ( overlap buffer ) */
+ if ( maxScal != scaleFactorLowBandSplitLow ) {
+ INT scale = scaleFactorLowBandSplitLow - maxScal;
+ for ( i=0; i<(6); i++ ) {
+ scaleValues( fixpQmfReal[i], lsb, scale );
+ scaleValues( fixpQmfImag[i], lsb, scale );
+ }
+ }
+ /* low band ( current frame ) */
+ if ( maxScal != scaleFactorLowBandSplitHigh ) {
+ INT scale = scaleFactorLowBandSplitHigh - maxScal;
+ /* for ( i=(6); i<(6)+MAX_NUM_COL; i++ ) { */
+ for ( i=(6); i<(6)+noCols; i++ ) {
+ scaleValues( fixpQmfReal[i], lsb, scale );
+ scaleValues( fixpQmfImag[i], lsb, scale );
+ }
+ }
+ /* high band */
+ if ( maxScal != scaleFactorHighBands ) {
+ INT scale = scaleFactorHighBands - maxScal;
+ /* for ( i=0; i<MAX_NUM_COL; i++ ) { */
+ for ( i=0; i<noCols; i++ ) {
+ scaleValues( &fixpQmfReal[i][lsb], (64)-lsb, scale );
+ scaleValues( &fixpQmfImag[i][lsb], (64)-lsb, scale );
+ }
+ }
+
+ if ( maxScal != h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer )
+ scalePsStatesBuffer(h_ps_d,(h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer-maxScal));
+
+ h_ps_d->specificTo.mpeg.hybrid.sf_mQmfBuffer = maxScal;
+ h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer = maxScal;
+
+ *scaleFactorHighBand += maxScal - scaleFactorHighBands;
+
+ h_ps_d->rescal = maxScal - scaleFactorLowBandSplitHigh;
+ h_ps_d->sf_IntBuffer = maxScal;
+
+ *scaleFactorLowBand_lb += maxScal - scaleFactorLowBandSplitLow;
+ *scaleFactorLowBand_hb += maxScal - scaleFactorLowBandSplitHigh;
+}
+
+void rescalFilterBankValues( HANDLE_PS_DEC h_ps_d, /* parametric stereo decoder handle */
+ FIXP_DBL **QmfBufferReal, /* qmf filterbank values */
+ FIXP_DBL **QmfBufferImag, /* qmf filterbank values */
+ int lsb, /* sbr start subband */
+ INT noCols)
+{
+ int i;
+ /* scale back 6 timeslots look ahead for hybrid filterbank to original value */
+ for ( i=noCols; i<noCols + (6); i++ ) {
+ scaleValues( QmfBufferReal[i], lsb, h_ps_d->rescal );
+ scaleValues( QmfBufferImag[i], lsb, h_ps_d->rescal );
+ }
+}
+
+/***************************************************************************/
+/*!
+ \brief Generate decorrelated side channel using allpass/delay
+
+ \return
+
+****************************************************************************/
+static void
+deCorrelateSlotBased( HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */
+
+ FIXP_DBL *mHybridRealLeft, /*!< left (mono) hybrid values real */
+ FIXP_DBL *mHybridImagLeft, /*!< left (mono) hybrid values imag */
+ SCHAR sf_mHybridLeft, /*!< scalefactor for left (mono) hybrid bands */
+
+ FIXP_DBL *rIntBufferLeft, /*!< real qmf bands left (mono) (38x64) */
+ FIXP_DBL *iIntBufferLeft, /*!< real qmf bands left (mono) (38x64) */
+ SCHAR sf_IntBuffer, /*!< scalefactor for all left and right qmf bands */
+
+ FIXP_DBL *mHybridRealRight, /*!< right (decorrelated) hybrid values real */
+ FIXP_DBL *mHybridImagRight, /*!< right (decorrelated) hybrid values imag */
+
+ FIXP_DBL *rIntBufferRight, /*!< real qmf bands right (decorrelated) (38x64) */
+ FIXP_DBL *iIntBufferRight ) /*!< real qmf bands right (decorrelated) (38x64) */
+{
+
+ INT i, m, sb, gr, bin;
+
+ FIXP_DBL peakDiff, nrg, transRatio;
+
+ FIXP_DBL *RESTRICT aaLeftReal;
+ FIXP_DBL *RESTRICT aaLeftImag;
+
+ FIXP_DBL *RESTRICT aaRightReal;
+ FIXP_DBL *RESTRICT aaRightImag;
+
+ FIXP_DBL *RESTRICT pRealDelayBuffer;
+ FIXP_DBL *RESTRICT pImagDelayBuffer;
+
+ C_ALLOC_SCRATCH_START(aaPowerSlot, FIXP_DBL, NO_MID_RES_BINS);
+ C_ALLOC_SCRATCH_START(aaTransRatioSlot, FIXP_DBL, NO_MID_RES_BINS);
+
+/*!
+<pre>
+ parameter index qmf bands hybrid bands
+ ----------------------------------------------------------------------------
+ 0 0 0,7
+ 1 0 1,6
+ 2 0 2
+ 3 0 3 HYBRID BANDS
+ 4 1 9
+ 5 1 8
+ 6 2 10
+ 7 2 11
+ ----------------------------------------------------------------------------
+ 8 3
+ 9 4
+ 10 5
+ 11 6
+ 12 7
+ 13 8
+ 14 9,10 (2 ) QMF BANDS
+ 15 11 - 13 (3 )
+ 16 14 - 17 (4 )
+ 17 18 - 22 (5 )
+ 18 23 - 34 (12)
+ 19 35 - 63 (29)
+ ----------------------------------------------------------------------------
+</pre>
+*/
+
+ #define FLTR_SCALE 3
+
+ /* hybrid bands (parameter index 0 - 7) */
+ aaLeftReal = mHybridRealLeft;
+ aaLeftImag = mHybridImagLeft;
+
+ aaPowerSlot[0] = ( fMultAddDiv2( fMultDiv2(aaLeftReal[0], aaLeftReal[0]), aaLeftImag[0], aaLeftImag[0] ) >> FLTR_SCALE ) +
+ ( fMultAddDiv2( fMultDiv2(aaLeftReal[7], aaLeftReal[7]), aaLeftImag[7], aaLeftImag[7] ) >> FLTR_SCALE );
+
+ aaPowerSlot[1] = ( fMultAddDiv2( fMultDiv2(aaLeftReal[1], aaLeftReal[1]), aaLeftImag[1], aaLeftImag[1] ) >> FLTR_SCALE ) +
+ ( fMultAddDiv2( fMultDiv2(aaLeftReal[6], aaLeftReal[6]), aaLeftImag[6], aaLeftImag[6] ) >> FLTR_SCALE );
+
+ aaPowerSlot[2] = fMultAddDiv2( fMultDiv2(aaLeftReal[2], aaLeftReal[2]), aaLeftImag[2], aaLeftImag[2] ) >> FLTR_SCALE;
+ aaPowerSlot[3] = fMultAddDiv2( fMultDiv2(aaLeftReal[3], aaLeftReal[3]), aaLeftImag[3], aaLeftImag[3] ) >> FLTR_SCALE;
+
+ aaPowerSlot[4] = fMultAddDiv2( fMultDiv2(aaLeftReal[9], aaLeftReal[9]), aaLeftImag[9], aaLeftImag[9] ) >> FLTR_SCALE;
+ aaPowerSlot[5] = fMultAddDiv2( fMultDiv2(aaLeftReal[8], aaLeftReal[8]), aaLeftImag[8], aaLeftImag[8] ) >> FLTR_SCALE;
+
+ aaPowerSlot[6] = fMultAddDiv2( fMultDiv2(aaLeftReal[10], aaLeftReal[10]), aaLeftImag[10], aaLeftImag[10] ) >> FLTR_SCALE;
+ aaPowerSlot[7] = fMultAddDiv2( fMultDiv2(aaLeftReal[11], aaLeftReal[11]), aaLeftImag[11], aaLeftImag[11] ) >> FLTR_SCALE;
+
+ /* qmf bands (parameter index 8 - 19) */
+ for ( bin = 8; bin < NO_MID_RES_BINS; bin++ ) {
+ FIXP_DBL slotNrg = FL2FXCONST_DBL(0.f);
+
+ for ( i = groupBorders20[bin+2]; i < groupBorders20[bin+3]; i++ ) { /* max loops: 29 */
+ slotNrg += fMultAddDiv2 ( fMultDiv2(rIntBufferLeft[i], rIntBufferLeft[i]), iIntBufferLeft[i], iIntBufferLeft[i]) >> FLTR_SCALE;
+ }
+ aaPowerSlot[bin] = slotNrg;
+
+ }
+
+
+ /* calculation of transient ratio */
+ for (bin=0; bin < NO_MID_RES_BINS; bin++) { /* noBins = 20 ( BASELINE_PS ) */
+
+ h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] = fMult( h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin], PEAK_DECAY_FACTOR );
+
+ if (h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] < aaPowerSlot[bin]) {
+ h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] = aaPowerSlot[bin];
+ }
+
+ /* calculate PSmoothPeakDecayDiffNrg */
+ peakDiff = fMultAdd ( (h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin]>>1),
+ INT_FILTER_COEFF, h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] - aaPowerSlot[bin] - h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin]);
+
+ /* save peakDiff for the next frame */
+ h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin] = peakDiff;
+
+ nrg = h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] + fMult( INT_FILTER_COEFF, aaPowerSlot[bin] - h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] );
+
+ /* Negative energies don't exist. But sometimes they appear due to rounding. */
+
+ nrg = fixMax(nrg,FL2FXCONST_DBL(0.f));
+
+ /* save nrg for the next frame */
+ h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] = nrg;
+
+ nrg = fMult( nrg, TRANSIENT_IMPACT_FACTOR );
+
+ /* save transient impact factor */
+ if ( peakDiff <= nrg || peakDiff == FL2FXCONST_DBL(0.0) ) {
+ aaTransRatioSlot[bin] = (FIXP_DBL)MAXVAL_DBL /* FL2FXCONST_DBL(1.0f)*/;
+ }
+ else if ( nrg <= FL2FXCONST_DBL(0.0f) ) {
+ aaTransRatioSlot[bin] = FL2FXCONST_DBL(0.f);
+ }
+ else {
+ /* scale to denominator */
+ INT scale_left = fixMax(0, CntLeadingZeros(peakDiff) - 1);
+ aaTransRatioSlot[bin] = schur_div( nrg<<scale_left, peakDiff<<scale_left, 16);
+ }
+ } /* bin */
+
+
+
+
+ #define DELAY_GROUP_OFFSET 20
+ #define NR_OF_DELAY_GROUPS 2
+
+ FIXP_DBL rTmp, iTmp, rTmp0, iTmp0, rR0, iR0;
+
+ INT TempDelay = h_ps_d->specificTo.mpeg.delayBufIndex; /* set delay indices */
+
+ pRealDelayBuffer = h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[TempDelay];
+ pImagDelayBuffer = h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[TempDelay];
+
+ aaLeftReal = mHybridRealLeft;
+ aaLeftImag = mHybridImagLeft;
+ aaRightReal = mHybridRealRight;
+ aaRightImag = mHybridImagRight;
+
+ /************************/
+ /* ICC groups : 0 - 9 */
+ /************************/
+
+ /* gr = ICC groups */
+ for (gr=0; gr < SUBQMF_GROUPS; gr++) {
+
+ transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
+
+ /* sb = subQMF/QMF subband */
+ sb = groupBorders20[gr];
+
+ /* Update delay buffers, sample delay allpass = 2 */
+ rTmp0 = pRealDelayBuffer[sb];
+ iTmp0 = pImagDelayBuffer[sb];
+
+ pRealDelayBuffer[sb] = aaLeftReal[sb];
+ pImagDelayBuffer[sb] = aaLeftImag[sb];
+
+ /* delay by fraction */
+ cplxMultDiv2(&rR0, &iR0, rTmp0, iTmp0, aaFractDelayPhaseFactorReSubQmf20[sb], aaFractDelayPhaseFactorImSubQmf20[sb]);
+ rR0<<=1;
+ iR0<<=1;
+
+ FIXP_DBL *pAaaRealDelayRBufferSerSubQmf = h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[sb];
+ FIXP_DBL *pAaaImagDelayRBufferSerSubQmf = h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[sb];
+
+ for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
+
+ INT tmpDelayRSer = h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m];
+
+ /* get delayed values from according buffer : m(0)=3; m(1)=4; m(2)=5; */
+ rTmp0 = pAaaRealDelayRBufferSerSubQmf[tmpDelayRSer];
+ iTmp0 = pAaaImagDelayRBufferSerSubQmf[tmpDelayRSer];
+
+ /* delay by fraction */
+ cplxMultDiv2(&rTmp, &iTmp, rTmp0, iTmp0, aaFractDelayPhaseFactorSerReSubQmf20[sb][m], aaFractDelayPhaseFactorSerImSubQmf20[sb][m]);
+
+ rTmp = (rTmp - fMultDiv2(aAllpassLinkDecaySer[m], rR0)) << 1;
+ iTmp = (iTmp - fMultDiv2(aAllpassLinkDecaySer[m], iR0)) << 1;
+
+ pAaaRealDelayRBufferSerSubQmf[tmpDelayRSer] = rR0 + fMult(aAllpassLinkDecaySer[m], rTmp);
+ pAaaImagDelayRBufferSerSubQmf[tmpDelayRSer] = iR0 + fMult(aAllpassLinkDecaySer[m], iTmp);
+
+ rR0 = rTmp;
+ iR0 = iTmp;
+
+ pAaaRealDelayRBufferSerSubQmf += aAllpassLinkDelaySer[m];
+ pAaaImagDelayRBufferSerSubQmf += aAllpassLinkDelaySer[m];
+
+ } /* m */
+
+ /* duck if a past transient is found */
+ aaRightReal[sb] = fMult(transRatio, rR0);
+ aaRightImag[sb] = fMult(transRatio, iR0);
+
+ } /* gr */
+
+
+ scaleValues( mHybridRealLeft, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
+ scaleValues( mHybridImagLeft, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
+ scaleValues( mHybridRealRight, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
+ scaleValues( mHybridImagRight, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
+
+
+ /************************/
+
+ aaLeftReal = rIntBufferLeft;
+ aaLeftImag = iIntBufferLeft;
+ aaRightReal = rIntBufferRight;
+ aaRightImag = iIntBufferRight;
+
+ pRealDelayBuffer = h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[TempDelay];
+ pImagDelayBuffer = h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[TempDelay];
+
+ /************************/
+ /* ICC groups : 10 - 19 */
+ /************************/
+
+
+ /* gr = ICC groups */
+ for (gr=SUBQMF_GROUPS; gr < NO_IID_GROUPS - NR_OF_DELAY_GROUPS; gr++) {
+
+ transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
+
+ /* sb = subQMF/QMF subband */
+ for (sb = groupBorders20[gr]; sb < groupBorders20[gr+1]; sb++) {
+ FIXP_DBL resR, resI;
+
+ /* decayScaleFactor = 1.0f + decay_cutoff * DECAY_SLOPE - DECAY_SLOPE * sb; DECAY_SLOPE = 0.05 */
+ FIXP_DBL decayScaleFactor = decayScaleFactTable[sb];
+
+ /* Update delay buffers, sample delay allpass = 2 */
+ rTmp0 = pRealDelayBuffer[sb];
+ iTmp0 = pImagDelayBuffer[sb];
+
+ pRealDelayBuffer[sb] = aaLeftReal[sb];
+ pImagDelayBuffer[sb] = aaLeftImag[sb];
+
+ /* delay by fraction */
+ cplxMultDiv2(&rR0, &iR0, rTmp0, iTmp0, aaFractDelayPhaseFactorReQmf[sb], aaFractDelayPhaseFactorImQmf[sb]);
+ rR0<<=1;
+ iR0<<=1;
+
+ resR = fMult(decayScaleFactor, rR0);
+ resI = fMult(decayScaleFactor, iR0);
+
+ FIXP_DBL *pAaaRealDelayRBufferSerQmf = h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[sb];
+ FIXP_DBL *pAaaImagDelayRBufferSerQmf = h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[sb];
+
+ for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
+
+ INT tmpDelayRSer = h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m];
+
+ /* get delayed values from according buffer : m(0)=3; m(1)=4; m(2)=5; */
+ rTmp0 = pAaaRealDelayRBufferSerQmf[tmpDelayRSer];
+ iTmp0 = pAaaImagDelayRBufferSerQmf[tmpDelayRSer];
+
+ /* delay by fraction */
+ cplxMultDiv2(&rTmp, &iTmp, rTmp0, iTmp0, aaFractDelayPhaseFactorSerReQmf[sb][m], aaFractDelayPhaseFactorSerImQmf[sb][m]);
+
+ rTmp = (rTmp - fMultDiv2(aAllpassLinkDecaySer[m], resR))<<1;
+ iTmp = (iTmp - fMultDiv2(aAllpassLinkDecaySer[m], resI))<<1;
+
+ resR = fMult(decayScaleFactor, rTmp);
+ resI = fMult(decayScaleFactor, iTmp);
+
+ pAaaRealDelayRBufferSerQmf[tmpDelayRSer] = rR0 + fMult(aAllpassLinkDecaySer[m], resR);
+ pAaaImagDelayRBufferSerQmf[tmpDelayRSer] = iR0 + fMult(aAllpassLinkDecaySer[m], resI);
+
+ rR0 = rTmp;
+ iR0 = iTmp;
+
+ pAaaRealDelayRBufferSerQmf += aAllpassLinkDelaySer[m];
+ pAaaImagDelayRBufferSerQmf += aAllpassLinkDelaySer[m];
+
+ } /* m */
+
+ /* duck if a past transient is found */
+ aaRightReal[sb] = fMult(transRatio, rR0);
+ aaRightImag[sb] = fMult(transRatio, iR0);
+
+ } /* sb */
+ } /* gr */
+
+ /************************/
+ /* ICC groups : 20, 21 */
+ /************************/
+
+
+ /* gr = ICC groups */
+ for (gr=DELAY_GROUP_OFFSET; gr < NO_IID_GROUPS; gr++) {
+
+ INT sbStart = groupBorders20[gr];
+ INT sbStop = groupBorders20[gr+1];
+
+ UCHAR *pDelayBufIdx = &h_ps_d->specificTo.mpeg.aDelayBufIndexDelayQmf[sbStart-FIRST_DELAY_SB];
+
+ transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
+
+ /* sb = subQMF/QMF subband */
+ for (sb = sbStart; sb < sbStop; sb++) {
+
+ /* Update delay buffers */
+ rR0 = h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB];
+ iR0 = h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB];
+
+ h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB] = aaLeftReal[sb];
+ h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB] = aaLeftImag[sb];
+
+ /* duck if a past transient is found */
+ aaRightReal[sb] = fMult(transRatio, rR0);
+ aaRightImag[sb] = fMult(transRatio, iR0);
+
+ if (++(*pDelayBufIdx) >= delayIndexQmf[sb]) {
+ *pDelayBufIdx = 0;
+ }
+ pDelayBufIdx++;
+
+ } /* sb */
+ } /* gr */
+
+
+ /* Update delay buffer index */
+ if (++h_ps_d->specificTo.mpeg.delayBufIndex >= NO_SAMPLE_DELAY_ALLPASS)
+ h_ps_d->specificTo.mpeg.delayBufIndex = 0;
+
+ for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
+ if (++h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m] >= aAllpassLinkDelaySer[m])
+ h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m] = 0;
+ }
+
+
+ scaleValues( &rIntBufferLeft[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
+ scaleValues( &iIntBufferLeft[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
+ scaleValues( &rIntBufferRight[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
+ scaleValues( &iIntBufferRight[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
+
+ /* free memory on scratch */
+ C_ALLOC_SCRATCH_END(aaTransRatioSlot, FIXP_DBL, NO_MID_RES_BINS);
+ C_ALLOC_SCRATCH_END(aaPowerSlot, FIXP_DBL, NO_MID_RES_BINS);
+}
+
+
+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;
+
+/* const UCHAR *pQuantizedIIDs;*/
+
+ FIXP_SGL invL;
+ FIXP_DBL ScaleL, ScaleR;
+ FIXP_DBL Alpha, Beta;
+ FIXP_DBL h11r, h12r, h21r, h22r;
+
+ const FIXP_DBL *PScaleFactors;
+
+ /* Overwrite old values in delay buffers when upper subband is higher than in last frame */
+ if (env == 0) {
+
+ if ((usb > h_ps_d->specificTo.mpeg.lastUsb) && h_ps_d->specificTo.mpeg.lastUsb) {
+
+ INT i,k,length;
+
+ for (i=h_ps_d->specificTo.mpeg.lastUsb ; i < FIRST_DELAY_SB; i++) {
+ FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
+ FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
+ }
+
+ for (k=0 ; k<NO_SAMPLE_DELAY_ALLPASS; k++) {
+ FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[k], FIRST_DELAY_SB*sizeof(FIXP_DBL));
+ }
+ length = (usb-FIRST_DELAY_SB)*sizeof(FIXP_DBL);
+ if(length>0) {
+ FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0], length);
+ FDKmemclear(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0], length);
+ }
+ length = (fixMin(NO_DELAY_BUFFER_BANDS,(INT)usb)-FIRST_DELAY_SB)*sizeof(FIXP_DBL);
+ if(length>0) {
+ for (k=1 ; k < h_ps_d->specificTo.mpeg.noSampleDelay; k++) {
+ FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[k], length);
+ FDKmemclear(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[k], length);
+ }
+ }
+ }
+ h_ps_d->specificTo.mpeg.lastUsb = usb;
+ } /* env == 0 */
+
+ if (h_ps_d->bsData[h_ps_d->processSlot].mpeg.bFineIidQ)
+ {
+ PScaleFactors = ScaleFactorsFine; /* values are shiftet right by one */
+ noIidSteps = NO_IID_STEPS_FINE;
+ /*pQuantizedIIDs = quantizedIIDsFine;*/
+ }
+
+ else
+ {
+ PScaleFactors = ScaleFactors; /* values are shiftet right by one */
+ noIidSteps = NO_IID_STEPS;
+ /*pQuantizedIIDs = quantizedIIDs;*/
+ }
+
+
+ /* 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.coef.aaIidIndexMapped[env][bin]];
+ ScaleL = PScaleFactors[noIidSteps - h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env][bin]];
+
+ Beta = fMult (fMult( Alphas[h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env][bin]], ( ScaleR - ScaleL )), FIXP_SQRT05);
+ Alpha = Alphas[h_ps_d->specificTo.mpeg.coef.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.coef.H11r[group] = h_ps_d->specificTo.mpeg.h11rPrev[group];
+ h_ps_d->specificTo.mpeg.coef.H12r[group] = h_ps_d->specificTo.mpeg.h12rPrev[group];
+ h_ps_d->specificTo.mpeg.coef.H21r[group] = h_ps_d->specificTo.mpeg.h21rPrev[group];
+ h_ps_d->specificTo.mpeg.coef.H22r[group] = h_ps_d->specificTo.mpeg.h22rPrev[group];
+
+ h_ps_d->specificTo.mpeg.coef.DeltaH11r[group] = fMult ( h11r - h_ps_d->specificTo.mpeg.coef.H11r[group], invL );
+ h_ps_d->specificTo.mpeg.coef.DeltaH12r[group] = fMult ( h12r - h_ps_d->specificTo.mpeg.coef.H12r[group], invL );
+ h_ps_d->specificTo.mpeg.coef.DeltaH21r[group] = fMult ( h21r - h_ps_d->specificTo.mpeg.coef.H21r[group], invL );
+ h_ps_d->specificTo.mpeg.coef.DeltaH22r[group] = fMult ( h22r - h_ps_d->specificTo.mpeg.coef.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 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 *QmfLeftReal, /*!< real bands left qmf channel */
+ FIXP_DBL *QmfLeftImag, /*!< imag bands left qmf channel */
+
+ FIXP_DBL *mHybridRealRight, /*!< hybrid values real right */
+ FIXP_DBL *mHybridImagRight, /*!< hybrid values imag right */
+
+ FIXP_DBL *QmfRightReal, /*!< real bands right qmf channel */
+ FIXP_DBL *QmfRightImag /*!< imag bands right qmf channel */
+ )
+{
+ INT group;
+ INT subband;
+
+ FIXP_DBL *RESTRICT HybrLeftReal;
+ FIXP_DBL *RESTRICT HybrLeftImag;
+ FIXP_DBL *RESTRICT HybrRightReal;
+ FIXP_DBL *RESTRICT HybrRightImag;
+
+ FIXP_DBL tmpLeft, tmpRight;
+
+
+ /**********************************************************************************************/
+ /*!
+ <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
+ ************************************************************************************************/
+
+
+ /* loop thru all groups ... */
+ HybrLeftReal = mHybridRealLeft;
+ HybrLeftImag = mHybridImagLeft;
+ HybrRightReal = mHybridRealRight;
+ HybrRightImag = mHybridImagRight;
+
+ /******************************************************/
+ /* 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) */
+ /******************************************************/
+ for ( group = 0; group < SUBQMF_GROUPS; group++ ) {
+
+ h_ps_d->specificTo.mpeg.coef.H11r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH11r[group];
+ h_ps_d->specificTo.mpeg.coef.H12r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH12r[group];
+ h_ps_d->specificTo.mpeg.coef.H21r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH21r[group];
+ h_ps_d->specificTo.mpeg.coef.H22r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH22r[group];
+
+ subband = groupBorders20[group];
+
+ tmpLeft = fMultAddDiv2( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightReal[subband]);
+ tmpRight = fMultAddDiv2( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightReal[subband]);
+ HybrLeftReal [subband] = tmpLeft<<1;
+ HybrRightReal[subband] = tmpRight<<1;
+
+ tmpLeft = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightImag[subband]);
+ tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightImag[subband]);
+ HybrLeftImag [subband] = tmpLeft;
+ HybrRightImag[subband] = tmpRight;
+ }
+
+ /* continue in the qmf buffers */
+ HybrLeftReal = QmfLeftReal;
+ HybrLeftImag = QmfLeftImag;
+ HybrRightReal = QmfRightReal;
+ HybrRightImag = QmfRightImag;
+
+ for (; group < NO_IID_GROUPS; group++ ) {
+
+ h_ps_d->specificTo.mpeg.coef.H11r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH11r[group];
+ h_ps_d->specificTo.mpeg.coef.H12r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH12r[group];
+ h_ps_d->specificTo.mpeg.coef.H21r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH21r[group];
+ h_ps_d->specificTo.mpeg.coef.H22r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH22r[group];
+
+ for ( subband = groupBorders20[group]; subband < groupBorders20[group + 1]; subband++ )
+ {
+ tmpLeft = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightReal[subband]);
+ tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightReal[subband]);
+ HybrLeftReal [subband] = tmpLeft;
+ HybrRightReal[subband] = tmpRight;
+
+ tmpLeft = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightImag[subband]);
+ tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightImag[subband]);
+ HybrLeftImag [subband] = tmpLeft;
+ HybrRightImag[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) */
+ )
+{
+
+ /*!
+ 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 |----->
+ | filter bank | | | | filter bank |
+ ------------- | 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>
+ */
+
+ /* get temporary hybrid qmf values of one timeslot */
+ C_ALLOC_SCRATCH_START(hybridRealLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+ C_ALLOC_SCRATCH_START(hybridImagLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+ C_ALLOC_SCRATCH_START(hybridRealRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+ C_ALLOC_SCRATCH_START(hybridImagRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+
+ SCHAR sf_IntBuffer = h_ps_d->sf_IntBuffer;
+
+ /* clear workbuffer */
+ FDKmemclear(hybridRealLeft, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
+ FDKmemclear(hybridImagLeft, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
+ FDKmemclear(hybridRealRight, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
+ FDKmemclear(hybridImagRight, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
+
+
+ /*!
+ 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) )
+ */
+
+
+ if (h_ps_d->procFrameBased == 1) /* If we have switched from frame to slot based processing */
+ { /* fill hybrid delay buffer. */
+ h_ps_d->procFrameBased = 0;
+
+ fillHybridDelayLine( rIntBufferLeft,
+ iIntBufferLeft,
+ hybridRealLeft,
+ hybridImagLeft,
+ hybridRealRight,
+ hybridImagRight,
+ &h_ps_d->specificTo.mpeg.hybrid );
+ }
+
+ slotBasedHybridAnalysis ( rIntBufferLeft[HYBRID_FILTER_DELAY], /* qmf filterbank values */
+ iIntBufferLeft[HYBRID_FILTER_DELAY], /* qmf filterbank values */
+ hybridRealLeft, /* hybrid filterbank values */
+ hybridImagLeft, /* hybrid filterbank values */
+ &h_ps_d->specificTo.mpeg.hybrid); /* hybrid filterbank handle */
+
+
+ SCHAR hybridScal = h_ps_d->specificTo.mpeg.hybrid.sf_mQmfBuffer;
+
+
+ /*!
+ 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
+ */
+
+ deCorrelateSlotBased( h_ps_d, /* parametric stereo decoder handle */
+ hybridRealLeft, /* left hybrid time slot */
+ hybridImagLeft,
+ hybridScal, /* scale factor of left hybrid time slot */
+ rIntBufferLeft[0], /* left qmf time slot */
+ iIntBufferLeft[0],
+ sf_IntBuffer, /* scale factor of left and right qmf time slot */
+ hybridRealRight, /* right hybrid time slot */
+ hybridImagRight,
+ rIntBufferRight, /* right qmf time slot */
+ iIntBufferRight );
+
+
+
+ /*!
+ 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, /* parametric stereo decoder handle */
+ hybridRealLeft, /* left hybrid time slot */
+ hybridImagLeft,
+ rIntBufferLeft[0], /* left qmf time slot */
+ iIntBufferLeft[0],
+ hybridRealRight, /* right hybrid time slot */
+ hybridImagRight,
+ rIntBufferRight, /* right qmf time slot */
+ iIntBufferRight );
+
+
+
+
+ /*!
+ 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.
+ */
+
+
+ /* left channel */
+ slotBasedHybridSynthesis ( hybridRealLeft, /* one timeslot of hybrid filterbank values */
+ hybridImagLeft,
+ rIntBufferLeft[0], /* one timeslot of qmf filterbank values */
+ iIntBufferLeft[0],
+ &h_ps_d->specificTo.mpeg.hybrid ); /* hybrid filterbank handle */
+
+ /* right channel */
+ slotBasedHybridSynthesis ( hybridRealRight, /* one timeslot of hybrid filterbank values */
+ hybridImagRight,
+ rIntBufferRight, /* one timeslot of qmf filterbank values */
+ iIntBufferRight,
+ &h_ps_d->specificTo.mpeg.hybrid ); /* hybrid filterbank handle */
+
+
+
+
+
+
+
+ /* free temporary hybrid qmf values of one timeslot */
+ C_ALLOC_SCRATCH_END(hybridImagRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+ C_ALLOC_SCRATCH_END(hybridRealRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+ C_ALLOC_SCRATCH_END(hybridImagLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+ C_ALLOC_SCRATCH_END(hybridRealLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
+
+}/* END ApplyPsSlot */
+
+
+/***************************************************************************/
+/*!
+
+ \brief assigns timeslots to an array
+
+ \return
+
+****************************************************************************/
+
+static void assignTimeSlotsPS (FIXP_DBL *bufAdr,
+ FIXP_DBL **bufPtr,
+ const int numSlots,
+ const int numChan)
+{
+ FIXP_DBL *ptr;
+ int slot;
+ ptr = bufAdr;
+ for(slot=0; slot < numSlots; slot++) {
+ bufPtr [slot] = ptr;
+ ptr += numChan;
+ }
+}
+