| /****************************************************************************** |
| * |
| * 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 Includes */ |
| /*****************************************************************************/ |
| |
| /* System include files */ |
| #include <stdio.h> |
| |
| /* User include files */ |
| #include "irc_datatypes.h" |
| #include "irc_cntrl_param.h" |
| #include "irc_common.h" |
| #include "irc_mem_req_and_acq.h" |
| #include "irc_fixed_point_error_bits.h" |
| #include "irc_cbr_buffer_control.h" |
| #include "irc_trace_support.h" |
| |
| typedef struct cbr_buffer_t |
| { |
| /* Buffer size = Delay * Bitrate*/ |
| WORD32 i4_buffer_size; |
| |
| /* Constant drain rate */ |
| WORD32 i4_drain_bits_per_frame[MAX_NUM_DRAIN_RATES]; |
| |
| /* Encoder Buffer Fullness */ |
| WORD32 i4_ebf; |
| |
| /* Upper threshold of the Buffer */ |
| WORD32 i4_upr_thr[MAX_PIC_TYPE]; |
| |
| /* Lower threshold of the Buffer */ |
| WORD32 i4_low_thr[MAX_PIC_TYPE]; |
| |
| /* Stuffing threshold equal to error bits per second in the drain bits |
| * fixed point computation */ |
| WORD32 i4_stuffing_threshold; |
| |
| /* For error due to bits per frame calculation */ |
| error_bits_handle aps_bpf_error_bits[MAX_NUM_DRAIN_RATES]; |
| |
| /* Whether the buffer model is used for CBR or VBR streaming */ |
| WORD32 i4_is_cbr_mode; |
| |
| /* Input parameters stored for initialization */ |
| WORD32 ai4_bit_rate[MAX_NUM_DRAIN_RATES]; |
| |
| WORD32 i4_max_delay; |
| |
| WORD32 ai4_num_pics_in_delay_period[MAX_PIC_TYPE]; |
| |
| WORD32 i4_tgt_frm_rate; |
| |
| UWORD32 u4_max_vbv_buf_size; |
| |
| } cbr_buffer_t; |
| |
| WORD32 irc_cbr_buffer_num_fill_use_free_memtab(cbr_buffer_t **pps_cbr_buffer, |
| itt_memtab_t *ps_memtab, |
| ITT_FUNC_TYPE_E e_func_type) |
| { |
| WORD32 i4_mem_tab_idx = 0, i; |
| cbr_buffer_t s_cbr_buffer_temp; |
| |
| /* |
| * Hack for all alloc, during which we don't have any state memory. |
| * Dereferencing can cause issues |
| */ |
| if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB) |
| (*pps_cbr_buffer) = &s_cbr_buffer_temp; |
| |
| if(e_func_type != GET_NUM_MEMTAB) |
| { |
| fill_memtab(&ps_memtab[i4_mem_tab_idx], sizeof(cbr_buffer_t), |
| ALIGN_128_BYTE, PERSISTENT, DDR); |
| use_or_fill_base(&ps_memtab[0], (void**)pps_cbr_buffer, e_func_type); |
| } |
| i4_mem_tab_idx++; |
| |
| for(i = 0; i < MAX_NUM_DRAIN_RATES; i++) |
| { |
| i4_mem_tab_idx += irc_error_bits_num_fill_use_free_memtab( |
| &pps_cbr_buffer[0]->aps_bpf_error_bits[i], |
| &ps_memtab[i4_mem_tab_idx], e_func_type); |
| } |
| return (i4_mem_tab_idx); |
| } |
| |
| /****************************************************************************** |
| * @brief Initialize the CBR VBV buffer state. |
| * This could however be used for VBR streaming VBV also |
| * |
| ******************************************************************************/ |
| void irc_init_cbr_buffer(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_buffer_delay, |
| WORD32 i4_tgt_frm_rate, |
| WORD32 *i4_bit_rate, |
| UWORD32 *u4_num_pics_in_delay_prd, |
| UWORD32 u4_vbv_buf_size) |
| { |
| WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES]; |
| int i; |
| |
| for(i = 0; i < MAX_NUM_DRAIN_RATES; i++) |
| { |
| X_PROD_Y_DIV_Z(i4_bit_rate[i], 1000, i4_tgt_frm_rate, |
| i4_bits_per_frm[i]); |
| /* Drain rate = bitrate/(framerate/1000) */ |
| ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i]; |
| /* Initialize the bits per frame error bits calculation */ |
| irc_init_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i], |
| i4_tgt_frm_rate, i4_bit_rate[i]); |
| } |
| |
| /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/ |
| /* This would mean CBR mode */ |
| if(i4_bit_rate[0] == i4_bit_rate[1]) |
| { |
| X_PROD_Y_DIV_Z(i4_bit_rate[0], i4_buffer_delay, 1000, |
| ps_cbr_buffer->i4_buffer_size); |
| ps_cbr_buffer->i4_is_cbr_mode = 1; |
| } |
| else |
| { |
| /* VBR streaming case which has different drain rates for I and P */ |
| ps_cbr_buffer->i4_buffer_size = u4_num_pics_in_delay_prd[0] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[0] |
| + u4_num_pics_in_delay_prd[1] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| ps_cbr_buffer->i4_is_cbr_mode = 0; |
| } |
| |
| if(ps_cbr_buffer->i4_buffer_size > (WORD32)u4_vbv_buf_size) |
| { |
| ps_cbr_buffer->i4_buffer_size = u4_vbv_buf_size; |
| } |
| |
| /* Initially Encoder buffer fullness is zero */ |
| ps_cbr_buffer->i4_ebf = 0; |
| |
| /* tgt_frame_rate is divided by 1000 because, an approximate value is fine |
| * as this is just a threshold below which stuffing is done to avoid buffer |
| * underflow due to fixed point error in drain rate |
| */ |
| ps_cbr_buffer->i4_stuffing_threshold = (i4_bit_rate[0] |
| - (i4_bits_per_frm[0] * (i4_tgt_frm_rate / 1000))); |
| |
| for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++) |
| { |
| /* |
| * Upper threshold for |
| * I frame = 1 * bits per frame |
| * P Frame = 4 * bits per frame. |
| * The threshold for I frame is only 1 * bits per frame as the threshold |
| * should only account for error in estimated bits. |
| * In P frame it should account for difference bets bits consumed by |
| * I(Scene change) and P frame I to P complexity is assumed to be 5. |
| */ |
| WORD32 i4_index; |
| i4_index = i4_i > 0 ? 1 : 0; |
| ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size |
| - (ps_cbr_buffer->i4_buffer_size >> 3); |
| |
| /* |
| * For both I and P frame Lower threshold is equal to drain rate.Even if |
| * the encoder consumes zero bits it should have enough bits to drain |
| */ |
| ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index]; |
| } |
| |
| /* Storing the input parameters for using it for change functions */ |
| for(i = 0; i < MAX_NUM_DRAIN_RATES; i++) |
| { |
| ps_cbr_buffer->ai4_bit_rate[i] = i4_bit_rate[i]; |
| } |
| |
| for(i = 0; i < MAX_PIC_TYPE; i++) |
| { |
| ps_cbr_buffer->ai4_num_pics_in_delay_period[i] = |
| u4_num_pics_in_delay_prd[i]; |
| } |
| ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate; |
| ps_cbr_buffer->i4_max_delay = i4_buffer_delay; |
| ps_cbr_buffer->u4_max_vbv_buf_size = u4_vbv_buf_size; |
| } |
| |
| /****************************************************************************** |
| * @brief Condition check for constraining the number of bits allocated based on |
| * bufer size |
| ******************************************************************************/ |
| WORD32 irc_cbr_buffer_constraint_check(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_tgt_bits, |
| picture_type_e e_pic_type) |
| { |
| WORD32 i4_max_tgt_bits, i4_min_tgt_bits; |
| WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ? |
| ps_cbr_buffer->i4_drain_bits_per_frame[0] : |
| ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| /* Max tgt bits = Upper threshold - current encoder buffer fullness */ |
| i4_max_tgt_bits = ps_cbr_buffer->i4_upr_thr[e_pic_type] |
| - ps_cbr_buffer->i4_ebf; |
| /* Max tgt bits cannot be negative */ |
| if(i4_max_tgt_bits < 0) |
| i4_max_tgt_bits = 0; |
| |
| /* |
| * Min tgt bits , least number of bits in the Encoder after |
| * draining such that it is greater than lower threshold |
| */ |
| i4_min_tgt_bits = ps_cbr_buffer->i4_low_thr[e_pic_type] |
| - (ps_cbr_buffer->i4_ebf - i4_drain_bits_per_frame); |
| /* Min tgt bits cannot be negative */ |
| if(i4_min_tgt_bits < 0) |
| i4_min_tgt_bits = 0; |
| |
| /* Current tgt bits should be between max and min tgt bits */ |
| CLIP(i4_tgt_bits, i4_max_tgt_bits, i4_min_tgt_bits); |
| return i4_tgt_bits; |
| } |
| |
| /* ***************************************************************************** |
| * @brief constaints the bit allocation based on buffer size |
| * |
| ******************************************************************************/ |
| WORD32 irc_vbr_stream_buffer_constraint_check(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_tgt_bits, |
| picture_type_e e_pic_type) |
| { |
| WORD32 i4_max_tgt_bits; |
| |
| /* Max tgt bits = Upper threshold - current encoder buffer fullness */ |
| i4_max_tgt_bits = ps_cbr_buffer->i4_upr_thr[e_pic_type] |
| - ps_cbr_buffer->i4_ebf; |
| |
| /* Max tgt bits cannot be negative */ |
| if(i4_max_tgt_bits < 0) |
| i4_max_tgt_bits = 0; |
| |
| if(i4_tgt_bits > i4_max_tgt_bits) |
| i4_tgt_bits = i4_max_tgt_bits; |
| |
| return i4_tgt_bits; |
| } |
| |
| /* ***************************************************************************** |
| * @brief Verifies the buffer state and returns whether it is overflowing, |
| * underflowing or normal |
| * |
| ******************************************************************************/ |
| vbv_buf_status_e irc_get_cbr_buffer_status(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_tot_consumed_bits, |
| WORD32 *pi4_num_bits_to_prevent_overflow, |
| picture_type_e e_pic_type) |
| { |
| vbv_buf_status_e e_buf_status; |
| WORD32 i4_cur_enc_buf; |
| WORD32 i4_error_bits = (e_pic_type == I_PIC) ? |
| irc_get_error_bits(ps_cbr_buffer |
| ->aps_bpf_error_bits[0]) : |
| irc_get_error_bits(ps_cbr_buffer |
| ->aps_bpf_error_bits[1]); |
| |
| WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ? |
| ps_cbr_buffer->i4_drain_bits_per_frame[0] : |
| ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| /* Add the tot consumed bits to the Encoder Buffer*/ |
| i4_cur_enc_buf = ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits; |
| |
| /* If the Encoder exceeds the Buffer Size signal an Overflow*/ |
| if(i4_cur_enc_buf > ps_cbr_buffer->i4_buffer_size) |
| { |
| e_buf_status = VBV_OVERFLOW; |
| i4_cur_enc_buf = ps_cbr_buffer->i4_buffer_size; |
| } |
| else |
| { |
| /* |
| * Subtract the constant drain bits and error bits due to fixed point |
| * implementation |
| */ |
| i4_cur_enc_buf -= (i4_drain_bits_per_frame + i4_error_bits); |
| |
| /* |
| * If the buffer is less than stuffing threshold an Underflow is |
| * signaled else its NORMAL |
| */ |
| if(i4_cur_enc_buf < ps_cbr_buffer->i4_stuffing_threshold) |
| { |
| e_buf_status = VBV_UNDERFLOW; |
| } |
| else |
| { |
| e_buf_status = VBV_NORMAL; |
| } |
| |
| if(i4_cur_enc_buf < 0) |
| i4_cur_enc_buf = 0; |
| } |
| |
| /* |
| * The RC lib models the encoder buffer, but the VBV buffer characterizes |
| * the decoder buffer |
| */ |
| if(e_buf_status == VBV_OVERFLOW) |
| { |
| e_buf_status = VBV_UNDERFLOW; |
| } |
| else if(e_buf_status == VBV_UNDERFLOW) |
| { |
| e_buf_status = VBV_OVERFLOW; |
| } |
| |
| pi4_num_bits_to_prevent_overflow[0] = (ps_cbr_buffer->i4_buffer_size |
| - i4_cur_enc_buf); |
| |
| return e_buf_status; |
| } |
| |
| /******************************************************************************* |
| * @brief Based on the bits consumed the buffer model is updated |
| ******************************************************************************/ |
| void irc_update_cbr_buffer(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_tot_consumed_bits, |
| picture_type_e e_pic_type) |
| { |
| WORD32 i4_error_bits = (e_pic_type == I_PIC) ? |
| irc_get_error_bits(ps_cbr_buffer-> |
| aps_bpf_error_bits[0]) : |
| irc_get_error_bits( ps_cbr_buffer-> |
| aps_bpf_error_bits[1]); |
| |
| WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ? |
| ps_cbr_buffer->i4_drain_bits_per_frame[0] : |
| ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| /* Update the Encoder buffer with the total consumed bits*/ |
| ps_cbr_buffer->i4_ebf += i4_tot_consumed_bits; |
| |
| /* |
| * Subtract the drain bits and error bits due to fixed point |
| * implementation |
| */ |
| ps_cbr_buffer->i4_ebf -= (i4_drain_bits_per_frame + i4_error_bits); |
| |
| if(ps_cbr_buffer->i4_ebf < 0) |
| ps_cbr_buffer->i4_ebf = 0; |
| |
| /*SS - Fix for lack of stuffing*/ |
| if(ps_cbr_buffer->i4_ebf > ps_cbr_buffer->i4_buffer_size) |
| { |
| trace_printf( |
| (const WORD8*)"Error: Should not be coming here with stuffing\n"); |
| ps_cbr_buffer->i4_ebf = ps_cbr_buffer->i4_buffer_size; |
| } |
| } |
| |
| /******************************************************************************* |
| * @brief If the buffer underflows then return the number of bits to prevent |
| * underflow |
| * |
| ******************************************************************************/ |
| WORD32 irc_get_cbr_bits_to_stuff(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_tot_consumed_bits, |
| picture_type_e e_pic_type) |
| { |
| WORD32 i4_bits_to_stuff; |
| WORD32 i4_error_bits = (e_pic_type == I_PIC) ? |
| irc_get_error_bits(ps_cbr_buffer |
| ->aps_bpf_error_bits[0]) : |
| irc_get_error_bits(ps_cbr_buffer |
| ->aps_bpf_error_bits[1]); |
| |
| WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ? |
| ps_cbr_buffer->i4_drain_bits_per_frame[0] : |
| ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| /* |
| * Stuffing bits got from the following equation |
| * Stuffing_threshold = ebf + tcb - drain bits - error bits + stuff_bits |
| */ |
| i4_bits_to_stuff = i4_drain_bits_per_frame + i4_error_bits |
| + ps_cbr_buffer->i4_stuffing_threshold |
| - (ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits); |
| |
| return i4_bits_to_stuff; |
| } |
| |
| /******************************************************************************* |
| * @brief Update the state for change in number of pics in the delay period |
| * |
| ******************************************************************************/ |
| void irc_change_cbr_vbv_num_pics_in_delay_period(cbr_buffer_t *ps_cbr_buffer, |
| UWORD32 *u4_num_pics_in_delay_prd) |
| { |
| WORD32 i; |
| |
| if(!ps_cbr_buffer->i4_is_cbr_mode) |
| { |
| ps_cbr_buffer->i4_buffer_size = |
| u4_num_pics_in_delay_prd[0] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[0] |
| + u4_num_pics_in_delay_prd[1] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| if(ps_cbr_buffer->i4_buffer_size |
| > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size) |
| { |
| ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size; |
| } |
| for(i = 0; i < MAX_PIC_TYPE; i++) |
| { |
| ps_cbr_buffer->i4_upr_thr[i] = ps_cbr_buffer->i4_buffer_size |
| - (ps_cbr_buffer->i4_buffer_size >> 3); |
| } |
| |
| /* Re-initialize the number of pics in delay period */ |
| for(i = 0; i < MAX_PIC_TYPE; i++) |
| { |
| ps_cbr_buffer->ai4_num_pics_in_delay_period[i] = |
| u4_num_pics_in_delay_prd[i]; |
| } |
| } |
| } |
| |
| /****************************************************************************** |
| * @brief update the state for change in target frame rate |
| * |
| ******************************************************************************/ |
| void irc_change_cbr_vbv_tgt_frame_rate(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_tgt_frm_rate) |
| { |
| WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES]; |
| int i; |
| |
| for(i = 0; i < MAX_NUM_DRAIN_RATES; i++) |
| { |
| X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[i], 1000, i4_tgt_frm_rate, |
| i4_bits_per_frm[i]); |
| /* Drain rate = bitrate/(framerate/1000) */ |
| ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i]; |
| /* Initialize the bits per frame error bits calculation */ |
| irc_change_frm_rate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i], |
| i4_tgt_frm_rate); |
| } |
| |
| /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/ |
| if(!ps_cbr_buffer->i4_is_cbr_mode) |
| { |
| /* VBR streaming case which has different drain rates for I and P */ |
| ps_cbr_buffer->i4_buffer_size = |
| ps_cbr_buffer->ai4_num_pics_in_delay_period[0] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[0] |
| + ps_cbr_buffer->ai4_num_pics_in_delay_period[1] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| } |
| |
| if(ps_cbr_buffer->i4_buffer_size |
| > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size) |
| { |
| ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size; |
| } |
| |
| /* |
| * Tgt_frame_rate is divided by 1000 because an approximate value is fine as |
| * this is just a threshold below which stuffing is done to avoid buffer |
| * underflow due to fixed point error in drain rate |
| */ |
| ps_cbr_buffer->i4_stuffing_threshold = (ps_cbr_buffer->ai4_bit_rate[0] |
| - (i4_bits_per_frm[0] * (i4_tgt_frm_rate / 1000))); |
| |
| for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++) |
| { |
| /* |
| * Upper threshold for |
| * I frame = 1 * bits per frame |
| * P Frame = 4 * bits per frame. |
| * The threshold for I frame is only 1 * bits per frame as the threshold should |
| * only account for error in estimated bits. |
| * In P frame it should account for difference bets bits consumed by I(Scene change) |
| * and P frame I to P complexity is assumed to be 5. |
| */ |
| WORD32 i4_index; |
| i4_index = i4_i > 0 ? 1 : 0; |
| ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size |
| - (ps_cbr_buffer->i4_buffer_size >> 3); |
| |
| /* |
| * For both I and P frame Lower threshold is equal to drain rate. |
| * Even if the encoder consumes zero bits it should have enough bits to |
| * drain |
| */ |
| ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index]; |
| } |
| |
| /* Storing the input parameters for using it for change functions */ |
| ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate; |
| } |
| |
| /******************************************************************************* |
| * @brief Change the state for change in bit rate |
| * |
| ******************************************************************************/ |
| void irc_change_cbr_vbv_bit_rate(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 *i4_bit_rate) |
| { |
| WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES]; |
| int i; |
| |
| for(i = 0; i < MAX_NUM_DRAIN_RATES; i++) |
| { |
| X_PROD_Y_DIV_Z(i4_bit_rate[i], 1000, ps_cbr_buffer->i4_tgt_frm_rate, |
| i4_bits_per_frm[i]); |
| /* Drain rate = bitrate/(framerate/1000) */ |
| ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i]; |
| /* Initialize the bits per frame error bits calculation */ |
| irc_change_bitrate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i], |
| i4_bit_rate[i]); |
| } |
| |
| /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/ |
| if(i4_bit_rate[0] == i4_bit_rate[1]) /* This would mean CBR mode */ |
| { |
| X_PROD_Y_DIV_Z(i4_bit_rate[0], ps_cbr_buffer->i4_max_delay, 1000, |
| ps_cbr_buffer->i4_buffer_size); |
| ps_cbr_buffer->i4_is_cbr_mode = 1; |
| } |
| else |
| { |
| /* VBR streaming case which has different drain rates for I and P */ |
| ps_cbr_buffer->i4_buffer_size = |
| ps_cbr_buffer->ai4_num_pics_in_delay_period[0] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[0] |
| + ps_cbr_buffer->ai4_num_pics_in_delay_period[1] |
| * ps_cbr_buffer->i4_drain_bits_per_frame[1]; |
| |
| ps_cbr_buffer->i4_is_cbr_mode = 0; |
| } |
| |
| if(ps_cbr_buffer->i4_buffer_size |
| > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size) |
| { |
| ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size; |
| } |
| |
| /* |
| * tgt_frame_rate is divided by 1000 because |
| * an approximate value is fine as this is just a threshold below which |
| * stuffing is done to avoid buffer underflow due to fixed point |
| * error in drain rate |
| */ |
| ps_cbr_buffer->i4_stuffing_threshold = (i4_bit_rate[0] |
| - (i4_bits_per_frm[0] |
| * (ps_cbr_buffer->i4_tgt_frm_rate / 1000))); |
| |
| for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++) |
| { |
| /* |
| * Upper threshold for |
| * I frame = 1 * bits per frame |
| * P Frame = 4 * bits per frame. |
| * The threshold for I frame is only 1 * bits per frame as the threshold |
| * should only account for error in estimated bits. |
| * In P frame it should account for difference bets bits consumed by |
| * I(Scene change) and P frame I to P complexity is assumed to be 5. |
| */ |
| |
| WORD32 i4_index; |
| i4_index = i4_i > 0 ? 1 : 0; |
| ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size |
| - (ps_cbr_buffer->i4_buffer_size >> 3); |
| |
| /* For both I and P frame Lower threshold is equal to drain rate. |
| * Even if the encoder consumes zero bits it should have enough bits to |
| * drain |
| */ |
| ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index]; |
| } |
| |
| /* Storing the input parameters for using it for change functions */ |
| for(i = 0; i < MAX_NUM_DRAIN_RATES; i++) |
| { |
| ps_cbr_buffer->ai4_bit_rate[i] = i4_bit_rate[i]; |
| } |
| } |
| |
| void irc_change_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer, |
| WORD32 i4_buffer_delay) |
| { |
| WORD32 i4_i; |
| |
| /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/ |
| if(ps_cbr_buffer->i4_is_cbr_mode) |
| { |
| X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[0], i4_buffer_delay, 1000, |
| ps_cbr_buffer->i4_buffer_size); |
| } |
| |
| if(ps_cbr_buffer->i4_buffer_size |
| > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size) |
| { |
| ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size; |
| } |
| |
| for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++) |
| { |
| /* |
| * Upper threshold for |
| * I frame = 1 * bits per frame |
| * P Frame = 4 * bits per frame. |
| * The threshold for I frame is only 1 * bits per frame as the threshold |
| * should only account for error in estimated bits. |
| * In P frame it should account for difference bets bits consumed by I |
| * (Scene change) and P frame I to P complexity is assumed to be 5. |
| */ |
| ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size |
| - (ps_cbr_buffer->i4_buffer_size >> 3); |
| } |
| |
| /* Storing the input parameters for using it for change functions */ |
| ps_cbr_buffer->i4_max_delay = i4_buffer_delay; |
| } |
| |
| WORD32 irc_get_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer) |
| { |
| return (ps_cbr_buffer->i4_max_delay); |
| } |
| |
| WORD32 irc_get_cbr_buffer_size(cbr_buffer_t *ps_cbr_buffer) |
| { |
| return (ps_cbr_buffer->i4_buffer_size); |
| } |
