xref: /aosp_15_r20/external/libavc/examples/svcdec/main.c (revision 495ae853bb871d1e5a258cb02c2cc13cde8ddb9a)

/******************************************************************************
 *
 * Copyright (C) 2022 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
 *  main.c
 *
 * @brief
 *  Contains an application that demonstrates use of H264 decoder API
 *
 * @author
 *  Kishore
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifdef X86_MINGW
#include <signal.h>
#endif

#ifdef IOS_DISPLAY
#include "cast_types.h"
#else
#include "ih264_typedefs.h"
#endif

#include "iv.h"
#include "ivd.h"
#include "ithread.h"

#include "ih264d.h"
#include "isvcd.h"
#ifdef WINDOWS_TIMER
#include <windows.h>
#else
#include <sys/time.h>
#endif

// #define ADAPTIVE_TEST
#define ADAPTIVE_MAX_WD 4096
#define ADAPTIVE_MAX_HT 2160

#define ALIGN8(x) ((((x) + 7) >> 3) << 3)
#define NUM_DISPLAY_BUFFERS 4
#define DEFAULT_FPS 30

#define ENABLE_DEGRADE 0
#define MAX_DISP_BUFFERS 64
#define EXTRA_DISP_BUFFERS 8
#define STRLENGTH 1000
#define STR2(x) #x
#define STR(X) STR2(X)

// #define TEST_FLUSH
#define FLUSH_FRM_CNT 100
// #define APP_EXTRA_BUFS 1

#undef PROFILE_ENABLE

#ifdef IOS
#define PATHLENMAX 500
char filename_with_path[PATHLENMAX];
#endif

#ifdef PROFILE_ENABLE
#ifdef WINDOWS_TIMER
typedef LARGE_INTEGER TIMER;
#else
// #ifdef GCC_TIMER
typedef struct timeval TIMER;
// #endif
#endif
#else
typedef WORD32 TIMER;
#endif

#ifdef PROFILE_ENABLE
#ifdef WINDOWS_TIMER
#define GETTIME(timer) QueryPerformanceCounter(timer);
#else
// #ifdef GCC_TIMER
#define GETTIME(timer) gettimeofday(timer, NULL);
// #endif
#endif

#ifdef WINDOWS_TIMER
#define ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency)                     \
    {                                                                                          \
        TIMER s_temp_time;                                                                     \
        s_temp_time.LowPart = s_end_timer.LowPart - s_start_timer.LowPart;                     \
        s_elapsed_time =                                                                       \
            (UWORD32) (((DOUBLE) s_temp_time.LowPart / (DOUBLE) frequency.LowPart) * 1000000); \
    }
#else
// #ifdef GCC_TIMER
#define ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency)     \
    s_elapsed_time = ((s_end_timer.tv_sec - s_start_timer.tv_sec) * 1000000) + \
                     (s_end_timer.tv_usec - s_start_timer.tv_usec);
// #endif
#endif

#else
#define GETTIME(timer)
#define ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency)
#endif

/* Function declarations */
#ifndef MD5_DISABLE
void calc_md5_cksum(UWORD8 *pu1_inbuf, UWORD32 u4_stride, UWORD32 u4_width, UWORD32 u4_height,
                    UWORD8 *pu1_cksum_p);
#else
#define calc_md5_cksum(a, b, c, d, e)
#endif
#ifdef SDL_DISPLAY
void *sdl_disp_init(UWORD32, UWORD32, WORD32, WORD32, WORD32, WORD32, WORD32, WORD32 *, WORD32 *);
void sdl_alloc_disp_buffers(void *);
void sdl_display(void *, WORD32);
void sdl_set_disp_buffers(void *, WORD32, UWORD8 **, UWORD8 **, UWORD8 **);
void sdl_disp_deinit(void *);
void sdl_disp_usleep(UWORD32);
IV_COLOR_FORMAT_T sdl_get_color_fmt(void);
UWORD32 sdl_get_stride(void);
#endif

#ifdef INTEL_CE5300
void *gdl_disp_init(UWORD32, UWORD32, WORD32, WORD32, WORD32, WORD32, WORD32, WORD32 *, WORD32 *);
void gdl_alloc_disp_buffers(void *);
void gdl_display(void *, WORD32);
void gdl_set_disp_buffers(void *, WORD32, UWORD8 **, UWORD8 **, UWORD8 **);
void gdl_disp_deinit(void *);
void gdl_disp_usleep(UWORD32);
IV_COLOR_FORMAT_T gdl_get_color_fmt(void);
UWORD32 gdl_get_stride(void);
#endif

#ifdef FBDEV_DISPLAY
void *fbd_disp_init(UWORD32, UWORD32, WORD32, WORD32, WORD32, WORD32, WORD32, WORD32 *, WORD32 *);
void fbd_alloc_disp_buffers(void *);
void fbd_display(void *, WORD32);
void fbd_set_disp_buffers(void *, WORD32, UWORD8 **, UWORD8 **, UWORD8 **);
void fbd_disp_deinit(void *);
void fbd_disp_usleep(UWORD32);
IV_COLOR_FORMAT_T fbd_get_color_fmt(void);
UWORD32 fbd_get_stride(void);
#endif

#ifdef IOS_DISPLAY
void *ios_disp_init(UWORD32, UWORD32, WORD32, WORD32, WORD32, WORD32, WORD32, WORD32 *, WORD32 *);
void ios_alloc_disp_buffers(void *);
void ios_display(void *, WORD32);
void ios_set_disp_buffers(void *, WORD32, UWORD8 **, UWORD8 **, UWORD8 **);
void ios_disp_deinit(void *);
void ios_disp_usleep(UWORD32);
IV_COLOR_FORMAT_T ios_get_color_fmt(void);
UWORD32 ios_get_stride(void);
#endif

typedef struct
{
    UWORD32 u4_piclen_flag;
    UWORD32 u4_file_save_flag;
    UWORD32 u4_frame_info_enable;
    UWORD32 u4_chksum_save_flag;
    UWORD32 u4_max_frm_ts;
    IV_COLOR_FORMAT_T e_output_chroma_format;
    IVD_ARCH_T e_arch;
    IVD_SOC_T e_soc;
    UWORD32 dump_q_rd_idx;
    UWORD32 dump_q_wr_idx;
    WORD32 disp_q_wr_idx;
    WORD32 disp_q_rd_idx;

    void *cocodec_obj;
    UWORD32 u4_share_disp_buf;
    UWORD32 num_disp_buf;
    UWORD32 b_pic_present;
    UWORD32 u4_disable_dblk_level;
    WORD32 i4_target_layer_id;
    WORD32 i4_degrade_type;
    WORD32 i4_degrade_pics;
    UWORD32 u4_num_cores;
    UWORD32 disp_delay;
    WORD32 trace_enable;
    CHAR ac_trace_fname[STRLENGTH];
    CHAR ac_piclen_fname[STRLENGTH];
    CHAR ac_ip_fname[STRLENGTH];
    CHAR ac_op_fname[STRLENGTH];
    CHAR ac_qp_map_fname[STRLENGTH];
    CHAR ac_blk_type_map_fname[STRLENGTH];
    CHAR ac_op_chksum_fname[STRLENGTH];
    ivd_out_bufdesc_t s_disp_buffers[MAX_DISP_BUFFERS];
    iv_yuv_buf_t s_disp_frm_queue[MAX_DISP_BUFFERS];
    UWORD32 s_disp_frm_id_queue[MAX_DISP_BUFFERS];
    UWORD32 loopback;
    UWORD32 display;
    UWORD32 full_screen;
    UWORD32 fps;

    UWORD32 u4_strd;

    /* For signalling to display thread */
    UWORD32 u4_pic_wd;
    UWORD32 u4_pic_ht;

    /* For IOS diplay */
    WORD32 i4_screen_wd;
    WORD32 i4_screen_ht;

    WORD32 quit;
    WORD32 paused;

    void *pv_disp_ctx;
    void *display_thread_handle;
    WORD32 display_thread_created;
    volatile WORD32 display_init_done;
    volatile WORD32 display_deinit_flag;

    void *(*disp_init)(UWORD32, UWORD32, WORD32, WORD32, WORD32, WORD32, WORD32, WORD32 *,
                       WORD32 *);
    void (*alloc_disp_buffers)(void *);
    void (*display_buffer)(void *, WORD32);
    void (*set_disp_buffers)(void *, WORD32, UWORD8 **, UWORD8 **, UWORD8 **);
    void (*disp_deinit)(void *);
    void (*disp_usleep)(UWORD32);
    IV_COLOR_FORMAT_T (*get_color_fmt)(void);
    UWORD32 (*get_stride)(void);
} vid_dec_ctx_t;

/**
 * function pointer to malloc
 */
void *(*pf_mem_alloc)(UWORD32 u4_size);

/**
 * function pointer to free
 */
void (*pf_mem_free)(void *pv_mem);

typedef enum
{
    INVALID,
    HELP,
    VERSION,
    INPUT_FILE,
    OUTPUT,
    QP_MAP_FILE,
    BLK_TYPE_MAP_FILE,
    CHKSUM,
    SAVE_OUTPUT,
    SAVE_FRAME_INFO,
    SAVE_CHKSUM,
    CHROMA_FORMAT,
    NUM_FRAMES,
    NUM_CORES,
    DISABLE_DEBLOCK_LEVEL,
    SHARE_DISPLAY_BUF,
    LOOPBACK,
    DISPLAY,
    FULLSCREEN,
    FPS,
    TRACE,
    CONFIG,

    DEGRADE_TYPE,
    DEGRADE_PICS,
    ARCH,
    SOC,
    PICLEN,
    PICLEN_FILE,
    TARGET_LAYER_ID,
} ARGUMENT_T;

typedef struct
{
    CHAR argument_shortname[4];
    CHAR argument_name[128];
    ARGUMENT_T argument;
    CHAR description[512];
} argument_t;

static const argument_t argument_mapping[] = {
    {"-h", "--help", HELP, "Print this help\n"},
    {"-c", "--config", CONFIG, "config file (Default: test.cfg)\n"},

    {"-v", "--version", VERSION, "Version information\n"},
    {"-i", "--input", INPUT_FILE, "Input file\n"},
    {"-o", "--output", OUTPUT, "Output file\n"},
    {"--", "--qp_map_file", QP_MAP_FILE, "QP map file\n"},
    {"--", "--blk_type_map_file", BLK_TYPE_MAP_FILE, "Block type map file\n"},
    {"--", "--piclen", PICLEN,
     "Flag to signal if the decoder has to use a file containing number of "
     "bytes in each picture to be fed in each call\n"},
    {"--", "--piclen_file", PICLEN_FILE,
     "File containing number of bytes in each picture - each line containing "
     "one i4_size\n"},
    {"--", "--chksum", CHKSUM, "Output MD5 Checksum file\n"},
    {"-s", "--save_output", SAVE_OUTPUT, "Save Output file\n"},
    {"--", "--save_frame_info", SAVE_FRAME_INFO, "Save frame_info file\n"},
    {"--", "--save_chksum", SAVE_CHKSUM, "Save Check sum file\n"},
    {"--", "--chroma_format", CHROMA_FORMAT,
     "Output Chroma format Supported values YUV_420P, YUV_422ILE, RGB_565, "
     "YUV_420SP_UV, YUV_420SP_VU\n"},
    {"-n", "--num_frames", NUM_FRAMES, "Number of frames to be decoded\n"},
    {"--", "--num_cores", NUM_CORES, "Number of cores to be used\n"},
    {"--", "--share_display_buf", SHARE_DISPLAY_BUF, "Enable shared display buffer mode\n"},
    {"--", "--disable_deblock_level", DISABLE_DEBLOCK_LEVEL,
     "Disable deblocking level : 0 to 4 - 0 Enable deblocking 4 Disable "
     "deblocking completely\n"},
    {"--", "--loopback", LOOPBACK, "Enable playback in a loop\n"},
    {"--", "--display", DISPLAY, "Enable display (uses SDL)\n"},
    {"--", "--fullscreen", FULLSCREEN, "Enable full screen (Only for GDL and SDL)\n"},
    {"--", "--fps", FPS, "FPS to be used for display \n"},
    {"-i", "--trace", TRACE, "Trace file\n"},

    {"--", "--degrade_type", DEGRADE_TYPE,
     "Degrade type : 0: No degrade 0th bit set : Disable SAO 1st bit set : "
     "Disable deblocking 2nd bit set : Faster inter prediction filters 3rd bit "
     "set : Fastest inter prediction filters\n"},
    {"--", "--degrade_pics", DEGRADE_PICS,
     "Degrade pics : 0 : No degrade  1 : Only on non-reference frames  2 : Do "
     "not degrade every 4th or key frames  3 : All non-key frames  4 : All "
     "frames"},

    {"--", "--arch", ARCH,
     "Set Architecture. Supported values  ARM_NONEON, ARM_A9Q, ARM_A7, ARM_A5, "
     "ARM_NEONINTR,ARMV8_GENERIC, X86_GENERIC, X86_SSSE3, X86_SSE4 \n"},
    {"--", "--soc", SOC, "Set SOC. Supported values  GENERIC, HISI_37X \n"},
    {"-t", "--target_layer_id", TARGET_LAYER_ID, "Version information\n"},

};

#define PEAK_WINDOW_SIZE 8
#define DEFAULT_SHARE_DISPLAY_BUF 0
#define STRIDE 0
#define DEFAULT_NUM_CORES 1

#define DUMP_SINGLE_BUF 0
#define IV_ISFATALERROR(x) (((x) >> IVD_FATALERROR) & 0x1)

#define ivd_api_function isvcd_api_function

#ifdef IOS
char filename_trace[PATHLENMAX];
#endif

#if ANDROID_NDK
/*****************************************************************************/
/*                                                                           */
/*  Function Name : raise                                                    */
/*                                                                           */
/*  Description   : Needed as a workaround when the application is built in  */
/*                  Android NDK. This is an exception to be called for divide*/
/*                  by zero error                                            */
/*                                                                           */
/*  Inputs        : a                                                        */
/*  Globals       :                                                          */
/*  Processing    : None                                                     */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       :                                                          */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         07 09 2012   100189          Initial Version                      */
/*                                                                           */
/*****************************************************************************/
int raise(int a)
{
    printf("Divide by zero\n");
    return 0;
}
#endif

#ifdef _WIN32
/*****************************************************************************/
/* Function to print library calls                                           */
/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*  Function Name : memalign                                                 */
/*                                                                           */
/*  Description   : Returns malloc data. Ideally should return aligned memory*/
/*                  support alignment will be added later                    */
/*                                                                           */
/*  Inputs        : alignment i4_size                                        */
/*  Globals       :                                                          */
/*  Processing    :                                                          */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       :                                                          */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore          Initial Version                     */
/*                                                                           */
/*****************************************************************************/

void *ih264a_aligned_malloc(void *pv_ctxt, WORD32 alignment, WORD32 i4_size)
{
    (void) pv_ctxt;
    return (void *) _aligned_malloc(i4_size, alignment);
}

void ih264a_aligned_free(void *pv_ctxt, void *pv_buf)
{
    (void) pv_ctxt;
    _aligned_free(pv_buf);
    return;
}
#endif

#if IOS
void *ih264a_aligned_malloc(void *pv_ctxt, WORD32 alignment, WORD32 i4_size)
{
    (void) pv_ctxt;
    return malloc(i4_size);
}

void ih264a_aligned_free(void *pv_ctxt, void *pv_buf)
{
    (void) pv_ctxt;
    free(pv_buf);
}
#endif

#if(!defined(IOS)) && (!defined(_WIN32))
void *ih264a_aligned_malloc(void *pv_ctxt, WORD32 alignment, WORD32 i4_size)
{
    void *buf = NULL;
    (void) pv_ctxt;
    if(0 != posix_memalign(&buf, alignment, i4_size))
    {
        return NULL;
    }
    return buf;
}

void ih264a_aligned_free(void *pv_ctxt, void *pv_buf)
{
    (void) pv_ctxt;
    free(pv_buf);
}
#endif

void *ih264a_memory_alloc(UWORD32 u4_size) { return (malloc(u4_size)); }

void ih264a_memory_free(void *pv_mem) { free(pv_mem); }
/*****************************************************************************/
/*                                                                           */
/*  Function Name : set_degrade                                              */
/*                                                                           */
/*  Description   : Control call to set degrade level                        */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj  - Codec Handle                                */
/*                  type - degrade level value between 0 to 4                */
/*                    0 : No degrade                                         */
/*                    1st bit : Disable SAO                                  */
/*                    2nd bit : Disable Deblock                              */
/*                    3rd bit : Faster MC for non-ref                        */
/*                    4th bit : Fastest MC for non-ref                       */
/*                  pics - Pictures that are are degraded                    */
/*                    0 : No degrade                                         */
/*                    1 : Non-ref pictures                                   */
/*                    2 : Pictures at given interval are not degraded        */
/*                    3 : All non-key pictures                               */
/*                    4 : All pictures                                       */
/*  Globals       :                                                          */
/*  Processing    : Calls degrade control to the codec                       */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Control call return i4_status                            */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T set_degrade(void *codec_obj, UWORD32 type, WORD32 pics)
{
    isvcd_ctl_degrade_ip_t s_ctl_ip;
    isvcd_ctl_degrade_op_t s_ctl_op;
    void *pv_api_ip, *pv_api_op;
    IV_API_CALL_STATUS_T e_dec_status;

    s_ctl_ip.u4_size = sizeof(isvcd_ctl_degrade_ip_t);
    s_ctl_ip.i4_degrade_type = type;
    s_ctl_ip.i4_nondegrade_interval = 4;
    s_ctl_ip.i4_degrade_pics = pics;

    s_ctl_op.u4_size = sizeof(isvcd_ctl_degrade_op_t);

    pv_api_ip = (void *) &s_ctl_ip;
    pv_api_op = (void *) &s_ctl_op;

    s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
    s_ctl_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_DEGRADE;

    e_dec_status = ivd_api_function((iv_obj_t *) codec_obj, pv_api_ip, pv_api_op);

    if(IV_SUCCESS != e_dec_status)
    {
        printf("Error in setting degrade level \n");
    }
    return (e_dec_status);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : enable_skipb_frames                                      */
/*                                                                           */
/*  Description   : Control call to enable skipping of b frames              */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj : Codec handle                                 */
/*  Globals       :                                                          */
/*  Processing    : Calls enable skip B frames control                       */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Control call return i4_status                            */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T enable_skipb_frames(void *codec_obj, vid_dec_ctx_t *ps_app_ctx)
{
    isvcd_ctl_set_config_ip_t s_h264d_ctl_ip;
    isvcd_ctl_set_config_op_t s_h264d_ctl_op;
    ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
    ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
    IV_API_CALL_STATUS_T e_dec_status;

    ps_ctl_ip->u4_disp_wd = ps_app_ctx->u4_strd;
    ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_B;

    ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
    ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_FRAME;
    ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
    ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
    ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);
    ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

    e_dec_status = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                                    (void *) &s_h264d_ctl_op);

    if(IV_SUCCESS != e_dec_status)
    {
        printf("Error in Enable SkipB frames \n");
    }

    return e_dec_status;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : disable_skipb_frames                                     */
/*                                                                           */
/*  Description   : Control call to disable skipping of b frames             */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj : Codec handle                                 */
/*  Globals       :                                                          */
/*  Processing    : Calls disable B frame skip control                       */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Control call return i4_status                            */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T disable_skipb_frames(void *codec_obj, vid_dec_ctx_t *ps_app_ctx)
{
    isvcd_ctl_set_config_ip_t s_h264d_ctl_ip;
    isvcd_ctl_set_config_op_t s_h264d_ctl_op;
    ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
    ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
    IV_API_CALL_STATUS_T e_dec_status;

    ps_ctl_ip->u4_disp_wd = ps_app_ctx->u4_strd;
    ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;

    ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
    ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_FRAME;
    ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
    ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
    ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);
    ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

    e_dec_status = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                                    (void *) &s_h264d_ctl_op);

    if(IV_SUCCESS != e_dec_status)
    {
        printf("Error in Disable SkipB frames\n");
    }

    return e_dec_status;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : enable_skippb_frames                                     */
/*                                                                           */
/*  Description   : Control call to enable skipping of P & B frames          */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj : Codec handle                                 */
/*  Globals       :                                                          */
/*  Processing    : Calls enable skip P and B frames control                 */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Control call return i4_status                            */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T enable_skippb_frames(void *codec_obj, vid_dec_ctx_t *ps_app_ctx)
{
    isvcd_ctl_set_config_ip_t s_h264d_ctl_ip;
    isvcd_ctl_set_config_op_t s_h264d_ctl_op;
    ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
    ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
    IV_API_CALL_STATUS_T e_dec_status;

    ps_ctl_ip->u4_disp_wd = ps_app_ctx->u4_strd;
    ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_PB;

    ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
    ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_FRAME;
    ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
    ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
    ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);
    ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

    e_dec_status = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                                    (void *) &s_h264d_ctl_op);
    if(IV_SUCCESS != e_dec_status)
    {
        printf("Error in Enable SkipPB frames\n");
    }

    return e_dec_status;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : disable_skippb_frames                                    */
/*                                                                           */
/*  Description   : Control call to disable skipping of P and B frames       */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj : Codec handle                                 */
/*  Globals       :                                                          */
/*  Processing    : Calls disable P and B frame skip control                 */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Control call return i4_status                            */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T disable_skippb_frames(void *codec_obj, vid_dec_ctx_t *ps_app_ctx)
{
    isvcd_ctl_set_config_ip_t s_h264d_ctl_ip;
    isvcd_ctl_set_config_op_t s_h264d_ctl_op;
    ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
    ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
    IV_API_CALL_STATUS_T e_dec_status;

    ps_ctl_ip->u4_disp_wd = ps_app_ctx->u4_strd;
    ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;

    ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
    ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_FRAME;
    ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
    ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
    ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);
    ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

    e_dec_status = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                                    (void *) &s_h264d_ctl_op);
    if(IV_SUCCESS != e_dec_status)
    {
        printf("Error in Disable SkipPB frames\n");
    }

    return e_dec_status;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : release_disp_frame                                       */
/*                                                                           */
/*  Description   : Calls release display control - Used to signal to the    */
/*                  decoder that this particular buffer has been displayed   */
/*                  and that the codec is now free to write to this buffer   */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj : Codec Handle                                 */
/*                  buf_id    : Buffer Id of the buffer to be released       */
/*                              This id would have been returned earlier by  */
/*                              the codec                                    */
/*  Globals       :                                                          */
/*  Processing    : Calls Release Display call                               */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Status of release display call                           */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T release_disp_frame(void *codec_obj, UWORD32 buf_id)
{
    ivd_rel_display_frame_ip_t s_video_rel_disp_ip;
    ivd_rel_display_frame_op_t s_video_rel_disp_op;
    IV_API_CALL_STATUS_T e_dec_status;

    s_video_rel_disp_ip.e_cmd = IVD_CMD_REL_DISPLAY_FRAME;
    s_video_rel_disp_ip.u4_size = sizeof(ivd_rel_display_frame_ip_t);
    s_video_rel_disp_op.u4_size = sizeof(ivd_rel_display_frame_op_t);
    s_video_rel_disp_ip.u4_disp_buf_id = buf_id;

    e_dec_status = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_video_rel_disp_ip,
                                    (void *) &s_video_rel_disp_op);
    if(IV_SUCCESS != e_dec_status)
    {
        printf("Error in Release Disp frame\n");
    }

    return (e_dec_status);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : get_version                                      */
/*                                                                           */
/*  Description   : Control call to get codec version                        */
/*                                                                           */
/*                                                                           */
/*  Inputs        : codec_obj : Codec handle                                 */
/*  Globals       :                                                          */
/*  Processing    : Calls enable skip B frames control                       */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Control call return i4_status                            */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

IV_API_CALL_STATUS_T get_version(void *codec_obj)
{
    ivd_ctl_getversioninfo_ip_t ps_ctl_ip;
    ivd_ctl_getversioninfo_op_t ps_ctl_op;
    UWORD8 au1_buf[512];
    IV_API_CALL_STATUS_T i4_status;
    ps_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
    ps_ctl_ip.e_sub_cmd = IVD_CMD_CTL_GETVERSION;
    ps_ctl_ip.u4_size = sizeof(ivd_ctl_getversioninfo_ip_t);
    ps_ctl_op.u4_size = sizeof(ivd_ctl_getversioninfo_op_t);
    ps_ctl_ip.pv_version_buffer = au1_buf;
    ps_ctl_ip.u4_version_buffer_size = sizeof(au1_buf);

    i4_status =
        ivd_api_function((iv_obj_t *) codec_obj, (void *) &(ps_ctl_ip), (void *) &(ps_ctl_op));

    if(i4_status != IV_SUCCESS)
    {
        printf(
            "Error in Getting Version number e_dec_status = %d u4_error_code = "
            "%x\n",
            i4_status, ps_ctl_op.u4_error_code);
    }
    else
    {
        printf("Ittiam Decoder Version number: %s\n", (char *) ps_ctl_ip.pv_version_buffer);
    }
    return i4_status;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : codec_exit                                               */
/*                                                                           */
/*  Description   : handles unrecoverable errors                             */
/*  Inputs        : Error message                                            */
/*  Globals       : None                                                     */
/*  Processing    : Prints error message to console and exits.               */
/*  Outputs       : Error mesage to the console                              */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Kishore         Creation                             */
/*                                                                           */
/*****************************************************************************/
void codec_exit(CHAR *pc_err_message)
{
    printf("%s\n", pc_err_message);
    exit(-1);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : dump_output                                              */
/*                                                                           */
/*  Description   : Used to dump output YUV                                  */
/*  Inputs        : App context, disp output desc, File pointer              */
/*  Globals       : None                                                     */
/*  Processing    : Dumps to a file                                          */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Kishore         Creation                             */
/*                                                                           */
/*****************************************************************************/
void dump_output(vid_dec_ctx_t *ps_app_ctx, iv_yuv_buf_t *ps_disp_frm_buf,
                 isvcd_video_decode_op_t *ps_h264d_decode_op, UWORD32 u4_disp_frm_id,
                 FILE *ps_op_file, FILE *ps_qp_file, FILE *ps_mb_type_file, FILE *ps_op_chksum_file,
                 WORD32 i4_op_frm_ts, UWORD32 file_save, UWORD32 chksum_save, UWORD32 mbinfo_save)

{
    UWORD32 i;
    iv_yuv_buf_t s_dump_disp_frm_buf;
    UWORD32 u4_disp_id;

    memset(&s_dump_disp_frm_buf, 0, sizeof(iv_yuv_buf_t));

    if(ps_app_ctx->u4_share_disp_buf)
    {
        if(ps_app_ctx->dump_q_wr_idx == MAX_DISP_BUFFERS) ps_app_ctx->dump_q_wr_idx = 0;

        if(ps_app_ctx->dump_q_rd_idx == MAX_DISP_BUFFERS) ps_app_ctx->dump_q_rd_idx = 0;

        ps_app_ctx->s_disp_frm_queue[ps_app_ctx->dump_q_wr_idx] = *ps_disp_frm_buf;
        ps_app_ctx->s_disp_frm_id_queue[ps_app_ctx->dump_q_wr_idx] = u4_disp_frm_id;
        ps_app_ctx->dump_q_wr_idx++;

        if((WORD32) i4_op_frm_ts >= (WORD32) (ps_app_ctx->disp_delay - 1))
        {
            s_dump_disp_frm_buf = ps_app_ctx->s_disp_frm_queue[ps_app_ctx->dump_q_rd_idx];
            u4_disp_id = ps_app_ctx->s_disp_frm_id_queue[ps_app_ctx->dump_q_rd_idx];
            ps_app_ctx->dump_q_rd_idx++;
        }
        else
        {
            return;
        }
    }
    else
    {
        s_dump_disp_frm_buf = *ps_disp_frm_buf;
        u4_disp_id = u4_disp_frm_id;
    }

    release_disp_frame(ps_app_ctx->cocodec_obj, u4_disp_id);

    if(0 == file_save && 0 == chksum_save && 0 == mbinfo_save) return;

    if(0 != mbinfo_save)
    {
        UWORD8 *buf;
        if(ps_h264d_decode_op->pu1_8x8_blk_qp_map && ps_qp_file)
        {
            buf = ps_h264d_decode_op->pu1_8x8_blk_qp_map;
            fwrite(buf, 1, ps_h264d_decode_op->u4_8x8_blk_qp_map_size, ps_qp_file);
            fflush(ps_qp_file);
        }
        if(ps_h264d_decode_op->pu1_8x8_blk_type_map && ps_mb_type_file)
        {
            buf = ps_h264d_decode_op->pu1_8x8_blk_type_map;
            fwrite(buf, 1, ps_h264d_decode_op->u4_8x8_blk_type_map_size, ps_mb_type_file);
            fflush(ps_mb_type_file);
        }
    }
    if(NULL == s_dump_disp_frm_buf.pv_y_buf) return;

    if(ps_app_ctx->e_output_chroma_format == IV_YUV_420P)
    {
#if DUMP_SINGLE_BUF
        {
            UWORD8 *buf = s_dump_disp_frm_buf.pv_y_buf - 80 - (s_dump_disp_frm_buf.u4_y_strd * 80);

            UWORD32 i4_size = s_dump_disp_frm_buf.u4_y_strd * ((s_dump_disp_frm_buf.u4_y_ht + 160) +
                                                               (s_dump_disp_frm_buf.u4_u_ht + 80));
            fwrite(buf, 1, i4_size, ps_op_file);
        }
#else
        if(0 != file_save && ps_op_file)
        {
            UWORD8 *buf;

            buf = (UWORD8 *) s_dump_disp_frm_buf.pv_y_buf;
            for(i = 0; i < s_dump_disp_frm_buf.u4_y_ht; i++)
            {
                fwrite(buf, 1, s_dump_disp_frm_buf.u4_y_wd, ps_op_file);
                buf += s_dump_disp_frm_buf.u4_y_strd;
            }

            buf = (UWORD8 *) s_dump_disp_frm_buf.pv_u_buf;
            for(i = 0; i < s_dump_disp_frm_buf.u4_u_ht; i++)
            {
                fwrite(buf, 1, s_dump_disp_frm_buf.u4_u_wd, ps_op_file);
                buf += s_dump_disp_frm_buf.u4_u_strd;
            }
            buf = (UWORD8 *) s_dump_disp_frm_buf.pv_v_buf;
            for(i = 0; i < s_dump_disp_frm_buf.u4_v_ht; i++)
            {
                fwrite(buf, 1, s_dump_disp_frm_buf.u4_v_wd, ps_op_file);
                buf += s_dump_disp_frm_buf.u4_v_strd;
            }
        }

        if(0 != chksum_save && ps_op_chksum_file)
        {
            UWORD8 au1_y_chksum[16];
            UWORD8 au1_u_chksum[16];
            UWORD8 au1_v_chksum[16];
            calc_md5_cksum((UWORD8 *) s_dump_disp_frm_buf.pv_y_buf, s_dump_disp_frm_buf.u4_y_strd,
                           s_dump_disp_frm_buf.u4_y_wd, s_dump_disp_frm_buf.u4_y_ht, au1_y_chksum);
            calc_md5_cksum((UWORD8 *) s_dump_disp_frm_buf.pv_u_buf, s_dump_disp_frm_buf.u4_u_strd,
                           s_dump_disp_frm_buf.u4_u_wd, s_dump_disp_frm_buf.u4_u_ht, au1_u_chksum);
            calc_md5_cksum((UWORD8 *) s_dump_disp_frm_buf.pv_v_buf, s_dump_disp_frm_buf.u4_v_strd,
                           s_dump_disp_frm_buf.u4_v_wd, s_dump_disp_frm_buf.u4_v_ht, au1_v_chksum);

            fwrite(au1_y_chksum, sizeof(UWORD8), 16, ps_op_chksum_file);
            fwrite(au1_u_chksum, sizeof(UWORD8), 16, ps_op_chksum_file);
            fwrite(au1_v_chksum, sizeof(UWORD8), 16, ps_op_chksum_file);
        }
#endif
    }
    else if((ps_app_ctx->e_output_chroma_format == IV_YUV_420SP_UV) ||
            (ps_app_ctx->e_output_chroma_format == IV_YUV_420SP_VU))
    {
#if DUMP_SINGLE_BUF
        {
            UWORD8 *buf = s_dump_disp_frm_buf.pv_y_buf - 24 - (s_dump_disp_frm_buf.u4_y_strd * 40);

            UWORD32 i4_size = s_dump_disp_frm_buf.u4_y_strd * ((s_dump_disp_frm_buf.u4_y_ht + 80) +
                                                               (s_dump_disp_frm_buf.u4_u_ht + 40));
            fwrite(buf, 1, i4_size, ps_op_file);
        }
#else
        {
            UWORD8 *buf;

            buf = (UWORD8 *) s_dump_disp_frm_buf.pv_y_buf;
            for(i = 0; i < s_dump_disp_frm_buf.u4_y_ht; i++)
            {
                fwrite(buf, 1, s_dump_disp_frm_buf.u4_y_wd, ps_op_file);
                buf += s_dump_disp_frm_buf.u4_y_strd;
            }

            buf = (UWORD8 *) s_dump_disp_frm_buf.pv_u_buf;
            for(i = 0; i < s_dump_disp_frm_buf.u4_u_ht; i++)
            {
                fwrite(buf, 1, s_dump_disp_frm_buf.u4_u_wd, ps_op_file);
                buf += s_dump_disp_frm_buf.u4_u_strd;
            }
        }
#endif
    }
    else if(ps_app_ctx->e_output_chroma_format == IV_RGBA_8888)
    {
        UWORD8 *buf;

        buf = (UWORD8 *) s_dump_disp_frm_buf.pv_y_buf;
        for(i = 0; i < s_dump_disp_frm_buf.u4_y_ht; i++)
        {
            fwrite(buf, 1, s_dump_disp_frm_buf.u4_y_wd * 4, ps_op_file);
            buf += s_dump_disp_frm_buf.u4_y_strd * 4;
        }
    }
    else
    {
        UWORD8 *buf;

        buf = (UWORD8 *) s_dump_disp_frm_buf.pv_y_buf;
        for(i = 0; i < s_dump_disp_frm_buf.u4_y_ht; i++)
        {
            fwrite(buf, 1, s_dump_disp_frm_buf.u4_y_strd * 2, ps_op_file);
            buf += s_dump_disp_frm_buf.u4_y_strd * 2;
        }
    }

    fflush(ps_op_file);
    fflush(ps_op_chksum_file);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : print_usage                                              */
/*                                                                           */
/*  Description   : Prints argument format                                   */
/*                                                                           */
/*                                                                           */
/*  Inputs        :                                                          */
/*  Globals       :                                                          */
/*  Processing    : Prints argument format                                   */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       :                                                          */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

void print_usage(void)
{
    WORD32 i = 0;
    WORD32 num_entries = sizeof(argument_mapping) / sizeof(argument_t);
    printf("\nUsage:\n");
    while(i < num_entries)
    {
        printf("%-32s\t %s", argument_mapping[i].argument_name, argument_mapping[i].description);
        i++;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : get_argument                                             */
/*                                                                           */
/*  Description   : Gets argument for a given string                         */
/*                                                                           */
/*                                                                           */
/*  Inputs        : name                                                     */
/*  Globals       :                                                          */
/*  Processing    : Searches the given string in the array and returns       */
/*                  appropriate argument ID                                  */
/*                                                                           */
/*  Outputs       : Argument ID                                              */
/*  Returns       : Argument ID                                              */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

ARGUMENT_T get_argument(CHAR *name)
{
    WORD32 i = 0;
    WORD32 num_entries = sizeof(argument_mapping) / sizeof(argument_t);
    while(i < num_entries)
    {
        if((0 == strcmp(argument_mapping[i].argument_name, name)) ||
           ((0 == strcmp(argument_mapping[i].argument_shortname, name)) &&
            (0 != strcmp(argument_mapping[i].argument_shortname, "--"))))
        {
            return argument_mapping[i].argument;
        }
        i++;
    }
    return INVALID;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : get_argument                                             */
/*                                                                           */
/*  Description   : Gets argument for a given string                         */
/*                                                                           */
/*                                                                           */
/*  Inputs        : name                                                     */
/*  Globals       :                                                          */
/*  Processing    : Searches the given string in the array and returns       */
/*                  appropriate argument ID                                  */
/*                                                                           */
/*  Outputs       : Argument ID                                              */
/*  Returns       : Argument ID                                              */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

void parse_argument(vid_dec_ctx_t *ps_app_ctx, CHAR *argument, CHAR *value)
{
    ARGUMENT_T arg;

    arg = get_argument(argument);
    switch(arg)
    {
        case HELP:
            print_usage();
            exit(-1);
        case VERSION:
            break;
        case INPUT_FILE:
            sscanf(value, "%" STR(STRLENGTH) "s", ps_app_ctx->ac_ip_fname);
            // input_passed = 1;
            break;

        case OUTPUT:
            sscanf(value, "%" STR(STRLENGTH) "s", ps_app_ctx->ac_op_fname);
            break;

        case QP_MAP_FILE:
            sscanf(value, "%" STR(STRLENGTH) "s", ps_app_ctx->ac_qp_map_fname);
            break;

        case BLK_TYPE_MAP_FILE:
            sscanf(value, "%" STR(STRLENGTH) "s", ps_app_ctx->ac_blk_type_map_fname);
            break;

        case CHKSUM:
            sscanf(value, "%" STR(STRLENGTH) "s", ps_app_ctx->ac_op_chksum_fname);
            break;

        case SAVE_OUTPUT:
            sscanf(value, "%d", &ps_app_ctx->u4_file_save_flag);
            break;

        case SAVE_FRAME_INFO:
            sscanf(value, "%d", &ps_app_ctx->u4_frame_info_enable);
            break;

        case SAVE_CHKSUM:
            sscanf(value, "%d", &ps_app_ctx->u4_chksum_save_flag);
            break;

        case CHROMA_FORMAT:
            if((strcmp(value, "YUV_420P")) == 0)
                ps_app_ctx->e_output_chroma_format = IV_YUV_420P;
            else if((strcmp(value, "YUV_422ILE")) == 0)
                ps_app_ctx->e_output_chroma_format = IV_YUV_422ILE;
            else if((strcmp(value, "RGB_565")) == 0)
                ps_app_ctx->e_output_chroma_format = IV_RGB_565;
            else if((strcmp(value, "RGBA_8888")) == 0)
                ps_app_ctx->e_output_chroma_format = IV_RGBA_8888;
            else if((strcmp(value, "YUV_420SP_UV")) == 0)
                ps_app_ctx->e_output_chroma_format = IV_YUV_420SP_UV;
            else if((strcmp(value, "YUV_420SP_VU")) == 0)
                ps_app_ctx->e_output_chroma_format = IV_YUV_420SP_VU;
            else
            {
                printf("\nInvalid colour format setting it to IV_YUV_420P\n");
                ps_app_ctx->e_output_chroma_format = IV_YUV_420P;
            }

            break;
        case NUM_FRAMES:
            sscanf(value, "%d", &ps_app_ctx->u4_max_frm_ts);
            break;

        case NUM_CORES:
            sscanf(value, "%d", &ps_app_ctx->u4_num_cores);
            break;
        case DEGRADE_PICS:
            sscanf(value, "%d", &ps_app_ctx->i4_degrade_pics);
            break;
        case DEGRADE_TYPE:
            sscanf(value, "%d", &ps_app_ctx->i4_degrade_type);
            break;
        case SHARE_DISPLAY_BUF:
            sscanf(value, "%d", &ps_app_ctx->u4_share_disp_buf);
            break;
        case LOOPBACK:
            sscanf(value, "%d", &ps_app_ctx->loopback);
            break;
        case DISPLAY:
#if defined(SDL_DISPLAY) || defined(FBDEV_DISPLAY) || defined(INTEL_CE5300) || defined(IOS_DISPLAY)
            sscanf(value, "%d", &ps_app_ctx->display);
#else
            ps_app_ctx->display = 0;
#endif
            break;
        case FULLSCREEN:
            sscanf(value, "%d", &ps_app_ctx->full_screen);
            break;
        case FPS:
            sscanf(value, "%d", &ps_app_ctx->fps);
            if(ps_app_ctx->fps <= 0) ps_app_ctx->fps = DEFAULT_FPS;
            break;
        case ARCH:
            if((strcmp(value, "ARM_NONEON")) == 0)
                ps_app_ctx->e_arch = ARCH_ARM_NONEON;
            else if((strcmp(value, "ARM_A9Q")) == 0)
                ps_app_ctx->e_arch = ARCH_ARM_A9Q;
            else if((strcmp(value, "ARM_A7")) == 0)
                ps_app_ctx->e_arch = ARCH_ARM_A7;
            else if((strcmp(value, "ARM_A5")) == 0)
                ps_app_ctx->e_arch = ARCH_ARM_A5;
            else if((strcmp(value, "ARM_NEONINTR")) == 0)
                ps_app_ctx->e_arch = ARCH_ARM_NEONINTR;
            else if((strcmp(value, "X86_GENERIC")) == 0)
                ps_app_ctx->e_arch = ARCH_X86_GENERIC;
            else if((strcmp(value, "X86_SSSE3")) == 0)
                ps_app_ctx->e_arch = ARCH_X86_SSSE3;
            else if((strcmp(value, "X86_SSE42")) == 0)
                ps_app_ctx->e_arch = ARCH_X86_SSE42;
            else if((strcmp(value, "X86_AVX2")) == 0)
                ps_app_ctx->e_arch = ARCH_X86_AVX2;
            else if((strcmp(value, "MIPS_GENERIC")) == 0)
                ps_app_ctx->e_arch = ARCH_MIPS_GENERIC;
            else if((strcmp(value, "MIPS_32")) == 0)
                ps_app_ctx->e_arch = ARCH_MIPS_32;
            else if((strcmp(value, "ARMV8_GENERIC")) == 0)
                ps_app_ctx->e_arch = ARCH_ARMV8_GENERIC;
            else
            {
                printf("\nInvalid Arch. Setting it to ARM_A9Q\n");
                ps_app_ctx->e_arch = ARCH_ARM_A9Q;
            }

            break;
        case SOC:
            if((strcmp(value, "GENERIC")) == 0)
                ps_app_ctx->e_soc = SOC_GENERIC;
            else if((strcmp(value, "HISI_37X")) == 0)
                ps_app_ctx->e_soc = SOC_HISI_37X;
            else
            {
                ps_app_ctx->e_soc = atoi(value);
                /*
                                printf("\nInvalid SOC. Setting it to GENERIC\n");
                                ps_app_ctx->e_soc = SOC_GENERIC;
                */
            }
            break;
        case PICLEN:
            sscanf(value, "%d", &ps_app_ctx->u4_piclen_flag);
            break;

        case PICLEN_FILE:
            sscanf(value, "%" STR(STRLENGTH) "s", ps_app_ctx->ac_piclen_fname);
            break;
        case DISABLE_DEBLOCK_LEVEL:
            sscanf(value, "%d", &ps_app_ctx->u4_disable_dblk_level);
            break;

        case TARGET_LAYER_ID:
            sscanf(value, "%d", &ps_app_ctx->i4_target_layer_id);
            break;

        case INVALID:
        default:
            printf("Ignoring argument :  %s\n", argument);
            break;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : read_cfg_file                                            */
/*                                                                           */
/*  Description   : Reads arguments from a configuration file                */
/*                                                                           */
/*                                                                           */
/*  Inputs        : ps_app_ctx  : Application context                        */
/*                  fp_cfg_file : Configuration file handle                  */
/*  Globals       :                                                          */
/*  Processing    : Parses the arguments and fills in the application context*/
/*                                                                           */
/*  Outputs       : Arguments parsed                                         */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

void read_cfg_file(vid_dec_ctx_t *ps_app_ctx, FILE *fp_cfg_file)
{
    CHAR line[STRLENGTH];
    CHAR description[STRLENGTH];
    CHAR value[STRLENGTH];
    CHAR argument[STRLENGTH];
    void *ret;
    while(0 == feof(fp_cfg_file))
    {
        line[0] = '\0';
        ret = fgets(line, STRLENGTH, fp_cfg_file);
        if(NULL == ret) break;
        argument[0] = '\0';
        /* Reading Input File Name */
        sscanf(line, "%s %s %s", argument, value, description);
        if(argument[0] == '\0') continue;

        parse_argument(ps_app_ctx, argument, value);
    }
}

/*!
**************************************************************************
* \if Function name : dispq_producer_dequeue \endif
*
* \brief
*    This function gets a free buffer index where display data can be written
*    This is a blocking call and can be exited by setting quit to true in
*    the application context
*
* \param[in]  ps_app_ctx  : Pointer to application context
*
* \return
*    returns Next free buffer index for producer
*
* \author
*  Ittiam
*
**************************************************************************
*/
WORD32 dispq_producer_dequeue(vid_dec_ctx_t *ps_app_ctx)
{
    WORD32 idx;

    /* If there is no free buffer wait */

    while(((ps_app_ctx->disp_q_wr_idx + 1) % NUM_DISPLAY_BUFFERS) == ps_app_ctx->disp_q_rd_idx)
    {
        ithread_sleep(1000);

        if(ps_app_ctx->quit) return (-1);
    }

    idx = ps_app_ctx->disp_q_wr_idx;
    return (idx);
}

/*!
**************************************************************************
* \if Function name : dispq_producer_queue \endif
*
* \brief
*    This function adds buffer which can be displayed
*
* \param[in]  ps_app_ctx  : Pointer to application context
*
* \return
*    returns Next free buffer index for producer
*
* \author
*  Ittiam
*
**************************************************************************
*/
WORD32 dispq_producer_queue(vid_dec_ctx_t *ps_app_ctx)
{
    ps_app_ctx->disp_q_wr_idx++;
    if(ps_app_ctx->disp_q_wr_idx == NUM_DISPLAY_BUFFERS) ps_app_ctx->disp_q_wr_idx = 0;

    return (0);
}
/*!
**************************************************************************
* \if Function name : dispq_consumer_dequeue \endif
*
* \brief
*    This function gets a free buffer index where display data can be written
*    This is a blocking call and can be exited by setting quit to true in
*    the application context
*
* \param[in]  ps_app_ctx  : Pointer to application context
*
* \return
*    returns Next free buffer index for producer
*
* \author
*  Ittiam
*
**************************************************************************
*/
WORD32 dispq_consumer_dequeue(vid_dec_ctx_t *ps_app_ctx)
{
    WORD32 idx;

    /* If there is no free buffer wait */

    while(ps_app_ctx->disp_q_wr_idx == ps_app_ctx->disp_q_rd_idx)
    {
        ithread_sleep(1000);

        if(ps_app_ctx->quit) return (-1);
    }

    idx = ps_app_ctx->disp_q_rd_idx;
    return (idx);
}

/*!
**************************************************************************
* \if Function name : dispq_producer_queue \endif
*
* \brief
*    This function adds buffer which can be displayed
*
* \param[in]  ps_app_ctx  : Pointer to application context
*
* \return
*    returns Next free buffer index for producer
*
* \author
*  Ittiam
*
**************************************************************************
*/
WORD32 dispq_consumer_queue(vid_dec_ctx_t *ps_app_ctx)
{
    ps_app_ctx->disp_q_rd_idx++;
    if(ps_app_ctx->disp_q_rd_idx == NUM_DISPLAY_BUFFERS) ps_app_ctx->disp_q_rd_idx = 0;

    return (0);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : display_thread                                           */
/*                                                                           */
/*  Description   : Thread to display the frame                              */
/*                                                                           */
/*                                                                           */
/*  Inputs        : pv_ctx  : Application context                            */
/*                                                                           */
/*  Globals       :                                                          */
/*  Processing    : Wait for a buffer to get produced by decoder and display */
/*                  that frame                                               */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        : Pause followed by quit is making some deadlock condn     */
/*                  If decoder was lagging initially and then fasten up,     */
/*                  display will also go at faster rate till it reaches      */
/*                  equilibrium wrt the initial time                         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*                                                                           */
/*****************************************************************************/

WORD32 display_thread(void *pv_ctx)
{
    vid_dec_ctx_t *ps_app_ctx = (vid_dec_ctx_t *) pv_ctx;

    UWORD32 frm_duration; /* in us */
    UWORD32 current_time = 0;
    UWORD32 expected_time;
    UWORD32 first_frame_displayed;

#ifdef WINDOWS_TIMER
    LARGE_INTEGER frequency;
#endif

#ifdef WINDOWS_TIMER
    QueryPerformanceFrequency(&frequency);
#endif

#ifdef PROFILE_ENABLE
    UWORD32 s_elapsed_time;
    TIMER s_start_timer;
    TIMER s_end_timer;
    TIMER s_first_frame_time;
#endif

    first_frame_displayed = 0;
    expected_time = 0;
    frm_duration = 1000000 / ps_app_ctx->fps;

    /* Init display and allocate display buffers */
    ps_app_ctx->pv_disp_ctx = (void *) ps_app_ctx->disp_init(
        ps_app_ctx->u4_pic_wd, ps_app_ctx->u4_pic_ht, ps_app_ctx->i4_screen_wd,
        ps_app_ctx->i4_screen_ht, ps_app_ctx->u4_pic_wd, ps_app_ctx->u4_pic_ht,
        ps_app_ctx->full_screen, &ps_app_ctx->quit, &ps_app_ctx->paused);
    ps_app_ctx->alloc_disp_buffers(ps_app_ctx->pv_disp_ctx);

    ps_app_ctx->display_init_done = 1;

    while(1)
    {
        WORD32 rd_idx;

        rd_idx = dispq_consumer_dequeue(ps_app_ctx);
        if(ps_app_ctx->quit) break;

        ps_app_ctx->display_buffer(ps_app_ctx->pv_disp_ctx, rd_idx);

        if(0 == first_frame_displayed)
        {
            GETTIME(&s_first_frame_time);
            first_frame_displayed = 1;
        }

        /*********************************************************************/
        /* Sleep based on the expected time of arrival of current buffer and */
        /* the Current frame                                                 */
        /*********************************************************************/

        GETTIME(&s_end_timer);
        ELAPSEDTIME(s_first_frame_time, s_end_timer, current_time, frequency);

        /* time in micro second */
        expected_time += frm_duration;

        // printf("current_time %d expected_time %d diff %d \n", current_time,
        // expected_time, (expected_time - current_time));
        /* sleep for the diff. in time */
        if(current_time < expected_time)
            ps_app_ctx->disp_usleep((expected_time - current_time));
        else
            expected_time += (current_time - expected_time);

        dispq_consumer_queue(ps_app_ctx);
    }

    while(0 == ps_app_ctx->display_deinit_flag)
    {
        ps_app_ctx->disp_usleep(1000);
    }
    ps_app_ctx->disp_deinit(ps_app_ctx->pv_disp_ctx);

    return 0;
}

void output_write_stall(CHAR *fname, UWORD32 cur_frm_idx)
{
    const UWORD8 threshold = 64;
    CHAR past_fname[1000];
    FILE *fp_fast_file = NULL;

    if(cur_frm_idx >= threshold)
    {
        sprintf(past_fname, fname, cur_frm_idx - threshold);
        do
        {
            fp_fast_file = fopen(past_fname, "rb");
            if(fp_fast_file != NULL)
            {
                fclose(fp_fast_file);
                /* Wait until the resource is released by a third party app*/
                ithread_sleep(5000);
            }
            else
                break;
        } while(1);
    }
}

void flush_output(iv_obj_t *codec_obj, vid_dec_ctx_t *ps_app_ctx, ivd_out_bufdesc_t *ps_out_buf,
                  UWORD8 *pu1_bs_buf, UWORD32 *pu4_op_frm_ts, FILE *ps_op_file, FILE *ps_qp_file,
                  FILE *ps_mb_type_file, UWORD8 *pu1_qp_map_buf, UWORD8 *pu1_blk_type_map_buf,
                  FILE *ps_op_chksum_file, UWORD32 u4_ip_frm_ts, UWORD32 u4_bytes_remaining)
{
    WORD32 ret;

    do
    {
        ivd_ctl_flush_ip_t s_ctl_ip;
        ivd_ctl_flush_op_t s_ctl_op;

        if(*pu4_op_frm_ts >= (ps_app_ctx->u4_max_frm_ts + ps_app_ctx->disp_delay)) break;

        s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
        s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH;
        s_ctl_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);
        s_ctl_op.u4_size = sizeof(ivd_ctl_flush_op_t);
        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_ip, (void *) &s_ctl_op);

        if(ret != IV_SUCCESS)
        {
            printf("Error in Setting the decoder in flush mode\n");
        }

        if(IV_SUCCESS == ret)
        {
            isvcd_video_decode_ip_t s_h264d_decode_ip;
            isvcd_video_decode_op_t s_h264d_decode_op;
            ivd_video_decode_ip_t *ps_video_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;
            ivd_video_decode_op_t *ps_video_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;

            ps_video_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;
            ps_video_decode_ip->u4_ts = u4_ip_frm_ts;
            ps_video_decode_ip->pv_stream_buffer = pu1_bs_buf;
            ps_video_decode_ip->u4_num_Bytes = u4_bytes_remaining;
            ps_video_decode_ip->u4_size = sizeof(isvcd_video_decode_ip_t);
            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[0] =
                ps_out_buf->u4_min_out_buf_size[0];
            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[1] =
                ps_out_buf->u4_min_out_buf_size[1];
            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[2] =
                ps_out_buf->u4_min_out_buf_size[2];

            ps_video_decode_ip->s_out_buffer.pu1_bufs[0] = ps_out_buf->pu1_bufs[0];
            ps_video_decode_ip->s_out_buffer.pu1_bufs[1] = ps_out_buf->pu1_bufs[1];
            ps_video_decode_ip->s_out_buffer.pu1_bufs[2] = ps_out_buf->pu1_bufs[2];
            ps_video_decode_ip->s_out_buffer.u4_num_bufs = ps_out_buf->u4_num_bufs;

            ps_video_decode_op->u4_size = sizeof(isvcd_video_decode_op_t);
            s_h264d_decode_ip.pu1_8x8_blk_qp_map = pu1_qp_map_buf;
            s_h264d_decode_ip.pu1_8x8_blk_type_map = pu1_blk_type_map_buf;
            s_h264d_decode_ip.u4_8x8_blk_qp_map_size = (ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
            s_h264d_decode_ip.u4_8x8_blk_type_map_size = (ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;

            /*****************************************************************************/
            /*   API Call: Video Decode */
            /*****************************************************************************/
            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_decode_ip,
                                   (void *) &s_h264d_decode_op);

            if(1 == ps_video_decode_op->u4_output_present)
            {
                CHAR cur_fname[1000];
                CHAR *extn = NULL;
                /* The objective is to dump the decoded frames into separate files
                 * instead of dumping all the frames in one common file. Also, the
                 * number of dumped frames at any given instance of time cannot exceed
                 * 'frame_memory'
                 */

                /*************************************************************************/
                /* Get SEI MDCV parameters */
                /*************************************************************************/
                if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_mdcv_params_present_flag)
                {
                    isvcd_ctl_get_sei_mdcv_params_ip_t s_ctl_get_sei_mdcv_params_ip;
                    isvcd_ctl_get_sei_mdcv_params_op_t s_ctl_get_sei_mdcv_params_op;

                    memset(&s_ctl_get_sei_mdcv_params_ip, 0,
                           sizeof(isvcd_ctl_get_sei_mdcv_params_ip_t));
                    memset(&s_ctl_get_sei_mdcv_params_op, 0,
                           sizeof(isvcd_ctl_get_sei_mdcv_params_op_t));

                    s_ctl_get_sei_mdcv_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                    s_ctl_get_sei_mdcv_params_ip.e_sub_cmd =
                        (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_MDCV_PARAMS;
                    s_ctl_get_sei_mdcv_params_ip.u4_size =
                        sizeof(isvcd_ctl_get_sei_mdcv_params_ip_t);
                    s_ctl_get_sei_mdcv_params_op.u4_size =
                        sizeof(isvcd_ctl_get_sei_mdcv_params_op_t);

                    ret = ivd_api_function((iv_obj_t *) codec_obj,
                                           (void *) &s_ctl_get_sei_mdcv_params_ip,
                                           (void *) &s_ctl_get_sei_mdcv_params_op);

                    if(IV_SUCCESS != ret)
                    {
                        printf("MDCV SEI params not present : Error %x\n",
                               s_ctl_get_sei_mdcv_params_op.u4_error_code);
                    }
                }
                /*************************************************************************/
                /* Get SEI CLL parameters */
                /*************************************************************************/
                if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_cll_params_present_flag)
                {
                    isvcd_ctl_get_sei_cll_params_ip_t s_ctl_get_sei_cll_params_ip;
                    isvcd_ctl_get_sei_cll_params_op_t s_ctl_get_sei_cll_params_op;

                    memset(&s_ctl_get_sei_cll_params_ip, 0,
                           sizeof(isvcd_ctl_get_sei_cll_params_ip_t));
                    memset(&s_ctl_get_sei_cll_params_op, 0,
                           sizeof(isvcd_ctl_get_sei_cll_params_op_t));

                    s_ctl_get_sei_cll_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                    s_ctl_get_sei_cll_params_ip.e_sub_cmd =
                        (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_CLL_PARAMS;
                    s_ctl_get_sei_cll_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_cll_params_ip_t);
                    s_ctl_get_sei_cll_params_op.u4_size = sizeof(isvcd_ctl_get_sei_cll_params_op_t);

                    ret = ivd_api_function((iv_obj_t *) codec_obj,
                                           (void *) &s_ctl_get_sei_cll_params_ip,
                                           (void *) &s_ctl_get_sei_cll_params_op);

                    if(IV_SUCCESS != ret)
                    {
                        printf("CLL SEI params not present : Error %x\n",
                               s_ctl_get_sei_cll_params_op.u4_error_code);
                    }
                }
                /*************************************************************************/
                /* Get SEI AVE parameters */
                /*************************************************************************/
                if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_ave_params_present_flag)
                {
                    isvcd_ctl_get_sei_ave_params_ip_t s_ctl_get_sei_ave_params_ip;
                    isvcd_ctl_get_sei_ave_params_op_t s_ctl_get_sei_ave_params_op;

                    memset(&s_ctl_get_sei_ave_params_ip, 0,
                           sizeof(isvcd_ctl_get_sei_ave_params_ip_t));
                    memset(&s_ctl_get_sei_ave_params_op, 0,
                           sizeof(isvcd_ctl_get_sei_ave_params_op_t));

                    s_ctl_get_sei_ave_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                    s_ctl_get_sei_ave_params_ip.e_sub_cmd =
                        (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_AVE_PARAMS;
                    s_ctl_get_sei_ave_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_ave_params_ip_t);
                    s_ctl_get_sei_ave_params_op.u4_size = sizeof(isvcd_ctl_get_sei_ave_params_op_t);

                    ret = ivd_api_function((iv_obj_t *) codec_obj,
                                           (void *) &s_ctl_get_sei_ave_params_ip,
                                           (void *) &s_ctl_get_sei_ave_params_op);

                    if(IV_SUCCESS != ret)
                    {
                        printf("AVE SEI params not present : Error %x\n",
                               s_ctl_get_sei_ave_params_op.u4_error_code);
                    }
                }
                /*************************************************************************/
                /* Get SEI CCV parameters */
                /*************************************************************************/
                if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_ccv_params_present_flag)
                {
                    isvcd_ctl_get_sei_ccv_params_ip_t s_ctl_get_sei_ccv_params_ip;
                    isvcd_ctl_get_sei_ccv_params_op_t s_ctl_get_sei_ccv_params_op;

                    memset(&s_ctl_get_sei_ccv_params_ip, 0,
                           sizeof(isvcd_ctl_get_sei_ccv_params_ip_t));
                    memset(&s_ctl_get_sei_ccv_params_op, 0,
                           sizeof(isvcd_ctl_get_sei_ccv_params_op_t));

                    s_ctl_get_sei_ccv_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                    s_ctl_get_sei_ccv_params_ip.e_sub_cmd =
                        (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_CCV_PARAMS;
                    s_ctl_get_sei_ccv_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_ccv_params_ip_t);
                    s_ctl_get_sei_ccv_params_op.u4_size = sizeof(isvcd_ctl_get_sei_ccv_params_op_t);

                    ret = ivd_api_function((iv_obj_t *) codec_obj,
                                           (void *) &s_ctl_get_sei_ccv_params_ip,
                                           (void *) &s_ctl_get_sei_ccv_params_op);

                    if(IV_SUCCESS != ret)
                    {
                        printf("CCV SEI params not present : Error %x\n",
                               s_ctl_get_sei_ccv_params_op.u4_error_code);
                    }
                }

                if(ps_app_ctx->u4_file_save_flag)
                {
                    /* Locate the position of extension yuv */
                    extn = strstr(ps_app_ctx->ac_op_fname, "%d");
                    if(extn != NULL)
                    {
                        output_write_stall(ps_app_ctx->ac_op_fname, *pu4_op_frm_ts);
                        /* Generate output file names */
                        sprintf(cur_fname, ps_app_ctx->ac_op_fname, *pu4_op_frm_ts);
                        /* Open Output file */
                        ps_op_file = fopen(cur_fname, "wb");
                        if(NULL == ps_op_file)
                        {
                            CHAR ac_error_str[STRLENGTH];
                            snprintf(ac_error_str, sizeof(ac_error_str),
                                     "Could not open output file %s", cur_fname);

                            codec_exit(ac_error_str);
                        }
                    }
                }

                dump_output(ps_app_ctx, &(ps_video_decode_op->s_disp_frm_buf), &s_h264d_decode_op,
                            ps_video_decode_op->u4_disp_buf_id, ps_op_file, ps_qp_file,
                            ps_mb_type_file, ps_op_chksum_file, *pu4_op_frm_ts,
                            ps_app_ctx->u4_file_save_flag, ps_app_ctx->u4_chksum_save_flag,
                            ps_app_ctx->u4_frame_info_enable);
                if(extn != NULL) fclose(ps_op_file);
                (*pu4_op_frm_ts)++;
            }
        }
    } while(IV_SUCCESS == ret);
}

#ifdef X86_MINGW
void sigsegv_handler()
{
    printf("Segmentation fault, Exiting.. \n");
    exit(-1);
}
#endif

UWORD32 default_get_stride(void) { return 0; }

IV_COLOR_FORMAT_T default_get_color_fmt(void) { return IV_YUV_420P; }
/*****************************************************************************/
/*                                                                           */
/*  Function Name : main                                                     */
/*                                                                           */
/*  Description   : Application to demonstrate codec API                     */
/*                                                                           */
/*                                                                           */
/*  Inputs        : argc    - Number of arguments                            */
/*                  argv[]  - Arguments                                      */
/*  Globals       :                                                          */
/*  Processing    : Shows how to use create, process, control and delete     */
/*                                                                           */
/*  Outputs       : Codec output in a file                                   */
/*  Returns       :                                                          */
/*                                                                           */
/*  Issues        : Assumes both PROFILE_ENABLE to be                        */
/*                  defined for multithread decode-display working           */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes                              */
/*         06 09 2021   Kishore         Initial Version                      */
/*****************************************************************************/
#ifdef IOS
int h264dec_main(char *homedir, char *documentdir, int screen_wd, int screen_ht)
#else
int main(WORD32 argc, CHAR *argv[])
#endif
{
    CHAR ac_cfg_fname[STRLENGTH];
    FILE *fp_cfg_file = NULL;
    FILE *ps_piclen_file = NULL;
    FILE *ps_ip_file = NULL;
    FILE *ps_op_file = NULL;
    FILE *ps_qp_file = NULL;
    FILE *ps_mb_type_file = NULL;
    FILE *ps_op_chksum_file = NULL;
    WORD32 ret;
    CHAR ac_error_str[STRLENGTH];
    vid_dec_ctx_t s_app_ctx;
    UWORD8 *pu1_bs_buf = NULL;
    UWORD8 *pu1_qp_map_buf = NULL;
    UWORD8 *pu1_blk_type_map_buf = NULL;

    ivd_out_bufdesc_t *ps_out_buf;
    UWORD32 u4_num_bytes_dec = 0;
    UWORD32 file_pos = 0;

    UWORD32 u4_ip_frm_ts = 0, u4_op_frm_ts = 0;

    WORD32 u4_bytes_remaining = 0;
    UWORD32 i;
    UWORD32 u4_ip_buf_len;
    WORD32 total_bytes_comsumed;
    UWORD32 max_op_frm_ts;
    UWORD32 u4_num_disp_bufs_with_dec;

#ifdef PROFILE_ENABLE
    UWORD32 u4_tot_cycles = 0;
    UWORD32 frm_cnt = 0;
    UWORD32 u4_tot_fmt_cycles = 0;
    UWORD32 peak_window[PEAK_WINDOW_SIZE];
    UWORD32 peak_window_idx = 0;
    UWORD32 peak_avg_max = 0;
#ifdef INTEL_CE5300
    UWORD32 time_consumed = 0;
    UWORD32 bytes_consumed = 0;
#endif
#endif

#ifdef WINDOWS_TIMER
    LARGE_INTEGER frequency;
#endif
#ifdef PROFILE_ENABLE
    WORD32 width = 0, height = 0;
#endif
    iv_obj_t *codec_obj;
#if defined(GPU_BUILD) && !defined(X86)
//    int ioctl_init();
//    ioctl_init();
#endif

#ifdef X86_MINGW
    // For getting printfs without any delay
    setvbuf(stdout, NULL, _IONBF, 0);
    setvbuf(stderr, NULL, _IONBF, 0);
#endif
#ifdef IOS
    sprintf(filename_trace, "%s/iostrace.txt", homedir);
    printf("\ntrace file name = %s", filename_trace);
#endif

#ifdef X86_MINGW
    {
        signal(SIGSEGV, sigsegv_handler);
    }
#endif

#ifndef IOS
    /* Usage */
    if(argc < 2)
    {
        printf("Using test.cfg as configuration file \n");
        strcpy(ac_cfg_fname, "test.cfg");
    }
    else if(argc == 2)
    {
        strcpy(ac_cfg_fname, argv[1]);
    }

#else
    strcpy(ac_cfg_fname, "test.cfg");

#endif

    /***********************************************************************/
    /*                  Initialize Application parameters                  */
    /***********************************************************************/

    strcpy(s_app_ctx.ac_ip_fname, "\0");
    s_app_ctx.dump_q_wr_idx = 0;
    s_app_ctx.dump_q_rd_idx = 0;
    s_app_ctx.display_thread_created = 0;
    s_app_ctx.disp_q_wr_idx = 0;
    s_app_ctx.disp_q_rd_idx = 0;
    s_app_ctx.disp_delay = 0;
    s_app_ctx.loopback = 0;
    s_app_ctx.display = 0;
    s_app_ctx.full_screen = 0;
    s_app_ctx.u4_piclen_flag = 0;
    s_app_ctx.fps = DEFAULT_FPS;
    file_pos = 0;
    total_bytes_comsumed = 0;
    u4_ip_frm_ts = 0;
    u4_op_frm_ts = 0;
#ifdef PROFILE_ENABLE
    memset(peak_window, 0, sizeof(WORD32) * PEAK_WINDOW_SIZE);
#endif
    s_app_ctx.u4_share_disp_buf = DEFAULT_SHARE_DISPLAY_BUF;
    s_app_ctx.u4_num_cores = DEFAULT_NUM_CORES;
    s_app_ctx.i4_degrade_type = 0;
    s_app_ctx.i4_degrade_pics = 0;
    s_app_ctx.e_arch = ARCH_ARM_A9Q;
    s_app_ctx.e_soc = SOC_GENERIC;
    s_app_ctx.i4_target_layer_id = 0;

    s_app_ctx.u4_strd = STRIDE;

    s_app_ctx.display_thread_handle = malloc(ithread_get_handle_size());
    s_app_ctx.quit = 0;
    s_app_ctx.paused = 0;
    // s_app_ctx.u4_output_present = 0;
    s_app_ctx.u4_chksum_save_flag = 0;
    s_app_ctx.u4_frame_info_enable = 0;

    s_app_ctx.get_stride = &default_get_stride;

    s_app_ctx.get_color_fmt = &default_get_color_fmt;

    /* Set function pointers for display */
#ifdef SDL_DISPLAY
    s_app_ctx.disp_init = &sdl_disp_init;
    s_app_ctx.alloc_disp_buffers = &sdl_alloc_disp_buffers;
    s_app_ctx.display_buffer = &sdl_display;
    s_app_ctx.set_disp_buffers = &sdl_set_disp_buffers;
    s_app_ctx.disp_deinit = &sdl_disp_deinit;
    s_app_ctx.disp_usleep = &sdl_disp_usleep;
    s_app_ctx.get_color_fmt = &sdl_get_color_fmt;
    s_app_ctx.get_stride = &sdl_get_stride;
#endif

#ifdef FBDEV_DISPLAY
    s_app_ctx.disp_init = &fbd_disp_init;
    s_app_ctx.alloc_disp_buffers = &fbd_alloc_disp_buffers;
    s_app_ctx.display_buffer = &fbd_display;
    s_app_ctx.set_disp_buffers = &fbd_set_disp_buffers;
    s_app_ctx.disp_deinit = &fbd_disp_deinit;
    s_app_ctx.disp_usleep = &fbd_disp_usleep;
    s_app_ctx.get_color_fmt = &fbd_get_color_fmt;
    s_app_ctx.get_stride = &fbd_get_stride;
#endif

#ifdef INTEL_CE5300
    s_app_ctx.disp_init = &gdl_disp_init;
    s_app_ctx.alloc_disp_buffers = &gdl_alloc_disp_buffers;
    s_app_ctx.display_buffer = &gdl_display;
    s_app_ctx.set_disp_buffers = &gdl_set_disp_buffers;
    s_app_ctx.disp_deinit = &gdl_disp_deinit;
    s_app_ctx.disp_usleep = &gdl_disp_usleep;
    s_app_ctx.get_color_fmt = &gdl_get_color_fmt;
    s_app_ctx.get_stride = &gdl_get_stride;
#endif

#ifdef IOS_DISPLAY
    s_app_ctx.disp_init = &ios_disp_init;
    s_app_ctx.alloc_disp_buffers = &ios_alloc_disp_buffers;
    s_app_ctx.display_buffer = &ios_display;
    s_app_ctx.set_disp_buffers = &ios_set_disp_buffers;
    s_app_ctx.disp_deinit = &ios_disp_deinit;
    s_app_ctx.disp_usleep = &ios_disp_usleep;
    s_app_ctx.get_color_fmt = &ios_get_color_fmt;
    s_app_ctx.get_stride = &ios_get_stride;
#endif

    s_app_ctx.display_deinit_flag = 0;
    s_app_ctx.e_output_chroma_format = IV_YUV_420SP_UV;
    /*************************************************************************/
    /* Parse arguments                                                       */
    /*************************************************************************/

#ifndef IOS
    /* Read command line arguments */
    if(argc > 2)
    {
        for(i = 1; i < (UWORD32) argc; i += 2)
        {
            if(CONFIG == get_argument(argv[i]))
            {
                strcpy(ac_cfg_fname, argv[i + 1]);
                if((fp_cfg_file = fopen(ac_cfg_fname, "r")) == NULL)
                {
                    snprintf(ac_error_str, sizeof(ac_error_str),
                             "Could not open Configuration file %s", ac_cfg_fname);
                    codec_exit(ac_error_str);
                }
                read_cfg_file(&s_app_ctx, fp_cfg_file);
                fclose(fp_cfg_file);
            }
            else
            {
                parse_argument(&s_app_ctx, argv[i], argv[i + 1]);
            }
        }
    }
    else
    {
        if((fp_cfg_file = fopen(ac_cfg_fname, "r")) == NULL)
        {
            snprintf(ac_error_str, sizeof(ac_error_str), "Could not open Configuration file %s",
                     ac_cfg_fname);
            codec_exit(ac_error_str);
        }
        read_cfg_file(&s_app_ctx, fp_cfg_file);
        fclose(fp_cfg_file);
    }
#else
    snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", homedir, ac_cfg_fname);
    if((fp_cfg_file = fopen(filename_with_path, "r")) == NULL)
    {
        snprintf(ac_error_str, sizeof(ac_error_str), "Could not open Configuration file %s",
                 ac_cfg_fname);
        codec_exit(ac_error_str);
    }
    read_cfg_file(&s_app_ctx, fp_cfg_file);
    fclose(fp_cfg_file);

#endif
#ifdef PRINT_PICSIZE
    /* If the binary is used for only getting number of bytes in each picture,
     * then disable the following features */
    s_app_ctx.u4_piclen_flag = 0;
    s_app_ctx.u4_file_save_flag = 0;
    s_app_ctx.u4_chksum_save_flag = 0;
    s_app_ctx.i4_degrade_pics = 0;
    s_app_ctx.i4_degrade_type = 0;
    s_app_ctx.loopback = 0;
    s_app_ctx.u4_share_disp_buf = 0;
    s_app_ctx.display = 0;
#endif

    /* If display is enabled, then turn off shared mode and get color format that
     * is supported by display */
    if(1 == s_app_ctx.display)
    {
        s_app_ctx.u4_share_disp_buf = 0;
        s_app_ctx.e_output_chroma_format = s_app_ctx.get_color_fmt();
    }
    if(strcmp(s_app_ctx.ac_ip_fname, "\0") == 0)
    {
        printf("\nNo input file given for decoding\n");
        exit(-1);
    }

    if(1 == s_app_ctx.u4_frame_info_enable)
    {
        pu1_qp_map_buf = calloc((ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6, 1);
        pu1_blk_type_map_buf = calloc((ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6, 1);
    }

    /***********************************************************************/
    /*          create the file object for input file                      */
    /***********************************************************************/
#ifdef IOS
    snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", homedir,
             s_app_ctx.ac_ip_fname);
    ps_ip_file = fopen(filename_with_path, "rb");
#else
    ps_ip_file = fopen(s_app_ctx.ac_ip_fname, "rb");
#endif
    if(NULL == ps_ip_file)
    {
        snprintf(ac_error_str, sizeof(ac_error_str), "Could not open input file %s",
                 s_app_ctx.ac_ip_fname);
        codec_exit(ac_error_str);
    }
    /***********************************************************************/
    /*          create the file object for input file                      */
    /***********************************************************************/
    if(1 == s_app_ctx.u4_piclen_flag)
    {
#ifdef IOS
        snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s",
                 s_app_ctx.ac_piclen_fname);
        ps_piclen_file = fopen(filename_with_path, "rb");
#else
        ps_piclen_file = fopen(s_app_ctx.ac_piclen_fname, "rb");
#endif
        if(NULL == ps_piclen_file)
        {
            snprintf(ac_error_str, sizeof(ac_error_str), "Could not open piclen file %s",
                     s_app_ctx.ac_piclen_fname);
            codec_exit(ac_error_str);
        }
    }

    /***********************************************************************/
    /*          create the file object for output file                     */
    /***********************************************************************/

    /* If the filename does not contain %d, then output will be dumped to
       a single file and it is opened here */
    if((1 == s_app_ctx.u4_file_save_flag) && (strstr(s_app_ctx.ac_op_fname, "%d") == NULL))
    {
#ifdef IOS
        snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir,
                 s_app_ctx.ac_op_fname);
        ps_op_file = fopen(filename_with_path, "wb");
#else
        ps_op_file = fopen(s_app_ctx.ac_op_fname, "wb");
#endif

        if(NULL == ps_op_file)
        {
            snprintf(ac_error_str, sizeof(ac_error_str), "Could not open output file %s",
                     s_app_ctx.ac_op_fname);
            codec_exit(ac_error_str);
        }
    }

    /***********************************************************************/
    /*          create the file object for mbinfo file                     */
    /***********************************************************************/

    if(1 == s_app_ctx.u4_frame_info_enable)
    {
#ifdef IOS
        snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir,
                 s_app_ctx.ac_qp_map_fname);
        ps_qp_file = fopen(filename_with_path, "wb");

        snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir,
                 s_app_ctx.ac_blk_type_map_fname);
        ps_mb_type_file = fopen(filename_with_path, "wb");
#else
        ps_qp_file = fopen(s_app_ctx.ac_qp_map_fname, "wb");
        ps_mb_type_file = fopen(s_app_ctx.ac_blk_type_map_fname, "wb");

#endif

        if(NULL == ps_qp_file)
        {
            snprintf(ac_error_str, sizeof(ac_error_str), "Could not open block_qp map file %s",
                     s_app_ctx.ac_qp_map_fname);
        }
        if(NULL == ps_mb_type_file)
        {
            snprintf(ac_error_str, sizeof(ac_error_str), "Could not open block_type map file %s",
                     s_app_ctx.ac_blk_type_map_fname);
        }
    }

    /***********************************************************************/
    /*          create the file object for check sum file                  */
    /***********************************************************************/
    if(1 == s_app_ctx.u4_chksum_save_flag)
    {
#if IOS
        snprintf(filename_with_path, sizeof(filename_with_path), "%s/%s", documentdir,
                 s_app_ctx.ac_op_chksum_fname);
        ps_op_chksum_file = fopen(filename_with_path, "wb");
#else
        ps_op_chksum_file = fopen(s_app_ctx.ac_op_chksum_fname, "wb");
#endif
        if(NULL == ps_op_chksum_file)
        {
            snprintf(ac_error_str, sizeof(ac_error_str), "Could not open check sum file %s",
                     s_app_ctx.ac_op_chksum_fname);
            codec_exit(ac_error_str);
        }
    }
    /***********************************************************************/
    /*                      Create decoder instance                        */
    /***********************************************************************/
    {
        ps_out_buf = (ivd_out_bufdesc_t *) malloc(sizeof(ivd_out_bufdesc_t));

        /*****************************************************************************/
        /*   API Call: Initialize the Decoder */
        /*****************************************************************************/
        {
            isvcd_create_ip_t s_create_ip = {};
            isvcd_create_op_t s_create_op = {};
            void *fxns = &ivd_api_function;

            s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
            s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = s_app_ctx.u4_share_disp_buf;
            s_create_ip.s_ivd_create_ip_t.e_output_format =
                (IV_COLOR_FORMAT_T) s_app_ctx.e_output_chroma_format;
            s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ih264a_aligned_malloc;
            s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ih264a_aligned_free;
            s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
            s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(isvcd_create_ip_t);
            s_create_op.s_ivd_create_op_t.u4_size = sizeof(isvcd_create_op_t);
            s_create_ip.u4_enable_frame_info = s_app_ctx.u4_frame_info_enable;

            ret = ivd_api_function(NULL, (void *) &s_create_ip, (void *) &s_create_op);
            if(ret != IV_SUCCESS)
            {
                sprintf(ac_error_str, "Error in Create %8x\n",
                        s_create_op.s_ivd_create_op_t.u4_error_code);
                codec_exit(ac_error_str);
            }
            codec_obj = (iv_obj_t *) s_create_op.s_ivd_create_op_t.pv_handle;
            codec_obj->pv_fxns = fxns;
            codec_obj->u4_size = sizeof(iv_obj_t);
            s_app_ctx.cocodec_obj = codec_obj;

            /*****************************************************************************/
            /*  set stride */
            /*****************************************************************************/
            {
                isvcd_ctl_set_config_ip_t s_h264d_ctl_ip = {};
                isvcd_ctl_set_config_op_t s_h264d_ctl_op = {};
                ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
                ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;

                ps_ctl_ip->u4_disp_wd = STRIDE;
                if(1 == s_app_ctx.display) ps_ctl_ip->u4_disp_wd = s_app_ctx.get_stride();

                ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;
                ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
                ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_HEADER;
                ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
                ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
                ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);
                ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

                ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                                       (void *) &s_h264d_ctl_op);
                if(ret != IV_SUCCESS)
                {
                    sprintf(ac_error_str, "\nError in setting the stride");
                    codec_exit(ac_error_str);
                }
            }
        }
    }

    /*************************************************************************/
    /* set num of cores                                                      */
    /*************************************************************************/
    {
        isvcd_ctl_set_num_cores_ip_t s_ctl_set_cores_ip;
        isvcd_ctl_set_num_cores_op_t s_ctl_set_cores_op;

        s_ctl_set_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
        s_ctl_set_cores_ip.e_sub_cmd =
            (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_SET_NUM_CORES;
        s_ctl_set_cores_ip.u4_num_cores = s_app_ctx.u4_num_cores;
        s_ctl_set_cores_ip.u4_size = sizeof(isvcd_ctl_set_num_cores_ip_t);
        s_ctl_set_cores_op.u4_size = sizeof(isvcd_ctl_set_num_cores_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_set_cores_ip,
                               (void *) &s_ctl_set_cores_op);
        if(ret != IV_SUCCESS)
        {
            sprintf(ac_error_str, "\nError in setting number of cores");
            codec_exit(ac_error_str);
        }
    }

    /*************************************************************************/
    /* set target layer                                                     */
    /*************************************************************************/
    {
        isvcd_set_target_layer_ip_t s_ctl_set_target_layer_ip;
        isvcd_set_target_layer_op_t s_ctl_set_target_layer_op;

        s_ctl_set_target_layer_ip.e_cmd = IVD_CMD_VIDEO_CTL;
        s_ctl_set_target_layer_ip.e_sub_cmd =
            (IVD_CONTROL_API_COMMAND_TYPE_T) ISVCD_CMD_CTL_SET_TGT_LAYER;
        s_ctl_set_target_layer_ip.u1_tgt_priority_id = 63;
        s_ctl_set_target_layer_ip.u1_tgt_temp_id = 7;
        s_ctl_set_target_layer_ip.u1_tgt_quality_id = 0;
        s_ctl_set_target_layer_ip.u1_tgt_dep_id = s_app_ctx.i4_target_layer_id;
        s_ctl_set_target_layer_ip.u4_size = sizeof(isvcd_set_target_layer_ip_t);
        s_ctl_set_target_layer_op.u4_size = sizeof(isvcd_set_target_layer_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_set_target_layer_ip,
                               (void *) &s_ctl_set_target_layer_op);

        if(ret != IV_SUCCESS)
        {
            sprintf(ac_error_str, "\nError in setting target layer id");
            codec_exit(ac_error_str);
        }
    }

    /*************************************************************************/
    /* set processsor                                                        */
    /*************************************************************************/
    {
        isvcd_ctl_set_processor_ip_t s_ctl_set_num_processor_ip;
        isvcd_ctl_set_processor_op_t s_ctl_set_num_processor_op;

        s_ctl_set_num_processor_ip.e_cmd = IVD_CMD_VIDEO_CTL;
        s_ctl_set_num_processor_ip.e_sub_cmd =
            (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_SET_PROCESSOR;
        s_ctl_set_num_processor_ip.u4_arch = s_app_ctx.e_arch;
        s_ctl_set_num_processor_ip.u4_soc = s_app_ctx.e_soc;
        s_ctl_set_num_processor_ip.u4_size = sizeof(isvcd_ctl_set_processor_ip_t);
        s_ctl_set_num_processor_op.u4_size = sizeof(isvcd_ctl_set_processor_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_set_num_processor_ip,
                               (void *) &s_ctl_set_num_processor_op);
        if(ret != IV_SUCCESS)
        {
            sprintf(ac_error_str, "\nError in setting Processor type");
            codec_exit(ac_error_str);
        }
    }

    flush_output(codec_obj, &s_app_ctx, ps_out_buf, pu1_bs_buf, &u4_op_frm_ts, ps_op_file,
                 ps_qp_file, ps_mb_type_file, pu1_qp_map_buf, pu1_blk_type_map_buf,
                 ps_op_chksum_file, u4_ip_frm_ts, u4_bytes_remaining);

    /*****************************************************************************/
    /*   Decode header to get width and height and buffer sizes */
    /*****************************************************************************/
    {
        isvcd_video_decode_ip_t s_h264d_decode_ip = {};
        isvcd_video_decode_op_t s_h264d_decode_op = {};
        ivd_video_decode_ip_t *ps_video_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;
        ivd_video_decode_op_t *ps_video_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;

        {
            isvcd_ctl_set_config_ip_t s_h264d_ctl_ip = {};
            isvcd_ctl_set_config_op_t s_h264d_ctl_op = {};
            ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
            ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;

            ps_ctl_ip->u4_disp_wd = STRIDE;
            if(1 == s_app_ctx.display) ps_ctl_ip->u4_disp_wd = s_app_ctx.get_stride();

            ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;
            ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
            ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_HEADER;
            ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
            ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
            ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);
            ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                                   (void *) &s_h264d_ctl_op);
            if(ret != IV_SUCCESS)
            {
                sprintf(ac_error_str, "\nError in setting the codec in header decode mode");
                codec_exit(ac_error_str);
            }
        }

        /* Allocate input buffer for header */
        u4_ip_buf_len = 256 * 1024;
        pu1_bs_buf = (UWORD8 *) malloc(u4_ip_buf_len);

        if(pu1_bs_buf == NULL)
        {
            sprintf(ac_error_str, "\nAllocation failure for input buffer of i4_size %d",
                    u4_ip_buf_len);
            codec_exit(ac_error_str);
        }

        do
        {
            WORD32 numbytes;

            if(0 == s_app_ctx.u4_piclen_flag)
            {
                fseek(ps_ip_file, file_pos, SEEK_SET);
                numbytes = u4_ip_buf_len;
            }
            else
            {
                WORD32 entries;
                entries = fscanf(ps_piclen_file, "%d\n", &numbytes);
                if(1 != entries) numbytes = u4_ip_buf_len;
            }

            u4_bytes_remaining = (WORD32) fread(pu1_bs_buf, sizeof(UWORD8), numbytes, ps_ip_file);

            if((1 == s_app_ctx.u4_piclen_flag) && (u4_bytes_remaining > 0))
            {
                *(pu1_bs_buf + numbytes) = 0x00;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x00;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x00;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x01;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x09;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x10;
                numbytes++;

                u4_bytes_remaining += 6;
            }

            if(0 == u4_bytes_remaining)
            {
                sprintf(ac_error_str, "\nUnable to read from input file");
                codec_exit(ac_error_str);
            }

            ps_video_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;
            ps_video_decode_ip->u4_ts = u4_ip_frm_ts;
            ps_video_decode_ip->pv_stream_buffer = pu1_bs_buf;
            ps_video_decode_ip->u4_num_Bytes = u4_bytes_remaining;
            ps_video_decode_ip->u4_size = sizeof(isvcd_video_decode_ip_t);
            ps_video_decode_op->u4_size = sizeof(isvcd_video_decode_op_t);
            s_h264d_decode_ip.pu1_8x8_blk_qp_map = pu1_qp_map_buf;
            s_h264d_decode_ip.pu1_8x8_blk_type_map = pu1_blk_type_map_buf;
            s_h264d_decode_ip.u4_8x8_blk_qp_map_size = (ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
            s_h264d_decode_ip.u4_8x8_blk_type_map_size = (ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;

            /*****************************************************************************/
            /*   API Call: Header Decode */
            /*****************************************************************************/
            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_decode_ip,
                                   (void *) &s_h264d_decode_op);

            if(ret != IV_SUCCESS)
            {
                printf("Error in header decode 0x%x\n", ps_video_decode_op->u4_error_code);
                // codec_exit(ac_error_str);
            }

            u4_num_bytes_dec = ps_video_decode_op->u4_num_bytes_consumed;
#ifndef PROFILE_ENABLE
            printf("%d\n", ps_video_decode_op->u4_num_bytes_consumed);
#endif
            file_pos += u4_num_bytes_dec;
            total_bytes_comsumed += u4_num_bytes_dec;
        } while(ret != IV_SUCCESS);

        /* copy pic_wd and pic_ht to initialize buffers */
        s_app_ctx.u4_pic_wd = ps_video_decode_op->u4_pic_wd;
        s_app_ctx.u4_pic_ht = ps_video_decode_op->u4_pic_ht;

        free(pu1_bs_buf);

#if IOS_DISPLAY
        s_app_ctx.i4_screen_wd = screen_wd;
        s_app_ctx.i4_screen_ht = screen_ht;
#endif
        {
            ivd_ctl_getbufinfo_ip_t s_ctl_ip;
            ivd_ctl_getbufinfo_op_t s_ctl_op;
            WORD32 outlen = 0;

            s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
            s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_GETBUFINFO;
            s_ctl_ip.u4_size = sizeof(ivd_ctl_getbufinfo_ip_t);
            s_ctl_op.u4_size = sizeof(ivd_ctl_getbufinfo_op_t);
            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_ip, (void *) &s_ctl_op);
            if(ret != IV_SUCCESS)
            {
                sprintf(ac_error_str, "Error in Get Buf Info %x", s_ctl_op.u4_error_code);
                codec_exit(ac_error_str);
            }

            /* Allocate bitstream buffer */
            u4_ip_buf_len = s_ctl_op.u4_min_in_buf_size[0];
#ifdef ADAPTIVE_TEST
            u4_ip_buf_len = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT * 3 >> 1;
#endif
            pu1_bs_buf = (UWORD8 *) malloc(u4_ip_buf_len);

            if(pu1_bs_buf == NULL)
            {
                sprintf(ac_error_str, "\nAllocation failure for input buffer of i4_size %d",
                        u4_ip_buf_len);
                codec_exit(ac_error_str);
            }

            s_app_ctx.num_disp_buf = s_ctl_op.u4_num_disp_bufs;
            /* Allocate output buffer only if display buffers are not shared */
            /* Or if shared and output is 420P */
            if((0 == s_app_ctx.u4_share_disp_buf) ||
               (IV_YUV_420P == s_app_ctx.e_output_chroma_format))
            {
#ifdef ADAPTIVE_TEST
                switch(s_app_ctx.e_output_chroma_format)
                {
                    case IV_YUV_420P:
                    {
                        s_ctl_op.u4_min_out_buf_size[0] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT;
                        s_ctl_op.u4_min_out_buf_size[1] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT >> 2;
                        s_ctl_op.u4_min_out_buf_size[2] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT >> 2;
                        break;
                    }
                    case IV_YUV_420SP_UV:
                    case IV_YUV_420SP_VU:
                    {
                        s_ctl_op.u4_min_out_buf_size[0] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT;
                        s_ctl_op.u4_min_out_buf_size[1] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT >> 1;
                        s_ctl_op.u4_min_out_buf_size[2] = 0;
                        break;
                    }
                    case IV_YUV_422ILE:
                    {
                        s_ctl_op.u4_min_out_buf_size[0] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT * 2;
                        s_ctl_op.u4_min_out_buf_size[1] = 0;
                        s_ctl_op.u4_min_out_buf_size[2] = 0;
                        break;
                    }
                    case IV_RGBA_8888:
                    {
                        s_ctl_op.u4_min_out_buf_size[0] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT * 4;
                        s_ctl_op.u4_min_out_buf_size[1] = 0;
                        s_ctl_op.u4_min_out_buf_size[2] = 0;
                        break;
                    }
                    case IV_RGB_565:
                    {
                        s_ctl_op.u4_min_out_buf_size[0] = ADAPTIVE_MAX_WD * ADAPTIVE_MAX_HT * 2;
                        s_ctl_op.u4_min_out_buf_size[1] = 0;
                        s_ctl_op.u4_min_out_buf_size[2] = 0;
                        break;
                    }
                    default:
                        break;
                }
#endif
                ps_out_buf->u4_min_out_buf_size[0] = s_ctl_op.u4_min_out_buf_size[0];
                ps_out_buf->u4_min_out_buf_size[1] = s_ctl_op.u4_min_out_buf_size[1];
                ps_out_buf->u4_min_out_buf_size[2] = s_ctl_op.u4_min_out_buf_size[2];

                outlen = s_ctl_op.u4_min_out_buf_size[0];
                if(s_ctl_op.u4_min_num_out_bufs > 1) outlen += s_ctl_op.u4_min_out_buf_size[1];

                if(s_ctl_op.u4_min_num_out_bufs > 2) outlen += s_ctl_op.u4_min_out_buf_size[2];

                ps_out_buf->pu1_bufs[0] = (UWORD8 *) malloc(outlen);
                if(ps_out_buf->pu1_bufs[0] == NULL)
                {
                    sprintf(ac_error_str, "\nAllocation failure for output buffer of i4_size %d",
                            outlen);
                    codec_exit(ac_error_str);
                }

                if(s_ctl_op.u4_min_num_out_bufs > 1)
                    ps_out_buf->pu1_bufs[1] =
                        ps_out_buf->pu1_bufs[0] + (s_ctl_op.u4_min_out_buf_size[0]);

                if(s_ctl_op.u4_min_num_out_bufs > 2)
                    ps_out_buf->pu1_bufs[2] =
                        ps_out_buf->pu1_bufs[1] + (s_ctl_op.u4_min_out_buf_size[1]);

                ps_out_buf->u4_num_bufs = s_ctl_op.u4_min_num_out_bufs;
            }

#ifdef APP_EXTRA_BUFS
            s_app_ctx.disp_delay = EXTRA_DISP_BUFFERS;
            s_ctl_op.u4_num_disp_bufs += EXTRA_DISP_BUFFERS;
#endif

            /*****************************************************************************/
            /*   API Call: Allocate display buffers for display buffer shared case */
            /*****************************************************************************/

            for(i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
            {
                s_app_ctx.s_disp_buffers[i].u4_min_out_buf_size[0] =
                    s_ctl_op.u4_min_out_buf_size[0];
                s_app_ctx.s_disp_buffers[i].u4_min_out_buf_size[1] =
                    s_ctl_op.u4_min_out_buf_size[1];
                s_app_ctx.s_disp_buffers[i].u4_min_out_buf_size[2] =
                    s_ctl_op.u4_min_out_buf_size[2];

                outlen = s_ctl_op.u4_min_out_buf_size[0];
                if(s_ctl_op.u4_min_num_out_bufs > 1) outlen += s_ctl_op.u4_min_out_buf_size[1];

                if(s_ctl_op.u4_min_num_out_bufs > 2) outlen += s_ctl_op.u4_min_out_buf_size[2];

                s_app_ctx.s_disp_buffers[i].pu1_bufs[0] = (UWORD8 *) malloc(outlen);

                if(s_app_ctx.s_disp_buffers[i].pu1_bufs[0] == NULL)
                {
                    sprintf(ac_error_str, "\nAllocation failure for output buffer of i4_size %d",
                            outlen);
                    codec_exit(ac_error_str);
                }

                if(s_ctl_op.u4_min_num_out_bufs > 1)
                    s_app_ctx.s_disp_buffers[i].pu1_bufs[1] =
                        s_app_ctx.s_disp_buffers[i].pu1_bufs[0] + (s_ctl_op.u4_min_out_buf_size[0]);

                if(s_ctl_op.u4_min_num_out_bufs > 2)
                    s_app_ctx.s_disp_buffers[i].pu1_bufs[2] =
                        s_app_ctx.s_disp_buffers[i].pu1_bufs[1] + (s_ctl_op.u4_min_out_buf_size[1]);

                s_app_ctx.s_disp_buffers[i].u4_num_bufs = s_ctl_op.u4_min_num_out_bufs;
            }
            s_app_ctx.num_disp_buf = s_ctl_op.u4_num_disp_bufs;
        }

        /* Create display thread and wait for the display buffers to be initialized*/
        if(1 == s_app_ctx.display)
        {
            if(0 == s_app_ctx.display_thread_created)
            {
                s_app_ctx.display_init_done = 0;
                ithread_create(s_app_ctx.display_thread_handle, NULL, (void *) &display_thread,
                               (void *) &s_app_ctx);
                s_app_ctx.display_thread_created = 1;

                while(1)
                {
                    if(s_app_ctx.display_init_done) break;

                    ithread_msleep(1);
                }
            }

            s_app_ctx.u4_strd = s_app_ctx.get_stride();
        }
    }

    /*************************************************************************/
    /* Get actual number of output buffers requried, which is dependent      */
    /* on ps_bitstrm properties such as width, height and level etc */
    /* This is needed mainly for shared display mode                         */
    /*************************************************************************/

    /*****************************************************************************/
    /*   API Call: Send the allocated display buffers to codec */
    /*****************************************************************************/
    {
        ivd_set_display_frame_ip_t s_set_display_frame_ip;
        ivd_set_display_frame_op_t s_set_display_frame_op;

        s_set_display_frame_ip.e_cmd = IVD_CMD_SET_DISPLAY_FRAME;
        s_set_display_frame_ip.u4_size = sizeof(ivd_set_display_frame_ip_t);
        s_set_display_frame_op.u4_size = sizeof(ivd_set_display_frame_op_t);

        s_set_display_frame_ip.num_disp_bufs = s_app_ctx.num_disp_buf;

        memcpy(&(s_set_display_frame_ip.s_disp_buffer), &(s_app_ctx.s_disp_buffers),
               s_app_ctx.num_disp_buf * sizeof(ivd_out_bufdesc_t));

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_set_display_frame_ip,
                               (void *) &s_set_display_frame_op);

        if(IV_SUCCESS != ret)
        {
            sprintf(ac_error_str, "Error in Set display frame");
            codec_exit(ac_error_str);
        }
    }

    /*************************************************************************/
    /* Get frame dimensions for display buffers such as x_offset,y_offset    */
    /* etc. This information might be needed to set display buffer           */
    /* offsets in case of shared display buffer mode                         */
    /*************************************************************************/
    {
        isvcd_ctl_get_frame_dimensions_ip_t s_ctl_get_frame_dimensions_ip;
        isvcd_ctl_get_frame_dimensions_op_t s_ctl_get_frame_dimensions_op;

        s_ctl_get_frame_dimensions_ip.e_cmd = IVD_CMD_VIDEO_CTL;
        s_ctl_get_frame_dimensions_ip.e_sub_cmd =
            (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_BUFFER_DIMENSIONS;
        s_ctl_get_frame_dimensions_ip.u4_size = sizeof(isvcd_ctl_get_frame_dimensions_ip_t);
        s_ctl_get_frame_dimensions_op.u4_size = sizeof(isvcd_ctl_get_frame_dimensions_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_get_frame_dimensions_ip,
                               (void *) &s_ctl_get_frame_dimensions_op);
        if(IV_SUCCESS != ret)
        {
            sprintf(ac_error_str, "Error in Get buffer Dimensions");
            codec_exit(ac_error_str);
        }
    }

    /*************************************************************************/
    /* Get VUI parameters                                                    */
    /*************************************************************************/
    {
        isvcd_ctl_get_vui_params_ip_t s_ctl_get_vui_params_ip;
        isvcd_ctl_get_vui_params_op_t s_ctl_get_vui_params_op;

        s_ctl_get_vui_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
        s_ctl_get_vui_params_ip.e_sub_cmd =
            (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_VUI_PARAMS;
        s_ctl_get_vui_params_ip.u4_size = sizeof(isvcd_ctl_get_vui_params_ip_t);
        s_ctl_get_vui_params_op.u4_size = sizeof(isvcd_ctl_get_vui_params_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_get_vui_params_ip,
                               (void *) &s_ctl_get_vui_params_op);
        if(IV_SUCCESS != ret)
        {
            sprintf(ac_error_str, "Error in Get VUI params");
            // codec_exit(ac_error_str);
        }
    }

    /*************************************************************************/
    /* Set the decoder in frame decode mode. It was set in header decode     */
    /* mode earlier                                                          */
    /*************************************************************************/
    {
        isvcd_ctl_set_config_ip_t s_h264d_ctl_ip = {};
        isvcd_ctl_set_config_op_t s_h264d_ctl_op = {};
        ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
        ivd_ctl_set_config_op_t *ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;

        ps_ctl_ip->u4_disp_wd = STRIDE;
        if(1 == s_app_ctx.display) ps_ctl_ip->u4_disp_wd = s_app_ctx.get_stride();
        ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;

        ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
        ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_FRAME;
        ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
        ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
        ps_ctl_ip->u4_size = sizeof(isvcd_ctl_set_config_ip_t);

        ps_ctl_op->u4_size = sizeof(isvcd_ctl_set_config_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_ctl_ip,
                               (void *) &s_h264d_ctl_op);

        if(IV_SUCCESS != ret)
        {
            sprintf(ac_error_str, "Error in Set Parameters");
            // codec_exit(ac_error_str);
        }
    }
    /*************************************************************************/
    /* If required disable deblocking and sao at given level                 */
    /*************************************************************************/

    set_degrade(codec_obj, s_app_ctx.i4_degrade_type, s_app_ctx.i4_degrade_pics);
#ifdef WINDOWS_TIMER
    QueryPerformanceFrequency(&frequency);
#endif
#ifndef PRINT_PICSIZE
    get_version(codec_obj);
#endif

    max_op_frm_ts = s_app_ctx.u4_max_frm_ts + s_app_ctx.disp_delay;

    if(max_op_frm_ts < s_app_ctx.disp_delay)
        max_op_frm_ts = 0xffffffff; /* clip as overflow has occured*/

    max_op_frm_ts = (s_app_ctx.u4_max_frm_ts > 0) ? (max_op_frm_ts) : 0xffffffff;

    u4_num_disp_bufs_with_dec = 0;

    while(u4_op_frm_ts < max_op_frm_ts)
    {
#ifdef TEST_FLUSH
        if(u4_ip_frm_ts == FLUSH_FRM_CNT)
        {
            ivd_ctl_flush_ip_t s_ctl_ip;
            ivd_ctl_flush_op_t s_ctl_op;

            s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
            s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH;
            s_ctl_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);
            s_ctl_op.u4_size = sizeof(ivd_ctl_flush_op_t);
            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_ip, (void *) &s_ctl_op);

            if(ret != IV_SUCCESS)
            {
                printf("Error in Setting the decoder in flush mode\n");
            }
            //            file_pos = 0;

            //          fseek(ps_ip_file, file_pos, SEEK_SET);
        }
#endif
        if(u4_num_disp_bufs_with_dec < s_app_ctx.num_disp_buf)
        {
            release_disp_frame(codec_obj, u4_num_disp_bufs_with_dec);
            u4_num_disp_bufs_with_dec++;
        }

        /*************************************************************************/
        /* set num of cores                                                      */
        /*************************************************************************/
#ifdef DYNAMIC_NUMCORES
        {
            isvcd_ctl_set_num_cores_ip_t s_ctl_set_cores_ip;
            isvcd_ctl_set_num_cores_op_t s_ctl_set_cores_op;

            s_ctl_set_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
            s_ctl_set_cores_ip.e_sub_cmd = IH264D_CMD_CTL_SET_NUM_CORES;
            s_ctl_set_cores_ip.u4_num_cores = 1 + 3 * (u4_ip_frm_ts % 2);
            s_ctl_set_cores_ip.u4_size = sizeof(isvcd_ctl_set_num_cores_ip_t);
            s_ctl_set_cores_op.u4_size = sizeof(isvcd_ctl_set_num_cores_op_t);

            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_set_cores_ip,
                                   (void *) &s_ctl_set_cores_op);
            if(ret != IV_SUCCESS)
            {
                sprintf(ac_error_str, "\nError in setting number of cores");
                codec_exit(ac_error_str);
            }
        }
#endif
        /***********************************************************************/
        /*   Seek the file to start of current frame, this is equavelent of    */
        /*   having a parcer which tells the start of current frame            */
        /***********************************************************************/
        {
            WORD32 numbytes;

            if(0 == s_app_ctx.u4_piclen_flag)
            {
                fseek(ps_ip_file, file_pos, SEEK_SET);
                numbytes = u4_ip_buf_len;
            }
            else
            {
                WORD32 entries;
                entries = fscanf(ps_piclen_file, "%d\n", &numbytes);
                if(1 != entries) numbytes = u4_ip_buf_len;
            }

            u4_bytes_remaining = (WORD32) fread(pu1_bs_buf, sizeof(UWORD8), numbytes, ps_ip_file);

            // AUD_PIC_BOUNDARY
            if((1 == s_app_ctx.u4_piclen_flag) && (u4_bytes_remaining > 0))
            {
                *(pu1_bs_buf + numbytes) = 0x00;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x00;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x00;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x01;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x09;
                numbytes++;
                *(pu1_bs_buf + numbytes) = 0x10;
                numbytes++;

                u4_bytes_remaining += 6;
            }

            if(u4_bytes_remaining == 0)
            {
                if(1 == s_app_ctx.loopback)
                {
                    file_pos = 0;
                    if(0 == s_app_ctx.u4_piclen_flag)
                    {
                        fseek(ps_ip_file, file_pos, SEEK_SET);
                        numbytes = u4_ip_buf_len;
                    }
                    else
                    {
                        WORD32 entries;
                        entries = fscanf(ps_piclen_file, "%d\n", &numbytes);
                        if(1 != entries) numbytes = u4_ip_buf_len;
                    }

                    u4_bytes_remaining =
                        (WORD32) fread(pu1_bs_buf, sizeof(UWORD8), numbytes, ps_ip_file);
                }
                else
                    break;
            }
        }

        /*********************************************************************/
        /* Following calls can be enabled at diffent times                   */
        /*********************************************************************/
#if ENABLE_DEGRADE
        if(u4_op_frm_ts >= 10000) disable_deblocking(codec_obj, 4);

        if(u4_op_frm_ts == 30000) enable_deblocking(codec_obj);

        if(u4_op_frm_ts == 10000) enable_skippb_frames(codec_obj);

        if(u4_op_frm_ts == 60000) disable_skippb_frames(codec_obj);

        if(u4_op_frm_ts == 30000) enable_skipb_frames(codec_obj);

        if(u4_op_frm_ts == 60000) disable_skipb_frames(codec_obj);
#endif

        {
            isvcd_video_decode_ip_t s_h264d_decode_ip = {};
            isvcd_video_decode_op_t s_h264d_decode_op = {};
            ivd_video_decode_ip_t *ps_video_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;
            ivd_video_decode_op_t *ps_video_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;
#ifdef PROFILE_ENABLE
            UWORD32 s_elapsed_time;
            TIMER s_start_timer;
            TIMER s_end_timer;
#endif

            ps_video_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;
            ps_video_decode_ip->u4_ts = u4_ip_frm_ts;
            ps_video_decode_ip->pv_stream_buffer = pu1_bs_buf;
            ps_video_decode_ip->u4_num_Bytes = u4_bytes_remaining;
            ps_video_decode_ip->u4_size = sizeof(isvcd_video_decode_ip_t);
            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[0] =
                ps_out_buf->u4_min_out_buf_size[0];
            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[1] =
                ps_out_buf->u4_min_out_buf_size[1];
            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[2] =
                ps_out_buf->u4_min_out_buf_size[2];

            ps_video_decode_ip->s_out_buffer.pu1_bufs[0] = ps_out_buf->pu1_bufs[0];
            ps_video_decode_ip->s_out_buffer.pu1_bufs[1] = ps_out_buf->pu1_bufs[1];
            ps_video_decode_ip->s_out_buffer.pu1_bufs[2] = ps_out_buf->pu1_bufs[2];
            ps_video_decode_ip->s_out_buffer.u4_num_bufs = ps_out_buf->u4_num_bufs;
            ps_video_decode_op->u4_size = sizeof(isvcd_video_decode_op_t);
            s_h264d_decode_ip.pu1_8x8_blk_qp_map = pu1_qp_map_buf;
            s_h264d_decode_ip.pu1_8x8_blk_type_map = pu1_blk_type_map_buf;
            s_h264d_decode_ip.u4_8x8_blk_qp_map_size = (ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;
            s_h264d_decode_ip.u4_8x8_blk_type_map_size = (ADAPTIVE_MAX_HT * ADAPTIVE_MAX_WD) >> 6;

            /* Get display buffer pointers */
            if(1 == s_app_ctx.display)
            {
                WORD32 wr_idx;

                wr_idx = dispq_producer_dequeue(&s_app_ctx);

                if(s_app_ctx.quit) break;

                s_app_ctx.set_disp_buffers(s_app_ctx.pv_disp_ctx, wr_idx,
                                           &ps_video_decode_ip->s_out_buffer.pu1_bufs[0],
                                           &ps_video_decode_ip->s_out_buffer.pu1_bufs[1],
                                           &ps_video_decode_ip->s_out_buffer.pu1_bufs[2]);
            }

            /*****************************************************************************/
            /*   API Call: Video Decode */
            /*****************************************************************************/

            GETTIME(&s_start_timer);

            ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_h264d_decode_ip,
                                   (void *) &s_h264d_decode_op);

            GETTIME(&s_end_timer);
            ELAPSEDTIME(s_start_timer, s_end_timer, s_elapsed_time, frequency);
#ifdef PROFILE_ENABLE
            {
                UWORD32 peak_avg, id;
                u4_tot_cycles += s_elapsed_time;
                peak_window[peak_window_idx++] = s_elapsed_time;
                if(peak_window_idx == PEAK_WINDOW_SIZE) peak_window_idx = 0;
                peak_avg = 0;
                for(id = 0; id < PEAK_WINDOW_SIZE; id++)
                {
                    peak_avg += peak_window[id];
                }
                peak_avg /= PEAK_WINDOW_SIZE;
                if(peak_avg > peak_avg_max) peak_avg_max = peak_avg;
                frm_cnt++;

                printf(
                    "FrameNum: %4d TimeTaken(microsec): %6d AvgTime: %6d "
                    "PeakAvgTimeMax: %6d Output: %2d NumBytes: %6d \n",
                    frm_cnt, s_elapsed_time, u4_tot_cycles / frm_cnt, peak_avg_max,
                    ps_video_decode_op->u4_output_present,
                    ps_video_decode_op->u4_num_bytes_consumed);
            }
#else
            printf("%d\n", ps_video_decode_op->u4_num_bytes_consumed);
#endif

            if(ret != IV_SUCCESS)
            {
                printf("Error in video Frame decode : ret %x Error %x\n", ret,
                       ps_video_decode_op->u4_error_code);
            }

            if((IV_SUCCESS != ret) &&
               ((ps_video_decode_op->u4_error_code & 0xFF) == IVD_RES_CHANGED))
            {
                ivd_ctl_reset_ip_t s_ctl_ip;
                ivd_ctl_reset_op_t s_ctl_op;

                flush_output(codec_obj, &s_app_ctx, ps_out_buf, pu1_bs_buf, &u4_op_frm_ts,
                             ps_op_file, ps_qp_file, ps_mb_type_file, pu1_qp_map_buf,
                             pu1_blk_type_map_buf, ps_op_chksum_file, u4_ip_frm_ts,
                             u4_bytes_remaining);

                s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
                s_ctl_ip.u4_size = sizeof(ivd_ctl_reset_ip_t);
                s_ctl_op.u4_size = sizeof(ivd_ctl_reset_op_t);

                ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_ip,
                                       (void *) &s_ctl_op);
                if(IV_SUCCESS != ret)
                {
                    sprintf(ac_error_str, "Error in Reset");
                    codec_exit(ac_error_str);
                }

                /*when reset all buffers are released by lib*/
                u4_num_disp_bufs_with_dec = 0;
                /*************************************************************************/
                /* set num of cores */
                /*************************************************************************/
                {
                    isvcd_ctl_set_num_cores_ip_t s_ctl_set_cores_ip;
                    isvcd_ctl_set_num_cores_op_t s_ctl_set_cores_op;

                    s_ctl_set_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                    s_ctl_set_cores_ip.e_sub_cmd =
                        (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_SET_NUM_CORES;
                    s_ctl_set_cores_ip.u4_num_cores = s_app_ctx.u4_num_cores;
                    s_ctl_set_cores_ip.u4_size = sizeof(isvcd_ctl_set_num_cores_ip_t);
                    s_ctl_set_cores_op.u4_size = sizeof(isvcd_ctl_set_num_cores_op_t);

                    ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_set_cores_ip,
                                           (void *) &s_ctl_set_cores_op);
                    if(ret != IV_SUCCESS)
                    {
                        sprintf(ac_error_str, "\nError in setting number of cores");
                        codec_exit(ac_error_str);
                    }
                }
                /*************************************************************************/
                /* set processsor */
                /*************************************************************************/

                {
                    isvcd_ctl_set_processor_ip_t s_ctl_set_num_processor_ip;
                    isvcd_ctl_set_processor_op_t s_ctl_set_num_processor_op;

                    s_ctl_set_num_processor_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                    s_ctl_set_num_processor_ip.e_sub_cmd =
                        (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_SET_PROCESSOR;
                    s_ctl_set_num_processor_ip.u4_arch = s_app_ctx.e_arch;
                    s_ctl_set_num_processor_ip.u4_soc = s_app_ctx.e_soc;
                    s_ctl_set_num_processor_ip.u4_size = sizeof(isvcd_ctl_set_processor_ip_t);
                    s_ctl_set_num_processor_op.u4_size = sizeof(isvcd_ctl_set_processor_op_t);

                    ret = ivd_api_function((iv_obj_t *) codec_obj,
                                           (void *) &s_ctl_set_num_processor_ip,
                                           (void *) &s_ctl_set_num_processor_op);
                    if(ret != IV_SUCCESS)
                    {
                        sprintf(ac_error_str, "\nError in setting Processor type");
                        codec_exit(ac_error_str);
                    }
                }
            }

            /*************************************************************************/
            /* Get SEI MDCV parameters                                               */
            /*************************************************************************/
            if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_mdcv_params_present_flag)
            {
                isvcd_ctl_get_sei_mdcv_params_ip_t s_ctl_get_sei_mdcv_params_ip;
                isvcd_ctl_get_sei_mdcv_params_op_t s_ctl_get_sei_mdcv_params_op;

                memset(&s_ctl_get_sei_mdcv_params_ip, 0,
                       sizeof(isvcd_ctl_get_sei_mdcv_params_ip_t));
                memset(&s_ctl_get_sei_mdcv_params_op, 0,
                       sizeof(isvcd_ctl_get_sei_mdcv_params_op_t));

                s_ctl_get_sei_mdcv_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                s_ctl_get_sei_mdcv_params_ip.e_sub_cmd =
                    (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_MDCV_PARAMS;
                s_ctl_get_sei_mdcv_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_mdcv_params_ip_t);
                s_ctl_get_sei_mdcv_params_op.u4_size = sizeof(isvcd_ctl_get_sei_mdcv_params_op_t);

                ret =
                    ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_get_sei_mdcv_params_ip,
                                     (void *) &s_ctl_get_sei_mdcv_params_op);

                if(IV_SUCCESS != ret)
                {
                    printf("MDCV SEI params not present : Error %x\n",
                           s_ctl_get_sei_mdcv_params_op.u4_error_code);
                }
            }
            /*************************************************************************/
            /* Get SEI CLL parameters                                                */
            /*************************************************************************/
            if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_cll_params_present_flag)
            {
                isvcd_ctl_get_sei_cll_params_ip_t s_ctl_get_sei_cll_params_ip;
                isvcd_ctl_get_sei_cll_params_op_t s_ctl_get_sei_cll_params_op;

                memset(&s_ctl_get_sei_cll_params_ip, 0, sizeof(isvcd_ctl_get_sei_cll_params_ip_t));
                memset(&s_ctl_get_sei_cll_params_op, 0, sizeof(isvcd_ctl_get_sei_cll_params_op_t));

                s_ctl_get_sei_cll_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                s_ctl_get_sei_cll_params_ip.e_sub_cmd =
                    (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_CLL_PARAMS;
                s_ctl_get_sei_cll_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_cll_params_ip_t);
                s_ctl_get_sei_cll_params_op.u4_size = sizeof(isvcd_ctl_get_sei_cll_params_op_t);

                ret =
                    ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_get_sei_cll_params_ip,
                                     (void *) &s_ctl_get_sei_cll_params_op);

                if(IV_SUCCESS != ret)
                {
                    printf("CLL SEI params not present : Error %x\n",
                           s_ctl_get_sei_cll_params_op.u4_error_code);
                }
            }
            /*************************************************************************/
            /* Get SEI AVE parameters                                                */
            /*************************************************************************/
            if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_ave_params_present_flag)
            {
                isvcd_ctl_get_sei_ave_params_ip_t s_ctl_get_sei_ave_params_ip;
                isvcd_ctl_get_sei_ave_params_op_t s_ctl_get_sei_ave_params_op;

                memset(&s_ctl_get_sei_ave_params_ip, 0, sizeof(isvcd_ctl_get_sei_ave_params_ip_t));
                memset(&s_ctl_get_sei_ave_params_op, 0, sizeof(isvcd_ctl_get_sei_ave_params_op_t));

                s_ctl_get_sei_ave_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                s_ctl_get_sei_ave_params_ip.e_sub_cmd =
                    (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_AVE_PARAMS;
                s_ctl_get_sei_ave_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_ave_params_ip_t);
                s_ctl_get_sei_ave_params_op.u4_size = sizeof(isvcd_ctl_get_sei_ave_params_op_t);

                ret =
                    ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_get_sei_ave_params_ip,
                                     (void *) &s_ctl_get_sei_ave_params_op);

                if(IV_SUCCESS != ret)
                {
                    printf("AVE SEI params not present : Error %x\n",
                           s_ctl_get_sei_ave_params_op.u4_error_code);
                }
            }
            /*************************************************************************/
            /* Get SEI CCV parameters                                                */
            /*************************************************************************/
            if(1 == ps_video_decode_op->s_sei_decode_op.u1_sei_ccv_params_present_flag)
            {
                isvcd_ctl_get_sei_ccv_params_ip_t s_ctl_get_sei_ccv_params_ip;
                isvcd_ctl_get_sei_ccv_params_op_t s_ctl_get_sei_ccv_params_op;

                memset(&s_ctl_get_sei_ccv_params_ip, 0, sizeof(isvcd_ctl_get_sei_ccv_params_ip_t));
                memset(&s_ctl_get_sei_ccv_params_op, 0, sizeof(isvcd_ctl_get_sei_ccv_params_op_t));

                s_ctl_get_sei_ccv_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
                s_ctl_get_sei_ccv_params_ip.e_sub_cmd =
                    (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_SEI_CCV_PARAMS;
                s_ctl_get_sei_ccv_params_ip.u4_size = sizeof(isvcd_ctl_get_sei_ccv_params_ip_t);
                s_ctl_get_sei_ccv_params_op.u4_size = sizeof(isvcd_ctl_get_sei_ccv_params_op_t);

                ret =
                    ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_ctl_get_sei_ccv_params_ip,
                                     (void *) &s_ctl_get_sei_ccv_params_op);

                if(IV_SUCCESS != ret)
                {
                    printf("CCV SEI params not present : Error %x\n",
                           s_ctl_get_sei_ccv_params_op.u4_error_code);
                }
            }

            if((1 == s_app_ctx.display) && (1 == ps_video_decode_op->u4_output_present))
            {
                dispq_producer_queue(&s_app_ctx);
            }

            if(IV_B_FRAME == ps_video_decode_op->e_pic_type) s_app_ctx.b_pic_present |= 1;

            u4_num_bytes_dec = ps_video_decode_op->u4_num_bytes_consumed;

            file_pos += u4_num_bytes_dec;
            total_bytes_comsumed += u4_num_bytes_dec;
            u4_ip_frm_ts++;

            if(1 == ps_video_decode_op->u4_output_present)
            {
                CHAR cur_fname[1000];
                CHAR *extn = NULL;
                /* The objective is to dump the decoded frames into separate files instead
                 * of dumping all the frames in one common file. Also, the number of
                 * dumped frames at any given instance of time cannot exceed
                 * 'frame_memory'
                 */
                if(s_app_ctx.u4_file_save_flag)
                {
                    /* Locate the position of extension yuv */
                    extn = strstr(s_app_ctx.ac_op_fname, "%d");
                    if(extn != NULL)
                    {
                        output_write_stall(s_app_ctx.ac_op_fname, u4_op_frm_ts);
                        /* Generate output file names */
                        sprintf(cur_fname, s_app_ctx.ac_op_fname, u4_op_frm_ts);
                        /* Open Output file */
                        ps_op_file = fopen(cur_fname, "wb");
                        if(NULL == ps_op_file)
                        {
                            snprintf(ac_error_str, sizeof(ac_error_str),
                                     "Could not open output file %s", cur_fname);

                            codec_exit(ac_error_str);
                        }
                    }
                }

#ifdef PROFILE_ENABLE
                width = ps_video_decode_op->s_disp_frm_buf.u4_y_wd;
                height = ps_video_decode_op->s_disp_frm_buf.u4_y_ht;
#endif
                dump_output(&s_app_ctx, &(ps_video_decode_op->s_disp_frm_buf), &s_h264d_decode_op,
                            ps_video_decode_op->u4_disp_buf_id, ps_op_file, ps_qp_file,
                            ps_mb_type_file, ps_op_chksum_file, u4_op_frm_ts,
                            s_app_ctx.u4_file_save_flag, s_app_ctx.u4_chksum_save_flag,
                            s_app_ctx.u4_frame_info_enable);

                u4_op_frm_ts++;
                if(extn != NULL) fclose(ps_op_file);
            }
            else
            {
                if((ps_video_decode_op->u4_error_code >> IVD_FATALERROR) & 1)
                {
                    printf("Fatal error\n");
                    break;
                }
            }
        }
    }

    /***********************************************************************/
    /*      To get the last decoded frames, call process with NULL input    */
    /***********************************************************************/
    flush_output(codec_obj, &s_app_ctx, ps_out_buf, pu1_bs_buf, &u4_op_frm_ts, ps_op_file,
                 ps_qp_file, ps_mb_type_file, pu1_qp_map_buf, pu1_blk_type_map_buf,
                 ps_op_chksum_file, u4_ip_frm_ts, u4_bytes_remaining);

    /* set disp_end u4_flag */
    s_app_ctx.quit = 1;

#ifdef PROFILE_ENABLE
    printf("Summary\n");
    printf("Input filename                  : %s\n", s_app_ctx.ac_ip_fname);
    printf("Output Width                    : %-4d\n", width);
    printf("Output Height                   : %-4d\n", height);

    if(frm_cnt)
    {
        double avg = u4_tot_cycles / frm_cnt;
        double bytes_avg = total_bytes_comsumed / frm_cnt;
        double bitrate = (bytes_avg * 8 * s_app_ctx.fps) / 1000000;
        printf("Bitrate @ %2d fps(mbps)          : %-6.2f\n", s_app_ctx.fps, bitrate);
        printf("Average decode time(micro sec)  : %-6d\n", (WORD32) avg);
        printf("Avg Peak decode time(%2d frames) : %-6d\n", PEAK_WINDOW_SIZE,
               (WORD32) peak_avg_max);
        avg = (u4_tot_cycles + u4_tot_fmt_cycles) * 1.0 / frm_cnt;

        if(0 == s_app_ctx.u4_share_disp_buf)
            printf("FPS achieved (with format conv) : %-3.2f\n", 1000000 / avg);
        else
            printf("FPS achieved                    : %-3.2f\n", 1000000 / avg);
    }
#endif
    /***********************************************************************/
    /*   Clear the decoder, close all the files, free all the memory       */
    /***********************************************************************/
    if(1 == s_app_ctx.display)
    {
        s_app_ctx.display_deinit_flag = 1;
        /* wait for display to finish */
        if(s_app_ctx.display_thread_created)
        {
            ithread_join(s_app_ctx.display_thread_handle, NULL);
        }
        free(s_app_ctx.display_thread_handle);
    }

    {
        ivd_delete_ip_t s_delete_dec_ip;
        ivd_delete_op_t s_delete_dec_op;

        s_delete_dec_ip.e_cmd = IVD_CMD_DELETE;
        s_delete_dec_ip.u4_size = sizeof(ivd_delete_ip_t);
        s_delete_dec_op.u4_size = sizeof(ivd_delete_op_t);

        ret = ivd_api_function((iv_obj_t *) codec_obj, (void *) &s_delete_dec_ip,
                               (void *) &s_delete_dec_op);

        if(IV_SUCCESS != ret)
        {
            sprintf(ac_error_str, "Error in Codec delete");
            codec_exit(ac_error_str);
        }
    }
    /***********************************************************************/
    /*              Close all the files and free all the memory            */
    /***********************************************************************/
    {
        fclose(ps_ip_file);

        if((1 == s_app_ctx.u4_file_save_flag) && (strstr(s_app_ctx.ac_op_fname, "%d") == NULL))
        {
            fclose(ps_op_file);
        }
        if(1 == s_app_ctx.u4_chksum_save_flag)
        {
            fclose(ps_op_chksum_file);
        }
        if(1 == s_app_ctx.u4_frame_info_enable)
        {
            if(NULL != ps_qp_file)
            {
                fclose(ps_qp_file);
            }
            if(NULL != ps_mb_type_file)
            {
                fclose(ps_mb_type_file);
            }
        }
    }

    if(0 == s_app_ctx.u4_share_disp_buf)
    {
        free(ps_out_buf->pu1_bufs[0]);
    }

    for(i = 0; i < s_app_ctx.num_disp_buf; i++)
    {
        free(s_app_ctx.s_disp_buffers[i].pu1_bufs[0]);
    }

    free(ps_out_buf);
    free(pu1_bs_buf);
    if(1 == s_app_ctx.u4_frame_info_enable)
    {
        if(pu1_qp_map_buf)
        {
            free(pu1_qp_map_buf);
        }
        if(pu1_blk_type_map_buf)
        {
            free(pu1_blk_type_map_buf);
        }
    }

    if(s_app_ctx.display_thread_handle) free(s_app_ctx.display_thread_handle);

    return (0);
}