[svn] / trunk / xvidcore / src / motion / motion_comp.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/motion/motion_comp.c

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

revision 373, Thu Aug 15 18:13:02 2002 UTC revision 374, Thu Aug 15 19:52:16 2002 UTC
# Line 99  Line 99 
99                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;
100    
101                  /* uv-image-based compensation */                  /* uv-image-based compensation */
102  #ifdef BUGGY_BFRAMES  /* Always do block-based compensation, until check for HALFPEL is possible
103  /* was #ifdef BFRAMES, but that's not possible because non-halfpel is _allowed_  #ifdef BFRAMES
    if max_bframes<=0 . We should better check for XVID_HALFPEL flag */  
   
104                  compensate8x8_halfpel(&dct_codes[4 * 64], cur->u, ref->u, refh->u,                  compensate8x8_halfpel(&dct_codes[4 * 64], cur->u, ref->u, refh->u,
105                                                            refv->u, refhv->u, 8 * i, 8 * j, dx, dy,                                                            refv->u, refhv->u, 8 * i, 8 * j, dx, dy,
106                                                            edged_width / 2);                                                            edged_width / 2);
# Line 110  Line 108 
108                                                            refv->v, refhv->v, 8 * i, 8 * j, dx, dy,                                                            refv->v, refhv->v, 8 * i, 8 * j, dx, dy,
109                                                            edged_width / 2);                                                            edged_width / 2);
110  #else  #else
111    */
   
112                  /* uv-block-based compensation */                  /* uv-block-based compensation */
113                  interpolate8x8_switch(refv->u, ref->u, 8 * i, 8 * j, dx, dy,                  interpolate8x8_switch(refv->u, ref->u, 8 * i, 8 * j, dx, dy,
114                                                            edged_width / 2, rounding);                                                            edged_width / 2, rounding);
# Line 126  Line 123 
123                                                    cur->v + 8 * j * edged_width / 2 + 8 * i,                                                    cur->v + 8 * j * edged_width / 2 + 8 * i,
124                                                    refv->v + 8 * j * edged_width / 2 + 8 * i,                                                    refv->v + 8 * j * edged_width / 2 + 8 * i,
125                                                    edged_width / 2);                                                    edged_width / 2);
126    /*
127  #endif  #endif
128    */
129          } else                                          // mode == MODE_INTER4V          } else                                          // mode == MODE_INTER4V
130          {          {
131                  int32_t sum, dx, dy;                  int32_t sum, dx, dy;
# Line 202  Line 201 
201          const int32_t edged_width = pParam->edged_width;          const int32_t edged_width = pParam->edged_width;
202          int32_t dx, dy;          int32_t dx, dy;
203          int32_t b_dx, b_dy;          int32_t b_dx, b_dy;
204            int k,sum;
205          int x = i;          int x = i;
206          int y = j;          int y = j;
207    
208    
   
209          switch (mb->mode) {          switch (mb->mode) {
210          case MODE_FORWARD:          case MODE_FORWARD:
211                  dx = mb->mvs[0].x;                  dx = mb->mvs[0].x;
# Line 292  Line 291 
291                  break;                  break;
292    
293    
294          case MODE_INTERPOLATE:          case MODE_INTERPOLATE:          /* _could_ use DIRECT, but would be overkill (no 4MV there) */
295    
296                  dx = mb->mvs[0].x;                  dx = mb->mvs[0].x;
297                  dy = mb->mvs[0].y;                  dy = mb->mvs[0].y;
298    
299                  b_dx = mb->b_mvs[0].x;                  b_dx = mb->b_mvs[0].x;
300                  b_dy = mb->b_mvs[0].y;                  b_dy = mb->b_mvs[0].y;
301    
302                  transfer_8to16sub2_c(&dct_codes[0 * 64],                  for (k=0;k<4;k++)
303                                                           cur->y + (i * 16) + (j * 16) * edged_width,                  {
304                                                           get_ref(f_ref->y, f_refh->y, f_refv->y,                          transfer_8to16sub2_c(&dct_codes[k * 64],
305                                                                           f_refhv->y, 16 * i, 16 * j, 1, dx, dy,                                                           cur->y + (i * 16+(k&1)*8) + (j * 16+((k>>1)*8)) * edged_width,
                                                                          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 * 64],  
                                                          cur->y + (i * 16 + 8) + (j * 16) * edged_width,  
306                                                           get_ref(f_ref->y, f_refh->y, f_refv->y,                                                           get_ref(f_ref->y, f_refh->y, f_refv->y,
307                                                                           f_refhv->y, 16 * i + 8, 16 * j, 1, dx, dy,                                                                           f_refhv->y, 2*i + (k&1), 2*j + (k>>1), 8, 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,  
308                                                                                                                     edged_width),                                                                                                                     edged_width),
309                                                           edged_width);                                                           get_ref(b_ref->y, b_refh->y, b_refv->y,
310                                                                             b_refhv->y, 2*i + (k&1), 2 * j+(k>>1), 8, b_dx, b_dy,
                 transfer_8to16sub2_c(&dct_codes[2 * 64],  
                                                          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 * 64],  
                                                          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,  
311                                                                                                                             edged_width),                                                                                                                             edged_width),
312                                                           edged_width);                                                           edged_width);
313                    }
314    
315                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;                  dx = (dx & 3) ? (dx >> 1) | 1 : dx / 2;
316                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;                  dy = (dy & 3) ? (dy >> 1) | 1 : dy / 2;
# Line 357  Line 321 
321                  transfer_8to16sub2_c(&dct_codes[4 * 64],                  transfer_8to16sub2_c(&dct_codes[4 * 64],
322                                                           cur->u + (y * 8) * edged_width / 2 + (x * 8),                                                           cur->u + (y * 8) * edged_width / 2 + (x * 8),
323                                                           get_ref(f_ref->u, f_refh->u, f_refv->u,                                                           get_ref(f_ref->u, f_refh->u, f_refv->u,
324                                                                           f_refhv->u, 8 * i, 8 * j, 1, dx, dy,                                                                           f_refhv->u, i, j, 8, dx, dy,
325                                                                           edged_width / 2), get_ref(b_ref->u,                                                                           edged_width / 2),
326                                                                                                                             b_refh->u,                                                           get_ref(b_ref->u, b_refh->u, b_refv->u,
327                                                                                                                             b_refv->u,                                                                           b_refhv->u, i, j, 8, b_dx, b_dy,
328                                                                                                                             b_refhv->u,                                                                           edged_width / 2),
                                                                                                                            8 * i, 8 * j, 1,  
                                                                                                                            b_dx, b_dy,  
                                                                                                                            edged_width /  
                                                                                                                            2),  
329                                                           edged_width / 2);                                                           edged_width / 2);
330    
331                  transfer_8to16sub2_c(&dct_codes[5 * 64],                  transfer_8to16sub2_c(&dct_codes[5 * 64],
332                                                           cur->v + (y * 8) * edged_width / 2 + (x * 8),                                                           cur->v + (y * 8) * edged_width / 2 + (x * 8),
333                                                           get_ref(f_ref->v, f_refh->v, f_refv->v,                                                           get_ref(f_ref->v, f_refh->v, f_refv->v,
334                                                                           f_refhv->v, 8 * i, 8 * j, 1, dx, dy,                                                                           f_refhv->v, 8 * i, 8 * j, 1, dx, dy,
335                                                                           edged_width / 2), get_ref(b_ref->v,                                                                           edged_width / 2),
336                                                                                                                             b_refh->v,                                                           get_ref(b_ref->v, b_refh->v, b_refv->v,
337                                                                                                                             b_refv->v,                                                                           b_refhv->v, 8 * i, 8 * j, 1, b_dx, b_dy,
338                                                                                                                             b_refhv->v,                                                                           edged_width / 2),
                                                                                                                            8 * i, 8 * j, 1,  
                                                                                                                            b_dx, b_dy,  
                                                                                                                            edged_width /  
                                                                                                                            2),  
339                                                           edged_width / 2);                                                           edged_width / 2);
340    
341                  break;                  break;
342    
343          case MODE_DIRECT:          case MODE_DIRECT:
344                  // todo  
345                  break;                  for (k=0;k<4;k++)
346                    {
347                            dx = mb->mvs[k].x;
348                            dy = mb->mvs[k].y;
349    
350                            b_dx = mb->b_mvs[k].x;
351                            b_dy = mb->b_mvs[k].y;
352    
353    //              fprintf(stderr,"Direct Vector %d -- %d:%d    %d:%d\n",k,dx,dy,b_dx,b_dy);
354    
355                            transfer_8to16sub2_c(&dct_codes[k * 64],
356                                                             cur->y + (i*16 + (k&1)*8) + (j*16 + (k>>1)*8 ) * edged_width,
357                                                             get_ref(f_ref->y, f_refh->y, f_refv->y, f_refhv->y,
358                                                                             2*i + (k&1), 2*j + (k>>1), 8, dx, dy,
359                                                                             edged_width),
360                                                             get_ref(b_ref->y, b_refh->y, b_refv->y, b_refhv->y,
361                                                                             2*i + (k&1), 2*j + (k>>1), 8, b_dx, b_dy,
362                                                                             edged_width),
363                                                             edged_width);
364          }          }
365    
366                    sum = mb->mvs[0].x + mb->mvs[1].x + mb->mvs[2].x + mb->mvs[3].x;
367                    dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
368    
369                    sum = mb->mvs[0].y + mb->mvs[1].y + mb->mvs[2].y + mb->mvs[3].y;
370                    dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
371    
372    
373                    sum = mb->b_mvs[0].x + mb->b_mvs[1].x + mb->b_mvs[2].x + mb->b_mvs[3].x;
374                    b_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
375    
376                    sum = mb->b_mvs[0].y + mb->b_mvs[1].y + mb->b_mvs[2].y + mb->b_mvs[3].y;
377                    b_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));
378    
379    /*              // for QPel don't forget to always do
380    
381                    if (quarterpel)
382                            sum /= 2;
383    */
384    
385                    transfer_8to16sub2_c(&dct_codes[4 * 64],
386                                                             cur->u + (y * 8) * edged_width / 2 + (x * 8),
387                                                             get_ref(f_ref->u, f_refh->u, f_refv->u,
388                                                                             f_refhv->u, i, j, 8, dx, dy,
389                                                                             edged_width / 2),
390                                                             get_ref(b_ref->u, b_refh->u, b_refv->u,
391                                                                             b_refhv->u, i, j, 8, b_dx, b_dy,
392                                                                             edged_width / 2),
393                                                             edged_width / 2);
394    
395                    transfer_8to16sub2_c(&dct_codes[5 * 64],
396                                                             cur->v + (y * 8) * edged_width / 2 + (x * 8),
397                                                             get_ref(f_ref->v, f_refh->v, f_refv->v,
398                                                                             f_refhv->v, i, j, 8, dx, dy,
399                                                                             edged_width / 2),
400                                                             get_ref(b_ref->v, b_refh->v, b_refv->v,
401                                                                             b_refhv->v, i, j, 8, b_dx, b_dy,
402                                                                             edged_width / 2),
403                                                             edged_width / 2);
404    
405    
406                    break;
407            }
408  }  }

Legend:
Removed from v.373  
changed lines
  Added in v.374

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