/* * 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_MotionEstimationMB.c * OpenMAX DL: v1.0.2 * Revision: 9641 * Date: Thursday, February 7, 2008 * * * * * Description: * Contains module for motion search 16x16 macroblock * */ #include "omxtypes.h" #include "armOMX.h" #include "omxVC.h" #include "armVC.h" #include "armCOMM.h" /** * Function: armVCM4P2_BlockMatch_16x16 * * Description: * 16x16 block match wrapper function, calls omxVCM4P2_BlockMatch_Integer_16x16. * If half pel search is enabled it also calls omxVCM4P2_BlockMatch_Half_16x16 * * Remarks: * * Parameters: * [in] pSrcRefBuf pointer to the reference Y plane; points to the reference MB that * corresponds to the location of the current macroblock in the current * plane. * [in] srcRefStep width of the reference plane * [in] pRefRect pointer to the valid rectangular in reference plane. Relative to image origin. * It's not limited to the image boundary, but depended on the padding. For example, * if you pad 4 pixels outside the image border, then the value for left border * can be -4 * [in] pSrcCurrBuf pointer to the current macroblock extracted from original plane (linear array, * 256 entries); must be aligned on an 16-byte boundary. * [in] pCurrPointPos position of the current macroblock in the current plane * [in] pSrcPreMV pointer to predicted motion vector; NULL indicates no predicted MV * [in] pSrcPreSAD pointer to SAD associated with the predicted MV (referenced by pSrcPreMV); may be set to NULL if unavailable. * [in] pMESpec vendor-specific motion estimation specification structure; must have been allocated * and then initialized using omxVCM4P2_MEInit prior to calling the block matching * function. * [out] pDstMV pointer to estimated MV * [out] pDstSAD pointer to minimum SAD * * * Return Value: * OMX_Sts_NoErr - no error * OMX_Sts_BadArgErr - bad arguments * */ static OMXResult armVCM4P2_BlockMatch_16x16( const OMX_U8 *pSrcRefBuf, const OMX_INT srcRefStep, const OMXRect *pRefRect, const OMX_U8 *pSrcCurrBuf, const OMXVCM4P2Coordinate *pCurrPointPos, OMXVCMotionVector *pSrcPreMV, OMX_INT *pSrcPreSAD, void *pMESpec, OMXVCMotionVector *pDstMV, OMX_INT *pDstSAD ) { OMXVCM4P2MEParams *pMEParams = (OMXVCM4P2MEParams *)pMESpec; OMX_INT rndVal; rndVal = pMEParams->rndVal; omxVCM4P2_BlockMatch_Integer_16x16( pSrcRefBuf, srcRefStep, pRefRect, pSrcCurrBuf, pCurrPointPos, pSrcPreMV, pSrcPreSAD, pMEParams, pDstMV, pDstSAD); if (pMEParams->halfPelSearchEnable) { omxVCM4P2_BlockMatch_Half_16x16( pSrcRefBuf, srcRefStep, pRefRect, pSrcCurrBuf, pCurrPointPos, rndVal, pDstMV, pDstSAD); } return OMX_Sts_NoErr; } /** * Function: armVCM4P2_BlockMatch_8x8 * * Description: * 8x8 block match wrapper function, calls omxVCM4P2_BlockMatch_Integer_8x8. * If half pel search is enabled it also calls omxVCM4P2_BlockMatch_Half_8x8 * * Remarks: * * Parameters: * [in] pSrcRefBuf pointer to the reference Y plane; points to the reference MB that * corresponds to the location of the current macroblock in the current * plane. * [in] srcRefStep width of the reference plane * [in] pRefRect pointer to the valid rectangular in reference plane. Relative to image origin. * It's not limited to the image boundary, but depended on the padding. For example, * if you pad 4 pixels outside the image border, then the value for left border * can be -4 * [in] pSrcCurrBuf pointer to the current macroblock extracted from original plane (linear array, * 256 entries); must be aligned on an 16-byte boundary. * [in] pCurrPointPos position of the current macroblock in the current plane * [in] pSrcPreMV pointer to predicted motion vector; NULL indicates no predicted MV * [in] pSrcPreSAD pointer to SAD associated with the predicted MV (referenced by pSrcPreMV); may be set to NULL if unavailable. * [in] pMESpec vendor-specific motion estimation specification structure; must have been allocated * and then initialized using omxVCM4P2_MEInit prior to calling the block matching * function. * [out] pDstMV pointer to estimated MV * [out] pDstSAD pointer to minimum SAD * * * Return Value: * OMX_Sts_NoErr - no error * OMX_Sts_BadArgErr - bad arguments * */ static OMXResult armVCM4P2_BlockMatch_8x8( const OMX_U8 *pSrcRefBuf, OMX_INT srcRefStep, const OMXRect *pRefRect, const OMX_U8 *pSrcCurrBuf, const OMXVCM4P2Coordinate *pCurrPointPos, OMXVCMotionVector *pSrcPreMV, OMX_INT *pSrcPreSAD, void *pMESpec, OMXVCMotionVector *pSrcDstMV, OMX_INT *pDstSAD ) { OMXVCM4P2MEParams *pMEParams = (OMXVCM4P2MEParams *)pMESpec; OMX_INT rndVal; rndVal = pMEParams->rndVal; omxVCM4P2_BlockMatch_Integer_8x8( pSrcRefBuf, srcRefStep, pRefRect, pSrcCurrBuf, pCurrPointPos, pSrcPreMV, pSrcPreSAD, pMEParams, pSrcDstMV, pDstSAD); if (pMEParams->halfPelSearchEnable) { omxVCM4P2_BlockMatch_Half_8x8( pSrcRefBuf, srcRefStep, pRefRect, pSrcCurrBuf, pCurrPointPos, rndVal, pSrcDstMV, pDstSAD); } return OMX_Sts_NoErr; } /** * Function: omxVCM4P2_MotionEstimationMB (6.2.4.3.1) * * Description: * Performs motion search for a 16x16 macroblock. Selects best motion search * strategy from among inter-1MV, inter-4MV, and intra modes. Supports * integer and half pixel resolution. * * Input Arguments: * * pSrcCurrBuf - pointer to the top-left corner of the current MB in the * original picture plane; must be aligned on a 16-byte boundary. * The function does not expect source data outside the region * bounded by the MB to be available; for example it is not * necessary for the caller to guarantee the availability of * pSrcCurrBuf[-SrcCurrStep], i.e., the row of pixels above the MB * to be processed. * srcCurrStep - width of the original picture plane, in terms of full * pixels; must be a multiple of 16. * pSrcRefBuf - pointer to the reference Y plane; points to the reference * plane location corresponding to the location of the current * macroblock in the current plane; must be aligned on a 16-byte * boundary. * srcRefStep - width of the reference picture plane, in terms of full * pixels; must be a multiple of 16. * pRefRect - reference plane valid region rectangle, specified relative to * the image origin * pCurrPointPos - position of the current macroblock in the current plane * pMESpec - pointer to the vendor-specific motion estimation specification * structure; must be allocated and then initialized using * omxVCM4P2_MEInit prior to calling this function. * pMBInfo - array, of dimension four, containing pointers to information * associated with four nearby MBs: * - pMBInfo[0] - pointer to left MB information * - pMBInfo[1] - pointer to top MB information * - pMBInfo[2] - pointer to top-left MB information * - pMBInfo[3] - pointer to top-right MB information * Any pointer in the array may be set equal to NULL if the * corresponding MB doesn't exist. For each MB, the following structure * members are used: * - mbType - macroblock type, either OMX_VC_INTRA, OMX_VC_INTER, or * OMX_VC_INTER4V * - pMV0[2][2] - estimated motion vectors; represented * in 1/2 pixel units * - sliceID - number of the slice to which the MB belongs * pSrcDstMBCurr - pointer to information structure for the current MB. * The following entries should be set prior to calling the * function: sliceID - the number of the slice the to which the * current MB belongs. The structure elements cbpy and cbpc are * ignored. * * Output Arguments: * * pSrcDstMBCurr - pointer to updated information structure for the current * MB after MB-level motion estimation has been completed. The * following structure members are updated by the ME function: * - mbType - macroblock type: OMX_VC_INTRA, OMX_VC_INTER, or * OMX_VC_INTER4V. * - pMV0[2][2] - estimated motion vectors; represented in * terms of 1/2 pel units. * - pMVPred[2][2] - predicted motion vectors; represented * in terms of 1/2 pel units. * The structure members cbpy and cbpc are not updated by the function. * pDstSAD - pointer to the minimum SAD for INTER1V, or sum of minimum SADs * for INTER4V * pDstBlockSAD - pointer to an array of SAD values for each of the four * 8x8 luma blocks in the MB. The block SADs are in scan order for * each MB. * * Return Value: * * OMX_Sts_NoErr - no error * OMX_Sts_BadArgErr - bad arguments. Returned if one or more of the * following conditions is true: * - at least one of the following pointers is NULL: pSrcCurrBuf, * pSrcRefBuf, pRefRect, pCurrPointPos, pMBInter, pMBIntra, * pSrcDstMBCurr, or pDstSAD. * */ OMXResult omxVCM4P2_MotionEstimationMB ( const OMX_U8 *pSrcCurrBuf, OMX_S32 srcCurrStep, const OMX_U8 *pSrcRefBuf, OMX_S32 srcRefStep, const OMXRect*pRefRect, const OMXVCM4P2Coordinate *pCurrPointPos, void *pMESpec, const OMXVCM4P2MBInfoPtr *pMBInfo, OMXVCM4P2MBInfo *pSrcDstMBCurr, OMX_U16 *pDstSAD, OMX_U16 *pDstBlockSAD ) { OMX_INT intraSAD, average, count, index, x, y; OMXVCMotionVector dstMV16x16; OMX_INT dstSAD16x16; OMX_INT dstSAD8x8; OMXVCM4P2MEParams *pMEParams; OMXVCM4P2Coordinate TempCurrPointPos; OMXVCM4P2Coordinate *pTempCurrPointPos; OMX_U8 aTempSrcCurrBuf[271]; OMX_U8 *pTempSrcCurrBuf; OMX_U8 *pDst; OMX_U8 aDst[71]; OMX_S32 dstStep = 8; OMX_INT predictType; OMX_S32 Sad; const OMX_U8 *pTempSrcRefBuf; OMXVCMotionVector* pSrcCandMV1[4]; OMXVCMotionVector* pSrcCandMV2[4]; OMXVCMotionVector* pSrcCandMV3[4]; /* Argument error checks */ armRetArgErrIf(!armIs16ByteAligned(pSrcCurrBuf), OMX_Sts_BadArgErr); armRetArgErrIf(!armIs16ByteAligned(pSrcRefBuf), OMX_Sts_BadArgErr); armRetArgErrIf(((srcCurrStep % 16) || (srcRefStep % 16)), OMX_Sts_BadArgErr); armRetArgErrIf(pSrcCurrBuf == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pSrcRefBuf == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pRefRect == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pCurrPointPos == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pSrcDstMBCurr == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pDstSAD == NULL, OMX_Sts_BadArgErr); pTempCurrPointPos = &(TempCurrPointPos); pTempSrcCurrBuf = armAlignTo16Bytes(aTempSrcCurrBuf); pMEParams = (OMXVCM4P2MEParams *)pMESpec; pTempCurrPointPos->x = pCurrPointPos->x; pTempCurrPointPos->y = pCurrPointPos->y; pSrcDstMBCurr->mbType = OMX_VC_INTER; /* Preparing a linear buffer for block match */ for (y = 0, index = count = 0; y < 16; y++, index += srcCurrStep - 16) { for(x = 0; x < 16; x++, count++, index++) { pTempSrcCurrBuf[count] = pSrcCurrBuf[index]; } } for(y = 0, index = 0; y < 2; y++) { for(x = 0; x < 2; x++,index++) { if((pMBInfo[0] != NULL) && (pMBInfo[0]->mbType != OMX_VC_INTRA)) { pSrcCandMV1[index] = &(pMBInfo[0]->pMV0[y][x]); } else { pSrcCandMV1[index] = NULL; } if((pMBInfo[1] != NULL) && (pMBInfo[1]->mbType != OMX_VC_INTRA)) { pSrcCandMV2[index] = &(pMBInfo[1]->pMV0[y][x]); } else { pSrcCandMV2[index] = NULL; } if((pMBInfo[3] != NULL) && (pMBInfo[3]->mbType != OMX_VC_INTRA)) { pSrcCandMV3[index] = &(pMBInfo[3]->pMV0[y][x]); } else { pSrcCandMV3[index] = NULL; } } } /* Calculating SAD at MV(0,0) */ armVCCOMM_SAD(pTempSrcCurrBuf, 16, pSrcRefBuf, srcRefStep, &Sad, 16, 16); *pDstSAD = Sad; /* Mode decision for NOT_CODED MB */ if(*pDstSAD == 0) { pSrcDstMBCurr->pMV0[0][0].dx = 0; pSrcDstMBCurr->pMV0[0][0].dy = 0; *pDstSAD = 0; return OMX_Sts_NoErr; } omxVCM4P2_FindMVpred( &(pSrcDstMBCurr->pMV0[0][0]), pSrcCandMV1[0], pSrcCandMV2[0], pSrcCandMV3[0], &(pSrcDstMBCurr->pMVPred[0][0]), NULL, 0); /* Inter 1 MV */ armVCM4P2_BlockMatch_16x16( pSrcRefBuf, srcRefStep, pRefRect, pTempSrcCurrBuf, pCurrPointPos, &(pSrcDstMBCurr->pMVPred[0][0]), NULL, pMEParams, &dstMV16x16, &dstSAD16x16); /* Initialize all with 1 MV values */ pSrcDstMBCurr->pMV0[0][0].dx = dstMV16x16.dx; pSrcDstMBCurr->pMV0[0][0].dy = dstMV16x16.dy; pSrcDstMBCurr->pMV0[0][1].dx = dstMV16x16.dx; pSrcDstMBCurr->pMV0[0][1].dy = dstMV16x16.dy; pSrcDstMBCurr->pMV0[1][0].dx = dstMV16x16.dx; pSrcDstMBCurr->pMV0[1][0].dy = dstMV16x16.dy; pSrcDstMBCurr->pMV0[1][1].dx = dstMV16x16.dx; pSrcDstMBCurr->pMV0[1][1].dy = dstMV16x16.dy; *pDstSAD = dstSAD16x16; if (pMEParams->searchEnable8x8) { /* Inter 4MV */ armVCM4P2_BlockMatch_8x8 (pSrcRefBuf, srcRefStep, pRefRect, pTempSrcCurrBuf, pTempCurrPointPos, &(pSrcDstMBCurr->pMVPred[0][0]), NULL, pMEParams, &(pSrcDstMBCurr->pMV0[0][0]), &dstSAD8x8 ); pDstBlockSAD[0] = dstSAD8x8; *pDstSAD = dstSAD8x8; pTempCurrPointPos->x += 8; pSrcRefBuf += 8; omxVCM4P2_FindMVpred( &(pSrcDstMBCurr->pMV0[0][1]), pSrcCandMV1[1], pSrcCandMV2[1], pSrcCandMV3[1], &(pSrcDstMBCurr->pMVPred[0][1]), NULL, 1); armVCM4P2_BlockMatch_8x8 (pSrcRefBuf, srcRefStep, pRefRect, pTempSrcCurrBuf, pTempCurrPointPos, &(pSrcDstMBCurr->pMVPred[0][1]), NULL, pMEParams, &(pSrcDstMBCurr->pMV0[0][1]), &dstSAD8x8 ); pDstBlockSAD[1] = dstSAD8x8; *pDstSAD += dstSAD8x8; pTempCurrPointPos->x -= 8; pTempCurrPointPos->y += 8; pSrcRefBuf += (srcRefStep * 8) - 8; omxVCM4P2_FindMVpred( &(pSrcDstMBCurr->pMV0[1][0]), pSrcCandMV1[2], pSrcCandMV2[2], pSrcCandMV3[2], &(pSrcDstMBCurr->pMVPred[1][0]), NULL, 2); armVCM4P2_BlockMatch_8x8 (pSrcRefBuf, srcRefStep, pRefRect, pTempSrcCurrBuf, pTempCurrPointPos, &(pSrcDstMBCurr->pMVPred[1][0]), NULL, pMEParams, &(pSrcDstMBCurr->pMV0[1][0]), &dstSAD8x8 ); pDstBlockSAD[2] = dstSAD8x8; *pDstSAD += dstSAD8x8; pTempCurrPointPos->x += 8; pSrcRefBuf += 8; omxVCM4P2_FindMVpred( &(pSrcDstMBCurr->pMV0[1][1]), pSrcCandMV1[3], pSrcCandMV2[3], pSrcCandMV3[3], &(pSrcDstMBCurr->pMVPred[1][1]), NULL, 3); armVCM4P2_BlockMatch_8x8 (pSrcRefBuf, srcRefStep, pRefRect, pTempSrcCurrBuf, pTempCurrPointPos, &(pSrcDstMBCurr->pMVPred[1][1]), NULL, pMEParams, &(pSrcDstMBCurr->pMV0[1][1]), &dstSAD8x8 ); pDstBlockSAD[3] = dstSAD8x8; *pDstSAD += dstSAD8x8; /* Checking if 4MV is equal to 1MV */ if ( (pSrcDstMBCurr->pMV0[0][0].dx != dstMV16x16.dx) || (pSrcDstMBCurr->pMV0[0][0].dy != dstMV16x16.dy) || (pSrcDstMBCurr->pMV0[0][1].dx != dstMV16x16.dx) || (pSrcDstMBCurr->pMV0[0][1].dy != dstMV16x16.dy) || (pSrcDstMBCurr->pMV0[1][0].dx != dstMV16x16.dx) || (pSrcDstMBCurr->pMV0[1][0].dy != dstMV16x16.dy) || (pSrcDstMBCurr->pMV0[1][1].dx != dstMV16x16.dx) || (pSrcDstMBCurr->pMV0[1][1].dy != dstMV16x16.dy) ) { /* select the 4 MV */ pSrcDstMBCurr->mbType = OMX_VC_INTER4V; } } /* finding the error in intra mode */ for (count = 0, average = 0; count < 256 ; count++) { average = average + pTempSrcCurrBuf[count]; } average = average/256; intraSAD = 0; /* Intra SAD calculation */ for (count = 0; count < 256 ; count++) { intraSAD += armAbs ((pTempSrcCurrBuf[count]) - (average)); } /* Using the MPEG4 VM formula for intra/inter mode decision Var < (SAD - 2*NB) where NB = N^2 is the number of pixels of the macroblock.*/ if (intraSAD <= (*pDstSAD - 512)) { pSrcDstMBCurr->mbType = OMX_VC_INTRA; pSrcDstMBCurr->pMV0[0][0].dx = 0; pSrcDstMBCurr->pMV0[0][0].dy = 0; *pDstSAD = intraSAD; pDstBlockSAD[0] = 0xFFFF; pDstBlockSAD[1] = 0xFFFF; pDstBlockSAD[2] = 0xFFFF; pDstBlockSAD[3] = 0xFFFF; } if(pSrcDstMBCurr->mbType == OMX_VC_INTER) { pTempSrcRefBuf = pSrcRefBuf + (srcRefStep * dstMV16x16.dy) + dstMV16x16.dx; if((dstMV16x16.dx & 0x1) && (dstMV16x16.dy & 0x1)) { predictType = OMX_VC_HALF_PIXEL_XY; } else if(dstMV16x16.dx & 0x1) { predictType = OMX_VC_HALF_PIXEL_X; } else if(dstMV16x16.dy & 0x1) { predictType = OMX_VC_HALF_PIXEL_Y; } else { predictType = OMX_VC_INTEGER_PIXEL; } pDst = armAlignTo8Bytes(&(aDst[0])); /* Calculating Block SAD at MV(dstMV16x16.dx,dstMV16x16.dy) */ /* Block 0 */ omxVCM4P2_MCReconBlock(pTempSrcRefBuf, srcRefStep, NULL, pDst, dstStep, predictType, pMEParams->rndVal); armVCCOMM_SAD(pTempSrcCurrBuf, 16, pDst, dstStep, &Sad, 8, 8); pDstBlockSAD[0] = Sad; /* Block 1 */ omxVCM4P2_MCReconBlock(pTempSrcRefBuf + 8, srcRefStep, NULL, pDst, dstStep, predictType, pMEParams->rndVal); armVCCOMM_SAD(pTempSrcCurrBuf + 8, 16, pDst, dstStep, &Sad, 8, 8); pDstBlockSAD[1] = Sad; /* Block 2 */ omxVCM4P2_MCReconBlock(pTempSrcRefBuf + (srcRefStep*8), srcRefStep, NULL, pDst, dstStep, predictType, pMEParams->rndVal); armVCCOMM_SAD(pTempSrcCurrBuf + (16*8), 16, pDst, dstStep, &Sad, 8, 8); pDstBlockSAD[2] = Sad; /* Block 3 */ omxVCM4P2_MCReconBlock(pTempSrcRefBuf + (srcRefStep*8) + 8, srcRefStep, NULL, pDst, dstStep, predictType, pMEParams->rndVal); armVCCOMM_SAD(pTempSrcCurrBuf + (16*8) + 8, 16, pDst, dstStep, &Sad, 8, 8); pDstBlockSAD[3] = Sad; } return OMX_Sts_NoErr; } /* End of file */