/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*------------------------------------------------------------------------------

    Table of contents

     1. Include headers
     2. External compiler flags
     3. Module defines
     4. Local function prototypes
     5. Functions
          h264bsdInterPrediction
          MvPrediction16x16
          MvPrediction16x8
          MvPrediction8x16
          MvPrediction8x8
          MvPrediction
          MedianFilter
          GetInterNeighbour
          GetPredictionMv

------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
    1. Include headers
------------------------------------------------------------------------------*/

#include "h264bsd_inter_prediction.h"
#include "h264bsd_neighbour.h"
#include "h264bsd_util.h"
#include "h264bsd_reconstruct.h"
#include "h264bsd_dpb.h"

/*------------------------------------------------------------------------------
    2. External compiler flags
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
    3. Module defines
------------------------------------------------------------------------------*/

typedef struct
{
    u32 available;
    u32 refIndex;
    mv_t mv;
} interNeighbour_t;

/*------------------------------------------------------------------------------
    4. Local function prototypes
------------------------------------------------------------------------------*/

static u32 MvPrediction16x16(mbStorage_t *pMb, mbPred_t *mbPred,
    dpbStorage_t *dpb);
static u32 MvPrediction16x8(mbStorage_t *pMb, mbPred_t *mbPred,
    dpbStorage_t *dpb);
static u32 MvPrediction8x16(mbStorage_t *pMb, mbPred_t *mbPred,
    dpbStorage_t *dpb);
static u32 MvPrediction8x8(mbStorage_t *pMb, subMbPred_t *subMbPred,
    dpbStorage_t *dpb);
static u32 MvPrediction(mbStorage_t *pMb, subMbPred_t *subMbPred,
    u32 mbPartIdx, u32 subMbPartIdx);
static i32 MedianFilter(i32 a, i32 b, i32 c);

static void GetInterNeighbour(u32 sliceId, mbStorage_t *nMb,
    interNeighbour_t *n, u32 index);
static void GetPredictionMv(mv_t *mv, interNeighbour_t *a, u32 refIndex);

static const neighbour_t N_A_SUB_PART[4][4][4] = {
    { { {MB_A,5}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,5}, {MB_A,7}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,5}, {MB_CURR,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,5}, {MB_CURR,0}, {MB_A,7}, {MB_CURR,2} } },

    { { {MB_CURR,1}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,1}, {MB_CURR,3}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,1}, {MB_CURR,4}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,1}, {MB_CURR,4}, {MB_CURR,3}, {MB_CURR,6} } },

    { { {MB_A,13}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,13}, {MB_A,15}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,13}, {MB_CURR,8}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,13}, {MB_CURR,8}, {MB_A,15}, {MB_CURR,10} } },

    { { {MB_CURR,9}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,9}, {MB_CURR,11}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,9}, {MB_CURR,12}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,9}, {MB_CURR,12}, {MB_CURR,11}, {MB_CURR,14} } } };

static const neighbour_t N_B_SUB_PART[4][4][4] = {
    { { {MB_B,10}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,10}, {MB_CURR,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,10}, {MB_B,11}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,10}, {MB_B,11}, {MB_CURR,0}, {MB_CURR,1} } },

    { { {MB_B,14}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,14}, {MB_CURR,4}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,14}, {MB_B,15}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,14}, {MB_B,15}, {MB_CURR,4}, {MB_CURR,5} } },

    { { {MB_CURR,2}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,2}, {MB_CURR,8}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,2}, {MB_CURR,3}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,2}, {MB_CURR,3}, {MB_CURR,8}, {MB_CURR,9} } },

    { { {MB_CURR,6}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,6}, {MB_CURR,12}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,6}, {MB_CURR,7}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,6}, {MB_CURR,7}, {MB_CURR,12}, {MB_CURR,13} } } };

static const neighbour_t N_C_SUB_PART[4][4][4] = {
    { { {MB_B,14}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,14}, {MB_NA,4}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,11}, {MB_B,14}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,11}, {MB_B,14}, {MB_CURR,1}, {MB_NA,4} } },

    { { {MB_C,10}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_C,10}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,15}, {MB_C,10}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,15}, {MB_C,10}, {MB_CURR,5}, {MB_NA,0} } },

    { { {MB_CURR,6}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,6}, {MB_NA,12}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,3}, {MB_CURR,6}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,3}, {MB_CURR,6}, {MB_CURR,9}, {MB_NA,12} } },

    { { {MB_NA,2}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_NA,2}, {MB_NA,8}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,7}, {MB_NA,2}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,7}, {MB_NA,2}, {MB_CURR,13}, {MB_NA,8} } } };

static const neighbour_t N_D_SUB_PART[4][4][4] = {
    { { {MB_D,15}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_D,15}, {MB_A,5}, {MB_NA,0}, {MB_NA,0} },
      { {MB_D,15}, {MB_B,10}, {MB_NA,0}, {MB_NA,0} },
      { {MB_D,15}, {MB_B,10}, {MB_A,5}, {MB_CURR,0} } },

    { { {MB_B,11}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,11}, {MB_CURR,1}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,11}, {MB_B,14}, {MB_NA,0}, {MB_NA,0} },
      { {MB_B,11}, {MB_B,14}, {MB_CURR,1}, {MB_CURR,4} } },

    { { {MB_A,7}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,7}, {MB_A,13}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,7}, {MB_CURR,2}, {MB_NA,0}, {MB_NA,0} },
      { {MB_A,7}, {MB_CURR,2}, {MB_A,13}, {MB_CURR,8} } },

    { { {MB_CURR,3}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,3}, {MB_CURR,9}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,3}, {MB_CURR,6}, {MB_NA,0}, {MB_NA,0} },
      { {MB_CURR,3}, {MB_CURR,6}, {MB_CURR,9}, {MB_CURR,12} } } };


#ifdef H264DEC_OMXDL

/*------------------------------------------------------------------------------

    Function: h264bsdInterPrediction

        Functional description:
          Processes one inter macroblock. Performs motion vector prediction
          and reconstructs prediction macroblock. Writes the final macroblock
          (prediction + residual) into the output image (currImage)

        Inputs:
          pMb           pointer to macroblock specific information
          pMbLayer      pointer to current macroblock data from stream
          dpb           pointer to decoded picture buffer
          mbNum         current macroblock number
          currImage     pointer to output image
          data          pointer where predicted macroblock will be stored

        Outputs:
          pMb           structure is updated with current macroblock
          currImage     current macroblock is written into image
          data          prediction is stored here

        Returns:
          HANTRO_OK     success
          HANTRO_NOK    error in motion vector prediction

------------------------------------------------------------------------------*/
u32 h264bsdInterPrediction(mbStorage_t *pMb, macroblockLayer_t *pMbLayer,
    dpbStorage_t *dpb, u32 mbNum, image_t *currImage, u8 *data)
{

/* Variables */

    u32 i;
    u32 x, y;
    u32 colAndRow;
    subMbPartMode_e subPartMode;
    image_t refImage;
    u8 fillBuff[32*21 + 15 + 32];
    u8 *pFill;
    u32 tmp;
/* Code */

    ASSERT(pMb);
    ASSERT(h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTER);
    ASSERT(pMbLayer);

    /* 16-byte alignment */
    pFill = ALIGN(fillBuff, 16);

    /* set row bits 15:0 */
    colAndRow = mbNum / currImage->width;
    /*set col to bits 31:16 */
    colAndRow += (mbNum - colAndRow * currImage->width) << 16;
    colAndRow <<= 4;

    refImage.width = currImage->width;
    refImage.height = currImage->height;

    switch (pMb->mbType)
    {
        case P_Skip:
        case P_L0_16x16:
            if (MvPrediction16x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            refImage.data = pMb->refAddr[0];
            tmp = (0<<24) + (0<<16) + (16<<8) + 16;
            h264bsdPredictSamples(data, pMb->mv, &refImage,
                                    colAndRow, tmp, pFill);
            break;

        case P_L0_L0_16x8:
            if ( MvPrediction16x8(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            refImage.data = pMb->refAddr[0];
            tmp = (0<<24) + (0<<16) + (16<<8) + 8;
            h264bsdPredictSamples(data, pMb->mv, &refImage,
                                    colAndRow, tmp, pFill);

            refImage.data = pMb->refAddr[2];
            tmp = (0<<24) + (8<<16) + (16<<8) + 8;
            h264bsdPredictSamples(data, pMb->mv+8, &refImage,
                                    colAndRow, tmp, pFill);
            break;

        case P_L0_L0_8x16:
            if ( MvPrediction8x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            refImage.data = pMb->refAddr[0];
            tmp = (0<<24) + (0<<16) + (8<<8) + 16;
            h264bsdPredictSamples(data, pMb->mv, &refImage,
                                    colAndRow, tmp, pFill);
            refImage.data = pMb->refAddr[1];
            tmp = (8<<24) + (0<<16) + (8<<8) + 16;
            h264bsdPredictSamples(data, pMb->mv+4, &refImage,
                                    colAndRow, tmp, pFill);
            break;

        default: /* P_8x8 and P_8x8ref0 */
            if ( MvPrediction8x8(pMb, &pMbLayer->subMbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            for (i = 0; i < 4; i++)
            {
                refImage.data = pMb->refAddr[i];
                subPartMode =
                    h264bsdSubMbPartMode(pMbLayer->subMbPred.subMbType[i]);
                x = i & 0x1 ? 8 : 0;
                y = i < 2 ? 0 : 8;
                switch (subPartMode)
                {
                    case MB_SP_8x8:
                        tmp = (x<<24) + (y<<16) + (8<<8) + 8;
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                                                    colAndRow, tmp, pFill);
                        break;

                    case MB_SP_8x4:
                        tmp = (x<<24) + (y<<16) + (8<<8) + 4;
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                                                    colAndRow, tmp, pFill);
                        tmp = (x<<24) + ((y+4)<<16) + (8<<8) + 4;
                        h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage,
                                                    colAndRow, tmp, pFill);
                        break;

                    case MB_SP_4x8:
                        tmp = (x<<24) + (y<<16) + (4<<8) + 8;
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                                                    colAndRow, tmp, pFill);
                        tmp = ((x+4)<<24) + (y<<16) + (4<<8) + 8;
                        h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage,
                                                    colAndRow, tmp, pFill);
                        break;

                    default:
                        tmp = (x<<24) + (y<<16) + (4<<8) + 4;
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                                                    colAndRow, tmp, pFill);
                        tmp = ((x+4)<<24) + (y<<16) + (4<<8) + 4;
                        h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage,
                                                    colAndRow, tmp, pFill);
                        tmp = (x<<24) + ((y+4)<<16) + (4<<8) + 4;
                        h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage,
                                                    colAndRow, tmp, pFill);
                        tmp = ((x+4)<<24) + ((y+4)<<16) + (4<<8) + 4;
                        h264bsdPredictSamples(data, pMb->mv+4*i+3, &refImage,
                                                    colAndRow, tmp, pFill);
                        break;
                }
            }
            break;
    }

    /* if decoded flag > 1 -> mb has already been successfully decoded and
     * written to output -> do not write again */
    if (pMb->decoded > 1)
        return HANTRO_OK;

    return(HANTRO_OK);
}

#else /* H264DEC_OMXDL */

/*------------------------------------------------------------------------------

    Function: h264bsdInterPrediction

        Functional description:
          Processes one inter macroblock. Performs motion vector prediction
          and reconstructs prediction macroblock. Writes the final macroblock
          (prediction + residual) into the output image (currImage)

        Inputs:
          pMb           pointer to macroblock specific information
          pMbLayer      pointer to current macroblock data from stream
          dpb           pointer to decoded picture buffer
          mbNum         current macroblock number
          currImage     pointer to output image
          data          pointer where predicted macroblock will be stored

        Outputs:
          pMb           structure is updated with current macroblock
          currImage     current macroblock is written into image
          data          prediction is stored here

        Returns:
          HANTRO_OK     success
          HANTRO_NOK    error in motion vector prediction

------------------------------------------------------------------------------*/
u32 h264bsdInterPrediction(mbStorage_t *pMb, macroblockLayer_t *pMbLayer,
    dpbStorage_t *dpb, u32 mbNum, image_t *currImage, u8 *data)
{

/* Variables */

    u32 i;
    u32 x, y;
    u32 row, col;
    subMbPartMode_e subPartMode;
    image_t refImage;

/* Code */

    ASSERT(pMb);
    ASSERT(h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTER);
    ASSERT(pMbLayer);

    row = mbNum / currImage->width;
    col = mbNum - row * currImage->width;
    row *= 16;
    col *= 16;

    refImage.width = currImage->width;
    refImage.height = currImage->height;

    switch (pMb->mbType)
    {
        case P_Skip:
        case P_L0_16x16:
            if (MvPrediction16x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            refImage.data = pMb->refAddr[0];
            h264bsdPredictSamples(data, pMb->mv, &refImage, col, row, 0, 0,
                16, 16);
            break;

        case P_L0_L0_16x8:
            if ( MvPrediction16x8(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            refImage.data = pMb->refAddr[0];
            h264bsdPredictSamples(data, pMb->mv, &refImage, col, row, 0, 0,
                16, 8);
            refImage.data = pMb->refAddr[2];
            h264bsdPredictSamples(data, pMb->mv+8, &refImage, col, row, 0, 8,
                16, 8);
            break;

        case P_L0_L0_8x16:
            if ( MvPrediction8x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            refImage.data = pMb->refAddr[0];
            h264bsdPredictSamples(data, pMb->mv, &refImage, col, row, 0, 0,
                8, 16);
            refImage.data = pMb->refAddr[1];
            h264bsdPredictSamples(data, pMb->mv+4, &refImage, col, row, 8, 0,
                8, 16);
            break;

        default: /* P_8x8 and P_8x8ref0 */
            if ( MvPrediction8x8(pMb, &pMbLayer->subMbPred, dpb) != HANTRO_OK)
                return(HANTRO_NOK);
            for (i = 0; i < 4; i++)
            {
                refImage.data = pMb->refAddr[i];
                subPartMode =
                    h264bsdSubMbPartMode(pMbLayer->subMbPred.subMbType[i]);
                x = i & 0x1 ? 8 : 0;
                y = i < 2 ? 0 : 8;
                switch (subPartMode)
                {
                    case MB_SP_8x8:
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                            col, row, x, y, 8, 8);
                        break;

                    case MB_SP_8x4:
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                            col, row, x, y, 8, 4);
                        h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage,
                            col, row, x, y+4, 8, 4);
                        break;

                    case MB_SP_4x8:
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                            col, row, x, y, 4, 8);
                        h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage,
                            col, row, x+4, y, 4, 8);
                        break;

                    default:
                        h264bsdPredictSamples(data, pMb->mv+4*i, &refImage,
                            col, row, x, y, 4, 4);
                        h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage,
                            col, row, x+4, y, 4, 4);
                        h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage,
                            col, row, x, y+4, 4, 4);
                        h264bsdPredictSamples(data, pMb->mv+4*i+3, &refImage,
                            col, row, x+4, y+4, 4, 4);
                        break;
                }
            }
            break;
    }

    /* if decoded flag > 1 -> mb has already been successfully decoded and
     * written to output -> do not write again */
    if (pMb->decoded > 1)
        return HANTRO_OK;

    if (pMb->mbType != P_Skip)
    {
        h264bsdWriteOutputBlocks(currImage, mbNum, data,
            pMbLayer->residual.level);
    }
    else
    {
        h264bsdWriteMacroblock(currImage, data);
    }

    return(HANTRO_OK);
}
#endif /* H264DEC_OMXDL */

/*------------------------------------------------------------------------------

    Function: MvPrediction16x16

        Functional description:
            Motion vector prediction for 16x16 partition mode

------------------------------------------------------------------------------*/

u32 MvPrediction16x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
{

/* Variables */

    mv_t mv;
    mv_t mvPred;
    interNeighbour_t a[3]; /* A, B, C */
    u32 refIndex;
    u8 *tmp;
    u32 *tmpMv1, *tmpMv2;

/* Code */

    refIndex = mbPred->refIdxL0[0];

    GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 5);
    GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 10);
    /*lint --e(740)  Unusual pointer cast (incompatible indirect types) */
    tmpMv1 = (u32*)(&a[0].mv); /* we test just that both MVs are zero */
    /*lint --e(740) */
    tmpMv2 = (u32*)(&a[1].mv); /* i.e. a[0].mv.hor == 0 && a[0].mv.ver == 0 */
    if (pMb->mbType == P_Skip &&
        (!a[0].available || !a[1].available ||
         ( a[0].refIndex == 0 && ((u32)(*tmpMv1) == 0) ) ||
         ( a[1].refIndex == 0 && ((u32)(*tmpMv2) == 0) )))
    {
            mv.hor = mv.ver = 0;
    }
    else
    {
        mv = mbPred->mvdL0[0];
        GetInterNeighbour(pMb->sliceId, pMb->mbC, a+2, 10);
        if (!a[2].available)
        {
            GetInterNeighbour(pMb->sliceId, pMb->mbD, a+2, 15);
        }

        GetPredictionMv(&mvPred, a, refIndex);

        mv.hor += mvPred.hor;
        mv.ver += mvPred.ver;

        /* horizontal motion vector range [-2048, 2047.75] */
        if ((u32)(i32)(mv.hor+8192) >= (16384))
            return(HANTRO_NOK);

        /* vertical motion vector range [-512, 511.75]
         * (smaller for low levels) */
        if ((u32)(i32)(mv.ver+2048) >= (4096))
            return(HANTRO_NOK);
    }

    tmp = h264bsdGetRefPicData(dpb, refIndex);
    if (tmp == NULL)
        return(HANTRO_NOK);

    pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] =
    pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] =
    pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] =
    pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv;

    pMb->refPic[0] = refIndex;
    pMb->refPic[1] = refIndex;
    pMb->refPic[2] = refIndex;
    pMb->refPic[3] = refIndex;
    pMb->refAddr[0] = tmp;
    pMb->refAddr[1] = tmp;
    pMb->refAddr[2] = tmp;
    pMb->refAddr[3] = tmp;

    return(HANTRO_OK);

}

/*------------------------------------------------------------------------------

    Function: MvPrediction16x8

        Functional description:
            Motion vector prediction for 16x8 partition mode

------------------------------------------------------------------------------*/

u32 MvPrediction16x8(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
{

/* Variables */

    mv_t mv;
    mv_t mvPred;
    interNeighbour_t a[3]; /* A, B, C */
    u32 refIndex;
    u8 *tmp;

/* Code */

    mv = mbPred->mvdL0[0];
    refIndex = mbPred->refIdxL0[0];

    GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 10);

    if (a[1].refIndex == refIndex)
        mvPred = a[1].mv;
    else
    {
        GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 5);
        GetInterNeighbour(pMb->sliceId, pMb->mbC, a+2, 10);
        if (!a[2].available)
        {
            GetInterNeighbour(pMb->sliceId, pMb->mbD, a+2, 15);
        }

        GetPredictionMv(&mvPred, a, refIndex);

    }
    mv.hor += mvPred.hor;
    mv.ver += mvPred.ver;

    /* horizontal motion vector range [-2048, 2047.75] */
    if ((u32)(i32)(mv.hor+8192) >= (16384))
        return(HANTRO_NOK);

    /* vertical motion vector range [-512, 511.75] (smaller for low levels) */
    if ((u32)(i32)(mv.ver+2048) >= (4096))
        return(HANTRO_NOK);

    tmp = h264bsdGetRefPicData(dpb, refIndex);
    if (tmp == NULL)
        return(HANTRO_NOK);

    pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] =
    pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] = mv;
    pMb->refPic[0] = refIndex;
    pMb->refPic[1] = refIndex;
    pMb->refAddr[0] = tmp;
    pMb->refAddr[1] = tmp;

    mv = mbPred->mvdL0[1];
    refIndex = mbPred->refIdxL0[1];

    GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 13);
    if (a[0].refIndex == refIndex)
        mvPred = a[0].mv;
    else
    {
        a[1].available = HANTRO_TRUE;
        a[1].refIndex = pMb->refPic[0];
        a[1].mv = pMb->mv[0];

        /* c is not available */
        GetInterNeighbour(pMb->sliceId, pMb->mbA, a+2, 7);

        GetPredictionMv(&mvPred, a, refIndex);

    }
    mv.hor += mvPred.hor;
    mv.ver += mvPred.ver;

    /* horizontal motion vector range [-2048, 2047.75] */
    if ((u32)(i32)(mv.hor+8192) >= (16384))
        return(HANTRO_NOK);

    /* vertical motion vector range [-512, 511.75] (smaller for low levels) */
    if ((u32)(i32)(mv.ver+2048) >= (4096))
        return(HANTRO_NOK);

    tmp = h264bsdGetRefPicData(dpb, refIndex);
    if (tmp == NULL)
        return(HANTRO_NOK);

    pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] =
    pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv;
    pMb->refPic[2] = refIndex;
    pMb->refPic[3] = refIndex;
    pMb->refAddr[2] = tmp;
    pMb->refAddr[3] = tmp;

    return(HANTRO_OK);

}

/*------------------------------------------------------------------------------

    Function: MvPrediction8x16

        Functional description:
            Motion vector prediction for 8x16 partition mode

------------------------------------------------------------------------------*/

u32 MvPrediction8x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb)
{

/* Variables */

    mv_t mv;
    mv_t mvPred;
    interNeighbour_t a[3]; /* A, B, C */
    u32 refIndex;
    u8 *tmp;

/* Code */

    mv = mbPred->mvdL0[0];
    refIndex = mbPred->refIdxL0[0];

    GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 5);

    if (a[0].refIndex == refIndex)
        mvPred = a[0].mv;
    else
    {
        GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 10);
        GetInterNeighbour(pMb->sliceId, pMb->mbB, a+2, 14);
        if (!a[2].available)
        {
            GetInterNeighbour(pMb->sliceId, pMb->mbD, a+2, 15);
        }

        GetPredictionMv(&mvPred, a, refIndex);

    }
    mv.hor += mvPred.hor;
    mv.ver += mvPred.ver;

    /* horizontal motion vector range [-2048, 2047.75] */
    if ((u32)(i32)(mv.hor+8192) >= (16384))
        return(HANTRO_NOK);

    /* vertical motion vector range [-512, 511.75] (smaller for low levels) */
    if ((u32)(i32)(mv.ver+2048) >= (4096))
        return(HANTRO_NOK);

    tmp = h264bsdGetRefPicData(dpb, refIndex);
    if (tmp == NULL)
        return(HANTRO_NOK);

    pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] =
    pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] = mv;
    pMb->refPic[0] = refIndex;
    pMb->refPic[2] = refIndex;
    pMb->refAddr[0] = tmp;
    pMb->refAddr[2] = tmp;

    mv = mbPred->mvdL0[1];
    refIndex = mbPred->refIdxL0[1];

    GetInterNeighbour(pMb->sliceId, pMb->mbC, a+2, 10);
    if (!a[2].available)
    {
        GetInterNeighbour(pMb->sliceId, pMb->mbB, a+2, 11);
    }
    if (a[2].refIndex == refIndex)
        mvPred = a[2].mv;
    else
    {
        a[0].available = HANTRO_TRUE;
        a[0].refIndex = pMb->refPic[0];
        a[0].mv = pMb->mv[0];

        GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 14);

        GetPredictionMv(&mvPred, a, refIndex);

    }
    mv.hor += mvPred.hor;
    mv.ver += mvPred.ver;

    /* horizontal motion vector range [-2048, 2047.75] */
    if ((u32)(i32)(mv.hor+8192) >= (16384))
        return(HANTRO_NOK);

    /* vertical motion vector range [-512, 511.75] (smaller for low levels) */
    if ((u32)(i32)(mv.ver+2048) >= (4096))
        return(HANTRO_NOK);

    tmp = h264bsdGetRefPicData(dpb, refIndex);
    if (tmp == NULL)
        return(HANTRO_NOK);

    pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] =
    pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv;
    pMb->refPic[1] = refIndex;
    pMb->refPic[3] = refIndex;
    pMb->refAddr[1] = tmp;
    pMb->refAddr[3] = tmp;

    return(HANTRO_OK);

}

/*------------------------------------------------------------------------------

    Function: MvPrediction8x8

        Functional description:
            Motion vector prediction for 8x8 partition mode

------------------------------------------------------------------------------*/

u32 MvPrediction8x8(mbStorage_t *pMb, subMbPred_t *subMbPred, dpbStorage_t *dpb)
{

/* Variables */

    u32 i, j;
    u32 numSubMbPart;

/* Code */

    for (i = 0; i < 4; i++)
    {
        numSubMbPart = h264bsdNumSubMbPart(subMbPred->subMbType[i]);
        pMb->refPic[i] = subMbPred->refIdxL0[i];
        pMb->refAddr[i] = h264bsdGetRefPicData(dpb, subMbPred->refIdxL0[i]);
        if (pMb->refAddr[i] == NULL)
            return(HANTRO_NOK);
        for (j = 0; j < numSubMbPart; j++)
        {
            if (MvPrediction(pMb, subMbPred, i, j) != HANTRO_OK)
                return(HANTRO_NOK);
        }
    }

    return(HANTRO_OK);

}

/*------------------------------------------------------------------------------

    Function: MvPrediction

        Functional description:
            Perform motion vector prediction for sub-partition

------------------------------------------------------------------------------*/

u32 MvPrediction(mbStorage_t *pMb, subMbPred_t *subMbPred, u32 mbPartIdx,
    u32 subMbPartIdx)
{

/* Variables */

    mv_t mv, mvPred;
    u32 refIndex;
    subMbPartMode_e subMbPartMode;
    const neighbour_t *n;
    mbStorage_t *nMb;
    interNeighbour_t a[3]; /* A, B, C */

/* Code */

    mv = subMbPred->mvdL0[mbPartIdx][subMbPartIdx];
    subMbPartMode = h264bsdSubMbPartMode(subMbPred->subMbType[mbPartIdx]);
    refIndex = subMbPred->refIdxL0[mbPartIdx];

    n = N_A_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx;
    nMb = h264bsdGetNeighbourMb(pMb, n->mb);
    GetInterNeighbour(pMb->sliceId, nMb, a, n->index);

    n = N_B_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx;
    nMb = h264bsdGetNeighbourMb(pMb, n->mb);
    GetInterNeighbour(pMb->sliceId, nMb, a+1, n->index);

    n = N_C_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx;
    nMb = h264bsdGetNeighbourMb(pMb, n->mb);
    GetInterNeighbour(pMb->sliceId, nMb, a+2, n->index);

    if (!a[2].available)
    {
        n = N_D_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx;
        nMb = h264bsdGetNeighbourMb(pMb, n->mb);
        GetInterNeighbour(pMb->sliceId, nMb, a+2, n->index);
    }

    GetPredictionMv(&mvPred, a, refIndex);

    mv.hor += mvPred.hor;
    mv.ver += mvPred.ver;

    /* horizontal motion vector range [-2048, 2047.75] */
    if (((u32)(i32)(mv.hor+8192) >= (16384)))
        return(HANTRO_NOK);

    /* vertical motion vector range [-512, 511.75] (smaller for low levels) */
    if (((u32)(i32)(mv.ver+2048) >= (4096)))
        return(HANTRO_NOK);

    switch (subMbPartMode)
    {
        case MB_SP_8x8:
            pMb->mv[4*mbPartIdx] = mv;
            pMb->mv[4*mbPartIdx + 1] = mv;
            pMb->mv[4*mbPartIdx + 2] = mv;
            pMb->mv[4*mbPartIdx + 3] = mv;
            break;

        case MB_SP_8x4:
            pMb->mv[4*mbPartIdx + 2*subMbPartIdx] = mv;
            pMb->mv[4*mbPartIdx + 2*subMbPartIdx + 1] = mv;
            break;

        case MB_SP_4x8:
            pMb->mv[4*mbPartIdx + subMbPartIdx] = mv;
            pMb->mv[4*mbPartIdx + subMbPartIdx + 2] = mv;
            break;

        case MB_SP_4x4:
            pMb->mv[4*mbPartIdx + subMbPartIdx] = mv;
            break;
    }

    return(HANTRO_OK);

}

/*------------------------------------------------------------------------------

    Function: MedianFilter

        Functional description:
            Median filtering for motion vector prediction

------------------------------------------------------------------------------*/

i32 MedianFilter(i32 a, i32 b, i32 c)
{

/* Variables */

    i32 max,min,med;

/* Code */

    max = min = med = a;
    if (b > max)
    {
        max = b;
    }
    else if (b < min)
    {
        min = b;
    }
    if (c > max)
    {
        med = max;
    }
    else if (c < min)
    {
        med = min;
    }
    else
    {
        med = c;
    }

    return(med);
}

/*------------------------------------------------------------------------------

    Function: GetInterNeighbour

        Functional description:
            Get availability, reference index and motion vector of a neighbour

------------------------------------------------------------------------------*/

void GetInterNeighbour(u32 sliceId, mbStorage_t *nMb,
    interNeighbour_t *n, u32 index)
{

    n->available = HANTRO_FALSE;
    n->refIndex = 0xFFFFFFFF;
    n->mv.hor = n->mv.ver = 0;

    if (nMb && (sliceId == nMb->sliceId))
    {
        u32 tmp;
        mv_t tmpMv;

        tmp = nMb->mbType;
        n->available = HANTRO_TRUE;
        /* MbPartPredMode "inlined" */
        if (tmp <= P_8x8ref0)
        {
            tmpMv = nMb->mv[index];
            tmp = nMb->refPic[index>>2];
            n->refIndex = tmp;
            n->mv = tmpMv;
        }
    }

}

/*------------------------------------------------------------------------------

    Function: GetPredictionMv

        Functional description:
            Compute motion vector predictor based on neighbours A, B and C

------------------------------------------------------------------------------*/

void GetPredictionMv(mv_t *mv, interNeighbour_t *a, u32 refIndex)
{

    if ( a[1].available || a[2].available || !a[0].available)
    {
        u32 isA, isB, isC;
        isA = (a[0].refIndex == refIndex) ? HANTRO_TRUE : HANTRO_FALSE;
        isB = (a[1].refIndex == refIndex) ? HANTRO_TRUE : HANTRO_FALSE;
        isC = (a[2].refIndex == refIndex) ? HANTRO_TRUE : HANTRO_FALSE;

        if (((u32)isA+(u32)isB+(u32)isC) != 1)
        {
            mv->hor = (i16)MedianFilter(a[0].mv.hor, a[1].mv.hor, a[2].mv.hor);
            mv->ver = (i16)MedianFilter(a[0].mv.ver, a[1].mv.ver, a[2].mv.ver);
        }
        else if (isA)
            *mv = a[0].mv;
        else if (isB)
            *mv = a[1].mv;
        else
            *mv = a[2].mv;
    }
    else
    {
        *mv = a[0].mv;
    }

}