p71924506
/
aosp12
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
aosp12/external/libhevc/encoder/ihevce_tile_interface.c

626 lines
22 KiB
C
Raw Blame History

/******************************************************************************
*
* 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);
}
}
}
Reference in New Issue View Git Blame Copy Permalink