开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
imdct.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：28k
源码类别：

Symbian

开发平台：

Visual C++

imdct.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /**************************************************************************************
  37.  * Fixed-point MP3 decoder
  38.  * Jon Recker (jrecker@real.com), Ken Cooke (kenc@real.com)
  39.  * June 2003
  40.  *
  41.  * imdct.c - antialias, inverse transform (short/long/mixed), windowing, 
  42.  *             overlap-add, frequency inversion
  43.  **************************************************************************************/
  45. #include "coder.h"
  46. #include "assembly.h"
  48. /**************************************************************************************
  49.  * Function:    AntiAlias
  50.  *
  51.  * Description: smooth transition across DCT block boundaries (every 18 coefficients)
  52.  *
  53.  * Inputs:      vector of dequantized coefficients, length = (nBfly+1) * 18
  54.  *              number of "butterflies" to perform (one butterfly means one
  55.  *                inter-block smoothing operation)
  56.  *
  57.  * Outputs:     updated coefficient vector x
  58.  *
  59.  * Return:      none
  60.  *
  61.  * Notes:       weighted average of opposite bands (pairwise) from the 8 samples 
  62.  *                before and after each block boundary
  63.  *              nBlocks = (nonZeroBound + 7) / 18, since nZB is the first ZERO sample 
  64.  *                above which all other samples are also zero
  65.  *              max gain per sample = 1.372
  66.  *                MAX(i) (abs(csa[i][0]) + abs(csa[i][1]))
  67.  *              bits gained = 0
  68.  *              assume at least 1 guard bit in x[] to avoid overflow
  69.  *                (should be guaranteed from dequant, and max gain from stproc * max 
  70.  *                 gain from AntiAlias < 2.0)
  71.  **************************************************************************************/
  72. static void AntiAlias(int *x, int nBfly)
  73. {
  74. int k, a0, b0, c0, c1;
  75. const int *c;
  77. /* csa = Q31 */
  78. for (k = nBfly; k > 0; k--) {
  79. c = csa[0];
  80. x += 18;
  82. a0 = x[-1]; c0 = *c; c++; b0 = x[0]; c1 = *c; c++;
  83. x[-1] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  84. x[0] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  86. a0 = x[-2]; c0 = *c; c++; b0 = x[1]; c1 = *c; c++;
  87. x[-2] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  88. x[1] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  90. a0 = x[-3]; c0 = *c; c++; b0 = x[2]; c1 = *c; c++;
  91. x[-3] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  92. x[2] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  94. a0 = x[-4]; c0 = *c; c++; b0 = x[3]; c1 = *c; c++;
  95. x[-4] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  96. x[3] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  98. a0 = x[-5]; c0 = *c; c++; b0 = x[4]; c1 = *c; c++;
  99. x[-5] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  100. x[4] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  102. a0 = x[-6]; c0 = *c; c++; b0 = x[5]; c1 = *c; c++;
  103. x[-6] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  104. x[5] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  106. a0 = x[-7]; c0 = *c; c++; b0 = x[6]; c1 = *c; c++;
  107. x[-7] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  108. x[6] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  110. a0 = x[-8]; c0 = *c; c++; b0 = x[7]; c1 = *c; c++;
  111. x[-8] = (MULSHIFT32(c0, a0) - MULSHIFT32(c1, b0)) << 1;
  112. x[7] =  (MULSHIFT32(c0, b0) + MULSHIFT32(c1, a0)) << 1;
  113. }
  114. }
  116. /**************************************************************************************
  117.  * Function:    WinPrevious
  118.  *
  119.  * Description: apply specified window to second half of previous IMDCT (overlap part)
  120.  *
  121.  * Inputs:      vector of 9 coefficients (xPrev)
  122.  *
  123.  * Outputs:     18 windowed output coefficients (gain 1 integer bit)
  124.  *              window type (0, 1, 2, 3)
  125.  *
  126.  * Return:      none
  127.  * 
  128.  * Notes:       produces 9 output samples from 18 input samples via symmetry
  129.  *              all blocks gain at least 1 guard bit via window (long blocks get extra
  130.  *                sign bit, short blocks can have one addition but max gain < 1.0)
  131.  **************************************************************************************/
  132. static void WinPrevious(int *xPrev, int *xPrevWin, int btPrev)
  133. {
  134. int i, x, *xp, *xpwLo, *xpwHi, wLo, wHi;
  135. const int *wpLo, *wpHi;
  137. xp = xPrev;
  138. /* mapping (see IMDCT12x3): xPrev[0-2] = sum[6-8], xPrev[3-8] = sum[12-17] */
  139. if (btPrev == 2) {
  140. /* this could be reordered for minimum loads/stores */
  141. wpLo = imdctWin[btPrev];
  142. xPrevWin[ 0] = MULSHIFT32(wpLo[ 6], xPrev[2]) + MULSHIFT32(wpLo[0], xPrev[6]);
  143. xPrevWin[ 1] = MULSHIFT32(wpLo[ 7], xPrev[1]) + MULSHIFT32(wpLo[1], xPrev[7]);
  144. xPrevWin[ 2] = MULSHIFT32(wpLo[ 8], xPrev[0]) + MULSHIFT32(wpLo[2], xPrev[8]);
  145. xPrevWin[ 3] = MULSHIFT32(wpLo[ 9], xPrev[0]) + MULSHIFT32(wpLo[3], xPrev[8]);
  146. xPrevWin[ 4] = MULSHIFT32(wpLo[10], xPrev[1]) + MULSHIFT32(wpLo[4], xPrev[7]);
  147. xPrevWin[ 5] = MULSHIFT32(wpLo[11], xPrev[2]) + MULSHIFT32(wpLo[5], xPrev[6]);
  148. xPrevWin[ 6] = MULSHIFT32(wpLo[ 6], xPrev[5]);
  149. xPrevWin[ 7] = MULSHIFT32(wpLo[ 7], xPrev[4]);
  150. xPrevWin[ 8] = MULSHIFT32(wpLo[ 8], xPrev[3]);
  151. xPrevWin[ 9] = MULSHIFT32(wpLo[ 9], xPrev[3]);
  152. xPrevWin[10] = MULSHIFT32(wpLo[10], xPrev[4]);
  153. xPrevWin[11] = MULSHIFT32(wpLo[11], xPrev[5]);
  154. xPrevWin[12] = xPrevWin[13] = xPrevWin[14] = xPrevWin[15] = xPrevWin[16] = xPrevWin[17] = 0;
  155. } else {
  156. /* use ARM-style pointers (*ptr++) so that ADS compiles well */
  157. wpLo = imdctWin[btPrev] + 18;
  158. wpHi = wpLo + 17;
  159. xpwLo = xPrevWin;
  160. xpwHi = xPrevWin + 17;
  161. for (i = 9; i > 0; i--) {
  162. x = *xp++; wLo = *wpLo++; wHi = *wpHi--;
  163. *xpwLo++ = MULSHIFT32(wLo, x);
  164. *xpwHi-- = MULSHIFT32(wHi, x);
  165. }
  166. }
  167. }
  169. /**************************************************************************************
  170.  * Function:    FreqInvertRescale
  171.  *
  172.  * Description: do frequency inversion (odd samples of odd blocks) and rescale 
  173.  *                if necessary (extra guard bits added before IMDCT)
  174.  *
  175.  * Inputs:      output vector y (18 new samples, spaced NBANDS apart)
  176.  *              previous sample vector xPrev (9 samples)
  177.  *              index of current block
  178.  *              number of extra shifts added before IMDCT (usually 0)
  179.  *
  180.  * Outputs:     inverted and rescaled (as necessary) outputs
  181.  *              rescaled (as necessary) previous samples
  182.  *
  183.  * Return:      updated mOut (from new outputs y)
  184.  **************************************************************************************/
  185. static int FreqInvertRescale(int *y, int *xPrev, int blockIdx, int es)
  186. {
  187. int i, d, mOut;
  188. int y0, y1, y2, y3, y4, y5, y6, y7, y8;
  190. if (es == 0) {
  191. /* fast case - frequency invert only (no rescaling) - can fuse into overlap-add for speed, if desired */
  192. if (blockIdx & 0x01) {
  193. y += NBANDS;
  194. y0 = *y; y += 2*NBANDS;
  195. y1 = *y; y += 2*NBANDS;
  196. y2 = *y; y += 2*NBANDS;
  197. y3 = *y; y += 2*NBANDS;
  198. y4 = *y; y += 2*NBANDS;
  199. y5 = *y; y += 2*NBANDS;
  200. y6 = *y; y += 2*NBANDS;
  201. y7 = *y; y += 2*NBANDS;
  202. y8 = *y; y += 2*NBANDS;
  204. y -= 18*NBANDS;
  205. *y = -y0; y += 2*NBANDS;
  206. *y = -y1; y += 2*NBANDS;
  207. *y = -y2; y += 2*NBANDS;
  208. *y = -y3; y += 2*NBANDS;
  209. *y = -y4; y += 2*NBANDS;
  210. *y = -y5; y += 2*NBANDS;
  211. *y = -y6; y += 2*NBANDS;
  212. *y = -y7; y += 2*NBANDS;
  213. *y = -y8; y += 2*NBANDS;
  214. }
  215. return 0;
  216. } else {
  217. /* undo pre-IMDCT scaling, clipping if necessary */
  218. mOut = 0;
  219. if (blockIdx & 0x01) {
  220. /* frequency invert */
  221. for (i = 0; i < 18; i+=2) {
  222. d = *y; CLIP_2N(d, 31 - es); *y = d << es; mOut |= FASTABS(*y); y += NBANDS;
  223. d = -*y; CLIP_2N(d, 31 - es); *y = d << es; mOut |= FASTABS(*y); y += NBANDS;
  224. d = *xPrev; CLIP_2N(d, 31 - es); *xPrev++ = d << es;
  225. }
  226. } else {
  227. for (i = 0; i < 18; i+=2) {
  228. d = *y; CLIP_2N(d, 31 - es); *y = d << es; mOut |= FASTABS(*y); y += NBANDS;
  229. d = *y; CLIP_2N(d, 31 - es); *y = d << es; mOut |= FASTABS(*y); y += NBANDS;
  230. d = *xPrev; CLIP_2N(d, 31 - es); *xPrev++ = d << es;
  231. }
  232. }
  233. return mOut;
  234. }
  235. }
  237. /* format = Q31
  238.  * #define M_PI 3.14159265358979323846
  239.  * double u = 2.0 * M_PI / 9.0;
  240.  * float c0 = sqrt(3.0) / 2.0; 
  241.  * float c1 = cos(u);          
  242.  * float c2 = cos(2*u);        
  243.  * float c3 = sin(u);          
  244.  * float c4 = sin(2*u);
  245.  */
  246. static const int c9_0 = 0x6ed9eba1;
  247. static const int c9_1 = 0x620dbe8b;
  248. static const int c9_2 = 0x163a1a7e;
  249. static const int c9_3 = 0x5246dd49;
  250. static const int c9_4 = 0x7e0e2e32;
  252. /* format = Q31
  253.  * cos(((0:8) + 0.5) * (pi/18)) 
  254.  */
  255. static const int c18[9] = {
  256. 0x7f834ed0, 0x7ba3751d, 0x7401e4c1, 0x68d9f964, 0x5a82799a, 0x496af3e2, 0x36185aee, 0x2120fb83, 0x0b27eb5c, 
  257. };
  259. /* require at least 3 guard bits in x[] to ensure no overflow */
  260. static __inline void idct9(int *x)
  261. {
  262. int a1, a2, a3, a4, a5, a6, a7, a8, a9;
  263. int a10, a11, a12, a13, a14, a15, a16, a17, a18;
  264. int a19, a20, a21, a22, a23, a24, a25, a26, a27;
  265. int m1, m3, m5, m6, m7, m8, m9, m10, m11, m12;
  266. int x0, x1, x2, x3, x4, x5, x6, x7, x8;
  268. x0 = x[0]; x1 = x[1]; x2 = x[2]; x3 = x[3]; x4 = x[4];
  269. x5 = x[5]; x6 = x[6]; x7 = x[7]; x8 = x[8];
  271. a1 = x0 - x6;
  272. a2 = x1 - x5;
  273. a3 = x1 + x5;
  274. a4 = x2 - x4;
  275. a5 = x2 + x4;
  276. a6 = x2 + x8;
  277. a7 = x1 + x7;
  279. a8 = a6 - a5; /* ie x[8] - x[4] */
  280. a9 = a3 - a7; /* ie x[5] - x[7] */
  281. a10 = a2 - x7; /* ie x[1] - x[5] - x[7] */
  282. a11 = a4 - x8; /* ie x[2] - x[4] - x[8] */
  284. /* do the << 1 as constant shifts where mX is actually used (free, no stall or extra inst.) */
  285. m1 =  MULSHIFT32(c9_0, x3);
  286. m3 =  MULSHIFT32(c9_0, a10);
  287. m5 =  MULSHIFT32(c9_1, a5);
  288. m6 =  MULSHIFT32(c9_2, a6);
  289. m7 =  MULSHIFT32(c9_1, a8);
  290. m8 =  MULSHIFT32(c9_2, a5);
  291. m9 =  MULSHIFT32(c9_3, a9);
  292. m10 = MULSHIFT32(c9_4, a7);
  293. m11 = MULSHIFT32(c9_3, a3);
  294. m12 = MULSHIFT32(c9_4, a9);
  296. a12 = x[0] +  (x[6] >> 1);
  297. a13 = a12  +  (  m1 << 1);
  298. a14 = a12  -  (  m1 << 1);
  299. a15 = a1   +  ( a11 >> 1);
  300. a16 = ( m5 << 1) + (m6 << 1);
  301. a17 = ( m7 << 1) - (m8 << 1);
  302. a18 = a16 + a17;
  303. a19 = ( m9 << 1) + (m10 << 1);
  304. a20 = (m11 << 1) - (m12 << 1);
  306. a21 = a20 - a19;
  307. a22 = a13 + a16;
  308. a23 = a14 + a16;
  309. a24 = a14 + a17;
  310. a25 = a13 + a17;
  311. a26 = a14 - a18;
  312. a27 = a13 - a18;
  314. x0 = a22 + a19; x[0] = x0;
  315. x1 = a15 + (m3 << 1); x[1] = x1;
  316. x2 = a24 + a20; x[2] = x2;
  317. x3 = a26 - a21; x[3] = x3;
  318. x4 = a1 - a11; x[4] = x4;
  319. x5 = a27 + a21; x[5] = x5;
  320. x6 = a25 - a20; x[6] = x6;
  321. x7 = a15 - (m3 << 1); x[7] = x7;
  322. x8 = a23 - a19; x[8] = x8;
  323. }
  325. /* let c(j) = cos(M_PI/36 * ((j)+0.5)), s(j) = sin(M_PI/36 * ((j)+0.5))
  326.  * then fastWin[2*j+0] = c(j)*(s(j) + c(j)), j = [0, 8]
  327.  *      fastWin[2*j+1] = c(j)*(s(j) - c(j))
  328.  * format = Q30
  329.  */
  330. static const int fastWin36[18] = {
  331. 0x42aace8b, 0xc2e92724, 0x47311c28, 0xc95f619a, 0x4a868feb, 0xd0859d8c,
  332. 0x4c913b51, 0xd8243ea0, 0x4d413ccc, 0xe0000000, 0x4c913b51, 0xe7dbc161,
  333. 0x4a868feb, 0xef7a6275, 0x47311c28, 0xf6a09e67, 0x42aace8b, 0xfd16d8dd,
  334. };
  336. /**************************************************************************************
  337.  * Function:    IMDCT36
  338.  *
  339.  * Description: 36-point modified DCT, with windowing and overlap-add (50% overlap)
  340.  *
  341.  * Inputs:      vector of 18 coefficients (N/2 inputs produces N outputs, by symmetry)
  342.  *              overlap part of last IMDCT (9 samples - see output comments)
  343.  *              window type (0,1,2,3) of current and previous block
  344.  *              current block index (for deciding whether to do frequency inversion)
  345.  *              number of guard bits in input vector
  346.  *
  347.  * Outputs:     18 output samples, after windowing and overlap-add with last frame
  348.  *              second half of (unwindowed) 36-point IMDCT - save for next time
  349.  *                only save 9 xPrev samples, using symmetry (see WinPrevious())
  350.  *
  351.  * Notes:       this is Ken's hyper-fast algorithm, including symmetric sin window
  352.  *                optimization, if applicable
  353.  *              total number of multiplies, general case: 
  354.  *                2*10 (idct9) + 9 (last stage imdct) + 36 (for windowing) = 65
  355.  *              total number of multiplies, btCurr == 0 && btPrev == 0:
  356.  *                2*10 (idct9) + 9 (last stage imdct) + 18 (for windowing) = 47
  357.  *
  358.  *              blockType == 0 is by far the most common case, so it should be
  359.  *                possible to use the fast path most of the time
  360.  *              this is the fastest known algorithm for performing 
  361.  *                long IMDCT + windowing + overlap-add in MP3
  362.  *
  363.  * Return:      mOut (OR of abs(y) for all y calculated here)
  364.  *
  365.  * TODO:        optimize for ARM (reorder window coefs, ARM-style pointers in C, 
  366.  *                inline asm may or may not be helpful)
  367.  **************************************************************************************/
  368. static int IMDCT36(int *xCurr, int *xPrev, int *y, int btCurr, int btPrev, int blockIdx, int gb)
  369. {
  370. int i, es, xBuf[18], xPrevWin[18];
  371. int acc1, acc2, s, d, t, mOut;
  372. int xo, xe, c, *xp, yLo, yHi;
  373. const int *cp, *wp;
  375. acc1 = acc2 = 0;
  376. xCurr += 17;
  378. /* 7 gb is always adequate for antialias + accumulator loop + idct9 */
  379. if (gb < 7) {
  380. /* rarely triggered - 5% to 10% of the time on normal clips (with Q25 input) */
  381. es = 7 - gb;
  382. for (i = 8; i >= 0; i--) {
  383. acc1 = ((*xCurr--) >> es) - acc1;
  384. acc2 = acc1 - acc2;
  385. acc1 = ((*xCurr--) >> es) - acc1;
  386. xBuf[i+9] = acc2; /* odd */
  387. xBuf[i+0] = acc1; /* even */
  388. xPrev[i] >>= es;
  389. }
  390. } else {
  391. es = 0;
  392. /* max gain = 18, assume adequate guard bits */
  393. for (i = 8; i >= 0; i--) {
  394. acc1 = (*xCurr--) - acc1;
  395. acc2 = acc1 - acc2;
  396. acc1 = (*xCurr--) - acc1;
  397. xBuf[i+9] = acc2; /* odd */
  398. xBuf[i+0] = acc1; /* even */
  399. }
  400. }
  401. /* xEven[0] and xOdd[0] scaled by 0.5 */
  402. xBuf[9] >>= 1;
  403. xBuf[0] >>= 1;
  405. /* do 9-point IDCT on even and odd */
  406. idct9(xBuf+0); /* even */
  407. idct9(xBuf+9); /* odd */
  409. xp = xBuf + 8;
  410. cp = c18 + 8;
  411. mOut = 0;
  412. if (btPrev == 0 && btCurr == 0) {
  413. /* fast path - use symmetry of sin window to reduce windowing multiplies to 18 (N/2) */
  414. wp = fastWin36;
  415. for (i = 0; i < 9; i++) {
  416. /* do ARM-style pointer arithmetic (i still needed for y[] indexing - compiler spills if 2 y pointers) */
  417. c = *cp--; xo = *(xp + 9); xe = *xp--;
  418. /* gain 2 int bits here */
  419. xo = MULSHIFT32(c, xo); /* 2*c18*xOdd (mul by 2 implicit in scaling)  */
  420. xe >>= 2;
  422. s = -(*xPrev); /* sum from last block (always at least 2 guard bits) */
  423. d = -(xe - xo); /* gain 2 int bits, don't shift xo (effective << 1 to eat sign bit, << 1 for mul by 2) */
  424. (*xPrev++) = xe + xo; /* symmetry - xPrev[i] = xPrev[17-i] for long blocks */
  425. t = s - d;
  427. yLo = (d + (MULSHIFT32(t, *wp++) << 2));
  428. yHi = (s + (MULSHIFT32(t, *wp++) << 2));
  429. y[(i)*NBANDS]    =  yLo;
  430. y[(17-i)*NBANDS] =  yHi;
  431. mOut |= FASTABS(yLo);
  432. mOut |= FASTABS(yHi);
  433. }
  434. } else {
  435. /* slower method - either prev or curr is using window type != 0 so do full 36-point window 
  436.  * output xPrevWin has at least 3 guard bits (xPrev has 2, gain 1 in WinPrevious)
  437.  */
  438. WinPrevious(xPrev, xPrevWin, btPrev);
  440. wp = imdctWin[btCurr];
  441. for (i = 0; i < 9; i++) {
  442. c = *cp--; xo = *(xp + 9); xe = *xp--;
  443. /* gain 2 int bits here */
  444. xo = MULSHIFT32(c, xo); /* 2*c18*xOdd (mul by 2 implicit in scaling)  */
  445. xe >>= 2;
  447. d = xe - xo;
  448. (*xPrev++) = xe + xo; /* symmetry - xPrev[i] = xPrev[17-i] for long blocks */
  450. yLo = (xPrevWin[i]    + MULSHIFT32(d, wp[i])) << 2;
  451. yHi = (xPrevWin[17-i] + MULSHIFT32(d, wp[17-i])) << 2;
  452. y[(i)*NBANDS]    = yLo;
  453. y[(17-i)*NBANDS] = yHi;
  454. mOut |= FASTABS(yLo);
  455. mOut |= FASTABS(yHi);
  456. }
  457. }
  459. xPrev -= 9;
  460. mOut |= FreqInvertRescale(y, xPrev, blockIdx, es);
  462. return mOut;
  463. }
  465. static const int c3_0 = 0x6ed9eba1; /* format = Q31, cos(pi/6) */
  466. static const int c6[3] = { 0x7ba3751d, 0x5a82799a, 0x2120fb83 }; /* format = Q31, cos(((0:2) + 0.5) * (pi/6)) */
  468. /* 12-point inverse DCT, used in IMDCT12x3() 
  469.  * 4 input guard bits will ensure no overflow
  470.  */
  471. static __inline void imdct12 (int *x, int *out)
  472. {
  473. int a0, a1, a2;
  474. int x0, x1, x2, x3, x4, x5;
  476. x0 = *x; x+=3; x1 = *x; x+=3;
  477. x2 = *x; x+=3; x3 = *x; x+=3;
  478. x4 = *x; x+=3; x5 = *x; x+=3;
  480. x4 -= x5;
  481. x3 -= x4;
  482. x2 -= x3;
  483. x3 -= x5;
  484. x1 -= x2;
  485. x0 -= x1;
  486. x1 -= x3;
  488. x0 >>= 1;
  489. x1 >>= 1;
  491. a0 = MULSHIFT32(c3_0, x2) << 1;
  492. a1 = x0 + (x4 >> 1);
  493. a2 = x0 - x4;
  494. x0 = a1 + a0;
  495. x2 = a2;
  496. x4 = a1 - a0;
  498. a0 = MULSHIFT32(c3_0, x3) << 1;
  499. a1 = x1 + (x5 >> 1);
  500. a2 = x1 - x5;
  502. /* cos window odd samples, mul by 2, eat sign bit */
  503. x1 = MULSHIFT32(c6[0], a1 + a0) << 2;
  504. x3 = MULSHIFT32(c6[1], a2) << 2;
  505. x5 = MULSHIFT32(c6[2], a1 - a0) << 2;
  507. *out = x0 + x1; out++;
  508. *out = x2 + x3; out++;
  509. *out = x4 + x5; out++;
  510. *out = x4 - x5; out++;
  511. *out = x2 - x3; out++;
  512. *out = x0 - x1;
  513. }
  515. /**************************************************************************************
  516.  * Function:    IMDCT12x3
  517.  *
  518.  * Description: three 12-point modified DCT's for short blocks, with windowing,
  519.  *                short block concatenation, and overlap-add
  520.  *
  521.  * Inputs:      3 interleaved vectors of 6 samples each 
  522.  *                (block0[0], block1[0], block2[0], block0[1], block1[1]....)
  523.  *              overlap part of last IMDCT (9 samples - see output comments)
  524.  *              window type (0,1,2,3) of previous block
  525.  *              current block index (for deciding whether to do frequency inversion)
  526.  *              number of guard bits in input vector
  527.  *
  528.  * Outputs:     updated sample vector x, net gain of 1 integer bit
  529.  *              second half of (unwindowed) IMDCT's - save for next time
  530.  *                only save 9 xPrev samples, using symmetry (see WinPrevious())
  531.  *
  532.  * Return:      mOut (OR of abs(y) for all y calculated here)
  533.  *
  534.  * TODO:        optimize for ARM
  535.  **************************************************************************************/
  536. static int IMDCT12x3(int *xCurr, int *xPrev, int *y, int btPrev, int blockIdx, int gb)
  537. {
  538. int i, es, mOut, yLo, xBuf[18], xPrevWin[18]; /* need temp buffer for reordering short blocks */
  539. const int *wp;
  541. es = 0;
  542. /* 7 gb is always adequate for accumulator loop + idct12 + window + overlap */
  543. if (gb < 7) {
  544. es = 7 - gb;
  545. for (i = 0; i < 18; i+=2) {
  546. xCurr[i+0] >>= es;
  547. xCurr[i+1] >>= es;
  548. *xPrev++ >>= es;
  549. }
  550. xPrev -= 9;
  551. }
  553. /* requires 4 input guard bits for each imdct12 */
  554. imdct12(xCurr + 0, xBuf + 0);
  555. imdct12(xCurr + 1, xBuf + 6);
  556. imdct12(xCurr + 2, xBuf + 12);
  558. /* window previous from last time */
  559. WinPrevious(xPrev, xPrevWin, btPrev);
  561. /* could unroll this for speed, minimum loads (short blocks usually rare, so doesn't make much overall difference) 
  562.  * xPrevWin[i] << 2 still has 1 gb always, max gain of windowed xBuf stuff also < 1.0 and gain the sign bit
  563.  * so y calculations won't overflow
  564.  */
  565. wp = imdctWin[2];
  566. mOut = 0;
  567. for (i = 0; i < 3; i++) {
  568. yLo = (xPrevWin[ 0+i] << 2);
  569. mOut |= FASTABS(yLo); y[( 0+i)*NBANDS] = yLo;
  570. yLo = (xPrevWin[ 3+i] << 2);
  571. mOut |= FASTABS(yLo); y[( 3+i)*NBANDS] = yLo;
  572. yLo = (xPrevWin[ 6+i] << 2) + (MULSHIFT32(wp[0+i], xBuf[3+i]));
  573. mOut |= FASTABS(yLo); y[( 6+i)*NBANDS] = yLo;
  574. yLo = (xPrevWin[ 9+i] << 2) + (MULSHIFT32(wp[3+i], xBuf[5-i]));
  575. mOut |= FASTABS(yLo); y[( 9+i)*NBANDS] = yLo;
  576. yLo = (xPrevWin[12+i] << 2) + (MULSHIFT32(wp[6+i], xBuf[2-i]) + MULSHIFT32(wp[0+i], xBuf[(6+3)+i]));
  577. mOut |= FASTABS(yLo); y[(12+i)*NBANDS] = yLo;
  578. yLo = (xPrevWin[15+i] << 2) + (MULSHIFT32(wp[9+i], xBuf[0+i]) + MULSHIFT32(wp[3+i], xBuf[(6+5)-i]));
  579. mOut |= FASTABS(yLo); y[(15+i)*NBANDS] = yLo;
  580. }
  582. /* save previous (unwindowed) for overlap - only need samples 6-8, 12-17 */
  583. for (i = 6; i < 9; i++)
  584. *xPrev++ = xBuf[i] >> 2;
  585. for (i = 12; i < 18; i++)
  586. *xPrev++ = xBuf[i] >> 2;
  588. xPrev -= 9;
  589. mOut |= FreqInvertRescale(y, xPrev, blockIdx, es);
  591. return mOut;
  592. }
  594. /**************************************************************************************
  595.  * Function:    HybridTransform
  596.  *
  597.  * Description: IMDCT's, windowing, and overlap-add on long/short/mixed blocks
  598.  *
  599.  * Inputs:      vector of input coefficients, length = nBlocksTotal * 18)
  600.  *              vector of overlap samples from last time, length = nBlocksPrev * 9)
  601.  *              buffer for output samples, length = MAXNSAMP
  602.  *              SideInfoSub struct for this granule/channel
  603.  *              BlockCount struct with necessary info
  604.  *                number of non-zero input and overlap blocks
  605.  *                number of long blocks in input vector (rest assumed to be short blocks)
  606.  *                number of blocks which use long window (type) 0 in case of mixed block
  607.  *                  (bc->currWinSwitch, 0 for non-mixed blocks)
  608.  *
  609.  * Outputs:     transformed, windowed, and overlapped sample buffer
  610.  *              does frequency inversion on odd blocks
  611.  *              updated buffer of samples for overlap
  612.  *
  613.  * Return:      number of non-zero IMDCT blocks calculated in this call
  614.  *                (including overlap-add)
  615.  *
  616.  * TODO:        examine mixedBlock/winSwitch logic carefully (test he_mode.bit)
  617.  **************************************************************************************/
  618. static int HybridTransform(int *xCurr, int *xPrev, int y[BLOCK_SIZE][NBANDS], SideInfoSub *sis, BlockCount *bc)
  619. {
  620. int xPrevWin[18], currWinIdx, prevWinIdx;
  621. int i, j, nBlocksOut, nonZero, mOut;
  622. int fiBit, xp;
  624. ASSERT(bc->nBlocksLong  <= NBANDS);
  625. ASSERT(bc->nBlocksTotal <= NBANDS);
  626. ASSERT(bc->nBlocksPrev  <= NBANDS);
  628. mOut = 0;
  630. /* do long blocks, if any */
  631. for(i = 0; i < bc->nBlocksLong; i++) {
  632. /* currWinIdx picks the right window for long blocks (if mixed, long blocks use window type 0) */
  633. currWinIdx = sis->blockType;
  634. if (sis->mixedBlock && i < bc->currWinSwitch) 
  635. currWinIdx = 0;
  637. prevWinIdx = bc->prevType;
  638. if (i < bc->prevWinSwitch)
  639.  prevWinIdx = 0;
  641. /* do 36-point IMDCT, including windowing and overlap-add */
  642. mOut |= IMDCT36(xCurr, xPrev, &(y[0][i]), currWinIdx, prevWinIdx, i, bc->gbIn);
  643. xCurr += 18;
  644. xPrev += 9;
  645. }
  647. /* do short blocks (if any) */
  648. for (   ; i < bc->nBlocksTotal; i++) {
  649. ASSERT(sis->blockType == 2);
  651. prevWinIdx = bc->prevType;
  652. if (i < bc->prevWinSwitch)
  653.  prevWinIdx = 0;
  655. mOut |= IMDCT12x3(xCurr, xPrev, &(y[0][i]), prevWinIdx, i, bc->gbIn);
  656. xCurr += 18;
  657. xPrev += 9;
  658. }
  659. nBlocksOut = i;
  661. /* window and overlap prev if prev longer that current */
  662. for (   ; i < bc->nBlocksPrev; i++) {
  663. prevWinIdx = bc->prevType;
  664. if (i < bc->prevWinSwitch)
  665.  prevWinIdx = 0;
  666. WinPrevious(xPrev, xPrevWin, prevWinIdx);
  668. nonZero = 0;
  669. fiBit = i << 31;
  670. for (j = 0; j < 9; j++) {
  671. xp = xPrevWin[2*j+0] << 2; /* << 2 temp for scaling */
  672. nonZero |= xp;
  673. y[2*j+0][i] = xp;
  674. mOut |= FASTABS(xp);
  676. /* frequency inversion on odd blocks/odd samples (flip sign if i odd, j odd) */
  677. xp = xPrevWin[2*j+1] << 2;
  678. xp = (xp ^ (fiBit >> 31)) + (i & 0x01);
  679. nonZero |= xp;
  680. y[2*j+1][i] = xp;
  681. mOut |= FASTABS(xp);
  683. xPrev[j] = 0;
  684. }
  685. xPrev += 9;
  686. if (nonZero)
  687. nBlocksOut = i;
  688. }
  690. /* clear rest of blocks */
  691. for (   ; i < 32; i++) {
  692. for (j = 0; j < 18; j++) 
  693. y[j][i] = 0;
  694. }
  696. bc->gbOut = CLZ(mOut) - 1;
  698. return nBlocksOut;
  699. }
  701. /**************************************************************************************
  702.  * Function:    IMDCT
  703.  *
  704.  * Description: do alias reduction, inverse MDCT, overlap-add, and frequency inversion
  705.  *
  706.  * Inputs:      MP3DecInfo structure filled by UnpackFrameHeader(), UnpackSideInfo(),
  707.  *                UnpackScaleFactors(), and DecodeHuffman() (for this granule, channel)
  708.  *                includes PCM samples in overBuf (from last call to IMDCT) for OLA
  709.  *              index of current granule and channel
  710.  *
  711.  * Outputs:     PCM samples in outBuf, for input to subband transform
  712.  *              PCM samples in overBuf, for OLA next time
  713.  *              updated hi->nonZeroBound index for this channel
  714.  *
  715.  * Return:      0 on success,  -1 if null input pointers
  716.  **************************************************************************************/
  717. int IMDCT(MP3DecInfo *mp3DecInfo, int gr, int ch)
  718. {
  719. int nBfly, blockCutoff;
  720. FrameHeader *fh;
  721. SideInfo *si;
  722. HuffmanInfo *hi;
  723. IMDCTInfo *mi;
  724. BlockCount bc;
  726. /* validate pointers */
  727. if (!mp3DecInfo || !mp3DecInfo->FrameHeaderPS || !mp3DecInfo->SideInfoPS || 
  728. !mp3DecInfo->HuffmanInfoPS || !mp3DecInfo->IMDCTInfoPS)
  729. return -1;
  731. /* si is an array of up to 4 structs, stored as gr0ch0, gr0ch1, gr1ch0, gr1ch1 */
  732. fh = (FrameHeader *)(mp3DecInfo->FrameHeaderPS);
  733. si = (SideInfo *)(mp3DecInfo->SideInfoPS);
  734. hi = (HuffmanInfo*)(mp3DecInfo->HuffmanInfoPS);
  735. mi = (IMDCTInfo *)(mp3DecInfo->IMDCTInfoPS);
  737. /* anti-aliasing done on whole long blocks only
  738.  * for mixed blocks, nBfly always 1, except 3 for 8 kHz MPEG 2.5 (see sfBandTab) 
  739.      *   nLongBlocks = number of blocks with (possibly) non-zero power 
  740.  *   nBfly = number of butterflies to do (nLongBlocks - 1, unless no long blocks)
  741.  */
  742. blockCutoff = fh->sfBand->l[(fh->ver == MPEG1 ? 8 : 6)] / 18; /* same as 3* num short sfb's in spec */
  743. if (si->sis[gr][ch].blockType != 2) {
  744. /* all long transforms */
  745. bc.nBlocksLong = MIN((hi->nonZeroBound[ch] + 7) / 18 + 1, 32);
  746. nBfly = bc.nBlocksLong - 1;
  747. } else if (si->sis[gr][ch].blockType == 2 && si->sis[gr][ch].mixedBlock) {
  748. /* mixed block - long transforms until cutoff, then short transforms */
  749. bc.nBlocksLong = blockCutoff;
  750. nBfly = bc.nBlocksLong - 1;
  751. } else {
  752. /* all short transforms */
  753. bc.nBlocksLong = 0;
  754. nBfly = 0;
  755. }
  756.  
  757. AntiAlias(hi->huffDecBuf[ch], nBfly);
  758. hi->nonZeroBound[ch] = MAX(hi->nonZeroBound[ch], (nBfly * 18) + 8);
  760. ASSERT(hi->nonZeroBound[ch] <= MAX_NSAMP);
  762. /* for readability, use a struct instead of passing a million parameters to HybridTransform() */
  763. bc.nBlocksTotal = (hi->nonZeroBound[ch] + 17) / 18;
  764. bc.nBlocksPrev = mi->numPrevIMDCT[ch];
  765. bc.prevType = mi->prevType[ch];
  766. bc.prevWinSwitch = mi->prevWinSwitch[ch];
  767. bc.currWinSwitch = (si->sis[gr][ch].mixedBlock ? blockCutoff : 0); /* where WINDOW switches (not nec. transform) */
  768. bc.gbIn = hi->gb[ch];
  770. mi->numPrevIMDCT[ch] = HybridTransform(hi->huffDecBuf[ch], mi->overBuf[ch], mi->outBuf[ch], &si->sis[gr][ch], &bc);
  771. mi->prevType[ch] = si->sis[gr][ch].blockType;
  772. mi->prevWinSwitch[ch] = bc.currWinSwitch; /* 0 means not a mixed block (either all short or all long) */
  773. mi->gb[ch] = bc.gbOut;
  775. ASSERT(mi->numPrevIMDCT[ch] <= NBANDS);
  777. /* output has gained 2 int bits */
  778. return 0;
  779. }