1 2 /* ----------------------------------------------------------------------------------------------------------- 3 Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5 Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16 of the MPEG specifications. 17 18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20 individually for the purpose of encoding or decoding bit streams in products that are compliant with 21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23 software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27 applications information and documentation. 28 29 2. COPYRIGHT LICENSE 30 31 Redistribution and use in source and binary forms, with or without modification, are permitted without 32 payment of copyright license fees provided that you satisfy the following conditions: 33 34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35 your modifications thereto in source code form. 36 37 You must retain the complete text of this software license in the documentation and/or other materials 38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40 modifications thereto to recipients of copies in binary form. 41 42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43 prior written permission. 44 45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46 software or your modifications thereto. 47 48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49 and the date of any change. For modified versions of the FDK AAC Codec, the term 50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term 51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." 52 53 3. NO PATENT LICENSE 54 55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57 respect to this software. 58 59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60 by appropriate patent licenses. 61 62 4. DISCLAIMER 63 64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors 65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties 66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69 or business interruption, however caused and on any theory of liability, whether in contract, strict 70 liability, or tort (including negligence), arising in any way out of the use of this software, even if 71 advised of the possibility of such damage. 72 73 5. CONTACT INFORMATION 74 75 Fraunhofer Institute for Integrated Circuits IIS 76 Attention: Audio and Multimedia Departments - FDK AAC LL 77 Am Wolfsmantel 33 78 91058 Erlangen, Germany 79 80 www.iis.fraunhofer.de/amm 81 amm-info (at) iis.fraunhofer.de 82 ----------------------------------------------------------------------------------------------------------- */ 83 84 #include "psdec_hybrid.h" 85 86 87 #include "fft.h" 88 #include "sbr_ram.h" 89 90 #include "FDK_tools_rom.h" 91 #include "sbr_rom.h" 92 93 /******************************************************************************* 94 Functionname: InitHybridFilterBank 95 ******************************************************************************* 96 97 Description: Init one instance of HANDLE_HYBRID stuct 98 99 Arguments: 100 101 Return: none 102 103 *******************************************************************************/ 104 105 106 SBR_ERROR 107 InitHybridFilterBank ( HANDLE_HYBRID hs, /*!< Handle to HYBRID struct. */ 108 SCHAR frameSize, /*!< Framesize (in Qmf sbband samples). */ 109 SCHAR noBands, /*!< Number of Qmf bands for hybrid filtering. */ 110 const UCHAR *pResolution ) /*!< Resolution in Qmf bands (length noBands). */ 111 { 112 SCHAR i; 113 UCHAR maxNoChannels = 0; 114 115 for (i = 0; i < noBands; i++) { 116 hs->pResolution[i] = pResolution[i]; 117 if(pResolution[i] > maxNoChannels) 118 maxNoChannels = pResolution[i]; 119 } 120 121 hs->nQmfBands = noBands; 122 hs->frameSize = frameSize; 123 hs->qmfBufferMove = HYBRID_FILTER_LENGTH - 1; 124 125 hs->sf_mQmfBuffer = 0; 126 127 return SBRDEC_OK; 128 } 129 130 /******************************************************************************* 131 Functionname: dualChannelFiltering 132 ******************************************************************************* 133 134 Description: fast 2-channel real-valued filtering with 6-tap delay. 135 136 Arguments: 137 138 Return: none 139 140 *******************************************************************************/ 141 142 /*! 143 2 channel filter 144 <pre> 145 Filter Coefs: 146 0.0, 147 0.01899487526049, 148 0.0, 149 -0.07293139167538, 150 0.0, 151 0.30596630545168, 152 0.5, 153 0.30596630545168, 154 0.0, 155 -0.07293139167538, 156 0.0, 157 0.01899487526049, 158 0.0 159 160 161 Filter design: 162 h[q,n] = g[n] * cos(2pi/2 * q * (n-6) ); n = 0..12, q = 0,1; 163 164 -> h[0,n] = g[n] * 1; 165 -> h[1,n] = g[n] * pow(-1,n); 166 </pre> 167 */ 168 169 static void slotBasedDualChannelFiltering( const FIXP_DBL *pQmfReal, 170 const FIXP_DBL *pQmfImag, 171 172 FIXP_DBL *mHybridReal, 173 FIXP_DBL *mHybridImag) 174 { 175 176 FIXP_DBL t1, t3, t5, t6; 177 178 /* symmetric filter coefficients */ 179 180 /* you don't have to shift the result after fMult because of p2_13_20 <= 0.5 */ 181 t1 = fMultDiv2(p2_13_20[1] , ( (pQmfReal[1] >> 1) + (pQmfReal[11] >> 1))); 182 t3 = fMultDiv2(p2_13_20[3] , ( (pQmfReal[3] >> 1) + (pQmfReal[ 9] >> 1))); 183 t5 = fMultDiv2(p2_13_20[5] , ( (pQmfReal[5] >> 1) + (pQmfReal[ 7] >> 1))); 184 t6 = fMultDiv2(p2_13_20[6] , (pQmfReal[6] >> 1) ); 185 186 mHybridReal[0] = (t1 + t3 + t5 + t6) << 2; 187 mHybridReal[1] = (- t1 - t3 - t5 + t6) << 2; 188 189 t1 = fMultDiv2(p2_13_20[1] , ( (pQmfImag[1] >> 1) + (pQmfImag[11] >> 1))); 190 t3 = fMultDiv2(p2_13_20[3] , ( (pQmfImag[3] >> 1) + (pQmfImag[ 9] >> 1))); 191 t5 = fMultDiv2(p2_13_20[5] , ( (pQmfImag[5] >> 1) + (pQmfImag[ 7] >> 1))); 192 t6 = fMultDiv2(p2_13_20[6] , pQmfImag[6] >> 1 ); 193 194 mHybridImag[0] = (t1 + t3 + t5 + t6) << 2; 195 mHybridImag[1] = (- t1 - t3 - t5 + t6) << 2; 196 } 197 198 199 /******************************************************************************* 200 Functionname: eightChannelFiltering 201 ******************************************************************************* 202 203 Description: fast 8-channel complex-valued filtering with 6-tap delay. 204 205 Arguments: 206 207 Return: none 208 209 *******************************************************************************/ 210 /*! 211 8 channel filter 212 213 Implementation using a FFT of length 8 214 <pre> 215 prototype filter coefficients: 216 0.00746082949812 0.02270420949825 0.04546865930473 0.07266113929591 0.09885108575264 0.11793710567217 217 0.125 218 0.11793710567217 0.09885108575264 0.07266113929591 0.04546865930473 0.02270420949825 0.00746082949812 219 220 Filter design: 221 N = 13; Q = 8; 222 h[q,n] = g[n] * exp(j * 2 * pi / Q * (q + .5) * (n - 6)); n = 0..(N-1), q = 0..(Q-1); 223 224 Time Signal: x[t]; 225 Filter Bank Output 226 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); 227 228 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] 229 + x[t - 8]*h[q, 8] + x[t - 7]*h[q, 7] 230 + x[t - 6]*h[q, 6] 231 + x[t - 5]*h[q, 5] + x[t - 4]*h[q, 4] 232 + x[t - 3]*h[q, 3] + x[t - 2]*h[q, 2] + x[t - 1]*h[q, 1] + x[t - 0]*h[q, 0]; 233 234 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); 235 236 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] 237 + x[t - 8]*h'[q, 4] + x[t - 7]*h'[q, 5] 238 + x[t - 6]*h'[q, 6] 239 + x[t - 5]*h'[q, 7] + x[t - 4]*h'[q, 8] 240 + x[t - 3]*h'[q, 9] + x[t - 2]*h'[q, 10] + x[t - 1]*h'[q, 11] + x[t - 0]*h'[q, 12]; 241 242 Try to split off FFT Modulation Term: 243 FFT(x[t], q) = sum(x[t+k]*exp(-j*2*pi/N *q * k)) 244 c m 245 Step 1: h'[q,n] = g[n] * ( exp(j * 2 * pi / 8 * .5 * (6 - n)) ) * ( exp (j * 2 * pi / 8 * q * (6 - n)) ); 246 247 h'[q,n] = g[n] *c[n] * m[q,n]; (see above) 248 c[n] = exp( j * 2 * pi / 8 * .5 * (6 - n) ); 249 m[q,n] = exp( j * 2 * pi / 8 * q * (6 - n) ); 250 251 y[q,t] = x[t - 0]*g[0]*c[0]*m[q,0] + x[t - 1]*g[1]*c[ 1]*m[q, 1] + ... 252 ... + x[t - 12]*g[2]*c[12]*m[q,12]; 253 254 | 255 n m *exp(-j*2*pi) | n' fft 256 ------------------------------------------------------------------------------------------------------------------------- 257 0 exp( j * 2 * pi / 8 * q * 6) -> exp(-j * 2 * pi / 8 * q * 2) | 2 exp(-j * 2 * pi / 8 * q * 0) 258 1 exp( j * 2 * pi / 8 * q * 5) -> exp(-j * 2 * pi / 8 * q * 3) | 3 exp(-j * 2 * pi / 8 * q * 1) 259 2 exp( j * 2 * pi / 8 * q * 4) -> exp(-j * 2 * pi / 8 * q * 4) | 4 exp(-j * 2 * pi / 8 * q * 2) 260 3 exp( j * 2 * pi / 8 * q * 3) -> exp(-j * 2 * pi / 8 * q * 5) | 5 exp(-j * 2 * pi / 8 * q * 3) 261 4 exp( j * 2 * pi / 8 * q * 2) -> exp(-j * 2 * pi / 8 * q * 6) | 6 exp(-j * 2 * pi / 8 * q * 4) 262 5 exp( j * 2 * pi / 8 * q * 1) -> exp(-j * 2 * pi / 8 * q * 7) | 7 exp(-j * 2 * pi / 8 * q * 5) 263 6 exp( j * 2 * pi / 8 * q * 0) | 0 exp(-j * 2 * pi / 8 * q * 6) 264 7 exp(-j * 2 * pi / 8 * q * 1) | 1 exp(-j * 2 * pi / 8 * q * 7) 265 8 exp(-j * 2 * pi / 8 * q * 2) | 2 266 9 exp(-j * 2 * pi / 8 * q * 3) | 3 267 10 exp(-j * 2 * pi / 8 * q * 4) | 4 268 11 exp(-j * 2 * pi / 8 * q * 5) | 5 269 12 exp(-j * 2 * pi / 8 * q * 6) | 6 270 271 272 now use fft modulation coefficients 273 m[6] = = fft[0] 274 m[7] = = fft[1] 275 m[8] = m[ 0] = fft[2] 276 m[9] = m[ 1] = fft[3] 277 m[10] = m[ 2] = fft[4] 278 m[11] = m[ 3] = fft[5] 279 m[12] = m[ 4] = fft[6] 280 m[ 5] = fft[7] 281 282 y[q,t] = ( x[t- 6]*g[ 6]*c[ 6] ) * fft[q,0] + 283 ( x[t- 7]*g[ 7]*c[ 7] ) * fft[q,1] + 284 ( x[t- 0]*g[ 0]*c[ 0] + x[t- 8]*g[ 8]*c[ 8] ) * fft[q,2] + 285 ( x[t- 1]*g[ 1]*c[ 1] + x[t- 9]*g[ 9]*c[ 9] ) * fft[q,3] + 286 ( x[t- 2]*g[ 2]*c[ 2] + x[t-10]*g[10]*c[10] ) * fft[q,4] + 287 ( x[t- 3]*g[ 3]*c[ 3] + x[t-11]*g[11]*c[11] ) * fft[q,5] + 288 ( x[t- 4]*g[ 4]*c[ 4] + x[t-12]*g[12]*c[12] ) * fft[q,6] + 289 ( x[t- 5]*g[ 5]*c[ 5] ) * fft[q,7]; 290 291 pre twiddle factors c[n] = exp(j * 2 * pi / 8 * .5 * (6 - n)); 292 n c] | n c[n] | n c[n] 293 --------------------------------------------------------------------------------------------------- 294 0 exp( j * 6 * pi / 8) | 1 exp( j * 5 * pi / 8) | 2 exp( j * 4 * pi / 8) 295 3 exp( j * 3 * pi / 8) | 4 exp( j * 2 * pi / 8) | 5 exp( j * 1 * pi / 8) 296 6 exp( j * 0 * pi / 8) | 7 exp(-j * 1 * pi / 8) | 8 exp(-j * 2 * pi / 8) 297 9 exp(-j * 3 * pi / 8) | 10 exp(-j * 4 * pi / 8) | 11 exp(-j * 5 * pi / 8) 298 12 exp(-j * 6 * pi / 8) | | 299 </pre> 300 */ 301 302 /* defining rotation factors for *ChannelFiltering */ 303 304 #define cos0Pi FL2FXCONST_DBL( 1.f) 305 #define sin0Pi FL2FXCONST_DBL( 0.f) 306 307 #define cos1Pi FL2FXCONST_DBL(-1.f) 308 #define sin1Pi FL2FXCONST_DBL( 0.f) 309 310 #define cos1Pi_2 FL2FXCONST_DBL( 0.f) 311 #define sin1Pi_2 FL2FXCONST_DBL( 1.f) 312 313 #define cos1Pi_3 FL2FXCONST_DBL( 0.5f) 314 #define sin1Pi_3 FL2FXCONST_DBL( 0.86602540378444f) 315 316 #define cos0Pi_4 cos0Pi 317 #define cos1Pi_4 FL2FXCONST_DBL(0.70710678118655f) 318 #define cos2Pi_4 cos1Pi_2 319 #define cos3Pi_4 (-cos1Pi_4) 320 #define cos4Pi_4 (-cos0Pi_4) 321 #define cos5Pi_4 cos3Pi_4 322 #define cos6Pi_4 cos2Pi_4 323 324 #define sin0Pi_4 sin0Pi 325 #define sin1Pi_4 FL2FXCONST_DBL(0.70710678118655f) 326 #define sin2Pi_4 sin1Pi_2 327 #define sin3Pi_4 sin1Pi_4 328 #define sin4Pi_4 sin0Pi_4 329 #define sin5Pi_4 (-sin3Pi_4) 330 #define sin6Pi_4 (-sin2Pi_4) 331 332 #define cos0Pi_8 cos0Pi 333 #define cos1Pi_8 FL2FXCONST_DBL(0.92387953251129f) 334 #define cos2Pi_8 cos1Pi_4 335 #define cos3Pi_8 FL2FXCONST_DBL(0.38268343236509f) 336 #define cos4Pi_8 cos2Pi_4 337 #define cos5Pi_8 (-cos3Pi_8) 338 #define cos6Pi_8 (-cos2Pi_8) 339 340 #define sin0Pi_8 sin0Pi 341 #define sin1Pi_8 cos3Pi_8 342 #define sin2Pi_8 sin1Pi_4 343 #define sin3Pi_8 cos1Pi_8 344 #define sin4Pi_8 sin2Pi_4 345 #define sin5Pi_8 sin3Pi_8 346 #define sin6Pi_8 sin1Pi_4 347 348 #if defined(ARCH_PREFER_MULT_32x16) 349 #define FIXP_HYB FIXP_SGL 350 #define FIXP_CAST FX_DBL2FX_SGL 351 #else 352 #define FIXP_HYB FIXP_DBL 353 #define FIXP_CAST 354 #endif 355 356 static const FIXP_HYB cr[13] = 357 { 358 FIXP_CAST(cos6Pi_8), FIXP_CAST(cos5Pi_8), FIXP_CAST(cos4Pi_8), 359 FIXP_CAST(cos3Pi_8), FIXP_CAST(cos2Pi_8), FIXP_CAST(cos1Pi_8), 360 FIXP_CAST(cos0Pi_8), 361 FIXP_CAST(cos1Pi_8), FIXP_CAST(cos2Pi_8), FIXP_CAST(cos3Pi_8), 362 FIXP_CAST(cos4Pi_8), FIXP_CAST(cos5Pi_8), FIXP_CAST(cos6Pi_8) 363 }; 364 365 static const FIXP_HYB ci[13] = 366 { 367 FIXP_CAST( sin6Pi_8), FIXP_CAST( sin5Pi_8), FIXP_CAST( sin4Pi_8), 368 FIXP_CAST( sin3Pi_8), FIXP_CAST( sin2Pi_8), FIXP_CAST( sin1Pi_8), 369 FIXP_CAST( sin0Pi_8) , 370 FIXP_CAST(-sin1Pi_8), FIXP_CAST(-sin2Pi_8), FIXP_CAST(-sin3Pi_8), 371 FIXP_CAST(-sin4Pi_8), FIXP_CAST(-sin5Pi_8), FIXP_CAST(-sin6Pi_8) 372 }; 373 374 static void slotBasedEightChannelFiltering( const FIXP_DBL *pQmfReal, 375 const FIXP_DBL *pQmfImag, 376 377 FIXP_DBL *mHybridReal, 378 FIXP_DBL *mHybridImag) 379 { 380 381 int bin; 382 FIXP_DBL _fft[128 + ALIGNMENT_DEFAULT - 1]; 383 FIXP_DBL *fft = (FIXP_DBL *)ALIGN_PTR(_fft); 384 385 #if defined(ARCH_PREFER_MULT_32x16) 386 const FIXP_SGL *p = p8_13_20; /* BASELINE_PS */ 387 #else 388 const FIXP_DBL *p = p8_13_20; /* BASELINE_PS */ 389 #endif 390 391 /* pre twiddeling */ 392 393 /* x*(a*b + c*d) = fMultDiv2(x, fMultAddDiv2(fMultDiv2(a, b), c, d)) */ 394 /* x*(a*b - c*d) = fMultDiv2(x, fMultSubDiv2(fMultDiv2(a, b), c, d)) */ 395 FIXP_DBL accu1, accu2, accu3, accu4; 396 397 #define TWIDDLE_1(n_0,n_1,n_2) \ 398 cplxMultDiv2(&accu1, &accu2, pQmfReal[n_0], pQmfImag[n_0], cr[n_0], ci[n_0]); \ 399 accu1 = fMultDiv2(p[n_0], accu1); \ 400 accu2 = fMultDiv2(p[n_0], accu2); \ 401 cplxMultDiv2(&accu3, &accu4, pQmfReal[n_1], pQmfImag[n_1], cr[n_1], ci[n_1]); \ 402 accu3 = fMultDiv2(p[n_1], accu3); \ 403 accu4 = fMultDiv2(p[n_1], accu4); \ 404 fft[FIXP_FFT_IDX_R(n_2)] = accu1 + accu3; \ 405 fft[FIXP_FFT_IDX_I(n_2)] = accu2 + accu4; 406 407 #define TWIDDLE_0(n_0,n_1) \ 408 cplxMultDiv2(&accu1, &accu2, pQmfReal[n_0], pQmfImag[n_0], cr[n_0], ci[n_0]); \ 409 fft[FIXP_FFT_IDX_R(n_1)] = fMultDiv2(p[n_0], accu1); \ 410 fft[FIXP_FFT_IDX_I(n_1)] = fMultDiv2(p[n_0], accu2); 411 412 TWIDDLE_0( 6, 0) 413 TWIDDLE_0( 7, 1) 414 415 TWIDDLE_1( 0, 8, 2) 416 TWIDDLE_1( 1, 9, 3) 417 TWIDDLE_1( 2,10, 4) 418 TWIDDLE_1( 3,11, 5) 419 TWIDDLE_1( 4,12, 6) 420 421 TWIDDLE_0( 5, 7) 422 423 fft_8 (fft); 424 425 /* resort fft data into output array*/ 426 for(bin=0; bin<8;bin++ ) { 427 mHybridReal[bin] = fft[FIXP_FFT_IDX_R(bin)] << 4; 428 mHybridImag[bin] = fft[FIXP_FFT_IDX_I(bin)] << 4; 429 } 430 } 431 432 433 /******************************************************************************* 434 Functionname: fillHybridDelayLine 435 ******************************************************************************* 436 437 Description: The delay line of the hybrid filter is filled and copied from 438 left to right. 439 440 Return: none 441 442 *******************************************************************************/ 443 444 void 445 fillHybridDelayLine( FIXP_DBL **fixpQmfReal, /*!< Qmf real Values */ 446 FIXP_DBL **fixpQmfImag, /*!< Qmf imag Values */ 447 FIXP_DBL fixpHybridLeftR[12], /*!< Hybrid real Values left channel */ 448 FIXP_DBL fixpHybridLeftI[12], /*!< Hybrid imag Values left channel */ 449 FIXP_DBL fixpHybridRightR[12], /*!< Hybrid real Values right channel */ 450 FIXP_DBL fixpHybridRightI[12], /*!< Hybrid imag Values right channel */ 451 HANDLE_HYBRID hHybrid ) 452 { 453 int i; 454 455 for (i = 0; i < HYBRID_FILTER_DELAY; i++) { 456 slotBasedHybridAnalysis ( fixpQmfReal[i], 457 fixpQmfReal[i], 458 fixpHybridLeftR, 459 fixpHybridLeftI, 460 hHybrid ); 461 } 462 463 FDKmemcpy(fixpHybridRightR, fixpHybridLeftR, sizeof(FIXP_DBL)*NO_SUB_QMF_CHANNELS); 464 FDKmemcpy(fixpHybridRightI, fixpHybridLeftI, sizeof(FIXP_DBL)*NO_SUB_QMF_CHANNELS); 465 } 466 467 468 /******************************************************************************* 469 Functionname: slotBasedHybridAnalysis 470 ******************************************************************************* 471 472 Description: The lower QMF subbands are further split to provide better 473 frequency resolution for PS processing. 474 475 Return: none 476 477 *******************************************************************************/ 478 479 480 void 481 slotBasedHybridAnalysis ( FIXP_DBL *fixpQmfReal, /*!< Qmf real Values */ 482 FIXP_DBL *fixpQmfImag, /*!< Qmf imag Values */ 483 484 FIXP_DBL fixpHybridReal[12], /*!< Hybrid real Values */ 485 FIXP_DBL fixpHybridImag[12], /*!< Hybrid imag Values */ 486 487 HANDLE_HYBRID hHybrid) 488 { 489 int k, band; 490 HYBRID_RES hybridRes; 491 int chOffset = 0; 492 493 C_ALLOC_SCRATCH_START(pTempRealSlot, FIXP_DBL, 4*HYBRID_FILTER_LENGTH); 494 495 FIXP_DBL *pTempImagSlot = pTempRealSlot + HYBRID_FILTER_LENGTH; 496 FIXP_DBL *pWorkRealSlot = pTempImagSlot + HYBRID_FILTER_LENGTH; 497 FIXP_DBL *pWorkImagSlot = pWorkRealSlot + HYBRID_FILTER_LENGTH; 498 499 /*! 500 Hybrid filtering is applied to the first hHybrid->nQmfBands QMF bands (3 when 10 or 20 stereo bands 501 are used, 5 when 34 stereo bands are used). For the remaining QMF bands a delay would be necessary. 502 But there is no need to implement a delay because there is a look-ahead of HYBRID_FILTER_DELAY = 6 503 QMF samples in the low-band buffer. 504 */ 505 506 for(band = 0; band < hHybrid->nQmfBands; band++) { 507 508 /* get hybrid resolution per qmf band */ 509 /* in case of baseline ps 10/20 band stereo mode : */ 510 /* */ 511 /* qmfBand[0] : 8 ( HYBRID_8_CPLX ) */ 512 /* qmfBand[1] : 2 ( HYBRID_2_REAL ) */ 513 /* qmfBand[2] : 2 ( HYBRID_2_REAL ) */ 514 /* */ 515 /* (split the 3 lower qmf band to 12 hybrid bands) */ 516 517 hybridRes = (HYBRID_RES)hHybrid->pResolution[band]; 518 519 FDKmemcpy(pWorkRealSlot, hHybrid->mQmfBufferRealSlot[band], hHybrid->qmfBufferMove * sizeof(FIXP_DBL)); 520 FDKmemcpy(pWorkImagSlot, hHybrid->mQmfBufferImagSlot[band], hHybrid->qmfBufferMove * sizeof(FIXP_DBL)); 521 522 pWorkRealSlot[hHybrid->qmfBufferMove] = fixpQmfReal[band]; 523 pWorkImagSlot[hHybrid->qmfBufferMove] = fixpQmfImag[band]; 524 525 FDKmemcpy(hHybrid->mQmfBufferRealSlot[band], pWorkRealSlot + 1, hHybrid->qmfBufferMove * sizeof(FIXP_DBL)); 526 FDKmemcpy(hHybrid->mQmfBufferImagSlot[band], pWorkImagSlot + 1, hHybrid->qmfBufferMove * sizeof(FIXP_DBL)); 527 528 if (fixpQmfReal) { 529 530 /* actual filtering only if output signal requested */ 531 switch( hybridRes ) { 532 533 /* HYBRID_2_REAL & HYBRID_8_CPLX are only needful for baseline ps */ 534 case HYBRID_2_REAL: 535 536 slotBasedDualChannelFiltering( pWorkRealSlot, 537 pWorkImagSlot, 538 pTempRealSlot, 539 pTempImagSlot); 540 break; 541 542 case HYBRID_8_CPLX: 543 544 slotBasedEightChannelFiltering( pWorkRealSlot, 545 pWorkImagSlot, 546 pTempRealSlot, 547 pTempImagSlot); 548 break; 549 550 default: 551 FDK_ASSERT(0); 552 } 553 554 for(k = 0; k < (SCHAR)hybridRes; k++) { 555 fixpHybridReal [chOffset + k] = pTempRealSlot[k]; 556 fixpHybridImag [chOffset + k] = pTempImagSlot[k]; 557 } 558 chOffset += hybridRes; 559 } /* if (mHybridReal) */ 560 } 561 562 /* group hybrid channels 3+4 -> 3 and 2+5 -> 2 */ 563 fixpHybridReal[3] += fixpHybridReal[4]; 564 fixpHybridImag[3] += fixpHybridImag[4]; 565 fixpHybridReal[4] = (FIXP_DBL)0; 566 fixpHybridImag[4] = (FIXP_DBL)0; 567 568 fixpHybridReal[2] += fixpHybridReal[5]; 569 fixpHybridImag[2] += fixpHybridImag[5]; 570 fixpHybridReal[5] = (FIXP_DBL)0; 571 fixpHybridImag[5] = (FIXP_DBL)0; 572 573 /* free memory on scratch */ 574 C_ALLOC_SCRATCH_END(pTempRealSlot, FIXP_DBL, 4*HYBRID_FILTER_LENGTH); 575 576 } 577 578 579 /******************************************************************************* 580 Functionname: slotBasedHybridSynthesis 581 ******************************************************************************* 582 583 Description: The coefficients offering higher resolution for the lower QMF 584 channel are simply added prior to the synthesis with the 54 585 subbands QMF. 586 587 Arguments: 588 589 Return: none 590 591 *******************************************************************************/ 592 593 /*! <pre> 594 l,r0(n) ---\ 595 l,r1(n) ---- + --\ 596 l,r2(n) ---/ \ 597 + --> F0(w) 598 l,r3(n) ---\ / 599 l,r4(n) ---- + --/ 600 l,r5(n) ---/ 601 602 603 l,r6(n) ---\ 604 + ---------> F1(w) 605 l,r7(n) ---/ 606 607 608 l,r8(n) ---\ 609 + ---------> F2(w) 610 l,r9(n) ---/ 611 612 </pre> 613 Hybrid QMF synthesis filterbank for the 10 and 20 stereo-bands configurations. The 614 coefficients offering higher resolution for the lower QMF channel are simply added 615 prior to the synthesis with the 54 subbands QMF. 616 617 [see ISO/IEC 14496-3:2001/FDAM 2:2004(E) - Page 52] 618 */ 619 620 621 void 622 slotBasedHybridSynthesis ( FIXP_DBL *fixpHybridReal, /*!< Hybrid real Values */ 623 FIXP_DBL *fixpHybridImag, /*!< Hybrid imag Values */ 624 FIXP_DBL *fixpQmfReal, /*!< Qmf real Values */ 625 FIXP_DBL *fixpQmfImag, /*!< Qmf imag Values */ 626 HANDLE_HYBRID hHybrid ) /*!< Handle to HYBRID struct. */ 627 { 628 int k, band; 629 630 HYBRID_RES hybridRes; 631 int chOffset = 0; 632 633 for(band = 0; band < hHybrid->nQmfBands; band++) { 634 635 FIXP_DBL qmfReal = FL2FXCONST_DBL(0.f); 636 FIXP_DBL qmfImag = FL2FXCONST_DBL(0.f); 637 hybridRes = (HYBRID_RES)hHybrid->pResolution[band]; 638 639 for(k = 0; k < (SCHAR)hybridRes; k++) { 640 qmfReal += fixpHybridReal[chOffset + k]; 641 qmfImag += fixpHybridImag[chOffset + k]; 642 } 643 644 fixpQmfReal[band] = qmfReal; 645 fixpQmfImag[band] = qmfImag; 646 647 chOffset += hybridRes; 648 } 649 } 650 651 652 653
