From 8d3d303c7942ced6a987a52db8977d768dc3605f Mon Sep 17 00:00:00 2001 From: Hamsalekha S Date: Fri, 13 Mar 2015 21:24:58 +0530 Subject: Initial version Change-Id: I7efe9a589cd24edf86e8d086b40c27cbbf8b4017 --- common/x86/ih264_iquant_itrans_recon_dc_ssse3.c | 437 ++++++++++++++++++++++++ 1 file changed, 437 insertions(+) create mode 100755 common/x86/ih264_iquant_itrans_recon_dc_ssse3.c (limited to 'common/x86/ih264_iquant_itrans_recon_dc_ssse3.c') diff --git a/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c b/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c new file mode 100755 index 0000000..d43c8e2 --- /dev/null +++ b/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c @@ -0,0 +1,437 @@ +/****************************************************************************** + * + * 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_ssse3.c + * + * @brief + * Contains function definitions for inverse quantization, inverse + * transform and reconstruction + * + * @author + * Mohit [100664] + * + * @par List of Functions: + * - ihevc_iquant_itrans_recon_4x4_dc_ssse3() + * - ihevc_iquant_itrans_recon_8x8_dc_ssse3() + * + * @remarks + * None + * + ******************************************************************************* + */ +/* User include files */ +#include "ih264_typedefs.h" +#include "ih264_defs.h" +#include "ih264_trans_macros.h" +#include "ih264_macros.h" +#include "ih264_platform_macros.h" +#include "ih264_trans_data.h" +#include "ih264_size_defs.h" +#include "ih264_structs.h" +#include "ih264_trans_quant_itrans_iquant.h" +#include + +/* + ******************************************************************************** + * + * @brief This function reconstructs a 4x4 sub block from quantized resiude and + * prediction buffer 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_ssse3.c + * + * @par Description: + * The quantized residue is first inverse quantized, then inverse transformed. + * This inverse transformed content is added to the prediction buffer to recon- + * struct the end output + * + * @param[in] pi2_src + * quantized 4x4 block + * + * @param[in] pu1_pred + * prediction 4x4 block + * + * @param[out] pu1_out + * reconstructed 4x4 block + * + * @param[in] src_strd + * quantization buffer stride + * + * @param[in] pred_strd, + * Prediction buffer stride + * + * @param[in] out_strd + * recon buffer Stride + * + * @param[in] pu2_scaling_list + * pointer to scaling list + * + * @param[in] pu2_norm_adjust + * pointer to inverse scale matrix + * + * @param[in] u4_qp_div_6 + * Floor (qp/6) + * + * @param[in] pi4_tmp + * temporary buffer of size 1*16 + * + * @returns none + * + * @remarks none + * + ******************************************************************************* + */ +void ih264_iquant_itrans_recon_4x4_dc_ssse3(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, + WORD32 iq_start_idx, + WORD16 *pi2_dc_ld_addr) +{ + UWORD32 *pu4_out = (UWORD32 *)pu1_out; + WORD32 q0 = pi2_src[0]; + WORD16 i_macro, rnd_fact = (u4_qp_div_6 < 4) ? 1 << (3 - u4_qp_div_6) : 0; + INV_QUANT(q0, pu2_iscal_mat[0], pu2_weigh_mat[0], u4_qp_div_6, rnd_fact, 4); + + if (iq_start_idx != 0 ) + q0 = pi2_dc_ld_addr[0]; // Restoring dc value for intra case + + i_macro = ((q0 + 32) >> 6); + + __m128i predload_r,pred_r0, pred_r1, pred_r2, pred_r3; + __m128i sign_reg; + __m128i zero_8x16b = _mm_setzero_si128(); // all bits reset to zero + __m128i temp4, temp5, temp6, temp7; + __m128i value_add = _mm_set1_epi16(i_macro); + + zero_8x16b = _mm_setzero_si128(); // all bits reset to zero + //Load pred buffer + predload_r = _mm_loadl_epi64((__m128i *) (&pu1_pred[0])); //p00 p01 p02 p03 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r0 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p00 p01 p02 p03 0 0 0 0 -- all 16 bits + predload_r = _mm_loadl_epi64((__m128i *) (&pu1_pred[pred_strd])); //p10 p11 p12 p13 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r1 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p10 p11 p12 p13 0 0 0 0 -- all 16 bits + predload_r = _mm_loadl_epi64((__m128i *) (&pu1_pred[2*pred_strd])); //p20 p21 p22 p23 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r2 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p20 p21 p22 p23 0 0 0 0 -- all 16 bits + predload_r = _mm_loadl_epi64((__m128i *) (&pu1_pred[3*pred_strd])); //p30 p31 p32 p33 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r3 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p30 p31 p32 p33 0 0 0 0 -- all 16 bits + + pred_r0 = _mm_unpacklo_epi64(pred_r0, pred_r1); //p00 p01 p02 p03 p10 p11 p12 p13 + pred_r2 = _mm_unpacklo_epi64(pred_r2, pred_r3); //p20 p21 p22p p23 p30 p31 p32 p33 + + temp4 = _mm_add_epi16(value_add, pred_r0); + temp5 = _mm_add_epi16(value_add, pred_r2); + /*------------------------------------------------------------------*/ + //Clipping the results to 8 bits + sign_reg = _mm_cmpgt_epi16(temp4, zero_8x16b); // sign check + temp4 = _mm_and_si128(temp4, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp5, zero_8x16b); // sign check + temp5 = _mm_and_si128(temp5, sign_reg); + + temp4 = _mm_packus_epi16(temp4,temp5); + temp5 = _mm_srli_si128(temp4,4); + temp6 = _mm_srli_si128(temp5,4); + temp7 = _mm_srli_si128(temp6,4); + + *pu4_out = _mm_cvtsi128_si32(temp4); + pu1_out += out_strd; + pu4_out = (UWORD32 *)(pu1_out); + *(pu4_out) = _mm_cvtsi128_si32(temp5); + pu1_out += out_strd; + pu4_out = (UWORD32 *)(pu1_out); + *(pu4_out) = _mm_cvtsi128_si32(temp6); + pu1_out += out_strd; + pu4_out = (UWORD32 *)(pu1_out); + *(pu4_out) = _mm_cvtsi128_si32(temp7); +} +/** + ******************************************************************************* + * + * @brief + * This function performs inverse quant and Inverse transform type Ci4 for 8x8 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_ssse3.c + * + * @par Description: + * Performs inverse transform Ci8 and adds the residue to get the + * reconstructed block + * + * @param[in] pi2_src + * Input 8x8coefficients + * + * @param[in] pu1_pred + * Prediction 8x8 block + * + * @param[out] pu1_recon + * Output 8x8 block + * + * @param[in] q_div + * QP/6 + * + * @param[in] q_rem + * QP%6 + * + * @param[in] q_lev + * Quantizer level + * + * @param[in] u4_src_stride + * Input stride + * + * @param[in] u4_pred_stride, + * Prediction stride + * + * @param[in] u4_out_stride + * Output Stride + * + * @param[in] pi4_tmp + * temporary buffer of size 1*64 + * the tmp for each block + * + * @param[in] pu4_iquant_mat + * Pointer to the inverse quantization matrix + * + * @returns Void + * + * @remarks + * None + * + ******************************************************************************* + */ + +void ih264_iquant_itrans_recon_8x8_dc_ssse3 (WORD16 *pi2_src, + UWORD8 *pu1_pred, + UWORD8 *pu1_out, + WORD32 pred_strd, + WORD32 out_strd, + const UWORD16 *pu2_iscale_mat, + const UWORD16 *pu2_weigh_mat, + UWORD32 qp_div, + WORD16 *pi2_tmp, + WORD32 iq_start_idx, + WORD16 *pi2_dc_ld_addr) +{ + WORD32 q0 = pi2_src[0]; + WORD16 i_macro, rnd_fact = (qp_div < 6) ? 1 << (5 - qp_div) : 0; + INV_QUANT(q0, pu2_iscale_mat[0], pu2_weigh_mat[0], qp_div, rnd_fact, 6); + i_macro = ((q0 + 32) >> 6); + + __m128i predload_r,pred_r0, pred_r1, pred_r2, pred_r3,pred_r4,pred_r5,pred_r6,pred_r7; + __m128i sign_reg; + __m128i zero_8x16b = _mm_setzero_si128(); // all bits reset to zero + __m128i temp1,temp2,temp3,temp4, temp5, temp6, temp7,temp8; + __m128i value_add = _mm_set1_epi16(i_macro); + + //Load pred buffer row 0 + predload_r = _mm_loadl_epi64((__m128i *)(&pu1_pred[0])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r0 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 1 + predload_r = _mm_loadl_epi64((__m128i *)(&pu1_pred[pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r1 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 2 + predload_r = _mm_loadl_epi64( + (__m128i *)(&pu1_pred[2 * pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r2 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 3 + predload_r = _mm_loadl_epi64( + (__m128i *)(&pu1_pred[3 * pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r3 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 4 + predload_r = _mm_loadl_epi64( + (__m128i *)(&pu1_pred[4 * pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r4 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 5 + predload_r = _mm_loadl_epi64( + (__m128i *)(&pu1_pred[5 * pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bit + pred_r5 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 6 + predload_r = _mm_loadl_epi64( + (__m128i *)(&pu1_pred[6 * pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r6 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + //Load pred buffer row 7 + predload_r = _mm_loadl_epi64( + (__m128i *)(&pu1_pred[7 * pred_strd])); //p0 p1 p2 p3 p4 p5 p6 p7 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r7 = _mm_unpacklo_epi8(predload_r, zero_8x16b); //p0 p1 p2 p3 p4 p5 p6 p7 -- all 16 bits + + temp1 = _mm_add_epi16(value_add, pred_r0); + + temp2 = _mm_add_epi16(value_add, pred_r1); + + temp3 = _mm_add_epi16(value_add, pred_r2); + + temp4 = _mm_add_epi16(value_add, pred_r3); + + temp5 = _mm_add_epi16(value_add, pred_r4); + + temp6 = _mm_add_epi16(value_add, pred_r5); + + temp7 = _mm_add_epi16(value_add, pred_r6); + + temp8 = _mm_add_epi16(value_add, pred_r7); + /*------------------------------------------------------------------*/ + //Clipping the results to 8 bits + sign_reg = _mm_cmpgt_epi16(temp1, zero_8x16b); // sign check + temp1 = _mm_and_si128(temp1, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp2, zero_8x16b); // sign check + temp2 = _mm_and_si128(temp2, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp3, zero_8x16b); // sign check + temp3 = _mm_and_si128(temp3, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp4, zero_8x16b); // sign check + temp4 = _mm_and_si128(temp4, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp5, zero_8x16b); // sign check + temp5 = _mm_and_si128(temp5, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp6, zero_8x16b); // sign check + temp6 = _mm_and_si128(temp6, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp7, zero_8x16b); // sign check + temp7 = _mm_and_si128(temp7, sign_reg); + sign_reg = _mm_cmpgt_epi16(temp8, zero_8x16b); // sign check + temp8 = _mm_and_si128(temp8, sign_reg); + + temp1 = _mm_packus_epi16(temp1, zero_8x16b); + temp2 = _mm_packus_epi16(temp2, zero_8x16b); + temp3 = _mm_packus_epi16(temp3, zero_8x16b); + temp4 = _mm_packus_epi16(temp4, zero_8x16b); + temp5 = _mm_packus_epi16(temp5, zero_8x16b); + temp6 = _mm_packus_epi16(temp6, zero_8x16b); + temp7 = _mm_packus_epi16(temp7, zero_8x16b); + temp8 = _mm_packus_epi16(temp8, zero_8x16b); + + _mm_storel_epi64((__m128i *)(&pu1_out[0]), temp1); + _mm_storel_epi64((__m128i *)(&pu1_out[out_strd]), temp2); + _mm_storel_epi64((__m128i *)(&pu1_out[2 * out_strd]), temp3); + _mm_storel_epi64((__m128i *)(&pu1_out[3 * out_strd]), temp4); + _mm_storel_epi64((__m128i *)(&pu1_out[4 * out_strd]), temp5); + _mm_storel_epi64((__m128i *)(&pu1_out[5 * out_strd]), temp6); + _mm_storel_epi64((__m128i *)(&pu1_out[6 * out_strd]), temp7); + _mm_storel_epi64((__m128i *)(&pu1_out[7 * out_strd]), temp8); +} + +/* + ******************************************************************************** + * + * @brief This function reconstructs a 4x4 sub block from quantized chroma resiude and + * prediction buffer + * + * @par Description: + * The quantized residue is first inverse quantized, then inverse transformed. + * This inverse transformed content is added to the prediction buffer to recon- + * struct the end output + * + * @param[in] pi2_src + * quantized 4x4 block + * + * @param[in] pu1_pred + * prediction 4x4 block + * + * @param[out] pu1_out + * reconstructed 4x4 block + * + * @param[in] src_strd + * quantization buffer stride + * + * @param[in] pred_strd, + * Prediction buffer stride + * + * @param[in] out_strd + * recon buffer Stride + * + * @param[in] pu2_scaling_list + * pointer to scaling list + * + * @param[in] pu2_norm_adjust + * pointer to inverse scale matrix + * + * @param[in] u4_qp_div_6 + * Floor (qp/6) + * + * @param[in] pi4_tmp + * temporary buffer of size 1*16 + * + * @returns none + * + * @remarks none + * + ******************************************************************************* + */ +void ih264_iquant_itrans_recon_chroma_4x4_dc_ssse3(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) + { + WORD16 q0 = pi2_dc_src[0]; // DC value won't be dequantized for chroma inverse transform + WORD16 i_macro = ((q0 + 32) >> 6); + + __m128i pred_r0, pred_r1, pred_r2, pred_r3, sign_reg; + __m128i zero_8x16b = _mm_setzero_si128(); // all bits reset to zero + __m128i chroma_mask = _mm_set1_epi16 (0xFF); + __m128i value_add = _mm_set1_epi16(i_macro); + + //Load pred buffer + pred_r0 = _mm_loadl_epi64((__m128i *) (&pu1_pred[0])); //p00 p01 p02 p03 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r1 = _mm_loadl_epi64((__m128i *) (&pu1_pred[pred_strd])); //p10 p11 p12 p13 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r2 = _mm_loadl_epi64((__m128i *) (&pu1_pred[2 * pred_strd])); //p20 p21 p22 p23 0 0 0 0 0 0 0 0 -- all 8 bits + pred_r3 = _mm_loadl_epi64((__m128i *) (&pu1_pred[3 * pred_strd])); //p30 p31 p32 p33 0 0 0 0 0 0 0 0 -- all 8 bits + + pred_r0 = _mm_and_si128(pred_r0, chroma_mask); + pred_r1 = _mm_and_si128(pred_r1, chroma_mask); + pred_r2 = _mm_and_si128(pred_r2, chroma_mask); + pred_r3 = _mm_and_si128(pred_r3, chroma_mask); + + pred_r0 = _mm_unpacklo_epi64(pred_r0, pred_r1); //p00 p01 p02 p03 p10 p11 p12 p13 + pred_r2 = _mm_unpacklo_epi64(pred_r2, pred_r3); //p20 p21 p22p p23 p30 p31 p32 p33 + + pred_r0 = _mm_add_epi16(value_add, pred_r0); + pred_r2 = _mm_add_epi16(value_add, pred_r2); + + /*------------------------------------------------------------------*/ + //Clipping the results to 8 bits + sign_reg = _mm_cmpgt_epi16(pred_r0, zero_8x16b); // sign check + pred_r0 = _mm_and_si128(pred_r0, sign_reg); + sign_reg = _mm_cmpgt_epi16(pred_r2, zero_8x16b); + pred_r2 = _mm_and_si128(pred_r2, sign_reg); + + pred_r0 = _mm_packus_epi16(pred_r0, pred_r2); + pred_r1 = _mm_srli_si128(pred_r0, 4); + pred_r2 = _mm_srli_si128(pred_r1, 4); + pred_r3 = _mm_srli_si128(pred_r2, 4); + + pred_r0 = _mm_unpacklo_epi8(pred_r0, zero_8x16b); //p00 p01 p02 p03 -- all 16 bits + pred_r1 = _mm_unpacklo_epi8(pred_r1, zero_8x16b); //p10 p11 p12 p13 -- all 16 bits + pred_r2 = _mm_unpacklo_epi8(pred_r2, zero_8x16b); //p20 p21 p22 p23 -- all 16 bits + pred_r3 = _mm_unpacklo_epi8(pred_r3, zero_8x16b); //p30 p31 p32 p33 -- all 16 bits + + chroma_mask = _mm_unpacklo_epi64(chroma_mask, zero_8x16b); //1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 -- 8 bits + + _mm_maskmoveu_si128(pred_r0, chroma_mask, (char *)(&pu1_out[0])); + _mm_maskmoveu_si128(pred_r1, chroma_mask, (char *)(&pu1_out[out_strd])); + _mm_maskmoveu_si128(pred_r2, chroma_mask, (char *)(&pu1_out[2*out_strd])); + _mm_maskmoveu_si128(pred_r3, chroma_mask, (char *)(&pu1_out[3*out_strd])); +} + + -- cgit v1.2.3