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.1 by greg, Thu Aug 6 16:45:01 1992 UTC vs.
Revision 2.23 by greg, Wed Aug 4 13:20:45 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", };
53	<	int  rpargc = 7;
52	>	char  *rpargv[128] = {"rpict", "-S", "1"};
53	>	int  rpargc = 3;
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 = 0.0;
60	<	int  hres = 512, vres = 512, hmult = 2, vmult = 2;
59	>	double  pixaspect = 1.0;
60	>	int  hres = 1024, vres = 1024, hmult = 4, vmult = 4;
61		/* output file */
62		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;
70
71		extern long  lseek(), ftell();
72
73	+	int  gotalrm = 0;
74	+	int  onalrm() { gotalrm++; }
75
76	+
77		main(argc, argv)
78		int  argc;
79		char  *argv[];
#	Line 43 | 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 67 | Line 113 | char  *argv[];
113		}
114		break;
115		case 'p':               /* pixel aspect ratio? */
116	<	if (argv[i][2] == 'a' && !argv[i][3])
117	<	pixaspect = atof(argv[i+1]);
118	<	break;
119	<	case 'x':               /* piece x resolution */
120	<	if (!argv[i][2])
121	<	hres = atoi(argv[i+1]);
122	<	break;
123	<	case 'y':               /* piece y resolution */
124	<	if (!argv[i][2])
125	<	vres = atoi(argv[i+1]);
126	<	break;
116	>	if (argv[i][2] != 'a' || argv[i][3])
117	>	break;
118	>	pixaspect = atof(argv[i+1]);
119	>	continue;
120	>	case 'x':               /* overall x resolution */
121	>	if (argv[i][2])
122	>	break;
123	>	hres = atoi(argv[++i]);
124	>	continue;
125	>	case 'y':               /* overall y resolution */
126	>	if (argv[i][2])
127	>	break;
128	>	vres = atoi(argv[++i]);
129	>	continue;
130		case 'X':               /* horizontal multiplier */
131		if (argv[i][2])
132		break;
#	Line 88 | Line 137 | char  *argv[];
137		break;
138		vmult = atoi(argv[++i]);
139		continue;
140	+	case 'F':               /* syncronization file */
141	+	if (argv[i][2])
142	+	break;
143	+	if ((syncfd = open(argv[++i],
144	+	O_RDWR|O_CREAT, 0666)) < 0) {
145	+	fprintf(stderr, "%s: cannot open\n",
146	+	argv[i]);
147	+	exit(1);
148	+	}
149	+	continue;
150	+	case 'z':               /* z-file ist verbotten */
151	+	fprintf(stderr, "%s: -z option not allowed\n",
152	+	argv[0]);
153	+	exit(1);
154		case 'o':               /* output file */
155		if (argv[i][2])
156		break;
157		outfile = argv[++i];
158		continue;
159	<	}
159	>	} else if (i >= argc-1)
160	>	break;
161		rpargv[rpargc++] = argv[i];
162		}
163	<	rpargv[rpargc] = NULL;
163	>	if (i >= argc) {
164	>	fprintf(stderr, "%s: missing octree argument\n", argv[0]);
165	>	exit(1);
166	>	}
167		if (outfile == NULL) {
168		fprintf(stderr, "%s: missing output file\n", argv[0]);
169		exit(1);
170		}
171		init(argc, argv);
172		rpiece();
173	<	rval = cleanup();
107	<	exit(rval);
173	>	exit(cleanup(0));
174		}
175
176
#	Line 112 | Line 178 | init(ac, av)                   /* set up output file and start rpict *
178		int  ac;
179		char  **av;
180		{
181	+	static char  hrbuf[16], vrbuf[16];
182	+	extern char  VersionID[];
183		char  *err;
184		FILE  *fp;
185		int  hr, vr;
#	Line 120 | Line 188 | char  **av;
188		fprintf(stderr, "%s: %s\n", progname, err);
189		exit(1);
190		}
191	+	if (syncfd != -1) {
192	+	char  buf[32];
193	+	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
194	+	sscanf(buf, "%d %d", &hmult, &vmult);
195	+	}
196	+	/* compute piece size */
197	+	hres /= hmult;
198	+	vres /= vmult;
199		normaspect(viewaspect(&ourview)*hmult/vmult, &pixaspect, &hres, &vres);
200	+	sprintf(hrbuf, "%d", hres);
201	+	rpargv[rpargc++] = "-x"; rpargv[rpargc++] = hrbuf;
202	+	sprintf(vrbuf, "%d", vres);
203	+	rpargv[rpargc++] = "-y"; rpargv[rpargc++] = vrbuf;
204	+	rpargv[rpargc++] = "-pa"; rpargv[rpargc++] = "0";
205	+	rpargv[rpargc++] = av[ac-1];
206	+	rpargv[rpargc] = NULL;
207		/* open output file */
208		if ((outfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0666)) >= 0) {
209		if ((fp = fdopen(dup(outfd), "w")) == NULL)
210		goto filerr;
211		printargs(ac, av, fp);          /* write header */
212	+	fprintf(fp, "SOFTWARE= %s\n", VersionID);
213		fputs(VIEWSTR, fp);
214		fprintview(&ourview, fp);
215		putc('\n', fp);
#	Line 135 | Line 219 | char  **av;
219		putc('\n', fp);
220		fprtresolu(hres*hmult, vres*vmult, fp);
221		} else if ((outfd = open(outfile, O_RDWR)) >= 0) {
138	–	sleep(30);                      /* wait for header */
222		if ((fp = fdopen(dup(outfd), "r+")) == NULL)
223		goto filerr;
224	<	getheader(fp, NULL);            /* skip header */
225	<	if (fscnresolu(&hr, &vr, fp) < 0 ||     /* check resolution */
224	>	getheader(fp, NULL, NULL);      /* skip header */
225	>	if (!fscnresolu(&hr, &vr, fp) ||        /* check resolution */
226		hr != hres*hmult || vr != vres*vmult) {
227	<	fprintf(stderr, "%s: picture resolution mismatch\n",
228	<	outfile);
227	>	fprintf(stderr, "%s: resolution mismatch on file \"%s\"\n",
228	>	progname, outfile);
229		exit(1);
230		}
231		} else {
232	<	fprintf(stderr, "%s: cannot open\n", outfile);
232	>	fprintf(stderr, "%s: cannot open file \"%s\"\n",
233	>	progname, outfile);
234		exit(1);
235		}
236		scanorig = ftell(fp);           /* record position of first scanline */
237		if (fclose(fp) == -1)           /* done with stream i/o */
238		goto filerr;
239	+	#if NFS
240	+	sync();                         /* flush NFS buffers */
241	+	#endif
242		/* start rpict process */
243		if (open_process(rpd, rpargv) <= 0) {
244	<	fprintf(stderr, "%s: cannot start\n", rpargv[0]);
244	>	fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
245		exit(1);
246		}
247		if ((fromrp = fdopen(rpd[0], "r")) == NULL ||
#	Line 163 | Line 250 | char  **av;
250		progname, rpargv[0]);
251		exit(1);
252		}
253	<	if ((scanline = (COLR *)malloc(hres*sizeof(COLR))) == NULL) {
253	>	if ((pbuf = (COLR *)bmalloc(hres*vres*sizeof(COLR))) == NULL) {
254		fprintf(stderr, "%s: out of memory\n", progname);
255		exit(1);
256		}
257	+	signal(SIGALRM, onalrm);
258		return;
259		filerr:
260	<	fprintf(stderr, "%s: file i/o error\n", outfile);
260	>	fprintf(stderr, "%s: i/o error on file \"%s\"\n", progname, outfile);
261		exit(1);
262		}
263
264
265		int
266	<	cleanup()                       /* close rpict process and clean up */
266	>	nextpiece(xp, yp)               /* get next piece assignment */
267	>	int  *xp, *yp;
268		{
269	<	register int  rpstat;
269	>	struct flock  fls;
270	>	char  buf[64];
271
272	<	free((char *)scanline);
272	>	if (gotalrm)                    /* someone wants us to quit */
273	>	return(0);
274	>	if (syncfd != -1) {             /* use sync file */
275	>	fls.l_type = F_WRLCK;           /* gain exclusive access */
276	>	fls.l_whence = 0;
277	>	fls.l_start = 0L;
278	>	fls.l_len = 0L;
279	>	fcntl(syncfd, F_SETLKW, &fls);
280	>	lseek(syncfd, 0L, 0);
281	>	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
282	>	if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
283	>	*xp = hmult-1;
284	>	*yp = vmult;
285	>	}
286	>	if (--(*yp) < 0) {              /* decrement position */
287	>	*yp = vmult-1;
288	>	if (--(*xp) < 0) {      /* all done! */
289	>	close(syncfd);
290	>	return(0);
291	>	}
292	>	}
293	>	sprintf(buf, "%4d %4d\n%4d %4d\n", hmult, vmult, *xp, *yp);
294	>	lseek(syncfd, 0L, 0);           /* write new position */
295	>	write(syncfd, buf, strlen(buf));
296	>	fls.l_type = F_UNLCK;           /* release sync file */
297	>	fcntl(syncfd, F_SETLKW, &fls);
298	>	return(1);
299	>	}
300	>	if (fgets(buf, sizeof(buf), stdin) == NULL)     /* use stdin */
301	>	return(0);
302	>	if (sscanf(buf, "%d %d", xp, yp) == 2)
303	>	return(1);
304	>	fprintf(stderr, "%s: input format error\n", progname);
305	>	exit(cleanup(1));
306	>	}
307	>
308	>
309	>	int
310	>	cleanup(rstat)                  /* close rpict process and clean up */
311	>	int  rstat;
312	>	{
313	>	int  status;
314	>
315	>	bfree((char *)pbuf, hres*vres*sizeof(COLR));
316		fclose(torp);
317		fclose(fromrp);
318	<	rpstat = close_process(rpd);
319	<	if (rpstat == -1)
320	<	rpstat = 0;
321	<	return(rpstat);
318	>	while (wait(&status) != -1)
319	>	if (rstat == 0)
320	>	rstat = status>>8 & 0xff;
321	>	return(rstat);
322		}
323
324
325		rpiece()                        /* render picture piece by piece */
326		{
194	–	extern char  *gets(), *strcat();
327		VIEW  pview;
196	–	char  buf[48];
328		int  xorg, yorg;
329	<
330	<	while (gets(buf) != NULL) {
331	<	if (sscanf(buf, "%d %d", &xorg, &yorg) != 2) {
332	<	fprintf(stderr, "%s: input format error\n", progname);
333	<	exit(1);
334	<	}
335	<	copystruct(&pview, &ourview);   /* compute view for piece */
336	<	switch (ourview.type) {
337	<	case VT_PER:
338	<	pview.horiz = 2.*180./PI*atan(
339	<	tan(PI/180./2.*ourview.horiz)/hmult );
340	<	pview.vert = 2.*180./PI*atan(
341	<	tan(PI/180./2.*ourview.vert)/vmult );
342	<	break;
343	<	case VT_PAR:
344	<	case VT_ANG:
345	<	pview.horiz = ourview.horiz / hmult;
346	<	pview.vert = ourview.vert / vmult;
347	<	break;
348	<	case VT_HEM:
349	<	default:
350	<	fprintf(stderr, "%s: unknown view type '-vt%c'\n",
351	<	progname, ourview.type);
352	<	exit(1);
353	<	}
354	<	pview.hoff += xorg - 0.5*(hmult-1);
355	<	pview.voff += yorg - 0.5*(vmult-1);
329	>	/* compute view parameters */
330	>	copystruct(&pview, &ourview);
331	>	switch (ourview.type) {
332	>	case VT_PER:
333	>	pview.horiz = 2.*180./PI*atan(
334	>	tan(PI/180./2.*ourview.horiz)/hmult );
335	>	pview.vert = 2.*180./PI*atan(
336	>	tan(PI/180./2.*ourview.vert)/vmult );
337	>	break;
338	>	case VT_PAR:
339	>	case VT_ANG:
340	>	pview.horiz = ourview.horiz / hmult;
341	>	pview.vert = ourview.vert / vmult;
342	>	break;
343	>	case VT_HEM:
344	>	pview.horiz = 2.*180./PI*asin(
345	>	sin(PI/180./2.*ourview.horiz)/hmult );
346	>	pview.vert = 2.*180./PI*asin(
347	>	sin(PI/180./2.*ourview.vert)/vmult );
348	>	break;
349	>	default:
350	>	fprintf(stderr, "%s: unknown view type '-vt%c'\n",
351	>	progname, ourview.type);
352	>	exit(cleanup(1));
353	>	}
354	>	/* render each piece */
355	>	while (nextpiece(&xorg, &yorg)) {
356	>	pview.hoff = ourview.hoff + xorg - 0.5*(hmult-1);
357	>	pview.voff = ourview.voff + yorg - 0.5*(vmult-1);
358		fputs(VIEWSTR, torp);
359		fprintview(&pview, torp);
360		putc('\n', torp);
361	<	fflush(torp);                   /* assign piece to rpict */
361	>	fflush(torp);                   /* assigns piece to rpict */
362		putpiece(xorg, yorg);           /* place piece in output */
230	–	if (verbose) {                  /* notify caller */
231	–	strcat(buf, " done\n");
232	–	writebuf(fileno(stdout), buf, strlen(buf));
233	–	}
363		}
364		}
365
366
367	+	int
368		putpiece(xpos, ypos)            /* get next piece from rpict */
369		int  xpos, ypos;
370		{
371	+	struct flock  fls;
372	+	int  pid, status;
373		int  hr, vr;
374	<	int  y;
375	<
376	<	getheader(fromrp, NULL);        /* discard header info. */
377	<	if (fscnresolu(&hr, &vr, fromrp) < 0 || /* check resolution */
378	<	hr != hres || vr != vres) {
379	<	fprintf(stderr, "%s: resolution mismatch from rpict\n",
248	<	progname);
249	<	exit(1);
374	>	register int  y;
375	>	/* check bounds */
376	>	if (xpos < 0 | ypos < 0 | xpos >= hmult | ypos >= vmult) {
377	>	fprintf(stderr, "%s: requested piece (%d,%d) out of range\n",
378	>	progname, xpos, ypos);
379	>	exit(cleanup(1));
380		}
381	<	for (y = 0; y < vr; y++) {      /* transfer scanlines */
382	<	if (freadcolrs(scanline, hr, fromrp) < 0) {
383	<	fprintf(stderr, "%s: read error from rpict\n",
384	<	progname);
385	<	exit(1);
381	>	/* check header from rpict */
382	>	guard_io();
383	>	getheader(fromrp, NULL, NULL);
384	>	if (!fscnresolu(&hr, &vr, fromrp) || hr != hres | vr != vres) {
385	>	fprintf(stderr, "%s: resolution mismatch from %s\n",
386	>	progname, rpargv[0]);
387	>	exit(cleanup(1));
388	>	}
389	>	unguard();
390	>	/* load new piece into buffer */
391	>	for (y = 0; y < vr; y++) {
392	>	guard_io();
393	>	if (freadcolrs(pbuf+y*hr, hr, fromrp) < 0) {
394	>	fprintf(stderr, "%s: read error from %s\n",
395	>	progname, rpargv[0]);
396	>	exit(cleanup(1));
397		}
398	<	if ((y == 0 || hmult != 1) && lseek(outfd,
399	<	scanorig+((long)((vmult-1-ypos)*vres+y)*hmult*hres+xpos*hres)*sizeof(COLR),
400	<	0) == -1) {
401	<	fprintf(stderr, "%s: seek error\n", outfile);
402	<	exit(1);
398	>	unguard();
399	>	}
400	>	#if MAXFORK
401	>	/* fork so we don't slow rpict down */
402	>	if ((pid = fork()) > 0) {
403	>	if (++nforked >= MAXFORK) {
404	>	wait(&status);          /* reap a child */
405	>	if (status)
406	>	exit(cleanup(status>>8 & 0xff));
407	>	nforked--;
408		}
409	<	if (writebuf(outfd, (char *)scanline, hr*sizeof(COLR)) !=
410	<	hr*sizeof(COLR)) {
411	<	fprintf(stderr, "%s: write error\n", outfile);
412	<	exit(1);
409	>	return(pid);
410	>	}
411	>	#else
412	>	pid = -1;               /* no forking */
413	>	#endif
414	>	fls.l_start = scanorig +
415	>	((long)(vmult-1-ypos)*vres*hmult+xpos)*hres*sizeof(COLR);
416	>	#if NFS
417	>	fls.l_len = ((long)(vres-1)*hmult+1)*hres*sizeof(COLR);
418	>	/* lock file section so NFS doesn't mess up */
419	>	fls.l_whence = 0;
420	>	fls.l_type = F_WRLCK;
421	>	fcntl(outfd, F_SETLKW, &fls);
422	>	#endif
423	>	/* write new piece to file */
424	>	if (lseek(outfd, fls.l_start, 0) == -1)
425	>	goto seekerr;
426	>	if (hmult == 1) {
427	>	if (writebuf(outfd, (char *)pbuf,
428	>	vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
429	>	goto writerr;
430	>	} else
431	>	for (y = 0; y < vr; y++) {
432	>	if (writebuf(outfd, (char *)(pbuf+y*hr),
433	>	hr*sizeof(COLR)) != hr*sizeof(COLR))
434	>	goto writerr;
435	>	if (y < vr-1 && lseek(outfd,
436	>	(long)(hmult-1)*hr*sizeof(COLR),
437	>	1) == -1)
438	>	goto seekerr;
439		}
440	+	if (verbose) {                          /* notify caller */
441	+	printf("%d %d done\n", xpos, ypos);
442	+	fflush(stdout);
443		}
444	+	if (pid == -1) {        /* didn't fork or fork failed */
445	+	#if NFS
446	+	fls.l_type = F_UNLCK;           /* release lock */
447	+	fcntl(outfd, F_SETLKW, &fls);
448	+	#endif
449	+	return(0);
450	+	}
451	+	_exit(0);               /* else exit child process (releasing lock) */
452	+	seekerr:
453	+	fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
454	+	_exit(1);
455	+	writerr:
456	+	fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
457	+	_exit(1);
458		}
459	+
460	+	#endif

Diff Legend

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