1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description:  

    16 * Implementation for MPEG4(H263) video transcoder. 

    17 * Block matching algorithms for MPEG4(H263) video transcoder.

    18 *

    19 */

    20 

    21 

    22 

    23 #include "biblin.h"

    24 #include "common.h"

    25 #include "h263dconfig.h"

    26 #include "decmbdct.h"

    27 #include "vdxint.h"

    28 

    29 /* 

    30  * Constants/definitions 

    31  */

    32 

    33 #define DIAMOND_SEARCH_NUMBER 2

    34 

    35 

    36 const tVLCTable sCBPCIType[9] = 

    37 {

    38     {0x01,0x01}, {0x01,0x03}, {0x02,0x03}, {0x03,0x03}, 

    39         {0x01,0x04}, {0x01,0x06}, {0x02,0x06}, {0x03,0x06}, 

    40         {0x01,0x09}

    41 };

    42 

    43 const tVLCTable sCBPCPType[21] = 

    44 {

    45     {0x01,0x01}, {0x03,0x04}, {0x02,0x04}, {0x05,0x06},

    46     {0x03,0x03}, {0x07,0x07}, {0x06,0x07}, {0x05,0x09}, 

    47     {0x02,0x03}, {0x05,0x07}, {0x04,0x07}, {0x05,0x08},

    48     {0x03,0x05}, {0x04,0x08}, {0x03,0x08}, {0x03,0x07},

    49     {0x04,0x06}, {0x04,0x09}, {0x03,0x09}, {0x02,0x09}, 

    50     {0x01,0x09}

    51 };

    52 

    53 const tVLCTable sCBPY[16] = 

    54 {

    55     {0x03,0x04}, {0x05,0x05}, {0x04,0x05}, {0x09,0x04},

    56     {0x03,0x05}, {0x07,0x04}, {0x02,0x06}, {0x0b,0x04},

    57     {0x02,0x05}, {0x03,0x06}, {0x05,0x04}, {0x0a,0x04},

    58     {0x04,0x04}, {0x08,0x04}, {0x06,0x04}, {0x03,0x02}

    59 };

    60 

    61 const unsigned int sDquant[5] = 

    62 {

    63     0x01, 0x00, (unsigned int)NOT_VALID, 0x02, 0x03

    64 };

    65 

    66 const tVLCTable sMVTab[33] =

    67 {

    68         {0x01,0x01}, {0x02,0x03}, {0x02,0x04}, {0x02,0x05}, 

    69         {0x06,0x07}, {0x0a,0x08}, {0x08,0x08}, {0x06,0x08},

    70         {0x16,0x0a}, {0x14,0x0a}, {0x12,0x0a}, {0x22,0x0b},

    71         {0x20,0x0b}, {0x1e,0x0b}, {0x1c,0x0b}, {0x1a,0x0b},

    72         {0x18,0x0b}, {0x16,0x0b}, {0x14,0x0b}, {0x12,0x0b},

    73         {0x10,0x0b}, {0x0e,0x0b}, {0x0c,0x0b}, {0x0a,0x0b},

    74         {0x08,0x0b}, {0x0e,0x0c}, {0x0c,0x0c}, {0x0a,0x0c}, 

    75         {0x08,0x0c}, {0x06,0x0c}, {0x04,0x0c}, {0x06,0x0d},

    76         {0x04,0x0d}

    77 }; 

    78 

    79 const int32  sFixedQuantScale1[32]=

    80 {

    81       0x0000, 0x7fff, 0x3fff, 0x2aaa, 

    82         0x1fff, 0x1999, 0x1555, 0x1249, 

    83         0x0fff, 0x0e38, 0x0ccc, 0x0ba2,  

    84         0x0aaa, 0x09d8, 0x0924, 0x0888,  

    85         0x07ff, 0x0787, 0x071c, 0x06bc,  

    86         0x0666, 0x0618, 0x05d1, 0x1590,  

    87         0x0555, 0x051e, 0x04ec, 0x04bd,  

    88         0x0492, 0x0469, 0x0444, 0x0421  

    89 };  

    90 

    91 const u_int16 sPrePostMult[64] = 

    92 { 

    93       0x8000, 0xb18a, 0xa73d, 0x9683,  

    94         0x8000, 0x9683, 0xa73d, 0xb18a, 

    95       0xb18a, 0xf641, 0xe7f7, 0xd0c3,  

    96         0xb18a, 0xd0c3, 0xe7f7, 0xf641, 

    97       0xa73d, 0xe7f7, 0xda82, 0xc4a7,  

    98         0xa73d, 0xc4a7, 0xda82, 0xe7f7, 

    99       0x9683, 0xd0c3, 0xc4a7, 0xb0fb,  

   100         0x9683, 0xb0fb, 0xc4a7, 0xd0c3, 

   101       0x8000, 0xb18a, 0xa73d, 0x9683,  

   102         0x8000, 0x9683, 0xa73d, 0xb18a, 

   103       0x9683, 0xd0c3, 0xc4a7, 0xb0fb,  

   104         0x9683, 0xb0fb, 0xc4a7, 0xd0c3, 

   105       0xa73d, 0xe7f7, 0xda82, 0xc4a7,  

   106         0xa73d, 0xc4a7, 0xda82, 0xe7f7, 

   107       0xb18a, 0xf641, 0xe7f7, 0xd0c3,  

   108         0xb18a, 0xd0c3, 0xe7f7, 0xf641

   109 };

   110 

   111 

   112 

   113 /* 

   114  * Function Declarations 

   115  */

   116 int32 vlbCodeACCoeffsSVHWithZigZag(int32 coeffStart, int16* block, bibBuffer_t * outBuf,

   117                                  int32 svh, int32 lastPos);

   118 void vlbPutBits(bibBuffer_t *base, int32 numBits, u_int32 value);

   119 

   120 

   121 

   122 /* 

   123  * Function Definitions 

   124  */

   125 

   126 /* {{-output"vbmGetH263IMCBPC.txt"}} */

   127 /*

   128 * vbmGetH263IMCBPC

   129 *

   130 * Parameters:

   131 *     vopCodingType            coding type (INTER/INTRA) for the VOP

   132 *           dQuant                   quantization parameter

   133 *           colorEffect              indicates color effect to be aplpied (e.g., black & white)

   134 *           cbpy                       cbpy value for the macro block

   135 *           mcbpcVal                   computed mcbpc value for the macro block

   136 *           length                   length of the computed mcbpc value codeword

   137 *

   138 * Function:

   139 *     This function evaluates the mcpbc codeword for INTRA macro block

   140 *

   141 * Returns:

   142 *     Nothing.

   143 *

   144 * Error codes:

   145 *     None.

   146 *

   147 */

   148 void vbmGetH263IMCBPC(int dQuant, int vopCodingType, int /*colorEffect*/, 

   149                                      int cbpy, int& mcbpcVal, int& length)

   150 {

   151     int index;

   152     int len, mcbpc;

   153 

   154     if(vopCodingType == 1 /* VDX_VOP_TYPE_P */)

   155     {

   156         index = (dQuant == 0 ? 12 : 16) + mcbpcVal;

   157         len = sCBPCPType[index].length + sCBPY[cbpy].length + 1;

   158         mcbpc = (sCBPCPType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;

   159         mcbpcVal = mcbpc;

   160         length = len;

   161     }

   162     else

   163     {

   164         index = (dQuant == 0 ? 0 : 4) + mcbpcVal;

   165         len = sCBPCIType[index].length + sCBPY[cbpy].length ;

   166         mcbpc = (sCBPCIType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;

   167         mcbpcVal = mcbpc;

   168         length = len;

   169     }

   170 }

   171 

   172 

   173 

   174 /* {{-output"vbmGetH263PMCBPC.txt"}} */

   175 /*

   176 * vbmGetH263PMCBPC

   177 *

   178 * Parameters:

   179 *           dQuant                   quantization parameter

   180 *           colorEffect              indicates color effect to be aplpied (e.g., black & white)

   181 *           cbpy                       cbpy value for the macro block

   182 *           mcbpcVal                   computed mcbpc value for the macro block

   183 *           length                   length of the computed mcbpc value codeword

   184 *

   185 * Function:

   186 *     This function evaluates the mcpbc codeword for INTER macro block

   187 *

   188 * Returns:

   189 *     Nothing.

   190 *

   191 * Error codes:

   192 *     None.

   193 *

   194 */

   195 void vbmGetH263PMCBPC(int dQuant, int /*colorEffect*/, int cbpy, int& mcbpcVal, int& length)

   196 {

   197     int index;

   198     int len, mcbpc;

   199     cbpy = (~cbpy) & 0xf;

   200     

   201     /* only ONE MV in baseline H263 */

   202     index = (dQuant == 0 ? 0 : 4) + mcbpcVal;

   203     len = sCBPCPType[index].length + sCBPY[cbpy].length;

   204     mcbpc = (sCBPCPType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;

   205     mcbpcVal = mcbpc;

   206     length = len;

   207 }

   208 

   209 

   210 

   211 /* {{-output"vbmEncodeMVDifferential.txt"}} */

   212 /*

   213 * vbmEncodeMVDifferential

   214 *

   215 * Parameters:

   216 *     outBuf                     output buffer

   217 *           mvdx                     motion vector difference value in horizontal direction, in half-pixel unit

   218 *           mvdy                     motion vector difference value in vertical direction, in half-pixel unit

   219 *           fCode                      Fcode value

   220 *

   221 * Function:

   222 *     This function encodes the MV difference after prediction into the bitstream

   223 *

   224 * Returns:

   225 *     Nothing.

   226 *

   227 * Error codes:

   228 *     None.

   229 *

   230 */

   231 void vbmEncodeMVDifferential(int32 mvdx, int32 mvdy, int32 fCode, 

   232                            bibBuffer_t * outBuf)

   233 {

   234     int32   mvd[2];

   235     u_int32 i;

   236     int32   temp;

   237     int32   motioncode;

   238     int32   motionresidual;

   239     int32   rsize = fCode - 1;

   240     u_int32 f     = 1 << rsize;

   241     int32   high  = 32 * f - 1;

   242     int32   low   = -32 * (int32) f;

   243     int32   range = 64 *f;

   244     

   245     mvd[0] = mvdx;

   246     mvd[1] = mvdy;

   247     

   248     for(i = 0; i < 2; i++)    

   249     {

   250         if (mvd[i] < low)

   251         {

   252             mvd[i] += range;

   253         }

   254         else

   255         {

   256             if (mvd[i] > high)

   257             {

   258                 mvd[i] -= range;

   259             }

   260         }

   261         temp = ABS(mvd[i]) -1 + f;

   262         motioncode = temp >> rsize;    

   263         if(mvd[i] >= 0)

   264         {

   265             vlbPutBits(outBuf, sMVTab[motioncode].length, sMVTab[motioncode].code);

   266         }

   267         else

   268         {

   269             vlbPutBits(outBuf, sMVTab[motioncode].length, (sMVTab[motioncode].code) ^ 1);

   270         }        

   271         if (rsize != 0 && motioncode != 0)

   272         {

   273             motionresidual = temp & (f - 1);

   274             vlbPutBits(outBuf, rsize, motionresidual);

   275         }   

   276     }

   277     return;

   278 }

   279 

   280 

   281 

   282 

   283 /* {{-output"vbmMedian3.txt"}} */

   284 /*

   285 * vbmMedian3

   286 *

   287 * Parameters:

   288 *     s1                         pointer to the first vector

   289 *     s2                         pointer to the second vector

   290 *     s3                         pointer to the third vector

   291 *     med                        pointer to store the median vector

   292 *

   293 * Function:

   294 *     This function finds the median of three vectors

   295 *

   296 * Returns:

   297 *     Nothing.

   298 *

   299 * Error codes:

   300 *     None.

   301 *

   302 */

   303 void vbmMedian3(int16 *s1, int16 *s2, int16 *s3, tMotionVector *med)

   304 {

   305     int32 temp1;

   306     int32 temp2;

   307     int32 temp3;

   308     

   309     temp1 = s1[0];

   310     temp2 = s2[0];

   311     temp3 = s3[0];

   312     

   313     if (temp1 > temp2)

   314     {

   315         temp1 += temp2;

   316         temp2 = temp1 - temp2;

   317         temp1 -= temp2;

   318     }

   319     if (temp2 > temp3)

   320     {

   321         temp2 += temp3;

   322         temp3 = temp2 - temp3;

   323         temp2 -= temp3;

   324     }

   325     if (temp1 > temp2)

   326     {

   327         temp1 += temp2;

   328         temp2 = temp1 - temp2;

   329         temp1 -= temp2;

   330     }

   331     

   332     med->mvx = (int16) temp2;

   333     temp1 = s1[1];

   334     temp2 = s2[1];

   335     temp3 = s3[1];

   336     

   337     if (temp1 > temp2)

   338     {

   339         temp1 += temp2;

   340         temp2 = temp1 - temp2;

   341         temp1 -= temp2;

   342     }

   343     if (temp2 > temp3)

   344     {

   345         temp2 += temp3;

   346         temp3 = temp2 - temp3;

   347         temp2 -= temp3;

   348     }

   349     if (temp1 > temp2)

   350     {

   351         temp1 += temp2;

   352         temp2 = temp1 - temp2;

   353         temp1 -= temp2;

   354     }

   355     med->mvy = (int16) temp2;

   356     

   357     return;

   358 }

   359 

   360 

   361 

   362 /* {{-output"vbmMvPrediction.txt"}} */

   363 /*

   364 * vbmMvPrediction

   365 *

   366 * Parameters:

   367 *     mbi                  macro block info needed for processing

   368 *     predMV               pointer to motion vector predictors

   369 *     mbinWidth            number of MBs per row

   370 *     mBCnt                    mecro block number

   371 *

   372 * Function:

   373 *     This function performs prediction of MV based on adjacent blocks

   374 *

   375 * Returns:

   376 *     Nothing.

   377 *

   378 * Error codes:

   379 *     None.

   380 *

   381 */

   382 void vbmMvPrediction(tMBInfo *mbi, int32 mBCnt, tMotionVector *predMV, int32 mbinWidth)

   383 {

   384     int16    p[3][2];

   385     int32    zeroFound = 0;

   386     int32    zeroPredictors = 0;

   387     

   388     if (mBCnt % mbinWidth == 0)

   389     {

   390         p[0][0] = 0;

   391         p[0][1] = 0;

   392         zeroPredictors++;

   393     }

   394     else

   395     {

   396         p[0][0] = (mbi - 1)->MV[0][0];

   397         p[0][1] = (mbi - 1)->MV[0][1];

   398     }

   399     

   400     if (mBCnt / mbinWidth == 0) 

   401     {

   402         p[1][0] = 0;

   403         p[1][1] = 0;

   404         zeroPredictors++;

   405         zeroFound += 1;

   406     }

   407     else

   408     {

   409         p[1][0] = (mbi - mbinWidth)->MV[0][0];

   410         p[1][1] = (mbi - mbinWidth)->MV[0][1];

   411     }

   412     

   413     if ((mBCnt / mbinWidth == 0) ||

   414         ((mBCnt % mbinWidth) == (mbinWidth - 1)))

   415     {

   416         p[2][0] = 0;

   417         p[2][1] = 0;

   418         zeroPredictors++;

   419         zeroFound += 2;

   420     }

   421     else

   422     {

   423         p[2][0] = (mbi - mbinWidth + 1)->MV[0][0];

   424         p[2][1] = (mbi - mbinWidth + 1)->MV[0][1];

   425     }

   426     

   427     if (zeroPredictors == 3)

   428     {

   429         predMV->mvx = 0;

   430         predMV->mvy = 0;

   431     }

   432     else if (zeroPredictors == 2)

   433     {

   434         predMV->mvx = p[zeroFound^3][0];

   435         predMV->mvy = p[zeroFound^3][1];

   436     }

   437     else

   438     {

   439         vbmMedian3(p[0], p[1], p[2], predMV);

   440     }

   441     return;

   442 }

   443 

   444 

   445 

   446 /* {{-output"vbmMBSAD.txt"}} */

   447 /*

   448 * vbmMBSAD

   449 *

   450 * Parameters:

   451 *     refFrame             pointer to reference frame

   452 *     currMB               pointer to current MB

   453 *     mv                   pointer to store the SAD and having motion vector

   454 *     mbPos                pointer to macroblock position structure

   455 *     vopWidth             width of frame/VOP

   456 *     yWidth               width of luminance frame 

   457 *

   458 * Function:

   459 *     This function computes the SAD (Sum of Absolute Difference) 

   460 *     for a macroblock for integer motion vector

   461 *

   462 * Returns:

   463 *     Nothing.

   464 *

   465 * Error codes:

   466 *     None.

   467 *

   468 */

   469 void vbmMBSAD(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, u_int32 yWidth,

   470                             tMotionVector* mv, const tMBPosition* mbPos)

   471 {

   472     u_int32     sad = 0;

   473     tPixel*     refPos;

   474     tPixel*     currPos;

   475     int32       row;

   476     int32       col;

   477     

   478     refPos = refFrame + (mbPos->y + mv->mvy) * vopWidth + (mbPos->x + mv->mvx); 

   479     currPos = currMB; 

   480     

   481     for(row = 0; row < MB_SIZE; row++)

   482     {

   483         col = row & 0x1;

   484         for(; col < MB_SIZE; col+= 2)

   485         {

   486             sad += ABS(*(refPos + col) - *(currPos + col));

   487         }

   488         refPos += vopWidth;

   489         currPos += yWidth;

   490     }

   491     mv->SAD = (sad << 1);

   492     return;

   493 }

   494 

   495 

   496 

   497 /* {{-output"vbmMVOutsideBound.txt"}} */

   498 /*

   499 * vbmMVOutsideBound

   500 *

   501 * Parameters:

   502 *     mbPos                pointer to macroblock position structure

   503 *     bestMV               pointer to store the best match motion vector

   504 *     halfPixel            flag to indicate whether half pel search is needed

   505 *

   506 * Function:

   507 *     This function checks whether the MV is within valid range

   508 *

   509 * Returns:

   510 *     Nothing.

   511 *

   512 * Error codes:

   513 *     None.

   514 *

   515 */

   516 tBool vbmMVOutsideBound(tMBPosition *mbPos, tMotionVector* bestMV, tBool halfPixel)

   517 {

   518     int32   xLeft;

   519     int32   xRight;

   520     int32   yTop;

   521     int32   yBottom;

   522     

   523     xLeft = (mbPos->x << halfPixel) + bestMV->mvx;

   524     xRight = (mbPos->x << halfPixel) + (MB_SIZE << halfPixel) + bestMV->mvx;

   525     yTop = (mbPos->y << halfPixel) + bestMV->mvy;

   526     yBottom = (mbPos->y << halfPixel) + (MB_SIZE << halfPixel) + bestMV->mvy;

   527     

   528     if (halfPixel)

   529     {

   530         return ((xLeft < mbPos->LeftBound) ||

   531             (xRight > mbPos->RightBound) ||

   532             (yTop < mbPos->TopBound) ||

   533             (yBottom > mbPos->BottomBound) ||

   534             ((bestMV->mvx) < -32  || (bestMV->mvx) > 31) ||

   535             ((bestMV->mvy) < -32  || (bestMV->mvy) > 31)

   536             );

   537     }

   538     else

   539     {

   540         return ((xLeft < mbPos->LeftBound) ||

   541             (xRight > mbPos->RightBound) ||

   542             (yTop < mbPos->TopBound) ||

   543             (yBottom > mbPos->BottomBound)||

   544             ((bestMV->mvx) < -16  || (bestMV->mvx) > 15) ||

   545             ((bestMV->mvy) < -16  || (bestMV->mvy) > 15)

   546             );

   547     }

   548 }

   549 

   550 

   551 

   552 /* {{-output"vbmEstimateBestPredictor.txt"}} */

   553 /*

   554 * vbmEstimateBestPredictor

   555 *

   556 * Parameters:

   557 *     refFrame             pointer to reference frame

   558 *     currMB               pointer to current MB

   559 *     initPred             pointer to predictor motion vectors, pixel unit

   560 *     mbPos                pointer to macroblock position structure

   561 *     vopWidth             width of frame/VOP

   562 *     yWidth               width of luminance frame 

   563 *     bestMV               pointer to store the best match motion vector

   564 *     noofPredictors       number of predictors

   565 *

   566 * Function:

   567 *     This function estimates the best predictor among the set

   568 *

   569 * Returns:

   570 *     Nothing.

   571 *

   572 * Error codes:

   573 *     None.

   574 *

   575 */

   576 void vbmEstimateBestPredictor(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, u_int32 yWidth, 

   577                               tMotionVector* initPred, tMBPosition* mbPos,

   578                               int32 noOfPredictors, tMotionVector* bestMV)

   579 {

   580     int32 i;

   581     bestMV->SAD = 65535;

   582     for(i = 0; i < noOfPredictors; i++)

   583     {

   584         if (vbmMVOutsideBound(mbPos, (initPred + i), 0))

   585         {

   586             initPred[i].SAD = 65535;

   587         }

   588         else

   589         {

   590             vbmMBSAD(refFrame, vopWidth, currMB, yWidth, (initPred + i), mbPos);

   591         }

   592         if(initPred[i].SAD < bestMV->SAD)

   593         {

   594             bestMV->SAD = initPred[i].SAD;

   595             bestMV->mvx = initPred[i].mvx;

   596             bestMV->mvy = initPred[i].mvy;

   597         }

   598     }

   599     

   600     return;

   601 }       

   602 

   603 

   604 

   605 /* {{-output"vbmEstimateBound.txt"}} */

   606 /*

   607 * vbmEstimateBound

   608 *

   609 * Parameters:

   610 *     mbPos                pointer to macroblock position structure

   611 *     vopWidth             width of frame/VOP

   612 *     vopHeight            height of frame/VOP

   613 *     searchRange          search range

   614 *

   615 * Function:

   616 *     This function evaluates the bounds for a macroblock BM search

   617 *

   618 * Returns:

   619 *     Nothing.

   620 *

   621 * Error codes:

   622 *     None.

   623 *

   624 */

   625 void vbmEstimateBound(tMBPosition *mbPos,u_int32 vopWidth, u_int32 vopHeight, int32 searchRange)

   626 {

   627     mbPos->LeftBound = mbPos->x - searchRange;

   628     mbPos->RightBound = mbPos->x + 16 + searchRange;

   629     mbPos->TopBound = mbPos->y - searchRange;

   630     mbPos->BottomBound = mbPos->y + 16 + searchRange;

   631     

   632     if(mbPos->LeftBound < 0)

   633     {

   634         mbPos->LeftBound = 0;

   635     }

   636     if(mbPos->RightBound > (int32)vopWidth)

   637     {

   638         mbPos->RightBound = vopWidth;

   639     }

   640     if(mbPos->TopBound < 0 )

   641     {

   642         mbPos->TopBound = 0;

   643     }

   644     if(mbPos->BottomBound > (int32)vopHeight)

   645     {

   646         mbPos->BottomBound = vopHeight;

   647     }

   648     

   649     return;

   650 }

   651 

   652 

   653 

   654 /* {{-output"vbmEstimateBoundHalfPel.txt"}} */

   655 /*

   656 * vbmEstimateBoundHalfPel

   657 *

   658 * Parameters:

   659 *     mbPos                pointer to macroblock position structure

   660 *     vopWidth             width of frame/VOP

   661 *     vopHeight            height of frame/VOP

   662 *

   663 * Function:

   664 *     This function evaluates the bounds for a macroblock BM search in half pel accuracy

   665 *

   666 * Returns:

   667 *     Nothing.

   668 *

   669 * Error codes:

   670 *     None.

   671 *

   672 */

   673 void vbmEstimateBoundHalfPel(tMBPosition *mbPos, u_int32 vopWidth, u_int32 vopHeight)

   674 {

   675     mbPos->LeftBound = 0;

   676     mbPos->RightBound = (vopWidth << 1);

   677     mbPos->TopBound = 0;

   678     mbPos->BottomBound = (vopHeight << 1);

   679     return;

   680 }

   681 

   682 

   683 

   684 /* {{-output"vbmSmallDiamondSearch.txt"}} */

   685 /*

   686 * vbmSmallDiamondSearch

   687 *

   688 * Parameters:

   689 *     refFrame             pointer to reference frame

   690 *     currMB               pointer to current MB

   691 *     initPred             pointer to predictor motion vectors, pixel unit

   692 *     mbPos                pointer to macroblock position structure

   693 *     vopWidth             width of frame/VOP

   694 *     yWidth               width of luminance frame 

   695 *     bestMV               pointer to store the best match motion vector

   696 * Function:

   697 *     This function performs motion estimation for a macroblock using small diamond search

   698 *

   699 * Returns:

   700 *     Nothing.

   701 *

   702 * Error codes:

   703 *     None.

   704 *

   705 */

   706 void vbmSmallDiamondSearch(tPixel* refFrame, tPixel* currMB, tMotionVector *initPred, 

   707                                                      tMotionVector* bestMV, u_int32 vopWidth, tMBPosition* mbPos, 

   708                                                      u_int32 yWidth)

   709 {

   710     u_int8 locateSDS[5][5] =

   711     {

   712         {0,0,0,0,0},

   713         {0,1,1,0,1},

   714         {0,1,1,1,0},

   715         {0,0,1,1,1},

   716         {0,1,0,1,1}

   717     };

   718     u_int32  i;

   719     int32   stepCount;

   720     int32   flag=1;

   721     int32   position=0;

   722     

   723     //form the diamond shap search pattern

   724     stepCount = 1;

   725     initPred[0].SAD = bestMV->SAD;

   726     initPred[1].mvx = (int16)(bestMV->mvx + 1);

   727     initPred[1].mvy = bestMV->mvy;

   728     initPred[2].mvx = bestMV->mvx;

   729     initPred[2].mvy = (int16)(bestMV->mvy - 1);

   730     initPred[3].mvx = (int16)(bestMV->mvx - 1);

   731     initPred[3].mvy = bestMV->mvy;

   732     initPred[4].mvx = bestMV->mvx;

   733     initPred[4].mvy = (int16)(bestMV->mvy + 1);

   734     

   735     for(i = 1; i < 5; i++)

   736     {

   737         if(vbmMVOutsideBound(mbPos, &initPred[i], 0) )

   738         {

   739             initPred[i].SAD = 65535;

   740         }

   741         else

   742         {

   743             vbmMBSAD(refFrame, vopWidth, currMB, yWidth, (initPred + i), mbPos);

   744         }

   745         if(initPred[i].SAD < bestMV->SAD)

   746         {

   747             bestMV->SAD = initPred[i].SAD;

   748             bestMV->mvx = initPred[i].mvx;

   749             bestMV->mvy = initPred[i].mvy;

   750             position = i;

   751         }

   752     }

   753     

   754     /* the minimum SAD falls in the center */

   755     if(bestMV->SAD == initPred[0].SAD)

   756     {

   757         return;

   758     }

   759     

   760     while(flag)

   761     {

   762         stepCount++;

   763         initPred[0].SAD = bestMV->SAD;

   764         initPred[1].mvx = (int16)(bestMV->mvx + 1);

   765         initPred[1].mvy = bestMV->mvy;

   766         initPred[2].mvx = bestMV->mvx;

   767         initPred[2].mvy = (int16)(bestMV->mvy - 1);

   768         initPred[3].mvx = (int16)(bestMV->mvx - 1);

   769         initPred[3].mvy = bestMV->mvy;

   770         initPred[4].mvx = bestMV->mvx;

   771         initPred[4].mvy = (int16)(bestMV->mvy + 1);

   772         

   773         for(i = 1; i < 5; i++)

   774         {

   775             if(locateSDS[position][i] != 0)

   776             {

   777                 if(vbmMVOutsideBound(mbPos, &initPred[i],0))

   778                 {

   779                     initPred[i].SAD = 65535;

   780                 }

   781                 else

   782                 {

   783                     vbmMBSAD(refFrame, vopWidth, currMB, yWidth, (initPred + i), mbPos);

   784                     if(initPred[i].SAD < bestMV->SAD)

   785                     {

   786                         bestMV->mvx = initPred[i].mvx;

   787                         bestMV->mvy = initPred[i].mvy;

   788                         bestMV->SAD = initPred[i].SAD;

   789                         position = i;

   790                     }

   791                 }

   792             }

   793         }

   794         if(bestMV->SAD == initPred[0].SAD)

   795         {

   796             break;

   797         }

   798         if(stepCount > DIAMOND_SEARCH_NUMBER) // we only do 2 diamond search here

   799         {

   800             break;

   801         }

   802     }

   803     

   804     return;

   805 }

   806 

   807 

   808                                                      

   809 /* {{-output"vbmSADHalfPel.txt"}} */

   810 /*

   811 * vbmSADHalfPel

   812 *

   813 * Parameters:

   814 *     refFrame             pointer to reference frame

   815 *     currMB               pointer to current MB

   816 *     mbPos                pointer to macroblock position structure

   817 *     vopWidth             width of frame/VOP

   818 *     yWidth               width of luminance frame 

   819 *     mv                   pointer to motion vector

   820 *     roundingControl      rounding control value

   821 *     blockSize            block size

   822 * Function:

   823 *     This function evaluates SAD for a macroblock/block for half pel motion vector

   824 *

   825 * Returns:

   826 *     Nothing.

   827 *

   828 * Error codes:

   829 *     None.

   830 *

   831 */

   832 void vbmSADHalfPel(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, u_int32 yWidth,

   833                                      tMotionVector* mv, const tMBPosition* mbPos, tBool roundingControl, 

   834                    int32 blockSize)

   835 {

   836     u_int32      sad = 0;

   837     tPixel*     refPos;

   838     tPixel*     currPos;

   839     int32       row;

   840     int32       col;

   841     int32       extendedVOPWidth;

   842     int32       temp;

   843     

   844     extendedVOPWidth = vopWidth ;

   845     refPos = refFrame + (mbPos->y + (mv->mvy >> 1)) * extendedVOPWidth + 

   846         (mbPos->x + (mv->mvx >> 1)); 

   847     currPos = currMB; 

   848     

   849     if(mv->mvy & 1)

   850     {

   851         if(mv->mvx & 1)

   852         {

   853             /* Both horizontal and vertical components are having half pel */

   854             for(row = 0; row < blockSize; row++)

   855             {

   856                 col = row & 0x1;

   857                 for(; col < blockSize; col += 2)

   858                 {

   859                     temp = (refPos[col] + refPos[col + 1] + 

   860                         refPos[col + extendedVOPWidth] +

   861                         refPos[col + extendedVOPWidth + 1] +

   862                         2 -roundingControl) >> 2;

   863                     sad += ABS(temp - currPos[col]);

   864                 }

   865                 refPos += extendedVOPWidth;

   866                 currPos += yWidth;

   867             }

   868             mv->SAD = (sad << 1);

   869         }

   870         else

   871         {

   872             /* Vertical component is having half pel */

   873             for(row = 0; row < blockSize; row++)

   874             {

   875                 col = row & 0x1;

   876                 for(; col < blockSize; col += 2)

   877                 {

   878                     temp = (refPos[col] + refPos[col + extendedVOPWidth]+

   879                         1 -roundingControl) >> 1;

   880                     sad += ABS(temp - currPos[col]);

   881                 }

   882                 refPos += extendedVOPWidth;

   883                 currPos += yWidth;

   884             }

   885             mv->SAD = (sad << 1);

   886         }

   887     }

   888     else

   889     {

   890         if(mv->mvx & 1)

   891         {

   892             /* Horizontal component is having half pel */

   893             for(row = 0; row < blockSize; row++)

   894             {

   895                 col = row & 0x1;

   896                 for(; col < blockSize; col += 2)

   897                 {

   898                     temp = (refPos[col] + refPos[col + 1] + 

   899                         1 -roundingControl) >> 1;

   900                     sad += ABS(temp - currPos[col]);

   901                 }

   902                 refPos += extendedVOPWidth;

   903                 currPos += yWidth;

   904             }

   905             mv->SAD = (sad << 1);

   906         }

   907         else

   908         {

   909             /* Both horizontal and vertical components are integer pel */

   910             for(row = 0; row < blockSize; row++)

   911             {

   912                 col = row & 0x1;

   913                 for(; col < blockSize; col += 2)

   914                 {

   915                     sad += ABS(refPos[col] - currPos[col]);

   916                 }

   917                 refPos += extendedVOPWidth;

   918                 currPos += yWidth;

   919             }

   920             mv->SAD = (sad << 1);

   921         }

   922     }

   923     

   924     return;

   925 }

   926 

   927 

   928 

   929 

   930 /* {{-output"vbmHalfPelSearchMB.txt"}} */

   931 /*

   932 * vbmHalfPelSearchMB

   933 *

   934 * Parameters:

   935 *     refFrame             pointer to reference frame

   936 *     currMB               pointer to current MB

   937 *     mbPos                pointer to macroblock position structure

   938 *     vopWidth             width of frame/VOP

   939 *     yWidth               width of luminance frame 

   940 *     initPred             pointer to predictor motion vectors, pixel unit

   941 *     bestMV               pointer to store the best match motion vector

   942 * Function:

   943 *     This function evaluates the half pel motion vector for a 16x16 block using 

   944 *     the integer pel motion vector

   945 *

   946 * Returns:

   947 *     Nothing.

   948 *

   949 * Error codes:

   950 *     None.

   951 *

   952 */

   953 void vbmHalfPelSearchMB(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, 

   954                                                 u_int32 yWidth, tMotionVector* initPred,

   955                                                 tMotionVector* bestMV, tMBPosition* mbPos)

   956 {

   957     int32 i;

   958     int32 position=0;

   959     

   960     initPred[0].SAD = bestMV->SAD;

   961     initPred[1].mvx = (int16)(bestMV->mvx + 1);

   962     initPred[1].mvy = bestMV->mvy;

   963     initPred[2].mvx = bestMV->mvx;

   964     initPred[2].mvy = (int16)(bestMV->mvy - 1);

   965     initPred[3].mvx = (int16)(bestMV->mvx - 1);

   966     initPred[3].mvy = bestMV->mvy;

   967     initPred[4].mvx = bestMV->mvx;

   968     initPred[4].mvy = (int16)(bestMV->mvy + 1);

   969     

   970     for(i = 1; i < 5; i++)

   971     {

   972         if(vbmMVOutsideBound(mbPos, &initPred[i], 1))

   973         {

   974             initPred[i].SAD = 65535;

   975         }

   976         else

   977         {

   978             vbmSADHalfPel(refFrame, vopWidth, currMB, yWidth, 

   979                 (initPred + i), mbPos,(tBool)(0), 16);

   980         }

   981         

   982         if(initPred[i].SAD < bestMV->SAD)

   983         {

   984             bestMV->mvx = initPred[i].mvx;

   985             bestMV->mvy = initPred[i].mvy;

   986             bestMV->SAD = initPred[i].SAD;

   987             position = i;

   988         }

   989     }

   990     

   991     if(1)

   992     {

   993         if(bestMV->SAD == initPred[0].SAD)

   994         {

   995             return;

   996         }

   997         else

   998         {

   999             switch(position)

  1000             {

  1001             case 1: case 3:

  1002                 initPred[5].mvx = bestMV->mvx;

  1003                 initPred[5].mvy = (int16)(bestMV->mvy - 1);

  1004                 initPred[6].mvx = bestMV->mvx;

  1005                 initPred[6].mvy = (int16)(bestMV->mvy + 1);

  1006                 break;

  1007                 

  1008             case 2: case 4:

  1009                 initPred[5].mvx = (int16)(bestMV->mvx - 1);

  1010                 initPred[5].mvy = bestMV->mvy;

  1011                 initPred[6].mvx = (int16)(bestMV->mvx + 1);

  1012                 initPred[6].mvy = bestMV->mvy;

  1013                 break;

  1014                 

  1015             default:

  1016                 break;

  1017             }

  1018             

  1019             for(i = 5; i < 7; i++)

  1020             {

  1021                 

  1022                 if(vbmMVOutsideBound(mbPos, &initPred[i],1))

  1023                 {

  1024                     initPred[i].SAD = 65535;

  1025                 }

  1026                 else

  1027                 {

  1028                     vbmSADHalfPel(refFrame, vopWidth, currMB, yWidth,

  1029                         (initPred + i), mbPos, (tBool)0, 16);

  1030                 }

  1031                 if(initPred[i].SAD < bestMV->SAD)

  1032                 {

  1033                     bestMV->mvx = initPred[i].mvx;

  1034                     bestMV->mvy = initPred[i].mvy;

  1035                     bestMV->SAD = initPred[i].SAD;

  1036                 }

  1037             }

  1038         }

  1039     }

  1040     

  1041     return;

  1042 }

  1043 

  1044 

  1045 

  1046 /* {{-output"vbmMEMBSpatioTemporalSearch.txt"}} */

  1047 /*

  1048 * vbmMEMBSpatioTemporalSearch

  1049 *

  1050 * Parameters:

  1051 *     refFrame             pointer to reference frame

  1052 *     currMB               pointer to current MB

  1053 *     mbPos                pointer to macroblock position structure

  1054 *     vopWidth             width of frame/VOP

  1055 *     vopHeight            height of frame/VOP

  1056 *     yWidth               width of luminance frame 

  1057 *     initPred             pointer to predictor motion vectors, pixel unit

  1058 *     bestMV               pointer to store the best match motion vector

  1059 *     noOfPredictors       number of MV predictors

  1060 *     searchRange          search range

  1061 *     minSAD               minimum SAD

  1062 * Function:

  1063 *     This function performs motion estimation for a macroblock using 

  1064 *     spatio-temporal correlation based search

  1065 *

  1066 * Returns:

  1067 *     Nothing.

  1068 *

  1069 * Error codes:

  1070 *     None.

  1071 *

  1072 */

  1073 int32 vbmMEMBSpatioTemporalSearch(tPixel* refFrame, u_int32 vopWidth, u_int32 vopHeight, 

  1074                                                                     tPixel* currMB, u_int32 yWidth, tMBPosition* mbPos,

  1075                                                                     tMotionVector   *initPred, int32 noOfPredictors,

  1076                                                                     tMotionVector* bestMV, int32 searchRange, u_int32 minSAD)

  1077 {

  1078     /* estimate the bound of MV for current MB */

  1079     vbmEstimateBound(mbPos, vopWidth, vopHeight, searchRange);

  1080     

  1081     /* get the best MV predictor from the candidates set */

  1082     vbmEstimateBestPredictor(refFrame, vopWidth, currMB, yWidth, initPred, mbPos, noOfPredictors, bestMV);

  1083     

  1084     if(bestMV->SAD >= minSAD)

  1085     {

  1086         /* from the MV predictor, starts the small diamond search    */

  1087         vbmSmallDiamondSearch(refFrame, currMB, initPred, bestMV, vopWidth, mbPos, yWidth);

  1088     }

  1089     

  1090     /* adjustment for half-pixel search */

  1091     bestMV->mvx <<= 1;

  1092     bestMV->mvy <<= 1;

  1093     

  1094     /* MV bound in half-pixel  */

  1095     vbmEstimateBoundHalfPel(mbPos,vopWidth, vopHeight);

  1096     

  1097     /* starts the half-pixel search around the integer-pixel MV */

  1098     vbmHalfPelSearchMB(refFrame, vopWidth, currMB, yWidth, 

  1099         initPred, bestMV, mbPos);

  1100     

  1101     return bestMV->SAD;

  1102 }

  1103 

  1104 

  1105 

  1106 /* {{-output"vbmRowDCT.txt"}} */

  1107 /*

  1108 * vbmRowDCT

  1109 *

  1110 * Parameters:

  1111 *     block                array of 64 block coefficients 

  1112 * Function:

  1113 *     This function performs row DCT of 8x8 block of data elements

  1114 *

  1115 * Returns:

  1116 *     Nothing.

  1117 *

  1118 * Error codes:

  1119 *     None.

  1120 *

  1121 */

  1122 void vbmRowDCT(int16 *block)

  1123 {

  1124     int32  coeff0, coeff1, coeff2, coeff3;

  1125     int32  coeff4, coeff5, coeff6, coeff7;

  1126     int32  temp;

  1127     u_int16 count;

  1128     int32  rowStartIndex;

  1129     

  1130     for(count = 0; count < BLOCK_SIZE; count++)

  1131     {

  1132         rowStartIndex = count << LOG_BLOCK_WIDTH;

  1133         

  1134         /* Stage 1 and up scaling of the input data to improve precision */

  1135         coeff0 = (block[rowStartIndex] + block[rowStartIndex + 7]) <<