« back to all changes in this revision
Viewing changes to jidctint.c
- browse files at revision 10
- compare with another revision
- download diff
- download tarball
- view history from revision 10
- Committer: Package Import Robot
- Author(s): Fathi Boudra
- Date: 2013-07-28 16:52:51 UTC
- mfrom: (1.1.3) (9.1.1 saucy-proposed)
- Revision ID: package-import@ubuntu.com-20130728165251-7vg6wszhm941kdej
Tags: 1.3.0-0ubuntu1
* New upstream release.
- drop debian/patches/branch-updates.diff
- refresh tjunittest.patch (now renamed to install-tjunittest.patch)
* Update debian/control:
- add myself to Uploaders.
* Update debian/copyright:
- add RSA Data Security copyright (md5).
* Update debian/libturbojpeg.install:
- install libturbojpeg.so.0* (needed by tjunittest and tjbench).
- drop debian/patches/branch-updates.diff
- refresh tjunittest.patch (now renamed to install-tjunittest.patch)
* Update debian/control:
- add myself to Uploaders.
* Update debian/copyright:
- add RSA Data Security copyright (md5).
* Update debian/libturbojpeg.install:
- install libturbojpeg.so.0* (needed by tjunittest and tjbench).
- files added:
- .pc/install-tjunittest.patch
- md5
- files removed:
- .pc/branch-updates.diff
- .pc/branch-updates.diff/release
- .pc/branch-updates.diff/simd
- .pc/tjunittest.patch
- files modified:
- .pc/applied-patches
added
removed
jidctint.c
2
2
* jidctint.c
3
3
*
4
4
* Copyright (C) 1991-1998, Thomas G. Lane.
5
* Modification developed 2002-2009 by Guido Vollbeding.
5
6
* This file is part of the Independent JPEG Group's software.
6
7
* For conditions of distribution and use, see the accompanying README file.
7
8
*
23
24
* The advantage of this method is that no data path contains more than one
24
25
* multiplication; this allows a very simple and accurate implementation in
25
26
* scaled fixed-point arithmetic, with a minimal number of shifts.
27
*
28
* We also provide IDCT routines with various output sample block sizes for
29
* direct resolution reduction or enlargement without additional resampling:
30
* NxN (N=1...16) pixels for one 8x8 input DCT block.
31
*
32
* For N<8 we simply take the corresponding low-frequency coefficients of
33
* the 8x8 input DCT block and apply an NxN point IDCT on the sub-block
34
* to yield the downscaled outputs.
35
* This can be seen as direct low-pass downsampling from the DCT domain
36
* point of view rather than the usual spatial domain point of view,
37
* yielding significant computational savings and results at least
38
* as good as common bilinear (averaging) spatial downsampling.
39
*
40
* For N>8 we apply a partial NxN IDCT on the 8 input coefficients as
41
* lower frequencies and higher frequencies assumed to be zero.
42
* It turns out that the computational effort is similar to the 8x8 IDCT
43
* regarding the output size.
44
* Furthermore, the scaling and descaling is the same for all IDCT sizes.
45
*
46
* CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
47
* since there would be too many additional constants to pre-calculate.
26
48
*/
27
49
28
50
#define JPEG_INTERNALS
38
60
*/
39
61
40
62
#if DCTSIZE != 8
41
Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
63
Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
42
64
#endif
43
65
44
66
386
408
}
387
409
}
388
410
411
#ifdef IDCT_SCALING_SUPPORTED
412
413
414
/*
415
* Perform dequantization and inverse DCT on one block of coefficients,
416
* producing a 7x7 output block.
417
*
418
* Optimized algorithm with 12 multiplications in the 1-D kernel.
419
* cK represents sqrt(2) * cos(K*pi/14).
420
*/
421
422
GLOBAL(void)
423
jpeg_idct_7x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
424
JCOEFPTR coef_block,
425
JSAMPARRAY output_buf, JDIMENSION output_col)
426
{
427
INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12, tmp13;
428
INT32 z1, z2, z3;
429
JCOEFPTR inptr;
430
ISLOW_MULT_TYPE * quantptr;
431
int * wsptr;
432
JSAMPROW outptr;
433
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
434
int ctr;
435
int workspace[7*7]; /* buffers data between passes */
436
SHIFT_TEMPS
437
438
/* Pass 1: process columns from input, store into work array. */
439
440
inptr = coef_block;
441
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
442
wsptr = workspace;
443
for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
444
/* Even part */
445
446
tmp13 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
447
tmp13 <<= CONST_BITS;
448
/* Add fudge factor here for final descale. */
449
tmp13 += ONE << (CONST_BITS-PASS1_BITS-1);
450
451
z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
452
z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
453
z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
454
455
tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734)); /* c4 */
456
tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123)); /* c6 */
457
tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
458
tmp0 = z1 + z3;
459
z2 -= tmp0;
460
tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
461
tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536)); /* c2-c4-c6 */
462
tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249)); /* c2+c4+c6 */
463
tmp13 += MULTIPLY(z2, FIX(1.414213562)); /* c0 */
464
465
/* Odd part */
466
467
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
468
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
469
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
470
471
tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347)); /* (c3+c1-c5)/2 */
472
tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339)); /* (c3+c5-c1)/2 */
473
tmp0 = tmp1 - tmp2;
474
tmp1 += tmp2;
475
tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276)); /* -c1 */
476
tmp1 += tmp2;
477
z2 = MULTIPLY(z1 + z3, FIX(0.613604268)); /* c5 */
478
tmp0 += z2;
479
tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693)); /* c3+c1-c5 */
480
481
/* Final output stage */
482
483
wsptr[7*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
484
wsptr[7*6] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
485
wsptr[7*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
486
wsptr[7*5] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
487
wsptr[7*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
488
wsptr[7*4] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
489
wsptr[7*3] = (int) RIGHT_SHIFT(tmp13, CONST_BITS-PASS1_BITS);
490
}
491
492
/* Pass 2: process 7 rows from work array, store into output array. */
493
494
wsptr = workspace;
495
for (ctr = 0; ctr < 7; ctr++) {
496
outptr = output_buf[ctr] + output_col;
497
498
/* Even part */
499
500
/* Add fudge factor here for final descale. */
501
tmp13 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
502
tmp13 <<= CONST_BITS;
503
504
z1 = (INT32) wsptr[2];
505
z2 = (INT32) wsptr[4];
506
z3 = (INT32) wsptr[6];
507
508
tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734)); /* c4 */
509
tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123)); /* c6 */
510
tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
511
tmp0 = z1 + z3;
512
z2 -= tmp0;
513
tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
514
tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536)); /* c2-c4-c6 */
515
tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249)); /* c2+c4+c6 */
516
tmp13 += MULTIPLY(z2, FIX(1.414213562)); /* c0 */
517
518
/* Odd part */
519
520
z1 = (INT32) wsptr[1];
521
z2 = (INT32) wsptr[3];
522
z3 = (INT32) wsptr[5];
523
524
tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347)); /* (c3+c1-c5)/2 */
525
tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339)); /* (c3+c5-c1)/2 */
526
tmp0 = tmp1 - tmp2;
527
tmp1 += tmp2;
528
tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276)); /* -c1 */
529
tmp1 += tmp2;
530
z2 = MULTIPLY(z1 + z3, FIX(0.613604268)); /* c5 */
531
tmp0 += z2;
532
tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693)); /* c3+c1-c5 */
533
534
/* Final output stage */
535
536
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
537
CONST_BITS+PASS1_BITS+3)
538
& RANGE_MASK];
539
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
540
CONST_BITS+PASS1_BITS+3)
541
& RANGE_MASK];
542
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
543
CONST_BITS+PASS1_BITS+3)
544
& RANGE_MASK];
545
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
546
CONST_BITS+PASS1_BITS+3)
547
& RANGE_MASK];
548
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
549
CONST_BITS+PASS1_BITS+3)
550
& RANGE_MASK];
551
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
552
CONST_BITS+PASS1_BITS+3)
553
& RANGE_MASK];
554
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13,
555
CONST_BITS+PASS1_BITS+3)
556
& RANGE_MASK];
557
558
wsptr += 7; /* advance pointer to next row */
559
}
560
}
561
562
563
/*
564
* Perform dequantization and inverse DCT on one block of coefficients,
565
* producing a reduced-size 6x6 output block.
566
*
567
* Optimized algorithm with 3 multiplications in the 1-D kernel.
568
* cK represents sqrt(2) * cos(K*pi/12).
569
*/
570
571
GLOBAL(void)
572
jpeg_idct_6x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
573
JCOEFPTR coef_block,
574
JSAMPARRAY output_buf, JDIMENSION output_col)
575
{
576
INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
577
INT32 z1, z2, z3;
578
JCOEFPTR inptr;
579
ISLOW_MULT_TYPE * quantptr;
580
int * wsptr;
581
JSAMPROW outptr;
582
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
583
int ctr;
584
int workspace[6*6]; /* buffers data between passes */
585
SHIFT_TEMPS
586
587
/* Pass 1: process columns from input, store into work array. */
588
589
inptr = coef_block;
590
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
591
wsptr = workspace;
592
for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
593
/* Even part */
594
595
tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
596
tmp0 <<= CONST_BITS;
597
/* Add fudge factor here for final descale. */
598
tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
599
tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
600
tmp10 = MULTIPLY(tmp2, FIX(0.707106781)); /* c4 */
601
tmp1 = tmp0 + tmp10;
602
tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
603
tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
604
tmp0 = MULTIPLY(tmp10, FIX(1.224744871)); /* c2 */
605
tmp10 = tmp1 + tmp0;
606
tmp12 = tmp1 - tmp0;
607
608
/* Odd part */
609
610
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
611
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
612
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
613
tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
614
tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
615
tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
616
tmp1 = (z1 - z2 - z3) << PASS1_BITS;
617
618
/* Final output stage */
619
620
wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
621
wsptr[6*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
622
wsptr[6*1] = (int) (tmp11 + tmp1);
623
wsptr[6*4] = (int) (tmp11 - tmp1);
624
wsptr[6*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
625
wsptr[6*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
626
}
627
628
/* Pass 2: process 6 rows from work array, store into output array. */
629
630
wsptr = workspace;
631
for (ctr = 0; ctr < 6; ctr++) {
632
outptr = output_buf[ctr] + output_col;
633
634
/* Even part */
635
636
/* Add fudge factor here for final descale. */
637
tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
638
tmp0 <<= CONST_BITS;
639
tmp2 = (INT32) wsptr[4];
640
tmp10 = MULTIPLY(tmp2, FIX(0.707106781)); /* c4 */
641
tmp1 = tmp0 + tmp10;
642
tmp11 = tmp0 - tmp10 - tmp10;
643
tmp10 = (INT32) wsptr[2];
644
tmp0 = MULTIPLY(tmp10, FIX(1.224744871)); /* c2 */
645
tmp10 = tmp1 + tmp0;
646
tmp12 = tmp1 - tmp0;
647
648
/* Odd part */
649
650
z1 = (INT32) wsptr[1];
651
z2 = (INT32) wsptr[3];
652
z3 = (INT32) wsptr[5];
653
tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
654
tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
655
tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
656
tmp1 = (z1 - z2 - z3) << CONST_BITS;
657
658
/* Final output stage */
659
660
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
661
CONST_BITS+PASS1_BITS+3)
662
& RANGE_MASK];
663
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
664
CONST_BITS+PASS1_BITS+3)
665
& RANGE_MASK];
666
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
667
CONST_BITS+PASS1_BITS+3)
668
& RANGE_MASK];
669
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
670
CONST_BITS+PASS1_BITS+3)
671
& RANGE_MASK];
672
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
673
CONST_BITS+PASS1_BITS+3)
674
& RANGE_MASK];
675
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
676
CONST_BITS+PASS1_BITS+3)
677
& RANGE_MASK];
678
679
wsptr += 6; /* advance pointer to next row */
680
}
681
}
682
683
684
/*
685
* Perform dequantization and inverse DCT on one block of coefficients,
686
* producing a reduced-size 5x5 output block.
687
*
688
* Optimized algorithm with 5 multiplications in the 1-D kernel.
689
* cK represents sqrt(2) * cos(K*pi/10).
690
*/
691
692
GLOBAL(void)
693
jpeg_idct_5x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
694
JCOEFPTR coef_block,
695
JSAMPARRAY output_buf, JDIMENSION output_col)
696
{
697
INT32 tmp0, tmp1, tmp10, tmp11, tmp12;
698
INT32 z1, z2, z3;
699
JCOEFPTR inptr;
700
ISLOW_MULT_TYPE * quantptr;
701
int * wsptr;
702
JSAMPROW outptr;
703
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
704
int ctr;
705
int workspace[5*5]; /* buffers data between passes */
706
SHIFT_TEMPS
707
708
/* Pass 1: process columns from input, store into work array. */
709
710
inptr = coef_block;
711
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
712
wsptr = workspace;
713
for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
714
/* Even part */
715
716
tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
717
tmp12 <<= CONST_BITS;
718
/* Add fudge factor here for final descale. */
719
tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
720
tmp0 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
721
tmp1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
722
z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
723
z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
724
z3 = tmp12 + z2;
725
tmp10 = z3 + z1;
726
tmp11 = z3 - z1;
727
tmp12 -= z2 << 2;
728
729
/* Odd part */
730
731
z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
732
z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
733
734
z1 = MULTIPLY(z2 + z3, FIX(0.831253876)); /* c3 */
735
tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c1-c3 */
736
tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c1+c3 */
737
738
/* Final output stage */
739
740
wsptr[5*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
741
wsptr[5*4] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
742
wsptr[5*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
743
wsptr[5*3] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
744
wsptr[5*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
745
}
746
747
/* Pass 2: process 5 rows from work array, store into output array. */
748
749
wsptr = workspace;
750
for (ctr = 0; ctr < 5; ctr++) {
751
outptr = output_buf[ctr] + output_col;
752
753
/* Even part */
754
755
/* Add fudge factor here for final descale. */
756
tmp12 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
757
tmp12 <<= CONST_BITS;
758
tmp0 = (INT32) wsptr[2];
759
tmp1 = (INT32) wsptr[4];
760
z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
761
z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
762
z3 = tmp12 + z2;
763
tmp10 = z3 + z1;
764
tmp11 = z3 - z1;
765
tmp12 -= z2 << 2;
766
767
/* Odd part */
768
769
z2 = (INT32) wsptr[1];
770
z3 = (INT32) wsptr[3];
771
772
z1 = MULTIPLY(z2 + z3, FIX(0.831253876)); /* c3 */
773
tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c1-c3 */
774
tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c1+c3 */
775
776
/* Final output stage */
777
778
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
779
CONST_BITS+PASS1_BITS+3)
780
& RANGE_MASK];
781
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
782
CONST_BITS+PASS1_BITS+3)
783
& RANGE_MASK];
784
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
785
CONST_BITS+PASS1_BITS+3)
786
& RANGE_MASK];
787
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
788
CONST_BITS+PASS1_BITS+3)
789
& RANGE_MASK];
790
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
791
CONST_BITS+PASS1_BITS+3)
792
& RANGE_MASK];
793
794
wsptr += 5; /* advance pointer to next row */
795
}
796
}
797
798
799
/*
800
* Perform dequantization and inverse DCT on one block of coefficients,
801
* producing a reduced-size 3x3 output block.
802
*
803
* Optimized algorithm with 2 multiplications in the 1-D kernel.
804
* cK represents sqrt(2) * cos(K*pi/6).
805
*/
806
807
GLOBAL(void)
808
jpeg_idct_3x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
809
JCOEFPTR coef_block,
810
JSAMPARRAY output_buf, JDIMENSION output_col)
811
{
812
INT32 tmp0, tmp2, tmp10, tmp12;
813
JCOEFPTR inptr;
814
ISLOW_MULT_TYPE * quantptr;
815
int * wsptr;
816
JSAMPROW outptr;
817
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
818
int ctr;
819
int workspace[3*3]; /* buffers data between passes */
820
SHIFT_TEMPS
821
822
/* Pass 1: process columns from input, store into work array. */
823
824
inptr = coef_block;
825
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
826
wsptr = workspace;
827
for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
828
/* Even part */
829
830
tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
831
tmp0 <<= CONST_BITS;
832
/* Add fudge factor here for final descale. */
833
tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
834
tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
835
tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
836
tmp10 = tmp0 + tmp12;
837
tmp2 = tmp0 - tmp12 - tmp12;
838
839
/* Odd part */
840
841
tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
842
tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
843
844
/* Final output stage */
845
846
wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
847
wsptr[3*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
848
wsptr[3*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
849
}
850
851
/* Pass 2: process 3 rows from work array, store into output array. */
852
853
wsptr = workspace;
854
for (ctr = 0; ctr < 3; ctr++) {
855
outptr = output_buf[ctr] + output_col;
856
857
/* Even part */
858
859
/* Add fudge factor here for final descale. */
860
tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
861
tmp0 <<= CONST_BITS;
862
tmp2 = (INT32) wsptr[2];
863
tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
864
tmp10 = tmp0 + tmp12;
865
tmp2 = tmp0 - tmp12 - tmp12;
866
867
/* Odd part */
868
869
tmp12 = (INT32) wsptr[1];
870
tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
871
872
/* Final output stage */
873
874
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
875
CONST_BITS+PASS1_BITS+3)
876
& RANGE_MASK];
877
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
878
CONST_BITS+PASS1_BITS+3)
879
& RANGE_MASK];
880
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
881
CONST_BITS+PASS1_BITS+3)
882
& RANGE_MASK];
883
884
wsptr += 3; /* advance pointer to next row */
885
}
886
}
887
888
889
/*
890
* Perform dequantization and inverse DCT on one block of coefficients,
891
* producing a 9x9 output block.
892
*
893
* Optimized algorithm with 10 multiplications in the 1-D kernel.
894
* cK represents sqrt(2) * cos(K*pi/18).
895
*/
896
897
GLOBAL(void)
898
jpeg_idct_9x9 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
899
JCOEFPTR coef_block,
900
JSAMPARRAY output_buf, JDIMENSION output_col)
901
{
902
INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13, tmp14;
903
INT32 z1, z2, z3, z4;
904
JCOEFPTR inptr;
905
ISLOW_MULT_TYPE * quantptr;
906
int * wsptr;
907
JSAMPROW outptr;
908
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
909
int ctr;
910
int workspace[8*9]; /* buffers data between passes */
911
SHIFT_TEMPS
912
913
/* Pass 1: process columns from input, store into work array. */
914
915
inptr = coef_block;
916
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
917
wsptr = workspace;
918
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
919
/* Even part */
920
921
tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
922
tmp0 <<= CONST_BITS;
923
/* Add fudge factor here for final descale. */
924
tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
925
926
z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
927
z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
928
z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
929
930
tmp3 = MULTIPLY(z3, FIX(0.707106781)); /* c6 */
931
tmp1 = tmp0 + tmp3;
932
tmp2 = tmp0 - tmp3 - tmp3;
933
934
tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
935
tmp11 = tmp2 + tmp0;
936
tmp14 = tmp2 - tmp0 - tmp0;
937
938
tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
939
tmp2 = MULTIPLY(z1, FIX(1.083350441)); /* c4 */
940
tmp3 = MULTIPLY(z2, FIX(0.245575608)); /* c8 */
941
942
tmp10 = tmp1 + tmp0 - tmp3;
943
tmp12 = tmp1 - tmp0 + tmp2;
944
tmp13 = tmp1 - tmp2 + tmp3;
945
946
/* Odd part */
947
948
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
949
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
950
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
951
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
952
953
z2 = MULTIPLY(z2, - FIX(1.224744871)); /* -c3 */
954
955
tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955)); /* c5 */
956
tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525)); /* c7 */
957
tmp0 = tmp2 + tmp3 - z2;
958
tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481)); /* c1 */
959
tmp2 += z2 - tmp1;
960
tmp3 += z2 + tmp1;
961
tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
962
963
/* Final output stage */
964
965
wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
966
wsptr[8*8] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
967
wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
968
wsptr[8*7] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
969
wsptr[8*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
970
wsptr[8*6] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
971
wsptr[8*3] = (int) RIGHT_SHIFT(tmp13 + tmp3, CONST_BITS-PASS1_BITS);
972
wsptr[8*5] = (int) RIGHT_SHIFT(tmp13 - tmp3, CONST_BITS-PASS1_BITS);
973
wsptr[8*4] = (int) RIGHT_SHIFT(tmp14, CONST_BITS-PASS1_BITS);
974
}
975
976
/* Pass 2: process 9 rows from work array, store into output array. */
977
978
wsptr = workspace;
979
for (ctr = 0; ctr < 9; ctr++) {
980
outptr = output_buf[ctr] + output_col;
981
982
/* Even part */
983
984
/* Add fudge factor here for final descale. */
985
tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
986
tmp0 <<= CONST_BITS;
987
988
z1 = (INT32) wsptr[2];
989
z2 = (INT32) wsptr[4];
990
z3 = (INT32) wsptr[6];
991
992
tmp3 = MULTIPLY(z3, FIX(0.707106781)); /* c6 */
993
tmp1 = tmp0 + tmp3;
994
tmp2 = tmp0 - tmp3 - tmp3;
995
996
tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
997
tmp11 = tmp2 + tmp0;
998
tmp14 = tmp2 - tmp0 - tmp0;
999
1000
tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
1001
tmp2 = MULTIPLY(z1, FIX(1.083350441)); /* c4 */
1002
tmp3 = MULTIPLY(z2, FIX(0.245575608)); /* c8 */
1003
1004
tmp10 = tmp1 + tmp0 - tmp3;
1005
tmp12 = tmp1 - tmp0 + tmp2;
1006
tmp13 = tmp1 - tmp2 + tmp3;
1007
1008
/* Odd part */
1009
1010
z1 = (INT32) wsptr[1];
1011
z2 = (INT32) wsptr[3];
1012
z3 = (INT32) wsptr[5];
1013
z4 = (INT32) wsptr[7];
1014
1015
z2 = MULTIPLY(z2, - FIX(1.224744871)); /* -c3 */
1016
1017
tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955)); /* c5 */
1018
tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525)); /* c7 */
1019
tmp0 = tmp2 + tmp3 - z2;
1020
tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481)); /* c1 */
1021
tmp2 += z2 - tmp1;
1022
tmp3 += z2 + tmp1;
1023
tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
1024
1025
/* Final output stage */
1026
1027
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
1028
CONST_BITS+PASS1_BITS+3)
1029
& RANGE_MASK];
1030
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
1031
CONST_BITS+PASS1_BITS+3)
1032
& RANGE_MASK];
1033
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
1034
CONST_BITS+PASS1_BITS+3)
1035
& RANGE_MASK];
1036
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
1037
CONST_BITS+PASS1_BITS+3)
1038
& RANGE_MASK];
1039
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
1040
CONST_BITS+PASS1_BITS+3)
1041
& RANGE_MASK];
1042
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
1043
CONST_BITS+PASS1_BITS+3)
1044
& RANGE_MASK];
1045
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp3,
1046
CONST_BITS+PASS1_BITS+3)
1047
& RANGE_MASK];
1048
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp3,
1049
CONST_BITS+PASS1_BITS+3)
1050
& RANGE_MASK];
1051
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp14,
1052
CONST_BITS+PASS1_BITS+3)
1053
& RANGE_MASK];
1054
1055
wsptr += 8; /* advance pointer to next row */
1056
}
1057
}
1058
1059
1060
/*
1061
* Perform dequantization and inverse DCT on one block of coefficients,
1062
* producing a 10x10 output block.
1063
*
1064
* Optimized algorithm with 12 multiplications in the 1-D kernel.
1065
* cK represents sqrt(2) * cos(K*pi/20).
1066
*/
1067
1068
GLOBAL(void)
1069
jpeg_idct_10x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1070
JCOEFPTR coef_block,
1071
JSAMPARRAY output_buf, JDIMENSION output_col)
1072
{
1073
INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1074
INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
1075
INT32 z1, z2, z3, z4, z5;
1076
JCOEFPTR inptr;
1077
ISLOW_MULT_TYPE * quantptr;
1078
int * wsptr;
1079
JSAMPROW outptr;
1080
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1081
int ctr;
1082
int workspace[8*10]; /* buffers data between passes */
1083
SHIFT_TEMPS
1084
1085
/* Pass 1: process columns from input, store into work array. */
1086
1087
inptr = coef_block;
1088
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1089
wsptr = workspace;
1090
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1091
/* Even part */
1092
1093
z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1094
z3 <<= CONST_BITS;
1095
/* Add fudge factor here for final descale. */
1096
z3 += ONE << (CONST_BITS-PASS1_BITS-1);
1097
z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1098
z1 = MULTIPLY(z4, FIX(1.144122806)); /* c4 */
1099
z2 = MULTIPLY(z4, FIX(0.437016024)); /* c8 */
1100
tmp10 = z3 + z1;
1101
tmp11 = z3 - z2;
1102
1103
tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1), /* c0 = (c4-c8)*2 */
1104
CONST_BITS-PASS1_BITS);
1105
1106
z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1107
z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1108
1109
z1 = MULTIPLY(z2 + z3, FIX(0.831253876)); /* c6 */
1110
tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
1111
tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
1112
1113
tmp20 = tmp10 + tmp12;
1114
tmp24 = tmp10 - tmp12;
1115
tmp21 = tmp11 + tmp13;
1116
tmp23 = tmp11 - tmp13;
1117
1118
/* Odd part */
1119
1120
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1121
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1122
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1123
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1124
1125
tmp11 = z2 + z4;
1126
tmp13 = z2 - z4;
1127
1128
tmp12 = MULTIPLY(tmp13, FIX(0.309016994)); /* (c3-c7)/2 */
1129
z5 = z3 << CONST_BITS;
1130
1131
z2 = MULTIPLY(tmp11, FIX(0.951056516)); /* (c3+c7)/2 */
1132
z4 = z5 + tmp12;
1133
1134
tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
1135
tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
1136
1137
z2 = MULTIPLY(tmp11, FIX(0.587785252)); /* (c1-c9)/2 */
1138
z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
1139
1140
tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
1141
1142
tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
1143
tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
1144
1145
/* Final output stage */
1146
1147
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1148
wsptr[8*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1149
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1150
wsptr[8*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1151
wsptr[8*2] = (int) (tmp22 + tmp12);
1152
wsptr[8*7] = (int) (tmp22 - tmp12);
1153
wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1154
wsptr[8*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1155
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1156
wsptr[8*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1157
}
1158
1159
/* Pass 2: process 10 rows from work array, store into output array. */
1160
1161
wsptr = workspace;
1162
for (ctr = 0; ctr < 10; ctr++) {
1163
outptr = output_buf[ctr] + output_col;
1164
1165
/* Even part */
1166
1167
/* Add fudge factor here for final descale. */
1168
z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1169
z3 <<= CONST_BITS;
1170
z4 = (INT32) wsptr[4];
1171
z1 = MULTIPLY(z4, FIX(1.144122806)); /* c4 */
1172
z2 = MULTIPLY(z4, FIX(0.437016024)); /* c8 */
1173
tmp10 = z3 + z1;
1174
tmp11 = z3 - z2;
1175
1176
tmp22 = z3 - ((z1 - z2) << 1); /* c0 = (c4-c8)*2 */
1177
1178
z2 = (INT32) wsptr[2];
1179
z3 = (INT32) wsptr[6];
1180
1181
z1 = MULTIPLY(z2 + z3, FIX(0.831253876)); /* c6 */
1182
tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
1183
tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
1184
1185
tmp20 = tmp10 + tmp12;
1186
tmp24 = tmp10 - tmp12;
1187
tmp21 = tmp11 + tmp13;
1188
tmp23 = tmp11 - tmp13;
1189
1190
/* Odd part */
1191
1192
z1 = (INT32) wsptr[1];
1193
z2 = (INT32) wsptr[3];
1194
z3 = (INT32) wsptr[5];
1195
z3 <<= CONST_BITS;
1196
z4 = (INT32) wsptr[7];
1197
1198
tmp11 = z2 + z4;
1199
tmp13 = z2 - z4;
1200
1201
tmp12 = MULTIPLY(tmp13, FIX(0.309016994)); /* (c3-c7)/2 */
1202
1203
z2 = MULTIPLY(tmp11, FIX(0.951056516)); /* (c3+c7)/2 */
1204
z4 = z3 + tmp12;
1205
1206
tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
1207
tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
1208
1209
z2 = MULTIPLY(tmp11, FIX(0.587785252)); /* (c1-c9)/2 */
1210
z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
1211
1212
tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
1213
1214
tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
1215
tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
1216
1217
/* Final output stage */
1218
1219
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1220
CONST_BITS+PASS1_BITS+3)
1221
& RANGE_MASK];
1222
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1223
CONST_BITS+PASS1_BITS+3)
1224
& RANGE_MASK];
1225
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1226
CONST_BITS+PASS1_BITS+3)
1227
& RANGE_MASK];
1228
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1229
CONST_BITS+PASS1_BITS+3)
1230
& RANGE_MASK];
1231
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1232
CONST_BITS+PASS1_BITS+3)
1233
& RANGE_MASK];
1234
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1235
CONST_BITS+PASS1_BITS+3)
1236
& RANGE_MASK];
1237
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1238
CONST_BITS+PASS1_BITS+3)
1239
& RANGE_MASK];
1240
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1241
CONST_BITS+PASS1_BITS+3)
1242
& RANGE_MASK];
1243
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1244
CONST_BITS+PASS1_BITS+3)
1245
& RANGE_MASK];
1246
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1247
CONST_BITS+PASS1_BITS+3)
1248
& RANGE_MASK];
1249
1250
wsptr += 8; /* advance pointer to next row */
1251
}
1252
}
1253
1254
1255
/*
1256
* Perform dequantization and inverse DCT on one block of coefficients,
1257
* producing a 11x11 output block.
1258
*
1259
* Optimized algorithm with 24 multiplications in the 1-D kernel.
1260
* cK represents sqrt(2) * cos(K*pi/22).
1261
*/
1262
1263
GLOBAL(void)
1264
jpeg_idct_11x11 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1265
JCOEFPTR coef_block,
1266
JSAMPARRAY output_buf, JDIMENSION output_col)
1267
{
1268
INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1269
INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
1270
INT32 z1, z2, z3, z4;
1271
JCOEFPTR inptr;
1272
ISLOW_MULT_TYPE * quantptr;
1273
int * wsptr;
1274
JSAMPROW outptr;
1275
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1276
int ctr;
1277
int workspace[8*11]; /* buffers data between passes */
1278
SHIFT_TEMPS
1279
1280
/* Pass 1: process columns from input, store into work array. */
1281
1282
inptr = coef_block;
1283
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1284
wsptr = workspace;
1285
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1286
/* Even part */
1287
1288
tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1289
tmp10 <<= CONST_BITS;
1290
/* Add fudge factor here for final descale. */
1291
tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
1292
1293
z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1294
z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1295
z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1296
1297
tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132)); /* c2+c4 */
1298
tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045)); /* c2-c6 */
1299
z4 = z1 + z3;
1300
tmp24 = MULTIPLY(z4, - FIX(1.155664402)); /* -(c2-c10) */
1301
z4 -= z2;
1302
tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976)); /* c2 */
1303
tmp21 = tmp20 + tmp23 + tmp25 -
1304
MULTIPLY(z2, FIX(1.821790775)); /* c2+c4+c10-c6 */
1305
tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
1306
tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
1307
tmp24 += tmp25;
1308
tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120)); /* c8+c10 */
1309
tmp24 += MULTIPLY(z2, FIX(1.944413522)) - /* c2+c8 */
1310
MULTIPLY(z1, FIX(1.390975730)); /* c4+c10 */
1311
tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562)); /* c0 */
1312
1313
/* Odd part */
1314
1315
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1316
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1317
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1318
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1319
1320
tmp11 = z1 + z2;
1321
tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
1322
tmp11 = MULTIPLY(tmp11, FIX(0.887983902)); /* c3-c9 */
1323
tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295)); /* c5-c9 */
1324
tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
1325
tmp10 = tmp11 + tmp12 + tmp13 -
1326
MULTIPLY(z1, FIX(0.923107866)); /* c7+c5+c3-c1-2*c9 */
1327
z1 = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
1328
tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588)); /* c1+c7+3*c9-c3 */
1329
tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623)); /* c3+c5-c7-c9 */
1330
z1 = MULTIPLY(z2 + z4, - FIX(1.798248910)); /* -(c1+c9) */
1331
tmp11 += z1;
1332
tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632)); /* c1+c5+c9-c7 */
1333
tmp14 += MULTIPLY(z2, - FIX(1.467221301)) + /* -(c5+c9) */
1334
MULTIPLY(z3, FIX(1.001388905)) - /* c1-c9 */
1335
MULTIPLY(z4, FIX(1.684843907)); /* c3+c9 */
1336
1337
/* Final output stage */
1338
1339
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1340
wsptr[8*10] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1341
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1342
wsptr[8*9] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1343
wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1344
wsptr[8*8] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1345
wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1346
wsptr[8*7] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1347
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1348
wsptr[8*6] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1349
wsptr[8*5] = (int) RIGHT_SHIFT(tmp25, CONST_BITS-PASS1_BITS);
1350
}
1351
1352
/* Pass 2: process 11 rows from work array, store into output array. */
1353
1354
wsptr = workspace;
1355
for (ctr = 0; ctr < 11; ctr++) {
1356
outptr = output_buf[ctr] + output_col;
1357
1358
/* Even part */
1359
1360
/* Add fudge factor here for final descale. */
1361
tmp10 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1362
tmp10 <<= CONST_BITS;
1363
1364
z1 = (INT32) wsptr[2];
1365
z2 = (INT32) wsptr[4];
1366
z3 = (INT32) wsptr[6];
1367
1368
tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132)); /* c2+c4 */
1369
tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045)); /* c2-c6 */
1370
z4 = z1 + z3;
1371
tmp24 = MULTIPLY(z4, - FIX(1.155664402)); /* -(c2-c10) */
1372
z4 -= z2;
1373
tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976)); /* c2 */
1374
tmp21 = tmp20 + tmp23 + tmp25 -
1375
MULTIPLY(z2, FIX(1.821790775)); /* c2+c4+c10-c6 */
1376
tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
1377
tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
1378
tmp24 += tmp25;
1379
tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120)); /* c8+c10 */
1380
tmp24 += MULTIPLY(z2, FIX(1.944413522)) - /* c2+c8 */
1381
MULTIPLY(z1, FIX(1.390975730)); /* c4+c10 */
1382
tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562)); /* c0 */
1383
1384
/* Odd part */
1385
1386
z1 = (INT32) wsptr[1];
1387
z2 = (INT32) wsptr[3];
1388
z3 = (INT32) wsptr[5];
1389
z4 = (INT32) wsptr[7];
1390
1391
tmp11 = z1 + z2;
1392
tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
1393
tmp11 = MULTIPLY(tmp11, FIX(0.887983902)); /* c3-c9 */
1394
tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295)); /* c5-c9 */
1395
tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
1396
tmp10 = tmp11 + tmp12 + tmp13 -
1397
MULTIPLY(z1, FIX(0.923107866)); /* c7+c5+c3-c1-2*c9 */
1398
z1 = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
1399
tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588)); /* c1+c7+3*c9-c3 */
1400
tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623)); /* c3+c5-c7-c9 */
1401
z1 = MULTIPLY(z2 + z4, - FIX(1.798248910)); /* -(c1+c9) */
1402
tmp11 += z1;
1403
tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632)); /* c1+c5+c9-c7 */
1404
tmp14 += MULTIPLY(z2, - FIX(1.467221301)) + /* -(c5+c9) */
1405
MULTIPLY(z3, FIX(1.001388905)) - /* c1-c9 */
1406
MULTIPLY(z4, FIX(1.684843907)); /* c3+c9 */
1407
1408
/* Final output stage */
1409
1410
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1411
CONST_BITS+PASS1_BITS+3)
1412
& RANGE_MASK];
1413
outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1414
CONST_BITS+PASS1_BITS+3)
1415
& RANGE_MASK];
1416
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1417
CONST_BITS+PASS1_BITS+3)
1418
& RANGE_MASK];
1419
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1420
CONST_BITS+PASS1_BITS+3)
1421
& RANGE_MASK];
1422
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1423
CONST_BITS+PASS1_BITS+3)
1424
& RANGE_MASK];
1425
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1426
CONST_BITS+PASS1_BITS+3)
1427
& RANGE_MASK];
1428
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1429
CONST_BITS+PASS1_BITS+3)
1430
& RANGE_MASK];
1431
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1432
CONST_BITS+PASS1_BITS+3)
1433
& RANGE_MASK];
1434
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1435
CONST_BITS+PASS1_BITS+3)
1436
& RANGE_MASK];
1437
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1438
CONST_BITS+PASS1_BITS+3)
1439
& RANGE_MASK];
1440
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp25,
1441
CONST_BITS+PASS1_BITS+3)
1442
& RANGE_MASK];
1443
1444
wsptr += 8; /* advance pointer to next row */
1445
}
1446
}
1447
1448
1449
/*
1450
* Perform dequantization and inverse DCT on one block of coefficients,
1451
* producing a 12x12 output block.
1452
*
1453
* Optimized algorithm with 15 multiplications in the 1-D kernel.
1454
* cK represents sqrt(2) * cos(K*pi/24).
1455
*/
1456
1457
GLOBAL(void)
1458
jpeg_idct_12x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1459
JCOEFPTR coef_block,
1460
JSAMPARRAY output_buf, JDIMENSION output_col)
1461
{
1462
INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1463
INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
1464
INT32 z1, z2, z3, z4;
1465
JCOEFPTR inptr;
1466
ISLOW_MULT_TYPE * quantptr;
1467
int * wsptr;
1468
JSAMPROW outptr;
1469
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1470
int ctr;
1471
int workspace[8*12]; /* buffers data between passes */
1472
SHIFT_TEMPS
1473
1474
/* Pass 1: process columns from input, store into work array. */
1475
1476
inptr = coef_block;
1477
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1478
wsptr = workspace;
1479
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1480
/* Even part */
1481
1482
z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1483
z3 <<= CONST_BITS;
1484
/* Add fudge factor here for final descale. */
1485
z3 += ONE << (CONST_BITS-PASS1_BITS-1);
1486
1487
z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1488
z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
1489
1490
tmp10 = z3 + z4;
1491
tmp11 = z3 - z4;
1492
1493
z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1494
z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
1495
z1 <<= CONST_BITS;
1496
z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1497
z2 <<= CONST_BITS;
1498
1499
tmp12 = z1 - z2;
1500
1501
tmp21 = z3 + tmp12;
1502
tmp24 = z3 - tmp12;
1503
1504
tmp12 = z4 + z2;
1505
1506
tmp20 = tmp10 + tmp12;
1507
tmp25 = tmp10 - tmp12;
1508
1509
tmp12 = z4 - z1 - z2;
1510
1511
tmp22 = tmp11 + tmp12;
1512
tmp23 = tmp11 - tmp12;
1513
1514
/* Odd part */
1515
1516
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1517
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1518
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1519
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1520
1521
tmp11 = MULTIPLY(z2, FIX(1.306562965)); /* c3 */
1522
tmp14 = MULTIPLY(z2, - FIX_0_541196100); /* -c9 */
1523
1524
tmp10 = z1 + z3;
1525
tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669)); /* c7 */
1526
tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384)); /* c5-c7 */
1527
tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716)); /* c1-c5 */
1528
tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580)); /* -(c7+c11) */
1529
tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
1530
tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
1531
tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) - /* c7-c11 */
1532
MULTIPLY(z4, FIX(1.982889723)); /* c5+c7 */
1533
1534
z1 -= z4;
1535
z2 -= z3;
1536
z3 = MULTIPLY(z1 + z2, FIX_0_541196100); /* c9 */
1537
tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865); /* c3-c9 */
1538
tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065); /* c3+c9 */
1539
1540
/* Final output stage */
1541
1542
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1543
wsptr[8*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1544
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1545
wsptr[8*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1546
wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1547
wsptr[8*9] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1548
wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1549
wsptr[8*8] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1550
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1551
wsptr[8*7] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1552
wsptr[8*5] = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1553
wsptr[8*6] = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
1554
}
1555
1556
/* Pass 2: process 12 rows from work array, store into output array. */
1557
1558
wsptr = workspace;
1559
for (ctr = 0; ctr < 12; ctr++) {
1560
outptr = output_buf[ctr] + output_col;
1561
1562
/* Even part */
1563
1564
/* Add fudge factor here for final descale. */
1565
z3 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1566
z3 <<= CONST_BITS;
1567
1568
z4 = (INT32) wsptr[4];
1569
z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
1570
1571
tmp10 = z3 + z4;
1572
tmp11 = z3 - z4;
1573
1574
z1 = (INT32) wsptr[2];
1575
z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
1576
z1 <<= CONST_BITS;
1577
z2 = (INT32) wsptr[6];
1578
z2 <<= CONST_BITS;
1579
1580
tmp12 = z1 - z2;
1581
1582
tmp21 = z3 + tmp12;
1583
tmp24 = z3 - tmp12;
1584
1585
tmp12 = z4 + z2;
1586
1587
tmp20 = tmp10 + tmp12;
1588
tmp25 = tmp10 - tmp12;
1589
1590
tmp12 = z4 - z1 - z2;
1591
1592
tmp22 = tmp11 + tmp12;
1593
tmp23 = tmp11 - tmp12;
1594
1595
/* Odd part */
1596
1597
z1 = (INT32) wsptr[1];
1598
z2 = (INT32) wsptr[3];
1599
z3 = (INT32) wsptr[5];
1600
z4 = (INT32) wsptr[7];
1601
1602
tmp11 = MULTIPLY(z2, FIX(1.306562965)); /* c3 */
1603
tmp14 = MULTIPLY(z2, - FIX_0_541196100); /* -c9 */
1604
1605
tmp10 = z1 + z3;
1606
tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669)); /* c7 */
1607
tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384)); /* c5-c7 */
1608
tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716)); /* c1-c5 */
1609
tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580)); /* -(c7+c11) */
1610
tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
1611
tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
1612
tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) - /* c7-c11 */
1613
MULTIPLY(z4, FIX(1.982889723)); /* c5+c7 */
1614
1615
z1 -= z4;
1616
z2 -= z3;
1617
z3 = MULTIPLY(z1 + z2, FIX_0_541196100); /* c9 */
1618
tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865); /* c3-c9 */
1619
tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065); /* c3+c9 */
1620
1621
/* Final output stage */
1622
1623
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1624
CONST_BITS+PASS1_BITS+3)
1625
& RANGE_MASK];
1626
outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1627
CONST_BITS+PASS1_BITS+3)
1628
& RANGE_MASK];
1629
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1630
CONST_BITS+PASS1_BITS+3)
1631
& RANGE_MASK];
1632
outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1633
CONST_BITS+PASS1_BITS+3)
1634
& RANGE_MASK];
1635
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1636
CONST_BITS+PASS1_BITS+3)
1637
& RANGE_MASK];
1638
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1639
CONST_BITS+PASS1_BITS+3)
1640
& RANGE_MASK];
1641
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1642
CONST_BITS+PASS1_BITS+3)
1643
& RANGE_MASK];
1644
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1645
CONST_BITS+PASS1_BITS+3)
1646
& RANGE_MASK];
1647
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1648
CONST_BITS+PASS1_BITS+3)
1649
& RANGE_MASK];
1650
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1651
CONST_BITS+PASS1_BITS+3)
1652
& RANGE_MASK];
1653
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
1654
CONST_BITS+PASS1_BITS+3)
1655
& RANGE_MASK];
1656
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
1657
CONST_BITS+PASS1_BITS+3)
1658
& RANGE_MASK];
1659
1660
wsptr += 8; /* advance pointer to next row */
1661
}
1662
}
1663
1664
1665
/*
1666
* Perform dequantization and inverse DCT on one block of coefficients,
1667
* producing a 13x13 output block.
1668
*
1669
* Optimized algorithm with 29 multiplications in the 1-D kernel.
1670
* cK represents sqrt(2) * cos(K*pi/26).
1671
*/
1672
1673
GLOBAL(void)
1674
jpeg_idct_13x13 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1675
JCOEFPTR coef_block,
1676
JSAMPARRAY output_buf, JDIMENSION output_col)
1677
{
1678
INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1679
INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
1680
INT32 z1, z2, z3, z4;
1681
JCOEFPTR inptr;
1682
ISLOW_MULT_TYPE * quantptr;
1683
int * wsptr;
1684
JSAMPROW outptr;
1685
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1686
int ctr;
1687
int workspace[8*13]; /* buffers data between passes */
1688
SHIFT_TEMPS
1689
1690
/* Pass 1: process columns from input, store into work array. */
1691
1692
inptr = coef_block;
1693
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1694
wsptr = workspace;
1695
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1696
/* Even part */
1697
1698
z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1699
z1 <<= CONST_BITS;
1700
/* Add fudge factor here for final descale. */
1701
z1 += ONE << (CONST_BITS-PASS1_BITS-1);
1702
1703
z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1704
z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1705
z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1706
1707
tmp10 = z3 + z4;
1708
tmp11 = z3 - z4;
1709
1710
tmp12 = MULTIPLY(tmp10, FIX(1.155388986)); /* (c4+c6)/2 */
1711
tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1; /* (c4-c6)/2 */
1712
1713
tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13; /* c2 */
1714
tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13; /* c10 */
1715
1716
tmp12 = MULTIPLY(tmp10, FIX(0.316450131)); /* (c8-c12)/2 */
1717
tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1; /* (c8+c12)/2 */
1718
1719
tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13; /* c6 */
1720
tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
1721
1722
tmp12 = MULTIPLY(tmp10, FIX(0.435816023)); /* (c2-c10)/2 */
1723
tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1; /* (c2+c10)/2 */
1724
1725
tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
1726
tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
1727
1728
tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1; /* c0 */
1729
1730
/* Odd part */
1731
1732
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1733
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1734
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1735
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1736
1737
tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651)); /* c3 */
1738
tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945)); /* c5 */
1739
tmp15 = z1 + z4;
1740
tmp13 = MULTIPLY(tmp15, FIX(0.937797057)); /* c7 */
1741
tmp10 = tmp11 + tmp12 + tmp13 -
1742
MULTIPLY(z1, FIX(2.020082300)); /* c7+c5+c3-c1 */
1743
tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458)); /* -c11 */
1744
tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
1745
tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
1746
tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945)); /* -c5 */
1747
tmp11 += tmp14;
1748
tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
1749
tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813)); /* -c9 */
1750
tmp12 += tmp14;
1751
tmp13 += tmp14;
1752
tmp15 = MULTIPLY(tmp15, FIX(0.338443458)); /* c11 */
1753
tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
1754
MULTIPLY(z2, FIX(0.466105296)); /* c1-c7 */
1755
z1 = MULTIPLY(z3 - z2, FIX(0.937797057)); /* c7 */
1756
tmp14 += z1;
1757
tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) - /* c3-c7 */
1758
MULTIPLY(z4, FIX(1.742345811)); /* c1+c11 */
1759
1760
/* Final output stage */
1761
1762
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1763
wsptr[8*12] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1764
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1765
wsptr[8*11] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1766
wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1767
wsptr[8*10] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1768
wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1769
wsptr[8*9] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1770
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1771
wsptr[8*8] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1772
wsptr[8*5] = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1773
wsptr[8*7] = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
1774
wsptr[8*6] = (int) RIGHT_SHIFT(tmp26, CONST_BITS-PASS1_BITS);
1775
}
1776
1777
/* Pass 2: process 13 rows from work array, store into output array. */
1778
1779
wsptr = workspace;
1780
for (ctr = 0; ctr < 13; ctr++) {
1781
outptr = output_buf[ctr] + output_col;
1782
1783
/* Even part */
1784
1785
/* Add fudge factor here for final descale. */
1786
z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
1787
z1 <<= CONST_BITS;
1788
1789
z2 = (INT32) wsptr[2];
1790
z3 = (INT32) wsptr[4];
1791
z4 = (INT32) wsptr[6];
1792
1793
tmp10 = z3 + z4;
1794
tmp11 = z3 - z4;
1795
1796
tmp12 = MULTIPLY(tmp10, FIX(1.155388986)); /* (c4+c6)/2 */
1797
tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1; /* (c4-c6)/2 */
1798
1799
tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13; /* c2 */
1800
tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13; /* c10 */
1801
1802
tmp12 = MULTIPLY(tmp10, FIX(0.316450131)); /* (c8-c12)/2 */
1803
tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1; /* (c8+c12)/2 */
1804
1805
tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13; /* c6 */
1806
tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
1807
1808
tmp12 = MULTIPLY(tmp10, FIX(0.435816023)); /* (c2-c10)/2 */
1809
tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1; /* (c2+c10)/2 */
1810
1811
tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
1812
tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
1813
1814
tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1; /* c0 */
1815
1816
/* Odd part */
1817
1818
z1 = (INT32) wsptr[1];
1819
z2 = (INT32) wsptr[3];
1820
z3 = (INT32) wsptr[5];
1821
z4 = (INT32) wsptr[7];
1822
1823
tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651)); /* c3 */
1824
tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945)); /* c5 */
1825
tmp15 = z1 + z4;
1826
tmp13 = MULTIPLY(tmp15, FIX(0.937797057)); /* c7 */
1827
tmp10 = tmp11 + tmp12 + tmp13 -
1828
MULTIPLY(z1, FIX(2.020082300)); /* c7+c5+c3-c1 */
1829
tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458)); /* -c11 */
1830
tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
1831
tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
1832
tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945)); /* -c5 */
1833
tmp11 += tmp14;
1834
tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
1835
tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813)); /* -c9 */
1836
tmp12 += tmp14;
1837
tmp13 += tmp14;
1838
tmp15 = MULTIPLY(tmp15, FIX(0.338443458)); /* c11 */
1839
tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
1840
MULTIPLY(z2, FIX(0.466105296)); /* c1-c7 */
1841
z1 = MULTIPLY(z3 - z2, FIX(0.937797057)); /* c7 */
1842
tmp14 += z1;
1843
tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) - /* c3-c7 */
1844
MULTIPLY(z4, FIX(1.742345811)); /* c1+c11 */
1845
1846
/* Final output stage */
1847
1848
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1849
CONST_BITS+PASS1_BITS+3)
1850
& RANGE_MASK];
1851
outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1852
CONST_BITS+PASS1_BITS+3)
1853
& RANGE_MASK];
1854
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1855
CONST_BITS+PASS1_BITS+3)
1856
& RANGE_MASK];
1857
outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1858
CONST_BITS+PASS1_BITS+3)
1859
& RANGE_MASK];
1860
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1861
CONST_BITS+PASS1_BITS+3)
1862
& RANGE_MASK];
1863
outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1864
CONST_BITS+PASS1_BITS+3)
1865
& RANGE_MASK];
1866
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1867
CONST_BITS+PASS1_BITS+3)
1868
& RANGE_MASK];
1869
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1870
CONST_BITS+PASS1_BITS+3)
1871
& RANGE_MASK];
1872
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1873
CONST_BITS+PASS1_BITS+3)
1874
& RANGE_MASK];
1875
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1876
CONST_BITS+PASS1_BITS+3)
1877
& RANGE_MASK];
1878
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
1879
CONST_BITS+PASS1_BITS+3)
1880
& RANGE_MASK];
1881
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
1882
CONST_BITS+PASS1_BITS+3)
1883
& RANGE_MASK];
1884
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp26,
1885
CONST_BITS+PASS1_BITS+3)
1886
& RANGE_MASK];
1887
1888
wsptr += 8; /* advance pointer to next row */
1889
}
1890
}
1891
1892
1893
/*
1894
* Perform dequantization and inverse DCT on one block of coefficients,
1895
* producing a 14x14 output block.
1896
*
1897
* Optimized algorithm with 20 multiplications in the 1-D kernel.
1898
* cK represents sqrt(2) * cos(K*pi/28).
1899
*/
1900
1901
GLOBAL(void)
1902
jpeg_idct_14x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1903
JCOEFPTR coef_block,
1904
JSAMPARRAY output_buf, JDIMENSION output_col)
1905
{
1906
INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
1907
INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
1908
INT32 z1, z2, z3, z4;
1909
JCOEFPTR inptr;
1910
ISLOW_MULT_TYPE * quantptr;
1911
int * wsptr;
1912
JSAMPROW outptr;
1913
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1914
int ctr;
1915
int workspace[8*14]; /* buffers data between passes */
1916
SHIFT_TEMPS
1917
1918
/* Pass 1: process columns from input, store into work array. */
1919
1920
inptr = coef_block;
1921
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1922
wsptr = workspace;
1923
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1924
/* Even part */
1925
1926
z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1927
z1 <<= CONST_BITS;
1928
/* Add fudge factor here for final descale. */
1929
z1 += ONE << (CONST_BITS-PASS1_BITS-1);
1930
z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1931
z2 = MULTIPLY(z4, FIX(1.274162392)); /* c4 */
1932
z3 = MULTIPLY(z4, FIX(0.314692123)); /* c12 */
1933
z4 = MULTIPLY(z4, FIX(0.881747734)); /* c8 */
1934
1935
tmp10 = z1 + z2;
1936
tmp11 = z1 + z3;
1937
tmp12 = z1 - z4;
1938
1939
tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
1940
CONST_BITS-PASS1_BITS);
1941
1942
z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1943
z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1944
1945
z3 = MULTIPLY(z1 + z2, FIX(1.105676686)); /* c6 */
1946
1947
tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
1948
tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
1949
tmp15 = MULTIPLY(z1, FIX(0.613604268)) - /* c10 */
1950
MULTIPLY(z2, FIX(1.378756276)); /* c2 */
1951
1952
tmp20 = tmp10 + tmp13;
1953
tmp26 = tmp10 - tmp13;
1954
tmp21 = tmp11 + tmp14;
1955
tmp25 = tmp11 - tmp14;
1956
tmp22 = tmp12 + tmp15;
1957
tmp24 = tmp12 - tmp15;
1958
1959
/* Odd part */
1960
1961
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1962
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1963
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1964
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1965
tmp13 = z4 << CONST_BITS;
1966
1967
tmp14 = z1 + z3;
1968
tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607)); /* c3 */
1969
tmp12 = MULTIPLY(tmp14, FIX(1.197448846)); /* c5 */
1970
tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
1971
tmp14 = MULTIPLY(tmp14, FIX(0.752406978)); /* c9 */
1972
tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426)); /* c9+c11-c13 */
1973
z1 -= z2;
1974
tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13; /* c11 */
1975
tmp16 += tmp15;
1976
z1 += z4;
1977
z4 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
1978
tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948)); /* c3-c9-c13 */
1979
tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773)); /* c3+c5-c13 */
1980
z4 = MULTIPLY(z3 - z2, FIX(1.405321284)); /* c1 */
1981
tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
1982
tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567)); /* c1+c11-c5 */
1983
1984
tmp13 = (z1 - z3) << PASS1_BITS;
1985
1986
/* Final output stage */
1987
1988
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1989
wsptr[8*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1990
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1991
wsptr[8*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1992
wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1993
wsptr[8*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1994
wsptr[8*3] = (int) (tmp23 + tmp13);
1995
wsptr[8*10] = (int) (tmp23 - tmp13);
1996
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1997
wsptr[8*9] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1998
wsptr[8*5] = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1999
wsptr[8*8] = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
2000
wsptr[8*6] = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
2001
wsptr[8*7] = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
2002
}
2003
2004
/* Pass 2: process 14 rows from work array, store into output array. */
2005
2006
wsptr = workspace;
2007
for (ctr = 0; ctr < 14; ctr++) {
2008
outptr = output_buf[ctr] + output_col;
2009
2010
/* Even part */
2011
2012
/* Add fudge factor here for final descale. */
2013
z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2014
z1 <<= CONST_BITS;
2015
z4 = (INT32) wsptr[4];
2016
z2 = MULTIPLY(z4, FIX(1.274162392)); /* c4 */
2017
z3 = MULTIPLY(z4, FIX(0.314692123)); /* c12 */
2018
z4 = MULTIPLY(z4, FIX(0.881747734)); /* c8 */
2019
2020
tmp10 = z1 + z2;
2021
tmp11 = z1 + z3;
2022
tmp12 = z1 - z4;
2023
2024
tmp23 = z1 - ((z2 + z3 - z4) << 1); /* c0 = (c4+c12-c8)*2 */
2025
2026
z1 = (INT32) wsptr[2];
2027
z2 = (INT32) wsptr[6];
2028
2029
z3 = MULTIPLY(z1 + z2, FIX(1.105676686)); /* c6 */
2030
2031
tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
2032
tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
2033
tmp15 = MULTIPLY(z1, FIX(0.613604268)) - /* c10 */
2034
MULTIPLY(z2, FIX(1.378756276)); /* c2 */
2035
2036
tmp20 = tmp10 + tmp13;
2037
tmp26 = tmp10 - tmp13;
2038
tmp21 = tmp11 + tmp14;
2039
tmp25 = tmp11 - tmp14;
2040
tmp22 = tmp12 + tmp15;
2041
tmp24 = tmp12 - tmp15;
2042
2043
/* Odd part */
2044
2045
z1 = (INT32) wsptr[1];
2046
z2 = (INT32) wsptr[3];
2047
z3 = (INT32) wsptr[5];
2048
z4 = (INT32) wsptr[7];
2049
z4 <<= CONST_BITS;
2050
2051
tmp14 = z1 + z3;
2052
tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607)); /* c3 */
2053
tmp12 = MULTIPLY(tmp14, FIX(1.197448846)); /* c5 */
2054
tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
2055
tmp14 = MULTIPLY(tmp14, FIX(0.752406978)); /* c9 */
2056
tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426)); /* c9+c11-c13 */
2057
z1 -= z2;
2058
tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4; /* c11 */
2059
tmp16 += tmp15;
2060
tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4; /* -c13 */
2061
tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948)); /* c3-c9-c13 */
2062
tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773)); /* c3+c5-c13 */
2063
tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284)); /* c1 */
2064
tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
2065
tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567)); /* c1+c11-c5 */
2066
2067
tmp13 = ((z1 - z3) << CONST_BITS) + z4;
2068
2069
/* Final output stage */
2070
2071
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2072
CONST_BITS+PASS1_BITS+3)
2073
& RANGE_MASK];
2074
outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2075
CONST_BITS+PASS1_BITS+3)
2076
& RANGE_MASK];
2077
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2078
CONST_BITS+PASS1_BITS+3)
2079
& RANGE_MASK];
2080
outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2081
CONST_BITS+PASS1_BITS+3)
2082
& RANGE_MASK];
2083
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2084
CONST_BITS+PASS1_BITS+3)
2085
& RANGE_MASK];
2086
outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2087
CONST_BITS+PASS1_BITS+3)
2088
& RANGE_MASK];
2089
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2090
CONST_BITS+PASS1_BITS+3)
2091
& RANGE_MASK];
2092
outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2093
CONST_BITS+PASS1_BITS+3)
2094
& RANGE_MASK];
2095
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2096
CONST_BITS+PASS1_BITS+3)
2097
& RANGE_MASK];
2098
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2099
CONST_BITS+PASS1_BITS+3)
2100
& RANGE_MASK];
2101
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2102
CONST_BITS+PASS1_BITS+3)
2103
& RANGE_MASK];
2104
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2105
CONST_BITS+PASS1_BITS+3)
2106
& RANGE_MASK];
2107
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
2108
CONST_BITS+PASS1_BITS+3)
2109
& RANGE_MASK];
2110
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
2111
CONST_BITS+PASS1_BITS+3)
2112
& RANGE_MASK];
2113
2114
wsptr += 8; /* advance pointer to next row */
2115
}
2116
}
2117
2118
2119
/*
2120
* Perform dequantization and inverse DCT on one block of coefficients,
2121
* producing a 15x15 output block.
2122
*
2123
* Optimized algorithm with 22 multiplications in the 1-D kernel.
2124
* cK represents sqrt(2) * cos(K*pi/30).
2125
*/
2126
2127
GLOBAL(void)
2128
jpeg_idct_15x15 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2129
JCOEFPTR coef_block,
2130
JSAMPARRAY output_buf, JDIMENSION output_col)
2131
{
2132
INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2133
INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2134
INT32 z1, z2, z3, z4;
2135
JCOEFPTR inptr;
2136
ISLOW_MULT_TYPE * quantptr;
2137
int * wsptr;
2138
JSAMPROW outptr;
2139
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2140
int ctr;
2141
int workspace[8*15]; /* buffers data between passes */
2142
SHIFT_TEMPS
2143
2144
/* Pass 1: process columns from input, store into work array. */
2145
2146
inptr = coef_block;
2147
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2148
wsptr = workspace;
2149
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2150
/* Even part */
2151
2152
z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2153
z1 <<= CONST_BITS;
2154
/* Add fudge factor here for final descale. */
2155
z1 += ONE << (CONST_BITS-PASS1_BITS-1);
2156
2157
z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2158
z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2159
z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2160
2161
tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
2162
tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
2163
2164
tmp12 = z1 - tmp10;
2165
tmp13 = z1 + tmp11;
2166
z1 -= (tmp11 - tmp10) << 1; /* c0 = (c6-c12)*2 */
2167
2168
z4 = z2 - z3;
2169
z3 += z2;
2170
tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
2171
tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
2172
z2 = MULTIPLY(z2, FIX(1.439773946)); /* c4+c14 */
2173
2174
tmp20 = tmp13 + tmp10 + tmp11;
2175
tmp23 = tmp12 - tmp10 + tmp11 + z2;
2176
2177
tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
2178
tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
2179
2180
tmp25 = tmp13 - tmp10 - tmp11;
2181
tmp26 = tmp12 + tmp10 - tmp11 - z2;
2182
2183
tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
2184
tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
2185
2186
tmp21 = tmp12 + tmp10 + tmp11;
2187
tmp24 = tmp13 - tmp10 + tmp11;
2188
tmp11 += tmp11;
2189
tmp22 = z1 + tmp11; /* c10 = c6-c12 */
2190
tmp27 = z1 - tmp11 - tmp11; /* c0 = (c6-c12)*2 */
2191
2192
/* Odd part */
2193
2194
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2195
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2196
z4 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2197
z3 = MULTIPLY(z4, FIX(1.224744871)); /* c5 */
2198
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2199
2200
tmp13 = z2 - z4;
2201
tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876)); /* c9 */
2202
tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148)); /* c3-c9 */
2203
tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899)); /* c3+c9 */
2204
2205
tmp13 = MULTIPLY(z2, - FIX(0.831253876)); /* -c9 */
2206
tmp15 = MULTIPLY(z2, - FIX(1.344997024)); /* -c3 */
2207
z2 = z1 - z4;
2208
tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353)); /* c1 */
2209
2210
tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
2211
tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
2212
tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3; /* c5 */
2213
z2 = MULTIPLY(z1 + z4, FIX(0.575212477)); /* c11 */
2214
tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3; /* c7-c11 */
2215
tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3; /* c11+c13 */
2216
2217
/* Final output stage */
2218
2219
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
2220
wsptr[8*14] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
2221
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
2222
wsptr[8*13] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
2223
wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
2224
wsptr[8*12] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
2225
wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
2226
wsptr[8*11] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
2227
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
2228
wsptr[8*10] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
2229
wsptr[8*5] = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
2230
wsptr[8*9] = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
2231
wsptr[8*6] = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
2232
wsptr[8*8] = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
2233
wsptr[8*7] = (int) RIGHT_SHIFT(tmp27, CONST_BITS-PASS1_BITS);
2234
}
2235
2236
/* Pass 2: process 15 rows from work array, store into output array. */
2237
2238
wsptr = workspace;
2239
for (ctr = 0; ctr < 15; ctr++) {
2240
outptr = output_buf[ctr] + output_col;
2241
2242
/* Even part */
2243
2244
/* Add fudge factor here for final descale. */
2245
z1 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2246
z1 <<= CONST_BITS;
2247
2248
z2 = (INT32) wsptr[2];
2249
z3 = (INT32) wsptr[4];
2250
z4 = (INT32) wsptr[6];
2251
2252
tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
2253
tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
2254
2255
tmp12 = z1 - tmp10;
2256
tmp13 = z1 + tmp11;
2257
z1 -= (tmp11 - tmp10) << 1; /* c0 = (c6-c12)*2 */
2258
2259
z4 = z2 - z3;
2260
z3 += z2;
2261
tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
2262
tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
2263
z2 = MULTIPLY(z2, FIX(1.439773946)); /* c4+c14 */
2264
2265
tmp20 = tmp13 + tmp10 + tmp11;
2266
tmp23 = tmp12 - tmp10 + tmp11 + z2;
2267
2268
tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
2269
tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
2270
2271
tmp25 = tmp13 - tmp10 - tmp11;
2272
tmp26 = tmp12 + tmp10 - tmp11 - z2;
2273
2274
tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
2275
tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
2276
2277
tmp21 = tmp12 + tmp10 + tmp11;
2278
tmp24 = tmp13 - tmp10 + tmp11;
2279
tmp11 += tmp11;
2280
tmp22 = z1 + tmp11; /* c10 = c6-c12 */
2281
tmp27 = z1 - tmp11 - tmp11; /* c0 = (c6-c12)*2 */
2282
2283
/* Odd part */
2284
2285
z1 = (INT32) wsptr[1];
2286
z2 = (INT32) wsptr[3];
2287
z4 = (INT32) wsptr[5];
2288
z3 = MULTIPLY(z4, FIX(1.224744871)); /* c5 */
2289
z4 = (INT32) wsptr[7];
2290
2291
tmp13 = z2 - z4;
2292
tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876)); /* c9 */
2293
tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148)); /* c3-c9 */
2294
tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899)); /* c3+c9 */
2295
2296
tmp13 = MULTIPLY(z2, - FIX(0.831253876)); /* -c9 */
2297
tmp15 = MULTIPLY(z2, - FIX(1.344997024)); /* -c3 */
2298
z2 = z1 - z4;
2299
tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353)); /* c1 */
2300
2301
tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
2302
tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
2303
tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3; /* c5 */
2304
z2 = MULTIPLY(z1 + z4, FIX(0.575212477)); /* c11 */
2305
tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3; /* c7-c11 */
2306
tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3; /* c11+c13 */
2307
2308
/* Final output stage */
2309
2310
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2311
CONST_BITS+PASS1_BITS+3)
2312
& RANGE_MASK];
2313
outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2314
CONST_BITS+PASS1_BITS+3)
2315
& RANGE_MASK];
2316
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2317
CONST_BITS+PASS1_BITS+3)
2318
& RANGE_MASK];
2319
outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2320
CONST_BITS+PASS1_BITS+3)
2321
& RANGE_MASK];
2322
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2323
CONST_BITS+PASS1_BITS+3)
2324
& RANGE_MASK];
2325
outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2326
CONST_BITS+PASS1_BITS+3)
2327
& RANGE_MASK];
2328
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2329
CONST_BITS+PASS1_BITS+3)
2330
& RANGE_MASK];
2331
outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2332
CONST_BITS+PASS1_BITS+3)
2333
& RANGE_MASK];
2334
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2335
CONST_BITS+PASS1_BITS+3)
2336
& RANGE_MASK];
2337
outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2338
CONST_BITS+PASS1_BITS+3)
2339
& RANGE_MASK];
2340
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2341
CONST_BITS+PASS1_BITS+3)
2342
& RANGE_MASK];
2343
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2344
CONST_BITS+PASS1_BITS+3)
2345
& RANGE_MASK];
2346
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
2347
CONST_BITS+PASS1_BITS+3)
2348
& RANGE_MASK];
2349
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
2350
CONST_BITS+PASS1_BITS+3)
2351
& RANGE_MASK];
2352
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp27,
2353
CONST_BITS+PASS1_BITS+3)
2354
& RANGE_MASK];
2355
2356
wsptr += 8; /* advance pointer to next row */
2357
}
2358
}
2359
2360
2361
/*
2362
* Perform dequantization and inverse DCT on one block of coefficients,
2363
* producing a 16x16 output block.
2364
*
2365
* Optimized algorithm with 28 multiplications in the 1-D kernel.
2366
* cK represents sqrt(2) * cos(K*pi/32).
2367
*/
2368
2369
GLOBAL(void)
2370
jpeg_idct_16x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2371
JCOEFPTR coef_block,
2372
JSAMPARRAY output_buf, JDIMENSION output_col)
2373
{
2374
INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
2375
INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2376
INT32 z1, z2, z3, z4;
2377
JCOEFPTR inptr;
2378
ISLOW_MULT_TYPE * quantptr;
2379
int * wsptr;
2380
JSAMPROW outptr;
2381
JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2382
int ctr;
2383
int workspace[8*16]; /* buffers data between passes */
2384
SHIFT_TEMPS
2385
2386
/* Pass 1: process columns from input, store into work array. */
2387
2388
inptr = coef_block;
2389
quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2390
wsptr = workspace;
2391
for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2392
/* Even part */
2393
2394
tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2395
tmp0 <<= CONST_BITS;
2396
/* Add fudge factor here for final descale. */
2397
tmp0 += 1 << (CONST_BITS-PASS1_BITS-1);
2398
2399
z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2400
tmp1 = MULTIPLY(z1, FIX(1.306562965)); /* c4[16] = c2[8] */
2401
tmp2 = MULTIPLY(z1, FIX_0_541196100); /* c12[16] = c6[8] */
2402
2403
tmp10 = tmp0 + tmp1;
2404
tmp11 = tmp0 - tmp1;
2405
tmp12 = tmp0 + tmp2;
2406
tmp13 = tmp0 - tmp2;
2407
2408
z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2409
z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2410
z3 = z1 - z2;
2411
z4 = MULTIPLY(z3, FIX(0.275899379)); /* c14[16] = c7[8] */
2412
z3 = MULTIPLY(z3, FIX(1.387039845)); /* c2[16] = c1[8] */
2413
2414
tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447); /* (c6+c2)[16] = (c3+c1)[8] */
2415
tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223); /* (c6-c14)[16] = (c3-c7)[8] */
2416
tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2417
tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2418
2419
tmp20 = tmp10 + tmp0;
2420
tmp27 = tmp10 - tmp0;
2421
tmp21 = tmp12 + tmp1;
2422
tmp26 = tmp12 - tmp1;
2423
tmp22 = tmp13 + tmp2;
2424
tmp25 = tmp13 - tmp2;
2425
tmp23 = tmp11 + tmp3;
2426
tmp24 = tmp11 - tmp3;
2427
2428
/* Odd part */
2429
2430
z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2431
z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2432
z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2433
z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2434
2435
tmp11 = z1 + z3;
2436
2437
tmp1 = MULTIPLY(z1 + z2, FIX(1.353318001)); /* c3 */
2438
tmp2 = MULTIPLY(tmp11, FIX(1.247225013)); /* c5 */
2439
tmp3 = MULTIPLY(z1 + z4, FIX(1.093201867)); /* c7 */
2440
tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586)); /* c9 */
2441
tmp11 = MULTIPLY(tmp11, FIX(0.666655658)); /* c11 */
2442
tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528)); /* c13 */
2443
tmp0 = tmp1 + tmp2 + tmp3 -
2444
MULTIPLY(z1, FIX(2.286341144)); /* c7+c5+c3-c1 */
2445
tmp13 = tmp10 + tmp11 + tmp12 -
2446
MULTIPLY(z1, FIX(1.835730603)); /* c9+c11+c13-c15 */
2447
z1 = MULTIPLY(z2 + z3, FIX(0.138617169)); /* c15 */
2448
tmp1 += z1 + MULTIPLY(z2, FIX(0.071888074)); /* c9+c11-c3-c15 */
2449
tmp2 += z1 - MULTIPLY(z3, FIX(1.125726048)); /* c5+c7+c15-c3 */
2450
z1 = MULTIPLY(z3 - z2, FIX(1.407403738)); /* c1 */
2451
tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282)); /* c1+c11-c9-c13 */
2452
tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411)); /* c1+c5+c13-c7 */
2453
z2 += z4;
2454
z1 = MULTIPLY(z2, - FIX(0.666655658)); /* -c11 */
2455
tmp1 += z1;
2456
tmp3 += z1 + MULTIPLY(z4, FIX(1.065388962)); /* c3+c11+c15-c7 */
2457
z2 = MULTIPLY(z2, - FIX(1.247225013)); /* -c5 */
2458
tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809)); /* c1+c5+c9-c13 */
2459
tmp12 += z2;
2460
z2 = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
2461
tmp2 += z2;
2462
tmp3 += z2;
2463
z2 = MULTIPLY(z4 - z3, FIX(0.410524528)); /* c13 */
2464
tmp10 += z2;
2465
tmp11 += z2;
2466
2467
/* Final output stage */
2468
2469
wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp0, CONST_BITS-PASS1_BITS);
2470
wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0, CONST_BITS-PASS1_BITS);
2471
wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp1, CONST_BITS-PASS1_BITS);
2472
wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1, CONST_BITS-PASS1_BITS);
2473
wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp2, CONST_BITS-PASS1_BITS);
2474
wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2, CONST_BITS-PASS1_BITS);
2475
wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp3, CONST_BITS-PASS1_BITS);
2476
wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3, CONST_BITS-PASS1_BITS);
2477
wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
2478
wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
2479
wsptr[8*5] = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
2480
wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
2481
wsptr[8*6] = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
2482
wsptr[8*9] = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
2483
wsptr[8*7] = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
2484
wsptr[8*8] = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
2485
}
2486
2487
/* Pass 2: process 16 rows from work array, store into output array. */
2488
2489
wsptr = workspace;
2490
for (ctr = 0; ctr < 16; ctr++) {
2491
outptr = output_buf[ctr] + output_col;
2492
2493
/* Even part */
2494
2495
/* Add fudge factor here for final descale. */
2496
tmp0 = (INT32) wsptr[0] + (ONE << (PASS1_BITS+2));
2497
tmp0 <<= CONST_BITS;
2498
2499
z1 = (INT32) wsptr[4];
2500
tmp1 = MULTIPLY(z1, FIX(1.306562965)); /* c4[16] = c2[8] */
2501
tmp2 = MULTIPLY(z1, FIX_0_541196100); /* c12[16] = c6[8] */
2502
2503
tmp10 = tmp0 + tmp1;
2504
tmp11 = tmp0 - tmp1;
2505
tmp12 = tmp0 + tmp2;
2506
tmp13 = tmp0 - tmp2;
2507
2508
z1 = (INT32) wsptr[2];
2509
z2 = (INT32) wsptr[6];
2510
z3 = z1 - z2;
2511
z4 = MULTIPLY(z3, FIX(0.275899379)); /* c14[16] = c7[8] */
2512
z3 = MULTIPLY(z3, FIX(1.387039845)); /* c2[16] = c1[8] */
2513
2514
tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447); /* (c6+c2)[16] = (c3+c1)[8] */
2515
tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223); /* (c6-c14)[16] = (c3-c7)[8] */
2516
tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2517
tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2518
2519
tmp20 = tmp10 + tmp0;
2520
tmp27 = tmp10 - tmp0;
2521
tmp21 = tmp12 + tmp1;
2522
tmp26 = tmp12 - tmp1;
2523
tmp22 = tmp13 + tmp2;
2524
tmp25 = tmp13 - tmp2;
2525
tmp23 = tmp11 + tmp3;
2526
tmp24 = tmp11 - tmp3;
2527
2528
/* Odd part */
2529
2530
z1 = (INT32) wsptr[1];
2531
z2 = (INT32) wsptr[3];
2532
z3 = (INT32) wsptr[5];
2533
z4 = (INT32) wsptr[7];
2534
2535
tmp11 = z1 + z3;
2536
2537
tmp1 = MULTIPLY(z1 + z2, FIX(1.353318001)); /* c3 */
2538
tmp2 = MULTIPLY(tmp11, FIX(1.247225013)); /* c5 */
2539
tmp3 = MULTIPLY(z1 + z4, FIX(1.093201867)); /* c7 */
2540
tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586)); /* c9 */
2541
tmp11 = MULTIPLY(tmp11, FIX(0.666655658)); /* c11 */
2542
tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528)); /* c13 */
2543
tmp0 = tmp1 + tmp2 + tmp3 -
2544
MULTIPLY(z1, FIX(2.286341144)); /* c7+c5+c3-c1 */
2545
tmp13 = tmp10 + tmp11 + tmp12 -
2546
MULTIPLY(z1, FIX(1.835730603)); /* c9+c11+c13-c15 */
2547
z1 = MULTIPLY(z2 + z3, FIX(0.138617169)); /* c15 */
2548
tmp1 += z1 + MULTIPLY(z2, FIX(0.071888074)); /* c9+c11-c3-c15 */
2549
tmp2 += z1 - MULTIPLY(z3, FIX(1.125726048)); /* c5+c7+c15-c3 */
2550
z1 = MULTIPLY(z3 - z2, FIX(1.407403738)); /* c1 */
2551
tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282)); /* c1+c11-c9-c13 */
2552
tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411)); /* c1+c5+c13-c7 */
2553
z2 += z4;
2554
z1 = MULTIPLY(z2, - FIX(0.666655658)); /* -c11 */
2555
tmp1 += z1;
2556
tmp3 += z1 + MULTIPLY(z4, FIX(1.065388962)); /* c3+c11+c15-c7 */
2557
z2 = MULTIPLY(z2, - FIX(1.247225013)); /* -c5 */
2558
tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809)); /* c1+c5+c9-c13 */
2559
tmp12 += z2;
2560
z2 = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
2561
tmp2 += z2;
2562
tmp3 += z2;
2563
z2 = MULTIPLY(z4 - z3, FIX(0.410524528)); /* c13 */
2564
tmp10 += z2;
2565
tmp11 += z2;
2566
2567
/* Final output stage */
2568
2569
outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
2570
CONST_BITS+PASS1_BITS+3)
2571
& RANGE_MASK];
2572
outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
2573
CONST_BITS+PASS1_BITS+3)
2574
& RANGE_MASK];
2575
outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
2576
CONST_BITS+PASS1_BITS+3)
2577
& RANGE_MASK];
2578
outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
2579
CONST_BITS+PASS1_BITS+3)
2580
& RANGE_MASK];
2581
outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
2582
CONST_BITS+PASS1_BITS+3)
2583
& RANGE_MASK];
2584
outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
2585
CONST_BITS+PASS1_BITS+3)
2586
& RANGE_MASK];
2587
outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
2588
CONST_BITS+PASS1_BITS+3)
2589
& RANGE_MASK];
2590
outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
2591
CONST_BITS+PASS1_BITS+3)
2592
& RANGE_MASK];
2593
outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
2594
CONST_BITS+PASS1_BITS+3)
2595
& RANGE_MASK];
2596
outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
2597
CONST_BITS+PASS1_BITS+3)
2598
& RANGE_MASK];
2599
outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
2600
CONST_BITS+PASS1_BITS+3)
2601
& RANGE_MASK];
2602
outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
2603
CONST_BITS+PASS1_BITS+3)
2604
& RANGE_MASK];
2605
outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
2606
CONST_BITS+PASS1_BITS+3)
2607
& RANGE_MASK];
2608
outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
2609
CONST_BITS+PASS1_BITS+3)
2610
& RANGE_MASK];
2611
outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
2612
CONST_BITS+PASS1_BITS+3)
2613
& RANGE_MASK];
2614
outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
2615
CONST_BITS+PASS1_BITS+3)
2616
& RANGE_MASK];
2617
2618
wsptr += 8; /* advance pointer to next row */
2619
}
2620
}
2621
2622
#endif /* IDCT_SCALING_SUPPORTED */
389
2623
#endif /* DCT_ISLOW_SUPPORTED */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1