ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/ranimate.c
Revision: 2.31
Committed: Tue Feb 25 02:47:24 2003 UTC (21 years, 1 month ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad3R5
Changes since 2.30: +1 -56 lines
Log Message:
Replaced inline copyright notice with #include "copyright.h"

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id$";
3 #endif
4 /*
5 * Radiance animation control program
6 *
7 * The main difference between this program and ranimove is that
8 * we have many optimizations here for camera motion in static
9 * environments, calling rpict and pinterp on multiple processors,
10 * where ranimove puts its emphasis on object motion, and does
11 * not use any external programs for image generation.
12 *
13 * See the ranimate(1) man page for further details.
14 */
15
16 #include "copyright.h"
17
18 #include "standard.h"
19 #include <ctype.h>
20 #include <sys/stat.h>
21 #include "view.h"
22 #include "vars.h"
23 #include "netproc.h"
24 /* default blur samples */
25 #ifndef DEF_NBLUR
26 #define DEF_NBLUR 5
27 #endif
28 /* default remote shell */
29 #ifdef _AUX_SOURCE
30 #define REMSH "remsh"
31 #else
32 #define REMSH "rsh"
33 #endif
34 /* input variables (alphabetical by name) */
35 #define ANIMATE 0 /* animation command */
36 #define ARCHIVE 1 /* archiving command */
37 #define BASENAME 2 /* output image base name */
38 #define DIRECTORY 3 /* working (sub)directory */
39 #define DISKSPACE 4 /* how much disk space to use */
40 #define END 5 /* ending frame number */
41 #define EXPOSURE 6 /* how to compute exposure */
42 #define HOST 7 /* rendering host machine */
43 #define INTERP 8 /* # frames to interpolate */
44 #define MBLUR 9 /* motion blur parameters */
45 #define NEXTANIM 10 /* next animation file */
46 #define OCTREE 11 /* octree file name */
47 #define OVERSAMP 12 /* # times to oversample image */
48 #define PFILT 13 /* pfilt options */
49 #define PINTERP 14 /* pinterp options */
50 #define RENDER 15 /* rendering options */
51 #define RESOLUTION 16 /* desired final resolution */
52 #define RIF 17 /* rad input file */
53 #define RSH 18 /* remote shell script or program */
54 #define RTRACE 19 /* use rtrace with pinterp? */
55 #define START 20 /* starting frame number */
56 #define TRANSFER 21 /* frame transfer command */
57 #define VIEWFILE 22 /* animation frame views */
58
59 int NVARS = 23; /* total number of variables */
60
61 VARIABLE vv[] = { /* variable-value pairs */
62 {"ANIMATE", 2, 0, NULL, onevalue},
63 {"ARCHIVE", 2, 0, NULL, onevalue},
64 {"BASENAME", 3, 0, NULL, onevalue},
65 {"DIRECTORY", 3, 0, NULL, onevalue},
66 {"DISKSPACE", 3, 0, NULL, fltvalue},
67 {"END", 2, 0, NULL, intvalue},
68 {"EXPOSURE", 3, 0, NULL, onevalue},
69 {"host", 4, 0, NULL, NULL},
70 {"INTERPOLATE", 3, 0, NULL, intvalue},
71 {"MBLUR", 2, 0, NULL, onevalue},
72 {"NEXTANIM", 3, 0, NULL, onevalue},
73 {"OCTREE", 3, 0, NULL, onevalue},
74 {"OVERSAMPLE", 2, 0, NULL, fltvalue},
75 {"pfilt", 2, 0, NULL, catvalues},
76 {"pinterp", 2, 0, NULL, catvalues},
77 {"render", 3, 0, NULL, catvalues},
78 {"RESOLUTION", 3, 0, NULL, onevalue},
79 {"RIF", 3, 0, NULL, onevalue},
80 {"RSH", 3, 0, NULL, onevalue},
81 {"RTRACE", 2, 0, NULL, boolvalue},
82 {"START", 2, 0, NULL, intvalue},
83 {"TRANSFER", 2, 0, NULL, onevalue},
84 {"VIEWFILE", 2, 0, NULL, onevalue},
85 };
86
87 #define SFNAME "STATUS" /* status file name */
88
89 struct {
90 char host[64]; /* control host name */
91 int pid; /* control process id */
92 char cfname[128]; /* control file name */
93 int rnext; /* next frame to render */
94 int fnext; /* next frame to filter */
95 int tnext; /* next frame to transfer */
96 } astat; /* animation status */
97
98 char *progname; /* our program name */
99 char *cfname; /* our control file name */
100
101 int nowarn = 0; /* turn warnings off? */
102 int silent = 0; /* silent mode? */
103 int noaction = 0; /* take no action? */
104
105 char *remsh; /* remote shell program/script */
106 char rendopt[2048]; /* rendering options */
107 char rresopt[32]; /* rendering resolution options */
108 char fresopt[32]; /* filter resolution options */
109 int pfiltalways; /* always use pfilt? */
110
111 char arcargs[10240]; /* files to archive */
112 char *arcfirst, *arcnext; /* pointers to first and next argument */
113
114 struct pslot {
115 int pid; /* process ID (0 if empty) */
116 int fout; /* output frame number */
117 int (*rcvf)(); /* recover function */
118 } *pslot; /* process slots */
119 int npslots; /* number of process slots */
120
121 #define phostname(ps) ((ps)->hostname[0] ? (ps)->hostname : astat.host)
122
123 struct pslot *findpslot();
124
125 PSERVER *lastpserver; /* last process server with error */
126
127 VIEW *getview();
128 char *getexp(), *dirfile();
129 int getblur();
130
131 extern time_t time();
132
133
134 main(argc, argv)
135 int argc;
136 char *argv[];
137 {
138 int explicate = 0;
139 int i;
140
141 progname = argv[0]; /* get arguments */
142 for (i = 1; i < argc && argv[i][0] == '-'; i++)
143 switch (argv[i][1]) {
144 case 'e': /* print variables */
145 explicate++;
146 break;
147 case 'w': /* turn off warnings */
148 nowarn++;
149 break;
150 case 's': /* silent mode */
151 silent++;
152 break;
153 case 'n': /* take no action */
154 noaction++;
155 break;
156 default:
157 goto userr;
158 }
159 if (i != argc-1)
160 goto userr;
161 cfname = argv[i];
162 /* load variables */
163 loadvars(cfname);
164 /* check variables */
165 checkvalues();
166 /* did we get DIRECTORY? */
167 checkdir();
168 /* check status */
169 if (getastat() < 0) {
170 fprintf(stderr, "%s: exiting\n", progname);
171 quit(1);
172 }
173 /* pfilt always if options given */
174 pfiltalways = vdef(PFILT);
175 /* load RIF if any */
176 if (vdef(RIF))
177 getradfile(vval(RIF));
178 /* set defaults */
179 setdefaults();
180 /* print variables */
181 if (explicate)
182 printvars(stdout);
183 /* set up process servers */
184 sethosts();
185 /* run animation */
186 animate();
187 /* all done */
188 if (vdef(NEXTANIM)) {
189 argv[i] = vval(NEXTANIM); /* just change input file */
190 if (!silent)
191 printargs(argc, argv, stdout);
192 if ((argv[0] = getpath(progname,getenv("PATH"),X_OK)) == NULL)
193 fprintf(stderr, "%s: command not found\n", progname);
194 else
195 execv(progname, argv);
196 quit(1);
197 }
198 quit(0);
199 userr:
200 fprintf(stderr, "Usage: %s [-s][-n][-w][-e] anim_file\n", progname);
201 quit(1);
202 }
203
204
205 getastat() /* check/set animation status */
206 {
207 char sfname[256];
208 FILE *fp;
209
210 sprintf(sfname, "%s/%s", vval(DIRECTORY), SFNAME);
211 if ((fp = fopen(sfname, "r")) == NULL) {
212 if (errno != ENOENT) {
213 perror(sfname);
214 return(-1);
215 }
216 astat.rnext = astat.fnext = astat.tnext = 0;
217 goto setours;
218 }
219 if (fscanf(fp, "Control host: %s\n", astat.host) != 1)
220 goto fmterr;
221 if (fscanf(fp, "Control PID: %d\n", &astat.pid) != 1)
222 goto fmterr;
223 if (fscanf(fp, "Control file: %s\n", astat.cfname) != 1)
224 goto fmterr;
225 if (fscanf(fp, "Next render: %d\n", &astat.rnext) != 1)
226 goto fmterr;
227 if (fscanf(fp, "Next filter: %d\n", &astat.fnext) != 1)
228 goto fmterr;
229 if (fscanf(fp, "Next transfer: %d\n", &astat.tnext) != 1)
230 goto fmterr;
231 fclose(fp);
232 if (astat.pid != 0) { /* thinks it's still running */
233 if (strcmp(myhostname(), astat.host)) {
234 fprintf(stderr,
235 "%s: process %d may still be running on host %s\n",
236 progname, astat.pid, astat.host);
237 return(-1);
238 }
239 if (kill(astat.pid, 0) != -1 || errno != ESRCH) {
240 fprintf(stderr, "%s: process %d is still running\n",
241 progname, astat.pid);
242 return(-1);
243 }
244 /* assume it is dead */
245 }
246 if (strcmp(cfname, astat.cfname) && astat.pid != 0) { /* other's */
247 fprintf(stderr, "%s: unfinished job \"%s\"\n",
248 progname, astat.cfname);
249 return(-1);
250 }
251 /* check control file mods. */
252 if (!nowarn && fdate(cfname) > fdate(sfname))
253 fprintf(stderr,
254 "%s: warning - control file modified since last run\n",
255 progname);
256 setours: /* set our values */
257 strcpy(astat.host, myhostname());
258 astat.pid = getpid();
259 strcpy(astat.cfname, cfname);
260 return(0);
261 fmterr:
262 fprintf(stderr, "%s: format error in status file \"%s\"\n",
263 progname, sfname);
264 fclose(fp);
265 return(-1);
266 }
267
268
269 putastat() /* put out current status */
270 {
271 char buf[256];
272 FILE *fp;
273
274 if (noaction)
275 return;
276 sprintf(buf, "%s/%s", vval(DIRECTORY), SFNAME);
277 if ((fp = fopen(buf, "w")) == NULL) {
278 perror(buf);
279 quit(1);
280 }
281 fprintf(fp, "Control host: %s\n", astat.host);
282 fprintf(fp, "Control PID: %d\n", astat.pid);
283 fprintf(fp, "Control file: %s\n", astat.cfname);
284 fprintf(fp, "Next render: %d\n", astat.rnext);
285 fprintf(fp, "Next filter: %d\n", astat.fnext);
286 fprintf(fp, "Next transfer: %d\n", astat.tnext);
287 fclose(fp);
288 }
289
290
291 checkdir() /* make sure we have our directory */
292 {
293 struct stat stb;
294
295 if (!vdef(DIRECTORY)) {
296 fprintf(stderr, "%s: %s undefined\n",
297 progname, vnam(DIRECTORY));
298 quit(1);
299 }
300 if (stat(vval(DIRECTORY), &stb) == -1) {
301 if (errno == ENOENT && mkdir(vval(DIRECTORY), 0777) == 0)
302 return;
303 perror(vval(DIRECTORY));
304 quit(1);
305 }
306 if (!(stb.st_mode & S_IFDIR)) {
307 fprintf(stderr, "%s: not a directory\n", vval(DIRECTORY));
308 quit(1);
309 }
310 }
311
312
313 setdefaults() /* set default values */
314 {
315 extern char *atos();
316 int decades;
317 char buf[256];
318
319 if (vdef(ANIMATE)) {
320 vval(OCTREE) = NULL;
321 vdef(OCTREE) = 0;
322 } else if (!vdef(OCTREE)) {
323 fprintf(stderr, "%s: either %s or %s must be defined\n",
324 progname, vnam(OCTREE), vnam(ANIMATE));
325 quit(1);
326 }
327 if (!vdef(VIEWFILE)) {
328 fprintf(stderr, "%s: %s undefined\n", progname, vnam(VIEWFILE));
329 quit(1);
330 }
331 if (!vdef(HOST)) {
332 vval(HOST) = LHOSTNAME;
333 vdef(HOST)++;
334 }
335 if (!vdef(START)) {
336 vval(START) = "1";
337 vdef(START)++;
338 }
339 if (!vdef(END)) {
340 sprintf(buf, "%d", countviews()+vint(START)-1);
341 vval(END) = savqstr(buf);
342 vdef(END)++;
343 }
344 if (vint(END) < vint(START)) {
345 fprintf(stderr, "%s: ending frame less than starting frame\n",
346 progname);
347 quit(1);
348 }
349 if (!vdef(BASENAME)) {
350 decades = (int)log10((double)vint(END)) + 1;
351 if (decades < 3) decades = 3;
352 sprintf(buf, "%s/frame%%0%dd", vval(DIRECTORY), decades);
353 vval(BASENAME) = savqstr(buf);
354 vdef(BASENAME)++;
355 }
356 if (!vdef(RESOLUTION)) {
357 vval(RESOLUTION) = "640";
358 vdef(RESOLUTION)++;
359 }
360 if (!vdef(OVERSAMP)) {
361 vval(OVERSAMP) = "2";
362 vdef(OVERSAMP)++;
363 }
364 if (!vdef(INTERP)) {
365 vval(INTERP) = "0";
366 vdef(INTERP)++;
367 }
368 if (!vdef(MBLUR)) {
369 vval(MBLUR) = "0";
370 vdef(MBLUR)++;
371 }
372 if (!vdef(RTRACE)) {
373 vval(RTRACE) = "F";
374 vdef(RTRACE)++;
375 }
376 if (!vdef(DISKSPACE)) {
377 if (!nowarn)
378 fprintf(stderr,
379 "%s: warning - no %s setting, assuming 100 Mbytes available\n",
380 progname, vnam(DISKSPACE));
381 vval(DISKSPACE) = "100";
382 vdef(DISKSPACE)++;
383 }
384 if (!vdef(RSH)) {
385 vval(RSH) = REMSH;
386 vdef(RSH)++;
387 }
388 /* locate remote shell program */
389 atos(buf, sizeof(buf), vval(RSH));
390 if ((remsh = getpath(buf, getenv("PATH"), X_OK)) != NULL)
391 remsh = savqstr(remsh);
392 else
393 remsh = vval(RSH); /* will generate error if used */
394
395 /* append rendering options */
396 if (vdef(RENDER))
397 sprintf(rendopt+strlen(rendopt), " %s", vval(RENDER));
398 }
399
400
401 sethosts() /* set up process servers */
402 {
403 extern char *iskip();
404 char buf[256], *dir, *uname;
405 int np;
406 register char *cp;
407 int i;
408
409 npslots = 0;
410 if (noaction)
411 return;
412 for (i = 0; i < vdef(HOST); i++) { /* add each host */
413 dir = uname = NULL;
414 np = 1;
415 strcpy(cp=buf, nvalue(HOST, i)); /* copy to buffer */
416 cp = sskip(cp); /* skip host name */
417 while (isspace(*cp))
418 *cp++ = '\0';
419 if (*cp) { /* has # processes? */
420 np = atoi(cp);
421 if ((cp = iskip(cp)) == NULL || (*cp && !isspace(*cp)))
422 badvalue(HOST);
423 while (isspace(*cp))
424 cp++;
425 if (*cp) { /* has directory? */
426 dir = cp;
427 cp = sskip(cp); /* skip dir. */
428 while (isspace(*cp))
429 *cp++ = '\0';
430 if (*cp) { /* has user? */
431 uname = cp;
432 if (*sskip(cp))
433 badvalue(HOST);
434 }
435 }
436 }
437 if (addpserver(buf, dir, uname, np) == NULL) {
438 if (!nowarn)
439 fprintf(stderr,
440 "%s: cannot execute on host \"%s\"\n",
441 progname, buf);
442 } else
443 npslots += np;
444 }
445 if (npslots == 0) {
446 fprintf(stderr, "%s: no working process servers\n", progname);
447 quit(1);
448 }
449 pslot = (struct pslot *)calloc(npslots, sizeof(struct pslot));
450 if (pslot == NULL) {
451 perror("malloc");
452 quit(1);
453 }
454 }
455
456
457 getradfile(rfargs) /* run rad and get needed variables */
458 char *rfargs;
459 {
460 static short mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
461 char combuf[256];
462 register int i;
463 register char *cp;
464 char *pippt;
465 /* create rad command */
466 sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
467 sprintf(combuf,
468 "rad -v 0 -s -e -w %s OPTFILE=%s | egrep '^[ \t]*(NOMATCH",
469 rfargs, rendopt+2);
470 cp = combuf;
471 while (*cp) {
472 if (*cp == '|') pippt = cp;
473 cp++;
474 } /* match unset variables */
475 for (i = 0; mvar[i] >= 0; i++)
476 if (!vdef(mvar[i])) {
477 *cp++ = '|';
478 strcpy(cp, vnam(mvar[i]));
479 while (*cp) cp++;
480 pippt = NULL;
481 }
482 if (pippt != NULL)
483 strcpy(pippt, "> /dev/null"); /* nothing to match */
484 else {
485 sprintf(cp, ")[ \t]*=' > %s/radset.var", vval(DIRECTORY));
486 cp += 11; /* point to file name */
487 }
488 system(combuf); /* ignore exit code */
489 if (pippt == NULL) { /* load variables and remove file */
490 loadvars(cp);
491 unlink(cp);
492 }
493 }
494
495
496 animate() /* run animation */
497 {
498 int xres, yres;
499 float pa, mult;
500 int frames_batch;
501 register int i;
502 double d1, d2;
503 /* compute rpict resolution */
504 i = sscanf(vval(RESOLUTION), "%d %d %f", &xres, &yres, &pa);
505 mult = vflt(OVERSAMP);
506 if (i == 3) {
507 sprintf(rresopt, "-x %d -y %d -pa %.3f", (int)(mult*xres),
508 (int)(mult*yres), pa);
509 sprintf(fresopt, "-x %d -y %d -pa %.3f", xres, yres, pa);
510 } else if (i) {
511 if (i == 1) yres = xres;
512 sprintf(rresopt, "-x %d -y %d", (int)(mult*xres),
513 (int)(mult*yres));
514 sprintf(fresopt, "-x %d -y %d -pa 1", xres, yres);
515 } else
516 badvalue(RESOLUTION);
517 /* consistency checks */
518 if (vdef(ANIMATE)) {
519 if (vint(INTERP)) {
520 if (!nowarn)
521 fprintf(stderr,
522 "%s: resetting %s=0 for animation\n",
523 progname, vnam(INTERP));
524 vval(INTERP) = "0";
525 }
526 if (strcmp(vval(MBLUR),"0")) { /* can't handle this */
527 if (!nowarn)
528 fprintf(stderr,
529 "%s: resetting %s=0 for animation\n",
530 progname, vnam(MBLUR));
531 vval(MBLUR) = "0";
532 }
533 }
534 /* figure # frames per batch */
535 d1 = mult*xres*mult*yres*4; /* space for orig. picture */
536 if ((i=vint(INTERP)) || getblur(NULL) > 1)
537 d1 += mult*xres*mult*yres*sizeof(float); /* Z-buffer */
538 d2 = xres*yres*4; /* space for final picture */
539 frames_batch = (i+1)*(vflt(DISKSPACE)*1048576.-d1)/(d1+i*d2);
540 if (frames_batch < i+2) {
541 fprintf(stderr, "%s: insufficient disk space allocated\n",
542 progname);
543 quit(1);
544 }
545 /* initialize archive argument list */
546 i = vdef(ARCHIVE) ? strlen(vval(ARCHIVE))+132 : 132;
547 arcnext = arcfirst = arcargs + i;
548 /* initialize status file */
549 if (astat.rnext == 0)
550 astat.rnext = astat.fnext = astat.tnext = vint(START);
551 putastat();
552 /* render in batches */
553 while (astat.tnext <= vint(END)) {
554 renderframes(frames_batch);
555 filterframes();
556 transferframes();
557 }
558 /* mark status as finished */
559 astat.pid = 0;
560 putastat();
561 /* close open files */
562 getview(0);
563 getexp(0);
564 }
565
566
567 renderframes(nframes) /* render next nframes frames */
568 int nframes;
569 {
570 static char vendbuf[16];
571 VIEW *vp;
572 FILE *fp = NULL;
573 char vfname[128];
574 int lastframe;
575 register int i;
576
577 if (astat.tnext < astat.rnext) /* other work to do first */
578 return;
579 /* create batch view file */
580 if (!vdef(ANIMATE)) {
581 sprintf(vfname, "%s/anim.vf", vval(DIRECTORY));
582 if ((fp = fopen(vfname, "w")) == NULL) {
583 perror(vfname);
584 quit(1);
585 }
586 }
587 /* bound batch properly */
588 lastframe = astat.rnext + nframes - 1;
589 if ((lastframe-1) % (vint(INTERP)+1)) /* need even interval */
590 lastframe += vint(INTERP)+1 - ((lastframe-1)%(vint(INTERP)+1));
591 if (lastframe > vint(END)) /* check for end */
592 lastframe = vint(END);
593 /* render each view */
594 for (i = astat.rnext; i <= lastframe; i++) {
595 if ((vp = getview(i)) == NULL) {
596 if (!nowarn)
597 fprintf(stderr,
598 "%s: ran out of views before last frame\n",
599 progname);
600 sprintf(vval(END)=vendbuf, "%d", i-1);
601 lastframe = i - 1;
602 break;
603 }
604 if (vdef(ANIMATE)) /* animate frame */
605 animrend(i, vp);
606 else { /* else record it */
607 fputs(VIEWSTR, fp);
608 fprintview(vp, fp);
609 putc('\n', fp);
610 }
611 }
612 if (vdef(ANIMATE)) /* wait for renderings to finish */
613 bwait(0);
614 else { /* else if walk-through */
615 fclose(fp); /* close view file */
616 walkwait(astat.rnext, lastframe, vfname); /* walk it */
617 unlink(vfname); /* remove view file */
618 }
619 astat.rnext = i; /* update status */
620 putastat();
621 }
622
623
624 filterframes() /* catch up with filtering */
625 {
626 VIEW *vp;
627 register int i;
628
629 if (astat.tnext < astat.fnext) /* other work to do first */
630 return;
631 /* filter each view */
632 for (i = astat.fnext; i < astat.rnext; i++) {
633 if ((vp = getview(i)) == NULL) { /* get view i */
634 fprintf(stderr,
635 "%s: unexpected error reading view for frame %d\n",
636 progname, i);
637 quit(1);
638 }
639 dofilt(i, vp, getexp(i), 0); /* filter frame */
640 }
641 bwait(0); /* wait for filter processes */
642 archive(); /* archive originals */
643 astat.fnext = i; /* update status */
644 putastat();
645 }
646
647
648 transferframes() /* catch up with picture transfers */
649 {
650 char combuf[10240], *fbase;
651 register char *cp;
652 register int i;
653
654 if (astat.tnext >= astat.fnext) /* nothing to do, yet */
655 return;
656 if (!vdef(TRANSFER)) { /* no transfer function -- leave 'em */
657 astat.tnext = astat.fnext;
658 putastat(); /* update status */
659 return;
660 }
661 strcpy(combuf, "cd "); /* start transfer command */
662 fbase = dirfile(cp = combuf+3, vval(BASENAME));
663 if (*cp) {
664 while (*++cp) ;
665 *cp++ = ';'; *cp++ = ' ';
666 } else
667 cp = combuf;
668 strcpy(cp, vval(TRANSFER));
669 while (*cp) cp++;
670 /* make argument list */
671 for (i = astat.tnext; i < astat.fnext; i++) {
672 *cp++ = ' ';
673 sprintf(cp, fbase, i);
674 while (*cp) cp++;
675 strcpy(cp, ".pic");
676 cp += 4;
677 }
678 if (runcom(combuf)) { /* transfer frames */
679 fprintf(stderr, "%s: error running transfer command\n",
680 progname);
681 quit(1);
682 }
683 astat.tnext = i; /* update status */
684 putastat();
685 }
686
687
688 animrend(frame, vp) /* start animation frame */
689 int frame;
690 VIEW *vp;
691 {
692 extern int recover();
693 char combuf[2048];
694 char fname[128];
695
696 sprintf(fname, vval(BASENAME), frame);
697 strcat(fname, ".unf");
698 if (access(fname, F_OK) == 0)
699 return;
700 sprintf(combuf, "%s %d | rpict%s%s -w0 %s > %s", vval(ANIMATE), frame,
701 rendopt, viewopt(vp), rresopt, fname);
702 bruncom(combuf, frame, recover); /* run in background */
703 }
704
705
706 walkwait(first, last, vfn) /* walk-through frames */
707 int first, last;
708 char *vfn;
709 {
710 double blurf;
711 int nblur = getblur(&blurf);
712 char combuf[2048];
713 register char *inspoint;
714 register int i;
715
716 if (!noaction && vint(INTERP)) /* create dummy frames */
717 for (i = first; i <= last; i++)
718 if (i < vint(END) && (i-1) % (vint(INTERP)+1)) {
719 sprintf(combuf, vval(BASENAME), i);
720 strcat(combuf, ".unf");
721 close(open(combuf, O_RDONLY|O_CREAT, 0666));
722 }
723 /* create command */
724 sprintf(combuf, "rpict%s%s -w0", rendopt,
725 viewopt(getview(first>1 ? first-1 : 1)));
726 inspoint = combuf;
727 while (*inspoint) inspoint++;
728 if (nblur) {
729 sprintf(inspoint, " -pm %.3f", blurf/nblur);
730 while (*inspoint) inspoint++;
731 }
732 if (nblur > 1 || vint(INTERP)) {
733 sprintf(inspoint, " -z %s.zbf", vval(BASENAME));
734 while (*inspoint) inspoint++;
735 }
736 sprintf(inspoint, " -o %s.unf %s -S %d",
737 vval(BASENAME), rresopt, first);
738 while (*inspoint) inspoint++;
739 sprintf(inspoint, " %s < %s", vval(OCTREE), vfn);
740 /* run in parallel */
741 i = (last-first+1)/(vint(INTERP)+1);
742 if (i < 1) i = 1;
743 if (pruncom(combuf, inspoint, i)) {
744 fprintf(stderr, "%s: error rendering frames %d through %d\n",
745 progname, first, last);
746 quit(1);
747 }
748 if (!noaction && vint(INTERP)) /* remove dummy frames */
749 for (i = first; i <= last; i++)
750 if (i < vint(END) && (i-1) % (vint(INTERP)+1)) {
751 sprintf(combuf, vval(BASENAME), i);
752 strcat(combuf, ".unf");
753 unlink(combuf);
754 }
755 }
756
757
758 int
759 recover(frame) /* recover the specified frame */
760 int frame;
761 {
762 static int *rfrm; /* list of recovered frames */
763 static int nrfrms = 0;
764 double blurf;
765 int nblur = getblur(&blurf);
766 char combuf[2048];
767 char fname[128];
768 register char *cp;
769 register int i;
770 /* check to see if recovered already */
771 for (i = nrfrms; i--; )
772 if (rfrm[i] == frame)
773 return(0);
774 /* build command */
775 sprintf(fname, vval(BASENAME), frame);
776 if (vdef(ANIMATE))
777 sprintf(combuf, "%s %d | rpict%s -w0",
778 vval(ANIMATE), frame, rendopt);
779 else
780 sprintf(combuf, "rpict%s -w0", rendopt);
781 cp = combuf;
782 while (*cp) cp++;
783 if (nblur) {
784 sprintf(cp, " -pm %.3f", blurf/nblur);
785 while (*cp) cp++;
786 }
787 if (nblur > 1 || vint(INTERP)) {
788 sprintf(cp, " -z %s.zbf", fname);
789 while (*cp) cp++;
790 }
791 sprintf(cp, " -ro %s.unf", fname);
792 while (*cp) cp++;
793 if (!vdef(ANIMATE)) {
794 *cp++ = ' ';
795 strcpy(cp, vval(OCTREE));
796 }
797 if (runcom(combuf)) /* run command */
798 return(1);
799 /* add frame to recovered list */
800 if (nrfrms)
801 rfrm = (int *)realloc((char *)rfrm, (nrfrms+1)*sizeof(int));
802 else
803 rfrm = (int *)malloc(sizeof(int));
804 if (rfrm == NULL) {
805 perror("malloc");
806 quit(1);
807 }
808 rfrm[nrfrms++] = frame;
809 return(0);
810 }
811
812
813 int
814 frecover(frame) /* recover filtered frame */
815 int frame;
816 {
817 VIEW *vp;
818 char *ex;
819
820 vp = getview(frame);
821 ex = getexp(frame);
822 if (dofilt(frame, vp, ex, 2) && dofilt(frame, vp, ex, 1))
823 return(1);
824 return(0);
825 }
826
827
828 archive() /* archive and remove renderings */
829 {
830 #define RMCOML (sizeof(rmcom)-1)
831 static char rmcom[] = "rm -f";
832 char basedir[128];
833 int dlen, alen;
834 register int j;
835
836 if (arcnext == arcfirst)
837 return; /* nothing to do */
838 dirfile(basedir, vval(BASENAME));
839 dlen = strlen(basedir);
840 if (vdef(ARCHIVE)) { /* run archive command */
841 alen = strlen(vval(ARCHIVE));
842 if (dlen) {
843 j = alen + dlen + 5;
844 strncpy(arcfirst-j, "cd ", 3);
845 strncpy(arcfirst-j+3, basedir, dlen);
846 (arcfirst-j)[dlen+3] = ';'; (arcfirst-j)[dlen+4] = ' ';
847 } else
848 j = alen;
849 strncpy(arcfirst-alen, vval(ARCHIVE), alen);
850 if (runcom(arcfirst-j)) {
851 fprintf(stderr, "%s: error running archive command\n",
852 progname);
853 quit(1);
854 }
855 }
856 if (dlen) {
857 j = RMCOML + dlen + 5;
858 strncpy(arcfirst-j, "cd ", 3);
859 strncpy(arcfirst-j+3, basedir, dlen);
860 (arcfirst-j)[dlen+3] = ';'; (arcfirst-j)[dlen+4] = ' ';
861 } else
862 j = RMCOML;
863 /* run remove command */
864 strncpy(arcfirst-RMCOML, rmcom, RMCOML);
865 runcom(arcfirst-j);
866 arcnext = arcfirst; /* reset argument list */
867 #undef RMCOML
868 }
869
870
871 int
872 dofilt(frame, vp, ep, rvr) /* filter frame */
873 int frame;
874 VIEW *vp;
875 char *ep;
876 int rvr;
877 {
878 extern int frecover();
879 static int iter = 0;
880 double blurf;
881 int nblur = getblur(&blurf);
882 char fnbefore[128], fnafter[128], *fbase;
883 char combuf[1024], fname0[128], fname1[128];
884 int usepinterp, usepfilt, nora_rgbe;
885 int frseq[2];
886 /* check what is needed */
887 usepinterp = (nblur > 1);
888 usepfilt = pfiltalways | ep==NULL;
889 if (ep != NULL && !strcmp(ep, "1"))
890 ep = "+0";
891 nora_rgbe = strcmp(vval(OVERSAMP),"1") || ep==NULL ||
892 *ep != '+' || *ep != '-' || !isint(ep);
893 /* compute rendered views */
894 frseq[0] = frame - ((frame-1) % (vint(INTERP)+1));
895 frseq[1] = frseq[0] + vint(INTERP) + 1;
896 fbase = dirfile(NULL, vval(BASENAME));
897 if (frseq[1] > vint(END))
898 frseq[1] = vint(END);
899 if (frseq[1] == frame) { /* pfilt only */
900 frseq[0] = frseq[1];
901 usepinterp = 0; /* update what's needed */
902 usepfilt |= nora_rgbe;
903 } else if (frseq[0] == frame) { /* no interpolation needed */
904 if (!rvr && frame > 1+vint(INTERP)) { /* archive previous */
905 *arcnext++ = ' ';
906 sprintf(arcnext, fbase, frame-vint(INTERP)-1);
907 while (*arcnext) arcnext++;
908 strcpy(arcnext, ".unf");
909 arcnext += 4;
910 if (usepinterp || vint(INTERP)) { /* and Z-buf */
911 *arcnext++ = ' ';
912 sprintf(arcnext, fbase, frame-vint(INTERP)-1);
913 while (*arcnext) arcnext++;
914 strcpy(arcnext, ".zbf");
915 arcnext += 4;
916 }
917 }
918 if (!usepinterp) /* update what's needed */
919 usepfilt |= nora_rgbe;
920 } else /* interpolation needed */
921 usepinterp++;
922 if (frseq[1] >= astat.rnext) /* next batch unavailable */
923 frseq[1] = frseq[0];
924 sprintf(fnbefore, vval(BASENAME), frseq[0]);
925 sprintf(fnafter, vval(BASENAME), frseq[1]);
926 if (rvr == 1 && recover(frseq[0])) /* recover before frame? */
927 return(1);
928 /* generate command */
929 if (usepinterp) { /* using pinterp */
930 if (rvr == 2 && recover(frseq[1])) /* recover after? */
931 return(1);
932 if (nblur > 1) { /* with pmblur */
933 sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
934 'a'+(iter%26));
935 sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
936 'a'+(iter%26));
937 if (!noaction) {
938 FILE *fp; /* motion blurring */
939 if ((fp = fopen(fname0, "w")) == NULL) {
940 perror(fname0); quit(1);
941 }
942 fputs(VIEWSTR, fp);
943 fprintview(vp, fp);
944 putc('\n', fp); fclose(fp);
945 if ((vp = getview(frame+1)) == NULL) {
946 fprintf(stderr,
947 "%s: unexpected error reading view for frame %d\n",
948 progname, frame+1);
949 quit(1);
950 }
951 if ((fp = fopen(fname1, "w")) == NULL) {
952 perror(fname1); quit(1);
953 }
954 fputs(VIEWSTR, fp);
955 fprintview(vp, fp);
956 putc('\n', fp); fclose(fp);
957 }
958 sprintf(combuf,
959 "(pmblur %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
960 blurf, nblur,
961 fname0, fname1, fname0, fname1);
962 iter++;
963 } else /* no blurring */
964 strcpy(combuf, "pinterp");
965 strcat(combuf, viewopt(vp));
966 if (vbool(RTRACE))
967 sprintf(combuf+strlen(combuf), " -ff -fr '%s -w0 %s'",
968 rendopt+1, vval(OCTREE));
969 if (vdef(PINTERP))
970 sprintf(combuf+strlen(combuf), " %s", vval(PINTERP));
971 if (usepfilt)
972 sprintf(combuf+strlen(combuf), " %s", rresopt);
973 else
974 sprintf(combuf+strlen(combuf), "-a %s -e %s",
975 fresopt, ep);
976 sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
977 fnbefore, fnbefore);
978 if (frseq[1] != frseq[0])
979 sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
980 fnafter, fnafter);
981 if (usepfilt) { /* also pfilt */
982 if (vdef(PFILT))
983 sprintf(combuf+strlen(combuf), " | pfilt %s",
984 vval(PFILT));
985 else
986 strcat(combuf, " | pfilt");
987 if (ep != NULL)
988 sprintf(combuf+strlen(combuf), " -1 -e %s %s",
989 ep, fresopt);
990 else
991 sprintf(combuf+strlen(combuf), " %s", fresopt);
992 }
993 } else if (usepfilt) { /* pfilt only */
994 if (rvr == 2)
995 return(1);
996 if (vdef(PFILT))
997 sprintf(combuf, "pfilt %s", vval(PFILT));
998 else
999 strcpy(combuf, "pfilt");
1000 if (ep != NULL)
1001 sprintf(combuf+strlen(combuf), " -1 -e %s %s %s.unf",
1002 ep, fresopt, fnbefore);
1003 else
1004 sprintf(combuf+strlen(combuf), " %s %s.unf",
1005 fresopt, fnbefore);
1006 } else { /* else just check it */
1007 if (rvr == 2)
1008 return(1);
1009 sprintf(combuf, "ra_rgbe -e %s -r %s.unf", ep, fnbefore);
1010 }
1011 /* output file name */
1012 sprintf(fname0, vval(BASENAME), frame);
1013 sprintf(combuf+strlen(combuf), " > %s.pic", fname0);
1014 if (rvr) /* in recovery */
1015 return(runcom(combuf));
1016 bruncom(combuf, frame, frecover); /* else run in background */
1017 return(0);
1018 }
1019
1020
1021 VIEW *
1022 getview(n) /* get view number n */
1023 int n;
1024 {
1025 static FILE *viewfp = NULL; /* view file pointer */
1026 static int viewnum = 0; /* current view number */
1027 static VIEW curview = STDVIEW; /* current view */
1028 char linebuf[256];
1029
1030 if (n == 0) { /* signal to close file and clean up */
1031 if (viewfp != NULL) {
1032 fclose(viewfp);
1033 viewfp = NULL;
1034 viewnum = 0;
1035 copystruct(&curview, &stdview);
1036 }
1037 return(NULL);
1038 }
1039 if (viewfp == NULL) { /* open file */
1040 if ((viewfp = fopen(vval(VIEWFILE), "r")) == NULL) {
1041 perror(vval(VIEWFILE));
1042 quit(1);
1043 }
1044 } else if (n > 0 && n < viewnum) { /* rewind file */
1045 if (viewnum == 1 && feof(viewfp))
1046 return(&curview); /* just one view */
1047 if (fseek(viewfp, 0L, 0) == EOF) {
1048 perror(vval(VIEWFILE));
1049 quit(1);
1050 }
1051 copystruct(&curview, &stdview);
1052 viewnum = 0;
1053 }
1054 if (n < 0) { /* get next view */
1055 register int c = getc(viewfp);
1056 if (c == EOF)
1057 return((VIEW *)NULL); /* that's it */
1058 ungetc(c, viewfp);
1059 n = viewnum + 1;
1060 }
1061 while (n > viewnum) { /* scan to desired view */
1062 if (fgets(linebuf, sizeof(linebuf), viewfp) == NULL)
1063 return(viewnum==1 ? &curview : (VIEW *)NULL);
1064 if (isview(linebuf) && sscanview(&curview, linebuf) > 0)
1065 viewnum++;
1066 }
1067 return(&curview); /* return it */
1068 }
1069
1070
1071 int
1072 countviews() /* count views in view file */
1073 {
1074 int n;
1075
1076 if (getview(n=1) == NULL)
1077 return(0);
1078 while (getview(-1) != NULL)
1079 n++;
1080 return(n);
1081 }
1082
1083
1084 char *
1085 getexp(n) /* get exposure for nth frame */
1086 int n;
1087 {
1088 extern char *fskip();
1089 static char expval[32];
1090 static FILE *expfp = NULL;
1091 static long *exppos;
1092 static int curfrm;
1093 register char *cp;
1094
1095 if (n == 0) { /* signal to close file */
1096 if (expfp != NULL) {
1097 fclose(expfp);
1098 free((void *)exppos);
1099 expfp = NULL;
1100 }
1101 return(NULL);
1102 } else if (n > vint(END)) /* request past end (error?) */
1103 return(NULL);
1104 if (!vdef(EXPOSURE)) /* no setting (auto) */
1105 return(NULL);
1106 if (isflt(vval(EXPOSURE))) /* always the same */
1107 return(vval(EXPOSURE));
1108 if (expfp == NULL) { /* open exposure file */
1109 if ((expfp = fopen(vval(EXPOSURE), "r")) == NULL) {
1110 fprintf(stderr,
1111 "%s: cannot open exposure file \"%s\"\n",
1112 progname, vval(EXPOSURE));
1113 quit(1);
1114 }
1115 curfrm = vint(END) + 1; /* init lookup tab. */
1116 exppos = (long *)malloc(curfrm*sizeof(long *));
1117 if (exppos == NULL) {
1118 perror(progname);
1119 quit(1);
1120 }
1121 while (curfrm--)
1122 exppos[curfrm] = -1L;
1123 curfrm = 0;
1124 }
1125 /* find position in file */
1126 if (n-1 != curfrm && n != curfrm && exppos[n-1] >= 0 &&
1127 fseek(expfp, exppos[curfrm=n-1], 0) == EOF) {
1128 fprintf(stderr, "%s: seek error on exposure file\n", progname);
1129 quit(1);
1130 }
1131 while (n > curfrm) { /* read exposure */
1132 if (exppos[curfrm] < 0)
1133 exppos[curfrm] = ftell(expfp);
1134 if (fgets(expval, sizeof(expval), expfp) == NULL) {
1135 fprintf(stderr, "%s: too few exposures\n",
1136 vval(EXPOSURE));
1137 quit(1);
1138 }
1139 curfrm++;
1140 cp = fskip(expval); /* check format */
1141 if (cp != NULL)
1142 while (isspace(*cp))
1143 *cp++ = '\0';
1144 if (cp == NULL || *cp) {
1145 fprintf(stderr,
1146 "%s: exposure format error on line %d\n",
1147 vval(EXPOSURE), curfrm);
1148 quit(1);
1149 }
1150 }
1151 return(expval); /* return value */
1152 }
1153
1154
1155 struct pslot *
1156 findpslot(pid) /* find or allocate a process slot */
1157 int pid;
1158 {
1159 register struct pslot *psempty = NULL;
1160 register int i;
1161
1162 for (i = 0; i < npslots; i++) { /* look for match */
1163 if (pslot[i].pid == pid)
1164 return(pslot+i);
1165 if (psempty == NULL && pslot[i].pid == 0)
1166 psempty = pslot+i;
1167 }
1168 return(psempty); /* return emtpy slot (error if NULL) */
1169 }
1170
1171
1172 int
1173 donecom(ps, pn, status) /* clean up after finished process */
1174 PSERVER *ps;
1175 int pn;
1176 int status;
1177 {
1178 register PROC *pp;
1179 register struct pslot *psl;
1180
1181 pp = ps->proc + pn;
1182 if (pp->elen) { /* pass errors */
1183 if (ps->hostname[0])
1184 fprintf(stderr, "%s: ", ps->hostname);
1185 fprintf(stderr, "Error output from: %s\n", pp->com);
1186 fputs(pp->errs, stderr);
1187 fflush(stderr);
1188 if (ps->hostname[0])
1189 status = 1; /* because rsh doesn't return status */
1190 }
1191 lastpserver = NULL;
1192 psl = findpslot(pp->pid); /* check for bruncom() slot */
1193 if (psl->pid) {
1194 if (status) {
1195 if (psl->rcvf != NULL) /* attempt recovery */
1196 status = (*psl->rcvf)(psl->fout);
1197 if (status) {
1198 fprintf(stderr,
1199 "%s: error rendering frame %d\n",
1200 progname, psl->fout);
1201 quit(1);
1202 }
1203 lastpserver = ps;
1204 }
1205 psl->pid = 0; /* free process slot */
1206 } else if (status)
1207 lastpserver = ps;
1208 freestr(pp->com); /* free command string */
1209 return(status);
1210 }
1211
1212
1213 int
1214 serverdown() /* check status of last process server */
1215 {
1216 if (lastpserver == NULL || !lastpserver->hostname[0])
1217 return(0);
1218 if (pserverOK(lastpserver)) /* server still up? */
1219 return(0);
1220 delpserver(lastpserver); /* else delete it */
1221 if (pslist == NULL) {
1222 fprintf(stderr, "%s: all process servers are down\n",
1223 progname);
1224 quit(1);
1225 }
1226 return(1);
1227 }
1228
1229
1230 int
1231 bruncom(com, fout, rf) /* run a command in the background */
1232 char *com;
1233 int fout;
1234 int (*rf)();
1235 {
1236 int pid;
1237 register struct pslot *psl;
1238
1239 if (noaction) {
1240 if (!silent)
1241 printf("\t%s\n", com); /* echo command */
1242 return(0);
1243 }
1244 com = savestr(com); /* else start it when we can */
1245 while ((pid = startjob(NULL, com, donecom)) == -1)
1246 bwait(1);
1247 if (!silent) { /* echo command */
1248 PSERVER *ps;
1249 int psn = pid;
1250 ps = findjob(&psn);
1251 printf("\t%s\n", com);
1252 printf("\tProcess started on %s\n", phostname(ps));
1253 fflush(stdout);
1254 }
1255 psl = findpslot(pid); /* record info. in appropriate slot */
1256 psl->pid = pid;
1257 psl->fout = fout;
1258 psl->rcvf = rf;
1259 return(pid);
1260 }
1261
1262
1263 bwait(ncoms) /* wait for batch job(s) to finish */
1264 int ncoms;
1265 {
1266 int status;
1267
1268 if (noaction)
1269 return;
1270 while ((status = wait4job(NULL, -1)) != -1) {
1271 serverdown(); /* update server status */
1272 if (--ncoms == 0)
1273 break; /* done enough */
1274 }
1275 }
1276
1277
1278 int
1279 pruncom(com, ppins, maxcopies) /* run a command in parallel over network */
1280 char *com, *ppins;
1281 int maxcopies;
1282 {
1283 int retstatus = 0;
1284 int hostcopies;
1285 char buf[10240], *com1, *s;
1286 int status;
1287 int pfd;
1288 register int n;
1289 register PSERVER *ps;
1290
1291 if (!silent)
1292 printf("\t%s\n", com); /* echo command */
1293 if (noaction)
1294 return(0);
1295 fflush(stdout);
1296 /* start jobs on each server */
1297 for (ps = pslist; ps != NULL; ps = ps->next) {
1298 hostcopies = 0;
1299 if (maxcopies > 1 && ps->nprocs > 1 && ppins != NULL) {
1300 strcpy(com1=buf, com); /* build -PP command */
1301 sprintf(com1+(ppins-com), " -PP %s/%s.persist",
1302 vval(DIRECTORY), phostname(ps));
1303 strcat(com1, ppins);
1304 } else
1305 com1 = com;
1306 while (maxcopies > 0) {
1307 s = savestr(com1);
1308 if (startjob(ps, s, donecom) != -1) {
1309 sleep(20);
1310 hostcopies++;
1311 maxcopies--;
1312 } else {
1313 freestr(s);
1314 break;
1315 }
1316 }
1317 if (!silent && hostcopies) {
1318 if (hostcopies > 1)
1319 printf("\t%d duplicate processes", hostcopies);
1320 else
1321 printf("\tProcess");
1322 printf(" started on %s\n", phostname(ps));
1323 fflush(stdout);
1324 }
1325 }
1326 /* wait for jobs to finish */
1327 while ((status = wait4job(NULL, -1)) != -1)
1328 retstatus += status && !serverdown();
1329 /* terminate parallel rpict's */
1330 for (ps = pslist; ps != NULL; ps = ps->next) {
1331 sprintf(buf, "%s/%s.persist", vval(DIRECTORY), phostname(ps));
1332 if ((pfd = open(buf, O_RDONLY)) >= 0) {
1333 n = read(pfd, buf, sizeof(buf)-1); /* get PID */
1334 buf[n] = '\0';
1335 close(pfd);
1336 for (n = 0; buf[n] && !isspace(buf[n]); n++)
1337 ;
1338 /* terminate */
1339 sprintf(buf, "kill -ALRM %d", atoi(buf+n));
1340 wait4job(ps, startjob(ps, buf, NULL));
1341 }
1342 }
1343 return(retstatus);
1344 }
1345
1346
1347 runcom(cs) /* run a command locally and wait for it */
1348 char *cs;
1349 {
1350 if (!silent) /* echo it */
1351 printf("\t%s\n", cs);
1352 if (noaction)
1353 return(0);
1354 fflush(stdout); /* flush output and pass to shell */
1355 return(system(cs));
1356 }
1357
1358
1359 rmfile(fn) /* remove a file */
1360 char *fn;
1361 {
1362 if (!silent)
1363 #ifdef MSDOS
1364 printf("\tdel %s\n", fn);
1365 #else
1366 printf("\trm -f %s\n", fn);
1367 #endif
1368 if (noaction)
1369 return(0);
1370 return(unlink(fn));
1371 }
1372
1373
1374 badvalue(vc) /* report bad variable value and exit */
1375 int vc;
1376 {
1377 fprintf(stderr, "%s: bad value for variable '%s'\n",
1378 progname, vnam(vc));
1379 quit(1);
1380 }
1381
1382
1383 char *
1384 dirfile(df, path) /* separate path into directory and file */
1385 char *df;
1386 register char *path;
1387 {
1388 register int i;
1389 int psep;
1390
1391 for (i = 0, psep = -1; path[i]; i++)
1392 if (path[i] == '/')
1393 psep = i;
1394 if (df != NULL)
1395 if (psep == 0) {
1396 df[0] = '/';
1397 df[1] = '\0';
1398 } else if (psep > 0) {
1399 strncpy(df, path, psep);
1400 df[psep] = '\0';
1401 } else
1402 df[0] = '\0';
1403 return(path+psep+1);
1404 }
1405
1406
1407 int
1408 getblur(double *bf) /* get # blur samples (and fraction) */
1409 {
1410 double blurf;
1411 int nblur;
1412 char *s;
1413
1414 if (!vdef(MBLUR)) {
1415 if (bf != NULL)
1416 *bf = 0.0;
1417 return(0);
1418 }
1419 blurf = atof(vval(MBLUR));
1420 if (blurf < 0.0)
1421 blurf = 0.0;
1422 if (bf != NULL)
1423 *bf = blurf;
1424 if (blurf <= FTINY)
1425 return(0);
1426 s = sskip(vval(MBLUR));
1427 if (!*s)
1428 return(DEF_NBLUR);
1429 nblur = atoi(s);
1430 if (nblur <= 0)
1431 return(1);
1432 return(nblur);
1433 }