aboutsummaryrefslogtreecommitdiffstats
path: root/libSBRdec/src/psdec_hybrid.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libSBRdec/src/psdec_hybrid.cpp')
-rw-r--r--libSBRdec/src/psdec_hybrid.cpp595
1 files changed, 595 insertions, 0 deletions
diff --git a/libSBRdec/src/psdec_hybrid.cpp b/libSBRdec/src/psdec_hybrid.cpp
new file mode 100644
index 0000000..9c73c69
--- /dev/null
+++ b/libSBRdec/src/psdec_hybrid.cpp
@@ -0,0 +1,595 @@
+/****************************************************************************
+
+ (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$
+
+*******************************************************************************/
+
+#include "psdec_hybrid.h"
+
+
+#include "fft.h"
+#include "sbr_ram.h"
+
+#include "FDK_tools_rom.h"
+#include "sbr_rom.h"
+
+/*******************************************************************************
+ Functionname: InitHybridFilterBank
+ *******************************************************************************
+
+ Description: Init one instance of HANDLE_HYBRID stuct
+
+ Arguments:
+
+ Return: none
+
+*******************************************************************************/
+
+
+SBR_ERROR
+InitHybridFilterBank ( HANDLE_HYBRID hs, /*!< Handle to HYBRID struct. */
+ SCHAR frameSize, /*!< Framesize (in Qmf súbband samples). */
+ SCHAR noBands, /*!< Number of Qmf bands for hybrid filtering. */
+ const UCHAR *pResolution ) /*!< Resolution in Qmf bands (length noBands). */
+{
+ SCHAR i;
+ UCHAR maxNoChannels = 0;
+
+ for (i = 0; i < noBands; i++) {
+ hs->pResolution[i] = pResolution[i];
+ if(pResolution[i] > maxNoChannels)
+ maxNoChannels = pResolution[i];
+ }
+
+ hs->nQmfBands = noBands;
+ hs->frameSize = frameSize;
+ hs->qmfBufferMove = HYBRID_FILTER_LENGTH - 1;
+
+ hs->sf_mQmfBuffer = 0;
+
+ return SBRDEC_OK;
+}
+
+/*******************************************************************************
+ Functionname: dualChannelFiltering
+ *******************************************************************************
+
+ Description: fast 2-channel real-valued filtering with 6-tap delay.
+
+ Arguments:
+
+ Return: none
+
+*******************************************************************************/
+
+/*!
+2 channel filter
+<pre>
+ Filter Coefs:
+ 0.0,
+ 0.01899487526049,
+ 0.0,
+ -0.07293139167538,
+ 0.0,
+ 0.30596630545168,
+ 0.5,
+ 0.30596630545168,
+ 0.0,
+ -0.07293139167538,
+ 0.0,
+ 0.01899487526049,
+ 0.0
+
+
+ Filter design:
+ h[q,n] = g[n] * cos(2pi/2 * q * (n-6) ); n = 0..12, q = 0,1;
+
+ -> h[0,n] = g[n] * 1;
+ -> h[1,n] = g[n] * pow(-1,n);
+</pre>
+*/
+
+static void slotBasedDualChannelFiltering( const FIXP_DBL *pQmfReal,
+ const FIXP_DBL *pQmfImag,
+
+ FIXP_DBL *mHybridReal,
+ FIXP_DBL *mHybridImag)
+{
+
+ FIXP_DBL t1, t3, t5, t6;
+
+ /* symmetric filter coefficients */
+
+ /* you don't have to shift the result after fMult because of p2_13_20 <= 0.5 */
+ t1 = fMultDiv2(p2_13_20[1] , ( (pQmfReal[1] >> 1) + (pQmfReal[11] >> 1)));
+ t3 = fMultDiv2(p2_13_20[3] , ( (pQmfReal[3] >> 1) + (pQmfReal[ 9] >> 1)));
+ t5 = fMultDiv2(p2_13_20[5] , ( (pQmfReal[5] >> 1) + (pQmfReal[ 7] >> 1)));
+ t6 = fMultDiv2(p2_13_20[6] , (pQmfReal[6] >> 1) );
+
+ mHybridReal[0] = (t1 + t3 + t5 + t6) << 2;
+ mHybridReal[1] = (- t1 - t3 - t5 + t6) << 2;
+
+ t1 = fMultDiv2(p2_13_20[1] , ( (pQmfImag[1] >> 1) + (pQmfImag[11] >> 1)));
+ t3 = fMultDiv2(p2_13_20[3] , ( (pQmfImag[3] >> 1) + (pQmfImag[ 9] >> 1)));
+ t5 = fMultDiv2(p2_13_20[5] , ( (pQmfImag[5] >> 1) + (pQmfImag[ 7] >> 1)));
+ t6 = fMultDiv2(p2_13_20[6] , pQmfImag[6] >> 1 );
+
+ mHybridImag[0] = (t1 + t3 + t5 + t6) << 2;
+ mHybridImag[1] = (- t1 - t3 - t5 + t6) << 2;
+}
+
+
+/*******************************************************************************
+ Functionname: eightChannelFiltering
+ *******************************************************************************
+
+ Description: fast 8-channel complex-valued filtering with 6-tap delay.
+
+ Arguments:
+
+ Return: none
+
+*******************************************************************************/
+/*!
+ 8 channel filter
+
+ Implementation using a FFT of length 8
+<pre>
+ prototype filter coefficients:
+ 0.00746082949812 0.02270420949825 0.04546865930473 0.07266113929591 0.09885108575264 0.11793710567217
+ 0.125
+ 0.11793710567217 0.09885108575264 0.07266113929591 0.04546865930473 0.02270420949825 0.00746082949812
+
+ Filter design:
+ N = 13; Q = 8;
+ h[q,n] = g[n] * exp(j * 2 * pi / Q * (q + .5) * (n - 6)); n = 0..(N-1), q = 0..(Q-1);
+
+ Time Signal: x[t];
+ Filter Bank Output
+ y[q,t] = conv(x[t],h[q,t]) = conv(h[q,t],x[t]) = sum(x[k] * h[q, t - k] ) = sum(h[q, k] * x[t - k] ); k = 0..(N-1);
+
+ y[q,t] = x[t - 12]*h[q, 12] + x[t - 11]*h[q, 11] + x[t - 10]*h[q, 10] + x[t - 9]*h[q, 9]
+ + x[t - 8]*h[q, 8] + x[t - 7]*h[q, 7]
+ + x[t - 6]*h[q, 6]
+ + x[t - 5]*h[q, 5] + x[t - 4]*h[q, 4]
+ + x[t - 3]*h[q, 3] + x[t - 2]*h[q, 2] + x[t - 1]*h[q, 1] + x[t - 0]*h[q, 0];
+
+ h'[q, n] = h[q,(N-1)-n] = g[n] * exp(j * 2 * pi / Q * (q + .5) * (6 - n)); n = 0..(N-1), q = 0..(Q-1);
+
+ y[q,t] = x[t - 12]*h'[q, 0] + x[t - 11]*h'[q, 1] + x[t - 10]*h'[q, 2] + x[t - 9]*h'[q, 3]
+ + x[t - 8]*h'[q, 4] + x[t - 7]*h'[q, 5]
+ + x[t - 6]*h'[q, 6]
+ + x[t - 5]*h'[q, 7] + x[t - 4]*h'[q, 8]
+ + x[t - 3]*h'[q, 9] + x[t - 2]*h'[q, 10] + x[t - 1]*h'[q, 11] + x[t - 0]*h'[q, 12];
+
+ Try to split off FFT Modulation Term:
+ FFT(x[t], q) = sum(x[t+k]*exp(-j*2*pi/N *q * k))
+ c m
+ Step 1: h'[q,n] = g[n] * ( exp(j * 2 * pi / 8 * .5 * (6 - n)) ) * ( exp (j * 2 * pi / 8 * q * (6 - n)) );
+
+ h'[q,n] = g[n] *c[n] * m[q,n]; (see above)
+ c[n] = exp( j * 2 * pi / 8 * .5 * (6 - n) );
+ m[q,n] = exp( j * 2 * pi / 8 * q * (6 - n) );
+
+ y[q,t] = x[t - 0]*g[0]*c[0]*m[q,0] + x[t - 1]*g[1]*c[ 1]*m[q, 1] + ...
+ ... + x[t - 12]*g[2]*c[12]*m[q,12];
+
+ |
+ n m *exp(-j*2*pi) | n' fft
+-------------------------------------------------------------------------------------------------------------------------
+ 0 exp( j * 2 * pi / 8 * q * 6) -> exp(-j * 2 * pi / 8 * q * 2) | 2 exp(-j * 2 * pi / 8 * q * 0)
+ 1 exp( j * 2 * pi / 8 * q * 5) -> exp(-j * 2 * pi / 8 * q * 3) | 3 exp(-j * 2 * pi / 8 * q * 1)
+ 2 exp( j * 2 * pi / 8 * q * 4) -> exp(-j * 2 * pi / 8 * q * 4) | 4 exp(-j * 2 * pi / 8 * q * 2)
+ 3 exp( j * 2 * pi / 8 * q * 3) -> exp(-j * 2 * pi / 8 * q * 5) | 5 exp(-j * 2 * pi / 8 * q * 3)
+ 4 exp( j * 2 * pi / 8 * q * 2) -> exp(-j * 2 * pi / 8 * q * 6) | 6 exp(-j * 2 * pi / 8 * q * 4)
+ 5 exp( j * 2 * pi / 8 * q * 1) -> exp(-j * 2 * pi / 8 * q * 7) | 7 exp(-j * 2 * pi / 8 * q * 5)
+ 6 exp( j * 2 * pi / 8 * q * 0) | 0 exp(-j * 2 * pi / 8 * q * 6)
+ 7 exp(-j * 2 * pi / 8 * q * 1) | 1 exp(-j * 2 * pi / 8 * q * 7)
+ 8 exp(-j * 2 * pi / 8 * q * 2) | 2
+ 9 exp(-j * 2 * pi / 8 * q * 3) | 3
+ 10 exp(-j * 2 * pi / 8 * q * 4) | 4
+ 11 exp(-j * 2 * pi / 8 * q * 5) | 5
+ 12 exp(-j * 2 * pi / 8 * q * 6) | 6
+
+
+ now use fft modulation coefficients
+ m[6] = = fft[0]
+ m[7] = = fft[1]
+ m[8] = m[ 0] = fft[2]
+ m[9] = m[ 1] = fft[3]
+ m[10] = m[ 2] = fft[4]
+ m[11] = m[ 3] = fft[5]
+ m[12] = m[ 4] = fft[6]
+ m[ 5] = fft[7]
+
+ y[q,t] = ( x[t- 6]*g[ 6]*c[ 6] ) * fft[q,0] +
+ ( x[t- 7]*g[ 7]*c[ 7] ) * fft[q,1] +
+ ( x[t- 0]*g[ 0]*c[ 0] + x[t- 8]*g[ 8]*c[ 8] ) * fft[q,2] +
+ ( x[t- 1]*g[ 1]*c[ 1] + x[t- 9]*g[ 9]*c[ 9] ) * fft[q,3] +
+ ( x[t- 2]*g[ 2]*c[ 2] + x[t-10]*g[10]*c[10] ) * fft[q,4] +
+ ( x[t- 3]*g[ 3]*c[ 3] + x[t-11]*g[11]*c[11] ) * fft[q,5] +
+ ( x[t- 4]*g[ 4]*c[ 4] + x[t-12]*g[12]*c[12] ) * fft[q,6] +
+ ( x[t- 5]*g[ 5]*c[ 5] ) * fft[q,7];
+
+ pre twiddle factors c[n] = exp(j * 2 * pi / 8 * .5 * (6 - n));
+ n c] | n c[n] | n c[n]
+---------------------------------------------------------------------------------------------------
+ 0 exp( j * 6 * pi / 8) | 1 exp( j * 5 * pi / 8) | 2 exp( j * 4 * pi / 8)
+ 3 exp( j * 3 * pi / 8) | 4 exp( j * 2 * pi / 8) | 5 exp( j * 1 * pi / 8)
+ 6 exp( j * 0 * pi / 8) | 7 exp(-j * 1 * pi / 8) | 8 exp(-j * 2 * pi / 8)
+ 9 exp(-j * 3 * pi / 8) | 10 exp(-j * 4 * pi / 8) | 11 exp(-j * 5 * pi / 8)
+ 12 exp(-j * 6 * pi / 8) | |
+</pre>
+*/
+
+/* defining rotation factors for *ChannelFiltering */
+
+#define cos0Pi FL2FXCONST_DBL( 1.f)
+#define sin0Pi FL2FXCONST_DBL( 0.f)
+
+#define cos1Pi FL2FXCONST_DBL(-1.f)
+#define sin1Pi FL2FXCONST_DBL( 0.f)
+
+#define cos1Pi_2 FL2FXCONST_DBL( 0.f)
+#define sin1Pi_2 FL2FXCONST_DBL( 1.f)
+
+#define cos1Pi_3 FL2FXCONST_DBL( 0.5f)
+#define sin1Pi_3 FL2FXCONST_DBL( 0.86602540378444f)
+
+#define cos0Pi_4 cos0Pi
+#define cos1Pi_4 FL2FXCONST_DBL(0.70710678118655f)
+#define cos2Pi_4 cos1Pi_2
+#define cos3Pi_4 (-cos1Pi_4)
+#define cos4Pi_4 (-cos0Pi_4)
+#define cos5Pi_4 cos3Pi_4
+#define cos6Pi_4 cos2Pi_4
+
+#define sin0Pi_4 sin0Pi
+#define sin1Pi_4 FL2FXCONST_DBL(0.70710678118655f)
+#define sin2Pi_4 sin1Pi_2
+#define sin3Pi_4 sin1Pi_4
+#define sin4Pi_4 sin0Pi_4
+#define sin5Pi_4 (-sin3Pi_4)
+#define sin6Pi_4 (-sin2Pi_4)
+
+#define cos0Pi_8 cos0Pi
+#define cos1Pi_8 FL2FXCONST_DBL(0.92387953251129f)
+#define cos2Pi_8 cos1Pi_4
+#define cos3Pi_8 FL2FXCONST_DBL(0.38268343236509f)
+#define cos4Pi_8 cos2Pi_4
+#define cos5Pi_8 (-cos3Pi_8)
+#define cos6Pi_8 (-cos2Pi_8)
+
+#define sin0Pi_8 sin0Pi
+#define sin1Pi_8 cos3Pi_8
+#define sin2Pi_8 sin1Pi_4
+#define sin3Pi_8 cos1Pi_8
+#define sin4Pi_8 sin2Pi_4
+#define sin5Pi_8 sin3Pi_8
+#define sin6Pi_8 sin1Pi_4
+
+#if defined(ARCH_PREFER_MULT_32x16)
+ #define FIXP_HYB FIXP_SGL
+ #define FIXP_CAST FX_DBL2FX_SGL
+#else
+ #define FIXP_HYB FIXP_DBL
+ #define FIXP_CAST
+#endif
+
+static const FIXP_HYB cr[13] =
+{
+ FIXP_CAST(cos6Pi_8), FIXP_CAST(cos5Pi_8), FIXP_CAST(cos4Pi_8),
+ FIXP_CAST(cos3Pi_8), FIXP_CAST(cos2Pi_8), FIXP_CAST(cos1Pi_8),
+ FIXP_CAST(cos0Pi_8),
+ FIXP_CAST(cos1Pi_8), FIXP_CAST(cos2Pi_8), FIXP_CAST(cos3Pi_8),
+ FIXP_CAST(cos4Pi_8), FIXP_CAST(cos5Pi_8), FIXP_CAST(cos6Pi_8)
+};
+
+static const FIXP_HYB ci[13] =
+{
+ FIXP_CAST( sin6Pi_8), FIXP_CAST( sin5Pi_8), FIXP_CAST( sin4Pi_8),
+ FIXP_CAST( sin3Pi_8), FIXP_CAST( sin2Pi_8), FIXP_CAST( sin1Pi_8),
+ FIXP_CAST( sin0Pi_8) ,
+ FIXP_CAST(-sin1Pi_8), FIXP_CAST(-sin2Pi_8), FIXP_CAST(-sin3Pi_8),
+ FIXP_CAST(-sin4Pi_8), FIXP_CAST(-sin5Pi_8), FIXP_CAST(-sin6Pi_8)
+};
+
+static void slotBasedEightChannelFiltering( const FIXP_DBL *pQmfReal,
+ const FIXP_DBL *pQmfImag,
+
+ FIXP_DBL *mHybridReal,
+ FIXP_DBL *mHybridImag)
+{
+
+ int bin;
+ FIXP_DBL _fft[128 + ALIGNMENT_DEFAULT - 1];
+ FIXP_DBL *fft = (FIXP_DBL *)ALIGN_PTR(_fft);
+
+#if defined(ARCH_PREFER_MULT_32x16)
+ const FIXP_SGL *p = p8_13_20; /* BASELINE_PS */
+#else
+ const FIXP_DBL *p = p8_13_20; /* BASELINE_PS */
+#endif
+
+ /* pre twiddeling */
+
+ /* x*(a*b + c*d) = fMultDiv2(x, fMultAddDiv2(fMultDiv2(a, b), c, d)) */
+ /* x*(a*b - c*d) = fMultDiv2(x, fMultSubDiv2(fMultDiv2(a, b), c, d)) */
+ FIXP_DBL accu1, accu2, accu3, accu4;
+
+ #define TWIDDLE_1(n_0,n_1,n_2) \
+ cplxMultDiv2(&accu1, &accu2, pQmfReal[n_0], pQmfImag[n_0], cr[n_0], ci[n_0]); \
+ accu1 = fMultDiv2(p[n_0], accu1); \
+ accu2 = fMultDiv2(p[n_0], accu2); \
+ cplxMultDiv2(&accu3, &accu4, pQmfReal[n_1], pQmfImag[n_1], cr[n_1], ci[n_1]); \
+ accu3 = fMultDiv2(p[n_1], accu3); \
+ accu4 = fMultDiv2(p[n_1], accu4); \
+ fft[FIXP_FFT_IDX_R(n_2)] = accu1 + accu3; \
+ fft[FIXP_FFT_IDX_I(n_2)] = accu2 + accu4;
+
+ #define TWIDDLE_0(n_0,n_1) \
+ cplxMultDiv2(&accu1, &accu2, pQmfReal[n_0], pQmfImag[n_0], cr[n_0], ci[n_0]); \
+ fft[FIXP_FFT_IDX_R(n_1)] = fMultDiv2(p[n_0], accu1); \
+ fft[FIXP_FFT_IDX_I(n_1)] = fMultDiv2(p[n_0], accu2);
+
+ TWIDDLE_0( 6, 0)
+ TWIDDLE_0( 7, 1)
+
+ TWIDDLE_1( 0, 8, 2)
+ TWIDDLE_1( 1, 9, 3)
+ TWIDDLE_1( 2,10, 4)
+ TWIDDLE_1( 3,11, 5)
+ TWIDDLE_1( 4,12, 6)
+
+ TWIDDLE_0( 5, 7)
+
+ fft_8 (fft);
+
+ /* resort fft data into output array*/
+ for(bin=0; bin<8;bin++ ) {
+ mHybridReal[bin] = fft[FIXP_FFT_IDX_R(bin)] << 4;
+ mHybridImag[bin] = fft[FIXP_FFT_IDX_I(bin)] << 4;
+ }
+}
+
+
+/*******************************************************************************
+ Functionname: fillHybridDelayLine
+ *******************************************************************************
+
+ Description: The delay line of the hybrid filter is filled and copied from
+ left to right.
+
+ Return: none
+
+*******************************************************************************/
+
+void
+fillHybridDelayLine( FIXP_DBL **fixpQmfReal, /*!< Qmf real Values */
+ FIXP_DBL **fixpQmfImag, /*!< Qmf imag Values */
+ FIXP_DBL fixpHybridLeftR[12], /*!< Hybrid real Values left channel */
+ FIXP_DBL fixpHybridLeftI[12], /*!< Hybrid imag Values left channel */
+ FIXP_DBL fixpHybridRightR[12], /*!< Hybrid real Values right channel */
+ FIXP_DBL fixpHybridRightI[12], /*!< Hybrid imag Values right channel */
+ HANDLE_HYBRID hHybrid )
+{
+ int i;
+
+ for (i = 0; i < HYBRID_FILTER_DELAY; i++) {
+ slotBasedHybridAnalysis ( fixpQmfReal[i],
+ fixpQmfReal[i],
+ fixpHybridLeftR,
+ fixpHybridLeftI,
+ hHybrid );
+ }
+
+ FDKmemcpy(fixpHybridRightR, fixpHybridLeftR, sizeof(FIXP_DBL)*NO_SUB_QMF_CHANNELS);
+ FDKmemcpy(fixpHybridRightI, fixpHybridLeftI, sizeof(FIXP_DBL)*NO_SUB_QMF_CHANNELS);
+}
+
+
+/*******************************************************************************
+ Functionname: slotBasedHybridAnalysis
+ *******************************************************************************
+
+ Description: The lower QMF subbands are further split to provide better
+ frequency resolution for PS processing.
+
+ Return: none
+
+*******************************************************************************/
+
+
+void
+slotBasedHybridAnalysis ( FIXP_DBL *fixpQmfReal, /*!< Qmf real Values */
+ FIXP_DBL *fixpQmfImag, /*!< Qmf imag Values */
+
+ FIXP_DBL fixpHybridReal[12], /*!< Hybrid real Values */
+ FIXP_DBL fixpHybridImag[12], /*!< Hybrid imag Values */
+
+ HANDLE_HYBRID hHybrid)
+{
+ int k, band;
+ HYBRID_RES hybridRes;
+ int chOffset = 0;
+
+ C_ALLOC_SCRATCH_START(pTempRealSlot, FIXP_DBL, 4*HYBRID_FILTER_LENGTH);
+
+ FIXP_DBL *pTempImagSlot = pTempRealSlot + HYBRID_FILTER_LENGTH;
+ FIXP_DBL *pWorkRealSlot = pTempImagSlot + HYBRID_FILTER_LENGTH;
+ FIXP_DBL *pWorkImagSlot = pWorkRealSlot + HYBRID_FILTER_LENGTH;
+
+ /*!
+ Hybrid filtering is applied to the first hHybrid->nQmfBands QMF bands (3 when 10 or 20 stereo bands
+ are used, 5 when 34 stereo bands are used). For the remaining QMF bands a delay would be necessary.
+ But there is no need to implement a delay because there is a look-ahead of HYBRID_FILTER_DELAY = 6
+ QMF samples in the low-band buffer.
+ */
+
+ for(band = 0; band < hHybrid->nQmfBands; band++) {
+
+ /* get hybrid resolution per qmf band */
+ /* in case of baseline ps 10/20 band stereo mode : */
+ /* */
+ /* qmfBand[0] : 8 ( HYBRID_8_CPLX ) */
+ /* qmfBand[1] : 2 ( HYBRID_2_REAL ) */
+ /* qmfBand[2] : 2 ( HYBRID_2_REAL ) */
+ /* */
+ /* (split the 3 lower qmf band to 12 hybrid bands) */
+
+ hybridRes = (HYBRID_RES)hHybrid->pResolution[band];
+
+ FDKmemcpy(pWorkRealSlot, hHybrid->mQmfBufferRealSlot[band], hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
+ FDKmemcpy(pWorkImagSlot, hHybrid->mQmfBufferImagSlot[band], hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
+
+ pWorkRealSlot[hHybrid->qmfBufferMove] = fixpQmfReal[band];
+ pWorkImagSlot[hHybrid->qmfBufferMove] = fixpQmfImag[band];
+
+ FDKmemcpy(hHybrid->mQmfBufferRealSlot[band], pWorkRealSlot + 1, hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
+ FDKmemcpy(hHybrid->mQmfBufferImagSlot[band], pWorkImagSlot + 1, hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
+
+ if (fixpQmfReal) {
+
+ /* actual filtering only if output signal requested */
+ switch( hybridRes ) {
+
+ /* HYBRID_2_REAL & HYBRID_8_CPLX are only needful for baseline ps */
+ case HYBRID_2_REAL:
+
+ slotBasedDualChannelFiltering( pWorkRealSlot,
+ pWorkImagSlot,
+ pTempRealSlot,
+ pTempImagSlot);
+ break;
+
+ case HYBRID_8_CPLX:
+
+ slotBasedEightChannelFiltering( pWorkRealSlot,
+ pWorkImagSlot,
+ pTempRealSlot,
+ pTempImagSlot);
+ break;
+
+ default:
+ FDK_ASSERT(0);
+ }
+
+ for(k = 0; k < (SCHAR)hybridRes; k++) {
+ fixpHybridReal [chOffset + k] = pTempRealSlot[k];
+ fixpHybridImag [chOffset + k] = pTempImagSlot[k];
+ }
+ chOffset += hybridRes;
+ } /* if (mHybridReal) */
+ }
+
+ /* group hybrid channels 3+4 -> 3 and 2+5 -> 2 */
+ fixpHybridReal[3] += fixpHybridReal[4];
+ fixpHybridImag[3] += fixpHybridImag[4];
+ fixpHybridReal[4] = (FIXP_DBL)0;
+ fixpHybridImag[4] = (FIXP_DBL)0;
+
+ fixpHybridReal[2] += fixpHybridReal[5];
+ fixpHybridImag[2] += fixpHybridImag[5];
+ fixpHybridReal[5] = (FIXP_DBL)0;
+ fixpHybridImag[5] = (FIXP_DBL)0;
+
+ /* free memory on scratch */
+ C_ALLOC_SCRATCH_END(pTempRealSlot, FIXP_DBL, 4*HYBRID_FILTER_LENGTH);
+
+}
+
+
+/*******************************************************************************
+ Functionname: slotBasedHybridSynthesis
+ *******************************************************************************
+
+ Description: The coefficients offering higher resolution for the lower QMF
+ channel are simply added prior to the synthesis with the 54
+ subbands QMF.
+
+ Arguments:
+
+ Return: none
+
+*******************************************************************************/
+
+/*! <pre>
+ l,r0(n) ---\
+ l,r1(n) ---- + --\
+ l,r2(n) ---/ \
+ + --> F0(w)
+ l,r3(n) ---\ /
+ l,r4(n) ---- + --/
+ l,r5(n) ---/
+
+
+ l,r6(n) ---\
+ + ---------> F1(w)
+ l,r7(n) ---/
+
+
+ l,r8(n) ---\
+ + ---------> F2(w)
+ l,r9(n) ---/
+
+ </pre>
+ Hybrid QMF synthesis filterbank for the 10 and 20 stereo-bands configurations. The
+ coefficients offering higher resolution for the lower QMF channel are simply added
+ prior to the synthesis with the 54 subbands QMF.
+
+ [see ISO/IEC 14496-3:2001/FDAM 2:2004(E) - Page 52]
+*/
+
+
+void
+slotBasedHybridSynthesis ( FIXP_DBL *fixpHybridReal, /*!< Hybrid real Values */
+ FIXP_DBL *fixpHybridImag, /*!< Hybrid imag Values */
+ FIXP_DBL *fixpQmfReal, /*!< Qmf real Values */
+ FIXP_DBL *fixpQmfImag, /*!< Qmf imag Values */
+ HANDLE_HYBRID hHybrid ) /*!< Handle to HYBRID struct. */
+{
+ int k, band;
+
+ HYBRID_RES hybridRes;
+ int chOffset = 0;
+
+ for(band = 0; band < hHybrid->nQmfBands; band++) {
+
+ FIXP_DBL qmfReal = FL2FXCONST_DBL(0.f);
+ FIXP_DBL qmfImag = FL2FXCONST_DBL(0.f);
+ hybridRes = (HYBRID_RES)hHybrid->pResolution[band];
+
+ for(k = 0; k < (SCHAR)hybridRes; k++) {
+ qmfReal += fixpHybridReal[chOffset + k];
+ qmfImag += fixpHybridImag[chOffset + k];
+ }
+
+ fixpQmfReal[band] = qmfReal;
+ fixpQmfImag[band] = qmfImag;
+
+ chOffset += hybridRes;
+ }
+}
+
+
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 05:10:08 +0000