/*

* 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:  

* Implementation for MPEG4(H263) video transcoder. 

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

*

*/

#include "biblin.h"

#include "common.h"

#include "h263dconfig.h"

#include "decmbdct.h"

#include "vdxint.h"

/* 

 * Constants/definitions 

 */

#define DIAMOND_SEARCH_NUMBER 2

const tVLCTable sCBPCIType[9] = 

{

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

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

        {0x01,0x09}

};

const tVLCTable sCBPCPType[21] = 

{

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

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

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

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

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

    {0x01,0x09}

};

const tVLCTable sCBPY[16] = 

{

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

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

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

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

};

const unsigned int sDquant[5] = 

{

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

};

const tVLCTable sMVTab[33] =

{

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

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

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

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

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

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

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

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

        {0x04,0x0d}

}; 

const int32  sFixedQuantScale1[32]=

{

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

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

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

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

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

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

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

        0x0492, 0x0469, 0x0444, 0x0421  

};  

const u_int16 sPrePostMult[64] = 

{ 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        0xb18a, 0xd0c3, 0xe7f7, 0xf641

};

/* 

 * Function Declarations 

 */

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

                                 int32 svh, int32 lastPos);

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

/* 

 * Function Definitions 

 */

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

/*

* vbmGetH263IMCBPC

*

* Parameters:

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

*           dQuant                   quantization parameter

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

*           cbpy                       cbpy value for the macro block

*           mcbpcVal                   computed mcbpc value for the macro block

*           length                   length of the computed mcbpc value codeword

*

* Function:

*     This function evaluates the mcpbc codeword for INTRA macro block

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

                                     int cbpy, int& mcbpcVal, int& length)

{

    int index;

    int len, mcbpc;

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

    {

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

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

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

        mcbpcVal = mcbpc;

        length = len;

    }

    else

    {

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

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

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

        mcbpcVal = mcbpc;

        length = len;

    }

}

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

/*

* vbmGetH263PMCBPC

*

* Parameters:

*           dQuant                   quantization parameter

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

*           cbpy                       cbpy value for the macro block

*           mcbpcVal                   computed mcbpc value for the macro block

*           length                   length of the computed mcbpc value codeword

*

* Function:

*     This function evaluates the mcpbc codeword for INTER macro block

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

{

    int index;

    int len, mcbpc;

    cbpy = (~cbpy) & 0xf;

    /* only ONE MV in baseline H263 */

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

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

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

    mcbpcVal = mcbpc;

    length = len;

}

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

/*

* vbmEncodeMVDifferential

*

* Parameters:

*     outBuf                     output buffer

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

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

*           fCode                      Fcode value

*

* Function:

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

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

                           bibBuffer_t * outBuf)

{

    int32   mvd[2];

    u_int32 i;

    int32   temp;

    int32   motioncode;

    int32   motionresidual;

    int32   rsize = fCode - 1;

    u_int32 f     = 1 << rsize;

    int32   high  = 32 * f - 1;

    int32   low   = -32 * (int32) f;

    int32   range = 64 *f;

    mvd[0] = mvdx;

    mvd[1] = mvdy;

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

    {

        if (mvd[i] < low)

        {

            mvd[i] += range;

        }

        else

        {

            if (mvd[i] > high)

            {

                mvd[i] -= range;

            }

        }

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

        motioncode = temp >> rsize;    

        if(mvd[i] >= 0)

        {

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

        }

        else

        {

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

        }        

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

        {

            motionresidual = temp & (f - 1);

            vlbPutBits(outBuf, rsize, motionresidual);

        }   

    }

    return;

}

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

/*

* vbmMedian3

*

* Parameters:

*     s1                         pointer to the first vector

*     s2                         pointer to the second vector

*     s3                         pointer to the third vector

*     med                        pointer to store the median vector

*

* Function:

*     This function finds the median of three vectors

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

{

    int32 temp1;

    int32 temp2;

    int32 temp3;

    temp1 = s1[0];

    temp2 = s2[0];

    temp3 = s3[0];

    if (temp1 > temp2)

    {

        temp1 += temp2;

        temp2 = temp1 - temp2;

        temp1 -= temp2;

    }

    if (temp2 > temp3)

    {

        temp2 += temp3;

        temp3 = temp2 - temp3;

        temp2 -= temp3;

    }

    if (temp1 > temp2)

    {

        temp1 += temp2;

        temp2 = temp1 - temp2;

        temp1 -= temp2;

    }

    med->mvx = (int16) temp2;

    temp1 = s1[1];

    temp2 = s2[1];

    temp3 = s3[1];

    if (temp1 > temp2)

    {

        temp1 += temp2;

        temp2 = temp1 - temp2;

        temp1 -= temp2;

    }

    if (temp2 > temp3)

    {

        temp2 += temp3;

        temp3 = temp2 - temp3;

        temp2 -= temp3;

    }

    if (temp1 > temp2)

    {

        temp1 += temp2;

        temp2 = temp1 - temp2;

        temp1 -= temp2;

    }

    med->mvy = (int16) temp2;

    return;

}

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

/*

* vbmMvPrediction

*

* Parameters:

*     mbi                  macro block info needed for processing

*     predMV               pointer to motion vector predictors

*     mbinWidth            number of MBs per row

*     mBCnt                    mecro block number

*

* Function:

*     This function performs prediction of MV based on adjacent blocks

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

{

    int16    p[3][2];

    int32    zeroFound = 0;

    int32    zeroPredictors = 0;

    if (mBCnt % mbinWidth == 0)

    {

        p[0][0] = 0;

        p[0][1] = 0;

        zeroPredictors++;

    }

    else

    {

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

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

    }

    if (mBCnt / mbinWidth == 0) 

    {

        p[1][0] = 0;

        p[1][1] = 0;

        zeroPredictors++;

        zeroFound += 1;

    }

    else

    {

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

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

    }

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

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

    {

        p[2][0] = 0;

        p[2][1] = 0;

        zeroPredictors++;

        zeroFound += 2;

    }

    else

    {

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

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

    }

    if (zeroPredictors == 3)

    {

        predMV->mvx = 0;

        predMV->mvy = 0;

    }

    else if (zeroPredictors == 2)

    {

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

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

    }

    else

    {

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

    }

    return;

}

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

/*

* vbmMBSAD

*

* Parameters:

*     refFrame             pointer to reference frame

*     currMB               pointer to current MB

*     mv                   pointer to store the SAD and having motion vector

*     mbPos                pointer to macroblock position structure

*     vopWidth             width of frame/VOP

*     yWidth               width of luminance frame 

*

* Function:

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

*     for a macroblock for integer motion vector

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

                            tMotionVector* mv, const tMBPosition* mbPos)

{

    u_int32     sad = 0;

    tPixel*     refPos;

    tPixel*     currPos;

    int32       row;

    int32       col;

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

    currPos = currMB; 

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

    {

        col = row & 0x1;

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

        {

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

        }

        refPos += vopWidth;

        currPos += yWidth;

    }

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

    return;

}

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

/*

* vbmMVOutsideBound

*

* Parameters:

*     mbPos                pointer to macroblock position structure

*     bestMV               pointer to store the best match motion vector

*     halfPixel            flag to indicate whether half pel search is needed

*

* Function:

*     This function checks whether the MV is within valid range

*

* Returns:

*     Nothing.

*

* Error codes:

*     None.

*

*/

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

{

    int32   xLeft;

    int32   xRight;

    int32   yTop;

    int32   yBottom;

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

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

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

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

    if (halfPixel)

    {