ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/tonemap.c

Comparing ray/src/common/tonemap.c (file contents):
Revision 3.4 by greg, Fri Apr 18 13:59:43 1997 UTC vs.
Revision 3.33 by greg, Mon Feb 9 20:23:51 2009 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1997 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Tone mapping functions.
6		* See tonemap.h for detailed function descriptions.
7	+	* Added von Kries white-balance calculations 10/01 (GW).
8	+	*
9	+	* Externals declared in tonemap.h
10		*/
11
12	+	#include "copyright.h"
13	+
14		#include        <stdio.h>
15		#include        <math.h>
16		#include        "tmprivat.h"
#	Line 16 | Line 18 | static char SCCSid[] = "$SunId$ LBL";
18
19		#define exp10(x)        exp(M_LN10*(x))
20
19	–	struct tmStruct *tmTop = NULL;          /* current tone mapping stack */
20	–
21		/* our list of conversion packages */
22		struct tmPackage        *tmPkg[TM_MAXPKG];
23		int     tmNumPkgs = 0;                  /* number of registered packages */
24
25	+	/* luminance->brightness lookup */
26	+	static TMbright         *tmFloat2BrtLUT = NULL;
27
28	<	int
27	<	tmErrorReturn(func, err)                /* error return (with message) */
28	<	char    *func;
29	<	int     err;
30	<	{
31	<	if (tmTop != NULL && tmTop->flags & TM_F_NOSTDERR)
32	<	return(err);
33	<	fputs(func, stderr);
34	<	fputs(": ", stderr);
35	<	fputs(tmErrorMessage[err], stderr);
36	<	fputs("!\n", stderr);
37	<	return(err);
38	<	}
28	>	#define tmCvLumLUfp(pf) tmFloat2BrtLUT[*(int32 *)(pf) >> 15]
29
30
31	<	struct tmStruct *
32	<	tmInit(flags, monpri, gamval)           /* initialize new tone mapping */
33	<	int     flags;
34	<	RGBPRIMP        monpri;
35	<	double  gamval;
31	>	TMstruct *
32	>	tmInit(                                 /* initialize new tone mapping */
33	>	int     flags,
34	>	RGBPRIMP        monpri,
35	>	double  gamval
36	>	)
37		{
47	–	static char     funcName[] = "tmInit";
38		COLORMAT        cmat;
39	<	register struct tmStruct        *tmnew;
40	<	register int    i;
39	>	TMstruct        *tmnew;
40	>	int     i;
41		/* allocate structure */
42	<	tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
42	>	tmnew = (TMstruct *)malloc(sizeof(TMstruct));
43		if (tmnew == NULL)
44		return(NULL);
45
46		tmnew->flags = flags & ~TM_F_UNIMPL;
47	+	if (tmnew->flags & TM_F_BW)
48	+	tmnew->flags &= ~TM_F_MESOPIC;
49		/* set monitor transform */
50		if (monpri == NULL || monpri == stdprims || tmnew->flags & TM_F_BW) {
51		tmnew->monpri = stdprims;
#	Line 81 | Line 73 | double gamval;
73		tmnew->inpsf = WHTEFFICACY;
74		tmnew->cmat[0][1] = tmnew->cmat[0][2] = tmnew->cmat[1][0] =
75		tmnew->cmat[1][2] = tmnew->cmat[2][0] = tmnew->cmat[2][1] = 0.;
76	<	tmnew->brmin = tmnew->brmax = 0;
76	>	tmnew->inpdat = NULL;
77	>	tmnew->hbrmin = 10; tmnew->hbrmax = -10;
78		tmnew->histo = NULL;
79	+	tmnew->mbrmin = 10; tmnew->mbrmax = -10;
80		tmnew->lumap = NULL;
81		/* zero private data */
82		for (i = TM_MAXPKG; i--; )
83		tmnew->pd[i] = NULL;
84	<	/* make tmnew current */
85	<	tmnew->tmprev = tmTop;
86	<	return(tmTop = tmnew);
84	>	tmnew->lastError = TM_E_OK;
85	>	tmnew->lastFunc = "NoErr";
86	>	/* return new TMstruct */
87	>	return(tmnew);
88		}
89
90
91		int
92	<	tmSetSpace(pri, sf)             /* set input color space for conversions */
93	<	RGBPRIMP        pri;
94	<	double  sf;
92	>	tmSetSpace(                     /* set input color space for conversions */
93	>	TMstruct        *tms,
94	>	RGBPRIMP        pri,
95	>	double  sf,
96	>	MEM_PTR dat
97	>	)
98		{
99	<	static char     funcName[] = "tmSetSpace";
100	<	register int    i, j;
99	>	static const char funcName[] = "tmSetSpace";
100	>	int     i, j;
101		/* error check */
102	<	if (tmTop == NULL)
102	>	if (tms == NULL)
103		returnErr(TM_E_TMINVAL);
104		if (sf <= 1e-12)
105		returnErr(TM_E_ILLEGAL);
106		/* check if no change */
107	<	if (pri == tmTop->inppri && FEQ(sf, tmTop->inpsf))
107	>	if (pri == tms->inppri && FEQ(sf, tms->inpsf) && dat == tms->inpdat)
108		returnOK;
109	<	tmTop->inppri = pri;                    /* let's set it */
110	<	tmTop->inpsf = sf;
109	>	tms->inppri = pri;                      /* let's set it */
110	>	tms->inpsf = sf;
111	>	tms->inpdat = dat;
112
113	<	if (tmTop->flags & TM_F_BW) {           /* color doesn't matter */
114	<	tmTop->monpri = tmTop->inppri;          /* eliminate xform */
115	<	if (tmTop->inppri == TM_XYZPRIM) {
116	<	tmTop->clf[CIEX] = tmTop->clf[CIEZ] = 0.;
117	<	tmTop->clf[CIEY] = 1.;
113	>	if (tms->flags & TM_F_BW) {             /* color doesn't matter */
114	>	tms->monpri = tms->inppri;              /* eliminate xform */
115	>	if (tms->inppri == TM_XYZPRIM) {
116	>	tms->clf[CIEX] = tms->clf[CIEZ] = 0.;
117	>	tms->clf[CIEY] = 1.;
118		} else {
119	<	comprgb2xyzmat(tmTop->cmat, tmTop->monpri);
120	<	tmTop->clf[RED] = tmTop->cmat[1][0];
121	<	tmTop->clf[GRN] = tmTop->cmat[1][1];
122	<	tmTop->clf[BLU] = tmTop->cmat[1][2];
119	>	comprgb2xyzmat(tms->cmat, tms->monpri);
120	>	tms->clf[RED] = tms->cmat[1][0];
121	>	tms->clf[GRN] = tms->cmat[1][1];
122	>	tms->clf[BLU] = tms->cmat[1][2];
123		}
124	<	tmTop->cmat[0][0] = tmTop->cmat[1][1] = tmTop->cmat[2][2] =
125	<	tmTop->inpsf;
126	<	tmTop->cmat[0][1] = tmTop->cmat[0][2] = tmTop->cmat[1][0] =
127	<	tmTop->cmat[1][2] = tmTop->cmat[2][0] = tmTop->cmat[2][1] = 0.;
124	>	tms->cmat[0][0] = tms->cmat[1][1] = tms->cmat[2][2] =
125	>	tms->inpsf;
126	>	tms->cmat[0][1] = tms->cmat[0][2] = tms->cmat[1][0] =
127	>	tms->cmat[1][2] = tms->cmat[2][0] = tms->cmat[2][1] = 0.;
128
129	<	} else if (tmTop->inppri == TM_XYZPRIM) /* input is XYZ */
130	<	compxyz2rgbmat(tmTop->cmat, tmTop->monpri);
129	>	} else if (tms->inppri == TM_XYZPRIM)   /* input is XYZ */
130	>	compxyz2rgbWBmat(tms->cmat, tms->monpri);
131
132		else {                                  /* input is RGB */
133	<	if (tmTop->inppri != tmTop->monpri &&
134	<	PRIMEQ(tmTop->inppri, tmTop->monpri))
135	<	tmTop->inppri = tmTop->monpri;  /* no xform */
136	<	comprgb2rgbmat(tmTop->cmat, tmTop->inppri, tmTop->monpri);
133	>	if (tms->inppri != tms->monpri &&
134	>	PRIMEQ(tms->inppri, tms->monpri))
135	>	tms->inppri = tms->monpri;      /* no xform */
136	>	comprgb2rgbWBmat(tms->cmat, tms->inppri, tms->monpri);
137		}
138		for (i = 0; i < 3; i++)
139		for (j = 0; j < 3; j++)
140	<	tmTop->cmat[i][j] *= tmTop->inpsf;
140	>	tms->cmat[i][j] *= tms->inpsf;
141		/* set color divisors */
142		for (i = 0; i < 3; i++)
143	<	if (tmTop->clf[i] > .001)
144	<	tmTop->cdiv[i] =
145	<	256.*pow(tmTop->clf[i], 1./tmTop->mongam);
143	>	if (tms->clf[i] > .001)
144	>	tms->cdiv[i] =
145	>	256.*pow(tms->clf[i], 1./tms->mongam);
146		else
147	<	tmTop->cdiv[i] = 1;
147	>	tms->cdiv[i] = 1;
148		/* notify packages */
149		for (i = tmNumPkgs; i--; )
150	<	if (tmTop->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
151	<	(*tmPkg[i]->NewSpace)(tmTop);
150	>	if (tms->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
151	>	(*tmPkg[i]->NewSpace)(tms);
152		returnOK;
153		}
154
155
156		void
157	<	tmClearHisto()                  /* clear current histogram */
157	>	tmClearHisto(                           /* clear current histogram */
158	>	TMstruct        *tms
159	>	)
160		{
161	<	if (tmTop == NULL || tmTop->histo == NULL)
161	>	if (tms == NULL || tms->histo == NULL)
162		return;
163	<	free((MEM_PTR)tmTop->histo);
164	<	tmTop->histo = NULL;
163	>	free((MEM_PTR)tms->histo);
164	>	tms->histo = NULL;
165		}
166
167
168	+	TMbright
169	+	tmCvLuminance(                          /* convert a single luminance */
170	+	double  lum
171	+	)
172	+	{
173	+	double  d;
174	+
175	+	#ifdef isfinite
176	+	if (!isfinite(lum) || lum <= TM_NOLUM)
177	+	#else
178	+	if (lum <= TM_NOLUM)
179	+	#endif
180	+	return(TM_NOBRT);
181	+	d = TM_BRTSCALE*log(lum);
182	+	if (d > 0.)
183	+	return((TMbright)(d+.5));
184	+	return((TMbright)(d-.5));
185	+	}
186	+
187	+
188		int
189	<	tmCvColors(ls, cs, scan, len)           /* convert float colors */
190	<	TMbright        *ls;
191	<	BYTE    *cs;
192	<	COLOR   *scan;
193	<	int     len;
189	>	tmCvLums(                               /* convert luminances using lookup */
190	>	TMbright        *ls,
191	>	float           *scan,
192	>	int             len
193	>	)
194		{
195	<	static char     funcName[] = "tmCvColors";
196	<	static COLOR    csmall = {1e-6, 1e-6, 1e-6};
195	>	if (tmFloat2BrtLUT == NULL) {   /* initialize lookup table */
196	>	int32   i;
197	>	tmFloat2BrtLUT = (TMbright *)malloc(sizeof(TMbright)*0x10000);
198	>	if (tmFloat2BrtLUT == NULL)
199	>	return(TM_E_NOMEM);
200	>	for (i = 0; i < 0x10000; i++) {
201	>	int32   l = (i<<1 | 1) << 14;
202	>	#ifndef isfinite
203	>	if ((l & 0x7f800000) == 0x7f800000)
204	>	tmFloat2BrtLUT[i] = TM_NOBRT;
205	>	else
206	>	#endif
207	>	tmFloat2BrtLUT[i] = tmCvLuminance(*(float *)&l);
208	>	}
209	>	}
210	>	if (len <= 0)
211	>	return(TM_E_OK);
212	>	if ((ls == NULL) | (scan == NULL))
213	>	return(TM_E_ILLEGAL);
214	>	while (len--) {
215	>	if (*scan <= TM_NOLUM) {
216	>	*ls++ = TM_NOBRT;
217	>	++scan;
218	>	continue;
219	>	}
220	>	*ls++ = tmCvLumLUfp(scan++);
221	>	}
222	>	return(TM_E_OK);
223	>	}
224	>
225	>
226	>	int
227	>	tmCvGrays(                              /* convert float gray values */
228	>	TMstruct        *tms,
229	>	TMbright        *ls,
230	>	float           *scan,
231	>	int             len
232	>	)
233	>	{
234	>	static const char funcName[] = "tmCvGrays";
235	>	int     i;
236	>
237	>	if (tms == NULL)
238	>	returnErr(TM_E_TMINVAL);
239	>	if ((ls == NULL) | (scan == NULL) | (len < 0))
240	>	returnErr(TM_E_ILLEGAL);
241	>	if (tmFloat2BrtLUT == NULL)                     /* initialize */
242	>	tmCvLums(NULL, NULL, 0);
243	>	for (i = len; i--; ) {
244	>	float   lum = tms->inpsf * scan[i];
245	>	if (lum <= TM_NOLUM)
246	>	ls[i] = TM_NOBRT;
247	>	else
248	>	ls[i] = tmCvLumLUfp(&lum);
249	>	}
250	>	returnOK;
251	>	}
252	>
253	>
254	>	int
255	>	tmCvColors(                             /* convert float colors */
256	>	TMstruct        *tms,
257	>	TMbright        *ls,
258	>	BYTE    *cs,
259	>	COLOR   *scan,
260	>	int     len
261	>	)
262	>	{
263	>	static const char funcName[] = "tmCvColors";
264	>	static BYTE     gamtab[1024];
265	>	static double   curgam = .0;
266		COLOR   cmon;
267	<	double  lum, slum;
268	<	register double d;
179	<	register int    i;
267	>	float   lum, slum, d;
268	>	int     i;
269
270	<	if (tmTop == NULL)
270	>	if (tms == NULL)
271		returnErr(TM_E_TMINVAL);
272	<	if (ls == NULL | scan == NULL | len <= 0)
272	>	if ((ls == NULL) | (scan == NULL) | (len < 0))
273		returnErr(TM_E_ILLEGAL);
274	+	if (tmFloat2BrtLUT == NULL)                     /* initialize */
275	+	tmCvLums(NULL, NULL, 0);
276	+	if (cs != TM_NOCHROM && fabs(tms->mongam - curgam) > .02) {
277	+	curgam = tms->mongam;                   /* (re)build table */
278	+	for (i = 1024; i--; )
279	+	gamtab[i] = (int)(256.*pow((i+.5)/1024., 1./curgam));
280	+	}
281		for (i = len; i--; ) {
282	<	if (tmNeedMatrix(tmTop))                /* get monitor RGB */
283	<	colortrans(cmon, tmTop->cmat, scan[i]);
188	<	else {
189	<	cmon[RED] = tmTop->inpsf*scan[i][RED];
190	<	cmon[GRN] = tmTop->inpsf*scan[i][GRN];
191	<	cmon[BLU] = tmTop->inpsf*scan[i][BLU];
192	<	}
193	<	/* world luminance */
194	<	lum =   tmTop->clf[RED]*cmon[RED] +
195	<	tmTop->clf[GRN]*cmon[GRN] +
196	<	tmTop->clf[BLU]*cmon[BLU] ;
197	<	/* check range */
198	<	if (clipgamut(cmon, lum, CGAMUT_LOWER, csmall, cwhite))
199	<	lum =   tmTop->clf[RED]*cmon[RED] +
200	<	tmTop->clf[GRN]*cmon[GRN] +
201	<	tmTop->clf[BLU]*cmon[BLU] ;
202	<	if (lum < MINLUM) {
203	<	ls[i] = MINBRT-1;               /* bogus value */
204	<	lum = MINLUM;
282	>	if (tmNeedMatrix(tms)) {                /* get monitor RGB */
283	>	colortrans(cmon, tms->cmat, scan[i]);
284		} else {
285	<	d = TM_BRTSCALE*log(lum);       /* encode it */
286	<	ls[i] = d>0. ? (int)(d+.5) : (int)(d-.5);
285	>	cmon[RED] = tms->inpsf*scan[i][RED];
286	>	cmon[GRN] = tms->inpsf*scan[i][GRN];
287	>	cmon[BLU] = tms->inpsf*scan[i][BLU];
288		}
289	+	#ifdef isfinite
290	+	if (!isfinite(cmon[RED]) || cmon[RED] < .0f) cmon[RED] = .0f;
291	+	if (!isfinite(cmon[GRN]) || cmon[GRN] < .0f) cmon[GRN] = .0f;
292	+	if (!isfinite(cmon[BLU]) || cmon[BLU] < .0f) cmon[BLU] = .0f;
293	+	#else
294	+	if (cmon[RED] < .0f) cmon[RED] = .0f;
295	+	if (cmon[GRN] < .0f) cmon[GRN] = .0f;
296	+	if (cmon[BLU] < .0f) cmon[BLU] = .0f;
297	+	#endif
298	+	/* world luminance */
299	+	lum =   tms->clf[RED]*cmon[RED] +
300	+	tms->clf[GRN]*cmon[GRN] +
301	+	tms->clf[BLU]*cmon[BLU] ;
302	+	if (lum <= TM_NOLUM) {                  /* convert brightness */
303	+	lum = cmon[RED] = cmon[GRN] = cmon[BLU] = TM_NOLUM;
304	+	ls[i] = TM_NOBRT;
305	+	} else
306	+	ls[i] = tmCvLumLUfp(&lum);
307		if (cs == TM_NOCHROM)                   /* no color? */
308		continue;
309	<	if (tmTop->flags & TM_F_MESOPIC && lum < LMESUPPER) {
309	>	if (tms->flags & TM_F_MESOPIC && lum < LMESUPPER) {
310		slum = scotlum(cmon);           /* mesopic adj. */
311	<	if (lum < LMESLOWER)
311	>	if (lum < LMESLOWER) {
312		cmon[RED] = cmon[GRN] = cmon[BLU] = slum;
313	<	else {
313	>	} else {
314		d = (lum - LMESLOWER)/(LMESUPPER - LMESLOWER);
315	<	if (tmTop->flags & TM_F_BW)
315	>	if (tms->flags & TM_F_BW)
316		cmon[RED] = cmon[GRN] =
317		cmon[BLU] = d*lum;
318		else
319		scalecolor(cmon, d);
320	<	d = (1.-d)*slum;
320	>	d = (1.f-d)*slum;
321		cmon[RED] += d;
322		cmon[GRN] += d;
323		cmon[BLU] += d;
324		}
325	<	} else if (tmTop->flags & TM_F_BW) {
325	>	} else if (tms->flags & TM_F_BW) {
326		cmon[RED] = cmon[GRN] = cmon[BLU] = lum;
327		}
328	<	d = tmTop->clf[RED]*cmon[RED]/lum;
329	<	cs[3*i  ] = d>=.999 ? 255 :
330	<	(int)(256.*pow(d, 1./tmTop->mongam));
331	<	d = tmTop->clf[GRN]*cmon[GRN]/lum;
332	<	cs[3*i+1] = d>=.999 ? 255 :
333	<	(int)(256.*pow(d, 1./tmTop->mongam));
236	<	d = tmTop->clf[BLU]*cmon[BLU]/lum;
237	<	cs[3*i+2] = d>=.999 ? 255 :
238	<	(int)(256.*pow(d, 1./tmTop->mongam));
328	>	d = tms->clf[RED]*cmon[RED]/lum;
329	>	cs[3*i  ] = d>=.999f ? 255 : gamtab[(int)(1024.f*d)];
330	>	d = tms->clf[GRN]*cmon[GRN]/lum;
331	>	cs[3*i+1] = d>=.999f ? 255 : gamtab[(int)(1024.f*d)];
332	>	d = tms->clf[BLU]*cmon[BLU]/lum;
333	>	cs[3*i+2] = d>=.999f ? 255 : gamtab[(int)(1024.f*d)];
334		}
335		returnOK;
336		}
337
338
339		int
340	<	tmAddHisto(ls, len, wt)                 /* add values to histogram */
341	<	register TMbright       *ls;
342	<	int     len;
343	<	int     wt;
340	>	tmAddHisto(                             /* add values to histogram */
341	>	TMstruct        *tms,
342	>	TMbright        *ls,
343	>	int     len,
344	>	int     wt
345	>	)
346		{
347	<	static char     funcName[] = "tmAddHisto";
348	<	int     sum, oldorig, oldlen, horig, hlen;
349	<	register int    i, j;
347	>	static const char funcName[] = "tmAddHisto";
348	>	int     oldorig=0, oldlen, horig, hlen;
349	>	int     i, j;
350
351	<	if (len <= 0)
255	<	returnErr(TM_E_ILLEGAL);
256	<	if (tmTop == NULL)
351	>	if (tms == NULL)
352		returnErr(TM_E_TMINVAL);
353	+	if (len < 0)
354	+	returnErr(TM_E_ILLEGAL);
355	+	if (len == 0)
356	+	returnOK;
357		/* first, grow limits */
358	<	if (tmTop->histo == NULL) {
358	>	if (tms->histo == NULL) {
359		for (i = len; i-- && ls[i] < MINBRT; )
360		;
361		if (i < 0)
362		returnOK;
363	<	tmTop->brmin = tmTop->brmax = ls[i];
363	>	tms->hbrmin = tms->hbrmax = ls[i];
364		oldlen = 0;
365		} else {
366	<	oldorig = (tmTop->brmin-MINBRT)/HISTEP;
367	<	oldlen = (tmTop->brmax-MINBRT)/HISTEP + 1 - oldorig;
366	>	oldorig = HISTI(tms->hbrmin);
367	>	oldlen = HISTI(tms->hbrmax) + 1 - oldorig;
368		}
369		for (i = len; i--; ) {
370		if ((j = ls[i]) < MINBRT)
371		continue;
372	<	if (j < tmTop->brmin)
373	<	tmTop->brmin = j;
374	<	else if (j > tmTop->brmax)
375	<	tmTop->brmax = j;
372	>	if (j < tms->hbrmin)
373	>	tms->hbrmin = j;
374	>	else if (j > tms->hbrmax)
375	>	tms->hbrmax = j;
376		}
377	<	horig = (tmTop->brmin-MINBRT)/HISTEP;
378	<	hlen = (tmTop->brmax-MINBRT)/HISTEP + 1 - horig;
377	>	horig = HISTI(tms->hbrmin);
378	>	hlen = HISTI(tms->hbrmax) + 1 - horig;
379		if (hlen > oldlen) {                    /* (re)allocate histogram */
380	<	register int    *newhist = (int *)calloc(hlen, sizeof(int));
380	>	int     *newhist = (int *)calloc(hlen, sizeof(int));
381		if (newhist == NULL)
382		returnErr(TM_E_NOMEM);
383		if (oldlen) {                   /* copy and free old */
384		for (i = oldlen, j = i+oldorig-horig; i; )
385	<	newhist[--j] = tmTop->histo[--i];
386	<	free((MEM_PTR)tmTop->histo);
385	>	newhist[--j] = tms->histo[--i];
386	>	free((MEM_PTR)tms->histo);
387		}
388	<	tmTop->histo = newhist;
290	<	if (tmTop->lumap != NULL) {     /* invalid tone map */
291	<	free((MEM_PTR)tmTop->lumap);
292	<	tmTop->lumap = NULL;
293	<	}
388	>	tms->histo = newhist;
389		}
390		if (wt == 0)
391		returnOK;
392		for (i = len; i--; )                    /* add in new counts */
393		if (ls[i] >= MINBRT)
394	<	tmTop->histo[ (ls[i]-MINBRT)/HISTEP - horig ] += wt;
394	>	tms->histo[ HISTI(ls[i]) - horig ] += wt;
395		returnOK;
396		}
397
398
399		static double
400	<	htcontrs(La)            /* human threshold contrast sensitivity, dL(La) */
401	<	double  La;
400	>	htcontrs(               /* human threshold contrast sensitivity, dL(La) */
401	>	double  La
402	>	)
403		{
404		double  l10La, l10dL;
405		/* formula taken from Ferwerda et al. [SG96] */
#	Line 324 | Line 420 | double La;
420
421
422		int
423	<	tmComputeMapping(gamval, Lddyn, Ldmax)
424	<	double  gamval;
425	<	double  Lddyn;
426	<	double  Ldmax;
423	>	tmFixedMapping(                 /* compute fixed, linear tone-mapping */
424	>	TMstruct        *tms,
425	>	double  expmult,
426	>	double  gamval
427	>	)
428		{
429	<	static char     funcName[] = "tmComputeMapping";
429	>	static const char funcName[] = "tmFixedMapping";
430	>	double          d;
431	>	int     i;
432	>
433	>	if (!tmNewMap(tms))
434	>	returnErr(TM_E_NOMEM);
435	>	if (expmult <= .0)
436	>	expmult = 1.;
437	>	if (gamval < MINGAM)
438	>	gamval = tms->mongam;
439	>	d = log(expmult/tms->inpsf);
440	>	for (i = tms->mbrmax-tms->mbrmin+1; i--; ) {
441	>	double  val = 256. * exp(
442	>	( d + (tms->mbrmin+i)*(1./TM_BRTSCALE) )
443	>	/ gamval);
444	>	tms->lumap[i] = val >= (double)0xffff ? 0xffff : (int)val;
445	>	}
446	>	returnOK;
447	>	}
448	>
449	>
450	>	int
451	>	tmComputeMapping(                       /* compute histogram tone-mapping */
452	>	TMstruct        *tms,
453	>	double  gamval,
454	>	double  Lddyn,
455	>	double  Ldmax
456	>	)
457	>	{
458	>	static const char funcName[] = "tmComputeMapping";
459		int     *histo;
460		float   *cumf;
461	<	int     brt0, histlen, histot, threshold, ceiling, trimmings;
461	>	int     brt0, histlen, threshold, ceiling, trimmings;
462		double  logLddyn, Ldmin, Ldavg, Lwavg, Tr, Lw, Ld;
463	<	int4    sum;
464	<	register double d;
465	<	register int    i, j;
463	>	int32   histot;
464	>	double  sum;
465	>	double  d;
466	>	int     i, j;
467
468	<	if (tmTop == NULL || tmTop->histo == NULL)
468	>	if (tms == NULL || tms->histo == NULL)
469		returnErr(TM_E_TMINVAL);
470		/* check arguments */
471		if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
472		if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
473	<	if (gamval < MINGAM) gamval = tmTop->mongam;
473	>	if (gamval < MINGAM) gamval = tms->mongam;
474		/* compute handy values */
475		Ldmin = Ldmax/Lddyn;
476		logLddyn = log(Lddyn);
477		Ldavg = sqrt(Ldmax*Ldmin);
478	<	i = (tmTop->brmin-MINBRT)/HISTEP;
479	<	brt0 = MINBRT + HISTEP/2 + i*HISTEP;
480	<	histlen = (tmTop->brmax-MINBRT)/HISTEP + 1 - i;
478	>	i = HISTI(tms->hbrmin);
479	>	brt0 = HISTV(i);
480	>	histlen = HISTI(tms->hbrmax) + 1 - i;
481		/* histogram total and mean */
482		histot = 0; sum = 0;
483		j = brt0 + histlen*HISTEP;
484		for (i = histlen; i--; ) {
485	<	histot += tmTop->histo[i];
486	<	sum += (j -= HISTEP) * tmTop->histo[i];
485	>	histot += tms->histo[i];
486	>	sum += (double)(j -= HISTEP) * tms->histo[i];
487		}
488	<	threshold = histot*.025 + .5;
489	<	if (threshold < 4)
488	>	threshold = histot*0.005 + .5;
489	>	if (!histot)
490		returnErr(TM_E_TMFAIL);
491		Lwavg = tmLuminance( (double)sum / histot );
492	<	if (!(tmTop->flags & TM_F_LINEAR)) {    /* clamp histogram */
493	<	histo = (int *)malloc(histlen*sizeof(int));
494	<	cumf = (float *)malloc((histlen+1)*sizeof(float));
495	<	if (histo == NULL | cumf == NULL)
496	<	returnErr(TM_E_NOMEM);
497	<	for (i = histlen; i--; )        /* make malleable copy */
498	<	histo[i] = tmTop->histo[i];
499	<	do {                            /* iterate to solution */
500	<	sum = 0;                /* cumulative probability */
501	<	for (i = 0; i < histlen; i++) {
502	<	cumf[i] = (double)sum/histot;
503	<	sum += histo[i];
492	>	/* use linear tone mapping? */
493	>	if (tms->flags & TM_F_LINEAR || threshold < 4 ||
494	>	tms->hbrmax - tms->hbrmin < TM_BRTSCALE*logLddyn)
495	>	goto linearmap;
496	>	/* clamp histogram */
497	>	histo = (int *)malloc(histlen*sizeof(int));
498	>	cumf = (float *)malloc((histlen+2)*sizeof(float));
499	>	if ((histo == NULL) | (cumf == NULL))
500	>	returnErr(TM_E_NOMEM);
501	>	cumf[histlen+1] = 1.;           /* guard for assignment code */
502	>	for (i = histlen; i--; )        /* make malleable copy */
503	>	histo[i] = tms->histo[i];
504	>	do {                            /* iterate to solution */
505	>	sum = 0;                /* cumulative probability */
506	>	for (i = 0; i < histlen; i++) {
507	>	cumf[i] = (double)sum/histot;
508	>	sum += histo[i];
509	>	}
510	>	cumf[histlen] = 1.;
511	>	Tr = histot * (double)(tms->hbrmax - tms->hbrmin) /
512	>	((double)histlen*TM_BRTSCALE) / logLddyn;
513	>	ceiling = Tr + 1.;
514	>	trimmings = 0;          /* clip to envelope */
515	>	for (i = histlen; i--; ) {
516	>	if (tms->flags & TM_F_HCONTR) {
517	>	Lw = tmLuminance(brt0 + i*HISTEP);
518	>	Ld = Ldmin * exp( logLddyn *
519	>	.5*(cumf[i]+cumf[i+1]) );
520	>	ceiling = Tr * (htcontrs(Ld) * Lw) /
521	>	(htcontrs(Lw) * Ld) + 1.;
522		}
523	<	cumf[i] = 1.;
524	<	Tr = histot * (double)(tmTop->brmax - tmTop->brmin) /
525	<	((double)histlen*TM_BRTSCALE) / logLddyn;
381	<	ceiling = Tr + 1.;
382	<	trimmings = 0;                  /* clip to envelope */
383	<	for (i = histlen; i--; ) {
384	<	if (tmTop->flags & TM_F_HCONTR) {
385	<	Lw = tmLuminance(brt0 + i*HISTEP);
386	<	Ld = Ldmin * exp( logLddyn *
387	<	.5*(cumf[i]+cumf[i+1]) );
388	<	ceiling = Tr * (htcontrs(Ld) * Lw) /
389	<	(htcontrs(Lw) * Ld) + 1.;
390	<	}
391	<	if (histo[i] > ceiling) {
392	<	trimmings += histo[i] - ceiling;
393	<	histo[i] = ceiling;
394	<	}
523	>	if (histo[i] > ceiling) {
524	>	trimmings += histo[i] - ceiling;
525	>	histo[i] = ceiling;
526		}
396	–	} while ((histot -= trimmings) > threshold &&
397	–	trimmings > threshold);
398	–	}
399	–	/* allocate luminance map */
400	–	if (tmTop->lumap == NULL) {
401	–	tmTop->lumap = (unsigned short *)malloc(
402	–	(tmTop->brmax-tmTop->brmin+1)*sizeof(unsigned short) );
403	–	if (tmTop->lumap == NULL)
404	–	returnErr(TM_E_NOMEM);
405	–	}
406	–	if (tmTop->flags & TM_F_LINEAR || histot <= threshold) {
407	–	/* linear tone mapping */
408	–	if (tmTop->flags & TM_F_HCONTR)
409	–	d = htcontrs(Ldavg) / htcontrs(Lwavg);
410	–	else
411	–	d = Ldavg / Lwavg;
412	–	d = log(d/Ldmax);
413	–	for (i = tmTop->brmax-tmTop->brmin+1; i--; )
414	–	tmTop->lumap[i] = 256. * exp(
415	–	( d + (tmTop->brmin+i)/(double)TM_BRTSCALE )
416	–	/ gamval );
417	–	} else {
418	–	/* histogram adjustment */
419	–	for (i = tmTop->brmax-tmTop->brmin+1; i--; ) {
420	–	j = d = (double)i/(tmTop->brmax-tmTop->brmin)*histlen;
421	–	d -= (double)j;
422	–	Ld = Ldmin*exp(logLddyn*((1.-d)*cumf[j]+d*cumf[j+1]));
423	–	d = (Ld - Ldmin)/(Ldmax - Ldmin);
424	–	tmTop->lumap[i] = 256.*pow(d, 1./gamval);
527		}
528	+	/* check if we're out of data */
529	+	if ((histot -= trimmings) <= threshold) {
530	+	free((MEM_PTR)histo);
531	+	free((MEM_PTR)cumf);
532	+	goto linearmap;
533	+	}
534	+	} while (trimmings > threshold);
535	+	/* allocate space for mapping */
536	+	if (!tmNewMap(tms))
537	+	returnErr(TM_E_NOMEM);
538	+	/* assign tone-mapping */
539	+	for (i = tms->mbrmax-tms->mbrmin+1; i--; ) {
540	+	j = d = (double)i/(tms->mbrmax-tms->mbrmin)*histlen;
541	+	d -= (double)j;
542	+	Ld = Ldmin*exp(logLddyn*((1.-d)*cumf[j]+d*cumf[j+1]));
543	+	d = (Ld - Ldmin)/(Ldmax - Ldmin);
544	+	tms->lumap[i] = 256.*pow(d, 1./gamval);
545		}
546	<	if (!(tmTop->flags & TM_F_LINEAR)) {
547	<	free((MEM_PTR)histo);
429	<	free((MEM_PTR)cumf);
430	<	}
546	>	free((MEM_PTR)histo);           /* clean up and return */
547	>	free((MEM_PTR)cumf);
548		returnOK;
549	+	linearmap:                              /* linear tone-mapping */
550	+	if (tms->flags & TM_F_HCONTR)
551	+	d = htcontrs(Ldavg) / htcontrs(Lwavg);
552	+	else
553	+	d = Ldavg / Lwavg;
554	+	return(tmFixedMapping(tms, tms->inpsf*d/Ldmax, gamval));
555		}
556
557
558		int
559	<	tmMapPixels(ps, ls, cs, len)
560	<	register BYTE   *ps;
561	<	TMbright        *ls;
562	<	register BYTE   *cs;
563	<	int     len;
559	>	tmMapPixels(                    /* apply tone-mapping to pixel(s) */
560	>	TMstruct        *tms,
561	>	BYTE    *ps,
562	>	TMbright        *ls,
563	>	BYTE    *cs,
564	>	int     len
565	>	)
566		{
567	<	static char     funcName[] = "tmMapPixels";
568	<	register int4   li, pv;
567	>	static const char funcName[] = "tmMapPixels";
568	>	int32   li, pv;
569
570	<	if (tmTop == NULL || tmTop->lumap == NULL)
570	>	if (tms == NULL || tms->lumap == NULL)
571		returnErr(TM_E_TMINVAL);
572	<	if (ps == NULL | ls == NULL | len <= 0)
572	>	if ((ps == NULL) | (ls == NULL) | (len < 0))
573		returnErr(TM_E_ILLEGAL);
574		while (len--) {
575	<	if ((li = *ls++) < tmTop->brmin)
576	<	li = tmTop->brmin;
577	<	else if (li > tmTop->brmax)
578	<	li = tmTop->brmax;
579	<	li = tmTop->lumap[li - tmTop->brmin];
575	>	if ((li = *ls++) < tms->mbrmin) {
576	>	li = 0;
577	>	} else {
578	>	if (li > tms->mbrmax)
579	>	li = tms->mbrmax;
580	>	li = tms->lumap[li - tms->mbrmin];
581	>	}
582		if (cs == TM_NOCHROM)
583		*ps++ = li>255 ? 255 : li;
584		else {
585	<	pv = *cs++ * li / tmTop->cdiv[RED];
585	>	pv = *cs++ * li / tms->cdiv[RED];
586		*ps++ = pv>255 ? 255 : pv;
587	<	pv = *cs++ * li / tmTop->cdiv[GRN];
587	>	pv = *cs++ * li / tms->cdiv[GRN];
588		*ps++ = pv>255 ? 255 : pv;
589	<	pv = *cs++ * li / tmTop->cdiv[BLU];
589	>	pv = *cs++ * li / tms->cdiv[BLU];
590		*ps++ = pv>255 ? 255 : pv;
591		}
592		}
#	Line 467 | Line 594 | int    len;
594		}
595
596
597	<	struct tmStruct *
598	<	tmPop()                         /* pop top tone mapping off stack */
597	>	TMstruct *
598	>	tmDup(                          /* duplicate top tone mapping */
599	>	TMstruct        *tms
600	>	)
601		{
473	–	register struct tmStruct        *tms;
474	–
475	–	if ((tms = tmTop) != NULL)
476	–	tmTop = tms->tmprev;
477	–	return(tms);
478	–	}
479	–
480	–
481	–	int
482	–	tmPull(tms)                     /* pull a tone mapping from stack */
483	–	register struct tmStruct        *tms;
484	–	{
485	–	register struct tmStruct        *tms2;
486	–	/* special cases first */
487	–	if (tms == NULL | tmTop == NULL)
488	–	return(0);
489	–	if (tms == tmTop) {
490	–	tmTop = tms->tmprev;
491	–	tms->tmprev = NULL;
492	–	return(1);
493	–	}
494	–	for (tms2 = tmTop; tms2->tmprev != NULL; tms2 = tms2->tmprev)
495	–	if (tms == tms2->tmprev) {      /* remove it */
496	–	tms2->tmprev = tms->tmprev;
497	–	tms->tmprev = NULL;
498	–	return(1);
499	–	}
500	–	return(0);                      /* not found on stack */
501	–	}
502	–
503	–
504	–	struct tmStruct *
505	–	tmDup()                         /* duplicate top tone mapping */
506	–	{
602		int     len;
603	<	register int    i;
604	<	register struct tmStruct        *tmnew;
603	>	int     i;
604	>	TMstruct        *tmnew;
605
606	<	if (tmTop == NULL)              /* anything to duplicate? */
606	>	if (tms == NULL)                /* anything to duplicate? */
607		return(NULL);
608	<	tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
608	>	tmnew = (TMstruct *)malloc(sizeof(TMstruct));
609		if (tmnew == NULL)
610		return(NULL);
611	<	*tmnew = *tmTop;                /* copy everything */
611	>	*tmnew = *tms;          /* copy everything */
612		if (tmnew->histo != NULL) {     /* duplicate histogram */
613	<	len = (tmnew->brmax-MINBRT)/HISTEP + 1 -
519	<	(tmnew->brmin-MINBRT)/HISTEP;
613	>	len = HISTI(tmnew->hbrmax) + 1 - HISTI(tmnew->hbrmin);
614		tmnew->histo = (int *)malloc(len*sizeof(int));
615		if (tmnew->histo != NULL)
616		for (i = len; i--; )
617	<	tmnew->histo[i] = tmTop->histo[i];
617	>	tmnew->histo[i] = tms->histo[i];
618		}
619		if (tmnew->lumap != NULL) {     /* duplicate luminance mapping */
620	<	len = tmnew->brmax-tmnew->brmin+1;
620	>	len = tmnew->mbrmax-tmnew->mbrmin+1;
621		tmnew->lumap = (unsigned short *)malloc(
622		len*sizeof(unsigned short) );
623		if (tmnew->lumap != NULL)
624		for (i = len; i--; )
625	<	tmnew->lumap[i] = tmTop->lumap[i];
625	>	tmnew->lumap[i] = tms->lumap[i];
626		}
627		/* clear package data */
628		for (i = tmNumPkgs; i--; )
629		tmnew->pd[i] = NULL;
630	<	tmnew->tmprev = tmTop;          /* make copy current */
631	<	return(tmTop = tmnew);
630	>	/* return copy */
631	>	return(tmnew);
632		}
633
634
541	–	int
542	–	tmPush(tms)                     /* push tone mapping on top of stack */
543	–	register struct tmStruct        *tms;
544	–	{
545	–	static char     funcName[] = "tmPush";
546	–	/* check validity */
547	–	if (tms == NULL)
548	–	returnErr(TM_E_ILLEGAL);
549	–	if (tms == tmTop)               /* check necessity */
550	–	returnOK;
551	–	/* pull if already in stack */
552	–	(void)tmPull(tms);
553	–	/* push it on top */
554	–	tms->tmprev = tmTop;
555	–	tmTop = tms;
556	–	returnOK;
557	–	}
558	–
559	–
635		void
636		tmDone(tms)                     /* done with tone mapping -- destroy it */
637	<	register struct tmStruct        *tms;
637	>	TMstruct        *tms;
638		{
639	<	register int    i;
640	<	/* NULL arg. is equiv. to tmTop */
641	<	if (tms == NULL && (tms = tmTop) == NULL)
639	>	int     i;
640	>	/* NULL arg. is equiv. to tms */
641	>	if (tms == NULL)
642		return;
568	–	/* take out of stack if present */
569	–	(void)tmPull(tms);
643		/* free tables */
644		if (tms->histo != NULL)
645		free((MEM_PTR)tms->histo);
#	Line 577 | Line 650 | register struct tmStruct       *tms;
650		if (tms->pd[i] != NULL)
651		(*tmPkg[i]->Free)(tms->pd[i]);
652		free((MEM_PTR)tms);             /* free basic structure */
653	+	}
654	+
655	+	/******************** Shared but Private library routines *********************/
656	+
657	+	BYTE    tmMesofact[BMESUPPER-BMESLOWER];
658	+
659	+	void
660	+	tmMkMesofact()                          /* build mesopic lookup factor table */
661	+	{
662	+	int     i;
663	+
664	+	if (tmMesofact[BMESUPPER-BMESLOWER-1])
665	+	return;
666	+
667	+	for (i = BMESLOWER; i < BMESUPPER; i++)
668	+	tmMesofact[i-BMESLOWER] = 256. *
669	+	(tmLuminance(i) - LMESLOWER) /
670	+	(LMESUPPER - LMESLOWER);
671	+	}
672	+
673	+
674	+	int
675	+	tmNewMap(                       /* allocate new tone-mapping array */
676	+	TMstruct        *tms
677	+	)
678	+	{
679	+	if (tms->lumap != NULL && (tms->mbrmax - tms->mbrmin) !=
680	+	(tms->hbrmax - tms->hbrmin)) {
681	+	free((MEM_PTR)tms->lumap);
682	+	tms->lumap = NULL;
683	+	}
684	+	tms->mbrmin = tms->hbrmin;
685	+	tms->mbrmax = tms->hbrmax;
686	+	if (tms->mbrmin > tms->mbrmax)
687	+	return 0;
688	+	if (tms->lumap == NULL)
689	+	tms->lumap = (unsigned short *)malloc(sizeof(unsigned short)*
690	+	(tms->mbrmax-tms->mbrmin+1));
691	+	return(tms->lumap != NULL);
692	+	}
693	+
694	+
695	+	int
696	+	tmErrorReturn(                          /* error return (with message) */
697	+	const char      *func,
698	+	TMstruct        *tms,
699	+	int     err
700	+	)
701	+	{
702	+	if (tms != NULL) {
703	+	tms->lastFunc = func;
704	+	tms->lastError = err;
705	+	if (tms->flags & TM_F_NOSTDERR)
706	+	return(err);
707	+	}
708	+	fputs(func, stderr);
709	+	fputs(": ", stderr);
710	+	fputs(tmErrorMessage[err], stderr);
711	+	fputs("!\n", stderr);
712	+	return(err);
713		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)