WebSVN - shark - Blame - Rev 1182 - /demos/trunk/fsf/mpeg2/recon.c

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

Subversion Repositories shark

(root)/demos/trunk/fsf/mpeg2/recon.c - Rev 1182