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

 *

 * Copyright (C) 2018 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 Name         : rc_rd_model.c                                        */

/*                                                                          */

/* Description       : Implall the Functions to Model the                   */

/*                     Rate Distortion Behaviour of the Codec over the Last */

/*                     Few Frames.                                          */

/*                                                                          */

/* List of Functions : update_frame_rd_model                                */

/*                     estimate_mpeg2_qp_for_resbits                        */

/*                                                                          */

/* Issues / Problems : None                                                 */

/*                                                                          */

/* Revision History  :                                                      */

/*        DD MM YYYY   Author(s)       Changes (Describe the changes made)  */

/*        21 06 2006   ittiam           Initial Version                      */

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

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

/* File Includes                                                             */

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

/* System include files */

#include <stdarg.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

/* User include files */

#include "ittiam_datatypes.h"

#include "var_q_operator.h"

#include "rc_common.h"

#include "rc_cntrl_param.h"

#include "mem_req_and_acq.h"

#include "rc_rd_model.h"

#include "rc_rd_model_struct.h"

#if RC_FIXED_POINT

WORD32 rc_rd_model_num_fill_use_free_memtab(

    rc_rd_model_t **pps_rc_rd_model, itt_memtab_t *ps_memtab, ITT_FUNC_TYPE_E e_func_type)

{

    WORD32 i4_mem_tab_idx = 0;

    static rc_rd_model_t s_rc_rd_model_temp;

    /* Hack for al alloc, during which we dont have any state memory.

      Dereferencing can cause issues */

    if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB)

        (*pps_rc_rd_model) = &s_rc_rd_model_temp;

    /*for src rate control state structure*/

    if(e_func_type != GET_NUM_MEMTAB)

    {

        fill_memtab(

            &ps_memtab[i4_mem_tab_idx], sizeof(rc_rd_model_t), MEM_TAB_ALIGNMENT, PERSISTENT, DDR);

        use_or_fill_base(&ps_memtab[0], (void **)pps_rc_rd_model, e_func_type);

    }

    i4_mem_tab_idx++;

    return (i4_mem_tab_idx);

}

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

  Function Name   : init_frm_rc_rd_model

  Description     :

  Arguments       : ps_rd_model

  Return Values   : void

  Revision History:

                    Creation

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

void init_frm_rc_rd_model(rc_rd_model_t *ps_rd_model, UWORD8 u1_max_frames_modelled)

{

    /* ps_rd_model = ps_rd_model + u1_pic_type; */

    ps_rd_model->u1_num_frms_in_model = 0;

    ps_rd_model->u1_curr_frm_counter = 0;

    ps_rd_model->u1_max_frms_to_model = u1_max_frames_modelled;

    ps_rd_model->model_coeff_a_quad.sm = 0;

    ps_rd_model->model_coeff_b_quad.sm = 0;

    ps_rd_model->model_coeff_c_quad.sm = 0;

    ps_rd_model->model_coeff_a_lin.sm = 0;

    ps_rd_model->model_coeff_b_lin.sm = 0;

    ps_rd_model->model_coeff_c_lin.sm = 0;

    ps_rd_model->model_coeff_a_lin_wo_int.sm = 0;

    ps_rd_model->model_coeff_b_lin_wo_int.sm = 0;

    ps_rd_model->model_coeff_c_lin_wo_int.sm = 0;

    ps_rd_model->model_coeff_a_quad.e = 0;

    ps_rd_model->model_coeff_b_quad.e = 0;

    ps_rd_model->model_coeff_c_quad.e = 0;

    ps_rd_model->model_coeff_a_lin.e = 0;

    ps_rd_model->model_coeff_b_lin.e = 0;

    ps_rd_model->model_coeff_c_lin.e = 0;

    ps_rd_model->model_coeff_a_lin_wo_int.e = 0;

    ps_rd_model->model_coeff_b_lin_wo_int.e = 0;

    ps_rd_model->model_coeff_c_lin_wo_int.e = 0;

}

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

  Function Name   : reset_frm_rc_rd_model

  Description     :

  Arguments       : ps_rd_model

  Return Values   : void

  Revision History:

                    Creation

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

void reset_frm_rc_rd_model(rc_rd_model_t *ps_rd_model)

{

    ps_rd_model->u1_num_frms_in_model = 0;

    ps_rd_model->u1_curr_frm_counter = 0;

    ps_rd_model->model_coeff_a_quad.sm = 0;

    ps_rd_model->model_coeff_b_quad.sm = 0;

    ps_rd_model->model_coeff_c_quad.sm = 0;

    ps_rd_model->model_coeff_a_lin.sm = 0;

    ps_rd_model->model_coeff_b_lin.sm = 0;

    ps_rd_model->model_coeff_c_lin.sm = 0;

    ps_rd_model->model_coeff_a_lin_wo_int.sm = 0;

    ps_rd_model->model_coeff_b_lin_wo_int.sm = 0;

    ps_rd_model->model_coeff_c_lin_wo_int.sm = 0;

    ps_rd_model->model_coeff_a_quad.e = 0;

    ps_rd_model->model_coeff_b_quad.e = 0;

    ps_rd_model->model_coeff_c_quad.e = 0;

    ps_rd_model->model_coeff_a_lin.e = 0;

    ps_rd_model->model_coeff_b_lin.e = 0;

    ps_rd_model->model_coeff_c_lin.e = 0;

    ps_rd_model->model_coeff_a_lin_wo_int.e = 0;

    ps_rd_model->model_coeff_b_lin_wo_int.e = 0;

    ps_rd_model->model_coeff_c_lin_wo_int.e = 0;

}

#if ENABLE_QUAD_MODEL

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

  Function Name   : find_model_coeffs

  Description     :

  Arguments       :

  Return Values   : void

  Revision History:

                    Creation

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

static UWORD8 find_model_coeffs(

    UWORD32 *pi4_res_bits,

    LWORD64 *pi8_sad_h264,

    WORD32 *pi4_avg_mpeg2_qp_q6,

    UWORD8 u1_num_frms,

    UWORD8 u1_model_used,

    WORD8 *pi1_frame_index,

    number_t *pmc_model_coeff,

    number_t *pmc_model_coeff_lin,

    number_t *pmc_model_coeff_lin_wo_int,

    rc_rd_model_t *ps_rd_model)

{

    UWORD32 i;

    UWORD8 u1_num_frms_used = 0;

    UWORD8 u1_frm_indx;

    number_t sum_y;

    number_t sum_x_y;

    number_t sum_x2_y;

    number_t sum_x;

    number_t sum_x2;

    number_t sum_x3;

    number_t sum_x4;

    number_t var_x2_y;

    number_t var_x_y;

    number_t var_x2_x;

    number_t var_x2_x2;

    number_t var_x_x;

    number_t x0, y0;

    number_t s_res_bits, s_sad_h264, s_avg_mpeg2_qp;

    number_t temp, temp1;

    number_t model_coeff_a, model_coeff_b, model_coeff_c, model_coeff_den;

    number_t s_num_frms_used;

    /* initilising */

    model_coeff_a.sm = 0;

    model_coeff_a.e = 0;

    model_coeff_b.sm = 0;

    model_coeff_b.e = 0;

    model_coeff_c.sm = 0;

    model_coeff_c.e = 0;

    sum_y.sm = 0;

    sum_x_y.sm = 0;

    sum_x2_y.sm = 0;

    sum_x.sm = 0;

    sum_x2.sm = 0;

    sum_x3.sm = 0;

    sum_x4.sm = 0;

    var_x2_y.sm = 0;

    var_x_y.sm = 0;

    var_x2_x.sm = 0;

    var_x2_x2.sm = 0;

    var_x_x.sm = 0;

    sum_y.e = 0;

    sum_x_y.e = 0;

    sum_x2_y.e = 0;

    sum_x.e = 0;

    sum_x2.e = 0;

    sum_x3.e = 0;

    sum_x4.e = 0;

    var_x2_y.e = 0;

    var_x_y.e = 0;

    var_x2_x.e = 0;

    var_x2_x2.e = 0;

    var_x_x.e = 0;

    for(i = 0; i < u1_num_frms; i++)

    {

        LWORD64 i8_local_sad_sm = 0;

        WORD32 i4_local_e = 0;

        if(-1 == pi1_frame_index[i])

            continue;

        u1_frm_indx = (UWORD8)pi1_frame_index[i];

        s_res_bits.sm = pi4_res_bits[u1_frm_indx];

        s_res_bits.e = 0;

        /*s_sad_h264.sm = pi8_sad_h264[u1_frm_indx];

        s_sad_h264.e  = 0;*/

        i8_local_sad_sm = pi8_sad_h264[u1_frm_indx];

        while(i8_local_sad_sm > 0x7FFFFFFF)

        {

            i8_local_sad_sm = i8_local_sad_sm / 2;

            i4_local_e++;

        }

        SET_VARQ_FRM_FIXQ(((WORD32)i8_local_sad_sm), s_sad_h264, -i4_local_e);

        /*fract_quant*/

        SET_VARQ_FRM_FIXQ(pi4_avg_mpeg2_qp_q6[u1_frm_indx], s_avg_mpeg2_qp, QSCALE_Q_FAC);

        y0 = s_res_bits;

        /*x0 = (float) (pi4_sad_h264[u1_frm_indx] /

                     (float)pui_avg_mpeg2_qp[u1_frm_indx]); */

        div32_var_q(s_sad_h264, s_avg_mpeg2_qp, &x0);

        /*

        sum_y    += y0;

        sum_x_y  += x0 * y0;

        sum_x2_y += x0 * x0 * y0;

        sum_x    += x0;

        sum_x2   += x0 * x0;

        sum_x3   += x0 * x0 * x0;

        sum_x4   += x0 * x0 * x0 * x0;

        */

        /* sum_y    += y0; */

        add32_var_q(sum_y, y0, &sum_y);

        /* sum_x_y  += x0 * y0; */

        mult32_var_q(x0, y0, &temp);

        add32_var_q(sum_x_y, temp, &sum_x_y);

        /* sum_x2_y += x0 * x0 * y0; */

        mult32_var_q(x0, temp, &temp);

        add32_var_q(sum_x2_y, temp, &sum_x2_y);

        /* sum_x    += x0; */

        add32_var_q(x0, sum_x, &sum_x);

        /* sum_x2   += x0 * x0; */

        mult32_var_q(x0, x0, &temp);

        add32_var_q(temp, sum_x2, &sum_x2);

        /* sum_x3   += x0 * x0 * x0; */

        mult32_var_q(x0, temp, &temp);

        add32_var_q(temp, sum_x3, &sum_x3);

        /* sum_x4   += x0 * x0 * x0 * x0; */

        mult32_var_q(x0, temp, &temp);

        add32_var_q(temp, sum_x4, &sum_x4);

        u1_num_frms_used++;

    }

    s_num_frms_used.sm = u1_num_frms_used;

    s_num_frms_used.e = 0;

    /* sum_y    /= u1_num_frms_used; */

    div32_var_q(sum_y, s_num_frms_used, &sum_y);

    /* sum_x_y  /= u1_num_frms_used; */

    div32_var_q(sum_x_y, s_num_frms_used, &sum_x_y);

    /* sum_x2_y /= u1_num_frms_used; */

    div32_var_q(sum_x2_y, s_num_frms_used, &sum_x2_y);

    /* sum_x    /= u1_num_frms_used; */

    div32_var_q(sum_x, s_num_frms_used, &sum_x);

    /* sum_x2   /= u1_num_frms_used; */

    div32_var_q(sum_x2, s_num_frms_used, &sum_x2);

    /* sum_x3   /= u1_num_frms_used; */

    div32_var_q(sum_x3, s_num_frms_used, &sum_x3);

    /* sum_x4   /= u1_num_frms_used; */

    div32_var_q(sum_x4, s_num_frms_used, &sum_x4);

#if !QUAD

    u1_model_used = LIN_MODEL;

#endif

    if((QUAD_MODEL == u1_model_used) && (u1_num_frms_used <= MIN_FRAMES_FOR_QUAD_MODEL))

    {

        u1_model_used = LIN_MODEL;

    }

    if(QUAD_MODEL == u1_model_used)

    {

        /* var_x2_y  = sum_x2_y - sum_x2 * sum_y; */

        mult32_var_q(sum_x2, sum_y, &temp);

        sub32_var_q(sum_x2_y, temp, &var_x2_y);

        /* var_x_y   = sum_x_y  - sum_x  * sum_y; */

        mult32_var_q(sum_x, sum_y, &temp);

        sub32_var_q(sum_x_y, temp, &var_x_y);

        /* var_x2_x  = sum_x3   - sum_x2 * sum_x; */

        mult32_var_q(sum_x2, sum_x, &temp);

        sub32_var_q(sum_x3, temp, &var_x2_x);

        /* var_x2_x2 = sum_x4   - sum_x2 * sum_x2; */

        mult32_var_q(sum_x2, sum_x2, &temp);

        sub32_var_q(sum_x4, temp, &var_x2_x2);

        /* var_x_x   = sum_x2   - sum_x  * sum_x; */

        mult32_var_q(sum_x, sum_x, &temp);

        sub32_var_q(sum_x2, temp, &var_x_x);

        /* model_coeff_den = (var_x2_x * var_x2_x - var_x2_x2 * var_x_x); */

        mult32_var_q(var_x2_x, var_x2_x, &temp);

        mult32_var_q(var_x2_x2, var_x_x, &temp1);

        sub32_var_q(temp, temp1, &model_coeff_den);

        if(0 != model_coeff_den.sm)

        {

            /* model_coeff_b   = (var_x_y * var_x2_x - var_x2_y * var_x_x); */

            mult32_var_q(var_x_y, var_x2_x, &temp);

            mult32_var_q(var_x2_y, var_x_x, &temp1);

            sub32_var_q(temp, temp1, &model_coeff_b);

            /* model_coeff_b   /= model_coeff_den; */

            div32_var_q(model_coeff_b, model_coeff_den, &model_coeff_b);

            /* model_coeff_a   = (var_x2_y * var_x2_x - var_x_y * var_x2_x2); */

            mult32_var_q(var_x2_y, var_x2_x, &temp);

            mult32_var_q(var_x_y, var_x2_x2, &temp1);

            sub32_var_q(temp, temp1, &model_coeff_a);

            /* model_coeff_a   /= model_coeff_den; */

            div32_var_q(model_coeff_a, model_coeff_den, &model_coeff_a);

            /*model_coeff_c   = sum_y - (model_coeff_a * sum_x) -

                              (model_coeff_b * sum_x2); */

            mult32_var_q(model_coeff_a, sum_x, &temp);

            mult32_var_q(model_coeff_b, sum_x2, &temp1);

            sub32_var_q(sum_y, temp, &model_coeff_c);

            sub32_var_q(model_coeff_c, temp1, &model_coeff_c);

            /* till here */

        }

        pmc_model_coeff[0] = model_coeff_b;

        /* pmc_model_coeff[0] = (float)(model_coeff_b.sm /pow(2,model_coeff_b.e)); */

        pmc_model_coeff[1] = model_coeff_a;

        /* pmc_model_coeff[1] = (float)(model_coeff_a.sm /pow(2,model_coeff_a.e)); */

        pmc_model_coeff[2] = model_coeff_c;

        /* pmc_model_coeff[2] = (float)(model_coeff_c.sm /pow(2,model_coeff_c.e)); */

    }

    if(NULL != pmc_model_coeff_lin)

    {

        /* var_x_y   = sum_x_y  - sum_x  * sum_y; */

        mult32_var_q(sum_x, sum_y, &temp);

        sub32_var_q(sum_x_y, temp, &var_x_y);

        /* var_x_x   = sum_x2   - sum_x  * sum_x; */

        mult32_var_q(sum_x, sum_x, &temp);

        sub32_var_q(sum_x2, temp, &var_x_x);

        if((0 != var_x_x.sm) && (u1_num_frms > 1))

        {

            /* model_coeff_b = (var_x_y / var_x_x); */

            div32_var_q(var_x_y, var_x_x, &model_coeff_b);

            /* model_coeff_c = sum_y - (model_coeff_b * sum_x); */

            mult32_var_q(model_coeff_b, sum_x, &temp);

            sub32_var_q(sum_y, temp, &model_coeff_c);

            model_coeff_a = model_coeff_b;

            pmc_model_coeff_lin[0] = model_coeff_b;

            /* pmc_model_coeff_lin[0] = (float)(model_coeff_b.sm /pow(2,model_coeff_b.e)); */

            pmc_model_coeff_lin[1] = model_coeff_a;

            /* pmc_model_coeff_lin[1] = (float)(model_coeff_a.sm /pow(2,model_coeff_a.e)); */

            pmc_model_coeff_lin[2] = model_coeff_c;

            /* pmc_model_coeff_lin[2] = (float)(model_coeff_c.sm /pow(2,model_coeff_c.e)); */

        }

    }

    /*  TO DO : FLOAT_TO_FIX */

    if(NULL != pmc_model_coeff_lin_wo_int)

    {

        UWORD8 u1_curr_frame_index;

        /* UWORD8 u1_avgqp_prvfrm; */

        number_t s_avgqp_prvfrm;

        /* UWORD32 u4_prevfrm_bits, u4_prevfrm_sad; */

        number_t s_prevfrm_bits, s_prevfrm_sad;

        WORD32 i4_local_e = 0;

        LWORD64 i8_local_sad_sm = 0;

        u1_curr_frame_index = ps_rd_model->u1_curr_frm_counter;

        if(0 == u1_curr_frame_index)

            u1_curr_frame_index = (UWORD8)(ps_rd_model->u1_max_frms_to_model - 1);

        else

            u1_curr_frame_index--;

        /* u1_avgqp_prvfrm = ps_rd_model->pu1_avg_mp2qp[u1_curr_frame_index]; */

        /*fract_quant*/

        SET_VARQ_FRM_FIXQ(

            ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index], s_avgqp_prvfrm, QSCALE_Q_FAC);

        /* u4_prevfrm_bits = ps_rd_model->pi4_res_bits[u1_curr_frame_index]; */

        s_prevfrm_bits.sm = ps_rd_model->pi4_res_bits[u1_curr_frame_index];

        s_prevfrm_bits.e = 0;

        /* u4_prevfrm_sad  = ps_rd_model->pi4_sad_h264[u1_curr_frame_index]; */

        /*s_prevfrm_sad.sm = ps_rd_model->pi8_sad[u1_curr_frame_index];

        s_prevfrm_sad.e  = 0;*/

        i8_local_sad_sm = ps_rd_model->pi8_sad[u1_curr_frame_index];

        while(i8_local_sad_sm > 0x7FFFFFFF)

        {

            i8_local_sad_sm = i8_local_sad_sm / 2;

            i4_local_e++;

        }

        SET_VARQ_FRM_FIXQ(((WORD32)i8_local_sad_sm), s_prevfrm_sad, -i4_local_e);

        if(0 != s_prevfrm_sad.sm)

        {

            /* model_coeff_a = (float)(u4_prevfrm_bits * u1_avgqp_prvfrm) / u4_prevfrm_sad; */

            mult32_var_q(s_prevfrm_bits, s_avgqp_prvfrm, &model_coeff_a);

            div32_var_q(model_coeff_a, s_prevfrm_sad, &model_coeff_a);

        }

        else

        {

            model_coeff_a.sm = 0;

            model_coeff_a.e = 0;

        }

        model_coeff_b.sm = 0;

        model_coeff_b.e = 0;

        model_coeff_c.sm = 0;

        model_coeff_c.e = 0;

        pmc_model_coeff_lin_wo_int[0] = model_coeff_b;

        pmc_model_coeff_lin_wo_int[1] = model_coeff_a;

        pmc_model_coeff_lin_wo_int[2] = model_coeff_c;

    }

    /* end of "TO DO : FLOAT_TO_FIX" */

    return u1_model_used;

}

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

  Function Name   : refine_set_of_points

  Description     :

  Arguments       :

  Return Values   : void

  Revision History:

                    Creation

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

static WORD8 refine_set_of_points(

    UWORD32 *pi4_res_bits,

    LWORD64 *pi8_sad_h264,

    WORD32 *pi4_avg_mpeg2_qp_q6,

    UWORD8 u1_num_frms,

    WORD8 *pi1_frame_index,

    number_t *ps_model_coeff,

    number_t *ps_avg_deviation)

{

    /* float  fl_avg_deviation, fl_estimated_bits, fl_deviation, x_val; */

    number_t s_avg_deviation, s_estimated_bits, s_deviation, x_val;

    /* number_t  ps_model_coeff[3]; */

    number_t s_sad_h264, s_avg_mpeg2_qp, s_res_bits;

    number_t temp, temp1;

    UWORD8 u1_return_value = 1;

    UWORD32 i;

    UWORD8 u1_num_frms_used, u1_frm_indx;

    number_t s_num_frms_used;

    /*

    convert_float_to_fix(pmc_model_coeff[0],&ps_model_coeff[0]);

    convert_float_to_fix(pmc_model_coeff[1],&ps_model_coeff[1]);

    convert_float_to_fix(pmc_model_coeff[2],&ps_model_coeff[2]);

    */

    u1_num_frms_used = 0;

    /* fl_avg_deviation = 0; */

    s_avg_deviation.sm = 0;

    s_avg_deviation.e = 0;

    for(i = 0; i < u1_num_frms; i++)

    {

        LWORD64 i8_local_sad_sm = 0;

        WORD32 i4_local_e = 0;

        if(-1 == pi1_frame_index[i])

            continue;

        u1_frm_indx = (UWORD8)pi1_frame_index[i];

        /*x_val = pi4_sad_h264[u1_frm_indx] /

                (float) pui_avg_mpeg2_qp[u1_frm_indx]; */

        /* s_sad_h264.sm = pi8_sad_h264[u1_frm_indx];

        s_sad_h264.e  = 0;*/

        i8_local_sad_sm = pi8_sad_h264[u1_frm_indx];

        while(i8_local_sad_sm > 0x7FFFFFFF)

        {

            i8_local_sad_sm = i8_local_sad_sm / 2;

            i4_local_e++;

        }

        SET_VARQ_FRM_FIXQ(((WORD32)i8_local_sad_sm), s_sad_h264, -i4_local_e);

        /*fract_quant*/

        SET_VARQ_FRM_FIXQ(pi4_avg_mpeg2_qp_q6[u1_frm_indx], s_avg_mpeg2_qp, QSCALE_Q_FAC);

        div32_var_q(s_sad_h264, s_avg_mpeg2_qp, &x_val);

        /*

        fl_estimated_bits = (pmc_model_coeff[0] * x_val * x_val ) +

                            (pmc_model_coeff[1] * x_val) +

                            (pmc_model_coeff[2]);

                            */

        mult32_var_q(x_val, x_val, &temp);

        mult32_var_q(temp, ps_model_coeff[0], &temp);

        mult32_var_q(x_val, ps_model_coeff[1], &temp1);

        add32_var_q(temp, temp1, &s_estimated_bits);

        add32_var_q(s_estimated_bits, ps_model_coeff[2], &s_estimated_bits);

        /*

        fl_deviation        = fabs(pi4_res_bits[u1_frm_indx] - fl_estimated_bits) /

                              (float) pi4_res_bits[u1_frm_indx];

                              */

        s_res_bits.sm = pi4_res_bits[u1_frm_indx];

        s_res_bits.e = 0;

        sub32_var_q(s_res_bits, s_estimated_bits, &temp);

        temp.sm = (temp.sm > 0) ? temp.sm : (-temp.sm);

        div32_var_q(temp, s_res_bits, &s_deviation);

        /* fl_deviation        = fl_deviation * fl_deviation; */

        mult32_var_q(s_deviation, s_deviation, &s_deviation);

        /* fl_avg_deviation    += fl_deviation;*/

        add32_var_q(s_avg_deviation, s_deviation, &s_avg_deviation);

        u1_num_frms_used++;

    }

    /* fl_avg_deviation /= u1_num_frms_used; */

    s_num_frms_used.sm = u1_num_frms_used;

    s_num_frms_used.e = 0;

    div32_var_q(s_avg_deviation, s_num_frms_used, &s_avg_deviation);

    /* fl_avg_deviation = sqrt(fl_avg_deviation); */

    /* fl_avg_deviation = (fl_avg_deviation); */

    for(i = 0; i < u1_num_frms; i++)

    {

        LWORD64 i8_local_sad_sm = 0;

        WORD32 i4_local_e = 0;

        if ((-1 == pi1_frame_index[i]) /*&&

            (i != 0)*/)

            continue;

        u1_frm_indx = (UWORD8)pi1_frame_index[i];

        /*

        x_val = pi4_sad_h264[u1_frm_indx] /

                (float) pui_avg_mpeg2_qp[u1_frm_indx];

                */

        /* s_sad_h264.sm = pi8_sad_h264[u1_frm_indx];

        s_sad_h264.e  = 0;*/

        i8_local_sad_sm = pi8_sad_h264[u1_frm_indx];

        while(i8_local_sad_sm > 0x7FFFFFFF)

        {

            i8_local_sad_sm = i8_local_sad_sm / 2;

            i4_local_e++;

        }

        SET_VARQ_FRM_FIXQ(((WORD32)i8_local_sad_sm), s_sad_h264, -i4_local_e);

        /*fract_quant*/

        SET_VARQ_FRM_FIXQ(pi4_avg_mpeg2_qp_q6[u1_frm_indx], s_avg_mpeg2_qp, QSCALE_Q_FAC);

        div32_var_q(s_sad_h264, s_avg_mpeg2_qp, &x_val);

        /*

        fl_estimated_bits = (pmc_model_coeff[0] * x_val * x_val ) +

                            (pmc_model_coeff[1] * x_val) +

                            (pmc_model_coeff[2]);

                            */

        mult32_var_q(x_val, x_val, &temp);

        mult32_var_q(temp, ps_model_coeff[0], &temp);

        mult32_var_q(x_val, ps_model_coeff[1], &temp1);

        add32_var_q(temp, temp1, &s_estimated_bits);

        add32_var_q(s_estimated_bits, ps_model_coeff[2], &s_estimated_bits);

        /*

        fl_deviation      = fabs(pi4_res_bits[u1_frm_indx] - fl_estimated_bits) /

                            (float) pi4_res_bits[u1_frm_indx];

                            */

        s_res_bits.sm = pi4_res_bits[u1_frm_indx];

        s_res_bits.e = 0;

        sub32_var_q(s_res_bits, s_estimated_bits, &temp);

        temp.sm = (temp.sm > 0) ? temp.sm : (-temp.sm);

        div32_var_q(temp, s_res_bits, &s_deviation);

        /* to remove the sqrt function */

        /*fl_deviation = fl_deviation * fl_deviation; */

        mult32_var_q(s_deviation, s_deviation, &s_deviation);

        /*

        if (fl_deviation > (fl_avg_deviation))

        {

            pi1_frame_index[i] = -1;

        }

        */

        sub32_var_q(s_deviation, s_avg_deviation, &temp);

        if(temp.sm > 0)

        {

            pi1_frame_index[i] = -1;

        }

    }

    {

        number_t up_thr, lo_thr;

        /*

        if (fl_avg_deviation > 0.0625)

        u1_return_value = 0;

        */

        up_thr.sm = UP_THR_SM;

        up_thr.e = UP_THR_E;

        sub32_var_q(s_avg_deviation, up_thr, &temp);

        if(temp.sm > 0)

        {

            u1_return_value = 0;

        }

        /*

        if (fl_avg_deviation < 0.0225)

            u1_return_value = 2;

            */

        lo_thr.sm = LO_THR_SM;

        lo_thr.e = LO_THR_E;

        sub32_var_q(s_avg_deviation, lo_thr, &temp);

        if(temp.sm < 0)

        {

            u1_return_value = 2;

        }

    }

    *ps_avg_deviation = s_avg_deviation;

    return (u1_return_value);

}

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

  Function Name   : calc_avg_sqr_dev_for_model

  Description     :

  Arguments       :

  Return Values   : void

  Revision History:

                    Creation

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

/* TO DO : FLOAT_TO_FIX */

static void calc_avg_sqr_dev_for_model(

    UWORD32 *pi4_res_bits,

    LWORD64 *pi8_sad_h264,

    WORD32 *pi4_avg_mpeg2_qp_q6,

    UWORD8 u1_num_frms,

    WORD8 *pi1_frame_index,

    number_t *ps_model_coeff,

    number_t *ps_avg_deviation)

{

    /* float  fl_avg_deviation, fl_estimated_bits, fl_deviation, x_val; */

    number_t s_avg_deviation, s_estimated_bits, s_deviation, x_val;

    /* UWORD8 u1_return_value = 1; */

    UWORD32 i;

    UWORD8 u1_num_frms_used, u1_frm_indx;

    number_t s_sad_h264;

    number_t s_avg_mpeg2_qp;

    number_t s_res_bits;

    number_t temp;

    number_t s_num_frms_used;

    u1_num_frms_used = 0;

    /* fl_avg_deviation = 0; */

    s_deviation.sm = 0;

    s_deviation.e = 0;

    s_avg_deviation.sm = 0;

    s_avg_deviation.e = 0;

    for(i = 0; i < u1_num_frms; i++)

    {

        LWORD64 i8_local_sad_sm;

        WORD32 i4_local_e = 0;

        if(-1 == pi1_frame_index[i])

            continue;

        u1_frm_indx = (UWORD8)pi1_frame_index[i];

        u1_frm_indx = (UWORD8)i;

        /*

        x_val = pi4_sad_h264[u1_frm_indx] /

                (float) pui_avg_mpeg2_qp[u1_frm_indx];

                */

        /* s_sad_h264.sm = pi8_sad_h264[u1_frm_indx];

        s_sad_h264.e  = 0;*/

        i8_local_sad_sm = pi8_sad_h264[u1_frm_indx];

        while(i8_local_sad_sm > 0x7FFFFFFF)

        {

            i8_local_sad_sm = i8_local_sad_sm / 2;

            i4_local_e++;

        }

        SET_VARQ_FRM_FIXQ(((WORD32)i8_local_sad_sm), s_sad_h264, -i4_local_e);

        /*fract_quant*/

        SET_VARQ_FRM_FIXQ(pi4_avg_mpeg2_qp_q6[u1_frm_indx], s_avg_mpeg2_qp, QSCALE_Q_FAC);

        div32_var_q(s_sad_h264, s_avg_mpeg2_qp, &x_val);

        /*fl_estimated_bits = (pmc_model_coeff[1] * x_val) +

                            (pmc_model_coeff[2]); */

        mult32_var_q(x_val, ps_model_coeff[1], &s_estimated_bits);

        add32_var_q(s_estimated_bits, ps_model_coeff[2], &s_estimated_bits);

        /*fl_deviation        = fabs(pi4_res_bits[u1_frm_indx] - fl_estimated_bits) /

                              (float) pi4_res_bits[u1_frm_indx]; */

        s_res_bits.sm = pi4_res_bits[u1_frm_indx];

        s_res_bits.e = 0;

        sub32_var_q(s_res_bits, s_estimated_bits, &temp);

        temp.sm = (temp.sm > 0) ? temp.sm : (-temp.sm);

        div32_var_q(temp, s_res_bits, &s_deviation);

        /* fl_deviation        = fl_deviation * fl_deviation; */

        mult32_var_q(s_deviation, s_deviation, &s_deviation);

        /* fl_avg_deviation    += fl_deviation; */

        add32_var_q(s_avg_deviation, s_deviation, &s_avg_deviation);

        u1_num_frms_used++;

    }

    /* fl_avg_deviation /= u1_num_frms_used; */

    s_num_frms_used.sm = u1_num_frms_used;

    s_num_frms_used.e = 0;

    div32_var_q(s_avg_deviation, s_num_frms_used, &s_avg_deviation);

    *ps_avg_deviation = s_avg_deviation;

}

/* end of "TO DO : FLOAT_TO_FIX" */

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

  Function Name   : is_qp_available

  Description     :

  Arguments       : ps_rd_model

  Return Values   : void

  Revision History:

                    Creation

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

static WORD32 is_qp_available(

    rc_rd_model_t *ps_rd_model, UWORD8 u1_curr_frame_index, WORD32 i4_num_frames_to_check)

{

    WORD32 i;

    /*fract_quant*/

    WORD32 i4_qp = ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index];

    WORD32 i4_num_frms = 0;

    for(i = 0; i < i4_num_frames_to_check; i++)

    {

        u1_curr_frame_index++;

        if(ps_rd_model->u1_max_frms_to_model == u1_curr_frame_index)

            u1_curr_frame_index = 0;

        /*fract_quant*/

        if(ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index] == i4_qp)

            i4_num_frms++;

    }

    if(i4_num_frms >= 2)

        return (1);

    else

        return (0);

}

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

/*                                                                          */

/*  Function Name : example_of_a_function                                   */

/*                                                                          */

/*  Description   : This function illustrates the use of C coding standards.*/

/*                  switch/case, if, for, block comments have been shown    */

/*                  here.                                                   */

/*  Inputs        : <What inputs does the function take?>                   */

/*  Globals       : <Does it use any global variables?>                     */

/*  Processing    : <Describe how the function operates - include algorithm */

/*                  description>                                            */

/*  Outputs       : <What does the function produce?>                       */

/*  Returns       : <What does the function return?>                        */

/*                                                                          */

/*  Issues        : <List any issues or problems with this function>        */

/*                                                                          */

/*  Revision History:                                                       */

/*                                                                          */

/*         DD MM YYYY   Author(s)       Changes (Describe the changes made) */

/*         13 07 2002   Ittiam          Draft                               */

/*                                                                          */

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

static void update_frame_rd_model(rc_rd_model_t *ps_rd_model)

{

    WORD8 pi1_frame_index[MAX_FRAMES_MODELLED];

    WORD8 pi1_frame_index_initial[MAX_FRAMES_MODELLED];

    UWORD32 u4_num_skips;

    UWORD8 u1_num_skips_temp;

    /*UWORD8  u1_avg_mpeg2_qp_temp, u1_min_mpeg2_qp, u1_max_mpeg2_qp; */

    /*WORD32  i4_avg_mpeg2_qp_temp, i4_min_mpeg2_qp, i4_max_mpeg2_qp;*/

    WORD32 i4_avg_mpeg2_qp_temp_q6, i4_min_mpeg2_qp_q6, i4_max_mpeg2_qp_q6;

    UWORD8 u1_num_frms_input, u1_num_active_frames, u1_reject_frame;

    /* UWORD8  u1_min2_mpeg2_qp, u1_max2_mpeg2_qp; */

    /* WORD32  i4_min2_mpeg2_qp, i4_max2_mpeg2_qp;*/

    WORD32 i4_min2_mpeg2_qp_q6, i4_max2_mpeg2_qp_q6;

    UWORD8 u1_min_qp_frame_indx, u1_max_qp_frame_indx;

    number_t model_coeff_array[3], model_coeff_array_lin[3];

    number_t model_coeff_array_lin_wo_int[3];

    WORD32 i;

    UWORD8 u1_curr_frame_index;

#if RC_MODEL_USED_BUG_FIX

    UWORD8 u1_lin_model_valid;

#endif

    number_t s_quad_avg_sqr_dev, s_lin_avg_sqr_dev;

    UWORD8 u1_check_model;

    model_coeff_array[0].sm = 0;

    model_coeff_array[0].e = 0;

    model_coeff_array[1].sm = 0;

    model_coeff_array[1].e = 0;

    model_coeff_array[2].sm = 0;

    model_coeff_array[2].e = 0;

    model_coeff_array_lin[0].sm = 0;

    model_coeff_array_lin[0].e = 0;

    model_coeff_array_lin[1].sm = 0;

    model_coeff_array_lin[1].e = 0;

    model_coeff_array_lin[2].sm = 0;

    model_coeff_array_lin[2].e = 0;

    model_coeff_array_lin_wo_int[0].sm = 0;

    model_coeff_array_lin_wo_int[0].e = 0;

    model_coeff_array_lin_wo_int[1].sm = 0;

    model_coeff_array_lin_wo_int[1].e = 0;

    model_coeff_array_lin_wo_int[2].sm = 0;

    model_coeff_array_lin_wo_int[2].e = 0;

    /* ps_rd_model += u1_pic_type; */

    u1_curr_frame_index = ps_rd_model->u1_curr_frm_counter;

    ps_rd_model->u1_model_used = QUAD_MODEL;

    if(0 == u1_curr_frame_index)

        u1_curr_frame_index = (UWORD8)(ps_rd_model->u1_max_frms_to_model - 1);

    else

        u1_curr_frame_index--;

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

    /* Rearrange data to be fed into a Linear Regression Module             */

    /* Module finds a,b,c such that                                         */

    /*      y = ax + bx^2 + c                                               */

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

    u4_num_skips = 0;

    u1_num_frms_input = 0;

    /*memset(ps_rd_model->au1_num_frames,   0, MPEG2_QP_ELEM);*/

    memset(pi1_frame_index, -1, MAX_FRAMES_MODELLED);

    /*i4_min_mpeg2_qp = MAX_MPEG2_QP;

    i4_max_mpeg2_qp = 0;*/

    i4_min_mpeg2_qp_q6 = (MAX_MPEG2_QP << QSCALE_Q_FAC);

    i4_max_mpeg2_qp_q6 = MIN_QSCALE_Q6;

    u1_num_active_frames = ps_rd_model->u1_num_frms_in_model;

    if(u1_num_active_frames > MAX_ACTIVE_FRAMES)

        u1_num_active_frames = MAX_ACTIVE_FRAMES;

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

    /* Choose the set of Points to be used for MSE fit of Quadratic model   */

    /* Points chosen are spread across the Qp range. Max of 2 points are    */

    /* chosen for a Qp.                                                     */

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

    for(i = 0; i < u1_num_active_frames; i++)

    {

        /* WORD32 i4_test1 = 0, i4_test2 = 0; NITT TBD */

        u1_reject_frame = 0;

        u1_num_skips_temp = ps_rd_model->pu1_num_skips[u1_curr_frame_index];

        /*fract_quant*/

        /*i4_avg_mpeg2_qp_temp = (ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index] >> QSCALE_Q_FAC);*/

        i4_avg_mpeg2_qp_temp_q6 = ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index];

        if((0 == u4_num_skips) && (0 != u1_num_skips_temp))

            u1_reject_frame = 1;

        if((1 == u4_num_skips) && (u1_num_skips_temp > 1))

            u1_reject_frame = 1;

        /* If there is already a frame having same qp reject the current frame */

        if(is_qp_available(ps_rd_model, u1_curr_frame_index, i))

            u1_reject_frame = 1;

        /*if (ps_rd_model->au1_num_frames[i4_avg_mpeg2_qp_temp]  >= 2)

        {

            u1_reject_frame = 1;

            i4_test2 = 1;

        }

        if(i4_test2 != i4_test1)

        {

            printf("Why am I here??\n");

        }*/

        if(0 == i)

            u1_reject_frame = 0;

        if(0 == u1_reject_frame)

        {

            pi1_frame_index[u1_num_frms_input] = (WORD8)u1_curr_frame_index;

            /* ps_rd_model->au1_num_frames[i4_avg_mpeg2_qp_temp] += 1; */

            /*if (i4_min_mpeg2_qp > i4_avg_mpeg2_qp_temp) i4_min_mpeg2_qp = i4_avg_mpeg2_qp_temp;

            if (i4_max_mpeg2_qp < i4_avg_mpeg2_qp_temp) i4_max_mpeg2_qp = i4_avg_mpeg2_qp_temp;*/

            if(i4_min_mpeg2_qp_q6 > i4_avg_mpeg2_qp_temp_q6)

                i4_min_mpeg2_qp_q6 = i4_avg_mpeg2_qp_temp_q6;

            if(i4_max_mpeg2_qp_q6 < i4_avg_mpeg2_qp_temp_q6)

                i4_max_mpeg2_qp_q6 = i4_avg_mpeg2_qp_temp_q6;

            u1_num_frms_input++;

        }

        if(0 == u1_curr_frame_index)

            u1_curr_frame_index = (UWORD8)(ps_rd_model->u1_max_frms_to_model - 1);

        else

            u1_curr_frame_index--;

    }

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

    /* Add Pivot Points to the Data set to be used for finding Quadratic    */

    /* Model Coeffs. These will help in constraining the shape of  Quadratic*/

    /* to adapt too much to the Local deviations.                           */

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

    /*i4_min2_mpeg2_qp     = i4_min_mpeg2_qp;

    i4_max2_mpeg2_qp     = i4_max_mpeg2_qp;*/

    i4_min2_mpeg2_qp_q6 = i4_min_mpeg2_qp_q6;

    i4_max2_mpeg2_qp_q6 = i4_max_mpeg2_qp_q6;

    u1_min_qp_frame_indx = INVALID_FRAME_INDEX;

    u1_max_qp_frame_indx = INVALID_FRAME_INDEX;

    /* Loop runnning over the Stored Frame Level Data

       to find frames of MinQp and MaxQp */

    for(; i < ps_rd_model->u1_num_frms_in_model; i++)

    {

        u1_num_skips_temp = ps_rd_model->pu1_num_skips[u1_curr_frame_index];

        /*fract_quant*/

        //i4_avg_mpeg2_qp_temp = ps_rd_model->ai4_avg_qp[u1_curr_frame_index];

        //i4_avg_mpeg2_qp_temp = (ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index] >> QSCALE_Q_FAC);

        i4_avg_mpeg2_qp_temp_q6 = ps_rd_model->ai4_avg_qp_q6[u1_curr_frame_index];

        if(((0 == u4_num_skips) && (0 != u1_num_skips_temp)) ||

           ((1 == u4_num_skips) && (u1_num_skips_temp > 1)))

            continue;

        /*

        if (i4_min2_mpeg2_qp > i4_avg_mpeg2_qp_temp)

        {

            i4_min2_mpeg2_qp     = i4_avg_mpeg2_qp_temp;

            u1_min_qp_frame_indx = u1_curr_frame_index;

        }

        if (i4_max2_mpeg2_qp < i4_avg_mpeg2_qp_temp)

        {

            i4_max2_mpeg2_qp     = i4_avg_mpeg2_qp_temp;

            u1_max_qp_frame_indx = u1_curr_frame_index;

        }

*/

        if(i4_min2_mpeg2_qp_q6 > i4_avg_mpeg2_qp_temp_q6)

        {

            i4_min2_mpeg2_qp_q6 = i4_avg_mpeg2_qp_temp_q6;

            u1_min_qp_frame_indx = u1_curr_frame_index;

        }

        if(i4_max2_mpeg2_qp_q6 < i4_avg_mpeg2_qp_temp_q6)

        {

            i4_max2_mpeg2_qp_q6 = i4_avg_mpeg2_qp_temp_q6;

            u1_max_qp_frame_indx = u1_curr_frame_index;

        }

        if(0 == u1_curr_frame_index)

            u1_curr_frame_index = (UWORD8)(ps_rd_model->u1_max_frms_to_model - 1);

        else

            u1_curr_frame_index--;

    }

    /* Add the Chosen Points to the regression data set */

    if(INVALID_FRAME_INDEX != u1_min_qp_frame_indx)

    {

        pi1_frame_index[u1_num_frms_input] = (WORD8)u1_min_qp_frame_indx;

        u1_num_frms_input++;

    }

    if(INVALID_FRAME_INDEX != u1_max_qp_frame_indx)

    {

        pi1_frame_index[u1_num_frms_input] = (WORD8)u1_max_qp_frame_indx;

        u1_num_frms_input++;

    }

    /* memcpy(pi1_frame_index_initial, pi1_frame_index, MAX_FRAMES_MODELLED); */

    {

        UWORD8 u1_k;

        for(u1_k = 0; u1_k < MAX_FRAMES_MODELLED; u1_k++)

        {

            pi1_frame_index_initial[u1_k] = pi1_frame_index[u1_k];

        }