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.45 by greg, Sun Feb 15 06:21:01 2004 UTC vs.
Revision 2.60 by greg, Sat Jun 7 05:09:46 2025 UTC

# Line 19 | Line 19 | static const char RCSid[] = "$Id$";
19   #include <ctype.h>
20   #include <sys/stat.h>
21   #include <time.h>
22 + #include <signal.h>
23  
23 – /*#include "standard.h"*/
24   #include "platform.h"
25 < #include "paths.h"
26 < #include "rtio.h"
27 < #include "rterror.h"
25 > #include "rtprocess.h"
26 > #include "standard.h"
27   #include "view.h"
28   #include "vars.h"
29   #include "netproc.h"
# Line 33 | Line 32 | static const char RCSid[] = "$Id$";
32   #define DEF_NBLUR       5
33   #endif
34                                  /* default remote shell */
35 < #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               /* motion blur parameters */
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 <        {"DIRECTORY",   3,      0,      NULL,   onevalue},
69 >        {"BASENAME",    3,      0,      NULL,   strvalue},
70 >        {"DBLUR",       2,      0,      NULL,   onevalue},
71 >        {"DIRECTORY",   3,      0,      NULL,   strvalue},
72          {"DISKSPACE",   3,      0,      NULL,   fltvalue},
73          {"END",         2,      0,      NULL,   intvalue},
74          {"EXPOSURE",    3,      0,      NULL,   onevalue},
75          {"host",        4,      0,      NULL,   NULL},
76          {"INTERPOLATE", 3,      0,      NULL,   intvalue},
77          {"MBLUR",       2,      0,      NULL,   onevalue},
78 <        {"NEXTANIM",    3,      0,      NULL,   onevalue},
79 <        {"OCTREE",      3,      0,      NULL,   onevalue},
78 >        {"NEXTANIM",    3,      0,      NULL,   strvalue},
79 >        {"OCTREE",      3,      0,      NULL,   strvalue},
80          {"OVERSAMPLE",  2,      0,      NULL,   fltvalue},
81          {"pfilt",       2,      0,      NULL,   catvalues},
82          {"pinterp",     2,      0,      NULL,   catvalues},
83          {"render",      3,      0,      NULL,   catvalues},
84          {"RESOLUTION",  3,      0,      NULL,   onevalue},
85 <        {"RIF",         3,      0,      NULL,   onevalue},
85 >        {"RIF",         3,      0,      NULL,   strvalue},
86          {"RSH",         3,      0,      NULL,   onevalue},
87          {"RTRACE",      2,      0,      NULL,   boolvalue},
88          {"START",       2,      0,      NULL,   intvalue},
89          {"TRANSFER",    2,      0,      NULL,   onevalue},
90 <        {"VIEWFILE",    2,      0,      NULL,   onevalue},
90 >        {"VIEWFILE",    2,      0,      NULL,   strvalue},
91   };
92  
93   #define SFNAME  "STATUS"                /* status file name */
94  
95   struct {
96          char    host[64];               /* control host name */
97 <        int     pid;                    /* control process id */
97 >        RT_PID  pid;                    /* control process id */
98          char    cfname[128];            /* control file name */
99          int     rnext;                  /* next frame to render */
100          int     fnext;                  /* next frame to filter */
101          int     tnext;                  /* next frame to transfer */
102   }       astat;                  /* animation status */
103  
101 – char    *progname;              /* our program name */
104   char    *cfname;                /* our control file name */
105  
106   int     nowarn = 0;             /* turn warnings off? */
# Line 115 | Line 117 | char   arcargs[10240];         /* files to archive */
117   char    *arcfirst, *arcnext;    /* pointers to first and next argument */
118  
119   struct pslot {
120 <        int     pid;                    /* process ID (0 if empty) */
120 >        RT_PID  pid;                    /* process ID (0 if empty) */
121          int     fout;                   /* output frame number */
122          int     (*rcvf)();              /* recover function */
123   }       *pslot;                 /* process slots */
# Line 124 | Line 126 | int    npslots;                /* number of process slots */
126   #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
127   PSERVER *lastpserver;           /* last process server with error */
128  
129 < static struct pslot * findpslot(int pid);
129 > static struct pslot * findpslot(RT_PID pid);
130   static void checkdir(void);
131   static VIEW * getview(int n);
132  
133   static char * dirfile(char *df, register char *path);
134   static char * getexp(int n);
135 < static int getblur(double *bf);
135 > static int getblur(double *mbf, double *dbf);
136   static int getastat(void);
137   static void getradfile(char *rfargs);
138   static void badvalue(int vc);
# Line 138 | Line 140 | static int rmfile(char *fn);
140   static int runcom(char *cs);
141   static int pruncom(char *com, char *ppins, int maxcopies);
142   static void bwait(int ncoms);
143 < static int bruncom(char *com, int fout, int (*rf)());
143 > static RT_PID bruncom(char *com, int fout, int (*rf)());
144   static int serverdown(void);
145 < static int donecom(PSERVER *ps, int pn, int status);
145 > static pscompfunc donecom;
146   static int countviews(void);
147   static int dofilt(int frame, int rvr);
148   static void archive(void);
# Line 157 | Line 159 | static void setdefaults(void);
159   static void putastat(void);
160  
161  
162 < main(argc, argv)
163 < int     argc;
164 < char    *argv[];
162 > int
163 > main(
164 >        int     argc,
165 >        char    *argv[]
166 > )
167   {
168          int     explicate = 0;
169          int     i;
170 <
171 <        progname = argv[0];                     /* get arguments */
170 >                                                /* set global progname */
171 >        fixargv0(argv[0]);
172 >                                                /* get arguments */
173          for (i = 1; i < argc && argv[i][0] == '-'; i++)
174                  switch (argv[i][1]) {
175                  case 'e':                       /* print variables */
# Line 212 | Line 217 | char   *argv[];
217          animate();
218                                                  /* all done */
219          if (vdef(NEXTANIM)) {
220 +                char    *fullp;
221                  argv[i] = vval(NEXTANIM);       /* just change input file */
222                  if (!silent)
223                          printargs(argc, argv, stdout);
224 <                if ((argv[0] = getpath(progname,getenv("PATH"),X_OK)) == NULL)
225 <                        fprintf(stderr, "%s: command not found\n", progname);
224 >                fflush(stdout);
225 >                if ((fullp = getpath(argv[0],getenv("PATH"),X_OK)) == NULL)
226 >                        fprintf(stderr, "%s: command not found\n", argv[0]);
227                  else
228 <                        execv(progname, argv);
228 >                        execv(fullp, argv);
229                  quit(1);
230          }
231          quit(0);
232 +        return(0); /* pro forma return */
233   userr:
234          fprintf(stderr, "Usage: %s [-s][-n][-w][-e] anim_file\n", progname);
235          quit(1);
236 +        return 1; /* pro forma return */
237   }
238  
239  
# Line 406 | Line 415 | setdefaults(void)                      /* set default values */
415          if (!vdef(DISKSPACE)) {
416                  if (!nowarn)
417                          fprintf(stderr,
418 <                "%s: warning - no %s setting, assuming 100 Mbytes available\n",
418 >                "%s: warning - no %s setting, assuming 1000 Mbytes available\n",
419                                          progname, vnam(DISKSPACE));
420 <                vval(DISKSPACE) = "100";
420 >                vval(DISKSPACE) = "1000";
421                  vdef(DISKSPACE)++;
422          }
423          if (!vdef(RSH)) {
# Line 491 | Line 500 | getradfile(char *rfargs)               /* run rad and get needed va
500          char    combuf[256];
501          register int    i;
502          register char   *cp;
503 <        char    *pippt;
503 >        char    *pippt = NULL;
504                                          /* create rad command */
505          sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
506          sprintf(combuf,
# Line 564 | Line 573 | animate(void)                  /* run animation */
573          }
574                                          /* figure # frames per batch */
575          d1 = mult*xres*mult*yres*4;             /* space for orig. picture */
576 <        if ((i=vint(INTERP)) || getblur(NULL) > 1)
576 >        if ((i=vint(INTERP)) || getblur(NULL, NULL) > 1)
577                  d1 += mult*xres*mult*yres*sizeof(float);        /* Z-buffer */
578          d2 = xres*yres*4;                       /* space for final picture */
579          frames_batch = (i+1)*(vflt(DISKSPACE)*1048576.-d1)/(d1+i*d2);
# Line 655 | Line 664 | renderframes(int nframes)              /* render next nframes fram
664   static void
665   filterframes(void)                              /* catch up with filtering */
666   {
658 –        VIEW    *vp;
667          register int    i;
668  
669          if (astat.tnext < astat.fnext)  /* other work to do first */
# Line 699 | Line 707 | transferframes(void)                   /* catch up with picture transf
707                  *cp++ = ' ';
708                  sprintf(cp, fbase, i);
709                  while (*cp) cp++;
710 <                strcpy(cp, ".pic");
710 >                strcpy(cp, ".hdr");
711                  cp += 4;
712          }
713          if (runcom(combuf)) {           /* transfer frames */
# Line 738 | Line 746 | int last,
746   char    *vfn
747   )
748   {
749 <        double  blurf;
750 <        int     nblur = getblur(&blurf);
749 >        double  mblurf, dblurf;
750 >        int     nblur = getblur(&mblurf, &dblurf);
751          char    combuf[2048];
752          register char   *inspoint;
753          register int    i;
# Line 757 | Line 765 | char   *vfn
765          inspoint = combuf;
766          while (*inspoint) inspoint++;
767          if (nblur) {
768 <                sprintf(inspoint, " -pm %.3f", blurf/nblur);
768 >                sprintf(inspoint, " -pm %.3f", mblurf/nblur);
769                  while (*inspoint) inspoint++;
770 +                sprintf(inspoint, " -pd %.3f", dblurf/nblur);
771 +                while (*inspoint) inspoint++;
772          }
773          if (nblur > 1 || vint(INTERP)) {
774                  sprintf(inspoint, " -z %s.zbf", vval(BASENAME));
# Line 791 | Line 801 | recover(int frame)                     /* recover the specified frame */
801   {
802          static int      *rfrm;          /* list of recovered frames */
803          static int      nrfrms = 0;
804 <        double  blurf;
805 <        int     nblur = getblur(&blurf);
804 >        double  mblurf, dblurf;
805 >        int     nblur = getblur(&mblurf, &dblurf);
806          char    combuf[2048];
807          char    fname[128];
808          register char   *cp;
# Line 811 | Line 821 | recover(int frame)                     /* recover the specified frame */
821          cp = combuf;
822          while (*cp) cp++;
823          if (nblur) {
824 <                sprintf(cp, " -pm %.3f", blurf/nblur);
824 >                sprintf(cp, " -pm %.3f", mblurf/nblur);
825                  while (*cp) cp++;
826 +                sprintf(cp, " -pd %.3f", dblurf/nblur);
827 +                while (*cp) cp++;
828          }
829          if (nblur > 1 || vint(INTERP)) {
830                  sprintf(cp, " -z %s.zbf", fname);
# Line 900 | Line 912 | int    rvr
912   )
913   {
914          static int      iter = 0;
915 <        double  blurf;
916 <        int     nblur = getblur(&blurf);
915 >        double  mblurf, dblurf;
916 >        int     nblur = getblur(&mblurf, &dblurf);
917          VIEW    *vp = getview(frame);
918          char    *ep = getexp(frame);
919          char    fnbefore[128], fnafter[128], *fbase;
# Line 933 | Line 945 | int    rvr
945                  usepfilt |= nora_rgbe;
946          } else if (frseq[0] == frame) {         /* no interpolation needed */
947                  if (!rvr && frame > 1+vint(INTERP)) {   /* archive previous */
948 +                        if (arcnext - arcargs +
949 +                                        strlen(fbase) >= sizeof(arcargs)-8) {
950 +                                fprintf(stderr,
951 + "%s: too many filenames in archive command -- reduce %s variable\n",
952 +                                                progname, vnam(DISKSPACE));
953 +                                quit(1);
954 +                        }
955                          *arcnext++ = ' ';
956                          sprintf(arcnext, fbase, frame-vint(INTERP)-1);
957                          while (*arcnext) arcnext++;
# Line 960 | Line 979 | int    rvr
979          if (usepinterp) {                       /* using pinterp */
980                  if (rvr == 2 && recover(frseq[1]))      /* recover after? */
981                          return(1);
982 <                if (nblur > 1) {                /* with pmblur */
982 >                if (nblur > 1) {                /* with pdmblur */
983                          sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
984                                          'a'+(iter%26));
985                          sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
# Line 987 | Line 1006 | int    rvr
1006                                  putc('\n', fp); fclose(fp);
1007                          }
1008                          sprintf(combuf,
1009 <                        "(pmblur %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
1010 <                                        blurf, nblur,
1009 >                        "(pmdblur %.3f %.3f %d %s %s; rm -f %s %s) | pinterp -B -a",
1010 >                                        mblurf, dblurf, nblur,
1011                                          fname0, fname1, fname0, fname1);
1012                          iter++;
1013                  } else                          /* no blurring */
# Line 1041 | Line 1060 | int    rvr
1060          }
1061                                                  /* output file name */
1062          sprintf(fname0, vval(BASENAME), frame);
1063 <        sprintf(combuf+strlen(combuf), " > %s.pic", fname0);
1063 >        sprintf(combuf+strlen(combuf), " > %s.hdr", fname0);
1064          if (rvr)                                /* in recovery */
1065                  return(runcom(combuf));
1066          bruncom(combuf, frame, frecover);       /* else run in background */
# Line 1114 | Line 1133 | countviews(void)                       /* count views in view file */
1133   static char *
1134   getexp(int n)                   /* get exposure for nth frame */
1135   {
1117 –        extern char     *fskip();
1136          static char     expval[32];
1137          static FILE     *expfp = NULL;
1138          static long     *exppos;
# Line 1182 | Line 1200 | getexp(int n)                  /* get exposure for nth frame */
1200  
1201  
1202   static struct pslot *
1203 < findpslot(int pid)                      /* find or allocate a process slot */
1203 > findpslot(RT_PID pid)                   /* find or allocate a process slot */
1204   {
1205          register struct pslot   *psempty = NULL;
1206          register int    i;
# Line 1199 | Line 1217 | findpslot(int pid)                     /* find or allocate a process slo
1217  
1218   static int
1219   donecom(                /* clean up after finished process */
1220 < PSERVER *ps,
1221 < int     pn,
1222 < int     status
1220 >        PSERVER *ps,
1221 >        int     pn,
1222 >        int     status
1223   )
1224   {
1225          register NETPROC        *pp;
# Line 1256 | Line 1274 | serverdown(void)                       /* check status of last process ser
1274   }
1275  
1276  
1277 < static int
1277 > static RT_PID
1278   bruncom(                /* run a command in the background */
1279   char    *com,
1280   int     fout,
1281   int     (*rf)()
1282   )
1283   {
1284 <        int     pid;
1284 >        RT_PID  pid;
1285          register struct pslot   *psl;
1286  
1287          if (noaction) {
# Line 1276 | Line 1294 | int    (*rf)()
1294                  bwait(1);
1295          if (!silent) {                          /* echo command */
1296                  PSERVER *ps;
1297 <                int     psn = pid;
1297 >                RT_PID  psn = pid;
1298                  ps = findjob(&psn);
1299                  printf("\t%s\n", com);
1300                  printf("\tProcess started on %s\n", phostname(ps));
# Line 1393 | Line 1411 | static int
1411   rmfile(char *fn)                        /* remove a file */
1412   {
1413          if (!silent)
1414 < #ifdef _WIN32
1414 > #if defined(_WIN32) || defined(_WIN64)
1415                  printf("\tdel %s\n", fn);
1416   #else
1417                  printf("\trm -f %s\n", fn);
# Line 1440 | Line 1458 | register char  *path
1458  
1459  
1460   static int
1461 < getblur(double *bf)             /* get # blur samples (and fraction) */
1461 > getblur(double *mbf, double *dbf)       /* get # blur samples (and fraction) */
1462   {
1463 <        double  blurf;
1464 <        int     nblur;
1463 >        double  mblurf, dblurf;
1464 >        int     nmblur, ndblur;
1465          char    *s;
1466 <
1467 <        if (!vdef(MBLUR)) {
1468 <                if (bf != NULL)
1469 <                        *bf = 0.0;
1470 <                return(0);
1471 <        }
1472 <        blurf = atof(vval(MBLUR));
1473 <        if (blurf < 0.0)
1474 <                blurf = 0.0;
1475 <        if (bf != NULL)
1476 <                *bf = blurf;
1477 <        if (blurf <= FTINY)
1478 <                return(0);
1479 <        s = sskip(vval(MBLUR));
1480 <        if (!*s)
1481 <                return(DEF_NBLUR);
1482 <        nblur = atoi(s);
1483 <        if (nblur <= 0)
1466 >                                        /* get motion blur */
1467 >        if (vdef(ANIMATE) || !vdef(MBLUR) || (mblurf = atof(vval(MBLUR))) < 0.0)
1468 >                mblurf = 0.0;
1469 >        if (mbf != NULL)
1470 >                *mbf = mblurf;
1471 >        if (mblurf <= FTINY)
1472 >                nmblur = 0;
1473 >        else if (!*(s = sskip(vval(MBLUR))))
1474 >                nmblur = DEF_NBLUR;
1475 >        else if ((nmblur = atoi(s)) <= 0)
1476 >                nmblur = 1;
1477 >                                        /* get depth-of-field blur */
1478 >        if (!vdef(DBLUR) || (dblurf = atof(vval(DBLUR))) < 0.0)
1479 >                dblurf = 0.0;
1480 >        if (dbf != NULL)
1481 >                *dbf = dblurf;
1482 >        if (dblurf <= FTINY)
1483 >                ndblur = 0;
1484 >        else if (!*(s = sskip(vval(DBLUR))))
1485 >                ndblur = DEF_NBLUR;
1486 >        else if ((ndblur = atoi(s)) <= 0)
1487 >                ndblur = 1;
1488 >        if ((nmblur == 1) & (ndblur == 1))
1489                  return(1);
1490 <        return(nblur);
1490 >                                        /* return combined samples */
1491 >        return(nmblur + ndblur);
1492   }

Diff Legend

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