| /****************************************************************************** |
| * |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| |
| /*! |
| ****************************************************************************** |
| * \file ihevce_tile_interface.c |
| * |
| * \brief |
| * This file contains functions related to tile interface |
| * |
| * \date |
| * 24/10/2012 |
| * |
| * \author |
| * Ittiam |
| * |
| * |
| * List of Functions |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| /* System include files */ |
| #include <string.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| |
| /* User include files */ |
| #include "ihevc_typedefs.h" |
| #include "itt_video_api.h" |
| #include "ihevce_api.h" |
| |
| #include "rc_cntrl_param.h" |
| #include "rc_frame_info_collector.h" |
| #include "rc_look_ahead_params.h" |
| |
| #include "ihevc_defs.h" |
| #include "ihevc_structs.h" |
| #include "ihevc_platform_macros.h" |
| #include "ihevc_deblk.h" |
| #include "ihevc_itrans_recon.h" |
| #include "ihevc_chroma_itrans_recon.h" |
| #include "ihevc_chroma_intra_pred.h" |
| #include "ihevc_intra_pred.h" |
| #include "ihevc_inter_pred.h" |
| #include "ihevc_mem_fns.h" |
| #include "ihevc_padding.h" |
| #include "ihevc_weighted_pred.h" |
| #include "ihevc_sao.h" |
| #include "ihevc_resi_trans.h" |
| #include "ihevc_quant_iquant_ssd.h" |
| #include "ihevc_cabac_tables.h" |
| |
| #include "ihevce_defs.h" |
| #include "ihevce_lap_enc_structs.h" |
| #include "ihevce_multi_thrd_structs.h" |
| #include "ihevce_me_common_defs.h" |
| #include "ihevce_had_satd.h" |
| #include "ihevce_error_codes.h" |
| #include "ihevce_bitstream.h" |
| #include "ihevce_cabac.h" |
| #include "ihevce_rdoq_macros.h" |
| #include "ihevce_function_selector.h" |
| #include "ihevce_enc_structs.h" |
| #include "ihevce_entropy_structs.h" |
| #include "ihevce_cmn_utils_instr_set_router.h" |
| #include "ihevce_enc_loop_structs.h" |
| #include "ihevce_tile_interface.h" |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_update_tile_params \endif |
| * |
| * \brief |
| * Updates the ps_tile_params structres based on the tile-position in frame. |
| * |
| ***************************************************************************** |
| */ |
| void ihevce_update_tile_params( |
| ihevce_static_cfg_params_t *ps_static_cfg_prms, |
| ihevce_tile_params_t *ps_tile_params, |
| WORD32 i4_resolution_id) |
| { |
| /* Total number of tiles in a frame */ |
| ihevce_app_tile_params_t *ps_app_tile_prms; |
| WORD32 i4_num_tiles; |
| WORD32 i4_cu_aligned_tgt_frame_ht, |
| i4_cu_aligned_tgt_frame_wd; //Frame width and height specific to target-resolution |
| WORD32 i4_ctb_aligned_tgt_frame_ht, |
| i4_ctb_aligned_tgt_frame_wd; //Frame width and height specific to target-resolution |
| WORD32 i4_x_y = 0; |
| WORD32 i4_pos; |
| WORD32 i4_i; |
| |
| WORD32 i4_curr_tile_id; |
| WORD32 i4_max_log2_cu_size, i4_ctb_size; |
| WORD32 i4_pic_wd_in_ctb; |
| WORD32 i4_pic_ht_in_ctb; |
| WORD32 min_cu_size; |
| WORD32 i4_num_tile_cols = 1; |
| WORD32 i4_num_tile_rows = 1; |
| |
| ps_app_tile_prms = &ps_static_cfg_prms->s_app_tile_params; |
| |
| i4_max_log2_cu_size = ps_static_cfg_prms->s_config_prms.i4_max_log2_cu_size; |
| i4_ctb_size = 1 << i4_max_log2_cu_size; |
| |
| min_cu_size = 1 << ps_static_cfg_prms->s_config_prms.i4_min_log2_cu_size; |
| |
| /* Allign the frame width to min CU size */ |
| i4_cu_aligned_tgt_frame_wd = |
| ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width + |
| SET_CTB_ALIGN( |
| ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width, |
| min_cu_size); |
| |
| /* Allign the frame hieght to min CU size */ |
| i4_cu_aligned_tgt_frame_ht = |
| ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height + |
| SET_CTB_ALIGN( |
| ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height, |
| min_cu_size); |
| |
| if(1 == ps_app_tile_prms->i4_tiles_enabled_flag) |
| { |
| i4_num_tile_cols = ps_app_tile_prms->i4_num_tile_cols; |
| i4_num_tile_rows = ps_app_tile_prms->i4_num_tile_rows; |
| } |
| |
| i4_num_tiles = i4_num_tile_cols * i4_num_tile_rows; |
| |
| i4_ctb_aligned_tgt_frame_wd = i4_cu_aligned_tgt_frame_wd; |
| i4_ctb_aligned_tgt_frame_wd += SET_CTB_ALIGN(i4_ctb_aligned_tgt_frame_wd, MAX_CTB_SIZE); |
| i4_pic_wd_in_ctb = i4_ctb_aligned_tgt_frame_wd >> i4_max_log2_cu_size; |
| |
| i4_ctb_aligned_tgt_frame_ht = i4_cu_aligned_tgt_frame_ht; |
| i4_ctb_aligned_tgt_frame_ht += SET_CTB_ALIGN(i4_ctb_aligned_tgt_frame_ht, MAX_CTB_SIZE); |
| i4_pic_ht_in_ctb = i4_ctb_aligned_tgt_frame_ht >> i4_max_log2_cu_size; |
| |
| /* Update tile enable flag in each instance's tile struct */ |
| ps_tile_params->i4_tiles_enabled_flag = ps_app_tile_prms->i4_tiles_enabled_flag; |
| |
| ps_tile_params->i4_num_tile_cols = i4_num_tile_cols; |
| ps_tile_params->i4_num_tile_rows = i4_num_tile_rows; |
| |
| i4_curr_tile_id = ps_tile_params->i4_curr_tile_id; |
| |
| /* num tiles in frame */ |
| ps_tile_params->i4_num_tiles = i4_num_tiles; |
| |
| ps_tile_params->i4_uniform_spacing_flag = ps_app_tile_prms->i4_uniform_spacing_flag; |
| |
| if(0 == ps_tile_params->i4_tiles_enabled_flag) |
| { |
| /* curr tile width and height */ |
| ps_tile_params->i4_curr_tile_width = i4_cu_aligned_tgt_frame_wd; |
| ps_tile_params->i4_curr_tile_height = i4_cu_aligned_tgt_frame_ht; |
| |
| ps_tile_params->i4_first_ctb_x = 0; |
| ps_tile_params->i4_first_ctb_y = 0; |
| |
| ps_tile_params->i4_first_sample_x = 0; |
| ps_tile_params->i4_first_sample_y = 0; |
| } |
| else |
| { |
| if(0 == ps_app_tile_prms->i4_uniform_spacing_flag) |
| { |
| /* curr tile width */ |
| ps_tile_params->i4_curr_tile_width = |
| ps_app_tile_prms->ai4_column_width[i4_curr_tile_id % i4_num_tile_cols]; |
| |
| /* curr tile height */ |
| ps_tile_params->i4_curr_tile_height = |
| ps_app_tile_prms->ai4_row_height[i4_curr_tile_id / i4_num_tile_cols]; |
| |
| /* ctb_x and ctb_y of first ctb in tile */ |
| i4_pos = i4_curr_tile_id % i4_num_tile_cols; |
| |
| for(i4_i = 0; i4_i < i4_pos; i4_i++) |
| { |
| i4_x_y += ps_app_tile_prms->ai4_column_width[i4_i]; |
| } |
| |
| ps_tile_params->i4_first_sample_x = i4_x_y; |
| ps_tile_params->i4_first_ctb_x = i4_x_y >> i4_max_log2_cu_size; |
| |
| i4_pos = i4_curr_tile_id / i4_num_tile_cols; |
| |
| i4_x_y = 0; |
| |
| for(i4_i = 0; i4_i < i4_pos; i4_i++) |
| { |
| i4_x_y += ps_app_tile_prms->ai4_row_height[i4_i]; |
| } |
| |
| ps_tile_params->i4_first_sample_y = i4_x_y; |
| ps_tile_params->i4_first_ctb_y = i4_x_y >> i4_max_log2_cu_size; |
| } |
| else |
| { |
| /* below formula for tile width/height and start_x/start_y are derived from HM Decoder */ |
| WORD32 i4_start = 0; |
| WORD32 i4_value = 0; |
| /* curr tile width */ |
| for(i4_i = 0; i4_i < i4_num_tile_cols; i4_i++) |
| { |
| i4_value = ((i4_i + 1) * i4_pic_wd_in_ctb) / i4_num_tile_cols - |
| (i4_i * i4_pic_wd_in_ctb) / i4_num_tile_cols; |
| |
| if(i4_i == (i4_curr_tile_id % i4_num_tile_cols)) |
| { |
| ps_tile_params->i4_first_ctb_x = i4_start; |
| ps_tile_params->i4_first_sample_x = (i4_start << i4_max_log2_cu_size); |
| ps_tile_params->i4_curr_tile_width = (i4_value << i4_max_log2_cu_size); |
| if(i4_i == (i4_num_tile_cols - 1)) |
| { |
| if(i4_cu_aligned_tgt_frame_wd % i4_ctb_size) |
| { |
| ps_tile_params->i4_curr_tile_width = |
| (ps_tile_params->i4_curr_tile_width - i4_ctb_size) + |
| (i4_cu_aligned_tgt_frame_wd % i4_ctb_size); |
| } |
| } |
| break; |
| } |
| i4_start += i4_value; |
| } |
| |
| /* curr tile height */ |
| i4_start = 0; |
| for(i4_i = 0; i4_i < i4_num_tile_rows; i4_i++) |
| { |
| i4_value = ((i4_i + 1) * i4_pic_ht_in_ctb) / i4_num_tile_rows - |
| (i4_i * i4_pic_ht_in_ctb) / i4_num_tile_rows; |
| |
| if(i4_i == (i4_curr_tile_id / i4_num_tile_cols)) |
| { |
| ps_tile_params->i4_first_ctb_y = i4_start; |
| ps_tile_params->i4_first_sample_y = (i4_start << i4_max_log2_cu_size); |
| ps_tile_params->i4_curr_tile_height = (i4_value << i4_max_log2_cu_size); |
| if(i4_i == (i4_num_tile_rows - 1)) |
| { |
| if(i4_cu_aligned_tgt_frame_ht % i4_ctb_size) |
| { |
| ps_tile_params->i4_curr_tile_height = |
| (ps_tile_params->i4_curr_tile_height - i4_ctb_size) + |
| (i4_cu_aligned_tgt_frame_ht % i4_ctb_size); |
| } |
| } |
| break; |
| } |
| i4_start += i4_value; |
| } |
| } |
| } |
| |
| /* Initiallize i4_curr_tile_wd_in_ctb_unit and i4_curr_tile_ht_in_ctb_unit */ |
| ps_tile_params->i4_curr_tile_wd_in_ctb_unit = |
| ps_tile_params->i4_curr_tile_width + |
| SET_CTB_ALIGN(ps_tile_params->i4_curr_tile_width, i4_ctb_size); |
| |
| ps_tile_params->i4_curr_tile_ht_in_ctb_unit = |
| ps_tile_params->i4_curr_tile_height + |
| SET_CTB_ALIGN(ps_tile_params->i4_curr_tile_height, i4_ctb_size); |
| |
| ps_tile_params->i4_curr_tile_wd_in_ctb_unit /= i4_ctb_size; |
| ps_tile_params->i4_curr_tile_ht_in_ctb_unit /= i4_ctb_size; |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_tiles_get_num_mem_recs \endif |
| * |
| * \brief |
| * Returns the total no. of memory records needed for tile encoding |
| * |
| * \param |
| * None |
| * |
| * \return |
| * total no. of memory required |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| WORD32 ihevce_tiles_get_num_mem_recs(void) |
| { |
| WORD32 i4_total_memtabs_req = 0; |
| |
| /*------------------------------------------------------------------*/ |
| /* Get number of memtabs */ |
| /*------------------------------------------------------------------*/ |
| /* Memory for keeping all tile's parameters */ |
| i4_total_memtabs_req++; |
| |
| /* Memory for keeping frame level tile_id map */ |
| i4_total_memtabs_req++; |
| |
| return (i4_total_memtabs_req); |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_tiles_get_mem_recs \endif |
| * |
| * \brief |
| * Fills each memory record attributes of tiles |
| * |
| * \param[in,out] ps_mem_tab : pointer to memory descriptors table |
| * \param[in] ps_tile_master_prms : master tile params |
| * \param[in] i4_mem_space : memspace in whihc memory request should be done |
| * |
| * \return |
| * total no. of mem records filled |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| WORD32 ihevce_tiles_get_mem_recs( |
| iv_mem_rec_t *ps_memtab, |
| ihevce_static_cfg_params_t *ps_static_cfg_params, |
| frm_ctb_ctxt_t *ps_frm_ctb_prms, |
| WORD32 i4_resolution_id, |
| WORD32 i4_mem_space) |
| { |
| //WORD32 i4_frame_width, i4_frame_height; |
| WORD32 i4_num_tiles; |
| WORD32 i4_total_memtabs_filled = 0; |
| WORD32 i4_num_tile_cols = 1; |
| WORD32 i4_num_tile_rows = 1; |
| WORD32 ctb_aligned_frame_width, ctb_aligned_frame_height; |
| WORD32 u4_ctb_in_a_row, u4_ctb_rows_in_a_frame; |
| |
| ihevce_app_tile_params_t *ps_app_tile_params = &ps_static_cfg_params->s_app_tile_params; |
| /* |
| i4_frame_width = ps_tile_master_prms->i4_frame_width; |
| i4_frame_height = ps_tile_master_prms->i4_frame_height;*/ |
| |
| if(1 == ps_app_tile_params->i4_tiles_enabled_flag) |
| { |
| i4_num_tile_cols = ps_app_tile_params->i4_num_tile_cols; |
| i4_num_tile_rows = ps_app_tile_params->i4_num_tile_rows; |
| } |
| |
| i4_num_tiles = i4_num_tile_cols * i4_num_tile_rows; |
| |
| /* -------- Memory for storing all tile params ---------*/ |
| ps_memtab[0].i4_size = sizeof(iv_mem_rec_t); |
| ps_memtab[0].i4_mem_size = i4_num_tiles * sizeof(ihevce_tile_params_t); |
| ps_memtab[0].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space; |
| ps_memtab[0].i4_mem_alignment = 8; |
| i4_total_memtabs_filled++; |
| |
| /* -------- Memory for CTB level tile-id map ---------*/ |
| ctb_aligned_frame_width = |
| ps_static_cfg_params->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width; |
| ctb_aligned_frame_height = |
| ps_static_cfg_params->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height; |
| |
| /*making the width and height a multiple of CTB size*/ |
| ctb_aligned_frame_width += SET_CTB_ALIGN( |
| ps_static_cfg_params->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width, |
| MAX_CTB_SIZE); |
| ctb_aligned_frame_height += SET_CTB_ALIGN( |
| ps_static_cfg_params->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height, |
| MAX_CTB_SIZE); |
| |
| u4_ctb_in_a_row = (ctb_aligned_frame_width / MAX_CTB_SIZE); |
| u4_ctb_rows_in_a_frame = (ctb_aligned_frame_height / MAX_CTB_SIZE); |
| |
| ps_frm_ctb_prms->i4_tile_id_ctb_map_stride = (ctb_aligned_frame_width / MAX_CTB_SIZE); |
| |
| /* Memory for a frame level memory to store tile-id corresponding to each CTB of frame*/ |
| /* (u4_ctb_in_a_row + 1): Keeping an extra column on the left. Tile Id's will be set to -1 in it */ |
| /* (u4_ctb_rows_in_a_frame + 1): Keeping an extra column on the top. Tile Id's will be set to -1 in it */ |
| /* -1 -1 -1 -1 -1 -1 -1 ....... -1 -1 |
| -1 0 0 1 1 2 2 ....... M -1 |
| -1 0 0 1 1 2 2 ....... M -1 |
| .. .. .. .. .. .. .. ....... M -1 |
| .. .. .. .. .. .. .. ....... M -1 |
| -1 N N N+1 N+1 N+2 N+2 ....... N+M -1 |
| */ |
| ps_memtab[1].i4_size = sizeof(iv_mem_rec_t); |
| ps_memtab[1].i4_mem_size = |
| (1 + u4_ctb_in_a_row + 1) * (1 + u4_ctb_rows_in_a_frame) * sizeof(WORD32); |
| ps_memtab[1].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space; |
| ps_memtab[1].i4_mem_alignment = 8; |
| i4_total_memtabs_filled++; |
| |
| return (i4_total_memtabs_filled); |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_tiles_mem_init \endif |
| * |
| * \brief |
| * Initialization of shared buffer memories |
| * |
| * \param[in] ps_mem_tab : pointer to memory descriptors table |
| * \param[in] ps_tile_master_prms : master tile params |
| * |
| * \return |
| * None |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| void *ihevce_tiles_mem_init( |
| iv_mem_rec_t *ps_memtab, |
| ihevce_static_cfg_params_t *ps_static_cfg_prms, |
| enc_ctxt_t *ps_enc_ctxt, |
| WORD32 i4_resolution_id) |
| { |
| WORD32 i4_num_tiles, tile_ctr; |
| WORD32 ctb_row_ctr, ctb_col_ctr, i; |
| WORD32 tile_pos_x, tile_pos_y; |
| WORD32 tile_wd_in_ctb, tile_ht_in_ctb; |
| WORD32 *pi4_tile_id_map_temp, *pi4_tile_id_map_base; |
| WORD32 frame_width_in_ctb; |
| WORD32 i4_num_tile_cols = 1; |
| WORD32 i4_num_tile_rows = 1; |
| |
| ihevce_tile_params_t *ps_tile_params_base; |
| frm_ctb_ctxt_t *ps_frm_ctb_prms = &ps_enc_ctxt->s_frm_ctb_prms; |
| |
| if(1 == ps_static_cfg_prms->s_app_tile_params.i4_tiles_enabled_flag) |
| { |
| i4_num_tile_cols = ps_static_cfg_prms->s_app_tile_params.i4_num_tile_cols; |
| i4_num_tile_rows = ps_static_cfg_prms->s_app_tile_params.i4_num_tile_rows; |
| } |
| |
| frame_width_in_ctb = |
| ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width; |
| frame_width_in_ctb += SET_CTB_ALIGN(frame_width_in_ctb, MAX_CTB_SIZE); |
| frame_width_in_ctb /= MAX_CTB_SIZE; |
| |
| /* -------- Memory for storing all tile params ---------*/ |
| ps_tile_params_base = (ihevce_tile_params_t *)ps_memtab->pv_base; |
| ps_memtab++; |
| |
| i4_num_tiles = i4_num_tile_cols * i4_num_tile_rows; |
| |
| for(tile_ctr = 0; tile_ctr < i4_num_tiles; tile_ctr++) |
| { |
| WORD32 i4_i; |
| ihevce_tile_params_t *ps_tile_params = (ps_tile_params_base + tile_ctr); |
| |
| /* Setting default values */ |
| memset(ps_tile_params, 0, sizeof(ihevce_tile_params_t)); |
| |
| ps_tile_params->i4_curr_tile_id = tile_ctr; /* tile id */ |
| |
| /* update create time tile params in each encoder context */ |
| ihevce_update_tile_params(ps_static_cfg_prms, ps_tile_params, i4_resolution_id); |
| |
| if(0 == ps_static_cfg_prms->s_app_tile_params.i4_uniform_spacing_flag) |
| { |
| /* Storing column width array and row height array inro enc ctxt */ |
| for(i4_i = 0; i4_i < i4_num_tile_cols; i4_i++) |
| { |
| ps_enc_ctxt->ai4_column_width_array[i4_i] = |
| ps_static_cfg_prms->s_app_tile_params.ai4_column_width[i4_i]; |
| } |
| for(i4_i = 0; i4_i < i4_num_tile_rows; i4_i++) |
| { |
| ps_enc_ctxt->ai4_row_height_array[i4_i] = |
| ps_static_cfg_prms->s_app_tile_params.ai4_row_height[i4_i]; |
| } |
| } |
| } |
| |
| /* -------- Memory for CTB level tile-id map ---------*/ |
| pi4_tile_id_map_base = (WORD32 *)ps_memtab->pv_base; |
| |
| // An extra col and row at top, left and right aroun frame level memory. Is set to -1. |
| ps_frm_ctb_prms->i4_tile_id_ctb_map_stride = frame_width_in_ctb + 2; |
| ps_frm_ctb_prms->pi4_tile_id_map = |
| pi4_tile_id_map_base + ps_frm_ctb_prms->i4_tile_id_ctb_map_stride + 1; |
| ps_memtab++; |
| |
| /* Filling -1 in top row */ |
| for(i = 0; i < ps_frm_ctb_prms->i4_tile_id_ctb_map_stride; i++) |
| { |
| pi4_tile_id_map_base[i] = -1; |
| } |
| |
| /* Now creating tile-id map */ |
| for(tile_ctr = 0; tile_ctr < ps_tile_params_base->i4_num_tiles; tile_ctr++) |
| { |
| ihevce_tile_params_t *ps_tile_params = ps_tile_params_base + tile_ctr; |
| |
| tile_pos_x = ps_tile_params->i4_first_ctb_x; |
| tile_pos_y = ps_tile_params->i4_first_ctb_y; |
| tile_wd_in_ctb = ps_tile_params->i4_curr_tile_wd_in_ctb_unit; |
| tile_ht_in_ctb = ps_tile_params->i4_curr_tile_ht_in_ctb_unit; |
| |
| pi4_tile_id_map_temp = ps_frm_ctb_prms->pi4_tile_id_map + |
| tile_pos_y * ps_frm_ctb_prms->i4_tile_id_ctb_map_stride + tile_pos_x; |
| |
| for(ctb_row_ctr = 0; (ctb_row_ctr < tile_ht_in_ctb); ctb_row_ctr++) |
| { |
| if(tile_pos_x == 0) |
| { /* Filling -1 in left column */ |
| pi4_tile_id_map_temp[-1] = -1; |
| } |
| |
| for(ctb_col_ctr = 0; (ctb_col_ctr < tile_wd_in_ctb); ctb_col_ctr++) |
| { |
| pi4_tile_id_map_temp[ctb_col_ctr] = tile_ctr; |
| } |
| |
| if(frame_width_in_ctb == (tile_pos_x + tile_wd_in_ctb)) |
| { /* Filling -1 in right column */ |
| pi4_tile_id_map_temp[tile_wd_in_ctb] = -1; |
| } |
| |
| pi4_tile_id_map_temp += ps_frm_ctb_prms->i4_tile_id_ctb_map_stride; |
| } |
| } |
| |
| return (void *)ps_tile_params_base; |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : update_last_coded_cu_qp \endif |
| * |
| * \brief Update i1_last_cu_qp based on CTB's position in tile |
| * |
| * \param[in] pi1_top_last_cu_qp |
| * Pointer to the CTB row's Qp storage |
| * \param[in] i1_entropy_coding_sync_enabled_flag |
| * flag to indicate rate control mode |
| * \param[in] ps_frm_ctb_prms |
| * Frame ctb parameters |
| * \param[in] i1_frame_qp |
| * Frame qp |
| * \param[in] vert_ctr |
| * first CTB row of frame |
| * \param[in] ctb_ctr |
| * ct row count |
| * \param[out] pi1_last_cu_qp |
| * Qp of the last CU of previous CTB row |
| * |
| * \return |
| * None |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| void update_last_coded_cu_qp( |
| WORD8 *pi1_top_last_cu_qp, |
| WORD8 i1_entropy_coding_sync_enabled_flag, |
| frm_ctb_ctxt_t *ps_frm_ctb_prms, |
| WORD8 i1_frame_qp, |
| WORD32 vert_ctr, |
| WORD32 ctb_ctr, |
| WORD8 *pi1_last_cu_qp) |
| { |
| WORD32 i4_curr_ctb_tile_id, i4_left_ctb_tile_id, i4_top_ctb_tile_id; |
| WORD32 *pi4_tile_id_map_temp; |
| |
| pi4_tile_id_map_temp = ps_frm_ctb_prms->pi4_tile_id_map + |
| vert_ctr * ps_frm_ctb_prms->i4_tile_id_ctb_map_stride + ctb_ctr; |
| |
| i4_curr_ctb_tile_id = *(pi4_tile_id_map_temp); |
| i4_left_ctb_tile_id = *(pi4_tile_id_map_temp - 1); |
| i4_top_ctb_tile_id = *(pi4_tile_id_map_temp - ps_frm_ctb_prms->i4_tile_id_ctb_map_stride); |
| |
| if(i4_curr_ctb_tile_id == i4_left_ctb_tile_id) |
| { |
| return; |
| } |
| else if(i4_curr_ctb_tile_id != i4_top_ctb_tile_id) |
| { /* First CTB of tile */ |
| *pi1_last_cu_qp = i1_frame_qp; |
| } |
| else |
| { /* First CTB of CTB-row */ |
| if(1 == i1_entropy_coding_sync_enabled_flag) |
| { |
| *pi1_last_cu_qp = i1_frame_qp; |
| } |
| else |
| { |
| *pi1_last_cu_qp = *(pi1_top_last_cu_qp); |
| } |
| } |
| } |
