WebSVN - shark - Blame - Rev 1625 - /advdemos/trunk/mpeg2/recon.c

Rev	Author	Line No.	Line
1624	giacomo	1	/* Predict.c, motion compensation routines */
		2
		3	/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
		4
		5	/*
		6	* Disclaimer of Warranty
		7	*
		8	* These software programs are available to the user without any license fee or
		9	* royalty on an "as is" basis. The MPEG Software Simulation Group disclaims
		10	* any and all warranties, whether express, implied, or statuary, including any
		11	* implied warranties or merchantability or of fitness for a particular
		12	* purpose. In no event shall the copyright-holder be liable for any
		13	* incidental, punitive, or consequential damages of any kind whatsoever
		14	* arising from the use of these programs.
		15	*
		16	* This disclaimer of warranty extends to the user of these programs and user's
		17	* customers, employees, agents, transferees, successors, and assigns.
		18	*
		19	* The MPEG Software Simulation Group does not represent or warrant that the
		20	* programs furnished hereunder are free of infringement of any third-party
		21	* patents.
		22	*
		23	* Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
		24	* are subject to royalty fees to patent holders. Many of these patents are
		25	* general enough such that they are unavoidable regardless of implementation
		26	* design.
		27	*
		28	*/
		29
		30	#include <stdio.h>
		31
		32	#include "config.h"
		33	#include "global.h"
		34
		35	/* private prototypes */
		36	static void form_prediction _ANSI_ARGS_((unsigned char *src[], int sfield,
		37	unsigned char *dst[], int dfield,
		38	int lx, int lx2, int w, int h, int x, int y, int dx, int dy,
		39	int average_flag));
		40
		41	static void form_component_prediction _ANSI_ARGS_((unsigned char src, unsigned char dst,
		42	int lx, int lx2, int w, int h, int x, int y, int dx, int dy, int average_flag));
		43
		44	void form_predictions(bx,by,macroblock_type,motion_type,PMV,motion_vertical_field_select,dmvector,stwtype)
		45	int bx, by;
		46	int macroblock_type;
		47	int motion_type;
		48	int PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];
		49	int stwtype;
		50	{
		51	int currentfield;
		52	unsigned char **predframe;
		53	int DMV[2][2];
		54	int stwtop, stwbot;
		55
		56	stwtop = stwtype%3; /* 0:temporal, 1:(spat+temp)/2, 2:spatial */
		57	stwbot = stwtype/3;
		58
		59	if ((macroblock_type & MACROBLOCK_MOTION_FORWARD)
		60	\|\| (picture_coding_type==P_TYPE))
		61	{
		62	if (picture_structure==FRAME_PICTURE)
		63	{
		64	if ((motion_type==MC_FRAME)
		65	\|\| !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
		66	{
		67	/* frame-based prediction (broken into top and bottom halves
		68	for spatial scalability prediction purposes) */
		69	if (stwtop<2)
		70	form_prediction(forward_reference_frame,0,current_frame,0,
		71	Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
		72	PMV[0][0][0],PMV[0][0][1],stwtop);
		73
		74	if (stwbot<2)
		75	form_prediction(forward_reference_frame,1,current_frame,1,
		76	Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
		77	PMV[0][0][0],PMV[0][0][1],stwbot);
		78	}
		79	else if (motion_type==MC_FIELD) /* field-based prediction */
		80	{
		81	/* top field prediction */
		82	if (stwtop<2)
		83	form_prediction(forward_reference_frame,motion_vertical_field_select[0][0],
		84	current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
		85	bx,by>>1,PMV[0][0][0],PMV[0][0][1]>>1,stwtop);
		86
		87	/* bottom field prediction */
		88	if (stwbot<2)
		89	form_prediction(forward_reference_frame,motion_vertical_field_select[1][0],
		90	current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
		91	bx,by>>1,PMV[1][0][0],PMV[1][0][1]>>1,stwbot);
		92	}
		93	else if (motion_type==MC_DMV) /* dual prime prediction */
		94	{
		95	/* calculate derived motion vectors */
		96	Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]>>1);
		97
		98	if (stwtop<2)
		99	{
		100	/* predict top field from top field */
		101	form_prediction(forward_reference_frame,0,current_frame,0,
		102	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
		103	PMV[0][0][0],PMV[0][0][1]>>1,0);
		104
		105	/* predict and add to top field from bottom field */
		106	form_prediction(forward_reference_frame,1,current_frame,0,
		107	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
		108	DMV[0][0],DMV[0][1],1);
		109	}
		110
		111	if (stwbot<2)
		112	{
		113	/* predict bottom field from bottom field */
		114	form_prediction(forward_reference_frame,1,current_frame,1,
		115	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
		116	PMV[0][0][0],PMV[0][0][1]>>1,0);
		117
		118	/* predict and add to bottom field from top field */
		119	form_prediction(forward_reference_frame,0,current_frame,1,
		120	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by>>1,
		121	DMV[1][0],DMV[1][1],1);
		122	}
		123	}
		124	else
		125	/* invalid motion_type */
		126	printf("invalid motion_type\n");
		127	}
		128	else /* TOP_FIELD or BOTTOM_FIELD */
		129	{
		130	/* field picture */
		131	currentfield = (picture_structure==BOTTOM_FIELD);
		132
		133	/* determine which frame to use for prediction */
		134	if ((picture_coding_type==P_TYPE) && Second_Field
		135	&& (currentfield!=motion_vertical_field_select[0][0]))
		136	predframe = backward_reference_frame; /* same frame */
		137	else
		138	predframe = forward_reference_frame; /* previous frame */
		139
		140	if ((motion_type==MC_FIELD)
		141	\|\| !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
		142	{
		143	/* field-based prediction */
		144	if (stwtop<2)
		145	form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,
		146	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
		147	PMV[0][0][0],PMV[0][0][1],stwtop);
		148	}
		149	else if (motion_type==MC_16X8)
		150	{
		151	if (stwtop<2)
		152	{
		153	form_prediction(predframe,motion_vertical_field_select[0][0],current_frame,0,
		154	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by,
		155	PMV[0][0][0],PMV[0][0][1],stwtop);
		156
		157	/* determine which frame to use for lower half prediction */
		158	if ((picture_coding_type==P_TYPE) && Second_Field
		159	&& (currentfield!=motion_vertical_field_select[1][0]))
		160	predframe = backward_reference_frame; /* same frame */
		161	else
		162	predframe = forward_reference_frame; /* previous frame */
		163
		164	form_prediction(predframe,motion_vertical_field_select[1][0],current_frame,0,
		165	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,bx,by+8,
		166	PMV[1][0][0],PMV[1][0][1],stwtop);
		167	}
		168	}
		169	else if (motion_type==MC_DMV) /* dual prime prediction */
		170	{
		171	if (Second_Field)
		172	predframe = backward_reference_frame; /* same frame */
		173	else
		174	predframe = forward_reference_frame; /* previous frame */
		175
		176	/* calculate derived motion vectors */
		177	Dual_Prime_Arithmetic(DMV,dmvector,PMV[0][0][0],PMV[0][0][1]);
		178
		179	/* predict from field of same parity */
		180	form_prediction(forward_reference_frame,currentfield,current_frame,0,
		181	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
		182	PMV[0][0][0],PMV[0][0][1],0);
		183
		184	/* predict from field of opposite parity */
		185	form_prediction(predframe,!currentfield,current_frame,0,
		186	Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,bx,by,
		187	DMV[0][0],DMV[0][1],1);
		188	}
		189	else
		190	/* invalid motion_type */
		191	printf("invalid motion_type\n");
		192	}
		193	stwtop = stwbot = 1;
		194	}
		195
		196	if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)
		197	{
		198	if (picture_structure==FRAME_PICTURE)
		199	{
		200	if (motion_type==MC_FRAME)
		201	{
		202	/* frame-based prediction */
		203	if (stwtop<2)
		204	form_prediction(backward_reference_frame,0,current_frame,0,
		205	Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
		206	PMV[0][1][0],PMV[0][1][1],stwtop);
		207
		208	if (stwbot<2)
		209	form_prediction(backward_reference_frame,1,current_frame,1,
		210	Coded_Picture_Width,Coded_Picture_Width<<1,16,8,bx,by,
		211	PMV[0][1][0],PMV[0][1][1],stwbot);
		212	}
		213	else /* field-based prediction */
		214	{
		215	/* top field prediction */
		216	if (stwtop<2)
		217	form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
		218	current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
		219	bx,by>>1,PMV[0][1][0],PMV[0][1][1]>>1,stwtop);
		220
		221	/* bottom field prediction */
		222	if (stwbot<2)
		223	form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],
		224	current_frame,1,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
		225	bx,by>>1,PMV[1][1][0],PMV[1][1][1]>>1,stwbot);
		226	}
		227	}
		228	else /* TOP_FIELD or BOTTOM_FIELD */
		229	{
		230	/* field picture */
		231	if (motion_type==MC_FIELD)
		232	{
		233	/* field-based prediction */
		234	form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
		235	current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,16,
		236	bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
		237	}
		238	else if (motion_type==MC_16X8)
		239	{
		240	form_prediction(backward_reference_frame,motion_vertical_field_select[0][1],
		241	current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
		242	bx,by,PMV[0][1][0],PMV[0][1][1],stwtop);
		243
		244	form_prediction(backward_reference_frame,motion_vertical_field_select[1][1],
		245	current_frame,0,Coded_Picture_Width<<1,Coded_Picture_Width<<1,16,8,
		246	bx,by+8,PMV[1][1][0],PMV[1][1][1],stwtop);
		247	}
		248	else
		249	/* invalid motion_type */
		250	printf("invalid motion_type\n");
		251	}
		252	}
		253	}
		254
		255	static void form_prediction(src,sfield,dst,dfield,lx,lx2,w,h,x,y,dx,dy,average_flag)
		256	unsigned char src[]; / prediction source buffer */
		257	int sfield; /* prediction source field number (0 or 1) */
		258	unsigned char dst[]; / prediction destination buffer */
		259	int dfield; /* prediction destination field number (0 or 1)*/
		260	int lx,lx2; /* line strides */
		261	int w,h; /* prediction block/sub-block width, height */
		262	int x,y; /* pixel co-ordinates of top-left sample in current MB */
		263	int dx,dy; /* horizontal, vertical prediction address */
		264	int average_flag; /* add prediction error to prediction ? */
		265	{
		266	/* Y */
		267	form_component_prediction(src[0]+(sfield?lx2>>1:0),dst[0]+(dfield?lx2>>1:0),
		268	lx,lx2,w,h,x,y,dx,dy,average_flag);
		269
		270	if (chroma_format!=CHROMA444)
		271	{
		272	lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
		273	}
		274
		275	if (chroma_format==CHROMA420)
		276	{
		277	h>>=1; y>>=1; dy/=2;
		278	}
		279
		280	/* Cb */
		281	form_component_prediction(src[1]+(sfield?lx2>>1:0),dst[1]+(dfield?lx2>>1:0),
		282	lx,lx2,w,h,x,y,dx,dy,average_flag);
		283
		284	/* Cr */
		285	form_component_prediction(src[2]+(sfield?lx2>>1:0),dst[2]+(dfield?lx2>>1:0),
		286	lx,lx2,w,h,x,y,dx,dy,average_flag);
		287	}
		288
		289	/* ISO/IEC 13818-2 section 7.6.4: Forming predictions */
		290	/* NOTE: the arithmetic below produces numerically equivalent results
		291	* to 7.6.4, yet is more elegant. It differs in the following ways:
		292	*
		293	* 1. the vectors (dx, dy) are based on cartesian frame
		294	* coordiantes along a half-pel grid (always positive numbers)
		295	* In contrast, vector[r][s][t] are differential (with positive and
		296	* negative values). As a result, deriving the integer vectors
		297	* (int_vec[t]) from dx, dy is accomplished by a simple right shift.
		298	*
		299	* 2. Half pel flags (xh, yh) are equivalent to the LSB (Least
		300	* Significant Bit) of the half-pel coordinates (dx,dy).
		301	*
		302	*
		303	* NOTE: the work of combining predictions (ISO/IEC 13818-2 section 7.6.7)
		304	* is distributed among several other stages. This is accomplished by
		305	* folding line offsets into the source and destination (src,dst)
		306	* addresses (note the call arguments to form_prediction() in Predict()),
		307	* line stride variables lx and lx2, the block dimension variables (w,h),
		308	* average_flag, and by the very order in which Predict() is called.
		309	* This implementation design (implicitly different than the spec)
		310	* was chosen for its elegance.
		311	*/
		312
		313	static void form_component_prediction(src,dst,lx,lx2,w,h,x,y,dx,dy,average_flag)
		314	unsigned char *src;
		315	unsigned char *dst;
		316	int lx; /* raster line increment */
		317	int lx2;
		318	int w,h;
		319	int x,y;
		320	int dx,dy;
		321	int average_flag; /* flag that signals bi-directional or Dual-Prime
		322	averaging (7.6.7.1 and 7.6.7.4). if average_flag==1,
		323	a previously formed prediction has been stored in
		324	pel_pred[] */
		325	{
		326	int xint; /* horizontal integer sample vector: analogous to int_vec[0] */
		327	int yint; /* vertical integer sample vectors: analogous to int_vec[1] */
		328	int xh; /* horizontal half sample flag: analogous to half_flag[0] */
		329	int yh; /* vertical half sample flag: analogous to half_flag[1] */
		330	int i, j, v;
		331	unsigned char s; / source pointer: analogous to pel_ref[][] */
		332	unsigned char d; / destination pointer: analogous to pel_pred[][] */
		333
		334	/* half pel scaling for integer vectors */
		335	xint = dx>>1;
		336	yint = dy>>1;
		337
		338	/* derive half pel flags */
		339	xh = dx & 1;
		340	yh = dy & 1;
		341
		342	/* compute the linear address of pel_ref[][] and pel_pred[][]
		343	based on cartesian/raster cordinates provided */
		344	s = src + lx*(y+yint) + x + xint;
		345	d = dst + lx*y + x;
		346
		347	if (!xh && !yh) /* no horizontal nor vertical half-pel */
		348	{
		349	if (average_flag)
		350	{
		351	for (j=0; j<h; j++)
		352	{
		353	for (i=0; i<w; i++)
		354	{
		355	v = d[i]+s[i];
		356	d[i] = (v+(v>=0?1:0))>>1;
		357	}
		358
		359	s+= lx2;
		360	d+= lx2;
		361	}
		362	}
		363	else
		364	{
		365	for (j=0; j<h; j++)
		366	{
		367	for (i=0; i<w; i++)
		368	{
		369	d[i] = s[i];
		370	}
		371
		372	s+= lx2;
		373	d+= lx2;
		374	}
		375	}
		376	}
		377	else if (!xh && yh) /* no horizontal but vertical half-pel */
		378	{
		379	if (average_flag)
		380	{
		381	for (j=0; j<h; j++)
		382	{
		383	for (i=0; i<w; i++)
		384	{
		385	v = d[i] + ((unsigned int)(s[i]+s[i+lx]+1)>>1);
		386	d[i]=(v+(v>=0?1:0))>>1;
		387	}
		388
		389	s+= lx2;
		390	d+= lx2;
		391	}
		392	}
		393	else
		394	{
		395	for (j=0; j<h; j++)
		396	{
		397	for (i=0; i<w; i++)
		398	{
		399	d[i] = (unsigned int)(s[i]+s[i+lx]+1)>>1;
		400	}
		401
		402	s+= lx2;
		403	d+= lx2;
		404	}
		405	}
		406	}
		407	else if (xh && !yh) /* horizontal but no vertical half-pel */
		408	{
		409	if (average_flag)
		410	{
		411	for (j=0; j<h; j++)
		412	{
		413	for (i=0; i<w; i++)
		414	{
		415	v = d[i] + ((unsigned int)(s[i]+s[i+1]+1)>>1);
		416	d[i] = (v+(v>=0?1:0))>>1;
		417	}
		418
		419	s+= lx2;
		420	d+= lx2;
		421	}
		422	}
		423	else
		424	{
		425	for (j=0; j<h; j++)
		426	{
		427	for (i=0; i<w; i++)
		428	{
		429	d[i] = (unsigned int)(s[i]+s[i+1]+1)>>1;
		430	}
		431
		432	s+= lx2;
		433	d+= lx2;
		434	}
		435	}
		436	}
		437	else /* if (xh && yh) horizontal and vertical half-pel */
		438	{
		439	if (average_flag)
		440	{
		441	for (j=0; j<h; j++)
		442	{
		443	for (i=0; i<w; i++)
		444	{
		445	v = d[i] + ((unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2);
		446	d[i] = (v+(v>=0?1:0))>>1;
		447	}
		448
		449	s+= lx2;
		450	d+= lx2;
		451	}
		452	}
		453	else
		454	{
		455	for (j=0; j<h; j++)
		456	{
		457	for (i=0; i<w; i++)
		458	{
		459	d[i] = (unsigned int)(s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
		460	}
		461
		462	s+= lx2;
		463	d+= lx2;
		464	}
		465	}
		466	}
		467	}

Subversion Repositories shark

(root)/advdemos/trunk/mpeg2/recon.c - Rev 1625