header.c

davinci avs.......................................................

  DecodeSliceHeader(currStream);
  DecodeSliceData(currStream);

}
*/
 /*! 
 *************************************************************************************
 * \brief :
 *    Reads new slice from bit_stream
 *************************************************************************************
 */
int read_new_byte_stream()
{
	byte *Buf;
	int Buf_cur_pos=0;
	
	int next_nalu_type;
	int i,slice_num=0;

	Slice_Enable=1;

	for(i=0;i<176;i++)
	{
		Position_of_Slice_in_Picbuff[i]=0;
	}	
    
	nalu = AllocNALU(MAX_CODED_FRAME_SIZE);//pgImage->width * pgImage->height * 4
  
  
  if ((Buf = (char*)calloc (MAX_CODED_FRAME_SIZE , sizeof(byte))) == NULL) 
		no_mem_exit("GetAnnexbNALU: Buf");

	while (1)
	{

		GetOneUnit(nalu,&next_nalu_type); //!<Get One NAL Unit
    
		switch(nalu->nal_unit_type)
		{
		  case NALU_TYPE_SPS:
			  SequenceParameterSet(nalu);
  		  break;

		  case NALU_TYPE_PPS:
     		PictureParameterSet(nalu);
			  break;

      case NALU_TYPE_IDR:
        DecodePictureHeader(nalu);
	      break;

		  case NALU_TYPE_P_HEADER:
        DecodePictureHeader(nalu);
			break;

		  case NALU_TYPE_SLICE:
       	Position_of_Slice_in_Picbuff[slice_num++]=Buf_cur_pos;
		    NALU2RBSP(nalu,Buf,&Buf_cur_pos);

        if(next_nalu_type == NALU_TYPE_SLICE)
				  break;
		else
        {
        	memcpy (currStream->streamBuffer, Buf, Buf_cur_pos);
	        currStream->code_len = currStream->bitstream_length = Buf_cur_pos;
	        currStream->read_len = currStream->frame_bitoffset = 0;
				//decode_picture_header(Buf,Buf_cur_pos);
				  FreeNALU(nalu);
				  free(Buf);

				if(next_nalu_type== -1)//end of bitstream
					return LPOS;
				else
					return SOP;
        }

     case NALU_TYPE_SEI:
       InterpretSEIMessage(nalu->buf, nalu->len, pgImage);
       break;
		
     case NALU_TYPE_RAPI:		//JX 050406
		   printf("random acess point indicator unit detected\n");
	     break;

	   default:
		   printf("Can't find start code\n");
		   FreeNALU(nalu);
	     free(Buf);
	     return EOS;
		}
	}
}

#ifdef _HRD_
 /*! 
 *************************************************************************************
 * \brief :
 *    hrd_parameters
 *************************************************************************************
 */
void hrd_parameters(seq_parameter_set *sps)
{
    sps->initial_cpb_removal_delay_length = u_v(5, "SPS: initial_cpb_removal_delay_length");
    sps->initial_dpb_output_delay_length  = u_v(5, "SPS: initial_dpb_output_delay_length");
    sps->bit_rate_scale = u_v(4, "SPS: bit_rate_scale");
    sps->cpb_size_scale = u_v(4, "SPS: cpb_size_scale");
    sps->dpb_size_scale = u_v(4, "SPS: dpb_size_scale");
    
}

#endif // _HRD_




 /*! 
 *************************************************************************************
 * \brief :
 *    sequence header parseting according AVS-M FCD
 * \notes:
 *    Add SPS indicator to trace file by Zhan MA
 *************************************************************************************
 */
void SequenceParameterSet (NALU_t *nalu)
{
  int profile_idc,level_idc,seq_parameter_set_id;

	seq_parameter_set *p = NULL;
  p = AllocSPS();
	sps = p;


#if TRACE
  fprintf(p_trace,"\n");
  tracebits2("start_code_prefix",24,0x01);
  fprintf(p_trace,"ANNEX B NALU, len %d, forbidden_bit %d, nal_reference_idc %d, nal_unit_type %d,\n",
            nalu->len,nalu->forbidden_bit,nalu->nal_reference_idc,nalu->nal_unit_type);
  tracebits2("SPS: NALU Header",8,nalu->buf[0]);
  fprintf(p_trace,"\nDecoding seq_parameter_set_rbsp\n\n");
#endif

  /* NALU to RBSP */
	memcpy (currStream->streamBuffer, nalu->buf+1, nalu->len-1);//WJP FOR NAL
	currStream->code_len = currStream->bitstream_length = nalu->len-1;//WJP FOR NAL
	currStream->read_len = currStream->frame_bitoffset = 0;//WJP FOR NAL
  	
	profile_idc                           = u_v(8, "SPS: Profile_idc");
  level_idc                             = u_v(8, "SPS: Level_idc");
	seq_parameter_set_id                  = ue_v("SPS: seq_parameter_set_id");
  
  sps                                   = sps_buf[seq_parameter_set_id];

  sps->profile_idc                      = profile_idc;
  sps->level_idc                        = level_idc;
	sps->seq_parameter_set_id             = seq_parameter_set_id;

	sps->delta_time_picture_distance_1    = u_v(16 , "SPS: delta_time_picture_distance_1");
	sps->num_ref_frames                   = ue_v("SPS: num_ref_frames");
	sps->horizontal_size_minus1           = ue_v("SPS: horizontal_size_minus1");
	sps->vertical_size_minus1             = ue_v("SPS: vertical_size_minus1");
	sps->aspect_ratio                     = u_v(4, "SPS: aspect_ratio");
	sps->frame_cropping_flag              = u_v(1, "SPS: frame_cropping_flag");
	

	if(sps->frame_cropping_flag )
	{
		sps->frame_cropping_left_offset     = ue_v("SPS: frame_cropping_left_offset");
		sps->frame_crop_right_offset        = ue_v("SPS: frame_cropping_right_offset");
		sps->frame_crop_top_offset          = ue_v("SPS: frame_cropping_top_offset");
		sps->frame_crop_bottom_offset       = ue_v("SPS: frame_cropping_bottom_offset");
	}
	
	sps->hrd_parameters_present_flag      = u_v(1,"SPS: hrd_par_present_flag");  //may be bugs here

#ifdef _HRD_
    sps->bit_rate_scale = 4;
    sps->cpb_size_scale = 6;
    sps->dpb_size_scale = 6;
    sps->initial_cpb_removal_delay_length = 24;
    sps->initial_dpb_output_delay_length  = 24;
    if (sps->hrd_parameters_present_flag)
    {
        hrd_parameters(sps);
    }
#endif // _HRD_  


  DecodeTrailingBits(currStream);
  
  CheckSPSValid(sps);  /* error report for bistream conformance*/
}



 /*! 
 *************************************************************************************
 * \brief :
 *    PictureParameterSet  
 *************************************************************************************
 */
void PictureParameterSet(NALU_t *nalu)
{
  int pic_parameter_set_id;

  pic_parameter_set *p = NULL;
	p = AllocPPS();
  pps = p;
  
#if TRACE
  fprintf(p_trace,"\n");
  tracebits2("start_code_prefix",24,0x01);
  fprintf(p_trace,"ANNEX B NALU, len %d, forbidden_bit %d, nal_reference_idc %d, nal_unit_type %d,\n",
            nalu->len,nalu->forbidden_bit,nalu->nal_reference_idc,nalu->nal_unit_type);
  tracebits2("PPS: NALU Header",8,nalu->buf[0]);
  fprintf(p_trace,"\nDecoding pic_parameter_set_rbsp\n\n");
#endif

	memcpy (currStream->streamBuffer, nalu->buf+1, nalu->len-1);//WJP FOR NAL
	currStream->code_len = currStream->bitstream_length = nalu->len-1;//WJP FOR NAL
	currStream->read_len = currStream->frame_bitoffset = 0;//WJP FOR NAL

	pic_parameter_set_id                       = ue_v("PPS: pic_parameter_set_id");
  pps                                        = pps_buf[pic_parameter_set_id];

  pps->pic_parameter_set_id                  = pic_parameter_set_id;
	pps->seq_parameter_set_id                  = ue_v("PPS: seq_parameter_set_id");
  pps->fixed_picture_qp_flag                 = u_v(1,"PPS: fixed_picture_qp_flag");
	pps->picture_reference_flag                = u_v(1,"PPS: picture_reference_flag");

	if(!pps->picture_reference_flag)  /* if 0 : mb adaptive reference picture selection */
	{
		pps->sliding_window_size_flag            = u_v(1,"PPS: sliding window size flag");
	}

	pps->skip_mode_flag                        = u_v(1,"PPS: skip mode flag");
	pps->loop_filter_disable_flag              = u_v(1,"PPS: loop filter disable flag");

	if(!pps->loop_filter_disable_flag)  /* 0 Enable Filter, 1 Diable Filter */
		pps->loop_filter_parameter_flag          = u_v(1,"PPS: loop filter parameter flag");
  else 
    pps->loop_filter_parameter_flag          = 0;

	pps->constrained_intra_pred_flag           = u_v(1,"PPS: Constrained Intra Prediction Flag");
	pps->half_pixel_mv_flag                    = u_v(1,"PPS: half_pix_mv_flag");

  DecodeTrailingBits(currStream);

  CheckPPSValid(pps);
}


 /*! 
 *************************************************************************************
 * \brief :
 *   
 *************************************************************************************
 */
/*
int sign(int a , int b)
{
  int x;
	
  x=abs(a);

  if (b>0)
    return(x);
  else 
    return(-x);
}
*/