ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/ranimate.c
(Generate patch)

Comparing ray/src/util/ranimate.c (file contents):
Revision 2.1 by greg, Fri Jan 12 12:16:17 1996 UTC vs.
Revision 2.11 by greg, Tue Apr 16 10:38:19 1996 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1995 Regents of the University of California */
1 > /* Copyright (c) 1996 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 9 | Line 9 | static char SCCSid[] = "$SunId$ LBL";
9   */
10  
11   #include "standard.h"
12 + #include <ctype.h>
13   #include <sys/types.h>
14   #include <sys/stat.h>
15   #include "view.h"
16   #include "vars.h"
17 + #include "netproc.h"
18 +                                /* default remote shell */
19 + #ifdef _AUX_SOURCE
20 + #define REMSH           "remsh"
21 + #else
22 + #define REMSH           "rsh"
23 + #endif
24                                  /* input variables */
25   #define HOST            0               /* rendering host machine */
26   #define RENDER          1               /* rendering options */
# Line 36 | Line 44 | static char SCCSid[] = "$SunId$ LBL";
44   #define DISKSPACE       19              /* how much disk space to use */
45   #define RESOLUTION      20              /* desired final resolution */
46   #define EXPOSURE        21              /* how to compute exposure */
47 + #define RSH             22              /* remote shell script or program */
48  
49 < int     NVARS = 22;             /* total number of variables */
49 > int     NVARS = 23;             /* total number of variables */
50  
51   VARIABLE        vv[] = {                /* variable-value pairs */
52          {"host",        4,      0,      NULL,   NULL},
# Line 55 | Line 64 | VARIABLE       vv[] = {                /* variable-value pairs */
64          {"ANIMATE",     2,      0,      NULL,   onevalue},
65          {"TRANSFER",    2,      0,      NULL,   onevalue},
66          {"ARCHIVE",     2,      0,      NULL,   onevalue},
67 <        {"INTERP",      3,      0,      NULL,   intvalue},
68 <        {"OVERSAMP",    2,      0,      NULL,   fltvalue},
67 >        {"INTERPOLATE", 3,      0,      NULL,   intvalue},
68 >        {"OVERSAMPLE",  2,      0,      NULL,   fltvalue},
69          {"MBLUR",       2,      0,      NULL,   onevalue},
70          {"RTRACE",      2,      0,      NULL,   boolvalue},
71          {"DISKSPACE",   3,      0,      NULL,   fltvalue},
72          {"RESOLUTION",  3,      0,      NULL,   onevalue},
73          {"EXPOSURE",    3,      0,      NULL,   onevalue},
74 +        {"RSH",         3,      0,      NULL,   onevalue},
75   };
76  
77   #define SFNAME  "STATUS"                /* status file name */
# Line 82 | Line 92 | int    nowarn = 0;             /* turn warnings off? */
92   int     silent = 0;             /* silent mode? */
93   int     noaction = 0;           /* take no action? */
94  
95 + char    *remsh;                 /* remote shell program/script */
96   char    rendopt[2048] = "";     /* rendering options */
97   char    rresopt[32];            /* rendering resolution options */
98   char    fresopt[32];            /* filter resolution options */
99   int     pfiltalways;            /* always use pfilt? */
100  
101 + char    arcargs[10240];         /* files to archive */
102 + char    *arcfirst, *arcnext;    /* pointers to first and next argument */
103 +
104 + struct pslot {
105 +        int     pid;                    /* process ID (0 if empty) */
106 +        int     fout;                   /* output frame number */
107 +        int     (*rcvf)();              /* recover function */
108 + }       *pslot;                 /* process slots */
109 + int     npslots;                /* number of process slots */
110 +
111 + int     lastpid;                /* ID of last completed background process */
112 + PSERVER *lastpserver;           /* last process server used */
113 +
114 + #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
115 +
116 + struct pslot    *findpslot();
117 +
118   VIEW    *getview();
119   char    *getexp();
120  
# Line 138 | Line 166 | char   *argv[];
166                                                  /* print variables */
167          if (explicate)
168                  printvars(stdout);
169 +                                                /* set up process servers */
170 +        sethosts();
171                                                  /* run animation */
172          animate();
173                                                  /* all done */
# Line 145 | Line 175 | char   *argv[];
175                  argv[i] = vval(NEXTANIM);       /* just change input file */
176                  if (!silent)
177                          printargs(argc, argv, stdout);
178 <                if (!noaction) {
179 <                        execvp(progname, argv);         /* pass to next */
180 <                        quit(1);                        /* shouldn't return */
181 <                }
178 >                if ((argv[0] = getpath(progname,getenv("PATH"),X_OK)) == NULL)
179 >                        fprintf(stderr, "%s: command not found\n", progname);
180 >                else
181 >                        execv(progname, argv);
182 >                quit(1);
183          }
184          quit(0);
185   userr:
# Line 185 | Line 216 | getastat()                     /* check/set animation status */
216                  goto fmterr;
217          fclose(fp);
218          if (astat.pid != 0) {                   /* thinks it's still running */
219 <                gethostname(buf, sizeof(buf));
189 <                if (strcmp(buf, astat.host)) {
219 >                if (strcmp(myhostname(), astat.host)) {
220                          fprintf(stderr,
221                          "%s: process %d may still be running on host %s\n",
222                                          progname, astat.pid, astat.host);
# Line 205 | Line 235 | getastat()                     /* check/set animation status */
235                  return(-1);
236          }
237   setours:                                        /* set our values */
238 <        gethostname(astat.host, sizeof(astat.host));
238 >        strcpy(astat.host, myhostname());
239          astat.pid = getpid();
240          strcpy(astat.cfname, cfname);
241          return(0);
# Line 222 | Line 252 | putastat()                     /* put out current status */
252          char    buf[256];
253          FILE    *fp;
254  
255 +        if (noaction)
256 +                return;
257          sprintf(buf, "%s/%s", vval(DIRECTORY), SFNAME);
258          if ((fp = fopen(buf, "w")) == NULL) {
259                  perror(buf);
# Line 261 | Line 293 | checkdir()                     /* make sure we have our directory */
293  
294   setdefaults()                   /* set default values */
295   {
296 +        extern char     *atos();
297          char    buf[256];
298  
299 <        if (vdef(OCTREE) == vdef(ANIMATE)) {
299 >        if (vdef(ANIMATE)) {
300 >                vval(OCTREE) = NULL;
301 >                vdef(OCTREE) = 0;
302 >        } else if (!vdef(OCTREE)) {
303                  fprintf(stderr, "%s: either %s or %s must be defined\n",
304                                  progname, vnam(OCTREE), vnam(ANIMATE));
305                  quit(1);
# Line 272 | Line 308 | setdefaults()                  /* set default values */
308                  fprintf(stderr, "%s: %s undefined\n", progname, vnam(VIEWFILE));
309                  quit(1);
310          }
311 +        if (!vdef(HOST)) {
312 +                vval(HOST) = LHOSTNAME;
313 +                vdef(HOST)++;
314 +        }
315          if (!vdef(START)) {
316                  vval(START) = "1";
317                  vdef(START)++;
318          }
319          if (!vdef(END)) {
320 <                sprintf(buf, "%d", countviews());
320 >                sprintf(buf, "%d", countviews()+vint(START)-1);
321                  vval(END) = savqstr(buf);
322                  vdef(END)++;
323          }
324 +        if (vint(END) < vint(START)) {
325 +                fprintf(stderr, "%s: ending frame less than starting frame\n",
326 +                                progname);
327 +                quit(1);
328 +        }
329          if (!vdef(BASENAME)) {
330                  sprintf(buf, "%s/frame%%03d", vval(DIRECTORY));
331                  vval(BASENAME) = savqstr(buf);
# Line 314 | Line 359 | setdefaults()                  /* set default values */
359                  vval(DISKSPACE) = "100";
360                  vdef(DISKSPACE)++;
361          }
362 +        if (!vdef(RSH)) {
363 +                vval(RSH) = REMSH;
364 +                vdef(RSH)++;
365 +        }
366 +                                /* locate remote shell program */
367 +        atos(buf, sizeof(buf), vval(RSH));
368 +        if ((remsh = getpath(buf, getenv("PATH"), X_OK)) != NULL)
369 +                remsh = savqstr(remsh);
370 +        else
371 +                remsh = vval(RSH);      /* will generate error if used */
372 +
373                                  /* append rendering options */
374          if (vdef(RENDER))
375                  sprintf(rendopt+strlen(rendopt), " %s", vval(RENDER));
376   }
377  
378  
379 < getradfile(rfname)              /* run rad and get needed variables */
324 < char    *rfname;
379 > sethosts()                      /* set up process servers */
380   {
381 +        extern char     *iskip();
382 +        char    buf[256], *dir, *uname;
383 +        int     np;
384 +        register char   *cp;
385 +        int     i;
386 +
387 +        npslots = 0;
388 +        if (noaction)
389 +                return;
390 +        for (i = 0; i < vdef(HOST); i++) {      /* add each host */
391 +                dir = uname = NULL;
392 +                np = 1;
393 +                strcpy(cp=buf, nvalue(HOST, i));        /* copy to buffer */
394 +                cp = sskip(cp);                         /* skip host name */
395 +                while (isspace(*cp))
396 +                        *cp++ = '\0';
397 +                if (*cp) {                              /* has # processes? */
398 +                        np = atoi(cp);
399 +                        if ((cp = iskip(cp)) == NULL || (*cp && !isspace(*cp)))
400 +                                badvalue(HOST);
401 +                        while (isspace(*cp))
402 +                                cp++;
403 +                        if (*cp) {                      /* has directory? */
404 +                                dir = cp;
405 +                                cp = sskip(cp);                 /* skip dir. */
406 +                                while (isspace(*cp))
407 +                                        *cp++ = '\0';
408 +                                if (*cp) {                      /* has user? */
409 +                                        uname = cp;
410 +                                        if (*sskip(cp))
411 +                                                badvalue(HOST);
412 +                                }
413 +                        }
414 +                }
415 +                if (addpserver(buf, dir, uname, np) == NULL) {
416 +                        if (!nowarn)
417 +                                fprintf(stderr,
418 +                                        "%s: cannot execute on host \"%s\"\n",
419 +                                                progname, buf);
420 +                } else
421 +                        npslots += np;
422 +        }
423 +        if (npslots == 0) {
424 +                fprintf(stderr, "%s: no working process servers\n", progname);
425 +                quit(1);
426 +        }
427 +        pslot = (struct pslot *)calloc(npslots, sizeof(struct pslot));
428 +        if (pslot == NULL) {
429 +                perror("malloc");
430 +                quit(1);
431 +        }
432 + }
433 +
434 +
435 + getradfile(rfargs)              /* run rad and get needed variables */
436 + char    *rfargs;
437 + {
438          static short    mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
439          char    combuf[256];
440          register int    i;
# Line 331 | Line 443 | char   *rfname;
443          sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
444          sprintf(combuf,
445          "rad -v 0 -s -e -w %s OPTFILE=%s | egrep '^[ \t]*(NOMATCH",
446 <                        rfname, rendopt+2);
446 >                        rfargs, rendopt+2);
447          cp = combuf;
448          while (*cp) cp++;               /* match unset variables */
449          for (i = 0; mvar[i] >= 0; i++)
# Line 343 | Line 455 | char   *rfname;
455          sprintf(cp, ")[ \t]*=' > %s/radset.var", vval(DIRECTORY));
456          cp += 11;                       /* point to file name */
457          if (system(combuf)) {
458 <                fprintf(stderr, "%s: bad rad input file \"%s\"\n",
459 <                                progname, rfname);
458 >                fprintf(stderr, "%s: error executing rad command:\n\t%s\n",
459 >                                progname, combuf);
460                  quit(1);
461          }
462          loadvars(cp);                   /* load variables and remove file */
# Line 401 | Line 513 | animate()                      /* run animation */
513                                  progname);
514                  quit(1);
515          }
516 +                                        /* initialize archive argument list */
517 +        i = 16;
518 +        if (vdef(ARCHIVE) && strlen(vval(ARCHIVE)) > i)
519 +                i = strlen(vval(ARCHIVE));
520 +        arcnext = arcfirst = arcargs + i;
521                                          /* initialize status file */
522          if (astat.rnext == 0)
523                  astat.rnext = astat.fnext = astat.tnext = vint(START);
524          putastat();
525                                          /* render in batches */
526 <        while (astat.rnext <= vint(END)) {
526 >        while (astat.tnext <= vint(END)) {
527                  renderframes(frames_batch);
528                  filterframes();
529                  transferframes();
# Line 466 | Line 583 | int    nframes;
583                  }
584          }
585          if (vdef(ANIMATE))              /* wait for renderings to finish */
586 <                animwait(0);
586 >                bwait(0);
587          else {                          /* else if walk-through */
588                  fclose(fp);             /* close view file */
589                  walkwait(astat.rnext, lastframe, vfname);       /* walk it */
590                  unlink(vfname);         /* remove view file */
591          }
475 –        if (vdef(ARCHIVE))              /* archive results */
476 –                archive(astat.rnext, lastframe);
592          astat.rnext = i;                /* update status */
593          putastat();
594   }
# Line 494 | Line 609 | filterframes()                         /* catch up with filtering */
609                                          progname, i);
610                          quit(1);
611                  }
612 <                dofilt(i, vp, getexp(i));               /* filter frame */
612 >                dofilt(i, vp, getexp(i), 0);            /* filter frame */
613          }
614 <        filtwait(0);                    /* wait for filter processes */
614 >        bwait(0);                       /* wait for filter processes */
615 >        archive();                      /* archive originals */
616          astat.fnext = i;                /* update status */
617          putastat();
618   }
# Line 539 | Line 655 | animrend(frame, vp)                    /* start animation frame */
655   int     frame;
656   VIEW    *vp;
657   {
658 +        extern int      recover();
659          char    combuf[2048];
660          char    fname[128];
661  
# Line 546 | Line 663 | VIEW   *vp;
663          strcat(fname, ".unf");
664          if (access(fname, F_OK) == 0)
665                  return;
666 <        sprintf(combuf, "%s %d | rpict%s%s %s > %s", vval(ANIMATE), frame,
666 >        sprintf(combuf, "%s %d | rpict%s%s -w0 %s > %s", vval(ANIMATE), frame,
667                          rendopt, viewopt(vp), rresopt, fname);
668 <        if (runcom(combuf)) {
552 <                fprintf(stderr, "%s: error rendering frame %d\n",
553 <                                progname, frame);
554 <                quit(1);
555 <        }
668 >        bruncom(combuf, frame, recover);        /* run in background */
669   }
670  
671  
559 – animwait(nwait)                         /* wait for renderings to finish */
560 – int     nwait;
561 – {
562 –        /* currently does nothing since parallel rendering not working */
563 – }
564 –
565 –
672   walkwait(first, last, vfn)              /* walk-through frames */
673   int     first, last;
674   char    *vfn;
675   {
676          char    combuf[2048];
677 +        char    *inspoint;
678          register int    i;
679  
680          if (!noaction && vint(INTERP))          /* create dummy frames */
# Line 578 | Line 685 | char   *vfn;
685                                  close(open(combuf, O_RDONLY|O_CREAT, 0666));
686                          }
687                                          /* create command */
688 <        sprintf(combuf, "rpict%s ", rendopt);
688 >        sprintf(combuf, "rpict%s -w0", rendopt);
689          if (vint(INTERP) || atoi(vval(MBLUR)))
690 <                sprintf(combuf+strlen(combuf), "-z %s.zbf ", vval(BASENAME));
691 <        sprintf(combuf+strlen(combuf), "-o %s.unf %s -S %d %s < %s",
692 <                        vval(BASENAME), rresopt, first, vval(OCTREE), vfn);
693 <        if (runcom(combuf)) {
694 <                fprintf(stderr,
695 <                "%s: error rendering walk-through frames %d through %d\n",
690 >                sprintf(combuf+strlen(combuf), " -z %s.zbf", vval(BASENAME));
691 >        sprintf(combuf+strlen(combuf), " -o %s.unf %s -S %d",
692 >                        vval(BASENAME), rresopt, first);
693 >        inspoint = combuf + strlen(combuf);
694 >        sprintf(inspoint, " %s < %s", vval(OCTREE), vfn);
695 >                                        /* run in parallel */
696 >        i = (last-first+1)/(vint(INTERP)+1);
697 >        if (i < 1) i = 1;
698 >        if (pruncom(combuf, inspoint, i)) {
699 >                fprintf(stderr, "%s: error rendering frames %d through %d\n",
700                                  progname, first, last);
701                  quit(1);
702          }
# Line 599 | Line 710 | char   *vfn;
710   }
711  
712  
713 + int
714   recover(frame)                          /* recover the specified frame */
715   int     frame;
716   {
717 +        static int      *rfrm;          /* list of recovered frames */
718 +        static int      nrfrms = 0;
719          char    combuf[2048];
720          char    fname[128];
721          register char   *cp;
722 <
722 >        register int    i;
723 >                                        /* check to see if recovered already */
724 >        for (i = nrfrms; i--; )
725 >                if (rfrm[i] == frame)
726 >                        return(0);
727 >                                        /* build command */
728          sprintf(fname, vval(BASENAME), frame);
729          if (vdef(ANIMATE))
730 <                sprintf(combuf, "%s %d | rpict%s",
730 >                sprintf(combuf, "%s %d | rpict%s -w0",
731                                  vval(ANIMATE), frame, rendopt);
732          else
733 <                sprintf(combuf, "rpict%s", rendopt);
733 >                sprintf(combuf, "rpict%s -w0", rendopt);
734          cp = combuf + strlen(combuf);
735          if (vint(INTERP) || atoi(vval(MBLUR))) {
736                  sprintf(cp, " -z %s.zbf", fname);
# Line 623 | Line 742 | int    frame;
742                  *cp++ = ' ';
743                  strcpy(cp, vval(OCTREE));
744          }
745 <        if (runcom(combuf)) {
746 <                fprintf(stderr, "%s: error recovering frame %d\n",
747 <                                progname, frame);
745 >        if (runcom(combuf))             /* run command */
746 >                return(1);
747 >                                        /* add frame to recovered list */
748 >        if (nrfrms)
749 >                rfrm = (int *)realloc((char *)rfrm, (nrfrms+1)*sizeof(int));
750 >        else
751 >                rfrm = (int *)malloc(sizeof(int));
752 >        if (rfrm == NULL) {
753 >                perror("malloc");
754                  quit(1);
755          }
756 +        rfrm[nrfrms++] = frame;
757 +        return(0);
758   }
759  
760  
761 < archive(first, last)                    /* archive finished renderings */
762 < int     first, last;
761 > int
762 > frecover(frame)                         /* recover filtered frame */
763 > int     frame;
764   {
765 <        char    combuf[10240];
766 <        int     offset;
767 <        struct stat     stb;
768 <        register char   *cp;
765 >        VIEW    *vp;
766 >        char    *ex;
767 >
768 >        vp = getview(frame);
769 >        ex = getexp(frame);
770 >        if (dofilt(frame, vp, ex, 2) && dofilt(frame, vp, ex, 1))
771 >                return(1);
772 >        return(0);
773 > }
774 >
775 >
776 > archive()                       /* archive and remove renderings */
777 > {
778 > #define RMCOML  (sizeof(rmcom)-1)
779 >        static char     rmcom[] = "rm -f";
780          register int    i;
781  
782 <        strcpy(cp=combuf, vval(ARCHIVE));
783 <        while (*cp) cp++;
784 <        offset = cp - combuf;
785 <        *cp++ = ' ';                            /* make argument list */
786 <        for (i = first; i <= last; i++) {
787 <                sprintf(cp, vval(BASENAME), i);
788 <                strcat(cp, ".unf");
789 <                if (stat(cp, &stb) == 0 && stb.st_size > 0) {   /* non-zero? */
790 <                        while (*cp) cp++;
652 <                        *cp++ = ' ';
653 <                        sprintf(cp, vval(BASENAME), i);
654 <                        strcat(cp, ".zbf");
655 <                        if (access(cp, F_OK) == 0) {            /* exists? */
656 <                                while (*cp) cp++;
657 <                                *cp++ = ' ';
658 <                        }
782 >        if (arcnext == arcfirst)
783 >                return;                         /* nothing to do */
784 >        if (vdef(ARCHIVE)) {                    /* run archive command */
785 >                i = strlen(vval(ARCHIVE));
786 >                strncpy(arcfirst-i, vval(ARCHIVE), i);
787 >                if (runcom(arcfirst-i)) {
788 >                        fprintf(stderr, "%s: error running archive command\n",
789 >                                        progname);
790 >                        quit(1);
791                  }
792          }
793 <        *--cp = '\0';
794 <        if (cp <= combuf + offset)              /* no files? */
795 <                return;
796 <        if (runcom(combuf)) {                   /* run archive command */
797 <                fprintf(stderr,
666 <                "%s: error running archive command on frames %d through %d\n",
667 <                                progname, first, last);
668 <                quit(1);
669 <        }
793 >                                                /* run remove command */
794 >        strncpy(arcfirst-RMCOML, rmcom, RMCOML);
795 >        runcom(arcfirst-RMCOML);
796 >        arcnext = arcfirst;                     /* reset argument list */
797 > #undef RMCOML
798   }
799  
800  
801 < dofilt(frame, vp, ep)                           /* filter frame */
801 > int
802 > dofilt(frame, vp, ep, rvr)                      /* filter frame */
803   int     frame;
804   VIEW    *vp;
805   char    *ep;
806 + int     rvr;
807   {
808 +        extern int      frecover();
809 +        static int      iter = 0;
810          char    fnbefore[128], fnafter[128];
811 <        char    combuf[1024], fname[128];
812 <        int     usepinterp, usepfilt;
813 <        int     frbefore, frafter, triesleft;
811 >        char    combuf[1024], fname0[128], fname1[128];
812 >        int     usepinterp, usepfilt, nora_rgbe;
813 >        int     frseq[2];
814                                                  /* check what is needed */
815          usepinterp = atoi(vval(MBLUR));
816          usepfilt = pfiltalways | ep==NULL;
817 +        if (ep != NULL && !strcmp(ep, "1"))
818 +                ep = "+0";
819 +        nora_rgbe = strcmp(vval(OVERSAMP),"1") || ep==NULL ||
820 +                        *ep != '+' || *ep != '-' || !isint(ep);
821                                                  /* compute rendered views */
822 <        frbefore = frame - ((frame-1) % (vint(INTERP)+1));
823 <        frafter = frbefore + vint(INTERP) + 1;
824 <        if (frafter > vint(END))
825 <                frafter = vint(END);
826 <        if (frafter == frame) {                 /* pfilt only */
827 <                frbefore = frafter;
822 >        frseq[0] = frame - ((frame-1) % (vint(INTERP)+1));
823 >        frseq[1] = frseq[0] + vint(INTERP) + 1;
824 >        if (frseq[1] > vint(END))
825 >                frseq[1] = vint(END);
826 >        if (frseq[1] == frame) {                        /* pfilt only */
827 >                frseq[0] = frseq[1];
828                  usepinterp = 0;                 /* update what's needed */
829 <                usepfilt |= vflt(OVERSAMP)>1.01 || strcmp(ep,"1");
830 <                triesleft = 2;
831 <        } else if (frbefore == frame) {         /* no interpolation */
832 <                                                /* remove unneeded files */
833 <                if (frbefore-vint(INTERP)-1 >= 1) {
834 <                        sprintf(fname, vval(BASENAME), frbefore-vint(INTERP)-1);
835 <                        sprintf(combuf, "rm -f %s.unf %s.zbf", fname, fname);
836 <                        runcom(combuf);
829 >                usepfilt |= nora_rgbe;
830 >        } else if (frseq[0] == frame) {         /* no interpolation needed */
831 >                if (!rvr && frame > 1+vint(INTERP)) {   /* archive previous */
832 >                        *arcnext++ = ' ';
833 >                        sprintf(arcnext, vval(BASENAME), frame-vint(INTERP)-1);
834 >                        while (*arcnext) arcnext++;
835 >                        strcpy(arcnext, ".unf");
836 >                        arcnext += 4;
837 >                        if (usepinterp || vint(INTERP)) {       /* and z-buf */
838 >                                *arcnext++ = ' ';
839 >                                sprintf(arcnext, vval(BASENAME),
840 >                                                frame-vint(INTERP)-1);
841 >                                while (*arcnext) arcnext++;
842 >                                strcpy(arcnext, ".zbf");
843 >                                arcnext += 4;
844 >                        }
845                  }
846 <                                                /* update what's needed */
847 <                if (usepinterp)
848 <                        triesleft = 3;
705 <                else {
706 <                        usepfilt |= vflt(OVERSAMP)>1.01 || strcmp(ep,"1");
707 <                        triesleft = 2;
708 <                }
709 <        } else {                                /* interpolation needed */
846 >                if (!usepinterp)                /* update what's needed */
847 >                        usepfilt |= nora_rgbe;
848 >        } else                                  /* interpolation needed */
849                  usepinterp++;
850 <                triesleft = 3;
851 <        }
852 <        if (frafter >= astat.rnext) {           /* next batch unavailable */
853 <                frafter = frbefore;
854 <                if (triesleft > 2)
855 <                        triesleft = 2;
856 <        }
718 <        sprintf(fnbefore, vval(BASENAME), frbefore);
719 <        sprintf(fnafter, vval(BASENAME), frafter);
720 < tryit:                                          /* generate command */
850 >        if (frseq[1] >= astat.rnext)            /* next batch unavailable */
851 >                frseq[1] = frseq[0];
852 >        sprintf(fnbefore, vval(BASENAME), frseq[0]);
853 >        sprintf(fnafter, vval(BASENAME), frseq[1]);
854 >        if (rvr == 1 && recover(frseq[0]))      /* recover before frame? */
855 >                return(1);
856 >                                                /* generate command */
857          if (usepinterp) {                       /* using pinterp */
858 +                if (rvr == 2 && recover(frseq[1]))      /* recover after? */
859 +                        return(1);
860                  if (atoi(vval(MBLUR))) {
861                          FILE    *fp;            /* motion blurring */
862 <                        sprintf(fname, "%s/vw0", vval(DIRECTORY));
863 <                        if ((fp = fopen(fname, "w")) == NULL) {
864 <                                perror(fname); quit(1);
862 >                        sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
863 >                                        'a'+(iter%26));
864 >                        if ((fp = fopen(fname0, "w")) == NULL) {
865 >                                perror(fname0); quit(1);
866                          }
867                          fputs(VIEWSTR, fp);
868                          fprintview(vp, fp);
# Line 734 | Line 873 | tryit:                                         /* generate command */
873                                                  progname, frame+1);
874                                  quit(1);
875                          }
876 <                        sprintf(fname, "%s/vw1", vval(DIRECTORY));
877 <                        if ((fp = fopen(fname, "w")) == NULL) {
878 <                                perror(fname); quit(1);
876 >                        sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
877 >                                        'a'+(iter%26));
878 >                        if ((fp = fopen(fname1, "w")) == NULL) {
879 >                                perror(fname1); quit(1);
880                          }
881                          fputs(VIEWSTR, fp);
882                          fprintview(vp, fp);
883                          putc('\n', fp); fclose(fp);
884                          sprintf(combuf,
885 <        "(pmblur %s %d %s/vw0 %s/vw1; rm -f %s/vw0 %s/vw1) | pinterp -B",
886 <                                *sskip(vval(MBLUR)) ? sskip(vval(MBLUR)) : "1",
887 <                                        atoi(vval(MBLUR)), vval(DIRECTORY),
888 <                                        vval(DIRECTORY), vval(DIRECTORY),
889 <                                        vval(DIRECTORY), vval(DIRECTORY));
885 >                        "(pmblur %s %d %s %s; rm -f %s %s) | pinterp -B",
886 >                        *sskip(vval(MBLUR)) ? sskip2(vval(MBLUR),1) : "1",
887 >                                        atoi(vval(MBLUR)),
888 >                                        fname0, fname1, fname0, fname1);
889 >                        iter++;
890                  } else                          /* no blurring */
891                          strcpy(combuf, "pinterp");
892                  strcat(combuf, viewopt(vp));
893                  if (vbool(RTRACE))
894 <                        sprintf(combuf+strlen(combuf), " -ff -fr '%s %s'",
894 >                        sprintf(combuf+strlen(combuf), " -ff -fr '%s -w0 %s'",
895                                          rendopt, vval(OCTREE));
896                  if (vdef(PINTERP))
897                          sprintf(combuf+strlen(combuf), " %s", vval(PINTERP));
# Line 762 | Line 902 | tryit:                                         /* generate command */
902                                          fresopt, ep);
903                  sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
904                                  fnbefore, fnbefore);
905 <                if (frafter != frbefore)
905 >                if (frseq[1] != frseq[0])
906                           sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
907                                          fnafter, fnafter);
908                  if (usepfilt) {                 /* also pfilt */
# Line 778 | Line 918 | tryit:                                         /* generate command */
918                                  sprintf(combuf+strlen(combuf), " %s", fresopt);
919                  }
920          } else if (usepfilt) {                  /* pfilt only */
921 +                if (rvr == 2)
922 +                        return(1);
923                  if (vdef(PFILT))
924                          sprintf(combuf, "pfilt %s", vval(PFILT));
925                  else
# Line 789 | Line 931 | tryit:                                         /* generate command */
931                          sprintf(combuf+strlen(combuf), " %s %s.unf",
932                                          fresopt, fnbefore);
933          } else {                                /* else just check it */
934 <                sprintf(combuf, "ra_rgbe -r %s.unf", fnbefore);
934 >                if (rvr == 2)
935 >                        return(1);
936 >                sprintf(combuf, "ra_rgbe -e %s -r %s.unf", ep, fnbefore);
937          }
938                                                  /* output file name */
939 <        sprintf(fname, vval(BASENAME), frame);
940 <        sprintf(combuf+strlen(combuf), " > %s.pic", fname);
941 <        if (runcom(combuf))                     /* run filter command */
942 <                switch (--triesleft) {
943 <                case 2:                         /* try to recover frafter */
944 <                        recover(frafter);
801 <                        goto tryit;
802 <                case 1:                         /* try to recover frbefore */
803 <                        recover(frbefore);
804 <                        goto tryit;
805 <                default:                        /* we've really failed */
806 <                        fprintf(stderr,
807 <                        "%s: unrecoverable filtering error on frame %d\n",
808 <                                        progname, frame);
809 <                        quit(1);
810 <                }
939 >        sprintf(fname0, vval(BASENAME), frame);
940 >        sprintf(combuf+strlen(combuf), " > %s.pic", fname0);
941 >        if (rvr)                                /* in recovery */
942 >                return(runcom(combuf));
943 >        bruncom(combuf, frame, frecover);       /* else run in background */
944 >        return(0);
945   }
946  
947  
814 – filtwait(nwait)                 /* wait for filtering processes to finish */
815 – int     nwait;
816 – {
817 –        /* currently does nothing since parallel filtering not working */
818 – }
819 –
820 –
948   VIEW *
949   getview(n)                      /* get view number n */
950   int     n;
# Line 842 | Line 969 | int    n;
969                          quit(1);
970                  }
971          } else if (n < viewnum) {       /* rewind file */
972 +                if (viewnum == 1 && feof(viewfp))
973 +                        return(&curview);               /* just one view */
974                  if (fseek(viewfp, 0L, 0) == EOF) {
975                          perror(vval(VIEWFILE));
976                          quit(1);
# Line 851 | Line 980 | int    n;
980          }
981          while (n > viewnum) {           /* scan to desired view */
982                  if (fgets(linebuf, sizeof(linebuf), viewfp) == NULL)
983 <                        return(NULL);
983 >                        return(viewnum==1 ? &curview : NULL);
984                  if (isview(linebuf) && sscanview(&curview, linebuf) > 0)
985                          viewnum++;
986          }
# Line 937 | Line 1066 | int    n;
1066   }
1067  
1068  
1069 < runcom(cs)                      /* run command */
1069 > struct pslot *
1070 > findpslot(pid)                  /* find or allocate a process slot */
1071 > int     pid;
1072 > {
1073 >        register struct pslot   *psempty = NULL;
1074 >        register int    i;
1075 >
1076 >        for (i = 0; i < npslots; i++) {         /* look for match */
1077 >                if (pslot[i].pid == pid)
1078 >                        return(pslot+i);
1079 >                if (psempty == NULL && pslot[i].pid == 0)
1080 >                        psempty = pslot+i;
1081 >        }
1082 >        return(psempty);                /* return emtpy slot (error if NULL) */
1083 > }
1084 >
1085 >
1086 > int
1087 > donecom(ps, pn, status)         /* clean up after finished process */
1088 > PSERVER *ps;
1089 > int     pn;
1090 > int     status;
1091 > {
1092 >        register PROC   *pp;
1093 >
1094 >        pp = ps->proc + pn;
1095 >        if (pp->elen) {                 /* pass errors */
1096 >                if (ps->hostname[0])
1097 >                        fprintf(stderr, "%s: ", ps->hostname);
1098 >                fprintf(stderr, "Error output from: %s\n", pp->com);
1099 >                fputs(pp->errs, stderr);
1100 >                fflush(stderr);
1101 >                if (ps->hostname[0])
1102 >                        status = 1;     /* because rsh doesn't return status */
1103 >        }
1104 >        freestr(pp->com);               /* free command string */
1105 >        lastpid = pp->pid;              /* record PID for bwait() */
1106 >        lastpserver = ps;               /* record server for serverdown() */
1107 >        return(status);
1108 > }
1109 >
1110 >
1111 > int
1112 > serverdown()                    /* check status of last process server */
1113 > {
1114 >        if (pserverOK(lastpserver))     /* server still up? */
1115 >                return(0);
1116 >        delpserver(lastpserver);        /* else delete it */
1117 >        if (pslist == NULL) {
1118 >                fprintf(stderr, "%s: all process servers are down\n",
1119 >                                progname);
1120 >                quit(1);
1121 >        }
1122 >        return(1);
1123 > }
1124 >
1125 >
1126 > int
1127 > bruncom(com, fout, rf)          /* run a command in the background */
1128 > char    *com;
1129 > int     fout;
1130 > int     (*rf)();
1131 > {
1132 >        int     pid;
1133 >        register struct pslot   *psl;
1134 >
1135 >        if (noaction) {
1136 >                if (!silent)
1137 >                        printf("\t%s\n", com);  /* echo command */
1138 >                return(0);
1139 >        }
1140 >                                        /* else start it when we can */
1141 >        while ((pid = startjob(NULL, savestr(com), donecom)) == -1)
1142 >                bwait(1);
1143 >        if (!silent) {                          /* echo command */
1144 >                PSERVER *ps;
1145 >                int     psn = pid;
1146 >                ps = findjob(&psn);
1147 >                printf("\t%s\n", com);
1148 >                printf("\tProcess started on %s\n", phostname(ps));
1149 >                fflush(stdout);
1150 >        }
1151 >        psl = findpslot(pid);           /* record info. in appropriate slot */
1152 >        psl->pid = pid;
1153 >        psl->fout = fout;
1154 >        psl->rcvf = rf;
1155 >        return(pid);
1156 > }
1157 >
1158 >
1159 > bwait(ncoms)                            /* wait for batch job(s) to finish */
1160 > int     ncoms;
1161 > {
1162 >        int     status;
1163 >        register struct pslot   *psl;
1164 >
1165 >        if (noaction)
1166 >                return;
1167 >        while ((status = wait4job(NULL, -1)) != -1) {
1168 >                psl = findpslot(lastpid);
1169 >                if (status) {           /* attempt recovery */
1170 >                        serverdown();   /* check server */
1171 >                        if (psl->rcvf == NULL || (*psl->rcvf)(psl->fout)) {
1172 >                                fprintf(stderr,
1173 >                                        "%s: error rendering frame %d\n",
1174 >                                                progname, psl->fout);
1175 >                                quit(1);
1176 >                        }
1177 >                }
1178 >                psl->pid = 0;           /* free process slot */
1179 >                if (!--ncoms)
1180 >                        return;         /* done enough */
1181 >        }
1182 > }
1183 >
1184 >
1185 > int
1186 > pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1187 > char    *com, *ppins;
1188 > int     maxcopies;
1189 > {
1190 >        int     retstatus = 0;
1191 >        int     hostcopies;
1192 >        char    com1buf[10240], *com1, *endcom1;
1193 >        int     status;
1194 >        register PSERVER        *ps;
1195 >
1196 >        if (!silent)
1197 >                printf("\t%s\n", com);  /* echo command */
1198 >        if (noaction)
1199 >                return(0);
1200 >        fflush(stdout);
1201 >                                        /* start jobs on each server */
1202 >        for (ps = pslist; ps != NULL; ps = ps->next) {
1203 >                hostcopies = 0;
1204 >                if (maxcopies > 1 && ps->nprocs > 1 && ppins != NULL) {
1205 >                        strcpy(com1=com1buf, com);      /* build -PP command */
1206 >                        sprintf(com1+(ppins-com), " -PP %s/%s.persist",
1207 >                                        vval(DIRECTORY), phostname(ps));
1208 >                        strcat(com1, ppins);
1209 >                        endcom1 = com1 + strlen(com1);
1210 >                        sprintf(endcom1, "; kill `sed -n '1s/^[^ ]* //p' %s/%s.persist`",
1211 >                                        vval(DIRECTORY), phostname(ps));
1212 >                } else {
1213 >                        com1 = com;
1214 >                        endcom1 = NULL;
1215 >                }
1216 >                while (maxcopies > 0 &&
1217 >                                startjob(ps, savestr(com1), donecom) != -1) {
1218 >                        sleep(10);
1219 >                        hostcopies++;
1220 >                        maxcopies--;
1221 >                        if (endcom1 != NULL)
1222 >                                *endcom1 = '\0';
1223 >                }
1224 >                if (!silent && hostcopies) {
1225 >                        if (hostcopies > 1)
1226 >                                printf("\t%d duplicate processes", hostcopies);
1227 >                        else
1228 >                                printf("\tProcess");
1229 >                        printf(" started on %s\n", phostname(ps));
1230 >                        fflush(stdout);
1231 >                }
1232 >        }
1233 >                                        /* wait for jobs to finish */
1234 >        while ((status = wait4job(NULL, -1)) != -1)
1235 >                if (status)
1236 >                        retstatus += !serverdown();     /* check server */
1237 >        return(retstatus);
1238 > }
1239 >
1240 >
1241 > runcom(cs)                      /* run a command locally and wait for it */
1242   char    *cs;
1243   {
1244          if (!silent)            /* echo it */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines