;// ;// 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_PredictReconCoefIntra_s.s ; * OpenMAX DL: v1.0.2 ; * Revision: 12290 ; * Date: Wednesday, April 9, 2008 ; * ; * ; * ; * ; * Description: ; * Contains module for DC/AC coefficient prediction ; * ; * ; * Function: omxVCM4P2_PredictReconCoefIntra ; * ; * 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; must be aligned on a 4-byte boundary. The ; * output coefficients are saturated to the range ; * [-2048, 2047]. ; * [in] pPredBufRow pointer to the coefficient row buffer; must be aligned ; * on a 4-byte boundary. ; * [in] pPredBufCol pointer to the coefficient column buffer; must be ; * aligned on a 4-byte boundary. ; * [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_VIDEO_HORIZONTAL predict horizontally ; * OMX_VIDEO_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 ; * [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 ; * Return Value: ; * OMX_Sts_NoErr - no error ; * OMX_Sts_BadArgErr - Bad arguments ; * - At least one of the pointers is NULL: pSrcDst, pPredBufRow, or pPredBufCol. ; * - At least one the following cases: curQP <= 0, predQP <= 0, curQP >31, ; * predQP > 31, preDir exceeds [1,2]. ; * - At least one of the pointers pSrcDst, pPredBufRow, or pPredBufCol is not ; * 4-byte aligned. ; * ; ********* INCLUDE omxtypes_s.h INCLUDE armCOMM_s.h M_VARIANTS CortexA8 IMPORT armVCM4P2_Reciprocal_QP_S32 IMPORT armVCM4P2_Reciprocal_QP_S16 IMPORT armVCM4P2_DCScaler IF CortexA8 ;// Input Arguments pSrcDst RN 0 pPredBufRow RN 1 pPredBufCol RN 2 curQP RN 3 QP RN 3 predQP RN 4 predDir RN 5 ACPredFlag RN 6 videoComp RN 7 ;// Local Variables shortVideoHeader RN 4 dcScaler RN 4 index RN 6 predCoeffTable RN 7 temp1 RN 6 temp2 RN 9 temp RN 14 Const RN 8 temppPredColBuf RN 8 tempPred RN 9 absCoeffDC RN 8 negdcScaler RN 10 Rem RN 11 temp3 RN 12 dcRowbufCoeff RN 10 dcColBuffCoeff RN 11 Return RN 0 ;//NEON Registers qPredRowBuf QN Q0.S16 dPredRowBuf0 DN D0.S16 dPredRowBuf1 DN D1.S16 qCoeffTab QN Q1.S32 qPredQP QN Q2.S16 dPredQP0 DN D4.S16 dPredQP1 DN D5.S16 qtemp1 QN Q3.S32 qtemp QN Q3.S16 dtemp0 DN D6.S16 dtemp1 DN D7.S16 dtemp2 DN D8.S16 dtemp3 DN D9.S16 dtemp4 DN D2.S16 dtemp5 DN D3.S16 dtemp6 DN D4.S16 dtemp7 DN D5.S16 qtempPred1 QN Q5.S32 qtempPred QN Q5.S16 dtempPred0 DN D10.S16 dtempPred1 DN D11.S16 M_START omxVCM4P2_PredictReconCoefIntra,r11,d11 ;// Assigning pointers to Input arguments on Stack M_ARG predQPonStack,4 M_ARG predDironStack,4 M_ARG ACPredFlagonStack,4 M_ARG videoComponStack,4 ;// DC Prediction M_LDR videoComp,videoComponStack ;// Load videoComp From Stack M_LDR predDir,predDironStack ;// Load Prediction direction ;// DC Scaler calculation LDR index, =armVCM4P2_DCScaler ADD index,index,videoComp,LSL #5 LDRB dcScaler,[index,QP] LDR predCoeffTable, =armVCM4P2_Reciprocal_QP_S16 ;// Loading the table with entries 32767/(1 to 63) CMP predDir,#2 ;// Check if the Prediction direction is vertical ;// Caulucate tempPred LDREQSH absCoeffDC,[pPredBufRow] ;// If vetical load the coeff from Row Prediction Buffer LDRNESH absCoeffDC,[pPredBufCol] ;// If horizontal load the coeff from column Prediction Buffer RSB negdcScaler,dcScaler,#0 ;// negdcScaler=-dcScaler MOV temp1,absCoeffDC ;// Load the Prediction coeff to temp for comparision CMP temp1,#0 RSBLT absCoeffDC,temp1,#0 ;// calculate absolute val of prediction coeff ADD temp,dcScaler,dcScaler LDRH temp,[predCoeffTable,temp] ;// Load value from coeff table for performing division using multiplication SMULBB tempPred,temp,absCoeffDC ;// tempped=pPredBufRow(Col)[0]*32767/dcScaler ADD temp3,dcScaler,#1 LSR tempPred,tempPred,#15 ;// tempped=pPredBufRow(Col)[0]/dcScaler LSR temp3,temp3,#1 ;// temp3=round(dcScaler/2) MLA Rem,negdcScaler,tempPred,absCoeffDC ;// Remainder Rem=abs(pPredBufRow(Col)[0])-tempPred*dcScaler LDRH dcRowbufCoeff,[pPredBufCol] CMP Rem,temp3 ;// compare Rem with (dcScaler/2) ADDGE tempPred,#1 ;// tempPred=tempPred+1 if Rem>=(dcScaler/2) CMP temp1,#0 RSBLT tempPred,tempPred,#0 ;// tempPred=-tempPred if STRH dcRowbufCoeff,[pPredBufRow,#-16] LDRH temp,[pSrcDst] ;// temp=pSrcDst[0] ADD temp,temp,tempPred ;// temp=pSrcDst[0]+tempPred SSAT16 temp,#12,temp ;// clip temp to [-2048,2047] SMULBB dcColBuffCoeff,temp,dcScaler ;// temp1=clipped(pSrcDst[0])*dcScaler M_LDR ACPredFlag,ACPredFlagonStack STRH dcColBuffCoeff,[pPredBufCol] ;// AC Prediction M_LDR predQP,predQPonStack CMP ACPredFlag,#1 ;// Check if the AC prediction flag is set or not BNE Exit ;// If not set Exit CMP predDir,#2 ;// Check the Prediction direction LDR predCoeffTable, =armVCM4P2_Reciprocal_QP_S32 ;// Loading the table with entries 0x1ffff/(1 to 63) MOV Const,#4 MUL curQP,curQP,Const ;// curQP=4*curQP VDUP dPredQP0,predQP LDR temp2,[predCoeffTable,curQP] ;// temp=0x1ffff/curQP VDUP qCoeffTab,temp2 BNE Horizontal ;// If the Prediction direction is horizontal branch to Horizontal ;// Vertical ;//Calculating tempPred VLD1 {dPredRowBuf0,dPredRowBuf1},[pPredBufRow] ;// Loading pPredBufRow[i]:i=0 t0 7 VMULL qtemp1,dPredRowBuf0,dPredQP0 ;//qtemp1[i]=pPredBufRow[i]*dPredQP[i]: i=0 t0 3 VMUL qtempPred1,qtemp1,qCoeffTab ;//qtempPred1[i]=pPredBufRow[i]*dPredQP[i]*0x1ffff/curQP : i=0 t0 3 VMULL qtemp1,dPredRowBuf1,dPredQP0 ;//qtemp1[i]=pPredBufRow[i]*dPredQP[i] : i=4 t0 7 VRSHR qtempPred1,qtempPred1,#17 ;//qtempPred1[i]=round(pPredBufRow[i]*dPredQP[i]/curQP) : i=0 t0 3 VSHRN dPredQP1,qtempPred1,#0 ;// narrow qtempPred1[i] to 16 bits VMUL qtempPred1,qtemp1,qCoeffTab ;//qtempPred1[i]=pPredBufRow[i]*dPredQP[i]*0x1ffff/curQP : i=4 t0 7 VRSHR qtempPred1,qtempPred1,#17 ;//qtempPred1[i]=round(pPredBufRow[i]*dPredQP[i]/curQP) : i=4 t0 7 VLD1 {dtemp0,dtemp1},[pSrcDst] ;//Loading pSrcDst[i] : i=0 to 7 VSHRN dtempPred1,qtempPred1,#0 ;// narrow qtempPred1[i] to 16 bits VMOV dtempPred0,dPredQP1 ;//updating source and row prediction buffer contents VADD qtemp,qtemp,qtempPred ;//pSrcDst[i]=pSrcDst[i]+qtempPred[i]: i=0 to 7 VQSHL qtemp,qtemp,#4 ;//Clip to [-2048,2047] LDRH dcRowbufCoeff,[pPredBufRow] ;//Loading Dc Value of Row Prediction buffer VSHR qtemp,qtemp,#4 VST1 {dtemp0,dtemp1},[pSrcDst] ;//storing back the updated values VST1 {dtemp0,dtemp1},[pPredBufRow] ;//storing back the updated row prediction values STRH dcRowbufCoeff,[pPredBufRow] ;// storing the updated DC Row Prediction coeff B Exit Horizontal ;// Calculating Temppred VLD1 {dPredRowBuf0,dPredRowBuf1},[pPredBufCol] ;// Loading pPredBufCol[i]:i=0 t0 7 VMULL qtemp1,dPredRowBuf0,dPredQP0 ;//qtemp1[i]=pPredBufCol[i]*dPredQP[i]: i=0 t0 3 VMUL qtempPred1,qtemp1,qCoeffTab ;//qtempPred1[i]=pPredBufCol[i]*dPredQP[i]*0x1ffff/curQP : i=0 t0 3 VMULL qtemp1,dPredRowBuf1,dPredQP0 ;//qtemp1[i]=pPredBufCol[i]*dPredQP[i] : i=4 t0 7 VRSHR qtempPred1,qtempPred1,#17 ;//qtempPred1[i]=round(pPredBufCol[i]*dPredQP[i]/curQP) : i=0 t0 3 VSHRN dPredQP1,qtempPred1,#0 ;// narrow qtempPred1[i] to 16 bits VMUL qtempPred1,qtemp1,qCoeffTab ;//qtempPred1[i]=pPredBufCol[i]*dPredQP[i]*0x1ffff/curQP : i=4 t0 7 MOV temppPredColBuf,pPredBufCol VRSHR qtempPred1,qtempPred1,#17 ;//qtempPred1[i]=round(pPredBufCol[i]*dPredQP[i]/curQP) : i=4 t0 7 VLD4 {dtemp0,dtemp1,dtemp2,dtemp3},[pSrcDst] ;// Loading coefficients Interleaving by 4 VSHRN dtempPred1,qtempPred1,#0 ;// narrow qtempPred1[i] to 16 bits VMOV dtempPred0,dPredQP1 ;// Updating source and column prediction buffer contents ADD temp2,pSrcDst,#32 VLD4 {dtemp4,dtemp5,dtemp6,dtemp7},[temp2] ;// Loading next 16 coefficients Interleaving by 4 VUZP dtemp0,dtemp4 ;// Interleaving by 8 VADD dtemp0,dtemp0,dtempPred0 ;// Adding tempPred to coeffs VQSHL dtemp0,dtemp0,#4 ;// Clip to [-2048,2047] VSHR dtemp0,dtemp0,#4 VST1 {dtemp0},[pPredBufCol]! ;// Updating Pridiction column buffer VZIP dtemp0,dtemp4 ;// deinterleaving VST4 {dtemp0,dtemp1,dtemp2,dtemp3},[pSrcDst] ;// Updating source coeffs VST4 {dtemp4,dtemp5,dtemp6,dtemp7},[temp2]! MOV temp1,temp2 VLD4 {dtemp0,dtemp1,dtemp2,dtemp3},[temp2]! ;// Loading coefficients Interleaving by 4 VLD4 {dtemp4,dtemp5,dtemp6,dtemp7},[temp2] VUZP dtemp0,dtemp4 ;// Interleaving by 8 VADD dtemp0,dtemp0,dtempPred1 VQSHL dtemp0,dtemp0,#4 ;// Clip to [-2048,2047] VSHR dtemp0,dtemp0,#4 VST1 {dtemp0},[pPredBufCol]! VZIP dtemp0,dtemp4 VST4 {dtemp0,dtemp1,dtemp2,dtemp3},[temp1] STRH dcColBuffCoeff,[temppPredColBuf] VST4 {dtemp4,dtemp5,dtemp6,dtemp7},[temp2] Exit STRH temp,[pSrcDst] MOV Return,#OMX_Sts_NoErr M_END ENDIF END