/* * Copyright (C) 2007-2008 ARM Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ /** * * File Name: omxVCM4P2_TransRecBlockCoef_intra.c * OpenMAX DL: v1.0.2 * Revision: 9641 * Date: Thursday, February 7, 2008 * * * * * Description: * Contains modules DCT->quant and reconstructing the intra texture data * */ #include "omxtypes.h" #include "armOMX.h" #include "omxVC.h" #include "armCOMM.h" #include "armVC.h" /** * Function: omxVCM4P2_TransRecBlockCoef_intra (6.2.4.4.4) * * Description: * Quantizes the DCT coefficients, implements intra block AC/DC coefficient * prediction, and reconstructs the current intra block texture for prediction * on the next frame. Quantized row and column coefficients are returned in * the updated coefficient buffers. * * Input Arguments: * * pSrc - pointer to the pixels of current intra block; must be aligned on * an 8-byte boundary. * pPredBufRow - pointer to the coefficient row buffer containing * ((num_mb_per_row * 2 + 1) * 8) elements of type OMX_S16. * Coefficients are organized into blocks of eight as described * below (Internal Prediction Coefficient Update Procedures). The * DC coefficient is first, and the remaining buffer locations * contain the quantized AC coefficients. Each group of eight row * buffer elements combined with one element eight elements ahead * contains the coefficient predictors of the neighboring block * that is spatially above or to the left of the block currently to * be decoded. A negative-valued DC coefficient indicates that this * neighboring block is not INTRA-coded or out of bounds, and * therefore the AC and DC coefficients are invalid. Pointer must * be aligned on an 8-byte boundary. * pPredBufCol - pointer to the prediction coefficient column buffer * containing 16 elements of type OMX_S16. Coefficients are * organized as described in section 6.2.2.5. Pointer must be * aligned on an 8-byte boundary. * pSumErr - pointer to a flag indicating whether or not AC prediction is * required; AC prediction is enabled if *pSumErr >=0, but the * value is not used for coefficient prediction, i.e., the sum of * absolute differences starts from 0 for each call to this * function. Otherwise AC prediction is disabled if *pSumErr < 0 . * blockIndex - block index indicating the component type and position, as * defined in [ISO14496-2], subclause 6.1.3.8. * curQp - quantization parameter of the macroblock to which the current * block belongs * pQpBuf - pointer to a 2-element quantization parameter buffer; pQpBuf[0] * contains the quantization parameter associated with the 8x8 * block left of the current block (QPa), and pQpBuf[1] contains * the quantization parameter associated with the 8x8 block above * the current block (QPc). In the event that the corresponding * block is outside of the VOP bound, the Qp value will not affect * the intra prediction process, as described in [ISO14496-2], * sub-clause 7.4.3.3, Adaptive AC Coefficient Prediction. * srcStep - width of the source buffer; must be a multiple of 8. * dstStep - width of the reconstructed destination buffer; must be a * multiple of 16. * shortVideoHeader - binary flag indicating presence of * short_video_header; shortVideoHeader==1 selects linear intra DC * mode, and shortVideoHeader==0 selects non linear intra DC mode. * * Output Arguments: * * pDst - pointer to the quantized DCT coefficient buffer; pDst[0] contains * the predicted DC coefficient; the remaining entries contain the * quantized AC coefficients (without prediction). The pointer * pDstmust be aligned on a 16-byte boundary. * pRec - pointer to the reconstructed texture; must be aligned on an * 8-byte boundary. * pPredBufRow - pointer to the updated coefficient row buffer * pPredBufCol - pointer to the updated coefficient column buffer * pPreACPredict - if prediction is enabled, the parameter points to the * start of the buffer containing the coefficient differences for * VLC encoding. The entry pPreACPredict[0]indicates prediction * direction for the current block and takes one of the following * values: OMX_VC_NONE (prediction disabled), OMX_VC_HORIZONTAL, or * OMX_VC_VERTICAL. The entries * pPreACPredict[1]-pPreACPredict[7]contain predicted AC * coefficients. If prediction is disabled (*pSumErr<0) then the * contents of this buffer are undefined upon return from the * function * pSumErr - pointer to the value of the accumulated AC coefficient errors, * i.e., sum of the absolute differences between predicted and * unpredicted AC coefficients * * Return Value: * * OMX_Sts_NoErr - no error * OMX_Sts_BadArgErr - Bad arguments: * - At least one of the following pointers is NULL: pSrc, pDst, pRec, * pCoefBufRow, pCoefBufCol, pQpBuf, pPreACPredict, pSumErr. * - blockIndex < 0 or blockIndex >= 10; * - curQP <= 0 or curQP >= 32. * - srcStep, or dstStep <= 0 or not a multiple of 8. * - pDst is not 16-byte aligned: . * - At least one of the following pointers is not 8-byte aligned: * pSrc, pRec. * * Note: The coefficient buffers must be updated in accordance with the * update procedures defined in section in 6.2.2. * */ OMXResult omxVCM4P2_TransRecBlockCoef_intra( const OMX_U8 *pSrc, OMX_S16 * pDst, OMX_U8 * pRec, OMX_S16 *pPredBufRow, OMX_S16 *pPredBufCol, OMX_S16 * pPreACPredict, OMX_INT *pSumErr, OMX_INT blockIndex, OMX_U8 curQp, const OMX_U8 *pQpBuf, OMX_INT srcStep, OMX_INT dstStep, OMX_INT shortVideoHeader ) { /* 64 elements are needed but to align it to 16 bytes need 8 more elements of padding */ OMX_S16 tempBuf1[79], tempBuf2[79]; OMX_S16 tempBuf3[79]; OMX_S16 *pTempBuf1, *pTempBuf2,*pTempBuf3; OMXVCM4P2VideoComponent videoComp; OMX_U8 flag; OMX_INT x, y, count, predDir; OMX_INT predQP, ACPredFlag; /* Aligning the local buffers */ pTempBuf1 = armAlignTo16Bytes(tempBuf1); pTempBuf2 = armAlignTo16Bytes(tempBuf2); pTempBuf3 = armAlignTo16Bytes(tempBuf3); /* Argument error checks */ armRetArgErrIf(pSrc == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pRec == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pDst == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(!armIs8ByteAligned(pSrc), OMX_Sts_BadArgErr); armRetArgErrIf(!armIs8ByteAligned(pRec), OMX_Sts_BadArgErr); armRetArgErrIf(!armIs16ByteAligned(pDst), OMX_Sts_BadArgErr); armRetArgErrIf(pPredBufRow == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pPredBufCol == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pPreACPredict == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pSumErr == NULL, OMX_Sts_BadArgErr); armRetArgErrIf(pQpBuf == NULL, OMX_Sts_BadArgErr); armRetArgErrIf((srcStep <= 0) || (dstStep <= 0) || (dstStep & 7) || (srcStep & 7) , OMX_Sts_BadArgErr); armRetArgErrIf((blockIndex < 0) || (blockIndex > 9), OMX_Sts_BadArgErr); armRetArgErrIf((curQp <= 0) || (curQp >=32), OMX_Sts_BadArgErr); /* Setting the videoComp */ if (blockIndex <= 3) { videoComp = OMX_VC_LUMINANCE; } else { videoComp = OMX_VC_CHROMINANCE; } /* Converting from 2-d to 1-d buffer */ for (y = 0, count = 0; y < 8; y++) { for(x= 0; x < 8; x++, count++) { pTempBuf1[count] = pSrc[(y*srcStep) + x]; } } omxVCM4P2_DCT8x8blk (pTempBuf1, pTempBuf2); omxVCM4P2_QuantIntra_I( pTempBuf2, curQp, blockIndex, shortVideoHeader); /* Converting from 1-D to 2-D buffer */ for (y = 0, count = 0; y < 8; y++) { for(x = 0; x < 8; x++, count++) { /* storing tempbuf2 to tempbuf1 */ pTempBuf1[count] = pTempBuf2[count]; pDst[(y*dstStep) + x] = pTempBuf2[count]; } } /* AC and DC prediction */ armVCM4P2_SetPredDir( blockIndex, pPredBufRow, pPredBufCol, &predDir, &predQP, pQpBuf); armRetDataErrIf(((predQP <= 0) || (predQP >= 32)), OMX_Sts_BadArgErr); flag = 1; if (*pSumErr < 0) { ACPredFlag = 0; } else { ACPredFlag = 1; } armVCM4P2_ACDCPredict( pTempBuf2, pPreACPredict, pPredBufRow, pPredBufCol, curQp, predQP, predDir, ACPredFlag, videoComp, flag, pSumErr); /* Reconstructing the texture data */ omxVCM4P2_QuantInvIntra_I( pTempBuf1, curQp, videoComp, shortVideoHeader); omxVCM4P2_IDCT8x8blk (pTempBuf1, pTempBuf3); for(count = 0; count < 64; count++) { pRec[count] = armMax(0,pTempBuf3[count]); } return OMX_Sts_NoErr; } /* End of file */