/* * 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: omxVCM4P10_BlockMatch_Half.c * OpenMAX DL: v1.0.2 * Revision: 9641 * Date: Thursday, February 7, 2008 * * * * * Description: * Contains modules for half pel Block matching, * */ #include "omxtypes.h" #include "armOMX.h" #include "omxVC.h" #include "armVC.h" #include "armCOMM.h" /** * Function: omxVCM4P10_BlockMatch_Half (6.3.5.2.2) * * Description: * Performs a half-pel block match using results from a prior integer search. * Returns the best MV and associated cost. This function estimates the * half-pixel motion vector by interpolating the integer resolution motion * vector referenced by the input parameter pSrcDstBestMV, i.e., the initial * integer MV is generated externally. The function * omxVCM4P10_BlockMatch_Integer may be used for integer motion estimation. * * Input Arguments: * * pSrcOrgY - Pointer to the current position in original picture plane. If * iBlockWidth==4, 4-byte alignment required. If iBlockWidth==8, * 8-byte alignment required. If iBlockWidth==16, 16-byte alignment * required. * pSrcRefY - Pointer to the top-left corner of the co-located block in the * reference picture If iBlockWidth==4, 4-byte alignment * required. If iBlockWidth==8, 8-byte alignment required. If * iBlockWidth==16, 16-byte alignment required. * nSrcOrgStep - Stride of the original picture plane in terms of full * pixels; must be a multiple of iBlockWidth. * nSrcRefStep - Stride of the reference picture plane in terms of full * pixels * iBlockWidth - Width of the current block in terms of full pixels; must * be equal to either 4, 8, or 16. * iBlockHeight - Height of the current block in terms of full pixels; must * be equal to either 4, 8, or 16. * nLamda - Lamda factor, used to compute motion cost * pMVPred - Predicted MV, represented in terms of 1/4-pel units; used to * compute motion cost * pSrcDstBestMV - The best MV resulting from a prior integer search, * represented in terms of 1/4-pel units * * Output Arguments: * * pSrcDstBestMV - Best MV resulting from the half-pel search, expressed in * terms of 1/4-pel units * pBestCost - Motion cost associated with the best MV; computed as * SAD+Lamda*BitsUsedByMV * * Return Value: * OMX_Sts_NoErr, if the function runs without error. * OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs: * - any of the following pointers is NULL: pSrcOrgY, pSrcRefY, * pSrcDstBestMV, pMVPred, pBestCost * - iBlockWidth or iBlockHeight are equal to values other than 4, 8, or 16. * - Any alignment restrictions are violated * */ OMXResult omxVCM4P10_BlockMatch_Half( const OMX_U8* pSrcOrgY, OMX_S32 nSrcOrgStep, const OMX_U8* pSrcRefY, OMX_S32 nSrcRefStep, OMX_U8 iBlockWidth, OMX_U8 iBlockHeight, OMX_U32 nLamda, const OMXVCMotionVector* pMVPred, OMXVCMotionVector* pSrcDstBestMV, OMX_S32* pBestCost ) { /* Definitions and Initializations*/ OMX_INT candSAD; OMX_INT fromX, toX, fromY, toY; /* Offset to the reference at the begining of the bounding box */ const OMX_U8 *pTempSrcRefY, *pTempSrcOrgY; OMX_S16 x, y; OMXVCMotionVector diffMV, candMV, integerMV; OMX_U8 interpolY[256]; /* Argument error checks */ armRetArgErrIf((iBlockWidth == 4) && (!armIs4ByteAligned(pSrcOrgY)), OMX_Sts_BadArgErr); armRetArgErrIf((iBlockWidth == 8) && (!armIs8ByteAligned(pSrcOrgY)), OMX_Sts_BadArgErr); armRetArgErrIf((iBlockWidth == 16) && (!armIs16ByteAligned(pSrcOrgY)), OMX_Sts_BadArgErr); armRetArgErrIf((iBlockWidth == 4) && (!armIs4ByteAligned(pSrcRefY)), OMX_Sts_BadArgErr); armRetArgErrIf((iBlockWidth == 8) && (!armIs8ByteAligned(pSrcRefY)), OMX_Sts_BadArgErr); armRetArgErrIf((iBlockWidth == 16) && (!armIs16ByteAligned(pSrcRefY)), OMX_Sts_BadArgErr); armRetArgErrIf((nSrcOrgStep % iBlockWidth), OMX_Sts_BadArgErr); armRetArgErrIf(pSrcOrgY == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pSrcRefY == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pMVPred == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pSrcDstBestMV == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pBestCost == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(((iBlockWidth!=4)&&(iBlockWidth!=8)&&(iBlockWidth!=16)) , OMX_Sts_BadArgErr); armRetArgErrIf(((iBlockHeight!=4)&&(iBlockHeight!=8)&&(iBlockHeight!=16)) , OMX_Sts_BadArgErr); /* Check for valid region */ fromX = 1; toX = 1; fromY = 1; toY = 1; /* Initialize to max value as a start point */ *pBestCost = 0x7fffffff; integerMV.dx = pSrcDstBestMV->dx; integerMV.dy = pSrcDstBestMV->dy; /* Looping on y- axis */ for (y = -fromY; y <= toY; y++) { /* Looping on x- axis */ for (x = -fromX; x <= toX; x++) { /* Positioning the pointer */ pTempSrcRefY = pSrcRefY + (nSrcRefStep * (integerMV.dy/4)) + (integerMV.dx/4); if (x < 0) { pTempSrcRefY = pTempSrcRefY + x; } if (y < 0) { pTempSrcRefY = pTempSrcRefY + (y * nSrcRefStep); } pTempSrcOrgY = pSrcOrgY; /* Prepare cand MV */ candMV.dx = integerMV.dx + x * 2; candMV.dy = integerMV.dy + y * 2; /* Interpolate half pel for the current position*/ armVCM4P10_Interpolate_Luma( pTempSrcRefY, nSrcRefStep, interpolY, iBlockWidth, iBlockWidth, iBlockHeight, armAbs(x) * 2, armAbs(y) * 2); /* Calculate the SAD */ armVCCOMM_SAD( pTempSrcOrgY, nSrcOrgStep, interpolY, iBlockWidth, &candSAD, iBlockHeight, iBlockWidth); diffMV.dx = candMV.dx - pMVPred->dx; diffMV.dy = candMV.dy - pMVPred->dy; /* Result calculations */ armVCM4P10_CompareMotionCostToMV ( candMV.dx, candMV.dy, diffMV, candSAD, pSrcDstBestMV, nLamda, pBestCost); } /* End of x- axis */ } /* End of y-axis */ return OMX_Sts_NoErr; } /* End of file */