WebSVN - shark - Blame - Rev 2 - /shark/branches/pj/ports/mpeg/video.c

Rev	Author	Line No.	Line
2	pj	1	/*
		2	* video.c --
		3	*
		4	* This file contains C code that implements the video decoder model.
		5	*
		6	*/
		7
		8	/*
		9	* Copyright (c) 1995 The Regents of the University of California.
		10	* All rights reserved.
		11	*
		12	* Permission to use, copy, modify, and distribute this software and its
		13	* documentation for any purpose, without fee, and without written agreement is
		14	* hereby granted, provided that the above copyright notice and the following
		15	* two paragraphs appear in all copies of this software.
		16	*
		17	* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
		18	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
		19	* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
		20	* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		21	*
		22	* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
		23	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
		24	* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
		25	* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
		26	* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
		27	*/
		28
		29	/*
		30	* Portions of this software Copyright (c) 1995 Brown University.
		31	* All rights reserved.
		32	*
		33	* Permission to use, copy, modify, and distribute this software and its
		34	* documentation for any purpose, without fee, and without written agreement
		35	* is hereby granted, provided that the above copyright notice and the
		36	* following two paragraphs appear in all copies of this software.
		37	*
		38	* IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR
		39	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
		40	* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN
		41	* UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		42	*
		43	* BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
		44	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
		45	* PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
		46	* BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
		47	* SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
		48	*/
		49
		50	#include <stdio.h>
		51	#include <stdlib.h>
		52	#include <assert.h>
		53
		54	#ifndef MIPS
		55	#include <sys/time.h>
		56	#else
		57	#include <sys/types.h>
		58	#include <sys/system.h>
		59	#endif
		60
		61	#ifndef NOCONTROLS
		62	#include "ctrlbar.h"
		63	#endif
		64	#include "decoders.h"
		65	#include "video.h"
		66	#include "util.h"
		67	#include "proto.h"
		68
		69	/* Declarations of functions. */
		70	static void ReconIMBlock();
		71	static void ReconPMBlock();
		72	static void ReconBMBlock();
		73	static void ReconBiMBlock();
		74	static void ReconSkippedBlock();
		75	static void DoPictureDisplay();
		76	static int ParseSeqHead();
		77	static int ParseGOP();
		78	static int ParsePicture();
		79	static int ParseSlice();
		80	static int ParseMacroBlock();
		81	static void ProcessSkippedPFrameMBlocks();
		82	static void ProcessSkippedBFrameMBlocks();
		83
		84	/*
		85	Changes to make the code reentrant:
		86	de-globalized: totNumFrames, realTimeStart, matched_depth, ditherType,
		87	curBits, ReconPMBlock statics, first, [lc]max[xy], ditherFlags,
		88	vid_stream, Parse_done, seekValue, ReadPack static, sys_layer,
		89	bitOffset, bitLength, bitBuffer, curVidStream,
		90	X globals to xinfo (window, et al)
		91	use vid_stream->film_has_ended instead of FilmState
		92	lookup tables only initialized once, global as possible
		93	(default_intra_matrix, zigzag, zigzag_direct, scan)
		94	get rid of setjmp, long jmp
		95	Additional changes:
		96	if DISABLE_DITHER defined then do not compile dithering code
		97	-lsh@cs.brown.edu (Loring Holden)
		98	*/
		99
		100	/* Macro for returning 1 if num is positive, -1 if negative, 0 if 0. */
		101
		102	#define Sign(num) ((num > 0) ? 1 : ((num == 0) ? 0 : -1))
		103
		104	/* Set up array for fast conversion from zig zag order to row/column
		105	coordinates.
		106	*/
		107
		108	const int zigzag[64][2] = {
		109	0, 0, 1, 0, 0, 1, 0, 2, 1, 1, 2, 0, 3, 0, 2, 1, 1, 2, 0, 3, 0, 4, 1, 3,
		110	2, 2, 3, 1, 4, 0, 5, 0, 4, 1, 3, 2, 2, 3, 1, 4, 0, 5, 0, 6, 1, 5, 2, 4,
		111	3, 3, 4, 2, 5, 1, 6, 0, 7, 0, 6, 1, 5, 2, 4, 3, 3, 4, 2, 5, 1, 6, 0, 7,
		112	1, 7, 2, 6, 3, 5, 4, 4, 5, 3, 6, 2, 7, 1, 7, 2, 6, 3, 5, 4, 4, 5, 3, 6,
		113	2, 7, 3, 7, 4, 6, 5, 5, 6, 4, 7, 3, 7, 4, 6, 5, 5, 6, 4, 7, 5, 7, 6, 6,
		114	7, 5, 7, 6, 6, 7, 7, 7};
		115	/* Array mapping zigzag to array pointer offset. */
		116
		117	const int zigzag_direct[64] = {
		118	0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12,
		119	19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35,
		120	42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
		121	58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63};
		122	/* Set up array for fast conversion from row/column coordinates to
		123	zig zag order.
		124	*/
		125
		126	const int scan[8][8] = {
		127	{0, 1, 5, 6, 14, 15, 27, 28},
		128	{2, 4, 7, 13, 16, 26, 29, 42},
		129	{3, 8, 12, 17, 25, 30, 41, 43},
		130	{9, 11, 18, 24, 31, 40, 44, 53},
		131	{10, 19, 23, 32, 39, 45, 52, 54},
		132	{20, 22, 33, 38, 46, 51, 55, 60},
		133	{21, 34, 37, 47, 50, 56, 59, 61},
		134	{35, 36, 48, 49, 57, 58, 62, 63}};
		135	/* Initialize P and B skip flags. */
		136
		137	static int No_P_Flag = FALSE;
		138	static int No_B_Flag = FALSE;
		139
		140	/* Max lum, chrom indices for illegal block checking. */
		141
		142
		143	/*
		144	* We use a lookup table to make sure values stay in the 0..255 range.
		145	* Since this is cropping (ie, x = (x < 0)?0:(x>255)?255:x; ), wee call this
		146	* table the "crop table".
		147	* MAX_NEG_CROP is the maximum neg/pos value we can handle.
		148	*/
		149
		150	#define MAX_NEG_CROP 2048
		151	#define NUM_CROP_ENTRIES (2048+2*MAX_NEG_CROP)
		152	static unsigned char cropTbl[NUM_CROP_ENTRIES];
		153
		154	/*
		155	The following accounts for time and size spent in various parsing acitivites
		156	if ANALYSIS has been defined.
		157	*/
		158
		159	#ifdef ANALYSIS
		160
		161
		162	unsigned int bitCount = 0;
		163
		164	int showmb_flag = 0;
		165	int showEachFlag = 0;
		166
		167	typedef struct {
		168	int frametype;
		169	unsigned int totsize;
		170	unsigned int number;
		171	unsigned int i_mbsize;
		172	unsigned int p_mbsize;
		173	unsigned int b_mbsize;
		174	unsigned int bi_mbsize;
		175	unsigned int i_mbnum;
		176	unsigned int p_mbnum;
		177	unsigned int b_mbnum;
		178	unsigned int bi_mbnum;
		179	unsigned int i_mbcbp[64];
		180	unsigned int p_mbcbp[64];
		181	unsigned int b_mbcbp[64];
		182	unsigned int bi_mbcbp[64];
		183	unsigned int i_mbcoeff[64];
		184	unsigned int p_mbcoeff[64];
		185	unsigned int b_mbcoeff[64];
		186	unsigned int bi_mbcoeff[64];
		187	double tottime;
		188	} Statval;
		189
		190	Statval stat_a[4];
		191	unsigned int pictureSizeCount;
		192	unsigned int mbSizeCount;
		193	unsigned int mbCBPPtr, mbCoeffPtr, *mbSizePtr;
		194	unsigned int cacheHit[8][8];
		195	unsigned int cacheMiss[8][8];
		196
		197	static void
		198	init_stat_struct(astat)
		199	Statval *astat;
		200	{
		201	int j;
		202
		203	astat->frametype = 0;
		204	astat->totsize = 0;
		205	astat->number = 0;
		206	astat->i_mbsize = 0;
		207	astat->p_mbsize = 0;
		208	astat->b_mbsize = 0;
		209	astat->bi_mbsize = 0;
		210	astat->i_mbnum = 0;
		211	astat->p_mbnum = 0;
		212	astat->b_mbnum = 0;
		213	astat->bi_mbnum = 0;
		214
		215	for (j = 0; j < 64; j++) {
		216
		217	astat->i_mbcbp[j] = 0;
		218	astat->p_mbcbp[j] = 0;
		219	astat->b_mbcbp[j] = 0;
		220	astat->bi_mbcbp[j] = 0;
		221	astat->i_mbcoeff[j] = 0;
		222	astat->p_mbcoeff[j] = 0;
		223	astat->b_mbcoeff[j] = 0;
		224	astat->bi_mbcoeff[j] = 0;
		225	}
		226	astat->tottime = 0.0;
		227	}
		228
		229	void
		230	init_stats()
		231	{
		232	int i, j;
		233
		234	for (i = 0; i < 4; i++) {
		235	init_stat_struct(&(stat_a[i]));
		236	stat_a[i].frametype = i;
		237	}
		238
		239	for (i = 0; i < 8; i++) {
		240	for (j = 0; j < 8; j++) {
		241	cacheHit[i][j] = 0;
		242	cacheMiss[i][j] = 0;
		243	}
		244	}
		245
		246	bitCount = 0;
		247	}
		248
		249	static void
		250	PrintOneStat()
		251	{
		252	int i;
		253
		254	printf("\n");
		255	switch (stat_a[0].frametype) {
		256	case I_TYPE:
		257	printf("I FRAME\n");
		258	break;
		259	case P_TYPE:
		260	printf("P FRAME\n");
		261	break;
		262	case B_TYPE:
		263	printf("B FRAME\n");
		264	break;
		265	}
		266
		267	printf("Size: %d bytes + %d bits\n", stat_a[0].totsize / 8, stat_a[0].totsize % 8);
		268	if (stat_a[0].i_mbnum > 0) {
		269	printf("\tI Macro Block Stats:\n");
		270	printf("\t%d I Macroblocks\n", stat_a[0].i_mbnum);
		271	printf("\tAvg. Size: %d bytes + %d bits\n",
		272	stat_a[0].i_mbsize / (8 * stat_a[0].i_mbnum),
		273	(stat_a[0].i_mbsize * stat_a[0].i_mbnum) % 8);
		274	printf("\t\tCoded Block Pattern Histogram:\n");
		275	for (i = 0; i < 64; i += 8) {
		276	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].i_mbcbp[i],
		277	stat_a[0].i_mbcbp[i + 1], stat_a[0].i_mbcbp[i + 2], stat_a[0].i_mbcbp[i + 3],
		278	stat_a[0].i_mbcbp[i + 4], stat_a[0].i_mbcbp[i + 5], stat_a[0].i_mbcbp[i + 6],
		279	stat_a[0].i_mbcbp[i + 7]);
		280	}
		281	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		282	for (i = 0; i < 64; i += 8) {
		283	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].i_mbcoeff[i],
		284	stat_a[0].i_mbcoeff[i + 1], stat_a[0].i_mbcoeff[i + 2],
		285	stat_a[0].i_mbcoeff[i + 3], stat_a[0].i_mbcoeff[i + 4],
		286	stat_a[0].i_mbcoeff[i + 5], stat_a[0].i_mbcoeff[i + 6],
		287	stat_a[0].i_mbcoeff[i + 7]);
		288	}
		289	}
		290	if (stat_a[0].p_mbnum > 0) {
		291	printf("\tP Macro Block Stats:\n");
		292	printf("\t%d P Macroblocks\n", stat_a[0].p_mbnum);
		293	printf("\tAvg. Size: %d bytes + %d bits\n",
		294	stat_a[0].p_mbsize / (8 * stat_a[0].p_mbnum),
		295	(stat_a[0].p_mbsize / stat_a[0].p_mbnum) % 8);
		296	printf("\t\tCoded Block Pattern Histogram:\n");
		297	for (i = 0; i < 64; i += 8) {
		298	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].p_mbcbp[i],
		299	stat_a[0].p_mbcbp[i + 1], stat_a[0].p_mbcbp[i + 2], stat_a[0].p_mbcbp[i + 3],
		300	stat_a[0].p_mbcbp[i + 4], stat_a[0].p_mbcbp[i + 5], stat_a[0].p_mbcbp[i + 6],
		301	stat_a[0].p_mbcbp[i + 7]);
		302	}
		303	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		304	for (i = 0; i < 64; i += 8) {
		305	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].p_mbcoeff[i],
		306	stat_a[0].p_mbcoeff[i + 1], stat_a[0].p_mbcoeff[i + 2],
		307	stat_a[0].p_mbcoeff[i + 3], stat_a[0].p_mbcoeff[i + 4],
		308	stat_a[0].p_mbcoeff[i + 5], stat_a[0].p_mbcoeff[i + 6],
		309	stat_a[0].p_mbcoeff[i + 7]);
		310	}
		311	}
		312	if (stat_a[0].b_mbnum > 0) {
		313	printf("\tB Macro Block Stats:\n");
		314	printf("\t%d B Macroblocks\n", stat_a[0].b_mbnum);
		315	printf("\tAvg. Size: %d bytes + %d bits\n",
		316	stat_a[0].b_mbsize / (8 * stat_a[0].b_mbnum),
		317	(stat_a[0].b_mbsize / stat_a[0].b_mbnum) % 8);
		318	printf("\t\tCoded Block Pattern Histogram:\n");
		319	for (i = 0; i < 64; i += 8) {
		320	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].b_mbcbp[i],
		321	stat_a[0].b_mbcbp[i + 1], stat_a[0].b_mbcbp[i + 2], stat_a[0].b_mbcbp[i + 3],
		322	stat_a[0].b_mbcbp[i + 4], stat_a[0].b_mbcbp[i + 5], stat_a[0].b_mbcbp[i + 6],
		323	stat_a[0].b_mbcbp[i + 7]);
		324	}
		325	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		326	for (i = 0; i < 64; i += 8) {
		327	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].b_mbcoeff[i],
		328	stat_a[0].b_mbcoeff[i + 1], stat_a[0].b_mbcoeff[i + 2],
		329	stat_a[0].b_mbcoeff[i + 3], stat_a[0].b_mbcoeff[i + 4],
		330	stat_a[0].b_mbcoeff[i + 5], stat_a[0].b_mbcoeff[i + 6],
		331	stat_a[0].b_mbcoeff[i + 7]);
		332	}
		333	}
		334	if (stat_a[0].bi_mbnum > 0) {
		335	printf("\tBi Macro Block Stats:\n");
		336	printf("\t%d Bi Macroblocks\n", stat_a[0].bi_mbnum);
		337	printf("\tAvg. Size: %d bytes + %d bits\n",
		338	stat_a[0].bi_mbsize / (8 * stat_a[0].bi_mbnum),
		339	(stat_a[0].bi_mbsize * stat_a[0].bi_mbnum) % 8);
		340	printf("\t\tCoded Block Pattern Histogram:\n");
		341	for (i = 0; i < 64; i += 8) {
		342	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].bi_mbcbp[i],
		343	stat_a[0].bi_mbcbp[i + 1], stat_a[0].bi_mbcbp[i + 2], stat_a[0].bi_mbcbp[i + 3],
		344	stat_a[0].bi_mbcbp[i + 4], stat_a[0].bi_mbcbp[i + 5], stat_a[0].bi_mbcbp[i + 6],
		345	stat_a[0].bi_mbcbp[i + 7]);
		346	}
		347	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		348	for (i = 0; i < 64; i += 8) {
		349	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[0].bi_mbcoeff[i],
		350	stat_a[0].bi_mbcoeff[i + 1], stat_a[0].bi_mbcoeff[i + 2],
		351	stat_a[0].bi_mbcoeff[i + 3], stat_a[0].bi_mbcoeff[i + 4],
		352	stat_a[0].bi_mbcoeff[i + 5], stat_a[0].bi_mbcoeff[i + 6],
		353	stat_a[0].bi_mbcoeff[i + 7]);
		354	}
		355	}
		356	printf("\nTime to Decode: %g secs.\n", stat_a[0].tottime);
		357	printf("****************\n");
		358	}
		359
		360	void
		361	PrintAllStats(vid_stream)
		362	VidStream *vid_stream;
		363	{
		364	int i, j;
		365	unsigned int supertot, supernum;
		366	double supertime;
		367
		368	printf("\n");
		369	printf("General Info: \n");
		370	printf("Width: %d\nHeight: %d\n", vid_stream->mb_width * 16, vid_stream->mb_height * 16);
		371
		372	for (i = 1; i < 4; i++) {
		373
		374	if (stat_a[i].number == 0)
		375	continue;
		376
		377	switch (i) {
		378	case 1:
		379	printf("I FRAMES\n");
		380	break;
		381	case 2:
		382	printf("P FRAMES\n");
		383	break;
		384	case 3:
		385	printf("B FRAMES\n");
		386	break;
		387	}
		388
		389	printf("Number: %d\n", stat_a[i].number);
		390	printf("Avg. Size: %d bytes + %d bits\n",
		391	stat_a[i].totsize / (8 * stat_a[i].number), (stat_a[i].totsize / stat_a[i].number) % 8);
		392	if (stat_a[i].i_mbnum > 0) {
		393	printf("\tI Macro Block Stats:\n");
		394	printf("\t%d I Macroblocks\n", stat_a[i].i_mbnum);
		395	printf("\tAvg. Size: %d bytes + %d bits\n",
		396	stat_a[i].i_mbsize / (8 * stat_a[i].i_mbnum),
		397	(stat_a[i].i_mbsize / stat_a[i].i_mbnum) % 8);
		398	printf("\t\tCoded Block Pattern Histogram:\n");
		399	for (j = 0; j < 64; j += 8) {
		400	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].i_mbcbp[j],
		401	stat_a[i].i_mbcbp[j + 1], stat_a[i].i_mbcbp[j + 2], stat_a[i].i_mbcbp[j + 3],
		402	stat_a[i].i_mbcbp[j + 4], stat_a[i].i_mbcbp[j + 5], stat_a[i].i_mbcbp[j + 6],
		403	stat_a[i].i_mbcbp[j + 7]);
		404	}
		405	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		406	for (j = 0; j < 64; j += 8) {
		407	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].i_mbcoeff[j],
		408	stat_a[i].i_mbcoeff[j + 1], stat_a[i].i_mbcoeff[j + 2],
		409	stat_a[i].i_mbcoeff[j + 3], stat_a[i].i_mbcoeff[j + 4],
		410	stat_a[i].i_mbcoeff[j + 5], stat_a[i].i_mbcoeff[j + 6],
		411	stat_a[i].i_mbcoeff[j + 7]);
		412	}
		413	}
		414	if (stat_a[i].p_mbnum > 0) {
		415	printf("\tP Macro Block Stats:\n");
		416	printf("\t%d P Macroblocks\n", stat_a[i].p_mbnum);
		417	printf("\tAvg. Size: %d bytes + %d bits\n",
		418	stat_a[i].p_mbsize / (8 * stat_a[i].p_mbnum),
		419	(stat_a[i].p_mbsize / stat_a[i].p_mbnum) % 8);
		420	printf("\t\tCoded Block Pattern Histogram:\n");
		421	for (j = 0; j < 64; j += 8) {
		422	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].p_mbcbp[j],
		423	stat_a[i].p_mbcbp[j + 1], stat_a[i].p_mbcbp[j + 2], stat_a[i].p_mbcbp[j + 3],
		424	stat_a[i].p_mbcbp[j + 4], stat_a[i].p_mbcbp[j + 5], stat_a[i].p_mbcbp[j + 6],
		425	stat_a[i].p_mbcbp[j + 7]);
		426	}
		427	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		428	for (j = 0; j < 64; j += 8) {
		429	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].p_mbcoeff[j],
		430	stat_a[i].p_mbcoeff[j + 1], stat_a[i].p_mbcoeff[j + 2],
		431	stat_a[i].p_mbcoeff[j + 3], stat_a[i].p_mbcoeff[j + 4],
		432	stat_a[i].p_mbcoeff[j + 5], stat_a[i].p_mbcoeff[j + 6],
		433	stat_a[i].p_mbcoeff[j + 7]);
		434	}
		435	}
		436	if (stat_a[i].b_mbnum > 0) {
		437	printf("\tB Macro Block Stats:\n");
		438	printf("\t%d B Macroblocks\n", stat_a[i].b_mbnum);
		439	printf("\tAvg. Size: %d bytes + %d bits\n",
		440	stat_a[i].b_mbsize / (8 * stat_a[i].b_mbnum),
		441	(stat_a[i].b_mbsize * stat_a[i].b_mbnum) % 8);
		442	printf("\t\tCoded Block Pattern Histogram:\n");
		443	for (j = 0; j < 64; j += 8) {
		444	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].b_mbcbp[j],
		445	stat_a[i].b_mbcbp[j + 1], stat_a[i].b_mbcbp[j + 2], stat_a[i].b_mbcbp[j + 3],
		446	stat_a[i].b_mbcbp[j + 4], stat_a[i].b_mbcbp[j + 5], stat_a[i].b_mbcbp[j + 6],
		447	stat_a[i].b_mbcbp[j + 7]);
		448	}
		449	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		450	for (j = 0; j < 64; j += 8) {
		451	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].b_mbcoeff[j],
		452	stat_a[i].b_mbcoeff[j + 1], stat_a[i].b_mbcoeff[j + 2],
		453	stat_a[i].b_mbcoeff[j + 3], stat_a[i].b_mbcoeff[j + 4],
		454	stat_a[i].b_mbcoeff[j + 5], stat_a[i].b_mbcoeff[j + 6],
		455	stat_a[i].b_mbcoeff[j + 7]);
		456	}
		457	}
		458	if (stat_a[i].bi_mbnum > 0) {
		459	printf("\tBi Macro Block Stats:\n");
		460	printf("\t%d Bi Macroblocks\n", stat_a[i].bi_mbnum);
		461	printf("\tAvg. Size: %d bytes + %d bits\n",
		462	stat_a[i].bi_mbsize / (8 * stat_a[i].bi_mbnum),
		463	(stat_a[i].bi_mbsize * stat_a[i].bi_mbnum) % 8);
		464	printf("\t\tCoded Block Pattern Histogram:\n");
		465	for (j = 0; j < 64; j += 8) {
		466	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].bi_mbcbp[j],
		467	stat_a[i].bi_mbcbp[j + 1], stat_a[i].bi_mbcbp[j + 2], stat_a[i].bi_mbcbp[j + 3],
		468	stat_a[i].bi_mbcbp[j + 4], stat_a[i].bi_mbcbp[j + 5], stat_a[i].bi_mbcbp[j + 6],
		469	stat_a[i].bi_mbcbp[j + 7]);
		470	}
		471	printf("\n\t\tNumber of Coefficients/Block Histogram:\n");
		472	for (j = 0; j < 64; j += 8) {
		473	printf("\t%.6d %.6d %.6d %.6d %.6d %.6d %.6d %.6d\n", stat_a[i].bi_mbcoeff[j],
		474	stat_a[i].bi_mbcoeff[j + 1], stat_a[i].bi_mbcoeff[j + 2],
		475	stat_a[i].bi_mbcoeff[j + 3], stat_a[i].bi_mbcoeff[j + 4],
		476	stat_a[i].bi_mbcoeff[j + 5], stat_a[i].bi_mbcoeff[j + 6],
		477	stat_a[i].bi_mbcoeff[j + 7]);
		478	}
		479	}
		480	printf("\nAvg. Time to Decode: %f secs.\n",
		481	(stat_a[i].tottime / ((double) stat_a[i].number)));
		482	printf("\n");
		483	printf("*************************\n\n");
		484	}
		485
		486	supertot = stat_a[1].totsize + stat_a[2].totsize + stat_a[3].totsize;
		487	supernum = stat_a[1].number + stat_a[2].number + stat_a[3].number;
		488	supertime = stat_a[1].tottime + stat_a[2].tottime + stat_a[3].tottime;
		489
		490	printf("Total Number of Frames: %d\n", supernum);
		491	printf("Avg Frame Size: %d bytes %d bits\n",
		492	supertot / (8 * supernum), (supertot / supernum) % 8);
		493	printf("Total Time Decoding: %g secs.\n", supertime);
		494	printf("Avg Decoding Time/Frame: %g secs.\n", supertime / ((double) supernum));
		495	printf("Avg Decoding Frames/Sec: %g secs.\n", ((double) supernum) / supertime);
		496	printf("\n");
		497
		498	printf("Cache Hits/Miss\n");
		499	for (i = 0; i < 8; i++) {
		500	printf("%.6d/%.6d\t%.6d/%.6d\t%.6d/%.6d\t%.6d/%.6d\n",
		501	cacheHit[i][0], cacheMiss[i][0], cacheHit[i][1], cacheMiss[i][1],
		502	cacheHit[i][2], cacheMiss[i][2], cacheHit[i][3], cacheMiss[i][3]);
		503	printf("%.6d/%.6d\t%.6d/%.6d\t%.6d/%.6d\t%.6d/%.6d\n",
		504	cacheHit[i][4], cacheMiss[i][4], cacheHit[i][5], cacheMiss[i][5],
		505	cacheHit[i][6], cacheMiss[i][6], cacheHit[i][7], cacheMiss[i][7]);
		506	}
		507
		508	}
		509
		510	static void
		511	CollectStats()
		512	{
		513	int i, j;
		514
		515	i = stat_a[0].frametype;
		516
		517	stat_a[i].totsize += stat_a[0].totsize;
		518	stat_a[i].number += stat_a[0].number;
		519	stat_a[i].i_mbsize += stat_a[0].i_mbsize;
		520	stat_a[i].p_mbsize += stat_a[0].p_mbsize;
		521	stat_a[i].b_mbsize += stat_a[0].b_mbsize;
		522	stat_a[i].bi_mbsize += stat_a[0].bi_mbsize;
		523	stat_a[i].i_mbnum += stat_a[0].i_mbnum;
		524	stat_a[i].p_mbnum += stat_a[0].p_mbnum;
		525	stat_a[i].b_mbnum += stat_a[0].b_mbnum;
		526	stat_a[i].bi_mbnum += stat_a[0].bi_mbnum;
		527
		528	for (j = 0; j < 64; j++) {
		529
		530	stat_a[i].i_mbcbp[j] += stat_a[0].i_mbcbp[j];
		531	stat_a[i].p_mbcbp[j] += stat_a[0].p_mbcbp[j];
		532	stat_a[i].b_mbcbp[j] += stat_a[0].b_mbcbp[j];
		533	stat_a[i].bi_mbcbp[j] += stat_a[0].bi_mbcbp[j];
		534	stat_a[i].i_mbcoeff[j] += stat_a[0].i_mbcoeff[j];
		535	stat_a[i].p_mbcoeff[j] += stat_a[0].p_mbcoeff[j];
		536	stat_a[i].b_mbcoeff[j] += stat_a[0].b_mbcoeff[j];
		537	stat_a[i].bi_mbcoeff[j] += stat_a[0].bi_mbcoeff[j];
		538	}
		539
		540	stat_a[i].tottime += stat_a[0].tottime;
		541
		542	init_stat_struct(&(stat_a[0]));
		543	}
		544
		545	static unsigned int
		546	bitCountRead()
		547	{
		548	return bitCount;
		549	}
		550
		551	static void
		552	StartTime()
		553	{
		554	stat_a[0].tottime = ReadSysClock();
		555	}
		556
		557	static void
		558	EndTime()
		559	{
		560	stat_a[0].tottime = ReadSysClock() - stat_a[0].tottime;
		561	}
		562	#endif
		563
		564
		565	/*
		566	*--------------------------------------------------------------
		567	*
		568	* ReadSysClock --
		569	*
		570	* Computes the current time according to the system clock.
		571	*
		572	* Results:
		573	* The current time according to the system clock.
		574	*
		575	* Side effects:
		576	* None.
		577	*
		578	*--------------------------------------------------------------
		579	*/
		580
		581	double
		582	ReadSysClock()
		583	{
		584	extern long sys_gettime(void*);
		585	/*struct timeval tv;
		586	(void) gettimeofday(&tv, (struct timezone *)NULL);
		587	return (tv.tv_sec + tv.tv_usec / 1000000.0);*/
		588	//return sys_time();
		589	return sys_gettime(NULL)/1000000.0;
		590	}
		591
		592
		593	/*
		594	*--------------------------------------------------------------
		595	*
		596	* PrintTimeInfo --
		597	*
		598	* Displays statistics regarding the video playback time.
		599	*
		600	* Results:
		601	* Outputs time statistics to the screen.
		602	*
		603	* Side effects:
		604	* None.
		605	*
		606	*--------------------------------------------------------------
		607	*/
		608
		609	void
		610	PrintTimeInfo(vid_stream)
		611	VidStream *vid_stream;
		612	{
		613	double spent;
		614
		615	#ifndef NOCONTROLS
		616	if (ControlShow != CTRLBAR_NONE)
		617	spent = StopWatch(STOPWATCH_STOP);
		618	else
		619	spent = ReadSysClock() - vid_stream->realTimeStart;
		620	#else
		621	spent = ReadSysClock() - vid_stream->realTimeStart;
		622	#endif
		623	if (!quietFlag) {
		624	printf("\nReal Time Spent (After Initializations): %f secs.\n", spent);
		625	printf("Avg. Frames/Sec: %f\n",
		626	((double) vid_stream->totNumFrames) / spent);
		627	}
		628	}
		629
		630
		631	/*
		632	*--------------------------------------------------------------
		633	*
		634	* InitCrop --
		635	*
		636	* Initializes cropTbl - this was taken from newVidStream so
		637	* that it wasn't done for each new video stream
		638	*
		639	* Results:
		640	* None
		641	*
		642	* Side effects:
		643	* cropTbl will be initialized
		644	*
		645	*--------------------------------------------------------------
		646	*/
		647	void
		648	InitCrop()
		649	{
		650	int i;
		651
		652	/* Initialize crop table. */
		653
		654	for (i = (-MAX_NEG_CROP); i < NUM_CROP_ENTRIES - MAX_NEG_CROP; i++) {
		655	if (i <= 0) {
		656	cropTbl[i + MAX_NEG_CROP] = 0;
		657	#ifdef TWELVE_BITS
		658	} else if (i >= 2047) {
		659	cropTbl[i + MAX_NEG_CROP] = 2047;
		660	#endif
		661	} else if (i >= 255) {
		662	cropTbl[i + MAX_NEG_CROP] = 255;
		663	} else {
		664	cropTbl[i + MAX_NEG_CROP] = i;
		665	}
		666	}
		667
		668	}
		669
		670
		671
		672	/*
		673	*--------------------------------------------------------------
		674	*
		675	* NewVidStream --
		676	*
		677	* Allocates and initializes a VidStream structure. Takes
		678	* as parameter requested size for buffer length.
		679	*
		680	* Results:
		681	* A pointer to the new VidStream structure.
		682	*
		683	* Side effects:
		684	* None.
		685	*
		686	*--------------------------------------------------------------
		687	*/
		688
		689	VidStream *
		690	NewVidStream(buffer_len)
		691	unsigned int buffer_len;
		692	{
		693	int i, j;
		694	VidStream *new;
		695	static const unsigned char default_intra_matrix[64] = {
		696	8, 16, 19, 22, 26, 27, 29, 34,
		697	16, 16, 22, 24, 27, 29, 34, 37,
		698	19, 22, 26, 27, 29, 34, 34, 38,
		699	22, 22, 26, 27, 29, 34, 37, 40,
		700	22, 26, 27, 29, 32, 35, 40, 48,
		701	26, 27, 29, 32, 35, 40, 48, 58,
		702	26, 27, 29, 34, 38, 46, 56, 69,
		703	27, 29, 35, 38, 46, 56, 69, 83};
		704
		705	/* Check for legal buffer length. */
		706
		707	if (buffer_len < 4)
		708	return NULL;
		709
		710	/* Make buffer length multiple of 4. */
		711
		712	buffer_len = (buffer_len + 3) >> 2;
		713
		714	/* Allocate memory for new structure. */
		715
		716	new = (VidStream *) malloc(sizeof(VidStream));
		717
		718	/* Initialize pointers to extension and user data. */
		719
		720	new->group.ext_data = new->group.user_data =
		721	new->picture.extra_info = new->picture.user_data =
		722	new->picture.ext_data = new->slice.extra_info =
		723	new->ext_data = new->user_data = NULL;
		724
		725	/* Copy default intra matrix. */
		726
		727	for (i = 0; i < 8; i++) {
		728	for (j = 0; j < 8; j++) {
		729	new->intra_quant_matrix[i][j] = default_intra_matrix[i * 8 + j];
		730	}
		731	}
		732
		733	/* Initialize non intra quantization matrix. */
		734
		735	for (i = 0; i < 8; i++) {
		736	for (j = 0; j < 8; j++) {
		737	new->non_intra_quant_matrix[i][j] = 16;
		738	}
		739	}
		740
		741	/* Initialize pointers to image spaces. */
		742
		743	new->current = new->past = new->future = NULL;
		744	for (i = 0; i < RING_BUF_SIZE; i++) {
		745	new->ring[i] = NULL;
		746	}
		747
		748	/* Create buffer. */
		749
		750	new->buf_start = (unsigned int ) malloc(buffer_len 4);
		751
		752	/*
		753	* Set max_buf_length to one less than actual length to deal with messy
		754	* data without proper seq. end codes.
		755	*/
		756
		757	new->max_buf_length = buffer_len - 1;
		758
		759	/* Initialize bitstream i/o fields. */
		760
		761	new->bit_offset = 0;
		762	new->buf_length = 0;
		763	new->buffer = new->buf_start;
		764
		765	/* Initialize fields that used to be global */
		766	new->film_has_ended = FALSE;
		767	new->filename = NULL;
		768	new->totNumFrames = 0;
		769	new->ditherFlags = NULL;
		770	new->EOF_flag = FALSE;
		771
		772	/* Return structure. */
		773
		774	return new;
		775	}
		776
		777
		778
		779	/*
		780	*--------------------------------------------------------------
		781	*
		782	* ResetVidStream --
		783	*
		784	* Re-initializes a VidStream structure. Takes
		785	* as parameter a pointer to the VidStream to reset.
		786	*
		787	* Results:
		788	* None.
		789	*
		790	* Side effects:
		791	* None.
		792	*
		793	*--------------------------------------------------------------
		794	*/
		795
		796	void
		797	ResetVidStream(vid)
		798	VidStream *vid;
		799	{
		800	int i;
		801
		802	/* Initialize pointers to image spaces. */
		803	vid->current = vid->past = vid->future = NULL;
		804
		805	/* Initialize rings */
		806	for (i = 0; i < RING_BUF_SIZE; i++)
		807	vid->ring[i]->locked = 0; /* Unlock */
		808
		809	/* Initialize bitstream i/o fields. */
		810	vid->bit_offset = vid->buf_length = 0;
		811	vid->buffer = vid->buf_start;
		812	vid->curBits = 0;
		813
		814	/* We are at the beginning of the film, so film has not ended */
		815	vid->film_has_ended = FALSE;
		816
		817	/* Initialize start time */
		818	vid->realTimeStart = ReadSysClock();
		819
		820	/* Reset number of frames to zero */
		821	vid->totNumFrames=0;
		822
		823	/* Reset EOF_flag to 0 */
		824	vid->EOF_flag = 0;
		825	}
		826
		827
		828	/*
		829	*--------------------------------------------------------------
		830	*
		831	* DestroyVidStream --
		832	*
		833	* Deallocates a VidStream structure.
		834	*
		835	* Results:
		836	* None.
		837	*
		838	* Side effects:
		839	* None.
		840	*
		841	*--------------------------------------------------------------
		842	*/
		843	void
		844	DestroyVidStream(astream, xinfo)
		845	VidStream *astream;
		846	XInfo *xinfo;
		847	{
		848	int i;
		849
		850	if (astream->ext_data != NULL)
		851	free(astream->ext_data);
		852
		853	if (astream->user_data != NULL)
		854	free(astream->user_data);
		855
		856	if (astream->group.ext_data != NULL)
		857	free(astream->group.ext_data);
		858
		859	if (astream->group.user_data != NULL)
		860	free(astream->group.user_data);
		861
		862	if (astream->picture.extra_info != NULL)
		863	free(astream->picture.extra_info);
		864
		865	if (astream->picture.ext_data != NULL)
		866	free(astream->picture.ext_data);
		867
		868	if (astream->picture.user_data != NULL)
		869	free(astream->picture.user_data);
		870
		871	if (astream->slice.extra_info != NULL)
		872	free(astream->slice.extra_info);
		873
		874	if (astream->buf_start != NULL)
		875	free(astream->buf_start);
		876
		877	for (i = 0; i < RING_BUF_SIZE; i++) {
		878	if (astream->ring[i] != NULL) {
		879	DestroyPictImage(astream->ring[i], xinfo);
		880	astream->ring[i] = NULL;
		881	}
		882	}
		883
		884	if (astream->ditherFlags !=NULL)
		885	free(astream->ditherFlags);
		886
		887	free((char *) astream);
		888	}
		889
		890
		891
		892
		893	/*
		894	*--------------------------------------------------------------
		895	*
		896	* NewPictImage --
		897	*
		898	* Allocates and initializes a PictImage structure.
		899	* The width and height of the image space are passed in
		900	* as parameters.
		901	*
		902	* Results:
		903	* A pointer to the new PictImage structure.
		904	*
		905	* Side effects:
		906	* None.
		907	*
		908	*--------------------------------------------------------------
		909	*/
		910
		911	PictImage *
		912	NewPictImage(vid_stream,xinfo)
		913	VidStream *vid_stream;
		914	XInfo *xinfo;
		915	{
		916	PictImage *new;
		917	int ditherType=vid_stream->ditherType;
		918	unsigned int width=vid_stream->mb_width * 16;
		919	unsigned int height=vid_stream->mb_height * 16;
		920	#ifdef SH_MEM
		921	Display *display=xinfo->display;
		922	#endif
		923
		924	/* Allocate memory space for new structure. */
		925
		926	new = (PictImage *) malloc(sizeof(PictImage));
		927
		928
		929	/* Allocate memory for image spaces. */
		930
		931	#ifdef SH_MEM
		932	new->ximage = NULL;
		933
		934	if (shmemFlag) {
		935	Visual *fc_visual;
		936	int depth;
		937	/*
		938	* factor is 1 or 2
		939	*/
		940	int factor = 1 + IS_2x2_DITHER(ditherType);
		941
		942	Visual *FindFullColorVisual();
		943
		944	#ifndef DISABLE_DITHER
		945	if (ditherType == FULL_COLOR_DITHER \|\| ditherType == FULL_COLOR2_DITHER) {
		946	#endif
		947	fc_visual = FindFullColorVisual(display, &depth);
		948	new->ximage = XShmCreateImage(display, fc_visual, (unsigned int) depth,
		949	ZPixmap,
		950	NULL, &(new->shminfo), width * factor,
		951	height * factor);
		952	#ifndef DISABLE_DITHER
		953	} else if (ditherType == FULL_COLOR2_DITHER) {
		954	fc_visual = FindFullColorVisual(display, &depth);
		955	new->ximage = XShmCreateImage(display, fc_visual, (unsigned int) depth,
		956	ZPixmap,
		957	NULL, &(new->shminfo), width2, height2);
		958	} else if (ditherType == MONO_DITHER \|\| ditherType == MONO_THRESHOLD) {
		959	new->ximage = XShmCreateImage(display, None, 1, XYBitmap,
		960	NULL, &(new->shminfo), width * factor,
		961	height * factor);
		962	} else {
		963	new->ximage = XShmCreateImage(display, None, xinfo->depth, ZPixmap, NULL,
		964	&(new->shminfo), width * factor,
		965	height * factor);
		966	}
		967	#endif
		968
		969	/* If no go, then revert to normal Xlib calls. */
		970
		971	if (new->ximage == NULL) {
		972	shmemFlag = 0;
		973	if (!quietFlag) {
		974	fprintf(stderr, "Shared memory error, disabling.\n");
		975	fprintf(stderr, "Ximage error.\n");
		976	}
		977	goto shmemerror;
		978	}
		979
		980	/* Success here, continue. */
		981
		982	#ifdef LITTLE_ENDIAN_ARCHITECTURE
		983	new->ximage->byte_order = LSBFirst;
		984	new->ximage->bitmap_bit_order = LSBFirst;
		985	#else
		986	new->ximage->byte_order = MSBFirst;
		987	new->ximage->bitmap_bit_order = MSBFirst;
		988	#endif
		989
		990	new->shminfo.shmid = shmget(IPC_PRIVATE, (unsigned int) (new->ximage->bytes_per_line *
		991	new->ximage->height),
		992	IPC_CREAT \| 0777);
		993
		994	if (new->shminfo.shmid < 0) {
		995	XDestroyImage(new->ximage);
		996	new->ximage = NULL;
		997	shmemFlag = 0;
		998	if (!quietFlag) {
		999	fprintf(stderr, "Shared memory error, disabling.\n");
		1000	fprintf(stderr, "Seg. id. error.\n");
		1001	}
		1002	goto shmemerror;
		1003	}
		1004
		1005	new->shminfo.shmaddr = (char *) shmat(new->shminfo.shmid, 0, 0);
		1006
		1007	if (new->shminfo.shmaddr == ((char *) -1)) {
		1008	XDestroyImage(new->ximage);
		1009	new->ximage = NULL;
		1010	shmemFlag = 0;
		1011	if (!quietFlag) {
		1012	fprintf(stderr, "Shared memory error, disabling.\n");
		1013	fprintf(stderr, "Address error.\n");
		1014	}
		1015	goto shmemerror;
		1016	}
		1017
		1018	new->ximage->data = new->shminfo.shmaddr;
		1019	new->display = (unsigned char *) new->ximage->data;
		1020	new->shminfo.readOnly = False;
		1021
		1022	XShmAttach(display, &(new->shminfo));
		1023	XSync(display, False);
		1024
		1025	if (gXErrorFlag) {
		1026	/* Ultimate failure here. */
		1027	XShmDetach(display,&(new->shminfo));
		1028	XSync(display, False);
		1029	XDestroyImage(new->ximage);
		1030	shmdt (new->shminfo.shmaddr);
		1031	shmctl (new->shminfo.shmid, IPC_RMID, 0);
		1032	new->ximage = NULL;
		1033	shmemFlag = 0;
		1034	if (!quietFlag) {
		1035	fprintf(stderr, "Shared memory error, disabling.\n");
		1036	}
		1037	gXErrorFlag = 0;
		1038	goto shmemerror;
		1039	} else {
		1040	shmctl(new->shminfo.shmid, IPC_RMID, 0);
		1041	}
		1042
		1043	if (!quietFlag) {
		1044	fprintf(stderr, "Sharing memory.\n");
		1045	}
		1046	} else
		1047	#endif
		1048	{
		1049	int temp_sz;
		1050	int factor;
		1051	shmemerror:
		1052	#ifndef DISABLE_DITHER
		1053	temp_sz = vid_stream->matched_depth >> 3;
		1054	#else
		1055	temp_sz = 4;
		1056	#endif
		1057	if(!temp_sz) temp_sz = 1;
		1058	if(temp_sz == 3) temp_sz = 4;
		1059	factor = 1 + IS_2x2_DITHER(ditherType); /* 1 or 2 */
		1060
		1061	new->display = (unsigned char ) malloc(width height * temp_sz *
		1062	factor * factor);
		1063	}
		1064	new->luminance = (unsigned char ) malloc(width height);
		1065	new->Cr = (unsigned char ) malloc(width height / 4);
		1066	new->Cb = (unsigned char ) malloc(width height / 4);
		1067
		1068	/* Reset locked flag. */
		1069
		1070	new->locked = 0;
		1071
		1072	/* Return pointer to new structure. */
		1073
		1074	return new;
		1075	}
		1076
		1077
		1078
		1079	/*
		1080	*--------------------------------------------------------------
		1081	*
		1082	* DestroyPictImage --
		1083	*
		1084	* Deallocates a PictImage structure.
		1085	*
		1086	* Results:
		1087	* None.
		1088	*
		1089	* Side effects:
		1090	* None.
		1091	*
		1092	*--------------------------------------------------------------
		1093	*/
		1094	void
		1095	DestroyPictImage(apictimage, xinfo)
		1096	PictImage *apictimage;
		1097	XInfo *xinfo;
		1098	{
		1099	if (apictimage->luminance != NULL) {
		1100	free(apictimage->luminance);
		1101	}
		1102	if (apictimage->Cr != NULL) {
		1103	free(apictimage->Cr);
		1104	}
		1105	if (apictimage->Cb != NULL) {
		1106	free(apictimage->Cb);
		1107	}
		1108	#ifdef SH_MEM
		1109	if ((apictimage->ximage != NULL)&&!noDisplayFlag&&shmemFlag) {
		1110	if (xinfo!=NULL) XShmDetach(xinfo->display, &(apictimage->shminfo));
		1111	XDestroyImage(apictimage->ximage);
		1112	shmdt(apictimage->shminfo.shmaddr);
		1113	apictimage->ximage = NULL;
		1114	apictimage->display = NULL;
		1115	}
		1116	#endif
		1117
		1118	if (apictimage->display != NULL) {
		1119	free(apictimage->display);
		1120	}
		1121	free(apictimage);
		1122	}
		1123
		1124
		1125	/*
		1126	*--------------------------------------------------------------
		1127	*
		1128	* mpegVidRsrc --
		1129	*
		1130	* Parses bit stream until MB_QUANTUM number of
		1131	* macroblocks have been decoded or current slice or
		1132	* picture ends, whichever comes first. If the start
		1133	* of a frame is encountered, the frame is time stamped
		1134	* with the value passed in time_stamp. If the value
		1135	* passed in buffer is not null, the video stream buffer
		1136	* is set to buffer and the length of the buffer is
		1137	* expected in value passed in through length. The current
		1138	* video stream is set to vid_stream. If vid_stream
		1139	* is passed as NULL, a new VidStream structure is created
		1140	* and initialized and used as the current video stream.
		1141	*
		1142	* Results:
		1143	* A pointer to the video stream structure used.
		1144	*
		1145	* Side effects:
		1146	* Bit stream is irreversibly parsed. If a picture is completed,
		1147	* a function is called to display the frame at the correct time.
		1148	*
		1149	*--------------------------------------------------------------
		1150	*/
		1151
		1152	VidStream *
		1153	mpegVidRsrc(time_stamp, vid_stream, first, xinfo)
		1154	TimeStamp time_stamp;
		1155	VidStream *vid_stream;
		1156	int first;
		1157	XInfo *xinfo;
		1158	{
		1159	unsigned int data;
		1160	int i, status;
		1161
		1162	/* If vid_stream is null, create new VidStream structure. */
		1163
		1164	if (vid_stream == NULL) {
		1165	return NULL;
		1166	}
		1167
		1168	/*
		1169	* If called for the first time, find start code, make sure it is a
		1170	* sequence start code.
		1171	*/
		1172
		1173	if (first) {
		1174	vid_stream->sys_layer=-1;
		1175	vid_stream->num_left=0;
		1176	vid_stream->leftover_bytes=0;
		1177	vid_stream->seekValue=0;
		1178	vid_stream->Parse_done=FALSE;
		1179	next_start_code(vid_stream); /* sets curBits */
		1180	show_bits32(data);
		1181	if (data != SEQ_START_CODE) {
		1182	fprintf(stderr, "This is not an MPEG video stream. (%x)\n",data);
		1183	DestroyVidStream(vid_stream,xinfo);
		1184	return NULL;
		1185	}
		1186	} else {
		1187	#ifdef UTIL2
		1188	vid_stream->curBits = *vid_stream->buffer << vid_stream->bit_offset;
		1189	#else
		1190	vid_stream->curBits = *vid_stream->buffer;
		1191	#endif
		1192	}
		1193
		1194	/* Get next 32 bits (size of start codes). */
		1195
		1196	show_bits32(data);
		1197
		1198	/*
		1199	* Process according to start code (or parse macroblock if not a start code
		1200	* at all).
		1201	*/
		1202
		1203	switch (data) {
		1204
		1205	case SEQ_END_CODE:
		1206	case 0x000001b9: /* handle ISO_11172_END_CODE too */
		1207
		1208	/* Display last frame. */
		1209
		1210	if (vid_stream->future != NULL) {
		1211	vid_stream->current = vid_stream->future;
		1212	#ifndef NOCONTROLS
		1213	ExecuteDisplay(vid_stream, 1, xinfo);
		1214	#else
		1215	ExecuteDisplay(vid_stream, xinfo);
		1216	#endif
		1217	}
		1218
		1219	/* Sequence done. Do the right thing. For right now, exit. */
		1220	if (!quietFlag) {
		1221	fprintf(stderr, "\nDone!\n");
		1222	}
		1223
		1224	#ifdef ANALYSIS
		1225	PrintAllStats(vid_stream);
		1226	#endif
		1227	PrintTimeInfo(vid_stream);
		1228
		1229	vid_stream->film_has_ended=TRUE;
		1230	#ifdef NOCONTROLS
		1231	if (loopFlag) {
		1232	clear_data_stream(vid_stream);
		1233	} else DestroyVidStream(vid_stream, xinfo);
		1234	#endif /* !NOCONTROLS */
		1235	goto done;
		1236	break;
		1237
		1238	case SEQ_START_CODE:
		1239
		1240	/* Sequence start code. Parse sequence header. */
		1241
		1242	if (ParseSeqHead(vid_stream,xinfo) != PARSE_OK)
		1243	goto error;
		1244
		1245	/*
		1246	* Return after sequence start code so that application above can use
		1247	* info in header.
		1248	*/
		1249	if (vid_stream->seekValue > 0) {
		1250	SeekStream(vid_stream);
		1251	}
		1252
		1253
		1254	goto done;
		1255
		1256	case GOP_START_CODE:
		1257
		1258	/* Group of Pictures start code. Parse gop header. */
		1259
		1260	if (ParseGOP(vid_stream) != PARSE_OK)
		1261	goto error;
		1262	goto done;
		1263
		1264	case PICTURE_START_CODE:
		1265
		1266	/* Picture start code. Parse picture header and first slice header. */
		1267
		1268	status = ParsePicture(vid_stream, time_stamp);
		1269
		1270	if (status == SKIP_PICTURE) {
		1271	next_start_code(vid_stream);
		1272	while (!next_bits(32, PICTURE_START_CODE, vid_stream)) {
		1273	if (next_bits(32, GOP_START_CODE, vid_stream))
		1274	break;
		1275	else if (next_bits(32, SEQ_END_CODE, vid_stream))
		1276	break;
		1277	flush_bits(24);
		1278	next_start_code(vid_stream);
		1279	}
		1280	goto done;
		1281	} else if (status != PARSE_OK)
		1282	goto error;
		1283
		1284
		1285	if (ParseSlice(vid_stream) != PARSE_OK)
		1286	goto error;
		1287	break;
		1288
		1289	case SEQUENCE_ERROR_CODE:
		1290	flush_bits32;
		1291	next_start_code(vid_stream);
		1292	goto done;
		1293
		1294	default:
		1295
		1296	/* Check for slice start code. */
		1297
		1298	if ((data >= SLICE_MIN_START_CODE) && (data <= SLICE_MAX_START_CODE)) {
		1299
		1300	/* Slice start code. Parse slice header. */
		1301
		1302	if (ParseSlice(vid_stream) != PARSE_OK)
		1303	goto error;
		1304	}
		1305	break;
		1306	}
		1307
		1308	/* Parse next MB_QUANTUM macroblocks. */
		1309
		1310	for (i = 0; i < MB_QUANTUM; i++) {
		1311
		1312	/* Check to see if actually a startcode and not a macroblock. */
		1313
		1314	if (!next_bits(23, 0x00000000, vid_stream)) {
		1315
		1316	/* Not start code. Parse Macroblock. */
		1317
		1318	if (ParseMacroBlock(vid_stream) != PARSE_OK)
		1319	goto error;
		1320
		1321	#ifdef ANALYSIS
		1322	if (showmb_flag) {
		1323	DoDitherImage(vid_stream);
		1324	#ifndef NOCONTROLS
		1325	ExecuteDisplay(vid_stream, 1, xinfo);
		1326	#else
		1327	ExecuteDisplay(vid_stream, xinfo);
		1328	#endif /* !NOCONTROLS */
		1329	}
		1330	#endif /* ANALYSIS */
		1331
		1332	} else {
		1333
		1334	/* Not macroblock, actually start code. Get start code. */
		1335
		1336	next_start_code(vid_stream);
		1337	show_bits32(data);
		1338
		1339	/*
		1340	* If start code is outside range of slice start codes, frame is
		1341	* complete, display frame.
		1342	*/
		1343
		1344	if (((data < SLICE_MIN_START_CODE) \|\| (data > SLICE_MAX_START_CODE)) &&
		1345	(data != SEQUENCE_ERROR_CODE)) {
		1346
		1347	#ifdef ANALYSIS
		1348	EndTime();
		1349	stat_a[0].totsize += bitCountRead() - pictureSizeCount;
		1350	if (showEachFlag) {
		1351	PrintOneStat();
		1352	};
		1353
		1354	CollectStats();
		1355	#endif
		1356
		1357	DoPictureDisplay(vid_stream, xinfo);
		1358	}
		1359	goto done;
		1360	}
		1361	}
		1362
		1363	/* Check if we just finished a picture on the MB_QUANTUMth macroblock */
		1364	if (next_bits(23, 0x00000000, vid_stream)) {
		1365	next_start_code(vid_stream);
		1366	show_bits32(data);
		1367	if ((data < SLICE_MIN_START_CODE) \|\| (data > SLICE_MAX_START_CODE)) {
		1368
		1369	#ifdef ANALYSIS
		1370	EndTime();
		1371	stat_a[0].totsize += bitCountRead() - pictureSizeCount;
		1372	if (showEachFlag) {
		1373	PrintOneStat();
		1374	};
		1375
		1376	CollectStats();
		1377	#endif
		1378
		1379	DoPictureDisplay(vid_stream, xinfo);
		1380	}
		1381	}
		1382
		1383	/* Return pointer to video stream structure. */
		1384
		1385	goto done;
		1386
		1387	error:
		1388	fprintf(stderr, "Error!!!!\n");
		1389	next_start_code(vid_stream);
		1390	goto done;
		1391
		1392	done:
		1393
		1394	return vid_stream;
		1395
		1396	}
		1397
		1398
		1399
		1400
		1401	/*
		1402	*--------------------------------------------------------------
		1403	*
		1404	* ParseSeqHead --
		1405	*
		1406	* Assumes bit stream is at the begining of the sequence
		1407	* header start code. Parses off the sequence header.
		1408	*
		1409	* Results:
		1410	* Fills the vid_stream structure with values derived and
		1411	* decoded from the sequence header. Allocates the pict image
		1412	* structures based on the dimensions of the image space
		1413	* found in the sequence header.
		1414	*
		1415	* Side effects:
		1416	* Bit stream irreversibly parsed off.
		1417	*
		1418	*--------------------------------------------------------------
		1419	*/
		1420	static int
		1421	ParseSeqHead(vid_stream,xinfo)
		1422	VidStream *vid_stream;
		1423	XInfo *xinfo;
		1424	{
		1425	unsigned int data;
		1426	int i, ditherType=vid_stream->ditherType;
		1427
		1428	/* Flush off sequence start code. */
		1429
		1430	flush_bits32;
		1431
		1432	/* Get horizontal size of image space. */
		1433
		1434	get_bits12(data);
		1435	vid_stream->h_size = data;
		1436
		1437	/* Get vertical size of image space. */
		1438
		1439	get_bits12(data);
		1440	vid_stream->v_size = data;
		1441
		1442	/* Calculate macroblock width and height of image space. */
		1443
		1444	vid_stream->mb_width = (vid_stream->h_size + 15) / 16;
		1445	vid_stream->mb_height = (vid_stream->v_size + 15) / 16;
		1446
		1447	#ifndef DISABLE_DITHER
		1448	/* If dither type is MBORDERED allocate ditherFlags. */
		1449	if (ditherType == MBORDERED_DITHER) {
		1450	vid_stream->ditherFlags =
		1451	(char ) malloc(vid_stream->mb_widthvid_stream->mb_height);
		1452	}
		1453	#endif
		1454
		1455	/*
		1456	* Initialize ring buffer of pict images now that dimensions of image space
		1457	* are known.
		1458	*/
		1459
		1460	#ifdef SH_MEM
		1461	if (xinfo->display != NULL) {
		1462	InstallXErrorHandler(xinfo->display);
		1463	}
		1464	#endif
		1465
		1466	if (vid_stream->ring[0] == NULL) {
		1467	for (i = 0; i < RING_BUF_SIZE; i++) {
		1468	vid_stream->ring[i] = NewPictImage(vid_stream,xinfo);
		1469	}
		1470	}
		1471	#ifdef SH_MEM
		1472	if (xinfo->display != NULL) {
		1473	DeInstallXErrorHandler(xinfo->display);
		1474	}
		1475	#endif
		1476
		1477	/* Parse of aspect ratio code. */
		1478
		1479	get_bits4(data);
		1480	vid_stream->aspect_ratio = (unsigned char) data;
		1481
		1482	/* Parse off picture rate code. */
		1483
		1484	get_bits4(data);
		1485	vid_stream->picture_rate = (unsigned char) data;
		1486
		1487	/* Parse off bit rate. */
		1488
		1489	get_bits18(data);
		1490	vid_stream->bit_rate = data;
		1491
		1492	/* Flush marker bit. */
		1493
		1494	flush_bits(1);
		1495
		1496	/* Parse off vbv buffer size. */
		1497
		1498	get_bits10(data);
		1499	vid_stream->vbv_buffer_size = data;
		1500
		1501	#ifdef not_def
		1502	/* Lets not bother with this. Only increases memory image */
		1503	if (data*1024>vid_stream->max_buf_length) {
		1504	unsigned int *newbuf;
		1505	int sz=1024*data+1;
		1506	/* If they actually want a bigger buffer than we default to,
		1507	let them have it! (if we can) */
		1508	newbuf = (unsigned int ) realloc(vid_stream->buf_start, (unsigned int) 4sz);
		1509	if (newbuf!=(unsigned int *)NULL) {
		1510	vid_stream->max_buf_length=sz;
		1511	vid_stream->buffer=
		1512	(vid_stream->buffer-vid_stream->buf_start)+newbuf;
		1513	vid_stream->buf_start=newbuf;
		1514	}}
		1515	#endif
		1516
		1517	/* Parse off contrained parameter flag. */
		1518
		1519	get_bits1(data);
		1520	if (data) {
		1521	vid_stream->const_param_flag = TRUE;
		1522	} else
		1523	vid_stream->const_param_flag = FALSE;
		1524
		1525	/*
		1526	* If intra_quant_matrix_flag set, parse off intra quant matrix values.
		1527	*/
		1528
		1529	get_bits1(data);
		1530	if (data) {
		1531	for (i = 0; i < 64; i++) {
		1532	get_bits8(data);
		1533
		1534	vid_stream->intra_quant_matrix[zigzag[i][1]][zigzag[i][0]] =
		1535	(unsigned char) data;
		1536	}
		1537	}
		1538	/*
		1539	* If non intra quant matrix flag set, parse off non intra quant matrix
		1540	* values.
		1541	*/
		1542
		1543	get_bits1(data);
		1544	if (data) {
		1545	for (i = 0; i < 64; i++) {
		1546	get_bits8(data);
		1547
		1548	vid_stream->non_intra_quant_matrix[zigzag[i][1]][zigzag[i][0]] =
		1549	(unsigned char) data;
		1550	}
		1551	}
		1552	/* Go to next start code. */
		1553
		1554	next_start_code(vid_stream);
		1555
		1556	/*
		1557	* If next start code is extension start code, parse off extension data.
		1558	*/
		1559
		1560	if (next_bits(32, EXT_START_CODE, vid_stream)) {
		1561	flush_bits32;
		1562	if (vid_stream->ext_data != NULL) {
		1563	free(vid_stream->ext_data);
		1564	vid_stream->ext_data = NULL;
		1565	}
		1566	vid_stream->ext_data = get_ext_data(vid_stream);
		1567	}
		1568	/* If next start code is user start code, parse off user data. */
		1569
		1570	if (next_bits(32, USER_START_CODE, vid_stream)) {
		1571	flush_bits32;
		1572	if (vid_stream->user_data != NULL) {
		1573	free(vid_stream->user_data);
		1574	vid_stream->user_data = NULL;
		1575	}
		1576	vid_stream->user_data = get_ext_data(vid_stream);
		1577	}
		1578	return PARSE_OK;
		1579	}
		1580
		1581
		1582
		1583	/*
		1584	*--------------------------------------------------------------
		1585	*
		1586	* ParseGOP --
		1587	*
		1588	* Parses of group of pictures header from bit stream
		1589	* associated with vid_stream.
		1590	*
		1591	* Results:
		1592	* Values in gop header placed into video stream structure.
		1593	*
		1594	* Side effects:
		1595	* Bit stream irreversibly parsed.
		1596	*
		1597	*--------------------------------------------------------------
		1598	*/
		1599
		1600	static int
		1601	ParseGOP(vid_stream)
		1602	VidStream *vid_stream;
		1603	{
		1604	unsigned int data;
		1605
		1606	/* Flush group of pictures start code. */
		1607
		1608	flush_bits32;
		1609
		1610	/* Parse off drop frame flag. */
		1611
		1612	get_bits1(data);
		1613	if (data) {
		1614	vid_stream->group.drop_flag = TRUE;
		1615	} else
		1616	vid_stream->group.drop_flag = FALSE;
		1617
		1618	/* Parse off hour component of time code. */
		1619
		1620	get_bits5(data);
		1621	vid_stream->group.tc_hours = data;
		1622
		1623	/* Parse off minute component of time code. */
		1624
		1625	get_bits6(data);
		1626	vid_stream->group.tc_minutes = data;
		1627
		1628	/* Flush marker bit. */
		1629
		1630	flush_bits(1);
		1631
		1632	/* Parse off second component of time code. */
		1633
		1634	get_bits6(data);
		1635	vid_stream->group.tc_seconds = data;
		1636
		1637	/* Parse off picture count component of time code. */
		1638
		1639	get_bits6(data);
		1640	vid_stream->group.tc_pictures = data;
		1641
		1642	/* Parse off closed gop and broken link flags. */
		1643
		1644	get_bits2(data);
		1645	if (data > 1) {
		1646	vid_stream->group.closed_gop = TRUE;
		1647	if (data > 2) {
		1648	vid_stream->group.broken_link = TRUE;
		1649	} else
		1650	vid_stream->group.broken_link = FALSE;
		1651	} else {
		1652	vid_stream->group.closed_gop = FALSE;
		1653	if (data) {
		1654	vid_stream->group.broken_link = TRUE;
		1655	} else
		1656	vid_stream->group.broken_link = FALSE;
		1657	}
		1658
		1659	/* Goto next start code. */
		1660
		1661	next_start_code(vid_stream);
		1662
		1663	/* If next start code is extension data, parse off extension data. */
		1664
		1665	if (next_bits(32, EXT_START_CODE, vid_stream)) {
		1666	flush_bits32;
		1667	if (vid_stream->group.ext_data != NULL) {
		1668	free(vid_stream->group.ext_data);
		1669	vid_stream->group.ext_data = NULL;
		1670	}
		1671	vid_stream->group.ext_data = get_ext_data(vid_stream);
		1672	}
		1673	/* If next start code is user data, parse off user data. */
		1674
		1675	if (next_bits(32, USER_START_CODE,vid_stream)) {
		1676	flush_bits32;
		1677	if (vid_stream->group.user_data != NULL) {
		1678	free(vid_stream->group.user_data);
		1679	vid_stream->group.user_data = NULL;
		1680	}
		1681	vid_stream->group.user_data = get_ext_data(vid_stream);
		1682	}
		1683	return PARSE_OK;
		1684	}
		1685
		1686
		1687
		1688	/*
		1689	*--------------------------------------------------------------
		1690	*
		1691	* ParsePicture --
		1692	*
		1693	* Parses picture header. Marks picture to be presented
		1694	* at particular time given a time stamp.
		1695	*
		1696	* Results:
		1697	* Values from picture header put into video stream structure.
		1698	*
		1699	* Side effects:
		1700	* Bit stream irreversibly parsed.
		1701	*
		1702	*--------------------------------------------------------------
		1703	*/
		1704
		1705	static int
		1706	ParsePicture(vid_stream, time_stamp)
		1707	VidStream *vid_stream;
		1708	TimeStamp time_stamp;
		1709	{
		1710	unsigned int data;
		1711	int i;
		1712
		1713	/* Flush header start code. */
		1714	flush_bits32;
		1715
		1716	/* Parse off temporal reference. */
		1717	get_bits10(data);
		1718	vid_stream->picture.temp_ref = data;
		1719
		1720	/* Parse of picture type. */
		1721	get_bits3(data);
		1722	vid_stream->picture.code_type = data;
		1723
		1724	if ((vid_stream->picture.code_type == B_TYPE) &&
		1725	(/* No_B_Flag \|\| */
		1726	(vid_stream->future == NULL) \|\|
		1727	((vid_stream->past == NULL) && !(vid_stream->group.closed_gop))))
		1728	/* According to 2-D.5.1 (p D-18) this is ok, if the refereneces are OK */
		1729	return SKIP_PICTURE;
		1730
		1731	if ((vid_stream->picture.code_type == P_TYPE) &&
		1732	(No_P_Flag \|\| (vid_stream->future == NULL)))
		1733	return SKIP_PICTURE;
		1734
		1735	#ifdef ANALYSIS
		1736	StartTime();
		1737	stat_a[0].frametype = vid_stream->picture.code_type;
		1738	stat_a[0].number = 1;
		1739	stat_a[0].totsize = 45;
		1740	pictureSizeCount = bitCountRead();
		1741	#endif
		1742
		1743	/* Parse off vbv buffer delay value. */
		1744	get_bits16(data);
		1745	vid_stream->picture.vbv_delay = data;
		1746
		1747	/* If P or B type frame... */
		1748
		1749	if ((vid_stream->picture.code_type == P_TYPE) \|\|
		1750	(vid_stream->picture.code_type == B_TYPE)) {
		1751
		1752	/* Parse off forward vector full pixel flag. */
		1753	get_bits1(data);
		1754	if (data) {
		1755	vid_stream->picture.full_pel_forw_vector = TRUE;
		1756	} else {
		1757	vid_stream->picture.full_pel_forw_vector = FALSE;
		1758	}
		1759
		1760	/* Parse of forw_r_code. */
		1761	get_bits3(data);
		1762
		1763	/* Decode forw_r_code into forw_r_size and forw_f. */
		1764
		1765	vid_stream->picture.forw_r_size = data - 1;
		1766	vid_stream->picture.forw_f = (1 << vid_stream->picture.forw_r_size);
		1767	}
		1768	/* If B type frame... */
		1769
		1770	if (vid_stream->picture.code_type == B_TYPE) {
		1771
		1772	/* Parse off back vector full pixel flag. */
		1773	get_bits1(data);
		1774	if (data)
		1775	vid_stream->picture.full_pel_back_vector = TRUE;
		1776	else
		1777	vid_stream->picture.full_pel_back_vector = FALSE;
		1778
		1779	/* Parse off back_r_code. */
		1780	get_bits3(data);
		1781
		1782	/* Decode back_r_code into back_r_size and back_f. */
		1783
		1784	vid_stream->picture.back_r_size = data - 1;
		1785	vid_stream->picture.back_f = (1 << vid_stream->picture.back_r_size);
		1786	}
		1787	/* Get extra bit picture info. */
		1788
		1789	if (vid_stream->picture.extra_info != NULL) {
		1790	free(vid_stream->picture.extra_info);
		1791	vid_stream->picture.extra_info = NULL;
		1792	}
		1793	vid_stream->picture.extra_info = get_extra_bit_info(vid_stream);
		1794
		1795	/* Goto next start code. */
		1796	next_start_code(vid_stream);
		1797
		1798	/* If start code is extension start code, parse off extension data. */
		1799
		1800	if (next_bits(32, EXT_START_CODE, vid_stream)) {
		1801	flush_bits32;
		1802
		1803	if (vid_stream->picture.ext_data != NULL) {
		1804	free(vid_stream->picture.ext_data);
		1805	vid_stream->picture.ext_data = NULL;
		1806	}
		1807	vid_stream->picture.ext_data = get_ext_data(vid_stream);
		1808	}
		1809	/* If start code is user start code, parse off user data. */
		1810
		1811	if (next_bits(32, USER_START_CODE, vid_stream)) {
		1812	flush_bits32;
		1813
		1814	if (vid_stream->picture.user_data != NULL) {
		1815	free(vid_stream->picture.user_data);
		1816	vid_stream->picture.user_data = NULL;
		1817	}
		1818	vid_stream->picture.user_data = get_ext_data(vid_stream);
		1819	}
		1820	/* Find a pict image structure in ring buffer not currently locked. */
		1821
		1822	i = 0;
		1823
		1824	while (vid_stream->ring[i]->locked != 0) {
		1825	if (++i >= RING_BUF_SIZE) {
		1826	perror("Fatal error. Ring buffer full.");
		1827	exit(1);
		1828	}
		1829	}
		1830
		1831	/* Set current pict image structure to the one just found in ring. */
		1832
		1833	vid_stream->current = vid_stream->ring[i];
		1834
		1835	/* Set time stamp. */
		1836
		1837	vid_stream->current->show_time = time_stamp;
		1838
		1839	/* Reset past macroblock address field. */
		1840
		1841	vid_stream->mblock.past_mb_addr = -1;
		1842
		1843	return PARSE_OK;
		1844	}
		1845
		1846
		1847
		1848	/*
		1849	*--------------------------------------------------------------
		1850	*
		1851	* ParseSlice --
		1852	*
		1853	* Parses off slice header.
		1854	*
		1855	* Results:
		1856	* Values found in slice header put into video stream structure.
		1857	*
		1858	* Side effects:
		1859	* Bit stream irreversibly parsed.
		1860	*
		1861	*--------------------------------------------------------------
		1862	*/
		1863
		1864	static int
		1865	ParseSlice(vid_stream)
		1866	VidStream *vid_stream;
		1867	{
		1868	unsigned int data;
		1869
		1870	/* Flush slice start code. */
		1871
		1872	flush_bits(24);
		1873
		1874	/* Parse off slice vertical position. */
		1875
		1876	get_bits8(data);
		1877	vid_stream->slice.vert_pos = data;
		1878
		1879	/* Parse off quantization scale. */
		1880
		1881	get_bits5(data);
		1882	vid_stream->slice.quant_scale = data;
		1883
		1884	/* Parse off extra bit slice info. */
		1885
		1886	if (vid_stream->slice.extra_info != NULL) {
		1887	free(vid_stream->slice.extra_info);
		1888	vid_stream->slice.extra_info = NULL;
		1889	}
		1890	vid_stream->slice.extra_info = get_extra_bit_info(vid_stream);
		1891
		1892	/* Reset past intrablock address. */
		1893
		1894	vid_stream->mblock.past_intra_addr = -2;
		1895
		1896	/* Reset previous recon motion vectors. */
		1897
		1898	vid_stream->mblock.recon_right_for_prev = 0;
		1899	vid_stream->mblock.recon_down_for_prev = 0;
		1900	vid_stream->mblock.recon_right_back_prev = 0;
		1901	vid_stream->mblock.recon_down_back_prev = 0;
		1902
		1903	/* Reset macroblock address. */
		1904
		1905	vid_stream->mblock.mb_address = ((vid_stream->slice.vert_pos - 1) *
		1906	vid_stream->mb_width) - 1;
		1907
		1908	/* Reset past dct dc y, cr, and cb values. */
		1909
		1910	vid_stream->block.dct_dc_y_past = 1024 << 3;
		1911	vid_stream->block.dct_dc_cr_past = 1024 << 3;
		1912	vid_stream->block.dct_dc_cb_past = 1024 << 3;
		1913
		1914	return PARSE_OK;
		1915	}
		1916
		1917
		1918
		1919	/*
		1920	*--------------------------------------------------------------
		1921	*
		1922	* ParseMacroBlock --
		1923	*
		1924	* Parseoff macroblock. Reconstructs DCT values. Applies
		1925	* inverse DCT, reconstructs motion vectors, calculates and
		1926	* set pixel values for macroblock in current pict image
		1927	* structure.
		1928	*
		1929	* Results:
		1930	* Here's where everything really happens. Welcome to the
		1931	* heart of darkness.
		1932	*
		1933	* Side effects:
		1934	* Bit stream irreversibly parsed off.
		1935	*
		1936	*--------------------------------------------------------------
		1937	*/
		1938
		1939	static int
		1940	ParseMacroBlock(vid_stream)
		1941	VidStream *vid_stream;
		1942	{
		1943	int addr_incr;
		1944	unsigned int data;
		1945	int mask, i, recon_right_for, recon_down_for, recon_right_back,
		1946	recon_down_back;
		1947	int zero_block_flag;
		1948	BOOLEAN mb_quant = 0, mb_motion_forw = 0, mb_motion_back = 0,
		1949	mb_pattern = 0;
		1950	int no_dith_flag = 0;
		1951	int ditherType = vid_stream->ditherType;
		1952
		1953	#ifdef ANALYSIS
		1954	mbSizeCount = bitCountRead();
		1955	#endif
		1956
		1957	/*
		1958	* Parse off macroblock address increment and add to macroblock address.
		1959	*/
		1960	do {
		1961	unsigned int ind;
		1962	show_bits11(ind);
		1963	DecodeMBAddrInc(addr_incr);
		1964	if (mb_addr_inc[ind].num_bits==0) {
		1965	addr_incr = 1;
		1966	}
		1967	if (addr_incr == MB_ESCAPE) {
		1968	vid_stream->mblock.mb_address += 33;
		1969	addr_incr = MB_STUFFING;
		1970	}
		1971	} while (addr_incr == MB_STUFFING);
		1972	vid_stream->mblock.mb_address += addr_incr;
		1973
		1974	if (vid_stream->mblock.mb_address > (vid_stream->mb_height *
		1975	vid_stream->mb_width - 1))
		1976	return SKIP_TO_START_CODE;
		1977
		1978	/*
		1979	* If macroblocks have been skipped, process skipped macroblocks.
		1980	*/
		1981
		1982	if (vid_stream->mblock.mb_address - vid_stream->mblock.past_mb_addr > 1) {
		1983	if (vid_stream->picture.code_type == P_TYPE)
		1984	ProcessSkippedPFrameMBlocks(vid_stream);
		1985	else if (vid_stream->picture.code_type == B_TYPE)
		1986	ProcessSkippedBFrameMBlocks(vid_stream);
		1987	}
		1988	/* Set past macroblock address to current macroblock address. */
		1989	vid_stream->mblock.past_mb_addr = vid_stream->mblock.mb_address;
		1990
		1991	/* Based on picture type decode macroblock type. */
		1992	switch (vid_stream->picture.code_type) {
		1993	case I_TYPE:
		1994	DecodeMBTypeI(mb_quant, mb_motion_forw, mb_motion_back, mb_pattern,
		1995	vid_stream->mblock.mb_intra);
		1996	break;
		1997
		1998	case P_TYPE:
		1999	DecodeMBTypeP(mb_quant, mb_motion_forw, mb_motion_back, mb_pattern,
		2000	vid_stream->mblock.mb_intra);
		2001	break;
		2002
		2003	case B_TYPE:
		2004	DecodeMBTypeB(mb_quant, mb_motion_forw, mb_motion_back, mb_pattern,
		2005	vid_stream->mblock.mb_intra);
		2006	break;
		2007	case D_TYPE:
		2008	fprintf(stderr, "ERROR: MPEG-1 Streams with D-frames are not supported\n");
		2009	exit(1);
		2010	}
		2011
		2012	/* If quantization flag set, parse off new quantization scale. */
		2013
		2014	if (mb_quant == TRUE) {
		2015	get_bits5(data);
		2016	vid_stream->slice.quant_scale = data;
		2017	}
		2018	/* If forward motion vectors exist... */
		2019	if (mb_motion_forw == TRUE) {
		2020
		2021	/* Parse off and decode horizontal forward motion vector. */
		2022	DecodeMotionVectors(vid_stream->mblock.motion_h_forw_code);
		2023
		2024	/* If horiz. forward r data exists, parse off. */
		2025
		2026	if ((vid_stream->picture.forw_f != 1) &&
		2027	(vid_stream->mblock.motion_h_forw_code != 0)) {
		2028	get_bitsn(vid_stream->picture.forw_r_size, data);
		2029	vid_stream->mblock.motion_h_forw_r = data;
		2030	}
		2031	/* Parse off and decode vertical forward motion vector. */
		2032	DecodeMotionVectors(vid_stream->mblock.motion_v_forw_code);
		2033
		2034	/* If vert. forw. r data exists, parse off. */
		2035
		2036	if ((vid_stream->picture.forw_f != 1) &&
		2037	(vid_stream->mblock.motion_v_forw_code != 0)) {
		2038	get_bitsn(vid_stream->picture.forw_r_size, data);
		2039	vid_stream->mblock.motion_v_forw_r = data;
		2040	}
		2041	}
		2042	/* If back motion vectors exist... */
		2043	if (mb_motion_back == TRUE) {
		2044
		2045	/* Parse off and decode horiz. back motion vector. */
		2046	DecodeMotionVectors(vid_stream->mblock.motion_h_back_code);
		2047
		2048	/* If horiz. back r data exists, parse off. */
		2049
		2050	if ((vid_stream->picture.back_f != 1) &&
		2051	(vid_stream->mblock.motion_h_back_code != 0)) {
		2052	get_bitsn(vid_stream->picture.back_r_size, data);
		2053	vid_stream->mblock.motion_h_back_r = data;
		2054	}
		2055	/* Parse off and decode vert. back motion vector. */
		2056	DecodeMotionVectors(vid_stream->mblock.motion_v_back_code);
		2057
		2058	/* If vert. back r data exists, parse off. */
		2059
		2060	if ((vid_stream->picture.back_f != 1) &&
		2061	(vid_stream->mblock.motion_v_back_code != 0)) {
		2062	get_bitsn(vid_stream->picture.back_r_size, data);
		2063	vid_stream->mblock.motion_v_back_r = data;
		2064	}
		2065	}
		2066	#ifdef ANALYSIS
		2067	if (vid_stream->mblock.mb_intra) {
		2068	stat_a[0].i_mbnum++;
		2069	mbCBPPtr = stat_a[0].i_mbcbp;
		2070	mbCoeffPtr = stat_a[0].i_mbcoeff;
		2071	mbSizePtr = &(stat_a[0].i_mbsize);
		2072	} else if (mb_motion_back && mb_motion_forw) {
		2073	stat_a[0].bi_mbnum++;
		2074	mbCBPPtr = stat_a[0].bi_mbcbp;
		2075	mbCoeffPtr = stat_a[0].bi_mbcoeff;
		2076	mbSizePtr = &(stat_a[0].bi_mbsize);
		2077	} else if (mb_motion_back) {
		2078	stat_a[0].b_mbnum++;
		2079	mbCBPPtr = stat_a[0].b_mbcbp;
		2080	mbCoeffPtr = stat_a[0].b_mbcoeff;
		2081	mbSizePtr = &(stat_a[0].b_mbsize);
		2082	} else {
		2083	stat_a[0].p_mbnum++;
		2084	mbCBPPtr = stat_a[0].p_mbcbp;
		2085	mbCoeffPtr = stat_a[0].p_mbcoeff;
		2086	mbSizePtr = &(stat_a[0].p_mbsize);
		2087	}
		2088	#endif
		2089
		2090	/* If mblock pattern flag set, parse and decode CBP (code block pattern). */
		2091	if (mb_pattern == TRUE) {
		2092	DecodeCBP(vid_stream->mblock.cbp);
		2093	}
		2094	/* Otherwise, set CBP to zero. */
		2095	else
		2096	vid_stream->mblock.cbp = 0;
		2097
		2098
		2099	#ifdef ANALYSIS
		2100	mbCBPPtr[vid_stream->mblock.cbp]++;
		2101	#endif
		2102
		2103	/* Reconstruct motion vectors depending on picture type. */
		2104	if (vid_stream->picture.code_type == P_TYPE) {
		2105
		2106	/*
		2107	* If no forw motion vectors, reset previous and current vectors to 0.
		2108	*/
		2109
		2110	if (!mb_motion_forw) {
		2111	recon_right_for = 0;
		2112	recon_down_for = 0;
		2113	vid_stream->mblock.recon_right_for_prev = 0;
		2114	vid_stream->mblock.recon_down_for_prev = 0;
		2115	}
		2116	/*
		2117	* Otherwise, compute new forw motion vectors. Reset previous vectors to
		2118	* current vectors.
		2119	*/
		2120
		2121	else {
		2122	ComputeForwVector(&recon_right_for, &recon_down_for, vid_stream);
		2123	}
		2124	}
		2125	if (vid_stream->picture.code_type == B_TYPE) {
		2126
		2127	/* Reset prev. and current vectors to zero if mblock is intracoded. */
		2128
		2129	if (vid_stream->mblock.mb_intra) {
		2130	vid_stream->mblock.recon_right_for_prev = 0;
		2131	vid_stream->mblock.recon_down_for_prev = 0;
		2132	vid_stream->mblock.recon_right_back_prev = 0;
		2133	vid_stream->mblock.recon_down_back_prev = 0;
		2134	} else {
		2135
		2136	/* If no forw vectors, current vectors equal prev. vectors. */
		2137
		2138	if (!mb_motion_forw) {
		2139	recon_right_for = vid_stream->mblock.recon_right_for_prev;
		2140	recon_down_for = vid_stream->mblock.recon_down_for_prev;
		2141	}
		2142	/*
		2143	* Otherwise compute forw. vectors. Reset prev vectors to new values.
		2144	*/
		2145
		2146	else {
		2147	ComputeForwVector(&recon_right_for, &recon_down_for, vid_stream);
		2148	}
		2149
		2150	/* If no back vectors, set back vectors to prev back vectors. */
		2151
		2152	if (!mb_motion_back) {
		2153	recon_right_back = vid_stream->mblock.recon_right_back_prev;
		2154	recon_down_back = vid_stream->mblock.recon_down_back_prev;
		2155	}
		2156	/* Otherwise compute new vectors and reset prev. back vectors. */
		2157
		2158	else {
		2159	ComputeBackVector(&recon_right_back, &recon_down_back, vid_stream);
		2160	}
		2161
		2162	/*
		2163	* Store vector existence flags in structure for possible skipped
		2164	* macroblocks to follow.
		2165	*/
		2166
		2167	vid_stream->mblock.bpict_past_forw = mb_motion_forw;
		2168	vid_stream->mblock.bpict_past_back = mb_motion_back;
		2169	}
		2170	}
		2171
		2172	#ifndef DISABLE_DITHER
		2173	/* For each possible block in macroblock. */
		2174	if (ditherType == GRAY_DITHER \|\|
		2175	ditherType == GRAY2_DITHER \|\|
		2176	ditherType == GRAY256_DITHER \|\|
		2177	ditherType == GRAY2562_DITHER \|\|
		2178	ditherType == MONO_DITHER \|\|
		2179	ditherType == MONO_THRESHOLD) {
		2180	for (mask = 32, i = 0; i < 4; mask >>= 1, i++) {
		2181
		2182	/* If block exists... */
		2183	if ((vid_stream->mblock.mb_intra) \|\| (vid_stream->mblock.cbp & mask)) {
		2184	zero_block_flag = 0;
		2185	ParseReconBlock(i, vid_stream);
		2186	} else {
		2187	zero_block_flag = 1;
		2188	}
		2189
		2190	/* If macroblock is intra coded... */
		2191	if (vid_stream->mblock.mb_intra) {
		2192	ReconIMBlock(vid_stream, i);
		2193	} else if (mb_motion_forw && mb_motion_back) {
		2194	ReconBiMBlock(vid_stream, i, recon_right_for, recon_down_for,
		2195	recon_right_back, recon_down_back, zero_block_flag);
		2196	} else if (mb_motion_forw \|\| (vid_stream->picture.code_type == P_TYPE)) {
		2197	ReconPMBlock(vid_stream, i, recon_right_for, recon_down_for,
		2198	zero_block_flag);
		2199	} else if (mb_motion_back) {
		2200	ReconBMBlock(vid_stream, i, recon_right_back, recon_down_back,
		2201	zero_block_flag);
		2202	}
		2203	}
		2204	/* Kill the Chrominance blocks... */
		2205	if ((vid_stream->mblock.mb_intra) \|\| (vid_stream->mblock.cbp & 0x2)) {
		2206	ParseAwayBlock(4, vid_stream);
		2207	}
		2208	if ((vid_stream->mblock.mb_intra) \|\| (vid_stream->mblock.cbp & 0x1)) {
		2209	ParseAwayBlock(5, vid_stream);
		2210	}
		2211	} else {
		2212	if ((ditherType == MBORDERED_DITHER) &&
		2213	(vid_stream->mblock.cbp == 0) &&
		2214	(vid_stream->picture.code_type == 3) &&
		2215	(!vid_stream->mblock.mb_intra) &&
		2216	(!(mb_motion_forw && mb_motion_back))) {
		2217	MBOrderedDitherDisplayCopy(vid_stream, vid_stream->mblock.mb_address,
		2218	mb_motion_forw, recon_right_for, recon_down_for,
		2219	mb_motion_back, recon_right_back, recon_down_back,
		2220	vid_stream->past->display, vid_stream->future->display);
		2221	vid_stream->ditherFlags[vid_stream->mblock.mb_address] = 0;
		2222	no_dith_flag = 1;
		2223	}
		2224	else {
		2225	#endif
		2226	for (mask = 32, i = 0; i < 6; mask >>= 1, i++) {
		2227
		2228	/* If block exists... */
		2229	if ((vid_stream->mblock.mb_intra) \|\| (vid_stream->mblock.cbp & mask)) {
		2230	zero_block_flag = 0;
		2231	ParseReconBlock(i, vid_stream);
		2232	} else {
		2233	zero_block_flag = 1;
		2234	}
		2235
		2236	/* If macroblock is intra coded... */
		2237	if (vid_stream->mblock.mb_intra) {
		2238	ReconIMBlock(vid_stream, i);
		2239	} else if (mb_motion_forw && mb_motion_back) {
		2240	ReconBiMBlock(vid_stream, i, recon_right_for, recon_down_for,
		2241	recon_right_back, recon_down_back, zero_block_flag);
		2242	} else if (mb_motion_forw \|\| (vid_stream->picture.code_type == P_TYPE)) {
		2243	ReconPMBlock(vid_stream, i, recon_right_for, recon_down_for,
		2244	zero_block_flag);
		2245	} else if (mb_motion_back) {
		2246	ReconBMBlock(vid_stream, i, recon_right_back, recon_down_back,
		2247	zero_block_flag);
		2248	}
		2249	}
		2250	#ifndef DISABLE_DITHER
		2251	}
		2252	}
		2253	#endif
		2254
		2255	#ifndef DISABLE_DITHER
		2256	if ((ditherType == MBORDERED_DITHER) && (!no_dith_flag)) {
		2257	if ((vid_stream->picture.code_type == 2) &&
		2258	(vid_stream->mblock.cbp == 0) &&
		2259	(!vid_stream->mblock.mb_intra)) {
		2260	MBOrderedDitherDisplayCopy(vid_stream, vid_stream->mblock.mb_address,
		2261	1, recon_right_for, recon_down_for,
		2262	0, 0, 0,
		2263	vid_stream->future->display,
		2264	(unsigned char *) NULL);
		2265	vid_stream->ditherFlags[vid_stream->mblock.mb_address] = 0;
		2266	}
		2267	else {
		2268	vid_stream->ditherFlags[vid_stream->mblock.mb_address] = 1;
		2269	}
		2270	}
		2271	#endif
		2272
		2273	/* If D Type picture, flush marker bit. */
		2274	if (vid_stream->picture.code_type == 4)
		2275	flush_bits(1);
		2276
		2277	/* If macroblock was intracoded, set macroblock past intra address. */
		2278	if (vid_stream->mblock.mb_intra)
		2279	vid_stream->mblock.past_intra_addr =
		2280	vid_stream->mblock.mb_address;
		2281
		2282	#ifdef ANALYSIS
		2283	*mbSizePtr += bitCountRead() - mbSizeCount;
		2284	#endif
		2285	return PARSE_OK;
		2286	}
		2287
		2288
		2289
		2290	/*
		2291	*--------------------------------------------------------------
		2292	*
		2293	* ReconIMBlock --
		2294	*
		2295	* Reconstructs intra coded macroblock.
		2296	*
		2297	* Results:
		2298	* None.
		2299	*
		2300	* Side effects:
		2301	* None.
		2302	*
		2303	*--------------------------------------------------------------
		2304	*/
		2305	#ifndef NDEBUG
		2306	/* If people really want to see such things, check 'em */
		2307	#define myassert(x,expression)\
		2308	if (!(expression)) {\
		2309	fprintf (stderr,"Bad crop value (%d) at line %d\n", x, __LINE__);\
		2310	next_start_code(vid_stream); return;}
		2311	#define assertCrop(x) myassert(x,((x) >= -MAX_NEG_CROP) && \
		2312	((x) <= 2048+MAX_NEG_CROP))
		2313	#else
		2314	#define assertCrop(x)
		2315	#endif
		2316
		2317	static void
		2318	ReconIMBlock(vid_stream, bnum)
		2319	VidStream *vid_stream;
		2320	int bnum;
		2321	{
		2322	int mb_row, mb_col, row, col, row_size, rr;
		2323	unsigned char *dest;
		2324
		2325	/* Calculate macroblock row and column from address. */
		2326
		2327	mb_row = vid_stream->mblock.mb_address / vid_stream->mb_width;
		2328	mb_col = vid_stream->mblock.mb_address % vid_stream->mb_width;
		2329
		2330
		2331	/* If block is luminance block... */
		2332
		2333	if (bnum < 4) {
		2334
		2335	/* Calculate row and col values for upper left pixel of block. */
		2336
		2337	row = mb_row * 16;
		2338	col = mb_col * 16;
		2339	if (bnum > 1)
		2340	row += 8;
		2341	if (bnum % 2)
		2342	col += 8;
		2343
		2344	/* Set dest to luminance plane of current pict image. */
		2345
		2346	dest = vid_stream->current->luminance;
		2347
		2348	/* Establish row size. */
		2349
		2350	row_size = vid_stream->mb_width * 16;
		2351	}
		2352	/* Otherwise if block is Cr block... */
		2353	/* Cr first because of the earlier mixup */
		2354
		2355	else if (bnum == 5) {
		2356
		2357	/* Set dest to Cr plane of current pict image. */
		2358
		2359	dest = vid_stream->current->Cr;
		2360
		2361	/* Establish row size. */
		2362
		2363	row_size = vid_stream->mb_width * 8;
		2364
		2365	/* Calculate row,col for upper left pixel of block. */
		2366
		2367	row = mb_row * 8;
		2368	col = mb_col * 8;
		2369	}
		2370	/* Otherwise block is Cb block, and ... */
		2371
		2372	else {
		2373
		2374	/* Set dest to Cb plane of current pict image. */
		2375
		2376	dest = vid_stream->current->Cb;
		2377
		2378	/* Establish row size. */
		2379
		2380	row_size = vid_stream->mb_width * 8;
		2381
		2382	/* Calculate row,col for upper left pixel value of block. */
		2383
		2384	row = mb_row * 8;
		2385	col = mb_col * 8;
		2386	}
		2387
		2388	/*
		2389	* For each pixel in block, set to cropped reconstructed value from inverse
		2390	* dct.
		2391	*/
		2392	{
		2393	short *sp = &vid_stream->block.dct_recon[0][0];
		2394	unsigned char *cm = cropTbl + MAX_NEG_CROP;
		2395	dest += row * row_size + col;
		2396	for (rr = 0; rr < 4; rr++, sp += 16, dest += row_size) {
		2397	dest[0] = cm[sp[0]];
		2398	assertCrop(sp[0]);
		2399	dest[1] = cm[sp[1]];
		2400	assertCrop(sp[1]);
		2401	dest[2] = cm[sp[2]];
		2402	assertCrop(sp[2]);
		2403	dest[3] = cm[sp[3]];
		2404	assertCrop(sp[3]);
		2405	dest[4] = cm[sp[4]];
		2406	assertCrop(sp[4]);
		2407	dest[5] = cm[sp[5]];
		2408	assertCrop(sp[5]);
		2409	dest[6] = cm[sp[6]];
		2410	assertCrop(sp[6]);
		2411	dest[7] = cm[sp[7]];
		2412	assertCrop(sp[7]);
		2413
		2414	dest += row_size;
		2415	dest[0] = cm[sp[8]];
		2416	assertCrop(sp[8]);
		2417	dest[1] = cm[sp[9]];
		2418	assertCrop(sp[9]);
		2419	dest[2] = cm[sp[10]];
		2420	assertCrop(sp[10]);
		2421	dest[3] = cm[sp[11]];
		2422	assertCrop(sp[11]);
		2423	dest[4] = cm[sp[12]];
		2424	assertCrop(sp[12]);
		2425	dest[5] = cm[sp[13]];
		2426	assertCrop(sp[13]);
		2427	dest[6] = cm[sp[14]];
		2428	assertCrop(sp[14]);
		2429	dest[7] = cm[sp[15]];
		2430	assertCrop(sp[15]);
		2431	}
		2432	}
		2433	}
		2434
		2435
		2436
		2437	/*
		2438	*--------------------------------------------------------------
		2439	*
		2440	* ReconPMBlock --
		2441	*
		2442	* Reconstructs forward predicted macroblocks.
		2443	*
		2444	* Results:
		2445	* None.
		2446	*
		2447	* Side effects:
		2448	* None.
		2449	*
		2450	*--------------------------------------------------------------
		2451	*/
		2452
		2453	static void
		2454	ReconPMBlock(vid_stream, bnum, recon_right_for, recon_down_for, zflag)
		2455	VidStream *vid_stream;
		2456	int bnum, recon_right_for, recon_down_for, zflag;
		2457	{
		2458	int mb_row, mb_col, row, col, row_size, rr;
		2459	unsigned char dest, past;
		2460	unsigned char rindex1, rindex2, rindex3, rindex4;
		2461	unsigned char *index;
		2462	short int *blockvals;
		2463
		2464	#ifdef LOOSE_MPEG
		2465	int maxx, maxy, cc;
		2466	int illegalBlock = 0;
		2467	int row_start, row_end, rfirst, rlast, col_start, col_end, cfirst, clast;
		2468	#endif
		2469
		2470	/* Calculate macroblock row and column from address. */
		2471
		2472	mb_row = vid_stream->mblock.mb_address / vid_stream->mb_width;
		2473	mb_col = vid_stream->mblock.mb_address % vid_stream->mb_width;
		2474
		2475	if (bnum < 4) {
		2476
		2477	/* Calculate right_for, down_for motion vectors. */
		2478
		2479	vid_stream->right_for = recon_right_for >> 1;
		2480	vid_stream->down_for = recon_down_for >> 1;
		2481	vid_stream->right_half_for = recon_right_for & 0x1;
		2482	vid_stream->down_half_for = recon_down_for & 0x1;
		2483
		2484	/* Set dest to luminance plane of current pict image. */
		2485
		2486	dest = vid_stream->current->luminance;
		2487
		2488	if (vid_stream->picture.code_type == B_TYPE) {
		2489	if (vid_stream->past != NULL)
		2490	past = vid_stream->past->luminance;
		2491	} else {
		2492
		2493	/* Set predictive frame to current future frame. */
		2494
		2495	if (vid_stream->future != NULL)
		2496	past = vid_stream->future->luminance;
		2497	}
		2498
		2499	/* Establish row size. */
		2500
		2501	row_size = vid_stream->mb_width << 4;
		2502
		2503	/* Calculate row,col of upper left pixel in block. */
		2504
		2505	row = mb_row << 4;
		2506	col = mb_col << 4;
		2507	if (bnum > 1)
		2508	row += 8;
		2509	if (bnum % 2)
		2510	col += 8;
		2511
		2512	#ifdef LOOSE_MPEG
		2513	/* Check for block illegality. */
		2514
		2515	maxx = vid_stream->mb_width*16-1;
		2516	maxy = vid_stream->mb_height*16-1;
		2517
		2518	if (row + vid_stream->down_for + 7 > maxy) illegalBlock \|= 0x4;
		2519	else if (row + vid_stream->down_for < 0) illegalBlock \|= 0x1;
		2520
		2521	if (col + vid_stream->right_for + 7 > maxx) illegalBlock \|= 0x2;
		2522	else if (col + vid_stream->right_for < 0) illegalBlock \|= 0x8;
		2523
		2524	#endif
		2525	}
		2526	/* Otherwise, block is NOT luminance block, ... */
		2527
		2528	else {
		2529
		2530	/* Construct motion vectors. */
		2531
		2532	recon_right_for /= 2;
		2533	recon_down_for /= 2;
		2534	vid_stream->right_for = recon_right_for >> 1;
		2535	vid_stream->down_for = recon_down_for >> 1;
		2536	vid_stream->right_half_for = recon_right_for & 0x1;
		2537	vid_stream->down_half_for = recon_down_for & 0x1;
		2538
		2539	/* Establish row size. */
		2540
		2541	row_size = vid_stream->mb_width << 3;
		2542
		2543	/* Calculate row,col of upper left pixel in block. */
		2544
		2545	row = mb_row << 3;
		2546	col = mb_col << 3;
		2547
		2548	#ifdef LOOSE_MPEG
		2549	/* Check for block illegality. */
		2550
		2551	maxx = vid_stream->mb_width*16-1;
		2552	maxy = vid_stream->mb_height*16-1;
		2553
		2554	if (row + vid_stream->down_for + 7 > maxy) illegalBlock \|= 0x4;
		2555	else if (row + vid_stream->down_for < 0) illegalBlock \|= 0x1;
		2556
		2557	if (col + vid_stream->right_for + 7 > maxx) illegalBlock \|= 0x2;
		2558	else if (col + vid_stream->right_for < 0) illegalBlock \|= 0x8;
		2559
		2560	#endif
		2561
		2562	/* If block is Cr block... */
		2563	/* 5 first because order was mixed up in earlier versions */
		2564
		2565	if (bnum == 5) {
		2566
		2567	/* Set dest to Cr plane of current pict image. */
		2568
		2569	dest = vid_stream->current->Cr;
		2570
		2571	if (vid_stream->picture.code_type == B_TYPE) {
		2572
		2573	if (vid_stream->past != NULL)
		2574	past = vid_stream->past->Cr;
		2575	} else {
		2576	if (vid_stream->future != NULL)
		2577	past = vid_stream->future->Cr;
		2578	}
		2579	}
		2580	/* Otherwise, block is Cb block... */
		2581
		2582	else {
		2583
		2584	/* Set dest to Cb plane of current pict image. */
		2585
		2586	dest = vid_stream->current->Cb;
		2587
		2588	if (vid_stream->picture.code_type == B_TYPE) {
		2589	if (vid_stream->past != NULL)
		2590	past = vid_stream->past->Cb;
		2591	} else {
		2592	if (vid_stream->future != NULL)
		2593	past = vid_stream->future->Cb;
		2594	}
		2595	}
		2596	}
		2597
		2598	/* For each pixel in block... */
		2599
		2600	#ifdef LOOSE_MPEG
		2601
		2602	if (illegalBlock) {
		2603	if (illegalBlock & 0x1) {
		2604	row_start = 0;
		2605	row_end = row+vid_stream->down_for+8;
		2606	rfirst = rlast = 8 - row_end;
		2607	}
		2608	else if (illegalBlock & 0x4) {
		2609	row_start = row + vid_stream->down_for;
		2610	row_end = maxy+1;
		2611	rlast = row_end - row_start - 1;
		2612	rfirst = 0;
		2613	}
		2614	else {
		2615	row_start = row+vid_stream->down_for;
		2616	row_end = row_start+8;
		2617	rfirst = 0;
		2618	}
		2619
		2620	if (illegalBlock & 0x8) {
		2621	col_start = 0;
		2622	col_end = col + vid_stream->right_for + 8;
		2623	cfirst = clast = 8 - col_end;
		2624	}
		2625	else if (illegalBlock & 0x2) {
		2626	col_start = col + vid_stream->right_for;
		2627	col_end = maxx + 1;
		2628	clast = col_end - col_start - 1;
		2629	cfirst = 0;
		2630	}
		2631	else {
		2632	col_start = col + vid_stream->right_for;
		2633	col_end = col_start + 8;
		2634	cfirst = 0;
		2635	}
		2636
		2637	for (rr = row_start; rr < row_end; rr++) {
		2638	rindex1 = past + (rr * row_size) + col_start;
		2639	index = dest + ((row + rfirst) * row_size) + col + cfirst;
		2640	for (cc = col_start; cc < col_end; cc++) {
		2641	index++ = rindex1++;
		2642	}
		2643	}
		2644
		2645	if (illegalBlock & 0x1) {
		2646	for (rr = rlast -1; rr >=0; rr--) {
		2647	index = dest + ((row + rr) * row_size) + col;
		2648	rindex1 = dest + ((row + rlast) * row_size) + col;
		2649	for (cc = 0; cc < 8; cc ++) {
		2650	index++ = rindex1++;
		2651	}
		2652	}
		2653	}
		2654	else if (illegalBlock & 0x4) {
		2655	for (rr = rlast+1; rr < 8; rr++) {
		2656	index = dest + ((row + rr) * row_size) + col;
		2657	rindex1 = dest + ((row + rlast) * row_size) + col;
		2658	for (cc = 0; cc < 8; cc ++) {
		2659	index++ = rindex1++;
		2660	}
		2661	}
		2662	}
		2663
		2664	if (illegalBlock & 0x2) {
		2665	for (cc = clast+1; cc < 8; cc++) {
		2666	index = dest + (row * row_size) + (col + cc);
		2667	rindex1 = dest + (row * row_size) + (col + clast);
		2668	for (rr = 0; rr < 8; rr++) {
		2669	index = rindex1;
		2670	index += row_size;
		2671	rindex1 += row_size;
		2672	}
		2673	}
		2674	}
		2675	else if (illegalBlock & 0x8) {
		2676	for (cc = clast-1; cc >= 0; cc--) {
		2677	index = dest + (row * row_size) + (col + cc);
		2678	rindex1 = dest + (row * row_size) + (col + clast);
		2679	for (rr = 0; rr < 8; rr++) {
		2680	index = rindex1;
		2681	index += row_size;
		2682	rindex1 += row_size;
		2683	}
		2684	}
		2685	}
		2686
		2687	if (!zflag) {
		2688	for (rr = 0; rr < 8; rr++) {
		2689	index = dest + (row*row_size) + col;
		2690	blockvals = &(vid_stream->block.dct_recon[rr][0]);
		2691	index[0] += blockvals[0];
		2692	index[1] += blockvals[1];
		2693	index[2] += blockvals[2];
		2694	index[3] += blockvals[3];
		2695	index[4] += blockvals[4];
		2696	index[5] += blockvals[5];
		2697	index[6] += blockvals[6];
		2698	index[7] += blockvals[7];
		2699	}
		2700	}
		2701	}
		2702	else {
		2703
		2704	#endif
		2705
		2706	index = dest + (row * row_size) + col;
		2707	rindex1 = past + (row + vid_stream->down_for) * row_size
		2708	+ col + vid_stream->right_for;
		2709
		2710	blockvals = &(vid_stream->block.dct_recon[0][0]);
		2711
		2712	/*
		2713	* Calculate predictive pixel value based on motion vectors and copy to
		2714	* dest plane.
		2715	*/
		2716
		2717	if ((!vid_stream->down_half_for) && (!vid_stream->right_half_for)) {
		2718	unsigned char *cm = cropTbl + MAX_NEG_CROP;
		2719	if (!zflag)
		2720	for (rr = 0; rr < 4; rr++) {
		2721	index[0] = cm[(int) rindex1[0] + (int) blockvals[0]];
		2722	index[1] = cm[(int) rindex1[1] + (int) blockvals[1]];
		2723	index[2] = cm[(int) rindex1[2] + (int) blockvals[2]];
		2724	index[3] = cm[(int) rindex1[3] + (int) blockvals[3]];
		2725	index[4] = cm[(int) rindex1[4] + (int) blockvals[4]];
		2726	index[5] = cm[(int) rindex1[5] + (int) blockvals[5]];
		2727	index[6] = cm[(int) rindex1[6] + (int) blockvals[6]];
		2728	index[7] = cm[(int) rindex1[7] + (int) blockvals[7]];
		2729	index += row_size;
		2730	rindex1 += row_size;
		2731
		2732	index[0] = cm[(int) rindex1[0] + (int) blockvals[8]];
		2733	index[1] = cm[(int) rindex1[1] + (int) blockvals[9]];
		2734	index[2] = cm[(int) rindex1[2] + (int) blockvals[10]];
		2735	index[3] = cm[(int) rindex1[3] + (int) blockvals[11]];
		2736	index[4] = cm[(int) rindex1[4] + (int) blockvals[12]];
		2737	index[5] = cm[(int) rindex1[5] + (int) blockvals[13]];
		2738	index[6] = cm[(int) rindex1[6] + (int) blockvals[14]];
		2739	index[7] = cm[(int) rindex1[7] + (int) blockvals[15]];
		2740	blockvals += 16;
		2741	index += row_size;
		2742	rindex1 += row_size;
		2743	}
		2744	else {
		2745	if (vid_stream->right_for & 0x1) {
		2746	/* No alignment, use bye copy */
		2747	for (rr = 0; rr < 4; rr++) {
		2748	index[0] = rindex1[0];
		2749	index[1] = rindex1[1];
		2750	index[2] = rindex1[2];
		2751	index[3] = rindex1[3];
		2752	index[4] = rindex1[4];
		2753	index[5] = rindex1[5];
		2754	index[6] = rindex1[6];
		2755	index[7] = rindex1[7];
		2756	index += row_size;
		2757	rindex1 += row_size;
		2758
		2759	index[0] = rindex1[0];
		2760	index[1] = rindex1[1];
		2761	index[2] = rindex1[2];
		2762	index[3] = rindex1[3];
		2763	index[4] = rindex1[4];
		2764	index[5] = rindex1[5];
		2765	index[6] = rindex1[6];
		2766	index[7] = rindex1[7];
		2767	index += row_size;
		2768	rindex1 += row_size;
		2769	}
		2770	} else if (vid_stream->right_for & 0x2) {
		2771	/* Half-word bit aligned, use 16 bit copy */
		2772	short src = (short )rindex1;
		2773	short dest = (short )index;
		2774	row_size >>= 1;
		2775	for (rr = 0; rr < 4; rr++) {
		2776	dest[0] = src[0];
		2777	dest[1] = src[1];
		2778	dest[2] = src[2];
		2779	dest[3] = src[3];
		2780	dest += row_size;
		2781	src += row_size;
		2782
		2783	dest[0] = src[0];
		2784	dest[1] = src[1];
		2785	dest[2] = src[2];
		2786	dest[3] = src[3];
		2787	dest += row_size;
		2788	src += row_size;
		2789	}
		2790	} else {
		2791	/* Word aligned, use 32 bit copy */
		2792	int src = (int )rindex1;
		2793	int dest = (int )index;
		2794	row_size >>= 2;
		2795	for (rr = 0; rr < 4; rr++) {
		2796	dest[0] = src[0];
		2797	dest[1] = src[1];
		2798	dest += row_size;
		2799	src += row_size;
		2800
		2801	dest[0] = src[0];
		2802	dest[1] = src[1];
		2803	dest += row_size;
		2804	src += row_size;
		2805	}
		2806	}
		2807	}
		2808	} else {
		2809	unsigned char *cm = cropTbl + MAX_NEG_CROP;
		2810	rindex2 = rindex1 + vid_stream->right_half_for
		2811	+ (vid_stream->down_half_for * row_size);
		2812
		2813	/* if one of the two is zero, then quality makes no difference */
		2814	if ((!vid_stream->right_half_for) \|\|
		2815	(!vid_stream->down_half_for) \|\| (!qualityFlag)) {
		2816
		2817	if (!zflag) {
		2818	for (rr = 0; rr < 4; rr++) {
		2819	index[0] = cm[((int) (rindex1[0] + rindex2[0] + 1) >> 1) + blockvals[0]];
		2820	index[1] = cm[((int) (rindex1[1] + rindex2[1] + 1) >> 1) + blockvals[1]];
		2821	index[2] = cm[((int) (rindex1[2] + rindex2[2] + 1) >> 1) + blockvals[2]];
		2822	index[3] = cm[((int) (rindex1[3] + rindex2[3] + 1) >> 1) + blockvals[3]];
		2823	index[4] = cm[((int) (rindex1[4] + rindex2[4] + 1) >> 1) + blockvals[4]];
		2824	index[5] = cm[((int) (rindex1[5] + rindex2[5] + 1) >> 1) + blockvals[5]];
		2825	index[6] = cm[((int) (rindex1[6] + rindex2[6] + 1) >> 1) + blockvals[6]];
		2826	index[7] = cm[((int) (rindex1[7] + rindex2[7] + 1) >> 1) + blockvals[7]];
		2827	index += row_size;
		2828	rindex1 += row_size;
		2829	rindex2 += row_size;
		2830
		2831	index[0] = cm[((int) (rindex1[0] + rindex2[0] + 1) >> 1) + blockvals[8]];
		2832	index[1] = cm[((int) (rindex1[1] + rindex2[1] + 1) >> 1) + blockvals[9]];
		2833	index[2] = cm[((int) (rindex1[2] + rindex2[2] + 1) >> 1) + blockvals[10]];
		2834	index[3] = cm[((int) (rindex1[3] + rindex2[3] + 1) >> 1) + blockvals[11]];
		2835	index[4] = cm[((int) (rindex1[4] + rindex2[4] + 1) >> 1) + blockvals[12]];
		2836	index[5] = cm[((int) (rindex1[5] + rindex2[5] + 1) >> 1) + blockvals[13]];
		2837	index[6] = cm[((int) (rindex1[6] + rindex2[6] + 1) >> 1) + blockvals[14]];
		2838	index[7] = cm[((int) (rindex1[7] + rindex2[7] + 1) >> 1) + blockvals[15]];
		2839	blockvals += 16;
		2840	index += row_size;
		2841	rindex1 += row_size;
		2842	rindex2 += row_size;
		2843	}
		2844	} else { /* zflag */
		2845	for (rr = 0; rr < 8; rr++) {
		2846	index[0] = (int) (rindex1[0] + rindex2[0] + 1) >> 1;
		2847	index[1] = (int) (rindex1[1] + rindex2[1] + 1) >> 1;
		2848	index[2] = (int) (rindex1[2] + rindex2[2] + 1) >> 1;
		2849	index[3] = (int) (rindex1[3] + rindex2[3] + 1) >> 1;
		2850	index[4] = (int) (rindex1[4] + rindex2[4] + 1) >> 1;
		2851	index[5] = (int) (rindex1[5] + rindex2[5] + 1) >> 1;
		2852	index[6] = (int) (rindex1[6] + rindex2[6] + 1) >> 1;
		2853	index[7] = (int) (rindex1[7] + rindex2[7] + 1) >> 1;
		2854	index += row_size;
		2855	rindex1 += row_size;
		2856	rindex2 += row_size;
		2857	}
		2858	}
		2859	} else { /* qualityFlag on and both vectors are non-zero */
		2860	rindex3 = rindex1 + vid_stream->right_half_for;
		2861	rindex4 = rindex1 + (vid_stream->down_half_for * row_size);
		2862	if (!zflag) {
		2863	for (rr = 0; rr < 4; rr++) {
		2864	index[0] = cm[((int) (rindex1[0] + rindex2[0] + rindex3[0] + rindex4[0] + 2) >> 2) + blockvals[0]];
		2865	index[1] = cm[((int) (rindex1[1] + rindex2[1] + rindex3[1] + rindex4[1] + 2) >> 2) + blockvals[1]];
		2866	index[2] = cm[((int) (rindex1[2] + rindex2[2] + rindex3[2] + rindex4[2] + 2) >> 2) + blockvals[2]];
		2867	index[3] = cm[((int) (rindex1[3] + rindex2[3] + rindex3[3] + rindex4[3] + 2) >> 2) + blockvals[3]];
		2868	index[4] = cm[((int) (rindex1[4] + rindex2[4] + rindex3[4] + rindex4[4] + 2) >> 2) + blockvals[4]];
		2869	index[5] = cm[((int) (rindex1[5] + rindex2[5] + rindex3[5] + rindex4[5] + 2) >> 2) + blockvals[5]];
		2870	index[6] = cm[((int) (rindex1[6] + rindex2[6] + rindex3[6] + rindex4[6] + 2) >> 2) + blockvals[6]];
		2871	index[7] = cm[((int) (rindex1[7] + rindex2[7] + rindex3[7] + rindex4[7] + 2) >> 2) + blockvals[7]];
		2872	index += row_size;
		2873	rindex1 += row_size;
		2874	rindex2 += row_size;
		2875	rindex3 += row_size;
		2876	rindex4 += row_size;
		2877
		2878	index[0] = cm[((int) (rindex1[0] + rindex2[0] + rindex3[0] + rindex4[0] + 2) >> 2) + blockvals[8]];
		2879	index[1] = cm[((int) (rindex1[1] + rindex2[1] + rindex3[1] + rindex4[1] + 2) >> 2) + blockvals[9]];
		2880	index[2] = cm[((int) (rindex1[2] + rindex2[2] + rindex3[2] + rindex4[2] + 2) >> 2) + blockvals[10]];
		2881	index[3] = cm[((int) (rindex1[3] + rindex2[3] + rindex3[3] + rindex4[3] + 2) >> 2) + blockvals[11]];
		2882	index[4] = cm[((int) (rindex1[4] + rindex2[4] + rindex3[4] + rindex4[4] + 2) >> 2) + blockvals[12]];
		2883	index[5] = cm[((int) (rindex1[5] + rindex2[5] + rindex3[5] + rindex4[5] + 2) >> 2) + blockvals[13]];
		2884	index[6] = cm[((int) (rindex1[6] + rindex2[6] + rindex3[6] + rindex4[6] + 2) >> 2) + blockvals[14]];
		2885	index[7] = cm[((int) (rindex1[7] + rindex2[7] + rindex3[7] + rindex4[7] + 2) >> 2) + blockvals[15]];
		2886	blockvals += 16;
		2887	index += row_size;
		2888	rindex1 += row_size;
		2889	rindex2 += row_size;
		2890	rindex3 += row_size;
		2891	rindex4 += row_size;
		2892	}
		2893	} else { /* zflag */
		2894	for (rr = 0; rr < 8; rr++) {
		2895	index[0] = (int) (rindex1[0] + rindex2[0] + rindex3[0] + rindex4[0] + 2) >> 2;
		2896	index[1] = (int) (rindex1[1] + rindex2[1] + rindex3[1] + rindex4[1] + 2) >> 2;
		2897	index[2] = (int) (rindex1[2] + rindex2[2] + rindex3[2] + rindex4[2] + 2) >> 2;
		2898	index[3] = (int) (rindex1[3] + rindex2[3] + rindex3[3] + rindex4[3] + 2) >> 2;
		2899	index[4] = (int) (rindex1[4] + rindex2[4] + rindex3[4] + rindex4[4] + 2) >> 2;
		2900	index[5] = (int) (rindex1[5] + rindex2[5] + rindex3[5] + rindex4[5] + 2) >> 2;
		2901	index[6] = (int) (rindex1[6] + rindex2[6] + rindex3[6] + rindex4[6] + 2) >> 2;
		2902	index[7] = (int) (rindex1[7] + rindex2[7] + rindex3[7] + rindex4[7] + 2) >> 2;
		2903	index += row_size;
		2904	rindex1 += row_size;
		2905	rindex2 += row_size;
		2906	rindex3 += row_size;
		2907	rindex4 += row_size;
		2908	}
		2909	}
		2910	}
		2911
		2912	}
		2913	#ifdef LOOSE_MPEG
		2914	}
		2915	#endif
		2916	}
		2917
		2918
		2919	/*
		2920	*--------------------------------------------------------------
		2921	*
		2922	* ReconBMBlock --
		2923	*
		2924	* Reconstructs back predicted macroblocks.
		2925	*
		2926	* Results:
		2927	* None.
		2928	*
		2929	* Side effects:
		2930	* None.
		2931	*
		2932	*--------------------------------------------------------------
		2933	*/
		2934
		2935	static void
		2936	ReconBMBlock(vid_stream, bnum, recon_right_back, recon_down_back, zflag)
		2937	VidStream *vid_stream;
		2938	int bnum, recon_right_back, recon_down_back, zflag;
		2939	{
		2940	int mb_row, mb_col, row, col, row_size, rr;
		2941	unsigned char dest, future;
		2942	int right_back, down_back, right_half_back, down_half_back;
		2943	unsigned char rindex1, rindex2, rindex3, rindex4;
		2944	unsigned char *index;
		2945	short int *blockvals;
		2946
		2947	#ifdef LOOSE_MPEG
		2948	int illegalBlock = 0;
		2949	int maxx, maxy, cc;
		2950	int row_start, row_end, rlast, rfirst, col_start, col_end, clast, cfirst;
		2951	#endif
		2952
		2953	/* Calculate macroblock row and column from address. */
		2954
		2955	mb_row = vid_stream->mblock.mb_address / vid_stream->mb_width;
		2956	mb_col = vid_stream->mblock.mb_address % vid_stream->mb_width;
		2957
		2958	/* If block is luminance block... */
		2959
		2960	if (bnum < 4) {
		2961
		2962	/* Calculate right_back, down_back motion vectors. */
		2963
		2964	right_back = recon_right_back >> 1;
		2965	down_back = recon_down_back >> 1;
		2966	right_half_back = recon_right_back & 0x1;
		2967	down_half_back = recon_down_back & 0x1;
		2968
		2969	/* Set dest to luminance plane of current pict image. */
		2970
		2971	dest = vid_stream->current->luminance;
		2972
		2973	/*
		2974	* If future frame exists, set future to luminance plane of future frame.
		2975	*/
		2976
		2977	if (vid_stream->future != NULL)
		2978	future = vid_stream->future->luminance;
		2979
		2980	/* Establish row size. */
		2981
		2982	row_size = vid_stream->mb_width << 4;
		2983
		2984	/* Calculate row,col of upper left pixel in block. */
		2985
		2986	row = mb_row << 4;
		2987	col = mb_col << 4;
		2988	if (bnum > 1)
		2989	row += 8;
		2990	if (bnum % 2)
		2991	col += 8;
		2992
		2993	#ifdef LOOSE_MPEG
		2994
		2995	/* Check for block illegality. */
		2996
		2997	maxx = vid_stream->mb_width*16-1;
		2998	maxy = vid_stream->mb_height*16-1;
		2999
		3000	if (row + down_back + 7 > maxy) illegalBlock \|= 0x4;
		3001	else if (row + down_back < 0) illegalBlock \|= 0x1;
		3002
		3003	if (col + right_back + 7 > maxx) illegalBlock \|= 0x2;
		3004	else if (col + right_back < 0) illegalBlock \|= 0x8;
		3005
		3006	#endif
		3007
		3008	}
		3009	/* Otherwise, block is NOT luminance block, ... */
		3010
		3011	else {
		3012
		3013	/* Construct motion vectors. */
		3014
		3015	recon_right_back /= 2;
		3016	recon_down_back /= 2;
		3017	right_back = recon_right_back >> 1;
		3018	down_back = recon_down_back >> 1;
		3019	right_half_back = recon_right_back & 0x1;
		3020	down_half_back = recon_down_back & 0x1;
		3021
		3022	/* Establish row size. */
		3023
		3024	row_size = vid_stream->mb_width << 3;
		3025
		3026	/* Calculate row,col of upper left pixel in block. */
		3027
		3028	row = mb_row << 3;
		3029	col = mb_col << 3;
		3030
		3031	#ifdef LOOSE_MPEG
		3032
		3033	/* Check for block illegality. */
		3034
		3035	maxx = vid_stream->mb_width*8-1;
		3036	maxy = vid_stream->mb_height*8-1;
		3037
		3038	if (row + down_back + 7 > maxy) illegalBlock \|= 0x4;
		3039	else if (row + down_back < 0) illegalBlock \|= 0x1;
		3040
		3041	if (col + right_back + 7 > maxx) illegalBlock \|= 0x2;
		3042	else if (col + right_back < 0) illegalBlock \|= 0x8;
		3043
		3044	#endif
		3045
		3046	/* If block is Cr block... */
		3047	/* They were switched earlier, so 5 is first - eyhung */
		3048
		3049	if (bnum == 5) {
		3050
		3051	/* Set dest to Cr plane of current pict image. */
		3052
		3053	dest = vid_stream->current->Cr;
		3054
		3055	/*
		3056	* If future frame exists, set future to Cr plane of future image.
		3057	*/
		3058
		3059	if (vid_stream->future != NULL)
		3060	future = vid_stream->future->Cr;
		3061	}
		3062	/* Otherwise, block is Cb block... */
		3063
		3064	else {
		3065
		3066	/* Set dest to Cb plane of current pict image. */
		3067
		3068	dest = vid_stream->current->Cb;
		3069
		3070	/*
		3071	* If future frame exists, set future to Cb plane of future frame.
		3072	*/
		3073
		3074	if (vid_stream->future != NULL)
		3075	future = vid_stream->future->Cb;
		3076	}
		3077	}
		3078
		3079	/* For each pixel in block do... */
		3080
		3081	#ifdef LOOSE_MPEG
		3082
		3083	if (illegalBlock) {
		3084	if (illegalBlock & 0x1) {
		3085	row_start = 0;
		3086	row_end = row+down_back+8;
		3087	rfirst = rlast = 8 - row_end;
		3088	}
		3089	else if (illegalBlock & 0x4) {
		3090	row_start = row + down_back;
		3091	row_end = maxy+1;
		3092	rlast = row_end - row_start - 1;
		3093	rfirst = 0;
		3094	}
		3095	else {
		3096	row_start = row+down_back;
		3097	row_end = row_start+8;
		3098	rfirst = 0;
		3099	}
		3100
		3101	if (illegalBlock & 0x8) {
		3102	col_start = 0;
		3103	col_end = col + right_back + 8;
		3104	cfirst = clast = 8 - col_end;
		3105	}
		3106	else if (illegalBlock & 0x2) {
		3107	col_start = col + right_back;
		3108	col_end = maxx + 1;
		3109	clast = col_end - col_start - 1;
		3110	cfirst = 0;
		3111	}
		3112	else {
		3113	col_start = col + right_back;
		3114	col_end = col_start + 8;
		3115	cfirst = 0;
		3116	}
		3117
		3118	for (rr = row_start; rr < row_end; rr++) {
		3119	rindex1 = future + (rr * row_size) + col_start;
		3120	index = dest + ((row + rfirst) * row_size) + col + cfirst;
		3121	for (cc = col_start; cc < col_end; cc++) {
		3122	index++ = rindex1++;
		3123	}
		3124	}
		3125
		3126	if (illegalBlock & 0x1) {
		3127	for (rr = rlast -1; rr >=0; rr--) {
		3128	index = dest + ((row + rr) * row_size) + col;
		3129	rindex1 = dest + ((row + rlast) * row_size) + col;
		3130	for (cc = 0; cc < 8; cc ++) {
		3131	index++ = rindex1++;
		3132	}
		3133	}
		3134	}
		3135	else if (illegalBlock & 0x4) {
		3136	for (rr = rlast+1; rr < 8; rr++) {
		3137	index = dest + ((row + rr) * row_size) + col;
		3138	rindex1 = dest + ((row + rlast) * row_size) + col;
		3139	for (cc = 0; cc < 8; cc ++) {
		3140	index++ = rindex1++;
		3141	}
		3142	}
		3143	}
		3144
		3145	if (illegalBlock & 0x2) {
		3146	for (cc = clast+1; cc < 8; cc++) {
		3147	index = dest + (row * row_size) + (col + cc);
		3148	rindex1 = dest + (row * row_size) + (col + clast);
		3149	for (rr = 0; rr < 8; rr++) {
		3150	index = rindex1;
		3151	index += row_size;
		3152	rindex1 += row_size;
		3153	}
		3154	}
		3155	}
		3156	else if (illegalBlock & 0x8) {
		3157	for (cc = clast-1; cc >= 0; cc--) {
		3158	index = dest + (row * row_size) + (col + cc);
		3159	rindex1 = dest + (row * row_size) + (col + clast);
		3160	for (rr = 0; rr < 8; rr++) {
		3161	index = rindex1;
		3162	index += row_size;
		3163	rindex1 += row_size;
		3164	}
		3165	}
		3166	}
		3167
		3168	if (!zflag) {
		3169	for (rr = 0; rr < 8; rr++) {
		3170	index = dest + (row*row_size) + col;
		3171	blockvals = &(vid_stream->block.dct_recon[rr][0]);
		3172	index[0] += blockvals[0];
		3173	index[1] += blockvals[1];
		3174	index[2] += blockvals[2];
		3175	index[3] += blockvals[3];
		3176	index[4] += blockvals[4];
		3177	index[5] += blockvals[5];
		3178	index[6] += blockvals[6];
		3179	index[7] += blockvals[7];
		3180	}
		3181	}
		3182	}
		3183	else {
		3184
		3185	#endif
		3186
		3187	index = dest + (row * row_size) + col;
		3188	rindex1 = future + (row + down_back) * row_size + col + right_back;
		3189
		3190	blockvals = &(vid_stream->block.dct_recon[0][0]);
		3191
		3192	if ((!right_half_back) && (!down_half_back)) {
		3193	unsigned char *cm = cropTbl + MAX_NEG_CROP;
		3194	if (!zflag)
		3195	for (rr = 0; rr < 4; rr++) {
		3196	index[0] = cm[(int) rindex1[0] + (int) blockvals[0]];
		3197	index[1] = cm[(int) rindex1[1] + (int) blockvals[1]];
		3198	index[2] = cm[(int) rindex1[2] + (int) blockvals[2]];
		3199	index[3] = cm[(int) rindex1[3] + (int) blockvals[3]];
		3200	index[4] = cm[(int) rindex1[4] + (int) blockvals[4]];
		3201	index[5] = cm[(int) rindex1[5] + (int) blockvals[5]];
		3202	index[6] = cm[(int) rindex1[6] + (int) blockvals[6]];
		3203	index[7] = cm[(int) rindex1[7] + (int) blockvals[7]];
		3204	index += row_size;
		3205	rindex1 += row_size;
		3206
		3207	index[0] = cm[(int) rindex1[0] + (int) blockvals[8]];
		3208	index[1] = cm[(int) rindex1[1] + (int) blockvals[9]];
		3209	index[2] = cm[(int) rindex1[2] + (int) blockvals[10]];
		3210	index[3] = cm[(int) rindex1[3] + (int) blockvals[11]];
		3211	index[4] = cm[(int) rindex1[4] + (int) blockvals[12]];
		3212	index[5] = cm[(int) rindex1[5] + (int) blockvals[13]];
		3213	index[6] = cm[(int) rindex1[6] + (int) blockvals[14]];
		3214	index[7] = cm[(int) rindex1[7] + (int) blockvals[15]];
		3215	blockvals += 16;
		3216	index += row_size;
		3217	rindex1 += row_size;
		3218	}
		3219	else {
		3220	if (right_back & 0x1) {
		3221	/* No alignment, use bye copy */
		3222	for (rr = 0; rr < 4; rr++) {
		3223	index[0] = rindex1[0];
		3224	index[1] = rindex1[1];
		3225	index[2] = rindex1[2];
		3226	index[3] = rindex1[3];
		3227	index[4] = rindex1[4];
		3228	index[5] = rindex1[5];
		3229	index[6] = rindex1[6];
		3230	index[7] = rindex1[7];
		3231	index += row_size;
		3232	rindex1 += row_size;
		3233
		3234	index[0] = rindex1[0];
		3235	index[1] = rindex1[1];
		3236	index[2] = rindex1[2];
		3237	index[3] = rindex1[3];
		3238	index[4] = rindex1[4];
		3239	index[5] = rindex1[5];
		3240	index[6] = rindex1[6];
		3241	index[7] = rindex1[7];
		3242	index += row_size;
		3243	rindex1 += row_size;
		3244	}
		3245	} else if (right_back & 0x2) {
		3246	/* Half-word bit aligned, use 16 bit copy */
		3247	short src = (short )rindex1;
		3248	short dest = (short )index;
		3249	row_size >>= 1;
		3250	for (rr = 0; rr < 4; rr++) {
		3251	dest[0] = src[0];
		3252	dest[1] = src[1];
		3253	dest[2] = src[2];
		3254	dest[3] = src[3];
		3255	dest += row_size;
		3256	src += row_size;
		3257
		3258	dest[0] = src[0];
		3259	dest[1] = src[1];
		3260	dest[2] = src[2];
		3261	dest[3] = src[3];
		3262	dest += row_size;
		3263	src += row_size;
		3264	}
		3265	} else {
		3266	/* Word aligned, use 32 bit copy */
		3267	int src = (int )rindex1;
		3268	int dest = (int )index;
		3269	row_size >>= 2;
		3270	for (rr = 0; rr < 4; rr++) {
		3271	dest[0] = src[0];
		3272	dest[1] = src[1];
		3273	dest += row_size;
		3274	src += row_size;
		3275
		3276	dest[0] = src[0];
		3277	dest[1] = src[1];
		3278	dest += row_size;
		3279	src += row_size;
		3280	}
		3281	}
		3282	}
		3283	} else {
		3284	unsigned char *cm = cropTbl + MAX_NEG_CROP;
		3285	rindex2 = rindex1 + right_half_back + (down_half_back * row_size);
		3286	if (!qualityFlag) {
		3287
		3288	if (!zflag) {
		3289	for (rr = 0; rr < 4; rr++) {
		3290	index[0] = cm[((int) (rindex1[0] + rindex2[0] + 1) >> 1) + blockvals[0]];
		3291	index[1] = cm[((int) (rindex1[1] + rindex2[1] + 1) >> 1) + blockvals[1]];
		3292	index[2] = cm[((int) (rindex1[2] + rindex2[2] + 1) >> 1) + blockvals[2]];
		3293	index[3] = cm[((int) (rindex1[3] + rindex2[3] + 1) >> 1) + blockvals[3]];
		3294	index[4] = cm[((int) (rindex1[4] + rindex2[4] + 1) >> 1) + blockvals[4]];
		3295	index[5] = cm[((int) (rindex1[5] + rindex2[5] + 1) >> 1) + blockvals[5]];
		3296	index[6] = cm[((int) (rindex1[6] + rindex2[6] + 1) >> 1) + blockvals[6]];
		3297	index[7] = cm[((int) (rindex1[7] + rindex2[7] + 1) >> 1) + blockvals[7]];
		3298	index += row_size;
		3299	rindex1 += row_size;
		3300	rindex2 += row_size;
		3301
		3302	index[0] = cm[((int) (rindex1[0] + rindex2[0] + 1) >> 1) + blockvals[8]];
		3303	index[1] = cm[((int) (rindex1[1] + rindex2[1] + 1) >> 1) + blockvals[9]];
		3304	index[2] = cm[((int) (rindex1[2] + rindex2[2] + 1) >> 1) + blockvals[10]];
		3305	index[3] = cm[((int) (rindex1[3] + rindex2[3] + 1) >> 1) + blockvals[11]];
		3306	index[4] = cm[((int) (rindex1[4] + rindex2[4] + 1) >> 1) + blockvals[12]];
		3307	index[5] = cm[((int) (rindex1[5] + rindex2[5] + 1) >> 1) + blockvals[13]];
		3308	index[6] = cm[((int) (rindex1[6] + rindex2[6] + 1) >> 1) + blockvals[14]];
		3309	index[7] = cm[((int) (rindex1[7] + rindex2[7] + 1) >> 1) + blockvals[15]];
		3310	blockvals += 16;
		3311	index += row_size;
		3312	rindex1 += row_size;
		3313	rindex2 += row_size;
		3314	}
		3315	} else { /* zflag */
		3316	for (rr = 0; rr < 8; rr++) {
		3317	index[0] = (int) (rindex1[0] + rindex2[0] + 1) >> 1;
		3318	index[1] = (int) (rindex1[1] + rindex2[1] + 1) >> 1;
		3319	index[2] = (int) (rindex1[2] + rindex2[2] + 1) >> 1;
		3320	index[3] = (int) (rindex1[3] + rindex2[3] + 1) >> 1;
		3321	index[4] = (int) (rindex1[4] + rindex2[4] + 1) >> 1;
		3322	index[5] = (int) (rindex1[5] + rindex2[5] + 1) >> 1;
		3323	index[6] = (int) (rindex1[6] + rindex2[6] + 1) >> 1;
		3324	index[7] = (int) (rindex1[7] + rindex2[7] + 1) >> 1;
		3325	index += row_size;
		3326	rindex1 += row_size;
		3327	rindex2 += row_size;
		3328	}
		3329	}
		3330	} else { /* qualityFlag on */
		3331	rindex3 = rindex1 + right_half_back;
		3332	rindex4 = rindex1 + (down_half_back * row_size);
		3333	if (!zflag) {
		3334	for (rr = 0; rr < 4; rr++) {
		3335	index[0] = cm[((int) (rindex1[0] + rindex2[0] + rindex3[0] + rindex4[0] + 2) >> 2) + blockvals[0]];
		3336	index[1] = cm[((int) (rindex1[1] + rindex2[1] + rindex3[1] + rindex4[1] + 2) >> 2) + blockvals[1]];
		3337	index[2] = cm[((int) (rindex1[2] + rindex2[2] + rindex3[2] + rindex4[2] + 2) >> 2) + blockvals[2]];
		3338	index[3] = cm[((int) (rindex1[3] + rindex2[3] + rindex3[3] + rindex4[3] + 2) >> 2) + blockvals[3]];
		3339	index[4] = cm[((int) (rindex1[4] + rindex2[4] + rindex3[4] + rindex4[4] + 2) >> 2) + blockvals[4]];
		3340	index[5] = cm[((int) (rindex1[5] + rindex2[5] + rindex3[5] + rindex4[5] + 2) >> 2) + blockvals[5]];
		3341	index[6] = cm[((int) (rindex1[6] + rindex2[6] + rindex3[6] + rindex4[6] + 2) >> 2) + blockvals[6]];
		3342	index[7] = cm[((int) (rindex1[7] + rindex2[7] + rindex3[7] + rindex4[7] + 2) >> 2) + blockvals[7]];
		3343	index += row_size;
		3344	rindex1 += row_size;
		3345	rindex2 += row_size;
		3346	rindex3 += row_size;
		3347	rindex4 += row_size;
		3348
		3349	index[0] = cm[((int) (rindex1[0] + rindex2[0] + rindex3[0] + rindex4[0] + 2) >> 2) + blockvals[8]];
		3350	index[1] = cm[((int) (rindex1[1] + rindex2[1] + rindex3[1] + rindex4[1] + 2) >> 2) + blockvals[9]];
		3351	index[2] = cm[((int) (rindex1[2] + rindex2[2] + rindex3[2] + rindex4[2] + 2) >> 2) + blockvals[10]];
		3352	index[3] = cm[((int) (rindex1[3] + rindex2[3] + rindex3[3] + rindex4[3] + 2) >> 2) + blockvals[11]];
		3353	index[4] = cm[((int) (rindex1[4] + rindex2[4] + rindex3[4] + rindex4[4] + 2) >> 2) + blockvals[12]];
		3354	index[5] = cm[((int) (rindex1[5] + rindex2[5] + rindex3[5] + rindex4[5] + 2) >> 2) + blockvals[13]];
		3355	index[6] = cm[((int) (rindex1[6] + rindex2[6] + rindex3[6] + rindex4[6] + 2) >> 2) + blockvals[14]];
		3356	index[7] = cm[((int) (rindex1[7] + rindex2[7] + rindex3[7] + rindex4[7] + 2) >> 2) + blockvals[15]];
		3357	blockvals += 16;
		3358	index += row_size;
		3359	rindex1 += row_size;
		3360	rindex2 += row_size;
		3361	rindex3 += row_size;
		3362	rindex4 += row_size;
		3363	}
		3364	} else { /* zflag */
		3365	for (rr = 0; rr < 8; rr++) {
		3366	index[0] = (int) (rindex1[0] + rindex2[0] + rindex3[0] + rindex4[0] + 2) >> 2;
		3367	index[1] = (int) (rindex1[1] + rindex2[1] + rindex3[1] + rindex4[1] + 2) >> 2;
		3368	index[2] = (int) (rindex1[2] + rindex2[2] + rindex3[2] + rindex4[2] + 2) >> 2;
		3369	index[3] = (int) (rindex1[3] + rindex2[3] + rindex3[3] + rindex4[3] + 2) >> 2;
		3370	index[4] = (int) (rindex1[4] + rindex2[4] + rindex3[4] + rindex4[4] + 2) >> 2;
		3371	index[5] = (int) (rindex1[5] + rindex2[5] + rindex3[5] + rindex4[5] + 2) >> 2;
		3372	index[6] = (int) (rindex1[6] + rindex2[6] + rindex3[6] + rindex4[6] + 2) >> 2;
		3373	index[7] = (int) (rindex1[7] + rindex2[7] + rindex3[7] + rindex4[7] + 2) >> 2;
		3374	index += row_size;
		3375	rindex1 += row_size;
		3376	rindex2 += row_size;
		3377	rindex3 += row_size;
		3378	rindex4 += row_size;
		3379	}
		3380	}
		3381	}
		3382
		3383	}
		3384	#ifdef LOOSE_MPEG
		3385	}
		3386	#endif
		3387	}
		3388
		3389
		3390	/*
		3391	*--------------------------------------------------------------
		3392	*
		3393	* ReconBiMBlock --
		3394	*
		3395	* Reconstructs bidirectionally predicted macroblocks.
		3396	*
		3397	* Results:
		3398	* None.
		3399	*
		3400	* Side effects:
		3401	* None.
		3402	*
		3403	*--------------------------------------------------------------
		3404	*/
		3405
		3406	static void
		3407	ReconBiMBlock(vid_stream, bnum, recon_right_for, recon_down_for,
		3408	recon_right_back, recon_down_back, zflag)
		3409	VidStream *vid_stream;
		3410	int bnum, recon_right_for, recon_down_for, recon_right_back, recon_down_back;
		3411	int zflag;
		3412	{
		3413	int mb_row, mb_col, row, col, row_size, rr;
		3414	unsigned char dest, past=NULL, *future=NULL;
		3415	int right_for, down_for, right_half_for, down_half_for;
		3416	int right_back, down_back, right_half_back, down_half_back;
		3417	unsigned char index, rindex1, *bindex1;
		3418	short int *blockvals;
		3419	int forw_row_start, back_row_start, forw_col_start, back_col_start;
		3420	#ifdef LOOSE_MPEG
		3421	int lmaxx = vid_stream->mb_width*16-1;
		3422	int lmaxy = vid_stream->mb_height*16-1;
		3423	int cmaxx = vid_stream->mb_width*8-1;
		3424	int cmaxy = vid_stream->mb_height*8-1;
		3425	#endif
		3426
		3427	#ifdef LOOSE_MPEG
		3428	int illegal_forw = 0;
		3429	int illegal_back = 0;
		3430	#endif
		3431
		3432	/* Calculate macroblock row and column from address. */
		3433
		3434	mb_row = vid_stream->mblock.mb_address / vid_stream->mb_width;
		3435	mb_col = vid_stream->mblock.mb_address % vid_stream->mb_width;
		3436
		3437	/* If block is luminance block... */
		3438
		3439	if (bnum < 4) {
		3440
		3441	/*
		3442	* Calculate right_for, down_for, right_half_for, down_half_for,
		3443	* right_back, down_bakc, right_half_back, and down_half_back, motion
		3444	* vectors.
		3445	*/
		3446
		3447	right_for = recon_right_for >> 1;
		3448	down_for = recon_down_for >> 1;
		3449	right_half_for = recon_right_for & 0x1;
		3450	down_half_for = recon_down_for & 0x1;
		3451
		3452	right_back = recon_right_back >> 1;
		3453	down_back = recon_down_back >> 1;
		3454	right_half_back = recon_right_back & 0x1;
		3455	down_half_back = recon_down_back & 0x1;
		3456
		3457	/* Set dest to luminance plane of current pict image. */
		3458
		3459	dest = vid_stream->current->luminance;
		3460
		3461	/* If past frame exists, set past to luminance plane of past frame. */
		3462
		3463	if (vid_stream->past != NULL)
		3464	past = vid_stream->past->luminance;
		3465
		3466	/*
		3467	* If future frame exists, set future to luminance plane of future frame.
		3468	*/
		3469
		3470	if (vid_stream->future != NULL)
		3471	future = vid_stream->future->luminance;
		3472
		3473	/* Establish row size. */
		3474
		3475	row_size = (vid_stream->mb_width << 4);
		3476
		3477	/* Calculate row,col of upper left pixel in block. */
		3478
		3479	row = (mb_row << 4);
		3480	col = (mb_col << 4);
		3481	if (bnum > 1)
		3482	row += 8;
		3483	if (bnum & 0x01)
		3484	col += 8;
		3485
		3486	forw_col_start = col + right_for;
		3487	forw_row_start = row + down_for;
		3488
		3489	back_col_start = col + right_back;
		3490	back_row_start = row + down_back;
		3491
		3492	#ifdef LOOSE_MPEG
		3493
		3494	/* Check for illegal pred. blocks. */
		3495
		3496
		3497	if (forw_col_start+7 > lmaxx) illegal_forw = 1;
		3498	else if (forw_col_start < 0) illegal_forw = 1;
		3499
		3500	if (forw_row_start+7 > lmaxy) illegal_forw = 1;
		3501	else if (forw_row_start < 0) illegal_forw = 1;
		3502
		3503	if (back_col_start+7 > lmaxx) illegal_back = 1;
		3504	else if (back_col_start < 0) illegal_back = 1;
		3505
		3506	if (back_row_start+7 > lmaxy) illegal_back = 1;
		3507	else if (back_row_start < 0) illegal_back = 1;
		3508
		3509	#endif
		3510
		3511	}
		3512	/* Otherwise, block is NOT luminance block, ... */
		3513
		3514	else {
		3515
		3516	/* Construct motion vectors. */
		3517
		3518	recon_right_for /= 2;
		3519	recon_down_for /= 2;
		3520	right_for = recon_right_for >> 1;
		3521	down_for = recon_down_for >> 1;
		3522	right_half_for = recon_right_for & 0x1;
		3523	down_half_for = recon_down_for & 0x1;
		3524
		3525	recon_right_back /= 2;
		3526	recon_down_back /= 2;
		3527	right_back = recon_right_back >> 1;
		3528	down_back = recon_down_back >> 1;
		3529	right_half_back = recon_right_back & 0x1;
		3530	down_half_back = recon_down_back & 0x1;
		3531
		3532	/* Establish row size. */
		3533
		3534	row_size = (vid_stream->mb_width << 3);
		3535
		3536	/* Calculate row,col of upper left pixel in block. */
		3537
		3538	row = (mb_row << 3);
		3539	col = (mb_col << 3);
		3540
		3541	forw_col_start = col + right_for;
		3542	forw_row_start = row + down_for;
		3543
		3544	back_col_start = col + right_back;
		3545	back_row_start = row + down_back;
		3546
		3547	#ifdef LOOSE_MPEG
		3548
		3549	/* Check for illegal pred. blocks. */
		3550
		3551	if (forw_col_start+7 > cmaxx) illegal_forw = 1;
		3552	else if (forw_col_start < 0) illegal_forw = 1;
		3553
		3554	if (forw_row_start+7 > cmaxy) illegal_forw = 1;
		3555	else if (forw_row_start < 0) illegal_forw = 1;
		3556
		3557	if (back_col_start+7 > cmaxx) illegal_back = 1;
		3558	else if (back_col_start < 0) illegal_back = 1;
		3559
		3560	if (back_row_start+7 > cmaxy) illegal_back = 1;
		3561	else if (back_row_start < 0) illegal_back = 1;
		3562
		3563	#endif
		3564
		3565	/* If block is Cr block... */
		3566	/* Switched earlier, so we test Cr first - eyhung */
		3567
		3568	if (bnum == 5) {
		3569
		3570	/* Set dest to Cr plane of current pict image. */
		3571
		3572	dest = vid_stream->current->Cr;
		3573
		3574	/* If past frame exists, set past to Cr plane of past image. */
		3575
		3576	if (vid_stream->past != NULL)
		3577	past = vid_stream->past->Cr;
		3578
		3579	/*
		3580	* If future frame exists, set future to Cr plane of future image.
		3581	*/
		3582
		3583	if (vid_stream->future != NULL)
		3584	future = vid_stream->future->Cr;
		3585	}
		3586	/* Otherwise, block is Cb block... */
		3587
		3588	else {
		3589
		3590	/* Set dest to Cb plane of current pict image. */
		3591
		3592	dest = vid_stream->current->Cb;
		3593
		3594	/* If past frame exists, set past to Cb plane of past frame. */
		3595
		3596	if (vid_stream->past != NULL)
		3597	past = vid_stream->past->Cb;
		3598
		3599	/*
		3600	* If future frame exists, set future to Cb plane of future frame.
		3601	*/
		3602
		3603	if (vid_stream->future != NULL)
		3604	future = vid_stream->future->Cb;
		3605	}
		3606	}
		3607
		3608	/* For each pixel in block... */
		3609
		3610	index = dest + (row * row_size) + col;
		3611
		3612	#ifdef LOOSE_MPEG
		3613	if (illegal_forw)
		3614	rindex1 = future + back_row_start * row_size + back_col_start;
		3615	else
		3616	#endif
		3617	rindex1 = past + forw_row_start * row_size + forw_col_start;
		3618
		3619	#ifdef LOOSE_MPEG
		3620	if (illegal_back)
		3621	bindex1 = past + forw_row_start * row_size + forw_col_start;
		3622	else
		3623	#endif
		3624	bindex1 = future + back_row_start * row_size + back_col_start;
		3625
		3626	blockvals = (short int *) &(vid_stream->block.dct_recon[0][0]);
		3627
		3628	{
		3629	unsigned char *cm = cropTbl + MAX_NEG_CROP;
		3630	if (!zflag)
		3631	for (rr = 0; rr < 4; rr++) {
		3632	index[0] = cm[((int) (rindex1[0] + bindex1[0]) >> 1) + blockvals[0]];
		3633	index[1] = cm[((int) (rindex1[1] + bindex1[1]) >> 1) + blockvals[1]];
		3634	index[2] = cm[((int) (rindex1[2] + bindex1[2]) >> 1) + blockvals[2]];
		3635	index[3] = cm[((int) (rindex1[3] + bindex1[3]) >> 1) + blockvals[3]];
		3636	index[4] = cm[((int) (rindex1[4] + bindex1[4]) >> 1) + blockvals[4]];
		3637	index[5] = cm[((int) (rindex1[5] + bindex1[5]) >> 1) + blockvals[5]];
		3638	index[6] = cm[((int) (rindex1[6] + bindex1[6]) >> 1) + blockvals[6]];
		3639	index[7] = cm[((int) (rindex1[7] + bindex1[7]) >> 1) + blockvals[7]];
		3640	index += row_size;
		3641	rindex1 += row_size;
		3642	bindex1 += row_size;
		3643
		3644	index[0] = cm[((int) (rindex1[0] + bindex1[0]) >> 1) + blockvals[8]];
		3645	index[1] = cm[((int) (rindex1[1] + bindex1[1]) >> 1) + blockvals[9]];
		3646	index[2] = cm[((int) (rindex1[2] + bindex1[2]) >> 1) + blockvals[10]];
		3647	index[3] = cm[((int) (rindex1[3] + bindex1[3]) >> 1) + blockvals[11]];
		3648	index[4] = cm[((int) (rindex1[4] + bindex1[4]) >> 1) + blockvals[12]];
		3649	index[5] = cm[((int) (rindex1[5] + bindex1[5]) >> 1) + blockvals[13]];
		3650	index[6] = cm[((int) (rindex1[6] + bindex1[6]) >> 1) + blockvals[14]];
		3651	index[7] = cm[((int) (rindex1[7] + bindex1[7]) >> 1) + blockvals[15]];
		3652	blockvals += 16;
		3653	index += row_size;
		3654	rindex1 += row_size;
		3655	bindex1 += row_size;
		3656	}
		3657
		3658	else
		3659	for (rr = 0; rr < 4; rr++) {
		3660	index[0] = (int) (rindex1[0] + bindex1[0]) >> 1;
		3661	index[1] = (int) (rindex1[1] + bindex1[1]) >> 1;
		3662	index[2] = (int) (rindex1[2] + bindex1[2]) >> 1;
		3663	index[3] = (int) (rindex1[3] + bindex1[3]) >> 1;
		3664	index[4] = (int) (rindex1[4] + bindex1[4]) >> 1;
		3665	index[5] = (int) (rindex1[5] + bindex1[5]) >> 1;
		3666	index[6] = (int) (rindex1[6] + bindex1[6]) >> 1;
		3667	index[7] = (int) (rindex1[7] + bindex1[7]) >> 1;
		3668	index += row_size;
		3669	rindex1 += row_size;
		3670	bindex1 += row_size;
		3671
		3672	index[0] = (int) (rindex1[0] + bindex1[0]) >> 1;
		3673	index[1] = (int) (rindex1[1] + bindex1[1]) >> 1;
		3674	index[2] = (int) (rindex1[2] + bindex1[2]) >> 1;
		3675	index[3] = (int) (rindex1[3] + bindex1[3]) >> 1;
		3676	index[4] = (int) (rindex1[4] + bindex1[4]) >> 1;
		3677	index[5] = (int) (rindex1[5] + bindex1[5]) >> 1;
		3678	index[6] = (int) (rindex1[6] + bindex1[6]) >> 1;
		3679	index[7] = (int) (rindex1[7] + bindex1[7]) >> 1;
		3680	index += row_size;
		3681	rindex1 += row_size;
		3682	bindex1 += row_size;
		3683	}
		3684	}
		3685	}
		3686
		3687
		3688	/*
		3689	*--------------------------------------------------------------
		3690	*
		3691	* ProcessSkippedPFrameMBlocks --
		3692	*
		3693	* Processes skipped macroblocks in P frames.
		3694	*
		3695	* Results:
		3696	* Calculates pixel values for luminance, Cr, and Cb planes
		3697	* in current pict image for skipped macroblocks.
		3698	*
		3699	* Side effects:
		3700	* Pixel values in pict image changed.
		3701	*
		3702	*--------------------------------------------------------------
		3703	*/
		3704
		3705	static void
		3706	ProcessSkippedPFrameMBlocks(vid_stream)
		3707	VidStream *vid_stream;
		3708	{
		3709	int row_size, half_row, mb_row, mb_col, row, col, rr;
		3710	int addr, row_incr, half_row_incr, crow, ccol;
		3711	int dest, src, dest1, src1;
		3712	int ditherType=vid_stream->ditherType;
		3713
		3714	/* Calculate row sizes for luminance and Cr/Cb macroblock areas. */
		3715
		3716	row_size = vid_stream->mb_width << 4;
		3717	half_row = (row_size >> 1);
		3718	row_incr = row_size >> 2;
		3719	half_row_incr = half_row >> 2;
		3720
		3721	/* For each skipped macroblock, do... */
		3722
		3723	for (addr = vid_stream->mblock.past_mb_addr + 1;
		3724	addr < vid_stream->mblock.mb_address; addr++) {
		3725
		3726	/* Calculate macroblock row and col. */
		3727
		3728	mb_row = addr / vid_stream->mb_width;
		3729	mb_col = addr % vid_stream->mb_width;
		3730
		3731	/* Calculate upper left pixel row,col for luminance plane. */
		3732
		3733	row = mb_row << 4;
		3734	col = mb_col << 4;
		3735
		3736
		3737	/* For each row in macroblock luminance plane... */
		3738
		3739	dest = (int )(vid_stream->current->luminance + (row row_size) + col);
		3740	src = (int )(vid_stream->future->luminance + (row row_size) + col);
		3741
		3742	for (rr = 0; rr < 8; rr++) {
		3743
		3744	/* Copy pixel values from last I or P picture. */
		3745
		3746	dest[0] = src[0];
		3747	dest[1] = src[1];
		3748	dest[2] = src[2];
		3749	dest[3] = src[3];
		3750	dest += row_incr;
		3751	src += row_incr;
		3752
		3753	dest[0] = src[0];
		3754	dest[1] = src[1];
		3755	dest[2] = src[2];
		3756	dest[3] = src[3];
		3757	dest += row_incr;
		3758	src += row_incr;
		3759	}
		3760
		3761	/*
		3762	* Divide row,col to get upper left pixel of macroblock in Cr and Cb
		3763	* planes.
		3764	*/
		3765
		3766	crow = row >> 1;
		3767	ccol = col >> 1;
		3768
		3769	/* For each row in Cr, and Cb planes... */
		3770
		3771	dest = (int )(vid_stream->current->Cr + (crow half_row) + ccol);
		3772	src = (int )(vid_stream->future->Cr + (crow half_row) + ccol);
		3773	dest1 = (int )(vid_stream->current->Cb + (crow half_row) + ccol);
		3774	src1 = (int )(vid_stream->future->Cb + (crow half_row) + ccol);
		3775
		3776	for (rr = 0; rr < 4; rr++) {
		3777
		3778	/* Copy pixel values from last I or P picture. */
		3779
		3780	dest[0] = src[0];
		3781	dest[1] = src[1];
		3782
		3783	dest1[0] = src1[0];
		3784	dest1[1] = src1[1];
		3785
		3786	dest += half_row_incr;
		3787	src += half_row_incr;
		3788	dest1 += half_row_incr;
		3789	src1 += half_row_incr;
		3790
		3791	dest[0] = src[0];
		3792	dest[1] = src[1];
		3793
		3794	dest1[0] = src1[0];
		3795	dest1[1] = src1[1];
		3796
		3797	dest += half_row_incr;
		3798	src += half_row_incr;
		3799	dest1 += half_row_incr;
		3800	src1 += half_row_incr;
		3801	}
		3802
		3803	#ifndef DISABLE_DITHER
		3804	if (ditherType == MBORDERED_DITHER) {
		3805	MBOrderedDitherDisplayCopy(vid_stream, addr,
		3806	1, 0, 0, 0, 0, 0,
		3807	vid_stream->future->display,
		3808	(unsigned char *) NULL);
		3809	vid_stream->ditherFlags[addr] = 0;
		3810	}
		3811	#endif
		3812	}
		3813
		3814	vid_stream->mblock.recon_right_for_prev = 0;
		3815	vid_stream->mblock.recon_down_for_prev = 0;
		3816	}
		3817
		3818
		3819
		3820
		3821
		3822	/*
		3823	*--------------------------------------------------------------
		3824	*
		3825	* ProcessSkippedBFrameMBlocks --
		3826	*
		3827	* Processes skipped macroblocks in B frames.
		3828	*
		3829	* Results:
		3830	* Calculates pixel values for luminance, Cr, and Cb planes
		3831	* in current pict image for skipped macroblocks.
		3832	*
		3833	* Side effects:
		3834	* Pixel values in pict image changed.
		3835	*
		3836	*--------------------------------------------------------------
		3837	*/
		3838
		3839	static void
		3840	ProcessSkippedBFrameMBlocks(vid_stream)
		3841	VidStream *vid_stream;
		3842	{
		3843	int row_size, half_row, mb_row, mb_col, row, col, rr;
		3844	int right_half_for = 0, down_half_for = 0;
		3845	int c_right_half_for = 0, c_down_half_for = 0;
		3846	int right_half_back = 0, down_half_back = 0;
		3847	int c_right_half_back = 0, c_down_half_back = 0;
		3848	int addr, right_for = 0, down_for = 0;
		3849	int recon_right_for, recon_down_for;
		3850	int recon_right_back, recon_down_back;
		3851	int right_back = 0, down_back = 0;
		3852	int c_right_for = 0, c_down_for = 0;
		3853	int c_right_back = 0, c_down_back = 0;
		3854	unsigned char forw_lum[256];
		3855	unsigned char forw_cr[64], forw_cb[64];
		3856	unsigned char back_lum[256], back_cr[64], back_cb[64];
		3857	int row_incr, half_row_incr;
		3858	int ccol, crow;
		3859	int ditherType=vid_stream->ditherType;
		3860
		3861	/* Calculate row sizes for luminance and Cr/Cb macroblock areas. */
		3862
		3863	row_size = vid_stream->mb_width << 4;
		3864	half_row = (row_size >> 1);
		3865	row_incr = row_size >> 2;
		3866	half_row_incr = half_row >> 2;
		3867
		3868	/* Establish motion vector codes based on full pixel flag. */
		3869
		3870	if (vid_stream->picture.full_pel_forw_vector) {
		3871	recon_right_for = vid_stream->mblock.recon_right_for_prev << 1;
		3872	recon_down_for = vid_stream->mblock.recon_down_for_prev << 1;
		3873	} else {
		3874	recon_right_for = vid_stream->mblock.recon_right_for_prev;
		3875	recon_down_for = vid_stream->mblock.recon_down_for_prev;
		3876	}
		3877
		3878	if (vid_stream->picture.full_pel_back_vector) {
		3879	recon_right_back = vid_stream->mblock.recon_right_back_prev << 1;
		3880	recon_down_back = vid_stream->mblock.recon_down_back_prev << 1;
		3881	} else {
		3882	recon_right_back = vid_stream->mblock.recon_right_back_prev;
		3883	recon_down_back = vid_stream->mblock.recon_down_back_prev;
		3884	}
		3885
		3886
		3887	/* If only one motion vector, do display copy, else do full
		3888	calculation.
		3889	*/
		3890
		3891	#ifndef DISABLE_DITHER
		3892	if (ditherType == MBORDERED_DITHER) {
		3893	if (vid_stream->mblock.bpict_past_forw &&
		3894	!vid_stream->mblock.bpict_past_back) {
		3895	for (addr = vid_stream->mblock.past_mb_addr+1;
		3896	addr < vid_stream->mblock.mb_address; addr++) {
		3897
		3898	MBOrderedDitherDisplayCopy(vid_stream, addr,
		3899	1, recon_right_for, recon_down_for,
		3900	0, 0, 0, vid_stream->past->display,
		3901	vid_stream->future->display);
		3902	vid_stream->ditherFlags[addr] = 0;
		3903	}
		3904	return;
		3905	}
		3906	if (vid_stream->mblock.bpict_past_back &&
		3907	!vid_stream->mblock.bpict_past_forw) {
		3908	for (addr = vid_stream->mblock.past_mb_addr+1;
		3909	addr < vid_stream->mblock.mb_address; addr++) {
		3910
		3911	MBOrderedDitherDisplayCopy(vid_stream, addr,
		3912	0, 0, 0,
		3913	1, recon_right_back, recon_down_back,
		3914	vid_stream->past->display, vid_stream->future->display);
		3915	vid_stream->ditherFlags[addr] = 0;
		3916	}
		3917	return;
		3918	}
		3919	}
		3920	#endif
		3921
		3922	/* Calculate motion vectors. */
		3923
		3924	if (vid_stream->mblock.bpict_past_forw) {
		3925	right_for = recon_right_for >> 1;
		3926	down_for = recon_down_for >> 1;
		3927	right_half_for = recon_right_for & 0x1;
		3928	down_half_for = recon_down_for & 0x1;
		3929
		3930	recon_right_for /= 2;
		3931	recon_down_for /= 2;
		3932	c_right_for = recon_right_for >> 1;
		3933	c_down_for = recon_down_for >> 1;
		3934	c_right_half_for = recon_right_for & 0x1;
		3935	c_down_half_for = recon_down_for & 0x1;
		3936
		3937	}
		3938	if (vid_stream->mblock.bpict_past_back) {
		3939	right_back = recon_right_back >> 1;
		3940	down_back = recon_down_back >> 1;
		3941	right_half_back = recon_right_back & 0x1;
		3942	down_half_back = recon_down_back & 0x1;
		3943
		3944	recon_right_back /= 2;
		3945	recon_down_back /= 2;
		3946	c_right_back = recon_right_back >> 1;
		3947	c_down_back = recon_down_back >> 1;
		3948	c_right_half_back = recon_right_back & 0x1;
		3949	c_down_half_back = recon_down_back & 0x1;
		3950
		3951	}
		3952	/* For each skipped macroblock, do... */
		3953
		3954	for (addr = vid_stream->mblock.past_mb_addr + 1;
		3955	addr < vid_stream->mblock.mb_address; addr++) {
		3956
		3957	/* Calculate macroblock row and col. */
		3958
		3959	mb_row = addr / vid_stream->mb_width;
		3960	mb_col = addr % vid_stream->mb_width;
		3961
		3962	/* Calculate upper left pixel row,col for luminance plane. */
		3963
		3964	row = mb_row << 4;
		3965	col = mb_col << 4;
		3966	crow = row / 2;
		3967	ccol = col / 2;
		3968
		3969	/* If forward predicted, calculate prediction values. */
		3970
		3971	if (vid_stream->mblock.bpict_past_forw) {
		3972
		3973	ReconSkippedBlock(vid_stream->past->luminance, forw_lum,
		3974	row, col, row_size, right_for, down_for,
		3975	right_half_for, down_half_for, 16);
		3976	ReconSkippedBlock(vid_stream->past->Cr, forw_cr, crow,
		3977	ccol, half_row,
		3978	c_right_for, c_down_for, c_right_half_for, c_down_half_for, 8);
		3979	ReconSkippedBlock(vid_stream->past->Cb, forw_cb, crow,
		3980	ccol, half_row,
		3981	c_right_for, c_down_for, c_right_half_for, c_down_half_for, 8);
		3982	}
		3983	/* If back predicted, calculate prediction values. */
		3984
		3985	if (vid_stream->mblock.bpict_past_back) {
		3986	ReconSkippedBlock(vid_stream->future->luminance, back_lum,
		3987	row, col, row_size, right_back, down_back,
		3988	right_half_back, down_half_back, 16);
		3989	ReconSkippedBlock(vid_stream->future->Cr, back_cr, crow,
		3990	ccol, half_row,
		3991	c_right_back, c_down_back,
		3992	c_right_half_back, c_down_half_back, 8);
		3993	ReconSkippedBlock(vid_stream->future->Cb, back_cb, crow,
		3994	ccol, half_row,
		3995	c_right_back, c_down_back,
		3996	c_right_half_back, c_down_half_back, 8);
		3997	}
		3998	if (vid_stream->mblock.bpict_past_forw &&
		3999	!vid_stream->mblock.bpict_past_back) {
		4000
		4001	int dest, dest1;
		4002	int src, src1;
		4003	dest = (int )(vid_stream->current->luminance + (row row_size) + col);
		4004	src = (int *)forw_lum;
		4005
		4006	for (rr = 0; rr < 16; rr++) {
		4007
		4008	/* memcpy(dest, forw_lum+(rr<<4), 16); */
		4009	dest[0] = src[0];
		4010	dest[1] = src[1];
		4011	dest[2] = src[2];
		4012	dest[3] = src[3];
		4013	dest += row_incr;
		4014	src += 4;
		4015	}
		4016
		4017	dest = (int )(vid_stream->current->Cr + (crow half_row) + ccol);
		4018	dest1 = (int )(vid_stream->current->Cb + (crow half_row) + ccol);
		4019	src = (int *)forw_cr;
		4020	src1 = (int *)forw_cb;
		4021
		4022	for (rr = 0; rr < 8; rr++) {
		4023	/*
		4024	* memcpy(dest, forw_cr+(rr<<3), 8); memcpy(dest1, forw_cb+(rr<<3),
		4025	* 8);
		4026	*/
		4027
		4028	dest[0] = src[0];
		4029	dest[1] = src[1];
		4030
		4031	dest1[0] = src1[0];
		4032	dest1[1] = src1[1];
		4033
		4034	dest += half_row_incr;
		4035	dest1 += half_row_incr;
		4036	src += 2;
		4037	src1 += 2;
		4038	}
		4039	} else if (vid_stream->mblock.bpict_past_back &&
		4040	!vid_stream->mblock.bpict_past_forw) {
		4041
		4042	int src, src1;
		4043	int dest, dest1;
		4044	dest = (int )(vid_stream->current->luminance + (row row_size) + col);
		4045	src = (int *)back_lum;
		4046
		4047	for (rr = 0; rr < 16; rr++) {
		4048	dest[0] = src[0];
		4049	dest[1] = src[1];
		4050	dest[2] = src[2];
		4051	dest[3] = src[3];
		4052	dest += row_incr;
		4053	src += 4;
		4054	}
		4055
		4056
		4057	dest = (int )(vid_stream->current->Cr + (crow half_row) + ccol);
		4058	dest1 = (int )(vid_stream->current->Cb + (crow half_row) + ccol);
		4059	src = (int *)back_cr;
		4060	src1 = (int *)back_cb;
		4061
		4062	for (rr = 0; rr < 8; rr++) {
		4063	/*
		4064	* memcpy(dest, back_cr+(rr<<3), 8); memcpy(dest1, back_cb+(rr<<3),
		4065	* 8);
		4066	*/
		4067
		4068	dest[0] = src[0];
		4069	dest[1] = src[1];
		4070
		4071	dest1[0] = src1[0];
		4072	dest1[1] = src1[1];
		4073
		4074	dest += half_row_incr;
		4075	dest1 += half_row_incr;
		4076	src += 2;
		4077	src1 += 2;
		4078	}
		4079	} else {
		4080
		4081	unsigned char src1, src2, src1a, src2a;
		4082	unsigned char dest, dest1;
		4083	dest = vid_stream->current->luminance + (row * row_size) + col;
		4084	src1 = forw_lum;
		4085	src2 = back_lum;
		4086
		4087	for (rr = 0; rr < 16; rr++) {
		4088	dest[0] = (int) (src1[0] + src2[0]) >> 1;
		4089	dest[1] = (int) (src1[1] + src2[1]) >> 1;
		4090	dest[2] = (int) (src1[2] + src2[2]) >> 1;
		4091	dest[3] = (int) (src1[3] + src2[3]) >> 1;
		4092	dest[4] = (int) (src1[4] + src2[4]) >> 1;
		4093	dest[5] = (int) (src1[5] + src2[5]) >> 1;
		4094	dest[6] = (int) (src1[6] + src2[6]) >> 1;
		4095	dest[7] = (int) (src1[7] + src2[7]) >> 1;
		4096	dest[8] = (int) (src1[8] + src2[8]) >> 1;
		4097	dest[9] = (int) (src1[9] + src2[9]) >> 1;
		4098	dest[10] = (int) (src1[10] + src2[10]) >> 1;
		4099	dest[11] = (int) (src1[11] + src2[11]) >> 1;
		4100	dest[12] = (int) (src1[12] + src2[12]) >> 1;
		4101	dest[13] = (int) (src1[13] + src2[13]) >> 1;
		4102	dest[14] = (int) (src1[14] + src2[14]) >> 1;
		4103	dest[15] = (int) (src1[15] + src2[15]) >> 1;
		4104	dest += row_size;
		4105	src1 += 16;
		4106	src2 += 16;
		4107	}
		4108
		4109
		4110	dest = vid_stream->current->Cr + (crow * half_row) + ccol;
		4111	dest1 = vid_stream->current->Cb + (crow * half_row) + ccol;
		4112	src1 = forw_cr;
		4113	src2 = back_cr;
		4114	src1a = forw_cb;
		4115	src2a = back_cb;
		4116
		4117	for (rr = 0; rr < 8; rr++) {
		4118	dest[0] = (int) (src1[0] + src2[0]) >> 1;
		4119	dest[1] = (int) (src1[1] + src2[1]) >> 1;
		4120	dest[2] = (int) (src1[2] + src2[2]) >> 1;
		4121	dest[3] = (int) (src1[3] + src2[3]) >> 1;
		4122	dest[4] = (int) (src1[4] + src2[4]) >> 1;
		4123	dest[5] = (int) (src1[5] + src2[5]) >> 1;
		4124	dest[6] = (int) (src1[6] + src2[6]) >> 1;
		4125	dest[7] = (int) (src1[7] + src2[7]) >> 1;
		4126	dest += half_row;
		4127	src1 += 8;
		4128	src2 += 8;
		4129
		4130	dest1[0] = (int) (src1a[0] + src2a[0]) >> 1;
		4131	dest1[1] = (int) (src1a[1] + src2a[1]) >> 1;
		4132	dest1[2] = (int) (src1a[2] + src2a[2]) >> 1;
		4133	dest1[3] = (int) (src1a[3] + src2a[3]) >> 1;
		4134	dest1[4] = (int) (src1a[4] + src2a[4]) >> 1;
		4135	dest1[5] = (int) (src1a[5] + src2a[5]) >> 1;
		4136	dest1[6] = (int) (src1a[6] + src2a[6]) >> 1;
		4137	dest1[7] = (int) (src1a[7] + src2a[7]) >> 1;
		4138	dest1 += half_row;
		4139	src1a += 8;
		4140	src2a += 8;
		4141	}
		4142	}
		4143
		4144	#ifndef DISABLE_DITHER
		4145	if (ditherType == MBORDERED_DITHER) {
		4146	vid_stream->ditherFlags[addr] = 1;
		4147	}
		4148	#endif
		4149	}
		4150	}
		4151
		4152
		4153
		4154
		4155
		4156	/*
		4157	*--------------------------------------------------------------
		4158	*
		4159	* ReconSkippedBlock --
		4160	*
		4161	* Reconstructs predictive block for skipped macroblocks
		4162	* in B Frames.
		4163	*
		4164	* Results:
		4165	* No return values.
		4166	*
		4167	* Side effects:
		4168	* None.
		4169	*
		4170	*--------------------------------------------------------------
		4171	*/
		4172
		4173	static void
		4174	ReconSkippedBlock(source, dest, row, col, row_size,
		4175	right, down, right_half, down_half, width)
		4176	unsigned char *source;
		4177	unsigned char *dest;
		4178	int row, col, row_size, right, down, right_half, down_half, width;
		4179	{
		4180	int rr;
		4181	unsigned char *source2;
		4182
		4183	source += ((row + down) * row_size) + col + right;
		4184
		4185	if (width == 16) {
		4186	if ((!right_half) && (!down_half)) {
		4187	if (right & 0x1) {
		4188	/* No alignment, use bye copy */
		4189	for (rr = 0; rr < 16; rr++) {
		4190	dest[0] = source[0];
		4191	dest[1] = source[1];
		4192	dest[2] = source[2];
		4193	dest[3] = source[3];
		4194	dest[4] = source[4];
		4195	dest[5] = source[5];
		4196	dest[6] = source[6];
		4197	dest[7] = source[7];
		4198	dest[8] = source[8];
		4199	dest[9] = source[9];
		4200	dest[10] = source[10];
		4201	dest[11] = source[11];
		4202	dest[12] = source[12];
		4203	dest[13] = source[13];
		4204	dest[14] = source[14];
		4205	dest[15] = source[15];
		4206	dest += 16;
		4207	source += row_size;
		4208	}
		4209	} else if (right & 0x2) {
		4210	/* Half-word bit aligned, use 16 bit copy */
		4211	short src = (short )source;
		4212	short d = (short )dest;
		4213	row_size >>= 1;
		4214	for (rr = 0; rr < 16; rr++) {
		4215	d[0] = src[0];
		4216	d[1] = src[1];
		4217	d[2] = src[2];
		4218	d[3] = src[3];
		4219	d[4] = src[4];
		4220	d[5] = src[5];
		4221	d[6] = src[6];
		4222	d[7] = src[7];
		4223	d += 8;
		4224	src += row_size;
		4225	}
		4226	} else {
		4227	/* Word aligned, use 32 bit copy */
		4228	int src = (int )source;
		4229	int d = (int )dest;
		4230	row_size >>= 2;
		4231	for (rr = 0; rr < 16; rr++) {
		4232	d[0] = src[0];
		4233	d[1] = src[1];
		4234	d[2] = src[2];
		4235	d[3] = src[3];
		4236	d += 4;
		4237	src += row_size;
		4238	}
		4239	}
		4240	} else {
		4241	source2 = source + right_half + (row_size * down_half);
		4242	for (rr = 0; rr < width; rr++) {
		4243	dest[0] = (int) (source[0] + source2[0]) >> 1;
		4244	dest[1] = (int) (source[1] + source2[1]) >> 1;
		4245	dest[2] = (int) (source[2] + source2[2]) >> 1;
		4246	dest[3] = (int) (source[3] + source2[3]) >> 1;
		4247	dest[4] = (int) (source[4] + source2[4]) >> 1;
		4248	dest[5] = (int) (source[5] + source2[5]) >> 1;
		4249	dest[6] = (int) (source[6] + source2[6]) >> 1;
		4250	dest[7] = (int) (source[7] + source2[7]) >> 1;
		4251	dest[8] = (int) (source[8] + source2[8]) >> 1;
		4252	dest[9] = (int) (source[9] + source2[9]) >> 1;
		4253	dest[10] = (int) (source[10] + source2[10]) >> 1;
		4254	dest[11] = (int) (source[11] + source2[11]) >> 1;
		4255	dest[12] = (int) (source[12] + source2[12]) >> 1;
		4256	dest[13] = (int) (source[13] + source2[13]) >> 1;
		4257	dest[14] = (int) (source[14] + source2[14]) >> 1;
		4258	dest[15] = (int) (source[15] + source2[15]) >> 1;
		4259	dest += width;
		4260	source += row_size;
		4261	source2 += row_size;
		4262	}
		4263	}
		4264	} else { /* (width == 8) */
		4265	assert(width == 8);
		4266	if ((!right_half) && (!down_half)) {
		4267	if (right & 0x1) {
		4268	for (rr = 0; rr < width; rr++) {
		4269	dest[0] = source[0];
		4270	dest[1] = source[1];
		4271	dest[2] = source[2];
		4272	dest[3] = source[3];
		4273	dest[4] = source[4];
		4274	dest[5] = source[5];
		4275	dest[6] = source[6];
		4276	dest[7] = source[7];
		4277	dest += 8;
		4278	source += row_size;
		4279	}
		4280	} else if (right & 0x02) {
		4281	short d = (short )dest;
		4282	short src = (short )source;
		4283	row_size >>= 1;
		4284	for (rr = 0; rr < width; rr++) {
		4285	d[0] = src[0];
		4286	d[1] = src[1];
		4287	d[2] = src[2];
		4288	d[3] = src[3];
		4289	d += 4;
		4290	src += row_size;
		4291	}
		4292	} else {
		4293	int d = (int )dest;
		4294	int src = (int )source;
		4295	row_size >>= 2;
		4296	for (rr = 0; rr < width; rr++) {
		4297	d[0] = src[0];
		4298	d[1] = src[1];
		4299	d += 2;
		4300	src += row_size;
		4301	}
		4302	}
		4303	} else {
		4304	source2 = source + right_half + (row_size * down_half);
		4305	for (rr = 0; rr < width; rr++) {
		4306	dest[0] = (int) (source[0] + source2[0]) >> 1;
		4307	dest[1] = (int) (source[1] + source2[1]) >> 1;
		4308	dest[2] = (int) (source[2] + source2[2]) >> 1;
		4309	dest[3] = (int) (source[3] + source2[3]) >> 1;
		4310	dest[4] = (int) (source[4] + source2[4]) >> 1;
		4311	dest[5] = (int) (source[5] + source2[5]) >> 1;
		4312	dest[6] = (int) (source[6] + source2[6]) >> 1;
		4313	dest[7] = (int) (source[7] + source2[7]) >> 1;
		4314	dest += width;
		4315	source += row_size;
		4316	source2 += row_size;
		4317	}
		4318	}
		4319	}
		4320	}
		4321
		4322
		4323
		4324
		4325	/*
		4326	*--------------------------------------------------------------
		4327	*
		4328	* DoPictureDisplay --
		4329	*
		4330	* Converts image from Lum, Cr, Cb to colormap space. Puts
		4331	* image in lum plane. Updates past and future frame
		4332	* pointers. Dithers image. Sends to display mechanism.
		4333	*
		4334	* Results:
		4335	* Pict image structure locked if displaying or if frame
		4336	* is needed as past or future reference.
		4337	*
		4338	* Side effects:
		4339	* Lum plane pummelled.
		4340	*
		4341	*--------------------------------------------------------------
		4342	*/
		4343
		4344	static void
		4345	DoPictureDisplay(vid_stream, xinfo)
		4346	VidStream *vid_stream;
		4347	XInfo *xinfo;
		4348	{
		4349
		4350	if (No_B_Flag && (vid_stream->picture.code_type == B_TYPE)) return;
		4351
		4352	/* Convert to colormap space and dither. */
		4353	DoDitherImage(vid_stream);
		4354
		4355	/* Update past and future references if needed. */
		4356
		4357	if ((vid_stream->picture.code_type == I_TYPE) \|\| (vid_stream->picture.code_type == P_TYPE)) {
		4358	if (vid_stream->future == NULL) {
		4359	vid_stream->future = vid_stream->current;
		4360	vid_stream->future->locked \|= FUTURE_LOCK;
		4361	} else {
		4362	if (vid_stream->past != NULL) {
		4363	vid_stream->past->locked &= ~PAST_LOCK;
		4364	}
		4365	vid_stream->past = vid_stream->future;
		4366	vid_stream->past->locked &= ~FUTURE_LOCK;
		4367	vid_stream->past->locked \|= PAST_LOCK;
		4368	vid_stream->future = vid_stream->current;
		4369	vid_stream->future->locked \|= FUTURE_LOCK;
		4370	vid_stream->current = vid_stream->past;
		4371	#ifndef NOCONTROLS
		4372	ExecuteDisplay(vid_stream, 1, xinfo);
		4373	#else
		4374	ExecuteDisplay(vid_stream, xinfo);
		4375	#endif /* !NOCONTROLS */
		4376	}
		4377	} else {
		4378	#ifndef NOCONTROLS
		4379	ExecuteDisplay(vid_stream, 1, xinfo);
		4380	#else
		4381	ExecuteDisplay(vid_stream, xinfo);
		4382	#endif /* !NOCONTROLS */
		4383	}
		4384	}
		4385
		4386
		4387
		4388
		4389	/*
		4390	*--------------------------------------------------------------
		4391	*
		4392	* SetBFlag --
		4393	*
		4394	* Called to set no b frame processing flag.
		4395	*
		4396	* Results:
		4397	* No_B_Flag flag is set to its argument.
		4398	*
		4399	* Side effects:
		4400	* None.
		4401	*
		4402	*--------------------------------------------------------------
		4403	*/
		4404
		4405	void
		4406	SetBFlag(val)
		4407	BOOLEAN val;
		4408	{
		4409	No_B_Flag = val;
		4410	}
		4411
		4412
		4413
		4414
		4415
		4416	/*
		4417	*--------------------------------------------------------------
		4418	*
		4419	* SetPFlag --
		4420	*
		4421	* Called to set no p frame processing flag.
		4422	*
		4423	* Results:
		4424	* No_P_Flag flag is set to value of argument
		4425	*
		4426	* Side effects:
		4427	* None.
		4428	*
		4429	*--------------------------------------------------------------
		4430	*/
		4431
		4432	void
		4433	SetPFlag(val)
		4434	BOOLEAN val;
		4435	{
		4436	No_P_Flag = val;
		4437	}

Subversion Repositories shark

(root)/shark/branches/pj/ports/mpeg/video.c - Rev 2