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.36 by greg, Sun Jun 1 15:21:57 2003 UTC vs.
Revision 2.50 by schorsch, Mon Sep 12 14:40:14 2005 UTC

# Line 15 | Line 15 | static const char RCSid[] = "$Id$";
15  
16   #include "copyright.h"
17  
18 < #include "standard.h"
18 > #include <stdio.h>
19   #include <ctype.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"
# Line 26 | Line 33 | static const char RCSid[] = "$Id$";
33   #define DEF_NBLUR       5
34   #endif
35                                  /* default remote shell */
36 < #ifdef _AUX_SOURCE
37 < #define REMSH           "remsh"
31 < #else
32 < #define REMSH           "rsh"
36 > #ifndef REMSH
37 > #define REMSH           "ssh"
38   #endif
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 DIRECTORY       3               /* working (sub)directory */
44 < #define DISKSPACE       4               /* how much disk space to use */
45 < #define END             5               /* ending frame number */
46 < #define EXPOSURE        6               /* how to compute exposure */
47 < #define HOST            7               /* rendering host machine */
48 < #define INTERP          8               /* # frames to interpolate */
49 < #define MBLUR           9               /* motion blur parameters */
50 < #define NEXTANIM        10              /* next animation file */
51 < #define OCTREE          11              /* octree file name */
52 < #define OVERSAMP        12              /* # times to oversample image */
53 < #define PFILT           13              /* pfilt options */
54 < #define PINTERP         14              /* pinterp options */
55 < #define RENDER          15              /* rendering options */
56 < #define RESOLUTION      16              /* desired final resolution */
57 < #define RIF             17              /* rad input file */
58 < #define RSH             18              /* remote shell script or program */
59 < #define RTRACE          19              /* use rtrace with pinterp? */
60 < #define START           20              /* starting frame number */
61 < #define TRANSFER        21              /* frame transfer command */
62 < #define VIEWFILE        22              /* animation frame views */
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 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 */
68          {"ANIMATE",     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},
# Line 88 | Line 95 | VARIABLE       vv[] = {                /* variable-value pairs */
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 112 | 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)
122 –
123 – struct pslot    *findpslot();
124 –
129   PSERVER *lastpserver;           /* last process server with error */
130  
131 < VIEW    *getview();
132 < char    *getexp(), *dirfile();
133 < int     getblur();
131 > static struct pslot * findpslot(RT_PID pid);
132 > static void checkdir(void);
133 > static VIEW * getview(int n);
134  
135 < extern time_t   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 196 | Line 228 | char   *argv[];
228                  quit(1);
229          }
230          quit(0);
231 +        return 0; /* pro forma return */
232   userr:
233          fprintf(stderr, "Usage: %s [-s][-n][-w][-e] anim_file\n", progname);
234          quit(1);
235 +        return 1; /* pro forma return */
236   }
237  
238  
239 < getastat()                      /* check/set animation status */
239 > static int
240 > getastat(void)                  /* check/set animation status */
241   {
242          char    sfname[256];
243          FILE    *fp;
# Line 266 | Line 301 | fmterr:
301   }
302  
303  
304 < putastat()                      /* put out current status */
304 > static void
305 > putastat(void)                  /* put out current status */
306   {
307          char    buf[256];
308          FILE    *fp;
# Line 288 | Line 324 | putastat()                     /* put out current status */
324   }
325  
326  
327 < checkdir()                      /* make sure we have our directory */
327 > static void
328 > checkdir(void)                  /* make sure we have our directory */
329   {
330          struct stat     stb;
331  
# Line 310 | Line 347 | checkdir()                     /* make sure we have our directory */
347   }
348  
349  
350 < setdefaults()                   /* set default values */
350 > static void
351 > setdefaults(void)                       /* set default values */
352   {
353          extern char     *atos();
354          int     decades;
# Line 398 | Line 436 | setdefaults()                  /* set default values */
436   }
437  
438  
439 < sethosts()                      /* set up process servers */
439 > static void
440 > sethosts(void)                  /* set up process servers */
441   {
442          extern char     *iskip();
443          char    buf[256], *dir, *uname;
# Line 453 | Line 492 | sethosts()                     /* set up process servers */
492          }
493   }
494  
495 <
496 < getradfile(rfargs)              /* run rad and get needed variables */
458 < char    *rfargs;
495 > static void
496 > getradfile(char *rfargs)                /* run rad and get needed variables */
497   {
498          static short    mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
499          char    combuf[256];
500          register int    i;
501          register char   *cp;
502 <        char    *pippt;
502 >        char    *pippt = NULL;
503                                          /* create rad command */
504          sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
505          sprintf(combuf,
# Line 480 | Line 518 | char   *rfargs;
518                          pippt = NULL;
519                  }
520          if (pippt != NULL)
521 <                strcpy(pippt, "> /dev/null");   /* nothing to match */
521 >                strcpy(pippt, "> " NULL_DEVICE);        /* nothing to match */
522          else {
523                  sprintf(cp, ")[ \t]*=' > %s/radset.var", vval(DIRECTORY));
524                  cp += 11;               /* point to file name */
# Line 493 | Line 531 | char   *rfargs;
531   }
532  
533  
534 < animate()                       /* run animation */
534 > static void
535 > animate(void)                   /* run animation */
536   {
537          int     xres, yres;
538          float   pa, mult;
# Line 533 | Line 572 | animate()                      /* run animation */
572          }
573                                          /* figure # frames per batch */
574          d1 = mult*xres*mult*yres*4;             /* space for orig. picture */
575 <        if ((i=vint(INTERP)) || getblur(NULL) > 1)
575 >        if ((i=vint(INTERP)) || getblur(NULL, NULL) > 1)
576                  d1 += mult*xres*mult*yres*sizeof(float);        /* Z-buffer */
577          d2 = xres*yres*4;                       /* space for final picture */
578          frames_batch = (i+1)*(vflt(DISKSPACE)*1048576.-d1)/(d1+i*d2);
# Line 564 | Line 603 | animate()                      /* run animation */
603   }
604  
605  
606 < renderframes(nframes)           /* render next nframes frames */
607 < int     nframes;
606 > static void
607 > renderframes(int nframes)               /* render next nframes frames */
608   {
609          static char     vendbuf[16];
610          VIEW    *vp;
# Line 621 | Line 660 | int    nframes;
660   }
661  
662  
663 < filterframes()                          /* catch up with filtering */
663 > static void
664 > filterframes(void)                              /* catch up with filtering */
665   {
626 –        VIEW    *vp;
666          register int    i;
667  
668          if (astat.tnext < astat.fnext)  /* other work to do first */
669                  return;
670                                          /* filter each view */
671 <        for (i = astat.fnext; i < astat.rnext; i++) {
672 <                if ((vp = getview(i)) == NULL) {        /* get view i */
673 <                        fprintf(stderr,
635 <                        "%s: unexpected error reading view for frame %d\n",
636 <                                        progname, i);
637 <                        quit(1);
638 <                }
639 <                dofilt(i, vp, getexp(i), 0);            /* filter frame */
640 <        }
671 >        for (i = astat.fnext; i < astat.rnext; i++)
672 >                dofilt(i, 0);
673 >
674          bwait(0);                       /* wait for filter processes */
675          archive();                      /* archive originals */
676          astat.fnext = i;                /* update status */
# Line 645 | Line 678 | filterframes()                         /* catch up with filtering */
678   }
679  
680  
681 < transferframes()                        /* catch up with picture transfers */
681 > static void
682 > transferframes(void)                    /* catch up with picture transfers */
683   {
684          char    combuf[10240], *fbase;
685          register char   *cp;
# Line 685 | Line 719 | transferframes()                       /* catch up with picture transfers
719   }
720  
721  
722 < animrend(frame, vp)                     /* start animation frame */
723 < int     frame;
724 < VIEW    *vp;
722 > static void
723 > animrend(                       /* start animation frame */
724 > int     frame,
725 > VIEW    *vp
726 > )
727   {
692 –        extern int      recover();
728          char    combuf[2048];
729          char    fname[128];
730  
# Line 703 | Line 738 | VIEW   *vp;
738   }
739  
740  
741 < walkwait(first, last, vfn)              /* walk-through frames */
742 < int     first, last;
743 < char    *vfn;
741 > static void
742 > walkwait(               /* walk-through frames */
743 > int     first,
744 > int last,
745 > char    *vfn
746 > )
747   {
748 <        double  blurf;
749 <        int     nblur = getblur(&blurf);
748 >        double  mblurf, dblurf;
749 >        int     nblur = getblur(&mblurf, &dblurf);
750          char    combuf[2048];
751          register char   *inspoint;
752          register int    i;
# Line 726 | Line 764 | char   *vfn;
764          inspoint = combuf;
765          while (*inspoint) inspoint++;
766          if (nblur) {
767 <                sprintf(inspoint, " -pm %.3f", blurf/nblur);
767 >                sprintf(inspoint, " -pm %.3f", mblurf/nblur);
768                  while (*inspoint) inspoint++;
769 +                sprintf(inspoint, " -pd %.3f", dblurf/nblur);
770 +                while (*inspoint) inspoint++;
771          }
772          if (nblur > 1 || vint(INTERP)) {
773                  sprintf(inspoint, " -z %s.zbf", vval(BASENAME));
# Line 755 | Line 795 | char   *vfn;
795   }
796  
797  
798 < int
799 < recover(frame)                          /* recover the specified frame */
760 < int     frame;
798 > static int
799 > recover(int frame)                      /* recover the specified frame */
800   {
801          static int      *rfrm;          /* list of recovered frames */
802          static int      nrfrms = 0;
803 <        double  blurf;
804 <        int     nblur = getblur(&blurf);
803 >        double  mblurf, dblurf;
804 >        int     nblur = getblur(&mblurf, &dblurf);
805          char    combuf[2048];
806          char    fname[128];
807          register char   *cp;
# Line 781 | Line 820 | int    frame;
820          cp = combuf;
821          while (*cp) cp++;
822          if (nblur) {
823 <                sprintf(cp, " -pm %.3f", blurf/nblur);
823 >                sprintf(cp, " -pm %.3f", mblurf/nblur);
824                  while (*cp) cp++;
825 +                sprintf(cp, " -pd %.3f", dblurf/nblur);
826 +                while (*cp) cp++;
827          }
828          if (nblur > 1 || vint(INTERP)) {
829                  sprintf(cp, " -z %s.zbf", fname);
# Line 810 | Line 851 | int    frame;
851   }
852  
853  
854 < int
855 < frecover(frame)                         /* recover filtered frame */
815 < int     frame;
854 > static int
855 > frecover(int frame)                             /* recover filtered frame */
856   {
857 <        VIEW    *vp;
818 <        char    *ex;
819 <
820 <        vp = getview(frame);
821 <        ex = getexp(frame);
822 <        if (dofilt(frame, vp, ex, 2) && dofilt(frame, vp, ex, 1))
857 >        if (dofilt(frame, 2) && dofilt(frame, 1))
858                  return(1);
859          return(0);
860   }
861  
862  
863 < archive()                       /* archive and remove renderings */
863 > static void
864 > archive(void)                   /* archive and remove renderings */
865   {
866   #define RMCOML  (sizeof(rmcom)-1)
867          static char     rmcom[] = "rm -f";
# Line 868 | Line 904 | archive()                      /* archive and remove renderings */
904   }
905  
906  
907 < int
908 < dofilt(frame, vp, ep, rvr)                      /* filter frame */
909 < int     frame;
910 < VIEW    *vp;
911 < char    *ep;
876 < int     rvr;
907 > static int
908 > dofilt(                         /* filter frame */
909 > int     frame,
910 > int     rvr
911 > )
912   {
878 –        extern int      frecover();
913          static int      iter = 0;
914 <        double  blurf;
915 <        int     nblur = getblur(&blurf);
914 >        double  mblurf, dblurf;
915 >        int     nblur = getblur(&mblurf, &dblurf);
916 >        VIEW    *vp = getview(frame);
917 >        char    *ep = getexp(frame);
918          char    fnbefore[128], fnafter[128], *fbase;
919          char    combuf[1024], fname0[128], fname1[128];
920          int     usepinterp, usepfilt, nora_rgbe;
921          int     frseq[2];
922                                                  /* check what is needed */
923 +        if (vp == NULL) {
924 +                 fprintf(stderr,
925 +                        "%s: unexpected error reading view for frame %d\n",
926 +                                          progname, frame);
927 +                quit(1);
928 +        }
929          usepinterp = (nblur > 1);
930 <        usepfilt = pfiltalways | ep==NULL;
930 >        usepfilt = pfiltalways | (ep==NULL);
931          if (ep != NULL && !strcmp(ep, "1"))
932                  ep = "+0";
933          nora_rgbe = strcmp(vval(OVERSAMP),"1") || ep==NULL ||
# Line 929 | Line 971 | int    rvr;
971          if (usepinterp) {                       /* using pinterp */
972                  if (rvr == 2 && recover(frseq[1]))      /* recover after? */
973                          return(1);
974 <                if (nblur > 1) {                /* with pmblur */
974 >                if (nblur > 1) {                /* with pdmblur */
975                          sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
976                                          'a'+(iter%26));
977                          sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
# Line 956 | Line 998 | int    rvr;
998                                  putc('\n', fp); fclose(fp);
999                          }
1000                          sprintf(combuf,
1001 <                        "(pmblur %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
1002 <                                        blurf, nblur,
1001 >                        "(pmdblur %.3f %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
1002 >                                        mblurf, dblurf, nblur,
1003                                          fname0, fname1, fname0, fname1);
1004                          iter++;
1005                  } else                          /* no blurring */
# Line 1018 | Line 1060 | int    rvr;
1060   }
1061  
1062  
1063 < VIEW *
1064 < getview(n)                      /* get view number n */
1023 < int     n;
1063 > static VIEW *
1064 > getview(int n)                  /* get view number n */
1065   {
1066          static FILE     *viewfp = NULL;         /* view file pointer */
1067          static int      viewnum = 0;            /* current view number */
# Line 1032 | Line 1073 | int    n;
1073                          fclose(viewfp);
1074                          viewfp = NULL;
1075                          viewnum = 0;
1076 <                        copystruct(&curview, &stdview);
1076 >                        curview = stdview;
1077                  }
1078                  return(NULL);
1079          }
# Line 1048 | Line 1089 | int    n;
1089                          perror(vval(VIEWFILE));
1090                          quit(1);
1091                  }
1092 <                copystruct(&curview, &stdview);
1092 >                curview = stdview;
1093                  viewnum = 0;
1094          }
1095          if (n < 0) {                            /* get next view */
# Line 1068 | Line 1109 | int    n;
1109   }
1110  
1111  
1112 < int
1113 < countviews()                    /* count views in view file */
1112 > static int
1113 > countviews(void)                        /* count views in view file */
1114   {
1115          int     n;
1116  
# Line 1081 | Line 1122 | countviews()                   /* count views in view file */
1122   }
1123  
1124  
1125 < char *
1126 < getexp(n)                       /* get exposure for nth frame */
1086 < int     n;
1125 > static char *
1126 > getexp(int n)                   /* get exposure for nth frame */
1127   {
1128          extern char     *fskip();
1129          static char     expval[32];
# Line 1152 | Line 1192 | int    n;
1192   }
1193  
1194  
1195 < struct pslot *
1196 < findpslot(pid)                  /* find or allocate a process slot */
1157 < int     pid;
1195 > static struct pslot *
1196 > findpslot(RT_PID pid)                   /* find or allocate a process slot */
1197   {
1198          register struct pslot   *psempty = NULL;
1199          register int    i;
# Line 1169 | Line 1208 | int    pid;
1208   }
1209  
1210  
1211 < int
1212 < donecom(ps, pn, status)         /* clean up after finished process */
1213 < PSERVER *ps;
1214 < int     pn;
1215 < int     status;
1211 > static int
1212 > donecom(                /* clean up after finished process */
1213 >        PSERVER *ps,
1214 >        int     pn,
1215 >        int     status
1216 > )
1217   {
1218 <        register PROC   *pp;
1218 >        register NETPROC        *pp;
1219          register struct pslot   *psl;
1220  
1221          pp = ps->proc + pn;
# Line 1210 | Line 1250 | int    status;
1250   }
1251  
1252  
1253 < int
1254 < serverdown()                    /* check status of last process server */
1253 > static int
1254 > serverdown(void)                        /* check status of last process server */
1255   {
1256          if (lastpserver == NULL || !lastpserver->hostname[0])
1257                  return(0);
# Line 1227 | Line 1267 | serverdown()                   /* check status of last process server
1267   }
1268  
1269  
1270 < int
1271 < bruncom(com, fout, rf)          /* run a command in the background */
1272 < char    *com;
1273 < int     fout;
1274 < int     (*rf)();
1270 > static RT_PID
1271 > bruncom(                /* run a command in the background */
1272 > char    *com,
1273 > int     fout,
1274 > int     (*rf)()
1275 > )
1276   {
1277 <        int     pid;
1277 >        RT_PID  pid;
1278          register struct pslot   *psl;
1279  
1280          if (noaction) {
# Line 1246 | Line 1287 | int    (*rf)();
1287                  bwait(1);
1288          if (!silent) {                          /* echo command */
1289                  PSERVER *ps;
1290 <                int     psn = pid;
1290 >                RT_PID  psn = pid;
1291                  ps = findjob(&psn);
1292                  printf("\t%s\n", com);
1293                  printf("\tProcess started on %s\n", phostname(ps));
# Line 1260 | Line 1301 | int    (*rf)();
1301   }
1302  
1303  
1304 < bwait(ncoms)                            /* wait for batch job(s) to finish */
1305 < int     ncoms;
1304 > static void
1305 > bwait(int ncoms)                                /* wait for batch job(s) to finish */
1306   {
1307          int     status;
1308  
# Line 1275 | Line 1316 | int    ncoms;
1316   }
1317  
1318  
1319 < int
1320 < pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1321 < char    *com, *ppins;
1322 < int     maxcopies;
1319 > static int
1320 > pruncom(        /* run a command in parallel over network */
1321 > char    *com,
1322 > char    *ppins,
1323 > int     maxcopies
1324 > )
1325   {
1326          int     retstatus = 0;
1327          int     hostcopies;
# Line 1345 | Line 1388 | int    maxcopies;
1388   }
1389  
1390  
1391 < runcom(cs)                      /* run a command locally and wait for it */
1392 < char    *cs;
1391 > static int
1392 > runcom(char *cs)                        /* run a command locally and wait for it */
1393   {
1394          if (!silent)            /* echo it */
1395                  printf("\t%s\n", cs);
# Line 1357 | Line 1400 | char   *cs;
1400   }
1401  
1402  
1403 < rmfile(fn)                      /* remove a file */
1404 < char    *fn;
1403 > static int
1404 > rmfile(char *fn)                        /* remove a file */
1405   {
1406          if (!silent)
1407 < #ifdef MSDOS
1407 > #ifdef _WIN32
1408                  printf("\tdel %s\n", fn);
1409   #else
1410                  printf("\trm -f %s\n", fn);
# Line 1372 | Line 1415 | char   *fn;
1415   }
1416  
1417  
1418 < badvalue(vc)                    /* report bad variable value and exit */
1419 < int     vc;
1418 > static void
1419 > badvalue(int vc)                        /* report bad variable value and exit */
1420   {
1421          fprintf(stderr, "%s: bad value for variable '%s'\n",
1422                          progname, vnam(vc));
# Line 1381 | Line 1424 | int    vc;
1424   }
1425  
1426  
1427 < char *
1428 < dirfile(df, path)               /* separate path into directory and file */
1429 < char    *df;
1430 < register char   *path;
1427 > static char *
1428 > dirfile(                /* separate path into directory and file */
1429 > char    *df,
1430 > register char   *path
1431 > )
1432   {
1433          register int    i;
1434          int     psep;
# Line 1392 | Line 1436 | register char  *path;
1436          for (i = 0, psep = -1; path[i]; i++)
1437                  if (path[i] == '/')
1438                          psep = i;
1439 <        if (df != NULL)
1439 >        if (df != NULL) {
1440                  if (psep == 0) {
1441                          df[0] = '/';
1442                          df[1] = '\0';
# Line 1401 | Line 1445 | register char  *path;
1445                          df[psep] = '\0';
1446                  } else
1447                          df[0] = '\0';
1448 +        }
1449          return(path+psep+1);
1450   }
1451  
1452  
1453 < int
1454 < getblur(double *bf)             /* get # blur samples (and fraction) */
1453 > static int
1454 > getblur(double *mbf, double *dbf)       /* get # blur samples (and fraction) */
1455   {
1456 <        double  blurf;
1457 <        int     nblur;
1456 >        double  mblurf, dblurf;
1457 >        int     nmblur, ndblur;
1458          char    *s;
1459 <
1460 <        if (!vdef(MBLUR)) {
1461 <                if (bf != NULL)
1462 <                        *bf = 0.0;
1463 <                return(0);
1464 <        }
1465 <        blurf = atof(vval(MBLUR));
1466 <        if (blurf < 0.0)
1467 <                blurf = 0.0;
1468 <        if (bf != NULL)
1469 <                *bf = blurf;
1470 <        if (blurf <= FTINY)
1471 <                return(0);
1472 <        s = sskip(vval(MBLUR));
1473 <        if (!*s)
1474 <                return(DEF_NBLUR);
1475 <        nblur = atoi(s);
1476 <        if (nblur <= 0)
1459 >                                        /* get motion blur */
1460 >        if (!vdef(MBLUR) || (mblurf = atof(vval(MBLUR))) < 0.0)
1461 >                mblurf = 0.0;
1462 >        if (mbf != NULL)
1463 >                *mbf = mblurf;
1464 >        if (mblurf <= FTINY)
1465 >                nmblur = 0;
1466 >        else if (!*(s = sskip(vval(MBLUR))))
1467 >                nmblur = DEF_NBLUR;
1468 >        else if ((nmblur = atoi(s)) <= 0)
1469 >                nmblur = 1;
1470 >                                        /* get depth-of-field blur */
1471 >        if (!vdef(DBLUR) || (dblurf = atof(vval(DBLUR))) < 0.0)
1472 >                dblurf = 0.0;
1473 >        if (dbf != NULL)
1474 >                *dbf = dblurf;
1475 >        if (dblurf <= FTINY)
1476 >                ndblur = 0;
1477 >        else if (!*(s = sskip(vval(DBLUR))))
1478 >                ndblur = DEF_NBLUR;
1479 >        else if ((ndblur = atoi(s)) <= 0)
1480 >                ndblur = 1;
1481 >        if ((nmblur == 1) & (ndblur == 1))
1482                  return(1);
1483 <        return(nblur);
1483 >                                        /* return combined samples */
1484 >        return(nmblur + ndblur);
1485   }

Diff Legend

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