ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/Development/ray/src/util/ranimate.c
(Generate patch)

Comparing ray/src/util/ranimate.c (file contents):
Revision 2.42 by schorsch, Tue Oct 21 19:19:29 2003 UTC vs.
Revision 2.44 by greg, Tue Dec 9 22:46:41 2003 UTC

# Line 15 | Line 15 | static const char RCSid[] = "$Id$";
15  
16   #include "copyright.h"
17  
18 + #include <stdio.h>
19   #include <ctype.h>
20   #include <sys/stat.h>
21 + #include <time.h>
22  
23 < #include "standard.h"
23 > /*#include "standard.h"*/
24 > #include "platform.h"
25   #include "paths.h"
26 + #include "rtio.h"
27 + #include "rterror.h"
28   #include "view.h"
29   #include "vars.h"
30   #include "netproc.h"
# Line 117 | Line 122 | struct pslot {
122   int     npslots;                /* number of process slots */
123  
124   #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
120 –
121 – struct pslot    *findpslot();
122 –
125   PSERVER *lastpserver;           /* last process server with error */
126  
127 < VIEW    *getview();
128 < char    *getexp(), *dirfile();
129 < int     getblur();
127 > static struct pslot * findpslot(int pid);
128 > static void checkdir(void);
129 > static VIEW * getview(int n);
130  
131 < extern time_t   time();
131 > static char * dirfile(char *df, register char *path);
132 > static char * getexp(int n);
133 > static int getblur(double *bf);
134 > static int getastat(void);
135 > static void getradfile(char *rfargs);
136 > static void badvalue(int vc);
137 > static int rmfile(char *fn);
138 > static int runcom(char *cs);
139 > static int pruncom(char *com, char *ppins, int maxcopies);
140 > static void bwait(int ncoms);
141 > static int bruncom(char *com, int fout, int (*rf)());
142 > static int serverdown(void);
143 > static int donecom(PSERVER *ps, int pn, int status);
144 > static int countviews(void);
145 > static int dofilt(int frame, int rvr);
146 > static void archive(void);
147 > static int frecover(int frame);
148 > static int recover(int frame);
149 > static void sethosts(void);
150 > static void walkwait(int first, int last, char *vfn);
151 > static void animrend(int frame, VIEW *vp);
152 > static void transferframes(void);
153 > static void filterframes(void);
154 > static void renderframes(int nframes);
155 > static void animate(void);
156 > static void setdefaults(void);
157 > static void putastat(void);
158  
159  
160   main(argc, argv)
# Line 200 | Line 228 | userr:
228   }
229  
230  
231 < getastat()                      /* check/set animation status */
231 > static int
232 > getastat(void)                  /* check/set animation status */
233   {
234          char    sfname[256];
235          FILE    *fp;
# Line 264 | Line 293 | fmterr:
293   }
294  
295  
296 < putastat()                      /* put out current status */
296 > static void
297 > putastat(void)                  /* put out current status */
298   {
299          char    buf[256];
300          FILE    *fp;
# Line 286 | Line 316 | putastat()                     /* put out current status */
316   }
317  
318  
319 < checkdir()                      /* make sure we have our directory */
319 > static void
320 > checkdir(void)                  /* make sure we have our directory */
321   {
322          struct stat     stb;
323  
# Line 308 | Line 339 | checkdir()                     /* make sure we have our directory */
339   }
340  
341  
342 < setdefaults()                   /* set default values */
342 > static void
343 > setdefaults(void)                       /* set default values */
344   {
345          extern char     *atos();
346          int     decades;
# Line 396 | Line 428 | setdefaults()                  /* set default values */
428   }
429  
430  
431 < sethosts()                      /* set up process servers */
431 > static void
432 > sethosts(void)                  /* set up process servers */
433   {
434          extern char     *iskip();
435          char    buf[256], *dir, *uname;
# Line 451 | Line 484 | sethosts()                     /* set up process servers */
484          }
485   }
486  
487 <
488 < getradfile(rfargs)              /* run rad and get needed variables */
456 < char    *rfargs;
487 > static void
488 > getradfile(char *rfargs)                /* run rad and get needed variables */
489   {
490          static short    mvar[] = {OCTREE,PFILT,RESOLUTION,EXPOSURE,-1};
491          char    combuf[256];
# Line 491 | Line 523 | char   *rfargs;
523   }
524  
525  
526 < animate()                       /* run animation */
526 > static void
527 > animate(void)                   /* run animation */
528   {
529          int     xres, yres;
530          float   pa, mult;
# Line 562 | Line 595 | animate()                      /* run animation */
595   }
596  
597  
598 < renderframes(nframes)           /* render next nframes frames */
599 < int     nframes;
598 > static void
599 > renderframes(int nframes)               /* render next nframes frames */
600   {
601          static char     vendbuf[16];
602          VIEW    *vp;
# Line 619 | Line 652 | int    nframes;
652   }
653  
654  
655 < filterframes()                          /* catch up with filtering */
655 > static void
656 > filterframes(void)                              /* catch up with filtering */
657   {
658          VIEW    *vp;
659          register int    i;
# Line 637 | Line 671 | filterframes()                         /* catch up with filtering */
671   }
672  
673  
674 < transferframes()                        /* catch up with picture transfers */
674 > static void
675 > transferframes(void)                    /* catch up with picture transfers */
676   {
677          char    combuf[10240], *fbase;
678          register char   *cp;
# Line 677 | Line 712 | transferframes()                       /* catch up with picture transfers
712   }
713  
714  
715 < animrend(frame, vp)                     /* start animation frame */
716 < int     frame;
717 < VIEW    *vp;
715 > static void
716 > animrend(                       /* start animation frame */
717 > int     frame,
718 > VIEW    *vp
719 > )
720   {
684 –        extern int      recover();
721          char    combuf[2048];
722          char    fname[128];
723  
# Line 695 | Line 731 | VIEW   *vp;
731   }
732  
733  
734 < walkwait(first, last, vfn)              /* walk-through frames */
735 < int     first, last;
736 < char    *vfn;
734 > static void
735 > walkwait(               /* walk-through frames */
736 > int     first,
737 > int last,
738 > char    *vfn
739 > )
740   {
741          double  blurf;
742          int     nblur = getblur(&blurf);
# Line 747 | Line 786 | char   *vfn;
786   }
787  
788  
789 < int
790 < recover(frame)                          /* recover the specified frame */
752 < int     frame;
789 > static int
790 > recover(int frame)                      /* recover the specified frame */
791   {
792          static int      *rfrm;          /* list of recovered frames */
793          static int      nrfrms = 0;
# Line 802 | Line 840 | int    frame;
840   }
841  
842  
843 < int
844 < frecover(frame)                         /* recover filtered frame */
807 < int     frame;
843 > static int
844 > frecover(int frame)                             /* recover filtered frame */
845   {
846          if (dofilt(frame, 2) && dofilt(frame, 1))
847                  return(1);
# Line 812 | Line 849 | int    frame;
849   }
850  
851  
852 < archive()                       /* archive and remove renderings */
852 > static void
853 > archive(void)                   /* archive and remove renderings */
854   {
855   #define RMCOML  (sizeof(rmcom)-1)
856          static char     rmcom[] = "rm -f";
# Line 855 | Line 893 | archive()                      /* archive and remove renderings */
893   }
894  
895  
896 < int
897 < dofilt(frame, rvr)                              /* filter frame */
898 < int     frame;
899 < int     rvr;
896 > static int
897 > dofilt(                         /* filter frame */
898 > int     frame,
899 > int     rvr
900 > )
901   {
863 –        extern int      frecover();
902          static int      iter = 0;
903          double  blurf;
904          int     nblur = getblur(&blurf);
# Line 1017 | Line 1055 | int    rvr;
1055   }
1056  
1057  
1058 < VIEW *
1059 < getview(n)                      /* get view number n */
1022 < int     n;
1058 > static VIEW *
1059 > getview(int n)                  /* get view number n */
1060   {
1061          static FILE     *viewfp = NULL;         /* view file pointer */
1062          static int      viewnum = 0;            /* current view number */
# Line 1067 | Line 1104 | int    n;
1104   }
1105  
1106  
1107 < int
1108 < countviews()                    /* count views in view file */
1107 > static int
1108 > countviews(void)                        /* count views in view file */
1109   {
1110          int     n;
1111  
# Line 1080 | Line 1117 | countviews()                   /* count views in view file */
1117   }
1118  
1119  
1120 < char *
1121 < getexp(n)                       /* get exposure for nth frame */
1085 < int     n;
1120 > static char *
1121 > getexp(int n)                   /* get exposure for nth frame */
1122   {
1123          extern char     *fskip();
1124          static char     expval[32];
# Line 1151 | Line 1187 | int    n;
1187   }
1188  
1189  
1190 < struct pslot *
1191 < findpslot(pid)                  /* find or allocate a process slot */
1156 < int     pid;
1190 > static struct pslot *
1191 > findpslot(int pid)                      /* find or allocate a process slot */
1192   {
1193          register struct pslot   *psempty = NULL;
1194          register int    i;
# Line 1168 | Line 1203 | int    pid;
1203   }
1204  
1205  
1206 < int
1207 < donecom(ps, pn, status)         /* clean up after finished process */
1208 < PSERVER *ps;
1209 < int     pn;
1210 < int     status;
1206 > static int
1207 > donecom(                /* clean up after finished process */
1208 > PSERVER *ps,
1209 > int     pn,
1210 > int     status
1211 > )
1212   {
1213 <        register PROC   *pp;
1213 >        register NETPROC        *pp;
1214          register struct pslot   *psl;
1215  
1216          pp = ps->proc + pn;
# Line 1209 | Line 1245 | int    status;
1245   }
1246  
1247  
1248 < int
1249 < serverdown()                    /* check status of last process server */
1248 > static int
1249 > serverdown(void)                        /* check status of last process server */
1250   {
1251          if (lastpserver == NULL || !lastpserver->hostname[0])
1252                  return(0);
# Line 1226 | Line 1262 | serverdown()                   /* check status of last process server
1262   }
1263  
1264  
1265 < int
1266 < bruncom(com, fout, rf)          /* run a command in the background */
1267 < char    *com;
1268 < int     fout;
1269 < int     (*rf)();
1265 > static int
1266 > bruncom(                /* run a command in the background */
1267 > char    *com,
1268 > int     fout,
1269 > int     (*rf)()
1270 > )
1271   {
1272          int     pid;
1273          register struct pslot   *psl;
# Line 1259 | Line 1296 | int    (*rf)();
1296   }
1297  
1298  
1299 < bwait(ncoms)                            /* wait for batch job(s) to finish */
1300 < int     ncoms;
1299 > static void
1300 > bwait(int ncoms)                                /* wait for batch job(s) to finish */
1301   {
1302          int     status;
1303  
# Line 1274 | Line 1311 | int    ncoms;
1311   }
1312  
1313  
1314 < int
1315 < pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1316 < char    *com, *ppins;
1317 < int     maxcopies;
1314 > static int
1315 > pruncom(        /* run a command in parallel over network */
1316 > char    *com,
1317 > char    *ppins,
1318 > int     maxcopies
1319 > )
1320   {
1321          int     retstatus = 0;
1322          int     hostcopies;
# Line 1344 | Line 1383 | int    maxcopies;
1383   }
1384  
1385  
1386 < runcom(cs)                      /* run a command locally and wait for it */
1387 < char    *cs;
1386 > static int
1387 > runcom(char *cs)                        /* run a command locally and wait for it */
1388   {
1389          if (!silent)            /* echo it */
1390                  printf("\t%s\n", cs);
# Line 1356 | Line 1395 | char   *cs;
1395   }
1396  
1397  
1398 < rmfile(fn)                      /* remove a file */
1399 < char    *fn;
1398 > static int
1399 > rmfile(char *fn)                        /* remove a file */
1400   {
1401          if (!silent)
1402   #ifdef _WIN32
# Line 1371 | Line 1410 | char   *fn;
1410   }
1411  
1412  
1413 < badvalue(vc)                    /* report bad variable value and exit */
1414 < int     vc;
1413 > static void
1414 > badvalue(int vc)                        /* report bad variable value and exit */
1415   {
1416          fprintf(stderr, "%s: bad value for variable '%s'\n",
1417                          progname, vnam(vc));
# Line 1380 | Line 1419 | int    vc;
1419   }
1420  
1421  
1422 < char *
1423 < dirfile(df, path)               /* separate path into directory and file */
1424 < char    *df;
1425 < register char   *path;
1422 > static char *
1423 > dirfile(                /* separate path into directory and file */
1424 > char    *df,
1425 > register char   *path
1426 > )
1427   {
1428          register int    i;
1429          int     psep;
# Line 1405 | Line 1445 | register char  *path;
1445   }
1446  
1447  
1448 < int
1448 > static int
1449   getblur(double *bf)             /* get # blur samples (and fraction) */
1450   {
1451          double  blurf;

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)