ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/tonemap.c
Revision: 3.55
Committed: Thu Nov 21 17:15:54 2024 UTC (5 months, 1 week ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 3.54: +3 -6 lines
Log Message:
refactor: Removed unused client data parametr from tmSetSpace() call

File Contents

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