falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
735 Commits
32 Branches
935MB
Tree: 789bee1264
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '789bee1264'
${ noResults }
FFmpeg/libavcodec/jrevdct.c

1170 lines
33KB
Raw Blame History 

  1. /*

  2.  * jrevdct.c

  3.  *

  4.  * Copyright (C) 1991, 1992, Thomas G. Lane.

  5.  * This file is part of the Independent JPEG Group's software.

  6.  * For conditions of distribution and use, see the accompanying README file.

  7.  *

  8.  * This file contains the basic inverse-DCT transformation subroutine.

  9.  *

  10.  * This implementation is based on an algorithm described in

  11.  *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT

  12.  *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,

  13.  *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.

  14.  * The primary algorithm described there uses 11 multiplies and 29 adds.

  15.  * We use their alternate method with 12 multiplies and 32 adds.

  16.  * The advantage of this method is that no data path contains more than one

  17.  * multiplication; this allows a very simple and accurate implementation in

  18.  * scaled fixed-point arithmetic, with a minimal number of shifts.

  19.  * 

  20.  * I've made lots of modifications to attempt to take advantage of the

  21.  * sparse nature of the DCT matrices we're getting.  Although the logic

  22.  * is cumbersome, it's straightforward and the resulting code is much

  23.  * faster.

  24.  *

  25.  * A better way to do this would be to pass in the DCT block as a sparse

  26.  * matrix, perhaps with the difference cases encoded.

  27.  */

  28. #include "common.h"

  29. #include "dsputil.h"

  30. 

  31. #define EIGHT_BIT_SAMPLES

  32. 

  33. #define DCTSIZE 8

  34. #define DCTSIZE2 64

  35. 

  36. #define GLOBAL

  37. 

  38. #define RIGHT_SHIFT(x, n) ((x) >> (n))

  39. 

  40. typedef DCTELEM DCTBLOCK[DCTSIZE2];

  41. 

  42. #define CONST_BITS 13

  43. 

  44. /*

  45.  * This routine is specialized to the case DCTSIZE = 8.

  46.  */

  47. 

  48. #if DCTSIZE != 8

  49.   Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */

  50. #endif

  51. 

  52. 

  53. /*

  54.  * A 2-D IDCT can be done by 1-D IDCT on each row followed by 1-D IDCT

  55.  * on each column.  Direct algorithms are also available, but they are

  56.  * much more complex and seem not to be any faster when reduced to code.

  57.  *

  58.  * The poop on this scaling stuff is as follows:

  59.  *

  60.  * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)

  61.  * larger than the true IDCT outputs.  The final outputs are therefore

  62.  * a factor of N larger than desired; since N=8 this can be cured by

  63.  * a simple right shift at the end of the algorithm.  The advantage of

  64.  * this arrangement is that we save two multiplications per 1-D IDCT,

  65.  * because the y0 and y4 inputs need not be divided by sqrt(N).

  66.  *

  67.  * We have to do addition and subtraction of the integer inputs, which

  68.  * is no problem, and multiplication by fractional constants, which is

  69.  * a problem to do in integer arithmetic.  We multiply all the constants

  70.  * by CONST_SCALE and convert them to integer constants (thus retaining

  71.  * CONST_BITS bits of precision in the constants).  After doing a

  72.  * multiplication we have to divide the product by CONST_SCALE, with proper

  73.  * rounding, to produce the correct output.  This division can be done

  74.  * cheaply as a right shift of CONST_BITS bits.  We postpone shifting

  75.  * as long as possible so that partial sums can be added together with

  76.  * full fractional precision.

  77.  *

  78.  * The outputs of the first pass are scaled up by PASS1_BITS bits so that

  79.  * they are represented to better-than-integral precision.  These outputs

  80.  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word

  81.  * with the recommended scaling.  (To scale up 12-bit sample data further, an

  82.  * intermediate int32 array would be needed.)

  83.  *

  84.  * To avoid overflow of the 32-bit intermediate results in pass 2, we must

  85.  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis

  86.  * shows that the values given below are the most effective.

  87.  */

  88. 

  89. #ifdef EIGHT_BIT_SAMPLES

  90. #define PASS1_BITS  2

  91. #else

  92. #define PASS1_BITS  1		/* lose a little precision to avoid overflow */

  93. #endif

  94. 

  95. #define ONE	((INT32) 1)

  96. 

  97. #define CONST_SCALE (ONE << CONST_BITS)

  98. 

  99. /* Convert a positive real constant to an integer scaled by CONST_SCALE.

  100.  * IMPORTANT: if your compiler doesn't do this arithmetic at compile time,

  101.  * you will pay a significant penalty in run time.  In that case, figure

  102.  * the correct integer constant values and insert them by hand.

  103.  */

  104. 

  105. /* Actually FIX is no longer used, we precomputed them all */

  106. #define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5)) 

  107. 

  108. /* Descale and correctly round an INT32 value that's scaled by N bits.

  109.  * We assume RIGHT_SHIFT rounds towards minus infinity, so adding

  110.  * the fudge factor is correct for either sign of X.

  111.  */

  112. 

  113. #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)

  114. 

  115. /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.

  116.  * For 8-bit samples with the recommended scaling, all the variable

  117.  * and constant values involved are no more than 16 bits wide, so a

  118.  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply;

  119.  * this provides a useful speedup on many machines.

  120.  * There is no way to specify a 16x16->32 multiply in portable C, but

  121.  * some C compilers will do the right thing if you provide the correct

  122.  * combination of casts.

  123.  * NB: for 12-bit samples, a full 32-bit multiplication will be needed.

  124.  */

  125. 

  126. #ifdef EIGHT_BIT_SAMPLES

  127. #ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */

  128. #define MULTIPLY(var,const)  (((INT16) (var)) * ((INT16) (const)))

  129. #endif

  130. #ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */

  131. #define MULTIPLY(var,const)  (((INT16) (var)) * ((INT32) (const)))

  132. #endif

  133. #endif

  134. 

  135. #ifndef MULTIPLY		/* default definition */

  136. #define MULTIPLY(var,const)  ((var) * (const))

  137. #endif

  138. 

  139. 

  140. /* 

  141.   Unlike our decoder where we approximate the FIXes, we need to use exact

  142. ones here or successive P-frames will drift too much with Reference frame coding 

  143. */

  144. #define FIX_0_211164243 1730

  145. #define FIX_0_275899380 2260

  146. #define FIX_0_298631336 2446

  147. #define FIX_0_390180644 3196

  148. #define FIX_0_509795579 4176

  149. #define FIX_0_541196100 4433

  150. #define FIX_0_601344887 4926

  151. #define FIX_0_765366865 6270

  152. #define FIX_0_785694958 6436

  153. #define FIX_0_899976223 7373

  154. #define FIX_1_061594337 8697

  155. #define FIX_1_111140466 9102

  156. #define FIX_1_175875602 9633

  157. #define FIX_1_306562965 10703

  158. #define FIX_1_387039845 11363

  159. #define FIX_1_451774981 11893

  160. #define FIX_1_501321110 12299

  161. #define FIX_1_662939225 13623

  162. #define FIX_1_847759065 15137

  163. #define FIX_1_961570560 16069

  164. #define FIX_2_053119869 16819

  165. #define FIX_2_172734803 17799

  166. #define FIX_2_562915447 20995

  167. #define FIX_3_072711026 25172

  168. 

  169. /*

  170.  * Perform the inverse DCT on one block of coefficients.

  171.  */

  172. 

  173. void j_rev_dct(DCTBLOCK data)

  174. {

  175.   INT32 tmp0, tmp1, tmp2, tmp3;

  176.   INT32 tmp10, tmp11, tmp12, tmp13;

  177.   INT32 z1, z2, z3, z4, z5;

  178.   INT32 d0, d1, d2, d3, d4, d5, d6, d7;

  179.   register DCTELEM *dataptr;

  180.   int rowctr;

  181.    

  182.   /* Pass 1: process rows. */

  183.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */

  184.   /* furthermore, we scale the results by 2**PASS1_BITS. */

  185. 

  186.   dataptr = data;

  187. 

  188.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {

  189.     /* Due to quantization, we will usually find that many of the input

  190.      * coefficients are zero, especially the AC terms.  We can exploit this

  191.      * by short-circuiting the IDCT calculation for any row in which all

  192.      * the AC terms are zero.  In that case each output is equal to the

  193.      * DC coefficient (with scale factor as needed).

  194.      * With typical images and quantization tables, half or more of the

  195.      * row DCT calculations can be simplified this way.

  196.      */

  197. 

  198.     register int *idataptr = (int*)dataptr;

  199. 

  200.     /* WARNING: we do the same permutation as MMX idct to simplify the

  201.        video core */

  202.     d0 = dataptr[0];

  203.     d2 = dataptr[1];

  204.     d4 = dataptr[2];

  205.     d6 = dataptr[3];

  206.     d1 = dataptr[4];

  207.     d3 = dataptr[5];

  208.     d5 = dataptr[6];

  209.     d7 = dataptr[7];

  210. 

  211.     if ((d1 | d2 | d3 | d4 | d5 | d6 | d7) == 0) {

  212.       /* AC terms all zero */

  213.       if (d0) {

  214. 	  /* Compute a 32 bit value to assign. */

  215. 	  DCTELEM dcval = (DCTELEM) (d0 << PASS1_BITS);

  216. 	  register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);

  217. 	  

  218. 	  idataptr[0] = v;

  219. 	  idataptr[1] = v;

  220. 	  idataptr[2] = v;

  221. 	  idataptr[3] = v;

  222.       }

  223.       

  224.       dataptr += DCTSIZE;	/* advance pointer to next row */

  225.       continue;

  226.     }

  227. 

  228.     /* Even part: reverse the even part of the forward DCT. */

  229.     /* The rotator is sqrt(2)*c(-6). */

  230. {

  231.     if (d6) {

  232. 	if (d4) {

  233. 	    if (d2) {

  234. 		if (d0) {

  235. 		    /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */

  236. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  237. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  238. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  239. 

  240. 		    tmp0 = (d0 + d4) << CONST_BITS;

  241. 		    tmp1 = (d0 - d4) << CONST_BITS;

  242. 

  243. 		    tmp10 = tmp0 + tmp3;

  244. 		    tmp13 = tmp0 - tmp3;

  245. 		    tmp11 = tmp1 + tmp2;

  246. 		    tmp12 = tmp1 - tmp2;

  247. 		} else {

  248. 		    /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */

  249. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  250. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  251. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  252. 

  253. 		    tmp0 = d4 << CONST_BITS;

  254. 

  255. 		    tmp10 = tmp0 + tmp3;

  256. 		    tmp13 = tmp0 - tmp3;

  257. 		    tmp11 = tmp2 - tmp0;

  258. 		    tmp12 = -(tmp0 + tmp2);

  259. 		}

  260. 	    } else {

  261. 		if (d0) {

  262. 		    /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */

  263. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  264. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  265. 

  266. 		    tmp0 = (d0 + d4) << CONST_BITS;

  267. 		    tmp1 = (d0 - d4) << CONST_BITS;

  268. 

  269. 		    tmp10 = tmp0 + tmp3;

  270. 		    tmp13 = tmp0 - tmp3;

  271. 		    tmp11 = tmp1 + tmp2;

  272. 		    tmp12 = tmp1 - tmp2;

  273. 		} else {

  274. 		    /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */

  275. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  276. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  277. 

  278. 		    tmp0 = d4 << CONST_BITS;

  279. 

  280. 		    tmp10 = tmp0 + tmp3;

  281. 		    tmp13 = tmp0 - tmp3;

  282. 		    tmp11 = tmp2 - tmp0;

  283. 		    tmp12 = -(tmp0 + tmp2);

  284. 		}

  285. 	    }

  286. 	} else {

  287. 	    if (d2) {

  288. 		if (d0) {

  289. 		    /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */

  290. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  291. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  292. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  293. 

  294. 		    tmp0 = d0 << CONST_BITS;

  295. 

  296. 		    tmp10 = tmp0 + tmp3;

  297. 		    tmp13 = tmp0 - tmp3;

  298. 		    tmp11 = tmp0 + tmp2;

  299. 		    tmp12 = tmp0 - tmp2;

  300. 		} else {

  301. 		    /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */

  302. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  303. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  304. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  305. 

  306. 		    tmp10 = tmp3;

  307. 		    tmp13 = -tmp3;

  308. 		    tmp11 = tmp2;

  309. 		    tmp12 = -tmp2;

  310. 		}

  311. 	    } else {

  312. 		if (d0) {

  313. 		    /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */

  314. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  315. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  316. 

  317. 		    tmp0 = d0 << CONST_BITS;

  318. 

  319. 		    tmp10 = tmp0 + tmp3;

  320. 		    tmp13 = tmp0 - tmp3;

  321. 		    tmp11 = tmp0 + tmp2;

  322. 		    tmp12 = tmp0 - tmp2;

  323. 		} else {

  324. 		    /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */

  325. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  326. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  327. 

  328. 		    tmp10 = tmp3;

  329. 		    tmp13 = -tmp3;

  330. 		    tmp11 = tmp2;

  331. 		    tmp12 = -tmp2;

  332. 		}

  333. 	    }

  334. 	}

  335.     } else {

  336. 	if (d4) {

  337. 	    if (d2) {

  338. 		if (d0) {

  339. 		    /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */

  340. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  341. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  342. 

  343. 		    tmp0 = (d0 + d4) << CONST_BITS;

  344. 		    tmp1 = (d0 - d4) << CONST_BITS;

  345. 

  346. 		    tmp10 = tmp0 + tmp3;

  347. 		    tmp13 = tmp0 - tmp3;

  348. 		    tmp11 = tmp1 + tmp2;

  349. 		    tmp12 = tmp1 - tmp2;

  350. 		} else {

  351. 		    /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */

  352. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  353. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  354. 

  355. 		    tmp0 = d4 << CONST_BITS;

  356. 

  357. 		    tmp10 = tmp0 + tmp3;

  358. 		    tmp13 = tmp0 - tmp3;

  359. 		    tmp11 = tmp2 - tmp0;

  360. 		    tmp12 = -(tmp0 + tmp2);

  361. 		}

  362. 	    } else {

  363. 		if (d0) {

  364. 		    /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */

  365. 		    tmp10 = tmp13 = (d0 + d4) << CONST_BITS;

  366. 		    tmp11 = tmp12 = (d0 - d4) << CONST_BITS;

  367. 		} else {

  368. 		    /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */

  369. 		    tmp10 = tmp13 = d4 << CONST_BITS;

  370. 		    tmp11 = tmp12 = -tmp10;

  371. 		}

  372. 	    }

  373. 	} else {

  374. 	    if (d2) {

  375. 		if (d0) {

  376. 		    /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */

  377. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  378. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  379. 

  380. 		    tmp0 = d0 << CONST_BITS;

  381. 

  382. 		    tmp10 = tmp0 + tmp3;

  383. 		    tmp13 = tmp0 - tmp3;

  384. 		    tmp11 = tmp0 + tmp2;

  385. 		    tmp12 = tmp0 - tmp2;

  386. 		} else {

  387. 		    /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */

  388. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  389. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  390. 

  391. 		    tmp10 = tmp3;

  392. 		    tmp13 = -tmp3;

  393. 		    tmp11 = tmp2;

  394. 		    tmp12 = -tmp2;

  395. 		}

  396. 	    } else {

  397. 		if (d0) {

  398. 		    /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */

  399. 		    tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;

  400. 		} else {

  401. 		    /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */

  402. 		    tmp10 = tmp13 = tmp11 = tmp12 = 0;

  403. 		}

  404. 	    }

  405. 	}

  406.       }

  407. 

  408.     /* Odd part per figure 8; the matrix is unitary and hence its

  409.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.

  410.      */

  411. 

  412.     if (d7) {

  413. 	if (d5) {

  414. 	    if (d3) {

  415. 		if (d1) {

  416. 		    /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */

  417. 		    z1 = d7 + d1;

  418. 		    z2 = d5 + d3;

  419. 		    z3 = d7 + d3;

  420. 		    z4 = d5 + d1;

  421. 		    z5 = MULTIPLY(z3 + z4, FIX_1_175875602);

  422. 		    

  423. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  424. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  425. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  426. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  427. 		    z1 = MULTIPLY(-z1, FIX_0_899976223);

  428. 		    z2 = MULTIPLY(-z2, FIX_2_562915447);

  429. 		    z3 = MULTIPLY(-z3, FIX_1_961570560);

  430. 		    z4 = MULTIPLY(-z4, FIX_0_390180644);

  431. 		    

  432. 		    z3 += z5;

  433. 		    z4 += z5;

  434. 		    

  435. 		    tmp0 += z1 + z3;

  436. 		    tmp1 += z2 + z4;

  437. 		    tmp2 += z2 + z3;

  438. 		    tmp3 += z1 + z4;

  439. 		} else {

  440. 		    /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */

  441. 		    z2 = d5 + d3;

  442. 		    z3 = d7 + d3;

  443. 		    z5 = MULTIPLY(z3 + d5, FIX_1_175875602);

  444. 		    

  445. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  446. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  447. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  448. 		    z1 = MULTIPLY(-d7, FIX_0_899976223);

  449. 		    z2 = MULTIPLY(-z2, FIX_2_562915447);

  450. 		    z3 = MULTIPLY(-z3, FIX_1_961570560);

  451. 		    z4 = MULTIPLY(-d5, FIX_0_390180644);

  452. 		    

  453. 		    z3 += z5;

  454. 		    z4 += z5;

  455. 		    

  456. 		    tmp0 += z1 + z3;

  457. 		    tmp1 += z2 + z4;

  458. 		    tmp2 += z2 + z3;

  459. 		    tmp3 = z1 + z4;

  460. 		}

  461. 	    } else {

  462. 		if (d1) {

  463. 		    /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */

  464. 		    z1 = d7 + d1;

  465. 		    z4 = d5 + d1;

  466. 		    z5 = MULTIPLY(d7 + z4, FIX_1_175875602);

  467. 		    

  468. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  469. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  470. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  471. 		    z1 = MULTIPLY(-z1, FIX_0_899976223);

  472. 		    z2 = MULTIPLY(-d5, FIX_2_562915447);

  473. 		    z3 = MULTIPLY(-d7, FIX_1_961570560);

  474. 		    z4 = MULTIPLY(-z4, FIX_0_390180644);

  475. 		    

  476. 		    z3 += z5;

  477. 		    z4 += z5;

  478. 		    

  479. 		    tmp0 += z1 + z3;

  480. 		    tmp1 += z2 + z4;

  481. 		    tmp2 = z2 + z3;

  482. 		    tmp3 += z1 + z4;

  483. 		} else {

  484. 		    /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */

  485. 		    tmp0 = MULTIPLY(-d7, FIX_0_601344887); 

  486. 		    z1 = MULTIPLY(-d7, FIX_0_899976223);

  487. 		    z3 = MULTIPLY(-d7, FIX_1_961570560);

  488. 		    tmp1 = MULTIPLY(-d5, FIX_0_509795579);

  489. 		    z2 = MULTIPLY(-d5, FIX_2_562915447);

  490. 		    z4 = MULTIPLY(-d5, FIX_0_390180644);

  491. 		    z5 = MULTIPLY(d5 + d7, FIX_1_175875602);

  492. 		    

  493. 		    z3 += z5;

  494. 		    z4 += z5;

  495. 		    

  496. 		    tmp0 += z3;

  497. 		    tmp1 += z4;

  498. 		    tmp2 = z2 + z3;

  499. 		    tmp3 = z1 + z4;

  500. 		}

  501. 	    }

  502. 	} else {

  503. 	    if (d3) {

  504. 		if (d1) {

  505. 		    /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */

  506. 		    z1 = d7 + d1;

  507. 		    z3 = d7 + d3;

  508. 		    z5 = MULTIPLY(z3 + d1, FIX_1_175875602);

  509. 		    

  510. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  511. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  512. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  513. 		    z1 = MULTIPLY(-z1, FIX_0_899976223);

  514. 		    z2 = MULTIPLY(-d3, FIX_2_562915447);

  515. 		    z3 = MULTIPLY(-z3, FIX_1_961570560);

  516. 		    z4 = MULTIPLY(-d1, FIX_0_390180644);

  517. 		    

  518. 		    z3 += z5;

  519. 		    z4 += z5;

  520. 		    

  521. 		    tmp0 += z1 + z3;

  522. 		    tmp1 = z2 + z4;

  523. 		    tmp2 += z2 + z3;

  524. 		    tmp3 += z1 + z4;

  525. 		} else {

  526. 		    /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */

  527. 		    z3 = d7 + d3;

  528. 		    

  529. 		    tmp0 = MULTIPLY(-d7, FIX_0_601344887); 

  530. 		    z1 = MULTIPLY(-d7, FIX_0_899976223);

  531. 		    tmp2 = MULTIPLY(d3, FIX_0_509795579);

  532. 		    z2 = MULTIPLY(-d3, FIX_2_562915447);

  533. 		    z5 = MULTIPLY(z3, FIX_1_175875602);

  534. 		    z3 = MULTIPLY(-z3, FIX_0_785694958);

  535. 		    

  536. 		    tmp0 += z3;

  537. 		    tmp1 = z2 + z5;

  538. 		    tmp2 += z3;

  539. 		    tmp3 = z1 + z5;

  540. 		}

  541. 	    } else {

  542. 		if (d1) {

  543. 		    /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */

  544. 		    z1 = d7 + d1;

  545. 		    z5 = MULTIPLY(z1, FIX_1_175875602);

  546. 

  547. 		    z1 = MULTIPLY(z1, FIX_0_275899380);

  548. 		    z3 = MULTIPLY(-d7, FIX_1_961570560);

  549. 		    tmp0 = MULTIPLY(-d7, FIX_1_662939225); 

  550. 		    z4 = MULTIPLY(-d1, FIX_0_390180644);

  551. 		    tmp3 = MULTIPLY(d1, FIX_1_111140466);

  552. 

  553. 		    tmp0 += z1;

  554. 		    tmp1 = z4 + z5;

  555. 		    tmp2 = z3 + z5;

  556. 		    tmp3 += z1;

  557. 		} else {

  558. 		    /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */

  559. 		    tmp0 = MULTIPLY(-d7, FIX_1_387039845);

  560. 		    tmp1 = MULTIPLY(d7, FIX_1_175875602);

  561. 		    tmp2 = MULTIPLY(-d7, FIX_0_785694958);

  562. 		    tmp3 = MULTIPLY(d7, FIX_0_275899380);

  563. 		}

  564. 	    }

  565. 	}

  566.     } else {

  567. 	if (d5) {

  568. 	    if (d3) {

  569. 		if (d1) {

  570. 		    /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */

  571. 		    z2 = d5 + d3;

  572. 		    z4 = d5 + d1;

  573. 		    z5 = MULTIPLY(d3 + z4, FIX_1_175875602);

  574. 		    

  575. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  576. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  577. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  578. 		    z1 = MULTIPLY(-d1, FIX_0_899976223);

  579. 		    z2 = MULTIPLY(-z2, FIX_2_562915447);

  580. 		    z3 = MULTIPLY(-d3, FIX_1_961570560);

  581. 		    z4 = MULTIPLY(-z4, FIX_0_390180644);

  582. 		    

  583. 		    z3 += z5;

  584. 		    z4 += z5;

  585. 		    

  586. 		    tmp0 = z1 + z3;

  587. 		    tmp1 += z2 + z4;

  588. 		    tmp2 += z2 + z3;

  589. 		    tmp3 += z1 + z4;

  590. 		} else {

  591. 		    /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */

  592. 		    z2 = d5 + d3;

  593. 		    

  594. 		    z5 = MULTIPLY(z2, FIX_1_175875602);

  595. 		    tmp1 = MULTIPLY(d5, FIX_1_662939225);

  596. 		    z4 = MULTIPLY(-d5, FIX_0_390180644);

  597. 		    z2 = MULTIPLY(-z2, FIX_1_387039845);

  598. 		    tmp2 = MULTIPLY(d3, FIX_1_111140466);

  599. 		    z3 = MULTIPLY(-d3, FIX_1_961570560);

  600. 		    

  601. 		    tmp0 = z3 + z5;

  602. 		    tmp1 += z2;

  603. 		    tmp2 += z2;

  604. 		    tmp3 = z4 + z5;

  605. 		}

  606. 	    } else {

  607. 		if (d1) {

  608. 		    /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */

  609. 		    z4 = d5 + d1;

  610. 		    

  611. 		    z5 = MULTIPLY(z4, FIX_1_175875602);

  612. 		    z1 = MULTIPLY(-d1, FIX_0_899976223);

  613. 		    tmp3 = MULTIPLY(d1, FIX_0_601344887);

  614. 		    tmp1 = MULTIPLY(-d5, FIX_0_509795579);

  615. 		    z2 = MULTIPLY(-d5, FIX_2_562915447);

  616. 		    z4 = MULTIPLY(z4, FIX_0_785694958);

  617. 		    

  618. 		    tmp0 = z1 + z5;

  619. 		    tmp1 += z4;

  620. 		    tmp2 = z2 + z5;

  621. 		    tmp3 += z4;

  622. 		} else {

  623. 		    /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */

  624. 		    tmp0 = MULTIPLY(d5, FIX_1_175875602);

  625. 		    tmp1 = MULTIPLY(d5, FIX_0_275899380);

  626. 		    tmp2 = MULTIPLY(-d5, FIX_1_387039845);

  627. 		    tmp3 = MULTIPLY(d5, FIX_0_785694958);

  628. 		}

  629. 	    }

  630. 	} else {

  631. 	    if (d3) {

  632. 		if (d1) {

  633. 		    /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */

  634. 		    z5 = d1 + d3;

  635. 		    tmp3 = MULTIPLY(d1, FIX_0_211164243);

  636. 		    tmp2 = MULTIPLY(-d3, FIX_1_451774981);

  637. 		    z1 = MULTIPLY(d1, FIX_1_061594337);

  638. 		    z2 = MULTIPLY(-d3, FIX_2_172734803);

  639. 		    z4 = MULTIPLY(z5, FIX_0_785694958);

  640. 		    z5 = MULTIPLY(z5, FIX_1_175875602);

  641. 		    

  642. 		    tmp0 = z1 - z4;

  643. 		    tmp1 = z2 + z4;

  644. 		    tmp2 += z5;

  645. 		    tmp3 += z5;

  646. 		} else {

  647. 		    /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */

  648. 		    tmp0 = MULTIPLY(-d3, FIX_0_785694958);

  649. 		    tmp1 = MULTIPLY(-d3, FIX_1_387039845);

  650. 		    tmp2 = MULTIPLY(-d3, FIX_0_275899380);

  651. 		    tmp3 = MULTIPLY(d3, FIX_1_175875602);

  652. 		}

  653. 	    } else {

  654. 		if (d1) {

  655. 		    /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */

  656. 		    tmp0 = MULTIPLY(d1, FIX_0_275899380);

  657. 		    tmp1 = MULTIPLY(d1, FIX_0_785694958);

  658. 		    tmp2 = MULTIPLY(d1, FIX_1_175875602);

  659. 		    tmp3 = MULTIPLY(d1, FIX_1_387039845);

  660. 		} else {

  661. 		    /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */

  662. 		    tmp0 = tmp1 = tmp2 = tmp3 = 0;

  663. 		}

  664. 	    }

  665. 	}

  666.     }

  667. }

  668.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */

  669. 

  670.     dataptr[0] = (DCTELEM) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);

  671.     dataptr[7] = (DCTELEM) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);

  672.     dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);

  673.     dataptr[6] = (DCTELEM) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);

  674.     dataptr[2] = (DCTELEM) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);

  675.     dataptr[5] = (DCTELEM) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);

  676.     dataptr[3] = (DCTELEM) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);

  677.     dataptr[4] = (DCTELEM) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);

  678. 

  679.     dataptr += DCTSIZE;		/* advance pointer to next row */

  680.   }

  681. 

  682.   /* Pass 2: process columns. */

  683.   /* Note that we must descale the results by a factor of 8 == 2**3, */

  684.   /* and also undo the PASS1_BITS scaling. */

  685. 

  686.   dataptr = data;

  687.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {

  688.     /* Columns of zeroes can be exploited in the same way as we did with rows.

  689.      * However, the row calculation has created many nonzero AC terms, so the

  690.      * simplification applies less often (typically 5% to 10% of the time).

  691.      * On machines with very fast multiplication, it's possible that the

  692.      * test takes more time than it's worth.  In that case this section

  693.      * may be commented out.

  694.      */

  695. 

  696.     d0 = dataptr[DCTSIZE*0];

  697.     d1 = dataptr[DCTSIZE*1];

  698.     d2 = dataptr[DCTSIZE*2];

  699.     d3 = dataptr[DCTSIZE*3];

  700.     d4 = dataptr[DCTSIZE*4];

  701.     d5 = dataptr[DCTSIZE*5];

  702.     d6 = dataptr[DCTSIZE*6];

  703.     d7 = dataptr[DCTSIZE*7];

  704. 

  705.     /* Even part: reverse the even part of the forward DCT. */

  706.     /* The rotator is sqrt(2)*c(-6). */

  707.     if (d6) {

  708. 	if (d4) {

  709. 	    if (d2) {

  710. 		if (d0) {

  711. 		    /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */

  712. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  713. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  714. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  715. 

  716. 		    tmp0 = (d0 + d4) << CONST_BITS;

  717. 		    tmp1 = (d0 - d4) << CONST_BITS;

  718. 

  719. 		    tmp10 = tmp0 + tmp3;

  720. 		    tmp13 = tmp0 - tmp3;

  721. 		    tmp11 = tmp1 + tmp2;

  722. 		    tmp12 = tmp1 - tmp2;

  723. 		} else {

  724. 		    /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */

  725. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  726. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  727. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  728. 

  729. 		    tmp0 = d4 << CONST_BITS;

  730. 

  731. 		    tmp10 = tmp0 + tmp3;

  732. 		    tmp13 = tmp0 - tmp3;

  733. 		    tmp11 = tmp2 - tmp0;

  734. 		    tmp12 = -(tmp0 + tmp2);

  735. 		}

  736. 	    } else {

  737. 		if (d0) {

  738. 		    /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */

  739. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  740. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  741. 

  742. 		    tmp0 = (d0 + d4) << CONST_BITS;

  743. 		    tmp1 = (d0 - d4) << CONST_BITS;

  744. 

  745. 		    tmp10 = tmp0 + tmp3;

  746. 		    tmp13 = tmp0 - tmp3;

  747. 		    tmp11 = tmp1 + tmp2;

  748. 		    tmp12 = tmp1 - tmp2;

  749. 		} else {

  750. 		    /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */

  751. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  752. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  753. 

  754. 		    tmp0 = d4 << CONST_BITS;

  755. 

  756. 		    tmp10 = tmp0 + tmp3;

  757. 		    tmp13 = tmp0 - tmp3;

  758. 		    tmp11 = tmp2 - tmp0;

  759. 		    tmp12 = -(tmp0 + tmp2);

  760. 		}

  761. 	    }

  762. 	} else {

  763. 	    if (d2) {

  764. 		if (d0) {

  765. 		    /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */

  766. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  767. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  768. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  769. 

  770. 		    tmp0 = d0 << CONST_BITS;

  771. 

  772. 		    tmp10 = tmp0 + tmp3;

  773. 		    tmp13 = tmp0 - tmp3;

  774. 		    tmp11 = tmp0 + tmp2;

  775. 		    tmp12 = tmp0 - tmp2;

  776. 		} else {

  777. 		    /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */

  778. 		    z1 = MULTIPLY(d2 + d6, FIX_0_541196100);

  779. 		    tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);

  780. 		    tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);

  781. 

  782. 		    tmp10 = tmp3;

  783. 		    tmp13 = -tmp3;

  784. 		    tmp11 = tmp2;

  785. 		    tmp12 = -tmp2;

  786. 		}

  787. 	    } else {

  788. 		if (d0) {

  789. 		    /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */

  790. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  791. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  792. 

  793. 		    tmp0 = d0 << CONST_BITS;

  794. 

  795. 		    tmp10 = tmp0 + tmp3;

  796. 		    tmp13 = tmp0 - tmp3;

  797. 		    tmp11 = tmp0 + tmp2;

  798. 		    tmp12 = tmp0 - tmp2;

  799. 		} else {

  800. 		    /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */

  801. 		    tmp2 = MULTIPLY(-d6, FIX_1_306562965);

  802. 		    tmp3 = MULTIPLY(d6, FIX_0_541196100);

  803. 

  804. 		    tmp10 = tmp3;

  805. 		    tmp13 = -tmp3;

  806. 		    tmp11 = tmp2;

  807. 		    tmp12 = -tmp2;

  808. 		}

  809. 	    }

  810. 	}

  811.     } else {

  812. 	if (d4) {

  813. 	    if (d2) {

  814. 		if (d0) {

  815. 		    /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */

  816. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  817. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  818. 

  819. 		    tmp0 = (d0 + d4) << CONST_BITS;

  820. 		    tmp1 = (d0 - d4) << CONST_BITS;

  821. 

  822. 		    tmp10 = tmp0 + tmp3;

  823. 		    tmp13 = tmp0 - tmp3;

  824. 		    tmp11 = tmp1 + tmp2;

  825. 		    tmp12 = tmp1 - tmp2;

  826. 		} else {

  827. 		    /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */

  828. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  829. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  830. 

  831. 		    tmp0 = d4 << CONST_BITS;

  832. 

  833. 		    tmp10 = tmp0 + tmp3;

  834. 		    tmp13 = tmp0 - tmp3;

  835. 		    tmp11 = tmp2 - tmp0;

  836. 		    tmp12 = -(tmp0 + tmp2);

  837. 		}

  838. 	    } else {

  839. 		if (d0) {

  840. 		    /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */

  841. 		    tmp10 = tmp13 = (d0 + d4) << CONST_BITS;

  842. 		    tmp11 = tmp12 = (d0 - d4) << CONST_BITS;

  843. 		} else {

  844. 		    /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */

  845. 		    tmp10 = tmp13 = d4 << CONST_BITS;

  846. 		    tmp11 = tmp12 = -tmp10;

  847. 		}

  848. 	    }

  849. 	} else {

  850. 	    if (d2) {

  851. 		if (d0) {

  852. 		    /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */

  853. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  854. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  855. 

  856. 		    tmp0 = d0 << CONST_BITS;

  857. 

  858. 		    tmp10 = tmp0 + tmp3;

  859. 		    tmp13 = tmp0 - tmp3;

  860. 		    tmp11 = tmp0 + tmp2;

  861. 		    tmp12 = tmp0 - tmp2;

  862. 		} else {

  863. 		    /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */

  864. 		    tmp2 = MULTIPLY(d2, FIX_0_541196100);

  865. 		    tmp3 = MULTIPLY(d2, FIX_1_306562965);

  866. 

  867. 		    tmp10 = tmp3;

  868. 		    tmp13 = -tmp3;

  869. 		    tmp11 = tmp2;

  870. 		    tmp12 = -tmp2;

  871. 		}

  872. 	    } else {

  873. 		if (d0) {

  874. 		    /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */

  875. 		    tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;

  876. 		} else {

  877. 		    /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */

  878. 		    tmp10 = tmp13 = tmp11 = tmp12 = 0;

  879. 		}

  880. 	    }

  881. 	}

  882.     }

  883. 

  884.     /* Odd part per figure 8; the matrix is unitary and hence its

  885.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.

  886.      */

  887.     if (d7) {

  888. 	if (d5) {

  889. 	    if (d3) {

  890. 		if (d1) {

  891. 		    /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */

  892. 		    z1 = d7 + d1;

  893. 		    z2 = d5 + d3;

  894. 		    z3 = d7 + d3;

  895. 		    z4 = d5 + d1;

  896. 		    z5 = MULTIPLY(z3 + z4, FIX_1_175875602);

  897. 		    

  898. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  899. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  900. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  901. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  902. 		    z1 = MULTIPLY(-z1, FIX_0_899976223);

  903. 		    z2 = MULTIPLY(-z2, FIX_2_562915447);

  904. 		    z3 = MULTIPLY(-z3, FIX_1_961570560);

  905. 		    z4 = MULTIPLY(-z4, FIX_0_390180644);

  906. 		    

  907. 		    z3 += z5;

  908. 		    z4 += z5;

  909. 		    

  910. 		    tmp0 += z1 + z3;

  911. 		    tmp1 += z2 + z4;

  912. 		    tmp2 += z2 + z3;

  913. 		    tmp3 += z1 + z4;

  914. 		} else {

  915. 		    /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */

  916. 		    z1 = d7;

  917. 		    z2 = d5 + d3;

  918. 		    z3 = d7 + d3;

  919. 		    z5 = MULTIPLY(z3 + d5, FIX_1_175875602);

  920. 		    

  921. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  922. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  923. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  924. 		    z1 = MULTIPLY(-d7, FIX_0_899976223);

  925. 		    z2 = MULTIPLY(-z2, FIX_2_562915447);

  926. 		    z3 = MULTIPLY(-z3, FIX_1_961570560);

  927. 		    z4 = MULTIPLY(-d5, FIX_0_390180644);

  928. 		    

  929. 		    z3 += z5;

  930. 		    z4 += z5;

  931. 		    

  932. 		    tmp0 += z1 + z3;

  933. 		    tmp1 += z2 + z4;

  934. 		    tmp2 += z2 + z3;

  935. 		    tmp3 = z1 + z4;

  936. 		}

  937. 	    } else {

  938. 		if (d1) {

  939. 		    /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */

  940. 		    z1 = d7 + d1;

  941. 		    z2 = d5;

  942. 		    z3 = d7;

  943. 		    z4 = d5 + d1;

  944. 		    z5 = MULTIPLY(z3 + z4, FIX_1_175875602);

  945. 		    

  946. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  947. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  948. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  949. 		    z1 = MULTIPLY(-z1, FIX_0_899976223);

  950. 		    z2 = MULTIPLY(-d5, FIX_2_562915447);

  951. 		    z3 = MULTIPLY(-d7, FIX_1_961570560);

  952. 		    z4 = MULTIPLY(-z4, FIX_0_390180644);

  953. 		    

  954. 		    z3 += z5;

  955. 		    z4 += z5;

  956. 		    

  957. 		    tmp0 += z1 + z3;

  958. 		    tmp1 += z2 + z4;

  959. 		    tmp2 = z2 + z3;

  960. 		    tmp3 += z1 + z4;

  961. 		} else {

  962. 		    /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */

  963. 		    tmp0 = MULTIPLY(-d7, FIX_0_601344887); 

  964. 		    z1 = MULTIPLY(-d7, FIX_0_899976223);

  965. 		    z3 = MULTIPLY(-d7, FIX_1_961570560);

  966. 		    tmp1 = MULTIPLY(-d5, FIX_0_509795579);

  967. 		    z2 = MULTIPLY(-d5, FIX_2_562915447);

  968. 		    z4 = MULTIPLY(-d5, FIX_0_390180644);

  969. 		    z5 = MULTIPLY(d5 + d7, FIX_1_175875602);

  970. 		    

  971. 		    z3 += z5;

  972. 		    z4 += z5;

  973. 		    

  974. 		    tmp0 += z3;

  975. 		    tmp1 += z4;

  976. 		    tmp2 = z2 + z3;

  977. 		    tmp3 = z1 + z4;

  978. 		}

  979. 	    }

  980. 	} else {

  981. 	    if (d3) {

  982. 		if (d1) {

  983. 		    /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */

  984. 		    z1 = d7 + d1;

  985. 		    z3 = d7 + d3;

  986. 		    z5 = MULTIPLY(z3 + d1, FIX_1_175875602);

  987. 		    

  988. 		    tmp0 = MULTIPLY(d7, FIX_0_298631336); 

  989. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  990. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  991. 		    z1 = MULTIPLY(-z1, FIX_0_899976223);

  992. 		    z2 = MULTIPLY(-d3, FIX_2_562915447);

  993. 		    z3 = MULTIPLY(-z3, FIX_1_961570560);

  994. 		    z4 = MULTIPLY(-d1, FIX_0_390180644);

  995. 		    

  996. 		    z3 += z5;

  997. 		    z4 += z5;

  998. 		    

  999. 		    tmp0 += z1 + z3;

  1000. 		    tmp1 = z2 + z4;

  1001. 		    tmp2 += z2 + z3;

  1002. 		    tmp3 += z1 + z4;

  1003. 		} else {

  1004. 		    /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */

  1005. 		    z3 = d7 + d3;

  1006. 		    

  1007. 		    tmp0 = MULTIPLY(-d7, FIX_0_601344887); 

  1008. 		    z1 = MULTIPLY(-d7, FIX_0_899976223);

  1009. 		    tmp2 = MULTIPLY(d3, FIX_0_509795579);

  1010. 		    z2 = MULTIPLY(-d3, FIX_2_562915447);

  1011. 		    z5 = MULTIPLY(z3, FIX_1_175875602);

  1012. 		    z3 = MULTIPLY(-z3, FIX_0_785694958);

  1013. 		    

  1014. 		    tmp0 += z3;

  1015. 		    tmp1 = z2 + z5;

  1016. 		    tmp2 += z3;

  1017. 		    tmp3 = z1 + z5;

  1018. 		}

  1019. 	    } else {

  1020. 		if (d1) {

  1021. 		    /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */

  1022. 		    z1 = d7 + d1;

  1023. 		    z5 = MULTIPLY(z1, FIX_1_175875602);

  1024. 

  1025. 		    z1 = MULTIPLY(z1, FIX_0_275899380);

  1026. 		    z3 = MULTIPLY(-d7, FIX_1_961570560);

  1027. 		    tmp0 = MULTIPLY(-d7, FIX_1_662939225); 

  1028. 		    z4 = MULTIPLY(-d1, FIX_0_390180644);

  1029. 		    tmp3 = MULTIPLY(d1, FIX_1_111140466);

  1030. 

  1031. 		    tmp0 += z1;

  1032. 		    tmp1 = z4 + z5;

  1033. 		    tmp2 = z3 + z5;

  1034. 		    tmp3 += z1;

  1035. 		} else {

  1036. 		    /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */

  1037. 		    tmp0 = MULTIPLY(-d7, FIX_1_387039845);

  1038. 		    tmp1 = MULTIPLY(d7, FIX_1_175875602);

  1039. 		    tmp2 = MULTIPLY(-d7, FIX_0_785694958);

  1040. 		    tmp3 = MULTIPLY(d7, FIX_0_275899380);

  1041. 		}

  1042. 	    }

  1043. 	}

  1044.     } else {

  1045. 	if (d5) {

  1046. 	    if (d3) {

  1047. 		if (d1) {

  1048. 		    /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */

  1049. 		    z2 = d5 + d3;

  1050. 		    z4 = d5 + d1;

  1051. 		    z5 = MULTIPLY(d3 + z4, FIX_1_175875602);

  1052. 		    

  1053. 		    tmp1 = MULTIPLY(d5, FIX_2_053119869);

  1054. 		    tmp2 = MULTIPLY(d3, FIX_3_072711026);

  1055. 		    tmp3 = MULTIPLY(d1, FIX_1_501321110);

  1056. 		    z1 = MULTIPLY(-d1, FIX_0_899976223);

  1057. 		    z2 = MULTIPLY(-z2, FIX_2_562915447);

  1058. 		    z3 = MULTIPLY(-d3, FIX_1_961570560);

  1059. 		    z4 = MULTIPLY(-z4, FIX_0_390180644);

  1060. 		    

  1061. 		    z3 += z5;

  1062. 		    z4 += z5;

  1063. 		    

  1064. 		    tmp0 = z1 + z3;

  1065. 		    tmp1 += z2 + z4;

  1066. 		    tmp2 += z2 + z3;

  1067. 		    tmp3 += z1 + z4;

  1068. 		} else {

  1069. 		    /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */

  1070. 		    z2 = d5 + d3;

  1071. 		    

  1072. 		    z5 = MULTIPLY(z2, FIX_1_175875602);

  1073. 		    tmp1 = MULTIPLY(d5, FIX_1_662939225);

  1074. 		    z4 = MULTIPLY(-d5, FIX_0_390180644);

  1075. 		    z2 = MULTIPLY(-z2, FIX_1_387039845);

  1076. 		    tmp2 = MULTIPLY(d3, FIX_1_111140466);

  1077. 		    z3 = MULTIPLY(-d3, FIX_1_961570560);

  1078. 		    

  1079. 		    tmp0 = z3 + z5;

  1080. 		    tmp1 += z2;

  1081. 		    tmp2 += z2;

  1082. 		    tmp3 = z4 + z5;

  1083. 		}

  1084. 	    } else {

  1085. 		if (d1) {

  1086. 		    /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */

  1087. 		    z4 = d5 + d1;

  1088. 		    

  1089. 		    z5 = MULTIPLY(z4, FIX_1_175875602);

  1090. 		    z1 = MULTIPLY(-d1, FIX_0_899976223);

  1091. 		    tmp3 = MULTIPLY(d1, FIX_0_601344887);

  1092. 		    tmp1 = MULTIPLY(-d5, FIX_0_509795579);

  1093. 		    z2 = MULTIPLY(-d5, FIX_2_562915447);

  1094. 		    z4 = MULTIPLY(z4, FIX_0_785694958);

  1095. 		    

  1096. 		    tmp0 = z1 + z5;

  1097. 		    tmp1 += z4;

  1098. 		    tmp2 = z2 + z5;

  1099. 		    tmp3 += z4;

  1100. 		} else {

  1101. 		    /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */

  1102. 		    tmp0 = MULTIPLY(d5, FIX_1_175875602);

  1103. 		    tmp1 = MULTIPLY(d5, FIX_0_275899380);

  1104. 		    tmp2 = MULTIPLY(-d5, FIX_1_387039845);

  1105. 		    tmp3 = MULTIPLY(d5, FIX_0_785694958);

  1106. 		}

  1107. 	    }

  1108. 	} else {

  1109. 	    if (d3) {

  1110. 		if (d1) {

  1111. 		    /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */

  1112. 		    z5 = d1 + d3;

  1113. 		    tmp3 = MULTIPLY(d1, FIX_0_211164243);

  1114. 		    tmp2 = MULTIPLY(-d3, FIX_1_451774981);

  1115. 		    z1 = MULTIPLY(d1, FIX_1_061594337);

  1116. 		    z2 = MULTIPLY(-d3, FIX_2_172734803);

  1117. 		    z4 = MULTIPLY(z5, FIX_0_785694958);

  1118. 		    z5 = MULTIPLY(z5, FIX_1_175875602);

  1119. 		    

  1120. 		    tmp0 = z1 - z4;

  1121. 		    tmp1 = z2 + z4;

  1122. 		    tmp2 += z5;

  1123. 		    tmp3 += z5;

  1124. 		} else {

  1125. 		    /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */

  1126. 		    tmp0 = MULTIPLY(-d3, FIX_0_785694958);

  1127. 		    tmp1 = MULTIPLY(-d3, FIX_1_387039845);

  1128. 		    tmp2 = MULTIPLY(-d3, FIX_0_275899380);

  1129. 		    tmp3 = MULTIPLY(d3, FIX_1_175875602);

  1130. 		}

  1131. 	    } else {

  1132. 		if (d1) {

  1133. 		    /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */

  1134. 		    tmp0 = MULTIPLY(d1, FIX_0_275899380);

  1135. 		    tmp1 = MULTIPLY(d1, FIX_0_785694958);

  1136. 		    tmp2 = MULTIPLY(d1, FIX_1_175875602);

  1137. 		    tmp3 = MULTIPLY(d1, FIX_1_387039845);

  1138. 		} else {

  1139. 		    /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */

  1140. 		    tmp0 = tmp1 = tmp2 = tmp3 = 0;

  1141. 		}

  1142. 	    }

  1143. 	}

  1144.     }

  1145. 

  1146.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */

  1147. 

  1148.     dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp3,

  1149. 					   CONST_BITS+PASS1_BITS+3);

  1150.     dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp10 - tmp3,

  1151. 					   CONST_BITS+PASS1_BITS+3);

  1152.     dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp11 + tmp2,

  1153. 					   CONST_BITS+PASS1_BITS+3);

  1154.     dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(tmp11 - tmp2,

  1155. 					   CONST_BITS+PASS1_BITS+3);

  1156.     dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp12 + tmp1,

  1157. 					   CONST_BITS+PASS1_BITS+3);

  1158.     dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12 - tmp1,

  1159. 					   CONST_BITS+PASS1_BITS+3);

  1160.     dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp13 + tmp0,

  1161. 					   CONST_BITS+PASS1_BITS+3);

  1162.     dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp13 - tmp0,

  1163. 					   CONST_BITS+PASS1_BITS+3);

  1164.     

  1165.     dataptr++;			/* advance pointer to next column */

  1166.   }

  1167. }

  1168.