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

Comparing ray/src/common/tmaptiff.c (file contents):
Revision 3.4 by schorsch, Sun Jul 27 22:12:01 2003 UTC vs.
Revision 3.8 by greg, Mon Feb 9 20:48:08 2009 UTC

# Line 10 | Line 10 | static const char      RCSid[] = "$Id$";
10   #include "copyright.h"
11  
12   #include <stdio.h>
13 < #include "tiffio.h"
13 > #include <stdlib.h>
14   #include "tmprivat.h"
15 + #include "tiffio.h"
16   #include "tmaptiff.h"
17  
18                                          /* input cases we handle */
# Line 78 | Line 79 | getTIFFtype(TIFF *tif)
79  
80   /* load and convert TIFF */
81   int
82 < tmLoadTIFF(TMbright **lpp, BYTE **cpp, int *xp, int *yp, char *fname, TIFF *tp)
82 > tmLoadTIFF(TMstruct *tms, TMbright **lpp, BYTE **cpp,
83 >                int *xp, int *yp, char *fname, TIFF *tp)
84   {
85          char    *funcName = fname==NULL ? "tmLoadTIFF" : fname;
86 <        RGBPRIMP        inppri = tmTop->monpri;
86 >        RGBPRIMP        inppri = tms->monpri;
87          RGBPRIMS        myprims;
88          float   *fa;
89          TIFF    *tif;
# Line 92 | Line 94 | tmLoadTIFF(TMbright **lpp, BYTE **cpp, int *xp, int *y
94          double  stonits;
95          int     y;
96                                          /* check arguments */
97 <        if (tmTop == NULL)
97 >        if (tms == NULL)
98                  returnErr(TM_E_TMINVAL);
99          if ((lpp == NULL) | (xp == NULL) | (yp == NULL) |
100                          ((fname == NULL) & (tp == NULL)))
# Line 132 | Line 134 | tmLoadTIFF(TMbright **lpp, BYTE **cpp, int *xp, int *y
134          case TC_LOGLUV24:
135                  TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_RAW);
136                  sl.l = (uint32 *)malloc(width*sizeof(uint32));
137 <                tmSetSpace(TM_XYZPRIM, stonits);
137 >                tmSetSpace(tms, TM_XYZPRIM, stonits, NULL);
138                  break;
139          case TC_LOGL16:
140                  TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_16BIT);
141                  sl.w = (uint16 *)malloc(width*sizeof(uint16));
142 <                tmSetSpace(tmTop->monpri, stonits);
142 >                tmSetSpace(tms, tms->monpri, stonits, NULL);
143                  break;
144          case TC_RGBFLOAT:
145                  sl.f = (float *)malloc(width*3*sizeof(float));
146 <                tmSetSpace(inppri, stonits);
146 >                tmSetSpace(tms, inppri, stonits, NULL);
147                  break;
148          case TC_GRYFLOAT:
149                  sl.f = (float *)malloc(width*sizeof(float));
150 <                tmSetSpace(tmTop->monpri, stonits);
150 >                tmSetSpace(tms, tms->monpri, stonits, NULL);
151                  break;
152          case TC_RGBSHORT:
153                  sl.w = (uint16 *)malloc(width*3*sizeof(uint16));
154 <                tmSetSpace(inppri, stonits);
154 >                tmSetSpace(tms, inppri, stonits, NULL);
155                  break;
156          case TC_GRYSHORT:
157                  sl.w = (uint16 *)malloc(width*sizeof(uint16));
158 <                tmSetSpace(tmTop->monpri, stonits);
158 >                tmSetSpace(tms, tms->monpri, stonits, NULL);
159                  break;
160          default:
161                  err = TM_E_CODERR1;
# Line 186 | Line 188 | tmLoadTIFF(TMbright **lpp, BYTE **cpp, int *xp, int *y
188                  }
189                  switch (tcase) {
190                  case TC_LOGLUV32:
191 <                        err = tmCvLuv32(*lpp + y*width,
191 >                        err = tmCvLuv32(tms, *lpp + y*width,
192                                  cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
193                                          sl.l, width);
194                          break;
195                  case TC_LOGLUV24:
196 <                        err = tmCvLuv24(*lpp + y*width,
196 >                        err = tmCvLuv24(tms, *lpp + y*width,
197                                  cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
198                                          sl.l, width);
199                          break;
200                  case TC_LOGL16:
201 <                        err = tmCvL16(*lpp + y*width, sl.w, width);
201 >                        err = tmCvL16(tms, *lpp + y*width, sl.w, width);
202                          break;
203                  case TC_RGBFLOAT:
204 <                        err = tmCvColors(*lpp + y*width,
204 >                        err = tmCvColors(tms, *lpp + y*width,
205                                  cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
206                                          (COLOR *)sl.f, width);
207                          break;
208                  case TC_GRYFLOAT:
209 <                        err = tmCvGrays(*lpp + y*width, sl.f, width);
209 >                        err = tmCvGrays(tms, *lpp + y*width, sl.f, width);
210                          break;
211                  case TC_RGBSHORT:
212 <                        err = tmCvRGB48(*lpp + y*width,
212 >                        err = tmCvRGB48(tms, *lpp + y*width,
213                                  cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
214                                          (uint16 (*)[3])sl.w, width, DEFGAM);
215                          break;
216                  case TC_GRYSHORT:
217 <                        err = tmCvGray16(*lpp + y*width, sl.w, width, DEFGAM);
217 >                        err = tmCvGray16(tms, *lpp + y*width,
218 >                                        sl.w, width, DEFGAM);
219                          break;
220                  default:
221                          err = TM_E_CODERR1;
# Line 253 | Line 256 | tmMapTIFF(BYTE **psp, int *xp, int *yp, int flags, RGB
256          double gamval, double Lddyn, double Ldmax, char *fname, TIFF *tp)
257   {
258          char    *funcName = fname==NULL ? "tmMapTIFF" : fname;
259 +        TMstruct        *tms;
260          TMbright        *lp;
261          BYTE    *cp;
262          int     err;
# Line 265 | Line 269 | tmMapTIFF(BYTE **psp, int *xp, int *yp, int flags, RGB
269          if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
270          if (flags & TM_F_BW) monpri = stdprims;
271                                          /* initialize tone mapping */
272 <        if (tmInit(flags, monpri, gamval) == NULL)
272 >        if ((tms = tmInit(flags, monpri, gamval)) == NULL)
273                  returnErr(TM_E_NOMEM);
274                                          /* load and convert TIFF */
275          cp = TM_NOCHROM;
276 <        err = tmLoadTIFF(&lp, flags&TM_F_BW ? TM_NOCHROMP : &cp,
276 >        err = tmLoadTIFF(tms, &lp, flags&TM_F_BW ? TM_NOCHROMP : &cp,
277                          xp, yp, fname, tp);
278          if (err != TM_E_OK) {
279 <                tmDone(NULL);
279 >                tmDone(tms);
280                  return(err);
281          }
282          if (cp == TM_NOCHROM) {
283                  *psp = (BYTE *)malloc(*xp * *yp * sizeof(BYTE));
284                  if (*psp == NULL) {
285                          free((MEM_PTR)lp);
286 <                        tmDone(NULL);
286 >                        tmDone(tms);
287                          returnErr(TM_E_NOMEM);
288                  }
289          } else
290                  *psp = cp;
291                                          /* compute color mapping */
292 <        err = tmAddHisto(lp, *xp * *yp, 1);
292 >        err = tmAddHisto(tms, lp, *xp * *yp, 1);
293          if (err != TM_E_OK)
294                  goto done;
295 <        err = tmComputeMapping(gamval, Lddyn, Ldmax);
295 >        err = tmComputeMapping(tms, gamval, Lddyn, Ldmax);
296          if (err != TM_E_OK)
297                  goto done;
298                                          /* map pixels */
299 <        err = tmMapPixels(*psp, lp, cp, *xp * *yp);
299 >        err = tmMapPixels(tms, *psp, lp, cp, *xp * *yp);
300  
301   done:                                   /* clean up */
302          free((MEM_PTR)lp);
303 <        tmDone(NULL);
303 >        tmDone(tms);
304          if (err != TM_E_OK) {           /* free memory on error */
305                  free((MEM_PTR)*psp);
306                  *psp = NULL;

Diff Legend

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