src/util/glareval.c

/* Copyright (c) 1991 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 * Compute pixels for glare calculation
 */

#include "glare.h"
#include "resolu.h"
                                        /* maximum rtrace buffer size */
#define MAXPIX          (4096/(6*sizeof(float)))

#define MAXSBUF         786432  /* maximum total size of scanline buffer */
#define HSIZE           317     /* size of scanline hash table */
#define NRETIRE         16      /* number of scanlines to retire at once */

int     rt_pd[3] = {-1,-1,-1};  /* process id & descriptors for rtrace */

FILE    *pictfp = NULL;         /* picture file pointer */
double  exposure;               /* picture exposure */
int     pxsiz, pysiz;           /* picture dimensions */

static int      curpos;         /* current scanline */
static long     *scanpos;       /* scanline positions */

typedef struct scan {
        int     y;              /* scanline position */
        long    lused;          /* for LRU replacement */
        struct scan     *next;  /* next in this hash or free list */
        /* followed by the scanline data */
} SCAN;                 /* buffered scanline */

#define scandata(sl)    ((COLR *)((sl)+1))
#define shash(y)        ((y)%HSIZE)

static int      maxpix;         /* maximum number of pixels to buffer */

static SCAN     *freelist;              /* scanline free list */
static SCAN     *hashtab[HSIZE];        /* scanline hash table */

static long     scanbufsiz;             /* size of allocated scanline buffer */

static long     ncall = 0L;     /* number of calls to getpictscan */
static long     nread = 0L;     /* number of scanlines read */
static long     nrecl = 0L;     /* number of scanlines reclaimed */

static int      wrongformat = 0;

SCAN    *scanretire();

extern long     ftell();


SCAN *
claimscan(y)                    /* claim scanline from buffers */
int     y;
{
        int     hi = shash(y);
        SCAN    *slast;
        register SCAN   *sl;

        for (sl = hashtab[hi]; sl != NULL; sl = sl->next)
                if (sl->y == y)                         /* active scanline */
                        return(sl);
        for (slast = NULL, sl = freelist; sl != NULL; slast = sl, sl = sl->next)
                if (sl->y == -1 || sl->y == y || sl->next == NULL) {
                        if (slast == NULL)              /* remove from free */
                                freelist = sl->next;
                        else
                                slast->next = sl->next;
                        if (sl->y == y) {               /* reclaim */
                                sl->next = hashtab[hi];
                                hashtab[hi] = sl;
                                nrecl++;
                        }
                        return(sl);
                }
        return(scanretire());           /* need more free scanlines */
}


COLR *
getpictscan(y)                  /* get picture scanline */
int     y;
{
        register SCAN   *sl;
        register int    i;
                                        /* first check our buffers */
        sl = claimscan(y);
        if (sl == NULL)
                memerr("claimscan()");
        sl->lused = ncall++;
        if (sl->y == y)                 /* scan hit */
                return(scandata(sl));
                                        /* else read in replacement */
        if (scanpos[y] < 0) {                   /* need to search */
                for (i = y+1; i < curpos; i++)
                        if (scanpos[i] >= 0) {
                                if (fseek(pictfp, scanpos[i], 0) < 0)
                                        goto seekerr;
                                curpos = i;
                                break;
                        }
                while (curpos >= y) {
                        scanpos[curpos] = ftell(pictfp);
                        if (freadcolrs(scandata(sl), pxsiz, pictfp) < 0)
                                goto readerr;
                        nread++;
                        curpos--;
                }
        } else {
                if (curpos != y && fseek(pictfp, scanpos[y], 0) < 0)
                        goto seekerr;
                if (freadcolrs(scandata(sl), pxsiz, pictfp) < 0)
                        goto readerr;
                nread++;
                curpos = y-1;
        }
        sl->y = y;
        i = shash(y);                   /* add to hash list */
        sl->next = hashtab[i];
        hashtab[i] = sl;
        return(scandata(sl));
readerr:
        fprintf(stderr, "%s: picture read error\n", progname);
        exit(1);
seekerr:
        fprintf(stderr, "%s: picture seek error\n", progname);
        exit(1);
}


#ifdef DEBUG
pict_stats()                    /* print out picture read statistics */
{
        static long     lastcall = 0L;  /* ncall at last report */
        static long     lastread = 0L;  /* nread at last report */
        static long     lastrecl = 0L;  /* nrecl at last report */

        if (ncall == lastcall)
                return;
        fprintf(stderr, "%s: %ld scanlines read (%ld reclaimed) in %ld calls\n",
                progname, nread-lastread, nrecl-lastrecl, ncall-lastcall);
        lastcall = ncall;
        lastread = nread;
        lastrecl = nrecl;
}
#endif


double
pict_val(vd)                    /* find picture value for view direction */
FVECT   vd;
{
        FVECT   pp;
        FVECT   ip;
        COLOR   res;

        if (pictfp == NULL)
                return(-1.0);
        pp[0] = pictview.vp[0] + vd[0];
        pp[1] = pictview.vp[1] + vd[1];
        pp[2] = pictview.vp[2] + vd[2];
        viewloc(ip, &pictview, pp);
        if (ip[2] <= FTINY || ip[0] < 0. || ip[0] >= 1. ||
                        ip[1] < 0. || ip[1] >= 1.)
                return(-1.0);
        colr_color(res, getpictscan((int)(ip[1]*pysiz))[(int)(ip[0]*pxsiz)]);
        return(luminance(res)/exposure);
}


double
getviewpix(vh, vv)              /* compute single view pixel */
int     vh, vv;
{
        FVECT   dir;
        float   rt_buf[12];
        double  res;

        if (compdir(dir, vh, vv) < 0)
                return(-1.0);
        npixinvw++;
        if ((res = pict_val(dir)) >= 0.0)
                return(res);
        if (rt_pd[0] == -1) {
                npixmiss++;
                return(-1.0);
        }
        rt_buf[0] = ourview.vp[0];
        rt_buf[1] = ourview.vp[1];
        rt_buf[2] = ourview.vp[2];
        rt_buf[3] = dir[0];
        rt_buf[4] = dir[1];
        rt_buf[5] = dir[2];
        rt_compute(rt_buf, 1);
        return(luminance(rt_buf));
}


getviewspan(vv, vb)             /* compute a span of view pixels */
int     vv;
float   *vb;
{
        float   rt_buf[6*MAXPIX];       /* rtrace send/receive buffer */
        register int    n;              /* number of pixels in buffer */
        short   buf_vh[MAXPIX];         /* pixel positions */
        FVECT   dir;
        register int    vh;

#ifdef DEBUG
        if (verbose)
                fprintf(stderr, "%s: computing view span at %d...\n",
                                progname, vv);
#endif
        n = 0;
        for (vh = -hsize; vh <= hsize; vh++) {
                if (compdir(dir, vh, vv) < 0) {         /* not in view */
                        vb[vh+hsize] = -1.0;
                        continue;
                }
                npixinvw++;
                if ((vb[vh+hsize] = pict_val(dir)) >= 0.0)
                        continue;
                if (rt_pd[0] == -1) {           /* missing information */
                        npixmiss++;
                        continue;
                }
                                                /* send to rtrace */
                if (n >= maxpix) {                      /* flush */
                        rt_compute(rt_buf, n);
                        while (n-- > 0)
                                vb[buf_vh[n]+hsize] = luminance(rt_buf+3*n);
                }
                rt_buf[6*n] = ourview.vp[0];
                rt_buf[6*n+1] = ourview.vp[1];
                rt_buf[6*n+2] = ourview.vp[2];
                rt_buf[6*n+3] = dir[0];
                rt_buf[6*n+4] = dir[1];
                rt_buf[6*n+5] = dir[2];
                buf_vh[n++] = vh;
        }
#ifdef DEBUG
        if (verbose)
                pict_stats();
#endif
        if (n > 0) {                            /* process pending buffer */
                rt_compute(rt_buf, n);
                while (n-- > 0)
                        vb[buf_vh[n]+hsize] = luminance(rt_buf+3*n);
        }
}


rt_compute(pb, np)              /* process buffer through rtrace */
float   *pb;
int     np;
{
#ifdef DEBUG
        if (verbose && np > 1)
                fprintf(stderr, "%s: sending %d samples to rtrace...\n",
                                progname, np);
#endif
        bzero(pb+6*np, 6*sizeof(float));
        if (process(rt_pd, pb, pb, 3*sizeof(float)*np,
                        6*sizeof(float)*(np+1)) < 3*sizeof(float)*np) {
                fprintf(stderr, "%s: rtrace communication error\n",
                                progname);
                exit(1);
        }
}


getexpos(s)                     /* get exposure from header line */
char    *s;
{
        char    fmt[32];

        if (isexpos(s))
                exposure *= exposval(s);
        else if (isformat(s)) {
                formatval(fmt, s);
                wrongformat = strcmp(fmt, COLRFMT);
        }
}


open_pict(fn)                   /* open picture file */
char    *fn;
{
        if ((pictfp = fopen(fn, "r")) == NULL) {
                fprintf(stderr, "%s: cannot open\n", fn);
                exit(1);
        }
        exposure = 1.0;
        getheader(pictfp, getexpos, NULL);
        if (wrongformat || !fscnresolu(&pxsiz, &pysiz, pictfp)) {
                fprintf(stderr, "%s: incompatible picture format\n", fn);
                exit(1);
        }
        initscans();
}


close_pict()                    /* done with picture */
{
        if (pictfp == NULL)
                return;
        fclose(pictfp);
        donescans();
        pictfp = NULL;
}


fork_rtrace(av)                 /* open pipe and start rtrace */
char    *av[];
{
        int     rval;

        rval = open_process(rt_pd, av);
        if (rval < 0) {
                perror(progname);
                exit(1);
        }
        if (rval == 0) {
                fprintf(stderr, "%s: command not found\n", av[0]);
                exit(1);
        }
        maxpix = rval/(6*sizeof(float));
        if (maxpix > MAXPIX)
                maxpix = MAXPIX;
        maxpix--;
}


done_rtrace()                   /* wait for rtrace to finish */
{
        int     status;

        status = close_process(rt_pd);
        if (status > 0) {
                fprintf(stderr, "%s: bad status (%d) from rtrace\n",
                                progname, status);
                exit(1);
        }
        rt_pd[0] = -1;
}


SCAN *
scanretire()                    /* retire old scanlines to free list */
{
        SCAN    *sold[NRETIRE];
        int     n;
        int     h;
        register SCAN   *sl;
        register int    i;
                                        /* grab the NRETIRE oldest scanlines */
        sold[n = 0] = NULL;
        for (h = 0; h < HSIZE; h++)
                for (sl = hashtab[h]; sl != NULL; sl = sl->next) {
                        for (i = n; i && sold[i-1]->lused > sl->lused; i--)
                                if (i < NRETIRE)
                                        sold[i] = sold[i-1];
                        if (i < NRETIRE) {
                                sold[i] = sl;
                                if (n < NRETIRE)        /* grow list */
                                        n++;
                        }
                }
                                        /* put scanlines into free list */
        for (i = 0; i < n; i++) {
                h = shash(sold[i]->y);
                sl = hashtab[h];
                if (sl == sold[i])
                        hashtab[h] = sl->next;
                else {
                        while (sl->next != sold[i])     /* IS in list */
                                sl = sl->next;
                        sl->next = sold[i]->next;
                }
                if (i > 0) {            /* save oldest as return value */
                        sold[i]->next = freelist;
                        freelist = sold[i];
                }
        }
        return(sold[0]);
}


static char     *scan_buf;


initscans()                             /* initialize scanline buffers */
{
        int     scansize;
        register SCAN   *ptr;
        register int    i;
                                        /* initialize positions */
        scanpos = (long *)bmalloc(pysiz*sizeof(long));
        if (scanpos == NULL)
                memerr("scanline positions");
        for (i = pysiz-1; i >= 0; i--)
                scanpos[i] = -1L;
        curpos = pysiz-1;
                                        /* clear hash table */
        for (i = 0; i < HSIZE; i++)
                hashtab[i] = NULL;
                                        /* allocate scanline buffers */
        scansize = sizeof(SCAN) + pxsiz*sizeof(COLR);
#ifdef ALIGN
        scansize = scansize+(sizeof(ALIGN)-1) & ~(sizeof(ALIGN)-1);
#endif
        i = MAXSBUF / scansize;         /* compute number to allocate */
        if (i > HSIZE)
                i = HSIZE;
        scanbufsiz = i*scansize;
        scan_buf = bmalloc(scanbufsiz); /* get in one big chunk */
        if (scan_buf == NULL)
                memerr("scanline buffers");
        ptr = (SCAN *)scan_buf;
        freelist = NULL;                /* build our free list */
        while (i-- > 0) {
                ptr->y = -1;
                ptr->lused = -1;
                ptr->next = freelist;
                freelist = ptr;
                ptr = (SCAN *)((char *)ptr + scansize); /* beware of C bugs */
        }
}


donescans()                             /* free up scanlines */
{
        bfree(scan_buf, scanbufsiz);
        bfree((char *)scanpos, pysiz*sizeof(long));
}
Revision:	2.3
Committed:	Tue Sep 21 10:53:45 1993 UTC (31 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.2:	+1 -1 lines
Log Message:	minor bug fix
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1991 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Compute pixels for glare calculation
9			*/
10
11			#include "glare.h"
12	greg	1.21	#include "resolu.h"
13	greg	1.19	/* maximum rtrace buffer size */
14			#define MAXPIX (4096/(6*sizeof(float)))
15	greg	1.1
16	greg	1.16	#define MAXSBUF 786432 /* maximum total size of scanline buffer */
17	greg	1.9	#define HSIZE 317 /* size of scanline hash table */
18	greg	1.8	#define NRETIRE 16 /* number of scanlines to retire at once */
19	greg	1.1
20	greg	1.19	int rt_pd[3] = {-1,-1,-1}; /* process id & descriptors for rtrace */
21	greg	1.1
22			FILE pictfp = NULL; / picture file pointer */
23			double exposure; /* picture exposure */
24			int pxsiz, pysiz; /* picture dimensions */
25	greg	1.8
26			static int curpos; /* current scanline */
27			static long scanpos; / scanline positions */
28
29			typedef struct scan {
30			int y; /* scanline position */
31	greg	1.1	long lused; /* for LRU replacement */
32	greg	1.8	struct scan next; / next in this hash or free list */
33			/* followed by the scanline data */
34			} SCAN; /* buffered scanline */
35	greg	1.1
36	greg	1.8	#define scandata(sl) ((COLR *)((sl)+1))
37			#define shash(y) ((y)%HSIZE)
38
39	greg	1.19	static int maxpix; /* maximum number of pixels to buffer */
40
41	greg	1.8	static SCAN freelist; / scanline free list */
42			static SCAN hashtab[HSIZE]; / scanline hash table */
43
44	greg	2.2	static long scanbufsiz; /* size of allocated scanline buffer */
45
46	greg	1.2	static long ncall = 0L; /* number of calls to getpictscan */
47			static long nread = 0L; /* number of scanlines read */
48	greg	1.15	static long nrecl = 0L; /* number of scanlines reclaimed */
49	greg	1.1
50	greg	1.13	static int wrongformat = 0;
51
52	greg	1.8	SCAN *scanretire();
53
54	greg	1.5	extern long ftell();
55	greg	1.2
56	greg	1.5
57	greg	1.8	SCAN *
58			claimscan(y) /* claim scanline from buffers */
59			int y;
60			{
61			int hi = shash(y);
62			SCAN *slast;
63			register SCAN *sl;
64
65			for (sl = hashtab[hi]; sl != NULL; sl = sl->next)
66			if (sl->y == y) /* active scanline */
67			return(sl);
68			for (slast = NULL, sl = freelist; sl != NULL; slast = sl, sl = sl->next)
69			if (sl->y == -1 \|\| sl->y == y \|\| sl->next == NULL) {
70			if (slast == NULL) /* remove from free */
71			freelist = sl->next;
72			else
73			slast->next = sl->next;
74			if (sl->y == y) { /* reclaim */
75			sl->next = hashtab[hi];
76			hashtab[hi] = sl;
77	greg	1.15	nrecl++;
78	greg	1.8	}
79			return(sl);
80			}
81			return(scanretire()); /* need more free scanlines */
82			}
83
84
85	greg	1.1	COLR *
86			getpictscan(y) /* get picture scanline */
87			int y;
88			{
89	greg	1.8	register SCAN *sl;
90	greg	1.1	register int i;
91			/* first check our buffers */
92	greg	1.8	sl = claimscan(y);
93			if (sl == NULL)
94			memerr("claimscan()");
95			sl->lused = ncall++;
96			if (sl->y == y) /* scan hit */
97			return(scandata(sl));
98			/* else read in replacement */
99	greg	1.5	if (scanpos[y] < 0) { /* need to search */
100			for (i = y+1; i < curpos; i++)
101			if (scanpos[i] >= 0) {
102			if (fseek(pictfp, scanpos[i], 0) < 0)
103			goto seekerr;
104			curpos = i;
105			break;
106			}
107			while (curpos >= y) {
108	greg	1.1	scanpos[curpos] = ftell(pictfp);
109	greg	1.8	if (freadcolrs(scandata(sl), pxsiz, pictfp) < 0)
110	greg	1.1	goto readerr;
111	greg	1.5	nread++;
112	greg	1.1	curpos--;
113			}
114	greg	1.5	} else {
115			if (curpos != y && fseek(pictfp, scanpos[y], 0) < 0)
116			goto seekerr;
117	greg	1.8	if (freadcolrs(scandata(sl), pxsiz, pictfp) < 0)
118	greg	1.5	goto readerr;
119			nread++;
120			curpos = y-1;
121	greg	1.1	}
122	greg	1.8	sl->y = y;
123			i = shash(y); /* add to hash list */
124			sl->next = hashtab[i];
125			hashtab[i] = sl;
126			return(scandata(sl));
127	greg	1.1	readerr:
128			fprintf(stderr, "%s: picture read error\n", progname);
129			exit(1);
130	greg	1.5	seekerr:
131			fprintf(stderr, "%s: picture seek error\n", progname);
132			exit(1);
133	greg	1.1	}
134
135
136	greg	1.6	#ifdef DEBUG
137	greg	1.2	pict_stats() /* print out picture read statistics */
138			{
139			static long lastcall = 0L; /* ncall at last report */
140			static long lastread = 0L; /* nread at last report */
141	greg	1.15	static long lastrecl = 0L; /* nrecl at last report */
142	greg	1.2
143			if (ncall == lastcall)
144			return;
145	greg	1.15	fprintf(stderr, "%s: %ld scanlines read (%ld reclaimed) in %ld calls\n",
146			progname, nread-lastread, nrecl-lastrecl, ncall-lastcall);
147	greg	1.2	lastcall = ncall;
148			lastread = nread;
149	greg	1.15	lastrecl = nrecl;
150	greg	1.2	}
151	greg	1.6	#endif
152	greg	1.2
153
154	greg	1.1	double
155			pict_val(vd) /* find picture value for view direction */
156			FVECT vd;
157			{
158			FVECT pp;
159	greg	1.21	FVECT ip;
160	greg	1.1	COLOR res;
161
162			if (pictfp == NULL)
163			return(-1.0);
164			pp[0] = pictview.vp[0] + vd[0];
165			pp[1] = pictview.vp[1] + vd[1];
166			pp[2] = pictview.vp[2] + vd[2];
167	greg	1.21	viewloc(ip, &pictview, pp);
168			if (ip[2] <= FTINY \|\| ip[0] < 0. \|\| ip[0] >= 1. \|\|
169			ip[1] < 0. \|\| ip[1] >= 1.)
170	greg	1.1	return(-1.0);
171	greg	1.21	colr_color(res, getpictscan((int)(ip[1]pysiz))[(int)(ip[0]pxsiz)]);
172	greg	1.1	return(luminance(res)/exposure);
173			}
174
175
176			double
177	greg	1.14	getviewpix(vh, vv) /* compute single view pixel */
178	greg	1.1	int vh, vv;
179			{
180			FVECT dir;
181	greg	1.19	float rt_buf[12];
182	greg	1.1	double res;
183
184	greg	1.14	if (compdir(dir, vh, vv) < 0)
185	greg	1.1	return(-1.0);
186	greg	1.7	npixinvw++;
187	greg	1.1	if ((res = pict_val(dir)) >= 0.0)
188			return(res);
189	greg	1.19	if (rt_pd[0] == -1) {
190	greg	1.7	npixmiss++;
191	greg	1.1	return(-1.0);
192	greg	1.7	}
193	greg	1.1	rt_buf[0] = ourview.vp[0];
194			rt_buf[1] = ourview.vp[1];
195			rt_buf[2] = ourview.vp[2];
196			rt_buf[3] = dir[0];
197			rt_buf[4] = dir[1];
198			rt_buf[5] = dir[2];
199			rt_compute(rt_buf, 1);
200			return(luminance(rt_buf));
201			}
202
203
204			getviewspan(vv, vb) /* compute a span of view pixels */
205			int vv;
206			float *vb;
207			{
208			float rt_buf[6MAXPIX]; / rtrace send/receive buffer */
209	greg	1.3	register int n; /* number of pixels in buffer */
210	greg	1.1	short buf_vh[MAXPIX]; /* pixel positions */
211			FVECT dir;
212			register int vh;
213
214	greg	1.4	#ifdef DEBUG
215	greg	1.1	if (verbose)
216			fprintf(stderr, "%s: computing view span at %d...\n",
217			progname, vv);
218	greg	1.4	#endif
219	greg	1.3	n = 0;
220	greg	1.1	for (vh = -hsize; vh <= hsize; vh++) {
221	greg	1.14	if (compdir(dir, vh, vv) < 0) { /* not in view */
222	greg	1.1	vb[vh+hsize] = -1.0;
223			continue;
224			}
225	greg	1.7	npixinvw++;
226	greg	1.1	if ((vb[vh+hsize] = pict_val(dir)) >= 0.0)
227			continue;
228	greg	1.19	if (rt_pd[0] == -1) { /* missing information */
229	greg	1.7	npixmiss++;
230	greg	1.1	continue;
231	greg	1.7	}
232	greg	1.1	/* send to rtrace */
233	greg	1.19	if (n >= maxpix) { /* flush */
234	greg	1.3	rt_compute(rt_buf, n);
235			while (n-- > 0)
236			vb[buf_vh[n]+hsize] = luminance(rt_buf+3*n);
237	greg	1.1	}
238	greg	1.3	rt_buf[6*n] = ourview.vp[0];
239			rt_buf[6*n+1] = ourview.vp[1];
240			rt_buf[6*n+2] = ourview.vp[2];
241			rt_buf[6*n+3] = dir[0];
242			rt_buf[6*n+4] = dir[1];
243			rt_buf[6*n+5] = dir[2];
244			buf_vh[n++] = vh;
245	greg	1.1	}
246	greg	1.4	#ifdef DEBUG
247	greg	1.2	if (verbose)
248			pict_stats();
249	greg	1.4	#endif
250	greg	1.3	if (n > 0) { /* process pending buffer */
251			rt_compute(rt_buf, n);
252			while (n-- > 0)
253			vb[buf_vh[n]+hsize] = luminance(rt_buf+3*n);
254			}
255	greg	1.1	}
256
257
258			rt_compute(pb, np) /* process buffer through rtrace */
259			float *pb;
260			int np;
261			{
262	greg	1.4	#ifdef DEBUG
263	greg	1.1	if (verbose && np > 1)
264			fprintf(stderr, "%s: sending %d samples to rtrace...\n",
265			progname, np);
266	greg	1.4	#endif
267	greg	1.20	bzero(pb+6np, 6sizeof(float));
268	greg	1.19	if (process(rt_pd, pb, pb, 3sizeof(float)np,
269			6sizeof(float)(np+1)) < 3sizeof(float)np) {
270			fprintf(stderr, "%s: rtrace communication error\n",
271	greg	1.1	progname);
272			exit(1);
273			}
274			}
275
276
277			getexpos(s) /* get exposure from header line */
278			char *s;
279			{
280	greg	1.13	char fmt[32];
281
282	greg	1.1	if (isexpos(s))
283			exposure *= exposval(s);
284	greg	1.13	else if (isformat(s)) {
285			formatval(fmt, s);
286			wrongformat = strcmp(fmt, COLRFMT);
287			}
288	greg	1.1	}
289
290
291			open_pict(fn) /* open picture file */
292			char *fn;
293			{
294			if ((pictfp = fopen(fn, "r")) == NULL) {
295	greg	2.3	fprintf(stderr, "%s: cannot open\n", fn);
296	greg	1.1	exit(1);
297			}
298			exposure = 1.0;
299	greg	1.13	getheader(pictfp, getexpos, NULL);
300	greg	1.21	if (wrongformat \|\| !fscnresolu(&pxsiz, &pysiz, pictfp)) {
301			fprintf(stderr, "%s: incompatible picture format\n", fn);
302	greg	1.1	exit(1);
303			}
304	greg	1.8	initscans();
305	greg	1.1	}
306
307
308			close_pict() /* done with picture */
309			{
310			if (pictfp == NULL)
311			return;
312			fclose(pictfp);
313	greg	1.8	donescans();
314	greg	1.1	pictfp = NULL;
315			}
316
317
318			fork_rtrace(av) /* open pipe and start rtrace */
319			char *av[];
320			{
321	greg	1.19	int rval;
322	greg	1.1
323	greg	1.19	rval = open_process(rt_pd, av);
324			if (rval < 0) {
325	greg	1.1	perror(progname);
326			exit(1);
327			}
328	greg	1.19	if (rval == 0) {
329			fprintf(stderr, "%s: command not found\n", av[0]);
330	greg	1.1	exit(1);
331			}
332	greg	1.19	maxpix = rval/(6*sizeof(float));
333			if (maxpix > MAXPIX)
334			maxpix = MAXPIX;
335			maxpix--;
336	greg	1.1	}
337
338
339			done_rtrace() /* wait for rtrace to finish */
340			{
341	greg	1.19	int status;
342	greg	1.1
343	greg	1.19	status = close_process(rt_pd);
344			if (status > 0) {
345	greg	1.1	fprintf(stderr, "%s: bad status (%d) from rtrace\n",
346			progname, status);
347			exit(1);
348			}
349	greg	1.19	rt_pd[0] = -1;
350	greg	1.8	}
351
352
353			SCAN *
354			scanretire() /* retire old scanlines to free list */
355			{
356			SCAN *sold[NRETIRE];
357			int n;
358			int h;
359			register SCAN *sl;
360			register int i;
361			/* grab the NRETIRE oldest scanlines */
362			sold[n = 0] = NULL;
363	greg	1.10	for (h = 0; h < HSIZE; h++)
364			for (sl = hashtab[h]; sl != NULL; sl = sl->next) {
365			for (i = n; i && sold[i-1]->lused > sl->lused; i--)
366			if (i < NRETIRE)
367	greg	1.8	sold[i] = sold[i-1];
368			if (i < NRETIRE) {
369	greg	1.10	sold[i] = sl;
370	greg	1.8	if (n < NRETIRE) /* grow list */
371			n++;
372	greg	1.10	}
373			}
374			/* put scanlines into free list */
375			for (i = 0; i < n; i++) {
376			h = shash(sold[i]->y);
377			sl = hashtab[h];
378			if (sl == sold[i])
379			hashtab[h] = sl->next;
380			else {
381			while (sl->next != sold[i]) /* IS in list */
382	greg	1.8	sl = sl->next;
383	greg	1.10	sl->next = sold[i]->next;
384	greg	1.8	}
385	greg	1.10	if (i > 0) { /* save oldest as return value */
386			sold[i]->next = freelist;
387			freelist = sold[i];
388			}
389	greg	1.8	}
390			return(sold[0]);
391			}
392
393
394			static char *scan_buf;
395
396
397			initscans() /* initialize scanline buffers */
398			{
399			int scansize;
400			register SCAN *ptr;
401			register int i;
402			/* initialize positions */
403	greg	2.2	scanpos = (long )bmalloc(pysizsizeof(long));
404	greg	1.8	if (scanpos == NULL)
405			memerr("scanline positions");
406			for (i = pysiz-1; i >= 0; i--)
407			scanpos[i] = -1L;
408			curpos = pysiz-1;
409			/* clear hash table */
410			for (i = 0; i < HSIZE; i++)
411			hashtab[i] = NULL;
412			/* allocate scanline buffers */
413			scansize = sizeof(SCAN) + pxsiz*sizeof(COLR);
414			#ifdef ALIGN
415	greg	1.17	scansize = scansize+(sizeof(ALIGN)-1) & ~(sizeof(ALIGN)-1);
416	greg	1.8	#endif
417			i = MAXSBUF / scansize; /* compute number to allocate */
418			if (i > HSIZE)
419			i = HSIZE;
420	greg	2.2	scanbufsiz = i*scansize;
421			scan_buf = bmalloc(scanbufsiz); /* get in one big chunk */
422	greg	1.8	if (scan_buf == NULL)
423			memerr("scanline buffers");
424			ptr = (SCAN *)scan_buf;
425			freelist = NULL; /* build our free list */
426			while (i-- > 0) {
427			ptr->y = -1;
428			ptr->lused = -1;
429			ptr->next = freelist;
430			freelist = ptr;
431			ptr = (SCAN )((char )ptr + scansize); /* beware of C bugs */
432			}
433			}
434
435
436			donescans() /* free up scanlines */
437			{
438	greg	2.2	bfree(scan_buf, scanbufsiz);
439			bfree((char )scanpos, pysizsizeof(long));
440	greg	1.1	}