/****************************************************************************** * * 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 * ih264_deblk_edge_filters.c * * @brief * Contains function definitions for deblocking * * @author * ittiam * * @par List of Functions: * - ih264_deblk_luma_vert_bs4 * - ih264_deblk_luma_horz_bs4 * - ih264_deblk_chroma_vert_bs4_bp * - ih264_deblk_chroma_horz_bs4_bp * - ih264_deblk_luma_vert_bslt4 * - ih264_deblk_chroma_vert_bslt4_bp * - ih264_deblk_luma_horz_bslt4 * - ih264_deblk_luma_horz_bslt4 * - ih264_deblk_luma_vert_bs4_mbaff * - ih264_deblk_chroma_vert_bs4_mbaff_bp * - ih264_deblk_luma_vert_bslt4_mbaff * - ih264_deblk_chroma_vert_bslt4_mbaff_bp * - ih264_deblk_chroma_vert_bs4 * - ih264_deblk_chroma_horz_bs4 * - ih264_deblk_chroma_vert_bslt4 * - ih264_deblk_chroma_horz_bslt4 * - ih264_deblk_chroma_vert_bs4_mbaff * - ih264_deblk_chroma_vert_bslt4_mbaff * * @remarks * none * ******************************************************************************* */ /*****************************************************************************/ /* File Includes */ /*****************************************************************************/ /* System Include Files */ #include /* User Include Files */ #include "ih264_typedefs.h" #include "ih264_macros.h" #include "ih264_deblk_edge_filters.h" #include "ih264_platform_macros.h" /*****************************************************************************/ /* Function Definitions */ /*****************************************************************************/ /** ******************************************************************************* * * @brief luma vertical edge deblock @ bs4 * * @par Description * This function performs filtering of a luma block vertical edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_luma_vert_bs4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta) { UWORD8 p3, p2, p1, p0, q0, q1, q2, q3; WORD32 pos_p3, pos_p2, pos_p1, pos_p0; WORD32 pos_q0, pos_q1, pos_q2,pos_q3; UWORD8 a_p, a_q; /* threshold variables */ WORD32 blk_strd = src_strd << 2; /* block_increment = src_strd * 4 */ UWORD8 *pu1_src_temp; WORD8 i = 0, edge; pos_q0 = 0; pos_q1 = 1; pos_q2 = 2; pos_q3 = 3; pos_p0 = -1; pos_p1 = -2; pos_p2 = -3; pos_p3 = -4; for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) { pu1_src_temp = pu1_src; for(i = 0; i < 4; ++i, pu1_src_temp += src_strd) { q0 = pu1_src_temp[pos_q0]; q1 = pu1_src_temp[pos_q1]; p0 = pu1_src_temp[pos_p0]; p1 = pu1_src_temp[pos_p1]; /* Filter Decision */ if((ABS(p0 - q0) >= alpha) || (ABS(q1 - q0) >= beta) || (ABS(p1 - p0) >= beta)) continue; p2 = pu1_src_temp[pos_p2]; p3 = pu1_src_temp[pos_p3]; q2 = pu1_src_temp[pos_q2]; q3 = pu1_src_temp[pos_q3]; if(ABS(p0 - q0) < ((alpha >> 2) + 2)) { /* Threshold Variables */ a_p = (UWORD8)ABS(p2 - p0); a_q = (UWORD8)ABS(q2 - q0); if(a_p < beta) { /* p0', p1', p2' */ pu1_src_temp[pos_p0] = ((p2 + X2(p1) + X2(p0) + X2(q0) + q1 + 4) >> 3); pu1_src_temp[pos_p1] = ((p2 + p1 + p0 + q0 + 2) >> 2); pu1_src_temp[pos_p2] = ((X2(p3) + X3(p2) + p1 + p0 + q0 + 4) >> 3); } else { /* p0'*/ pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); } if(a_q < beta) { /* q0', q1', q2' */ pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2 + 4) >> 3; pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2; pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4) >> 3; } else { /* q0'*/ pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; } } else { /* p0', q0'*/ pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; } } } } /** ******************************************************************************* * * @brief luma horizontal edge deblock @ bs4 * * @par Description * This function performs filtering of a luma block horizontal edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_luma_horz_bs4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta) { UWORD8 p3, p2, p1, p0, q0, q1, q2, q3; WORD32 pos_p3, pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2, pos_q3; UWORD8 a_p, a_q; /* threshold variables */ UWORD8 *pu1_p3; /* pointer to the src sample p3 */ UWORD8 *pu1_p3_temp; UWORD8 *pu1_src_temp; WORD8 i = 0, edge; pu1_p3 = pu1_src - (src_strd << 2); pos_q0 = 0; pos_q1 = src_strd; pos_q2 = X2(src_strd); pos_q3 = X3(src_strd); pos_p0 = X3(src_strd); pos_p1 = X2(src_strd); pos_p2 = src_strd; pos_p3 = 0; for(edge = 0; edge < 4; edge++, pu1_src += 4, pu1_p3 += 4) { pu1_src_temp = pu1_src; pu1_p3_temp = pu1_p3; for(i = 0; i < 4; ++i, pu1_src_temp++, pu1_p3_temp++) { q0 = pu1_src_temp[pos_q0]; q1 = pu1_src_temp[pos_q1]; p0 = pu1_p3_temp[pos_p0]; p1 = pu1_p3_temp[pos_p1]; /* Filter Decision */ if((ABS(p0 - q0) >= alpha) || (ABS(q1 - q0) >= beta) || (ABS(p1 - p0) >= beta)) continue; p2 = pu1_p3_temp[pos_p2]; p3 = pu1_p3_temp[pos_p3]; q2 = pu1_src_temp[pos_q2]; q3 = pu1_src_temp[pos_q3]; if(ABS(p0 - q0) < ((alpha >> 2) + 2)) { /* Threshold Variables */ a_p = ABS(p2 - p0); a_q = ABS(q2 - q0); if((a_p < beta)) { /* p0', p1', p2' */ pu1_p3_temp[pos_p0] = (p2 + X2(p1) + X2(p0) + X2(q0) + q1 + 4) >> 3; pu1_p3_temp[pos_p1] = (p2 + p1 + p0 + q0 + 2) >> 2; pu1_p3_temp[pos_p2] = (X2(p3) + X3(p2) + p1 + p0 + q0 + 4) >> 3; } else { /* p0'*/ pu1_p3_temp[pos_p0] = (X2(p1) + p0 + q1 + 2) >> 2; } if(a_q < beta) { /* q0', q1', q2' */ pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2 + 4) >> 3; pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2; pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4) >> 3; } else { /* q0'*/ pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; } } else { /* p0', q0'*/ pu1_p3_temp[pos_p0] = (X2(p1) + p0 + q1 + 2) >> 2; pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; } } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bs4_bp(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta) { UWORD8 *pu1_src_u = pu1_src; /* pointer to the src sample q0 of U */ UWORD8 *pu1_src_v = pu1_src + 1; /* pointer to the src sample q0 of V */ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 i = 0, edge; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += src_strd) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha) && (ABS(q1_u - q0_u) < beta) && (ABS(p1_u - p0_u) < beta)) { /* p0' */ pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); /* q0' */ pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha) && (ABS(q1_v - q0_v) < beta) && (ABS(p1_v - p0_v) < beta)) { /* p0' */ pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); /* q0' */ pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; } } } } /** ******************************************************************************* * * @brief chroma horizontal edge deblock @ bs4 * * @par Description * This function performs filtering of a chroma block horizontal edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_horz_bs4_bp(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta) { UWORD8 *pu1_src_u = pu1_src; /* pointer to the src sample q0 of U */ UWORD8 *pu1_src_v = pu1_src + 1; /* pointer to the src sample q0 of V */ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; UWORD8 *pu1_p1_u; /* pointer to the src sample p1 of U */ UWORD8 *pu1_p1_v; /* pointer to the src sample p1 of U */ UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; WORD8 i = 0, edge; pu1_p1_u = pu1_src_u - (src_strd << 1); pu1_p1_v = pu1_src_v - (src_strd << 1); pos_q0 = 0; pos_q1 = src_strd; pos_p0 = src_strd; pos_p1 = 0; for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, pu1_src_v += 4, pu1_p1_v += 4) { pu1_src_temp_u = pu1_src_u; pu1_p1_temp_u = pu1_p1_u; pu1_src_temp_v = pu1_src_v; pu1_p1_temp_v = pu1_p1_v; for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, pu1_src_temp_v += 2, pu1_p1_temp_v += 2) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_p1_temp_u[pos_p0]; p1_u = pu1_p1_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_p1_temp_v[pos_p0]; p1_v = pu1_p1_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha) && (ABS(q1_u - q0_u) < beta) && (ABS(p1_u - p0_u) < beta)) { /* p0' */ pu1_p1_temp_u[pos_p0] = (X2(p1_u) + p0_u + q1_u + 2) >> 2; /* q0' */ pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha) && (ABS(q1_v - q0_v) < beta) && (ABS(p1_v - p0_v) < beta)) { /* p0' */ pu1_p1_temp_v[pos_p0] = (X2(p1_v) + p0_v + q1_v + 2) >> 2; /* q0' */ pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; } } } } /** ******************************************************************************* * * @brief luma vertical edge deblock @ bs < 4 * * @par Description * This function performs filtering of a luma block vertical edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab * tc0_table * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_luma_vert_bslt4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta, UWORD32 u4_bs, const UWORD8 *pu1_cliptab) { WORD8 i = 0, edge; UWORD8 p2, p1, p0, q0, q1, q2; WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2; UWORD8 a_p, a_q; /* threshold variables */ WORD32 blk_strd = src_strd << 2; /* block_increment = src_strd * 4 */ UWORD8 *pu1_src_temp; WORD8 delta; WORD8 tc; WORD16 val; UWORD8 tc0, u1_bs; pos_q0 = 0; pos_q1 = 1; pos_q2 = 2; pos_p0 = -1; pos_p1 = -2; pos_p2 = -3; for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) { pu1_src_temp = pu1_src; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tc0 = pu1_cliptab[u1_bs]; for(i = 0; i < 4; ++i, pu1_src_temp += src_strd) { q0 = pu1_src_temp[pos_q0]; q1 = pu1_src_temp[pos_q1]; p0 = pu1_src_temp[pos_p0]; p1 = pu1_src_temp[pos_p1]; /* Filter Decision */ if((ABS(p0 - q0) >= alpha) || (ABS(q1 - q0) >= beta) || (ABS(p1 - p0) >= beta)) continue; q2 = pu1_src_temp[pos_q2]; p2 = pu1_src_temp[pos_p2]; a_p = ABS(p2 - p0); a_q = ABS(q2 - q0); /* tc */ tc = tc0 + (a_p < beta) + (a_q < beta); val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0 + delta; pu1_src_temp[pos_p0] = CLIP_U8(val); /* q0' */ val = q0 - delta; pu1_src_temp[pos_q0] = CLIP_U8(val); /* Luma only */ if(a_p < beta) { /* p1' */ val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1); pu1_src_temp[pos_p1] += CLIP3(-tc0, tc0, val); } if(a_q < beta) { /* q1' */ val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1); pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val); } } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs < 4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab * tc0_table * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bslt4_bp(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta, UWORD32 u4_bs, const UWORD8 *pu1_cliptab) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * (4 >> 1)*/ WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 i = 0, edge; WORD8 delta; WORD8 tc; WORD16 val; UWORD8 tc0, u1_bs; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tc0 = pu1_cliptab[u1_bs]; tc = tc0 + 1; for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += src_strd) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha) && (ABS(q1_u - q0_u) < beta) && (ABS(p1_u - p0_u) < beta)) { val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0_u + delta; pu1_src_temp_u[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_u - delta; pu1_src_temp_u[pos_q0] = CLIP_U8(val); } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha) && (ABS(q1_v - q0_v) < beta) && (ABS(p1_v - p0_v) < beta)) { val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0_v + delta; pu1_src_temp_v[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_v - delta; pu1_src_temp_v[pos_q0] = CLIP_U8(val); } } } } /** ******************************************************************************* * * @brief luma horizontal edge deblock @ bs < 4 * * @par Description * This function performs filtering of a luma block horizontal edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab * tc0_table * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_luma_horz_bslt4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta, UWORD32 u4_bs, const UWORD8 *pu1_cliptab) { UWORD8 p2, p1, p0, q0, q1, q2; WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2; UWORD8 a_p, a_q; /* Threshold variables */ UWORD8 *pu1_p2; /* Pointer to the src sample p2 */ UWORD8 *pu1_p2_temp; UWORD8 *pu1_src_temp; WORD8 i = 0, edge; WORD8 delta; WORD8 tc; WORD16 val; UWORD8 tc0, u1_bs; pu1_p2 = pu1_src - (src_strd << 2); pos_q0 = 0; pos_q1 = src_strd; pos_q2 = X2(src_strd); pos_p0 = X3(src_strd); pos_p1 = X2(src_strd); pos_p2 = src_strd; for(edge = 0; edge < 4; edge++, pu1_src += 4, pu1_p2 += 4) { pu1_src_temp = pu1_src; pu1_p2_temp = pu1_p2; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tc0 = pu1_cliptab[u1_bs]; for(i = 0; i < 4; ++i, pu1_src_temp++, pu1_p2_temp++) { q0 = pu1_src_temp[pos_q0]; q1 = pu1_src_temp[pos_q1]; p0 = pu1_p2_temp[pos_p0]; p1 = pu1_p2_temp[pos_p1]; /* Filter Decision */ if((ABS(p0 - q0) >= alpha) || (ABS(q1 - q0) >= beta) || (ABS(p1 - p0) >= beta)) continue; q2 = pu1_src_temp[pos_q2]; p2 = pu1_p2_temp[pos_p2]; a_p = ABS(p2 - p0); a_q = ABS(q2 - q0); /* tc */ tc = tc0 + (a_p < beta) + (a_q < beta); val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0 + delta; pu1_p2_temp[pos_p0] = CLIP_U8(val); /* q0' */ val = q0 - delta; pu1_src_temp[pos_q0] = CLIP_U8(val); /* Luma */ if(a_p < beta) { /* p1' */ val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1); pu1_p2_temp[pos_p1] += CLIP3(-tc0, tc0, val); } if(a_q < beta) { /* q1' */ val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1); pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val); } } } } /** ******************************************************************************* * * @brief chroma horizontal edge deblock @ bs < 4 * * @par Description * This function performs filtering of a chroma block horizontal edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab * tc0_table * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_horz_bslt4_bp(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta, UWORD32 u4_bs, const UWORD8 *pu1_cliptab) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of plane U*/ UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of plane V*/ UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; WORD8 i = 0, edge; WORD8 delta; WORD8 tc; WORD16 val; UWORD8 u1_bs; UWORD8 tc0; pu1_p1_u = pu1_src_u - (src_strd << 1); pu1_p1_v = pu1_src_v - (src_strd << 1); pos_q0 = 0; pos_q1 = src_strd; pos_p0 = src_strd; pos_p1 = 0; for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, pu1_src_v += 4, pu1_p1_v += 4) { pu1_src_temp_u = pu1_src_u; pu1_p1_temp_u = pu1_p1_u; pu1_src_temp_v = pu1_src_v; pu1_p1_temp_v = pu1_p1_v; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tc0 = pu1_cliptab[u1_bs]; for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, pu1_src_temp_v += 2, pu1_p1_temp_v += 2) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_p1_temp_u[pos_p0]; p1_u = pu1_p1_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_p1_temp_v[pos_p0]; p1_v = pu1_p1_temp_v[pos_p1]; /* tc */ tc = tc0 + 1; /* Filter Decision */ if(ABS(p0_u - q0_u) < alpha && ABS(q1_u - q0_u) < beta && ABS(p1_u - p0_u) < beta) { val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0_u + delta; pu1_p1_temp_u[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_u - delta; pu1_src_temp_u[pos_q0] = CLIP_U8(val); } /* Filter Decision */ if(ABS(p0_v - q0_v) < alpha && ABS(q1_v - q0_v) < beta && ABS(p1_v - p0_v) < beta) { val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0_v + delta; pu1_p1_temp_v[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_v - delta; pu1_src_temp_v[pos_q0] = CLIP_U8(val); } } } } /*****************************************************************************/ /* Function Definitions for vertical edge deblocking for double-call */ /*****************************************************************************/ /** ******************************************************************************* * * @brief luma vertical edge deblock @ bs4 * * @par Description * This function performs filtering of a luma block vertical edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_luma_vert_bs4_mbaff(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta) { UWORD8 p3, p2, p1, p0, q0, q1, q2, q3; WORD32 pos_p3, pos_p2, pos_p1, pos_p0; WORD32 pos_q0, pos_q1, pos_q2, pos_q3; UWORD8 a_p, a_q; /* threshold variables */ WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ UWORD8 *pu1_src_temp; WORD8 i = 0, edge; pos_q0 = 0; pos_q1 = 1; pos_q2 = 2; pos_q3 = 3; pos_p0 = -1; pos_p1 = -2; pos_p2 = -3; pos_p3 = -4; for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) { pu1_src_temp = pu1_src; for(i = 0; i < 2; ++i, pu1_src_temp += src_strd) { q0 = pu1_src_temp[pos_q0]; q1 = pu1_src_temp[pos_q1]; p0 = pu1_src_temp[pos_p0]; p1 = pu1_src_temp[pos_p1]; /* Filter Decision */ if((ABS(p0 - q0) >= alpha) || (ABS(q1 - q0) >= beta) || (ABS(p1 - p0) >= beta)) continue; p2 = pu1_src_temp[pos_p2]; p3 = pu1_src_temp[pos_p3]; q2 = pu1_src_temp[pos_q2]; q3 = pu1_src_temp[pos_q3]; if(ABS(p0 - q0) < ((alpha >> 2) + 2)) { /* Threshold Variables */ a_p = (UWORD8)ABS(p2 - p0); a_q = (UWORD8)ABS(q2 - q0); if(a_p < beta) { /* p0', p1', p2' */ pu1_src_temp[pos_p0] = ((p2 + X2(p1) + X2(p0) + X2(q0) + q1 + 4) >> 3); pu1_src_temp[pos_p1] = ((p2 + p1 + p0 + q0 + 2) >> 2); pu1_src_temp[pos_p2] = ((X2(p3) + X3(p2) + p1 + p0 + q0 + 4) >> 3); } else { /* p0'*/ pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); } if(a_q < beta) { /* q0', q1', q2' */ pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2 + 4) >> 3; pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2; pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4) >> 3; } else { /* q0'*/ pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; } } else { /* p0', q0'*/ pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; } } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bs4_mbaff_bp(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 edge; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha) && (ABS(q1_u - q0_u) < beta) && (ABS(p1_u - p0_u) < beta)) { /* p0' */ pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); /* q0' */ pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; } /* Filter Decision */ if(ABS(p0_v - q0_v) < alpha && ABS(q1_v - q0_v) < beta && ABS(p1_v - p0_v) < beta) { /* p0' */ pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); /* q0' */ pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; } } } /** ******************************************************************************* * * @brief luma vertical edge deblock @ bs < 4 * * @par Description * This function performs filtering of a luma block vertical edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab * tc0_table * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_luma_vert_bslt4_mbaff(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta, UWORD32 u4_bs, const UWORD8 *pu1_cliptab) { WORD8 i = 0, edge; UWORD8 p2, p1, p0, q0, q1, q2; WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2; UWORD8 a_p, a_q; /* Threshold variables */ WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ UWORD8 *pu1_src_temp; WORD8 delta; WORD8 tc; WORD16 val; UWORD8 tc0, u1_bs; pos_q0 = 0; pos_q1 = 1; pos_q2 = 2; pos_p0 = -1; pos_p1 = -2; pos_p2 = -3; for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) { pu1_src_temp = pu1_src; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tc0 = pu1_cliptab[u1_bs]; for(i = 0; i < 2; ++i, pu1_src_temp += src_strd) { q0 = pu1_src_temp[pos_q0]; q1 = pu1_src_temp[pos_q1]; p0 = pu1_src_temp[pos_p0]; p1 = pu1_src_temp[pos_p1]; /* Filter Decision */ if((ABS(p0 - q0) >= alpha) || (ABS(q1 - q0) >= beta) || (ABS(p1 - p0) >= beta)) continue; q2 = pu1_src_temp[pos_q2]; p2 = pu1_src_temp[pos_p2]; a_p = ABS(p2 - p0); a_q = ABS(q2 - q0); /* tc */ tc = tc0 + (a_p < beta) + (a_q < beta); val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0 + delta; pu1_src_temp[pos_p0] = CLIP_U8(val); /* q0' */ val = q0 - delta; pu1_src_temp[pos_q0] = CLIP_U8(val); /* Luma only */ if(a_p < beta) { /* p1' */ val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1); pu1_src_temp[pos_p1] += CLIP3(-tc0, tc0, val); } if(a_q < beta) { /* q1' */ val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1); pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val); } } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs < 4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha * alpha value for the boundary * * @param[in] beta * beta value for the boundary * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab * tc0_table * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bslt4_mbaff_bp(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha, WORD32 beta, UWORD32 u4_bs, const UWORD8 *pu1_cliptab) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 edge; WORD8 delta; WORD8 tc; WORD16 val; UWORD8 tc0, u1_bs; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tc0 = pu1_cliptab[u1_bs]; tc = tc0 + 1; q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha) && (ABS(q1_u - q0_u) < beta) && (ABS(p1_u - p0_u) < beta)) { val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0_u + delta; pu1_src_temp_u[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_u - delta; pu1_src_temp_u[pos_q0] = CLIP_U8(val); } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha) && (ABS(q1_v - q0_v) < beta) && (ABS(p1_v - p0_v) < beta)) { val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); delta = CLIP3(-tc, tc, val); /* p0' */ val = p0_v + delta; pu1_src_temp_v[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_v - delta; pu1_src_temp_v[pos_q0] = CLIP_U8(val); } } } /*****************************************************************************/ /* Function Definitions for chroma deblocking in high profile */ /*****************************************************************************/ /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha_cb * alpha value for the boundary of U * * @param[in] beta_cb * beta value for the boundary of U * * @param[in] alpha_cr * alpha value for the boundary of V * * @param[in] beta_cr * beta value for the boundary of V * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bs4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha_cb, WORD32 beta_cb, WORD32 alpha_cr, WORD32 beta_cr) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2*/ WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 i = 0, edge; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += src_strd) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha_cb) && (ABS(q1_u - q0_u) < beta_cb) && (ABS(p1_u - p0_u) < beta_cb)) { /* p0' */ pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); /* q0' */ pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha_cr) && (ABS(q1_v - q0_v) < beta_cr) && (ABS(p1_v - p0_v) < beta_cr)) { /* p0' */ pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); /* q0' */ pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; } } } } /** ******************************************************************************* * * @brief chroma horizontal edge deblock @ bs4 * * @par Description * This function performs filtering of a chroma block horizontal edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha_cb * alpha value for the boundary of U * * @param[in] beta_cb * beta value for the boundary of U * * @param[in] alpha_cr * alpha value for the boundary of V * * @param[in] beta_cr * beta value for the boundary of V * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_horz_bs4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha_cb, WORD32 beta_cb, WORD32 alpha_cr, WORD32 beta_cr) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of U */ UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of U */ UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; WORD8 i = 0, edge; pu1_p1_u = pu1_src_u - (src_strd << 1); pu1_p1_v = pu1_src_v - (src_strd << 1); pos_q0 = 0; pos_q1 = src_strd; pos_p0 = src_strd; pos_p1 = 0; for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, pu1_src_v += 4, pu1_p1_v += 4) { pu1_src_temp_u = pu1_src_u; pu1_p1_temp_u = pu1_p1_u; pu1_src_temp_v = pu1_src_v; pu1_p1_temp_v = pu1_p1_v; for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, pu1_src_temp_v += 2, pu1_p1_temp_v += 2) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_p1_temp_u[pos_p0]; p1_u = pu1_p1_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_p1_temp_v[pos_p0]; p1_v = pu1_p1_temp_v[pos_p1]; /* Filter Decision */ if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb && ABS(p1_u - p0_u) < beta_cb) { /* p0' */ pu1_p1_temp_u[pos_p0] = (X2(p1_u) + p0_u + q1_u + 2) >> 2; /* q0' */ pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; } /* Filter Decision */ if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr && ABS(p1_v - p0_v) < beta_cr) { /* p0' */ pu1_p1_temp_v[pos_p0] = (X2(p1_v) + p0_v + q1_v + 2) >> 2; /* q0' */ pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; } } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs < 4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha_cb * alpha value for the boundary of U * * @param[in] beta_cb * beta value for the boundary of U * * @param[in] alpha_cr * alpha value for the boundary of V * * @param[in] beta_cr * beta value for the boundary of V * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab_cb * tc0_table of U * * @param[in] pu1_cliptab_cr * tc0_table of V * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bslt4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha_cb, WORD32 beta_cb, WORD32 alpha_cr, WORD32 beta_cr, UWORD32 u4_bs, const UWORD8 *pu1_cliptab_cb, const UWORD8 *pu1_cliptab_cr) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 i = 0, edge; WORD8 delta; WORD8 tcb, tcr; WORD16 val; UWORD8 tcb0, tcr0, u1_bs; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tcb0 = pu1_cliptab_cb[u1_bs]; tcr0 = pu1_cliptab_cr[u1_bs]; tcb = tcb0 + 1; tcr = tcr0 + 1; for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += src_strd) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb && ABS(p1_u - p0_u) < beta_cb) { val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); delta = CLIP3(-tcb, tcb, val); /* p0' */ val = p0_u + delta; pu1_src_temp_u[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_u - delta; pu1_src_temp_u[pos_q0] = CLIP_U8(val); } /* Filter Decision */ if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr && ABS(p1_v - p0_v) < beta_cr) { val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); delta = CLIP3(-tcr, tcr, val); /* p0' */ val = p0_v + delta; pu1_src_temp_v[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_v - delta; pu1_src_temp_v[pos_q0] = CLIP_U8(val); } } } } /** ******************************************************************************* * * @brief chroma horizontal edge deblock @ bs < 4 * * @par Description * This function performs filtering of a chroma block horizontal edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha_cb * alpha value for the boundary of U * * @param[in] beta_cb * beta value for the boundary of U * * @param[in] alpha_cr * alpha value for the boundary of V * * @param[in] beta_cr * beta value for the boundary of V * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab_cb * tc0_table of U * * @param[in] pu1_cliptab_cr * tc0_table of V * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_horz_bslt4(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha_cb, WORD32 beta_cb, WORD32 alpha_cr, WORD32 beta_cr, UWORD32 u4_bs, const UWORD8 *pu1_cliptab_cb, const UWORD8 *pu1_cliptab_cr) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of plane U*/ UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of plane V*/ UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; WORD8 i = 0, edge; WORD8 delta; WORD8 tcb, tcr; WORD16 val; UWORD8 u1_bs; UWORD8 tcb0, tcr0; pu1_p1_u = pu1_src_u - (src_strd << 1); pu1_p1_v = pu1_src_v - (src_strd << 1); pos_q0 = 0; pos_q1 = src_strd; pos_p0 = src_strd; pos_p1 = 0; for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, pu1_src_v += 4, pu1_p1_v += 4) { pu1_src_temp_u = pu1_src_u; pu1_p1_temp_u = pu1_p1_u; pu1_src_temp_v = pu1_src_v; pu1_p1_temp_v = pu1_p1_v; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tcb0 = pu1_cliptab_cb[u1_bs]; tcr0 = pu1_cliptab_cr[u1_bs]; for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, pu1_src_temp_v += 2, pu1_p1_temp_v += 2) { q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_p1_temp_u[pos_p0]; p1_u = pu1_p1_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_p1_temp_v[pos_p0]; p1_v = pu1_p1_temp_v[pos_p1]; /* tc */ tcb = tcb0 + 1; tcr = tcr0 + 1; /* Filter Decision */ if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb && ABS(p1_u - p0_u) < beta_cb) { val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); delta = CLIP3(-tcb, tcb, val); /* p0' */ val = p0_u + delta; pu1_p1_temp_u[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_u - delta; pu1_src_temp_u[pos_q0] = CLIP_U8(val); } /* Filter Decision */ if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr && ABS(p1_v - p0_v) < beta_cr) { val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); delta = CLIP3(-tcr, tcr, val); /* p0' */ val = p0_v + delta; pu1_p1_temp_v[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_v - delta; pu1_src_temp_v[pos_q0] = CLIP_U8(val); } } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is set to 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha_cb * alpha value for the boundary of U * * @param[in] beta_cb * beta value for the boundary of U * * @param[in] alpha_cr * alpha value for the boundary of V * * @param[in] beta_cr * beta value for the boundary of V * * @returns none * * @remarks This operation is described in Sec. 8.7.2.4 under the title * "Filtering process for edges for bS equal to 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bs4_mbaff(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha_cb, WORD32 beta_cb, WORD32 alpha_cr, WORD32 beta_cr) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 edge; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha_cb) && (ABS(q1_u - q0_u) < beta_cb) && (ABS(p1_u - p0_u) < beta_cb)) { /* p0' */ pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); /* q0' */ pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha_cr) && (ABS(q1_v - q0_v) < beta_cr) && (ABS(p1_v - p0_v) < beta_cr)) { /* p0' */ pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); /* q0' */ pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; } } } /** ******************************************************************************* * * @brief chroma vertical edge deblock @ bs < 4 * * @par Description * This function performs filtering of a chroma block vertical edge when the * boundary strength is less than 4 * * @param[in] pu1_src * pointer to the src sample q0 of U * * @param[in] src_strd * source stride * * @param[in] alpha_cb * alpha value for the boundary of U * * @param[in] beta_cb * beta value for the boundary of U * * @param[in] alpha_cr * alpha value for the boundary of V * * @param[in] beta_cr * beta value for the boundary of V * * @param[in] u4_bs * packed Boundary strength array * * @param[in] pu1_cliptab_cb * tc0_table of U * * @param[in] pu1_cliptab_cr * tc0_table of V * * @returns none * * @remarks This operation is described in Sec. 8.7.2.3 under the title * "Filtering process for edges for bS less than 4" in ITU T Rec H.264 * ****************************************************************************** */ void ih264_deblk_chroma_vert_bslt4_mbaff(UWORD8 *pu1_src, WORD32 src_strd, WORD32 alpha_cb, WORD32 beta_cb, WORD32 alpha_cr, WORD32 beta_cr, UWORD32 u4_bs, const UWORD8 *pu1_cliptab_cb, const UWORD8 *pu1_cliptab_cr) { UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; WORD32 blk_strd = src_strd; WORD32 pos_p1, pos_p0, pos_q0, pos_q1; UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; WORD8 edge; WORD8 delta; WORD8 tcb, tcr; WORD16 val; UWORD8 tcb0, tcr0, u1_bs; pos_q0 = 0; pos_q1 = 2; pos_p0 = -2; pos_p1 = -4; for(edge = 0; edge < 4; edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) { pu1_src_temp_u = pu1_src_u; pu1_src_temp_v = pu1_src_v; /* Filter Decision */ u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); if(!u1_bs) continue; /* tc0 */ tcb0 = pu1_cliptab_cb[u1_bs]; tcr0 = pu1_cliptab_cr[u1_bs]; tcb = tcb0 + 1; tcr = tcr0 + 1; q0_u = pu1_src_temp_u[pos_q0]; q1_u = pu1_src_temp_u[pos_q1]; p0_u = pu1_src_temp_u[pos_p0]; p1_u = pu1_src_temp_u[pos_p1]; q0_v = pu1_src_temp_v[pos_q0]; q1_v = pu1_src_temp_v[pos_q1]; p0_v = pu1_src_temp_v[pos_p0]; p1_v = pu1_src_temp_v[pos_p1]; /* Filter Decision */ if((ABS(p0_u - q0_u) < alpha_cb) && (ABS(q1_u - q0_u) < beta_cb) && (ABS(p1_u - p0_u) < beta_cb)) { val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); delta = CLIP3(-tcb, tcb, val); /* p0' */ val = p0_u + delta; pu1_src_temp_u[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_u - delta; pu1_src_temp_u[pos_q0] = CLIP_U8(val); } /* Filter Decision */ if((ABS(p0_v - q0_v) < alpha_cr) && (ABS(q1_v - q0_v) < beta_cr) && (ABS(p1_v - p0_v) < beta_cr)) { val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); delta = CLIP3(-tcr, tcr, val); /* p0' */ val = p0_v + delta; pu1_src_temp_v[pos_p0] = CLIP_U8(val); /* q0' */ val = q0_v - delta; pu1_src_temp_v[pos_q0] = CLIP_U8(val); } } }