Revert "Multi-thread parsing implementation."

BZ: 158125

This reverts commit e2699e3cabfaa4f8187451f49bd7aff411a41a9f.

Change-Id: Ifc604446a28caaae33f2e586aab390c99ed11618
diff --git a/mixvbp/include/vbp_trace.h b/mixvbp/include/vbp_trace.h
index 7fd891f..ba916b9 100755
--- a/mixvbp/include/vbp_trace.h
+++ b/mixvbp/include/vbp_trace.h
@@ -11,9 +11,9 @@
 #define VBP_TRACE_H_
 
 
-#ifndef VBP_TRACE
+
 #define VBP_TRACE
-#endif
+
 
 #ifdef VBP_TRACE /* if VBP_TRACE is defined*/
 
diff --git a/mixvbp/vbp_manager/Android.mk b/mixvbp/vbp_manager/Android.mk
index a0c95a9..a45fe7e 100755
--- a/mixvbp/vbp_manager/Android.mk
+++ b/mixvbp/vbp_manager/Android.mk
@@ -2,7 +2,7 @@
 
 include $(CLEAR_VARS)
 
-MIXVBP_LOG_ENABLE := true
+#MIXVBP_LOG_ENABLE := true
 
 LOCAL_SRC_FILES :=			\
 	vbp_h264_parser.c		\
@@ -13,10 +13,8 @@
 	viddec_parse_sc.c		\
 	viddec_pm_parser_ops.c		\
 	viddec_pm_utils_bstream.c       \
-        vbp_thread.c                    \
 
 LOCAL_CFLAGS := -DVBP -DHOST_ONLY
-LOCAL_CFLAGS += -DUSE_MULTI_THREADING
 
 LOCAL_C_INCLUDES +=			\
 	$(LOCAL_PATH)/include		\
@@ -41,8 +39,6 @@
 	libdl				\
 	libcutils
 
-LOCAL_LDLIBS += -lpthread
-
 ifeq ($(strip $(MIXVBP_LOG_ENABLE)),true)
 LOCAL_CFLAGS += -DVBP_TRACE
 LOCAL_SHARED_LIBRARIES += liblog
@@ -72,6 +68,4 @@
 LOCAL_SRC_FILES += secvideo/merrifield/vbp_h264secure_parser.c
 endif
 
-LOCAL_LDLIBS += -lpthread
-
 include $(BUILD_SHARED_LIBRARY)
diff --git a/mixvbp/vbp_manager/include/viddec_parser_ops.h b/mixvbp/vbp_manager/include/viddec_parser_ops.h
index 533b231..77054b5 100755
--- a/mixvbp/vbp_manager/include/viddec_parser_ops.h
+++ b/mixvbp/vbp_manager/include/viddec_parser_ops.h
@@ -30,10 +30,6 @@
 typedef    uint32_t (*fn_update_data)(void *parent, void *data, uint32_t size);
 #endif
 
-typedef    uint32_t (*fn_is_payload_start)(void *parent);
-typedef    uint32_t (*fn_parse_syntax_threading) (void *parent, void *ctxt, uint32_t thread_index);
-typedef    uint32_t (*fn_post_parse_threading) (void *parent, void *ctxt, uint32_t slice_index);
-typedef    uint32_t (*fn_query_thread_parsing_cap) (void);
 
 typedef struct
 {
@@ -49,10 +45,6 @@
 #if (defined USE_AVC_SHORT_FORMAT || defined USE_SLICE_HEADER_PARSING)
     fn_update_data update_data;
 #endif
-    fn_is_payload_start is_payload_start;
-    fn_parse_syntax_threading parse_syntax_threading;
-    fn_post_parse_threading post_parse_threading;
-    fn_query_thread_parsing_cap query_thread_parsing_cap;
 } viddec_parser_ops_t;
 
 
diff --git a/mixvbp/vbp_manager/vbp_h264_parser.c b/mixvbp/vbp_manager/vbp_h264_parser.c
index 9c75519..dd93ea7 100755
--- a/mixvbp/vbp_manager/vbp_h264_parser.c
+++ b/mixvbp/vbp_manager/vbp_h264_parser.c
@@ -26,7 +26,6 @@
 #include <dlfcn.h>
 
 #include "h264.h"
-#include "h264parse.h"
 #include "vbp_loader.h"
 #include "vbp_utils.h"
 #include "vbp_h264_parser.h"
@@ -186,33 +185,6 @@
         return VBP_LOAD;
     }
 
-    pcontext->parser_ops->is_payload_start = dlsym(pcontext->fd_parser, "viddec_h264_payload_start");
-    if (NULL == pcontext->parser_ops->is_payload_start)
-    {
-        ETRACE ("Failed to set entry point." );
-    }
-
-    pcontext->parser_ops->parse_syntax_threading = dlsym(pcontext->fd_parser, "viddec_h264_threading_parse");
-    if (NULL == pcontext->parser_ops->parse_syntax_threading)
-    {
-        ETRACE ("Failed to set entry point." );
-        return VBP_LOAD;
-    }
-
-    pcontext->parser_ops->post_parse_threading = dlsym(pcontext->fd_parser, "viddec_h264_post_parse");
-    if (NULL == pcontext->parser_ops->post_parse_threading)
-    {
-        ETRACE ("Failed to set entry point." );
-        return VBP_LOAD;
-    }
-
-    pcontext->parser_ops->query_thread_parsing_cap = dlsym(pcontext->fd_parser, "viddec_h264_query_thread_parsing_cap");
-    if (NULL == pcontext->parser_ops->query_thread_parsing_cap)
-    {
-        ETRACE ("Failed to set entry point." );
-        return VBP_LOAD;
-    }
-
     /* entry point not needed */
     pcontext->parser_ops->is_frame_start = NULL;
     return VBP_OK;
@@ -1050,7 +1022,6 @@
     {
         /* partial frame */
         query_data->num_pictures = 1;
-        WTRACE("partial frame found.");
     }
 
     if (query_data->num_pictures > MAX_NUM_PICTURES)
@@ -1070,7 +1041,7 @@
     pic_parms = pic_data->pic_parms;
 
     // relax this condition to support partial frame parsing
-    // TODO: Is partial frame needed to support??
+
     //if (parser->info.SliceHeader.first_mb_in_slice == 0)
     {
         /**
@@ -1160,8 +1131,6 @@
         pic_parms->pic_fields.bits.constrained_intra_pred_flag = parser->info.active_PPS.constrained_intra_pred_flag;
 
         pic_parms->frame_num = parser->info.SliceHeader.frame_num;
-
-
     }
 
 
@@ -1192,6 +1161,7 @@
         pic_parms->num_ref_idx_l1_default_active_minus1 = parser->info.active_PPS.num_ref_idx_l1_active - 1;
     }
 #endif
+
     return VBP_OK;
 }
 
@@ -1712,11 +1682,11 @@
         break;
 
     case h264_NAL_UNIT_TYPE_SPS:
-        VTRACE("SPS header is parsed.");
+        ITRACE("SPS header is parsed.");
         break;
 
     case h264_NAL_UNIT_TYPE_PPS:
-        VTRACE("PPS header is parsed.");
+        ITRACE("PPS header is parsed.");
         break;
 
     case h264_NAL_UNIT_TYPE_Acc_unit_delimiter:
@@ -1724,11 +1694,11 @@
         break;
 
     case h264_NAL_UNIT_TYPE_EOSeq:
-        VTRACE("EOSeq is parsed.");
+        ITRACE("EOSeq is parsed.");
         break;
 
     case h264_NAL_UNIT_TYPE_EOstream:
-        VTRACE("EOStream is parsed");
+        ITRACE("EOStream is parsed");
         break;
 
     default:
diff --git a/mixvbp/vbp_manager/vbp_mp42_parser.c b/mixvbp/vbp_manager/vbp_mp42_parser.c
index b954b38..9b4c63f 100755
--- a/mixvbp/vbp_manager/vbp_mp42_parser.c
+++ b/mixvbp/vbp_manager/vbp_mp42_parser.c
@@ -124,11 +124,6 @@
     /* entry point not needed */
     pcontext->parser_ops->flush = NULL;
 
-    pcontext->parser_ops->is_payload_start = NULL;
-    pcontext->parser_ops->parse_syntax_threading = NULL;
-    pcontext->parser_ops->post_parse_threading = NULL;
-    pcontext->parser_ops->query_thread_parsing_cap = NULL;
-
     return VBP_OK;
 }
 
diff --git a/mixvbp/vbp_manager/vbp_thread.c b/mixvbp/vbp_manager/vbp_thread.c
deleted file mode 100755
index e1f665b..0000000
--- a/mixvbp/vbp_manager/vbp_thread.c
+++ /dev/null
@@ -1,634 +0,0 @@
-/* INTEL CONFIDENTIAL
-* Copyright (c) 2013 Intel Corporation.  All rights reserved.
-*
-* The source code contained or described herein and all documents
-* related to the source code ("Material") are owned by Intel
-* Corporation or its suppliers or licensors.  Title to the
-* Material remains with Intel Corporation or its suppliers and
-* licensors.  The Material contains trade secrets and proprietary
-* and confidential information of Intel or its suppliers and
-* licensors. The Material is protected by worldwide copyright and
-* trade secret laws and treaty provisions.  No part of the Material
-* may be used, copied, reproduced, modified, published, uploaded,
-* posted, transmitted, distributed, or disclosed in any way without
-* Intel's prior express written permission.
-*
-* No license under any patent, copyright, trade secret or other
-* intellectual property right is granted to or conferred upon you
-* by disclosure or delivery of the Materials, either expressly, by
-* implication, inducement, estoppel or otherwise. Any license
-* under such intellectual property rights must be express and
-* approved by Intel in writing.
-*
-*/
-#include <unistd.h>
-#include <stdio.h>
-#include <assert.h>
-
-#include "vbp_thread.h"
-#include "vbp_loader.h"
-
-/* consider a qual core with hyper thread */
-#define MAX_AUTO_THREADS 8
-
-#define THREADING_SCHEME_BUNDLE
-
-typedef long long int nsecs_t;
-
-static nsecs_t systemTime()
-{
-    struct timeval t;
-    gettimeofday(&t, NULL);
-    return 1000000 * t.tv_sec + t.tv_usec;
-}
-
-
-typedef struct PerThreadContext {
-    pthread_t thread;
-
-    int32_t index;                  // thread index referenced by thread itself when needed.
-    int32_t thread_init;
-    struct ThreadContext* parent;
-
-    pthread_cond_t input_cond;      // Used to wait for a new packet from the main thread.
-    pthread_cond_t progress_cond;   // Used by child threads to wait for progress to change.
-    pthread_cond_t output_cond;     // Used by the main thread to wait for frames to finish.
-
-    pthread_mutex_t mutex;          // Mutex used to protect the contents of the PerThreadContext.
-    pthread_mutex_t progress_mutex; // Mutex used to protect frame progress values and progress_cond.
-
-    vbp_context* vbpctx;
-    viddec_pm_cxt_t* pmctx;         // Working parser context
-    viddec_pm_cxt_t* input_pmctx;   // Input parser context
-    void* codec_data;               // Points to specific codec data that holds output, all threads share
-                                    // one instance
-    uint32_t start_item;            // start of parsing item num for bundle parsing
-
-    enum {
-        STATE_INPUT_WAIT,
-        STATE_WORKING,
-        STATE_EXIT
-    } state;
-
-} PerThreadContext;
-
-typedef struct ThreadContext {
-    PerThreadContext* threads[MAX_AUTO_THREADS]; // The contexts for each thread.
-    PerThreadContext* prev_thread;               // The last thread submit_packet() was called on.
-    int delaying;                       // Set for the first N packets, where N is the number of threads.
-                                        // While it is set, vbp_thread_parse_syntax won't return any results
-
-    uint32_t next_finished;             // The next thread count to return output from.
-    uint32_t next_parsing;              // The next thread count to submit input packet to.
-
-    uint32_t active_thread_count;       // num of thread need to be warmed up
-
-    sem_t finish_sem;                   // semaphore of finish work to synchronize working thread and main thread
-    uint32_t start_item_to_parse;
-    uint32_t last_item_to_parse;
-
-} ThreadContext;
-
-
-int32_t get_cpu_count()
-{
-    int32_t cpu_num;
-#if defined(_SC_NPROC_ONLN)
-    cpu_num = sysconf(_SC_NPROC_ONLN);
-#elif defined(_SC_NPROCESSORS_ONLN)
-    cpu_num = sysconf(_SC_NPROCESSORS_ONLN);
-#endif
-    return cpu_num;
-}
-
-
-void set_thread_affinity_mask(cpu_set_t mask)
-{
-    int err, syscallres;
-    pid_t pid = gettid();
-    syscallres = syscall(__NR_sched_setaffinity, pid, sizeof(mask), &mask);
-    if (syscallres)
-    {
-        ETRACE("Error in the syscall setaffinity.");
-    }
-}
-
-
-static void vbp_update_parser_for_item(viddec_pm_cxt_t *cxt,
-                                      viddec_pm_cxt_t *src_cxt,
-                                      uint32 item)
-{
-
-    /* set up bitstream buffer */
-    cxt->getbits.list = src_cxt->getbits.list;
-
-    /* setup buffer pointer */
-    cxt->getbits.bstrm_buf.buf = src_cxt->getbits.bstrm_buf.buf;
-
-
-    /* setup bitstream parser */
-    cxt->getbits.bstrm_buf.buf_index = src_cxt->list.data[item].stpos;
-    cxt->getbits.bstrm_buf.buf_st = src_cxt->list.data[item].stpos;
-    cxt->getbits.bstrm_buf.buf_end = src_cxt->list.data[item].edpos;
-
-    /* It is possible to end up with buf_offset not equal zero. */
-    cxt->getbits.bstrm_buf.buf_bitoff = 0;
-    cxt->getbits.au_pos = 0;
-    cxt->getbits.list_off = 0;
-    cxt->getbits.phase = 0;
-    cxt->getbits.emulation_byte_counter = 0;
-
-    cxt->list.start_offset = src_cxt->list.data[item].stpos;
-    cxt->list.end_offset = src_cxt->list.data[item].edpos;
-    cxt->list.total_bytes = src_cxt->list.data[item].edpos - src_cxt->list.data[item].stpos;
-
-}
-
-
-
-static void* parser_worker_thread(void* arg)
-{
-    PerThreadContext* p = arg;
-    ThreadContext* t_cxt = p->parent;
-    vbp_context* vbpctx = p->vbpctx;
-    viddec_pm_cxt_t* pm_cxt = p->pmctx;
-    viddec_parser_ops_t* ops = vbpctx->parser_ops;
-
-
-// probably not to make each parsing thread have affinity to a cpu core
-// having cpus fully occupied will even lead to low performance
-// current experimental solution: just make main thread have affinity
-#if 0
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-    CPU_SET(p->index, &mask); // cpu affinity is set to same num as thread index
-    set_thread_affinity_mask(mask);
-#endif
-
-    pthread_mutex_lock(&p->mutex);
-
-    nsecs_t t0;
-    while (1) {
-        while (p->state == STATE_INPUT_WAIT) {
-            pthread_cond_wait(&p->input_cond, &p->mutex);
-        }
-
-        if (p->state == STATE_WORKING) {
-            //now we get input data, call actual parse.
-            //t0 = systemTime();
-            sleep(0);
-            ops->parse_syntax_threading((void *)p->pmctx, p->codec_data, p->index);
-
-            pthread_mutex_lock(&p->progress_mutex);
-            p->state = STATE_INPUT_WAIT;
-
-            pthread_cond_broadcast(&p->progress_cond);
-            pthread_cond_signal(&p->output_cond);
-            pthread_mutex_unlock(&p->progress_mutex);
-        } else if (p->state == STATE_EXIT) {
-            break;
-        }
-    }
-    pthread_mutex_unlock(&p->mutex);
-    pthread_exit(NULL);
-    return NULL;
-}
-
-static void* parser_worker_thread_bundle(void* arg)
-{
-    PerThreadContext* p = arg;
-    ThreadContext* t_cxt = p->parent;
-    vbp_context* vbpctx = p->vbpctx;
-    viddec_parser_ops_t* ops = vbpctx->parser_ops;
-
-// probably not to make each parsing thread have affinity to a cpu core
-// having cpus fully occupied will even lead to low performance
-// current experimental solution: just make main thread have affinity
-#if 1
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-    CPU_SET(p->index, &mask); // cpu affinity is set to same num as thread index
-    set_thread_affinity_mask(mask);
-#endif
-
-    pthread_mutex_lock(&p->mutex);
-
-    nsecs_t t0;
-    while (1) {
-        while (p->state == STATE_INPUT_WAIT) {
-            pthread_cond_wait(&p->input_cond, &p->mutex);
-        }
-
-        if (p->state == STATE_WORKING) {
-            uint32_t working_item = p->start_item;  // start point
-            uint32_t slice_index = 0 + p->index;     // start point
-
-            while (working_item <= t_cxt->last_item_to_parse) {
-                vbp_update_parser_for_item(p->pmctx, p->input_pmctx, working_item);
-                ops->parse_syntax_threading((void *)p->pmctx, p->codec_data, slice_index);
-
-                working_item += t_cxt->active_thread_count;
-                slice_index += t_cxt->active_thread_count;
-            }
-
-            pthread_mutex_lock(&p->progress_mutex);
-            p->state = STATE_INPUT_WAIT;
-
-            pthread_cond_broadcast(&p->progress_cond);
-            pthread_mutex_unlock(&p->progress_mutex);
-        } else if (p->state == STATE_EXIT) {
-            break;
-        }
-    }
-    pthread_mutex_unlock(&p->mutex);
-    pthread_exit(NULL);
-    return NULL;
-}
-
-
-uint32_t update_context_from_input(viddec_pm_cxt_t* dest,
-                                   viddec_pm_cxt_t* source)
-{
-    if ((dest == NULL) || (source == NULL) || (dest == source)) {
-        ETRACE("%s error", __func__);
-        return 1;
-    }
-    /* set up bitstream buffer */
-    dest->getbits.list = source->getbits.list;
-
-    /* buffer pointer */
-    dest->getbits.bstrm_buf.buf = source->getbits.bstrm_buf.buf;
-
-    /* bitstream parser */
-    dest->getbits.bstrm_buf.buf_index = source->getbits.bstrm_buf.buf_index;
-    dest->getbits.bstrm_buf.buf_st = source->getbits.bstrm_buf.buf_st;
-    dest->getbits.bstrm_buf.buf_end = source->getbits.bstrm_buf.buf_end;
-
-    /* It is possible to end up with buf_offset not equal zero. */
-    dest->getbits.bstrm_buf.buf_bitoff = 0;
-    dest->getbits.au_pos = 0;
-    dest->getbits.list_off = 0;
-    dest->getbits.phase = 0;
-    dest->getbits.emulation_byte_counter = 0;
-
-    dest->list.start_offset = source->list.start_offset;
-    dest->list.end_offset = source->list.end_offset;
-    dest->list.total_bytes = source->list.total_bytes;
-    return 0;
-}
-
-uint32_t update_context_to_output(viddec_pm_cxt_t* dest,
-                                   viddec_pm_cxt_t* source)
-{
-    if ((dest == NULL) || (source == NULL) || (dest == source)) {
-        ETRACE("%s error", __func__);
-        return 1;
-    }
-
-    /* bitstream parser */
-    dest->getbits.bstrm_buf.buf_index = source->getbits.bstrm_buf.buf_index;
-    dest->getbits.bstrm_buf.buf_st = source->getbits.bstrm_buf.buf_st;
-    dest->getbits.bstrm_buf.buf_end = source->getbits.bstrm_buf.buf_end;
-
-    /* It is possible to end up with buf_offset not equal zero. */
-    dest->getbits.bstrm_buf.buf_bitoff = source->getbits.bstrm_buf.buf_bitoff;
-    dest->getbits.au_pos = source->getbits.au_pos;
-    dest->getbits.list_off = source->getbits.list_off;
-    dest->getbits.phase = source->getbits.phase;
-    dest->getbits.emulation_byte_counter = source->getbits.emulation_byte_counter;
-    dest->getbits.is_emul_reqd = source->getbits.is_emul_reqd;
-
-    dest->list.start_offset = source->list.start_offset;
-    dest->list.end_offset = source->list.end_offset;
-    dest->list.total_bytes = source->list.total_bytes;
-
-    return 0;
-}
-
-
-
-uint32_t feed_thread_input(PerThreadContext* p, void* parent)
-{
-    ThreadContext* t_context = p->parent;
-    viddec_pm_cxt_t* pm_cxt = (viddec_pm_cxt_t*) parent;
-
-    //nsecs_t t0 = systemTime();
-    if (pm_cxt->getbits.bstrm_buf.buf == NULL) {
-        return 1;
-    }
-
-    pthread_mutex_lock(&p->mutex);
-
-    if (p->state == STATE_WORKING) {
-        pthread_mutex_lock(&p->progress_mutex);
-        while (p->state == STATE_WORKING) {
-            pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
-        }
-        pthread_mutex_unlock(&p->progress_mutex);
-    }
-
-    /* Now update the input to the working thread*/
-    update_context_from_input(p->pmctx, pm_cxt);
-    p->codec_data = (void*)&(pm_cxt->codec_data[0]);
-
-    p->state = STATE_WORKING;
-    t_context->next_parsing++;
-
-    //t0 = systemTime();
-    pthread_cond_signal(&p->input_cond);
-    pthread_mutex_unlock(&p->mutex);
-
-    return 0;
-}
-
-void vbp_thread_init(vbp_context* pcontext)
-{
-    int i;
-    ThreadContext* t_context = NULL;
-    int32_t thread_count = pcontext->thread_count;
-    int32_t err = 0;
-
-#ifdef THREADING_SCHEME_BUNDLE
-    ITRACE("%s, threading_parse_scheme set to SCHEME_BUNDLE", __func__);
-    pcontext->threading_parse_scheme = SCHEME_BUNDLE;
-#else
-    ITRACE("%s, threading_parse_scheme set to SCHEME_SEQUENTIAL", __func__);
-    pcontext->threading_parse_scheme = SCHEME_SEQUENTIAL;
-#endif
-
-    if (thread_count == 0) {
-        int32_t cpu_num = get_cpu_count();
-        if (cpu_num > 1) {
-            if (pcontext->threading_parse_scheme == SCHEME_BUNDLE) {
-                thread_count = pcontext->thread_count = cpu_num - 1;
-            } else {
-                thread_count = pcontext->thread_count = cpu_num - 1;
-            }
-        }
-        else {
-            thread_count = pcontext->thread_count = 1;
-        }
-    }
-
-    pcontext->thread_opaque = t_context =
-              (ThreadContext*)malloc(sizeof(ThreadContext));
-    if (t_context != NULL) {
-        t_context->active_thread_count = thread_count; //default active count
-
-        t_context->delaying = 1;
-        t_context->next_parsing = t_context->next_finished = 0;
-    }
-
-    ITRACE("%s, creating %d parsing thread.", __func__, thread_count);
-    for (i = 0; i < thread_count; i++) {
-        t_context->threads[i] = (PerThreadContext*)malloc(sizeof(PerThreadContext));
-        assert(t_context->threads[i] != NULL);
-        PerThreadContext* p = t_context->threads[i];
-
-        if (p != NULL) {
-            p->index = i;
-            p->parent = t_context;
-            p->vbpctx = pcontext;
-            p->pmctx = vbp_malloc(viddec_pm_cxt_t, 1);
-            viddec_pm_utils_bstream_init(&(p->pmctx->getbits), NULL, 0);
-
-            pthread_mutex_init(&p->mutex, NULL);
-            pthread_mutex_init(&p->progress_mutex, NULL);
-            pthread_cond_init(&p->input_cond, NULL);
-            pthread_cond_init(&p->progress_cond, NULL);
-            pthread_cond_init(&p->output_cond, NULL);
-
-            p->state = STATE_INPUT_WAIT;
-
-            if(pcontext->threading_parse_scheme == SCHEME_SEQUENTIAL) {
-                err = pthread_create(&p->thread, NULL, parser_worker_thread, p);
-            } else {
-                err = pthread_create(&p->thread, NULL, parser_worker_thread_bundle, p);
-            }
-
-            p->thread_init = !err;
-        }
-    }
-#if 1
-    ITRACE("%s, set_thread_affinity_mask", __func__);
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-    CPU_SET(3, &mask); // 0~thread_count-1 cpus was set to each sub thread,
-                       // last cpu is set to main thread
-    set_thread_affinity_mask(mask);
-#endif
-}
-
-
-void vbp_thread_free(vbp_context* pcontext)
-{
-    ITRACE("%s", __func__);
-    ThreadContext* t_context = pcontext->thread_opaque;
-    int i;
-    int thread_count = pcontext->thread_count;
-
-    for (i = 0; i < thread_count; i++) {
-        PerThreadContext *p = t_context->threads[i];
-
-        pthread_mutex_lock(&p->mutex);
-        p->state = STATE_EXIT;
-        pthread_cond_signal(&p->input_cond);
-        pthread_mutex_unlock(&p->mutex);
-
-        if (p->thread_init) {
-            pthread_join(p->thread, NULL);
-        }
-        p->thread_init = 0;
-    }
-
-    for (i = 0; i < thread_count; i++) {
-        PerThreadContext *p = t_context->threads[i];
-
-        pthread_mutex_destroy(&p->mutex);
-        pthread_mutex_destroy(&p->progress_mutex);
-        pthread_cond_destroy(&p->input_cond);
-        pthread_cond_destroy(&p->progress_cond);
-        pthread_cond_destroy(&p->output_cond);
-
-        if (p->pmctx != NULL) {
-            free(p->pmctx);
-        }
-
-        free(p);
-        p = NULL;
-    }
-
-    free(t_context);
-}
-
-/*
- * Entry function of multi-thread parsing
- *
- * parent - A viddec_pm_cxt_t type parser management context,
- *          which contains input stream.
- * ctxt   - Codec specific parser context, actually codec_data[] in
- *          viddec_pm_cxt_t, Used for storing parsed output
- * return - 0 indicates no output is gotten, just warm up the threads
- *          1 indicates there is output
- *
- * see viddec_parser_ops.h
- *     uint32_t (*fn_parse_syntax) (void *parent, void *ctxt);
- */
-uint32_t vbp_thread_parse_syntax(void* parent,
-                                 void* ctxt,
-                                 vbp_context* pcontext)
-{
-    ThreadContext* t_context = pcontext->thread_opaque;
-    uint32_t finished = t_context->next_finished;
-
-    if ((parent == NULL) || (ctxt == NULL)) {
-        return 0;
-    }
-
-    PerThreadContext* p;
-
-    nsecs_t t0,t1;
-    //t0 = t1 = systemTime();
-
-    /* Submit an input packet to the next parser thread*/
-    p = t_context->threads[t_context->next_parsing];
-    feed_thread_input(p, parent);
-
-    //p->state = STATE_WORKING;
-    //t_context->next_parsing++;
-
-    //t0 = systemTime();
-    //pthread_cond_signal(&p->input_cond);
-
-    //t0 = systemTime();
-
-    if ((t_context->delaying == 1) &&
-        (t_context->next_parsing > (t_context->active_thread_count - 1))) {
-        t_context->delaying = 0;
-    }
-
-    /* If we are still in early stage that warming up each thread, indicate we got no output*/
-    if (t_context->delaying == 1) {
-        return 0;
-    }
-
-    /* return available parsed frame from the oldest thread
-     * notice that we start getting output from thread[0] after just submitting input
-     * to thread[active_count-1]
-     * */
-    p = t_context->threads[finished++];
-
-    if (p->state != STATE_INPUT_WAIT) {
-        pthread_mutex_lock(&p->progress_mutex);
-        while (p->state != STATE_INPUT_WAIT) {
-            pthread_cond_wait(&p->output_cond, &p->progress_mutex);
-        }
-        pthread_mutex_unlock(&p->progress_mutex);
-    }
-
-
-    if (finished > (t_context->active_thread_count - 1)) {
-        finished = 0;
-    }
-
-    if (t_context->next_parsing >= t_context->active_thread_count) {
-        t_context->next_parsing = 0;
-    }
-
-    t_context->next_finished = finished;
-
-    update_context_to_output((viddec_pm_cxt_t*) parent, p->pmctx);
-
-    return 1;
-}
-
-
-/*
- * Entry function of multi-thread parsing
- *
- * parent - A viddec_pm_cxt_t type parser management context,
- *          which contains input stream.
- * ctxt   - Codec specific parser context, actually codec_data[] in
- *          viddec_pm_cxt_t, Used for storing parsed output
- * start_item - num of start item passed to trigger multithread parsing
- *
- */
-uint32_t vbp_thread_parse_syntax_bundle(void* parent,
-                                   void* ctxt,
-                                   vbp_context* pcontext,
-                                   uint32_t start_item)
-{
-    ThreadContext* t_context = pcontext->thread_opaque;
-    if ((parent == NULL) || (ctxt == NULL)) {
-        return 0;
-    }
-
-    PerThreadContext* p = NULL;
-    viddec_pm_cxt_t* pm_cxt = (viddec_pm_cxt_t*) parent;
-    t_context->start_item_to_parse = start_item;
-    t_context->last_item_to_parse = pm_cxt->list.num_items - 1;
-
-    sem_init(&(t_context->finish_sem),0,0);
-
-    uint32_t i;
-    for (i = 0; i < t_context->active_thread_count; i++) {
-        p = t_context->threads[i];
-        p->start_item = start_item + i;
-
-        if (p->state == STATE_WORKING) {
-            pthread_mutex_lock(&p->progress_mutex);
-            while (p->state == STATE_WORKING) {
-                pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
-            }
-            pthread_mutex_unlock(&p->progress_mutex);
-        }
-
-        p->codec_data = (void*)&(pm_cxt->codec_data[0]);
-        p->input_pmctx = pm_cxt;
-
-        p->state = STATE_WORKING;
-
-        pthread_cond_signal(&p->input_cond);
-        pthread_mutex_unlock(&p->mutex);
-
-    }
-    return 1;
-}
-
-
-/*
- * set active threads num since not all threads need to be warmed up
- * when a frame has fewer slice num than threads we created.
- *
- * active_count  - threads num to be activated.
- */
-uint32_t vbp_thread_set_active(vbp_context* pcontext,
-                              uint32_t active_count)
-{
-    ThreadContext* t_context = pcontext->thread_opaque;
-
-    if (t_context != NULL) {
-        if (active_count < pcontext->thread_count) {
-            t_context->active_thread_count = active_count;
-        } else { //reset to the default
-            t_context->active_thread_count = pcontext->thread_count;
-        }
-
-        //reset to the default
-        t_context->delaying = 1;
-        t_context->next_parsing = t_context->next_finished = 0;
-    }
-    return 0;
-}
-
-uint32_t vbp_thread_get_active(vbp_context* pcontext)
-{
-    ThreadContext* t_context = pcontext->thread_opaque;
-
-    if (t_context != NULL) {
-        return t_context->active_thread_count;
-    }
-    return 0;
-}
-
-
diff --git a/mixvbp/vbp_manager/vbp_thread.h b/mixvbp/vbp_manager/vbp_thread.h
deleted file mode 100755
index e182ac1..0000000
--- a/mixvbp/vbp_manager/vbp_thread.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* INTEL CONFIDENTIAL
-* Copyright (c) 2013 Intel Corporation.  All rights reserved.
-*
-* The source code contained or described herein and all documents
-* related to the source code ("Material") are owned by Intel
-* Corporation or its suppliers or licensors.  Title to the
-* Material remains with Intel Corporation or its suppliers and
-* licensors.  The Material contains trade secrets and proprietary
-* and confidential information of Intel or its suppliers and
-* licensors. The Material is protected by worldwide copyright and
-* trade secret laws and treaty provisions.  No part of the Material
-* may be used, copied, reproduced, modified, published, uploaded,
-* posted, transmitted, distributed, or disclosed in any way without
-* Intel's prior express written permission.
-*
-* No license under any patent, copyright, trade secret or other
-* intellectual property right is granted to or conferred upon you
-* by disclosure or delivery of the Materials, either expressly, by
-* implication, inducement, estoppel or otherwise. Any license
-* under such intellectual property rights must be express and
-* approved by Intel in writing.
-*
-*/
-
-#ifndef VBP_THREAD_H
-#define VBP_THREAD_H
-
-#define _GNU_SOURCE
-#include <pthread.h>
-#include <semaphore.h>
-
-#include <sys/syscall.h>
-#include "vbp_utils.h"
-#include "include/viddec_pm.h"
-#include <sched.h>
-
-
-void vbp_thread_init(vbp_context *pcontext);
-
-void vbp_thread_free(vbp_context *pcontext);
-
-uint32_t vbp_thread_parse_syntax(void* parent,
-                                 void* ctxt,
-                                 vbp_context* pcontext);
-
-uint32_t vbp_thread_set_active(vbp_context* pcontext,
-                               uint32_t active_count);
-
-uint32_t vbp_thread_get_active(vbp_context* pcontext);
-
-#endif
diff --git a/mixvbp/vbp_manager/vbp_utils.c b/mixvbp/vbp_manager/vbp_utils.c
index 21b1e5d..1647269 100755
--- a/mixvbp/vbp_manager/vbp_utils.c
+++ b/mixvbp/vbp_manager/vbp_utils.c
@@ -39,21 +39,6 @@
 #include "vbp_h264secure_parser.h"
 #endif
 
-#ifdef USE_MULTI_THREADING
-#include "vbp_thread.h"
-#endif
-
-#define LEAST_SLICES_MULTI_THREADING 10
-
-typedef long long int nsecs_t;
-
-static nsecs_t systemTime()
-{
-    struct timeval t;
-    gettimeofday(&t, NULL);
-    return 1000000 * t.tv_sec + t.tv_usec;
-}
-
 
 /* buffer counter */
 uint32 buffer_counter = 0;
@@ -318,36 +303,12 @@
 }
 
 
-static void vbp_setup_parser_for_item(viddec_pm_cxt_t *cxt, uint32 item)
-{
-    /* setup bitstream parser */
-    cxt->getbits.bstrm_buf.buf_index = cxt->list.data[item].stpos;
-    cxt->getbits.bstrm_buf.buf_st = cxt->list.data[item].stpos;
-    cxt->getbits.bstrm_buf.buf_end = cxt->list.data[item].edpos;
-
-    /* It is possible to end up with buf_offset not equal zero. */
-    cxt->getbits.bstrm_buf.buf_bitoff = 0;
-
-    cxt->getbits.au_pos = 0;
-    cxt->getbits.list_off = 0;
-    cxt->getbits.phase = 0;
-    cxt->getbits.emulation_byte_counter = 0;
-
-    cxt->list.start_offset = cxt->list.data[item].stpos;
-    cxt->list.end_offset = cxt->list.data[item].edpos;
-    cxt->list.total_bytes = cxt->list.data[item].edpos - cxt->list.data[item].stpos;
-
-}
-
 
 /**
  *
  * parse the elementary sample buffer or codec configuration data
  *
  */
-//static uint32 frame_num = 0;
-//static nsecs_t total_time_of_multislice = 0;
-//static uint32 frame_multislice_num = 0;
 static uint32 vbp_utils_parse_es_buffer(vbp_context *pcontext, uint8 init_data_flag)
 {
     viddec_pm_cxt_t *cxt = pcontext->parser_cxt;
@@ -378,7 +339,6 @@
     }
     */
 
-    uint32_t multi_parse_done = 0;
 
     /* populate the list.*/
     if (init_data_flag)
@@ -404,176 +364,48 @@
 
     // TODO: check if cxt->getbits.is_emul_reqd is set properly
 
-    //frame_num ++;
+    for (i = 0; i < cxt->list.num_items; i++)
+    {
+        /* setup bitstream parser */
+        cxt->getbits.bstrm_buf.buf_index = cxt->list.data[i].stpos;
+        cxt->getbits.bstrm_buf.buf_st = cxt->list.data[i].stpos;
+        cxt->getbits.bstrm_buf.buf_end = cxt->list.data[i].edpos;
 
-    nsecs_t t0, t1, t2, tt0, tt1, tt2;
-    t0 = t1 = t2 = tt0 = tt1 = tt2 = 0;
-    //t0 = systemTime();
+        /* It is possible to end up with buf_offset not equal zero. */
+        cxt->getbits.bstrm_buf.buf_bitoff = 0;
 
-    if (0 == pcontext->is_multithread_parsing_enabled) {
-        for (i = 0; i < cxt->list.num_items; i++) {
-            vbp_setup_parser_for_item(cxt, i);
-            /* invoke parse entry point to parse the buffer */
-            //t1 = systemTime();
-            error = ops->parse_syntax((void *)cxt, (void *)&(cxt->codec_data[0]));
-            //t2 = systemTime();
-            //tt1 += t2 - t1;
+        cxt->getbits.au_pos = 0;
+        cxt->getbits.list_off = 0;
+        cxt->getbits.phase = 0;
+        cxt->getbits.emulation_byte_counter = 0;
 
-            /* can't return error for now. Neet further investigation */
-            if (0 != error) {
-                WTRACE("failed to parse the syntax: %d!", error);
-            }
+        cxt->list.start_offset = cxt->list.data[i].stpos;
+        cxt->list.end_offset = cxt->list.data[i].edpos;
+        cxt->list.total_bytes = cxt->list.data[i].edpos - cxt->list.data[i].stpos;
 
-            /* process parsing result */
-            //t2 = systemTime();
-            error = pcontext->func_process_parsing_result(pcontext, i);
-            //tt2 += systemTime() - t2;
+        /* invoke parse entry point to parse the buffer */
+        error = ops->parse_syntax((void *)cxt, (void *)&(cxt->codec_data[0]));
 
-            if (VBP_MULTI == error) {
-                ITRACE("Multiple frames are found in one bufffer.");
-                return VBP_OK;
-            }
-            else if (0 != error) {
-                ETRACE("Failed to process parsing result.");
-                return error;
-            }
-        }
-    }
-    // Multi-threading option is enabled
-    else if (1 == pcontext->is_multithread_parsing_enabled) {
-
-        int got_output = 0;
-        int is_payload_start = 0;
-        int single_parse_count = 0;
-        int use_thread_parsing = 0;
-
-        for (i = 0; i < cxt->list.num_items; i++) {
-
-            vbp_setup_parser_for_item(cxt, i);
-
-            // we assume no configuration data following slice data in a frame's buffer
-            is_payload_start = ops->is_payload_start((void *)cxt);
-
-            if (is_payload_start == 0) {
-                //t1 = systemTime();
-                error = ops->parse_syntax((void *)cxt, (void *)&(cxt->codec_data[0]));
-                //tt1 += systemTime() - t1;
-
-                //t2 = systemTime();
-                error = pcontext->func_process_parsing_result(pcontext, i);
-                single_parse_count ++;
-                //tt2 += systemTime() - t2;
-            } else if (((cxt->list.num_items - single_parse_count) < LEAST_SLICES_MULTI_THREADING)) {
-                //t1 = systemTime();
-                error = ops->parse_syntax((void *)cxt, (void *)&(cxt->codec_data[0]));
-                //tt1 += systemTime() - t1;
-
-                //t2 = systemTime();
-                error = pcontext->func_process_parsing_result(pcontext, i);
-                //tt2 += systemTime() - t2;
-            } else {
-                use_thread_parsing = 1;
-                break;
-            }
-
-            if (VBP_MULTI == error) {
-                ITRACE("Multiple frames are found in one bufffer.");
-                return VBP_OK;
-            }
-            else if (0 != error) {
-                ETRACE("Failed to process parsing result.");
-                return error;
-            }
+        /* can't return error for now. Neet further investigation */
+        if (0 != error)
+        {
+            VTRACE("failed to parse the syntax: %d!", error);
         }
 
-        if (use_thread_parsing) {
-            vbp_thread_set_active(pcontext, cxt->list.num_items - single_parse_count);
-            uint32_t thread_count = vbp_thread_get_active(pcontext);
+        /* process parsing result */
+        error = pcontext->func_process_parsing_result(pcontext, i);
 
-            //t1 = systemTime();
-            if (pcontext->threading_parse_scheme == SCHEME_BUNDLE) {
-            // Multithread parsing Scheme-Bundle-Input
-            // This interface push threads to parse all slice header without interrupt.
-                vbp_thread_parse_syntax_bundle((void *)cxt,
-                                               (void *)&(cxt->codec_data[0]),
-                                               pcontext,
-                                               i); //first slice's item num
-
-                uint32_t j;
-                for (j = i; j < cxt->list.num_items; j++) {
-                    error = ops->post_parse_threading((void *)cxt,
-                                                      (void *)&(cxt->codec_data[0]),
-                                                      j-single_parse_count); // slice index
-                    error = pcontext->func_process_parsing_result(pcontext, j); // item num
-                }
-                //tt1 += systemTime() - t1;
-
-            } else if (pcontext->threading_parse_scheme == SCHEME_SEQUENTIAL) {
-            // Multithread parsing Scheme-Sequential-Input.
-            // This interface push threads to parse one slice header one time.
-                uint32_t j;
-                for (j = i; j < cxt->list.num_items; j++) {
-                    vbp_setup_parser_for_item(cxt, j);
-
-                    //t1 = systemTime();
-                    got_output = vbp_thread_parse_syntax((void *)cxt,
-                                                         (void *)&(cxt->codec_data[0]),
-                                                         pcontext);
-                    //tt1 += systemTime() - t1;
-
-                    if (got_output == 1) {
-                        //t2 = systemTime();
-                        error = ops->post_parse_threading((void *)cxt,
-                                                          (void *)&(cxt->codec_data[0]),
-                                                          //slice count with thread delay
-                                                          (j-(thread_count-1)-single_parse_count) % thread_count);
-
-                        error = pcontext->func_process_parsing_result(pcontext,
-                                                                      // item count with thread delay
-                                                                      j-(thread_count-1));
-
-                        multi_parse_done ++;
-                        //tt2 += systemTime() - t2;
-                    }
-                }
-
-                int need_to_clearance = thread_count -1;
-                cxt->getbits.bstrm_buf.buf = NULL;
-                for (i = cxt->list.num_items - need_to_clearance; i < cxt->list.num_items; i++) {
-                    //t1 = systemTime();
-                    got_output = vbp_thread_parse_syntax((void *)cxt,
-                                                         (void *)&(cxt->codec_data[0]),
-                                                         pcontext);
-                                                         //&got_output);
-                    //tt1 += systemTime() - t1;
-
-                    if (got_output == 1) {
-                        //t2 = systemTime();
-                        error = ops->post_parse_threading((void *)cxt,
-                                                          (void *)&(cxt->codec_data[0]),
-                                                          (i-single_parse_count) % thread_count);
-
-                        error = pcontext->func_process_parsing_result(pcontext, i);
-                        multi_parse_done ++;
-                        //tt2 += systemTime() - t2;
-                    }
-                }
-            }
+        if (VBP_MULTI == error) {
+            ITRACE("Multiple frames are found in one bufffer.");
+            return VBP_OK;
+        }
+        else if (0 != error)
+        {
+            ETRACE("Failed to process parsing result.");
+            return error;
         }
     }
-#if 0
-    tt0 = systemTime() - t0;
-    if (cxt->list.num_items > 8) {
-        total_time_of_multislice += tt0;
-        frame_multislice_num ++;
-        ETRACE("### ================== TIME CALCULATION =======================");
-        ETRACE("### ------------item num: %d", cxt->list.num_items);
-        ETRACE("### ------------The frame[%d] cost time: %lld us", frame_num-1, tt0);
-        ETRACE("### ------------Accumulated multi-slice frames: %d", frame_multislice_num);
-        ETRACE("### ------------Accumulated average time that multislice frame cost: %lld us", total_time_of_multislice/frame_multislice_num);
-        ETRACE("### ================== TIME CALCULATION END ===================");
-    }
-#endif
+
     return VBP_OK;
 }
 
@@ -631,21 +463,6 @@
     *ppcontext = pcontext;
     error = VBP_OK;
 
-
-    /* default is not enabled */
-    pcontext->is_multithread_parsing_enabled = 0;
-
-#ifndef USE_AVC_SHORT_FORMAT
-#ifdef USE_MULTI_THREADING
-    if (pcontext->parser_ops->query_thread_parsing_cap != NULL) {
-        if (pcontext->parser_ops->query_thread_parsing_cap() == 1) {
-            pcontext->is_multithread_parsing_enabled = 1;
-            ITRACE("Multi-thead parsing is enabled.");
-            vbp_thread_init(pcontext);
-        }
-    }
-#endif
-#endif
 cleanup:
 
     if (VBP_OK != error)
@@ -666,12 +483,6 @@
  */
 uint32 vbp_utils_destroy_context(vbp_context *pcontext)
 {
-#ifdef USE_MULTI_THREADING
-    if (1 == pcontext->is_multithread_parsing_enabled) {
-        vbp_thread_free(pcontext);
-    }
-#endif
-
     /* entry point, not need to validate input parameters. */
     vbp_utils_free_parser_memory(pcontext);
     vbp_utils_uninitialize_context(pcontext);
diff --git a/mixvbp/vbp_manager/vbp_utils.h b/mixvbp/vbp_manager/vbp_utils.h
index 7cf9321..633159c 100755
--- a/mixvbp/vbp_manager/vbp_utils.h
+++ b/mixvbp/vbp_manager/vbp_utils.h
@@ -31,9 +31,6 @@
 #include "viddec_pm.h"
 #include "vbp_trace.h"
 #include <stdlib.h>
-#include "vbp_loader.h"
-
-#include <sys/time.h>
 
 #define MAGIC_NUMBER 0x0DEADBEEF
 #define MAX_WORKLOAD_ITEMS 1000
@@ -71,13 +68,6 @@
 typedef uint32 (*function_update_data)(vbp_context* cxt, void *newdata, uint32 size);
 #endif
 
-typedef enum
-{
-    SCHEME_BUNDLE = 0,
-    SCHEME_SEQUENTIAL,
-} threading_parse_scheme_t;
-
-
 struct vbp_context_t
 {
     /* magic number */
@@ -104,13 +94,6 @@
     /* parser type specific data*/
     void *parser_private;
 
-    /* multithreading */
-    uint32 thread_count;
-    void *thread_opaque;
-    uint32 is_multithread_parsing_enabled;
-
-    threading_parse_scheme_t  threading_parse_scheme;
-
     function_init_parser_entries func_init_parser_entries;
     function_allocate_query_data func_allocate_query_data;
     function_free_query_data func_free_query_data;
diff --git a/mixvbp/vbp_manager/vbp_vc1_parser.c b/mixvbp/vbp_manager/vbp_vc1_parser.c
index 65b6f76..12e28e9 100755
--- a/mixvbp/vbp_manager/vbp_vc1_parser.c
+++ b/mixvbp/vbp_manager/vbp_vc1_parser.c
@@ -111,10 +111,6 @@
 
     /* entry point not needed */
     pcontext->parser_ops->flush = NULL;
-    pcontext->parser_ops->is_payload_start = NULL;
-    pcontext->parser_ops->parse_syntax_threading = NULL;
-    pcontext->parser_ops->post_parse_threading = NULL;
-    pcontext->parser_ops->query_thread_parsing_cap = NULL;
 
     return VBP_OK;
 }
diff --git a/mixvbp/vbp_manager/vbp_vp8_parser.c b/mixvbp/vbp_manager/vbp_vp8_parser.c
index 9ac097d..73d9281 100755
--- a/mixvbp/vbp_manager/vbp_vp8_parser.c
+++ b/mixvbp/vbp_manager/vbp_vp8_parser.c
@@ -67,10 +67,6 @@
     pcontext->parser_ops->is_frame_start = NULL;
 
     pcontext->parser_ops->flush = NULL;
-    pcontext->parser_ops->is_payload_start = NULL;
-    pcontext->parser_ops->parse_syntax_threading = NULL;
-    pcontext->parser_ops->post_parse_threading = NULL;
-    pcontext->parser_ops->query_thread_parsing_cap = NULL;
 
     return VBP_OK;
 }
diff --git a/mixvbp/vbp_plugin/h264/h264parse.c b/mixvbp/vbp_plugin/h264/h264parse.c
index 330c5e6..cbb04fe 100755
--- a/mixvbp/vbp_plugin/h264/h264parse.c
+++ b/mixvbp/vbp_plugin/h264/h264parse.c
@@ -65,7 +65,7 @@
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
-// keep for h264 secure parse
+
 h264_Status h264_active_par_set(h264_Info*pInfo,h264_Slice_Header_t* SliceHeader)
 {
     //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
@@ -114,43 +114,14 @@
         }
     }
 
-    pInfo->img.PicWidthInMbs = (pInfo->active_SPS.sps_disp.pic_width_in_mbs_minus1 + 1);
-    pInfo->img.FrameHeightInMbs = pInfo->active_SPS.sps_disp.frame_mbs_only_flag ?
-                 (pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) :
-                 ((pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) << 1);
+    pInfo->img.PicWidthInMbs    = (pInfo->active_SPS.sps_disp.pic_width_in_mbs_minus1 + 1);
+    pInfo->img.FrameHeightInMbs = pInfo->active_SPS.sps_disp.frame_mbs_only_flag?				\
+                                  (pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) :	\
+                                  ((pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) << 1);
 
     return H264_STATUS_OK;
 };   //// End of h264_active_par_set
 
-
-
-h264_Status h264_set_active_par_set(h264_Info*pInfo,h264_Slice_Header_t* SliceHeader)
-{
-    uint32_t pps_addr = pInfo->PPS_PADDR_GL +
-                        SliceHeader->pic_parameter_id * sizeof(pic_param_set);
-    SliceHeader->active_PPS = (pic_param_set*)pps_addr;
-    pic_param_set* active_PPS = SliceHeader->active_PPS;
-
-    if (active_PPS->seq_parameter_set_id >= MAX_NUM_SPS)
-    {
-        return H264_PPS_INVALID_PIC_ID;    /// Invalid PPS detected
-    }
-
-    uint32_t sps_addr = pInfo->SPS_PADDR_GL + \
-                        active_PPS->seq_parameter_set_id * sizeof(seq_param_set_all);
-    SliceHeader->active_SPS = (seq_param_set_used*)sps_addr;
-    seq_param_set_used* active_SPS = SliceHeader->active_SPS;
-
-    if (active_SPS->seq_parameter_set_id >= MAX_NUM_SPS)
-    {
-        return H264_PPS_INVALID_PIC_ID;    //// Invalid SPS detected
-    }
-
-    return H264_STATUS_OK;
-};   // End of h264_set_active_par_set
-
-
-
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
@@ -202,183 +173,38 @@
             SliceHeader->sh_error |= 4;
         }
 
-    } else      {
+    } else 	{
         SliceHeader->sh_error |= 1;
     }
 
-    return retStatus;
-}
 
-h264_Status h264_Parse_Slice_Layer_Without_Partitioning_RBSP_opt(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
-{
-    h264_Status retStatus = H264_STATUS_ERROR;
+    //if(SliceHeader->sh_error) {
+    //pInfo->wl_err_flag |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
+    //}
 
-    ////////////////////////////////////////////////////
-    //// Parse slice header info
-    //// Part1: not depend on the active PPS/SPS
-    //// Part2/3: depend on the active parset
-    //////////////////////////////////////////////////
 
-    SliceHeader->sh_error = 0;
 
-    if (h264_Parse_Slice_Header_1(parent, pInfo, SliceHeader) == H264_STATUS_OK)
+    //////////////////////////////////
+    //// Parse slice data (MB loop)
+    //////////////////////////////////
+    //retStatus = h264_Parse_Slice_Data(pInfo);
     {
-        retStatus = h264_set_active_par_set(pInfo, SliceHeader);
+        //uint32_t data = 0;
+        //if( viddec_pm_peek_bits(parent, &data, 32) == -1)
+        //retStatus = H264_STATUS_ERROR;
     }
-
-   if (retStatus == H264_STATUS_OK)
-    {
-        switch (SliceHeader->active_SPS->profile_idc)
-        {
-        case h264_ProfileBaseline:
-        case h264_ProfileMain:
-        case h264_ProfileExtended:
-            SliceHeader->active_PPS->transform_8x8_mode_flag = 0;
-            SliceHeader->active_PPS->pic_scaling_matrix_present_flag = 0;
-            SliceHeader->active_PPS->second_chroma_qp_index_offset =
-                SliceHeader->active_PPS->chroma_qp_index_offset;
-
-        default:
-            break;
-        }
-
-        if (h264_Parse_Slice_Header_2_opt(parent, pInfo, SliceHeader) != H264_STATUS_OK)
-        {
-            SliceHeader->sh_error |= 2;
-        }
-        else if (h264_Parse_Slice_Header_3_opt(parent, pInfo, SliceHeader) != H264_STATUS_OK)
-        {
-            SliceHeader->sh_error |= 4;
-        }
-    } else {
-        SliceHeader->sh_error |= 1;
-    }
+    //h264_Parse_rbsp_trailing_bits(pInfo);
 
     return retStatus;
 }
 
 
-h264_Status h264_Post_Parsing_Slice_Header(void *parent, h264_Info* pInfo, h264_Slice_Header_t *next_SliceHeader)
-{
-
-    h264_Status retStatus = H264_STATUS_OK;
-
-    memcpy(&pInfo->active_PPS, next_SliceHeader->active_PPS, sizeof(pic_param_set));
-    memcpy(&pInfo->active_SPS, next_SliceHeader->active_SPS, sizeof(seq_param_set_used));
-
-    if ((1 == pInfo->primary_pic_type_plus_one) && (pInfo->got_start)) {
-        pInfo->img.recovery_point_found |= 4;
-    }
-    pInfo->primary_pic_type_plus_one = 0;
-
-    pInfo->img.PicWidthInMbs    = (pInfo->active_SPS.sps_disp.pic_width_in_mbs_minus1 + 1);
-    pInfo->img.FrameHeightInMbs = pInfo->active_SPS.sps_disp.frame_mbs_only_flag?                       \
-                                  (pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) :     \
-                                  ((pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) << 1);
-
-    pInfo->sei_information.recovery_point = 0;
-
-    pInfo->img.current_slice_num++;
-
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Processing if new picture coming
-    //  1) if it's the second field
-    //	2) if it's a new frame
-    ////////////////////////////////////////////////////////////////////////////
-    //AssignQuantParam(pInfo);
-    if (h264_is_new_picture_start(pInfo, *next_SliceHeader, pInfo->SliceHeader))
-    {
-        //
-        ///----------------- New Picture.boundary detected--------------------
-        //
-        pInfo->img.g_new_pic++;
-
-        //
-        // Complete previous picture
-        h264_dpb_store_previous_picture_in_dpb(pInfo, 0, 0); //curr old
-        //h264_hdr_post_poc(0, 0, use_old);
-        //
-        // Update slice structures:
-        h264_update_old_slice(pInfo, *next_SliceHeader);  //cur->old; next->cur;
-        //
-        // 1) if resolution change: reset dpb
-        // 2) else: init frame store
-        h264_update_img_info(pInfo); //img, dpb
-        //
-        ///----------------- New frame.boundary detected--------------------
-        //
-        pInfo->img.second_field = h264_is_second_field(pInfo);
-        if (pInfo->img.second_field == 0)
-        {
-            pInfo->img.g_new_frame = 1;
-            h264_dpb_update_queue_dangling_field(pInfo);
-            //
-            /// DPB management
-            ///	1) check the gaps
-            ///	2) assign fs for non-exist frames
-            ///	3) fill the gaps
-            ///	4) store frame into DPB if ...
-            //
-            //if(pInfo->SliceHeader.redundant_pic_cnt)
-            {
-                h264_dpb_gaps_in_frame_num_mem_management(pInfo);
-            }
-        }
-        //
-        /// Decoding POC
-        h264_hdr_decoding_poc (pInfo, 0, 0);
-        //
-        /// Init Frame Store for next frame
-        h264_dpb_init_frame_store (pInfo);
-        pInfo->img.current_slice_num = 1;
-        if (pInfo->SliceHeader.first_mb_in_slice != 0)
-        {
-            ////Come here means we have slice lost at the beginning, since no FMO support
-            pInfo->SliceHeader.sh_error |= (pInfo->SliceHeader.structure << 17);
-        }
-        /// Emit out the New Frame
-        if (pInfo->img.g_new_frame)
-        {
-            h264_parse_emit_start_new_frame(parent, pInfo);
-        }
-
-        h264_parse_emit_current_pic(parent, pInfo);
-    }
-    else ///////////////////////////////////////////////////// If Not a picture start
-    {
-        //
-        /// Update slice structures: cur->old; next->cur;
-        h264_update_old_slice(pInfo, *next_SliceHeader);
-        //
-        /// 1) if resolution change: reset dpb
-        /// 2) else: update img info
-        h264_update_img_info(pInfo);
-    }
-
-
-    //////////////////////////////////////////////////////////////
-    // DPB reference list init and reordering
-    //////////////////////////////////////////////////////////////
-
-    //////////////////////////////////////////////// Update frame Type--- IDR/I/P/B for frame or field
-    h264_update_frame_type(pInfo);
-
-#ifndef USE_AVC_SHORT_FORMAT
-    h264_dpb_update_ref_lists(pInfo);
-#endif
-    /// Emit out the current "good" slice
-    h264_parse_emit_current_slice(parent, pInfo);
-
-    return retStatus;
-}
-
 
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
 
-h264_Status h264_Parse_NAL_Unit(void *parent, uint8_t* nal_unit_type, uint8_t *nal_ref_idc)
+h264_Status h264_Parse_NAL_Unit(void *parent, h264_Info* pInfo, uint8_t *nal_ref_idc)
 {
     h264_Status ret = H264_STATUS_ERROR;
 
@@ -386,7 +212,7 @@
     if (viddec_pm_get_bits(parent, &code, 8) != -1)
     {
         *nal_ref_idc = (uint8_t)((code >> 5) & 0x3);
-        *nal_unit_type = (uint8_t)((code >> 0) & 0x1f);
+        pInfo->nal_unit_type = (uint8_t)((code >> 0) & 0x1f);
         ret = H264_STATUS_OK;
     }
 
@@ -604,58 +430,43 @@
 /* ------------------------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------------------------ */
 
-int32_t h264_is_new_picture_start(h264_Info * pInfo,
-                                  h264_Slice_Header_t cur_slice,
-                                  h264_Slice_Header_t old_slice)
+int32_t h264_is_new_picture_start(h264_Info * pInfo, h264_Slice_Header_t cur_slice, h264_Slice_Header_t old_slice)
 {
     int result = 0;
 
-    if (pInfo->number_of_first_au_info_nal_before_first_slice) {
+    if (pInfo->number_of_first_au_info_nal_before_first_slice)
+    {
         pInfo->number_of_first_au_info_nal_before_first_slice = 0;
         return 1;
     }
 
-    if (old_slice.pic_parameter_id != cur_slice.pic_parameter_id) {
-        return 1;
-    }
-    if (old_slice.frame_num != cur_slice.frame_num) {
-        return 1;
-    }
-    if (old_slice.field_pic_flag != cur_slice.field_pic_flag) {
-        return 1;
-    }
-    if (cur_slice.field_pic_flag && old_slice.field_pic_flag) {
-        if (old_slice.bottom_field_flag != cur_slice.bottom_field_flag) {
-            return 1;
-        }
+    result |= (old_slice.pic_parameter_id != cur_slice.pic_parameter_id);
+    result |= (old_slice.frame_num != cur_slice.frame_num);
+    result |= (old_slice.field_pic_flag != cur_slice.field_pic_flag);
+    if (cur_slice.field_pic_flag && old_slice.field_pic_flag)
+    {
+        result |= (old_slice.bottom_field_flag != cur_slice.bottom_field_flag);
     }
 
-    if ((old_slice.nal_ref_idc != cur_slice.nal_ref_idc) && \
-              ((old_slice.nal_ref_idc == 0) || (cur_slice.nal_ref_idc == 0))) {
-        return 1;
-    }
-    if (old_slice.idr_flag != cur_slice.idr_flag) {
-        return 1;
+    result |= (old_slice.nal_ref_idc != cur_slice.nal_ref_idc) && \
+              ((old_slice.nal_ref_idc == 0) || (cur_slice.nal_ref_idc == 0));
+    result |= ( old_slice.idr_flag != cur_slice.idr_flag);
+
+    if (cur_slice.idr_flag && old_slice.idr_flag)
+    {
+        result |= (old_slice.idr_pic_id != cur_slice.idr_pic_id);
     }
 
-    if (cur_slice.idr_flag && old_slice.idr_flag) {
-        if (old_slice.idr_pic_id != cur_slice.idr_pic_id) {
-            return 1;
-        }
+    if (pInfo->active_SPS.pic_order_cnt_type == 0)
+    {
+        result |=  (old_slice.pic_order_cnt_lsb          != cur_slice.pic_order_cnt_lsb);
+        result |=  (old_slice.delta_pic_order_cnt_bottom != cur_slice.delta_pic_order_cnt_bottom);
     }
 
-    if (pInfo->active_SPS.pic_order_cnt_type == 0) {
-        if ((old_slice.pic_order_cnt_lsb != cur_slice.pic_order_cnt_lsb) || \
-           (old_slice.delta_pic_order_cnt_bottom != cur_slice.delta_pic_order_cnt_bottom)) {
-            return 1;
-        }
-    }
-
-    if (pInfo->active_SPS.pic_order_cnt_type == 1) {
-        if ((old_slice.delta_pic_order_cnt[0] != cur_slice.delta_pic_order_cnt[0]) || \
-            (old_slice.delta_pic_order_cnt[1] != cur_slice.delta_pic_order_cnt[1])) {
-            return 1;
-        }
+    if (pInfo->active_SPS.pic_order_cnt_type == 1)
+    {
+        result |= (old_slice.delta_pic_order_cnt[0] != cur_slice.delta_pic_order_cnt[0]);
+        result |= (old_slice.delta_pic_order_cnt[1] != cur_slice.delta_pic_order_cnt[1]);
     }
 
     return result;
diff --git a/mixvbp/vbp_plugin/h264/h264parse_dpb.c b/mixvbp/vbp_plugin/h264/h264parse_dpb.c
old mode 100755
new mode 100644
diff --git a/mixvbp/vbp_plugin/h264/h264parse_pps.c b/mixvbp/vbp_plugin/h264/h264parse_pps.c
index b4098ec..2c4cc52 100755
--- a/mixvbp/vbp_plugin/h264/h264parse_pps.c
+++ b/mixvbp/vbp_plugin/h264/h264parse_pps.c
@@ -22,8 +22,6 @@
         }
         PictureParameterSet->pic_parameter_set_id = (uint8_t)code;
 
-        VTRACE("parsing PPS: id = %d", PictureParameterSet->pic_parameter_set_id);
-
         code = h264_GetVLCElement(parent, pInfo, false);
         if (code > MAX_NUM_SPS - 1)
         {
@@ -32,8 +30,6 @@
         }
         PictureParameterSet->seq_parameter_set_id = (uint8_t)code;
 
-        VTRACE("parsing PPS: refering SPS id = %d", PictureParameterSet->seq_parameter_set_id);
-
         ///// entropy_coding_mode_flag
         viddec_pm_get_bits(parent, &code, 1);
         PictureParameterSet->entropy_coding_mode_flag = (uint8_t)code;
diff --git a/mixvbp/vbp_plugin/h264/h264parse_sh.c b/mixvbp/vbp_plugin/h264/h264parse_sh.c
index 02bd202..625e146 100755
--- a/mixvbp/vbp_plugin/h264/h264parse_sh.c
+++ b/mixvbp/vbp_plugin/h264/h264parse_sh.c
@@ -95,17 +95,13 @@
         }
 
         ////// Check valid or not of first_mb_in_slice
-        int32_t PicWidthInMbs    = (pInfo->active_SPS.sps_disp.pic_width_in_mbs_minus1 + 1);
-        int32_t FrameHeightInMbs = pInfo->active_SPS.sps_disp.frame_mbs_only_flag ?
-                                  (pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) :
-                                  ((pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1) << 1);
         if (SliceHeader->structure == FRAME)
         {
-            max_mb_num = FrameHeightInMbs * PicWidthInMbs;
+            max_mb_num = pInfo->img.FrameHeightInMbs * pInfo->img.PicWidthInMbs;
         }
         else
         {
-            max_mb_num = FrameHeightInMbs * PicWidthInMbs / 2;
+            max_mb_num = pInfo->img.FrameHeightInMbs * pInfo->img.PicWidthInMbs / 2;
         }
 
         ///if(pInfo->img.MbaffFrameFlag)
@@ -115,10 +111,7 @@
         }
 
         if (SliceHeader->first_mb_in_slice >= max_mb_num)
-        {
-            WTRACE("first mb in slice exceed max mb num.");
             break;
-        }
 
         if (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
         {
@@ -172,121 +165,6 @@
     return ret;
 }
 
-h264_Status h264_Parse_Slice_Header_2_opt(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
-{
-    h264_Status ret = H264_SliceHeader_ERROR;
-
-    uint32_t code;
-    int32_t max_mb_num=0;
-
-    do {
-        //////////////////////////////////// Slice header part 2//////////////////
-
-        /// Frame_num
-        viddec_pm_get_bits(parent, &code, SliceHeader->active_SPS->log2_max_frame_num_minus4 + 4);
-        SliceHeader->frame_num = (int32_t)code;
-
-        /// Picture structure
-        SliceHeader->structure = FRAME;
-        SliceHeader->field_pic_flag = 0;
-        SliceHeader->bottom_field_flag = 0;
-
-        if (!(SliceHeader->active_SPS->sps_disp.frame_mbs_only_flag))
-        {
-            /// field_pic_flag
-            viddec_pm_get_bits(parent, &code, 1);
-            SliceHeader->field_pic_flag = (uint8_t)code;
-
-            if (SliceHeader->field_pic_flag)
-            {
-                viddec_pm_get_bits(parent, &code, 1);
-                SliceHeader->bottom_field_flag = (uint8_t)code;
-
-                SliceHeader->structure = SliceHeader->bottom_field_flag ? BOTTOM_FIELD: TOP_FIELD;
-            }
-        }
-
-        ////// Check valid or not of first_mb_in_slice
-        int32_t PicWidthInMbs    = (SliceHeader->active_SPS->sps_disp.pic_width_in_mbs_minus1 + 1);
-        int32_t FrameHeightInMbs = SliceHeader->active_SPS->sps_disp.frame_mbs_only_flag ?
-                                  (SliceHeader->active_SPS->sps_disp.pic_height_in_map_units_minus1 + 1) :
-                                  ((SliceHeader->active_SPS->sps_disp.pic_height_in_map_units_minus1 + 1) << 1);
-        if (SliceHeader->structure == FRAME)
-        {
-            max_mb_num = FrameHeightInMbs * PicWidthInMbs;
-        }
-        else
-        {
-            max_mb_num = FrameHeightInMbs * PicWidthInMbs / 2;
-        }
-
-        ///if(pInfo->img.MbaffFrameFlag)
-        if (SliceHeader->active_SPS->sps_disp.mb_adaptive_frame_field_flag & (!(pInfo->SliceHeader.field_pic_flag)))
-        {
-            SliceHeader->first_mb_in_slice <<= 1;
-        }
-
-        if (SliceHeader->first_mb_in_slice >= max_mb_num)
-        {
-            WTRACE("first mb in slice exceed max mb num.");
-            break;
-        }
-
-        if (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
-        {
-            SliceHeader->idr_pic_id = h264_GetVLCElement(parent, pInfo, false);
-        }
-
-        if (SliceHeader->active_SPS->pic_order_cnt_type == 0)
-        {
-            viddec_pm_get_bits(parent, &code , SliceHeader->active_SPS->log2_max_pic_order_cnt_lsb_minus4 + 4);
-            SliceHeader->pic_order_cnt_lsb = (uint32_t)code;
-
-            if ((SliceHeader->active_PPS->pic_order_present_flag) && !(SliceHeader->field_pic_flag))
-            {
-                SliceHeader->delta_pic_order_cnt_bottom = h264_GetVLCElement(parent, pInfo, true);
-            }
-            else
-            {
-                SliceHeader->delta_pic_order_cnt_bottom = 0;
-            }
-        }
-
-        if ((SliceHeader->active_SPS->pic_order_cnt_type == 1) &&
-            !(SliceHeader->active_SPS->delta_pic_order_always_zero_flag))
-        {
-            SliceHeader->delta_pic_order_cnt[0] = h264_GetVLCElement(parent, pInfo, true);
-            if ((SliceHeader->active_PPS->pic_order_present_flag) && !(SliceHeader->field_pic_flag))
-            {
-                SliceHeader->delta_pic_order_cnt[1] = h264_GetVLCElement(parent, pInfo, true);
-            }
-        }
-
-        if (SliceHeader->active_PPS->redundant_pic_cnt_present_flag)
-        {
-            SliceHeader->redundant_pic_cnt = h264_GetVLCElement(parent, pInfo, false);
-            if (SliceHeader->redundant_pic_cnt > 127)
-                break;
-        }
-        else
-        {
-            SliceHeader->redundant_pic_cnt = 0;
-        }
-
-        ret = H264_STATUS_OK;
-    } while (0);
-
-    //////////// FMO is not supported curently, so comment out the following code
-    //if((pInfo->active_PPS.num_slice_groups_minus1 > 0) && (pInfo->active_PPS.slice_group_map_type >= 3) && (pInfo->active_PPS.slice_group_map_type <= 5) )
-    //{
-    //	SliceHeader->slice_group_change_cycle = 0;				//one of the variables is not known in the high profile
-    //}
-
-    return ret;
-}
-
-
-
 /*-----------------------------------------------------------------------------------------*/
 // slice header 3
 // (direct_spatial_mv_pred_flag, num_ref_idx, pic_list_reorder, PWT,  ref_pic_remark, alpha, beta, etc)
@@ -366,13 +244,14 @@
         ////
         //// Parse Pred_weight_table but not store it becasue it will be reparsed in HW
         ////
-        if (((pInfo->active_PPS.weighted_pred_flag)
-               && ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP)))
-            || ((pInfo->active_PPS.weighted_bipred_idc == 1) && (SliceHeader->slice_type == h264_PtypeB)))
+        if (((pInfo->active_PPS.weighted_pred_flag) && ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP))) || ((pInfo->active_PPS.weighted_bipred_idc == 1) && (SliceHeader->slice_type == h264_PtypeB)))
         {
 
             viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);
 
+            pInfo->h264_pwt_enabled = 1;
+            pInfo->h264_pwt_start_byte_offset = byte_offset;
+            pInfo->h264_pwt_start_bit_offset  = bits_offset;
 
             if (h264_Parse_Pred_Weight_Table(parent, pInfo, SliceHeader) != H264_STATUS_OK)
             {
@@ -380,6 +259,18 @@
             }
 
             viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);
+
+            if (0 == bits_offset)
+            {
+                pInfo->h264_pwt_end_byte_offset = byte_offset-1;
+                pInfo->h264_pwt_end_bit_offset  = 8;
+            }
+            else
+            {
+                pInfo->h264_pwt_end_byte_offset = byte_offset;
+                pInfo->h264_pwt_end_bit_offset  = bits_offset;
+            }
+
         }
 
 
@@ -472,195 +363,6 @@
 }
 
 
-h264_Status h264_Parse_Slice_Header_3_opt(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
-{
-    h264_Status ret = H264_SliceHeader_ERROR;
-
-    //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
-    int32_t  slice_alpha_c0_offset, slice_beta_offset;
-    uint32_t code;
-    uint32_t bits_offset =0, byte_offset =0;
-    uint8_t  is_emul =0;
-
-    do {
-        /// direct_spatial_mv_pred_flag
-        if (SliceHeader->slice_type == h264_PtypeB)
-        {
-            viddec_pm_get_bits(parent, &code , 1);
-            SliceHeader->direct_spatial_mv_pred_flag = (uint8_t)code;
-        }
-        else
-        {
-            SliceHeader->direct_spatial_mv_pred_flag = 0;
-        }
-
-        //
-        // Reset ref_idx and Overide it if exist
-        //
-        SliceHeader->num_ref_idx_l0_active = SliceHeader->active_PPS->num_ref_idx_l0_active;
-        SliceHeader->num_ref_idx_l1_active = SliceHeader->active_PPS->num_ref_idx_l1_active;
-
-        if ((SliceHeader->slice_type == h264_PtypeP) ||
-            (SliceHeader->slice_type == h264_PtypeSP) ||
-            (SliceHeader->slice_type == h264_PtypeB))
-        {
-            viddec_pm_get_bits(parent, &code, 1);
-            SliceHeader->num_ref_idx_active_override_flag  = (uint8_t)code;
-
-            if (SliceHeader->num_ref_idx_active_override_flag)
-            {
-                SliceHeader->num_ref_idx_l0_active = h264_GetVLCElement(parent, pInfo, false) + 1;
-                if (SliceHeader->slice_type == h264_PtypeB)
-                {
-                    SliceHeader->num_ref_idx_l1_active = h264_GetVLCElement(parent, pInfo, false) + 1;
-                }
-            }
-        }
-
-        if (SliceHeader->slice_type != h264_PtypeB)
-        {
-            SliceHeader->num_ref_idx_l1_active = 0;
-        }
-
-        if ((SliceHeader->num_ref_idx_l0_active > MAX_NUM_REF_FRAMES) ||
-            (SliceHeader->num_ref_idx_l1_active > MAX_NUM_REF_FRAMES))
-        {
-            WTRACE("ref index greater than expected during slice header parsing.");
-            break;
-        }
-
-#ifdef USE_AVC_SHORT_FORMAT
-        bool keepParsing = false;
-        keepParsing = h264_is_new_picture_start(pInfo, *SliceHeader, pInfo->SliceHeader) &&
-                      (SliceHeader->nal_ref_idc != 0);
-        if (!keepParsing)
-        {
-            ITRACE("short format parsing: no need to go on!");
-            ret = H264_STATUS_OK;
-            break;
-        }
-#endif
-        if (h264_Parse_Ref_Pic_List_Reordering(parent, pInfo, SliceHeader) != H264_STATUS_OK)
-        {
-            WTRACE("ref list reordering failed during slice header parsing.");
-            break;
-        }
-
-
-        ////
-        //// Parse Pred_weight_table but not store it becasue it will be reparsed in HW
-        ////
-        if (((SliceHeader->active_PPS->weighted_pred_flag)
-               && ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP)))
-            || ((SliceHeader->active_PPS->weighted_bipred_idc == 1) && (SliceHeader->slice_type == h264_PtypeB)))
-        {
-
-            //viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);
-
-            if (h264_Parse_Pred_Weight_Table_opt(parent, pInfo, SliceHeader) != H264_STATUS_OK)
-            {
-                break;
-            }
-
-            viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);
-
-        }
-
-
-
-        ////
-        //// Parse Ref_pic marking if there
-        ////
-        if (SliceHeader->nal_ref_idc != 0)
-        {
-            if (h264_Parse_Dec_Ref_Pic_Marking(parent, pInfo, SliceHeader) != H264_STATUS_OK)
-            {
-                WTRACE("ref pic marking failed during slice header parsing.");
-                break;
-            }
-        }
-
-        if ((SliceHeader->active_PPS->entropy_coding_mode_flag) &&
-            (SliceHeader->slice_type != h264_PtypeI) &&
-            (SliceHeader->slice_type != h264_PtypeSI))
-        {
-            SliceHeader->cabac_init_idc = h264_GetVLCElement(parent, pInfo, false);
-        }
-        else
-        {
-            SliceHeader->cabac_init_idc = 0;
-        }
-
-        if (SliceHeader->cabac_init_idc > 2)
-        {
-            break;
-        }
-
-        SliceHeader->slice_qp_delta = h264_GetVLCElement(parent, pInfo, true);
-        if ((SliceHeader->slice_qp_delta > (25 - SliceHeader->active_PPS->pic_init_qp_minus26)) ||
-            (SliceHeader->slice_qp_delta < -(26 + SliceHeader->active_PPS->pic_init_qp_minus26)))
-        {
-            WTRACE("slice_qp_delta value is invalid.");
-            break;
-        }
-
-        if ((SliceHeader->slice_type == h264_PtypeSP) || (SliceHeader->slice_type == h264_PtypeSI))
-        {
-            if (SliceHeader->slice_type == h264_PtypeSP)
-            {
-                viddec_pm_get_bits(parent, &code, 1);
-                SliceHeader->sp_for_switch_flag  = (uint8_t)code;
-
-            }
-            SliceHeader->slice_qs_delta = h264_GetVLCElement(parent, pInfo, true);
-
-            if ((SliceHeader->slice_qs_delta > (25 - SliceHeader->active_PPS->pic_init_qs_minus26)) ||
-                (SliceHeader->slice_qs_delta < -(26 + SliceHeader->active_PPS->pic_init_qs_minus26)) )
-            {
-                WTRACE("slice_qp_delta value is invalid.");
-                break;
-            }
-        }
-        if (SliceHeader->active_PPS->deblocking_filter_control_present_flag)
-        {
-            SliceHeader->disable_deblocking_filter_idc = h264_GetVLCElement(parent, pInfo, false);
-            if (SliceHeader->disable_deblocking_filter_idc != 1)
-            {
-                SliceHeader->slice_alpha_c0_offset_div2 = h264_GetVLCElement(parent, pInfo, true);
-                slice_alpha_c0_offset = SliceHeader->slice_alpha_c0_offset_div2 << 1;
-                if (slice_alpha_c0_offset < -12 || slice_alpha_c0_offset > 12)
-                {
-                    break;
-                }
-
-                SliceHeader->slice_beta_offset_div2 = h264_GetVLCElement(parent, pInfo, true);
-                slice_beta_offset = SliceHeader->slice_beta_offset_div2 << 1;
-                if (slice_beta_offset < -12 || slice_beta_offset > 12)
-                {
-                    break;
-                }
-            }
-            else
-            {
-                SliceHeader->slice_alpha_c0_offset_div2 = 0;
-                SliceHeader->slice_beta_offset_div2 = 0;
-            }
-        }
-
-        ret = H264_STATUS_OK;
-    } while (0);
-
-    //////////// FMO is not supported curently, so comment out the following code
-    //if((pInfo->active_PPS.num_slice_groups_minus1 > 0) && (pInfo->active_PPS.slice_group_map_type >= 3) && (pInfo->active_PPS.slice_group_map_type <= 5) )
-    //{
-    //	SliceHeader->slice_group_change_cycle = 0;				//one of the variables is not known in the high profile
-    //}
-
-    return ret;
-}
-
-
-
 /*--------------------------------------------------------------------------------------------------*/
 //
 // The syntax elements reordering_of_pic_nums_idc, abs_diff_pic_num_minus1, and long_term_pic_num
@@ -675,7 +377,7 @@
 //
 /*--------------------------------------------------------------------------------------------------*/
 
-h264_Status h264_Parse_Ref_Pic_List_Reordering(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
+h264_Status h264_Parse_Ref_Pic_List_Reordering(void *parent, h264_Info* pInfo,h264_Slice_Header_t *SliceHeader)
 {
     //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
     int32_t reorder= -1;
@@ -698,18 +400,14 @@
                     return H264_SliceHeader_ERROR;
                 }
 
-                SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] =
-                    h264_GetVLCElement(parent, pInfo, false);
-                if ((SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 0) ||
-                    (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 1))
+                SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] = h264_GetVLCElement(parent, pInfo, false);
+                if ((SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 0) || (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 1))
                 {
-                    SliceHeader->sh_refpic_l0.list_reordering_num[reorder].abs_diff_pic_num_minus1 =
-                        h264_GetVLCElement(parent, pInfo, false);
+                    SliceHeader->sh_refpic_l0.list_reordering_num[reorder].abs_diff_pic_num_minus1 = h264_GetVLCElement(parent, pInfo, false);
                 }
                 else if (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 2)
                 {
-                    SliceHeader->sh_refpic_l0.list_reordering_num[reorder].long_term_pic_num =
-                        h264_GetVLCElement(parent, pInfo, false);
+                    SliceHeader->sh_refpic_l0.list_reordering_num[reorder].long_term_pic_num = h264_GetVLCElement(parent, pInfo, false);
                 }
 
             } while (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] != 3);
@@ -732,16 +430,13 @@
                     return H264_SliceHeader_ERROR;
                 }
                 SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] = h264_GetVLCElement(parent, pInfo, false);
-                if ((SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 0) ||
-                    (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 1))
+                if ((SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 0) || (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 1))
                 {
-                    SliceHeader->sh_refpic_l1.list_reordering_num[reorder].abs_diff_pic_num_minus1 =
-                        h264_GetVLCElement(parent, pInfo, false);
+                    SliceHeader->sh_refpic_l1.list_reordering_num[reorder].abs_diff_pic_num_minus1 = h264_GetVLCElement(parent, pInfo, false);
                 }
                 else if (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 2)
                 {
-                    SliceHeader->sh_refpic_l1.list_reordering_num[reorder].long_term_pic_num =
-                        h264_GetVLCElement(parent, pInfo, false);
+                    SliceHeader->sh_refpic_l1.list_reordering_num[reorder].long_term_pic_num = h264_GetVLCElement(parent, pInfo, false);
                 }
             } while (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] != 3);
         }
@@ -819,8 +514,7 @@
             }
             else
             {
-                SliceHeader->sh_predwttbl.luma_weight_l1[i] = 
-                    (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
+                SliceHeader->sh_predwttbl.luma_weight_l1[i] = (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
                 SliceHeader->sh_predwttbl.luma_offset_l1[i] = 0;
             }
 
@@ -841,8 +535,7 @@
                 {
                     for (j = 0; j < 2; j++)
                     {
-                        SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] =
-                            (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
+                        SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] = (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
                         SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] = 0;
                     }
                 }
@@ -855,113 +548,6 @@
 } ///// End of h264_Parse_Pred_Weight_Table
 
 
-h264_Status h264_Parse_Pred_Weight_Table_opt(void *parent, h264_Info* pInfo,h264_Slice_Header_t *SliceHeader)
-{
-    uint32_t i = 0, j = 0;
-    uint32_t flag;
-
-    SliceHeader->sh_predwttbl.luma_log2_weight_denom = h264_GetVLCElement(parent, pInfo, false);
-
-    if (SliceHeader->active_SPS->sps_disp.chroma_format_idc != 0)
-    {
-        SliceHeader->sh_predwttbl.chroma_log2_weight_denom = h264_GetVLCElement(parent,pInfo, false);
-    }
-
-    for (i = 0; i < SliceHeader->num_ref_idx_l0_active; i++)
-    {
-        viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
-        SliceHeader->sh_predwttbl.luma_weight_l0_flag = flag;
-
-        if (SliceHeader->sh_predwttbl.luma_weight_l0_flag)
-        {
-            SliceHeader->sh_predwttbl.luma_weight_l0[i] = h264_GetVLCElement(parent, pInfo, true);
-            SliceHeader->sh_predwttbl.luma_offset_l0[i] = h264_GetVLCElement(parent, pInfo, true);
-        }
-        else
-        {
-            SliceHeader->sh_predwttbl.luma_weight_l0[i] = (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
-            SliceHeader->sh_predwttbl.luma_offset_l0[i] = 0;
-        }
-
-        if (SliceHeader->active_SPS->sps_disp.chroma_format_idc != 0)
-        {
-            viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
-            SliceHeader->sh_predwttbl.chroma_weight_l0_flag = flag;
-
-            if (SliceHeader->sh_predwttbl.chroma_weight_l0_flag)
-            {
-                for (j = 0; j < 2; j++)
-                {
-                    SliceHeader->sh_predwttbl.chroma_weight_l0[i][j] = h264_GetVLCElement(parent, pInfo, true);
-                    SliceHeader->sh_predwttbl.chroma_offset_l0[i][j] = h264_GetVLCElement(parent, pInfo, true);
-                }
-            }
-            else
-            {
-                for (j = 0; j < 2; j++)
-                {
-                    SliceHeader->sh_predwttbl.chroma_weight_l0[i][j] =
-                        (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
-                    SliceHeader->sh_predwttbl.chroma_offset_l0[i][j] = 0;
-                }
-            }
-        }
-
-    }
-
-    if (SliceHeader->slice_type == h264_PtypeB)
-    {
-        for (i = 0; i < SliceHeader->num_ref_idx_l1_active; i++)
-        {
-            viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
-            SliceHeader->sh_predwttbl.luma_weight_l1_flag = flag;
-
-            if (SliceHeader->sh_predwttbl.luma_weight_l1_flag)
-            {
-                SliceHeader->sh_predwttbl.luma_weight_l1[i] = h264_GetVLCElement(parent, pInfo, true);
-                SliceHeader->sh_predwttbl.luma_offset_l1[i] = h264_GetVLCElement(parent, pInfo, true);
-            }
-            else
-            {
-                SliceHeader->sh_predwttbl.luma_weight_l1[i] =
-                    (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
-                SliceHeader->sh_predwttbl.luma_offset_l1[i] = 0;
-            }
-
-            if (SliceHeader->active_SPS->sps_disp.chroma_format_idc != 0)
-            {
-                viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
-                SliceHeader->sh_predwttbl.chroma_weight_l1_flag = flag;
-
-                if (SliceHeader->sh_predwttbl.chroma_weight_l1_flag)
-                {
-                    for (j = 0; j < 2; j++)
-                    {
-                        SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] =
-                            h264_GetVLCElement(parent, pInfo, true);
-                        SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] =
-                            h264_GetVLCElement(parent, pInfo, true);
-                    }
-                }
-                else
-                {
-                    for (j = 0; j < 2; j++)
-                    {
-                        SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] =
-                            (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
-                        SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] = 0;
-                    }
-                }
-            }
-
-        }
-    }
-
-    return H264_STATUS_OK;
-}
-
-
-
 /*--------------------------------------------------------------------------------------------------*/
 // The syntax elements specify marking of the reference pictures.
 //			1)IDR:		no_output_of_prior_pics_flag,
@@ -1014,32 +600,25 @@
             {
                 if (i < NUM_MMCO_OPERATIONS)
                 {
-                    SliceHeader->sh_dec_refpic.memory_management_control_operation[i] =
-                        h264_GetVLCElement(parent, pInfo, false);
-                    if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 1) ||
-                        (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3))
+                    SliceHeader->sh_dec_refpic.memory_management_control_operation[i] = h264_GetVLCElement(parent, pInfo, false);
+                    if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 1) || (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3))
                     {
-                        SliceHeader->sh_dec_refpic.difference_of_pic_num_minus1[i] =
-                            h264_GetVLCElement(parent, pInfo, false);
+                        SliceHeader->sh_dec_refpic.difference_of_pic_num_minus1[i] = h264_GetVLCElement(parent, pInfo, false);
                     }
 
                     if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 2)
                     {
-                        SliceHeader->sh_dec_refpic.long_term_pic_num[i] =
-                            h264_GetVLCElement(parent, pInfo, false);
+                        SliceHeader->sh_dec_refpic.long_term_pic_num[i] = h264_GetVLCElement(parent, pInfo, false);
                     }
 
-                    if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3) ||
-                        (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 6))
+                    if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3) || (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 6))
                     {
-                        SliceHeader->sh_dec_refpic.long_term_frame_idx[i] =
-                            h264_GetVLCElement(parent, pInfo, false);
+                        SliceHeader->sh_dec_refpic.long_term_frame_idx[i] = h264_GetVLCElement(parent, pInfo, false);
                     }
 
                     if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 4)
                     {
-                        SliceHeader->sh_dec_refpic.max_long_term_frame_idx_plus1[i] =
-                            h264_GetVLCElement(parent, pInfo, false);
+                        SliceHeader->sh_dec_refpic.max_long_term_frame_idx_plus1[i] = h264_GetVLCElement(parent, pInfo, false);
                     }
 
                     if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 5)
diff --git a/mixvbp/vbp_plugin/h264/include/h264.h b/mixvbp/vbp_plugin/h264/include/h264.h
index acb3a59..7015c37 100755
--- a/mixvbp/vbp_plugin/h264/include/h264.h
+++ b/mixvbp/vbp_plugin/h264/include/h264.h
@@ -681,8 +681,56 @@
         int8_t chroma_offset_l1[32][2];
     } h264_pred_weight_table;
 
-#define MAX_USER_DATA_SIZE 1024
+    typedef struct _h264_Slice_Header
+    {
+        int32_t 		first_mb_in_slice;								//UE
+        int32_t		frame_num;											//UV
+        int32_t		pic_order_cnt_lsb;								//UV
+        int32_t		delta_pic_order_cnt_bottom;					//SE
+        int32_t		delta_pic_order_cnt[2];								//SE
+        int32_t		redundant_pic_cnt;									//UE
 
+        uint32_t		num_ref_idx_l0_active;								//UE
+        uint32_t		num_ref_idx_l1_active;								//UE
+
+        int32_t		slice_qp_delta;										//SE
+        int32_t		slice_qs_delta;										//SE
+        int32_t		slice_alpha_c0_offset_div2;						//SE
+        int32_t		slice_beta_offset_div2;								//SE
+        int32_t		slice_group_change_cycle;							//UV
+
+        h264_pred_weight_table  sh_predwttbl;
+
+        ///// Flags or IDs
+        //h264_ptype_t	slice_type;											//UE
+        uint8_t			slice_type;
+        uint8_t 			nal_ref_idc;
+        uint8_t			structure;
+        uint8_t 			pic_parameter_id;									//UE
+
+        uint8_t			field_pic_flag;
+        uint8_t			bottom_field_flag;
+        uint8_t			idr_flag;											//UE
+        uint8_t			idr_pic_id;											//UE
+
+        uint8_t 			sh_error;
+        uint8_t			cabac_init_idc;										//UE
+        uint8_t			sp_for_switch_flag;
+        uint8_t			disable_deblocking_filter_idc;						//UE
+
+        uint8_t			direct_spatial_mv_pred_flag;
+        uint8_t			num_ref_idx_active_override_flag;
+        int16_t			current_slice_nr;
+
+        //// For Ref list reordering
+        h264_Dec_Ref_Pic_Marking_t sh_dec_refpic;
+        h264_Ref_Pic_List_Reordering_t sh_refpic_l0;
+        h264_Ref_Pic_List_Reordering_t sh_refpic_l1;
+
+    } h264_Slice_Header_t;
+
+
+#define   MAX_USER_DATA_SIZE              1024
     typedef struct _h264_user_data_t
     {
         h264_sei_payloadtype    user_data_type;
@@ -780,71 +828,6 @@
 
     } seq_param_set_all, *seq_param_set_all_ptr;
 
-    typedef struct _h264_Slice_Header
-    {
-        int32_t 	first_mb_in_slice;						//UE
-        int32_t		frame_num;							//UV
-        int32_t		pic_order_cnt_lsb;						//UV
-        int32_t		delta_pic_order_cnt_bottom;					//SE
-        int32_t		delta_pic_order_cnt[2];						//SE
-        int32_t		redundant_pic_cnt;						//UE
-
-        uint32_t	num_ref_idx_l0_active;						//UE
-        uint32_t	num_ref_idx_l1_active;						//UE
-
-        int32_t		slice_qp_delta;							//SE
-        int32_t		slice_qs_delta;							//SE
-        int32_t		slice_alpha_c0_offset_div2;					//SE
-        int32_t		slice_beta_offset_div2;						//SE
-        int32_t		slice_group_change_cycle;					//UV
-
-        h264_pred_weight_table  sh_predwttbl;
-
-        ///// Flags or IDs
-        //h264_ptype_t	slice_type;							//UE
-        uint8_t			slice_type;
-        uint8_t 		nal_ref_idc;
-        uint8_t			structure;
-        uint8_t 		pic_parameter_id;					//UE
-
-        uint8_t			field_pic_flag;
-        uint8_t			bottom_field_flag;
-        uint8_t			idr_flag;						//UE
-        uint8_t			idr_pic_id;						//UE
-
-        uint8_t 		sh_error;
-        uint8_t			cabac_init_idc;						//UE
-        uint8_t			sp_for_switch_flag;
-        uint8_t			disable_deblocking_filter_idc;				//UE
-
-        uint8_t			direct_spatial_mv_pred_flag;
-        uint8_t			num_ref_idx_active_override_flag;
-        int16_t			current_slice_nr;
-
-        //// For Ref list reordering
-        h264_Dec_Ref_Pic_Marking_t sh_dec_refpic;
-        h264_Ref_Pic_List_Reordering_t sh_refpic_l0;
-        h264_Ref_Pic_List_Reordering_t sh_refpic_l1;
-
-        seq_param_set_used*     active_SPS;
-        pic_param_set*          active_PPS;
-        uint32_t                parse_done;         // flag to indicate parse done
-
-        // temp field for multithread parsing to store bitstream info
-        uint32_t                bstrm_buf_buf_index;
-        uint32_t                bstrm_buf_buf_st;
-        uint32_t                bstrm_buf_buf_end;
-        uint32_t                bstrm_buf_buf_bitoff;
-        uint32_t                au_pos;
-        uint32_t                list_off;
-        uint32_t                phase;
-        uint32_t                emulation_byte_counter;
-        uint32_t                is_emul_reqd;
-        int32_t                 list_start_offset;
-        int32_t                 list_end_offset;
-        int32_t                 list_total_bytes;
-
-    } h264_Slice_Header_t;
 
 ///// Image control parameter////////////
     typedef struct _h264_img_par
@@ -949,14 +932,13 @@
         //// Structures
         //// need to gurantee active_SPS and active_PPS start from 4-bytes alignment address
         seq_param_set_used	active_SPS;
-        pic_param_set	        active_PPS;
+        pic_param_set			active_PPS;
 
 
         h264_Slice_Header_t  SliceHeader;
         OldSliceParams       old_slice;
         sei_info             sei_information;
 
-        h264_Slice_Header_t*  working_sh[150]; // working slice header for multithreading
         h264_img_par      img;
 
         uintptr_t         SPS_PADDR_GL;
diff --git a/mixvbp/vbp_plugin/h264/include/h264parse.h b/mixvbp/vbp_plugin/h264/include/h264parse.h
index 6adee42..2b1c7a6 100755
--- a/mixvbp/vbp_plugin/h264/include/h264parse.h
+++ b/mixvbp/vbp_plugin/h264/include/h264parse.h
@@ -89,7 +89,7 @@
 ////////////////////////////////////////////////////////////////////
 
 //NAL
-    extern h264_Status h264_Parse_NAL_Unit(void *parent, uint8_t *nal_unit_type, uint8_t *nal_ref_idc);
+    extern h264_Status h264_Parse_NAL_Unit(void *parent, h264_Info* pInfo, uint8_t *nal_ref_idc);
 
 ////// Slice header
     extern h264_Status h264_Parse_Slice_Layer_Without_Partitioning_RBSP(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader);
@@ -97,12 +97,6 @@
     extern h264_Status h264_Parse_Slice_Header_2(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader);
     extern h264_Status h264_Parse_Slice_Header_3(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader);
 
-// For multi-thread parsing optimized.
-    extern h264_Status h264_Parse_Slice_Layer_Without_Partitioning_RBSP_opt(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader);
-    extern h264_Status h264_Parse_Slice_Header_2_opt(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader);
-    extern h264_Status h264_Parse_Slice_Header_3_opt(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader);
-
-    extern h264_Status h264_Post_Parsing_Slice_Header(void *parent, h264_Info* pInfo, h264_Slice_Header_t *next_SliceHeader);
 
 ////// SPS
     extern h264_Status h264_Parse_SeqParameterSet(void *parent, h264_Info * pInfo,seq_param_set_used_ptr SPS, vui_seq_parameters_t_not_used_ptr pVUI_Seq_Not_Used, int32_t* pOffset_ref_frame);
@@ -119,8 +113,6 @@
     extern h264_Status h264_Parse_Pred_Weight_Table(void *parent,h264_Info* pInfo,h264_Slice_Header_t *SliceHeader);
     extern h264_Status h264_Parse_Dec_Ref_Pic_Marking(void *parent,h264_Info* pInfo,h264_Slice_Header_t *SliceHeader);
 
-    extern h264_Status h264_Parse_Pred_Weight_Table_opt(void *parent,h264_Info* pInfo,h264_Slice_Header_t *SliceHeader);
-
 
 
 ///// Mem functions
diff --git a/mixvbp/vbp_plugin/h264/mix_vbp_h264_stubs.c b/mixvbp/vbp_plugin/h264/mix_vbp_h264_stubs.c
index eb85022..62e6ab3 100755
--- a/mixvbp/vbp_plugin/h264/mix_vbp_h264_stubs.c
+++ b/mixvbp/vbp_plugin/h264/mix_vbp_h264_stubs.c
@@ -204,12 +204,10 @@
 void h264_parse_emit_start_new_frame( void *parent, h264_Info *pInfo )
 {
 
-    uint32_t i=0,nitems=0;
+    uint32_t                   i=0,nitems=0;
 
     ///////////////////////// Frame attributes//////////////////////////
 
-// Remove workload related stuff
-# if 0
     //Push data into current workload if first frame or frame_boundary already detected by non slice nal
     if ( (pInfo->Is_first_frame_in_stream)||(pInfo->is_frame_boundary_detected_by_non_slice_nal))
     {
@@ -229,7 +227,6 @@
 
         pInfo->is_current_workload_done=1;
     }
-#endif
 
     ///////////////////// SPS/////////////////////
     // h264_parse_emit_sps(parent, pInfo);
diff --git a/mixvbp/vbp_plugin/h264/secvideo/baytrail/viddec_h264secure_parse.c b/mixvbp/vbp_plugin/h264/secvideo/baytrail/viddec_h264secure_parse.c
index b9ec1c0..9490ddd 100755
--- a/mixvbp/vbp_plugin/h264/secvideo/baytrail/viddec_h264secure_parse.c
+++ b/mixvbp/vbp_plugin/h264/secvideo/baytrail/viddec_h264secure_parse.c
@@ -40,15 +40,14 @@
 
 
     uint8_t nal_ref_idc = 0;
-    uint8_t nal_unit_type = 0;
 
     ///// Parse NAL Unit header
     pInfo->img.g_new_frame = 0;
     pInfo->push_to_cur = 1;
     pInfo->is_current_workload_done =0;
+    pInfo->nal_unit_type = 0;
 
-    h264_Parse_NAL_Unit(parent, &nal_unit_type, &nal_ref_idc);
-    pInfo->nal_unit_type = nal_unit_type;
+    h264_Parse_NAL_Unit(parent, pInfo, &nal_ref_idc);
 
     ///// Check frame bounday for non-vcl elimitter
     h264_check_previous_frame_end(pInfo);
diff --git a/mixvbp/vbp_plugin/h264/viddec_h264_parse.c b/mixvbp/vbp_plugin/h264/viddec_h264_parse.c
index fcf5c36..28a319a 100755
--- a/mixvbp/vbp_plugin/h264/viddec_h264_parse.c
+++ b/mixvbp/vbp_plugin/h264/viddec_h264_parse.c
@@ -7,12 +7,6 @@
 
 #include "h264parse_dpb.h"
 #include <vbp_trace.h>
-#include <assert.h>
-
-uint32_t viddec_threading_backup_ctx_info(void *parent, h264_Slice_Header_t *next_SliceHeader);
-uint32_t viddec_threading_restore_ctx_info(void *parent, h264_Slice_Header_t *next_SliceHeader);
-
-#define MAX_SLICE_HEADER 150
 
 /* Init function which can be called to intialized local context on open and flush and preserve*/
 void viddec_h264_init(void *ctxt, uint32_t *persist_mem, uint32_t preserve)
@@ -30,26 +24,6 @@
     /* picture level info which will always be initialized */
     h264_init_Info_under_sps_pps_level(pInfo);
 
-    uint32_t i;
-    for(i = 0; i < MAX_SLICE_HEADER; i++) {
-        pInfo->working_sh[i] = (h264_Slice_Header_t*)malloc(sizeof(h264_Slice_Header_t));
-        assert(pInfo->working_sh[i] != NULL);
-
-        pInfo->working_sh[i]->parse_done = 0;
-        pInfo->working_sh[i]->bstrm_buf_buf_index = 0;
-        pInfo->working_sh[i]->bstrm_buf_buf_st = 0;
-        pInfo->working_sh[i]->bstrm_buf_buf_end = 0;
-        pInfo->working_sh[i]->bstrm_buf_buf_bitoff = 0;
-        pInfo->working_sh[i]->au_pos = 0;
-        pInfo->working_sh[i]->list_off = 0;
-        pInfo->working_sh[i]->phase = 0;
-        pInfo->working_sh[i]->emulation_byte_counter = 0;
-        pInfo->working_sh[i]->is_emul_reqd = 0;
-        pInfo->working_sh[i]->list_start_offset = 0;
-        pInfo->working_sh[i]->list_end_offset = 0;
-        pInfo->working_sh[i]->list_total_bytes = 0;
-        pInfo->working_sh[i]->slice_group_change_cycle = 0;
-    }
     return;
 }
 
@@ -66,7 +40,6 @@
     h264_Status status = H264_STATUS_ERROR;
 
     uint8_t nal_ref_idc = 0;
-    uint8_t nal_unit_type = 0;
 
     ///// Parse NAL Unit header
     pInfo->img.g_new_frame = 0;
@@ -74,10 +47,9 @@
     pInfo->is_current_workload_done =0;
     pInfo->nal_unit_type = 0;
 
-    h264_Parse_NAL_Unit(parent, &nal_unit_type, &nal_ref_idc);
+    h264_Parse_NAL_Unit(parent, pInfo, &nal_ref_idc);
     VTRACE("Start parsing NAL unit, type = %d", pInfo->nal_unit_type);
 
-    pInfo->nal_unit_type = nal_unit_type;
     ///// Check frame bounday for non-vcl elimitter
     h264_check_previous_frame_end(pInfo);
 
@@ -446,64 +418,6 @@
     return status;
 }
 
-
-uint32_t viddec_h264_threading_parse(void *parent, void *ctxt, uint32_t slice_index)
-{
-    struct h264_viddec_parser* parser = ctxt;
-
-    h264_Info * pInfo = &(parser->info);
-
-    h264_Status status = H264_STATUS_ERROR;
-
-    uint8_t nal_ref_idc = 0;
-    uint8_t nal_unit_type = 0;
-
-    h264_Parse_NAL_Unit(parent, &nal_unit_type, &nal_ref_idc);
-
-    pInfo->nal_unit_type = nal_unit_type;
-
-
-    //////// Parse valid NAL unit
-    if (nal_unit_type == h264_NAL_UNIT_TYPE_SLICE) {
-        h264_Slice_Header_t* next_SliceHeader = pInfo->working_sh[slice_index];
-        memset(next_SliceHeader, 0, sizeof(h264_Slice_Header_t));
-
-        next_SliceHeader->nal_ref_idc = nal_ref_idc;
-
-
-        ////////////////////////////////////////////////////////////////////////////
-        // Step 2: Parsing slice header
-        ////////////////////////////////////////////////////////////////////////////
-        /// IDR flag
-        next_SliceHeader->idr_flag = (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR);
-
-
-        /// Pass slice header
-        status = h264_Parse_Slice_Layer_Without_Partitioning_RBSP_opt(parent, pInfo, next_SliceHeader);
-
-        viddec_threading_backup_ctx_info(parent, next_SliceHeader);
-
-        if (next_SliceHeader->sh_error & 3)
-        {
-            ETRACE("Slice Header parsing error.");
-            status = H264_STATUS_ERROR;
-            return status;
-        }
-
-        //h264_Post_Parsing_Slice_Header(parent, pInfo, &next_SliceHeader);
-        next_SliceHeader->parse_done  = 1;
-
-    } else {
-        ETRACE("Wrong NALU. Multi thread is supposed to just parse slice nalu type.");
-        status = H264_STATUS_ERROR;
-        return status;
-    }
-
-   return status;
-}
-
-
-
 void viddec_h264_get_context_size(viddec_parser_memory_sizes_t *size)
 {
     /* Should return size of my structure */
@@ -538,104 +452,7 @@
     p_dpb->fs_dec_idc = MPD_DPB_FS_NULL_IDC;
     p_dpb->fs_non_exist_idc = MPD_DPB_FS_NULL_IDC;
 
-    for(i = 0; i < MAX_SLICE_HEADER; i++) {
-        free(pInfo->working_sh[i]);
-        pInfo->working_sh[i] = NULL;
-    }
     return;
 }
 
-uint32_t viddec_h264_payload_start(void *parent)
-{
-
-    uint32_t code;
-    uint8_t nal_unit_type = 0;
-    if ( viddec_pm_peek_bits(parent, &code, 8) != -1)
-    {
-        nal_unit_type = (uint8_t)((code >> 0) & 0x1f);
-    }
-    //check that whether slice data starts
-    if (nal_unit_type == h264_NAL_UNIT_TYPE_SLICE)
-    {
-        return 1;
-    } else {
-        return 0;
-    }
-}
-
-uint32_t viddec_h264_post_parse(void *parent, void *ctxt, uint32_t slice_index)
-{
-    struct h264_viddec_parser* parser = ctxt;
-    h264_Info * pInfo = &(parser->info);
-    h264_Status status = H264_STATUS_ERROR;
-
-    h264_Slice_Header_t* next_SliceHeader = pInfo->working_sh[slice_index];
-
-    while (next_SliceHeader->parse_done != 1) {
-        sleep(0);
-        //WTRACE("slice header[%d] parse not finish, block to wait.", slice_index);
-    }
-
-    viddec_threading_restore_ctx_info(parent, next_SliceHeader);
-    status = h264_Post_Parsing_Slice_Header(parent, pInfo, next_SliceHeader);
-
-    next_SliceHeader->parse_done = 0;
-
-    return status;
-}
-
-
-uint32_t viddec_h264_query_thread_parsing_cap(void)
-{
-    // current implementation of h.264 is capable to enable multi-thread parsing
-    return 1;
-}
-
-uint32_t viddec_threading_backup_ctx_info(void *parent, h264_Slice_Header_t *next_SliceHeader)
-{
-    h264_Status retStatus = H264_STATUS_OK;
-
-    viddec_pm_cxt_t* pm_cxt = (viddec_pm_cxt_t*) parent;
-
-    next_SliceHeader->bstrm_buf_buf_index = pm_cxt->getbits.bstrm_buf.buf_index;
-    next_SliceHeader->bstrm_buf_buf_st = pm_cxt->getbits.bstrm_buf.buf_st;
-    next_SliceHeader->bstrm_buf_buf_end = pm_cxt->getbits.bstrm_buf.buf_end;
-    next_SliceHeader->bstrm_buf_buf_bitoff = pm_cxt->getbits.bstrm_buf.buf_bitoff;
-
-    next_SliceHeader->au_pos = pm_cxt->getbits.au_pos;
-    next_SliceHeader->list_off = pm_cxt->getbits.list_off;
-    next_SliceHeader->phase = pm_cxt->getbits.phase;
-    next_SliceHeader->emulation_byte_counter = pm_cxt->getbits.emulation_byte_counter;
-    next_SliceHeader->is_emul_reqd = pm_cxt->getbits.is_emul_reqd;
-
-    next_SliceHeader->list_start_offset = pm_cxt->list.start_offset;
-    next_SliceHeader->list_end_offset = pm_cxt->list.end_offset;
-    next_SliceHeader->list_total_bytes = pm_cxt->list.total_bytes;
-
-    return retStatus;
-}
-
-uint32_t viddec_threading_restore_ctx_info(void *parent, h264_Slice_Header_t *next_SliceHeader)
-{
-    h264_Status retStatus = H264_STATUS_OK;
-
-    viddec_pm_cxt_t* pm_cxt = (viddec_pm_cxt_t*) parent;
-
-    pm_cxt->getbits.bstrm_buf.buf_index = next_SliceHeader->bstrm_buf_buf_index;
-    pm_cxt->getbits.bstrm_buf.buf_st = next_SliceHeader->bstrm_buf_buf_st;
-    pm_cxt->getbits.bstrm_buf.buf_end = next_SliceHeader->bstrm_buf_buf_end;
-    pm_cxt->getbits.bstrm_buf.buf_bitoff = next_SliceHeader->bstrm_buf_buf_bitoff;
-
-    pm_cxt->getbits.au_pos = next_SliceHeader->au_pos;
-    pm_cxt->getbits.list_off = next_SliceHeader->list_off;
-    pm_cxt->getbits.phase = next_SliceHeader->phase;
-    pm_cxt->getbits.emulation_byte_counter = next_SliceHeader->emulation_byte_counter;
-    pm_cxt->getbits.is_emul_reqd = next_SliceHeader->is_emul_reqd;
-
-    pm_cxt->list.start_offset = next_SliceHeader->list_start_offset;
-    pm_cxt->list.end_offset = next_SliceHeader->list_end_offset;
-    pm_cxt->list.total_bytes = next_SliceHeader->list_total_bytes;
-
-    return retStatus;
-}