/* * 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; }