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

 *

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