Merge "Decoder: add support to use ihevcd instead of ivd structures" am: 104da7c893

Original change: https://android-review.googlesource.com/c/platform/external/libhevc/+/1972340

Change-Id: Iafbda89da650453d457e1fd1f8a07619f6f57c17
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

3 files changed, 137 insertions, 98 deletions

diff --git a/decoder/ihevcd_api.c b/decoder/ihevcd_api.c
index d8ee57d..9bca829 100644
--- a/decoder/ihevcd_api.c
+++ b/decoder/ihevcd_api.c
@@ -417,8 +417,7 @@ static IV_API_CALL_STATUS_T api_check_struct_sanity(iv_obj_t *ps_handle,
             if(ps_ip->s_ivd_video_decode_ip_t.u4_size
                             != sizeof(ihevcd_cxa_video_decode_ip_t)
                             && ps_ip->s_ivd_video_decode_ip_t.u4_size
-                                            != offsetof(ivd_video_decode_ip_t,
-                                                        s_out_buffer))
+                                            != sizeof(ivd_video_decode_ip_t))
             {
                 ps_op->s_ivd_video_decode_op_t.u4_error_code |= 1
                                 << IVD_UNSUPPORTEDPARAM;
@@ -430,8 +429,7 @@ static IV_API_CALL_STATUS_T api_check_struct_sanity(iv_obj_t *ps_handle,
             if(ps_op->s_ivd_video_decode_op_t.u4_size
                             != sizeof(ihevcd_cxa_video_decode_op_t)
                             && ps_op->s_ivd_video_decode_op_t.u4_size
-                                            != offsetof(ivd_video_decode_op_t,
-                                                        u4_output_present))
+                                            != sizeof(ivd_video_decode_op_t))
             {
                 ps_op->s_ivd_video_decode_op_t.u4_error_code |= 1
                                 << IVD_UNSUPPORTEDPARAM;
@@ -494,7 +492,9 @@ static IV_API_CALL_STATUS_T api_check_struct_sanity(iv_obj_t *ps_handle,
                     ps_op = (ihevcd_cxa_ctl_set_config_op_t *)pv_api_op;
 
                     if(ps_ip->s_ivd_ctl_set_config_ip_t.u4_size
-                                    != sizeof(ihevcd_cxa_ctl_set_config_ip_t))
+                                    != sizeof(ihevcd_cxa_ctl_set_config_ip_t) &&
+                                    ps_ip->s_ivd_ctl_set_config_ip_t.u4_size
+                                                != sizeof(ivd_ctl_set_config_ip_t))
                     {
                         ps_op->s_ivd_ctl_set_config_op_t.u4_error_code |= 1
                                         << IVD_UNSUPPORTEDPARAM;
diff --git a/decoder/ihevcd_decode.c b/decoder/ihevcd_decode.c
index 1eabb3b..4eed26c 100644
--- a/decoder/ihevcd_decode.c
+++ b/decoder/ihevcd_decode.c
@@ -183,10 +183,20 @@ static UWORD32 ihevcd_map_error(IHEVCD_ERROR_T e_error)
  *******************************************************************************
  */
 static void ihevcd_fill_outargs(codec_t *ps_codec,
-                                ivd_video_decode_ip_t *ps_dec_ip,
-                                ivd_video_decode_op_t *ps_dec_op)
+                                void *pv_api_ip,
+                                void *pv_api_op)
 {
 
+    ihevcd_cxa_video_decode_ip_t *ps_hevcd_dec_ip;
+    ihevcd_cxa_video_decode_op_t *ps_hevcd_dec_op;
+    ivd_video_decode_ip_t *ps_dec_ip;
+    ivd_video_decode_op_t *ps_dec_op;
+
+    ps_hevcd_dec_ip = (ihevcd_cxa_video_decode_ip_t *)pv_api_ip;
+    ps_hevcd_dec_op = (ihevcd_cxa_video_decode_op_t *)pv_api_op;
+    ps_dec_ip = &ps_hevcd_dec_ip->s_ivd_video_decode_ip_t;
+    ps_dec_op = &ps_hevcd_dec_op->s_ivd_video_decode_op_t;
+
     ps_dec_op->u4_error_code = ihevcd_map_error((IHEVCD_ERROR_T)ps_codec->i4_error_code);
     ps_dec_op->u4_num_bytes_consumed = ps_dec_ip->u4_num_Bytes
                     - ps_codec->i4_bytes_remaining;
@@ -387,6 +397,9 @@ WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
 {
     WORD32 ret = IV_SUCCESS;
     codec_t *ps_codec = (codec_t *)(ps_codec_obj->pv_codec_handle);
+    ihevcd_cxa_video_decode_ip_t s_hevcd_dec_ip = {};
+    ihevcd_cxa_video_decode_ip_t *ps_hevcd_dec_ip;
+    ihevcd_cxa_video_decode_op_t *ps_hevcd_dec_op;
     ivd_video_decode_ip_t *ps_dec_ip;
     ivd_video_decode_op_t *ps_dec_op;
 
@@ -399,11 +412,18 @@ WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
     ps_codec->i4_bytes_remaining = 0;
 
     ps_dec_ip = (ivd_video_decode_ip_t *)pv_api_ip;
-    ps_dec_op = (ivd_video_decode_op_t *)pv_api_op;
+    memcpy(&s_hevcd_dec_ip, ps_dec_ip, ps_dec_ip->u4_size);
+    s_hevcd_dec_ip.s_ivd_video_decode_ip_t.u4_size = sizeof(ihevcd_cxa_video_decode_ip_t);
+
+    ps_hevcd_dec_ip = &s_hevcd_dec_ip;
+    ps_dec_ip = &ps_hevcd_dec_ip->s_ivd_video_decode_ip_t;
+
+    ps_hevcd_dec_op = (ihevcd_cxa_video_decode_op_t *)pv_api_op;
+    ps_dec_op = &ps_hevcd_dec_op->s_ivd_video_decode_op_t;
 
     {
         UWORD32 u4_size = ps_dec_op->u4_size;
-        memset(ps_dec_op, 0, sizeof(ivd_video_decode_op_t));
+        memset(ps_hevcd_dec_op, 0, u4_size);
         ps_dec_op->u4_size = u4_size; //Restore size field
     }
     if(ps_codec->i4_init_done != 1)
@@ -532,7 +552,7 @@ WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
                                   ps_codec->i4_disp_buf_id, BUF_MGR_DISP);
         }
 
-        ihevcd_fill_outargs(ps_codec, ps_dec_ip, ps_dec_op);
+        ihevcd_fill_outargs(ps_codec, ps_hevcd_dec_ip, ps_hevcd_dec_op);
 
         if(1 == ps_dec_op->u4_output_present)
         {
@@ -936,7 +956,7 @@ WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
         /* Increment the number of pictures decoded */
         ps_codec->u4_pic_cnt++;
     }
-    ihevcd_fill_outargs(ps_codec, ps_dec_ip, ps_dec_op);
+    ihevcd_fill_outargs(ps_codec, ps_hevcd_dec_ip, ps_hevcd_dec_op);
 
     if(1 == ps_dec_op->u4_output_present)
     {
diff --git a/test/decoder/main.c b/test/decoder/main.c
index 3773056..e274fba 100644
--- a/test/decoder/main.c
+++ b/test/decoder/main.c
@@ -1625,42 +1625,46 @@ void flush_output(iv_obj_t *codec_obj,
 
         if(IV_SUCCESS == ret)
         {
-            ivd_video_decode_ip_t s_video_decode_ip;
-            ivd_video_decode_op_t s_video_decode_op;
-
-            s_video_decode_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-            s_video_decode_ip.u4_ts = u4_ip_frm_ts;
-            s_video_decode_ip.pv_stream_buffer = pu1_bs_buf;
-            s_video_decode_ip.u4_num_Bytes = u4_bytes_remaining;
-            s_video_decode_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-            s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[0] =
+            ihevcd_cxa_video_decode_ip_t s_hevcd_video_decode_ip = {};
+            ihevcd_cxa_video_decode_op_t s_hevcd_video_decode_op = {};
+            ivd_video_decode_ip_t *ps_video_decode_ip =
+                &s_hevcd_video_decode_ip.s_ivd_video_decode_ip_t;
+            ivd_video_decode_op_t *ps_video_decode_op =
+                &s_hevcd_video_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(ihevcd_cxa_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];
-            s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[1] =
+            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[1] =
                             ps_out_buf->u4_min_out_buf_size[1];
-            s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[2] =
+            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[2] =
                             ps_out_buf->u4_min_out_buf_size[2];
 
-            s_video_decode_ip.s_out_buffer.pu1_bufs[0] =
+            ps_video_decode_ip->s_out_buffer.pu1_bufs[0] =
                             ps_out_buf->pu1_bufs[0];
-            s_video_decode_ip.s_out_buffer.pu1_bufs[1] =
+            ps_video_decode_ip->s_out_buffer.pu1_bufs[1] =
                             ps_out_buf->pu1_bufs[1];
-            s_video_decode_ip.s_out_buffer.pu1_bufs[2] =
+            ps_video_decode_ip->s_out_buffer.pu1_bufs[2] =
                             ps_out_buf->pu1_bufs[2];
-            s_video_decode_ip.s_out_buffer.u4_num_bufs =
+            ps_video_decode_ip->s_out_buffer.u4_num_bufs =
                             ps_out_buf->u4_num_bufs;
 
-            s_video_decode_op.u4_size = sizeof(ivd_video_decode_op_t);
+            ps_video_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
 
             /*****************************************************************************/
             /*   API Call: Video Decode                                                  */
             /*****************************************************************************/
-            ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_video_decode_ip,
-                                       (void *)&s_video_decode_op);
+            ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_hevcd_video_decode_ip,
+                                       (void *)&s_hevcd_video_decode_op);
 
-            if(1 == s_video_decode_op.u4_output_present)
+            if(1 == ps_video_decode_op->u4_output_present)
             {
-                dump_output(ps_app_ctx, &(s_video_decode_op.s_disp_frm_buf),
-                            s_video_decode_op.u4_disp_buf_id, ps_op_file,
+                dump_output(ps_app_ctx, &(ps_video_decode_op->s_disp_frm_buf),
+                            ps_video_decode_op->u4_disp_buf_id, ps_op_file,
                             ps_op_chksum_file,
                             *pu4_op_frm_ts, ps_app_ctx->u4_file_save_flag,
                             ps_app_ctx->u4_chksum_save_flag);
@@ -2137,30 +2141,36 @@ int main(WORD32 argc, CHAR *argv[])
     /*   Decode header to get width and height and buffer sizes                  */
     /*****************************************************************************/
     {
-        ivd_video_decode_ip_t s_video_decode_ip;
-        ivd_video_decode_op_t s_video_decode_op;
+        ihevcd_cxa_video_decode_ip_t s_hevcd_video_decode_ip = {};
+        ihevcd_cxa_video_decode_op_t s_hevcd_video_decode_op = {};
+        ivd_video_decode_ip_t *ps_video_decode_ip =
+            &s_hevcd_video_decode_ip.s_ivd_video_decode_ip_t;
+        ivd_video_decode_op_t *ps_video_decode_op =
+            &s_hevcd_video_decode_op.s_ivd_video_decode_op_t;
 
 
 
         {
-            ivd_ctl_set_config_ip_t s_ctl_ip;
-            ivd_ctl_set_config_op_t s_ctl_op;
+            ihevcd_cxa_ctl_set_config_ip_t s_hevcd_ctl_ip = {};
+            ihevcd_cxa_ctl_set_config_op_t s_hevcd_ctl_op = {};
+            ivd_ctl_set_config_ip_t *ps_ctl_ip = &s_hevcd_ctl_ip.s_ivd_ctl_set_config_ip_t;
+            ivd_ctl_set_config_op_t *ps_ctl_op = &s_hevcd_ctl_op.s_ivd_ctl_set_config_op_t;
 
-
-            s_ctl_ip.u4_disp_wd = STRIDE;
+            ps_ctl_ip->u4_disp_wd = STRIDE;
             if(1 == s_app_ctx.display)
-                s_ctl_ip.u4_disp_wd = s_app_ctx.get_stride();
+                ps_ctl_ip->u4_disp_wd = s_app_ctx.get_stride();
 
-            s_ctl_ip.e_frm_skip_mode = IVD_SKIP_NONE;
-            s_ctl_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
-            s_ctl_ip.e_vid_dec_mode = IVD_DECODE_HEADER;
-            s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
-            s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
-            s_ctl_ip.u4_size = sizeof(ivd_ctl_set_config_ip_t);
-            s_ctl_op.u4_size = sizeof(ivd_ctl_set_config_op_t);
+            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(ihevcd_cxa_ctl_set_config_ip_t);
 
-            ret = ivd_cxa_api_function((iv_obj_t*)codec_obj, (void *)&s_ctl_ip,
-                                       (void *)&s_ctl_op);
+            ps_ctl_op->u4_size = sizeof(ihevcd_cxa_ctl_set_config_op_t);
+
+            ret = ivd_cxa_api_function((iv_obj_t*)codec_obj, (void *)&s_hevcd_ctl_ip,
+                                       (void *)&s_hevcd_ctl_op);
             if(ret != IV_SUCCESS)
             {
                 sprintf(ac_error_str,
@@ -2206,37 +2216,38 @@ int main(WORD32 argc, CHAR *argv[])
                 codec_exit(ac_error_str);
             }
 
-            s_video_decode_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-            s_video_decode_ip.u4_ts = u4_ip_frm_ts;
-            s_video_decode_ip.pv_stream_buffer = pu1_bs_buf;
-            s_video_decode_ip.u4_num_Bytes = u4_bytes_remaining;
-            s_video_decode_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-            s_video_decode_op.u4_size = sizeof(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(ihevcd_cxa_video_decode_ip_t);
+
+            ps_video_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
 
             /*****************************************************************************/
             /*   API Call: Header Decode                                                  */
             /*****************************************************************************/
-            ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_video_decode_ip,
-                                       (void *)&s_video_decode_op);
+            ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_hevcd_video_decode_ip,
+                                       (void *)&s_hevcd_video_decode_op);
 
             if(ret != IV_SUCCESS)
             {
                 sprintf(ac_error_str, "\nError in header decode %x",
-                        s_video_decode_op.u4_error_code);
+                        ps_video_decode_op->u4_error_code);
                 // codec_exit(ac_error_str);
             }
 
-            u4_num_bytes_dec = s_video_decode_op.u4_num_bytes_consumed;
+            u4_num_bytes_dec = ps_video_decode_op->u4_num_bytes_consumed;
 #ifndef PROFILE_ENABLE
-            printf("%d\n",s_video_decode_op.u4_num_bytes_consumed);
+            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 = s_video_decode_op.u4_pic_wd;
-        s_app_ctx.u4_pic_ht = s_video_decode_op.u4_pic_ht;
+        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);
 
@@ -2698,8 +2709,12 @@ int main(WORD32 argc, CHAR *argv[])
 
 
         {
-            ivd_video_decode_ip_t s_video_decode_ip;
-            ivd_video_decode_op_t s_video_decode_op;
+            ihevcd_cxa_video_decode_ip_t s_hevcd_video_decode_ip = {};
+            ihevcd_cxa_video_decode_op_t s_hevcd_video_decode_op = {};
+            ivd_video_decode_ip_t *ps_video_decode_ip =
+                &s_hevcd_video_decode_ip.s_ivd_video_decode_ip_t;
+            ivd_video_decode_op_t *ps_video_decode_op =
+                &s_hevcd_video_decode_op.s_ivd_video_decode_op_t;
 #ifdef PROFILE_ENABLE
             UWORD32 s_elapsed_time;
             TIMER s_start_timer;
@@ -2707,27 +2722,28 @@ int main(WORD32 argc, CHAR *argv[])
 #endif
 
 
-            s_video_decode_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-            s_video_decode_ip.u4_ts = u4_ip_frm_ts;
-            s_video_decode_ip.pv_stream_buffer = pu1_bs_buf;
-            s_video_decode_ip.u4_num_Bytes = u4_bytes_remaining;
-            s_video_decode_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-            s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[0] =
+            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(ihevcd_cxa_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];
-            s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[1] =
+            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[1] =
                             ps_out_buf->u4_min_out_buf_size[1];
-            s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[2] =
+            ps_video_decode_ip->s_out_buffer.u4_min_out_buf_size[2] =
                             ps_out_buf->u4_min_out_buf_size[2];
 
-            s_video_decode_ip.s_out_buffer.pu1_bufs[0] =
+            ps_video_decode_ip->s_out_buffer.pu1_bufs[0] =
                             ps_out_buf->pu1_bufs[0];
-            s_video_decode_ip.s_out_buffer.pu1_bufs[1] =
+            ps_video_decode_ip->s_out_buffer.pu1_bufs[1] =
                             ps_out_buf->pu1_bufs[1];
-            s_video_decode_ip.s_out_buffer.pu1_bufs[2] =
+            ps_video_decode_ip->s_out_buffer.pu1_bufs[2] =
                             ps_out_buf->pu1_bufs[2];
-            s_video_decode_ip.s_out_buffer.u4_num_bufs =
+            ps_video_decode_ip->s_out_buffer.u4_num_bufs =
                             ps_out_buf->u4_num_bufs;
-            s_video_decode_op.u4_size = sizeof(ivd_video_decode_op_t);
+
+            ps_video_decode_op->u4_size = sizeof(ihevcd_cxa_video_decode_op_t);
 
             /* Get display buffer pointers */
             if(1 == s_app_ctx.display)
@@ -2740,9 +2756,9 @@ int main(WORD32 argc, CHAR *argv[])
                     break;
 
                 s_app_ctx.set_disp_buffers(s_app_ctx.pv_disp_ctx, wr_idx,
-                                           &s_video_decode_ip.s_out_buffer.pu1_bufs[0],
-                                           &s_video_decode_ip.s_out_buffer.pu1_bufs[1],
-                                           &s_video_decode_ip.s_out_buffer.pu1_bufs[2]);
+                                           &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]);
             }
 
             /*****************************************************************************/
@@ -2751,8 +2767,8 @@ int main(WORD32 argc, CHAR *argv[])
 
             GETTIME(&s_start_timer);
 
-            ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_video_decode_ip,
-                                       (void *)&s_video_decode_op);
+            ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_hevcd_video_decode_ip,
+                                       (void *)&s_hevcd_video_decode_op);
 
 
             GETTIME(&s_end_timer);
@@ -2774,13 +2790,16 @@ int main(WORD32 argc, CHAR *argv[])
                     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, s_video_decode_op.u4_output_present, s_video_decode_op.u4_num_bytes_consumed);
+                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);
 
             }
 #ifdef INTEL_CE5300
             time_consumed += s_elapsed_time;
-            bytes_consumed += s_video_decode_op.u4_num_bytes_consumed;
+            bytes_consumed += ps_video_decode_op->u4_num_bytes_consumed;
             if(!(frm_cnt % (s_app_ctx.fps)))
             {
                 time_consumed = time_consumed / s_app_ctx.fps;
@@ -2792,17 +2811,17 @@ int main(WORD32 argc, CHAR *argv[])
             }
 #endif
 #else
-            printf("%d\n", s_video_decode_op.u4_num_bytes_consumed);
+            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,
-                       s_video_decode_op.u4_error_code);
+                       ps_video_decode_op->u4_error_code);
             }
 
             if((IV_SUCCESS != ret) &&
-                            ((s_video_decode_op.u4_error_code & 0xFF) == IVD_RES_CHANGED))
+                            ((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;
@@ -2875,7 +2894,7 @@ int main(WORD32 argc, CHAR *argv[])
             /*************************************************************************/
             /* Get SEI mastering display color volume parameters                     */
             /*************************************************************************/
-            if(1 == s_video_decode_op.u4_output_present)
+            if(1 == ps_video_decode_op->u4_output_present)
             {
 
                 ihevcd_cxa_ctl_get_sei_mastering_params_ip_t s_ctl_get_sei_mastering_params_ip;
@@ -2902,28 +2921,28 @@ int main(WORD32 argc, CHAR *argv[])
 
 
             if((1 == s_app_ctx.display) &&
-                            (1 == s_video_decode_op.u4_output_present))
+                            (1 == ps_video_decode_op->u4_output_present))
             {
                 dispq_producer_queue(&s_app_ctx);
             }
 
-            if(IV_B_FRAME == s_video_decode_op.e_pic_type)
+            if(IV_B_FRAME == ps_video_decode_op->e_pic_type)
                 s_app_ctx.b_pic_present |= 1;
 
-            u4_num_bytes_dec = s_video_decode_op.u4_num_bytes_consumed;
+            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 == s_video_decode_op.u4_output_present)
+            if(1 == ps_video_decode_op->u4_output_present)
             {
-                width = s_video_decode_op.s_disp_frm_buf.u4_y_wd;
-                height = s_video_decode_op.s_disp_frm_buf.u4_y_ht;
-                dump_output(&s_app_ctx, &(s_video_decode_op.s_disp_frm_buf),
-                            s_video_decode_op.u4_disp_buf_id, ps_op_file,
-                            ps_op_chksum_file,
+                width = ps_video_decode_op->s_disp_frm_buf.u4_y_wd;
+                height = ps_video_decode_op->s_disp_frm_buf.u4_y_ht;
+                dump_output(&s_app_ctx, &(ps_video_decode_op->s_disp_frm_buf),
+                            ps_video_decode_op->u4_disp_buf_id,
+                            ps_op_file, ps_op_chksum_file,
                             u4_op_frm_ts, s_app_ctx.u4_file_save_flag,
                             s_app_ctx.u4_chksum_save_flag);
 
@@ -2931,7 +2950,7 @@ int main(WORD32 argc, CHAR *argv[])
             }
             else
             {
-                if((s_video_decode_op.u4_error_code >> IVD_FATALERROR) & 1)
+                if((ps_video_decode_op->u4_error_code >> IVD_FATALERROR) & 1)
                 {
                     printf("Fatal error\n");
                     break;