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.12 by greg, Tue Jul 15 00:30:09 2003 UTC vs.
Revision 3.42 by greg, Thu Jan 7 20:34:45 2021 UTC

# Line 12 | Line 12 | static const char      RCSid[] = "$Id$";
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  
21 – struct tmStruct *tmTop = NULL;          /* current tone mapping stack */
22 –
23                                          /* our list of conversion packages */
24   struct tmPackage        *tmPkg[TM_MAXPKG];
25   int     tmNumPkgs = 0;                  /* number of registered packages */
26  
27 < int     tmLastError;                    /* last error incurred by library */
28 < char    *tmLastFunction;                /* error-generating function name */
27 >                                        /* luminance->brightness lookup */
28 > static TMbright         *tmFloat2BrtLUT = NULL;
29  
30 + #define tmCvLumLUfp(pf) tmFloat2BrtLUT[*(int32 *)(pf) >> 15]
31  
32 < struct tmStruct *
33 < tmInit(flags, monpri, gamval)           /* initialize new tone mapping */
34 < int     flags;
35 < RGBPRIMP        monpri;
36 < double  gamval;
32 >
33 > TMstruct *
34 > tmInit(                                 /* initialize new tone mapping */
35 > int     flags,
36 > RGBPRIMP        monpri,
37 > double  gamval
38 > )
39   {
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 50 | Line 55 | double gamval;
55                  tmnew->clf[GRN] = rgb2xyzmat[1][1];
56                  tmnew->clf[BLU] = rgb2xyzmat[1][2];
57          } else {
58 <                comprgb2xyzWBmat(cmat, tmnew->monpri=monpri);
58 >                comprgb2xyzmat(cmat, tmnew->monpri=monpri);
59                  tmnew->clf[RED] = cmat[1][0];
60                  tmnew->clf[GRN] = cmat[1][1];
61                  tmnew->clf[BLU] = cmat[1][2];
# Line 62 | Line 67 | double gamval;
67                  tmnew->mongam = gamval;
68                                                  /* set color divisors */
69          for (i = 0; i < 3; i++)
70 <                tmnew->cdiv[i] = 256.*pow(tmnew->clf[i], 1./tmnew->mongam);
70 >                tmnew->cdiv[i] = TM_BRES*pow(tmnew->clf[i], 1./tmnew->mongam);
71  
72                                                  /* set input transform */
73          tmnew->inppri = tmnew->monpri;
# Line 70 | Line 75 | double gamval;
75                          tmnew->inpsf = WHTEFFICACY;
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->inpdat = NULL;
79          tmnew->hbrmin = 10; tmnew->hbrmax = -10;
80          tmnew->histo = NULL;
81          tmnew->mbrmin = 10; tmnew->mbrmax = -10;
# Line 77 | Line 83 | double gamval;
83                                                  /* zero private data */
84          for (i = TM_MAXPKG; i--; )
85                  tmnew->pd[i] = NULL;
86 <                                                /* make tmnew current */
87 <        tmnew->tmprev = tmTop;
88 <        return(tmTop = tmnew);
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;
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.;
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 <                        comprgb2xyzWBmat(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] =
129 <                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] =
127 >                                tms->inpsf;
128 >                tms->cmat[0][1] = tms->cmat[0][2] = tms->cmat[1][0] =
129 >                tms->cmat[1][2] = tms->cmat[2][0] = tms->cmat[2][1] = 0.;
130  
131 <        } else if (tmTop->inppri == TM_XYZPRIM) /* input is XYZ */
132 <                compxyz2rgbWBmat(tmTop->cmat, tmTop->monpri);
131 >        } else if (tms->inppri == TM_XYZPRIM)   /* input is XYZ */
132 >                compxyz2rgbWBmat(tms->cmat, tms->monpri);
133  
134          else {                                  /* input is RGB */
135 <                if (tmTop->inppri != tmTop->monpri &&
136 <                                PRIMEQ(tmTop->inppri, tmTop->monpri))
137 <                        tmTop->inppri = tmTop->monpri;  /* no xform */
138 <                comprgb2rgbWBmat(tmTop->cmat, tmTop->inppri, tmTop->monpri);
135 >                if (tms->inppri != tms->monpri &&
136 >                                PRIMEQ(tms->inppri, tms->monpri))
137 >                        tms->inppri = tms->monpri;      /* no xform */
138 >                if (!comprgb2rgbWBmat(tms->cmat, tms->inppri, tms->monpri))
139 >                        returnErr(TM_E_ILLEGAL);
140          }
141          for (i = 0; i < 3; i++)
142                  for (j = 0; j < 3; j++)
143 <                        tmTop->cmat[i][j] *= tmTop->inpsf;
143 >                        tms->cmat[i][j] *= tms->inpsf;
144                                                  /* set color divisors */
145          for (i = 0; i < 3; i++)
146 <                if (tmTop->clf[i] > .001)
147 <                        tmTop->cdiv[i] =
136 <                                256.*pow(tmTop->clf[i], 1./tmTop->mongam);
137 <                else
138 <                        tmTop->cdiv[i] = 1;
146 >                tms->cdiv[i] = TM_BRES*pow(tms->clf[i] < .001 ? .001 :
147 >                                                tms->clf[i], 1./tms->mongam);
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 +        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";
194 <        static COLOR    csmall = {.5*MINLUM, .5*MINLUM, .5*MINLUM};
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;
169 <        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 (tmNeedMatrix(tmTop))                /* get monitor RGB */
281 <                        colortrans(cmon, tmTop->cmat, scan[i]);
178 <                else {
179 <                        cmon[RED] = tmTop->inpsf*scan[i][RED];
180 <                        cmon[GRN] = tmTop->inpsf*scan[i][GRN];
181 <                        cmon[BLU] = tmTop->inpsf*scan[i][BLU];
182 <                }
183 <                                                        /* world luminance */
184 <                lum =   tmTop->clf[RED]*cmon[RED] +
185 <                        tmTop->clf[GRN]*cmon[GRN] +
186 <                        tmTop->clf[BLU]*cmon[BLU] ;
187 <                                                        /* check range */
188 <                if (clipgamut(cmon, lum, CGAMUT_LOWER, csmall, cwhite))
189 <                        lum =   tmTop->clf[RED]*cmon[RED] +
190 <                                tmTop->clf[GRN]*cmon[GRN] +
191 <                                tmTop->clf[BLU]*cmon[BLU] ;
192 <                if (lum < MINLUM) {
193 <                        ls[i] = MINBRT-1;               /* bogus value */
194 <                        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 :
328 <                                (int)(256.*pow(d, 1./tmTop->mongam));
329 <                d = tmTop->clf[GRN]*cmon[GRN]/lum;
330 <                cs[3*i+1] = d>=.999 ? 255 :
331 <                                (int)(256.*pow(d, 1./tmTop->mongam));
226 <                d = tmTop->clf[BLU]*cmon[BLU]/lum;
227 <                cs[3*i+2] = d>=.999 ? 255 :
228 <                                (int)(256.*pow(d, 1./tmTop->mongam));
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 < tmCvGrays(ls, scan, len)                /* convert float gray values */
339 < TMbright        *ls;
340 < float   *scan;
341 < int     len;
338 > tmAddHisto(                             /* add values to histogram */
339 > TMstruct        *tms,
340 > TMbright        *ls,
341 > int     len,
342 > int     wt
343 > )
344   {
345 <        static char     funcName[] = "tmCvGrays";
241 <        register double d;
242 <        register int    i;
243 <
244 <        if (tmTop == NULL)
245 <                returnErr(TM_E_TMINVAL);
246 <        if (ls == NULL | scan == NULL | len < 0)
247 <                returnErr(TM_E_ILLEGAL);
248 <        for (i = len; i--; )
249 <                if (scan[i] <= TM_NOLUM) {
250 <                        ls[i] = TM_NOBRT;               /* bogus value */
251 <                } else {
252 <                        d = TM_BRTSCALE*log(scan[i]);   /* encode it */
253 <                        ls[i] = d>0. ? (int)(d+.5) : (int)(d-.5);
254 <                }
255 <        returnOK;
256 < }
257 <
258 <
259 < int
260 < tmAddHisto(ls, len, wt)                 /* add values to histogram */
261 < register TMbright       *ls;
262 < int     len;
263 < int     wt;
264 < {
265 <        static char     funcName[] = "tmAddHisto";
345 >        static const char funcName[] = "tmAddHisto";
346          int     oldorig=0, oldlen, horig, hlen;
347 <        register int    i, j;
347 >        int     i, j;
348  
349 <        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->hbrmin = tmTop->hbrmax = ls[i];
361 >                tms->hbrmin = tms->hbrmax = ls[i];
362                  oldlen = 0;
363          } else {
364 <                oldorig = (tmTop->hbrmin-MINBRT)/HISTEP;
365 <                oldlen = (tmTop->hbrmax-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)
369                          continue;
370 <                if (j < tmTop->hbrmin)
371 <                        tmTop->hbrmin = j;
372 <                else if (j > tmTop->hbrmax)
373 <                        tmTop->hbrmax = j;
370 >                if (j < tms->hbrmin)
371 >                        tms->hbrmin = j;
372 >                else if (j > tms->hbrmax)
373 >                        tms->hbrmax = j;
374          }
375 <        horig = (tmTop->hbrmin-MINBRT)/HISTEP;
376 <        hlen = (tmTop->hbrmax-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((MEM_PTR)tmTop->histo);
382 >                        memcpy((MEM_PTR)(newhist+(oldorig-horig)),
383 >                                (MEM_PTR)tms->histo, oldlen*sizeof(HIST_TYP));
384 >                        free((MEM_PTR)tms->histo);
385                  }
386 <                tmTop->histo = newhist;
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 336 | Line 417 | double La;
417   }
418  
419  
339 – static int
340 – tmNewMap()
341 – {
342 –        if (tmTop->lumap != NULL && (tmTop->mbrmax - tmTop->mbrmin) !=
343 –                                        (tmTop->hbrmax - tmTop->hbrmin)) {
344 –                free((MEM_PTR)tmTop->lumap);
345 –                tmTop->lumap = NULL;
346 –        }
347 –        tmTop->mbrmin = tmTop->hbrmin;
348 –        tmTop->mbrmax = tmTop->hbrmax;
349 –        if (tmTop->mbrmin > tmTop->mbrmax)
350 –                return 0;
351 –        if (tmTop->lumap == NULL)
352 –                tmTop->lumap = (unsigned short *)malloc(sizeof(unsigned short)*
353 –                                        (tmTop->mbrmax-tmTop->mbrmin+1));
354 –        return(tmTop->lumap != NULL);
355 – }
356 –
357 –
420   int
421 < tmFixedMapping(expmult, gamval)
422 < double  expmult;
423 < double  gamval;
421 > tmFixedMapping(                 /* compute fixed, linear tone-mapping */
422 > TMstruct        *tms,
423 > double  expmult,
424 > double  gamval
425 > )
426   {
427 <        static char     funcName[] = "tmFixedMapping";
427 >        static const char funcName[] = "tmFixedMapping";
428          double          d;
429 <        register int    i;
429 >        int     i;
430          
431 <        if (!tmNewMap())
431 >        if (!tmNewMap(tms))
432                  returnErr(TM_E_NOMEM);
433          if (expmult <= .0)
434                  expmult = 1.;
435          if (gamval < MINGAM)
436 <                gamval = tmTop->mongam;
437 <        d = log(expmult/tmTop->inpsf);
438 <        for (i = tmTop->mbrmax-tmTop->mbrmin+1; i--; )
439 <                tmTop->lumap[i] = 256. * exp(
440 <                        ( d + (tmTop->mbrmin+i)*(1./TM_BRTSCALE) )
441 <                        / gamval );
436 >                gamval = tms->mongam;
437 >        d = log(expmult/tms->inpsf);
438 >        for (i = tms->mbrmax-tms->mbrmin+1; i--; ) {
439 >                double  val = TM_BRES * exp(
440 >                        ( d + (tms->mbrmin+i)*(1./TM_BRTSCALE) )
441 >                        / gamval);
442 >                tms->lumap[i] = val;
443 >                if (sizeof(TMAP_TYP) == 2 && val >= 0xffff)
444 >                        tms->lumap[i] = 0xffff;
445 >        }
446          returnOK;
447   }
448  
449  
450   int
451 < tmComputeMapping(gamval, Lddyn, Ldmax)
452 < double  gamval;
453 < double  Lddyn;
454 < double  Ldmax;
451 > tmComputeMapping(                       /* compute histogram tone-mapping */
452 > TMstruct        *tms,
453 > double  gamval,
454 > double  Lddyn,
455 > double  Ldmax
456 > )
457   {
458 <        static char     funcName[] = "tmComputeMapping";
459 <        int     *histo;
458 >        static const char funcName[] = "tmComputeMapping";
459 >        HIST_TYP        *histo;
460          float   *cumf;
461 <        int     brt0, histlen, threshold, ceiling, trimmings;
461 >        int     brt0, histlen;
462 >        HIST_TYP        threshold, ceiling, trimmings, histot;
463          double  logLddyn, Ldmin, Ldavg, Lwavg, Tr, Lw, Ld;
393 –        int32   histot;
464          double  sum;
465 <        register double d;
466 <        register int    i, j;
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->hbrmin-MINBRT)/HISTEP;
479 <        brt0 = MINBRT + HISTEP/2 + i*HISTEP;
480 <        histlen = (tmTop->hbrmax-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 );
422 –                                        /* allocate space for mapping */
423 –        if (!tmNewMap())
424 –                returnErr(TM_E_NOMEM);
492                                          /* use linear tone mapping? */
493 <        if (tmTop->flags & TM_F_LINEAR)
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));
497 >        histo = (HIST_TYP *)malloc(histlen*sizeof(HIST_TYP));
498          cumf = (float *)malloc((histlen+2)*sizeof(float));
499 <        if (histo == NULL | cumf == NULL)
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] = tmTop->histo[i];
502 >                                        /* make malleable copy */
503 >        memcpy((MEM_PTR)histo, (MEM_PTR)tms->histo, histlen*sizeof(HIST_TYP));
504          do {                            /* iterate to solution */
505                  sum = 0;                /* cumulative probability */
506                  for (i = 0; i < histlen; i++) {
# Line 440 | Line 508 | double Ldmax;
508                          sum += histo[i];
509                  }
510                  cumf[histlen] = 1.;
511 <                Tr = histot * (double)(tmTop->hbrmax - tmTop->hbrmin) /
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 (tmTop->flags & TM_F_HCONTR) {
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]) );
# Line 464 | Line 532 | double Ldmax;
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 = tmTop->mbrmax-tmTop->mbrmin+1; i--; ) {
540 <                j = d = (double)i/(tmTop->mbrmax-tmTop->mbrmin)*histlen;
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 <                tmTop->lumap[i] = 256.*pow(d, 1./gamval);
544 >                tms->lumap[i] = TM_BRES*pow(d, 1./gamval);
545          }
546          free((MEM_PTR)histo);           /* clean up and return */
547          free((MEM_PTR)cumf);
548          returnOK;
549   linearmap:                              /* linear tone-mapping */
550 <        if (tmTop->flags & TM_F_HCONTR)
550 >        if (tms->flags & TM_F_HCONTR)
551                  d = htcontrs(Ldavg) / htcontrs(Lwavg);
552          else
553                  d = Ldavg / Lwavg;
554 <        return(tmFixedMapping(tmTop->inpsf*d/Ldmax, gamval));
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 > uby8    *ps,
562 > TMbright        *ls,
563 > uby8    *cs,
564 > int     len
565 > )
566   {
567 <        static char     funcName[] = "tmMapPixels";
568 <        register int32  li, pv;
567 >        static const char funcName[] = "tmMapPixels";
568 >        TMbright        lv;
569 >        TMAP_TYP        li;
570 >        int             pv;
571  
572 <        if (tmTop == NULL || tmTop->lumap == NULL)
572 >        if (tms == NULL || tms->lumap == NULL)
573                  returnErr(TM_E_TMINVAL);
574 <        if (ps == NULL | ls == NULL | len < 0)
574 >        if ((ps == NULL) | (ls == NULL) | (len < 0))
575                  returnErr(TM_E_ILLEGAL);
576          while (len--) {
577 <                if ((li = *ls++) < tmTop->mbrmin) {
577 >                if ((lv = *ls++) < tms->mbrmin) {
578                          li = 0;
579                  } else {
580 <                        if (li > tmTop->mbrmax)
581 <                                li = tmTop->mbrmax;
582 <                        li = tmTop->lumap[li - tmTop->mbrmin];
580 >                        if (lv > tms->mbrmax)
581 >                                lv = tms->mbrmax;
582 >                        li = tms->lumap[lv - tms->mbrmin];
583                  }
584                  if (cs == TM_NOCHROM)
585 <                        *ps++ = li>255 ? 255 : li;
585 >                        *ps++ = li>=TM_BRES ? 255 : (int)(256*li/TM_BRES);
586                  else {
587 <                        pv = *cs++ * li / tmTop->cdiv[RED];
587 >                        pv = *cs++ * li / tms->cdiv[RED];
588                          *ps++ = pv>255 ? 255 : pv;
589 <                        pv = *cs++ * li / tmTop->cdiv[GRN];
589 >                        pv = *cs++ * li / tms->cdiv[GRN];
590                          *ps++ = pv>255 ? 255 : pv;
591 <                        pv = *cs++ * li / tmTop->cdiv[BLU];
591 >                        pv = *cs++ * li / tms->cdiv[BLU];
592                          *ps++ = pv>255 ? 255 : pv;
593                  }
594          }
# Line 521 | Line 596 | int    len;
596   }
597  
598  
599 < struct tmStruct *
600 < tmPop()                         /* pop top tone mapping off stack */
599 > TMstruct *
600 > tmDup(                          /* duplicate tone mapping */
601 > TMstruct        *tms
602 > )
603   {
527 –        register struct tmStruct        *tms;
528 –
529 –        if ((tms = tmTop) != NULL)
530 –                tmTop = tms->tmprev;
531 –        return(tms);
532 – }
533 –
534 –
535 – int
536 – tmPull(tms)                     /* pull a tone mapping from stack */
537 – register struct tmStruct        *tms;
538 – {
539 –        register struct tmStruct        *tms2;
540 –                                        /* special cases first */
541 –        if (tms == NULL | tmTop == NULL)
542 –                return(0);
543 –        if (tms == tmTop) {
544 –                tmTop = tms->tmprev;
545 –                tms->tmprev = NULL;
546 –                return(1);
547 –        }
548 –        for (tms2 = tmTop; tms2->tmprev != NULL; tms2 = tms2->tmprev)
549 –                if (tms == tms2->tmprev) {      /* remove it */
550 –                        tms2->tmprev = tms->tmprev;
551 –                        tms->tmprev = NULL;
552 –                        return(1);
553 –                }
554 –        return(0);                      /* not found on stack */
555 – }
556 –
557 –
558 – struct tmStruct *
559 – tmDup()                         /* duplicate top tone mapping */
560 – {
604          int     len;
605 <        register int    i;
606 <        register struct tmStruct        *tmnew;
605 >        int     i;
606 >        TMstruct        *tmnew;
607  
608 <        if (tmTop == NULL)              /* anything to duplicate? */
608 >        if (tms == NULL)                /* anything to duplicate? */
609                  return(NULL);
610 <        tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
610 >        tmnew = (TMstruct *)malloc(sizeof(TMstruct));
611          if (tmnew == NULL)
612                  return(NULL);
613 <        *tmnew = *tmTop;                /* copy everything */
613 >        *tmnew = *tms;          /* copy everything */
614          if (tmnew->histo != NULL) {     /* duplicate histogram */
615 <                len = (tmnew->hbrmax-MINBRT)/HISTEP + 1 -
616 <                                (tmnew->hbrmin-MINBRT)/HISTEP;
574 <                tmnew->histo = (int *)malloc(len*sizeof(int));
615 >                len = HISTI(tmnew->hbrmax) + 1 - HISTI(tmnew->hbrmin);
616 >                tmnew->histo = (HIST_TYP *)malloc(len*sizeof(HIST_TYP));
617                  if (tmnew->histo != NULL)
618 <                        for (i = len; i--; )
619 <                                tmnew->histo[i] = tmTop->histo[i];
618 >                        memcpy((MEM_PTR)tmnew->histo, (MEM_PTR)tms->histo,
619 >                                        len*sizeof(HIST_TYP));
620          }
621          if (tmnew->lumap != NULL) {     /* duplicate luminance mapping */
622                  len = tmnew->mbrmax-tmnew->mbrmin+1;
623 <                tmnew->lumap = (unsigned short *)malloc(
582 <                                                len*sizeof(unsigned short) );
623 >                tmnew->lumap = (TMAP_TYP *)malloc(len*sizeof(TMAP_TYP));
624                  if (tmnew->lumap != NULL)
625 <                        for (i = len; i--; )
626 <                                tmnew->lumap[i] = tmTop->lumap[i];
625 >                        memcpy((MEM_PTR)tmnew->lumap, (MEM_PTR)tms->lumap,
626 >                                        len*sizeof(TMAP_TYP));
627          }
628                                          /* clear package data */
629          for (i = tmNumPkgs; i--; )
630                  tmnew->pd[i] = NULL;
631 <        tmnew->tmprev = tmTop;          /* make copy current */
632 <        return(tmTop = tmnew);
631 >                                        /* return copy */
632 >        return(tmnew);
633   }
634  
635  
595 – int
596 – tmPush(tms)                     /* push tone mapping on top of stack */
597 – register struct tmStruct        *tms;
598 – {
599 –        static char     funcName[] = "tmPush";
600 –                                        /* check validity */
601 –        if (tms == NULL)
602 –                returnErr(TM_E_ILLEGAL);
603 –        if (tms == tmTop)               /* check necessity */
604 –                returnOK;
605 –                                        /* pull if already in stack */
606 –        (void)tmPull(tms);
607 –                                        /* push it on top */
608 –        tms->tmprev = tmTop;
609 –        tmTop = tms;
610 –        returnOK;
611 – }
612 –
613 –
636   void
637   tmDone(tms)                     /* done with tone mapping -- destroy it */
638 < register struct tmStruct        *tms;
638 > TMstruct        *tms;
639   {
640 <        register int    i;
641 <                                        /* NULL arg. is equiv. to tmTop */
642 <        if (tms == NULL && (tms = tmTop) == NULL)
640 >        int     i;
641 >                                        /* NULL arg. is equiv. to tms */
642 >        if (tms == NULL)
643                  return;
622 –                                        /* take out of stack if present */
623 –        (void)tmPull(tms);
644                                          /* free tables */
645          if (tms->histo != NULL)
646                  free((MEM_PTR)tms->histo);
# Line 635 | Line 655 | register struct tmStruct       *tms;
655  
656   /******************** Shared but Private library routines *********************/
657  
658 < BYTE    tmMesofact[BMESUPPER-BMESLOWER];
658 > uby8    tmMesofact[BMESUPPER-BMESLOWER];
659  
660   void
661   tmMkMesofact()                          /* build mesopic lookup factor table */
662   {
663 <        register int    i;
663 >        int     i;
664  
665          if (tmMesofact[BMESUPPER-BMESLOWER-1])
666                  return;
# Line 653 | Line 673 | tmMkMesofact()                         /* build mesopic lookup factor table
673  
674  
675   int
676 < tmErrorReturn(func, err)                /* error return (with message) */
677 < char    *func;
678 < int     err;
676 > tmNewMap(                       /* allocate new tone-mapping array */
677 > TMstruct        *tms
678 > )
679   {
680 <        tmLastFunction = func;
681 <        tmLastError = err;
682 <        if (tmTop != NULL && tmTop->flags & TM_F_NOSTDERR)
683 <                return(err);
680 >        if (tms->lumap != NULL && (tms->mbrmax - tms->mbrmin) !=
681 >                                        (tms->hbrmax - tms->hbrmin)) {
682 >                free((MEM_PTR)tms->lumap);
683 >                tms->lumap = NULL;
684 >        }
685 >        tms->mbrmin = tms->hbrmin;
686 >        tms->mbrmax = tms->hbrmax;
687 >        if (tms->mbrmin > tms->mbrmax)
688 >                return 0;
689 >        if (tms->lumap == NULL)
690 >                tms->lumap = (TMAP_TYP *)malloc(sizeof(TMAP_TYP)*
691 >                                        (tms->mbrmax-tms->mbrmin+1));
692 >        return(tms->lumap != NULL);
693 > }
694 >
695 >
696 > int
697 > tmErrorReturn(                          /* error return (with message) */
698 > const char      *func,
699 > TMstruct        *tms,
700 > int     err
701 > )
702 > {
703 >        if (tms != NULL) {
704 >                tms->lastFunc = func;
705 >                tms->lastError = err;
706 >                if (tms->flags & TM_F_NOSTDERR)
707 >                        return(err);
708 >        }
709          fputs(func, stderr);
710          fputs(": ", stderr);
711          fputs(tmErrorMessage[err], stderr);

Diff Legend

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