hvirtual/mpeg2enc/predict.c

   1 /* predict.c, motion compensated prediction                                 */
   2
   3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
   4
   5 /*
   6  * Disclaimer of Warranty
   7  *
   8  * These software programs are available to the user without any license fee or
   9  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10  * any and all warranties, whether express, implied, or statuary, including any
  11  * implied warranties or merchantability or of fitness for a particular
  12  * purpose.  In no event shall the copyright-holder be liable for any
  13  * incidental, punitive, or consequential damages of any kind whatsoever
  14  * arising from the use of these programs.
  15  *
  16  * This disclaimer of warranty extends to the user of these programs and user's
  17  * customers, employees, agents, transferees, successors, and assigns.
  18  *
  19  * The MPEG Software Simulation Group does not represent or warrant that the
  20  * programs furnished hereunder are free of infringement of any third-party
  21  * patents.
  22  *
  23  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24  * are subject to royalty fees to patent holders.  Many of these patents are
  25  * general enough such that they are unavoidable regardless of implementation
  26  * design.
  27  *
  28  */
  29
  30 #include "config.h"
  31 #include <stdio.h>
  32 #include "global.h"
  33 #include "cpu_accel.h"
  34 #include "simd.h"
  35
  36
  37 /* private prototypes */
  38 static void predict_mb (
  39         pict_data_s *picture,
  40         uint8_t *oldref[], uint8_t *newref[], uint8_t *cur[],
  41         int lx, int bx, int by, mbinfo_s *mbi, int secondfield);
  42
  43 static void pred (
  44         pict_data_s *picture,
  45         uint8_t *src[], int sfield,
  46         uint8_t *dst[], int dfield,
  47         int lx, int w, int h, int x, int y, int dx, int dy, int addflag);
  48
  49 static void pred_comp (
  50         pict_data_s *picture,
  51         uint8_t *src, uint8_t *dst,
  52         int lx, int w, int h, int x, int y, int dx, int dy, int addflag);
  53 #ifdef X86_CPU
  54 static void pred_comp_mmxe(
  55         pict_data_s *picture,
  56         uint8_t *src, uint8_t *dst,
  57         int lx, int w, int h, int x, int y, int dx, int dy, int addflag);
  58 static void pred_comp_mmx(
  59         pict_data_s *picture,
  60         uint8_t *src, uint8_t *dst,
  61         int lx, int w, int h, int x, int y, int dx, int dy, int addflag);
  62 #endif
  63 static void calc_DMV
  64         (       pict_data_s *picture,int DMV[][2],
  65                 int *dmvector, int mvx, int mvy);
  66
  67 static void clearblock (pict_data_s *picture,
  68                                                 uint8_t *cur[], int i0, int j0);
  69
  70 /*
  71   Initialise prediction - currently purely selection of which
  72   versions of the various low level computation routines to use
  73
  74   */
  75
  76 static void (*ppred_comp)(
  77         pict_data_s *picture,
  78         uint8_t *src, uint8_t *dst,
  79         int lx, int w, int h, int x, int y, int dx, int dy, int addflag);
  80
  81 void init_predict()
  82 {
  83         int cpucap = cpu_accel();
  84
  85         if( cpucap  == 0 )      /* No MMX/SSE etc support available */
  86         {
  87                 ppred_comp = pred_comp;
  88         }
  89
  90 #ifdef X86_CPU
  91         else if(cpucap & ACCEL_X86_MMXEXT ) /* AMD MMX or SSE... */
  92         {
  93                 if(verbose) fprintf( stderr, "SETTING EXTENDED MMX for PREDICTION!\n");
  94                 ppred_comp = pred_comp_mmxe;
  95         }
  96     else if(cpucap & ACCEL_X86_MMX ) /* Original MMX... */
  97         {
  98                 if(verbose) fprintf( stderr, "SETTING MMX for PREDICTION!\n");
  99                 ppred_comp = pred_comp_mmx;
 100         }
 101 #endif
 102     else
 103         {
 104                 ppred_comp = pred_comp;
 105         }
 106 }
 107
 108 /* form prediction for a complete picture (frontend for predict_mb)
 109  *
 110  * reff: reference frame for forward prediction
 111  * refb: reference frame for backward prediction
 112  * cur:  destination (current) frame
 113  * secondfield: predict second field of a frame
 114  * mbi:  macroblock info
 115  *
 116  * Notes:
 117  * - cf. predict_mb
 118  */
 119
 120 void predict(pict_data_s *picture,
 121                          uint8_t *reff[],
 122                          uint8_t *refb[],
 123                          uint8_t *cur[3],
 124                          int secondfield)
 125 {
 126         int i, j, k;
 127         mbinfo_s *mbi = picture->mbinfo;
 128         k = 0;
 129
 130         /* loop through all macroblocks of the picture */
 131         for (j=0; j<height2; j+=16)
 132                 for (i=0; i<width; i+=16)
 133                 {
 134                         predict_mb(picture,reff,refb,cur,width,i,j,
 135                                            &mbi[k], secondfield );
 136                         k++;
 137                 }
 138 }
 139
 140 /* form prediction for one macroblock
 141  *
 142  * oldref: reference frame for forward prediction
 143  * newref: reference frame for backward prediction
 144  * cur:    destination (current) frame
 145  * lx:     frame width (identical to global var `width')
 146  * bx,by:  picture (field or frame) coordinates of macroblock to be predicted
 147  * pict_type: I, P or B
 148  * pict_struct: FRAME_PICTURE, TOP_FIELD, BOTTOM_FIELD
 149  * mb_type:     MB_FORWARD, MB_BACKWARD, MB_INTRA
 150  * motion_type: MC_FRAME, MC_FIELD, MC_16X8, MC_DMV
 151  * secondfield: predict second field of a frame
 152  * PMV[2][2][2]: motion vectors (in half pel picture coordinates)
 153  * mv_field_sel[2][2]: motion vertical field selects (for field predictions)
 154  * dmvector: differential motion vectors (for dual prime)
 155  *
 156  * Notes:
 157  * - when predicting a P type picture which is the second field of
 158  *   a frame, the same parity reference field is in oldref, while the
 159  *   opposite parity reference field is assumed to be in newref!
 160  * - intra macroblocks are modelled to have a constant prediction of 128
 161  *   for all pels; this results in a DC DCT coefficient symmetric to 0
 162  * - vectors for field prediction in frame pictures are in half pel frame
 163  *   coordinates (vertical component is twice the field value and always
 164  *   even)
 165  *
 166  * already covers dual prime (not yet used)
 167  */
 168
 169 static void predict_mb (
 170         pict_data_s *picture,
 171         uint8_t *oldref[], uint8_t *newref[], uint8_t *cur[],
 172         int lx, int bx, int by, mbinfo_s *mbi,  int secondfield
 173         )
 174 {
 175         int addflag, currentfield;
 176         uint8_t **predframe;
 177         int DMV[2][2];
 178
 179         if (mbi->mb_type&MB_INTRA)
 180         {
 181                 clearblock(picture,cur,bx,by);
 182                 return;
 183         }
 184
 185         addflag = 0; /* first prediction is stored, second is added and averaged */
 186
 187         if ((mbi->mb_type & MB_FORWARD) || (picture->pict_type==P_TYPE))
 188         {
 189                 /* forward prediction, including zero MV in P pictures */
 190
 191                 if (picture->pict_struct==FRAME_PICTURE)
 192                 {
 193                         /* frame picture */
 194
 195                         if ((mbi->motion_type==MC_FRAME) || !(mbi->mb_type & MB_FORWARD))
 196                         {
 197                                 /* frame-based prediction in frame picture */
 198                                 pred(picture,
 199                                          oldref,0,cur,0,
 200                                          lx,16,16,bx,by,mbi->MV[0][0][0],mbi->MV[0][0][1],0);
 201                         }
 202                         else if (mbi->motion_type==MC_FIELD)
 203                         {
 204                                 /* field-based prediction in frame picture
 205                                  *
 206                                  * note scaling of the vertical coordinates (by, mbi->MV[][0][1])
 207                                  * from frame to field!
 208                                  */
 209
 210                                 /* top field prediction */
 211                                 pred(picture,oldref,mbi->mv_field_sel[0][0],cur,0,
 212                                          lx<<1,16,8,bx,by>>1,mbi->MV[0][0][0],mbi->MV[0][0][1]>>1,0);
 213
 214                                 /* bottom field prediction */
 215                                 pred(picture,oldref,mbi->mv_field_sel[1][0],cur,1,
 216                                          lx<<1,16,8,bx,by>>1,mbi->MV[1][0][0],mbi->MV[1][0][1]>>1,0);
 217                         }
 218                         else if (mbi->motion_type==MC_DMV)
 219                         {
 220                                 /* dual prime prediction */
 221
 222                                 /* calculate derived motion vectors */
 223                                 calc_DMV(picture,DMV,mbi->dmvector,mbi->MV[0][0][0],mbi->MV[0][0][1]>>1);
 224
 225                                 /* predict top field from top field */
 226                                 pred(picture,oldref,0,cur,0,
 227                                          lx<<1,16,8,bx,by>>1,mbi->MV[0][0][0],mbi->MV[0][0][1]>>1,0);
 228
 229                                 /* predict bottom field from bottom field */
 230                                 pred(picture,oldref,1,cur,1,
 231                                          lx<<1,16,8,bx,by>>1,mbi->MV[0][0][0],mbi->MV[0][0][1]>>1,0);
 232
 233                                 /* predict and add to top field from bottom field */
 234                                 pred(picture,oldref,1,cur,0,
 235                                          lx<<1,16,8,bx,by>>1,DMV[0][0],DMV[0][1],1);
 236
 237                                 /* predict and add to bottom field from top field */
 238                                 pred(picture,oldref,0,cur,1,
 239                                          lx<<1,16,8,bx,by>>1,DMV[1][0],DMV[1][1],1);
 240                         }
 241                         else
 242                         {
 243                                 /* invalid mbi->motion_type in frame picture */
 244                                 fprintf(stderr,"invalid motion_type\n");
 245                         }
 246                 }
 247                 else /* TOP_FIELD or BOTTOM_FIELD */
 248                 {
 249                         /* field picture */
 250
 251                         currentfield = (picture->pict_struct==BOTTOM_FIELD);
 252
 253                         /* determine which frame to use for prediction */
 254                         if ((picture->pict_type==P_TYPE) && secondfield
 255                                 && (currentfield!=mbi->mv_field_sel[0][0]))
 256                                 predframe = newref; /* same frame */
 257                         else
 258                                 predframe = oldref; /* previous frame */
 259
 260                         if ((mbi->motion_type==MC_FIELD) || !(mbi->mb_type & MB_FORWARD))
 261                         {
 262                                 /* field-based prediction in field picture */
 263                                 pred(picture,predframe,mbi->mv_field_sel[0][0],cur,currentfield,
 264                                          lx<<1,16,16,bx,by,mbi->MV[0][0][0],mbi->MV[0][0][1],0);
 265                         }
 266                         else if (mbi->motion_type==MC_16X8)
 267                         {
 268                                 /* 16 x 8 motion compensation in field picture */
 269
 270                                 /* upper half */
 271                                 pred(picture,predframe,mbi->mv_field_sel[0][0],cur,currentfield,
 272                                          lx<<1,16,8,bx,by,mbi->MV[0][0][0],mbi->MV[0][0][1],0);
 273
 274                                 /* determine which frame to use for lower half prediction */
 275                                 if ((picture->pict_type==P_TYPE) && secondfield
 276                                         && (currentfield!=mbi->mv_field_sel[1][0]))
 277                                         predframe = newref; /* same frame */
 278                                 else
 279                                         predframe = oldref; /* previous frame */
 280
 281                                 /* lower half */
 282                                 pred(picture,predframe,mbi->mv_field_sel[1][0],cur,currentfield,
 283                                          lx<<1,16,8,bx,by+8,mbi->MV[1][0][0],mbi->MV[1][0][1],0);
 284                         }
 285                         else if (mbi->motion_type==MC_DMV)
 286                         {
 287                                 /* dual prime prediction */
 288
 289                                 /* determine which frame to use for prediction */
 290                                 if (secondfield)
 291                                         predframe = newref; /* same frame */
 292                                 else
 293                                         predframe = oldref; /* previous frame */
 294
 295                                 /* calculate derived motion vectors */
 296                                 calc_DMV(picture,DMV,mbi->dmvector,mbi->MV[0][0][0],mbi->MV[0][0][1]);
 297
 298                                 /* predict from field of same parity */
 299                                 pred(picture,oldref,currentfield,cur,currentfield,
 300                                          lx<<1,16,16,bx,by,mbi->MV[0][0][0],mbi->MV[0][0][1],0);
 301
 302                                 /* predict from field of opposite parity */
 303                                 pred(picture,predframe,!currentfield,cur,currentfield,
 304                                          lx<<1,16,16,bx,by,DMV[0][0],DMV[0][1],1);
 305                         }
 306                         else
 307                         {
 308                                 /* invalid motion_type in field picture */
 309                                 fprintf(stderr,"invalid motion_type\n");
 310                         }
 311                 }
 312                 addflag = 1; /* next prediction (if any) will be averaged with this one */
 313         }
 314
 315         if (mbi->mb_type & MB_BACKWARD)
 316         {
 317                 /* backward prediction */
 318
 319                 if (picture->pict_struct==FRAME_PICTURE)
 320                 {
 321                         /* frame picture */
 322
 323                         if (mbi->motion_type==MC_FRAME)
 324                         {
 325                                 /* frame-based prediction in frame picture */
 326                                 pred(picture,newref,0,cur,0,
 327                                          lx,16,16,bx,by,mbi->MV[0][1][0],mbi->MV[0][1][1],addflag);
 328                         }
 329                         else
 330                         {
 331                                 /* field-based prediction in frame picture
 332                                  *
 333                                  * note scaling of the vertical coordinates (by, mbi->MV[][1][1])
 334                                  * from frame to field!
 335                                  */
 336
 337                                 /* top field prediction */
 338                                 pred(picture,newref,mbi->mv_field_sel[0][1],cur,0,
 339                                          lx<<1,16,8,bx,by>>1,mbi->MV[0][1][0],mbi->MV[0][1][1]>>1,addflag);
 340
 341                                 /* bottom field prediction */
 342                                 pred(picture,newref,mbi->mv_field_sel[1][1],cur,1,
 343                                          lx<<1,16,8,bx,by>>1,mbi->MV[1][1][0],mbi->MV[1][1][1]>>1,addflag);
 344                         }
 345                 }
 346                 else /* TOP_FIELD or BOTTOM_FIELD */
 347                 {
 348                         /* field picture */
 349
 350                         currentfield = (picture->pict_struct==BOTTOM_FIELD);
 351
 352                         if (mbi->motion_type==MC_FIELD)
 353                         {
 354                                 /* field-based prediction in field picture */
 355                                 pred(picture,newref,mbi->mv_field_sel[0][1],cur,currentfield,
 356                                          lx<<1,16,16,bx,by,mbi->MV[0][1][0],mbi->MV[0][1][1],addflag);
 357                         }
 358                         else if (mbi->motion_type==MC_16X8)
 359                         {
 360                                 /* 16 x 8 motion compensation in field picture */
 361
 362                                 /* upper half */
 363                                 pred(picture,newref,mbi->mv_field_sel[0][1],cur,currentfield,
 364                                          lx<<1,16,8,bx,by,mbi->MV[0][1][0],mbi->MV[0][1][1],addflag);
 365
 366                                 /* lower half */
 367                                 pred(picture,newref,mbi->mv_field_sel[1][1],cur,currentfield,
 368                                          lx<<1,16,8,bx,by+8,mbi->MV[1][1][0],mbi->MV[1][1][1],addflag);
 369                         }
 370                         else
 371                         {
 372                                 /* invalid motion_type in field picture */
 373                                 fprintf(stderr,"invalid motion_type\n");
 374                         }
 375                 }
 376         }
 377 }
 378
 379 /* predict a rectangular block (all three components)
 380  *
 381  * src:     source frame (Y,U,V)
 382  * sfield:  source field select (0: frame or top field, 1: bottom field)
 383  * dst:     destination frame (Y,U,V)
 384  * dfield:  destination field select (0: frame or top field, 1: bottom field)
 385  *
 386  * the following values are in luminance picture (frame or field) dimensions
 387  * lx:      distance of vertically adjacent pels (selects frame or field pred.)
 388  * w,h:     width and height of block (only 16x16 or 16x8 are used)
 389  * x,y:     coordinates of destination block
 390  * dx,dy:   half pel motion vector
 391  * addflag: store or add (= average) prediction
 392  */
 393
 394 static void pred (
 395         pict_data_s *picture,
 396         uint8_t *src[], int sfield,
 397         uint8_t *dst[], int dfield,
 398         int lx, int w, int h, int x, int y, int dx, int dy, int addflag
 399         )
 400 {
 401         int cc;
 402
 403         for (cc=0; cc<3; cc++)
 404         {
 405                 if (cc==1)
 406                 {
 407                         /* scale for color components */
 408                         if (chroma_format==CHROMA420)
 409                         {
 410                                 /* vertical */
 411                                 h >>= 1; y >>= 1; dy /= 2;
 412                         }
 413                         if (chroma_format!=CHROMA444)
 414                         {
 415                                 /* horizontal */
 416                                 w >>= 1; x >>= 1; dx /= 2;
 417                                 lx >>= 1;
 418                         }
 419                 }
 420                 (*ppred_comp)(  picture,
 421                                                 src[cc]+(sfield?lx>>1:0),dst[cc]+(dfield?lx>>1:0),
 422                                                 lx,w,h,x,y,dx,dy,addflag);
 423         }
 424 }
 425
 426 /* low level prediction routine
 427  *
 428  * src:     prediction source
 429  * dst:     prediction destination
 430  * lx:      line width (for both src and dst)
 431  * x,y:     destination coordinates
 432  * dx,dy:   half pel motion vector
 433  * w,h:     size of prediction block
 434  * addflag: store or add prediction
 435  *
 436  * There are also SIMD versions of this routine...
 437  */
 438
 439 static void pred_comp(
 440         pict_data_s *picture,
 441         uint8_t *src,
 442         uint8_t *dst,
 443         int lx,
 444         int w, int h,
 445         int x, int y,
 446         int dx, int dy,
 447         int addflag)
 448 {
 449         int xint, xh, yint, yh;
 450         int i, j;
 451         uint8_t *s, *d;
 452
 453         /* half pel scaling */
 454         xint = dx>>1; /* integer part */
 455         xh = dx & 1;  /* half pel flag */
 456         yint = dy>>1;
 457         yh = dy & 1;
 458
 459         /* origins */
 460         s = src + lx*(y+yint) + (x+xint); /* motion vector */
 461         d = dst + lx*y + x;
 462
 463         if (!xh && !yh)
 464                 if (addflag)
 465                         for (j=0; j<h; j++)
 466                         {
 467                                 for (i=0; i<w; i++)
 468                                         d[i] = (unsigned int)(d[i]+s[i]+1)>>1;
 469                                 s+= lx;
 470                                 d+= lx;
 471                         }
 472                 else
 473                         for (j=0; j<h; j++)
 474                         {
 475                                 for (i=0; i<w; i++)
 476                                         d[i] = s[i];
 477                                 s+= lx;
 478                                 d+= lx;
 479                         }
 480         else if (!xh && yh)
 481                 if (addflag)
 482                         for (j=0; j<h; j++)
 483                         {
 484                                 for (i=0; i<w; i++)
 485                                         d[i] = (d[i] + ((unsigned int)(s[i]+s[i+lx]+1)>>1)+1)>>1;
 486                                 s+= lx;
 487                                 d+= lx;
 488                         }
 489                 else
 490                         for (j=0; j<h; j++)
 491                         {
 492                                 for (i=0; i<w; i++)
 493                                         d[i] = (unsigned int)(s[i]+s[i+lx]+1)>>1;
 494                                 s+= lx;
 495                                 d+= lx;
 496                         }
 497         else if (xh && !yh)
 498                 if (addflag)
 499                         for (j=0; j<h; j++)
 500                         {
 501                                 for (i=0; i<w; i++)
 502                                         d[i] = (d[i] + ((unsigned int)(s[i]+s[i+1]+1)>>1)+1)>>1;
 503                                 s+= lx;
 504                                 d+= lx;
 505                         }
 506                 else
 507                         for (j=0; j<h; j++)
 508                         {
 509                                 for (i=0; i<w; i++)
 510                                         d[i] = (unsigned int)(s[i]+s[i+1]+1)>>1;
 511                                 s+= lx;
 512                                 d+= lx;
 513                         }
 514         else /* if (xh && yh) */
 515                 if (addflag)
 516                         for (j=0; j<h; j++)
 517                         {
 518                                 for (i=0; i<w; i++)
 519                                         d[i] = (d[i] + ((unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2)+1)>>1;
 520                                 s+= lx;
 521                                 d+= lx;
 522                         }
 523                 else
 524                         for (j=0; j<h; j++)
 525                         {
 526                                 for (i=0; i<w; i++)
 527                                         d[i] = (unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
 528                                 s+= lx;
 529                                 d+= lx;
 530                         }
 531 }
 532
 533 #ifdef X86_CPU
 534 static void pred_comp_mmxe(
 535         pict_data_s *picture,
 536         uint8_t *src,
 537         uint8_t *dst,
 538         int lx,
 539         int w, int h,
 540         int x, int y,
 541         int dx, int dy,
 542         int addflag)
 543 {
 544         int xint, xh, yint, yh;
 545         uint8_t *s, *d;
 546
 547         /* half pel scaling */
 548         xint = dx>>1; /* integer part */
 549         xh = dx & 1;  /* half pel flag */
 550         yint = dy>>1;
 551         yh = dy & 1;
 552
 553         /* origins */
 554         s = src + lx*(y+yint) + (x+xint); /* motion vector */
 555         d = dst + lx*y + x;
 556
 557         if( xh )
 558         {
 559                 if( yh )
 560                         predcomp_11_mmxe(s,d,lx,w,h,addflag);
 561                 else /* !yh */
 562                         predcomp_10_mmxe(s,d,lx,w,h,addflag);
 563         }
 564         else /* !xh */
 565         {
 566                 if( yh )
 567                         predcomp_01_mmxe(s,d,lx,w,h,addflag);
 568                 else /* !yh */
 569                         predcomp_00_mmxe(s,d,lx,w,h,addflag);
 570         }
 571
 572 }
 573
 574 static void pred_comp_mmx(
 575         pict_data_s *picture,
 576         uint8_t *src,
 577         uint8_t *dst,
 578         int lx,
 579         int w, int h,
 580         int x, int y,
 581         int dx, int dy,
 582         int addflag)
 583 {
 584         int xint, xh, yint, yh;
 585         uint8_t *s, *d;
 586
 587         /* half pel scaling */
 588         xint = dx>>1; /* integer part */
 589         xh = dx & 1;  /* half pel flag */
 590         yint = dy>>1;
 591         yh = dy & 1;
 592
 593         /* origins */
 594         s = src + lx*(y+yint) + (x+xint); /* motion vector */
 595         d = dst + lx*y + x;
 596
 597         if( xh )
 598         {
 599                 if( yh )
 600                         predcomp_11_mmx(s,d,lx,w,h,addflag);
 601                 else /* !yh */
 602                         predcomp_10_mmx(s,d,lx,w,h,addflag);
 603         }
 604         else /* !xh */
 605         {
 606                 if( yh )
 607                         predcomp_01_mmx(s,d,lx,w,h,addflag);
 608                 else /* !yh */
 609                         predcomp_00_mmx(s,d,lx,w,h,addflag);
 610         }
 611
 612 }
 613 #endif
 614
 615 /* calculate derived motion vectors (DMV) for dual prime prediction
 616  * dmvector[2]: differential motion vectors (-1,0,+1)
 617  * mvx,mvy: motion vector (for same parity)
 618  *
 619  * DMV[2][2]: derived motion vectors (for opposite parity)
 620  *
 621  * uses global variables pict_struct and topfirst
 622  *
 623  * Notes:
 624  *  - all vectors are in field coordinates (even for frame pictures)
 625  */
 626
 627 static void calc_DMV(
 628         pict_data_s *picture,int DMV[][2],
 629         int *dmvector, int mvx, int mvy
 630 )
 631 {
 632   if (picture->pict_struct==FRAME_PICTURE)
 633   {
 634     if (picture->topfirst)
 635     {
 636       /* vector for prediction of top field from bottom field */
 637       DMV[0][0] = ((mvx  +(mvx>0))>>1) + dmvector[0];
 638       DMV[0][1] = ((mvy  +(mvy>0))>>1) + dmvector[1] - 1;
 639
 640       /* vector for prediction of bottom field from top field */
 641       DMV[1][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];
 642       DMV[1][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] + 1;
 643     }
 644     else
 645     {
 646       /* vector for prediction of top field from bottom field */
 647       DMV[0][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];
 648       DMV[0][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] - 1;
 649
 650       /* vector for prediction of bottom field from top field */
 651       DMV[1][0] = ((mvx  +(mvx>0))>>1) + dmvector[0];
 652       DMV[1][1] = ((mvy  +(mvy>0))>>1) + dmvector[1] + 1;
 653     }
 654   }
 655   else
 656   {
 657     /* vector for prediction from field of opposite 'parity' */
 658     DMV[0][0] = ((mvx+(mvx>0))>>1) + dmvector[0];
 659     DMV[0][1] = ((mvy+(mvy>0))>>1) + dmvector[1];
 660
 661     /* correct for vertical field shift */
 662     if (picture->pict_struct==TOP_FIELD)
 663       DMV[0][1]--;
 664     else
 665       DMV[0][1]++;
 666   }
 667 }
 668
 669 static void clearblock(
 670         pict_data_s *picture,
 671         uint8_t *cur[], int i0, int j0
 672         )
 673 {
 674   int i, j, w, h;
 675   uint8_t *p;
 676
 677   p = cur[0] + ((picture->pict_struct==BOTTOM_FIELD) ? width : 0) + i0 + width2*j0;
 678
 679   for (j=0; j<16; j++)
 680   {
 681     for (i=0; i<16; i++)
 682       p[i] = 128;
 683     p+= width2;
 684   }
 685
 686   w = h = 16;
 687
 688   if (chroma_format!=CHROMA444)
 689   {
 690     i0>>=1; w>>=1;
 691   }
 692
 693   if (chroma_format==CHROMA420)
 694   {
 695     j0>>=1; h>>=1;
 696   }
 697
 698   p = cur[1] + ((picture->pict_struct==BOTTOM_FIELD) ? chrom_width : 0) + i0
 699              + chrom_width2*j0;
 700
 701   for (j=0; j<h; j++)
 702   {
 703     for (i=0; i<w; i++)
 704       p[i] = 128;
 705     p+= chrom_width2;
 706   }
 707
 708   p = cur[2] + ((picture->pict_struct==BOTTOM_FIELD) ? chrom_width : 0) + i0
 709              + chrom_width2*j0;
 710
 711   for (j=0; j<h; j++)
 712   {
 713     for (i=0; i<w; i++)
 714       p[i] = 128;
 715     p+= chrom_width2;
 716   }
 717 }