| /****************************************************************************** |
| * |
| * 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 <stdio.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <assert.h> |
| |
| #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; |
| |
| } |
| } |
| } |
