/*

* 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. Operations may include:

* 1. Bitstream Copying 

* 2. BlackAndWhite Effect

* 3. MPEG4 to VDT_RESYN (Simple profile)

* 4. H.263 -> MPEG4 (Open Loop structure, no MV refinement)

* 5. MPEG4 -> H263, partial implemented 

*

* We call functions 2~5 as transcoding functions since they involve MB level data processing

*    

* Note:

* When RVLC is used and errors occur during  forward decoding, 

* We don't do backward transcoding, the rest of the data is discarded, 

*

*/

/* 

* Includes

*/

#include "MPEG4Transcoder.h"

#include "debug.h"

/* Print macro */

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

/* 

* Defines and Typedefs

*/

typedef unsigned int         uint32;

#define EInternalAssertionFailure 1000

#define VDT_NO_DATA(a, b, c, d) ((a) == (c) && (b) == (d))

const int KDataNotValid = -1; 

const int KMpeg4VopTimeIncrementResolutionLength = 16; 

const int KOutputMpeg4TimeIncResolution = 30000;

const int KShortHeaderMpeg4VosSize = 14; 

const int KH263ToMpeg4VosSize = 28; 

/*Bit stream formating*/

#define WRITE32(op, x) sPutBits((op), 16, ((uint32)(x)) >> 16);       \

sPutBits((op), 16, (x) & 0x0000ffff)

/* 

* Constants 

*/

#ifdef _DEBUG

const TUint KInitialBufferSize = 200000; /* MPEG4 Simple Visual Profile (Levels 0,1,2,3) initial frame data buffer size vga support */

#endif

                                                                                /* 

                                                                                * Function Declarations 

*/

//Static Functions 

static void sStuffBitsH263(bibBuffer_t *outBuffer);

static TVedVideoBitstreamMode sGetMPEG4Mode(int error_resilience_disable, int dp, int rvlc);

static int sFindCBP(int *mbdata, int fUseIntraDCVLC);

void vdtPutInterMBCMT(bibBuffer_t *outBuffer, int coeffStart, int *coeff, int *numTextureBits, int svh);

void vdtPutIntraMBCMT(bibBuffer_t *outBuffer, int *coeff, int *numTextureBits, int index,  int skipDC, int skipAC);

void vbmEncodeMVDifferential(int32 mvdx, int32 mvdy, int32 fCode, bibBuffer_t *outBuffer);

void vbmGetH263IMCBPC(int lDQuant, int vopCodingType, int colorEffect, int cbpy, int& mcbpcVal, int& len);

void vbmGetH263PMCBPC(int lDQuant, int colorEffect, int cbpy, int& mcbpcVal, int& len);

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

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

void vbmPutInterMB(tMBPosition* mbPos, bibBuffer_t *outBuf, dmdPParam_t *paramMB, tMotionVector *initPred, 

                                     int32 noOfPredictors, u_int32 vopWidth, u_int32 vopHeight, int32 searchRange, 

                                     int32 mbNo, int32* numTextureBits, int16 colorEffect, tMBInfo *mbsinfo);

void sPutBits (bibBuffer_t *buf, int numBits, unsigned int value);  //forward decl

/* 

* Function Definitions 

*/

/*

* sStuffBitsH263

*

* Parameters: 

*    outBuffer    output buffer

*

* Function:

*    This function stuffs bits for H.263 format

* Returns:

*    None

* Error codes:

*    None.

*

*/

static void sStuffBitsH263(bibBuffer_t *outBuffer)

{

    const int stuffingBits[8][2] = { {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}, {0,0} };

    VDTASSERT(outBuffer->baseAddr);

    /* find the number of stuffing bits to insert in the output buffer */

    int bi = outBuffer->bitIndex;

    int newNumBits = stuffingBits[bi][0]; 

    int newValue = stuffingBits[bi][1]; 

    sPutBits(outBuffer, newNumBits, newValue);

    return;

}

/*

* sGetMPEG4Mode

*

* Parameters: 

*    

*

* Function:

*    This function gets the mode of the MPEG-4 bitstream

* Returns:

*    Nothing

* Error codes:

*    None.

*

*/

static TVedVideoBitstreamMode sGetMPEG4Mode(int error_resilience_disable, int dp, int rvlc)

{

    TVedVideoBitstreamMode mode = EVedVideoBitstreamModeUnknown;

    int combination = ((!error_resilience_disable) << 2) | (dp << 1) | rvlc;

    switch (combination)

    {

        case 0:

            mode = EVedVideoBitstreamModeMPEG4Regular;

            break;

        case 2:

            mode = EVedVideoBitstreamModeMPEG4DP;

            break;

        case 3:

            mode = EVedVideoBitstreamModeMPEG4DP_RVLC;

            break;

        case 4:

            mode = EVedVideoBitstreamModeMPEG4Resyn;

            break;

        case 6:

            mode = EVedVideoBitstreamModeMPEG4Resyn_DP;

            break;

        case 7:

            mode = EVedVideoBitstreamModeMPEG4Resyn_DP_RVLC;

            break;

        default:

            mode = EVedVideoBitstreamModeUnknown;

    }

    return mode;

}

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

/*

* sFindCBP

*

* Parameters: 

*    mbdata          Contains the actual MB data to be quantized

*    fUseIntraDCVLC  ON for INTRA, OFF for INTER

*

* Function:

*    This function finds the coded bit pattern of the MB 

* Returns:

*    Coded Block Pattern.

* Error codes:

*    None.

*

*/

static int sFindCBP(int *mbdata, int fUseIntraDCVLC)

{

    int coeffCnt;

    int *block;

    int blkCnt;

    int cbpFlag = 0;

    int codedBlockPattern = 0;

    for (blkCnt = 0; blkCnt < 6; blkCnt++)

    {   

        cbpFlag = 0;

        codedBlockPattern <<= 1;

        block = &mbdata[blkCnt * BLOCK_COEFF_SIZE];

        for (coeffCnt = fUseIntraDCVLC; coeffCnt < BLOCK_COEFF_SIZE;

             coeffCnt++)

             {

                 if (block[coeffCnt])

                 {

                     cbpFlag = 1;

                     codedBlockPattern |= cbpFlag;

                     break;

                 }

             }

    }

    return codedBlockPattern;

}   

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

/*

* sPutBits

*

* Parameters:

*          outBuf           output buffer

*           numBits         number of bits to output

*           value           new value

*

* Function:

*    This function puts some bits to the output buffer

* Returns:

*    Nothing.

* Error codes:

*    None.

*

*/

void sPutBits (bibBuffer_t *buf, int numBits, unsigned int value)

{

    bibEditParams_t edParam;

    edParam.curNumBits = edParam.newNumBits = numBits;

    edParam.StartByteIndex = edParam.StartBitIndex = 0; /* used for source buffer only  */

    edParam.newValue = value;                           /* use value 128, encoded as codeword "1111 1111" = 255 */

    CopyBufferEdit((bibBuffer_t*)NULL, buf, &edParam, 0); 

}

/*

* GetTimeIncPosition

*    

*

* Parameters:

*    hInstance                  instance handle

*

* Function:

*    Calculates the time increment position for the current VOP.

*

* Returns:

*    VDX error codes

*    

*/

int GetTimeIncPosition(

   bibBuffer_t *inBuffer,

   const vdxGetVopHeaderInputParam_t *inpParam,

   vdxVopHeader_t *header,

   int * ModuloByteIndex,

   int * ModuloBitIndex,

   int * ByteIndex,

   int * BitIndex,

   int *bitErrorIndication)

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

{

  /* Get VOP header */

    int ret = vdxGetVopHeader(inBuffer, inpParam, header, 

        ModuloByteIndex, ModuloBitIndex, ByteIndex, BitIndex,

        bitErrorIndication);

    return ret;

}

/*

* CopyEditVop

*    

*

* Parameters:

*    hInstance                  instance handle

*

* Function:

*    This function copies the VOP header with edited time stamps of the VOP.

*

* Returns:

*    TX error codes

*/

int CopyEditVop(vdeHInstance_t hInstance, int aNrOfBytesToSkip, bibBuffer_t * inBuffer, 

                 vdeDecodeParamters_t *aDecoderInfo)

{

    PRINT((_L("CopyEditVop() begin")));

    int StartByteIndex = 0;

    int StartBitIndex = 7;

    int16 error;

    int sncCode;

    int timeIncByteIndex, timeIncBitIndex;

    int moduloBaseByteIndex, moduloBaseBitIndex;

    int vopheaderBitLeft;

    int numBitChange = 0;

    int increaseBytes = 0;

    int stuffingLength = 0;

    tMPEG4TimeParameter * timeStamp = aDecoderInfo->aMPEG4TimeStamp;

    MPEG4TimeParameter CurNewTimeCode;

    int outTirDecreased = 0;

    int outputTimeResolution = *aDecoderInfo->aMPEG4TargetTimeResolution;

    int numOutputTrBits;

    for (numOutputTrBits = 1; ((outputTimeResolution-1) >> numOutputTrBits) != 0; numOutputTrBits++)

        {

        }

    int num_bits;

    vdxGetVopHeaderInputParam_t inpParam;

    vdxVopHeader_t vopheader;

    int bitErrorIndication;

    vdeInstance_t * vdeTemp = (vdeInstance_t *)hInstance;

    bibBuffer_t *outBuffer = vdeTemp->outBuffer;

    bibBufferEdit_t * bufEdit = vdeTemp->bufEdit;

    int FrameSizeInByte = outBuffer->numBytesRead;

    bibRewindBits(bibNumberOfFlushedBits(inBuffer),inBuffer,&error);

    bibRewindBits(bibNumberOfFlushedBits(outBuffer),outBuffer,&error);

    if ( aNrOfBytesToSkip > 0 )

        {

        // VOS header is already in the beginning of the output buffer

        bibForwardBits(aNrOfBytesToSkip<<3, outBuffer);

        // need to also skip the VOS header from input

        }

    bufEdit->copyMode = CopyWhole; /* CopyWhole - default */

    /* record position */

    StartByteIndex = inBuffer->numBytesRead;

    StartBitIndex = inBuffer->bitIndex;

    /* get time increment resolution */

    vdcInstance_t * vdcTemp = (vdcInstance_t *)(vdeTemp->vdcHInstance);

    int currentTimeIncResolution = vdcTemp->pictureParam.time_increment_resolution > 0? vdcTemp->pictureParam.time_increment_resolution : outputTimeResolution;

    inpParam.time_increment_resolution = currentTimeIncResolution;

    /* find the next vop start code */

    do 

    {

        sncCode = sncSeekMPEGStartCode(inBuffer, vdcTemp->pictureParam.fcode_forward, vdcTemp->pictureParam.error_res_disable, 0, &error);

        bibForwardBits(32,inBuffer); // one start code is found, move on  

        if(inBuffer->bitsLeft <= 0) 

        {

            return TX_ERR;  // did not find any sync code --- vop is corrupted

        }

    }

    while (sncCode != SNC_VOP);

    bibRewindBits(32,inBuffer, &error);  // go back 

    // if we have VOS header in the input, we are now just after it. If aNrOfBytesToSkip > 0, we should not copy it

    // however, aNrOfBytesToSkip refers to output buffer, so we should not use it when skipping the input

    if ( aNrOfBytesToSkip > 0 )

        {

        StartByteIndex = inBuffer->numBytesRead;

        StartBitIndex = inBuffer->bitIndex;

        }

    /* read vop header */

    GetTimeIncPosition(inBuffer, &inpParam, &vopheader, 

        &moduloBaseByteIndex, &moduloBaseBitIndex, &timeIncByteIndex, 

        &timeIncBitIndex, &bitErrorIndication);

    /* record the header end; */

    vopheaderBitLeft = inBuffer->bitsLeft;

    /* copy-edit the part from the begin to the end of modulo base */

    CurNewTimeCode = *timeStamp;

    if (CurNewTimeCode.modulo_time_base != vopheader.time_base_incr)

    {

        if (!bufEdit->editParams)

        {

            bufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

            if(!bufEdit->editParams)

            {

                //Memory not available 

                return TX_ERR; //indicating error;

            }

            else

            {

                bufEdit->numChanges = 1;

            }

        }

        bufEdit->copyMode = CopyWithEdit; /* CopyWithEdit */

        bufEdit->editParams->curNumBits = vopheader.time_base_incr + 1;

        bufEdit->editParams->newNumBits = CurNewTimeCode.modulo_time_base + 1;

        bufEdit->editParams->newValue = ((1 << CurNewTimeCode.modulo_time_base) - 1) << 1;

        bufEdit->editParams->StartByteIndex = moduloBaseByteIndex;

        bufEdit->editParams->StartBitIndex = moduloBaseBitIndex;

        numBitChange += bufEdit->editParams->newNumBits - bufEdit->editParams->curNumBits;

    }

    else

    {

        bufEdit->copyMode = CopyWhole; /* CopyWithEdit */

    }

    /* set the end of copy point */

    bibRewindBits((inBuffer->numBytesRead<<3)+7-inBuffer->bitIndex,inBuffer,&error);

    bibForwardBits((moduloBaseByteIndex<<3)+7-moduloBaseBitIndex+vopheader.time_base_incr+2, inBuffer);

    /* copy data */

    CopyStream(inBuffer,outBuffer,bufEdit,StartByteIndex,StartBitIndex);

    StartByteIndex=inBuffer->getIndex;

    StartBitIndex=inBuffer->bitIndex;

    bufEdit->copyMode = CopyWhole; /* CopyWhole */

    /* copy and edit until the end of Vop header */

    if (currentTimeIncResolution != outputTimeResolution /* && volheader.time_increment_resolution != 30 */

        || vopheader.time_inc != CurNewTimeCode.time_inc)

    {

        for (num_bits = 1; ((currentTimeIncResolution-1) >> num_bits) != 0; num_bits++) 

            {

            }

        /* prepare editing position */

        if (!bufEdit->editParams)

        {

            bufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

            if(!bufEdit->editParams)

            {

                //Memory not available 

                return TX_ERR; //indicating error no memory;

            }

            else

            {

                bufEdit->numChanges = 1;

            }

        }

        bufEdit->copyMode = CopyWithEdit; /* CopyWithEdit */

        bufEdit->editParams->StartByteIndex = timeIncByteIndex;

        bufEdit->editParams->StartBitIndex = timeIncBitIndex;

        bufEdit->editParams->curNumBits = num_bits;

        bufEdit->editParams->newNumBits = numOutputTrBits;

        bufEdit->editParams->newValue = vopheader.time_inc;

        /* update time increment */

        if (vopheader.time_inc != CurNewTimeCode.time_inc)

        {

            /*bufEdit->editParams->newValue = (int)(vopheader.time_inc * (float)outputTimeResolution /

            (float)currentTimeIncResolution + 0.5); //CurNewTimeCode.time_inc;

            */

            bufEdit->editParams->newValue = CurNewTimeCode.time_inc;

        }

        numBitChange += bufEdit->editParams->newNumBits - bufEdit->editParams->curNumBits;

    }

    /* set the copy end point to the end of vop header */

    bibForwardBits(inBuffer->bitsLeft - vopheaderBitLeft, inBuffer);

    /* copy data */

    CopyStream(inBuffer,outBuffer,bufEdit,StartByteIndex,StartBitIndex);

    StartByteIndex=inBuffer->getIndex;

    StartBitIndex=inBuffer->bitIndex;

    if ( vdcTemp->pictureParam.error_res_disable && (inBuffer->bitsLeft > 40) )   // 40 as below to avoid negative values below

        {

        // there are no VP headers => no need to search for VP start codes => can jump to the end.

        // 40 = 5 bytes; in the end there is a start code that has 4 bytes

        bibForwardBits( inBuffer->bitsLeft-40 ,inBuffer);

        }

    PRINT((_L("CopyEditVop() seek sync")));

    /* find the next resync marker */

    sncCode = sncSeekMPEGStartCode(inBuffer, vopheader.fcode_forward, vdcTemp->pictureParam.error_res_disable, 0, &error);

    if ( sncCode == SNC_NO_SYNC )

        {

        PRINT((_L("CopyEditVop() sync NOT found, interrupt the copying and return")));

        return TX_ERR;

        }

    PRINT((_L("CopyEditVop() sync found")));

    /* record next resync position */

    int resyncBitsLeft = inBuffer->bitsLeft;

    /* rewind stuffing bits */

    sncRewindStuffing(inBuffer, &error);        

    if (!bufEdit->editParams)

    {

        bufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

        if(!bufEdit->editParams)

        {

            //Memory not available 

            return TX_ERR; //indicating error no memory;

        }

        else

        {

            bufEdit->numChanges = 1;

        }

    }

    /* record position */

    bufEdit->editParams->StartByteIndex = inBuffer->getIndex;

    bufEdit->editParams->StartBitIndex = inBuffer->bitIndex;

    /* calculate new stuffing bits */

    bufEdit->editParams->curNumBits = inBuffer->bitsLeft - resyncBitsLeft;

    /* calculate number of bits/bytes changed */

    if (numBitChange<0)

    {

        outTirDecreased = 1;

        numBitChange = -numBitChange;

    }

    int numByteChange = numBitChange >> 3;