;//
;// 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