ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/util/rpiece.c

Comparing ray/src/util/rpiece.c (file contents):
Revision 2.22 by greg, Wed Aug 4 10:08:47 1993 UTC vs.
Revision 2.30 by greg, Mon Apr 11 14:44:10 1994 UTC

#	Line 9 | Line 9 | static char SCCSid[] = "$SunId$ LBL";
9		*/
10
11		#include "standard.h"
12	–	#include <fcntl.h>
12
13		#ifndef F_SETLKW
14
#	Line 40 | Line 39 | char *argv[];
39		#endif
40		#endif
41		/* protection from SYSV signals(!) */
42	<	#if defined(sgi) || defined(hpux)
42	>	#if defined(sgi)
43		#define guard_io()      sighold(SIGALRM)
44		#define unguard()       sigrelse(SIGALRM)
45		#endif
#	Line 49 | Line 48 | char *argv[];
48		#define unguard()       0
49		#endif
50		/* rpict command */
51	<	char  *rpargv[128] = {"rpict", "-S", "1", "-x", "512", "-y", "512", "-pa", "1"};
52	<	int  rpargc = 9;
51	>	char  *rpargv[128] = {"rpict", "-S", "1"};
52	>	int  rpargc = 3;
53		int  rpd[3];
54		FILE  *torp, *fromrp;
55		COLR  *pbuf;
56		/* our view parameters */
57		VIEW  ourview = STDVIEW;
58		double  pixaspect = 1.0;
59	<	int  hres = 512, vres = 512, hmult = 2, vmult = 2;
59	>	int  hres = 1024, vres = 1024, hmult = 4, vmult = 4;
60		/* output file */
61		char  *outfile = NULL;
62		int  outfd;
63		long  scanorig;
64	<	int  syncfd = -1;               /* lock file descriptor */
64	>	FILE  *syncfp = NULL;           /* synchronization file pointer */
65	>	int  synclst = F_UNLCK;         /* synchronization file lock status */
66		int  nforked = 0;
67
68	+	#define  sflock(t)      if ((t)!=synclst) dolock(fileno(syncfp),synclst=t)
69	+
70		char  *progname;
71		int  verbose = 0;
72	+	int  rvrlim = -1;
73
74		extern long  lseek(), ftell();
75
#	Line 113 | Line 116 | char  *argv[];
116		}
117		break;
118		case 'p':               /* pixel aspect ratio? */
119	<	if (argv[i][2] == 'a' && !argv[i][3])
120	<	pixaspect = atof(argv[i+1]);
121	<	break;
122	<	case 'x':               /* piece x resolution */
123	<	if (!argv[i][2])
124	<	hres = atoi(argv[i+1]);
125	<	break;
126	<	case 'y':               /* piece y resolution */
127	<	if (!argv[i][2])
128	<	vres = atoi(argv[i+1]);
129	<	break;
119	>	if (argv[i][2] != 'a' || argv[i][3])
120	>	break;
121	>	pixaspect = atof(argv[i+1]);
122	>	continue;
123	>	case 'x':               /* overall x resolution */
124	>	if (argv[i][2])
125	>	break;
126	>	hres = atoi(argv[++i]);
127	>	continue;
128	>	case 'y':               /* overall y resolution */
129	>	if (argv[i][2])
130	>	break;
131	>	vres = atoi(argv[++i]);
132	>	continue;
133		case 'X':               /* horizontal multiplier */
134		if (argv[i][2])
135		break;
#	Line 134 | Line 140 | char  *argv[];
140		break;
141		vmult = atoi(argv[++i]);
142		continue;
143	+	case 'R':               /* recover */
144	+	if (argv[i][2])
145	+	break;
146	+	rvrlim = 0;
147	+	/* fall through */
148		case 'F':               /* syncronization file */
149		if (argv[i][2])
150		break;
151	<	if ((syncfd = open(argv[++i],
152	<	O_RDWR|O_CREAT, 0666)) < 0) {
151	>	if ((syncfp =
152	>	fdopen(open(argv[++i],O_RDWR|O_CREAT,0666),"r+")) == NULL) {
153		fprintf(stderr, "%s: cannot open\n",
154		argv[i]);
155		exit(1);
#	Line 153 | Line 164 | char  *argv[];
164		break;
165		outfile = argv[++i];
166		continue;
167	<	}
167	>	} else if (i >= argc-1)
168	>	break;
169		rpargv[rpargc++] = argv[i];
170		}
171	<	rpargv[rpargc] = NULL;
171	>	if (i >= argc) {
172	>	fprintf(stderr, "%s: missing octree argument\n", argv[0]);
173	>	exit(1);
174	>	}
175		if (outfile == NULL) {
176		fprintf(stderr, "%s: missing output file\n", argv[0]);
177		exit(1);
#	Line 167 | Line 182 | char  *argv[];
182		}
183
184
185	+	dolock(fd, ltyp)                /* lock or unlock a file */
186	+	int  fd;
187	+	int  ltyp;
188	+	{
189	+	static struct flock  fls;       /* static so initialized to zeroes */
190	+	extern char  *sys_errlist[];
191	+
192	+	fls.l_type = ltyp;
193	+	if (fcntl(fd, F_SETLKW, &fls) < 0) {
194	+	fprintf(stderr, "%s: cannot lock/unlock file: %s\n",
195	+	progname, sys_errlist[errno]);
196	+	exit(1);
197	+	}
198	+	}
199	+
200	+
201		init(ac, av)                    /* set up output file and start rpict */
202		int  ac;
203		char  **av;
204		{
205	+	static char  hrbuf[16], vrbuf[16];
206		extern char  VersionID[];
207		char  *err;
208		FILE  *fp;
#	Line 180 | Line 212 | char  **av;
212		fprintf(stderr, "%s: %s\n", progname, err);
213		exit(1);
214		}
215	<	if (syncfd != -1) {
216	<	char  buf[32];
217	<	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
218	<	sscanf(buf, "%d %d", &hmult, &vmult);
215	>	if (syncfp != NULL) {
216	>	sflock(F_RDLCK);
217	>	fscanf(syncfp, "%d %d", &hmult, &vmult);
218	>	sflock(F_UNLCK);
219		}
220	+	/* compute piece size */
221	+	hres /= hmult;
222	+	vres /= vmult;
223		normaspect(viewaspect(&ourview)*hmult/vmult, &pixaspect, &hres, &vres);
224	+	sprintf(hrbuf, "%d", hres);
225	+	rpargv[rpargc++] = "-x"; rpargv[rpargc++] = hrbuf;
226	+	sprintf(vrbuf, "%d", vres);
227	+	rpargv[rpargc++] = "-y"; rpargv[rpargc++] = vrbuf;
228	+	rpargv[rpargc++] = "-pa"; rpargv[rpargc++] = "0";
229	+	rpargv[rpargc++] = av[ac-1];
230	+	rpargv[rpargc] = NULL;
231		/* open output file */
232		if ((outfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0666)) >= 0) {
233	+	dolock(outfd, F_WRLCK);
234		if ((fp = fdopen(dup(outfd), "w")) == NULL)
235		goto filerr;
236	<	printargs(ac, av, fp);          /* write header */
236	>	newheader("RADIANCE", fp);      /* create header */
237	>	printargs(ac, av, fp);
238		fprintf(fp, "SOFTWARE= %s\n", VersionID);
239		fputs(VIEWSTR, fp);
240		fprintview(&ourview, fp);
#	Line 201 | Line 245 | char  **av;
245		putc('\n', fp);
246		fprtresolu(hres*hmult, vres*vmult, fp);
247		} else if ((outfd = open(outfile, O_RDWR)) >= 0) {
248	+	dolock(outfd, F_RDLCK);
249		if ((fp = fdopen(dup(outfd), "r+")) == NULL)
250		goto filerr;
251		getheader(fp, NULL, NULL);      /* skip header */
#	Line 218 | Line 263 | char  **av;
263		scanorig = ftell(fp);           /* record position of first scanline */
264		if (fclose(fp) == -1)           /* done with stream i/o */
265		goto filerr;
266	<	#if NFS
222	<	sync();                         /* flush NFS buffers */
223	<	#endif
266	>	dolock(outfd, F_UNLCK);
267		/* start rpict process */
268		if (open_process(rpd, rpargv) <= 0) {
269		fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
#	Line 232 | Line 275 | char  **av;
275		progname, rpargv[0]);
276		exit(1);
277		}
278	<	if ((pbuf = (COLR *)malloc(hres*vres*sizeof(COLR))) == NULL) {
278	>	if ((pbuf = (COLR *)bmalloc(hres*vres*sizeof(COLR))) == NULL) {
279		fprintf(stderr, "%s: out of memory\n", progname);
280		exit(1);
281		}
#	Line 248 | Line 291 | int
291		nextpiece(xp, yp)               /* get next piece assignment */
292		int  *xp, *yp;
293		{
251	–	struct flock  fls;
252	–	char  buf[64];
253	–
294		if (gotalrm)                    /* someone wants us to quit */
295		return(0);
296	<	if (syncfd != -1) {             /* use sync file */
297	<	fls.l_type = F_WRLCK;           /* gain exclusive access */
298	<	fls.l_whence = 0;
299	<	fls.l_start = 0L;
300	<	fls.l_len = 0L;
301	<	fcntl(syncfd, F_SETLKW, &fls);
302	<	lseek(syncfd, 0L, 0);
303	<	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
304	<	if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
296	>	if (syncfp != NULL) {           /* use sync file */
297	>	/*
298	>	* So we don't necessarily have to lock and unlock the file
299	>	* multiple times (very slow), we establish an exclusive
300	>	* lock at the beginning on our synchronization file and
301	>	* maintain it in the subroutine rvrpiece().
302	>	*/
303	>	sflock(F_WRLCK);
304	>	fseek(syncfp, 0L, 0);           /* read position */
305	>	if (fscanf(syncfp, "%*d %*d %d %d", xp, yp) < 2) {
306		*xp = hmult-1;
307		*yp = vmult;
308		}
309	+	if (rvrlim == 0)                /* initialize recovery limit */
310	+	rvrlim = *xp*vmult + *yp;
311	+	if (rvrpiece(xp, yp)) {         /* do stragglers first */
312	+	sflock(F_UNLCK);
313	+	return(1);
314	+	}
315		if (--(*yp) < 0) {              /* decrement position */
316		*yp = vmult-1;
317	<	if (--(*xp) < 0) {      /* all done! */
318	<	close(syncfd);
317	>	if (--(*xp) < 0) {      /* all done */
318	>	sflock(F_UNLCK);
319		return(0);
320		}
321		}
322	<	sprintf(buf, "%4d %4d\n%4d %4d\n", hmult, vmult, *xp, *yp);
323	<	lseek(syncfd, 0L, 0);           /* write new position */
324	<	write(syncfd, buf, strlen(buf));
325	<	fls.l_type = F_UNLCK;           /* release sync file */
279	<	fcntl(syncfd, F_SETLKW, &fls);
322	>	fseek(syncfp, 0L, 0);           /* write new position */
323	>	fprintf(syncfp, "%4d %4d\n%4d %4d\n\n", hmult, vmult, *xp, *yp);
324	>	fflush(syncfp);
325	>	sflock(F_UNLCK);                /* release sync file */
326		return(1);
327		}
328	<	if (fgets(buf, sizeof(buf), stdin) == NULL)     /* use stdin */
283	<	return(0);
284	<	if (sscanf(buf, "%d %d", xp, yp) == 2)
285	<	return(1);
286	<	fprintf(stderr, "%s: input format error\n", progname);
287	<	exit(cleanup(1));
328	>	return(scanf("%d %d", xp, yp) == 2);    /* use stdin */
329		}
330
331
332		int
333	+	rvrpiece(xp, yp)                /* check for recoverable pieces */
334	+	register int  *xp, *yp;
335	+	{
336	+	static char  *pdone = NULL;     /* which pieces are done */
337	+	static long  readpos = -1;      /* how far we've read */
338	+	register int  i;
339	+	/*
340	+	* This routine is called by nextpiece() with an
341	+	* exclusive lock on syncfp and the file pointer at the
342	+	* appropriate position to read in the finished pieces.
343	+	*/
344	+	if (rvrlim < 0)
345	+	return(0);              /* only check if asked */
346	+	if (pdone == NULL)              /* first call */
347	+	pdone = calloc(hmult*vmult, sizeof(char));
348	+	if (pdone == NULL) {
349	+	fprintf(stderr, "%s: out of memory\n", progname);
350	+	exit(1);
351	+	}
352	+	if (readpos != -1)              /* mark what's been done */
353	+	fseek(syncfp, readpos, 0);
354	+	while (fscanf(syncfp, "%d %d", xp, yp) == 2)
355	+	pdone[*xp*vmult+*yp] = 1;
356	+	if (!feof(syncfp)) {
357	+	fprintf(stderr, "%s: format error in sync file\n", progname);
358	+	exit(1);
359	+	}
360	+	readpos = ftell(syncfp);
361	+	i = hmult*vmult;                /* find an unaccounted for piece */
362	+	while (i-- > rvrlim)
363	+	if (!pdone[i]) {
364	+	*xp = i / vmult;
365	+	*yp = i % vmult;
366	+	pdone[i] = 1;   /* consider it done */
367	+	return(1);
368	+	}
369	+	rvrlim = -1;                    /* nothing left to recover */
370	+	free(pdone);
371	+	pdone = NULL;
372	+	return(0);
373	+	}
374	+
375	+
376	+	int
377		cleanup(rstat)                  /* close rpict process and clean up */
378		int  rstat;
379		{
380		int  status;
381
382	<	free((char *)pbuf);
382	>	bfree((char *)pbuf, hres*vres*sizeof(COLR));
383		fclose(torp);
384		fclose(fromrp);
385		while (wait(&status) != -1)
#	Line 368 | Line 453 | int  xpos, ypos;
453		progname, rpargv[0]);
454		exit(cleanup(1));
455		}
456	+	if (verbose) {                          /* notify caller */
457	+	printf("%d %d begun\n", xpos, ypos);
458	+	fflush(stdout);
459	+	}
460		unguard();
461		/* load new piece into buffer */
462		for (y = 0; y < vr; y++) {
#	Line 400 | Line 489 | int  xpos, ypos;
489		/* lock file section so NFS doesn't mess up */
490		fls.l_whence = 0;
491		fls.l_type = F_WRLCK;
492	<	fcntl(outfd, F_SETLKW, &fls);
492	>	if (fcntl(outfd, F_SETLKW, &fls) < 0)
493	>	filerr("lock");
494		#endif
495		/* write new piece to file */
496		if (lseek(outfd, fls.l_start, 0) == -1)
497	<	goto seekerr;
497	>	filerr("seek");
498		if (hmult == 1) {
499		if (writebuf(outfd, (char *)pbuf,
500		vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
501	<	goto writerr;
501	>	filerr("write");
502		} else
503		for (y = 0; y < vr; y++) {
504		if (writebuf(outfd, (char *)(pbuf+y*hr),
505		hr*sizeof(COLR)) != hr*sizeof(COLR))
506	<	goto writerr;
506	>	filerr("write");
507		if (y < vr-1 && lseek(outfd,
508		(long)(hmult-1)*hr*sizeof(COLR),
509		1) == -1)
510	<	goto seekerr;
510	>	filerr("seek");
511		}
512	+	#if NFS
513	+	fls.l_type = F_UNLCK;           /* release lock */
514	+	if (fcntl(outfd, F_SETLKW, &fls) < 0)
515	+	filerr("lock");
516	+	#endif
517	+	if (syncfp != NULL) {                   /* record what's been done */
518	+	sflock(F_WRLCK);
519	+	fseek(syncfp, 0L, 2);           /* append index */
520	+	fprintf(syncfp, "%4d %4d\n", xpos, ypos);
521	+	fflush(syncfp);
522	+	/*** Unlock not necessary, since
523	+	sflock(F_UNLCK);        _exit() or nextpiece() is next ***/
524	+	}
525		if (verbose) {                          /* notify caller */
526		printf("%d %d done\n", xpos, ypos);
527		fflush(stdout);
528		}
529	<	if (pid == -1) {        /* didn't fork or fork failed */
427	<	#if NFS
428	<	fls.l_type = F_UNLCK;           /* release lock */
429	<	fcntl(outfd, F_SETLKW, &fls);
430	<	#endif
529	>	if (pid == -1)          /* didn't fork or fork failed */
530		return(0);
531	<	}
532	<	_exit(0);               /* else exit child process (releasing lock) */
533	<	seekerr:
534	<	fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
535	<	_exit(1);
536	<	writerr:
537	<	fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
531	>	_exit(0);               /* else exit child process (releasing locks) */
532	>	}
533	>
534	>
535	>	filerr(t)                       /* report file error and exit */
536	>	char  *t;
537	>	{
538	>	extern char  *sys_errlist[];
539	>
540	>	fprintf(stderr, "%s: %s error on file \"%s\": %s\n",
541	>	progname, t, outfile, sys_errlist[errno]);
542		_exit(1);
543		}
544

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)