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.81 by greg, Fri Apr 25 23:04:16 2014 UTC vs.
Revision 2.131 by greg, Thu Jan 23 22:03:08 2025 UTC

# Line 1 | Line 1
1 #ifndef lint
1   static const char       RCSid[] = "$Id$";
3 #endif
2   /*
3   *  ambient.c - routines dealing with ambient (inter-reflected) component.
4   *
# Line 14 | Line 12 | static const char      RCSid[] = "$Id$";
12   #include  "platform.h"
13   #include  "ray.h"
14   #include  "otypes.h"
15 + #include  "otspecial.h"
16   #include  "resolu.h"
17   #include  "ambient.h"
18   #include  "random.h"
19 + #include  "pmapamb.h"
20  
21   #ifndef  OCTSCALE
22   #define  OCTSCALE       1.0     /* ceil((valid rad.)/(cube size)) */
23   #endif
24  
25 extern char  *shm_boundary;     /* memory sharing boundary */
26
25   #ifndef  MAXASET
26   #define  MAXASET        4095    /* maximum number of elements in ambient set */
27   #endif
# Line 35 | Line 33 | double minarad;                /* minimum ambient radius */
33   static AMBTREE  atrunk;         /* our ambient trunk node */
34  
35   static FILE  *ambfp = NULL;     /* ambient file pointer */
36 < static int  nunflshed = 0;      /* number of unflushed ambient values */
36 > static int  nunflshed;          /* number of unflushed ambient values */
37  
40 #ifndef SORT_THRESH
41 #ifdef SMLMEM
42 #define SORT_THRESH     ((16L<<20)/sizeof(AMBVAL))
43 #else
44 #define SORT_THRESH     ((64L<<20)/sizeof(AMBVAL))
45 #endif
46 #endif
47 #ifndef SORT_INTVL
48 #define SORT_INTVL      (SORT_THRESH<<1)
49 #endif
50 #ifndef MAX_SORT_INTVL
51 #define MAX_SORT_INTVL  (SORT_INTVL<<6)
52 #endif
53
54
55 static double  qambacc = 0.;            /* ambient accuracy to the 1/4 power */
38   static double  avsum = 0.;              /* computed ambient value sum (log) */
39   static unsigned int  navsum = 0;        /* number of values in avsum */
40   static unsigned int  nambvals = 0;      /* total number of indirect values */
59 static unsigned int  nambshare = 0;     /* number of values from file */
60 static unsigned long  ambclock = 0;     /* ambient access clock */
61 static unsigned long  lastsort = 0;     /* time of last value sort */
62 static long  sortintvl = SORT_INTVL;    /* time until next sort */
41   static FILE  *ambinp = NULL;            /* auxiliary file for input */
42 < static long  lastpos = -1;              /* last flush position */
42 > static off_t  lastpos = -1;             /* last flush position */
43  
66 #define MAXACLOCK       (1L<<30)        /* clock turnover value */
67        /*
68         * Track access times unless we are sharing ambient values
69         * through memory on a multiprocessor, when we want to avoid
70         * claiming our own memory (copy on write).  Go ahead anyway
71         * if more than two thirds of our values are unshared.
72         * Compile with -Dtracktime=0 to turn this code off.
73         */
74 #ifndef tracktime
75 #define tracktime       (shm_boundary == NULL || nambvals > 3*nambshare)
76 #endif
77
44   #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
45  
46 < #define  newambval()    (AMBVAL *)malloc(sizeof(AMBVAL))
47 < #define  freeav(av)     free((void *)av);
46 > #define  AVSIZE         (sizeof(AMBVAL)-sizeof(SCOLOR)+sizeof(COLORV)*NCSAMP)
47 > #define  newambval()    (AMBVAL *)malloc(AVSIZE)
48  
49 < static void initambfile(int creat);
49 > #define  tfunc(x0, x, x1)       (((x)-(x0))/((x1)-(x0)))
50 >
51 > static void initambfile(int cre8);
52   static void avsave(AMBVAL *av);
53   static AMBVAL *avstore(AMBVAL  *aval);
54   static AMBTREE *newambtree(void);
# Line 88 | Line 56 | static void freeambtree(AMBTREE  *atp);
56  
57   typedef void unloadtf_t(AMBVAL *);
58   static unloadtf_t avinsert;
91 static unloadtf_t av2list;
59   static unloadtf_t avfree;
60   static void unloadatree(AMBTREE  *at, unloadtf_t *f);
61  
62 < static int aposcmp(const void *avp1, const void *avp2);
96 < static int avlmemi(AMBVAL *avaddr);
97 < static void sortambvals(int always);
62 > static void sortambvals(void);
63  
64 + static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
65 + static double   sumambient(SCOLOR acol, RAY *r, FVECT rn, int al,
66 +                                AMBTREE *at, FVECT c0, double s);
67 + static int      makeambient(SCOLOR acol, RAY *r, FVECT rn, int al);
68 + static int      extambient(SCOLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
69 +                                FVECT uvw[3]);
70 +
71   #ifdef  F_SETLKW
72   static void aflock(int  typ);
73   #endif
# Line 110 | Line 82 | setambres(                             /* set ambient resolution */
82                                                  /* set min & max radii */
83          if (ar <= 0) {
84                  minarad = 0;
85 <                maxarad = thescene.cusize / 2.0;
85 >                maxarad = thescene.cusize*0.2;
86          } else {
87                  minarad = thescene.cusize / ar;
88 <                maxarad = 64 * minarad;                 /* heuristic */
89 <                if (maxarad > thescene.cusize / 2.0)
90 <                        maxarad = thescene.cusize / 2.0;
88 >                maxarad = 64.0 * minarad;               /* heuristic */
89 >                if (maxarad > thescene.cusize*0.2)
90 >                        maxarad = thescene.cusize*0.2;
91          }
92          if (minarad <= FTINY)
93 <                minarad = 10*FTINY;
93 >                minarad = 10.0*FTINY;
94          if (maxarad <= minarad)
95 <                maxarad = 64 * minarad;
95 >                maxarad = 64.0 * minarad;
96   }
97  
98  
# Line 129 | Line 101 | setambacc(                             /* set ambient accuracy */
101          double  newa
102   )
103   {
104 <        double  ambdiff;
105 <
106 <        if (newa < 0.0)
107 <                newa = 0.0;
108 <        ambdiff = fabs(newa - ambacc);
109 <        if (ambdiff >= .01 && (ambacc = newa) > FTINY) {
110 <                qambacc = sqrt(sqrt(ambacc));
139 <                if (nambvals > 0)
140 <                        sortambvals(1);         /* rebuild tree */
104 >        static double   olda;           /* remember previous setting here */
105 >        
106 >        newa *= (newa > 0);
107 >        if (fabs(newa - olda) >= .05*(newa + olda)) {
108 >                ambacc = newa;
109 >                if (ambacc > FTINY && nambvals > 0)
110 >                        sortambvals();          /* rebuild tree */
111          }
112   }
113  
# Line 146 | Line 116 | void
116   setambient(void)                                /* initialize calculation */
117   {
118          int     readonly = 0;
119 <        long    flen;
119 >        off_t   flen;
120          AMBVAL  amb;
121                                                  /* make sure we're fresh */
122          ambdone();
123                                                  /* init ambient limits */
124          setambres(ambres);
125 <        qambacc = sqrt(sqrt(ambacc *= (ambacc > FTINY)));
125 >        setambacc(ambacc);
126          if (ambfile == NULL || !ambfile[0])
127                  return;
128          if (ambacc <= FTINY) {
# Line 166 | Line 136 | setambient(void)                               /* initialize calculation */
136                  readonly = (ambfp = fopen(ambfile, "r")) != NULL;
137          if (ambfp != NULL) {
138                  initambfile(0);                 /* file exists */
139 <                lastpos = ftell(ambfp);
139 >                lastpos = ftello(ambfp);
140                  while (readambval(&amb, ambfp))
141 <                        avinsert(avstore(&amb));
172 <                nambshare = nambvals;           /* share loaded values */
141 >                        avstore(&amb);
142                  if (readonly) {
143                          sprintf(errmsg,
144                                  "loaded %u values from read-only ambient file",
# Line 180 | Line 149 | setambient(void)                               /* initialize calculation */
149                          return;                 /* avoid ambsync() */
150                  }
151                                                  /* align file pointer */
152 <                lastpos += (long)nambvals*AMBVALSIZ;
153 <                flen = lseek(fileno(ambfp), (off_t)0, SEEK_END);
152 >                lastpos += (off_t)nambvals*AMBVALSIZ;
153 >                flen = lseek(fileno(ambfp), 0, SEEK_END);
154                  if (flen != lastpos) {
155                          sprintf(errmsg,
156                          "ignoring last %ld values in ambient file (corrupted)",
157                                          (flen - lastpos)/AMBVALSIZ);
158                          error(WARNING, errmsg);
159 <                        fseek(ambfp, lastpos, SEEK_SET);
160 < #ifndef _WIN32 /* XXX we need a replacement for that one */
192 <                        ftruncate(fileno(ambfp), (off_t)lastpos);
193 < #endif
159 >                        fseeko(ambfp, lastpos, SEEK_SET);
160 >                        ftruncate(fileno(ambfp), lastpos);
161                  }
162          } else if ((ambfp = fopen(ambfile, "w+")) != NULL) {
163                  initambfile(1);                 /* else create new file */
164                  fflush(ambfp);
165 <                lastpos = ftell(ambfp);
165 >                lastpos = ftello(ambfp);
166          } else {
167                  sprintf(errmsg, "cannot open ambient file \"%s\"", ambfile);
168                  error(SYSTEM, errmsg);
169          }
203 #ifdef getc_unlocked
204        flockfile(ambfp);                       /* application-level lock */
205 #endif
170   #ifdef  F_SETLKW
171          aflock(F_UNLCK);                        /* release file */
172   #endif
# Line 223 | Line 187 | ambdone(void)                  /* close ambient file and free memory
187                  lastpos = -1;
188          }
189                                          /* free ambient tree */
190 <        unloadatree(&atrunk, &avfree);
190 >        unloadatree(&atrunk, avfree);
191                                          /* reset state variables */
192          avsum = 0.;
193          navsum = 0;
194          nambvals = 0;
231        nambshare = 0;
232        ambclock = 0;
233        lastsort = 0;
234        sortintvl = SORT_INTVL;
195   }
196  
197  
# Line 264 | Line 224 | ambnotify(                     /* record new modifier */
224                  }
225   }
226  
267 /************ THE FOLLOWING ROUTINES DIFFER BETWEEN NEW & OLD ***************/
227  
269 #ifdef NEWAMB
270
271 #define tfunc(lwr, x, upr)      (((x)-(lwr))/((upr)-(lwr)))
272
273 static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
274                                AMBTREE *at, FVECT c0, double s);
275 static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
276 static void     extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
277                                FVECT uvw[3]);
278
228   void
229   multambient(            /* compute ambient component & multiply by coef. */
230 <        COLOR  aval,
230 >        SCOLOR  aval,
231          RAY  *r,
232          FVECT  nrm
233   )
234   {
235 +        static double  logAvgAbsorp = 1;
236          static int  rdepth = 0;                 /* ambient recursion */
237 <        COLOR   acol;
238 <        int     ok;
237 >        SCOLOR  acol, caustic;
238 >        int     i, ok;
239          double  d, l;
240  
241 +        /* PMAP: Factor in ambient from photon map, if enabled and ray is
242 +         * ambient. Return as all ambient components accounted for, else
243 +         * continue. */
244 +        if (ambPmap(aval, r, rdepth))
245 +                return;
246 +
247 +        if (logAvgAbsorp > 0)                   /* exclude in -aw to avoid growth */
248 +                logAvgAbsorp = log(1.-AVGREFL);
249 +
250 +        /* PMAP: Factor in specular-diffuse ambient (caustics) from photon
251 +         * map, if enabled and ray is primary, else caustic is zero.  Continue
252 +         * with RADIANCE ambient calculation */
253 + {/* XXX TEMPORARY */
254 +        COLOR   pmc;
255 +        scolor_color(pmc, aval);
256 +        ambPmapCaustic(pmc, r, rdepth);
257 +        setscolor(caustic, colval(pmc,RED), colval(pmc,GRN), colval(pmc,BLU));
258 + }
259          if (ambdiv <= 0)                        /* no ambient calculation */
260                  goto dumbamb;
261                                                  /* check number of bounces */
# Line 298 | Line 266 | multambient(           /* compute ambient component & multiply
266                          ambincl != inset(ambset, r->ro->omod))
267                  goto dumbamb;
268  
269 <        if (ambacc <= FTINY) {                  /* no ambient storage */
270 <                copycolor(acol, aval);
269 >        if (ambacc <= FTINY) {                  /* no ambient storage? */
270 >                double  rdot = DOT(nrm,r->ron);
271 >                int     sgn = 1 - 2*(rdot < 0);
272 >                float   dgrad[2], *dgp = NULL;
273 >                FVECT   uvd[2];
274 >
275 >                if (sgn*rdot < 0.9999)
276 >                        dgp = dgrad;            /* compute rotational grad. */
277 >                copyscolor(acol, aval);
278                  rdepth++;
279 <                ok = doambient(acol, r, r->rweight, NULL, NULL, NULL, NULL);
279 >                ok = doambient(acol, r, r->rweight*sgn,
280 >                                uvd, NULL, NULL, dgp, NULL);
281                  rdepth--;
282                  if (!ok)
283                          goto dumbamb;
284 <                copycolor(aval, acol);
284 >                if ((ok > 0) & (dgp != NULL)) { /* apply texture */
285 >                        FVECT   v1;
286 >                        VCROSS(v1, r->ron, nrm);
287 >                        d = 1.0;
288 >                        for (i = 3; i--; )
289 >                                d += sgn*v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
290 >                        if (d >= 0.05)
291 >                                scalescolor(acol, d);
292 >                }
293 >                copyscolor(aval, acol);
294 >
295 >                /* PMAP: add in caustic */
296 >                saddscolor(aval, caustic);
297                  return;
298          }
311
312        if (tracktime)                          /* sort to minimize thrashing */
313                sortambvals(0);
299                                                  /* interpolate ambient value */
300 <        setcolor(acol, 0.0, 0.0, 0.0);
300 >        scolorblack(acol);
301          d = sumambient(acol, r, nrm, rdepth,
302                          &atrunk, thescene.cuorg, thescene.cusize);
303 +                        
304          if (d > FTINY) {
305 <                d = 1.0/d;
306 <                scalecolor(acol, d);
307 <                multcolor(aval, acol);
305 >                scalescolor(acol, 1.0/d);
306 >                smultscolor(aval, acol);
307 >
308 >                /* PMAP: add in caustic */
309 >                saddscolor(aval, caustic);
310                  return;
311          }
312 +        
313          rdepth++;                               /* need to cache new value */
314          ok = makeambient(acol, r, nrm, rdepth-1);
315          rdepth--;
316 +        
317          if (ok) {
318 <                multcolor(aval, acol);          /* computed new value */
318 >                smultscolor(aval, acol);        /* computed new value */
319 >
320 >                /* PMAP: add in caustic */
321 >                saddscolor(aval, caustic);
322                  return;
323          }
324 +        
325   dumbamb:                                        /* return global value */
326          if ((ambvwt <= 0) | (navsum == 0)) {
327 <                multcolor(aval, ambval);
327 >                smultcolor(aval, ambval);
328 >                
329 >                /* PMAP: add in caustic */
330 >                saddscolor(aval, caustic);
331                  return;
332          }
333 <        l = bright(ambval);                     /* average in computations */
333 >        
334 >        l = bright(ambval);                     /* average in computations */  
335          if (l > FTINY) {
336 <                d = (log(l)*(double)ambvwt + avsum) /
336 >                d = (log(l)*(double)ambvwt + avsum + logAvgAbsorp*navsum) /
337                                  (double)(ambvwt + navsum);
338                  d = exp(d) / l;
339 <                scalecolor(aval, d);
340 <                multcolor(aval, ambval);        /* apply color of ambval */
339 >                scalescolor(aval, d);
340 >                smultcolor(aval, ambval);       /* apply color of ambval */
341          } else {
342 <                d = exp( avsum / (double)navsum );
343 <                scalecolor(aval, d);            /* neutral color */
342 >                d = exp( avsum/(double)navsum + logAvgAbsorp );
343 >                scalescolor(aval, d);           /* neutral color */
344          }
345   }
346  
347  
348 < double
348 > /* Plug a potential leak where ambient cache value is occluded */
349 > static int
350 > plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
351 > {
352 >        const double    cost70sq = 0.1169778;   /* cos(70deg)^2 */
353 >        RAY             rtst;
354 >        FVECT           vdif;
355 >        double          normdot, ndotd, nadotd;
356 >        double          a, b, c, t[2];
357 >
358 >        ang += 2.*PI*(ang < 0);                 /* check direction flags */
359 >        if ( !(ap->corral>>(int)(ang*(16./PI)) & 1) )
360 >                return(0);
361 >        /*
362 >         * Generate test ray, targeting 20 degrees above sample point plane
363 >         * along surface normal from cache position.  This should be high
364 >         * enough to miss local geometry we don't really care about.
365 >         */
366 >        VSUB(vdif, ap->pos, r->rop);
367 >        normdot = DOT(anorm, r->ron);
368 >        ndotd = DOT(vdif, r->ron);
369 >        nadotd = DOT(vdif, anorm);
370 >        a = normdot*normdot - cost70sq;
371 >        b = 2.0*(normdot*ndotd - nadotd*cost70sq);
372 >        c = ndotd*ndotd - DOT(vdif,vdif)*cost70sq;
373 >        if (quadratic(t, a, b, c) != 2)
374 >                return(1);                      /* should rarely happen */
375 >        if (t[1] <= FTINY)
376 >                return(0);                      /* should fail behind test */
377 >        rayorigin(&rtst, SHADOW, r, NULL);
378 >        VSUM(rtst.rdir, vdif, anorm, t[1]);     /* further dist. > plane */
379 >        rtst.rmax = normalize(rtst.rdir);       /* short ray test */
380 >        while (localhit(&rtst, &thescene)) {    /* check for occluder */
381 >                OBJREC  *m = findmaterial(rtst.ro);
382 >                if (m != NULL && !istransp(m) && !isBSDFproxy(m) &&
383 >                                (rtst.clipset == NULL ||
384 >                                        !inset(rtst.clipset, rtst.ro->omod)))
385 >                        return(1);              /* plug light leak */
386 >                VCOPY(rtst.rorg, rtst.rop);     /* skip invisible surface */
387 >                rtst.rmax -= rtst.rot;
388 >                rayclear(&rtst);
389 >        }
390 >        return(0);                              /* seems we're OK */
391 > }
392 >
393 >
394 > static double
395   sumambient(             /* get interpolated ambient value */
396 <        COLOR  acol,
396 >        SCOLOR  acol,
397          RAY  *r,
398          FVECT  rn,
399          int  al,
# Line 359 | Line 403 | sumambient(            /* get interpolated ambient value */
403   )
404   {                       /* initial limit is 10 degrees plus ambacc radians */
405          const double    minangle = 10.0 * PI/180.;
406 <        const double    maxangle = (minangle+ambacc-PI/2.)*pow(r->rweight,0.13)
407 <                                        + PI/2.;
406 >        const int       sgn = 1 - 2*(DOT(r->ron,rn) < 0);
407 >        double          maxangle = minangle + ambacc;
408          double          wsum = 0.0;
409          FVECT           ck0;
410          int             i, j;
411          AMBVAL          *av;
412 +
413 +        if (at->kid != NULL) {          /* sum children first */                                
414 +                s *= 0.5;
415 +                for (i = 0; i < 8; i++) {
416 +                        for (j = 0; j < 3; j++) {
417 +                                ck0[j] = c0[j];
418 +                                if (1<<j & i)
419 +                                        ck0[j] += s;
420 +                                if (r->rop[j] < ck0[j] - OCTSCALE*s)
421 +                                        break;
422 +                                if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
423 +                                        break;
424 +                        }
425 +                        if (j == 3)
426 +                                wsum += sumambient(acol, r, rn, al,
427 +                                                        at->kid+i, ck0, s);
428 +                }
429 +                                        /* good enough? */
430 +                if ((wsum >= 0.05) & (s*ambacc > minarad))
431 +                        return(wsum);
432 +        }
433 +                                        /* adjust maximum angle */
434 +        if (at->alist != NULL && (at->alist->lvl <= al) & (r->rweight < 0.6))
435 +                maxangle = (maxangle - PI/2.)*pow(r->rweight,0.13) + PI/2.;
436                                          /* sum this node */
437          for (av = at->alist; av != NULL; av = av->next) {
438 <                double  d, delta_r2, delta_t2;
439 <                COLOR   ct;
438 >                double  u, v, d, delta_r2, delta_t2;
439 >                SCOLOR  sct;
440                  FVECT   uvw[3];
373                                        /* record access */
374                if (tracktime)
375                        av->latick = ambclock;
441                  /*
442                   *  Ambient level test
443                   */
444 <                if (av->lvl > al)       /* list sorted, so this works */
444 >                if (av->lvl > al ||     /* list sorted, so this works */
445 >                                (av->lvl == al) & (av->weight < 0.9*r->rweight))
446                          break;
381                if (av->weight < 0.9*r->rweight)
382                        continue;
447                  /*
448                   *  Direction test using unperturbed normal
449                   */
450                  decodedir(uvw[2], av->ndir);
451 <                d = DOT(uvw[2], r->ron);
451 >                d = sgn * DOT(uvw[2], r->ron);
452                  if (d <= 0.0)           /* >= 90 degrees */
453                          continue;
454                  delta_r2 = 2.0 - 2.0*d; /* approx. radians^2 */
# Line 393 | Line 457 | sumambient(            /* get interpolated ambient value */
457                  /*
458                   *  Modified ray behind test
459                   */
460 <                VSUB(ck0, av->pos, r->rop);
460 >                VSUB(ck0, r->rop, av->pos);
461                  d = DOT(ck0, uvw[2]);
462 <                if (d < -minarad*qambacc-.001)
462 >                if (d < -minarad*ambacc)
463                          continue;
464                  d /= av->rad[0];
465                  delta_t2 = d*d;
466 <                if (delta_t2 >= qambacc*qambacc)
466 >                if (delta_t2 >= ambacc*ambacc)
467                          continue;
468                  /*
469                   *  Elliptical radii test based on Hessian
470                   */
471                  decodedir(uvw[0], av->udir);
472                  VCROSS(uvw[1], uvw[2], uvw[0]);
473 <                d = DOT(ck0, uvw[0]) / av->rad[0];
473 >                d = (u = DOT(ck0, uvw[0])) / av->rad[0];
474                  delta_t2 += d*d;
475 <                d = DOT(ck0, uvw[1]) / av->rad[1];
475 >                d = (v = DOT(ck0, uvw[1])) / av->rad[1];
476                  delta_t2 += d*d;
477 <                if (delta_t2 >= qambacc*qambacc)
477 >                if (delta_t2 >= ambacc*ambacc)
478                          continue;
479                  /*
480 +                 *  Test for potential light leak
481 +                 */
482 +                if (av->corral && plugaleak(r, av, uvw[2], atan2a(v,u)))
483 +                        continue;
484 +                /*
485                   *  Extrapolate value and compute final weight (hat function)
486                   */
487 <                extambient(ct, av, r->rop, rn, uvw);
487 >                if (!extambient(sct, av, r->rop, rn, uvw))
488 >                        continue;
489                  d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
490 <                        tfunc(qambacc, sqrt(delta_t2), 0.0);
491 <                scalecolor(ct, d);
492 <                addcolor(acol, ct);
490 >                        tfunc(ambacc, sqrt(delta_t2), 0.0);
491 >                scalescolor(sct, d);
492 >                saddscolor(acol, sct);
493                  wsum += d;
494          }
425        if (at->kid == NULL)
426                return(wsum);
427                                        /* sum children */
428        s *= 0.5;
429        for (i = 0; i < 8; i++) {
430                for (j = 0; j < 3; j++) {
431                        ck0[j] = c0[j];
432                        if (1<<j & i)
433                                ck0[j] += s;
434                        if (r->rop[j] < ck0[j] - OCTSCALE*s)
435                                break;
436                        if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
437                                break;
438                }
439                if (j == 3)
440                        wsum += sumambient(acol, r, rn, al,
441                                                at->kid+i, ck0, s);
442        }
495          return(wsum);
496   }
497  
498  
499 < int
499 > static int
500   makeambient(            /* make a new ambient value for storage */
501 <        COLOR  acol,
501 >        SCOLOR  acol,
502          RAY  *r,
503          FVECT  rn,
504          int  al
505   )
506   {
507 +        int     sgn = 1 - 2*(DOT(r->ron,rn) < 0);
508          AMBVAL  amb;
509          FVECT   uvw[3];
510          int     i;
# Line 461 | Line 514 | makeambient(           /* make a new ambient value for storage
514                  amb.weight *= AVGREFL;
515          if (r->rweight < 0.1*amb.weight)        /* heuristic override */
516                  amb.weight = 1.25*r->rweight;
517 <        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
517 >        setscolor(acol, AVGREFL, AVGREFL, AVGREFL);
518                                                  /* compute ambient */
519 <        i = doambient(acol, r, amb.weight, uvw, amb.rad, amb.gpos, amb.gdir);
520 <        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
519 >        i = doambient(acol, r, amb.weight*sgn,
520 >                        uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
521 >        scalescolor(acol, 1./AVGREFL);          /* undo assumed reflectance */
522          if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
523                  return(i);
524 +        uvw[2][0] = sgn*r->ron[0];              /* orient unperturbed normal */
525 +        uvw[2][1] = sgn*r->ron[1];
526 +        uvw[2][2] = sgn*r->ron[2];
527                                                  /* store value */
528          VCOPY(amb.pos, r->rop);
529 <        amb.ndir = encodedir(r->ron);
529 >        amb.ndir = encodedir(uvw[2]);
530          amb.udir = encodedir(uvw[0]);
531          amb.lvl = al;
532 <        copycolor(amb.val, acol);
533 <                                                /* insert into tree */
534 <        avsave(&amb);                           /* and save to file */
478 <        if (rn != r->ron) {                     /* texture */
479 <                VCOPY(uvw[2], r->ron);
532 >        copyscolor(amb.val, acol);
533 >        avsave(&amb);                           /* insert and save to file */
534 >        if (DOT(uvw[2],rn) < 0.9999)            /* texture? */
535                  extambient(acol, &amb, r->rop, rn, uvw);
481        }
536          return(1);
537   }
538  
539  
540 < void
540 > static int
541   extambient(             /* extrapolate value at pv, nv */
542 <        COLOR  cr,
542 >        SCOLOR  scr,
543          AMBVAL   *ap,
544          FVECT  pv,
545          FVECT  nv,
546          FVECT  uvw[3]
547   )
548   {
549 +        const double    min_d = 0.05;
550 +        const double    max_d = 20.;
551          static FVECT    my_uvw[3];
552          FVECT           v1;
553          int             i;
# Line 511 | Line 567 | extambient(            /* extrapolate value at pv, nv */
567          for (i = 3; i--; )
568                  d += v1[i] * (ap->gdir[0]*uvw[0][i] + ap->gdir[1]*uvw[1][i]);
569          
570 <        if (d <= 0.0) {
571 <                setcolor(cr, 0.0, 0.0, 0.0);
572 <                return;
573 <        }
574 <        copycolor(cr, ap->val);
575 <        scalecolor(cr, d);
570 >        if (d < min_d)                  /* clamp min/max scaling */
571 >                d = min_d;
572 >        else if (d > max_d)
573 >                d = max_d;
574 >        copyscolor(scr, ap->val);
575 >        scalescolor(scr, d);
576 >        return(d > min_d);
577   }
578  
579  
# Line 538 | Line 595 | avinsert(                              /* insert ambient value in our tree */
595          at = &atrunk;
596          VCOPY(ck0, thescene.cuorg);
597          s = thescene.cusize;
598 <        while (s*(OCTSCALE/2) > av->rad[1]*qambacc) {
598 >        while (s*(OCTSCALE/2) > av->rad[1]*ambacc) {
599                  if (at->kid == NULL)
600                          if ((at->kid = newambtree()) == NULL)
601                                  error(SYSTEM, "out of memory in avinsert");
# Line 553 | Line 610 | avinsert(                              /* insert ambient value in our tree */
610          }
611          avh.next = at->alist;           /* order by increasing level */
612          for (ap = &avh; ap->next != NULL; ap = ap->next)
613 <                if (ap->next->lvl >= av->lvl)
613 >                if ( ap->next->lvl > av->lvl ||
614 >                                (ap->next->lvl == av->lvl) &
615 >                                (ap->next->weight <= av->weight) )
616                          break;
617          av->next = ap->next;
618          ap->next = (AMBVAL*)av;
# Line 561 | Line 620 | avinsert(                              /* insert ambient value in our tree */
620   }
621  
622  
564 #else /* ! NEWAMB */
565
566 static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
567                                AMBTREE *at, FVECT c0, double s);
568 static double   makeambient(COLOR acol, RAY *r, FVECT rn, int al);
569 static void     extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv);
570
571
572 void
573 multambient(            /* compute ambient component & multiply by coef. */
574        COLOR  aval,
575        RAY  *r,
576        FVECT  nrm
577 )
578 {
579        static int  rdepth = 0;                 /* ambient recursion */
580        COLOR   acol;
581        double  d, l;
582
583        if (ambdiv <= 0)                        /* no ambient calculation */
584                goto dumbamb;
585                                                /* check number of bounces */
586        if (rdepth >= ambounce)
587                goto dumbamb;
588                                                /* check ambient list */
589        if (ambincl != -1 && r->ro != NULL &&
590                        ambincl != inset(ambset, r->ro->omod))
591                goto dumbamb;
592
593        if (ambacc <= FTINY) {                  /* no ambient storage */
594                copycolor(acol, aval);
595                rdepth++;
596                d = doambient(acol, r, r->rweight, NULL, NULL);
597                rdepth--;
598                if (d <= FTINY)
599                        goto dumbamb;
600                copycolor(aval, acol);
601                return;
602        }
603
604        if (tracktime)                          /* sort to minimize thrashing */
605                sortambvals(0);
606                                                /* interpolate ambient value */
607        setcolor(acol, 0.0, 0.0, 0.0);
608        d = sumambient(acol, r, nrm, rdepth,
609                        &atrunk, thescene.cuorg, thescene.cusize);
610        if (d > FTINY) {
611                d = 1.0/d;
612                scalecolor(acol, d);
613                multcolor(aval, acol);
614                return;
615        }
616        rdepth++;                               /* need to cache new value */
617        d = makeambient(acol, r, nrm, rdepth-1);
618        rdepth--;
619        if (d > FTINY) {
620                multcolor(aval, acol);          /* got new value */
621                return;
622        }
623 dumbamb:                                        /* return global value */
624        if ((ambvwt <= 0) | (navsum == 0)) {
625                multcolor(aval, ambval);
626                return;
627        }
628        l = bright(ambval);                     /* average in computations */
629        if (l > FTINY) {
630                d = (log(l)*(double)ambvwt + avsum) /
631                                (double)(ambvwt + navsum);
632                d = exp(d) / l;
633                scalecolor(aval, d);
634                multcolor(aval, ambval);        /* apply color of ambval */
635        } else {
636                d = exp( avsum / (double)navsum );
637                scalecolor(aval, d);            /* neutral color */
638        }
639 }
640
641
642 static double
643 sumambient(     /* get interpolated ambient value */
644        COLOR  acol,
645        RAY  *r,
646        FVECT  rn,
647        int  al,
648        AMBTREE  *at,
649        FVECT  c0,
650        double  s
651 )
652 {
653        double  d, e1, e2, wt, wsum;
654        COLOR  ct;
655        FVECT  ck0;
656        int  i;
657        int  j;
658        AMBVAL   *av;
659
660        wsum = 0.0;
661                                        /* do this node */
662        for (av = at->alist; av != NULL; av = av->next) {
663                double  rn_dot = -2.0;
664                if (tracktime)
665                        av->latick = ambclock;
666                /*
667                 *  Ambient level test.
668                 */
669                if (av->lvl > al)       /* list sorted, so this works */
670                        break;
671                if (av->weight < 0.9*r->rweight)
672                        continue;
673                /*
674                 *  Ambient radius test.
675                 */
676                VSUB(ck0, av->pos, r->rop);
677                e1 = DOT(ck0, ck0) / (av->rad * av->rad);
678                if (e1 > ambacc*ambacc*1.21)
679                        continue;
680                /*
681                 *  Direction test using closest normal.
682                 */
683                d = DOT(av->dir, r->ron);
684                if (rn != r->ron) {
685                        rn_dot = DOT(av->dir, rn);
686                        if (rn_dot > 1.0-FTINY)
687                                rn_dot = 1.0-FTINY;
688                        if (rn_dot >= d-FTINY) {
689                                d = rn_dot;
690                                rn_dot = -2.0;
691                        }
692                }
693                e2 = (1.0 - d) * r->rweight;
694                if (e2 < 0.0)
695                        e2 = 0.0;
696                else if (e1 + e2 > ambacc*ambacc*1.21)
697                        continue;
698                /*
699                 *  Ray behind test.
700                 */
701                d = 0.0;
702                for (j = 0; j < 3; j++)
703                        d += (r->rop[j] - av->pos[j]) *
704                                        (av->dir[j] + r->ron[j]);
705                if (d*0.5 < -minarad*ambacc-.001)
706                        continue;
707                /*
708                 *  Jittering final test reduces image artifacts.
709                 */
710                e1 = sqrt(e1);
711                e2 = sqrt(e2);
712                wt = e1 + e2;
713                if (wt > ambacc*(.9+.2*urand(9015+samplendx)))
714                        continue;
715                /*
716                 *  Recompute directional error using perturbed normal
717                 */
718                if (rn_dot > 0.0) {
719                        e2 = sqrt((1.0 - rn_dot)*r->rweight);
720                        wt = e1 + e2;
721                }
722                if (wt <= 1e-3)
723                        wt = 1e3;
724                else
725                        wt = 1.0 / wt;
726                wsum += wt;
727                extambient(ct, av, r->rop, rn);
728                scalecolor(ct, wt);
729                addcolor(acol, ct);
730        }
731        if (at->kid == NULL)
732                return(wsum);
733                                        /* do children */
734        s *= 0.5;
735        for (i = 0; i < 8; i++) {
736                for (j = 0; j < 3; j++) {
737                        ck0[j] = c0[j];
738                        if (1<<j & i)
739                                ck0[j] += s;
740                        if (r->rop[j] < ck0[j] - OCTSCALE*s)
741                                break;
742                        if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
743                                break;
744                }
745                if (j == 3)
746                        wsum += sumambient(acol, r, rn, al,
747                                                at->kid+i, ck0, s);
748        }
749        return(wsum);
750 }
751
752
753 static double
754 makeambient(            /* make a new ambient value for storage */
755        COLOR  acol,
756        RAY  *r,
757        FVECT  rn,
758        int  al
759 )
760 {
761        AMBVAL  amb;
762        FVECT   gp, gd;
763        int     i;
764
765        amb.weight = 1.0;                       /* compute weight */
766        for (i = al; i-- > 0; )
767                amb.weight *= AVGREFL;
768        if (r->rweight < 0.1*amb.weight)        /* heuristic override */
769                amb.weight = 1.25*r->rweight;
770        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
771                                                /* compute ambient */
772        amb.rad = doambient(acol, r, amb.weight, gp, gd);
773        if (amb.rad <= FTINY) {
774                setcolor(acol, 0.0, 0.0, 0.0);
775                return(0.0);
776        }
777        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
778                                                /* store value */
779        VCOPY(amb.pos, r->rop);
780        VCOPY(amb.dir, r->ron);
781        amb.lvl = al;
782        copycolor(amb.val, acol);
783        VCOPY(amb.gpos, gp);
784        VCOPY(amb.gdir, gd);
785                                                /* insert into tree */
786        avsave(&amb);                           /* and save to file */
787        if (rn != r->ron)
788                extambient(acol, &amb, r->rop, rn);     /* texture */
789        return(amb.rad);
790 }
791
792
623   static void
794 extambient(             /* extrapolate value at pv, nv */
795        COLOR  cr,
796        AMBVAL   *ap,
797        FVECT  pv,
798        FVECT  nv
799 )
800 {
801        FVECT  v1;
802        int  i;
803        double  d;
804
805        d = 1.0;                        /* zeroeth order */
806                                        /* gradient due to translation */
807        for (i = 0; i < 3; i++)
808                d += ap->gpos[i]*(pv[i]-ap->pos[i]);
809                                        /* gradient due to rotation */
810        VCROSS(v1, ap->dir, nv);
811        d += DOT(ap->gdir, v1);
812        if (d <= 0.0) {
813                setcolor(cr, 0.0, 0.0, 0.0);
814                return;
815        }
816        copycolor(cr, ap->val);
817        scalecolor(cr, d);
818 }
819
820
821 static void
822 avinsert(                               /* insert ambient value in our tree */
823        AMBVAL *av
824 )
825 {
826        AMBTREE  *at;
827        AMBVAL  *ap;
828        AMBVAL  avh;
829        FVECT  ck0;
830        double  s;
831        int  branch;
832        int  i;
833
834        if (av->rad <= FTINY)
835                error(CONSISTENCY, "zero ambient radius in avinsert");
836        at = &atrunk;
837        VCOPY(ck0, thescene.cuorg);
838        s = thescene.cusize;
839        while (s*(OCTSCALE/2) > av->rad*ambacc) {
840                if (at->kid == NULL)
841                        if ((at->kid = newambtree()) == NULL)
842                                error(SYSTEM, "out of memory in avinsert");
843                s *= 0.5;
844                branch = 0;
845                for (i = 0; i < 3; i++)
846                        if (av->pos[i] > ck0[i] + s) {
847                                ck0[i] += s;
848                                branch |= 1 << i;
849                        }
850                at = at->kid + branch;
851        }
852        avh.next = at->alist;           /* order by increasing level */
853        for (ap = &avh; ap->next != NULL; ap = ap->next)
854                if (ap->next->lvl >= av->lvl)
855                        break;
856        av->next = ap->next;
857        ap->next = (AMBVAL*)av;
858        at->alist = avh.next;
859 }
860
861 #endif  /* ! NEWAMB */
862
863 /************* FOLLOWING ROUTINES SAME FOR NEW & OLD METHODS ***************/
864
865 static void
624   initambfile(            /* initialize ambient file */
625          int  cre8
626   )
627   {
628          extern char  *progname, *octname;
629          static char  *mybuf = NULL;
630 +        int  ntries = 3;
631  
632 +        if (!AMBFLUSH)
633 +                error(INTERNAL, "BUFSIZ too small in initambfile");
634   #ifdef  F_SETLKW
635          aflock(cre8 ? F_WRLCK : F_RDLCK);
636   #endif
# Line 877 | Line 638 | initambfile(           /* initialize ambient file */
638          if (mybuf == NULL)
639                  mybuf = (char *)bmalloc(BUFSIZ+8);
640          setbuf(ambfp, mybuf);
641 +        nunflshed = 0;
642 + retry:
643          if (cre8) {                     /* new file */
644                  newheader("RADIANCE", ambfp);
645                  fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
# Line 885 | Line 648 | initambfile(           /* initialize ambient file */
648                                  ambvwt, ambounce, ambacc);
649                  fprintf(ambfp, "-ad %d -as %d -ar %d ",
650                                  ambdiv, ambssamp, ambres);
651 +                fprintf(ambfp, "-dr %d -ds %g -dt %g -dc %g ", directrelay,
652 +                                srcsizerat, shadthresh, shadcert);
653 +                fprintf(ambfp, "-ss %g -st %g -lr %d -lw %g ", specjitter,
654 +                                specthresh, maxdepth, minweight);
655 +                fprintf(ambfp, "-cw %g %g -cs %d ", WLPART[3], WLPART[0], NCSAMP);
656                  if (octname != NULL)
657                          fputs(octname, ambfp);
658 <                fputc('\n', ambfp);
658 >                fputc('\n', ambfp);     /* end of command line, not header! */
659                  fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
660                  fputnow(ambfp);
661 +                AMB_CNDX = CNDX;        /* use current spectral sampling */
662 +                AMB_WLPART = WLPART;
663 +                fputwlsplit(WLPART, ambfp);
664 +                fputncomp(NCSAMP, ambfp);
665                  fputformat(AMBFMT, ambfp);
666                  fputc('\n', ambfp);
667                  putambmagic(ambfp);
668 <        } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
669 <                error(USER, "bad ambient file");
668 >        } else if (getheader(ambfp, amb_headline, NULL) < 0 || !hasambmagic(ambfp)) {
669 >                if (--ntries > 0 && ftell(ambfp) == 0) {
670 > #ifdef  F_SETLKW
671 >                        aflock(F_UNLCK);
672 >                        clearerr(ambfp);
673 >                        sleep(2);
674 >                        aflock(F_RDLCK);
675 > #else
676 >                        clearerr(ambfp);
677 >                        sleep(2);
678 > #endif
679 >                        goto retry;
680 >                }
681 >                error(USER, "bad/incompatible ambient file");
682 >        }
683 >        if ((AMB_CNDX != CNDX) | (AMB_WLPART != WLPART)) {
684 >                if (setspectrsamp(AMB_CNDX, AMB_WLPART) < 0)
685 >                        error(USER, "bad wavelength sampling in ambient file");
686 >                if (AMB_CNDX[3] == CNDX[3] && FABSEQ(AMB_WLPART[0],WLPART[0]) &&
687 >                                        FABSEQ(AMB_WLPART[3],WLPART[3])) {
688 >                        AMB_CNDX = CNDX;
689 >                        AMB_WLPART = WLPART;            /* just the same */
690 >                } else
691 >                        error(WARNING, "different ambient file wavelength sampling");
692 >        }
693   }
694  
695  
# Line 903 | Line 698 | avsave(                                /* insert and save an ambient value */
698          AMBVAL  *av
699   )
700   {
701 <        avinsert(avstore(av));
701 >        avstore(av);
702          if (ambfp == NULL)
703                  return;
704          if (writambval(av, ambfp) < 0)
# Line 918 | Line 713 | writerr:
713  
714  
715   static AMBVAL *
716 < avstore(                                /* allocate memory and store aval */
716 > avstore(                                /* allocate memory and save aval */
717          AMBVAL  *aval
718   )
719   {
# Line 927 | Line 722 | avstore(                               /* allocate memory and store aval */
722  
723          if ((av = newambval()) == NULL)
724                  error(SYSTEM, "out of memory in avstore");
725 <        *av = *aval;
931 <        av->latick = ambclock;
725 >        memcpy(av, aval, AVSIZE);       /* AVSIZE <= sizeof(AMBVAL) */
726          av->next = NULL;
727          nambvals++;
728 <        d = bright(av->val);
728 >        d = pbright(av->val);
729          if (d > FTINY) {                /* add to log sum for averaging */
730                  avsum += log(d);
731                  navsum++;
732          }
733 +        avinsert(av);                   /* insert in our cache tree */
734          return(av);
735   }
736  
# Line 962 | Line 757 | newambtree(void)                               /* allocate 8 ambient tree structs
757          }
758          atp = atfreelist;
759          atfreelist = atp->kid;
760 <        memset((char *)atp, '\0', 8*sizeof(AMBTREE));
760 >        memset(atp, 0, 8*sizeof(AMBTREE));
761          return(atp);
762   }
763  
# Line 988 | Line 783 | unloadatree(                   /* unload an ambient value tree */
783                                          /* transfer values at this node */
784          for (av = at->alist; av != NULL; av = at->alist) {
785                  at->alist = av->next;
786 +                av->next = NULL;
787                  (*f)(av);
788          }
789          if (at->kid == NULL)
# Line 999 | Line 795 | unloadatree(                   /* unload an ambient value tree */
795   }
796  
797  
1002 static struct avl {
1003        AMBVAL  *p;
1004        unsigned long   t;
1005 }       *avlist1;                       /* ambient value list with ticks */
1006 static AMBVAL   **avlist2;              /* memory positions for sorting */
1007 static int      i_avlist;               /* index for lists */
1008
1009 static int alatcmp(const void *av1, const void *av2);
1010
798   static void
799   avfree(AMBVAL *av)
800   {
801          free(av);
802   }
803  
804 +
805   static void
806 < av2list(
1019 <        AMBVAL *av
1020 < )
806 > sortambvals(void)                       /* resort ambient values */
807   {
808 < #ifdef DEBUG
1023 <        if (i_avlist >= nambvals)
1024 <                error(CONSISTENCY, "too many ambient values in av2list1");
1025 < #endif
1026 <        avlist1[i_avlist].p = avlist2[i_avlist] = (AMBVAL*)av;
1027 <        avlist1[i_avlist++].t = av->latick;
1028 < }
808 >        AMBTREE  oldatrunk = atrunk;
809  
810 <
811 < static int
812 < alatcmp(                        /* compare ambient values for MRA */
1033 <        const void *av1,
1034 <        const void *av2
1035 < )
1036 < {
1037 <        long  lc = ((struct avl *)av2)->t - ((struct avl *)av1)->t;
1038 <        return(lc<0 ? -1 : lc>0 ? 1 : 0);
810 >        atrunk.alist = NULL;
811 >        atrunk.kid = NULL;
812 >        unloadatree(&oldatrunk, avinsert);
813   }
814  
815  
1042 /* GW NOTE 2002/10/3:
1043 * I used to compare AMBVAL pointers, but found that this was the
1044 * cause of a serious consistency error with gcc, since the optimizer
1045 * uses some dangerous trick in pointer subtraction that
1046 * assumes pointers differ by exact struct size increments.
1047 */
1048 static int
1049 aposcmp(                        /* compare ambient value positions */
1050        const void      *avp1,
1051        const void      *avp2
1052 )
1053 {
1054        long    diff = *(char * const *)avp1 - *(char * const *)avp2;
1055        if (diff < 0)
1056                return(-1);
1057        return(diff > 0);
1058 }
1059
1060
1061 static int
1062 avlmemi(                                /* find list position from address */
1063        AMBVAL  *avaddr
1064 )
1065 {
1066        AMBVAL  **avlpp;
1067
1068        avlpp = (AMBVAL **)bsearch((char *)&avaddr, (char *)avlist2,
1069                        nambvals, sizeof(AMBVAL *), &aposcmp);
1070        if (avlpp == NULL)
1071                error(CONSISTENCY, "address not found in avlmemi");
1072        return(avlpp - avlist2);
1073 }
1074
1075
1076 static void
1077 sortambvals(                    /* resort ambient values */
1078        int     always
1079 )
1080 {
1081        AMBTREE  oldatrunk;
1082        AMBVAL  tav, *tap, *pnext;
1083        int     i, j;
1084                                        /* see if it's time yet */
1085        if (!always && (ambclock++ < lastsort+sortintvl ||
1086                        nambvals < SORT_THRESH))
1087                return;
1088        /*
1089         * The idea here is to minimize memory thrashing
1090         * in VM systems by improving reference locality.
1091         * We do this by periodically sorting our stored ambient
1092         * values in memory in order of most recently to least
1093         * recently accessed.  This ordering was chosen so that new
1094         * ambient values (which tend to be less important) go into
1095         * higher memory with the infrequently accessed values.
1096         *      Since we expect our values to need sorting less
1097         * frequently as the process continues, we double our
1098         * waiting interval after each call.
1099         *      This routine is also called by setambacc() with
1100         * the "always" parameter set to 1 so that the ambient
1101         * tree will be rebuilt with the new accuracy parameter.
1102         */
1103        if (tracktime) {                /* allocate pointer arrays to sort */
1104                avlist2 = (AMBVAL **)malloc(nambvals*sizeof(AMBVAL *));
1105                avlist1 = (struct avl *)malloc(nambvals*sizeof(struct avl));
1106        } else {
1107                avlist2 = NULL;
1108                avlist1 = NULL;
1109        }
1110        if (avlist1 == NULL) {          /* no time tracking -- rebuild tree? */
1111                if (avlist2 != NULL)
1112                        free((void *)avlist2);
1113                if (always) {           /* rebuild without sorting */
1114                        oldatrunk = atrunk;
1115                        atrunk.alist = NULL;
1116                        atrunk.kid = NULL;
1117                        unloadatree(&oldatrunk, &avinsert);
1118                }
1119        } else {                        /* sort memory by last access time */
1120                /*
1121                 * Sorting memory is tricky because it isn't contiguous.
1122                 * We have to sort an array of pointers by MRA and also
1123                 * by memory position.  We then copy values in "loops"
1124                 * to minimize memory hits.  Nevertheless, we will visit
1125                 * everyone at least twice, and this is an expensive process
1126                 * when we're thrashing, which is when we need to do it.
1127                 */
1128 #ifdef DEBUG
1129                sprintf(errmsg, "sorting %u ambient values at ambclock=%lu...",
1130                                nambvals, ambclock);
1131                eputs(errmsg);
1132 #endif
1133                i_avlist = 0;
1134                unloadatree(&atrunk, &av2list); /* empty current tree */
1135 #ifdef DEBUG
1136                if (i_avlist < nambvals)
1137                        error(CONSISTENCY, "missing ambient values in sortambvals");
1138 #endif
1139                qsort((char *)avlist1, nambvals, sizeof(struct avl), &alatcmp);
1140                qsort((char *)avlist2, nambvals, sizeof(AMBVAL *), &aposcmp);
1141                for (i = 0; i < nambvals; i++) {
1142                        if (avlist1[i].p == NULL)
1143                                continue;
1144                        tap = avlist2[i];
1145                        tav = *tap;
1146                        for (j = i; (pnext = avlist1[j].p) != tap;
1147                                        j = avlmemi(pnext)) {
1148                                *(avlist2[j]) = *pnext;
1149                                avinsert(avlist2[j]);
1150                                avlist1[j].p = NULL;
1151                        }
1152                        *(avlist2[j]) = tav;
1153                        avinsert(avlist2[j]);
1154                        avlist1[j].p = NULL;
1155                }
1156                free((void *)avlist1);
1157                free((void *)avlist2);
1158                                                /* compute new sort interval */
1159                sortintvl = ambclock - lastsort;
1160                if (sortintvl >= MAX_SORT_INTVL/2)
1161                        sortintvl = MAX_SORT_INTVL;
1162                else
1163                        sortintvl <<= 1;        /* wait twice as long next */
1164 #ifdef DEBUG
1165                eputs("done\n");
1166 #endif
1167        }
1168        if (ambclock >= MAXACLOCK)
1169                ambclock = MAXACLOCK/2;
1170        lastsort = ambclock;
1171 }
1172
1173
816   #ifdef  F_SETLKW
817  
818   static void
# Line 1182 | Line 824 | aflock(                        /* lock/unlock ambient file */
824  
825          if (typ == fls.l_type)          /* already called? */
826                  return;
827 +
828          fls.l_type = typ;
829 <        if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
830 <                error(SYSTEM, "cannot (un)lock ambient file");
829 >        do
830 >                if (fcntl(fileno(ambfp), F_SETLKW, &fls) != -1)
831 >                        return;
832 >        while (errno == EINTR);
833 >        
834 >        error(SYSTEM, "cannot (un)lock ambient file");
835   }
836  
837  
838   int
839   ambsync(void)                   /* synchronize ambient file */
840   {
841 <        long  flen;
841 >        off_t  flen;
842          AMBVAL  avs;
843          int  n;
844  
# Line 1200 | Line 847 | ambsync(void)                  /* synchronize ambient file */
847                                  /* gain appropriate access */
848          aflock(nunflshed ? F_WRLCK : F_RDLCK);
849                                  /* see if file has grown */
850 <        if ((flen = lseek(fileno(ambfp), (off_t)0, SEEK_END)) < 0)
850 >        if ((flen = lseek(fileno(ambfp), 0, SEEK_END)) < 0)
851                  goto seekerr;
852          if ((n = flen - lastpos) > 0) {         /* file has grown */
853 <                if (ambinp == NULL) {           /* use duplicate filedes */
854 <                        ambinp = fdopen(dup(fileno(ambfp)), "r");
853 >                if (ambinp == NULL) {           /* get new file pointer */
854 >                        ambinp = fopen(ambfile, "rb");
855                          if (ambinp == NULL)
856 <                                error(SYSTEM, "fdopen failed in ambsync");
856 >                                error(SYSTEM, "fopen failed in ambsync");
857                  }
858 <                if (fseek(ambinp, lastpos, SEEK_SET) < 0)
858 >                if (fseeko(ambinp, lastpos, SEEK_SET) < 0)
859                          goto seekerr;
860                  while (n >= AMBVALSIZ) {        /* load contributed values */
861                          if (!readambval(&avs, ambinp)) {
# Line 1218 | Line 865 | ambsync(void)                  /* synchronize ambient file */
865                                  error(WARNING, errmsg);
866                                  break;
867                          }
868 <                        avinsert(avstore(&avs));
868 >                        avstore(&avs);
869                          n -= AMBVALSIZ;
870                  }
871 <                lastpos = flen - n;
872 <                /*** seek always as safety measure
873 <                if (n) ***/                     /* alignment */
1227 <                        if (lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0)
1228 <                                goto seekerr;
871 >                lastpos = flen - n;             /* check alignment */
872 >                if (n && lseek(fileno(ambfp), lastpos, SEEK_SET) < 0)
873 >                        goto seekerr;
874          }
875          n = fflush(ambfp);                      /* calls write() at last */
876 <        if (n != EOF)
1232 <                lastpos += (long)nunflshed*AMBVALSIZ;
1233 <        else if ((lastpos = lseek(fileno(ambfp), (off_t)0, SEEK_CUR)) < 0)
1234 <                goto seekerr;
1235 <                
876 >        lastpos += (off_t)nunflshed*AMBVALSIZ;
877          aflock(F_UNLCK);                        /* release file */
878          nunflshed = 0;
879          return(n);
880   seekerr:
881          error(SYSTEM, "seek failed in ambsync");
882 <        return -1; /* pro forma return */
882 >        return(EOF);    /* pro forma return */
883   }
884  
885   #else   /* ! F_SETLKW */

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines