[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 1978, Mon May 16 16:19:06 2011 UTC revision 1979, Mon May 16 16:20:15 2011 UTC
# Line 3  Line 3 
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - Inverse DCT  -   *  - Inverse DCT  -
5   *   *
6   *  These routines are from Independent JPEG Group's free JPEG software   *  Copyright (C) 2006-2011 Xvid Solutions GmbH
  *  Copyright (C) 1991-1998, Thomas G. Lane (see the file README.IJG)  
7   *   *
8   *  This program is free software ; you can redistribute it and/or modify   *  This program is free software ; you can redistribute it and/or modify
9   *  it under the terms of the GNU General Public License as published by   *  it under the terms of the GNU General Public License as published by
# Line 24  Line 23 
23   *   *
24   ****************************************************************************/   ****************************************************************************/
25    
 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */  
   
26  /*  /*
27   * Disclaimer of Warranty   *  Authors: Skal
  *  
  * These software programs are available to the user without any license fee or  
  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims  
  * 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.  
  *  
  * This disclaimer of warranty extends to the user of these programs and user's  
  * customers, employees, agents, transferees, successors, and assigns.  
28   *   *
29   * The MPEG Software Simulation Group does not represent or warrant that the   *  Walken IDCT
30   * programs furnished hereunder are free of infringement of any third-party   *  Alternative idct implementations for decoding compatibility
  * patents.  
31   *   *
32   * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,   *  NOTE: this "C" version is not the original one,
33   * are subject to royalty fees to patent holders.  Many of these patents are   *  but is modified to yield the same error profile
34   * general enough such that they are unavoidable regardless of implementation   *  than the MMX version.
  * design.  
35   *   *
36   * MPEG2AVI   ************************************************************************/
  * --------  
  * v0.16B33 renamed the initialization function to init_idct_int32()  
  * 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.  
  *  
  * v0.14  changed int to long, to avoid confusion when compiling on x86  
  *        platform ( in VC++ "int" -> 32bits )  
  */  
   
 /**********************************************************/  
 /* 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       */  
 /**********************************************************/  
   
 /* this code assumes >> to be a two's-complement arithmetic */  
 /* right shift: (-2)>>1 == -1 , (-3)>>1 == -2               */  
37    
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) */  
   
 /* private data  
  * Initialized by idct_int32_init so it's mostly RO data,  
  * doesn't hurt thread safety */  
 static short iclip[1024];               /* clipping table */  
 static short *iclp;  
42    
43  /* private prototypes */  #define XVID_DSP_CLIP_255(x)   ( ((x)&~255) ? ((-(x)) >> (8*sizeof((x))-1))&0xff : (x) )
44    
45  /* row (horizontal) IDCT  #define ROW_SHIFT 11
46   *  #define COL_SHIFT 6
47   *           7                       pi         1  
48   * dst[k] = sum c[l] * src[l] * cos( -- * ( k + - ) * l )  // #define FIX(x)   (int)((x) * (1<<ROW_SHIFT))
49   *          l=0                      8          2  #define Rnd0 65536 // 1<<(COL_SHIFT+ROW_SHIFT-1);
50   *  #define Rnd1 3597  // FIX (1.75683487303);
51   * where: c[0]    = 128  #define Rnd2 2260  // FIX (1.10355339059);
52   *        c[1..7] = 128*sqrt(2)  #define Rnd3 1203  // FIX (0.587788325588);
53   */  #define Rnd4 0
54    #define Rnd5 120   // FIX (0.058658283817);
55  #if 0  #define Rnd6 512   // FIX (0.25);
56  static void idctrow(blk)  #define Rnd7 512   // FIX (0.25);
57  short *blk;  #undef FIX
58  {  
59    int X0, X1, X2, X3, X4, X5, X6, X7, X8;  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)
   if (!((X1 = blk[4]<<11) | (X2 = blk[6]) | (X3 = blk[2]) |  
         (X4 = blk[1]) | (X5 = blk[7]) | (X6 = blk[5]) | (X7 = blk[3])))  
65    {    {
66      blk[0]=blk[1]=blk[2]=blk[3]=blk[4]=blk[5]=blk[6]=blk[7]=blk[0]<<3;    const int C1 = Tab[0];
67      return;    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        const int K = C4*In[0] + Rnd;
79        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;
   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] = (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;  
106  }  }
107  #endif        else return 0;
108        }
109  /* column (vertical) IDCT    }
110   *    else if (!(Left|Right))
  *             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)  
  */  
   
 #if 0  
 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;
   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];  
147  }  }
 #endif  
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  
 idct_int32(short *const block)  
168  {  {
169      int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;
170    
171          /*      // odd
          * idct_int32_init() must be called before the first call to this  
          * function!  
          */  
   
172    
173  #if 0    mm4 = (int)In[7*8];
174          int i;    mm5 = (int)In[5*8];
175          long i;    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          for (i=0; i<8; i++)  static void Idct_Col_4(short * const In)
220                  idctrow(block+8*i);  {
221      int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;
222    
223          for (i=0; i<8; i++)      // odd
                 idctcol(block+i);  
 #endif  
224    
225          short *blk;    mm0 = (int)In[1*8];
226          long i;    mm2 = (int)In[3*8];
         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)
264          {          {
265                  blk = block + (i << 3);    int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;
                 if (!  
                         ((X1 = blk[4] << 11) | (X2 = blk[6]) | (X3 = blk[2]) | (X4 =  
                                                                                                                                         blk[1]) |  
                          (X5 = blk[7]) | (X6 = blk[5]) | (X7 = blk[3]))) {  
                         blk[0] = blk[1] = blk[2] = blk[3] = blk[4] = blk[5] = blk[6] =  
                                 blk[7] = blk[0] << 3;  
                         continue;  
                 }  
   
                 X0 = (blk[0] << 11) + 128;      /* for proper rounding in the fourth stage  */  
   
                 /* first stage  */  
                 X8 = W7 * (X4 + X5);  
                 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);  
266    
267          }                                                       /* end for ( i = 0; i < 8; ++i ) IDCT-rows */      // odd
268    
269      mm7 = (int)In[1*8];
270      mm4 = MULT(Tan1, mm7, 16);
271    
272      mm6 = mm7 + mm4;
273          for (i = 0; i < 8; i++)         /* idct columns */    mm5 = mm7 - mm4;
274          {    mm6 = 2*MULT(Sqrt2, mm6, 16);  // 2*sqrt2
275                  blk = block + i;    mm5 = 2*MULT(Sqrt2, mm5, 16);
276                  /* shortcut  */  
277                  if (!      // even
278                          ((X1 = (blk[8 * 4] << 8)) | (X2 = blk[8 * 6]) | (X3 =  
279                                                                                                                           blk[8 *    mm0 = mm1 = (int)In[0*8];
280                                                                                                                                   2]) | (X4 =    mm3 = (int)In[2*8];
281                                                                                                                                                  blk[8 *    mm2 = MULT(Tan2,mm3, 16);
282                                                                                                                                                          1])  
283                           | (X5 = blk[8 * 7]) | (X6 = blk[8 * 5]) | (X7 = blk[8 * 3]))) {    BUTF(mm0, mm3, Spill);
284                          blk[8 * 0] = blk[8 * 1] = blk[8 * 2] = blk[8 * 3] = blk[8 * 4] =    BUTF(mm0, mm7, Spill);
285                                  blk[8 * 5] = blk[8 * 6] = blk[8 * 7] =    In[8*0] = (int16_t) (mm0 >> COL_SHIFT);
286                                  iclp[(blk[8 * 0] + 32) >> 6];    In[8*7] = (int16_t) (mm7 >> COL_SHIFT);
287                          continue;    BUTF(mm3, mm4, mm0);
288                  }    In[8*3] = (int16_t) (mm3 >> COL_SHIFT);
289      In[8*4] = (int16_t) (mm4 >> COL_SHIFT);
290                  X0 = (blk[8 * 0] << 8) + 8192;  
291      BUTF(mm1, mm2, mm0);
292                  /* first stage  */    BUTF(mm1, mm6, mm0);
293                  X8 = W7 * (X4 + X5) + 4;    In[8*1] = (int16_t) (mm1 >> COL_SHIFT);
294                  X4 = (X8 + (W1 - W7) * X4) >> 3;    In[8*6] = (int16_t) (mm6 >> COL_SHIFT);
295                  X5 = (X8 - (W1 + W7) * X5) >> 3;    BUTF(mm2, mm5, mm0);
296                  X8 = W3 * (X6 + X7) + 4;    In[8*2] = (int16_t) (mm2 >> COL_SHIFT);
297                  X6 = (X8 - (W3 - W5) * X6) >> 3;    In[8*5] = (int16_t) (mm5 >> COL_SHIFT);
                 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];  
298          }          }
299    
300  }                                                               /* end function idct_int32(block) */  #undef Tan1
301    #undef Tan2
302    #undef Tan3
303    #undef Sqrt2
304    
305    #undef ROW_SHIFT
306    #undef COL_SHIFT
307    
308    //////////////////////////////////////////////////////////
309    
310  void  void idct_int32(short *const In)
 idct_int32_init(void)  
311  {  {
312          int i;    int i, Rows = 0x07;
313    
314          iclp = iclip + 512;    Idct_Row(In + 0*8, Tab04, Rnd0);
315          for (i = -512; i < 512; i++)    Idct_Row(In + 1*8, Tab17, Rnd1);
316                  iclp[i] = (i < -256) ? -256 : ((i > 255) ? 255 : i);    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      if (Rows&0xf0) {
324        for(i=0; i<8; i++)
325          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.1978  
changed lines
  Added in v.1979

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4