/******************************************************************************
|
*
|
* 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_bs_compute_ctb.c
|
*
|
* @brief
|
* This file contains functions needed for boundary strength calculation
|
*
|
* @author
|
* ittiam
|
*
|
* @List of Functions
|
* ihevce_bs_init_ctb()
|
* ihevce_bs_compute_ctb()
|
* ihevce_bs_clear_invalid()
|
*
|
******************************************************************************
|
*/
|
|
/*****************************************************************************/
|
/* File Includes */
|
/*****************************************************************************/
|
/* System include files */
|
#include <stdio.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <assert.h>
|
#include <stdarg.h>
|
#include <math.h>
|
|
/* User include files */
|
#include "ihevc_typedefs.h"
|
#include "itt_video_api.h"
|
#include "ihevce_api.h"
|
|
#include "rc_cntrl_param.h"
|
#include "rc_frame_info_collector.h"
|
#include "rc_look_ahead_params.h"
|
|
#include "ihevc_defs.h"
|
#include "ihevc_structs.h"
|
#include "ihevc_platform_macros.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 "ihevc_cabac_tables.h"
|
|
#include "ihevce_defs.h"
|
#include "ihevce_lap_enc_structs.h"
|
#include "ihevce_multi_thrd_structs.h"
|
#include "ihevce_me_common_defs.h"
|
#include "ihevce_had_satd.h"
|
#include "ihevce_error_codes.h"
|
#include "ihevce_bitstream.h"
|
#include "ihevce_cabac.h"
|
#include "ihevce_rdoq_macros.h"
|
#include "ihevce_function_selector.h"
|
#include "ihevce_enc_structs.h"
|
#include "ihevce_entropy_structs.h"
|
#include "ihevce_cmn_utils_instr_set_router.h"
|
#include "ihevce_enc_loop_structs.h"
|
#include "ihevce_bs_compute_ctb.h"
|
#include "ihevce_global_tables.h"
|
|
/*****************************************************************************/
|
/* Global Tables */
|
/*****************************************************************************/
|
// clang-format off
|
UWORD16 gau2_bs_table[2][8] =
|
{
|
{ BS_INTRA_4, BS_INTRA_8, BS_INVALID, BS_INTRA_16, BS_INVALID, BS_INVALID, BS_INVALID, BS_INTRA_32 },
|
{ BS_CBF_4, BS_CBF_8, BS_INVALID, BS_CBF_16, BS_INVALID, BS_INVALID, BS_INVALID, BS_CBF_32 }
|
};
|
// clang-format on
|
|
/*****************************************************************************/
|
/* Function Definitions */
|
/*****************************************************************************/
|
|
/**
|
*******************************************************************************
|
*
|
* @brief Initialize the Boundary Strength at a CTB level
|
*
|
* @par Description
|
* Initialize the Boundary Strength at a CTB level to zeros*
|
*
|
* @param[out] ps_deblk_prms
|
* Pointer to structure s_deblk_prms, which contains
|
* s_deblk_prms.au4_horz_bs : max of 8 such conti. bs to be comp. for 64x64 ctb
|
* s_deblk_prms.au4_vert_bs : max of 8 such conti. bs to be comp. for 64x64 ctb
|
*
|
* @param[in] ctb_size
|
* Size in pels (can be 16, 32 or 64)
|
*
|
* @returns none
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
void ihevce_bs_init_ctb(
|
deblk_bs_ctb_ctxt_t *ps_deblk_prms,
|
frm_ctb_ctxt_t *ps_frm_ctb_prms,
|
WORD32 ctb_ctr,
|
WORD32 vert_ctr)
|
{
|
WORD32 ctb_size = ps_frm_ctb_prms->i4_ctb_size;
|
|
/* Pointer to the array to store the packed BS values in horizontal dir. */
|
UWORD32 *pu4_horz_bs = &ps_deblk_prms->au4_horz_bs[0];
|
/* Pointer to the array to store the packed BS values in vertical dir. */
|
UWORD32 *pu4_vert_bs = &ps_deblk_prms->au4_vert_bs[0];
|
|
WORD32 i4_top_ctb_tile_id, i4_left_ctb_tile_id;
|
WORD32 *pi4_tile_id_map_temp;
|
|
pi4_tile_id_map_temp = ps_frm_ctb_prms->pi4_tile_id_map +
|
vert_ctr * ps_frm_ctb_prms->i4_tile_id_ctb_map_stride + ctb_ctr;
|
|
i4_left_ctb_tile_id = *(pi4_tile_id_map_temp - 1);
|
i4_top_ctb_tile_id = *(pi4_tile_id_map_temp - ps_frm_ctb_prms->i4_tile_id_ctb_map_stride);
|
|
ps_deblk_prms->u1_not_first_ctb_row_of_frame = (i4_top_ctb_tile_id != -1);
|
ps_deblk_prms->u1_not_first_ctb_col_of_frame = (i4_left_ctb_tile_id != -1);
|
|
/* BS should be set to NULL in the following cases
|
Frame boundaries
|
Edges if deblocking is disabled by disable_deblocking_filter_flag
|
Slice boundaries if deblocking across slices is disabled
|
Tile boundaries if deblocking across slices is disabled
|
These are not considered now, except the frame boundary
|
*/
|
|
/* Initializing the bs array to 0. array size = (ctb_size/8 + 1)*4 bytes */
|
memset(pu4_horz_bs, 0, ((ctb_size >> 3) + 1) * sizeof(UWORD32));
|
memset(pu4_vert_bs, 0, ((ctb_size >> 3) + 1) * sizeof(UWORD32));
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief Calculate the Boundary Strength at CU level
|
*
|
* @par Description
|
* Calculate the Boundary Strength at CU level
|
*
|
* @param[in] ps_cu_final
|
* Pointer to the final CU structure, of which we use the following values
|
* u2_num_tus_in_cu : Total TUs in this CU
|
* ps_enc_tu : Pointer to first tu of this cu. Each TU need to be
|
* populated in TU order.
|
* u4_pred_mode_flag : The prediction mode flag for the CU
|
* cu_size : CU size in terms of min CU (8x8) units
|
* cu_pos_x : X Position of CU in current ctb
|
* cu_pos_y : Y Position of CU in current ctb
|
* u4_part_mode : Partition information for CU. For inter 0 : @sa PART_SIZE_E
|
* ps_pu : Pointer to first pu of this cu
|
*
|
* @param[in] ps_top_nbr_4x4
|
* Pointer to top 4x4 CU nbr structure
|
*
|
* @param[in] ps_left_nbr_4x4
|
* Pointer to left 4x4 CU nbr structure
|
*
|
* @param[in] ps_curr_nbr_4x4
|
* Pointer to current 4x4 ctb structure
|
*
|
* @param[in] nbr_4x4_left_strd
|
* Left nbr buffer stride in terms of 4x4 units
|
*
|
* @param[in] num_4x4_in_ctb
|
* Current buffer stride in terms of 4x4 units
|
*
|
* @param[out] ps_deblk_prms
|
* Pointer to structure s_deblk_prms, which contains
|
* s_deblk_prms.au4_horz_bs : max of 8 such conti. bs to be comp. for 64x64 ctb
|
* s_deblk_prms.au4_vert_bs : max of 8 such conti. bs to be comp. for 64x64 ctb
|
*
|
* @returns none
|
*
|
* @remarks
|
* 1 : Setting all 4 edges for a TU or PU block. Which is inefficient in
|
* a) may set the BS twice b) set the frame/slice boundaries
|
* 2 : always update BS using bit-wise OR, which may set BS to 3 also.
|
* ( Deblocking should take care of it as 2 itself )
|
*
|
*******************************************************************************
|
*/
|
void ihevce_bs_compute_cu(
|
cu_enc_loop_out_t *ps_cu_final,
|
nbr_4x4_t *ps_top_nbr_4x4,
|
nbr_4x4_t *ps_left_nbr_4x4,
|
nbr_4x4_t *ps_curr_nbr_4x4,
|
WORD32 nbr_4x4_left_strd,
|
WORD32 num_4x4_in_ctb,
|
deblk_bs_ctb_ctxt_t *ps_deblk_prms)
|
{
|
WORD32 i;
|
WORD32 j;
|
/* copy required arguments from pointer to CU structure */
|
/* Total TUs in this CU */
|
UWORD16 u2_num_tus_in_cu = ps_cu_final->u2_num_tus_in_cu;
|
/* Pointer to first tu of this cu */
|
tu_enc_loop_out_t *ps_enc_tu = ps_cu_final->ps_enc_tu;
|
/* The prediction mode flag for the CU */
|
UWORD32 u4_pred_mode_flag = ps_cu_final->b1_pred_mode_flag;
|
/* X Position of CU in current ctb in (8x8) units */
|
WORD32 cu_pos_x = ps_cu_final->b3_cu_pos_x;
|
/* Y Position of CU in current ctb in (8x8) units */
|
WORD32 cu_pos_y = ps_cu_final->b3_cu_pos_y;
|
|
/* Indicates partition information for CU */
|
UWORD32 u4_part_mode = ps_cu_final->b3_part_mode;
|
|
/* Pointer to first pu of this cu */
|
pu_t *ps_pu = ps_cu_final->ps_pu;
|
|
/* Number of pus in current cu */
|
WORD32 num_pus_in_cu;
|
/* Pointer to the array to store the packed BS values in horizontal dir. */
|
UWORD32 *pu4_horz_bs = &ps_deblk_prms->au4_horz_bs[0];
|
/* Pointer to the array to store the packed BS values in vertical dir. */
|
UWORD32 *pu4_vert_bs = &ps_deblk_prms->au4_vert_bs[0];
|
|
(void)ps_curr_nbr_4x4;
|
(void)num_4x4_in_ctb;
|
|
/* CTB boundary case setting the BS for intra and cbf non zero case for CU top edge */
|
if((ps_deblk_prms->u1_not_first_ctb_row_of_frame) && (0 == ps_cu_final->b3_cu_pos_y))
|
{
|
nbr_4x4_t *ps_nbr_4x4;
|
UWORD32 u4_temp_bs = *pu4_horz_bs;
|
WORD32 horz_bit_offset;
|
WORD32 ctr;
|
|
/* every 4x4 takes 2 bits in the register this is taken care in the loop */
|
/* deriving 4x4 position */
|
horz_bit_offset = (ps_cu_final->b3_cu_pos_x << 3) >> 2;
|
|
/* scanning through each 4x4 csb along horizontal direction */
|
for(ctr = 0; ctr < ((ps_cu_final->b4_cu_size << 3) >> 2); ctr++)
|
{
|
ps_nbr_4x4 = ps_top_nbr_4x4 + ctr;
|
if(ps_nbr_4x4->b1_intra_flag)
|
{
|
/* To store in BigEnd. format. BS[0]|BS[1]| .. |BS[15] */
|
u4_temp_bs = (u4_temp_bs | (2U << (30 - 2 * (ctr + horz_bit_offset))));
|
}
|
else if(ps_nbr_4x4->b1_y_cbf)
|
{
|
/* To store in BigEnd. format. BS[0]|BS[1]| .. |BS[15] */
|
u4_temp_bs = (u4_temp_bs | (1 << (30 - 2 * (ctr + horz_bit_offset))));
|
}
|
}
|
|
/* storing the BS computed for first row based on top ctb CUs */
|
*(pu4_horz_bs) = u4_temp_bs;
|
}
|
|
/* CTB boundary case setting the BS for intra and cbf non zero case for CU left edge */
|
if((ps_deblk_prms->u1_not_first_ctb_col_of_frame) && (0 == ps_cu_final->b3_cu_pos_x))
|
{
|
nbr_4x4_t *ps_nbr_4x4;
|
UWORD32 u4_temp_bs = *pu4_vert_bs;
|
WORD32 vert_bit_offset;
|
WORD32 ctr;
|
|
/* every 4x4 takes 2 bits in the register this is taken care in the loop */
|
/* deriving 4x4 position */
|
vert_bit_offset = (ps_cu_final->b3_cu_pos_y << 3) >> 2;
|
|
/* scanning through each 4x4 csb along vertical direction */
|
for(ctr = 0; ctr < ((ps_cu_final->b4_cu_size << 3) >> 2); ctr++)
|
{
|
ps_nbr_4x4 = ps_left_nbr_4x4 + ctr * nbr_4x4_left_strd;
|
if(ps_nbr_4x4->b1_intra_flag)
|
{
|
/* To store in BigEnd. format. BS[0]|BS[1]| .. |BS[15] */
|
u4_temp_bs = (u4_temp_bs | (2U << (30 - 2 * (ctr + vert_bit_offset))));
|
}
|
else if(ps_nbr_4x4->b1_y_cbf)
|
{
|
/* To store in BigEnd. format. BS[0]|BS[1]| .. |BS[15] */
|
u4_temp_bs = (u4_temp_bs | (1 << (30 - 2 * (ctr + vert_bit_offset))));
|
}
|
}
|
|
/* storing the BS computed for first col based on left ctb Cus */
|
*(pu4_vert_bs) = u4_temp_bs;
|
}
|
|
/* Passes through each TU inside the CU */
|
for(i = 0; i < u2_num_tus_in_cu; i++)
|
{
|
UWORD32 u4_tu_pos_x, u4_tu_pos_y;
|
UWORD32 u4_tu_size;
|
UWORD32 *pu4_tu_top_edge;
|
UWORD32 *pu4_tu_bottom_edge;
|
UWORD32 *pu4_tu_left_edge;
|
UWORD32 *pu4_tu_right_edge;
|
UWORD32 u4_bs_value;
|
WORD32 set_bs_flag = 0;
|
WORD32 tbl_idx = 1;
|
|
/* TU_size calculation */
|
u4_tu_size = 1 << ((ps_enc_tu->s_tu.b3_size) + 2);
|
|
/* TU X position in terms of min TU (4x4) units wrt ctb */
|
u4_tu_pos_x = ps_enc_tu->s_tu.b4_pos_x;
|
/* TU Y position in terms of min TU (4x4) units wrt ctb */
|
u4_tu_pos_y = ps_enc_tu->s_tu.b4_pos_y;
|
|
/* pointers to the edges of current TU */
|
pu4_tu_top_edge = pu4_horz_bs + (u4_tu_pos_y >> 1);
|
pu4_tu_bottom_edge = pu4_horz_bs + ((u4_tu_pos_y + 1) >> 1) + (u4_tu_size >> 3);
|
pu4_tu_left_edge = pu4_vert_bs + (u4_tu_pos_x >> 1);
|
pu4_tu_right_edge = pu4_vert_bs + ((u4_tu_pos_x + 1) >> 1) + (u4_tu_size >> 3);
|
|
/* chooose the table index based on pred_mode */
|
if(PRED_MODE_INTRA == u4_pred_mode_flag)
|
{
|
tbl_idx = 0;
|
}
|
|
/* get the BS value from table if required */
|
if((ps_enc_tu->s_tu.b1_y_cbf) || (PRED_MODE_INTRA == u4_pred_mode_flag))
|
{
|
set_bs_flag = 1;
|
u4_bs_value = gau2_bs_table[tbl_idx][(u4_tu_size >> 2) - 1];
|
}
|
|
if(1 == set_bs_flag)
|
{
|
/* Store the BS value */
|
if(4 == u4_tu_size)
|
{
|
if(0 == (u4_tu_pos_y & 1))
|
{
|
/* Only top TU edge came on a 8 pixel bounadey */
|
SET_VALUE_BIG((pu4_tu_top_edge), u4_bs_value, u4_tu_pos_x, u4_tu_size);
|
}
|
else
|
{
|
/* Only bottom TU edge came on a 8 pixel bounadey */
|
SET_VALUE_BIG((pu4_tu_bottom_edge), u4_bs_value, u4_tu_pos_x, u4_tu_size);
|
}
|
if(0 == (u4_tu_pos_x & 1))
|
{
|
/* Only left TU edge came on a 8 pixel bounadey */
|
SET_VALUE_BIG((pu4_tu_left_edge), u4_bs_value, u4_tu_pos_y, u4_tu_size);
|
}
|
else
|
{
|
/* Only right TU edge came on a 8 pixel bounadey */
|
SET_VALUE_BIG((pu4_tu_right_edge), u4_bs_value, u4_tu_pos_y, u4_tu_size);
|
}
|
}
|
/* set all edges for other TU sizes */
|
else
|
{
|
/* setting top TU edge */
|
SET_VALUE_BIG((pu4_tu_top_edge), u4_bs_value, u4_tu_pos_x, u4_tu_size);
|
/* setting bottom TU edge */
|
SET_VALUE_BIG((pu4_tu_bottom_edge), u4_bs_value, u4_tu_pos_x, u4_tu_size);
|
/* setting left TU edge */
|
SET_VALUE_BIG((pu4_tu_left_edge), u4_bs_value, u4_tu_pos_y, u4_tu_size);
|
/* setting right TU edge */
|
SET_VALUE_BIG((pu4_tu_right_edge), u4_bs_value, u4_tu_pos_y, u4_tu_size);
|
}
|
}
|
|
/* point to next TU inside CU in TU order */
|
ps_enc_tu++;
|
}
|
|
if(PRED_MODE_INTRA == u4_pred_mode_flag)
|
{
|
/* no mv based BS computation in INTRA case */
|
return;
|
}
|
/* BS update due to PU mv.s */
|
if(u4_part_mode == SIZE_2Nx2N) /* symmetric motion partition, 2Nx2N */
|
{
|
num_pus_in_cu = 1;
|
}
|
else if(u4_part_mode == SIZE_NxN) /* symmetric motion partition, NxN */
|
{
|
num_pus_in_cu = 4;
|
}
|
else /* other sym. or asym. partiotions */
|
{
|
num_pus_in_cu = 2;
|
}
|
|
/* Go through each PU inside CU in PU order and set the top & bottom */
|
/* PU edge BS accordingly */
|
for(i = 0; i < num_pus_in_cu; i++)
|
{
|
WORD32 k;
|
/* X Position of PU in terms of min PU (4x4) units in current ctb */
|
WORD32 pu_pos_x = ps_pu->b4_pos_x;
|
/* Y Position of PU in terms of min PU (4x4) units in current ctb */
|
WORD32 pu_pos_y = ps_pu->b4_pos_y;
|
/* PU width in 4 pixel unit */
|
WORD32 pu_wd = (ps_pu->b4_wd) + 1;
|
/* PU height in 4 pixel unit */
|
WORD32 pu_ht = (ps_pu->b4_ht) + 1;
|
/* Pred L0 flag */
|
WORD32 cur_pred_l0_flag;
|
/* pointer to current PU */
|
nbr_4x4_t *ps_curr_nbr_4x4_pu;
|
|
/* go through each 4x4 block along the PU edges and do BS calculation */
|
/* can optimize further with proper checks according to PU size */
|
/* but in that case also @CTB boundary, we should go by 4x4 nbr.s only*/
|
|
/* load cur. PU parameters */
|
WORD8 i1_cur_l0_ref_pic_buf_id, i1_cur_l1_ref_pic_buf_id;
|
WORD32 cur_mv_no;
|
WORD16 i2_mv_x0, i2_mv_y0, i2_mv_x1, i2_mv_y1;
|
|
ps_curr_nbr_4x4_pu = ps_curr_nbr_4x4 + (pu_pos_x - (cu_pos_x << 1)) +
|
(pu_pos_y - (cu_pos_y << 1)) * num_4x4_in_ctb;
|
|
cur_pred_l0_flag = ps_curr_nbr_4x4_pu->b1_pred_l0_flag;
|
|
/* L0 & L1 unique ref. pic. id for cur. PU, (stored in upper 4 bits) */
|
i1_cur_l0_ref_pic_buf_id = (ps_curr_nbr_4x4_pu->mv.i1_l0_ref_pic_buf_id);
|
i1_cur_l1_ref_pic_buf_id = (ps_curr_nbr_4x4_pu->mv.i1_l1_ref_pic_buf_id);
|
|
/* Number of motion vectors used for cur. PU */
|
cur_mv_no = cur_pred_l0_flag + ps_curr_nbr_4x4_pu->b1_pred_l1_flag;
|
|
/* x and y mv for L0 and L1, for cur. PU */
|
i2_mv_x0 = ps_curr_nbr_4x4_pu->mv.s_l0_mv.i2_mvx;
|
i2_mv_y0 = ps_curr_nbr_4x4_pu->mv.s_l0_mv.i2_mvy;
|
i2_mv_x1 = ps_curr_nbr_4x4_pu->mv.s_l1_mv.i2_mvx;
|
i2_mv_y1 = ps_curr_nbr_4x4_pu->mv.s_l1_mv.i2_mvy;
|
|
/* two cases for updating TOP and LEFT edges respectively */
|
/* k = 0 : TOP edge update, k = 1 : LEFT edge update */
|
for(k = 0; k < 2; k++)
|
{
|
WORD32 pu_pos_pointer_calc, pu_pos_bit_calc;
|
UWORD32 *pu4_pu_cur_edge;
|
WORD32 pu_dim, nbr_inc;
|
nbr_4x4_t *ps_nbr_4x4;
|
|
/* TOP edge case */
|
if(0 == k)
|
{
|
pu_pos_pointer_calc = pu_pos_y;
|
pu_pos_bit_calc = pu_pos_x;
|
pu4_pu_cur_edge = pu4_horz_bs + (pu_pos_y >> 1);
|
pu_dim = pu_wd;
|
|
/* top neighbours are accessed linearly */
|
nbr_inc = 1;
|
|
/* If the current 4x4 csb is in the first row of CTB */
|
if(0 == pu_pos_pointer_calc)
|
{ /* then need to check if top CTB is physically available */
|
/* (slice bound. are considered as availabale) */
|
if(ps_deblk_prms->u1_not_first_ctb_row_of_frame)
|
{
|
ps_nbr_4x4 = ps_top_nbr_4x4 + (nbr_inc * (pu_pos_x - (cu_pos_x << 1)));
|
}
|
else
|
{
|
/* This is done for avoiding uninitialized memory access at pic. boundaries*/
|
ps_nbr_4x4 = ps_curr_nbr_4x4_pu;
|
}
|
}
|
/* within ctb, so top neighbour is available */
|
else
|
{
|
ps_nbr_4x4 = ps_curr_nbr_4x4_pu - num_4x4_in_ctb;
|
}
|
}
|
/* LEFT edge case */
|
else
|
{
|
pu_pos_pointer_calc = pu_pos_x;
|
pu_pos_bit_calc = pu_pos_y;
|
pu4_pu_cur_edge = pu4_vert_bs + (pu_pos_x >> 1);
|
pu_dim = pu_ht;
|
|
/* left neighbours are accessed using stride */
|
nbr_inc = nbr_4x4_left_strd;
|
|
/* If the current 4x4 csb is in the first col of CTB */
|
if(0 == pu_pos_pointer_calc)
|
{ /* then need to check if left CTB is available */
|
if(ps_deblk_prms->u1_not_first_ctb_col_of_frame)
|
{
|
ps_nbr_4x4 = ps_left_nbr_4x4 + (nbr_inc * (pu_pos_y - (cu_pos_y << 1)));
|
}
|
else
|
{
|
/* This is done for avoiding uninitialized memory access at pic. boundaries*/
|
ps_nbr_4x4 = ps_curr_nbr_4x4_pu;
|
nbr_inc = num_4x4_in_ctb;
|
}
|
}
|
/* within ctb, so left neighbour is available */
|
else
|
{
|
ps_nbr_4x4 = ps_curr_nbr_4x4_pu - 1;
|
nbr_inc = num_4x4_in_ctb;
|
}
|
}
|
|
/* Only if the current edge falls on 8 pixel grid and ... */
|
if(0 == (pu_pos_pointer_calc & 1))
|
{
|
/* go through the edge in 4x4 unit. Can be optimized */
|
/* In that case special case for CTB boundary */
|
for(j = 0; j < pu_dim; j++)
|
{
|
//nbr_4x4_t *ps_temp_nbr_4x4;
|
|
/* ... and if the BS not set yet */
|
if(0 == EXTRACT_VALUE_BIG(pu4_pu_cur_edge, (pu_pos_bit_calc + j)))
|
{
|
WORD8 i1_nbr_l0_ref_pic_buf_id, i1_nbr_l1_ref_pic_buf_id;
|
WORD32 nbr_mv_no;
|
WORD32 bs_flag = 0;
|
WORD32 nbr_pred_l0_flag = ps_nbr_4x4->b1_pred_l0_flag;
|
|
/* L0 & L1 unique ref. pic. id for nbr. csb, in upper 4 bits */
|
i1_nbr_l0_ref_pic_buf_id = (ps_nbr_4x4->mv.i1_l0_ref_pic_buf_id);
|
i1_nbr_l1_ref_pic_buf_id = (ps_nbr_4x4->mv.i1_l1_ref_pic_buf_id);
|
|
/* Number of motion vectors used */
|
nbr_mv_no = nbr_pred_l0_flag + ps_nbr_4x4->b1_pred_l1_flag;
|
|
/* If diff. no. of motion vectors used */
|
if(cur_mv_no != nbr_mv_no)
|
{
|
bs_flag = 1;
|
}
|
/* If One motion vector is used */
|
else if(1 == cur_mv_no)
|
{
|
WORD16 i2_mv_x, i2_mv_y;
|
|
if(cur_pred_l0_flag)
|
{ /* L0 used for cur. */
|
if(nbr_pred_l0_flag)
|
{ /* L0 used for nbr. */
|
if(i1_cur_l0_ref_pic_buf_id != i1_nbr_l0_ref_pic_buf_id)
|
{
|
/* reference pictures used are different */
|
bs_flag = 1;
|
}
|
}
|
else
|
{ /* L1 used for nbr. */
|
if(i1_cur_l0_ref_pic_buf_id != i1_nbr_l1_ref_pic_buf_id)
|
{
|
/* reference pictures used are different */
|
bs_flag = 1;
|
}
|
}
|
if(!bs_flag)
|
{
|
i2_mv_x = i2_mv_x0;
|
i2_mv_y = i2_mv_y0;
|
}
|
}
|
else
|
{ /* L1 used for cur. */
|
if(nbr_pred_l0_flag)
|
{ /* L0 used for nbr. */
|
if(i1_cur_l1_ref_pic_buf_id != i1_nbr_l0_ref_pic_buf_id)
|
{
|
/* reference pictures used are different */
|
bs_flag = 1;
|
}
|
}
|
else
|
{ /* L1 used for nbr. */
|
if(i1_cur_l1_ref_pic_buf_id != i1_nbr_l1_ref_pic_buf_id)
|
{
|
/* reference pictures used are different */
|
bs_flag = 1;
|
}
|
}
|
if(!bs_flag)
|
{
|
i2_mv_x = i2_mv_x1;
|
i2_mv_y = i2_mv_y1;
|
}
|
}
|
|
if(!bs_flag)
|
{
|
WORD16 i2_nbr_mv_x, i2_nbr_mv_y;
|
|
if(nbr_pred_l0_flag)
|
{
|
i2_nbr_mv_x = ps_nbr_4x4->mv.s_l0_mv.i2_mvx;
|
i2_nbr_mv_y = ps_nbr_4x4->mv.s_l0_mv.i2_mvy;
|
}
|
else
|
{
|
i2_nbr_mv_x = ps_nbr_4x4->mv.s_l1_mv.i2_mvx;
|
i2_nbr_mv_y = ps_nbr_4x4->mv.s_l1_mv.i2_mvy;
|
}
|
// clang-format off
|
bs_flag =
|
(abs(i2_mv_x - i2_nbr_mv_x) < 4) &&
|
(abs(i2_mv_y - i2_nbr_mv_y) < 4)
|
? 0
|
: 1;
|
// clang-format on
|
}
|
}
|
/* If two motion vectors are used */
|
else if(2 == cur_mv_no)
|
{
|
/* check whether same reference pictures used */
|
if((i1_cur_l0_ref_pic_buf_id == i1_nbr_l0_ref_pic_buf_id &&
|
i1_cur_l1_ref_pic_buf_id == i1_nbr_l1_ref_pic_buf_id) ||
|
(i1_cur_l0_ref_pic_buf_id == i1_nbr_l1_ref_pic_buf_id &&
|
i1_cur_l1_ref_pic_buf_id == i1_nbr_l0_ref_pic_buf_id))
|
{
|
WORD16 i2_nbr_mv_x0, i2_nbr_mv_y0, i2_nbr_mv_x1, i2_nbr_mv_y1;
|
|
/* x and y mv for L0 and L1, for nbr. csb*/
|
i2_nbr_mv_x0 = ps_nbr_4x4->mv.s_l0_mv.i2_mvx;
|
i2_nbr_mv_y0 = ps_nbr_4x4->mv.s_l0_mv.i2_mvy;
|
i2_nbr_mv_x1 = ps_nbr_4x4->mv.s_l1_mv.i2_mvx;
|
i2_nbr_mv_y1 = ps_nbr_4x4->mv.s_l1_mv.i2_mvy;
|
|
/* Different L0 and L1 */
|
if(i1_cur_l0_ref_pic_buf_id != i1_cur_l1_ref_pic_buf_id)
|
{
|
if(i1_cur_l0_ref_pic_buf_id == i1_nbr_l0_ref_pic_buf_id)
|
{
|
// clang-format off
|
bs_flag =
|
(abs(i2_mv_x0 - i2_nbr_mv_x0) < 4) &&
|
(abs(i2_mv_y0 - i2_nbr_mv_y0) < 4) &&
|
(abs(i2_mv_x1 - i2_nbr_mv_x1) < 4) &&
|
(abs(i2_mv_y1 - i2_nbr_mv_y1) < 4)
|
? 0
|
: 1;
|
// clang-format on
|
}
|
else
|
{
|
// clang-format off
|
bs_flag =
|
(abs(i2_mv_x0 - i2_nbr_mv_x1) < 4) &&
|
(abs(i2_mv_y0 - i2_nbr_mv_y1) < 4) &&
|
(abs(i2_mv_x1 - i2_nbr_mv_x0) < 4) &&
|
(abs(i2_mv_y1 - i2_nbr_mv_y0) < 4)
|
? 0
|
: 1;
|
// clang-format on
|
}
|
}
|
else /* Same L0 and L1 */
|
{
|
// clang-format off
|
bs_flag =
|
((abs(i2_mv_x0 - i2_nbr_mv_x0) >= 4) ||
|
(abs(i2_mv_y0 - i2_nbr_mv_y0) >= 4) ||
|
(abs(i2_mv_x1 - i2_nbr_mv_x1) >= 4) ||
|
(abs(i2_mv_y1 - i2_nbr_mv_y1) >= 4)) &&
|
((abs(i2_mv_x0 - i2_nbr_mv_x1) >= 4) ||
|
(abs(i2_mv_y0 - i2_nbr_mv_y1) >= 4) ||
|
(abs(i2_mv_x1 - i2_nbr_mv_x0) >= 4) ||
|
(abs(i2_mv_y1 - i2_nbr_mv_y0) >= 4))
|
? 1
|
: 0;
|
// clang-format on
|
}
|
}
|
else /* If the reference pictures used are different */
|
{
|
bs_flag = 1;
|
}
|
}
|
|
if(bs_flag)
|
{ /*Storing if BS set due to PU mvs */
|
/*Storing in BigEnd. format. BS[0]|BS[1]| .. |BS[15] & edge_size is 4*/
|
SET_VALUE_BIG((pu4_pu_cur_edge), BS_CBF_4, (pu_pos_bit_calc + j), 4);
|
}
|
}
|
|
/* increment the neighbour */
|
ps_nbr_4x4 += nbr_inc;
|
}
|
}
|
}
|
/* point to the next PU */
|
ps_pu++;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief Clear the invalid Boundary Strength which may be set by
|
* ihevce_bs_compute_cu
|
*
|
* @par Description
|
* Clear the invalid Boundary Strength which may be set by ihevce_bs_compute_cu
|
* (as it does all 4 edges in a shot for some cases)
|
*
|
* @param[out] ps_deblk_prms
|
* Pointer to structure s_deblk_prms, which contains
|
* s_deblk_prms.au4_horz_bs : max of 8 such conti. bs to be comp. for 64x64 ctb
|
* s_deblk_prms.au4_vert_bs : max of 8 such conti. bs to be comp. for 64x64 ctb
|
*
|
* @param[in] last_ctb_row_flag
|
* Flag for checking whether the current CTB is in last ctb_row
|
*
|
* @param[in] last_ctb_in_row_flag
|
* Flag for checking whether the current CTB is the last in current row
|
*
|
* @param[in] last_hz_ctb_wd
|
* Valid Width (pixels) in the last CTB in every row (padding cases)
|
*
|
* @param[in] last_vt_ctb_ht
|
* Valid Height (pixels) in the last CTB row (padding cases)
|
*
|
* @returns none
|
*
|
* @remarks
|
*
|
*******************************************************************************
|
*/
|
void ihevce_bs_clear_invalid(
|
deblk_bs_ctb_ctxt_t *ps_deblk_prms,
|
WORD32 last_ctb_row_flag,
|
WORD32 last_ctb_in_row_flag,
|
WORD32 last_hz_ctb_wd,
|
WORD32 last_vt_ctb_ht)
|
{
|
/* Rightmost CTB. Right padding may be there */
|
/* clear the last vert BS which might have set by ihevce_bs_compute_cu */
|
if(1 == last_ctb_in_row_flag)
|
{
|
ps_deblk_prms->au4_vert_bs[last_hz_ctb_wd >> 3] = 0;
|
}
|
|
/* Bottommost CTB. Bottom padding may be there */
|
/* clear the last horz BS which might have set by ihevce_bs_compute_cu */
|
if(1 == last_ctb_row_flag)
|
{
|
ps_deblk_prms->au4_horz_bs[last_vt_ctb_ht >> 3] = 0;
|
}
|
}
|
