ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rpiece.c
Revision: 2.59
Committed: Wed Jan 12 21:07:39 2022 UTC (8 months, 3 weeks ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 2.58: +12 -48 lines
Log Message:
refactor: created cropview() function to manage view sections

File Contents

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