mpvd.java

优秀的MPEG2-TS流分析软件

	50.0,
	((60.0*1000.0)/1001.0),
	60.0,

	-1,		// reserved
	-1,
	-1,
	-1,
	-1,
	-1,
	-1
};

/* global value */
private byte backward_reference_frame[] = new byte[3], forward_reference_frame[] = new byte[3];
private byte auxframe[] = new byte[3], current_frame[] = new byte[3];
private byte u422, v422, u444, v444, rgb24, lum;
private int pf_backward, pf_forward, pf_current;
private float frame_rate,Frame_Rate;
//from gopheader
private int gop_hour;
private int gop_minute;
private int gop_sec;
private int gop_frame;
private int drop_flag;
private int closed_gop;
private int broken_link;



public void Clear_Block(int comp) { // assembler?
	java.util.Arrays.fill(block[comp],(short)0);	//clear macroblaock
}

/***/
public void loadbits(int size) {
	BitPos = BufferPos<<3;
	BufferPos += size;
}

public int Get_Bits(int N) {
	int Pos, Val;
	Pos = BitPos>>>3;
	Val =   (0xFF&buf[Pos])<<24 |
		(0xFF&buf[Pos+1])<<16 |
		(0xFF&buf[Pos+2])<<8 |
		(0xFF&buf[Pos+3]);
	Val <<= BitPos & 7;
	Val >>>= 32-N;
	BitPos += N;
	BufferPos = BitPos>>>3;
	return Val;
}

public int Show_Bits(int N) {
	int Pos, Val;
	Pos = BitPos>>>3;
	Val =   (0xFF&buf[Pos])<<24 |
		(0xFF&buf[Pos+1])<<16 |
		(0xFF&buf[Pos+2])<<8 |
		(0xFF&buf[Pos+3]);
	Val <<= BitPos & 7;
	Val >>>= 32-N;
	return Val;
}
/***/

public void Flush_Bits(int N) {
	BitPos += N;
	BufferPos = BitPos>>>3;
}

/***
public void loadbits(int size) {
	Bits = new boolean[size*8];
	BitPos = 0;
	for (int a=0;a<size;a++)
		for (int b=0;b<8;b++) if (((0x80>>>b) & buf[BufferPos+a])!=0) Bits[(a*8)+b]=true;
	BufferPos+=size;
}

public int Get_Bits(int N) {
	int Val=0;
	for (int a=0;a<N;a++) if (Bits[BitPos+a]) Val |= 1<<(N-1-a);
	BitPos += N;
	return Val;
}

public int Show_Bits(int N) {
	int Val=0;
	for (int a=0;a<N;a++) if (Bits[BitPos+a]) Val |= 1<<(N-1-a);
	return Val;
}
***/


/* decode headers from one input stream */
public int extern_Get_Hdr() {
	int start_code;

	for (;;){
		/* look for next_start_code */
		if (DIRECTION) 
			previous_start_code();
		else 
			next_start_code();

		if ((start_code=Get_Bits(32))==SEQUENCE_HEADER_CODE){
			resetDecoder(); //DM26112003 081.5++
			StartPos=BufferPos-4;
			sequence_header();
			next_start_code();

			if ((start_code=Get_Bits(32))==GROUP_START_CODE)
			{
				group_of_pictures_header();
				next_start_code();

				if ((start_code=Get_Bits(32))==PICTURE_START_CODE)
				{
					picture_header();
					return 1;
				}
			}
		} else if (viewGOP && start_code==GROUP_START_CODE){
			StartPos=BufferPos-4;
			group_of_pictures_header();
			next_start_code();
			if ((start_code=Get_Bits(32))==PICTURE_START_CODE){
				picture_header();
				return 1;
			}
		}
		//else if (start_code==SEQUENCE_END_CODE)
		//	return 2;
		else if (DIRECTION) 
			Flush_Bits(-40);
	}
}

/* decode headers from one input stream */
public int Get_Hdr() {
	video_format=5;

	for (;;){
		/* look for next_start_code */



		next_start_code();

		switch (Get_Bits(32)){
			case SEQUENCE_HEADER_CODE:
				resetDecoder(); //DM26112003 081.5++
				StartPos=BufferPos-4;
				sequence_header();
				break;

			case GROUP_START_CODE:
				group_of_pictures_header();
				break;

			case PICTURE_START_CODE:
				picture_header();
				return 1;

			case SEQUENCE_END_CODE:
				return 2;
		}
	}
}

/* align to start of next next_start_code */
public void next_start_code(){
	Flush_Bits( (8-(BitPos & 7))&7 );
	while (Show_Bits(24) != 1)
		Flush_Bits(8);
}

/* align to start of next next_start_code */
public void previous_start_code(){
	Flush_Bits( (8-(BitPos & 7))&7 );
	while (Show_Bits(24) != 1) 
		Flush_Bits(-8);
}

/* decode sequence header */
public void sequence_header(){
	int constrained_parameters_flag;
	int bit_rate_value;
	int vbv_buffer_size;
	int i;

	horizontal_size             = Get_Bits(12);
	vertical_size               = Get_Bits(12);
	aspect_ratio_information    = Get_Bits(4);
	frame_rate_code             = Get_Bits(4);
	bit_rate_value              = Get_Bits(18);
	Flush_Bits(1);	// marker bit
	vbv_buffer_size             = Get_Bits(10);
	constrained_parameters_flag = Get_Bits(1);

	//DM05072004 081.7 int06 changed
	info_4 = " ";

	if ((load_intra_quantizer_matrix = Get_Bits(1))>0)
	{
		for (i=0; i<64; i++)
			intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);

		//DM05072004 081.7 int06 add
		info_4 += ",iqm";
	}
	else
	{
		System.arraycopy(default_intra_quantizer_matrix,0,intra_quantizer_matrix,0,64);
	}

	if ((load_non_intra_quantizer_matrix = Get_Bits(1))>0)
	{
		for (i=0; i<64; i++)
			non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);

		//DM05072004 081.7 int06 add
		info_4 += ",niqm";
	}
	else
	{
		java.util.Arrays.fill(non_intra_quantizer_matrix,16);
	}

	/* copy luminance to chrominance matrices */
	System.arraycopy(intra_quantizer_matrix,0,chroma_intra_quantizer_matrix,0,64);
	System.arraycopy(non_intra_quantizer_matrix,0,chroma_non_intra_quantizer_matrix,0,64);

	frame_rate = (float)frame_rate_Table[frame_rate_code]; //DM06022004 081.6 int15 add


	extension_and_user_data();

	//DM06052004 081.7 int02 add
	//DM29082004 081.7 int10 changed
	info_3 = ", " + (bit_rate_value * 400) + "bps, vbv " + vbv_buffer_size + (constrained_parameters_flag > 0 ? ", cpf" : "");
}

/* decode group of pictures header */
/* ISO/IEC 13818-2 section 6.2.2.6 */
public void group_of_pictures_header(){
	drop_flag   = Get_Bits(1);
	gop_hour    = Get_Bits(5);
	gop_minute  = Get_Bits(6);
	Flush_Bits(1);	// marker bit
	gop_sec     = Get_Bits(6);
	gop_frame	= Get_Bits(6);
	closed_gop  = Get_Bits(1);
	broken_link = Get_Bits(1);

	extension_and_user_data();
}

/* decode extension and user data */
/* ISO/IEC 13818-2 section 6.2.2.2 */
public void extension_and_user_data(){
	int code, ext_ID;

	next_start_code();

	while ((code = Show_Bits(32))==EXTENSION_START_CODE || code==USER_DATA_START_CODE){
		if (code==EXTENSION_START_CODE)	{
			Flush_Bits(32);
			ext_ID = Get_Bits(4);

			switch (ext_ID)	{
				case SEQUENCE_EXTENSION_ID:
					sequence_extension();
					break;
				case SEQUENCE_DISPLAY_EXTENSION_ID:
					sequence_display_extension();
					break;
				case QUANT_MATRIX_EXTENSION_ID:
					quant_matrix_extension();
					break;
				case PICTURE_DISPLAY_EXTENSION_ID:
					picture_display_extension();
					break;
				case PICTURE_CODING_EXTENSION_ID:
					picture_coding_extension();
					break;
				case COPYRIGHT_EXTENSION_ID:
					copyright_extension();
					break;
			}
			next_start_code();
		}else{
			info_4 += ", user_data"; //DM06052004 081.7 int02 add
			Flush_Bits(32);	// ISO/IEC 13818-2  sections 6.3.4.1 and 6.2.2.2.2
			next_start_code();	// skip user data
		}
	}
}

/* decode picture header */
/* ISO/IEC 13818-2 section 6.2.3 */
public void picture_header(){
	int vbv_delay;
	int full_pel_forward_vector;
	int forward_f_code;
	int full_pel_backward_vector;
	int backward_f_code;
	int Extra_Information_Byte_Count;

	temporal_reference  = Get_Bits(10);
	picture_coding_type = Get_Bits(3);

	vbv_delay = Get_Bits(16);

	if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)	{
		full_pel_forward_vector = Get_Bits(1);
		forward_f_code = Get_Bits(3);
	}

	if (picture_coding_type==B_TYPE){
		full_pel_backward_vector = Get_Bits(1);
		backward_f_code = Get_Bits(3);
	}

	Extra_Information_Byte_Count = extra_bit_information();
	extension_and_user_data();
}

/* decode sequence extension */
/* ISO/IEC 13818-2 section 6.2.2.3 */
public void sequence_extension(){
	int low_delay;
	int frame_rate_extension_n;
	int frame_rate_extension_d;

	int horizontal_size_extension;
	int vertical_size_extension;
	int bit_rate_extension;
	int vbv_buffer_size_extension;

	profile_and_level_indication = Get_Bits(8);
	progressive_sequence         = Get_Bits(1);
	chroma_format                = Get_Bits(2);
	horizontal_size_extension    = Get_Bits(2);
	vertical_size_extension      = Get_Bits(2);
	bit_rate_extension           = Get_Bits(12);
	Flush_Bits(1);	// marker bit
	vbv_buffer_size_extension    = Get_Bits(8);
	low_delay                    = Get_Bits(1);
 
	frame_rate_extension_n       = Get_Bits(2);
	frame_rate_extension_d       = Get_Bits(5);
	frame_rate = frame_rate * (frame_rate_extension_n+1) / (frame_rate_extension_d+1); //DM06022004 081.6 int15 changed

	horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0xfff);
	vertical_size = (vertical_size_extension<<12) | (vertical_size&0xfff);

	info_4 += ", low delay=" + low_delay; //DM26052004 081.7 int03 add
}

/* decode sequence display extension */
public void sequence_display_extension(){
	int color_description;
	int color_primaries;
	int transfer_characteristics;
	int matrix_coefficients;
	int display_horizontal_size;
	int display_vertical_size;

	video_format      = Get_Bits(3);
	color_description = Get_Bits(1);

	if (color_description>0){
		color_primaries          = Get_Bits(8);
		transfer_characteristics = Get_Bits(8);
		matrix_coefficients      = Get_Bits(8);
	}

	display_horizontal_size = Get_Bits(14);
	Flush_Bits(1);	// marker bit
	display_vertical_size   = Get_Bits(14);

	//DM06052004 081.7 int02 add
	//DM26052004 081.7 int03 changed
	info_4 += ", SDE: " + display_horizontal_size + "*" + display_vertical_size;
}

/* decode quant matrix entension */
/* ISO/IEC 13818-2 section 6.2.3.2 */
public void quant_matrix_extension(){
	int i;

	if ((load_intra_quantizer_matrix = Get_Bits(1))>0)
		for (i=0; i<64; i++)
			chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
			= intra_quantizer_matrix[scan[ZIG_ZAG][i]] 
			= Get_Bits(8);

	if ((load_non_intra_quantizer_matrix = Get_Bits(1))>0)
		for (i=0; i<64; i++)
			chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
			= non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] 
			= Get_Bits(8);

	if ((load_chroma_intra_quantizer_matrix = Get_Bits(1))>0)
		for (i=0; i<64; i++)
			chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);

	if ((load_chroma_non_intra_quantizer_matrix = Get_Bits(1))>0)
		for (i=0; i<64; i++)
			chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
}

/* decode picture display extension */
/* ISO/IEC 13818-2 section 6.2.3.3. */
public void picture_display_extension(){
	int frame_center_horizontal_offset[] = new int[3];
	int frame_center_vertical_offset[] = new int[3];

	int i;
	int number_of_frame_center_offsets;