| /* |
| * 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_PredictIntraChroma_8x8.c |
| * OpenMAX DL: v1.0.2 |
| * Revision: 9641 |
| * Date: Thursday, February 7, 2008 |
| * |
| * |
| * |
| * |
| * H.264 Chroma 8x8 intra prediction module |
| * |
| */ |
| |
| #include "omxtypes.h" |
| #include "armOMX.h" |
| #include "omxVC.h" |
| |
| #include "armCOMM.h" |
| #include "armVC.h" |
| |
| /* |
| * Description: |
| * Perform DC style intra prediction, upper block has priority |
| * |
| * Parameters: |
| * [in] pSrcLeft Pointer to the buffer of 16 left coefficients: |
| * p[x, y] (x = -1, y = 0..3) |
| * [in] pSrcAbove Pointer to the buffer of 16 above coefficients: |
| * p[x,y] (x = 0..3, y = -1) |
| * [in] leftStep Step of left coefficient buffer |
| * [in] dstStep Step of the destination buffer |
| * [in] availability Neighboring 16x16 MB availability flag |
| * [out] pDst Pointer to the destination buffer |
| * |
| * Return Value: |
| * None |
| */ |
| |
| static void armVCM4P10_PredictIntraDCUp4x4( |
| const OMX_U8* pSrcLeft, |
| const OMX_U8 *pSrcAbove, |
| OMX_U8* pDst, |
| OMX_INT leftStep, |
| OMX_INT dstStep, |
| OMX_S32 availability |
| ) |
| { |
| int x, y, Sum=0, Count = 0; |
| |
| if (availability & OMX_VC_UPPER) |
| { |
| for (x=0; x<4; x++) |
| { |
| Sum += pSrcAbove[x]; |
| } |
| Count++; |
| } |
| else if (availability & OMX_VC_LEFT) |
| { |
| for (y=0; y<4; y++) |
| { |
| Sum += pSrcLeft[y*leftStep]; |
| } |
| Count++; |
| } |
| if (Count==0) |
| { |
| Sum = 128; |
| } |
| else |
| { |
| Sum = (Sum + 2) >> 2; |
| } |
| for (y=0; y<4; y++) |
| { |
| for (x=0; x<4; x++) |
| { |
| pDst[y*dstStep+x] = (OMX_U8)Sum; |
| } |
| } |
| } |
| |
| /* |
| * Description: |
| * Perform DC style intra prediction, left block has priority |
| * |
| * Parameters: |
| * [in] pSrcLeft Pointer to the buffer of 16 left coefficients: |
| * p[x, y] (x = -1, y = 0..3) |
| * [in] pSrcAbove Pointer to the buffer of 16 above coefficients: |
| * p[x,y] (x = 0..3, y = -1) |
| * [in] leftStep Step of left coefficient buffer |
| * [in] dstStep Step of the destination buffer |
| * [in] availability Neighboring 16x16 MB availability flag |
| * [out] pDst Pointer to the destination buffer |
| * |
| * Return Value: |
| * None |
| */ |
| |
| static void armVCM4P10_PredictIntraDCLeft4x4( |
| const OMX_U8* pSrcLeft, |
| const OMX_U8 *pSrcAbove, |
| OMX_U8* pDst, |
| OMX_INT leftStep, |
| OMX_INT dstStep, |
| OMX_S32 availability |
| ) |
| { |
| int x, y, Sum=0, Count = 0; |
| |
| if (availability & OMX_VC_LEFT) |
| { |
| for (y=0; y<4; y++) |
| { |
| Sum += pSrcLeft[y*leftStep]; |
| } |
| Count++; |
| } |
| else if (availability & OMX_VC_UPPER) |
| { |
| for (x=0; x<4; x++) |
| { |
| Sum += pSrcAbove[x]; |
| } |
| Count++; |
| } |
| if (Count==0) |
| { |
| Sum = 128; |
| } |
| else |
| { |
| Sum = (Sum + 2) >> 2; |
| } |
| for (y=0; y<4; y++) |
| { |
| for (x=0; x<4; x++) |
| { |
| pDst[y*dstStep+x] = (OMX_U8)Sum; |
| } |
| } |
| } |
| |
| /** |
| * Function: omxVCM4P10_PredictIntraChroma_8x8 (6.3.3.1.3) |
| * |
| * Description: |
| * Performs intra prediction for chroma samples. |
| * |
| * Input Arguments: |
| * |
| * pSrcLeft - Pointer to the buffer of 8 left pixels: p[x, y] (x = -1, y= |
| * 0..7). |
| * pSrcAbove - Pointer to the buffer of 8 above pixels: p[x,y] (x = 0..7, y |
| * = -1); must be aligned on an 8-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 8. |
| * dstStep - Step of the destination buffer; must be a multiple of 8. |
| * predMode - Intra chroma prediction mode, please refer to section 3.4.3. |
| * availability - Neighboring chroma block availability flag, please refer |
| * to "Neighboring Macroblock Availability". |
| * |
| * Output Arguments: |
| * |
| * pDst - Pointer to the destination buffer; must be aligned on an 8-byte |
| * boundary. |
| * |
| * Return Value: |
| * If the function runs without error, it returns OMX_Sts_NoErr. |
| * If any of the following cases occurs, the function returns |
| * OMX_Sts_BadArgErr: |
| * pDst is NULL. |
| * dstStep < 8 or dstStep is not a multiple of 8. |
| * leftStep is not a multiple of 8. |
| * predMode is not in the valid range of enumeration |
| * OMXVCM4P10IntraChromaPredMode. |
| * predMode is OMX_VC_CHROMA_VERT, but availability doesn't set |
| * OMX_VC_UPPER indicating p[x,-1] (x = 0..7) is not available. |
| * predMode is OMX_VC_CHROMA_HOR, but availability doesn't set OMX_VC_LEFT |
| * indicating p[-1,y] (y = 0..7) is not available. |
| * predMode is OMX_VC_CHROMA_PLANE, but availability doesn't set |
| * OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating |
| * p[x,-1](x = 0..7), or p[-1,y] (y = 0..7), or p[-1,-1] 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 8-byte boundary. Note: |
| * pSrcAbove, pSrcAbove, pSrcAboveLeft may be invalid pointer if |
| * they are not used by intra prediction implied in predMode. |
| * Note: OMX_VC_UPPER_RIGHT is not used in intra chroma |
| * prediction. |
| * |
| */ |
| OMXResult omxVCM4P10_PredictIntraChroma_8x8( |
| const OMX_U8* pSrcLeft, |
| const OMX_U8 *pSrcAbove, |
| const OMX_U8 *pSrcAboveLeft, |
| OMX_U8* pDst, |
| OMX_INT leftStep, |
| OMX_INT dstStep, |
| OMXVCM4P10IntraChromaPredMode predMode, |
| OMX_S32 availability |
| ) |
| { |
| int x, y, Sum; |
| int H, V, a, b, c; |
| |
| armRetArgErrIf(pDst == NULL, OMX_Sts_BadArgErr); |
| armRetArgErrIf(dstStep < 8, OMX_Sts_BadArgErr); |
| armRetArgErrIf((dstStep % 8) != 0, OMX_Sts_BadArgErr); |
| armRetArgErrIf((leftStep % 8) != 0, OMX_Sts_BadArgErr); |
| armRetArgErrIf(armNot8ByteAligned(pSrcAbove), OMX_Sts_BadArgErr); |
| armRetArgErrIf(armNot8ByteAligned(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_CHROMA_VERT && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); |
| armRetArgErrIf(predMode==OMX_VC_CHROMA_HOR && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); |
| armRetArgErrIf(predMode==OMX_VC_CHROMA_PLANE && !(availability & OMX_VC_UPPER), OMX_Sts_BadArgErr); |
| armRetArgErrIf(predMode==OMX_VC_CHROMA_PLANE && !(availability & OMX_VC_UPPER_LEFT), OMX_Sts_BadArgErr); |
| armRetArgErrIf(predMode==OMX_VC_CHROMA_PLANE && !(availability & OMX_VC_LEFT), OMX_Sts_BadArgErr); |
| armRetArgErrIf((unsigned)predMode > OMX_VC_CHROMA_PLANE, OMX_Sts_BadArgErr); |
| |
| switch (predMode) |
| { |
| case OMX_VC_CHROMA_DC: |
| armVCM4P10_PredictIntraDC4x4( pSrcLeft, pSrcAbove, pDst, leftStep, dstStep, availability); |
| armVCM4P10_PredictIntraDCUp4x4( pSrcLeft, pSrcAbove+4, pDst+4, leftStep, dstStep, availability); |
| armVCM4P10_PredictIntraDCLeft4x4( pSrcLeft+4*leftStep, pSrcAbove, pDst+4*dstStep, leftStep, dstStep, availability); |
| armVCM4P10_PredictIntraDC4x4( pSrcLeft+4*leftStep, pSrcAbove+4, pDst+4+4*dstStep, leftStep, dstStep, availability); |
| break; |
| |
| case OMX_VC_CHROMA_HOR: |
| for (y=0; y<8; y++) |
| { |
| for (x=0; x<8; x++) |
| { |
| pDst[y*dstStep+x] = pSrcLeft[y*leftStep]; |
| } |
| } |
| break; |
| |
| case OMX_VC_CHROMA_VERT: |
| for (y=0; y<8; y++) |
| { |
| for (x=0; x<8; x++) |
| { |
| pDst[y*dstStep+x] = pSrcAbove[x]; |
| } |
| } |
| break; |
| |
| case OMX_VC_CHROMA_PLANE: |
| H = 4*(pSrcAbove[7] - pSrcAboveLeft[0]); |
| for (x=2; x>=0; x--) |
| { |
| H += (x+1)*(pSrcAbove[4+x] - pSrcAbove[2-x]); |
| } |
| V = 4*(pSrcLeft[7*leftStep] - pSrcAboveLeft[0]); |
| for (y=2; y>=0; y--) |
| { |
| V += (y+1)*(pSrcLeft[(4+y)*leftStep] - pSrcLeft[(2-y)*leftStep]); |
| } |
| a = 16*(pSrcAbove[7] + pSrcLeft[7*leftStep]); |
| b = (17*H+16)>>5; |
| c = (17*V+16)>>5; |
| for (y=0; y<8; y++) |
| { |
| for (x=0; x<8; x++) |
| { |
| Sum = (a + b*(x-3) + c*(y-3) + 16)>>5; |
| pDst[y*dstStep+x] = (OMX_U8)armClip(0,255,Sum); |
| } |
| } |
| break; |
| } |
| |
| return OMX_Sts_NoErr; |
| } |
