frameworks/base/media/libstagefright/codecs/m4v_h263/enc/src/motion_comp.cpp

   1 /* ------------------------------------------------------------------
   2  * Copyright (C) 1998-2009 PacketVideo
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  13  * express or implied.
  14  * See the License for the specific language governing permissions
  15  * and limitations under the License.
  16  * -------------------------------------------------------------------
  17  */
  18 #include "mp4lib_int.h"
  19 #include "mp4enc_lib.h"
  20
  21 //const static Int roundtab4[] = {0,1,1,1};
  22 //const static Int roundtab8[] = {0,0,1,1,1,1,1,2};
  23 //const static Int roundtab12[] = {0,0,0,1,1,1,1,1,1,1,2,2};
  24 const static Int roundtab16[] = {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
  25
  26 #define FORWARD_MODE    1
  27 #define BACKWARD_MODE   2
  28 #define BIDIRECTION_MODE    3
  29 #define DIRECT_MODE         4
  30
  31 #ifdef __cplusplus
  32 extern "C"
  33 {
  34 #endif
  35     /*Function Prototype */
  36     /* no-edge padding */
  37     Int EncGetPredOutside(Int xpos, Int ypos, UChar *c_prev, UChar *rec,
  38     Int width, Int height, Int rnd1);
  39
  40     void Copy_MB_from_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int width);
  41     void Copy_B_from_Vop(UChar *comp, Int cChan[], Int width);
  42     void Copy_MB_into_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int width);
  43     void Copy_B_into_Vop(UChar *comp, Int cChan[], Int width);
  44     void get_MB(UChar *c_prev, UChar *c_prev_u  , UChar *c_prev_v,
  45                 Short mb[6][64], Int lx, Int lx_uv);
  46
  47     Int GetPredAdvBy0x0(
  48         UChar *c_prev,      /* i */
  49         UChar *pred_block,      /* i */
  50         Int lx,     /* i */
  51         Int rnd1 /* i */
  52     );
  53
  54     Int GetPredAdvBy0x1(
  55         UChar *c_prev,      /* i */
  56         UChar *pred_block,      /* i */
  57         Int lx,     /* i */
  58         Int rnd1 /* i */
  59     );
  60
  61     Int GetPredAdvBy1x0(
  62         UChar *c_prev,      /* i */
  63         UChar *pred_block,      /* i */
  64         Int lx,     /* i */
  65         Int rnd1 /* i */
  66     );
  67
  68     Int GetPredAdvBy1x1(
  69         UChar *c_prev,      /* i */
  70         UChar *pred_block,      /* i */
  71         Int lx,     /* i */
  72         Int rnd1 /* i */
  73     );
  74
  75     static Int(*const GetPredAdvBTable[2][2])(UChar*, UChar*, Int, Int) =
  76     {
  77         {&GetPredAdvBy0x0, &GetPredAdvBy0x1},
  78         {&GetPredAdvBy1x0, &GetPredAdvBy1x1}
  79     };
  80
  81
  82 #ifdef __cplusplus
  83 }
  84 #endif
  85
  86
  87 /* ======================================================================== */
  88 /*  Function : getMotionCompensatedMB( )                                    */
  89 /*  Date     : 4/17/2001                                                    */
  90 /*  Purpose  : Get the motion compensate block into video->predictionMB     */
  91 /*              and generate video->predictionErrorMB                       */
  92 /*              modified from MBMotionComp() function in the decoder        */
  93 /*  In/out   :                                                              */
  94 /*  Return   :                                                              */
  95 /*  Modified :                                                              */
  96 /* ======================================================================== */
  97
  98 void getMotionCompensatedMB(VideoEncData *video, Int ind_x, Int ind_y, Int offset)
  99 {
 100     Vop *prevVop = video->forwardRefVop; //reference frame
 101     Vop *currVop = video->currVop;
 102     Int mbnum = video->mbnum;       //mb index
 103     MOT *mot = video->mot[mbnum];
 104     Int ypos, xpos;
 105     UChar *c_prev, *cu_prev, *cv_prev;
 106     UChar *c_rec, *cu_rec, *cv_rec;
 107     Int height, pitch, pitch_uv, height_uv;
 108     Int mode = video->headerInfo.Mode[mbnum];  /* get mode */
 109     Int dx, dy;
 110     Int xpred, ypred;
 111     Int xsum, ysum;
 112     Int round1;
 113
 114     OSCL_UNUSED_ARG(offset);
 115
 116     round1 = (Int)(1 - video->currVop->roundingType);
 117
 118     pitch  = currVop->pitch;
 119     height = currVop->height;
 120     pitch_uv  = pitch >> 1;
 121     height_uv = height >> 1;
 122
 123     ypos = ind_y << 4 ;
 124     xpos = ind_x << 4 ;
 125
 126     c_rec = video->predictedMB;
 127     cu_rec = video->predictedMB + 256;
 128     cv_rec = video->predictedMB + 264;
 129
 130     if (mode == MODE_INTER || mode == MODE_INTER_Q)
 131     {
 132         /* Motion vector in x direction       */
 133         dx = mot[0].x;
 134         dy = mot[0].y;
 135
 136         c_prev  = prevVop->yChan;
 137
 138         xpred = (xpos << 1) + dx ;
 139         ypred = (ypos << 1) + dy ;
 140
 141         /* Call function that performs luminance prediction */
 142         EncPrediction_INTER(xpred, ypred, c_prev, c_rec,
 143                             pitch, round1);
 144
 145         if ((dx & 3) == 0)  dx = dx >> 1;
 146         else        dx = (dx >> 1) | 1;
 147
 148         if ((dy & 3) == 0)      dy = dy >> 1;
 149         else        dy = (dy >> 1) | 1;
 150
 151         xpred = xpos + dx;
 152         ypred = ypos + dy;
 153
 154         cu_prev = prevVop->uChan;
 155         cv_prev = prevVop->vChan;
 156
 157         EncPrediction_Chrom(xpred, ypred, cu_prev, cv_prev, cu_rec, cv_rec,
 158                             pitch_uv, (currVop->width) >> 1, height_uv, round1);
 159     }
 160 #ifndef NO_INTER4V
 161     else if (mode == MODE_INTER4V)
 162     {
 163         c_prev  = prevVop->yChan;
 164         cu_prev = prevVop->uChan;
 165         cv_prev = prevVop->vChan;
 166
 167         EncPrediction_INTER4V(xpos, ypos, mot, c_prev, c_rec,
 168                               pitch, round1);
 169
 170         xsum = mot[1].x + mot[2].x + mot[3].x + mot[4].x;
 171         ysum = mot[1].y + mot[2].y + mot[3].y + mot[4].y;
 172
 173         dx = PV_SIGN(xsum) * (roundtab16[(PV_ABS(xsum)) & 0xF] +
 174                               (((PV_ABS(xsum)) >> 4) << 1));
 175         dy = PV_SIGN(ysum) * (roundtab16[(PV_ABS(ysum)) & 0xF] +
 176                               (((PV_ABS(ysum)) >> 4) << 1));
 177
 178         ypred = ypos + dy;
 179         xpred = xpos + dx;
 180
 181         EncPrediction_Chrom(xpred, ypred, cu_prev, cv_prev, cu_rec, cv_rec,
 182                             pitch_uv, (currVop->width) >> 1, height_uv, round1);
 183     }
 184 #endif
 185     else
 186     {
 187         ;//printf("Error, MODE_SKIPPED is not decided yet!\n");
 188     }
 189
 190     return ;
 191 }
 192
 193 /***************************************************************************
 194     Function:   EncPrediction_INTER
 195     Date:       04/17/2001
 196     Purpose:    Get predicted area for luminance and compensate with the residue.
 197                 Modified from luminance_pred_mode_inter() in decoder.
 198 ***************************************************************************/
 199
 200 void EncPrediction_INTER(
 201     Int xpred,          /* i */
 202     Int ypred,          /* i */
 203     UChar *c_prev,          /* i */
 204     UChar *c_rec,       /* i */
 205     Int lx,         /* i */
 206     Int round1          /* i */
 207 )
 208 {
 209     c_prev += (xpred >> 1) + ((ypred >> 1) * lx);
 210
 211     GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
 212
 213     c_prev += B_SIZE;
 214     c_rec += B_SIZE;
 215
 216     GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
 217
 218     c_prev += (lx << 3) - B_SIZE;
 219     c_rec += (16 << 3) - B_SIZE; /* padding */
 220
 221     GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
 222
 223     c_prev += B_SIZE;
 224     c_rec += B_SIZE;
 225
 226     GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
 227
 228     return;
 229 }
 230
 231 #ifndef NO_INTER4V
 232 /***************************************************************************
 233     Function:   EncPrediction_INTER4V
 234     Date:       04/17/2001
 235     Purpose:    Get predicted area for luminance and compensate with the residue.
 236                 Modified from luminance_pred_mode_inter4v() in decoder.
 237 ***************************************************************************/
 238
 239 void EncPrediction_INTER4V(
 240     Int xpos,           /* i */
 241     Int ypos,           /* i */
 242     MOT *mot,           /* i */
 243     UChar *c_prev,          /* i */
 244     UChar *c_rec,           /* i */
 245     Int lx,         /* i */
 246     Int round1          /* i */
 247 )
 248 {
 249     Int ypred, xpred;
 250
 251     xpred = (Int)((xpos << 1) + mot[1].x);
 252     ypred = (Int)((ypos << 1) + mot[1].y);
 253
 254     GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
 255                                        c_rec, lx, round1);
 256
 257     c_rec += B_SIZE;
 258
 259     xpred = (Int)(((xpos + B_SIZE) << 1) + mot[2].x);
 260     ypred = (Int)((ypos << 1) + mot[2].y);
 261
 262     GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
 263                                        c_rec, lx, round1);
 264
 265     c_rec += (16 << 3) - B_SIZE; /* padding */
 266
 267     xpred = (Int)((xpos << 1) + mot[3].x);
 268     ypred = (Int)(((ypos + B_SIZE) << 1) + mot[3].y);
 269
 270     GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
 271                                        c_rec, lx, round1);
 272
 273     c_rec += B_SIZE;
 274
 275     xpred = (Int)(((xpos + B_SIZE) << 1) + mot[4].x);
 276     ypred = (Int)(((ypos + B_SIZE) << 1) + mot[4].y);
 277
 278     GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
 279                                        c_rec, lx, round1);
 280
 281     return;
 282 }
 283 #endif /* NO_INTER4V */
 284
 285 /***************************************************************************
 286     Function:   EncPrediction_Chrom
 287     Date:       04/17/2001
 288     Purpose:    Get predicted area for chrominance and compensate with the residue.
 289                 Modified from chrominance_pred() in decoder.
 290 ***************************************************************************/
 291
 292 void EncPrediction_Chrom(
 293     Int xpred,          /* i */
 294     Int ypred,          /* i */
 295     UChar *cu_prev,         /* i */
 296     UChar *cv_prev,         /* i */
 297     UChar *cu_rec,
 298     UChar *cv_rec,
 299     Int lx,
 300     Int width_uv,           /* i */
 301     Int height_uv,          /* i */
 302     Int round1          /* i */
 303 )
 304 {
 305     /* check whether the MV points outside the frame */
 306     /* Compute prediction for Chrominance b block (block[4]) */
 307     if (xpred >= 0 && xpred <= ((width_uv << 1) - (2*B_SIZE)) && ypred >= 0 &&
 308             ypred <= ((height_uv << 1) - (2*B_SIZE)))
 309     {
 310         /*****************************/
 311         /* (x,y) is inside the frame */
 312         /*****************************/
 313
 314         /* Compute prediction for Chrominance b (block[4]) */
 315         GetPredAdvBTable[ypred&1][xpred&1](cu_prev + (xpred >> 1) + ((ypred >> 1)*lx),
 316                                            cu_rec, lx, round1);
 317
 318         /* Compute prediction for Chrominance r (block[5]) */
 319         GetPredAdvBTable[ypred&1][xpred&1](cv_prev + (xpred >> 1) + ((ypred >> 1)*lx),
 320                                            cv_rec,  lx, round1);
 321     }
 322     else
 323     {
 324         /******************************/
 325         /* (x,y) is outside the frame */
 326         /******************************/
 327
 328         /* Compute prediction for Chrominance b (block[4]) */
 329         EncGetPredOutside(xpred, ypred,
 330                           cu_prev, cu_rec,
 331                           width_uv, height_uv, round1);
 332
 333         /* Compute prediction for Chrominance r (block[5]) */
 334         EncGetPredOutside(xpred, ypred,
 335                           cv_prev, cv_rec,
 336                           width_uv, height_uv, round1);
 337     }
 338
 339     return;
 340 }
 341 /***************************************************************************
 342     Function:   GetPredAdvancedB
 343     Date:       04/17/2001
 344     Purpose:    Get predicted area (block) and compensate with the residue.
 345                 - modified from GetPredAdvancedBAdd in decoder.
 346     Intput/Output:
 347     Modified:
 348 ***************************************************************************/
 349
 350 Int GetPredAdvBy0x0(
 351     UChar *prev,        /* i */
 352     UChar *rec,     /* i */
 353     Int lx,     /* i */
 354     Int rnd /* i */
 355 )
 356 {
 357     Int i;      /* loop variable */
 358     ULong  pred_word, word1, word2;
 359     Int tmp;
 360
 361     OSCL_UNUSED_ARG(rnd);
 362
 363     /* initialize offset to adjust pixel counter */
 364     /*    the next row; full-pel resolution      */
 365
 366     tmp = (ULong)prev & 0x3;
 367
 368     if (tmp == 0)  /* word-aligned */
 369     {
 370         rec -= 16; /* preset */
 371         prev -= lx;
 372
 373         for (i = 8; i > 0; i--)
 374         {
 375             *((ULong*)(rec += 16)) = *((ULong*)(prev += lx));
 376             *((ULong*)(rec + 4)) = *((ULong*)(prev + 4));
 377         }
 378         return 1;
 379     }
 380     else if (tmp == 1) /* first position */
 381     {
 382         prev--; /* word-aligned */
 383         rec -= 16; /* preset */
 384         prev -= lx;
 385
 386         for (i = 8; i > 0; i--)
 387         {
 388             word1 = *((ULong*)(prev += lx)); /* read 4 bytes, b4 b3 b2 b1 */
 389             word2 = *((ULong*)(prev + 4));  /* read 4 bytes, b8 b7 b6 b5 */
 390             word1 >>= 8; /* 0 b4 b3 b2 */
 391             pred_word = word1 | (word2 << 24);  /* b5 b4 b3 b2 */
 392             *((ULong*)(rec += 16)) = pred_word;
 393
 394             word1 = *((ULong*)(prev + 8)); /* b12 b11 b10 b9 */
 395             word2 >>= 8; /* 0 b8 b7 b6 */
 396             pred_word = word2 | (word1 << 24); /* b9 b8 b7 b6 */
 397             *((ULong*)(rec + 4)) = pred_word;
 398         }
 399
 400         return 1;
 401     }
 402     else if (tmp == 2) /* second position */
 403     {
 404         prev -= 2; /* word1-aligned */
 405         rec -= 16; /* preset */
 406         prev -= lx;
 407
 408         for (i = 8; i > 0; i--)
 409         {
 410             word1 = *((ULong*)(prev += lx)); /* read 4 bytes, b4 b3 b2 b1 */
 411             word2 = *((ULong*)(prev + 4));  /* read 4 bytes, b8 b7 b6 b5 */
 412             word1 >>= 16; /* 0 0 b4 b3 */
 413             pred_word = word1 | (word2 << 16);  /* b6 b5 b4 b3 */
 414             *((ULong*)(rec += 16)) = pred_word;
 415
 416             word1 = *((ULong*)(prev + 8)); /* b12 b11 b10 b9 */
 417             word2 >>= 16; /* 0 0 b8 b7 */
 418             pred_word = word2 | (word1 << 16); /* b10 b9 b8 b7 */
 419             *((ULong*)(rec + 4)) = pred_word;
 420         }
 421
 422         return 1;
 423     }
 424     else /* third position */
 425     {
 426         prev -= 3; /* word1-aligned */
 427         rec -= 16; /* preset */
 428         prev -= lx;
 429
 430         for (i = 8; i > 0; i--)
 431         {
 432             word1 = *((ULong*)(prev += lx)); /* read 4 bytes, b4 b3 b2 b1 */
 433             word2 = *((ULong*)(prev + 4));  /* read 4 bytes, b8 b7 b6 b5 */
 434             word1 >>= 24; /* 0 0 0 b4 */
 435             pred_word = word1 | (word2 << 8);   /* b7 b6 b5 b4 */
 436             *((ULong*)(rec += 16)) = pred_word;
 437
 438             word1 = *((ULong*)(prev + 8)); /* b12 b11 b10 b9 */
 439             word2 >>= 24; /* 0 0 0 b8 */
 440             pred_word = word2 | (word1 << 8); /* b11 b10 b9 b8 */
 441             *((ULong*)(rec + 4)) = pred_word;
 442
 443         }
 444
 445         return 1;
 446     }
 447 }
 448 /**************************************************************************/
 449 Int GetPredAdvBy0x1(
 450     UChar *prev,        /* i */
 451     UChar *rec,     /* i */
 452     Int lx,     /* i */
 453     Int rnd1 /* i */
 454 )
 455 {
 456     Int i;      /* loop variable */
 457     Int offset;
 458     ULong word1, word2, word3, word12;
 459     Int tmp;
 460     ULong mask;
 461
 462     /* initialize offset to adjust pixel counter */
 463     /*    the next row; full-pel resolution      */
 464     offset = lx - B_SIZE; /* offset for prev */
 465
 466     /* Branch based on pixel location (half-pel or full-pel) for x and y */
 467     rec -= 12; /* preset */
 468
 469     tmp = (ULong)prev & 3;
 470     mask = 254;
 471     mask |= (mask << 8);
 472     mask |= (mask << 16); /* 0xFEFEFEFE */
 473
 474     if (tmp == 0) /* word-aligned */
 475     {
 476         if (rnd1 == 1)
 477         {
 478             for (i = B_SIZE; i > 0; i--)
 479             {
 480                 word1 = *((ULong*)prev); /* b4 b3 b2 b1 */
 481                 word2 = *((ULong*)(prev += 4)); /* b8 b7 b6 b5 */
 482                 word12 = (word1 >> 8); /* 0 b4 b3 b2 */
 483                 word12 |= (word2 << 24); /* b5 b4 b3 b2 */
 484                 word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
 485                 word1 &= mask;
 486                 word3 &= (~mask); /* 0x1010101, check last bit */
 487                 word12 &= mask;
 488                 word1 >>= 1;
 489                 word1 = word1 + (word12 >> 1);
 490                 word1 += word3;
 491                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 492
 493                 word1 = *((ULong*)(prev += 4)); /* b12 b11 b10 b9 */
 494                 word12 = (word2 >> 8); /* 0 b8 b7 b6 */
 495                 word12 |= (word1 << 24); /* b9 b8 b7 b6 */
 496                 word3 = word2 | word12;
 497                 word2 &= mask;
 498                 word3 &= (~mask);  /* 0x1010101, check last bit */
 499                 word12 &= mask;
 500                 word2 >>= 1;
 501                 word2 = word2 + (word12 >> 1);
 502                 word2 += word3;
 503                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 504
 505                 prev += offset;
 506             }
 507             return 1;
 508         }
 509         else /* rnd1 == 0 */
 510         {
 511             for (i = B_SIZE; i > 0; i--)
 512             {
 513                 word1 = *((ULong*)prev); /* b4 b3 b2 b1 */
 514
 515                 word2 = *((ULong*)(prev += 4)); /* b8 b7 b6 b5 */
 516                 word12 = (word1 >> 8); /* 0 b4 b3 b2 */
 517                 word12 |= (word2 << 24); /* b5 b4 b3 b2 */
 518                 word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
 519                 word1 &= mask;
 520                 word3 &= (~mask); /* 0x1010101, check last bit */
 521                 word12 &= mask;
 522                 word1 >>= 1;
 523                 word1 = word1 + (word12 >> 1);
 524                 word1 += word3;
 525                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 526
 527                 word1 = *((ULong*)(prev += 4)); /* b12 b11 b10 b9 */
 528                 word12 = (word2 >> 8); /* 0 b8 b7 b6 */
 529                 word12 |= (word1 << 24); /* b9 b8 b7 b6 */
 530                 word3 = word2 & word12;
 531                 word2 &= mask;
 532                 word3 &= (~mask);  /* 0x1010101, check last bit */
 533                 word12 &= mask;
 534                 word2 >>= 1;
 535                 word2 = word2 + (word12 >> 1);
 536                 word2 += word3;
 537                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 538
 539                 prev += offset;
 540             }
 541             return 1;
 542         } /* rnd1 */
 543     }
 544     else if (tmp == 1)
 545     {
 546         prev--; /* word-aligned */
 547         if (rnd1 == 1)
 548         {
 549             for (i = B_SIZE; i > 0; i--)
 550             {
 551                 word1 = *((ULong*)prev); /* b3 b2 b1 b0 */
 552                 word2 = *((ULong*)(prev += 4)); /* b7 b6 b5 b4 */
 553                 word12 = (word1 >> 8); /* 0 b3 b2 b1 */
 554                 word1 >>= 16; /* 0 0 b3 b2 */
 555                 word12 |= (word2 << 24); /* b4 b3 b2 b1 */
 556                 word1 |= (word2 << 16); /* b5 b4 b3 b2 */
 557                 word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
 558                 word1 &= mask;
 559                 word3 &= (~mask); /* 0x1010101, check last bit */
 560                 word12 &= mask;
 561                 word1 >>= 1;
 562                 word1 = word1 + (word12 >> 1);
 563                 word1 += word3;
 564                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 565
 566                 word1 = *((ULong*)(prev += 4)); /* b11 b10 b9 b8 */
 567                 word12 = (word2 >> 8); /* 0 b7 b6 b5 */
 568                 word2 >>= 16; /* 0 0 b7 b6 */
 569                 word12 |= (word1 << 24); /* b8 b7 b6 b5 */
 570                 word2 |= (word1 << 16); /* b9 b8 b7 b6 */
 571                 word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word2&word12
 572                 word2 &= mask;
 573                 word3 &= (~mask); /* 0x1010101, check last bit */
 574                 word12 &= mask;
 575                 word2 >>= 1;
 576                 word2 = word2 + (word12 >> 1);
 577                 word2 += word3;
 578                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 579
 580                 prev += offset;
 581             }
 582             return 1;
 583         }
 584         else /* rnd1 = 0 */
 585         {
 586             for (i = B_SIZE; i > 0; i--)
 587             {
 588                 word1 = *((ULong*)prev); /* b3 b2 b1 b0 */
 589
 590                 word2 = *((ULong*)(prev += 4)); /* b7 b6 b5 b4 */
 591                 word12 = (word1 >> 8); /* 0 b3 b2 b1 */
 592                 word1 >>= 16; /* 0 0 b3 b2 */
 593                 word12 |= (word2 << 24); /* b4 b3 b2 b1 */
 594                 word1 |= (word2 << 16); /* b5 b4 b3 b2 */
 595                 word3 = word1 & word12;
 596                 word1 &= mask;
 597                 word3 &= (~mask); /* 0x1010101, check last bit */
 598                 word12 &= mask;
 599                 word1 >>= 1;
 600                 word1 = word1 + (word12 >> 1);
 601                 word1 += word3;
 602                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 603
 604                 word1 = *((ULong*)(prev += 4)); /* b11 b10 b9 b8 */
 605                 word12 = (word2 >> 8); /* 0 b7 b6 b5 */
 606                 word2 >>= 16; /* 0 0 b7 b6 */
 607                 word12 |= (word1 << 24); /* b8 b7 b6 b5 */
 608                 word2 |= (word1 << 16); /* b9 b8 b7 b6 */
 609                 word3 = word2 & word12;
 610                 word2 &= mask;
 611                 word3 &= (~mask); /* 0x1010101, check last bit */
 612                 word12 &= mask;
 613                 word2 >>= 1;
 614                 word2 = word2 + (word12 >> 1);
 615                 word2 += word3;
 616                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 617
 618                 prev += offset;
 619             }
 620             return 1;
 621         } /* rnd1 */
 622     }
 623     else if (tmp == 2)
 624     {
 625         prev -= 2; /* word-aligned */
 626         if (rnd1 == 1)
 627         {
 628             for (i = B_SIZE; i > 0; i--)
 629             {
 630                 word1 = *((ULong*)prev); /* b2 b1 b0 bN1 */
 631                 word2 = *((ULong*)(prev += 4)); /* b6 b5 b4 b3 */
 632                 word12 = (word1 >> 16); /* 0 0 b2 b1 */
 633                 word1 >>= 24; /* 0 0 0 b2 */
 634                 word12 |= (word2 << 16); /* b4 b3 b2 b1 */
 635                 word1 |= (word2 << 8); /* b5 b4 b3 b2 */
 636                 word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
 637                 word1 &= mask;
 638                 word3 &= (~mask); /* 0x1010101, check last bit */
 639                 word12 &= mask;
 640                 word1 >>= 1;
 641                 word1 = word1 + (word12 >> 1);
 642                 word1 += word3;
 643                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 644
 645                 word1 = *((ULong*)(prev += 4)); /* b10 b9 b8 b7 */
 646                 word12 = (word2 >> 16); /* 0 0 b6 b5 */
 647                 word2 >>= 24; /* 0 0 0 b6 */
 648                 word12 |= (word1 << 16); /* b8 b7 b6 b5 */
 649                 word2 |= (word1 << 8); /* b9 b8 b7 b6 */
 650                 word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word1&word12
 651                 word2 &= mask;
 652                 word3 &= (~mask); /* 0x1010101, check last bit */
 653                 word12 &= mask;
 654                 word2 >>= 1;
 655                 word2 = word2 + (word12 >> 1);
 656                 word2 += word3;
 657                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 658                 prev += offset;
 659             }
 660             return 1;
 661         }
 662         else /* rnd1 == 0 */
 663         {
 664             for (i = B_SIZE; i > 0; i--)
 665             {
 666                 word1 = *((ULong*)prev); /* b2 b1 b0 bN1 */
 667                 word2 = *((ULong*)(prev += 4)); /* b6 b5 b4 b3 */
 668                 word12 = (word1 >> 16); /* 0 0 b2 b1 */
 669                 word1 >>= 24; /* 0 0 0 b2 */
 670                 word12 |= (word2 << 16); /* b4 b3 b2 b1 */
 671                 word1 |= (word2 << 8); /* b5 b4 b3 b2 */
 672                 word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
 673                 word1 &= mask;
 674                 word3 &= (~mask); /* 0x1010101, check last bit */
 675                 word12 &= mask;
 676                 word1 >>= 1;
 677                 word1 = word1 + (word12 >> 1);
 678                 word1 += word3;
 679                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 680
 681                 word1 = *((ULong*)(prev += 4)); /* b10 b9 b8 b7 */
 682                 word12 = (word2 >> 16); /* 0 0 b6 b5 */
 683                 word2 >>= 24; /* 0 0 0 b6 */
 684                 word12 |= (word1 << 16); /* b8 b7 b6 b5 */
 685                 word2 |= (word1 << 8); /* b9 b8 b7 b6 */
 686                 word3 = word2 & word12; // rnd1 = 1; otherwise word3 = word1&word12
 687                 word2 &= mask;
 688                 word3 &= (~mask); /* 0x1010101, check last bit */
 689                 word12 &= mask;
 690                 word2 >>= 1;
 691                 word2 = word2 + (word12 >> 1);
 692                 word2 += word3;
 693                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 694                 prev += offset;
 695             }
 696             return 1;
 697         }
 698     }
 699     else /* tmp = 3 */
 700     {
 701         prev -= 3; /* word-aligned */
 702         if (rnd1 == 1)
 703         {
 704             for (i = B_SIZE; i > 0; i--)
 705             {
 706                 word1 = *((ULong*)prev); /* b1 b0 bN1 bN2 */
 707                 word2 = *((ULong*)(prev += 4)); /* b5 b4 b3 b2 */
 708                 word12 = (word1 >> 24); /* 0 0 0 b1 */
 709                 word12 |= (word2 << 8); /* b4 b3 b2 b1 */
 710                 word1 = word2;
 711                 word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
 712                 word1 &= mask;
 713                 word3 &= (~mask); /* 0x1010101, check last bit */
 714                 word12 &= mask;
 715                 word1 >>= 1;
 716                 word1 = word1 + (word12 >> 1);
 717                 word1 += word3;
 718                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 719
 720                 word1 = *((ULong*)(prev += 4)); /* b9 b8 b7 b6 */
 721                 word12 = (word2 >> 24); /* 0 0 0 b5 */
 722                 word12 |= (word1 << 8); /* b8 b7 b6 b5 */
 723                 word2 = word1; /* b9 b8 b7 b6 */
 724                 word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word1&word12
 725                 word2 &= mask;
 726                 word3 &= (~mask); /* 0x1010101, check last bit */
 727                 word12 &= mask;
 728                 word2 >>= 1;
 729                 word2 = word2 + (word12 >> 1);
 730                 word2 += word3;
 731                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 732                 prev += offset;
 733             }
 734             return 1;
 735         }
 736         else
 737         {
 738             for (i = B_SIZE; i > 0; i--)
 739             {
 740                 word1 = *((ULong*)prev); /* b1 b0 bN1 bN2 */
 741                 word2 = *((ULong*)(prev += 4)); /* b5 b4 b3 b2 */
 742                 word12 = (word1 >> 24); /* 0 0 0 b1 */
 743                 word12 |= (word2 << 8); /* b4 b3 b2 b1 */
 744                 word1 = word2;
 745                 word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
 746                 word1 &= mask;
 747                 word3 &= (~mask); /* 0x1010101, check last bit */
 748                 word12 &= mask;
 749                 word1 >>= 1;
 750                 word1 = word1 + (word12 >> 1);
 751                 word1 += word3;
 752                 *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
 753
 754                 word1 = *((ULong*)(prev += 4)); /* b9 b8 b7 b6 */
 755                 word12 = (word2 >> 24); /* 0 0 0 b5 */
 756                 word12 |= (word1 << 8); /* b8 b7 b6 b5 */
 757                 word2 = word1; /* b9 b8 b7 b6 */
 758                 word3 = word2 & word12; // rnd1 = 1; otherwise word3 = word1&word12
 759                 word2 &= mask;
 760                 word3 &= (~mask); /* 0x1010101, check last bit */
 761                 word12 &= mask;
 762                 word2 >>= 1;
 763                 word2 = word2 + (word12 >> 1);
 764                 word2 += word3;
 765                 *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
 766                 prev += offset;
 767             }
 768             return 1;
 769         }
 770     }
 771 }
 772
 773 /**************************************************************************/
 774 Int GetPredAdvBy1x0(
 775     UChar *prev,        /* i */
 776     UChar *rec,     /* i */
 777     Int lx,     /* i */
 778     Int rnd1 /* i */
 779 )
 780 {
 781     Int i;      /* loop variable */
 782     Int offset;
 783     ULong  word1, word2, word3, word12, word22;
 784     Int tmp;
 785     ULong mask;
 786
 787     /* initialize offset to adjust pixel counter */
 788     /*    the next row; full-pel resolution      */
 789     offset = lx - B_SIZE; /* offset for prev */
 790
 791     /* Branch based on pixel location (half-pel or full-pel) for x and y */
 792     rec -= 12; /* preset */
 793
 794     tmp = (ULong)prev & 3;
 795     mask = 254;
 796     mask |= (mask << 8);
 797     mask |= (mask << 16); /* 0xFEFEFEFE */
 798
 799     if (tmp == 0) /* word-aligned */
 800     {
 801         prev -= 4;
 802         if (rnd1 == 1)
 803         {
 804             for (i = B_SIZE; i > 0; i--)
 805             {
 806                 word1 = *((ULong*)(prev += 4));
 807                 word2 = *((ULong*)(prev + lx));
 808                 word3 = word1 | word2; // rnd1 = 1; otherwise word3 = word1&word2
 809                 word1 &= mask;
 810                 word3 &= (~mask); /* 0x1010101, check last bit */
 811                 word2 &= mask;
 812                 word1 >>= 1;
 813                 word1 = word1 + (word2 >> 1);
 814                 word1 += word3;
 815                 *((ULong*)(rec += 12)) = word1;
 816                 word1 = *((ULong*)(prev += 4));
 817                 word2 = *((ULong*)(prev + lx));
 818                 word3 = word1 | word2; // rnd1 = 1; otherwise word3 = word1&word2
 819                 word1 &= mask;
 820                 word3 &= (~mask); /* 0x1010101, check last bit */
 821                 word2 &= mask;
 822                 word1 >>= 1;
 823                 word1 = word1 + (word2 >> 1);
 824                 word1 += word3;
 825                 *((ULong*)(rec += 4)) = word1;
 826
 827                 prev += offset;
 828             }
 829             return 1;
 830         }
 831         else   /* rnd1 = 0 */
 832         {
 833             for (i = B_SIZE; i > 0; i--)
 834             {
 835                 word1 = *((ULong*)(prev += 4));
 836                 word2 = *((ULong*)(prev + lx));
 837                 word3 = word1 & word2;  /* rnd1 = 0; */
 838                 word1 &= mask;
 839                 word3 &= (~mask); /* 0x1010101, check last bit */
 840                 word2 &= mask;
 841                 word1 >>= 1;
 842                 word1 = word1 + (word2 >> 1);
 843                 word1 += word3;
 844                 *((ULong*)(rec += 12)) = word1;
 845                 word1 = *((ULong*)(prev += 4));
 846                 word2 = *((ULong*)(prev + lx));
 847                 word3 = word1 & word2;  /* rnd1 = 0; */
 848                 word1 &= mask;
 849                 word3 &= (~mask); /* 0x1010101, check last bit */
 850                 word2 &= mask;
 851                 word1 >>= 1;
 852                 word1 = word1 + (word2 >> 1);
 853                 word1 += word3;
 854                 *((ULong*)(rec += 4)) = word1;
 855
 856                 prev += offset;
 857             }
 858             return 1;
 859         }
 860     }
 861     else if (tmp == 1)
 862     {
 863         prev--; /* word-aligned */
 864         if (rnd1 == 1)
 865         {
 866             for (i = B_SIZE; i > 0; i--)
 867             {
 868                 word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
 869                 word22 = *((ULong*)(prev + lx));
 870
 871                 word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
 872                 word2 = *((ULong*)(prev + lx));
 873                 word12 >>= 8; /* 0 b4 b3 b2 */
 874                 word22 >>= 8;
 875                 word12 = word12 | (word1 << 24); /* b5 b4 b3 b2 */
 876                 word22 = word22 | (word2 << 24);
 877                 word3 = word12 | word22;
 878                 word12 &= mask;
 879                 word22 &= mask;
 880                 word3 &= (~mask); /* 0x1010101, check last bit */
 881                 word12 >>= 1;
 882                 word12 = word12 + (word22 >> 1);
 883                 word12 += word3;
 884                 *((ULong*)(rec += 12)) = word12;
 885
 886                 word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
 887                 word22 = *((ULong*)(prev + lx));
 888                 word1 >>= 8; /* 0 b8 b7 b6 */
 889                 word2 >>= 8;
 890                 word1 = word1 | (word12 << 24); /* b9 b8 b7 b6 */
 891                 word2 = word2 | (word22 << 24);
 892                 word3 = word1 | word2;
 893                 word1 &= mask;
 894                 word2 &= mask;
 895                 word3 &= (~mask); /* 0x1010101, check last bit */
 896                 word1 >>= 1;
 897                 word1 = word1 + (word2 >> 1);
 898                 word1 += word3;
 899                 *((ULong*)(rec += 4)) = word1;
 900                 prev += offset;
 901             }
 902             return 1;
 903         }
 904         else /* rnd1 = 0 */
 905         {
 906             for (i = B_SIZE; i > 0; i--)
 907             {
 908                 word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
 909                 word22 = *((ULong*)(prev + lx));
 910
 911                 word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
 912                 word2 = *((ULong*)(prev + lx));
 913                 word12 >>= 8; /* 0 b4 b3 b2 */
 914                 word22 >>= 8;
 915                 word12 = word12 | (word1 << 24); /* b5 b4 b3 b2 */
 916                 word22 = word22 | (word2 << 24);
 917                 word3 = word12 & word22;
 918                 word12 &= mask;
 919                 word22 &= mask;
 920                 word3 &= (~mask); /* 0x1010101, check last bit */
 921                 word12 >>= 1;
 922                 word12 = word12 + (word22 >> 1);
 923                 word12 += word3;
 924                 *((ULong*)(rec += 12)) = word12;
 925
 926                 word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
 927                 word22 = *((ULong*)(prev + lx));
 928                 word1 >>= 8; /* 0 b8 b7 b6 */
 929                 word2 >>= 8;
 930                 word1 = word1 | (word12 << 24); /* b9 b8 b7 b6 */
 931                 word2 = word2 | (word22 << 24);
 932                 word3 = word1 & word2;
 933                 word1 &= mask;
 934                 word2 &= mask;
 935                 word3 &= (~mask); /* 0x1010101, check last bit */
 936                 word1 >>= 1;
 937                 word1 = word1 + (word2 >> 1);
 938                 word1 += word3;
 939                 *((ULong*)(rec += 4)) = word1;
 940                 prev += offset;
 941             }
 942             return 1;
 943         }
 944     }
 945     else if (tmp == 2)
 946     {
 947         prev -= 2; /* word-aligned */
 948         if (rnd1 == 1)
 949         {
 950             for (i = B_SIZE; i > 0; i--)
 951             {
 952                 word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
 953                 word22 = *((ULong*)(prev + lx));
 954
 955                 word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
 956                 word2 = *((ULong*)(prev + lx));
 957                 word12 >>= 16; /* 0 0 b4 b3 */
 958                 word22 >>= 16;
 959                 word12 = word12 | (word1 << 16); /* b6 b5 b4 b3 */
 960                 word22 = word22 | (word2 << 16);
 961                 word3 = word12 | word22;
 962                 word12 &= mask;
 963                 word22 &= mask;
 964                 word3 &= (~mask); /* 0x1010101, check last bit */
 965                 word12 >>= 1;
 966                 word12 = word12 + (word22 >> 1);
 967                 word12 += word3;
 968                 *((ULong*)(rec += 12)) = word12;
 969
 970                 word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
 971                 word22 = *((ULong*)(prev + lx));
 972                 word1 >>= 16; /* 0 0 b8 b7 */
 973                 word2 >>= 16;
 974                 word1 = word1 | (word12 << 16); /* b10 b9 b8 b7 */
 975                 word2 = word2 | (word22 << 16);
 976                 word3 = word1 | word2;
 977                 word1 &= mask;
 978                 word2 &= mask;
 979                 word3 &= (~mask); /* 0x1010101, check last bit */
 980                 word1 >>= 1;
 981                 word1 = word1 + (word2 >> 1);
 982                 word1 += word3;
 983                 *((ULong*)(rec += 4)) = word1;
 984                 prev += offset;
 985             }
 986             return 1;
 987         }
 988         else /* rnd1 = 0 */
 989         {
 990             for (i = B_SIZE; i > 0; i--)
 991             {
 992                 word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
 993                 word22 = *((ULong*)(prev + lx));
 994
 995                 word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
 996                 word2 = *((ULong*)(prev + lx));
 997                 word12 >>= 16; /* 0 0 b4 b3 */
 998                 word22 >>= 16;
 999                 word12 = word12 | (word1 << 16); /* b6 b5 b4 b3 */
1000                 word22 = word22 | (word2 << 16);
1001                 word3 = word12 & word22;
1002                 word12 &= mask;
1003                 word22 &= mask;
1004                 word3 &= (~mask); /* 0x1010101, check last bit */
1005                 word12 >>= 1;
1006                 word12 = word12 + (word22 >> 1);
1007                 word12 += word3;
1008                 *((ULong*)(rec += 12)) = word12;
1009
1010                 word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
1011                 word22 = *((ULong*)(prev + lx));
1012                 word1 >>= 16; /* 0 0 b8 b7 */
1013                 word2 >>= 16;
1014                 word1 = word1 | (word12 << 16); /* b10 b9 b8 b7 */
1015                 word2 = word2 | (word22 << 16);
1016                 word3 = word1 & word2;
1017                 word1 &= mask;
1018                 word2 &= mask;
1019                 word3 &= (~mask); /* 0x1010101, check last bit */
1020                 word1 >>= 1;
1021                 word1 = word1 + (word2 >> 1);
1022                 word1 += word3;
1023                 *((ULong*)(rec += 4)) = word1;
1024                 prev += offset;
1025             }
1026
1027             return 1;
1028         }
1029     }
1030     else /* tmp == 3 */
1031     {
1032         prev -= 3; /* word-aligned */
1033         if (rnd1 == 1)
1034         {
1035             for (i = B_SIZE; i > 0; i--)
1036             {
1037                 word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
1038                 word22 = *((ULong*)(prev + lx));
1039
1040                 word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
1041                 word2 = *((ULong*)(prev + lx));
1042                 word12 >>= 24; /* 0 0 0 b4 */
1043                 word22 >>= 24;
1044                 word12 = word12 | (word1 << 8); /* b7 b6 b5 b4 */
1045                 word22 = word22 | (word2 << 8);
1046                 word3 = word12 | word22;
1047                 word12 &= mask;
1048                 word22 &= mask;
1049                 word3 &= (~mask); /* 0x1010101, check last bit */
1050                 word12 >>= 1;
1051                 word12 = word12 + (word22 >> 1);
1052                 word12 += word3;
1053                 *((ULong*)(rec += 12)) = word12;
1054
1055                 word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
1056                 word22 = *((ULong*)(prev + lx));
1057                 word1 >>= 24; /* 0 0 0 b8 */
1058                 word2 >>= 24;
1059                 word1 = word1 | (word12 << 8); /* b11 b10 b9 b8 */
1060                 word2 = word2 | (word22 << 8);
1061                 word3 = word1 | word2;
1062                 word1 &= mask;
1063                 word2 &= mask;
1064                 word3 &= (~mask); /* 0x1010101, check last bit */
1065                 word1 >>= 1;
1066                 word1 = word1 + (word2 >> 1);
1067                 word1 += word3;
1068                 *((ULong*)(rec += 4)) = word1;
1069                 prev += offset;
1070             }
1071             return 1;
1072         }
1073         else /* rnd1 = 0 */
1074         {
1075             for (i = B_SIZE; i > 0; i--)
1076             {
1077                 word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
1078                 word22 = *((ULong*)(prev + lx));
1079
1080                 word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
1081                 word2 = *((ULong*)(prev + lx));
1082                 word12 >>= 24; /* 0 0 0 b4 */
1083                 word22 >>= 24;
1084                 word12 = word12 | (word1 << 8); /* b7 b6 b5 b4 */
1085                 word22 = word22 | (word2 << 8);
1086                 word3 = word12 & word22;
1087                 word12 &= mask;
1088                 word22 &= mask;
1089                 word3 &= (~mask); /* 0x1010101, check last bit */
1090                 word12 >>= 1;
1091                 word12 = word12 + (word22 >> 1);
1092                 word12 += word3;
1093                 *((ULong*)(rec += 12)) = word12;
1094
1095                 word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
1096                 word22 = *((ULong*)(prev + lx));
1097                 word1 >>= 24; /* 0 0 0 b8 */
1098                 word2 >>= 24;
1099                 word1 = word1 | (word12 << 8); /* b11 b10 b9 b8 */
1100                 word2 = word2 | (word22 << 8);
1101                 word3 = word1 & word2;
1102                 word1 &= mask;
1103                 word2 &= mask;
1104                 word3 &= (~mask); /* 0x1010101, check last bit */
1105                 word1 >>= 1;
1106                 word1 = word1 + (word2 >> 1);
1107                 word1 += word3;
1108                 *((ULong*)(rec += 4)) = word1;
1109                 prev += offset;
1110             }
1111             return 1;
1112         } /* rnd */
1113     } /* tmp */
1114 }
1115
1116 /**********************************************************************************/
1117 Int GetPredAdvBy1x1(
1118     UChar *prev,        /* i */
1119     UChar *rec,     /* i */
1120     Int lx,     /* i */
1121     Int rnd1 /* i */
1122 )
1123 {
1124     Int i;      /* loop variable */
1125     Int offset;
1126     ULong  x1, x2, x1m, x2m, y1, y2, y1m, y2m; /* new way */
1127     Int tmp;
1128     Int rnd2;
1129     ULong mask;
1130
1131     /* initialize offset to adjust pixel counter */
1132     /*    the next row; full-pel resolution      */
1133     offset = lx - B_SIZE; /* offset for prev */
1134
1135     rnd2 = rnd1 + 1;
1136     rnd2 |= (rnd2 << 8);
1137     rnd2 |= (rnd2 << 16);
1138
1139     mask = 0x3F;
1140     mask |= (mask << 8);
1141     mask |= (mask << 16); /* 0x3f3f3f3f */
1142
1143     tmp = (ULong)prev & 3;
1144
1145     rec -= 4; /* preset */
1146
1147     if (tmp == 0) /* word-aligned */
1148     {
1149         for (i = B_SIZE; i > 0; i--)
1150         {
1151             x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
1152             x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
1153             y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
1154             y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
1155
1156             x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
1157             x2m = (x2 >> 2) & mask;
1158             x1 = x1 ^(x1m << 2);
1159             x2 = x2 ^(x2m << 2);
1160             x1m += x2m;
1161             x1 += x2;
1162
1163             /* x2m, x2 free */
1164             y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
1165             y2m = (y2 >> 2) & mask;
1166             y1 = y1 ^(y1m << 2);
1167             y2 = y2 ^(y2m << 2);
1168             y1m += y2m;
1169             y1 += y2;
1170
1171             /* y2m, y2 free */
1172             /* x2m, x2 free */
1173             x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
1174             y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
1175             x2m = (x2 >> 2) & mask;
1176             y2m = (y2 >> 2) & mask;
1177             x2 = x2 ^(x2m << 2);
1178             y2 = y2 ^(y2m << 2);
1179             x2m += y2m;
1180             x2 += y2;
1181             /* y2m, y2 free */
1182
1183             /* now operate on x1m, x1, y1m, y1, x2m, x2 */
1184             /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
1185             /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
1186             /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
1187             /* x1, y1, x2 */
1188
1189             y2m = x1m >> 8;
1190             y2 = x1 >> 8;
1191             y2m |= (y1m << 24);  /* a4+b4, a3+b3, a2+b2, a1+b1 */
1192             y2 |= (y1 << 24);
1193             x1m += y2m;  /* a3+b3+a4+b4, ....., a0+b0+a1+b1 */
1194             x1 += y2;
1195             x1 += rnd2;
1196             x1 &= (mask << 2);
1197             x1m += (x1 >> 2);
1198             *((ULong*)(rec += 4)) = x1m; /* save x1m */
1199
1200             y2m = y1m >> 8;
1201             y2 = y1 >> 8;
1202             y2m |= (x2m << 24); /* a8+b8, a7+b7, a6+b6, a5+b5 */
1203             y2 |= (x2 << 24);
1204             y1m += y2m;  /* a7+b7+a8+b8, ....., a4+b4+a5+b5 */
1205             y1 += y2;
1206             y1 += rnd2;
1207             y1 &= (mask << 2);
1208             y1m += (y1 >> 2);
1209             *((ULong*)(rec += 4)) = y1m; /* save y1m */
1210
1211             rec += 8;
1212             prev += offset;
1213         }
1214
1215         return 1;
1216     }
1217     else if (tmp == 1)
1218     {
1219         prev--; /* to word-aligned */
1220         for (i = B_SIZE; i > 0; i--)
1221         {
1222             x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
1223             x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
1224             y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
1225             y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
1226
1227             x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
1228             x2m = (x2 >> 2) & mask;
1229             x1 = x1 ^(x1m << 2);
1230             x2 = x2 ^(x2m << 2);
1231             x1m += x2m;
1232             x1 += x2;
1233
1234             /* x2m, x2 free */
1235             y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
1236             y2m = (y2 >> 2) & mask;
1237             y1 = y1 ^(y1m << 2);
1238             y2 = y2 ^(y2m << 2);
1239             y1m += y2m;
1240             y1 += y2;
1241
1242             /* y2m, y2 free */
1243             /* x2m, x2 free */
1244             x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
1245             y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
1246             x2m = (x2 >> 2) & mask;
1247             y2m = (y2 >> 2) & mask;
1248             x2 = x2 ^(x2m << 2);
1249             y2 = y2 ^(y2m << 2);
1250             x2m += y2m;
1251             x2 += y2;
1252             /* y2m, y2 free */
1253
1254             /* now operate on x1m, x1, y1m, y1, x2m, x2 */
1255             /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
1256             /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
1257             /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
1258             /* x1, y1, x2 */
1259
1260             x1m >>= 8 ;
1261             x1 >>= 8;
1262             x1m |= (y1m << 24);  /* a4+b4, a3+b3, a2+b2, a1+b1 */
1263             x1 |= (y1 << 24);
1264             y2m = (y1m << 16);
1265             y2 = (y1 << 16);
1266             y2m |= (x1m >> 8); /* a5+b5, a4+b4, a3+b3, a2+b2 */
1267             y2 |= (x1 >> 8);
1268             x1 += rnd2;
1269             x1m += y2m;  /* a4+b4+a5+b5, ....., a1+b1+a2+b2 */
1270             x1 += y2;
1271             x1 &= (mask << 2);
1272             x1m += (x1 >> 2);
1273             *((ULong*)(rec += 4)) = x1m; /* save x1m */
1274
1275             y1m >>= 8;
1276             y1 >>= 8;
1277             y1m |= (x2m << 24); /* a8+b8, a7+b7, a6+b6, a5+b5 */
1278             y1 |= (x2 << 24);
1279             y2m = (x2m << 16);
1280             y2 = (x2 << 16);
1281             y2m |= (y1m >> 8); /*  a9+b9, a8+b8, a7+b7, a6+b6,*/
1282             y2 |= (y1 >> 8);
1283             y1 += rnd2;
1284             y1m += y2m;  /* a8+b8+a9+b9, ....., a5+b5+a6+b6 */
1285             y1 += y2;
1286             y1 &= (mask << 2);
1287             y1m += (y1 >> 2);
1288             *((ULong*)(rec += 4)) = y1m; /* save y1m */
1289
1290             rec += 8;
1291             prev += offset;
1292         }
1293         return 1;
1294     }
1295     else if (tmp == 2)
1296     {
1297         prev -= 2; /* to word-aligned */
1298         for (i = B_SIZE; i > 0; i--)
1299         {
1300             x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
1301             x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
1302             y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
1303             y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
1304
1305             x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
1306             x2m = (x2 >> 2) & mask;
1307             x1 = x1 ^(x1m << 2);
1308             x2 = x2 ^(x2m << 2);
1309             x1m += x2m;
1310             x1 += x2;
1311
1312             /* x2m, x2 free */
1313             y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
1314             y2m = (y2 >> 2) & mask;
1315             y1 = y1 ^(y1m << 2);
1316             y2 = y2 ^(y2m << 2);
1317             y1m += y2m;
1318             y1 += y2;
1319
1320             /* y2m, y2 free */
1321             /* x2m, x2 free */
1322             x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
1323             y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
1324             x2m = (x2 >> 2) & mask;
1325             y2m = (y2 >> 2) & mask;
1326             x2 = x2 ^(x2m << 2);
1327             y2 = y2 ^(y2m << 2);
1328             x2m += y2m;
1329             x2 += y2;
1330             /* y2m, y2 free */
1331
1332             /* now operate on x1m, x1, y1m, y1, x2m, x2 */
1333             /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
1334             /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
1335             /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
1336             /* x1, y1, x2 */
1337
1338             x1m >>= 16 ;
1339             x1 >>= 16;
1340             x1m |= (y1m << 16);  /* a5+b5, a4+b4, a3+b3, a2+b2 */
1341             x1 |= (y1 << 16);
1342             y2m = (y1m << 8);
1343             y2 = (y1 << 8);
1344             y2m |= (x1m >> 8); /* a6+b6, a5+b5, a4+b4, a3+b3 */
1345             y2 |= (x1 >> 8);
1346             x1 += rnd2;
1347             x1m += y2m;  /* a5+b5+a6+b6, ....., a2+b2+a3+b3 */
1348             x1 += y2;
1349             x1 &= (mask << 2);
1350             x1m += (x1 >> 2);
1351             *((ULong*)(rec += 4)) = x1m; /* save x1m */
1352
1353             y1m >>= 16;
1354             y1 >>= 16;
1355             y1m |= (x2m << 16); /* a9+b9, a8+b8, a7+b7, a6+b6 */
1356             y1 |= (x2 << 16);
1357             y2m = (x2m << 8);
1358             y2 = (x2 << 8);
1359             y2m |= (y1m >> 8); /*  a10+b10, a9+b9, a8+b8, a7+b7,*/
1360             y2 |= (y1 >> 8);
1361             y1 += rnd2;
1362             y1m += y2m;  /* a9+b9+a10+b10, ....., a6+b6+a7+b7 */
1363             y1 += y2;
1364             y1 &= (mask << 2);
1365             y1m += (y1 >> 2);
1366             *((ULong*)(rec += 4)) = y1m; /* save y1m */
1367
1368             rec += 8;
1369             prev += offset;
1370         }
1371         return 1;
1372     }
1373     else /* tmp == 3 */
1374     {
1375         prev -= 3; /* to word-aligned */
1376         for (i = B_SIZE; i > 0; i--)
1377         {
1378             x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
1379             x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
1380             y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
1381             y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
1382
1383             x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
1384             x2m = (x2 >> 2) & mask;
1385             x1 = x1 ^(x1m << 2);
1386             x2 = x2 ^(x2m << 2);
1387             x1m += x2m;
1388             x1 += x2;
1389
1390             /* x2m, x2 free */
1391             y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
1392             y2m = (y2 >> 2) & mask;
1393             y1 = y1 ^(y1m << 2);
1394             y2 = y2 ^(y2m << 2);
1395             y1m += y2m;
1396             y1 += y2;
1397
1398             /* y2m, y2 free */
1399             /* x2m, x2 free */
1400             x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
1401             y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
1402             x2m = (x2 >> 2) & mask;
1403             y2m = (y2 >> 2) & mask;
1404             x2 = x2 ^(x2m << 2);
1405             y2 = y2 ^(y2m << 2);
1406             x2m += y2m;
1407             x2 += y2;
1408             /* y2m, y2 free */
1409
1410             /* now operate on x1m, x1, y1m, y1, x2m, x2 */
1411             /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
1412             /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
1413             /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
1414             /* x1, y1, x2 */
1415
1416             x1m >>= 24 ;
1417             x1 >>= 24;
1418             x1m |= (y1m << 8);  /* a6+b6, a5+b5, a4+b4, a3+b3 */
1419             x1 |= (y1 << 8);
1420
1421             x1m += y1m;  /* a6+b6+a7+b7, ....., a3+b3+a4+b4 */
1422             x1 += y1;
1423             x1 += rnd2;
1424             x1 &= (mask << 2);
1425             x1m += (x1 >> 2);
1426             *((ULong*)(rec += 4)) = x1m; /* save x1m */
1427
1428             y1m >>= 24;
1429             y1 >>= 24;
1430             y1m |= (x2m << 8); /* a10+b10, a9+b9, a8+b8, a7+b7 */
1431             y1 |= (x2 << 8);
1432             y1m += x2m;  /* a10+b10+a11+b11, ....., a7+b7+a8+b8 */
1433             y1 += x2;
1434             y1 += rnd2;
1435             y1 &= (mask << 2);
1436             y1m += (y1 >> 2);
1437             *((ULong*)(rec += 4)) = y1m; /* save y1m */
1438
1439             rec += 8;
1440             prev += offset;
1441         }
1442         return 1;
1443     }
1444 }
1445
1446
1447 /*=============================================================================
1448     Function:   EncGetPredOutside
1449     Date:       04/17/2001
1450     Purpose:    - modified from GetPredOutside in the decoder.
1451     Modified:    09/24/05
1452                 use the existing non-initialized padded region
1453 =============================================================================*/
1454 // not really needed since padding is included
1455 #define PAD_CORNER  { temp = *src; \
1456                      temp |= (temp<<8); \
1457                      temp |= (temp<<16); \
1458                      *((ULong*)dst) = temp; \
1459                      *((ULong*)(dst+4)) = temp; \
1460                      *((ULong*)(dst+=lx)) = temp; \
1461                      *((ULong*)(dst+4)) = temp; \
1462                      *((ULong*)(dst+=lx)) = temp; \
1463                      *((ULong*)(dst+4)) = temp; \
1464                      *((ULong*)(dst+=lx)) = temp; \
1465                      *((ULong*)(dst+4)) = temp; \
1466                      *((ULong*)(dst+=lx)) = temp; \
1467                      *((ULong*)(dst+4)) = temp; \
1468                      *((ULong*)(dst+=lx)) = temp; \
1469                      *((ULong*)(dst+4)) = temp; \
1470                      *((ULong*)(dst+=lx)) = temp; \
1471                      *((ULong*)(dst+4)) = temp; \
1472                      *((ULong*)(dst+=lx)) = temp; \
1473                      *((ULong*)(dst+4)) = temp; }
1474
1475 #define PAD_ROW     { temp = *((ULong*)src); \
1476                       temp2 = *((ULong*)(src+4)); \
1477                       *((ULong*)dst) = temp; \
1478                       *((ULong*)(dst+4)) = temp2; \
1479                       *((ULong*)(dst+=lx)) = temp; \
1480                       *((ULong*)(dst+4)) = temp2; \
1481                       *((ULong*)(dst+=lx)) = temp; \
1482                       *((ULong*)(dst+4)) = temp2; \
1483                       *((ULong*)(dst+=lx)) = temp; \
1484                       *((ULong*)(dst+4)) = temp2; \
1485                       *((ULong*)(dst+=lx)) = temp; \
1486                       *((ULong*)(dst+4)) = temp2; \
1487                       *((ULong*)(dst+=lx)) = temp; \
1488                       *((ULong*)(dst+4)) = temp2; \
1489                       *((ULong*)(dst+=lx)) = temp; \
1490                       *((ULong*)(dst+4)) = temp2; \
1491                       *((ULong*)(dst+=lx)) = temp; \
1492                       *((ULong*)(dst+4)) = temp2; }
1493
1494 #define PAD_COL     { temp = *src;   temp |= (temp<<8);  temp |= (temp<<16); \
1495                       *((ULong*)dst) = temp; \
1496                      *((ULong*)(dst+4)) = temp; \
1497                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1498                       *((ULong*)(dst+=lx)) = temp; \
1499                      *((ULong*)(dst+4)) = temp; \
1500                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1501                       *((ULong*)(dst+=lx)) = temp; \
1502                      *((ULong*)(dst+4)) = temp; \
1503                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1504                       *((ULong*)(dst+=lx)) = temp; \
1505                      *((ULong*)(dst+4)) = temp; \
1506                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1507                       *((ULong*)(dst+=lx)) = temp; \
1508                      *((ULong*)(dst+4)) = temp; \
1509                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1510                       *((ULong*)(dst+=lx)) = temp; \
1511                      *((ULong*)(dst+4)) = temp; \
1512                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1513                       *((ULong*)(dst+=lx)) = temp; \
1514                      *((ULong*)(dst+4)) = temp; \
1515                       temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
1516                       *((ULong*)(dst+=lx)) = temp; \
1517                       *((ULong*)(dst+4)) = temp; }
1518
1519
1520 Int EncGetPredOutside(Int xpos, Int ypos, UChar *c_prev, UChar *rec,
1521                       Int width, Int height, Int rnd1)
1522 {
1523     Int lx;
1524     UChar *src, *dst;
1525     ULong temp, temp2;
1526     Int xoffset;
1527
1528     lx = width + 16; /* only works for chroma */
1529
1530     if (xpos < 0)
1531     {
1532         if (ypos < 0) /* pad top-left */
1533         {
1534             /* pad corner */
1535             src = c_prev;
1536             dst = c_prev - (lx << 3) - 8;
1537             PAD_CORNER
1538
1539             /* pad top */
1540             dst = c_prev - (lx << 3);
1541             PAD_ROW
1542
1543             /* pad left */
1544             dst = c_prev - 8;
1545             PAD_COL
1546
1547             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1548                                              rec, lx, rnd1);
1549
1550             return 1;
1551         }
1552         else if ((ypos >> 1) < (height - 8)) /* pad left of frame */
1553         {
1554             /* pad left */
1555             src = c_prev + (ypos >> 1) * lx;
1556             dst = src - 8;
1557             PAD_COL
1558             /* pad extra row */
1559             temp = *(src += lx);
1560             temp |= (temp << 8);
1561             temp |= (temp << 16);
1562             *((ULong*)(dst += lx)) = temp;
1563             *((ULong*)(dst + 4)) = temp;
1564
1565             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1566                                              rec, lx, rnd1);
1567
1568             return 1;
1569         }
1570         else /* pad bottom-left */
1571         {
1572             /* pad corner */
1573             src = c_prev + (height - 1) * lx;
1574             dst = src + lx - 8;
1575             PAD_CORNER
1576
1577             /* pad bottom */
1578             dst = src + lx;
1579             PAD_ROW
1580
1581             /* pad left */
1582             src -= (lx << 3);
1583             src += lx;
1584             dst = src - 8;
1585             PAD_COL
1586
1587             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1588                                              rec, lx, rnd1);
1589
1590             return 1;
1591         }
1592     }
1593     else if ((xpos >> 1) < (width - 8))
1594     {
1595         if (ypos < 0) /* pad top of frame */
1596         {
1597             xoffset = (xpos >> 1) & 0x3;
1598             src = c_prev + (xpos >> 1) - xoffset;
1599             dst = src - (lx << 3);
1600             PAD_ROW
1601             if (xoffset || (xpos&1))
1602             {
1603                 temp = *((ULong*)(src + 8));
1604                 dst = src - (lx << 3) + 8;
1605                 *((ULong*)dst) = temp;
1606                 *((ULong*)(dst += lx)) = temp;
1607                 *((ULong*)(dst += lx)) = temp;
1608                 *((ULong*)(dst += lx)) = temp;
1609                 *((ULong*)(dst += lx)) = temp;
1610                 *((ULong*)(dst += lx)) = temp;
1611                 *((ULong*)(dst += lx)) = temp;
1612                 *((ULong*)(dst += lx)) = temp;
1613             }
1614
1615             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1616                                              rec, lx, rnd1);
1617
1618             return 1;
1619         }
1620         else /* pad bottom of frame */
1621         {
1622             xoffset = (xpos >> 1) & 0x3;
1623             src = c_prev + (xpos >> 1) - xoffset + (height - 1) * lx;
1624             dst = src + lx;
1625             PAD_ROW
1626             if (xoffset || (xpos&1))
1627             {
1628                 temp = *((ULong*)(src + 8));
1629                 dst = src + lx + 8;
1630                 *((ULong*)dst) = temp;
1631                 *((ULong*)(dst += lx)) = temp;
1632                 *((ULong*)(dst += lx)) = temp;
1633                 *((ULong*)(dst += lx)) = temp;
1634                 *((ULong*)(dst += lx)) = temp;
1635                 *((ULong*)(dst += lx)) = temp;
1636                 *((ULong*)(dst += lx)) = temp;
1637                 *((ULong*)(dst += lx)) = temp;
1638             }
1639
1640             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1641                                              rec, lx, rnd1);
1642
1643             return 1;
1644         }
1645     }
1646     else
1647     {
1648         if (ypos < 0) /* pad top-right */
1649         {
1650             /* pad corner */
1651             src = c_prev + width - 1;
1652             dst = src - (lx << 3) + 1;
1653             PAD_CORNER
1654
1655             /* pad top */
1656             src -= 7;
1657             dst = src - (lx << 3);
1658             PAD_ROW
1659
1660             /* pad left */
1661             src += 7;
1662             dst = src + 1;
1663             PAD_COL
1664
1665             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1666                                              rec, lx, rnd1);
1667
1668             return 1;
1669         }
1670         else if ((ypos >> 1) < (height - B_SIZE)) /* pad right of frame */
1671         {
1672             /* pad left */
1673             src = c_prev + (ypos >> 1) * lx + width - 1;
1674             dst = src + 1;
1675             PAD_COL
1676             /* pad extra row */
1677             temp = *(src += lx);
1678             temp |= (temp << 8);
1679             temp |= (temp << 16);
1680             *((ULong*)(dst += lx)) = temp;
1681             *((ULong*)(dst + 4)) = temp;
1682
1683             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1684                                              rec, lx, rnd1);
1685
1686             return 1;
1687         }
1688         else /* pad bottom-right */
1689         {
1690             /* pad left */
1691             src = c_prev + (height - 8) * lx + width - 1;
1692             dst = src + 1;
1693             PAD_COL
1694
1695             /* pad corner */
1696             dst = src + lx + 1;
1697             PAD_CORNER
1698
1699             /* pad bottom */
1700             src -= 7;
1701             dst = src + lx;
1702             PAD_ROW
1703
1704             GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
1705                                              rec, lx, rnd1);
1706
1707             return 1;
1708         }
1709     }
1710 }
1711
1712 /* ====================================================================== /
1713     Function : Copy_MB_from_Vop()
1714     Date     : 04/17/2001
1715  ====================================================================== */
1716
1717 void Copy_MB_from_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int pitch)
1718 {
1719     Int row, col, i;
1720     Int *src1, *src2;
1721     Int offset = pitch - MB_SIZE;
1722     ULong temp;
1723
1724     for (i = 0; i < 4; i += 2)
1725     {
1726         src1 = yChan[i];
1727         src2 = yChan[i+1];
1728
1729         row = B_SIZE;
1730         while (row--)
1731         {
1732             col = B_SIZE;
1733             while (col)
1734             {
1735                 temp = *((ULong*)comp);
1736                 *src1++ = (Int)(temp & 0xFF);
1737                 *src1++ = (Int)((temp >> 8) & 0xFF);
1738                 *src1++ = (Int)((temp >> 16) & 0xFF);
1739                 *src1++ = (Int)((temp >> 24) & 0xFF);
1740                 comp += 4;
1741                 col -= 4;
1742             }
1743             col = B_SIZE;
1744             while (col)
1745             {
1746                 temp = *((ULong*)comp);
1747                 *src2++ = (Int)(temp & 0xFF);
1748                 *src2++ = (Int)((temp >> 8) & 0xFF);
1749                 *src2++ = (Int)((temp >> 16) & 0xFF);
1750                 *src2++ = (Int)((temp >> 24) & 0xFF);
1751                 comp += 4;
1752                 col -= 4;
1753             }
1754             comp += offset;
1755         }
1756     }
1757     return ;
1758 }
1759
1760 /* ====================================================================== /
1761     Function : Copy_B_from_Vop()
1762     Date     : 04/17/2001
1763 / ====================================================================== */
1764
1765 void Copy_B_from_Vop(UChar *comp, Int cChan[], Int pitch)
1766 {
1767     Int row, col;
1768     Int offset = pitch - B_SIZE;
1769     ULong temp;
1770
1771     row = B_SIZE;
1772     while (row--)
1773     {
1774         col = B_SIZE;
1775         while (col)
1776         {
1777             temp = *((ULong*)comp);
1778             *cChan++ = (Int)(temp & 0xFF);
1779             *cChan++ = (Int)((temp >> 8) & 0xFF);
1780             *cChan++ = (Int)((temp >> 16) & 0xFF);
1781             *cChan++ = (Int)((temp >> 24) & 0xFF);
1782             comp += 4;
1783             col -= 4;
1784         }
1785         comp += offset;
1786     }
1787 }
1788
1789 /* ====================================================================== /
1790     Function : Copy_MB_into_Vop()
1791     Date     : 04/17/2001
1792     History  : From decoder
1793 / ====================================================================== */
1794
1795 void Copy_MB_into_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int pitch)
1796 {
1797     Int row, col, i;
1798     Int *src1, *src2;
1799     Int offset = pitch - MB_SIZE;
1800     UChar mask = 0xFF;
1801     Int tmp;
1802     ULong temp;
1803
1804     for (i = 0; i < 4; i += 2)
1805     {
1806         src1 = yChan[i];
1807         src2 = yChan[i+1];
1808
1809         row = B_SIZE;
1810         while (row--)
1811         {
1812             col = B_SIZE;
1813             while (col)
1814             {
1815                 tmp = (*src1++);
1816                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1817                 temp = tmp << 24;
1818                 tmp = (*src1++);
1819                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1820                 temp |= (tmp << 16);
1821                 tmp = (*src1++);
1822                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1823                 temp |= (tmp << 8);
1824                 tmp = (*src1++);
1825                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1826                 temp |= tmp;
1827                 *((ULong*)comp) = temp;
1828                 comp += 4;
1829                 col -= 4;
1830             }
1831             col = B_SIZE;
1832             while (col)
1833             {
1834                 tmp = (*src2++);
1835                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1836                 temp = tmp << 24;
1837                 tmp = (*src2++);
1838                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1839                 temp |= (tmp << 16);
1840                 tmp = (*src2++);
1841                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1842                 temp |= (tmp << 8);
1843                 tmp = (*src2++);
1844                 if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1845                 temp |= tmp;
1846                 *((ULong*)comp) = temp;
1847                 comp += 4;
1848                 col -= 4;
1849             }
1850             comp += offset;
1851         }
1852     }
1853     return ;
1854 }
1855
1856
1857 /* ====================================================================== /
1858     Function : Copy_B_into_Vop()
1859     Date     : 04/17/2001
1860     History  : From decoder
1861 / ====================================================================== */
1862
1863 void Copy_B_into_Vop(UChar *comp, Int cChan[], Int pitch)
1864 {
1865     Int row, col;
1866     Int offset = pitch - B_SIZE;
1867     Int tmp;
1868     UChar mask = 0xFF;
1869     ULong temp;
1870
1871     row = B_SIZE;
1872     while (row--)
1873     {
1874         col = B_SIZE;
1875         while (col)
1876         {
1877             tmp = (*cChan++);
1878             if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1879             temp = tmp << 24;
1880             tmp = (*cChan++);
1881             if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1882             temp |= (tmp << 16);
1883             tmp = (*cChan++);
1884             if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1885             temp |= (tmp << 8);
1886             tmp = (*cChan++);
1887             if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
1888             temp |= tmp;
1889             *((ULong*)comp) = temp;
1890             comp += 4;
1891             col -= 4;
1892         }
1893         comp += offset;
1894     }
1895 }
1896
1897 /* ======================================================================== */
1898 /*  Function : get_MB( )                                                    */
1899 /*  Date     : 10/03/2000                                                   */
1900 /*  Purpose  : Copy 4 Y to reference frame                                  */
1901 /*  In/out   :                                                              */
1902 /*  Return   :                                                              */
1903 /*  Modified :                                                              */
1904 /* ======================================================================== */
1905 void get_MB(UChar *c_prev, UChar *c_prev_u  , UChar *c_prev_v,
1906             Short mb[6][64], Int lx, Int lx_uv)
1907
1908 {
1909     Int i, j, count = 0, count1 = 0;
1910     Int k1 = lx - MB_SIZE, k2 = lx_uv - B_SIZE;
1911
1912     for (i = 0; i < B_SIZE; i++)
1913     {
1914         for (j = 0; j < B_SIZE; j++)
1915         {
1916             mb[0][count] = (Int)(*c_prev++);
1917             mb[4][count] = (Int)(*c_prev_u++);
1918             mb[5][count++] = (Int)(*c_prev_v++);
1919         }
1920
1921         for (j = 0; j < B_SIZE; j++)
1922             mb[1][count1++] = (Int)(*c_prev++);
1923
1924         c_prev += k1;
1925         c_prev_u += k2;
1926         c_prev_v += k2;
1927
1928
1929     }
1930
1931     count = count1 = 0;
1932     for (i = 0; i < B_SIZE; i++)
1933     {
1934         for (j = 0; j < B_SIZE; j++)
1935             mb[2][count++] = (Int)(*c_prev++);
1936
1937         for (j = 0; j < B_SIZE; j++)
1938             mb[3][count1++] = (Int)(*c_prev++);
1939
1940         c_prev += k1;
1941     }
1942 }
1943
1944 void PutSkippedBlock(UChar *rec, UChar *prev, Int lx)
1945 {
1946     UChar *end;
1947     Int offset = (lx - 8) >> 2;
1948     Int *src, *dst;
1949
1950     dst = (Int*)rec;
1951     src = (Int*)prev;
1952
1953     end = prev + (lx << 3);
1954
1955     do
1956     {
1957         *dst++ = *src++;
1958         *dst++ = *src++;
1959         dst += offset;
1960         src += offset;
1961     }
1962     while ((UInt)src < (UInt)end);
1963
1964     return ;
1965 }