| /* |
| * 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: armVCM4P2_ACDCPredict.c |
| * OpenMAX DL: v1.0.2 |
| * Revision: 9641 |
| * Date: Thursday, February 7, 2008 |
| * |
| * |
| * |
| * |
| * Description: |
| * Contains module for DC/AC coefficient prediction |
| * |
| */ |
| |
| #include "omxtypes.h" |
| #include "armOMX.h" |
| |
| #include "armVC.h" |
| #include "armCOMM.h" |
| |
| /** |
| * Function: armVCM4P2_ACDCPredict |
| * |
| * Description: |
| * Performs adaptive DC/AC coefficient prediction for an intra block. Prior |
| * to the function call, prediction direction (predDir) should be selected |
| * as specified in subclause 7.4.3.1 of ISO/IEC 14496-2. |
| * |
| * Remarks: |
| * |
| * Parameters: |
| * [in] pSrcDst pointer to the coefficient buffer which contains |
| * the quantized coefficient residuals (PQF) of the |
| * current block |
| * [in] pPredBufRow pointer to the coefficient row buffer |
| * [in] pPredBufCol pointer to the coefficient column buffer |
| * [in] curQP quantization parameter of the current block. curQP |
| * may equal to predQP especially when the current |
| * block and the predictor block are in the same |
| * macroblock. |
| * [in] predQP quantization parameter of the predictor block |
| * [in] predDir indicates the prediction direction which takes one |
| * of the following values: |
| * OMX_VC_HORIZONTAL predict horizontally |
| * OMX_VC_VERTICAL predict vertically |
| * [in] ACPredFlag a flag indicating if AC prediction should be |
| * performed. It is equal to ac_pred_flag in the bit |
| * stream syntax of MPEG-4 |
| * [in] videoComp video component type (luminance, chrominance or |
| * alpha) of the current block |
| * [in] flag This flag defines the if one wants to use this functions to |
| * calculate PQF (set 1, prediction) or QF (set 0, reconstruction) |
| * [out] pPreACPredict pointer to the predicted coefficients buffer. |
| * Filled ONLY if it is not NULL |
| * [out] pSrcDst pointer to the coefficient buffer which contains |
| * the quantized coefficients (QF) of the current |
| * block |
| * [out] pPredBufRow pointer to the updated coefficient row buffer |
| * [out] pPredBufCol pointer to the updated coefficient column buffer |
| * [out] pSumErr pointer to the updated sum of the difference |
| * between predicted and unpredicted coefficients |
| * If this is NULL, do not update |
| * |
| * Return Value: |
| * Standard OMXResult result. See enumeration for possible result codes. |
| * |
| */ |
| |
| OMXResult armVCM4P2_ACDCPredict( |
| OMX_S16 * pSrcDst, |
| OMX_S16 * pPreACPredict, |
| OMX_S16 * pPredBufRow, |
| OMX_S16 * pPredBufCol, |
| OMX_INT curQP, |
| OMX_INT predQP, |
| OMX_INT predDir, |
| OMX_INT ACPredFlag, |
| OMXVCM4P2VideoComponent videoComp, |
| OMX_U8 flag, |
| OMX_INT *pSumErr |
| ) |
| { |
| OMX_INT dcScaler, i; |
| OMX_S16 tempPred; |
| |
| /* Argument error checks */ |
| armRetArgErrIf(pSrcDst == NULL, OMX_Sts_BadArgErr); |
| armRetArgErrIf(pPredBufRow == NULL, OMX_Sts_BadArgErr); |
| armRetArgErrIf(pPredBufCol == NULL, OMX_Sts_BadArgErr); |
| armRetArgErrIf(curQP <= 0, OMX_Sts_BadArgErr); |
| armRetArgErrIf(predQP <= 0, OMX_Sts_BadArgErr); |
| armRetArgErrIf((predDir != 1) && (predDir != 2), OMX_Sts_BadArgErr); |
| armRetArgErrIf(!armIs4ByteAligned(pSrcDst), OMX_Sts_BadArgErr); |
| armRetArgErrIf(!armIs4ByteAligned(pPredBufRow), OMX_Sts_BadArgErr); |
| armRetArgErrIf(!armIs4ByteAligned(pPredBufCol), OMX_Sts_BadArgErr); |
| |
| |
| /* Set DC scaler value to avoid some compilers giving a warning. */ |
| dcScaler=0; |
| |
| /* Calculate the DC scaler value */ |
| if (videoComp == OMX_VC_LUMINANCE) |
| { |
| if (curQP >= 1 && curQP <= 4) |
| { |
| dcScaler = 8; |
| } |
| else if (curQP >= 5 && curQP <= 8) |
| { |
| dcScaler = 2 * curQP; |
| } |
| else if (curQP >= 9 && curQP <= 24) |
| { |
| dcScaler = curQP + 8; |
| } |
| else |
| { |
| dcScaler = (2 * curQP) - 16; |
| } |
| } |
| else if (videoComp == OMX_VC_CHROMINANCE) |
| { |
| if (curQP >= 1 && curQP <= 4) |
| { |
| dcScaler = 8; |
| } |
| else if (curQP >= 5 && curQP <= 24) |
| { |
| dcScaler = (curQP + 13)/2; |
| } |
| else |
| { |
| dcScaler = curQP - 6; |
| } |
| } |
| |
| if (pPreACPredict != NULL) |
| { |
| pPreACPredict[0] = predDir; |
| } |
| |
| if (predDir == OMX_VC_VERTICAL) |
| { |
| /* F[0][0]//dc_scaler */ |
| tempPred = armIntDivAwayFromZero(pPredBufRow[0], dcScaler); |
| } |
| else |
| { |
| /* F[0][0]//dc_scaler */ |
| tempPred = armIntDivAwayFromZero(pPredBufCol[0], dcScaler); |
| } |
| |
| /* Updating the DC value to the row and col buffer */ |
| *(pPredBufRow - 8) = *pPredBufCol; |
| |
| if (flag) |
| { |
| /* Cal and store F[0][0] into the col buffer */ |
| *pPredBufCol = pSrcDst[0] * dcScaler; |
| |
| /* PQF = QF - F[0][0]//dc_scaler */ |
| pSrcDst[0] -= tempPred; |
| } |
| else |
| { |
| /* QF = PQF + F[0][0]//dc_scaler */ |
| pSrcDst[0] += tempPred; |
| |
| /* Saturate */ |
| pSrcDst[0] = armClip (-2048, 2047, pSrcDst[0]); |
| |
| /* Cal and store F[0][0] into the col buffer */ |
| *pPredBufCol = pSrcDst[0] * dcScaler; |
| } |
| |
| |
| if (ACPredFlag == 1) |
| { |
| if (predDir == OMX_VC_VERTICAL) |
| { |
| for (i = 1; i < 8; i++) |
| { |
| tempPred = armIntDivAwayFromZero \ |
| (pPredBufRow[i] * predQP, curQP); |
| if (flag) |
| { |
| /* Updating QF to the row buff */ |
| pPredBufRow[i] = pSrcDst[i]; |
| /*PQFX[v][0] = QFX[v][0] - (QFA[v][0] * QPA) // QPX */ |
| pSrcDst[i] -= tempPred; |
| /* Sum of absolute values of AC prediction error, this can |
| be used as a reference to choose whether to use |
| AC prediction */ |
| *pSumErr += armAbs(pSrcDst[i]); |
| /* pPreACPredict[1~7] store the error signal |
| after AC prediction */ |
| pPreACPredict[i] = pSrcDst[i]; |
| } |
| else |
| { |
| /*QFX[v][0] = PQFX[v][0] + (QFA[v][0] * QPA) // QPX */ |
| pSrcDst[i] += tempPred; |
| |
| /* Saturate */ |
| pSrcDst[i] = armClip (-2048, 2047, pSrcDst[i]); |
| |
| /* Updating QF to the row buff */ |
| pPredBufRow[i] = pSrcDst[i]; |
| } |
| } |
| } |
| else |
| { |
| for (i = 8; i < 64; i += 8) |
| { |
| tempPred = armIntDivAwayFromZero \ |
| (pPredBufCol[i>>3] * predQP, curQP); |
| if (flag) |
| { |
| /* Updating QF to col buff */ |
| pPredBufCol[i>>3] = pSrcDst[i]; |
| /*PQFX[0][u] = QFX[0][u] - (QFA[0][u] * QPA) // QPX */ |
| pSrcDst[i] -= tempPred; |
| /* Sum of absolute values of AC prediction error, this can |
| be used as a reference to choose whether to use AC |
| prediction */ |
| *pSumErr += armAbs(pSrcDst[i]); |
| /* pPreACPredict[1~7] store the error signal |
| after AC prediction */ |
| pPreACPredict[i>>3] = pSrcDst[i]; |
| } |
| else |
| { |
| /*QFX[0][u] = PQFX[0][u] + (QFA[0][u] * QPA) // QPX */ |
| pSrcDst[i] += tempPred; |
| |
| /* Saturate */ |
| pSrcDst[i] = armClip (-2048, 2047, pSrcDst[i]); |
| |
| /* Updating QF to col buff */ |
| pPredBufCol[i>>3] = pSrcDst[i]; |
| } |
| } |
| } |
| } |
| |
| return OMX_Sts_NoErr; |
| } |
| |
| /*End of File*/ |
| |
