p71924506
/
aosp12
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
aosp12/external/libavc/encoder/ih264e_rate_control.c

731 lines
25 KiB
C
Raw Normal View History

init from android-12.1.0_r8
2023-01-09 17:11:35 +08:00
/******************************************************************************
*
* 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;
}