From 9bf37cc9712506b2483650c82d3c41152337ef7e Mon Sep 17 00:00:00 2001 From: Dave Burke Date: Tue, 17 Apr 2012 09:51:45 -0700 Subject: Fraunhofer AAC codec. License boilerplate update to follow. Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5 --- libSBRdec/src/psdec_hybrid.cpp | 595 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 595 insertions(+) create mode 100644 libSBRdec/src/psdec_hybrid.cpp (limited to 'libSBRdec/src/psdec_hybrid.cpp') 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 +
+   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);
+
+*/ + +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 +
+   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)  |                                |
+
+*/ + +/* 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 + +*******************************************************************************/ + +/*! 
+      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) ---/
+
+
+ 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; + } +} + + + -- cgit v1.2.3