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.46 by schorsch, Fri Mar 26 21:36:20 2004 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 "paths.h"
26 + #include "rtio.h"
27 + #include "rterror.h"
28 + #include "rtmisc.h"
29   #include "view.h"
30   #include "vars.h"
31   #include "netproc.h"
# Line 26 | Line 34 | static const char RCSid[] = "$Id$";
34   #define DEF_NBLUR       5
35   #endif
36                                  /* default remote shell */
29 – #ifdef _AUX_SOURCE
30 – #define REMSH           "remsh"
31 – #else
37   #define REMSH           "rsh"
33 – #endif
38                                  /* input variables (alphabetical by name) */
39   #define ANIMATE         0               /* animation command */
40   #define ARCHIVE         1               /* archiving command */
# Line 119 | Line 123 | struct pslot {
123   int     npslots;                /* number of process slots */
124  
125   #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
122 –
123 – struct pslot    *findpslot();
124 –
126   PSERVER *lastpserver;           /* last process server with error */
127  
128 < VIEW    *getview();
129 < char    *getexp(), *dirfile();
130 < int     getblur();
128 > static struct pslot * findpslot(int pid);
129 > static void checkdir(void);
130 > static VIEW * getview(int n);
131  
132 < extern time_t   time();
132 > static char * dirfile(char *df, register char *path);
133 > static char * getexp(int n);
134 > static int getblur(double *bf);
135 > static int getastat(void);
136 > static void getradfile(char *rfargs);
137 > static void badvalue(int vc);
138 > static int rmfile(char *fn);
139 > static int runcom(char *cs);
140 > static int pruncom(char *com, char *ppins, int maxcopies);
141 > static void bwait(int ncoms);
142 > static int bruncom(char *com, int fout, int (*rf)());
143 > static int serverdown(void);
144 > static pscompfunc donecom;
145 > static int countviews(void);
146 > static int dofilt(int frame, int rvr);
147 > static void archive(void);
148 > static int frecover(int frame);
149 > static int recover(int frame);
150 > static void sethosts(void);
151 > static void walkwait(int first, int last, char *vfn);
152 > static void animrend(int frame, VIEW *vp);
153 > static void transferframes(void);
154 > static void filterframes(void);
155 > static void renderframes(int nframes);
156 > static void animate(void);
157 > static void setdefaults(void);
158 > static void putastat(void);
159  
160  
161 < main(argc, argv)
162 < int     argc;
163 < char    *argv[];
161 > int
162 > main(
163 >        int     argc,
164 >        char    *argv[]
165 > )
166   {
167          int     explicate = 0;
168          int     i;
# Line 196 | Line 225 | char   *argv[];
225                  quit(1);
226          }
227          quit(0);
228 +        return 0; /* pro forma return */
229   userr:
230          fprintf(stderr, "Usage: %s [-s][-n][-w][-e] anim_file\n", progname);
231          quit(1);
232 +        return 1; /* pro forma return */
233   }
234  
235  
236 < getastat()                      /* check/set animation status */
236 > static int
237 > getastat(void)                  /* check/set animation status */
238   {
239          char    sfname[256];
240          FILE    *fp;
# Line 266 | Line 298 | fmterr:
298   }
299  
300  
301 < putastat()                      /* put out current status */
301 > static void
302 > putastat(void)                  /* put out current status */
303   {
304          char    buf[256];
305          FILE    *fp;
# Line 288 | Line 321 | putastat()                     /* put out current status */
321   }
322  
323  
324 < checkdir()                      /* make sure we have our directory */
324 > static void
325 > checkdir(void)                  /* make sure we have our directory */
326   {
327          struct stat     stb;
328  
# Line 310 | Line 344 | checkdir()                     /* make sure we have our directory */
344   }
345  
346  
347 < setdefaults()                   /* set default values */
347 > static void
348 > setdefaults(void)                       /* set default values */
349   {
350          extern char     *atos();
351          int     decades;
# Line 398 | Line 433 | setdefaults()                  /* set default values */
433   }
434  
435  
436 < sethosts()                      /* set up process servers */
436 > static void
437 > sethosts(void)                  /* set up process servers */
438   {
439          extern char     *iskip();
440          char    buf[256], *dir, *uname;
# Line 453 | Line 489 | sethosts()                     /* set up process servers */
489          }
490   }
491  
492 <
493 < getradfile(rfargs)              /* run rad and get needed variables */
458 < char    *rfargs;
492 > static void
493 > getradfile(char *rfargs)                /* run rad and get needed variables */
494   {
495          static short    mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
496          char    combuf[256];
497          register int    i;
498          register char   *cp;
499 <        char    *pippt;
499 >        char    *pippt = NULL;
500                                          /* create rad command */
501          sprintf(rendopt, " @%s/render.opt", vval(DIRECTORY));
502          sprintf(combuf,
# Line 480 | Line 515 | char   *rfargs;
515                          pippt = NULL;
516                  }
517          if (pippt != NULL)
518 <                strcpy(pippt, "> /dev/null");   /* nothing to match */
518 >                strcpy(pippt, "> " NULL_DEVICE);        /* nothing to match */
519          else {
520                  sprintf(cp, ")[ \t]*=' > %s/radset.var", vval(DIRECTORY));
521                  cp += 11;               /* point to file name */
# Line 493 | Line 528 | char   *rfargs;
528   }
529  
530  
531 < animate()                       /* run animation */
531 > static void
532 > animate(void)                   /* run animation */
533   {
534          int     xres, yres;
535          float   pa, mult;
# Line 564 | Line 600 | animate()                      /* run animation */
600   }
601  
602  
603 < renderframes(nframes)           /* render next nframes frames */
604 < int     nframes;
603 > static void
604 > renderframes(int nframes)               /* render next nframes frames */
605   {
606          static char     vendbuf[16];
607          VIEW    *vp;
# Line 621 | Line 657 | int    nframes;
657   }
658  
659  
660 < filterframes()                          /* catch up with filtering */
660 > static void
661 > filterframes(void)                              /* catch up with filtering */
662   {
626 –        VIEW    *vp;
663          register int    i;
664  
665          if (astat.tnext < astat.fnext)  /* other work to do first */
666                  return;
667                                          /* filter each view */
668 <        for (i = astat.fnext; i < astat.rnext; i++) {
669 <                if ((vp = getview(i)) == NULL) {        /* get view i */
670 <                        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 <        }
668 >        for (i = astat.fnext; i < astat.rnext; i++)
669 >                dofilt(i, 0);
670 >
671          bwait(0);                       /* wait for filter processes */
672          archive();                      /* archive originals */
673          astat.fnext = i;                /* update status */
# Line 645 | Line 675 | filterframes()                         /* catch up with filtering */
675   }
676  
677  
678 < transferframes()                        /* catch up with picture transfers */
678 > static void
679 > transferframes(void)                    /* catch up with picture transfers */
680   {
681          char    combuf[10240], *fbase;
682          register char   *cp;
# Line 685 | Line 716 | transferframes()                       /* catch up with picture transfers
716   }
717  
718  
719 < animrend(frame, vp)                     /* start animation frame */
720 < int     frame;
721 < VIEW    *vp;
719 > static void
720 > animrend(                       /* start animation frame */
721 > int     frame,
722 > VIEW    *vp
723 > )
724   {
692 –        extern int      recover();
725          char    combuf[2048];
726          char    fname[128];
727  
# Line 703 | Line 735 | VIEW   *vp;
735   }
736  
737  
738 < walkwait(first, last, vfn)              /* walk-through frames */
739 < int     first, last;
740 < char    *vfn;
738 > static void
739 > walkwait(               /* walk-through frames */
740 > int     first,
741 > int last,
742 > char    *vfn
743 > )
744   {
745          double  blurf;
746          int     nblur = getblur(&blurf);
# Line 755 | Line 790 | char   *vfn;
790   }
791  
792  
793 < int
794 < recover(frame)                          /* recover the specified frame */
760 < int     frame;
793 > static int
794 > recover(int frame)                      /* recover the specified frame */
795   {
796          static int      *rfrm;          /* list of recovered frames */
797          static int      nrfrms = 0;
# Line 810 | Line 844 | int    frame;
844   }
845  
846  
847 < int
848 < frecover(frame)                         /* recover filtered frame */
815 < int     frame;
847 > static int
848 > frecover(int frame)                             /* recover filtered frame */
849   {
850 <        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))
850 >        if (dofilt(frame, 2) && dofilt(frame, 1))
851                  return(1);
852          return(0);
853   }
854  
855  
856 < archive()                       /* archive and remove renderings */
856 > static void
857 > archive(void)                   /* archive and remove renderings */
858   {
859   #define RMCOML  (sizeof(rmcom)-1)
860          static char     rmcom[] = "rm -f";
# Line 868 | Line 897 | archive()                      /* archive and remove renderings */
897   }
898  
899  
900 < int
901 < dofilt(frame, vp, ep, rvr)                      /* filter frame */
902 < int     frame;
903 < VIEW    *vp;
904 < char    *ep;
876 < int     rvr;
900 > static int
901 > dofilt(                         /* filter frame */
902 > int     frame,
903 > int     rvr
904 > )
905   {
878 –        extern int      frecover();
906          static int      iter = 0;
907          double  blurf;
908          int     nblur = getblur(&blurf);
909 +        VIEW    *vp = getview(frame);
910 +        char    *ep = getexp(frame);
911          char    fnbefore[128], fnafter[128], *fbase;
912          char    combuf[1024], fname0[128], fname1[128];
913          int     usepinterp, usepfilt, nora_rgbe;
914          int     frseq[2];
915                                                  /* check what is needed */
916 +        if (vp == NULL) {
917 +                 fprintf(stderr,
918 +                        "%s: unexpected error reading view for frame %d\n",
919 +                                          progname, frame);
920 +                quit(1);
921 +        }
922          usepinterp = (nblur > 1);
923 <        usepfilt = pfiltalways | ep==NULL;
923 >        usepfilt = pfiltalways | (ep==NULL);
924          if (ep != NULL && !strcmp(ep, "1"))
925                  ep = "+0";
926          nora_rgbe = strcmp(vval(OVERSAMP),"1") || ep==NULL ||
# Line 1018 | Line 1053 | int    rvr;
1053   }
1054  
1055  
1056 < VIEW *
1057 < getview(n)                      /* get view number n */
1023 < int     n;
1056 > static VIEW *
1057 > getview(int n)                  /* get view number n */
1058   {
1059          static FILE     *viewfp = NULL;         /* view file pointer */
1060          static int      viewnum = 0;            /* current view number */
# Line 1032 | Line 1066 | int    n;
1066                          fclose(viewfp);
1067                          viewfp = NULL;
1068                          viewnum = 0;
1069 <                        copystruct(&curview, &stdview);
1069 >                        curview = stdview;
1070                  }
1071                  return(NULL);
1072          }
# Line 1048 | Line 1082 | int    n;
1082                          perror(vval(VIEWFILE));
1083                          quit(1);
1084                  }
1085 <                copystruct(&curview, &stdview);
1085 >                curview = stdview;
1086                  viewnum = 0;
1087          }
1088          if (n < 0) {                            /* get next view */
# Line 1068 | Line 1102 | int    n;
1102   }
1103  
1104  
1105 < int
1106 < countviews()                    /* count views in view file */
1105 > static int
1106 > countviews(void)                        /* count views in view file */
1107   {
1108          int     n;
1109  
# Line 1081 | Line 1115 | countviews()                   /* count views in view file */
1115   }
1116  
1117  
1118 < char *
1119 < getexp(n)                       /* get exposure for nth frame */
1086 < int     n;
1118 > static char *
1119 > getexp(int n)                   /* get exposure for nth frame */
1120   {
1121          extern char     *fskip();
1122          static char     expval[32];
# Line 1152 | Line 1185 | int    n;
1185   }
1186  
1187  
1188 < struct pslot *
1189 < findpslot(pid)                  /* find or allocate a process slot */
1157 < int     pid;
1188 > static struct pslot *
1189 > findpslot(int pid)                      /* find or allocate a process slot */
1190   {
1191          register struct pslot   *psempty = NULL;
1192          register int    i;
# Line 1169 | Line 1201 | int    pid;
1201   }
1202  
1203  
1204 < int
1205 < donecom(ps, pn, status)         /* clean up after finished process */
1206 < PSERVER *ps;
1207 < int     pn;
1208 < int     status;
1204 > static int
1205 > donecom(                /* clean up after finished process */
1206 >        PSERVER *ps,
1207 >        int     pn,
1208 >        int     status
1209 > )
1210   {
1211 <        register PROC   *pp;
1211 >        register NETPROC        *pp;
1212          register struct pslot   *psl;
1213  
1214          pp = ps->proc + pn;
# Line 1210 | Line 1243 | int    status;
1243   }
1244  
1245  
1246 < int
1247 < serverdown()                    /* check status of last process server */
1246 > static int
1247 > serverdown(void)                        /* check status of last process server */
1248   {
1249          if (lastpserver == NULL || !lastpserver->hostname[0])
1250                  return(0);
# Line 1227 | Line 1260 | serverdown()                   /* check status of last process server
1260   }
1261  
1262  
1263 < int
1264 < bruncom(com, fout, rf)          /* run a command in the background */
1265 < char    *com;
1266 < int     fout;
1267 < int     (*rf)();
1263 > static int
1264 > bruncom(                /* run a command in the background */
1265 > char    *com,
1266 > int     fout,
1267 > int     (*rf)()
1268 > )
1269   {
1270          int     pid;
1271          register struct pslot   *psl;
# Line 1260 | Line 1294 | int    (*rf)();
1294   }
1295  
1296  
1297 < bwait(ncoms)                            /* wait for batch job(s) to finish */
1298 < int     ncoms;
1297 > static void
1298 > bwait(int ncoms)                                /* wait for batch job(s) to finish */
1299   {
1300          int     status;
1301  
# Line 1275 | Line 1309 | int    ncoms;
1309   }
1310  
1311  
1312 < int
1313 < pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1314 < char    *com, *ppins;
1315 < int     maxcopies;
1312 > static int
1313 > pruncom(        /* run a command in parallel over network */
1314 > char    *com,
1315 > char    *ppins,
1316 > int     maxcopies
1317 > )
1318   {
1319          int     retstatus = 0;
1320          int     hostcopies;
# Line 1345 | Line 1381 | int    maxcopies;
1381   }
1382  
1383  
1384 < runcom(cs)                      /* run a command locally and wait for it */
1385 < char    *cs;
1384 > static int
1385 > runcom(char *cs)                        /* run a command locally and wait for it */
1386   {
1387          if (!silent)            /* echo it */
1388                  printf("\t%s\n", cs);
# Line 1357 | Line 1393 | char   *cs;
1393   }
1394  
1395  
1396 < rmfile(fn)                      /* remove a file */
1397 < char    *fn;
1396 > static int
1397 > rmfile(char *fn)                        /* remove a file */
1398   {
1399          if (!silent)
1400 < #ifdef MSDOS
1400 > #ifdef _WIN32
1401                  printf("\tdel %s\n", fn);
1402   #else
1403                  printf("\trm -f %s\n", fn);
# Line 1372 | Line 1408 | char   *fn;
1408   }
1409  
1410  
1411 < badvalue(vc)                    /* report bad variable value and exit */
1412 < int     vc;
1411 > static void
1412 > badvalue(int vc)                        /* report bad variable value and exit */
1413   {
1414          fprintf(stderr, "%s: bad value for variable '%s'\n",
1415                          progname, vnam(vc));
# Line 1381 | Line 1417 | int    vc;
1417   }
1418  
1419  
1420 < char *
1421 < dirfile(df, path)               /* separate path into directory and file */
1422 < char    *df;
1423 < register char   *path;
1420 > static char *
1421 > dirfile(                /* separate path into directory and file */
1422 > char    *df,
1423 > register char   *path
1424 > )
1425   {
1426          register int    i;
1427          int     psep;
# Line 1392 | Line 1429 | register char  *path;
1429          for (i = 0, psep = -1; path[i]; i++)
1430                  if (path[i] == '/')
1431                          psep = i;
1432 <        if (df != NULL)
1432 >        if (df != NULL) {
1433                  if (psep == 0) {
1434                          df[0] = '/';
1435                          df[1] = '\0';
# Line 1401 | Line 1438 | register char  *path;
1438                          df[psep] = '\0';
1439                  } else
1440                          df[0] = '\0';
1441 +        }
1442          return(path+psep+1);
1443   }
1444  
1445  
1446 < int
1446 > static int
1447   getblur(double *bf)             /* get # blur samples (and fraction) */
1448   {
1449          double  blurf;

Diff Legend

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