/* 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;
}