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.28 by gwlarson, Mon Jul 6 18:17:39 1998 UTC vs.
Revision 2.49 by greg, Mon Feb 7 17:08:17 2005 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
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 "paths.h"
26 + #include "standard.h"
27   #include "view.h"
28   #include "vars.h"
29   #include "netproc.h"
30 +                                /* default blur samples */
31 + #ifndef DEF_NBLUR
32 + #define DEF_NBLUR       5
33 + #endif
34                                  /* default remote shell */
35 < #ifdef _AUX_SOURCE
36 < #define REMSH           "remsh"
21 < #else
22 < #define REMSH           "rsh"
35 > #ifndef REMSH
36 > #define REMSH           "ssh"
37   #endif
38                                  /* input variables (alphabetical by name) */
39   #define ANIMATE         0               /* animation command */
40   #define ARCHIVE         1               /* archiving command */
41   #define BASENAME        2               /* output image base name */
42 < #define DIRECTORY       3               /* working (sub)directory */
43 < #define DISKSPACE       4               /* how much disk space to use */
44 < #define END             5               /* ending frame number */
45 < #define EXPOSURE        6               /* how to compute exposure */
46 < #define HOST            7               /* rendering host machine */
47 < #define INTERP          8               /* # frames to interpolate */
48 < #define MBLUR           9               /* samples for motion blur */
49 < #define NEXTANIM        10              /* next animation file */
50 < #define OCTREE          11              /* octree file name */
51 < #define OVERSAMP        12              /* # times to oversample image */
52 < #define PFILT           13              /* pfilt options */
53 < #define PINTERP         14              /* pinterp options */
54 < #define RENDER          15              /* rendering options */
55 < #define RESOLUTION      16              /* desired final resolution */
56 < #define RIF             17              /* rad input file */
57 < #define RSH             18              /* remote shell script or program */
58 < #define RTRACE          19              /* use rtrace with pinterp? */
59 < #define START           20              /* starting frame number */
60 < #define TRANSFER        21              /* frame transfer command */
61 < #define VIEWFILE        22              /* animation frame views */
42 > #define DBLUR           3               /* depth of field blur */
43 > #define DIRECTORY       4               /* working (sub)directory */
44 > #define DISKSPACE       5               /* how much disk space to use */
45 > #define END             6               /* ending frame number */
46 > #define EXPOSURE        7               /* how to compute exposure */
47 > #define HOST            8               /* rendering host machine */
48 > #define INTERP          9               /* # frames to interpolate */
49 > #define MBLUR           10              /* motion blur parameters */
50 > #define NEXTANIM        11              /* next animation file */
51 > #define OCTREE          12              /* octree file name */
52 > #define OVERSAMP        13              /* # times to oversample image */
53 > #define PFILT           14              /* pfilt options */
54 > #define PINTERP         15              /* pinterp options */
55 > #define RENDER          16              /* rendering options */
56 > #define RESOLUTION      17              /* desired final resolution */
57 > #define RIF             18              /* rad input file */
58 > #define RSH             19              /* remote shell script or program */
59 > #define RTRACE          20              /* use rtrace with pinterp? */
60 > #define START           21              /* starting frame number */
61 > #define TRANSFER        22              /* frame transfer command */
62 > #define VIEWFILE        23              /* animation frame views */
63  
64 < int     NVARS = 23;             /* total number of variables */
64 > int     NVARS = 24;             /* total number of variables */
65  
66   VARIABLE        vv[] = {                /* variable-value pairs */
67          {"ANIMATE",     2,      0,      NULL,   onevalue},
68          {"ARCHIVE",     2,      0,      NULL,   onevalue},
69          {"BASENAME",    3,      0,      NULL,   onevalue},
70 +        {"DBLUR",       2,      0,      NULL,   onevalue},
71          {"DIRECTORY",   3,      0,      NULL,   onevalue},
72          {"DISKSPACE",   3,      0,      NULL,   fltvalue},
73          {"END",         2,      0,      NULL,   intvalue},
# Line 109 | Line 125 | struct pslot {
125   int     npslots;                /* number of process slots */
126  
127   #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
112 –
113 – struct pslot    *findpslot();
114 –
128   PSERVER *lastpserver;           /* last process server with error */
129  
130 < VIEW    *getview();
131 < char    *getexp(), *dirfile();
130 > static struct pslot * findpslot(int pid);
131 > static void checkdir(void);
132 > static VIEW * getview(int n);
133  
134 < extern time_t   fdate(), time();
134 > static char * dirfile(char *df, register char *path);
135 > static char * getexp(int n);
136 > static int getblur(double *mbf, double *dbf);
137 > static int getastat(void);
138 > static void getradfile(char *rfargs);
139 > static void badvalue(int vc);
140 > static int rmfile(char *fn);
141 > static int runcom(char *cs);
142 > static int pruncom(char *com, char *ppins, int maxcopies);
143 > static void bwait(int ncoms);
144 > static int bruncom(char *com, int fout, int (*rf)());
145 > static int serverdown(void);
146 > static pscompfunc donecom;
147 > static int countviews(void);
148 > static int dofilt(int frame, int rvr);
149 > static void archive(void);
150 > static int frecover(int frame);
151 > static int recover(int frame);
152 > static void sethosts(void);
153 > static void walkwait(int first, int last, char *vfn);
154 > static void animrend(int frame, VIEW *vp);
155 > static void transferframes(void);
156 > static void filterframes(void);
157 > static void renderframes(int nframes);
158 > static void animate(void);
159 > static void setdefaults(void);
160 > static void putastat(void);
161  
162  
163 < main(argc, argv)
164 < int     argc;
165 < char    *argv[];
163 > int
164 > main(
165 >        int     argc,
166 >        char    *argv[]
167 > )
168   {
169          int     explicate = 0;
170          int     i;
# Line 185 | Line 227 | char   *argv[];
227                  quit(1);
228          }
229          quit(0);
230 +        return 0; /* pro forma return */
231   userr:
232          fprintf(stderr, "Usage: %s [-s][-n][-w][-e] anim_file\n", progname);
233          quit(1);
234 +        return 1; /* pro forma return */
235   }
236  
237  
238 < getastat()                      /* check/set animation status */
238 > static int
239 > getastat(void)                  /* check/set animation status */
240   {
241          char    sfname[256];
242          FILE    *fp;
# Line 255 | Line 300 | fmterr:
300   }
301  
302  
303 < putastat()                      /* put out current status */
303 > static void
304 > putastat(void)                  /* put out current status */
305   {
306          char    buf[256];
307          FILE    *fp;
# Line 277 | Line 323 | putastat()                     /* put out current status */
323   }
324  
325  
326 < checkdir()                      /* make sure we have our directory */
326 > static void
327 > checkdir(void)                  /* make sure we have our directory */
328   {
329          struct stat     stb;
330  
# Line 299 | Line 346 | checkdir()                     /* make sure we have our directory */
346   }
347  
348  
349 < setdefaults()                   /* set default values */
349 > static void
350 > setdefaults(void)                       /* set default values */
351   {
352          extern char     *atos();
353          int     decades;
# Line 387 | Line 435 | setdefaults()                  /* set default values */
435   }
436  
437  
438 < sethosts()                      /* set up process servers */
438 > static void
439 > sethosts(void)                  /* set up process servers */
440   {
441          extern char     *iskip();
442          char    buf[256], *dir, *uname;
# Line 442 | Line 491 | sethosts()                     /* set up process servers */
491          }
492   }
493  
494 <
495 < getradfile(rfargs)              /* run rad and get needed variables */
447 < char    *rfargs;
494 > static void
495 > getradfile(char *rfargs)                /* run rad and get needed variables */
496   {
497          static short    mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
498          char    combuf[256];
499          register int    i;
500          register char   *cp;
501 <        char    *pippt;
501 >        char    *pippt = NULL;
502                                          /* create rad command */
503          sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
504          sprintf(combuf,
# Line 469 | Line 517 | char   *rfargs;
517                          pippt = NULL;
518                  }
519          if (pippt != NULL)
520 <                strcpy(pippt, "> /dev/null");   /* nothing to match */
520 >                strcpy(pippt, "> " NULL_DEVICE);        /* nothing to match */
521          else {
522                  sprintf(cp, ")[ \t]*=' > %s/radset.var", vval(DIRECTORY));
523                  cp += 11;               /* point to file name */
# Line 482 | Line 530 | char   *rfargs;
530   }
531  
532  
533 < animate()                       /* run animation */
533 > static void
534 > animate(void)                   /* run animation */
535   {
536          int     xres, yres;
537          float   pa, mult;
# Line 512 | Line 561 | animate()                      /* run animation */
561                                                  progname, vnam(INTERP));
562                          vval(INTERP) = "0";
563                  }
564 <                if (atoi(vval(MBLUR))) {        /* can't handle this yet */
564 >                if (strcmp(vval(MBLUR),"0")) {  /* can't handle this */
565                          if (!nowarn)
566                                  fprintf(stderr,
567                                          "%s: resetting %s=0 for animation\n",
# Line 522 | Line 571 | animate()                      /* run animation */
571          }
572                                          /* figure # frames per batch */
573          d1 = mult*xres*mult*yres*4;             /* space for orig. picture */
574 <        if ((i=vint(INTERP)) || atoi(vval(MBLUR)))
574 >        if ((i=vint(INTERP)) || getblur(NULL, NULL) > 1)
575                  d1 += mult*xres*mult*yres*sizeof(float);        /* Z-buffer */
576          d2 = xres*yres*4;                       /* space for final picture */
577          frames_batch = (i+1)*(vflt(DISKSPACE)*1048576.-d1)/(d1+i*d2);
# Line 553 | Line 602 | animate()                      /* run animation */
602   }
603  
604  
605 < renderframes(nframes)           /* render next nframes frames */
606 < int     nframes;
605 > static void
606 > renderframes(int nframes)               /* render next nframes frames */
607   {
608          static char     vendbuf[16];
609          VIEW    *vp;
# Line 610 | Line 659 | int    nframes;
659   }
660  
661  
662 < filterframes()                          /* catch up with filtering */
662 > static void
663 > filterframes(void)                              /* catch up with filtering */
664   {
615 –        VIEW    *vp;
665          register int    i;
666  
667          if (astat.tnext < astat.fnext)  /* other work to do first */
668                  return;
669                                          /* filter each view */
670 <        for (i = astat.fnext; i < astat.rnext; i++) {
671 <                if ((vp = getview(i)) == NULL) {        /* get view i */
672 <                        fprintf(stderr,
624 <                        "%s: unexpected error reading view for frame %d\n",
625 <                                        progname, i);
626 <                        quit(1);
627 <                }
628 <                dofilt(i, vp, getexp(i), 0);            /* filter frame */
629 <        }
670 >        for (i = astat.fnext; i < astat.rnext; i++)
671 >                dofilt(i, 0);
672 >
673          bwait(0);                       /* wait for filter processes */
674          archive();                      /* archive originals */
675          astat.fnext = i;                /* update status */
# Line 634 | Line 677 | filterframes()                         /* catch up with filtering */
677   }
678  
679  
680 < transferframes()                        /* catch up with picture transfers */
680 > static void
681 > transferframes(void)                    /* catch up with picture transfers */
682   {
683          char    combuf[10240], *fbase;
684          register char   *cp;
# Line 674 | Line 718 | transferframes()                       /* catch up with picture transfers
718   }
719  
720  
721 < animrend(frame, vp)                     /* start animation frame */
722 < int     frame;
723 < VIEW    *vp;
721 > static void
722 > animrend(                       /* start animation frame */
723 > int     frame,
724 > VIEW    *vp
725 > )
726   {
681 –        extern int      recover();
727          char    combuf[2048];
728          char    fname[128];
729  
# Line 692 | Line 737 | VIEW   *vp;
737   }
738  
739  
740 < walkwait(first, last, vfn)              /* walk-through frames */
741 < int     first, last;
742 < char    *vfn;
740 > static void
741 > walkwait(               /* walk-through frames */
742 > int     first,
743 > int last,
744 > char    *vfn
745 > )
746   {
747 +        double  mblurf, dblurf;
748 +        int     nblur = getblur(&mblurf, &dblurf);
749          char    combuf[2048];
750 <        char    *inspoint;
750 >        register char   *inspoint;
751          register int    i;
752  
753          if (!noaction && vint(INTERP))          /* create dummy frames */
# Line 710 | Line 760 | char   *vfn;
760                                          /* create command */
761          sprintf(combuf, "rpict%s%s -w0", rendopt,
762                          viewopt(getview(first>1 ? first-1 : 1)));
763 <        if (vint(INTERP) || atoi(vval(MBLUR)))
764 <                sprintf(combuf+strlen(combuf), " -z %s.zbf", vval(BASENAME));
765 <        sprintf(combuf+strlen(combuf), " -o %s.unf %s -S %d",
763 >        inspoint = combuf;
764 >        while (*inspoint) inspoint++;
765 >        if (nblur) {
766 >                sprintf(inspoint, " -pm %.3f", mblurf/nblur);
767 >                while (*inspoint) inspoint++;
768 >                sprintf(inspoint, " -pd %.3f", dblurf/nblur);
769 >                while (*inspoint) inspoint++;
770 >        }
771 >        if (nblur > 1 || vint(INTERP)) {
772 >                sprintf(inspoint, " -z %s.zbf", vval(BASENAME));
773 >                while (*inspoint) inspoint++;
774 >        }
775 >        sprintf(inspoint, " -o %s.unf %s -S %d",
776                          vval(BASENAME), rresopt, first);
777 <        inspoint = combuf + strlen(combuf);
777 >        while (*inspoint) inspoint++;
778          sprintf(inspoint, " %s < %s", vval(OCTREE), vfn);
779                                          /* run in parallel */
780          i = (last-first+1)/(vint(INTERP)+1);
# Line 734 | Line 794 | char   *vfn;
794   }
795  
796  
797 < int
798 < recover(frame)                          /* recover the specified frame */
739 < int     frame;
797 > static int
798 > recover(int frame)                      /* recover the specified frame */
799   {
800          static int      *rfrm;          /* list of recovered frames */
801          static int      nrfrms = 0;
802 +        double  mblurf, dblurf;
803 +        int     nblur = getblur(&mblurf, &dblurf);
804          char    combuf[2048];
805          char    fname[128];
806          register char   *cp;
# Line 755 | Line 816 | int    frame;
816                                  vval(ANIMATE), frame, rendopt);
817          else
818                  sprintf(combuf, "rpict%s -w0", rendopt);
819 <        cp = combuf + strlen(combuf);
820 <        if (vint(INTERP) || atoi(vval(MBLUR))) {
819 >        cp = combuf;
820 >        while (*cp) cp++;
821 >        if (nblur) {
822 >                sprintf(cp, " -pm %.3f", mblurf/nblur);
823 >                while (*cp) cp++;
824 >                sprintf(cp, " -pd %.3f", dblurf/nblur);
825 >                while (*cp) cp++;
826 >        }
827 >        if (nblur > 1 || vint(INTERP)) {
828                  sprintf(cp, " -z %s.zbf", fname);
829                  while (*cp) cp++;
830          }
# Line 770 | Line 838 | int    frame;
838                  return(1);
839                                          /* add frame to recovered list */
840          if (nrfrms)
841 <                rfrm = (int *)realloc((char *)rfrm, (nrfrms+1)*sizeof(int));
841 >                rfrm = (int *)realloc((void *)rfrm, (nrfrms+1)*sizeof(int));
842          else
843                  rfrm = (int *)malloc(sizeof(int));
844          if (rfrm == NULL) {
# Line 782 | Line 850 | int    frame;
850   }
851  
852  
853 < int
854 < frecover(frame)                         /* recover filtered frame */
787 < int     frame;
853 > static int
854 > frecover(int frame)                             /* recover filtered frame */
855   {
856 <        VIEW    *vp;
790 <        char    *ex;
791 <
792 <        vp = getview(frame);
793 <        ex = getexp(frame);
794 <        if (dofilt(frame, vp, ex, 2) && dofilt(frame, vp, ex, 1))
856 >        if (dofilt(frame, 2) && dofilt(frame, 1))
857                  return(1);
858          return(0);
859   }
860  
861  
862 < archive()                       /* archive and remove renderings */
862 > static void
863 > archive(void)                   /* archive and remove renderings */
864   {
865   #define RMCOML  (sizeof(rmcom)-1)
866          static char     rmcom[] = "rm -f";
# Line 840 | Line 903 | archive()                      /* archive and remove renderings */
903   }
904  
905  
906 < int
907 < dofilt(frame, vp, ep, rvr)                      /* filter frame */
908 < int     frame;
909 < VIEW    *vp;
910 < char    *ep;
848 < int     rvr;
906 > static int
907 > dofilt(                         /* filter frame */
908 > int     frame,
909 > int     rvr
910 > )
911   {
850 –        extern int      frecover();
912          static int      iter = 0;
913 +        double  mblurf, dblurf;
914 +        int     nblur = getblur(&mblurf, &dblurf);
915 +        VIEW    *vp = getview(frame);
916 +        char    *ep = getexp(frame);
917          char    fnbefore[128], fnafter[128], *fbase;
918          char    combuf[1024], fname0[128], fname1[128];
919          int     usepinterp, usepfilt, nora_rgbe;
920          int     frseq[2];
921                                                  /* check what is needed */
922 <        usepinterp = atoi(vval(MBLUR));
923 <        usepfilt = pfiltalways | ep==NULL;
922 >        if (vp == NULL) {
923 >                 fprintf(stderr,
924 >                        "%s: unexpected error reading view for frame %d\n",
925 >                                          progname, frame);
926 >                quit(1);
927 >        }
928 >        usepinterp = (nblur > 1);
929 >        usepfilt = pfiltalways | (ep==NULL);
930          if (ep != NULL && !strcmp(ep, "1"))
931                  ep = "+0";
932          nora_rgbe = strcmp(vval(OVERSAMP),"1") || ep==NULL ||
# Line 899 | Line 970 | int    rvr;
970          if (usepinterp) {                       /* using pinterp */
971                  if (rvr == 2 && recover(frseq[1]))      /* recover after? */
972                          return(1);
973 <                if (atoi(vval(MBLUR))) {
973 >                if (nblur > 1) {                /* with pdmblur */
974                          sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
975                                          'a'+(iter%26));
976                          sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
# Line 926 | Line 997 | int    rvr;
997                                  putc('\n', fp); fclose(fp);
998                          }
999                          sprintf(combuf,
1000 <                        "(pmblur %s %d %s %s; rm -f %s %s) | pinterp -B",
1001 <                        *sskip(vval(MBLUR)) ? sskip2(vval(MBLUR),1) : "1",
931 <                                        atoi(vval(MBLUR)),
1000 >                        "(pmdblur %.3f %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
1001 >                                        mblurf, dblurf, nblur,
1002                                          fname0, fname1, fname0, fname1);
1003                          iter++;
1004                  } else                          /* no blurring */
# Line 942 | Line 1012 | int    rvr;
1012                  if (usepfilt)
1013                          sprintf(combuf+strlen(combuf), " %s", rresopt);
1014                  else
1015 <                        sprintf(combuf+strlen(combuf), " %s -e %s",
1015 >                        sprintf(combuf+strlen(combuf), " -a %s -e %s",
1016                                          fresopt, ep);
1017                  sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
1018                                  fnbefore, fnbefore);
# Line 989 | Line 1059 | int    rvr;
1059   }
1060  
1061  
1062 < VIEW *
1063 < getview(n)                      /* get view number n */
994 < int     n;
1062 > static VIEW *
1063 > getview(int n)                  /* get view number n */
1064   {
1065          static FILE     *viewfp = NULL;         /* view file pointer */
1066          static int      viewnum = 0;            /* current view number */
# Line 1003 | Line 1072 | int    n;
1072                          fclose(viewfp);
1073                          viewfp = NULL;
1074                          viewnum = 0;
1075 <                        copystruct(&curview, &stdview);
1075 >                        curview = stdview;
1076                  }
1077                  return(NULL);
1078          }
# Line 1019 | Line 1088 | int    n;
1088                          perror(vval(VIEWFILE));
1089                          quit(1);
1090                  }
1091 <                copystruct(&curview, &stdview);
1091 >                curview = stdview;
1092                  viewnum = 0;
1093          }
1094          if (n < 0) {                            /* get next view */
# Line 1039 | Line 1108 | int    n;
1108   }
1109  
1110  
1111 < int
1112 < countviews()                    /* count views in view file */
1111 > static int
1112 > countviews(void)                        /* count views in view file */
1113   {
1114          int     n;
1115  
# Line 1052 | Line 1121 | countviews()                   /* count views in view file */
1121   }
1122  
1123  
1124 < char *
1125 < getexp(n)                       /* get exposure for nth frame */
1057 < int     n;
1124 > static char *
1125 > getexp(int n)                   /* get exposure for nth frame */
1126   {
1127          extern char     *fskip();
1128          static char     expval[32];
# Line 1066 | Line 1134 | int    n;
1134          if (n == 0) {                           /* signal to close file */
1135                  if (expfp != NULL) {
1136                          fclose(expfp);
1137 <                        free((char *)exppos);
1137 >                        free((void *)exppos);
1138                          expfp = NULL;
1139                  }
1140                  return(NULL);
# Line 1123 | Line 1191 | int    n;
1191   }
1192  
1193  
1194 < struct pslot *
1195 < findpslot(pid)                  /* find or allocate a process slot */
1128 < int     pid;
1194 > static struct pslot *
1195 > findpslot(int pid)                      /* find or allocate a process slot */
1196   {
1197          register struct pslot   *psempty = NULL;
1198          register int    i;
# Line 1140 | Line 1207 | int    pid;
1207   }
1208  
1209  
1210 < int
1211 < donecom(ps, pn, status)         /* clean up after finished process */
1212 < PSERVER *ps;
1213 < int     pn;
1214 < int     status;
1210 > static int
1211 > donecom(                /* clean up after finished process */
1212 >        PSERVER *ps,
1213 >        int     pn,
1214 >        int     status
1215 > )
1216   {
1217 <        register PROC   *pp;
1217 >        register NETPROC        *pp;
1218          register struct pslot   *psl;
1219  
1220          pp = ps->proc + pn;
# Line 1181 | Line 1249 | int    status;
1249   }
1250  
1251  
1252 < int
1253 < serverdown()                    /* check status of last process server */
1252 > static int
1253 > serverdown(void)                        /* check status of last process server */
1254   {
1255          if (lastpserver == NULL || !lastpserver->hostname[0])
1256                  return(0);
# Line 1198 | Line 1266 | serverdown()                   /* check status of last process server
1266   }
1267  
1268  
1269 < int
1270 < bruncom(com, fout, rf)          /* run a command in the background */
1271 < char    *com;
1272 < int     fout;
1273 < int     (*rf)();
1269 > static int
1270 > bruncom(                /* run a command in the background */
1271 > char    *com,
1272 > int     fout,
1273 > int     (*rf)()
1274 > )
1275   {
1276          int     pid;
1277          register struct pslot   *psl;
# Line 1231 | Line 1300 | int    (*rf)();
1300   }
1301  
1302  
1303 < bwait(ncoms)                            /* wait for batch job(s) to finish */
1304 < int     ncoms;
1303 > static void
1304 > bwait(int ncoms)                                /* wait for batch job(s) to finish */
1305   {
1306          int     status;
1307  
# Line 1246 | Line 1315 | int    ncoms;
1315   }
1316  
1317  
1318 < int
1319 < pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1320 < char    *com, *ppins;
1321 < int     maxcopies;
1318 > static int
1319 > pruncom(        /* run a command in parallel over network */
1320 > char    *com,
1321 > char    *ppins,
1322 > int     maxcopies
1323 > )
1324   {
1325          int     retstatus = 0;
1326          int     hostcopies;
# Line 1271 | Line 1342 | int    maxcopies;
1342                          strcpy(com1=buf, com);  /* build -PP command */
1343                          sprintf(com1+(ppins-com), " -PP %s/%s.persist",
1344                                          vval(DIRECTORY), phostname(ps));
1345 +                        unlink(com1+(ppins-com)+5);
1346                          strcat(com1, ppins);
1347                  } else
1348                          com1 = com;
# Line 1315 | Line 1387 | int    maxcopies;
1387   }
1388  
1389  
1390 < runcom(cs)                      /* run a command locally and wait for it */
1391 < char    *cs;
1390 > static int
1391 > runcom(char *cs)                        /* run a command locally and wait for it */
1392   {
1393          if (!silent)            /* echo it */
1394                  printf("\t%s\n", cs);
# Line 1327 | Line 1399 | char   *cs;
1399   }
1400  
1401  
1402 < rmfile(fn)                      /* remove a file */
1403 < char    *fn;
1402 > static int
1403 > rmfile(char *fn)                        /* remove a file */
1404   {
1405          if (!silent)
1406 < #ifdef MSDOS
1406 > #ifdef _WIN32
1407                  printf("\tdel %s\n", fn);
1408   #else
1409                  printf("\trm -f %s\n", fn);
# Line 1342 | Line 1414 | char   *fn;
1414   }
1415  
1416  
1417 < badvalue(vc)                    /* report bad variable value and exit */
1418 < int     vc;
1417 > static void
1418 > badvalue(int vc)                        /* report bad variable value and exit */
1419   {
1420          fprintf(stderr, "%s: bad value for variable '%s'\n",
1421                          progname, vnam(vc));
# Line 1351 | Line 1423 | int    vc;
1423   }
1424  
1425  
1426 < char *
1427 < dirfile(df, path)               /* separate path into directory and file */
1428 < char    *df;
1429 < register char   *path;
1426 > static char *
1427 > dirfile(                /* separate path into directory and file */
1428 > char    *df,
1429 > register char   *path
1430 > )
1431   {
1432          register int    i;
1433          int     psep;
# Line 1362 | Line 1435 | register char  *path;
1435          for (i = 0, psep = -1; path[i]; i++)
1436                  if (path[i] == '/')
1437                          psep = i;
1438 <        if (df != NULL)
1438 >        if (df != NULL) {
1439                  if (psep == 0) {
1440                          df[0] = '/';
1441                          df[1] = '\0';
# Line 1371 | Line 1444 | register char  *path;
1444                          df[psep] = '\0';
1445                  } else
1446                          df[0] = '\0';
1447 +        }
1448          return(path+psep+1);
1449 + }
1450 +
1451 +
1452 + static int
1453 + getblur(double *mbf, double *dbf)       /* get # blur samples (and fraction) */
1454 + {
1455 +        double  mblurf, dblurf;
1456 +        int     nmblur, ndblur;
1457 +        char    *s;
1458 +                                        /* get motion blur */
1459 +        if (!vdef(MBLUR) || (mblurf = atof(vval(MBLUR))) < 0.0)
1460 +                mblurf = 0.0;
1461 +        if (mbf != NULL)
1462 +                *mbf = mblurf;
1463 +        if (mblurf <= FTINY)
1464 +                nmblur = 0;
1465 +        else if (!*(s = sskip(vval(MBLUR))))
1466 +                nmblur = DEF_NBLUR;
1467 +        else if ((nmblur = atoi(s)) <= 0)
1468 +                nmblur = 1;
1469 +                                        /* get depth-of-field blur */
1470 +        if (!vdef(DBLUR) || (dblurf = atof(vval(DBLUR))) < 0.0)
1471 +                dblurf = 0.0;
1472 +        if (dbf != NULL)
1473 +                *dbf = dblurf;
1474 +        if (dblurf <= FTINY)
1475 +                ndblur = 0;
1476 +        else if (!*(s = sskip(vval(DBLUR))))
1477 +                ndblur = DEF_NBLUR;
1478 +        else if ((ndblur = atoi(s)) <= 0)
1479 +                ndblur = 1;
1480 +        if ((nmblur == 1) & (ndblur == 1))
1481 +                return(1);
1482 +                                        /* return combined samples */
1483 +        return(nmblur + ndblur);
1484   }

Diff Legend

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