[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

trunk/xvidcore/src/motion/motion_comp.c revision 118, Sat Apr 13 16:30:02 2002 UTC branches/dev-api-4/xvidcore/src/motion/motion_comp.c revision 935, Sat Mar 22 13:41:11 2003 UTC
# Line 1  Line 1 
1    // 30.10.2002   corrected qpel chroma rounding
2    // 04.10.2002   added qpel support to MBMotionCompensation
3    // 01.05.2002   updated MBMotionCompensationBVOP
4  // 14.04.2002   bframe compensation  // 14.04.2002   bframe compensation
5    
6    #include <stdio.h>
7    
8  #include "../encoder.h"  #include "../encoder.h"
9  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
10  #include "../image/interpolate8x8.h"  #include "../image/interpolate8x8.h"
11    #include "../image/reduced.h"
12  #include "../utils/timer.h"  #include "../utils/timer.h"
13  #include "motion.h"  #include "motion.h"
14    
15    #ifndef ABS
16  #define ABS(X) (((X)>0)?(X):-(X))  #define ABS(X) (((X)>0)?(X):-(X))
17    #endif
18    #ifndef SIGN
19  #define SIGN(X) (((X)>0)?1:-1)  #define SIGN(X) (((X)>0)?1:-1)
20    #endif
21    
22    #ifndef RSHIFT
23    #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
24    #endif
25    
26    /* assume b>0 */
27    #ifndef RDIV
28    #define RDIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
29    #endif
30    
31    
32    /* This is borrowed from        decoder.c   */
33    static __inline int gmc_sanitize(int value, int quarterpel, int fcode)
34    {
35            int length = 1 << (fcode+4);
36    
37    //      if (quarterpel) value *= 2;
38    
39            if (value < -length)
40                    return -length;
41            else if (value >= length)
42                    return length-1;
43            else return value;
44    }
45    
46    /* And this is borrowed from   bitstream.c  until we find a common solution */
47    
48    static uint32_t __inline
49    log2bin(uint32_t value)
50    {
51    /* Changed by Chenm001 */
52    #if !defined(_MSC_VER)
53            int n = 0;
54    
55            while (value) {
56                    value >>= 1;
57                    n++;
58            }
59            return n;
60    #else
61            __asm {
62                    bsr eax, value
63                    inc eax
64            }
65    #endif
66    }
67    
68  static __inline void compensate8x8_halfpel(  
69                                  int16_t * const dct_codes,  static __inline void
70    compensate16x16_interpolate(int16_t * const dct_codes,
71                                  uint8_t * const cur,                                  uint8_t * const cur,
72                                  const uint8_t * const ref,                                  const uint8_t * const ref,
73                                  const uint8_t * const refh,                                  const uint8_t * const refh,
74                                  const uint8_t * const refv,                                  const uint8_t * const refv,
75                                  const uint8_t * const refhv,                                  const uint8_t * const refhv,
76                                  const uint32_t x, const uint32_t y,                                                          uint8_t * const tmp,
77                                  const int32_t dx,  const int dy,                                                          uint32_t x,
78                                  const uint32_t stride)                                                          uint32_t y,
79                                                            const int32_t dx,
80                                                            const int32_t dy,
81                                                            const int32_t stride,
82                                                            const int quarterpel,
83                                                            const int reduced_resolution,
84                                                            const int32_t rounding)
85  {  {
86          int32_t ddx,ddy;          const uint8_t * ptr;
87    
88          switch ( ((dx&1)<<1) + (dy&1) )   // ((dx%2)?2:0)+((dy%2)?1:0)          if (!reduced_resolution) {
     {  
     case 0 :  
                 ddx = dx/2;  
                 ddy = dy/2;  
                 transfer_8to16sub(dct_codes, cur + y*stride + x,  
                                 ref + (y+ddy)*stride + x+ddx, stride);  
                 break;  
89    
90      case 1 :                  if(quarterpel) {
91                  ddx = dx/2;                          if ((dx&3) | (dy&3)) {
92                  ddy = (dy-1)/2;                                  interpolate16x16_quarterpel(tmp - y * stride - x,
93                  transfer_8to16sub(dct_codes, cur + y*stride + x,                                                                                          (uint8_t *) ref, tmp + 32,
94                                  refv + (y+ddy)*stride + x+ddx, stride);                                                                                          tmp + 64, tmp + 96, x, y, dx, dy, stride, rounding);
95                  break;                                  ptr = tmp;
96                            } else ptr =  ref + (y + dy/4)*stride + x + dx/4; // fullpixel position
97    
98      case 2 :                  } else ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
                 ddx = (dx-1)/2;  
                 ddy = dy/2;  
                 transfer_8to16sub(dct_codes, cur + y*stride + x,  
                                 refh + (y+ddy)*stride + x+ddx, stride);  
                 break;  
99    
         default :       // case 3:  
                 ddx = (dx-1)/2;  
                 ddy = (dy-1)/2;  
100                  transfer_8to16sub(dct_codes, cur + y*stride + x,                  transfer_8to16sub(dct_codes, cur + y*stride + x,
101                                  refhv + (y+ddy)*stride + x+ddx, stride);                                                          ptr, stride);
102                  break;                  transfer_8to16sub(dct_codes+64, cur + y * stride + x + 8,
103                                                            ptr + 8, stride);
104                    transfer_8to16sub(dct_codes+128, cur + y * stride + x + 8*stride,
105                                                            ptr + 8*stride, stride);
106                    transfer_8to16sub(dct_codes+192, cur + y * stride + x + 8*stride+8,
107                                                            ptr + 8*stride + 8, stride);
108    
109            } else { //reduced_resolution
110    
111                    x *= 2; y *= 2;
112    
113                    ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
114    
115                    filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
116                    filter_diff_18x18_to_8x8(dct_codes, ptr, stride);
117    
118                    filter_18x18_to_8x8(dct_codes+64, cur+y*stride + x + 16, stride);
119                    filter_diff_18x18_to_8x8(dct_codes+64, ptr + 16, stride);
120    
121                    filter_18x18_to_8x8(dct_codes+128, cur+(y+16)*stride + x, stride);
122                    filter_diff_18x18_to_8x8(dct_codes+128, ptr + 16*stride, stride);
123    
124                    filter_18x18_to_8x8(dct_codes+192, cur+(y+16)*stride + x + 16, stride);
125                    filter_diff_18x18_to_8x8(dct_codes+192, ptr + 16*stride + 16, stride);
126    
127                    transfer32x32_copy(cur + y*stride + x, ptr, stride);
128      }      }
129  }  }
130    
131    static __inline void
132    compensate8x8_interpolate(      int16_t * const dct_codes,
133                                                            uint8_t * const cur,
134                                                            const uint8_t * const ref,
135                                                            const uint8_t * const refh,
136                                                            const uint8_t * const refv,
137                                                            const uint8_t * const refhv,
138                                                            uint8_t * const tmp,
139                                                            uint32_t x,
140                                                            uint32_t y,
141                                                            const int32_t dx,
142                                                            const int32_t dy,
143                                                            const int32_t stride,
144                                                            const int32_t quarterpel,
145                                                            const int reduced_resolution,
146                                                            const int32_t rounding)
147    {
148            const uint8_t * ptr;
149    
150            if (!reduced_resolution) {
151    
152  void MBMotionCompensation(                  if(quarterpel) {
153          MACROBLOCK * const mb,                          if ((dx&3) | (dy&3)) {
154                                    interpolate8x8_quarterpel(tmp - y*stride - x,
155                                                                                    (uint8_t *) ref, tmp + 32,
156                                                                                    tmp + 64, tmp + 96, x, y, dx, dy, stride, rounding);
157                                    ptr = tmp;
158                            } else ptr = ref + (y + dy/4)*stride + x + dx/4; // fullpixel position
159                    } else ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
160    
161                            transfer_8to16sub(dct_codes, cur + y * stride + x, ptr, stride);
162    
163            } else { //reduced_resolution
164    
165                    x *= 2; y *= 2;
166    
167                    ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride);
168    
169                    filter_18x18_to_8x8(dct_codes, cur+y*stride + x, stride);
170                    filter_diff_18x18_to_8x8(dct_codes, ptr, stride);
171    
172                    transfer16x16_copy(cur + y*stride + x, ptr, stride);
173            }
174    }
175    
176    /* XXX: slow, inelegant... */
177    static void
178    interpolate18x18_switch(uint8_t * const cur,
179                                                    const uint8_t * const refn,
180                                                    const uint32_t x,
181                                                    const uint32_t y,
182                                                    const int32_t dx,
183                                                    const int dy,
184                                                    const int32_t stride,
185                                                    const int32_t rounding)
186    {
187            interpolate8x8_switch(cur, refn, x-1, y-1, dx, dy, stride, rounding);
188            interpolate8x8_switch(cur, refn, x+7, y-1, dx, dy, stride, rounding);
189            interpolate8x8_switch(cur, refn, x+9, y-1, dx, dy, stride, rounding);
190    
191            interpolate8x8_switch(cur, refn, x-1, y+7, dx, dy, stride, rounding);
192            interpolate8x8_switch(cur, refn, x+7, y+7, dx, dy, stride, rounding);
193            interpolate8x8_switch(cur, refn, x+9, y+7, dx, dy, stride, rounding);
194    
195            interpolate8x8_switch(cur, refn, x-1, y+9, dx, dy, stride, rounding);
196            interpolate8x8_switch(cur, refn, x+7, y+9, dx, dy, stride, rounding);
197            interpolate8x8_switch(cur, refn, x+9, y+9, dx, dy, stride, rounding);
198    }
199    
200    static void
201    CompensateChroma(       int dx, int dy,
202                                            const int i, const int j,
203                                            IMAGE * const Cur,
204                                            const IMAGE * const Ref,
205                                            uint8_t * const temp,
206                                            int16_t * const coeff,
207                                            const int32_t stride,
208                                            const int rounding,
209                                            const int rrv)
210    { /* uv-block-based compensation */
211    
212            if (!rrv) {
213                    transfer_8to16sub(coeff, Cur->u + 8 * j * stride + 8 * i,
214                                                            interpolate8x8_switch2(temp, Ref->u, 8 * i, 8 * j,
215                                                                                                            dx, dy, stride, rounding),
216                                                            stride);
217                    transfer_8to16sub(coeff + 64, Cur->v + 8 * j * stride + 8 * i,
218                                                            interpolate8x8_switch2(temp, Ref->v, 8 * i, 8 * j,
219                                                                                                            dx, dy, stride, rounding),
220                                                            stride);
221            } else {
222                    uint8_t * current, * reference;
223    
224                    current = Cur->u + 16*j*stride + 16*i;
225                    reference = temp - 16*j*stride - 16*i;
226                    interpolate18x18_switch(reference, Ref->u, 16*i, 16*j, dx, dy, stride, rounding);
227                    filter_18x18_to_8x8(coeff, current, stride);
228                    filter_diff_18x18_to_8x8(coeff, temp, stride);
229                    transfer16x16_copy(current, temp, stride);
230    
231                    current = Cur->v + 16*j*stride + 16*i;
232                    interpolate18x18_switch(reference, Ref->v, 16*i, 16*j, dx, dy, stride, rounding);
233                    filter_18x18_to_8x8(coeff + 64, current, stride);
234                    filter_diff_18x18_to_8x8(coeff + 64, temp, stride);
235                    transfer16x16_copy(current, temp, stride);
236            }
237    }
238    
239    void
240    MBMotionCompensation(MACROBLOCK * const mb,
241          const uint32_t i,          const uint32_t i,
242          const uint32_t j,          const uint32_t j,
243          const IMAGE * const ref,          const IMAGE * const ref,
244          const IMAGE * const refh,          const IMAGE * const refh,
245          const IMAGE * const refv,          const IMAGE * const refv,
246          const IMAGE * const refhv,          const IMAGE * const refhv,
247                                            const IMAGE * const refGMC,
248          IMAGE * const cur,          IMAGE * const cur,
249          int16_t *dct_codes,          int16_t *dct_codes,
250          const uint32_t width,          const uint32_t width,
251          const uint32_t height,          const uint32_t height,
252          const uint32_t edged_width,          const uint32_t edged_width,
253          const uint32_t rounding)                                          const int32_t quarterpel,
254                                            const int reduced_resolution,
255                                            const int32_t rounding)
256  {  {
257          static const uint32_t roundtab[16] =          int32_t dx;
258                  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };          int32_t dy;
259    
260            uint8_t * const tmp = refv->u;
261    
262          if (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q)          if ( (!reduced_resolution) && (mb->mode == MODE_NOT_CODED) ) {  /* quick copy for early SKIP */
263          {  /* early SKIP is only activated in P-VOPs, not in S-VOPs, so mcsel can never be 1 */
264                  int32_t dx = mb->mvs[0].x;  
265                  int32_t dy = mb->mvs[0].y;                  transfer16x16_copy(cur->y + 16 * (i + j * edged_width),
266                                                      ref->y + 16 * (i + j * edged_width),
267                                                      edged_width);
268    
269                    transfer8x8_copy(cur->u + 8 * (i + j * edged_width/2),
270                                                            ref->u + 8 * (i + j * edged_width/2),
271                                                            edged_width / 2);
272                    transfer8x8_copy(cur->v + 8 * (i + j * edged_width/2),
273                                                            ref->v + 8 * (i + j * edged_width/2),
274                                                            edged_width / 2);
275                    return;
276            }
277    
278                  compensate8x8_halfpel(&dct_codes[0*64], cur->y, ref->y, refh->y, refv->y, refhv->y,          if ((mb->mode == MODE_NOT_CODED || mb->mode == MODE_INTER
279                                        16*i,     16*j,     dx, dy, edged_width);                                  || mb->mode == MODE_INTER_Q)) {
                 compensate8x8_halfpel(&dct_codes[1*64], cur->y, ref->y, refh->y, refv->y, refhv->y,  
                                       16*i + 8, 16*j,     dx, dy, edged_width);  
                 compensate8x8_halfpel(&dct_codes[2*64], cur->y, ref->y, refh->y, refv->y, refhv->y,  
                                       16*i,     16*j + 8, dx, dy, edged_width);  
                 compensate8x8_halfpel(&dct_codes[3*64], cur->y, ref->y, refh->y, refv->y, refhv->y,  
                                       16*i + 8, 16*j + 8, dx, dy, edged_width);  
280    
281                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;          /* reduced resolution + GMC:  not possible */
                 dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;  
282    
283                  /* uv-image-based compensation                  if (mb->mcsel) {
                    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);            */  
284    
285                  /* uv-block-based compensation */                          /* call normal routine once, easier than "if (mcsel)"ing all the time */
                 interpolate8x8_switch(refv->u, ref->u, 8*i, 8*j, dx, dy, edged_width/2, rounding);  
                 transfer_8to16sub(&dct_codes[4*64],  
                                   cur->u + 8*j*edged_width/2 + 8*i,  
                                   refv->u + 8*j*edged_width/2 + 8*i, edged_width/2);  
286    
287                  interpolate8x8_switch(refv->v, ref->v, 8*i, 8*j, dx, dy, edged_width/2, rounding);                          transfer_8to16sub(&dct_codes[0*64], cur->y + 16*j*edged_width + 16*i,
288                  transfer_8to16sub(&dct_codes[5*64],                                                                                          refGMC->y + 16*j*edged_width + 16*i, edged_width);
289                                    cur->v + 8*j*edged_width/2 + 8*i,                          transfer_8to16sub(&dct_codes[1*64], cur->y + 16*j*edged_width + 16*i+8,
290                                    refv->v + 8*j*edged_width/2 + 8*i, edged_width/2);                                                                                          refGMC->y + 16*j*edged_width + 16*i+8, edged_width);
291                            transfer_8to16sub(&dct_codes[2*64], cur->y + (16*j+8)*edged_width + 16*i,
292                                                                                            refGMC->y + (16*j+8)*edged_width + 16*i, edged_width);
293                            transfer_8to16sub(&dct_codes[3*64], cur->y + (16*j+8)*edged_width + 16*i+8,
294                                                                                            refGMC->y + (16*j+8)*edged_width + 16*i+8, edged_width);
295    
296          }  /* lumi is needed earlier for mode decision, but chroma should be done block-based, but it isn't, yet. */
297          else    // mode == MODE_INTER4V  
298          {                          transfer_8to16sub(&dct_codes[4 * 64], cur->u + 8 *j*edged_width/2 + 8*i,
299                  int32_t sum, dx, dy;                                                                  refGMC->u + 8 *j*edged_width/2 + 8*i, edged_width/2);
300    
301                  compensate8x8_halfpel(&dct_codes[0*64], cur->y, ref->y, refh->y, refv->y, refhv->y,                          transfer_8to16sub(&dct_codes[5 * 64], cur->v + 8*j* edged_width/2 + 8*i,
302                                        16*i,     16*j,     mb->mvs[0].x, mb->mvs[0].y, edged_width);                                                                  refGMC->v + 8*j* edged_width/2 + 8*i, edged_width/2);
                 compensate8x8_halfpel(&dct_codes[1*64], cur->y, ref->y, refh->y, refv->y, refhv->y,  
                                       16*i + 8, 16*j,     mb->mvs[1].x, mb->mvs[1].y, edged_width);  
                 compensate8x8_halfpel(&dct_codes[2*64], cur->y, ref->y, refh->y, refv->y, refhv->y,  
                                       16*i,     16*j + 8, mb->mvs[2].x, mb->mvs[2].y, edged_width);  
                 compensate8x8_halfpel(&dct_codes[3*64], cur->y, ref->y, refh->y, refv->y, refhv->y,  
                                       16*i + 8, 16*j + 8, mb->mvs[3].x, mb->mvs[3].y, edged_width);  
303    
304                  sum = mb->mvs[0].x + mb->mvs[1].x + mb->mvs[2].x + mb->mvs[3].x;                          return;
305                  dx = (sum ? SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) : 0);                  }
306    
307                  sum = mb->mvs[0].y + mb->mvs[1].y + mb->mvs[2].y + mb->mvs[3].y;                  /* ordinary compensation */
                 dy = (sum ? SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2) : 0);  
308    
309                  /* uv-image-based compensation                  dx = (quarterpel ? mb->qmvs[0].x : mb->mvs[0].x);
310                     compensate8x8_halfpel(dct_codes[4], cur->u, ref->u, refh->u, refv->u, refhv->u,                  dy = (quarterpel ? mb->qmvs[0].y : mb->mvs[0].y);
                    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);            */  
311    
312                  /* uv-block-based compensation */                  if (reduced_resolution) {
313                  interpolate8x8_switch(refv->u, ref->u, 8*i, 8*j, dx, dy, edged_width/2, rounding);                          dx = RRV_MV_SCALEUP(dx);
314                  transfer_8to16sub(&dct_codes[4*64],                          dy = RRV_MV_SCALEUP(dy);
315                                    cur->u + 8*j*edged_width/2 + 8*i,                  }
                                   refv->u + 8*j*edged_width/2 + 8*i, edged_width/2);  
316    
317                  interpolate8x8_switch(refv->v, ref->v, 8*i, 8*j, dx, dy, edged_width/2, rounding);                  compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, ref->y, refh->y,
318                  transfer_8to16sub(&dct_codes[5*64],                                                          refv->y, refhv->y, tmp, 16 * i, 16 * j, dx, dy,
319                                    cur->v + 8*j*edged_width/2 + 8*i,                                                          edged_width, quarterpel, reduced_resolution, rounding);
320                                    refv->v + 8*j*edged_width/2 + 8*i, edged_width/2);  
321                    if (quarterpel) { dx /= 2; dy /= 2; }
322    
323                    dx = (dx >> 1) + roundtab_79[dx & 0x3];
324                    dy = (dy >> 1) + roundtab_79[dy & 0x3];
325    
326            } else {                                        // mode == MODE_INTER4V
327                    int k, sumx = 0, sumy = 0;
328                    const VECTOR * const mvs = (quarterpel ? mb->qmvs : mb->mvs);
329    
330                    for (k = 0; k < 4; k++) {
331                            dx = mvs[k].x;
332                            dy = mvs[k].y;
333                            sumx += quarterpel ? dx/2 : dx;
334                            sumy += quarterpel ? dy/2 : dy;
335    
336                            if (reduced_resolution){
337                                    dx = RRV_MV_SCALEUP(dx);
338                                    dy = RRV_MV_SCALEUP(dy);
339                            }
340    
341                            compensate8x8_interpolate(&dct_codes[k * 64], cur->y, ref->y, refh->y,
342                                                                            refv->y, refhv->y, tmp, 16 * i + 8*(k&1), 16 * j + 8*(k>>1), dx,
343                                                                            dy, edged_width, quarterpel, reduced_resolution, rounding);
344          }          }
345                    dx = (sumx >> 3) + roundtab_76[sumx & 0xf];
346                    dy = (sumy >> 3) + roundtab_76[sumy & 0xf];
347  }  }
348    
349            CompensateChroma(dx, dy, i, j, cur, ref, tmp,
350                                            &dct_codes[4 * 64], edged_width / 2, rounding, reduced_resolution);
351    }
352    
353    
354  void MBMotionCompensationBVOP(  void
355                          MBParam * pParam,  MBMotionCompensationBVOP(MBParam * pParam,
356                          MACROBLOCK * const mb,                          MACROBLOCK * const mb,
357                      const uint32_t i,                      const uint32_t i,
358                          const uint32_t j,                          const uint32_t j,
# Line 165  Line 365 
365                          const IMAGE * const b_refh,                          const IMAGE * const b_refh,
366                      const IMAGE * const b_refv,                      const IMAGE * const b_refv,
367                          const IMAGE * const b_refhv,                          const IMAGE * const b_refhv,
368                      int16_t dct_codes[][64])                                                  int16_t * dct_codes)
369  {  {
370          static const uint32_t roundtab[16] =          const uint32_t edged_width = pParam->edged_width;
371                  { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };          int32_t dx, dy, b_dx, b_dy, sumx, sumy, b_sumx, b_sumy;
372            int k;
373            const int quarterpel = pParam->vol_flags & XVID_QUARTERPEL;
374            const uint8_t * ptr1, * ptr2;
375            uint8_t * const tmp = f_refv->u;
376            const VECTOR * const fmvs = (quarterpel ? mb->qmvs : mb->mvs);
377            const VECTOR * const bmvs = (quarterpel ? mb->b_qmvs : mb->b_mvs);
378    
379          const int32_t edged_width = pParam->edged_width;          switch (mb->mode) {
380          int32_t dx, dy;          case MODE_FORWARD:
381          int32_t b_dx, b_dy;                  dx = fmvs->x; dy = fmvs->y;
         int x = i;  
         int y = j;  
382    
383                    compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, f_ref->y, f_refh->y,
384                                                            f_refv->y, f_refhv->y, tmp, 16 * i, 16 * j, dx,
385                                                            dy, edged_width, quarterpel, 0, 0);
386    
387                    if (quarterpel) { dx /= 2; dy /= 2; }
388    
389          switch(mb->mode)                  CompensateChroma(       (dx >> 1) + roundtab_79[dx & 0x3],
390          {                                                          (dy >> 1) + roundtab_79[dy & 0x3],
391          case MODE_FORWARD :                                                          i, j, cur, f_ref, tmp,
392                  dx = mb->mvs[0].x;                                                          &dct_codes[4 * 64], edged_width / 2, 0, 0);
                 dy = mb->mvs[0].y;  
393    
394                  transfer_8to16sub_c(                  return;
                         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);  
395    
396                  transfer_8to16sub(          case MODE_BACKWARD:
397                          dct_codes[1],                  b_dx = bmvs->x; b_dy = bmvs->y;
                         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);  
398    
399                  transfer_8to16sub_c(                  compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, b_ref->y, b_refh->y,
400                          dct_codes[2],                                                                                  b_refv->y, b_refhv->y, tmp, 16 * i, 16 * j, b_dx,
401                          cur->y + (j*16+8)*edged_width + (i*16),                                                                                  b_dy, edged_width, quarterpel, 0, 0);
402                          get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,  
403                                                          i*16, j*16+8, 1, dx, dy, edged_width),                  if (quarterpel) { b_dx /= 2; b_dy /= 2; }
404                          edged_width);  
405                    CompensateChroma(       (b_dx >> 1) + roundtab_79[b_dx & 0x3],
406                                                            (b_dy >> 1) + roundtab_79[b_dy & 0x3],
407                                                            i, j, cur, b_ref, tmp,
408                                                            &dct_codes[4 * 64], edged_width / 2, 0, 0);
409    
410                    return;
411    
412            case MODE_INTERPOLATE: /* _could_ use DIRECT, but would be overkill (no 4MV there) */
413            case MODE_DIRECT_NO4V:
414                    dx = fmvs->x; dy = fmvs->y;
415                    b_dx = bmvs->x; b_dy = bmvs->y;
416    
417                    if (quarterpel) {
418    
419                            if ((dx&3) | (dy&3)) {
420                                    interpolate16x16_quarterpel(tmp - i * 16 - j * 16 * edged_width,
421                                            (uint8_t *) f_ref->y, tmp + 32,
422                                            tmp + 64, tmp + 96, 16*i, 16*j, dx, dy, edged_width, 0);
423                                    ptr1 = tmp;
424                            } else ptr1 = f_ref->y + (16*j + dy/4)*edged_width + 16*i + dx/4; // fullpixel position
425    
426                            if ((b_dx&3) | (b_dy&3)) {
427                                    interpolate16x16_quarterpel(tmp - i * 16 - j * 16 * edged_width + 16,
428                                            (uint8_t *) b_ref->y, tmp + 32,
429                                            tmp + 64, tmp + 96, 16*i, 16*j, b_dx, b_dy, edged_width, 0);
430                                    ptr2 = tmp + 16;
431                            } else ptr2 = b_ref->y + (16*j + b_dy/4)*edged_width + 16*i + b_dx/4; // fullpixel position
432    
433                            b_dx /= 2;
434                            b_dy /= 2;
435                            dx /= 2;
436                            dy /= 2;
437    
438                    } else {
439                            ptr1 = get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,
440                                                            i, j, 16, dx, dy, edged_width);
441    
442                  transfer_8to16sub(                          ptr2 = get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,
443                          dct_codes[3],                                                          i, j, 16, b_dx, b_dy, edged_width);
444                          cur->y + (j*16+8)*edged_width + (i*16+8),                  }
445                          get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,                  for (k = 0; k < 4; k++)
446                                                          i*16+8, j*16+8, 1, dx, dy, edged_width),                                  transfer_8to16sub2(&dct_codes[k * 64],
447                          edged_width);                                                                          cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
448                                                                            ptr1 + (k&1)*8 + (k>>1)*8*edged_width,
449                                                                            ptr2 + (k&1)*8 + (k>>1)*8*edged_width, edged_width);
450    
451    
452                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;                  dx = (dx >> 1) + roundtab_79[dx & 0x3];
453                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;                  dy = (dy >> 1) + roundtab_79[dy & 0x3];
454    
455                  /* uv-image-based compensation */                  b_dx = (b_dx >> 1) + roundtab_79[b_dx & 0x3];
456                  compensate8x8_halfpel(dct_codes[4], cur->u, f_ref->u, f_refh->u, f_refv->u, f_refhv->u,                  b_dy = (b_dy >> 1) + roundtab_79[b_dy & 0x3];
                                                                 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);  
457    
458                  break;                  break;
459    
460          case MODE_BACKWARD :          default: // MODE_DIRECT (or MODE_DIRECT_NONE_MV in case of bframes decoding)
461                  b_dx = mb->b_mvs[0].x;                  sumx = sumy = b_sumx = b_sumy = 0;
                 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);  
462    
463                  transfer_8to16sub(                  for (k = 0; k < 4; k++) {
                         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);  
464    
465                  transfer_8to16sub_c(                          dx = fmvs[k].x; dy = fmvs[k].y;
466                          dct_codes[2],                          b_dx = bmvs[k].x; b_dy = bmvs[k].y;
                         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);  
467    
468                  transfer_8to16sub(                          if (quarterpel) {
469                          dct_codes[3],                                  sumx += dx/2; sumy += dy/2;
470                          cur->y + (j*16+8)*edged_width + (i*16+8),                                  b_sumx += b_dx/2; b_sumy += b_dy/2;
471                          get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,  
472                                                          i*16+8, j*16+8, 1, b_dx, b_dy, edged_width),                                  if ((dx&3) | (dy&3)) {
473                          edged_width);                                          interpolate8x8_quarterpel(tmp - (i * 16+(k&1)*8) - (j * 16+((k>>1)*8)) * edged_width,
474                                                    (uint8_t *) f_ref->y,
475                                                    tmp + 32, tmp + 64, tmp + 96,
476                                                    16*i + (k&1)*8, 16*j + (k>>1)*8, dx, dy, edged_width, 0);
477                                            ptr1 = tmp;
478                                    } else ptr1 = f_ref->y + (16*j + (k>>1)*8 + dy/4)*edged_width + 16*i + (k&1)*8 + dx/4;
479    
480                                    if ((b_dx&3) | (b_dy&3)) {
481                                            interpolate8x8_quarterpel(tmp - (i * 16+(k&1)*8) - (j * 16+((k>>1)*8)) * edged_width + 16,
482                                                    (uint8_t *) b_ref->y,
483                                                    tmp + 16, tmp + 32, tmp + 48,
484                                                    16*i + (k&1)*8, 16*j + (k>>1)*8, b_dx, b_dy, edged_width, 0);
485                                            ptr2 = tmp + 16;
486                                    } else ptr2 = b_ref->y + (16*j + (k>>1)*8 + b_dy/4)*edged_width + 16*i + (k&1)*8 + b_dx/4;
487                            } else {
488                                    sumx += dx; sumy += dy;
489                                    b_sumx += b_dx; b_sumy += b_dy;
490    
491                                    ptr1 = get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,
492                                                                    2*i + (k&1), 2*j + (k>>1), 8, dx, dy, edged_width);
493                                    ptr2 = get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,
494                                                                    2*i + (k&1), 2*j + (k>>1), 8, b_dx, b_dy,  edged_width);
495                            }
496                            transfer_8to16sub2(&dct_codes[k * 64],
497                                                                    cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
498                                                                    ptr1, ptr2,     edged_width);
499    
500                  b_dx = (b_dx & 3) ? (b_dx >> 1) | 1 : b_dx / 2;                  }
                 b_dy = (b_dy & 3) ? (b_dy >> 1) | 1 : b_dy / 2;  
501    
502                  /* uv-image-based compensation */                  dx = (sumx >> 3) + roundtab_76[sumx & 0xf];
503                  compensate8x8_halfpel(dct_codes[4], cur->u,                  dy = (sumy >> 3) + roundtab_76[sumy & 0xf];
504                                          b_ref->u, b_refh->u, b_refv->u, b_refhv->u,                  b_dx = (b_sumx >> 3) + roundtab_76[b_sumx & 0xf];
505                                          8*i, 8*j, b_dx, b_dy, edged_width/2);                  b_dy = (b_sumy >> 3) + roundtab_76[b_sumy & 0xf];
                 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);  
506    
507                  break;                  break;
508            }
509    
510            // uv block-based chroma interpolation for direct and interpolate modes
511            transfer_8to16sub2(&dct_codes[4 * 64],
512                                                    cur->u + (j * 8) * edged_width / 2 + (i * 8),
513                                                    interpolate8x8_switch2(tmp, b_ref->u, 8 * i, 8 * j,
514                                                                                                    b_dx, b_dy, edged_width / 2, 0),
515                                                    interpolate8x8_switch2(tmp + 8, f_ref->u, 8 * i, 8 * j,
516                                                                                                    dx, dy, edged_width / 2, 0),
517                                                    edged_width / 2);
518    
519          case MODE_INTERPOLATE :          transfer_8to16sub2(&dct_codes[5 * 64],
520                  dx = mb->mvs[0].x;                                                  cur->v + (j * 8) * edged_width / 2 + (i * 8),
521                  dy = mb->mvs[0].y;                                                  interpolate8x8_switch2(tmp, b_ref->v, 8 * i, 8 * j,
522                  b_dx = mb->b_mvs[0].x;                                                                                                  b_dx, b_dy, edged_width / 2, 0),
523                  b_dy = mb->b_mvs[0].y;                                                  interpolate8x8_switch2(tmp + 8, f_ref->v, 8 * i, 8 * j,
524                                                                                                    dx, dy, edged_width / 2, 0),
525                  transfer_8to16sub2_c(                                                  edged_width / 2);
526                                  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);  
527    
                 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);  
528    
                 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);  
529    
530                  transfer_8to16sub2_c(  void generate_GMCparameters( const int num_wp, const int res,
531                                  dct_codes[3],                                                  const WARPPOINTS *const warp,
532                                  cur->y + (i*16+8) + (j*16+8)*edged_width,                                                  const int width, const int height,
533                                  get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,                                                  GMC_DATA *const gmc)
534                                                          16*i + 8, 16*j + 8, 1, dx, dy, edged_width),  {
535                                  get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,          const int du0 = warp->duv[0].x;
536                                                          16*i + 8, 16*j + 8, 1, b_dx, b_dy, edged_width),          const int dv0 = warp->duv[0].y;
537                                  edged_width);          const int du1 = warp->duv[1].x;
538            const int dv1 = warp->duv[1].y;
539            const int du2 = warp->duv[2].x;
540            const int dv2 = warp->duv[2].y;
541    
542            gmc->W = width;
543            gmc->H = height;
544    
545            gmc->rho = 4 - log2bin(res-1);  // = {3,2,1,0} for res={2,4,8,16}
546    
547            gmc->alpha = log2bin(gmc->W-1);
548            gmc->Ws = (1 << gmc->alpha);
549    
550            gmc->dxF = 16*gmc->Ws + RDIV( 8*gmc->Ws*du1, gmc->W );
551            gmc->dxG = RDIV( 8*gmc->Ws*dv1, gmc->W );
552            gmc->Fo  = (res*du0 + 1) << (gmc->alpha+gmc->rho-1);
553            gmc->Go  = (res*dv0 + 1) << (gmc->alpha+gmc->rho-1);
554    
555            if (num_wp==2) {
556                    gmc->dyF = -gmc->dxG;
557                    gmc->dyG =  gmc->dxF;
558            } else if (num_wp==3) {
559                    gmc->beta = log2bin(gmc->H-1);
560                    gmc->Hs = (1 << gmc->beta);
561                    gmc->dyF =                       RDIV( 8*gmc->Hs*du2, gmc->H );
562                    gmc->dyG = 16*gmc->Hs + RDIV( 8*gmc->Hs*dv2, gmc->H );
563                    if (gmc->beta > gmc->alpha) {
564                            gmc->dxF <<= (gmc->beta - gmc->alpha);
565                            gmc->dxG <<= (gmc->beta - gmc->alpha);
566                            gmc->alpha = gmc->beta;
567                            gmc->Ws = 1<< gmc->beta;
568                    } else {
569                            gmc->dyF <<= gmc->alpha - gmc->beta;
570                            gmc->dyG <<= gmc->alpha - gmc->beta;
571                    }
572            }
573    
574            gmc->cFo = gmc->dxF + gmc->dyF + (1 << (gmc->alpha+gmc->rho+1));
575            gmc->cFo += 16*gmc->Ws*(du0-1);
576    
577                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;          gmc->cGo = gmc->dxG + gmc->dyG + (1 << (gmc->alpha+gmc->rho+1));
578                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;          gmc->cGo += 16*gmc->Ws*(dv0-1);
579    }
580    
581                  b_dx = (b_dx & 3) ? (b_dx >> 1) | 1 : b_dx / 2;  void
582                  b_dy = (b_dy & 3) ? (b_dy >> 1) | 1 : b_dy / 2;  generate_GMCimage(      const GMC_DATA *const gmc_data, // [input] precalculated data
583                                            const IMAGE *const pRef,                // [input]
584                                            const int mb_width,
585                                            const int mb_height,
586                                            const int stride,
587                                            const int stride2,
588                                            const int fcode,                                // [input] some parameters...
589                                            const int32_t quarterpel,               // [input] for rounding avgMV
590                                            const int reduced_resolution,   // [input] ignored
591                                            const int32_t rounding,                 // [input] for rounding image data
592                                            MACROBLOCK *const pMBs,                 // [output] average motion vectors
593                                            IMAGE *const pGMC)                              // [output] full warped image
594    {
595    
596                  transfer_8to16sub2_c(          unsigned int mj,mi;
597                                  dct_codes[4],          VECTOR avgMV;
                                 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);  
598    
599                  transfer_8to16sub2_c(          for (mj = 0; mj < (unsigned int)mb_height; mj++)
600                                  dct_codes[5],                  for (mi = 0; mi < (unsigned int)mb_width; mi++) {
                                 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),  
                                 edged_width/2);  
601    
602                  break;                          avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj,
603                                                    stride, stride2, quarterpel, rounding, pGMC);
604    
605          case MODE_DIRECT :                          pMBs[mj*mb_width+mi].amv.x = gmc_sanitize(avgMV.x, quarterpel, fcode);
606                  // todo                          pMBs[mj*mb_width+mi].amv.y = gmc_sanitize(avgMV.y, quarterpel, fcode);
607                  break;                          pMBs[mj*mb_width+mi].mcsel = 0; /* until mode decision */
608            }
609          }          }
610    
611    
612    
613    #define MLT(i)  (((16-(i))<<16) + (i))
614    static const uint32_t MTab[16] = {
615      MLT( 0), MLT( 1), MLT( 2), MLT( 3), MLT( 4), MLT( 5), MLT( 6), MLT(7),
616      MLT( 8), MLT( 9), MLT(10), MLT(11), MLT(12), MLT(13), MLT(14), MLT(15)
617    };
618    #undef MLT
619    
620    VECTOR generate_GMCimageMB( const GMC_DATA *const gmc_data,
621                                                            const IMAGE *const pRef,
622                                                            const int mi, const int mj,
623                                                            const int stride,
624                                                            const int stride2,
625                                                            const int quarterpel,
626                                                            const int rounding,
627                                                            IMAGE *const pGMC)
628    {
629            const int W = gmc_data->W;
630            const int H = gmc_data->H;
631    
632            const int rho = gmc_data->rho;
633            const int alpha = gmc_data->alpha;
634    
635            const int rounder = ( 128 - (rounding<<(rho+rho)) ) << 16;
636    
637            const int dxF = gmc_data->dxF;
638            const int dyF = gmc_data->dyF;
639            const int dxG = gmc_data->dxG;
640            const int dyG = gmc_data->dyG;
641    
642            uint8_t *dstY, *dstU, *dstV;
643    
644            int I,J;
645            VECTOR avgMV = {0,0};
646    
647            int32_t Fj, Gj;
648    
649            dstY = &pGMC->y[(mj*16)*stride+mi*16] + 16;
650    
651            Fj = gmc_data->Fo + dyF*mj*16 + dxF*mi*16;
652            Gj = gmc_data->Go + dyG*mj*16 + dxG*mi*16;
653    
654            for (J = 16; J > 0; --J) {
655                    int32_t Fi, Gi;
656    
657                    Fi = Fj; Fj += dyF;
658                    Gi = Gj; Gj += dyG;
659                    for (I = -16; I < 0; ++I) {
660                            int32_t F, G;
661                            uint32_t ri, rj;
662    
663                            F = ( Fi >> (alpha+rho) ) << rho; Fi += dxF;
664                            G = ( Gi >> (alpha+rho) ) << rho; Gi += dxG;
665    
666                            avgMV.x += F;
667                            avgMV.y += G;
668    
669                            ri = MTab[F&15];
670                            rj = MTab[G&15];
671    
672                            F >>= 4;
673                            G >>= 4;
674    
675                            if (F < -1) F = -1;
676                            else if (F > W) F = W;
677                            if (G< -1) G=-1;
678                            else if (G>H) G=H;
679    
680                            {        // MMX-like bilinear...
681                                    const int offset = G*stride + F;
682                                    uint32_t f0, f1;
683                                    f0 = pRef->y[ offset +0 ];
684                                    f0 |= pRef->y[ offset +1 ] << 16;
685                                    f1 = pRef->y[ offset+stride +0 ];
686                                    f1 |= pRef->y[ offset+stride +1 ] << 16;
687                                    f0 = (ri*f0)>>16;
688                                    f1 = (ri*f1) & 0x0fff0000;
689                                    f0 |= f1;
690                                    f0 = ( rj*f0 + rounder ) >> 24;
691    
692                                    dstY[I] = (uint8_t)f0;
693                            }
694                    }
695    
696                    dstY += stride;
697            }
698    
699            dstU = &pGMC->u[(mj*8)*stride2+mi*8] + 8;
700            dstV = &pGMC->v[(mj*8)*stride2+mi*8] + 8;
701    
702            Fj = gmc_data->cFo + dyF*4 *mj*8 + dxF*4 *mi*8;
703            Gj = gmc_data->cGo + dyG*4 *mj*8 + dxG*4 *mi*8;
704    
705            for (J = 8; J > 0; --J) {
706                    int32_t Fi, Gi;
707                    Fi = Fj; Fj += 4*dyF;
708                    Gi = Gj; Gj += 4*dyG;
709    
710                    for (I = -8; I < 0; ++I) {
711                            int32_t F, G;
712                            uint32_t ri, rj;
713    
714                            F = ( Fi >> (alpha+rho+2) ) << rho; Fi += 4*dxF;
715                            G = ( Gi >> (alpha+rho+2) ) << rho; Gi += 4*dxG;
716    
717                            ri = MTab[F&15];
718                            rj = MTab[G&15];
719    
720                            F >>= 4;
721                            G >>= 4;
722    
723                            if (F < -1) F=-1;
724                            else if (F >= W/2) F = W/2;
725                            if (G < -1) G = -1;
726                            else if (G >= H/2) G = H/2;
727    
728                            {
729                                    const int offset = G*stride2 + F;
730                                    uint32_t f0, f1;
731    
732                                    f0      = pRef->u[ offset                +0 ];
733                                    f0 |= pRef->u[ offset            +1 ] << 16;
734                                    f1      = pRef->u[ offset+stride2 +0 ];
735                                    f1 |= pRef->u[ offset+stride2 +1 ] << 16;
736                                    f0 = (ri*f0)>>16;
737                                    f1 = (ri*f1) & 0x0fff0000;
738                                    f0 |= f1;
739                                    f0 = ( rj*f0 + rounder ) >> 24;
740    
741                                    dstU[I] = (uint8_t)f0;
742    
743    
744                                    f0      = pRef->v[ offset                +0 ];
745                                    f0 |= pRef->v[ offset            +1 ] << 16;
746                                    f1      = pRef->v[ offset+stride2 +0 ];
747                                    f1 |= pRef->v[ offset+stride2 +1 ] << 16;
748                                    f0 = (ri*f0)>>16;
749                                    f1 = (ri*f1) & 0x0fff0000;
750                                    f0 |= f1;
751                                    f0 = ( rj*f0 + rounder ) >> 24;
752    
753                                    dstV[I] = (uint8_t)f0;
754                            }
755                    }
756                    dstU += stride2;
757                    dstV += stride2;
758            }
759    
760    
761            avgMV.x -= 16*((256*mi+120)<<4);        // 120 = 15*16/2
762            avgMV.y -= 16*((256*mj+120)<<4);
763    
764            avgMV.x = RSHIFT( avgMV.x, (4+7-quarterpel) );
765            avgMV.y = RSHIFT( avgMV.y, (4+7-quarterpel) );
766    
767            return avgMV;
768    }
769    
770    
771    
772    #ifdef OLD_GRUEL_GMC
773    void
774    generate_GMCparameters( const int num_wp,                       // [input]: number of warppoints
775                                                    const int res,                  // [input]: resolution
776                                                    const WARPPOINTS *const warp, // [input]: warp points
777                                                    const int width, const int height,
778                                                    GMC_DATA *const gmc)    // [output] precalculated parameters
779    {
780    
781    /* We follow mainly two sources: The original standard, which is ugly, and the
782       thesis from Andreas Dehnhardt, which is much nicer.
783    
784            Notation is: indices are written next to the variable,
785                                     primes in the standard are denoted by a suffix 'p'.
786            types are   "c"=constant, "i"=input parameter, "f"=calculated, then fixed,
787                                    "o"=output data, " "=other, "u" = unused, "p"=calc for every pixel
788    
789    type | variable name  |   ISO name (TeX-style) |  value or range  |  usage
790    -------------------------------------------------------------------------------------
791     c   | H                          |   H                                    |  [16 , ?]            |  image width (w/o edges)
792     c   | W                          |   W                                    |  [16 , ?]            |  image height (w/o edges)
793    
794     c   | i0                         |   i_0                                  |  0                           |  ref. point #1, X
795     c   | j0                         |   j_0                                  |  0                           |  ref. point #1, Y
796     c   | i1                         |   i_1                                  |  W                           |  ref. point #2, X
797     c   | j1                         |   j_1                                  |  0                           |  ref. point #2, Y
798     cu  | i2                         |   i_2                                  |  0                           |  ref. point #3, X
799     cu  | i2                         |   j_2                                  |  H                           |  ref. point #3, Y
800    
801     i   | du0                |   du[0]                        |  [-16863,16863]  |  warp vector #1, Y
802     i   | dv0                |   dv[0]                        |  [-16863,16863]  |  warp vector #1, Y
803     i   | du1                |   du[1]                        |  [-16863,16863]  |  warp vector #2, Y
804     i   | dv1                |   dv[1]                        |  [-16863,16863]  |  warp vector #2, Y
805     iu  | du2                |   du[2]                        |  [-16863,16863]  |  warp vector #3, Y
806     iu  | dv2                |   dv[2]                        |  [-16863,16863]  |  warp vector #3, Y
807    
808     i   | s                          |   s                                 |  {2,4,8,16}     |  interpol. resolution
809     f   | sigma              |             -                          |  log2(s)            |  X / s == X >> sigma
810     f   | r                          |   r                                 |  =16/s                   |  complementary res.
811     f   | rho                      |   \rho                                 |  log2(r)              |  X / r == X >> rho
812    
813     f   | i0s                      |   i'_0                                 |                                |
814     f   | j0s                      |   j'_0                                 |                                |
815     f       | i1s                  |   i'_1                                 |                                |
816     f       | j1s                  |   j'_1                                 |                                |
817     f       | i2s                  |   i'_2                                 |                                |
818     f       | j2s                  |   j'_2                                 |                                |
819    
820     f   | alpha              |   \alpha                       |                              |  2^{alpha-1} < W <= 2^alpha
821     f   | beta                |   \beta                            |                                 |  2^{beta-1} < H <= 2^beta
822    
823     f   | Ws                        |   W'                            | W = 2^{alpha}      |  scaled width
824     f   | Hs                        |   H'                            | W = 2^{beta}        |  scaled height
825    
826     f   | i1ss                |   i''_1                            |  "virtual sprite stuff"
827     f   | j1ss                |   j''_1                            |  "virtual sprite stuff"
828     f   | i2ss                |   i''_2                            |  "virtual sprite stuff"
829     f   | j2ss                |   j''_2                            |  "virtual sprite stuff"
830    */
831    
832    /* Some calculations are disabled because we only use 2 warppoints at the moment */
833    
834            int du0 = warp->duv[0].x;
835            int dv0 = warp->duv[0].y;
836            int du1 = warp->duv[1].x;
837            int dv1 = warp->duv[1].y;
838    //      int du2 = warp->duv[2].x;
839    //      int dv2 = warp->duv[2].y;
840    
841            gmc->num_wp = num_wp;
842    
843            gmc->s = res;                                           /* scaling parameters 2,4,8 or 16 */
844            gmc->sigma = log2bin(res-1);    /* log2bin(15)=4, log2bin(16)=5, log2bin(17)=5  */
845            gmc->r = 16/res;
846            gmc->rho = 4 - gmc->sigma;              /* = log2bin(r-1) */
847    
848            gmc->W = width;
849            gmc->H = height;                        /* fixed reference coordinates */
850    
851            gmc->alpha = log2bin(gmc->W-1);
852            gmc->Ws= 1<<gmc->alpha;
853    
854    //      gmc->beta = log2bin(gmc->H-1);
855    //      gmc->Hs= 1<<gmc->beta;
856    
857    //      printf("du0=%d dv0=%d du1=%d dv1=%d s=%d sigma=%d W=%d alpha=%d, Ws=%d, rho=%d\n",du0,dv0,du1,dv1,gmc->s,gmc->sigma,gmc->W,gmc->alpha,gmc->Ws,gmc->rho);
858    
859            /* i2s is only needed for num_wp >= 3, etc.  */
860            /* the 's' values are in 1/s pel resolution */
861            gmc->i0s = res/2 * ( du0 );
862            gmc->j0s = res/2 * ( dv0 );
863            gmc->i1s = res/2 * (2*width + du1 + du0 );
864            gmc->j1s = res/2 * ( dv1 + dv0 );
865    //      gmc->i2s = res/2 * ( du2 + du0 );
866    //      gmc->j2s = res/2 * (2*height + dv2 + dv0 );
867    
868            /* i2s and i2ss are only needed for num_wp == 3, etc.  */
869    
870            /* the 'ss' values are in 1/16 pel resolution */
871            gmc->i1ss = 16*gmc->Ws + ROUNDED_DIV(((gmc->W-gmc->Ws)*(gmc->r*gmc->i0s) + gmc->Ws*(gmc->r*gmc->i1s - 16*gmc->W)),gmc->W);
872            gmc->j1ss = ROUNDED_DIV( ((gmc->W - gmc->Ws)*(gmc->r*gmc->j0s) + gmc->Ws*gmc->r*gmc->j1s) ,gmc->W );
873    
874    //      gmc->i2ss = ROUNDED_DIV( ((gmc->H - gmc->Hs)*(gmc->r*gmc->i0s) + gmc->Hs*(gmc->r*gmc->i2s)), gmc->H);
875    //      gmc->j2ss = 16*gmc->Hs + ROUNDED_DIV( ((gmc->H-gmc->Hs)*(gmc->r*gmc->j0s) + gmc->Ws*(gmc->r*gmc->j2s - 16*gmc->H)), gmc->H);
876    
877            return;
878    }
879    
880    void
881    generate_GMCimage(      const GMC_DATA *const gmc_data,         // [input] precalculated data
882                                            const IMAGE *const pRef,                        // [input]
883                                            const int mb_width,
884                                            const int mb_height,
885                                            const int stride,
886                                            const int stride2,
887                                            const int fcode,                                        // [input] some parameters...
888                                            const int32_t quarterpel,                       // [input] for rounding avgMV
889                                            const int reduced_resolution,           // [input] ignored
890                                            const int32_t rounding,                 // [input] for rounding image data
891                                            MACROBLOCK *const pMBs,         // [output] average motion vectors
892                                            IMAGE *const pGMC)                      // [output] full warped image
893    {
894    
895            unsigned int mj,mi;
896            VECTOR avgMV;
897    
898            for (mj = 0;mj < mb_height; mj++)
899            for (mi = 0;mi < mb_width; mi++) {
900    
901                    avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj,
902                                            stride, stride2, quarterpel, rounding, pGMC);
903    
904                    pMBs[mj*mb_width+mi].amv.x = gmc_sanitize(avgMV.x, quarterpel, fcode);
905                    pMBs[mj*mb_width+mi].amv.y = gmc_sanitize(avgMV.y, quarterpel, fcode);
906                    pMBs[mj*mb_width+mi].mcsel = 0; /* until mode decision */
907            }
908    }
909    
910    
911    VECTOR generate_GMCimageMB(     const GMC_DATA *const gmc_data, /* [input] all precalc data */
912                                                            const IMAGE *const pRef,                /* [input] */
913                                                            const int mi, const int mj,     /* [input] MB position  */
914                                                            const int stride,                               /* [input] Lumi stride */
915                                                            const int stride2,                              /* [input] chroma stride */
916                                                            const int quarterpel,                   /* [input] for rounding of avgMV */
917                                                            const int rounding,                     /* [input] for rounding of imgae data */
918                                                            IMAGE *const pGMC)                              /* [outut] generate image */
919    
920    /*
921    type | variable name  |   ISO name (TeX-style) |  value or range  |  usage
922    -------------------------------------------------------------------------------------
923     p   | F                          |   F(i,j)                       |                              | pelwise motion vector X in s-th pel
924     p   | G                          |   G(i,j)                       |                              | pelwise motion vector Y in s-th pel
925     p   | Fc                        |   F_c(i,j)                    |                                |
926     p   | Gc                        |   G_c(i,j)                    |                                | same for chroma
927    
928     p   | Y00                      |   Y_{00}                         |  [0,255*s*s]        | first: 4 neighbouring Y-values
929     p   | Y01                      |   Y_{01}                         |  [0,255]            | at fullpel position, around the
930     p   | Y10                      |   Y_{10}                         |  [0,255*s]    | position where pelweise MV points to
931     p   | Y11                      |   Y_{11}                         |  [0,255]            | later: bilinear interpol Y-values in Y00
932    
933     p   | C00                      |   C_{00}                         |  [0,255*s*s]        | same for chroma Cb and Cr
934     p   | C01                      |   C_{01}                         |  [0,255]            |
935     p   | C10                      |   C_{10}                         |  [0,255*s]    |
936     p   | C11                      |   C_{11}                         |  [0,255]            |
937    
938    */
939    {
940            const int W = gmc_data->W;
941            const int H = gmc_data->H;
942    
943            const int s = gmc_data->s;
944            const int sigma = gmc_data->sigma;
945    
946            const int r = gmc_data->r;
947            const int rho = gmc_data->rho;
948    
949            const int i0s = gmc_data->i0s;
950            const int j0s = gmc_data->j0s;
951    
952            const int i1ss = gmc_data->i1ss;
953            const int j1ss = gmc_data->j1ss;
954    //      const int i2ss = gmc_data->i2ss;
955    //      const int j2ss = gmc_data->j2ss;
956    
957            const int alpha = gmc_data->alpha;
958            const int Ws    = gmc_data->Ws;
959    
960    //      const int beta  = gmc_data->beta;
961    //      const int Hs    = gmc_data->Hs;
962    
963            int I,J;
964            VECTOR avgMV = {0,0};
965    
966            for (J=16*mj;J<16*(mj+1);J++)
967            for (I=16*mi;I<16*(mi+1);I++)
968            {
969                    int F= i0s + ( ((-r*i0s+i1ss)*I + (r*j0s-j1ss)*J + (1<<(alpha+rho-1))) >>  (alpha+rho) );
970                    int G= j0s + ( ((-r*j0s+j1ss)*I + (-r*i0s+i1ss)*J + (1<<(alpha+rho-1))) >> (alpha+rho) );
971    
972    /* this naive implementation (with lots of multiplications) isn't slower (rather faster) than
973       working incremental. Don't ask me why... maybe the whole this is memory bound? */
974    
975                    const int ri= F & (s-1); // fractional part of pelwise MV X
976                    const int rj= G & (s-1); // fractional part of pelwise MV Y
977    
978                    int Y00,Y01,Y10,Y11;
979    
980    /* unclipped values are used for avgMV */
981                    avgMV.x += F-(I<<sigma);                /* shift position to 1/s-pel, as the MV is */
982                    avgMV.y += G-(J<<sigma);                /* TODO: don't do this (of course) */
983    
984                    F >>= sigma;
985                    G >>= sigma;
986    
987    /* clip values to be in range. Since we have edges, clip to 1 less than lower boundary
988       this way positions F+1/G+1 are still right */
989    
990                    if (F< -1)
991                            F=-1;
992                    else if (F>W)
993                            F=W;    /* W or W-1 doesn't matter, so save 1 subtract ;-) */
994                    if (G< -1)
995                            G=-1;
996                    else if (G>H)
997                            G=H;            /* dito */
998    
999                    Y00 = pRef->y[ G*stride + F ];                          // Lumi values
1000                    Y01 = pRef->y[ G*stride + F+1 ];
1001                    Y10 = pRef->y[ G*stride + F+stride ];
1002                    Y11 = pRef->y[ G*stride + F+stride+1 ];
1003    
1004                    /* bilinear interpolation */
1005                    Y00 = ((s-ri)*Y00 + ri*Y01);
1006                    Y10 = ((s-ri)*Y10 + ri*Y11);
1007                    Y00 = ((s-rj)*Y00 + rj*Y10 + s*s/2 - rounding ) >> (sigma+sigma);
1008    
1009                    pGMC->y[J*stride+I] = (uint8_t)Y00;                                                                             /* output 1 Y-pixel */
1010            }
1011    
1012    
1013    /* doing chroma _here_ is even more stupid and slow, because won't be used until Compensation and
1014            most likely not even then (only if the block really _is_ GMC)
1015    */
1016    
1017            for (J=8*mj;J<8*(mj+1);J++)             /* this plays the role of j_c,i_c in the standard */
1018            for (I=8*mi;I<8*(mi+1);I++)             /* For I_c we have to use I_c = 4*i_c+1 ! */
1019            {
1020                    /* same positions for both chroma components, U=Cb and V=Cr */
1021                    int Fc=((-r*i0s+i1ss)*(4*I+1) + (r*j0s-j1ss)*(4*J+1) +2*Ws*r*i0s
1022                                                    -16*Ws +(1<<(alpha+rho+1)))>>(alpha+rho+2);
1023                    int Gc=((-r*j0s+j1ss)*(4*I+1) +(-r*i0s+i1ss)*(4*J+1) +2*Ws*r*j0s
1024                                                    -16*Ws +(1<<(alpha+rho+1))) >>(alpha+rho+2);
1025    
1026                    const int ri= Fc & (s-1); // fractional part of pelwise MV X
1027                    const int rj= Gc & (s-1); // fractional part of pelwise MV Y
1028    
1029                    int C00,C01,C10,C11;
1030    
1031                    Fc >>= sigma;
1032                    Gc >>= sigma;
1033    
1034                    if (Fc< -1)
1035                            Fc=-1;
1036                    else if (Fc>=W/2)
1037                            Fc=W/2;         /* W or W-1 doesn't matter, so save 1 subtraction ;-) */
1038                    if (Gc< -1)
1039                            Gc=-1;
1040                    else if (Gc>=H/2)
1041                            Gc=H/2;         /* dito */
1042    
1043    /* now calculate U data */
1044                    C00 = pRef->u[ Gc*stride2 + Fc ];                               // chroma-value Cb
1045                    C01 = pRef->u[ Gc*stride2 + Fc+1 ];
1046                    C10 = pRef->u[ (Gc+1)*stride2 + Fc ];
1047                    C11 = pRef->u[ (Gc+1)*stride2 + Fc+1 ];
1048    
1049                    /* bilinear interpolation */
1050                    C00 = ((s-ri)*C00 + ri*C01);
1051                    C10 = ((s-ri)*C10 + ri*C11);
1052                    C00 = ((s-rj)*C00 + rj*C10 + s*s/2 - rounding ) >> (sigma+sigma);
1053    
1054                    pGMC->u[J*stride2+I] = (uint8_t)C00;                                                                            /* output 1 U-pixel */
1055    
1056    /* now calculate V data */
1057                    C00 = pRef->v[ Gc*stride2 + Fc ];                               // chroma-value Cr
1058                    C01 = pRef->v[ Gc*stride2 + Fc+1 ];
1059                    C10 = pRef->v[ (Gc+1)*stride2 + Fc ];
1060                    C11 = pRef->v[ (Gc+1)*stride2 + Fc+1 ];
1061    
1062                    /* bilinear interpolation */
1063                    C00 = ((s-ri)*C00 + ri*C01);
1064                    C10 = ((s-ri)*C10 + ri*C11);
1065                    C00 = ((s-rj)*C00 + rj*C10 + s*s/2 - rounding ) >> (sigma+sigma);
1066    
1067                    pGMC->v[J*stride2+I] = (uint8_t)C00;                                                                            /* output 1 V-pixel */
1068            }
1069    
1070    /* The average vector is rounded from 1/s-pel to 1/2 or 1/4 using the '//' operator*/
1071    
1072            avgMV.x = RSHIFT( avgMV.x, (sigma+7-quarterpel) );
1073            avgMV.y = RSHIFT( avgMV.y, (sigma+7-quarterpel) );
1074    
1075            /* ^^^^ this is the way MS Reference Software does it */
1076    
1077            return avgMV;   /* clipping to fcode area is done outside! */
1078  }  }
1079    
1080    #endif

Legend:
Removed from v.118  
changed lines
  Added in v.935

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