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

Comparing ray/src/util/ranimove1.c (file contents):
Revision 3.7 by schorsch, Tue Oct 21 19:19:29 2003 UTC vs.
Revision 3.23 by greg, Wed Jan 24 04:39:52 2018 UTC

# Line 4 | Line 4 | static const char      RCSid[] = "$Id$";
4   /*
5   *  ranimove1.c
6   *
7 < *  Basic frame rendering routines for ranimate(1).
7 > *  Basic frame rendering routines for ranimove(1).
8   *
9   *  Created by Gregory Ward on Wed Jan 08 2003.
10   */
# Line 16 | Line 16 | static const char      RCSid[] = "$Id$";
16   #include "platform.h"
17   #include "ranimove.h"
18   #include "otypes.h"
19 + #include "source.h"
20   #include "random.h"
21  
22   double          acctab[256];    /* accuracy value table */
# Line 29 | Line 30 | float          *zbuffer;       /* depth at each pixel */
30   OBJECT          *obuffer;       /* object id at each pixel */
31   short           *xmbuffer;      /* x motion at each pixel */
32   short           *ymbuffer;      /* y motion at each pixel */
33 < BYTE            *abuffer;       /* accuracy at each pixel */
34 < BYTE            *sbuffer;       /* sample count per pixel */
33 > uby8            *abuffer;       /* accuracy at each pixel */
34 > uby8            *sbuffer;       /* sample count per pixel */
35  
36   VIEW            vwprev;         /* last frame's view */
37   COLOR           *cprev;         /* last frame colors */
38   float           *zprev;         /* last frame depth */
39   OBJECT          *oprev;         /* last frame objects */
40 < BYTE            *aprev;         /* last frame accuracy */
40 > uby8            *aprev;         /* last frame accuracy */
41  
42   float           *cerrmap;       /* conspicuous error map */
43   COLOR           *val2map;       /* value-squared map for variance */
# Line 46 | Line 47 | double         frm_stop;       /* when to stop rendering this frame
47   double          hlsmax;         /* maximum high-level saliency this frame */
48  
49  
50 + static void next_frame(void);
51 + static int sample_here(int x, int y);
52 + static int offset_cmp(const void *p1, const void *p2);
53 + static void setmotion(int n, FVECT wpos);
54 + static void init_frame_sample(void);
55 +
56 +
57 + #if 0
58   void
59 < write_map(mp, fn)               /* write out float map (debugging) */
60 < float   *mp;
61 < char    *fn;
59 > write_map(              /* write out float map (debugging) */
60 >        float   *mp,
61 >        char    *fn
62 > )
63   {
64          FILE    *fp = fopen(fn, "w");
65          COLOR   scanbuf[2048];
# Line 70 | Line 80 | char   *fn;
80          }
81          fclose(fp);
82   }
83 + #endif
84  
85  
86   static void
87 < next_frame()                    /* prepare next frame buffer */
87 > next_frame(void)                        /* prepare next frame buffer */
88   {
89          VIEW    *fv;
90          char    *err;
# Line 96 | Line 107 | next_frame()                   /* prepare next frame buffer */
107                  error(USER, errmsg);
108          }
109          if (cbuffer == NULL) {
110 +                int     n;
111                                          /* compute resolution and allocate */
112                  switch (sscanf(vval(RESOLUTION), "%d %d %lf",
113                                  &hres, &vres, &pixaspect)) {
# Line 119 | Line 131 | next_frame()                   /* prepare next frame buffer */
131                  obuffer = (OBJECT *)malloc(sizeof(OBJECT)*hres*vres);
132                  xmbuffer = (short *)malloc(sizeof(short)*hres*vres);
133                  ymbuffer = (short *)malloc(sizeof(short)*hres*vres);
134 <                abuffer = (BYTE *)calloc(hres*vres, sizeof(BYTE));
135 <                sbuffer = (BYTE *)calloc(hres*vres, sizeof(BYTE));
134 >                abuffer = (uby8 *)calloc(hres*vres, sizeof(uby8));
135 >                sbuffer = (uby8 *)calloc(hres*vres, sizeof(uby8));
136                  cprev = (COLOR *)malloc(sizeof(COLOR)*hres*vres);
137                  zprev = (float *)malloc(sizeof(float)*hres*vres);
138                  oprev = (OBJECT *)malloc(sizeof(OBJECT)*hres*vres);
139 <                aprev = (BYTE *)malloc(sizeof(BYTE)*hres*vres);
139 >                aprev = (uby8 *)malloc(sizeof(uby8)*hres*vres);
140                  if ((cbuffer==NULL) | (zbuffer==NULL) | (obuffer==NULL) |
141                                  (xmbuffer==NULL) | (ymbuffer==NULL) |
142                                  (abuffer==NULL) | (sbuffer==NULL) |
143                                  (cprev==NULL) | (zprev == NULL) |
144                                  (oprev==NULL) | (aprev==NULL))
145                          error(SYSTEM, "out of memory in init_frame");
146 +                for (n = hres*vres; n--; ) {
147 +                        zprev[n] = -1.f;
148 +                        oprev[n] = OVOID;
149 +                }
150                  frm_stop = getTime() + rtperfrm;
151          } else {
152                  COLOR   *cp;            /* else just swap buffers */
153                  float   *fp;
154                  OBJECT  *op;
155 <                BYTE    *bp;
155 >                uby8    *bp;
156                  cp = cprev; cprev = cbuffer; cbuffer = cp;
157                  fp = zprev; zprev = zbuffer; zbuffer = fp;
158                  op = oprev; oprev = obuffer; obuffer = op;
159                  bp = aprev; aprev = abuffer; abuffer = bp;
160 <                memset(abuffer, '\0', sizeof(BYTE)*hres*vres);
161 <                memset(sbuffer, '\0', sizeof(BYTE)*hres*vres);
160 >                memset(abuffer, '\0', sizeof(uby8)*hres*vres);
161 >                memset(sbuffer, '\0', sizeof(uby8)*hres*vres);
162                  frm_stop += rtperfrm;
163          }
164          cerrmap = NULL;
# Line 155 | Line 171 | next_frame()                   /* prepare next frame buffer */
171  
172  
173   static int
174 < sample_here(x, y)               /* 4x4 quincunx sample at this pixel? */
175 < register int    x, y;
174 > sample_here(            /* 4x4 quincunx sample at this pixel? */
175 >        int     x,
176 >        int     y
177 > )
178   {
179          if (y & 0x1)            /* every other row has samples */
180                  return(0);
# Line 167 | Line 185 | register int   x, y;
185  
186  
187   void
188 < sample_pos(hv, x, y, sn)        /* compute jittered sample position */
189 < double  hv[2];
190 < int     x, y;
191 < int     sn;
188 > sample_pos(     /* compute jittered sample position */
189 >        double  hv[2],
190 >        int     x,
191 >        int     y,
192 >        int     sn
193 > )
194   {
195          int     hl[2];
196  
# Line 182 | Line 202 | int    sn;
202  
203  
204   double
205 < sample_wt(xo, yo)               /* compute interpolant sample weight */
206 < int     xo, yo;
205 > sample_wt(              /* compute interpolant sample weight */
206 >        int     xo,
207 >        int yo
208 > )
209   {
210          static double   etab[400];
211          /* we can't use the name rad2 here, for some reason Visual C
# Line 204 | Line 226 | int    xo, yo;
226  
227  
228   static int
229 < offset_cmp(p1, p2)              /* compare offset distances */
230 < const void      *p1, *p2;
229 > offset_cmp(             /* compare offset distances */
230 >        const void      *p1,
231 >        const void      *p2
232 > )
233   {
234          return(*(const int *)p1 - *(const int *)p2);
235   }
236  
237  
238   int
239 < getclosest(iarr, nc, x, y)      /* get nc closest neighbors on same object */
240 < int     *iarr;
241 < int     nc;
242 < int     x, y;
239 > getclosest(     /* get nc closest neighbors on same object */
240 >        int     *iarr,
241 >        int     nc,
242 >        int     x,
243 >        int     y
244 > )
245   {
246   #define NSCHECK         ((2*SAMPDIST+1)*(2*SAMPDIST+1))
247          static int      hro, vro;
248          static int      ioffs[NSCHECK];
249          OBJECT  myobj;
250          int     i0, nf;
251 <        register int    i, j;
251 >        int     i, j;
252                                          /* get our object number */
253          myobj = obuffer[fndx(x, y)];
254                                          /* special case for borders */
# Line 285 | Line 311 | int    x, y;
311  
312  
313   static void
314 < setmotion(n, wpos)              /* compute motion vector for this pixel */
315 < register int    n;
316 < FVECT   wpos;
314 > setmotion(              /* compute motion vector for this pixel */
315 >                int     n,
316 >                FVECT   wpos
317 > )
318   {
319          FVECT   ovp;
293 –        MAT4    xfm;
294 –        double  d;
320          int     moi;
321          int     xp, yp;
322                                          /* ID object and update maximum HLS */
# Line 304 | Line 329 | FVECT  wpos;
329                  multp3(ovp, wpos, obj_move[moi].bxfm);
330                  wpos = ovp;
331          }
332 <        viewloc(ovp, &vwprev, wpos);
308 <        if (ovp[2] <= FTINY)
332 >        if (viewloc(ovp, &vwprev, wpos) <= 0)
333                  return;
334          xp = (int)(ovp[0]*hres);
335          yp = (int)(ovp[1]*vres);
# Line 322 | Line 346 | FVECT  wpos;
346  
347  
348   static void
349 < init_frame_sample()             /* sample our initial frame */
349 > init_frame_sample(void)         /* sample our initial frame */
350   {
351          RAY     ir;
352          int     x, y;
353 <        register int    n;
353 >        int     n;
354  
355          if (!silent) {
356                  printf("\tComputing initial samples...");
# Line 337 | Line 361 | init_frame_sample()            /* sample our initial frame */
361              for (x = hres; x--; ) {
362                  double  hv[2];
363                  n = fndx(x, y);
364 <                xmbuffer[n] = MO_UNK;
341 <                ymbuffer[n] = MO_UNK;
364 >                xmbuffer[n] = ymbuffer[n] = MO_UNK;
365                  sample_pos(hv, x, y, 0);
366                  ir.rmax = viewray(ir.rorg, ir.rdir, &vw, hv[0], hv[1]);
367                  if (ir.rmax < -FTINY) {
# Line 349 | Line 372 | init_frame_sample()            /* sample our initial frame */
372                          continue;
373                  }
374                  if (!sample_here(x, y)) {       /* just cast */
375 <                        rayorigin(&ir, NULL, PRIMARY, 1.0);
375 >                        rayorigin(&ir, PRIMARY, NULL, NULL);
376                          if (!localhit(&ir, &thescene)) {
377 <                                if (ir.ro != &Aftplane)
378 <                                        sourcehit(&ir);
377 >                                if (ir.ro != &Aftplane && sourcehit(&ir)) {
378 >                                        rayshade(&ir, ir.ro->omod);
379 >                                        rayparticipate(&ir);
380 >                                }
381                                  copycolor(cbuffer[n], ir.rcol);
382                                  zbuffer[n] = ir.rot;
383                                  obuffer[n] = ir.robj;
# Line 367 | Line 392 | init_frame_sample()            /* sample our initial frame */
392                  }
393                  if (nprocs > 1) {               /* get sample */
394                          int     rval;
395 <                        rayorigin(&ir, NULL, PRIMARY, 1.0);
395 >                        rayorigin(&ir, PRIMARY, NULL, NULL);
396                          ir.rno = n;
397                          rval = ray_pqueue(&ir);
398                          if (!rval)
# Line 381 | Line 406 | init_frame_sample()            /* sample our initial frame */
406                  zbuffer[n] = ir.rot;
407                  obuffer[n] = ir.robj;
408                  sbuffer[n] = 1;
409 <                if (ir.rot >= FHUGE)
409 >                if (ir.rot >= 0.99*FHUGE)
410                          abuffer[n] = ADISTANT;
411                  else {
412                          abuffer[n] = ALOWQ;
# Line 425 | Line 450 | init_frame_sample()            /* sample our initial frame */
450  
451  
452   int
453 < getambcolor(clr, obj)           /* get ambient color for object if we can */
454 < COLOR   clr;
455 < int     obj;
453 > getambcolor(            /* get ambient color for object if we can */
454 >                COLOR   clr,
455 >                int     obj
456 > )
457   {
458 <        register OBJREC *op;
458 >        OBJREC  *op;
459  
460          if (obj == OVOID)
461                  return(0);
462 <        op = objptr(obj);
463 <        if ((op->otype == OBJ_INSTANCE) & (op->omod == OVOID))
462 >        op = objptr(obj);               /* search for material */
463 >        if (op->omod == OVOID)
464                  return(0);
465 <                                        /* search for material */
466 <        do {
467 <                if (op->omod == OVOID || ofun[op->otype].flags & T_X)
442 <                        return(0);
443 <                op = objptr(op->omod);
444 <        } while (!ismaterial(op->otype));
465 >        op = findmaterial(objptr(op->omod));
466 >        if (op == NULL)
467 >                return(0);
468          /*
469           * Since this routine is called to compute the difference
470           * from rendering with and without interreflections,
# Line 455 | Line 478 | int    obj;
478                          if (lv[0] == op->oname[0] &&
479                                          !strcmp(lv+1, op->oname+1))
480                                  break;
481 <                if ((lv != NULL) != hirendparams.ambincl)
481 >                if ((lv != NULL) ^ hirendparams.ambincl)
482                          return(0);
483          }
484          switch (op->otype) {
# Line 495 | Line 518 | int    obj;
518  
519  
520   double
521 < estimaterr(cs, cs2, ns, ns0)    /* estimate relative error from samples */
522 < COLOR   cs, cs2;
523 < int     ns;
521 > estimaterr(             /* estimate relative error from samples */
522 >                COLOR   cs,
523 >                COLOR   cs2,
524 >                int     ns,
525 >                int ns0
526 > )
527   {
528          double  d, d2, brt;
529  
# Line 518 | Line 544 | int    ns;
544  
545  
546   double
547 < comperr(neigh, nc, ns0)         /* estimate relative error in neighborhood */
548 < int     *neigh;
549 < int     nc;
550 < int     ns0;
547 > comperr(                /* estimate relative error in neighborhood */
548 >                int     *neigh,
549 >                int     nc,
550 >                int     ns0
551 > )
552   {
553          COLOR   csum, csum2;
554          COLOR   ctmp;
555          int     i;
556          int     ns;
557 <        register int    n;
557 >        int     n;
558                                          /* add together samples */
559          setcolor(csum, 0., 0., 0.);
560          setcolor(csum2, 0., 0., 0.);
# Line 553 | Line 580 | int    ns0;
580  
581  
582   void
583 < comp_frame_error()              /* initialize frame error values */
583 > comp_frame_error(void)          /* initialize frame error values */
584   {
585 <        BYTE    *edone = NULL;
585 >        uby8    *edone = NULL;
586          COLOR   objamb;
587          double  eest;
588          int     neigh[NSAMPOK];
589          int     nc;
590 <        int     x, y, i, j;
591 <        register int    n;
590 >        int     x, y, i;
591 >        int     n;
592  
593          if (!silent) {
594                  printf("\tComputing error map\n");
# Line 579 | Line 606 | comp_frame_error()             /* initialize frame error values *
606                   * error should be less than the ambient value divided
607                   * by the returned ray value -- we take half of this.
608                   */
609 <                edone = (BYTE *)calloc(hres*vres, sizeof(BYTE));
610 <                for (y = vres; y--; )
584 <                    for (x = hres; x--; ) {
585 <                        n = fndx(x, y);
609 >                edone = (uby8 *)calloc(hres*vres, sizeof(uby8));
610 >                for (n = hres*vres; n--; ) {
611                          if ((abuffer[n] != ALOWQ) | (obuffer[n] == OVOID))
612                                  continue;
613                          if (!getambcolor(objamb, obuffer[n]))
# Line 599 | Line 624 | comp_frame_error()             /* initialize frame error values *
624                          else if (i >= ADISTANT/2) i = ADISTANT/2-1;
625                          abuffer[n] = i;
626                          edone[n] = 1;
627 <                    }
627 >                }
628          }
629                                          /* final statistical estimate */
630          for (y = vres; y--; )
# Line 632 | Line 657 | comp_frame_error()             /* initialize frame error values *
657  
658  
659   void
660 < init_frame()                    /* render base (low quality) frame */
660 > init_frame(void)                        /* render base (low quality) frame */
661   {
662          int     restart;
638 –
663                                          /* allocate/swap buffers */
664          next_frame();
665                                          /* check rendering status */
666          restart = (!nobjects || vdef(MOVE));
667          if (!restart && curparams != &lorendparams && nprocs > 1)
668                  restart = -1;
645 –        if (restart > 0) {
646 –                if (nprocs > 1)
647 –                        ray_pdone(1);
648 –                else
649 –                        ray_done(1);
650 –        }
669                                          /* post low quality parameters */
670          if (curparams != &lorendparams)
671                  ray_restore(curparams = &lorendparams);
# Line 679 | Line 697 | init_frame()                   /* render base (low quality) frame */
697          init_frame_sample();
698                                          /* initialize frame error */
699          comp_frame_error();
700 < return;
700 > #if 0
701   {
702          float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
703          char    fnm[256];
704 <        register int    n;
704 >        int     n;
705          for (n = hres*vres; n--; )
706                  ebuf[n] = acctab[abuffer[n]];
707          sprintf(fnm, vval(BASENAME), fcur);
# Line 691 | Line 709 | return;
709          write_map(ebuf, fnm);
710          free((void *)ebuf);
711   }
712 + #endif
713   }
714  
715  
716   void
717 < filter_frame()                  /* interpolation, motion-blur, and exposure */
717 > filter_frame(void)                      /* interpolation, motion-blur, and exposure */
718   {
719 <        double  expval = expspec_val(getexp(fcur));
720 <        int     x, y;
721 <        int     neigh[NPINTERP];
722 <        int     nc;
723 <        COLOR   cval;
724 <        double  w, wsum;
725 <        register int    n;
719 >        const double    expval = expspec_val(getexp(fcur));
720 >        int             x, y;
721 >        int             neigh[NPINTERP];
722 >        int             nc;
723 >        COLOR           cval;
724 >        double          w, wsum;
725 >        int             n;
726  
727   #if 0
728 < /* XXX TEMPORARY!! */
729 < conspicuity();
730 < write_map(cerrmap, "outcmap.pic");
731 < {
732 <        float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
733 <        for (n = hres*vres; n--; )
734 <                ebuf[n] = acctab[abuffer[n]];
735 <        write_map(ebuf, "outerr.pic");
736 <        free((void *)ebuf);
737 < }
728 >        /* XXX TEMPORARY!! */
729 >        conspicuity();
730 >        write_map(cerrmap, "outcmap.pic");
731 >        {
732 >                float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
733 >                for (n = hres*vres; n--; )
734 >                        ebuf[n] = acctab[abuffer[n]];
735 >                write_map(ebuf, "outerr.pic");
736 >                free((void *)ebuf);
737 >        }
738   #endif
720 –
739          if (!silent) {
740                  printf("\tFiltering frame\n");
741                  fflush(stdout);
742          }
743                                          /* normalize samples */
744 <        for (y = vres; y--; )
727 <            for (x = hres; x--; ) {
728 <                n = fndx(x, y);
744 >        for (n = hres*vres; n--; ) {
745                  if (sbuffer[n] <= 1)
746                          continue;
747                  w = 1.0/(double)sbuffer[n];
748                  scalecolor(cbuffer[n], w);
749 <            }
749 >        }
750                                          /* interpolate samples */
751          for (y = vres; y--; )
752              for (x = hres; x--; ) {
# Line 739 | Line 755 | write_map(cerrmap, "outcmap.pic");
755                          continue;
756                  nc = getclosest(neigh, NPINTERP, x, y);
757                  setcolor(cbuffer[n], 0., 0., 0.);
758 +                if (nc <= 0) {          /* no acceptable neighbors */
759 +                        if (y < vres-1)
760 +                                nc = fndx(x, y+1);
761 +                        else if (x < hres-1)
762 +                                nc = fndx(x+1, y);
763 +                        else
764 +                                continue;
765 +                        copycolor(cbuffer[n], cbuffer[nc]);
766 +                        continue;
767 +                }
768                  wsum = 0.;
769                  while (nc-- > 0) {
770                          copycolor(cval, cbuffer[neigh[nc]]);
# Line 748 | Line 774 | write_map(cerrmap, "outcmap.pic");
774                          addcolor(cbuffer[n], cval);
775                          wsum += w;
776                  }
777 <                if (wsum > FTINY) {
778 <                        w = 1.0/wsum;
753 <                        scalecolor(cbuffer[n], w);
754 <                }
777 >                w = 1.0/wsum;
778 >                scalecolor(cbuffer[n], w);
779              }
780                                          /* motion blur if requested */
781          if (mblur > .02) {
758 –                int     len;
782                  int     xs, ys, xl, yl;
783                  int     rise, run;
784                  long    rise2, run2;
# Line 793 | Line 816 | write_map(cerrmap, "outcmap.pic");
816                                  while (cnt)
817                                          if (rise2 >= run2) {
818                                                  if ((xl >= 0) & (xl < hres) &
819 <                                                        (yl >= 0) & (yl < vres)) {
819 >                                                    (yl >= 0) & (yl < vres)) {
820                                                          n2 = fndx(xl, yl);
821                                                          addcolor(outbuffer[n2],
822                                                                          cval);
# Line 814 | Line 837 | write_map(cerrmap, "outcmap.pic");
837                                  while (cnt)
838                                          if (run2 >= rise2) {
839                                                  if ((xl >= 0) & (xl < hres) &
840 <                                                        (yl >= 0) & (yl < vres)) {
840 >                                                    (yl >= 0) & (yl < vres)) {
841                                                          n2 = fndx(xl, yl);
842                                                          addcolor(outbuffer[n2],
843                                                                          cval);
# Line 830 | Line 853 | write_map(cerrmap, "outcmap.pic");
853                          }
854                      }
855                                          /* compute final results */
856 <                for (y = vres; y--; )
834 <                    for (x = hres; x--; ) {
835 <                        n = fndx(x, y);
856 >                for (n = hres*vres; n--; ) {
857                          if (wbuffer[n] <= FTINY)
858                                  continue;
859 <                        w = 1./wbuffer[n];
859 >                        w = expval/wbuffer[n];
860                          scalecolor(outbuffer[n], w);
861 <                    }
862 <        } else
863 <                for (n = hres*vres; n--; )
864 <                        copycolor(outbuffer[n], cbuffer[n]);
844 < /*
845 < for (n = hres*vres; n--; )
846 <        if (!sbuffer[n])
847 <                setcolor(outbuffer[n], 0., 0., 0.);
848 < */
849 <                                /* adjust exposure */
850 <        if ((expval < 0.99) | (expval > 1.01))
851 <                for (n = hres*vres; n--; )
861 >                }
862 >        } else {                        /* no blur -- just exposure */
863 >                memcpy(outbuffer, cbuffer, sizeof(COLOR)*hres*vres);
864 >                for (n = ((expval < 0.99) | (expval > 1.01))*hres*vres; n--; )
865                          scalecolor(outbuffer[n], expval);
866 < return;
867 < {
868 <        float   *sbuf = (float *)malloc(sizeof(float)*hres*vres);
869 <        char    fnm[256];
870 <        sprintf(fnm, vval(BASENAME), fcur);
871 <        strcat(fnm, "_outsamp.pic");
872 <        for (n = hres*vres; n--; )
873 <                sbuf[n] = (float)sbuffer[n];
874 <        write_map(sbuf, fnm);
875 <        free((void *)sbuf);
866 >        }
867 >        /*
868 >           for (n = hres*vres; n--; )
869 >                   if (!sbuffer[n])
870 >                           setcolor(outbuffer[n], 0., 0., 0.);
871 >         */
872 > #if 0
873 >        {
874 >                float   *sbuf = (float *)malloc(sizeof(float)*hres*vres);
875 >                char    fnm[256];
876 >                sprintf(fnm, vval(BASENAME), fcur);
877 >                strcat(fnm, "_outsamp.pic");
878 >                for (n = hres*vres; n--; )
879 >                        sbuf[n] = (float)sbuffer[n];
880 >                write_map(sbuf, fnm);
881 >                free((void *)sbuf);
882 >        }
883 > #endif
884   }
864 – }
885  
886  
887   void
888 < send_frame()                    /* send frame to destination */
888 > send_frame(void)                        /* send frame to destination */
889   {
890 <        char    pfname[1024];
890 >        char    fname[1024];
891          double  d;
892          FILE    *fp;
893          int     y;
894                                          /* open output picture */
895 <        sprintf(pfname, vval(BASENAME), fcur);
896 <        strcat(pfname, ".pic");
897 <        fp = fopen(pfname, "w");
895 >        sprintf(fname, vval(BASENAME), fcur);
896 >        strcat(fname, ".hdr");
897 >        fp = fopen(fname, "w");
898          if (fp == NULL) {
899 <                sprintf(errmsg, "cannot open output frame \"%s\"", pfname);
899 >                sprintf(errmsg, "cannot open output frame \"%s\"", fname);
900                  error(SYSTEM, errmsg);
901          }
902          SET_FILE_BINARY(fp);
903          if (!silent) {
904 <                printf("\tWriting to \"%s\"\n", pfname);
904 >                printf("\tWriting to \"%s\"\n", fname);
905                  fflush(stdout);
906          }
907                                          /* write header */
# Line 910 | Line 930 | send_frame()                   /* send frame to destination */
930                          goto writerr;
931          if (fclose(fp) == EOF)
932                  goto writerr;
933 +        if (vdef(ZNAME)) {              /* output z-buffer */
934 +                sprintf(fname, vval(ZNAME), fcur);
935 +                strcat(fname, ".zbf");
936 +                fp = fopen(fname, "w");
937 +                if (fp == NULL) {
938 +                        sprintf(errmsg, "cannot open z-file \"%s\"\n", fname);
939 +                        error(SYSTEM, errmsg);
940 +                }
941 +                SET_FILE_BINARY(fp);
942 +                if (!silent) {
943 +                        printf("\tWriting depths to \"%s\"\n", fname);
944 +                        fflush(stdout);
945 +                }
946 +                for (y = vres; y--; )
947 +                        if (fwrite(zbuffer+y*hres, sizeof(float),
948 +                                                hres, fp) != hres)
949 +                                goto writerr;
950 +                if (fclose(fp) == EOF)
951 +                        goto writerr;
952 +        }
953 +        if (vdef(MNAME)) {              /* output motion buffer */
954 +                unsigned short  *mbuffer = (unsigned short *)malloc(
955 +                                                sizeof(unsigned short)*3*hres);
956 +                int             x, n;
957 +                if (mbuffer == NULL)
958 +                        error(SYSTEM, "out of memory in send_frame");
959 +                sprintf(fname, vval(MNAME), fcur);
960 +                strcat(fname, ".mvo");
961 +                fp = fopen(fname, "w");
962 +                if (fp == NULL) {
963 +                        sprintf(errmsg, "cannot open motion file \"%s\"\n",
964 +                                                        fname);
965 +                        error(SYSTEM, errmsg);
966 +                }
967 +                SET_FILE_BINARY(fp);
968 +                if (!silent) {
969 +                        printf("\tWriting motion vectors to \"%s\"\n", fname);
970 +                        fflush(stdout);
971 +                }
972 +                for (y = vres; y--; ) {
973 +                        for (x = hres; x--; ) {
974 +                                n = fndx(x,y);
975 +                                mbuffer[3*x] = xmbuffer[n] + 0x8000;
976 +                                mbuffer[3*x+1] = ymbuffer[n] + 0x8000;
977 +                                mbuffer[3*x+2] = (oprev[n]!=OVOID)*0x8000;
978 +                        }
979 +                        if (fwrite(mbuffer, sizeof(*mbuffer),
980 +                                                3*hres, fp) != 3*hres)
981 +                                goto writerr;
982 +                }
983 +                free((void *)mbuffer);
984 +                if (fclose(fp) == EOF)
985 +                        goto writerr;
986 +        }
987          return;                         /* all is well */
988   writerr:
989 <        sprintf(errmsg, "error writing frame \"%s\"", pfname);
989 >        sprintf(errmsg, "error writing file \"%s\"", fname);
990          error(SYSTEM, errmsg);
991   }
992  
993  
994   void
995 < free_frame()                    /* free frame allocation */
995 > free_frame(void)                        /* free frame allocation */
996   {
997          if (cbuffer == NULL)
998                  return;

Diff Legend

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