/****************************************************************************** * * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore * * 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. * ******************************************************************************/ /** ******************************************************************************* * @file * ihevc_deblk.c * * @brief * Contains definition for the ctb level deblk function * * @author * Srinivas T * * @par List of Functions: * - ihevc_deblk() * * @remarks * None * ******************************************************************************* */ #include #include #include #include #include #include "ihevc_typedefs.h" #include "iv.h" #include "ivd.h" #include "ihevcd_cxa.h" #include "ithread.h" #include "ihevc_defs.h" #include "ihevc_debug.h" #include "ihevc_defs.h" #include "ihevc_structs.h" #include "ihevc_macros.h" #include "ihevc_platform_macros.h" #include "ihevc_cabac_tables.h" #include "ihevc_error.h" #include "ihevc_common_tables.h" #include "ihevcd_trace.h" #include "ihevcd_defs.h" #include "ihevcd_function_selector.h" #include "ihevcd_structs.h" #include "ihevcd_error.h" #include "ihevcd_nal.h" #include "ihevcd_bitstream.h" #include "ihevcd_job_queue.h" #include "ihevcd_utils.h" #include "ihevcd_debug.h" #include "ihevc_deblk.h" #include "ihevc_deblk_tables.h" #include "ihevcd_profile.h" /** ******************************************************************************* * * @brief * Deblock CTB level function. * * @par Description: * For a given CTB, deblocking on both vertical and * horizontal edges is done. Both the luma and chroma * blocks are processed * * @param[in] ps_deblk * Pointer to the deblock context * * @returns * * @remarks * None * ******************************************************************************* */ void ihevcd_deblk_ctb(deblk_ctxt_t *ps_deblk, WORD32 i4_is_last_ctb_x, WORD32 i4_is_last_ctb_y) { WORD32 ctb_size; WORD32 log2_ctb_size; UWORD32 u4_bs; WORD32 bs_tz; /*Leading zeros in boundary strength*/ WORD32 qp_p, qp_q; WORD32 filter_p, filter_q; UWORD8 *pu1_src; WORD32 qp_strd; UWORD32 *pu4_vert_bs, *pu4_horz_bs; UWORD32 *pu4_ctb_vert_bs, *pu4_ctb_horz_bs; WORD32 bs_strd; WORD32 src_strd; UWORD8 *pu1_qp; UWORD16 *pu2_ctb_no_loop_filter_flag; UWORD16 au2_ctb_no_loop_filter_flag[9]; WORD32 col, row; /* Flag to indicate if QP is constant in CTB * 0 - top_left, 1 - top, 2 - left, 3 - current */ UWORD32 u4_qp_const_in_ctb[4] = { 0, 0, 0, 0 }; WORD32 ctb_indx; WORD32 chroma_yuv420sp_vu = ps_deblk->is_chroma_yuv420sp_vu; sps_t *ps_sps; pps_t *ps_pps; codec_t *ps_codec; slice_header_t *ps_slice_hdr; PROFILE_DISABLE_DEBLK(); ps_sps = ps_deblk->ps_sps; ps_pps = ps_deblk->ps_pps; ps_codec = ps_deblk->ps_codec; ps_slice_hdr = ps_deblk->ps_slice_hdr; log2_ctb_size = ps_sps->i1_log2_ctb_size; ctb_size = (1 << ps_sps->i1_log2_ctb_size); /* strides are in units of number of bytes */ /* ctb_size * ctb_size / 8 / 16 is the number of bytes needed per CTB */ bs_strd = (ps_sps->i2_pic_wd_in_ctb + 1) << (2 * log2_ctb_size - 7); pu4_vert_bs = (UWORD32 *)((UWORD8 *)ps_deblk->s_bs_ctxt.pu4_pic_vert_bs + (ps_deblk->i4_ctb_x << (2 * log2_ctb_size - 7)) + ps_deblk->i4_ctb_y * bs_strd); pu4_ctb_vert_bs = pu4_vert_bs; pu4_horz_bs = (UWORD32 *)((UWORD8 *)ps_deblk->s_bs_ctxt.pu4_pic_horz_bs + (ps_deblk->i4_ctb_x << (2 * log2_ctb_size - 7)) + ps_deblk->i4_ctb_y * bs_strd); pu4_ctb_horz_bs = pu4_horz_bs; qp_strd = ps_sps->i2_pic_wd_in_ctb << (log2_ctb_size - 3); pu1_qp = ps_deblk->s_bs_ctxt.pu1_pic_qp + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * qp_strd) << (log2_ctb_size - 3)); pu2_ctb_no_loop_filter_flag = ps_deblk->au2_ctb_no_loop_filter_flag; ctb_indx = ps_deblk->i4_ctb_x + ps_sps->i2_pic_wd_in_ctb * ps_deblk->i4_ctb_y; if(i4_is_last_ctb_y) { pu4_vert_bs = (UWORD32 *)((UWORD8 *)pu4_vert_bs + bs_strd); pu4_ctb_vert_bs = pu4_vert_bs; /* ctb_size/8 is the number of edges per CTB * ctb_size/4 is the number of BS values needed per edge * divided by 8 for the number of bytes * 2 is the number of bits needed for each BS value */ memset(pu4_vert_bs, 0, 1 << (2 * log2_ctb_size - 7)); pu1_qp += (qp_strd << (log2_ctb_size - 3)); pu2_ctb_no_loop_filter_flag += (ctb_size >> 3); ctb_indx += ps_sps->i2_pic_wd_in_ctb; } if(i4_is_last_ctb_x) { pu4_horz_bs = (UWORD32 *)((UWORD8 *)pu4_horz_bs + (1 << (2 * log2_ctb_size - 7))); pu4_ctb_horz_bs = pu4_horz_bs; memset(pu4_horz_bs, 0, 1 << (2 * log2_ctb_size - 7)); pu1_qp += (ctb_size >> 3); for(row = 0; row < (ctb_size >> 3) + 1; row++) au2_ctb_no_loop_filter_flag[row] = ps_deblk->au2_ctb_no_loop_filter_flag[row] >> (ctb_size >> 3); pu2_ctb_no_loop_filter_flag = au2_ctb_no_loop_filter_flag; ctb_indx += 1; } u4_qp_const_in_ctb[3] = ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx) >> 3] & (1 << (ctb_indx & 7)); if(ps_deblk->i4_ctb_x || i4_is_last_ctb_x) { u4_qp_const_in_ctb[2] = ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx - 1) >> 3] & (1 << ((ctb_indx - 1) & 7)); } if((ps_deblk->i4_ctb_x || i4_is_last_ctb_x) && (ps_deblk->i4_ctb_y || i4_is_last_ctb_y)) { u4_qp_const_in_ctb[0] = ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx - ps_sps->i2_pic_wd_in_ctb - 1) >> 3] & (1 << ((ctb_indx - ps_sps->i2_pic_wd_in_ctb - 1) & 7)); } if(ps_deblk->i4_ctb_y || i4_is_last_ctb_y) { u4_qp_const_in_ctb[1] = ps_deblk->s_bs_ctxt.pu1_pic_qp_const_in_ctb[(ctb_indx - ps_sps->i2_pic_wd_in_ctb) >> 3] & (1 << ((ctb_indx - ps_sps->i2_pic_wd_in_ctb) & 7)); } src_strd = ps_codec->i4_strd; /* Luma Vertical Edge */ if(0 == i4_is_last_ctb_x) { /* Top CTB's slice header */ slice_header_t *ps_slice_hdr_top; { WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb; if(i4_is_last_ctb_y) cur_ctb_indx += ps_sps->i2_pic_wd_in_ctb; ps_slice_hdr_top = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - ps_sps->i2_pic_wd_in_ctb]; } pu1_src = ps_deblk->pu1_cur_pic_luma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd) << (log2_ctb_size)); pu1_src += i4_is_last_ctb_y ? ps_deblk->ps_codec->i4_strd << log2_ctb_size : 0; /** Deblocking is done on a shifted CTB - * Vertical edge processing is done by shifting the CTB up by four pixels */ pu1_src -= 4 * src_strd; for(col = 0; col < ctb_size / 8; col++) { WORD32 shift = 0; /* downshift vert_bs by ctb_size/2 for each column * shift = (col & ((MAX_CTB_SIZE >> log2_ctb_size) - 1)) << (log2_ctb_size - 1); * which will reduce to the following assuming ctb size is one of 16, 32 and 64 * and deblocking is done on 8x8 grid */ if(6 != log2_ctb_size) shift = (col & 1) << (log2_ctb_size - 1); /* BS for the column - Last row is excluded and the top row is included*/ u4_bs = (pu4_vert_bs[0] >> shift) << 2; if(ps_deblk->i4_ctb_y || i4_is_last_ctb_y) { /* Picking the last BS of the previous CTB corresponding to the same column */ UWORD32 *pu4_vert_bs_top = (UWORD32 *)((UWORD8 *)pu4_vert_bs - bs_strd); UWORD32 u4_top_bs = (*pu4_vert_bs_top) >> (shift + (1 << (log2_ctb_size - 1)) - 2); u4_bs |= u4_top_bs & 3; } for(row = 0; row < ctb_size / 4;) { WORD8 i1_beta_offset_div2 = ps_slice_hdr->i1_beta_offset_div2; WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2; /* Trailing zeros are computed and the corresponding rows are not processed */ bs_tz = CTZ(u4_bs) >> 1; if(0 != bs_tz) { u4_bs = u4_bs >> (bs_tz << 1); if((row + bs_tz) >= (ctb_size / 4)) pu1_src += 4 * (ctb_size / 4 - row) * src_strd; else pu1_src += 4 * bs_tz * src_strd; row += bs_tz; continue; } if(0 == row) { i1_beta_offset_div2 = ps_slice_hdr_top->i1_beta_offset_div2; i1_tc_offset_div2 = ps_slice_hdr_top->i1_tc_offset_div2; if(0 == col) { qp_p = u4_qp_const_in_ctb[0] ? pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] : pu1_qp[-qp_strd - 1]; } else { qp_p = u4_qp_const_in_ctb[1] ? pu1_qp[-ctb_size / 8 * qp_strd] : pu1_qp[col - 1 - qp_strd]; } qp_q = u4_qp_const_in_ctb[1] ? pu1_qp[-ctb_size / 8 * qp_strd] : pu1_qp[col - qp_strd]; } else { if(0 == col) { qp_p = u4_qp_const_in_ctb[2] ? pu1_qp[-ctb_size / 8] : pu1_qp[((row - 1) >> 1) * qp_strd - 1]; } else { qp_p = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[((row - 1) >> 1) * qp_strd + col - 1]; } qp_q = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[((row - 1) >> 1) * qp_strd + col]; } filter_p = (pu2_ctb_no_loop_filter_flag[(row + 1) >> 1] >> col) & 1; filter_q = (pu2_ctb_no_loop_filter_flag[(row + 1) >> 1] >> col) & 2; /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */ filter_p = !filter_p; filter_q = !filter_q; if(filter_p || filter_q) { DUMP_DEBLK_LUMA_VERT(pu1_src, src_strd, u4_bs & 3, qp_p, qp_q, ps_slice_hdr->i1_beta_offset_div2, ps_slice_hdr->i1_tc_offset_div2, filter_p, filter_q); ps_codec->s_func_selector.ihevc_deblk_luma_vert_fptr(pu1_src, src_strd, u4_bs & 3, qp_p, qp_q, i1_beta_offset_div2, i1_tc_offset_div2, filter_p, filter_q); } pu1_src += 4 * src_strd; u4_bs = u4_bs >> 2; row++; } if((64 == ctb_size) || ((32 == ctb_size) && (col & 1))) { pu4_vert_bs++; } pu1_src -= (src_strd << log2_ctb_size); pu1_src += 8; } pu4_vert_bs = pu4_ctb_vert_bs; } /* Luma Horizontal Edge */ if(0 == i4_is_last_ctb_y) { /* Left CTB's slice header */ slice_header_t *ps_slice_hdr_left; { WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb; if(i4_is_last_ctb_x) cur_ctb_indx += 1; ps_slice_hdr_left = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - 1]; } pu1_src = ps_deblk->pu1_cur_pic_luma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd) << log2_ctb_size); pu1_src += i4_is_last_ctb_x ? ctb_size : 0; /** Deblocking is done on a shifted CTB - * Horizontal edge processing is done by shifting the CTB left by four pixels */ pu1_src -= 4; for(row = 0; row < ctb_size / 8; row++) { WORD32 shift = 0; /* downshift vert_bs by ctb_size/2 for each column * shift = (row & (MAX_CTB_SIZE / ctb_size - 1)) * ctb_size / 2; * which will reduce to the following assuming ctb size is one of 16, 32 and 64 * and deblocking is done on 8x8 grid */ if(6 != log2_ctb_size) shift = (row & 1) << (log2_ctb_size - 1); /* BS for the row - Last column is excluded and the left column is included*/ u4_bs = (pu4_horz_bs[0] >> shift) << 2; if(ps_deblk->i4_ctb_x || i4_is_last_ctb_x) { /** Picking the last BS of the previous CTB corresponding to the same row * UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (ctb_size / 8) * (ctb_size / 4) / 8 * 2); */ UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (1 << (2 * log2_ctb_size - 7))); UWORD32 u4_left_bs = (*pu4_horz_bs_left) >> (shift + (1 << (log2_ctb_size - 1)) - 2); u4_bs |= u4_left_bs & 3; } for(col = 0; col < ctb_size / 4;) { WORD8 i1_beta_offset_div2 = ps_slice_hdr->i1_beta_offset_div2; WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2; bs_tz = CTZ(u4_bs) >> 1; if(0 != bs_tz) { u4_bs = u4_bs >> (bs_tz << 1); if((col + bs_tz) >= (ctb_size / 4)) pu1_src += 4 * (ctb_size / 4 - col); else pu1_src += 4 * bs_tz; col += bs_tz; continue; } if(0 == col) { i1_beta_offset_div2 = ps_slice_hdr_left->i1_beta_offset_div2; i1_tc_offset_div2 = ps_slice_hdr_left->i1_tc_offset_div2; if(0 == row) { qp_p = u4_qp_const_in_ctb[0] ? pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] : pu1_qp[-qp_strd - 1]; } else { qp_p = u4_qp_const_in_ctb[2] ? pu1_qp[-ctb_size / 8] : pu1_qp[(row - 1) * qp_strd - 1]; } qp_q = u4_qp_const_in_ctb[2] ? pu1_qp[-ctb_size / 8] : pu1_qp[row * qp_strd - 1]; } else { if(0 == row) { qp_p = u4_qp_const_in_ctb[1] ? pu1_qp[-ctb_size / 8 * qp_strd] : pu1_qp[((col - 1) >> 1) - qp_strd]; } else { qp_p = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[((col - 1) >> 1) + (row - 1) * qp_strd]; } qp_q = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[((col - 1) >> 1) + row * qp_strd]; } filter_p = (pu2_ctb_no_loop_filter_flag[row] >> ((col + 1) >> 1)) & 1; filter_q = (pu2_ctb_no_loop_filter_flag[row + 1] >> ((col + 1) >> 1)) & 1; /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */ filter_p = !filter_p; filter_q = !filter_q; if(filter_p || filter_q) { DUMP_DEBLK_LUMA_HORZ(pu1_src, src_strd, u4_bs & 3, qp_p, qp_q, ps_slice_hdr->i1_beta_offset_div2, ps_slice_hdr->i1_tc_offset_div2, filter_p, filter_q); ps_codec->s_func_selector.ihevc_deblk_luma_horz_fptr(pu1_src, src_strd, u4_bs & 3, qp_p, qp_q, i1_beta_offset_div2, i1_tc_offset_div2, filter_p, filter_q); } pu1_src += 4; u4_bs = u4_bs >> 2; col++; } if((64 == ctb_size) || ((32 == ctb_size) && (row & 1))) { pu4_horz_bs++; } pu1_src -= ctb_size; pu1_src += (src_strd << 3); } pu4_horz_bs = pu4_ctb_horz_bs; } /* Chroma Veritcal Edge */ if(0 == i4_is_last_ctb_x) { /* Top CTB's slice header */ slice_header_t *ps_slice_hdr_top; { WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb; if(i4_is_last_ctb_y) cur_ctb_indx += ps_sps->i2_pic_wd_in_ctb; ps_slice_hdr_top = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - ps_sps->i2_pic_wd_in_ctb]; } pu1_src = ps_deblk->pu1_cur_pic_chroma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd / 2) << log2_ctb_size); pu1_src += i4_is_last_ctb_y ? (ps_deblk->ps_codec->i4_strd / 2) << log2_ctb_size : 0; /** Deblocking is done on a shifted CTB - * Vertical edge processing is done by shifting the CTB up by four pixels */ pu1_src -= 4 * src_strd; for(col = 0; col < ctb_size / 16; col++) { /* BS for the column - Last row is excluded and the top row is included*/ u4_bs = pu4_vert_bs[0] << 2; if(ps_deblk->i4_ctb_y || i4_is_last_ctb_y) { /* Picking the last BS of the previous CTB corresponding to the same column */ UWORD32 *pu4_vert_bs_top = (UWORD32 *)((UWORD8 *)pu4_vert_bs - bs_strd); UWORD32 u4_top_bs = (*pu4_vert_bs_top) >> ((1 << (log2_ctb_size - 1)) - 2); u4_bs |= u4_top_bs & 3; } /* Every alternate boundary strength value is used for chroma */ u4_bs &= 0x22222222; for(row = 0; row < ctb_size / 8;) { WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2; bs_tz = CTZ(u4_bs) >> 2; if(0 != bs_tz) { if((row + bs_tz) >= (ctb_size / 8)) pu1_src += 4 * (ctb_size / 8 - row) * src_strd; else pu1_src += 4 * bs_tz * src_strd; row += bs_tz; u4_bs = u4_bs >> (bs_tz << 2); continue; } if(0 == row) { i1_tc_offset_div2 = ps_slice_hdr_top->i1_tc_offset_div2; if(0 == col) { qp_p = u4_qp_const_in_ctb[0] ? pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] : pu1_qp[-qp_strd - 1]; } else { qp_p = u4_qp_const_in_ctb[1] ? pu1_qp[-ctb_size / 8 * qp_strd] : pu1_qp[2 * col - 1 - qp_strd]; } qp_q = u4_qp_const_in_ctb[1] ? pu1_qp[-ctb_size / 8 * qp_strd] : pu1_qp[2 * col - qp_strd]; } else { if(0 == col) { qp_p = u4_qp_const_in_ctb[2] ? pu1_qp[-ctb_size / 8] : pu1_qp[(row - 1) * qp_strd - 1]; } else { qp_p = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[(row - 1) * qp_strd + 2 * col - 1]; } qp_q = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[(row - 1) * qp_strd + 2 * col]; } filter_p = (pu2_ctb_no_loop_filter_flag[row] >> (col << 1)) & 1; filter_q = (pu2_ctb_no_loop_filter_flag[row] >> (col << 1)) & 2; /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */ filter_p = !filter_p; filter_q = !filter_q; if(filter_p || filter_q) { ASSERT(1 == ((u4_bs & 3) >> 1)); DUMP_DEBLK_CHROMA_VERT(pu1_src, src_strd, u4_bs & 3, qp_p, qp_q, ps_pps->i1_pic_cb_qp_offset, ps_pps->i1_pic_cr_qp_offset, ps_slice_hdr->i1_tc_offset_div2, filter_p, filter_q); if(chroma_yuv420sp_vu) { ps_codec->s_func_selector.ihevc_deblk_chroma_vert_fptr(pu1_src, src_strd, qp_q, qp_p, ps_pps->i1_pic_cr_qp_offset, ps_pps->i1_pic_cb_qp_offset, i1_tc_offset_div2, filter_q, filter_p); } else { ps_codec->s_func_selector.ihevc_deblk_chroma_vert_fptr(pu1_src, src_strd, qp_p, qp_q, ps_pps->i1_pic_cb_qp_offset, ps_pps->i1_pic_cr_qp_offset, i1_tc_offset_div2, filter_p, filter_q); } } pu1_src += 4 * src_strd; u4_bs = u4_bs >> 4; row++; } pu4_vert_bs += (64 == ctb_size) ? 2 : 1; pu1_src -= ((src_strd / 2) << log2_ctb_size); pu1_src += 16; } } /* Chroma Horizontal Edge */ if(0 == i4_is_last_ctb_y) { /* Left CTB's slice header */ slice_header_t *ps_slice_hdr_left; { WORD32 cur_ctb_indx = ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_sps->i2_pic_wd_in_ctb; if(i4_is_last_ctb_x) cur_ctb_indx += 1; ps_slice_hdr_left = ps_codec->ps_slice_hdr_base + ps_deblk->pu1_slice_idx[cur_ctb_indx - 1]; } pu1_src = ps_deblk->pu1_cur_pic_chroma + ((ps_deblk->i4_ctb_x + ps_deblk->i4_ctb_y * ps_deblk->ps_codec->i4_strd / 2) << log2_ctb_size); pu1_src += i4_is_last_ctb_x ? ctb_size : 0; /** Deblocking is done on a shifted CTB - * Vertical edge processing is done by shifting the CTB up by four pixels (8 here beacuse UV are interleaved) */ pu1_src -= 8; for(row = 0; row < ctb_size / 16; row++) { /* BS for the row - Last column is excluded and the left column is included*/ u4_bs = pu4_horz_bs[0] << 2; if(ps_deblk->i4_ctb_x || i4_is_last_ctb_x) { /** Picking the last BS of the previous CTB corresponding to the same row * UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (ctb_size / 8) * (ctb_size / 4) / 8 * 2); */ UWORD32 *pu4_horz_bs_left = (UWORD32 *)((UWORD8 *)pu4_horz_bs - (1 << (2 * log2_ctb_size - 7))); UWORD32 u4_left_bs = (*pu4_horz_bs_left) >> ((1 << (log2_ctb_size - 1)) - 2); u4_bs |= u4_left_bs & 3; } /* Every alternate boundary strength value is used for chroma */ u4_bs &= 0x22222222; for(col = 0; col < ctb_size / 8;) { WORD8 i1_tc_offset_div2 = ps_slice_hdr->i1_tc_offset_div2; bs_tz = CTZ(u4_bs) >> 2; if(0 != bs_tz) { u4_bs = u4_bs >> (bs_tz << 2); if((col + bs_tz) >= (ctb_size / 8)) pu1_src += 8 * (ctb_size / 8 - col); else pu1_src += 8 * bs_tz; col += bs_tz; continue; } if(0 == col) { i1_tc_offset_div2 = ps_slice_hdr_left->i1_tc_offset_div2; if(0 == row) { qp_p = u4_qp_const_in_ctb[0] ? pu1_qp[-ctb_size / 8 * qp_strd - ctb_size / 8] : pu1_qp[-qp_strd - 1]; } else { qp_p = u4_qp_const_in_ctb[2] ? pu1_qp[-ctb_size / 8] : pu1_qp[(2 * row - 1) * qp_strd - 1]; } qp_q = u4_qp_const_in_ctb[2] ? pu1_qp[-ctb_size / 8] : pu1_qp[(2 * row) * qp_strd - 1]; } else { if(0 == row) { qp_p = u4_qp_const_in_ctb[1] ? pu1_qp[-ctb_size / 8 * qp_strd] : pu1_qp[col - 1 - qp_strd]; } else { qp_p = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[(col - 1) + (2 * row - 1) * qp_strd]; } qp_q = u4_qp_const_in_ctb[3] ? pu1_qp[0] : pu1_qp[(col - 1) + 2 * row * qp_strd]; } filter_p = (pu2_ctb_no_loop_filter_flag[row << 1] >> col) & 1; filter_q = (pu2_ctb_no_loop_filter_flag[(row << 1) + 1] >> col) & 1; /* filter_p and filter_q are inverted as they are calculated using no_loop_filter_flags */ filter_p = !filter_p; filter_q = !filter_q; if(filter_p || filter_q) { ASSERT(1 == ((u4_bs & 3) >> 1)); DUMP_DEBLK_CHROMA_HORZ(pu1_src, src_strd, u4_bs & 3, qp_p, qp_q, ps_pps->i1_pic_cb_qp_offset, ps_pps->i1_pic_cr_qp_offset, ps_slice_hdr->i1_tc_offset_div2, filter_p, filter_q); if(chroma_yuv420sp_vu) { ps_codec->s_func_selector.ihevc_deblk_chroma_horz_fptr(pu1_src, src_strd, qp_q, qp_p, ps_pps->i1_pic_cr_qp_offset, ps_pps->i1_pic_cb_qp_offset, i1_tc_offset_div2, filter_q, filter_p); } else { ps_codec->s_func_selector.ihevc_deblk_chroma_horz_fptr(pu1_src, src_strd, qp_p, qp_q, ps_pps->i1_pic_cb_qp_offset, ps_pps->i1_pic_cr_qp_offset, i1_tc_offset_div2, filter_p, filter_q); } } pu1_src += 8; u4_bs = u4_bs >> 4; col++; } pu4_horz_bs += (64 == ctb_size) ? 2 : 1; pu1_src -= ctb_size; pu1_src += 8 * src_strd; } } }