src/rt/rc2.c

#ifndef lint
static const char RCSid[] = "$Id: rc2.c,v 2.24 2019/09/04 20:19:51 greg Exp $";
#endif
/*
 * Accumulate ray contributions for a set of materials
 * File i/o and recovery
 */

#include <ctype.h>
#include "platform.h"
#include "rcontrib.h"
#include "resolu.h"

/* Close output stream and free record */
static void
closestream(void *p)
{
        STREAMOUT       *sop = (STREAMOUT *)p;
        
        if (sop->ofp != NULL) {
                int     status = 0;
                if (sop->outpipe)
                        status = pclose(sop->ofp);
                else if (sop->ofp != stdout)
                        status = fclose(sop->ofp);
                if (status)
                        error(SYSTEM, "error closing output stream");
        }
        free(p);
}

LUTAB   ofiletab = LU_SINIT(free,closestream);  /* output file table */

#define OF_MODIFIER     01
#define OF_BIN          02

/************************** STREAM & FILE I/O ***************************/

/* Construct output file name and return flags whether modifier/bin present */
static int
ofname(char *oname, const char *ospec, const char *mname, int bn)
{
        const char      *mnp = NULL;
        const char      *bnp = NULL;
        const char      *cp;
        
        if (ospec == NULL)
                return(-1);
        for (cp = ospec; *cp; cp++)             /* check format position(s) */
                if (*cp == '%') {
                        do
                                ++cp;
                        while (isdigit(*cp));
                        switch (*cp) {
                        case '%':
                                break;
                        case 's':
                                if (mnp != NULL)
                                        return(-1);
                                mnp = cp;
                                break;
                        case 'd':
                        case 'i':
                        case 'o':
                        case 'x':
                        case 'X':
                                if (bnp != NULL)
                                        return(-1);
                                bnp = cp;
                                break;
                        default:
                                return(-1);
                        }
                }
        if (mnp != NULL) {                      /* create file name */
                if (bnp != NULL) {
                        if (bnp > mnp)
                                sprintf(oname, ospec, mname, bn);
                        else
                                sprintf(oname, ospec, bn, mname);
                        return(OF_MODIFIER|OF_BIN);
                }
                sprintf(oname, ospec, mname);
                return(OF_MODIFIER);
        }
        if (bnp != NULL) {
                sprintf(oname, ospec, bn);
                return(OF_BIN);
        }
        strcpy(oname, ospec);
        return(0);
}


/* Write header to the given output stream */
static void
printheader(FILE *fout, const char *info)
{
        extern char     VersionID[];
                                                /* copy octree header */
        if (octname[0] == '!') {
                newheader("RADIANCE", fout);
                fputs(octname+1, fout);
                if (octname[strlen(octname)-1] != '\n')
                        fputc('\n', fout);
        } else {
                FILE    *fin = fopen(octname, (outfmt=='a') ? "r" : "rb");
                if (fin == NULL)
                        quit(1);
                checkheader(fin, OCTFMT, fout);
                fclose(fin);
        }
        printargs(gargc-1, gargv, fout);        /* add our command */
        fprintf(fout, "SOFTWARE= %s\n", VersionID);
        fputnow(fout);
        fputs("NCOMP=3\n", fout);               /* always RGB */
        if (info != NULL)                       /* add extra info if given */
                fputs(info, fout);
        if ((outfmt == 'f') | (outfmt == 'd'))
                fputendian(fout);
        fputformat(formstr(outfmt), fout);
        fputc('\n', fout);                      /* empty line ends header */
}


/* Write resolution string to given output stream */
static void
printresolu(FILE *fout, int xr, int yr)
{
        if ((xr > 0) & (yr > 0))        /* resolution string */
                fprtresolu(xr, yr, fout);
}


/* Get output stream pointer (open and write header if new and noopen==0) */
STREAMOUT *
getostream(const char *ospec, const char *mname, int bn, int noopen)
{
        static STREAMOUT        stdos;
        char                    info[1024];
        int                     ofl;
        char                    oname[1024];
        LUENT                   *lep;
        STREAMOUT               *sop;
        char                    *cp;

        info[0] = '\0';
        if (ospec == NULL) {                    /* use stdout? */
                if (!noopen & !using_stdout) {
                        if (outfmt != 'a')
                                SET_FILE_BINARY(stdout);
#ifdef getc_unlocked
                        flockfile(stdout);      /* avoid lock/unlock overhead */
#endif
                        if (header) {
                                cp = info;
                                if (yres > 0) {
                                        sprintf(cp, "NROWS=%d\n", yres *
                                                        (xres + !xres) );
                                        while (*cp) ++cp;
                                }
                                if ((xres <= 0) | (stdos.reclen > 1))
                                        sprintf(cp, "NCOLS=%d\n", stdos.reclen);
                                printheader(stdout, info);
                        }
                        if (stdos.reclen == 1)
                                printresolu(stdout, xres, yres);
                        if (waitflush > 0)
                                fflush(stdout);
                        stdos.xr = xres; stdos.yr = yres;
                        using_stdout = 1;
                }
                stdos.ofp = stdout;
                stdos.reclen += noopen;
                return(&stdos);
        }
        ofl = ofname(oname, ospec, mname, bn);  /* get output name */
        if (ofl < 0) {
                sprintf(errmsg, "bad output format '%s'", ospec);
                error(USER, errmsg);
        }
        lep = lu_find(&ofiletab, oname);        /* look it up */
        if (lep->key == NULL)                   /* new entry */
                lep->key = strcpy((char *)malloc(strlen(oname)+1), oname);
        sop = (STREAMOUT *)lep->data;
        if (sop == NULL) {                      /* allocate stream */
                sop = (STREAMOUT *)malloc(sizeof(STREAMOUT));
                if (sop == NULL)
                        error(SYSTEM, "out of memory in getostream");
                sop->outpipe = (oname[0] == '!');
                sop->reclen = 0;
                sop->ofp = NULL;                /* open iff noopen==0 */
                sop->xr = xres; sop->yr = yres;
                lep->data = (char *)sop;
                if (!sop->outpipe & !force_open & !recover &&
                                access(oname, F_OK) == 0) {
                        errno = EEXIST;         /* file exists */
                        goto openerr;
                }
        } else if (noopen && outfmt == 'c' &&   /* stream exists to picture? */
                        (sop->xr > 0) & (sop->yr > 0)) {
                if (ofl & OF_BIN)
                        return(NULL);           /* let caller offset bins */
                sprintf(errmsg, "output '%s' not a valid picture", oname);
                error(WARNING, errmsg);
        }
        if (!noopen && sop->ofp == NULL) {      /* open output stream */
                if (oname[0] == '!')            /* output to command */
                        sop->ofp = popen(oname+1, "w");
                else                            /* else open file */
                        sop->ofp = fopen(oname, "w");
                if (sop->ofp == NULL)
                        goto openerr;
                if (outfmt != 'a')
                        SET_FILE_BINARY(sop->ofp);
#ifdef getc_unlocked
                flockfile(sop->ofp);            /* avoid lock/unlock overhead */
#endif
                if (accumulate > 0) {           /* global resolution */
                        sop->xr = xres; sop->yr = yres;
                }
                if (header) {
                        cp = info;
                        if (ofl & OF_MODIFIER || sop->reclen == 1) {
                                sprintf(cp, "MODIFIER=%s\n", mname);
                                while (*cp) ++cp;
                        }
                        if (ofl & OF_BIN) {
                                sprintf(cp, "BIN=%d\n", bn);
                                while (*cp) ++cp;
                        }
                        if (sop->yr > 0) {
                                sprintf(cp, "NROWS=%d\n", sop->yr *
                                                (sop->xr + !sop->xr) );
                                while (*cp) ++cp;
                        }
                        if ((sop->xr <= 0) | (sop->reclen > 1))
                                sprintf(cp, "NCOLS=%d\n", sop->reclen);
                        printheader(sop->ofp, info);
                }
                if (sop->reclen == 1)
                        printresolu(sop->ofp, sop->xr, sop->yr);
                if (waitflush > 0)
                        fflush(sop->ofp);
        }
        sop->reclen += noopen;                  /* add to length if noopen */
        return(sop);                            /* return output stream */
openerr:
        sprintf(errmsg, "cannot open '%s' for writing", oname);
        error(SYSTEM, errmsg);
        return(NULL);   /* pro forma return */
}


/* Get a vector from stdin */
int
getvec(FVECT vec)
{
        float   vf[3];
        double  vd[3];
        char    buf[32];
        int     i;

        switch (inpfmt) {
        case 'a':                                       /* ascii */
                for (i = 0; i < 3; i++) {
                        if (fgetword(buf, sizeof(buf), stdin) == NULL ||
                                        !isflt(buf))
                                return(-1);
                        vec[i] = atof(buf);
                }
                break;
        case 'f':                                       /* binary float */
                if (getbinary((char *)vf, sizeof(float), 3, stdin) != 3)
                        return(-1);
                VCOPY(vec, vf);
                break;
        case 'd':                                       /* binary double */
                if (getbinary((char *)vd, sizeof(double), 3, stdin) != 3)
                        return(-1);
                VCOPY(vec, vd);
                break;
        default:
                error(CONSISTENCY, "botched input format");
        }
        return(0);
}


/* Put out ray contribution to file */
static void
put_contrib(const DCOLOR cnt, FILE *fout)
{
        double  sf = 1;
        COLOR   fv;
        COLR    cv;

        if (accumulate > 1)
                sf = 1./(double)accumulate;
        switch (outfmt) {
        case 'a':
                if (accumulate > 1)
                        fprintf(fout, "%.6e\t%.6e\t%.6e\t",
                                        sf*cnt[0], sf*cnt[1], sf*cnt[2]);
                else
                        fprintf(fout, "%.6e\t%.6e\t%.6e\t",
                                        cnt[0], cnt[1], cnt[2]);
                break;
        case 'f':
                if (accumulate > 1) {
                        copycolor(fv, cnt);
                        scalecolor(fv, sf);
                } else
                        copycolor(fv, cnt);
                putbinary(fv, sizeof(float), 3, fout);
                break;
        case 'd':
                if (accumulate > 1) {
                        DCOLOR  dv;
                        copycolor(dv, cnt);
                        scalecolor(dv, sf);
                        putbinary(dv, sizeof(double), 3, fout);
                } else
                        putbinary(cnt, sizeof(double), 3, fout);
                break;
        case 'c':
                if (accumulate > 1)
                        setcolr(cv, sf*cnt[0], sf*cnt[1], sf*cnt[2]);
                else
                        setcolr(cv, cnt[0], cnt[1], cnt[2]);
                putbinary(cv, sizeof(cv), 1, fout);
                break;
        default:
                error(INTERNAL, "botched output format");
        }
}


/* Output modifier values to appropriate stream(s) */
void
mod_output(MODCONT *mp)
{
        STREAMOUT       *sop = getostream(mp->outspec, mp->modname, mp->bin0, 0);
        int             j;

        put_contrib(mp->cbin[0], sop->ofp);
        if (mp->nbins > 3 &&    /* minor optimization */
                        sop == getostream(mp->outspec, mp->modname, mp->bin0+1, 0)) {
                for (j = 1; j < mp->nbins; j++)
                        put_contrib(mp->cbin[j], sop->ofp);
        } else {
                for (j = 1; j < mp->nbins; j++) {
                        sop = getostream(mp->outspec, mp->modname, mp->bin0+j, 0);
                        put_contrib(mp->cbin[j], sop->ofp);
                }
        }
}


/* callback to output newline to ASCII file and/or flush as requested */
static int
puteol(const LUENT *e, void *p)
{
        STREAMOUT       *sop = (STREAMOUT *)e->data;

        if (outfmt == 'a')
                putc('\n', sop->ofp);
        if (!waitflush)
                fflush(sop->ofp);
        if (ferror(sop->ofp)) {
                sprintf(errmsg, "write error on file '%s'", e->key);
                error(SYSTEM, errmsg);
        }
        return(0);
}


/* Terminate record output and flush if time */
void
end_record()
{
        --waitflush;
        lu_doall(&ofiletab, &puteol, NULL);
        if (using_stdout & (outfmt == 'a'))
                putc('\n', stdout);
        if (!waitflush) {
                waitflush = (yres > 0) & (xres > 1) ? 0 : xres;
                if (using_stdout)
                        fflush(stdout);
        }
}

/************************** PARTIAL RESULTS RECOVERY ***********************/

/* Get ray contribution from previous file */
static int
get_contrib(DCOLOR cnt, FILE *finp)
{
        COLOR   fv;
        COLR    cv;

        switch (outfmt) {
        case 'a':
                return(fscanf(finp,"%lf %lf %lf",&cnt[0],&cnt[1],&cnt[2]) == 3);
        case 'f':
                if (getbinary(fv, sizeof(fv[0]), 3, finp) != 3)
                        return(0);
                copycolor(cnt, fv);
                return(1);
        case 'd':
                return(getbinary(cnt, sizeof(cnt[0]), 3, finp) == 3);
        case 'c':
                if (getbinary(cv, sizeof(cv), 1, finp) != 1)
                        return(0);
                colr_color(fv, cv);
                copycolor(cnt, fv);
                return(1);
        default:
                error(INTERNAL, "botched output format");
        }
        return(0);      /* pro forma return */
}


/* Close output file opened for input */
static int
myclose(const LUENT *e, void *p)
{
        STREAMOUT       *sop = (STREAMOUT *)e->data;
        
        if (sop->ofp == NULL)
                return(0);
        fclose(sop->ofp);
        sop->ofp = NULL;
        return(0);
}


/* Load previously accumulated values */
void
reload_output()
{
        int             i, j;
        MODCONT         *mp;
        int             ofl;
        char            oname[1024];
        char            *fmode = "rb";
        char            *outvfmt;
        LUENT           *oent;
        int             xr, yr;
        STREAMOUT       *sop;
        DCOLOR          rgbv;

        if (outfmt == 'a')
                fmode = "r";
        outvfmt = formstr(outfmt);
                                                /* reload modifier values */
        for (i = 0; i < nmods; i++) {
                mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
                if (mp->outspec == NULL)
                        error(USER, "cannot reload from stdout");
                if (mp->outspec[0] == '!')
                        error(USER, "cannot reload from command");
                for (j = 0; j < mp->nbins; j++) { /* load each modifier bin */
                        ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
                        if (ofl < 0)
                                error(USER, "bad output file specification");
                        oent = lu_find(&ofiletab, oname);
                        if (oent->data == NULL)
                                error(INTERNAL, "unallocated stream in reload_output()");
                        sop = (STREAMOUT *)oent->data;
                        if (sop->ofp == NULL) { /* open output as input */
                                sop->ofp = fopen(oname, fmode);
                                if (sop->ofp == NULL) {
                                        sprintf(errmsg, "missing reload file '%s'",
                                                        oname);
                                        error(WARNING, errmsg);
                                        break;
                                }
#ifdef getc_unlocked
                                flockfile(sop->ofp);
#endif
                                if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
                                        sprintf(errmsg, "format mismatch for '%s'",
                                                        oname);
                                        error(USER, errmsg);
                                }
                                if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
                                                (!fscnresolu(&xr, &yr, sop->ofp) ||
                                                        (xr != sop->xr) |
                                                        (yr != sop->yr))) {
                                        sprintf(errmsg, "resolution mismatch for '%s'",
                                                        oname);
                                        error(USER, errmsg);
                                }
                        }
                                                        /* read in RGB value */
                        if (!get_contrib(rgbv, sop->ofp)) {
                                if (!j) {
                                        fclose(sop->ofp);
                                        break;          /* ignore empty file */
                                }
                                if (j < mp->nbins) {
                                        sprintf(errmsg, "missing data in '%s'",
                                                        oname);
                                        error(USER, errmsg);
                                }
                                break;
                        }                               
                        copycolor(mp->cbin[j], rgbv);
                }
        }
        lu_doall(&ofiletab, &myclose, NULL);    /* close all files */
}


/* Seek on the given output file */
static int
myseeko(const LUENT *e, void *p)
{
        STREAMOUT       *sop = (STREAMOUT *)e->data;
        off_t           nbytes = *(off_t *)p;
        
        if (sop->reclen > 1)
                nbytes *= (off_t)sop->reclen;
        if (fseeko(sop->ofp, nbytes, SEEK_CUR) < 0) {
                sprintf(errmsg, "seek error on file '%s'", e->key);
                error(SYSTEM, errmsg);
        }
        return(0);
}


/* Recover output if possible */
void
recover_output()
{
        off_t           lastout = -1;
        int             outvsiz, recsiz;
        char            *outvfmt;
        int             i, j;
        MODCONT         *mp;
        int             ofl;
        char            oname[1024];
        LUENT           *oent;
        STREAMOUT       *sop;
        off_t           nvals;
        int             xr, yr;

        switch (outfmt) {
        case 'a':
                error(USER, "cannot recover ASCII output");
                return;
        case 'f':
                outvsiz = sizeof(float)*3;
                break;
        case 'd':
                outvsiz = sizeof(double)*3;
                break;
        case 'c':
                outvsiz = sizeof(COLR);
                break;
        default:
                error(INTERNAL, "botched output format");
                return;
        }
        outvfmt = formstr(outfmt);
                                                /* check modifier outputs */
        for (i = 0; i < nmods; i++) {
                mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
                if (mp->outspec == NULL)
                        error(USER, "cannot recover from stdout");
                if (mp->outspec[0] == '!')
                        error(USER, "cannot recover from command");
                for (j = 0; j < mp->nbins; j++) { /* check each bin's file */
                        ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
                        if (ofl < 0)
                                error(USER, "bad output file specification");
                        oent = lu_find(&ofiletab, oname);
                        if (oent->data == NULL)
                                error(INTERNAL, "unallocated stream in recover_output()");
                        sop = (STREAMOUT *)oent->data;
                        if (sop->ofp != NULL) { /* already open? */
                                if (ofl & OF_BIN)
                                        continue;
                                break;
                        }
                                                /* open output */
                        sop->ofp = fopen(oname, "rb+");
                        if (sop->ofp == NULL) {
                                sprintf(errmsg, "missing recover file '%s'",
                                                oname);
                                error(WARNING, errmsg);
                                lastout = 0;
                                break;
                        }
                        nvals = lseek(fileno(sop->ofp), 0, SEEK_END);
                        if (nvals <= 0) {
                                lastout = 0;    /* empty output, quit here */
                                fclose(sop->ofp);
                                break;
                        }
                        recsiz = outvsiz * sop->reclen;

                        lseek(fileno(sop->ofp), 0, SEEK_SET);
                        if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
                                sprintf(errmsg, "format mismatch for '%s'",
                                                oname);
                                error(USER, errmsg);
                        }
                        if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
                                        (!fscnresolu(&xr, &yr, sop->ofp) ||
                                                (xr != sop->xr) |
                                                (yr != sop->yr))) {
                                sprintf(errmsg, "resolution mismatch for '%s'",
                                                oname);
                                error(USER, errmsg);
                        }
                        nvals = (nvals - (off_t)ftell(sop->ofp)) / recsiz;
                        if ((lastout < 0) | (nvals < lastout))
                                lastout = nvals;
                        if (!(ofl & OF_BIN))
                                break;          /* no bin separation */
                }
                if (!lastout) {                 /* empty output */
                        error(WARNING, "no previous data to recover");
                                                /* reclose all outputs */
                        lu_doall(&ofiletab, &myclose, NULL);
                        return;
                }
        }
        if (lastout < 0) {
                error(WARNING, "no output files to recover");
                return;
        }
        if (raysleft && lastout >= raysleft/accumulate) {
                error(WARNING, "output appears to be complete");
                /* XXX should read & discard input? */
                quit(0);
        }
                                                /* seek on all files */
        nvals = lastout * outvsiz;
        lu_doall(&ofiletab, &myseeko, &nvals);
                                                /* skip repeated input */
        lastout *= accumulate;
        for (nvals = 0; nvals < lastout; nvals++) {
                FVECT   vdummy;
                if (getvec(vdummy) < 0 || getvec(vdummy) < 0)
                        error(USER, "unexpected EOF on input");
        }
        lastray = lastdone = (RNUMBER)lastout;
        if (raysleft)
                raysleft -= lastray;
}
Revision:	2.25
Committed:	Fri Apr 7 00:03:26 2023 UTC (13 months, 1 week ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4
Changes since 2.24:	+3 -2 lines
Log Message:	fix(rcontrib): Fixed potential string overrun while printing header
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.25	static const char RCSid[] = "$Id: rc2.c,v 2.24 2019/09/04 20:19:51 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Accumulate ray contributions for a set of materials
6			* File i/o and recovery
7			*/
8
9	schorsch	2.17	#include <ctype.h>
10			#include "platform.h"
11	greg	2.1	#include "rcontrib.h"
12			#include "resolu.h"
13
14	greg	2.3	/* Close output stream and free record */
15			static void
16			closestream(void *p)
17			{
18			STREAMOUT sop = (STREAMOUT )p;
19
20			if (sop->ofp != NULL) {
21			int status = 0;
22			if (sop->outpipe)
23			status = pclose(sop->ofp);
24			else if (sop->ofp != stdout)
25			status = fclose(sop->ofp);
26			if (status)
27			error(SYSTEM, "error closing output stream");
28			}
29			free(p);
30			}
31
32			LUTAB ofiletab = LU_SINIT(free,closestream); /* output file table */
33
34	greg	2.1	#define OF_MODIFIER 01
35			#define OF_BIN 02
36
37			/************************ STREAM & FILE I/O *************************/
38
39			/* Construct output file name and return flags whether modifier/bin present */
40			static int
41			ofname(char oname, const char ospec, const char *mname, int bn)
42			{
43			const char *mnp = NULL;
44			const char *bnp = NULL;
45			const char *cp;
46
47			if (ospec == NULL)
48			return(-1);
49			for (cp = ospec; cp; cp++) / check format position(s) */
50			if (*cp == '%') {
51			do
52			++cp;
53			while (isdigit(*cp));
54			switch (*cp) {
55			case '%':
56			break;
57			case 's':
58			if (mnp != NULL)
59			return(-1);
60			mnp = cp;
61			break;
62			case 'd':
63			case 'i':
64			case 'o':
65			case 'x':
66			case 'X':
67			if (bnp != NULL)
68			return(-1);
69			bnp = cp;
70			break;
71			default:
72			return(-1);
73			}
74			}
75			if (mnp != NULL) { /* create file name */
76			if (bnp != NULL) {
77			if (bnp > mnp)
78			sprintf(oname, ospec, mname, bn);
79			else
80			sprintf(oname, ospec, bn, mname);
81			return(OF_MODIFIER\|OF_BIN);
82			}
83			sprintf(oname, ospec, mname);
84			return(OF_MODIFIER);
85			}
86			if (bnp != NULL) {
87			sprintf(oname, ospec, bn);
88			return(OF_BIN);
89			}
90			strcpy(oname, ospec);
91			return(0);
92			}
93
94
95			/* Write header to the given output stream */
96			static void
97			printheader(FILE fout, const char info)
98			{
99			extern char VersionID[];
100			/* copy octree header */
101			if (octname[0] == '!') {
102			newheader("RADIANCE", fout);
103			fputs(octname+1, fout);
104			if (octname[strlen(octname)-1] != '\n')
105			fputc('\n', fout);
106			} else {
107	greg	2.2	FILE *fin = fopen(octname, (outfmt=='a') ? "r" : "rb");
108	greg	2.1	if (fin == NULL)
109			quit(1);
110	greg	2.2	checkheader(fin, OCTFMT, fout);
111	greg	2.1	fclose(fin);
112			}
113			printargs(gargc-1, gargv, fout); /* add our command */
114			fprintf(fout, "SOFTWARE= %s\n", VersionID);
115			fputnow(fout);
116	greg	2.9	fputs("NCOMP=3\n", fout); /* always RGB */
117	greg	2.1	if (info != NULL) /* add extra info if given */
118			fputs(info, fout);
119	greg	2.23	if ((outfmt == 'f') \| (outfmt == 'd'))
120			fputendian(fout);
121	greg	2.1	fputformat(formstr(outfmt), fout);
122			fputc('\n', fout); /* empty line ends header */
123			}
124
125
126			/* Write resolution string to given output stream */
127			static void
128			printresolu(FILE *fout, int xr, int yr)
129			{
130			if ((xr > 0) & (yr > 0)) /* resolution string */
131			fprtresolu(xr, yr, fout);
132			}
133
134
135			/* Get output stream pointer (open and write header if new and noopen==0) */
136			STREAMOUT *
137			getostream(const char ospec, const char mname, int bn, int noopen)
138			{
139			static STREAMOUT stdos;
140	greg	2.9	char info[1024];
141	greg	2.1	int ofl;
142			char oname[1024];
143			LUENT *lep;
144			STREAMOUT *sop;
145	greg	2.11	char *cp;
146	greg	2.25
147			info[0] = '\0';
148	greg	2.1	if (ospec == NULL) { /* use stdout? */
149	greg	2.3	if (!noopen & !using_stdout) {
150	greg	2.1	if (outfmt != 'a')
151			SET_FILE_BINARY(stdout);
152	greg	2.24	#ifdef getc_unlocked
153			flockfile(stdout); /* avoid lock/unlock overhead */
154			#endif
155	greg	2.9	if (header) {
156	greg	2.11	cp = info;
157			if (yres > 0) {
158			sprintf(cp, "NROWS=%d\n", yres *
159			(xres + !xres) );
160			while (*cp) ++cp;
161			}
162	greg	2.13	if ((xres <= 0) \| (stdos.reclen > 1))
163			sprintf(cp, "NCOLS=%d\n", stdos.reclen);
164	greg	2.9	printheader(stdout, info);
165			}
166	greg	2.13	if (stdos.reclen == 1)
167			printresolu(stdout, xres, yres);
168	greg	2.1	if (waitflush > 0)
169			fflush(stdout);
170			stdos.xr = xres; stdos.yr = yres;
171			using_stdout = 1;
172			}
173			stdos.ofp = stdout;
174			stdos.reclen += noopen;
175			return(&stdos);
176			}
177			ofl = ofname(oname, ospec, mname, bn); /* get output name */
178			if (ofl < 0) {
179			sprintf(errmsg, "bad output format '%s'", ospec);
180			error(USER, errmsg);
181			}
182			lep = lu_find(&ofiletab, oname); /* look it up */
183			if (lep->key == NULL) /* new entry */
184			lep->key = strcpy((char *)malloc(strlen(oname)+1), oname);
185			sop = (STREAMOUT *)lep->data;
186			if (sop == NULL) { /* allocate stream */
187			sop = (STREAMOUT *)malloc(sizeof(STREAMOUT));
188			if (sop == NULL)
189			error(SYSTEM, "out of memory in getostream");
190	greg	2.19	sop->outpipe = (oname[0] == '!');
191	greg	2.1	sop->reclen = 0;
192			sop->ofp = NULL; /* open iff noopen==0 */
193			sop->xr = xres; sop->yr = yres;
194			lep->data = (char *)sop;
195			if (!sop->outpipe & !force_open & !recover &&
196			access(oname, F_OK) == 0) {
197			errno = EEXIST; /* file exists */
198			goto openerr;
199			}
200	greg	2.19	} else if (noopen && outfmt == 'c' && /* stream exists to picture? */
201			(sop->xr > 0) & (sop->yr > 0)) {
202			if (ofl & OF_BIN)
203			return(NULL); /* let caller offset bins */
204			sprintf(errmsg, "output '%s' not a valid picture", oname);
205			error(WARNING, errmsg);
206	greg	2.1	}
207			if (!noopen && sop->ofp == NULL) { /* open output stream */
208			if (oname[0] == '!') /* output to command */
209			sop->ofp = popen(oname+1, "w");
210			else /* else open file */
211			sop->ofp = fopen(oname, "w");
212			if (sop->ofp == NULL)
213			goto openerr;
214			if (outfmt != 'a')
215			SET_FILE_BINARY(sop->ofp);
216	greg	2.15	#ifdef getc_unlocked
217	greg	2.1	flockfile(sop->ofp); /* avoid lock/unlock overhead */
218			#endif
219	greg	2.11	if (accumulate > 0) { /* global resolution */
220			sop->xr = xres; sop->yr = yres;
221			}
222	greg	2.1	if (header) {
223	greg	2.11	cp = info;
224	greg	2.1	if (ofl & OF_MODIFIER \|\| sop->reclen == 1) {
225			sprintf(cp, "MODIFIER=%s\n", mname);
226			while (*cp) ++cp;
227			}
228			if (ofl & OF_BIN) {
229			sprintf(cp, "BIN=%d\n", bn);
230			while (*cp) ++cp;
231			}
232	greg	2.11	if (sop->yr > 0) {
233			sprintf(cp, "NROWS=%d\n", sop->yr *
234			(sop->xr + !sop->xr) );
235			while (*cp) ++cp;
236			}
237	greg	2.13	if ((sop->xr <= 0) \| (sop->reclen > 1))
238			sprintf(cp, "NCOLS=%d\n", sop->reclen);
239	greg	2.1	printheader(sop->ofp, info);
240			}
241	greg	2.13	if (sop->reclen == 1)
242			printresolu(sop->ofp, sop->xr, sop->yr);
243	greg	2.1	if (waitflush > 0)
244			fflush(sop->ofp);
245			}
246			sop->reclen += noopen; /* add to length if noopen */
247			return(sop); /* return output stream */
248			openerr:
249			sprintf(errmsg, "cannot open '%s' for writing", oname);
250			error(SYSTEM, errmsg);
251			return(NULL); /* pro forma return */
252			}
253
254
255			/* Get a vector from stdin */
256			int
257			getvec(FVECT vec)
258			{
259			float vf[3];
260			double vd[3];
261			char buf[32];
262			int i;
263
264			switch (inpfmt) {
265			case 'a': /* ascii */
266			for (i = 0; i < 3; i++) {
267			if (fgetword(buf, sizeof(buf), stdin) == NULL \|\|
268			!isflt(buf))
269			return(-1);
270			vec[i] = atof(buf);
271			}
272			break;
273			case 'f': /* binary float */
274	greg	2.18	if (getbinary((char *)vf, sizeof(float), 3, stdin) != 3)
275	greg	2.1	return(-1);
276			VCOPY(vec, vf);
277			break;
278			case 'd': /* binary double */
279	greg	2.18	if (getbinary((char *)vd, sizeof(double), 3, stdin) != 3)
280	greg	2.1	return(-1);
281			VCOPY(vec, vd);
282			break;
283			default:
284			error(CONSISTENCY, "botched input format");
285			}
286			return(0);
287			}
288
289
290			/* Put out ray contribution to file */
291			static void
292			put_contrib(const DCOLOR cnt, FILE *fout)
293			{
294			double sf = 1;
295	greg	2.2	COLOR fv;
296	greg	2.1	COLR cv;
297
298			if (accumulate > 1)
299			sf = 1./(double)accumulate;
300			switch (outfmt) {
301			case 'a':
302			if (accumulate > 1)
303			fprintf(fout, "%.6e\t%.6e\t%.6e\t",
304			sfcnt[0], sfcnt[1], sf*cnt[2]);
305			else
306			fprintf(fout, "%.6e\t%.6e\t%.6e\t",
307			cnt[0], cnt[1], cnt[2]);
308			break;
309			case 'f':
310			if (accumulate > 1) {
311	greg	2.2	copycolor(fv, cnt);
312			scalecolor(fv, sf);
313	greg	2.1	} else
314			copycolor(fv, cnt);
315	greg	2.18	putbinary(fv, sizeof(float), 3, fout);
316	greg	2.1	break;
317			case 'd':
318			if (accumulate > 1) {
319	greg	2.2	DCOLOR dv;
320			copycolor(dv, cnt);
321			scalecolor(dv, sf);
322	greg	2.18	putbinary(dv, sizeof(double), 3, fout);
323	greg	2.1	} else
324	greg	2.18	putbinary(cnt, sizeof(double), 3, fout);
325	greg	2.1	break;
326			case 'c':
327			if (accumulate > 1)
328			setcolr(cv, sfcnt[0], sfcnt[1], sf*cnt[2]);
329			else
330			setcolr(cv, cnt[0], cnt[1], cnt[2]);
331	greg	2.18	putbinary(cv, sizeof(cv), 1, fout);
332	greg	2.1	break;
333			default:
334			error(INTERNAL, "botched output format");
335			}
336			}
337
338
339			/* Output modifier values to appropriate stream(s) */
340			void
341			mod_output(MODCONT *mp)
342			{
343	greg	2.19	STREAMOUT *sop = getostream(mp->outspec, mp->modname, mp->bin0, 0);
344	greg	2.1	int j;
345
346			put_contrib(mp->cbin[0], sop->ofp);
347			if (mp->nbins > 3 && /* minor optimization */
348	greg	2.19	sop == getostream(mp->outspec, mp->modname, mp->bin0+1, 0)) {
349	greg	2.1	for (j = 1; j < mp->nbins; j++)
350			put_contrib(mp->cbin[j], sop->ofp);
351	greg	2.3	} else {
352	greg	2.1	for (j = 1; j < mp->nbins; j++) {
353	greg	2.19	sop = getostream(mp->outspec, mp->modname, mp->bin0+j, 0);
354	greg	2.1	put_contrib(mp->cbin[j], sop->ofp);
355			}
356	greg	2.3	}
357	greg	2.1	}
358
359
360			/* callback to output newline to ASCII file and/or flush as requested */
361			static int
362			puteol(const LUENT e, void p)
363			{
364			STREAMOUT sop = (STREAMOUT )e->data;
365
366			if (outfmt == 'a')
367			putc('\n', sop->ofp);
368			if (!waitflush)
369			fflush(sop->ofp);
370			if (ferror(sop->ofp)) {
371			sprintf(errmsg, "write error on file '%s'", e->key);
372			error(SYSTEM, errmsg);
373			}
374			return(0);
375			}
376
377
378			/* Terminate record output and flush if time */
379			void
380			end_record()
381			{
382			--waitflush;
383	greg	2.7	lu_doall(&ofiletab, &puteol, NULL);
384	greg	2.1	if (using_stdout & (outfmt == 'a'))
385			putc('\n', stdout);
386			if (!waitflush) {
387			waitflush = (yres > 0) & (xres > 1) ? 0 : xres;
388			if (using_stdout)
389			fflush(stdout);
390			}
391			}
392
393			/************************ PARTIAL RESULTS RECOVERY *********************/
394
395			/* Get ray contribution from previous file */
396			static int
397			get_contrib(DCOLOR cnt, FILE *finp)
398			{
399			COLOR fv;
400			COLR cv;
401
402			switch (outfmt) {
403			case 'a':
404			return(fscanf(finp,"%lf %lf %lf",&cnt[0],&cnt[1],&cnt[2]) == 3);
405			case 'f':
406	greg	2.18	if (getbinary(fv, sizeof(fv[0]), 3, finp) != 3)
407	greg	2.1	return(0);
408			copycolor(cnt, fv);
409			return(1);
410			case 'd':
411	greg	2.18	return(getbinary(cnt, sizeof(cnt[0]), 3, finp) == 3);
412	greg	2.1	case 'c':
413	greg	2.18	if (getbinary(cv, sizeof(cv), 1, finp) != 1)
414	greg	2.1	return(0);
415			colr_color(fv, cv);
416			copycolor(cnt, fv);
417			return(1);
418			default:
419			error(INTERNAL, "botched output format");
420			}
421			return(0); /* pro forma return */
422			}
423
424
425			/* Close output file opened for input */
426			static int
427			myclose(const LUENT e, void p)
428			{
429			STREAMOUT sop = (STREAMOUT )e->data;
430
431			if (sop->ofp == NULL)
432			return(0);
433			fclose(sop->ofp);
434			sop->ofp = NULL;
435			return(0);
436			}
437
438
439			/* Load previously accumulated values */
440			void
441			reload_output()
442			{
443			int i, j;
444			MODCONT *mp;
445			int ofl;
446			char oname[1024];
447			char *fmode = "rb";
448			char *outvfmt;
449			LUENT *oent;
450			int xr, yr;
451	greg	2.20	STREAMOUT *sop;
452	greg	2.1	DCOLOR rgbv;
453
454			if (outfmt == 'a')
455			fmode = "r";
456			outvfmt = formstr(outfmt);
457			/* reload modifier values */
458			for (i = 0; i < nmods; i++) {
459			mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
460			if (mp->outspec == NULL)
461			error(USER, "cannot reload from stdout");
462			if (mp->outspec[0] == '!')
463			error(USER, "cannot reload from command");
464	greg	2.20	for (j = 0; j < mp->nbins; j++) { /* load each modifier bin */
465			ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
466	greg	2.1	if (ofl < 0)
467			error(USER, "bad output file specification");
468			oent = lu_find(&ofiletab, oname);
469	greg	2.20	if (oent->data == NULL)
470			error(INTERNAL, "unallocated stream in reload_output()");
471			sop = (STREAMOUT *)oent->data;
472			if (sop->ofp == NULL) { /* open output as input */
473			sop->ofp = fopen(oname, fmode);
474			if (sop->ofp == NULL) {
475	greg	2.1	sprintf(errmsg, "missing reload file '%s'",
476			oname);
477			error(WARNING, errmsg);
478			break;
479			}
480	greg	2.15	#ifdef getc_unlocked
481	greg	2.20	flockfile(sop->ofp);
482	greg	2.1	#endif
483	greg	2.20	if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
484	greg	2.1	sprintf(errmsg, "format mismatch for '%s'",
485			oname);
486			error(USER, errmsg);
487			}
488	greg	2.20	if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
489			(!fscnresolu(&xr, &yr, sop->ofp) \|\|
490			(xr != sop->xr) \|
491			(yr != sop->yr))) {
492	greg	2.1	sprintf(errmsg, "resolution mismatch for '%s'",
493			oname);
494			error(USER, errmsg);
495			}
496			}
497			/* read in RGB value */
498	greg	2.20	if (!get_contrib(rgbv, sop->ofp)) {
499	greg	2.1	if (!j) {
500	greg	2.20	fclose(sop->ofp);
501	greg	2.1	break; /* ignore empty file */
502			}
503			if (j < mp->nbins) {
504			sprintf(errmsg, "missing data in '%s'",
505			oname);
506			error(USER, errmsg);
507			}
508			break;
509	greg	2.20	}
510	greg	2.1	copycolor(mp->cbin[j], rgbv);
511			}
512			}
513	greg	2.7	lu_doall(&ofiletab, &myclose, NULL); /* close all files */
514	greg	2.1	}
515
516
517			/* Seek on the given output file */
518			static int
519			myseeko(const LUENT e, void p)
520			{
521			STREAMOUT sop = (STREAMOUT )e->data;
522			off_t nbytes = (off_t )p;
523
524			if (sop->reclen > 1)
525	greg	2.22	nbytes *= (off_t)sop->reclen;
526	greg	2.1	if (fseeko(sop->ofp, nbytes, SEEK_CUR) < 0) {
527			sprintf(errmsg, "seek error on file '%s'", e->key);
528			error(SYSTEM, errmsg);
529			}
530			return(0);
531			}
532
533
534			/* Recover output if possible */
535			void
536			recover_output()
537			{
538			off_t lastout = -1;
539			int outvsiz, recsiz;
540			char *outvfmt;
541			int i, j;
542			MODCONT *mp;
543			int ofl;
544			char oname[1024];
545			LUENT *oent;
546	greg	2.20	STREAMOUT *sop;
547	greg	2.1	off_t nvals;
548			int xr, yr;
549
550			switch (outfmt) {
551			case 'a':
552			error(USER, "cannot recover ASCII output");
553			return;
554			case 'f':
555			outvsiz = sizeof(float)*3;
556			break;
557			case 'd':
558			outvsiz = sizeof(double)*3;
559			break;
560			case 'c':
561			outvsiz = sizeof(COLR);
562			break;
563			default:
564			error(INTERNAL, "botched output format");
565			return;
566			}
567			outvfmt = formstr(outfmt);
568			/* check modifier outputs */
569			for (i = 0; i < nmods; i++) {
570			mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
571			if (mp->outspec == NULL)
572			error(USER, "cannot recover from stdout");
573			if (mp->outspec[0] == '!')
574			error(USER, "cannot recover from command");
575	greg	2.20	for (j = 0; j < mp->nbins; j++) { /* check each bin's file */
576			ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
577	greg	2.1	if (ofl < 0)
578			error(USER, "bad output file specification");
579			oent = lu_find(&ofiletab, oname);
580	greg	2.20	if (oent->data == NULL)
581			error(INTERNAL, "unallocated stream in recover_output()");
582			sop = (STREAMOUT *)oent->data;
583			if (sop->ofp != NULL) { /* already open? */
584	greg	2.1	if (ofl & OF_BIN)
585			continue;
586			break;
587			}
588			/* open output */
589	greg	2.20	sop->ofp = fopen(oname, "rb+");
590			if (sop->ofp == NULL) {
591	greg	2.1	sprintf(errmsg, "missing recover file '%s'",
592			oname);
593			error(WARNING, errmsg);
594	greg	2.21	lastout = 0;
595	greg	2.1	break;
596			}
597	greg	2.20	nvals = lseek(fileno(sop->ofp), 0, SEEK_END);
598	greg	2.1	if (nvals <= 0) {
599			lastout = 0; /* empty output, quit here */
600	greg	2.20	fclose(sop->ofp);
601	greg	2.1	break;
602			}
603	greg	2.20	recsiz = outvsiz * sop->reclen;
604	greg	2.1
605	greg	2.20	lseek(fileno(sop->ofp), 0, SEEK_SET);
606			if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
607	greg	2.1	sprintf(errmsg, "format mismatch for '%s'",
608			oname);
609			error(USER, errmsg);
610			}
611	greg	2.20	if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
612			(!fscnresolu(&xr, &yr, sop->ofp) \|\|
613			(xr != sop->xr) \|
614			(yr != sop->yr))) {
615	greg	2.1	sprintf(errmsg, "resolution mismatch for '%s'",
616			oname);
617			error(USER, errmsg);
618			}
619	greg	2.20	nvals = (nvals - (off_t)ftell(sop->ofp)) / recsiz;
620	greg	2.1	if ((lastout < 0) \| (nvals < lastout))
621			lastout = nvals;
622			if (!(ofl & OF_BIN))
623			break; /* no bin separation */
624			}
625			if (!lastout) { /* empty output */
626			error(WARNING, "no previous data to recover");
627	greg	2.21	/* reclose all outputs */
628			lu_doall(&ofiletab, &myclose, NULL);
629	greg	2.1	return;
630			}
631			}
632			if (lastout < 0) {
633			error(WARNING, "no output files to recover");
634			return;
635			}
636			if (raysleft && lastout >= raysleft/accumulate) {
637			error(WARNING, "output appears to be complete");
638			/* XXX should read & discard input? */
639			quit(0);
640			}
641			/* seek on all files */
642			nvals = lastout * outvsiz;
643	greg	2.7	lu_doall(&ofiletab, &myseeko, &nvals);
644	greg	2.1	/* skip repeated input */
645	greg	2.5	lastout *= accumulate;
646	greg	2.1	for (nvals = 0; nvals < lastout; nvals++) {
647			FVECT vdummy;
648			if (getvec(vdummy) < 0 \|\| getvec(vdummy) < 0)
649			error(USER, "unexpected EOF on input");
650			}
651	greg	2.5	lastray = lastdone = (RNUMBER)lastout;
652	greg	2.1	if (raysleft)
653			raysleft -= lastray;
654			}