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.76 by greg, Wed Apr 23 06:04:18 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();
# 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 357 | Line 401 | sumambient(            /* get interpolated ambient value */
401          FVECT  c0,
402          double  s
403   )
404 < {                                       /* initial limit is ambacc radians */
405 <        const double    maxangle = (ambacc-PI/2.)*pow(r->rweight,0.13) + PI/2.;
404 > {                       /* initial limit is 10 degrees plus ambacc radians */
405 >        const double    minangle = 10.0 * PI/180.;
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];
371                                        /* record access */
372                if (tracktime)
373                        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;
379                if (av->weight < 0.9*r->rweight)
380                        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 */
455                  if (delta_r2 >= maxangle*maxangle)
456                          continue;
457                  /*
458 +                 *  Modified ray behind test
459 +                 */
460 +                VSUB(ck0, r->rop, av->pos);
461 +                d = DOT(ck0, uvw[2]);
462 +                if (d < -minarad*ambacc)
463 +                        continue;
464 +                d /= av->rad[0];
465 +                delta_t2 = d*d;
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 <                VSUB(ck0, av->pos, r->rop);
397 <                d = DOT(ck0, uvw[0]) / av->rad[0];
398 <                delta_t2 = d*d;
399 <                d = DOT(ck0, uvw[1]) / av->rad[1];
473 >                d = (u = DOT(ck0, uvw[0])) / av->rad[0];
474                  delta_t2 += d*d;
475 <                if (delta_t2 >= qambacc*qambacc)
475 >                d = (v = DOT(ck0, uvw[1])) / av->rad[1];
476 >                delta_t2 += d*d;
477 >                if (delta_t2 >= ambacc*ambacc)
478                          continue;
479                  /*
480 <                 *  Intersection behind test
480 >                 *  Test for potential light leak
481                   */
482 <                d = 0.0;
407 <                for (j = 0; j < 3; j++)
408 <                        d += (r->rop[j] - av->pos[j])*(uvw[2][j] + r->ron[j]);
409 <                if (d*0.5 < -minarad*ambacc-.001)
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          }
421        if (at->kid == NULL)
422                return(wsum);
423                                        /* sum children */
424        s *= 0.5;
425        for (i = 0; i < 8; i++) {
426                for (j = 0; j < 3; j++) {
427                        ck0[j] = c0[j];
428                        if (1<<j & i)
429                                ck0[j] += s;
430                        if (r->rop[j] < ck0[j] - OCTSCALE*s)
431                                break;
432                        if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
433                                break;
434                }
435                if (j == 3)
436                        wsum += sumambient(acol, r, rn, al,
437                                                at->kid+i, ck0, s);
438        }
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 457 | 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 */
474 <        if (rn != r->ron) {                     /* texture */
475 <                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);
477        }
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 507 | 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 534 | 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 549 | 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 557 | Line 620 | avinsert(                              /* insert ambient value in our tree */
620   }
621  
622  
560 #else /* ! NEWAMB */
561
562 static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
563                                AMBTREE *at, FVECT c0, double s);
564 static double   makeambient(COLOR acol, RAY *r, FVECT rn, int al);
565 static void     extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv);
566
567
568 void
569 multambient(            /* compute ambient component & multiply by coef. */
570        COLOR  aval,
571        RAY  *r,
572        FVECT  nrm
573 )
574 {
575        static int  rdepth = 0;                 /* ambient recursion */
576        COLOR   acol;
577        double  d, l;
578
579        if (ambdiv <= 0)                        /* no ambient calculation */
580                goto dumbamb;
581                                                /* check number of bounces */
582        if (rdepth >= ambounce)
583                goto dumbamb;
584                                                /* check ambient list */
585        if (ambincl != -1 && r->ro != NULL &&
586                        ambincl != inset(ambset, r->ro->omod))
587                goto dumbamb;
588
589        if (ambacc <= FTINY) {                  /* no ambient storage */
590                copycolor(acol, aval);
591                rdepth++;
592                d = doambient(acol, r, r->rweight, NULL, NULL);
593                rdepth--;
594                if (d <= FTINY)
595                        goto dumbamb;
596                copycolor(aval, acol);
597                return;
598        }
599
600        if (tracktime)                          /* sort to minimize thrashing */
601                sortambvals(0);
602                                                /* interpolate ambient value */
603        setcolor(acol, 0.0, 0.0, 0.0);
604        d = sumambient(acol, r, nrm, rdepth,
605                        &atrunk, thescene.cuorg, thescene.cusize);
606        if (d > FTINY) {
607                d = 1.0/d;
608                scalecolor(acol, d);
609                multcolor(aval, acol);
610                return;
611        }
612        rdepth++;                               /* need to cache new value */
613        d = makeambient(acol, r, nrm, rdepth-1);
614        rdepth--;
615        if (d > FTINY) {
616                multcolor(aval, acol);          /* got new value */
617                return;
618        }
619 dumbamb:                                        /* return global value */
620        if ((ambvwt <= 0) | (navsum == 0)) {
621                multcolor(aval, ambval);
622                return;
623        }
624        l = bright(ambval);                     /* average in computations */
625        if (l > FTINY) {
626                d = (log(l)*(double)ambvwt + avsum) /
627                                (double)(ambvwt + navsum);
628                d = exp(d) / l;
629                scalecolor(aval, d);
630                multcolor(aval, ambval);        /* apply color of ambval */
631        } else {
632                d = exp( avsum / (double)navsum );
633                scalecolor(aval, d);            /* neutral color */
634        }
635 }
636
637
638 static double
639 sumambient(     /* get interpolated ambient value */
640        COLOR  acol,
641        RAY  *r,
642        FVECT  rn,
643        int  al,
644        AMBTREE  *at,
645        FVECT  c0,
646        double  s
647 )
648 {
649        double  d, e1, e2, wt, wsum;
650        COLOR  ct;
651        FVECT  ck0;
652        int  i;
653        int  j;
654        AMBVAL   *av;
655
656        wsum = 0.0;
657                                        /* do this node */
658        for (av = at->alist; av != NULL; av = av->next) {
659                double  rn_dot = -2.0;
660                if (tracktime)
661                        av->latick = ambclock;
662                /*
663                 *  Ambient level test.
664                 */
665                if (av->lvl > al)       /* list sorted, so this works */
666                        break;
667                if (av->weight < 0.9*r->rweight)
668                        continue;
669                /*
670                 *  Ambient radius test.
671                 */
672                VSUB(ck0, av->pos, r->rop);
673                e1 = DOT(ck0, ck0) / (av->rad * av->rad);
674                if (e1 > ambacc*ambacc*1.21)
675                        continue;
676                /*
677                 *  Direction test using closest normal.
678                 */
679                d = DOT(av->dir, r->ron);
680                if (rn != r->ron) {
681                        rn_dot = DOT(av->dir, rn);
682                        if (rn_dot > 1.0-FTINY)
683                                rn_dot = 1.0-FTINY;
684                        if (rn_dot >= d-FTINY) {
685                                d = rn_dot;
686                                rn_dot = -2.0;
687                        }
688                }
689                e2 = (1.0 - d) * r->rweight;
690                if (e2 < 0.0)
691                        e2 = 0.0;
692                else if (e1 + e2 > ambacc*ambacc*1.21)
693                        continue;
694                /*
695                 *  Ray behind test.
696                 */
697                d = 0.0;
698                for (j = 0; j < 3; j++)
699                        d += (r->rop[j] - av->pos[j]) *
700                                        (av->dir[j] + r->ron[j]);
701                if (d*0.5 < -minarad*ambacc-.001)
702                        continue;
703                /*
704                 *  Jittering final test reduces image artifacts.
705                 */
706                e1 = sqrt(e1);
707                e2 = sqrt(e2);
708                wt = e1 + e2;
709                if (wt > ambacc*(.9+.2*urand(9015+samplendx)))
710                        continue;
711                /*
712                 *  Recompute directional error using perturbed normal
713                 */
714                if (rn_dot > 0.0) {
715                        e2 = sqrt((1.0 - rn_dot)*r->rweight);
716                        wt = e1 + e2;
717                }
718                if (wt <= 1e-3)
719                        wt = 1e3;
720                else
721                        wt = 1.0 / wt;
722                wsum += wt;
723                extambient(ct, av, r->rop, rn);
724                scalecolor(ct, wt);
725                addcolor(acol, ct);
726        }
727        if (at->kid == NULL)
728                return(wsum);
729                                        /* do children */
730        s *= 0.5;
731        for (i = 0; i < 8; i++) {
732                for (j = 0; j < 3; j++) {
733                        ck0[j] = c0[j];
734                        if (1<<j & i)
735                                ck0[j] += s;
736                        if (r->rop[j] < ck0[j] - OCTSCALE*s)
737                                break;
738                        if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
739                                break;
740                }
741                if (j == 3)
742                        wsum += sumambient(acol, r, rn, al,
743                                                at->kid+i, ck0, s);
744        }
745        return(wsum);
746 }
747
748
749 static double
750 makeambient(            /* make a new ambient value for storage */
751        COLOR  acol,
752        RAY  *r,
753        FVECT  rn,
754        int  al
755 )
756 {
757        AMBVAL  amb;
758        FVECT   gp, gd;
759        int     i;
760
761        amb.weight = 1.0;                       /* compute weight */
762        for (i = al; i-- > 0; )
763                amb.weight *= AVGREFL;
764        if (r->rweight < 0.1*amb.weight)        /* heuristic override */
765                amb.weight = 1.25*r->rweight;
766        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
767                                                /* compute ambient */
768        amb.rad = doambient(acol, r, amb.weight, gp, gd);
769        if (amb.rad <= FTINY) {
770                setcolor(acol, 0.0, 0.0, 0.0);
771                return(0.0);
772        }
773        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
774                                                /* store value */
775        VCOPY(amb.pos, r->rop);
776        VCOPY(amb.dir, r->ron);
777        amb.lvl = al;
778        copycolor(amb.val, acol);
779        VCOPY(amb.gpos, gp);
780        VCOPY(amb.gdir, gd);
781                                                /* insert into tree */
782        avsave(&amb);                           /* and save to file */
783        if (rn != r->ron)
784                extambient(acol, &amb, r->rop, rn);     /* texture */
785        return(amb.rad);
786 }
787
788
623   static void
790 extambient(             /* extrapolate value at pv, nv */
791        COLOR  cr,
792        AMBVAL   *ap,
793        FVECT  pv,
794        FVECT  nv
795 )
796 {
797        FVECT  v1;
798        int  i;
799        double  d;
800
801        d = 1.0;                        /* zeroeth order */
802                                        /* gradient due to translation */
803        for (i = 0; i < 3; i++)
804                d += ap->gpos[i]*(pv[i]-ap->pos[i]);
805                                        /* gradient due to rotation */
806        VCROSS(v1, ap->dir, nv);
807        d += DOT(ap->gdir, v1);
808        if (d <= 0.0) {
809                setcolor(cr, 0.0, 0.0, 0.0);
810                return;
811        }
812        copycolor(cr, ap->val);
813        scalecolor(cr, d);
814 }
815
816
817 static void
818 avinsert(                               /* insert ambient value in our tree */
819        AMBVAL *av
820 )
821 {
822        AMBTREE  *at;
823        AMBVAL  *ap;
824        AMBVAL  avh;
825        FVECT  ck0;
826        double  s;
827        int  branch;
828        int  i;
829
830        if (av->rad <= FTINY)
831                error(CONSISTENCY, "zero ambient radius in avinsert");
832        at = &atrunk;
833        VCOPY(ck0, thescene.cuorg);
834        s = thescene.cusize;
835        while (s*(OCTSCALE/2) > av->rad*ambacc) {
836                if (at->kid == NULL)
837                        if ((at->kid = newambtree()) == NULL)
838                                error(SYSTEM, "out of memory in avinsert");
839                s *= 0.5;
840                branch = 0;
841                for (i = 0; i < 3; i++)
842                        if (av->pos[i] > ck0[i] + s) {
843                                ck0[i] += s;
844                                branch |= 1 << i;
845                        }
846                at = at->kid + branch;
847        }
848        avh.next = at->alist;           /* order by increasing level */
849        for (ap = &avh; ap->next != NULL; ap = ap->next)
850                if (ap->next->lvl >= av->lvl)
851                        break;
852        av->next = ap->next;
853        ap->next = (AMBVAL*)av;
854        at->alist = avh.next;
855 }
856
857 #endif  /* ! NEWAMB */
858
859 /************* FOLLOWING ROUTINES SAME FOR NEW & OLD METHODS ***************/
860
861 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 873 | 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 881 | 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 899 | 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 914 | 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 923 | 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;
927 <        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 958 | 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 984 | 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 995 | Line 795 | unloadatree(                   /* unload an ambient value tree */
795   }
796  
797  
998 static struct avl {
999        AMBVAL  *p;
1000        unsigned long   t;
1001 }       *avlist1;                       /* ambient value list with ticks */
1002 static AMBVAL   **avlist2;              /* memory positions for sorting */
1003 static int      i_avlist;               /* index for lists */
1004
1005 static int alatcmp(const void *av1, const void *av2);
1006
798   static void
799   avfree(AMBVAL *av)
800   {
801          free(av);
802   }
803  
804 +
805   static void
806 < av2list(
1015 <        AMBVAL *av
1016 < )
806 > sortambvals(void)                       /* resort ambient values */
807   {
808 < #ifdef DEBUG
1019 <        if (i_avlist >= nambvals)
1020 <                error(CONSISTENCY, "too many ambient values in av2list1");
1021 < #endif
1022 <        avlist1[i_avlist].p = avlist2[i_avlist] = (AMBVAL*)av;
1023 <        avlist1[i_avlist++].t = av->latick;
1024 < }
808 >        AMBTREE  oldatrunk = atrunk;
809  
810 <
811 < static int
812 < alatcmp(                        /* compare ambient values for MRA */
1029 <        const void *av1,
1030 <        const void *av2
1031 < )
1032 < {
1033 <        long  lc = ((struct avl *)av2)->t - ((struct avl *)av1)->t;
1034 <        return(lc<0 ? -1 : lc>0 ? 1 : 0);
810 >        atrunk.alist = NULL;
811 >        atrunk.kid = NULL;
812 >        unloadatree(&oldatrunk, avinsert);
813   }
814  
815  
1038 /* GW NOTE 2002/10/3:
1039 * I used to compare AMBVAL pointers, but found that this was the
1040 * cause of a serious consistency error with gcc, since the optimizer
1041 * uses some dangerous trick in pointer subtraction that
1042 * assumes pointers differ by exact struct size increments.
1043 */
1044 static int
1045 aposcmp(                        /* compare ambient value positions */
1046        const void      *avp1,
1047        const void      *avp2
1048 )
1049 {
1050        long    diff = *(char * const *)avp1 - *(char * const *)avp2;
1051        if (diff < 0)
1052                return(-1);
1053        return(diff > 0);
1054 }
1055
1056
1057 static int
1058 avlmemi(                                /* find list position from address */
1059        AMBVAL  *avaddr
1060 )
1061 {
1062        AMBVAL  **avlpp;
1063
1064        avlpp = (AMBVAL **)bsearch((char *)&avaddr, (char *)avlist2,
1065                        nambvals, sizeof(AMBVAL *), &aposcmp);
1066        if (avlpp == NULL)
1067                error(CONSISTENCY, "address not found in avlmemi");
1068        return(avlpp - avlist2);
1069 }
1070
1071
1072 static void
1073 sortambvals(                    /* resort ambient values */
1074        int     always
1075 )
1076 {
1077        AMBTREE  oldatrunk;
1078        AMBVAL  tav, *tap, *pnext;
1079        int     i, j;
1080                                        /* see if it's time yet */
1081        if (!always && (ambclock++ < lastsort+sortintvl ||
1082                        nambvals < SORT_THRESH))
1083                return;
1084        /*
1085         * The idea here is to minimize memory thrashing
1086         * in VM systems by improving reference locality.
1087         * We do this by periodically sorting our stored ambient
1088         * values in memory in order of most recently to least
1089         * recently accessed.  This ordering was chosen so that new
1090         * ambient values (which tend to be less important) go into
1091         * higher memory with the infrequently accessed values.
1092         *      Since we expect our values to need sorting less
1093         * frequently as the process continues, we double our
1094         * waiting interval after each call.
1095         *      This routine is also called by setambacc() with
1096         * the "always" parameter set to 1 so that the ambient
1097         * tree will be rebuilt with the new accuracy parameter.
1098         */
1099        if (tracktime) {                /* allocate pointer arrays to sort */
1100                avlist2 = (AMBVAL **)malloc(nambvals*sizeof(AMBVAL *));
1101                avlist1 = (struct avl *)malloc(nambvals*sizeof(struct avl));
1102        } else {
1103                avlist2 = NULL;
1104                avlist1 = NULL;
1105        }
1106        if (avlist1 == NULL) {          /* no time tracking -- rebuild tree? */
1107                if (avlist2 != NULL)
1108                        free((void *)avlist2);
1109                if (always) {           /* rebuild without sorting */
1110                        oldatrunk = atrunk;
1111                        atrunk.alist = NULL;
1112                        atrunk.kid = NULL;
1113                        unloadatree(&oldatrunk, &avinsert);
1114                }
1115        } else {                        /* sort memory by last access time */
1116                /*
1117                 * Sorting memory is tricky because it isn't contiguous.
1118                 * We have to sort an array of pointers by MRA and also
1119                 * by memory position.  We then copy values in "loops"
1120                 * to minimize memory hits.  Nevertheless, we will visit
1121                 * everyone at least twice, and this is an expensive process
1122                 * when we're thrashing, which is when we need to do it.
1123                 */
1124 #ifdef DEBUG
1125                sprintf(errmsg, "sorting %u ambient values at ambclock=%lu...",
1126                                nambvals, ambclock);
1127                eputs(errmsg);
1128 #endif
1129                i_avlist = 0;
1130                unloadatree(&atrunk, &av2list); /* empty current tree */
1131 #ifdef DEBUG
1132                if (i_avlist < nambvals)
1133                        error(CONSISTENCY, "missing ambient values in sortambvals");
1134 #endif
1135                qsort((char *)avlist1, nambvals, sizeof(struct avl), &alatcmp);
1136                qsort((char *)avlist2, nambvals, sizeof(AMBVAL *), &aposcmp);
1137                for (i = 0; i < nambvals; i++) {
1138                        if (avlist1[i].p == NULL)
1139                                continue;
1140                        tap = avlist2[i];
1141                        tav = *tap;
1142                        for (j = i; (pnext = avlist1[j].p) != tap;
1143                                        j = avlmemi(pnext)) {
1144                                *(avlist2[j]) = *pnext;
1145                                avinsert(avlist2[j]);
1146                                avlist1[j].p = NULL;
1147                        }
1148                        *(avlist2[j]) = tav;
1149                        avinsert(avlist2[j]);
1150                        avlist1[j].p = NULL;
1151                }
1152                free((void *)avlist1);
1153                free((void *)avlist2);
1154                                                /* compute new sort interval */
1155                sortintvl = ambclock - lastsort;
1156                if (sortintvl >= MAX_SORT_INTVL/2)
1157                        sortintvl = MAX_SORT_INTVL;
1158                else
1159                        sortintvl <<= 1;        /* wait twice as long next */
1160 #ifdef DEBUG
1161                eputs("done\n");
1162 #endif
1163        }
1164        if (ambclock >= MAXACLOCK)
1165                ambclock = MAXACLOCK/2;
1166        lastsort = ambclock;
1167 }
1168
1169
816   #ifdef  F_SETLKW
817  
818   static void
# Line 1178 | 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 1196 | 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 1214 | 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 */
1223 <                        if (lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0)
1224 <                                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)
1228 <                lastpos += (long)nunflshed*AMBVALSIZ;
1229 <        else if ((lastpos = lseek(fileno(ambfp), (off_t)0, SEEK_CUR)) < 0)
1230 <                goto seekerr;
1231 <                
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