1 /*****************************************************************************
2 * idct.c : C IDCT module
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
5 * $Id: idct.c,v 1.19 2001/12/30 07:09:55 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 *****************************************************************************/
30 #include <videolan/vlc.h>
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 )
50 ADD_SHORTCUT( "idct" )
54 idct_getfunctions( &p_module->p_functions->idct );
57 MODULE_DEACTIVATE_START
58 MODULE_DEACTIVATE_STOP
60 /* Following functions are local */
62 /*****************************************************************************
63 * idct_Probe: returns a preference score
64 *****************************************************************************/
65 static int idct_Probe( probedata_t *p_data )
70 /*****************************************************************************
71 * NormScan : Unused in this IDCT
72 *****************************************************************************/
73 static void NormScan( u8 ppi_scan[2][64] )
77 /*****************************************************************************
78 * IDCT : IDCT function for normal matrices
79 *****************************************************************************/
80 static __inline__ void IDCT( dctelem_t * p_block )
82 s32 tmp0, tmp1, tmp2, tmp3;
83 s32 tmp10, tmp11, tmp12, tmp13;
84 s32 z1, z2, z3, z4, z5;
85 s32 d0, d1, d2, d3, d4, d5, d6, d7;
91 /* Pass 1: process rows. */
92 /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
93 /* furthermore, we scale the results by 2**PASS1_BITS. */
97 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
99 /* Due to quantization, we will usually find that many of the input
100 * coefficients are zero, especially the AC terms. We can exploit this
101 * by short-circuiting the IDCT calculation for any row in which all
102 * the AC terms are zero. In that case each output is equal to the
103 * DC coefficient (with scale factor as needed).
104 * With typical images and quantization tables, half or more of the
105 * row DCT calculations can be simplified this way.
108 register int * idataptr = (int*)dataptr;
111 if ( (d1 == 0) && ((idataptr[1] | idataptr[2] | idataptr[3]) == 0) )
113 /* AC terms all zero */
116 /* Compute a 32 bit value to assign. */
117 dctelem_t dcval = (dctelem_t) (d0 << PASS1_BITS);
118 register int v = (dcval & 0xffff) | (dcval << 16);
126 dataptr += DCTSIZE; /* advance pointer to next row */
136 /* Even part: reverse the even part of the forward DCT. */
137 /* The rotator is sqrt(2)*c(-6). */
146 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
147 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
148 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
149 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
151 tmp0 = (d0 + d4) << CONST_BITS;
152 tmp1 = (d0 - d4) << CONST_BITS;
161 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
162 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
163 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
164 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
166 tmp0 = d4 << CONST_BITS;
171 tmp12 = -(tmp0 + tmp2);
178 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
179 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
180 tmp3 = MULTIPLY(d6, FIX(0.541196100));
182 tmp0 = (d0 + d4) << CONST_BITS;
183 tmp1 = (d0 - d4) << CONST_BITS;
192 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
193 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
194 tmp3 = MULTIPLY(d6, FIX(0.541196100));
196 tmp0 = d4 << CONST_BITS;
201 tmp12 = -(tmp0 + tmp2);
211 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
212 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
213 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
214 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
216 tmp0 = d0 << CONST_BITS;
225 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
226 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
227 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
228 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
240 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
241 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
242 tmp3 = MULTIPLY(d6, FIX(0.541196100));
244 tmp0 = d0 << CONST_BITS;
253 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
254 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
255 tmp3 = MULTIPLY(d6, FIX(0.541196100));
273 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
274 tmp2 = MULTIPLY(d2, FIX(0.541196100));
275 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
277 tmp0 = (d0 + d4) << CONST_BITS;
278 tmp1 = (d0 - d4) << CONST_BITS;
287 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
288 tmp2 = MULTIPLY(d2, FIX(0.541196100));
289 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
291 tmp0 = d4 << CONST_BITS;
296 tmp12 = -(tmp0 + tmp2);
303 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
304 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
305 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
309 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
310 tmp10 = tmp13 = d4 << CONST_BITS;
311 tmp11 = tmp12 = -tmp10;
321 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
322 tmp2 = MULTIPLY(d2, FIX(0.541196100));
323 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
325 tmp0 = d0 << CONST_BITS;
334 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
335 tmp2 = MULTIPLY(d2, FIX(0.541196100));
336 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
348 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
349 tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
353 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
354 tmp10 = tmp13 = tmp11 = tmp12 = 0;
361 /* Odd part per figure 8; the matrix is unitary and hence its
362 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
373 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
378 z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
380 tmp0 = MULTIPLY(d7, FIX(0.298631336));
381 tmp1 = MULTIPLY(d5, FIX(2.053119869));
382 tmp2 = MULTIPLY(d3, FIX(3.072711026));
383 tmp3 = MULTIPLY(d1, FIX(1.501321110));
384 z1 = MULTIPLY(z1, - FIX(0.899976223));
385 z2 = MULTIPLY(z2, - FIX(2.562915447));
386 z3 = MULTIPLY(z3, - FIX(1.961570560));
387 z4 = MULTIPLY(z4, - FIX(0.390180644));
399 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
402 z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
404 tmp0 = MULTIPLY(d7, FIX(0.298631336));
405 tmp1 = MULTIPLY(d5, FIX(2.053119869));
406 tmp2 = MULTIPLY(d3, FIX(3.072711026));
407 z1 = MULTIPLY(d7, - FIX(0.899976223));
408 z2 = MULTIPLY(z2, - FIX(2.562915447));
409 z3 = MULTIPLY(z3, - FIX(1.961570560));
410 z4 = MULTIPLY(d5, - FIX(0.390180644));
425 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
428 z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
430 tmp0 = MULTIPLY(d7, FIX(0.298631336));
431 tmp1 = MULTIPLY(d5, FIX(2.053119869));
432 tmp3 = MULTIPLY(d1, FIX(1.501321110));
433 z1 = MULTIPLY(z1, - FIX(0.899976223));
434 z2 = MULTIPLY(d5, - FIX(2.562915447));
435 z3 = MULTIPLY(d7, - FIX(1.961570560));
436 z4 = MULTIPLY(z4, - FIX(0.390180644));
448 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
449 z5 = MULTIPLY(d7 + d5, FIX(1.175875602));
451 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
452 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
453 z1 = MULTIPLY(d7, - FIX(0.899976223));
454 z3 = MULTIPLY(d7, - FIX(1.961570560));
455 z2 = MULTIPLY(d5, - FIX(2.562915447));
456 z4 = MULTIPLY(d5, - FIX(0.390180644));
474 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
477 z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
479 tmp0 = MULTIPLY(d7, FIX(0.298631336));
480 tmp2 = MULTIPLY(d3, FIX(3.072711026));
481 tmp3 = MULTIPLY(d1, FIX(1.501321110));
482 z1 = MULTIPLY(z1, - FIX(0.899976223));
483 z2 = MULTIPLY(d3, - FIX(2.562915447));
484 z3 = MULTIPLY(z3, - FIX(1.961570560));
485 z4 = MULTIPLY(d1, - FIX(0.390180644));
497 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
499 z5 = MULTIPLY(z3, FIX(1.175875602));
501 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
502 tmp2 = MULTIPLY(d3, FIX(0.509795579));
503 z1 = MULTIPLY(d7, - FIX(0.899976223));
504 z2 = MULTIPLY(d3, - FIX(2.562915447));
505 z3 = MULTIPLY(z3, - FIX2(0.785694958));
517 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
519 z5 = MULTIPLY(z1, FIX(1.175875602));
521 tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
522 tmp3 = MULTIPLY(d1, FIX2(1.111140466));
523 z1 = MULTIPLY(z1, FIX2(0.275899379));
524 z3 = MULTIPLY(d7, - FIX(1.961570560));
525 z4 = MULTIPLY(d1, - FIX(0.390180644));
534 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
535 tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
536 tmp1 = MULTIPLY(d7, FIX(1.175875602));
537 tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
538 tmp3 = MULTIPLY(d7, FIX2(0.275899379));
551 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
554 z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
556 tmp1 = MULTIPLY(d5, FIX(2.053119869));
557 tmp2 = MULTIPLY(d3, FIX(3.072711026));
558 tmp3 = MULTIPLY(d1, FIX(1.501321110));
559 z1 = MULTIPLY(d1, - FIX(0.899976223));
560 z2 = MULTIPLY(z2, - FIX(2.562915447));
561 z3 = MULTIPLY(d3, - FIX(1.961570560));
562 z4 = MULTIPLY(z4, - FIX(0.390180644));
574 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
576 z5 = MULTIPLY(z2, FIX(1.175875602));
578 tmp1 = MULTIPLY(d5, FIX2(1.662939225));
579 tmp2 = MULTIPLY(d3, FIX2(1.111140466));
580 z2 = MULTIPLY(z2, - FIX2(1.387039845));
581 z3 = MULTIPLY(d3, - FIX(1.961570560));
582 z4 = MULTIPLY(d5, - FIX(0.390180644));
594 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
596 z5 = MULTIPLY(z4, FIX(1.175875602));
598 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
599 tmp3 = MULTIPLY(d1, FIX2(0.601344887));
600 z1 = MULTIPLY(d1, - FIX(0.899976223));
601 z2 = MULTIPLY(d5, - FIX(2.562915447));
602 z4 = MULTIPLY(z4, FIX2(0.785694958));
611 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
612 tmp0 = MULTIPLY(d5, FIX(1.175875602));
613 tmp1 = MULTIPLY(d5, FIX2(0.275899380));
614 tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
615 tmp3 = MULTIPLY(d5, FIX2(0.785694958));
625 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
628 tmp2 = MULTIPLY(d3, - FIX(1.451774981));
629 tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
630 z1 = MULTIPLY(d1, FIX(1.061594337));
631 z2 = MULTIPLY(d3, - FIX(2.172734803));
632 z4 = MULTIPLY(z5, FIX(0.785694958));
633 z5 = MULTIPLY(z5, FIX(1.175875602));
642 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
643 tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
644 tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
645 tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
646 tmp3 = MULTIPLY(d3, FIX(1.175875602));
653 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
654 tmp0 = MULTIPLY(d1, FIX2(0.275899379));
655 tmp1 = MULTIPLY(d1, FIX2(0.785694958));
656 tmp2 = MULTIPLY(d1, FIX(1.175875602));
657 tmp3 = MULTIPLY(d1, FIX2(1.387039845));
661 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
662 tmp0 = tmp1 = tmp2 = tmp3 = 0;
668 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
670 dataptr[0] = (dctelem_t) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
671 dataptr[7] = (dctelem_t) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
672 dataptr[1] = (dctelem_t) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
673 dataptr[6] = (dctelem_t) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
674 dataptr[2] = (dctelem_t) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
675 dataptr[5] = (dctelem_t) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
676 dataptr[3] = (dctelem_t) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
677 dataptr[4] = (dctelem_t) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
679 dataptr += DCTSIZE; /* advance pointer to next row */
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. */
687 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
689 /* Columns of zeroes can be exploited in the same way as we did with rows.
690 * However, the row calculation has created many nonzero AC terms, so the
691 * simplification applies less often (typically 5% to 10% of the time).
692 * On machines with very fast multiplication, it's possible that the
693 * test takes more time than it's worth. In that case this section
694 * may be commented out.
697 d0 = dataptr[DCTSIZE*0];
698 d1 = dataptr[DCTSIZE*1];
699 d2 = dataptr[DCTSIZE*2];
700 d3 = dataptr[DCTSIZE*3];
701 d4 = dataptr[DCTSIZE*4];
702 d5 = dataptr[DCTSIZE*5];
703 d6 = dataptr[DCTSIZE*6];
704 d7 = dataptr[DCTSIZE*7];
706 /* Even part: reverse the even part of the forward DCT. */
707 /* The rotator is sqrt(2)*c(-6). */
716 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
717 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
718 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
719 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
721 tmp0 = (d0 + d4) << CONST_BITS;
722 tmp1 = (d0 - d4) << CONST_BITS;
731 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
732 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
733 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
734 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
736 tmp0 = d4 << CONST_BITS;
741 tmp12 = -(tmp0 + tmp2);
748 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
749 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
750 tmp3 = MULTIPLY(d6, FIX(0.541196100));
752 tmp0 = (d0 + d4) << CONST_BITS;
753 tmp1 = (d0 - d4) << CONST_BITS;
762 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
763 tmp2 = MULTIPLY(d6, -FIX2(1.306562965));
764 tmp3 = MULTIPLY(d6, FIX(0.541196100));
766 tmp0 = d4 << CONST_BITS;
771 tmp12 = -(tmp0 + tmp2);
781 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
782 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
783 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
784 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
786 tmp0 = d0 << CONST_BITS;
795 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
796 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
797 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
798 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
810 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
811 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
812 tmp3 = MULTIPLY(d6, FIX(0.541196100));
814 tmp0 = d0 << CONST_BITS;
823 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
824 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
825 tmp3 = MULTIPLY(d6, FIX(0.541196100));
842 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
843 tmp2 = MULTIPLY(d2, FIX(0.541196100));
844 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
846 tmp0 = (d0 + d4) << CONST_BITS;
847 tmp1 = (d0 - d4) << CONST_BITS;
856 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
857 tmp2 = MULTIPLY(d2, FIX(0.541196100));
858 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
860 tmp0 = d4 << CONST_BITS;
865 tmp12 = -(tmp0 + tmp2);
872 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
873 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
874 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
878 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
879 tmp10 = tmp13 = d4 << CONST_BITS;
880 tmp11 = tmp12 = -tmp10;
890 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
891 tmp2 = MULTIPLY(d2, FIX(0.541196100));
892 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
894 tmp0 = d0 << CONST_BITS;
903 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
904 tmp2 = MULTIPLY(d2, FIX(0.541196100));
905 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
917 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
918 tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
922 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
923 tmp10 = tmp13 = tmp11 = tmp12 = 0;
929 /* Odd part per figure 8; the matrix is unitary and hence its
930 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
940 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
945 z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
947 tmp0 = MULTIPLY(d7, FIX(0.298631336));
948 tmp1 = MULTIPLY(d5, FIX(2.053119869));
949 tmp2 = MULTIPLY(d3, FIX(3.072711026));
950 tmp3 = MULTIPLY(d1, FIX(1.501321110));
951 z1 = MULTIPLY(z1, - FIX(0.899976223));
952 z2 = MULTIPLY(z2, - FIX(2.562915447));
953 z3 = MULTIPLY(z3, - FIX(1.961570560));
954 z4 = MULTIPLY(z4, - FIX(0.390180644));
966 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
969 z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
971 tmp0 = MULTIPLY(d7, FIX(0.298631336));
972 tmp1 = MULTIPLY(d5, FIX(2.053119869));
973 tmp2 = MULTIPLY(d3, FIX(3.072711026));
974 z1 = MULTIPLY(d7, - FIX(0.899976223));
975 z2 = MULTIPLY(z2, - FIX(2.562915447));
976 z3 = MULTIPLY(z3, - FIX(1.961570560));
977 z4 = MULTIPLY(d5, - FIX(0.390180644));
992 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
995 z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
997 tmp0 = MULTIPLY(d7, FIX(0.298631336));
998 tmp1 = MULTIPLY(d5, FIX(2.053119869));
999 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1000 z1 = MULTIPLY(z1, - FIX(0.899976223));
1001 z2 = MULTIPLY(d5, - FIX(2.562915447));
1002 z3 = MULTIPLY(d7, - FIX(1.961570560));
1003 z4 = MULTIPLY(z4, - FIX(0.390180644));
1015 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
1016 z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
1018 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1019 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1020 z1 = MULTIPLY(d7, - FIX(0.899976223));
1021 z3 = MULTIPLY(d7, - FIX(1.961570560));
1022 z2 = MULTIPLY(d5, - FIX(2.562915447));
1023 z4 = MULTIPLY(d5, - FIX(0.390180644));
1041 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
1044 z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
1046 tmp0 = MULTIPLY(d7, FIX(0.298631336));
1047 tmp2 = MULTIPLY(d3, FIX(3.072711026));
1048 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1049 z1 = MULTIPLY(z1, - FIX(0.899976223));
1050 z2 = MULTIPLY(d3, - FIX(2.562915447));
1051 z3 = MULTIPLY(z3, - FIX(1.961570560));
1052 z4 = MULTIPLY(d1, - FIX(0.390180644));
1064 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
1066 z5 = MULTIPLY(z3, FIX(1.175875602));
1068 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1069 z1 = MULTIPLY(d7, - FIX(0.899976223));
1070 tmp2 = MULTIPLY(d3, FIX(0.509795579));
1071 z2 = MULTIPLY(d3, - FIX(2.562915447));
1072 z3 = MULTIPLY(z3, - FIX2(0.785694958));
1084 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
1086 z5 = MULTIPLY(z1, FIX(1.175875602));
1088 tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
1089 tmp3 = MULTIPLY(d1, FIX2(1.111140466));
1090 z1 = MULTIPLY(z1, FIX2(0.275899379));
1091 z3 = MULTIPLY(d7, - FIX(1.961570560));
1092 z4 = MULTIPLY(d1, - FIX(0.390180644));
1101 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
1102 tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
1103 tmp1 = MULTIPLY(d7, FIX(1.175875602));
1104 tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
1105 tmp3 = MULTIPLY(d7, FIX2(0.275899379));
1118 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
1121 z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
1123 tmp1 = MULTIPLY(d5, FIX(2.053119869));
1124 tmp2 = MULTIPLY(d3, FIX(3.072711026));
1125 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1126 z1 = MULTIPLY(d1, - FIX(0.899976223));
1127 z2 = MULTIPLY(z2, - FIX(2.562915447));
1128 z3 = MULTIPLY(d3, - FIX(1.961570560));
1129 z4 = MULTIPLY(z4, - FIX(0.390180644));
1141 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
1143 z5 = MULTIPLY(z2, FIX(1.175875602));
1145 tmp1 = MULTIPLY(d5, FIX2(1.662939225));
1146 tmp2 = MULTIPLY(d3, FIX2(1.111140466));
1147 z2 = MULTIPLY(z2, - FIX2(1.387039845));
1148 z3 = MULTIPLY(d3, - FIX(1.961570560));
1149 z4 = MULTIPLY(d5, - FIX(0.390180644));
1161 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
1163 z5 = MULTIPLY(z4, FIX(1.175875602));
1165 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1166 tmp3 = MULTIPLY(d1, FIX2(0.601344887));
1167 z1 = MULTIPLY(d1, - FIX(0.899976223));
1168 z2 = MULTIPLY(d5, - FIX(2.562915447));
1169 z4 = MULTIPLY(z4, FIX2(0.785694958));
1178 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
1179 tmp0 = MULTIPLY(d5, FIX(1.175875602));
1180 tmp1 = MULTIPLY(d5, FIX2(0.275899380));
1181 tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
1182 tmp3 = MULTIPLY(d5, FIX2(0.785694958));
1192 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
1195 tmp2 = MULTIPLY(d3, - FIX(1.451774981));
1196 tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
1197 z1 = MULTIPLY(d1, FIX(1.061594337));
1198 z2 = MULTIPLY(d3, - FIX(2.172734803));
1199 z4 = MULTIPLY(z5, FIX(0.785694958));
1200 z5 = MULTIPLY(z5, FIX(1.175875602));
1209 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
1210 tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
1211 tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
1212 tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
1213 tmp3 = MULTIPLY(d3, FIX(1.175875602));
1220 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
1221 tmp0 = MULTIPLY(d1, FIX2(0.275899379));
1222 tmp1 = MULTIPLY(d1, FIX2(0.785694958));
1223 tmp2 = MULTIPLY(d1, FIX(1.175875602));
1224 tmp3 = MULTIPLY(d1, FIX2(1.387039845));
1228 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
1229 tmp0 = tmp1 = tmp2 = tmp3 = 0;
1235 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1237 dataptr[DCTSIZE*0] = (dctelem_t) DESCALE(tmp10 + tmp3,
1238 CONST_BITS+PASS1_BITS+3);
1239 dataptr[DCTSIZE*7] = (dctelem_t) DESCALE(tmp10 - tmp3,
1240 CONST_BITS+PASS1_BITS+3);
1241 dataptr[DCTSIZE*1] = (dctelem_t) DESCALE(tmp11 + tmp2,
1242 CONST_BITS+PASS1_BITS+3);
1243 dataptr[DCTSIZE*6] = (dctelem_t) DESCALE(tmp11 - tmp2,
1244 CONST_BITS+PASS1_BITS+3);
1245 dataptr[DCTSIZE*2] = (dctelem_t) DESCALE(tmp12 + tmp1,
1246 CONST_BITS+PASS1_BITS+3);
1247 dataptr[DCTSIZE*5] = (dctelem_t) DESCALE(tmp12 - tmp1,
1248 CONST_BITS+PASS1_BITS+3);
1249 dataptr[DCTSIZE*3] = (dctelem_t) DESCALE(tmp13 + tmp0,
1250 CONST_BITS+PASS1_BITS+3);
1251 dataptr[DCTSIZE*4] = (dctelem_t) DESCALE(tmp13 - tmp0,
1252 CONST_BITS+PASS1_BITS+3);
1254 dataptr++; /* advance pointer to next column */
1258 #include "idct_sparse.h"
1259 #include "idct_decl.h"