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.25 by gwlarson, Tue Mar 3 11:44:46 1998 UTC vs.
Revision 2.52 by greg, Tue Apr 18 04:30:35 2006 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1996 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char RCSid[] = "$Id$";
3   #endif
6 –
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 "standard.h"
16 > #include "copyright.h"
17 >
18 > #include <stdio.h>
19   #include <ctype.h>
13 – #include <sys/types.h>
20   #include <sys/stat.h>
21 + #include <time.h>
22 + #include <signal.h>
23 +
24 + #include "platform.h"
25 + #include "rtprocess.h"
26 + #include "paths.h"
27 + #include "standard.h"
28   #include "view.h"
29   #include "vars.h"
30   #include "netproc.h"
31 +                                /* default blur samples */
32 + #ifndef DEF_NBLUR
33 + #define DEF_NBLUR       5
34 + #endif
35                                  /* default remote shell */
36 < #ifdef _AUX_SOURCE
37 < #define REMSH           "remsh"
21 < #else
22 < #define REMSH           "rsh"
36 > #ifndef REMSH
37 > #define REMSH           "ssh"
38   #endif
39 <                                /* input variables */
40 < #define HOST            0               /* rendering host machine */
41 < #define RENDER          1               /* rendering options */
42 < #define PFILT           2               /* pfilt options */
43 < #define PINTERP         3               /* pinterp options */
44 < #define OCTREE          4               /* octree file name */
45 < #define DIRECTORY       5               /* working (sub)directory */
46 < #define BASENAME        6               /* output image base name */
47 < #define VIEWFILE        7               /* animation frame views */
48 < #define START           8               /* starting frame number */
49 < #define END             9               /* ending frame number */
50 < #define RIF             10              /* rad input file */
39 >                                /* input variables (alphabetical by name) */
40 > #define ANIMATE         0               /* animation command */
41 > #define ARCHIVE         1               /* archiving command */
42 > #define BASENAME        2               /* output image base name */
43 > #define DBLUR           3               /* depth of field blur */
44 > #define DIRECTORY       4               /* working (sub)directory */
45 > #define DISKSPACE       5               /* how much disk space to use */
46 > #define END             6               /* ending frame number */
47 > #define EXPOSURE        7               /* how to compute exposure */
48 > #define HOST            8               /* rendering host machine */
49 > #define INTERP          9               /* # frames to interpolate */
50 > #define MBLUR           10              /* motion blur parameters */
51   #define NEXTANIM        11              /* next animation file */
52 < #define ANIMATE         12              /* animation command */
53 < #define TRANSFER        13              /* frame transfer command */
54 < #define ARCHIVE         14              /* archiving command */
55 < #define INTERP          15              /* # frames to interpolate */
56 < #define OVERSAMP        16              /* # times to oversample image */
57 < #define MBLUR           17              /* samples for motion blur */
58 < #define RTRACE          18              /* use rtrace with pinterp? */
59 < #define DISKSPACE       19              /* how much disk space to use */
60 < #define RESOLUTION      20              /* desired final resolution */
61 < #define EXPOSURE        21              /* how to compute exposure */
62 < #define RSH             22              /* remote shell script or program */
52 > #define OCTREE          12              /* octree file name */
53 > #define OVERSAMP        13              /* # times to oversample image */
54 > #define PFILT           14              /* pfilt options */
55 > #define PINTERP         15              /* pinterp options */
56 > #define RENDER          16              /* rendering options */
57 > #define RESOLUTION      17              /* desired final resolution */
58 > #define RIF             18              /* rad input file */
59 > #define RSH             19              /* remote shell script or program */
60 > #define RTRACE          20              /* use rtrace with pinterp? */
61 > #define START           21              /* starting frame number */
62 > #define TRANSFER        22              /* frame transfer command */
63 > #define VIEWFILE        23              /* animation frame views */
64  
65 < int     NVARS = 23;             /* total number of variables */
65 > int     NVARS = 24;             /* total number of variables */
66  
67   VARIABLE        vv[] = {                /* variable-value pairs */
52 –        {"host",        4,      0,      NULL,   NULL},
53 –        {"render",      3,      0,      NULL,   catvalues},
54 –        {"pfilt",       2,      0,      NULL,   catvalues},
55 –        {"pinterp",     2,      0,      NULL,   catvalues},
56 –        {"OCTREE",      3,      0,      NULL,   onevalue},
57 –        {"DIRECTORY",   3,      0,      NULL,   onevalue},
58 –        {"BASENAME",    3,      0,      NULL,   onevalue},
59 –        {"VIEWFILE",    2,      0,      NULL,   onevalue},
60 –        {"START",       2,      0,      NULL,   intvalue},
61 –        {"END",         2,      0,      NULL,   intvalue},
62 –        {"RIF",         3,      0,      NULL,   onevalue},
63 –        {"NEXTANIM",    3,      0,      NULL,   onevalue},
68          {"ANIMATE",     2,      0,      NULL,   onevalue},
65 –        {"TRANSFER",    2,      0,      NULL,   onevalue},
69          {"ARCHIVE",     2,      0,      NULL,   onevalue},
70 +        {"BASENAME",    3,      0,      NULL,   onevalue},
71 +        {"DBLUR",       2,      0,      NULL,   onevalue},
72 +        {"DIRECTORY",   3,      0,      NULL,   onevalue},
73 +        {"DISKSPACE",   3,      0,      NULL,   fltvalue},
74 +        {"END",         2,      0,      NULL,   intvalue},
75 +        {"EXPOSURE",    3,      0,      NULL,   onevalue},
76 +        {"host",        4,      0,      NULL,   NULL},
77          {"INTERPOLATE", 3,      0,      NULL,   intvalue},
68 –        {"OVERSAMPLE",  2,      0,      NULL,   fltvalue},
78          {"MBLUR",       2,      0,      NULL,   onevalue},
79 <        {"RTRACE",      2,      0,      NULL,   boolvalue},
80 <        {"DISKSPACE",   3,      0,      NULL,   fltvalue},
79 >        {"NEXTANIM",    3,      0,      NULL,   onevalue},
80 >        {"OCTREE",      3,      0,      NULL,   onevalue},
81 >        {"OVERSAMPLE",  2,      0,      NULL,   fltvalue},
82 >        {"pfilt",       2,      0,      NULL,   catvalues},
83 >        {"pinterp",     2,      0,      NULL,   catvalues},
84 >        {"render",      3,      0,      NULL,   catvalues},
85          {"RESOLUTION",  3,      0,      NULL,   onevalue},
86 <        {"EXPOSURE",    3,      0,      NULL,   onevalue},
86 >        {"RIF",         3,      0,      NULL,   onevalue},
87          {"RSH",         3,      0,      NULL,   onevalue},
88 +        {"RTRACE",      2,      0,      NULL,   boolvalue},
89 +        {"START",       2,      0,      NULL,   intvalue},
90 +        {"TRANSFER",    2,      0,      NULL,   onevalue},
91 +        {"VIEWFILE",    2,      0,      NULL,   onevalue},
92   };
93  
94   #define SFNAME  "STATUS"                /* status file name */
95  
96   struct {
97          char    host[64];               /* control host name */
98 <        int     pid;                    /* control process id */
98 >        RT_PID  pid;                    /* control process id */
99          char    cfname[128];            /* control file name */
100          int     rnext;                  /* next frame to render */
101          int     fnext;                  /* next frame to filter */
# Line 102 | Line 119 | char   arcargs[10240];         /* files to archive */
119   char    *arcfirst, *arcnext;    /* pointers to first and next argument */
120  
121   struct pslot {
122 <        int     pid;                    /* process ID (0 if empty) */
122 >        RT_PID  pid;                    /* process ID (0 if empty) */
123          int     fout;                   /* output frame number */
124          int     (*rcvf)();              /* recover function */
125   }       *pslot;                 /* process slots */
126   int     npslots;                /* number of process slots */
127  
128   #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
112 –
113 – struct pslot    *findpslot();
114 –
129   PSERVER *lastpserver;           /* last process server with error */
130  
131 < VIEW    *getview();
132 < char    *getexp(), *dirfile();
131 > static struct pslot * findpslot(RT_PID pid);
132 > static void checkdir(void);
133 > static VIEW * getview(int n);
134  
135 < extern time_t   fdate(), time();
135 > static char * dirfile(char *df, register char *path);
136 > static char * getexp(int n);
137 > static int getblur(double *mbf, double *dbf);
138 > static int getastat(void);
139 > static void getradfile(char *rfargs);
140 > static void badvalue(int vc);
141 > static int rmfile(char *fn);
142 > static int runcom(char *cs);
143 > static int pruncom(char *com, char *ppins, int maxcopies);
144 > static void bwait(int ncoms);
145 > static RT_PID bruncom(char *com, int fout, int (*rf)());
146 > static int serverdown(void);
147 > static pscompfunc donecom;
148 > static int countviews(void);
149 > static int dofilt(int frame, int rvr);
150 > static void archive(void);
151 > static int frecover(int frame);
152 > static int recover(int frame);
153 > static void sethosts(void);
154 > static void walkwait(int first, int last, char *vfn);
155 > static void animrend(int frame, VIEW *vp);
156 > static void transferframes(void);
157 > static void filterframes(void);
158 > static void renderframes(int nframes);
159 > static void animate(void);
160 > static void setdefaults(void);
161 > static void putastat(void);
162  
163  
164 < main(argc, argv)
165 < int     argc;
166 < char    *argv[];
164 > int
165 > main(
166 >        int     argc,
167 >        char    *argv[]
168 > )
169   {
170          int     explicate = 0;
171          int     i;
# Line 175 | Line 218 | char   *argv[];
218          animate();
219                                                  /* all done */
220          if (vdef(NEXTANIM)) {
221 +                char    *fullp;
222                  argv[i] = vval(NEXTANIM);       /* just change input file */
223                  if (!silent)
224                          printargs(argc, argv, stdout);
225 <                if ((argv[0] = getpath(progname,getenv("PATH"),X_OK)) == NULL)
226 <                        fprintf(stderr, "%s: command not found\n", progname);
225 >                fflush(stdout);
226 >                if ((fullp = getpath(argv[0],getenv("PATH"),X_OK)) == NULL)
227 >                        fprintf(stderr, "%s: command not found\n", argv[0]);
228                  else
229 <                        execv(progname, argv);
229 >                        execv(fullp, argv);
230                  quit(1);
231          }
232          quit(0);
233 +        return(0); /* pro forma return */
234   userr:
235          fprintf(stderr, "Usage: %s [-s][-n][-w][-e] anim_file\n", progname);
236          quit(1);
237 +        return 1; /* pro forma return */
238   }
239  
240  
241 < getastat()                      /* check/set animation status */
241 > static int
242 > getastat(void)                  /* check/set animation status */
243   {
244          char    sfname[256];
245          FILE    *fp;
# Line 255 | Line 303 | fmterr:
303   }
304  
305  
306 < putastat()                      /* put out current status */
306 > static void
307 > putastat(void)                  /* put out current status */
308   {
309          char    buf[256];
310          FILE    *fp;
# Line 277 | Line 326 | putastat()                     /* put out current status */
326   }
327  
328  
329 < checkdir()                      /* make sure we have our directory */
329 > static void
330 > checkdir(void)                  /* make sure we have our directory */
331   {
332          struct stat     stb;
333  
# Line 299 | Line 349 | checkdir()                     /* make sure we have our directory */
349   }
350  
351  
352 < setdefaults()                   /* set default values */
352 > static void
353 > setdefaults(void)                       /* set default values */
354   {
355          extern char     *atos();
356          int     decades;
# Line 387 | Line 438 | setdefaults()                  /* set default values */
438   }
439  
440  
441 < sethosts()                      /* set up process servers */
441 > static void
442 > sethosts(void)                  /* set up process servers */
443   {
444          extern char     *iskip();
445          char    buf[256], *dir, *uname;
# Line 442 | Line 494 | sethosts()                     /* set up process servers */
494          }
495   }
496  
497 <
498 < getradfile(rfargs)              /* run rad and get needed variables */
447 < char    *rfargs;
497 > static void
498 > getradfile(char *rfargs)                /* run rad and get needed variables */
499   {
500          static short    mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
501          char    combuf[256];
502          register int    i;
503          register char   *cp;
504 <        char    *pippt;
504 >        char    *pippt = NULL;
505                                          /* create rad command */
506          sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
507          sprintf(combuf,
# Line 469 | Line 520 | char   *rfargs;
520                          pippt = NULL;
521                  }
522          if (pippt != NULL)
523 <                strcpy(pippt, "> /dev/null");   /* nothing to match */
523 >                strcpy(pippt, "> " NULL_DEVICE);        /* nothing to match */
524          else {
525                  sprintf(cp, ")[ \t]*=' > %s/radset.var", vval(DIRECTORY));
526                  cp += 11;               /* point to file name */
527          }
528 <        if (system(combuf)) {
478 <                fprintf(stderr, "%s: error executing rad command:\n\t%s\n",
479 <                                progname, combuf);
480 <                quit(1);
481 <        }
528 >        system(combuf);                 /* ignore exit code */
529          if (pippt == NULL) {            /* load variables and remove file */
530                  loadvars(cp);
531                  unlink(cp);
# Line 486 | Line 533 | char   *rfargs;
533   }
534  
535  
536 < animate()                       /* run animation */
536 > static void
537 > animate(void)                   /* run animation */
538   {
539          int     xres, yres;
540          float   pa, mult;
# Line 516 | Line 564 | animate()                      /* run animation */
564                                                  progname, vnam(INTERP));
565                          vval(INTERP) = "0";
566                  }
567 <                if (atoi(vval(MBLUR))) {        /* can't handle this yet */
567 >                if (strcmp(vval(MBLUR),"0")) {  /* can't handle this */
568                          if (!nowarn)
569                                  fprintf(stderr,
570                                          "%s: resetting %s=0 for animation\n",
# Line 526 | Line 574 | animate()                      /* run animation */
574          }
575                                          /* figure # frames per batch */
576          d1 = mult*xres*mult*yres*4;             /* space for orig. picture */
577 <        if ((i=vint(INTERP)) || atoi(vval(MBLUR)))
577 >        if ((i=vint(INTERP)) || getblur(NULL, NULL) > 1)
578                  d1 += mult*xres*mult*yres*sizeof(float);        /* Z-buffer */
579          d2 = xres*yres*4;                       /* space for final picture */
580          frames_batch = (i+1)*(vflt(DISKSPACE)*1048576.-d1)/(d1+i*d2);
# Line 557 | Line 605 | animate()                      /* run animation */
605   }
606  
607  
608 < renderframes(nframes)           /* render next nframes frames */
609 < int     nframes;
608 > static void
609 > renderframes(int nframes)               /* render next nframes frames */
610   {
611          static char     vendbuf[16];
612          VIEW    *vp;
# Line 614 | Line 662 | int    nframes;
662   }
663  
664  
665 < filterframes()                          /* catch up with filtering */
665 > static void
666 > filterframes(void)                              /* catch up with filtering */
667   {
619 –        VIEW    *vp;
668          register int    i;
669  
670          if (astat.tnext < astat.fnext)  /* other work to do first */
671                  return;
672                                          /* filter each view */
673 <        for (i = astat.fnext; i < astat.rnext; i++) {
674 <                if ((vp = getview(i)) == NULL) {        /* get view i */
675 <                        fprintf(stderr,
628 <                        "%s: unexpected error reading view for frame %d\n",
629 <                                        progname, i);
630 <                        quit(1);
631 <                }
632 <                dofilt(i, vp, getexp(i), 0);            /* filter frame */
633 <        }
673 >        for (i = astat.fnext; i < astat.rnext; i++)
674 >                dofilt(i, 0);
675 >
676          bwait(0);                       /* wait for filter processes */
677          archive();                      /* archive originals */
678          astat.fnext = i;                /* update status */
# Line 638 | Line 680 | filterframes()                         /* catch up with filtering */
680   }
681  
682  
683 < transferframes()                        /* catch up with picture transfers */
683 > static void
684 > transferframes(void)                    /* catch up with picture transfers */
685   {
686          char    combuf[10240], *fbase;
687          register char   *cp;
# Line 678 | Line 721 | transferframes()                       /* catch up with picture transfers
721   }
722  
723  
724 < animrend(frame, vp)                     /* start animation frame */
725 < int     frame;
726 < VIEW    *vp;
724 > static void
725 > animrend(                       /* start animation frame */
726 > int     frame,
727 > VIEW    *vp
728 > )
729   {
685 –        extern int      recover();
730          char    combuf[2048];
731          char    fname[128];
732  
# Line 696 | Line 740 | VIEW   *vp;
740   }
741  
742  
743 < walkwait(first, last, vfn)              /* walk-through frames */
744 < int     first, last;
745 < char    *vfn;
743 > static void
744 > walkwait(               /* walk-through frames */
745 > int     first,
746 > int last,
747 > char    *vfn
748 > )
749   {
750 +        double  mblurf, dblurf;
751 +        int     nblur = getblur(&mblurf, &dblurf);
752          char    combuf[2048];
753 <        char    *inspoint;
753 >        register char   *inspoint;
754          register int    i;
755  
756          if (!noaction && vint(INTERP))          /* create dummy frames */
# Line 712 | Line 761 | char   *vfn;
761                                  close(open(combuf, O_RDONLY|O_CREAT, 0666));
762                          }
763                                          /* create command */
764 <        sprintf(combuf, "rpict%s -w0", rendopt);
765 <        if (vint(INTERP) || atoi(vval(MBLUR)))
766 <                sprintf(combuf+strlen(combuf), " -z %s.zbf", vval(BASENAME));
767 <        sprintf(combuf+strlen(combuf), " -o %s.unf %s -S %d",
764 >        sprintf(combuf, "rpict%s%s -w0", rendopt,
765 >                        viewopt(getview(first>1 ? first-1 : 1)));
766 >        inspoint = combuf;
767 >        while (*inspoint) inspoint++;
768 >        if (nblur) {
769 >                sprintf(inspoint, " -pm %.3f", mblurf/nblur);
770 >                while (*inspoint) inspoint++;
771 >                sprintf(inspoint, " -pd %.3f", dblurf/nblur);
772 >                while (*inspoint) inspoint++;
773 >        }
774 >        if (nblur > 1 || vint(INTERP)) {
775 >                sprintf(inspoint, " -z %s.zbf", vval(BASENAME));
776 >                while (*inspoint) inspoint++;
777 >        }
778 >        sprintf(inspoint, " -o %s.unf %s -S %d",
779                          vval(BASENAME), rresopt, first);
780 <        inspoint = combuf + strlen(combuf);
780 >        while (*inspoint) inspoint++;
781          sprintf(inspoint, " %s < %s", vval(OCTREE), vfn);
782                                          /* run in parallel */
783          i = (last-first+1)/(vint(INTERP)+1);
# Line 737 | Line 797 | char   *vfn;
797   }
798  
799  
800 < int
801 < recover(frame)                          /* recover the specified frame */
742 < int     frame;
800 > static int
801 > recover(int frame)                      /* recover the specified frame */
802   {
803          static int      *rfrm;          /* list of recovered frames */
804          static int      nrfrms = 0;
805 +        double  mblurf, dblurf;
806 +        int     nblur = getblur(&mblurf, &dblurf);
807          char    combuf[2048];
808          char    fname[128];
809          register char   *cp;
# Line 758 | Line 819 | int    frame;
819                                  vval(ANIMATE), frame, rendopt);
820          else
821                  sprintf(combuf, "rpict%s -w0", rendopt);
822 <        cp = combuf + strlen(combuf);
823 <        if (vint(INTERP) || atoi(vval(MBLUR))) {
822 >        cp = combuf;
823 >        while (*cp) cp++;
824 >        if (nblur) {
825 >                sprintf(cp, " -pm %.3f", mblurf/nblur);
826 >                while (*cp) cp++;
827 >                sprintf(cp, " -pd %.3f", dblurf/nblur);
828 >                while (*cp) cp++;
829 >        }
830 >        if (nblur > 1 || vint(INTERP)) {
831                  sprintf(cp, " -z %s.zbf", fname);
832                  while (*cp) cp++;
833          }
# Line 773 | Line 841 | int    frame;
841                  return(1);
842                                          /* add frame to recovered list */
843          if (nrfrms)
844 <                rfrm = (int *)realloc((char *)rfrm, (nrfrms+1)*sizeof(int));
844 >                rfrm = (int *)realloc((void *)rfrm, (nrfrms+1)*sizeof(int));
845          else
846                  rfrm = (int *)malloc(sizeof(int));
847          if (rfrm == NULL) {
# Line 785 | Line 853 | int    frame;
853   }
854  
855  
856 < int
857 < frecover(frame)                         /* recover filtered frame */
790 < int     frame;
856 > static int
857 > frecover(int frame)                             /* recover filtered frame */
858   {
859 <        VIEW    *vp;
793 <        char    *ex;
794 <
795 <        vp = getview(frame);
796 <        ex = getexp(frame);
797 <        if (dofilt(frame, vp, ex, 2) && dofilt(frame, vp, ex, 1))
859 >        if (dofilt(frame, 2) && dofilt(frame, 1))
860                  return(1);
861          return(0);
862   }
863  
864  
865 < archive()                       /* archive and remove renderings */
865 > static void
866 > archive(void)                   /* archive and remove renderings */
867   {
868   #define RMCOML  (sizeof(rmcom)-1)
869          static char     rmcom[] = "rm -f";
# Line 843 | Line 906 | archive()                      /* archive and remove renderings */
906   }
907  
908  
909 < int
910 < dofilt(frame, vp, ep, rvr)                      /* filter frame */
911 < int     frame;
912 < VIEW    *vp;
913 < char    *ep;
851 < int     rvr;
909 > static int
910 > dofilt(                         /* filter frame */
911 > int     frame,
912 > int     rvr
913 > )
914   {
853 –        extern int      frecover();
915          static int      iter = 0;
916 +        double  mblurf, dblurf;
917 +        int     nblur = getblur(&mblurf, &dblurf);
918 +        VIEW    *vp = getview(frame);
919 +        char    *ep = getexp(frame);
920          char    fnbefore[128], fnafter[128], *fbase;
921          char    combuf[1024], fname0[128], fname1[128];
922          int     usepinterp, usepfilt, nora_rgbe;
923          int     frseq[2];
924                                                  /* check what is needed */
925 <        usepinterp = atoi(vval(MBLUR));
926 <        usepfilt = pfiltalways | ep==NULL;
925 >        if (vp == NULL) {
926 >                 fprintf(stderr,
927 >                        "%s: unexpected error reading view for frame %d\n",
928 >                                          progname, frame);
929 >                quit(1);
930 >        }
931 >        usepinterp = (nblur > 1);
932 >        usepfilt = pfiltalways | (ep==NULL);
933          if (ep != NULL && !strcmp(ep, "1"))
934                  ep = "+0";
935          nora_rgbe = strcmp(vval(OVERSAMP),"1") || ep==NULL ||
# Line 875 | Line 946 | int    rvr;
946                  usepfilt |= nora_rgbe;
947          } else if (frseq[0] == frame) {         /* no interpolation needed */
948                  if (!rvr && frame > 1+vint(INTERP)) {   /* archive previous */
949 +                        if (arcnext - arcargs +
950 +                                        strlen(fbase) >= sizeof(arcargs)-8) {
951 +                                fprintf(stderr,
952 + "%s: too many filenames in archive command -- reduce %s variable\n",
953 +                                                progname, vnam(DISKSPACE));
954 +                                quit(1);
955 +                        }
956                          *arcnext++ = ' ';
957                          sprintf(arcnext, fbase, frame-vint(INTERP)-1);
958                          while (*arcnext) arcnext++;
# Line 902 | Line 980 | int    rvr;
980          if (usepinterp) {                       /* using pinterp */
981                  if (rvr == 2 && recover(frseq[1]))      /* recover after? */
982                          return(1);
983 <                if (atoi(vval(MBLUR))) {
983 >                if (nblur > 1) {                /* with pdmblur */
984                          sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
985                                          'a'+(iter%26));
986                          sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
# Line 929 | Line 1007 | int    rvr;
1007                                  putc('\n', fp); fclose(fp);
1008                          }
1009                          sprintf(combuf,
1010 <                        "(pmblur %s %d %s %s; rm -f %s %s) | pinterp -B",
1011 <                        *sskip(vval(MBLUR)) ? sskip2(vval(MBLUR),1) : "1",
934 <                                        atoi(vval(MBLUR)),
1010 >                        "(pmdblur %.3f %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
1011 >                                        mblurf, dblurf, nblur,
1012                                          fname0, fname1, fname0, fname1);
1013                          iter++;
1014                  } else                          /* no blurring */
# Line 945 | Line 1022 | int    rvr;
1022                  if (usepfilt)
1023                          sprintf(combuf+strlen(combuf), " %s", rresopt);
1024                  else
1025 <                        sprintf(combuf+strlen(combuf), " %s -e %s",
1025 >                        sprintf(combuf+strlen(combuf), " -a %s -e %s",
1026                                          fresopt, ep);
1027                  sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
1028                                  fnbefore, fnbefore);
# Line 992 | Line 1069 | int    rvr;
1069   }
1070  
1071  
1072 < VIEW *
1073 < getview(n)                      /* get view number n */
997 < int     n;
1072 > static VIEW *
1073 > getview(int n)                  /* get view number n */
1074   {
1075          static FILE     *viewfp = NULL;         /* view file pointer */
1076          static int      viewnum = 0;            /* current view number */
# Line 1006 | Line 1082 | int    n;
1082                          fclose(viewfp);
1083                          viewfp = NULL;
1084                          viewnum = 0;
1085 <                        copystruct(&curview, &stdview);
1085 >                        curview = stdview;
1086                  }
1087                  return(NULL);
1088          }
# Line 1022 | Line 1098 | int    n;
1098                          perror(vval(VIEWFILE));
1099                          quit(1);
1100                  }
1101 <                copystruct(&curview, &stdview);
1101 >                curview = stdview;
1102                  viewnum = 0;
1103          }
1104          if (n < 0) {                            /* get next view */
# Line 1042 | Line 1118 | int    n;
1118   }
1119  
1120  
1121 < int
1122 < countviews()                    /* count views in view file */
1121 > static int
1122 > countviews(void)                        /* count views in view file */
1123   {
1124          int     n;
1125  
# Line 1055 | Line 1131 | countviews()                   /* count views in view file */
1131   }
1132  
1133  
1134 < char *
1135 < getexp(n)                       /* get exposure for nth frame */
1060 < int     n;
1134 > static char *
1135 > getexp(int n)                   /* get exposure for nth frame */
1136   {
1137          extern char     *fskip();
1138          static char     expval[32];
# Line 1069 | Line 1144 | int    n;
1144          if (n == 0) {                           /* signal to close file */
1145                  if (expfp != NULL) {
1146                          fclose(expfp);
1147 <                        free((char *)exppos);
1147 >                        free((void *)exppos);
1148                          expfp = NULL;
1149                  }
1150                  return(NULL);
# Line 1126 | Line 1201 | int    n;
1201   }
1202  
1203  
1204 < struct pslot *
1205 < findpslot(pid)                  /* find or allocate a process slot */
1131 < int     pid;
1204 > static struct pslot *
1205 > findpslot(RT_PID pid)                   /* find or allocate a process slot */
1206   {
1207          register struct pslot   *psempty = NULL;
1208          register int    i;
# Line 1143 | Line 1217 | int    pid;
1217   }
1218  
1219  
1220 < int
1221 < donecom(ps, pn, status)         /* clean up after finished process */
1222 < PSERVER *ps;
1223 < int     pn;
1224 < int     status;
1220 > static int
1221 > donecom(                /* clean up after finished process */
1222 >        PSERVER *ps,
1223 >        int     pn,
1224 >        int     status
1225 > )
1226   {
1227 <        register PROC   *pp;
1227 >        register NETPROC        *pp;
1228          register struct pslot   *psl;
1229  
1230          pp = ps->proc + pn;
# Line 1184 | Line 1259 | int    status;
1259   }
1260  
1261  
1262 < int
1263 < serverdown()                    /* check status of last process server */
1262 > static int
1263 > serverdown(void)                        /* check status of last process server */
1264   {
1265          if (lastpserver == NULL || !lastpserver->hostname[0])
1266                  return(0);
# Line 1201 | Line 1276 | serverdown()                   /* check status of last process server
1276   }
1277  
1278  
1279 < int
1280 < bruncom(com, fout, rf)          /* run a command in the background */
1281 < char    *com;
1282 < int     fout;
1283 < int     (*rf)();
1279 > static RT_PID
1280 > bruncom(                /* run a command in the background */
1281 > char    *com,
1282 > int     fout,
1283 > int     (*rf)()
1284 > )
1285   {
1286 <        int     pid;
1286 >        RT_PID  pid;
1287          register struct pslot   *psl;
1288  
1289          if (noaction) {
# Line 1220 | Line 1296 | int    (*rf)();
1296                  bwait(1);
1297          if (!silent) {                          /* echo command */
1298                  PSERVER *ps;
1299 <                int     psn = pid;
1299 >                RT_PID  psn = pid;
1300                  ps = findjob(&psn);
1301                  printf("\t%s\n", com);
1302                  printf("\tProcess started on %s\n", phostname(ps));
# Line 1234 | Line 1310 | int    (*rf)();
1310   }
1311  
1312  
1313 < bwait(ncoms)                            /* wait for batch job(s) to finish */
1314 < int     ncoms;
1313 > static void
1314 > bwait(int ncoms)                                /* wait for batch job(s) to finish */
1315   {
1316          int     status;
1317  
# Line 1249 | Line 1325 | int    ncoms;
1325   }
1326  
1327  
1328 < int
1329 < pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1330 < char    *com, *ppins;
1331 < int     maxcopies;
1328 > static int
1329 > pruncom(        /* run a command in parallel over network */
1330 > char    *com,
1331 > char    *ppins,
1332 > int     maxcopies
1333 > )
1334   {
1335          int     retstatus = 0;
1336          int     hostcopies;
# Line 1274 | Line 1352 | int    maxcopies;
1352                          strcpy(com1=buf, com);  /* build -PP command */
1353                          sprintf(com1+(ppins-com), " -PP %s/%s.persist",
1354                                          vval(DIRECTORY), phostname(ps));
1355 +                        unlink(com1+(ppins-com)+5);
1356                          strcat(com1, ppins);
1357                  } else
1358                          com1 = com;
# Line 1318 | Line 1397 | int    maxcopies;
1397   }
1398  
1399  
1400 < runcom(cs)                      /* run a command locally and wait for it */
1401 < char    *cs;
1400 > static int
1401 > runcom(char *cs)                        /* run a command locally and wait for it */
1402   {
1403          if (!silent)            /* echo it */
1404                  printf("\t%s\n", cs);
# Line 1330 | Line 1409 | char   *cs;
1409   }
1410  
1411  
1412 < rmfile(fn)                      /* remove a file */
1413 < char    *fn;
1412 > static int
1413 > rmfile(char *fn)                        /* remove a file */
1414   {
1415          if (!silent)
1416 < #ifdef MSDOS
1416 > #ifdef _WIN32
1417                  printf("\tdel %s\n", fn);
1418   #else
1419                  printf("\trm -f %s\n", fn);
# Line 1345 | Line 1424 | char   *fn;
1424   }
1425  
1426  
1427 < badvalue(vc)                    /* report bad variable value and exit */
1428 < int     vc;
1427 > static void
1428 > badvalue(int vc)                        /* report bad variable value and exit */
1429   {
1430          fprintf(stderr, "%s: bad value for variable '%s'\n",
1431                          progname, vnam(vc));
# Line 1354 | Line 1433 | int    vc;
1433   }
1434  
1435  
1436 < char *
1437 < dirfile(df, path)               /* separate path into directory and file */
1438 < char    *df;
1439 < register char   *path;
1436 > static char *
1437 > dirfile(                /* separate path into directory and file */
1438 > char    *df,
1439 > register char   *path
1440 > )
1441   {
1442          register int    i;
1443          int     psep;
# Line 1365 | Line 1445 | register char  *path;
1445          for (i = 0, psep = -1; path[i]; i++)
1446                  if (path[i] == '/')
1447                          psep = i;
1448 <        if (df != NULL)
1448 >        if (df != NULL) {
1449                  if (psep == 0) {
1450                          df[0] = '/';
1451                          df[1] = '\0';
# Line 1374 | Line 1454 | register char  *path;
1454                          df[psep] = '\0';
1455                  } else
1456                          df[0] = '\0';
1457 +        }
1458          return(path+psep+1);
1459 + }
1460 +
1461 +
1462 + static int
1463 + getblur(double *mbf, double *dbf)       /* get # blur samples (and fraction) */
1464 + {
1465 +        double  mblurf, dblurf;
1466 +        int     nmblur, ndblur;
1467 +        char    *s;
1468 +                                        /* get motion blur */
1469 +        if (!vdef(MBLUR) || (mblurf = atof(vval(MBLUR))) < 0.0)
1470 +                mblurf = 0.0;
1471 +        if (mbf != NULL)
1472 +                *mbf = mblurf;
1473 +        if (mblurf <= FTINY)
1474 +                nmblur = 0;
1475 +        else if (!*(s = sskip(vval(MBLUR))))
1476 +                nmblur = DEF_NBLUR;
1477 +        else if ((nmblur = atoi(s)) <= 0)
1478 +                nmblur = 1;
1479 +                                        /* get depth-of-field blur */
1480 +        if (!vdef(DBLUR) || (dblurf = atof(vval(DBLUR))) < 0.0)
1481 +                dblurf = 0.0;
1482 +        if (dbf != NULL)
1483 +                *dbf = dblurf;
1484 +        if (dblurf <= FTINY)
1485 +                ndblur = 0;
1486 +        else if (!*(s = sskip(vval(DBLUR))))
1487 +                ndblur = DEF_NBLUR;
1488 +        else if ((ndblur = atoi(s)) <= 0)
1489 +                ndblur = 1;
1490 +        if ((nmblur == 1) & (ndblur == 1))
1491 +                return(1);
1492 +                                        /* return combined samples */
1493 +        return(nmblur + ndblur);
1494   }

Diff Legend

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