decode.c

mpeg2 decoder filter过滤服务端

    error = convert (MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0,
		     mpeg2_accels, arg, &convert_init);
    if (!error) {
	mpeg2dec->convert = convert;
	mpeg2dec->convert_arg = arg;
	mpeg2dec->convert_id_size = convert_init.id_size;
	mpeg2dec->convert_stride = 0;
    }
    return error;
}

int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride)
{
    if (!mpeg2dec->convert) {
	if (stride < (int) mpeg2dec->sequence.width)
	    stride = mpeg2dec->sequence.width;
	mpeg2dec->decoder.stride_frame = stride;
    } else {
	mpeg2_convert_init_t convert_init;

	stride = mpeg2dec->convert (MPEG2_CONVERT_STRIDE, NULL,
				    &(mpeg2dec->sequence), stride,
				    mpeg2_accels, mpeg2dec->convert_arg,
				    &convert_init);
	mpeg2dec->convert_id_size = convert_init.id_size;
	mpeg2dec->convert_stride = stride;
    }
    return stride;
}

void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id)
{
    mpeg2_fbuf_t * fbuf;

    if (mpeg2dec->custom_fbuf) {
	if (mpeg2dec->state == STATE_SEQUENCE) {
	    mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
	    mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
	}
	mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type ==
				   PIC_FLAG_CODING_TYPE_B));
	fbuf = mpeg2dec->fbuf[0];
    } else {
	fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf);
	mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
    }
    fbuf->buf[0] = buf[0];
    fbuf->buf[1] = buf[1];
    fbuf->buf[2] = buf[2];
    fbuf->id = id;
}

void mpeg2_custom_fbuf (mpeg2dec_t * mpeg2dec, int custom_fbuf)
{
    mpeg2dec->custom_fbuf = custom_fbuf;
}

void mpeg2_skip (mpeg2dec_t * mpeg2dec, int skip)
{
    mpeg2dec->first_decode_slice = 1;
    mpeg2dec->nb_decode_slices = skip ? 0 : (0xb0 - 1);
}

void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end)
{
    start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start;
    end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end;
    mpeg2dec->first_decode_slice = start;
    mpeg2dec->nb_decode_slices = end - start;
}

void mpeg2_tag_picture (mpeg2dec_t * mpeg2dec, uint32_t tag, uint32_t tag2)
{
    mpeg2dec->tag_previous = mpeg2dec->tag_current;
    mpeg2dec->tag2_previous = mpeg2dec->tag2_current;
    mpeg2dec->tag_current = tag;
    mpeg2dec->tag2_current = tag2;
    mpeg2dec->num_tags++;
    mpeg2dec->bytes_since_tag = 0;
}

uint32_t mpeg2_accel (uint32_t accel)
{
    if (!mpeg2_accels) {
	if (accel & MPEG2_ACCEL_DETECT)
	    accel |= mpeg2_detect_accel ();
	mpeg2_accels = accel |= MPEG2_ACCEL_DETECT;
	mpeg2_cpu_state_init (accel);
	mpeg2_idct_init (accel);
	mpeg2_mc_init (accel);
    }
    return mpeg2_accels & ~MPEG2_ACCEL_DETECT;
}

void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset)
{
    mpeg2dec->buf_start = mpeg2dec->buf_end = NULL;
    mpeg2dec->num_tags = 0;
    mpeg2dec->shift = 0xffffff00;
    mpeg2dec->code = 0xb4;
    mpeg2dec->action = mpeg2_seek_header;
    mpeg2dec->state = STATE_INVALID;
    mpeg2dec->first = 1;

    mpeg2_reset_info(&(mpeg2dec->info));
    mpeg2dec->info.gop = NULL;
    mpeg2dec->info.user_data = NULL;
    mpeg2dec->info.user_data_len = 0;
    if (full_reset) {
	mpeg2dec->info.sequence = NULL;
	mpeg2_header_state_init (mpeg2dec);
    }

}

mpeg2dec_t *  mpeg2_init (void)
{
    mpeg2dec_t * mpeg2dec;

    mpeg2_accel (MPEG2_ACCEL_DETECT);

    mpeg2dec = (mpeg2dec_t *) mpeg2_malloc (sizeof (mpeg2dec_t),
					    MPEG2_ALLOC_MPEG2DEC);
    if (mpeg2dec == NULL)
	return NULL;

    memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t));
    memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t));

    mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc (BUFFER_SIZE + 4,
						       MPEG2_ALLOC_CHUNK);

    mpeg2dec->sequence.width = (unsigned)-1;
    //mpeg2_reset (mpeg2dec, 1);
	mpeg2_reset (mpeg2dec, 0);

    return mpeg2dec;
}

void mpeg2_close (mpeg2dec_t * mpeg2dec)
{
    mpeg2_header_state_init (mpeg2dec);
    mpeg2_free (mpeg2dec->chunk_buffer);
    mpeg2_free (mpeg2dec);
}


/*
//add by djhuang


void InitialDecoder(void)
{
	int i, size;

	mb_width = (horizontal_size+15)/16;
	mb_height = progressive_sequence ? (vertical_size+15)/16 : 2*((vertical_size+31)/32);

	Coded_Picture_Width = 16 * mb_width;
	Coded_Picture_Height = 16 * mb_height;

	Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width : Coded_Picture_Width>>1;
	Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height : Coded_Picture_Height>>1;

	block_count = ChromaFormat[chroma_format];

	hheightd2 = Coded_Picture_Height / 2 - 2;
	qheightd2 = Coded_Picture_Height / 4 - 2;
	hwidth = Coded_Picture_Width / 2;
	hwidthd8 = Coded_Picture_Width / 2 - 8;
	dwidth = Coded_Picture_Width * 2;
	qwidth = Coded_Picture_Width * 4;
	nwidth = Coded_Picture_Width * 9;

	for (i=0; i<3; i++)
	{
		if (i==0)
			size = Coded_Picture_Width * Coded_Picture_Height;
		else
			size = Chroma_Width * Chroma_Height;

		backward_reference_frame[i] = (unsigned char*)malloc(size);
		forward_reference_frame[i] = (unsigned char*)malloc(size);
		auxframe[i] = (unsigned char*)malloc(size);
	}

	u422 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height/2);
	v422 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height/2);
	u444 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height);
	v444 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height);
	rgb24 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height*3);
	yuy2 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height*2);
	lum = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height);

	ZeroMemory(&birgb, sizeof(BITMAPINFOHEADER));
	birgb.biSize = sizeof(BITMAPINFOHEADER);
	birgb.biWidth = Coded_Picture_Width;
	birgb.biHeight = Coded_Picture_Height;
	birgb.biPlanes = 1;
	birgb.biBitCount = 24;
	birgb.biCompression = BI_RGB;
	birgb.biSizeImage = Coded_Picture_Width * Coded_Picture_Height * 3;

	biyuv = birgb;
	biyuv.biBitCount = 16;
	biyuv.biCompression = mmioFOURCC('Y','U','Y','2');
	biyuv.biSizeImage = Coded_Picture_Width * Coded_Picture_Height * 2;
}

void CheckSequenceHeader(void)
{
	if (!Check_Flag)
	{
		Initialize_Reference_IDCT();
		Initialize_Buffer();

		while (!Check_Flag)
		{
			next_start_code();
			switch (Get_Bits(32))
			{
			case PACK_START_CODE:
				SystemStream_Flag = 1;
				break;

			case SEQUENCE_HEADER_CODE:
				sequence_header();
				InitialDecoder();
				Check_Flag = 1;
				break;
			}
		}
		
		Frame_Rate = (FO_Flag==FO_FILM) ? frame_rate*4/5 : frame_rate;
		
		ResetCacheChecking();   // Reuse the cache header
		Initialize_Buffer();
	}
}



void InitSystem(void)
{
	int  i;
	Stop_Flag = Rip_Flag = Fault_Flag = 0;
	Frame_Number = Second_Field = 0;
	VOB_ID = CELL_ID = 0;
	Bitrate_Meter = 0;
	SystemStream_Flag = 0;

	for (i = 0; i < 8; i++)
	{
		p_block[i] = (short *)malloc(sizeof(short)*64 + 64);
		block[i]   = (short *)((long)p_block[i] + 64 - (long)p_block[i]%64);
	}
	
	Initialize_Reference_IDCT();
//	Initialize_FPU_IDCT();
	
	iDCT_Flag  = IDCT_MMX;
	FO_Flag    = FO_NONE;
	Scale_Flag = TRUE;
	if (Scale_Flag)
	{
		YUVRGB_Scale  = 0x1000254310002543;
		YUVRGB_Offset = 0x0010001000100010;
	}
	else
	{
		YUVRGB_Scale  = 0x1000200010002000;
		YUVRGB_Offset = 0x0000000000000000;
	}

	Luminance_Flag     = 0;
	gIsPictureDecoding = FALSE;
	gIsEOS = FALSE; 
}

void UninitSystem(void)
{
	int i;
	if (Check_Flag)
	{
		for (i=0; i<3; i++)
		{
			free(backward_reference_frame[i]);
			free(forward_reference_frame[i]);
			free(auxframe[i]);
		}

		free(u422);
		free(v422);
		free(u444);
		free(v444);
		free(rgb24);
		free(yuy2);
		free(lum);
	}
	Check_Flag = 0;

	// Added by luqiming
	for (i = 0; i < 8; i++)
	{
		if (p_block[i])
		{
			free(p_block[i]);
			p_block[i] = 0;
		}		
	}
}

*/