@/****************************************************************************** @ * @ * Copyright (C) 2015 The Android Open Source Project @ * @ * 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. @ * @ ***************************************************************************** @ * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore @*/ @** @ ******************************************************************************* @ * @file @ * ih264_iquant_itrans_recon_dc_a9.s @ * @ * @brief @ * Contains function definitions for single stage inverse transform @ * @ * @author @ * Mohit @ * @ * @par List of Functions: @ * - ih264_iquant_itrans_recon_4x4_dc_a9() @ * - ih264_iquant_itrans_recon_8x8_dc_a9() @ * - ih264_iquant_itrans_recon_chroma_4x4_dc_a9() @ * @ * @remarks @ * None @ * @ ******************************************************************************* @* @** @ ******************************************************************************* @ * @ * @brief @ * This function performs inverse quant and Inverse transform type Ci4 for 4*4 block @ * for dc input pattern only, i.e. only the (0,0) element of the input 4x4 block is @ * non-zero. For complete function, refer ih264_iquant_itrans_recon_a9.s @ * @ * @par Description: @ * Performs inverse transform Ci4 and adds the residue to get the @ * reconstructed block @ * @ * @param[in] pi2_src @ * Input 4x4 coefficients @ * @ * @param[in] pu1_pred @ * Prediction 4x4 block @ * @ * @param[out] pu1_out @ * Output 4x4 block @ * @ * @param[in] u4_qp_div_6 @ * QP @ * @ * @param[in] pu2_weigh_mat @ * Pointer to weight matrix @ * @ * @param[in] pred_strd, @ * Prediction stride @ * @ * @param[in] out_strd @ * Output Stride @ * @ *@param[in] pi2_tmp @ * temporary buffer of size 1*16 @ * @ * @param[in] pu2_iscal_mat @ * Pointer to the inverse quantization matrix @ * @ * @returns Void @ * @ * @remarks @ * None @ * @ ******************************************************************************* @ * @void ih264_iquant_itrans_recon_4x4_dc(WORD16 *pi2_src, @ UWORD8 *pu1_pred, @ UWORD8 *pu1_out, @ WORD32 pred_strd, @ WORD32 out_strd, @ const UWORD16 *pu2_iscal_mat, @ const UWORD16 *pu2_weigh_mat, @ UWORD32 u4_qp_div_6, @ WORD32 *pi4_tmp, @ WORD32 iq_start_idx @ WORD16 *pi2_dc_ld_addr) @**************Variables Vs Registers***************************************** @r0 => *pi2_src @r1 => *pu1_pred @r2 => *pu1_out @r3 => pred_strd @r4 => out_strd @r5 => *pu2_iscal_mat @r6 => *pu2_weigh_mat @r7 => u4_qp_div_6 @r9 => iq_start_idx @unused => pi2_dc_ld_addr .text .syntax unified .p2align 2 .global ih264_iquant_itrans_recon_4x4_dc_a9 ih264_iquant_itrans_recon_4x4_dc_a9: @Only one shift is done in horizontal inverse because, @if u4_qp_div_6 is lesser than 4 then shift value will be neagative and do negative left shift, in this case rnd_factor has value @if u4_qp_div_6 is greater than 4 then shift value will be positive and do left shift, here rnd_factor is 0 stmfd sp!, {r4-r10, r14} @stack stores the values of the arguments ldr r5, [sp, #36] @Loads *pu2_iscal_mat ldr r6, [sp, #40] @Loads *pu2_weigh_mat ldrsh r8, [r0] @load pi2_src[0], SH for signed halfword load ldrh r6, [r6] @load pu2_weight_mat[0] , H for unsigned halfword load ldrh r5, [r5] @load pu2_iscal_mat[0] , H for unsigned halfword load @=======================DEQUANT FROM HERE=================================== mul r6, r6, r5 @pu2_iscal_mat[0]*pu2_weigh_mat[0] ldr r7, [sp, #44] @Loads u4_qp_div_6 mul r6, r6, r8 @pi2_src[0]*pu2_iscal_mat[0]*pu2_weigh_mat[0] ldr r4, [sp, #32] @Loads out_strd ldr r9, [sp, #52] @Loads iq_start_idx lsl r6, r6, r7 @(pi2_src[0]*pu2_iscal_mat[0]*pu2_weigh_mat[0])< intra case , so result of subtraction is zero and Z flag is set ldrsheq r10, [r0] @ Loads signed halfword pi2_src[0], if r9==1 moveq r6, r10 @ Restore dc value in case of intra, i.e. r9 == 1 add r6, r6, #32 @i_macro = q0 + 32 asr r6, r6, #6 @i_macro >>6 = DC output of 2-stage transform vdup.s16 q0, r6 @copy transform output to Q0 vld1.32 d30[0], [r1], r3 @I row Load pu1_pred buffer vld1.32 d30[1], [r1], r3 @II row Load pu1_pred buffer vld1.32 d31[0], [r1], r3 @III row Load pu1_pred buf vld1.32 d31[1], [r1], r3 @IV row Load pu1_pred buffer vaddw.u8 q10, q0, d30 vaddw.u8 q11, q0, d31 vqmovun.s16 d0, q10 vst1.32 d0[0], [r2], r4 @I row store the value vqmovun.s16 d1, q11 vst1.32 d0[1], [r2], r4 @II row store the value vst1.32 d1[0], [r2], r4 @III row store the value vst1.32 d1[1], [r2] @IV row store the value ldmfd sp!, {r4-r10, r15} @Reload the registers from SP @* @ ******************************************************************************* @ * @ * @brief @ * This function performs inverse quant and Inverse transform type Ci4 for 8*8 block @ * for dc input pattern only, i.e. only the (0,0) element of the input 8x8 block is @ * non-zero. For complete function, refer ih264_iquant_itrans_recon_a9.s @ * @ * @par Description: @ * Performs inverse transform Ci8 and adds the residue to get the @ * reconstructed block @ * @ * @param[in] pi2_src @ * Input 4x4 coefficients @ * @ * @param[in] pu1_pred @ * Prediction 4x4 block @ * @ * @param[out] pu1_out @ * Output 4x4 block @ * @ * @param[in] u4_qp_div_6 @ * QP @ * @ * @param[in] pu2_weigh_mat @ * Pointer to weight matrix @ * @ * @param[in] pred_strd, @ * Prediction stride @ * @ * @param[in] out_strd @ * Output Stride @ * @ *@param[in] pi2_tmp @ * temporary buffer of size 1*64 @ * @ * @param[in] pu2_iscal_mat @ * Pointer to the inverse quantization matrix @ * @ * @returns Void @ * @ * @remarks @ * None @ * @ ******************************************************************************* @ * @void ih264_iquant_itrans_recon_8x8_dc(WORD16 *pi2_src, @ UWORD8 *pu1_pred, @ UWORD8 *pu1_out, @ WORD32 pred_strd, @ WORD32 out_strd, @ const UWORD16 *pu2_iscal_mat, @ const UWORD16 *pu2_weigh_mat, @ UWORD32 u4_qp_div_6, @ WORD32 *pi4_tmp, @ WORD32 iq_start_idx) @**************Variables Vs Registers***************************************** @r0 => *pi2_src @r1 => *pu1_pred @r2 => *pu1_out @r3 => pred_strd @r4 => out_strd @r5 => *pu2_iscal_mat @r6 => *pu2_weigh_mat @r7 => u4_qp_div_6 .global ih264_iquant_itrans_recon_8x8_dc_a9 ih264_iquant_itrans_recon_8x8_dc_a9: stmfd sp!, {r4-r8, r14} @stack stores the values of the arguments ldr r5, [sp, #28] @Loads *pu2_iscal_mat ldr r6, [sp, #32] @Loads *pu2_weigh_mat ldrsh r8, [r0] @load pi2_src[0], SH for signed halfword load ldrh r6, [r6] @load pu2_weight_mat[0] , H for unsigned halfword load ldrh r5, [r5] @load pu2_iscal_mat[0] , H for unsigned halfword load @=======================DEQUANT FROM HERE=================================== mul r6, r6, r5 @pu2_iscal_mat[0]*pu2_weigh_mat[0] ldr r7, [sp, #36] @Loads u4_qp_div_6 mul r6, r6, r8 @pi2_src[0]*pu2_iscal_mat[0]*pu2_weigh_mat[0] ldr r4, [sp, #24] @Loads out_strd vpush {d8-d15} lsl r6, r6, r7 @(pi2_src[0]*pu2_iscal_mat[0]*pu2_weigh_mat[0])<>6 = DC output of 2-stage transform vdup.s16 q8, r6 @copy transform output to Q0 vld1.32 d24, [r1], r3 @ Q12 = 0x070605....0x070605.... vld1.32 d25, [r1], r3 @ Q12 = 0x070605....0x070605.... vld1.32 d26, [r1], r3 @ Q12 = 0x070605....0x070605.... vaddw.u8 q0, q8, d24 vld1.32 d27, [r1], r3 @ Q12 = 0x070605....0x070605.... vaddw.u8 q1, q8, d25 vld1.32 d28, [r1], r3 @ Q12 = 0x070605....0x070605.... vaddw.u8 q2, q8, d26 vld1.32 d29, [r1], r3 @ Q12 = 0x070605....0x070605.... vaddw.u8 q3, q8, d27 vld1.32 d30, [r1], r3 @ Q12 = 0x070605....0x070605.... vaddw.u8 q4, q8, d28 vld1.32 d31, [r1], r3 @ Q12 = 0x070605....0x070605.... @ Code Added to pack sign and magnitudes vqmovun.s16 d0, q0 vaddw.u8 q5, q8, d29 vqmovun.s16 d1, q1 vaddw.u8 q6, q8, d30 vqmovun.s16 d2, q2 vqmovun.s16 d3, q3 vaddw.u8 q7, q8, d31 vqmovun.s16 d4, q4 vqmovun.s16 d5, q5 vst1.32 d0, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vqmovun.s16 d6, q6 vst1.32 d1, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vqmovun.s16 d7, q7 vst1.32 d2, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vst1.32 d3, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vst1.32 d4, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vst1.32 d5, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vst1.32 d6, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vst1.32 d7, [r2], r4 @ Magnitudes of 1st 4x4 block coeffs vpop {d8-d15} ldmfd sp!, {r4-r8, r15} @ * @ ******************************************************************************** @ * @ * @brief This function reconstructs a 4x4 sub block from quantized resiude and @ * prediction buffer if only dc value is present for residue @ * @ * @par Description: @ * The quantized residue is first inverse quantized, @ * This inverse quantized content is added to the prediction buffer to recon- @ * struct the end output @ * @ * @param[in] pi2_src @ * quantized dc coeffiient @ * @ * @param[in] pu1_pred @ * prediction 4x4 block in interleaved format @ * @ * @param[in] pred_strd, @ * Prediction buffer stride in interleaved format @ * @ * @param[in] out_strd @ * recon buffer Stride @ * @ * @returns none @ * @ * @remarks none @ * @ ******************************************************************************* @ * @ void ih264_iquant_itrans_recon_chroma_4x4_dc(WORD16 *pi2_src, @ UWORD8 *pu1_pred, @ UWORD8 *pu1_out, @ WORD32 pred_strd, @ WORD32 out_strd, @ const UWORD16 *pu2_iscal_mat, @ const UWORD16 *pu2_weigh_mat, @ UWORD32 u4_qp_div_6, @ WORD16 *pi2_tmp, @ WORD16 *pi2_dc_src) @ Register Usage @ r0 : pi2_src @ r1 : pu1_pred @ r2 : pu1_out @ r3 : pred_strd @ Neon registers d0-d7, d16-d30 are used @ No need for pushing arm and neon registers .global ih264_iquant_itrans_recon_chroma_4x4_dc_a9 ih264_iquant_itrans_recon_chroma_4x4_dc_a9: ldr r0, [sp, #20] vld1.s16 d0, [r0] @load pi2_dc_src ldr r0, [sp] @load out_strd vld2.s8 {d2, d3}, [r1], r3 @load pred plane 1 => d2 &pred palne 2 => d3 vld2.s8 {d3, d4}, [r1], r3 vrshr.s16 d0, d0, #6 @i_macro = ((q0 + 32) >> 6); vld2.s8 {d4, d5}, [r1], r3 vld2.s8 {d5, d6}, [r1], r3 vdup.s16 q0, d0[0] @duplicate pi2_sr[0] mov r1, r2 @backup pu1_out vtrn.32 d2, d3 @mov the 4 coeffs of current block to d2 vtrn.32 d4, d5 vmov.u16 q15, #0x00ff vld1.u8 d18, [r2], r0 @load out [8 bit size) -8 coeffs vaddw.u8 q1, q0, d2 @Add pred vld1.u8 d19, [r2], r0 vaddw.u8 q2, q0, d4 vld1.u8 d20, [r2], r0 vld1.u8 d21, [r2], r0 vqmovun.s16 d2, q1 vqmovun.s16 d4, q2 vmovl.u8 q1, d2 vmovl.u8 q2, d4 vbit.u8 q9, q1, q15 vbit.u8 q10, q2, q15 vst1.u8 d18, [r1], r0 @store out vst1.u8 d19, [r1], r0 vst1.u8 d20, [r1], r0 vst1.u8 d21, [r1], r0 bx lr