/* * Copyright (C) 2007-2008 ARM Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ /* ---------------------------------------------------------------- * * * File Name: omxVCM4P10_PredictIntra_4x4.c * OpenMAX DL: v1.0.2 * Revision: 9641 * Date: Thursday, February 7, 2008 * * * * * H.264 4x4 intra prediction module * */ #include "omxtypes.h" #include "armOMX.h" #include "omxVC.h" #include "armCOMM.h" #include "armVC.h" /** * Function: omxVCM4P10_PredictIntra_4x4 (6.3.3.1.1) * * Description: * Perform Intra_4x4 prediction for luma samples. If the upper-right block is * not available, then duplication work should be handled inside the function. * Users need not define them outside. * * Input Arguments: * * pSrcLeft - Pointer to the buffer of 4 left pixels: * p[x, y] (x = -1, y = 0..3) * pSrcAbove - Pointer to the buffer of 8 above pixels: * p[x,y] (x = 0..7, y =-1); * must be aligned on a 4-byte boundary. * pSrcAboveLeft - Pointer to the above left pixels: p[x,y] (x = -1, y = -1) * leftStep - Step of left pixel buffer; must be a multiple of 4. * dstStep - Step of the destination buffer; must be a multiple of 4. * predMode - Intra_4x4 prediction mode. * availability - Neighboring 4x4 block availability flag, refer to * "Neighboring Macroblock Availability" . * * Output Arguments: * * pDst - Pointer to the destination buffer; must be aligned on a 4-byte * boundary. * * Return Value: * If the function runs without error, it returns OMX_Sts_NoErr. * If one of the following cases occurs, the function returns * OMX_Sts_BadArgErr: * pDst is NULL. * dstStep < 4, or dstStep is not a multiple of 4. * leftStep is not a multiple of 4. * predMode is not in the valid range of enumeration * OMXVCM4P10Intra4x4PredMode. * predMode is OMX_VC_4x4_VERT, but availability doesn't set OMX_VC_UPPER * indicating p[x,-1] (x = 0..3) is not available. * predMode is OMX_VC_4x4_HOR, but availability doesn't set OMX_VC_LEFT * indicating p[-1,y] (y = 0..3) is not available. * predMode is OMX_VC_4x4_DIAG_DL, but availability doesn't set * OMX_VC_UPPER indicating p[x, 1] (x = 0..3) is not available. * predMode is OMX_VC_4x4_DIAG_DR, but availability doesn't set * OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating * p[x,-1] (x = 0..3), or p[-1,y] (y = 0..3) or p[-1,-1] is not * available. * predMode is OMX_VC_4x4_VR, but availability doesn't set * OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating * p[x,-1] (x = 0..3), or p[-1,y] (y = 0..3) or p[-1,-1] is not * available. * predMode is OMX_VC_4x4_HD, but availability doesn't set * OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating * p[x,-1] (x = 0..3), or p[-1,y] (y = 0..3) or p[-1,-1] is not * available. * predMode is OMX_VC_4x4_VL, but availability doesn't set OMX_VC_UPPER * indicating p[x,-1] (x = 0..3) is not available. * predMode is OMX_VC_4x4_HU, but availability doesn't set OMX_VC_LEFT * indicating p[-1,y] (y = 0..3) is not available. * availability sets OMX_VC_UPPER, but pSrcAbove is NULL. * availability sets OMX_VC_LEFT, but pSrcLeft is NULL. * availability sets OMX_VC_UPPER_LEFT, but pSrcAboveLeft is NULL. * either pSrcAbove or pDst is not aligned on a 4-byte boundary. * * Note: * pSrcAbove, pSrcAbove, pSrcAboveLeft may be invalid pointers if * they are not used by intra prediction as implied in predMode. * */ OMXResult omxVCM4P10_PredictIntra_4x4( const OMX_U8* pSrcLeft, const OMX_U8 *pSrcAbove, const OMX_U8 *pSrcAboveLeft, OMX_U8* pDst, OMX_INT leftStep, OMX_INT dstStep, OMXVCM4P10Intra4x4PredMode predMode, OMX_S32 availability ) { int x, y; OMX_U8 pTmp[10]; armRetArgErrIf(pDst == NULL, OMX_Sts_BadArgErr); armRetArgErrIf((leftStep % 4) != 0, OMX_Sts_BadArgErr); armRetArgErrIf((dstStep % 4) != 0, OMX_Sts_BadArgErr); armRetArgErrIf((dstStep < 4), OMX_Sts_BadArgErr); armRetArgErrIf(armNot4ByteAligned(pSrcAbove), OMX_Sts_BadArgErr); armRetArgErrIf(armNot4ByteAligned(pDst), OMX_Sts_BadArgErr); armRetArgErrIf((availability & OMX_VC_UPPER) && pSrcAbove == NULL, OMX_Sts_BadArgErr); armRetArgErrIf((availability & OMX_VC_LEFT ) && pSrcLeft == NULL, OMX_Sts_BadArgErr); armRetArgErrIf((availability & OMX_VC_UPPER_LEFT) && pSrcAboveLeft == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_VERT && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_HOR && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_DIAG_DL && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_DIAG_DR && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_DIAG_DR && !(availability & OMX_VC_UPPER_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_DIAG_DR && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_VR && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_VR && !(availability & OMX_VC_UPPER_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_VR && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_HD && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_HD && !(availability & OMX_VC_UPPER_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_HD && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_VL && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); armRetArgErrIf(predMode==OMX_VC_4X4_HU && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); armRetArgErrIf((unsigned)predMode > OMX_VC_4X4_HU, OMX_Sts_BadArgErr); /* Note: This code must not read the pSrc arrays unless the corresponding * block is marked as available. If the block is not avaibable then pSrc * may not be a valid pointer. * * Note: To make the code more readable we refer to the neighbouring pixels * in variables named as below: * * UL U0 U1 U2 U3 U4 U5 U6 U7 * L0 xx xx xx xx * L1 xx xx xx xx * L2 xx xx xx xx * L3 xx xx xx xx */ #define UL pSrcAboveLeft[0] #define U0 pSrcAbove[0] #define U1 pSrcAbove[1] #define U2 pSrcAbove[2] #define U3 pSrcAbove[3] #define U4 pSrcAbove[4] #define U5 pSrcAbove[5] #define U6 pSrcAbove[6] #define U7 pSrcAbove[7] #define L0 pSrcLeft[0*leftStep] #define L1 pSrcLeft[1*leftStep] #define L2 pSrcLeft[2*leftStep] #define L3 pSrcLeft[3*leftStep] switch (predMode) { case OMX_VC_4X4_VERT: for (y=0; y<4; y++) { pDst[y*dstStep+0] = U0; pDst[y*dstStep+1] = U1; pDst[y*dstStep+2] = U2; pDst[y*dstStep+3] = U3; } break; case OMX_VC_4X4_HOR: for (x=0; x<4; x++) { pDst[0*dstStep+x] = L0; pDst[1*dstStep+x] = L1; pDst[2*dstStep+x] = L2; pDst[3*dstStep+x] = L3; } break; case OMX_VC_4X4_DC: /* This can always be used even if no blocks available */ armVCM4P10_PredictIntraDC4x4(pSrcLeft, pSrcAbove, pDst, leftStep, dstStep, availability); break; case OMX_VC_4X4_DIAG_DL: pTmp[0] = (OMX_U8)((U0 + 2*U1 + U2 + 2)>>2); pTmp[1] = (OMX_U8)((U1 + 2*U2 + U3 + 2)>>2); if (availability & OMX_VC_UPPER_RIGHT) { pTmp[2] = (OMX_U8)((U2 + 2*U3 + U4 + 2)>>2); pTmp[3] = (OMX_U8)((U3 + 2*U4 + U5 + 2)>>2); pTmp[4] = (OMX_U8)((U4 + 2*U5 + U6 + 2)>>2); pTmp[5] = (OMX_U8)((U5 + 2*U6 + U7 + 2)>>2); pTmp[6] = (OMX_U8)((U6 + 3*U7 + 2)>>2); } else { pTmp[2] = (OMX_U8)((U2 + 3*U3 + 2)>>2); pTmp[3] = U3; pTmp[4] = U3; pTmp[5] = U3; pTmp[6] = U3; } for (y=0; y<4; y++) { for (x=0; x<4; x++) { pDst[y*dstStep+x] = pTmp[x+y]; } } break; case OMX_VC_4X4_DIAG_DR: /* x-y = -3, -2, -1, 0, 1, 2, 3 */ pTmp[0] = (OMX_U8)((L1 + 2*L2 + L3 + 2)>>2); pTmp[1] = (OMX_U8)((L0 + 2*L1 + L2 + 2)>>2); pTmp[2] = (OMX_U8)((UL + 2*L0 + L1 + 2)>>2); pTmp[3] = (OMX_U8)((U0 + 2*UL + L0 + 2)>>2); pTmp[4] = (OMX_U8)((U1 + 2*U0 + UL + 2)>>2); pTmp[5] = (OMX_U8)((U2 + 2*U1 + U0 + 2)>>2); pTmp[6] = (OMX_U8)((U3 + 2*U2 + U1 + 2)>>2); for (y=0; y<4; y++) { for (x=0; x<4; x++) { pDst[y*dstStep+x] = pTmp[3+x-y]; } } break; case OMX_VC_4X4_VR: /* zVR=2x-y = -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 * x-(y>>1) = -1, -1, 0, 0, 1, 1, 2, 2, 3, 3 * y = 3, 2, ?, ?, ?, ?, ?, ?, 1, 0 */ pTmp[0] = (OMX_U8)((L2 + 2*L1 + L0 + 2)>>2); pTmp[1] = (OMX_U8)((L1 + 2*L0 + UL + 2)>>2); pTmp[2] = (OMX_U8)((L0 + 2*UL + U0 + 2)>>2); pTmp[3] = (OMX_U8)((UL + U0 + 1)>>1); pTmp[4] = (OMX_U8)((UL + 2*U0 + U1 + 2)>>2); pTmp[5] = (OMX_U8)((U0 + U1 + 1)>>1); pTmp[6] = (OMX_U8)((U0 + 2*U1 + U2 + 2)>>2); pTmp[7] = (OMX_U8)((U1 + U2 + 1)>>1); pTmp[8] = (OMX_U8)((U1 + 2*U2 + U3 + 2)>>2); pTmp[9] = (OMX_U8)((U2 + U3 + 1)>>1); for (y=0; y<4; y++) { for (x=0; x<4; x++) { pDst[y*dstStep+x] = pTmp[3+2*x-y]; } } break; case OMX_VC_4X4_HD: /* zHD=2y-x = -3 -2 -1 0 1 2 3 4 5 6 * y-(x>>1) = -1 -1 0 0 1 1 2 2 3 3 * x = 3 2 1 0 */ pTmp[0] = (OMX_U8)((U2 + 2*U1 + U0 + 2)>>2); pTmp[1] = (OMX_U8)((U1 + 2*U0 + UL + 2)>>2); pTmp[2] = (OMX_U8)((U0 + 2*UL + L0 + 2)>>2); pTmp[3] = (OMX_U8)((UL + L0 + 1)>>1); pTmp[4] = (OMX_U8)((UL + 2*L0 + L1 + 2)>>2); pTmp[5] = (OMX_U8)((L0 + L1 + 1)>>1); pTmp[6] = (OMX_U8)((L0 + 2*L1 + L2 + 2)>>2); pTmp[7] = (OMX_U8)((L1 + L2 + 1)>>1); pTmp[8] = (OMX_U8)((L1 + 2*L2 + L3 + 2)>>2); pTmp[9] = (OMX_U8)((L2 + L3 + 1)>>1); for (y=0; y<4; y++) { for (x=0; x<4; x++) { pDst[y*dstStep+x] = pTmp[3+2*y-x]; } } break; case OMX_VC_4X4_VL: /* Note: x+(y>>1) = (2*x+y)>>1 * 2x+y = 0 1 2 3 4 5 6 7 8 9 */ pTmp[0] = (OMX_U8)((U0 + U1 + 1)>>1); pTmp[1] = (OMX_U8)((U0 + 2*U1 + U2 + 2)>>2); pTmp[2] = (OMX_U8)((U1 + U2 + 1)>>1); pTmp[3] = (OMX_U8)((U1 + 2*U2 + U3 + 2)>>2); pTmp[4] = (OMX_U8)((U2 + U3 + 1)>>1); if (availability & OMX_VC_UPPER_RIGHT) { pTmp[5] = (OMX_U8)((U2 + 2*U3 + U4 + 2)>>2); pTmp[6] = (OMX_U8)((U3 + U4 + 1)>>1); pTmp[7] = (OMX_U8)((U3 + 2*U4 + U5 + 2)>>2); pTmp[8] = (OMX_U8)((U4 + U5 + 1)>>1); pTmp[9] = (OMX_U8)((U4 + 2*U5 + U6 + 2)>>2); } else { pTmp[5] = (OMX_U8)((U2 + 3*U3 + 2)>>2); pTmp[6] = U3; pTmp[7] = U3; pTmp[8] = U3; pTmp[9] = U3; } for (y=0; y<4; y++) { for (x=0; x<4; x++) { pDst[y*dstStep+x] = pTmp[2*x+y]; } } break; case OMX_VC_4X4_HU: /* zHU = x+2*y */ pTmp[0] = (OMX_U8)((L0 + L1 + 1)>>1); pTmp[1] = (OMX_U8)((L0 + 2*L1 + L2 + 2)>>2); pTmp[2] = (OMX_U8)((L1 + L2 + 1)>>1); pTmp[3] = (OMX_U8)((L1 + 2*L2 + L3 + 2)>>2); pTmp[4] = (OMX_U8)((L2 + L3 + 1)>>1); pTmp[5] = (OMX_U8)((L2 + 3*L3 + 2)>>2); pTmp[6] = L3; pTmp[7] = L3; pTmp[8] = L3; pTmp[9] = L3; for (y=0; y<4; y++) { for (x=0; x<4; x++) { pDst[y*dstStep+x] = pTmp[x+2*y]; } } break; } return OMX_Sts_NoErr; }