1 /*****************************************************************************
2 * idct.c : C IDCT module
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
5 * $Id: idct.c,v 1.24 2002/06/01 12:31:59 sam Exp $
7 * Author: Gaƫl Hendryckx <jimmy@via.ecp.fr>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
22 *****************************************************************************/
24 /*****************************************************************************
26 *****************************************************************************/
35 /*****************************************************************************
36 * Local and extern prototypes.
37 *****************************************************************************/
38 static void idct_getfunctions( function_list_t * p_function_list );
40 /*****************************************************************************
41 * Build configuration tree.
42 *****************************************************************************/
47 SET_DESCRIPTION( _("IDCT module") )
48 ADD_CAPABILITY( IDCT, 50 )
53 idct_getfunctions( &p_module->p_functions->idct );
56 MODULE_DEACTIVATE_START
57 MODULE_DEACTIVATE_STOP
59 /* Following functions are local */
61 /*****************************************************************************
62 * NormScan : Unused in this IDCT
63 *****************************************************************************/
64 static void NormScan( u8 ppi_scan[2][64] )
68 /*****************************************************************************
69 * IDCT : IDCT function for normal matrices
70 *****************************************************************************/
71 static inline void IDCT( dctelem_t * p_block )
73 s32 tmp0, tmp1, tmp2, tmp3;
74 s32 tmp10, tmp11, tmp12, tmp13;
75 s32 z1, z2, z3, z4, z5;
76 s32 d0, d1, d2, d3, d4, d5, d6, d7;
82 /* Pass 1: process rows. */
83 /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
84 /* furthermore, we scale the results by 2**PASS1_BITS. */
88 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
90 /* Due to quantization, we will usually find that many of the input
91 * coefficients are zero, especially the AC terms. We can exploit this
92 * by short-circuiting the IDCT calculation for any row in which all
93 * the AC terms are zero. In that case each output is equal to the
94 * DC coefficient (with scale factor as needed).
95 * With typical images and quantization tables, half or more of the
96 * row DCT calculations can be simplified this way.
99 register int * idataptr = (int*)dataptr;
102 if ( (d1 == 0) && ((idataptr[1] | idataptr[2] | idataptr[3]) == 0) )
104 /* AC terms all zero */
107 /* Compute a 32 bit value to assign. */
108 dctelem_t dcval = (dctelem_t) (d0 << PASS1_BITS);
109 register int v = (dcval & 0xffff) | (dcval << 16);
117 dataptr += DCTSIZE; /* advance pointer to next row */
127 /* Even part: reverse the even part of the forward DCT. */
128 /* The rotator is sqrt(2)*c(-6). */
137 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
138 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
139 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
140 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
142 tmp0 = (d0 + d4) << CONST_BITS;
143 tmp1 = (d0 - d4) << CONST_BITS;
152 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
153 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
154 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
155 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
157 tmp0 = d4 << CONST_BITS;
162 tmp12 = -(tmp0 + tmp2);
169 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
170 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
171 tmp3 = MULTIPLY(d6, FIX(0.541196100));
173 tmp0 = (d0 + d4) << CONST_BITS;
174 tmp1 = (d0 - d4) << CONST_BITS;
183 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
184 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
185 tmp3 = MULTIPLY(d6, FIX(0.541196100));
187 tmp0 = d4 << CONST_BITS;
192 tmp12 = -(tmp0 + tmp2);
202 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
203 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
204 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
205 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
207 tmp0 = d0 << CONST_BITS;
216 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
217 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
218 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
219 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
231 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
232 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
233 tmp3 = MULTIPLY(d6, FIX(0.541196100));
235 tmp0 = d0 << CONST_BITS;
244 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
245 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
246 tmp3 = MULTIPLY(d6, FIX(0.541196100));
264 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
265 tmp2 = MULTIPLY(d2, FIX(0.541196100));
266 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
268 tmp0 = (d0 + d4) << CONST_BITS;
269 tmp1 = (d0 - d4) << CONST_BITS;
278 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
279 tmp2 = MULTIPLY(d2, FIX(0.541196100));
280 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
282 tmp0 = d4 << CONST_BITS;
287 tmp12 = -(tmp0 + tmp2);
294 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
295 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
296 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
300 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
301 tmp10 = tmp13 = d4 << CONST_BITS;
302 tmp11 = tmp12 = -tmp10;
312 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
313 tmp2 = MULTIPLY(d2, FIX(0.541196100));
314 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
316 tmp0 = d0 << CONST_BITS;
325 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
326 tmp2 = MULTIPLY(d2, FIX(0.541196100));
327 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
339 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
340 tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
344 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
345 tmp10 = tmp13 = tmp11 = tmp12 = 0;
352 /* Odd part per figure 8; the matrix is unitary and hence its
353 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
364 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
369 z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
371 tmp0 = MULTIPLY(d7, FIX(0.298631336));
372 tmp1 = MULTIPLY(d5, FIX(2.053119869));
373 tmp2 = MULTIPLY(d3, FIX(3.072711026));
374 tmp3 = MULTIPLY(d1, FIX(1.501321110));
375 z1 = MULTIPLY(z1, - FIX(0.899976223));
376 z2 = MULTIPLY(z2, - FIX(2.562915447));
377 z3 = MULTIPLY(z3, - FIX(1.961570560));
378 z4 = MULTIPLY(z4, - FIX(0.390180644));
390 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
393 z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
395 tmp0 = MULTIPLY(d7, FIX(0.298631336));
396 tmp1 = MULTIPLY(d5, FIX(2.053119869));
397 tmp2 = MULTIPLY(d3, FIX(3.072711026));
398 z1 = MULTIPLY(d7, - FIX(0.899976223));
399 z2 = MULTIPLY(z2, - FIX(2.562915447));
400 z3 = MULTIPLY(z3, - FIX(1.961570560));
401 z4 = MULTIPLY(d5, - FIX(0.390180644));
416 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
419 z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
421 tmp0 = MULTIPLY(d7, FIX(0.298631336));
422 tmp1 = MULTIPLY(d5, FIX(2.053119869));
423 tmp3 = MULTIPLY(d1, FIX(1.501321110));
424 z1 = MULTIPLY(z1, - FIX(0.899976223));
425 z2 = MULTIPLY(d5, - FIX(2.562915447));
426 z3 = MULTIPLY(d7, - FIX(1.961570560));
427 z4 = MULTIPLY(z4, - FIX(0.390180644));
439 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
440 z5 = MULTIPLY(d7 + d5, FIX(1.175875602));
442 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
443 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
444 z1 = MULTIPLY(d7, - FIX(0.899976223));
445 z3 = MULTIPLY(d7, - FIX(1.961570560));
446 z2 = MULTIPLY(d5, - FIX(2.562915447));
447 z4 = MULTIPLY(d5, - FIX(0.390180644));
465 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
468 z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
470 tmp0 = MULTIPLY(d7, FIX(0.298631336));
471 tmp2 = MULTIPLY(d3, FIX(3.072711026));
472 tmp3 = MULTIPLY(d1, FIX(1.501321110));
473 z1 = MULTIPLY(z1, - FIX(0.899976223));
474 z2 = MULTIPLY(d3, - FIX(2.562915447));
475 z3 = MULTIPLY(z3, - FIX(1.961570560));
476 z4 = MULTIPLY(d1, - FIX(0.390180644));
488 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
490 z5 = MULTIPLY(z3, FIX(1.175875602));
492 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
493 tmp2 = MULTIPLY(d3, FIX(0.509795579));
494 z1 = MULTIPLY(d7, - FIX(0.899976223));
495 z2 = MULTIPLY(d3, - FIX(2.562915447));
496 z3 = MULTIPLY(z3, - FIX2(0.785694958));
508 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
510 z5 = MULTIPLY(z1, FIX(1.175875602));
512 tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
513 tmp3 = MULTIPLY(d1, FIX2(1.111140466));
514 z1 = MULTIPLY(z1, FIX2(0.275899379));
515 z3 = MULTIPLY(d7, - FIX(1.961570560));
516 z4 = MULTIPLY(d1, - FIX(0.390180644));
525 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
526 tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
527 tmp1 = MULTIPLY(d7, FIX(1.175875602));
528 tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
529 tmp3 = MULTIPLY(d7, FIX2(0.275899379));
542 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
545 z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
547 tmp1 = MULTIPLY(d5, FIX(2.053119869));
548 tmp2 = MULTIPLY(d3, FIX(3.072711026));
549 tmp3 = MULTIPLY(d1, FIX(1.501321110));
550 z1 = MULTIPLY(d1, - FIX(0.899976223));
551 z2 = MULTIPLY(z2, - FIX(2.562915447));
552 z3 = MULTIPLY(d3, - FIX(1.961570560));
553 z4 = MULTIPLY(z4, - FIX(0.390180644));
565 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
567 z5 = MULTIPLY(z2, FIX(1.175875602));
569 tmp1 = MULTIPLY(d5, FIX2(1.662939225));
570 tmp2 = MULTIPLY(d3, FIX2(1.111140466));
571 z2 = MULTIPLY(z2, - FIX2(1.387039845));
572 z3 = MULTIPLY(d3, - FIX(1.961570560));
573 z4 = MULTIPLY(d5, - FIX(0.390180644));
585 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
587 z5 = MULTIPLY(z4, FIX(1.175875602));
589 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
590 tmp3 = MULTIPLY(d1, FIX2(0.601344887));
591 z1 = MULTIPLY(d1, - FIX(0.899976223));
592 z2 = MULTIPLY(d5, - FIX(2.562915447));
593 z4 = MULTIPLY(z4, FIX2(0.785694958));
602 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
603 tmp0 = MULTIPLY(d5, FIX(1.175875602));
604 tmp1 = MULTIPLY(d5, FIX2(0.275899380));
605 tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
606 tmp3 = MULTIPLY(d5, FIX2(0.785694958));
616 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
619 tmp2 = MULTIPLY(d3, - FIX(1.451774981));
620 tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
621 z1 = MULTIPLY(d1, FIX(1.061594337));
622 z2 = MULTIPLY(d3, - FIX(2.172734803));
623 z4 = MULTIPLY(z5, FIX(0.785694958));
624 z5 = MULTIPLY(z5, FIX(1.175875602));
633 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
634 tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
635 tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
636 tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
637 tmp3 = MULTIPLY(d3, FIX(1.175875602));
644 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
645 tmp0 = MULTIPLY(d1, FIX2(0.275899379));
646 tmp1 = MULTIPLY(d1, FIX2(0.785694958));
647 tmp2 = MULTIPLY(d1, FIX(1.175875602));
648 tmp3 = MULTIPLY(d1, FIX2(1.387039845));
652 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
653 tmp0 = tmp1 = tmp2 = tmp3 = 0;
659 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
661 dataptr[0] = (dctelem_t) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
662 dataptr[7] = (dctelem_t) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
663 dataptr[1] = (dctelem_t) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
664 dataptr[6] = (dctelem_t) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
665 dataptr[2] = (dctelem_t) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
666 dataptr[5] = (dctelem_t) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
667 dataptr[3] = (dctelem_t) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
668 dataptr[4] = (dctelem_t) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
670 dataptr += DCTSIZE; /* advance pointer to next row */
673 /* Pass 2: process columns. */
674 /* Note that we must descale the results by a factor of 8 == 2**3, */
675 /* and also undo the PASS1_BITS scaling. */
678 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
680 /* Columns of zeroes can be exploited in the same way as we did with rows.
681 * However, the row calculation has created many nonzero AC terms, so the
682 * simplification applies less often (typically 5% to 10% of the time).
683 * On machines with very fast multiplication, it's possible that the
684 * test takes more time than it's worth. In that case this section
685 * may be commented out.
688 d0 = dataptr[DCTSIZE*0];
689 d1 = dataptr[DCTSIZE*1];
690 d2 = dataptr[DCTSIZE*2];
691 d3 = dataptr[DCTSIZE*3];
692 d4 = dataptr[DCTSIZE*4];
693 d5 = dataptr[DCTSIZE*5];
694 d6 = dataptr[DCTSIZE*6];
695 d7 = dataptr[DCTSIZE*7];
697 /* Even part: reverse the even part of the forward DCT. */
698 /* The rotator is sqrt(2)*c(-6). */
707 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
708 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
709 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
710 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
712 tmp0 = (d0 + d4) << CONST_BITS;
713 tmp1 = (d0 - d4) << CONST_BITS;
722 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
723 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
724 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
725 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
727 tmp0 = d4 << CONST_BITS;
732 tmp12 = -(tmp0 + tmp2);
739 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
740 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
741 tmp3 = MULTIPLY(d6, FIX(0.541196100));
743 tmp0 = (d0 + d4) << CONST_BITS;
744 tmp1 = (d0 - d4) << CONST_BITS;
753 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
754 tmp2 = MULTIPLY(d6, -FIX2(1.306562965));
755 tmp3 = MULTIPLY(d6, FIX(0.541196100));
757 tmp0 = d4 << CONST_BITS;
762 tmp12 = -(tmp0 + tmp2);
772 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
773 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
774 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
775 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
777 tmp0 = d0 << CONST_BITS;
786 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
787 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
788 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
789 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
801 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
802 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
803 tmp3 = MULTIPLY(d6, FIX(0.541196100));
805 tmp0 = d0 << CONST_BITS;
814 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
815 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
816 tmp3 = MULTIPLY(d6, FIX(0.541196100));
833 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
834 tmp2 = MULTIPLY(d2, FIX(0.541196100));
835 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
837 tmp0 = (d0 + d4) << CONST_BITS;
838 tmp1 = (d0 - d4) << CONST_BITS;
847 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
848 tmp2 = MULTIPLY(d2, FIX(0.541196100));
849 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
851 tmp0 = d4 << CONST_BITS;
856 tmp12 = -(tmp0 + tmp2);
863 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
864 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
865 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
869 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
870 tmp10 = tmp13 = d4 << CONST_BITS;
871 tmp11 = tmp12 = -tmp10;
881 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
882 tmp2 = MULTIPLY(d2, FIX(0.541196100));
883 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
885 tmp0 = d0 << CONST_BITS;
894 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
895 tmp2 = MULTIPLY(d2, FIX(0.541196100));
896 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
908 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
909 tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
913 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
914 tmp10 = tmp13 = tmp11 = tmp12 = 0;
920 /* Odd part per figure 8; the matrix is unitary and hence its
921 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
931 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
936 z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
938 tmp0 = MULTIPLY(d7, FIX(0.298631336));
939 tmp1 = MULTIPLY(d5, FIX(2.053119869));
940 tmp2 = MULTIPLY(d3, FIX(3.072711026));
941 tmp3 = MULTIPLY(d1, FIX(1.501321110));
942 z1 = MULTIPLY(z1, - FIX(0.899976223));
943 z2 = MULTIPLY(z2, - FIX(2.562915447));
944 z3 = MULTIPLY(z3, - FIX(1.961570560));
945 z4 = MULTIPLY(z4, - FIX(0.390180644));
957 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
960 z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
962 tmp0 = MULTIPLY(d7, FIX(0.298631336));
963 tmp1 = MULTIPLY(d5, FIX(2.053119869));
964 tmp2 = MULTIPLY(d3, FIX(3.072711026));
965 z1 = MULTIPLY(d7, - FIX(0.899976223));
966 z2 = MULTIPLY(z2, - FIX(2.562915447));
967 z3 = MULTIPLY(z3, - FIX(1.961570560));
968 z4 = MULTIPLY(d5, - FIX(0.390180644));
983 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
986 z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
988 tmp0 = MULTIPLY(d7, FIX(0.298631336));
989 tmp1 = MULTIPLY(d5, FIX(2.053119869));
990 tmp3 = MULTIPLY(d1, FIX(1.501321110));
991 z1 = MULTIPLY(z1, - FIX(0.899976223));
992 z2 = MULTIPLY(d5, - FIX(2.562915447));
993 z3 = MULTIPLY(d7, - FIX(1.961570560));
994 z4 = MULTIPLY(z4, - FIX(0.390180644));
1006 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
1007 z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
1009 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1010 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1011 z1 = MULTIPLY(d7, - FIX(0.899976223));
1012 z3 = MULTIPLY(d7, - FIX(1.961570560));
1013 z2 = MULTIPLY(d5, - FIX(2.562915447));
1014 z4 = MULTIPLY(d5, - FIX(0.390180644));
1032 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
1035 z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
1037 tmp0 = MULTIPLY(d7, FIX(0.298631336));
1038 tmp2 = MULTIPLY(d3, FIX(3.072711026));
1039 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1040 z1 = MULTIPLY(z1, - FIX(0.899976223));
1041 z2 = MULTIPLY(d3, - FIX(2.562915447));
1042 z3 = MULTIPLY(z3, - FIX(1.961570560));
1043 z4 = MULTIPLY(d1, - FIX(0.390180644));
1055 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
1057 z5 = MULTIPLY(z3, FIX(1.175875602));
1059 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1060 z1 = MULTIPLY(d7, - FIX(0.899976223));
1061 tmp2 = MULTIPLY(d3, FIX(0.509795579));
1062 z2 = MULTIPLY(d3, - FIX(2.562915447));
1063 z3 = MULTIPLY(z3, - FIX2(0.785694958));
1075 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
1077 z5 = MULTIPLY(z1, FIX(1.175875602));
1079 tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
1080 tmp3 = MULTIPLY(d1, FIX2(1.111140466));
1081 z1 = MULTIPLY(z1, FIX2(0.275899379));
1082 z3 = MULTIPLY(d7, - FIX(1.961570560));
1083 z4 = MULTIPLY(d1, - FIX(0.390180644));
1092 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
1093 tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
1094 tmp1 = MULTIPLY(d7, FIX(1.175875602));
1095 tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
1096 tmp3 = MULTIPLY(d7, FIX2(0.275899379));
1109 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
1112 z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
1114 tmp1 = MULTIPLY(d5, FIX(2.053119869));
1115 tmp2 = MULTIPLY(d3, FIX(3.072711026));
1116 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1117 z1 = MULTIPLY(d1, - FIX(0.899976223));
1118 z2 = MULTIPLY(z2, - FIX(2.562915447));
1119 z3 = MULTIPLY(d3, - FIX(1.961570560));
1120 z4 = MULTIPLY(z4, - FIX(0.390180644));
1132 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
1134 z5 = MULTIPLY(z2, FIX(1.175875602));
1136 tmp1 = MULTIPLY(d5, FIX2(1.662939225));
1137 tmp2 = MULTIPLY(d3, FIX2(1.111140466));
1138 z2 = MULTIPLY(z2, - FIX2(1.387039845));
1139 z3 = MULTIPLY(d3, - FIX(1.961570560));
1140 z4 = MULTIPLY(d5, - FIX(0.390180644));
1152 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
1154 z5 = MULTIPLY(z4, FIX(1.175875602));
1156 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1157 tmp3 = MULTIPLY(d1, FIX2(0.601344887));
1158 z1 = MULTIPLY(d1, - FIX(0.899976223));
1159 z2 = MULTIPLY(d5, - FIX(2.562915447));
1160 z4 = MULTIPLY(z4, FIX2(0.785694958));
1169 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
1170 tmp0 = MULTIPLY(d5, FIX(1.175875602));
1171 tmp1 = MULTIPLY(d5, FIX2(0.275899380));
1172 tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
1173 tmp3 = MULTIPLY(d5, FIX2(0.785694958));
1183 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
1186 tmp2 = MULTIPLY(d3, - FIX(1.451774981));
1187 tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
1188 z1 = MULTIPLY(d1, FIX(1.061594337));
1189 z2 = MULTIPLY(d3, - FIX(2.172734803));
1190 z4 = MULTIPLY(z5, FIX(0.785694958));
1191 z5 = MULTIPLY(z5, FIX(1.175875602));
1200 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
1201 tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
1202 tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
1203 tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
1204 tmp3 = MULTIPLY(d3, FIX(1.175875602));
1211 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
1212 tmp0 = MULTIPLY(d1, FIX2(0.275899379));
1213 tmp1 = MULTIPLY(d1, FIX2(0.785694958));
1214 tmp2 = MULTIPLY(d1, FIX(1.175875602));
1215 tmp3 = MULTIPLY(d1, FIX2(1.387039845));
1219 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
1220 tmp0 = tmp1 = tmp2 = tmp3 = 0;
1226 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1228 dataptr[DCTSIZE*0] = (dctelem_t) DESCALE(tmp10 + tmp3,
1229 CONST_BITS+PASS1_BITS+3);
1230 dataptr[DCTSIZE*7] = (dctelem_t) DESCALE(tmp10 - tmp3,
1231 CONST_BITS+PASS1_BITS+3);
1232 dataptr[DCTSIZE*1] = (dctelem_t) DESCALE(tmp11 + tmp2,
1233 CONST_BITS+PASS1_BITS+3);
1234 dataptr[DCTSIZE*6] = (dctelem_t) DESCALE(tmp11 - tmp2,
1235 CONST_BITS+PASS1_BITS+3);
1236 dataptr[DCTSIZE*2] = (dctelem_t) DESCALE(tmp12 + tmp1,
1237 CONST_BITS+PASS1_BITS+3);
1238 dataptr[DCTSIZE*5] = (dctelem_t) DESCALE(tmp12 - tmp1,
1239 CONST_BITS+PASS1_BITS+3);
1240 dataptr[DCTSIZE*3] = (dctelem_t) DESCALE(tmp13 + tmp0,
1241 CONST_BITS+PASS1_BITS+3);
1242 dataptr[DCTSIZE*4] = (dctelem_t) DESCALE(tmp13 - tmp0,
1243 CONST_BITS+PASS1_BITS+3);
1245 dataptr++; /* advance pointer to next column */
1249 static inline void RestoreCPUState( )
1254 #include "idct_sparse.h"
1255 #include "idct_decl.h"