diff --git a/mpp/codec/dec/h264/h264d_api.c b/mpp/codec/dec/h264/h264d_api.c
index 8f89d153..13f5cbcb 100644
--- a/mpp/codec/dec/h264/h264d_api.c
+++ b/mpp/codec/dec/h264/h264d_api.c
@@ -18,8 +18,9 @@
 #include "mpp_packet.h"
 #include "mpp_packet_impl.h"
 #include "mpp_mem.h"
-#include "h264d_api.h"
+
 #include "h264d_log.h"
+#include "h264d_api.h"
 #include "h264d_global.h"
 #include "h264d_parse.h"
 
@@ -30,7 +31,7 @@
 
 static MPP_RET free_input_ctx(H264dInputCtx_t *p_Inp)
 {
-	INP_CHECK(!p_Inp);
+    INP_CHECK(!p_Inp);
     FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
 
     (void)p_Inp;
@@ -41,7 +42,7 @@ __RETURN:
 }
 static MPP_RET init_input_ctx(H264dInputCtx_t *p_Inp, MppParserInitCfg *init)
 {
-	INP_CHECK(!p_Inp && !init);
+    INP_CHECK(!p_Inp && !init);
     FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
 
     p_Inp->init = *init;
@@ -54,193 +55,182 @@ __RETURN:
 
 static MPP_RET free_cur_ctx(H264dCurCtx_t *p_Cur)
 {
-	RK_U32 i = 0;
-	INP_CHECK(!p_Cur);
+    RK_U32 i = 0;
+    INP_CHECK(!p_Cur);
     FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
-	if (p_Cur)
-	{
-		//rkv_h264d_recycle_slice(p_Cur->slice);
-		for (i = 0; i < 2; i++)
-		{
-			mpp_free(p_Cur->listP[i]);
-			mpp_free(p_Cur->listB[i]);
-		}
-		mpp_free(p_Cur->strm.buf);
-	}
+    if (p_Cur) {
+        //rkv_h264d_recycle_slice(p_Cur->slice);
+        for (i = 0; i < 2; i++) {
+            mpp_free(p_Cur->listP[i]);
+            mpp_free(p_Cur->listB[i]);
+        }
+        mpp_free(p_Cur->strm.buf);
+    }
     FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
     return MPP_OK;
 }
 static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur)
 {
-	RK_U32 i = 0;
-	INP_CHECK(!p_Cur);
+    RK_U32 i = 0;
+    INP_CHECK(!p_Cur);
     FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
 
-	MEM_CHECK(p_Cur->strm.buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE));
-	p_Cur->strm.max_size = NALU_BUF_MAX_SIZE;
-	p_Cur->strm.prefixdata[0] = 0xff;
-	p_Cur->strm.prefixdata[1] = 0xff;
-	p_Cur->strm.prefixdata[2] = 0xff;
-	for (i = 0; i < 2; i++)
-	{
-		MEM_CHECK(p_Cur->listP[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE*sizeof(H264_StorePic_t*))); // +1 for reordering
-		MEM_CHECK(p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE*sizeof(H264_StorePic_t*))); // +1 for reordering
-	}
+    MEM_CHECK(p_Cur->strm.buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE));
+    p_Cur->strm.max_size = NALU_BUF_MAX_SIZE;
+    p_Cur->strm.prefixdata[0] = 0xff;
+    p_Cur->strm.prefixdata[1] = 0xff;
+    p_Cur->strm.prefixdata[2] = 0xff;
+    for (i = 0; i < 2; i++) {
+        MEM_CHECK(p_Cur->listP[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*))); // +1 for reordering
+        MEM_CHECK(p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*))); // +1 for reordering
+    }
     FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
     return MPP_OK;
 __FAILED:
-	free_cur_ctx(p_Cur);
+    free_cur_ctx(p_Cur);
 
-	return MPP_NOK;
+    return MPP_NOK;
 }
 
 
 static MPP_RET free_vid_ctx(H264dVideoCtx_t *p_Vid)
 {
-	RK_U32 i = 0;
-	INP_CHECK(!p_Vid);
+    RK_U32 i = 0;
+    INP_CHECK(!p_Vid);
     FunctionIn(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
-	for (i = 0; i < MAX_NUM_DPB_LAYERS; i++)
-	{
-		mpp_free(p_Vid->p_Dpb_layer[i]);
-	}
+    for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
+        mpp_free(p_Vid->p_Dpb_layer[i]);
+    }
     FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
     return MPP_OK;
 }
 static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
 {
-	RK_U32 i = 0;
-	INP_CHECK(!p_Vid);
+    RK_U32 i = 0;
+    INP_CHECK(!p_Vid);
     FunctionIn(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
-	for (i = 0; i < MAX_NUM_DPB_LAYERS; i++)
-	{
-		MEM_CHECK(p_Vid->p_Dpb_layer[i]  = mpp_calloc(H264_DpbBuf_t, 1));
-		p_Vid->p_Dpb_layer[i]->layer_id  = i;
-		p_Vid->p_Dpb_layer[i]->p_Vid     = p_Vid;
-		p_Vid->p_Dpb_layer[i]->init_done = 0;
-	}
-	//!< init video pars
-	for (i = 0; i < MAXSPS; i++)
-	{
-		p_Vid->spsSet[i].seq_parameter_set_id = -1;
-		p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
-	}
-	for (i = 0; i < MAXPPS; i++)
-	{
-		p_Vid->ppsSet[i].pic_parameter_set_id = -1;
-		p_Vid->ppsSet[i].seq_parameter_set_id = -1;
-	}
-	//!< init active_sps
-	p_Vid->active_sps       = NULL;
-	p_Vid->active_subsps    = NULL;
-	p_Vid->active_sps_id[0] = -1;
-	p_Vid->active_sps_id[1] = -1;
-	//!< init subspsSet
-	for (i = 0; i < MAXSPS; i++)
-	{
-		p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
-		p_Vid->subspsSet[i].num_views_minus1 = -1;
-		p_Vid->subspsSet[i].num_level_values_signalled_minus1 = -1;
-	}
+    for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
+        MEM_CHECK(p_Vid->p_Dpb_layer[i]  = mpp_calloc(H264_DpbBuf_t, 1));
+        p_Vid->p_Dpb_layer[i]->layer_id  = i;
+        p_Vid->p_Dpb_layer[i]->p_Vid     = p_Vid;
+        p_Vid->p_Dpb_layer[i]->init_done = 0;
+    }
+    //!< init video pars
+    for (i = 0; i < MAXSPS; i++) {
+        p_Vid->spsSet[i].seq_parameter_set_id = -1;
+        p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
+    }
+    for (i = 0; i < MAXPPS; i++) {
+        p_Vid->ppsSet[i].pic_parameter_set_id = -1;
+        p_Vid->ppsSet[i].seq_parameter_set_id = -1;
+    }
+    //!< init active_sps
+    p_Vid->active_sps       = NULL;
+    p_Vid->active_subsps    = NULL;
+    p_Vid->active_sps_id[0] = -1;
+    p_Vid->active_sps_id[1] = -1;
+    //!< init subspsSet
+    for (i = 0; i < MAXSPS; i++) {
+        p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
+        p_Vid->subspsSet[i].num_views_minus1 = -1;
+        p_Vid->subspsSet[i].num_level_values_signalled_minus1 = -1;
+    }
     FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
     return MPP_OK;
 __FAILED:
-	free_vid_ctx(p_Vid);
+    free_vid_ctx(p_Vid);
 
-	return MPP_NOK;
+    return MPP_NOK;
 }
 
 static MPP_RET free_dxva_ctx(H264dDxvaCtx_t *p_dxva)
-{		
-	INP_CHECK(!p_dxva);
-	FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
+{
+    INP_CHECK(!p_dxva);
+    FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
 
-	mpp_free(p_dxva->slice_short);
-	mpp_free(p_dxva->slice_long);
-	mpp_free(p_dxva->bitstream);
-	mpp_free(p_dxva->syn.buf);
+    mpp_free(p_dxva->slice_short);
+    mpp_free(p_dxva->slice_long);
+    mpp_free(p_dxva->bitstream);
+    mpp_free(p_dxva->syn.buf);
 
-	FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
+    FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
-	return MPP_OK;
+    return MPP_OK;
 }
 
 static MPP_RET init_dxva_ctx(H264dDxvaCtx_t *p_dxva)
 {
-	INP_CHECK(!p_dxva);
-	FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
+    INP_CHECK(!p_dxva);
+    FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
 
-	p_dxva->max_slice_size = MAX_SLICE_SIZE;
-	MEM_CHECK(p_dxva->slice_short = mpp_calloc(DXVA_Slice_H264_Short, p_dxva->max_slice_size));
-	MEM_CHECK(p_dxva->slice_long  = mpp_calloc(DXVA_Slice_H264_Long,  p_dxva->max_slice_size));
-	p_dxva->max_strm_size = FRAME_BUF_MAX_SIZE;
-	MEM_CHECK(p_dxva->bitstream = mpp_malloc(RK_U8,p_dxva->max_strm_size));
-	MEM_CHECK(p_dxva->syn.buf   = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE));
+    p_dxva->max_slice_size = MAX_SLICE_SIZE;
+    MEM_CHECK(p_dxva->slice_short = mpp_calloc(DXVA_Slice_H264_Short, p_dxva->max_slice_size));
+    MEM_CHECK(p_dxva->slice_long  = mpp_calloc(DXVA_Slice_H264_Long,  p_dxva->max_slice_size));
+    p_dxva->max_strm_size = FRAME_BUF_MAX_SIZE;
+    MEM_CHECK(p_dxva->bitstream = mpp_malloc(RK_U8, p_dxva->max_strm_size));
+    MEM_CHECK(p_dxva->syn.buf   = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE));
 
-	FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
+    FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
-	return MPP_OK;
+    return MPP_OK;
 
 __FAILED:
-	return MPP_NOK;
+    return MPP_NOK;
 }
 
 static MPP_RET free_dec_ctx(H264_DecCtx_t *p_Dec)
 {
-	RK_U32 i = 0;
-	INP_CHECK(!p_Dec);
+    RK_U32 i = 0;
+    INP_CHECK(!p_Dec);
     FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
-	for (i = 0; i < MAX_TASK_SIZE; i++)
-	{
-		free_dxva_ctx(&p_Dec->dxva_ctx[i]);
-	}
-	mpp_free(p_Dec->mem);
+    for (i = 0; i < MAX_TASK_SIZE; i++) {
+        free_dxva_ctx(&p_Dec->dxva_ctx[i]);
+    }
+    mpp_free(p_Dec->mem);
 
     FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
     return MPP_OK;
 }
 static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
-{	
-	RK_U32 i = 0;
-	INP_CHECK(p_Dec);
+{
+    RK_U32 i = 0;
+    INP_CHECK(!p_Dec);
     FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
 
-	MEM_CHECK(p_Dec->mem = mpp_calloc(H264_DecMem_t, 1));
+    MEM_CHECK(p_Dec->mem = mpp_calloc(H264_DecMem_t, 1));
 
-	p_Dec->dpb_mark       = p_Dec->mem->dpb_mark;         //!< for write out, MAX_DPB_SIZE
-	p_Dec->dpb_info       = p_Dec->mem->dpb_info;         //!< 16
-	p_Dec->refpic_info_p  = p_Dec->mem->refpic_info_p;    //!< 32
-	p_Dec->refpic_info[0] = p_Dec->mem->refpic_info[0];   //!< [2][32]
-	p_Dec->refpic_info[1] = p_Dec->mem->refpic_info[1];   //!< [2][32]
-	p_Dec->dxva_ctx       = p_Dec->mem->dxva_ctx;         //!< MAX_TASK_SIZE
+    p_Dec->dpb_mark       = p_Dec->mem->dpb_mark;         //!< for write out, MAX_DPB_SIZE
+    p_Dec->dpb_info       = p_Dec->mem->dpb_info;         //!< 16
+    p_Dec->refpic_info_p  = p_Dec->mem->refpic_info_p;    //!< 32
+    p_Dec->refpic_info[0] = p_Dec->mem->refpic_info[0];   //!< [2][32]
+    p_Dec->refpic_info[1] = p_Dec->mem->refpic_info[1];   //!< [2][32]
+    p_Dec->dxva_ctx       = p_Dec->mem->dxva_ctx;         //!< MAX_TASK_SIZE
 
-	for (i = 0; i < MAX_TASK_SIZE; i++)
-	{
-		p_Dec->dxva_ctx[i].p_Dec = p_Dec;
-		FUN_CHECK(init_dxva_ctx(&p_Dec->dxva_ctx[i]));
-	}	
-	//!< init Dpb_memory Mark
-	for (i = 0; i < MAX_DPB_SIZE; i++)
-	{
-		p_Dec->dpb_mark[i].index = i;
-	}
-	//!< set Dec support decoder method
-	p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME | MPP_DEC_BY_SLICE;
-	p_Dec->next_state = SliceSTATE_ResetSlice;
-	p_Dec->nalu_ret = NALU_NULL;
-	p_Dec->first_frame_flag = 1;
+    for (i = 0; i < MAX_TASK_SIZE; i++) {
+        p_Dec->dxva_ctx[i].p_Dec = p_Dec;
+        FUN_CHECK(init_dxva_ctx(&p_Dec->dxva_ctx[i]));
+    }
+    //!< init Dpb_memory Mark
+    for (i = 0; i < MAX_DPB_SIZE; i++) {
+        p_Dec->dpb_mark[i].index = i;
+    }
+    //!< set Dec support decoder method
+    p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME | MPP_DEC_BY_SLICE;
+    p_Dec->next_state = SliceSTATE_ResetSlice;
+    p_Dec->nalu_ret = NALU_NULL;
+    p_Dec->first_frame_flag = 1;
 __RETURN:
     return MPP_OK;
 
 __FAILED:
-	free_dec_ctx(p_Dec);
+    free_dec_ctx(p_Dec);
 
-	return MPP_NOK;
+    return MPP_NOK;
 }
 
 
@@ -299,7 +289,7 @@ MPP_RET h264d_deinit(void *decoder)
 {
     H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
 
-	INP_CHECK(decoder);
+    INP_CHECK(!decoder);
     FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
 
     free_input_ctx(p_Dec->p_Inp);
@@ -323,7 +313,7 @@ __RETURN:
 */
 MPP_RET  h264d_reset(void *decoder)
 {
-	INP_CHECK(decoder);
+    INP_CHECK(decoder);
 
     (void)decoder;
 __RETURN:
@@ -338,7 +328,7 @@ __RETURN:
 */
 MPP_RET  h264d_flush(void *decoder)
 {
-	INP_CHECK(decoder);
+    INP_CHECK(decoder);
 
     (void)decoder;
 __RETURN:
@@ -372,10 +362,10 @@ MPP_RET  h264d_control(void *decoder, RK_S32 cmd_type, void *param)
 */
 MPP_RET h264d_parse(void *decoder, MppPacket in_pkt, HalDecTask *in_task)
 {
-	H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
-	MppPacketImpl *pkt = (MppPacketImpl *)in_pkt;	
-	INP_CHECK(!decoder && !in_pkt && !in_task);
-	FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
+    H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
+    MppPacketImpl *pkt = (MppPacketImpl *)in_pkt;
+    INP_CHECK(!decoder && !in_pkt && !in_task);
+    FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
 
 
 
@@ -383,17 +373,17 @@ MPP_RET h264d_parse(void *decoder, MppPacket in_pkt, HalDecTask *in_task)
 
 
 
-	pkt->size = (pkt->size >= 500) ? (pkt->size - 500) : 0;
+    pkt->size = (pkt->size >= 500) ? (pkt->size - 500) : 0;
 
-	in_task->valid = pkt->size ? 0 : 1;
+    in_task->valid = pkt->size ? 0 : 1;
 
 
 
 
 
-	FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
+    FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
 __RETURN:
-	return MPP_OK;
+    return MPP_OK;
 }
 
 /*!
diff --git a/mpp/codec/dec/h264/h264d_bitread.c b/mpp/codec/dec/h264/h264d_bitread.c
index 9032f437..b4bf2d13 100644
--- a/mpp/codec/dec/h264/h264d_bitread.c
+++ b/mpp/codec/dec/h264/h264d_bitread.c
@@ -16,6 +16,7 @@
 */
 #include <string.h>
 #include <stdlib.h>
+#include "mpp_err.h"
 #include "h264d_bitread.h"
 
 
@@ -70,9 +71,7 @@ MPP_RET read_bits(BitReadCtx_t *bitctx, RK_S32 num_bits, RK_S32 *out)
         *out |= (bitctx->curr_byte_ << (bits_left - bitctx->num_remaining_bits_in_curr_byte_));
         bits_left -= bitctx->num_remaining_bits_in_curr_byte_;
 
-        if (ret = update_currbyte(bitctx)) {
-            return MPP_NOK;
-        }
+        FUN_CHECK(ret = update_currbyte(bitctx));
     }
 
     *out |= (bitctx->curr_byte_ >> (bitctx->num_remaining_bits_in_curr_byte_ - bits_left));
@@ -81,6 +80,8 @@ MPP_RET read_bits(BitReadCtx_t *bitctx, RK_S32 num_bits, RK_S32 *out)
     bitctx->used_bits += num_bits;
 
     return MPP_OK;
+__FAILED:
+    return ret;
 }
 /*!
 ***********************************************************************
@@ -106,26 +107,22 @@ MPP_RET read_ue(BitReadCtx_t *bitctx, RK_U32 *val)
     RK_S32 rest;
     // Count the number of contiguous zero bits.
     do {
-        if (read_bits(bitctx, 1, &bit)) {
-            return ret = MPP_NOK;
-        }
+        FUN_CHECK(ret = read_bits(bitctx, 1, &bit));
         num_bits++;
     } while (bit == 0);
 
-    if (num_bits > 31) {
-        return ret = MPP_NOK;
-    }
+    VAL_CHECK(num_bits < 32);
     // Calculate exp-Golomb code value of size num_bits.
     *val = (1 << num_bits) - 1;
 
     if (num_bits > 0) {
-        if (read_bits(bitctx, num_bits, &rest)) {
-            return ret = MPP_NOK;
-        }
+        FUN_CHECK(ret = read_bits(bitctx, num_bits, &rest));
         *val += rest;
     }
 
-    return ret = MPP_OK;
+    return MPP_OK;
+__FAILED:
+    return ret;
 }
 /*!
 ***********************************************************************
@@ -137,9 +134,8 @@ MPP_RET read_se(BitReadCtx_t *bitctx, RK_S32 *val)
 {
     MPP_RET ret = MPP_NOK;
     RK_U32 ue;
-    if (ret = read_ue(bitctx, &ue)) {
-        return ret = MPP_NOK;
-    }
+    FUN_CHECK(ret = read_ue(bitctx, &ue));
+
     if (ue % 2 == 0) { // odd
         *val = -(RK_S32)(ue >> 1);
     } else {
@@ -147,6 +143,8 @@ MPP_RET read_se(BitReadCtx_t *bitctx, RK_S32 *val)
     }
 
     return MPP_OK;
+__FAILED:
+    return ret;
 }
 
 /*!
diff --git a/mpp/codec/dec/h264/h264d_global.h b/mpp/codec/dec/h264/h264d_global.h
index b77efe7a..63749651 100644
--- a/mpp/codec/dec/h264/h264d_global.h
+++ b/mpp/codec/dec/h264/h264d_global.h
@@ -21,6 +21,8 @@
 #include <stdio.h>
 #include "rk_type.h"
 #include "rk_mpi.h"
+
+#include "h264d_log.h"
 #include "h264d_bitread.h"
 #include "h264d_syntax.h"
 
@@ -789,21 +791,20 @@ typedef struct h264_old_slice_par_t {
 #define FRAME_BUF_MAX_SIZE         64//512*1024
 #define FRAME_BUF_ADD_SIZE         32//512
 #define SYNTAX_BUF_SIZE            5
-typedef struct h264d_dxva_ctx_t
-{
-	RK_U8                            cfgBitstrmRaw;
-	struct _DXVA_PicParams_H264_MVC  pp;
-	struct _DXVA_Qmatrix_H264        qm;
-	RK_U32                           max_slice_size;
-	RK_U32                           slice_count;
-	struct _DXVA_Slice_H264_Short    *slice_short;  //!<  MAX_SLICES
-	struct _DXVA_Slice_H264_Long     *slice_long;   //!<  MAX_SLICES
-	RK_U8                            *bitstream;
-	RK_U32                           max_strm_size;
-	RK_U32                           strm_offset;
-	struct h264d_syntax_t            syn;
-	struct h264_dec_ctx_t            *p_Dec;
-}H264dDxvaCtx_t;
+typedef struct h264d_dxva_ctx_t {
+    RK_U8                            cfgBitstrmRaw;
+    struct _DXVA_PicParams_H264_MVC  pp;
+    struct _DXVA_Qmatrix_H264        qm;
+    RK_U32                           max_slice_size;
+    RK_U32                           slice_count;
+    struct _DXVA_Slice_H264_Short    *slice_short;  //!<  MAX_SLICES
+    struct _DXVA_Slice_H264_Long     *slice_long;   //!<  MAX_SLICES
+    RK_U8                            *bitstream;
+    RK_U32                           max_strm_size;
+    RK_U32                           strm_offset;
+    struct h264d_syntax_t            syn;
+    struct h264_dec_ctx_t            *p_Dec;
+} H264dDxvaCtx_t;
 
 
 //!< input parameter
@@ -911,24 +912,23 @@ typedef struct h264d_video_ctx_t {
 
 } H264dVideoCtx_t;
 
-typedef struct h264d_mem_t
-{
-	struct h264_dpb_mark_t     dpb_mark[MAX_DPB_SIZE];         //!< for write out, MAX_DPB_SIZE
-	struct h264_dpb_info_t     dpb_info[DPB_INFO_SIZE];         //!< 16
-	struct h264_refpic_info_t  refpic_info_p[REFPIC_INFO_SIZE];    //!< 32
-	struct h264_refpic_info_t  refpic_info[2][REFPIC_INFO_SIZE];   //!< [2][32]
-	struct h264d_dxva_ctx_t    dxva_ctx[MAX_TASK_SIZE];	
-}H264_DecMem_t;
+typedef struct h264d_mem_t {
+    struct h264_dpb_mark_t     dpb_mark[MAX_DPB_SIZE];         //!< for write out, MAX_DPB_SIZE
+    struct h264_dpb_info_t     dpb_info[DPB_INFO_SIZE];         //!< 16
+    struct h264_refpic_info_t  refpic_info_p[REFPIC_INFO_SIZE];    //!< 32
+    struct h264_refpic_info_t  refpic_info[2][REFPIC_INFO_SIZE];   //!< [2][32]
+    struct h264d_dxva_ctx_t    dxva_ctx[MAX_TASK_SIZE];
+} H264_DecMem_t;
 
 //!< decoder video parameter
 typedef struct h264_dec_ctx_t {
-	struct h264d_mem_t        *mem;
-	struct h264_dpb_mark_t    *dpb_mark;         //!< for write out, MAX_DPB_SIZE
-	struct h264_dpb_info_t    *dpb_info;         //!< 16
-	struct h264_refpic_info_t *refpic_info_p;    //!< 32
-	struct h264_refpic_info_t *refpic_info[2];   //!< [2][32]
-	struct h264d_dxva_ctx_t   *dxva_ctx;
-  
+    struct h264d_mem_t        *mem;
+    struct h264_dpb_mark_t    *dpb_mark;         //!< for write out, MAX_DPB_SIZE
+    struct h264_dpb_info_t    *dpb_info;         //!< 16
+    struct h264_refpic_info_t *refpic_info_p;    //!< 32
+    struct h264_refpic_info_t *refpic_info[2];   //!< [2][32]
+    struct h264d_dxva_ctx_t   *dxva_ctx;
+
     struct h264d_input_ctx_t  *p_Inp;
     struct h264d_cur_ctx_t    *p_Cur;            //!< current parameters, use in read nalu
     struct h264d_video_ctx_t  *p_Vid;            //!< parameters for video decoder
diff --git a/mpp/codec/dec/h264/h264d_parse.h b/mpp/codec/dec/h264/h264d_parse.h
index c06bfd84..0ea4e3dd 100644
--- a/mpp/codec/dec/h264/h264d_parse.h
+++ b/mpp/codec/dec/h264/h264d_parse.h
@@ -1,90 +1,88 @@
-/*
-*
-* Copyright 2015 Rockchip Electronics Co. LTD
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-#ifndef __H264D_PARSE_H__
-#define __H264D_PARSE_H__
-#include "rk_type.h"
-#include "mpp_err.h"
-
-
-typedef enum
-{
-	NALU_NULL = 0,
+/*
+*
+* Copyright 2015 Rockchip Electronics Co. LTD
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 
-	//StreamError,
-	//HaveNoStream,
-	//NaluNotSupport,
-	//ReadNaluError,
-	//NALU_ERROR,
-	//NALU_OK,
-	//StartofNalu,
-	//EndofStream,
-	//ReallocBufError,
-	//MidOfNalu,
-	//EndOfNalu,
-	//StartOfPicture,
-	//StartOfSlice,
-	//SkipNALU,
-	//NALU_SPS,
-	//NALU_SubSPS,
-	//NALU_PPS,
-	//NALU_SEI,
-
-	NALU_MAX,
-}NALU_STATUS;
+#ifndef __H264D_PARSE_H__
+#define __H264D_PARSE_H__
+#include "rk_type.h"
+#include "mpp_err.h"
 
 
-typedef enum Rkv_slice_state_t
-{
-	SliceSTATE_NULL = 0,
-	SliceSTATE_IDLE,
+typedef enum {
+    NALU_NULL = 0,
 
-	//SliceSTATE_GetLastSlice,
-	SliceSTATE_ResetSlice,
-	//SliceSTATE_ReadNalu,
-	//SliceSTATE_ParseNalu,
-	//SliceSTATE_DecodeOneSlice,
-	//SliceSTATE_InitPicture,
-	//SliceSTATE_GetOuterDpbMemory,
-	////SliceSTATE_InitSlice,
-	//SliceSTATE_GetSliceData,
-	//SliceSTATE_RegisterOneSlice,
-	//SliceSTATE_RegisterOneFrame,
-	//SliceSTATE_ExitPicture,
-	//SliceSTATE_ErrorMaster,
+    //StreamError,
+    //HaveNoStream,
+    //NaluNotSupport,
+    //ReadNaluError,
+    //NALU_ERROR,
+    //NALU_OK,
+    //StartofNalu,
+    //EndofStream,
+    //ReallocBufError,
+    //MidOfNalu,
+    //EndOfNalu,
+    //StartOfPicture,
+    //StartOfSlice,
+    //SkipNALU,
+    //NALU_SPS,
+    //NALU_SubSPS,
+    //NALU_PPS,
+    //NALU_SEI,
 
-	//SliceSTATE_Return,
-	SliceSTATE_MAX,
+    NALU_MAX,
+} NALU_STATUS;
 
-}RKV_SLICE_STATUS;
-
-
-
-
-
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-
-#ifdef  __cplusplus
-}
-#endif
-
-
-#endif /* __H264D_PARSE_H__ */
+
+typedef enum Rkv_slice_state_t {
+    SliceSTATE_NULL = 0,
+    SliceSTATE_IDLE,
+
+    //SliceSTATE_GetLastSlice,
+    SliceSTATE_ResetSlice,
+    //SliceSTATE_ReadNalu,
+    //SliceSTATE_ParseNalu,
+    //SliceSTATE_DecodeOneSlice,
+    //SliceSTATE_InitPicture,
+    //SliceSTATE_GetOuterDpbMemory,
+    ////SliceSTATE_InitSlice,
+    //SliceSTATE_GetSliceData,
+    //SliceSTATE_RegisterOneSlice,
+    //SliceSTATE_RegisterOneFrame,
+    //SliceSTATE_ExitPicture,
+    //SliceSTATE_ErrorMaster,
+
+    //SliceSTATE_Return,
+    SliceSTATE_MAX,
+
+} RKV_SLICE_STATUS;
+
+
+
+
+
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef  __cplusplus
+}
+#endif
+
+
+#endif /* __H264D_PARSE_H__ */
diff --git a/mpp/hal/rkdec/h264d/CMakeLists.txt b/mpp/hal/rkdec/h264d/CMakeLists.txt
index 17dbff48..140d8b0a 100644
--- a/mpp/hal/rkdec/h264d/CMakeLists.txt
+++ b/mpp/hal/rkdec/h264d/CMakeLists.txt
@@ -23,5 +23,8 @@ add_library(hal_h264d STATIC
             ${HAL_H264D_HDR} 
             ${HAL_H264D_SRC} 
             )
-                    
+target_link_libraries(hal_h264d
+                      mpp
+                      )                
 set_target_properties(hal_h264d PROPERTIES FOLDER "mpp/hal")        
+