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

 *

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

*

* \brief

*    This file contains wrapper utilities to use hevc encoder library

*

* \date

*    15/04/2014

*

* \author

*    Ittiam

*

* List of Functions

*

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

/* 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 "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_plugin.h"

#include "ihevce_plugin_priv.h"

#include "ihevce_hle_interface.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_error_codes.h"

#include "ihevce_error_checks.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_global_tables.h"

#include "cast_types.h"

#include "osal.h"

#include "osal_defaults.h"

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

/* Constant Macros                                                           */

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

#define CREATE_TIME_ALLOCATION_INPUT 1

#define CREATE_TIME_ALLOCATION_OUTPUT 0

#define MAX_NUM_FRM_IN_GOP 600

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

/* Extern variables                                                          */

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

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

/* Function Definitions                                                      */

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

/*!

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

* \if Function name : mem_mngr_alloc \endif

*

* \brief

*    Memory manager specific alloc function

*    it expects to reset the allocated memory and provide the zero initialised

*    memory whenever this function getting called

*

* \param[in] pv_handle : handle to memory manager

*                        (currently not required can be set to null)

* \param[in] ps_memtab : memory descriptor pointer

*

* \return

*    Memory pointer

*

* \author

*  Ittiam

*

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

*/

void mem_mngr_alloc(void *pv_handle, ihevce_sys_api_t *ps_sys_api, iv_mem_rec_t *ps_memtab)

{

#ifndef X86_MINGW

    WORD32 error, mem_alignment;

#endif

    (void)pv_handle;

#ifdef X86_MINGW

    ps_memtab->pv_base = _aligned_malloc(ps_memtab->i4_mem_size, ps_memtab->i4_mem_alignment);

#else

    mem_alignment = ps_memtab->i4_mem_alignment;

    mem_alignment = (mem_alignment >> 3) << 3;

    if(mem_alignment == 0)

    {

        error = posix_memalign(&ps_memtab->pv_base, sizeof(void *), ps_memtab->i4_mem_size);

    }

    else

    {

        error = posix_memalign(&ps_memtab->pv_base, mem_alignment, ps_memtab->i4_mem_size);

    }

    if(error != 0)

    {

        ps_sys_api->ihevce_printf(ps_sys_api->pv_cb_handle, "posix_memalign error %d\n", error);

    }

#endif

    if(ps_memtab->pv_base == NULL)

    {

        ps_sys_api->ihevce_printf(

            ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Unable to allocate memory\n");

        ASSERT(0);

    }

    else

    {

        memset(ps_memtab->pv_base, 0, ps_memtab->i4_mem_size);

    }

    return;

}

/*!

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

* \if Function name : memory_alloc \endif

*

* \brief

*    common memory allocate function should be used across all threads

*    it expects to reset the allocated memory and return the zero initialised

*    memory pointer whenever this function getting called

*

* \param[in] pv_handle : handle to memory manager

*                        (currently not required can be set to null)

* \param[in] u4_size : size of memory required

*

* \return

*    Memory pointer

*

* \author

*  Ittiam

*

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

*/

void *memory_alloc(void *pv_handle, UWORD32 u4_size)

{

    (void)pv_handle;

    void *pv_buf = malloc(u4_size);

    if(pv_buf)

    {

        memset(pv_buf, 0, u4_size);

    }

    return (pv_buf);

}

/*!

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

* \if Function name : mem_mngr_free \endif

*

* \brief

*    Memory manager specific free function

*

* \param[in] pv_handle : handle to memory manager

*                        (currently not required can be set to null)

* \param[in] ps_memtab : memory descriptor pointer

*

* \return

*    Memory pointer

*

* \author

*  Ittiam

*

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

*/

void mem_mngr_free(void *pv_handle, iv_mem_rec_t *ps_memtab)

{

    (void)pv_handle;

#ifdef X86_MINGW

    _aligned_free(ps_memtab->pv_base);

#else

    free(ps_memtab->pv_base);

#endif

    return;

}

/*!

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

* \if Function name : memory_free \endif

*

* \brief

*    common memory free function should be used across all threads

*

* \param[in] pv_handle : handle to memory manager

*                        (currently not required can be set to null)

* \param[in] pv_mem : memory to be freed

*

* \return

*    Memory pointer

*

* \author

*  Ittiam

*

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

*/

void memory_free(void *pv_handle, void *pv_mem)

{

    (void)pv_handle;

    free(pv_mem);

    return;

}

/*!

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

* \if Function name : ihevce_set_def_params \endif

*

* \brief

*    Set default values

*

* \param[in] Static params pointer

*

* \return

*    status

*

* \author

*  Ittiam

*

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

*/

IHEVCE_PLUGIN_STATUS_T ihevce_set_def_params(ihevce_static_cfg_params_t *ps_params)

{

    WORD32 i, j;

    /* sanity checks */

    if(NULL == ps_params)

        return (IHEVCE_EFAIL);

    memset(ps_params, 0, sizeof(*ps_params));

    /* initialsie all the parameters to default values */

    ps_params->i4_size = sizeof(ihevce_static_cfg_params_t);

    ps_params->i4_save_recon = 0;

    ps_params->i4_log_dump_level = 0;

    ps_params->i4_enable_logo = 0;

    ps_params->i4_enable_csv_dump = 0;

    /* Control to free the entropy output buffers   */

    /* 1  for non_blocking mode */

    /* and 0 for blocking mode */

    ps_params->i4_outbuf_buf_free_control = 1;

    /* coding tools parameters */

    ps_params->s_coding_tools_prms.i4_size = sizeof(ihevce_coding_params_t);

    ps_params->s_coding_tools_prms.i4_cropping_mode = 1;

    ps_params->s_coding_tools_prms.i4_deblocking_type = 0;

    ps_params->s_coding_tools_prms.i4_enable_entropy_sync = 0;

    // New IDR/CDR Params

    ps_params->s_coding_tools_prms.i4_max_closed_gop_period = 0;

    ps_params->s_coding_tools_prms.i4_min_closed_gop_period = 0;

    ps_params->s_coding_tools_prms.i4_max_cra_open_gop_period = 60;

    ps_params->s_coding_tools_prms.i4_max_i_open_gop_period = 0;

    ps_params->s_coding_tools_prms.i4_max_reference_frames = -1;

    ps_params->s_coding_tools_prms.i4_max_temporal_layers = 0;

    ps_params->s_coding_tools_prms.i4_slice_type = 0;

    ps_params->s_coding_tools_prms.i4_use_default_sc_mtx = 0;

    ps_params->s_coding_tools_prms.i4_weighted_pred_enable = 0;

    ps_params->s_coding_tools_prms.i4_vqet = 0;

    ps_params->e_arch_type = ARCH_NA;

    /* config parameters */

    ps_params->s_config_prms.i4_size = sizeof(ihevce_config_prms_t);

    ps_params->s_config_prms.i4_cu_level_rc = 1;

    ps_params->s_config_prms.i4_init_vbv_fullness = 0;

    ps_params->s_config_prms.i4_max_frame_qp = 51;

    ps_params->s_config_prms.i4_max_log2_cu_size = 6;

    ps_params->s_config_prms.i4_max_log2_tu_size = 5;

    ps_params->s_config_prms.i4_max_search_range_horz = 512;

    ps_params->s_config_prms.i4_max_search_range_vert = 256;

    ps_params->s_config_prms.i4_max_tr_tree_depth_I = 1;

    ps_params->s_config_prms.i4_max_tr_tree_depth_nI = 3;

    ps_params->s_config_prms.i4_min_frame_qp = 1;

    ps_params->s_config_prms.i4_min_log2_cu_size = 3;

    ps_params->s_config_prms.i4_min_log2_tu_size = 2;

    ps_params->s_config_prms.i4_num_frms_to_encode = -1;

    ps_params->s_config_prms.i4_rate_control_mode = 2;

    ps_params->s_config_prms.i4_stuffing_enable = 0;

    ps_params->s_config_prms.i4_vbr_max_peak_rate_dur = 2000;

    /* LAP parameters */

    ps_params->s_lap_prms.i4_size = sizeof(ihevce_lap_params_t);

    ps_params->s_lap_prms.i4_deinterlacer_enable = 0;

    ps_params->s_lap_prms.i4_denoise_enable = 0;

    ps_params->s_lap_prms.i4_enable_wts_ofsts = 1;

    ps_params->s_lap_prms.i4_rc_look_ahead_pics = 0;

    /* Multi Thread parameters */

    ps_params->s_multi_thrd_prms.i4_size = sizeof(ihevce_static_multi_thread_params_t);

    ps_params->s_multi_thrd_prms.i4_max_num_cores = 1;

    ps_params->s_multi_thrd_prms.i4_memory_alloc_ctrl_flag = 0;

    ps_params->s_multi_thrd_prms.i4_num_proc_groups = 1;

    ps_params->s_multi_thrd_prms.ai4_num_cores_per_grp[0] = -1;

    ps_params->s_multi_thrd_prms.i4_use_thrd_affinity = -1;  //0;

    memset(&ps_params->s_multi_thrd_prms.au8_core_aff_mask[0], 0, sizeof(ULWORD64) * MAX_NUM_CORES);

    /* Output Streams parameters */

    ps_params->s_out_strm_prms.i4_size = sizeof(ihevce_out_strm_params_t);

    ps_params->s_out_strm_prms.i4_aud_enable_flags = 0;

    ps_params->s_out_strm_prms.i4_eos_enable_flags = 0;

    ps_params->s_out_strm_prms.i4_codec_profile = 1;

    ps_params->s_out_strm_prms.i4_codec_tier = 0;

    ps_params->s_out_strm_prms.i4_codec_type = 0;

#ifndef DISABLE_SEI

    ps_params->s_out_strm_prms.i4_sei_buffer_period_flags = 0;

    ps_params->s_out_strm_prms.i4_sei_enable_flag = 0;

    ps_params->s_out_strm_prms.i4_sei_payload_enable_flag = 0;

    ps_params->s_out_strm_prms.i4_sei_pic_timing_flags = 0;

    ps_params->s_out_strm_prms.i4_sei_cll_enable = 0;

    ps_params->s_out_strm_prms.u2_sei_avg_cll = 0;

    ps_params->s_out_strm_prms.u2_sei_max_cll = 0;

    ps_params->s_out_strm_prms.i4_sei_recovery_point_flags = 0;

    ps_params->s_out_strm_prms.i4_sei_mastering_disp_colour_vol_flags = 0;

    ps_params->s_out_strm_prms.i4_decoded_pic_hash_sei_flag = 0;

#endif

    ps_params->s_out_strm_prms.i4_sps_at_cdr_enable = 1;

    ps_params->s_out_strm_prms.i4_vui_enable = 0;

    /*Set the interoperability flag to 0*/

    ps_params->s_out_strm_prms.i4_interop_flags = 0;

    /* Source parameters */

    ps_params->s_src_prms.i4_size = sizeof(ihevce_src_params_t);

    ps_params->s_src_prms.inp_chr_format = 1;

    ps_params->s_src_prms.i4_chr_format = 11;

    ps_params->s_src_prms.i4_field_pic = 0;

    ps_params->s_src_prms.i4_frm_rate_denom = 1000;

    ps_params->s_src_prms.i4_frm_rate_num = 30000;

    ps_params->s_src_prms.i4_height = 0;  //1080;

    ps_params->s_src_prms.i4_input_bit_depth = 8;

    ps_params->s_src_prms.i4_topfield_first = 1;

    ps_params->s_src_prms.i4_width = 0;  //1920;

    ps_params->s_src_prms.i4_orig_width = 0;

    ps_params->s_src_prms.i4_orig_height = 0;

    /* Target layer parameters */

    ps_params->s_tgt_lyr_prms.i4_size = sizeof(ihevce_tgt_layer_params_t);

    ps_params->s_tgt_lyr_prms.i4_enable_temporal_scalability = 0;

    ps_params->s_tgt_lyr_prms.i4_internal_bit_depth = 8;

    ps_params->s_tgt_lyr_prms.i4_mbr_quality_setting = IHEVCE_MBR_HIGH_QUALITY;

    ps_params->s_tgt_lyr_prms.i4_multi_res_layer_reuse = 0;

    ps_params->s_tgt_lyr_prms.i4_num_res_layers = 1;

    ps_params->s_tgt_lyr_prms.i4_mres_single_out = 0;

    ps_params->s_tgt_lyr_prms.i4_start_res_id = 0;

    ps_params->s_tgt_lyr_prms.pf_scale_chroma = NULL;

    ps_params->s_tgt_lyr_prms.pf_scale_luma = NULL;

    ps_params->s_tgt_lyr_prms.pv_scaler_handle = NULL;

    /* target parameters */

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

    {

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_size = sizeof(ihevce_tgt_params_t);

        for(j = 0; j < IHEVCE_MAX_NUM_BITRATES; j++)

        {

            ps_params->s_tgt_lyr_prms.as_tgt_params[i].ai4_frame_qp[j] = 32;

            ps_params->s_tgt_lyr_prms.as_tgt_params[i].ai4_tgt_bitrate[j] = 5000000;

            ps_params->s_tgt_lyr_prms.as_tgt_params[i].ai4_peak_bitrate[j] = 10000000;

            ps_params->s_tgt_lyr_prms.as_tgt_params[i].ai4_max_vbv_buffer_size[j] = -1;

        }

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_codec_level = 156;

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_frm_rate_scale_factor = 1;

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_height = 0;

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_num_bitrate_instances = 1;

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_quality_preset = IHEVCE_QUALITY_P5;

        ps_params->s_tgt_lyr_prms.as_tgt_params[i].i4_width = 0;

    }

    /* SEI VUI parameters */

    ps_params->s_vui_sei_prms.u1_aspect_ratio_info_present_flag = 0;

    ps_params->s_vui_sei_prms.au1_aspect_ratio_idc[0] = 255;

    ps_params->s_vui_sei_prms.au2_sar_width[0] = 4;

    ps_params->s_vui_sei_prms.au2_sar_height[0] = 3;

    ps_params->s_vui_sei_prms.u1_overscan_info_present_flag = 0;

    ps_params->s_vui_sei_prms.u1_overscan_appropriate_flag = 0;

    ps_params->s_vui_sei_prms.u1_video_signal_type_present_flag = 1;

    ps_params->s_vui_sei_prms.u1_video_format = 5;

    ps_params->s_vui_sei_prms.u1_video_full_range_flag = 1;

    ps_params->s_vui_sei_prms.u1_colour_description_present_flag = 0;

    ps_params->s_vui_sei_prms.u1_colour_primaries = 2;

    ps_params->s_vui_sei_prms.u1_transfer_characteristics = 2;

    ps_params->s_vui_sei_prms.u1_matrix_coefficients = 2;

    ps_params->s_vui_sei_prms.u1_chroma_loc_info_present_flag = 0;

    ps_params->s_vui_sei_prms.u1_chroma_sample_loc_type_top_field = 0;

    ps_params->s_vui_sei_prms.u1_chroma_sample_loc_type_bottom_field = 0;

    ps_params->s_vui_sei_prms.u1_vui_hrd_parameters_present_flag = 0;

    ps_params->s_vui_sei_prms.u1_timing_info_present_flag = 0;

    ps_params->s_vui_sei_prms.u1_nal_hrd_parameters_present_flag = 0;

    /* Setting sysAPIs to NULL */

    memset(&ps_params->s_sys_api, 0, sizeof(ihevce_sys_api_t));

    /* Multi pass parameters */

    memset(&ps_params->s_pass_prms, 0, sizeof(ihevce_pass_prms_t));

    ps_params->s_pass_prms.i4_size = sizeof(ihevce_pass_prms_t);

    /* Tile parameters */

    ps_params->s_app_tile_params.i4_size = sizeof(ihevce_app_tile_params_t);

    ps_params->s_app_tile_params.i4_tiles_enabled_flag = 0;

    ps_params->s_app_tile_params.i4_uniform_spacing_flag = 1;

    ps_params->s_app_tile_params.i4_num_tile_cols = 1;

    ps_params->s_app_tile_params.i4_num_tile_rows = 1;

    ps_params->s_slice_params.i4_slice_segment_mode = 0;

    ps_params->s_slice_params.i4_slice_segment_argument = 1300;

    return (IHEVCE_EOK);

}

/*!

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

* \if Function name : ihevce_cmds_error_report \endif

*

* \brief

*    Call back from encoder to report errors

*

* \param[in]    pv_error_handling_cb_handle

* \param[in]    i4_error_code

* \param[in]    i4_cmd_type

* \param[in]    i4_id

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

IV_API_CALL_STATUS_T ihevce_cmds_error_report(

    void *pv_cb_handle, WORD32 i4_error_code, WORD32 i4_cmd_type, WORD32 i4_buf_id)

{

    /*local variables*/

    plugin_ctxt_t *plugin_ctxt = (plugin_ctxt_t *)pv_cb_handle;

    ihevce_static_cfg_params_t *ps_static_cfg_params =

        ((ihevce_hle_ctxt_t *)plugin_ctxt->pv_hle_interface_ctxt)->ps_static_cfg_prms;

    if(i4_cmd_type == 0)

        ps_static_cfg_params->s_sys_api.ihevce_printf(

            ps_static_cfg_params->s_sys_api.pv_cb_handle,

            "PLUGIN ERROR: Asynchronous Buffer Error %d in Buffer Id %d",

            i4_error_code,

            i4_buf_id);

    else

        ps_static_cfg_params->s_sys_api.ihevce_printf(

            ps_static_cfg_params->s_sys_api.pv_cb_handle,

            "PLUGIN ERROR: Synchronous Buffer Error %d in Buffer Id %d",

            i4_error_code,

            i4_buf_id);

    return (IV_SUCCESS);

}

/*!

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

* \if Function name : ihevce_strm_fill_done \endif

*

* \brief

*    Call back from encoder when Bitstream is ready to consume

*

* \param[in]

* \param[in]

* \param[in]

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

IV_API_CALL_STATUS_T

    ihevce_strm_fill_done(void *pv_ctxt, void *pv_curr_out, WORD32 i4_br_id, WORD32 i4_res_id)

{

    /* local variables */

    plugin_ctxt_t *ps_ctxt = (plugin_ctxt_t *)pv_ctxt;

    app_ctxt_t *ps_app_ctxt = &ps_ctxt->s_app_ctxt;

    out_strm_prms_t *ps_out_strm_prms = &ps_app_ctxt->as_out_strm_prms[i4_res_id][i4_br_id];

    void *pv_app_out_strm_buf_mutex_hdl = ps_out_strm_prms->pv_app_out_strm_buf_mutex_hdl;

    void *pv_app_out_strm_buf_cond_var_hdl = ps_out_strm_prms->pv_app_out_strm_buf_cond_var_hdl;

    iv_output_data_buffs_t *ps_curr_out = (iv_output_data_buffs_t *)pv_curr_out;

    WORD32 end_flag = ps_curr_out->i4_end_flag;

    WORD32 osal_result;

    /* ------  output dump stream  -- */

    if((WORD32)IV_FAIL != ps_curr_out->i4_process_ret_sts)

    {

        if(0 != ps_curr_out->i4_bytes_generated)

        {

            /* accumulate the total bits generated */

            (ps_out_strm_prms->u8_total_bits) += ps_curr_out->i4_bytes_generated * 8;

            (ps_out_strm_prms->u4_num_frms_enc)++;

        }

    }

    /****** Lock the critical section ******/

    osal_result = osal_mutex_lock(pv_app_out_strm_buf_mutex_hdl);

    if(OSAL_SUCCESS != osal_result)

        return (IV_FAIL);

    /* Update the end flag to communicate with the o/p thread */

    ps_app_ctxt->ai4_out_strm_end_flag[i4_res_id][i4_br_id] = end_flag;

    /* set the produced status of the buffer */

    {

        WORD32 idx = ps_curr_out->i4_cb_buf_id;

        ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_timestamp_low =

            ps_curr_out->i4_out_timestamp_low;

        ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_timestamp_high =

            ps_curr_out->i4_out_timestamp_high;

        ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_bytes_gen =

            ps_curr_out->i4_bytes_generated;

        ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_is_key_frame = 0;

        ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_end_flag = end_flag;

        if((IV_IDR_FRAME == ps_curr_out->i4_encoded_frame_type) ||

           (IV_I_FRAME == ps_curr_out->i4_encoded_frame_type))

        {

            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_is_key_frame = 1;

        }

        /* set the buffer as produced */

        ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][idx].i4_is_prod = 1;

    }

    /****** Wake ******/

    osal_cond_var_signal(pv_app_out_strm_buf_cond_var_hdl);

    /****** Unlock the critical section ******/

    osal_result = osal_mutex_unlock(pv_app_out_strm_buf_mutex_hdl);

    if(OSAL_SUCCESS != osal_result)

        return (IV_FAIL);

    return (IV_SUCCESS);

}

/*!

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

* \if Function name : ihevce_plugin_init \endif

*

* \brief

*    Initialises the encoder context and threads

*

* \param[in] Static params pointer

*

* \return

*    status

*

* \author

*  Ittiam

*

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

*/

IHEVCE_PLUGIN_STATUS_T ihevce_init(ihevce_static_cfg_params_t *ps_params, void **ppv_ihevce_hdl)

{

    /* local variables */

    plugin_ctxt_t *ps_ctxt;

    app_ctxt_t *ps_app_ctxt;

    ihevce_hle_ctxt_t *ps_interface_ctxt;

    ihevce_sys_api_t *ps_sys_api;

    osal_cb_funcs_t s_cb_funcs;

    WORD32 status = 0;

    /* sanity checks */

    if(NULL == ps_params)

        return (IHEVCE_EFAIL);

    if(NULL == ppv_ihevce_hdl)

        return (IHEVCE_EFAIL);

    /* set the handle to null by default */

    *ppv_ihevce_hdl = NULL;

    /* Initiallizing system apis */

    ps_sys_api = &ps_params->s_sys_api;

    ihevce_init_sys_api(NULL, ps_sys_api);

    /* --------------------------------------------------------------------- */

    /*                   Query and print Encoder version                     */

    /* --------------------------------------------------------------------- */

    ps_sys_api->ihevce_printf(

        ps_sys_api->pv_cb_handle, "Encoder version %s\n\n", ihevce_get_encoder_version());

    /* --------------------------------------------------------------------- */

    /*                    Plugin Handle create                               */

    /* --------------------------------------------------------------------- */

    ps_ctxt = (plugin_ctxt_t *)memory_alloc(NULL, sizeof(plugin_ctxt_t));

    if(NULL == ps_ctxt)

    {

        ps_sys_api->ihevce_printf(

            ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in Plugin initialization\n");

        return (IHEVCE_EFAIL);

    }

    /* initialise memory call backs */

    ps_ctxt->ihevce_mem_alloc = memory_alloc;

    ps_ctxt->ihevce_mem_free = memory_free;

    ps_ctxt->u8_num_frames_encoded = 0;

    if((0 == ps_params->i4_res_id) && (0 == ps_params->i4_br_id))

    {

        /* --------------------------------------------------------------------- */

        /*                      OSAL Handle create                               */

        /* --------------------------------------------------------------------- */

        ps_ctxt->pv_osal_handle = memory_alloc(NULL, OSAL_HANDLE_SIZE);

        /* Initialize OSAL call back functions */

        s_cb_funcs.mmr_handle = NULL;

        s_cb_funcs.osal_alloc = memory_alloc;

        s_cb_funcs.osal_free = memory_free;

        status = osal_init(ps_ctxt->pv_osal_handle);

        if(OSAL_SUCCESS != status)

        {

            ps_sys_api->ihevce_printf(

                ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in OSAL initialization\n");

            return (IHEVCE_EFAIL);

        }

        status = osal_register_callbacks(ps_ctxt->pv_osal_handle, &s_cb_funcs);

        if(OSAL_SUCCESS != status)

        {

            ps_sys_api->ihevce_printf(

                ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in OSAL call back registration\n");

            return (IHEVCE_EFAIL);

        }

        /* --------------------------------------------------------------------- */

        /*                      Thread affinity  Initialization                  */

        /* --------------------------------------------------------------------- */

        if(ps_params->s_multi_thrd_prms.i4_use_thrd_affinity)

        {

            WORD32 i4_ctr;

            /* loop over all the cores */

            for(i4_ctr = 0; i4_ctr < ps_params->s_multi_thrd_prms.i4_max_num_cores; i4_ctr++)

            {

                /* All cores are logical cores  */

                ps_params->s_multi_thrd_prms.au8_core_aff_mask[i4_ctr] = ((ULWORD64)1 << i4_ctr);

            }

        }

        /* --------------------------------------------------------------------- */

        /*             Context Initialization                                    */

        /* --------------------------------------------------------------------- */

        ps_app_ctxt = &ps_ctxt->s_app_ctxt;

        ps_ctxt->ps_static_cfg_prms = (ihevce_static_cfg_params_t *)ps_ctxt->ihevce_mem_alloc(

            NULL, sizeof(ihevce_static_cfg_params_t));

        if(NULL == ps_ctxt->ps_static_cfg_prms)

        {

            ps_sys_api->ihevce_printf(

                ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in Plugin memory initialization\n");

            return (IHEVCE_EFAIL);

        }

        ps_params->apF_csv_file[0][0] = NULL;

        /* set the memory manager handle to NULL */

        ps_app_ctxt->pv_mem_mngr_handle = NULL;

        /* --------------------------------------------------------------------- */

        /*            Back up the static params passed by caller                 */

        /* --------------------------------------------------------------------- */

        memcpy(ps_ctxt->ps_static_cfg_prms, ps_params, sizeof(ihevce_static_cfg_params_t));

        ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_orig_width =

            ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_width;

        if(HEVCE_MIN_WIDTH > ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_width)

        {

            ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_width = HEVCE_MIN_WIDTH;

        }

        ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_orig_height =

            ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_height;

        if(HEVCE_MIN_HEIGHT > ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_height)

        {

            ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_height = HEVCE_MIN_HEIGHT;

        }

        /* setting tgt width and height same as src width and height */

        ps_ctxt->ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[0].i4_width =

            ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_width;

        ps_ctxt->ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[0].i4_height =

            ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_height;

        /* setting key frame interval */

        ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_max_closed_gop_period =

            MIN(MAX_NUM_FRM_IN_GOP,

                ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_max_closed_gop_period);

        ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_max_cra_open_gop_period =

            MIN(MAX_NUM_FRM_IN_GOP,

                ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_max_cra_open_gop_period);

        ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_max_i_open_gop_period =

            MIN(MAX_NUM_FRM_IN_GOP,

                ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_max_i_open_gop_period);

        /* entropy sync is disabled if there is only one CTB row */

        if(ps_ctxt->ps_static_cfg_prms->s_src_prms.i4_height <=

            (1 << ps_ctxt->ps_static_cfg_prms->s_config_prms.i4_max_log2_cu_size))

        {

            ps_ctxt->ps_static_cfg_prms->s_coding_tools_prms.i4_enable_entropy_sync = 0;

        }

        /* --------------------------------------------------------------------- */

        /*            High Level Encoder context init                            */

        /* --------------------------------------------------------------------- */

        ps_interface_ctxt =

            (ihevce_hle_ctxt_t *)ps_ctxt->ihevce_mem_alloc(NULL, sizeof(ihevce_hle_ctxt_t));

        if(NULL == ps_interface_ctxt)

        {

            ps_sys_api->ihevce_printf(

                ps_sys_api->pv_cb_handle,

                "IHEVCE ERROR: Error in Plugin HLE memory initialization\n");

            return (IHEVCE_EFAIL);

        }

        ps_interface_ctxt->i4_size = sizeof(ihevce_hle_ctxt_t);

        ps_ctxt->pv_hle_interface_ctxt = ps_interface_ctxt;

        /* store the static config parameters pointer */

        ps_interface_ctxt->ps_static_cfg_prms = ps_ctxt->ps_static_cfg_prms;

        /* initialise the interface strucure parameters */

        ps_interface_ctxt->pv_inp_cb_handle = (void *)ps_ctxt;

        ps_interface_ctxt->pv_out_cb_handle = (void *)ps_ctxt;

        ps_interface_ctxt->pv_recon_cb_handle = (void *)ps_ctxt;

        ps_interface_ctxt->pv_osal_handle = ps_ctxt->pv_osal_handle;

        ps_interface_ctxt->ihevce_mem_alloc = mem_mngr_alloc;

        ps_interface_ctxt->ihevce_mem_free = mem_mngr_free;

        ps_interface_ctxt->i4_hle_init_done = 0;

        ps_interface_ctxt->pv_mem_mgr_hdl = ps_app_ctxt->pv_mem_mngr_handle;

        /* reigter the callbacks */

        ps_interface_ctxt->ihevce_output_strm_fill_done = ihevce_strm_fill_done;

        ps_interface_ctxt->ihevce_output_recon_fill_done = NULL;

        ps_interface_ctxt->ihevce_set_free_input_buff = NULL;

        /*Added for run time or create time creation*/

        ps_interface_ctxt->i4_create_time_input_allocation = (WORD32)CREATE_TIME_ALLOCATION_INPUT;

        ps_interface_ctxt->i4_create_time_output_allocation = (WORD32)CREATE_TIME_ALLOCATION_OUTPUT;

        ps_interface_ctxt->ihevce_cmds_error_report = ihevce_cmds_error_report;

        ps_interface_ctxt->pv_cmd_err_cb_handle = (void *)ps_ctxt;

        /* --------------------------------------------------------------------- */

        /*           High Level Encoder Instance Creation                        */

        /* --------------------------------------------------------------------- */

        status = ihevce_hle_interface_create(ps_interface_ctxt);

        if((WORD32)IV_FAIL == status)

        {

            ihevce_hle_interface_delete(ps_interface_ctxt);

            memory_free(NULL, ps_interface_ctxt);

            /* free static config memory */

            ps_ctxt->ihevce_mem_free(NULL, ps_ctxt->ps_static_cfg_prms);

            /* free osal handle */

            memory_free(NULL, ps_ctxt->pv_osal_handle);

            /* free plugin ctxt memory */

            memory_free(NULL, ps_ctxt);

            ps_sys_api->ihevce_printf(

                ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in Plugin HLE create failed\n");

            return (IHEVCE_EFAIL);

        }

        /* --------------------------------------------------------------------- */

        /*            Input Output and Command buffer allocation                 */

        /* --------------------------------------------------------------------- */

        {

            WORD32 ctr;

            WORD32 buf_size;

            UWORD8 *pu1_tmp_buf;

            WORD32 i4_res_id;

            WORD32 i4_br_id;

            WORD32 i4_num_resolutions;

            WORD32 ai4_num_bitrate_instances[IHEVCE_MAX_NUM_RESOLUTIONS] = { 1 };

            iv_input_bufs_req_t s_input_bufs_req;

            iv_res_layer_output_bufs_req_t s_res_layer_output_bufs_req;

            iv_res_layer_recon_bufs_req_t s_res_layer_recon_bufs_req;

            /* local array of pointers */

            void *apv_inp_luma_bufs[MAX_NUM_INP_DATA_BUFS];

            void *apv_inp_cb_bufs[MAX_NUM_INP_DATA_BUFS];

            void *apv_inp_cr_bufs[MAX_NUM_INP_DATA_BUFS];

            void *apv_inp_sync_bufs[MAX_NUM_INP_CTRL_SYNC_BUFS];

            void *apv_inp_async_bufs[MAX_NUM_INP_CTRL_ASYNC_BUFS];

            void *apv_out_data_bufs[IHEVCE_MAX_NUM_RESOLUTIONS][IHEVCE_MAX_NUM_BITRATES]

                                   [MAX_NUM_OUT_DATA_BUFS];

            /* get the number of resolutions */

            i4_num_resolutions = ps_ctxt->ps_static_cfg_prms->s_tgt_lyr_prms.i4_num_res_layers;

            /* set the size of the structure */

            s_input_bufs_req.i4_size = sizeof(iv_input_bufs_req_t);

            s_res_layer_output_bufs_req.i4_size = sizeof(iv_res_layer_output_bufs_req_t);

            s_res_layer_recon_bufs_req.i4_size = sizeof(iv_res_layer_recon_bufs_req_t);

            /* loop over num resolutions */

            for(i4_res_id = 0; i4_res_id < i4_num_resolutions; i4_res_id++)

            {

                /* store the number of bitrates */

                ai4_num_bitrate_instances[i4_res_id] =

                    ps_ctxt->ps_static_cfg_prms->s_tgt_lyr_prms.as_tgt_params[i4_res_id]

                        .i4_num_bitrate_instances;

                /* loop over num bitrates */

                for(i4_br_id = 0; i4_br_id < ai4_num_bitrate_instances[i4_res_id]; i4_br_id++)

                {

                    s_res_layer_output_bufs_req.s_output_buf_req[i4_res_id][i4_br_id].i4_size =

                        sizeof(iv_output_bufs_req_t);

                }

            }

            /* call Query I/O buffer */

            status = ihevce_query_io_buf_req(

                ps_interface_ctxt,

                &s_input_bufs_req,

                &s_res_layer_output_bufs_req,

                &s_res_layer_recon_bufs_req);

            /* check on the requirements against the MAX of application */

            /* should be present only for debug purpose                 */

            /* ---------------  Input data buffers init ---------------------- */

            /* allocate memory for input buffers  */

            if(ps_interface_ctxt->i4_create_time_input_allocation == 1)

            {

                buf_size = s_input_bufs_req.i4_min_size_uv_buf + s_input_bufs_req.i4_min_size_y_buf;

                ps_ctxt->s_memtab_inp_data_buf.i4_size = sizeof(iv_mem_rec_t);

                ps_ctxt->s_memtab_inp_data_buf.i4_mem_alignment = 4;

                ps_ctxt->s_memtab_inp_data_buf.i4_mem_size =

                    (s_input_bufs_req.i4_min_num_yuv_bufs + XTRA_INP_DATA_BUFS) * buf_size;

                ps_ctxt->s_memtab_inp_data_buf.e_mem_type = IV_EXT_CACHEABLE_NUMA_NODE0_MEM;

                mem_mngr_alloc(

                    ps_app_ctxt->pv_mem_mngr_handle, ps_sys_api, &ps_ctxt->s_memtab_inp_data_buf);

                pu1_tmp_buf = (UWORD8 *)ps_ctxt->s_memtab_inp_data_buf.pv_base;

                if(NULL == pu1_tmp_buf)

                {

                    ps_sys_api->ihevce_printf(

                        ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in allocate memory\n");

                    return (IHEVCE_EFAIL);

                }

                /* loop to initialise the buffer pointer */

                for(ctr = 0; ctr < s_input_bufs_req.i4_min_num_yuv_bufs + XTRA_INP_DATA_BUFS; ctr++)

                {

                    apv_inp_luma_bufs[ctr] = pu1_tmp_buf;

                    apv_inp_cb_bufs[ctr] = pu1_tmp_buf + s_input_bufs_req.i4_min_size_y_buf;

                    apv_inp_cr_bufs[ctr] = NULL; /* 420SP case */

                    /* increment the input buffer pointer to next buffer */

                    pu1_tmp_buf += buf_size;

                }

            }

            /* ---------------  Output data buffers init ---------------------- */

            /* loop over num resolutions */

            for(i4_res_id = 0; i4_res_id < i4_num_resolutions; i4_res_id++)

            {

                for(i4_br_id = 0; i4_br_id < ai4_num_bitrate_instances[i4_res_id]; i4_br_id++)

                {

                    buf_size = s_res_layer_output_bufs_req.s_output_buf_req[i4_res_id][i4_br_id]

                                   .i4_min_size_bitstream_buf;

                    ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id].i4_size =

                        sizeof(iv_mem_rec_t);

                    ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id].i4_mem_alignment = 4;

                    if(!ps_interface_ctxt->i4_create_time_output_allocation)

                    {

                        ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id].i4_mem_size =

                            (s_res_layer_output_bufs_req.s_output_buf_req[i4_res_id][i4_br_id]

                                 .i4_min_num_out_bufs +

                             XTRA_OUT_DATA_BUFS) *

                            buf_size;

                    }

                    else

                    {

                        ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id].i4_mem_size =

                            (s_res_layer_output_bufs_req.s_output_buf_req[i4_res_id][i4_br_id]

                                 .i4_min_num_out_bufs) *

                            buf_size;

                    }

                    ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id].e_mem_type =

                        IV_EXT_CACHEABLE_NUMA_NODE1_MEM;

                    mem_mngr_alloc(

                        ps_app_ctxt->pv_mem_mngr_handle,

                        ps_sys_api,

                        &ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id]);

                    pu1_tmp_buf =

                        (UWORD8 *)ps_ctxt->as_memtab_out_data_buf[i4_res_id][i4_br_id].pv_base;

                    if(NULL == pu1_tmp_buf)

                    {

                        ps_sys_api->ihevce_printf(

                            ps_sys_api->pv_cb_handle, "IHEVCE ERROR: Error in allocate memory\n");

                        return (IHEVCE_EFAIL);

                    }

                    if(ps_interface_ctxt->i4_create_time_output_allocation == 1)

                    {

                        /* loop to initialise the buffer pointer */

                        for(ctr = 0;

                            ctr < s_res_layer_output_bufs_req.s_output_buf_req[i4_res_id][i4_br_id]

                                      .i4_min_num_out_bufs;

                            ctr++)

                        {

                            apv_out_data_bufs[i4_res_id][i4_br_id][ctr] = pu1_tmp_buf;

                            pu1_tmp_buf += buf_size;

                        }

                    }

                    else

                    {

                        WORD32 i4_num_out_bufs =

                            s_res_layer_output_bufs_req.s_output_buf_req[i4_res_id][i4_br_id]

                                .i4_min_num_out_bufs +

                            XTRA_OUT_DATA_BUFS;

                        ps_ctxt->i4_num_out_bufs = i4_num_out_bufs;

                        ps_ctxt->ai4_free_out_buf_idx[i4_res_id][i4_br_id] = 0;

                        ps_ctxt->i4_prod_out_buf_idx = 0;

                        /* Assert to make sure ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][] array

                        has more bufs than ps_ctxt->i4_num_out_bufs. Needed to identify

                        wrap-around case */

                        ASSERT(ps_ctxt->i4_num_out_bufs <= MAX_NUM_OUT_DATA_BUFS);

                        /* loop to initialise the buffer pointer */

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

                        {

                            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][ctr].i4_idx = ctr;

                            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][ctr].i4_is_free = 1;

                            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][ctr].i4_is_prod = 0;

                            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][ctr].i4_bytes_gen = 0;

                            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][ctr].pu1_buf = pu1_tmp_buf;

                            ps_ctxt->aaas_out_bufs[i4_res_id][i4_br_id][ctr].i4_buf_size = buf_size;

                            pu1_tmp_buf += buf_size;

                        }

                    }

                    /* create mutex for controlling the out strm buf b/w appln and encoder */

                    ps_app_ctxt->as_out_strm_prms[i4_res_id][i4_br_id]

                        .pv_app_out_strm_buf_mutex_hdl = osal_mutex_create(ps_ctxt->pv_osal_handle);

                    if(NULL == ps_app_ctxt->as_out_strm_prms[i4_res_id][i4_br_id]

                                   .pv_app_out_strm_buf_mutex_hdl)

                    {

                        ps_sys_api->ihevce_printf(

                            ps_sys_api->pv_cb_handle,

                            "IHEVCE ERROR: Error in Plugin initialization\n");

                        return (IHEVCE_EFAIL);

                    }

                    /* create mutex for controlling the out strm buf b/w appln and encoder */

                    ps_app_ctxt->as_out_strm_prms[i4_res_id][i4_br_id]

                        .pv_app_out_strm_buf_cond_var_hdl =

                        osal_cond_var_create(ps_ctxt->pv_osal_handle);

                    if(NULL == ps_app_ctxt->as_out_strm_prms[i4_res_id][i4_br_id]

                                   .pv_app_out_strm_buf_cond_var_hdl)

                    {

                        ps_sys_api->ihevce_printf(

                            ps_sys_api->pv_cb_handle,

                            "IHEVCE ERROR: Error in Plugin initialization\n");

                        return (IHEVCE_EFAIL);

                    }

                }

            }

            if(ps_interface_ctxt->i4_create_time_input_allocation == 1)

            {

                /* ------------- Input sync command buffers init -------------------- */

                buf_size = s_input_bufs_req.i4_min_size_synch_ctrl_bufs;

                ps_ctxt->s_memtab_inp_sync_ctrl_buf.i4_size = sizeof(iv_mem_rec_t);

                ps_ctxt->s_memtab_inp_sync_ctrl_buf.i4_mem_alignment = 4;

                ps_ctxt->s_memtab_inp_sync_ctrl_buf.i4_mem_size =

                    (s_input_bufs_req.i4_min_num_yuv_bufs + XTRA_INP_DATA_BUFS) * buf_size;

                ps_ctxt->s_memtab_inp_sync_ctrl_buf.e_mem_type = IV_EXT_CACHEABLE_NUMA_NODE0_MEM;