king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
v811_spc009/external/libhevc/encoder/arm/ihevce_scan_coeffs_neon.c

497 lines
18 KiB
Raw Permalink Blame History

/******************************************************************************
*
* 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
* ihevce_scan_coeffs_neon.c
*
* @brief
* Contains definitions for scanning quantized tu
*
* @author
* Ittiam
*
* @par List of Functions:
*
* @remarks
* None
*
********************************************************************************
*/
/*****************************************************************************/
/* File Includes */
/*****************************************************************************/
/* System include files */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <arm_neon.h>
/* User include files */
#include "ihevc_typedefs.h"
#include "itt_video_api.h"
#include "ihevc_defs.h"
#include "ihevc_debug.h"
#include "ihevce_api.h"
#include "ihevce_defs.h"
#include "rc_cntrl_param.h"
#include "rc_frame_info_collector.h"
#include "rc_look_ahead_params.h"
#include "ihevce_lap_enc_structs.h"
#include "ihevc_platform_macros.h"
#include "ihevc_structs.h"
#include "ihevce_multi_thrd_structs.h"
#include "ihevc_deblk.h"
#include "ihevc_itrans_recon.h"
#include "ihevc_chroma_itrans_recon.h"
#include "ihevc_chroma_intra_pred.h"
#include "ihevc_intra_pred.h"
#include "ihevc_inter_pred.h"
#include "ihevc_mem_fns.h"
#include "ihevc_padding.h"
#include "ihevc_weighted_pred.h"
#include "ihevc_sao.h"
#include "ihevc_resi_trans.h"
#include "ihevc_quant_iquant_ssd.h"
#include "ihevce_function_selector.h"
#include "ihevce_me_common_defs.h"
#include "ihevce_enc_structs.h"
#include "ihevce_global_tables.h"
#include "ihevce_ipe_instr_set_router.h"
#include "ihevce_common_utils.h"
/*****************************************************************************/
/* Function Declarations */
/*****************************************************************************/
FT_SCAN_COEFFS ihevce_scan_coeffs_neon;
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
static WORD32 movemask_neon(uint8x16_t input)
{
const int8_t __attribute__((aligned(16))) xr[8] = { -7, -6, -5, -4, -3, -2, -1, 0 };
uint8x8_t mask_and = vdup_n_u8(0x80);
int8x8_t mask_shift = vld1_s8(xr);
uint8x8_t lo = vget_low_u8(input);
uint8x8_t hi = vget_high_u8(input);
lo = vand_u8(lo, mask_and);
lo = vshl_u8(lo, mask_shift);
hi = vand_u8(hi, mask_and);
hi = vshl_u8(hi, mask_shift);
lo = vpadd_u8(lo, lo);
lo = vpadd_u8(lo, lo);
lo = vpadd_u8(lo, lo);
hi = vpadd_u8(hi, hi);
hi = vpadd_u8(hi, hi);
hi = vpadd_u8(hi, hi);
return ((hi[0] << 8) | (lo[0] & 0xFF));
}
WORD32 ihevce_scan_coeffs_neon(
WORD16 *pi2_quant_coeffs,
WORD32 *pi4_subBlock2csbfId_map,
WORD32 scan_idx,
WORD32 trans_size,
UWORD8 *pu1_out_data,
UWORD8 *pu1_csbf_buf,
WORD32 i4_csbf_stride)
{
WORD32 i, trans_unit_idx, num_gt1_flag, num_gt0_flag;
UWORD16 u2_csbf0flags;
WORD32 num_bytes = 0;
UWORD8 *pu1_trans_table;
UWORD8 *pu1_csb_table;
WORD32 shift_value, mask_value;
WORD32 blk_row, blk_col;
WORD32 x_pos, y_pos;
WORD32 quant_coeff;
UWORD8 *pu1_out_data_header;
UWORD16 *pu2_out_data_coeff;
int8x16_t one, shuffle, zero;
int16x8_t ones;
int8x8x2_t quant;
(void)i4_csbf_stride;
pu1_out_data_header = pu1_out_data;
u2_csbf0flags = 0xBAD0;
pu1_csb_table = (UWORD8 *)&(g_u1_scan_table_4x4[scan_idx][0]);
GETRANGE(shift_value, trans_size);
shift_value = shift_value - 3;
mask_value = (trans_size / 4) - 1;
switch(trans_size)
{
case 32:
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_8x8[scan_idx][0]);
break;
case 16:
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_4x4[scan_idx][0]);
break;
case 8:
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_2x2[scan_idx][0]);
break;
case 4:
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_1x1[0]);
break;
}
shuffle = vld1q_s8((WORD8 *)pu1_csb_table);
zero = vdupq_n_s8(0);
one = vdupq_n_s8(1);
ones = vdupq_n_s16(1);
for(trans_unit_idx = (trans_size * trans_size / 16) - 1; trans_unit_idx >= 0; trans_unit_idx--)
{
if(pu1_csbf_buf[pi4_subBlock2csbfId_map[pu1_trans_table[trans_unit_idx]]])
{
WORD32 sig_coeff_abs_gt0_flags, sig_coeff_abs_gt1_flags;
WORD32 sign_flag, pos_last_coded;
UWORD8 u1_last_x, u1_last_y;
WORD16 *pi2_temp_quant_coeff = pi2_quant_coeffs;
int16x4_t quant0, quant1, quant2, quant3;
int16x8_t quant01, quant23;
int8x8_t a, b, c, d, shuffle_0, shuffle_1;
int8x16_t shuffle_out, shuffle_out_abs;
uint8x16_t sign, eq0, eq1;
blk_row = pu1_trans_table[trans_unit_idx] >> shift_value;
blk_col = pu1_trans_table[trans_unit_idx] & mask_value;
pi2_temp_quant_coeff += (blk_col * 4 + (blk_row * 4) * trans_size);
quant0 = vld1_s16(pi2_temp_quant_coeff + 0 * trans_size);
quant1 = vld1_s16(pi2_temp_quant_coeff + 1 * trans_size);
quant2 = vld1_s16(pi2_temp_quant_coeff + 2 * trans_size);
quant3 = vld1_s16(pi2_temp_quant_coeff + 3 * trans_size);
quant01 = vcombine_s16(quant0, quant1);
quant23 = vcombine_s16(quant2, quant3);
a = vqmovn_s16(quant01);
b = vqmovn_s16(quant23);
quant.val[0] = a;
quant.val[1] = b;
c = vget_low_s8(shuffle);
d = vget_high_s8(shuffle);
shuffle_0 = vtbl2_s8(quant, c);
shuffle_1 = vtbl2_s8(quant, d);
shuffle_out = vcombine_s8(shuffle_0, shuffle_1);
shuffle_out_abs = vabsq_s8(shuffle_out);
sign = vcgtq_s8(zero, shuffle_out);
eq0 = vceqq_s8(shuffle_out, zero);
eq1 = vceqq_s8(shuffle_out_abs, one);
sign_flag = movemask_neon(sign);
sig_coeff_abs_gt0_flags = movemask_neon(eq0);
sig_coeff_abs_gt1_flags = movemask_neon(eq1);
sig_coeff_abs_gt0_flags = ~sig_coeff_abs_gt0_flags;
sig_coeff_abs_gt1_flags = ~sig_coeff_abs_gt1_flags;
sig_coeff_abs_gt0_flags = sig_coeff_abs_gt0_flags & 0x0000FFFF;
sig_coeff_abs_gt1_flags = sig_coeff_abs_gt1_flags & sig_coeff_abs_gt0_flags;
ASSERT(sig_coeff_abs_gt0_flags != 0);
GET_POS_MSB_32(pos_last_coded, sig_coeff_abs_gt0_flags);
/* Update gt1 flag based on num_gt0_flag */
num_gt0_flag = ihevce_num_ones_popcnt(sig_coeff_abs_gt0_flags);
/* Find the position of 9th(MAX_GT_ONE+1) 1 in sig_coeff_abs_gt0_flags from MSB and update gt1 flag */
if(num_gt0_flag > MAX_GT_ONE)
{
WORD32 gt0_first_byte = sig_coeff_abs_gt0_flags & 0xFF;
WORD32 num_gt0_second_byte =
ihevce_num_ones_popcnt(sig_coeff_abs_gt0_flags & 0xFF00);
WORD32 pos_nineth_one; /* pos. of 9th one from MSB of sig_coeff_abs_gt0_flags */
WORD32 gt0_after_nineth_one, num_gt0_first_byte_to_nine;
num_gt0_first_byte_to_nine = (MAX_GT_ONE + 1) - num_gt0_second_byte;
while(num_gt0_first_byte_to_nine)
{
GET_POS_MSB_32(pos_nineth_one, gt0_first_byte);
gt0_first_byte = CLEAR_BIT(
gt0_first_byte,
pos_nineth_one); /*gt0_second_byte &= (~(0x1<<pos_eighth_one));*/
num_gt0_first_byte_to_nine--;
}
/* Update gt1 based on pos_eighth_one */
gt0_after_nineth_one = SET_BIT(gt0_first_byte, pos_nineth_one);
sig_coeff_abs_gt1_flags = sig_coeff_abs_gt1_flags | gt0_after_nineth_one;
}
/* Get x_pos & y_pos of last coded in csb wrt to TU */
u1_last_x = (pu1_csb_table[pos_last_coded] & 0x3) + blk_col * 4;
u1_last_y = (pu1_csb_table[pos_last_coded] >> 2) + blk_row * 4;
num_gt1_flag = ihevce_num_ones_popcnt(sig_coeff_abs_gt1_flags);
/* storing last_x and last_y */
*pu1_out_data_header = u1_last_x;
pu1_out_data_header++;
*pu1_out_data_header = u1_last_y;
pu1_out_data_header++;
/* storing the scan order */
*pu1_out_data_header = (UWORD8)scan_idx;
pu1_out_data_header++;
/* storing last_sub_block pos. in scan order count */
*pu1_out_data_header = (UWORD8)trans_unit_idx;
pu1_out_data_header++;
/*stored the first 4 bytes, now all are word16. So word16 pointer*/
pu2_out_data_coeff = (UWORD16 *)pu1_out_data_header;
/* u2_csbf0flags word */
u2_csbf0flags = 0xBAD0 | 1; /*since right&bottom csbf is 0*/
/* storing u2_csbf0flags word */
*pu2_out_data_coeff = u2_csbf0flags;
pu2_out_data_coeff++;
/* storing u2_sig_coeff_abs_gt0_flags 2 bytes */
*pu2_out_data_coeff = (UWORD16)sig_coeff_abs_gt0_flags;
pu2_out_data_coeff++;
/* storing u2_sig_coeff_abs_gt1_flags 2 bytes */
*pu2_out_data_coeff = (UWORD16)sig_coeff_abs_gt1_flags;
pu2_out_data_coeff++;
/* storing u2_sign_flags 2 bytes */
*pu2_out_data_coeff = (UWORD16)sign_flag;
pu2_out_data_coeff++;
/* Store the u2_abs_coeff_remaining[] */
for(i = 0; i < num_gt1_flag; i++)
{
volatile WORD32 bit_pos;
ASSERT(sig_coeff_abs_gt1_flags != 0);
GET_POS_MSB_32(bit_pos, sig_coeff_abs_gt1_flags);
sig_coeff_abs_gt1_flags = CLEAR_BIT(
sig_coeff_abs_gt1_flags,
bit_pos); /*sig_coeff_abs_gt1_flags &= (~(0x1<<bit_pos));*/
x_pos = (pu1_csb_table[bit_pos] & 0x3);
y_pos = (pu1_csb_table[bit_pos] >> 2);
quant_coeff = pi2_temp_quant_coeff[x_pos + (y_pos * trans_size)];
/* storing u2_abs_coeff_remaining[i] 2 bytes */
*pu2_out_data_coeff = (UWORD16)abs(quant_coeff) - 1;
pu2_out_data_coeff++;
}
break; /*We just need this loop for finding 1st non-zero csb only*/
}
}
/* go through remaining csb in the scan order */
for(trans_unit_idx = trans_unit_idx - 1; trans_unit_idx >= 0; trans_unit_idx--)
{
blk_row = pu1_trans_table[trans_unit_idx] >> shift_value; /*row of csb*/
blk_col = pu1_trans_table[trans_unit_idx] & mask_value; /*col of csb*/
/* u2_csbf0flags word */
u2_csbf0flags = 0xBAD0 | /* assuming csbf_buf has only 0 or 1 values */
(pu1_csbf_buf[pi4_subBlock2csbfId_map[pu1_trans_table[trans_unit_idx]]]);
/********************************************************************/
/* Minor hack: As per HEVC spec csbf in not signalled in stream for */
/* block0, instead sig coeff map is directly signalled. This is */
/* taken care by forcing csbf for block0 to be 1 even if it is 0 */
/********************************************************************/
if(0 == trans_unit_idx)
{
u2_csbf0flags |= 1;
}
if((blk_col + 1 < trans_size / 4)) /* checking right boundary */
{
if(pu1_csbf_buf[pi4_subBlock2csbfId_map[blk_row * trans_size / 4 + blk_col + 1]])
{
/* set the 2nd bit of u2_csbf0flags for right csbf */
u2_csbf0flags = u2_csbf0flags | (1 << 1);
}
}
if((blk_row + 1 < trans_size / 4)) /* checking bottom oundary */
{
if(pu1_csbf_buf[pi4_subBlock2csbfId_map[(blk_row + 1) * trans_size / 4 + blk_col]])
{
/* set the 3rd bit of u2_csbf0flags for bottom csbf */
u2_csbf0flags = u2_csbf0flags | (1 << 2);
}
}
/* storing u2_csbf0flags word */
*pu2_out_data_coeff = u2_csbf0flags;
pu2_out_data_coeff++;
/* check for the csb flag in our scan order */
if(u2_csbf0flags & 0x1)
{
WORD32 sig_coeff_abs_gt0_flags, sig_coeff_abs_gt1_flags;
WORD32 sign_flag;
int16x4_t quant0, quant1, quant2, quant3;
int16x8_t quant01, quant23;
int8x8_t a, b, c, d, shuffle_0, shuffle_1;
int8x16_t shuffle_out, shuffle_out_abs;
uint8x16_t sign, eq0, eq1;
/* x_pos=blk_col*4, y_pos=blk_row*4 */
WORD16 *pi2_temp_quant_coeff =
pi2_quant_coeffs + blk_col * 4 + (blk_row * 4) * trans_size;
/* Load Quant Values */
quant0 = vld1_s16(pi2_temp_quant_coeff + 0 * trans_size);
quant1 = vld1_s16(pi2_temp_quant_coeff + 1 * trans_size);
quant2 = vld1_s16(pi2_temp_quant_coeff + 2 * trans_size);
quant3 = vld1_s16(pi2_temp_quant_coeff + 3 * trans_size);
/* Two quant rows together */
quant01 = vcombine_s16(quant0, quant1);
quant23 = vcombine_s16(quant2, quant3);
/* All 4 rows: For sign, gt0, gt1 flags, even 8 bit version is enough! */
a = vqmovn_s16(quant01);
b = vqmovn_s16(quant23);
quant.val[0] = a;
quant.val[1] = b;
c = vget_low_s8(shuffle);
d = vget_high_s8(shuffle);
shuffle_0 = vtbl2_s8(quant, c);
shuffle_1 = vtbl2_s8(quant, d);
shuffle_out = vcombine_s8(shuffle_0, shuffle_1);
/* ABS values */
shuffle_out_abs = vabsq_s8(shuffle_out);
/* sign bits : Will get 0xFF if (0 > shuffle_out) */
sign = vcgtq_s8(zero, shuffle_out);
/* gt0 : Will get 0xFF if ( shuffle_out == 0 ) */
eq0 = vceqq_s8(shuffle_out, zero);
/* gt1 : Will get 0xFF if ( abs(shuffle_out) == 1 ) */
eq1 = vceqq_s8(shuffle_out_abs, one);
/* movemask:0 extended upper 16bits,Only low16 bits are required while storing */
sign_flag = movemask_neon(sign);
sig_coeff_abs_gt0_flags = movemask_neon(eq0);
sig_coeff_abs_gt1_flags = movemask_neon(eq1);
/* Update gt0 and gt1 based on ==0 and ==1 flag */
sig_coeff_abs_gt0_flags = ~sig_coeff_abs_gt0_flags; /* != 0 */
sig_coeff_abs_gt1_flags = ~sig_coeff_abs_gt1_flags; /* (abs) != 1 */
sig_coeff_abs_gt0_flags = sig_coeff_abs_gt0_flags & 0x0000FFFF; /* Clear high Word */
sig_coeff_abs_gt1_flags = sig_coeff_abs_gt1_flags & sig_coeff_abs_gt0_flags;
/* Update gt1 flag based on num_gt0_flag */
num_gt0_flag = ihevce_num_ones_popcnt(sig_coeff_abs_gt0_flags);
/* Find the position of 9th(MAX_GT_ONE+1) 1 in sig_coeff_abs_gt0_flags from MSB and update gt1 flag */
if(num_gt0_flag > MAX_GT_ONE)
{
WORD32 gt0_first_byte = sig_coeff_abs_gt0_flags & 0xFF;
WORD32 num_gt0_second_byte =
ihevce_num_ones_popcnt(sig_coeff_abs_gt0_flags & 0xFF00);
WORD32 pos_nineth_one; /* pos. of 9th one from MSB of sig_coeff_abs_gt0_flags */
WORD32 gt0_after_nineth_one, num_gt0_first_byte_to_nine;
num_gt0_first_byte_to_nine = (MAX_GT_ONE + 1) - num_gt0_second_byte;
while(num_gt0_first_byte_to_nine)
{
GET_POS_MSB_32(pos_nineth_one, gt0_first_byte);
gt0_first_byte = CLEAR_BIT(
gt0_first_byte,
pos_nineth_one); /*gt0_second_byte &= (~(0x1<<pos_eighth_one));*/
num_gt0_first_byte_to_nine--;
}
/* Update gt1 based on pos_eighth_one */
gt0_after_nineth_one = SET_BIT(gt0_first_byte, pos_nineth_one);
sig_coeff_abs_gt1_flags = sig_coeff_abs_gt1_flags | gt0_after_nineth_one;
}
num_gt1_flag = ihevce_num_ones_popcnt(sig_coeff_abs_gt1_flags);
/* storing u2_sig_coeff_abs_gt0_flags 2 bytes */
*pu2_out_data_coeff = (UWORD16)sig_coeff_abs_gt0_flags;
pu2_out_data_coeff++;
/* storing u2_sig_coeff_abs_gt1_flags 2 bytes */
*pu2_out_data_coeff = (UWORD16)sig_coeff_abs_gt1_flags;
pu2_out_data_coeff++;
/* storing u2_sign_flags 2 bytes */
*pu2_out_data_coeff = (UWORD16)sign_flag;
pu2_out_data_coeff++;
/* Store the u2_abs_coeff_remaining[] */
for(i = 0; i < num_gt1_flag; i++)
{
volatile WORD32 bit_pos;
ASSERT(sig_coeff_abs_gt1_flags != 0);
GET_POS_MSB_32(bit_pos, sig_coeff_abs_gt1_flags);
sig_coeff_abs_gt1_flags = CLEAR_BIT(
sig_coeff_abs_gt1_flags,
bit_pos); /*sig_coeff_abs_gt1_flags &= (~(0x1<<bit_pos));*/
x_pos = (pu1_csb_table[bit_pos] & 0x3);
y_pos = (pu1_csb_table[bit_pos] >> 2);
quant_coeff = pi2_temp_quant_coeff[x_pos + (y_pos * trans_size)];
/* storing u2_abs_coeff_remaining[i] 2 bytes */
*pu2_out_data_coeff = (UWORD16)abs(quant_coeff) - 1;
pu2_out_data_coeff++;
}
}
}
num_bytes = (UWORD8 *)pu2_out_data_coeff - pu1_out_data;
return num_bytes; /* Return the number of bytes written to out_data */
}
Reference in new issue View Git Blame Copy Permalink