1 /*****************************************************************************
2 * idct.c : C IDCT module
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
5 * $Id: idct.c,v 1.25 2002/07/31 20:56:51 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 static int Open( vlc_object_t *p_this );
37 /*****************************************************************************
39 *****************************************************************************/
41 set_description( _("IDCT module") );
42 set_capability( "idct", 50 );
44 set_callbacks( Open, NULL );
47 /* Following functions are local */
49 /*****************************************************************************
50 * NormScan : Unused in this IDCT
51 *****************************************************************************/
52 static void NormScan( u8 ppi_scan[2][64] )
56 /*****************************************************************************
57 * IDCT : IDCT function for normal matrices
58 *****************************************************************************/
59 static inline void IDCT( dctelem_t * p_block )
61 s32 tmp0, tmp1, tmp2, tmp3;
62 s32 tmp10, tmp11, tmp12, tmp13;
63 s32 z1, z2, z3, z4, z5;
64 s32 d0, d1, d2, d3, d4, d5, d6, d7;
70 /* Pass 1: process rows. */
71 /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
72 /* furthermore, we scale the results by 2**PASS1_BITS. */
76 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
78 /* Due to quantization, we will usually find that many of the input
79 * coefficients are zero, especially the AC terms. We can exploit this
80 * by short-circuiting the IDCT calculation for any row in which all
81 * the AC terms are zero. In that case each output is equal to the
82 * DC coefficient (with scale factor as needed).
83 * With typical images and quantization tables, half or more of the
84 * row DCT calculations can be simplified this way.
87 register int * idataptr = (int*)dataptr;
90 if ( (d1 == 0) && ((idataptr[1] | idataptr[2] | idataptr[3]) == 0) )
92 /* AC terms all zero */
95 /* Compute a 32 bit value to assign. */
96 dctelem_t dcval = (dctelem_t) (d0 << PASS1_BITS);
97 register int v = (dcval & 0xffff) | (dcval << 16);
105 dataptr += DCTSIZE; /* advance pointer to next row */
115 /* Even part: reverse the even part of the forward DCT. */
116 /* The rotator is sqrt(2)*c(-6). */
125 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
126 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
127 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
128 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
130 tmp0 = (d0 + d4) << CONST_BITS;
131 tmp1 = (d0 - d4) << CONST_BITS;
140 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
141 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
142 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
143 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
145 tmp0 = d4 << CONST_BITS;
150 tmp12 = -(tmp0 + tmp2);
157 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
158 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
159 tmp3 = MULTIPLY(d6, FIX(0.541196100));
161 tmp0 = (d0 + d4) << CONST_BITS;
162 tmp1 = (d0 - d4) << CONST_BITS;
171 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
172 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
173 tmp3 = MULTIPLY(d6, FIX(0.541196100));
175 tmp0 = d4 << CONST_BITS;
180 tmp12 = -(tmp0 + tmp2);
190 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
191 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
192 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
193 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
195 tmp0 = d0 << CONST_BITS;
204 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
205 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
206 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
207 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
219 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
220 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
221 tmp3 = MULTIPLY(d6, FIX(0.541196100));
223 tmp0 = d0 << CONST_BITS;
232 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
233 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
234 tmp3 = MULTIPLY(d6, FIX(0.541196100));
252 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
253 tmp2 = MULTIPLY(d2, FIX(0.541196100));
254 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
256 tmp0 = (d0 + d4) << CONST_BITS;
257 tmp1 = (d0 - d4) << CONST_BITS;
266 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
267 tmp2 = MULTIPLY(d2, FIX(0.541196100));
268 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
270 tmp0 = d4 << CONST_BITS;
275 tmp12 = -(tmp0 + tmp2);
282 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
283 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
284 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
288 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
289 tmp10 = tmp13 = d4 << CONST_BITS;
290 tmp11 = tmp12 = -tmp10;
300 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
301 tmp2 = MULTIPLY(d2, FIX(0.541196100));
302 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
304 tmp0 = d0 << CONST_BITS;
313 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
314 tmp2 = MULTIPLY(d2, FIX(0.541196100));
315 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
327 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
328 tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
332 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
333 tmp10 = tmp13 = tmp11 = tmp12 = 0;
340 /* Odd part per figure 8; the matrix is unitary and hence its
341 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
352 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
357 z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
359 tmp0 = MULTIPLY(d7, FIX(0.298631336));
360 tmp1 = MULTIPLY(d5, FIX(2.053119869));
361 tmp2 = MULTIPLY(d3, FIX(3.072711026));
362 tmp3 = MULTIPLY(d1, FIX(1.501321110));
363 z1 = MULTIPLY(z1, - FIX(0.899976223));
364 z2 = MULTIPLY(z2, - FIX(2.562915447));
365 z3 = MULTIPLY(z3, - FIX(1.961570560));
366 z4 = MULTIPLY(z4, - FIX(0.390180644));
378 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
381 z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
383 tmp0 = MULTIPLY(d7, FIX(0.298631336));
384 tmp1 = MULTIPLY(d5, FIX(2.053119869));
385 tmp2 = MULTIPLY(d3, FIX(3.072711026));
386 z1 = MULTIPLY(d7, - FIX(0.899976223));
387 z2 = MULTIPLY(z2, - FIX(2.562915447));
388 z3 = MULTIPLY(z3, - FIX(1.961570560));
389 z4 = MULTIPLY(d5, - FIX(0.390180644));
404 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
407 z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
409 tmp0 = MULTIPLY(d7, FIX(0.298631336));
410 tmp1 = MULTIPLY(d5, FIX(2.053119869));
411 tmp3 = MULTIPLY(d1, FIX(1.501321110));
412 z1 = MULTIPLY(z1, - FIX(0.899976223));
413 z2 = MULTIPLY(d5, - FIX(2.562915447));
414 z3 = MULTIPLY(d7, - FIX(1.961570560));
415 z4 = MULTIPLY(z4, - FIX(0.390180644));
427 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
428 z5 = MULTIPLY(d7 + d5, FIX(1.175875602));
430 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
431 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
432 z1 = MULTIPLY(d7, - FIX(0.899976223));
433 z3 = MULTIPLY(d7, - FIX(1.961570560));
434 z2 = MULTIPLY(d5, - FIX(2.562915447));
435 z4 = MULTIPLY(d5, - FIX(0.390180644));
453 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
456 z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
458 tmp0 = MULTIPLY(d7, FIX(0.298631336));
459 tmp2 = MULTIPLY(d3, FIX(3.072711026));
460 tmp3 = MULTIPLY(d1, FIX(1.501321110));
461 z1 = MULTIPLY(z1, - FIX(0.899976223));
462 z2 = MULTIPLY(d3, - FIX(2.562915447));
463 z3 = MULTIPLY(z3, - FIX(1.961570560));
464 z4 = MULTIPLY(d1, - FIX(0.390180644));
476 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
478 z5 = MULTIPLY(z3, FIX(1.175875602));
480 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
481 tmp2 = MULTIPLY(d3, FIX(0.509795579));
482 z1 = MULTIPLY(d7, - FIX(0.899976223));
483 z2 = MULTIPLY(d3, - FIX(2.562915447));
484 z3 = MULTIPLY(z3, - FIX2(0.785694958));
496 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
498 z5 = MULTIPLY(z1, FIX(1.175875602));
500 tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
501 tmp3 = MULTIPLY(d1, FIX2(1.111140466));
502 z1 = MULTIPLY(z1, FIX2(0.275899379));
503 z3 = MULTIPLY(d7, - FIX(1.961570560));
504 z4 = MULTIPLY(d1, - FIX(0.390180644));
513 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
514 tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
515 tmp1 = MULTIPLY(d7, FIX(1.175875602));
516 tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
517 tmp3 = MULTIPLY(d7, FIX2(0.275899379));
530 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
533 z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
535 tmp1 = MULTIPLY(d5, FIX(2.053119869));
536 tmp2 = MULTIPLY(d3, FIX(3.072711026));
537 tmp3 = MULTIPLY(d1, FIX(1.501321110));
538 z1 = MULTIPLY(d1, - FIX(0.899976223));
539 z2 = MULTIPLY(z2, - FIX(2.562915447));
540 z3 = MULTIPLY(d3, - FIX(1.961570560));
541 z4 = MULTIPLY(z4, - FIX(0.390180644));
553 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
555 z5 = MULTIPLY(z2, FIX(1.175875602));
557 tmp1 = MULTIPLY(d5, FIX2(1.662939225));
558 tmp2 = MULTIPLY(d3, FIX2(1.111140466));
559 z2 = MULTIPLY(z2, - FIX2(1.387039845));
560 z3 = MULTIPLY(d3, - FIX(1.961570560));
561 z4 = MULTIPLY(d5, - FIX(0.390180644));
573 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
575 z5 = MULTIPLY(z4, FIX(1.175875602));
577 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
578 tmp3 = MULTIPLY(d1, FIX2(0.601344887));
579 z1 = MULTIPLY(d1, - FIX(0.899976223));
580 z2 = MULTIPLY(d5, - FIX(2.562915447));
581 z4 = MULTIPLY(z4, FIX2(0.785694958));
590 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
591 tmp0 = MULTIPLY(d5, FIX(1.175875602));
592 tmp1 = MULTIPLY(d5, FIX2(0.275899380));
593 tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
594 tmp3 = MULTIPLY(d5, FIX2(0.785694958));
604 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
607 tmp2 = MULTIPLY(d3, - FIX(1.451774981));
608 tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
609 z1 = MULTIPLY(d1, FIX(1.061594337));
610 z2 = MULTIPLY(d3, - FIX(2.172734803));
611 z4 = MULTIPLY(z5, FIX(0.785694958));
612 z5 = MULTIPLY(z5, FIX(1.175875602));
621 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
622 tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
623 tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
624 tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
625 tmp3 = MULTIPLY(d3, FIX(1.175875602));
632 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
633 tmp0 = MULTIPLY(d1, FIX2(0.275899379));
634 tmp1 = MULTIPLY(d1, FIX2(0.785694958));
635 tmp2 = MULTIPLY(d1, FIX(1.175875602));
636 tmp3 = MULTIPLY(d1, FIX2(1.387039845));
640 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
641 tmp0 = tmp1 = tmp2 = tmp3 = 0;
647 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
649 dataptr[0] = (dctelem_t) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
650 dataptr[7] = (dctelem_t) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
651 dataptr[1] = (dctelem_t) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
652 dataptr[6] = (dctelem_t) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
653 dataptr[2] = (dctelem_t) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
654 dataptr[5] = (dctelem_t) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
655 dataptr[3] = (dctelem_t) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
656 dataptr[4] = (dctelem_t) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
658 dataptr += DCTSIZE; /* advance pointer to next row */
661 /* Pass 2: process columns. */
662 /* Note that we must descale the results by a factor of 8 == 2**3, */
663 /* and also undo the PASS1_BITS scaling. */
666 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
668 /* Columns of zeroes can be exploited in the same way as we did with rows.
669 * However, the row calculation has created many nonzero AC terms, so the
670 * simplification applies less often (typically 5% to 10% of the time).
671 * On machines with very fast multiplication, it's possible that the
672 * test takes more time than it's worth. In that case this section
673 * may be commented out.
676 d0 = dataptr[DCTSIZE*0];
677 d1 = dataptr[DCTSIZE*1];
678 d2 = dataptr[DCTSIZE*2];
679 d3 = dataptr[DCTSIZE*3];
680 d4 = dataptr[DCTSIZE*4];
681 d5 = dataptr[DCTSIZE*5];
682 d6 = dataptr[DCTSIZE*6];
683 d7 = dataptr[DCTSIZE*7];
685 /* Even part: reverse the even part of the forward DCT. */
686 /* The rotator is sqrt(2)*c(-6). */
695 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
696 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
697 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
698 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
700 tmp0 = (d0 + d4) << CONST_BITS;
701 tmp1 = (d0 - d4) << CONST_BITS;
710 /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
711 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
712 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
713 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
715 tmp0 = d4 << CONST_BITS;
720 tmp12 = -(tmp0 + tmp2);
727 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
728 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
729 tmp3 = MULTIPLY(d6, FIX(0.541196100));
731 tmp0 = (d0 + d4) << CONST_BITS;
732 tmp1 = (d0 - d4) << CONST_BITS;
741 /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
742 tmp2 = MULTIPLY(d6, -FIX2(1.306562965));
743 tmp3 = MULTIPLY(d6, FIX(0.541196100));
745 tmp0 = d4 << CONST_BITS;
750 tmp12 = -(tmp0 + tmp2);
760 /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
761 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
762 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
763 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
765 tmp0 = d0 << CONST_BITS;
774 /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
775 z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
776 tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
777 tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
789 /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
790 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
791 tmp3 = MULTIPLY(d6, FIX(0.541196100));
793 tmp0 = d0 << CONST_BITS;
802 /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
803 tmp2 = MULTIPLY(d6, - FIX2(1.306562965));
804 tmp3 = MULTIPLY(d6, FIX(0.541196100));
821 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
822 tmp2 = MULTIPLY(d2, FIX(0.541196100));
823 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
825 tmp0 = (d0 + d4) << CONST_BITS;
826 tmp1 = (d0 - d4) << CONST_BITS;
835 /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
836 tmp2 = MULTIPLY(d2, FIX(0.541196100));
837 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
839 tmp0 = d4 << CONST_BITS;
844 tmp12 = -(tmp0 + tmp2);
851 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
852 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
853 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
857 /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
858 tmp10 = tmp13 = d4 << CONST_BITS;
859 tmp11 = tmp12 = -tmp10;
869 /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
870 tmp2 = MULTIPLY(d2, FIX(0.541196100));
871 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
873 tmp0 = d0 << CONST_BITS;
882 /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
883 tmp2 = MULTIPLY(d2, FIX(0.541196100));
884 tmp3 = MULTIPLY(d2, (FIX(1.306562965) + .5));
896 /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
897 tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
901 /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
902 tmp10 = tmp13 = tmp11 = tmp12 = 0;
908 /* Odd part per figure 8; the matrix is unitary and hence its
909 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
919 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
924 z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
926 tmp0 = MULTIPLY(d7, FIX(0.298631336));
927 tmp1 = MULTIPLY(d5, FIX(2.053119869));
928 tmp2 = MULTIPLY(d3, FIX(3.072711026));
929 tmp3 = MULTIPLY(d1, FIX(1.501321110));
930 z1 = MULTIPLY(z1, - FIX(0.899976223));
931 z2 = MULTIPLY(z2, - FIX(2.562915447));
932 z3 = MULTIPLY(z3, - FIX(1.961570560));
933 z4 = MULTIPLY(z4, - FIX(0.390180644));
945 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
948 z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
950 tmp0 = MULTIPLY(d7, FIX(0.298631336));
951 tmp1 = MULTIPLY(d5, FIX(2.053119869));
952 tmp2 = MULTIPLY(d3, FIX(3.072711026));
953 z1 = MULTIPLY(d7, - FIX(0.899976223));
954 z2 = MULTIPLY(z2, - FIX(2.562915447));
955 z3 = MULTIPLY(z3, - FIX(1.961570560));
956 z4 = MULTIPLY(d5, - FIX(0.390180644));
971 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
974 z5 = MULTIPLY(d7 + z4, FIX(1.175875602));
976 tmp0 = MULTIPLY(d7, FIX(0.298631336));
977 tmp1 = MULTIPLY(d5, FIX(2.053119869));
978 tmp3 = MULTIPLY(d1, FIX(1.501321110));
979 z1 = MULTIPLY(z1, - FIX(0.899976223));
980 z2 = MULTIPLY(d5, - FIX(2.562915447));
981 z3 = MULTIPLY(d7, - FIX(1.961570560));
982 z4 = MULTIPLY(z4, - FIX(0.390180644));
994 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
995 z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
997 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
998 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
999 z1 = MULTIPLY(d7, - FIX(0.899976223));
1000 z3 = MULTIPLY(d7, - FIX(1.961570560));
1001 z2 = MULTIPLY(d5, - FIX(2.562915447));
1002 z4 = MULTIPLY(d5, - FIX(0.390180644));
1020 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
1023 z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
1025 tmp0 = MULTIPLY(d7, FIX(0.298631336));
1026 tmp2 = MULTIPLY(d3, FIX(3.072711026));
1027 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1028 z1 = MULTIPLY(z1, - FIX(0.899976223));
1029 z2 = MULTIPLY(d3, - FIX(2.562915447));
1030 z3 = MULTIPLY(z3, - FIX(1.961570560));
1031 z4 = MULTIPLY(d1, - FIX(0.390180644));
1043 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
1045 z5 = MULTIPLY(z3, FIX(1.175875602));
1047 tmp0 = MULTIPLY(d7, - FIX2(0.601344887));
1048 z1 = MULTIPLY(d7, - FIX(0.899976223));
1049 tmp2 = MULTIPLY(d3, FIX(0.509795579));
1050 z2 = MULTIPLY(d3, - FIX(2.562915447));
1051 z3 = MULTIPLY(z3, - FIX2(0.785694958));
1063 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
1065 z5 = MULTIPLY(z1, FIX(1.175875602));
1067 tmp0 = MULTIPLY(d7, - FIX2(1.662939224));
1068 tmp3 = MULTIPLY(d1, FIX2(1.111140466));
1069 z1 = MULTIPLY(z1, FIX2(0.275899379));
1070 z3 = MULTIPLY(d7, - FIX(1.961570560));
1071 z4 = MULTIPLY(d1, - FIX(0.390180644));
1080 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
1081 tmp0 = MULTIPLY(d7, - FIX2(1.387039845));
1082 tmp1 = MULTIPLY(d7, FIX(1.175875602));
1083 tmp2 = MULTIPLY(d7, - FIX2(0.785694958));
1084 tmp3 = MULTIPLY(d7, FIX2(0.275899379));
1097 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
1100 z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
1102 tmp1 = MULTIPLY(d5, FIX(2.053119869));
1103 tmp2 = MULTIPLY(d3, FIX(3.072711026));
1104 tmp3 = MULTIPLY(d1, FIX(1.501321110));
1105 z1 = MULTIPLY(d1, - FIX(0.899976223));
1106 z2 = MULTIPLY(z2, - FIX(2.562915447));
1107 z3 = MULTIPLY(d3, - FIX(1.961570560));
1108 z4 = MULTIPLY(z4, - FIX(0.390180644));
1120 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
1122 z5 = MULTIPLY(z2, FIX(1.175875602));
1124 tmp1 = MULTIPLY(d5, FIX2(1.662939225));
1125 tmp2 = MULTIPLY(d3, FIX2(1.111140466));
1126 z2 = MULTIPLY(z2, - FIX2(1.387039845));
1127 z3 = MULTIPLY(d3, - FIX(1.961570560));
1128 z4 = MULTIPLY(d5, - FIX(0.390180644));
1140 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
1142 z5 = MULTIPLY(z4, FIX(1.175875602));
1144 tmp1 = MULTIPLY(d5, - FIX2(0.509795578));
1145 tmp3 = MULTIPLY(d1, FIX2(0.601344887));
1146 z1 = MULTIPLY(d1, - FIX(0.899976223));
1147 z2 = MULTIPLY(d5, - FIX(2.562915447));
1148 z4 = MULTIPLY(z4, FIX2(0.785694958));
1157 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
1158 tmp0 = MULTIPLY(d5, FIX(1.175875602));
1159 tmp1 = MULTIPLY(d5, FIX2(0.275899380));
1160 tmp2 = MULTIPLY(d5, - FIX2(1.387039845));
1161 tmp3 = MULTIPLY(d5, FIX2(0.785694958));
1171 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
1174 tmp2 = MULTIPLY(d3, - FIX(1.451774981));
1175 tmp3 = MULTIPLY(d1, (FIX(0.211164243) - 1));
1176 z1 = MULTIPLY(d1, FIX(1.061594337));
1177 z2 = MULTIPLY(d3, - FIX(2.172734803));
1178 z4 = MULTIPLY(z5, FIX(0.785694958));
1179 z5 = MULTIPLY(z5, FIX(1.175875602));
1188 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
1189 tmp0 = MULTIPLY(d3, - FIX2(0.785694958));
1190 tmp1 = MULTIPLY(d3, - FIX2(1.387039845));
1191 tmp2 = MULTIPLY(d3, - FIX2(0.275899379));
1192 tmp3 = MULTIPLY(d3, FIX(1.175875602));
1199 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
1200 tmp0 = MULTIPLY(d1, FIX2(0.275899379));
1201 tmp1 = MULTIPLY(d1, FIX2(0.785694958));
1202 tmp2 = MULTIPLY(d1, FIX(1.175875602));
1203 tmp3 = MULTIPLY(d1, FIX2(1.387039845));
1207 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
1208 tmp0 = tmp1 = tmp2 = tmp3 = 0;
1214 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1216 dataptr[DCTSIZE*0] = (dctelem_t) DESCALE(tmp10 + tmp3,
1217 CONST_BITS+PASS1_BITS+3);
1218 dataptr[DCTSIZE*7] = (dctelem_t) DESCALE(tmp10 - tmp3,
1219 CONST_BITS+PASS1_BITS+3);
1220 dataptr[DCTSIZE*1] = (dctelem_t) DESCALE(tmp11 + tmp2,
1221 CONST_BITS+PASS1_BITS+3);
1222 dataptr[DCTSIZE*6] = (dctelem_t) DESCALE(tmp11 - tmp2,
1223 CONST_BITS+PASS1_BITS+3);
1224 dataptr[DCTSIZE*2] = (dctelem_t) DESCALE(tmp12 + tmp1,
1225 CONST_BITS+PASS1_BITS+3);
1226 dataptr[DCTSIZE*5] = (dctelem_t) DESCALE(tmp12 - tmp1,
1227 CONST_BITS+PASS1_BITS+3);
1228 dataptr[DCTSIZE*3] = (dctelem_t) DESCALE(tmp13 + tmp0,
1229 CONST_BITS+PASS1_BITS+3);
1230 dataptr[DCTSIZE*4] = (dctelem_t) DESCALE(tmp13 - tmp0,
1231 CONST_BITS+PASS1_BITS+3);
1233 dataptr++; /* advance pointer to next column */
1237 static inline void RestoreCPUState( )
1242 #include "idct_sparse.h"
1243 #include "idct_decl.h"