www.pudn.com > wm2.5.zip > parset.c

 
//cbzhu 041219 
#include  
#include  
#include  
#include  
#include  
#include  
 
#include "global.h" 
#include "define.h" 
#include "types.h" 
#include "vlc.h" 
#include "nalu.h" 
 
#include "parset.h" 
//#include "memalloc.h" 
 
extern void no_mem_exit (char *where); 
extern void Form_RBSP(Bitstream *currBitStream); 
 
seq_parameter_set *AllocSPS() 
{ 
	seq_parameter_set *p; 
	if ((p=calloc (1,sizeof (seq_parameter_set) )) == NULL) 
		no_mem_exit ("AllocSPS: SPS"); 
	return p; 
} 
 
pic_parameter_set *AllocPPS() 
{ 
	pic_parameter_set *p; 
	if ((p=calloc (1,sizeof (pic_parameter_set) )) == NULL) 
		no_mem_exit ("AllocPPS: PPS"); 
	return p; 
} 
 
pic_header *AllocPicHeader() 
{ 
	pic_header *p; 
	if((p=calloc (1,sizeof (pic_header))) == NULL) 
		no_mem_exit("AllocPicHeader: PicHeader"); 
	return p; 
} 
 
void FreeParameterSets () 
{ 
  FreeSPS (active_sps); 
  FreePPS (active_pps); 
} 
 
void GenerateParameterSets () 
{ 
	seq_parameter_set *sps=NULL; 
	pic_parameter_set *pps=NULL; 
 
	sps = AllocSPS(); 
	pps = AllocPPS(); 
 
	FillParameterSetStructures (sps, pps); 
 
	active_sps = sps; 
	active_pps = pps; 
 
	//write_parset(active_sps,active_pps); 
} 
 
void FillParameterSetStructures (seq_parameter_set *sps,  
                                 pic_parameter_set *pps)  
{ 
	assert (sps != NULL); 
	assert (pps != NULL); 
	sps->profile_idc =  input.profile_idc = 0x20; 
	sps->level_idc = input.level_idc = 0x42; 
	sps->seq_parameter_set_id = 0; 
	sps->num_ref_frames = input.num_reference_frames; 
	sps->horizontal_size_minus1 = input.img_width/MB_BLOCK_SIZE - 1; 
	sps->vertical_size_minus1 = input.img_height/MB_BLOCK_SIZE -1; 
	sps->aspect_ratio = ASPECT_RATIO_DAR_16_9; 
	sps->frame_cropping_flag = 0; 
 
	//if(sps->frame_cropping_flag) 
	sps->frame_cropping_left_offset = 0; 
	sps->frame_crop_right_offset = 0; 
	sps->frame_crop_top_offset = 0; 
	sps->frame_crop_bottom_offset = 0; 
 
	sps->delta_time_picture_distance_1 =  90000 / input.PictureRate; 
	sps->hrd_parameters_present_flag = 0; 
 
	pps->pic_parameter_set_id = 0; 
	pps->seq_parameter_set_id = 0; 
	pps->fixed_picture_qp_flag = pgImage->fixed_picture_qp; 
	pps->picture_reference_flag = pgImage->picture_reference_flag; 
	pps->sliding_window_size_flag = 0; 
	 
	pps->skip_mode_flag = 1;  //problem// 
	 
	pps->loop_filter_disable_flag = 0; 
 
	//if(pps->loop_filter_disable_flag == 0) 
	pps->loop_filter_parameter_flag = 1; 
	 
	pps->constrained_intra_pred_flag = 1;   //MZ 
	pps->half_pixel_mv_flag = input.HalfPixelMVEnable; 
	 
} 
 
void FreeSPS (seq_parameter_set *sps) 
{ 
	assert (sps != NULL); 
	free (sps); 
} 
 
void FreePPS(pic_parameter_set *pps) 
{ 
	assert (pps != NULL); 
	free (pps); 
} 
 
void FreePicHeader (pic_header *ph) 
{ 
	assert (ph != NULL); 
	free (ph); 
} 
 
void write_parset(seq_parameter_set *sps , pic_parameter_set *pps) 
{ 
	write_SPS(sps); 
	write_PPS(pps); 
} 
 
void write_SPS(seq_parameter_set *sps) 
{ 
	NALU_t *nalu;//WJP FOR NAL 
	 
	pgcurrBitStream->byte_pos = 0; 
	pgcurrBitStream->bits_to_go = 8; 
	 
	//u_v(32,"parset start code",0x1b0); 
	u_v(8,"profile_idc",sps->profile_idc); 
	u_v(8,"level_idc",sps->level_idc); 
	ue_linfo(sps->seq_parameter_set_id); 
	u_v(16,"delta_time_picture_distance_1",sps->delta_time_picture_distance_1);  // 
	ue_linfo(sps->num_ref_frames); 
	ue_linfo(sps->horizontal_size_minus1); 
	ue_linfo(sps->vertical_size_minus1); 
	u_v(4,"aspect_ratio",sps->aspect_ratio); 
	u_v(1,"frame_cropping_flag",sps->frame_cropping_flag); 
	 
	if(sps->frame_cropping_flag) 
	{ 
		ue_linfo(sps->frame_cropping_left_offset); 
		ue_linfo(sps->frame_crop_right_offset); 
		ue_linfo(sps->frame_crop_top_offset); 
		ue_linfo(sps->frame_crop_bottom_offset); 
	} 
 
	//u_v(16,"delta_time_picture_distance_1",sps->delta_time_picture_distance_1); 
	u_v(1,"HRD parameter flag",sps->hrd_parameters_present_flag); 
 
	//isolated region information,not included in fcd,but only for encoder-decoder matching 
	//u_v(1,"isolated region enable",input.IREGEnable); 
	//u_v(8,"isolated region evolution rate",input.IREGRate); 
 
	//WJP FOR NAL 
	Form_RBSP(pgcurrBitStream); 
	nalu = AllocNALU(pgcurrBitStream->byte_pos+1);		 
	Form_NALU(nalu, NALU_TYPE_SPS, NAL_REF_IDC_SPS, pgcurrBitStream->streamBuffer, pgcurrBitStream->byte_pos); 
	gTotalBits += 8*Write_NALU2File(nalu,pgcurrBitStream->f); 
	FreeNALU(nalu); 
	//END 
 
} 
 
void write_PPS(pic_parameter_set *pps) 
{ 
	NALU_t *nalu;//WJP FOR NAL 
	 
	pgcurrBitStream->byte_pos = 0; 
	pgcurrBitStream->bits_to_go = 8; 
 
	ue_linfo(pps->pic_parameter_set_id); 
	ue_linfo(pps->seq_parameter_set_id); 
	u_v(1,"fixed qp flag",pps->fixed_picture_qp_flag); 
	u_v(1,"picture_reference_flag",pps->picture_reference_flag); 
	 
	if(pps->picture_reference_flag == 0) 
	{ 
		u_v(1,"sliding window size flag",pps->sliding_window_size_flag); 
	} 
 
	u_v(1,"skip mode flag",pps->skip_mode_flag); 
	u_v(1,"loop filter disable flag",pps->loop_filter_disable_flag); 
 
	if(pps->loop_filter_disable_flag == 0) 
	{ 
		u_v(1,"loopfilter parameter flag",pps->loop_filter_parameter_flag); 
	} 
 
	u_v(1,"constrained intra predict flag",pps->constrained_intra_pred_flag);//MZ 
	u_v(1,"half pixel mv flag",pps->half_pixel_mv_flag); 
 
	//WJP FOR NAL 
	Form_RBSP(pgcurrBitStream); 
	nalu = AllocNALU(pgcurrBitStream->byte_pos+1);		 
	Form_NALU(nalu, NALU_TYPE_PPS, NAL_REF_IDC_PPS, pgcurrBitStream->streamBuffer, pgcurrBitStream->byte_pos); 
	gTotalBits += 8*Write_NALU2File(nalu,pgcurrBitStream->f); 
	FreeNALU(nalu); 
	//END 
 
//	byte_align(pgcurrBitStream); 
//	fwrite(pgcurrBitStream->streamBuffer,1,pgcurrBitStream->byte_pos,pgcurrBitStream->f); 
} 
 
 
void FillPicHeader(pic_header *p) 
{ 
	picture_header_rbsp->picture_coding_type = pgImage->picture_code_type; 
	picture_header_rbsp->pic_parameter_set_id = 0; 
	picture_header_rbsp->alpha_ci_offset = pgImage->alpha_ci_offset; 
	picture_header_rbsp->cp_offset = pgImage->cp_offset; 
	picture_header_rbsp->frame_num = pgImage->frame_num; 
	picture_header_rbsp->loopfilter_qp_offset = pgImage->loopfilter_qp_offset; 
	picture_header_rbsp->picture_distance = pgImage->picture_distance; 
	picture_header_rbsp->picture_distance_gap_minus1 = pgImage->picture_distance_gap_minus1; 
	picture_header_rbsp->sliding_window_size_minus1 = 0; 
	picture_header_rbsp->picture_qp = pgMbData->qp_mb;         
	      
} 
 
void write_PicHeader(pic_header *p) 
{ 
	NALU_t *nalu; 
	pic_header *ph; 
	ph = AllocPicHeader(); 
	picture_header_rbsp = ph; 
	//cbzhu 041221 
	 
	FillPicHeader(picture_header_rbsp); 
	 
	//if(pgImage->picture_code_type == 0) 
	//	u_v(8, "I picture start code",0xB3); 
	//else 
	//	u_v(8, "P picture start code",0xB6); 
	u_v(2, "picture coding type",picture_header_rbsp->picture_coding_type);  //p_pic_type  
	u_v(8, "picture distance", picture_header_rbsp->picture_distance); 
	 
  ue_linfo(picture_header_rbsp->pic_parameter_set_id); 
   
  //?mazhan 
  //if(picture_header_rbsp->picture_distance==0) 
   ue_linfo(picture_header_rbsp->picture_distance_gap_minus1); 
	 
   
  u_v(5 , "frame number",picture_header_rbsp->frame_num); 
	u_v(6 , "piture qp",picture_header_rbsp->picture_qp); 
	if(active_pps->loop_filter_parameter_flag) 
	{ 
		se_linfo(picture_header_rbsp->alpha_ci_offset); 
		se_linfo(picture_header_rbsp->cp_offset); 
		se_linfo(picture_header_rbsp->loopfilter_qp_offset); 
	} 
	if(active_pps->sliding_window_size_flag) 
	{ 
		u_v(1,"sliding window size minus 1",picture_header_rbsp->sliding_window_size_minus1); 
	} 
	 
 
	//printf("%d %d %d\n" , pgImage->picture_reference_flag ,pgImage->p_pic_type, pgImage->nb_references); 
 
	FreePicHeader(picture_header_rbsp); 
	//WJP FOR NAL 
	Form_RBSP(pgcurrBitStream); 
	nalu = AllocNALU(pgcurrBitStream->byte_pos+1); 
   
	if(pgImage->p_pic_type == 0) //as reference 
		Form_NALU(nalu, NALU_TYPE_P_HEADER, NAL_REF_IDC_REF, pgcurrBitStream->streamBuffer, pgcurrBitStream->byte_pos); 
	else  //non reference 
		Form_NALU(nalu, NALU_TYPE_P_HEADER, NAL_REF_IDC_NONREF, pgcurrBitStream->streamBuffer, pgcurrBitStream->byte_pos); 
	 
  gTotalBits += 8*Write_NALU2File(nalu,pgcurrBitStream->f); 
	FreeNALU(nalu); 
	 
	//END 
}