ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/tonemap.c
(Generate patch)

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

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines