| /****************************************************************************** |
| * |
| * 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_entropy_cod.c |
| * |
| * \brief |
| * This file contains interface function definitions related to Entroy coding |
| * |
| * \date |
| * 18/09/2012 |
| * |
| * \author |
| * Ittiam |
| * |
| * List of Functions |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| /*****************************************************************************/ |
| /* 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_hle_interface.h" |
| #include "ihevce_hle_q_func.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_entropy_structs.h" |
| #include "ihevce_entropy_interface.h" |
| #include "ihevce_rc_enc_structs.h" |
| #include "ihevce_rc_interface.h" |
| #include "ihevce_encode_header.h" |
| #include "ihevce_encode_header_sei_vui.h" |
| #include "ihevce_trace.h" |
| |
| #include "cast_types.h" |
| #include "osal.h" |
| #include "osal_defaults.h" |
| |
| /*****************************************************************************/ |
| /* Extern variables */ |
| /*****************************************************************************/ |
| UWORD8 gau1_pic_type_string[5][11] = { |
| { "I-SLICE " }, { "P-SLICE " }, { "B-SLICE " }, { "IDR-SLICE" }, { "b-SLICE " } |
| }; |
| |
| /*****************************************************************************/ |
| /* Function Macros */ |
| /*****************************************************************************/ |
| #define PSNR_FROM_MSE(x, bit_depth) \ |
| ((x == 0) ? 99.999999 : (20 * log10(((1 << bit_depth) - 1) / sqrt(x)))) |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_ent_coding_thrd \endif |
| * |
| * \brief |
| * Entropy coding thread interface function |
| * |
| * \param[in] Frame process pointer |
| * |
| * \return |
| * None |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| WORD32 ihevce_ent_coding_thrd(void *pv_frm_proc_thrd_ctxt) |
| { |
| /* local variabels */ |
| frm_proc_thrd_ctxt_t *ps_thrd_ctxt; |
| enc_ctxt_t *ps_enc_ctxt; |
| WORD32 i4_thrd_id; |
| ihevce_hle_ctxt_t *ps_hle_ctxt; |
| WORD32 end_flag; |
| WORD32 out_buf_id; |
| WORD32 inp_buf_id; |
| WORD32 entropy_error = 0; |
| WORD32 i4_bitrate_instance_num, i4_resolution_id, i4_out_res_id; |
| WORD32 i4_bufque_id; |
| UWORD32 u4_encode_frm_num = 0; |
| UWORD32 u4_au_cpb_removal_delay_minus1 = 0; |
| WORD32 i4_no_output = 0; |
| WORD32 i4_do_entr_last = 1; |
| WORD32 i4_use_dummy_buffer = 0; |
| void *pv_entropy_hdl; |
| entropy_context_t *ps_entropy_ctxt; |
| |
| iv_output_data_buffs_t *ps_curr_out = NULL; |
| frm_proc_ent_cod_ctxt_t *ps_curr_inp = NULL; |
| iv_output_data_buffs_t s_curr_out_dummy; |
| |
| /* derive local variables */ |
| ps_thrd_ctxt = (frm_proc_thrd_ctxt_t *)pv_frm_proc_thrd_ctxt; |
| i4_thrd_id = ps_thrd_ctxt->i4_thrd_id; |
| ps_hle_ctxt = (ihevce_hle_ctxt_t *)ps_thrd_ctxt->ps_hle_ctxt; |
| ps_enc_ctxt = (enc_ctxt_t *)ps_thrd_ctxt->pv_enc_ctxt; |
| end_flag = 0; |
| i4_bitrate_instance_num = i4_thrd_id; |
| i4_bufque_id = i4_thrd_id; |
| i4_resolution_id = ps_enc_ctxt->i4_resolution_id; |
| i4_out_res_id = i4_resolution_id; |
| |
| /*swaping of buf_id for 0th and reference bitrate location, as encoder |
| assumes always 0th loc for reference bitrate and app must receive in |
| the configured order*/ |
| i4_bufque_id = i4_bitrate_instance_num; |
| if(i4_bitrate_instance_num == 0) |
| { |
| i4_bufque_id = ps_enc_ctxt->i4_ref_mbr_id; |
| } |
| else if(i4_bitrate_instance_num == ps_enc_ctxt->i4_ref_mbr_id) |
| { |
| i4_bufque_id = 0; |
| } |
| |
| if(1 == ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms.i4_mres_single_out) |
| { |
| i4_bufque_id = 0; |
| i4_out_res_id = 0; |
| } |
| pv_entropy_hdl = ps_enc_ctxt->s_module_ctxt.apv_ent_cod_ctxt[i4_bitrate_instance_num]; |
| ps_entropy_ctxt = (entropy_context_t *)pv_entropy_hdl; |
| /* ---------- Processing Loop until end command is recieved --------- */ |
| while(0 == end_flag) |
| { |
| /*Get a buffer pointer*/ |
| /* ------- get next input buffer from Frame buffer que ---------- */ |
| ps_curr_inp = (frm_proc_ent_cod_ctxt_t *)ihevce_q_get_filled_buff( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_FRM_PRS_ENT_COD_Q + i4_bitrate_instance_num), |
| &inp_buf_id, |
| BUFF_QUE_BLOCKING_MODE); |
| if(1 == ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms.i4_mres_single_out) |
| { |
| if(1 == ps_curr_inp->i4_out_flush_flag) |
| { |
| if(1 == ps_enc_ctxt->s_multi_thrd.pi4_active_res_id[i4_resolution_id]) |
| ps_enc_ctxt->s_multi_thrd.pi4_active_res_id[i4_resolution_id] = 0; |
| else |
| ASSERT(0); |
| } |
| else |
| { |
| if(0 == ps_enc_ctxt->s_multi_thrd.pi4_active_res_id[i4_resolution_id]) |
| { |
| /* During change in resolution check whether prev res is active before starting to dump new resolution */ |
| WORD32 other_res_active = 1; |
| WORD32 ctr; |
| volatile WORD32 *pi4_active_res_check; |
| pi4_active_res_check = ps_enc_ctxt->s_multi_thrd.pi4_active_res_id; |
| while(other_res_active) |
| { |
| /* Continue in polling mode untill all the other resolutions are in passive mode */ |
| other_res_active = 0; |
| for(ctr = 0; |
| ctr < ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms.i4_num_res_layers; |
| ctr++) |
| { |
| if(ctr != i4_resolution_id) |
| { |
| /* Check whether any resolution other than current resolution is active */ |
| /* If its active it means that previous resolution has not finished entropy */ |
| /* Wait for it to finish entropy*/ |
| other_res_active |= pi4_active_res_check[ctr]; |
| } |
| } |
| if(1 == ps_curr_inp->i4_end_flag) |
| { |
| i4_no_output = 1; |
| } |
| } |
| |
| if(0 == ps_curr_inp->i4_end_flag) |
| { |
| ps_enc_ctxt->s_multi_thrd.pi4_active_res_id[i4_resolution_id] = 1; |
| } |
| } |
| } |
| } |
| if(0 == ps_curr_inp->i4_out_flush_flag) |
| { |
| if(1 == i4_no_output) |
| { |
| ps_curr_out = NULL; |
| } |
| else |
| { |
| if(!i4_use_dummy_buffer) |
| { |
| /* ------- get a filled descriptor from output Que ------------ */ |
| ps_curr_out = (iv_output_data_buffs_t *)ihevce_q_get_filled_buff( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_OUTPUT_DATA_Q + i4_bufque_id), |
| &out_buf_id, |
| BUFF_QUE_BLOCKING_MODE); |
| } |
| else |
| { |
| ps_curr_out = &s_curr_out_dummy; |
| out_buf_id = 0; |
| ps_curr_out->i4_bitstream_buf_size = ps_entropy_ctxt->i4_bitstream_buf_size; |
| ps_curr_out->pv_bitstream_bufs = ps_entropy_ctxt->pv_dummy_out_buf; |
| } |
| } |
| } |
| |
| PROFILE_START( |
| &ps_hle_ctxt->profile_entropy[ps_enc_ctxt->i4_resolution_id][i4_bitrate_instance_num]); |
| /* Content Light Level Information */ |
| { |
| ps_curr_inp->s_sei.i1_sei_cll_enable = |
| (WORD8)ps_enc_ctxt->ps_stat_prms->s_out_strm_prms.i4_sei_cll_enable; |
| ps_curr_inp->s_sei.s_cll_info_sei_params.u2_sei_max_cll = |
| ps_enc_ctxt->ps_stat_prms->s_out_strm_prms.u2_sei_max_cll; |
| ps_curr_inp->s_sei.s_cll_info_sei_params.u2_sei_avg_cll = |
| ps_enc_ctxt->ps_stat_prms->s_out_strm_prms.u2_sei_avg_cll; |
| } |
| if((NULL != ps_curr_out) && (NULL != ps_curr_inp)) |
| |
| { |
| WORD32 i; |
| |
| /*PIC_INFO: reset the pic-level info flags*/ |
| ps_curr_inp->s_pic_level_info.i8_total_cu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_intra_cu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_inter_cu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_skip_cu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_pu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_intra_pu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_non_skipped_inter_pu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_merge_pu = 0; |
| for(i = 0; i < 4; i++) |
| { |
| ps_curr_inp->s_pic_level_info.i8_total_cu_based_on_size[i] = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_2nx2n_intra_pu[i] = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_2nx2n_inter_pu[i] = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_tu_based_on_size[i] = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_smp_inter_pu[i] = 0; |
| if(i != 3) |
| { |
| ps_curr_inp->s_pic_level_info.i8_total_amp_inter_pu[i] = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_nxn_inter_pu[i] = 0; |
| } |
| } |
| |
| ps_curr_inp->s_pic_level_info.i8_total_nxn_intra_pu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_L0_mode = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_L1_mode = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_BI_mode = 0; |
| //ps_curr_inp->s_pic_level_info.u4_frame_intra_sad = ps_enc_ctxt->u4 |
| for(i = 0; i < MAX_DPB_SIZE; i++) |
| { |
| ps_curr_inp->s_pic_level_info.i8_total_L0_ref_idx[i] = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_L1_ref_idx[i] = 0; |
| } |
| |
| ps_curr_inp->s_pic_level_info.i8_total_tu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_non_coded_tu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_intra_coded_tu = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_inter_coded_tu = 0; |
| |
| ps_curr_inp->s_pic_level_info.i8_total_qp = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_qp_min_cu = 0; |
| ps_curr_inp->s_pic_level_info.i4_min_qp = 100; |
| ps_curr_inp->s_pic_level_info.i4_max_qp = 0; |
| ps_curr_inp->s_pic_level_info.i4_max_frame_qp = 0; |
| |
| ps_curr_inp->s_pic_level_info.i8_sum_squared_frame_qp = 0; |
| ps_curr_inp->s_pic_level_info.i8_total_frame_qp = 0; |
| ps_curr_inp->s_pic_level_info.f_total_buffer_underflow = 0; |
| ps_curr_inp->s_pic_level_info.f_total_buffer_overflow = 0; |
| ps_curr_inp->s_pic_level_info.f_max_buffer_underflow = 0; |
| ps_curr_inp->s_pic_level_info.f_max_buffer_overflow = 0; |
| |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_intra = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_inter = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_slice_header = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_sao = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_split_cu_flag = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_cu_hdr_bits = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_split_tu_flag = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_qp_delta_bits = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_cbf_luma_bits = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_cbf_chroma_bits = 0; |
| |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_res_luma_bits = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_res_chroma_bits = 0; |
| |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_ref_id = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_mvd = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_merge_flag = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_mpm_luma = 0; |
| ps_curr_inp->s_pic_level_info.u8_bits_estimated_mpm_chroma = 0; |
| |
| if(1 == ps_curr_inp->i4_frm_proc_valid_flag) |
| { |
| /* --- Init of buffering period and pic timing SEI related params ----*/ |
| { |
| UWORD32 i4_dbf, i4_buffersize, i4_trgt_bit_rate; |
| if(ps_enc_ctxt->ps_stat_prms->s_config_prms.i4_rate_control_mode != 3) |
| { |
| ihevce_get_dbf_buffer_size( |
| (void *)ps_enc_ctxt->s_module_ctxt.apv_rc_ctxt[i4_bitrate_instance_num], |
| &i4_buffersize, |
| &i4_dbf, |
| &i4_trgt_bit_rate); |
| } |
| else |
| { |
| /* Default initializations in CQP mode */ |
| WORD32 codec_level = |
| ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms.as_tgt_params[0] |
| .i4_codec_level; |
| WORD32 codec_level_index = ihevce_get_level_index(codec_level); |
| |
| i4_buffersize = |
| (UWORD32)g_as_level_data[codec_level_index].i4_max_cpb[HIGH_TIER]; |
| i4_trgt_bit_rate = |
| (UWORD32)g_as_level_data[codec_level_index].i4_max_bit_rate[HIGH_TIER]; |
| i4_dbf = i4_buffersize; |
| } |
| |
| ps_curr_inp->s_sei.s_buf_period_sei_params.u4_buffer_size_sei = i4_buffersize; |
| ps_curr_inp->s_sei.s_buf_period_sei_params.u4_dbf_sei = i4_dbf; |
| ps_curr_inp->s_sei.s_buf_period_sei_params.u4_target_bit_rate_sei = |
| i4_trgt_bit_rate; |
| |
| /* ----------------- Derivation of u4_au_cpb_removal_delay_minus1 --------------------------------*/ |
| ps_curr_inp->s_sei.s_pic_timing_sei_params.u4_au_cpb_removal_delay_minus1 = |
| u4_au_cpb_removal_delay_minus1; |
| |
| /* ----------------- Derivation of u4_pic_dpb_output_delay --------------------------------*/ |
| ps_curr_inp->s_sei.s_pic_timing_sei_params.u4_pic_dpb_output_delay = |
| ps_curr_inp->ps_sps->ai1_sps_max_num_reorder_pics[0] + |
| ps_curr_inp->i4_display_num - u4_encode_frm_num; |
| } |
| /* call the core entropy coding entry point function */ |
| entropy_error = ihevce_entropy_encode_frame( |
| pv_entropy_hdl, ps_curr_out, ps_curr_inp, ps_curr_out->i4_bitstream_buf_size); |
| |
| /* ----------------- Derivation of u4_au_cpb_removal_delay_minus1 --------------------------------*/ |
| if(ps_curr_inp->s_sei.i1_buf_period_params_present_flag) |
| { |
| /* Reset u4_au_cpb_removal_delay_minus1 after every buffering period as subsequent pictiming is w.r.t new buffering period SEI */ |
| u4_au_cpb_removal_delay_minus1 = 0; |
| } |
| else |
| { |
| /* cpb delay is circularly incremented with wrap around based on max length signalled in VUI */ |
| UWORD8 u1_au_cpb_removal_delay_length = |
| ps_curr_inp->ps_sps->s_vui_parameters.s_vui_hrd_parameters |
| .u1_au_cpb_removal_delay_length_minus1 + |
| 1; |
| |
| UWORD32 u4_max_cpb_removal_delay_val = |
| (1 << u1_au_cpb_removal_delay_length) - 1; |
| |
| u4_au_cpb_removal_delay_minus1 = (u4_au_cpb_removal_delay_minus1 + 1) & |
| u4_max_cpb_removal_delay_val; |
| } |
| /* Debug prints for entropy error */ |
| if(entropy_error) |
| { |
| DBG_PRINTF("Entropy encode error %x\n", entropy_error); |
| DEBUG("Entropy encode error %d\n", entropy_error); |
| } |
| if(ps_enc_ctxt->ps_stat_prms->s_config_prms.i4_rate_control_mode != 3) |
| { |
| /* acquire mutex lock for rate control calls */ |
| osal_mutex_lock(ps_enc_ctxt->pv_rc_mutex_lock_hdl); |
| |
| /* get frame rate/bit rate/max buffer size */ |
| ihevce_vbv_compliance_frame_level_update( |
| ps_enc_ctxt->s_module_ctxt.apv_rc_ctxt[i4_bitrate_instance_num], |
| (ps_curr_out->i4_bytes_generated << 3), |
| i4_resolution_id, |
| i4_bitrate_instance_num, |
| ps_curr_inp->s_sei.s_pic_timing_sei_params.u4_au_cpb_removal_delay_minus1); |
| /* release mutex lock after rate control calls */ |
| osal_mutex_unlock(ps_enc_ctxt->pv_rc_mutex_lock_hdl); |
| } |
| |
| /*correct the mismatch between rdopt and entropy thread mismatch*/ |
| { |
| /* acquire mutex lock for rate control calls */ |
| osal_mutex_lock(ps_enc_ctxt->pv_rc_mutex_lock_hdl); |
| |
| /*Set to -1 when no change in bitrate, other-wise set to encoder bufferfullness at that moment*/ |
| ps_curr_out->i8_cur_vbv_level = ps_curr_inp->i8_buf_level_bitrate_change; |
| if(ps_curr_inp->i8_buf_level_bitrate_change != -1) |
| { |
| LWORD64 bitrate, buffer_size; |
| ASSERT( |
| i4_bitrate_instance_num == |
| 0); //since dynamic change in bitrate is not supported in multi bitrate and resolution |
| get_avg_bitrate_bufsize( |
| ps_enc_ctxt->s_module_ctxt.apv_rc_ctxt[i4_bitrate_instance_num], |
| &bitrate, |
| &buffer_size); |
| |
| change_bitrate_vbv_complaince( |
| ps_enc_ctxt->s_module_ctxt.apv_rc_ctxt[i4_bitrate_instance_num], |
| bitrate, |
| buffer_size); |
| /*Change bitrate in SEI-VUI related context as well*/ |
| ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms |
| .as_tgt_params[ps_enc_ctxt->i4_resolution_id] |
| .ai4_tgt_bitrate[i4_bitrate_instance_num] = (WORD32)bitrate; |
| ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms |
| .as_tgt_params[ps_enc_ctxt->i4_resolution_id] |
| .ai4_max_vbv_buffer_size[i4_bitrate_instance_num] = (WORD32)buffer_size; |
| } |
| /*account for error to meet bitrate more precisely*/ |
| ihevce_rc_rdopt_entropy_bit_correct( |
| ps_enc_ctxt->s_module_ctxt.apv_rc_ctxt[i4_bitrate_instance_num], |
| (ps_curr_out->i4_bytes_generated << 3), |
| inp_buf_id); //ps_curr_inp->i4_inp_timestamp_low |
| |
| /* release mutex lock after rate control calls */ |
| osal_mutex_unlock(ps_enc_ctxt->pv_rc_mutex_lock_hdl); |
| } |
| u4_encode_frm_num++; |
| } |
| else |
| { |
| ps_curr_out->i4_bytes_generated = 0; |
| ps_curr_out->i4_encoded_frame_type = IV_NA_FRAME; |
| } |
| |
| ps_curr_out->i4_buf_id = out_buf_id; |
| end_flag = ps_curr_inp->i4_end_flag; |
| ps_curr_out->i4_end_flag = ps_curr_inp->i4_end_flag; |
| |
| if(1 == ps_enc_ctxt->s_multi_thrd.i4_force_end_flag) |
| { |
| end_flag = 1; |
| ps_curr_out->i4_end_flag = 1; |
| } |
| if(!i4_use_dummy_buffer) |
| { |
| /* Call back to Apln. saying buffer is produced */ |
| ps_hle_ctxt->ihevce_output_strm_fill_done( |
| ps_hle_ctxt->pv_out_cb_handle, |
| ps_curr_out, |
| i4_bufque_id, /* br intance */ |
| i4_out_res_id /* res_instance*/); |
| } |
| |
| if(ps_curr_inp->i4_frm_proc_valid_flag) |
| { |
| ps_curr_inp->s_pic_level_info.u8_total_bits_generated = |
| ps_curr_out->i4_bytes_generated * 8; |
| } |
| |
| /* --- release the current output buffer ---- */ |
| if(!i4_use_dummy_buffer) |
| { |
| ihevce_q_rel_buf( |
| (void *)ps_enc_ctxt, (IHEVCE_OUTPUT_DATA_Q + i4_bufque_id), out_buf_id); |
| } |
| |
| /* release the input buffer*/ |
| ihevce_q_rel_buf( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_FRM_PRS_ENT_COD_Q + i4_bitrate_instance_num), |
| inp_buf_id); |
| |
| /* reset the pointers to NULL */ |
| ps_curr_inp = NULL; |
| ps_curr_out = NULL; |
| } |
| else |
| { |
| end_flag = ps_curr_inp->i4_end_flag; |
| if(NULL != ps_curr_inp) |
| { |
| /* release the input buffer*/ |
| ihevce_q_rel_buf( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_FRM_PRS_ENT_COD_Q + i4_bitrate_instance_num), |
| inp_buf_id); |
| } |
| |
| // ASSERT(0); |
| } |
| PROFILE_STOP( |
| &ps_hle_ctxt->profile_entropy[ps_enc_ctxt->i4_resolution_id][i4_bitrate_instance_num], |
| NULL); |
| } |
| |
| /* Release all the buffers the application might have queued in */ |
| /* Do this only if its not a force end */ |
| if(1 != ps_enc_ctxt->s_multi_thrd.i4_force_end_flag) |
| { |
| end_flag = 0; |
| } |
| if(1 == ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms.i4_mres_single_out) |
| { |
| ps_enc_ctxt->ps_stat_prms->i4_outbuf_buf_free_control = 1; |
| i4_do_entr_last = ps_enc_ctxt->s_multi_thrd.pi4_active_res_id[i4_resolution_id]; |
| } |
| else |
| { |
| i4_do_entr_last = 1; |
| } |
| |
| if((1 == i4_do_entr_last) && (!i4_use_dummy_buffer)) |
| { |
| while(0 == end_flag) |
| { |
| if(1 == ps_enc_ctxt->ps_stat_prms->i4_outbuf_buf_free_control) //FFMPEG application |
| { |
| /* ------- get a filled descriptor from output Que ------------ */ |
| ps_curr_out = (iv_output_data_buffs_t *)ihevce_q_get_filled_buff( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_OUTPUT_DATA_Q + i4_bufque_id), |
| &out_buf_id, |
| BUFF_QUE_NON_BLOCKING_MODE); |
| |
| /* Update the end_flag from application */ |
| end_flag = (ps_curr_out == NULL); |
| } |
| else if( |
| 0 == ps_enc_ctxt->ps_stat_prms |
| ->i4_outbuf_buf_free_control) // process call control based application |
| { |
| ps_curr_out = (iv_output_data_buffs_t *)ihevce_q_get_filled_buff( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_OUTPUT_DATA_Q + i4_bufque_id), |
| &out_buf_id, |
| BUFF_QUE_BLOCKING_MODE); |
| } |
| else |
| { |
| /* should not enter here */ |
| ASSERT(0); |
| } |
| |
| if(ps_curr_out) |
| { |
| end_flag = ps_curr_out->i4_is_last_buf; |
| |
| /* Fill the min. necessory things */ |
| ps_curr_out->i4_process_ret_sts = IV_SUCCESS; |
| ps_curr_out->i4_end_flag = 1; |
| ps_curr_out->i4_bytes_generated = 0; |
| |
| /* Call back to Apln. saying buffer is produced */ |
| ps_hle_ctxt->ihevce_output_strm_fill_done( |
| ps_hle_ctxt->pv_out_cb_handle, |
| ps_curr_out, |
| i4_bufque_id, /* br intance */ |
| i4_out_res_id /* res_instance*/); |
| |
| /* --- release the current output buffer ---- */ |
| ihevce_q_rel_buf( |
| (void *)ps_enc_ctxt, (IHEVCE_OUTPUT_DATA_Q + i4_bufque_id), out_buf_id); |
| } |
| } |
| } |
| if(1 == ps_enc_ctxt->ps_stat_prms->s_tgt_lyr_prms.i4_mres_single_out) |
| { |
| /* Mres single out usecase: Set active res_id to zero for curretn res so that other resolutions exit entropy */ |
| ps_enc_ctxt->s_multi_thrd.pi4_active_res_id[i4_resolution_id] = 0; |
| } |
| |
| return (0); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Generate sps, pps and vps header for |
| * |
| * @par Description |
| * This function generates nal headers like SPS/PPS/VPS |
| * |
| * @param[in] ps_hle_ctxt |
| * pointer to high level interface context (handle) |
| * |
| * @param[in] i4_bitrate_instance_id |
| * bitrate id |
| * |
| * @param[in] i4_resolution_id |
| * resolution id |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_encode_header( |
| ihevce_hle_ctxt_t *ps_hle_ctxt, WORD32 i4_bitrate_instance_id, WORD32 i4_resolution_id) |
| { |
| WORD32 ret = IHEVCE_SUCCESS; |
| bitstrm_t s_bit_strm; |
| bitstrm_t *ps_bitstrm = &s_bit_strm; |
| enc_ctxt_t *ps_enc_ctxt; |
| ihevce_tgt_layer_params_t *ps_tgt_lyr_prms; |
| sps_t *ps_sps; |
| vps_t *ps_vps; |
| pps_t *ps_pps; |
| iv_output_data_buffs_t *ps_curr_out = NULL; |
| WORD32 out_buf_id; |
| |
| /* sanity checks */ |
| if((ps_hle_ctxt == NULL) || (ps_hle_ctxt->i4_size != sizeof(ihevce_hle_ctxt_t)) || |
| ps_hle_ctxt->i4_hle_init_done != 1) |
| return IHEVCE_FAIL; |
| |
| ps_tgt_lyr_prms = (ihevce_tgt_layer_params_t *)&ps_hle_ctxt->ps_static_cfg_prms->s_tgt_lyr_prms; |
| |
| if(i4_resolution_id >= ps_tgt_lyr_prms->i4_num_res_layers) |
| return IHEVCE_FAIL; |
| |
| if(i4_bitrate_instance_id >= |
| ps_tgt_lyr_prms->as_tgt_params[i4_resolution_id].i4_num_bitrate_instances) |
| return IHEVCE_FAIL; |
| |
| ps_enc_ctxt = (enc_ctxt_t *)ps_hle_ctxt->apv_enc_hdl[i4_resolution_id]; |
| ps_sps = &ps_enc_ctxt->as_sps[i4_bitrate_instance_id]; |
| ps_vps = &ps_enc_ctxt->as_vps[i4_bitrate_instance_id]; |
| ps_pps = &ps_enc_ctxt->as_pps[i4_bitrate_instance_id]; |
| |
| /* ------- get a filled descriptor from output Que ------------ */ |
| ps_curr_out = (iv_output_data_buffs_t *)ihevce_q_get_filled_buff( |
| (void *)ps_enc_ctxt, |
| (IHEVCE_OUTPUT_DATA_Q + i4_bitrate_instance_id), |
| &out_buf_id, |
| BUFF_QUE_BLOCKING_MODE); |
| |
| /* Initialize the bitstream engine */ |
| ret |= ihevce_bitstrm_init( |
| ps_bitstrm, (UWORD8 *)ps_curr_out->pv_bitstream_bufs, ps_curr_out->i4_bitstream_buf_size); |
| |
| /* Reset Bitstream NAL counter */ |
| ps_bitstrm->i4_num_nal = 0; |
| |
| /* generate vps */ |
| ret |= ihevce_generate_vps(ps_bitstrm, ps_vps); |
| |
| /* generate sps */ |
| ret |= ihevce_generate_sps(ps_bitstrm, ps_sps); |
| |
| /* generate pps */ |
| ret |= ihevce_generate_pps(ps_bitstrm, ps_pps); |
| |
| /* attach the time stamp of the input to output */ |
| ps_curr_out->i4_out_timestamp_low = 0; |
| ps_curr_out->i4_out_timestamp_high = 0; |
| |
| /*attach the app frame info of this buffer */ |
| ps_curr_out->pv_app_frm_ctxt = NULL; |
| |
| /* frame never skipped for now */ |
| ps_curr_out->i4_frame_skipped = 0; |
| |
| /* update error code and return */ |
| ps_curr_out->i4_process_error_code = ret; |
| |
| ps_curr_out->i4_bytes_generated = ps_bitstrm->u4_strm_buf_offset; |
| |
| /* ------------------- Initialize non-VCL prefix NAL Size/offsets --------------------*/ |
| { |
| WORD32 num_non_vcl_prefix_nals = ps_bitstrm->i4_num_nal; |
| WORD32 ctr = 0; |
| |
| ASSERT(num_non_vcl_prefix_nals <= MAX_NUM_PREFIX_NALS_PER_AU); |
| |
| ps_curr_out->i4_num_non_vcl_prefix_nals = num_non_vcl_prefix_nals; |
| for(ctr = 0; ctr < MIN(num_non_vcl_prefix_nals, MAX_NUM_PREFIX_NALS_PER_AU); ctr++) |
| { |
| /* NAL offset is derive by subtracting Bistream base from NAL start pointer */ |
| ULWORD64 u8_cur_nal_start = (ULWORD64)ps_bitstrm->apu1_nal_start[ctr]; |
| |
| #if POPULATE_NAL_SIZE |
| |
| /* ----------Populate NAL Size -------------*/ |
| if((ctr + 1) < num_non_vcl_prefix_nals) |
| { |
| ULWORD64 u8_next_nal_start = (ULWORD64)ps_bitstrm->apu1_nal_start[ctr + 1]; |
| ps_curr_out->ai4_size_non_vcl_prefix_nals[ctr] = |
| (UWORD32)(u8_next_nal_start - u8_cur_nal_start); |
| } |
| else |
| { |
| ULWORD64 u8_next_nal_start = |
| (ULWORD64)ps_bitstrm->pu1_strm_buffer + ps_bitstrm->u4_strm_buf_offset; |
| ps_curr_out->ai4_size_non_vcl_prefix_nals[ctr] = |
| (UWORD32)(u8_next_nal_start - u8_cur_nal_start); |
| } |
| ASSERT(ps_curr_out->ai4_size_non_vcl_prefix_nals[ctr] > 0); |
| |
| #elif POPULATE_NAL_OFFSET |
| |
| /* ----------Populate NAL Offset -------------*/ |
| |
| ASSERT(u8_cur_nal_start >= u8_bitstream_base); |
| ps_curr_out->ai4_off_non_vcl_prefix_nals[ctr] = |
| (UWORD32)(u8_cur_nal_start - u8_bitstream_base); |
| |
| if(ctr) |
| { |
| /* sanity check on increasing NAL offsets */ |
| ASSERT( |
| ps_curr_out->ai4_off_non_vcl_prefix_nals[ctr] > |
| ps_curr_out->ai4_off_non_vcl_prefix_nals[ctr - 1]); |
| } |
| #endif /* POPULATE_NAL_SIZE */ |
| } |
| } |
| |
| ps_curr_out->i4_buf_id = out_buf_id; |
| ps_curr_out->i4_end_flag = 0; |
| if(IHEVCE_SUCCESS == ret) |
| { |
| ps_curr_out->i4_process_ret_sts = IV_SUCCESS; |
| } |
| else |
| { |
| ps_curr_out->i4_process_ret_sts = IV_FAIL; |
| } |
| ps_curr_out->i4_encoded_frame_type = IV_NA_FRAME; |
| |
| /* Call back to Apln. saying buffer is produced */ |
| ps_hle_ctxt->ihevce_output_strm_fill_done( |
| ps_hle_ctxt->pv_out_cb_handle, ps_curr_out, i4_bitrate_instance_id, i4_resolution_id); |
| |
| /* release the input buffer*/ |
| ihevce_q_rel_buf( |
| (void *)ps_enc_ctxt, (IHEVCE_OUTPUT_DATA_Q + i4_bitrate_instance_id), out_buf_id); |
| |
| return ret; |
| } |
