/*

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

*

*/

#include "globals.h"

#include "bitbuffer.h"

#include "macroblock.h"

#include "motcomp.h"

#include "framebuffer.h"

#include "vld.h"

#include "parameterset.h"

#ifdef USE_CLIPBUF

#include "clipbuf.h"

#endif

/*

 * Static functions

 */

static int getMacroblock(macroblock_s *mb, int numRefFrames,

                         int8 *ipTab, int8 **numCoefUpPred, int diffVecs[][2],

                         int picType, int chromaQpIdx, bitbuffer_s *bitbuf);

static int getMbAvailability(macroblock_s *mb, mbAttributes_s *mbData,

                             int picWidth, int constrainedIntra);

#ifdef USE_CLIPBUF

const u_int8 *mcpGetClip8Buf()

{

  return clip8Buf;

}

#endif

/*

 *

 * getMacroblock:

 *

 * Parameters:

 *      mb                    Macroblock parameters

 *      multRef               1 -> multiple reference frames used

 *      ipTab                 Macroblock intra pred. modes

 *      numCoefUpPred         Block coefficient counts of upper MBs

 *      diffVecs              Macroblock delta motion vectors

 *      picType               Picture type (intra/inter)

 *      chromaQpIdx           Chroma QP index relative to luma QP

 *      bitbuf                Bitbuffer handle

 *

 * Function:

 *      Get macroblock parameters from bitbuffer

 *      

 * Returns:

 *      MBK_OK for no error, MBK_ERROR for error

 *

 */

static int getMacroblock(macroblock_s *mb, int numRefFrames,

                         int8 *ipTab, int8 **numCoefUpPred, int diffVecs[][2],

                         int picType, int chromaQpIdx, bitbuffer_s *bitbuf)

{

  vldMBtype_s hdr;

  int numVecs;

  int delta_qp;

  int i;

  int8 *numCoefPtrY, *numCoefPtrU, *numCoefPtrV;

  int retCode;

  numCoefPtrY = &numCoefUpPred[0][mb->blkX];

  numCoefPtrU = &numCoefUpPred[1][mb->blkX>>1];

  numCoefPtrV = &numCoefUpPred[2][mb->blkX>>1];

  /*

   * Get Macroblock type

   */

  /* Check if we have to fetch run indicator */

  if (IS_SLICE_P(picType) && mb->numSkipped < 0) {

    mb->numSkipped = vldGetRunIndicator(bitbuf);

    if (bibGetStatus(bitbuf) < 0)

      return MBK_ERROR;

  }

  if (IS_SLICE_P(picType) && mb->numSkipped > 0) {

    /* If skipped MBs, set MB to COPY */

    mb->type = MBK_INTER;

    mb->interMode = MOT_COPY;

    mb->refNum[0] = 0;

    mb->cbpY = mb->cbpChromaDC = mb->cbpC = 0;

    mb->numSkipped -= 1;

    vldGetZeroLumaCoeffs(numCoefPtrY, mb->numCoefLeftPred);

    vldGetZeroChromaCoeffs(numCoefPtrU, numCoefPtrV, mb->numCoefLeftPredC);

    return MBK_OK;

  }

  else {

    if (vldGetMBtype(bitbuf, &hdr, picType) < 0) {

      PRINT((_L("Error: illegal MB type\n")));     

      return MBK_ERROR;

    }

    mb->type        = hdr.type;

    mb->intraType   = hdr.intraType;

    mb->intraMode   = hdr.intraMode;

    mb->interMode   = hdr.interMode;

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

      mb->inter8x8modes[i] = hdr.inter8x8modes[i];

    mb->cbpY        = hdr.cbpY;

    mb->cbpChromaDC = hdr.cbpChromaDC;

    mb->cbpC        = hdr.cbpC;

    mb->numSkipped -= 1;

  }

  if (mb->type == MBK_INTRA && mb->intraType == MBK_INTRA_TYPE_PCM) {

    vldGetAllCoeffs(numCoefPtrY, numCoefPtrU, numCoefPtrV,

                    mb->numCoefLeftPred, mb->numCoefLeftPredC);

    return MBK_OK;

  }

  /*

   * 4x4 intra prediction modes 

   */

  if (mb->type == MBK_INTRA && mb->intraType == MBK_INTRA_TYPE1) {

    if (vldGetIntraPred(bitbuf, ipTab) < 0) {

      PRINT((_L("Error: illegal intra pred\n")));     

      return MBK_ERROR;

    }

  }

  /*

   * 8x8 chroma intra prediction mode

   */

  if (mb->type == MBK_INTRA) {

    mb->intraModeChroma = vldGetChromaIntraPred(bitbuf);

    if (mb->intraModeChroma < 0) {

      PRINT((_L("Error: illegal chroma intra pred\n")));     

      return MBK_ERROR;

    }

  }

  /*

   * Reference frame number and motion vectors

   */

  if (mb->type == MBK_INTER) {

    numVecs = mcpGetNumMotVecs(mb->interMode, mb->inter8x8modes);

    mb->numMotVecs = numVecs;

    retCode = vldGetMotVecs(bitbuf, mb->interMode, numRefFrames,

                            mb->refNum, diffVecs, numVecs);

    if (retCode < 0) {

      PRINT((_L("Error: illegal motion vectors\n")));     

      return MBK_ERROR;

    }

  }

  /*

   * Coded block pattern

   */

  if (!(mb->type == MBK_INTRA && mb->intraType == MBK_INTRA_TYPE2)) {

    retCode = vldGetCBP(bitbuf, mb->type, &mb->cbpY, &mb->cbpChromaDC, &mb->cbpC);

    if (retCode < 0) {

      PRINT((_L("Error: illegal CBP\n")));     

      return MBK_ERROR;

    }

  }

  /* Delta QP */

  if ((mb->type == MBK_INTRA && mb->intraType == MBK_INTRA_TYPE2) || 

      (mb->cbpY | mb->cbpChromaDC | mb->cbpC) != 0)

  {

    retCode = vldGetDeltaqp(bitbuf, &delta_qp);

    if (retCode < 0 || delta_qp < -(MAX_QP-MIN_QP+1)/2 || delta_qp >= (MAX_QP-MIN_QP+1)/2) {

      PRINT((_L("Error: illegal delta qp\n")));     

      return MBK_ERROR;

    }

    if (delta_qp != 0) {

      int qp = mb->qp + delta_qp;

      if (qp < MIN_QP)

        qp += (MAX_QP-MIN_QP+1);

      if (qp > MAX_QP)

        qp -= (MAX_QP-MIN_QP+1);

      mb->qp = qp;

      mb->qpC = qpChroma[clip(MIN_QP, MAX_QP, mb->qp + chromaQpIdx)];

    }

  }

  /*

   * Get transform coefficients

   */

  /*

   * Luma DC coefficients (if 16x16 intra)

   */

  if (mb->type == MBK_INTRA && mb->intraType == MBK_INTRA_TYPE2) {

    retCode = vldGetLumaDCcoeffs(bitbuf, mb->dcCoefY, numCoefPtrY,

                             mb->numCoefLeftPred, mb->mbAvailBits);

    if (retCode < 0) {

      PRINT((_L("Error: illegal luma DC coefficient\n")));     

      return MBK_ERROR;

    }

  }

  /*

   * Luma AC coefficients

   */

  if (mb->cbpY != 0) {

    retCode = vldGetLumaCoeffs(bitbuf, mb->type, mb->intraType, &mb->cbpY,

                               mb->coefY, numCoefPtrY, mb->numCoefLeftPred,

                               mb->mbAvailBits);

    if (retCode < 0) {

      PRINT((_L("Error: illegal luma AC coefficient\n")));     

      return MBK_ERROR;

    } 

  }

  else

    vldGetZeroLumaCoeffs(numCoefPtrY, mb->numCoefLeftPred);

  /*

   * Chroma DC coefficients

   */

  if (mb->cbpChromaDC != 0) {

    retCode = vldGetChromaDCcoeffs(bitbuf, mb->dcCoefC, &mb->cbpChromaDC);

    if (retCode < 0) {

      PRINT((_L("Error: illegal chroma DC coefficient\n")));     

      return MBK_ERROR;

    }

  }

  /*

   * Chroma AC coefficients

   */

  if (mb->cbpC != 0) {

    retCode = vldGetChromaCoeffs(bitbuf, mb->coefC, &mb->cbpC, numCoefPtrU, numCoefPtrV,

                             mb->numCoefLeftPredC[0], mb->numCoefLeftPredC[1], mb->mbAvailBits);

    if (retCode < 0) {

      PRINT((_L("Error: illegal chroma AC coefficient\n")));     

      return MBK_ERROR;

    }

  }

  else {

    vldGetZeroChromaCoeffs(numCoefPtrU, numCoefPtrV, mb->numCoefLeftPredC);

  }

  return MBK_OK;

}

/*

 *

 * mbkSetInitialQP:

 *

 * Parameters:

 *      mb                    Macroblock object

 *      qp                    Quantization parameter

 *      chromaQpIdx           Chroma QP index relative to luma QP

 *

 * Function:

 *      Set macroblock qp.

 *      

 * Returns:

 *      -

 *

 */

void mbkSetInitialQP(macroblock_s *mb, int qp, int chromaQpIdx)

{

  mb->qp  = qp;

  mb->qpC = qpChroma[clip(MIN_QP, MAX_QP, qp + chromaQpIdx)];

  mb->numSkipped = -1;

}

/*

 *

 * getMbAvailability:

 *

 * Parameters:

 *      mb                    Macroblock object

 *      mbData                Buffers for for macroblock attributes

 *      picWidth              Picture width

 *      constrainedIntra      Constrained intra prediction flag

 *

 * Function:

 *      Get neighboring macroblock availability info

 *      

 * Returns:

 *      Macroblock availability bits:

 *        bit 0 : left macroblock

 *        bit 1 : upper macroblock

 *        bit 2 : upper-right macroblock

 *        bit 3 : upper-left macroblock

 *        bit 4 : left macroblock (intra)

 *        bit 5 : upper macroblock (intra)

 *        bit 6 : upper-right macroblock (intra)

 *        bit 7 : upper-left macroblock (intra)

 */

static int getMbAvailability(macroblock_s *mb, mbAttributes_s *mbData,

                             int picWidth, int constrainedIntra)

{

  int mbsPerLine;

  int mbAddr;

  int currSliceIdx;

  int *sliceMap;

  int8 *mbTypeTable;

  int mbAvailBits;

  mbsPerLine = picWidth/MBK_SIZE;

  mbAddr = mb->idxY*mbsPerLine+mb->idxX;

  sliceMap = & mbData->sliceMap[mbAddr];

  currSliceIdx = sliceMap[0];

  mbAvailBits = 0;

  /* Check availability of left macroblock */

  if (mb->idxX > 0 && sliceMap[-1] == currSliceIdx)

    mbAvailBits |= 0x11;

  /* Check availability of upper, upper-left and upper-right macroblocks */

  if (mb->idxY > 0) {

    sliceMap -= mbsPerLine;

    /* Check availability of upper macroblock */

    if (sliceMap[0] == currSliceIdx)

      mbAvailBits |= 0x22;

    /* Check availability of upper-right macroblock */

    if (mb->idxX+1 < mbsPerLine && sliceMap[1] == currSliceIdx)

      mbAvailBits |= 0x44;

    /* Check availability of upper-left macroblock */

    if (mb->idxX > 0 && sliceMap[-1] == currSliceIdx)

      mbAvailBits |= 0x88;

  }

  /*

   * Check availability of intra MB if constrained intra is enabled

   */

  if (constrainedIntra) {

     mbTypeTable = & mbData->mbTypeTable[mbAddr];

    /* Check availability of left intra macroblock */

    if ((mbAvailBits & 0x10) && mbTypeTable[-1] != MBK_INTRA)

      mbAvailBits &= ~0x10;

    /* Check availability of upper, upper-left and upper-right intra macroblocks */

    if (mbAvailBits & (0x20|0x40|0x80)) {

      mbTypeTable -= mbsPerLine;

      /* Check availability of upper intra macroblock */

      if ((mbAvailBits & 0x20) && mbTypeTable[0] != MBK_INTRA)

        mbAvailBits &= ~0x20;

      /* Check availability of upper-right intra macroblock */

      if ((mbAvailBits & 0x40) && mbTypeTable[1] != MBK_INTRA)

        mbAvailBits &= ~0x40;

      /* Check availability of upper-left intra macroblock */

      if ((mbAvailBits & 0x80) && mbTypeTable[-1] != MBK_INTRA)

        mbAvailBits &= ~0x80;

    }

  }

  return mbAvailBits;

}

// mbkParse

// Parses the input macroblock. If PCM coding is used then re-aligns the byte 

// alignment if previous (slice header) modifications have broken the alignment.

TInt mbkParse(macroblock_s *mb, TInt numRefFrames, mbAttributes_s *mbData, 

			  TInt picWidth, TInt picType, TInt constIpred, TInt chromaQpIdx,

              TInt mbIdxX, TInt mbIdxY, void *streamBuf, TInt aBitOffset)

{

  	TInt8 ipTab[BLK_PER_MB*BLK_PER_MB];

  	TInt diffVecs[BLK_PER_MB*BLK_PER_MB][2];

//  	TInt hasDc;

//  	TInt pixOffset;

  	TInt constrainedIntra;

  	TInt copyMbFlag;

  	TInt mbAddr;

  	TInt pcmMbFlag;

  	TInt retCode;

  	mb->idxX = mbIdxX;

  	mb->idxY = mbIdxY;

  	mb->blkX = mbIdxX*BLK_PER_MB;

  	mb->blkY = mbIdxY*BLK_PER_MB;

  	mb->pixX = mbIdxX*MBK_SIZE;

  	mb->pixY = mbIdxY*MBK_SIZE;

  	mbAddr = mb->idxY*(picWidth/MBK_SIZE)+mb->idxX;

  	copyMbFlag = pcmMbFlag = 0;

  	constrainedIntra = constIpred && !(IS_SLICE_I(picType));

  	mb->mbAvailBits = getMbAvailability(mb, mbData, picWidth, constrainedIntra);

  	// Read macroblock bits

    retCode = getMacroblock(mb, numRefFrames, ipTab, mbData->numCoefUpPred, diffVecs,

                            picType, chromaQpIdx, (bitbuffer_s *)streamBuf);

  	if (retCode < 0)

	    return retCode;

  	// Set PCM flag 

  	if (mb->type == MBK_INTRA && mb->intraType == MBK_INTRA_TYPE_PCM)

	    pcmMbFlag = 1;

  	// Get intra/inter prediction

  	if (mb->type == MBK_INTRA) 

  	{

    	mbData->mbTypeTable[mbAddr] = MBK_INTRA;

    	if (pcmMbFlag) 

    	{

    		bitbuffer_s* tempBitBuffer = (bitbuffer_s *)streamBuf;

    		// Synchronize bitbuffer bit position to get it between 1 and 8

			syncBitBufferBitpos(tempBitBuffer);

   			// To find out how much we have to shift to reach the byte alignment again,

   			// we have to first find out the old alignment

   			// oldAlignment is the place of the bitpos before the aBitOffset, i.e. it is

   			// the amount of zero alignment bits plus one

   			TInt oldAlignmentBits = tempBitBuffer->bitpos + aBitOffset - 1;

   			TInt shiftAmount;

   			// If Bit-wise shift, i.e. aBitOffset is zero, do nothing

    		// Fix the possible bit buffer byte alignment

    		if (aBitOffset > 0)

    		{

    			// aBitOffset > 0 indicates a bitshift to the right

    			// To counter the shift to right we have to shift left by the same amount 

    			// unless shift is larger than the number of original alignment bits in 

    			// which case we have to shift more to the right 

	   			// If the computed old alignment bits value is larger than eight, 

	   			//the correct value is (computed value) % 8

	   			oldAlignmentBits = oldAlignmentBits % 8;

    			if ( oldAlignmentBits < aBitOffset )

    			{

    				// When the amount of shift is larger than the number of original alignment bits,

    				// shift right to fill up the rest of the current byte with zeros

    				shiftAmount = 8 - aBitOffset;

   					// Here we can't shift back left since there were not enough alignment bits originally, 

   					// thus we have to shift right by new bit position - tempBitBuffer->bitpos

   					// E.g. original alignment bits 2, right shift by 4 bits:

   					/////////////////////////////////////////////////////////////////

					// original             after bit shift      byte alignment reset

					// 1. byte: 2. byte:    1. byte: 2. byte:    1. byte: 2. byte: 3. byte:

					// xxxxxx00 yyyyyyyy -> xxxxxxxx xx00yyyy -> xxxxxxxx xx000000 yyyyyyyy

   					/////////////////////////////////////////////////////////////////

   					ShiftBitBufferBitsRight(tempBitBuffer, shiftAmount);

    			}

    			else

    			{

   					// In this case, the old alignment bits are more than enough 

   					// to shift back left by the aBitOffset amount

   					// E.g. original alignment bits 4, right shift by 2 bits:

   					/////////////////////////////////////////////////////////////////

					// original             after bit shift      byte alignment reset

   					// 1. byte: 2. byte:    1. byte: 2. byte:    1. byte: 2. byte:

   					// xxxx0000 yyyyyyyy -> xxxxxx00 00yyyyyy -> xxxxxx00 yyyyyyyy

   					/////////////////////////////////////////////////////////////////

   					ShiftBitBufferBitsLeft(tempBitBuffer, aBitOffset);

    			}

    		}

    		else if(aBitOffset < 0)

    		{

    			// There was a bit shift to left

    			// Change the aBitOffset sign to positive