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

 *

 * 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 ihevce_frame_process.c

*

* \brief

*    This file contains top level functions related Frame processing

*

* \date

*    18/09/2012

*

* \author

*    Ittiam

*

*

* List of Functions

*

*

******************************************************************************

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

#include <time.h>

/* User include files */

#include "ihevc_typedefs.h"

#include "itt_video_api.h"

#include "ihevce_api.h"

#include "rc_cntrl_param.h"

#include "rc_frame_info_collector.h"

#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"

#include "ihevc_debug.h"

#include "ihevc_macros.h"

#include "ihevc_structs.h"

#include "ihevc_platform_macros.h"

#include "ihevc_deblk.h"

#include "ihevc_itrans_recon.h"

#include "ihevc_chroma_itrans_recon.h"

#include "ihevc_chroma_intra_pred.h"

#include "ihevc_intra_pred.h"

#include "ihevc_inter_pred.h"

#include "ihevc_mem_fns.h"

#include "ihevc_padding.h"

#include "ihevc_weighted_pred.h"

#include "ihevc_sao.h"

#include "ihevc_resi_trans.h"

#include "ihevc_quant_iquant_ssd.h"

#include "ihevc_cabac_tables.h"

#include "ihevc_common_tables.h"

#include "ihevce_defs.h"

#include "ihevce_buffer_que_interface.h"

#include "ihevce_hle_interface.h"

#include "ihevce_hle_q_func.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_lap_interface.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_multi_thrd_funcs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_had_satd.h"

#include "ihevce_error_checks.h"

#include "ihevce_error_codes.h"

#include "ihevce_bitstream.h"

#include "ihevce_cabac.h"

#include "ihevce_rdoq_macros.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_global_tables.h"

#include "ihevce_cmn_utils_instr_set_router.h"

#include "ihevce_ipe_instr_set_router.h"

#include "ihevce_entropy_structs.h"

#include "ihevce_enc_loop_structs.h"

#include "ihevce_enc_loop_utils.h"

#include "ihevce_inter_pred.h"

#include "ihevce_common_utils.h"

#include "ihevce_sub_pic_rc.h"

#include "hme_datatype.h"

#include "hme_interface.h"

#include "hme_common_defs.h"

#include "hme_defs.h"

#include "ihevce_enc_loop_pass.h"

#include "ihevce_trace.h"

#include "ihevce_encode_header.h"

#include "ihevce_encode_header_sei_vui.h"

#include "ihevce_ipe_structs.h"

#include "ihevce_ipe_pass.h"

#include "ihevce_dep_mngr_interface.h"

#include "ihevce_rc_enc_structs.h"

#include "hme_globals.h"

#include "ihevce_me_pass.h"

#include "ihevce_coarse_me_pass.h"

#include "ihevce_frame_process.h"

#include "ihevce_rc_interface.h"

#include "ihevce_profile.h"

#include "ihevce_decomp_pre_intra_structs.h"

#include "ihevce_decomp_pre_intra_pass.h"

#include "ihevce_frame_process_utils.h"

#include "cast_types.h"

#include "osal.h"

#include "osal_defaults.h"

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

/* Constant Macros                                                           */

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

#define REF_MOD_STRENGTH 1.0

#define REF_MAX_STRENGTH 1.4f

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

/* Extern variables                                                          */

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

/**

* @var   QP2QUANT_MD[]

*

* @brief Direct Cost Comoparision Table

*

* @param Comments: Direct cost is compared with 16 * QP2QUANT_MD[Qp]

*                  If direct cost is less  than 16 * QP2QUANT_MD[Qp]

*                  than direct cost is assumed to be zero

*/

const WORD16 QP2QUANT_MD[52] = { 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

                                 1,  1,  1,  2,  2,  2,  2,  3,  3,  3,  4,  4,  4,

                                 5,  6,  6,  7,  8,  9,  10, 11, 13, 14, 16, 18, 20,

                                 23, 25, 29, 32, 36, 40, 45, 51, 57, 64, 72, 81, 91 };

/*

Gaussian 11x11 window with a sigma of 1.5 - values multiplied by 2048

Window made into 9x9 window as most entries were zero

The center weight has been reduced by 1 after dropping first row/col and last row/col

*/

UWORD8 g_u1_win_size = 9;

UWORD8 g_u1_win_q_shift = 11;

UWORD8 au1_g_win[81] = { 0,  1,  2, 3,  4,  3,   2,   1,   0,  1,  3, 8,  16, 20, 16,  8,   3,

                         1,  2,  8, 24, 48, 60,  48,  24,  8,  2,  3, 16, 48, 93, 116, 93,  48,

                         16, 3,  4, 20, 60, 116, 144, 116, 60, 20, 4, 3,  16, 48, 93,  116, 93,

                         48, 16, 3, 2,  8,  24,  48,  60,  48, 24, 8, 2,  1,  3,  8,   16,  20,

                         16, 8,  3, 1,  0,  1,   2,   3,   4,  3,  2, 1,  0 };

/* lagrange params */

const double lamda_modifier_for_I_pic[8] = { 0.85,   0.7471, 0.6646, 0.5913,

                                             0.5261, 0.4680, 0.4164, 0.3705 };

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

/* Function Definitions                                                      */

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

/*!

******************************************************************************

* \if Function name : ihevce_mbr_quality_tool_set_configuration \endif

*

* \brief

*   tool set selection for auxilary bitrate. currently only num intra and inter

*       candidates for auxilary bitrates are controlled

*

* \param[in] ps_enc_loop_thrd_ctxt : enc ctxt

* \param[in] ps_stat_prms: static parameters

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_mbr_quality_tool_set_configuration(

    ihevce_enc_loop_ctxt_t *ps_enc_loop_thrd_ctxt, ihevce_static_cfg_params_t *ps_stat_prms)

{

    /* for single bitrate encoder*/

    switch(ps_stat_prms->s_tgt_lyr_prms.i4_mbr_quality_setting)

    {

    case IHEVCE_MBR_HIGH_QUALITY:

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_intra = 3;

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_inter = 4;

        break;

    case IHEVCE_MBR_MEDIUM_SPEED:

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_intra = 3;

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_inter = 3;

        break;

    case IHEVCE_MBR_HIGH_SPEED:

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_intra = 2;

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_inter = 2;

        break;

    case IHEVCE_MBR_EXTREME_SPEED:

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_intra = 1;

        ps_enc_loop_thrd_ctxt->i4_num_modes_to_evaluate_inter = 1;

        break;

    default:

        assert(0);

        break;

    }

}

/*!

******************************************************************************

* \if Function name : ihevce_find_free_indx \endif

*

* \brief

*    Pre encode Frame processing slave thread entry point function

*

* \param[in] Frame processing thread context pointer

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

WORD32 ihevce_find_free_indx(recon_pic_buf_t **pps_recon_buf_q, WORD32 i4_num_buf)

{

    WORD32 i4_ctr;

    WORD32 i4_is_full = 1;

    WORD32 i4_least_POC = 0x7FFFFFFF;

    WORD32 i4_least_POC_idx = -1;

    WORD32 i4_least_GOP_num = 0x7FFFFFFF;

    for(i4_ctr = 0; i4_ctr < i4_num_buf; i4_ctr++)

    {

        if(pps_recon_buf_q[i4_ctr]->i4_is_free == 1)

        {

            i4_is_full = 0;

            break;

        }

    }

    if(i4_is_full)

    {

        /* remove if any non-reference pictures are present */

        for(i4_ctr = 0; i4_ctr < i4_num_buf; i4_ctr++)

        {

            if(!pps_recon_buf_q[i4_ctr]->i4_is_reference &&

               pps_recon_buf_q[i4_ctr]->i4_non_ref_free_flag)

            {

                i4_least_POC_idx = i4_ctr;

                break;

            }

        }

        /* if all non reference pictures are removed, then find the least poc

        in the least gop number*/

        if(i4_least_POC_idx == -1)

        {

            for(i4_ctr = 0; i4_ctr < i4_num_buf; i4_ctr++)

            {

                if(i4_least_GOP_num > pps_recon_buf_q[i4_ctr]->i4_idr_gop_num)

                {

                    i4_least_GOP_num = pps_recon_buf_q[i4_ctr]->i4_idr_gop_num;

                }

            }

            for(i4_ctr = 0; i4_ctr < i4_num_buf; i4_ctr++)

            {

                if(i4_least_POC > pps_recon_buf_q[i4_ctr]->i4_poc &&

                   i4_least_GOP_num == pps_recon_buf_q[i4_ctr]->i4_idr_gop_num)

                {

                    i4_least_POC = pps_recon_buf_q[i4_ctr]->i4_poc;

                    i4_least_POC_idx = i4_ctr;

                }

            }

        }

    }

    return i4_least_POC_idx;

}

/*!

******************************************************************************

* \if Function name : complexity_RC_reset_marking \endif

*

* \brief

*   this function the complexity variation and set the complexity change flag for

*   rate control to reset the model

*

* \param[in] ps_enc_loop_thrd_ctxt : enc ctxt

* \param[in] ps_stat_prms: static parameters

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void complexity_RC_reset_marking(enc_ctxt_t *ps_enc_ctxt, WORD32 i4_cur_ipe_idx, WORD32 i4_end_flag)

{

    rc_lap_out_params_t *ps_cur_ipe_lap_out;

    rc_lap_out_params_t *ps_lap_out_temp;

    WORD32 i4_max_temporal_layers;

    ps_cur_ipe_lap_out =

        &ps_enc_ctxt->s_multi_thrd.aps_curr_inp_pre_enc[i4_cur_ipe_idx]->s_rc_lap_out;

    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_model = 0;

    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_bits = 0;

    i4_max_temporal_layers = ps_enc_ctxt->ps_stat_prms->s_coding_tools_prms.i4_max_temporal_layers;

    /*reset the RC_reset counter at reset points*/

    if(ps_cur_ipe_lap_out->i4_is_I_only_scd || ps_cur_ipe_lap_out->i4_is_non_I_scd ||

       ps_cur_ipe_lap_out->i4_rc_scene_type == SCENE_TYPE_SCENE_CUT)

    {

        ps_enc_ctxt->i4_past_RC_reset_count = 0;

    }

    if(ps_cur_ipe_lap_out->i4_rc_scene_type == SCENE_TYPE_SCENE_CUT)

    {

        ps_enc_ctxt->i4_past_RC_scd_reset_count = 0;

    }

    ps_enc_ctxt->i4_past_RC_reset_count++;

    ps_enc_ctxt->i4_past_RC_scd_reset_count++;

    /*complexity based rate control reset */

    if((ps_cur_ipe_lap_out->i4_rc_pic_type == IV_P_FRAME ||

        ps_cur_ipe_lap_out->i4_rc_pic_type == IV_I_FRAME) &&

       (i4_max_temporal_layers > 1) && (!i4_end_flag) &&

       (ps_enc_ctxt->s_multi_thrd.i4_delay_pre_me_btw_l0_ipe > (2 * (1 << i4_max_temporal_layers))))

    {

        WORD32 i4_is_cur_pic_high_complex_region =

            ps_enc_ctxt->s_multi_thrd.aps_curr_out_pre_enc[i4_cur_ipe_idx]

                ->i4_is_high_complex_region;

        WORD32 i4_next_ipe_idx;

        WORD32 i4_next_next_ipe_idx;

        WORD32 i4_temp_ipe_idx;

        WORD32 i;

        ps_enc_ctxt->i4_future_RC_reset = 0;

        ps_enc_ctxt->i4_future_RC_scd_reset = 0;

        ASSERT(i4_is_cur_pic_high_complex_region != -1);

        /*get the next idx of p/i picture */

        i4_next_ipe_idx = (i4_cur_ipe_idx + 1);

        if(i4_next_ipe_idx >= ps_enc_ctxt->s_multi_thrd.i4_max_delay_pre_me_btw_l0_ipe)

        {

            i4_next_ipe_idx = 0;

        }

        i4_temp_ipe_idx = i4_next_ipe_idx;

        for(i = 0; i < (1 << i4_max_temporal_layers); i++)

        {

            ps_lap_out_temp =

                &ps_enc_ctxt->s_multi_thrd.aps_curr_inp_pre_enc[i4_next_ipe_idx]->s_rc_lap_out;

            if(ps_lap_out_temp->i4_rc_pic_type == IV_P_FRAME ||

               ps_lap_out_temp->i4_rc_pic_type == IV_I_FRAME)

            {

                break;

            }

            i4_next_ipe_idx++;

            if(i4_next_ipe_idx >= ps_enc_ctxt->s_multi_thrd.i4_max_delay_pre_me_btw_l0_ipe)

            {

                i4_next_ipe_idx = 0;

            }

        }

        /* get the next idx of next p/i picture*/

        i4_next_next_ipe_idx = (i4_next_ipe_idx + 1);

        if(i4_next_next_ipe_idx >= ps_enc_ctxt->s_multi_thrd.i4_max_delay_pre_me_btw_l0_ipe)

        {

            i4_next_next_ipe_idx = 0;

        }

        for(i = 0; i < (1 << i4_max_temporal_layers); i++)

        {

            ps_lap_out_temp =

                &ps_enc_ctxt->s_multi_thrd.aps_curr_inp_pre_enc[i4_next_next_ipe_idx]->s_rc_lap_out;

            if(ps_lap_out_temp->i4_rc_pic_type == IV_P_FRAME ||

               ps_lap_out_temp->i4_rc_pic_type == IV_I_FRAME)

            {

                break;

            }

            i4_next_next_ipe_idx++;

            if(i4_next_next_ipe_idx >= ps_enc_ctxt->s_multi_thrd.i4_max_delay_pre_me_btw_l0_ipe)

            {

                i4_next_next_ipe_idx = 0;

            }

        }

        /*check for any possible RC reset in the future 8 frames*/

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

        {

            ps_lap_out_temp =

                &ps_enc_ctxt->s_multi_thrd.aps_curr_inp_pre_enc[i4_temp_ipe_idx]->s_rc_lap_out;

            if(ps_lap_out_temp->i4_is_I_only_scd || ps_lap_out_temp->i4_is_non_I_scd ||

               ps_lap_out_temp->i4_rc_scene_type == SCENE_TYPE_SCENE_CUT)

            {

                ps_enc_ctxt->i4_future_RC_reset = 1;

            }

            if(ps_cur_ipe_lap_out->i4_rc_scene_type == SCENE_TYPE_SCENE_CUT)

            {

                ps_enc_ctxt->i4_future_RC_scd_reset = 1;

            }

            i4_temp_ipe_idx++;

            if(i4_temp_ipe_idx >= ps_enc_ctxt->s_multi_thrd.i4_max_delay_pre_me_btw_l0_ipe)

            {

                i4_temp_ipe_idx = 0;

            }

        }

        if((!ps_enc_ctxt->i4_future_RC_reset) && (ps_enc_ctxt->i4_past_RC_reset_count > 8))

        {

            /*if the prev two P/I pic is not in high complex region

            then enable reset RC flag*/

            if((!ps_enc_ctxt->ai4_is_past_pic_complex[0]) &&

               (!ps_enc_ctxt->ai4_is_past_pic_complex[1]))

            {

                if(i4_is_cur_pic_high_complex_region)

                {

                    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_model = 1;

                    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_bits = 1;

                    ps_enc_ctxt->i4_is_I_reset_done = 0;

                }

            }

            /*if the next two P/I pic is not in high complex region

            then enable reset RC flag*/

            if((!ps_enc_ctxt->s_multi_thrd.aps_curr_out_pre_enc[i4_next_ipe_idx]

                     ->i4_is_high_complex_region) &&

               (!ps_enc_ctxt->s_multi_thrd.aps_curr_out_pre_enc[i4_next_next_ipe_idx]

                     ->i4_is_high_complex_region))

            {

                if(i4_is_cur_pic_high_complex_region)

                {

                    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_model = 1;

                    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_bits = 1;

                    ps_enc_ctxt->i4_is_I_reset_done = 0;

                }

            }

        }

        else if((!ps_enc_ctxt->i4_future_RC_scd_reset) && (ps_enc_ctxt->i4_past_RC_scd_reset_count > 8))

        {

            /*if the prev two P/I pic is not in high complex region

            then enable reset RC flag*/

            if((!ps_enc_ctxt->ai4_is_past_pic_complex[0]) &&

               (!ps_enc_ctxt->ai4_is_past_pic_complex[1]))

            {

                if(i4_is_cur_pic_high_complex_region)

                {

                    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_bits = 1;

                }

            }

            /*if the next two P/I pic is not in high complex region

            then enable reset RC flag*/

            if((!ps_enc_ctxt->s_multi_thrd.aps_curr_out_pre_enc[i4_next_ipe_idx]

                     ->i4_is_high_complex_region) &&

               (!ps_enc_ctxt->s_multi_thrd.aps_curr_out_pre_enc[i4_next_next_ipe_idx]

                     ->i4_is_high_complex_region))

            {

                if(i4_is_cur_pic_high_complex_region)

                {

                    ps_cur_ipe_lap_out->i4_is_cmplx_change_reset_bits = 1;

                }

            }

        }

        /* forcing I frame reset after complexity change is disable as it gives gain, could be due to that

        required i reset is already happening on pre Intra SAD*/

        /*if(!ps_enc_ctxt->i4_is_I_reset_done && (ps_cur_ipe_lap_out->i4_pic_type

        == IV_I_FRAME))

        {

            ps_cur_ipe_lap_out->i4_is_I_only_scd = 1;

            ps_enc_ctxt->i4_is_I_reset_done = 1;

        }*/

        ps_enc_ctxt->ai4_is_past_pic_complex[0] = i4_is_cur_pic_high_complex_region;

        ps_enc_ctxt->ai4_is_past_pic_complex[1] = ps_enc_ctxt->ai4_is_past_pic_complex[0];

    }

    return;

}

/*!

******************************************************************************

* \if Function name : ihevce_manage_ref_pics \endif

*

* \brief

*    Reference picture management based on delta poc array given by LAP

*    Populates the reference list after removing non used reference pictures

*    populates the delta poc of reference pics to be signalled in slice header

*

* \param[in] encoder context pointer

* \param[in] current LAP Encoder buffer pointer

* \param[in] current frame process and entropy buffer pointer

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_pre_enc_manage_ref_pics(

    enc_ctxt_t *ps_enc_ctxt,

    ihevce_lap_enc_buf_t *ps_curr_inp,

    pre_enc_me_ctxt_t *ps_curr_out,

    WORD32 i4_ping_pong)

{

    /* local variables */

    WORD32 ctr;

    WORD32 ref_pics;

    WORD32 ai4_buf_status[HEVCE_MAX_DPB_PICS] = { 0 };

    WORD32 curr_poc;

    WORD32 wp_flag = 0;

    WORD32 num_ref_pics_list0 = 0;

    WORD32 num_ref_pics_list1 = 0;

    WORD32 cra_poc = ps_curr_inp->s_lap_out.i4_assoc_IRAP_poc;

    WORD32 slice_type = ps_curr_out->s_slice_hdr.i1_slice_type;

    recon_pic_buf_t *(*aps_pre_enc_ref_pic_list)[HEVCE_MAX_REF_PICS * 2];

    WORD32 i4_inc_L1_active_ref_pic = 0;

    WORD32 i4_inc_L0_active_ref_pic = 0;

    (void)ps_curr_out;

    curr_poc = ps_curr_inp->s_lap_out.i4_poc;

    /* Number of reference pics given by LAP should not be greater than max */

    ASSERT(HEVCE_MAX_REF_PICS >= ps_curr_inp->s_lap_out.i4_num_ref_pics);

    /*derive ref_pic_list based on ping_pong instance */

    aps_pre_enc_ref_pic_list = ps_enc_ctxt->aps_pre_enc_ref_lists[i4_ping_pong];

    /* derive the weighted prediction enable flag based on slice type */

    if(BSLICE == slice_type)

    {

        wp_flag = ps_curr_inp->s_lap_out.i1_weighted_bipred_flag;

    }

    else if(PSLICE == slice_type)

    {

        wp_flag = ps_curr_inp->s_lap_out.i1_weighted_pred_flag;

    }

    else

    {

        wp_flag = 0;

    }

    /*to support diplicate pics*/

    {

        WORD32 i, j;

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

        {

            for(j = 0; j < HEVCE_MAX_REF_PICS * 2; j++)

            {

                aps_pre_enc_ref_pic_list[i][j] =

                    &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][i][j];

            }

        }

    }

    /* run a loop over the number of reference pics given by LAP */

    for(ref_pics = 0; ref_pics < ps_curr_inp->s_lap_out.i4_num_ref_pics; ref_pics++)

    {

        WORD32 ref_poc;

        WORD32 i4_loop = 1;

        WORD32 i4_temp_list;

        ref_poc = curr_poc + ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].i4_ref_pic_delta_poc;

        /* run a loop to check the poc based on delta poc array */

        for(ctr = 0; ctr < ps_enc_ctxt->i4_pre_enc_num_buf_recon_q; ctr++)

        {

            /* if the POC is matching with current ref picture*/

            if((ref_poc == ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr]->i4_poc) &&

               (0 == ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr]->i4_is_free))

            {

                /* mark the buf status as used */

                ai4_buf_status[ctr] = 1;

                /* populate the reference lists based on delta poc array */

                if((ref_poc < curr_poc) || (0 == curr_poc))

                {

                    /* list 0 */

                    memcpy(

                        &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_0][num_ref_pics_list0],

                        ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr],

                        sizeof(recon_pic_buf_t));

                    i4_temp_list = num_ref_pics_list0;

                    /*duplicate pics added to the list*/

                    while(i4_loop != ps_curr_inp->s_lap_out.as_ref_pics[ref_pics]

                                         .i4_num_duplicate_entries_in_ref_list)

                    {

                        /* list 0 */

                        i4_temp_list++;

                        memcpy(

                            &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_0][i4_temp_list],

                            ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr],

                            sizeof(recon_pic_buf_t));

                        i4_loop++;

                    }

                    /* populate weights and offsets corresponding to this ref pic */

                    memcpy(

                        &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_0][num_ref_pics_list0]

                             .s_weight_offset,

                        &ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].as_wght_off[0],

                        sizeof(ihevce_wght_offst_t));

                    /* Store the used as ref for current pic flag  */

                    ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_0][num_ref_pics_list0]

                        .i4_used_by_cur_pic_flag =

                        ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].i4_used_by_cur_pic_flag;

                    num_ref_pics_list0++;

                    i4_loop = 1;

                    /*duplicate pics added to the list*/

                    while(i4_loop != ps_curr_inp->s_lap_out.as_ref_pics[ref_pics]

                                         .i4_num_duplicate_entries_in_ref_list)

                    {

                        /* populate weights and offsets corresponding to this ref pic */

                        memcpy(

                            &ps_enc_ctxt

                                 ->as_pre_enc_ref_lists[i4_ping_pong][LIST_0][num_ref_pics_list0]

                                 .s_weight_offset,

                            &ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].as_wght_off[i4_loop],

                            sizeof(ihevce_wght_offst_t));

                        /* Store the used as ref for current pic flag  */

                        ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_0][num_ref_pics_list0]

                            .i4_used_by_cur_pic_flag =

                            ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].i4_used_by_cur_pic_flag;

                        num_ref_pics_list0++;

                        i4_loop++;

                    }

                }

                else

                {

                    /* list 1 */

                    memcpy(

                        &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_1][num_ref_pics_list1],

                        ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr],

                        sizeof(recon_pic_buf_t));

                    i4_temp_list = num_ref_pics_list1;

                    /*duplicate pics added to the list*/

                    while(i4_loop != ps_curr_inp->s_lap_out.as_ref_pics[ref_pics]

                                         .i4_num_duplicate_entries_in_ref_list)

                    {

                        /* list 1 */

                        i4_temp_list++;

                        memcpy(

                            &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_1][i4_temp_list],

                            ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr],

                            sizeof(recon_pic_buf_t));

                        i4_loop++;

                    }

                    /* populate weights and offsets corresponding to this ref pic */

                    memcpy(

                        &ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_1][num_ref_pics_list1]

                             .s_weight_offset,

                        &ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].as_wght_off[0],

                        sizeof(ihevce_wght_offst_t));

                    /* Store the used as ref for current pic flag  */

                    ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_1][num_ref_pics_list1]

                        .i4_used_by_cur_pic_flag =

                        ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].i4_used_by_cur_pic_flag;

                    num_ref_pics_list1++;

                    i4_loop = 1;

                    /*duplicate pics added to the list*/

                    while(i4_loop != ps_curr_inp->s_lap_out.as_ref_pics[ref_pics]

                                         .i4_num_duplicate_entries_in_ref_list)

                    {

                        /* populate weights and offsets corresponding to this ref pic */

                        memcpy(

                            &ps_enc_ctxt

                                 ->as_pre_enc_ref_lists[i4_ping_pong][LIST_1][num_ref_pics_list1]

                                 .s_weight_offset,

                            &ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].as_wght_off[i4_loop],

                            sizeof(ihevce_wght_offst_t));

                        /* Store the used as ref for current pic flag  */

                        ps_enc_ctxt->as_pre_enc_ref_lists[i4_ping_pong][LIST_1][num_ref_pics_list1]

                            .i4_used_by_cur_pic_flag =

                            ps_curr_inp->s_lap_out.as_ref_pics[ref_pics].i4_used_by_cur_pic_flag;

                        num_ref_pics_list1++;

                        i4_loop++;

                    }

                }

                break;

            }

        }

        /* if the reference picture is not found then error */

        ASSERT(ctr != ps_enc_ctxt->i4_pre_enc_num_buf_recon_q);

    }

    /* sort the reference pics in List0 in descending order POC */

    if(num_ref_pics_list0 > 1)

    {

        /* run a loop for num ref pics -1 */

        for(ctr = 0; ctr < num_ref_pics_list0 - 1; ctr++)

        {

            WORD32 max_idx = ctr;

            recon_pic_buf_t *ps_temp;

            WORD32 i;

            for(i = (ctr + 1); i < num_ref_pics_list0; i++)

            {

                /* check for poc greater than current ref poc */

                if(aps_pre_enc_ref_pic_list[LIST_0][i]->i4_poc >

                   aps_pre_enc_ref_pic_list[LIST_0][max_idx]->i4_poc)

                {

                    max_idx = i;

                }

            }

            /* if max of remaining is not current, swap the pointers */

            if(max_idx != ctr)

            {

                ps_temp = aps_pre_enc_ref_pic_list[LIST_0][max_idx];

                aps_pre_enc_ref_pic_list[LIST_0][max_idx] = aps_pre_enc_ref_pic_list[LIST_0][ctr];

                aps_pre_enc_ref_pic_list[LIST_0][ctr] = ps_temp;

            }

        }

    }

    /* sort the reference pics in List1 in ascending order POC */

    if(num_ref_pics_list1 > 1)

    {

        /* run a loop for num ref pics -1 */

        for(ctr = 0; ctr < num_ref_pics_list1 - 1; ctr++)

        {

            WORD32 min_idx = ctr;

            recon_pic_buf_t *ps_temp;

            WORD32 i;

            for(i = (ctr + 1); i < num_ref_pics_list1; i++)

            {

                /* check for p[oc less than current ref poc */

                if(aps_pre_enc_ref_pic_list[LIST_1][i]->i4_poc <

                   aps_pre_enc_ref_pic_list[LIST_1][min_idx]->i4_poc)

                {

                    min_idx = i;

                }

            }

            /* if min of remaining is not current, swap the pointers */

            if(min_idx != ctr)

            {

                ps_temp = aps_pre_enc_ref_pic_list[LIST_1][min_idx];

                aps_pre_enc_ref_pic_list[LIST_1][min_idx] = aps_pre_enc_ref_pic_list[LIST_1][ctr];

                aps_pre_enc_ref_pic_list[LIST_1][ctr] = ps_temp;

            }

        }

    }

    /* call the ME API to update the DPB of HME pyramids coarse layers */

    ihevce_coarse_me_frame_dpb_update(

        ps_enc_ctxt->s_module_ctxt.pv_coarse_me_ctxt,

        num_ref_pics_list0,

        num_ref_pics_list1,

        &aps_pre_enc_ref_pic_list[LIST_0][0],

        &aps_pre_enc_ref_pic_list[LIST_1][0]);

    /* Default list creation based on uses as ref pic for current pic flag */

    {

        WORD32 num_ref_pics_list_final = 0;

        WORD32 list_idx = 0;

        /* LIST 0 */

        /* run a loop for num ref pics in list 0 */

        for(ctr = 0; ctr < num_ref_pics_list0; ctr++)

        {

            /* check for used as reference flag */

            if(1 == aps_pre_enc_ref_pic_list[LIST_0][ctr]->i4_used_by_cur_pic_flag)

            {

                /* copy the pointer to the actual valid list idx */

                aps_pre_enc_ref_pic_list[LIST_0][list_idx] = aps_pre_enc_ref_pic_list[LIST_0][ctr];

                /* increment the valid pic counters and idx */

                list_idx++;

                num_ref_pics_list_final++;

            }

        }

        /* finally store the number of pictures in List0 */

        num_ref_pics_list0 = num_ref_pics_list_final;

        /* LIST 1 */

        num_ref_pics_list_final = 0;

        list_idx = 0;

        /* run a loop for num ref pics in list 1 */

        for(ctr = 0; ctr < num_ref_pics_list1; ctr++)

        {

            /* check for used as reference flag */

            if(1 == aps_pre_enc_ref_pic_list[LIST_1][ctr]->i4_used_by_cur_pic_flag)

            {

                /* copy the pointer to the actual valid list idx */

                aps_pre_enc_ref_pic_list[LIST_1][list_idx] = aps_pre_enc_ref_pic_list[LIST_1][ctr];

                /* increment the valid pic counters and idx */

                list_idx++;

                num_ref_pics_list_final++;

            }

        }

        /* finally store the number of pictures in List1 */

        num_ref_pics_list1 = num_ref_pics_list_final;

    }

    /*in case of single active ref picture on L0 and L1, then consider one of them weighted

    and another non-weighted*/

    if(ps_curr_inp->s_lap_out.i4_pic_type == IV_P_FRAME)

    {

        if(num_ref_pics_list0 > 2)

        {

            if(aps_pre_enc_ref_pic_list[LIST_0][0]->i4_poc ==

               aps_pre_enc_ref_pic_list[LIST_0][1]->i4_poc)

            {

                i4_inc_L0_active_ref_pic = 1;

            }

        }

    }

    else

    {

        if(num_ref_pics_list0 >= 2 && num_ref_pics_list1 >= 2)

        {

            if(aps_pre_enc_ref_pic_list[LIST_0][0]->i4_poc ==

               aps_pre_enc_ref_pic_list[LIST_0][1]->i4_poc)

            {

                i4_inc_L0_active_ref_pic = 1;

            }

            if(aps_pre_enc_ref_pic_list[LIST_1][0]->i4_poc ==

               aps_pre_enc_ref_pic_list[LIST_1][1]->i4_poc)

            {

                i4_inc_L1_active_ref_pic = 1;

            }

        }

    }

    /* append the reference pics in List1 and end of list0 */

    for(ctr = 0; ctr < num_ref_pics_list1; ctr++)

    {

        aps_pre_enc_ref_pic_list[LIST_0][num_ref_pics_list0 + ctr] =

            aps_pre_enc_ref_pic_list[LIST_1][ctr];

    }

    /* append the reference pics in List0 and end of list1 */

    for(ctr = 0; ctr < num_ref_pics_list0; ctr++)

    {

        aps_pre_enc_ref_pic_list[LIST_1][num_ref_pics_list1 + ctr] =

            aps_pre_enc_ref_pic_list[LIST_0][ctr];

    }

    /* reference list modification for adding duplicate reference */

    {

    }

    /* popluate the default weights and offsets for disabled cases */

    {

        WORD32 i;

        /* populate the weights and offsets for all pics in L0 + L1 */

        for(i = 0; i < (num_ref_pics_list0 + num_ref_pics_list1); i++)

        {

            /* populate the weights and offsets if weighted prediction is disabled */

            if(1 == wp_flag)

            {

                /* if weights are disabled then populate default values */

                if(0 ==

                   aps_pre_enc_ref_pic_list[LIST_0][i]->s_weight_offset.u1_luma_weight_enable_flag)

                {

                    /* set to default values */

                    aps_pre_enc_ref_pic_list[LIST_0][i]->s_weight_offset.i2_luma_weight =

                        (1 << ps_curr_inp->s_lap_out.i4_log2_luma_wght_denom);

                    aps_pre_enc_ref_pic_list[LIST_0][i]->s_weight_offset.i2_luma_offset = 0;

                }

            }

        }

        for(i = 0; i < (num_ref_pics_list0 + num_ref_pics_list1); i++)

        {

            /* populate the weights and offsets if weighted prediction is enabled */

            if(1 == wp_flag)

            {

                /* if weights are disabled then populate default values */

                if(0 ==

                   aps_pre_enc_ref_pic_list[LIST_1][i]->s_weight_offset.u1_luma_weight_enable_flag)

                {

                    /* set to default values */

                    aps_pre_enc_ref_pic_list[LIST_1][i]->s_weight_offset.i2_luma_weight =

                        (1 << ps_curr_inp->s_lap_out.i4_log2_luma_wght_denom);

                    aps_pre_enc_ref_pic_list[LIST_1][i]->s_weight_offset.i2_luma_offset = 0;

                }

            }

        }

    }

    /* run a loop to free the non used reference pics */

    for(ctr = 0; ctr < ps_enc_ctxt->i4_pre_enc_num_buf_recon_q; ctr++)

    {

        /* if not used as reference */

        if(0 == ai4_buf_status[ctr])

        {

            ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr]->i4_is_free = 1;

            ps_enc_ctxt->pps_pre_enc_recon_buf_q[ctr]->i4_poc = -1;

        }

    }

    /* store the number of reference pics in the list for ME/MC etc */

    ps_enc_ctxt->i4_pre_enc_num_ref_l0 = num_ref_pics_list0;

    ps_enc_ctxt->i4_pre_enc_num_ref_l1 = num_ref_pics_list1;

#define HME_USE_ONLY_2REF

#ifndef HME_USE_ONLY_2REF

    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active = num_ref_pics_list0;

    ps_enc_ctxt->i4_pre_enc_num_ref_l1_active = num_ref_pics_list1;

#else

#if MULTI_REF_ENABLE == 1

    if(ps_curr_inp->s_lap_out.i4_quality_preset >= IHEVCE_QUALITY_P3)

    {

        if(ps_curr_inp->s_lap_out.i4_pic_type == IV_P_FRAME)

        {

            if(IHEVCE_QUALITY_P6 == ps_curr_inp->s_lap_out.i4_quality_preset)

            {

                if(1 == ps_enc_ctxt->s_runtime_src_prms.i4_field_pic)

                {

                    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active =

                        MIN(MAX_NUM_REFS_IN_PPICS_IN_XS25 + 1, num_ref_pics_list0);

                }

                else

                {

                    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active =

                        MIN(MAX_NUM_REFS_IN_PPICS_IN_XS25, num_ref_pics_list0);

                    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active += i4_inc_L0_active_ref_pic;

                }

                ps_enc_ctxt->i4_pre_enc_num_ref_l1_active = 0;

            }

            else

            {

                if(1 == ps_enc_ctxt->s_runtime_src_prms.i4_field_pic)

                {

                    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active = MIN(3, num_ref_pics_list0);

                }

                else

                {

                    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active = MIN(2, num_ref_pics_list0);

                    ps_enc_ctxt->i4_pre_enc_num_ref_l0_active += i4_inc_L0_active_ref_pic;

                }

                ps_enc_ctxt->i4_pre_enc_num_ref_l1_active = 0;

            }

        }

        else

        {

            if(1 == ps_enc_ctxt->s_runtime_src_prms.i4_field_pic)

            {

                ps_enc_ctxt->i4_pre_enc_num_ref_l0_active = MIN(2, num_ref_pics_list0);

                ps_enc_ctxt->i4_pre_enc_num_ref_l1_active = MIN(1, num_ref_pics_list1);

                ps_enc_ctxt->i4_pre_enc_num_ref_l1_active += i4_inc_L1_active_ref_pic;

            }

            else

            {

                ps_enc_ctxt->i4_pre_enc_num_ref_l0_active = MIN(1, num_ref_pics_list0);

                ps_enc_ctxt->i4_pre_enc_num_ref_l1_active = MIN(1, num_ref_pics_list1);

                ps_enc_ctxt->i4_pre_enc_num_ref_l1_active += i4_inc_L1_active_ref_pic;

                ps_enc_ctxt->i4_pre_enc_num_ref_l0_active += i4_inc_L0_active_ref_pic;

            }

        }

    }

    else

    {

        if(ps_curr_inp->s_lap_out.i4_pic_type == IV_P_FRAME)