[svn] / trunk / xvidcore / src / dct / idct.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/dct/idct.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3, Fri Mar 8 02:46:11 2002 UTC revision 1989, Wed May 18 09:13:52 2011 UTC
# Line 1  Line 1 
1  /* idct.c, inverse fast discrete cosine transform                           */  /*****************************************************************************
   
 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */  
   
 /*  
  * Disclaimer of Warranty  
2   *   *
3   * These software programs are available to the user without any license fee or   *  XVID MPEG-4 VIDEO CODEC
4   * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims   *  - Inverse DCT  -
  * any and all warranties, whether express, implied, or statuary, including any  
  * implied warranties or merchantability or of fitness for a particular  
  * purpose.  In no event shall the copyright-holder be liable for any  
  * incidental, punitive, or consequential damages of any kind whatsoever  
  * arising from the use of these programs.  
5   *   *
6   * This disclaimer of warranty extends to the user of these programs and user's   *  Copyright (C) 2006-2011 Xvid Solutions GmbH
  * customers, employees, agents, transferees, successors, and assigns.  
7   *   *
8   * The MPEG Software Simulation Group does not represent or warrant that the   *  This program is free software ; you can redistribute it and/or modify
9   * programs furnished hereunder are free of infringement of any third-party   *  it under the terms of the GNU General Public License as published by
10   * patents.   *  the Free Software Foundation ; either version 2 of the License, or
11     *  (at your option) any later version.
12   *   *
13   * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,   *  This program is distributed in the hope that it will be useful,
14   * are subject to royalty fees to patent holders.  Many of these patents are   *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
15   * general enough such that they are unavoidable regardless of implementation   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   * design.   *  GNU General Public License for more details.
17   *   *
18   * MPEG2AVI   *  You should have received a copy of the GNU General Public License
19   * --------   *  along with this program ; if not, write to the Free Software
20   * v0.16B33 renamed the initialization function to init_idct_int32()   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  * v0.16B32 removed the unused idct_row() and idct_col() functions  
  * v0.16B3  changed var declarations to static, to enforce data align  
  * v0.16B22  idct_FAST() renamed to idct_int32()  
  *        also merged idct_FAST() into a single function, to help VC++  
  *        optimize it.  
21   *   *
22   * v0.14  changed int to long, to avoid confusion when compiling on x86   * $Id$
23   *        platform ( in VC++ "int" -> 32bits )   *
24   */   ****************************************************************************/
   
 /**********************************************************/  
 /* inverse two dimensional DCT, Chen-Wang algorithm       */  
 /* (cf. IEEE ASSP-32, pp. 803-816, Aug. 1984)             */  
 /* 32-bit integer arithmetic (8 bit coefficients)         */  
 /* 11 mults, 29 adds per DCT                              */  
 /*                                      sE, 18.8.91       */  
 /**********************************************************/  
 /* coefficients extended to 12 bit for IEEE1180-1990      */  
 /* compliance                           sE,  2.1.94       */  
 /**********************************************************/  
25    
26  /* this code assumes >> to be a two's-complement arithmetic */  /*
27  /* right shift: (-2)>>1 == -1 , (-3)>>1 == -2               */   *  Authors: Skal
28     *
29     *  Walken IDCT
30     *  Alternative idct implementations for decoding compatibility
31     *
32     *  NOTE: this "C" version is not the original one,
33     *  but is modified to yield the same error profile
34     *  than the MMX version.
35     *
36     ************************************************************************/
37    
 //#include <windows.h>  
38  #include "idct.h"  #include "idct.h"
39    
40  #define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */  /* function pointer */
41  #define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */  idctFuncPtr idct;
 #define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */  
 #define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */  
 #define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */  
 #define W7 565  /* 2048*sqrt(2)*cos(7*pi/16) */  
   
   
 /* global declarations */  
 //void init_idct_int32 (void);  
 //void idct_int32 (short *block);  
   
 /* private data */  
 static short iclip[1024]; /* clipping table */  
 static short *iclp;  
   
 /* private prototypes */  
 //static void idctrow _ANSI_ARGS_((short *blk));  
 //static void idctcol _ANSI_ARGS_((short *blk));  
42    
43  /* row (horizontal) IDCT  #define XVID_DSP_CLIP_255(x)   ( ((x)&~255) ? ((-(x)) >> (8*sizeof((x))-1))&0xff : (x) )
  *  
  *           7                       pi         1  
  * dst[k] = sum c[l] * src[l] * cos( -- * ( k + - ) * l )  
  *          l=0                      8          2  
  *  
  * where: c[0]    = 128  
  *        c[1..7] = 128*sqrt(2)  
  */  
44    
45  /*  #define ROW_SHIFT 11
46  static void idctrow(blk)  #define COL_SHIFT 6
47  short *blk;  
48  {  // #define FIX(x)   (int)((x) * (1<<ROW_SHIFT))
49    int X0, X1, X2, X3, X4, X5, X6, X7, X8;  #define Rnd0 65536 // 1<<(COL_SHIFT+ROW_SHIFT-1);
50    #define Rnd1 3597  // FIX (1.75683487303);
51    #define Rnd2 2260  // FIX (1.10355339059);
52    #define Rnd3 1203  // FIX (0.587788325588);
53    #define Rnd4 0
54    #define Rnd5 120   // FIX (0.058658283817);
55    #define Rnd6 512   // FIX (0.25);
56    #define Rnd7 512   // FIX (0.25);
57    #undef FIX
58    
59    static const int Tab04[] = { 22725, 21407, 19266, 16384, 12873,  8867, 4520 };
60    static const int Tab17[] = { 31521, 29692, 26722, 22725, 17855, 12299, 6270 };
61    static const int Tab26[] = { 29692, 27969, 25172, 21407, 16819, 11585, 5906 };
62    static const int Tab35[] = { 26722, 25172, 22654, 19266, 15137, 10426, 5315 };
63    
64    // shortcut  static int Idct_Row(short * In, const int * const Tab, int Rnd)
65    if (!((X1 = blk[4]<<11) | (X2 = blk[6]) | (X3 = blk[2]) |  {
66          (X4 = blk[1]) | (X5 = blk[7]) | (X6 = blk[5]) | (X7 = blk[3])))    const int C1 = Tab[0];
67      const int C2 = Tab[1];
68      const int C3 = Tab[2];
69      const int C4 = Tab[3];
70      const int C5 = Tab[4];
71      const int C6 = Tab[5];
72      const int C7 = Tab[6];
73    
74      const int Right = In[5]|In[6]|In[7];
75      const int Left  = In[1]|In[2]|In[3];
76      if (!(Right | In[4]))
77    {    {
78      blk[0]=blk[1]=blk[2]=blk[3]=blk[4]=blk[5]=blk[6]=blk[7]=blk[0]<<3;      const int K = C4*In[0] + Rnd;
79      return;      if (Left)
80        {
81          const int a0 = K + C2*In[2];
82          const int a1 = K + C6*In[2];
83          const int a2 = K - C6*In[2];
84          const int a3 = K - C2*In[2];
85    
86          const int b0 = C1*In[1] + C3*In[3];
87          const int b1 = C3*In[1] - C7*In[3];
88          const int b2 = C5*In[1] - C1*In[3];
89          const int b3 = C7*In[1] - C5*In[3];
90    
91          In[0] = (a0 + b0) >> ROW_SHIFT;
92          In[1] = (a1 + b1) >> ROW_SHIFT;
93          In[2] = (a2 + b2) >> ROW_SHIFT;
94          In[3] = (a3 + b3) >> ROW_SHIFT;
95          In[4] = (a3 - b3) >> ROW_SHIFT;
96          In[5] = (a2 - b2) >> ROW_SHIFT;
97          In[6] = (a1 - b1) >> ROW_SHIFT;
98          In[7] = (a0 - b0) >> ROW_SHIFT;
99    }    }
100        else
101    X0 = (blk[0]<<11) + 128; // for proper rounding in the fourth stage      {
102          const int a0 = K >> ROW_SHIFT;
103    // first stage        if (a0) {
104    X8 = W7*(X4+X5);          In[0] = In[1] = In[2] = In[3] =
105    X4 = X8 + (W1-W7)*X4;          In[4] = In[5] = In[6] = In[7] = a0;
106    X5 = X8 - (W1+W7)*X5;        }
107    X8 = W3*(X6+X7);        else return 0;
108    X6 = X8 - (W3-W5)*X6;      }
109    X7 = X8 - (W3+W5)*X7;    }
110      else if (!(Left|Right))
   // second stage  
   X8 = X0 + X1;  
   X0 -= X1;  
   X1 = W6*(X3+X2);  
   X2 = X1 - (W2+W6)*X2;  
   X3 = X1 + (W2-W6)*X3;  
   X1 = X4 + X6;  
   X4 -= X6;  
   X6 = X5 + X7;  
   X5 -= X7;  
   
   // third stage  
   X7 = X8 + X3;  
   X8 -= X3;  
   X3 = X0 + X2;  
   X0 -= X2;  
   X2 = (181*(X4+X5)+128)>>8;  
   X4 = (181*(X4-X5)+128)>>8;  
   
   // fourth stage  
   blk[0] = (X7+X1)>>8;  
   blk[1] = (X3+X2)>>8;  
   blk[2] = (X0+X4)>>8;  
   blk[3] = (X8+X6)>>8;  
   blk[4] = (X8-X6)>>8;  
   blk[5] = (X0-X4)>>8;  
   blk[6] = (X3-X2)>>8;  
   blk[7] = (X7-X1)>>8;  
 }*/  
   
 /* column (vertical) IDCT  
  *  
  *             7                         pi         1  
  * dst[8*k] = sum c[l] * src[8*l] * cos( -- * ( k + - ) * l )  
  *            l=0                        8          2  
  *  
  * where: c[0]    = 1/1024  
  *        c[1..7] = (1/1024)*sqrt(2)  
  */  
 /*  
 static void idctcol(blk)  
 short *blk;  
111  {  {
112    int X0, X1, X2, X3, X4, X5, X6, X7, X8;      const int a0 = (Rnd + C4*(In[0]+In[4])) >> ROW_SHIFT;
113        const int a1 = (Rnd + C4*(In[0]-In[4])) >> ROW_SHIFT;
114    
115    // shortcut      In[0] = a0;
116    if (!((X1 = (blk[8*4]<<8)) | (X2 = blk[8*6]) | (X3 = blk[8*2]) |      In[3] = a0;
117          (X4 = blk[8*1]) | (X5 = blk[8*7]) | (X6 = blk[8*5]) | (X7 = blk[8*3])))      In[4] = a0;
118        In[7] = a0;
119        In[1] = a1;
120        In[2] = a1;
121        In[5] = a1;
122        In[6] = a1;
123      }
124      else
125    {    {
126      blk[8*0]=blk[8*1]=blk[8*2]=blk[8*3]=blk[8*4]=blk[8*5]=blk[8*6]=blk[8*7]=      const int K = C4*In[0] + Rnd;
127        iclp[(blk[8*0]+32)>>6];      const int a0 = K + C2*In[2] + C4*In[4] + C6*In[6];
128      return;      const int a1 = K + C6*In[2] - C4*In[4] - C2*In[6];
129    }      const int a2 = K - C6*In[2] - C4*In[4] + C2*In[6];
130        const int a3 = K - C2*In[2] + C4*In[4] - C6*In[6];
131    X0 = (blk[8*0]<<8) + 8192;  
132        const int b0 = C1*In[1] + C3*In[3] + C5*In[5] + C7*In[7];
133    // first stage      const int b1 = C3*In[1] - C7*In[3] - C1*In[5] - C5*In[7];
134    X8 = W7*(X4+X5) + 4;      const int b2 = C5*In[1] - C1*In[3] + C7*In[5] + C3*In[7];
135    X4 = (X8+(W1-W7)*X4)>>3;      const int b3 = C7*In[1] - C5*In[3] + C3*In[5] - C1*In[7];
136    X5 = (X8-(W1+W7)*X5)>>3;  
137    X8 = W3*(X6+X7) + 4;      In[0] = (a0 + b0) >> ROW_SHIFT;
138    X6 = (X8-(W3-W5)*X6)>>3;      In[1] = (a1 + b1) >> ROW_SHIFT;
139    X7 = (X8-(W3+W5)*X7)>>3;      In[2] = (a2 + b2) >> ROW_SHIFT;
140        In[3] = (a3 + b3) >> ROW_SHIFT;
141    // second stage      In[4] = (a3 - b3) >> ROW_SHIFT;
142    X8 = X0 + X1;      In[5] = (a2 - b2) >> ROW_SHIFT;
143    X0 -= X1;      In[6] = (a1 - b1) >> ROW_SHIFT;
144    X1 = W6*(X3+X2) + 4;      In[7] = (a0 - b0) >> ROW_SHIFT;
145    X2 = (X1-(W2+W6)*X2)>>3;    }
146    X3 = (X1+(W2-W6)*X3)>>3;    return 1;
147    X1 = X4 + X6;  }
   X4 -= X6;  
   X6 = X5 + X7;  
   X5 -= X7;  
   
   // third stage  
   X7 = X8 + X3;  
   X8 -= X3;  
   X3 = X0 + X2;  
   X0 -= X2;  
   X2 = (181*(X4+X5)+128)>>8;  
   X4 = (181*(X4-X5)+128)>>8;  
   
   // fourth stage  
   blk[8*0] = iclp[(X7+X1)>>14];  
   blk[8*1] = iclp[(X3+X2)>>14];  
   blk[8*2] = iclp[(X0+X4)>>14];  
   blk[8*3] = iclp[(X8+X6)>>14];  
   blk[8*4] = iclp[(X8-X6)>>14];  
   blk[8*5] = iclp[(X0-X4)>>14];  
   blk[8*6] = iclp[(X3-X2)>>14];  
   blk[8*7] = iclp[(X7-X1)>>14];  
 }*/  
148    
149  // function pointer  #define Tan1  0x32ec
150  idctFuncPtr idct;  #define Tan2  0x6a0a
151    #define Tan3  0xab0e
152    #define Sqrt2 0x5a82
153    
154    #define MULT(c,x, n)  ( ((c) * (x)) >> (n) )
155    // 12b version => #define MULT(c,x, n)  ( (((c)>>3) * (x)) >> ((n)-3) )
156    // 12b zero-testing version:
157    
158    #define BUTF(a, b, tmp) \
159      (tmp) = (a)+(b);      \
160      (b)   = (a)-(b);      \
161      (a)   = (tmp)
162    
163    #define LOAD_BUTF(m1, m2, a, b, tmp, S) \
164      (m1) = (S)[(a)] + (S)[(b)];           \
165      (m2) = (S)[(a)] - (S)[(b)]
166    
167  /* two dimensional inverse discrete cosine transform */  static void Idct_Col_8(short * const In)
 //void j_rev_dct(block)  
 //short *block;  
 void idct_int32(short * const block)  
168  {  {
169      int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;
170    
171    // idct_int32_init() must be called before the first call to this function!      // odd
172    
173      mm4 = (int)In[7*8];
174      mm5 = (int)In[5*8];
175      mm6 = (int)In[3*8];
176      mm7 = (int)In[1*8];
177    
178      mm0 = MULT(Tan1, mm4, 16) + mm7;
179      mm1 = MULT(Tan1, mm7, 16) - mm4;
180      mm2 = MULT(Tan3, mm5, 16) + mm6;
181      mm3 = MULT(Tan3, mm6, 16) - mm5;
182    
183      mm7 = mm0 + mm2;
184      mm4 = mm1 - mm3;
185      mm0 = mm0 - mm2;
186      mm1 = mm1 + mm3;
187      mm6 = mm0 + mm1;
188      mm5 = mm0 - mm1;
189      mm5 = 2*MULT(Sqrt2, mm5, 16);  // 2*sqrt2
190      mm6 = 2*MULT(Sqrt2, mm6, 16);  // Watch out: precision loss but done to match
191                                     // the pmulhw used in mmx/sse versions
192    
193        // even
194    
195      mm1 = (int)In[2*8];
196      mm2 = (int)In[6*8];
197      mm3 = MULT(Tan2,mm2, 16) + mm1;
198      mm2 = MULT(Tan2,mm1, 16) - mm2;
199    
200      LOAD_BUTF(mm0, mm1, 0*8, 4*8, Spill, In);
201    
202      BUTF(mm0, mm3, Spill);
203      BUTF(mm0, mm7, Spill);
204      In[8*0] = (int16_t) (mm0 >> COL_SHIFT);
205      In[8*7] = (int16_t) (mm7 >> COL_SHIFT);
206      BUTF(mm3, mm4, mm0);
207      In[8*3] = (int16_t) (mm3 >> COL_SHIFT);
208      In[8*4] = (int16_t) (mm4 >> COL_SHIFT);
209    
210      BUTF(mm1, mm2, mm0);
211      BUTF(mm1, mm6, mm0);
212      In[8*1] = (int16_t) (mm1 >> COL_SHIFT);
213      In[8*6] = (int16_t) (mm6 >> COL_SHIFT);
214      BUTF(mm2, mm5, mm0);
215      In[8*2] = (int16_t) (mm2 >> COL_SHIFT);
216      In[8*5] = (int16_t) (mm5 >> COL_SHIFT);
217    }
218    
219    /*int i;  static void Idct_Col_4(short * const In)
220    long i;  {
221      int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;
222    
223    for (i=0; i<8; i++)      // odd
     idctrow(block+8*i);  
224    
225    for (i=0; i<8; i++)    mm0 = (int)In[1*8];
226      idctcol(block+i);*/    mm2 = (int)In[3*8];
   static short *blk;  
   static long i;  
   static long X0, X1, X2, X3, X4, X5, X6, X7, X8;  
227    
228      mm1 = MULT(Tan1, mm0, 16);
229      mm3 = MULT(Tan3, mm2, 16);
230    
231      mm7 = mm0 + mm2;
232      mm4 = mm1 - mm3;
233      mm0 = mm0 - mm2;
234      mm1 = mm1 + mm3;
235      mm6 = mm0 + mm1;
236      mm5 = mm0 - mm1;
237      mm6 = 2*MULT(Sqrt2, mm6, 16);  // 2*sqrt2
238      mm5 = 2*MULT(Sqrt2, mm5, 16);
239    
240        // even
241    
242      mm0 = mm1 = (int)In[0*8];
243      mm3 = (int)In[2*8];
244      mm2 = MULT(Tan2,mm3, 16);
245    
246      BUTF(mm0, mm3, Spill);
247      BUTF(mm0, mm7, Spill);
248      In[8*0] = (int16_t) (mm0 >> COL_SHIFT);
249      In[8*7] = (int16_t) (mm7 >> COL_SHIFT);
250      BUTF(mm3, mm4, mm0);
251      In[8*3] = (int16_t) (mm3 >> COL_SHIFT);
252      In[8*4] = (int16_t) (mm4 >> COL_SHIFT);
253    
254      BUTF(mm1, mm2, mm0);
255      BUTF(mm1, mm6, mm0);
256      In[8*1] = (int16_t) (mm1 >> COL_SHIFT);
257      In[8*6] = (int16_t) (mm6 >> COL_SHIFT);
258      BUTF(mm2, mm5, mm0);
259      In[8*2] = (int16_t) (mm2 >> COL_SHIFT);
260      In[8*5] = (int16_t) (mm5 >> COL_SHIFT);
261    }
262    
263    for (i=0; i<8; i++)   // idct rows  static void Idct_Col_3(short * const In)
   {  
         blk = block+(i<<3);  
         if (!((X1 = blk[4]<<11) | (X2 = blk[6]) | (X3 = blk[2]) |  
         (X4 = blk[1]) | (X5 = blk[7]) | (X6 = blk[5]) | (X7 = blk[3])))  
264          {          {
265                  blk[0]=blk[1]=blk[2]=blk[3]=blk[4]=blk[5]=blk[6]=blk[7]=blk[0]<<3;    int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;
                 continue;  
         }  
266    
267          X0 = (blk[0]<<11) + 128; // for proper rounding in the fourth stage      // odd
268    
269          // first stage    mm7 = (int)In[1*8];
270          X8 = W7*(X4+X5);    mm4 = MULT(Tan1, mm7, 16);
         X4 = X8 + (W1-W7)*X4;  
         X5 = X8 - (W1+W7)*X5;  
         X8 = W3*(X6+X7);  
         X6 = X8 - (W3-W5)*X6;  
         X7 = X8 - (W3+W5)*X7;  
   
         // second stage  
         X8 = X0 + X1;  
         X0 -= X1;  
         X1 = W6*(X3+X2);  
         X2 = X1 - (W2+W6)*X2;  
         X3 = X1 + (W2-W6)*X3;  
         X1 = X4 + X6;  
         X4 -= X6;  
         X6 = X5 + X7;  
         X5 -= X7;  
   
         // third stage  
         X7 = X8 + X3;  
         X8 -= X3;  
         X3 = X0 + X2;  
         X0 -= X2;  
         X2 = (181*(X4+X5)+128)>>8;  
         X4 = (181*(X4-X5)+128)>>8;  
   
         // fourth stage  
   
         blk[0] = (short)((X7+X1)>>8);  
         blk[1] = (short)((X3+X2)>>8);  
         blk[2] = (short)((X0+X4)>>8);  
         blk[3] = (short)((X8+X6)>>8);  
         blk[4] = (short)((X8-X6)>>8);  
         blk[5] = (short)((X0-X4)>>8);  
         blk[6] = (short)((X3-X2)>>8);  
         blk[7] = (short)((X7-X1)>>8);  
271    
272    } // end for ( i = 0; i < 8; ++i ) IDCT-rows    mm6 = mm7 + mm4;
273      mm5 = mm7 - mm4;
274      mm6 = 2*MULT(Sqrt2, mm6, 16);  // 2*sqrt2
275      mm5 = 2*MULT(Sqrt2, mm5, 16);
276    
277        // even
278    
279      mm0 = mm1 = (int)In[0*8];
280      mm3 = (int)In[2*8];
281      mm2 = MULT(Tan2,mm3, 16);
282    
283      BUTF(mm0, mm3, Spill);
284      BUTF(mm0, mm7, Spill);
285      In[8*0] = (int16_t) (mm0 >> COL_SHIFT);
286      In[8*7] = (int16_t) (mm7 >> COL_SHIFT);
287      BUTF(mm3, mm4, mm0);
288      In[8*3] = (int16_t) (mm3 >> COL_SHIFT);
289      In[8*4] = (int16_t) (mm4 >> COL_SHIFT);
290    
291      BUTF(mm1, mm2, mm0);
292      BUTF(mm1, mm6, mm0);
293      In[8*1] = (int16_t) (mm1 >> COL_SHIFT);
294      In[8*6] = (int16_t) (mm6 >> COL_SHIFT);
295      BUTF(mm2, mm5, mm0);
296      In[8*2] = (int16_t) (mm2 >> COL_SHIFT);
297      In[8*5] = (int16_t) (mm5 >> COL_SHIFT);
298    }
299    
300    #undef Tan1
301    #undef Tan2
302    #undef Tan3
303    #undef Sqrt2
304    
305    #undef ROW_SHIFT
306    #undef COL_SHIFT
307    
308    for (i=0; i<8; i++)   // idct columns  //////////////////////////////////////////////////////////
309    {  
310          blk = block + i;  void idct_int32(short *const In)
     // shortcut  
         if (!((X1 = (blk[8*4]<<8)) | (X2 = blk[8*6]) | (X3 = blk[8*2]) |  
         (X4 = blk[8*1]) | (X5 = blk[8*7]) | (X6 = blk[8*5]) | (X7 = blk[8*3])))  
         {  
                 blk[8*0]=blk[8*1]=blk[8*2]=blk[8*3]=blk[8*4]=  
                         blk[8*5]=blk[8*6]=blk[8*7]=iclp[(blk[8*0]+32)>>6];  
                 continue;  
         }  
   
         X0 = (blk[8*0]<<8) + 8192;  
   
         // first stage  
         X8 = W7*(X4+X5) + 4;  
         X4 = (X8+(W1-W7)*X4)>>3;  
         X5 = (X8-(W1+W7)*X5)>>3;  
         X8 = W3*(X6+X7) + 4;  
         X6 = (X8-(W3-W5)*X6)>>3;  
         X7 = (X8-(W3+W5)*X7)>>3;  
   
         // second stage  
         X8 = X0 + X1;  
         X0 -= X1;  
         X1 = W6*(X3+X2) + 4;  
         X2 = (X1-(W2+W6)*X2)>>3;  
         X3 = (X1+(W2-W6)*X3)>>3;  
         X1 = X4 + X6;  
         X4 -= X6;  
         X6 = X5 + X7;  
         X5 -= X7;  
   
         // third stage  
         X7 = X8 + X3;  
         X8 -= X3;  
         X3 = X0 + X2;  
         X0 -= X2;  
         X2 = (181*(X4+X5)+128)>>8;  
         X4 = (181*(X4-X5)+128)>>8;  
   
         // fourth stage  
         blk[8*0] = iclp[(X7+X1)>>14];  
         blk[8*1] = iclp[(X3+X2)>>14];  
         blk[8*2] = iclp[(X0+X4)>>14];  
         blk[8*3] = iclp[(X8+X6)>>14];  
         blk[8*4] = iclp[(X8-X6)>>14];  
         blk[8*5] = iclp[(X0-X4)>>14];  
         blk[8*6] = iclp[(X3-X2)>>14];  
         blk[8*7] = iclp[(X7-X1)>>14];  
   }  
   
 } // end function idct_int32(block)  
   
   
 //void  
 //idct_int32_init()  
 void idct_int32_init()  
311  {  {
312    int i;    int i, Rows = 0x07;
313    
314      Idct_Row(In + 0*8, Tab04, Rnd0);
315      Idct_Row(In + 1*8, Tab17, Rnd1);
316      Idct_Row(In + 2*8, Tab26, Rnd2);
317      if (Idct_Row(In + 3*8, Tab35, Rnd3)) Rows |= 0x08;
318      if (Idct_Row(In + 4*8, Tab04, Rnd4)) Rows |= 0x10;
319      if (Idct_Row(In + 5*8, Tab35, Rnd5)) Rows |= 0x20;
320      if (Idct_Row(In + 6*8, Tab26, Rnd6)) Rows |= 0x40;
321      if (Idct_Row(In + 7*8, Tab17, Rnd7)) Rows |= 0x80;
322    
323    iclp = iclip+512;    if (Rows&0xf0) {
324    for (i= -512; i<512; i++)      for(i=0; i<8; i++)
325      iclp[i] = (i<-256) ? -256 : ((i>255) ? 255 : i);        Idct_Col_8(In + i);
326      }
327      else if (Rows&0x08) {
328        for(i=0; i<8; i++)
329          Idct_Col_4(In + i);
330      }
331      else {
332        for(i=0; i<8; i++)
333          Idct_Col_3(In + i);
334      }
335  }  }
Legend:
Removed from v.3  
changed lines
  Added in v.1989
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4