| /****************************************************************************** |
| * |
| * Copyright (C) 2015 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 |
| * ih264e_rate_control.c |
| * |
| * @brief |
| * Contains api function definitions for h264 rate control |
| * |
| * @author |
| * ittiam |
| * |
| * @par List of Functions: |
| * - ih264e_rc_init() |
| * - ih264e_rc_get_picture_details() |
| * - ih264e_rc_pre_enc() |
| * - ih264e_update_rc_mb_info() |
| * - ih264e_rc_get_buffer_status() |
| * - ih264e_rc_post_enc() |
| * - ih264e_update_rc_bits_info() |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| |
| /* User include files */ |
| #include "irc_datatypes.h" |
| #include "iv2.h" |
| #include "ive2.h" |
| #include "ih264e.h" |
| #include "ih264_defs.h" |
| #include "ih264_macros.h" |
| #include "ih264_structs.h" |
| #include "ih264_trans_quant_itrans_iquant.h" |
| #include "ih264_inter_pred_filters.h" |
| #include "ih264_mem_fns.h" |
| #include "ih264_padding.h" |
| #include "ih264_intra_pred_filters.h" |
| #include "ih264_deblk_edge_filters.h" |
| #include "ih264_common_tables.h" |
| #include "ih264_cabac_tables.h" |
| #include "ih264e_defs.h" |
| #include "ih264e_globals.h" |
| #include "irc_mem_req_and_acq.h" |
| #include "irc_cntrl_param.h" |
| #include "irc_frame_info_collector.h" |
| #include "irc_rate_control_api.h" |
| #include "ih264e_time_stamp.h" |
| #include "ih264e_modify_frm_rate.h" |
| #include "ih264e_rate_control.h" |
| #include "ih264e_error.h" |
| #include "ih264e_bitstream.h" |
| #include "ime_distortion_metrics.h" |
| #include "ime_defs.h" |
| #include "ime_structs.h" |
| #include "ih264e_cabac_structs.h" |
| #include "ih264e_structs.h" |
| #include "ih264e_utils.h" |
| #include "irc_trace_support.h" |
| |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief This function does nothing |
| * |
| * @par Description |
| * This function does nothing |
| * |
| * @param[in] variadic function |
| |
| * @returns none |
| * |
| * @remarks This function is used by the rc library for debugging purposes. |
| * However this function was not part of rc library. So this is defined here |
| * to resolve link issues. |
| * |
| ******************************************************************************* |
| */ |
| int trace_printf(const WORD8 *format, ...) |
| { |
| UNUSED(format); |
| return(0); |
| }; |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function initializes rate control context and variables |
| * |
| * @par Description |
| * This function initializes rate control type, source and target frame rate, |
| * average and peak bitrate, intra-inter frame interval and initial |
| * quantization parameter |
| * |
| * @param[in] pv_rc_api |
| * Handle to rate control api |
| * |
| * @param[in] pv_frame_time |
| * Handle to frame time context |
| * |
| * @param[in] pv_time_stamp |
| * Handle to time stamp context |
| * |
| * @param[in] pv_pd_frm_rate |
| * Handle to pull down frame time context |
| * |
| * @param[in] u4_max_frm_rate |
| * Maximum frame rate |
| * |
| * @param[in] u4_src_frm_rate |
| * Source frame rate |
| * |
| * @param[in] u4_tgt_frm_rate |
| * Target frame rate |
| * |
| * @param[in] e_rate_control_type |
| * Rate control type |
| * |
| * @param[in] u4_avg_bit_rate |
| * Average bit rate |
| * |
| * @param[in] u4_peak_bit_rate |
| * Peak bit rate |
| * |
| * @param[in] u4_max_delay |
| * Maximum delay between frames |
| * |
| * @param[in] u4_intra_frame_interval |
| * Intra frame interval |
| * |
| * @param[in] pu1_init_qp |
| * Initial qp |
| * |
| * @param[in] i4_max_inter_frm_int |
| * Maximum inter frame interval |
| * |
| * @param[in] pu1_min_max_qp |
| * Array of min/max qp |
| * |
| * @param[in] u1_profile_level |
| * Encoder profile level |
| * |
| * @returns none |
| * |
| * @remarks |
| * |
| ******************************************************************************* |
| */ |
| void ih264e_rc_init(void *pv_rc_api, |
| void *pv_frame_time, |
| void *pv_time_stamp, |
| void *pv_pd_frm_rate, |
| UWORD32 u4_max_frm_rate, |
| UWORD32 u4_src_frm_rate, |
| UWORD32 u4_tgt_frm_rate, |
| rc_type_e e_rate_control_type, |
| UWORD32 u4_avg_bit_rate, |
| UWORD32 u4_peak_bit_rate, |
| UWORD32 u4_max_delay, |
| UWORD32 u4_intra_frame_interval, |
| WORD32 i4_inter_frm_int, |
| UWORD8 *pu1_init_qp, |
| WORD32 i4_max_inter_frm_int, |
| UWORD8 *pu1_min_max_qp, |
| UWORD8 u1_profile_level) |
| { |
| // UWORD8 u1_is_mb_level_rc_on = 0; |
| UWORD32 au4_peak_bit_rate[2] = {0,0}; |
| UWORD32 u4_min_bit_rate = 0; |
| WORD32 i4_is_gop_closed = 1; |
| // WORD32 i4_use_est_intra_sad = 1; |
| UWORD32 u4_src_ticks = 0; |
| UWORD32 u4_tgt_ticks = 0; |
| UWORD8 u1_level_idx = ih264e_get_lvl_idx(u1_profile_level); |
| UWORD32 u4_max_cpb_size = 1200 * gas_ih264_lvl_tbl[u1_level_idx].u4_max_cpb_size; |
| |
| /* Fill the params needed for the RC init */ |
| if (e_rate_control_type == CBR_NLDRC) |
| { |
| au4_peak_bit_rate[0] = u4_avg_bit_rate; |
| au4_peak_bit_rate[1] = u4_avg_bit_rate; |
| } |
| else |
| { |
| au4_peak_bit_rate[0] = u4_peak_bit_rate; |
| au4_peak_bit_rate[1] = u4_peak_bit_rate; |
| } |
| |
| /* Initialize frame time computation module*/ |
| ih264e_init_frame_time(pv_frame_time, |
| u4_src_frm_rate, /* u4_src_frm_rate */ |
| u4_tgt_frm_rate); /* u4_tgt_frm_rate */ |
| |
| /* Initialize the pull_down frame rate */ |
| ih264e_init_pd_frm_rate(pv_pd_frm_rate, |
| u4_src_frm_rate); /* u4_input_frm_rate */ |
| |
| /* Initialize time stamp structure */ |
| ih264e_init_time_stamp(pv_time_stamp, |
| u4_max_frm_rate, /* u4_max_frm_rate */ |
| u4_src_frm_rate); /* u4_src_frm_rate */ |
| |
| u4_src_ticks = ih264e_frame_time_get_src_ticks(pv_frame_time); |
| u4_tgt_ticks = ih264e_frame_time_get_tgt_ticks(pv_frame_time); |
| |
| /* Init max_inter_frame int */ |
| i4_max_inter_frm_int = (i4_inter_frm_int == 1) ? 2 : (i4_inter_frm_int + 2); |
| |
| /* Initialize the rate control */ |
| irc_initialise_rate_control(pv_rc_api, /* RC handle */ |
| e_rate_control_type, /* RC algo type */ |
| 0, /* MB activity on/off */ |
| u4_avg_bit_rate, /* Avg Bitrate */ |
| au4_peak_bit_rate, /* Peak bitrate array[2]:[I][P] */ |
| u4_min_bit_rate, /* Min Bitrate */ |
| u4_src_frm_rate, /* Src frame_rate */ |
| u4_max_delay, /* Max buffer delay */ |
| u4_intra_frame_interval, /* Intra frm_interval */ |
| i4_inter_frm_int, /* Inter frame interval */ |
| pu1_init_qp, /* Init QP array[3]:[I][P][B] */ |
| u4_max_cpb_size, /* Max VBV/CPB Buffer Size */ |
| i4_max_inter_frm_int, /* Max inter frm_interval */ |
| i4_is_gop_closed, /* Open/Closed GOP */ |
| pu1_min_max_qp, /* Min-max QP array[6]:[Imax][Imin][Pmax][Pmin][Bmax][Bmin] */ |
| 0, /* How to calc the I-frame estimated_sad */ |
| u4_src_ticks, /* Src_ticks = LCM(src_frm_rate,tgt_frm_rate)/src_frm_rate */ |
| u4_tgt_ticks); /* Tgt_ticks = LCM(src_frm_rate,tgt_frm_rate)/tgt_frm_rate */ |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief Function to get picture details |
| * |
| * @par Description |
| * This function returns the Picture type(I/P/B) |
| * |
| * @param[in] pv_rc_api |
| * Handle to Rate control api |
| * |
| * @returns |
| * Picture type |
| * |
| * @remarks none |
| * |
| ******************************************************************************* |
| */ |
| picture_type_e ih264e_rc_get_picture_details(void *pv_rc_api, |
| WORD32 *pi4_pic_id, |
| WORD32 *pi4_pic_disp_order_no) |
| { |
| picture_type_e e_rc_pic_type = P_PIC; |
| |
| irc_get_picture_details(pv_rc_api, pi4_pic_id, pi4_pic_disp_order_no, |
| &e_rc_pic_type); |
| |
| return (e_rc_pic_type); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief Function to get rate control output before encoding |
| * |
| * @par Description |
| * This function is called before queing the current frame. It decides if we should |
| * skip the current iput buffer due to frame rate mismatch. It also updates RC about |
| * the acehivble frame rate |
| * |
| * @param[in] ps_rate_control_api |
| * Handle to rate control api |
| * |
| * @param[in] ps_pd_frm_rate |
| * Handle to pull down frm rate context |
| * |
| * @param[in] ps_time_stamp |
| * Handle to time stamp context |
| * |
| * @param[in] ps_frame_time |
| * Handle to frame time context |
| * |
| * @param[in] i4_delta_time_stamp |
| * Time stamp difference between frames |
| * |
| * @param[in] i4_total_mb_in_frame |
| * Total Macro Blocks in frame |
| * |
| * @param[in/out] pe_vop_coding_type |
| * Picture coding type(I/P/B) |
| * |
| * @param[in/out] pu1_frame_qp |
| * QP for current frame |
| * |
| * @returns |
| * Skip or queue the current frame |
| * |
| * @remarks |
| * |
| ******************************************************************************* |
| */ |
| WORD32 ih264e_update_rc_framerates(void *ps_rate_control_api, |
| void *ps_pd_frm_rate, |
| void *ps_time_stamp, |
| void *ps_frame_time) |
| { |
| WORD8 i4_skip_src = 0; |
| UWORD32 u4_src_not_skipped_for_dts = 0; |
| |
| /* Update the time stamp for the current frame */ |
| ih264e_update_time_stamp(ps_time_stamp); |
| |
| /* Check if a src not needs to be skipped */ |
| i4_skip_src = ih264e_should_src_be_skipped(ps_frame_time, |
| 1, |
| &u4_src_not_skipped_for_dts); |
| |
| if (i4_skip_src) |
| { |
| /*********************************************************************** |
| *Based on difference in source and target frame rate frames are skipped |
| ***********************************************************************/ |
| /*update the missing frames frm_rate with 0 */ |
| ih264e_update_pd_frm_rate(ps_pd_frm_rate, 0); |
| } |
| else |
| { |
| WORD32 i4_avg_frm_rate, i4_source_frame_rate; |
| |
| i4_source_frame_rate = ih264e_frame_time_get_src_frame_rate( |
| ps_frame_time); |
| |
| /* Update the frame rate of the frame present with the tgt_frm_rate */ |
| /* If the frm was not skipped due to delta_time_stamp, update the |
| frame_rate with double the tgt_frame_rate value, so that it makes |
| up for one of the frames skipped by the application */ |
| ih264e_update_pd_frm_rate(ps_pd_frm_rate, i4_source_frame_rate); |
| |
| /* Based on the update get the average frame rate */ |
| i4_avg_frm_rate = ih264e_get_pd_avg_frm_rate(ps_pd_frm_rate); |
| |
| /* Call the RC library function to change the frame_rate to the |
| actually achieved frm_rate */ |
| irc_change_frm_rate_for_bit_alloc(ps_rate_control_api, i4_avg_frm_rate); |
| } |
| |
| return (i4_skip_src); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief Function to update mb info for rate control context |
| * |
| * @par Description |
| * After encoding a mb, information such as mb type, qp used, mb distortion |
| * resulted in encoding the block and so on needs to be preserved for modeling |
| * RC. This is preserved via this function call. |
| * |
| * @param[in] ps_frame_info |
| * Handle Frame info context |
| * |
| * @param[in] ps_proc |
| * Process context |
| * |
| * @returns |
| * |
| * @remarks |
| * |
| ******************************************************************************* |
| */ |
| void ih264e_update_rc_mb_info(frame_info_t *ps_frame_info, void *pv_proc) |
| { |
| /* proc ctxt */ |
| process_ctxt_t *ps_proc = pv_proc; |
| |
| /* is intra or inter */ |
| WORD32 mb_type = !ps_proc->u4_is_intra; |
| |
| /* distortion */ |
| ps_frame_info->tot_mb_sad[mb_type] += ps_proc->i4_mb_distortion; |
| |
| /* qp */ |
| ps_frame_info->qp_sum[mb_type] += gau1_h264_to_mpeg2_qmap[ps_proc->u4_mb_qp]; |
| |
| /* mb cnt */ |
| ps_frame_info->num_mbs[mb_type]++; |
| |
| /* cost */ |
| if (ps_proc->u4_is_intra) |
| { |
| ps_frame_info->intra_mb_cost_sum += ps_proc->i4_mb_cost; |
| } |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief Function to get rate control buffer status |
| * |
| * @par Description |
| * This function is used to get buffer status(underflow/overflow) by rate |
| * control module |
| * |
| * @param[in] pv_rc_api |
| * Handle to rate control api context |
| * |
| * @param[in] i4_total_frame_bits |
| * Total frame bits |
| * |
| * @param[in] u1_pic_type |
| * Picture type |
| * |
| * @param[in] pi4_num_bits_to_prevent_vbv_underflow |
| * Number of bits to prevent underflow |
| * |
| * @param[out] pu1_is_enc_buf_overflow |
| * Buffer overflow indication flag |
| * |
| * @param[out] pu1_is_enc_buf_underflow |
| * Buffer underflow indication flag |
| * |
| * @returns |
| * |
| * @remarks |
| * |
| ******************************************************************************* |
| */ |
| void ih264e_rc_get_buffer_status(void *pv_rc_api, |
| WORD32 i4_total_frame_bits, |
| picture_type_e e_pic_type, |
| WORD32 *pi4_num_bits_to_prevent_vbv_underflow, |
| UWORD8 *pu1_is_enc_buf_overflow, |
| UWORD8 *pu1_is_enc_buf_underflow) |
| { |
| vbv_buf_status_e e_vbv_buf_status = VBV_NORMAL; |
| |
| e_vbv_buf_status = irc_get_buffer_status(pv_rc_api, |
| i4_total_frame_bits, |
| e_pic_type, |
| pi4_num_bits_to_prevent_vbv_underflow); |
| |
| if (e_vbv_buf_status == VBV_OVERFLOW) |
| { |
| *pu1_is_enc_buf_underflow = 1; |
| *pu1_is_enc_buf_overflow = 0; |
| } |
| else if (e_vbv_buf_status == VBV_UNDERFLOW) |
| { |
| *pu1_is_enc_buf_underflow = 0; |
| *pu1_is_enc_buf_overflow = 1; |
| } |
| else |
| { |
| *pu1_is_enc_buf_underflow = 0; |
| *pu1_is_enc_buf_overflow = 0; |
| } |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief Function to update rate control module after encoding |
| * |
| * @par Description |
| * This function is used to update the rate control module after the current |
| * frame encoding is done with details such as bits consumed, SAD for I/P/B, |
| * intra cost ,mb type and other |
| * |
| * @param[in] ps_rate_control_api |
| * Handle to rate control api context |
| * |
| * @param[in] ps_frame_info |
| * Handle to frame info context |
| * |
| * @param[in] ps_pd_frm_rate |
| * Handle to pull down frame rate context |
| * |
| * @param[in] ps_time_stamp |
| * Handle to time stamp context |
| * |
| * @param[in] ps_frame_time |
| * Handle to frame time context |
| * |
| * @param[in] i4_total_mb_in_frame |
| * Total mb in frame |
| * |
| * @param[in] pe_vop_coding_type |
| * Picture coding type |
| * |
| * @param[in] i4_is_first_frame |
| * Is first frame |
| * |
| * @param[in] pi4_is_post_encode_skip |
| * Post encoding skip flag |
| * |
| * @param[in] u1_frame_qp |
| * Frame qp |
| * |
| * @param[in] pi4_num_intra_in_prev_frame |
| * Numberf of intra mbs in previous frame |
| * |
| * @param[in] pi4_avg_activity |
| * Average activity |
| * |
| * @returns |
| * |
| * @remarks |
| * |
| ******************************************************************************* |
| */ |
| WORD32 ih264e_rc_post_enc(void * ps_rate_control_api, |
| frame_info_t *ps_frame_info, |
| void * ps_pd_frm_rate, |
| void * ps_time_stamp, |
| void * ps_frame_time, |
| WORD32 i4_total_mb_in_frame, |
| picture_type_e *pe_vop_coding_type, |
| WORD32 i4_is_first_frame, |
| WORD32 *pi4_is_post_encode_skip, |
| UWORD8 u1_frame_qp, |
| WORD32 *pi4_num_intra_in_prev_frame, |
| WORD32 *pi4_avg_activity) |
| { |
| /* Variables for the update_frm_level_info */ |
| WORD32 ai4_tot_mb_in_type[MAX_MB_TYPE]; |
| WORD32 ai4_tot_mb_type_qp[MAX_MB_TYPE] = {0, 0}; |
| WORD32 ai4_mb_type_sad[MAX_MB_TYPE] = {0, 0}; |
| WORD32 ai4_mb_type_tex_bits[MAX_MB_TYPE] = {0, 0}; |
| WORD32 i4_total_frame_bits = 0; |
| WORD32 i4_total_hdr_bits = 0; |
| WORD32 i4_total_texturebits; |
| WORD32 i4_avg_mb_activity = 0; |
| WORD32 i4_intra_frm_cost = 0; |
| UWORD8 u1_is_scd = 0; |
| WORD32 i4_cbr_bits_to_stuff = 0; |
| UWORD32 u4_num_intra_in_prev_frame = *pi4_num_intra_in_prev_frame; |
| UNUSED(ps_pd_frm_rate); |
| UNUSED(ps_time_stamp); |
| UNUSED(ps_frame_time); |
| UNUSED(u1_frame_qp); |
| /* Accumulate RC stats */ |
| ai4_tot_mb_in_type[MB_TYPE_INTRA] = irc_fi_get_total_mb(ps_frame_info,MB_TYPE_INTRA); |
| ai4_tot_mb_in_type[MB_TYPE_INTER] = irc_fi_get_total_mb(ps_frame_info,MB_TYPE_INTER); |
| /* ai4_tot_mb_type_qp[MB_TYPE_INTRA] = 0; |
| ai4_tot_mb_type_qp[MB_TYPE_INTER] = ps_enc->pu1_h264_mpg2quant[u1_frame_qp] * i4_total_mb_in_frame;*/ |
| ai4_tot_mb_type_qp[MB_TYPE_INTRA] = irc_fi_get_total_mb_qp(ps_frame_info,MB_TYPE_INTRA); |
| ai4_tot_mb_type_qp[MB_TYPE_INTER] = irc_fi_get_total_mb_qp(ps_frame_info,MB_TYPE_INTER); |
| ai4_mb_type_sad[MB_TYPE_INTRA] = irc_fi_get_total_mb_sad(ps_frame_info,MB_TYPE_INTRA); |
| ai4_mb_type_sad[MB_TYPE_INTER] = irc_fi_get_total_mb_sad(ps_frame_info,MB_TYPE_INTER); |
| i4_intra_frm_cost = irc_fi_get_total_intra_mb_cost(ps_frame_info); |
| i4_avg_mb_activity = irc_fi_get_avg_activity(ps_frame_info); |
| i4_total_hdr_bits = irc_fi_get_total_header_bits(ps_frame_info); |
| i4_total_texturebits = irc_fi_get_total_mb_texture_bits(ps_frame_info,MB_TYPE_INTRA); |
| i4_total_texturebits += irc_fi_get_total_mb_texture_bits(ps_frame_info,MB_TYPE_INTER); |
| i4_total_frame_bits = i4_total_hdr_bits + i4_total_texturebits ; |
| |
| *pi4_avg_activity = i4_avg_mb_activity; |
| |
| |
| /* Texture bits are not accumulated. Hence subtracting hdr bits from total bits */ |
| ai4_mb_type_tex_bits[MB_TYPE_INTRA] = 0; |
| ai4_mb_type_tex_bits[MB_TYPE_INTER] = i4_total_frame_bits - i4_total_hdr_bits; |
| |
| /* Set post encode skip to zero */ |
| pi4_is_post_encode_skip[0]= 0; |
| |
| /* For NLDRC, get the buffer status for stuffing or skipping */ |
| if (irc_get_rc_type(ps_rate_control_api) == CBR_NLDRC) |
| { |
| WORD32 i4_get_num_bit_to_prevent_vbv_overflow; |
| UWORD8 u1_enc_buf_overflow,u1_enc_buf_underflow; |
| |
| /* Getting the buffer status */ |
| ih264e_rc_get_buffer_status(ps_rate_control_api, i4_total_frame_bits, |
| pe_vop_coding_type[0], &i4_get_num_bit_to_prevent_vbv_overflow, |
| &u1_enc_buf_overflow,&u1_enc_buf_underflow); |
| |
| /* We skip the frame if decoder buffer is underflowing. But we never skip first I frame */ |
| if ((u1_enc_buf_overflow == 1) && (i4_is_first_frame != 1)) |
| // if ((u1_enc_buf_overflow == 1) && (i4_is_first_frame != 0)) |
| { |
| irc_post_encode_frame_skip(ps_rate_control_api, (picture_type_e)pe_vop_coding_type[0]); |
| // i4_total_frame_bits = imp4_write_skip_frame_header(ps_enc); |
| i4_total_frame_bits = 0; |
| |
| *pi4_is_post_encode_skip = 1; |
| |
| /* Adjust the GOP if in case we skipped an I-frame */ |
| if (*pe_vop_coding_type == I_PIC) |
| irc_force_I_frame(ps_rate_control_api); |
| |
| /* Since this frame is skipped by writing 7 bytes header, we say this is a P frame */ |
| // *pe_vop_coding_type = P; |
| |
| /* Getting the buffer status again,to check if it underflows */ |
| irc_get_buffer_status(ps_rate_control_api, i4_total_frame_bits, |
| (picture_type_e)pe_vop_coding_type[0], &i4_get_num_bit_to_prevent_vbv_overflow); |
| |
| } |
| |
| /* In this case we stuff bytes as buffer is overflowing */ |
| if (u1_enc_buf_underflow == 1) |
| { |
| /* The stuffing function is directly pulled out from split controller workspace. |
| encode_vop_data() function makes sure alignment data is dumped at the end of a |
| frame. Split controller was identifying this alignment byte, overwriting it with |
| the stuff data and then finally aligning the buffer. Here every thing is inside |
| the DSP. So, ideally encode_vop_data needn't align, and we can start stuffing directly. |
| But in that case, it'll break the logic for a normal frame. |
| Hence for simplicity, not changing this part since it is ok to align and |
| then overwrite since stuffing is not done for every frame */ |
| i4_cbr_bits_to_stuff = irc_get_bits_to_stuff(ps_rate_control_api, i4_total_frame_bits, pe_vop_coding_type[0]); |
| |
| /* Just add extra 32 bits to make sure we don't stuff lesser */ |
| i4_cbr_bits_to_stuff += 32; |
| |
| /* We can not stuff more than the outbuf size. So have a check here */ |
| /* Add stuffed bits to total bits */ |
| i4_total_frame_bits += i4_cbr_bits_to_stuff; |
| } |
| } |
| |
| #define ENABLE_SCD 1 |
| #if ENABLE_SCD |
| /* If number of intra MBs are more than 2/3rd of total MBs, assume it as a scene change */ |
| if ((ai4_tot_mb_in_type[MB_TYPE_INTRA] > ((2 * i4_total_mb_in_frame) / 3)) && |
| (*pe_vop_coding_type == P_PIC) && |
| (ai4_tot_mb_in_type[MB_TYPE_INTRA] > ((11 * (WORD32)u4_num_intra_in_prev_frame) / 10))) |
| { |
| u1_is_scd = 1; |
| } |
| #endif |
| |
| /* Update num intra mbs of this frame */ |
| if (pi4_is_post_encode_skip[0] == 0) |
| { |
| *pi4_num_intra_in_prev_frame = ai4_tot_mb_in_type[MB_TYPE_INTRA]; |
| } |
| |
| /* Reset intra count to zero, if u encounter an I frame */ |
| if (*pe_vop_coding_type == I_PIC) |
| { |
| *pi4_num_intra_in_prev_frame = 0; |
| } |
| |
| /* Do an update of rate control after post encode */ |
| irc_update_frame_level_info(ps_rate_control_api, /* RC state */ |
| pe_vop_coding_type[0], /* PIC type */ |
| ai4_mb_type_sad, /* SAD for [Intra/Inter] */ |
| i4_total_frame_bits, /* Total frame bits */ |
| i4_total_hdr_bits, /* header bits for */ |
| ai4_mb_type_tex_bits, /* for MB[Intra/Inter] */ |
| ai4_tot_mb_type_qp, /* for MB[Intra/Inter] */ |
| ai4_tot_mb_in_type, /* for MB[Intra/Inter] */ |
| i4_avg_mb_activity, /* Average mb activity in frame */ |
| u1_is_scd, /* Is a scene change detected */ |
| 0, /* Pre encode skip */ |
| (WORD32)i4_intra_frm_cost, /* Intra cost for frame */ |
| 0); /* Not done outside */ |
| |
| return (i4_cbr_bits_to_stuff >> 3); |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief Function to update bits consumed info to rate control context |
| * |
| * @par Description |
| * Function to update bits consume info to rate control context |
| * |
| * @param[in] ps_frame_info |
| * Frame info context |
| * |
| * @param[in] ps_entropy |
| * Entropy context |
| * |
| * @returns |
| * total bits consumed by the frame |
| * |
| * @remarks |
| * |
| ******************************************************************************* |
| */ |
| void ih264e_update_rc_bits_info(frame_info_t *ps_frame_info, void *pv_entropy) |
| { |
| entropy_ctxt_t *ps_entropy = pv_entropy; |
| |
| ps_frame_info->mb_header_bits[MB_TYPE_INTRA] += ps_entropy->u4_header_bits[MB_TYPE_INTRA]; |
| |
| ps_frame_info->mb_texture_bits[MB_TYPE_INTRA] += ps_entropy->u4_residue_bits[MB_TYPE_INTRA]; |
| |
| ps_frame_info->mb_header_bits[MB_TYPE_INTER] += ps_entropy->u4_header_bits[MB_TYPE_INTER]; |
| |
| ps_frame_info->mb_texture_bits[MB_TYPE_INTER] += ps_entropy->u4_residue_bits[MB_TYPE_INTER]; |
| |
| return; |
| } |
| |
