1 /****************************************************************************** 2 * 3 * Copyright (C) 2018 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ***************************************************************************** 18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19 */ 20 /** 21 ******************************************************************************* 22 * @file 23 * ihevce_deblk.c 24 * 25 * @brief 26 * Contains definition for the ctb level deblk function 27 * 28 * @author 29 * ittiam 30 * 31 * @List of Functions: 32 * ihevce_deblk_populate_qp_map() 33 * ihevce_deblk_ctb() 34 * ihevce_hbd_deblk_ctb() 35 * 36 * @remarks 37 * None 38 * 39 ******************************************************************************* 40 */ 41 42 /*****************************************************************************/ 43 /* File Includes */ 44 /*****************************************************************************/ 45 /* System include files */ 46 #include <stdio.h> 47 #include <string.h> 48 #include <stdlib.h> 49 #include <assert.h> 50 #include <stdarg.h> 51 #include <math.h> 52 53 /* User include files */ 54 #include "ihevc_typedefs.h" 55 #include "itt_video_api.h" 56 #include "ihevce_api.h" 57 58 #include "rc_cntrl_param.h" 59 #include "rc_frame_info_collector.h" 60 #include "rc_look_ahead_params.h" 61 62 #include "ihevc_defs.h" 63 #include "ihevc_debug.h" 64 #include "ihevc_structs.h" 65 #include "ihevc_platform_macros.h" 66 #include "ihevc_deblk.h" 67 #include "ihevc_deblk_tables.h" 68 #include "ihevc_common_tables.h" 69 #include "ihevc_itrans_recon.h" 70 #include "ihevc_chroma_itrans_recon.h" 71 #include "ihevc_chroma_intra_pred.h" 72 #include "ihevc_intra_pred.h" 73 #include "ihevc_inter_pred.h" 74 #include "ihevc_mem_fns.h" 75 #include "ihevc_padding.h" 76 #include "ihevc_weighted_pred.h" 77 #include "ihevc_sao.h" 78 #include "ihevc_resi_trans.h" 79 #include "ihevc_quant_iquant_ssd.h" 80 #include "ihevc_cabac_tables.h" 81 82 #include "ihevce_defs.h" 83 #include "ihevce_hle_interface.h" 84 #include "ihevce_lap_enc_structs.h" 85 #include "ihevce_multi_thrd_structs.h" 86 #include "ihevce_me_common_defs.h" 87 #include "ihevce_had_satd.h" 88 #include "ihevce_error_codes.h" 89 #include "ihevce_bitstream.h" 90 #include "ihevce_cabac.h" 91 #include "ihevce_rdoq_macros.h" 92 #include "ihevce_function_selector.h" 93 #include "ihevce_enc_structs.h" 94 #include "ihevce_entropy_structs.h" 95 #include "ihevce_cmn_utils_instr_set_router.h" 96 #include "ihevce_enc_loop_structs.h" 97 #include "ihevce_common_utils.h" 98 #include "ihevce_global_tables.h" 99 #include "ihevce_deblk.h" 100 #include "ihevce_tile_interface.h" 101 102 /*****************************************************************************/ 103 /* Function Definitions */ 104 /*****************************************************************************/ 105 106 /*! 107 ****************************************************************************** 108 * \if Function name : ihevce_deblk_populate_qp_map \endif 109 * 110 * \brief 111 * 112 * 113 ***************************************************************************** 114 */ 115 void ihevce_deblk_populate_qp_map( 116 ihevce_enc_loop_ctxt_t *ps_ctxt, 117 deblk_ctbrow_prms_t *ps_deblk_ctb_row_params, 118 ctb_enc_loop_out_t *ps_ctb_out_dblk, 119 WORD32 vert_ctr, 120 frm_ctb_ctxt_t *ps_frm_ctb_prms, 121 ihevce_tile_params_t *ps_col_tile_params) 122 { 123 ctb_enc_loop_out_t *ps_ctb_out; 124 WORD32 ctb_ctr, ctb_start, ctb_end; 125 WORD32 tile_qp_offset, tile_qp_size, i4_offset_for_last_cu_qp; 126 /* Create the Qp map for the entire current CTB-row for deblocking purpose(only)*/ 127 /* Do this iff cur pic is referred or recon dump is enabled or psnr calc is on*/ 128 /*Qp of the last CU of previous CTB row*/ 129 WORD8 i1_last_cu_qp; 130 /*A pointer pointing to the top 4x4 block's Qp for all CTb rows*/ 131 WORD8 *pi1_qp_top_4x4_ctb_row = 132 ps_deblk_ctb_row_params->api1_qp_top_4x4_ctb_row[ps_ctxt->i4_enc_frm_id] + 133 (ps_deblk_ctb_row_params->u4_qp_top_4x4_buf_size * ps_ctxt->i4_bitrate_instance_num); 134 135 UWORD32 u4_qp_top_4x4_buf_strd = ps_deblk_ctb_row_params->u4_qp_top_4x4_buf_strd; 136 137 /*The Qp map which has to be populated*/ 138 UWORD32 u4_qp_buffer_stride = ps_deblk_ctb_row_params->u4_qp_buffer_stride; 139 WORD8 *pi1_ctb_tile_qp = ps_deblk_ctb_row_params->pi1_ctb_row_qp; 140 141 /*Temporary pointers to Qp map at CTB level*/ 142 WORD8 *pi1_ctb_qp_map_tile; 143 144 i4_offset_for_last_cu_qp = ps_ctxt->pi4_offset_for_last_cu_qp[ps_ctxt->i4_tile_col_idx]; 145 /* total QPs to be copied for current row is : */ 146 tile_qp_size = i4_offset_for_last_cu_qp + 1; 147 /*Pointing to the first CTB of current CTB row*/ 148 ps_ctb_out = ps_ctb_out_dblk; 149 /* Offset req. for the row QP to the tile start */ 150 tile_qp_offset = ps_col_tile_params->i4_first_ctb_x * (ps_frm_ctb_prms->i4_ctb_size / 4); 151 152 ctb_start = ps_col_tile_params->i4_first_ctb_x; 153 ctb_end = 154 (ps_col_tile_params->i4_first_ctb_x + ps_col_tile_params->i4_curr_tile_wd_in_ctb_unit); 155 156 if(vert_ctr) /*Not first CTB row of frame*/ 157 { 158 /*copy from top4x4_array data stored by upper CTB-row to qp-map*/ 159 memcpy( 160 pi1_ctb_tile_qp, 161 (pi1_qp_top_4x4_ctb_row + (vert_ctr - 1) * u4_qp_top_4x4_buf_strd + tile_qp_offset), 162 tile_qp_size); 163 } 164 165 /*pu1_ctb_row_qp points to top4x4 row in Qp-map. 166 Now pointing pu1_ctb_qp_map to cur 4x4 row*/ 167 pi1_ctb_qp_map_tile = pi1_ctb_tile_qp + u4_qp_buffer_stride; 168 169 /* This i1_last_cu_qp will be conditionally overwritten later */ 170 i1_last_cu_qp = ps_ctxt->i4_frame_qp; 171 172 /* -- Loop over all the CTBs in a CTB-row for populating the Qp-map ----- */ 173 for(ctb_ctr = ctb_start; ctb_ctr < ctb_end; ctb_ctr++) 174 { 175 WORD32 cu_ctr; 176 cu_enc_loop_out_t *ps_curr_cu; 177 178 /* Update i1_last_cu_qp based on CTB's position in tile */ 179 update_last_coded_cu_qp( 180 (ps_deblk_ctb_row_params->pi1_ctb_row_qp + i4_offset_for_last_cu_qp), 181 ps_ctxt->i1_entropy_coding_sync_enabled_flag, 182 ps_frm_ctb_prms, 183 ps_ctxt->i4_frame_qp, 184 vert_ctr, 185 ctb_ctr, 186 &i1_last_cu_qp); 187 188 /* store the pointer of first cu of current ctb */ 189 ps_curr_cu = ps_ctb_out->ps_enc_cu; 190 191 /* --------- loop over all the CUs in the CTB --------------- */ 192 for(cu_ctr = 0; cu_ctr < ps_ctb_out->u1_num_cus_in_ctb; cu_ctr++) 193 { 194 UWORD8 u1_vert_4x4, u1_horz_4x4; //for_loop counters 195 WORD8 *pi1_cu_qp_map; 196 197 WORD8 i1_qp, i1_qp_left, i1_qp_top; 198 199 pi1_cu_qp_map = pi1_ctb_qp_map_tile + 200 (ps_curr_cu->b3_cu_pos_y * 2) * u4_qp_buffer_stride + 201 (ps_curr_cu->b3_cu_pos_x * 2); 202 203 /*If the current CU is coded in skip_mode/zero_CBF then 204 for deblocking, Qp of the previously coded CU will be used*/ 205 if(ps_curr_cu->b1_skip_flag || ps_curr_cu->b1_no_residual_syntax_flag) 206 { 207 if(0 == ps_curr_cu->b3_cu_pos_x) 208 i1_qp_left = i1_last_cu_qp; 209 else 210 i1_qp_left = *(pi1_cu_qp_map - 1); 211 212 if(0 == ps_curr_cu->b3_cu_pos_y) 213 i1_qp_top = i1_last_cu_qp; 214 else 215 i1_qp_top = *(pi1_cu_qp_map - u4_qp_buffer_stride); 216 217 i1_qp = (i1_qp_left + i1_qp_top + 1) / 2; 218 219 if(0 == ps_curr_cu->b1_first_cu_in_qg) 220 { 221 i1_qp = i1_last_cu_qp; 222 } 223 } 224 else 225 { 226 i1_qp = ps_curr_cu->i1_cu_qp; 227 } 228 229 i1_last_cu_qp = i1_qp; 230 231 /*---- Loop for populating Qp map for the current CU -------*/ 232 for(u1_vert_4x4 = 0; u1_vert_4x4 < (ps_curr_cu->b4_cu_size * 2); u1_vert_4x4++) 233 { 234 for(u1_horz_4x4 = 0; u1_horz_4x4 < (ps_curr_cu->b4_cu_size * 2); u1_horz_4x4++) 235 { 236 pi1_cu_qp_map[u1_horz_4x4] = i1_qp; 237 } 238 pi1_cu_qp_map += u4_qp_buffer_stride; 239 } 240 /*Update Qp-map ptr. Qp map is at 4x4 level but b4_cu_size is at 8x8 level*/ 241 ps_curr_cu++; 242 } 243 pi1_ctb_qp_map_tile += (ps_frm_ctb_prms->i4_ctb_size / 4); //one qp per 4x4 block. 244 ps_ctb_out++; 245 246 } //for(ctb_ctr = 0; ctb_ctr < num_ctbs_horz; ctb_ctr++) 247 248 /*fill into the top4x4_array Qp for the lower CTB-row from bottom part of cur CTB row*/ 249 memcpy( 250 (pi1_qp_top_4x4_ctb_row + vert_ctr * u4_qp_top_4x4_buf_strd + tile_qp_offset), 251 (pi1_ctb_tile_qp + (ps_frm_ctb_prms->i4_ctb_size / 4) * u4_qp_buffer_stride), 252 tile_qp_size); 253 } 254 255 /** 256 ******************************************************************************* 257 * 258 * @brief 259 * Deblock CTB level function. 260 * 261 * @par Description: 262 * For a given CTB, deblocking on both vertical and 263 * horizontal edges is done. Both the luma and chroma 264 * blocks are processed 265 * 266 * @param[in] 267 * ps_deblk: Pointer to the deblock context 268 * last_col: if the CTB is the last CTB of current CTB-row value is 1 else 0 269 * ps_deblk_ctb_row_params: deblk ctb row params 270 * 271 * @returns 272 * 273 * @remarks 274 * None 275 * 276 ******************************************************************************* 277 */ 278 void ihevce_deblk_ctb( 279 deblk_ctb_params_t *ps_deblk, WORD32 last_col, deblk_ctbrow_prms_t *ps_deblk_ctb_row_params) 280 { 281 WORD32 ctb_size; 282 UWORD32 u4_bs; 283 WORD32 bs_lz; /*Leading zeros in boundary strength*/ 284 WORD32 qp_p, qp_q; 285 UWORD8 *pu1_src; 286 UWORD8 *pu1_src_uv; 287 UWORD8 *pu1_curr_src; 288 WORD32 col_size; 289 WORD32 col, row, i4_edge_count; 290 WORD32 num_columns_for_vert_filt; 291 WORD32 num_blks_for_vert_filt; 292 WORD32 num_rows_for_horz_filt; 293 294 ihevc_deblk_chroma_horz_ft *pf_deblk_chroma_horz; 295 ihevc_deblk_chroma_horz_ft *pf_deblk_chroma_vert; 296 297 /* Filter flags are packed along with the qp info. 298 6 out of the 8 bits correspond to qp and 1 to filter flag. */ 299 /* filter_p and filter_q are initialized to 1. 300 They are to be extracted along with the qp info. */ 301 WORD32 filter_p, filter_q; 302 WORD8 *pi1_ctb_row_qp_p, *pi1_ctb_row_qp_temp; 303 WORD8 *pi1_ctb_row_qp_q; 304 305 func_selector_t *ps_func_slector = ps_deblk->ps_func_selector; 306 307 WORD32 left_luma_edge_filter_flag = ps_deblk->i4_deblock_left_ctb_edge; 308 WORD32 top_luma_edge_filter_flag = ps_deblk->i4_deblock_top_ctb_edge; 309 WORD32 left_chroma_edge_filter_flag = ps_deblk->i4_deblock_left_ctb_edge; 310 WORD32 top_chroma_edge_filter_flag = ps_deblk->i4_deblock_top_ctb_edge; 311 UWORD32 *bs_vert = ps_deblk_ctb_row_params->pu4_ctb_row_bs_vert; 312 UWORD32 *bs_horz = ps_deblk_ctb_row_params->pu4_ctb_row_bs_horz; 313 UWORD32 *bs_vert_uv = bs_vert; 314 UWORD32 *bs_horz_uv = bs_horz; 315 UWORD32 u4_qp_buffer_stride = ps_deblk_ctb_row_params->u4_qp_buffer_stride; 316 UWORD8 u1_is_422 = (ps_deblk->u1_chroma_array_type == 2); 317 318 if(u1_is_422) 319 { 320 pf_deblk_chroma_horz = ps_func_slector->ihevc_deblk_422chroma_horz_fptr; 321 pf_deblk_chroma_vert = ps_func_slector->ihevc_deblk_422chroma_vert_fptr; 322 } 323 else 324 { 325 pf_deblk_chroma_horz = ps_func_slector->ihevc_deblk_chroma_horz_fptr; 326 pf_deblk_chroma_vert = ps_func_slector->ihevc_deblk_chroma_vert_fptr; 327 } 328 329 ctb_size = ps_deblk->i4_ctb_size; 330 331 /* The PCM filter flag and bypass trans flag are always set to 1 in encoder profile */ 332 /* Can be removed during optimization */ 333 filter_q = 1; 334 filter_p = 1; 335 336 ////////////////////////////////////////////////////////////////////////////// 337 /* Luma Veritcal Edge */ 338 pu1_src = ps_deblk->pu1_ctb_y; 339 pi1_ctb_row_qp_temp = ps_deblk_ctb_row_params->pi1_ctb_row_qp + u4_qp_buffer_stride; 340 num_columns_for_vert_filt = ctb_size / 8; 341 num_blks_for_vert_filt = ctb_size / 4; 342 343 for(i4_edge_count = 0; i4_edge_count < num_columns_for_vert_filt; i4_edge_count++) 344 { 345 u4_bs = *bs_vert; 346 /* get the current 4x4 vertical pointer */ 347 pu1_curr_src = pu1_src; 348 pi1_ctb_row_qp_q = pi1_ctb_row_qp_temp + (i4_edge_count << 1); 349 350 /* If the current edge is not the 1st edge of frame or slice */ 351 if(1 == left_luma_edge_filter_flag) 352 { 353 for(row = 0; row < num_blks_for_vert_filt;) 354 { 355 bs_lz = CLZ(u4_bs) >> 1; 356 /* If BS = 0, skip the egde filtering */ 357 if(0 != bs_lz) 358 { 359 u4_bs = u4_bs << (bs_lz << 1); 360 pu1_curr_src += ((bs_lz << 2) * ps_deblk->i4_luma_pic_stride); 361 pi1_ctb_row_qp_q += (bs_lz * u4_qp_buffer_stride); 362 row += bs_lz; 363 continue; 364 } 365 qp_p = *(pi1_ctb_row_qp_q - 1); 366 qp_q = *pi1_ctb_row_qp_q; 367 368 ps_func_slector->ihevc_deblk_luma_vert_fptr( 369 pu1_curr_src, 370 ps_deblk->i4_luma_pic_stride, 371 (u4_bs >> 30), /* bits 31 and 30 are extracted */ 372 qp_p, 373 qp_q, 374 ps_deblk->i4_beta_offset_div2, 375 ps_deblk->i4_tc_offset_div2, 376 filter_p, 377 filter_q); 378 379 u4_bs = u4_bs << 2; 380 pu1_curr_src += (ps_deblk->i4_luma_pic_stride << 2); 381 pi1_ctb_row_qp_q += u4_qp_buffer_stride; 382 row++; 383 } 384 } 385 386 /* Increment the boundary strength and src pointer for the next column */ 387 bs_vert += 1; 388 pu1_src += 8; 389 390 /* Enable for the next edges of ctb*/ 391 left_luma_edge_filter_flag = 1; 392 } 393 394 ////////////////////////////////////////////////////////////////////////////// 395 /* Chroma Veritcal Edge */ 396 pu1_src_uv = ps_deblk->pu1_ctb_uv; 397 pi1_ctb_row_qp_temp = ps_deblk_ctb_row_params->pi1_ctb_row_qp + u4_qp_buffer_stride; 398 399 /* Column spacing is 4 for each chroma component */ 400 /* and hence 8 when they are interleaved. */ 401 /* But, only those columns with a x co-ordinate */ 402 /* that is divisiblee by 8 are filtered */ 403 /* Hence, denominator is 16 */ 404 num_columns_for_vert_filt = ctb_size / 16; 405 /* blk_size is 4 and chroma_ctb_height is ctb_size/2 */ 406 num_blks_for_vert_filt = (0 == u1_is_422) ? (ctb_size / 2) / 4 : (ctb_size) / 4; 407 408 for(i4_edge_count = 0; i4_edge_count < num_columns_for_vert_filt; i4_edge_count++) 409 { 410 /* Every alternate boundary strength value is used for 420 chroma */ 411 u4_bs = *(bs_vert_uv) & ((0 == u1_is_422) ? 0x88888888 : 0xaaaaaaaa); 412 pu1_curr_src = pu1_src_uv; 413 pi1_ctb_row_qp_q = pi1_ctb_row_qp_temp + (i4_edge_count << 2); 414 415 /* If the current edge is not the 1st edge of frame or slice */ 416 if(1 == left_chroma_edge_filter_flag) 417 { 418 /* Each 'bs' is 2 bits long */ 419 /* The divby4 in 420 is */ 420 /* necessitated by the fact that */ 421 /* chroma ctb_ht is half that of luma */ 422 WORD32 i4_log2_num_bits_per_bs = ((0 == u1_is_422) + 1); 423 /* i4_sub_heightC = 2 for 420 */ 424 /* i4_sub_heightC = 1 for 422 */ 425 WORD32 i4_sub_heightC = i4_log2_num_bits_per_bs; 426 427 for(row = 0; row < num_blks_for_vert_filt;) 428 { 429 bs_lz = CLZ(u4_bs) >> i4_log2_num_bits_per_bs; 430 431 /* If BS = 0, skip the egde filtering */ 432 if(0 != bs_lz) 433 { 434 row += bs_lz; 435 u4_bs = u4_bs << (bs_lz << i4_log2_num_bits_per_bs); 436 /* '<<2' because of blk_size being 4x4 */ 437 pu1_curr_src += ((bs_lz << 2) * ps_deblk->i4_chroma_pic_stride); 438 439 /* In 420, every alternate QP row is skipped, because chroma height */ 440 /* In 422, no row is skipped */ 441 pi1_ctb_row_qp_q += ((u4_qp_buffer_stride << (i4_sub_heightC - 1)) * bs_lz); 442 443 continue; 444 } 445 446 qp_p = *(pi1_ctb_row_qp_q - i4_sub_heightC); 447 qp_q = *pi1_ctb_row_qp_q; 448 449 pf_deblk_chroma_vert( 450 pu1_curr_src, 451 ps_deblk->i4_chroma_pic_stride, 452 qp_p, 453 qp_q, 454 ps_deblk->i4_cb_qp_indx_offset, 455 ps_deblk->i4_cr_qp_indx_offset, 456 ps_deblk->i4_tc_offset_div2, 457 filter_p, 458 filter_q); 459 460 u4_bs = u4_bs << (1 << i4_log2_num_bits_per_bs); 461 pu1_curr_src += (ps_deblk->i4_chroma_pic_stride << 2); 462 pi1_ctb_row_qp_q += (u4_qp_buffer_stride << (i4_sub_heightC - 1)); 463 row++; 464 } 465 } 466 /* Increment the boundary strength by 2 and src pointer for the next column */ 467 /* As the edge filtering happens for alternate column */ 468 bs_vert_uv += 2; 469 pu1_src_uv += 16; 470 left_chroma_edge_filter_flag = 1; 471 } 472 473 ////////////////////////////////////////////////////////////////////////////// 474 475 /* Luma Horizontal Edge */ 476 pu1_src = ps_deblk->pu1_ctb_y; 477 col_size = ctb_size / 4; 478 479 /* If the ctb is the 1st ctb of row, */ 480 /* Decrement the loop count to exclude filtering of last 4 pixels */ 481 /* else shift the src pointer by 4 pixels to do filtering for shifted ctb */ 482 if(ps_deblk->i4_deblock_left_ctb_edge == 1) 483 { 484 pu1_src -= 4; 485 /*If the ctb is at the horizonatl end of PIC*/ 486 /* Increase the column size to filter last 4 pixels */ 487 col_size += last_col; 488 } 489 else if(!last_col) 490 { 491 col_size -= 1; 492 } 493 { 494 UWORD8 *pu1_src_temp = pu1_src; 495 //pu1_ctb_row_qp_p and pu1_ctb_row_qp_q point to alternate rows 496 pi1_ctb_row_qp_p = ps_deblk_ctb_row_params->pi1_ctb_row_qp; 497 498 num_rows_for_horz_filt = ctb_size / 8; 499 500 for(i4_edge_count = 0; i4_edge_count < num_rows_for_horz_filt; i4_edge_count++) 501 { 502 WORD32 col_size_temp = col_size; 503 pi1_ctb_row_qp_q = pi1_ctb_row_qp_p + u4_qp_buffer_stride; 504 pu1_src = pu1_src_temp + (i4_edge_count * 8 * ps_deblk->i4_luma_pic_stride); 505 506 if(1 == top_luma_edge_filter_flag) 507 { 508 //Deblock the last vertical_4x4_column of previous CTB 509 if(ps_deblk->i4_deblock_left_ctb_edge == 1) 510 { 511 u4_bs = ps_deblk->au1_prev_bs[i4_edge_count] & 0x3; 512 if(u4_bs != 0) 513 { 514 qp_p = *(pi1_ctb_row_qp_p - 1); 515 qp_q = *(pi1_ctb_row_qp_q - 1); 516 517 ps_func_slector->ihevc_deblk_luma_horz_fptr( 518 pu1_src, 519 ps_deblk->i4_luma_pic_stride, 520 u4_bs, 521 qp_p, 522 qp_q, 523 ps_deblk->i4_beta_offset_div2, 524 ps_deblk->i4_tc_offset_div2, 525 1, 526 1); 527 } 528 529 pu1_src += 4; 530 col_size_temp--; 531 } 532 //Start deblocking current CTB 533 u4_bs = *(bs_horz); 534 535 for(col = 0; col < col_size_temp;) 536 { 537 bs_lz = CLZ(u4_bs) >> 1; 538 if(0 != bs_lz) 539 { 540 u4_bs = u4_bs << (bs_lz << 1); 541 pu1_src += 4 * bs_lz; 542 col += bs_lz; 543 continue; 544 } 545 qp_p = *(pi1_ctb_row_qp_p + col); 546 qp_q = *(pi1_ctb_row_qp_q + col); 547 548 ps_func_slector->ihevc_deblk_luma_horz_fptr( 549 pu1_src, 550 ps_deblk->i4_luma_pic_stride, 551 u4_bs >> (sizeof(u4_bs) * 8 - 2), 552 qp_p, 553 qp_q, 554 ps_deblk->i4_beta_offset_div2, 555 ps_deblk->i4_tc_offset_div2, 556 filter_p, 557 filter_q); 558 559 pu1_src += 4; 560 u4_bs = u4_bs << 2; 561 col++; 562 } 563 //Store the last vertical_4x4 column of CTB's info for next CTB deblocking 564 u4_bs = *bs_horz; 565 ps_deblk->au1_prev_bs[i4_edge_count] = 566 (UWORD8)(((u4_bs << ((ctb_size >> 1) - 2))) >> 30); 567 } 568 bs_horz += 1; 569 pi1_ctb_row_qp_p += (u4_qp_buffer_stride << 1); 570 top_luma_edge_filter_flag = 1; 571 } 572 } 573 574 ////////////////////////////////////////////////////////////////////////////// 575 /* Chroma Horizontal Edge */ 576 pu1_src_uv = ps_deblk->pu1_ctb_uv; 577 col_size = ctb_size / 8; 578 579 /* If the ctb is the 1st ctb of row, */ 580 /* Decrement the loop count to exclude filtering of last 4 pixels */ 581 /* else shift the src pointer by 8 (uv) pixels to do filtering for shifted ctb */ 582 if(ps_deblk->i4_deblock_left_ctb_edge == 1) 583 { 584 pu1_src_uv -= 8; 585 586 /*If the ctb is at the horizonatl end of PIC*/ 587 /* Increase the column size to filter last 8 (uv) pixels */ 588 col_size += last_col; 589 } 590 else if(!last_col) 591 { 592 col_size--; 593 } 594 595 { 596 UWORD8 *pu1_src_temp = pu1_src_uv; 597 598 //pu1_ctb_row_qp_p and pu1_ctb_row_qp_q point to alternate rows 599 pi1_ctb_row_qp_p = ps_deblk_ctb_row_params->pi1_ctb_row_qp; 600 num_rows_for_horz_filt = ctb_size / ((0 == u1_is_422) ? 16 : 8); 601 602 for(i4_edge_count = 0; i4_edge_count < num_rows_for_horz_filt; i4_edge_count++) 603 { 604 WORD32 col_size_temp = col_size; 605 606 pi1_ctb_row_qp_q = pi1_ctb_row_qp_p + u4_qp_buffer_stride; 607 pu1_src_uv = pu1_src_temp + (i4_edge_count * 8 * ps_deblk->i4_chroma_pic_stride); 608 609 if(1 == top_chroma_edge_filter_flag) 610 { 611 //Deblock the last vertical _4x4_column of previous CTB 612 if(ps_deblk->i4_deblock_left_ctb_edge == 1) 613 { 614 u4_bs = ps_deblk->au1_prev_bs_uv[i4_edge_count] & 0x2; 615 616 if(u4_bs == 2) 617 { 618 qp_p = *(pi1_ctb_row_qp_p - 1); 619 qp_q = *(pi1_ctb_row_qp_q - 1); 620 621 pf_deblk_chroma_horz( 622 pu1_src_uv, 623 ps_deblk->i4_chroma_pic_stride, 624 qp_p, 625 qp_q, 626 ps_deblk->i4_cb_qp_indx_offset, 627 ps_deblk->i4_cr_qp_indx_offset, 628 ps_deblk->i4_tc_offset_div2, 629 1, 630 1); 631 } 632 633 pu1_src_uv += 8; 634 col_size_temp--; 635 } 636 637 //Start deblocking current CTB 638 u4_bs = *(bs_horz_uv)&0x88888888; 639 640 for(col = 0; col < col_size_temp;) 641 { 642 bs_lz = CLZ(u4_bs) >> 2; 643 644 if(0 != bs_lz) 645 { 646 u4_bs = u4_bs << (bs_lz << 2); 647 pu1_src_uv += (8 * bs_lz); 648 649 col += bs_lz; 650 continue; 651 } 652 653 qp_p = *(pi1_ctb_row_qp_p + (col << 1)); 654 qp_q = *(pi1_ctb_row_qp_q + (col << 1)); 655 656 pf_deblk_chroma_horz( 657 pu1_src_uv, 658 ps_deblk->i4_chroma_pic_stride, 659 qp_p, 660 qp_q, 661 ps_deblk->i4_cb_qp_indx_offset, 662 ps_deblk->i4_cr_qp_indx_offset, 663 ps_deblk->i4_tc_offset_div2, 664 filter_p, 665 filter_q); 666 667 pu1_src_uv += 8; 668 u4_bs = u4_bs << 4; 669 col++; 670 } 671 672 //Store the last vertical_4x4 column of CTB's info for next CTB deblocking 673 u4_bs = *bs_horz_uv; 674 ps_deblk->au1_prev_bs_uv[i4_edge_count] = 675 (UWORD8)(((u4_bs << ((ctb_size >> 1) - 4))) >> 30); 676 } 677 678 bs_horz_uv += ((0 == u1_is_422) + 1); 679 pi1_ctb_row_qp_p += (u4_qp_buffer_stride << ((0 == u1_is_422) + 1)); 680 top_chroma_edge_filter_flag = 1; 681 } 682 } 683 684 return; 685 } 686
