| /****************************************************************************** |
| * |
| * 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_interface.c |
| * |
| * @brief |
| * This file contains function definitions for entropy interface related to |
| * memory init and process apis |
| * |
| * @author |
| * Ittiam |
| * |
| * List of Functions |
| * ihevce_entropy_get_num_mem_recs() |
| * ihevce_entropy_size_of_out_buffer() |
| * ihevce_entropy_get_mem_recs() |
| * ihevce_entropy_init() |
| * ihevce_entropy_encode_frame() |
| * |
| ****************************************************************************** |
| */ |
| |
| /*****************************************************************************/ |
| /* 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_entropy_structs.h" |
| #include "ihevce_entropy_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" |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Number of memory records are returned for entropy module |
| * |
| * @par Description |
| * |
| * @return number of memory records |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_get_num_mem_recs(void) |
| { |
| return (NUM_ENTROPY_MEM_RECS); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Estimated bitstream buffer size basing on input dimensions |
| * |
| * @par Description |
| * |
| * @return bitstream buffer size |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_size_of_out_buffer(frm_proc_ent_cod_ctxt_t *ps_curr_inp) |
| { |
| WORD32 i4_size; |
| |
| i4_size = (WORD32)( |
| ps_curr_inp->ps_sps->i2_pic_height_in_luma_samples * |
| ps_curr_inp->ps_sps->i2_pic_width_in_luma_samples); |
| |
| return (i4_size); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Populates Memory requirements of the entropy module |
| * |
| * @par Description |
| * |
| * @param[inout] ps_mem_tab |
| * pointer to memory descriptors table |
| * |
| * @param[in] ps_init_prms |
| * Create time static parameters |
| * |
| * @param[in] i4_mem_space |
| * memspace in whihc memory request should be done |
| * |
| * @return number of memory requirements filled |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_get_mem_recs( |
| iv_mem_rec_t *ps_mem_tab, |
| ihevce_static_cfg_params_t *ps_init_prms, |
| WORD32 i4_mem_space, |
| WORD32 i4_resolution_id) |
| { |
| /* memories should be requested assuming worst case requirememnts */ |
| WORD32 max_width = ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width; |
| WORD32 max_height = ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height; |
| WORD32 max_align_width = ALIGN64(max_width); |
| WORD32 max_align_height = ALIGN64(max_height); |
| |
| /* Module context structure */ |
| ps_mem_tab[ENTROPY_CTXT].i4_mem_size = sizeof(entropy_context_t); |
| ps_mem_tab[ENTROPY_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space; |
| ps_mem_tab[ENTROPY_CTXT].i4_mem_alignment = 64; |
| |
| /* top row cu skip flags (1 bit per 8x8CU) */ |
| ps_mem_tab[ENTROPY_TOP_SKIP_FLAGS].i4_mem_size = max_align_width >> 6; |
| ps_mem_tab[ENTROPY_TOP_SKIP_FLAGS].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space; |
| ps_mem_tab[ENTROPY_TOP_SKIP_FLAGS].i4_mem_alignment = 64; |
| |
| /* top row CU Depth (1 byte per 8x8CU) */ |
| ps_mem_tab[ENTROPY_TOP_CU_DEPTH].i4_mem_size = (max_align_width >> 3); |
| ps_mem_tab[ENTROPY_TOP_CU_DEPTH].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space; |
| ps_mem_tab[ENTROPY_TOP_CU_DEPTH].i4_mem_alignment = 64; |
| |
| /* Dummy_buffer to handle first pass MBR case*/ |
| ps_mem_tab[ENTROPY_DUMMY_OUT_BUF].i4_mem_size = (max_align_width * max_align_height * 2); |
| ps_mem_tab[ENTROPY_DUMMY_OUT_BUF].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space; |
| ps_mem_tab[ENTROPY_DUMMY_OUT_BUF].i4_mem_alignment = 64; |
| |
| return (NUM_ENTROPY_MEM_RECS); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Intialization of entropy module |
| * |
| * @par Description |
| * pointers of the memory requests done in ihevce_entropy_get_mem_recs() are |
| * used to initialized the entropy module and the handle is returned |
| * |
| * @param[inout] ps_mem_tab |
| * pointer to memory descriptors table |
| * |
| * @param[in] ps_init_prms |
| * Create time static parameters |
| * |
| * @return |
| * Handle of the entropy module returned as void ptr |
| * |
| ****************************************************************************** |
| */ |
| void *ihevce_entropy_init( |
| iv_mem_rec_t *ps_mem_tab, |
| ihevce_static_cfg_params_t *ps_init_prms, |
| void *pv_tile_params_base, |
| WORD32 i4_res_id) |
| { |
| entropy_context_t *ps_entropy_ctxt; |
| |
| /* Entropy state structure */ |
| ps_entropy_ctxt = (entropy_context_t *)ps_mem_tab[ENTROPY_CTXT].pv_base; |
| memset(ps_entropy_ctxt, 0, sizeof(entropy_context_t)); |
| |
| ps_entropy_ctxt->pu1_skip_cu_top = (UWORD8 *)ps_mem_tab[ENTROPY_TOP_SKIP_FLAGS].pv_base; |
| ps_entropy_ctxt->pu1_cu_depth_top = (UWORD8 *)ps_mem_tab[ENTROPY_TOP_CU_DEPTH].pv_base; |
| ps_entropy_ctxt->pv_dummy_out_buf = ps_mem_tab[ENTROPY_DUMMY_OUT_BUF].pv_base; |
| ps_entropy_ctxt->i4_bitstream_buf_size = ps_mem_tab[ENTROPY_DUMMY_OUT_BUF].i4_mem_size; |
| |
| /* perform all one time initialisation here */ |
| /*************************************************************************/ |
| /* Note pu1_cbf_cb, pu1_cbf_cr initialization are done with array idx 1 */ |
| /* This is because these flags are accessed as pu1_cbf_cb[tfr_depth - 1] */ |
| /* without cheking for tfr_depth= 0 */ |
| /*************************************************************************/ |
| ps_entropy_ctxt->apu1_cbf_cb[0] = &ps_entropy_ctxt->au1_cbf_cb[0][1]; |
| ps_entropy_ctxt->apu1_cbf_cr[0] = &ps_entropy_ctxt->au1_cbf_cr[0][1]; |
| ps_entropy_ctxt->apu1_cbf_cb[1] = &ps_entropy_ctxt->au1_cbf_cb[1][1]; |
| ps_entropy_ctxt->apu1_cbf_cr[1] = &ps_entropy_ctxt->au1_cbf_cr[1][1]; |
| |
| memset(ps_entropy_ctxt->au1_cbf_cb, 0, (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8)); |
| |
| /* register codec level */ |
| ps_entropy_ctxt->i4_codec_level = |
| ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_res_id].i4_codec_level; |
| |
| /* Flag to enable/disable insertion of SPS, VPS & PPS at every CRA frame */ |
| ps_entropy_ctxt->i4_sps_at_cdr_enable = ps_init_prms->s_out_strm_prms.i4_sps_at_cdr_enable; |
| |
| /* Store Tile params base into entropy context */ |
| ps_entropy_ctxt->pv_tile_params_base = pv_tile_params_base; |
| |
| ps_entropy_ctxt->pv_sys_api = (void *)&ps_init_prms->s_sys_api; |
| |
| ps_entropy_ctxt->i4_slice_segment_mode = ps_init_prms->s_slice_params.i4_slice_segment_mode; |
| |
| /* Set slice segment length */ |
| if((ps_entropy_ctxt->i4_slice_segment_mode == 1) || |
| (ps_entropy_ctxt->i4_slice_segment_mode == 2)) |
| { |
| ps_entropy_ctxt->i4_slice_segment_max_length = |
| ps_init_prms->s_slice_params.i4_slice_segment_argument; |
| } |
| else |
| { |
| ps_entropy_ctxt->i4_slice_segment_max_length = 0; |
| } |
| |
| /* return the handle to caller */ |
| return ((void *)ps_entropy_ctxt); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief entry point for entropy coding of a frame |
| * |
| * @par Description |
| * This function generates nal headers like SPS/PPS/slice header and call the |
| * slice data entropy coding function |
| * |
| * @param[in] ps_enc_ctxt |
| * pointer to encoder context (handle) |
| * |
| * @param[out] ps_curr_out |
| * pointer to output data buffer context where bitstream is generated |
| * |
| * @param[out] ps_curr_inp |
| * pointer to entropy input params context |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_encode_frame( |
| void *pv_entropy_hdl, |
| iv_output_data_buffs_t *ps_curr_out, |
| frm_proc_ent_cod_ctxt_t *ps_curr_inp, |
| WORD32 i4_out_buf_size) |
| { |
| WORD32 ret = IHEVCE_SUCCESS; |
| WORD32 tile_ctr, total_tiles = 1; |
| entropy_context_t *ps_entropy_ctxt = (entropy_context_t *)pv_entropy_hdl; |
| |
| /* current frame slice type and nal type */ |
| WORD32 slice_type = ps_curr_inp->s_slice_hdr.i1_slice_type; |
| |
| /* current frame slice type and nal type */ |
| WORD32 nal_type = ps_curr_inp->i4_slice_nal_type; |
| |
| /* read vps, sps and pps from input params */ |
| vps_t *ps_vps = ps_curr_inp->ps_vps; |
| sps_t *ps_sps = ps_curr_inp->ps_sps; |
| pps_t *ps_pps = ps_curr_inp->ps_pps; |
| sei_params_t *ps_sei = &ps_curr_inp->s_sei; |
| ihevce_tile_params_t *ps_tile_params_base; |
| WORD32 out_buf_size = i4_out_buf_size; |
| |
| /* Headers are repeated once per IDR. Should be changed to every CRA */ |
| WORD32 insert_vps_sps_pps = |
| ((slice_type == ISLICE) && |
| (((NAL_IDR_N_LP == nal_type) || (NAL_CRA == nal_type)) || (NAL_IDR_W_LP == nal_type))); |
| |
| WORD32 insert_per_cra = |
| ((slice_type == ISLICE) && |
| (((NAL_IDR_N_LP == nal_type) || (NAL_CRA == nal_type)) || (NAL_IDR_W_LP == nal_type))); |
| bitstrm_t *ps_bitstrm = &ps_entropy_ctxt->s_bit_strm; |
| |
| ULWORD64 u8_bits_slice_header_prev; |
| |
| WORD32 i4_slice_segment_max_length_bckp; |
| WORD32 i4_max_num_slices; |
| |
| ihevce_sys_api_t *ps_sys_api = (ihevce_sys_api_t *)ps_entropy_ctxt->pv_sys_api; |
| |
| #if POPULATE_NAL_OFFSET |
| ULWORD64 u8_bitstream_base = (ULWORD64)ps_curr_out->pv_bitstream_bufs; |
| #endif |
| if(0 == ps_entropy_ctxt->i4_sps_at_cdr_enable) |
| { |
| insert_vps_sps_pps = |
| ((slice_type == ISLICE) && ((NAL_IDR_N_LP == nal_type) || (NAL_IDR_W_LP == nal_type))); |
| } |
| /* intialize vps, sps, pps, sei and slice header in entropy context */ |
| ps_entropy_ctxt->ps_vps = ps_vps; |
| ps_entropy_ctxt->ps_sps = ps_sps; |
| ps_entropy_ctxt->ps_pps = ps_pps; |
| ps_entropy_ctxt->ps_sei = ps_sei; |
| ps_entropy_ctxt->ps_slice_hdr = &ps_curr_inp->s_slice_hdr; |
| ps_entropy_ctxt->i4_is_cu_cbf_zero = 1; |
| |
| ps_entropy_ctxt->ps_pic_level_info = &ps_curr_inp->s_pic_level_info; |
| |
| /* intialize the frame level ctb pointer for current slice */ |
| ps_entropy_ctxt->ps_frm_ctb = ps_curr_inp->ps_frm_ctb_data; |
| |
| /* Initiallizing to indicate the start of frame */ |
| ps_entropy_ctxt->i4_next_slice_seg_x = 0; |
| ps_entropy_ctxt->i4_next_slice_seg_y = 0; |
| |
| /* enable the residue encode flag */ |
| ps_entropy_ctxt->i4_enable_res_encode = 1; |
| |
| /* Initialize the bitstream engine */ |
| ret |= ihevce_bitstrm_init(ps_bitstrm, (UWORD8 *)ps_curr_out->pv_bitstream_bufs, out_buf_size); |
| |
| /* Reset Bitstream NAL counter */ |
| ps_bitstrm->i4_num_nal = 0; |
| |
| /*PIC INFO: Store the Bits before slice header is encoded*/ |
| u8_bits_slice_header_prev = (ps_bitstrm->u4_strm_buf_offset * 8); |
| |
| /* generate AUD if enabled from the application */ |
| if(1 == ps_curr_inp->i1_aud_present_flag) |
| { |
| UWORD8 u1_pic_type; |
| |
| switch(slice_type) |
| { |
| case ISLICE: |
| u1_pic_type = 0; |
| break; |
| case PSLICE: |
| u1_pic_type = 1; |
| break; |
| default: |
| u1_pic_type = 2; |
| break; |
| } |
| |
| ret |= ihevce_generate_aud(ps_bitstrm, u1_pic_type); |
| } |
| |
| if(insert_vps_sps_pps) |
| { |
| /* generate vps */ |
| ret |= ihevce_generate_vps(ps_bitstrm, ps_entropy_ctxt->ps_vps); |
| |
| /* generate sps */ |
| ret |= ihevce_generate_sps(ps_bitstrm, ps_entropy_ctxt->ps_sps); |
| |
| /* generate pps */ |
| ret |= ihevce_generate_pps(ps_bitstrm, ps_entropy_ctxt->ps_pps); |
| } |
| |
| /* generate sei */ |
| if(1 == ps_entropy_ctxt->ps_sei->i1_sei_parameters_present_flag) |
| { |
| WORD32 i4_insert_prefix_sei = |
| ps_entropy_ctxt->ps_sei->i1_buf_period_params_present_flag || |
| ps_entropy_ctxt->ps_sei->i1_pic_timing_params_present_flag || |
| ps_entropy_ctxt->ps_sei->i1_recovery_point_params_present_flag || |
| ps_entropy_ctxt->ps_sei->i4_sei_mastering_disp_colour_vol_params_present_flags || |
| ps_curr_inp->u4_num_sei_payload || ps_curr_inp->s_sei.i1_sei_cll_enable; |
| |
| if(i4_insert_prefix_sei) |
| { |
| ret |= ihevce_generate_sei( |
| ps_bitstrm, |
| ps_entropy_ctxt->ps_sei, |
| &ps_entropy_ctxt->ps_sps->s_vui_parameters, |
| insert_per_cra, |
| NAL_PREFIX_SEI, |
| ps_curr_inp->u4_num_sei_payload, |
| &ps_curr_inp->as_sei_payload[0]); |
| } |
| } |
| |
| /*PIC INFO: Populate slice header bits */ |
| ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_slice_header += |
| (ps_bitstrm->u4_strm_buf_offset * 8) - u8_bits_slice_header_prev; |
| |
| ps_tile_params_base = (ihevce_tile_params_t *)ps_entropy_ctxt->pv_tile_params_base; |
| |
| ps_curr_out->i4_bytes_generated = 0; //Init |
| |
| /* ------------------- 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 */ |
| } |
| } |
| |
| total_tiles = ps_tile_params_base->i4_num_tiles; |
| |
| /* frame level NUM slices related params initialisations */ |
| { |
| WORD32 codec_level_index = ihevce_get_level_index(ps_entropy_ctxt->i4_codec_level); |
| |
| i4_max_num_slices = g_as_level_data[codec_level_index].i4_max_slices_per_picture; |
| ps_entropy_ctxt->i4_num_slice_seg = 0; |
| } |
| |
| /* back up slice arg length before pic encoding */ |
| i4_slice_segment_max_length_bckp = ps_entropy_ctxt->i4_slice_segment_max_length; |
| |
| for(tile_ctr = 0; tile_ctr < total_tiles; tile_ctr++) |
| { |
| WORD32 i4_end_of_slice = 0; |
| |
| /* Loop over all the slice segments */ |
| while(0 == i4_end_of_slice) |
| { |
| WORD32 i4_bytes_generated, i4_slice_header_bits; |
| |
| /*PIC INFO: Store the Bits before slice header is encoded*/ |
| u8_bits_slice_header_prev = (ps_bitstrm->u4_strm_buf_offset * 8); |
| |
| /* generate slice header */ |
| ret |= ihevce_generate_slice_header( |
| ps_bitstrm, |
| nal_type, |
| ps_entropy_ctxt->ps_slice_hdr, |
| ps_entropy_ctxt->ps_pps, |
| ps_entropy_ctxt->ps_sps, |
| &ps_entropy_ctxt->s_dup_bit_strm_ent_offset, |
| &ps_entropy_ctxt->s_cabac_ctxt.u4_first_slice_start_offset, |
| (ps_tile_params_base + tile_ctr), |
| ps_entropy_ctxt->i4_next_slice_seg_x, |
| ps_entropy_ctxt->i4_next_slice_seg_y); |
| |
| i4_slice_header_bits = |
| (ps_bitstrm->u4_strm_buf_offset * 8) - (WORD32)u8_bits_slice_header_prev; |
| |
| /* Update slice segment length with bytes in slice header */ |
| if(2 == ps_entropy_ctxt->i4_slice_segment_mode) |
| { |
| ps_entropy_ctxt->i4_slice_seg_len = (i4_slice_header_bits / 8); |
| } |
| else //Initiallize to zero |
| { |
| ps_entropy_ctxt->i4_slice_seg_len = 0; |
| } |
| |
| /*PIC INFO: Populate slice header bits */ |
| ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_slice_header += |
| i4_slice_header_bits; |
| |
| /* check if number of slices generated in is MAX -1 as per codec_level */ |
| if(ps_entropy_ctxt->i4_num_slice_seg == (i4_max_num_slices - 1)) |
| { |
| /* i4_slice_segment_max_length is set to a huge positive value */ |
| /* so that remaining CTBS in the picture gets encoded as a single slice */ |
| ps_entropy_ctxt->i4_slice_segment_max_length = 0x7FFFFFFF; |
| } |
| |
| /* encode the slice data */ |
| ret |= ihevce_encode_slice_data( |
| ps_entropy_ctxt, (ps_tile_params_base + tile_ctr), &i4_end_of_slice); |
| |
| /* increment the number of slices generated */ |
| ps_entropy_ctxt->i4_num_slice_seg++; |
| |
| if(1 == ps_pps->i1_entropy_coding_sync_enabled_flag) |
| { |
| /*after encoding is done each slice offset is available. Enter these offset in slice header*/ |
| ihevce_insert_entry_offset_slice_header( |
| &ps_entropy_ctxt->s_dup_bit_strm_ent_offset, |
| ps_entropy_ctxt->ps_slice_hdr, |
| ps_entropy_ctxt->ps_pps, |
| ps_entropy_ctxt->s_cabac_ctxt.u4_first_slice_start_offset); |
| } |
| |
| /* compute the bytes generated and return */ |
| if(1 == ps_pps->i1_entropy_coding_sync_enabled_flag) |
| { |
| i4_bytes_generated = ps_entropy_ctxt->s_dup_bit_strm_ent_offset.u4_strm_buf_offset; |
| } |
| else |
| { |
| i4_bytes_generated = ps_entropy_ctxt->s_cabac_ctxt.u4_strm_buf_offset; |
| } |
| |
| /* Updating bytes generated and Updating strm_buffer pointer */ |
| ps_curr_out->i4_bytes_generated += i4_bytes_generated; |
| |
| /* Re-Initialize the bitstream engine after each tile or slice */ |
| ihevce_bitstrm_init( |
| ps_bitstrm, (ps_bitstrm->pu1_strm_buffer + i4_bytes_generated), out_buf_size); |
| } |
| } |
| |
| /* Max slices related warning prints based on last slice status */ |
| if(ps_entropy_ctxt->i4_num_slice_seg == i4_max_num_slices) |
| { |
| if(ps_entropy_ctxt->i4_slice_seg_len >= i4_slice_segment_max_length_bckp) |
| { |
| if(1 == ps_entropy_ctxt->i4_slice_segment_mode) |
| { |
| ps_sys_api->ihevce_printf( |
| ps_sys_api->pv_cb_handle, |
| "IHEVCE_WARNING: Last slice contains %d CTBs exceeds %d (Max limit of CTBs " |
| "configured). As per codec_level max number of slices per frame is %d\n", |
| ps_entropy_ctxt->i4_slice_seg_len, |
| i4_slice_segment_max_length_bckp, |
| i4_max_num_slices); |
| } |
| else if(2 == ps_entropy_ctxt->i4_slice_segment_mode) |
| { |
| ps_sys_api->ihevce_printf( |
| ps_sys_api->pv_cb_handle, |
| "IHEVCE_WARNING: Last slice contains %d Bytes exceeds %d (Max limit of Bytes " |
| "configured). As per codec_level max number of slices per frame is %d\n", |
| ps_entropy_ctxt->i4_slice_seg_len, |
| i4_slice_segment_max_length_bckp, |
| i4_max_num_slices); |
| } |
| } |
| } |
| |
| /* restore slice arg length after pic encoding */ |
| ps_entropy_ctxt->i4_slice_segment_max_length = i4_slice_segment_max_length_bckp; |
| |
| /* ---------------------- Initialize VCL NAL Size/offsets ---------------------------*/ |
| { |
| WORD32 vcl_start = ps_curr_out->i4_num_non_vcl_prefix_nals; |
| WORD32 num_vcl_nals = ps_bitstrm->i4_num_nal - vcl_start; |
| WORD32 ctr = 0; |
| |
| ASSERT(num_vcl_nals > 0); |
| ASSERT(num_vcl_nals <= MAX_NUM_VCL_NALS_PER_AU); |
| |
| ps_curr_out->i4_num_vcl_nals = num_vcl_nals; |
| for(ctr = 0; ctr < MIN(num_vcl_nals, MAX_NUM_VCL_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 + vcl_start]; |
| |
| #if POPULATE_NAL_SIZE |
| |
| /* ----------Populate NAL Size -------------*/ |
| if((ctr + 1) < num_vcl_nals) |
| { |
| ULWORD64 u8_next_nal_start = |
| (ULWORD64)ps_bitstrm->apu1_nal_start[ctr + vcl_start + 1]; |
| ps_curr_out->ai4_size_vcl_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_vcl_nals[ctr] = |
| (UWORD32)(u8_next_nal_start - u8_cur_nal_start); |
| } |
| ASSERT(ps_curr_out->ai4_size_vcl_nals[ctr] > 0); |
| |
| #elif POPULATE_NAL_OFFSET |
| |
| /* ----------Populate NAL Offset -------------*/ |
| |
| ASSERT(u8_cur_nal_start >= u8_bitstream_base); |
| ps_curr_out->ai4_off_vcl_nals[ctr] = (UWORD32)(u8_cur_nal_start - u8_bitstream_base); |
| |
| if(ctr) |
| { |
| /* sanity check on increasing NAL offsets */ |
| ASSERT(ps_curr_out->ai4_off_vcl_nals[ctr] > ps_curr_out->ai4_off_vcl_nals[ctr - 1]); |
| } |
| #endif /* POPULATE_NAL_SIZE */ |
| } |
| } |
| |
| /* generate suffix sei */ |
| if(1 == ps_entropy_ctxt->ps_sei->i1_sei_parameters_present_flag) |
| { |
| /* Insert hash SEI */ |
| if(0 != ps_entropy_ctxt->ps_sei->i1_decoded_pic_hash_sei_flag) |
| { |
| ret |= ihevce_generate_sei( |
| ps_bitstrm, |
| ps_entropy_ctxt->ps_sei, |
| &ps_entropy_ctxt->ps_sps->s_vui_parameters, |
| insert_per_cra, |
| NAL_SUFFIX_SEI, |
| ps_curr_inp->u4_num_sei_payload, |
| &ps_curr_inp->as_sei_payload[0]); |
| } |
| |
| /* Updating bytes generated */ |
| ps_curr_out->i4_bytes_generated += ps_bitstrm->u4_strm_buf_offset; |
| } |
| |
| /* generate end of sequence nal */ |
| if((1 == ps_curr_inp->i1_eos_present_flag) && (ps_curr_inp->i4_is_end_of_idr_gop == 1)) |
| { |
| ret |= ihevce_generate_eos(ps_bitstrm); |
| /* Updating bytes generated */ |
| ps_curr_out->i4_bytes_generated += ps_bitstrm->u4_strm_buf_offset; |
| } |
| |
| /* ------------------- Initialize non-VCL suffix NAL Size/offsets -----------------------*/ |
| { |
| WORD32 non_vcl_suffix_start = |
| ps_curr_out->i4_num_non_vcl_prefix_nals + ps_curr_out->i4_num_vcl_nals; |
| WORD32 num_non_vcl_suffix_nals = ps_bitstrm->i4_num_nal - non_vcl_suffix_start; |
| WORD32 ctr = 0; |
| |
| ASSERT(num_non_vcl_suffix_nals >= 0); |
| ASSERT(num_non_vcl_suffix_nals <= MAX_NUM_SUFFIX_NALS_PER_AU); |
| |
| ps_curr_out->i4_num_non_vcl_suffix_nals = num_non_vcl_suffix_nals; |
| for(ctr = 0; ctr < MIN(num_non_vcl_suffix_nals, MAX_NUM_SUFFIX_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 + non_vcl_suffix_start]; |
| |
| #if POPULATE_NAL_SIZE |
| |
| /* ----------Populate NAL Size -------------*/ |
| if((ctr + 1) < num_non_vcl_suffix_nals) |
| { |
| ULWORD64 u8_next_nal_start = |
| (ULWORD64)ps_bitstrm->apu1_nal_start[ctr + non_vcl_suffix_start + 1]; |
| ps_curr_out->ai4_size_non_vcl_suffix_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_suffix_nals[ctr] = |
| (UWORD32)(u8_next_nal_start - u8_cur_nal_start); |
| } |
| ASSERT(ps_curr_out->ai4_size_non_vcl_suffix_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_suffix_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_suffix_nals[ctr] > |
| ps_curr_out->ai4_off_non_vcl_suffix_nals[ctr - 1]); |
| } |
| #endif /* POPULATE_NAL_SIZE */ |
| } |
| } |
| |
| /*PIC INFO: Populatinf Ref POC, weights and offset*/ |
| { |
| WORD32 i; |
| ps_entropy_ctxt->ps_pic_level_info->i1_num_ref_idx_l0_active = |
| ps_entropy_ctxt->ps_slice_hdr->i1_num_ref_idx_l0_active; |
| ps_entropy_ctxt->ps_pic_level_info->i1_num_ref_idx_l1_active = |
| ps_entropy_ctxt->ps_slice_hdr->i1_num_ref_idx_l1_active; |
| for(i = 0; i < ps_entropy_ctxt->ps_slice_hdr->i1_num_ref_idx_l0_active; i++) |
| { |
| ps_entropy_ctxt->ps_pic_level_info->i4_ref_poc_l0[i] = |
| ps_entropy_ctxt->ps_slice_hdr->s_rplm.i4_ref_poc_l0[i]; |
| ps_entropy_ctxt->ps_pic_level_info->i1_list_entry_l0[i] = |
| ps_entropy_ctxt->ps_slice_hdr->s_rplm.i1_list_entry_l0[i]; |
| ps_entropy_ctxt->ps_pic_level_info->i2_luma_weight_l0[i] = |
| (DOUBLE)ps_entropy_ctxt->ps_slice_hdr->s_wt_ofst.i2_luma_weight_l0[i] / |
| (1 << ps_entropy_ctxt->ps_slice_hdr->s_wt_ofst.i1_luma_log2_weight_denom); |
| ps_entropy_ctxt->ps_pic_level_info->i2_luma_offset_l0[i] = |
| ps_entropy_ctxt->ps_slice_hdr->s_wt_ofst.i2_luma_offset_l0[i]; |
| } |
| for(i = 0; i < ps_entropy_ctxt->ps_slice_hdr->i1_num_ref_idx_l1_active; i++) |
| { |
| ps_entropy_ctxt->ps_pic_level_info->i4_ref_poc_l1[i] = |
| ps_entropy_ctxt->ps_slice_hdr->s_rplm.i4_ref_poc_l1[i]; |
| ps_entropy_ctxt->ps_pic_level_info->i1_list_entry_l1[i] = |
| ps_entropy_ctxt->ps_slice_hdr->s_rplm.i1_list_entry_l1[i]; |
| ps_entropy_ctxt->ps_pic_level_info->i2_luma_weight_l1[i] = |
| (DOUBLE)ps_entropy_ctxt->ps_slice_hdr->s_wt_ofst.i2_luma_weight_l1[i] / |
| (1 << ps_entropy_ctxt->ps_slice_hdr->s_wt_ofst.i1_luma_log2_weight_denom); |
| ps_entropy_ctxt->ps_pic_level_info->i2_luma_offset_l1[i] = |
| ps_entropy_ctxt->ps_slice_hdr->s_wt_ofst.i2_luma_offset_l1[i]; |
| } |
| } |
| |
| /* attach the time stamp of the input to output */ |
| ps_curr_out->i4_out_timestamp_low = ps_curr_inp->i4_inp_timestamp_low; |
| |
| ps_curr_out->i4_out_timestamp_high = ps_curr_inp->i4_inp_timestamp_high; |
| |
| /*attach the app frame info of this buffer */ |
| ps_curr_out->pv_app_frm_ctxt = ps_curr_inp->pv_app_frm_ctxt; |
| |
| /* 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; |
| |
| switch(slice_type) |
| { |
| case ISLICE: |
| if((nal_type == NAL_IDR_N_LP) || (NAL_IDR_W_LP == nal_type)) |
| { |
| ps_curr_out->i4_encoded_frame_type = IV_IDR_FRAME; |
| } |
| else |
| { |
| ps_curr_out->i4_encoded_frame_type = IV_I_FRAME; |
| } |
| break; |
| case PSLICE: |
| ps_curr_out->i4_encoded_frame_type = IV_P_FRAME; |
| break; |
| case BSLICE: |
| ps_curr_out->i4_encoded_frame_type = IV_B_FRAME; |
| break; |
| } |
| |
| if(IHEVCE_SUCCESS == ret) |
| { |
| ps_curr_out->i4_process_ret_sts = IV_SUCCESS; |
| } |
| else |
| { |
| ps_curr_out->i4_process_ret_sts = IV_FAIL; |
| } |
| |
| return (ret); |
| } |
