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