| /****************************************************************************** |
| * |
| * Copyright (C) 2022 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 |
| * isvce_encode.c |
| * |
| * @brief |
| * This file contains functions for encoding the input yuv frame in synchronous |
| * api mode |
| * |
| * @author |
| * ittiam |
| * |
| * List of Functions |
| * - isvce_join_threads() |
| * - isvce_wait_for_thread() |
| * - isvce_encode() |
| * |
| ****************************************************************************** |
| */ |
| #include <stdio.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <limits.h> |
| #include <assert.h> |
| #include <math.h> |
| #include <stdbool.h> |
| |
| #include "ih264_typedefs.h" |
| /* Dependencies of ih264_buf_mgr.h */ |
| /* Dependencies of ih264_list.h */ |
| #include "ih264_error.h" |
| /* Dependencies of ih264_common_tables.h */ |
| #include "ih264_defs.h" |
| #include "ih264_structs.h" |
| #include "ih264_buf_mgr.h" |
| #include "ih264_common_tables.h" |
| #include "ih264_list.h" |
| #include "ih264_platform_macros.h" |
| #include "ih264_trans_data.h" |
| #include "ih264_size_defs.h" |
| /* Dependencies of ih264e_cabac_structs.h */ |
| #include "ih264_cabac_tables.h" |
| /* Dependencies of ime_structs.h */ |
| #include "ime_defs.h" |
| #include "ime_distortion_metrics.h" |
| /* Dependencies of ih264e_structs.h */ |
| #include "iv2.h" |
| #include "ive2.h" |
| #include "ih264_defs.h" |
| #include "ih264_deblk_edge_filters.h" |
| #include "ih264_inter_pred_filters.h" |
| #include "ih264_structs.h" |
| #include "ih264_trans_quant_itrans_iquant.h" |
| /* Dependencies of ih264e_bitstream.h */ |
| #include "ih264e_error.h" |
| #include "ih264e_bitstream.h" |
| #include "ih264e_cabac_structs.h" |
| #include "irc_cntrl_param.h" |
| #include "irc_frame_info_collector.h" |
| #include "ime_statistics.h" |
| #include "ime_structs.h" |
| /* Dependencies of 'ih264e_utils.h' */ |
| #include "ih264e_defs.h" |
| #include "ih264e_structs.h" |
| #include "ih264e_utils.h" |
| #include "ime.h" |
| #include "isvce.h" |
| #include "isvce_cabac.h" |
| #include "isvce_deblk.h" |
| #include "isvce_defs.h" |
| #include "isvce_downscaler.h" |
| #include "isvce_encode_header.h" |
| #include "isvce_fmt_conv.h" |
| #include "isvce_ibl_eval.h" |
| #include "isvce_ilp_mv.h" |
| #include "isvce_intra_modes_eval.h" |
| #include "isvce_me.h" |
| #include "isvce_process.h" |
| #include "isvce_rate_control.h" |
| #include "isvce_residual_pred.h" |
| #include "isvce_sub_pic_rc.h" |
| #include "isvce_utils.h" |
| |
| #define SEI_BASED_FORCE_IDR 1 |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief This function puts the current thread to sleep for a duration |
| * of sleep_us |
| * |
| * @par Description |
| * ithread_yield() method causes the calling thread to yield execution to |
| *another thread that is ready to run on the current processor. The operating |
| *system selects the thread to yield to. ithread_usleep blocks the current thread |
| *for the specified number of milliseconds. In other words, yield just says, end |
| *my timeslice prematurely, look around for other threads to run. If there is |
| *nothing better than me, continue. Sleep says I don't want to run for x |
| * milliseconds. Even if no other thread wants to run, don't make me run. |
| * |
| * @param[in] sleep_us |
| * thread sleep duration |
| * |
| * @returns error_status |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T isvce_wait_for_thread(UWORD32 sleep_us) |
| { |
| /* yield thread */ |
| ithread_yield(); |
| |
| /* put thread to sleep */ |
| ithread_sleep(sleep_us); |
| |
| return IH264E_SUCCESS; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief |
| * Encodes in synchronous api mode |
| * |
| * @par Description |
| * This routine processes input yuv, encodes it and outputs bitstream and recon |
| * |
| * @param[in] ps_codec_obj |
| * Pointer to codec object at API level |
| * |
| * @param[in] pv_api_ip |
| * Pointer to input argument structure |
| * |
| * @param[out] pv_api_op |
| * Pointer to output argument structure |
| * |
| * @returns Status |
| * |
| ****************************************************************************** |
| */ |
| WORD32 isvce_encode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op) |
| { |
| /* error status */ |
| IH264E_ERROR_T error_status = IH264E_SUCCESS; |
| |
| /* codec ctxt */ |
| isvce_codec_t *ps_codec = (isvce_codec_t *) ps_codec_obj->pv_codec_handle; |
| |
| /* input frame to encode */ |
| isvce_video_encode_ip_t *ps_video_encode_ip = pv_api_ip; |
| |
| /* output buffer to write stream */ |
| isvce_video_encode_op_t *ps_video_encode_op = pv_api_op; |
| |
| /* i/o structures */ |
| isvce_inp_buf_t s_inp_buf; |
| isvce_out_buf_t s_out_buf; |
| |
| WORD32 ctxt_sel = 0, i4_rc_pre_enc_skip; |
| WORD32 i, j; |
| |
| ASSERT(MAX_CTXT_SETS == 1); |
| |
| /********************************************************************/ |
| /* BEGIN INIT */ |
| /********************************************************************/ |
| /* reset output structure */ |
| ps_video_encode_op->s_ive_op.u4_error_code = IV_SUCCESS; |
| ps_video_encode_op->s_ive_op.output_present = 0; |
| ps_video_encode_op->s_ive_op.dump_recon = 0; |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_NA_FRAME; |
| |
| /* Check for output memory allocation size */ |
| { |
| UWORD32 u4_min_bufsize = |
| isvce_get_min_outbuf_size(ps_codec->s_cfg.u4_wd, ps_codec->s_cfg.u4_ht, |
| ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers); |
| UWORD32 u4_bufsize_per_layer = ps_video_encode_ip->s_ive_ip.s_out_buf.u4_bufsize / |
| ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; |
| |
| if(ps_video_encode_ip->s_ive_ip.s_out_buf.u4_bufsize < u4_min_bufsize) |
| { |
| error_status = IH264E_INSUFFICIENT_OUTPUT_BUFFER; |
| |
| SET_ERROR_ON_RETURN(error_status, IVE_UNSUPPORTEDPARAM, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| } |
| |
| for(i = 0; i < ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; i++) |
| { |
| s_out_buf.as_bits_buf[i] = ps_video_encode_ip->s_ive_ip.s_out_buf; |
| |
| s_out_buf.as_bits_buf[i].u4_bufsize = u4_bufsize_per_layer; |
| s_out_buf.as_bits_buf[i].pv_buf = |
| ((UWORD8 *) ps_video_encode_ip->s_ive_ip.s_out_buf.pv_buf) + |
| u4_bufsize_per_layer * i; |
| } |
| } |
| |
| s_out_buf.u4_is_last = 0; |
| s_out_buf.u4_timestamp_low = ps_video_encode_ip->s_ive_ip.u4_timestamp_low; |
| s_out_buf.u4_timestamp_high = ps_video_encode_ip->s_ive_ip.u4_timestamp_high; |
| |
| /* api call cnt */ |
| ps_codec->i4_encode_api_call_cnt += 1; |
| |
| /* codec context selector */ |
| ctxt_sel = ps_codec->i4_encode_api_call_cnt % MAX_CTXT_SETS; |
| |
| /* reset status flags */ |
| ps_codec->ai4_pic_cnt[ctxt_sel] = -1; |
| ps_codec->s_rate_control.post_encode_skip[ctxt_sel] = 0; |
| ps_codec->s_rate_control.pre_encode_skip[ctxt_sel] = 0; |
| |
| /* pass output buffer to codec */ |
| ps_codec->as_out_buf[ctxt_sel] = s_out_buf; |
| |
| /* initialize codec ctxt with default params for the first encode api call */ |
| if(ps_codec->i4_encode_api_call_cnt == 0) |
| { |
| isvce_codec_init(ps_codec); |
| } |
| |
| /* parse configuration params */ |
| for(i = 0; i < MAX_ACTIVE_CONFIG_PARAMS; i++) |
| { |
| isvce_cfg_params_t *ps_cfg = &ps_codec->as_cfg[i]; |
| |
| if(1 == ps_cfg->u4_is_valid) |
| { |
| if(((ps_cfg->u4_timestamp_high == ps_video_encode_ip->s_ive_ip.u4_timestamp_high) && |
| (ps_cfg->u4_timestamp_low == ps_video_encode_ip->s_ive_ip.u4_timestamp_low)) || |
| ((WORD32) ps_cfg->u4_timestamp_high == -1) || |
| ((WORD32) ps_cfg->u4_timestamp_low == -1)) |
| { |
| error_status = isvce_codec_update_config(ps_codec, ps_cfg); |
| SET_ERROR_ON_RETURN(error_status, IVE_UNSUPPORTEDPARAM, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| |
| ps_cfg->u4_is_valid = 0; |
| } |
| } |
| } |
| /* Force IDR based on SEI params */ |
| #if SEI_BASED_FORCE_IDR |
| { |
| sei_mdcv_params_t *ps_sei_mdcv_params = &ps_codec->s_sei.s_sei_mdcv_params; |
| sei_mdcv_params_t *ps_cfg_sei_mdcv_params = &ps_codec->s_cfg.s_sei.s_sei_mdcv_params; |
| sei_cll_params_t *ps_sei_cll_params = &ps_codec->s_sei.s_sei_cll_params; |
| sei_cll_params_t *ps_cfg_sei_cll_params = &ps_codec->s_cfg.s_sei.s_sei_cll_params; |
| sei_ave_params_t *ps_sei_ave_params = &ps_codec->s_sei.s_sei_ave_params; |
| sei_ave_params_t *ps_cfg_sei_ave_params = &ps_codec->s_cfg.s_sei.s_sei_ave_params; |
| |
| if((ps_sei_mdcv_params->au2_display_primaries_x[0] != |
| ps_cfg_sei_mdcv_params->au2_display_primaries_x[0]) || |
| (ps_sei_mdcv_params->au2_display_primaries_x[1] != |
| ps_cfg_sei_mdcv_params->au2_display_primaries_x[1]) || |
| (ps_sei_mdcv_params->au2_display_primaries_x[2] != |
| ps_cfg_sei_mdcv_params->au2_display_primaries_x[2]) || |
| (ps_sei_mdcv_params->au2_display_primaries_y[0] != |
| ps_cfg_sei_mdcv_params->au2_display_primaries_y[0]) || |
| (ps_sei_mdcv_params->au2_display_primaries_y[1] != |
| ps_cfg_sei_mdcv_params->au2_display_primaries_y[1]) || |
| (ps_sei_mdcv_params->au2_display_primaries_y[2] != |
| ps_cfg_sei_mdcv_params->au2_display_primaries_y[2]) || |
| (ps_sei_mdcv_params->u2_white_point_x != ps_cfg_sei_mdcv_params->u2_white_point_x) || |
| (ps_sei_mdcv_params->u2_white_point_y != ps_cfg_sei_mdcv_params->u2_white_point_y) || |
| (ps_sei_mdcv_params->u4_max_display_mastering_luminance != |
| ps_cfg_sei_mdcv_params->u4_max_display_mastering_luminance) || |
| (ps_sei_mdcv_params->u4_min_display_mastering_luminance != |
| ps_cfg_sei_mdcv_params->u4_min_display_mastering_luminance)) |
| { |
| ps_codec->s_sei.s_sei_mdcv_params = ps_codec->s_cfg.s_sei.s_sei_mdcv_params; |
| ps_codec->s_sei.u1_sei_mdcv_params_present_flag = 1; |
| } |
| else |
| { |
| ps_codec->s_sei.u1_sei_mdcv_params_present_flag = 0; |
| } |
| |
| if((ps_sei_cll_params->u2_max_content_light_level != |
| ps_cfg_sei_cll_params->u2_max_content_light_level) || |
| (ps_sei_cll_params->u2_max_pic_average_light_level != |
| ps_cfg_sei_cll_params->u2_max_pic_average_light_level)) |
| { |
| ps_codec->s_sei.s_sei_cll_params = ps_codec->s_cfg.s_sei.s_sei_cll_params; |
| ps_codec->s_sei.u1_sei_cll_params_present_flag = 1; |
| } |
| else |
| { |
| ps_codec->s_sei.u1_sei_cll_params_present_flag = 0; |
| } |
| |
| if((ps_sei_ave_params->u4_ambient_illuminance != |
| ps_cfg_sei_ave_params->u4_ambient_illuminance) || |
| (ps_sei_ave_params->u2_ambient_light_x != ps_cfg_sei_ave_params->u2_ambient_light_x) || |
| (ps_sei_ave_params->u2_ambient_light_y != ps_cfg_sei_ave_params->u2_ambient_light_y)) |
| { |
| ps_codec->s_sei.s_sei_ave_params = ps_codec->s_cfg.s_sei.s_sei_ave_params; |
| ps_codec->s_sei.u1_sei_ave_params_present_flag = 1; |
| } |
| else |
| { |
| ps_codec->s_sei.u1_sei_ave_params_present_flag = 0; |
| } |
| |
| if((1 == ps_codec->s_sei.u1_sei_mdcv_params_present_flag) || |
| (1 == ps_codec->s_sei.u1_sei_cll_params_present_flag) || |
| (1 == ps_codec->s_sei.u1_sei_ave_params_present_flag)) |
| { |
| ps_codec->force_curr_frame_type = IV_IDR_FRAME; |
| } |
| } |
| #endif |
| |
| /* In case of alt ref and B pics we will have non reference frame in stream */ |
| if(ps_codec->s_cfg.u4_enable_alt_ref || ps_codec->s_cfg.u4_num_bframes) |
| { |
| ps_codec->i4_non_ref_frames_in_stream = 1; |
| } |
| |
| if(ps_codec->i4_encode_api_call_cnt == 0) |
| { |
| /********************************************************************/ |
| /* number of mv/ref bank buffers used by the codec, */ |
| /* 1 to handle curr frame */ |
| /* 1 to store information of ref frame */ |
| /* 1 more additional because of the codec employs 2 ctxt sets */ |
| /* to assist asynchronous API */ |
| /********************************************************************/ |
| |
| /* initialize mv bank buffer manager */ |
| error_status = isvce_svc_au_data_mgr_add_bufs(ps_codec); |
| |
| SET_ERROR_ON_RETURN(error_status, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| |
| /* initialize ref bank buffer manager */ |
| error_status = isvce_svc_au_buf_mgr_add_bufs(ps_codec); |
| |
| SET_ERROR_ON_RETURN(error_status, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| |
| /* for the first frame, generate header when not requested explicitly */ |
| if(ps_codec->i4_header_mode == 0 && ps_codec->u4_header_generated == 0) |
| { |
| ps_codec->i4_gen_header = 1; |
| } |
| } |
| |
| /* generate header and return when encoder is operated in header mode */ |
| if(ps_codec->i4_header_mode == 1) |
| { |
| /* whenever the header is generated, this implies a start of sequence |
| * and a sequence needs to be started with IDR |
| */ |
| ps_codec->force_curr_frame_type = IV_IDR_FRAME; |
| |
| s_inp_buf.s_svc_params = ps_codec->s_cfg.s_svc_params; |
| s_inp_buf.s_inp_props.s_raw_buf = ps_video_encode_ip->s_ive_ip.s_inp_buf; |
| s_inp_buf.s_inp_props.s_raw_buf.au4_wd[Y] = ps_codec->s_cfg.u4_wd; |
| s_inp_buf.s_inp_props.s_raw_buf.au4_ht[Y] = ps_codec->s_cfg.u4_ht; |
| |
| isvce_init_svc_dimension(&s_inp_buf); |
| |
| /* generate header */ |
| error_status = isvce_generate_sps_pps(ps_codec, &s_inp_buf); |
| |
| /* send the input to app */ |
| ps_video_encode_op->s_ive_op.s_inp_buf = ps_video_encode_ip->s_ive_ip.s_inp_buf; |
| ps_video_encode_op->s_ive_op.u4_timestamp_low = |
| ps_video_encode_ip->s_ive_ip.u4_timestamp_low; |
| ps_video_encode_op->s_ive_op.u4_timestamp_high = |
| ps_video_encode_ip->s_ive_ip.u4_timestamp_high; |
| |
| ps_video_encode_op->s_ive_op.u4_is_last = ps_video_encode_ip->s_ive_ip.u4_is_last; |
| |
| /* send the output to app */ |
| ps_video_encode_op->s_ive_op.output_present = 1; |
| ps_video_encode_op->s_ive_op.dump_recon = 0; |
| ps_video_encode_op->s_ive_op.s_out_buf = ps_codec->as_out_buf[ctxt_sel].as_bits_buf[0]; |
| |
| for(i = 1; i < ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; i++) |
| { |
| memmove(((UWORD8 *) ps_video_encode_op->s_ive_op.s_out_buf.pv_buf + |
| ps_video_encode_op->s_ive_op.s_out_buf.u4_bytes), |
| ps_codec->as_out_buf[ctxt_sel].as_bits_buf[i].pv_buf, |
| ps_codec->as_out_buf[ctxt_sel].as_bits_buf[i].u4_bytes); |
| |
| ps_video_encode_op->s_ive_op.s_out_buf.u4_bytes += |
| ps_codec->as_out_buf[ctxt_sel].as_bits_buf[i].u4_bytes; |
| } |
| |
| /* error status */ |
| SET_ERROR_ON_RETURN(error_status, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| |
| /* indicates that header has been generated previously */ |
| ps_codec->u4_header_generated = 1; |
| |
| /* api call cnt */ |
| ps_codec->i4_encode_api_call_cnt--; |
| |
| /* header mode tag is not sticky */ |
| ps_codec->i4_header_mode = 0; |
| ps_codec->i4_gen_header = 0; |
| |
| return IV_SUCCESS; |
| } |
| |
| /* curr pic cnt */ |
| ps_codec->i4_pic_cnt += 1; |
| |
| i4_rc_pre_enc_skip = 0; |
| for(i = 0; i < ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; i++) |
| { |
| i4_rc_pre_enc_skip = |
| isvce_input_queue_update(ps_codec, &ps_video_encode_ip->s_ive_ip, &s_inp_buf, i); |
| } |
| |
| s_out_buf.u4_is_last = s_inp_buf.s_inp_props.u4_is_last; |
| ps_video_encode_op->s_ive_op.u4_is_last = s_inp_buf.s_inp_props.u4_is_last; |
| |
| /* Only encode if the current frame is not pre-encode skip */ |
| if(!i4_rc_pre_enc_skip && s_inp_buf.s_inp_props.s_raw_buf.apv_bufs[0]) |
| { |
| isvce_process_ctxt_t *ps_proc = &ps_codec->as_process[ctxt_sel * MAX_PROCESS_THREADS]; |
| |
| WORD32 num_thread_cnt = ps_codec->s_cfg.u4_num_cores - 1; |
| |
| ps_codec->ai4_pic_cnt[ctxt_sel] = ps_codec->i4_pic_cnt; |
| |
| error_status = isvce_svc_au_init(ps_codec, &s_inp_buf); |
| |
| SET_ERROR_ON_RETURN(error_status, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| |
| isvce_nalu_info_au_init(ps_codec->as_nalu_descriptors, |
| ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers); |
| |
| #if ENABLE_MODE_STAT_VISUALISER |
| isvce_msv_get_input_frame(ps_codec->ps_mode_stat_visualiser, &s_inp_buf); |
| #endif |
| |
| for(i = 0; i < ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; i++) |
| { |
| isvce_svc_layer_pic_init(ps_codec, &s_inp_buf, i); |
| |
| for(j = 0; j < num_thread_cnt; j++) |
| { |
| ithread_create(ps_codec->apv_proc_thread_handle[j], NULL, isvce_process_thread, |
| &ps_codec->as_process[j + 1]); |
| |
| ps_codec->ai4_process_thread_created[j] = 1; |
| |
| ps_codec->i4_proc_thread_cnt++; |
| } |
| |
| /* launch job */ |
| isvce_process_thread(ps_proc); |
| |
| /* Join threads at the end of encoding a frame */ |
| isvce_join_threads(ps_codec); |
| |
| ih264_list_reset(ps_codec->pv_proc_jobq); |
| |
| ih264_list_reset(ps_codec->pv_entropy_jobq); |
| } |
| |
| #if ENABLE_MODE_STAT_VISUALISER |
| isvce_msv_dump_visualisation(ps_codec->ps_mode_stat_visualiser); |
| #endif |
| |
| isvce_sub_pic_rc_dump_data(ps_codec->as_process->ps_sub_pic_rc_ctxt); |
| } |
| |
| /**************************************************************************** |
| * RECON |
| * Since we have forward dependent frames, we cannot return recon in |
| *encoding order. It must be in poc order, or input pic order. To achieve this |
| *we introduce a delay of 1 to the recon wrt encode. Now since we have that |
| * delay, at any point minimum of pic_cnt in our ref buffer will be the |
| * correct frame. For ex let our GOP be IBBP [1 2 3 4] . The encode order |
| * will be [1 4 2 3] .Now since we have a delay of 1, when we are done with |
| * encoding 4, the min in the list will be 1. After encoding 2, it will be |
| * 2, 3 after 3 and 4 after 4. Hence we can return in sequence. Note |
| * that the 1 delay is critical. Hence if we have post enc skip, we must |
| * skip here too. Note that since post enc skip already frees the recon |
| * buffer we need not do any thing here |
| * |
| * We need to return a recon when ever we consume an input buffer. This |
| * comsumption include a pre or post enc skip. Thus dump recon is set for |
| * all cases except when |
| * 1) We are waiting -> ps_codec->i4_pic_cnt > |
| *ps_codec->s_cfg.u4_num_bframe An exception need to be made for the case when |
| *we have the last buffer since we need to flush out the on remainig recon. |
| ****************************************************************************/ |
| |
| ps_video_encode_op->s_ive_op.dump_recon = 0; |
| |
| if(ps_codec->s_cfg.u4_enable_recon && |
| ((ps_codec->i4_pic_cnt > (WORD32) ps_codec->s_cfg.u4_num_bframes) || |
| s_inp_buf.s_inp_props.u4_is_last)) |
| { |
| /* error status */ |
| IH264_ERROR_T ret = IH264_SUCCESS; |
| |
| svc_au_buf_t *ps_pic_buf = NULL; |
| |
| WORD32 i4_buf_status, i4_curr_poc = 32768; |
| |
| /* In case of skips we return recon, but indicate that buffer is zero size |
| */ |
| if(ps_codec->s_rate_control.post_encode_skip[ctxt_sel] || i4_rc_pre_enc_skip) |
| { |
| ps_video_encode_op->s_ive_op.dump_recon = 1; |
| ps_video_encode_op->s_ive_op.s_recon_buf.au4_wd[0] = 0; |
| ps_video_encode_op->s_ive_op.s_recon_buf.au4_wd[1] = 0; |
| } |
| else |
| { |
| for(i = 0; i < ps_codec->i4_ref_buf_cnt; i++) |
| { |
| if(ps_codec->as_ref_set[i].i4_pic_cnt == -1) continue; |
| |
| i4_buf_status = ih264_buf_mgr_get_status( |
| ps_codec->pv_ref_buf_mgr, ps_codec->as_ref_set[i].ps_pic_buf->i4_buf_id); |
| |
| if((i4_buf_status & BUF_MGR_IO) && (ps_codec->as_ref_set[i].i4_poc < i4_curr_poc)) |
| { |
| ps_pic_buf = ps_codec->as_ref_set[i].ps_pic_buf; |
| i4_curr_poc = ps_codec->as_ref_set[i].i4_poc; |
| } |
| } |
| |
| ps_video_encode_op->s_ive_op.s_recon_buf = ps_video_encode_ip->s_ive_ip.s_recon_buf; |
| |
| /* |
| * If we get a valid buffer. output and free recon. |
| * |
| * we may get an invalid buffer if num_b_frames is 0. This is because |
| * We assume that there will be a ref frame in ref list after encoding |
| * the last frame. With B frames this is correct since its forward ref |
| * pic will be in the ref list. But if num_b_frames is 0, we will not |
| * have a forward ref pic |
| */ |
| |
| if(ps_pic_buf) |
| { |
| if((ps_video_encode_ip->s_ive_ip.s_recon_buf.au4_wd[Y] != |
| ps_codec->s_cfg.u4_disp_wd) || |
| (ps_video_encode_ip->s_ive_ip.s_recon_buf.au4_ht[Y] != |
| ps_codec->s_cfg.u4_disp_ht)) |
| { |
| SET_ERROR_ON_RETURN(IH264E_NO_FREE_RECONBUF, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| } |
| |
| isvce_fmt_conv(ps_codec, ps_pic_buf, |
| ps_video_encode_ip->s_ive_ip.s_recon_buf.apv_bufs[0], |
| ps_video_encode_ip->s_ive_ip.s_recon_buf.apv_bufs[1], |
| ps_video_encode_ip->s_ive_ip.s_recon_buf.apv_bufs[2], |
| ps_video_encode_ip->s_ive_ip.s_recon_buf.au4_wd[0], |
| ps_video_encode_ip->s_ive_ip.s_recon_buf.au4_wd[1], 0, |
| ps_codec->s_cfg.u4_disp_ht); |
| |
| ps_video_encode_op->s_ive_op.dump_recon = 1; |
| |
| ret = ih264_buf_mgr_release(ps_codec->pv_ref_buf_mgr, ps_pic_buf->i4_buf_id, |
| BUF_MGR_IO); |
| |
| if(IH264_SUCCESS != ret) |
| { |
| SET_ERROR_ON_RETURN((IH264E_ERROR_T) ret, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| } |
| } |
| } |
| } |
| |
| /*************************************************************************** |
| * Free reference buffers: |
| * In case of a post enc skip, we have to ensure that those pics will not |
| * be used as reference anymore. In all other cases we will not even mark |
| * the ref buffers |
| ***************************************************************************/ |
| if(ps_codec->s_rate_control.post_encode_skip[ctxt_sel]) |
| { |
| /* pic info */ |
| svc_au_buf_t *ps_cur_pic; |
| |
| /* mv info */ |
| svc_au_data_t *ps_cur_mv_buf; |
| |
| /* error status */ |
| IH264_ERROR_T ret = IH264_SUCCESS; |
| |
| /* Decrement coded pic count */ |
| ps_codec->i4_poc--; |
| |
| /* loop through to get the min pic cnt among the list of pics stored in ref |
| * list */ |
| /* since the skipped frame may not be on reference list, we may not have an |
| * MV bank hence free only if we have allocated */ |
| for(i = 0; i < ps_codec->i4_ref_buf_cnt; i++) |
| { |
| if(ps_codec->i4_pic_cnt == ps_codec->as_ref_set[i].i4_pic_cnt) |
| { |
| ps_cur_pic = ps_codec->as_ref_set[i].ps_pic_buf; |
| |
| ps_cur_mv_buf = ps_codec->as_ref_set[i].ps_svc_au_data; |
| |
| /* release this frame from reference list and recon list */ |
| ret = ih264_buf_mgr_release(ps_codec->pv_svc_au_data_store_mgr, |
| ps_cur_mv_buf->i4_buf_id, BUF_MGR_REF); |
| ret |= ih264_buf_mgr_release(ps_codec->pv_svc_au_data_store_mgr, |
| ps_cur_mv_buf->i4_buf_id, BUF_MGR_IO); |
| SET_ERROR_ON_RETURN((IH264E_ERROR_T) ret, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| |
| ret = ih264_buf_mgr_release(ps_codec->pv_ref_buf_mgr, ps_cur_pic->i4_buf_id, |
| BUF_MGR_REF); |
| ret |= ih264_buf_mgr_release(ps_codec->pv_ref_buf_mgr, ps_cur_pic->i4_buf_id, |
| BUF_MGR_IO); |
| SET_ERROR_ON_RETURN((IH264E_ERROR_T) ret, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| break; |
| } |
| } |
| } |
| |
| /* |
| * Since recon is not in sync with output, ie there can be frame to be |
| * given back as recon even after last output. Hence we need to mark that |
| * the output is not the last. |
| * Hence search through reflist and mark appropriately |
| */ |
| if(ps_codec->s_cfg.u4_enable_recon) |
| { |
| WORD32 i4_buf_status = 0; |
| |
| for(i = 0; i < ps_codec->i4_ref_buf_cnt; i++) |
| { |
| if(ps_codec->as_ref_set[i].i4_pic_cnt == -1) continue; |
| |
| i4_buf_status |= ih264_buf_mgr_get_status( |
| ps_codec->pv_ref_buf_mgr, ps_codec->as_ref_set[i].ps_pic_buf->i4_buf_id); |
| } |
| |
| if(i4_buf_status & BUF_MGR_IO) |
| { |
| s_out_buf.u4_is_last = 0; |
| ps_video_encode_op->s_ive_op.u4_is_last = 0; |
| } |
| } |
| |
| /************************************************************************** |
| * Signaling to APP |
| * 1) If we valid a valid output mark it so |
| * 2) Set the codec output ps_video_encode_op |
| * 3) Set the error status |
| * 4) Set the return Pic type |
| * Note that we already has marked recon properly |
| * 5)Send the consumed input back to app so that it can free it if possible |
| * |
| * We will have to return the output and input buffers unconditionally |
| * so that app can release them |
| **************************************************************************/ |
| if(!i4_rc_pre_enc_skip && !ps_codec->s_rate_control.post_encode_skip[ctxt_sel] && |
| s_inp_buf.s_inp_props.s_raw_buf.apv_bufs[0]) |
| { |
| /* receive output back from codec */ |
| s_out_buf = ps_codec->as_out_buf[ctxt_sel]; |
| |
| /* send the output to app */ |
| ps_video_encode_op->s_ive_op.output_present = 1; |
| ps_video_encode_op->s_ive_op.u4_error_code = IV_SUCCESS; |
| |
| /* Set the time stamps of the encodec input */ |
| ps_video_encode_op->s_ive_op.u4_timestamp_low = s_inp_buf.s_inp_props.u4_timestamp_low; |
| ps_video_encode_op->s_ive_op.u4_timestamp_high = s_inp_buf.s_inp_props.u4_timestamp_high; |
| |
| switch(ps_codec->pic_type) |
| { |
| case PIC_IDR: |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_IDR_FRAME; |
| break; |
| |
| case PIC_I: |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_I_FRAME; |
| break; |
| |
| case PIC_P: |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_P_FRAME; |
| break; |
| |
| case PIC_B: |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_B_FRAME; |
| break; |
| |
| default: |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_NA_FRAME; |
| break; |
| } |
| |
| for(i = 0; i < (WORD32) ps_codec->s_cfg.u4_num_cores; i++) |
| { |
| error_status = ps_codec->as_process[ctxt_sel + i].i4_error_code; |
| SET_ERROR_ON_RETURN(error_status, IVE_FATALERROR, |
| ps_video_encode_op->s_ive_op.u4_error_code, IV_FAIL); |
| } |
| } |
| else |
| { |
| /* receive output back from codec */ |
| s_out_buf = ps_codec->as_out_buf[ctxt_sel]; |
| |
| ps_video_encode_op->s_ive_op.output_present = 0; |
| ps_video_encode_op->s_ive_op.u4_error_code = IV_SUCCESS; |
| |
| /* Set the time stamps of the encodec input */ |
| ps_video_encode_op->s_ive_op.u4_timestamp_low = 0; |
| ps_video_encode_op->s_ive_op.u4_timestamp_high = 0; |
| |
| ps_video_encode_op->s_ive_op.s_inp_buf = s_inp_buf.s_inp_props.s_raw_buf; |
| |
| ps_video_encode_op->s_ive_op.u4_encoded_frame_type = IV_NA_FRAME; |
| } |
| |
| /* Send the input to encoder so that it can free it if possible */ |
| ps_video_encode_op->s_ive_op.s_out_buf = ps_codec->as_out_buf[ctxt_sel].as_bits_buf[0]; |
| |
| for(i = 1; i < ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; i++) |
| { |
| memmove(((UWORD8 *) ps_video_encode_op->s_ive_op.s_out_buf.pv_buf + |
| ps_video_encode_op->s_ive_op.s_out_buf.u4_bytes), |
| ps_codec->as_out_buf[ctxt_sel].as_bits_buf[i].pv_buf, |
| ps_codec->as_out_buf[ctxt_sel].as_bits_buf[i].u4_bytes); |
| |
| ps_video_encode_op->s_ive_op.s_out_buf.u4_bytes += |
| ps_codec->as_out_buf[ctxt_sel].as_bits_buf[i].u4_bytes; |
| } |
| |
| if(ps_codec->s_cfg.b_nalu_info_export_enable && !i4_rc_pre_enc_skip && |
| !ps_codec->s_rate_control.post_encode_skip[ctxt_sel] && |
| s_inp_buf.s_inp_props.s_raw_buf.apv_bufs[0]) |
| { |
| ps_video_encode_op->b_is_nalu_info_present = true; |
| |
| for(i = 0; i < ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers; i++) |
| { |
| isvce_nalu_info_csv_translator(&ps_codec->as_nalu_descriptors[i], |
| &ps_video_encode_ip->ps_nalu_info_buf[i]); |
| |
| ps_video_encode_op->ps_nalu_info_buf[i] = ps_video_encode_ip->ps_nalu_info_buf[i]; |
| } |
| } |
| else |
| { |
| ps_video_encode_op->b_is_nalu_info_present = false; |
| } |
| |
| ps_video_encode_op->s_ive_op.s_inp_buf = s_inp_buf.s_inp_props.s_raw_buf; |
| |
| return IV_SUCCESS; |
| } |
