ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/ambient.c
Revision: 2.93
Committed: Fri Nov 21 00:53:52 2014 UTC (9 years, 6 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.92: +5 -6 lines
Log Message:
Further limit minimum to 5% of original interreflected value

File Contents

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