/*
 * Copyright (C) 2007-2008 ARM Limited
 *
 * 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.
 *
 */
/**
 * 
 * File Name:  omxVCM4P2_MCReconBlock.c
 * OpenMAX DL: v1.0.2
 * Revision:   9641
 * Date:       Thursday, February 7, 2008
 * 
 * 
 * 
 * Description:
 * MPEG4 motion compensation prediction for an 8x8 block using 
 * interpolation
 * 
 */
 
#include "omxtypes.h"
#include "armOMX.h"
#include "omxVC.h"

#include "armCOMM.h"

/**
 * Function: armVCM4P2_HalfPelVer
 *
 * Description:
 * Performs half pel motion compensation for an 8x8 block using vertical 
 * interpolation described in ISO/IEC 14496-2, subclause 7.6.2.
 *
 * Remarks:
 *
 * Parameters:
 * [in] pSrc        pointer to the block in the reference plane.
 * [in] srcStep     distance between the start of consecutive lines
 *                  in the reference plane, in bytes; must be a multiple
 *                  of 8.
 * [in] rndVal      rounding control parameter: 0 - disabled; 1 - enabled.
 * [out] pDst       pointer to the linaer 8x8 destination buffer;
 *
 */
static OMXVoid armVCM4P2_HalfPelVer(
      const OMX_U8 *pSrc,
      OMX_INT srcStep, 
      OMX_U8 *pDst,
      OMX_INT rndVal)
{
  const OMX_U8 *pTempSrc1;
  const OMX_U8 *pTempSrc2;
  OMX_INT y, x;
  
  pTempSrc1 = pSrc;  
  pTempSrc2 = pSrc + srcStep;
  srcStep -= 8;
  for (y = 0; y < 8; y++)
  {
    for (x = 0; x < 8; x++)
    {
      *pDst++ = ((*pTempSrc1++ + *pTempSrc2++) + 1 - rndVal) >> 1;
    }
    pTempSrc1 += srcStep;
    pTempSrc2 += srcStep;
  }
}

/**
 * Function: armVCM4P2_HalfPelHor
 *
 * Description:
 * Performs half pel motion compensation for an 8x8 block using horizontal 
 * interpolation described in ISO/IEC 14496-2, subclause 7.6.2.
 *
 * Remarks:
 *
 * Parameters:
 * [in] pSrc        pointer to the block in the reference plane.
 * [in] srcStep     distance between the start of consecutive lines
 *                  in the reference plane, in bytes; must be a multiple
 *                  of 8.
 * [in] rndVal      rounding control parameter: 0 - disabled; 1 - enabled.
 * [out] pDst       pointer to the linaer 8x8 destination buffer;
 *
 */
static OMXVoid armVCM4P2_HalfPelHor(
      const OMX_U8 *pSrc,
      OMX_INT srcStep, 
      OMX_U8 *pDst,
      OMX_INT rndVal)
{
  const OMX_U8 *pTempSrc1;
  const OMX_U8 *pTempSrc2;
  OMX_INT y, x;
  
  pTempSrc1 = pSrc;
  pTempSrc2 = pTempSrc1 + 1;

  srcStep -= 8;
  for (y=0; y<8; y++)
  {
    for (x=0; x<8; x++)
    {
      *pDst++ = ((*pTempSrc1++ + *pTempSrc2++) + 1 - rndVal) >> 1;
    }
    pTempSrc1 += srcStep;
    pTempSrc2 += srcStep;
  }
}


/**
 * Function: armVCM4P2_HalfPelVerHor
 *
 * Description:
 * Performs half pel motion compensation for an 8x8 block using both 
 * horizontal and vertical interpolation described in ISO/IEC 14496-2,
 * subclause 7.6.2.
 *
 * Remarks:
 *
 * Parameters:
 * [in] pSrc        pointer to the block in the reference plane.
 * [in] srcStep     distance between the start of consecutive lines
 *                  in the reference plane, in bytes; must be a multiple
 *                  of 8.
 * [in] rndVal      rounding control parameter: 0 - disabled; 1 - enabled.
 * [out] pDst       pointer to the linaer 8x8 destination buffer;
 *
 */
static OMXVoid armVCM4P2_HalfPelVerHor(
      const OMX_U8 *pSrc,
      OMX_INT srcStep, 
      OMX_U8 *pDst,
      OMX_INT rndVal)
{
  const OMX_U8 *pTempSrc1;
  const OMX_U8 *pTempSrc2;
  const OMX_U8 *pTempSrc3;
  const OMX_U8 *pTempSrc4;
  OMX_INT y, x;

  pTempSrc1 = pSrc;
  pTempSrc2 = pSrc + srcStep;
  pTempSrc3 = pSrc + 1;
  pTempSrc4 = pSrc + srcStep + 1;

  srcStep -= 8;
  for (y=0; y<8; y++)
  {
    for (x=0; x<8; x++)
	{
	  *pDst++ = ((*pTempSrc1++ + *pTempSrc2++ + *pTempSrc3++ + *pTempSrc4++) + 
	                  2 - rndVal) >> 2;
	}
    pTempSrc1 += srcStep;
    pTempSrc2 += srcStep;
    pTempSrc3 += srcStep;
    pTempSrc4 += srcStep;
  }
}

/**
 * Function: armVCM4P2_MCReconBlock_NoRes
 *
 * Description:
 * Do motion compensation and copy the result to the current block.
 *
 * Remarks:
 *
 * Parameters:
 * [in] pSrc        pointer to the block in the reference plane.
 * [in] srcStep     distance between the start of consecutive lines
 *                  in the reference plane, in bytes; must be a multiple
 *                  of 8.
 * [in] dstStep     distance between the start of consecutive lines in the
 *                  destination plane, in bytes; must be a multiple of 8.
 * [in] predictType bilinear interpolation type, as defined in section 6.2.1.2.
 * [in] rndVal      rounding control parameter: 0 - disabled; 1 - enabled.
 * [out] pDst       pointer to the destination buffer; must be 8-byte aligned.
 *                  If prediction residuals are added then output intensities
 *                  are clipped to the range [0,255].
 *
 */
static OMXVoid armVCM4P2_MCReconBlock_NoRes(
      const OMX_U8 *pSrc, 
      OMX_INT srcStep,
      OMX_U8 *pDst,
      OMX_INT dstStep)
{
    OMX_U8 x,y,count,index;
    
    /* Copying the ref 8x8 blk to the curr blk */
    for (y = 0, count = 0, index = 0; y < 8; y++,index += (srcStep -8), count += (dstStep - 8))
    {
        for (x = 0; x < 8; x++, count++,index++)
        {
            pDst[count] = pSrc[index];
        }       
    }
}

/**
 * Function: armVCM4P2_MCReconBlock_Res
 *
 * Description:
 * Reconstructs INTER block by summing the motion compensation results
 * and the results of the inverse transformation (prediction residuals).
 * Output intensities are clipped to the range [0,255].
 *
 * Remarks:
 *
 * Parameters:
 * [in] pSrc        pointer to the block in the reference plane.
 * [in] pSrcResidue pointer to a buffer containing the 16-bit prediction
 *                  residuals. If the pointer is NULL,then no prediction
 *                  is done, only motion compensation, i.e., the block is
 *                  moved with interpolation.
 * [in] dstStep     distance between the start of consecutive lines in the
 *                  destination plane, in bytes; must be a multiple of 8.
 * [out] pDst       pointer to the destination buffer; must be 8-byte aligned.
 *                  If prediction residuals are added then output intensities
 *                  are clipped to the range [0,255].
 *
 */
static OMXVoid armVCM4P2_MCReconBlock_Res(
      const OMX_U8 *pSrc, 
      const OMX_S16 *pSrcResidue,
      OMX_U8 *pDst,
      OMX_INT dstStep)
{
      
  OMX_U8 x,y;
  OMX_INT temp;
  
  for(y = 0; y < 8; y++)
  {
    for(x = 0; x < 8; x++)
    {
      temp = pSrc[x] + pSrcResidue[x];         
      pDst[x] = armClip(0,255,temp);
    }
    pDst += dstStep;
    pSrc += 8;
    pSrcResidue += 8;
  }
}

/**
 * Function:  omxVCM4P2_MCReconBlock   (6.2.5.5.1)
 *
 * Description:
 * Performs motion compensation prediction for an 8x8 block using 
 * interpolation described in [ISO14496-2], subclause 7.6.2. 
 *
 * Input Arguments:
 *   
 *   pSrc - pointer to the block in the reference plane. 
 *   srcStep - distance between the start of consecutive lines in the 
 *            reference plane, in bytes; must be a multiple of 8. 
 *   dstStep - distance between the start of consecutive lines in the 
 *            destination plane, in bytes; must be a multiple of 8. 
 *   pSrcResidue - pointer to a buffer containing the 16-bit prediction 
 *            residuals; must be 16-byte aligned. If the pointer is NULL, then 
 *            no prediction is done, only motion compensation, i.e., the block 
 *            is moved with interpolation. 
 *   predictType - bilinear interpolation type, as defined in section 
 *            6.2.1.2. 
 *   rndVal - rounding control parameter: 0 - disabled; 1 - enabled. 
 *
 * Output Arguments:
 *   
 *   pDst - pointer to the destination buffer; must be 8-byte aligned.  If 
 *            prediction residuals are added then output intensities are 
 *            clipped to the range [0,255]. 
 *
 * Return Value:
 *    
 *    OMX_Sts_NoErr - no error 
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following 
 *              conditions: 
 *    -    pDst is not 8-byte aligned. 
 *    -    pSrcResidue is not 16-byte aligned. 
 *    -    one or more of the following pointers is NULL: pSrc or pDst. 
 *    -    either srcStep or dstStep is not a multiple of 8. 
 *    -    invalid type specified for the parameter predictType. 
 *    -    the parameter rndVal is not equal either to 0 or 1. 
 *
 */
OMXResult omxVCM4P2_MCReconBlock(
		const OMX_U8 *pSrc,
		OMX_INT srcStep,
		const OMX_S16 *pSrcResidue,
		OMX_U8 *pDst, 
		OMX_INT dstStep,
		OMX_INT predictType,
		OMX_INT rndVal)
{
    /* Definitions and Initializations*/
    OMX_U8 pTempDst[64];
    
    /* Argument error checks */
    armRetArgErrIf(pSrc == NULL, OMX_Sts_BadArgErr);
    armRetArgErrIf(pDst == NULL, OMX_Sts_BadArgErr);
    armRetArgErrIf(!armIs8ByteAligned(pDst), OMX_Sts_BadArgErr);
    armRetArgErrIf(!armIs16ByteAligned(pSrcResidue), OMX_Sts_BadArgErr);
    armRetArgErrIf(((dstStep % 8) || (srcStep % 8)), OMX_Sts_BadArgErr);
    armRetArgErrIf(((predictType != OMX_VC_INTEGER_PIXEL) &&
                    (predictType != OMX_VC_HALF_PIXEL_X) &&
                    (predictType != OMX_VC_HALF_PIXEL_Y) &&
                    (predictType != OMX_VC_HALF_PIXEL_XY)
                   ),OMX_Sts_BadArgErr); 
    armRetArgErrIf(((rndVal != 0) && (rndVal != 1)),OMX_Sts_BadArgErr);
    
    switch(predictType)
    {
        case OMX_VC_INTEGER_PIXEL:
                                   armVCM4P2_MCReconBlock_NoRes(pSrc,
                                                                    srcStep,
                                                                    &(pTempDst[0]),
                                                                    8);
                                   break;
        case OMX_VC_HALF_PIXEL_X:
                                   armVCM4P2_HalfPelHor(pSrc,
                                                            srcStep,
                                                            &(pTempDst[0]),
                                                            rndVal);
                                   break;
        case OMX_VC_HALF_PIXEL_Y:
                                   armVCM4P2_HalfPelVer(pSrc,
                                                            srcStep,
                                                            &(pTempDst[0]),
                                                            rndVal);
                                   break;
        case OMX_VC_HALF_PIXEL_XY:
                                   armVCM4P2_HalfPelVerHor(pSrc,
                                                            srcStep,
                                                            &(pTempDst[0]),
                                                            rndVal);
                                   break;
    }
    
    if(pSrcResidue == NULL)
    {
      armVCM4P2_MCReconBlock_NoRes(&(pTempDst[0]),
                                         8,
                                         pDst,
                                         dstStep);    
    }
    else
    {
      armVCM4P2_MCReconBlock_Res(&(pTempDst[0]),
                                          pSrcResidue,
                                          pDst,
                                          dstStep);    
    }
    
    return OMX_Sts_NoErr;
}