/* Any workload management goes in this file */

#include "viddec_fw_debug.h"
#include "viddec_parser_ops.h"
#include "h264.h"
#include "h264parse.h"
#include "viddec_fw_item_types.h"
#include "h264parse_dpb.h"


#include "viddec_fw_workload.h"
#include <auto_eas/gen4_mfd.h>
#include "viddec_pm_utils_bstream.h"

// picture parameter 1
#define PUT_BSD_PP1_IMG_DISPOSABLE_FLAG_BIT(w)            (((uint32_t)w)&0x1)
#define PUT_BSD_PP1_SLICE_TYPE_BITS(w)                    ((((uint32_t)w)&0x7)<<1)
#define PUT_BSD_PP1_WEIGHTED_BIPRED_IDC_BITS(w)           ((((uint32_t)w)&0x3)<<4)
#define PUT_BSD_PP1_WEIGHTED_PRED_FLAG_BIT(w)             ((((uint32_t)w)&0x1)<<6)
#define PUT_BSD_PP1_NUM_REF_IDX_L0_BITS(w)                ((((uint32_t)w)&0x3F)<<8)
#define PUT_BSD_PP1_NUM_REF_IDX_L1_BITS(w)                ((((uint32_t)w)&0x3F)<<16)

// picture parameter 2
#define PUT_BSD_PP2_CABAC_INIT_IDC_BITS(w)                (((uint32_t)w)&0x3)
#define PUT_BSD_PP2_QP_BITS(w)                            ((((uint32_t)w)&0x3F)<<2)
#define PUT_BSD_PP2_DISABLE_DBF_IDC_BITS(w)               ((((uint32_t)w)&0x3)<<8)
#define PUT_BSD_PP2_ALPHA_C0_OFFSET_DIV2_BITS(w)          ((((uint32_t)w)&0xF)<<10)
#define PUT_BSD_PP2_BETA_OFFSET_DIV2_BITS(w)              ((((uint32_t)w)&0xF)<<14)
#define PUT_BSD_PP2_IMG_DIRECT_TYPE_BIT(w)                ((((uint32_t)w)&0x1)<<18)
#define PUT_BSD_PP2_CHROMA_QP_OFFSET_BITS(w)              ((((uint32_t)w)&0x1F)<<19)
#define PUT_BSD_PP2_CHROMA_QP_OFFSET_2_BITS(w)            ((((uint32_t)w)&0x1F)<<24)


// slice start parameter
#define PUT_BSD_SS_START_ADDR_BITS(w)                      (((uint32_t)w)&0x7fff)         // 14:0  current slice start address
#define PUT_BSD_SS_SKIP_FS_IDC_BITS(w)                    ((((uint32_t)w)&0x3f)<<16)      // [5:0], [4:0] frame store idc, [5] - 0: top-filed, 1: bottom field
#define PUT_BSD_SS_SKIP_TYPE_BIT(w)                       ((((uint32_t)w)&0x1)<<24)       // 0: P-skip, 1: I-skip
#define PUT_BSD_SS_SKIP_REWIND_BITS(w)                    ((((uint32_t)w)&0xf)<<28)       // number of MB or MBAFF pairs to rewind before skip

//h264_dpb_init
#define PUT_FRAME_WIDTH_MB_BITS(w)                        (((uint32_t)w)&0x7F)
#define PUT_FRAME_HEIGHT_MB_BITS(w)                       ((((uint32_t)w)&0x7F)<<16)

//dpb lut table init
//#define PUT_BSD_IMAGE_FRAME_STORE_IDC_BITS(w)             ((((uint32_t)w)&0x1F)<<8)

//h264 img init
#define PUT_BSD_IMAGE_STRUCTURE_BITS(w)                   (((uint32_t)w)&0x3)
#define PUT_BSD_IMAGE_IDR_BIT(w)                          ((((uint32_t)w)&0x1)<<2)
#define PUT_BSD_IMAGE_MBAFF_FRAME_FLAG_BIT(w)             ((((uint32_t)w)&0x1)<<3)
#define PUT_BSD_IMAGE_ENTROPY_CODING_MODE_FLAG_BIT(w)     ((((uint32_t)w)&0x1)<<4)
#define PUT_BSD_IMAGE_CONSTRAINED_INTRA_PRED_FLAG_BIT(w)  ((((uint32_t)w)&0x1)<<5)
#define PUT_BSD_IMG_FRAME_MBS_ONLY_FLAG_BIT(w)            ((((uint32_t)w)&0x1)<<6)
#define PUT_BSD_IMG_DIRECT_8X8_INFER_FLAG_BIT(w)          ((((uint32_t)w)&0x1)<<7)
#define PUT_BSD_IMAGE_FRAME_STORE_IDC_BITS(w)             ((((uint32_t)w)&0x1F)<<8)

#define PUT_HPD_BSD_IMG_TRANSFORM_8X8_MODE_FLAG_BIT(w)    ((((uint32_t)w)&0x1)<<13)
#define PUT_HPD_BSD_IMG_MONOCHROME_FLAG_BIT(w)            ((((uint32_t)w)&0x1)<<14)
#define PUT_HPD_BSD_IMG_GREY_NONEXISTING_FLAG_BIT(w)      ((((uint32_t)w)&0x1)<<15)
#define PUT_HPD_BSD_IMG_QM_PRESENT_FLAG_BIT(w)            ((((uint32_t)w)&0x1)<<16)
#define PUT_HPD_BSD_IMG_QM_LIST_FLAGS_BITS(w)             ((((uint32_t)w)&0xFF)<<17)
#define PUT_HPD_BSD_IMG_MONOCHROME_PWT_FLAG_BIT(w)        ((((uint32_t)w)&0x1)<<25)


extern void h264_dpb_store_previous_picture_in_dpb(h264_Info * pInfo,
        int32_t NonExisting,
        int32_t use_old);

extern void h264_dpb_flush_dpb (h264_Info * pInfo,int32_t output_all, int32_t keep_complement, int32_t num_ref_frames);


void h264_translate_parser_info_to_frame_attributes(viddec_workload_t *wl, h264_Info *pInfo)
{

    viddec_frame_attributes_t *attrs = &wl->attrs;


    //// Cont_size
    attrs->cont_size.height       = pInfo->img.FrameHeightInMbs*16;
    attrs->cont_size.width        = pInfo->img.PicWidthInMbs*16;

    //// The following attributes will be updated in slice level
    attrs->h264.used_for_reference = 0;
    attrs->h264.top_field_first = 0;
    attrs->h264.top_field_poc = 0;
    attrs->h264.bottom_field_poc = 0;
    attrs->h264.field_pic_flag = 0;

#if 1
/// Double check the size late!!!!!
    //attrs->h264.cropped_size.width = pInfo->img.PicWidthInMbs*16;
    //attrs->h264.cropped_size.height = pInfo->img.PicWidthInMbs*16;

    if ( (pInfo->active_SPS.sps_disp.frame_cropping_flag) &&
            (pInfo->active_SPS.sps_disp.chroma_format_idc < 4))
    {
        int32_t CropUnitX, CropUnitY;
        int32_t SubWidthC, SubHeightC;

        if (pInfo->active_SPS.sps_disp.chroma_format_idc == 0)
        {
            CropUnitX = 1;
            CropUnitY = 2 - pInfo->active_SPS.sps_disp.frame_mbs_only_flag;
        }
        else
        {
            SubWidthC = 2 - ((pInfo->active_SPS.sps_disp.chroma_format_idc - 1) >> 1);
            SubHeightC = 2 - ((pInfo->active_SPS.sps_disp.chroma_format_idc - 1) >>1)
                         - ((pInfo->active_SPS.sps_disp.chroma_format_idc - 1) & 0x1);
            CropUnitX = SubWidthC;
            CropUnitY = SubHeightC * (2 - pInfo->active_SPS.sps_disp.frame_mbs_only_flag);
        }

        if ((int32_t)attrs->cont_size.height >(pInfo->active_SPS.sps_disp.frame_crop_rect_bottom_offset*CropUnitY))
        {
            attrs->cont_size.height -= (pInfo->active_SPS.sps_disp.frame_crop_rect_bottom_offset*CropUnitY);
            //attrs->h264.cropped_size.height-= (pInfo->active_SPS.sps_disp.frame_crop_rect_bottom_offset*CropUnitY);
        }
    }
/// Pan-Scan Info

#endif

}


static void h264_parse_update_frame_attributes(void *parent, h264_Info *pInfo)
{
    viddec_workload_t        *wl_cur,  *wl_next;
    viddec_frame_attributes_t *attrs;
    uint8_t    frame_type=0;


    if (pInfo->push_to_cur) //cur is empty, fill new frame in cur
    {
        wl_cur = viddec_pm_get_header( parent );
        attrs = &wl_cur->attrs;
    }
    else
    {
        wl_next = viddec_pm_get_next_header (parent);
        attrs = &wl_next->attrs;
    }

    /////////update frame type
    if ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type)&(0x1 << FRAME_TYPE_STRUCTRUE_OFFSET))
    {
        frame_type = ( (pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type)&((0x7 << FRAME_TYPE_FRAME_OFFSET)) )>> FRAME_TYPE_FRAME_OFFSET;
        switch (frame_type)
        {
        case FRAME_TYPE_IDR:
            attrs->frame_type = VIDDEC_FRAME_TYPE_IDR;
            break;
        case FRAME_TYPE_I:
            attrs->frame_type = VIDDEC_FRAME_TYPE_I;
            break;
        case FRAME_TYPE_P:
            attrs->frame_type = VIDDEC_FRAME_TYPE_P;
            break;
        case FRAME_TYPE_B:
            attrs->frame_type = VIDDEC_FRAME_TYPE_B;
            break;
        default:
            attrs->frame_type = VIDDEC_FRAME_TYPE_INVALID;
            break;
        }

        attrs->bottom_field_type = VIDDEC_FRAME_TYPE_INVALID;
    }
    else
    {
        frame_type = ( (pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type)&((0x7 << FRAME_TYPE_TOP_OFFSET)) )>> FRAME_TYPE_TOP_OFFSET;
        switch (frame_type)
        {
        case FRAME_TYPE_IDR:
            attrs->frame_type = VIDDEC_FRAME_TYPE_IDR;
            break;
        case FRAME_TYPE_I:
            attrs->frame_type = VIDDEC_FRAME_TYPE_I;
            break;
        case FRAME_TYPE_P:
            attrs->frame_type = VIDDEC_FRAME_TYPE_P;
            break;
        case FRAME_TYPE_B:
            attrs->frame_type = VIDDEC_FRAME_TYPE_B;
            break;
        default:
            attrs->frame_type = VIDDEC_FRAME_TYPE_INVALID;
            break;

        }

        frame_type = ( (pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type)&((0x7 << FRAME_TYPE_BOTTOM_OFFSET)) )>> FRAME_TYPE_BOTTOM_OFFSET;
        switch (frame_type)
        {
        case FRAME_TYPE_IDR:
            attrs->bottom_field_type = VIDDEC_FRAME_TYPE_IDR;
            break;
        case FRAME_TYPE_I:
            attrs->bottom_field_type = VIDDEC_FRAME_TYPE_I;
            break;
        case FRAME_TYPE_P:
            attrs->bottom_field_type = VIDDEC_FRAME_TYPE_P;
            break;
        case FRAME_TYPE_B:
            attrs->bottom_field_type = VIDDEC_FRAME_TYPE_B;
            break;
        default:
            attrs->bottom_field_type = VIDDEC_FRAME_TYPE_INVALID;
            break;

        }
    }

    /////////update is_referece flag
    attrs->h264.used_for_reference |= (pInfo->SliceHeader.nal_ref_idc == 0)? 0: 1;

    /////////update POC
    attrs->h264.top_field_poc = pInfo->img.toppoc;
    attrs->h264.bottom_field_poc = pInfo->img.bottompoc;

    //////// update TFF
    if (attrs->h264.top_field_poc <= attrs->h264.bottom_field_poc) {
        attrs->h264.top_field_first = 1;
    } else {
        attrs->h264.top_field_first = 0;
    }

    /////// update field_pic_flag
    //attrs->h264.field_pic_flag |= (pInfo->SliceHeader.field_pic_flag << pInfo->SliceHeader.bottom_field_flag);
    attrs->h264.field_pic_flag |= pInfo->SliceHeader.field_pic_flag;

    return;
}


static void h264_fill_slice_data(h264_Info *pInfo, h264_slice_data * p_slice_data)
{
    uint32_t data=0;
    uint32_t first_mb_in_slice =0;


    ////////////fill pic parameters 1
    data =   PUT_BSD_PP1_IMG_DISPOSABLE_FLAG_BIT( (pInfo->SliceHeader.nal_ref_idc == 0) ) +
             PUT_BSD_PP1_SLICE_TYPE_BITS(pInfo->SliceHeader.slice_type) +
             PUT_BSD_PP1_WEIGHTED_BIPRED_IDC_BITS(pInfo->active_PPS.weighted_bipred_idc) +
             PUT_BSD_PP1_WEIGHTED_PRED_FLAG_BIT(pInfo->active_PPS.weighted_pred_flag)  +
             PUT_BSD_PP1_NUM_REF_IDX_L0_BITS(pInfo->SliceHeader.num_ref_idx_l0_active)  +
             PUT_BSD_PP1_NUM_REF_IDX_L1_BITS(pInfo->SliceHeader.num_ref_idx_l1_active);
    p_slice_data->h264_bsd_slice_p1 = data;


    ///////////fill pic parameters 2
    data =   PUT_BSD_PP2_CABAC_INIT_IDC_BITS(pInfo->SliceHeader.cabac_init_idc) +
             PUT_BSD_PP2_QP_BITS( (pInfo->SliceHeader.slice_qp_delta + pInfo->active_PPS.pic_init_qp_minus26+26) ) +
             PUT_BSD_PP2_DISABLE_DBF_IDC_BITS(pInfo->SliceHeader.disable_deblocking_filter_idc) +
             PUT_BSD_PP2_ALPHA_C0_OFFSET_DIV2_BITS(pInfo->SliceHeader.slice_alpha_c0_offset_div2) +
             PUT_BSD_PP2_BETA_OFFSET_DIV2_BITS(pInfo->SliceHeader.slice_beta_offset_div2) +
             PUT_BSD_PP2_IMG_DIRECT_TYPE_BIT(pInfo->SliceHeader.direct_spatial_mv_pred_flag) +
             PUT_BSD_PP2_CHROMA_QP_OFFSET_BITS(pInfo->active_PPS.chroma_qp_index_offset) +
             PUT_BSD_PP2_CHROMA_QP_OFFSET_2_BITS(pInfo->active_PPS.second_chroma_qp_index_offset);

    p_slice_data->h264_bsd_slice_p2 = data;

    /////////fill slice start
    first_mb_in_slice = pInfo->SliceHeader.first_mb_in_slice;

    data =   PUT_BSD_SS_START_ADDR_BITS(first_mb_in_slice);
    data |=  PUT_BSD_SS_SKIP_FS_IDC_BITS( pInfo->h264_list_replacement) |
             PUT_BSD_SS_SKIP_TYPE_BIT(0) |
             PUT_BSD_SS_SKIP_REWIND_BITS((pInfo->img.MbaffFrameFlag? 2: 3));

    p_slice_data->h264_bsd_slice_start = data;

}


static void h264_parse_emit_4X4_scaling_matrix( void *parent, h264_Info *pInfo )
{

    viddec_workload_item_t     wi;

    uint32_t                   i=0, n_items=0;
    uint32_t                   qm_type=0;


    for ( i = 0; i < 6; i++ )
    {
        qm_type = FB_QM;
        if (pInfo->active_SPS.seq_scaling_matrix_present_flag) // check sps first
        {
            if (pInfo->active_SPS.seq_scaling_list_present_flag[i])
            {
                pInfo->qm_present_list |= ((0x1)<<i);

                if (pInfo->active_SPS.UseDefaultScalingMatrix4x4Flag[i]) {
                    qm_type = DEFAULT_QM;
                } else {
                    qm_type = SPS_QM;
                }
            }
        }

        if (pInfo->active_PPS.pic_scaling_matrix_present_flag) // then check pps
        {
            if (pInfo->active_PPS.pic_scaling_list_present_flag[i])
            {
                pInfo->qm_present_list |= ((0x1)<<i);
                if (pInfo->active_PPS.UseDefaultScalingMatrix4x4Flag[i]) {
                    qm_type = DEFAULT_QM;
                } else {
                    qm_type = PPS_QM;
                }
            }
            else
            {
                if ((i != 0) && (i != 3) && (i < 6)) {
                    pInfo->qm_present_list  &= ~((0x1)<<i);
                    qm_type = FB_QM;
                }
            }
        }


        ///////////////////// Emit out Scaling_matrix//////////////////////
        wi.vwi_type = VIDDEC_WORKLOAD_H264_SCALING_MATRIX;
        //    data_offset    0x aa  bb  cc  dd
        //    bb    is the workload item offset
        //    cc    is the qm_type
        //    dd    is the matrix number
        //
        switch (qm_type)
        {
        case (SPS_QM): {

            for (n_items =0; n_items<2; n_items++)
            {
                wi.data.data_offset = i + (SPS_QM << 4) + (n_items <<8);
                wi.data.data_payload[0] = ((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+0]))+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+1]))<<8)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+2]))<<16)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+3]))<<24);
                wi.data.data_payload[1] = ((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+4]))+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+5]))<<8)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+6]))<<16)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList4x4[i][n_items*8+7]))<<24);
                //cur is empty, fill new frame in cur
                viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            }

            break;
        }
        case (PPS_QM): {

            for (n_items =0; n_items<2; n_items++)
            {
                wi.data.data_offset = i + (PPS_QM << 4) + (n_items <<8);
                wi.data.data_payload[0] = ((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+0]))+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+1]))<<8)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+2]))<<16)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+3]))<<24);
                wi.data.data_payload[1] = ((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+4]))+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+5]))<<8)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+6]))<<16)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList4x4[i][n_items*8+7]))<<24);
                //cur is empty, fill new frame in cur
                viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            }

            break;
        }
        case (DEFAULT_QM):
        {

            wi.data.data_offset = i + (DEFAULT_QM << 4);
            wi.data.data_payload[0] = 0;
            wi.data.data_payload[1] = 0;
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            break;
        }
        default:
        {
            break;
        }
        }
    }

}

static void h264_parse_emit_8X8_scaling_matrix( void *parent, h264_Info *pInfo )
{

    viddec_workload_item_t     wi;

    uint32_t                   i=0, n_items=0;
    uint32_t                   qm_type=0;

    for ( i = 6; i < 8; i++ )
    {
        qm_type = FB_QM;
        if (pInfo->active_SPS.seq_scaling_matrix_present_flag) // check sps first
        {
            if (pInfo->active_SPS.seq_scaling_list_present_flag[i])
            {
                pInfo->qm_present_list |= ((0x1)<<i);

                if (pInfo->active_SPS.UseDefaultScalingMatrix8x8Flag[i-6])
                {
                    qm_type = DEFAULT_QM;
                }
                else
                {
                    qm_type = SPS_QM;
                }
            }
        }

        if (pInfo->active_PPS.pic_scaling_matrix_present_flag) // then check pps
        {
            if (pInfo->active_PPS.pic_scaling_list_present_flag[i])
            {
                pInfo->qm_present_list |= ((0x1)<<i);

                if (pInfo->active_PPS.UseDefaultScalingMatrix8x8Flag[i-6])
                {
                    qm_type = DEFAULT_QM;
                }
                else
                {
                    qm_type = PPS_QM;
                }
            }
        }
        wi.vwi_type = VIDDEC_WORKLOAD_H264_SCALING_MATRIX;

        //    data_offset    0x aa  bb  cc  dd
        //    bb    is the workload item offset
        //    cc    is the qm_type
        //    dd    is the matrix number
        //
        switch (qm_type)
        {
        case (SPS_QM):
        {
            for (n_items =0; n_items<8; n_items++)
            {
                wi.data.data_offset = i + (SPS_QM << 4) + (n_items <<8);
                wi.data.data_payload[0] = ((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+0]))+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+1]))<<8)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+2]))<<16)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+3]))<<24);
                wi.data.data_payload[1] = ((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+4]))+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+5]))<<8)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+6]))<<16)+
                                          (((uint32_t)(pInfo->active_SPS.ScalingList8x8[i-6][n_items*8+7]))<<24);
                //cur is empty, fill new frame in cur
                viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            }
            break;
        }
        case (PPS_QM):
        {
            for (n_items =0; n_items<8; n_items++)
            {
                wi.data.data_offset = i + (PPS_QM << 4) + (n_items <<8);
                wi.data.data_payload[0] = ((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+0]))+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+1]))<<8)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+2]))<<16)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+3]))<<24);
                wi.data.data_payload[1] = ((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+4]))+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+5]))<<8)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+6]))<<16)+
                                          (((uint32_t)(pInfo->active_PPS.ScalingList8x8[i-6][n_items*8+7]))<<24);
                //cur is empty, fill new frame in cur
                viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            }
            break;
        }
        case (DEFAULT_QM):
        {
            wi.data.data_offset = i + (DEFAULT_QM << 4);
            wi.data.data_payload[0] = 0;
            wi.data.data_payload[1] = 0;
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            break;
        }
        default: {
            break;
        }
        }
    }

}


static void h264_fill_pic_data(h264_Info *pInfo, h264_pic_data * p_pic_data)
{
    uint32_t data=0;
    uint32_t dec_idc =0;
    uint32_t frame_structure =0;

    //fill h264_dpb_init
    data =   PUT_FRAME_WIDTH_MB_BITS(pInfo->dpb.PicWidthInMbs) +
             PUT_FRAME_HEIGHT_MB_BITS(pInfo->dpb.FrameHeightInMbs);

    p_pic_data->h264_dpb_init = data;

    ////////////////////////////////file current pic info
    data = 0;
    dec_idc = pInfo->dpb.fs_dec_idc;
    frame_structure = pInfo->img.structure;
    if (frame_structure == FRAME)
        frame_structure=0;
    //data =  PUT_BSD_IMAGE_FRAME_STORE_IDC_BITS(pInfo->dpb.fs[dec_idc].fs_idc);

    //p_pic_data->h264_cur_bsd_img_init= data;

    data  =  PUT_BSD_IMAGE_STRUCTURE_BITS(frame_structure)  +
             PUT_BSD_IMAGE_IDR_BIT(pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR) +
             PUT_BSD_IMAGE_MBAFF_FRAME_FLAG_BIT(pInfo->img.MbaffFrameFlag) +
             PUT_BSD_IMAGE_ENTROPY_CODING_MODE_FLAG_BIT(pInfo->active_PPS.entropy_coding_mode_flag) +
             PUT_BSD_IMAGE_CONSTRAINED_INTRA_PRED_FLAG_BIT(pInfo->active_PPS.constrained_intra_pred_flag) +
             PUT_BSD_IMG_FRAME_MBS_ONLY_FLAG_BIT(pInfo->active_SPS.sps_disp.frame_mbs_only_flag) +
             PUT_BSD_IMG_DIRECT_8X8_INFER_FLAG_BIT(pInfo->active_SPS.sps_disp.direct_8x8_inference_flag) +
             PUT_HPD_BSD_IMG_TRANSFORM_8X8_MODE_FLAG_BIT(pInfo->active_PPS.transform_8x8_mode_flag) +
             PUT_HPD_BSD_IMG_MONOCHROME_FLAG_BIT(((pInfo->active_SPS.sps_disp.chroma_format_idc==0)? 0x1: 0x0)) +
             PUT_HPD_BSD_IMG_GREY_NONEXISTING_FLAG_BIT(0x0) +
             PUT_HPD_BSD_IMG_QM_PRESENT_FLAG_BIT((pInfo->active_PPS.pic_scaling_matrix_present_flag||pInfo->active_SPS.seq_scaling_matrix_present_flag)) +
             PUT_HPD_BSD_IMG_QM_LIST_FLAGS_BITS(pInfo->qm_present_list) +
             PUT_HPD_BSD_IMG_MONOCHROME_PWT_FLAG_BIT(0x1) +
             PUT_BSD_IMAGE_FRAME_STORE_IDC_BITS(pInfo->dpb.fs[dec_idc].fs_idc);

    p_pic_data->h264_cur_bsd_img_init= data;

    //to do: add qm list
    //PUT_HPD_BSD_IMG_QM_LIST_FLAGS_BITS(pInfo->img.q .qm_present_list) +
    //printf("structure = %d, tpoc = %d, bpoc = %d\n", pInfo->img.structure, pInfo->img.toppoc, pInfo->img.bottompoc);

    if (pInfo->img.structure == FRAME)
    {
        // Write down POC
        p_pic_data->h264_cur_mpr_tf_poc = pInfo->img.toppoc;
        p_pic_data->h264_cur_mpr_bf_poc = pInfo->img.bottompoc;
    } else if (pInfo->img.structure == TOP_FIELD)
    {
        // Write down POC
        p_pic_data->h264_cur_mpr_tf_poc = pInfo->img.toppoc;
        p_pic_data->h264_cur_mpr_bf_poc = 0;
    }
    else if (pInfo->img.structure ==  BOTTOM_FIELD)
    {
        // Write down POC
        p_pic_data->h264_cur_mpr_tf_poc = 0;
        p_pic_data->h264_cur_mpr_bf_poc = pInfo->img.bottompoc;
    }
    else
    {
        // Write down POC
        p_pic_data->h264_cur_mpr_tf_poc = 0;
        p_pic_data->h264_cur_mpr_bf_poc = 0;
    }

    return;
}

static void h264_parse_emit_sps(void *parent, h264_Info *pInfo)
{
    viddec_workload_item_t     wi;

    if (pInfo->Is_SPS_updated)
    {
        viddec_fw_reset_workload_item(&wi);
        wi.vwi_type = VIDDEC_WORKLOAD_SEQUENCE_INFO;

        viddec_fw_h264_sps_set_profile_idc(&(wi.h264_sps), pInfo->active_SPS.profile_idc);
        viddec_fw_h264_sps_set_level_idc(&(wi.h264_sps), pInfo->active_SPS.level_idc);
        viddec_fw_h264_sps_set_chroma_format_idc(&(wi.h264_sps), pInfo->active_SPS.sps_disp.chroma_format_idc);
        viddec_fw_h264_sps_set_num_ref_frames(&(wi.h264_sps), pInfo->active_SPS.num_ref_frames);
        viddec_fw_h264_sps_set_gaps_in_frame_num_value_allowed_flag(&(wi.h264_sps), pInfo->active_SPS.gaps_in_frame_num_value_allowed_flag);
        viddec_fw_h264_sps_set_frame_mbs_only_flag(&(wi.h264_sps), pInfo->active_SPS.sps_disp.frame_mbs_only_flag);
        viddec_fw_h264_sps_set_frame_cropping_flag(&(wi.h264_sps), pInfo->active_SPS.sps_disp.frame_cropping_flag);
        viddec_fw_h264_sps_set_vui_parameters_present_flag(&(wi.h264_sps), pInfo->active_SPS.sps_disp.vui_parameters_present_flag);
        wi.h264_sps.pic_width_in_mbs_minus1 = pInfo->active_SPS.sps_disp.pic_width_in_mbs_minus1;
        wi.h264_sps.pic_height_in_map_units_minus1 = pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1;

        //cur is empty, fill new frame in cur
        viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);

        viddec_fw_reset_workload_item(&wi);
        if (pInfo->active_SPS.sps_disp.frame_cropping_flag)
        {
            wi.vwi_type = VIDDEC_WORKLOAD_H264_CROPPING;
            viddec_fw_h264_cropping_set_left(&(wi.h264_cropping), pInfo->active_SPS.sps_disp.frame_crop_rect_left_offset);
            viddec_fw_h264_cropping_set_right(&(wi.h264_cropping), pInfo->active_SPS.sps_disp.frame_crop_rect_right_offset);
            viddec_fw_h264_cropping_set_top(&(wi.h264_cropping), pInfo->active_SPS.sps_disp.frame_crop_rect_top_offset);
            viddec_fw_h264_cropping_set_bottom(&(wi.h264_cropping), pInfo->active_SPS.sps_disp.frame_crop_rect_bottom_offset);
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
        }
        viddec_fw_reset_workload_item(&wi);
        if (pInfo->active_SPS.sps_disp.vui_parameters_present_flag == 1)
        {
            wi.vwi_type = VIDDEC_WORKLOAD_DISPLAY_INFO;
            viddec_fw_h264_vui_set_aspect_ratio_info_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.aspect_ratio_info_present_flag);
            viddec_fw_h264_vui_set_video_signal_type_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.video_signal_type_present_flag);
            viddec_fw_h264_vui_set_pic_struct_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.pic_struct_present_flag);
            viddec_fw_h264_vui_set_timing_info_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.timing_info_present_flag);
            viddec_fw_h264_vui_set_nal_hrd_parameters_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.nal_hrd_parameters_present_flag);
            viddec_fw_h264_vui_set_vcl_hrd_parameters_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.vcl_hrd_parameters_present_flag);

            if (pInfo->active_SPS.sps_disp.vui_seq_parameters.aspect_ratio_info_present_flag == 1)
            {
                viddec_fw_h264_vui_set_aspect_ratio_idc(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.aspect_ratio_idc);
                if (h264_AR_Extended_SAR == pInfo->active_SPS.sps_disp.vui_seq_parameters.aspect_ratio_idc)
                {
                    viddec_fw_h264_vui_set_sar_width(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.sar_width);
                    viddec_fw_h264_vui_set_sar_height(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.sar_height);
                }
            }


            if (pInfo->active_SPS.sps_disp.vui_seq_parameters.video_signal_type_present_flag)
            {
                viddec_fw_h264_vui_set_colour_description_present_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.colour_description_present_flag);
                if (pInfo->active_SPS.sps_disp.vui_seq_parameters.colour_description_present_flag)
                {
                    viddec_fw_h264_vui_set_colour_primaries(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.colour_primaries);
                    viddec_fw_h264_vui_set_transfer_characteristics(&(wi.h264_vui),  pInfo->active_SPS.sps_disp.vui_seq_parameters.transfer_characteristics);
                }
                viddec_fw_h264_vui_set_video_format(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.video_format);
            }

            if (pInfo->active_SPS.sps_disp.vui_seq_parameters.timing_info_present_flag == 1)
            {
                viddec_fw_h264_vui_set_fixed_frame_rate_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.fixed_frame_rate_flag);
            }

            if ( (pInfo->active_SPS.sps_disp.vui_seq_parameters.nal_hrd_parameters_present_flag == 1)
                    || (pInfo->active_SPS.sps_disp.vui_seq_parameters.vcl_hrd_parameters_present_flag == 1))
            {
                viddec_fw_h264_vui_set_low_delay_hrd_flag(&(wi.h264_vui), pInfo->active_SPS.sps_disp.vui_seq_parameters.low_delay_hrd_flag);
            }

            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
        }

        viddec_fw_reset_workload_item(&wi);

        if (pInfo->active_SPS.sps_disp.vui_seq_parameters.timing_info_present_flag == 1)
        {
            wi.vwi_type = VIDDEC_WORKLOAD_H264_VUI_TIMING_INFO;

            wi.h264_vui_time_info.num_units_in_tick = pInfo->active_SPS.sps_disp.vui_seq_parameters.num_units_in_tick;
            wi.h264_vui_time_info.time_scale = pInfo->active_SPS.sps_disp.vui_seq_parameters.time_scale;
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
        }
        pInfo->Is_SPS_updated =0;

    }

    return;
}


static void h264_parse_emit_ref_list( void *parent, h264_Info *pInfo, uint32_t list_id)
{
    uint32_t  i=0, nitems=0, byte_index=0, data=0, data_writed=0;
    uint8_t    *p_list;
    viddec_workload_item_t     wi;

    if (0 == list_id)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_H264_REFR_LIST_0;

        if ( (h264_PtypeB==pInfo->SliceHeader.slice_type)||(h264_PtypeP==pInfo->SliceHeader.slice_type) )
        {
            nitems = pInfo->SliceHeader.num_ref_idx_l0_active;
            if (pInfo->SliceHeader.sh_refpic_l0.ref_pic_list_reordering_flag)
            {
                p_list = pInfo->slice_ref_list0;
            }
            else
            {
                p_list = pInfo->dpb.listX_0;
            }
        }
        else
        {
            nitems =0;
            p_list = pInfo->dpb.listX_0;
        }
    }
    else
    {
        wi.vwi_type = VIDDEC_WORKLOAD_H264_REFR_LIST_1;

        if ( h264_PtypeB==pInfo->SliceHeader.slice_type)
        {
            nitems = pInfo->SliceHeader.num_ref_idx_l1_active;
            if (pInfo->SliceHeader.sh_refpic_l1.ref_pic_list_reordering_flag)
            {
                p_list = pInfo->slice_ref_list1;
            }
            else
            {
                p_list = pInfo->dpb.listX_1;
            }
        }
        else
        {
            nitems = 0;
            p_list = pInfo->dpb.listX_1;
        }

    }

    if (0 == nitems)
    {
        return;
    }

    byte_index =0;
    data_writed=0;


    for (i=0; i < 32; i++)
    {
        if (byte_index == 0) data = 0;

        if (i<nitems)
        {
            if ( viddec_h264_get_is_non_existent(&(pInfo->dpb.fs[ (p_list[i]&0x1f) ])))
            {
                data |= (pInfo->h264_list_replacement) << byte_index;
            }
            else
            {
                data |= (p_list[i] & 0x7f) << byte_index;
            }
        }
        else
        {
            data |= (0x80) << byte_index;
        }


        if (byte_index == 24)
        {
            byte_index = 0;
            wi.data.data_offset = data_writed&(~0x1);
            wi.data.data_payload[data_writed&0x1]=data;

            data =0;

            if (data_writed&0x1)
            {
                //cur is empty, fill new frame in cur
                viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
            }
            data_writed ++;
        }
        else
        {
            byte_index += 8;
        }
    }

}


void h264_parse_emit_current_slice( void *parent, h264_Info *pInfo )
{

    viddec_workload_item_t     wi;
    h264_slice_data 				slice_data;

    uint32_t		i=0, nitems=0, data=0;
    uint32_t 	bits_offset =0, byte_offset =0;
    uint8_t    	is_emul =0;

    ////////////////////// Update frame attributes/////////////////
    h264_parse_update_frame_attributes(parent,pInfo);


    if (pInfo->SliceHeader.sh_error) {
        // Error type definition, refer to viddec_fw_common_defs.h
        //		if error in top field, VIDDEC_FW_WORKLOAD_ERR_TOPFIELD			= (1 << 17)
        //		if error in bottom field, VIDDEC_FW_WORKLOAD_ERR_BOTTOMFIELD	   = (1 << 18)
        //		if this is frame based, both 2 bits should be set

        if (pInfo->push_to_cur) {
            pInfo->wl_err_curr |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
            pInfo->wl_err_curr |= (pInfo->SliceHeader.structure << FIELD_ERR_OFFSET);
        } else {
            pInfo->wl_err_next |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
            pInfo->wl_err_next |= (pInfo->SliceHeader.structure << FIELD_ERR_OFFSET);
        }
    }


    ////////////////////// Update Reference list //////////////////
    if ( (h264_PtypeB==pInfo->SliceHeader.slice_type)||(h264_PtypeP==pInfo->SliceHeader.slice_type) )
    {
        if (pInfo->SliceHeader.sh_refpic_l0.ref_pic_list_reordering_flag)
        {
            nitems = pInfo->SliceHeader.num_ref_idx_l0_active;

            for (i=0; i<nitems; i++)
            {
                if (viddec_h264_get_is_non_existent(&(pInfo->dpb.fs[pInfo->slice_ref_list0[i]&0x1f]))==0)
                {
                    pInfo->h264_list_replacement = (pInfo->slice_ref_list0[i]&0xFF)|0x80;
                    break;
                }
            }
        }
        else
        {
            nitems = pInfo->dpb.listXsize[0];

            for (i=0; i<nitems; i++)
            {
                if (viddec_h264_get_is_non_existent(&(pInfo->dpb.fs[pInfo->dpb.listX_0[i]&0x1f]))==0)
                {
                    pInfo->h264_list_replacement = (pInfo->dpb.listX_0[i]&0xFF)|0x80;
                    break;
                }
            }
        }

    }
    else
    {
        nitems =0;
    }
    /////file ref list 0
    h264_parse_emit_ref_list(parent, pInfo, 0);

    /////file ref list 1
    h264_parse_emit_ref_list(parent, pInfo, 1);

    ///////////////////////////////////// Slice Data ////////////////////////////////
    h264_fill_slice_data(pInfo, &slice_data);

    wi.vwi_type = VIDDEC_WORKLOAD_H264_SLICE_REG;

    wi.data.data_offset = slice_data.h264_bsd_slice_start;
    wi.data.data_payload[0] = slice_data.h264_bsd_slice_p1;
    wi.data.data_payload[1] = slice_data.h264_bsd_slice_p2;

    //cur is empty, fill new frame in cur
    viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);

    ///////////////////////////predict weight table item and data if have///////////////////////////
    if (pInfo->h264_pwt_enabled)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_H264_PWT_BITS_OFFSET;
        wi.data.data_offset = pInfo->h264_pwt_end_byte_offset- pInfo->h264_pwt_start_byte_offset+1;
        wi.data.data_payload[0] = pInfo->h264_pwt_start_bit_offset;
        wi.data.data_payload[1] = pInfo->h264_pwt_end_bit_offset;

        if (pInfo->push_to_cur) //cur is empty, fill new frame in cur
        {
            viddec_pm_append_workitem( parent , &wi, false);

            wi.vwi_type = VIDDEC_WORKLOAD_H264_PWT_ES_BYTES;
            wi.es.es_flags = 0;
            viddec_pm_append_misc_tags(parent, pInfo->h264_pwt_start_byte_offset, pInfo->h264_pwt_end_byte_offset,&wi,1);
        }
        else
        {
            viddec_pm_append_workitem( parent , &wi, true);

            wi.vwi_type = VIDDEC_WORKLOAD_H264_PWT_ES_BYTES;
            wi.es.es_flags = 0;
            viddec_pm_append_misc_tags(parent, pInfo->h264_pwt_start_byte_offset, pInfo->h264_pwt_end_byte_offset,&wi,0);
        }
    }


    ////////////////////////////////// Update ES Buffer for Slice ///////////////////////
    viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);

    //OS_INFO("DEBUG---entropy_coding_mode_flag:%d, bits_offset: %d\n", pInfo->active_PPS.entropy_coding_mode_flag, bits_offset);

    if (pInfo->active_PPS.entropy_coding_mode_flag)
    {
        if (0!=bits_offset)  {
            viddec_pm_get_bits(parent, &data, 8-bits_offset);
        }
    }
    else
    {
        if (0!=bits_offset)  {
            wi.vwi_type = VIDDEC_WORKLOAD_H264_SH_BITS_OFFSET;
            wi.data.data_offset = bits_offset;
            wi.data.data_payload[0]=0;
            wi.data.data_payload[1]=0;
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
        }
    }

    if (pInfo->push_to_cur) //cur is empty, fill new frame in cur
    {
        viddec_pm_append_pixeldata( parent );
    }
    else
    {
        viddec_pm_append_pixeldata_next( parent);
    }

    return;
}


void h264_parse_emit_current_pic( void *parent, h264_Info *pInfo )
{

    viddec_workload_item_t     wi;

    const uint32_t             *pl;
    uint32_t                   i=0,nitems=0;

    h264_pic_data pic_data;

    pInfo->qm_present_list=0;

    h264_parse_emit_4X4_scaling_matrix(parent, pInfo);
    h264_parse_emit_8X8_scaling_matrix(parent, pInfo);

    h264_fill_pic_data(pInfo, &pic_data);

    // How many payloads must be generated
    nitems = (sizeof(h264_pic_data) + 7) / 8; // In QWORDs rounded up

    pl = (const uint32_t *) &pic_data;

    // Dump slice data to an array of workitems,  to do pl access non valid mem
    for ( i = 0; i < nitems; i++ )
    {
        wi.vwi_type           = VIDDEC_WORKLOAD_H264_PIC_REG;
        wi.data.data_offset   = (unsigned int)pl - (unsigned int)&pic_data; // offset within struct
        wi.data.data_payload[0] = pl[0];
        wi.data.data_payload[1] = pl[1];
        pl += 2;
        //cur is empty, fill new frame in cur
        viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
    }

    return;
}

void h264_parse_emit_start_new_frame( void *parent, h264_Info *pInfo )
{

    viddec_workload_item_t     wi;
    uint32_t                   i=0,nitems=0;

    ///////////////////////// Frame attributes//////////////////////////

    //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))
    {
        viddec_workload_t			*wl_cur = viddec_pm_get_header( parent );
        //pInfo->img.g_new_frame = 0;
        pInfo->Is_first_frame_in_stream =0;
        pInfo->is_frame_boundary_detected_by_non_slice_nal=0;
        pInfo->push_to_cur = 1;
        h264_translate_parser_info_to_frame_attributes(wl_cur, pInfo);
    }
    else  // move to cur if frame boundary detected by previous non slice nal, or move to next if not
    {
        viddec_workload_t        *wl_next = viddec_pm_get_next_header (parent);

        pInfo->push_to_cur = 0;
        h264_translate_parser_info_to_frame_attributes(wl_next, pInfo);

        pInfo->is_current_workload_done=1;
    }

    ///////////////////// SPS/////////////////////
    h264_parse_emit_sps(parent, pInfo);

    /////////////////////display frames/////////////////////
    nitems = pInfo->dpb.frame_numbers_need_to_be_displayed;

    for (i=0; i<nitems; i++)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_REF_FRAME_DISPLAY_0 + pInfo->dpb.frame_id_need_to_be_displayed[i];
        wi.ref_frame.reference_id = pInfo->dpb.frame_id_need_to_be_displayed[i];
        wi.ref_frame.luma_phys_addr = 0;
        wi.ref_frame.chroma_phys_addr = 0;
        //cur is empty, fill new frame in cur
        viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
    }
    pInfo->dpb.frame_numbers_need_to_be_displayed =0;


    /////////////////////release frames/////////////////////
    nitems = pInfo->dpb.frame_numbers_need_to_be_removed;

    for (i=0; i<nitems; i++)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_REF_FRAME_RELEASE_0 + pInfo->dpb.frame_id_need_to_be_removed[i];
        wi.ref_frame.reference_id = pInfo->dpb.frame_id_need_to_be_removed[i];
        wi.ref_frame.luma_phys_addr = 0;
        wi.ref_frame.chroma_phys_addr = 0;
        //cur is empty, fill new frame in cur
        viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
    }
    pInfo->dpb.frame_numbers_need_to_be_removed =0;

    /////////////////////flust frames (do not display)/////////////////////
    nitems = pInfo->dpb.frame_numbers_need_to_be_dropped;

    for (i=0; i<nitems; i++)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_REF_FRAME_DROPOUT_0 + pInfo->dpb.frame_id_need_to_be_dropped[i];
        wi.ref_frame.reference_id = pInfo->dpb.frame_id_need_to_be_dropped[i];
        wi.ref_frame.luma_phys_addr = 0;
        wi.ref_frame.chroma_phys_addr = 0;
        //cur is empty, fill new frame in cur
        viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
    }
    pInfo->dpb.frame_numbers_need_to_be_dropped =0;

    /////////////////////updata DPB frames/////////////////////
    nitems = pInfo->dpb.used_size;
    for (i=0; i<nitems; i++)
    {
        uint8_t fs_id = pInfo->dpb.fs_dpb_idc[i];

        if (viddec_h264_get_is_non_existent(&(pInfo->dpb.fs[fs_id])) == 0)
        {
            wi.vwi_type = VIDDEC_WORKLOAD_DPB_ACTIVE_FRAME_0+fs_id;
            wi.ref_frame.reference_id = fs_id;
            wi.ref_frame.luma_phys_addr = 0;
            wi.ref_frame.chroma_phys_addr = 0;
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
        }
    }

    /////////////////////updata dpb frames info (poc)/////////////////////
    nitems = pInfo->dpb.used_size;
    for (i=0; i<nitems; i++)
    {
        uint8_t fs_id = pInfo->dpb.fs_dpb_idc[i];

        if (viddec_h264_get_is_non_existent(&(pInfo->dpb.fs[fs_id])) == 0)
        {
            wi.vwi_type = VIDDEC_WORKLOAD_H264_DPB_FRAME_POC;
            wi.data.data_offset = fs_id;
            //printf("is_used = %d, tpoc = %d, bpoc = %d\n", pInfo->dpb.fs[fs_id].is_used, pInfo->dpb.fs[fs_id].top_field.poc, pInfo->dpb.fs[fs_id].bottom_field.poc);

            switch (viddec_h264_get_is_used(&(pInfo->dpb.fs[fs_id])))
            {
            case (FRAME): {
                wi.data.data_payload[0] = pInfo->dpb.fs[fs_id].top_field.poc;
                wi.data.data_payload[1] = pInfo->dpb.fs[fs_id].bottom_field.poc;
                break;
            };

            case (TOP_FIELD): {
                wi.data.data_payload[0] = pInfo->dpb.fs[fs_id].top_field.poc;
                wi.data.data_payload[1] = 0;
                break;
            };

            case (BOTTOM_FIELD): {
                wi.data.data_payload[0] = 0;
                wi.data.data_payload[1] = pInfo->dpb.fs[fs_id].bottom_field.poc;
                break;
            };

            default : {
                wi.data.data_payload[0] = 0;
                wi.data.data_payload[1] = 0;
                break;
            };
            }
            //cur is empty, fill new frame in cur
            viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
        }
    }

    /////////////////////Alloc buffer for current Existing frame/////////////////////
    if (0!=pInfo->dpb.frame_numbers_need_to_be_allocated)
    {
        if (pInfo->push_to_cur)
        {
            viddec_workload_t        *wl_cur = viddec_pm_get_header (parent);
            wl_cur->is_reference_frame |= WORKLOAD_REFERENCE_FRAME | (pInfo->dpb.frame_id_need_to_be_allocated & 0x1f);
        }
        else
        {
            viddec_workload_t        *wl_next = viddec_pm_get_next_header (parent);
            wl_next->is_reference_frame |= WORKLOAD_REFERENCE_FRAME | (pInfo->dpb.frame_id_need_to_be_allocated & 0x1f);
        }
    }
    pInfo->dpb.frame_numbers_need_to_be_allocated =0;

    return;
}


void h264_parse_emit_eos( void *parent, h264_Info *pInfo )
{

    uint32_t nitems=0, i=0;
    viddec_workload_item_t	wi;


    wi.vwi_type = VIDDEC_WORKLOAD_EOS_BEGIN_BOUNDARY;
    wi.ref_frame.reference_id = 0;
    wi.ref_frame.luma_phys_addr = 0;
    wi.ref_frame.chroma_phys_addr = 0;

    //cur is empty, fill new frame in cur
    viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);

    //// Now we can flush out all frames in DPB fro display

    if (MPD_DPB_FS_NULL_IDC != pInfo->dpb.fs_dec_idc)
    {
        if (viddec_h264_get_is_used(&(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc])) != 3)
        {
            h264_dpb_mark_dangling_field(&pInfo->dpb, pInfo->dpb.fs_dec_idc);  //, DANGLING_TYPE_GAP_IN_FRAME
        }
    }


    h264_dpb_store_previous_picture_in_dpb(pInfo, 0,0);
    h264_dpb_flush_dpb(pInfo, 1, 0, pInfo->active_SPS.num_ref_frames);


    /////////////////////display frames/////////////////////
    nitems = pInfo->dpb.frame_numbers_need_to_be_displayed;

    for (i=0; i<nitems; i++)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_EOS_DISPLAY_FRAME_0 + pInfo->dpb.frame_id_need_to_be_displayed[i];
        wi.ref_frame.reference_id = pInfo->dpb.frame_id_need_to_be_displayed[i];
        wi.ref_frame.luma_phys_addr = 0;
        wi.ref_frame.chroma_phys_addr = 0;
        //cur is empty, fill new frame in cur
        viddec_pm_append_workitem( parent, &wi , !pInfo->push_to_cur);
    }
    pInfo->dpb.frame_numbers_need_to_be_displayed =0;


    /////////////////////release frames/////////////////////
    nitems = pInfo->dpb.frame_numbers_need_to_be_removed;

    for (i=0; i<nitems; i++)
    {
        wi.vwi_type = VIDDEC_WORKLOAD_EOS_RELEASE_FRAME_0 + pInfo->dpb.frame_id_need_to_be_removed[i];
        wi.ref_frame.reference_id = pInfo->dpb.frame_id_need_to_be_removed[i];
        wi.ref_frame.luma_phys_addr = 0;
        wi.ref_frame.chroma_phys_addr = 0;

        if (pInfo->push_to_cur) //cur is empty, fill new frame in cur
        {
            viddec_pm_append_workitem( parent, &wi , false);
            viddec_pm_set_next_frame_error_on_eos(parent, VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE);
        }
        else
        {
            viddec_pm_append_workitem( parent, &wi , true);
            viddec_pm_set_next_frame_error_on_eos(parent, pInfo->wl_err_next);
        }
    }
    pInfo->dpb.frame_numbers_need_to_be_removed =0;

    return;
}