--- ray/src/rt/ambient.c	1997/08/30 10:17:01	2.43
+++ ray/src/rt/ambient.c	2007/09/14 00:50:31	2.64
@@ -1,37 +1,32 @@
-/* Copyright (c) 1996 Regents of the University of California */
-
 #ifndef lint
-static char SCCSid[] = "$SunId$ LBL";
+static const char	RCSid[] = "$Id: ambient.c,v 2.64 2007/09/14 00:50:31 greg Exp $";
 #endif
-
 /*
  *  ambient.c - routines dealing with ambient (inter-reflected) component.
+ *
+ *  Declarations of external symbols in ambient.h
  */
 
-#include  "ray.h"
+#include "copyright.h"
 
-#include  "octree.h"
+#include <string.h>
 
+#include  "platform.h"
+#include  "ray.h"
 #include  "otypes.h"
-
+#include  "resolu.h"
 #include  "ambient.h"
-
 #include  "random.h"
 
 #ifndef  OCTSCALE
 #define	 OCTSCALE	1.0	/* ceil((valid rad.)/(cube size)) */
 #endif
 
-typedef struct ambtree {
-	AMBVAL	*alist;		/* ambient value list */
-	struct ambtree	*kid;	/* 8 child nodes */
-}  AMBTREE;			/* ambient octree */
-
-extern CUBE  thescene;		/* contains space boundaries */
-
 extern char  *shm_boundary;	/* memory sharing boundary */
 
-#define	 MAXASET	511	/* maximum number of elements in ambient set */
+#ifndef  MAXASET
+#define	 MAXASET	2047	/* maximum number of elements in ambient set */
+#endif
 OBJECT	ambset[MAXASET+1]={0};	/* ambient include/exclude set */
 
 double	maxarad;		/* maximum ambient radius */
@@ -43,10 +38,10 @@ static FILE  *ambfp = NULL;	/* ambient file pointer */
 static int  nunflshed = 0;	/* number of unflushed ambient values */
 
 #ifndef SORT_THRESH
-#ifdef BIGMEM
-#define SORT_THRESH	((9L<<20)/sizeof(AMBVAL))
-#else
+#ifdef SMLMEM
 #define SORT_THRESH	((3L<<20)/sizeof(AMBVAL))
+#else
+#define SORT_THRESH	((9L<<20)/sizeof(AMBVAL))
 #endif
 #endif
 #ifndef SORT_INTVL
@@ -63,6 +58,8 @@ static unsigned int  nambshare = 0;	/* number of value
 static unsigned long  ambclock = 0;	/* ambient access clock */
 static unsigned long  lastsort = 0;	/* time of last value sort */
 static long  sortintvl = SORT_INTVL;	/* time until next sort */
+static FILE  *ambinp = NULL;		/* auxiliary file for input */
+static long  lastpos = -1;		/* last flush position */
 
 #define MAXACLOCK	(1L<<30)	/* clock turnover value */
 	/*
@@ -78,18 +75,33 @@ static long  sortintvl = SORT_INTVL;	/* time until nex
 
 #define	 AMBFLUSH	(BUFSIZ/AMBVALSIZ)
 
-#define	 newambval()	(AMBVAL *)bmalloc(sizeof(AMBVAL))
+#define	 newambval()	(AMBVAL *)malloc(sizeof(AMBVAL))
+#define  freeav(av)	free((void *)av);
 
-extern long  ftell(), lseek();
-static int  initambfile(), avsave(), avinsert(), sortambvals(), avlmemi();
-static AMBVAL  *avstore();
+static void initambfile(int creat);
+static void avsave(AMBVAL *av);
+static AMBVAL *avstore(AMBVAL  *aval);
+static AMBTREE *newambtree(void);
+static void freeambtree(AMBTREE  *atp);
+
+typedef void unloadtf_t(void *);
+static unloadtf_t avinsert;
+static unloadtf_t av2list;
+static void unloadatree(AMBTREE  *at, unloadtf_t *f);
+
+static int aposcmp(const void *avp1, const void *avp2);
+static int avlmemi(AMBVAL *avaddr);
+static void sortambvals(int always);
+
 #ifdef  F_SETLKW
-static  aflock();
+static void aflock(int  typ);
 #endif
 
 
-setambres(ar)				/* set ambient resolution */
-int  ar;
+extern void
+setambres(				/* set ambient resolution */
+	int  ar
+)
 {
 	ambres = ar < 0 ? 0 : ar;		/* may be done already */
 						/* set min & max radii */
@@ -109,8 +121,10 @@ int  ar;
 }
 
 
-setambacc(newa)				/* set ambient accuracy */
-double  newa;
+extern void
+setambacc(				/* set ambient accuracy */
+	double  newa
+)
 {
 	double  ambdiff;
 
@@ -122,58 +136,107 @@ double  newa;
 }
 
 
-setambient(afile)			/* initialize calculation */
-char  *afile;
+extern void
+setambient(void)				/* initialize calculation */
 {
+	int	readonly = 0;
 	long  pos, flen;
 	AMBVAL	amb;
+						/* make sure we're fresh */
+	ambdone();
 						/* init ambient limits */
 	setambres(ambres);
 	setambacc(ambacc);
-	if (afile == NULL)
+	if (ambfile == NULL || !ambfile[0])
 		return;
 	if (ambacc <= FTINY) {
 		sprintf(errmsg, "zero ambient accuracy so \"%s\" not opened",
-				afile);
+				ambfile);
 		error(WARNING, errmsg);
 		return;
 	}
 						/* open ambient file */
-	if ((ambfp = fopen(afile, "r+")) != NULL) {
-		initambfile(0);
+	if ((ambfp = fopen(ambfile, "r+")) == NULL)
+		readonly = (ambfp = fopen(ambfile, "r")) != NULL;
+	if (ambfp != NULL) {
+		initambfile(0);			/* file exists */
 		pos = ftell(ambfp);
 		while (readambval(&amb, ambfp))
 			avinsert(avstore(&amb));
-						/* align */
+		nambshare = nambvals;		/* share loaded values */
+		if (readonly) {
+			sprintf(errmsg,
+				"loaded %u values from read-only ambient file",
+					nambvals);
+			error(WARNING, errmsg);
+			fclose(ambfp);		/* close file so no writes */
+			ambfp = NULL;
+			return;			/* avoid ambsync() */
+		}
+						/* align file pointer */
 		pos += (long)nambvals*AMBVALSIZ;
-		flen = lseek(fileno(ambfp), 0L, 2);
+		flen = lseek(fileno(ambfp), (off_t)0, SEEK_END);
 		if (flen != pos) {
 			sprintf(errmsg,
 			"ignoring last %ld values in ambient file (corrupted)",
 					(flen - pos)/AMBVALSIZ);
 			error(WARNING, errmsg);
 			fseek(ambfp, pos, 0);
-			ftruncate(fileno(ambfp), pos);
+#ifndef _WIN32 /* XXX we need a replacement for that one */
+			ftruncate(fileno(ambfp), (off_t)pos);
+#endif
 		}
-		nambshare = nambvals;
-	} else if ((ambfp = fopen(afile, "w+")) != NULL)
-		initambfile(1);
-	else {
-		sprintf(errmsg, "cannot open ambient file \"%s\"", afile);
+	} else if ((ambfp = fopen(ambfile, "w+")) != NULL) {
+		initambfile(1);			/* else create new file */
+	} else {
+		sprintf(errmsg, "cannot open ambient file \"%s\"", ambfile);
 		error(SYSTEM, errmsg);
 	}
-	nunflshed++;	/* lie */
-	ambsync();
+	ambsync();			/* load previous values */
 }
 
 
-ambnotify(obj)			/* record new modifier */
-OBJECT	obj;
+extern void
+ambdone(void)			/* close ambient file and free memory */
 {
+	if (ambfp != NULL) {		/* close ambient file */
+		ambsync();
+		fclose(ambfp);
+		ambfp = NULL;
+		if (ambinp != NULL) {	
+			fclose(ambinp);
+			ambinp = NULL;
+		}
+		lastpos = -1;
+	}
+					/* free ambient tree */
+	unloadatree(&atrunk, free);
+					/* reset state variables */
+	avsum = 0.;
+	navsum = 0;
+	nambvals = 0;
+	nambshare = 0;
+	ambclock = 0;
+	lastsort = 0;
+	sortintvl = SORT_INTVL;
+}
+
+
+extern void
+ambnotify(			/* record new modifier */
+	OBJECT	obj
+)
+{
 	static int  hitlimit = 0;
-	register OBJREC	 *o = objptr(obj);
+	register OBJREC	 *o;
 	register char  **amblp;
 
+	if (obj == OVOID) {		/* starting over */
+		ambset[0] = 0;
+		hitlimit = 0;
+		return;
+	}
+	o = objptr(obj);
 	if (hitlimit || !ismodifier(o->otype))
 		return;
 	for (amblp = amblist; *amblp != NULL; amblp++)
@@ -189,12 +252,15 @@ OBJECT	obj;
 }
 
 
-ambient(acol, r, nrm)		/* compute ambient component for ray */
-COLOR  acol;
-register RAY  *r;
-FVECT  nrm;
+extern void
+multambient(		/* compute ambient component & multiply by coef. */
+	COLOR  aval,
+	register RAY  *r,
+	FVECT  nrm
+)
 {
 	static int  rdepth = 0;			/* ambient recursion */
+	COLOR	acol;
 	double	d, l;
 
 	if (ambdiv <= 0)			/* no ambient calculation */
@@ -208,55 +274,64 @@ FVECT  nrm;
 		goto dumbamb;
 
 	if (ambacc <= FTINY) {			/* no ambient storage */
+		copycolor(acol, aval);
 		rdepth++;
 		d = doambient(acol, r, r->rweight, NULL, NULL);
 		rdepth--;
 		if (d <= FTINY)
 			goto dumbamb;
+		copycolor(aval, acol);
 		return;
 	}
 
 	if (tracktime)				/* sort to minimize thrashing */
 		sortambvals(0);
-						/* get ambient value */
+						/* interpolate ambient value */
 	setcolor(acol, 0.0, 0.0, 0.0);
 	d = sumambient(acol, r, nrm, rdepth,
 			&atrunk, thescene.cuorg, thescene.cusize);
 	if (d > FTINY) {
-		scalecolor(acol, 1.0/d);
+		d = 1.0/d;
+		scalecolor(acol, d);
+		multcolor(aval, acol);
 		return;
 	}
 	rdepth++;				/* need to cache new value */
 	d = makeambient(acol, r, nrm, rdepth-1);
 	rdepth--;
-	if (d > FTINY)
+	if (d > FTINY) {
+		multcolor(aval, acol);		/* got new value */
 		return;
+	}
 dumbamb:					/* return global value */
-	copycolor(acol, ambval);
-	if (ambvwt <= 0 | navsum == 0)
+	if ((ambvwt <= 0) | (navsum == 0)) {
+		multcolor(aval, ambval);
 		return;
+	}
 	l = bright(ambval);			/* average in computations */
 	if (l > FTINY) {
 		d = (log(l)*(double)ambvwt + avsum) /
 				(double)(ambvwt + navsum);
 		d = exp(d) / l;
-		scalecolor(acol, d);		/* apply color of ambval */
+		scalecolor(aval, d);
+		multcolor(aval, ambval);	/* apply color of ambval */
 	} else {
 		d = exp( avsum / (double)navsum );
-		setcolor(acol, d, d, d);	/* neutral color */
+		scalecolor(aval, d);		/* neutral color */
 	}
 }
 
 
-double
-sumambient(acol, r, rn, al, at, c0, s)	/* get interpolated ambient value */
-COLOR  acol;
-register RAY  *r;
-FVECT  rn;
-int  al;
-AMBTREE	 *at;
-FVECT  c0;
-double	s;
+extern double
+sumambient(	/* get interpolated ambient value */
+	COLOR  acol,
+	register RAY  *r,
+	FVECT  rn,
+	int  al,
+	AMBTREE	 *at,
+	FVECT  c0,
+	double	s
+)
 {
 	double	d, e1, e2, wt, wsum;
 	COLOR  ct;
@@ -268,6 +343,7 @@ double	s;
 	wsum = 0.0;
 					/* do this node */
 	for (av = at->alist; av != NULL; av = av->next) {
+		double	rn_dot = -2.0;
 		if (tracktime)
 			av->latick = ambclock;
 		/*
@@ -275,7 +351,7 @@ double	s;
 		 */
 		if (av->lvl > al)	/* list sorted, so this works */
 			break;
-		if (av->weight < r->rweight-FTINY)
+		if (av->weight < 0.9*r->rweight)
 			continue;
 		/*
 		 *  Ambient radius test.
@@ -290,9 +366,19 @@ double	s;
 		if (e1 > ambacc*ambacc*1.21)
 			continue;
 		/*
-		 *  Normal direction test.
+		 *  Direction test using closest normal.
 		 */
-		e2 = (1.0 - DOT(av->dir, r->ron)) * r->rweight;
+		d = DOT(av->dir, r->ron);
+		if (rn != r->ron) {
+			rn_dot = DOT(av->dir, rn);
+			if (rn_dot > 1.0-FTINY)
+				rn_dot = 1.0-FTINY;
+			if (rn_dot >= d-FTINY) {
+				d = rn_dot;
+				rn_dot = -2.0;
+			}
+		}
+		e2 = (1.0 - d) * r->rweight;
 		if (e2 < 0.0) e2 = 0.0;
 		if (e1 + e2 > ambacc*ambacc*1.21)
 			continue;
@@ -308,9 +394,18 @@ double	s;
 		/*
 		 *  Jittering final test reduces image artifacts.
 		 */
-		wt = sqrt(e1) + sqrt(e2);
+		e1 = sqrt(e1);
+		e2 = sqrt(e2);
+		wt = e1 + e2;
 		if (wt > ambacc*(.9+.2*urand(9015+samplendx)))
 			continue;
+		/*
+		 *  Recompute directional error using perturbed normal
+		 */
+		if (rn_dot > 0.0) {
+			e2 = sqrt((1.0 - rn_dot)*r->rweight);
+			wt = e1 + e2;
+		}
 		if (wt <= 1e-3)
 			wt = 1e3;
 		else
@@ -335,30 +430,39 @@ double	s;
 				break;
 		}
 		if (j == 3)
-			wsum += sumambient(acol, r, rn, al, at->kid+i, ck0, s);
+			wsum += sumambient(acol, r, rn, al,
+						at->kid+i, ck0, s);
 	}
 	return(wsum);
 }
 
 
-double
-makeambient(acol, r, rn, al)	/* make a new ambient value */
-COLOR  acol;
-register RAY  *r;
-FVECT  rn;
-int  al;
+extern double
+makeambient(		/* make a new ambient value for storage */
+	COLOR  acol,
+	RAY  *r,
+	FVECT  rn,
+	int  al
+)
 {
 	AMBVAL	amb;
 	FVECT	gp, gd;
-						/* compute weight */
-	amb.weight = pow(AVGREFL, (double)al);
-	if (r->rweight < 0.1*amb.weight)	/* heuristic */
-		amb.weight = r->rweight;
+	int	i;
+
+	amb.weight = 1.0;			/* compute weight */
+	for (i = al; i-- > 0; )
+		amb.weight *= AVGREFL;
+	if (r->rweight < 0.1*amb.weight)	/* heuristic override */
+		amb.weight = 1.25*r->rweight;
+	setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
 						/* compute ambient */
 	amb.rad = doambient(acol, r, amb.weight, gp, gd);
-	if (amb.rad <= FTINY)
+	if (amb.rad <= FTINY) {
+		setcolor(acol, 0.0, 0.0, 0.0);
 		return(0.0);
-						/* store it */
+	}
+	scalecolor(acol, 1./AVGREFL);		/* undo assumed reflectance */
+						/* store value */
 	VCOPY(amb.pos, r->rop);
 	VCOPY(amb.dir, r->ron);
 	amb.lvl = al;
@@ -373,12 +477,15 @@ int  al;
 }
 
 
-extambient(cr, ap, pv, nv)		/* extrapolate value at pv, nv */
-COLOR  cr;
-register AMBVAL	 *ap;
-FVECT  pv, nv;
+extern void
+extambient(		/* extrapolate value at pv, nv */
+	COLOR  cr,
+	register AMBVAL	 *ap,
+	FVECT  pv,
+	FVECT  nv
+)
 {
-	FVECT  v1, v2;
+	FVECT  v1;
 	register int  i;
 	double	d;
 
@@ -387,9 +494,8 @@ FVECT  pv, nv;
 	for (i = 0; i < 3; i++)
 		d += ap->gpos[i]*(pv[i]-ap->pos[i]);
 					/* gradient due to rotation */
-	VCOPY(v1, ap->dir);
-	fcross(v2, v1, nv);
-	d += DOT(ap->gdir, v2);
+	VCROSS(v1, ap->dir, nv);
+	d += DOT(ap->gdir, v1);
 	if (d <= 0.0) {
 		setcolor(cr, 0.0, 0.0, 0.0);
 		return;
@@ -399,29 +505,35 @@ FVECT  pv, nv;
 }
 
 
-static
-initambfile(creat)		/* initialize ambient file */
-int  creat;
+static void
+initambfile(		/* initialize ambient file */
+	int  creat
+)
 {
-	extern char  *progname, *octname, VersionID[];
+	extern char  *progname, *octname;
+	static char  *mybuf = NULL;
 
 #ifdef	F_SETLKW
 	aflock(creat ? F_WRLCK : F_RDLCK);
 #endif
-#ifdef MSDOS
-	setmode(fileno(ambfp), O_BINARY);
-#endif
-	setbuf(ambfp, bmalloc(BUFSIZ+8));
+	SET_FILE_BINARY(ambfp);
+	if (mybuf == NULL)
+		mybuf = (char *)bmalloc(BUFSIZ+8);
+	setbuf(ambfp, mybuf);
 	if (creat) {			/* new file */
 		newheader("RADIANCE", ambfp);
 		fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
 				progname, colval(ambval,RED),
 				colval(ambval,GRN), colval(ambval,BLU),
 				ambvwt, ambounce, ambacc);
-		fprintf(ambfp, "-ad %d -as %d -ar %d %s\n",
-				ambdiv, ambssamp, ambres,
-				octname==NULL ? "" : octname);
+		fprintf(ambfp, "-ad %d -as %d -ar %d ",
+				ambdiv, ambssamp, ambres);
+		if (octname != NULL)
+			printargs(1, &octname, ambfp);
+		else
+			fputc('\n', ambfp);
 		fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
+		fputnow(ambfp);
 		fputformat(AMBFMT, ambfp);
 		putc('\n', ambfp);
 		putambmagic(ambfp);
@@ -430,9 +542,10 @@ int  creat;
 }
 
 
-static
-avsave(av)				/* insert and save an ambient value */
-AMBVAL	*av;
+static void
+avsave(				/* insert and save an ambient value */
+	AMBVAL	*av
+)
 {
 	avinsert(avstore(av));
 	if (ambfp == NULL)
@@ -444,20 +557,21 @@ AMBVAL	*av;
 			goto writerr;
 	return;
 writerr:
-	error(SYSTEM, "error writing ambient file");
+	error(SYSTEM, "error writing to ambient file");
 }
 
 
 static AMBVAL *
-avstore(aval)				/* allocate memory and store aval */
-register AMBVAL  *aval;
+avstore(				/* allocate memory and store aval */
+	register AMBVAL  *aval
+)
 {
 	register AMBVAL  *av;
 	double	d;
 
 	if ((av = newambval()) == NULL)
 		error(SYSTEM, "out of memory in avstore");
-	copystruct(av, aval);
+	*av = *aval;
 	av->latick = ambclock;
 	av->next = NULL;
 	nambvals++;
@@ -475,14 +589,13 @@ register AMBVAL  *aval;
 static AMBTREE  *atfreelist = NULL;	/* free ambient tree structures */
 
 
-static
-AMBTREE *
-newambtree()				/* allocate 8 ambient tree structs */
+static AMBTREE *
+newambtree(void)				/* allocate 8 ambient tree structs */
 {
 	register AMBTREE  *atp, *upperlim;
 
 	if (atfreelist == NULL) {	/* get more nodes */
-		atfreelist = (AMBTREE *)bmalloc(ATALLOCSZ*8*sizeof(AMBTREE));
+		atfreelist = (AMBTREE *)malloc(ATALLOCSZ*8*sizeof(AMBTREE));
 		if (atfreelist == NULL)
 			return(NULL);
 					/* link new free list */
@@ -493,23 +606,25 @@ newambtree()				/* allocate 8 ambient tree structs */
 	}
 	atp = atfreelist;
 	atfreelist = atp->kid;
-	bzero((char *)atp, 8*sizeof(AMBTREE));
+	memset((char *)atp, '\0', 8*sizeof(AMBTREE));
 	return(atp);
 }
 
 
-static
-freeambtree(atp)			/* free 8 ambient tree structs */
-AMBTREE  *atp;
+static void
+freeambtree(			/* free 8 ambient tree structs */
+	AMBTREE  *atp
+)
 {
 	atp->kid = atfreelist;
 	atfreelist = atp;
 }
 
 
-static
-avinsert(av)				/* insert ambient value in our tree */
-register AMBVAL	 *av;
+static void
+avinsert(				/* insert ambient value in our tree */
+	void *av
+)
 {
 	register AMBTREE  *at;
 	register AMBVAL  *ap;
@@ -519,19 +634,19 @@ register AMBVAL	 *av;
 	int  branch;
 	register int  i;
 
-	if (av->rad <= FTINY)
+	if (((AMBVAL*)av)->rad <= FTINY)
 		error(CONSISTENCY, "zero ambient radius in avinsert");
 	at = &atrunk;
 	VCOPY(ck0, thescene.cuorg);
 	s = thescene.cusize;
-	while (s*(OCTSCALE/2) > av->rad*ambacc) {
+	while (s*(OCTSCALE/2) > ((AMBVAL*)av)->rad*ambacc) {
 		if (at->kid == NULL)
 			if ((at->kid = newambtree()) == NULL)
 				error(SYSTEM, "out of memory in avinsert");
 		s *= 0.5;
 		branch = 0;
 		for (i = 0; i < 3; i++)
-			if (av->pos[i] > ck0[i] + s) {
+			if (((AMBVAL*)av)->pos[i] > ck0[i] + s) {
 				ck0[i] += s;
 				branch |= 1 << i;
 			}
@@ -539,18 +654,19 @@ register AMBVAL	 *av;
 	}
 	avh.next = at->alist;		/* order by increasing level */
 	for (ap = &avh; ap->next != NULL; ap = ap->next)
-		if (ap->next->lvl >= av->lvl)
+		if (ap->next->lvl >= ((AMBVAL*)av)->lvl)
 			break;
-	av->next = ap->next;
-	ap->next = av;
+	((AMBVAL*)av)->next = ap->next;
+	ap->next = (AMBVAL*)av;
 	at->alist = avh.next;
 }
 
 
-static
-unloadatree(at, f)			/* unload an ambient value tree */
-register AMBTREE  *at;
-int	(*f)();
+static void
+unloadatree(			/* unload an ambient value tree */
+	register AMBTREE  *at,
+	unloadtf_t *f
+)
 {
 	register AMBVAL  *av;
 	register int  i;
@@ -575,41 +691,56 @@ static struct avl {
 static AMBVAL	**avlist2;		/* memory positions for sorting */
 static int	i_avlist;		/* index for lists */
 
+static int alatcmp(const void *av1, const void *av2);
 
-static
-av2list(av)
-register AMBVAL	*av;
+static void
+av2list(
+	void *av
+)
 {
 #ifdef DEBUG
 	if (i_avlist >= nambvals)
 		error(CONSISTENCY, "too many ambient values in av2list1");
 #endif
-	avlist1[i_avlist].p = avlist2[i_avlist] = av;
-	avlist1[i_avlist++].t = av->latick;
+	avlist1[i_avlist].p = avlist2[i_avlist] = (AMBVAL*)av;
+	avlist1[i_avlist++].t = ((AMBVAL*)av)->latick;
 }
 
 
 static int
-alatcmp(av1, av2)			/* compare ambient values for MRA */
-struct avl	*av1, *av2;
+alatcmp(			/* compare ambient values for MRA */
+	const void *av1,
+	const void *av2
+)
 {
-	register long  lc = av2->t - av1->t;
+	register long  lc = ((struct avl *)av2)->t - ((struct avl *)av1)->t;
 	return(lc<0 ? -1 : lc>0 ? 1 : 0);
 }
 
 
+/* GW NOTE 2002/10/3:
+ * I used to compare AMBVAL pointers, but found that this was the
+ * cause of a serious consistency error with gcc, since the optimizer
+ * uses some dangerous trick in pointer subtraction that
+ * assumes pointers differ by exact struct size increments.
+ */
 static int
-aposcmp(avp1, avp2)			/* compare ambient value positions */
-AMBVAL	**avp1, **avp2;
+aposcmp(			/* compare ambient value positions */
+	const void	*avp1,
+	const void	*avp2
+)
 {
-	return(*avp1 - *avp2);
+	register long	diff = *(char * const *)avp1 - *(char * const *)avp2;
+	if (diff < 0)
+		return(-1);
+	return(diff > 0);
 }
 
-
 #if 1
 static int
-avlmemi(avaddr)				/* find list position from address */
-AMBVAL	*avaddr;
+avlmemi(				/* find list position from address */
+	AMBVAL	*avaddr
+)
 {
 	register AMBVAL  **avlpp;
 
@@ -625,9 +756,10 @@ AMBVAL	*avaddr;
 #endif
 
 
-static
-sortambvals(always)			/* resort ambient values */
-int	always;
+static void
+sortambvals(			/* resort ambient values */
+	int	always
+)
 {
 	AMBTREE  oldatrunk;
 	AMBVAL	tav, *tap, *pnext;
@@ -660,9 +792,9 @@ int	always;
 	}
 	if (avlist1 == NULL) {		/* no time tracking -- rebuild tree? */
 		if (avlist2 != NULL)
-			free((char *)avlist2);
+			free((void *)avlist2);
 		if (always) {		/* rebuild without sorting */
-			copystruct(&oldatrunk, &atrunk);
+			oldatrunk = atrunk;
 			atrunk.alist = NULL;
 			atrunk.kid = NULL;
 			unloadatree(&oldatrunk, avinsert);
@@ -693,19 +825,19 @@ int	always;
 			if (avlist1[i].p == NULL)
 				continue;
 			tap = avlist2[i];
-			copystruct(&tav, tap);
+			tav = *tap;
 			for (j = i; (pnext = avlist1[j].p) != tap;
 					j = avlmemi(pnext)) {
-				copystruct(avlist2[j], pnext);
+				*(avlist2[j]) = *pnext;
 				avinsert(avlist2[j]);
 				avlist1[j].p = NULL;
 			}
-			copystruct(avlist2[j], &tav);
+			*(avlist2[j]) = tav;
 			avinsert(avlist2[j]);
 			avlist1[j].p = NULL;
 		}
-		free((char *)avlist1);
-		free((char *)avlist2);
+		free((void *)avlist1);
+		free((void *)avlist2);
 						/* compute new sort interval */
 		sortintvl = ambclock - lastsort;
 		if (sortintvl >= MAX_SORT_INTVL/2)
@@ -724,9 +856,10 @@ int	always;
 
 #ifdef	F_SETLKW
 
-static
-aflock(typ)			/* lock/unlock ambient file */
-int  typ;
+static void
+aflock(			/* lock/unlock ambient file */
+	int  typ
+)
 {
 	static struct flock  fls;	/* static so initialized to zeroes */
 
@@ -736,25 +869,21 @@ int  typ;
 }
 
 
-int
-ambsync()			/* synchronize ambient file */
+extern int
+ambsync(void)			/* synchronize ambient file */
 {
-	static FILE  *ambinp = NULL;
-	static long  lastpos = -1;
 	long  flen;
 	AMBVAL	avs;
 	register int  n;
 
-	if (nunflshed == 0)
-		return(0);
 	if (lastpos < 0)	/* initializing (locked in initambfile) */
 		goto syncend;
-				/* gain exclusive access */
-	aflock(F_WRLCK);
+				/* gain appropriate access */
+	aflock(nunflshed ? F_WRLCK : F_RDLCK);
 				/* see if file has grown */
-	if ((flen = lseek(fileno(ambfp), 0L, 2)) < 0)
+	if ((flen = lseek(fileno(ambfp), (off_t)0, SEEK_END)) < 0)
 		goto seekerr;
-	if (n = flen - lastpos) {		/* file has grown */
+	if ( (n = flen - lastpos) ) {		/* file has grown */
 		if (ambinp == NULL) {		/* use duplicate filedes */
 			ambinp = fdopen(dup(fileno(ambfp)), "r");
 			if (ambinp == NULL)
@@ -765,17 +894,18 @@ ambsync()			/* synchronize ambient file */
 		while (n >= AMBVALSIZ) {	/* load contributed values */
 			if (!readambval(&avs, ambinp)) {
 				sprintf(errmsg,
-				"ambient file corrupted near character %ld",
-						flen - n);
+			"ambient file \"%s\" corrupted near character %ld",
+						ambfile, flen - n);
 				error(WARNING, errmsg);
 				break;
 			}
 			avinsert(avstore(&avs));
 			n -= AMBVALSIZ;
 		}
+		lastpos = flen - n;
 		/*** seek always as safety measure
 		if (n) ***/			/* alignment */
-			if (lseek(fileno(ambfp), flen-n, 0) < 0)
+			if (lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0)
 				goto seekerr;
 	}
 #ifdef  DEBUG
@@ -788,22 +918,24 @@ ambsync()			/* synchronize ambient file */
 #endif
 syncend:
 	n = fflush(ambfp);			/* calls write() at last */
-	if ((lastpos = lseek(fileno(ambfp), 0L, 1)) < 0)
-		goto seekerr;
+	if (n == EOF) {
+		if ((lastpos = lseek(fileno(ambfp), (off_t)0, SEEK_CUR)) < 0)
+			goto seekerr;
+	} else
+		lastpos += (long)nunflshed*AMBVALSIZ;
 	aflock(F_UNLCK);			/* release file */
 	nunflshed = 0;
 	return(n);
 seekerr:
 	error(SYSTEM, "seek failed in ambsync");
+	return -1; /* pro forma return */
 }
 
 #else
 
-int
-ambsync()			/* flush ambient file */
+extern int
+ambsync(void)			/* flush ambient file */
 {
-	if (nunflshed == 0)
-		return(0);
 	nunflshed = 0;
 	return(fflush(ambfp));
 }