| /****************************************************************************** |
| * |
| * Copyright (C) 2018 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 |
| * ihevc_quant_iquant_ssd.c |
| * |
| * @brief |
| * Contains function definitions for quantization, followed by Inverse |
| * quantization to find transform domain SSD |
| * |
| * @author |
| * 100453, 100578 |
| * |
| * @par List of Functions: |
| * - ihevc_quant_iquant_ssd() |
| * - ihevc_quant_iquant_ssd_flat_scale_mat() |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include "ihevc_typedefs.h" |
| #include "ihevc_macros.h" |
| #include "ihevc_platform_macros.h" |
| #include "ihevc_defs.h" |
| #include "ihevc_debug.h" |
| #include "ihevc_trans_tables.h" |
| #include "ihevc_quant_iquant_ssd.h" |
| #include "ihevc_func_selector.h" |
| #include "ihevc_trans_macros.h" |
| #include <assert.h> |
| |
| /*****************************************************************************/ |
| /* Globals */ |
| /*****************************************************************************/ |
| |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization, followed by Inverse |
| * quantization to find transform domain SSD |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_quant_iquant_ssd |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD32 val; |
| WORD16 i2_temp; |
| WORD32 ssd_cost = 0; |
| |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /* Quantization */ |
| QUANT(pi2_q_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| |
| /* SSD Computation & Accumulation */ |
| val = i2_temp - pi2_iq_dst[j]; |
| ssd_cost += val*val; |
| |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| |
| /* Store the cost */ |
| *pi8_cost = ssd_cost; |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization, followed by Inverse |
| * quantization |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_quant_iquant |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD16 i2_temp; |
| |
| (void)pi8_cost; |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /* Quantization */ |
| QUANT(pi2_q_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| shift_iq, |
| qp_div); |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization, followed by Inverse |
| * quantization to find transform domain SSD |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_quant_iquant_ssd_rdoq |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD32 val; |
| WORD16 i2_temp; |
| WORD32 ssd_cost = 0; |
| |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /* Quantization */ |
| QUANT(pi2_q_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| |
| if (abs(pi2_q_dst[j]) > 1) |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| |
| } |
| |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| |
| /* SSD Computation & Accumulation */ |
| val = i2_temp - pi2_iq_dst[j]; |
| ssd_cost += val*val; |
| |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| /* Store the cost */ |
| *pi8_cost = ssd_cost; |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| WORD32 ihevc_quant_iquant_rdoq |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD16 i2_temp; |
| |
| (void)pi8_cost; |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /* Quantization */ |
| QUANT(pi2_q_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| if (abs(pi2_q_dst[j]) > 1) |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| } |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| shift_iq, |
| qp_div); |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization(using flat scale matrix), followed by |
| * inverse quantization to find transform domain SSD |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_quant_iquant_ssd_flat_scale_mat |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD32 val; |
| WORD16 i2_temp; |
| /* Initialize cost to zero */ |
| WORD32 ssd_cost = 0; |
| |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /*QUANT(pi2_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add);*/ |
| |
| /* modified by 1028 */ |
| /* Quantization */ |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| if(pi2_q_dst[j] == 0) |
| { |
| pi2_iq_dst[j] = 0; |
| } |
| else |
| { |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| } |
| |
| /* SSD Computation & Accumulation */ |
| val = i2_temp - pi2_iq_dst[j]; |
| ssd_cost += val*val; |
| |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| /* Store the cost */ |
| *pi8_cost = ssd_cost; |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| WORD32 ihevc_quant_iquant_flat_scale_mat |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD16 i2_temp; |
| |
| (void)pi8_cost; |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /* Quantization */ |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| if(pi2_q_dst[j] == 0) |
| { |
| pi2_iq_dst[j] = 0; |
| } |
| else |
| { |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| } |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization(using flat scale matrix), followed by |
| * inverse quantization to find transform domain SSD; when we perform RDOQ. |
| * In case the quantized value turns out to be grater than 1, we then requantize |
| * use half rounding. |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_quant_iquant_ssd_flat_scale_mat_rdoq |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD32 val; |
| WORD16 i2_temp; |
| /* Initialize cost to zero */ |
| WORD32 ssd_cost = 0; |
| |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| WORD16 i2_temp1; |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /*QUANT(pi2_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add);*/ |
| |
| /* modified by 1028 */ |
| /* Quantization */ |
| |
| if (1) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| } |
| else |
| { \ |
| WORD16 inp = pi2_coeffs[j],out = pi2_q_dst[j]; |
| WORD32 quant_coeff = g_ihevc_quant_scales[qp_rem]; |
| WORD32 log2_trans_size = log2_size; |
| WORD32 tmp; \ |
| WORD32 sign; \ |
| WORD32 bit_depth,transform_shift; \ |
| WORD32 q_bits, quant_multiplier; \ |
| \ |
| /* q_bits and q_add calculation*/ \ |
| /* To be moved outside in neon. To be computer once per transform call */ \ |
| bit_depth = 8; \ |
| transform_shift = MAX_TR_DYNAMIC_RANGE - bit_depth - log2_trans_size; \ |
| quant_multiplier = 4 ; /* because quant_coeff are multiplied by 16. Instead of multiplying, we can reduce the division factor q_bits by 4 */ \ |
| q_bits = QUANT_SHIFT + qp_div + transform_shift + SCALING_Q_SHIFT - quant_multiplier - FLAT_RESCALE_MAT_Q_SHIFT /* 2048 */; \ |
| \ |
| sign = (inp)<0 ? -1:1; \ |
| \ |
| tmp = (WORD32)(abs(inp)); \ |
| tmp = tmp * (quant_coeff); \ |
| tmp = tmp + (((WORD32)q_add) << (q_bits - QUANT_ROUND_FACTOR_Q)); \ |
| tmp = tmp >> q_bits; \ |
| \ |
| tmp = tmp * sign; \ |
| out = (WORD16) CLIP_S16(tmp); \ |
| } |
| i2_temp1 = pi2_q_dst[j]; |
| if (abs(pi2_q_dst[j]) > 1) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], i2_temp, |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| } |
| |
| |
| ASSERT(abs(i2_temp1-pi2_q_dst[j]) <= 1); |
| ASSERT(abs(i2_temp1) <= abs(pi2_q_dst[j])); |
| |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| |
| /* SSD Computation & Accumulation */ |
| val = i2_temp - pi2_iq_dst[j]; |
| ssd_cost += val*val; |
| |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| |
| } |
| /* Store the cost */ |
| *pi8_cost = ssd_cost; |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| return cbf; |
| } |
| |
| WORD32 ihevc_quant_iquant_flat_scale_mat_rdoq |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD16 i2_temp; |
| |
| (void)pi8_cost; |
| (void)pi4_quant_round_factor_0_1; |
| (void)pi4_quant_round_factor_1_2; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| WORD16 i2_temp1; |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add); |
| |
| i2_temp1 = pi2_q_dst[j]; |
| |
| if (abs(pi2_q_dst[j]) > 1) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], i2_temp, |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| } |
| |
| ASSERT(abs(i2_temp1-pi2_q_dst[j]) <= 1); |
| ASSERT(abs(i2_temp1) <= abs(pi2_q_dst[j])); |
| |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization, followed by Inverse |
| * quantization to find transform domain SSD |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_q_iq_ssd_var_rnd_fact |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD32 val; |
| WORD16 i2_temp; |
| //WORD16 i2_temp_1; |
| /* Initialize cost to zero */ |
| WORD32 ssd_cost = 0; |
| |
| (void)q_add; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| |
| { |
| /* Quantization */ |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, 0); |
| if (abs(pi2_q_dst[j]) >= 2) |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| |
| } |
| else if (abs(pi2_q_dst[j]) >= 1) |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_1_2); |
| } |
| |
| else |
| { |
| /* Quantization */ |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_0_1); |
| } |
| |
| } |
| |
| |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| |
| /* SSD Computation & Accumulation */ |
| val = i2_temp - pi2_iq_dst[j]; |
| ssd_cost += val*val; |
| |
| pi4_quant_round_factor_0_1++; |
| pi4_quant_round_factor_1_2++; |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| /* Store the cost */ |
| *pi8_cost = ssd_cost; |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| WORD32 ihevc_q_iq_var_rnd_fact |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD16 i2_temp; |
| |
| (void)q_add; |
| (void)pi8_cost; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| i2_temp = pi2_coeffs[j]; |
| |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, 0); |
| |
| if (abs(pi2_q_dst[j]) >= 2) |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| } |
| else if (abs(pi2_q_dst[j]) >= 1) |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_1_2); |
| } |
| else |
| { |
| QUANT(pi2_q_dst[j],i2_temp, |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_0_1); |
| } |
| } |
| |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| shift_iq, |
| qp_div); |
| |
| pi4_quant_round_factor_0_1++; |
| pi4_quant_round_factor_1_2++; |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| } |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| |
| return cbf; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function performs quantization(using flat scale matrix), followed by |
| * inverse quantization to find transform domain SSD; when we perform RDOQ. |
| * In case the quantized value turns out to be grater than 1, we then requantize |
| * use half rounding. |
| * |
| * @par Description: |
| * Performs quantization on coeffs |
| * |
| * @param[in] pi2_coeffs |
| * 4x4 Coeffs |
| * |
| * @param[in] pi2_quant_coeff |
| * Scaling Matrix |
| * |
| * @param[out] pi2_dst |
| * Output 4x4 coefficients |
| * |
| * @param[in] qp_div |
| * Quantization parameter / 6 |
| * |
| * @param[in] qp_rem |
| * Quantization parameter % 6 |
| * |
| * @param[in] src_strd |
| * Input stride |
| * |
| * @param[in] dst_strd |
| * Output Stride |
| * |
| * @param[out] csbf |
| * coded sub block flag |
| * |
| * @param[in] csbf_strd |
| * coded sub block flag |
| * |
| * @param[out] zero_col |
| * zero column flag |
| * |
| * @param[out] zero_row |
| * zero column flag |
| * |
| * @returns cbf |
| * coded block flag |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| WORD32 ihevc_q_iq_ssd_flat_scale_mat_var_rnd_fact |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD32 val; |
| WORD16 i2_temp; |
| /* Initialize cost to zero */ |
| WORD32 ssd_cost = 0; |
| |
| (void)q_add; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| /* Quant initialization */ |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| WORD16 i2_temp1; |
| /* Back up the coefficients before Quantization */ |
| i2_temp = pi2_coeffs[j]; |
| |
| /*QUANT(pi2_dst[j], pi2_coeffs[j], |
| pi2_quant_coeff[j] * g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, q_add);*/ |
| |
| /* modified by 1028 */ |
| /* Quantization */ |
| |
| |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, 0); |
| |
| i2_temp1 = pi2_q_dst[j]; |
| |
| if (abs(pi2_q_dst[j]) >= 2) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], i2_temp, |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| } |
| else if (abs(pi2_q_dst[j]) >= 1) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_1_2); |
| } |
| |
| else |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_0_1); |
| } |
| |
| } |
| |
| |
| |
| |
| ASSERT(abs(i2_temp1-pi2_q_dst[j]) <= 1); |
| |
| |
| /* Inverse Quantization */ |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], /*pi2_dequant_coeff[index*trans_size] * g_ihevc_iquant_scales[qp_rem] */ |
| shift_iq, |
| qp_div); |
| |
| /* SSD Computation & Accumulation */ |
| val = i2_temp - pi2_iq_dst[j]; |
| ssd_cost += val*val; |
| |
| pi4_quant_round_factor_0_1++; |
| pi4_quant_round_factor_1_2++; |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| |
| } |
| /* Store the cost */ |
| *pi8_cost = ssd_cost; |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| return cbf; |
| } |
| |
| WORD32 ihevc_q_iq_flat_scale_mat_var_rnd_fact |
| ( |
| WORD16 *pi2_coeffs, |
| WORD16 *pi2_quant_coeff, |
| WORD16 *pi2_q_dst, |
| WORD16 *pi2_iq_dst, |
| WORD32 trans_size, |
| WORD32 qp_div,/* qpscaled / 6 */ |
| WORD32 qp_rem,/* qpscaled % 6 */ |
| WORD32 q_add, |
| WORD32 *pi4_quant_round_factor_0_1, |
| WORD32 *pi4_quant_round_factor_1_2, |
| WORD32 src_strd, |
| WORD32 dst_q_strd, |
| WORD32 dst_iq_strd, |
| UWORD8 *csbf, |
| WORD32 csbf_strd, |
| WORD32 *zero_col, |
| WORD32 *zero_row, |
| WORD16 *pi2_dequant_coeff, |
| LWORD64 *pi8_cost |
| ) |
| { |
| WORD32 i, j; |
| WORD32 log2_size; |
| WORD16 *pi2_q_dst_orig; |
| WORD32 cbf = 0; |
| WORD32 bit_depth,shift_iq; |
| WORD16 i2_temp; |
| |
| (void)q_add; |
| (void)pi8_cost; |
| pi2_q_dst_orig = pi2_q_dst; |
| |
| GETRANGE(log2_size, trans_size); |
| log2_size -= 1; |
| |
| bit_depth = 8 + 0; |
| shift_iq = bit_depth + log2_size - 5; |
| |
| for(i = 0; i < trans_size; i++) |
| { |
| for(j = 0; j < trans_size; j++) |
| { |
| WORD16 i2_temp1; |
| |
| i2_temp = pi2_coeffs[j]; |
| |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, 0); |
| |
| i2_temp1 = pi2_q_dst[j]; |
| |
| if (abs(pi2_q_dst[j]) >= 2) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], i2_temp, |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, ((1 << QUANT_ROUND_FACTOR_Q)/2)); |
| } |
| else if (abs(pi2_q_dst[j]) >= 1) |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_1_2); |
| } |
| else |
| { |
| QUANT_NO_WEIGHTMAT(pi2_q_dst[j], pi2_coeffs[j], |
| g_ihevc_quant_scales[qp_rem], qp_div, |
| log2_size, *pi4_quant_round_factor_0_1); |
| } |
| } |
| |
| ASSERT(abs(i2_temp1-pi2_q_dst[j]) <= 1); |
| |
| IQUANT(pi2_iq_dst[j], |
| pi2_q_dst[j], /*pi2_src[index*src_strd]*/ |
| pi2_dequant_coeff[j]*g_ihevc_iquant_scales[qp_rem], |
| shift_iq, |
| qp_div); |
| |
| pi4_quant_round_factor_0_1++; |
| pi4_quant_round_factor_1_2++; |
| } |
| |
| pi2_q_dst += dst_q_strd; |
| pi2_iq_dst += dst_iq_strd; |
| pi2_quant_coeff += trans_size; |
| pi2_coeffs += src_strd; |
| pi2_dequant_coeff += trans_size; |
| |
| } |
| |
| /* CSBF update */ |
| { |
| WORD32 block_row, block_col; |
| WORD32 row, col; |
| WORD16 *pi2_block; |
| UWORD32 temp_zero_col = 0; |
| UWORD32 temp_zero_row = 0; |
| |
| pi2_q_dst = pi2_q_dst_orig; |
| |
| for(block_row = 0; block_row < trans_size; block_row += 4) |
| { |
| //block_col is incrementing by 1 for easy update of csbf pointer |
| for(block_col = 0; block_col < trans_size / 4; block_col++) |
| { |
| pi2_block = pi2_q_dst + block_row * dst_q_strd + block_col * 4; |
| *(csbf + block_col) = 0; |
| |
| for(row = 0; row < 4; row++) |
| { |
| for(col = 0; col < 4; col++) |
| { |
| if(pi2_block[row * dst_q_strd + col] != 0) |
| { |
| *(csbf + block_col) = 1; |
| break; |
| } |
| } |
| if(*(csbf + block_col) == 1) |
| { |
| /* zero_col update *//* temp_zero_col = ~zero_col */ |
| temp_zero_col = (temp_zero_col) | (0xFU << block_col * 4); |
| // zero col can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 colums of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| /* zero row update */ /* temp_zero_row = ~zero_row */ |
| temp_zero_row = (temp_zero_row) | (0xFU << block_row); |
| // zero row can be optimized further. Now clearing the |
| // entire 4 bits corresponding to 4 rows of 4x4 block |
| // even if any 4x4 csbf is set |
| |
| break; |
| } |
| } |
| |
| cbf = cbf || (*(csbf + block_col)); // cbf update |
| } |
| csbf += csbf_strd; |
| } |
| |
| *zero_col = ~temp_zero_col; //final zero_col storing |
| *zero_row = ~temp_zero_row; //final zero_row storing |
| } |
| return cbf; |
| } |
