| /****************************************************************************** |
| * |
| * 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_encode_header.c |
| * |
| * @brief |
| * This file contains function definitions related to header encoding |
| * |
| * @author |
| * Ittiam |
| * |
| * List of Functions |
| * ihevce_generate_nal_unit_header |
| * ihevce_generate_when_profile_present |
| * ihevce_generate_profile_tier_level |
| * ihevce_short_term_ref_pic_set |
| * ihevce_generate_bit_rate_pic_rate_info |
| * ihevce_generate_aud |
| * ihevce_generate_eos |
| * ihevce_generate_vps |
| * ihevce_generate_sps |
| * ihevce_generate_pps |
| * ihevce_generate_slice_header |
| * ihevce_populate_vps |
| * ihevce_populate_sps |
| * ihevce_populate_pps |
| * ihevce_populate_slice_header |
| * ihevce_insert_entry_offset_slice_header |
| * |
| ****************************************************************************** |
| */ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| /* System include files */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <stdarg.h> |
| #include <math.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_macros.h" |
| #include "ihevc_debug.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 "ihevc_trans_tables.h" |
| #include "ihevc_trans_macros.h" |
| |
| #include "ihevce_defs.h" |
| #include "ihevce_lap_enc_structs.h" |
| #include "ihevce_multi_thrd_structs.h" |
| #include "ihevce_multi_thrd_funcs.h" |
| #include "ihevce_me_common_defs.h" |
| #include "ihevce_had_satd.h" |
| #include "ihevce_error_codes.h" |
| #include "ihevce_error_checks.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_global_tables.h" |
| #include "ihevce_encode_header.h" |
| #include "ihevce_encode_header_sei_vui.h" |
| #include "ihevce_trace.h" |
| |
| /*****************************************************************************/ |
| /* Constant Macros */ |
| /*****************************************************************************/ |
| #define CU_LEVEL_QP_LIMIT_8x8 3 |
| #define CU_LEVEL_QP_LIMIT_16x16 2 |
| #define CU_LEVEL_QP_LIMIT_32x32 1 |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generate nal unit header in the stream as per section 7.3.1.2 |
| * |
| * @par Description |
| * Inserts the nal type and temporal id plus 1 as per section 7.3.1.2 Nal unit |
| * header syntax |
| * |
| * @param[inout] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] nal_unit_type |
| * nal type to be inserted |
| * |
| * @param[in] temporal id |
| * temporal id to be inserted |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_nal_unit_header( |
| bitstrm_t *ps_bitstrm, WORD32 nal_unit_type, WORD32 nuh_temporal_id) |
| { |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| /* sanity checks */ |
| ASSERT((nal_unit_type >= 0) && (nal_unit_type < 64)); |
| ASSERT((nuh_temporal_id >= 0) && (nuh_temporal_id < 7)); |
| |
| /* forbidden_zero_bit + nal_unit_type */ |
| PUT_BITS( |
| ps_bitstrm, |
| nal_unit_type, |
| (1 + 6), /*extra 1 is for forbidden zero bit */ |
| return_status); |
| |
| /* nuh_reserved_zero_6bits */ |
| PUT_BITS(ps_bitstrm, 0, 6, return_status); |
| |
| /* nuh_temporal_id_plus1 */ |
| PUT_BITS(ps_bitstrm, (nuh_temporal_id + 1), 3, return_status); |
| |
| return (return_status); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates fields related to Profile, Tier and Level data. |
| * |
| * @par Description |
| * Generates fields related to Profile, Tier and Level data. |
| * Called when profile_present flag is 1 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_ptl |
| * pointer to structure containing Profile, Tier and Level data data |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| static WORD32 |
| ihevce_generate_when_profile_present(bitstrm_t *ps_bitstrm, profile_tier_lvl_t *ps_ptl) |
| { |
| WORD32 return_status = IHEVCE_SUCCESS; |
| WORD32 i; |
| |
| /* XXX_profile_space[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_profile_space, 2, return_status); |
| ENTROPY_TRACE("XXX_profile_space[]", ps_ptl->i1_profile_space); |
| |
| /* XXX_tier_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_tier_flag, 1, return_status); |
| ENTROPY_TRACE("XXX_tier_flag[]", ps_ptl->i1_tier_flag); |
| |
| /* XXX_profile_idc[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_profile_idc, 5, return_status); |
| ENTROPY_TRACE("XXX_profile_idc[]", ps_ptl->i1_profile_idc); |
| |
| for(i = 0; i < MAX_PROFILE_COMPATBLTY; i++) |
| { |
| /* XXX_profile_compatibility_flag[][j] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->ai1_profile_compatibility_flag[i], 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_profile_compatibility_flag[][j]", ps_ptl->ai1_profile_compatibility_flag[i]); |
| } |
| |
| /* XXX_progressive_source_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_progressive_source_flag, 1, return_status); |
| ENTROPY_TRACE("XXX_progressive_source_flag[]", ps_ptl->i1_general_progressive_source_flag); |
| |
| /* XXX_interlaced_source_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_interlaced_source_flag, 1, return_status); |
| ENTROPY_TRACE("XXX_interlaced_source_flag[]", ps_ptl->i1_general_interlaced_source_flag); |
| |
| /* XXX_non_packed_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_non_packed_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_non_packed_constraint_flag[]", ps_ptl->i1_general_non_packed_constraint_flag); |
| |
| /* XXX_frame_only_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_frame_only_constraint_flag, 1, return_status); |
| ENTROPY_TRACE("XXX_frame_only_constraint_flag[]", ps_ptl->i1_frame_only_constraint_flag); |
| |
| /* XXX_general_max_12bit_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_12bit_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_max_12bit_constraint_flag[]", ps_ptl->i1_general_max_12bit_constraint_flag); |
| |
| /* XXX_general_max_10bit_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_10bit_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_max_10bit_constraint_flag[]", ps_ptl->i1_general_max_10bit_constraint_flag); |
| |
| /* XXX_general_max_8bit_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_8bit_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_max_8bit_constraint_flag[]", ps_ptl->i1_general_max_8bit_constraint_flag); |
| |
| /* XXX_general_max_422chroma_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_422chroma_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_max_422chroma_constraint_flag[]", |
| ps_ptl->i1_general_max_422chroma_constraint_flag); |
| |
| /* XXX_general_max_420chroma_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_420chroma_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_max_420chroma_constraint_flag[]", |
| ps_ptl->i1_general_max_420chroma_constraint_flag); |
| |
| /* XXX_general_max_monochrome_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_max_monochrome_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_max_monochrome_constraint_flag[]", |
| ps_ptl->i1_general_max_monochrome_constraint_flag); |
| |
| /* XXX_general_intra_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_intra_constraint_flag, 1, return_status); |
| ENTROPY_TRACE("XXX_general_intra_constraint_flag[]", ps_ptl->i1_general_intra_constraint_flag); |
| |
| /* XXX_general_one_picture_only_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_one_picture_only_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_one_picture_only_constraint_flag[]", |
| ps_ptl->i1_general_one_picture_only_constraint_flag); |
| |
| /* XXX_general_lower_bit_rate_constraint_flag[] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->i1_general_lower_bit_rate_constraint_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "XXX_general_lower_bit_rate_constraint_flag[]", |
| ps_ptl->i1_general_lower_bit_rate_constraint_flag); |
| |
| /* XXX_reserved_zero_35bits[] */ |
| PUT_BITS(ps_bitstrm, 0, 16, return_status); |
| PUT_BITS(ps_bitstrm, 0, 16, return_status); |
| PUT_BITS(ps_bitstrm, 0, 3, return_status); |
| ENTROPY_TRACE("XXX_reserved_zero_35bits[]", 0); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates Profile, Tier and Level data |
| * |
| * @par Description |
| * Generates Profile, Tier and Level data as per Section 7.3.3 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_ptl |
| * pointer to structure containing Profile, Tier and Level data data |
| * |
| * @param[in] i1_profile_present_flag |
| * flag that indicates whether profile-related data is present |
| * |
| * @param[in] i1_vps_max_sub_layers_minus1 |
| * (Maximum number of sub_layers present) minus 1 |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| static WORD32 ihevce_generate_profile_tier_level( |
| bitstrm_t *ps_bitstrm, |
| profile_tier_lvl_info_t *ps_ptl, |
| WORD8 i1_profile_present_flag, |
| WORD8 i1_max_sub_layers_minus1) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| if(i1_profile_present_flag) |
| { |
| ihevce_generate_when_profile_present(ps_bitstrm, &ps_ptl->s_ptl_gen); |
| } |
| |
| /* general_level_idc */ |
| PUT_BITS(ps_bitstrm, ps_ptl->s_ptl_gen.u1_level_idc, 8, return_status); |
| ENTROPY_TRACE("general_level_idc", ps_ptl->s_ptl_gen.u1_level_idc); |
| |
| for(i = 0; i < i1_max_sub_layers_minus1; i++) |
| { |
| /* sub_layer_profile_present_flag[i] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->ai1_sub_layer_profile_present_flag[i], 1, return_status); |
| ENTROPY_TRACE( |
| "sub_layer_profile_present_flag[i]", ps_ptl->ai1_sub_layer_profile_present_flag[i]); |
| |
| /* sub_layer_level_present_flag[i] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->ai1_sub_layer_level_present_flag[i], 1, return_status); |
| ENTROPY_TRACE( |
| "sub_layer_level_present_flag[i]", ps_ptl->ai1_sub_layer_level_present_flag[i]); |
| } |
| |
| if(i1_max_sub_layers_minus1 > 0) |
| { |
| for(i = i1_max_sub_layers_minus1; i < 8; i++) |
| { |
| /* reserved_zero_2bits[i] */ |
| PUT_BITS(ps_bitstrm, 0, 2, return_status); |
| ENTROPY_TRACE("reserved_zero_2bits[i]", 0); |
| } |
| } |
| |
| for(i = 0; i < i1_max_sub_layers_minus1; i++) |
| { |
| if(ps_ptl->ai1_sub_layer_profile_present_flag[i]) |
| { |
| ihevce_generate_when_profile_present(ps_bitstrm, &ps_ptl->as_ptl_sub[i]); |
| } |
| |
| if(ps_ptl->ai1_sub_layer_level_present_flag[i]) //TEMPORALA_SCALABILITY CHANGES BUG_FIX |
| { |
| /* sub_layer_level_idc[i] */ |
| PUT_BITS(ps_bitstrm, ps_ptl->as_ptl_sub[i].u1_level_idc, 8, return_status); |
| ENTROPY_TRACE("sub_layer_level_idc[i]", ps_ptl->as_ptl_sub[i].u1_level_idc); |
| } |
| } |
| |
| return return_status; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * Generates short term reference picture set |
| * |
| * @par Description |
| * Generates short term reference picture set as per section 7.3.5.2. |
| * Can be called by either SPS or Slice header parsing modules. |
| * |
| * @param[in] ps_bitstrm |
| * Pointer to bitstream structure |
| * |
| * @param[out] ps_stref_picset_base |
| * Pointer to first short term ref pic set structure |
| * |
| * @param[in] num_short_term_ref_pic_sets |
| * Number of short term reference pic sets |
| * |
| * @param[in] idx |
| * Current short term ref pic set id |
| * |
| * @returns Error code from WORD32 |
| * |
| * |
| ******************************************************************************* |
| */ |
| static WORD32 ihevce_short_term_ref_pic_set( |
| bitstrm_t *ps_bitstrm, |
| stref_picset_t *ps_stref_picset_base, |
| WORD32 num_short_term_ref_pic_sets, |
| WORD32 idx, |
| WORD32 *pi4_NumPocTotalCurr) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| stref_picset_t *ps_stref_picset = ps_stref_picset_base + idx; |
| |
| (void)num_short_term_ref_pic_sets; |
| if(idx > 0) |
| { |
| /* inter_ref_pic_set_prediction_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_stref_picset->i1_inter_ref_pic_set_prediction_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "inter_ref_pic_set_prediction_flag", |
| ps_stref_picset->i1_inter_ref_pic_set_prediction_flag); |
| } |
| |
| /* This flag is assumed to be 0 for now */ |
| ASSERT(0 == ps_stref_picset->i1_inter_ref_pic_set_prediction_flag); |
| |
| /* num_negative_pics */ |
| PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->i1_num_neg_pics, return_status); |
| ENTROPY_TRACE("num_negative_pics", ps_stref_picset->i1_num_neg_pics); |
| |
| /* num_positive_pics */ |
| PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->i1_num_pos_pics, return_status); |
| ENTROPY_TRACE("num_positive_pics", ps_stref_picset->i1_num_pos_pics); |
| |
| for(i = 0; i < ps_stref_picset->i1_num_neg_pics; i++) |
| { |
| /* delta_poc_s0_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->ai2_delta_poc[i] - 1, return_status); |
| ENTROPY_TRACE("delta_poc_s0_minus1", ps_stref_picset->ai2_delta_poc[i] - 1); |
| |
| /* used_by_curr_pic_s0_flag */ |
| PUT_BITS(ps_bitstrm, ps_stref_picset->ai1_used[i], 1, return_status); |
| ENTROPY_TRACE("used_by_curr_pic_s0_flag", ps_stref_picset->ai1_used[i]); |
| /*get the num pocs used for cur pic*/ |
| if(ps_stref_picset->ai1_used[i]) |
| { |
| *pi4_NumPocTotalCurr += 1; |
| } |
| } |
| |
| for(; i < (ps_stref_picset->i1_num_pos_pics + ps_stref_picset->i1_num_neg_pics); i++) |
| { |
| /* delta_poc_s1_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_stref_picset->ai2_delta_poc[i] - 1, return_status); |
| ENTROPY_TRACE("delta_poc_s1_minus1", ps_stref_picset->ai2_delta_poc[i] - 1); |
| |
| /* used_by_curr_pic_s1_flag */ |
| PUT_BITS(ps_bitstrm, ps_stref_picset->ai1_used[i], 1, return_status); |
| ENTROPY_TRACE("used_by_curr_pic_s1_flag", ps_stref_picset->ai1_used[i]); |
| /*get the num pocs used for cur pic*/ |
| if(ps_stref_picset->ai1_used[i]) |
| { |
| *pi4_NumPocTotalCurr += 1; |
| } |
| } |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates ref pic list modification |
| * |
| * @par Description |
| * Generate ref pic list modification syntax as per Section 7.3.6.2 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_slice_hdr |
| * pointer to structure containing slice header |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| static WORD32 ref_pic_list_modification( |
| bitstrm_t *ps_bitstrm, slice_header_t *ps_slice_hdr, WORD32 i4_NumPocTotalCurr) |
| { |
| WORD32 return_status = IHEVCE_SUCCESS; |
| WORD32 i; |
| |
| /* ref_pic_list_modification_flag_l0 */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0, 1, return_status); |
| ENTROPY_TRACE( |
| "ref_pic_list_modification_flag_l0", |
| ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0); |
| |
| if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0) |
| { |
| for(i = 0; i <= (ps_slice_hdr->i1_num_ref_idx_l0_active - 1); i++) |
| { |
| WORD32 num_bits = 32 - CLZ(i4_NumPocTotalCurr - 1); |
| |
| /* list_entry_l0[ i ] */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->s_rplm.i1_list_entry_l0[i], num_bits, return_status); |
| ENTROPY_TRACE("list_entry_l0", ps_slice_hdr->s_rplm.i1_list_entry_l0[i]); |
| } |
| } |
| |
| if((BSLICE == ps_slice_hdr->i1_slice_type)) |
| { |
| /* ref_pic_list_modification_flag_l1 */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1, 1, return_status); |
| ENTROPY_TRACE( |
| "ref_pic_list_modification_flag_l1", |
| ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1); |
| |
| if(ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1) |
| { |
| for(i = 0; i <= (ps_slice_hdr->i1_num_ref_idx_l1_active - 1); i++) |
| { |
| WORD32 num_bits = 32 - CLZ(i4_NumPocTotalCurr - 1); |
| |
| /* list_entry_l1[ i ] */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->s_rplm.i1_list_entry_l1[i], num_bits, return_status); |
| ENTROPY_TRACE("list_entry_l1", ps_slice_hdr->s_rplm.i1_list_entry_l1[i]); |
| } |
| } |
| } /*end of B slice check*/ |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates Pred Weight Table |
| * |
| * @par Description |
| * Generate Pred Weight Table as per Section 7.3.5.4 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_sps |
| * pointer to structure containing SPS data |
| * |
| * @param[in] ps_pps |
| * pointer to structure containing PPS data |
| * |
| * @param[in] ps_slice_hdr |
| * pointer to structure containing slice header |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| static WORD32 ihevce_generate_pred_weight_table( |
| bitstrm_t *ps_bitstrm, sps_t *ps_sps, pps_t *ps_pps, slice_header_t *ps_slice_hdr) |
| { |
| WORD32 i; |
| WORD32 delta_luma_weight; |
| WORD32 delta_chroma_weight; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| pred_wt_ofst_t *ps_wt_ofst = &ps_slice_hdr->s_wt_ofst; |
| UWORD32 u4_luma_log2_weight_denom = ps_wt_ofst->i1_luma_log2_weight_denom; |
| WORD32 chroma_log2_weight_denom = (ps_wt_ofst->i1_chroma_log2_weight_denom); |
| WORD32 i4_wght_count = 0; |
| |
| (void)ps_pps; |
| /* luma_log2_weight_denom */ |
| PUT_BITS_UEV(ps_bitstrm, u4_luma_log2_weight_denom, return_status); |
| ENTROPY_TRACE("luma_log2_weight_denom", u4_luma_log2_weight_denom); |
| |
| if(ps_sps->i1_chroma_format_idc != 0) |
| { |
| /* delta_chroma_log2_weight_denom */ |
| PUT_BITS_SEV( |
| ps_bitstrm, chroma_log2_weight_denom - u4_luma_log2_weight_denom, return_status); |
| ENTROPY_TRACE( |
| "delta_chroma_log2_weight_denom", chroma_log2_weight_denom - u4_luma_log2_weight_denom); |
| } |
| |
| for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) |
| { |
| /* luma_weight_l0_flag[ i ] */ |
| PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_luma_weight_l0_flag[i], 1, return_status); |
| i4_wght_count += ps_wt_ofst->i1_luma_weight_l0_flag[i]; |
| assert(i4_wght_count <= 24); |
| ENTROPY_TRACE("luma_weight_l0_flag[ i ]", ps_wt_ofst->i1_luma_weight_l0_flag[i]); |
| } |
| |
| if(ps_sps->i1_chroma_format_idc != 0) |
| { |
| for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) |
| { |
| /* chroma_weight_l0_flag[ i ] */ |
| PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_chroma_weight_l0_flag[i], 1, return_status); |
| i4_wght_count += 2 * ps_wt_ofst->i1_chroma_weight_l0_flag[i]; |
| assert(i4_wght_count <= 24); |
| ENTROPY_TRACE("chroma_weight_l0_flag[ i ]", ps_wt_ofst->i1_chroma_weight_l0_flag[i]); |
| } |
| } |
| |
| delta_luma_weight = (1 << u4_luma_log2_weight_denom); |
| delta_chroma_weight = (1 << chroma_log2_weight_denom); |
| |
| for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l0_active; i++) |
| { |
| if(ps_wt_ofst->i1_luma_weight_l0_flag[i]) |
| { |
| /* delta_luma_weight_l0[ i ] */ |
| PUT_BITS_SEV( |
| ps_bitstrm, ps_wt_ofst->i2_luma_weight_l0[i] - delta_luma_weight, return_status); |
| ENTROPY_TRACE( |
| "delta_luma_weight_l0[ i ]", ps_wt_ofst->i2_luma_weight_l0[i] - delta_luma_weight); |
| |
| /* luma_offset_l0[ i ] */ |
| PUT_BITS_SEV(ps_bitstrm, ps_wt_ofst->i2_luma_offset_l0[i], return_status); |
| ENTROPY_TRACE("luma_offset_l0[ i ]", ps_wt_ofst->i2_luma_offset_l0[i]); |
| } |
| |
| if(ps_wt_ofst->i1_chroma_weight_l0_flag[i]) |
| { |
| WORD32 shift = (1 << (BIT_DEPTH_CHROMA - 1)); |
| WORD32 delta_chroma_weight_l0[2]; |
| WORD32 delta_chroma_offset_l0[2]; |
| |
| delta_chroma_weight_l0[0] = ps_wt_ofst->i2_chroma_weight_l0_cb[i] - delta_chroma_weight; |
| delta_chroma_weight_l0[1] = ps_wt_ofst->i2_chroma_weight_l0_cr[i] - delta_chroma_weight; |
| |
| delta_chroma_offset_l0[0] = |
| ps_wt_ofst->i2_chroma_offset_l0_cb[i] + |
| ((shift * ps_wt_ofst->i2_chroma_weight_l0_cb[i]) >> chroma_log2_weight_denom) - |
| shift; |
| delta_chroma_offset_l0[1] = |
| ps_wt_ofst->i2_chroma_offset_l0_cr[i] + |
| ((shift * ps_wt_ofst->i2_chroma_weight_l0_cr[i]) >> chroma_log2_weight_denom) - |
| shift; |
| |
| /* delta_chroma_weight_l0[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l0[0], return_status); |
| ENTROPY_TRACE("delta_chroma_weight_l0[ i ]", delta_chroma_weight_l0[0]); |
| |
| /* delta_chroma_offset_l0[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l0[0], return_status); |
| ENTROPY_TRACE("delta_chroma_offset_l0[ i ]", delta_chroma_offset_l0[0]); |
| |
| /* delta_chroma_weight_l0[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l0[1], return_status); |
| ENTROPY_TRACE("delta_chroma_weight_l0[ i ]", delta_chroma_weight_l0[1]); |
| |
| /* delta_chroma_offset_l0[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l0[1], return_status); |
| ENTROPY_TRACE("delta_chroma_offset_l0[ i ]", delta_chroma_offset_l0[1]); |
| } |
| } |
| |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) |
| { |
| /* luma_weight_l1_flag[ i ] */ |
| PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_luma_weight_l1_flag[i], 1, return_status); |
| i4_wght_count += ps_wt_ofst->i1_luma_weight_l1_flag[i]; |
| assert(i4_wght_count <= 24); |
| ENTROPY_TRACE("luma_weight_l1_flag[ i ]", ps_wt_ofst->i1_luma_weight_l1_flag[i]); |
| } |
| |
| if(ps_sps->i1_chroma_format_idc != 0) |
| { |
| for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) |
| { |
| /* chroma_weight_l1_flag[ i ] */ |
| PUT_BITS(ps_bitstrm, ps_wt_ofst->i1_chroma_weight_l1_flag[i], 1, return_status); |
| i4_wght_count += ps_wt_ofst->i1_chroma_weight_l1_flag[i]; |
| assert(i4_wght_count <= 24); |
| ENTROPY_TRACE( |
| "chroma_weight_l1_flag[ i ]", ps_wt_ofst->i1_chroma_weight_l1_flag[i]); |
| } |
| } |
| |
| for(i = 0; i < ps_slice_hdr->i1_num_ref_idx_l1_active; i++) |
| { |
| if(ps_wt_ofst->i1_luma_weight_l1_flag[i]) |
| { |
| /* delta_luma_weight_l1[ i ] */ |
| PUT_BITS_SEV( |
| ps_bitstrm, |
| ps_wt_ofst->i2_luma_weight_l1[i] - delta_luma_weight, |
| return_status); |
| ENTROPY_TRACE( |
| "delta_luma_weight_l1[ i ]", |
| ps_wt_ofst->i2_luma_weight_l1[i] - delta_luma_weight); |
| |
| /* luma_offset_l1[ i ] */ |
| PUT_BITS_SEV(ps_bitstrm, ps_wt_ofst->i2_luma_offset_l1[i], return_status); |
| ENTROPY_TRACE("luma_offset_l1[ i ]", ps_wt_ofst->i2_luma_offset_l1[i]); |
| } |
| |
| if(ps_wt_ofst->i1_chroma_weight_l1_flag[i]) |
| { |
| WORD32 shift = (1 << (BIT_DEPTH_CHROMA - 1)); |
| WORD32 delta_chroma_weight_l1[2]; |
| WORD32 delta_chroma_offset_l1[2]; |
| |
| delta_chroma_weight_l1[0] = |
| ps_wt_ofst->i2_chroma_weight_l1_cb[i] - delta_chroma_weight; |
| delta_chroma_weight_l1[1] = |
| ps_wt_ofst->i2_chroma_weight_l1_cr[i] - delta_chroma_weight; |
| |
| delta_chroma_offset_l1[0] = |
| ps_wt_ofst->i2_chroma_offset_l1_cb[i] + |
| ((shift * ps_wt_ofst->i2_chroma_weight_l1_cb[i]) >> chroma_log2_weight_denom) - |
| shift; |
| delta_chroma_offset_l1[1] = |
| ps_wt_ofst->i2_chroma_offset_l1_cr[i] + |
| ((shift * ps_wt_ofst->i2_chroma_weight_l1_cr[i]) >> chroma_log2_weight_denom) - |
| shift; |
| |
| /* delta_chroma_weight_l1[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l1[0], return_status); |
| ENTROPY_TRACE("delta_chroma_weight_l1[ i ]", delta_chroma_weight_l1[0]); |
| |
| /* delta_chroma_offset_l1[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l1[0], return_status); |
| ENTROPY_TRACE("delta_chroma_offset_l1[ i ]", delta_chroma_offset_l1[0]); |
| |
| /* delta_chroma_weight_l1[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_weight_l1[1], return_status); |
| ENTROPY_TRACE("delta_chroma_weight_l1[ i ]", delta_chroma_weight_l1[1]); |
| |
| /* delta_chroma_offset_l1[ i ][j] */ |
| PUT_BITS_SEV(ps_bitstrm, delta_chroma_offset_l1[1], return_status); |
| ENTROPY_TRACE("delta_chroma_offset_l1[ i ]", delta_chroma_offset_l1[1]); |
| } |
| } |
| } |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates AUD (Access Unit Delimiter) |
| * |
| * @par Description |
| * Generate Access Unit Delimiter as per Section 7.3.2.5 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] pic_type |
| * picture type |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_aud(bitstrm_t *ps_bitstrm, WORD32 pic_type) |
| { |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| /* Insert the NAL start code */ |
| return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); |
| |
| /* Insert Nal Unit Header */ |
| return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_AUD, 0); |
| |
| /* pic_type */ |
| PUT_BITS(ps_bitstrm, pic_type, 3, return_status); |
| ENTROPY_TRACE("pic type", pic_type); |
| |
| ihevce_put_rbsp_trailing_bits(ps_bitstrm); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates EOS (End of Sequence) |
| * |
| * @par Description |
| * Generate End of sequence as per Section 7.3.2.6 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_eos(bitstrm_t *ps_bitstrm) |
| { |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| /* Insert the NAL start code */ |
| return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); |
| |
| /* Insert Nal Unit Header */ |
| return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_EOS, 0); |
| |
| ihevce_put_rbsp_trailing_bits(ps_bitstrm); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates VPS (Video Parameter Set) |
| * |
| * @par Description |
| * Generate Video Parameter Set as per Section 7.3.2.1 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_vps |
| * pointer to structure containing VPS data |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_vps(bitstrm_t *ps_bitstrm, vps_t *ps_vps) |
| { |
| WORD32 i; |
| WORD8 i1_vps_max_sub_layers_minus1 = ps_vps->i1_vps_max_sub_layers - 1; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| /* Insert Start Code */ |
| ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); |
| |
| /* Insert Nal Unit Header */ |
| ihevce_generate_nal_unit_header(ps_bitstrm, NAL_VPS, 0); |
| |
| /* video_parameter_set_id */ |
| PUT_BITS(ps_bitstrm, ps_vps->i1_vps_id, 4, return_status); |
| ENTROPY_TRACE("video_parameter_set_id", ps_vps->i1_vps_id); |
| |
| /* vps_reserved_three_2bits */ |
| PUT_BITS(ps_bitstrm, 3, 2, return_status); |
| ENTROPY_TRACE("vps_reserved_three_2bits", 3); |
| |
| /* vps_max_layers_minus1 */ |
| PUT_BITS(ps_bitstrm, 0, 6, return_status); |
| ENTROPY_TRACE("vps_max_layers_minus1 ", 3); |
| |
| /* vps_max_sub_layers_minus1 */ |
| PUT_BITS(ps_bitstrm, i1_vps_max_sub_layers_minus1, 3, return_status); |
| ENTROPY_TRACE("vps_max_sub_layers_minus1", i1_vps_max_sub_layers_minus1); |
| |
| /* vps_temporal_id_nesting_flag */ |
| PUT_BITS(ps_bitstrm, ps_vps->i1_vps_temporal_id_nesting_flag, 1, return_status); |
| ENTROPY_TRACE("vps_temporal_id_nesting_flag", ps_vps->i1_vps_temporal_id_nesting_flag); |
| |
| /* vps_reserved_0xffff_16bits */ |
| PUT_BITS(ps_bitstrm, 0xffff, 16, return_status); |
| ENTROPY_TRACE("vps_reserved_0xffff_16bits", 0xffff); |
| |
| /* profile-tier and level info */ |
| ihevce_generate_profile_tier_level(ps_bitstrm, &ps_vps->s_ptl, 1, i1_vps_max_sub_layers_minus1); |
| |
| /* vps_sub_layer_ordering_info_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_vps->i1_sub_layer_ordering_info_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "vps_sub_layer_ordering_info_present_flag", |
| ps_vps->i1_sub_layer_ordering_info_present_flag); |
| |
| i = ps_vps->i1_sub_layer_ordering_info_present_flag ? 0 : i1_vps_max_sub_layers_minus1; |
| |
| for(; i <= i1_vps_max_sub_layers_minus1; i++) |
| { |
| /* vps_max_dec_pic_buffering[i] */ |
| PUT_BITS_UEV(ps_bitstrm, ps_vps->ai1_vps_max_dec_pic_buffering[i], return_status); |
| ENTROPY_TRACE( |
| "vps_max_dec_pic_buffering_minus1[i]", ps_vps->ai1_vps_max_dec_pic_buffering[i]); |
| |
| /* vps_num_reorder_pics[i] */ |
| PUT_BITS_UEV(ps_bitstrm, ps_vps->ai1_vps_max_num_reorder_pics[i], return_status); |
| ENTROPY_TRACE("ai1_vps_max_num_reorder_pics[i]", ps_vps->ai1_vps_max_num_reorder_pics[i]); |
| |
| /* vps_max_latency_increase[i] */ |
| PUT_BITS_UEV(ps_bitstrm, ps_vps->ai1_vps_max_latency_increase[i], return_status); |
| ENTROPY_TRACE("ai1_vps_max_latency_increase[i]", ps_vps->ai1_vps_max_latency_increase[i]); |
| } |
| |
| /* vps_max_layer_id */ |
| PUT_BITS(ps_bitstrm, ps_vps->i1_vps_max_nuh_reserved_zero_layer_id, 6, return_status); |
| ENTROPY_TRACE("vps_max_layer_id", ps_vps->i1_vps_max_nuh_reserved_zero_layer_id); |
| |
| /* vps_num_layer_sets_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, 0, return_status); |
| ENTROPY_TRACE("vps_num_layer_sets_minus1", 0); |
| |
| /* vps_timing_info_present_flag */ |
| PUT_BITS(ps_bitstrm, 0, 1, return_status); |
| ENTROPY_TRACE("vps_timing_info_present_flag", 0); |
| |
| /* vps_extension_flag */ |
| PUT_BITS(ps_bitstrm, 0, 1, return_status); |
| ENTROPY_TRACE("vps_extension_flag", 0); |
| |
| /* rbsp trailing bits */ |
| ihevce_put_rbsp_trailing_bits(ps_bitstrm); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates SPS (Video Parameter Set) |
| * |
| * @par Description |
| * Parse Video Parameter Set as per Section 7.3.2.2 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_sps |
| * pointer to structure containing SPS data |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_sps(bitstrm_t *ps_bitstrm, sps_t *ps_sps) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| WORD8 i1_max_sub_layers_minus1 = ps_sps->i1_sps_max_sub_layers - 1; |
| |
| UWORD32 u4_log2_max_pic_order_cnt_lsb = (UWORD32)(ps_sps->i1_log2_max_pic_order_cnt_lsb); |
| |
| UWORD32 u4_log2_min_coding_block_size_minus3 = |
| (UWORD32)(ps_sps->i1_log2_min_coding_block_size) - 3; |
| |
| UWORD32 u4_log2_diff_max_min_coding_block_size = |
| (UWORD32)(ps_sps->i1_log2_diff_max_min_coding_block_size); |
| |
| UWORD32 u4_log2_min_transform_block_size_minus2 = |
| (UWORD32)(ps_sps->i1_log2_min_transform_block_size) - 2; |
| |
| UWORD32 u4_log2_diff_max_min_transform_block_size = |
| (UWORD32)(ps_sps->i1_log2_diff_max_min_transform_block_size); |
| |
| /* Insert Start Code */ |
| return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); |
| |
| /* Insert Nal Unit Header */ |
| return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_SPS, 0); |
| |
| /* video_parameter_set_id */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_vps_id, 4, return_status); |
| ENTROPY_TRACE("video_parameter_set_id", ps_sps->i1_vps_id); |
| |
| /* sps_max_sub_layers_minus1 */ |
| PUT_BITS(ps_bitstrm, i1_max_sub_layers_minus1, 3, return_status); |
| ENTROPY_TRACE("sps_max_sub_layers_minus1", i1_max_sub_layers_minus1); |
| |
| /* sps_temporal_id_nesting_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_sps_temporal_id_nesting_flag, 1, return_status); |
| ENTROPY_TRACE("sps_temporal_id_nesting_flag", ps_sps->i1_sps_temporal_id_nesting_flag); |
| |
| /* profile-tier and level info */ |
| ihevce_generate_profile_tier_level(ps_bitstrm, &ps_sps->s_ptl, 1, i1_max_sub_layers_minus1); |
| |
| /* seq_parameter_set_id */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_sps_id, return_status); |
| ENTROPY_TRACE("seq_parameter_set_id", ps_sps->i1_sps_id); |
| |
| /* chroma_format_idc */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_chroma_format_idc, return_status); |
| ENTROPY_TRACE("chroma_format_idc", ps_sps->i1_chroma_format_idc); |
| |
| if(CHROMA_FMT_IDC_YUV444 == ps_sps->i1_chroma_format_idc) |
| { |
| /* separate_colour_plane_flag */ |
| PUT_BITS(ps_bitstrm, 1, 1, return_status); |
| ENTROPY_TRACE("separate_colour_plane_flag", 1); |
| } |
| |
| /* pic_width_in_luma_samples */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_width_in_luma_samples, return_status); |
| ENTROPY_TRACE("pic_width_in_luma_samples", ps_sps->i2_pic_width_in_luma_samples); |
| |
| /* pic_height_in_luma_samples */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_height_in_luma_samples, return_status); |
| ENTROPY_TRACE("pic_height_in_luma_samples", ps_sps->i2_pic_height_in_luma_samples); |
| |
| /* pic_cropping_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_pic_cropping_flag, 1, return_status); |
| ENTROPY_TRACE("pic_cropping_flag", ps_sps->i1_pic_cropping_flag); |
| |
| if(ps_sps->i1_pic_cropping_flag) |
| { |
| /* pic_crop_left_offset */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_left_offset, return_status); |
| ENTROPY_TRACE("pic_crop_left_offset", ps_sps->i2_pic_crop_left_offset); |
| |
| /* pic_crop_right_offset */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_right_offset, return_status); |
| ENTROPY_TRACE("pic_crop_right_offset", ps_sps->i2_pic_crop_right_offset); |
| |
| /* pic_crop_top_offset */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_top_offset, return_status); |
| ENTROPY_TRACE("pic_crop_top_offset", ps_sps->i2_pic_crop_top_offset); |
| |
| /* pic_crop_bottom_offset */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i2_pic_crop_bottom_offset, return_status); |
| ENTROPY_TRACE("pic_crop_bottom_offset", ps_sps->i2_pic_crop_bottom_offset); |
| } |
| |
| /* bit_depth_luma_minus8 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_bit_depth_luma_minus8, return_status); |
| ENTROPY_TRACE("bit_depth_luma_minus8", ps_sps->i1_bit_depth_luma_minus8); |
| |
| /* bit_depth_chroma_minus8 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_bit_depth_chroma_minus8, return_status); |
| ENTROPY_TRACE("i1_bit_depth_chroma_minus8", ps_sps->i1_bit_depth_chroma_minus8); |
| |
| /* log2_max_pic_order_cnt_lsb_minus4 */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_max_pic_order_cnt_lsb - 4, return_status); |
| ENTROPY_TRACE("log2_max_pic_order_cnt_lsb_minus4", u4_log2_max_pic_order_cnt_lsb - 4); |
| |
| /* sps_sub_layer_ordering_info_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_sps_sub_layer_ordering_info_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "sps_sub_layer_ordering_info_present_flag", |
| ps_sps->i1_sps_sub_layer_ordering_info_present_flag); |
| |
| i = ps_sps->i1_sps_sub_layer_ordering_info_present_flag ? 0 : i1_max_sub_layers_minus1; |
| |
| for(; i <= i1_max_sub_layers_minus1; i++) |
| { |
| /* max_dec_pic_buffering */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->ai1_sps_max_dec_pic_buffering[i], return_status); |
| ENTROPY_TRACE("max_dec_pic_buffering_minus1", ps_sps->ai1_sps_max_dec_pic_buffering[i]); |
| |
| /* num_reorder_pics */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->ai1_sps_max_num_reorder_pics[i], return_status); |
| ENTROPY_TRACE("num_reorder_pics", ps_sps->ai1_sps_max_num_reorder_pics[i]); |
| |
| /* max_latency_increase */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->ai1_sps_max_latency_increase[i], return_status); |
| ENTROPY_TRACE("max_latency_increase", ps_sps->ai1_sps_max_latency_increase[i]); |
| } |
| |
| /* log2_min_coding_block_size_minus3 */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_min_coding_block_size_minus3, return_status); |
| ENTROPY_TRACE("log2_min_coding_block_size_minus3", u4_log2_min_coding_block_size_minus3); |
| |
| /* log2_diff_max_min_coding_block_size */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_diff_max_min_coding_block_size, return_status); |
| ENTROPY_TRACE("log2_diff_max_min_coding_block_size", u4_log2_diff_max_min_coding_block_size); |
| |
| /* log2_min_transform_block_size_minus2 */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_min_transform_block_size_minus2, return_status); |
| ENTROPY_TRACE("log2_min_transform_block_size_minus2", u4_log2_min_transform_block_size_minus2); |
| |
| /* log2_diff_max_min_transform_block_size */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_diff_max_min_transform_block_size, return_status); |
| ENTROPY_TRACE( |
| "log2_diff_max_min_transform_block_size", u4_log2_diff_max_min_transform_block_size); |
| |
| /* max_transform_hierarchy_depth_inter */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_max_transform_hierarchy_depth_inter, return_status); |
| ENTROPY_TRACE( |
| "max_transform_hierarchy_depth_inter", ps_sps->i1_max_transform_hierarchy_depth_inter); |
| |
| /* max_transform_hierarchy_depth_intra */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_max_transform_hierarchy_depth_intra, return_status); |
| ENTROPY_TRACE( |
| "max_transform_hierarchy_depth_intra", ps_sps->i1_max_transform_hierarchy_depth_intra); |
| |
| /* scaling_list_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_scaling_list_enable_flag, 1, return_status); |
| ENTROPY_TRACE("scaling_list_enabled_flag", ps_sps->i1_scaling_list_enable_flag); |
| |
| if(ps_sps->i1_scaling_list_enable_flag) |
| { |
| /* sps_scaling_list_data_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_sps_scaling_list_data_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "sps_scaling_list_data_present_flag", ps_sps->i1_sps_scaling_list_data_present_flag); |
| |
| #if 0 /* TODO: Will be enabled once scaling list support is added */ |
| if(ps_sps->i1_sps_scaling_list_data_present_flag) |
| { |
| //TODO |
| ihevce_generate_scaling_list_data(ps_bitstrm); |
| } |
| #endif |
| } |
| |
| /* asymmetric_motion_partitions_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_amp_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("asymmetric_motion_partitions_enabled_flag", ps_sps->i1_amp_enabled_flag); |
| |
| /* sample_adaptive_offset_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_sample_adaptive_offset_enabled_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "sample_adaptive_offset_enabled_flag", ps_sps->i1_sample_adaptive_offset_enabled_flag); |
| |
| /* pcm_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("pcm_enabled_flag", ps_sps->i1_pcm_enabled_flag); |
| if(ps_sps->i1_pcm_enabled_flag) |
| { |
| UWORD32 u4_log2_min_pcm_coding_block_size = (ps_sps->i1_log2_min_pcm_coding_block_size); |
| UWORD32 u4_log2_diff_max_min_pcm_coding_block_size = |
| (ps_sps->i1_log2_diff_max_min_pcm_coding_block_size); |
| |
| /* pcm_sample_bit_depth_luma_minus1 */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_sample_bit_depth_luma - 1, 4, return_status); |
| ENTROPY_TRACE("pcm_sample_bit_depth_luma", ps_sps->i1_pcm_sample_bit_depth_luma - 1); |
| |
| /* pcm_sample_bit_depth_chroma_minus1 */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_sample_bit_depth_chroma - 1, 4, return_status); |
| ENTROPY_TRACE("pcm_sample_bit_depth_chroma", ps_sps->i1_pcm_sample_bit_depth_chroma - 1); |
| |
| /* log2_min_pcm_coding_block_size_minus3 */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_min_pcm_coding_block_size - 3, return_status); |
| ENTROPY_TRACE( |
| "log2_min_pcm_coding_block_size_minus3", u4_log2_min_pcm_coding_block_size - 3); |
| |
| /* log2_diff_max_min_pcm_coding_block_size */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_diff_max_min_pcm_coding_block_size, return_status); |
| ENTROPY_TRACE( |
| "log2_diff_max_min_pcm_coding_block_size", u4_log2_diff_max_min_pcm_coding_block_size); |
| |
| /* pcm_loop_filter_disable_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_pcm_loop_filter_disable_flag, 1, return_status); |
| ENTROPY_TRACE("pcm_loop_filter_disable_flag", ps_sps->i1_pcm_loop_filter_disable_flag); |
| } |
| |
| /* num_short_term_ref_pic_sets */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_num_short_term_ref_pic_sets, return_status); |
| ENTROPY_TRACE("num_short_term_ref_pic_sets", ps_sps->i1_num_short_term_ref_pic_sets); |
| |
| for(i = 0; i < ps_sps->i1_num_short_term_ref_pic_sets; i++) |
| { |
| WORD32 i4_NumPocTotalCurr = 0; |
| ihevce_short_term_ref_pic_set( |
| ps_bitstrm, |
| &ps_sps->as_stref_picset[0], |
| ps_sps->i1_num_short_term_ref_pic_sets, |
| i, |
| &i4_NumPocTotalCurr); |
| } |
| |
| /* long_term_ref_pics_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_long_term_ref_pics_present_flag, 1, return_status); |
| ENTROPY_TRACE("long_term_ref_pics_present_flag", ps_sps->i1_long_term_ref_pics_present_flag); |
| |
| if(ps_sps->i1_long_term_ref_pics_present_flag) |
| { |
| /* num_long_term_ref_pics_sps */ |
| PUT_BITS_UEV(ps_bitstrm, ps_sps->i1_num_long_term_ref_pics_sps, return_status); |
| ENTROPY_TRACE("num_long_term_ref_pics_sps", ps_sps->i1_num_long_term_ref_pics_sps); |
| |
| for(i = 0; i < ps_sps->i1_num_long_term_ref_pics_sps; i++) |
| { |
| /* lt_ref_pic_poc_lsb_sps[i] */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_sps->au2_lt_ref_pic_poc_lsb_sps[i], |
| u4_log2_max_pic_order_cnt_lsb, |
| return_status); |
| ENTROPY_TRACE("lt_ref_pic_poc_lsb_sps[i]", ps_sps->au2_lt_ref_pic_poc_lsb_sps[i]); |
| |
| /* used_by_curr_pic_lt_sps_flag[i] */ |
| PUT_BITS(ps_bitstrm, ps_sps->ai1_used_by_curr_pic_lt_sps_flag[i], 1, return_status); |
| ENTROPY_TRACE( |
| "used_by_curr_pic_lt_sps_flag[i]", ps_sps->ai1_used_by_curr_pic_lt_sps_flag[i]); |
| } |
| } |
| |
| /* sps_temporal_mvp_enable_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_sps_temporal_mvp_enable_flag, 1, return_status); |
| ENTROPY_TRACE("sps_temporal_mvp_enable_flag", ps_sps->i1_sps_temporal_mvp_enable_flag); |
| |
| #if !HM_8DOT1_SYNTAX |
| /* strong_intra_smoothing_enable_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_strong_intra_smoothing_enable_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "sps_strong_intra_smoothing_enable_flag", ps_sps->i1_strong_intra_smoothing_enable_flag); |
| #endif |
| |
| /* vui_parameters_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_sps->i1_vui_parameters_present_flag, 1, return_status); |
| ENTROPY_TRACE("vui_parameters_present_flag", ps_sps->i1_vui_parameters_present_flag); |
| |
| ENTROPY_TRACE("----------- vui_parameters -----------", 0); |
| |
| if(ps_sps->i1_vui_parameters_present_flag) |
| { |
| /* Add vui parameters to the bitstream */ |
| ihevce_generate_vui(ps_bitstrm, ps_sps, ps_sps->s_vui_parameters); |
| } |
| |
| /* sps_extension_flag */ |
| PUT_BITS(ps_bitstrm, 0, 1, return_status); |
| ENTROPY_TRACE("sps_extension_flag", 0); |
| |
| /* rbsp trailing bits */ |
| ihevce_put_rbsp_trailing_bits(ps_bitstrm); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates PPS (Picture Parameter Set) |
| * |
| * @par Description |
| * Generate Picture Parameter Set as per Section 7.3.2.3 |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] ps_pps |
| * pointer to structure containing PPS data |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_pps(bitstrm_t *ps_bitstrm, pps_t *ps_pps) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| /* Insert the NAL start code */ |
| return_status = ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); |
| |
| /* Insert Nal Unit Header */ |
| return_status |= ihevce_generate_nal_unit_header(ps_bitstrm, NAL_PPS, 0); |
| |
| /* pic_parameter_set_id */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_pps_id, return_status); |
| ENTROPY_TRACE("pic_parameter_set_id", ps_pps->i1_pps_id); |
| |
| /* seq_parameter_set_id */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_sps_id, return_status); |
| ENTROPY_TRACE("seq_parameter_set_id", ps_pps->i1_sps_id); |
| |
| /* dependent_slices_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_dependent_slice_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("dependent_slices_enabled_flag", ps_pps->i1_dependent_slice_enabled_flag); |
| |
| /* output_flag_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_output_flag_present_flag, 1, return_status); |
| ENTROPY_TRACE("output_flag_present_flag", ps_pps->i1_output_flag_present_flag); |
| |
| /* num_extra_slice_header_bits */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_num_extra_slice_header_bits, 3, return_status); |
| ENTROPY_TRACE("num_extra_slice_header_bits", ps_pps->i1_num_extra_slice_header_bits); |
| |
| /* sign_data_hiding_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_sign_data_hiding_flag, 1, return_status); |
| ENTROPY_TRACE("sign_data_hiding_flag", ps_pps->i1_sign_data_hiding_flag); |
| |
| /* cabac_init_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_cabac_init_present_flag, 1, return_status); |
| ENTROPY_TRACE("cabac_init_present_flag", ps_pps->i1_cabac_init_present_flag); |
| |
| /* num_ref_idx_l0_default_active_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_ref_idx_l0_default_active - 1, return_status); |
| ENTROPY_TRACE( |
| "num_ref_idx_l0_default_active_minus1", ps_pps->i1_num_ref_idx_l0_default_active - 1); |
| |
| /* num_ref_idx_l1_default_active_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_ref_idx_l1_default_active - 1, return_status); |
| ENTROPY_TRACE( |
| "num_ref_idx_l1_default_active_minus1", ps_pps->i1_num_ref_idx_l1_default_active - 1); |
| |
| /* pic_init_qp_minus26 */ |
| PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_init_qp - 26, return_status); |
| ENTROPY_TRACE("pic_init_qp_minus26", ps_pps->i1_pic_init_qp - 26); |
| |
| /* constrained_intra_pred_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_constrained_intra_pred_flag, 1, return_status); |
| ENTROPY_TRACE("constrained_intra_pred_flag", ps_pps->i1_constrained_intra_pred_flag); |
| |
| /* transform_skip_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_transform_skip_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("transform_skip_enabled_flag", ps_pps->i1_transform_skip_enabled_flag); |
| |
| /* cu_qp_delta_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_cu_qp_delta_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("cu_qp_delta_enabled_flag", ps_pps->i1_cu_qp_delta_enabled_flag); |
| |
| if(ps_pps->i1_cu_qp_delta_enabled_flag) |
| { |
| /* diff_cu_qp_delta_depth */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_diff_cu_qp_delta_depth, return_status); |
| ENTROPY_TRACE("diff_cu_qp_delta_depth", ps_pps->i1_diff_cu_qp_delta_depth); |
| } |
| |
| /* cb_qp_offset */ |
| PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_cb_qp_offset, return_status); |
| ENTROPY_TRACE("cb_qp_offset", ps_pps->i1_pic_cb_qp_offset); |
| |
| /* cr_qp_offset */ |
| PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_pic_cr_qp_offset, return_status); |
| ENTROPY_TRACE("cr_qp_offset", ps_pps->i1_pic_cr_qp_offset); |
| |
| /* slicelevel_chroma_qp_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "slicelevel_chroma_qp_flag", ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag); |
| |
| /* weighted_pred_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_weighted_pred_flag, 1, return_status); |
| ENTROPY_TRACE("weighted_pred_flag", ps_pps->i1_weighted_pred_flag); |
| |
| /* weighted_bipred_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_weighted_bipred_flag, 1, return_status); |
| ENTROPY_TRACE("weighted_bipred_flag", ps_pps->i1_weighted_bipred_flag); |
| |
| /* transquant_bypass_enable_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_transquant_bypass_enable_flag, 1, return_status); |
| ENTROPY_TRACE("transquant_bypass_enable_flag", ps_pps->i1_transquant_bypass_enable_flag); |
| |
| /* tiles_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_tiles_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("tiles_enabled_flag", ps_pps->i1_tiles_enabled_flag); |
| |
| /* entropy_coding_sync_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_entropy_coding_sync_enabled_flag, 1, return_status); |
| ENTROPY_TRACE("entropy_coding_sync_enabled_flag", ps_pps->i1_entropy_coding_sync_enabled_flag); |
| |
| if(ps_pps->i1_tiles_enabled_flag) |
| { |
| /* num_tile_columns_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_tile_columns - 1, return_status); |
| ENTROPY_TRACE("num_tile_columns_minus1", ps_pps->i1_num_tile_columns - 1); |
| |
| /* num_tile_rows_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->i1_num_tile_rows - 1, return_status); |
| ENTROPY_TRACE("num_tile_rows_minus1", ps_pps->i1_num_tile_rows - 1); |
| |
| /* uniform_spacing_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_uniform_spacing_flag, 1, return_status); |
| ENTROPY_TRACE("uniform_spacing_flag", ps_pps->i1_uniform_spacing_flag); |
| |
| if(!ps_pps->i1_uniform_spacing_flag) |
| { |
| for(i = 0; i < ps_pps->i1_num_tile_columns - 1; i++) |
| { |
| /* column_width_minus1[i] */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->ps_tile[i].u2_wd - 1, return_status); |
| ENTROPY_TRACE("column_width_minus1[i]", ps_pps->ps_tile[i].u2_wd - 1); |
| } |
| for(i = 0; i < ps_pps->i1_num_tile_rows - 1; i++) |
| { |
| /* row_height_minus1[i] */ |
| PUT_BITS_UEV(ps_bitstrm, ps_pps->ps_tile[i].u2_ht - 1, return_status); |
| ENTROPY_TRACE("row_height_minus1[i]", ps_pps->ps_tile[i].u2_ht - 1); |
| } |
| } |
| |
| /* loop_filter_across_tiles_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_loop_filter_across_tiles_enabled_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "loop_filter_across_tiles_enabled_flag", |
| ps_pps->i1_loop_filter_across_tiles_enabled_flag); |
| } |
| |
| /* loop_filter_across_slices_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_loop_filter_across_slices_enabled_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "loop_filter_across_slices_enabled_flag", |
| ps_pps->i1_loop_filter_across_slices_enabled_flag); |
| |
| /* deblocking_filter_control_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_deblocking_filter_control_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "deblocking_filter_control_present_flag", |
| ps_pps->i1_deblocking_filter_control_present_flag); |
| |
| if(ps_pps->i1_deblocking_filter_control_present_flag) |
| { |
| /* deblocking_filter_override_enabled_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_deblocking_filter_override_enabled_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "deblocking_filter_override_enabled_flag", |
| ps_pps->i1_deblocking_filter_override_enabled_flag); |
| |
| /* pic_disable_deblocking_filter_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_pic_disable_deblocking_filter_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "pic_disable_deblocking_filter_flag", ps_pps->i1_pic_disable_deblocking_filter_flag); |
| |
| if(!ps_pps->i1_pic_disable_deblocking_filter_flag) |
| { |
| /* beta_offset_div2 */ |
| PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_beta_offset_div2 >> 1, return_status); |
| ENTROPY_TRACE("beta_offset_div2", ps_pps->i1_beta_offset_div2 >> 1); |
| |
| /* tc_offset_div2 */ |
| PUT_BITS_SEV(ps_bitstrm, ps_pps->i1_tc_offset_div2 >> 1, return_status); |
| ENTROPY_TRACE("tc_offset_div2", ps_pps->i1_tc_offset_div2 >> 1); |
| } |
| } |
| |
| /* pps_scaling_list_data_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_pps_scaling_list_data_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "pps_scaling_list_data_present_flag", ps_pps->i1_pps_scaling_list_data_present_flag); |
| |
| #if 0 /* TODO: Will be enabled once scaling list support is added */ |
| if(ps_pps->i1_pps_scaling_list_data_present_flag ) |
| { |
| //TODO |
| ihevce_scaling_list_data(); |
| } |
| #endif |
| |
| /* lists_modification_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_lists_modification_present_flag, 1, return_status); |
| ENTROPY_TRACE("lists_modification_present_flag", ps_pps->i1_lists_modification_present_flag); |
| |
| { |
| UWORD32 u4_log2_parallel_merge_level_minus2 = ps_pps->i1_log2_parallel_merge_level; |
| |
| u4_log2_parallel_merge_level_minus2 -= 2; |
| |
| /* log2_parallel_merge_level_minus2 */ |
| PUT_BITS_UEV(ps_bitstrm, u4_log2_parallel_merge_level_minus2, return_status); |
| ENTROPY_TRACE("log2_parallel_merge_level_minus2", u4_log2_parallel_merge_level_minus2); |
| } |
| |
| /* slice_header_extension_present_flag */ |
| PUT_BITS(ps_bitstrm, ps_pps->i1_slice_header_extension_present_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "slice_header_extension_present_flag", ps_pps->i1_slice_header_extension_present_flag); |
| |
| /* pps_extension_flag */ |
| PUT_BITS(ps_bitstrm, 0, 1, return_status); |
| ENTROPY_TRACE("pps_extension_flag", 0); |
| |
| ihevce_put_rbsp_trailing_bits(ps_bitstrm); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generates Slice Header |
| * |
| * @par Description |
| * Generate Slice Header as per Section 7.3.5.1 |
| * |
| * @param[inout] ps_bitstrm |
| * pointer to bitstream context for generating slice header |
| * |
| * @param[in] i1_nal_unit_type |
| * nal unit type |
| * |
| * @param[in] ps_slice_hdr |
| * pointer to slice header params |
| * |
| * @param[in] ps_pps |
| * pointer to pps params referred by slice |
| * |
| * @param[in] ps_sps |
| * pointer to sps params referred by slice |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_generate_slice_header( |
| bitstrm_t *ps_bitstrm, |
| WORD8 i1_nal_unit_type, |
| slice_header_t *ps_slice_hdr, |
| pps_t *ps_pps, |
| sps_t *ps_sps, |
| bitstrm_t *ps_dup_bit_strm_ent_offset, |
| UWORD32 *pu4_first_slice_start_offset, |
| ihevce_tile_params_t *ps_tile_params, |
| WORD32 i4_next_slice_seg_x, |
| WORD32 i4_next_slice_seg_y) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| |
| WORD32 RapPicFlag = (i1_nal_unit_type >= NAL_BLA_W_LP) && |
| (i1_nal_unit_type <= NAL_RSV_RAP_VCL23); |
| WORD32 idr_pic_flag = (NAL_IDR_W_LP == i1_nal_unit_type) || (NAL_IDR_N_LP == i1_nal_unit_type); |
| |
| WORD32 disable_deblocking_filter_flag; |
| |
| WORD32 i4_NumPocTotalCurr = 0; |
| /* Initialize the pic width and pic height from sps parameters */ |
| WORD32 pic_width = ps_sps->i2_pic_width_in_luma_samples; |
| WORD32 pic_height = ps_sps->i2_pic_height_in_luma_samples; |
| |
| /* Initialize the CTB size from sps parameters */ |
| WORD32 log2_ctb_size = |
| ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size; |
| WORD32 ctb_size = (1 << log2_ctb_size); |
| |
| /* Update ps_slice_hdr->i2_slice_address based on tile position in frame */ |
| WORD32 num_ctb_in_row = (pic_width + ctb_size - 1) >> log2_ctb_size; |
| |
| /* Overwrite i2_slice_address here as pre-enc didn't had tile structure |
| available in it's scope. Otherwise i2_slice_address would be set in |
| populate_slice_header() itself */ |
| if(1 == ps_tile_params->i4_tiles_enabled_flag) |
| { |
| ps_slice_hdr->i2_slice_address = |
| ps_tile_params->i4_first_ctb_y * num_ctb_in_row + ps_tile_params->i4_first_ctb_x; |
| } |
| else |
| { |
| ps_slice_hdr->i2_slice_address = i4_next_slice_seg_x + i4_next_slice_seg_y * num_ctb_in_row; |
| } |
| |
| /* Overwrite i1_first_slice_in_pic_flag here as pre-enc didn't had tile structure |
| available in it's scope. Otherwise i1_first_slice_in_pic_flag would be set in |
| populate_slice_header() itself */ |
| ps_slice_hdr->i1_first_slice_in_pic_flag = (ps_slice_hdr->i2_slice_address == 0); |
| |
| /* Currently if dependent slices are enabled, then all slices |
| after first slice of picture, are made dependent slices */ |
| if((1 == ps_pps->i1_dependent_slice_enabled_flag) && |
| (0 == ps_slice_hdr->i1_first_slice_in_pic_flag)) |
| { |
| ps_slice_hdr->i1_dependent_slice_flag = 1; |
| } |
| else |
| { |
| ps_slice_hdr->i1_dependent_slice_flag = 0; |
| } |
| |
| /* Insert start code */ |
| return_status |= ihevce_put_nal_start_code_prefix(ps_bitstrm, 1); |
| |
| /* Insert Nal Unit Header */ |
| return_status |= ihevce_generate_nal_unit_header( |
| ps_bitstrm, |
| i1_nal_unit_type, |
| ps_slice_hdr->u4_nuh_temporal_id); //TEMPORALA_SCALABILITY CHANGES |
| |
| /* first_slice_in_pic_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_first_slice_in_pic_flag, 1, return_status); |
| ENTROPY_TRACE("first_slice_in_pic_flag", ps_slice_hdr->i1_first_slice_in_pic_flag); |
| |
| if(RapPicFlag) |
| { |
| /* no_output_of_prior_pics_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_no_output_of_prior_pics_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "no_output_of_prior_pics_flag", ps_slice_hdr->i1_no_output_of_prior_pics_flag); |
| } |
| |
| /* pic_parameter_set_id */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_pps_id, return_status); |
| ENTROPY_TRACE("pic_parameter_set_id", ps_slice_hdr->i1_pps_id); |
| |
| /* If ps_pps->i1_dependent_slice_enabled_flag is enabled and |
| curent slice is not the first slice of picture then put |
| i1_dependent_slice_flag into the bitstream */ |
| if((ps_pps->i1_dependent_slice_enabled_flag) && (!ps_slice_hdr->i1_first_slice_in_pic_flag)) |
| { |
| /* dependent_slice_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_dependent_slice_flag, 1, return_status); |
| ENTROPY_TRACE("dependent_slice_flag", ps_slice_hdr->i1_dependent_slice_flag); |
| } |
| |
| if(!ps_slice_hdr->i1_first_slice_in_pic_flag) |
| { |
| WORD32 num_bits; |
| WORD32 num_ctb_in_pic; |
| |
| /* ctbs in frame ceiled for width / height not multiple of ctb size */ |
| num_ctb_in_pic = ((pic_width + (ctb_size - 1)) >> log2_ctb_size) * |
| ((pic_height + (ctb_size - 1)) >> log2_ctb_size); |
| |
| /* Use CLZ to compute Ceil( Log2( PicSizeInCtbsY ) ) */ |
| num_bits = 32 - CLZ(num_ctb_in_pic - 1); |
| |
| /* slice_address */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i2_slice_address, num_bits, return_status); |
| ENTROPY_TRACE("slice_address", ps_slice_hdr->i2_slice_address); |
| } |
| |
| if(!ps_slice_hdr->i1_dependent_slice_flag) |
| { |
| for(i = 0; i < ps_pps->i1_num_extra_slice_header_bits; i++) |
| { |
| /* slice_reserved_undetermined_flag */ |
| PUT_BITS(ps_bitstrm, 0, 1, return_status); |
| ENTROPY_TRACE("slice_reserved_undetermined_flag", 0); |
| } |
| /* slice_type */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_slice_type, return_status); |
| ENTROPY_TRACE("slice_type", ps_slice_hdr->i1_slice_type); |
| |
| if(ps_pps->i1_output_flag_present_flag) |
| { |
| /* pic_output_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_pic_output_flag, 1, return_status); |
| ENTROPY_TRACE("pic_output_flag", ps_slice_hdr->i1_pic_output_flag); |
| } |
| |
| if(!idr_pic_flag) |
| { |
| /* pic_order_cnt_lsb */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->i4_pic_order_cnt_lsb, |
| ps_sps->i1_log2_max_pic_order_cnt_lsb, |
| return_status); |
| ENTROPY_TRACE("pic_order_cnt_lsb", ps_slice_hdr->i4_pic_order_cnt_lsb); |
| |
| /* short_term_ref_pic_set_sps_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "short_term_ref_pic_set_sps_flag", |
| ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag); |
| |
| if(!ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag) |
| { |
| ihevce_short_term_ref_pic_set( |
| ps_bitstrm, &ps_slice_hdr->s_stref_picset, 1, 0, &i4_NumPocTotalCurr); |
| } |
| else |
| { |
| WORD32 num_bits = 32 - CLZ(ps_sps->i1_num_short_term_ref_pic_sets); |
| |
| /* short_term_ref_pic_set_idx */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->i1_short_term_ref_pic_set_idx, |
| num_bits, |
| return_status); |
| ENTROPY_TRACE( |
| "short_term_ref_pic_set_idx", ps_slice_hdr->i1_short_term_ref_pic_set_idx); |
| } |
| |
| if(ps_sps->i1_long_term_ref_pics_present_flag) |
| { |
| if(ps_sps->i1_num_long_term_ref_pics_sps > 0) |
| { |
| /* num_long_term_sps */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_long_term_sps, return_status); |
| ENTROPY_TRACE("num_long_term_sps", ps_slice_hdr->i1_num_long_term_sps); |
| } |
| |
| /* num_long_term_pics */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_long_term_pics, return_status); |
| ENTROPY_TRACE("num_long_term_pics", ps_slice_hdr->i1_num_long_term_pics); |
| |
| for(i = 0; |
| i < (ps_slice_hdr->i1_num_long_term_sps + ps_slice_hdr->i1_num_long_term_pics); |
| i++) |
| { |
| if(i < ps_slice_hdr->i1_num_long_term_sps) |
| { |
| /* Use CLZ to compute Ceil( Log2 |
| ( num_long_term_ref_pics_sps ) ) */ |
| WORD32 num_bits = 32 - CLZ(ps_sps->i1_num_long_term_ref_pics_sps); |
| |
| /* lt_idx_sps[i] */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->ai1_lt_idx_sps[i], num_bits, return_status); |
| ENTROPY_TRACE("lt_idx_sps[i]", ps_slice_hdr->ai1_lt_idx_sps[i]); |
| } |
| else |
| { |
| /* poc_lsb_lt[i] */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->ai4_poc_lsb_lt[i], |
| ps_sps->i1_log2_max_pic_order_cnt_lsb, |
| return_status); |
| ENTROPY_TRACE("poc_lsb_lt[i]", ps_slice_hdr->ai4_poc_lsb_lt[i]); |
| |
| /* used_by_curr_pic_lt_flag[i] */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i], |
| 1, |
| return_status); |
| ENTROPY_TRACE( |
| "used_by_curr_pic_lt_flag[i]", |
| ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i]); |
| } |
| |
| /* delta_poc_msb_present_flag[i] */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->ai1_delta_poc_msb_present_flag[i], |
| 1, |
| return_status); |
| ENTROPY_TRACE( |
| "delta_poc_msb_present_flag[i]", |
| ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]); |
| |
| if(ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]) |
| { |
| /* delata_poc_msb_cycle_lt[i] */ |
| PUT_BITS_UEV( |
| ps_bitstrm, ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i], return_status); |
| ENTROPY_TRACE( |
| "delata_poc_msb_cycle_lt", ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i]); |
| } |
| } |
| } |
| |
| if(ps_sps->i1_sps_temporal_mvp_enable_flag) |
| { |
| /* slice_temporal_mvp_enable_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->i1_slice_temporal_mvp_enable_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "slice_temporal_mvp_enable_flag", |
| ps_slice_hdr->i1_slice_temporal_mvp_enable_flag); |
| } |
| } |
| |
| if(ps_sps->i1_sample_adaptive_offset_enabled_flag) |
| { |
| /* slice_sao_luma_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_slice_sao_luma_flag, 1, return_status); |
| ENTROPY_TRACE("slice_sao_luma_flag", ps_slice_hdr->i1_slice_sao_luma_flag); |
| |
| /* slice_sao_chroma_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_slice_sao_chroma_flag, 1, return_status); |
| ENTROPY_TRACE("slice_sao_chroma_flag", ps_slice_hdr->i1_slice_sao_chroma_flag); |
| } |
| if((PSLICE == ps_slice_hdr->i1_slice_type) || (BSLICE == ps_slice_hdr->i1_slice_type)) |
| { |
| /* num_ref_idx_active_override_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_active_override_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "num_ref_idx_active_override_flag", |
| ps_slice_hdr->i1_num_ref_idx_active_override_flag); |
| |
| if(ps_slice_hdr->i1_num_ref_idx_active_override_flag) |
| { |
| /* i1_num_ref_idx_l0_active_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l0_active - 1, return_status); |
| ENTROPY_TRACE( |
| "i1_num_ref_idx_l0_active_minus1", ps_slice_hdr->i1_num_ref_idx_l0_active - 1); |
| |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| /* i1_num_ref_idx_l1_active */ |
| PUT_BITS_UEV( |
| ps_bitstrm, ps_slice_hdr->i1_num_ref_idx_l1_active - 1, return_status); |
| ENTROPY_TRACE( |
| "i1_num_ref_idx_l1_active", ps_slice_hdr->i1_num_ref_idx_l1_active - 1); |
| } |
| } |
| |
| if(ps_pps->i1_lists_modification_present_flag && i4_NumPocTotalCurr > 1) |
| { |
| ref_pic_list_modification(ps_bitstrm, ps_slice_hdr, i4_NumPocTotalCurr); |
| } |
| |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| /* mvd_l1_zero_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_mvd_l1_zero_flag, 1, return_status); |
| ENTROPY_TRACE("mvd_l1_zero_flag", ps_slice_hdr->i1_mvd_l1_zero_flag); |
| } |
| |
| if(ps_pps->i1_cabac_init_present_flag) |
| { |
| /* cabac_init_flag */ |
| PUT_BITS(ps_bitstrm, ps_slice_hdr->i1_cabac_init_flag, 1, return_status); |
| ENTROPY_TRACE("cabac_init_flag", ps_slice_hdr->i1_cabac_init_flag); |
| } |
| |
| if(ps_slice_hdr->i1_slice_temporal_mvp_enable_flag) |
| { |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| /* collocated_from_l0_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->i1_collocated_from_l0_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "collocated_from_l0_flag", ps_slice_hdr->i1_collocated_from_l0_flag); |
| } |
| if((ps_slice_hdr->i1_collocated_from_l0_flag && |
| (ps_slice_hdr->i1_num_ref_idx_l0_active > 1)) || |
| (!ps_slice_hdr->i1_collocated_from_l0_flag && |
| (ps_slice_hdr->i1_num_ref_idx_l1_active > 1))) |
| { |
| /* collocated_ref_idx */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_collocated_ref_idx, return_status); |
| ENTROPY_TRACE("collocated_ref_idx", ps_slice_hdr->i1_collocated_ref_idx); |
| } |
| } |
| |
| if((ps_pps->i1_weighted_pred_flag && (PSLICE == ps_slice_hdr->i1_slice_type)) || |
| (ps_pps->i1_weighted_bipred_flag && (BSLICE == ps_slice_hdr->i1_slice_type))) |
| { |
| ihevce_generate_pred_weight_table(ps_bitstrm, ps_sps, ps_pps, ps_slice_hdr); |
| } |
| |
| #if !HM_8DOT1_SYNTAX |
| /* five_minus_max_num_merge_cand */ |
| PUT_BITS_UEV(ps_bitstrm, 5 - ps_slice_hdr->i1_max_num_merge_cand, return_status); |
| ENTROPY_TRACE("five_minus_max_num_merge_cand", 5 - ps_slice_hdr->i1_max_num_merge_cand); |
| #endif |
| } |
| #if HM_8DOT1_SYNTAX |
| /* five_minus_max_num_merge_cand */ |
| PUT_BITS_UEV(ps_bitstrm, 5 - ps_slice_hdr->i1_max_num_merge_cand, return_status); |
| ENTROPY_TRACE("five_minus_max_num_merge_cand", 5 - ps_slice_hdr->i1_max_num_merge_cand); |
| #endif |
| |
| /* slice_qp_delta */ |
| PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_qp_delta, return_status); |
| ENTROPY_TRACE("slice_qp_delta", ps_slice_hdr->i1_slice_qp_delta); |
| |
| if(ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag) |
| { |
| /* slice_cb_qp_offset */ |
| PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_cb_qp_offset, return_status); |
| ENTROPY_TRACE("slice_cb_qp_offset", ps_slice_hdr->i1_slice_cb_qp_offset); |
| |
| /* slice_cr_qp_offset */ |
| PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_slice_cr_qp_offset, return_status); |
| ENTROPY_TRACE("slice_cr_qp_offset", ps_slice_hdr->i1_slice_cr_qp_offset); |
| } |
| |
| if(ps_pps->i1_deblocking_filter_control_present_flag) |
| { |
| if(ps_pps->i1_deblocking_filter_override_enabled_flag) |
| { |
| /* deblocking_filter_override_flag */ |
| PUT_BITS( |
| ps_bitstrm, ps_slice_hdr->i1_deblocking_filter_override_flag, 1, return_status); |
| ENTROPY_TRACE( |
| "deblocking_filter_override_flag", |
| ps_slice_hdr->i1_deblocking_filter_override_flag); |
| } |
| |
| if(ps_slice_hdr->i1_deblocking_filter_override_flag) |
| { |
| /* slice_disable_deblocking_filter_flag */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->i1_slice_disable_deblocking_filter_flag, |
| 1, |
| return_status); |
| ENTROPY_TRACE( |
| "slice_disable_deblocking_filter_flag", |
| ps_slice_hdr->i1_slice_disable_deblocking_filter_flag); |
| |
| if(!ps_slice_hdr->i1_slice_disable_deblocking_filter_flag) |
| { |
| /* beta_offset_div2 */ |
| PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_beta_offset_div2 >> 1, return_status); |
| ENTROPY_TRACE("beta_offset_div2", ps_slice_hdr->i1_beta_offset_div2 >> 1); |
| |
| /* tc_offset_div2 */ |
| PUT_BITS_SEV(ps_bitstrm, ps_slice_hdr->i1_tc_offset_div2 >> 1, return_status); |
| ENTROPY_TRACE("tc_offset_div2", ps_slice_hdr->i1_tc_offset_div2 >> 1); |
| } |
| } |
| } |
| |
| disable_deblocking_filter_flag = ps_slice_hdr->i1_slice_disable_deblocking_filter_flag | |
| ps_pps->i1_pic_disable_deblocking_filter_flag; |
| |
| if(ps_pps->i1_loop_filter_across_slices_enabled_flag && |
| (ps_slice_hdr->i1_slice_sao_luma_flag || ps_slice_hdr->i1_slice_sao_chroma_flag || |
| !disable_deblocking_filter_flag)) |
| { |
| /* slice_loop_filter_across_slices_enabled_flag */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag, |
| 1, |
| return_status); |
| ENTROPY_TRACE( |
| "slice_loop_filter_across_slices_enabled_flag", |
| ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag); |
| } |
| } |
| |
| if((ps_pps->i1_tiles_enabled_flag) || (ps_pps->i1_entropy_coding_sync_enabled_flag)) |
| { |
| /* num_entry_point_offsets */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i4_num_entry_point_offsets, return_status); |
| ENTROPY_TRACE("num_entry_point_offsets", ps_slice_hdr->i4_num_entry_point_offsets); |
| |
| /*copy the bitstream state at this stage, later once all the offset are known the duplicated state is used to write offset in bitstream*/ |
| memcpy(ps_dup_bit_strm_ent_offset, ps_bitstrm, sizeof(bitstrm_t)); |
| |
| if(ps_slice_hdr->i4_num_entry_point_offsets > 0) |
| { |
| /* offset_len_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_offset_len - 1, return_status); |
| ENTROPY_TRACE("offset_len_minus1", ps_slice_hdr->i1_offset_len - 1); |
| |
| /*check the bitstream offset here, the first offset will be fixed here based on num_entry_offset and maximum possible emulaiton prevention bytes*/ |
| /*This offset is used to generate bitstream, In the end of frame processing actual offset are updated and if there was no emulation bits the extra bytes |
| shall be filled with 0xFF so that decoder discards it as part of slice header extension*/ |
| |
| /*assume one byte of emulation preention for every offset we signal*/ |
| /*considering emulation prevention bytes and assuming incomplete word(4 bytes) that is yet to filled and offset length(4 bytes) that will be calc |
| based on max offset length after frame is encoded*/ |
| pu4_first_slice_start_offset[0] = |
| ps_bitstrm->u4_strm_buf_offset + |
| ((ps_slice_hdr->i4_num_entry_point_offsets * ps_slice_hdr->i1_offset_len) >> 3) + |
| ps_slice_hdr->i4_num_entry_point_offsets + 4 + 4; |
| |
| ps_slice_hdr->pu4_entry_point_offset[0] = (*pu4_first_slice_start_offset); |
| |
| for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++) |
| { |
| /* entry_point_offset[i] */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->pu4_entry_point_offset[i], |
| ps_slice_hdr->i1_offset_len, |
| return_status); |
| ENTROPY_TRACE("entry_point_offset[i]", ps_slice_hdr->pu4_entry_point_offset[i]); |
| } |
| } |
| } |
| |
| if(ps_pps->i1_slice_header_extension_present_flag) |
| { |
| /* slice_header_extension_length */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i2_slice_header_extension_length, return_status); |
| ENTROPY_TRACE( |
| "slice_header_extension_length", ps_slice_hdr->i2_slice_header_extension_length); |
| |
| for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++) |
| { |
| /* slice_header_extension_data_byte[i] */ |
| PUT_BITS(ps_bitstrm, 0, 8, return_status); |
| ENTROPY_TRACE("slice_header_extension_data_byte[i]", 0); |
| } |
| } |
| |
| BYTE_ALIGNMENT(ps_bitstrm); |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Populates vps structure |
| * |
| * @par Description |
| * All the parameters in vps are currently hard coded |
| * |
| * @param[out] ps_vps |
| * pointer to vps params that needs to be populated |
| * |
| * @param[in] ps_src_params |
| * pointer to source config params; resolution, frame rate etc |
| * |
| * @param[in] ps_out_strm_params |
| * pointer to output stream config params |
| * |
| * @param[in] ps_coding_params |
| * pointer to coding params; to enable/disable various toolsets in pps |
| * |
| * @param[in] ps_config_prms |
| * pointer to configuration params like bitrate, HRD buffer sizes, cu, tu sizes |
| * |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_populate_vps( |
| enc_ctxt_t *ps_enc_ctxt, |
| vps_t *ps_vps, |
| ihevce_src_params_t *ps_src_params, |
| ihevce_out_strm_params_t *ps_out_strm_params, |
| ihevce_coding_params_t *ps_coding_params, |
| ihevce_config_prms_t *ps_config_prms, |
| ihevce_static_cfg_params_t *ps_stat_cfg_prms, |
| WORD32 i4_resolution_id) |
| { |
| WORD8 *pi1_profile_compatiblity_flags; |
| WORD32 i; |
| WORD32 i4_field_pic = ps_src_params->i4_field_pic; |
| WORD32 i4_codec_level_index; |
| ps_vps->i1_vps_id = DEFAULT_VPS_ID; |
| |
| (void)ps_config_prms; |
| /* default sub layers is 1 */ |
| ps_vps->i1_vps_max_sub_layers = 1; |
| if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_enable_temporal_scalability) |
| { |
| ps_vps->i1_vps_max_sub_layers = 2; |
| } |
| |
| for(i = 0; i < ps_vps->i1_vps_max_sub_layers; i++) |
| { |
| /* currently bit rate and pic rate signalling is disabled */ |
| ps_vps->ai1_bit_rate_info_present_flag[i] = 0; |
| ps_vps->ai1_pic_rate_info_present_flag[i] = 0; |
| |
| if(ps_vps->ai1_bit_rate_info_present_flag[i]) |
| { |
| /* TODO: Add support for bitrate and max bitrate */ |
| ps_vps->au2_avg_bit_rate[i] = 0; |
| ps_vps->au2_max_bit_rate[i] = 0; |
| } |
| |
| if(ps_vps->ai1_pic_rate_info_present_flag[i]) |
| { |
| /* TODO: Add support for pic rate idc and avg pic rate */ |
| } |
| } |
| |
| /* default sub layer ordering info present flag */ |
| ps_vps->i1_sub_layer_ordering_info_present_flag = VPS_SUB_LAYER_ORDERING_INFO_ABSENT; |
| |
| /* hrd and temporal id nesting not supported for now */ |
| ps_vps->i1_vps_num_hrd_parameters = 0; |
| |
| if(ps_vps->i1_vps_max_sub_layers == 1) |
| { |
| ps_vps->i1_vps_temporal_id_nesting_flag = 1; |
| } |
| else |
| { |
| ps_vps->i1_vps_temporal_id_nesting_flag = 0; |
| } |
| |
| /* populate the general profile, tier and level information */ |
| ps_vps->s_ptl.s_ptl_gen.i1_profile_space = 0; // BLU_RAY specific change is default |
| |
| /* set the profile according to user input */ |
| ps_vps->s_ptl.s_ptl_gen.i1_profile_idc = ps_out_strm_params->i4_codec_profile; |
| |
| /***************************************************************/ |
| /* set the profile compatibility flag for current profile to 1 */ |
| /* the rest of the flags are set to 0 */ |
| /***************************************************************/ |
| pi1_profile_compatiblity_flags = &ps_vps->s_ptl.s_ptl_gen.ai1_profile_compatibility_flag[0]; |
| |
| for(i = 0; i < ps_vps->i1_vps_max_sub_layers; i++) //TEMPORALA_SCALABILITY CHANGES |
| { |
| ps_vps->ai1_vps_max_dec_pic_buffering[i] = |
| ps_coding_params->i4_max_reference_frames + (2 << i4_field_pic) - 1; |
| |
| ps_vps->ai1_vps_max_num_reorder_pics[i] = ps_coding_params->i4_max_temporal_layers |
| << i4_field_pic; |
| |
| ps_vps->ai1_vps_max_latency_increase[i] = 0; |
| |
| ps_vps->s_ptl.ai1_sub_layer_level_present_flag[i] = 1; //TEMPORALA_SCALABILITY CHANGES |
| |
| ps_vps->s_ptl.ai1_sub_layer_profile_present_flag[i] = 0; //TEMPORALA_SCALABILITY CHANGES |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_profile_space = 0; // BLU_RAY specific change is default |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_profile_idc = ps_out_strm_params->i4_codec_profile; |
| |
| memset( |
| ps_vps->s_ptl.as_ptl_sub[i].ai1_profile_compatibility_flag, |
| 0, |
| MAX_PROFILE_COMPATBLTY * sizeof(WORD8)); |
| |
| ps_vps->s_ptl.as_ptl_sub[i] |
| .ai1_profile_compatibility_flag[ps_out_strm_params->i4_codec_profile] = 1; |
| |
| ps_vps->s_ptl.as_ptl_sub[i].u1_level_idc = |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; |
| |
| if(0 == i) // Only one level temporal scalability suport has been added. |
| { |
| i4_codec_level_index = ihevce_get_level_index( |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level); |
| |
| if(i4_codec_level_index) |
| i4_codec_level_index -= 1; |
| |
| ps_vps->s_ptl.as_ptl_sub[i].u1_level_idc = |
| (WORD32)g_as_level_data[i4_codec_level_index].e_level; |
| } |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_tier_flag = ps_out_strm_params->i4_codec_tier; |
| |
| if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) |
| { |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 1; |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; |
| } |
| else if(ps_src_params->i4_field_pic == IV_INTERLACED) |
| { |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 1; |
| } |
| else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) |
| { |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; |
| } |
| |
| ps_vps->s_ptl.as_ptl_sub[i].i1_general_non_packed_constraint_flag = |
| DEFAULT_NON_PACKED_CONSTRAINT_FLAG; |
| |
| if(ps_enc_ctxt->i4_blu_ray_spec == 1) |
| { |
| ps_vps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = 1; |
| } |
| else |
| { |
| ps_vps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = |
| DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; |
| } |
| } |
| |
| memset(pi1_profile_compatiblity_flags, 0, MAX_PROFILE_COMPATBLTY); |
| pi1_profile_compatiblity_flags[ps_out_strm_params->i4_codec_profile] = 1; |
| |
| /* set the level idc according to user input */ |
| ps_vps->s_ptl.s_ptl_gen.u1_level_idc = |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_tier_flag = ps_out_strm_params->i4_codec_tier; |
| |
| if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 1; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; |
| } |
| else if(ps_src_params->i4_field_pic == IV_INTERLACED) |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 1; |
| } |
| else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; |
| } |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_non_packed_constraint_flag = |
| DEFAULT_NON_PACKED_CONSTRAINT_FLAG; |
| |
| if(ps_enc_ctxt->i4_blu_ray_spec == 1) |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = 1; |
| } |
| else |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; |
| } |
| if((ps_out_strm_params->i4_codec_profile == 4) && |
| (ps_src_params->i4_chr_format == IV_YUV_420SP_UV)) |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 1; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; |
| } |
| else if( |
| (ps_out_strm_params->i4_codec_profile == 4) && |
| (ps_src_params->i4_chr_format == IV_YUV_422SP_UV)) |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; |
| } |
| else |
| { |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_vps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 0; |
| } |
| |
| ps_vps->i1_vps_max_nuh_reserved_zero_layer_id = 0; |
| |
| return IHEVCE_SUCCESS; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Populates sps structure |
| * |
| * @par Description |
| * Populates sps structure for its use in header generation |
| * |
| * @param[out] ps_sps |
| * pointer to sps params that needs to be populated |
| * |
| * @param[in] ps_vps |
| * pointer to vps params referred by the sps |
| * |
| * @param[in] ps_src_params |
| * pointer to source config params; resolution, frame rate etc |
| * |
| * @param[in] ps_out_strm_params |
| * pointer to output stream config params |
| * |
| * @param[in] ps_coding_params |
| * pointer to coding params; to enable/disable various toolsets in pps |
| * |
| * @param[in] ps_config_prms |
| * pointer to configuration params like bitrate, HRD buffer sizes, cu, tu sizes |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_populate_sps( |
| enc_ctxt_t *ps_enc_ctxt, |
| sps_t *ps_sps, |
| vps_t *ps_vps, |
| ihevce_src_params_t *ps_src_params, |
| ihevce_out_strm_params_t *ps_out_strm_params, |
| ihevce_coding_params_t *ps_coding_params, |
| ihevce_config_prms_t *ps_config_prms, |
| frm_ctb_ctxt_t *ps_frm_ctb_prms, |
| ihevce_static_cfg_params_t *ps_stat_cfg_prms, |
| WORD32 i4_resolution_id) |
| { |
| WORD32 i; |
| WORD32 i4_field_pic = ps_src_params->i4_field_pic; |
| WORD32 i4_quality_preset = |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset; |
| WORD32 i4_codec_level_index; |
| |
| if(i4_quality_preset == IHEVCE_QUALITY_P7) |
| { |
| i4_quality_preset = IHEVCE_QUALITY_P6; |
| } |
| |
| ps_sps->i1_sps_id = DEFAULT_SPS_ID; |
| |
| if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_mres_single_out) |
| { |
| ps_sps->i1_sps_id = i4_resolution_id; |
| } |
| |
| ps_sps->i1_vps_id = ps_vps->i1_vps_id; |
| |
| ps_sps->i2_pic_height_in_luma_samples = ps_frm_ctb_prms->i4_cu_aligned_pic_ht; |
| |
| ps_sps->i2_pic_width_in_luma_samples = ps_frm_ctb_prms->i4_cu_aligned_pic_wd; |
| |
| ps_sps->i1_amp_enabled_flag = AMP_ENABLED; |
| |
| ps_sps->i1_chroma_format_idc = (ps_src_params->i4_chr_format == IV_YUV_422SP_UV) ? 2 : 1; |
| |
| ps_sps->i1_separate_colour_plane_flag = 0; |
| |
| ps_sps->i1_bit_depth_luma_minus8 = ps_stat_cfg_prms->s_tgt_lyr_prms.i4_internal_bit_depth - 8; |
| |
| ps_sps->i1_bit_depth_chroma_minus8 = ps_stat_cfg_prms->s_tgt_lyr_prms.i4_internal_bit_depth - 8; |
| |
| ps_sps->i1_log2_min_coding_block_size = ps_config_prms->i4_min_log2_cu_size; |
| |
| ps_sps->i1_log2_diff_max_min_coding_block_size = |
| ps_config_prms->i4_max_log2_cu_size - ps_config_prms->i4_min_log2_cu_size; |
| |
| ps_sps->i1_log2_ctb_size = |
| ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size; |
| |
| ps_sps->i1_log2_diff_max_min_transform_block_size = |
| ps_config_prms->i4_max_log2_tu_size - ps_config_prms->i4_min_log2_tu_size; |
| |
| ps_sps->i1_log2_min_transform_block_size = ps_config_prms->i4_min_log2_tu_size; |
| |
| ps_sps->i1_long_term_ref_pics_present_flag = LONG_TERM_REF_PICS_ABSENT; |
| |
| ps_sps->i1_max_transform_hierarchy_depth_inter = ps_config_prms->i4_max_tr_tree_depth_nI; |
| |
| ps_sps->i1_max_transform_hierarchy_depth_intra = ps_config_prms->i4_max_tr_tree_depth_I; |
| |
| ps_sps->i1_pcm_enabled_flag = PCM_DISABLED; |
| |
| ps_sps->i1_pcm_loop_filter_disable_flag = PCM_LOOP_FILTER_DISABLED; |
| |
| ps_sps->i1_pic_cropping_flag = !!ps_coding_params->i4_cropping_mode; |
| |
| if(i4_quality_preset < IHEVCE_QUALITY_P4) |
| { |
| /*** Enable SAO for PQ,HQ,MS presets **/ |
| ps_sps->i1_sample_adaptive_offset_enabled_flag = SAO_ENABLED; |
| } |
| else |
| { |
| ps_sps->i1_sample_adaptive_offset_enabled_flag = SAO_DISABLED; |
| } |
| #if DISABLE_SAO |
| ps_sps->i1_sample_adaptive_offset_enabled_flag = SAO_DISABLED; |
| #endif |
| |
| if(ps_coding_params->i4_use_default_sc_mtx == 1) |
| { |
| ps_sps->i1_scaling_list_enable_flag = SCALING_LIST_ENABLED; |
| } |
| else |
| { |
| ps_sps->i1_scaling_list_enable_flag = SCALING_LIST_DISABLED; |
| } |
| |
| ps_sps->i1_sps_max_sub_layers = DEFAULT_SPS_MAX_SUB_LAYERS; |
| |
| if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_enable_temporal_scalability) |
| { |
| ps_sps->i1_sps_max_sub_layers = DEFAULT_SPS_MAX_SUB_LAYERS + 1; |
| } |
| |
| ps_sps->i1_sps_sub_layer_ordering_info_present_flag = SPS_SUB_LAYER_ORDERING_INFO_ABSENT; |
| |
| ps_sps->i1_sps_scaling_list_data_present_flag = SCALING_LIST_DATA_ABSENT; |
| |
| if(ps_sps->i1_sps_max_sub_layers == 1) |
| { |
| ps_sps->i1_sps_temporal_id_nesting_flag = 1; //NO_SPS_TEMPORAL_ID_NESTING_DONE; |
| } |
| else |
| { |
| ps_sps->i1_sps_temporal_id_nesting_flag = 0; //NO_SPS_TEMPORAL_ID_NESTING_DONE; |
| } |
| |
| /* short term and long term ref pic set not signalled in sps */ |
| ps_sps->i1_num_short_term_ref_pic_sets = 0; |
| ps_sps->i1_long_term_ref_pics_present_flag = 0; |
| |
| ps_sps->i1_num_long_term_ref_pics_sps = 0; |
| ps_sps->i1_sps_temporal_mvp_enable_flag = !DISABLE_TMVP; |
| |
| ps_sps->i1_strong_intra_smoothing_enable_flag = STRONG_INTRA_SMOOTHING_FLAG_ENABLE; |
| |
| ps_sps->i1_vui_parameters_present_flag = ps_out_strm_params->i4_vui_enable; |
| |
| /*required in generation of slice header*/ |
| ps_sps->i2_pic_ht_in_ctb = ps_frm_ctb_prms->i4_num_ctbs_vert; |
| |
| ps_sps->i2_pic_wd_in_ctb = ps_frm_ctb_prms->i4_num_ctbs_horz; |
| |
| ps_sps->i1_log2_max_pic_order_cnt_lsb = DEFAULT_LOG2_MAX_POC_LSB; |
| |
| if(ps_sps->i1_pic_cropping_flag) |
| { |
| WORD32 num_rows_to_pad_bottom = |
| ps_sps->i2_pic_height_in_luma_samples - ps_stat_cfg_prms->s_src_prms.i4_orig_height; |
| WORD32 num_rows_to_pad_right = |
| ps_sps->i2_pic_width_in_luma_samples - ps_stat_cfg_prms->s_src_prms.i4_orig_width; |
| |
| ps_sps->i2_pic_crop_top_offset = DEFAULT_PIC_CROP_TOP_OFFSET; |
| |
| ps_sps->i2_pic_crop_left_offset = DEFAULT_PIC_CROP_LEFT_OFFSET; |
| |
| /* picture offsets should be signalled in terms of chroma unit */ |
| ps_sps->i2_pic_crop_bottom_offset = num_rows_to_pad_bottom >> 1; |
| |
| /* picture offsets should be signalled in terms of chroma unit */ |
| ps_sps->i2_pic_crop_right_offset = num_rows_to_pad_right >> 1; |
| } |
| |
| for(i = 0; i < (ps_sps->i1_sps_max_sub_layers); i++) |
| { |
| ps_sps->ai1_sps_max_dec_pic_buffering[i] = |
| ps_coding_params->i4_max_reference_frames + (2 << i4_field_pic) - 1; |
| |
| ps_sps->ai1_sps_max_num_reorder_pics[i] = ps_coding_params->i4_max_temporal_layers |
| << i4_field_pic; |
| |
| ps_sps->ai1_sps_max_latency_increase[i] = 0; |
| |
| ps_sps->s_ptl.ai1_sub_layer_level_present_flag[i] = 1; //TEMPORALA_SCALABILITY CHANGES |
| |
| ps_sps->s_ptl.ai1_sub_layer_profile_present_flag[i] = 0; //TEMPORALA_SCALABILITY CHANGES |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_profile_space = 0; // BLU_RAY specific change is default |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_profile_idc = ps_out_strm_params->i4_codec_profile; |
| |
| memset( |
| ps_sps->s_ptl.as_ptl_sub[i].ai1_profile_compatibility_flag, |
| 0, |
| MAX_PROFILE_COMPATBLTY * sizeof(WORD8)); |
| |
| ps_sps->s_ptl.as_ptl_sub[i] |
| .ai1_profile_compatibility_flag[ps_out_strm_params->i4_codec_profile] = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].u1_level_idc = |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; |
| |
| if(0 == i) // Only one level temporal scalability suport has been added. |
| { |
| i4_codec_level_index = ihevce_get_level_index( |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level); |
| |
| if(i4_codec_level_index) |
| i4_codec_level_index -= 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].u1_level_idc = |
| (WORD32)g_as_level_data[i4_codec_level_index].e_level; |
| } |
| ps_sps->s_ptl.as_ptl_sub[i].i1_tier_flag = ps_out_strm_params->i4_codec_tier; |
| |
| if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; |
| } |
| else if(ps_src_params->i4_field_pic == IV_INTERLACED) |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 1; |
| } |
| else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_progressive_source_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_interlaced_source_flag = 0; |
| } |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_non_packed_constraint_flag = |
| DEFAULT_NON_PACKED_CONSTRAINT_FLAG; |
| |
| if(ps_enc_ctxt->i4_blu_ray_spec == 1) |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = 1; |
| } |
| else |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_frame_only_constraint_flag = |
| DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; |
| } |
| if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 1)) |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_12bit_constraint_flag = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_422chroma_constraint_flag = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_420chroma_constraint_flag = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_intra_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_lower_bit_rate_constraint_flag = 1; |
| } |
| else if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 2)) |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_12bit_constraint_flag = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_422chroma_constraint_flag = 1; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_420chroma_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_intra_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_lower_bit_rate_constraint_flag = 1; |
| } |
| else |
| { |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_12bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_422chroma_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_420chroma_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_intra_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_sps->s_ptl.as_ptl_sub[i].i1_general_lower_bit_rate_constraint_flag = 0; |
| } |
| } |
| |
| memset( |
| ps_sps->s_ptl.s_ptl_gen.ai1_profile_compatibility_flag, |
| 0, |
| MAX_PROFILE_COMPATBLTY * sizeof(WORD8)); |
| |
| /* populate the general profile, tier and level information */ |
| ps_sps->s_ptl.s_ptl_gen.i1_profile_space = 0; // BLU_RAY specific change is default |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_profile_idc = ps_out_strm_params->i4_codec_profile; |
| |
| ps_sps->s_ptl.s_ptl_gen.ai1_profile_compatibility_flag[ps_out_strm_params->i4_codec_profile] = |
| 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.u1_level_idc = |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_codec_level; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_tier_flag = ps_out_strm_params->i4_codec_tier; |
| |
| if(ps_src_params->i4_field_pic == IV_PROGRESSIVE) |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; |
| } |
| else if(ps_src_params->i4_field_pic == IV_INTERLACED) |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 1; |
| } |
| else if(ps_src_params->i4_field_pic == IV_CONTENTTYPE_NA) |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_general_progressive_source_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_interlaced_source_flag = 0; |
| } |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_non_packed_constraint_flag = |
| DEFAULT_NON_PACKED_CONSTRAINT_FLAG; |
| |
| if(ps_enc_ctxt->i4_blu_ray_spec == 1) |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = 1; |
| } |
| else |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_frame_only_constraint_flag = DEFAULT_FRAME_ONLY_CONSTRAINT_FLAG; |
| } |
| if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 1)) |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; |
| } |
| else if((ps_out_strm_params->i4_codec_profile == 4) && (ps_sps->i1_chroma_format_idc == 2)) |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 1; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 1; |
| } |
| else |
| { |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_12bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_10bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_8bit_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_422chroma_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_420chroma_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_max_monochrome_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_intra_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_one_picture_only_constraint_flag = 0; |
| |
| ps_sps->s_ptl.s_ptl_gen.i1_general_lower_bit_rate_constraint_flag = 0; |
| } |
| |
| return IHEVCE_SUCCESS; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Populates pps structure based on input cofiguration params |
| * |
| * @par Description |
| * Populates pps structure for its use in header generation |
| * |
| * @param[out] ps_pps |
| * pointer to pps params structure which needs to be populated |
| * |
| * @param[in] ps_sps |
| * pointer to sps params refered by the pps |
| * |
| * @param[in] ps_src_params |
| * pointer to source config params; resolution, frame rate etc |
| * |
| * @param[in] ps_out_strm_params |
| * pointer to output stream config params |
| * |
| * @param[in] ps_coding_params |
| * pointer to coding params; to enable/disable various toolsets in pps |
| * |
| * @param[in] ps_config_prms |
| * pointer to configuration params like bitrate, HRD buffer sizes, cu, tu sizes |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_populate_pps( |
| pps_t *ps_pps, |
| sps_t *ps_sps, |
| ihevce_src_params_t *ps_src_params, |
| ihevce_out_strm_params_t *ps_out_strm_params, |
| ihevce_coding_params_t *ps_coding_params, |
| ihevce_config_prms_t *ps_config_prms, |
| ihevce_static_cfg_params_t *ps_stat_cfg_prms, |
| WORD32 i4_bitrate_instance_id, |
| WORD32 i4_resolution_id, |
| ihevce_tile_params_t *ps_tile_params_base, |
| WORD32 *pi4_column_width_array, |
| WORD32 *pi4_row_height_array) |
| { |
| (void)ps_src_params; |
| (void)ps_out_strm_params; |
| |
| ps_pps->i1_beta_offset_div2 = DEFAULT_BETA_OFFSET; |
| |
| ps_pps->i1_cabac_init_present_flag = CABAC_INIT_ABSENT; |
| |
| ps_pps->i1_constrained_intra_pred_flag = CONSTR_IPRED_DISABLED; |
| /*delta qp can be disabled for constant qp mode to save on qp signalling bits*/ |
| ps_pps->i1_cu_qp_delta_enabled_flag = ps_config_prms->i4_cu_level_rc; |
| |
| ps_pps->i1_deblocking_filter_control_present_flag = DEBLOCKING_FILTER_CONTROL_PRESENT; |
| |
| ps_pps->i1_deblocking_filter_override_enabled_flag = DEBLOCKING_FILTER_OVERRIDE_DISABLED; |
| |
| ps_pps->i1_pic_disable_deblocking_filter_flag = ps_coding_params->i4_deblocking_type; |
| |
| if(0 != ps_stat_cfg_prms->s_slice_params.i4_slice_segment_mode) |
| { |
| ps_pps->i1_dependent_slice_enabled_flag = DEPENDENT_SLICE_ENABLED; |
| } |
| else |
| { |
| ps_pps->i1_dependent_slice_enabled_flag = DEPENDENT_SLICE_DISABLED; |
| } |
| |
| /* Assign the diff_cu_qp_delta_depth with 3,2,1 for making |
| CU_LEVEL_QP_MODULATION limited to 8x8, 16x16, 32x32 respectively : Lokesh */ |
| ps_pps->i1_diff_cu_qp_delta_depth = CU_LEVEL_QP_LIMIT_8x8; |
| |
| if(1 == ps_coding_params->i4_enable_entropy_sync) |
| { |
| ps_pps->i1_entropy_coding_sync_enabled_flag = ENTROPY_CODING_SYNC_ENABLED; |
| } |
| else |
| { |
| ps_pps->i1_entropy_coding_sync_enabled_flag = ENTROPY_CODING_SYNC_DISABLED; |
| } |
| |
| ps_pps->i1_entropy_slice_enabled_flag = ENTROPY_SLICE_DISABLED; |
| |
| ps_pps->i1_lists_modification_present_flag = ps_coding_params->i4_weighted_pred_enable; |
| |
| ps_pps->i1_log2_parallel_merge_level = DEFAULT_PARALLEL_MERGE_LEVEL; |
| |
| ps_pps->i1_num_extra_slice_header_bits = 0; |
| |
| /* SAO_note_01: Currently SAO is implemented is such a way that the |
| loop-filter has to be enabled across syntatical-tiles and slices. |
| Search for <SAO_note_01> in workspace to know more */ |
| ps_pps->i1_loop_filter_across_slices_enabled_flag = LF_ACROSS_SLICES_ENABLED; |
| |
| ps_pps->i1_num_ref_idx_l0_default_active = DEFAULT_NUM_REF_IDX_L0_DEFAULT_ACTIVE; |
| |
| ps_pps->i1_num_ref_idx_l1_default_active = DEFAULT_NUM_REF_IDX_L1_DEFAULT_ACTIVE; |
| |
| if(0 == ps_tile_params_base->i4_tiles_enabled_flag) |
| { |
| ps_pps->i1_num_tile_columns = NUM_TILES_COLS; |
| |
| ps_pps->i1_num_tile_rows = NUM_TILES_ROWS; |
| |
| ps_pps->i1_tiles_enabled_flag = TILES_DISABLED; |
| |
| ps_pps->i1_uniform_spacing_flag = SPACING_IS_UNIFORM; |
| } |
| else |
| { |
| ps_pps->i1_num_tile_columns = ps_tile_params_base->i4_num_tile_cols; |
| |
| ps_pps->i1_num_tile_rows = ps_tile_params_base->i4_num_tile_rows; |
| |
| ps_pps->i1_tiles_enabled_flag = TILES_ENABLED; |
| |
| ps_pps->i1_uniform_spacing_flag = ps_tile_params_base->i4_uniform_spacing_flag; |
| |
| if(SPACING_IS_NONUNIFORM == ps_pps->i1_uniform_spacing_flag) |
| { |
| WORD32 i4_i; |
| for(i4_i = 0; i4_i < ps_tile_params_base->i4_num_tile_cols; i4_i++) |
| { |
| ps_pps->ps_tile[i4_i].u2_wd = pi4_column_width_array[i4_i] >> |
| ps_config_prms->i4_max_log2_cu_size; |
| } |
| for(i4_i = 0; i4_i < ps_tile_params_base->i4_num_tile_rows; i4_i++) |
| { |
| ps_pps->ps_tile[i4_i].u2_ht = pi4_row_height_array[i4_i] >> |
| ps_config_prms->i4_max_log2_cu_size; |
| } |
| } |
| } |
| |
| /* SAO_note_01: Currently SAO is implemented is such a way that the |
| loop-filter has to be enabled across syntatical-tiles and slices. |
| Search for <SAO_note_01> in workspace to know more */ |
| if(0 == ps_tile_params_base->i4_tiles_enabled_flag) |
| { |
| ps_pps->i1_loop_filter_across_tiles_enabled_flag = 1; |
| } |
| else |
| { |
| ps_pps->i1_loop_filter_across_tiles_enabled_flag = 0; |
| } |
| |
| ps_pps->i1_output_flag_present_flag = OUTPUT_FLAG_ABSENT; |
| |
| ps_pps->i1_pic_cb_qp_offset = DEFAULT_PIC_CB_QP_OFFSET; |
| |
| ps_pps->i1_pic_cr_qp_offset = DEFAULT_PIC_CR_QP_OFFSET; |
| |
| /*init qp is different for each bit-rate instance */ |
| ps_pps->i1_pic_init_qp = CLIP3( |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id] |
| .ai4_frame_qp[i4_bitrate_instance_id], |
| ps_config_prms->i4_min_frame_qp, |
| ps_config_prms->i4_max_frame_qp); |
| |
| /* enable chroma QP offset only if stasino or psy rd is present */ |
| if(((ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_CONTROL_TOGGLER)) && |
| ((ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_NOISE_PRESERVATION)) || |
| (ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_1)) || |
| (ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_2)) || |
| (ps_coding_params->i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_3))))) |
| { |
| ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag = |
| SLICE_LEVEL_CHROMA_QP_OFFSETS_PRESENT; |
| } |
| else |
| { |
| ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag = |
| SLICE_LEVEL_CHROMA_QP_OFFSETS_ABSENT; |
| } |
| |
| ps_pps->i1_pps_id = DEFAULT_PPS_ID; |
| |
| if(1 == ps_stat_cfg_prms->s_tgt_lyr_prms.i4_mres_single_out) |
| { |
| ps_pps->i1_pps_id = i4_resolution_id; |
| } |
| |
| ps_pps->i1_pps_scaling_list_data_present_flag = SCALING_LIST_DATA_ABSENT; |
| |
| if(ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset < |
| IHEVCE_QUALITY_P3) |
| { |
| ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_HIDDEN; |
| } |
| else if( |
| ps_stat_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset == |
| IHEVCE_QUALITY_P3) |
| { |
| ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_UNHIDDEN; |
| } |
| else |
| { |
| ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_UNHIDDEN; |
| } |
| |
| #if DISABLE_SBH |
| ps_pps->i1_sign_data_hiding_flag = SIGN_DATA_UNHIDDEN; |
| #endif |
| |
| ps_pps->i1_slice_extension_present_flag = SLICE_EXTENSION_ABSENT; |
| |
| ps_pps->i1_slice_header_extension_present_flag = SLICE_HEADER_EXTENSION_ABSENT; |
| |
| ps_pps->i1_sps_id = ps_sps->i1_sps_id; |
| |
| ps_pps->i1_tc_offset_div2 = DEFAULT_TC_OFFSET; |
| |
| ps_pps->i1_transform_skip_enabled_flag = TRANSFORM_SKIP_DISABLED; |
| |
| ps_pps->i1_transquant_bypass_enable_flag = TRANSFORM_BYPASS_DISABLED; |
| |
| ps_pps->i1_weighted_bipred_flag = ps_coding_params->i4_weighted_pred_enable; |
| |
| ps_pps->i1_weighted_pred_flag = ps_coding_params->i4_weighted_pred_enable; |
| |
| return IHEVCE_SUCCESS; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Populates slice header structure |
| * |
| * @par Description |
| * Populates slice header structure for its use in header generation |
| * |
| * @param[out] ps_slice_hdr |
| * pointer to slice header structure that needs to be populated |
| * |
| * @param[in] ps_pps |
| * pointer to pps params structure refered by the slice |
| * |
| * @param[in] ps_sps |
| * pointer to sps params refered by the pps |
| * |
| * @param[in] nal_unit_type |
| * nal unit type for current slice |
| * |
| * @param[in] slice_type |
| * current slice type |
| * |
| * @param[in] ctb_x |
| * x offset of first ctb in current slice (ctb units) |
| * |
| * @param[in] ctb_y |
| * y offset of first ctb in current slice (ctb units) |
| * |
| * @param[in] poc |
| * pic order count for current slice (shall be 0 for IDR pics) |
| * |
| * @param[in] cur_slice_qp |
| * qp for the current slice |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_populate_slice_header( |
| slice_header_t *ps_slice_hdr, |
| pps_t *ps_pps, |
| sps_t *ps_sps, |
| WORD32 nal_unit_type, |
| WORD32 slice_type, |
| WORD32 ctb_x, |
| WORD32 ctb_y, |
| WORD32 poc, |
| WORD32 cur_slice_qp, |
| WORD32 max_merge_candidates, |
| WORD32 i4_rc_pass_num, |
| WORD32 i4_quality_preset, |
| WORD32 stasino_enabled) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| WORD32 RapPicFlag = (nal_unit_type >= NAL_BLA_W_LP) && (nal_unit_type <= NAL_RSV_RAP_VCL23); |
| |
| WORD32 idr_pic_flag = (NAL_IDR_W_LP == nal_unit_type) || (NAL_IDR_N_LP == nal_unit_type); |
| |
| WORD32 disable_deblocking_filter_flag; |
| |
| (void)ctb_x; |
| (void)ctb_y; |
| /* first_slice_in_pic_flag */ |
| if(i4_quality_preset == IHEVCE_QUALITY_P7) |
| { |
| i4_quality_preset = IHEVCE_QUALITY_P6; |
| } |
| |
| if(RapPicFlag) |
| { |
| /* no_output_of_prior_pics_flag */ /* TODO:revisit this */ |
| ps_slice_hdr->i1_no_output_of_prior_pics_flag = 0; //BLU_RAY specific already done |
| } |
| |
| /* pic_parameter_set_id */ |
| ps_slice_hdr->i1_pps_id = ps_pps->i1_pps_id; |
| |
| { |
| /* This i1_dependent_slice_flag will further be updated in generate_slice_header() function */ |
| ps_slice_hdr->i1_dependent_slice_flag = 0; |
| } |
| |
| if(!ps_slice_hdr->i1_dependent_slice_flag) |
| { |
| /* slice_type */ |
| ps_slice_hdr->i1_slice_type = (WORD8)slice_type; |
| |
| if(ps_pps->i1_output_flag_present_flag) |
| { |
| /* pic_output_flag */ /* TODO:revisit this */ |
| ps_slice_hdr->i1_pic_output_flag = 0; |
| } |
| |
| /* separate colour plane flag not supported in this encoder */ |
| ASSERT(0 == ps_sps->i1_separate_colour_plane_flag); |
| |
| if(!idr_pic_flag) |
| { |
| WORD32 log2_max_poc_lsb = ps_sps->i1_log2_max_pic_order_cnt_lsb; |
| |
| /* pic_order_cnt_lsb */ |
| ps_slice_hdr->i4_pic_order_cnt_lsb = poc & ((1 << log2_max_poc_lsb) - 1); |
| |
| /* short_term_ref_pic_set_sps_flag */ |
| /* TODO : revisit this */ |
| ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag = 0; |
| |
| if(!ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag) |
| { |
| /* TODO: To populate short term ref pic set for this slice */ |
| } |
| |
| /* long term ref pic flag not supported */ |
| ASSERT(0 == ps_sps->i1_long_term_ref_pics_present_flag); |
| if(ps_sps->i1_long_term_ref_pics_present_flag) |
| { |
| /* TODO : not supported */ |
| } |
| } |
| |
| //ASSERT(0 == ps_sps->i1_sample_adaptive_offset_enabled_flag); |
| if(ps_sps->i1_sample_adaptive_offset_enabled_flag) |
| { |
| /* slice_sao_luma_flag */ |
| ps_slice_hdr->i1_slice_sao_luma_flag = 1; |
| ps_slice_hdr->i1_slice_sao_chroma_flag = 1; |
| } |
| |
| #if DISABLE_LUMA_SAO |
| ps_slice_hdr->i1_slice_sao_luma_flag = 0; |
| #endif |
| |
| #if DISABLE_CHROMA_SAO |
| ps_slice_hdr->i1_slice_sao_chroma_flag = 0; |
| #endif |
| if((PSLICE == ps_slice_hdr->i1_slice_type) || (BSLICE == ps_slice_hdr->i1_slice_type)) |
| { |
| /* TODO: currently temporal mvp disabled, need to enable later */ |
| if(1 == ps_sps->i1_sps_temporal_mvp_enable_flag) |
| { |
| ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = 1; |
| } |
| else |
| { |
| ps_slice_hdr->i1_slice_temporal_mvp_enable_flag = 0; |
| } |
| |
| /* num_ref_idx_active_override_flag */ |
| ps_slice_hdr->i1_num_ref_idx_active_override_flag = 0; |
| |
| if(ps_slice_hdr->i1_num_ref_idx_active_override_flag) |
| { |
| /* TODO revisit this*/ |
| /* i1_num_ref_idx_l0_active_minus1 */ |
| ps_slice_hdr->i1_num_ref_idx_l0_active = 1; |
| |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| /* i1_num_ref_idx_l1_active */ |
| /* TODO revisit this*/ |
| ps_slice_hdr->i1_num_ref_idx_l1_active = 1; |
| } |
| } |
| |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| /* mvd_l1_zero_flag */ |
| ps_slice_hdr->i1_mvd_l1_zero_flag = 0; |
| } |
| |
| { |
| /* cabac_init_flag curently set to 0 */ |
| ps_slice_hdr->i1_cabac_init_flag = ps_pps->i1_cabac_init_present_flag ? 1 : 0; |
| } |
| |
| if(ps_slice_hdr->i1_slice_temporal_mvp_enable_flag) |
| { |
| if(BSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| /* collocated_from_l0_flag */ |
| ps_slice_hdr->i1_collocated_from_l0_flag = 0; |
| } |
| else if(PSLICE == ps_slice_hdr->i1_slice_type) |
| { |
| ps_slice_hdr->i1_collocated_from_l0_flag = 1; |
| } |
| |
| if((ps_slice_hdr->i1_collocated_from_l0_flag && |
| (ps_slice_hdr->i1_num_ref_idx_l0_active > 1)) || |
| (!ps_slice_hdr->i1_collocated_from_l0_flag && |
| (ps_slice_hdr->i1_num_ref_idx_l1_active > 1))) |
| { |
| /* collocated_ref_idx */ |
| /* TODO revisit this*/ |
| ps_slice_hdr->i1_collocated_ref_idx = 0; |
| //ps_slice_hdr->i1_num_ref_idx_l1_active - 1; |
| } |
| } |
| } |
| ps_slice_hdr->i1_max_num_merge_cand = max_merge_candidates; |
| |
| /* TODO : revisit this */ |
| ps_slice_hdr->i1_slice_qp_delta = (WORD8)cur_slice_qp - ps_pps->i1_pic_init_qp; |
| |
| if(!ps_pps->i1_pic_slice_level_chroma_qp_offsets_present_flag || !stasino_enabled) |
| { |
| /* slice_cb_qp_offset */ |
| ps_slice_hdr->i1_slice_cb_qp_offset = 0; |
| |
| /* slice_cr_qp_offset */ |
| ps_slice_hdr->i1_slice_cr_qp_offset = 0; |
| } |
| else /* only noisy regions have lower Chroma QP rating */ |
| { |
| ps_slice_hdr->i1_slice_cb_qp_offset = -2; |
| ps_slice_hdr->i1_slice_cr_qp_offset = -2; |
| } |
| |
| if(ps_pps->i1_deblocking_filter_control_present_flag) |
| { |
| ps_slice_hdr->i1_deblocking_filter_override_flag = 0; |
| |
| if(ps_pps->i1_deblocking_filter_override_enabled_flag) |
| { |
| /* deblocking_filter_override_flag */ |
| ps_slice_hdr->i1_deblocking_filter_override_flag = 0; |
| } |
| |
| if(ps_slice_hdr->i1_deblocking_filter_override_flag) |
| { |
| /* slice_disable_deblocking_filter_flag */ |
| ps_slice_hdr->i1_slice_disable_deblocking_filter_flag = DISABLE_DEBLOCKING_FLAG; |
| |
| if(!ps_slice_hdr->i1_slice_disable_deblocking_filter_flag) |
| { |
| /* beta_offset_div2 */ |
| ps_slice_hdr->i1_beta_offset_div2 = 0; |
| |
| /* tc_offset_div2 */ |
| ps_slice_hdr->i1_tc_offset_div2 = 0; |
| } |
| } |
| } |
| |
| disable_deblocking_filter_flag = ps_slice_hdr->i1_slice_disable_deblocking_filter_flag | |
| ps_pps->i1_pic_disable_deblocking_filter_flag; |
| |
| if(ps_pps->i1_loop_filter_across_slices_enabled_flag && |
| (ps_slice_hdr->i1_slice_sao_luma_flag || ps_slice_hdr->i1_slice_sao_chroma_flag || |
| !disable_deblocking_filter_flag)) |
| { |
| /* slice_loop_filter_across_slices_enabled_flag */ |
| ps_slice_hdr->i1_slice_loop_filter_across_slices_enabled_flag = 1; |
| } |
| } |
| |
| if(1 == ps_pps->i1_entropy_coding_sync_enabled_flag) |
| { |
| /* num_entry_point_offsets, same as NUM of ctb rows to enable entropy sync at start of every CTB */ |
| ps_slice_hdr->i4_num_entry_point_offsets = ps_sps->i2_pic_ht_in_ctb - 1; |
| |
| if(ps_slice_hdr->i4_num_entry_point_offsets > 0) |
| { |
| /* generate offset_len here */ |
| /* fixing the offset lenght assuming 4kx2k is log2(w * h / num_ctb_row) = 20*/ |
| ps_slice_hdr->i1_offset_len = 24; |
| } |
| } |
| else |
| { |
| ps_slice_hdr->i4_num_entry_point_offsets = 0; |
| ps_slice_hdr->i1_offset_len = 0; |
| } |
| |
| /* slice_header_extension_present_flag not supported */ |
| //if(ps_pps->i1_slice_header_extension_present_flag) |
| { |
| /* slice_header_extension_length */ |
| ps_slice_hdr->i2_slice_header_extension_length = 0; |
| |
| for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++) |
| { |
| /* slice_header_extension_data_byte[i] */ |
| } |
| } |
| |
| /* TODO : hard coding ref pix set for now */ |
| /* Need to update this once the ref pics are known from lap output */ |
| |
| /* NOTE */ |
| /* inter ref pic prediction is too much of logic for few bit savings*/ |
| /* at slice header level this is not supported by the encoder */ |
| ps_slice_hdr->s_stref_picset.i1_inter_ref_pic_set_prediction_flag = 0; |
| |
| /* hardcoding 1 ref pic for now ..... will be updated base on lap output */ |
| ps_slice_hdr->s_stref_picset.i1_num_delta_pocs = 1; |
| ps_slice_hdr->s_stref_picset.i1_num_neg_pics = 1; |
| ps_slice_hdr->s_stref_picset.i1_num_pos_pics = 0; |
| |
| memset( |
| ps_slice_hdr->s_stref_picset.ai2_delta_poc, |
| 0, |
| MAX_DPB_SIZE * sizeof(*ps_slice_hdr->s_stref_picset.ai2_delta_poc)); |
| ps_slice_hdr->s_stref_picset.ai2_delta_poc[0] = 1; |
| |
| return return_status; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Insert entry point offset |
| * |
| * @par Description |
| * Insert entry point offset in slice header after frame processing is done 7.3.5.1 |
| * |
| * @param[inout] ps_bitstrm |
| * pointer to bitstream context for generating slice header |
| * |
| * @param[in] i1_nal_unit_type |
| * nal unit type |
| * |
| * @param[in] ps_slice_hdr |
| * pointer to slice header params |
| * |
| * @param[in] ps_pps |
| * pointer to pps params referred by slice |
| * |
| * @param[in] ps_sps |
| * pointer to sps params referred by slice |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_insert_entry_offset_slice_header( |
| bitstrm_t *ps_bitstrm, |
| slice_header_t *ps_slice_hdr, |
| pps_t *ps_pps, |
| UWORD32 u4_first_slice_start_offset) |
| { |
| WORD32 i; |
| WORD32 return_status = IHEVCE_SUCCESS; |
| UWORD32 max_offset = 0, offset_len = 0, num_bytes_shift = 0; |
| /*entire slice data has to be shifted*/ |
| num_bytes_shift = |
| ps_slice_hdr->pu4_entry_point_offset[ps_slice_hdr->i4_num_entry_point_offsets + 1] - |
| ps_slice_hdr->pu4_entry_point_offset[0]; |
| /*generate relative offset*/ |
| for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++) |
| { |
| ps_slice_hdr->pu4_entry_point_offset[i] = |
| ps_slice_hdr->pu4_entry_point_offset[i + 1] - ps_slice_hdr->pu4_entry_point_offset[i]; |
| if(ps_slice_hdr->pu4_entry_point_offset[i] > (WORD32)max_offset) |
| { |
| max_offset = ps_slice_hdr->pu4_entry_point_offset[i]; |
| } |
| } |
| while(1) |
| { |
| if(max_offset & 0x80000000) |
| { |
| break; |
| } |
| max_offset <<= 1; |
| offset_len++; |
| } |
| offset_len = 32 - offset_len; |
| ps_slice_hdr->i1_offset_len = offset_len; |
| |
| if(ps_slice_hdr->i4_num_entry_point_offsets > 0) |
| { |
| /* offset_len_minus1 */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i1_offset_len - 1, return_status); |
| ENTROPY_TRACE("offset_len_minus1", ps_slice_hdr->i1_offset_len - 1); |
| } |
| |
| for(i = 0; i < ps_slice_hdr->i4_num_entry_point_offsets; i++) |
| { |
| /* entry_point_offset[i] */ |
| /* entry point offset minus1 is indicated in 10.0 */ |
| PUT_BITS( |
| ps_bitstrm, |
| ps_slice_hdr->pu4_entry_point_offset[i] - 1, |
| ps_slice_hdr->i1_offset_len, |
| return_status); |
| ENTROPY_TRACE("entry_point_offset[i]", ps_slice_hdr->pu4_entry_point_offset[i]); |
| } |
| |
| if(ps_pps->i1_slice_header_extension_present_flag) |
| { |
| /* slice_header_extension_length */ |
| PUT_BITS_UEV(ps_bitstrm, ps_slice_hdr->i2_slice_header_extension_length, return_status); |
| ENTROPY_TRACE( |
| "slice_header_extension_length", ps_slice_hdr->i2_slice_header_extension_length); |
| /*calculate slice header extension length to fill in the gap*/ |
| |
| for(i = 0; i < ps_slice_hdr->i2_slice_header_extension_length; i++) |
| { |
| /* slice_header_extension_data_byte[i] */ |
| PUT_BITS(ps_bitstrm, 0xFF, 8, return_status); |
| ENTROPY_TRACE("slice_header_extension_data_byte[i]", 0); |
| } |
| } |
| |
| BYTE_ALIGNMENT(ps_bitstrm); |
| |
| ASSERT(num_bytes_shift > 0); |
| /* copy the bitstream to point where header data has ended*/ |
| memmove( |
| (UWORD8 *)(ps_bitstrm->pu1_strm_buffer + ps_bitstrm->u4_strm_buf_offset), |
| (UWORD8 *)(ps_bitstrm->pu1_strm_buffer + u4_first_slice_start_offset), |
| num_bytes_shift); |
| |
| /*send feedback of actual bytes generated*/ |
| ps_bitstrm->u4_strm_buf_offset += num_bytes_shift; |
| |
| //ASSERT(ps_bitstrm->u4_strm_buf_offset == u4_first_slice_start_offset); |
| return return_status; |
| } |
