/* * 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. * */ /** x * * File Name: omxVCM4P10_MotionEstimationMB.c * OpenMAX DL: v1.0.2 * Revision: 9641 * Date: Thursday, February 7, 2008 * * * * Description: * This function perform MB level motion estimation * */ #include "omxtypes.h" #include "armOMX.h" #include "omxVC.h" #include "armCOMM.h" #include "armVC.h" #define ARM_VCM4P10_MAX_FRAMES (15) #define ARM_VCM4P10_MAX_4x4_SAD (0xffff) #define ARM_VCM4P10_MAX_MODE_VALUE (0xffffffff) #define ARM_VCM4P10_MAX_MODES (16) #define ARM_VCM4P10_MB_BLOCK_SIZE (16) #define ARM_VCM4P10_MEDIAN(a,b,c) (a>b?a>c?b>c?b:c:a:b>c?a>c?a:c:b) #define ARM_VCM4P10_SHIFT_QP (12) #define ARM_VCM4P10_MVPRED_MEDIAN (0) #define ARM_VCM4P10_MVPRED_L (1) #define ARM_VCM4P10_MVPRED_U (2) #define ARM_VCM4P10_MVPRED_UR (3) #define ARM_VCM4P10_MB_BLOCK_SIZE (16) #define ARM_VCM4P10_BLOCK_SIZE (4) #define ARM_VCM4P10_MAX_COST (1 << 30) #define ARM_VCM4P10_INVALID_BLOCK (-2) /** * Function: armVCM4P10_CalculateBlockSAD * * Description: * Calculate SAD value for the selected MB encoding mode and update * pDstBlockSAD parameter. These SAD values are calculated 4x4 blocks at * a time and in the scan order. * * Remarks: * * Parameters: * [in] pSrcMBInfo - * [in] pSrcCurrBuf - * [in] SrcCurrStep - * [in] pSrcRefBufList- * [in] SrcRefStep - * [in] pSrcRecBuf - * [in] SrcRecStep - * [in] pRefRect - * [in] pCurrPointPos - * [in] Lambda - * [in] pMESpec - * [in] pMBInter - * [in] pMBIntra - * [out] pDstBlockSAD - pointer to 16 element array for SAD corresponding to 4x4 blocks * Return Value: * None * */ static OMXResult armVCM4P10_CalculateBlockSAD( OMXVCM4P10MBInfo *pSrcMBInfo, const OMX_U8 *pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8 *pSrcRefBufList[ARM_VCM4P10_MAX_FRAMES], OMX_S32 SrcRefStep, const OMX_U8 *pSrcRecBuf, OMX_S32 SrcRecStep, const OMXRect *pRefRect, const OMXVCM4P2Coordinate *pCurrPointPos, const OMXVCM4P10MBInfoPtr *pMBInter, const OMXVCM4P10MBInfoPtr *pMBIntra, OMX_U16 *pDstBlockSAD) { OMX_INT InvalidSAD = 0; OMX_INT i; OMX_U8 Buffer [16*16 + 15]; OMX_U8 *pTempDstBuf; OMX_S32 TempDstStep; OMX_U8 *pTempRefBuf; OMX_S32 TempRefStep; /* Temporary buffer to store the predicted mb coefficients */ pTempDstBuf = armAlignTo16Bytes(Buffer); TempDstStep = 16; /* Update pDstBlockSAD if MB is a valid type */ if (pSrcMBInfo) { OMX_U32 Width=0, Height=0, MaxXPart, MaxYPart,MaxSubXPart,MaxSubYPart; /* Depending on type of MB, do prediction and fill temp buffer */ switch (pSrcMBInfo->mbType) { case OMX_VC_P_16x16: Width = 16; Height = 16; break; case OMX_VC_P_16x8: Width = 16; Height = 8; break; case OMX_VC_P_8x16: Width = 8; Height = 16; break; case OMX_VC_P_8x8: Width = 8; Height = 8; break; case OMX_VC_INTRA_4x4: { /* Create predicted MB Intra4x4 mode */ OMX_S32 PredIntra4x4Mode [5][9]; OMX_S32 x, y, Block8x8, Block4x4, BlockX, BlockY; OMX_U8 pSrcYBuff [(16*3)*(16*2)]; OMX_U8 *pSrcY; OMX_S32 StepSrcY; OMX_S32 availability; for (y = 0; y < 5; y++) { for (x = 0; x < 9; x++) { /* * Initialize with value of ARM_VCM4P10_INVALID_BLOCK, to mean this * 4x4 block is not available */ PredIntra4x4Mode [y][x] = ARM_VCM4P10_INVALID_BLOCK; } } /* Replace ARM_VCM4P10_INVALID_BLOCK value with available MBs values*/ for (x = 0; x < 4; x++) { /* Store values of b0, b1, b2, b3 */ if (pMBIntra[1] != NULL) { PredIntra4x4Mode [0][x + 1] = pMBIntra[1]->pIntra4x4PredMode[3*4 + x]; } /* Store values of d0, d1, d2, d3 */ if (pMBIntra[3] != NULL) { PredIntra4x4Mode [0][x + 5] = pMBIntra[3]->pIntra4x4PredMode[3*4 + x]; } } /* Store values of c3 */ if (pMBIntra[2] != NULL) { PredIntra4x4Mode [0][0] = pMBIntra[2]->pIntra4x4PredMode[15]; } for (y = 0; y < 4; y++) { /* Store values of a0, a1, a2, a3 */ if (pMBIntra[0] != NULL) { PredIntra4x4Mode [y + 1][0] = pMBIntra[0]->pIntra4x4PredMode[y*4 + 3]; } } /* * Update neighbouring Pred mode array which will be used for * prediction of Intra4x4 modes. */ pSrcY = pSrcYBuff; StepSrcY = 16 * 3; for (y = 0; y < (16 * 2); y++) { for (x = 0; x < (16 * 3); x++) { pSrcY [StepSrcY * y + x] = pSrcRecBuf [SrcRecStep * (y - 16) + x - 16]; } } /* for each 8x8 block */ for (Block8x8 = 0; Block8x8 < 4; Block8x8++) { /* for each 4x4 block inside 8x8 block */ for (Block4x4 = 0; Block4x4 < 4; Block4x4++) { /* Get block cordinates from 8x8 block index and 4x4 block index */ BlockX = ((Block8x8 & 1) << 1) + (Block4x4 & 1); BlockY = ((Block8x8 >> 1) << 1) + (Block4x4 >> 1); /* Add offset to point to start of current MB in the array pIntra4x4PredMode */ x = BlockX + 1; y = BlockY + 1; availability = 0; /* Check for availability of LEFT Block */ if (PredIntra4x4Mode [y][x - 1] != ARM_VCM4P10_INVALID_BLOCK) { availability |= OMX_VC_LEFT; } /* Check for availability of UPPER Block */ if (PredIntra4x4Mode [y - 1][x] != ARM_VCM4P10_INVALID_BLOCK) { availability |= OMX_VC_UPPER; } /* Check for availability of UPPER LEFT Block */ if (PredIntra4x4Mode [y - 1][x - 1] != ARM_VCM4P10_INVALID_BLOCK) { availability |= OMX_VC_UPPER_LEFT; } PredIntra4x4Mode [y][x] = pSrcMBInfo->pIntra4x4PredMode[BlockY*4+BlockX]; x = BlockX * 4; y = BlockY * 4; pSrcY = pSrcYBuff + 16 * StepSrcY + 16 + y * StepSrcY + x; omxVCM4P10_PredictIntra_4x4( pSrcY - 1, pSrcY - StepSrcY, pSrcY - StepSrcY - 1, pTempDstBuf + x + y * TempDstStep, StepSrcY, TempDstStep, pSrcMBInfo->pIntra4x4PredMode[BlockY*4+BlockX], availability); for (BlockY=0;BlockY<4;BlockY++) { for(BlockX=0;BlockX<4;BlockX++) { pSrcY [BlockY * StepSrcY + BlockX] = (OMX_U8)(*(pTempDstBuf + x + y * TempDstStep + BlockY * TempDstStep + BlockX)); } } } } break; } case OMX_VC_INTRA_16x16: { OMX_U32 MBPosX = pCurrPointPos->x >> 4; OMX_U32 MBPosY = pCurrPointPos->y >> 4; OMX_U32 availability = 0; /* Check for availability of LEFT MB */ if ((MBPosX != 0) && (pMBIntra [0] != 0 || pMBInter [0] != 0)) { availability |= OMX_VC_LEFT; } /* Check for availability of UP MB */ if ((MBPosY != 0) && (pMBIntra [1] != 0 || pMBInter [1] != 0)) { availability |= OMX_VC_UPPER; } /* Check for availability of UP-LEFT MB */ if ((MBPosX > 0) && (MBPosY > 0) && (pMBIntra [2] != 0 || pMBInter [2] != 0)) { availability |= OMX_VC_UPPER_LEFT; } omxVCM4P10_PredictIntra_16x16( pSrcRecBuf - 1, pSrcRecBuf - SrcRecStep, pSrcRecBuf - SrcRecStep - 1, pTempDstBuf, SrcRecStep, TempDstStep, pSrcMBInfo->Intra16x16PredMode, availability); break; } case OMX_VC_INTER_SKIP: case OMX_VC_PREF0_8x8: case OMX_VC_INTRA_PCM: default: /* These cases will update pDstBlockSAD with MAX value */ InvalidSAD = 1; break; } /* INTER MB */ if ((pSrcMBInfo->mbType == OMX_VC_P_16x16) || (pSrcMBInfo->mbType == OMX_VC_P_8x16) || (pSrcMBInfo->mbType == OMX_VC_P_16x8) || (pSrcMBInfo->mbType == OMX_VC_P_8x8)) { const OMX_U8 *pTempSrcBuf; OMX_S32 TempSrcStep; OMX_S32 mvx,mvy; OMX_U32 PartX, PartY, SubPartX, SubPartY; TempSrcStep = SrcRefStep; MaxXPart = 16/Width; MaxYPart = 16/Height; for (PartY = 0; PartY < MaxYPart; PartY++) { for (PartX = 0; PartX < MaxXPart; PartX++) { pTempSrcBuf = pSrcRefBufList[pSrcMBInfo->pRefL0Idx[PartY * 2 + PartX]]; if (MaxXPart == 2 && MaxYPart == 2) { switch (pSrcMBInfo->subMBType[PartY*2+PartX]) { case OMX_VC_SUB_P_8x8: Width = 8; Height = 8; break; case OMX_VC_SUB_P_8x4: Width = 8; Height = 4; break; case OMX_VC_SUB_P_4x8: Width = 4; Height = 8; break; case OMX_VC_SUB_P_4x4: Width = 4; Height = 4; break; default: /* Default */ Width = 4; Height = 4; break; } MaxSubXPart = 8/Width; MaxSubYPart = 8/Height; for (SubPartY = 0; SubPartY < MaxSubYPart; SubPartY++) { for (SubPartX = 0; SubPartX < MaxSubXPart; SubPartX++) { mvx = pSrcMBInfo->pMV0 [2*PartY + SubPartY][2*PartX + SubPartX].dx; mvy = pSrcMBInfo->pMV0 [2*PartY + SubPartY][2*PartX + SubPartX].dy; armVCM4P10_Interpolate_Luma( pTempSrcBuf + (8*PartX + 4*SubPartX + (mvx/4)) + (8*PartY + 4*SubPartY + (mvy/4)) * TempSrcStep, TempSrcStep, pTempDstBuf + (8*PartX + 4*SubPartX) + (8*PartY + 4*SubPartY) * TempDstStep, TempDstStep, Width, Height, mvx & 3, mvy & 3 ); } } } else { mvx = pSrcMBInfo->pMV0 [2*PartY][2*PartX].dx; mvy = pSrcMBInfo->pMV0 [2*PartY][2*PartX].dy; armVCM4P10_Interpolate_Luma( pTempSrcBuf + (8*PartX + (mvx/4)) + (8*PartY + (mvy/4)) * TempSrcStep, TempSrcStep, pTempDstBuf + (8*PartX) + (8*PartY) * TempDstStep, TempDstStep, Width, Height, mvx & 3, mvy & 3 ); } } } } } else { InvalidSAD = 1; } /* Calculate SAD from predicted buffer */ if (!InvalidSAD) { OMX_U32 x8x8, y8x8, x4x4, y4x4, Block8x8, Block4x4; OMX_S32 SAD; pTempRefBuf = pTempDstBuf; TempRefStep = 16; /* SAD for each 4x4 block in scan order */ for (Block8x8 = 0; Block8x8 < 4; Block8x8++) { x8x8 = 8*(Block8x8 & 1); y8x8 = 8*(Block8x8 >> 1); for (Block4x4 = 0; Block4x4 < 4; Block4x4++) { x4x4 = 4*(Block4x4 & 1); y4x4 = 4*(Block4x4 >> 1); armVCCOMM_SAD( pSrcCurrBuf + (x8x8 + x4x4) + (y8x8 + y4x4) * SrcCurrStep, SrcCurrStep, pTempRefBuf + (x8x8 + x4x4) + (y8x8 + y4x4) * TempRefStep, TempRefStep, &SAD, 4, /* Height */ 4); /* Width */ *(pDstBlockSAD + 4 * Block8x8 + Block4x4) = (SAD < 0x7fff) ? (OMX_U16) SAD : ARM_VCM4P10_MAX_MODE_VALUE; } } } else { /* Fill SADs with max values and return*/ for (i = 0; i < 16; i++) { pDstBlockSAD [i] = ARM_VCM4P10_MAX_4x4_SAD; } } return OMX_Sts_NoErr; } /** * Function: armVCM4P10_Mode4x4Decision * * Description: * Intra 4x4 Mode decision by calculating cost for all possible modes and * choosing the best mode * * Remarks: * * Parameters: * [in] pSrcCurrBuf - Pointer to the start of current Macroblock * [in] SrcCurrStep - Step size of the pointer pSrcCurrBuf * [in/out] pSrcDstMBCurr - Pointer to the OMXVCM4P10MBInfo which will be updated for * field pIntra4x4PredMode of the current block. * [in] Block8x8 - Index 8x8 block in which current 4x4 block belongs * [in] Block4x4 - Index of current 4x4 block * [in/out] pPredIntra4x4SrcY - Pointer to current block location in buffer * with reconstructed values. This will be modified by this * function with best mode predicted values * [in] StepPredIntra4x4SrcY - Step size of the pointer pPredIntra4x4SrcY * [in] pIntra4x4PredMode - Array of Intra 4x4 prediction mode for the MB. * Current MB modes starts at [1,1]. * [in] pBestCost - Cost for the Best Intra 4x4 mode * Return Value: * None * */ static OMXVoid armVCM4P10_Mode4x4Decision ( const OMX_U8* pSrcCurrBuf, OMX_S32 SrcCurrStep, OMXVCM4P10MBInfo *pSrcDstMBCurr, OMX_S32 Block8x8, OMX_S32 Block4x4, OMX_U8 *pPredIntra4x4SrcY, OMX_S32 StepPredIntra4x4SrcY, OMX_S32 pIntra4x4PredMode [][9], OMX_S32 *pBestCost ) { OMX_S32 i, j, x, y, BlockX, BlockY, mode; OMX_S32 Cost, BestCost; OMX_U8 *pSrcY; OMX_S32 StepSrcY; OMX_S32 availability = 0; OMX_U8 pPredBlock [4*4]; OMXResult Ret = OMX_Sts_Err; /* Get block cordinates from 8x8 block index and 4x4 block index */ BlockX = ((Block8x8 & 1) << 1) + (Block4x4 & 1); BlockY = ((Block8x8 >> 1) << 1) + (Block4x4 >> 1); /* Add offset to point to start of current MB in the array pIntra4x4PredMode */ x = BlockX + 1; y = BlockY + 1; /* Check for availability of LEFT Block */ if (pIntra4x4PredMode [y][x - 1] != ARM_VCM4P10_INVALID_BLOCK) { availability |= OMX_VC_LEFT; } /* Check for availability of UPPER Block */ if (pIntra4x4PredMode [y - 1][x] != ARM_VCM4P10_INVALID_BLOCK) { availability |= OMX_VC_UPPER; } /* Check for availability of UPPER LEFT Block */ if (pIntra4x4PredMode [y - 1][x - 1] != ARM_VCM4P10_INVALID_BLOCK) { availability |= OMX_VC_UPPER_LEFT; } pSrcY = pPredIntra4x4SrcY + StepPredIntra4x4SrcY * (BlockY << 2) + (BlockX << 2); StepSrcY = StepPredIntra4x4SrcY; x = BlockX * 4; y = BlockY * 4; Cost = BestCost = ARM_VCM4P10_MAX_COST; /* Go through each mode for minim cost */ for (mode = 0; mode < 9; mode++) { Ret = omxVCM4P10_PredictIntra_4x4( pSrcY - 1, pSrcY - StepSrcY, pSrcY - StepSrcY - 1, pPredBlock, StepSrcY, 4, (OMXVCM4P10Intra4x4PredMode) mode, availability); if (Ret == OMX_Sts_NoErr) { armVCCOMM_SAD( pSrcCurrBuf + (y * SrcCurrStep) + x, SrcCurrStep, pPredBlock, 4, &Cost, 4, 4); if (Cost < BestCost) { BestCost = Cost; pIntra4x4PredMode [BlockY + 1][BlockX + 1] = (OMXVCM4P10Intra4x4PredMode) mode; pSrcDstMBCurr->pIntra4x4PredMode [BlockY * 4 + BlockX] = (OMXVCM4P10Intra4x4PredMode) mode; for (j = 0; j < 4; j++) { for (i = 0; i < 4; i++) { pSrcY [StepSrcY * j + i] = pPredBlock [4 * j + i]; } } } } } *pBestCost = BestCost; return; } /** * Function: armVCM4P10_SetMotionVectorPredictor * * Description: * This function will do the MV Prediction for Inter MBs * * Parameters: * [in] BlockStartX - Start X index in integer pels in current Block * [in] BlockStartY - Start Y index in integer pels in current Block * [in] BlockSizeX - Width of current block * [in] BlockSizeY - Height of current block * [in] RefFrame - Index of the reference frame for prediction * [in] pRefFrArr - Pointer to Ref array storing neighbouring MVs for MV prediction * [in] pMVArr - Pointer to MV array storing neighbouring MVs for MV prediction * [out] pMVPred - Pointer to predicted MVs * Remarks: * * Return Value: * None * */ static OMXVoid armVCM4P10_SetMotionVectorPredictor( OMX_U32 BlockStartX, OMX_U32 BlockStartY, OMX_U32 BlockSizex, OMX_U32 BlockSizey, OMX_S32 RefFrame, OMX_S32 pRefFrArr[][6], OMXVCMotionVector pMVArr[][12], OMXVCMotionVector *pMVPred ) { OMX_S32 RFrameL; /* Left */ OMX_S32 RFrameU; /* Up */ OMX_S32 RFrameUR; /* Up-Right */ OMX_S32 BlockX, BlockY, BlockXFr, BlockYFr, MVPredType; OMX_S32 BlockXPlusOff, BlockXPlusOffFr, BlockXMin1Fr, BlockYMin1Fr; BlockX = 4 + (BlockStartX >> 2); BlockY = 4 + (BlockStartY >> 2); BlockXPlusOff = BlockX + (BlockSizex >> 2); BlockXFr = BlockX >> 1; BlockYFr = BlockY >> 1; BlockXMin1Fr = (BlockX - 1) >> 1; BlockYMin1Fr = (BlockY - 1) >> 1; BlockXPlusOffFr = BlockXPlusOff >> 1; MVPredType = ARM_VCM4P10_MVPRED_MEDIAN; RFrameL = pRefFrArr [BlockYFr][BlockXMin1Fr]; RFrameU = pRefFrArr [BlockYMin1Fr][BlockXFr]; RFrameUR = pRefFrArr [BlockYMin1Fr][BlockXPlusOffFr]; if (RFrameUR == ARM_VCM4P10_INVALID_BLOCK) { RFrameUR = pRefFrArr [BlockYMin1Fr][BlockXMin1Fr]; } /* * Prediction if only one of the neighbors uses the reference frame * we are checking */ if (RFrameL == RefFrame && RFrameU != RefFrame && RFrameUR != RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_L; } else if(RFrameL != RefFrame && RFrameU == RefFrame && RFrameUR != RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_U; } else if(RFrameL != RefFrame && RFrameU != RefFrame && RFrameUR == RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_UR; } /* Directional predictions */ else if(BlockSizex == 8 && BlockSizey == 16) { if(BlockStartX == 0) { if(RFrameL == RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_L; } } else { if (RFrameUR == RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_UR; } } } else if(BlockSizex == 16 && BlockSizey == 8) { if(BlockStartY == 0) { if(RFrameU == RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_U; } } else { if(RFrameL == RefFrame) { MVPredType = ARM_VCM4P10_MVPRED_L; } } } switch (MVPredType) { case ARM_VCM4P10_MVPRED_MEDIAN: if (!(pRefFrArr [BlockYMin1Fr][BlockXMin1Fr] == ARM_VCM4P10_INVALID_BLOCK || pRefFrArr [BlockYMin1Fr][BlockXFr] == ARM_VCM4P10_INVALID_BLOCK || pRefFrArr [BlockYMin1Fr][BlockXPlusOffFr] == ARM_VCM4P10_INVALID_BLOCK)) { pMVPred->dx = pMVArr [BlockY][BlockX - 1].dx; pMVPred->dy = pMVArr [BlockY][BlockX - 1].dy; } else { pMVPred->dx = ARM_VCM4P10_MEDIAN(pMVArr [BlockY][BlockX - 1].dx, pMVArr [BlockY - 1][BlockX].dx, pMVArr [BlockY - 1][BlockXPlusOff].dx); pMVPred->dy = ARM_VCM4P10_MEDIAN(pMVArr [BlockY][BlockX - 1].dy, pMVArr [BlockY - 1][BlockX].dy, pMVArr [BlockY - 1][BlockXPlusOff].dy); } break; case ARM_VCM4P10_MVPRED_L: pMVPred->dx = pMVArr [BlockY][BlockX - 1].dx; pMVPred->dy = pMVArr [BlockY][BlockX - 1].dy; break; case ARM_VCM4P10_MVPRED_U: pMVPred->dx = pMVArr [BlockY - 1][BlockX].dx; pMVPred->dy = pMVArr [BlockY - 1][BlockX].dy; break; case ARM_VCM4P10_MVPRED_UR: if (pRefFrArr [BlockYMin1Fr][BlockXPlusOffFr] != ARM_VCM4P10_INVALID_BLOCK) { pMVPred->dx = pMVArr [BlockY - 1][BlockXPlusOff].dx; pMVPred->dy = pMVArr [BlockY - 1][BlockXPlusOff].dy; } else { pMVPred->dx = pMVArr [BlockY - 1][BlockX - 1].dx; pMVPred->dy = pMVArr [BlockY - 1][BlockX - 1].dy; } break; default: break; } return; } /** * Function: armVCM4P10_BlockMotionSearch * * Description: * Gets best MV for the current block * * Parameters: * [in] pSrcCurrBuf - Pointer to the start of luma component of current Macroblock * [in] SrcCurrStep - Step size for the pointer pSrcCurrBuf * [in] pSrcRefY - Pointer to the start of luma component of co-located reference MB * [in] nSrcRefStep - Step size for the pointer pSrcRefY * [in] pRefRect Pointer to the valid reference rectangle; relative to the image origin. * [in] pCurrPointPos Position of the current macroblock in the current plane. * [in] pMESpec - Motion estimation structure * [in] pMBInter - Array, of dimension four, containing pointers to information associated with four * adjacent type INTER MBs (Left, Top, Top-Left, Top-Right). * [in] nLamda - For calculating the cost * [out] pBestCost - Minimum cost for encoding current block * [out] pBestMV - MV corresponding to best cost * [in] BlockStartX - Block start X index in integer pels * [in] BlockStartY - Block start Y index in integer pels * [in] BlockSizeX - Width of current block * [in] BlockSizeY - Height of current block * [in] RefFrame - Index of the reference frame for prediction * [in] pRefFrArr - Pointer to reference frame array storing neighbouring MVs for prediction * [in] pMVArr - Pointer to MV array storing neighbouring MVs for MV prediction * [in] pMVPred - Pointer to MV predicted from neighbour MVs * Remarks: * * Return Value: * OMXResult * */ static OMXResult armVCM4P10_BlockMotionSearch( const OMX_U8* pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8* pSrcRefY, OMX_S32 nSrcRefStep, const OMXRect *pRefRect, const OMXVCM4P2Coordinate *pCurrPointPos, void* pMESpec, OMX_S32 nLamda, OMX_S32* pBestCost, OMXVCMotionVector *pBestMV, OMX_U32 BlockStartX, OMX_U32 BlockStartY, OMX_U32 BlockSizeX, OMX_U32 BlockSizeY, OMX_S32 RefFrame, OMX_S32 pRefFrArr [][6], OMXVCMotionVector pMVArr [][12], OMXVCMotionVector *pMVPred ) { OMXVCMotionVector MVCalculated, MVCandidate; OMX_S32 Cost; OMXResult RetValue; OMXVCM4P10MEParams *pMEParams; OMXVCM4P2Coordinate CurrBlockPos; /* Get Predicted Motion Vectors */ armVCM4P10_SetMotionVectorPredictor ( BlockStartX, BlockStartY, BlockSizeX, BlockSizeY, RefFrame, pRefFrArr, pMVArr, pMVPred); /* Initialize candidate MV */ MVCandidate.dx = 0; MVCandidate.dy = 0; CurrBlockPos.x = pCurrPointPos->x + BlockStartX; CurrBlockPos.y = pCurrPointPos->y + BlockStartY; /* Block Match Integer */ RetValue = omxVCM4P10_BlockMatch_Integer ( pSrcCurrBuf, SrcCurrStep, pSrcRefY, nSrcRefStep, pRefRect, &CurrBlockPos, BlockSizeX, BlockSizeY, nLamda, pMVPred, &MVCandidate, &MVCalculated, &Cost, pMESpec); /* updated BestMV*/ /**pBestCost = Cost; pBestMV->dx = MVCalculated.dx; pBestMV->dy = MVCalculated.dy;*/ pMEParams = (OMXVCM4P10MEParams *) pMESpec; /* Block Match Half pel */ if (pMEParams->halfSearchEnable) { RetValue = omxVCM4P10_BlockMatch_Half( pSrcCurrBuf, SrcCurrStep, pSrcRefY, nSrcRefStep, BlockSizeX, BlockSizeY, nLamda, pMVPred, &MVCalculated, /* input/output*/ &Cost); } /* Block Match Quarter pel */ if (pMEParams->quarterSearchEnable) { RetValue = omxVCM4P10_BlockMatch_Quarter( pSrcCurrBuf, SrcCurrStep, pSrcRefY, nSrcRefStep, BlockSizeX, BlockSizeY, nLamda, pMVPred, &MVCalculated, &Cost); } /* updated Best Cost and Best MV */ *pBestCost = Cost; pBestMV->dx = MVCalculated.dx; pBestMV->dy = MVCalculated.dy; /* * Skip MB cost calculations of 16x16 inter mode */ return RetValue; } /** * Function: armVCM4P10_PartitionME * * Description: * Gets best cost for the current partition * * Parameters: * [in] pSrcCurrBuf - Pointer to the start of luma component of current Macroblock * [in] SrcCurrStep - Step size for the pointer pSrcCurrBuf * [in] pSrcRefBufList - Pointer to List of ref buffer of co-located reference MB * [in] nSrcRefStep - Step size for the pointer pSrcRefY * [in] pRefRect Pointer to the valid reference rectangle; relative to the image origin. * [in] pCurrPointPos Position of the current macroblock in the current plane. * [in] pMESpec - Motion estimation structure * [in] PartWidth - Width of current partition * [in] PartHeight - Height of current partition * [in] BlockWidth - Width of current block * [in] BlockHeight - Height of current block * [in] PartStartX - Partition start X index in integer pels * [in] PartStartY - Partition start Y index in integer pels * [in] pMVArr - Pointer to MV array storing neighbouring MVs for MV prediction * [in] pRefFrArr - Pointer to reference frame array storing neighbouring MVs for prediction * [in] Lambda - For calculating the cost * [out] pCost - Pointer to cost for Inter MB * * Return Value: * OMXResult * */ static OMXResult armVCM4P10_PartitionME ( const OMX_U8* pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8 *pSrcRefBufList[ARM_VCM4P10_MAX_FRAMES], OMX_S32 SrcRefStep, const OMXRect *pRefRect, const OMXVCM4P2Coordinate *pCurrPointPos, void* pMESpec, OMX_S32 PartWidth, OMX_S32 PartHeight, OMX_S32 BlockWidth, OMX_S32 BlockHeight, OMX_S32 PartStartX, OMX_S32 PartStartY, OMXVCMotionVector pMVArr [][12], OMX_S32 pRefFrArr [][6], OMXVCMotionVector pMVPredArr [][4], OMX_S32 Lambda, OMX_S32 *pCost ) { OMX_U32 x, y, i, j, ref, OffX, OffY, OffSrc, OffRef; OMX_S32 BlockCost, PartitionCost, BestCost; OMX_S32 BestRefFrame=0; OMXVCMotionVector BestMV [4][4]; OMXVCMotionVector BestMVPred [4][4]; OMXVCMotionVector MVPred; OMXVCMotionVector DstMV; BestCost = ARM_VCM4P10_MAX_COST; for (ref = 0; ref < ARM_VCM4P10_MAX_FRAMES; ref++) { if (pSrcRefBufList [ref] == NULL) { /* No reference frame, continue */ continue; } PartitionCost = 0; for (y = 0; y < PartHeight; y += BlockHeight) { for (x = 0; x < PartWidth; x += BlockWidth) { OffSrc = SrcCurrStep * (PartStartY + y) + PartStartX + x; OffRef = SrcRefStep * (PartStartY + y) + PartStartX + x; armVCM4P10_BlockMotionSearch ( pSrcCurrBuf + OffSrc, SrcCurrStep, pSrcRefBufList [ref] + OffRef, SrcRefStep, pRefRect, pCurrPointPos, pMESpec, Lambda, &BlockCost, &DstMV, x + PartStartX, y + PartStartY, BlockWidth, BlockHeight, ref, pRefFrArr, pMVArr, &MVPred); PartitionCost += BlockCost; OffX = (PartStartX + x) >> 2; OffY = (PartStartY + y) >> 2; for (j = 0; j < (BlockHeight >> 2); j++) { for (i = 0; i < (BlockWidth >> 2); i++) { pMVArr [4 + OffY + j][4 + OffX + i].dx = DstMV.dx; pMVArr [4 + OffY + j][4 + OffX + i].dy = DstMV.dy; pMVPredArr [OffY + j][OffX + i].dx = MVPred.dx; pMVPredArr [OffY + j][OffX + i].dy = MVPred.dy; } } pRefFrArr [2 + (OffY >> 1)][2 + (OffX >> 1)] = ref; for (j = 0; j < (BlockHeight >> 3); j++) { for (i = 0; i < (BlockWidth >> 3); i++) { pRefFrArr [2 + (OffY >> 1) + j][2 + (OffX >> 1) + i] = ref; } } } } /* * If PartitionCost is less for this reference frame, motion vectors needs to be backedup */ if (PartitionCost <= BestCost) { BestCost = PartitionCost; BestRefFrame = ref; for (y = 0; y < (PartHeight/BlockHeight); y++) { for (x = 0; x < (PartWidth/BlockWidth); x++) { OffX = (PartStartX + x * BlockWidth) >> 2; OffY = (PartStartY + y * BlockHeight) >> 2; BestMV[y][x].dx = pMVArr [4 + OffY][4 + OffX].dx; BestMV[y][x].dy = pMVArr [4 + OffY][4 + OffX].dy; BestMVPred[y][x].dx = pMVPredArr [OffY][OffX].dx; BestMVPred[y][x].dy = pMVPredArr [OffY][OffX].dy; } } } } /* * Copy back best reference frame, motion vectors and cost. */ for (y = 0; y < (PartHeight/BlockHeight); y++) { for (x = 0; x < (PartWidth/BlockWidth); x++) { OffX = (PartStartX + x * BlockWidth) >> 2; OffY = (PartStartY + y * BlockHeight) >> 2; for (j = 0; j < (BlockHeight >> 2); j++) { for (i = 0; i < (BlockWidth >> 2); i++) { pMVArr [4 + OffY + j][4 + OffX + i].dx = BestMV[y][x].dx; pMVArr [4 + OffY + j][4 + OffX + i].dy = BestMV[y][x].dy; pMVPredArr [OffY + j][OffX + i].dx = BestMVPred[y][x].dx; pMVPredArr [OffY + j][OffX + i].dy = BestMVPred[y][x].dy; } } for (j = 0; j < (BlockHeight >> 3); j++) { for (i = 0; i < (BlockWidth >> 3); i++) { pRefFrArr [2 + (OffY >> 1) + j][2 + (OffX >> 1) + i] = BestRefFrame; } } } } *pCost = BestCost; return OMX_Sts_NoErr; } /** * Function: armVCM4P10_Intra16x16Estimation * * Description: * Performs MB-level motion estimation for INTER MB type and selects best motion estimation strategy from * the set of modes supported in baseline profile ISO/IEC 14496-10. * * Remarks: * * Parameters: * [in] pSrcCurrBuf - Pointer to the start of luma component of current Macroblock * [in] SrcCurrStep - Step size for the pointer pSrcCurrBuf * [in] pSrcRecBuf - Pointer to the start of luma component of co-located reconstructed MB * [in] SrcRecStep - Step size for the pointer pSrcRecBuf * [in] nMBPosX - Position of MB in the frame w.r.t X axis * [in] nMBPosY - Position of MB in the frame w.r.t Y axis * [in] pMBInter - Array, of dimension four, containing pointers to information associated with four * adjacent type INTER MBs (Left, Top, Top-Left, Top-Right). * [in] pMBIntra - Array, of dimension four, containing pointers to information associated with four * adjacent type INTRA MBs (Left, Top, Top-Left, Top-Right). * [in/out] pSrcDstMBCurr - Pointer to information structure for the current MB. Following member should be set * before calling this function * [in] Lambda - For calculating the cost * [out] pCost - Pointer to cost for Intra16x16 * Return Value: * OMX_Sts_NoErr - No Error * OMX_Sts_BadArgErr - Bad arguments: * */ static OMXResult armVCM4P10_Intra16x16Estimation( const OMX_U8* pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8* pSrcRecBuf, OMX_S32 SrcRecStep, const OMXVCM4P2Coordinate *pCurrPointPos, const OMXVCM4P10MBInfoPtr *pMBInter, const OMXVCM4P10MBInfoPtr *pMBIntra, OMXVCM4P10MBInfo *pSrcDstMBCurr, OMX_U32 *pCost) { OMX_U8 PredBuf [16*16 + 16]; OMX_U8 *pPred; OMX_S32 mode; OMX_S32 Cost; OMX_S32 availability = 0; OMXResult Ret; OMXVCM4P10Intra16x16PredMode IntraMode16x16 [4] = {OMX_VC_16X16_VERT, OMX_VC_16X16_HOR, OMX_VC_16X16_DC, OMX_VC_16X16_PLANE}; OMX_U32 MBPosX = pCurrPointPos->x >> 4; OMX_U32 MBPosY = pCurrPointPos->y >> 4; pPred = armAlignTo16Bytes(PredBuf); /* Check for availability of LEFT MB */ if ((MBPosX != 0) && (pMBIntra [0] != 0 || pMBInter [0] != 0)) { availability |= OMX_VC_LEFT; } /* Check for availability of UP MB */ if ((MBPosY != 0) && (pMBIntra [1] != 0 || pMBInter [1] != 0)) { availability |= OMX_VC_UPPER; } /* Check for availability of UP-LEFT MB */ if ((MBPosX > 0) && (MBPosY > 0) && (pMBIntra [2] != 0 || pMBInter [2] != 0)) { availability |= OMX_VC_UPPER_LEFT; } *pCost = ARM_VCM4P10_MAX_COST; for (mode = 0; mode < 4; mode++) { Ret = omxVCM4P10_PredictIntra_16x16( pSrcRecBuf - 1, pSrcRecBuf - SrcRecStep, pSrcRecBuf - SrcRecStep - 1, pPred, SrcRecStep, 16, IntraMode16x16 [mode], availability); if (Ret == OMX_Sts_NoErr) { armVCCOMM_SAD( pSrcCurrBuf, SrcCurrStep, pPred, 16, &Cost, 16, 16); if (Cost < *pCost) { *pCost = Cost; pSrcDstMBCurr->Intra16x16PredMode = IntraMode16x16 [mode]; } } } return OMX_Sts_NoErr; } /** * Function: armVCM4P10_Intra4x4Estimation * * Description: * Performs MB-level motion estimation for Intra 4x4 MB type and selects * the best set of modes supported in baseline profile. * * Parameters: * [in] pSrcCurrBuf - Pointer to the start of luma component of current Macroblock * [in] SrcCurrStep - Step size for the pointer pSrcCurrBuf * [in] pSrcRecBuf - Pointer to the start of luma component of co-located reconstructed MB * [in] SrcRecStep - Step size for the pointer pSrcRecBuf * [in] nMBPosX - Position of MB in the frame w.r.t X axis * [in] nMBPosY - Position of MB in the frame w.r.t Y axis * [in] pMBIntra - Array, of dimension four, containing pointers to information associated with four * adjacent type INTRA MBs (Left, Top, Top-Left, Top-Right). * [in/out] pSrcDstMBCurr - Pointer to information structure for the current MB. Following member should be set * before calling this function * [in] Lambda - For calculating the cost * [out] pCost - Pointer to cost for Intra4x4 * Return Value: * OMX_Sts_NoErr - No Error * OMX_Sts_BadArgErr - Bad arguments: * */ static OMXResult armVCM4P10_Intra4x4Estimation( const OMX_U8* pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8* pSrcRecBuf, OMX_S32 SrcRecStep, const OMXVCM4P10MBInfoPtr *pMBIntra, OMXVCM4P10MBInfo *pSrcDstMBCurr, OMX_U32 *pCost) { OMX_S32 x, y, Block4x4, Block8x8; OMX_S32 Cost; /* * PredIntra4x4Mode will store prediction modes of 4x4 blocks. * Modes for current MB starts at index [1][1]. * Modes of nighbouring MB's will be as shown below * A value of ARM_VCM4P10_INVALID_BLOCK for any block in this array means * that block is not available for prediction. * * c3 b0 b1 b2 b3 d0 d1 d2 d3 * a0 xx xx xx xx - - - - * a1 xx xx xx xx - - - - * a2 xx xx xx xx - - - - * a3 xx xx xx xx - - - - * */ OMX_S32 PredIntra4x4Mode [5][9]; /* * pSrcY stores re-construsted source array of size 3MB X 2MB as below * * MB11 MB12 MB13 * MB21 MB22 MB23 * * This array will be used for local reconstruction of 4x4 blocks * with best prediction mode within an MB */ OMX_U8 pSrcY [(16*3)*(16*2)]; OMX_S32 StepSrcY; /* init */ *pCost = 0; for (y = 0; y < 5; y++) { for (x = 0; x < 9; x++) { /* * Initialize with value of ARM_VCM4P10_INVALID_BLOCK, to mean this * 4x4 block is not available */ PredIntra4x4Mode [y][x] = ARM_VCM4P10_INVALID_BLOCK; } } /* Replace ARM_VCM4P10_INVALID_BLOCK value with available MBs values*/ for (x = 0; x < 4; x++) { /* Store values of b0, b1, b2, b3 */ if (pMBIntra[1] != NULL) { PredIntra4x4Mode [0][x + 1] = pMBIntra[1]->pIntra4x4PredMode[3*4 + x]; } /* Store values of d0, d1, d2, d3 */ if (pMBIntra[3] != NULL) { PredIntra4x4Mode [0][x + 5] = pMBIntra[3]->pIntra4x4PredMode[3*4 + x]; } } /* Store values of c3 */ if (pMBIntra[2] != NULL) { PredIntra4x4Mode [0][0] = pMBIntra[2]->pIntra4x4PredMode[15]; } for (y = 0; y < 4; y++) { /* Store values of a0, a1, a2, a3 */ if (pMBIntra[0] != NULL) { PredIntra4x4Mode [y + 1][0] = pMBIntra[0]->pIntra4x4PredMode[y*4 + 3]; } } /* * Update neighbouring Pred mode array which will be used for * prediction of Intra4x4 modes. */ StepSrcY = 16 * 3; for (y = 0; y < (16 * 2); y++) { for (x = 0; x < (16 * 3); x++) { pSrcY [StepSrcY * y + x] = pSrcRecBuf [SrcRecStep * (y - 16) + x - 16]; } } /* for each 8x8 block */ for (Block8x8 = 0; Block8x8 < 4; Block8x8++) { /* for each 4x4 block inside 8x8 block */ for (Block4x4 = 0; Block4x4 < 4; Block4x4++) { armVCM4P10_Mode4x4Decision ( pSrcCurrBuf, SrcCurrStep, pSrcDstMBCurr, Block8x8, Block4x4, pSrcY + 16 * StepSrcY + 16, StepSrcY, PredIntra4x4Mode, &Cost); *pCost += Cost; } } return OMX_Sts_NoErr; } /** * Function: armVCM4P10_InterMEMB * * Description: * Performs MB-level motion estimation for INTER MB type and selects best motion estimation strategy from * the set of modes supported in baseline profile ISO/IEC 14496-10. * * Remarks: * * Parameters: * [in] pSrcCurrBuf - Pointer to the start of luma component of current Macroblock * [in] SrcCurrStep - Step size for the pointer pSrcCurrBuf * [in] pSrcRefBufList - Pointer to the start of luma component of co-located reference MB * [in] SrcRefStep - Step size for the pointer pSrcRefY * [in] pRefRect Pointer to the valid reference rectangle; relative to the image origin. * [in] pCurrPointPos Position of the current macroblock in the current plane. * [in] pMESpec - Motion estimation structure * [in] pMBInter - Array, of dimension four, containing pointers to information associated with four * adjacent type INTER MBs (Left, Top, Top-Left, Top-Right). * [in/out] pSrcDstMBCurr - Pointer to information structure for the current MB. Following member should be set * before calling this function * [in] Lambda - For calculating the cost * [out] pDstCost - Pointer to cost for Inter MB * Return Value: * OMX_Sts_NoErr - No Error * OMX_Sts_BadArgErr - Bad arguments: * */ static OMXResult armVCM4P10_InterMEMB( const OMX_U8 *pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8 *pSrcRefBufList[ARM_VCM4P10_MAX_FRAMES], OMX_S32 SrcRefStep, const OMXRect *pRefRect, const OMXVCM4P2Coordinate *pCurrPointPos, OMX_U32 Lambda, void *pMESpec, const OMXVCM4P10MBInfoPtr *pMBInter, OMXVCM4P10MBInfoPtr pSrcDstMBCurr, OMX_U32 *pDstCost) { OMX_S32 i, j, x, y, mode; OMX_U32 Block8x8, XPerMB, YPerMB, Block2x, Block2y; OMX_S32 PartStartX = 0, PartStartY = 0; OMX_S32 PartWidth = 8, PartHeight = 8, BlockWidth = 4, BlockHeight = 4; const OMX_U32 BlkSz [4][2] = {{4,4}, {4,8}, {8,4}}; const OMX_U32 PartSz [4][2] = {{8,8}, {8,16}, {16,8}, {16,16}}; const OMXVCM4P10SubMacroblockType ModeSubMBType4x4 [] = {OMX_VC_SUB_P_4x4, OMX_VC_SUB_P_4x8, OMX_VC_SUB_P_8x4, OMX_VC_SUB_P_8x8}; const OMXVCM4P10MacroblockType ModeMBType [] = {OMX_VC_P_8x8, OMX_VC_P_8x16, OMX_VC_P_16x8, OMX_VC_P_16x16}; OMXVCM4P10MEParams *pMBOptions; /* * RefFrArr and MVArr will be used for temporary storage of Reference frame index and MVs * It will store RefIndex and MVs of 6 MBs as shown below * * |------|------|------| * |Tp-Lt |Top |Tp-R | * | MB | MB | MB | * |------|------|------| * |Left | Curr | | * | MB | MB | | * |------|------|------| */ OMX_S32 RefFrArr [4][6]; OMXVCMotionVector MVArr [8][12]; OMXVCMotionVector MVPredArr [4][4]; /* * IndexToLoc will translate pMBInter index into spacial arrangement of MBs */ OMX_S32 IndexToLoc [] = {2,1,3,0}; OMX_U32 part, MaxPart; OMX_S32 Cost, MotionCost8x8 [4], MBCost, BestCost; /* * Update neighbouring MV array and Ref frame array which will be used for * prediction of MVs and Ref frames. */ /* Set cost to a high value */ Cost = BestCost = ARM_VCM4P10_MAX_COST; for (y = 0; y < 8; y++) { for (x = 0; x < 12; x++) { i = 3 * (y >> 2) + (x >> 2); if ((y < 4 || x < 4) && (pMBInter[IndexToLoc[i]] != NULL)) { MVArr [y][x].dx = pMBInter[IndexToLoc[i]]->pMV0[y % 4][x % 4].dx; MVArr [y][x].dy = pMBInter[IndexToLoc[i]]->pMV0[y % 4][x % 4].dy; } else { MVArr [y][x].dx = 0; MVArr [y][x].dy = 0; } } } for (y = 0; y < 4; y++) { for (x = 0; x < 6; x++) { i = 3 * (y >> 1) + (x >> 1); if ((y < 2 || x < 2) && (pMBInter[IndexToLoc[i]] != NULL)) { RefFrArr [y][x] = pMBInter[IndexToLoc[i]]->pRefL0Idx [(y % 2) * 2 + (x % 2)]; } else { RefFrArr [y][x] = ARM_VCM4P10_INVALID_BLOCK; } } } for (y = 0; y < 4; y++) { for (x = 0; x < 4; x++) { MVPredArr [y][x].dx = 0; MVPredArr [y][x].dy = 0; } } /* * Motion Estimation for 8x8 MB Partition */ for (i = 0; i < 4; i++) { MotionCost8x8 [i] = 0; } pMBOptions = (OMXVCM4P10MEParams *) pMESpec; if (pMBOptions->blockSplitEnable8x8 == 1 && pMBOptions->blockSplitEnable4x4 == 1) { pSrcDstMBCurr->mbType = OMX_VC_P_8x8; PartWidth = PartSz [0][0]; PartHeight = PartSz [0][1]; /* For each 8x8 partitions */ for (Block8x8 = 0; Block8x8 < 4; Block8x8++) { PartStartX = (Block8x8 % 2) << 3; PartStartY = (Block8x8 / 2) << 3; Block2x = (Block8x8 & 1) << 1; Block2y = (Block8x8 >> 1) << 1; BestCost = ARM_VCM4P10_MAX_COST; for (mode = 0; mode < 3; mode++) { BlockWidth = BlkSz [mode][0]; BlockHeight = BlkSz [mode][1]; armVCM4P10_PartitionME ( pSrcCurrBuf, SrcCurrStep, pSrcRefBufList, SrcRefStep, pRefRect, pCurrPointPos, pMESpec, PartWidth, PartHeight, BlockWidth, BlockHeight, PartStartX, PartStartY, MVArr, RefFrArr, MVPredArr, Lambda, &Cost); if (Cost <= BestCost) { /* Update cost */ BestCost = Cost; /* Update MBCurr struct */ pSrcDstMBCurr->subMBType [Block8x8] = ModeSubMBType4x4 [mode]; pSrcDstMBCurr->pRefL0Idx [Block8x8] = RefFrArr [2 + (PartStartY >> 3)][2 + (PartStartX >> 3)]; /* Update pMV0 and pMVPred of MBCurr struct */ for (j = 0; j < 2; j++) { for (i = 0; i < 2; i++) { pSrcDstMBCurr->pMV0 [Block2y + j][Block2x + i].dx = MVArr [4 + Block2y + j][4 + Block2x + i].dx; pSrcDstMBCurr->pMV0 [Block2y + j][Block2x + i].dy = MVArr [4 + Block2y + j][4 + Block2x + i].dy; pSrcDstMBCurr->pMVPred [Block2y + j][Block2x + i].dx = MVPredArr [Block2y + j][Block2x + i].dx; pSrcDstMBCurr->pMVPred [Block2y + j][Block2x + i].dy = MVPredArr [Block2y + j][Block2x + i].dy; } } } } /* Update cost */ MotionCost8x8 [Block8x8] = BestCost; } /* Cost for mbType OMX_VC_P_8x8 */ BestCost = 0; for (i = 0; i < 4; i++) { BestCost += MotionCost8x8 [i]; } } else { /* Set sub MB type to 8x8 */ for (i = 0; i < 4; i++) { pSrcDstMBCurr->subMBType [i] = OMX_VC_SUB_P_8x8; } } /* * Motion Estimation for 8x8, 8x16, 16x8 and 16x16 MB Partition * If pMBOptions->b8x8BlockSplitEnable is 0, do only 16x16 ME (mode 3) */ for (mode = (pMBOptions->blockSplitEnable8x8 == 1 ? 0 : 3); mode < 4; mode++) { BlockWidth = PartWidth = PartSz [mode][0]; BlockHeight = PartHeight = PartSz [mode][1]; XPerMB = 16 / PartWidth; YPerMB = 16 / PartHeight; MaxPart = XPerMB * YPerMB; MBCost = 0; /* part size 4, 2, 2 and 1 corresponding to 8x8, 8x16, 16x8 and 16x16 MB */ for (part = 0; part < MaxPart; part++) { PartStartX = (part % XPerMB) * PartWidth; PartStartY = (part / XPerMB) * PartHeight; armVCM4P10_PartitionME ( pSrcCurrBuf, SrcCurrStep, pSrcRefBufList, SrcRefStep, pRefRect, pCurrPointPos, pMESpec, PartWidth, PartHeight, BlockWidth, BlockHeight, PartStartX, PartStartY, MVArr, RefFrArr, MVPredArr, Lambda, &Cost); MBCost += Cost; } if (MBCost <= BestCost) { /* Update cost */ BestCost = MBCost; /* Update mbType of MBCurr struct */ pSrcDstMBCurr->mbType = ModeMBType [mode]; /* Update pMV0 and pMVPred of MBCurr struct */ for (j = 0; j < 4; j++) { for (i = 0; i < 4; i++) { pSrcDstMBCurr->pMV0 [j][i].dx = MVArr [4+j][4+i].dx; pSrcDstMBCurr->pMV0 [j][i].dy = MVArr [4+j][4+i].dy; pSrcDstMBCurr->pMVPred [j][i].dx = MVPredArr [j][i].dx; pSrcDstMBCurr->pMVPred [j][i].dy = MVPredArr [j][i].dy; } } for (j = 0; j < 2; j++) { for (i = 0; i < 2; i++) { pSrcDstMBCurr->pRefL0Idx [j*2+i] = RefFrArr [2+j][2+i]; } } } } /* Update Best Cost */ *pDstCost = BestCost; return OMX_Sts_NoErr; } /** * Function: omxVCM4P10_MotionEstimationMB (6.3.5.3.1) * * Description: * Performs MB-level motion estimation and selects best motion estimation * strategy from the set of modes supported in baseline profile [ISO14496-10]. * * Input Arguments: * * pSrcCurrBuf - Pointer to the current position in original picture plane; * 16-byte alignment required * pSrcRefBufList - Pointer to an array with 16 entries. Each entry points * to the top-left corner of the co-located MB in a reference * picture. The array is filled from low-to-high with valid * reference frame pointers; the unused high entries should be set * to NULL. Ordering of the reference frames should follow * [ISO14496-10] subclause 8.2.4 Decoding Process for Reference * Picture Lists. The entries must be 16-byte aligned. * pSrcRecBuf - Pointer to the top-left corner of the co-located MB in the * reconstructed picture; must be 16-byte aligned. * SrcCurrStep - Width of the original picture plane in terms of full * pixels; must be a multiple of 16. * SrcRefStep - Width of the reference picture plane in terms of full * pixels; must be a multiple of 16. * SrcRecStep - Width of the reconstructed picture plane in terms of full * pixels; must be a multiple of 16. * pRefRect - Pointer to the valid reference rectangle; relative to the * image origin. * pCurrPointPos - Position of the current macroblock in the current plane. * Lambda - Lagrange factor for computing the cost function * pMESpec - Pointer to the motion estimation specification structure; must * have been allocated and initialized prior to calling this * function. * pMBInter - Array, of dimension four, containing pointers to information * associated with four adjacent type INTER MBs (Left, Top, * Top-Left, Top-Right). Any pointer in the array may be set equal * to NULL if the corresponding MB doesn t exist or is not of type * INTER. pMBInter[0] - Pointer to left MB information pMBInter[1] * - Pointer to top MB information pMBInter[2] - Pointer to * top-left MB information pMBInter[3] - Pointer to top-right MB * information * pMBIntra - Array, of dimension four, containing pointers to information * associated with four adjacent type INTRA MBs (Left, Top, * Top-Left, Top-Right). Any pointer in the array may be set equal * to NULL if the corresponding MB doesn t exist or is not of type * INTRA. pMBIntra[0] - Pointer to left MB information pMBIntra[1] * - Pointer to top MB information pMBIntra[2] - Pointer to * top-left MB information pMBIntra[3] - Pointer to top-right MB * information * 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. * * Output Arguments: * * pDstCost - Pointer to the minimum motion cost for the current MB. * pDstBlockSAD - Pointer to the array of SADs for each of the sixteen luma * 4x4 blocks in each MB. The block SADs are in scan order for * each MB. For implementations that cannot compute the SAD values * individually, the maximum possible value (0xffff) is returned * for each of the 16 block SAD entries. * pSrcDstMBCurr - Pointer to updated information structure for the current * MB after MB-level motion estimation has been completed. The * following fields are updated by the ME function. The following * parameter set quantifies the MB-level ME search results: MbType * subMBType[4] pMV0[4][4] pMVPred[4][4] pRefL0Idx[4] * Intra16x16PredMode pIntra4x4PredMode[4][4] * * Return Value: * OMX_Sts_NoErr, if the function runs without error. * OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs: * - One of more of the following pointers is NULL: pSrcCurrBuf, * pSrcRefBufList, pSrcRecBuf, pRefRect, pCurrPointPos, pMESpec, * pMBInter, pMBIntra,pSrcDstMBCurr, pDstCost, pSrcRefBufList[0] * - SrcRefStep, SrcRecStep are not multiples of 16 * - iBlockWidth or iBlockHeight are values other than 4, 8, or 16. * - Any alignment restrictions are violated * */ OMXResult omxVCM4P10_MotionEstimationMB( const OMX_U8 *pSrcCurrBuf, OMX_S32 SrcCurrStep, const OMX_U8 *pSrcRefBufList[ARM_VCM4P10_MAX_FRAMES], OMX_S32 SrcRefStep, const OMX_U8 *pSrcRecBuf, OMX_S32 SrcRecStep, const OMXRect *pRefRect, const OMXVCM4P2Coordinate *pCurrPointPos, OMX_U32 Lambda, void *pMESpec, const OMXVCM4P10MBInfoPtr *pMBInter, const OMXVCM4P10MBInfoPtr *pMBIntra, OMXVCM4P10MBInfo *pSrcDstMBCurr, OMX_INT *pDstCost, OMX_U16 *pDstBlockSAD) { OMX_U32 Cost, i, IntraFlag = 1; OMXVCM4P10MEParams *pMEParams; /* check for argument error */ armRetArgErrIf(pSrcCurrBuf == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pSrcRefBufList == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pSrcRecBuf == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pRefRect == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pCurrPointPos == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pMESpec == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pMBInter == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pMBIntra == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pSrcDstMBCurr == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(pDstCost == NULL, OMX_Sts_BadArgErr) armRetArgErrIf(SrcRefStep <= 0 || SrcRefStep & 15, OMX_Sts_BadArgErr) armRetArgErrIf(SrcRecStep <= 0 || SrcRecStep & 15, OMX_Sts_BadArgErr) armRetArgErrIf(SrcCurrStep <= 0 || SrcCurrStep & 15, OMX_Sts_BadArgErr) armRetArgErrIf(armNot16ByteAligned(pSrcCurrBuf), OMX_Sts_BadArgErr) armRetArgErrIf(armNot16ByteAligned(pSrcRecBuf), OMX_Sts_BadArgErr) for (i = 0; i < ARM_VCM4P10_MAX_FRAMES; i++) { armRetArgErrIf(pSrcRefBufList [i] != NULL && armNot16ByteAligned(pSrcRefBufList [i]), OMX_Sts_BadArgErr) /* Check if current MB needs INTER cost calculations */ if (pSrcRefBufList [i] != NULL && IntraFlag == 1) { IntraFlag = 0; } } *pDstCost = ARM_VCM4P10_MAX_COST; /* * Inter cost calculations */ /* check this MB can be Inter */ if (IntraFlag != 1) { armVCM4P10_InterMEMB( pSrcCurrBuf, SrcCurrStep, pSrcRefBufList, SrcRefStep, pRefRect, pCurrPointPos, Lambda, pMESpec, pMBInter, pSrcDstMBCurr, &Cost ); *pDstCost = Cost; } pMEParams = (OMXVCM4P10MEParams *)pMESpec; if (pMEParams->intraEnable4x4 == 1) { /* * Intra 4x4 cost calculations */ armVCM4P10_Intra4x4Estimation( pSrcCurrBuf, SrcCurrStep, pSrcRecBuf, SrcRecStep, pMBIntra, pSrcDstMBCurr, &Cost ); if (Cost <= *pDstCost) { *pDstCost = Cost; pSrcDstMBCurr->mbType = OMX_VC_INTRA_4x4; } } /* * Cost for Intra 16x16 mode */ armVCM4P10_Intra16x16Estimation( pSrcCurrBuf, SrcCurrStep, pSrcRecBuf, SrcRecStep, pCurrPointPos, pMBInter, pMBIntra, pSrcDstMBCurr, &Cost ); if (Cost <= *pDstCost) { *pDstCost = Cost; pSrcDstMBCurr->mbType = OMX_VC_INTRA_16x16; } /* * Update pDstBlockSAD to max value */ armVCM4P10_CalculateBlockSAD( pSrcDstMBCurr, pSrcCurrBuf, SrcCurrStep, pSrcRefBufList, SrcRefStep, pSrcRecBuf, SrcRecStep, pRefRect, pCurrPointPos, pMBInter, pMBIntra, pDstBlockSAD); return OMX_Sts_NoErr; } /***************************************************************************** * END OF FILE *****************************************************************************/