[svn] / branches / release-1_3-branch / xvidcore / src / dct / fdct.c Repository:
ViewVC logotype

Diff of /branches/release-1_3-branch/xvidcore/src/dct/fdct.c

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

revision 1984, Wed May 18 08:51:47 2011 UTC revision 1985, Wed May 18 09:02:35 2011 UTC
# Line 3  Line 3 
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - Forward DCT  -   *  - Forward DCT  -
5   *   *
6   *  Copyright (C) 2006-2011 Xvid Solutions GmbH   *  These routines are from Independent JPEG Group's free JPEG software
7     *  Copyright (C) 1991-1998, Thomas G. Lane (see the file README.IJG)
8   *   *
9   *  This program is free software ; you can redistribute it and/or modify   *  This program is free software ; you can redistribute it and/or modify
10   *  it under the terms of the GNU General Public License as published by   *  it under the terms of the GNU General Public License as published by
# Line 19  Line 20 
20   *  along with this program ; if not, write to the Free Software   *  along with this program ; if not, write to the Free Software
21   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22   *   *
23   * $Id: fdct.c,v 1.7 2004-03-22 22:36:23 edgomez Exp $   * $Id$
24   *   *
25   ****************************************************************************/   ****************************************************************************/
26    
27    /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
28    
29  /*  /*
30   *  Authors: Skal   * Disclaimer of Warranty
31   *   *
32   *  "Fast and precise" LLM implementation of FDCT/IDCT, where   * These software programs are available to the user without any license fee or
33   *  rotations are decomposed using:   * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
34   *    tmp = (x+y).cos t   * any and all warranties, whether express, implied, or statuary, including any
35   *    x' = tmp + y.(sin t - cos t)   * implied warranties or merchantability or of fitness for a particular
36   *    y' = tmp - x.(sin t + cos t)   * purpose.  In no event shall the copyright-holder be liable for any
37   *   * incidental, punitive, or consequential damages of any kind whatsoever
38   *  See details at the end of this file...   * arising from the use of these programs.
39   *   *
40   * Reference (e.g.):   * This disclaimer of warranty extends to the user of these programs and user's
41   *  Loeffler C., Ligtenberg A., and Moschytz C.S.:   * customers, employees, agents, transferees, successors, and assigns.
42   *    Practical Fast 1D DCT Algorithm with Eleven Multiplications,   *
43   *  Proc. ICASSP 1989, 988-991.   * The MPEG Software Simulation Group does not represent or warrant that the
44   *   * programs furnished hereunder are free of infringement of any third-party
45   *  IEEE-1180-like error specs for FDCT:   * patents.
46   * Peak error:   1.0000   *
47   * Peak MSE:     0.0340   * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
48   * Overall MSE:  0.0200   * are subject to royalty fees to patent holders.  Many of these patents are
49   * Peak ME:      0.0191   * general enough such that they are unavoidable regardless of implementation
50   * Overall ME:   -0.0033   * design.
51   *   *
52   ********************************************************/   */
53    
54    /* This routine is a slow-but-accurate integer implementation of the
55     * forward DCT (Discrete Cosine Transform). Taken from the IJG software
56     *
57     * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
58     * on each column.  Direct algorithms are also available, but they are
59     * much more complex and seem not to be any faster when reduced to code.
60     *
61     * This implementation is based on an algorithm described in
62     *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
63     *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
64     *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
65     * The primary algorithm described there uses 11 multiplies and 29 adds.
66     * We use their alternate method with 12 multiplies and 32 adds.
67     * The advantage of this method is that no data path contains more than one
68     * multiplication; this allows a very simple and accurate implementation in
69     * scaled fixed-point arithmetic, with a minimal number of shifts.
70     *
71     * The poop on this scaling stuff is as follows:
72     *
73     * Each 1-D DCT step produces outputs which are a factor of sqrt(N)
74     * larger than the true DCT outputs.  The final outputs are therefore
75     * a factor of N larger than desired; since N=8 this can be cured by
76     * a simple right shift at the end of the algorithm.  The advantage of
77     * this arrangement is that we save two multiplications per 1-D DCT,
78     * because the y0 and y4 outputs need not be divided by sqrt(N).
79     * In the IJG code, this factor of 8 is removed by the quantization step
80     * (in jcdctmgr.c), here it is removed.
81     *
82     * We have to do addition and subtraction of the integer inputs, which
83     * is no problem, and multiplication by fractional constants, which is
84     * a problem to do in integer arithmetic.  We multiply all the constants
85     * by CONST_SCALE and convert them to integer constants (thus retaining
86     * CONST_BITS bits of precision in the constants).  After doing a
87     * multiplication we have to divide the product by CONST_SCALE, with proper
88     * rounding, to produce the correct output.  This division can be done
89     * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
90     * as long as possible so that partial sums can be added together with
91     * full fractional precision.
92     *
93     * The outputs of the first pass are scaled up by PASS1_BITS bits so that
94     * they are represented to better-than-integral precision.  These outputs
95     * require 8 + PASS1_BITS + 3 bits; this fits in a 16-bit word
96     * with the recommended scaling.  (For 12-bit sample data, the intermediate
97     * array is INT32 anyway.)
98     *
99     * To avoid overflow of the 32-bit intermediate results in pass 2, we must
100     * have 8 + CONST_BITS + PASS1_BITS <= 26.  Error analysis
101     * shows that the values given below are the most effective.
102     *
103     * We can gain a little more speed, with a further compromise in accuracy,
104     * by omitting the addition in a descaling shift.  This yields an incorrectly
105     * rounded result half the time...
106     */
107    
108  #include "fdct.h"  #include "fdct.h"
109    
110  /* function pointer */  #define USE_ACCURATE_ROUNDING
 fdctFuncPtr fdct;  
111    
112  /*  #define RIGHT_SHIFT(x, shft)  ((x) >> (shft))
 //////////////////////////////////////////////////////////  
 */  
   
 #define BUTF(a, b, tmp) \  
   (tmp) = (a)+(b);      \  
   (b)   = (a)-(b);      \  
   (a)   = (tmp)  
   
 #define LOAD_BUTF(m1, m2, a, b, tmp, S) \  
   (m1) = (S)[(a)] + (S)[(b)];           \  
   (m2) = (S)[(a)] - (S)[(b)]  
   
 #define ROTATE(m1,m2,c,k1,k2,tmp,Fix,Rnd) \  
   (tmp) = ( (m1) + (m2) )*(c);            \  
   (m1) *= k1;                             \  
   (m2) *= k2;                             \  
   (tmp) += (Rnd);                         \  
   (m1) = ((m1)+(tmp))>>(Fix);             \  
   (m2) = ((m2)+(tmp))>>(Fix);  
   
 #define ROTATE2(m1,m2,c,k1,k2,tmp) \  
   (tmp) = ( (m1) + (m2) )*(c);     \  
   (m1) *= k1;                      \  
   (m2) *= k2;                      \  
   (m1) = (m1)+(tmp);               \  
   (m2) = (m2)+(tmp);  
   
 #define ROTATE0(m1,m2,c,k1,k2,tmp) \  
   (m1) = ( (m2) )*(c);             \  
   (m2) = (m2)*k2+(m1);  
   
 #define SHIFTL(x,n)   ((x)<<(n))  
 #define SHIFTR(x, n)  ((x)>>(n))  
 #define HALF(n)       (1<<((n)-1))  
   
 #define IPASS 3  
 #define FPASS 2  
 #define FIX  16  
   
 #if 1  
   
 #define ROT6_C     35468  
 #define ROT6_SmC   50159  
 #define ROT6_SpC  121095  
 #define ROT17_C    77062  
 #define ROT17_SmC  25571  
 #define ROT17_SpC 128553  
 #define ROT37_C    58981  
 #define ROT37_SmC  98391  
 #define ROT37_SpC  19571  
 #define ROT13_C   167963  
 #define ROT13_SmC 134553  
 #define ROT13_SpC 201373  
113    
114    #ifdef USE_ACCURATE_ROUNDING
115    #define ONE ((int) 1)
116    #define DESCALE(x, n)  RIGHT_SHIFT((x) + (ONE << ((n) - 1)), n)
117  #else  #else
118    #define DESCALE(x, n)  RIGHT_SHIFT(x, n)
119    #endif
120    
121  #include <math.h>  #define CONST_BITS  13
122  #define FX(x) ( (int)floor((x)*(1<<FIX) + .5 ) )  #define PASS1_BITS  2
123    
124  static const double c1 = cos(1.*M_PI/16);  #define FIX_0_298631336  ((int)  2446)  /* FIX(0.298631336) */
125  static const double c2 = cos(2.*M_PI/16);  #define FIX_0_390180644  ((int)  3196)  /* FIX(0.390180644) */
126  static const double c3 = cos(3.*M_PI/16);  #define FIX_0_541196100  ((int)  4433)  /* FIX(0.541196100) */
127  static const double c4 = cos(4.*M_PI/16);  #define FIX_0_765366865  ((int)  6270)  /* FIX(0.765366865) */
128  static const double c5 = cos(5.*M_PI/16);  #define FIX_0_899976223  ((int)  7373)  /* FIX(0.899976223) */
129  static const double c6 = cos(6.*M_PI/16);  #define FIX_1_175875602  ((int)  9633)  /* FIX(1.175875602) */
130  static const double c7 = cos(7.*M_PI/16);  #define FIX_1_501321110  ((int) 12299)  /* FIX(1.501321110) */
131    #define FIX_1_847759065  ((int) 15137)  /* FIX(1.847759065) */
132  static const int ROT6_C   = FX(c2-c6);  // 0.541  #define FIX_1_961570560  ((int) 16069)  /* FIX(1.961570560) */
133  static const int ROT6_SmC = FX(2*c6);   // 0.765  #define FIX_2_053119869  ((int) 16819)  /* FIX(2.053119869) */
134  static const int ROT6_SpC = FX(2*c2);   // 1.847  #define FIX_2_562915447  ((int) 20995)  /* FIX(2.562915447) */
135    #define FIX_3_072711026  ((int) 25172)  /* FIX(3.072711026) */
 static const int ROT17_C   = FX(c1+c7);  // 1.175  
 static const int ROT17_SmC = FX(2*c7);   // 0.390  
 static const int ROT17_SpC = FX(2*c1);   // 1.961  
   
 static const int ROT37_C   = FX((c3-c7)/c4);  // 0.899  
 static const int ROT37_SmC = FX(2*(c5+c7));   // 1.501  
 static const int ROT37_SpC = FX(2*(c1-c3));   // 0.298  
   
 static const int ROT13_C   = FX((c1+c3)/c4);  // 2.562  
 static const int ROT13_SmC = FX(2*(c3+c7));   // 2.053  
 static const int ROT13_SpC = FX(2*(c1+c5));   // 3.072  
136    
137  #endif  /* function pointer */
138    fdctFuncPtr fdct;
139    
140  /*  /*
141  //////////////////////////////////////////////////////////   * Perform an integer forward DCT on one block of samples.
 // Forward transform  
142  */  */
143    
144  void fdct_int32( short *const In )  void
145    fdct_int32(short *const block)
146  {  {
147    short *pIn;          int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
148            int tmp10, tmp11, tmp12, tmp13;
149            int z1, z2, z3, z4, z5;
150            short *blkptr;
151            int *dataptr;
152            int data[64];
153    int i;    int i;
154    
155    pIn = In;          /* Pass 1: process rows. */
156    for(i=8; i>0; --i)          /* Note results are scaled up by sqrt(8) compared to a true DCT; */
157    {          /* furthermore, we scale the results by 2**PASS1_BITS. */
158      int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;  
159            dataptr = data;
160        // even          blkptr = block;
161            for (i = 0; i < 8; i++) {
162      LOAD_BUTF(mm1,mm6, 1, 6, mm0, pIn);                  tmp0 = blkptr[0] + blkptr[7];
163      LOAD_BUTF(mm2,mm5, 2, 5, mm0, pIn);                  tmp7 = blkptr[0] - blkptr[7];
164      LOAD_BUTF(mm3,mm4, 3, 4, mm0, pIn);                  tmp1 = blkptr[1] + blkptr[6];
165      LOAD_BUTF(mm0,mm7, 0, 7, Spill, pIn);                  tmp6 = blkptr[1] - blkptr[6];
166                    tmp2 = blkptr[2] + blkptr[5];
167                    tmp5 = blkptr[2] - blkptr[5];
168                    tmp3 = blkptr[3] + blkptr[4];
169                    tmp4 = blkptr[3] - blkptr[4];
170    
171      BUTF(mm1, mm2, Spill);                  /* Even part per LL&M figure 1 --- note that published figure is faulty;
172      BUTF(mm0, mm3, Spill);                   * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
173                     */
     ROTATE(mm3, mm2, ROT6_C, ROT6_SmC, -ROT6_SpC, Spill, FIX-FPASS, HALF(FIX-FPASS));  
     pIn[2] = mm3;  
     pIn[6] = mm2;  
   
     BUTF(mm0, mm1, Spill);  
     pIn[0] = SHIFTL(mm0, FPASS);  
     pIn[4] = SHIFTL(mm1, FPASS);  
174    
175                    tmp10 = tmp0 + tmp3;
176                    tmp13 = tmp0 - tmp3;
177                    tmp11 = tmp1 + tmp2;
178                    tmp12 = tmp1 - tmp2;
179    
180                    dataptr[0] = (tmp10 + tmp11) << PASS1_BITS;
181                    dataptr[4] = (tmp10 - tmp11) << PASS1_BITS;
182    
183                    z1 = (tmp12 + tmp13) * FIX_0_541196100;
184                    dataptr[2] =
185                            DESCALE(z1 + tmp13 * FIX_0_765366865, CONST_BITS - PASS1_BITS);
186                    dataptr[6] =
187                            DESCALE(z1 + tmp12 * (-FIX_1_847759065), CONST_BITS - PASS1_BITS);
188    
189                    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
190                     * cK represents cos(K*pi/16).
191                     * i0..i3 in the paper are tmp4..tmp7 here.
192                     */
193    
194        // odd                  z1 = tmp4 + tmp7;
195                    z2 = tmp5 + tmp6;
196                    z3 = tmp4 + tmp6;
197                    z4 = tmp5 + tmp7;
198                    z5 = (z3 + z4) * FIX_1_175875602;       /* sqrt(2) * c3 */
199    
200                    tmp4 *= FIX_0_298631336;        /* sqrt(2) * (-c1+c3+c5-c7) */
201                    tmp5 *= FIX_2_053119869;        /* sqrt(2) * ( c1+c3-c5+c7) */
202                    tmp6 *= FIX_3_072711026;        /* sqrt(2) * ( c1+c3+c5-c7) */
203                    tmp7 *= FIX_1_501321110;        /* sqrt(2) * ( c1+c3-c5-c7) */
204                    z1 *= -FIX_0_899976223; /* sqrt(2) * (c7-c3) */
205                    z2 *= -FIX_2_562915447; /* sqrt(2) * (-c1-c3) */
206                    z3 *= -FIX_1_961570560; /* sqrt(2) * (-c3-c5) */
207                    z4 *= -FIX_0_390180644; /* sqrt(2) * (c5-c3) */
208    
209                    z3 += z5;
210                    z4 += z5;
211    
212                    dataptr[7] = DESCALE(tmp4 + z1 + z3, CONST_BITS - PASS1_BITS);
213                    dataptr[5] = DESCALE(tmp5 + z2 + z4, CONST_BITS - PASS1_BITS);
214                    dataptr[3] = DESCALE(tmp6 + z2 + z3, CONST_BITS - PASS1_BITS);
215                    dataptr[1] = DESCALE(tmp7 + z1 + z4, CONST_BITS - PASS1_BITS);
216    
217      mm3 = mm5 + mm7;                  dataptr += 8;                   /* advance pointer to next row */
218      mm2 = mm4 + mm6;                  blkptr += 8;
219      ROTATE(mm2, mm3,  ROT17_C, -ROT17_SpC, -ROT17_SmC, mm0, FIX-FPASS, HALF(FIX-FPASS));          }
     ROTATE(mm4, mm7, -ROT37_C,  ROT37_SpC,  ROT37_SmC, mm0, FIX-FPASS, HALF(FIX-FPASS));  
     mm7 += mm3;  
     mm4 += mm2;  
     pIn[1] = mm7;  
     pIn[7] = mm4;  
220    
221      ROTATE(mm5, mm6, -ROT13_C,  ROT13_SmC,  ROT13_SpC, mm0, FIX-FPASS, HALF(FIX-FPASS));          /* Pass 2: process columns.
222      mm5 += mm3;           * We remove the PASS1_BITS scaling, but leave the results scaled up
223      mm6 += mm2;           * by an overall factor of 8.
224      pIn[3] = mm6;           */
     pIn[5] = mm5;  
225    
226      pIn  += 8;          dataptr = data;
227    }          for (i = 0; i < 8; i++) {
228                    tmp0 = dataptr[0] + dataptr[56];
229                    tmp7 = dataptr[0] - dataptr[56];
230                    tmp1 = dataptr[8] + dataptr[48];
231                    tmp6 = dataptr[8] - dataptr[48];
232                    tmp2 = dataptr[16] + dataptr[40];
233                    tmp5 = dataptr[16] - dataptr[40];
234                    tmp3 = dataptr[24] + dataptr[32];
235                    tmp4 = dataptr[24] - dataptr[32];
236    
237    pIn = In;                  /* Even part per LL&M figure 1 --- note that published figure is faulty;
238    for(i=8; i>0; --i)                   * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
239    {                   */
     int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, Spill;  
240    
241        // even                  tmp10 = tmp0 + tmp3;
242                    tmp13 = tmp0 - tmp3;
243                    tmp11 = tmp1 + tmp2;
244                    tmp12 = tmp1 - tmp2;
245    
246                    dataptr[0] = DESCALE(tmp10 + tmp11, PASS1_BITS);
247                    dataptr[32] = DESCALE(tmp10 - tmp11, PASS1_BITS);
248    
249                    z1 = (tmp12 + tmp13) * FIX_0_541196100;
250                    dataptr[16] =
251                            DESCALE(z1 + tmp13 * FIX_0_765366865, CONST_BITS + PASS1_BITS);
252                    dataptr[48] =
253                            DESCALE(z1 + tmp12 * (-FIX_1_847759065), CONST_BITS + PASS1_BITS);
254    
255                    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
256                     * cK represents cos(K*pi/16).
257                     * i0..i3 in the paper are tmp4..tmp7 here.
258                     */
259    
260      LOAD_BUTF(mm1,mm6, 1*8, 6*8, mm0, pIn);                  z1 = tmp4 + tmp7;
261      LOAD_BUTF(mm2,mm5, 2*8, 5*8, mm0, pIn);                  z2 = tmp5 + tmp6;
262      BUTF(mm1, mm2, mm0);                  z3 = tmp4 + tmp6;
263                    z4 = tmp5 + tmp7;
264      LOAD_BUTF(mm3,mm4, 3*8, 4*8, mm0, pIn);                  z5 = (z3 + z4) * FIX_1_175875602;       /* sqrt(2) * c3 */
265      LOAD_BUTF(mm0,mm7, 0*8, 7*8, Spill, pIn);  
266      BUTF(mm0, mm3, Spill);                  tmp4 *= FIX_0_298631336;        /* sqrt(2) * (-c1+c3+c5-c7) */
267                    tmp5 *= FIX_2_053119869;        /* sqrt(2) * ( c1+c3-c5+c7) */
268      ROTATE(mm3, mm2, ROT6_C, ROT6_SmC, -ROT6_SpC, Spill, 0,  HALF(FIX+FPASS+3));                  tmp6 *= FIX_3_072711026;        /* sqrt(2) * ( c1+c3+c5-c7) */
269      pIn[2*8] = (int16_t)SHIFTR(mm3,FIX+FPASS+3);                  tmp7 *= FIX_1_501321110;        /* sqrt(2) * ( c1+c3-c5-c7) */
270      pIn[6*8] = (int16_t)SHIFTR(mm2,FIX+FPASS+3);                  z1 *= -FIX_0_899976223; /* sqrt(2) * (c7-c3) */
271                    z2 *= -FIX_2_562915447; /* sqrt(2) * (-c1-c3) */
272      mm0 += HALF(FPASS+3) - 1;                  z3 *= -FIX_1_961570560; /* sqrt(2) * (-c3-c5) */
273      BUTF(mm0, mm1, Spill);                  z4 *= -FIX_0_390180644; /* sqrt(2) * (c5-c3) */
274      pIn[0*8] = (int16_t)SHIFTR(mm0, FPASS+3);  
275      pIn[4*8] = (int16_t)SHIFTR(mm1, FPASS+3);                  z3 += z5;
276                    z4 += z5;
277        // odd  
278                    dataptr[56] = DESCALE(tmp4 + z1 + z3, CONST_BITS + PASS1_BITS);
279      mm3 = mm5 + mm7;                  dataptr[40] = DESCALE(tmp5 + z2 + z4, CONST_BITS + PASS1_BITS);
280      mm2 = mm4 + mm6;                  dataptr[24] = DESCALE(tmp6 + z2 + z3, CONST_BITS + PASS1_BITS);
281                    dataptr[8] = DESCALE(tmp7 + z1 + z4, CONST_BITS + PASS1_BITS);
     ROTATE(mm2, mm3,  ROT17_C, -ROT17_SpC, -ROT17_SmC, mm0, 0, HALF(FIX+FPASS+3));  
     ROTATE2(mm4, mm7, -ROT37_C,  ROT37_SpC,  ROT37_SmC, mm0);  
     mm7 += mm3;  
     mm4 += mm2;  
     pIn[7*8] = (int16_t)SHIFTR(mm4,FIX+FPASS+3);  
     pIn[1*8] = (int16_t)SHIFTR(mm7,FIX+FPASS+3);  
   
     ROTATE2(mm5, mm6, -ROT13_C,  ROT13_SmC,  ROT13_SpC, mm0);  
     mm5 += mm3;  
     mm6 += mm2;  
     pIn[5*8] = (int16_t)SHIFTR(mm5,FIX+FPASS+3);  
     pIn[3*8] = (int16_t)SHIFTR(mm6,FIX+FPASS+3);  
282    
283      pIn++;                  dataptr++;                              /* advance pointer to next column */
284    }    }
285            /* descale */
286            for (i = 0; i < 64; i++)
287                    block[i] = (short int) DESCALE(data[i], 3);
288  }  }
 #undef FIX  
 #undef FPASS  
 #undef IPASS  
   
 #undef BUTF  
 #undef LOAD_BUTF  
 #undef ROTATE  
 #undef ROTATE2  
 #undef SHIFTL  
 #undef SHIFTR  
   
 //////////////////////////////////////////////////////////  
 //   - Data flow schematics for FDCT -  
 // Output is scaled by 2.sqrt(2)  
 // Initial butterflies (in0/in7, etc.) are not fully depicted.  
 // Note: Rot6 coeffs are multiplied by sqrt(2).  
 //////////////////////////////////////////////////////////  
 /*  
  <---------Stage1 =even part=----------->  
   
  in3 mm3  +_____.___-___________.____* out6  
   x              \ /            |  
  in4 mm4          \             |  
                  / \            |  
  in0 mm0  +_____o___+__.___-___ | ___* out4  
   x                     \ /     |  
  in7 mm7                 \    (Rot6)  
                         / \     |  
  in1 mm1  +_____o___+__o___+___ | ___* out0  
   x              \ /            |  
  in6 mm6          /             |  
                  / \            |  
  in2 mm2  +_____.___-___________o____* out2  
   x  
  in5 mm5  
   
  <---------Stage2 =odd part=---------------->  
   
  mm7*___._________.___-___[xSqrt2]___* out3  
         |          \ /  
       (Rot3)        \  
         |          / \  
  mm5*__ | ___o____o___+___.___-______* out7  
         |    |             \ /  
         |  (Rot1)           \  
         |    |             / \  
  mm6*__ |____.____o___+___o___+______* out1  
         |          \ /  
         |           /  
         |          / \  
  mm4*___o_________.___-___[xSqrt2]___* out5  
   
   
   
     Alternative schematics for stage 2:  
     -----------------------------------  
   
  mm7 *___[xSqrt2]____o___+____o_______* out1  
                       \ /     |  
                        /    (Rot1)  
                       / \     |  
  mm6 *____o___+______.___-___ | __.___* out5  
            \ /                |   |  
             /                 |   |  
            / \                |   |  
  mm5 *____.___-______.___-____.__ | __* out7  
                       \ /         |  
                        \        (Rot3)  
                       / \         |  
  mm4 *___[xSqrt2]____o___+________o___* out3  
   
 */  
Legend:
Removed from v.1984  
changed lines
  Added in v.1985
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4