ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rpiece.c
Revision: 2.45
Committed: Sat Oct 23 18:55:53 2004 UTC (19 years, 5 months ago) by schorsch
Content type: text/plain
Branch: MAIN
CVS Tags: rad3R7P2, rad3R7P1, rad3R6P1, rad3R8
Changes since 2.44: +4 -2 lines
Log Message:
Compatibility fixes as suggested by Siegbert Debatin.

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 schorsch 2.45 static const char RCSid[] = "$Id: rpiece.c,v 2.44 2004/06/08 19:48:31 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * Generate sections of a picture.
6     */
7    
8 schorsch 2.43
9     #include <stdio.h>
10     #include <signal.h>
11     #include <sys/types.h>
12 schorsch 2.45 #ifndef NON_POSIX /* XXX need abstraction for process management */
13     #include <sys/wait.h>
14     #endif
15 schorsch 2.43
16 greg 2.42 #include "platform.h"
17 greg 2.44 #include "standard.h"
18 schorsch 2.43 #include "color.h"
19     #include "view.h"
20     #include "rtprocess.h"
21 greg 2.16
22     #ifndef F_SETLKW
23    
24 schorsch 2.43 int
25     main(
26     int argc,
27     char *argv[]
28     )
29 greg 2.16 {
30     fprintf(stderr, "%s: no NFS lock manager on this machine\n", argv[0]);
31     exit(1);
32     }
33    
34     #else
35    
36 greg 2.12 #ifndef NFS
37     #define NFS 1
38     #endif
39 greg 2.9 /* set the following to 0 to forgo forking */
40     #ifndef MAXFORK
41 greg 2.12 #if NFS
42 greg 2.10 #define MAXFORK 3 /* allotment of duped processes */
43 greg 2.12 #else
44     #define MAXFORK 0
45 greg 2.9 #endif
46 greg 2.12 #endif
47 greg 2.18 /* protection from SYSV signals(!) */
48 greg 2.27 #if defined(sgi)
49 greg 2.18 #define guard_io() sighold(SIGALRM)
50     #define unguard() sigrelse(SIGALRM)
51     #endif
52     #ifndef guard_io
53 schorsch 2.43 #define guard_io()
54     #define unguard()
55 greg 2.18 #endif
56 gregl 2.34
57 greg 2.37 extern char *strerror();
58 gregl 2.34
59 greg 2.1 /* rpict command */
60 greg 2.23 char *rpargv[128] = {"rpict", "-S", "1"};
61     int rpargc = 3;
62 greg 2.1 FILE *torp, *fromrp;
63 greg 2.8 COLR *pbuf;
64 greg 2.1 /* our view parameters */
65     VIEW ourview = STDVIEW;
66 greg 2.4 double pixaspect = 1.0;
67 greg 2.23 int hres = 1024, vres = 1024, hmult = 4, vmult = 4;
68 greg 2.1 /* output file */
69     char *outfile = NULL;
70     int outfd;
71     long scanorig;
72 greg 2.25 FILE *syncfp = NULL; /* synchronization file pointer */
73     int synclst = F_UNLCK; /* synchronization file lock status */
74 greg 2.9 int nforked = 0;
75 greg 2.1
76 greg 2.25 #define sflock(t) if ((t)!=synclst) dolock(fileno(syncfp),synclst=t)
77    
78 greg 2.1 char *progname;
79     int verbose = 0;
80 greg 2.31 unsigned timelim = 0;
81 greg 2.25 int rvrlim = -1;
82 greg 2.1
83 greg 2.6 int gotalrm = 0;
84 schorsch 2.38 void onalrm(int i) { gotalrm++; }
85 greg 2.1
86 schorsch 2.43 static void dolock(int fd, int ltyp);
87     static void init(int ac, char **av);
88     static int nextpiece(int *xp, int *yp);
89     static int rvrpiece(int *xp, int *yp);
90     static int cleanup(int rstat);
91     static void rpiece(void);
92     static int putpiece(int xpos, int ypos);
93     static void filerr(char *t);
94 greg 2.6
95 schorsch 2.43
96     int
97     main(
98     int argc,
99     char *argv[]
100     )
101 greg 2.1 {
102     register int i, rval;
103    
104     progname = argv[0];
105     for (i = 1; i < argc; i++) {
106 greg 2.22 /* expand arguments */
107 greg 2.37 while ((rval = expandarg(&argc, &argv, i)) > 0)
108     ;
109     if (rval < 0) {
110     fprintf(stderr, "%s: cannot expand '%s'",
111     argv[0], argv[i]);
112     exit(1);
113     }
114 greg 2.1 if (argv[i][0] == '-')
115     switch (argv[i][1]) {
116     case 'v':
117     switch (argv[i][2]) {
118     case '\0': /* verbose option */
119     verbose = !verbose;
120     continue;
121     case 'f': /* view file */
122     if (viewfile(argv[++i], &ourview, NULL) <= 0) {
123     fprintf(stderr,
124     "%s: not a view file\n", argv[i]);
125     exit(1);
126     }
127     continue;
128     default: /* view option? */
129     rval = getviewopt(&ourview, argc-i, argv+i);
130     if (rval >= 0) {
131     i += rval;
132     continue;
133     }
134     break;
135     }
136     break;
137     case 'p': /* pixel aspect ratio? */
138 greg 2.23 if (argv[i][2] != 'a' || argv[i][3])
139     break;
140 gregl 2.35 pixaspect = atof(argv[++i]);
141 greg 2.23 continue;
142 greg 2.31 case 'T': /* time limit (hours) */
143     if (argv[i][2])
144     break;
145     timelim = atof(argv[++i])*3600. + .5;
146     break;
147 greg 2.23 case 'x': /* overall x resolution */
148     if (argv[i][2])
149     break;
150     hres = atoi(argv[++i]);
151     continue;
152     case 'y': /* overall y resolution */
153     if (argv[i][2])
154     break;
155     vres = atoi(argv[++i]);
156     continue;
157 greg 2.1 case 'X': /* horizontal multiplier */
158     if (argv[i][2])
159     break;
160     hmult = atoi(argv[++i]);
161     continue;
162     case 'Y': /* vertical multiplier */
163     if (argv[i][2])
164     break;
165     vmult = atoi(argv[++i]);
166     continue;
167 greg 2.25 case 'R': /* recover */
168     if (argv[i][2])
169     break;
170     rvrlim = 0;
171     /* fall through */
172 greg 2.5 case 'F': /* syncronization file */
173     if (argv[i][2])
174     break;
175 greg 2.28 if ((syncfp =
176     fdopen(open(argv[++i],O_RDWR|O_CREAT,0666),"r+")) == NULL) {
177 greg 2.5 fprintf(stderr, "%s: cannot open\n",
178     argv[i]);
179     exit(1);
180     }
181     continue;
182 greg 2.15 case 'z': /* z-file ist verbotten */
183     fprintf(stderr, "%s: -z option not allowed\n",
184     argv[0]);
185     exit(1);
186 greg 2.1 case 'o': /* output file */
187     if (argv[i][2])
188     break;
189     outfile = argv[++i];
190     continue;
191 greg 2.23 } else if (i >= argc-1)
192     break;
193 greg 2.1 rpargv[rpargc++] = argv[i];
194     }
195 greg 2.23 if (i >= argc) {
196     fprintf(stderr, "%s: missing octree argument\n", argv[0]);
197     exit(1);
198     }
199 greg 2.1 if (outfile == NULL) {
200     fprintf(stderr, "%s: missing output file\n", argv[0]);
201     exit(1);
202     }
203     init(argc, argv);
204     rpiece();
205 greg 2.15 exit(cleanup(0));
206 greg 2.1 }
207    
208    
209 schorsch 2.43 static void
210     dolock( /* lock or unlock a file */
211     int fd,
212     int ltyp
213     )
214 greg 2.25 {
215     static struct flock fls; /* static so initialized to zeroes */
216    
217     fls.l_type = ltyp;
218     if (fcntl(fd, F_SETLKW, &fls) < 0) {
219 greg 2.28 fprintf(stderr, "%s: cannot lock/unlock file: %s\n",
220 greg 2.37 progname, strerror(errno));
221 greg 2.25 exit(1);
222     }
223     }
224    
225    
226 schorsch 2.43 static void
227     init( /* set up output file and start rpict */
228     int ac,
229     char **av
230     )
231 greg 2.1 {
232 greg 2.23 static char hrbuf[16], vrbuf[16];
233 greg 2.2 extern char VersionID[];
234 greg 2.1 char *err;
235     FILE *fp;
236     int hr, vr;
237 schorsch 2.39 SUBPROC rpd; /* since we don't close_process(), this can be local */
238 greg 2.1 /* set up view */
239     if ((err = setview(&ourview)) != NULL) {
240     fprintf(stderr, "%s: %s\n", progname, err);
241     exit(1);
242     }
243 greg 2.25 if (syncfp != NULL) {
244     sflock(F_RDLCK);
245     fscanf(syncfp, "%d %d", &hmult, &vmult);
246     sflock(F_UNLCK);
247 greg 2.5 }
248 greg 2.23 /* compute piece size */
249     hres /= hmult;
250     vres /= vmult;
251 greg 2.1 normaspect(viewaspect(&ourview)*hmult/vmult, &pixaspect, &hres, &vres);
252 greg 2.23 sprintf(hrbuf, "%d", hres);
253     rpargv[rpargc++] = "-x"; rpargv[rpargc++] = hrbuf;
254     sprintf(vrbuf, "%d", vres);
255     rpargv[rpargc++] = "-y"; rpargv[rpargc++] = vrbuf;
256     rpargv[rpargc++] = "-pa"; rpargv[rpargc++] = "0";
257     rpargv[rpargc++] = av[ac-1];
258     rpargv[rpargc] = NULL;
259 greg 2.1 /* open output file */
260     if ((outfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0666)) >= 0) {
261 greg 2.25 dolock(outfd, F_WRLCK);
262 greg 2.1 if ((fp = fdopen(dup(outfd), "w")) == NULL)
263     goto filerr;
264 greg 2.29 newheader("RADIANCE", fp); /* create header */
265     printargs(ac, av, fp);
266 greg 2.2 fprintf(fp, "SOFTWARE= %s\n", VersionID);
267 greg 2.1 fputs(VIEWSTR, fp);
268     fprintview(&ourview, fp);
269     putc('\n', fp);
270     if (pixaspect < .99 || pixaspect > 1.01)
271     fputaspect(pixaspect, fp);
272     fputformat(COLRFMT, fp);
273     putc('\n', fp);
274     fprtresolu(hres*hmult, vres*vmult, fp);
275     } else if ((outfd = open(outfile, O_RDWR)) >= 0) {
276 greg 2.25 dolock(outfd, F_RDLCK);
277 greg 2.1 if ((fp = fdopen(dup(outfd), "r+")) == NULL)
278     goto filerr;
279 greg 2.13 getheader(fp, NULL, NULL); /* skip header */
280 greg 2.15 if (!fscnresolu(&hr, &vr, fp) || /* check resolution */
281 greg 2.1 hr != hres*hmult || vr != vres*vmult) {
282 greg 2.8 fprintf(stderr, "%s: resolution mismatch on file \"%s\"\n",
283     progname, outfile);
284 greg 2.1 exit(1);
285     }
286     } else {
287 greg 2.8 fprintf(stderr, "%s: cannot open file \"%s\"\n",
288     progname, outfile);
289 greg 2.1 exit(1);
290     }
291     scanorig = ftell(fp); /* record position of first scanline */
292     if (fclose(fp) == -1) /* done with stream i/o */
293     goto filerr;
294 greg 2.25 dolock(outfd, F_UNLCK);
295 greg 2.1 /* start rpict process */
296 schorsch 2.39 if (open_process(&rpd, rpargv) <= 0) {
297 greg 2.3 fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
298 greg 2.1 exit(1);
299     }
300 schorsch 2.39 if ((fromrp = fdopen(rpd.r, "r")) == NULL ||
301     (torp = fdopen(rpd.w, "w")) == NULL) {
302 greg 2.1 fprintf(stderr, "%s: cannot open stream to %s\n",
303     progname, rpargv[0]);
304     exit(1);
305     }
306 greg 2.23 if ((pbuf = (COLR *)bmalloc(hres*vres*sizeof(COLR))) == NULL) {
307 greg 2.1 fprintf(stderr, "%s: out of memory\n", progname);
308     exit(1);
309     }
310 greg 2.6 signal(SIGALRM, onalrm);
311 greg 2.31 if (timelim)
312     alarm(timelim);
313 greg 2.1 return;
314     filerr:
315 greg 2.8 fprintf(stderr, "%s: i/o error on file \"%s\"\n", progname, outfile);
316 greg 2.1 exit(1);
317     }
318    
319    
320 schorsch 2.43 static int
321     nextpiece( /* get next piece assignment */
322     int *xp,
323     int *yp
324     )
325 greg 2.5 {
326 greg 2.6 if (gotalrm) /* someone wants us to quit */
327     return(0);
328 greg 2.25 if (syncfp != NULL) { /* use sync file */
329     /*
330     * So we don't necessarily have to lock and unlock the file
331     * multiple times (very slow), we establish an exclusive
332     * lock at the beginning on our synchronization file and
333     * maintain it in the subroutine rvrpiece().
334     */
335     sflock(F_WRLCK);
336     fseek(syncfp, 0L, 0); /* read position */
337     if (fscanf(syncfp, "%*d %*d %d %d", xp, yp) < 2) {
338 greg 2.8 *xp = hmult-1;
339     *yp = vmult;
340     }
341 greg 2.25 if (rvrlim == 0) /* initialize recovery limit */
342     rvrlim = *xp*vmult + *yp;
343     if (rvrpiece(xp, yp)) { /* do stragglers first */
344     sflock(F_UNLCK);
345     return(1);
346     }
347 greg 2.8 if (--(*yp) < 0) { /* decrement position */
348 greg 2.5 *yp = vmult-1;
349 greg 2.25 if (--(*xp) < 0) { /* all done */
350     sflock(F_UNLCK);
351 greg 2.5 return(0);
352     }
353     }
354 greg 2.25 fseek(syncfp, 0L, 0); /* write new position */
355     fprintf(syncfp, "%4d %4d\n%4d %4d\n\n", hmult, vmult, *xp, *yp);
356     fflush(syncfp);
357     sflock(F_UNLCK); /* release sync file */
358 greg 2.5 return(1);
359     }
360 greg 2.26 return(scanf("%d %d", xp, yp) == 2); /* use stdin */
361 greg 2.5 }
362    
363    
364 schorsch 2.43 static int
365     rvrpiece( /* check for recoverable pieces */
366     register int *xp,
367     register int *yp
368     )
369 greg 2.25 {
370     static char *pdone = NULL; /* which pieces are done */
371     static long readpos = -1; /* how far we've read */
372     register int i;
373     /*
374     * This routine is called by nextpiece() with an
375     * exclusive lock on syncfp and the file pointer at the
376     * appropriate position to read in the finished pieces.
377     */
378     if (rvrlim < 0)
379     return(0); /* only check if asked */
380     if (pdone == NULL) /* first call */
381     pdone = calloc(hmult*vmult, sizeof(char));
382 greg 2.30 if (pdone == NULL) {
383     fprintf(stderr, "%s: out of memory\n", progname);
384     exit(1);
385     }
386 greg 2.25 if (readpos != -1) /* mark what's been done */
387     fseek(syncfp, readpos, 0);
388     while (fscanf(syncfp, "%d %d", xp, yp) == 2)
389     pdone[*xp*vmult+*yp] = 1;
390     if (!feof(syncfp)) {
391     fprintf(stderr, "%s: format error in sync file\n", progname);
392     exit(1);
393     }
394     readpos = ftell(syncfp);
395     i = hmult*vmult; /* find an unaccounted for piece */
396     while (i-- > rvrlim)
397     if (!pdone[i]) {
398     *xp = i / vmult;
399     *yp = i % vmult;
400     pdone[i] = 1; /* consider it done */
401     return(1);
402     }
403     rvrlim = -1; /* nothing left to recover */
404     free(pdone);
405     pdone = NULL;
406     return(0);
407     }
408    
409    
410 schorsch 2.43 static int
411     cleanup( /* close rpict process and clean up */
412     int rstat
413     )
414 greg 2.1 {
415 greg 2.10 int status;
416 greg 2.1
417 greg 2.23 bfree((char *)pbuf, hres*vres*sizeof(COLR));
418 greg 2.1 fclose(torp);
419     fclose(fromrp);
420 greg 2.10 while (wait(&status) != -1)
421 greg 2.9 if (rstat == 0)
422     rstat = status>>8 & 0xff;
423     return(rstat);
424 greg 2.1 }
425    
426    
427 schorsch 2.43 static void
428     rpiece(void) /* render picture piece by piece */
429 greg 2.1 {
430     VIEW pview;
431     int xorg, yorg;
432 greg 2.11 /* compute view parameters */
433 schorsch 2.40 pview = ourview;
434 greg 2.11 switch (ourview.type) {
435     case VT_PER:
436     pview.horiz = 2.*180./PI*atan(
437     tan(PI/180./2.*ourview.horiz)/hmult );
438     pview.vert = 2.*180./PI*atan(
439     tan(PI/180./2.*ourview.vert)/vmult );
440     break;
441     case VT_PAR:
442     case VT_ANG:
443     pview.horiz = ourview.horiz / hmult;
444     pview.vert = ourview.vert / vmult;
445     break;
446 greg 2.32 case VT_CYL:
447     pview.horiz = ourview.horiz / hmult;
448     pview.vert = 2.*180./PI*atan(
449     tan(PI/180./2.*ourview.vert)/vmult );
450     break;
451 greg 2.11 case VT_HEM:
452     pview.horiz = 2.*180./PI*asin(
453     sin(PI/180./2.*ourview.horiz)/hmult );
454     pview.vert = 2.*180./PI*asin(
455     sin(PI/180./2.*ourview.vert)/vmult );
456     break;
457     default:
458     fprintf(stderr, "%s: unknown view type '-vt%c'\n",
459     progname, ourview.type);
460     exit(cleanup(1));
461     }
462     /* render each piece */
463 greg 2.5 while (nextpiece(&xorg, &yorg)) {
464 gregl 2.33 pview.hoff = ourview.hoff*hmult + xorg - 0.5*(hmult-1);
465     pview.voff = ourview.voff*vmult + yorg - 0.5*(vmult-1);
466 greg 2.1 fputs(VIEWSTR, torp);
467     fprintview(&pview, torp);
468     putc('\n', torp);
469 greg 2.11 fflush(torp); /* assigns piece to rpict */
470 greg 2.1 putpiece(xorg, yorg); /* place piece in output */
471     }
472     }
473    
474    
475 schorsch 2.43 static int
476     putpiece( /* get next piece from rpict */
477     int xpos,
478     int ypos
479     )
480 greg 2.1 {
481 greg 2.7 struct flock fls;
482 greg 2.9 int pid, status;
483 greg 2.1 int hr, vr;
484 greg 2.8 register int y;
485     /* check bounds */
486 schorsch 2.41 if ((xpos < 0) | (ypos < 0) | (xpos >= hmult) | (ypos >= vmult)) {
487 greg 2.5 fprintf(stderr, "%s: requested piece (%d,%d) out of range\n",
488     progname, xpos, ypos);
489 greg 2.10 exit(cleanup(1));
490 greg 2.5 }
491 greg 2.8 /* check header from rpict */
492 greg 2.18 guard_io();
493 greg 2.13 getheader(fromrp, NULL, NULL);
494 schorsch 2.41 if (!fscnresolu(&hr, &vr, fromrp) || (hr != hres) | (vr != vres)) {
495 greg 2.3 fprintf(stderr, "%s: resolution mismatch from %s\n",
496     progname, rpargv[0]);
497 greg 2.10 exit(cleanup(1));
498 greg 2.1 }
499 greg 2.24 if (verbose) { /* notify caller */
500     printf("%d %d begun\n", xpos, ypos);
501     fflush(stdout);
502     }
503 greg 2.18 unguard();
504 greg 2.8 /* load new piece into buffer */
505 greg 2.18 for (y = 0; y < vr; y++) {
506     guard_io();
507 greg 2.8 if (freadcolrs(pbuf+y*hr, hr, fromrp) < 0) {
508 greg 2.3 fprintf(stderr, "%s: read error from %s\n",
509     progname, rpargv[0]);
510 greg 2.10 exit(cleanup(1));
511 greg 2.1 }
512 greg 2.18 unguard();
513     }
514 greg 2.9 #if MAXFORK
515     /* fork so we don't slow rpict down */
516     if ((pid = fork()) > 0) {
517 greg 2.10 if (++nforked >= MAXFORK) {
518 greg 2.9 wait(&status); /* reap a child */
519     if (status)
520 greg 2.10 exit(cleanup(status>>8 & 0xff));
521 greg 2.9 nforked--;
522     }
523     return(pid);
524     }
525     #else
526     pid = -1; /* no forking */
527     #endif
528 greg 2.19 fls.l_start = scanorig +
529     ((long)(vmult-1-ypos)*vres*hmult+xpos)*hres*sizeof(COLR);
530 greg 2.12 #if NFS
531 greg 2.19 fls.l_len = ((long)(vres-1)*hmult+1)*hres*sizeof(COLR);
532 greg 2.8 /* lock file section so NFS doesn't mess up */
533     fls.l_whence = 0;
534     fls.l_type = F_WRLCK;
535 greg 2.26 if (fcntl(outfd, F_SETLKW, &fls) < 0)
536     filerr("lock");
537 greg 2.12 #endif
538 greg 2.8 /* write new piece to file */
539 greg 2.42 if (lseek(outfd, (off_t)fls.l_start, SEEK_SET) < 0)
540 greg 2.26 filerr("seek");
541 greg 2.9 if (hmult == 1) {
542     if (writebuf(outfd, (char *)pbuf,
543     vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
544 greg 2.26 filerr("write");
545 greg 2.9 } else
546     for (y = 0; y < vr; y++) {
547     if (writebuf(outfd, (char *)(pbuf+y*hr),
548     hr*sizeof(COLR)) != hr*sizeof(COLR))
549 greg 2.26 filerr("write");
550 greg 2.9 if (y < vr-1 && lseek(outfd,
551 greg 2.37 (off_t)(hmult-1)*hr*sizeof(COLR),
552 greg 2.42 SEEK_CUR) < 0)
553 greg 2.26 filerr("seek");
554 greg 2.1 }
555 greg 2.25 #if NFS
556     fls.l_type = F_UNLCK; /* release lock */
557 greg 2.26 if (fcntl(outfd, F_SETLKW, &fls) < 0)
558     filerr("lock");
559 greg 2.25 #endif
560 greg 2.32 if (verbose) { /* notify caller */
561     printf("%d %d done\n", xpos, ypos);
562     fflush(stdout);
563     }
564 greg 2.25 if (syncfp != NULL) { /* record what's been done */
565     sflock(F_WRLCK);
566     fseek(syncfp, 0L, 2); /* append index */
567     fprintf(syncfp, "%4d %4d\n", xpos, ypos);
568     fflush(syncfp);
569     /*** Unlock not necessary, since
570     sflock(F_UNLCK); _exit() or nextpiece() is next ***/
571 greg 2.20 }
572 greg 2.25 if (pid == -1) /* didn't fork or fork failed */
573 greg 2.9 return(0);
574 greg 2.25 _exit(0); /* else exit child process (releasing locks) */
575 greg 2.26 }
576    
577    
578 schorsch 2.43 static void
579     filerr( /* report file error and exit */
580     char *t
581     )
582 greg 2.26 {
583     fprintf(stderr, "%s: %s error on file \"%s\": %s\n",
584 greg 2.37 progname, t, outfile, strerror(errno));
585 greg 2.9 _exit(1);
586 greg 2.1 }
587 greg 2.16
588     #endif