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.7 by greg, Sat Aug 8 18:47:39 1992 UTC vs.
Revision 2.22 by greg, Wed Aug 4 10:08:47 1993 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1992 Regents of the University of California */
1	>	/* Copyright (c) 1993 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 10 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10
11		#include "standard.h"
12		#include <fcntl.h>
13	+
14	+	#ifndef F_SETLKW
15	+
16	+	main(argc, argv)
17	+	int argc;
18	+	char *argv[];
19	+	{
20	+	fprintf(stderr, "%s: no NFS lock manager on this machine\n", argv[0]);
21	+	exit(1);
22	+	}
23	+
24	+	#else
25	+
26		#include <signal.h>
27		#include "color.h"
28		#include "view.h"
29		#include "resolu.h"
30
31	+	#ifndef NFS
32	+	#define  NFS                    1
33	+	#endif
34	+	/* set the following to 0 to forgo forking */
35	+	#ifndef MAXFORK
36	+	#if NFS
37	+	#define  MAXFORK                3       /* allotment of duped processes */
38	+	#else
39	+	#define  MAXFORK                0
40	+	#endif
41	+	#endif
42	+	/* protection from SYSV signals(!) */
43	+	#if defined(sgi) || defined(hpux)
44	+	#define guard_io()      sighold(SIGALRM)
45	+	#define unguard()       sigrelse(SIGALRM)
46	+	#endif
47	+	#ifndef guard_io
48	+	#define guard_io()      0
49	+	#define unguard()       0
50	+	#endif
51		/* rpict command */
52		char  *rpargv[128] = {"rpict", "-S", "1", "-x", "512", "-y", "512", "-pa", "1"};
53		int  rpargc = 9;
54		int  rpd[3];
55		FILE  *torp, *fromrp;
56	<	COLR  *scanline;
56	>	COLR  *pbuf;
57		/* our view parameters */
58		VIEW  ourview = STDVIEW;
59		double  pixaspect = 1.0;
#	Line 30 | Line 63 | char  *outfile = NULL;
63		int  outfd;
64		long  scanorig;
65		int  syncfd = -1;               /* lock file descriptor */
66	+	int  nforked = 0;
67
68		char  *progname;
69		int  verbose = 0;
#	Line 48 | Line 82 | char  *argv[];
82
83		progname = argv[0];
84		for (i = 1; i < argc; i++) {
85	+	/* expand arguments */
86	+	while (rval = expandarg(&argc, &argv, i))
87	+	if (rval < 0) {
88	+	fprintf(stderr, "%s: cannot expand '%s'",
89	+	argv[0], argv[i]);
90	+	exit(1);
91	+	}
92		if (argv[i][0] == '-')
93		switch (argv[i][1]) {
94		case 'v':
#	Line 96 | Line 137 | char  *argv[];
137		case 'F':               /* syncronization file */
138		if (argv[i][2])
139		break;
140	<	if ((syncfd = open(argv[++i], O_RDWR)) < 0) {
140	>	if ((syncfd = open(argv[++i],
141	>	O_RDWR|O_CREAT, 0666)) < 0) {
142		fprintf(stderr, "%s: cannot open\n",
143		argv[i]);
144		exit(1);
145		}
146		continue;
147	+	case 'z':               /* z-file ist verbotten */
148	+	fprintf(stderr, "%s: -z option not allowed\n",
149	+	argv[0]);
150	+	exit(1);
151		case 'o':               /* output file */
152		if (argv[i][2])
153		break;
#	Line 117 | Line 163 | char  *argv[];
163		}
164		init(argc, argv);
165		rpiece();
166	<	rval = cleanup();
121	<	exit(rval);
166	>	exit(cleanup(0));
167		}
168
169
#	Line 158 | Line 203 | char  **av;
203		} else if ((outfd = open(outfile, O_RDWR)) >= 0) {
204		if ((fp = fdopen(dup(outfd), "r+")) == NULL)
205		goto filerr;
206	<	getheader(fp, NULL);            /* skip header */
207	<	if (fscnresolu(&hr, &vr, fp) < 0 ||     /* check resolution */
206	>	getheader(fp, NULL, NULL);      /* skip header */
207	>	if (!fscnresolu(&hr, &vr, fp) ||        /* check resolution */
208		hr != hres*hmult || vr != vres*vmult) {
209	<	fprintf(stderr, "%s: picture resolution mismatch\n",
210	<	outfile);
209	>	fprintf(stderr, "%s: resolution mismatch on file \"%s\"\n",
210	>	progname, outfile);
211		exit(1);
212		}
213		} else {
214	<	fprintf(stderr, "%s: cannot open\n", outfile);
214	>	fprintf(stderr, "%s: cannot open file \"%s\"\n",
215	>	progname, outfile);
216		exit(1);
217		}
218		scanorig = ftell(fp);           /* record position of first scanline */
219		if (fclose(fp) == -1)           /* done with stream i/o */
220		goto filerr;
221	+	#if NFS
222	+	sync();                         /* flush NFS buffers */
223	+	#endif
224		/* start rpict process */
225		if (open_process(rpd, rpargv) <= 0) {
226		fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
#	Line 183 | Line 232 | char  **av;
232		progname, rpargv[0]);
233		exit(1);
234		}
235	<	if ((scanline = (COLR *)malloc(hres*sizeof(COLR))) == NULL) {
235	>	if ((pbuf = (COLR *)malloc(hres*vres*sizeof(COLR))) == NULL) {
236		fprintf(stderr, "%s: out of memory\n", progname);
237		exit(1);
238		}
239		signal(SIGALRM, onalrm);
240		return;
241		filerr:
242	<	fprintf(stderr, "%s: file i/o error\n", outfile);
242	>	fprintf(stderr, "%s: i/o error on file \"%s\"\n", progname, outfile);
243		exit(1);
244		}
245
#	Line 199 | Line 248 | int
248		nextpiece(xp, yp)               /* get next piece assignment */
249		int  *xp, *yp;
250		{
202	–	extern char  *fgets();
251		struct flock  fls;
252		char  buf[64];
253
#	Line 214 | Line 262 | int  *xp, *yp;
262		lseek(syncfd, 0L, 0);
263		buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
264		if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
217	–	*xp = hmult;
218	–	*yp = vmult-1;
219	–	}
220	–	if (--(*xp) < 0) {              /* decrement position */
265		*xp = hmult-1;
266	<	if (--(*yp) < 0) {      /* all done! */
266	>	*yp = vmult;
267	>	}
268	>	if (--(*yp) < 0) {              /* decrement position */
269	>	*yp = vmult-1;
270	>	if (--(*xp) < 0) {      /* all done! */
271		close(syncfd);
272		return(0);
273		}
274		}
275	<	sprintf(buf, "%d %d\n%d %d\n", hmult, vmult, *xp, *yp);
275	>	sprintf(buf, "%4d %4d\n%4d %4d\n", hmult, vmult, *xp, *yp);
276		lseek(syncfd, 0L, 0);           /* write new position */
277		write(syncfd, buf, strlen(buf));
278		fls.l_type = F_UNLCK;           /* release sync file */
#	Line 236 | Line 284 | int  *xp, *yp;
284		if (sscanf(buf, "%d %d", xp, yp) == 2)
285		return(1);
286		fprintf(stderr, "%s: input format error\n", progname);
287	<	exit(1);
287	>	exit(cleanup(1));
288		}
289
290
291		int
292	<	cleanup()                       /* close rpict process and clean up */
292	>	cleanup(rstat)                  /* close rpict process and clean up */
293	>	int  rstat;
294		{
295	<	register int  rpstat;
295	>	int  status;
296
297	<	free((char *)scanline);
297	>	free((char *)pbuf);
298		fclose(torp);
299		fclose(fromrp);
300	<	rpstat = close_process(rpd);
301	<	if (rpstat == -1)
302	<	rpstat = 0;
303	<	return(rpstat);
300	>	while (wait(&status) != -1)
301	>	if (rstat == 0)
302	>	rstat = status>>8 & 0xff;
303	>	return(rstat);
304		}
305
306
#	Line 259 | Line 308 | rpiece()                       /* render picture piece by piece */
308		{
309		VIEW  pview;
310		int  xorg, yorg;
311	<
311	>	/* compute view parameters */
312	>	copystruct(&pview, &ourview);
313	>	switch (ourview.type) {
314	>	case VT_PER:
315	>	pview.horiz = 2.*180./PI*atan(
316	>	tan(PI/180./2.*ourview.horiz)/hmult );
317	>	pview.vert = 2.*180./PI*atan(
318	>	tan(PI/180./2.*ourview.vert)/vmult );
319	>	break;
320	>	case VT_PAR:
321	>	case VT_ANG:
322	>	pview.horiz = ourview.horiz / hmult;
323	>	pview.vert = ourview.vert / vmult;
324	>	break;
325	>	case VT_HEM:
326	>	pview.horiz = 2.*180./PI*asin(
327	>	sin(PI/180./2.*ourview.horiz)/hmult );
328	>	pview.vert = 2.*180./PI*asin(
329	>	sin(PI/180./2.*ourview.vert)/vmult );
330	>	break;
331	>	default:
332	>	fprintf(stderr, "%s: unknown view type '-vt%c'\n",
333	>	progname, ourview.type);
334	>	exit(cleanup(1));
335	>	}
336	>	/* render each piece */
337		while (nextpiece(&xorg, &yorg)) {
338	<	copystruct(&pview, &ourview);   /* compute view for piece */
339	<	switch (ourview.type) {
266	<	case VT_PER:
267	<	pview.horiz = 2.*180./PI*atan(
268	<	tan(PI/180./2.*ourview.horiz)/hmult );
269	<	pview.vert = 2.*180./PI*atan(
270	<	tan(PI/180./2.*ourview.vert)/vmult );
271	<	break;
272	<	case VT_PAR:
273	<	case VT_ANG:
274	<	pview.horiz = ourview.horiz / hmult;
275	<	pview.vert = ourview.vert / vmult;
276	<	break;
277	<	case VT_HEM:
278	<	pview.horiz = 2.*180./PI*asin(
279	<	sin(PI/180./2.*ourview.horiz)/hmult );
280	<	pview.vert = 2.*180./PI*asin(
281	<	sin(PI/180./2.*ourview.vert)/vmult );
282	<	break;
283	<	default:
284	<	fprintf(stderr, "%s: unknown view type '-vt%c'\n",
285	<	progname, ourview.type);
286	<	exit(1);
287	<	}
288	<	pview.hoff += xorg - 0.5*(hmult-1);
289	<	pview.voff += yorg - 0.5*(vmult-1);
338	>	pview.hoff = ourview.hoff + xorg - 0.5*(hmult-1);
339	>	pview.voff = ourview.voff + yorg - 0.5*(vmult-1);
340		fputs(VIEWSTR, torp);
341		fprintview(&pview, torp);
342		putc('\n', torp);
343	<	fflush(torp);                   /* assign piece to rpict */
343	>	fflush(torp);                   /* assigns piece to rpict */
344		putpiece(xorg, yorg);           /* place piece in output */
295	–	if (verbose) {                  /* notify caller */
296	–	printf("%d %d done\n", xorg, yorg);
297	–	fflush(stdout);
298	–	}
345		}
346		}
347
348
349	+	int
350		putpiece(xpos, ypos)            /* get next piece from rpict */
351		int  xpos, ypos;
352		{
353		struct flock  fls;
354	+	int  pid, status;
355		int  hr, vr;
356	<	int  y;
357	<
356	>	register int  y;
357	>	/* check bounds */
358		if (xpos < 0 | ypos < 0 | xpos >= hmult | ypos >= vmult) {
359		fprintf(stderr, "%s: requested piece (%d,%d) out of range\n",
360		progname, xpos, ypos);
361	<	exit(1);
361	>	exit(cleanup(1));
362		}
363	<	getheader(fromrp, NULL);        /* discard header info. */
364	<	if (fscnresolu(&hr, &vr, fromrp) < 0 || /* check resolution */
365	<	hr != hres || vr != vres) {
363	>	/* check header from rpict */
364	>	guard_io();
365	>	getheader(fromrp, NULL, NULL);
366	>	if (!fscnresolu(&hr, &vr, fromrp) || hr != hres | vr != vres) {
367		fprintf(stderr, "%s: resolution mismatch from %s\n",
368		progname, rpargv[0]);
369	<	exit(1);
369	>	exit(cleanup(1));
370		}
371	<	fls.l_whence = 1;
372	<	fls.l_start = 0L;
373	<	fls.l_len = hr*sizeof(COLR);
374	<	for (y = 0; y < vr; y++) {      /* transfer scanlines */
375	<	if (freadcolrs(scanline, hr, fromrp) < 0) {
371	>	unguard();
372	>	/* load new piece into buffer */
373	>	for (y = 0; y < vr; y++) {
374	>	guard_io();
375	>	if (freadcolrs(pbuf+y*hr, hr, fromrp) < 0) {
376		fprintf(stderr, "%s: read error from %s\n",
377		progname, rpargv[0]);
378	<	exit(1);
378	>	exit(cleanup(1));
379		}
380	<	if ((y == 0 || hmult != 1) && lseek(outfd,
381	<	scanorig+((long)((vmult-1-ypos)*vres+y)*hmult*hres+xpos*hres)*sizeof(COLR),
382	<	0) == -1) {
383	<	fprintf(stderr, "%s: seek error\n", outfile);
384	<	exit(1);
380	>	unguard();
381	>	}
382	>	#if MAXFORK
383	>	/* fork so we don't slow rpict down */
384	>	if ((pid = fork()) > 0) {
385	>	if (++nforked >= MAXFORK) {
386	>	wait(&status);          /* reap a child */
387	>	if (status)
388	>	exit(cleanup(status>>8 & 0xff));
389	>	nforked--;
390		}
391	<	fls.l_type = F_WRLCK;
392	<	fcntl(outfd, F_SETLKW, &fls);
393	<	if (writebuf(outfd, (char *)scanline, hr*sizeof(COLR)) !=
394	<	hr*sizeof(COLR)) {
395	<	fprintf(stderr, "%s: write error\n", outfile);
396	<	exit(1);
391	>	return(pid);
392	>	}
393	>	#else
394	>	pid = -1;               /* no forking */
395	>	#endif
396	>	fls.l_start = scanorig +
397	>	((long)(vmult-1-ypos)*vres*hmult+xpos)*hres*sizeof(COLR);
398	>	#if NFS
399	>	fls.l_len = ((long)(vres-1)*hmult+1)*hres*sizeof(COLR);
400	>	/* lock file section so NFS doesn't mess up */
401	>	fls.l_whence = 0;
402	>	fls.l_type = F_WRLCK;
403	>	fcntl(outfd, F_SETLKW, &fls);
404	>	#endif
405	>	/* write new piece to file */
406	>	if (lseek(outfd, fls.l_start, 0) == -1)
407	>	goto seekerr;
408	>	if (hmult == 1) {
409	>	if (writebuf(outfd, (char *)pbuf,
410	>	vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
411	>	goto writerr;
412	>	} else
413	>	for (y = 0; y < vr; y++) {
414	>	if (writebuf(outfd, (char *)(pbuf+y*hr),
415	>	hr*sizeof(COLR)) != hr*sizeof(COLR))
416	>	goto writerr;
417	>	if (y < vr-1 && lseek(outfd,
418	>	(long)(hmult-1)*hr*sizeof(COLR),
419	>	1) == -1)
420	>	goto seekerr;
421		}
422	<	fls.l_type = F_UNLCK;
422	>	if (verbose) {                          /* notify caller */
423	>	printf("%d %d done\n", xpos, ypos);
424	>	fflush(stdout);
425	>	}
426	>	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
431	+	return(0);
432		}
433	+	_exit(0);               /* else exit child process (releasing lock) */
434	+	seekerr:
435	+	fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
436	+	_exit(1);
437	+	writerr:
438	+	fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
439	+	_exit(1);
440		}
441	+
442	+	#endif

Diff Legend

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