src/common/tmapcolrs.c

#ifndef lint
static const char       RCSid[] = "$Id: tmapcolrs.c,v 3.15 2004/01/02 11:36:26 schorsch Exp $";
#endif
/*
 * Routines for tone mapping on Radiance RGBE and XYZE pictures.
 *
 * Externals declared in tonemap.h
 */

#include "copyright.h"

#include        <stdio.h>
#include        <string.h>
#include        <math.h>
#include        <time.h>

#include        "tmprivat.h"
#include        "resolu.h"
#include        "rtprocess.h"

#ifndef TM_PIC_CTRANS
#define TM_PIC_CTRANS   1               /* transform colors? (expensive) */
#endif

#define GAMTSZ  1024

typedef struct {
        BYTE            gamb[GAMTSZ];   /* gamma lookup table */
        COLR            clfb;           /* encoded tm->clf */
        TMbright        inpsfb;         /* encoded tm->inpsf */
} COLRDATA;

static MEM_PTR  colrInit(struct tmStruct *);
static void     colrNewSpace(struct tmStruct *);
static gethfunc headline;

static struct tmPackage colrPkg = {     /* our package functions */
        colrInit, colrNewSpace, free
};
static int      colrReg = -1;           /* our package registration number */

#define LOGISZ  260
static TMbright logi[LOGISZ];


int
tmCvColrs(ls, cs, scan, len)            /* convert RGBE/XYZE colors */
TMbright        *ls;
BYTE    *cs;
COLR    *scan;
int     len;
{
        static char     funcName[] = "tmCvColrs";
        COLR    cmon;
        register COLRDATA       *cd;
        register int    i, bi, li;

        if (tmTop == NULL)
                returnErr(TM_E_TMINVAL);
        if ((ls == NULL) | (scan == NULL) | (len < 0))
                returnErr(TM_E_ILLEGAL);
#if TM_PIC_CTRANS
        if (tmNeedMatrix(tmTop)) {              /* need floating point */
#else
        if (tmTop->inppri == TM_XYZPRIM) {      /* no way around this */
#endif
                register COLOR  *newscan;
                newscan = (COLOR *)tempbuffer(len*sizeof(COLOR));
                if (newscan == NULL)
                        returnErr(TM_E_NOMEM);
                for (i = len; i--; )
                        colr_color(newscan[i], scan[i]);
                return(tmCvColors(ls, cs, newscan, len));
        }
        if (colrReg < 0) {                      /* build tables if necessary */
                colrReg = tmRegPkg(&colrPkg);
                if (colrReg < 0)
                        returnErr(TM_E_CODERR1);
                for (i = 256; i--; )
                        logi[i] = TM_BRTSCALE*log((i+.5)/256.) - .5;
                for (i = 256; i < LOGISZ; i++)
                        logi[i] = 0;
                tmMkMesofact();
        }
        if ((cd = (COLRDATA *)tmPkgData(tmTop,colrReg)) == NULL)
                returnErr(TM_E_NOMEM);
        for (i = len; i--; ) {
                copycolr(cmon, scan[i]);
                                                        /* world luminance */
                li =  ( cd->clfb[RED]*cmon[RED] +
                        cd->clfb[GRN]*cmon[GRN] +
                        cd->clfb[BLU]*cmon[BLU] ) >> 8;
                bi = BRT2SCALE(cmon[EXP]-COLXS) +
                                logi[li] + cd->inpsfb;
                if (li <= 0) {
                        bi = TM_NOBRT;                  /* bogus value */
                        li = 1;                         /* avoid li==0 */
                }
                ls[i] = bi;
                if (cs == TM_NOCHROM)                   /* no color? */
                        continue;
                                                        /* mesopic adj. */
                if (tmTop->flags & TM_F_MESOPIC && bi < BMESUPPER) {
                        register int    pf, sli = normscot(cmon);
                        if (bi < BMESLOWER)
                                cmon[RED] = cmon[GRN] = cmon[BLU] = sli;
                        else {
                                if (tmTop->flags & TM_F_BW)
                                        cmon[RED] = cmon[GRN] = cmon[BLU] = li;
                                pf = tmMesofact[bi-BMESLOWER];
                                sli *= 256 - pf;
                                cmon[RED] = ( sli + pf*cmon[RED] ) >> 8;
                                cmon[GRN] = ( sli + pf*cmon[GRN] ) >> 8;
                                cmon[BLU] = ( sli + pf*cmon[BLU] ) >> 8;
                        }
                } else if (tmTop->flags & TM_F_BW) {
                        cmon[RED] = cmon[GRN] = cmon[BLU] = li;
                }
                bi = ( (int32)GAMTSZ*cd->clfb[RED]*cmon[RED]/li ) >> 8;
                cs[3*i  ] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
                bi = ( (int32)GAMTSZ*cd->clfb[GRN]*cmon[GRN]/li ) >> 8;
                cs[3*i+1] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
                bi = ( (int32)GAMTSZ*cd->clfb[BLU]*cmon[BLU]/li ) >> 8;
                cs[3*i+2] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
        }
        returnOK;
}


#define FMTRGB          1       /* Input is RGBE */
#define FMTCIE          2       /* Input is CIE XYZE */
#define FMTUNK          3       /* Input format is unspecified */
#define FMTBAD          4       /* Input is not a recognized format */

static struct radhead {
        int     format;         /* FMTRGB, FMTCIE, FMTUNK, FMTBAD */
        double  expos;          /* input exposure value */
        RGBPRIMP        primp;  /* input primaries */
        RGBPRIMS        mypri;  /* custom primaries */
} rhdefault = {FMTUNK, 1., stdprims, STDPRIMS};


static int
headline(                       /* grok a header line */
        register char   *s,
        void    *vrh
)
{
        char    fmt[32];
        register struct radhead *rh = vrh;

        if (formatval(fmt, s)) {
                if (!strcmp(fmt, COLRFMT))
                        rh->format = FMTRGB;
                else if (!strcmp(fmt, CIEFMT))
                        rh->format = FMTCIE;
                else
                        rh->format = FMTBAD;
                return(0);
        }
        if (isexpos(s)) {
                rh->expos *= exposval(s);
                return(0);
        }
        if (isprims(s)) {
                primsval(rh->mypri, s);
                rh->primp = rh->mypri;
                return(0);
        }
        return(0);
}


int
tmLoadPicture(lpp, cpp, xp, yp, fname, fp)      /* convert Radiance picture */
TMbright        **lpp;
BYTE    **cpp;
int     *xp, *yp;
char    *fname;
FILE    *fp;
{
        char    *funcName = fname==NULL ? "tmLoadPicture" : fname;
        FILE    *inpf;
        struct radhead  info;
        int     err;
        COLR    *scanin = NULL;
        int     i;
                                                /* check arguments */
        if (tmTop == NULL)
                returnErr(TM_E_TMINVAL);
        if ((lpp == NULL) | (xp == NULL) | (yp == NULL) |
                        ((fname == NULL) & (fp == TM_GETFILE)))
                returnErr(TM_E_ILLEGAL);
        *xp = *yp = 0;                          /* error precaution */
        if ((inpf = fp) == TM_GETFILE && (inpf = fopen(fname, "r")) == NULL)
                returnErr(TM_E_BADFILE);
        *lpp = NULL;
        if (cpp != TM_NOCHROMP) *cpp = NULL;
        info = rhdefault;                       /* get our header */
        getheader(inpf, headline, &info);
        if ((info.format == FMTBAD) | (info.expos <= 0.) ||
                        fgetresolu(xp, yp, inpf) < 0) {
                err = TM_E_BADFILE; goto done;
        }
        if (info.format == FMTUNK)              /* assume RGBE format */
                info.format = FMTRGB;
        if (info.format == FMTRGB)
                info.expos /= WHTEFFICACY;
        else if (info.format == FMTCIE)
                info.primp = TM_XYZPRIM;
                                                /* prepare library */
        if ((err = tmSetSpace(info.primp, 1./info.expos)) != TM_E_OK)
                goto done;
        err = TM_E_NOMEM;                       /* allocate arrays */
        *lpp = (TMbright *)malloc(sizeof(TMbright) * *xp * *yp);
        if (*lpp == NULL)
                goto done;
        if (cpp != TM_NOCHROMP) {
                *cpp = (BYTE *)malloc(3*sizeof(BYTE) * *xp * *yp);
                if (*cpp == NULL)
                        goto done;
        }
        scanin = (COLR *)malloc(sizeof(COLR) * *xp);
        if (scanin == NULL)
                goto done;
        err = TM_E_BADFILE;                     /* read & convert scanlines */
        for (i = 0; i < *yp; i++) {
                if (freadcolrs(scanin, *xp, inpf) < 0) {
                        err = TM_E_BADFILE; break;
                }
                err = tmCvColrs(*lpp + (i * *xp),
                        cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp + (i * 3 * *xp),
                                scanin, *xp);
                if (err != TM_E_OK)
                        break;
        }
done:                                           /* clean up */
        if (fp == NULL)
                fclose(inpf);
        if (scanin != NULL)
                free((MEM_PTR)scanin);
        if (err != TM_E_OK) {
                if (*lpp != NULL)
                        free((MEM_PTR)*lpp);
                if (cpp != TM_NOCHROMP && *cpp != NULL)
                        free((MEM_PTR)*cpp);
                returnErr(err);
        }
        returnOK;
}


#ifdef PCOND
static int                                      /* run pcond to map picture */
dopcond(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname)
BYTE    **psp;
int     *xp, *yp;
int     flags;
RGBPRIMP        monpri;
double  gamval, Lddyn, Ldmax;
char    *fname;
{
        char    *funcName = fname;
        char    cmdbuf[1024];
        FILE    *infp;
        register COLR   *scan;
        register BYTE   *rp;
        int     y;
        register int    x;
                                        /* set up gamma correction */
        if (setcolrcor(pow, 1./gamval) < 0)
                returnErr(TM_E_NOMEM);
                                        /* create command */
        strcpy(cmdbuf, PCOND);
        if (flags & TM_F_HCONTR)
                strcat(cmdbuf, " -s");
        if (flags & TM_F_MESOPIC)
                strcat(cmdbuf, " -c");
        if (flags & TM_F_LINEAR)
                strcat(cmdbuf, " -l");
        if (flags & TM_F_ACUITY)
                strcat(cmdbuf, " -a");
        if (flags & TM_F_VEIL)
                strcat(cmdbuf, " -v");
        if (flags & TM_F_CWEIGHT)
                strcat(cmdbuf, " -w");
        if (monpri != stdprims)
                sprintf(cmdbuf+strlen(cmdbuf), " -p %f %f %f %f %f %f %f %f",
                                monpri[RED][CIEX], monpri[RED][CIEY],
                                monpri[GRN][CIEX], monpri[GRN][CIEY],
                                monpri[BLU][CIEX], monpri[BLU][CIEY],
                                monpri[WHT][CIEX], monpri[WHT][CIEY]);
        sprintf(cmdbuf+strlen(cmdbuf), " -d %f -u %f %s", Lddyn, Ldmax, fname);
                                        /* start pcond */
        if ((infp = popen(cmdbuf, "r")) == NULL)
                returnErr(TM_E_BADFILE);
                                        /* check picture format and size */
        if (checkheader(infp, COLRFMT, NULL) < 0 ||
                        fgetresolu(xp, yp, infp) < 0) {
                pclose(infp);
                returnErr(TM_E_BADFILE);
        }
                                        /* allocate arrays */
        scan = (COLR *)malloc(sizeof(COLR) * *xp);
        if (flags & TM_F_BW)
                rp = (BYTE *)malloc(sizeof(BYTE) * *xp * *yp);
        else
                rp = (BYTE *)malloc(3*sizeof(BYTE) * *xp * *yp);
        if (((*psp = rp) == NULL) | (scan == NULL)) {
                pclose(infp);
                returnErr(TM_E_NOMEM);
        }
                                        /* read and gamma map file */
        for (y = 0; y < *yp; y++) {
                if (freadcolrs(scan, *xp, infp) < 0) {
                        pclose(infp);
                        free((MEM_PTR)scan);
                        free((MEM_PTR)*psp);
                        *psp = NULL;
                        returnErr(TM_E_BADFILE);
                }
                colrs_gambs(scan, *xp);
                if (flags & TM_F_BW)
                        for (x = 0; x < *xp; x++)
                                *rp++ = normbright(scan[x]);
                else
                        for (x = 0; x < *xp; x++) {
                                *rp++ = scan[x][RED];
                                *rp++ = scan[x][GRN];
                                *rp++ = scan[x][BLU];
                        }
        }
        free((MEM_PTR)scan);
        pclose(infp);
        returnOK;
}
#endif


int                                     /* map a Radiance picture */
tmMapPicture(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname, fp)
BYTE    **psp;
int     *xp, *yp;
int     flags;
RGBPRIMP        monpri;
double  gamval, Lddyn, Ldmax;
char    *fname;
FILE    *fp;
{
        char    *funcName = fname==NULL ? "tmMapPicture" : fname;
        BYTE    *cp;
        TMbright        *lp;
        int     err;
                                                /* check arguments */
        if ((psp == NULL) | (xp == NULL) | (yp == NULL) | (monpri == NULL) |
                        ((fname == NULL) & (fp == TM_GETFILE)))
                returnErr(TM_E_ILLEGAL);
                                                /* set defaults */
        if (gamval < MINGAM) gamval = DEFGAM;
        if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
        if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
        if (flags & TM_F_BW) monpri = stdprims;
#ifdef PCOND
                                                /* check for pcond run */
        if (fp == TM_GETFILE && flags & TM_F_UNIMPL)
                return( dopcond(psp, xp, yp, flags,
                                monpri, gamval, Lddyn, Ldmax, fname) );
#endif
                                                /* initialize tone mapping */
        if (tmInit(flags, monpri, gamval) == NULL)
                returnErr(TM_E_NOMEM);
                                                /* load & convert picture */
        err = tmLoadPicture(&lp, (flags&TM_F_BW) ? TM_NOCHROMP : &cp,
                        xp, yp, fname, fp);
        if (err != TM_E_OK) {
                tmDone(NULL);
                return(err);
        }
                                                /* allocate space for result */
        if (flags & TM_F_BW) {
                *psp = (BYTE *)malloc(sizeof(BYTE) * *xp * *yp);
                if (*psp == NULL) {
                        free((MEM_PTR)lp);
                        tmDone(NULL);
                        returnErr(TM_E_NOMEM);
                }
                cp = TM_NOCHROM;
        } else
                *psp = cp;
                                                /* compute color mapping */
        err = tmAddHisto(lp, *xp * *yp, 1);
        if (err != TM_E_OK)
                goto done;
        err = tmComputeMapping(gamval, Lddyn, Ldmax);
        if (err != TM_E_OK)
                goto done;
                                                /* map colors */
        err = tmMapPixels(*psp, lp, cp, *xp * *yp);

done:                                           /* clean up */
        free((MEM_PTR)lp);
        tmDone(NULL);
        if (err != TM_E_OK) {                   /* free memory on error */
                free((MEM_PTR)*psp);
                *psp = NULL;
                returnErr(err);
        }
        returnOK;
}


static void
colrNewSpace(tms)               /* color space changed for tone mapping */
register struct tmStruct        *tms;
{
        register COLRDATA       *cd;
        double  d;

        cd = (COLRDATA *)tms->pd[colrReg];
        cd->clfb[RED] = 256.*tms->clf[RED] + .5;
        cd->clfb[GRN] = 256.*tms->clf[GRN] + .5;
        cd->clfb[BLU] = 256.*tms->clf[BLU] + .5;
        cd->clfb[EXP] = COLXS;
        d = TM_BRTSCALE*log(tms->inpsf);
        cd->inpsfb = d<0. ? d-.5 : d+.5;
}


static MEM_PTR
colrInit(tms)                   /* initialize private data for tone mapping */
register struct tmStruct        *tms;
{
        register COLRDATA       *cd;
        register int    i;
                                        /* allocate our data */
        cd = (COLRDATA *)malloc(sizeof(COLRDATA));
        if (cd == NULL)
                return(NULL);
        tms->pd[colrReg] = (MEM_PTR)cd;
                                        /* compute gamma table */
        for (i = GAMTSZ; i--; )
                cd->gamb[i] = 256.*pow((i+.5)/GAMTSZ, 1./tms->mongam);
                                        /* compute color and scale factors */
        colrNewSpace(tms);
        return((MEM_PTR)cd);
}
Revision:	3.16
Committed:	Sat Oct 23 18:55:52 2004 UTC (19 years, 6 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R6P1
Changes since 3.15:	+3 -1 lines
Log Message:	Compatibility fixes as suggested by Siegbert Debatin.
#	User	Rev	Content
1	greg	3.1	#ifndef lint
2	schorsch	3.16	static const char RCSid[] = "$Id: tmapcolrs.c,v 3.15 2004/01/02 11:36:26 schorsch Exp $";
3	greg	3.1	#endif
4			/*
5			* Routines for tone mapping on Radiance RGBE and XYZE pictures.
6	greg	3.10	*
7			* Externals declared in tonemap.h
8			*/
9
10	greg	3.11	#include "copyright.h"
11	greg	3.1
12			#include <stdio.h>
13	greg	3.10	#include <string.h>
14	greg	3.1	#include <math.h>
15	greg	3.10	#include <time.h>
16	schorsch	3.16
17	greg	3.1	#include "tmprivat.h"
18			#include "resolu.h"
19	schorsch	3.16	#include "rtprocess.h"
20	greg	3.1
21	greg	3.10	#ifndef TM_PIC_CTRANS
22			#define TM_PIC_CTRANS 1 /* transform colors? (expensive) */
23			#endif
24	greg	3.1
25	greg	3.3	#define GAMTSZ 1024
26
27			typedef struct {
28			BYTE gamb[GAMTSZ]; /* gamma lookup table */
29			COLR clfb; /* encoded tm->clf */
30			TMbright inpsfb; /* encoded tm->inpsf */
31			} COLRDATA;
32
33	greg	3.10	static MEM_PTR colrInit(struct tmStruct *);
34			static void colrNewSpace(struct tmStruct *);
35	schorsch	3.15	static gethfunc headline;
36
37	greg	3.3	static struct tmPackage colrPkg = { /* our package functions */
38			colrInit, colrNewSpace, free
39			};
40			static int colrReg = -1; /* our package registration number */
41
42	greg	3.1	#define LOGISZ 260
43			static TMbright logi[LOGISZ];
44
45
46			int
47	gwlarson	3.6	tmCvColrs(ls, cs, scan, len) /* convert RGBE/XYZE colors */
48	greg	3.1	TMbright *ls;
49			BYTE *cs;
50			COLR *scan;
51			int len;
52			{
53			static char funcName[] = "tmCvColrs";
54			COLR cmon;
55	greg	3.3	register COLRDATA *cd;
56	greg	3.1	register int i, bi, li;
57
58			if (tmTop == NULL)
59			returnErr(TM_E_TMINVAL);
60	schorsch	3.14	if ((ls == NULL) \| (scan == NULL) \| (len < 0))
61	greg	3.1	returnErr(TM_E_ILLEGAL);
62	greg	3.10	#if TM_PIC_CTRANS
63	greg	3.3	if (tmNeedMatrix(tmTop)) { /* need floating point */
64	greg	3.10	#else
65			if (tmTop->inppri == TM_XYZPRIM) { /* no way around this */
66			#endif
67	greg	3.1	register COLOR *newscan;
68			newscan = (COLOR )tempbuffer(lensizeof(COLOR));
69			if (newscan == NULL)
70			returnErr(TM_E_NOMEM);
71			for (i = len; i--; )
72			colr_color(newscan[i], scan[i]);
73			return(tmCvColors(ls, cs, newscan, len));
74			}
75	gwlarson	3.6	if (colrReg < 0) { /* build tables if necessary */
76	greg	3.3	colrReg = tmRegPkg(&colrPkg);
77			if (colrReg < 0)
78			returnErr(TM_E_CODERR1);
79	greg	3.1	for (i = 256; i--; )
80			logi[i] = TM_BRTSCALE*log((i+.5)/256.) - .5;
81			for (i = 256; i < LOGISZ; i++)
82	greg	3.10	logi[i] = 0;
83			tmMkMesofact();
84	greg	3.1	}
85	greg	3.3	if ((cd = (COLRDATA *)tmPkgData(tmTop,colrReg)) == NULL)
86			returnErr(TM_E_NOMEM);
87	greg	3.1	for (i = len; i--; ) {
88			copycolr(cmon, scan[i]);
89			/* world luminance */
90	greg	3.3	li = ( cd->clfb[RED]*cmon[RED] +
91			cd->clfb[GRN]*cmon[GRN] +
92			cd->clfb[BLU]*cmon[BLU] ) >> 8;
93	greg	3.10	bi = BRT2SCALE(cmon[EXP]-COLXS) +
94	greg	3.3	logi[li] + cd->inpsfb;
95	greg	3.10	if (li <= 0) {
96			bi = TM_NOBRT; /* bogus value */
97			li = 1; /* avoid li==0 */
98	greg	3.1	}
99			ls[i] = bi;
100			if (cs == TM_NOCHROM) /* no color? */
101			continue;
102			/* mesopic adj. */
103			if (tmTop->flags & TM_F_MESOPIC && bi < BMESUPPER) {
104			register int pf, sli = normscot(cmon);
105			if (bi < BMESLOWER)
106			cmon[RED] = cmon[GRN] = cmon[BLU] = sli;
107			else {
108	gwlarson	3.8	if (tmTop->flags & TM_F_BW)
109			cmon[RED] = cmon[GRN] = cmon[BLU] = li;
110	greg	3.10	pf = tmMesofact[bi-BMESLOWER];
111	greg	3.1	sli *= 256 - pf;
112			cmon[RED] = ( sli + pf*cmon[RED] ) >> 8;
113			cmon[GRN] = ( sli + pf*cmon[GRN] ) >> 8;
114			cmon[BLU] = ( sli + pf*cmon[BLU] ) >> 8;
115			}
116	gwlarson	3.8	} else if (tmTop->flags & TM_F_BW) {
117			cmon[RED] = cmon[GRN] = cmon[BLU] = li;
118	greg	3.1	}
119	greg	3.12	bi = ( (int32)GAMTSZcd->clfb[RED]cmon[RED]/li ) >> 8;
120	greg	3.3	cs[3*i ] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
121	greg	3.12	bi = ( (int32)GAMTSZcd->clfb[GRN]cmon[GRN]/li ) >> 8;
122	greg	3.3	cs[3*i+1] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
123	greg	3.12	bi = ( (int32)GAMTSZcd->clfb[BLU]cmon[BLU]/li ) >> 8;
124	greg	3.3	cs[3*i+2] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
125	greg	3.1	}
126			returnOK;
127			}
128
129
130			#define FMTRGB 1 /* Input is RGBE */
131			#define FMTCIE 2 /* Input is CIE XYZE */
132			#define FMTUNK 3 /* Input format is unspecified */
133			#define FMTBAD 4 /* Input is not a recognized format */
134
135			static struct radhead {
136			int format; /* FMTRGB, FMTCIE, FMTUNK, FMTBAD */
137			double expos; /* input exposure value */
138			RGBPRIMP primp; /* input primaries */
139			RGBPRIMS mypri; /* custom primaries */
140			} rhdefault = {FMTUNK, 1., stdprims, STDPRIMS};
141
142
143			static int
144	schorsch	3.15	headline( /* grok a header line */
145			register char *s,
146			void *vrh
147			)
148	greg	3.1	{
149			char fmt[32];
150	schorsch	3.15	register struct radhead *rh = vrh;
151	greg	3.1
152			if (formatval(fmt, s)) {
153			if (!strcmp(fmt, COLRFMT))
154			rh->format = FMTRGB;
155			else if (!strcmp(fmt, CIEFMT))
156			rh->format = FMTCIE;
157			else
158			rh->format = FMTBAD;
159	gwlarson	3.7	return(0);
160	greg	3.1	}
161			if (isexpos(s)) {
162			rh->expos *= exposval(s);
163	gwlarson	3.7	return(0);
164	greg	3.1	}
165			if (isprims(s)) {
166			primsval(rh->mypri, s);
167			rh->primp = rh->mypri;
168	gwlarson	3.7	return(0);
169	greg	3.1	}
170	gwlarson	3.7	return(0);
171	greg	3.1	}
172
173
174			int
175			tmLoadPicture(lpp, cpp, xp, yp, fname, fp) /* convert Radiance picture */
176			TMbright **lpp;
177			BYTE **cpp;
178			int xp, yp;
179			char *fname;
180			FILE *fp;
181			{
182			char *funcName = fname==NULL ? "tmLoadPicture" : fname;
183			FILE *inpf;
184			struct radhead info;
185			int err;
186			COLR *scanin = NULL;
187			int i;
188			/* check arguments */
189			if (tmTop == NULL)
190			returnErr(TM_E_TMINVAL);
191	schorsch	3.14	if ((lpp == NULL) \| (xp == NULL) \| (yp == NULL) \|
192			((fname == NULL) & (fp == TM_GETFILE)))
193	greg	3.1	returnErr(TM_E_ILLEGAL);
194			xp = yp = 0; /* error precaution */
195			if ((inpf = fp) == TM_GETFILE && (inpf = fopen(fname, "r")) == NULL)
196			returnErr(TM_E_BADFILE);
197	gwlarson	3.6	*lpp = NULL;
198			if (cpp != TM_NOCHROMP) *cpp = NULL;
199	greg	3.1	info = rhdefault; /* get our header */
200	schorsch	3.15	getheader(inpf, headline, &info);
201	schorsch	3.14	if ((info.format == FMTBAD) \| (info.expos <= 0.) \|\|
202	greg	3.1	fgetresolu(xp, yp, inpf) < 0) {
203			err = TM_E_BADFILE; goto done;
204			}
205			if (info.format == FMTUNK) /* assume RGBE format */
206			info.format = FMTRGB;
207			if (info.format == FMTRGB)
208			info.expos /= WHTEFFICACY;
209			else if (info.format == FMTCIE)
210			info.primp = TM_XYZPRIM;
211			/* prepare library */
212			if ((err = tmSetSpace(info.primp, 1./info.expos)) != TM_E_OK)
213			goto done;
214			err = TM_E_NOMEM; /* allocate arrays */
215			lpp = (TMbright )malloc(sizeof(TMbright) * xp *yp);
216			if (*lpp == NULL)
217			goto done;
218			if (cpp != TM_NOCHROMP) {
219			cpp = (BYTE )malloc(3sizeof(BYTE) xp *yp);
220			if (*cpp == NULL)
221			goto done;
222			}
223			scanin = (COLR )malloc(sizeof(COLR) *xp);
224			if (scanin == NULL)
225			goto done;
226			err = TM_E_BADFILE; /* read & convert scanlines */
227			for (i = 0; i < *yp; i++) {
228			if (freadcolrs(scanin, *xp, inpf) < 0) {
229			err = TM_E_BADFILE; break;
230			}
231			err = tmCvColrs(lpp + (i *xp),
232			cpp==TM_NOCHROMP ? TM_NOCHROM : cpp + (i 3 * *xp),
233			scanin, *xp);
234			if (err != TM_E_OK)
235			break;
236			}
237			done: /* clean up */
238			if (fp == NULL)
239			fclose(inpf);
240			if (scanin != NULL)
241	gwlarson	3.6	free((MEM_PTR)scanin);
242			if (err != TM_E_OK) {
243			if (*lpp != NULL)
244			free((MEM_PTR)*lpp);
245			if (cpp != TM_NOCHROMP && *cpp != NULL)
246			free((MEM_PTR)*cpp);
247	greg	3.1	returnErr(err);
248	gwlarson	3.6	}
249	greg	3.1	returnOK;
250			}
251
252
253	gwlarson	3.9	#ifdef PCOND
254	schorsch	3.13	static int /* run pcond to map picture */
255	greg	3.1	dopcond(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname)
256			BYTE **psp;
257			int xp, yp;
258			int flags;
259			RGBPRIMP monpri;
260			double gamval, Lddyn, Ldmax;
261			char *fname;
262			{
263			char *funcName = fname;
264	greg	3.10	char cmdbuf[1024];
265	greg	3.1	FILE *infp;
266			register COLR *scan;
267			register BYTE *rp;
268			int y;
269			register int x;
270			/* set up gamma correction */
271			if (setcolrcor(pow, 1./gamval) < 0)
272			returnErr(TM_E_NOMEM);
273			/* create command */
274	gwlarson	3.9	strcpy(cmdbuf, PCOND);
275	greg	3.1	if (flags & TM_F_HCONTR)
276	gwlarson	3.9	strcat(cmdbuf, " -s");
277	greg	3.1	if (flags & TM_F_MESOPIC)
278	gwlarson	3.9	strcat(cmdbuf, " -c");
279	greg	3.1	if (flags & TM_F_LINEAR)
280	gwlarson	3.9	strcat(cmdbuf, " -l");
281	greg	3.1	if (flags & TM_F_ACUITY)
282	gwlarson	3.9	strcat(cmdbuf, " -a");
283	greg	3.1	if (flags & TM_F_VEIL)
284	gwlarson	3.9	strcat(cmdbuf, " -v");
285	greg	3.1	if (flags & TM_F_CWEIGHT)
286	gwlarson	3.9	strcat(cmdbuf, " -w");
287			if (monpri != stdprims)
288			sprintf(cmdbuf+strlen(cmdbuf), " -p %f %f %f %f %f %f %f %f",
289			monpri[RED][CIEX], monpri[RED][CIEY],
290			monpri[GRN][CIEX], monpri[GRN][CIEY],
291			monpri[BLU][CIEX], monpri[BLU][CIEY],
292			monpri[WHT][CIEX], monpri[WHT][CIEY]);
293			sprintf(cmdbuf+strlen(cmdbuf), " -d %f -u %f %s", Lddyn, Ldmax, fname);
294	greg	3.1	/* start pcond */
295			if ((infp = popen(cmdbuf, "r")) == NULL)
296			returnErr(TM_E_BADFILE);
297			/* check picture format and size */
298			if (checkheader(infp, COLRFMT, NULL) < 0 \|\|
299			fgetresolu(xp, yp, infp) < 0) {
300			pclose(infp);
301			returnErr(TM_E_BADFILE);
302			}
303			/* allocate arrays */
304	greg	3.2	scan = (COLR )malloc(sizeof(COLR) *xp);
305	greg	3.1	if (flags & TM_F_BW)
306			rp = (BYTE )malloc(sizeof(BYTE) xp *yp);
307			else
308			rp = (BYTE )malloc(3sizeof(BYTE) * xp *yp);
309	schorsch	3.14	if (((*psp = rp) == NULL) \| (scan == NULL)) {
310	greg	3.1	pclose(infp);
311			returnErr(TM_E_NOMEM);
312			}
313			/* read and gamma map file */
314			for (y = 0; y < *yp; y++) {
315			if (freadcolrs(scan, *xp, infp) < 0) {
316			pclose(infp);
317	gwlarson	3.6	free((MEM_PTR)scan);
318			free((MEM_PTR)*psp);
319	greg	3.2	*psp = NULL;
320	greg	3.1	returnErr(TM_E_BADFILE);
321			}
322			colrs_gambs(scan, *xp);
323			if (flags & TM_F_BW)
324			for (x = 0; x < *xp; x++)
325			*rp++ = normbright(scan[x]);
326			else
327			for (x = 0; x < *xp; x++) {
328			*rp++ = scan[x][RED];
329			*rp++ = scan[x][GRN];
330			*rp++ = scan[x][BLU];
331			}
332			}
333	gwlarson	3.6	free((MEM_PTR)scan);
334	greg	3.1	pclose(infp);
335			returnOK;
336			}
337	gwlarson	3.9	#endif
338	greg	3.1
339
340			int /* map a Radiance picture */
341			tmMapPicture(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname, fp)
342			BYTE **psp;
343			int xp, yp;
344			int flags;
345			RGBPRIMP monpri;
346			double gamval, Lddyn, Ldmax;
347			char *fname;
348			FILE *fp;
349			{
350			char *funcName = fname==NULL ? "tmMapPicture" : fname;
351			BYTE *cp;
352			TMbright *lp;
353			int err;
354			/* check arguments */
355	schorsch	3.14	if ((psp == NULL) \| (xp == NULL) \| (yp == NULL) \| (monpri == NULL) \|
356			((fname == NULL) & (fp == TM_GETFILE)))
357	greg	3.1	returnErr(TM_E_ILLEGAL);
358			/* set defaults */
359			if (gamval < MINGAM) gamval = DEFGAM;
360			if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
361			if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
362			if (flags & TM_F_BW) monpri = stdprims;
363	gwlarson	3.9	#ifdef PCOND
364	greg	3.1	/* check for pcond run */
365			if (fp == TM_GETFILE && flags & TM_F_UNIMPL)
366			return( dopcond(psp, xp, yp, flags,
367			monpri, gamval, Lddyn, Ldmax, fname) );
368	gwlarson	3.9	#endif
369	greg	3.1	/* initialize tone mapping */
370			if (tmInit(flags, monpri, gamval) == NULL)
371			returnErr(TM_E_NOMEM);
372			/* load & convert picture */
373			err = tmLoadPicture(&lp, (flags&TM_F_BW) ? TM_NOCHROMP : &cp,
374			xp, yp, fname, fp);
375			if (err != TM_E_OK) {
376			tmDone(NULL);
377			return(err);
378			}
379			/* allocate space for result */
380			if (flags & TM_F_BW) {
381			psp = (BYTE )malloc(sizeof(BYTE) * xp *yp);
382	greg	3.2	if (*psp == NULL) {
383	gwlarson	3.6	free((MEM_PTR)lp);
384	greg	3.2	tmDone(NULL);
385	greg	3.1	returnErr(TM_E_NOMEM);
386	greg	3.2	}
387	greg	3.1	cp = TM_NOCHROM;
388			} else
389			*psp = cp;
390			/* compute color mapping */
391			err = tmAddHisto(lp, xp *yp, 1);
392			if (err != TM_E_OK)
393			goto done;
394			err = tmComputeMapping(gamval, Lddyn, Ldmax);
395			if (err != TM_E_OK)
396			goto done;
397			/* map colors */
398			err = tmMapPixels(psp, lp, cp, xp * *yp);
399
400			done: /* clean up */
401	gwlarson	3.6	free((MEM_PTR)lp);
402	greg	3.1	tmDone(NULL);
403			if (err != TM_E_OK) { /* free memory on error */
404	gwlarson	3.6	free((MEM_PTR)*psp);
405	greg	3.1	*psp = NULL;
406			returnErr(err);
407			}
408			returnOK;
409	greg	3.3	}
410
411
412			static void
413			colrNewSpace(tms) /* color space changed for tone mapping */
414			register struct tmStruct *tms;
415			{
416			register COLRDATA *cd;
417			double d;
418
419			cd = (COLRDATA *)tms->pd[colrReg];
420			cd->clfb[RED] = 256.*tms->clf[RED] + .5;
421			cd->clfb[GRN] = 256.*tms->clf[GRN] + .5;
422			cd->clfb[BLU] = 256.*tms->clf[BLU] + .5;
423			cd->clfb[EXP] = COLXS;
424			d = TM_BRTSCALE*log(tms->inpsf);
425			cd->inpsfb = d<0. ? d-.5 : d+.5;
426			}
427
428
429			static MEM_PTR
430			colrInit(tms) /* initialize private data for tone mapping */
431			register struct tmStruct *tms;
432			{
433			register COLRDATA *cd;
434			register int i;
435			/* allocate our data */
436			cd = (COLRDATA *)malloc(sizeof(COLRDATA));
437			if (cd == NULL)
438			return(NULL);
439			tms->pd[colrReg] = (MEM_PTR)cd;
440			/* compute gamma table */
441			for (i = GAMTSZ; i--; )
442			cd->gamb[i] = 256.*pow((i+.5)/GAMTSZ, 1./tms->mongam);
443			/* compute color and scale factors */
444			colrNewSpace(tms);
445			return((MEM_PTR)cd);
446	greg	3.1	}