/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

* Motion vector calculations and storage.

*

*/

#include "h263dConfig.h"

#include "vdcmvc.h"

#include "core.h"

#include "errcodes.h"

#include "debug.h"

/* 

 * Defines 

 */

#define NEIGHBOUR_SIZE 2      /* The size for neighbour array */

#define MVD_NOT_CODED -32767  /* Macroblock is not coded in mvcTable_t */

#define MVD_INTRA -32765      /* Marks intra macroblock in mvcTable_t */

#define MVD_UMIN_MPEG4 -10240

#define MVD_MIN -160          /* The minimum for mvd. */

#define MVD_MAX 155           /* The maximum for mvd. */

#define MVD_UMIN_V1 -315      /* The minimum for MV in unrestricted mode (v1) */

#define MVD_UMAX_V1 315       /* The maximum for MV in unrestricted mode (v1) */

#define MVD_UMIN_V2 -32000    /* The minimum for MV in unrestricted mode (v2)

                                 Note: this value is used to check the validity

                                 of MVs. If there is no MV for a MB 

                                 MVD_NOT_CODED or MVD_INTRA are used, and

                                 therefore any value bigger than those

                                 suits for this definition. In H.263 v2 

                                 unlimited submode, MVs can have any length

                                 within a picture (plus 15-pixel border),

                                 and therefore this definition is set to small

                                 enough value. */

#define MVD_155 155           /* MV for 15.5 */

#define MVD_160 160           /* MV for 16 */

#define MVD_320 320           /* MV for 32 */

/* It is assumed that motion vector values are signed and in order

   (for example MV for 15.5 < MV for 16).

   No other assumptions are made. */

/* 

 * Macros 

 */

/* mvValid checks if the specified item is a valid motion vector */

/* Note: MVD_NOT_CODED and MVD_INTRA are very small negative numbers.

         Thus, we can use the minimum MV for H.263 Annex D unlimited

         submode to check the validity of a passed item. Actually,

         we could use any value larger than MVD_NOT_CODED and MVD_INTRA

         and smaller than or equal to the minimum MV. */

#define mvValid(d1item, d1y, d1time) \

   (d1item.mvx >= MVD_UMIN_V2 \

      && d1item.y == (d1y) && d1item.time == (d1time))

#define mvValidMPEG(d1item, d1y, d1time) \

   (d1item.mvx >= MVD_UMIN_MPEG4 \

      && d1item.y == (d1y) && d1item.time == (d1time))

/* mvLegal cheks if the specified item has been updated to either contain

   a motion vector or not coded / intra information */

#define mvLegal(d5item, d5y, d5time) \

   (d5item.y == (d5y) && d5item.time == (d5time))

/* mvStore puts given arguments into the motion vector array

   Used from: mvcCalcMV */

#define mvStore(d2row, d2x, d2y, d2mvx, d2mvy, d2time, d2type) \

   d2row[d2x].mvx = d2mvx; d2row[d2x].mvy = d2mvy; \

   d2row[d2x].y = d2y; d2row[d2x].time = d2time; d2row[d2x].fourMVs = 1; \

   d2row[d2x].type = d2type

/* mvStoreMB puts given arguments into the motion vector array for the

   whole macroblock

   Used from: mvcCalcMV, mvcMarkMBIntra, mvcMarkMBNotCoded */

#define mvStoreMB(d4row1, d4row2, d4x, d4y, d4mvx, d4mvy, d4time, d4type) \

   d4row1[d4x].mvx = d4row1[d4x + 1].mvx = \

      d4row2[d4x].mvx = d4row2[d4x + 1].mvx = d4mvx; \

   d4row1[d4x].mvy = d4row1[d4x + 1].mvy = \

      d4row2[d4x].mvy = d4row2[d4x + 1].mvy = d4mvy; \

   d4row1[d4x].y = d4row1[d4x + 1].y = d4y; \

   d4row2[d4x].y = d4row2[d4x + 1].y = d4y + 1; \

   d4row1[d4x].time = d4row1[d4x + 1].time = \

      d4row2[d4x].time = d4row2[d4x + 1].time = time; \

   d4row1[d4x].fourMVs = d4row1[d4x + 1].fourMVs = \

      d4row2[d4x].fourMVs = d4row2[d4x + 1].fourMVs = 0; \

   d4row1[d4x].type = d4row1[d4x + 1].type = \

      d4row2[d4x].type = d4row2[d4x + 1].type = (d4type)

/* updateRowPointers checks if currX, currY or currTime have changed

   and updates them. It also updates mvRow0, mvRow1 and mvRow2.

   Used from: mvcCalcMV, mvcMarkMBIntra, mvcMarkMBNotCoded */

#define updateRowPointers(d3x, d3y, d3time) \

   if (d3x != mvcData->currX) \

      mvcData->currX = d3x; \

   if (d3y != mvcData->currY) { \

      int \

         mvRowIndex, \

         currMaxX = mvcData->currMaxX; \

      mvRowItem_t *mvRow = mvcData->mvRow; \

      mvcData->currY = d3y; \

      mvcData->mvRowIndex = mvRowIndex = (mvcData->mvRowIndex + 2) % 3; \

      mvcData->mvRow0 = &mvRow[(currMaxX + 1) * 2 * mvRowIndex]; \

      mvcData->mvRow1 = &mvRow[(currMaxX + 1) * 2 * ((mvRowIndex + 1) % 3)]; \

      mvcData->mvRow2 = &mvRow[(currMaxX + 1) * 2 * ((mvRowIndex + 2) % 3)]; \

   } \

   if (d3time != mvcData->currTime) \

      mvcData->currTime = d3time 

/* mvcInvMVD takes the other one of the possible MVD values defined in

   H.263 Recommendation */

#define mvcInvMVD(invMv) \

   (invMv < 0) ? \

      MVD_320 + invMv : \

      -MVD_320 + invMv

/* sign123(x) returns

      1 if x < 0,

      2 if x > 0,

      3 if x == 0 

   In other words,

      bit 0 = 1 if x <= 0, 

      bit 1 = 1 if x >= 0 */

#define sign123(x) ((x == 0) ? 3 : (x < 0) ? 1 : 2)

/* 

 * Local prototypes

 */

static void mvcGetNeighbourMVs(mvcData_t *mvcData, int x, int y, int time,

   int *nmvx, int *nmvy, int prevFlag, int16 *error);

__inline static void mvcCheckAndSet( 

      mvRowItem_t *mvRowPtr, int xind, int yind, int time, int nind, 

      int *nmvx, int *nmvy, mvRowItem_t *cmvRowPtr, int cxind, int cyind,

      int16 *error);

__inline static void mvcSetToCurrent( 

      mvRowItem_t *mvRowPtr, int xind, int yind, int time, int nind,

      int *nmvx, int *nmvy, int16 *error);

/*

 * Global functions

 */

/* {{-output"mvcSetBorders.txt"}} */

/*

 *

 * mvcSetBorders

 *

 * Parameters:

 *    mvcData        mvcData_t structure

 *    x              the x coordinate of the MB (0 .. maxX)

 *    y              the y coordinate of the MB

 *                   (0 .. macroblock rows in frame - 1)

 *    mba            Macroblock address of starting MB of the slice. This 

 *                   value SHOULD be set to -1 if Annex K is not in use.

 *    numMBsInMBLine    Number of MBs in MB line    

 *    rightOfBorder     There is a border on the left of the current MB

 *    downOfBorder      There is a border on top of the current MB

 *

 * Function:

 *    This function calculates the borders of GOBs and Slices..This function 

 *    SHOULD be called before mvcCalcMV.....

 *

 * Returns:

 *    Nothing

 *

 * Error codes:

 *    None

 *

 */

void mvcSetBorders(

      mvcData_t *mvcData, int x, int y, int mba, int numMBsInMBLine, 

      int *rightOfBorder, int *downOfBorder 

)

{

   int

      upRightMBIsStart;

   if (mvcData)   {

      mvcData->rightOfBorderPrev = mvcData->rightOfBorder;

      mvcData->downOfBorderPrev = mvcData->downOfBorder;

   }

   if (mba == -1) {

      if (x == 0) {

         *rightOfBorder = 1;

      }

      else  {

         *rightOfBorder = 0;

      }

      /* Always downOfBorder is set to 1, since in QCIF and CIF every GOB

         has only 1 MB line. If larger images are supported, numMBLinesInGOB

         should be passed here. Also number of starting MB of the GOB may be

         needed...*/

      *downOfBorder = 1;

      upRightMBIsStart = 0;

   }

   else  {

      int

         xs,   /* x coordinate of start MB */

         ys;   /* y coordinate of start MB */

      xs = mba % numMBsInMBLine;

      ys = mba / numMBsInMBLine;

      /* slice structured mode*/

      /* Check if there is slice border on top of the  current MB:

         For that, check either current MB should be on the same MB line 

         with the starting MB of slice or current MB should not be on the

         left of the starting MB if the MB is on the second line of the 

         slice. */

      if ((y == ys) || ((x < xs) && (ys+1 == y)))  {

         *downOfBorder = 1;

      }

      else  {

         *downOfBorder = 0;

      }   

      /* Check if there is a slice border on the left of the current MB.*/

      if (((x == xs) && (y == ys)) || (x == 0))  {

         *rightOfBorder = 1;

      }

      else  {

         *rightOfBorder = 0;

      }

      /* Test the situation of MV2 is in another slice but MV3 in in the

         same slice... i.e:

         MB1 MB1 MB1 MB2 MB2 .........MB2

         MB2 MB2 MB2 MB2 MB2..........MB2

                  *                        

         The MB marked with * is an exmaple. MB on top of it is in another slice

         but the MB which MV3 will come from is in the same slice...*/

      if ((x+1 == xs) && (y-1 == ys))

         upRightMBIsStart = 1;

      else

         upRightMBIsStart = 0;

   }   

   if (mvcData)   {

      mvcData->upRightMBIsStart = upRightMBIsStart;

      mvcData->downOfBorder = *downOfBorder;

      mvcData->rightOfBorder = *rightOfBorder;

      mvcData->leftOfBorder = 0;

   }

}

/* {{-output"mvcCalcMV.txt"}} */

/*

 *

 * mvcCalcMV

 *

 * Parameters:

 *       mvcData        mvcData_t structure

 *

 *       mvdx           motion vector data returned by vlcGetMVD

 *       mvdy

 *

 *       *mvx           the resulting motion vector is placed to *mvx and *mvy

 *       *mvy

 *

 *       predictorMode  0, 1, 2 or 3. See H.263 recommendation, Annex F, Figure

 *                      15, where modes are in the following order:

 *                         0  1

 *                         2  3

 *

 *                      Advanced Prediction mode: It is assumed that this

 *                      function is called by setting predictorMode 0, 1, 2

 *                      and 3 in this order for a particular macroblock.

 *

 *                      Normal: This function should be called by setting

 *                      predictorMode to 0.

 *

 *       fourMVs        if != 0, four motion vectors for current macroblock

 *                      is assumed

 *

 *       unrestrictedMV       if != 0, unrestricted motion vector mode is used

 *

 *       topOfGOB             if != 0, the current MB is assumed to be in the

 *                            first line of the current GOB

 *

 *       nonEmptyGOBHeader    if != 0, the GOB header of the current GOB is

 *                            is assumed to be non-empty, and MV2 and MV3 are

 *                            set to MV1 if they are outside the GOB. If Annex K

 *                            is in use set this value to 1......

 *

 *       x              the x coordinate of the MB (0 .. maxX)

 *       y              the y coordinate of the MB

 *                      (0 .. macroblock rows in frame - 1)

 *

 *       time           a value which is related to the time when the current

 *                      frame must be shown. This value should be unique

 *                      among a relatively small group of consecutive frames.

 *

 *       mbType         must be MVC_MB_INTER or MVC_MB_INTRA. MVC_MB_INTRA 

 *                      should be used only in PB frames mode.

 *

 *       error          error code

 *

 *       fPLUSPTYPE     PLUSTYPE flag

 *

 *       fUMVLimited    Annex D v2 flag

 *                      1  => Limited MVs    (UUI = 1)

 *                      0  => Unlimited MVs  (UUI = 01)

 *

 * Function:

 *       This function counts the motion vector value for given macroblock.

 *       See H.263 Recommendation 6.1.1 Differential Motion Vectors and

 *       Annex F. Advanced Prediction Mode.

 *

 * Returns:

 *       Changes *mvx, *mvy and possibly *error.

 *

 * Error codes:

 *       ERR_MVC_MVDX_ILLEGAL    mvdx illegal

 *       ERR_MVC_MVDY_ILLEGAL    mvdy illegal

 *       ERR_MVC_MVX_ILLEGAL     mvx is NULL

 *       ERR_MVC_MVY_ILLEGAL     mvy is NULL

 *       ERR_MVC_MODE_ILLEGAL    predictorMode illegal

 *       ERR_MVC_X_ILLEGAL       x < 0 or x > maxX

 *       ERR_MVC_Y_ILLEGAL       y < 0

 *       ERR_MVC_TIME_ILLEGAL    time < 0

 *       ERR_MVC_MVPTR           result is not legal

 *

 */

void mvcCalcMV(mvcData_t *mvcData, int mvdx, int mvdy,

   int *mvx, int *mvy, u_char predictorMode, u_char fourMVs,

   u_char unrestrictedMV,  u_char nonEmptyGOBHeader, int x, 

   int y, int time, int mbType, int16 *error, int fPLUSPTYPE, 

   int fUMVLimited)

/* {{-output"mvcCalcMV.txt"}} */

{

   int 

      i, j,    /* loop variables */

      mvcx[3], /* Candidates: mv[0] = MV1, mv[1] = MV2, mv[2] = MV3 */

      mvcy[3],

      *mv,     /* mvcx or mvcy */

      *mvptr,  /* == mvx or mvy */

      mvd,     /* mvdx or mvdy */

      xx2,     /* x * 2 */

      yx2,     /* y * 2 */

      xmv1,    /* index for MV1 */

      xmv2,    /* index for MV2 */

      xmv3,    /* index for MV3 */

      ymv1,

      ymv2,

      ymv3,

      mvRangeLow,    /* Lower boundary for MV Range  

                        Look H.263+ Rec. Table D.1, D.2 */

      mvRangeHigh,   /* Higher boundary for MV Range  

                        Look H.263+ Rec. Table D.1, D.2 */

      picDim,        /* Temporary variable for luminance width or height */

      mbCorner,      /* Temporary variable for MB's topleft corner's 

                        coordinate (x or y)*/

      mvRes;         /* MB's rightmost or bottommost pixel plus MV

                        for checking restriction D.1.1 */

   mvRowItem_t

      *currMvRow,

      *prevMvRow,

      *mvRow0,

      *mvRow1,

      *mvRow2;

   /* Check parameters */

    if ((!fPLUSPTYPE) || (!unrestrictedMV))

   {

      if (mvdx < MVD_MIN || mvdx > MVD_MAX) {

         *error = ERR_MVC_MVDX_ILLEGAL;

         return;

      }

      if (mvdy < MVD_MIN || mvdy > MVD_MAX) {

         *error = ERR_MVC_MVDY_ILLEGAL;

         return;

      }

   }

   if (!mvx) {

      *error = ERR_MVC_MVX_ILLEGAL;

      return;

   }

   if (!mvy) {

      *error = ERR_MVC_MVY_ILLEGAL;

      return;

   }

   if ((fourMVs && predictorMode > 3) ||

      (!fourMVs && predictorMode > 0)) {

      *error = ERR_MVC_MODE_ILLEGAL;

      return;

   }

   if (x < 0 || x > mvcData->currMaxX) {

      *error = ERR_MVC_X_ILLEGAL;

      return;

   }

   if (y < 0) {

      *error = ERR_MVC_Y_ILLEGAL;

      return;

   }

   if (time < 0) {

      *error = ERR_MVC_TIME_ILLEGAL;

      return;

   }

   updateRowPointers(x, y, time);

   mvRow0 = mvcData->mvRow0;

   mvRow1 = mvcData->mvRow1;

   mvRow2 = mvcData->mvRow2;

   /* Seek candidate predictors */

   xx2 = x << 1; /* xx2 = x * 2 */

   yx2 = y << 1;

   xmv1 = xx2 - 1 + (predictorMode & 1);

   xmv2 = xx2 + (predictorMode == 1);

   xmv3 = xx2 + 2 - (predictorMode > 1);

   ymv1 = yx2 + (predictorMode > 1);

   ymv2 = ymv3 = yx2 - 1 + (predictorMode > 1);

   if (predictorMode <= 1) {

      currMvRow = mvRow1;

      prevMvRow = mvRow0;

   }

   else {

      currMvRow = mvRow2;

      prevMvRow = mvRow1;

   }

   if ( (predictorMode & 1) || /* right column of the MB */

      ( !mvcData->rightOfBorder && mvValid(currMvRow[xmv1], ymv1, time) ) ) {

      mvcx[0] = currMvRow[xmv1].mvx;

      mvcy[0] = currMvRow[xmv1].mvy;

   }

   else

      /* if (x == 0 || motion vector for previous MB does not exist ||

             the previous MB belongs to a different slice) */

      mvcx[0] = mvcy[0] = 0;

   if ((y == 0 || (mvcData->downOfBorder && nonEmptyGOBHeader)) && predictorMode <= 1) {

      /* mv2 and mv3 are outside the picture or GOB

         (if non-empty GOB header) or outside the slice*/

      mvcx[1] = mvcx[0];

      mvcy[1] = mvcy[0];

      /* Check if the MB ont the previous line and on the next column

         in in the same slice (means start MBof the slice).. */

      if (!mvcData->upRightMBIsStart)   {

         mvcx[2] = mvcx[0];

         mvcy[2] = mvcy[0];

      }

      if (x == mvcData->currMaxX)

         mvcx[2] = mvcy[2] = 0;

   }

   else {

      if (mvValid(prevMvRow[xmv2], ymv2, time)) {

         mvcx[1] = prevMvRow[xmv2].mvx;

         mvcy[1] = prevMvRow[xmv2].mvy;

      }

      else 

         mvcx[1] = mvcy[1] = 0;

      if (mvValid(prevMvRow[xmv3], ymv3, time)) {

         mvcx[2] = prevMvRow[xmv3].mvx;

         mvcy[2] = prevMvRow[xmv3].mvy;

      }

      else

         mvcx[2] = mvcy[2] = 0;

   }

    for (j = 0, mv = mvcx, mvd = mvdx, mvptr = mvx,

         picDim = mvcData->currLumWidth, mbCorner = x,

         mvRangeLow = mvcData->mvRangeLowX,

         mvRangeHigh = mvcData->mvRangeHighX;

         j < 2;

         j++, mv = mvcy, mvd = mvdy, mvptr = mvy, 

         picDim = mvcData->currLumHeight, mbCorner = y,

         mvRangeLow = mvcData->mvRangeLowY,

         mvRangeHigh = mvcData->mvRangeHighY) {

      int choice1, min, predictor;

      /* Find the median of the candidates */

      min = mv[0];

      predictor = 32767;

      for (i = 1; i < 3; i++) {

         if (mv[i] <= min) {

            predictor = min;

            min = mv[i];

            continue;

         }

         if (mv[i] < predictor)

            predictor = mv[i];

      }