[svn] / branches / dev-api-4 / xvidcore / src / utils / mbtransquant.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/src/utils/mbtransquant.c

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

revision 677, Tue Nov 26 23:44:11 2002 UTC revision 851, Sat Feb 15 15:22:19 2003 UTC
# Line 1  Line 1 
1  /*****************************************************************************   /******************************************************************************
2   *    *                                                                            *
3   *  XVID MPEG-4 VIDEO CODEC    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
4   *  - MacroBlock transfer and quantization -    *                                                                            *
5   *    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
6   *  Copyright(C) 2002-2001 Christoph Lampert <gruel@web.de>    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
7   *               2002-2001 Michael Militzer <isibaar@xvid.org>    *  software module in hardware or software products are advised that its     *
8   *               2002-2001 Peter Ross <pross@xvid.org>    *  use may infringe existing patents or copyrights, and any such use         *
9   *               2002      Daniel Smith <danielsmith@astroboymail.com>    *  would be at such party's own risk.  The original developer of this        *
10   *    *  software module and his/her company, and subsequent editors and their     *
11   *  This file is part of XviD, a free MPEG-4 video encoder/decoder    *  companies, will have no liability for use of this software or             *
12   *    *  modifications or derivatives thereof.                                     *
13   *  XviD is free software; you can redistribute it and/or modify it    *                                                                            *
14   *  under the terms of the GNU General Public License as published by    *  XviD is free software; you can redistribute it and/or modify it           *
15   *  the Free Software Foundation; either version 2 of the License, or    *  under the terms of the GNU General Public License as published by         *
16   *  (at your option) any later version.    *  the Free Software Foundation; either version 2 of the License, or         *
17   *    *  (at your option) any later version.                                       *
18   *  This program is distributed in the hope that it will be useful,    *                                                                            *
19   *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *  XviD is distributed in the hope that it will be useful, but               *
20   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
21   *  GNU General Public License for more details.    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
22   *    *  GNU General Public License for more details.                              *
23   *  You should have received a copy of the GNU General Public License    *                                                                            *
24   *  along with this program; if not, write to the Free Software    *  You should have received a copy of the GNU General Public License         *
25   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA    *  along with this program; if not, write to the Free Software               *
26   *    *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
27   *  Under section 8 of the GNU General Public License, the copyright    *                                                                            *
28   *  holders of XVID explicitly forbid distribution in the following    ******************************************************************************/
29   *  countries:  
30   *   /******************************************************************************
31   *    - Japan    *                                                                            *
32   *    - United States of America    *  mbtransquant.c                                                            *
33   *    *                                                                            *
34   *  Linking XviD statically or dynamically with other modules is making a    *  Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au>                    *
35   *  combined work based on XviD.  Thus, the terms and conditions of the    *  Copyright (C) 2001 - Michael Militzer <isibaar@xvid.org>                  *
36   *  GNU General Public License cover the whole combination.    *                                                                            *
37   *    *  For more information visit the XviD homepage: http://www.xvid.org         *
38   *  As a special exception, the copyright holders of XviD give you    *                                                                            *
39   *  permission to link XviD with independent modules that communicate with    ******************************************************************************/
40   *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the  
41   *  license terms of these independent modules, and to copy and distribute   /******************************************************************************
42   *  the resulting combined work under terms of your choice, provided that    *                                                                            *
43   *  every copy of the combined work is accompanied by a complete copy of    *  Revision history:                                                         *
44   *  the source code of XviD (the version of XviD used to produce the    *                                                                            *
45   *  combined work), being distributed under the terms of the GNU General    *  29.03.2002 interlacing speedup - used transfer strides instead of             *
46   *  Public License plus this exception.  An independent module is a module    *             manual field-to-frame conversion                                                           *
47   *  which is not derived from or based on XviD.    *  26.03.2002 interlacing support - moved transfers outside loops                        *
48   *    *  22.12.2001 get_dc_scaler() moved to common.h                                                          *
49   *  Note that people who make modified versions of XviD are not obligated    *  19.11.2001 introduced coefficient thresholding (Isibaar)                  *
50   *  to grant this special exception for their modified versions; it is    *  17.11.2001 initial version                                                *
51   *  their choice whether to do so.  The GNU General Public License gives    *                                                                            *
52   *  permission to release a modified version without this exception; this    ******************************************************************************/
  *  exception also makes it possible to release a modified version which  
  *  carries forward this exception.  
  *  
  * $Id: mbtransquant.c,v 1.20 2002-11-26 23:44:11 edgomez Exp $  
  *  
  ****************************************************************************/  
53    
54  #include <string.h>  #include <string.h>
55    
# Line 71  Line 65 
65  #include "../quant/quant_h263.h"  #include "../quant/quant_h263.h"
66  #include "../encoder.h"  #include "../encoder.h"
67    
68  #define MIN(X, Y) ((X)<(Y)?(X):(Y))  #include "../image/reduced.h"
 #define MAX(X, Y) ((X)>(Y)?(X):(Y))  
69    
70  #define TOOSMALL_LIMIT 3                /* skip blocks having a coefficient sum below this value */  MBFIELDTEST_PTR MBFieldTest;
71    
72  /* this isnt pretty, but its better than 20 ifdefs */  #define TOOSMALL_LIMIT  1       /* skip blocks having a coefficient sum below this value */
73    
74  void  void
75  MBTransQuantIntra(const MBParam * pParam,  MBTransQuantIntra(const MBParam * pParam,
# Line 90  Line 83 
83    
84          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
85          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
86          uint32_t next_block = stride * 8;          uint32_t next_block = stride * ((frame->global_flags & XVID_REDUCED)?16:8);
87          uint32_t i;          uint32_t i;
88          uint32_t iQuant = frame->quant;          uint32_t iQuant = frame->quant;
89          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
90          IMAGE *pCurrent = &frame->image;          IMAGE *pCurrent = &frame->image;
91    
92            start_timer();
93            if ((frame->global_flags & XVID_REDUCED))
94            {
95                    pY_Cur = pCurrent->y + (y_pos << 5) * stride + (x_pos << 5);
96                    pU_Cur = pCurrent->u + (y_pos << 4) * stride2 + (x_pos << 4);
97                    pV_Cur = pCurrent->v + (y_pos << 4) * stride2 + (x_pos << 4);
98    
99                    filter_18x18_to_8x8(&data[0 * 64], pY_Cur, stride);
100                    filter_18x18_to_8x8(&data[1 * 64], pY_Cur + 16, stride);
101                    filter_18x18_to_8x8(&data[2 * 64], pY_Cur + next_block, stride);
102                    filter_18x18_to_8x8(&data[3 * 64], pY_Cur + next_block + 16, stride);
103                    filter_18x18_to_8x8(&data[4 * 64], pU_Cur, stride2);
104                    filter_18x18_to_8x8(&data[5 * 64], pV_Cur, stride2);
105            }else{
106          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
107          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
108          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
109    
         start_timer();  
110          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
111          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
112          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
113          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
114          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
115          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
116            }
117          stop_transfer_timer();          stop_transfer_timer();
118    
119            /* XXX: rrv+interlacing is buggy */
120          start_timer();          start_timer();
121          pMB->field_dct = 0;          pMB->field_dct = 0;
122          if ((frame->global_flags & XVID_INTERLACING) &&          if ((frame->global_flags & XVID_INTERLACING) &&
# Line 129  Line 137 
137                          start_timer();                          start_timer();
138                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);                          quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
139                          stop_quant_timer();                          stop_quant_timer();
   
                         start_timer();  
                         dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);  
                         stop_iquant_timer();  
140                  } else {                  } else {
141                          start_timer();                          start_timer();
142                          quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);                          quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
143                          stop_quant_timer();                          stop_quant_timer();
144                    }
145    
146                    /* speedup: dont decode when encoding only ivops */
147                    if (pParam->iMaxKeyInterval != 1 || pParam->max_bframes > 0)
148                    {
149                            if (pParam->m_quant_type == H263_QUANT) {
150                                    start_timer();
151                                    dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
152                                    stop_iquant_timer();
153                            } else {
154                          start_timer();                          start_timer();
155                          dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);                          dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
156                          stop_iquant_timer();                          stop_iquant_timer();
# Line 147  Line 160 
160                  idct(&data[i * 64]);                  idct(&data[i * 64]);
161                  stop_idct_timer();                  stop_idct_timer();
162          }          }
163            }
164    
165            /* speedup: dont decode when encoding only ivops */
166            if (pParam->iMaxKeyInterval != 1 || pParam->max_bframes > 0)
167            {
168    
169          if (pMB->field_dct) {          if (pMB->field_dct) {
170                  next_block = stride;                  next_block = stride;
# Line 154  Line 172 
172          }          }
173    
174          start_timer();          start_timer();
175                    if ((frame->global_flags & XVID_REDUCED))
176                    {
177                            copy_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);
178                            copy_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);
179                            copy_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);
180                            copy_upsampled_8x8_16to8(pY_Cur + next_block + 16, &data[3 * 64], stride);
181                            copy_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);
182                            copy_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);
183    
184                    }else{
185          transfer_16to8copy(pY_Cur, &data[0 * 64], stride);          transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
186          transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);          transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
187          transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);          transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
188          transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);          transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);
189          transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);          transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
190          transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);          transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
191                    }
192          stop_transfer_timer();          stop_transfer_timer();
193            }
194    
195  }  }
196    
# Line 177  Line 207 
207    
208          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
209          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
210          uint32_t next_block = stride * 8;          uint32_t next_block = stride * ((frame->global_flags & XVID_REDUCED)?16:8);
211          uint32_t i;          uint32_t i;
212          uint32_t iQuant = frame->quant;          uint32_t iQuant = frame->quant;
213          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
# Line 185  Line 215 
215          uint32_t sum;          uint32_t sum;
216          IMAGE *pCurrent = &frame->image;          IMAGE *pCurrent = &frame->image;
217    
218            if ((frame->global_flags & XVID_REDUCED))
219            {
220                    pY_Cur = pCurrent->y + (y_pos << 5) * stride + (x_pos << 5);
221                    pU_Cur = pCurrent->u + (y_pos << 4) * stride2 + (x_pos << 4);
222                    pV_Cur = pCurrent->v + (y_pos << 4) * stride2 + (x_pos << 4);
223            }else{
224          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);          pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
225          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
226          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
227            }
228    
229          start_timer();          start_timer();
230          pMB->field_dct = 0;          pMB->field_dct = 0;
# Line 199  Line 236 
236          stop_interlacing_timer();          stop_interlacing_timer();
237    
238          for (i = 0; i < 6; i++) {          for (i = 0; i < 6; i++) {
239                    uint32_t increase_limit = (iQuant == 1) ? 1 : 0;
240    
241                  /*                  /*
242                   *  no need to transfer 8->16-bit                   *  no need to transfer 8->16-bit
243                   * (this is performed already in motion compensation)                   * (this is performed already in motion compensation)
# Line 217  Line 256 
256                          stop_quant_timer();                          stop_quant_timer();
257                  }                  }
258    
259                  if ((sum >= TOOSMALL_LIMIT) || (qcoeff[i*64] != 0) ||                  if ((sum >= TOOSMALL_LIMIT + increase_limit) || (qcoeff[i*64] != 0) ||
260                          (qcoeff[i*64+1] != 0) || (qcoeff[i*64+8] != 0)) {                          (qcoeff[i*64+1] != 0) || (qcoeff[i*64+8] != 0)) {
261    
262                          if (pParam->m_quant_type == H263_QUANT) {                          if (pParam->m_quant_type == H263_QUANT) {
# Line 244  Line 283 
283          }          }
284    
285          start_timer();          start_timer();
286            if ((frame->global_flags & XVID_REDUCED))
287            {
288                    if (cbp & 32)
289                            add_upsampled_8x8_16to8(pY_Cur, &data[0 * 64], stride);
290                    if (cbp & 16)
291                            add_upsampled_8x8_16to8(pY_Cur + 16, &data[1 * 64], stride);
292                    if (cbp & 8)
293                            add_upsampled_8x8_16to8(pY_Cur + next_block, &data[2 * 64], stride);
294                    if (cbp & 4)
295                            add_upsampled_8x8_16to8(pY_Cur + 16 + next_block, &data[3 * 64], stride);
296                    if (cbp & 2)
297                            add_upsampled_8x8_16to8(pU_Cur, &data[4 * 64], stride2);
298                    if (cbp & 1)
299                            add_upsampled_8x8_16to8(pV_Cur, &data[5 * 64], stride2);
300            }else{
301          if (cbp & 32)          if (cbp & 32)
302                  transfer_16to8add(pY_Cur, &data[0 * 64], stride);                  transfer_16to8add(pY_Cur, &data[0 * 64], stride);
303          if (cbp & 16)          if (cbp & 16)
# Line 256  Line 310 
310                  transfer_16to8add(pU_Cur, &data[4 * 64], stride2);                  transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
311          if (cbp & 1)          if (cbp & 1)
312                  transfer_16to8add(pV_Cur, &data[5 * 64], stride2);                  transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
313            }
314          stop_transfer_timer();          stop_transfer_timer();
315    
316          return cbp;          return cbp;
# Line 388  Line 443 
443  MBQuantIntra(const MBParam * pParam,  MBQuantIntra(const MBParam * pParam,
444                           FRAMEINFO * frame,                           FRAMEINFO * frame,
445                           MACROBLOCK *pMB,                           MACROBLOCK *pMB,
446                           int16_t data[6 * 64],                       int16_t qcoeff[6 * 64],
447                       int16_t qcoeff[6 * 64])                           int16_t data[6*64])
448  {  {
449          int i;          int i;
450          int iQuant = frame->quant;          int iQuant = frame->quant;
# Line 462  Line 517 
517                          stop_quant_timer();                          stop_quant_timer();
518                  }                  }
519    
520                  if (sum >= TOOSMALL_LIMIT) {    /* skip block ? */                  if (sum >= TOOSMALL_LIMIT) {    // skip block ?
521                          cbp |= 1 << (5 - i);                          cbp |= 1 << (5 - i);
522                  }                  }
523          }          }
# Line 582  Line 637 
637    
638    
639    
640  /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */  /* permute block and return field dct choice */
641    
642    
643  uint32_t  uint32_t
644  MBDecideFieldDCT(int16_t data[6 * 64])  MBDecideFieldDCT(int16_t data[6 * 64])
645  {  {
646            uint32_t field = MBFieldTest(data);
647    
648            if (field) {
649                    MBFrameToField(data);
650            }
651    
652            return field;
653    }
654    
655    
656    /* if sum(diff between field lines) < sum(diff between frame lines), use field dct */
657    
658    uint32_t
659    MBFieldTest_c(int16_t data[6 * 64])
660    {
661          const uint8_t blocks[] =          const uint8_t blocks[] =
662                  { 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };                  { 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };
663          const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };          const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };
# Line 622  Line 691 
691                  }                  }
692          }          }
693    
694          if (frame > (field + 350)) {          return (frame >= (field + 350));
                 MBFrameToField(data);  
         }  
   
         return (frame > (field + 350));  
695  }  }
696    
697    
# Line 642  Line 707 
707    
708          /* left blocks */          /* left blocks */
709    
710          /* 1=2, 2=4, 4=8, 8=1 */          // 1=2, 2=4, 4=8, 8=1
711          MOVLINE(tmp, LINE(0, 1));          MOVLINE(tmp, LINE(0, 1));
712          MOVLINE(LINE(0, 1), LINE(0, 2));          MOVLINE(LINE(0, 1), LINE(0, 2));
713          MOVLINE(LINE(0, 2), LINE(0, 4));          MOVLINE(LINE(0, 2), LINE(0, 4));
714          MOVLINE(LINE(0, 4), LINE(2, 0));          MOVLINE(LINE(0, 4), LINE(2, 0));
715          MOVLINE(LINE(2, 0), tmp);          MOVLINE(LINE(2, 0), tmp);
716    
717          /* 3=6, 6=12, 12=9, 9=3 */          // 3=6, 6=12, 12=9, 9=3
718          MOVLINE(tmp, LINE(0, 3));          MOVLINE(tmp, LINE(0, 3));
719          MOVLINE(LINE(0, 3), LINE(0, 6));          MOVLINE(LINE(0, 3), LINE(0, 6));
720          MOVLINE(LINE(0, 6), LINE(2, 4));          MOVLINE(LINE(0, 6), LINE(2, 4));
721          MOVLINE(LINE(2, 4), LINE(2, 1));          MOVLINE(LINE(2, 4), LINE(2, 1));
722          MOVLINE(LINE(2, 1), tmp);          MOVLINE(LINE(2, 1), tmp);
723    
724          /* 5=10, 10=5 */          // 5=10, 10=5
725          MOVLINE(tmp, LINE(0, 5));          MOVLINE(tmp, LINE(0, 5));
726          MOVLINE(LINE(0, 5), LINE(2, 2));          MOVLINE(LINE(0, 5), LINE(2, 2));
727          MOVLINE(LINE(2, 2), tmp);          MOVLINE(LINE(2, 2), tmp);
728    
729          /* 7=14, 14=13, 13=11, 11=7 */          // 7=14, 14=13, 13=11, 11=7
730          MOVLINE(tmp, LINE(0, 7));          MOVLINE(tmp, LINE(0, 7));
731          MOVLINE(LINE(0, 7), LINE(2, 6));          MOVLINE(LINE(0, 7), LINE(2, 6));
732          MOVLINE(LINE(2, 6), LINE(2, 5));          MOVLINE(LINE(2, 6), LINE(2, 5));
# Line 670  Line 735 
735    
736          /* right blocks */          /* right blocks */
737    
738          /* 1=2, 2=4, 4=8, 8=1 */          // 1=2, 2=4, 4=8, 8=1
739          MOVLINE(tmp, LINE(1, 1));          MOVLINE(tmp, LINE(1, 1));
740          MOVLINE(LINE(1, 1), LINE(1, 2));          MOVLINE(LINE(1, 1), LINE(1, 2));
741          MOVLINE(LINE(1, 2), LINE(1, 4));          MOVLINE(LINE(1, 2), LINE(1, 4));
742          MOVLINE(LINE(1, 4), LINE(3, 0));          MOVLINE(LINE(1, 4), LINE(3, 0));
743          MOVLINE(LINE(3, 0), tmp);          MOVLINE(LINE(3, 0), tmp);
744    
745          /* 3=6, 6=12, 12=9, 9=3 */          // 3=6, 6=12, 12=9, 9=3
746          MOVLINE(tmp, LINE(1, 3));          MOVLINE(tmp, LINE(1, 3));
747          MOVLINE(LINE(1, 3), LINE(1, 6));          MOVLINE(LINE(1, 3), LINE(1, 6));
748          MOVLINE(LINE(1, 6), LINE(3, 4));          MOVLINE(LINE(1, 6), LINE(3, 4));
749          MOVLINE(LINE(3, 4), LINE(3, 1));          MOVLINE(LINE(3, 4), LINE(3, 1));
750          MOVLINE(LINE(3, 1), tmp);          MOVLINE(LINE(3, 1), tmp);
751    
752          /* 5=10, 10=5 */          // 5=10, 10=5
753          MOVLINE(tmp, LINE(1, 5));          MOVLINE(tmp, LINE(1, 5));
754          MOVLINE(LINE(1, 5), LINE(3, 2));          MOVLINE(LINE(1, 5), LINE(3, 2));
755          MOVLINE(LINE(3, 2), tmp);          MOVLINE(LINE(3, 2), tmp);
756    
757          /* 7=14, 14=13, 13=11, 11=7 */          // 7=14, 14=13, 13=11, 11=7
758          MOVLINE(tmp, LINE(1, 7));          MOVLINE(tmp, LINE(1, 7));
759          MOVLINE(LINE(1, 7), LINE(3, 6));          MOVLINE(LINE(1, 7), LINE(3, 6));
760          MOVLINE(LINE(3, 6), LINE(3, 5));          MOVLINE(LINE(3, 6), LINE(3, 5));

Legend:
Removed from v.677  
changed lines
  Added in v.851

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