/******************************************************************************

 *

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

/*****************************************************************************/

/* System include files */

#include <stdio.h>

/* User include files */

#include "irc_datatypes.h"

#include "irc_common.h"

#include "irc_cntrl_param.h"

#include "irc_mem_req_and_acq.h"

#include "irc_fixed_point_error_bits.h"

#include "irc_vbr_storage_vbv.h"

#include "irc_trace_support.h"

#define MAX(x, y)  ((x) > (y) ? (x) : (y))

typedef struct vbr_storage_vbv_t

{

    WORD32 i4_max_buf_size;

    WORD32 i4_cur_buf_size;

    WORD32 i4_max_bits_inflow_per_frm_period;

    WORD32 i4_max_bits_per_tgt_frm;

    /* Storing input variables */

    WORD32 i4_max_bit_rate;

    WORD32 i4_max_frame_rate;

    /* Error bits calculation module */

    error_bits_handle ps_error_bits;

} vbr_storage_vbv_t;

static void overflow_avoided_summation(WORD32 *pi4_accumulator, WORD32 i4_input)

{

    if((pi4_accumulator[0] > 0)

                    && (((int)0x7fffffff - pi4_accumulator[0]) < i4_input))

    {

        pi4_accumulator[0] = 0x7fffffff;

    }

    else if((pi4_accumulator[0] < 0)

                    && (((int)0x80000000 - pi4_accumulator[0]) > i4_input))

    {

        pi4_accumulator[0] = 0x80000000;

    }

    else

    {

        pi4_accumulator[0] += i4_input;

    }

}

WORD32 irc_vbr_vbv_num_fill_use_free_memtab(vbr_storage_vbv_t **pps_vbr_storage_vbv,

                                            itt_memtab_t *ps_memtab,

                                            ITT_FUNC_TYPE_E e_func_type)

{

    WORD32 i4_mem_tab_idx = 0;

    vbr_storage_vbv_t s_vbr_storage_vbv_temp;

    /*

     * Hack for al 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_vbr_storage_vbv) = &s_vbr_storage_vbv_temp;

    /*for src rate control state structure*/

    if(e_func_type != GET_NUM_MEMTAB)

    {

        fill_memtab(&ps_memtab[i4_mem_tab_idx], sizeof(vbr_storage_vbv_t),

                    ALIGN_128_BYTE, PERSISTENT, DDR);

        use_or_fill_base(&ps_memtab[0], (void**)pps_vbr_storage_vbv,

                         e_func_type);

    }

    i4_mem_tab_idx++;

    i4_mem_tab_idx += irc_error_bits_num_fill_use_free_memtab(

                    &pps_vbr_storage_vbv[0]->ps_error_bits,

                    &ps_memtab[i4_mem_tab_idx], e_func_type);

    return (i4_mem_tab_idx);

}

void irc_init_vbr_vbv(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                      WORD32 i4_max_bit_rate,

                      WORD32 i4_frm_rate,

                      WORD32 i4_max_vbv_buff_size)

{

    ps_vbr_storage_vbv->i4_max_buf_size = i4_max_vbv_buff_size;

    ps_vbr_storage_vbv->i4_cur_buf_size = i4_max_vbv_buff_size;

    /*

     * Calculate the max number of bits that flow into the decoder

     * in the interval of two frames

     */

    X_PROD_Y_DIV_Z(i4_max_bit_rate, 1000, i4_frm_rate,

                   ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period);

    /* init error bits */

    irc_init_error_bits(ps_vbr_storage_vbv->ps_error_bits, i4_frm_rate,

                        i4_max_bit_rate);

    /* Storing the input values */

    ps_vbr_storage_vbv->i4_max_bits_per_tgt_frm =

                    ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period;

    ps_vbr_storage_vbv->i4_max_bit_rate = i4_max_bit_rate;

    ps_vbr_storage_vbv->i4_max_frame_rate = i4_frm_rate;

}

void irc_update_vbr_vbv(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                        WORD32 i4_total_bits_decoded)

{

    WORD32 i4_error_bits = irc_get_error_bits(

                    ps_vbr_storage_vbv->ps_error_bits);

    /*

     * In the time interval between two decoded frames the buffer would have been

     * filled up by the max_bits_inflow_per_frm_period.

     */

    overflow_avoided_summation(

                    &ps_vbr_storage_vbv->i4_cur_buf_size,

                    (ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period

                                    + i4_error_bits));

    if(ps_vbr_storage_vbv->i4_cur_buf_size

                    > ps_vbr_storage_vbv->i4_max_buf_size)

    {

        ps_vbr_storage_vbv->i4_cur_buf_size =

                        ps_vbr_storage_vbv->i4_max_buf_size;

    }

    ps_vbr_storage_vbv->i4_cur_buf_size -= i4_total_bits_decoded;

    /* Update the error bits state */

    irc_update_error_bits(ps_vbr_storage_vbv->ps_error_bits);

}

WORD32 irc_get_max_target_bits(vbr_storage_vbv_t *ps_vbr_storage_vbv)

{

    WORD32 i4_cur_buf_size = ps_vbr_storage_vbv->i4_cur_buf_size;

    WORD32 i4_error_bits = irc_get_error_bits(

                    ps_vbr_storage_vbv->ps_error_bits);

    /* The buffer size when the next frame is decoded */

    overflow_avoided_summation(

                    &i4_cur_buf_size,

                    (ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period

                                    + i4_error_bits));

    if(i4_cur_buf_size > ps_vbr_storage_vbv->i4_max_buf_size)

    {

        i4_cur_buf_size = ps_vbr_storage_vbv->i4_max_buf_size;

    }

    /*

     * Thus for the next frame the maximum number of bits the decoder can consume

     * without underflow is i4_cur_buf_size

     */

    return i4_cur_buf_size;

}

/****************************************************************************

 Function Name : irc_get_buffer_status

 Description   : Gets the state of VBV buffer

 Inputs        : Rate control API , header and texture bits

 Outputs       : 0 = normal, 1 = underflow, 2= overflow

 Returns       : vbv_buf_status_e

 *****************************************************************************/

vbv_buf_status_e irc_get_vbv_buffer_status(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                                           WORD32 i4_total_frame_bits,

                                           WORD32 *pi4_num_bits_to_prevent_vbv_underflow)

{

    vbv_buf_status_e e_buf_status;

    WORD32 i4_cur_buf;

    WORD32 i4_error_bits = irc_get_error_bits(

                    ps_vbr_storage_vbv->ps_error_bits);

    /* error bits due to fixed point computation of drain rate*/

    i4_cur_buf = ps_vbr_storage_vbv->i4_cur_buf_size;

    overflow_avoided_summation(

                    &i4_cur_buf,

                    (ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period

                                    + i4_error_bits));

    if(i4_cur_buf > ps_vbr_storage_vbv->i4_max_buf_size)

    {

        i4_cur_buf = ps_vbr_storage_vbv->i4_max_buf_size;

    }

    pi4_num_bits_to_prevent_vbv_underflow[0] = i4_cur_buf;

    i4_cur_buf -= i4_total_frame_bits;

    if(i4_cur_buf < 0)

    {

        e_buf_status = VBV_UNDERFLOW;

    }

    else if(i4_cur_buf > ps_vbr_storage_vbv->i4_max_buf_size)

    {

        e_buf_status = VBV_OVERFLOW;

    }

    else if(i4_cur_buf < (ps_vbr_storage_vbv->i4_max_buf_size >> 2))

    {

        e_buf_status = VBR_CAUTION;

    }

    else

    {

        e_buf_status = VBV_NORMAL;

    }

    return e_buf_status;

}

UWORD8 irc_restrict_swing_dvd_comp(vbr_storage_vbv_t *ps_vbr_storage_vbv)

{

    UWORD8 u1_restrict_swing = 1;

    if(ps_vbr_storage_vbv->i4_cur_buf_size

                    < (ps_vbr_storage_vbv->i4_max_buf_size >> 1))

    {

        u1_restrict_swing = 0;

    }

    return (u1_restrict_swing);

}

WORD32 irc_get_max_vbv_buf_size(vbr_storage_vbv_t *ps_vbr_storage_vbv)

{

    return (ps_vbr_storage_vbv->i4_max_buf_size);

}

WORD32 irc_get_cur_vbv_buf_size(vbr_storage_vbv_t *ps_vbr_storage_vbv)

{

    return (ps_vbr_storage_vbv->i4_cur_buf_size);

}

WORD32 irc_get_max_bits_inflow_per_frm_periode(vbr_storage_vbv_t *ps_vbr_storage_vbv)

{

    return (ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period);

}

WORD32 irc_get_max_bits_per_tgt_frm(vbr_storage_vbv_t *ps_vbr_storage_vbv)

{

    return (ps_vbr_storage_vbv->i4_max_bits_per_tgt_frm);

}

WORD32 irc_vbv_get_vbv_buf_fullness(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                                    UWORD32 u4_bits)

{

    WORD32 i4_error_bits = irc_get_error_bits(

                    ps_vbr_storage_vbv->ps_error_bits);

    WORD32 i4_cur_buf_size = ps_vbr_storage_vbv->i4_cur_buf_size;

    overflow_avoided_summation(

                    &i4_cur_buf_size,

                    (ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period

                                    + i4_error_bits));

    if(i4_cur_buf_size > ps_vbr_storage_vbv->i4_max_buf_size)

    {

        i4_cur_buf_size = ps_vbr_storage_vbv->i4_max_buf_size;

    }

    i4_cur_buf_size -= u4_bits;

    return (i4_cur_buf_size);

}

WORD32 irc_get_max_tgt_bits_dvd_comp(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                                     WORD32 i4_rem_bits_in_gop,

                                     WORD32 i4_rem_frms_in_gop,

                                     picture_type_e e_pic_type)

{

    WORD32 i4_dbf_max, i4_dbf_min, i4_dbf_prev, i4_vbv_size, i4_dbf_desired;

    WORD32 i4_max_tgt_bits;

    i4_vbv_size = ps_vbr_storage_vbv->i4_max_buf_size;

    i4_dbf_max = 95 * i4_vbv_size / 100;

    i4_dbf_min = 10 * i4_vbv_size / 100;

    i4_dbf_prev = ps_vbr_storage_vbv->i4_cur_buf_size;

    if(i4_rem_bits_in_gop < 0)

        i4_rem_bits_in_gop = 0;

    if(i4_rem_frms_in_gop <= 0)

        i4_rem_frms_in_gop = 1;

    if(e_pic_type == I_PIC)

    {

        i4_dbf_desired = i4_dbf_min;

    }

    else

    {

        i4_dbf_desired = (i4_dbf_max - i4_rem_bits_in_gop / i4_rem_frms_in_gop

                        - i4_dbf_prev) / i4_rem_frms_in_gop;

        i4_dbf_desired += i4_dbf_prev;

    }

    i4_dbf_prev += ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period;

    if(i4_dbf_prev > ps_vbr_storage_vbv->i4_max_buf_size)

    {

        i4_dbf_prev = ps_vbr_storage_vbv->i4_max_buf_size;

    }

    i4_max_tgt_bits = MAX(0, (i4_dbf_prev - i4_dbf_desired));

    return (i4_max_tgt_bits);

}

void irc_change_vbr_vbv_frame_rate(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                                   WORD32 i4_frm_rate)

{

    /*

     * Calculate the max number of bits that flow into the decoder

     * in the interval of two frames

     */

    X_PROD_Y_DIV_Z(ps_vbr_storage_vbv->i4_max_bit_rate, 1000, i4_frm_rate,

                   ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period);

    /* Update the lower modules */

    irc_change_frm_rate_in_error_bits(ps_vbr_storage_vbv->ps_error_bits,

                                      i4_frm_rate);

    /* Storing the input values */

    ps_vbr_storage_vbv->i4_max_frame_rate = i4_frm_rate;

}

void irc_change_vbr_vbv_bit_rate(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                                 WORD32 i4_max_bit_rate)

{

    /*

     * Calculate the max number of bits that flow into the decoder

     * in the interval of two frames

     */

    X_PROD_Y_DIV_Z(i4_max_bit_rate, 1000, ps_vbr_storage_vbv->i4_max_frame_rate,

                   ps_vbr_storage_vbv->i4_max_bits_inflow_per_frm_period);

    /* update the lower modules */

    irc_change_bitrate_in_error_bits(ps_vbr_storage_vbv->ps_error_bits,

                                     i4_max_bit_rate);

    /* Storing the input values */

    ps_vbr_storage_vbv->i4_max_bit_rate = i4_max_bit_rate;

}

void irc_change_vbr_max_bits_per_tgt_frm(vbr_storage_vbv_t *ps_vbr_storage_vbv,

                                         WORD32 i4_tgt_frm_rate)

{

    /*

     * Calculate the max number of bits that flow into the decoder

     * in the interval of two frames

     */

    X_PROD_Y_DIV_Z(ps_vbr_storage_vbv->i4_max_bit_rate, 1000, i4_tgt_frm_rate,

                   ps_vbr_storage_vbv->i4_max_bits_per_tgt_frm);

}