headers.c

网络MPEG4IP流媒体开发源代码

#include "../mpeg3private.h"
#include "../mpeg3protos.h"
#include "mpeg3video.h"

#include <stdio.h>
#include <stdlib.h>

int mpeg3video_getseqhdr(mpeg3video_t *video)
{
	int i;

	int aspect_ratio, picture_rate, vbv_buffer_size;
	int constrained_parameters_flag;
	int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;

	video->horizontal_size = mpeg3bits_getbits(video->vstream, 12);
	video->vertical_size = mpeg3bits_getbits(video->vstream, 12);
	aspect_ratio = mpeg3bits_getbits(video->vstream, 4);
	video->framerate_code = mpeg3bits_getbits(video->vstream, 4);
	video->bitrate = mpeg3bits_getbits(video->vstream, 18);
	mpeg3bits_getbit_noptr(video->vstream); /* marker bit (=1) */
	vbv_buffer_size = mpeg3bits_getbits(video->vstream, 10);
	constrained_parameters_flag = mpeg3bits_getbit_noptr(video->vstream);
	video->frame_rate = mpeg3_frame_rate_table[video->framerate_code];

 	load_intra_quantizer_matrix = mpeg3bits_getbit_noptr(video->vstream);
 	if(load_intra_quantizer_matrix)
	{
    	for(i = 0; i < 64; i++)
      		video->intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  	}
  	else 
	{
    	for(i = 0; i < 64; i++)
      		video->intra_quantizer_matrix[i] = mpeg3_default_intra_quantizer_matrix[i];
  	}

	load_non_intra_quantizer_matrix = mpeg3bits_getbit_noptr(video->vstream);
	if(load_non_intra_quantizer_matrix)
	{
    	for(i = 0; i < 64; i++)
      		video->non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  	}
  	else 
	{
    	for(i = 0; i < 64; i++)
      		video->non_intra_quantizer_matrix[i] = 16;
  	}

/* copy luminance to chrominance matrices */
  	for(i = 0; i < 64; i++)
	{
    	video->chroma_intra_quantizer_matrix[i] = video->intra_quantizer_matrix[i];
   	 	video->chroma_non_intra_quantizer_matrix[i] = video->non_intra_quantizer_matrix[i];
  	}

	return 0;
}


/* decode sequence extension */

int mpeg3video_sequence_extension(mpeg3video_t *video)
{
	int prof_lev;
	int horizontal_size_extension, vertical_size_extension;
	int bit_rate_extension, vbv_buffer_size_extension, low_delay;
	int frame_rate_extension_n, frame_rate_extension_d;
	int pos = 0;

	video->mpeg2 = 1;
	video->scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
	prof_lev = mpeg3bits_getbyte_noptr(video->vstream);
	video->prog_seq = mpeg3bits_getbit_noptr(video->vstream);
	video->chroma_format = mpeg3bits_getbits(video->vstream, 2);
	horizontal_size_extension = mpeg3bits_getbits(video->vstream, 2);
	vertical_size_extension = mpeg3bits_getbits(video->vstream, 2);
	bit_rate_extension = mpeg3bits_getbits(video->vstream, 12);
	mpeg3bits_getbit_noptr(video->vstream);
	vbv_buffer_size_extension = mpeg3bits_getbyte_noptr(video->vstream);
	low_delay = mpeg3bits_getbit_noptr(video->vstream);
	frame_rate_extension_n = mpeg3bits_getbits(video->vstream, 2);
	frame_rate_extension_d = mpeg3bits_getbits(video->vstream, 5);
	video->horizontal_size = (horizontal_size_extension << 12) | (video->horizontal_size & 0x0fff);
	video->vertical_size = (vertical_size_extension << 12) | (video->vertical_size & 0x0fff);
	return 0;
}


/* decode sequence display extension */

int mpeg3video_sequence_display_extension(mpeg3video_t *video)
{
	int colour_primaries = 0, transfer_characteristics = 0;
	int display_horizontal_size, display_vertical_size;
	int pos = 0;
	int video_format = mpeg3bits_getbits(video->vstream, 3);
	int colour_description = mpeg3bits_getbit_noptr(video->vstream);

	if(colour_description)
	{
    	colour_primaries = mpeg3bits_getbyte_noptr(video->vstream);
    	transfer_characteristics = mpeg3bits_getbyte_noptr(video->vstream);
    	video->matrix_coefficients = mpeg3bits_getbyte_noptr(video->vstream);
	}

	display_horizontal_size = mpeg3bits_getbits(video->vstream, 14);
	mpeg3bits_getbit_noptr(video->vstream);
	display_vertical_size = mpeg3bits_getbits(video->vstream, 14);
	return 0;
}


/* decode quant matrix entension */

int mpeg3video_quant_matrix_extension(mpeg3video_t *video)
{
	int i;
	int load_intra_quantiser_matrix, load_non_intra_quantiser_matrix;
	int load_chroma_intra_quantiser_matrix;
	int load_chroma_non_intra_quantiser_matrix;
	int pos = 0;

	if((load_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
	{
      	for(i = 0; i < 64; i++)
		{
    		video->chroma_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
    			= video->intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
    			= mpeg3bits_getbyte_noptr(video->vstream);
      	}
	}

	if((load_non_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
	{
    	for (i = 0; i < 64; i++)
		{
    		video->chroma_non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
    			= video->non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
    			= mpeg3bits_getbyte_noptr(video->vstream);
    	}
	}

	if((load_chroma_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
	{
    	for(i = 0; i < 64; i++)
    		video->chroma_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
	}

	if((load_chroma_non_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
	{
      	for(i = 0; i < 64; i++)
    		video->chroma_non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
	}
	return 0;
}


/* decode sequence scalable extension */

int mpeg3video_sequence_scalable_extension(mpeg3video_t *video)
{
	int layer_id;

	video->scalable_mode = mpeg3bits_getbits(video->vstream, 2) + 1; /* add 1 to make SC_DP != SC_NONE */
	layer_id = mpeg3bits_getbits(video->vstream, 4);

	if(video->scalable_mode == SC_SPAT)
	{
    	video->llw = mpeg3bits_getbits(video->vstream, 14); /* lower_layer_prediction_horizontal_size */
    	mpeg3bits_getbit_noptr(video->vstream);
    	video->llh = mpeg3bits_getbits(video->vstream, 14); /* lower_layer_prediction_vertical_size */
    	video->hm = mpeg3bits_getbits(video->vstream, 5);
    	video->hn = mpeg3bits_getbits(video->vstream, 5);
    	video->vm = mpeg3bits_getbits(video->vstream, 5);
    	video->vn = mpeg3bits_getbits(video->vstream, 5);
	}

	if(video->scalable_mode == SC_TEMP)
      	fprintf(stderr, "mpeg3video_sequence_scalable_extension: temporal scalability not implemented\n");
	return 0;
}


/* decode picture display extension */

int mpeg3video_picture_display_extension(mpeg3video_t *video)
{
	int n, i;
	short frame_centre_horizontal_offset[3];
	short frame_centre_vertical_offset[3];



	if(video->prog_seq || video->pict_struct != FRAME_PICTURE)
		n = 1;
	else 
		n = video->repeatfirst ? 3 : 2;




	for(i = 0; i < n; i++)
	{
    	frame_centre_horizontal_offset[i] = (short)mpeg3bits_getbits(video->vstream, 16);
    	mpeg3bits_getbit_noptr(video->vstream);
    	frame_centre_vertical_offset[i] = (short)mpeg3bits_getbits(video->vstream, 16);
    	mpeg3bits_getbit_noptr(video->vstream);
	}
	return 0;
}


/* decode picture coding extension */

int mpeg3video_picture_coding_extension(mpeg3video_t *video)
{
	int chroma_420_type, composite_display_flag;
	int v_axis = 0, field_sequence = 0, sub_carrier = 0, burst_amplitude = 0, sub_carrier_phase = 0;

	video->h_forw_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
	video->v_forw_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
	video->h_back_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
	video->v_back_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
	video->dc_prec = mpeg3bits_getbits(video->vstream, 2);
	video->pict_struct = mpeg3bits_getbits(video->vstream, 2);
	video->topfirst = mpeg3bits_getbit_noptr(video->vstream);
	video->frame_pred_dct = mpeg3bits_getbit_noptr(video->vstream);
	video->conceal_mv = mpeg3bits_getbit_noptr(video->vstream);
	video->qscale_type = mpeg3bits_getbit_noptr(video->vstream);
	video->intravlc = mpeg3bits_getbit_noptr(video->vstream);
	video->altscan = mpeg3bits_getbit_noptr(video->vstream);


	video->repeatfirst = mpeg3bits_getbit_noptr(video->vstream);


	chroma_420_type = mpeg3bits_getbit_noptr(video->vstream);
	video->prog_frame = mpeg3bits_getbit_noptr(video->vstream);

	if(video->repeat_count > 100)
		video->repeat_count = 0;
	video->repeat_count += 100;

	video->current_repeat = 0;

	if(video->prog_seq)
	{
		if(video->repeatfirst)
		{
			if(video->topfirst)
				video->repeat_count += 200;
			else
				video->repeat_count += 100;
		}
	}
	else
	if(video->prog_frame)
	{
		if(video->repeatfirst)
		{
			video->repeat_count += 50;
		}