/src/libavc/encoder/irc_bit_allocation.c

Source
/******************************************************************************
 *
 * 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
*/

/** Includes */
#include <stdio.h>
#include <string.h>
#include "irc_datatypes.h"
#include "irc_mem_req_and_acq.h"
#include "irc_common.h"
#include "irc_cntrl_param.h"
#include "irc_fixed_point_error_bits.h"
#include "irc_rd_model.h"
#include "irc_est_sad.h"
#include "irc_picture_type.h"
#include "irc_bit_allocation.h"
#include "irc_trace_support.h"

/** Macros **/
#define MIN(x,y)  ((x) < (y))? (x) : (y)

/* State structure for bit allocation */
typedef struct
{
    /* using var_q number as it can cross 31 bits for large intra frameinterval */
    number_t vq_rem_bits_in_period;

    /* Storing inputs */
    WORD32 i4_tot_frms_in_gop;

    WORD32 i4_num_intra_frm_interval;

    WORD32 i4_bits_per_frm;

} rem_bit_in_prd_t;

typedef struct bit_allocation_t
{
    rem_bit_in_prd_t s_rbip;

    /* A universal constant giving the relative complexity between pictures */
    WORD32 i2_K[MAX_PIC_TYPE];

    /* To get a estimate of the header bits consumed */
    WORD32 i4_prev_frm_header_bits[MAX_PIC_TYPE];

    WORD32 i4_bits_per_frm;

    WORD32 i4_num_gops_in_period;

    /* Num gops as set by rate control module */
    WORD32 i4_actual_num_gops_in_period;

    number_t vq_saved_bits;

    WORD32 i4_max_bits_per_frm[MAX_NUM_DRAIN_RATES];

    WORD32 i4_min_bits_per_frm;

    /* Error bits module */
    error_bits_handle ps_error_bits;

    /* Storing frame rate */
    WORD32 i4_frame_rate;

    WORD32 i4_bit_rate;

    WORD32 ai4_peak_bit_rate[MAX_NUM_DRAIN_RATES];

} bit_allocation_t;

static WORD32 get_number_of_frms_in_a_gop(pic_handling_handle ps_pic_handling)
{
    WORD32 i4_tot_frms_in_gop = 0, i;
    WORD32 ai4_frms_in_gop[MAX_PIC_TYPE];

    /* Query the pic_handling struct for the rem frames in the period */
    irc_pic_type_get_frms_in_gop(ps_pic_handling, ai4_frms_in_gop);

    /* Get the total frms in the gop */
    i4_tot_frms_in_gop = 0;
    for(i = 0; i < MAX_PIC_TYPE; i++)
    {
        i4_tot_frms_in_gop += ai4_frms_in_gop[i];
    }
    return (i4_tot_frms_in_gop);
}

static void init_rbip(rem_bit_in_prd_t *ps_rbip,
                      pic_handling_handle ps_pic_handling,
                      WORD32 i4_bits_per_frm,
                      WORD32 i4_num_intra_frm_interval)
{
    WORD32 i4_tot_frms_in_gop = get_number_of_frms_in_a_gop(ps_pic_handling);

    /* rem_bits_in_period = bits_per_frm * tot_frms_in_gop * num_intra_frm_interval */
    {
        number_t vq_bits_per_frm, vq_tot_frms_in_gop, vq_num_intra_frm_interval;
        number_t *pvq_rem_bits_in_period = &ps_rbip->vq_rem_bits_in_period;

        SET_VAR_Q(vq_bits_per_frm, i4_bits_per_frm, 0);
        SET_VAR_Q(vq_tot_frms_in_gop, i4_tot_frms_in_gop, 0);
        SET_VAR_Q(vq_num_intra_frm_interval, i4_num_intra_frm_interval, 0);

        /* rem_bits_in_period = bits_per_frm * tot_frms_in_gop */
        mult32_var_q(vq_bits_per_frm, vq_tot_frms_in_gop,
                     pvq_rem_bits_in_period);

        /* rem_bits_in_period *= num_intra_frm_interval */
        mult32_var_q(vq_num_intra_frm_interval, pvq_rem_bits_in_period[0],
                     pvq_rem_bits_in_period);
    }

    /*
     * Store the total number of frames in GOP value which is
     * used from module A
     */
    ps_rbip->i4_tot_frms_in_gop = i4_tot_frms_in_gop;
    ps_rbip->i4_num_intra_frm_interval = i4_num_intra_frm_interval;
    ps_rbip->i4_bits_per_frm = i4_bits_per_frm;
}

static void check_update_rbip(rem_bit_in_prd_t *ps_rbip,
                              pic_handling_handle ps_pic_handling)
{
    /*
     * NOTE: Intra frame interval changes after the first I frame that is
     * encoded in a GOP
     */
    WORD32 i4_new_tot_frms_in_gop = get_number_of_frms_in_a_gop(
                    ps_pic_handling);

    if(i4_new_tot_frms_in_gop != ps_rbip->i4_tot_frms_in_gop)
    {
        WORD32 i4_rem_frames_in_period =
                        ps_rbip->i4_num_intra_frm_interval
                                        * (i4_new_tot_frms_in_gop
                                                        - ps_rbip->i4_tot_frms_in_gop);

        number_t vq_rem_frms_in_period, s_bits_per_frm, vq_delta_bits_in_period;

        SET_VAR_Q(vq_rem_frms_in_period, i4_rem_frames_in_period, 0);
        SET_VAR_Q(s_bits_per_frm, ps_rbip->i4_bits_per_frm, 0);

        /* delta_bits_in_period = bits_per_frm * rem_frms_in_period */
        mult32_var_q(s_bits_per_frm, vq_rem_frms_in_period,
                     &vq_delta_bits_in_period);

        /* rem_bits_in_period += delta_bits_in_period */
        add32_var_q(vq_delta_bits_in_period, ps_rbip->vq_rem_bits_in_period,
                    &ps_rbip->vq_rem_bits_in_period);
    }
    /* Updated the new values */
    ps_rbip->i4_tot_frms_in_gop = i4_new_tot_frms_in_gop;
}

static void irc_ba_update_rbip(rem_bit_in_prd_t *ps_rbip,
                               pic_handling_handle ps_pic_handling,
                               number_t vq_num_bits)
{
    check_update_rbip(ps_rbip, ps_pic_handling);

    /* rem_bits_in_period += num_of_bits */
    add32_var_q(vq_num_bits, ps_rbip->vq_rem_bits_in_period,
                &ps_rbip->vq_rem_bits_in_period);
}

static void irc_ba_change_rbip(rem_bit_in_prd_t *ps_rbip,
                               pic_handling_handle ps_pic_handling,
                               WORD32 i4_new_bits_per_frm,
                               WORD32 i4_new_num_intra_frm_interval)
{
    WORD32 ai4_rem_frms_in_period[MAX_PIC_TYPE], i4_rem_frms_in_gop, i;
    irc_pic_type_get_rem_frms_in_gop(ps_pic_handling, ai4_rem_frms_in_period);

    i4_rem_frms_in_gop = 0;
    for(i = 0; i < MAX_PIC_TYPE; i++)
        i4_rem_frms_in_gop += ai4_rem_frms_in_period[i];

    if(i4_new_bits_per_frm != ps_rbip->i4_bits_per_frm)
    {
        WORD32 i4_rem_frms_in_period = (ps_rbip->i4_num_intra_frm_interval - 1)
                        * ps_rbip->i4_tot_frms_in_gop + i4_rem_frms_in_gop;

        number_t vq_rem_frms_in_period, vq_delta_bits_per_frm,
                        vq_delta_bits_in_period;

        /* delta_bits_per_frm = new_bits_per_frm - old_bits_per_frm */
        SET_VAR_Q(vq_delta_bits_per_frm,
                  (i4_new_bits_per_frm - ps_rbip->i4_bits_per_frm), 0);

        SET_VAR_Q(vq_rem_frms_in_period, i4_rem_frms_in_period, 0);

        /* delta_bits_in_period = delta_bits_per_frm * rem_frms_in_period */
        mult32_var_q(vq_delta_bits_per_frm, vq_rem_frms_in_period,
                     &vq_delta_bits_in_period);

        /* ps_rbip->rem_bits_in_period += delta_bits_in_period */
        add32_var_q(vq_delta_bits_in_period, ps_rbip->vq_rem_bits_in_period,
                    &ps_rbip->vq_rem_bits_in_period);
    }

    if(i4_new_num_intra_frm_interval != ps_rbip->i4_num_intra_frm_interval)
    {
        WORD32 i4_rem_frms_in_period = ps_rbip->i4_tot_frms_in_gop
                        * (i4_new_num_intra_frm_interval
                                        - ps_rbip->i4_num_intra_frm_interval);

        number_t vq_rem_frms_in_period, vq_new_bits_per_frm,
                        vq_delta_bits_in_period;

        /* new_bits_per_frm = new_new_bits_per_frm - old_new_bits_per_frm */
        SET_VAR_Q(vq_new_bits_per_frm, i4_new_bits_per_frm, 0);

        SET_VAR_Q(vq_rem_frms_in_period, i4_rem_frms_in_period, 0);

        /* delta_bits_in_period = new_bits_per_frm * rem_frms_in_period */
        mult32_var_q(vq_new_bits_per_frm, vq_rem_frms_in_period,
                     &vq_delta_bits_in_period);

        /* ps_rbip->rem_bits_in_period += delta_bits_in_period */
        add32_var_q(vq_delta_bits_in_period, ps_rbip->vq_rem_bits_in_period,
                    &ps_rbip->vq_rem_bits_in_period);
    }
    /* Update the new value */
    ps_rbip->i4_num_intra_frm_interval = i4_new_num_intra_frm_interval;
    ps_rbip->i4_bits_per_frm = i4_new_bits_per_frm;
}

WORD32 irc_ba_num_fill_use_free_memtab(bit_allocation_t **pps_bit_allocation,
                                       itt_memtab_t *ps_memtab,
                                       ITT_FUNC_TYPE_E e_func_type)
{
    WORD32 i4_mem_tab_idx = 0;
    bit_allocation_t s_bit_allocation_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_bit_allocation) = &s_bit_allocation_temp;

    /*for src rate control state structure*/
    if(e_func_type != GET_NUM_MEMTAB)
    {
        fill_memtab(&ps_memtab[i4_mem_tab_idx], sizeof(bit_allocation_t),
                    ALIGN_128_BYTE, PERSISTENT, DDR);
        use_or_fill_base(&ps_memtab[0], (void**)pps_bit_allocation,
                         e_func_type);
    }
    i4_mem_tab_idx++;

    i4_mem_tab_idx += irc_error_bits_num_fill_use_free_memtab(
                    &pps_bit_allocation[0]->ps_error_bits,
                    &ps_memtab[i4_mem_tab_idx], e_func_type);

    return (i4_mem_tab_idx);
}

/*******************************************************************************
 Function Name : irc_ba_init_bit_allocation
 Description   : Initialize the bit_allocation structure.
 ******************************************************************************/
void irc_ba_init_bit_allocation(bit_allocation_t *ps_bit_allocation,
                                pic_handling_handle ps_pic_handling,
                                WORD32 i4_num_intra_frm_interval,
                                WORD32 i4_bit_rate,
                                WORD32 i4_frm_rate,
                                WORD32 *i4_peak_bit_rate,
                                WORD32 i4_min_bitrate)
{
    WORD32 i;
    WORD32 i4_bits_per_frm, i4_max_bits_per_frm[MAX_NUM_DRAIN_RATES];

    /* Calculate the bits per frame */
    X_PROD_Y_DIV_Z(i4_bit_rate, 1000, i4_frm_rate, i4_bits_per_frm);
    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
    {
        X_PROD_Y_DIV_Z(i4_peak_bit_rate[i], 1000, i4_frm_rate,
                       i4_max_bits_per_frm[i]);
    }
    /* Initialize the bits_per_frame */
    ps_bit_allocation->i4_bits_per_frm = i4_bits_per_frm;
    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
    {
        ps_bit_allocation->i4_max_bits_per_frm[i] = i4_max_bits_per_frm[i];
    }
    X_PROD_Y_DIV_Z(i4_min_bitrate, 1000, i4_frm_rate,
                   ps_bit_allocation->i4_min_bits_per_frm);

    /*
     * Initialize the rem_bits in period
     * The first gop in case of an OPEN GOP may have fewer B_PICs,
     * That condition is not taken care of
     */
    init_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, i4_bits_per_frm,
              i4_num_intra_frm_interval);

    /* Initialize the num_gops_in_period */
    ps_bit_allocation->i4_num_gops_in_period = i4_num_intra_frm_interval;
    ps_bit_allocation->i4_actual_num_gops_in_period = i4_num_intra_frm_interval;

    /* Relative complexity between I and P frames */
    ps_bit_allocation->i2_K[I_PIC] = (1 << K_Q);
    ps_bit_allocation->i2_K[P_PIC] = I_TO_P_RATIO;
    ps_bit_allocation->i2_K[B_PIC] = (P_TO_B_RATIO * I_TO_P_RATIO) >> K_Q;

    /* Initialize the saved bits to 0*/
    SET_VAR_Q(ps_bit_allocation->vq_saved_bits, 0, 0);

    /* Update the error bits module with average bits */
    irc_init_error_bits(ps_bit_allocation->ps_error_bits, i4_frm_rate,
                        i4_bit_rate);
    /* Store the input for implementing change in values */
    ps_bit_allocation->i4_frame_rate = i4_frm_rate;
    ps_bit_allocation->i4_bit_rate = i4_bit_rate;

    memset(ps_bit_allocation->i4_prev_frm_header_bits, 0, sizeof(ps_bit_allocation->i4_prev_frm_header_bits));
    for(i=0;i<MAX_NUM_DRAIN_RATES;i++)
        ps_bit_allocation->ai4_peak_bit_rate[i] = i4_peak_bit_rate[i];
}

/*******************************************************************************
 Function Name : get_cur_frm_est_bits
 Description   : Based on remaining bits in period and rd_model
 the number of bits required for the current frame is estimated.
 ******************************************************************************/
WORD32 irc_ba_get_cur_frm_est_texture_bits(bit_allocation_t *ps_bit_allocation,
                                           rc_rd_model_handle *pps_rd_model,
                                           est_sad_handle ps_est_sad,
                                           pic_handling_handle ps_pic_handling,
                                           picture_type_e e_pic_type)
{
    WORD32 i, j;
    WORD32 i4_est_texture_bits_for_frm;
    number_t vq_rem_texture_bits;
    number_t vq_complexity_estimate[MAX_PIC_TYPE];
    WORD32 i4_rem_frms_in_period[MAX_PIC_TYPE], i4_frms_in_period[MAX_PIC_TYPE];
    number_t vq_max_consumable_bits;
    number_t vq_rem_frms_in_period[MAX_PIC_TYPE], vq_est_texture_bits_for_frm;
    number_t vq_prev_hdr_bits[MAX_PIC_TYPE];
    number_t vq_num_bits;
    WORD32 complexity_est = 0;

    /* Get the rem_frms_in_gop & the frms_in_gop from the pic_type state struct */
    irc_pic_type_get_rem_frms_in_gop(ps_pic_handling, i4_rem_frms_in_period);
    irc_pic_type_get_frms_in_gop(ps_pic_handling, i4_frms_in_period);

    /* Depending on the number of gops in a period, find the num_frms_in_prd */
    for(j = 0; j < MAX_PIC_TYPE; j++)
    {
        i4_rem_frms_in_period[j] += (i4_frms_in_period[j]
                        * (ps_bit_allocation->i4_num_gops_in_period - 1));
        i4_frms_in_period[j] *= ps_bit_allocation->i4_num_gops_in_period;
    }

    /* Remove the header bits from the remaining bits to find how many bits you
     can transfer.*/
    SET_VAR_Q(vq_num_bits, 0, 0);
    irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits);
    for(i = 0; i < MAX_PIC_TYPE; i++)
    {
        SET_VAR_Q(vq_rem_frms_in_period[i], i4_rem_frms_in_period[i], 0);
        SET_VAR_Q(vq_prev_hdr_bits[i],
                  ps_bit_allocation->i4_prev_frm_header_bits[i], 0);
    }
    {
        /*
         *rem_texture_bits = rem_bits_in_period -
         *(rem_frms_in_period[I_PIC] * prev_frm_header_bits[I_PIC]) -
         *(rem_frms_in_period[P_PIC] * prev_frm_header_bits[P_PIC]) -
         *(rem_frms_in_period[B_PIC] * prev_frm_header_bits[B_PIC]);
         */
        number_t vq_rem_hdr_bits;
        vq_rem_texture_bits = ps_bit_allocation->s_rbip.vq_rem_bits_in_period;

        mult32_var_q(vq_prev_hdr_bits[I_PIC], vq_rem_frms_in_period[I_PIC],
                     &vq_rem_hdr_bits);
        sub32_var_q(vq_rem_texture_bits, vq_rem_hdr_bits, &vq_rem_texture_bits);

        mult32_var_q(vq_prev_hdr_bits[P_PIC], vq_rem_frms_in_period[P_PIC],
                     &vq_rem_hdr_bits);
        sub32_var_q(vq_rem_texture_bits, vq_rem_hdr_bits, &vq_rem_texture_bits);

        mult32_var_q(vq_prev_hdr_bits[B_PIC], vq_rem_frms_in_period[B_PIC],
                     &vq_rem_hdr_bits);
        sub32_var_q(vq_rem_texture_bits, vq_rem_hdr_bits, &vq_rem_texture_bits);
    }
    {
        /* max_consumable_bits =
         *(frms_in_period[I_PIC] * max_bits_per_frm[0] ) +
         *(frms_in_period[P_PIC] + frms_in_period[B_PIC] ) * max_bits_per_frm[1];
         */
        number_t vq_max_bits, vq_max_bits_per_frm[2];

        SET_VAR_Q(vq_max_bits_per_frm[0],
                  ps_bit_allocation->i4_max_bits_per_frm[0], 0);
        SET_VAR_Q(vq_max_bits_per_frm[1],
                  ps_bit_allocation->i4_max_bits_per_frm[1], 0);

        mult32_var_q(vq_rem_frms_in_period[I_PIC], vq_max_bits_per_frm[0],
                     &vq_max_bits);
        vq_max_consumable_bits = vq_max_bits;

        mult32_var_q(vq_rem_frms_in_period[P_PIC], vq_max_bits_per_frm[1],
                     &vq_max_bits);
        add32_var_q(vq_max_bits, vq_max_consumable_bits,
                    &vq_max_consumable_bits);

        mult32_var_q(vq_rem_frms_in_period[B_PIC], vq_max_bits_per_frm[1],
                     &vq_max_bits);
        add32_var_q(vq_max_bits, vq_max_consumable_bits,
                    &vq_max_consumable_bits);
    }

    /* rem_texture_bits = MIN(rem_texture_bits, max_consumable_bits) */
    MIN_VARQ(vq_max_consumable_bits, vq_rem_texture_bits, vq_rem_texture_bits);

    /* The bits are then allocated based on the relative complexity of the
     current frame with respect to that of the rest of the frames in period */
    for(i = 0; i < MAX_PIC_TYPE; i++)
    {
        number_t vq_lin_mod_coeff, vq_est_sad, vq_K;

        /* Getting the linear model coefficient */
        vq_lin_mod_coeff = irc_get_linear_coefficient(pps_rd_model[i]);

        /* Getting the estimated SAD */
        SET_VAR_Q(vq_est_sad, irc_get_est_sad(ps_est_sad,i), 0);

        /* Making K factor a var Q format */
        SET_VAR_Q(vq_K, ps_bit_allocation->i2_K[i], K_Q);

        /* Complexity_estimate = [ (lin_mod_coeff * estimated_sad) / K factor ]  */
        mult32_var_q(vq_lin_mod_coeff, vq_est_sad, &vq_lin_mod_coeff);
        div32_var_q(vq_lin_mod_coeff, vq_K, &vq_complexity_estimate[i]);
    }

    /*
     * For simple cases, one of the complexities go to zero and in those cases
     * distribute the bits evenly among frames based on I_TO_P_RATIO
     */

    /* Also check the B-pictures complexity only in case they are present*/
    if(i4_frms_in_period[B_PIC] == 0)
    {
        complexity_est = (vq_complexity_estimate[I_PIC]
                        && vq_complexity_estimate[P_PIC]);
    }
    else
    {
        complexity_est = (vq_complexity_estimate[I_PIC]
                        && vq_complexity_estimate[P_PIC]
                        && vq_complexity_estimate[B_PIC]);
    }

    if(complexity_est)
    {
        /*
         * Estimated texture bits =
         * (remaining bits) * (cur frm complexity)
         * ---------------------------------------
         * (num_i_frm*i_frm_complexity) + (num_p_frm*pfrm_complexity)
         *  + (b_frm * b_frm_cm)
         */
        mult32_var_q(vq_rem_texture_bits, vq_complexity_estimate[e_pic_type],
                     &vq_rem_texture_bits);

        for(i = 0; i < MAX_PIC_TYPE; i++)
        {
            mult32_var_q(vq_rem_frms_in_period[i], vq_complexity_estimate[i],
                         &vq_rem_frms_in_period[i]);
        }

        add32_var_q(vq_rem_frms_in_period[I_PIC], vq_rem_frms_in_period[P_PIC],
                    &vq_rem_frms_in_period[I_PIC]);

        add32_var_q(vq_rem_frms_in_period[I_PIC], vq_rem_frms_in_period[B_PIC],
                    &vq_rem_frms_in_period[I_PIC]);

        div32_var_q(vq_rem_texture_bits, vq_rem_frms_in_period[I_PIC],
                    &vq_est_texture_bits_for_frm);

        number_t_to_word32(vq_est_texture_bits_for_frm,
                           &i4_est_texture_bits_for_frm);
    }
    else
    {
        number_t vq_i_to_p_bit_ratio, vq_rem_frms;

        SET_VAR_Q(vq_i_to_p_bit_ratio, I_TO_P_BIT_RATIO, 0);

        /* rem_frms = ((I_TO_P_BIT_RATIO * rem_frms_in_period[I_PIC]) +
         * rem_frms_in_period[P_PIC]  +  rem_frms_in_period[B_PIC]);
         */
        mult32_var_q(vq_rem_frms_in_period[I_PIC], vq_i_to_p_bit_ratio,
                     &vq_rem_frms);
        add32_var_q(vq_rem_frms_in_period[P_PIC], vq_rem_frms, &vq_rem_frms);
        add32_var_q(vq_rem_frms_in_period[B_PIC], vq_rem_frms, &vq_rem_frms);

        /* est_texture_bits_for_frm = rem_texture_bits / rem_frms */
        div32_var_q(vq_rem_texture_bits, vq_rem_frms,
                    &vq_est_texture_bits_for_frm);
        number_t_to_word32(vq_est_texture_bits_for_frm,
                           &i4_est_texture_bits_for_frm);

        i4_est_texture_bits_for_frm =
                        (I_PIC == e_pic_type) ?
                                        (i4_est_texture_bits_for_frm
                                                        * I_TO_P_BIT_RATIO) :
                                        i4_est_texture_bits_for_frm;
    }

    /*
     * If the remaining bits in the period becomes negative then the estimated
     * texture bits would also become negative. This would send a feedback to
     * the model which may go for a toss. Thus sending the minimum possible
     * value = 0
     */
    if(i4_est_texture_bits_for_frm < 0)
    {
        i4_est_texture_bits_for_frm = 0;
    }

    return (i4_est_texture_bits_for_frm);
}

/******************************************************************************
 Function Name : irc_ba_get_cur_frm_est_header_bits
 Description   : Based on remaining bits in period and rd_model
                 the number of bits required for the current frame is estimated.
 ******************************************************************************/
WORD32 irc_ba_get_cur_frm_est_header_bits(bit_allocation_t *ps_bit_allocation,
                                          picture_type_e e_pic_type)
{
    return (ps_bit_allocation->i4_prev_frm_header_bits[e_pic_type]);
}

WORD32 irc_ba_get_rem_bits_in_period(bit_allocation_t *ps_bit_allocation,
                                     pic_handling_handle ps_pic_handling)
{
    WORD32 i4_rem_bits_in_gop = 0;

    number_t vq_num_bits;
    SET_VAR_Q(vq_num_bits, 0, 0);

    irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits);
    number_t_to_word32(ps_bit_allocation->s_rbip.vq_rem_bits_in_period,
                       &i4_rem_bits_in_gop);
    return (i4_rem_bits_in_gop);
}

/*******************************************************************************
 Function Name : irc_ba_update_cur_frm_consumed_bits
 Description   : Based on remaining bits in period and rd_model
                 the number of bits required for the current frame is estimated.
 ******************************************************************************/
void irc_ba_update_cur_frm_consumed_bits(bit_allocation_t *ps_bit_allocation,
                                         pic_handling_handle ps_pic_handling,
                                         WORD32 i4_total_frame_bits,
                                         WORD32 i4_model_updation_hdr_bits,
                                         picture_type_e e_pic_type,
                                         UWORD8 u1_is_scd,
                                         WORD32 i4_last_frm_in_gop)
{
    WORD32 i4_error_bits = irc_get_error_bits(ps_bit_allocation->ps_error_bits);

    /* Update the remaining bits in period */
    number_t vq_num_bits;
    SET_VAR_Q(vq_num_bits, (-i4_total_frame_bits + i4_error_bits), 0);

    irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits);

    /*
     * Update the header bits so that it can be used as an estimate to the next
     * frame
     */
    if(u1_is_scd)
    {
        /*
         * In case of SCD, even though the frame type is P, it is equivalent to
         * a I frame and so the corresponding header bits is updated
         */
        ps_bit_allocation->i4_prev_frm_header_bits[I_PIC] =
                        i4_model_updation_hdr_bits;

#define MAX_NUM_GOPS_IN_PERIOD (3)
        if(ps_bit_allocation->i4_num_gops_in_period < MAX_NUM_GOPS_IN_PERIOD)
        {
            /*
             * Whenever there is a scene change increase the number of gops by
             * 2 so that the number of bits allocated is not very constrained
             */
            ps_bit_allocation->i4_num_gops_in_period += 2;
            /* Add the extra bits in GOP to remaining bits in period */
            irc_ba_change_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
                               ps_bit_allocation->i4_bits_per_frm,
                               ps_bit_allocation->i4_num_gops_in_period);
        }
    }
    else
    {
        ps_bit_allocation->i4_prev_frm_header_bits[e_pic_type] =
                        i4_model_updation_hdr_bits;
    }

    if(i4_last_frm_in_gop)
    {
        WORD32 i4_tot_frms_in_gop = get_number_of_frms_in_a_gop(
                ps_pic_handling);
        number_t vq_total_frms_in_gop, vq_bits_per_frm, vq_num_bits_in_gop;

        SET_VAR_Q(vq_total_frms_in_gop, i4_tot_frms_in_gop, 0);
        SET_VAR_Q(vq_bits_per_frm, ps_bit_allocation->i4_bits_per_frm, 0);

        mult32_var_q(vq_bits_per_frm, vq_total_frms_in_gop,
                     &vq_num_bits_in_gop);
        /*
         * If the number of gops in period has been increased due to scene
         * change, slowly bring in down across the gops
         */
        if(ps_bit_allocation->i4_num_gops_in_period
                        > ps_bit_allocation->i4_actual_num_gops_in_period)
        {
            ps_bit_allocation->i4_num_gops_in_period--;
            irc_ba_change_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
                               ps_bit_allocation->i4_bits_per_frm,
                               ps_bit_allocation->i4_num_gops_in_period);
        }
        /*
         * If rem_bits_in_period < 0 decrease the number of bits allocated for
         * the next period else increase it
         */
        irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
                           vq_num_bits_in_gop);
    }
    /* Update the lower modules */
    irc_update_error_bits(ps_bit_allocation->ps_error_bits);
}

void irc_ba_change_remaining_bits_in_period(bit_allocation_t *ps_bit_allocation,
                                            pic_handling_handle ps_pic_handling,
                                            WORD32 i4_bit_rate,
                                            WORD32 i4_frame_rate,
                                            WORD32 *i4_peak_bit_rate)
{
    WORD32 i4_new_avg_bits_per_frm;
    WORD32 i4_new_peak_bits_per_frm[MAX_NUM_DRAIN_RATES];
    WORD32 i4_rem_frms_in_period[MAX_PIC_TYPE];
    int i;

    /* Calculate the new per frame bits */
    X_PROD_Y_DIV_Z(i4_bit_rate, 1000, i4_frame_rate, i4_new_avg_bits_per_frm);
    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
    {
        X_PROD_Y_DIV_Z(i4_peak_bit_rate[i], 1000, i4_frame_rate,
                       i4_new_peak_bits_per_frm[i]);
    }

    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
    {
        ps_bit_allocation->i4_max_bits_per_frm[i] = i4_new_peak_bits_per_frm[i];
    }

    /*
     * Get the rem_frms_in_prd & the frms_in_prd from the pic_type state
     * struct
     */
    irc_pic_type_get_rem_frms_in_gop(ps_pic_handling, i4_rem_frms_in_period);

    /*
     * If the difference > 0(/ <0), the remaining bits in period needs to be
     * increased(/decreased) based on the remaining number of frames
     */
    irc_ba_change_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
                       i4_new_avg_bits_per_frm,
                       ps_bit_allocation->i4_num_gops_in_period);

    /* Update the new average bits per frame */
    ps_bit_allocation->i4_bits_per_frm = i4_new_avg_bits_per_frm;
    /* change the lower modules state */
    irc_change_bitrate_in_error_bits(ps_bit_allocation->ps_error_bits,
                                     i4_bit_rate);
    irc_change_frm_rate_in_error_bits(ps_bit_allocation->ps_error_bits,
                                      i4_frame_rate);

    /* Store the modified frame_rate */
    ps_bit_allocation->i4_frame_rate = i4_frame_rate;
    ps_bit_allocation->i4_bit_rate = i4_bit_rate;
    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
        ps_bit_allocation->ai4_peak_bit_rate[i] = i4_peak_bit_rate[i];
}

void irc_ba_change_ba_peak_bit_rate(bit_allocation_t *ps_bit_allocation,
                                    WORD32 *ai4_peak_bit_rate)
{
    WORD32 i;

    /* Calculate the bits per frame */
    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
    {
        X_PROD_Y_DIV_Z(ai4_peak_bit_rate[i], 1000,
                       ps_bit_allocation->i4_frame_rate,
                       ps_bit_allocation->i4_max_bits_per_frm[i]);
        ps_bit_allocation->ai4_peak_bit_rate[i] = ai4_peak_bit_rate[i];
    }
}

/******************************************************************************
 * @brief Modifies the remaining bit in period for the gop which has fif.
 *      since fif would cause a new gop to be created, we need to add the number
 *      of encoded frames in the fif GOP worth of bits to remaining bits in
 *      period
 ******************************************************************************/
void irc_ba_change_rem_bits_in_prd_at_force_I_frame(bit_allocation_t *ps_bit_allocation,
                                                    pic_handling_handle ps_pic_handling)
{
    WORD32 i4_frms_in_period;
    number_t vq_frms_in_period, vq_bits_per_frm, vq_num_bits_in_period;

    i4_frms_in_period = irc_pic_type_get_frms_in_gop_force_I_frm(
                    ps_pic_handling);
    SET_VAR_Q(vq_frms_in_period, i4_frms_in_period, 0);
    SET_VAR_Q(vq_bits_per_frm, ps_bit_allocation->i4_bits_per_frm, 0);

    mult32_var_q(vq_bits_per_frm, vq_frms_in_period, &vq_num_bits_in_period);

    irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits_in_period);
}

void irc_ba_check_and_update_bit_allocation(bit_allocation_t *ps_bit_allocation,
                                            pic_handling_handle ps_pic_handling,
                                            WORD32 i4_cur_buf_size,
                                            WORD32 i4_max_buf_size,
                                            WORD32 i4_max_bits_inflow_per_frm,
                                            WORD32 i4_tot_frame_bits)
{

    number_t vq_max_drain_bits, vq_extra_bits, vq_less_bits,
                    vq_allocated_saved_bits, vq_min_bits_for_period;
    WORD32 i4_num_frms_in_period = get_number_of_frms_in_a_gop(ps_pic_handling);
    number_t vq_rem_bits_in_period, vq_num_frms_in_period, vq_zero;
    WORD32 b_rem_bits_gt_max_drain, b_rem_bits_lt_min_bits,
                    b_saved_bits_gt_zero;
    rem_bit_in_prd_t *ps_rbip = &ps_bit_allocation->s_rbip;

    UNUSED(i4_cur_buf_size);
    UNUSED(i4_max_buf_size);
    UNUSED(i4_tot_frame_bits);

    /*
     * If the remaining bits is greater than what can be drained in that period
     * Clip the remaining bits in period to the maximum it can drain in that
     * period with the error of current buffer size.Accumulate the saved bits
     * if any. else if the remaining bits is lesser than the minimum bit rate
     * promised in that period Add the excess bits to remaining bits in period
     * and reduce it from the saved bits Else Provide the extra bits from the
     * "saved bits pool".
     */
    /*
     * max_drain_bits = num_gops_in_period * num_frms_in_period *
     * * max_bits_inflow_per_frm
     */
    SET_VAR_Q(vq_num_frms_in_period,
              (ps_bit_allocation->i4_num_gops_in_period * i4_num_frms_in_period),
              0);
    SET_VAR_Q(vq_max_drain_bits, i4_max_bits_inflow_per_frm, 0);
    SET_VAR_Q(vq_zero, 0, 0);
    mult32_var_q(vq_max_drain_bits, vq_num_frms_in_period, &vq_max_drain_bits);

    /*
     * min_bits_for_period = num_gops_in_period * num_frms_in_period *
     * min_bits_per_frm
     */
    SET_VAR_Q(vq_min_bits_for_period, ps_bit_allocation->i4_min_bits_per_frm,
              0);
    mult32_var_q(vq_min_bits_for_period, vq_num_frms_in_period,
                 &vq_min_bits_for_period);

    vq_rem_bits_in_period = ps_rbip->vq_rem_bits_in_period;

    /* Evaluate rem_bits_in_period  > max_drain_bits      */
    VQ_A_GT_VQ_B(ps_rbip->vq_rem_bits_in_period, vq_max_drain_bits,
                 b_rem_bits_gt_max_drain);

    /* Evaluate rem_bits_in_period  < min_bits_for_period */
    VQ_A_LT_VQ_B(ps_rbip->vq_rem_bits_in_period, vq_min_bits_for_period,
                 b_rem_bits_lt_min_bits);

    /* Evaluate saved_bits  > 0 */
    VQ_A_LT_VQ_B(ps_bit_allocation->vq_saved_bits, vq_zero,
                 b_saved_bits_gt_zero);

    /* (i4_rem_bits_in_period > i4_max_drain_bits) */
    if(b_rem_bits_gt_max_drain)
    {
        /* extra_bits = rem_bits_in_period - max_drain_bits */
        sub32_var_q(ps_rbip->vq_rem_bits_in_period, vq_max_drain_bits,
                    &vq_extra_bits);

        /* saved_bits += extra_bits */
        add32_var_q(ps_bit_allocation->vq_saved_bits, vq_extra_bits,
                    &ps_bit_allocation->vq_saved_bits);

        /* rem_bits_in_period = vq_max_drain_bits */
        ps_rbip->vq_rem_bits_in_period = vq_max_drain_bits;
    }
    else if(b_rem_bits_lt_min_bits)
    {
        /* extra_bits(-ve) =  rem_bits_in_period - i4_min_bits_for_period */
        sub32_var_q(ps_rbip->vq_rem_bits_in_period, vq_min_bits_for_period,
                    &vq_extra_bits);

        /* saved_bits += extra_bits(-ve) */
        add32_var_q(ps_bit_allocation->vq_saved_bits, vq_extra_bits,
                    &ps_bit_allocation->vq_saved_bits);

        /* rem_bits_in_period = min_bits_for_period */
        ps_rbip->vq_rem_bits_in_period = vq_min_bits_for_period;
    }
    else if(b_saved_bits_gt_zero)
    {
        /* less_bits = max_drain_bits - _rem_bits_in_period */
        sub32_var_q(vq_max_drain_bits, vq_rem_bits_in_period, &vq_less_bits);

        /* allocated_saved_bits = MIN (less_bits, saved_bits) */
        MIN_VARQ(ps_bit_allocation->vq_saved_bits, vq_less_bits,
                 vq_allocated_saved_bits);

        /* rem_bits_in_period += allocted_save_bits */
        add32_var_q(ps_rbip->vq_rem_bits_in_period, vq_allocated_saved_bits,
                    &ps_rbip->vq_rem_bits_in_period);

        /* saved_bits -= allocted_save_bits */
        sub32_var_q(ps_bit_allocation->vq_saved_bits, vq_allocated_saved_bits,
                    &ps_bit_allocation->vq_saved_bits);
    }
    return;
}

WORD32 irc_ba_get_frame_rate(bit_allocation_t *ps_bit_allocation)
{
    return (ps_bit_allocation->i4_frame_rate);
}

WORD32 irc_ba_get_bit_rate(bit_allocation_t *ps_bit_allocation)
{
    return (ps_bit_allocation->i4_bit_rate);
}

void irc_ba_get_peak_bit_rate(bit_allocation_t *ps_bit_allocation,
                              WORD32 *pi4_peak_bit_rate)
{
    WORD32 i;
    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
    {
        pi4_peak_bit_rate[i] = ps_bit_allocation->ai4_peak_bit_rate[i];
    }
}

Coverage Report

Created: 2026-01-10 06:44