Upgrade libhevc to v1.2.0 am: 5e1f4eca4e am: 97c882fb98 am: 14d0d6d0bd am: 88bf7c2497 am: a03eb12b9f

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

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

12 files changed, 190 insertions, 139 deletions

diff --git a/Android.bp b/Android.bp
index a7ca755..7e8a6e7 100644
--- a/Android.bp
+++ b/Android.bp
@@ -40,7 +40,6 @@ cc_library_static {
 
     cflags: [
         "-D_LIB",
-        "-DMULTICORE",
         "-fPIC",
 
         "-O3",
diff --git a/METADATA b/METADATA
index c196d34..97a0771 100644
--- a/METADATA
+++ b/METADATA
@@ -1,16 +1,19 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update libhevc
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
 name: "libhevc"
 description: "Android fork of the libhevc library."
-
 third_party {
   url {
     type: GIT
     value: "https://github.com/ittiam-systems/libhevc.git"
   }
-  version: "v1.1.1"
+  version: "v1.2.0"
   license_type: NOTICE
   last_upgrade_date {
     year: 2023
-    month: 04
-    day: 24
+    month: 8
+    day: 8
   }
 }
diff --git a/decoder/ihevcd_api.c b/decoder/ihevcd_api.c
index 031808d..e37d44b 100644
--- a/decoder/ihevcd_api.c
+++ b/decoder/ihevcd_api.c
@@ -822,15 +822,11 @@ static IV_API_CALL_STATUS_T api_check_struct_sanity(iv_obj_t *ps_handle,
                         return IV_FAIL;
                     }
 
-#ifdef MULTICORE
                     if((ps_ip->u4_num_cores < 1) || (ps_ip->u4_num_cores > MAX_NUM_CORES))
-#else
-                    if(ps_ip->u4_num_cores != 1)
-#endif
-                        {
-                            ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
-                            return IV_FAIL;
-                        }
+                    {
+                        ps_op->u4_error_code |= 1 << IVD_UNSUPPORTEDPARAM;
+                        return IV_FAIL;
+                    }
                     break;
                 }
                 case IHEVCD_CXA_CMD_CTL_SET_PROCESSOR:
@@ -1216,6 +1212,7 @@ WORD32 ihevcd_allocate_static_bufs(iv_obj_t **pps_codec_obj,
     ps_codec->pf_aligned_alloc = pf_aligned_alloc;
     ps_codec->pf_aligned_free = pf_aligned_free;
     ps_codec->pv_mem_ctxt = pv_mem_ctxt;
+    ps_codec->i4_threads_active = ps_create_ip->u4_keep_threads_active;
 
     /* Request memory to hold thread handles for each processing thread */
     size = MAX_PROCESS_THREADS * ithread_get_handle_size();
@@ -1230,52 +1227,52 @@ WORD32 ihevcd_allocate_static_bufs(iv_obj_t **pps_codec_obj,
                         (UWORD8 *)pv_buf + (i * handle_size);
     }
 
-#ifdef KEEP_THREADS_ACTIVE
-    /* Request memory to hold mutex (start/done) for each processing thread */
-    size = 2 * MAX_PROCESS_THREADS * ithread_get_mutex_lock_size();
-    pv_buf = ps_codec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
-    RETURN_IF((NULL == pv_buf), IV_FAIL);
-    memset(pv_buf, 0, size);
-
-    for(i = 0; i < MAX_PROCESS_THREADS; i++)
+    if(ps_codec->i4_threads_active)
     {
-        WORD32 ret;
-        WORD32 mutex_size = ithread_get_mutex_lock_size();
-        ps_codec->apv_proc_start_mutex[i] =
-                        (UWORD8 *)pv_buf + (2 * i * mutex_size);
-        ps_codec->apv_proc_done_mutex[i] =
-                        (UWORD8 *)pv_buf + ((2 * i + 1) * mutex_size);
-
-        ret = ithread_mutex_init(ps_codec->apv_proc_start_mutex[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+        /* Request memory to hold mutex (start/done) for each processing thread */
+        size = 2 * MAX_PROCESS_THREADS * ithread_get_mutex_lock_size();
+        pv_buf = ps_codec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
+        RETURN_IF((NULL == pv_buf), IV_FAIL);
+        memset(pv_buf, 0, size);
 
-        ret = ithread_mutex_init(ps_codec->apv_proc_done_mutex[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
-    }
+        for(i = 0; i < MAX_PROCESS_THREADS; i++)
+        {
+            WORD32 ret;
+            WORD32 mutex_size = ithread_get_mutex_lock_size();
+            ps_codec->apv_proc_start_mutex[i] =
+                            (UWORD8 *)pv_buf + (2 * i * mutex_size);
+            ps_codec->apv_proc_done_mutex[i] =
+                            (UWORD8 *)pv_buf + ((2 * i + 1) * mutex_size);
+
+            ret = ithread_mutex_init(ps_codec->apv_proc_start_mutex[i]);
+            RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-    size = 2 * MAX_PROCESS_THREADS * ithread_get_cond_struct_size();
-    pv_buf = ps_codec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
-    RETURN_IF((NULL == pv_buf), IV_FAIL);
-    memset(pv_buf, 0, size);
+            ret = ithread_mutex_init(ps_codec->apv_proc_done_mutex[i]);
+            RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+        }
 
-    for(i = 0; i < MAX_PROCESS_THREADS; i++)
-    {
-        WORD32 ret;
-        WORD32 cond_size = ithread_get_cond_struct_size();
-        ps_codec->apv_proc_start_condition[i] =
-                        (UWORD8 *)pv_buf + (2 * i * cond_size);
-        ps_codec->apv_proc_done_condition[i] =
-                        (UWORD8 *)pv_buf + ((2 * i + 1) * cond_size);
+        size = 2 * MAX_PROCESS_THREADS * ithread_get_cond_struct_size();
+        pv_buf = ps_codec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
+        RETURN_IF((NULL == pv_buf), IV_FAIL);
+        memset(pv_buf, 0, size);
 
-        ret = ithread_cond_init(ps_codec->apv_proc_start_condition[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+        for(i = 0; i < MAX_PROCESS_THREADS; i++)
+        {
+            WORD32 ret;
+            WORD32 cond_size = ithread_get_cond_struct_size();
+            ps_codec->apv_proc_start_condition[i] =
+                            (UWORD8 *)pv_buf + (2 * i * cond_size);
+            ps_codec->apv_proc_done_condition[i] =
+                            (UWORD8 *)pv_buf + ((2 * i + 1) * cond_size);
+
+            ret = ithread_cond_init(ps_codec->apv_proc_start_condition[i]);
+            RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-        ret = ithread_cond_init(ps_codec->apv_proc_done_condition[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+            ret = ithread_cond_init(ps_codec->apv_proc_done_condition[i]);
+            RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+        }
     }
 
-#endif
-
     /* Request memory for static bitstream buffer which holds bitstream after emulation prevention */
     size = MIN_BITSBUF_SIZE;
     pv_buf = pf_aligned_alloc(pv_mem_ctxt, 128, size + 16); //Alloc extra for parse optimization
@@ -1464,6 +1461,37 @@ WORD32 ihevcd_allocate_static_bufs(iv_obj_t **pps_codec_obj,
     return (status);
 }
 
+WORD32 ihevcd_join_threads(codec_t *ps_codec)
+{
+    if(ps_codec->i4_threads_active)
+    {
+        int i;
+        /* Wait for threads */
+        ps_codec->i4_break_threads = 1;
+
+        for(i = 0; i < MAX_PROCESS_THREADS; i++)
+        {
+            WORD32 ret;
+            if(ps_codec->ai4_process_thread_created[i])
+            {
+                ret = ithread_mutex_lock(ps_codec->apv_proc_start_mutex[i]);
+                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+
+                ps_codec->ai4_process_start[i] = 1;
+                ret = ithread_cond_signal(ps_codec->apv_proc_start_condition[i]);
+                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+
+                ret = ithread_mutex_unlock(ps_codec->apv_proc_start_mutex[i]);
+                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+
+                ithread_join(ps_codec->apv_process_thread_handle[i], NULL);
+
+                ps_codec->ai4_process_thread_created[i] = 0;
+            }
+        }
+    }
+    return IV_SUCCESS;
+}
 /**
 *******************************************************************************
 *
@@ -1494,43 +1522,29 @@ WORD32 ihevcd_free_static_bufs(iv_obj_t *ps_codec_obj)
     pf_aligned_free = ps_codec->pf_aligned_free;
     pv_mem_ctxt = ps_codec->pv_mem_ctxt;
 
-#ifdef KEEP_THREADS_ACTIVE
-    /* Wait for threads */
-    ps_codec->i4_break_threads = 1;
-    for(int i = 0; i < MAX_PROCESS_THREADS; i++)
+    if(ps_codec->i4_threads_active)
     {
-        WORD32 ret;
-        if(ps_codec->ai4_process_thread_created[i])
+        /* Wait for threads */
+        ihevcd_join_threads(ps_codec);
+
+        for(int i = 0; i < MAX_PROCESS_THREADS; i++)
         {
-            ret = ithread_mutex_lock(ps_codec->apv_proc_start_mutex[i]);
+            WORD32 ret;
+            ret = ithread_cond_destroy(ps_codec->apv_proc_start_condition[i]);
             RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-            ps_codec->ai4_process_start[i] = 1;
-            ret = ithread_cond_signal(ps_codec->apv_proc_start_condition[i]);
+            ret = ithread_cond_destroy(ps_codec->apv_proc_done_condition[i]);
             RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-            ret = ithread_mutex_unlock(ps_codec->apv_proc_start_mutex[i]);
+            ret = ithread_mutex_destroy(ps_codec->apv_proc_start_mutex[i]);
             RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-            ithread_join(ps_codec->apv_process_thread_handle[i], NULL);
-
-            ps_codec->ai4_process_thread_created[i] = 0;
+            ret = ithread_mutex_destroy(ps_codec->apv_proc_done_mutex[i]);
+            RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
         }
-        ret = ithread_cond_destroy(ps_codec->apv_proc_start_condition[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
-
-        ret = ithread_cond_destroy(ps_codec->apv_proc_done_condition[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
-
-        ret = ithread_mutex_destroy(ps_codec->apv_proc_start_mutex[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
-
-        ret = ithread_mutex_destroy(ps_codec->apv_proc_done_mutex[i]);
-        RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+        ALIGNED_FREE(ps_codec, ps_codec->apv_proc_start_mutex[0]);
+        ALIGNED_FREE(ps_codec, ps_codec->apv_proc_start_condition[0]);
     }
-    ALIGNED_FREE(ps_codec, ps_codec->apv_proc_start_mutex[0]);
-    ALIGNED_FREE(ps_codec, ps_codec->apv_proc_start_condition[0]);
-#endif
 
     ALIGNED_FREE(ps_codec, ps_codec->apv_process_thread_handle[0]);
     ALIGNED_FREE(ps_codec, ps_codec->pu1_bitsbuf_static);
@@ -2943,6 +2957,8 @@ WORD32 ihevcd_reset(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
     if(ps_codec != NULL)
     {
         DEBUG("\nReset called \n");
+        ihevcd_join_threads(ps_codec);
+
         ihevcd_init(ps_codec);
     }
     else
@@ -3504,11 +3520,7 @@ WORD32 ihevcd_set_num_cores(iv_obj_t *ps_codec_obj,
     ps_ip = (ihevcd_cxa_ctl_set_num_cores_ip_t *)pv_api_ip;
     ps_op = (ihevcd_cxa_ctl_set_num_cores_op_t *)pv_api_op;
 
-#ifdef MULTICORE
     ps_codec->i4_num_cores = ps_ip->u4_num_cores;
-#else
-    ps_codec->i4_num_cores = 1;
-#endif
     ps_op->u4_error_code = 0;
     return IV_SUCCESS;
 }
diff --git a/decoder/ihevcd_cxa.h b/decoder/ihevcd_cxa.h
index 7baf480..8434a53 100644
--- a/decoder/ihevcd_cxa.h
+++ b/decoder/ihevcd_cxa.h
@@ -176,6 +176,11 @@ typedef struct {
      * enable_frm_info
      */
     UWORD32                                 u4_enable_frame_info;
+
+    /**
+     * enable_threads
+     */
+    UWORD32                                  u4_keep_threads_active;
 }ihevcd_cxa_create_ip_t;
 
 
diff --git a/decoder/ihevcd_decode.c b/decoder/ihevcd_decode.c
index d9ee1c0..8047483 100644
--- a/decoder/ihevcd_decode.c
+++ b/decoder/ihevcd_decode.c
@@ -983,22 +983,25 @@ WORD32 ihevcd_decode(iv_obj_t *ps_codec_obj, void *pv_api_ip, void *pv_api_op)
         {
             if(ps_codec->ai4_process_thread_created[i])
             {
-#ifdef KEEP_THREADS_ACTIVE
-                ret = ithread_mutex_lock(ps_codec->apv_proc_done_mutex[i]);
-                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+                if(ps_codec->i4_threads_active)
+                {
+                    ret = ithread_mutex_lock(ps_codec->apv_proc_done_mutex[i]);
+                    RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-                while(!ps_codec->ai4_process_done[i])
+                    while(!ps_codec->ai4_process_done[i])
+                    {
+                        ithread_cond_wait(ps_codec->apv_proc_done_condition[i],
+                                          ps_codec->apv_proc_done_mutex[i]);
+                    }
+                    ps_codec->ai4_process_done[i] = 0;
+                    ret = ithread_mutex_unlock(ps_codec->apv_proc_done_mutex[i]);
+                    RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+                }
+                else
                 {
-                    ithread_cond_wait(ps_codec->apv_proc_done_condition[i],
-                                      ps_codec->apv_proc_done_mutex[i]);
+                    ithread_join(ps_codec->apv_process_thread_handle[i], NULL);
+                    ps_codec->ai4_process_thread_created[i] = 0;
                 }
-                ps_codec->ai4_process_done[i] = 0;
-                ret = ithread_mutex_unlock(ps_codec->apv_proc_done_mutex[i]);
-                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
-#else
-                ithread_join(ps_codec->apv_process_thread_handle[i], NULL);
-                ps_codec->ai4_process_thread_created[i] = 0;
-#endif
             }
         }
 
diff --git a/decoder/ihevcd_parse_slice_header.c b/decoder/ihevcd_parse_slice_header.c
index e452488..9742456 100644
--- a/decoder/ihevcd_parse_slice_header.c
+++ b/decoder/ihevcd_parse_slice_header.c
@@ -440,6 +440,9 @@ IHEVCD_ERROR_T ihevcd_parse_slice_header(codec_t *ps_codec,
                 {
                     numbits = 32 - CLZ(ps_sps->i1_num_short_term_ref_pic_sets - 1);
                     BITS_PARSE("short_term_ref_pic_set_idx", value, ps_bitstrm, numbits);
+                    if (value >= ps_sps->i1_num_short_term_ref_pic_sets) {
+                        return IHEVCD_INVALID_PARAMETER;
+                    }
                     ps_slice_hdr->i1_short_term_ref_pic_set_idx = value;
                 }
 
diff --git a/decoder/ihevcd_process_slice.c b/decoder/ihevcd_process_slice.c
index 50b2c00..c9f83e8 100644
--- a/decoder/ihevcd_process_slice.c
+++ b/decoder/ihevcd_process_slice.c
@@ -1596,31 +1596,32 @@ void ihevcd_process_thread(process_ctxt_t *ps_proc)
         ithread_set_affinity(ps_proc->i4_id + 1);
     }
 
-#ifdef KEEP_THREADS_ACTIVE
     while(1)
     {
         codec_t *ps_dec = ps_proc->ps_codec;
-        DEBUG("In ihevcd_process_thread \n");
+        if(ps_proc->ps_codec->i4_threads_active)
+        {
+            DEBUG("In ihevcd_process_thread \n");
 
-        ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[ps_proc->i4_id]);
-        if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
-            break;
+            ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[ps_proc->i4_id]);
+            if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
+                break;
 
-        while(!ps_dec->ai4_process_start[ps_proc->i4_id])
-        {
-            ithread_cond_wait(ps_dec->apv_proc_start_condition[ps_proc->i4_id],
-                              ps_dec->apv_proc_start_mutex[ps_proc->i4_id]);
-        }
-        ps_dec->ai4_process_start[ps_proc->i4_id] = 0;
-        ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[ps_proc->i4_id]);
-        if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
-            break;
+            while(!ps_dec->ai4_process_start[ps_proc->i4_id])
+            {
+                ithread_cond_wait(ps_dec->apv_proc_start_condition[ps_proc->i4_id],
+                                  ps_dec->apv_proc_start_mutex[ps_proc->i4_id]);
+            }
+            ps_dec->ai4_process_start[ps_proc->i4_id] = 0;
+            ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[ps_proc->i4_id]);
+            if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
+                break;
 
-        DEBUG(" Got control at ihevcd_process_thread \n");
+            DEBUG(" Got control at ihevcd_process_thread \n");
 
-        if(ps_dec->i4_break_threads == 1)
-            break;
-#endif
+            if(ps_dec->i4_break_threads == 1)
+                break;
+        }
         while(1)
         {
             proc_job_t s_job;
@@ -1670,19 +1671,24 @@ void ihevcd_process_thread(process_ctxt_t *ps_proc)
                                 s_job.i2_ctb_y << ps_sps->i1_log2_ctb_size, num_rows);
             }
         }
-#ifdef KEEP_THREADS_ACTIVE
-        ret = ithread_mutex_lock(ps_dec->apv_proc_done_mutex[ps_proc->i4_id]);
-        if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
-            break;
+        if(ps_proc->ps_codec->i4_threads_active)
+        {
+            ret = ithread_mutex_lock(ps_dec->apv_proc_done_mutex[ps_proc->i4_id]);
+            if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
+                break;
 
-        ps_dec->ai4_process_done[ps_proc->i4_id] = 1;
-        ithread_cond_signal(ps_dec->apv_proc_done_condition[ps_proc->i4_id]);
+            ps_dec->ai4_process_done[ps_proc->i4_id] = 1;
+            ithread_cond_signal(ps_dec->apv_proc_done_condition[ps_proc->i4_id]);
 
-        ret = ithread_mutex_unlock(ps_dec->apv_proc_done_mutex[ps_proc->i4_id]);
-        if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
+            ret = ithread_mutex_unlock(ps_dec->apv_proc_done_mutex[ps_proc->i4_id]);
+            if((IHEVCD_ERROR_T)IHEVCD_SUCCESS != ret)
+                break;
+        }
+        else
+        {
             break;
+        }
     }
-#endif
     //ithread_exit(0);
     return;
 }
diff --git a/decoder/ihevcd_structs.h b/decoder/ihevcd_structs.h
index cbc86af..d974756 100644
--- a/decoder/ihevcd_structs.h
+++ b/decoder/ihevcd_structs.h
@@ -2080,7 +2080,6 @@ struct _codec_t
      */
     parse_ctxt_t s_parse;
 
-#ifdef KEEP_THREADS_ACTIVE
     /**
      * Condition variable to signal process start
      */
@@ -2115,7 +2114,6 @@ struct _codec_t
      * Flag to signal processing thread to exit
      */
     WORD32 i4_break_threads;
-#endif
 
     /**
      * Processing context - One for each processing thread
@@ -2239,6 +2237,8 @@ struct _codec_t
 
     /** Number of active display buffers - for shared mode */
     WORD32  i4_share_disp_buf_cnt;
+
+    WORD32 i4_threads_active;
 };
 
 #endif /* _IHEVCD_STRUCTS_H_ */
diff --git a/decoder/ihevcd_utils.c b/decoder/ihevcd_utils.c
index 563d948..d38703a 100755
--- a/decoder/ihevcd_utils.c
+++ b/decoder/ihevcd_utils.c
@@ -1040,9 +1040,10 @@ IHEVCD_ERROR_T ihevcd_parse_pic_init(codec_t *ps_codec)
     /* Reset the jobq to start of the jobq buffer */
     ihevcd_jobq_reset((jobq_t *)ps_codec->pv_proc_jobq);
 
-#ifdef KEEP_THREADS_ACTIVE
-    ps_codec->i4_break_threads = 0;
-#endif
+    if(ps_codec->i4_threads_active)
+    {
+        ps_codec->i4_break_threads = 0;
+    }
     ps_codec->s_parse.i4_pic_pu_idx = 0;
     ps_codec->s_parse.i4_pic_tu_idx = 0;
 
@@ -1248,16 +1249,17 @@ IHEVCD_ERROR_T ihevcd_parse_pic_init(codec_t *ps_codec)
                                 (void *)&ps_codec->as_process[i]);
                     ps_codec->ai4_process_thread_created[i] = 1;
                 }
-#ifdef KEEP_THREADS_ACTIVE
-                ret = ithread_mutex_lock(ps_codec->apv_proc_start_mutex[i]);
-                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+                if(ps_codec->i4_threads_active)
+                {
+                    ret = ithread_mutex_lock(ps_codec->apv_proc_start_mutex[i]);
+                    RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
 
-                ps_codec->ai4_process_start[i] = 1;
-                ithread_cond_signal(ps_codec->apv_proc_start_condition[i]);
+                    ps_codec->ai4_process_start[i] = 1;
+                    ithread_cond_signal(ps_codec->apv_proc_start_condition[i]);
 
-                ret = ithread_mutex_unlock(ps_codec->apv_proc_start_mutex[i]);
-                RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
-#endif
+                    ret = ithread_mutex_unlock(ps_codec->apv_proc_start_mutex[i]);
+                    RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
+                }
             }
             else
             {
diff --git a/fuzzer/hevc_dec_fuzzer.cpp b/fuzzer/hevc_dec_fuzzer.cpp
index 8dec5da..be3a054 100644
--- a/fuzzer/hevc_dec_fuzzer.cpp
+++ b/fuzzer/hevc_dec_fuzzer.cpp
@@ -118,6 +118,7 @@ void Codec::createCodec() {
   create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
   create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
   create_ip.s_ivd_create_ip_t.e_output_format = mColorFormat;
+  create_ip.u4_keep_threads_active = 1;
   create_ip.s_ivd_create_ip_t.pf_aligned_alloc = iv_aligned_malloc;
   create_ip.s_ivd_create_ip_t.pf_aligned_free = iv_aligned_free;
   create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
@@ -256,7 +257,9 @@ void Codec::allocFrame() {
 void Codec::decodeHeader(const uint8_t *data, size_t size) {
   setParams(IVD_DECODE_HEADER);
 
-  while (size > 0) {
+  size_t numDecodeCalls = 0;
+
+  while (size > 0 && numDecodeCalls < kMaxNumDecodeCalls) {
     IV_API_CALL_STATUS_T ret;
     ivd_video_decode_ip_t dec_ip{};
     ivd_video_decode_op_t dec_op{};
@@ -283,6 +286,7 @@ void Codec::decodeHeader(const uint8_t *data, size_t size) {
 
     data += bytes_consumed;
     size -= bytes_consumed;
+    numDecodeCalls++;
 
     mWidth = std::min(dec_op.u4_pic_wd, (UWORD32)10240);
     mHeight = std::min(dec_op.u4_pic_ht, (UWORD32)10240);
diff --git a/fuzzer/ossfuzz.sh b/fuzzer/ossfuzz.sh
index ee1f1c7..2145c75 100755
--- a/fuzzer/ossfuzz.sh
+++ b/fuzzer/ossfuzz.sh
@@ -18,10 +18,10 @@ test "${SRC}" != "" || exit 1
 test "${WORK}" != "" || exit 1
 test "${OUT}" != "" || exit 1
 
-#Opt out of null and shift sanitizers in undefined sanitizer
+#Opt out of shift sanitizer in undefined sanitizer
 if [[ $SANITIZER = *undefined* ]]; then
-  CFLAGS="$CFLAGS -fno-sanitize=null,shift"
-  CXXFLAGS="$CXXFLAGS -fno-sanitize=null,shift"
+  CFLAGS="$CFLAGS -fno-sanitize=shift"
+  CXXFLAGS="$CXXFLAGS -fno-sanitize=shift"
 fi
 
 # Build libhevc
diff --git a/test/decoder/main.c b/test/decoder/main.c
index 8028de3..3ed97dd 100644
--- a/test/decoder/main.c
+++ b/test/decoder/main.c
@@ -227,6 +227,9 @@ typedef struct
     WORD32  quit;
     WORD32  paused;
 
+    /* Active threads present*/
+    UWORD32 i4_active_threads;
+
 
     void *pv_disp_ctx;
     void *display_thread_handle;
@@ -277,6 +280,8 @@ typedef enum
     SOC,
     PICLEN,
     PICLEN_FILE,
+
+    KEEP_THREADS_ACTIVE,
 }ARGUMENT_T;
 
 typedef struct
@@ -342,6 +347,8 @@ static const argument_t argument_mapping[] =
         "Set Architecture. Supported values  ARM_NONEON, ARM_A9Q, ARM_A7, ARM_A5, ARM_NEONINTR, X86_GENERIC, X86_SSSE3, X86_SSE4 \n" },
     { "--",  "--soc", SOC,
         "Set SOC. Supported values  GENERIC, HISI_37X \n" },
+    {"--", "--keep_threads_active", KEEP_THREADS_ACTIVE,
+        "Keep threads active"},
 };
 
 #define PEAK_WINDOW_SIZE            8
@@ -854,6 +861,7 @@ IV_API_CALL_STATUS_T get_version(void *codec_obj)
 /*****************************************************************************/
 void codec_exit(CHAR *pc_err_message)
 {
+    printf("Summary\n");
     printf("%s\n", pc_err_message);
     exit(-1);
 }
@@ -1335,6 +1343,10 @@ void parse_argument(vid_dec_ctx_t *ps_app_ctx, CHAR *argument, CHAR *value)
             sscanf(value, "%s", ps_app_ctx->ac_piclen_fname);
             break;
 
+        case KEEP_THREADS_ACTIVE:
+            sscanf(value, "%d", &ps_app_ctx->i4_active_threads);
+            break;
+
         case INVALID:
         default:
             printf("Ignoring argument :  %s\n", argument);
@@ -1879,6 +1891,7 @@ int main(WORD32 argc, CHAR *argv[])
     s_app_ctx.full_screen = 0;
     s_app_ctx.u4_piclen_flag = 0;
     s_app_ctx.u4_frame_info_enable = 0;
+    s_app_ctx.i4_active_threads = 1;
     s_app_ctx.fps = DEFAULT_FPS;
     file_pos = 0;
     total_bytes_comsumed = 0;
@@ -2157,6 +2170,7 @@ int main(WORD32 argc, CHAR *argv[])
             s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ihevcd_cxa_create_ip_t);
             s_create_op.s_ivd_create_op_t.u4_size = sizeof(ihevcd_cxa_create_op_t);
             s_create_ip.u4_enable_frame_info = s_app_ctx.u4_frame_info_enable;
+            s_create_ip.u4_keep_threads_active = s_app_ctx.i4_active_threads;