You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
731 lines
25 KiB
731 lines
25 KiB
/******************************************************************************
|
|
*
|
|
* 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;
|
|
}
|
|
|