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

Comparing ray/src/rt/ambient.c (file contents):
Revision 2.40 by greg, Tue Jul 9 21:56:44 1996 UTC vs.
Revision 2.94 by greg, Tue Feb 24 19:39:26 2015 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1996 Regents of the University of California */
2 <
3 < #ifndef lint
4 < static char SCCSid[] = "$SunId$ LBL";
5 < #endif
6 <
1 > static const char       RCSid[] = "$Id$";
2   /*
3   *  ambient.c - routines dealing with ambient (inter-reflected) component.
4 + *
5 + *  Declarations of external symbols in ambient.h
6   */
7  
8 < #include  "ray.h"
8 > #include "copyright.h"
9  
10 < #include  "octree.h"
10 > #include <string.h>
11  
12 + #include  "platform.h"
13 + #include  "ray.h"
14   #include  "otypes.h"
15 <
15 > #include  "resolu.h"
16   #include  "ambient.h"
18
17   #include  "random.h"
18 + #include  "pmapamb.h"
19  
20   #ifndef  OCTSCALE
21   #define  OCTSCALE       1.0     /* ceil((valid rad.)/(cube size)) */
22   #endif
23  
25 typedef struct ambtree {
26        AMBVAL  *alist;         /* ambient value list */
27        struct ambtree  *kid;   /* 8 child nodes */
28 }  AMBTREE;                     /* ambient octree */
29
30 extern CUBE  thescene;          /* contains space boundaries */
31
24   extern char  *shm_boundary;     /* memory sharing boundary */
25  
26 < #define  MAXASET        511     /* maximum number of elements in ambient set */
26 > #ifndef  MAXASET
27 > #define  MAXASET        4095    /* maximum number of elements in ambient set */
28 > #endif
29   OBJECT  ambset[MAXASET+1]={0};  /* ambient include/exclude set */
30  
31   double  maxarad;                /* maximum ambient radius */
# Line 43 | Line 37 | static FILE  *ambfp = NULL;    /* ambient file pointer */
37   static int  nunflshed = 0;      /* number of unflushed ambient values */
38  
39   #ifndef SORT_THRESH
40 < #ifdef BIGMEM
41 < #define SORT_THRESH     ((9L<<20)/sizeof(AMBVAL))
40 > #ifdef SMLMEM
41 > #define SORT_THRESH     ((16L<<20)/sizeof(AMBVAL))
42   #else
43 < #define SORT_THRESH     ((3L<<20)/sizeof(AMBVAL))
43 > #define SORT_THRESH     ((64L<<20)/sizeof(AMBVAL))
44   #endif
45   #endif
46   #ifndef SORT_INTVL
47 < #define SORT_INTVL      (SORT_THRESH<<4)
47 > #define SORT_INTVL      (SORT_THRESH<<1)
48   #endif
49   #ifndef MAX_SORT_INTVL
50 < #define MAX_SORT_INTVL  (SORT_INTVL<<8)
50 > #define MAX_SORT_INTVL  (SORT_INTVL<<6)
51   #endif
52  
53 < static COLOR  avsum = BLKCOLOR;         /* computed ambient value sum */
53 >
54 > static double  avsum = 0.;              /* computed ambient value sum (log) */
55 > static unsigned int  navsum = 0;        /* number of values in avsum */
56   static unsigned int  nambvals = 0;      /* total number of indirect values */
57   static unsigned int  nambshare = 0;     /* number of values from file */
58   static unsigned long  ambclock = 0;     /* ambient access clock */
59   static unsigned long  lastsort = 0;     /* time of last value sort */
60   static long  sortintvl = SORT_INTVL;    /* time until next sort */
61 + static FILE  *ambinp = NULL;            /* auxiliary file for input */
62 + static long  lastpos = -1;              /* last flush position */
63  
64   #define MAXACLOCK       (1L<<30)        /* clock turnover value */
65          /*
# Line 69 | Line 67 | static long  sortintvl = SORT_INTVL;   /* time until nex
67           * through memory on a multiprocessor, when we want to avoid
68           * claiming our own memory (copy on write).  Go ahead anyway
69           * if more than two thirds of our values are unshared.
70 +         * Compile with -Dtracktime=0 to turn this code off.
71           */
72 + #ifndef tracktime
73   #define tracktime       (shm_boundary == NULL || nambvals > 3*nambshare)
74 + #endif
75  
76   #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
77  
78 < #define  newambval()    (AMBVAL *)bmalloc(sizeof(AMBVAL))
78 > #define  newambval()    (AMBVAL *)malloc(sizeof(AMBVAL))
79 > #define  freeav(av)     free((void *)av);
80  
81 < extern long  ftell(), lseek();
82 < static int  initambfile(), avsave(), avinsert(), sortambvals(), avlmemi();
83 < static AMBVAL  *avstore();
81 > static void initambfile(int creat);
82 > static void avsave(AMBVAL *av);
83 > static AMBVAL *avstore(AMBVAL  *aval);
84 > static AMBTREE *newambtree(void);
85 > static void freeambtree(AMBTREE  *atp);
86 >
87 > typedef void unloadtf_t(AMBVAL *);
88 > static unloadtf_t avinsert;
89 > static unloadtf_t av2list;
90 > static unloadtf_t avfree;
91 > static void unloadatree(AMBTREE  *at, unloadtf_t *f);
92 >
93 > static int aposcmp(const void *avp1, const void *avp2);
94 > static int avlmemi(AMBVAL *avaddr);
95 > static void sortambvals(int always);
96 >
97   #ifdef  F_SETLKW
98 < static  aflock();
98 > static void aflock(int  typ);
99   #endif
100  
101  
102 < setambres(ar)                           /* set ambient resolution */
103 < int  ar;
102 > void
103 > setambres(                              /* set ambient resolution */
104 >        int  ar
105 > )
106   {
107          ambres = ar < 0 ? 0 : ar;               /* may be done already */
108                                                  /* set min & max radii */
109          if (ar <= 0) {
110                  minarad = 0;
111 <                maxarad = thescene.cusize / 2.0;
111 >                maxarad = thescene.cusize*0.2;
112          } else {
113                  minarad = thescene.cusize / ar;
114 <                maxarad = 64 * minarad;                 /* heuristic */
115 <                if (maxarad > thescene.cusize / 2.0)
116 <                        maxarad = thescene.cusize / 2.0;
114 >                maxarad = 64.0 * minarad;               /* heuristic */
115 >                if (maxarad > thescene.cusize*0.2)
116 >                        maxarad = thescene.cusize*0.2;
117          }
118          if (minarad <= FTINY)
119 <                minarad = 10*FTINY;
119 >                minarad = 10.0*FTINY;
120          if (maxarad <= minarad)
121 <                maxarad = 64 * minarad;
121 >                maxarad = 64.0 * minarad;
122   }
123  
124  
125 < setambacc(newa)                         /* set ambient accuracy */
126 < double  newa;
125 > void
126 > setambacc(                              /* set ambient accuracy */
127 >        double  newa
128 > )
129   {
130 <        double  ambdiff;
131 <
132 <        if (newa < 0.0)
133 <                newa = 0.0;
134 <        ambdiff = fabs(newa - ambacc);
135 <        if (ambdiff >= .01 && (ambacc = newa) > FTINY && nambvals > 0)
136 <                sortambvals(1);                 /* rebuild tree */
130 >        static double   olda;           /* remember previous setting here */
131 >        
132 >        newa *= (newa > 0);
133 >        if (fabs(newa - olda) >= .05*(newa + olda)) {
134 >                ambacc = newa;
135 >                if (nambvals > 0)
136 >                        sortambvals(1);         /* rebuild tree */
137 >        }
138   }
139  
140  
141 < setambient(afile)                       /* initialize calculation */
142 < char  *afile;
141 > void
142 > setambient(void)                                /* initialize calculation */
143   {
144 <        long  pos, flen;
144 >        int     readonly = 0;
145 >        long    flen;
146          AMBVAL  amb;
147 +                                                /* make sure we're fresh */
148 +        ambdone();
149                                                  /* init ambient limits */
150          setambres(ambres);
151          setambacc(ambacc);
152 <        if (afile == NULL)
152 >        if (ambfile == NULL || !ambfile[0])
153                  return;
154          if (ambacc <= FTINY) {
155                  sprintf(errmsg, "zero ambient accuracy so \"%s\" not opened",
156 <                                afile);
156 >                                ambfile);
157                  error(WARNING, errmsg);
158                  return;
159          }
160                                                  /* open ambient file */
161 <        if ((ambfp = fopen(afile, "r+")) != NULL) {
162 <                initambfile(0);
163 <                pos = ftell(ambfp);
161 >        if ((ambfp = fopen(ambfile, "r+")) == NULL)
162 >                readonly = (ambfp = fopen(ambfile, "r")) != NULL;
163 >        if (ambfp != NULL) {
164 >                initambfile(0);                 /* file exists */
165 >                lastpos = ftell(ambfp);
166                  while (readambval(&amb, ambfp))
167 <                        avinsert(avstore(&amb));
168 <                                                /* align */
169 <                pos += (long)nambvals*AMBVALSIZ;
170 <                flen = lseek(fileno(ambfp), 0L, 2);
171 <                if (flen != pos) {
172 <                        error(WARNING,
167 >                        avstore(&amb);
168 >                nambshare = nambvals;           /* share loaded values */
169 >                if (readonly) {
170 >                        sprintf(errmsg,
171 >                                "loaded %u values from read-only ambient file",
172 >                                        nambvals);
173 >                        error(WARNING, errmsg);
174 >                        fclose(ambfp);          /* close file so no writes */
175 >                        ambfp = NULL;
176 >                        return;                 /* avoid ambsync() */
177 >                }
178 >                                                /* align file pointer */
179 >                lastpos += (long)nambvals*AMBVALSIZ;
180 >                flen = lseek(fileno(ambfp), (off_t)0, SEEK_END);
181 >                if (flen != lastpos) {
182 >                        sprintf(errmsg,
183                          "ignoring last %ld values in ambient file (corrupted)",
184 <                                        (flen - pos)/AMBVALSIZ);
185 <                        fseek(ambfp, pos, 0);
186 <                        ftruncate(fileno(ambfp), pos);
184 >                                        (flen - lastpos)/AMBVALSIZ);
185 >                        error(WARNING, errmsg);
186 >                        fseek(ambfp, lastpos, SEEK_SET);
187 > #ifndef _WIN32 /* XXX we need a replacement for that one */
188 >                        ftruncate(fileno(ambfp), (off_t)lastpos);
189 > #endif
190                  }
191 <                nambshare = nambvals;
192 <        } else if ((ambfp = fopen(afile, "w+")) != NULL)
193 <                initambfile(1);
194 <        else {
195 <                sprintf(errmsg, "cannot open ambient file \"%s\"", afile);
191 >        } else if ((ambfp = fopen(ambfile, "w+")) != NULL) {
192 >                initambfile(1);                 /* else create new file */
193 >                fflush(ambfp);
194 >                lastpos = ftell(ambfp);
195 >        } else {
196 >                sprintf(errmsg, "cannot open ambient file \"%s\"", ambfile);
197                  error(SYSTEM, errmsg);
198          }
199 <        nunflshed++;    /* lie */
200 <        ambsync();
199 > #ifdef getc_unlocked
200 >        flockfile(ambfp);                       /* application-level lock */
201 > #endif
202 > #ifdef  F_SETLKW
203 >        aflock(F_UNLCK);                        /* release file */
204 > #endif
205   }
206  
207  
208 < ambnotify(obj)                  /* record new modifier */
209 < OBJECT  obj;
208 > void
209 > ambdone(void)                   /* close ambient file and free memory */
210   {
211 +        if (ambfp != NULL) {            /* close ambient file */
212 +                ambsync();
213 +                fclose(ambfp);
214 +                ambfp = NULL;
215 +                if (ambinp != NULL) {  
216 +                        fclose(ambinp);
217 +                        ambinp = NULL;
218 +                }
219 +                lastpos = -1;
220 +        }
221 +                                        /* free ambient tree */
222 +        unloadatree(&atrunk, &avfree);
223 +                                        /* reset state variables */
224 +        avsum = 0.;
225 +        navsum = 0;
226 +        nambvals = 0;
227 +        nambshare = 0;
228 +        ambclock = 0;
229 +        lastsort = 0;
230 +        sortintvl = SORT_INTVL;
231 + }
232 +
233 +
234 + void
235 + ambnotify(                      /* record new modifier */
236 +        OBJECT  obj
237 + )
238 + {
239          static int  hitlimit = 0;
240 <        register OBJREC  *o = objptr(obj);
241 <        register char  **amblp;
240 >        OBJREC   *o;
241 >        char  **amblp;
242  
243 +        if (obj == OVOID) {             /* starting over */
244 +                ambset[0] = 0;
245 +                hitlimit = 0;
246 +                return;
247 +        }
248 +        o = objptr(obj);
249          if (hitlimit || !ismodifier(o->otype))
250                  return;
251          for (amblp = amblist; *amblp != NULL; amblp++)
# Line 183 | Line 260 | OBJECT obj;
260                  }
261   }
262  
263 + /************ THE FOLLOWING ROUTINES DIFFER BETWEEN NEW & OLD ***************/
264  
265 < ambient(acol, r, nrm)           /* compute ambient component for ray */
266 < COLOR  acol;
267 < register RAY  *r;
268 < FVECT  nrm;
265 > #ifndef OLDAMB
266 >
267 > #define tfunc(lwr, x, upr)      (((x)-(lwr))/((upr)-(lwr)))
268 >
269 > static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
270 > static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
271 >                                AMBTREE *at, FVECT c0, double s);
272 > static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
273 > static int      extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
274 >                                FVECT uvw[3]);
275 >
276 > void
277 > multambient(            /* compute ambient component & multiply by coef. */
278 >        COLOR  aval,
279 >        RAY  *r,
280 >        FVECT  nrm
281 > )
282   {
283          static int  rdepth = 0;                 /* ambient recursion */
284 <        double  d;
284 >        COLOR   acol, caustic;
285 >        int     ok;
286 >        double  d, l;
287  
288 +        /* PMAP: Factor in ambient from photon map, if enabled and ray is
289 +         * ambient. Return as all ambient components accounted for, else
290 +         * continue. */
291 +        if (ambPmap(aval, r, rdepth))
292 +                return;
293 +
294 +        /* PMAP: Factor in specular-diffuse ambient (caustics) from photon
295 +         * map, if enabled and ray is primary, else caustic is zero.  Continue
296 +         * with RADIANCE ambient calculation */
297 +        copycolor(caustic, aval);
298 +        ambPmapCaustic(caustic, r, rdepth);
299 +        
300          if (ambdiv <= 0)                        /* no ambient calculation */
301                  goto dumbamb;
302                                                  /* check number of bounces */
# Line 203 | Line 308 | FVECT  nrm;
308                  goto dumbamb;
309  
310          if (ambacc <= FTINY) {                  /* no ambient storage */
311 +                copycolor(acol, aval);
312                  rdepth++;
313 +                ok = doambient(acol, r, r->rweight,
314 +                                NULL, NULL, NULL, NULL, NULL);
315 +                rdepth--;
316 +                if (!ok)
317 +                        goto dumbamb;
318 +                copycolor(aval, acol);
319 +
320 +                /* PMAP: add in caustic */
321 +                addcolor(aval, caustic);
322 +                return;
323 +        }
324 +
325 +        if (tracktime)                          /* sort to minimize thrashing */
326 +                sortambvals(0);
327 +                                                /* interpolate ambient value */
328 +        setcolor(acol, 0.0, 0.0, 0.0);
329 +        d = sumambient(acol, r, nrm, rdepth,
330 +                        &atrunk, thescene.cuorg, thescene.cusize);
331 +                        
332 +        if (d > FTINY) {
333 +                d = 1.0/d;
334 +                scalecolor(acol, d);
335 +                multcolor(aval, acol);
336 +
337 +                /* PMAP: add in caustic */
338 +                addcolor(aval, caustic);
339 +                return;
340 +        }
341 +        
342 +        rdepth++;                               /* need to cache new value */
343 +        ok = makeambient(acol, r, nrm, rdepth-1);
344 +        rdepth--;
345 +        
346 +        if (ok) {
347 +                multcolor(aval, acol);          /* computed new value */
348 +
349 +                /* PMAP: add in caustic */
350 +                addcolor(aval, caustic);
351 +                return;
352 +        }
353 +        
354 + dumbamb:                                        /* return global value */
355 +        if ((ambvwt <= 0) | (navsum == 0)) {
356 +                multcolor(aval, ambval);
357 +                
358 +                /* PMAP: add in caustic */
359 +                addcolor(aval, caustic);
360 +                return;
361 +        }
362 +        
363 +        l = bright(ambval);                     /* average in computations */  
364 +        if (l > FTINY) {
365 +                d = (log(l)*(double)ambvwt + avsum) /
366 +                                (double)(ambvwt + navsum);
367 +                d = exp(d) / l;
368 +                scalecolor(aval, d);
369 +                multcolor(aval, ambval);        /* apply color of ambval */
370 +        } else {
371 +                d = exp( avsum / (double)navsum );
372 +                scalecolor(aval, d);            /* neutral color */
373 +        }
374 + }
375 +
376 +
377 + /* Plug a potential leak where ambient cache value is occluded */
378 + static int
379 + plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
380 + {
381 +        const double    cost70sq = 0.1169778;   /* cos(70deg)^2 */
382 +        RAY             rtst;
383 +        FVECT           vdif;
384 +        double          normdot, ndotd, nadotd;
385 +        double          a, b, c, t[2];
386 +
387 +        ang += 2.*PI*(ang < 0);                 /* check direction flags */
388 +        if ( !(ap->corral>>(int)(ang*(16./PI)) & 1) )
389 +                return(0);
390 +        /*
391 +         * Generate test ray, targeting 20 degrees above sample point plane
392 +         * along surface normal from cache position.  This should be high
393 +         * enough to miss local geometry we don't really care about.
394 +         */
395 +        VSUB(vdif, ap->pos, r->rop);
396 +        normdot = DOT(anorm, r->ron);
397 +        ndotd = DOT(vdif, r->ron);
398 +        nadotd = DOT(vdif, anorm);
399 +        a = normdot*normdot - cost70sq;
400 +        b = 2.0*(normdot*ndotd - nadotd*cost70sq);
401 +        c = ndotd*ndotd - DOT(vdif,vdif)*cost70sq;
402 +        if (quadratic(t, a, b, c) != 2)
403 +                return(1);                      /* should rarely happen */
404 +        if (t[1] <= FTINY)
405 +                return(0);                      /* should fail behind test */
406 +        rayorigin(&rtst, SHADOW, r, NULL);
407 +        VSUM(rtst.rdir, vdif, anorm, t[1]);     /* further dist. > plane */
408 +        rtst.rmax = normalize(rtst.rdir);       /* short ray test */
409 +        while (localhit(&rtst, &thescene)) {    /* check for occluder */
410 +                if (rtst.ro->omod != OVOID &&
411 +                                (rtst.clipset == NULL ||
412 +                                        !inset(rtst.clipset, rtst.ro->omod)))
413 +                        return(1);              /* plug light leak */
414 +                VCOPY(rtst.rorg, rtst.rop);     /* skip invisible surface */
415 +                rtst.rmax -= rtst.rot;
416 +                rayclear(&rtst);
417 +        }
418 +        return(0);                              /* seems we're OK */
419 + }
420 +
421 +
422 + static double
423 + sumambient(             /* get interpolated ambient value */
424 +        COLOR  acol,
425 +        RAY  *r,
426 +        FVECT  rn,
427 +        int  al,
428 +        AMBTREE  *at,
429 +        FVECT  c0,
430 +        double  s
431 + )
432 + {                       /* initial limit is 10 degrees plus ambacc radians */
433 +        const double    minangle = 10.0 * PI/180.;
434 +        double          maxangle = minangle + ambacc;
435 +        double          wsum = 0.0;
436 +        FVECT           ck0;
437 +        int             i, j;
438 +        AMBVAL          *av;
439 +
440 +        if (at->kid != NULL) {          /* sum children first */                                
441 +                s *= 0.5;
442 +                for (i = 0; i < 8; i++) {
443 +                        for (j = 0; j < 3; j++) {
444 +                                ck0[j] = c0[j];
445 +                                if (1<<j & i)
446 +                                        ck0[j] += s;
447 +                                if (r->rop[j] < ck0[j] - OCTSCALE*s)
448 +                                        break;
449 +                                if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
450 +                                        break;
451 +                        }
452 +                        if (j == 3)
453 +                                wsum += sumambient(acol, r, rn, al,
454 +                                                        at->kid+i, ck0, s);
455 +                }
456 +                                        /* good enough? */
457 +                if (wsum >= 0.05 && s > minarad*10.0)
458 +                        return(wsum);
459 +        }
460 +                                        /* adjust maximum angle */
461 +        if (at->alist != NULL && (at->alist->lvl <= al) & (r->rweight < 0.6))
462 +                maxangle = (maxangle - PI/2.)*pow(r->rweight,0.13) + PI/2.;
463 +                                        /* sum this node */
464 +        for (av = at->alist; av != NULL; av = av->next) {
465 +                double  u, v, d, delta_r2, delta_t2;
466 +                COLOR   ct;
467 +                FVECT   uvw[3];
468 +                                        /* record access */
469 +                if (tracktime)
470 +                        av->latick = ambclock;
471 +                /*
472 +                 *  Ambient level test
473 +                 */
474 +                if (av->lvl > al ||     /* list sorted, so this works */
475 +                                (av->lvl == al) & (av->weight < 0.9*r->rweight))
476 +                        break;
477 +                /*
478 +                 *  Direction test using unperturbed normal
479 +                 */
480 +                decodedir(uvw[2], av->ndir);
481 +                d = DOT(uvw[2], r->ron);
482 +                if (d <= 0.0)           /* >= 90 degrees */
483 +                        continue;
484 +                delta_r2 = 2.0 - 2.0*d; /* approx. radians^2 */
485 +                if (delta_r2 >= maxangle*maxangle)
486 +                        continue;
487 +                /*
488 +                 *  Modified ray behind test
489 +                 */
490 +                VSUB(ck0, r->rop, av->pos);
491 +                d = DOT(ck0, uvw[2]);
492 +                if (d < -minarad*ambacc-.001)
493 +                        continue;
494 +                d /= av->rad[0];
495 +                delta_t2 = d*d;
496 +                if (delta_t2 >= ambacc*ambacc)
497 +                        continue;
498 +                /*
499 +                 *  Elliptical radii test based on Hessian
500 +                 */
501 +                decodedir(uvw[0], av->udir);
502 +                VCROSS(uvw[1], uvw[2], uvw[0]);
503 +                d = (u = DOT(ck0, uvw[0])) / av->rad[0];
504 +                delta_t2 += d*d;
505 +                d = (v = DOT(ck0, uvw[1])) / av->rad[1];
506 +                delta_t2 += d*d;
507 +                if (delta_t2 >= ambacc*ambacc)
508 +                        continue;
509 +                /*
510 +                 *  Test for potential light leak
511 +                 */
512 +                if (av->corral && plugaleak(r, av, uvw[2], atan2a(v,u)))
513 +                        continue;
514 +                /*
515 +                 *  Extrapolate value and compute final weight (hat function)
516 +                 */
517 +                if (!extambient(ct, av, r->rop, rn, uvw))
518 +                        continue;
519 +                d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
520 +                        tfunc(ambacc, sqrt(delta_t2), 0.0);
521 +                scalecolor(ct, d);
522 +                addcolor(acol, ct);
523 +                wsum += d;
524 +        }
525 +        return(wsum);
526 + }
527 +
528 +
529 + static int
530 + makeambient(            /* make a new ambient value for storage */
531 +        COLOR  acol,
532 +        RAY  *r,
533 +        FVECT  rn,
534 +        int  al
535 + )
536 + {
537 +        AMBVAL  amb;
538 +        FVECT   uvw[3];
539 +        int     i;
540 +
541 +        amb.weight = 1.0;                       /* compute weight */
542 +        for (i = al; i-- > 0; )
543 +                amb.weight *= AVGREFL;
544 +        if (r->rweight < 0.1*amb.weight)        /* heuristic override */
545 +                amb.weight = 1.25*r->rweight;
546 +        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
547 +                                                /* compute ambient */
548 +        i = doambient(acol, r, amb.weight,
549 +                        uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
550 +        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
551 +        if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
552 +                return(i);
553 +                                                /* store value */
554 +        VCOPY(amb.pos, r->rop);
555 +        amb.ndir = encodedir(r->ron);
556 +        amb.udir = encodedir(uvw[0]);
557 +        amb.lvl = al;
558 +        copycolor(amb.val, acol);
559 +                                                /* insert into tree */
560 +        avsave(&amb);                           /* and save to file */
561 +        if (rn != r->ron) {                     /* texture */
562 +                VCOPY(uvw[2], r->ron);
563 +                extambient(acol, &amb, r->rop, rn, uvw);
564 +        }
565 +        return(1);
566 + }
567 +
568 +
569 + static int
570 + extambient(             /* extrapolate value at pv, nv */
571 +        COLOR  cr,
572 +        AMBVAL   *ap,
573 +        FVECT  pv,
574 +        FVECT  nv,
575 +        FVECT  uvw[3]
576 + )
577 + {
578 +        const double    min_d = 0.05;
579 +        static FVECT    my_uvw[3];
580 +        FVECT           v1;
581 +        int             i;
582 +        double          d = 1.0;        /* zeroeth order */
583 +
584 +        if (uvw == NULL) {              /* need local coordinates? */
585 +                decodedir(my_uvw[2], ap->ndir);
586 +                decodedir(my_uvw[0], ap->udir);
587 +                VCROSS(my_uvw[1], my_uvw[2], my_uvw[0]);
588 +                uvw = my_uvw;
589 +        }
590 +        for (i = 3; i--; )              /* gradient due to translation */
591 +                d += (pv[i] - ap->pos[i]) *
592 +                        (ap->gpos[0]*uvw[0][i] + ap->gpos[1]*uvw[1][i]);
593 +
594 +        VCROSS(v1, uvw[2], nv);         /* gradient due to rotation */
595 +        for (i = 3; i--; )
596 +                d += v1[i] * (ap->gdir[0]*uvw[0][i] + ap->gdir[1]*uvw[1][i]);
597 +        
598 +        if (d < min_d)                  /* should not use if we can avoid it */
599 +                d = min_d;
600 +        copycolor(cr, ap->val);
601 +        scalecolor(cr, d);
602 +        return(d > min_d);
603 + }
604 +
605 +
606 + static void
607 + avinsert(                               /* insert ambient value in our tree */
608 +        AMBVAL *av
609 + )
610 + {
611 +        AMBTREE  *at;
612 +        AMBVAL  *ap;
613 +        AMBVAL  avh;
614 +        FVECT  ck0;
615 +        double  s;
616 +        int  branch;
617 +        int  i;
618 +
619 +        if (av->rad[0] <= FTINY)
620 +                error(CONSISTENCY, "zero ambient radius in avinsert");
621 +        at = &atrunk;
622 +        VCOPY(ck0, thescene.cuorg);
623 +        s = thescene.cusize;
624 +        while (s*(OCTSCALE/2) > av->rad[1]*ambacc) {
625 +                if (at->kid == NULL)
626 +                        if ((at->kid = newambtree()) == NULL)
627 +                                error(SYSTEM, "out of memory in avinsert");
628 +                s *= 0.5;
629 +                branch = 0;
630 +                for (i = 0; i < 3; i++)
631 +                        if (av->pos[i] > ck0[i] + s) {
632 +                                ck0[i] += s;
633 +                                branch |= 1 << i;
634 +                        }
635 +                at = at->kid + branch;
636 +        }
637 +        avh.next = at->alist;           /* order by increasing level */
638 +        for (ap = &avh; ap->next != NULL; ap = ap->next)
639 +                if ( ap->next->lvl > av->lvl ||
640 +                                (ap->next->lvl == av->lvl) &
641 +                                (ap->next->weight <= av->weight) )
642 +                        break;
643 +        av->next = ap->next;
644 +        ap->next = (AMBVAL*)av;
645 +        at->alist = avh.next;
646 + }
647 +
648 +
649 + #else /* ! NEWAMB */
650 +
651 + static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
652 +                                AMBTREE *at, FVECT c0, double s);
653 + static double   makeambient(COLOR acol, RAY *r, FVECT rn, int al);
654 + static void     extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv);
655 +
656 +
657 + void
658 + multambient(            /* compute ambient component & multiply by coef. */
659 +        COLOR  aval,
660 +        RAY  *r,
661 +        FVECT  nrm
662 + )
663 + {
664 +        static int  rdepth = 0;                 /* ambient recursion */
665 +        COLOR   acol, caustic;
666 +        double  d, l;
667 +
668 +        /* PMAP: Factor in ambient from global photon map (if enabled) and return
669 +         * as all ambient components accounted for */
670 +        if (ambGlobalPmap(aval, r, rdepth))
671 +                return;
672 +
673 +        /* PMAP: Otherwise factor in ambient from caustic photon map
674 +         * (ambCausticPmap() returns zero if caustic photons disabled) and
675 +         * continue with RADIANCE ambient calculation */
676 +        copycolor(caustic, aval);
677 +        ambCausticPmap(caustic, r, rdepth);
678 +        
679 +        if (ambdiv <= 0)                        /* no ambient calculation */
680 +                goto dumbamb;
681 +                                                /* check number of bounces */
682 +        if (rdepth >= ambounce)
683 +                goto dumbamb;
684 +                                                /* check ambient list */
685 +        if (ambincl != -1 && r->ro != NULL &&
686 +                        ambincl != inset(ambset, r->ro->omod))
687 +                goto dumbamb;
688 +
689 +        if (ambacc <= FTINY) {                  /* no ambient storage */
690 +                copycolor(acol, aval);
691 +                rdepth++;
692                  d = doambient(acol, r, r->rweight, NULL, NULL);
693                  rdepth--;
694                  if (d <= FTINY)
695                          goto dumbamb;
696 +                copycolor(aval, acol);          
697 +        
698 +           /* PMAP: add in caustic */
699 +                addcolor(aval, caustic);        
700                  return;
701          }
702  
703          if (tracktime)                          /* sort to minimize thrashing */
704                  sortambvals(0);
705 <                                                /* get ambient value */
705 >                                                /* interpolate ambient value */
706          setcolor(acol, 0.0, 0.0, 0.0);
707          d = sumambient(acol, r, nrm, rdepth,
708                          &atrunk, thescene.cuorg, thescene.cusize);
709 +                        
710          if (d > FTINY) {
711 <                scalecolor(acol, 1.0/d);
711 >                d = 1.0/d;
712 >                scalecolor(acol, d);
713 >                multcolor(aval, acol);
714 >                
715 >                /* PMAP: add in caustic */
716 >                addcolor(aval, caustic);        
717                  return;
718          }
719 +        
720          rdepth++;                               /* need to cache new value */
721          d = makeambient(acol, r, nrm, rdepth-1);
722          rdepth--;
723 <        if (d > FTINY)
723 >        
724 >        if (d > FTINY) {
725 >                multcolor(aval, acol);          /* got new value */
726 >
727 >                /* PMAP: add in caustic */
728 >                addcolor(aval, caustic);                        
729                  return;
730 +        }
731 +        
732   dumbamb:                                        /* return global value */
733 <        copycolor(acol, ambval);
734 <        if (ambvwt <= 0 | nambvals == 0)
733 >        if ((ambvwt <= 0) | (navsum == 0)) {
734 >                multcolor(aval, ambval);
735 >
736 >                /* PMAP: add in caustic */
737 >                addcolor(aval, caustic);        
738                  return;
739 <        scalecolor(acol, (double)ambvwt);
740 <        addcolor(acol, avsum);                  /* average in computations */
741 <        d = 1.0/(ambvwt+nambvals);
742 <        scalecolor(acol, d);
739 >        }
740 >        
741 >        l = bright(ambval);                     /* average in computations */
742 >        if (l > FTINY) {
743 >                d = (log(l)*(double)ambvwt + avsum) /
744 >                                (double)(ambvwt + navsum);
745 >                d = exp(d) / l;
746 >                scalecolor(aval, d);
747 >                multcolor(aval, ambval);        /* apply color of ambval */
748 >        } else {
749 >                d = exp( avsum / (double)navsum );
750 >                scalecolor(aval, d);            /* neutral color */
751 >        }
752   }
753  
754  
755 < double
756 < sumambient(acol, r, rn, al, at, c0, s)  /* get interpolated ambient value */
757 < COLOR  acol;
758 < register RAY  *r;
759 < FVECT  rn;
760 < int  al;
761 < AMBTREE  *at;
762 < FVECT  c0;
763 < double  s;
755 > static double
756 > sumambient(     /* get interpolated ambient value */
757 >        COLOR  acol,
758 >        RAY  *r,
759 >        FVECT  rn,
760 >        int  al,
761 >        AMBTREE  *at,
762 >        FVECT  c0,
763 >        double  s
764 > )
765   {
766          double  d, e1, e2, wt, wsum;
767          COLOR  ct;
768          FVECT  ck0;
769          int  i;
770 <        register int  j;
771 <        register AMBVAL  *av;
770 >        int  j;
771 >        AMBVAL   *av;
772  
773          wsum = 0.0;
774                                          /* do this node */
775          for (av = at->alist; av != NULL; av = av->next) {
776 +                double  rn_dot = -2.0;
777                  if (tracktime)
778                          av->latick = ambclock;
779                  /*
780                   *  Ambient level test.
781                   */
782 <                if (av->lvl > al)       /* list sorted, so this works */
782 >                if (av->lvl > al ||     /* list sorted, so this works */
783 >                                (av->lvl == al) & (av->weight < 0.9*r->rweight))
784                          break;
267                if (av->weight < r->rweight-FTINY)
268                        continue;
785                  /*
786                   *  Ambient radius test.
787                   */
788 <                d = av->pos[0] - r->rop[0];
789 <                e1 = d * d;
274 <                d = av->pos[1] - r->rop[1];
275 <                e1 += d * d;
276 <                d = av->pos[2] - r->rop[2];
277 <                e1 += d * d;
278 <                e1 /= av->rad * av->rad;
788 >                VSUB(ck0, av->pos, r->rop);
789 >                e1 = DOT(ck0, ck0) / (av->rad * av->rad);
790                  if (e1 > ambacc*ambacc*1.21)
791                          continue;
792                  /*
793 <                 *  Normal direction test.
793 >                 *  Direction test using closest normal.
794                   */
795 <                e2 = (1.0 - DOT(av->dir, r->ron)) * r->rweight;
796 <                if (e2 < 0.0) e2 = 0.0;
797 <                if (e1 + e2 > ambacc*ambacc*1.21)
795 >                d = DOT(av->dir, r->ron);
796 >                if (rn != r->ron) {
797 >                        rn_dot = DOT(av->dir, rn);
798 >                        if (rn_dot > 1.0-FTINY)
799 >                                rn_dot = 1.0-FTINY;
800 >                        if (rn_dot >= d-FTINY) {
801 >                                d = rn_dot;
802 >                                rn_dot = -2.0;
803 >                        }
804 >                }
805 >                e2 = (1.0 - d) * r->rweight;
806 >                if (e2 < 0.0)
807 >                        e2 = 0.0;
808 >                else if (e1 + e2 > ambacc*ambacc*1.21)
809                          continue;
810                  /*
811                   *  Ray behind test.
# Line 297 | Line 819 | double s;
819                  /*
820                   *  Jittering final test reduces image artifacts.
821                   */
822 <                wt = sqrt(e1) + sqrt(e2);
822 >                e1 = sqrt(e1);
823 >                e2 = sqrt(e2);
824 >                wt = e1 + e2;
825                  if (wt > ambacc*(.9+.2*urand(9015+samplendx)))
826                          continue;
827 +                /*
828 +                 *  Recompute directional error using perturbed normal
829 +                 */
830 +                if (rn_dot > 0.0) {
831 +                        e2 = sqrt((1.0 - rn_dot)*r->rweight);
832 +                        wt = e1 + e2;
833 +                }
834                  if (wt <= 1e-3)
835                          wt = 1e3;
836                  else
# Line 324 | Line 855 | double s;
855                                  break;
856                  }
857                  if (j == 3)
858 <                        wsum += sumambient(acol, r, rn, al, at->kid+i, ck0, s);
858 >                        wsum += sumambient(acol, r, rn, al,
859 >                                                at->kid+i, ck0, s);
860          }
861          return(wsum);
862   }
863  
864  
865 < double
866 < makeambient(acol, r, rn, al)    /* make a new ambient value */
867 < COLOR  acol;
868 < register RAY  *r;
869 < FVECT  rn;
870 < int  al;
865 > static double
866 > makeambient(            /* make a new ambient value for storage */
867 >        COLOR  acol,
868 >        RAY  *r,
869 >        FVECT  rn,
870 >        int  al
871 > )
872   {
873          AMBVAL  amb;
874          FVECT   gp, gd;
875 <                                                /* compute weight */
876 <        amb.weight = pow(AVGREFL, (double)al);
877 <        if (r->rweight < 0.1*amb.weight)        /* heuristic */
878 <                amb.weight = r->rweight;
875 >        int     i;
876 >
877 >        amb.weight = 1.0;                       /* compute weight */
878 >        for (i = al; i-- > 0; )
879 >                amb.weight *= AVGREFL;
880 >        if (r->rweight < 0.1*amb.weight)        /* heuristic override */
881 >                amb.weight = 1.25*r->rweight;
882 >        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
883                                                  /* compute ambient */
884          amb.rad = doambient(acol, r, amb.weight, gp, gd);
885 <        if (amb.rad <= FTINY)
885 >        if (amb.rad <= FTINY) {
886 >                setcolor(acol, 0.0, 0.0, 0.0);
887                  return(0.0);
888 <                                                /* store it */
888 >        }
889 >        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
890 >                                                /* store value */
891          VCOPY(amb.pos, r->rop);
892          VCOPY(amb.dir, r->ron);
893          amb.lvl = al;
# Line 362 | Line 902 | int  al;
902   }
903  
904  
905 < extambient(cr, ap, pv, nv)              /* extrapolate value at pv, nv */
906 < COLOR  cr;
907 < register AMBVAL  *ap;
908 < FVECT  pv, nv;
905 > static void
906 > extambient(             /* extrapolate value at pv, nv */
907 >        COLOR  cr,
908 >        AMBVAL   *ap,
909 >        FVECT  pv,
910 >        FVECT  nv
911 > )
912   {
913 <        FVECT  v1, v2;
914 <        register int  i;
913 >        FVECT  v1;
914 >        int  i;
915          double  d;
916  
917          d = 1.0;                        /* zeroeth order */
# Line 376 | Line 919 | FVECT  pv, nv;
919          for (i = 0; i < 3; i++)
920                  d += ap->gpos[i]*(pv[i]-ap->pos[i]);
921                                          /* gradient due to rotation */
922 <        VCOPY(v1, ap->dir);
923 <        fcross(v2, v1, nv);
381 <        d += DOT(ap->gdir, v2);
922 >        VCROSS(v1, ap->dir, nv);
923 >        d += DOT(ap->gdir, v1);
924          if (d <= 0.0) {
925                  setcolor(cr, 0.0, 0.0, 0.0);
926                  return;
# Line 388 | Line 930 | FVECT  pv, nv;
930   }
931  
932  
933 < static
934 < initambfile(creat)              /* initialize ambient file */
935 < int  creat;
933 > static void
934 > avinsert(                               /* insert ambient value in our tree */
935 >        AMBVAL *av
936 > )
937   {
938 <        extern char  *progname, *octname, VersionID[];
938 >        AMBTREE  *at;
939 >        AMBVAL  *ap;
940 >        AMBVAL  avh;
941 >        FVECT  ck0;
942 >        double  s;
943 >        int  branch;
944 >        int  i;
945  
946 +        if (av->rad <= FTINY)
947 +                error(CONSISTENCY, "zero ambient radius in avinsert");
948 +        at = &atrunk;
949 +        VCOPY(ck0, thescene.cuorg);
950 +        s = thescene.cusize;
951 +        while (s*(OCTSCALE/2) > av->rad*ambacc) {
952 +                if (at->kid == NULL)
953 +                        if ((at->kid = newambtree()) == NULL)
954 +                                error(SYSTEM, "out of memory in avinsert");
955 +                s *= 0.5;
956 +                branch = 0;
957 +                for (i = 0; i < 3; i++)
958 +                        if (av->pos[i] > ck0[i] + s) {
959 +                                ck0[i] += s;
960 +                                branch |= 1 << i;
961 +                        }
962 +                at = at->kid + branch;
963 +        }
964 +        avh.next = at->alist;           /* order by increasing level */
965 +        for (ap = &avh; ap->next != NULL; ap = ap->next)
966 +                if ( ap->next->lvl > av->lvl ||
967 +                                (ap->next->lvl == av->lvl) &
968 +                                (ap->next->weight <= av->weight) )
969 +                        break;
970 +        av->next = ap->next;
971 +        ap->next = (AMBVAL*)av;
972 +        at->alist = avh.next;
973 + }
974 +
975 + #endif  /* ! NEWAMB */
976 +
977 + /************* FOLLOWING ROUTINES SAME FOR NEW & OLD METHODS ***************/
978 +
979 + static void
980 + initambfile(            /* initialize ambient file */
981 +        int  cre8
982 + )
983 + {
984 +        extern char  *progname, *octname;
985 +        static char  *mybuf = NULL;
986 +
987   #ifdef  F_SETLKW
988 <        aflock(creat ? F_WRLCK : F_RDLCK);
988 >        aflock(cre8 ? F_WRLCK : F_RDLCK);
989   #endif
990 < #ifdef MSDOS
991 <        setmode(fileno(ambfp), O_BINARY);
992 < #endif
993 <        setbuf(ambfp, bmalloc(BUFSIZ+8));
994 <        if (creat) {                    /* new file */
990 >        SET_FILE_BINARY(ambfp);
991 >        if (mybuf == NULL)
992 >                mybuf = (char *)bmalloc(BUFSIZ+8);
993 >        setbuf(ambfp, mybuf);
994 >        if (cre8) {                     /* new file */
995                  newheader("RADIANCE", ambfp);
996 <                fprintf(ambfp, "%s -av %g %g %g -ab %d -aa %g ",
996 >                fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
997                                  progname, colval(ambval,RED),
998                                  colval(ambval,GRN), colval(ambval,BLU),
999 <                                ambounce, ambacc);
1000 <                fprintf(ambfp, "-ad %d -as %d -ar %d %s\n",
1001 <                                ambdiv, ambssamp, ambres,
1002 <                                octname==NULL ? "" : octname);
999 >                                ambvwt, ambounce, ambacc);
1000 >                fprintf(ambfp, "-ad %d -as %d -ar %d ",
1001 >                                ambdiv, ambssamp, ambres);
1002 >                if (octname != NULL)
1003 >                        fputs(octname, ambfp);
1004 >                fputc('\n', ambfp);
1005                  fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
1006 +                fputnow(ambfp);
1007                  fputformat(AMBFMT, ambfp);
1008 <                putc('\n', ambfp);
1008 >                fputc('\n', ambfp);
1009                  putambmagic(ambfp);
1010          } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
1011                  error(USER, "bad ambient file");
1012   }
1013  
1014  
1015 < static
1016 < avsave(av)                              /* insert and save an ambient value */
1017 < AMBVAL  *av;
1015 > static void
1016 > avsave(                         /* insert and save an ambient value */
1017 >        AMBVAL  *av
1018 > )
1019   {
1020 <        avinsert(avstore(av));
1020 >        avstore(av);
1021          if (ambfp == NULL)
1022                  return;
1023          if (writambval(av, ambfp) < 0)
# Line 433 | Line 1027 | AMBVAL *av;
1027                          goto writerr;
1028          return;
1029   writerr:
1030 <        error(SYSTEM, "error writing ambient file");
1030 >        error(SYSTEM, "error writing to ambient file");
1031   }
1032  
1033  
1034   static AMBVAL *
1035 < avstore(aval)                           /* allocate memory and store aval */
1036 < register AMBVAL  *aval;
1035 > avstore(                                /* allocate memory and save aval */
1036 >        AMBVAL  *aval
1037 > )
1038   {
1039 <        register AMBVAL  *av;
1039 >        AMBVAL  *av;
1040 >        double  d;
1041  
1042          if ((av = newambval()) == NULL)
1043                  error(SYSTEM, "out of memory in avstore");
1044 <        copystruct(av, aval);
1044 >        *av = *aval;
1045          av->latick = ambclock;
1046          av->next = NULL;
451        addcolor(avsum, av->val);       /* add to sum for averaging */
1047          nambvals++;
1048 +        d = bright(av->val);
1049 +        if (d > FTINY) {                /* add to log sum for averaging */
1050 +                avsum += log(d);
1051 +                navsum++;
1052 +        }
1053 +        avinsert(av);                   /* insert in our cache tree */
1054          return(av);
1055   }
1056  
# Line 459 | Line 1060 | register AMBVAL  *aval;
1060   static AMBTREE  *atfreelist = NULL;     /* free ambient tree structures */
1061  
1062  
1063 < static
1064 < AMBTREE *
464 < newambtree()                            /* allocate 8 ambient tree structs */
1063 > static AMBTREE *
1064 > newambtree(void)                                /* allocate 8 ambient tree structs */
1065   {
1066 <        register AMBTREE  *atp, *upperlim;
1066 >        AMBTREE  *atp, *upperlim;
1067  
1068          if (atfreelist == NULL) {       /* get more nodes */
1069 <                atfreelist = (AMBTREE *)bmalloc(ATALLOCSZ*8*sizeof(AMBTREE));
1069 >                atfreelist = (AMBTREE *)malloc(ATALLOCSZ*8*sizeof(AMBTREE));
1070                  if (atfreelist == NULL)
1071                          return(NULL);
1072                                          /* link new free list */
# Line 477 | Line 1077 | newambtree()                           /* allocate 8 ambient tree structs */
1077          }
1078          atp = atfreelist;
1079          atfreelist = atp->kid;
1080 <        bzero((char *)atp, 8*sizeof(AMBTREE));
1080 >        memset((char *)atp, '\0', 8*sizeof(AMBTREE));
1081          return(atp);
1082   }
1083  
1084  
1085 < static
1086 < freeambtree(atp)                        /* free 8 ambient tree structs */
1087 < AMBTREE  *atp;
1085 > static void
1086 > freeambtree(                    /* free 8 ambient tree structs */
1087 >        AMBTREE  *atp
1088 > )
1089   {
1090          atp->kid = atfreelist;
1091          atfreelist = atp;
1092   }
1093  
1094  
1095 < static
1096 < avinsert(av)                            /* insert ambient value in our tree */
1097 < register AMBVAL  *av;
1095 > static void
1096 > unloadatree(                    /* unload an ambient value tree */
1097 >        AMBTREE  *at,
1098 >        unloadtf_t *f
1099 > )
1100   {
1101 <        register AMBTREE  *at;
1102 <        register AMBVAL  *ap;
500 <        AMBVAL  avh;
501 <        FVECT  ck0;
502 <        double  s;
503 <        int  branch;
504 <        register int  i;
505 <
506 <        if (av->rad <= FTINY)
507 <                error(CONSISTENCY, "zero ambient radius in avinsert");
508 <        at = &atrunk;
509 <        VCOPY(ck0, thescene.cuorg);
510 <        s = thescene.cusize;
511 <        while (s*(OCTSCALE/2) > av->rad*ambacc) {
512 <                if (at->kid == NULL)
513 <                        if ((at->kid = newambtree()) == NULL)
514 <                                error(SYSTEM, "out of memory in avinsert");
515 <                s *= 0.5;
516 <                branch = 0;
517 <                for (i = 0; i < 3; i++)
518 <                        if (av->pos[i] > ck0[i] + s) {
519 <                                ck0[i] += s;
520 <                                branch |= 1 << i;
521 <                        }
522 <                at = at->kid + branch;
523 <        }
524 <        avh.next = at->alist;           /* order by increasing level */
525 <        for (ap = &avh; ap->next != NULL; ap = ap->next)
526 <                if (ap->next->lvl >= av->lvl)
527 <                        break;
528 <        av->next = ap->next;
529 <        ap->next = av;
530 <        at->alist = avh.next;
531 < }
532 <
533 <
534 < static
535 < unloadatree(at, f)                      /* unload an ambient value tree */
536 < register AMBTREE  *at;
537 < int     (*f)();
538 < {
539 <        register AMBVAL  *av;
540 <        register int  i;
1101 >        AMBVAL  *av;
1102 >        int  i;
1103                                          /* transfer values at this node */
1104          for (av = at->alist; av != NULL; av = at->alist) {
1105                  at->alist = av->next;
# Line 559 | Line 1121 | static struct avl {
1121   static AMBVAL   **avlist2;              /* memory positions for sorting */
1122   static int      i_avlist;               /* index for lists */
1123  
1124 + static int alatcmp(const void *av1, const void *av2);
1125  
1126 < static
1127 < av2list(av)
565 < register AMBVAL *av;
1126 > static void
1127 > avfree(AMBVAL *av)
1128   {
1129 +        free(av);
1130 + }
1131 +
1132 + static void
1133 + av2list(
1134 +        AMBVAL *av
1135 + )
1136 + {
1137   #ifdef DEBUG
1138          if (i_avlist >= nambvals)
1139                  error(CONSISTENCY, "too many ambient values in av2list1");
1140   #endif
1141 <        avlist1[i_avlist].p = avlist2[i_avlist] = av;
1141 >        avlist1[i_avlist].p = avlist2[i_avlist] = (AMBVAL*)av;
1142          avlist1[i_avlist++].t = av->latick;
1143   }
1144  
1145  
1146   static int
1147 < alatcmp(av1, av2)                       /* compare ambient values for MRA */
1148 < struct avl      *av1, *av2;
1147 > alatcmp(                        /* compare ambient values for MRA */
1148 >        const void *av1,
1149 >        const void *av2
1150 > )
1151   {
1152 <        register long  lc = av2->t - av1->t;
1152 >        long  lc = ((struct avl *)av2)->t - ((struct avl *)av1)->t;
1153          return(lc<0 ? -1 : lc>0 ? 1 : 0);
1154   }
1155  
1156  
1157 + /* GW NOTE 2002/10/3:
1158 + * I used to compare AMBVAL pointers, but found that this was the
1159 + * cause of a serious consistency error with gcc, since the optimizer
1160 + * uses some dangerous trick in pointer subtraction that
1161 + * assumes pointers differ by exact struct size increments.
1162 + */
1163   static int
1164 < aposcmp(avp1, avp2)                     /* compare ambient value positions */
1165 < AMBVAL  **avp1, **avp2;
1164 > aposcmp(                        /* compare ambient value positions */
1165 >        const void      *avp1,
1166 >        const void      *avp2
1167 > )
1168   {
1169 <        return(*avp1 - *avp2);
1169 >        long    diff = *(char * const *)avp1 - *(char * const *)avp2;
1170 >        if (diff < 0)
1171 >                return(-1);
1172 >        return(diff > 0);
1173   }
1174  
1175  
593 #if 1
1176   static int
1177 < avlmemi(avaddr)                         /* find list position from address */
1178 < AMBVAL  *avaddr;
1177 > avlmemi(                                /* find list position from address */
1178 >        AMBVAL  *avaddr
1179 > )
1180   {
1181 <        register AMBVAL  **avlpp;
1181 >        AMBVAL  **avlpp;
1182  
1183          avlpp = (AMBVAL **)bsearch((char *)&avaddr, (char *)avlist2,
1184 <                        nambvals, sizeof(AMBVAL *), aposcmp);
1184 >                        nambvals, sizeof(AMBVAL *), &aposcmp);
1185          if (avlpp == NULL)
1186                  error(CONSISTENCY, "address not found in avlmemi");
1187          return(avlpp - avlist2);
1188   }
606 #else
607 #define avlmemi(avaddr) ((AMBVAL **)bsearch((char *)&avaddr,(char *)avlist2, \
608                                nambvals,sizeof(AMBVAL *),aposcmp) - avlist2)
609 #endif
1189  
1190  
1191 < static
1192 < sortambvals(always)                     /* resort ambient values */
1193 < int     always;
1191 > static void
1192 > sortambvals(                    /* resort ambient values */
1193 >        int     always
1194 > )
1195   {
1196          AMBTREE  oldatrunk;
1197          AMBVAL  tav, *tap, *pnext;
1198 <        register int    i, j;
1198 >        int     i, j;
1199                                          /* see if it's time yet */
1200          if (!always && (ambclock++ < lastsort+sortintvl ||
1201                          nambvals < SORT_THRESH))
# Line 644 | Line 1224 | int    always;
1224          }
1225          if (avlist1 == NULL) {          /* no time tracking -- rebuild tree? */
1226                  if (avlist2 != NULL)
1227 <                        free((char *)avlist2);
1227 >                        free((void *)avlist2);
1228                  if (always) {           /* rebuild without sorting */
1229 <                        copystruct(&oldatrunk, &atrunk);
1229 >                        oldatrunk = atrunk;
1230                          atrunk.alist = NULL;
1231                          atrunk.kid = NULL;
1232 <                        unloadatree(&oldatrunk, avinsert);
1232 >                        unloadatree(&oldatrunk, &avinsert);
1233                  }
1234          } else {                        /* sort memory by last access time */
1235                  /*
# Line 666 | Line 1246 | int    always;
1246                  eputs(errmsg);
1247   #endif
1248                  i_avlist = 0;
1249 <                unloadatree(&atrunk, av2list);  /* empty current tree */
1249 >                unloadatree(&atrunk, &av2list); /* empty current tree */
1250   #ifdef DEBUG
1251                  if (i_avlist < nambvals)
1252                          error(CONSISTENCY, "missing ambient values in sortambvals");
# Line 677 | Line 1257 | int    always;
1257                          if (avlist1[i].p == NULL)
1258                                  continue;
1259                          tap = avlist2[i];
1260 <                        copystruct(&tav, tap);
1260 >                        tav = *tap;
1261                          for (j = i; (pnext = avlist1[j].p) != tap;
1262                                          j = avlmemi(pnext)) {
1263 <                                copystruct(avlist2[j], pnext);
1263 >                                *(avlist2[j]) = *pnext;
1264                                  avinsert(avlist2[j]);
1265                                  avlist1[j].p = NULL;
1266                          }
1267 <                        copystruct(avlist2[j], &tav);
1267 >                        *(avlist2[j]) = tav;
1268                          avinsert(avlist2[j]);
1269                          avlist1[j].p = NULL;
1270                  }
1271 <                free((char *)avlist1);
1272 <                free((char *)avlist2);
1271 >                free((void *)avlist1);
1272 >                free((void *)avlist2);
1273                                                  /* compute new sort interval */
1274                  sortintvl = ambclock - lastsort;
1275                  if (sortintvl >= MAX_SORT_INTVL/2)
# Line 708 | Line 1288 | int    always;
1288  
1289   #ifdef  F_SETLKW
1290  
1291 < static
1292 < aflock(typ)                     /* lock/unlock ambient file */
1293 < int  typ;
1291 > static void
1292 > aflock(                 /* lock/unlock ambient file */
1293 >        int  typ
1294 > )
1295   {
1296          static struct flock  fls;       /* static so initialized to zeroes */
1297  
1298 +        if (typ == fls.l_type)          /* already called? */
1299 +                return;
1300          fls.l_type = typ;
1301          if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
1302                  error(SYSTEM, "cannot (un)lock ambient file");
# Line 721 | Line 1304 | int  typ;
1304  
1305  
1306   int
1307 < ambsync()                       /* synchronize ambient file */
1307 > ambsync(void)                   /* synchronize ambient file */
1308   {
726        static FILE  *ambinp = NULL;
727        static long  lastpos = -1;
1309          long  flen;
1310          AMBVAL  avs;
1311 <        register int  n;
1311 >        int  n;
1312  
1313 <        if (nunflshed == 0)
1313 >        if (ambfp == NULL)      /* no ambient file? */
1314                  return(0);
1315 <        if (lastpos < 0)        /* initializing (locked in initambfile) */
1316 <                goto syncend;
736 <                                /* gain exclusive access */
737 <        aflock(F_WRLCK);
1315 >                                /* gain appropriate access */
1316 >        aflock(nunflshed ? F_WRLCK : F_RDLCK);
1317                                  /* see if file has grown */
1318 <        if ((flen = lseek(fileno(ambfp), 0L, 2)) < 0)
1318 >        if ((flen = lseek(fileno(ambfp), (off_t)0, SEEK_END)) < 0)
1319                  goto seekerr;
1320 <        if (n = flen - lastpos) {               /* file has grown */
1320 >        if ((n = flen - lastpos) > 0) {         /* file has grown */
1321                  if (ambinp == NULL) {           /* use duplicate filedes */
1322                          ambinp = fdopen(dup(fileno(ambfp)), "r");
1323                          if (ambinp == NULL)
1324                                  error(SYSTEM, "fdopen failed in ambsync");
1325                  }
1326 <                if (fseek(ambinp, lastpos, 0) < 0)
1326 >                if (fseek(ambinp, lastpos, SEEK_SET) < 0)
1327                          goto seekerr;
1328                  while (n >= AMBVALSIZ) {        /* load contributed values */
1329                          if (!readambval(&avs, ambinp)) {
1330                                  sprintf(errmsg,
1331 <                                "ambient file corrupted near character %ld",
1332 <                                                flen - n);
1331 >                        "ambient file \"%s\" corrupted near character %ld",
1332 >                                                ambfile, flen - n);
1333                                  error(WARNING, errmsg);
1334                                  break;
1335                          }
1336 <                        avinsert(avstore(&avs));
1336 >                        avstore(&avs);
1337                          n -= AMBVALSIZ;
1338                  }
1339 +                lastpos = flen - n;
1340                  /*** seek always as safety measure
1341                  if (n) ***/                     /* alignment */
1342 <                        if (lseek(fileno(ambfp), flen-n, 0) < 0)
1342 >                        if (lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0)
1343                                  goto seekerr;
1344          }
765 #ifdef  DEBUG
766        if (ambfp->_ptr - ambfp->_base != nunflshed*AMBVALSIZ) {
767                sprintf(errmsg, "ambient file buffer at %d rather than %d",
768                                ambfp->_ptr - ambfp->_base,
769                                nunflshed*AMBVALSIZ);
770                error(CONSISTENCY, errmsg);
771        }
772 #endif
773 syncend:
1345          n = fflush(ambfp);                      /* calls write() at last */
1346 <        if ((lastpos = lseek(fileno(ambfp), 0L, 1)) < 0)
1346 >        if (n != EOF)
1347 >                lastpos += (long)nunflshed*AMBVALSIZ;
1348 >        else if ((lastpos = lseek(fileno(ambfp), (off_t)0, SEEK_CUR)) < 0)
1349                  goto seekerr;
1350 +                
1351          aflock(F_UNLCK);                        /* release file */
1352          nunflshed = 0;
1353          return(n);
1354   seekerr:
1355          error(SYSTEM, "seek failed in ambsync");
1356 +        return -1; /* pro forma return */
1357   }
1358  
1359 < #else
1359 > #else   /* ! F_SETLKW */
1360  
1361   int
1362 < ambsync()                       /* flush ambient file */
1362 > ambsync(void)                   /* flush ambient file */
1363   {
1364 <        if (nunflshed == 0)
1364 >        if (ambfp == NULL)
1365                  return(0);
1366          nunflshed = 0;
1367          return(fflush(ambfp));
1368   }
1369  
1370 < #endif
1370 > #endif  /* ! F_SETLKW */

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines