wrapper/libavc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libavc/encoder/ih264e_deblk.c
Ram Mohan M 50fd862b8d libavcenc: Remove duplicate code and improve readability 
This commit does not introduce any new functionality w.r.t previous
commit. But it fixes few things. They are listed below:
1. Guard Bands in header files are fixed
2. Header files contains function definition comments. These are same
as in source file. Maintaining same comment at two locations is
unnecessary. These are removed.
3. Improved consistency and code indentation
4. Removed comments that dont align with implementation
5. Grouped headers of a workspace together
2023-10-01 01:37:17 +05:30

912 lines
31 KiB
C
Raw Permalink Blame History

/******************************************************************************
*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
/**
*******************************************************************************
* @file
* ih264e_deblk.c
*
* @brief
* This file contains functions that are associated with deblocking
*
* @author
* ittiam
*
* @par List of Functions:
* - ih264e_fill_bs_1mv_1ref_non_mbaff
* - ih264e_calculate_csbp
* - ih264e_compute_bs
* - ih264e_filter_top_edge
* - ih264e_filter_left_edge
* - ih264e_deblock_mb
*
* @remarks
* none
*
*******************************************************************************
*/
/*****************************************************************************/
/* File Includes */
/*****************************************************************************/
/* System Include Files */
#include <stdio.h>
#include <string.h>
#include <assert.h>
/* User Include Files */
#include "ih264e_config.h"
#include "ih264_typedefs.h"
#include "iv2.h"
#include "ive2.h"
#include "ih264_macros.h"
#include "ih264_defs.h"
#include "ih264_mem_fns.h"
#include "ih264_padding.h"
#include "ih264_structs.h"
#include "ih264_trans_quant_itrans_iquant.h"
#include "ih264_inter_pred_filters.h"
#include "ih264_intra_pred_filters.h"
#include "ih264_deblk_edge_filters.h"
#include "ih264_trans_data.h"
#include "ih264_cabac_tables.h"
#include "ih264_deblk_tables.h"
#include "ime_defs.h"
#include "ime_distortion_metrics.h"
#include "ime_structs.h"
#include "irc_cntrl_param.h"
#include "irc_frame_info_collector.h"
#include "ih264e_error.h"
#include "ih264e_defs.h"
#include "ih264e_rate_control.h"
#include "ih264e_bitstream.h"
#include "ih264e_cabac_structs.h"
#include "ih264e_structs.h"
#include "ih264e_deblk.h"
/*****************************************************************************/
/* global definitions */
/*****************************************************************************/
/**
******************************************************************************
* @brief BS Table Lookup
* input :
* output :
* @remarks none
******************************************************************************
*/
static const UWORD32 gu4_bs_table[][16] =
{
{
0x00000000, 0x02000000, 0x00020000, 0x02020000,
0x00000200, 0x02000200, 0x00020200, 0x02020200,
0x00000002, 0x02000002, 0x00020002, 0x02020002,
0x00000202, 0x02000202, 0x00020202, 0x02020202
},
{
0x01010101, 0x02010101, 0x01020101, 0x02020101,
0x01010201, 0x02010201, 0x01020201, 0x02020201,
0x01010102, 0x02010102, 0x01020102, 0x02020102,
0x01010202, 0x02010202, 0x01020202, 0x02020202
}
};
/**
******************************************************************************
* @brief Transpose Matrix used in BS
* input :
* output :
* @remarks none
******************************************************************************
*/
static const UWORD16 ih264e_gu2_4x4_v2h_reorder[16] =
{
0x0000, 0x0001, 0x0010, 0x0011,
0x0100, 0x0101, 0x0110, 0x0111,
0x1000, 0x1001, 0x1010, 0x1011,
0x1100, 0x1101, 0x1110, 0x1111
};
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
/**
*******************************************************************************
*
* @brief Fill BS value for all the edges of an mb
*
* @par Description:
* Fill BS value for all the edges of an mb
*
* @param[in] pu4_horz_bs
* Base pointer of horizontal BS table
*
* @param[in] pu4_vert_bs
* Base pointer of vertical BS table
*
* @param[in] u4_left_mb_csbp
* coded sub block pattern of left mb
*
* @param[in] u4_left_mb_csbp
* coded sub block pattern of top mb
*
* @param[in] ps_left_pu
* PU for left MB
*
* @param[in] ps_top_pu
* PU for top MB
*
* @param[in] ps_curr_pu
* PU for current MB
*
* @returns none
*
* @remarks none
*
*******************************************************************************
*/
static void ih264e_fill_bs_1mv_1ref_non_mbaff(UWORD32 *pu4_horz_bs,
UWORD32 *pu4_vert_bs,
UWORD32 u4_left_mb_csbp,
UWORD32 u4_top_mb_csbp,
UWORD32 u4_cur_mb_csbp,
enc_pu_t *ps_left_pu,
enc_pu_t *ps_top_pu,
enc_pu_t *ps_curr_pu)
{
/* motion vectors of blks p & q */
WORD16 i16_qMvl0_x, i16_qMvl0_y, i16_pMvl0_x, i16_pMvl0_y;
WORD16 i16_qMvl1_x, i16_qMvl1_y, i16_pMvl1_x, i16_pMvl1_y;
/* temp var */
UWORD32 u4_left_flag, u4_top_flag;
const UWORD32 *bs_map;
UWORD32 u4_reordered_vert_bs_enc, u4_temp;
/* Coded Pattern for Horizontal Edge */
/*-----------------------------------------------------------------------*/
/*u4_nbr_horz_csbp=11C|10C|9C|8C|7C|6C|5C|4C|3C|2C|1C|0C|15T|14T|13T|12T */
/*-----------------------------------------------------------------------*/
UWORD32 u4_nbr_horz_csbp = (u4_cur_mb_csbp << 4) | (u4_top_mb_csbp >> 12);
UWORD32 u4_horz_bs_enc = u4_cur_mb_csbp | u4_nbr_horz_csbp;
/* Coded Pattern for Vertical Edge */
/*-----------------------------------------------------------------------*/
/*u4_left_mb_masked_csbp = 15L|0|0|0|11L|0|0|0|7L|0|0|0|3L|0|0|0 */
/*-----------------------------------------------------------------------*/
UWORD32 u4_left_mb_masked_csbp = u4_left_mb_csbp & CSBP_RIGHT_BLOCK_MASK;
/*-----------------------------------------------------------------------*/
/*u4_cur_mb_masked_csbp =14C|13C|12C|x|10C|9C|8C|x|6C|5C|4C|x|2C|1C|0C|x */
/*-----------------------------------------------------------------------*/
UWORD32 u4_cur_mb_masked_csbp = (u4_cur_mb_csbp << 1)
& (~CSBP_LEFT_BLOCK_MASK);
/*-----------------------------------------------------------------------*/
/*u4_nbr_vert_csbp=14C|13C|12C|15L|10C|9C|8C|11L|6C|5C|4C|7L|2C|1C|0C|3L */
/*-----------------------------------------------------------------------*/
UWORD32 u4_nbr_vert_csbp = (u4_cur_mb_masked_csbp)
| (u4_left_mb_masked_csbp >> 3);
UWORD32 u4_vert_bs_enc = u4_cur_mb_csbp | u4_nbr_vert_csbp;
/* BS Calculation for MB Boundary Edges */
/* BS calculation for 1 2 3 horizontal boundary */
bs_map = gu4_bs_table[0];
pu4_horz_bs[1] = bs_map[(u4_horz_bs_enc >> 4) & 0xF];
pu4_horz_bs[2] = bs_map[(u4_horz_bs_enc >> 8) & 0xF];
pu4_horz_bs[3] = bs_map[(u4_horz_bs_enc >> 12) & 0xF];
/* BS calculation for 5 6 7 vertical boundary */
/* Do 4x4 tranpose of u4_vert_bs_enc by using look up table for reorder */
u4_reordered_vert_bs_enc = ih264e_gu2_4x4_v2h_reorder[u4_vert_bs_enc & 0xF];
u4_temp = ih264e_gu2_4x4_v2h_reorder[(u4_vert_bs_enc >> 4) & 0xF];
u4_reordered_vert_bs_enc |= (u4_temp << 1);
u4_temp = ih264e_gu2_4x4_v2h_reorder[(u4_vert_bs_enc >> 8) & 0xF];
u4_reordered_vert_bs_enc |= (u4_temp << 2);
u4_temp = ih264e_gu2_4x4_v2h_reorder[(u4_vert_bs_enc >> 12) & 0xF];
u4_reordered_vert_bs_enc |= (u4_temp << 3);
pu4_vert_bs[1] = bs_map[(u4_reordered_vert_bs_enc >> 4) & 0xF];
pu4_vert_bs[2] = bs_map[(u4_reordered_vert_bs_enc >> 8) & 0xF];
pu4_vert_bs[3] = bs_map[(u4_reordered_vert_bs_enc >> 12) & 0xF];
/* BS Calculation for MB Boundary Edges */
if (ps_top_pu->b1_intra_flag)
{
pu4_horz_bs[0] = 0x04040404;
}
else
{
if (ps_curr_pu->b2_pred_mode != ps_top_pu->b2_pred_mode)
{
u4_top_flag = 1;
}
else if(ps_curr_pu->b2_pred_mode != 2)
{
i16_pMvl0_x = ps_top_pu->s_me_info[ps_top_pu->b2_pred_mode].s_mv.i2_mvx;
i16_pMvl0_y = ps_top_pu->s_me_info[ps_top_pu->b2_pred_mode].s_mv.i2_mvy;
i16_qMvl0_x = ps_curr_pu->s_me_info[ps_curr_pu->b2_pred_mode].s_mv.i2_mvx;
i16_qMvl0_y = ps_curr_pu->s_me_info[ps_curr_pu->b2_pred_mode].s_mv.i2_mvy;
u4_top_flag = (ABS((i16_pMvl0_x - i16_qMvl0_x)) >= 4)
| (ABS((i16_pMvl0_y - i16_qMvl0_y)) >= 4);
}
else
{
i16_pMvl0_x = ps_top_pu->s_me_info[PRED_L0].s_mv.i2_mvx;
i16_pMvl0_y = ps_top_pu->s_me_info[PRED_L0].s_mv.i2_mvy;
i16_pMvl1_x = ps_top_pu->s_me_info[PRED_L1].s_mv.i2_mvx;
i16_pMvl1_y = ps_top_pu->s_me_info[PRED_L1].s_mv.i2_mvy;
i16_qMvl0_x = ps_curr_pu->s_me_info[PRED_L0].s_mv.i2_mvx;
i16_qMvl0_y = ps_curr_pu->s_me_info[PRED_L0].s_mv.i2_mvy;
i16_qMvl1_x = ps_curr_pu->s_me_info[PRED_L1].s_mv.i2_mvx;
i16_qMvl1_y = ps_curr_pu->s_me_info[PRED_L1].s_mv.i2_mvy;
u4_top_flag = (ABS((i16_pMvl0_x - i16_qMvl0_x)) >= 4)
| (ABS((i16_pMvl0_y - i16_qMvl0_y)) >= 4)
| (ABS((i16_pMvl1_x - i16_qMvl1_x)) >= 4)
| (ABS((i16_pMvl1_y - i16_qMvl1_y)) >= 4);
}
bs_map = gu4_bs_table[!!u4_top_flag];
pu4_horz_bs[0] = bs_map[u4_horz_bs_enc & 0xF];
}
if (ps_left_pu->b1_intra_flag)
{
pu4_vert_bs[0] = 0x04040404;
}
else
{
if (ps_curr_pu->b2_pred_mode != ps_left_pu->b2_pred_mode)
{
u4_left_flag = 1;
}
else if (ps_curr_pu->b2_pred_mode != 2)/* Not bipred */
{
i16_pMvl0_x = ps_left_pu->s_me_info[ps_left_pu->b2_pred_mode].s_mv.i2_mvx;
i16_pMvl0_y = ps_left_pu->s_me_info[ps_left_pu->b2_pred_mode].s_mv.i2_mvy;
i16_qMvl0_x = ps_curr_pu->s_me_info[ps_curr_pu->b2_pred_mode].s_mv.i2_mvx;
i16_qMvl0_y = ps_curr_pu->s_me_info[ps_curr_pu->b2_pred_mode].s_mv.i2_mvy;
u4_left_flag = (ABS((i16_pMvl0_x - i16_qMvl0_x)) >= 4)
| (ABS((i16_pMvl0_y - i16_qMvl0_y)) >= 4);
}
else
{
i16_pMvl0_x = ps_left_pu->s_me_info[PRED_L0].s_mv.i2_mvx;
i16_pMvl0_y = ps_left_pu->s_me_info[PRED_L0].s_mv.i2_mvy;
i16_pMvl1_x = ps_left_pu->s_me_info[PRED_L1].s_mv.i2_mvx;
i16_pMvl1_y = ps_left_pu->s_me_info[PRED_L1].s_mv.i2_mvy;
i16_qMvl0_x = ps_curr_pu->s_me_info[PRED_L0].s_mv.i2_mvx;
i16_qMvl0_y = ps_curr_pu->s_me_info[PRED_L0].s_mv.i2_mvy;
i16_qMvl1_x = ps_curr_pu->s_me_info[PRED_L1].s_mv.i2_mvx;
i16_qMvl1_y = ps_curr_pu->s_me_info[PRED_L1].s_mv.i2_mvy;
u4_left_flag = (ABS((i16_pMvl0_x - i16_qMvl0_x)) >= 4)
| (ABS((i16_pMvl0_y - i16_qMvl0_y)) >= 4)
| (ABS((i16_pMvl1_x - i16_qMvl1_x)) >= 4)
| (ABS((i16_pMvl1_y - i16_qMvl1_y)) >= 4);
}
bs_map = gu4_bs_table[!!u4_left_flag];
pu4_vert_bs[0] = bs_map[u4_reordered_vert_bs_enc & 0xF];
}
}
/**
*******************************************************************************
*
* @brief calculate coded subblock pattern from nnz
*
* @par Description:
* calculate coded subblock pattern from nnz
*
* @param[in] ps_proc
* process context
*
* @returns csbp
*
* @remarks none
*
*******************************************************************************
*/
static UWORD32 ih264e_calculate_csbp(process_ctxt_t *ps_proc)
{
/* number of non zeros for each tx blk */
UWORD8 *pu1_curr_nnz = (UWORD8 *)ps_proc->au4_nnz;
/* csbp */
UWORD32 u4_csbp = 0;
/* temp var */
WORD32 i4_i;
pu1_curr_nnz += 1;
/* Creating Subblock pattern for current MB */
/* 15C|14C|13C|12C|11C|10C|9C|8C|7C|6C|5C|4C|3C|2C|1C|0C */
for (i4_i = 0; i4_i < 16; i4_i++ )
{
u4_csbp |= ((!!*(pu1_curr_nnz + i4_i))<< i4_i);
}
return u4_csbp;
}
/**
*******************************************************************************
*
* @brief This function computes blocking strength for an mb
*
* @par Description:
* This function computes blocking strength for an mb
*
* @param[in] ps_proc
* process context
*
* @returns none
*
* @remarks
*
*******************************************************************************
*/
void ih264e_compute_bs(process_ctxt_t * ps_proc)
{
/* deblk bs context */
bs_ctxt_t *ps_bs = &(ps_proc->s_deblk_ctxt.s_bs_ctxt);
/* vertical blocking strength */
UWORD32 *pu4_pic_vert_bs;
/* horizontal blocking strength */
UWORD32 *pu4_pic_horz_bs;
/* mb indices */
WORD32 i4_mb_x, i4_mb_y;
/* is intra */
WORD32 i4_intra;
/* temp var */
WORD32 i4_wd_mbs = ps_proc->i4_wd_mbs;
/* init indices */
i4_mb_x = ps_bs->i4_mb_x;
i4_mb_y = ps_bs->i4_mb_y;
/* init pointers */
pu4_pic_vert_bs = ps_bs->pu4_pic_vert_bs + ((i4_mb_y * i4_wd_mbs) + i4_mb_x) * 4;
pu4_pic_horz_bs = ps_bs->pu4_pic_horz_bs + ((i4_mb_y * i4_wd_mbs) + i4_mb_x) * 4;
/* is intra? */
i4_intra = ps_proc->u4_is_intra;
/* compute blocking strength */
if (i4_intra)
{
pu4_pic_vert_bs[0] = 0x04040404;
pu4_pic_vert_bs[1] = pu4_pic_vert_bs[2] = pu4_pic_vert_bs[3] = 0x03030303;
pu4_pic_horz_bs[0] = 0x04040404;
pu4_pic_horz_bs[1] = pu4_pic_horz_bs[2] = pu4_pic_horz_bs[3] = 0x03030303;
}
else
{
/* left mb syntax info */
mb_info_t *ps_left_mb_syntax_ele = &ps_proc->s_left_mb_syntax_ele;
/* top mb syntax info */
mb_info_t *ps_top_mb_syntax_ele = ps_proc->ps_top_row_mb_syntax_ele + i4_mb_x;
/* top row motion vector info */
enc_pu_t *ps_top_row_pu = ps_proc->ps_top_row_pu + i4_mb_x;
/* csbp for curr mb */
ps_proc->u4_csbp = ih264e_calculate_csbp(ps_proc);
/* csbp for ngbrs */
if (i4_mb_x == 0)
{
ps_left_mb_syntax_ele->u4_csbp = 0;
ps_proc->s_left_mb_pu.b1_intra_flag = 0;
ps_proc->s_left_mb_pu.b2_pred_mode = ps_proc->ps_pu->b2_pred_mode;
ps_proc->s_left_mb_pu.s_me_info[0].s_mv = ps_proc->ps_pu->s_me_info[0].s_mv;
ps_proc->s_left_mb_pu.s_me_info[1].s_mv = ps_proc->ps_pu->s_me_info[1].s_mv;
}
if (i4_mb_y == 0)
{
ps_top_mb_syntax_ele->u4_csbp = 0;
ps_top_row_pu->b1_intra_flag = 0;
ps_top_row_pu->b2_pred_mode = ps_proc->ps_pu->b2_pred_mode;
ps_top_row_pu->s_me_info[0].s_mv = ps_proc->ps_pu->s_me_info[0].s_mv;
ps_top_row_pu->s_me_info[1].s_mv = ps_proc->ps_pu->s_me_info[1].s_mv;
}
ih264e_fill_bs_1mv_1ref_non_mbaff(pu4_pic_horz_bs,
pu4_pic_vert_bs,
ps_left_mb_syntax_ele->u4_csbp,
ps_top_mb_syntax_ele->u4_csbp,
ps_proc->u4_csbp,
&ps_proc->s_left_mb_pu,
ps_top_row_pu,
ps_proc->ps_pu);
}
return ;
}
/**
*******************************************************************************
*
* @brief This function performs deblocking of top horizontal edge
*
* @par Description:
* This function performs deblocking of top horizontal edge
*
* @param[in] ps_codec
* pointer to codec context
*
* @param[in] ps_proc
* pointer to proc context
*
* @param[in] pu1_mb_qp
* pointer to mb quantization param
*
* @param[in] pu1_cur_pic_luma
* pointer to recon buffer luma
*
* @param[in] pu1_cur_pic_chroma
* pointer to recon buffer chroma
*
* @param[in] pu4_pic_horz_bs
* pointer to horizontal blocking strength
*
* @returns none
*
* @remarks none
*
*******************************************************************************
*/
static void ih264e_filter_top_edge(codec_t *ps_codec,
process_ctxt_t *ps_proc,
UWORD8 *pu1_mb_qp,
UWORD8 *pu1_cur_pic_luma,
UWORD8 *pu1_cur_pic_chroma,
UWORD32 *pu4_pic_horz_bs)
{
/* strd */
WORD32 i4_rec_strd = ps_proc->i4_rec_strd;
/* deblk params */
UWORD32 u4_alpha_luma, u4_beta_luma, u4_qp_luma, u4_idx_A_luma, u4_idx_B_luma, u4_qp_p, u4_qp_q;
UWORD32 u4_alpha_chroma, u4_beta_chroma, u4_qp_chroma, u4_idx_A_chroma, u4_idx_B_chroma;
/* collect qp of left & top mb */
u4_qp_p = pu1_mb_qp[-ps_proc->i4_wd_mbs];
u4_qp_q = pu1_mb_qp[0];
/********/
/* luma */
/********/
u4_qp_luma = (u4_qp_p + u4_qp_q + 1) >> 1;
/* filter offset A and filter offset B have to be received from slice header */
/* TODO : for now lets set these offsets as zero */
u4_idx_A_luma = MIN(51, u4_qp_luma + 0);
u4_idx_B_luma = MIN(51, u4_qp_luma + 0);
/* alpha, beta computation */
u4_alpha_luma = gu1_ih264_alpha_table[u4_idx_A_luma];
u4_beta_luma = gu1_ih264_beta_table[u4_idx_B_luma];
/**********/
/* chroma */
/**********/
u4_qp_chroma = (gu1_qpc_fqpi[u4_qp_p] + gu1_qpc_fqpi[u4_qp_q] + 1) >> 1;
/* filter offset A and filter offset B have to be received from slice header */
/* TODO : for now lets set these offsets as zero */
u4_idx_A_chroma = MIN(51, u4_qp_chroma + 0);
u4_idx_B_chroma = MIN(51, u4_qp_chroma + 0);
/* alpha, beta computation */
u4_alpha_chroma = gu1_ih264_alpha_table[u4_idx_A_chroma];
u4_beta_chroma = gu1_ih264_beta_table[u4_idx_B_chroma];
/* deblk edge */
/* top Horizontal edge - allowed to be deblocked ? */
if (pu4_pic_horz_bs[0] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_horz_bs4(pu1_cur_pic_luma, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
ps_codec->pf_deblk_chroma_horz_bs4(pu1_cur_pic_chroma, i4_rec_strd, u4_alpha_chroma, u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_horz_bslt4(pu1_cur_pic_luma, i4_rec_strd, u4_alpha_luma,
u4_beta_luma, pu4_pic_horz_bs[0],
gu1_ih264_clip_table[u4_idx_A_luma]);
ps_codec->pf_deblk_chroma_horz_bslt4(pu1_cur_pic_chroma, i4_rec_strd, u4_alpha_chroma,
u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma, pu4_pic_horz_bs[0],
gu1_ih264_clip_table[u4_idx_A_chroma], gu1_ih264_clip_table[u4_idx_A_chroma]);
}
}
/**
*******************************************************************************
*
* @brief This function performs deblocking of left vertical edge
*
* @par Description:
* This function performs deblocking of top horizontal edge
*
* @param[in] ps_codec
* pointer to codec context
*
* @param[in] ps_proc
* pointer to proc context
*
* @param[in] pu1_mb_qp
* pointer to mb quantization param
*
* @param[in] pu1_cur_pic_luma
* pointer to recon buffer luma
*
* @param[in] pu1_cur_pic_chroma
* pointer to recon buffer chroma
*
* @param[in] pu4_pic_vert_bs
* pointer to vertical blocking strength
*
* @returns none
*
* @remarks none
*
*******************************************************************************
*/
static void ih264e_filter_left_edge(codec_t *ps_codec,
process_ctxt_t *ps_proc,
UWORD8 *pu1_mb_qp,
UWORD8 *pu1_cur_pic_luma,
UWORD8 *pu1_cur_pic_chroma,
UWORD32 *pu4_pic_vert_bs)
{
/* strd */
WORD32 i4_rec_strd = ps_proc->i4_rec_strd;
/* deblk params */
UWORD32 u4_alpha_luma, u4_beta_luma, u4_qp_luma, u4_idx_A_luma, u4_idx_B_luma, u4_qp_p, u4_qp_q;
UWORD32 u4_alpha_chroma, u4_beta_chroma, u4_qp_chroma, u4_idx_A_chroma, u4_idx_B_chroma;
/* collect qp of left & curr mb */
u4_qp_p = pu1_mb_qp[-1];
u4_qp_q = pu1_mb_qp[0];
/********/
/* luma */
/********/
u4_qp_luma = (u4_qp_p + u4_qp_q + 1) >> 1;
/* filter offset A and filter offset B have to be received from slice header */
/* TODO : for now lets set these offsets as zero */
u4_idx_A_luma = MIN(51, u4_qp_luma + 0);
u4_idx_B_luma = MIN(51, u4_qp_luma + 0);
/* alpha, beta computation */
u4_alpha_luma = gu1_ih264_alpha_table[u4_idx_A_luma];
u4_beta_luma = gu1_ih264_beta_table[u4_idx_B_luma];
/**********/
/* chroma */
/**********/
u4_qp_chroma = (gu1_qpc_fqpi[u4_qp_p] + gu1_qpc_fqpi[u4_qp_q] + 1) >> 1;
/* filter offset A and filter offset B have to be received from slice header */
/* TODO : for now lets set these offsets as zero */
u4_idx_A_chroma = MIN(51, u4_qp_chroma + 0);
u4_idx_B_chroma = MIN(51, u4_qp_chroma + 0);
/* alpha, beta computation */
u4_alpha_chroma = gu1_ih264_alpha_table[u4_idx_A_chroma];
u4_beta_chroma = gu1_ih264_beta_table[u4_idx_B_chroma];
/* deblk edge */
if (pu4_pic_vert_bs[0] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_vert_bs4(pu1_cur_pic_luma, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
ps_codec->pf_deblk_chroma_vert_bs4(pu1_cur_pic_chroma, i4_rec_strd, u4_alpha_chroma, u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_vert_bslt4(pu1_cur_pic_luma, i4_rec_strd,
u4_alpha_luma, u4_beta_luma,
pu4_pic_vert_bs[0],
gu1_ih264_clip_table[u4_idx_A_luma]);
ps_codec->pf_deblk_chroma_vert_bslt4(pu1_cur_pic_chroma, i4_rec_strd, u4_alpha_chroma,
u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma, pu4_pic_vert_bs[0],
gu1_ih264_clip_table[u4_idx_A_chroma], gu1_ih264_clip_table[u4_idx_A_chroma]);
}
}
/**
*******************************************************************************
*
* @brief This function performs deblocking on an mb
*
* @par Description:
* This function performs deblocking on an mb
*
* @param[in] ps_proc
* process context corresponding to the job
*
* @param[in] ps_deblk
* pointer to deblock context
*
* @returns none
*
* @remarks none
*
*******************************************************************************
*/
void ih264e_deblock_mb(process_ctxt_t *ps_proc, deblk_ctxt_t * ps_deblk)
{
/* codec ctxt */
codec_t *ps_codec = ps_proc->ps_codec;
/* ngbr availability */
UWORD8 u1_mb_a, u1_mb_b;
/* mb indices */
WORD32 i4_mb_x = ps_deblk->i4_mb_x, i4_mb_y = ps_deblk->i4_mb_y;
/* pic qp ptr */
UWORD8 *pu1_pic_qp = ps_deblk->s_bs_ctxt.pu1_pic_qp;
/* vertical blocking strength */
UWORD32 *pu4_pic_vert_bs = ps_deblk->s_bs_ctxt.pu4_pic_vert_bs;
/* horizontal blocking strength */
UWORD32 *pu4_pic_horz_bs = ps_deblk->s_bs_ctxt.pu4_pic_horz_bs;
/* src buffers luma */
UWORD8 *pu1_cur_pic_luma = ps_deblk->pu1_cur_pic_luma;
/* src buffers chroma */
UWORD8 *pu1_cur_pic_chroma = ps_deblk->pu1_cur_pic_chroma;
/* strd */
WORD32 i4_rec_strd = ps_proc->i4_rec_strd;
/* deblk params */
UWORD32 u4_alpha_luma, u4_beta_luma, u4_qp_luma, u4_idx_A_luma, u4_idx_B_luma;
UWORD32 u4_alpha_chroma, u4_beta_chroma, u4_qp_chroma, u4_idx_A_chroma, u4_idx_B_chroma;
/* temp var */
UWORD32 push_ptr = (i4_mb_y * ps_proc->i4_wd_mbs) + i4_mb_x;
/* derive neighbor availability */
/* In slice mode the edges of mbs that lie on the slice boundary are not deblocked */
/* deblocking filter idc '2' */
if (ps_codec->s_cfg.e_slice_mode != IVE_SLICE_MODE_NONE)
{
/* slice index */
UWORD8 *pu1_slice_idx = ps_deblk->pu1_slice_idx;
pu1_slice_idx += (i4_mb_y * ps_proc->i4_wd_mbs);
/* left macroblock availability */
u1_mb_a = (i4_mb_x == 0 ||
(pu1_slice_idx[i4_mb_x - 1 ] != pu1_slice_idx[i4_mb_x]))? 0 : 1;
/* top macroblock availability */
u1_mb_b = (i4_mb_y == 0 ||
(pu1_slice_idx[i4_mb_x-ps_proc->i4_wd_mbs] != pu1_slice_idx[i4_mb_x]))? 0 : 1;
}
else
{
/* left macroblock availability */
u1_mb_a = (i4_mb_x == 0)? 0 : 1;
/* top macroblock availability */
u1_mb_b = (i4_mb_y == 0)? 0 : 1;
}
pu1_pic_qp += push_ptr;
pu4_pic_vert_bs += push_ptr * 4;
pu4_pic_horz_bs += push_ptr * 4;
/********/
/* luma */
/********/
u4_qp_luma = pu1_pic_qp[0];
/* filter offset A and filter offset B have to be received from slice header */
/* TODO : for now lets set these offsets as zero */
u4_idx_A_luma = MIN(51, u4_qp_luma + 0);
u4_idx_B_luma = MIN(51, u4_qp_luma + 0);
/* alpha, beta computation */
u4_alpha_luma = gu1_ih264_alpha_table[u4_idx_A_luma];
u4_beta_luma = gu1_ih264_beta_table[u4_idx_B_luma];
/**********/
/* chroma */
/**********/
u4_qp_chroma = gu1_qpc_fqpi[u4_qp_luma];
/* filter offset A and filter offset B have to be received from slice header */
/* TODO : for now lets set these offsets as zero */
u4_idx_A_chroma = MIN(51, u4_qp_chroma + 0);
u4_idx_B_chroma = MIN(51, u4_qp_chroma + 0);
/* alpha, beta computation */
u4_alpha_chroma = gu1_ih264_alpha_table[u4_idx_A_chroma];
u4_beta_chroma = gu1_ih264_beta_table[u4_idx_B_chroma];
/* Deblock vertical edges */
/* left vertical edge 0 - allowed to be deblocked ? */
if (u1_mb_a)
{
ih264e_filter_left_edge(ps_codec, ps_proc, pu1_pic_qp, pu1_cur_pic_luma, pu1_cur_pic_chroma, pu4_pic_vert_bs);
}
/* vertical edge 1 */
if (pu4_pic_vert_bs[1] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_vert_bs4(pu1_cur_pic_luma + 4, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_vert_bslt4(pu1_cur_pic_luma + 4, i4_rec_strd,
u4_alpha_luma, u4_beta_luma,
pu4_pic_vert_bs[1],
gu1_ih264_clip_table[u4_idx_A_luma]);
}
/* vertical edge 2 */
if (pu4_pic_vert_bs[2] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_vert_bs4(pu1_cur_pic_luma + 8, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
ps_codec->pf_deblk_chroma_vert_bs4(pu1_cur_pic_chroma + 8, i4_rec_strd, u4_alpha_chroma, u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_vert_bslt4(pu1_cur_pic_luma + 8, i4_rec_strd, u4_alpha_luma,
u4_beta_luma, pu4_pic_vert_bs[2],
gu1_ih264_clip_table[u4_idx_A_luma]);
ps_codec->pf_deblk_chroma_vert_bslt4(pu1_cur_pic_chroma + 8, i4_rec_strd, u4_alpha_chroma,
u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma, pu4_pic_vert_bs[2],
gu1_ih264_clip_table[u4_idx_A_chroma], gu1_ih264_clip_table[u4_idx_A_chroma]);
}
/* vertical edge 3 */
if (pu4_pic_vert_bs[3] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_vert_bs4(pu1_cur_pic_luma + 12, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_vert_bslt4(pu1_cur_pic_luma + 12, i4_rec_strd, u4_alpha_luma,
u4_beta_luma, pu4_pic_vert_bs[3],
gu1_ih264_clip_table[u4_idx_A_luma]);
}
/* Deblock Horizontal edges */
/* Horizontal edge 0 */
if (u1_mb_b)
{
ih264e_filter_top_edge(ps_codec, ps_proc, pu1_pic_qp, pu1_cur_pic_luma, pu1_cur_pic_chroma, pu4_pic_horz_bs);
}
/* horizontal edge 1 */
if (pu4_pic_horz_bs[1] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_horz_bs4(pu1_cur_pic_luma + 4 * i4_rec_strd, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_horz_bslt4(pu1_cur_pic_luma + 4 * i4_rec_strd, i4_rec_strd, u4_alpha_luma,
u4_beta_luma, pu4_pic_horz_bs[1],
gu1_ih264_clip_table[u4_idx_A_luma]);
}
/* horizontal edge 2 */
if (pu4_pic_horz_bs[2] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_horz_bs4(pu1_cur_pic_luma + 8 * i4_rec_strd, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
ps_codec->pf_deblk_chroma_horz_bs4(pu1_cur_pic_chroma + 4 * i4_rec_strd, i4_rec_strd, u4_alpha_chroma, u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_horz_bslt4(pu1_cur_pic_luma + 8 * i4_rec_strd, i4_rec_strd, u4_alpha_luma,
u4_beta_luma, pu4_pic_horz_bs[2],
gu1_ih264_clip_table[u4_idx_A_luma]);
ps_codec->pf_deblk_chroma_horz_bslt4(pu1_cur_pic_chroma + 4 * i4_rec_strd, i4_rec_strd, u4_alpha_chroma,
u4_beta_chroma, u4_alpha_chroma, u4_beta_chroma, pu4_pic_horz_bs[2],
gu1_ih264_clip_table[u4_idx_A_chroma], gu1_ih264_clip_table[u4_idx_A_chroma]);
}
/* horizontal edge 3 */
if (pu4_pic_horz_bs[3] == 0x04040404)
{
/* strong filter */
ps_codec->pf_deblk_luma_horz_bs4(pu1_cur_pic_luma + 12 * i4_rec_strd, i4_rec_strd, u4_alpha_luma, u4_beta_luma);
}
else
{
/* normal filter */
ps_codec->pf_deblk_luma_horz_bslt4(pu1_cur_pic_luma + 12 * i4_rec_strd, i4_rec_strd, u4_alpha_luma,
u4_beta_luma, pu4_pic_horz_bs[3],
gu1_ih264_clip_table[u4_idx_A_luma]);
}
return ;
}
Reference in a new issue View git blame Copy permalink