1/8 resolution decoding
[ffmpeg.git] / libavcodec / jrevdct.c
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  
29 /**
30  * @file jrevdct.c
31  * Independent JPEG Group's LLM idct.
32  */
33  
34 #include "common.h"
35 #include "dsputil.h"
36
37 #define EIGHT_BIT_SAMPLES
38
39 #define DCTSIZE 8
40 #define DCTSIZE2 64
41
42 #define GLOBAL
43
44 #define RIGHT_SHIFT(x, n) ((x) >> (n))
45
46 typedef DCTELEM DCTBLOCK[DCTSIZE2];
47
48 #define CONST_BITS 13
49
50 /*
51  * This routine is specialized to the case DCTSIZE = 8.
52  */
53
54 #if DCTSIZE != 8
55   Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
56 #endif
57
58
59 /*
60  * A 2-D IDCT can be done by 1-D IDCT on each row followed by 1-D IDCT
61  * on each column.  Direct algorithms are also available, but they are
62  * much more complex and seem not to be any faster when reduced to code.
63  *
64  * The poop on this scaling stuff is as follows:
65  *
66  * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
67  * larger than the true IDCT outputs.  The final outputs are therefore
68  * a factor of N larger than desired; since N=8 this can be cured by
69  * a simple right shift at the end of the algorithm.  The advantage of
70  * this arrangement is that we save two multiplications per 1-D IDCT,
71  * because the y0 and y4 inputs need not be divided by sqrt(N).
72  *
73  * We have to do addition and subtraction of the integer inputs, which
74  * is no problem, and multiplication by fractional constants, which is
75  * a problem to do in integer arithmetic.  We multiply all the constants
76  * by CONST_SCALE and convert them to integer constants (thus retaining
77  * CONST_BITS bits of precision in the constants).  After doing a
78  * multiplication we have to divide the product by CONST_SCALE, with proper
79  * rounding, to produce the correct output.  This division can be done
80  * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
81  * as long as possible so that partial sums can be added together with
82  * full fractional precision.
83  *
84  * The outputs of the first pass are scaled up by PASS1_BITS bits so that
85  * they are represented to better-than-integral precision.  These outputs
86  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
87  * with the recommended scaling.  (To scale up 12-bit sample data further, an
88  * intermediate int32 array would be needed.)
89  *
90  * To avoid overflow of the 32-bit intermediate results in pass 2, we must
91  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
92  * shows that the values given below are the most effective.
93  */
94
95 #ifdef EIGHT_BIT_SAMPLES
96 #define PASS1_BITS  2
97 #else
98 #define PASS1_BITS  1           /* lose a little precision to avoid overflow */
99 #endif
100
101 #define ONE     ((int32_t) 1)
102
103 #define CONST_SCALE (ONE << CONST_BITS)
104
105 /* Convert a positive real constant to an integer scaled by CONST_SCALE.
106  * IMPORTANT: if your compiler doesn't do this arithmetic at compile time,
107  * you will pay a significant penalty in run time.  In that case, figure
108  * the correct integer constant values and insert them by hand.
109  */
110
111 /* Actually FIX is no longer used, we precomputed them all */
112 #define FIX(x)  ((int32_t) ((x) * CONST_SCALE + 0.5)) 
113
114 /* Descale and correctly round an int32_t value that's scaled by N bits.
115  * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
116  * the fudge factor is correct for either sign of X.
117  */
118
119 #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
120
121 /* Multiply an int32_t variable by an int32_t constant to yield an int32_t result.
122  * For 8-bit samples with the recommended scaling, all the variable
123  * and constant values involved are no more than 16 bits wide, so a
124  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply;
125  * this provides a useful speedup on many machines.
126  * There is no way to specify a 16x16->32 multiply in portable C, but
127  * some C compilers will do the right thing if you provide the correct
128  * combination of casts.
129  * NB: for 12-bit samples, a full 32-bit multiplication will be needed.
130  */
131
132 #ifdef EIGHT_BIT_SAMPLES
133 #ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
134 #define MULTIPLY(var,const)  (((int16_t) (var)) * ((int16_t) (const)))
135 #endif
136 #ifdef SHORTxLCONST_32          /* known to work with Microsoft C 6.0 */
137 #define MULTIPLY(var,const)  (((int16_t) (var)) * ((int32_t) (const)))
138 #endif
139 #endif
140
141 #ifndef MULTIPLY                /* default definition */
142 #define MULTIPLY(var,const)  ((var) * (const))
143 #endif
144
145
146 /* 
147   Unlike our decoder where we approximate the FIXes, we need to use exact
148 ones here or successive P-frames will drift too much with Reference frame coding 
149 */
150 #define FIX_0_211164243 1730
151 #define FIX_0_275899380 2260
152 #define FIX_0_298631336 2446
153 #define FIX_0_390180644 3196
154 #define FIX_0_509795579 4176
155 #define FIX_0_541196100 4433
156 #define FIX_0_601344887 4926
157 #define FIX_0_765366865 6270
158 #define FIX_0_785694958 6436
159 #define FIX_0_899976223 7373
160 #define FIX_1_061594337 8697
161 #define FIX_1_111140466 9102
162 #define FIX_1_175875602 9633
163 #define FIX_1_306562965 10703
164 #define FIX_1_387039845 11363
165 #define FIX_1_451774981 11893
166 #define FIX_1_501321110 12299
167 #define FIX_1_662939225 13623
168 #define FIX_1_847759065 15137
169 #define FIX_1_961570560 16069
170 #define FIX_2_053119869 16819
171 #define FIX_2_172734803 17799
172 #define FIX_2_562915447 20995
173 #define FIX_3_072711026 25172
174
175 /*
176  * Perform the inverse DCT on one block of coefficients.
177  */
178
179 void j_rev_dct(DCTBLOCK data)
180 {
181   int32_t tmp0, tmp1, tmp2, tmp3;
182   int32_t tmp10, tmp11, tmp12, tmp13;
183   int32_t z1, z2, z3, z4, z5;
184   int32_t d0, d1, d2, d3, d4, d5, d6, d7;
185   register DCTELEM *dataptr;
186   int rowctr;
187    
188   /* Pass 1: process rows. */
189   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
190   /* furthermore, we scale the results by 2**PASS1_BITS. */
191
192   dataptr = data;
193
194   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
195     /* Due to quantization, we will usually find that many of the input
196      * coefficients are zero, especially the AC terms.  We can exploit this
197      * by short-circuiting the IDCT calculation for any row in which all
198      * the AC terms are zero.  In that case each output is equal to the
199      * DC coefficient (with scale factor as needed).
200      * With typical images and quantization tables, half or more of the
201      * row DCT calculations can be simplified this way.
202      */
203
204     register int *idataptr = (int*)dataptr;
205
206     /* WARNING: we do the same permutation as MMX idct to simplify the
207        video core */
208     d0 = dataptr[0];
209     d2 = dataptr[1];
210     d4 = dataptr[2];
211     d6 = dataptr[3];
212     d1 = dataptr[4];
213     d3 = dataptr[5];
214     d5 = dataptr[6];
215     d7 = dataptr[7];
216
217     if ((d1 | d2 | d3 | d4 | d5 | d6 | d7) == 0) {
218       /* AC terms all zero */
219       if (d0) {
220           /* Compute a 32 bit value to assign. */
221           DCTELEM dcval = (DCTELEM) (d0 << PASS1_BITS);
222           register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
223           
224           idataptr[0] = v;
225           idataptr[1] = v;
226           idataptr[2] = v;
227           idataptr[3] = v;
228       }
229       
230       dataptr += DCTSIZE;       /* advance pointer to next row */
231       continue;
232     }
233
234     /* Even part: reverse the even part of the forward DCT. */
235     /* The rotator is sqrt(2)*c(-6). */
236 {
237     if (d6) {
238         if (d4) {
239             if (d2) {
240                 if (d0) {
241                     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
242                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
243                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
244                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
245
246                     tmp0 = (d0 + d4) << CONST_BITS;
247                     tmp1 = (d0 - d4) << CONST_BITS;
248
249                     tmp10 = tmp0 + tmp3;
250                     tmp13 = tmp0 - tmp3;
251                     tmp11 = tmp1 + tmp2;
252                     tmp12 = tmp1 - tmp2;
253                 } else {
254                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
255                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
256                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
257                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
258
259                     tmp0 = d4 << CONST_BITS;
260
261                     tmp10 = tmp0 + tmp3;
262                     tmp13 = tmp0 - tmp3;
263                     tmp11 = tmp2 - tmp0;
264                     tmp12 = -(tmp0 + tmp2);
265                 }
266             } else {
267                 if (d0) {
268                     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
269                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
270                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
271
272                     tmp0 = (d0 + d4) << CONST_BITS;
273                     tmp1 = (d0 - d4) << CONST_BITS;
274
275                     tmp10 = tmp0 + tmp3;
276                     tmp13 = tmp0 - tmp3;
277                     tmp11 = tmp1 + tmp2;
278                     tmp12 = tmp1 - tmp2;
279                 } else {
280                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
281                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
282                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
283
284                     tmp0 = d4 << CONST_BITS;
285
286                     tmp10 = tmp0 + tmp3;
287                     tmp13 = tmp0 - tmp3;
288                     tmp11 = tmp2 - tmp0;
289                     tmp12 = -(tmp0 + tmp2);
290                 }
291             }
292         } else {
293             if (d2) {
294                 if (d0) {
295                     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
296                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
297                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
298                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
299
300                     tmp0 = d0 << CONST_BITS;
301
302                     tmp10 = tmp0 + tmp3;
303                     tmp13 = tmp0 - tmp3;
304                     tmp11 = tmp0 + tmp2;
305                     tmp12 = tmp0 - tmp2;
306                 } else {
307                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
308                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
309                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
310                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
311
312                     tmp10 = tmp3;
313                     tmp13 = -tmp3;
314                     tmp11 = tmp2;
315                     tmp12 = -tmp2;
316                 }
317             } else {
318                 if (d0) {
319                     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
320                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
321                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
322
323                     tmp0 = d0 << CONST_BITS;
324
325                     tmp10 = tmp0 + tmp3;
326                     tmp13 = tmp0 - tmp3;
327                     tmp11 = tmp0 + tmp2;
328                     tmp12 = tmp0 - tmp2;
329                 } else {
330                     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
331                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
332                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
333
334                     tmp10 = tmp3;
335                     tmp13 = -tmp3;
336                     tmp11 = tmp2;
337                     tmp12 = -tmp2;
338                 }
339             }
340         }
341     } else {
342         if (d4) {
343             if (d2) {
344                 if (d0) {
345                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
346                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
347                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
348
349                     tmp0 = (d0 + d4) << CONST_BITS;
350                     tmp1 = (d0 - d4) << CONST_BITS;
351
352                     tmp10 = tmp0 + tmp3;
353                     tmp13 = tmp0 - tmp3;
354                     tmp11 = tmp1 + tmp2;
355                     tmp12 = tmp1 - tmp2;
356                 } else {
357                     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
358                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
359                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
360
361                     tmp0 = d4 << CONST_BITS;
362
363                     tmp10 = tmp0 + tmp3;
364                     tmp13 = tmp0 - tmp3;
365                     tmp11 = tmp2 - tmp0;
366                     tmp12 = -(tmp0 + tmp2);
367                 }
368             } else {
369                 if (d0) {
370                     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
371                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
372                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
373                 } else {
374                     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
375                     tmp10 = tmp13 = d4 << CONST_BITS;
376                     tmp11 = tmp12 = -tmp10;
377                 }
378             }
379         } else {
380             if (d2) {
381                 if (d0) {
382                     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
383                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
384                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
385
386                     tmp0 = d0 << CONST_BITS;
387
388                     tmp10 = tmp0 + tmp3;
389                     tmp13 = tmp0 - tmp3;
390                     tmp11 = tmp0 + tmp2;
391                     tmp12 = tmp0 - tmp2;
392                 } else {
393                     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
394                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
395                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
396
397                     tmp10 = tmp3;
398                     tmp13 = -tmp3;
399                     tmp11 = tmp2;
400                     tmp12 = -tmp2;
401                 }
402             } else {
403                 if (d0) {
404                     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
405                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
406                 } else {
407                     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
408                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
409                 }
410             }
411         }
412       }
413
414     /* Odd part per figure 8; the matrix is unitary and hence its
415      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
416      */
417
418     if (d7) {
419         if (d5) {
420             if (d3) {
421                 if (d1) {
422                     /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
423                     z1 = d7 + d1;
424                     z2 = d5 + d3;
425                     z3 = d7 + d3;
426                     z4 = d5 + d1;
427                     z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
428                     
429                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
430                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
431                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
432                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
433                     z1 = MULTIPLY(-z1, FIX_0_899976223);
434                     z2 = MULTIPLY(-z2, FIX_2_562915447);
435                     z3 = MULTIPLY(-z3, FIX_1_961570560);
436                     z4 = MULTIPLY(-z4, FIX_0_390180644);
437                     
438                     z3 += z5;
439                     z4 += z5;
440                     
441                     tmp0 += z1 + z3;
442                     tmp1 += z2 + z4;
443                     tmp2 += z2 + z3;
444                     tmp3 += z1 + z4;
445                 } else {
446                     /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
447                     z2 = d5 + d3;
448                     z3 = d7 + d3;
449                     z5 = MULTIPLY(z3 + d5, FIX_1_175875602);
450                     
451                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
452                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
453                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
454                     z1 = MULTIPLY(-d7, FIX_0_899976223);
455                     z2 = MULTIPLY(-z2, FIX_2_562915447);
456                     z3 = MULTIPLY(-z3, FIX_1_961570560);
457                     z4 = MULTIPLY(-d5, FIX_0_390180644);
458                     
459                     z3 += z5;
460                     z4 += z5;
461                     
462                     tmp0 += z1 + z3;
463                     tmp1 += z2 + z4;
464                     tmp2 += z2 + z3;
465                     tmp3 = z1 + z4;
466                 }
467             } else {
468                 if (d1) {
469                     /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
470                     z1 = d7 + d1;
471                     z4 = d5 + d1;
472                     z5 = MULTIPLY(d7 + z4, FIX_1_175875602);
473                     
474                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
475                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
476                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
477                     z1 = MULTIPLY(-z1, FIX_0_899976223);
478                     z2 = MULTIPLY(-d5, FIX_2_562915447);
479                     z3 = MULTIPLY(-d7, FIX_1_961570560);
480                     z4 = MULTIPLY(-z4, FIX_0_390180644);
481                     
482                     z3 += z5;
483                     z4 += z5;
484                     
485                     tmp0 += z1 + z3;
486                     tmp1 += z2 + z4;
487                     tmp2 = z2 + z3;
488                     tmp3 += z1 + z4;
489                 } else {
490                     /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
491                     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
492                     z1 = MULTIPLY(-d7, FIX_0_899976223);
493                     z3 = MULTIPLY(-d7, FIX_1_961570560);
494                     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
495                     z2 = MULTIPLY(-d5, FIX_2_562915447);
496                     z4 = MULTIPLY(-d5, FIX_0_390180644);
497                     z5 = MULTIPLY(d5 + d7, FIX_1_175875602);
498                     
499                     z3 += z5;
500                     z4 += z5;
501                     
502                     tmp0 += z3;
503                     tmp1 += z4;
504                     tmp2 = z2 + z3;
505                     tmp3 = z1 + z4;
506                 }
507             }
508         } else {
509             if (d3) {
510                 if (d1) {
511                     /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
512                     z1 = d7 + d1;
513                     z3 = d7 + d3;
514                     z5 = MULTIPLY(z3 + d1, FIX_1_175875602);
515                     
516                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
517                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
518                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
519                     z1 = MULTIPLY(-z1, FIX_0_899976223);
520                     z2 = MULTIPLY(-d3, FIX_2_562915447);
521                     z3 = MULTIPLY(-z3, FIX_1_961570560);
522                     z4 = MULTIPLY(-d1, FIX_0_390180644);
523                     
524                     z3 += z5;
525                     z4 += z5;
526                     
527                     tmp0 += z1 + z3;
528                     tmp1 = z2 + z4;
529                     tmp2 += z2 + z3;
530                     tmp3 += z1 + z4;
531                 } else {
532                     /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
533                     z3 = d7 + d3;
534                     
535                     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
536                     z1 = MULTIPLY(-d7, FIX_0_899976223);
537                     tmp2 = MULTIPLY(d3, FIX_0_509795579);
538                     z2 = MULTIPLY(-d3, FIX_2_562915447);
539                     z5 = MULTIPLY(z3, FIX_1_175875602);
540                     z3 = MULTIPLY(-z3, FIX_0_785694958);
541                     
542                     tmp0 += z3;
543                     tmp1 = z2 + z5;
544                     tmp2 += z3;
545                     tmp3 = z1 + z5;
546                 }
547             } else {
548                 if (d1) {
549                     /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
550                     z1 = d7 + d1;
551                     z5 = MULTIPLY(z1, FIX_1_175875602);
552
553                     z1 = MULTIPLY(z1, FIX_0_275899380);
554                     z3 = MULTIPLY(-d7, FIX_1_961570560);
555                     tmp0 = MULTIPLY(-d7, FIX_1_662939225); 
556                     z4 = MULTIPLY(-d1, FIX_0_390180644);
557                     tmp3 = MULTIPLY(d1, FIX_1_111140466);
558
559                     tmp0 += z1;
560                     tmp1 = z4 + z5;
561                     tmp2 = z3 + z5;
562                     tmp3 += z1;
563                 } else {
564                     /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
565                     tmp0 = MULTIPLY(-d7, FIX_1_387039845);
566                     tmp1 = MULTIPLY(d7, FIX_1_175875602);
567                     tmp2 = MULTIPLY(-d7, FIX_0_785694958);
568                     tmp3 = MULTIPLY(d7, FIX_0_275899380);
569                 }
570             }
571         }
572     } else {
573         if (d5) {
574             if (d3) {
575                 if (d1) {
576                     /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
577                     z2 = d5 + d3;
578                     z4 = d5 + d1;
579                     z5 = MULTIPLY(d3 + z4, FIX_1_175875602);
580                     
581                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
582                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
583                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
584                     z1 = MULTIPLY(-d1, FIX_0_899976223);
585                     z2 = MULTIPLY(-z2, FIX_2_562915447);
586                     z3 = MULTIPLY(-d3, FIX_1_961570560);
587                     z4 = MULTIPLY(-z4, FIX_0_390180644);
588                     
589                     z3 += z5;
590                     z4 += z5;
591                     
592                     tmp0 = z1 + z3;
593                     tmp1 += z2 + z4;
594                     tmp2 += z2 + z3;
595                     tmp3 += z1 + z4;
596                 } else {
597                     /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
598                     z2 = d5 + d3;
599                     
600                     z5 = MULTIPLY(z2, FIX_1_175875602);
601                     tmp1 = MULTIPLY(d5, FIX_1_662939225);
602                     z4 = MULTIPLY(-d5, FIX_0_390180644);
603                     z2 = MULTIPLY(-z2, FIX_1_387039845);
604                     tmp2 = MULTIPLY(d3, FIX_1_111140466);
605                     z3 = MULTIPLY(-d3, FIX_1_961570560);
606                     
607                     tmp0 = z3 + z5;
608                     tmp1 += z2;
609                     tmp2 += z2;
610                     tmp3 = z4 + z5;
611                 }
612             } else {
613                 if (d1) {
614                     /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
615                     z4 = d5 + d1;
616                     
617                     z5 = MULTIPLY(z4, FIX_1_175875602);
618                     z1 = MULTIPLY(-d1, FIX_0_899976223);
619                     tmp3 = MULTIPLY(d1, FIX_0_601344887);
620                     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
621                     z2 = MULTIPLY(-d5, FIX_2_562915447);
622                     z4 = MULTIPLY(z4, FIX_0_785694958);
623                     
624                     tmp0 = z1 + z5;
625                     tmp1 += z4;
626                     tmp2 = z2 + z5;
627                     tmp3 += z4;
628                 } else {
629                     /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
630                     tmp0 = MULTIPLY(d5, FIX_1_175875602);
631                     tmp1 = MULTIPLY(d5, FIX_0_275899380);
632                     tmp2 = MULTIPLY(-d5, FIX_1_387039845);
633                     tmp3 = MULTIPLY(d5, FIX_0_785694958);
634                 }
635             }
636         } else {
637             if (d3) {
638                 if (d1) {
639                     /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
640                     z5 = d1 + d3;
641                     tmp3 = MULTIPLY(d1, FIX_0_211164243);
642                     tmp2 = MULTIPLY(-d3, FIX_1_451774981);
643                     z1 = MULTIPLY(d1, FIX_1_061594337);
644                     z2 = MULTIPLY(-d3, FIX_2_172734803);
645                     z4 = MULTIPLY(z5, FIX_0_785694958);
646                     z5 = MULTIPLY(z5, FIX_1_175875602);
647                     
648                     tmp0 = z1 - z4;
649                     tmp1 = z2 + z4;
650                     tmp2 += z5;
651                     tmp3 += z5;
652                 } else {
653                     /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
654                     tmp0 = MULTIPLY(-d3, FIX_0_785694958);
655                     tmp1 = MULTIPLY(-d3, FIX_1_387039845);
656                     tmp2 = MULTIPLY(-d3, FIX_0_275899380);
657                     tmp3 = MULTIPLY(d3, FIX_1_175875602);
658                 }
659             } else {
660                 if (d1) {
661                     /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
662                     tmp0 = MULTIPLY(d1, FIX_0_275899380);
663                     tmp1 = MULTIPLY(d1, FIX_0_785694958);
664                     tmp2 = MULTIPLY(d1, FIX_1_175875602);
665                     tmp3 = MULTIPLY(d1, FIX_1_387039845);
666                 } else {
667                     /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
668                     tmp0 = tmp1 = tmp2 = tmp3 = 0;
669                 }
670             }
671         }
672     }
673 }
674     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
675
676     dataptr[0] = (DCTELEM) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
677     dataptr[7] = (DCTELEM) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
678     dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
679     dataptr[6] = (DCTELEM) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
680     dataptr[2] = (DCTELEM) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
681     dataptr[5] = (DCTELEM) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
682     dataptr[3] = (DCTELEM) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
683     dataptr[4] = (DCTELEM) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
684
685     dataptr += DCTSIZE;         /* advance pointer to next row */
686   }
687
688   /* Pass 2: process columns. */
689   /* Note that we must descale the results by a factor of 8 == 2**3, */
690   /* and also undo the PASS1_BITS scaling. */
691
692   dataptr = data;
693   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
694     /* Columns of zeroes can be exploited in the same way as we did with rows.
695      * However, the row calculation has created many nonzero AC terms, so the
696      * simplification applies less often (typically 5% to 10% of the time).
697      * On machines with very fast multiplication, it's possible that the
698      * test takes more time than it's worth.  In that case this section
699      * may be commented out.
700      */
701
702     d0 = dataptr[DCTSIZE*0];
703     d1 = dataptr[DCTSIZE*1];
704     d2 = dataptr[DCTSIZE*2];
705     d3 = dataptr[DCTSIZE*3];
706     d4 = dataptr[DCTSIZE*4];
707     d5 = dataptr[DCTSIZE*5];
708     d6 = dataptr[DCTSIZE*6];
709     d7 = dataptr[DCTSIZE*7];
710
711     /* Even part: reverse the even part of the forward DCT. */
712     /* The rotator is sqrt(2)*c(-6). */
713     if (d6) {
714         if (d4) {
715             if (d2) {
716                 if (d0) {
717                     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
718                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
719                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
720                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
721
722                     tmp0 = (d0 + d4) << CONST_BITS;
723                     tmp1 = (d0 - d4) << CONST_BITS;
724
725                     tmp10 = tmp0 + tmp3;
726                     tmp13 = tmp0 - tmp3;
727                     tmp11 = tmp1 + tmp2;
728                     tmp12 = tmp1 - tmp2;
729                 } else {
730                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
731                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
732                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
733                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
734
735                     tmp0 = d4 << CONST_BITS;
736
737                     tmp10 = tmp0 + tmp3;
738                     tmp13 = tmp0 - tmp3;
739                     tmp11 = tmp2 - tmp0;
740                     tmp12 = -(tmp0 + tmp2);
741                 }
742             } else {
743                 if (d0) {
744                     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
745                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
746                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
747
748                     tmp0 = (d0 + d4) << CONST_BITS;
749                     tmp1 = (d0 - d4) << CONST_BITS;
750
751                     tmp10 = tmp0 + tmp3;
752                     tmp13 = tmp0 - tmp3;
753                     tmp11 = tmp1 + tmp2;
754                     tmp12 = tmp1 - tmp2;
755                 } else {
756                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
757                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
758                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
759
760                     tmp0 = d4 << CONST_BITS;
761
762                     tmp10 = tmp0 + tmp3;
763                     tmp13 = tmp0 - tmp3;
764                     tmp11 = tmp2 - tmp0;
765                     tmp12 = -(tmp0 + tmp2);
766                 }
767             }
768         } else {
769             if (d2) {
770                 if (d0) {
771                     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
772                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
773                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
774                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
775
776                     tmp0 = d0 << CONST_BITS;
777
778                     tmp10 = tmp0 + tmp3;
779                     tmp13 = tmp0 - tmp3;
780                     tmp11 = tmp0 + tmp2;
781                     tmp12 = tmp0 - tmp2;
782                 } else {
783                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
784                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
785                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
786                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
787
788                     tmp10 = tmp3;
789                     tmp13 = -tmp3;
790                     tmp11 = tmp2;
791                     tmp12 = -tmp2;
792                 }
793             } else {
794                 if (d0) {
795                     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
796                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
797                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
798
799                     tmp0 = d0 << CONST_BITS;
800
801                     tmp10 = tmp0 + tmp3;
802                     tmp13 = tmp0 - tmp3;
803                     tmp11 = tmp0 + tmp2;
804                     tmp12 = tmp0 - tmp2;
805                 } else {
806                     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
807                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
808                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
809
810                     tmp10 = tmp3;
811                     tmp13 = -tmp3;
812                     tmp11 = tmp2;
813                     tmp12 = -tmp2;
814                 }
815             }
816         }
817     } else {
818         if (d4) {
819             if (d2) {
820                 if (d0) {
821                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
822                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
823                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
824
825                     tmp0 = (d0 + d4) << CONST_BITS;
826                     tmp1 = (d0 - d4) << CONST_BITS;
827
828                     tmp10 = tmp0 + tmp3;
829                     tmp13 = tmp0 - tmp3;
830                     tmp11 = tmp1 + tmp2;
831                     tmp12 = tmp1 - tmp2;
832                 } else {
833                     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
834                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
835                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
836
837                     tmp0 = d4 << CONST_BITS;
838
839                     tmp10 = tmp0 + tmp3;
840                     tmp13 = tmp0 - tmp3;
841                     tmp11 = tmp2 - tmp0;
842                     tmp12 = -(tmp0 + tmp2);
843                 }
844             } else {
845                 if (d0) {
846                     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
847                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
848                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
849                 } else {
850                     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
851                     tmp10 = tmp13 = d4 << CONST_BITS;
852                     tmp11 = tmp12 = -tmp10;
853                 }
854             }
855         } else {
856             if (d2) {
857                 if (d0) {
858                     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
859                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
860                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
861
862                     tmp0 = d0 << CONST_BITS;
863
864                     tmp10 = tmp0 + tmp3;
865                     tmp13 = tmp0 - tmp3;
866                     tmp11 = tmp0 + tmp2;
867                     tmp12 = tmp0 - tmp2;
868                 } else {
869                     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
870                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
871                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
872
873                     tmp10 = tmp3;
874                     tmp13 = -tmp3;
875                     tmp11 = tmp2;
876                     tmp12 = -tmp2;
877                 }
878             } else {
879                 if (d0) {
880                     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
881                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
882                 } else {
883                     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
884                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
885                 }
886             }
887         }
888     }
889
890     /* Odd part per figure 8; the matrix is unitary and hence its
891      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
892      */
893     if (d7) {
894         if (d5) {
895             if (d3) {
896                 if (d1) {
897                     /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
898                     z1 = d7 + d1;
899                     z2 = d5 + d3;
900                     z3 = d7 + d3;
901                     z4 = d5 + d1;
902                     z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
903                     
904                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
905                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
906                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
907                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
908                     z1 = MULTIPLY(-z1, FIX_0_899976223);
909                     z2 = MULTIPLY(-z2, FIX_2_562915447);
910                     z3 = MULTIPLY(-z3, FIX_1_961570560);
911                     z4 = MULTIPLY(-z4, FIX_0_390180644);
912                     
913                     z3 += z5;
914                     z4 += z5;
915                     
916                     tmp0 += z1 + z3;
917                     tmp1 += z2 + z4;
918                     tmp2 += z2 + z3;
919                     tmp3 += z1 + z4;
920                 } else {
921                     /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
922                     z1 = d7;
923                     z2 = d5 + d3;
924                     z3 = d7 + d3;
925                     z5 = MULTIPLY(z3 + d5, FIX_1_175875602);
926                     
927                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
928                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
929                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
930                     z1 = MULTIPLY(-d7, FIX_0_899976223);
931                     z2 = MULTIPLY(-z2, FIX_2_562915447);
932                     z3 = MULTIPLY(-z3, FIX_1_961570560);
933                     z4 = MULTIPLY(-d5, FIX_0_390180644);
934                     
935                     z3 += z5;
936                     z4 += z5;
937                     
938                     tmp0 += z1 + z3;
939                     tmp1 += z2 + z4;
940                     tmp2 += z2 + z3;
941                     tmp3 = z1 + z4;
942                 }
943             } else {
944                 if (d1) {
945                     /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
946                     z1 = d7 + d1;
947                     z2 = d5;
948                     z3 = d7;
949                     z4 = d5 + d1;
950                     z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
951                     
952                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
953                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
954                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
955                     z1 = MULTIPLY(-z1, FIX_0_899976223);
956                     z2 = MULTIPLY(-d5, FIX_2_562915447);
957                     z3 = MULTIPLY(-d7, FIX_1_961570560);
958                     z4 = MULTIPLY(-z4, FIX_0_390180644);
959                     
960                     z3 += z5;
961                     z4 += z5;
962                     
963                     tmp0 += z1 + z3;
964                     tmp1 += z2 + z4;
965                     tmp2 = z2 + z3;
966                     tmp3 += z1 + z4;
967                 } else {
968                     /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
969                     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
970                     z1 = MULTIPLY(-d7, FIX_0_899976223);
971                     z3 = MULTIPLY(-d7, FIX_1_961570560);
972                     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
973                     z2 = MULTIPLY(-d5, FIX_2_562915447);
974                     z4 = MULTIPLY(-d5, FIX_0_390180644);
975                     z5 = MULTIPLY(d5 + d7, FIX_1_175875602);
976                     
977                     z3 += z5;
978                     z4 += z5;
979                     
980                     tmp0 += z3;
981                     tmp1 += z4;
982                     tmp2 = z2 + z3;
983                     tmp3 = z1 + z4;
984                 }
985             }
986         } else {
987             if (d3) {
988                 if (d1) {
989                     /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
990                     z1 = d7 + d1;
991                     z3 = d7 + d3;
992                     z5 = MULTIPLY(z3 + d1, FIX_1_175875602);
993                     
994                     tmp0 = MULTIPLY(d7, FIX_0_298631336); 
995                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
996                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
997                     z1 = MULTIPLY(-z1, FIX_0_899976223);
998                     z2 = MULTIPLY(-d3, FIX_2_562915447);
999                     z3 = MULTIPLY(-z3, FIX_1_961570560);
1000                     z4 = MULTIPLY(-d1, FIX_0_390180644);
1001                     
1002                     z3 += z5;
1003                     z4 += z5;
1004                     
1005                     tmp0 += z1 + z3;
1006                     tmp1 = z2 + z4;
1007                     tmp2 += z2 + z3;
1008                     tmp3 += z1 + z4;
1009                 } else {
1010                     /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
1011                     z3 = d7 + d3;
1012                     
1013                     tmp0 = MULTIPLY(-d7, FIX_0_601344887); 
1014                     z1 = MULTIPLY(-d7, FIX_0_899976223);
1015                     tmp2 = MULTIPLY(d3, FIX_0_509795579);
1016                     z2 = MULTIPLY(-d3, FIX_2_562915447);
1017                     z5 = MULTIPLY(z3, FIX_1_175875602);
1018                     z3 = MULTIPLY(-z3, FIX_0_785694958);
1019                     
1020                     tmp0 += z3;
1021                     tmp1 = z2 + z5;
1022                     tmp2 += z3;
1023                     tmp3 = z1 + z5;
1024                 }
1025             } else {
1026                 if (d1) {
1027                     /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
1028                     z1 = d7 + d1;
1029                     z5 = MULTIPLY(z1, FIX_1_175875602);
1030
1031                     z1 = MULTIPLY(z1, FIX_0_275899380);
1032                     z3 = MULTIPLY(-d7, FIX_1_961570560);
1033                     tmp0 = MULTIPLY(-d7, FIX_1_662939225); 
1034                     z4 = MULTIPLY(-d1, FIX_0_390180644);
1035                     tmp3 = MULTIPLY(d1, FIX_1_111140466);
1036
1037                     tmp0 += z1;
1038                     tmp1 = z4 + z5;
1039                     tmp2 = z3 + z5;
1040                     tmp3 += z1;
1041                 } else {
1042                     /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
1043                     tmp0 = MULTIPLY(-d7, FIX_1_387039845);
1044                     tmp1 = MULTIPLY(d7, FIX_1_175875602);
1045                     tmp2 = MULTIPLY(-d7, FIX_0_785694958);
1046                     tmp3 = MULTIPLY(d7, FIX_0_275899380);
1047                 }
1048             }
1049         }
1050     } else {
1051         if (d5) {
1052             if (d3) {
1053                 if (d1) {
1054                     /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
1055                     z2 = d5 + d3;
1056                     z4 = d5 + d1;
1057                     z5 = MULTIPLY(d3 + z4, FIX_1_175875602);
1058                     
1059                     tmp1 = MULTIPLY(d5, FIX_2_053119869);
1060                     tmp2 = MULTIPLY(d3, FIX_3_072711026);
1061                     tmp3 = MULTIPLY(d1, FIX_1_501321110);
1062                     z1 = MULTIPLY(-d1, FIX_0_899976223);
1063                     z2 = MULTIPLY(-z2, FIX_2_562915447);
1064                     z3 = MULTIPLY(-d3, FIX_1_961570560);
1065                     z4 = MULTIPLY(-z4, FIX_0_390180644);
1066                     
1067                     z3 += z5;
1068                     z4 += z5;
1069                     
1070                     tmp0 = z1 + z3;
1071                     tmp1 += z2 + z4;
1072                     tmp2 += z2 + z3;
1073                     tmp3 += z1 + z4;
1074                 } else {
1075                     /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
1076                     z2 = d5 + d3;
1077                     
1078                     z5 = MULTIPLY(z2, FIX_1_175875602);
1079                     tmp1 = MULTIPLY(d5, FIX_1_662939225);
1080                     z4 = MULTIPLY(-d5, FIX_0_390180644);
1081                     z2 = MULTIPLY(-z2, FIX_1_387039845);
1082                     tmp2 = MULTIPLY(d3, FIX_1_111140466);
1083                     z3 = MULTIPLY(-d3, FIX_1_961570560);
1084                     
1085                     tmp0 = z3 + z5;
1086                     tmp1 += z2;
1087                     tmp2 += z2;
1088                     tmp3 = z4 + z5;
1089                 }
1090             } else {
1091                 if (d1) {
1092                     /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
1093                     z4 = d5 + d1;
1094                     
1095                     z5 = MULTIPLY(z4, FIX_1_175875602);
1096                     z1 = MULTIPLY(-d1, FIX_0_899976223);
1097                     tmp3 = MULTIPLY(d1, FIX_0_601344887);
1098                     tmp1 = MULTIPLY(-d5, FIX_0_509795579);
1099                     z2 = MULTIPLY(-d5, FIX_2_562915447);
1100                     z4 = MULTIPLY(z4, FIX_0_785694958);
1101                     
1102                     tmp0 = z1 + z5;
1103                     tmp1 += z4;
1104                     tmp2 = z2 + z5;
1105                     tmp3 += z4;
1106                 } else {
1107                     /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
1108                     tmp0 = MULTIPLY(d5, FIX_1_175875602);
1109                     tmp1 = MULTIPLY(d5, FIX_0_275899380);
1110                     tmp2 = MULTIPLY(-d5, FIX_1_387039845);
1111                     tmp3 = MULTIPLY(d5, FIX_0_785694958);
1112                 }
1113             }
1114         } else {
1115             if (d3) {
1116                 if (d1) {
1117                     /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
1118                     z5 = d1 + d3;
1119                     tmp3 = MULTIPLY(d1, FIX_0_211164243);
1120                     tmp2 = MULTIPLY(-d3, FIX_1_451774981);
1121                     z1 = MULTIPLY(d1, FIX_1_061594337);
1122                     z2 = MULTIPLY(-d3, FIX_2_172734803);
1123                     z4 = MULTIPLY(z5, FIX_0_785694958);
1124                     z5 = MULTIPLY(z5, FIX_1_175875602);
1125                     
1126                     tmp0 = z1 - z4;
1127                     tmp1 = z2 + z4;
1128                     tmp2 += z5;
1129                     tmp3 += z5;
1130                 } else {
1131                     /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
1132                     tmp0 = MULTIPLY(-d3, FIX_0_785694958);
1133                     tmp1 = MULTIPLY(-d3, FIX_1_387039845);
1134                     tmp2 = MULTIPLY(-d3, FIX_0_275899380);
1135                     tmp3 = MULTIPLY(d3, FIX_1_175875602);
1136                 }
1137             } else {
1138                 if (d1) {
1139                     /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
1140                     tmp0 = MULTIPLY(d1, FIX_0_275899380);
1141                     tmp1 = MULTIPLY(d1, FIX_0_785694958);
1142                     tmp2 = MULTIPLY(d1, FIX_1_175875602);
1143                     tmp3 = MULTIPLY(d1, FIX_1_387039845);
1144                 } else {
1145                     /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
1146                     tmp0 = tmp1 = tmp2 = tmp3 = 0;
1147                 }
1148             }
1149         }
1150     }
1151
1152     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1153
1154     dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp3,
1155                                            CONST_BITS+PASS1_BITS+3);
1156     dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp10 - tmp3,
1157                                            CONST_BITS+PASS1_BITS+3);
1158     dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp11 + tmp2,
1159                                            CONST_BITS+PASS1_BITS+3);
1160     dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(tmp11 - tmp2,
1161                                            CONST_BITS+PASS1_BITS+3);
1162     dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp12 + tmp1,
1163                                            CONST_BITS+PASS1_BITS+3);
1164     dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12 - tmp1,
1165                                            CONST_BITS+PASS1_BITS+3);
1166     dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp13 + tmp0,
1167                                            CONST_BITS+PASS1_BITS+3);
1168     dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp13 - tmp0,
1169                                            CONST_BITS+PASS1_BITS+3);
1170     
1171     dataptr++;                  /* advance pointer to next column */
1172   }
1173 }
1174
1175 #undef DCTSIZE
1176 #define DCTSIZE 4
1177 #define DCTSTRIDE 8
1178
1179 void j_rev_dct4(DCTBLOCK data)
1180 {
1181   int32_t tmp0, tmp1, tmp2, tmp3;
1182   int32_t tmp10, tmp11, tmp12, tmp13;
1183   int32_t z1;
1184   int32_t d0, d2, d4, d6;
1185   register DCTELEM *dataptr;
1186   int rowctr;
1187    
1188   /* Pass 1: process rows. */
1189   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
1190   /* furthermore, we scale the results by 2**PASS1_BITS. */
1191
1192   dataptr = data;
1193
1194   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
1195     /* Due to quantization, we will usually find that many of the input
1196      * coefficients are zero, especially the AC terms.  We can exploit this
1197      * by short-circuiting the IDCT calculation for any row in which all
1198      * the AC terms are zero.  In that case each output is equal to the
1199      * DC coefficient (with scale factor as needed).
1200      * With typical images and quantization tables, half or more of the
1201      * row DCT calculations can be simplified this way.
1202      */
1203
1204     register int *idataptr = (int*)dataptr;
1205
1206     d0 = dataptr[0];
1207     d2 = dataptr[1];
1208     d4 = dataptr[2];
1209     d6 = dataptr[3];
1210
1211     if ((d2 | d4 | d6) == 0) {
1212       /* AC terms all zero */
1213       if (d0) {
1214           /* Compute a 32 bit value to assign. */
1215           DCTELEM dcval = (DCTELEM) (d0 << PASS1_BITS);
1216           register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
1217           
1218           idataptr[0] = v;
1219           idataptr[1] = v;
1220       }
1221       
1222       dataptr += DCTSTRIDE;     /* advance pointer to next row */
1223       continue;
1224     }
1225
1226     /* Even part: reverse the even part of the forward DCT. */
1227     /* The rotator is sqrt(2)*c(-6). */
1228     if (d6) {
1229         if (d4) {
1230             if (d2) {
1231                 if (d0) {
1232                     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
1233                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1234                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1235                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1236
1237                     tmp0 = (d0 + d4) << CONST_BITS;
1238                     tmp1 = (d0 - d4) << CONST_BITS;
1239
1240                     tmp10 = tmp0 + tmp3;
1241                     tmp13 = tmp0 - tmp3;
1242                     tmp11 = tmp1 + tmp2;
1243                     tmp12 = tmp1 - tmp2;
1244                 } else {
1245                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
1246                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1247                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1248                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1249
1250                     tmp0 = d4 << CONST_BITS;
1251
1252                     tmp10 = tmp0 + tmp3;
1253                     tmp13 = tmp0 - tmp3;
1254                     tmp11 = tmp2 - tmp0;
1255                     tmp12 = -(tmp0 + tmp2);
1256                 }
1257             } else {
1258                 if (d0) {
1259                     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
1260                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1261                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1262
1263                     tmp0 = (d0 + d4) << CONST_BITS;
1264                     tmp1 = (d0 - d4) << CONST_BITS;
1265
1266                     tmp10 = tmp0 + tmp3;
1267                     tmp13 = tmp0 - tmp3;
1268                     tmp11 = tmp1 + tmp2;
1269                     tmp12 = tmp1 - tmp2;
1270                 } else {
1271                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
1272                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1273                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1274
1275                     tmp0 = d4 << CONST_BITS;
1276
1277                     tmp10 = tmp0 + tmp3;
1278                     tmp13 = tmp0 - tmp3;
1279                     tmp11 = tmp2 - tmp0;
1280                     tmp12 = -(tmp0 + tmp2);
1281                 }
1282             }
1283         } else {
1284             if (d2) {
1285                 if (d0) {
1286                     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
1287                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1288                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1289                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1290
1291                     tmp0 = d0 << CONST_BITS;
1292
1293                     tmp10 = tmp0 + tmp3;
1294                     tmp13 = tmp0 - tmp3;
1295                     tmp11 = tmp0 + tmp2;
1296                     tmp12 = tmp0 - tmp2;
1297                 } else {
1298                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
1299                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1300                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1301                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1302
1303                     tmp10 = tmp3;
1304                     tmp13 = -tmp3;
1305                     tmp11 = tmp2;
1306                     tmp12 = -tmp2;
1307                 }
1308             } else {
1309                 if (d0) {
1310                     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
1311                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1312                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1313
1314                     tmp0 = d0 << CONST_BITS;
1315
1316                     tmp10 = tmp0 + tmp3;
1317                     tmp13 = tmp0 - tmp3;
1318                     tmp11 = tmp0 + tmp2;
1319                     tmp12 = tmp0 - tmp2;
1320                 } else {
1321                     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
1322                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1323                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1324
1325                     tmp10 = tmp3;
1326                     tmp13 = -tmp3;
1327                     tmp11 = tmp2;
1328                     tmp12 = -tmp2;
1329                 }
1330             }
1331         }
1332     } else {
1333         if (d4) {
1334             if (d2) {
1335                 if (d0) {
1336                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
1337                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1338                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1339
1340                     tmp0 = (d0 + d4) << CONST_BITS;
1341                     tmp1 = (d0 - d4) << CONST_BITS;
1342
1343                     tmp10 = tmp0 + tmp3;
1344                     tmp13 = tmp0 - tmp3;
1345                     tmp11 = tmp1 + tmp2;
1346                     tmp12 = tmp1 - tmp2;
1347                 } else {
1348                     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
1349                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1350                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1351
1352                     tmp0 = d4 << CONST_BITS;
1353
1354                     tmp10 = tmp0 + tmp3;
1355                     tmp13 = tmp0 - tmp3;
1356                     tmp11 = tmp2 - tmp0;
1357                     tmp12 = -(tmp0 + tmp2);
1358                 }
1359             } else {
1360                 if (d0) {
1361                     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
1362                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
1363                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
1364                 } else {
1365                     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
1366                     tmp10 = tmp13 = d4 << CONST_BITS;
1367                     tmp11 = tmp12 = -tmp10;
1368                 }
1369             }
1370         } else {
1371             if (d2) {
1372                 if (d0) {
1373                     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
1374                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1375                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1376
1377                     tmp0 = d0 << CONST_BITS;
1378
1379                     tmp10 = tmp0 + tmp3;
1380                     tmp13 = tmp0 - tmp3;
1381                     tmp11 = tmp0 + tmp2;
1382                     tmp12 = tmp0 - tmp2;
1383                 } else {
1384                     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
1385                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1386                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1387
1388                     tmp10 = tmp3;
1389                     tmp13 = -tmp3;
1390                     tmp11 = tmp2;
1391                     tmp12 = -tmp2;
1392                 }
1393             } else {
1394                 if (d0) {
1395                     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
1396                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
1397                 } else {
1398                     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
1399                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
1400                 }
1401             }
1402         }
1403       }
1404
1405     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1406
1407     dataptr[0] = (DCTELEM) DESCALE(tmp10, CONST_BITS-PASS1_BITS);
1408     dataptr[1] = (DCTELEM) DESCALE(tmp11, CONST_BITS-PASS1_BITS);
1409     dataptr[2] = (DCTELEM) DESCALE(tmp12, CONST_BITS-PASS1_BITS);
1410     dataptr[3] = (DCTELEM) DESCALE(tmp13, CONST_BITS-PASS1_BITS);
1411
1412     dataptr += DCTSTRIDE;               /* advance pointer to next row */
1413   }
1414
1415   /* Pass 2: process columns. */
1416   /* Note that we must descale the results by a factor of 8 == 2**3, */
1417   /* and also undo the PASS1_BITS scaling. */
1418
1419   dataptr = data;
1420   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
1421     /* Columns of zeroes can be exploited in the same way as we did with rows.
1422      * However, the row calculation has created many nonzero AC terms, so the
1423      * simplification applies less often (typically 5% to 10% of the time).
1424      * On machines with very fast multiplication, it's possible that the
1425      * test takes more time than it's worth.  In that case this section
1426      * may be commented out.
1427      */
1428
1429     d0 = dataptr[DCTSTRIDE*0];
1430     d2 = dataptr[DCTSTRIDE*1];
1431     d4 = dataptr[DCTSTRIDE*2];
1432     d6 = dataptr[DCTSTRIDE*3];
1433
1434     /* Even part: reverse the even part of the forward DCT. */
1435     /* The rotator is sqrt(2)*c(-6). */
1436     if (d6) {
1437         if (d4) {
1438             if (d2) {
1439                 if (d0) {
1440                     /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
1441                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1442                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1443                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1444
1445                     tmp0 = (d0 + d4) << CONST_BITS;
1446                     tmp1 = (d0 - d4) << CONST_BITS;
1447
1448                     tmp10 = tmp0 + tmp3;
1449                     tmp13 = tmp0 - tmp3;
1450                     tmp11 = tmp1 + tmp2;
1451                     tmp12 = tmp1 - tmp2;
1452                 } else {
1453                     /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
1454                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1455                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1456                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1457
1458                     tmp0 = d4 << CONST_BITS;
1459
1460                     tmp10 = tmp0 + tmp3;
1461                     tmp13 = tmp0 - tmp3;
1462                     tmp11 = tmp2 - tmp0;
1463                     tmp12 = -(tmp0 + tmp2);
1464                 }
1465             } else {
1466                 if (d0) {
1467                     /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
1468                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1469                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1470
1471                     tmp0 = (d0 + d4) << CONST_BITS;
1472                     tmp1 = (d0 - d4) << CONST_BITS;
1473
1474                     tmp10 = tmp0 + tmp3;
1475                     tmp13 = tmp0 - tmp3;
1476                     tmp11 = tmp1 + tmp2;
1477                     tmp12 = tmp1 - tmp2;
1478                 } else {
1479                     /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
1480                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1481                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1482
1483                     tmp0 = d4 << CONST_BITS;
1484
1485                     tmp10 = tmp0 + tmp3;
1486                     tmp13 = tmp0 - tmp3;
1487                     tmp11 = tmp2 - tmp0;
1488                     tmp12 = -(tmp0 + tmp2);
1489                 }
1490             }
1491         } else {
1492             if (d2) {
1493                 if (d0) {
1494                     /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
1495                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1496                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1497                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1498
1499                     tmp0 = d0 << CONST_BITS;
1500
1501                     tmp10 = tmp0 + tmp3;
1502                     tmp13 = tmp0 - tmp3;
1503                     tmp11 = tmp0 + tmp2;
1504                     tmp12 = tmp0 - tmp2;
1505                 } else {
1506                     /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
1507                     z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1508                     tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1509                     tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1510
1511                     tmp10 = tmp3;
1512                     tmp13 = -tmp3;
1513                     tmp11 = tmp2;
1514                     tmp12 = -tmp2;
1515                 }
1516             } else {
1517                 if (d0) {
1518                     /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
1519                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1520                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1521
1522                     tmp0 = d0 << CONST_BITS;
1523
1524                     tmp10 = tmp0 + tmp3;
1525                     tmp13 = tmp0 - tmp3;
1526                     tmp11 = tmp0 + tmp2;
1527                     tmp12 = tmp0 - tmp2;
1528                 } else {
1529                     /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
1530                     tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1531                     tmp3 = MULTIPLY(d6, FIX_0_541196100);
1532
1533                     tmp10 = tmp3;
1534                     tmp13 = -tmp3;
1535                     tmp11 = tmp2;
1536                     tmp12 = -tmp2;
1537                 }
1538             }
1539         }
1540     } else {
1541         if (d4) {
1542             if (d2) {
1543                 if (d0) {
1544                     /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
1545                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1546                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1547
1548                     tmp0 = (d0 + d4) << CONST_BITS;
1549                     tmp1 = (d0 - d4) << CONST_BITS;
1550
1551                     tmp10 = tmp0 + tmp3;
1552                     tmp13 = tmp0 - tmp3;
1553                     tmp11 = tmp1 + tmp2;
1554                     tmp12 = tmp1 - tmp2;
1555                 } else {
1556                     /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
1557                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1558                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1559
1560                     tmp0 = d4 << CONST_BITS;
1561
1562                     tmp10 = tmp0 + tmp3;
1563                     tmp13 = tmp0 - tmp3;
1564                     tmp11 = tmp2 - tmp0;
1565                     tmp12 = -(tmp0 + tmp2);
1566                 }
1567             } else {
1568                 if (d0) {
1569                     /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
1570                     tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
1571                     tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
1572                 } else {
1573                     /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
1574                     tmp10 = tmp13 = d4 << CONST_BITS;
1575                     tmp11 = tmp12 = -tmp10;
1576                 }
1577             }
1578         } else {
1579             if (d2) {
1580                 if (d0) {
1581                     /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
1582                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1583                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1584
1585                     tmp0 = d0 << CONST_BITS;
1586
1587                     tmp10 = tmp0 + tmp3;
1588                     tmp13 = tmp0 - tmp3;
1589                     tmp11 = tmp0 + tmp2;
1590                     tmp12 = tmp0 - tmp2;
1591                 } else {
1592                     /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
1593                     tmp2 = MULTIPLY(d2, FIX_0_541196100);
1594                     tmp3 = MULTIPLY(d2, FIX_1_306562965);
1595
1596                     tmp10 = tmp3;
1597                     tmp13 = -tmp3;
1598                     tmp11 = tmp2;
1599                     tmp12 = -tmp2;
1600                 }
1601             } else {
1602                 if (d0) {
1603                     /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
1604                     tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
1605                 } else {
1606                     /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
1607                     tmp10 = tmp13 = tmp11 = tmp12 = 0;
1608                 }
1609             }
1610         }
1611     }
1612
1613     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1614
1615     dataptr[DCTSTRIDE*0] = (DCTELEM) DESCALE(tmp10,
1616                                            CONST_BITS+PASS1_BITS+3);
1617     dataptr[DCTSTRIDE*1] = (DCTELEM) DESCALE(tmp11,
1618                                            CONST_BITS+PASS1_BITS+3);
1619     dataptr[DCTSTRIDE*2] = (DCTELEM) DESCALE(tmp12,
1620                                            CONST_BITS+PASS1_BITS+3);
1621     dataptr[DCTSTRIDE*3] = (DCTELEM) DESCALE(tmp13,
1622                                            CONST_BITS+PASS1_BITS+3);
1623     
1624     dataptr++;                  /* advance pointer to next column */
1625   }
1626 }
1627
1628 void j_rev_dct2(DCTBLOCK data){
1629   int d00, d01, d10, d11;
1630
1631   data[0] += 4;
1632   d00 = data[0+0*DCTSTRIDE] + data[1+0*DCTSTRIDE];
1633   d01 = data[0+0*DCTSTRIDE] - data[1+0*DCTSTRIDE];
1634   d10 = data[0+1*DCTSTRIDE] + data[1+1*DCTSTRIDE];
1635   d11 = data[0+1*DCTSTRIDE] - data[1+1*DCTSTRIDE];
1636  
1637   data[0+0*DCTSTRIDE]= (d00 + d10)>>3;
1638   data[1+0*DCTSTRIDE]= (d01 + d11)>>3;
1639   data[0+1*DCTSTRIDE]= (d00 - d10)>>3;
1640   data[1+1*DCTSTRIDE]= (d01 - d11)>>3;
1641 }
1642
1643 void j_rev_dct1(DCTBLOCK data){
1644   data[0] = (data[0] + 4)>>3;
1645 }
1646
1647 #undef FIX
1648 #undef CONST_BITS