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

Diff of /branches/dev-api-4/xvidcore/src/motion/motion_comp.c

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

revision 118, Sat Apr 13 16:30:02 2002 UTC revision 652, Sun Nov 17 00:35:33 2002 UTC
# Line 1  Line 1 
1  // 14.04.2002   bframe compensation  /*****************************************************************************
2     *
3     *  XVID MPEG-4 VIDEO CODEC
4     *  - Motion Compensation module -
5     *
6     *  Copyright(C) 2002 Peter Ross <pross@xvid.org>
7     *
8     *  This file is part of XviD, a free MPEG-4 video encoder/decoder
9     *
10     *  XviD is free software; you can redistribute it and/or modify it
11     *  under the terms of the GNU General Public License as published by
12     *  the Free Software Foundation; either version 2 of the License, or
13     *  (at your option) any later version.
14     *
15     *  This program is distributed in the hope that it will be useful,
16     *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18     *  GNU General Public License for more details.
19     *
20     *  You should have received a copy of the GNU General Public License
21     *  along with this program; if not, write to the Free Software
22     *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23     *
24     *  Under section 8 of the GNU General Public License, the copyright
25     *  holders of XVID explicitly forbid distribution in the following
26     *  countries:
27     *
28     *    - Japan
29     *    - United States of America
30     *
31     *  Linking XviD statically or dynamically with other modules is making a
32     *  combined work based on XviD.  Thus, the terms and conditions of the
33     *  GNU General Public License cover the whole combination.
34     *
35     *  As a special exception, the copyright holders of XviD give you
36     *  permission to link XviD with independent modules that communicate with
37     *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38     *  license terms of these independent modules, and to copy and distribute
39     *  the resulting combined work under terms of your choice, provided that
40     *  every copy of the combined work is accompanied by a complete copy of
41     *  the source code of XviD (the version of XviD used to produce the
42     *  combined work), being distributed under the terms of the GNU General
43     *  Public License plus this exception.  An independent module is a module
44     *  which is not derived from or based on XviD.
45     *
46     *  Note that people who make modified versions of XviD are not obligated
47     *  to grant this special exception for their modified versions; it is
48     *  their choice whether to do so.  The GNU General Public License gives
49     *  permission to release a modified version without this exception; this
50     *  exception also makes it possible to release a modified version which
51     *  carries forward this exception.
52     *
53     * $Id: motion_comp.c,v 1.15 2002-11-17 00:32:06 edgomez Exp $
54     *
55     *************************************************************************/
56    
57  #include "../encoder.h"  #include "../encoder.h"
58  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
# Line 9  Line 63 
63  #define ABS(X) (((X)>0)?(X):-(X))  #define ABS(X) (((X)>0)?(X):-(X))
64  #define SIGN(X) (((X)>0)?1:-1)  #define SIGN(X) (((X)>0)?1:-1)
65    
66  static __inline void compensate8x8_halfpel(  static __inline void
67                                  int16_t * const dct_codes,  compensate8x8_halfpel(int16_t * const dct_codes,
68                                  uint8_t * const cur,                                  uint8_t * const cur,
69                                  const uint8_t * const ref,                                  const uint8_t * const ref,
70                                  const uint8_t * const refh,                                  const uint8_t * const refh,
71                                  const uint8_t * const refv,                                  const uint8_t * const refv,
72                                  const uint8_t * const refhv,                                  const uint8_t * const refhv,
73                                  const uint32_t x, const uint32_t y,                                            const uint32_t x,
74                                  const int32_t dx,  const int dy,                                            const uint32_t y,
75                                              const int32_t dx,
76                                              const int dy,
77                                  const uint32_t stride)                                  const uint32_t stride)
78  {  {
79          int32_t ddx,ddy;          int32_t ddx,ddy;
# Line 28  Line 84 
84                  ddx = dx/2;                  ddx = dx/2;
85                  ddy = dy/2;                  ddy = dy/2;
86                  transfer_8to16sub(dct_codes, cur + y*stride + x,                  transfer_8to16sub(dct_codes, cur + y*stride + x,
87                                  ref + (y+ddy)*stride + x+ddx, stride);                                                    ref + (int) ((y + ddy) * stride + x + ddx), stride);
88                  break;                  break;
89    
90      case 1 :      case 1 :
91                  ddx = dx/2;                  ddx = dx/2;
92                  ddy = (dy-1)/2;                  ddy = (dy-1)/2;
93                  transfer_8to16sub(dct_codes, cur + y*stride + x,                  transfer_8to16sub(dct_codes, cur + y*stride + x,
94                                  refv + (y+ddy)*stride + x+ddx, stride);                                                    refv + (int) ((y + ddy) * stride + x + ddx), stride);
95                  break;                  break;
96    
97      case 2 :      case 2 :
98                  ddx = (dx-1)/2;                  ddx = (dx-1)/2;
99                  ddy = dy/2;                  ddy = dy/2;
100                  transfer_8to16sub(dct_codes, cur + y*stride + x,                  transfer_8to16sub(dct_codes, cur + y*stride + x,
101                                  refh + (y+ddy)*stride + x+ddx, stride);                                                    refh + (int) ((y + ddy) * stride + x + ddx), stride);
102                  break;                  break;
103    
104          default :       // case 3:          default :       // case 3:
105                  ddx = (dx-1)/2;                  ddx = (dx-1)/2;
106                  ddy = (dy-1)/2;                  ddy = (dy-1)/2;
107                  transfer_8to16sub(dct_codes, cur + y*stride + x,                  transfer_8to16sub(dct_codes, cur + y*stride + x,
108                                  refhv + (y+ddy)*stride + x+ddx, stride);                                                    refhv + (int) ((y + ddy) * stride + x + ddx), stride);
109                  break;                  break;
110      }      }
111  }  }
112    
113    
114    
115  void MBMotionCompensation(  void
116          MACROBLOCK * const mb,  MBMotionCompensation(MACROBLOCK * const mb,
117          const uint32_t i,          const uint32_t i,
118          const uint32_t j,          const uint32_t j,
119          const IMAGE * const ref,          const IMAGE * const ref,
# Line 75  Line 131 
131                  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };                  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
132    
133    
134          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q)          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) {
         {  
135                  int32_t dx = mb->mvs[0].x;                  int32_t dx = mb->mvs[0].x;
136                  int32_t dy = mb->mvs[0].y;                  int32_t dy = mb->mvs[0].y;
137    
138                  compensate8x8_halfpel(&dct_codes[0*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                  compensate8x8_halfpel(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
139                                        16*i,     16*j,     dx, dy, edged_width);                                                            refv->y, refhv->y, 16 * i, 16 * j, dx, dy,
140                  compensate8x8_halfpel(&dct_codes[1*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                                                            edged_width);
141                                        16*i + 8, 16*j,     dx, dy, edged_width);                  compensate8x8_halfpel(&dct_codes[1 * 64], cur->y, ref->y, refh->y,
142                  compensate8x8_halfpel(&dct_codes[2*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                                                            refv->y, refhv->y, 16 * i + 8, 16 * j, dx, dy,
143                                        16*i,     16*j + 8, dx, dy, edged_width);                                                            edged_width);
144                  compensate8x8_halfpel(&dct_codes[3*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                  compensate8x8_halfpel(&dct_codes[2 * 64], cur->y, ref->y, refh->y,
145                                        16*i + 8, 16*j + 8, dx, dy, edged_width);                                                            refv->y, refhv->y, 16 * i, 16 * j + 8, dx, dy,
146                                                              edged_width);
147                    compensate8x8_halfpel(&dct_codes[3 * 64], cur->y, ref->y, refh->y,
148                                                              refv->y, refhv->y, 16 * i + 8, 16 * j + 8, dx,
149                                                              dy, edged_width);
150    
151                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;
152                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;
153    
154                  /* uv-image-based compensation                  /* uv-image-based compensation */
                    compensate8x8_halfpel(dct_codes[4], cur->u, ref->u, refh->u, refv->u, refhv->u,  
                    8*i, 8*j, dx, dy, edged_width/2);  
                    compensate8x8_halfpel(dct_codes[5], cur->v, ref->v, refh->v, refv->v, refhv->v,  
                    8*i, 8*j, dx, dy, edged_width/2);            */  
155    
156                  /* uv-block-based compensation */                  interpolate8x8_switch(refv->u, ref->u, 8 * i, 8 * j, dx, dy,
157                  interpolate8x8_switch(refv->u, ref->u, 8*i, 8*j, dx, dy, edged_width/2, rounding);                                                            edged_width / 2, rounding);
158                  transfer_8to16sub(&dct_codes[4*64],                  transfer_8to16sub(&dct_codes[4*64],
159                                    cur->u + 8*j*edged_width/2 + 8*i,                                    cur->u + 8*j*edged_width/2 + 8*i,
160                                    refv->u + 8*j*edged_width/2 + 8*i, edged_width/2);                                                    refv->u + 8 * j * edged_width / 2 + 8 * i,
161                                                      edged_width / 2);
162    
163                  interpolate8x8_switch(refv->v, ref->v, 8*i, 8*j, dx, dy, edged_width/2, rounding);                  interpolate8x8_switch(refv->v, ref->v, 8 * i, 8 * j, dx, dy,
164                                                              edged_width / 2, rounding);
165                  transfer_8to16sub(&dct_codes[5*64],                  transfer_8to16sub(&dct_codes[5*64],
166                                    cur->v + 8*j*edged_width/2 + 8*i,                                    cur->v + 8*j*edged_width/2 + 8*i,
167                                    refv->v + 8*j*edged_width/2 + 8*i, edged_width/2);                                                    refv->v + 8 * j * edged_width / 2 + 8 * i,
168                                                      edged_width / 2);
169    
170          }          } else                                          // mode == MODE_INTER4V
         else    // mode == MODE_INTER4V  
171          {          {
172                  int32_t sum, dx, dy;                  int32_t sum, dx, dy;
173    
174                  compensate8x8_halfpel(&dct_codes[0*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                  compensate8x8_halfpel(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
175                                        16*i,     16*j,     mb->mvs[0].x, mb->mvs[0].y, edged_width);                                                            refv->y, refhv->y, 16 * i, 16 * j, mb->mvs[0].x,
176                  compensate8x8_halfpel(&dct_codes[1*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                                                            mb->mvs[0].y, edged_width);
177                                        16*i + 8, 16*j,     mb->mvs[1].x, mb->mvs[1].y, edged_width);                  compensate8x8_halfpel(&dct_codes[1 * 64], cur->y, ref->y, refh->y,
178                  compensate8x8_halfpel(&dct_codes[2*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                                                            refv->y, refhv->y, 16 * i + 8, 16 * j,
179                                        16*i,     16*j + 8, mb->mvs[2].x, mb->mvs[2].y, edged_width);                                                            mb->mvs[1].x, mb->mvs[1].y, edged_width);
180                  compensate8x8_halfpel(&dct_codes[3*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                  compensate8x8_halfpel(&dct_codes[2 * 64], cur->y, ref->y, refh->y,
181                                        16*i + 8, 16*j + 8, mb->mvs[3].x, mb->mvs[3].y, edged_width);                                                            refv->y, refhv->y, 16 * i, 16 * j + 8,
182                                                              mb->mvs[2].x, mb->mvs[2].y, edged_width);
183                    compensate8x8_halfpel(&dct_codes[3 * 64], cur->y, ref->y, refh->y,
184                                                              refv->y, refhv->y, 16 * i + 8, 16 * j + 8,
185                                                              mb->mvs[3].x, mb->mvs[3].y, edged_width);
186    
187                  sum = mb->mvs[0].x + mb->mvs[1].x + mb->mvs[2].x + mb->mvs[3].x;                  sum = mb->mvs[0].x + mb->mvs[1].x + mb->mvs[2].x + mb->mvs[3].x;
188                  dx = (sum ? SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) : 0);                  dx = (sum ? SIGN(sum) *
189                              (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) : 0);
190    
191                  sum = mb->mvs[0].y + mb->mvs[1].y + mb->mvs[2].y + mb->mvs[3].y;                  sum = mb->mvs[0].y + mb->mvs[1].y + mb->mvs[2].y + mb->mvs[3].y;
192                  dy = (sum ? SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) : 0);                  dy = (sum ? SIGN(sum) *
193                              (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) : 0);
                 /* uv-image-based compensation  
                    compensate8x8_halfpel(dct_codes[4], cur->u, ref->u, refh->u, refv->u, refhv->u,  
                    8*i, 8*j, dx, dy, edged_width/2);  
                    compensate8x8_halfpel(dct_codes[5], cur->v, ref->v, refh->v, refv->v, refhv->v,  
                    8*i, 8*j, dx, dy, edged_width/2);            */  
194    
195                  /* uv-block-based compensation */                  /* uv-block-based compensation */
196                  interpolate8x8_switch(refv->u, ref->u, 8*i, 8*j, dx, dy, edged_width/2, rounding);                  interpolate8x8_switch(refv->u, ref->u, 8 * i, 8 * j, dx, dy,
197                                                              edged_width / 2, rounding);
198                  transfer_8to16sub(&dct_codes[4*64],                  transfer_8to16sub(&dct_codes[4*64],
199                                    cur->u + 8*j*edged_width/2 + 8*i,                                    cur->u + 8*j*edged_width/2 + 8*i,
200                                    refv->u + 8*j*edged_width/2 + 8*i, edged_width/2);                                                    refv->u + 8 * j * edged_width / 2 + 8 * i,
201                                                      edged_width / 2);
202    
203                  interpolate8x8_switch(refv->v, ref->v, 8*i, 8*j, dx, dy, edged_width/2, rounding);                  interpolate8x8_switch(refv->v, ref->v, 8 * i, 8 * j, dx, dy,
204                                                              edged_width / 2, rounding);
205                  transfer_8to16sub(&dct_codes[5*64],                  transfer_8to16sub(&dct_codes[5*64],
206                                    cur->v + 8*j*edged_width/2 + 8*i,                                    cur->v + 8*j*edged_width/2 + 8*i,
207                                    refv->v + 8*j*edged_width/2 + 8*i, edged_width/2);                                                    refv->v + 8 * j * edged_width / 2 + 8 * i,
   
         }  
 }  
   
   
   
 void MBMotionCompensationBVOP(  
                         MBParam * pParam,  
                         MACROBLOCK * const mb,  
                     const uint32_t i,  
                         const uint32_t j,  
                         IMAGE * const cur,  
                     const IMAGE * const f_ref,  
                         const IMAGE * const f_refh,  
                     const IMAGE * const f_refv,  
                         const IMAGE * const f_refhv,  
                     const IMAGE * const b_ref,  
                         const IMAGE * const b_refh,  
                     const IMAGE * const b_refv,  
                         const IMAGE * const b_refhv,  
                     int16_t dct_codes[][64])  
 {  
         static const uint32_t roundtab[16] =  
                 { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };  
   
         const int32_t edged_width = pParam->edged_width;  
         int32_t dx, dy;  
         int32_t b_dx, b_dy;  
         int x = i;  
         int y = j;  
   
   
   
         switch(mb->mode)  
         {  
         case MODE_FORWARD :  
                 dx = mb->mvs[0].x;  
                 dy = mb->mvs[0].y;  
   
                 transfer_8to16sub_c(  
                         dct_codes[0],  
                         cur->y + (j*16)*edged_width + (i*16),  
                         get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         i*16, j*16, 1, dx, dy, edged_width),  
                         edged_width);  
   
                 transfer_8to16sub(  
                         dct_codes[1],  
                         cur->y + (j*16)*edged_width + (i*16+8),  
                         get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         i*16+8, j*16, 1, dx, dy, edged_width),  
                         edged_width);  
   
                 transfer_8to16sub_c(  
                         dct_codes[2],  
                         cur->y + (j*16+8)*edged_width + (i*16),  
                         get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         i*16, j*16+8, 1, dx, dy, edged_width),  
                         edged_width);  
   
                 transfer_8to16sub(  
                         dct_codes[3],  
                         cur->y + (j*16+8)*edged_width + (i*16+8),  
                         get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         i*16+8, j*16+8, 1, dx, dy, edged_width),  
                         edged_width);  
   
   
                 dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;  
                 dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;  
   
                 /* uv-image-based compensation */  
                 compensate8x8_halfpel(dct_codes[4], cur->u, f_ref->u, f_refh->u, f_refv->u, f_refhv->u,  
                                                                 8*i, 8*j, dx, dy, edged_width/2);  
                 compensate8x8_halfpel(dct_codes[5], cur->v, f_ref->v, f_refh->v, f_refv->v, f_refhv->v,  
                                                                 8*i, 8*j, dx, dy, edged_width/2);  
   
                 break;  
   
         case MODE_BACKWARD :  
                 b_dx = mb->b_mvs[0].x;  
                 b_dy = mb->b_mvs[0].y;  
   
                 transfer_8to16sub_c(  
                         dct_codes[0],  
                         cur->y + (j*16)*edged_width + (i*16),  
                         get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         i*16, j*16, 1, b_dx, b_dy, edged_width),  
                         edged_width);  
   
                 transfer_8to16sub(  
                         dct_codes[1],  
                         cur->y + (j*16)*edged_width + (i*16+8),  
                         get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         i*16+8, j*16, 1, b_dx, b_dy, edged_width),  
                         edged_width);  
   
                 transfer_8to16sub_c(  
                         dct_codes[2],  
                         cur->y + (j*16+8)*edged_width + (i*16),  
                         get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         i*16, j*16+8, 1, b_dx, b_dy, edged_width),  
                         edged_width);  
   
                 transfer_8to16sub(  
                         dct_codes[3],  
                         cur->y + (j*16+8)*edged_width + (i*16+8),  
                         get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         i*16+8, j*16+8, 1, b_dx, b_dy, edged_width),  
                         edged_width);  
   
                 b_dx = (b_dx & 3) ? (b_dx >> 1) | 1 : b_dx / 2;  
                 b_dy = (b_dy & 3) ? (b_dy >> 1) | 1 : b_dy / 2;  
   
                 /* uv-image-based compensation */  
                 compensate8x8_halfpel(dct_codes[4], cur->u,  
                                         b_ref->u, b_refh->u, b_refv->u, b_refhv->u,  
                                         8*i, 8*j, b_dx, b_dy, edged_width/2);  
                 compensate8x8_halfpel(dct_codes[5], cur->v,  
                                         b_ref->v, b_refh->v, b_refv->v, b_refhv->v,  
                                         8*i, 8*j, b_dx, b_dy, edged_width/2);  
   
                 break;  
   
   
         case MODE_INTERPOLATE :  
                 dx = mb->mvs[0].x;  
                 dy = mb->mvs[0].y;  
                 b_dx = mb->b_mvs[0].x;  
                 b_dy = mb->b_mvs[0].y;  
   
                 transfer_8to16sub2_c(  
                                 dct_codes[0],  
                                 cur->y + (i*16) + (j*16)*edged_width,  
                                 get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         16*i, 16*j, 1, dx, dy, edged_width),  
                                 get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         16*i, 16*j, 1, b_dx, b_dy, edged_width),  
                                 edged_width);  
   
                 transfer_8to16sub2_c(  
                                 dct_codes[1],  
                                 cur->y + (i*16+8) + (j*16)*edged_width,  
                                 get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         16*i+8, 16*j, 1, dx, dy, edged_width),  
                                 get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         16*i+8, 16*j, 1, b_dx, b_dy, edged_width),  
                                 edged_width);  
   
                 transfer_8to16sub2_c(  
                                 dct_codes[2],  
                                 cur->y + (i*16) + (j*16+8)*edged_width,  
                                 get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         16*i, 16*j+8, 1, dx, dy, edged_width),  
                                 get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         16*i, 16*j+8, 1, b_dx, b_dy, edged_width),  
                                 edged_width);  
   
                 transfer_8to16sub2_c(  
                                 dct_codes[3],  
                                 cur->y + (i*16+8) + (j*16+8)*edged_width,  
                                 get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
                                                         16*i + 8, 16*j + 8, 1, dx, dy, edged_width),  
                                 get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
                                                         16*i + 8, 16*j + 8, 1, b_dx, b_dy, edged_width),  
                                 edged_width);  
   
   
                 dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;  
                 dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;  
   
                 b_dx = (b_dx & 3) ? (b_dx >> 1) | 1 : b_dx / 2;  
                 b_dy = (b_dy & 3) ? (b_dy >> 1) | 1 : b_dy / 2;  
   
                 transfer_8to16sub2_c(  
                                 dct_codes[4],  
                                 cur->u + (y*8)*edged_width/2 + (x*8),  
                                 get_ref(f_ref->u, f_refh->u, f_refv->u, f_refhv->u,  
                                                         8*i, 8*j, 1, dx, dy, edged_width/2),  
                                 get_ref(b_ref->u, b_refh->u, b_refv->u, b_refhv->u,  
                                                         8*i, 8*j, 1, b_dx, b_dy, edged_width/2),  
                                 edged_width/2);  
   
                 transfer_8to16sub2_c(  
                                 dct_codes[5],  
                                 cur->v + (y*8)*edged_width/2 + (x*8),  
                                 get_ref(f_ref->v, f_refh->v, f_refv->v, f_refhv->v,  
                                                         8*i, 8*j, 1, dx, dy, edged_width/2),  
                                 get_ref(b_ref->v, b_refh->v, b_refv->v, b_refhv->v,  
                                                         8*i, 8*j, 1, b_dx, b_dy, edged_width/2),  
208                                  edged_width/2);                                  edged_width/2);
   
                 break;  
   
         case MODE_DIRECT :  
                 // todo  
                 break;  
209          }          }
   
210  }  }
   
Legend:
Removed from v.118  
changed lines
  Added in v.652
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4