/******************************************************************************
|
*
|
* 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_deblk_edge_filter.c
|
*
|
* @brief
|
* Contains function definitions for deblocking filters
|
*
|
* @author
|
* Ittiam
|
*
|
* @par List of Functions:
|
* - ihevc_hbd_deblk_luma_vert()
|
* - ihevc_hbd_deblk_luma_horz()
|
* - ihevc_hbd_deblk_chroma_vert()
|
* - ihevc_deblk_422chroma_vert()
|
* - ihevc_hbd_deblk_422chroma_vert()
|
* - ihevc_hbd_deblk_chroma_horz()
|
* - ihevc_deblk_422chroma_horz()
|
* - ihevc_hbd_deblk_422chroma_horz()
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <assert.h>
|
#include "ihevc_typedefs.h"
|
#include "ihevc_macros.h"
|
#include "ihevc_platform_macros.h"
|
#include "ihevc_func_selector.h"
|
#include "ihevc_deblk.h"
|
#include "ihevc_deblk_tables.h"
|
#include "ihevc_debug.h"
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Decision process and filtering for the luma block vertical edge for high bit depth.
|
*
|
* @par Description:
|
* The decision process for the luma block vertical edge is carried out and
|
* an appropriate filter is applied. The boundary filter strength, bs should
|
* be greater than 0. The pcm flags and the transquant bypass flags should
|
* be taken care of by the calling function.
|
*
|
* @param[in] pu2_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_hbd_deblk_luma_vert(UWORD16 *pu2_src,
|
WORD32 src_strd,
|
WORD32 bs,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 beta_offset_div2,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q,
|
UWORD8 bit_depth)
|
{
|
WORD32 qp_luma, beta_indx, tc_indx;
|
WORD32 beta, tc;
|
WORD32 dp0, dp3, dq0, dq3, d0, d3, dp, dq, d;
|
WORD32 d_sam0, d_sam3;
|
WORD32 de, dep, deq;
|
WORD32 row;
|
WORD32 tmp_p0, tmp_p1, tmp_p2, tmp_q0, tmp_q1, tmp_q2;
|
WORD32 delta, delta_p, delta_q;
|
|
ASSERT((bs > 0) && (bs <= 3));
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
qp_luma = (quant_param_p + quant_param_q + 1) >> 1;
|
beta_indx = CLIP3(qp_luma + (beta_offset_div2 << 1), 0, 51);
|
|
/* BS based on implementation can take value 3 if it is intra/inter egde */
|
/* based on BS, tc index is calcuated by adding 2 * ( bs - 1) to QP and tc_offset */
|
/* for BS = 1 adding factor is (0*2), BS = 2 or 3 adding factor is (1*2) */
|
/* the above desired functionallity is achieved by doing (2*(bs>>1)) */
|
|
tc_indx = CLIP3(qp_luma + (2 * (bs >> 1)) + (tc_offset_div2 << 1), 0, 53);
|
|
beta = gai4_ihevc_beta_table[beta_indx] * (1 << (bit_depth - 8));
|
tc = gai4_ihevc_tc_table[tc_indx] * (1 << (bit_depth - 8));
|
if(0 == tc)
|
{
|
return;
|
}
|
|
dq0 = ABS(pu2_src[2] - 2 * pu2_src[1] + pu2_src[0]);
|
dq3 = ABS(pu2_src[3 * src_strd + 2] - 2 * pu2_src[3 * src_strd + 1]
|
+ pu2_src[3 * src_strd + 0]);
|
dp0 = ABS(pu2_src[-3] - 2 * pu2_src[-2] + pu2_src[-1]);
|
dp3 = ABS(pu2_src[3 * src_strd - 3] - 2 * pu2_src[3 * src_strd - 2]
|
+ pu2_src[3 * src_strd - 1]);
|
|
d0 = dp0 + dq0;
|
d3 = dp3 + dq3;
|
|
dp = dp0 + dp3;
|
dq = dq0 + dq3;
|
|
d = d0 + d3;
|
|
de = 0;
|
dep = 0;
|
deq = 0;
|
|
if(d < beta)
|
{
|
d_sam0 = 0;
|
if((2 * d0 < (beta >> 2))
|
&& (ABS(pu2_src[3] - pu2_src[0]) + ABS(pu2_src[-1] - pu2_src[-4])
|
< (beta >> 3))
|
&& ABS(pu2_src[0] - pu2_src[-1]) < ((5 * tc + 1) >> 1))
|
{
|
d_sam0 = 1;
|
}
|
|
pu2_src += 3 * src_strd;
|
d_sam3 = 0;
|
if((2 * d3 < (beta >> 2))
|
&& (ABS(pu2_src[3] - pu2_src[0]) + ABS(pu2_src[-1] - pu2_src[-4])
|
< (beta >> 3))
|
&& ABS(pu2_src[0] - pu2_src[-1]) < ((5 * tc + 1) >> 1))
|
{
|
d_sam3 = 1;
|
}
|
pu2_src -= 3 * src_strd;
|
|
de = (d_sam0 == 1 && d_sam3 == 1) ? 2 : 1;
|
dep = (dp < (beta + (beta >> 1)) >> 3) ? 1 : 0;
|
deq = (dq < (beta + (beta >> 1)) >> 3) ? 1 : 0;
|
if(tc <= 1)
|
{
|
dep = 0;
|
deq = 0;
|
}
|
}
|
|
if(de != 0)
|
{
|
for(row = 0; row < 4; row++)
|
{
|
tmp_p0 = pu2_src[-1];
|
tmp_p1 = pu2_src[-2];
|
tmp_p2 = pu2_src[-3];
|
|
tmp_q0 = pu2_src[0];
|
tmp_q1 = pu2_src[1];
|
tmp_q2 = pu2_src[2];
|
|
if(de == 2)
|
{
|
tmp_q0 = CLIP3((pu2_src[2] + 2 * pu2_src[1] +
|
2 * pu2_src[0] + 2 * pu2_src[-1] +
|
pu2_src[-2] + 4) >> 3,
|
pu2_src[0] - 2 * tc,
|
pu2_src[0] + 2 * tc);
|
|
tmp_q1 = CLIP3((pu2_src[2] + pu2_src[1] + pu2_src[0] +
|
pu2_src[-1] + 2) >> 2,
|
pu2_src[1] - 2 * tc,
|
pu2_src[1] + 2 * tc);
|
|
tmp_q2 = CLIP3((2 * pu2_src[3] + 3 * pu2_src[2] +
|
pu2_src[1] + pu2_src[0] +
|
pu2_src[-1] + 4) >> 3,
|
pu2_src[2] - 2 * tc,
|
pu2_src[2] + 2 * tc);
|
|
tmp_p0 = CLIP3((pu2_src[1] + 2 * pu2_src[0] +
|
2 * pu2_src[-1] + 2 * pu2_src[-2] +
|
pu2_src[-3] + 4) >> 3,
|
pu2_src[-1] - 2 * tc,
|
pu2_src[-1] + 2 * tc);
|
|
tmp_p1 = CLIP3((pu2_src[0] + pu2_src[-1] +
|
pu2_src[-2] + pu2_src[-3] + 2) >> 2,
|
pu2_src[-2] - 2 * tc,
|
pu2_src[-2] + 2 * tc);
|
|
tmp_p2 = CLIP3((pu2_src[0] + pu2_src[-1] +
|
pu2_src[-2] + 3 * pu2_src[-3] +
|
2 * pu2_src[-4] + 4) >> 3,
|
pu2_src[-3] - 2 * tc,
|
pu2_src[-3] + 2 * tc);
|
}
|
else
|
{
|
delta = (9 * (pu2_src[0] - pu2_src[-1]) -
|
3 * (pu2_src[1] - pu2_src[-2]) + 8) >> 4;
|
if(ABS(delta) < 10 * tc)
|
{
|
delta = CLIP3(delta, -tc, tc);
|
|
tmp_p0 = CLIP3(pu2_src[-1] + delta, 0, ((1 << bit_depth) - 1));
|
tmp_q0 = CLIP3(pu2_src[0] - delta, 0, ((1 << bit_depth) - 1));
|
if(dep == 1)
|
{
|
delta_p = CLIP3((((pu2_src[-3] + pu2_src[-1] + 1) >> 1)
|
- pu2_src[-2] + delta) >> 1,
|
-(tc >> 1),
|
(tc >> 1));
|
tmp_p1 = CLIP3(pu2_src[-2] + delta_p, 0, ((1 << bit_depth) - 1));
|
}
|
|
if(deq == 1)
|
{
|
delta_q = CLIP3((((pu2_src[2] + pu2_src[0] + 1) >> 1)
|
- pu2_src[1] - delta) >> 1,
|
-(tc >> 1),
|
(tc >> 1));
|
tmp_q1 = CLIP3(pu2_src[1] + delta_q, 0, ((1 << bit_depth) - 1));
|
}
|
}
|
}
|
|
if(filter_flag_p != 0)
|
{
|
pu2_src[-3] = tmp_p2;
|
pu2_src[-2] = tmp_p1;
|
pu2_src[-1] = tmp_p0;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu2_src[0] = tmp_q0;
|
pu2_src[1] = tmp_q1;
|
pu2_src[2] = tmp_q2;
|
}
|
|
pu2_src += src_strd;
|
}
|
}
|
}
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
*
|
* Decision process and filtering for the luma block horizontal edge for high bit depth
|
*
|
* @par Description:
|
* The decision process for the luma block horizontal edge is carried out
|
* and an appropriate filter is applied. The boundary filter strength, bs
|
* should be greater than 0. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu1_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_hbd_deblk_luma_horz(UWORD16 *pu2_src,
|
WORD32 src_strd,
|
WORD32 bs,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 beta_offset_div2,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q,
|
UWORD8 bit_depth)
|
{
|
WORD32 qp_luma, beta_indx, tc_indx;
|
WORD32 beta, tc;
|
WORD32 dp0, dp3, dq0, dq3, d0, d3, dp, dq, d;
|
WORD32 d_sam0, d_sam3;
|
WORD32 de, dep, deq;
|
WORD32 col;
|
WORD32 tmp_p0, tmp_p1, tmp_p2, tmp_q0, tmp_q1, tmp_q2;
|
WORD32 delta, delta_p, delta_q;
|
|
ASSERT((bs > 0));
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
qp_luma = (quant_param_p + quant_param_q + 1) >> 1;
|
beta_indx = CLIP3(qp_luma + (beta_offset_div2 << 1), 0, 51);
|
|
/* BS based on implementation can take value 3 if it is intra/inter egde */
|
/* based on BS, tc index is calcuated by adding 2 * ( bs - 1) to QP and tc_offset */
|
/* for BS = 1 adding factor is (0*2), BS = 2 or 3 adding factor is (1*2) */
|
/* the above desired functionallity is achieved by doing (2*(bs>>1)) */
|
|
tc_indx = CLIP3(qp_luma + 2 * (bs >> 1) + (tc_offset_div2 << 1), 0, 53);
|
|
beta = gai4_ihevc_beta_table[beta_indx] * (1 << (bit_depth - 8));
|
tc = gai4_ihevc_tc_table[tc_indx] * (1 << (bit_depth - 8));
|
if(0 == tc)
|
{
|
return;
|
}
|
|
dq0 = ABS(pu2_src[2 * src_strd] - 2 * pu2_src[1 * src_strd] +
|
pu2_src[0 * src_strd]);
|
|
dq3 = ABS(pu2_src[3 + 2 * src_strd] - 2 * pu2_src[3 + 1 * src_strd] +
|
pu2_src[3 + 0 * src_strd]);
|
|
dp0 = ABS(pu2_src[-3 * src_strd] - 2 * pu2_src[-2 * src_strd] +
|
pu2_src[-1 * src_strd]);
|
|
dp3 = ABS(pu2_src[3 - 3 * src_strd] - 2 * pu2_src[3 - 2 * src_strd] +
|
pu2_src[3 - 1 * src_strd]);
|
|
d0 = dp0 + dq0;
|
d3 = dp3 + dq3;
|
|
dp = dp0 + dp3;
|
dq = dq0 + dq3;
|
|
d = d0 + d3;
|
|
de = 0;
|
dep = 0;
|
deq = 0;
|
|
if(d < beta)
|
{
|
d_sam0 = 0;
|
if((2 * d0 < (beta >> 2))
|
&& (ABS(pu2_src[3 * src_strd] - pu2_src[0 * src_strd]) +
|
ABS(pu2_src[-1 * src_strd] - pu2_src[-4 * src_strd])
|
< (beta >> 3))
|
&& ABS(pu2_src[0 * src_strd] - pu2_src[-1 * src_strd])
|
< ((5 * tc + 1) >> 1))
|
{
|
d_sam0 = 1;
|
}
|
|
pu2_src += 3;
|
d_sam3 = 0;
|
if((2 * d3 < (beta >> 2))
|
&& (ABS(pu2_src[3 * src_strd] - pu2_src[0 * src_strd]) +
|
ABS(pu2_src[-1 * src_strd] - pu2_src[-4 * src_strd])
|
< (beta >> 3))
|
&& ABS(pu2_src[0 * src_strd] - pu2_src[-1 * src_strd])
|
< ((5 * tc + 1) >> 1))
|
{
|
d_sam3 = 1;
|
}
|
pu2_src -= 3;
|
|
de = (d_sam0 == 1 && d_sam3 == 1) ? 2 : 1;
|
dep = (dp < ((beta + (beta >> 1)) >> 3)) ? 1 : 0;
|
deq = (dq < ((beta + (beta >> 1)) >> 3)) ? 1 : 0;
|
if(tc <= 1)
|
{
|
dep = 0;
|
deq = 0;
|
}
|
}
|
|
if(de != 0)
|
{
|
for(col = 0; col < 4; col++)
|
{
|
tmp_p0 = pu2_src[-1 * src_strd];
|
tmp_p1 = pu2_src[-2 * src_strd];
|
tmp_p2 = pu2_src[-3 * src_strd];
|
|
tmp_q0 = pu2_src[0 * src_strd];
|
tmp_q1 = pu2_src[1 * src_strd];
|
tmp_q2 = pu2_src[2 * src_strd];
|
if(de == 2)
|
{
|
tmp_q0 = CLIP3((pu2_src[2 * src_strd] +
|
2 * pu2_src[1 * src_strd] +
|
2 * pu2_src[0 * src_strd] +
|
2 * pu2_src[-1 * src_strd] +
|
pu2_src[-2 * src_strd] + 4) >> 3,
|
pu2_src[0 * src_strd] - 2 * tc,
|
pu2_src[0 * src_strd] + 2 * tc);
|
|
tmp_q1 = CLIP3((pu2_src[2 * src_strd] +
|
pu2_src[1 * src_strd] +
|
pu2_src[0 * src_strd] +
|
pu2_src[-1 * src_strd] + 2) >> 2,
|
pu2_src[1 * src_strd] - 2 * tc,
|
pu2_src[1 * src_strd] + 2 * tc);
|
|
tmp_q2 = CLIP3((2 * pu2_src[3 * src_strd] +
|
3 * pu2_src[2 * src_strd] +
|
pu2_src[1 * src_strd] +
|
pu2_src[0 * src_strd] +
|
pu2_src[-1 * src_strd] + 4) >> 3,
|
pu2_src[2 * src_strd] - 2 * tc,
|
pu2_src[2 * src_strd] + 2 * tc);
|
|
tmp_p0 = CLIP3((pu2_src[1 * src_strd] +
|
2 * pu2_src[0 * src_strd] +
|
2 * pu2_src[-1 * src_strd] +
|
2 * pu2_src[-2 * src_strd] +
|
pu2_src[-3 * src_strd] + 4) >> 3,
|
pu2_src[-1 * src_strd] - 2 * tc,
|
pu2_src[-1 * src_strd] + 2 * tc);
|
|
tmp_p1 = CLIP3((pu2_src[0 * src_strd] +
|
pu2_src[-1 * src_strd] +
|
pu2_src[-2 * src_strd] +
|
pu2_src[-3 * src_strd] + 2) >> 2,
|
pu2_src[-2 * src_strd] - 2 * tc,
|
pu2_src[-2 * src_strd] + 2 * tc);
|
|
tmp_p2 = CLIP3((pu2_src[0 * src_strd] +
|
pu2_src[-1 * src_strd] +
|
pu2_src[-2 * src_strd] +
|
3 * pu2_src[-3 * src_strd] +
|
2 * pu2_src[-4 * src_strd] + 4) >> 3,
|
pu2_src[-3 * src_strd] - 2 * tc,
|
pu2_src[-3 * src_strd] + 2 * tc);
|
}
|
else
|
{
|
delta = (9 * (pu2_src[0 * src_strd] - pu2_src[-1 * src_strd]) -
|
3 * (pu2_src[1 * src_strd] - pu2_src[-2 * src_strd]) +
|
8) >> 4;
|
if(ABS(delta) < 10 * tc)
|
{
|
delta = CLIP3(delta, -tc, tc);
|
tmp_p0 = CLIP3(pu2_src[-1 * src_strd] + delta, 0, ((1 << bit_depth) - 1));
|
tmp_q0 = CLIP3(pu2_src[0 * src_strd] - delta, 0, ((1 << bit_depth) - 1));
|
if(dep == 1)
|
{
|
delta_p = CLIP3((((pu2_src[-3 * src_strd] +
|
pu2_src[-1 * src_strd] + 1) >> 1) -
|
pu2_src[-2 * src_strd] + delta) >> 1,
|
-(tc >> 1),
|
(tc >> 1));
|
tmp_p1 = CLIP3(pu2_src[-2 * src_strd] + delta_p, 0, ((1 << bit_depth) - 1));
|
}
|
|
if(deq == 1)
|
{
|
delta_q = CLIP3((((pu2_src[2 * src_strd] +
|
pu2_src[0 * src_strd] + 1) >> 1) -
|
pu2_src[1 * src_strd] - delta) >> 1,
|
-(tc >> 1),
|
(tc >> 1));
|
tmp_q1 = CLIP3(pu2_src[1 * src_strd] + delta_q, 0, ((1 << bit_depth) - 1));
|
}
|
}
|
}
|
|
if(filter_flag_p != 0)
|
{
|
pu2_src[-3 * src_strd] = tmp_p2;
|
pu2_src[-2 * src_strd] = tmp_p1;
|
pu2_src[-1 * src_strd] = tmp_p0;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu2_src[0 * src_strd] = tmp_q0;
|
pu2_src[1 * src_strd] = tmp_q1;
|
pu2_src[2 * src_strd] = tmp_q2;
|
}
|
|
pu2_src += 1;
|
}
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Filtering for the chroma block vertical edge.
|
*
|
* @par Description:
|
* Filter for chroma vertical edge. The boundary filter strength, bs
|
* should be greater than 1. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu2_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_hbd_deblk_chroma_vert(UWORD16 *pu2_src,
|
WORD32 src_strd,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 qp_offset_u,
|
WORD32 qp_offset_v,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q,
|
UWORD8 bit_depth)
|
{
|
WORD32 qp_indx_u, qp_chroma_u;
|
WORD32 qp_indx_v, qp_chroma_v;
|
WORD32 tc_indx_u, tc_u;
|
WORD32 tc_indx_v, tc_v;
|
WORD32 delta_u, tmp_p0_u, tmp_q0_u;
|
WORD32 delta_v, tmp_p0_v, tmp_q0_v;
|
WORD32 row;
|
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
/* chroma processing is done only if BS is 2 */
|
/* this function is assumed to be called only if BS is 2 */
|
qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_u = qp_indx_u < 0 ? qp_indx_u : (qp_indx_u > 57 ? qp_indx_u - 6 : gai4_ihevc_qp_table[qp_indx_u]);
|
|
qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_v = qp_indx_v < 0 ? qp_indx_v : (qp_indx_v > 57 ? qp_indx_v - 6 : gai4_ihevc_qp_table[qp_indx_v]);
|
|
tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_u = gai4_ihevc_tc_table[tc_indx_u] * (1 << (bit_depth - 8));
|
|
tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_v = gai4_ihevc_tc_table[tc_indx_v] * (1 << (bit_depth - 8));
|
|
if(0 == tc_u && 0 == tc_v)
|
{
|
return;
|
}
|
|
for(row = 0; row < 4; row++)
|
{
|
delta_u = CLIP3((((pu2_src[0] - pu2_src[-2]) << 2) +
|
pu2_src[-4] - pu2_src[2] + 4) >> 3,
|
-tc_u, tc_u);
|
tmp_p0_u = CLIP3(pu2_src[-2] + delta_u, 0, ((1 << bit_depth) - 1));
|
tmp_q0_u = CLIP3(pu2_src[0] - delta_u, 0, ((1 << bit_depth) - 1));
|
|
delta_v = CLIP3((((pu2_src[1] - pu2_src[-1]) << 2) +
|
pu2_src[-3] - pu2_src[3] + 4) >> 3,
|
-tc_v, tc_v);
|
tmp_p0_v = CLIP3(pu2_src[-1] + delta_v, 0, ((1 << bit_depth) - 1));
|
tmp_q0_v = CLIP3(pu2_src[1] - delta_v, 0, ((1 << bit_depth) - 1));
|
if(filter_flag_p != 0)
|
{
|
pu2_src[-2] = tmp_p0_u;
|
pu2_src[-1] = tmp_p0_v;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu2_src[0] = tmp_q0_u;
|
pu2_src[1] = tmp_q0_v;
|
}
|
|
pu2_src += src_strd;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Filtering for the chroma block vertical edge.
|
*
|
* @par Description:
|
* Filter for chroma vertical edge. The boundary filter strength, bs
|
* should be greater than 1. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu1_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_deblk_422chroma_vert(UWORD8 *pu1_src,
|
WORD32 src_strd,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 qp_offset_u,
|
WORD32 qp_offset_v,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q)
|
{
|
WORD32 qp_indx_u, qp_chroma_u;
|
WORD32 qp_indx_v, qp_chroma_v;
|
WORD32 tc_indx_u, tc_u;
|
WORD32 tc_indx_v, tc_v;
|
WORD32 delta_u, tmp_p0_u, tmp_q0_u;
|
WORD32 delta_v, tmp_p0_v, tmp_q0_v;
|
WORD32 row;
|
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
/* chroma processing is done only if BS is 2 */
|
/* this function is assumed to be called only if BS is 2 */
|
qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_u = MIN(qp_indx_u, 51);
|
|
qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_v = MIN(qp_indx_v, 51);
|
|
tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_u = gai4_ihevc_tc_table[tc_indx_u];
|
|
tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_v = gai4_ihevc_tc_table[tc_indx_v];
|
|
if(0 == tc_u && 0 == tc_v)
|
{
|
return;
|
}
|
|
for(row = 0; row < 4; row++)
|
{
|
delta_u = CLIP3((((pu1_src[0] - pu1_src[-2]) << 2) +
|
pu1_src[-4] - pu1_src[2] + 4) >> 3,
|
-tc_u, tc_u);
|
|
tmp_p0_u = CLIP_U8(pu1_src[-2] + delta_u);
|
tmp_q0_u = CLIP_U8(pu1_src[0] - delta_u);
|
|
delta_v = CLIP3((((pu1_src[1] - pu1_src[-1]) << 2) +
|
pu1_src[-3] - pu1_src[3] + 4) >> 3,
|
-tc_v, tc_v);
|
|
tmp_p0_v = CLIP_U8(pu1_src[-1] + delta_v);
|
tmp_q0_v = CLIP_U8(pu1_src[1] - delta_v);
|
|
if(filter_flag_p != 0)
|
{
|
pu1_src[-2] = tmp_p0_u;
|
pu1_src[-1] = tmp_p0_v;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu1_src[0] = tmp_q0_u;
|
pu1_src[1] = tmp_q0_v;
|
}
|
|
pu1_src += src_strd;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Filtering for the chroma block vertical edge.
|
*
|
* @par Description:
|
* Filter for chroma vertical edge. The boundary filter strength, bs
|
* should be greater than 1. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu2_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_hbd_deblk_422chroma_vert(UWORD16 *pu2_src,
|
WORD32 src_strd,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 qp_offset_u,
|
WORD32 qp_offset_v,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q,
|
UWORD8 bit_depth)
|
{
|
WORD32 qp_indx_u, qp_chroma_u;
|
WORD32 qp_indx_v, qp_chroma_v;
|
WORD32 tc_indx_u, tc_u;
|
WORD32 tc_indx_v, tc_v;
|
WORD32 delta_u, tmp_p0_u, tmp_q0_u;
|
WORD32 delta_v, tmp_p0_v, tmp_q0_v;
|
WORD32 row;
|
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
/* chroma processing is done only if BS is 2 */
|
/* this function is assumed to be called only if BS is 2 */
|
qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_u = MIN(qp_indx_u, 51);
|
|
qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_v = MIN(qp_indx_v, 51);
|
|
tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_u = gai4_ihevc_tc_table[tc_indx_u] * (1 << (bit_depth - 8));
|
|
tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_v = gai4_ihevc_tc_table[tc_indx_v] * (1 << (bit_depth - 8));
|
|
if(0 == tc_u && 0 == tc_v)
|
{
|
return;
|
}
|
|
for(row = 0; row < 4; row++)
|
{
|
delta_u = CLIP3((((pu2_src[0] - pu2_src[-2]) << 2) +
|
pu2_src[-4] - pu2_src[2] + 4) >> 3,
|
-tc_u, tc_u);
|
tmp_p0_u = CLIP3(pu2_src[-2] + delta_u, 0, ((1 << bit_depth) - 1));
|
tmp_q0_u = CLIP3(pu2_src[0] - delta_u, 0, ((1 << bit_depth) - 1));
|
|
delta_v = CLIP3((((pu2_src[1] - pu2_src[-1]) << 2) +
|
pu2_src[-3] - pu2_src[3] + 4) >> 3,
|
-tc_v, tc_v);
|
tmp_p0_v = CLIP3(pu2_src[-1] + delta_v, 0, ((1 << bit_depth) - 1));
|
tmp_q0_v = CLIP3(pu2_src[1] - delta_v, 0, ((1 << bit_depth) - 1));
|
if(filter_flag_p != 0)
|
{
|
pu2_src[-2] = tmp_p0_u;
|
pu2_src[-1] = tmp_p0_v;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu2_src[0] = tmp_q0_u;
|
pu2_src[1] = tmp_q0_v;
|
}
|
|
pu2_src += src_strd;
|
}
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Filtering for the chroma block horizontal edge.
|
*
|
* @par Description:
|
* Filter for chroma horizontal edge. The boundary filter strength, bs
|
* should be greater than 1. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu1_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_deblk_422chroma_horz
|
(
|
UWORD8 *pu1_src,
|
WORD32 src_strd,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 qp_offset_u,
|
WORD32 qp_offset_v,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q
|
)
|
{
|
WORD32 qp_indx_u, qp_chroma_u;
|
WORD32 qp_indx_v, qp_chroma_v;
|
WORD32 tc_indx_u, tc_u;
|
WORD32 tc_indx_v, tc_v;
|
WORD32 tc;
|
|
WORD32 delta, tmp_p0, tmp_q0;
|
WORD32 col;
|
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
/* chroma processing is done only if BS is 2 */
|
/* this function is assumed to be called only if BS is 2 */
|
qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_u = MIN(qp_indx_u, 51);
|
|
qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_v = MIN(qp_indx_v, 51);
|
|
tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_u = gai4_ihevc_tc_table[tc_indx_u];
|
|
tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_v = gai4_ihevc_tc_table[tc_indx_v];
|
|
if(0 == tc_u && 0 == tc_v)
|
{
|
return;
|
}
|
|
for(col = 0; col < 8; col++)
|
{
|
tc = (col & 1) ? tc_v : tc_u;
|
delta = CLIP3((((pu1_src[0 * src_strd] -
|
pu1_src[-1 * src_strd]) << 2) +
|
pu1_src[-2 * src_strd] -
|
pu1_src[1 * src_strd] + 4) >> 3,
|
-tc, tc);
|
|
tmp_p0 = CLIP_U8(pu1_src[-1 * src_strd] + delta);
|
tmp_q0 = CLIP_U8(pu1_src[0 * src_strd] - delta);
|
|
if(filter_flag_p != 0)
|
{
|
pu1_src[-1 * src_strd] = tmp_p0;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu1_src[0 * src_strd] = tmp_q0;
|
}
|
|
pu1_src += 1;
|
}
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Filtering for the chroma block horizontal edge.
|
*
|
* @par Description:
|
* Filter for chroma horizontal edge. The boundary filter strength, bs
|
* should be greater than 1. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu2_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_hbd_deblk_chroma_horz(UWORD16 *pu2_src,
|
WORD32 src_strd,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 qp_offset_u,
|
WORD32 qp_offset_v,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q,
|
UWORD8 bit_depth)
|
{
|
WORD32 qp_indx_u, qp_chroma_u;
|
WORD32 qp_indx_v, qp_chroma_v;
|
WORD32 tc_indx_u, tc_u;
|
WORD32 tc_indx_v, tc_v;
|
WORD32 tc;
|
|
WORD32 delta, tmp_p0, tmp_q0;
|
WORD32 col;
|
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
/* chroma processing is done only if BS is 2 */
|
/* this function is assumed to be called only if BS is 2 */
|
qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_u = qp_indx_u < 0 ? qp_indx_u : (qp_indx_u > 57 ? qp_indx_u - 6 : gai4_ihevc_qp_table[qp_indx_u]);
|
|
qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_v = qp_indx_v < 0 ? qp_indx_v : (qp_indx_v > 57 ? qp_indx_v - 6 : gai4_ihevc_qp_table[qp_indx_v]);
|
|
tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_u = gai4_ihevc_tc_table[tc_indx_u] * (1 << (bit_depth - 8));
|
|
tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_v = gai4_ihevc_tc_table[tc_indx_v] * (1 << (bit_depth - 8));
|
|
if(0 == tc_u && 0 == tc_v)
|
{
|
return;
|
}
|
|
for(col = 0; col < 8; col++)
|
{
|
tc = (col & 1) ? tc_v : tc_u;
|
delta = CLIP3((((pu2_src[0 * src_strd] -
|
pu2_src[-1 * src_strd]) << 2) +
|
pu2_src[-2 * src_strd] -
|
pu2_src[1 * src_strd] + 4) >> 3,
|
-tc, tc);
|
tmp_p0 = CLIP3(pu2_src[-1 * src_strd] + delta, 0, ((1 << bit_depth) - 1));
|
tmp_q0 = CLIP3(pu2_src[0 * src_strd] - delta, 0, ((1 << bit_depth) - 1));
|
|
if(filter_flag_p != 0)
|
{
|
pu2_src[-1 * src_strd] = tmp_p0;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu2_src[0 * src_strd] = tmp_q0;
|
}
|
|
pu2_src += 1;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Filtering for the chroma block horizontal edge.
|
*
|
* @par Description:
|
* Filter for chroma horizontal edge. The boundary filter strength, bs
|
* should be greater than 1. The pcm flags and the transquant bypass flags
|
* should be taken care of by the calling function.
|
*
|
* @param[in] pu2_src
|
* Pointer to the src sample q(0,0)
|
*
|
* @param[in] src_strd
|
* Source stride
|
*
|
* @param[in] bs
|
* Boundary filter strength of q(0,0)
|
*
|
* @param[in] quant_param_p
|
* quantization parameter of p block
|
*
|
* @param[in] quant_param_q
|
* quantization parameter of p block
|
*
|
* @param[in] beta_offset_div2
|
*
|
*
|
* @param[in] tc_offset_div2
|
*
|
*
|
* @param[in] filter_flag_p
|
* flag whether to filter the p block
|
*
|
* @param[in] filter_flag_q
|
* flag whether to filter the q block
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ihevc_hbd_deblk_422chroma_horz(UWORD16 *pu2_src,
|
WORD32 src_strd,
|
WORD32 quant_param_p,
|
WORD32 quant_param_q,
|
WORD32 qp_offset_u,
|
WORD32 qp_offset_v,
|
WORD32 tc_offset_div2,
|
WORD32 filter_flag_p,
|
WORD32 filter_flag_q,
|
UWORD8 bit_depth)
|
{
|
WORD32 qp_indx_u, qp_chroma_u;
|
WORD32 qp_indx_v, qp_chroma_v;
|
WORD32 tc_indx_u, tc_u;
|
WORD32 tc_indx_v, tc_v;
|
WORD32 tc;
|
|
WORD32 delta, tmp_p0, tmp_q0;
|
WORD32 col;
|
|
ASSERT(filter_flag_p || filter_flag_q);
|
|
/* chroma processing is done only if BS is 2 */
|
/* this function is assumed to be called only if BS is 2 */
|
qp_indx_u = qp_offset_u + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_u = MIN(qp_indx_u, 51);
|
|
qp_indx_v = qp_offset_v + ((quant_param_p + quant_param_q + 1) >> 1);
|
qp_chroma_v = MIN(qp_indx_v, 51);
|
|
tc_indx_u = CLIP3(qp_chroma_u + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_u = gai4_ihevc_tc_table[tc_indx_u] * (1 << (bit_depth - 8));
|
|
tc_indx_v = CLIP3(qp_chroma_v + 2 + (tc_offset_div2 << 1), 0, 53);
|
tc_v = gai4_ihevc_tc_table[tc_indx_v] * (1 << (bit_depth - 8));
|
|
if(0 == tc_u && 0 == tc_v)
|
{
|
return;
|
}
|
|
for(col = 0; col < 8; col++)
|
{
|
tc = (col & 1) ? tc_v : tc_u;
|
delta = CLIP3((((pu2_src[0 * src_strd] -
|
pu2_src[-1 * src_strd]) << 2) +
|
pu2_src[-2 * src_strd] -
|
pu2_src[1 * src_strd] + 4) >> 3,
|
-tc, tc);
|
tmp_p0 = CLIP3(pu2_src[-1 * src_strd] + delta, 0, ((1 << bit_depth) - 1));
|
tmp_q0 = CLIP3(pu2_src[0 * src_strd] - delta, 0, ((1 << bit_depth) - 1));
|
|
if(filter_flag_p != 0)
|
{
|
pu2_src[-1 * src_strd] = tmp_p0;
|
}
|
|
if(filter_flag_q != 0)
|
{
|
pu2_src[0 * src_strd] = tmp_q0;
|
}
|
|
pu2_src += 1;
|
}
|
}
|
