xref: /aosp_15_r20/external/libhevc/encoder/ihevce_lap_interface.c (revision c83a76b084498d55f252f48b2e3786804cdf24b7)

/******************************************************************************
 *
 * 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_lap_interface.c
*
* @brief
*  This file contains function definitions related to look-ahead processing
*
* @author
*  ittiam
*
* @par List of Functions:
*
******************************************************************************
*/

/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/

/* System Include Files */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.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_macros.h"
#include "ihevc_debug.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 "ihevce_defs.h"
#include "ihevce_api.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_lap_structs.h"
#include "ihevce_multi_thrd_structs.h"
#include "ihevce_function_selector.h"
#include "ihevce_me_common_defs.h"
#include "ihevce_enc_structs.h"
#include "ihevce_rc_enc_structs.h"
#include "ihevce_rc_interface.h"
#include "ihevce_buffer_que_interface.h"

/*****************************************************************************/
/* Globals                                                                   */
/*****************************************************************************/
WORD32 gau1_order_insert_pic_type[MAX_TEMPORAL_LAYERS][8] = {
    { P_PIC, B_PIC, P_PIC, B_PIC, P_PIC, B_PIC, P_PIC, B_PIC },
    { P_PIC, B_PIC, B1_PIC, B1_PIC, P_PIC, B_PIC, B1_PIC, B1_PIC },
    { P_PIC, B_PIC, B1_PIC, B2_PIC, B2_PIC, B1_PIC, B2_PIC, B2_PIC },
};

UWORD8 gau1_use_by_cur_pic_flag[MAX_REF_PICS] = { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/*!
************************************************************************
* \brief
*    return number of records used by LAP
*
************************************************************************
*/
WORD32 ihevce_lap_get_num_mem_recs(void)
{
    return (NUM_LAP_MEM_RECS);
}

/*!
************************************************************************
* @brief
*    return each record attributes of LAP
************************************************************************
*/
WORD32 ihevce_lap_get_mem_recs(iv_mem_rec_t *ps_mem_tab, WORD32 i4_mem_space)
{
    /* number of NODE memory */
    WORD32 max_nodes = MAX_SUB_GOP_SIZE - 1;

    ps_mem_tab[LAP_CTXT].i4_mem_size = sizeof(lap_struct_t);
    ps_mem_tab[LAP_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
    ps_mem_tab[LAP_CTXT].i4_mem_alignment = 8;

    /* Node memory for 2 sub-gops*/
    ps_mem_tab[LAP_NODE_MEM].i4_mem_size = (max_nodes * sizeof(ihevce_encode_node_t));

    ps_mem_tab[LAP_NODE_MEM].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;

    ps_mem_tab[LAP_NODE_MEM].i4_mem_alignment = 8;

    return (NUM_LAP_MEM_RECS);
}

/*!
************************************************************************
* @brief
*    Init LAP structure
************************************************************************
*/
void *ihevce_lap_init(
    iv_mem_rec_t *ps_mem_tab,
    ihevce_lap_static_params_t *ps_lap_params,
    ihevce_static_cfg_params_t *ps_static_cfg_prms)
{
    WORD32 i4_src_interlace_field;
    WORD32 i4_max_temporal_layers;
    ihevce_encode_node_t *ps_encode_node_struct;
    lap_struct_t *ps_lap_struct = (lap_struct_t *)ps_mem_tab[LAP_CTXT].pv_base;
    ihevce_lap_static_params_t *ps_lap_static_params = &ps_lap_struct->s_lap_static_params;
    ps_lap_struct->aps_encode_node[0] = (ihevce_encode_node_t *)ps_mem_tab[LAP_NODE_MEM].pv_base;

    memcpy(
        &ps_lap_struct->s_static_cfg_params,
        ps_static_cfg_prms,
        sizeof(ihevce_static_cfg_params_t));
    memmove(ps_lap_static_params, ps_lap_params, sizeof(ihevce_lap_static_params_t));
    ps_lap_static_params->e_arch_type = ps_static_cfg_prms->e_arch_type;

    /* Set the array to zero */
    memset(&ps_lap_struct->ai4_capture_order_poc[0], 0, MAX_NUM_ENC_NODES * sizeof(WORD32));
    memset(&ps_lap_struct->ai4_encode_order_poc[0], 0, MAX_NUM_ENC_NODES * sizeof(WORD32));
    memset(&ps_lap_struct->ref_poc_array[0], 0xFF, sizeof(ps_lap_struct->ref_poc_array));
    memset(&ps_lap_struct->ai4_pic_type_to_be_removed, 0, NUM_LAP2_LOOK_AHEAD * sizeof(WORD32));
    memset(&ps_lap_struct->ai4_num_buffer[0], 0, sizeof(ps_lap_struct->ai4_num_buffer));

    ps_lap_struct->i4_curr_poc = 0;
    ps_lap_struct->i4_cra_poc = 0;

    i4_max_temporal_layers = ps_lap_static_params->i4_max_temporal_layers;
    i4_src_interlace_field = ps_lap_static_params->i4_src_interlace_field;
    ps_lap_struct->i4_max_idr_period =
        ps_static_cfg_prms->s_coding_tools_prms.i4_max_closed_gop_period;
    ps_lap_struct->i4_min_idr_period =
        ps_static_cfg_prms->s_coding_tools_prms.i4_min_closed_gop_period;
    ps_lap_struct->i4_max_cra_period =
        ps_static_cfg_prms->s_coding_tools_prms.i4_max_cra_open_gop_period;
    ps_lap_struct->i4_max_i_period =
        ps_static_cfg_prms->s_coding_tools_prms.i4_max_i_open_gop_period;
    ps_lap_struct->i4_idr_counter = 0;
    ps_lap_struct->i4_cra_counter = 0;
    ps_lap_struct->i4_i_counter = 0;
    ps_lap_struct->i4_idr_gop_num = -1;
    ps_lap_struct->i4_curr_ref_pics = 0;
    ps_lap_struct->i4_display_num = 0;
    ps_lap_struct->i4_num_frm_type_decided = 0;
    ps_lap_struct->i4_next_start_ctr = 0;
    ps_lap_struct->ai1_pic_type[0] = PIC_TYPE_IDR;

    ps_lap_struct->i4_enable_logo = ps_lap_static_params->i4_enable_logo;
    ps_lap_struct->i4_cra_i_pic_flag = 0;
    ps_lap_struct->i4_force_end_flag = 0;
    ps_lap_struct->i4_sub_gop_size = (1 << i4_max_temporal_layers);
    ps_lap_struct->i4_sub_gop_size_idr =
        ps_lap_struct->i4_sub_gop_size + (i4_max_temporal_layers > 0);

    ps_lap_struct->i4_is_all_i_pic_in_seq = 0;

    if(ps_lap_struct->i4_max_idr_period == 1 || ps_lap_struct->i4_max_cra_period == 1 ||
       ps_lap_struct->i4_max_i_period == 1)
    {
        ps_lap_struct->i4_is_all_i_pic_in_seq = 1;
    }

    if(1 == i4_src_interlace_field && (!ps_lap_struct->i4_is_all_i_pic_in_seq))
    {
        ps_lap_struct->i4_sub_gop_size <<= 1;
        ps_lap_struct->i4_sub_gop_size_idr <<= 1;
    }

    ps_lap_struct->i4_fixed_open_gop_period = 1;
    ps_lap_struct->i4_fixed_i_period = 1;

    if(ps_static_cfg_prms->s_coding_tools_prms.i4_max_closed_gop_period <=
       ps_lap_struct->i4_sub_gop_size)
    {
        ps_lap_struct->i4_min_idr_period =
            ps_static_cfg_prms->s_coding_tools_prms.i4_max_closed_gop_period;
    }
    if(ps_lap_struct->i4_max_idr_period)
    {
        if(ps_lap_struct->i4_max_cra_period)
        {
            ps_lap_struct->i4_gop_period = ps_lap_struct->i4_max_cra_period;
        }
        else if(ps_lap_struct->i4_max_i_period)
        {
            ps_lap_struct->i4_gop_period = ps_lap_struct->i4_max_i_period;
        }
        else
        {
            ps_lap_struct->i4_gop_period = ps_lap_struct->i4_max_idr_period;
        }
    }
    else
    {
        if(ps_lap_struct->i4_max_i_period)
        {
            ps_lap_struct->i4_gop_period = ps_lap_struct->i4_max_i_period;
        }
        else if(ps_lap_struct->i4_max_cra_period)
        {
            ps_lap_struct->i4_gop_period = ps_lap_struct->i4_max_cra_period;
        }
    }

    if(!ps_lap_struct->i4_max_i_period)
    {
        ps_lap_struct->i4_max_i_period =
            2 * MAX(ps_lap_struct->i4_max_idr_period, ps_lap_struct->i4_max_cra_period);
    }

    ps_lap_struct->i4_no_back_to_back_i_avoidance = 0;

    /*Infinite GOP case*/
    if(!ps_lap_struct->i4_gop_period)
    {
        /*max signed 32 bit value which will be ~ 414 days considering 60frames/fields per second*/
        ps_lap_struct->i4_max_i_period = 0x7fffffff;
        ps_lap_struct->i4_gop_period =
            (INFINITE_GOP_CDR_TIME_S * (ps_static_cfg_prms->s_src_prms.i4_frm_rate_num /
                                        ps_static_cfg_prms->s_src_prms.i4_frm_rate_denom));
    }

    if(ps_lap_struct->i4_gop_period < (2 * ps_lap_struct->i4_sub_gop_size))
    {
        ps_lap_struct->i4_no_back_to_back_i_avoidance = 1;
    }

    ps_lap_struct->i4_rc_lap_period =
        ps_static_cfg_prms->s_lap_prms.i4_rc_look_ahead_pics + MIN_L1_L0_STAGGER_NON_SEQ;
    ps_lap_struct->pv_prev_inp_buf = NULL;
    ps_lap_struct->i4_buf_deq_idx = 0;
    ps_lap_struct->i4_deq_idx = 0;
    ps_lap_struct->i4_enq_idx = 0;
    ps_lap_struct->i4_lap2_counter = 0;
    ps_lap_struct->i4_dyn_sub_gop_size = ps_lap_struct->i4_sub_gop_size;
    ps_lap_struct->i4_buf_enq_idx = 0;
    ps_lap_struct->i4_lap_out_idx = 0;
    ps_lap_struct->i4_capture_idx = 0;
    ps_lap_struct->i4_idr_flag = 1;
    ps_lap_struct->i4_num_bufs_encode_order = 0;
    ps_lap_struct->end_flag = 0;
    ps_lap_struct->i4_immediate_idr_case = 0;
    ps_lap_struct->i4_max_buf_in_enc_order = 0;
    ps_lap_struct->i4_end_flag_pic_idx = 0;
    memset(
        &ps_lap_struct->api4_encode_order_array[0],
        0,
        sizeof(ihevce_lap_enc_buf_t *) * MAX_NUM_ENC_NODES);
    ps_lap_struct->i4_sub_gop_pic_idx = 0;
    ps_lap_struct->i4_force_idr_pos = 0;
    ps_lap_struct->i4_num_dummy_pic = 0;
    ps_lap_struct->i4_lap_encode_idx = 0;
    ps_lap_struct->i4_deq_lap_buf = 0;
    ps_lap_struct->i4_sub_gop_end = 0;

    {
        WORD32 node_offset, curr_layer;
        WORD32 i;
        /*intialization of aps_lap_inp_buf*/
        for(i = 0; i < MAX_QUEUE_LENGTH; i++)
        {
            ps_lap_struct->aps_lap_inp_buf[i] = NULL;
        }

        /* init capture order and encode order pointer */
        ps_lap_struct->pi4_capture_poc_ptr = &ps_lap_struct->ai4_capture_order_poc[0];
        ps_lap_struct->pi4_encode_poc_ptr = &ps_lap_struct->ai4_encode_order_poc[0];

        /* init all the buffer status to default values */
        ps_encode_node_struct = ps_lap_struct->aps_encode_node[0];

        ps_encode_node_struct->pv_left_node = NULL;
        ps_encode_node_struct->pv_right_node = NULL;

        /* Initialise the tree */
        node_offset = 1;
        curr_layer = 0;
        ihevce_populate_tree_nodes(
            ps_encode_node_struct,
            ps_encode_node_struct,
            &node_offset,
            curr_layer,
            ps_lap_static_params->i4_max_temporal_layers);
    }

    ps_mem_tab += NUM_LAP_MEM_RECS;

    return ((void *)ps_lap_struct);
}

/*!
******************************************************************************
* \if Function name : ihevce_populate_tree_nodes \endif
*
* \brief
*    LAP populate nodes function
*
* \param[in] encode_parent_node_t node pointer to base
*            encode_node_t        node pointer to current buffer
*            loop_count                layer count
*            hier_layer           total layers
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_populate_tree_nodes(
    ihevce_encode_node_t *encode_parent_node_t,
    ihevce_encode_node_t *encode_node_t,
    WORD32 *loop_count,
    WORD32 layer,
    WORD32 hier_layer)
{
    /* If only I/P pictures, return NULL from the child nodes*/
    if(hier_layer == 0)
    {
        encode_node_t->pv_left_node = NULL;
        encode_node_t->pv_right_node = NULL;
        return;
    }
    if(layer == hier_layer)
        return;

    layer = layer + 1;

    /* If the layers are not exhausted */
    if(layer < hier_layer)
    {
        encode_node_t->pv_left_node = encode_parent_node_t + (*loop_count);
        encode_node_t->pv_right_node = encode_parent_node_t + (*loop_count + 1);
        (*loop_count) = (*loop_count) + 2;
    }
    else
    {
        encode_node_t->pv_left_node = NULL;
        encode_node_t->pv_right_node = NULL;
    }

    /* Populate Left tree nodes */
    ihevce_populate_tree_nodes(
        encode_parent_node_t,
        (ihevce_encode_node_t *)encode_node_t->pv_left_node,
        loop_count,
        layer,
        hier_layer);

    /* Populate right tree nodes */
    ihevce_populate_tree_nodes(
        encode_parent_node_t,
        (ihevce_encode_node_t *)encode_node_t->pv_right_node,
        loop_count,
        layer,
        hier_layer);
}

/*!
************************************************************************
* \brief
*    pad input when its dimensions are not aligned to LCU size
************************************************************************
*/
void ihevce_lap_pad_input_bufs(
    ihevce_lap_enc_buf_t *ps_curr_inp, WORD32 align_pic_wd, WORD32 align_pic_ht)
{
    /* local variables */
    WORD32 ctr_horz, ctr_vert;

    /* ------- Horizontal Right Padding ------ */
    if(align_pic_wd != ps_curr_inp->s_lap_out.s_input_buf.i4_y_wd)
    {
        UWORD8 *pu1_inp;
        UWORD16 *pu2_inp;
        WORD32 pad_wd;
        WORD32 pad_ht;

        /* ------------- LUMA ----------------------------- */
        /* derive the pointers and dimensions to be padded */
        pad_ht = ps_curr_inp->s_lap_out.s_input_buf.i4_y_ht;
        pad_wd = align_pic_wd - ps_curr_inp->s_lap_out.s_input_buf.i4_y_wd;
        pu1_inp = (UWORD8 *)ps_curr_inp->s_lap_out.s_input_buf.pv_y_buf;
        pu1_inp += ps_curr_inp->s_lap_out.s_input_buf.i4_y_wd;

        /* loops for padding the right region for entire pic */
        for(ctr_vert = 0; ctr_vert < pad_ht; ctr_vert++)
        {
            for(ctr_horz = 0; ctr_horz < pad_wd; ctr_horz++)
            {
                /* last pixel is replicated */
                pu1_inp[ctr_horz] = pu1_inp[-1];
            }

            /* row level increments */
            pu1_inp += ps_curr_inp->s_lap_out.s_input_buf.i4_y_strd;
        }

        /* ------------- CHROMA ---------------------------- */
        /* derive the pointers and dimensions to be padded */
        pad_ht = ps_curr_inp->s_lap_out.s_input_buf.i4_uv_ht;
        pad_wd = align_pic_wd - ps_curr_inp->s_lap_out.s_input_buf.i4_uv_wd;
        pad_wd >>= 1;
        pu1_inp = (UWORD8 *)ps_curr_inp->s_lap_out.s_input_buf.pv_u_buf;
        pu2_inp = (UWORD16 *)(pu1_inp + ps_curr_inp->s_lap_out.s_input_buf.i4_uv_wd);

        /* loops for padding the right region for entire pic */
        for(ctr_vert = 0; ctr_vert < pad_ht; ctr_vert++)
        {
            for(ctr_horz = 0; ctr_horz < pad_wd; ctr_horz++)
            {
                /* last pixel is replicated, cb and cr pixel interleaved */
                pu2_inp[ctr_horz] = pu2_inp[-1];
            }

            /* row level increments */
            pu2_inp += (ps_curr_inp->s_lap_out.s_input_buf.i4_uv_strd >> 1);
        }
    }

    /* ------- Vertical Bottom Padding ------ */
    if(align_pic_ht != ps_curr_inp->s_lap_out.s_input_buf.i4_y_ht)
    {
        UWORD8 *pu1_inp, *pu1_src;
        WORD32 pad_ht;

        /* ------------- LUMA ----------------------------- */
        /* derive the pointers and dimensions to be padded */
        pad_ht = align_pic_ht - ps_curr_inp->s_lap_out.s_input_buf.i4_y_ht;
        pu1_inp = (UWORD8 *)ps_curr_inp->s_lap_out.s_input_buf.pv_y_buf;
        pu1_inp += ps_curr_inp->s_lap_out.s_input_buf.i4_y_ht *
                   ps_curr_inp->s_lap_out.s_input_buf.i4_y_strd;

        /* get the pointer of last row */
        pu1_src = pu1_inp - ps_curr_inp->s_lap_out.s_input_buf.i4_y_strd;

        /* loops for padding the bottom region for entire row */
        for(ctr_vert = 0; ctr_vert < pad_ht; ctr_vert++)
        {
            /* copy the eniter orw including horz padd region */
            memcpy(pu1_inp, pu1_src, align_pic_wd);

            /* row level increments */
            pu1_inp += ps_curr_inp->s_lap_out.s_input_buf.i4_y_strd;
        }

        /* ------------- CHROMA ----------------------------- */
        /* derive the pointers and dimensions to be padded */
        pad_ht = (align_pic_ht >> 1) - ps_curr_inp->s_lap_out.s_input_buf.i4_uv_ht;
        pu1_inp = (UWORD8 *)ps_curr_inp->s_lap_out.s_input_buf.pv_u_buf;
        pu1_inp += ps_curr_inp->s_lap_out.s_input_buf.i4_uv_ht *
                   ps_curr_inp->s_lap_out.s_input_buf.i4_uv_strd;

        /* get the pointer of last row */
        pu1_src = pu1_inp - ps_curr_inp->s_lap_out.s_input_buf.i4_uv_strd;

        /* loops for padding the bottom region for entire row */
        for(ctr_vert = 0; ctr_vert < pad_ht; ctr_vert++)
        {
            /* copy the eniter orw including horz padd region */
            memcpy(pu1_inp, pu1_src, align_pic_wd);

            /* row level increments */
            pu1_inp += ps_curr_inp->s_lap_out.s_input_buf.i4_uv_strd;
        }
    }
    return;
}

/*!
************************************************************************
* \brief
*    check for last inp buf
************************************************************************
*/
WORD32 ihevce_check_last_inp_buf(WORD32 *pi4_cmd_buf)
{
    WORD32 cmd = (*pi4_cmd_buf) & (IHEVCE_COMMANDS_TAG_MASK);

    if(IHEVCE_SYNCH_API_FLUSH_TAG == cmd)
        return 1;
    return 0;
}

/*!
************************************************************************
* \brief
*    lap parse sync commands
************************************************************************
*/
void ihevce_lap_parse_sync_cmd(
    ihevce_hle_ctxt_t *ps_hle_ctxt,
    ihevce_static_cfg_params_t *ps_static_cfg_prms,
    WORD32 *pi4_cmd_buf,
    ihevce_lap_enc_buf_t *ps_lap_inp_buf,
    WORD32 *pi4_flush_check,
    WORD32 *pi4_force_idr_check)
{
    WORD32 *pi4_tag_parse = pi4_cmd_buf;
    WORD32 i4_cmd_size = ps_lap_inp_buf->s_input_buf.i4_cmd_buf_size;
    WORD32 i4_buf_id = ps_lap_inp_buf->s_input_buf.i4_buf_id;
#ifndef DISABLE_SEI
    UWORD32 u4_num_sei = 0;
#endif
    WORD32 i4_end_flag = 0;

    while(i4_cmd_size >= 4)
    {
        switch((*pi4_tag_parse) & (IHEVCE_COMMANDS_TAG_MASK))
        {
        case IHEVCE_SYNCH_API_FLUSH_TAG:
            if(i4_cmd_size < 8 || pi4_tag_parse[1])
            {
                ps_hle_ctxt->ihevce_cmds_error_report(
                    ps_hle_ctxt->pv_cmd_err_cb_handle,
                    IHEVCE_SYNCH_ERR_LENGTH_NOT_ZERO,
                    1,
                    i4_buf_id);
                return;
            }
            (*pi4_flush_check) = 1;
            pi4_tag_parse += 2;
            i4_cmd_size -= 8;
#ifndef DISABLE_SEI
            u4_num_sei++;
#endif
            break;
        case IHEVCE_SYNCH_API_FORCE_IDR_TAG:
            if(i4_cmd_size < 8 || pi4_tag_parse[1])
            {
                ps_hle_ctxt->ihevce_cmds_error_report(
                    ps_hle_ctxt->pv_cmd_err_cb_handle,
                    IHEVCE_SYNCH_ERR_LENGTH_NOT_ZERO,
                    1,
                    i4_buf_id);
                return;
            }
            (*pi4_force_idr_check) = 1;
            pi4_tag_parse += 2;
            i4_cmd_size -= 8;
#ifndef DISABLE_SEI
            u4_num_sei++;
#endif
            break;
        case IHEVCE_SYNCH_API_END_TAG:
            i4_end_flag = 1;
            i4_cmd_size -= 4;
            break;
        default:
            ps_hle_ctxt->ihevce_cmds_error_report(
                ps_hle_ctxt->pv_cmd_err_cb_handle, IHEVCE_SYNCH_ERR_TLV_ERROR, 1, i4_buf_id);
            i4_end_flag = 1;
        }
        if(i4_end_flag)
            break;
    }
#ifndef DISABLE_SEI
    if(u4_num_sei > MAX_NUMBER_OF_SEI_PAYLOAD)  //Checking for max number of SEI messages.
        ps_hle_ctxt->ihevce_cmds_error_report(
            ps_hle_ctxt->pv_cmd_err_cb_handle, IHEVCE_SYNCH_ERR_TOO_MANY_SEI_MSG, 1, i4_buf_id);
#endif

    if(!i4_end_flag)
        ps_hle_ctxt->ihevce_cmds_error_report(
            ps_hle_ctxt->pv_cmd_err_cb_handle, IHEVCE_SYNCH_ERR_NO_END_TAG, 1, i4_buf_id);
}

/*!
************************************************************************
* \brief
*    lap parse Async commands
************************************************************************
*/
void ihevce_lap_parse_async_cmd(
    ihevce_hle_ctxt_t *ps_hle_ctxt,
    WORD32 *pi4_cmd_buf,
    WORD32 i4_length,
    WORD32 i4_buf_id,
    WORD32 *pi4_num_set_bitrate_cmds,
    ihevce_dyn_config_prms_t *ps_dyn_br)
{
    WORD32 i4_end_flag = 0;
    WORD32 *pi4_tag_parse = pi4_cmd_buf;

    while(i4_length >= 4)
    {
        switch(*pi4_tag_parse)
        {
        case IHEVCE_ASYNCH_API_SETBITRATE_TAG:
            if(i4_length < (8 + sizeof(ihevce_dyn_config_prms_t)) ||
               pi4_tag_parse[1] != sizeof(ihevce_dyn_config_prms_t))
            {
                ps_hle_ctxt->ihevce_cmds_error_report(
                    ps_hle_ctxt->pv_cmd_err_cb_handle, IHEVCE_ASYNCH_ERR_BR_NOT_BYTE, 1, i4_buf_id);
                return;
            }
            memcpy(
                (void *)ps_dyn_br, (void *)(pi4_tag_parse + 2), sizeof(ihevce_dyn_config_prms_t));
            pi4_tag_parse += (2 + (sizeof(ihevce_dyn_config_prms_t) >> 2));
            i4_length -= (8 + sizeof(ihevce_dyn_config_prms_t));
            *pi4_num_set_bitrate_cmds += 1;
            ps_dyn_br++;
            break;
        case IHEVCE_ASYNCH_API_END_TAG:
            i4_end_flag = 1;
            i4_length -= 4;
            break;
        default:
            ps_hle_ctxt->ihevce_cmds_error_report(
                ps_hle_ctxt->pv_cmd_err_cb_handle, IHEVCE_ASYNCH_ERR_TLV_ERROR, 1, i4_buf_id);
            i4_end_flag = 1;
        }
        if(i4_end_flag)
            break;
    }
    if(!i4_end_flag)
        ps_hle_ctxt->ihevce_cmds_error_report(
            ps_hle_ctxt->pv_cmd_err_cb_handle, IHEVCE_ASYNCH_ERR_NO_END_TAG, 1, i4_buf_id);
}

/*!
************************************************************************
* \brief
*    ref pics weight offset calculation
************************************************************************
*/
void ref_pics_weight_offset_calc(ihevce_lap_output_params_t *ps_lap_out, lap_struct_t *ps_lap_struct)
{
    WORD32 i, j;
    WORD32 *ref_poc_array = ps_lap_struct->ref_poc_array;
    WORD32 ai4_delta_poc[MAX_REF_PICS];
    WORD32 ref_poc_arr_sort[MAX_REF_PICS];

    /* Default weighted pred parameters populated for  now */
    ps_lap_out->i4_log2_luma_wght_denom = DENOM_DEFAULT;
    ps_lap_out->i4_log2_chroma_wght_denom = DENOM_DEFAULT;

    /* sort the ref_poc_array based on delta as
     * in case weighted pred dup pics are inserted and it should consider
     * the neighbors first for prediction than farthest */
    for(i = 0; i < ps_lap_struct->i4_curr_ref_pics; i++)
    {
        ai4_delta_poc[i] = ref_poc_array[i] - ps_lap_out->i4_poc;
    }

    for(i = 0; i < ps_lap_struct->i4_curr_ref_pics; i++)
    {
        WORD32 i4_min, temp;
        i4_min = i;
        for(j = i; j < ps_lap_struct->i4_curr_ref_pics; j++)
        {
            if(abs(ai4_delta_poc[j]) <= abs(ai4_delta_poc[i4_min]))
            {
                i4_min = j;
            }
        }
        temp = ai4_delta_poc[i];
        ai4_delta_poc[i] = ai4_delta_poc[i4_min];
        ai4_delta_poc[i4_min] = temp;
        ref_poc_arr_sort[i] = ai4_delta_poc[i] + ps_lap_out->i4_poc;
    }

    for(i = 0; i < ps_lap_struct->i4_curr_ref_pics; i++)
    {
        ps_lap_out->as_ref_pics[i].i4_ref_pic_delta_poc = ref_poc_arr_sort[i] - ps_lap_out->i4_poc;
        ASSERT(ps_lap_out->as_ref_pics[i].i4_ref_pic_delta_poc);

        /* Enable flag for the reference pics to be used by curr pic */
        ps_lap_out->as_ref_pics[i].i4_used_by_cur_pic_flag = gau1_use_by_cur_pic_flag[i];

        /* Currently no weighted prediction offset added */
        ps_lap_out->as_ref_pics[i].i4_num_duplicate_entries_in_ref_list = 1;
    }
    return;
}

/*!
************************************************************************
* \brief
*    ref b picture population
************************************************************************
*/
void ref_b_pic_population(
    WORD32 curr_layer, ihevce_lap_enc_buf_t *ps_lap_inp, lap_struct_t *ps_lap_struct)
{
    ihevce_lap_output_params_t *ps_lap_out = &ps_lap_inp->s_lap_out;
    WORD32 *ref_poc_array = ps_lap_struct->ref_poc_array;
    WORD32 *p_ref_poc_array = ref_poc_array;
    WORD32 i4_interlace_field = ps_lap_struct->s_lap_static_params.i4_src_interlace_field;
    WORD32 i4_max_ref_pics = ps_lap_struct->s_lap_static_params.i4_max_reference_frames;
    WORD32 max_temporal_layers = ps_lap_struct->s_lap_static_params.i4_max_temporal_layers;

    /* LAP output structure */
    ps_lap_out->i4_poc = ps_lap_struct->pi4_encode_poc_ptr[0];
    ps_lap_out->i4_idr_gop_num = ps_lap_struct->i4_idr_gop_num;
    ps_lap_out->i4_assoc_IRAP_poc = ps_lap_struct->i4_assoc_IRAP_poc;
    ps_lap_out->i4_temporal_lyr_id = curr_layer;
    ps_lap_out->i4_pic_type = IV_B_FRAME;

    if((ps_lap_out->i4_poc > ps_lap_struct->i4_cra_poc) &&
       (ref_poc_array[0] < ps_lap_struct->i4_cra_poc) && ps_lap_struct->i4_cra_i_pic_flag)
    {
        ref_poc_array[0] = ps_lap_struct->i4_cra_poc;
        ps_lap_struct->i4_curr_ref_pics = 1;
    }

    ps_lap_out->i4_num_ref_pics = ps_lap_struct->i4_curr_ref_pics;

    /* Default: Cur pic is ref pic*/
    ps_lap_out->i4_is_ref_pic = 1;

    if(1 == i4_interlace_field)
    {
        WORD32 i4_bottom_field = ps_lap_inp->s_input_buf.i4_bottom_field;
        WORD32 first_field = (ps_lap_inp->s_input_buf.i4_topfield_first ^ i4_bottom_field);

        /*If current pic is top field B picture and is present in top hierarchical layer */
        /* Dereference the curr pic */
        if(ps_lap_out->i4_temporal_lyr_id == max_temporal_layers)
        {
            if(0 == first_field)
                ps_lap_out->i4_is_ref_pic = 0;
            else
                ps_lap_out->i4_is_ref_pic = 2;
        }
    }
    else
    {
        /*If progressive B picture and is present in top hierarchical layer */
        if(ps_lap_out->i4_temporal_lyr_id >= max_temporal_layers)
        {
            ps_lap_out->i4_temporal_lyr_id = max_temporal_layers;
            ps_lap_out->i4_is_ref_pic = 0;
        }
    }

    ref_pics_weight_offset_calc(ps_lap_out, ps_lap_struct);

    /* Updating number of current reference Pictures for the Given Picture */
    /* If the current frame is n-layer B frame, donot increment*/
    if(ps_lap_struct->i4_curr_ref_pics < i4_max_ref_pics)
    {
        if(ps_lap_out->i4_is_ref_pic)
        {
            ps_lap_struct->i4_curr_ref_pics++;
        }
    }

    /* Arrange the reference array in ascending order */
    {
        WORD32 i, j, temp;
        for(i = 0; i < (ps_lap_struct->i4_curr_ref_pics - 1); i++)
        {
            for(j = i + 1; j < ps_lap_struct->i4_curr_ref_pics; j++)
            {
                if(ref_poc_array[i] > ref_poc_array[j])
                {
                    temp = ref_poc_array[i];
                    ref_poc_array[i] = ref_poc_array[j];
                    ref_poc_array[j] = temp;
                }
            }
        }
    }

    {
        WORD32 ref = ps_lap_out->i4_poc;
        if(ps_lap_out->i4_is_ref_pic && ref > *p_ref_poc_array)
        {
            *p_ref_poc_array = ref;
        }
    }

    return;
}

/*!
************************************************************************
* \brief
*    ref i/p pic population
************************************************************************
*/
void ref_pic_population(ihevce_lap_enc_buf_t *ps_lap_inp, lap_struct_t *ps_lap_struct)
{
    ihevce_lap_output_params_t *ps_lap_out = &ps_lap_inp->s_lap_out;
    WORD32 *ref_poc_array = ps_lap_struct->ref_poc_array;
    WORD32 *p_ref_poc_array = ref_poc_array;
    WORD32 i4_max_ref_pics = ps_lap_struct->s_lap_static_params.i4_max_reference_frames;

    /* Update the POC position */
    ps_lap_out->i4_poc = ps_lap_struct->pi4_encode_poc_ptr[0];

    /* picture after CRA can't refer pic before CRA*/
    if((ps_lap_out->i4_poc > ps_lap_struct->i4_cra_poc) &&
       (ref_poc_array[0] <= ps_lap_struct->i4_cra_poc) && ps_lap_struct->i4_cra_i_pic_flag)
    {
        ref_poc_array[0] = ps_lap_struct->i4_cra_poc;
        ps_lap_struct->i4_curr_ref_pics = 1;
    }

    /* For every IDR period, set pic type as IDR frame and reset reference POC array to 0*/
    if(IV_IDR_FRAME == ps_lap_out->i4_pic_type)
    {
        ps_lap_struct->i4_idr_gop_num++;
        ps_lap_struct->i4_curr_ref_pics = 0;
        ps_lap_out->i4_num_ref_pics = 0;
        ps_lap_struct->i4_cra_i_pic_flag = 1;
        ps_lap_struct->i4_cra_poc = ps_lap_out->i4_poc;

        memset(ps_lap_struct->ref_poc_array, 0xFF, sizeof(WORD32) * MAX_REF_PICS);
    }
    else if(IV_I_FRAME == ps_lap_out->i4_pic_type)
    {
        /* For the I-frames after CRA Frame, no pictures should be referenced */
        if((1 == ps_lap_struct->i4_cra_i_pic_flag) && ps_lap_out->i4_is_cra_pic)
        {
            ps_lap_struct->i4_curr_ref_pics = 0;
            ps_lap_out->i4_num_ref_pics = 0;
        }
        ps_lap_struct->i4_cra_poc = ps_lap_out->i4_poc;
        ps_lap_struct->i4_cra_i_pic_flag = ps_lap_out->i4_is_cra_pic;
    }
    else if(IV_P_FRAME == ps_lap_out->i4_pic_type)
    {
        /* If the current POC is the P POC after CRA I POC */
        if(1 == ps_lap_struct->i4_cra_i_pic_flag)
        {
            ps_lap_struct->i4_curr_ref_pics = 1;
            ps_lap_struct->i4_cra_i_pic_flag = 0;
        }
    }

    if(ps_lap_out->i4_pic_type == IV_IDR_FRAME ||
       (ps_lap_out->i4_pic_type == IV_I_FRAME && ps_lap_out->i4_is_cra_pic))
    {
        ps_lap_struct->i4_assoc_IRAP_poc = ps_lap_out->i4_poc;
    }

    /*Update ps_lap_out*/
    ps_lap_out->i4_idr_gop_num = ps_lap_struct->i4_idr_gop_num;
    ps_lap_out->i4_is_ref_pic = 1;
    ps_lap_out->i4_assoc_IRAP_poc = ps_lap_struct->i4_assoc_IRAP_poc;

    /* Reference POCS */
    ps_lap_out->i4_num_ref_pics = ps_lap_struct->i4_curr_ref_pics;

    /* I and P frames are always mapped to layer zero*/
    ps_lap_out->i4_temporal_lyr_id = 0;

    ref_pics_weight_offset_calc(ps_lap_out, ps_lap_struct);

    if(ps_lap_struct->i4_curr_ref_pics < i4_max_ref_pics)
    {
        if(ps_lap_out->i4_is_ref_pic)
        {
            ps_lap_struct->i4_curr_ref_pics++;
        }
    }

    /* Arrange the reference array in ascending order */
    {
        WORD32 i, j, temp;
        for(i = 0; i < (ps_lap_struct->i4_curr_ref_pics - 1); i++)
        {
            for(j = i + 1; j < (ps_lap_struct->i4_curr_ref_pics); j++)
            {
                if(ref_poc_array[i] > ref_poc_array[j])
                {
                    temp = ref_poc_array[i];
                    ref_poc_array[i] = ref_poc_array[j];
                    ref_poc_array[j] = temp;
                }
            }
        }
    }

    {
        /* add the current pictute at the start of the reference queue */
        /*For I and P pictures, all the previous frames are reference frames */
        /* If the current ref POC is greater than the least POC in reference array*/
        /* Then fill the reference array */

        WORD32 ref = ps_lap_out->i4_poc;

        if(ps_lap_out->i4_is_ref_pic && ref > *p_ref_poc_array)
        {
            *p_ref_poc_array = ref;
        }
    }

    return;
}

/*!
************************************************************************
* \brief
*    determine next sub-gop state
************************************************************************
*/
void ihevce_determine_next_sub_gop_state(lap_struct_t *ps_lap_struct)
{
    WORD32 i4_num_b_frames = -1;
    WORD32 i4_sd = ps_lap_struct->i4_sub_gop_size;
    WORD32 i4_sd_idr = ps_lap_struct->i4_sub_gop_size_idr;
    WORD32 i4_Midr = ps_lap_struct->i4_max_idr_period;
    WORD32 i4_midr = ps_lap_struct->i4_min_idr_period;
    WORD32 i4_Mcra = ps_lap_struct->i4_max_cra_period;
    WORD32 i4_Mi = ps_lap_struct->i4_max_i_period;
    WORD32 i4_Cd = ps_lap_struct->i4_idr_counter;
    WORD32 i4_Cc = ps_lap_struct->i4_cra_counter;
    WORD32 i4_Ci = ps_lap_struct->i4_i_counter;

    if(ps_lap_struct->i4_force_idr_pos)
    {
        ps_lap_struct->i4_num_frm_type_decided = 1;
        ps_lap_struct->ai1_pic_type[0] = PIC_TYPE_IDR;
        ps_lap_struct->i4_idr_counter = 0;
        ps_lap_struct->i4_cra_counter = 0;
        ps_lap_struct->i4_i_counter = 0;
        ps_lap_struct->i4_force_idr_pos = 0;
        ps_lap_struct->i4_sub_gop_pic_idx = 0;
    }

    if(i4_Midr)
        ASSERT(i4_Cd < i4_Midr);

    if(i4_Mcra)
        ASSERT(i4_Cc < i4_Mcra);

    if(i4_Mi)
        ASSERT(i4_Ci < i4_Mi);

    /*if all are i pictures */
    if((i4_Midr == 1) || (i4_Mcra == 1) || (i4_Mi == 1))
    {
        ps_lap_struct->i4_num_frm_type_decided = 1;
        if((i4_Midr == 1) || ((i4_Cd + i4_sd) == i4_Midr))
        {
            ps_lap_struct->ai1_pic_type[1] = PIC_TYPE_IDR;
            ps_lap_struct->i4_idr_counter = 0;
            ps_lap_struct->i4_cra_counter = 0;
            ps_lap_struct->i4_i_counter = 0;
        }
        else if((i4_Mcra == 1) || ((i4_Cc + i4_sd) == i4_Mcra))
        {
            ps_lap_struct->ai1_pic_type[1] = PIC_TYPE_CRA;
            ps_lap_struct->i4_idr_counter += 1;
            ps_lap_struct->i4_cra_counter = 0;
            ps_lap_struct->i4_i_counter = 0;
        }
        else
        {
            ps_lap_struct->ai1_pic_type[1] = PIC_TYPE_I;
            ps_lap_struct->i4_idr_counter += 1;
            ps_lap_struct->i4_cra_counter += 1;
            ps_lap_struct->i4_i_counter = 0;
        }
        return;
    }

    if((i4_Cd + i4_sd_idr >= i4_Midr) && i4_Midr)
    {
        /*if idr falls already on sub-gop aligned w.r.t Midr or if strict idr use case*/
        if(i4_sd_idr != i4_sd)
        {
            i4_num_b_frames = i4_Midr - i4_Cd - 2;
            memset(&ps_lap_struct->ai1_pic_type[1], PIC_TYPE_B, i4_num_b_frames);
            ps_lap_struct->ai1_pic_type[i4_num_b_frames + 1] = PIC_TYPE_P;
            ps_lap_struct->ai1_pic_type[i4_num_b_frames + 2] = PIC_TYPE_IDR;
            ps_lap_struct->i4_num_frm_type_decided = i4_num_b_frames + 2;
            ps_lap_struct->i4_idr_counter = 0;
            ps_lap_struct->i4_cra_counter = 0;
            ps_lap_struct->i4_i_counter = 0;
        }
        else
        {
            i4_num_b_frames = 0;
            ps_lap_struct->ai1_pic_type[1] = PIC_TYPE_IDR;
            ps_lap_struct->i4_num_frm_type_decided = 1;
            ps_lap_struct->i4_idr_counter = 0;
            ps_lap_struct->i4_cra_counter = 0;
            ps_lap_struct->i4_i_counter = 0;
        }
    }
    /*if next sub gop is going to have CRA as Cc reaches Mcra*/
    else if(((i4_Cc + i4_sd) >= i4_Mcra) && i4_Mcra)
    {
        if(((i4_Cc + i4_sd) == i4_Mcra) || (1 == ps_lap_struct->i4_fixed_open_gop_period))
        {
            i4_num_b_frames = i4_Mcra - i4_Cc - 1;
            memset(&ps_lap_struct->ai1_pic_type[1], PIC_TYPE_B, i4_num_b_frames);
            ps_lap_struct->ai1_pic_type[i4_num_b_frames + 1] = PIC_TYPE_CRA;
            ps_lap_struct->i4_num_frm_type_decided = i4_num_b_frames + 1;
            ps_lap_struct->i4_idr_counter += ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_cra_counter = 0;
            ps_lap_struct->i4_i_counter = 0;
        }
        else
        {
            ps_lap_struct->ai1_pic_type[0] = PIC_TYPE_CRA;
            i4_num_b_frames = i4_sd - 1;
            memset(&ps_lap_struct->ai1_pic_type[1], PIC_TYPE_B, i4_num_b_frames);
            ps_lap_struct->ai1_pic_type[i4_num_b_frames + 1] = PIC_TYPE_P;
            ps_lap_struct->i4_num_frm_type_decided = i4_num_b_frames + 1;
            ps_lap_struct->i4_idr_counter += ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_cra_counter = ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_i_counter = ps_lap_struct->i4_num_frm_type_decided;
        }
    }
    /*if next sub gop is going to have I_slice as Ci reaches Mi*/
    else if((i4_Ci + i4_sd >= i4_Mi) && i4_Mi)
    {
        if(((i4_Ci + i4_sd) == i4_Mi) || (1 == ps_lap_struct->i4_fixed_i_period))
        {
            i4_num_b_frames = i4_Mi - i4_Ci - 1;
            memset(&ps_lap_struct->ai1_pic_type[1], PIC_TYPE_B, i4_num_b_frames);
            ps_lap_struct->ai1_pic_type[i4_num_b_frames + 1] = PIC_TYPE_I;
            ps_lap_struct->i4_num_frm_type_decided = i4_num_b_frames + 1;
            ps_lap_struct->i4_idr_counter += ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_cra_counter += ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_i_counter = 0;
        }
        else
        {
            ps_lap_struct->ai1_pic_type[0] = PIC_TYPE_I;
            i4_num_b_frames = i4_sd - 1;
            memset(&ps_lap_struct->ai1_pic_type[1], PIC_TYPE_B, i4_num_b_frames);
            ps_lap_struct->ai1_pic_type[i4_num_b_frames + 1] = PIC_TYPE_P;
            ps_lap_struct->i4_num_frm_type_decided = i4_num_b_frames + 1;
            ps_lap_struct->i4_idr_counter += ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_cra_counter += ps_lap_struct->i4_num_frm_type_decided;
            ps_lap_struct->i4_i_counter = ps_lap_struct->i4_num_frm_type_decided;
        }
    }
    /* if next sub-gop is not going to be idr,cra,I*/
    else
    {
        i4_num_b_frames = i4_sd - 1;
        memset(&ps_lap_struct->ai1_pic_type[1], PIC_TYPE_B, i4_num_b_frames);
        ps_lap_struct->ai1_pic_type[i4_num_b_frames + 1] = PIC_TYPE_P;
        ps_lap_struct->i4_num_frm_type_decided = i4_num_b_frames + 1;
        ps_lap_struct->i4_idr_counter += ps_lap_struct->i4_num_frm_type_decided;
        ps_lap_struct->i4_cra_counter += ps_lap_struct->i4_num_frm_type_decided;
        ps_lap_struct->i4_i_counter += ps_lap_struct->i4_num_frm_type_decided;
    }
    ASSERT(i4_num_b_frames != -1);

    return;
}

/*!
************************************************************************
* \brief
*    assign pic type to input buf
************************************************************************
*/
void ihevce_assign_pic_type(lap_struct_t *ps_lap_struct, ihevce_lap_enc_buf_t *ps_lap_inp_buf)
{
    WORD8 pic_type = ps_lap_struct->ai1_pic_type[ps_lap_struct->i4_next_start_ctr];

    switch(pic_type)
    {
    case PIC_TYPE_I:
    {
        ps_lap_inp_buf->s_lap_out.i4_pic_type = IV_I_FRAME;
        ps_lap_inp_buf->s_lap_out.i4_is_cra_pic = 0;
        ps_lap_inp_buf->s_lap_out.i4_is_I_in_any_field = 1;
        break;
    }
    case PIC_TYPE_P:
    {
        ps_lap_inp_buf->s_lap_out.i4_pic_type = IV_P_FRAME;
        ps_lap_inp_buf->s_lap_out.i4_is_cra_pic = 0;
        break;
    }
    case PIC_TYPE_B:
    {
        ps_lap_inp_buf->s_lap_out.i4_pic_type = IV_B_FRAME;
        ps_lap_inp_buf->s_lap_out.i4_is_cra_pic = 0;
        break;
    }
    case PIC_TYPE_IDR:
    {
        ps_lap_struct->i4_curr_poc = 0;
        ps_lap_inp_buf->s_lap_out.i4_pic_type = IV_IDR_FRAME;
        ps_lap_inp_buf->s_lap_out.i4_is_cra_pic = 0;
        break;
    }
    case PIC_TYPE_CRA:
    {
        ps_lap_inp_buf->s_lap_out.i4_pic_type = IV_I_FRAME;
        ps_lap_inp_buf->s_lap_out.i4_is_I_in_any_field = 1;
        ps_lap_inp_buf->s_lap_out.i4_is_cra_pic = 1;
        break;
    }
    default:
        ASSERT(0);
    }
    return;
}

/*!
************************************************************************
* \brief
*    capture order traversal nodes
************************************************************************
*/
void ihevce_encode_order_traversal_nodes(
    ihevce_encode_node_t *encode_node_t,
    ihevce_lap_enc_buf_t **encode_order,
    WORD32 *loop_count,
    WORD32 curr_layer,
    lap_struct_t *ps_lap_struct)
{
    if(encode_node_t == NULL)
        return;

    encode_order[*loop_count] = (ihevce_lap_enc_buf_t *)encode_node_t->ps_lap_top_buff;

    if(encode_order[*loop_count] != NULL)
    {
        ihevce_lap_enc_buf_t *ps_lap_inp;

        ps_lap_struct->pi4_encode_poc_ptr[0] = encode_node_t->data;
        ref_b_pic_population(curr_layer, encode_order[*loop_count], ps_lap_struct);

        ps_lap_inp = (ihevce_lap_enc_buf_t *)encode_order[*loop_count];
        ihevce_rc_populate_common_params(&ps_lap_inp->s_lap_out, &ps_lap_inp->s_rc_lap_out);

        ps_lap_struct->pi4_encode_poc_ptr++;
    }

    (*loop_count) = (*loop_count) + 1;

    /* Pre-order Left-node traversal*/
    ihevce_encode_order_traversal_nodes(
        (ihevce_encode_node_t *)encode_node_t->pv_left_node,
        encode_order,
        loop_count,
        curr_layer + 1,
        ps_lap_struct);

    /* Pre-order Right-node traversal*/
    ihevce_encode_order_traversal_nodes(
        (ihevce_encode_node_t *)encode_node_t->pv_right_node,
        encode_order,
        loop_count,
        curr_layer + 1,
        ps_lap_struct);
}

/*!
************************************************************************
* \brief
*    capture order traversal nodes
************************************************************************
*/
void ihevce_capture_order_traversal_nodes(
    ihevce_encode_node_t *encode_node_t,
    ihevce_lap_enc_buf_t **api4_capture_order_array,
    WORD32 *capture_order_poc_array,
    WORD32 *loop_count,
    WORD32 i4_interlace_field)
{
    if(encode_node_t == NULL)
        return;

    /* Inorder Insertion for the left-child node */
    ihevce_capture_order_traversal_nodes(
        (ihevce_encode_node_t *)encode_node_t->pv_left_node,
        api4_capture_order_array,
        capture_order_poc_array,
        loop_count,
        i4_interlace_field);

    if(i4_interlace_field)
    {
        encode_node_t->ps_lap_top_buff =
            (ihevce_lap_enc_buf_t *)api4_capture_order_array[*loop_count];
        encode_node_t->data = capture_order_poc_array[*loop_count];
        encode_node_t->ps_lap_bottom_buff =
            (ihevce_lap_enc_buf_t *)api4_capture_order_array[*loop_count + 1];
    }
    else
    {
        encode_node_t->ps_lap_top_buff =
            (ihevce_lap_enc_buf_t *)api4_capture_order_array[*loop_count];
        encode_node_t->data = capture_order_poc_array[*loop_count];
    }
    if(i4_interlace_field)
        (*loop_count) = (*loop_count) + 2;
    else
        (*loop_count) = (*loop_count) + 1;

    /* Inorder Insertion for the right-child node */
    ihevce_capture_order_traversal_nodes(
        (ihevce_encode_node_t *)encode_node_t->pv_right_node,
        api4_capture_order_array,
        capture_order_poc_array,
        loop_count,
        i4_interlace_field);
}

/*!
************************************************************************
* \brief
*    I/P pic population
************************************************************************
*/
void ihevce_ip_pic_population(
    ihevce_encode_node_t *ps_encode_node, lap_struct_t *ps_lap_struct, WORD32 i4_first_gop)
{
    ihevce_lap_enc_buf_t *ps_lap_inp = NULL;
    WORD32 hier_layer = ps_lap_struct->s_lap_static_params.i4_max_temporal_layers;
    WORD32 sub_gop_size = ps_lap_struct->i4_dyn_sub_gop_size;
    ihevce_lap_enc_buf_t **api4_capture_order_array = ps_lap_struct->api4_capture_order_array;
    ihevce_lap_enc_buf_t **api4_encode_order_array = ps_lap_struct->api4_encode_order_array;
    WORD32 *ai4_capture_order_poc = ps_lap_struct->pi4_capture_poc_ptr;

    /* Populate the encode order POC dependent on IDR frames and Interlace Field*/
    if(1 == ps_lap_struct->i4_idr_flag)
    {
        if(i4_first_gop)
        {
            api4_encode_order_array[0] = api4_capture_order_array[0];

            if(api4_encode_order_array[0] != NULL)
            {
                ps_lap_struct->pi4_encode_poc_ptr[0] = ai4_capture_order_poc[0];
                ref_pic_population(api4_encode_order_array[0], ps_lap_struct);

                ps_lap_inp = api4_encode_order_array[0];
                ihevce_rc_populate_common_params(&ps_lap_inp->s_lap_out, &ps_lap_inp->s_rc_lap_out);

                ps_lap_struct->pi4_encode_poc_ptr++;
            }

            if(ps_lap_struct->i4_immediate_idr_case != 1)
            {
                api4_encode_order_array[1] = api4_capture_order_array[sub_gop_size];

                if(api4_encode_order_array[1] != NULL)
                {
                    ps_lap_struct->pi4_encode_poc_ptr[0] = ai4_capture_order_poc[sub_gop_size];
                    ref_pic_population(api4_encode_order_array[1], ps_lap_struct);

                    ps_lap_inp = api4_encode_order_array[1];
                    ihevce_rc_populate_common_params(
                        &ps_lap_inp->s_lap_out, &ps_lap_inp->s_rc_lap_out);

                    ps_lap_struct->pi4_encode_poc_ptr++;
                }
            }
        }
        else
        {
            api4_encode_order_array[0] = api4_capture_order_array[sub_gop_size - 1];

            if(api4_encode_order_array[0] != NULL)
            {
                ps_lap_struct->pi4_encode_poc_ptr[0] = ai4_capture_order_poc[sub_gop_size - 1];
                ref_pic_population(api4_encode_order_array[0], ps_lap_struct);

                ps_lap_inp = api4_encode_order_array[0];
                ihevce_rc_populate_common_params(&ps_lap_inp->s_lap_out, &ps_lap_inp->s_rc_lap_out);

                ps_lap_struct->pi4_encode_poc_ptr++;
            }
        }
    }
    else
    {
        api4_encode_order_array[0] = api4_capture_order_array[sub_gop_size - 1];

        if(api4_encode_order_array[0] != NULL)
        {
            ps_lap_struct->pi4_encode_poc_ptr[0] = ai4_capture_order_poc[sub_gop_size - 1];
            ref_pic_population(api4_encode_order_array[0], ps_lap_struct);

            ps_lap_inp = api4_encode_order_array[0];
            ihevce_rc_populate_common_params(&ps_lap_inp->s_lap_out, &ps_lap_inp->s_rc_lap_out);

            ps_lap_struct->pi4_encode_poc_ptr++;
        }
    }
    return;
}

/*!
************************************************************************
* \brief
*    B pic population
************************************************************************
*/
void ihevce_b_pic_population(ihevce_encode_node_t *ps_encode_node, lap_struct_t *ps_lap_struct)
{
    WORD32 interlace_field = ps_lap_struct->s_lap_static_params.i4_src_interlace_field;
    ihevce_lap_enc_buf_t **api4_encode_order_array = ps_lap_struct->api4_encode_order_array;
    WORD32 *capture_order_poc_array = ps_lap_struct->pi4_capture_poc_ptr;
    WORD32 loop_count = 0;

    /* encoder_order offset changed dependent on IDR and Interlace Field */
    if(ps_lap_struct->i4_idr_flag)
        loop_count = 1 + interlace_field;

    /* Inorder Insertion of POC in tree, for capture order */
    ihevce_capture_order_traversal_nodes(
        ps_encode_node,
        &ps_lap_struct->api4_capture_order_array[0],
        capture_order_poc_array,
        &loop_count,
        interlace_field);

    /* encoder_order offset changed dependent on IDR and Interlace Field */
    /* If the gop_size is multiple of CRA period , decrement loop count */
    if(ps_lap_struct->i4_idr_flag)
        loop_count = 2 + (interlace_field * 2);
    else
        loop_count = 1 + interlace_field;

    /* Pre-order traversal of the tree to get encode-order POCs*/
    ihevce_encode_order_traversal_nodes(
        ps_encode_node, api4_encode_order_array, &loop_count, 1, ps_lap_struct);

    return;
}

/*!
************************************************************************
* \brief
*    rc_update_model_control_by_lap_for_modified_sub_gop
************************************************************************
*/
void rc_update_model_control_by_lap_for_modified_sub_gop(
    lap_struct_t *ps_lap_struct, ihevce_lap_enc_buf_t *ps_lap_out_buf)
{
    ihevce_lap_output_params_t *ps_lap_out = &ps_lap_out_buf->s_lap_out;

    /* model update flag for rc*/
    if(ps_lap_out->i4_pic_type == IV_P_FRAME)
    {
        WORD32 i4_loop = 0;
        WORD32 i4_min_delta_poc = 0x7FFFFFFF;

        for(i4_loop = 0; i4_loop < ps_lap_out->i4_num_ref_pics; i4_loop++)
        {
            if(i4_min_delta_poc > ABS(ps_lap_out->as_ref_pics[i4_loop].i4_ref_pic_delta_poc))
            {
                i4_min_delta_poc = ABS(ps_lap_out->as_ref_pics[i4_loop].i4_ref_pic_delta_poc);
            }
        }
    }

    if(ps_lap_out->i4_pic_type == IV_B_FRAME)
    {
        WORD32 i4_loop = 0;
        WORD32 i4_min_delta_poc = 0x7FFFFFFF;
        WORD32 i4_min_delta_poc_for_b =
            (1 << ps_lap_struct->s_lap_static_params.i4_max_temporal_layers) /
            (ps_lap_out->i4_temporal_lyr_id + 1);

        for(i4_loop = 0; i4_loop < ps_lap_out->i4_num_ref_pics; i4_loop++)
        {
            if(i4_min_delta_poc > ABS(ps_lap_out->as_ref_pics[i4_loop].i4_ref_pic_delta_poc))
            {
                i4_min_delta_poc = ABS(ps_lap_out->as_ref_pics[i4_loop].i4_ref_pic_delta_poc);
            }
        }
    }
    return;
}

/*!
************************************************************************
* \brief
*    Update num of pic type for rc
************************************************************************
*/
void update_rc_num_pic_type(lap_struct_t *ps_lap_struct, ihevce_lap_enc_buf_t *ps_lap_out_buf)
{
    WORD32 i4_field_flag = ps_lap_struct->s_lap_static_params.i4_src_interlace_field;
    rc_lap_out_params_t *ps_rc_lap_out = &ps_lap_out_buf->s_rc_lap_out;

    ps_lap_struct->i4_lap2_counter++;

    if(ps_lap_out_buf->s_lap_out.i4_pic_type == IV_I_FRAME ||
       ps_lap_out_buf->s_lap_out.i4_pic_type == IV_IDR_FRAME)
    {
        ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = I_PIC;
        GET_IDX_CIRCULAR_BUF(ps_lap_struct->i4_enq_idx, 1, NUM_LAP2_LOOK_AHEAD);
    }
    else if(ps_lap_out_buf->s_lap_out.i4_pic_type == IV_P_FRAME)
    {
        if(ps_lap_out_buf->s_lap_out.i4_first_field)
        {
            ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = P_PIC;
        }
        else
        {
            ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = P1_PIC;
        }
        GET_IDX_CIRCULAR_BUF(ps_lap_struct->i4_enq_idx, 1, NUM_LAP2_LOOK_AHEAD);
    }
    else if(ps_lap_out_buf->s_lap_out.i4_pic_type == IV_B_FRAME)
    {
        if(ps_lap_out_buf->s_lap_out.i4_temporal_lyr_id == 1)
        {
            if(ps_lap_out_buf->s_lap_out.i4_first_field)
            {
                ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = B_PIC;
            }
            else
            {
                ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = BB_PIC;
            }
            GET_IDX_CIRCULAR_BUF(ps_lap_struct->i4_enq_idx, 1, NUM_LAP2_LOOK_AHEAD);
        }
        else if(ps_lap_out_buf->s_lap_out.i4_temporal_lyr_id == 2)
        {
            if(ps_lap_out_buf->s_lap_out.i4_first_field)
            {
                ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = B1_PIC;
            }
            else
            {
                ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = B11_PIC;
            }
            GET_IDX_CIRCULAR_BUF(ps_lap_struct->i4_enq_idx, 1, NUM_LAP2_LOOK_AHEAD);
        }
        else if(ps_lap_out_buf->s_lap_out.i4_temporal_lyr_id == 3)
        {
            if(ps_lap_out_buf->s_lap_out.i4_first_field)
            {
                ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = B2_PIC;
            }
            else
            {
                ps_lap_struct->ai4_pic_type_to_be_removed[ps_lap_struct->i4_enq_idx] = B22_PIC;
            }
            GET_IDX_CIRCULAR_BUF(ps_lap_struct->i4_enq_idx, 1, NUM_LAP2_LOOK_AHEAD);
        }
        else
        {
            ASSERT(0);
        }
    }
    else
    {
        ASSERT(0);
    }

    if(!ps_lap_struct->i4_rc_lap_period)
    {
        if(ps_lap_struct->i4_rc_lap_period < ps_lap_struct->i4_gop_period)
        {
            WORD32 i4_loop;
            WORD32 idx = 0;
            WORD32 i4_max_temporal_layer =
                ps_lap_struct->s_lap_static_params.i4_max_temporal_layers;

            for(i4_loop = 0;
                i4_loop < (ps_lap_struct->i4_gop_period - ps_lap_struct->i4_rc_lap_period);
                i4_loop++)
            {
                ps_rc_lap_out->i4_next_sc_i_in_rc_look_ahead++;

                if(i4_max_temporal_layer == 0)
                {
                    if(ps_lap_struct->i4_is_all_i_pic_in_seq)
                    {
                        ps_rc_lap_out->ai4_num_pic_type[I_PIC]++;
                    }
                    else
                    {
                        /*second field*/
                        if((i4_loop & 1) && i4_field_flag)
                        {
                            ps_rc_lap_out->ai4_num_pic_type[P1_PIC]++;
                        }
                        else
                        {
                            ps_rc_lap_out->ai4_num_pic_type[P_PIC]++;
                        }
                    }
                }
                else
                {
                    ps_rc_lap_out->ai4_num_pic_type
                        [gau1_order_insert_pic_type[i4_max_temporal_layer - 1][idx]]++;

                    GET_IDX_CIRCULAR_BUF(idx, 1, (8 << i4_field_flag));
                }
            }
        }
    }
    else
    {
        ASSERT(ps_lap_struct->i4_lap2_counter <= ps_lap_struct->i4_rc_lap_period);

        if(ps_lap_struct->i4_lap2_counter == ps_lap_struct->i4_rc_lap_period)
        {
            WORD32 i4_loop, i4_period, i4_next_i_pic = 0;
            WORD32 i4_stop_count = 0;
            WORD32 i4_temp_deq = ps_lap_struct->i4_deq_idx;
            WORD32 i4_first_pic_type = ps_lap_struct->ai4_pic_type_to_be_removed[i4_temp_deq];

            if(ps_lap_struct->i4_rc_lap_period >= ps_lap_struct->i4_gop_period)
            {
                i4_period = ps_lap_struct->i4_gop_period;
            }
            else
            {
                i4_period = ps_lap_struct->i4_rc_lap_period;
            }

            for(i4_loop = 0; i4_loop < i4_period; i4_loop++)
            {
                if(ps_lap_struct->ai4_pic_type_to_be_removed[i4_temp_deq] == I_PIC && i4_loop &&
                   i4_first_pic_type == I_PIC)
                {
                    i4_stop_count = 1;
                }

                if(!i4_stop_count)
                {
                    ps_rc_lap_out->i4_next_sc_i_in_rc_look_ahead++;
                }

                ps_rc_lap_out
                    ->ai4_num_pic_type[ps_lap_struct->ai4_pic_type_to_be_removed[i4_temp_deq]]++;

                GET_IDX_CIRCULAR_BUF(i4_temp_deq, 1, NUM_LAP2_LOOK_AHEAD);
            }
            if(ps_lap_struct->i4_rc_lap_period < ps_lap_struct->i4_gop_period)
            {
                WORD32 i4_loop;
                WORD32 idx = 0;
                WORD32 i4_max_temporal_layer =
                    ps_lap_struct->s_lap_static_params.i4_max_temporal_layers;

                for(i4_loop = 0;
                    i4_loop < (ps_lap_struct->i4_gop_period - ps_lap_struct->i4_rc_lap_period) &&
                    (!i4_next_i_pic);
                    i4_loop++)
                {
                    if(!i4_stop_count)
                    {
                        ps_rc_lap_out->i4_next_sc_i_in_rc_look_ahead++;
                    }

                    if(i4_max_temporal_layer == 0)
                    {
                        if(ps_lap_struct->i4_is_all_i_pic_in_seq)
                        {
                            ps_rc_lap_out->ai4_num_pic_type[I_PIC]++;
                        }
                        else
                        {
                            /*second field*/
                            if((i4_loop & 1) && i4_field_flag)
                            {
                                ps_rc_lap_out->ai4_num_pic_type[P1_PIC]++;
                            }
                            else
                            {
                                ps_rc_lap_out->ai4_num_pic_type[P_PIC]++;
                            }
                        }
                    }
                    else
                    {
                        ps_rc_lap_out->ai4_num_pic_type
                            [gau1_order_insert_pic_type[i4_max_temporal_layer - 1][idx]]++;
                        GET_IDX_CIRCULAR_BUF(idx, 1, (8 << i4_field_flag));
                    }
                }
            }
            /*remove one pic type*/
            GET_IDX_CIRCULAR_BUF(ps_lap_struct->i4_deq_idx, 1, NUM_LAP2_LOOK_AHEAD);
            ps_lap_struct->i4_lap2_counter--;
        }
    }

    {
        WORD32 i4_loop;
        WORD32 idx = 0;
        WORD32 i4_max_temporal_layer = ps_lap_struct->s_lap_static_params.i4_max_temporal_layers;
        WORD32 i4_num_pictype = 0;

        for(i4_loop = 0; i4_loop < MAX_PIC_TYPE; i4_loop++)
        {
            i4_num_pictype += ps_rc_lap_out->ai4_num_pic_type[i4_loop];
        }

        if(!i4_num_pictype)
        {
            ps_rc_lap_out->i4_next_sc_i_in_rc_look_ahead = ps_lap_struct->i4_gop_period;

            for(i4_loop = 0; i4_loop < (ps_lap_struct->i4_gop_period); i4_loop++)
            {
                if(i4_max_temporal_layer == 0)
                {
                    if(ps_lap_struct->i4_is_all_i_pic_in_seq)
                    {
                        ps_rc_lap_out->ai4_num_pic_type[I_PIC]++;
                    }
                    else
                    {
                        /*second field*/
                        if((i4_loop & 1) && i4_field_flag)
                        {
                            ps_rc_lap_out->ai4_num_pic_type[P1_PIC]++;
                        }
                        else
                        {
                            ps_rc_lap_out->ai4_num_pic_type[P_PIC]++;
                        }
                    }
                }
                else
                {
                    ps_rc_lap_out->ai4_num_pic_type
                        [gau1_order_insert_pic_type[i4_max_temporal_layer - 1][idx]]++;

                    GET_IDX_CIRCULAR_BUF(idx, 1, (8 << i4_field_flag));
                }
            }
        }
    }
    /*FOR RC : ensure  at least 1 I pic in the gop period at any case*/
    if(!ps_rc_lap_out->ai4_num_pic_type[I_PIC])
    {
        ASSERT(ps_rc_lap_out->ai4_num_pic_type[P_PIC]);
        ps_lap_out_buf->s_rc_lap_out.ai4_num_pic_type[P_PIC]--;
        ps_lap_out_buf->s_rc_lap_out.ai4_num_pic_type[I_PIC]++;
    }
    return;
}

/*!
************************************************************************
* \brief
*    pre rel lap output update
************************************************************************
*/
void ihevce_pre_rel_lapout_update(lap_struct_t *ps_lap_struct, ihevce_lap_enc_buf_t *ps_lap_out_buf)
{
    WORD32 i4_first_field = 1;
    WORD32 i4_field = ps_lap_struct->s_lap_static_params.i4_src_interlace_field;

    if(i4_field)
    {
        i4_first_field = ps_lap_out_buf->s_lap_out.i4_first_field;
    }

    ps_lap_out_buf->s_lap_out.i4_used = 0;

    rc_update_model_control_by_lap_for_modified_sub_gop(ps_lap_struct, ps_lap_out_buf);
    update_rc_num_pic_type(ps_lap_struct, ps_lap_out_buf);

    /* curr buf next is null, prev buf next is curr and prev buff equal to curr*/

    ps_lap_out_buf->s_rc_lap_out.ps_rc_lap_out_next_encode = NULL;
    if(ps_lap_struct->pv_prev_inp_buf != NULL &&
       ps_lap_struct->s_lap_static_params.s_lap_params.i4_rc_look_ahead_pics)
    {
        ((ihevce_lap_enc_buf_t *)ps_lap_struct->pv_prev_inp_buf)
            ->s_rc_lap_out.ps_rc_lap_out_next_encode = (void *)&ps_lap_out_buf->s_rc_lap_out;
    }

    ps_lap_struct->pv_prev_inp_buf = (void *)ps_lap_out_buf;
    ps_lap_out_buf->s_lap_out.i4_is_prev_pic_in_Tid0_same_scene = 1;

    /*with force idr below check is not valid*/
#if(!FORCE_IDR_TEST)
    if(ps_lap_struct->i4_max_idr_period == ps_lap_struct->i4_min_idr_period)
    {
        if(!ps_lap_out_buf->s_lap_out.i4_poc)
        {
            ASSERT(ps_lap_struct->i4_max_prev_poc == (ps_lap_struct->i4_max_idr_period - 1));
            ps_lap_struct->i4_max_prev_poc = 0;
        }
    }
#endif

    /*assert if num of reference frame is zero in case of P or B frame*/
    if(ps_lap_out_buf->s_lap_out.i4_pic_type == IV_P_FRAME ||
       ps_lap_out_buf->s_lap_out.i4_pic_type == IV_B_FRAME)
    {
        ASSERT(ps_lap_out_buf->s_lap_out.i4_num_ref_pics != 0);
    }

    /*assert if poc = 0 and pictype is not an idr*/
    if(ps_lap_out_buf->s_lap_out.i4_pic_type != IV_IDR_FRAME &&
       ps_lap_out_buf->s_lap_out.i4_poc == 0)
    {
        ASSERT(0);
    }
    if(ps_lap_out_buf->s_lap_out.i4_pic_type == IV_IDR_FRAME &&
       ps_lap_out_buf->s_lap_out.i4_poc != 0)
    {
        ASSERT(0);
    }
    if(ps_lap_out_buf->s_lap_out.i4_poc < 0)
    {
        ASSERT(0);
    }

#if(!FORCE_IDR_TEST)
    if((!ps_lap_struct->i4_max_idr_period) && ps_lap_out_buf->s_lap_out.i4_display_num != 0)
    {
        ASSERT(ps_lap_out_buf->s_lap_out.i4_pic_type != IV_IDR_FRAME);
    }
#endif
    if(!ps_lap_struct->i4_max_cra_period)
    {
        ASSERT(ps_lap_out_buf->s_lap_out.i4_is_cra_pic != 1);
    }

    if(ps_lap_out_buf->s_lap_out.i4_force_idr_flag)
    {
        ASSERT(ps_lap_out_buf->s_lap_out.i4_pic_type == IV_IDR_FRAME);
    }
    ps_lap_out_buf->s_lap_out.i4_curr_frm_qp = -1;
}

/*!
************************************************************************
* \brief
*    lap queue input
************************************************************************
*/
void ihevce_lap_queue_input(
    lap_struct_t *ps_lap_struct, ihevce_lap_enc_buf_t *ps_input_lap_enc_buf, WORD32 *pi4_tree_num)
{
    ihevce_encode_node_t *ps_encode_node =
        (ihevce_encode_node_t *)ps_lap_struct->aps_encode_node[*pi4_tree_num];

    WORD32 i4_capture_idx = ps_lap_struct->i4_capture_idx;

    /* Static Lap parameters */
    ihevce_lap_static_params_t *ps_lap_static_params =
        (ihevce_lap_static_params_t *)&ps_lap_struct->s_lap_static_params;

    WORD32 hier_layer = ps_lap_static_params->i4_max_temporal_layers;
    WORD32 sub_gop_size = ps_lap_struct->i4_dyn_sub_gop_size;

    /* queue the current input in capture array */
    {
        WORD32 first_gop_flag;

        if(!i4_capture_idx)
        {
            memset(
                &ps_lap_struct->api4_capture_order_array[0],
                0,
                sizeof(ihevce_lap_enc_buf_t *) * MAX_NUM_ENC_NODES);
        }
        ps_lap_struct->api4_capture_order_array[i4_capture_idx] = ps_input_lap_enc_buf;

        if(ps_input_lap_enc_buf != NULL)
        {
            if(ps_input_lap_enc_buf->s_lap_out.i4_end_flag == 1)
                ps_lap_struct->i4_end_flag_pic_idx = i4_capture_idx;
            ps_lap_struct->ai4_capture_order_poc[i4_capture_idx] = ps_lap_struct->i4_curr_poc++;
        }

        if((1 == ps_lap_struct->i4_num_dummy_pic) && (ps_lap_struct->i4_sub_gop_end == 0))
        {
            ps_lap_struct->i4_sub_gop_end = i4_capture_idx - 1;
        }
        i4_capture_idx++;

        /* to take care of buffering 1 extra picture at start or at IDR interval*/
        if(!ps_lap_struct->i4_is_all_i_pic_in_seq)
        {
            if(ps_lap_static_params->i4_src_interlace_field && sub_gop_size <= 2)
            {
                first_gop_flag = 0;
            }
            else
            {
                first_gop_flag = ps_lap_struct->i4_idr_flag
                                 << ps_lap_static_params->i4_src_interlace_field;
            }
        }
        else
        {
            first_gop_flag = ps_lap_struct->i4_idr_flag;
        }

        /* For every IDR period, set idr_flag and reset POC value and gop_size to 0*/
        if(ps_input_lap_enc_buf != NULL)
        {
            if((!first_gop_flag) && (ps_input_lap_enc_buf->s_lap_out.i4_pic_type == IV_IDR_FRAME))
            {
                ps_lap_struct->pi4_encode_poc_ptr = &ps_lap_struct->ai4_encode_order_poc[0];
                ps_lap_struct->i4_idr_flag = 1;
                ps_lap_struct->i4_curr_poc = 0;
                ps_lap_struct->ai4_capture_order_poc[i4_capture_idx - 1] =
                    ps_lap_struct->i4_curr_poc++;
            }
        }

        if(first_gop_flag &&
           (ps_lap_struct->i4_is_all_i_pic_in_seq || ps_lap_struct->i4_immediate_idr_case))
        {
            sub_gop_size = 0;
        }

        if(!first_gop_flag && ps_lap_struct->i4_immediate_idr_case &&
           (i4_capture_idx != (sub_gop_size + first_gop_flag)))
        {
            sub_gop_size = 1 << ps_lap_static_params->i4_src_interlace_field;
            ps_lap_struct->i4_dyn_sub_gop_size = 1 << ps_lap_static_params->i4_src_interlace_field;
        }

        /* reset the queue idx end of every gop */
        if(i4_capture_idx == (sub_gop_size + first_gop_flag))
        {
            ps_lap_struct->pi4_encode_poc_ptr = &ps_lap_struct->ai4_encode_order_poc[0];

            if(ps_lap_struct->i4_end_flag_pic_idx && (1 != sub_gop_size))
            {
                WORD32 i4_temp_poc = 0;
                ihevce_lap_enc_buf_t *ps_temp_lap_enc_buf = NULL;

                /*swap the lap enc buf and poc*/
                ps_temp_lap_enc_buf =
                    ps_lap_struct->api4_capture_order_array[ps_lap_struct->i4_end_flag_pic_idx - 1];
                ps_lap_struct->api4_capture_order_array[ps_lap_struct->i4_end_flag_pic_idx - 1] =
                    NULL;
                ps_lap_struct->api4_capture_order_array[i4_capture_idx - 2] =
                    ps_lap_struct->api4_capture_order_array[ps_lap_struct->i4_end_flag_pic_idx];

                if((i4_capture_idx - 2) != ps_lap_struct->i4_end_flag_pic_idx)
                    ps_lap_struct->api4_capture_order_array[ps_lap_struct->i4_end_flag_pic_idx] =
                        NULL;

                ps_temp_lap_enc_buf->s_lap_out.i4_pic_type = IV_P_FRAME;
                ps_lap_struct->api4_capture_order_array[i4_capture_idx - 1] = ps_temp_lap_enc_buf;

                i4_temp_poc =
                    ps_lap_struct->ai4_capture_order_poc[ps_lap_struct->i4_end_flag_pic_idx - 1];
                ps_lap_struct->ai4_capture_order_poc[i4_capture_idx - 2] =
                    ps_lap_struct->ai4_capture_order_poc[ps_lap_struct->i4_end_flag_pic_idx];

                ps_lap_struct->ai4_capture_order_poc[i4_capture_idx - 1] = i4_temp_poc;
            }

            if(ps_lap_struct->i4_num_dummy_pic)
            {
                WORD32 pic_idx;
                ihevce_lap_enc_buf_t *ps_temp_lap_enc_buf = NULL;
                static const WORD32 subgop_temporal_layer3[8] = { 7, 3, 1, 0, 2, 5, 4, 6 };
                static const WORD32 subgop_temporal_layer2[4] = { 3, 1, 0, 2 };
                const WORD32 *subgop_pic_idx = (ps_lap_static_params->i4_max_temporal_layers == 2)
                                                   ? &subgop_temporal_layer2[0]
                                                   : &subgop_temporal_layer3[0];
                WORD32 max_pic_count = ps_lap_struct->i4_sub_gop_end + 1;

                for(pic_idx = 0; pic_idx < max_pic_count; pic_idx++)
                {
                    WORD32 i4_temp_idx = ps_lap_static_params->i4_max_temporal_layers > 1
                                             ? subgop_pic_idx[pic_idx]
                                             : 1;

                    if(NULL == ps_lap_struct->api4_capture_order_array[i4_temp_idx])
                    {
                        ps_temp_lap_enc_buf =
                            ps_lap_struct->api4_capture_order_array[ps_lap_struct->i4_sub_gop_end];
                        if(pic_idx == 0)
                        {
                            ps_temp_lap_enc_buf->s_lap_out.i4_pic_type = IV_P_FRAME;
                        }
                        ps_lap_struct->api4_capture_order_array[i4_temp_idx] = ps_temp_lap_enc_buf;
                        ps_lap_struct->api4_capture_order_array[ps_lap_struct->i4_sub_gop_end] =
                            NULL;

                        ps_lap_struct->ai4_capture_order_poc[i4_temp_idx] =
                            ps_lap_struct->ai4_capture_order_poc[ps_lap_struct->i4_sub_gop_end];
                        ps_lap_struct->ai4_capture_order_poc[ps_lap_struct->i4_sub_gop_end] = 0;
                        ps_lap_struct->i4_sub_gop_end--;
                    }
                }
                ps_lap_struct->i4_sub_gop_end = 0;
            }
            i4_capture_idx = 0;

            /* add the number of pics in sub gop to the gop counter */
            /* Get reordered Buffer for encoder, wait till all sub-gop buffers are output */

            /* Popluate I/P pictures */
            ihevce_ip_pic_population(ps_encode_node, ps_lap_struct, first_gop_flag);

            /* For hierarchical layers, Populate B picture */
            if((hier_layer > 0) &&
               sub_gop_size > (1 << ps_lap_static_params->i4_src_interlace_field))
            {
                ihevce_b_pic_population(ps_encode_node, ps_lap_struct);
            }

            ps_lap_struct->i4_num_bufs_encode_order = sub_gop_size + first_gop_flag;

            /* correction of encode order in case of multiple non reference B*/
            if(ps_lap_struct->i4_dyn_sub_gop_size > ps_lap_struct->i4_sub_gop_size)
            {
                WORD32 i4_loop;
                ihevce_lap_enc_buf_t *ps_lap_enc_buf, *ps_lap_enc_buf_tmp[MAX_NUM_ENC_NODES];
                WORD32 i4_enc_cnt, i4_cap_cnt;

                i4_cap_cnt = first_gop_flag;
                i4_enc_cnt = 0;

                for(i4_loop = 0; i4_loop < ps_lap_struct->i4_num_bufs_encode_order; i4_loop++)
                {
                    ps_lap_enc_buf = ps_lap_struct->api4_encode_order_array[i4_loop];

                    if(ps_lap_enc_buf != NULL && !ps_lap_enc_buf->s_lap_out.i4_is_ref_pic &&
                       (ps_lap_enc_buf->s_lap_out.i4_temporal_lyr_id ==
                        ps_lap_struct->s_lap_static_params.i4_max_temporal_layers))
                    {
                        if(ps_lap_enc_buf != ps_lap_struct->api4_capture_order_array[i4_cap_cnt])
                        {
                            ps_lap_enc_buf_tmp[i4_enc_cnt] =
                                ps_lap_struct->api4_capture_order_array[i4_cap_cnt];
                            i4_enc_cnt++;
                            i4_loop++;
                        }
                        i4_cap_cnt += 2;
                        ps_lap_enc_buf_tmp[i4_enc_cnt] = ps_lap_enc_buf;
                        i4_enc_cnt++;
                        ps_lap_enc_buf_tmp[i4_enc_cnt] =
                            ps_lap_struct->api4_capture_order_array[i4_cap_cnt];
                        i4_enc_cnt++;
                        i4_cap_cnt += 2;
                        i4_loop++;
                    }
                    else
                    {
                        ps_lap_enc_buf_tmp[i4_enc_cnt] = ps_lap_enc_buf;
                        i4_enc_cnt++;
                    }
                }
                for(i4_loop = 0; i4_loop < ps_lap_struct->i4_num_bufs_encode_order; i4_loop++)
                {
                    ps_lap_struct->api4_encode_order_array[i4_loop] = ps_lap_enc_buf_tmp[i4_loop];
                }
            }

            /* reset the IDR flag */
            ps_lap_struct->i4_idr_flag = 0;
            ps_lap_struct->i4_dyn_sub_gop_size = ps_lap_struct->i4_sub_gop_size;

            /*Copy encode array to lap output buf*/
            memcpy(
                &ps_lap_struct->api4_lap_out_buf[ps_lap_struct->i4_lap_encode_idx],
                &ps_lap_struct->api4_encode_order_array[0],
                sizeof(ihevce_lap_enc_buf_t *) * ps_lap_struct->i4_num_bufs_encode_order);

            memset(
                &ps_lap_struct->api4_encode_order_array[0],
                0,
                sizeof(ihevce_lap_enc_buf_t *) * ps_lap_struct->i4_num_bufs_encode_order);

            ps_lap_struct->ai4_num_buffer[ps_lap_struct->i4_lap_encode_idx] =
                ps_lap_struct->i4_num_bufs_encode_order - ps_lap_struct->i4_num_dummy_pic;

            ps_lap_struct->i4_lap_encode_idx++;
            ps_lap_struct->i4_lap_encode_idx &= (MAX_SUBGOP_IN_ENCODE_QUEUE - 1);
        }

        /* store the capture index */
        ps_lap_struct->i4_capture_idx = i4_capture_idx;
        ps_lap_struct->i4_immediate_idr_case = 0;
    }
    return;
}

/*!
************************************************************************
* \brief
*    lap process
************************************************************************
*/
ihevce_lap_enc_buf_t *ihevce_lap_process(void *pv_interface_ctxt, ihevce_lap_enc_buf_t *ps_curr_inp)
{
    lap_intface_t *ps_lap_interface = (lap_intface_t *)pv_interface_ctxt;
    lap_struct_t *ps_lap_struct = (lap_struct_t *)ps_lap_interface->pv_lap_module_ctxt;
    ihevce_hle_ctxt_t *ps_hle_ctxt = (ihevce_hle_ctxt_t *)ps_lap_interface->pv_hle_ctxt;
    ihevce_lap_enc_buf_t *ps_lap_inp_buf = ps_curr_inp;
    ihevce_tgt_params_t *ps_tgt_params =
        &ps_lap_struct->s_static_cfg_params.s_tgt_lyr_prms.as_tgt_params[0];
    WORD32 i4_field_flag = ps_lap_struct->s_lap_static_params.i4_src_interlace_field;
    WORD32 i4_flush_check = 0;
    WORD32 i4_force_idr_check = 0;
    WORD32 i4_tree_num = 0;
    iv_input_ctrl_buffs_t *ps_ctrl_buf = NULL;
    WORD32 buf_id = 0;
    WORD32 i4_lap_window_size = 1 << ps_lap_struct->s_lap_static_params.i4_max_temporal_layers;

    ps_lap_interface->i4_ctrl_in_que_blocking_mode = BUFF_QUE_NON_BLOCKING_MODE;

    /* ----------- LAP processing ----------- */
    if(ps_lap_struct->end_flag != 1)
    {
        ASSERT(NULL != ps_curr_inp);

        /* ---------- get the filled control command buffer ------------ */
        ps_ctrl_buf = (iv_input_ctrl_buffs_t *)ihevce_q_get_filled_buff(
            ps_hle_ctxt->apv_enc_hdl[0],
            ps_lap_interface->i4_ctrl_in_que_id,
            &buf_id,
            ps_lap_interface->i4_ctrl_in_que_blocking_mode);

        /* ----------- check the command ---------------------- */
        if(NULL != ps_ctrl_buf)
        {
            /* check for async errors */
            ihevce_dyn_config_prms_t as_dyn_br[MAX_NUM_DYN_BITRATE_CMDS];
            WORD32 i4_num_set_bitrate_cmds = 0;
            WORD32 bitrt_ctr = 0;

            ihevce_lap_parse_async_cmd(
                ps_hle_ctxt,
                (WORD32 *)ps_ctrl_buf->pv_asynch_ctrl_bufs,
                ps_ctrl_buf->i4_cmd_buf_size,
                ps_ctrl_buf->i4_buf_id,
                &i4_num_set_bitrate_cmds,
                &as_dyn_br[0]);

            /* Call the call back function to register the new bitrate */
            for(bitrt_ctr = 0; bitrt_ctr < i4_num_set_bitrate_cmds; bitrt_ctr++)
            {
                ps_lap_interface->ihevce_dyn_bitrate_cb(
                    (void *)ps_hle_ctxt, (void *)&as_dyn_br[bitrt_ctr]);
            }

            /* release async ctrl buffer*/
            ihevce_q_rel_buf(
                ps_hle_ctxt->apv_enc_hdl[0], IHEVCE_INPUT_ASYNCH_CTRL_Q, ps_ctrl_buf->i4_buf_id);
        }

        {
            WORD32 *pi4_cmd_buf = (WORD32 *)ps_lap_inp_buf->s_input_buf.pv_synch_ctrl_bufs;

            /* check for sync cmd buffer error */
            /* check FLUSH comand and Force IDR in the complete buffer */
            i4_flush_check = 0;
            i4_force_idr_check = 0;
            ihevce_lap_parse_sync_cmd(
                ps_hle_ctxt,
                &ps_lap_struct->s_static_cfg_params,
                pi4_cmd_buf,
                ps_lap_inp_buf,
                &i4_flush_check,
                &i4_force_idr_check);

            if(i4_flush_check)
                ps_lap_struct->end_flag = 1;

            ps_lap_inp_buf->s_lap_out.i4_out_flush_flag = 0;
            ps_lap_inp_buf->s_lap_out.i4_end_flag = ps_lap_struct->end_flag;

            /* check if input buffer is a valid buffer */
            if(1 == ps_lap_inp_buf->s_input_buf.i4_inp_frm_data_valid_flag)
            {
                /* Initialise laps input buffer descriptors */
                memset(&ps_lap_inp_buf->s_lap_out, 0, sizeof(ihevce_lap_output_params_t));
                memset(&ps_lap_inp_buf->s_rc_lap_out, 0, sizeof(rc_lap_out_params_t));
                /* Default initialization of lapout parameters */
                ps_lap_inp_buf->s_lap_out.i4_scene_type = SCENE_TYPE_NORMAL;
                ps_lap_inp_buf->s_lap_out.u4_scene_num = 0;
                ps_lap_inp_buf->s_lap_out.i4_display_num = ps_lap_struct->i4_display_num;
                ps_lap_inp_buf->s_lap_out.i4_quality_preset = ps_tgt_params->i4_quality_preset;
                ps_lap_inp_buf->s_lap_out.i1_weighted_pred_flag = 0;
                ps_lap_inp_buf->s_lap_out.i1_weighted_bipred_flag = 0;
                ps_lap_inp_buf->s_lap_out.i4_log2_luma_wght_denom = DENOM_DEFAULT;
                ps_lap_inp_buf->s_lap_out.i4_log2_chroma_wght_denom = DENOM_DEFAULT;
                ps_lap_inp_buf->s_lap_out.as_ref_pics[0].i4_num_duplicate_entries_in_ref_list = 1;
                ps_lap_inp_buf->s_lap_out.as_ref_pics[0].i4_used_by_cur_pic_flag = 1;
                ps_lap_inp_buf->s_lap_out.as_ref_pics[0].as_wght_off[0].u1_luma_weight_enable_flag =
                    0;
                ps_lap_inp_buf->s_lap_out.as_ref_pics[0]
                    .as_wght_off[0]
                    .u1_chroma_weight_enable_flag = 0;
                ps_lap_inp_buf->s_lap_out.i4_first_field = 1;
                ps_lap_inp_buf->s_lap_out.i4_force_idr_flag = 0;
                ps_lap_inp_buf->s_lap_out.i4_curr_frm_qp = ps_tgt_params->ai4_frame_qp[0];
                ps_lap_inp_buf->s_lap_out.i4_used = 1;
                if(i4_force_idr_check)
                {
                    ps_lap_inp_buf->s_lap_out.i4_force_idr_flag = 1;
                }
                /* Populate input params in lap out struct */
                ps_lap_inp_buf->s_lap_out.s_input_buf.pv_y_buf =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.pv_y_buf;
                ps_lap_inp_buf->s_lap_out.s_input_buf.pv_u_buf =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.pv_u_buf;
                ps_lap_inp_buf->s_lap_out.s_input_buf.pv_v_buf =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.pv_v_buf;
                ps_lap_inp_buf->s_lap_out.s_input_buf.i4_y_wd =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.i4_y_wd;
                ps_lap_inp_buf->s_lap_out.s_input_buf.i4_y_ht =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.i4_y_ht;
                ps_lap_inp_buf->s_lap_out.s_input_buf.i4_y_strd =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.i4_y_strd;
                ps_lap_inp_buf->s_lap_out.s_input_buf.i4_uv_wd =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.i4_uv_wd;
                ps_lap_inp_buf->s_lap_out.s_input_buf.i4_uv_ht =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.i4_uv_ht;
                ps_lap_inp_buf->s_lap_out.s_input_buf.i4_uv_strd =
                    ps_lap_inp_buf->s_input_buf.s_input_buf.i4_uv_strd;

                ps_lap_struct->i4_display_num++;
                ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_enq_idx] = ps_lap_inp_buf;
                /* update first field flag */
                ps_lap_inp_buf->s_lap_out.i4_first_field = 1;
                if(i4_field_flag)
                {
                    ps_lap_inp_buf->s_lap_out.i4_first_field =
                        (ps_lap_inp_buf->s_input_buf.i4_topfield_first ^
                         ps_lap_inp_buf->s_input_buf.i4_bottom_field);
                }

                /* force idr in case interlace input can be taken only for first field */
                if(!ps_lap_inp_buf->s_lap_out.i4_first_field)
                {
                    ps_lap_inp_buf->s_lap_out.i4_force_idr_flag = 0;
                }

                if((i4_lap_window_size > 1) &&
                   (ps_lap_struct->ai1_pic_type[ps_lap_struct->i4_next_start_ctr] != PIC_TYPE_IDR))
                {
                    ps_lap_struct->i4_sub_gop_pic_idx++;
                    if(ps_lap_struct->i4_sub_gop_pic_idx > i4_lap_window_size)
                    {
                        ps_lap_struct->i4_sub_gop_pic_idx =
                            ps_lap_struct->i4_sub_gop_pic_idx - i4_lap_window_size;
                    }
                }
                else if(1 == i4_lap_window_size)
                {
                    ps_lap_struct->i4_sub_gop_pic_idx = 1;
                }

                if(i4_force_idr_check &&
                   (ps_lap_struct->ai1_pic_type[ps_lap_struct->i4_next_start_ctr] != PIC_TYPE_IDR))
                {
                    ps_lap_struct->i4_force_idr_pos = ps_lap_struct->i4_sub_gop_pic_idx;
                }

                /* store pictype for next subgop */
                if((0 == ps_lap_struct->i4_num_frm_type_decided) &&
                   (ps_lap_struct->i4_force_idr_pos == 0))
                {
                    ps_lap_struct->ai1_pic_type[0] =
                        ps_lap_struct->ai1_pic_type[ps_lap_struct->i4_next_start_ctr];

                    ihevce_determine_next_sub_gop_state(ps_lap_struct);

                    ps_lap_struct->i4_next_start_ctr = 0;
                }
                else if(
                    i4_force_idr_check &&
                    (ps_lap_struct->i4_force_idr_pos <= ps_lap_struct->i4_sub_gop_size))
                {
                    /*check force idr pos is 1st pic in sub-gop then don't add dummy pics*/
                    if(ps_lap_struct->i4_force_idr_pos != 1)
                    {
                        WORD32 sub_gop_pos = ps_lap_struct->i4_force_idr_pos;
                        while(sub_gop_pos <= ps_lap_struct->i4_sub_gop_size)
                        {
                            ps_lap_struct->i4_num_dummy_pic++;
                            ihevce_lap_queue_input(ps_lap_struct, NULL, &i4_tree_num);
                            sub_gop_pos++;
                        }
                        ps_lap_struct->i4_num_dummy_pic = 0;
                    }
                    ps_lap_struct->ai1_pic_type[0] =
                        ps_lap_struct->ai1_pic_type[ps_lap_struct->i4_next_start_ctr];

                    ihevce_determine_next_sub_gop_state(ps_lap_struct);

                    ps_lap_struct->i4_next_start_ctr = 0;
                }

                if(/*ps_lap_struct->i4_init_delay_over &&*/ 0 !=
                   ps_lap_struct->i4_num_frm_type_decided)
                {
                    ihevce_assign_pic_type(
                        ps_lap_struct,
                        ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx]);

                    ps_lap_struct->i4_num_frm_type_decided--;

                    if(NULL != ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx])
                    {
                        /*special case of two consequetive idr at the start of encode or due to force idr*/
                        ps_lap_struct->i4_immediate_idr_case =
                            ps_lap_struct->i4_is_all_i_pic_in_seq;
                        if(ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx]
                               ->s_lap_out.i4_pic_type == IV_IDR_FRAME)
                        {
                            ps_lap_struct->i4_immediate_idr_case = 1;
                        }
                        else
                        {
                            WORD32 i4_prev_idx = ps_lap_struct->i4_buf_deq_idx > 0
                                                     ? ps_lap_struct->i4_buf_deq_idx - 1
                                                     : ps_lap_struct->i4_buf_deq_idx;
                            /*field case of single IDR field followed by P*/
                            if(NULL != ps_lap_struct->aps_lap_inp_buf[i4_prev_idx] &&
                               i4_field_flag &&
                               ps_lap_struct->aps_lap_inp_buf[i4_prev_idx]->s_lap_out.i4_pic_type ==
                                   IV_IDR_FRAME &&
                               !ps_lap_struct->i4_num_frm_type_decided)
                            {
                                ps_lap_struct->i4_immediate_idr_case = 1;
                            }
                        }
                    }

                    /* Queue in the current input Buffer to LAP que */
                    ihevce_lap_queue_input(
                        ps_lap_struct,
                        ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx],
                        &i4_tree_num);

                    ps_lap_struct->i4_next_start_ctr++;
                    ps_lap_struct->i4_buf_deq_idx++;
                    if(ps_lap_struct->i4_buf_deq_idx >= MAX_QUEUE_LENGTH)
                        ps_lap_struct->i4_buf_deq_idx = 0;
                }

                ps_lap_struct->i4_buf_enq_idx++;
                if(ps_lap_struct->i4_buf_enq_idx >= MAX_QUEUE_LENGTH)
                    ps_lap_struct->i4_buf_enq_idx = 0;
            } /* end if for valid input buffer check*/
        }

        /* source pixel padding if width/height is not aligned to 8 pixel */
        if(ps_lap_inp_buf->s_input_buf.i4_inp_frm_data_valid_flag)
        {
            ihevce_src_params_t *ps_src_prms = &ps_lap_struct->s_static_cfg_params.s_src_prms;
            WORD32 i4_align_wd = ps_src_prms->i4_width;
            WORD32 i4_align_ht = ps_src_prms->i4_height;
            WORD32 min_cu_size =
                (1 << ps_lap_struct->s_static_cfg_params.s_config_prms.i4_min_log2_cu_size);

            i4_align_wd += SET_CTB_ALIGN(ps_src_prms->i4_width, min_cu_size);
            i4_align_ht += SET_CTB_ALIGN(ps_src_prms->i4_height, min_cu_size);

            ihevce_lap_pad_input_bufs(ps_lap_inp_buf, i4_align_wd, i4_align_ht);
        }
        {
            ps_lap_inp_buf->s_lap_out.s_logo_ctxt.logo_width = 0;
            ps_lap_inp_buf->s_lap_out.s_logo_ctxt.logo_height = 0;
            ps_lap_inp_buf->s_lap_out.s_logo_ctxt.logo_x_offset = 0;
            ps_lap_inp_buf->s_lap_out.s_logo_ctxt.logo_y_offset = 0;
        }
    }

    if(ps_lap_struct->end_flag == 1)
    {
        ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_enq_idx] = ps_lap_inp_buf;

        /*to be filed*/
        if(0 == ps_lap_struct->i4_num_frm_type_decided)
        {
            ps_lap_struct->ai1_pic_type[0] =
                ps_lap_struct->ai1_pic_type[ps_lap_struct->i4_next_start_ctr];

            ihevce_determine_next_sub_gop_state(ps_lap_struct);

            ps_lap_struct->i4_next_start_ctr = 0;
        }

        if(NULL != ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx])
        {
            ihevce_assign_pic_type(
                ps_lap_struct, ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx]);
        }

        ps_lap_struct->i4_num_frm_type_decided--;

        if(NULL != ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx])
        {
            /*special case of two consequetive idr at the start of encode or due to force idr*/
            ps_lap_struct->i4_immediate_idr_case = ps_lap_struct->i4_is_all_i_pic_in_seq;

            if(ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx]
                   ->s_lap_out.i4_pic_type == IV_IDR_FRAME)
            {
                ps_lap_struct->i4_immediate_idr_case = 1;
            }
            else
            {
                WORD32 i4_prev_idx = ps_lap_struct->i4_buf_deq_idx > 0
                                         ? ps_lap_struct->i4_buf_deq_idx - 1
                                         : ps_lap_struct->i4_buf_deq_idx;
                /*field case of single IDR field followed by P*/
                if(NULL != ps_lap_struct->aps_lap_inp_buf[i4_prev_idx] && i4_field_flag &&
                   ps_lap_struct->aps_lap_inp_buf[i4_prev_idx]->s_lap_out.i4_pic_type ==
                       IV_IDR_FRAME &&
                   !ps_lap_struct->i4_num_frm_type_decided)
                {
                    ps_lap_struct->i4_immediate_idr_case = 1;
                }
            }
        }
        /* Queue in the current input Buffer to LAP que */
        ihevce_lap_queue_input(
            ps_lap_struct,
            ps_lap_struct->aps_lap_inp_buf[ps_lap_struct->i4_buf_deq_idx],
            &i4_tree_num);
        ps_lap_struct->i4_max_buf_in_enc_order =
            ps_lap_struct->ai4_num_buffer[ps_lap_struct->i4_deq_lap_buf];
        ps_lap_struct->i4_next_start_ctr++;
        ps_lap_struct->i4_buf_deq_idx++;

        if(ps_lap_struct->i4_buf_deq_idx >= MAX_QUEUE_LENGTH)
            ps_lap_struct->i4_buf_deq_idx = 0;

        ps_lap_struct->i4_buf_enq_idx++;
        if(ps_lap_struct->i4_buf_enq_idx >= MAX_QUEUE_LENGTH)
            ps_lap_struct->i4_buf_enq_idx = 0;
    }

    if(1 == ps_lap_struct->i4_force_end_flag)
    {
        ihevce_force_end(ps_hle_ctxt);
    }

    /*return encode order pic to pre enc*/
    ps_lap_inp_buf = NULL;

    if(NULL !=
       ps_lap_struct->api4_lap_out_buf[ps_lap_struct->i4_deq_lap_buf][ps_lap_struct->i4_lap_out_idx])
    {
        ps_lap_inp_buf =
            ps_lap_struct
                ->api4_lap_out_buf[ps_lap_struct->i4_deq_lap_buf][ps_lap_struct->i4_lap_out_idx];
        ps_lap_struct
            ->api4_lap_out_buf[ps_lap_struct->i4_deq_lap_buf][ps_lap_struct->i4_lap_out_idx] = NULL;
        if(!ps_lap_inp_buf->s_lap_out.i4_end_flag)
            ihevce_pre_rel_lapout_update(ps_lap_struct, ps_lap_inp_buf);

        ps_lap_struct->i4_max_buf_in_enc_order =
            ps_lap_struct->ai4_num_buffer[ps_lap_struct->i4_deq_lap_buf];
    }

    ps_lap_struct->i4_lap_out_idx++;
    if(ps_lap_struct->i4_lap_out_idx == ps_lap_struct->i4_max_buf_in_enc_order)
    {
        if(ps_lap_struct->ai4_num_buffer[ps_lap_struct->i4_deq_lap_buf])
        {
            ps_lap_struct->ai4_num_buffer[ps_lap_struct->i4_deq_lap_buf] = 0;
            ps_lap_struct->i4_deq_lap_buf++;
            ps_lap_struct->i4_deq_lap_buf &= (MAX_SUBGOP_IN_ENCODE_QUEUE - 1);
        }

        ps_lap_struct->i4_lap_out_idx = 0;
    }

    return (ps_lap_inp_buf);
}

/*!
************************************************************************
* \brief
*    lap get input buffer requirement count
************************************************************************
*/
WORD32 ihevce_lap_get_num_ip_bufs(ihevce_lap_static_params_t *ps_lap_stat_prms)
{
    WORD32 i4_lap_window_size = 1;
    WORD32 gop_delay = 1 << ps_lap_stat_prms->i4_max_temporal_layers;

    if(ps_lap_stat_prms->s_lap_params.i4_rc_look_ahead_pics != 0)
    {
        i4_lap_window_size = 1 + ps_lap_stat_prms->s_lap_params.i4_rc_look_ahead_pics;
    }

    gop_delay += (i4_lap_window_size);
    return gop_delay;
}