src/px/tmaptiff.c

/* Copyright (c) 1998 Silicon Graphics, Inc. */

#ifndef lint
static char SCCSid[] = "$SunId$ SGI";
#endif

/*
 * Perform tone mapping on TIFF input.
 */

#include <stdio.h>
#include "tiffio.h"
#include "tmprivat.h"


int
tmLoadTIFF(lpp, cpp, xp, yp, fname, tp) /* load and convert TIFF */
TMbright        **lpp;
BYTE    **cpp;
int     *xp, *yp;
char    *fname;
TIFF    *tp;
{
        char    *funcName = fname==NULL ? "tmLoadTIFF" : fname;
        TIFF    *tif;
        int     err;
        union {uint16 *w; uint32 *l; MEM_PTR p;} sl;
        uint16  comp, phot, pconf;
        uint32  width, height;
        double  stonits;
        int     y;
                                        /* check arguments */
        if (tmTop == NULL)
                returnErr(TM_E_TMINVAL);
        if (lpp == NULL | xp == NULL | yp == NULL |
                        (fname == NULL & tp == NULL))
                returnErr(TM_E_ILLEGAL);
                                        /* check/get TIFF tags */
        sl.p = NULL; *lpp = NULL;
        if (cpp != TM_NOCHROMP) *cpp = TM_NOCHROM;
        err = TM_E_BADFILE;
        if ((tif = tp) == NULL && (tif = TIFFOpen(fname, "r")) == NULL)
                returnErr(TM_E_BADFILE);
        TIFFGetFieldDefaulted(tif, TIFFTAG_PHOTOMETRIC, &phot);
        TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &comp);
        if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) ||
                        !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))
                goto done;
        *xp = width; *yp = height;
        TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &pconf);
        if (pconf != PLANARCONFIG_CONTIG)
                goto done;
        if (!TIFFGetField(tif, TIFFTAG_STONITS, &stonits))
                stonits = 1.;
        if (phot == PHOTOMETRIC_LOGLUV) {
                if (comp != COMPRESSION_SGILOG && comp != COMPRESSION_SGILOG24)
                        goto done;
                TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_RAW);
                sl.l = (uint32 *)malloc(width*sizeof(uint32));
                if (cpp != TM_NOCHROMP) {
                        *cpp = (BYTE *)malloc(width*height*3*sizeof(BYTE));
                        if (*cpp == NULL) {
                                err = TM_E_NOMEM;
                                goto done;
                        }
                }
        } else if (phot == PHOTOMETRIC_LOGL) {
                if (comp != COMPRESSION_SGILOG)
                        goto done;
                TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_16BIT);
                sl.w = (uint16 *)malloc(width*sizeof(uint16));
        } else
                goto done;
        *lpp = (TMbright *)malloc(width*height*sizeof(TMbright));
        if (sl.p == NULL | *lpp == NULL) {
                err = TM_E_NOMEM;
                goto done;
        }
                                        /* set input color space */
        tmSetSpace(TM_XYZPRIM, stonits);
                                        /* read and convert each scanline */
        for (y = 0; y < height; y++) {
                if (TIFFReadScanline(tif, sl.p, y, 0) < 0) {
                        err = TM_E_BADFILE;
                        break;
                }
                if (phot == PHOTOMETRIC_LOGL)
                        err = tmCvL16(*lpp + y*width, sl.w, width);
                else if (comp == COMPRESSION_SGILOG24)
                        err = tmCvLuv24(*lpp + y*width,
                                cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
                                        sl.l, width);
                else
                        err = tmCvLuv32(*lpp + y*width,
                                cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
                                        sl.l, width);
                if (err != TM_E_OK)
                        break;
        }
done:                                   /* clean up */
        if (tp == NULL)
                TIFFClose(tif);
        if (sl.p != NULL)
                free(sl.p);
        if (err != TM_E_OK) {           /* free buffers on error */
                if (*lpp != NULL)
                        free((MEM_PTR)*lpp);
                *lpp = NULL;
                if (cpp != TM_NOCHROMP) {
                        if (*cpp != TM_NOCHROM)
                                free((MEM_PTR)*cpp);
                        *cpp = NULL;
                }
                *xp = *yp = 0;
                returnErr(err);
        }
        returnOK;
}


/*
 * Load and tone-map a SGILOG TIFF.
 * Beware of greyscale input -- you must check the PHOTOMETRIC tag to
 * determine that the returned array contains only grey values, not RGB.
 * As in tmMapPicture(), grey values are also returned if flags&TM_F_BW.
 */
int
tmMapTIFF(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname, tp)
BYTE    **psp;
int     *xp, *yp;
int     flags;
RGBPRIMP        monpri;
double  gamval, Lddyn, Ldmax;
char    *fname;
TIFF    *tp;
{
        char    *funcName = fname==NULL ? "tmMapTIFF" : fname;
        TMbright        *lp;
        BYTE    *cp;
        int     err;
                                        /* check arguments */
        if (psp == NULL | xp == NULL | yp == NULL | monpri == NULL |
                        (fname == NULL & tp == NULL))
                returnErr(TM_E_ILLEGAL);
        if (gamval < MINGAM) gamval = DEFGAM;
        if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
        if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
        if (flags & TM_F_BW) monpri = stdprims;
                                        /* initialize tone mapping */
        if (tmInit(flags, monpri, gamval) == NULL)
                returnErr(TM_E_NOMEM);
                                        /* load and convert TIFF */
        cp = TM_NOCHROM;
        err = tmLoadTIFF(&lp, flags&TM_F_BW ? TM_NOCHROMP : &cp,
                        xp, yp, fname, tp);
        if (err != TM_E_OK) {
                tmDone(NULL);
                return(err);
        }
        if (cp == TM_NOCHROM) {
                *psp = (BYTE *)malloc(*xp * *yp * sizeof(BYTE));
                if (*psp == NULL) {
                        free((MEM_PTR)lp);
                        tmDone(NULL);
                        returnErr(TM_E_NOMEM);
                }
        } else
                *psp = cp;
                                        /* compute color mapping */
        err = tmAddHisto(lp, *xp * *yp, 1);
        if (err != TM_E_OK)
                goto done;
        err = tmComputeMapping(gamval, Lddyn, Ldmax);
        if (err != TM_E_OK)
                goto done;
                                        /* map pixels */
        err = tmMapPixels(*psp, lp, cp, *xp * *yp);

done:                                   /* clean up */
        free((MEM_PTR)lp);
        tmDone(NULL);
        if (err != TM_E_OK) {           /* free memory on error */
                free((MEM_PTR)*psp);
                *psp = NULL;
                *xp = *yp = 0;
                returnErr(err);
        }
        returnOK;
}
Revision:	3.3
Committed:	Sat Feb 22 02:07:28 2003 UTC (22 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 3.2:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	gwlarson	3.1	/* Copyright (c) 1998 Silicon Graphics, Inc. */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ SGI";
5			#endif
6
7			/*
8			* Perform tone mapping on TIFF input.
9			*/
10
11			#include <stdio.h>
12			#include "tiffio.h"
13			#include "tmprivat.h"
14
15
16			int
17			tmLoadTIFF(lpp, cpp, xp, yp, fname, tp) /* load and convert TIFF */
18			TMbright **lpp;
19			BYTE **cpp;
20			int xp, yp;
21			char *fname;
22			TIFF *tp;
23			{
24			char *funcName = fname==NULL ? "tmLoadTIFF" : fname;
25			TIFF *tif;
26			int err;
27	gwlarson	3.2	union {uint16 w; uint32 l; MEM_PTR p;} sl;
28	gwlarson	3.1	uint16 comp, phot, pconf;
29			uint32 width, height;
30			double stonits;
31			int y;
32			/* check arguments */
33			if (tmTop == NULL)
34			returnErr(TM_E_TMINVAL);
35			if (lpp == NULL \| xp == NULL \| yp == NULL \|
36			(fname == NULL & tp == NULL))
37			returnErr(TM_E_ILLEGAL);
38			/* check/get TIFF tags */
39			sl.p = NULL; *lpp = NULL;
40			if (cpp != TM_NOCHROMP) *cpp = TM_NOCHROM;
41			err = TM_E_BADFILE;
42			if ((tif = tp) == NULL && (tif = TIFFOpen(fname, "r")) == NULL)
43			returnErr(TM_E_BADFILE);
44			TIFFGetFieldDefaulted(tif, TIFFTAG_PHOTOMETRIC, &phot);
45			TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &comp);
46			if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) \|\|
47			!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))
48			goto done;
49			xp = width; yp = height;
50			TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &pconf);
51			if (pconf != PLANARCONFIG_CONTIG)
52			goto done;
53			if (!TIFFGetField(tif, TIFFTAG_STONITS, &stonits))
54			stonits = 1.;
55			if (phot == PHOTOMETRIC_LOGLUV) {
56			if (comp != COMPRESSION_SGILOG && comp != COMPRESSION_SGILOG24)
57			goto done;
58			TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_RAW);
59			sl.l = (uint32 )malloc(widthsizeof(uint32));
60			if (cpp != TM_NOCHROMP) {
61			cpp = (BYTE )malloc(widthheight3*sizeof(BYTE));
62			if (*cpp == NULL) {
63			err = TM_E_NOMEM;
64			goto done;
65			}
66			}
67			} else if (phot == PHOTOMETRIC_LOGL) {
68			if (comp != COMPRESSION_SGILOG)
69			goto done;
70			TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_16BIT);
71			sl.w = (uint16 )malloc(widthsizeof(uint16));
72			} else
73			goto done;
74			lpp = (TMbright )malloc(widthheightsizeof(TMbright));
75			if (sl.p == NULL \| *lpp == NULL) {
76			err = TM_E_NOMEM;
77			goto done;
78			}
79			/* set input color space */
80			tmSetSpace(TM_XYZPRIM, stonits);
81			/* read and convert each scanline */
82			for (y = 0; y < height; y++) {
83			if (TIFFReadScanline(tif, sl.p, y, 0) < 0) {
84			err = TM_E_BADFILE;
85			break;
86			}
87			if (phot == PHOTOMETRIC_LOGL)
88			err = tmCvL16(lpp + ywidth, sl.w, width);
89			else if (comp == COMPRESSION_SGILOG24)
90			err = tmCvLuv24(lpp + ywidth,
91			cpp==TM_NOCHROMP ? TM_NOCHROM : cpp+y3*width,
92			sl.l, width);
93			else
94			err = tmCvLuv32(lpp + ywidth,
95			cpp==TM_NOCHROMP ? TM_NOCHROM : cpp+y3*width,
96			sl.l, width);
97			if (err != TM_E_OK)
98			break;
99			}
100			done: /* clean up */
101			if (tp == NULL)
102			TIFFClose(tif);
103			if (sl.p != NULL)
104			free(sl.p);
105			if (err != TM_E_OK) { /* free buffers on error */
106			if (*lpp != NULL)
107			free((MEM_PTR)*lpp);
108			*lpp = NULL;
109			if (cpp != TM_NOCHROMP) {
110			if (*cpp != TM_NOCHROM)
111			free((MEM_PTR)*cpp);
112			*cpp = NULL;
113			}
114			xp = yp = 0;
115			returnErr(err);
116			}
117			returnOK;
118			}
119
120
121			/*
122			* Load and tone-map a SGILOG TIFF.
123			* Beware of greyscale input -- you must check the PHOTOMETRIC tag to
124			* determine that the returned array contains only grey values, not RGB.
125			* As in tmMapPicture(), grey values are also returned if flags&TM_F_BW.
126			*/
127			int
128			tmMapTIFF(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname, tp)
129			BYTE **psp;
130			int xp, yp;
131			int flags;
132			RGBPRIMP monpri;
133			double gamval, Lddyn, Ldmax;
134			char *fname;
135			TIFF *tp;
136			{
137			char *funcName = fname==NULL ? "tmMapTIFF" : fname;
138			TMbright *lp;
139			BYTE *cp;
140			int err;
141			/* check arguments */
142			if (psp == NULL \| xp == NULL \| yp == NULL \| monpri == NULL \|
143			(fname == NULL & tp == NULL))
144			returnErr(TM_E_ILLEGAL);
145			if (gamval < MINGAM) gamval = DEFGAM;
146			if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
147			if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
148			if (flags & TM_F_BW) monpri = stdprims;
149			/* initialize tone mapping */
150			if (tmInit(flags, monpri, gamval) == NULL)
151			returnErr(TM_E_NOMEM);
152			/* load and convert TIFF */
153			cp = TM_NOCHROM;
154			err = tmLoadTIFF(&lp, flags&TM_F_BW ? TM_NOCHROMP : &cp,
155			xp, yp, fname, tp);
156			if (err != TM_E_OK) {
157			tmDone(NULL);
158			return(err);
159			}
160			if (cp == TM_NOCHROM) {
161			psp = (BYTE )malloc(xp yp sizeof(BYTE));
162			if (*psp == NULL) {
163			free((MEM_PTR)lp);
164			tmDone(NULL);
165			returnErr(TM_E_NOMEM);
166			}
167			} else
168			*psp = cp;
169			/* compute color mapping */
170			err = tmAddHisto(lp, xp *yp, 1);
171			if (err != TM_E_OK)
172			goto done;
173			err = tmComputeMapping(gamval, Lddyn, Ldmax);
174			if (err != TM_E_OK)
175			goto done;
176			/* map pixels */
177			err = tmMapPixels(psp, lp, cp, xp * *yp);
178
179			done: /* clean up */
180			free((MEM_PTR)lp);
181			tmDone(NULL);
182			if (err != TM_E_OK) { /* free memory on error */
183			free((MEM_PTR)*psp);
184			*psp = NULL;
185			xp = yp = 0;
186			returnErr(err);
187			}
188			returnOK;
189			}