ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/px/ra_tiff.c

Comparing ray/src/px/ra_tiff.c (file contents):
Revision 2.4 by greg, Mon Jul 12 12:41:18 1993 UTC vs.
Revision 2.28 by schorsch, Sun Mar 28 20:33:14 2004 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1991 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	<	*  program to convert between RADIANCE and 24-bit TIFF files.
5	>	*  Program to convert between RADIANCE and TIFF files.
6	>	*  Added LogLuv encodings 7/97 (GWL).
7	>	*  Added white-balance adjustment 10/01 (GW).
8		*/
9
10		#include  <stdio.h>
12	–
11		#include  <math.h>
12	+	#include  <ctype.h>
13	+	#include  <time.h>
14	+	#include  <string.h>
15
16		#include  "tiffio.h"
16	–
17		#include  "color.h"
18	–
18		#include  "resolu.h"
19
20	+	#define  GAMCOR         2.2             /* default gamma */
21
22	<	extern char  *malloc(), *realloc();
22	>	/* conversion flags */
23	>	#define C_CXFM          0x1             /* needs color transformation */
24	>	#define C_GAMUT         0x2             /* needs gamut mapping */
25	>	#define C_GAMMA         0x4             /* needs gamma correction */
26	>	#define C_GRY           0x8             /* TIFF is greyscale */
27	>	#define C_XYZE          0x10            /* Radiance is XYZE */
28	>	#define C_RFLT          0x20            /* Radiance data is float */
29	>	#define C_TFLT          0x40            /* TIFF data is float */
30	>	#define C_TWRD          0x80            /* TIFF data is 16-bit */
31	>	#define C_PRIM          0x100           /* has assigned primaries */
32
33	<	int  lzcomp = 0;                        /* use Lempel-Ziv compression? */
33	>	typedef void colcvf_t(uint32 y);
34
35	<	int  greyscale = 0;                     /* produce greyscale image? */
35	>	struct {
36	>	uint16  flags;          /* conversion flags (defined above) */
37	>	char    capdate[20];    /* capture date/time */
38	>	char    owner[256];     /* content owner */
39	>	uint16  comp;           /* TIFF compression type */
40	>	uint16  phot;           /* TIFF photometric type */
41	>	uint16  pconf;          /* TIFF planar configuration */
42	>	float   gamcor;         /* gamma correction value */
43	>	short   bradj;          /* Radiance exposure adjustment (stops) */
44	>	uint16  orient;         /* visual orientation (TIFF spec.) */
45	>	double  stonits;        /* input conversion to nits */
46	>	float   pixrat;         /* pixel aspect ratio */
47	>	FILE    *rfp;           /* Radiance stream pointer */
48	>	TIFF    *tif;           /* TIFF pointer */
49	>	uint32  xmax, ymax;     /* image dimensions */
50	>	COLORMAT        cmat;   /* color transformation matrix */
51	>	RGBPRIMS        prims;  /* RGB primaries */
52	>	union {
53	>	COLR    *colrs;         /* 4-byte ???E pointer */
54	>	COLOR   *colors;        /* float array pointer */
55	>	char    *p;             /* generic pointer */
56	>	} r;                    /* Radiance scanline */
57	>	union {
58	>	uint8   *bp;            /* byte pointer */
59	>	uint16  *wp;            /* word pointer */
60	>	float   *fp;            /* float pointer */
61	>	char    *p;             /* generic pointer */
62	>	} t;                    /* TIFF scanline */
63	>	colcvf_t *tf;   /* translation procedure */
64	>	}       cvts = {        /* conversion structure */
65	>	0, "", "", COMPRESSION_NONE, PHOTOMETRIC_RGB,
66	>	PLANARCONFIG_CONTIG, GAMCOR, 0, 1, 1., 1.,
67	>	};
68
69	<	double  gamcor = 2.2;                   /* gamma correction */
69	>	#define CHK(f)          (cvts.flags & (f))
70	>	#define SET(f)          (cvts.flags |= (f))
71	>	#define CLR(f)          (cvts.flags &= ~(f))
72	>	#define TGL(f)          (cvts.flags ^= (f))
73
74	<	int  bradj = 0;                         /* brightness adjustment */
74	>	static colcvf_t Luv2Color, L2Color, RGB2Colr, Gry2Colr;
75	>	static colcvf_t Color2Luv, Color2L, Colr2RGB, Colr2Gry;
76	>	static colcvf_t RRGGBB2Color, GGry2Color, Color2RRGGBB, Color2GGry;
77
78	+	static gethfunc headline;
79	+	static void quiterr(char *err);
80	+	static void allocbufs(void);
81	+	static void initfromtif(void);
82	+	static void tiff2ra(int  ac, char  *av[]);
83	+	static void initfromrad(void);
84	+	static void ra2tiff(int  ac, char  *av[]);
85	+
86	+
87	+
88	+	#define RfGfBf2Color    Luv2Color
89	+	#define Gryf2Color      L2Color
90	+	#define Color2Gryf      Color2L
91	+	#define Color2RfGfBf    Color2Luv
92	+
93	+	short   ortab[8] = {            /* orientation conversion table */
94	+	YMAJOR|YDECR,
95	+	YMAJOR|YDECR|XDECR,
96	+	YMAJOR|XDECR,
97	+	YMAJOR,
98	+	YDECR,
99	+	XDECR|YDECR,
100	+	XDECR,
101	+	0
102	+	};
103	+
104	+	#define pixorder()      ortab[cvts.orient-1]
105	+
106	+	extern char     TMSTR[];        /* "CAPDATE=" from header.c */
107	+	char            OWNSTR[] = "OWNER=";
108	+
109		char  *progname;
110
111
112	<	main(argc, argv)
113	<	int  argc;
37	<	char  *argv[];
112	>	int
113	>	main(int  argc, char  *argv[])
114		{
115		int  reverse = 0;
116		int  i;
#	Line 44 | Line 120 | char  *argv[];
120		for (i = 1; i < argc; i++)
121		if (argv[i][0] == '-')
122		switch (argv[i][1]) {
123	<	case 'g':
124	<	gamcor = atof(argv[++i]);
123	>	case 'g':               /* gamma correction */
124	>	cvts.gamcor = atof(argv[++i]);
125		break;
126	<	case 'z':
127	<	lzcomp = !lzcomp;
126	>	case 'x':               /* XYZE Radiance output */
127	>	TGL(C_XYZE);
128		break;
129	<	case 'b':
130	<	greyscale = !greyscale;
129	>	case 'z':               /* LZW compressed output */
130	>	cvts.comp = COMPRESSION_LZW;
131		break;
132	<	case 'e':
132	>	case 'L':               /* LogLuv 32-bit output */
133	>	cvts.comp = COMPRESSION_SGILOG;
134	>	cvts.phot = PHOTOMETRIC_LOGLUV;
135	>	break;
136	>	case 'l':               /* LogLuv 24-bit output */
137	>	cvts.comp = COMPRESSION_SGILOG24;
138	>	cvts.phot = PHOTOMETRIC_LOGLUV;
139	>	break;
140	>	case 'w':               /* 16-bit/primary output? */
141	>	TGL(C_TWRD);
142	>	break;
143	>	case 'f':               /* IEEE float output? */
144	>	TGL(C_TFLT);
145	>	break;
146	>	case 'b':               /* greyscale output? */
147	>	TGL(C_GRY);
148	>	break;
149	>	case 'e':               /* exposure adjustment */
150		if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
151		goto userr;
152	<	bradj = atoi(argv[++i]);
152	>	cvts.bradj = atoi(argv[++i]);
153		break;
154	<	case 'r':
154	>	case 'r':               /* reverse conversion? */
155		reverse = !reverse;
156		break;
157		case '\0':
#	Line 69 | Line 162 | char  *argv[];
162		else
163		break;
164		doneopts:
165	<	setcolrgam(gamcor);
165	>	if (reverse) {
166
74	–	if (reverse)
167		if (i != argc-2 && i != argc-1)
168		goto userr;
169	<	else
170	<	tiff2ra(argv[i], argv[i+1]);
171	<	else
169	>
170	>	tiff2ra(i, argv);
171	>
172	>	} else {
173	>
174		if (i != argc-2)
175		goto userr;
176	<	else
177	<	ra2tiff(argv[i], argv[i+1]);
176	>	/* consistency checks */
177	>	if (CHK(C_GRY)) {
178	>	if (cvts.phot == PHOTOMETRIC_RGB)
179	>	cvts.phot = PHOTOMETRIC_MINISBLACK;
180	>	else {
181	>	cvts.phot = PHOTOMETRIC_LOGL;
182	>	cvts.comp = COMPRESSION_SGILOG;
183	>	}
184	>	}
185	>	if (CHK(C_TWRD|C_TFLT) == (C_TWRD|C_TFLT))
186	>	goto userr;
187
188	+	ra2tiff(i, argv);
189	+	}
190	+
191		exit(0);
192		userr:
193		fprintf(stderr,
194	<	"Usage: %s [-r][-b][-z][-e +/-stops][-g gamma] input output\n",
194	>	"Usage: %s [-z|-L|-l|-f|-w][-b][-e +/-stops][-g gamma] {in.pic|-} out.tif\n",
195		progname);
196	+	fprintf(stderr,
197	+	"   Or: %s -r [-x][-e +/-stops][-g gamma] in.tif [out.pic|-]\n",
198	+	progname);
199		exit(1);
200		}
201
202
203	<	quiterr(err)            /* print message and exit */
204	<	char  *err;
203	>	static void
204	>	quiterr(                /* print message and exit */
205	>	char  *err
206	>	)
207		{
208		if (err != NULL) {
209		fprintf(stderr, "%s: %s\n", progname, err);
#	Line 102 | Line 213 | char  *err;
213		}
214
215
216	<	tiff2ra(inpf, outf)     /* convert TIFF file to Radiance picture */
217	<	char    *inpf, *outf;
216	>	static void
217	>	allocbufs(void)                 /* allocate scanline buffers */
218		{
219	<	unsigned long   xmax, ymax;
220	<	TIFF    *tif;
221	<	unsigned short  pconfig, nsamps;
222	<	unsigned short  hi;
223	<	register BYTE   *scanin;
224	<	register COLR   *scanout;
225	<	register int    x;
226	<	int     y;
227	<	/* open/check  TIFF file */
228	<	if ((tif = TIFFOpen(inpf, "r")) == NULL)
229	<	quiterr("cannot open TIFF input");
230	<	if (!TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &nsamps) ||
231	<	(nsamps != 1 && nsamps != 3))
232	<	quiterr("unsupported samples per pixel");
233	<	if (!TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &hi) || hi != 8)
234	<	quiterr("unsupported bits per sample");
235	<	if (TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &hi) &&
236	<	hi != (nsamps==1 ? 1 : 2))
237	<	quiterr("unsupported photometric interpretation");
238	<	if (!TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &pconfig) ||
239	<	(pconfig != 1 && pconfig != 2))
240	<	quiterr("unsupported planar configuration");
241	<	if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &xmax) ||
242	<	!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &ymax))
219	>	int     rsiz, tsiz;
220	>
221	>	rsiz = CHK(C_RFLT) ? sizeof(COLOR) : sizeof(COLR);
222	>	tsiz = (CHK(C_TFLT) ? sizeof(float) :
223	>	CHK(C_TWRD) ? sizeof(uint16) : sizeof(uint8)) *
224	>	(CHK(C_GRY) ? 1 : 3);
225	>	cvts.r.p = (char *)malloc(rsiz*cvts.xmax);
226	>	cvts.t.p = (char *)malloc(tsiz*cvts.xmax);
227	>	if ((cvts.r.p == NULL) | (cvts.t.p == NULL))
228	>	quiterr("no memory to allocate scanline buffers");
229	>	}
230	>
231	>
232	>	static void
233	>	initfromtif(void)               /* initialize conversion from TIFF input */
234	>	{
235	>	uint16  hi;
236	>	char    *cp;
237	>	float   *fa, f1, f2;
238	>
239	>	CLR(C_GRY|C_GAMMA|C_PRIM|C_RFLT|C_TFLT|C_TWRD|C_CXFM);
240	>
241	>	TIFFGetFieldDefaulted(cvts.tif, TIFFTAG_PLANARCONFIG, &cvts.pconf);
242	>
243	>	if (TIFFGetField(cvts.tif, TIFFTAG_PRIMARYCHROMATICITIES, &fa)) {
244	>	cvts.prims[RED][CIEX] = fa[0];
245	>	cvts.prims[RED][CIEY] = fa[1];
246	>	cvts.prims[GRN][CIEX] = fa[2];
247	>	cvts.prims[GRN][CIEY] = fa[3];
248	>	cvts.prims[BLU][CIEX] = fa[4];
249	>	cvts.prims[BLU][CIEY] = fa[5];
250	>	cvts.prims[WHT][CIEX] = 1./3.;
251	>	cvts.prims[WHT][CIEY] = 1./3.;
252	>	if (TIFFGetField(cvts.tif, TIFFTAG_WHITEPOINT, &fa)) {
253	>	cvts.prims[WHT][CIEX] = fa[0];
254	>	cvts.prims[WHT][CIEY] = fa[1];
255	>	}
256	>	SET(C_PRIM);
257	>	}
258	>
259	>	if (!TIFFGetField(cvts.tif, TIFFTAG_COMPRESSION, &cvts.comp))
260	>	cvts.comp = COMPRESSION_NONE;
261	>
262	>	if (TIFFGetField(cvts.tif, TIFFTAG_XRESOLUTION, &f1) &&
263	>	TIFFGetField(cvts.tif, TIFFTAG_YRESOLUTION, &f2))
264	>	cvts.pixrat = f1/f2;
265	>
266	>	TIFFGetFieldDefaulted(cvts.tif, TIFFTAG_ORIENTATION, &cvts.orient);
267	>
268	>	if (!TIFFGetFieldDefaulted(cvts.tif, TIFFTAG_PHOTOMETRIC, &cvts.phot))
269	>	quiterr("TIFF has unspecified photometric type");
270	>
271	>	switch (cvts.phot) {
272	>	case PHOTOMETRIC_LOGLUV:
273	>	SET(C_RFLT|C_TFLT);
274	>	if (!CHK(C_XYZE)) {
275	>	cpcolormat(cvts.cmat, xyz2rgbmat);
276	>	SET(C_CXFM|C_GAMUT);
277	>	} else if (cvts.comp == COMPRESSION_SGILOG)
278	>	SET(C_GAMUT);
279	>	if (cvts.pconf != PLANARCONFIG_CONTIG)
280	>	quiterr("cannot handle separate Luv planes");
281	>	TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
282	>	SGILOGDATAFMT_FLOAT);
283	>	cvts.tf = Luv2Color;
284	>	break;
285	>	case PHOTOMETRIC_LOGL:
286	>	SET(C_GRY|C_RFLT|C_TFLT|C_GAMUT);
287	>	cvts.pconf = PLANARCONFIG_CONTIG;
288	>	TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
289	>	SGILOGDATAFMT_FLOAT);
290	>	cvts.tf = L2Color;
291	>	break;
292	>	case PHOTOMETRIC_YCBCR:
293	>	if (cvts.comp == COMPRESSION_JPEG &&
294	>	cvts.pconf == PLANARCONFIG_CONTIG) {
295	>	TIFFSetField(cvts.tif, TIFFTAG_JPEGCOLORMODE,
296	>	JPEGCOLORMODE_RGB);
297	>	cvts.phot = PHOTOMETRIC_RGB;
298	>	} else
299	>	quiterr("unsupported photometric type");
300	>	/* fall through */
301	>	case PHOTOMETRIC_RGB:
302	>	SET(C_GAMMA);
303	>	setcolrgam(cvts.gamcor);
304	>	if (CHK(C_XYZE)) {
305	>	comprgb2xyzWBmat(cvts.cmat,
306	>	CHK(C_PRIM) ? cvts.prims : stdprims);
307	>	SET(C_CXFM);
308	>	}
309	>	if (!TIFFGetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, &hi) ||
310	>	hi != 3)
311	>	quiterr("unsupported samples per pixel for RGB");
312	>	if (!TIFFGetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, &hi))
313	>	hi = -1;
314	>	switch (hi) {
315	>	case 8:
316	>	cvts.tf = RGB2Colr;
317	>	break;
318	>	case 16:
319	>	cvts.tf = RRGGBB2Color;
320	>	SET(C_RFLT|C_TWRD);
321	>	break;
322	>	case 32:
323	>	cvts.tf = RfGfBf2Color;
324	>	SET(C_RFLT|C_TFLT);
325	>	break;
326	>	default:
327	>	quiterr("unsupported bits per sample for RGB");
328	>	}
329	>	break;
330	>	case PHOTOMETRIC_MINISBLACK:
331	>	SET(C_GRY|C_GAMMA);
332	>	setcolrgam(cvts.gamcor);
333	>	cvts.pconf = PLANARCONFIG_CONTIG;
334	>	if (!TIFFGetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, &hi) ||
335	>	hi != 1)
336	>	quiterr("unsupported samples per pixel for greyscale");
337	>	if (!TIFFGetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, &hi))
338	>	hi = -1;
339	>	switch (hi) {
340	>	case 8:
341	>	cvts.tf = Gry2Colr;
342	>	break;
343	>	case 16:
344	>	cvts.tf = GGry2Color;
345	>	SET(C_RFLT|C_TWRD);
346	>	break;
347	>	case 32:
348	>	cvts.tf = Gryf2Color;
349	>	SET(C_RFLT|C_TFLT);
350	>	break;
351	>	default:
352	>	quiterr("unsupported bits per sample for Gray");
353	>	}
354	>	break;
355	>	default:
356	>	quiterr("unsupported photometric type");
357	>	break;
358	>	}
359	>
360	>	if (!TIFFGetField(cvts.tif, TIFFTAG_IMAGEWIDTH, &cvts.xmax) ||
361	>	!TIFFGetField(cvts.tif, TIFFTAG_IMAGELENGTH, &cvts.ymax))
362		quiterr("unknown input image resolution");
363	<	/* allocate scanlines */
364	<	scanin = (BYTE *)malloc(TIFFScanlineSize(tif));
365	<	scanout = (COLR *)malloc(xmax*sizeof(COLR));
366	<	if (scanin == NULL || scanout == NULL)
367	<	quiterr("out of memory in tiff2ra");
368	<	/* open output and write header */
369	<	if (outf != NULL && strcmp(outf, "-") &&
370	<	freopen(outf, "w", stdout) == NULL)
371	<	quiterr("cannot open Radiance output file");
372	<	fputs(progname, stdout);
373	<	if (bradj)
374	<	printf(" -e %+d", bradj);
375	<	fputs(" -r\n", stdout);
376	<	fputformat(COLRFMT, stdout);
377	<	putchar('\n');
378	<	fprtresolu(xmax, ymax, stdout);
379	<	/* convert image */
380	<	if (nsamps == 1)
381	<	pconfig = 1;
382	<	for (y = 0; y < ymax; y++) {
383	<	if (pconfig == 1) {
384	<	if (TIFFReadScanline(tif, scanin, y, 0) < 0)
385	<	goto readerr;
386	<	if (nsamps == 1)
387	<	for (x = 0; x < xmax; x++)
388	<	scanout[x][RED] =
389	<	scanout[x][GRN] =
390	<	scanout[x][BLU] = scanin[x];
391	<	else
392	<	for (x = 0; x < xmax; x++) {
393	<	scanout[x][RED] = scanin[3*x];
394	<	scanout[x][GRN] = scanin[3*x+1];
395	<	scanout[x][BLU] = scanin[3*x+2];
396	<	}
397	<	} else {
398	<	if (TIFFReadScanline(tif, scanin, y, 0) < 0)
399	<	goto readerr;
400	<	for (x = 0; x < xmax; x++)
401	<	scanout[x][RED] = scanin[x];
402	<	if (TIFFReadScanline(tif, scanin, y, 1) < 0)
403	<	goto readerr;
404	<	for (x = 0; x < xmax; x++)
405	<	scanout[x][GRN] = scanin[x];
406	<	if (TIFFReadScanline(tif, scanin, y, 2) < 0)
407	<	goto readerr;
408	<	for (x = 0; x < xmax; x++)
409	<	scanout[x][BLU] = scanin[x];
363	>
364	>	if (!TIFFGetField(cvts.tif, TIFFTAG_STONITS, &cvts.stonits))
365	>	cvts.stonits = 1.;
366	>
367	>	if (!TIFFGetField(cvts.tif, TIFFTAG_DATETIME, &cp))
368	>	cvts.capdate[0] = '\0';
369	>	else {
370	>	strncpy(cvts.capdate, cp, 19);
371	>	cvts.capdate[19] = '\0';
372	>	}
373	>	if (!TIFFGetField(cvts.tif, TIFFTAG_ARTIST, &cp))
374	>	cvts.owner[0] = '\0';
375	>	else {
376	>	strncpy(cvts.owner, cp, sizeof(cvts.owner));
377	>	cvts.owner[sizeof(cvts.owner)-1] = '\0';
378	>	}
379	>	/* add to Radiance header */
380	>	if (cvts.pixrat < .99 || cvts.pixrat > 1.01)
381	>	fputaspect(cvts.pixrat, cvts.rfp);
382	>	if (CHK(C_XYZE)) {
383	>	fputexpos(pow(2.,(double)cvts.bradj)/cvts.stonits, cvts.rfp);
384	>	fputformat(CIEFMT, cvts.rfp);
385	>	} else {
386	>	if (CHK(C_PRIM))
387	>	fputprims(cvts.prims, cvts.rfp);
388	>	fputexpos(WHTEFFICACY*pow(2.,(double)cvts.bradj)/cvts.stonits,
389	>	cvts.rfp);
390	>	fputformat(COLRFMT, cvts.rfp);
391	>	}
392	>	if (cvts.capdate[0])
393	>	fprintf(cvts.rfp, "%s %s\n", TMSTR, cvts.capdate);
394	>	if (cvts.owner[0])
395	>	fprintf(cvts.rfp, "%s %s\n", OWNSTR, cvts.owner);
396	>
397	>	allocbufs();                    /* allocate scanline buffers */
398	>	}
399	>
400	>
401	>	static void
402	>	tiff2ra(                /* convert TIFF image to Radiance picture */
403	>	int  ac,
404	>	char  *av[]
405	>	)
406	>	{
407	>	int32   y;
408	>	/* open TIFF input */
409	>	if ((cvts.tif = TIFFOpen(av[ac], "r")) == NULL)
410	>	quiterr("cannot open TIFF input");
411	>	/* open Radiance output */
412	>	if (av[ac+1] == NULL || !strcmp(av[ac+1], "-"))
413	>	cvts.rfp = stdout;
414	>	else if ((cvts.rfp = fopen(av[ac+1], "w")) == NULL)
415	>	quiterr("cannot open Radiance output picture");
416	>	/* start output header */
417	>	newheader("RADIANCE", cvts.rfp);
418	>	printargs(ac, av, cvts.rfp);
419	>
420	>	initfromtif();                  /* initialize conversion */
421	>
422	>	fputc('\n', cvts.rfp);          /* finish Radiance header */
423	>	fputresolu(pixorder(), (int)cvts.xmax, (int)cvts.ymax, cvts.rfp);
424	>
425	>	for (y = 0; y < cvts.ymax; y++)         /* convert image */
426	>	(*cvts.tf)(y);
427	>	/* clean up */
428	>	fclose(cvts.rfp);
429	>	TIFFClose(cvts.tif);
430	>	}
431	>
432	>
433	>	static int
434	>	headline(                       /* process Radiance input header line */
435	>	char    *s,
436	>	void    *p
437	>	)
438	>	{
439	>	static int      tmstrlen = 0;
440	>	static int      ownstrlen = 0;
441	>	char    fmt[32];
442	>
443	>	if (!tmstrlen)
444	>	tmstrlen = strlen(TMSTR);
445	>	if (!ownstrlen)
446	>	ownstrlen = strlen(OWNSTR);
447	>	if (formatval(fmt, s)) {
448	>	if (!strcmp(fmt, COLRFMT))
449	>	CLR(C_XYZE);
450	>	else if (!strcmp(fmt, CIEFMT))
451	>	SET(C_XYZE);
452	>	else
453	>	quiterr("unrecognized input picture format");
454	>	return(1);
455	>	}
456	>	if (isexpos(s)) {
457	>	cvts.stonits /= exposval(s);
458	>	return(1);
459	>	}
460	>	if (isaspect(s)) {
461	>	cvts.pixrat *= aspectval(s);
462	>	return(1);
463	>	}
464	>	if (isprims(s)) {
465	>	primsval(cvts.prims, s);
466	>	SET(C_PRIM);
467	>	return(1);
468	>	}
469	>	if (isdate(s)) {
470	>	if (s[tmstrlen] == ' ')
471	>	strncpy(cvts.capdate, s+tmstrlen+1, 19);
472	>	else
473	>	strncpy(cvts.capdate, s+tmstrlen, 19);
474	>	cvts.capdate[19] = '\0';
475	>	return(1);
476	>	}
477	>	if (!strncmp(s, OWNSTR, ownstrlen)) {
478	>	register char   *cp = s + ownstrlen;
479	>
480	>	while (isspace(*cp))
481	>	++cp;
482	>	strncpy(cvts.owner, cp, sizeof(cvts.owner));
483	>	cvts.owner[sizeof(cvts.owner)-1] = '\0';
484	>	for (cp = cvts.owner; *cp; cp++)
485	>	;
486	>	while (cp > cvts.owner && isspace(cp[-1]))
487	>	*--cp = '\0';
488	>	return(1);
489	>	}
490	>	return(0);
491	>	}
492	>
493	>
494	>	static void
495	>	initfromrad(void)                       /* initialize input from a Radiance picture */
496	>	{
497	>	int     i1, i2, po;
498	>	/* read Radiance header */
499	>	CLR(C_RFLT|C_XYZE|C_PRIM|C_GAMMA|C_CXFM);
500	>	cvts.capdate[0] = '\0';
501	>	cvts.owner[0] = '\0';
502	>	cvts.stonits = 1.;
503	>	cvts.pixrat = 1.;
504	>	cvts.pconf = PLANARCONFIG_CONTIG;
505	>	getheader(cvts.rfp, headline, NULL);
506	>	if ((po = fgetresolu(&i1, &i2, cvts.rfp)) < 0)
507	>	quiterr("bad Radiance picture");
508	>	cvts.xmax = i1; cvts.ymax = i2;
509	>	for (i1 = 0; i1 < 8; i1++)              /* interpret orientation */
510	>	if (ortab[i1] == po) {
511	>	cvts.orient = i1 + 1;
512	>	break;
513		}
514	<	gambs_colrs(scanout, xmax);
515	<	if (bradj)
516	<	shiftcolrs(scanout, xmax, bradj);
517	<	if (fwritecolrs(scanout, xmax, stdout) < 0)
518	<	quiterr("error writing Radiance picture");
514	>	if (i1 >= 8)
515	>	quiterr("internal error 1 in initfromrad");
516	>	if (!(po & YMAJOR))
517	>	cvts.pixrat = 1./cvts.pixrat;
518	>	if (!CHK(C_XYZE))
519	>	cvts.stonits *= WHTEFFICACY;
520	>	/* set up conversion */
521	>	TIFFSetField(cvts.tif, TIFFTAG_COMPRESSION, cvts.comp);
522	>	TIFFSetField(cvts.tif, TIFFTAG_PHOTOMETRIC, cvts.phot);
523	>
524	>	switch (cvts.phot) {
525	>	case PHOTOMETRIC_LOGLUV:
526	>	SET(C_RFLT|C_TFLT);
527	>	CLR(C_GRY|C_TWRD);
528	>	if (!CHK(C_XYZE)) {
529	>	comprgb2xyzWBmat(cvts.cmat,
530	>	CHK(C_PRIM) ? cvts.prims : stdprims);
531	>	SET(C_CXFM);
532	>	}
533	>	if (cvts.comp != COMPRESSION_SGILOG &&
534	>	cvts.comp != COMPRESSION_SGILOG24)
535	>	quiterr("internal error 2 in initfromrad");
536	>	TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
537	>	SGILOGDATAFMT_FLOAT);
538	>	cvts.tf = Color2Luv;
539	>	break;
540	>	case PHOTOMETRIC_LOGL:
541	>	SET(C_GRY|C_RFLT|C_TFLT);
542	>	CLR(C_TWRD);
543	>	if (cvts.comp != COMPRESSION_SGILOG)
544	>	quiterr("internal error 3 in initfromrad");
545	>	TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
546	>	SGILOGDATAFMT_FLOAT);
547	>	cvts.tf = Color2L;
548	>	break;
549	>	case PHOTOMETRIC_RGB:
550	>	SET(C_GAMMA|C_GAMUT);
551	>	CLR(C_GRY);
552	>	setcolrgam(cvts.gamcor);
553	>	if (CHK(C_XYZE)) {
554	>	compxyz2rgbWBmat(cvts.cmat,
555	>	CHK(C_PRIM) ? cvts.prims : stdprims);
556	>	SET(C_CXFM);
557	>	}
558	>	if (CHK(C_PRIM)) {
559	>	TIFFSetField(cvts.tif, TIFFTAG_PRIMARYCHROMATICITIES,
560	>	(float *)cvts.prims);
561	>	TIFFSetField(cvts.tif, TIFFTAG_WHITEPOINT,
562	>	(float *)cvts.prims[WHT]);
563	>	}
564	>	if (CHK(C_TWRD)) {
565	>	cvts.tf = Color2RRGGBB;
566	>	SET(C_RFLT);
567	>	} else if (CHK(C_TFLT)) {
568	>	TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
569	>	SAMPLEFORMAT_IEEEFP);
570	>	cvts.tf = Color2RfGfBf;
571	>	SET(C_RFLT);
572	>	} else
573	>	cvts.tf = Colr2RGB;
574	>	break;
575	>	case PHOTOMETRIC_MINISBLACK:
576	>	SET(C_GRY|C_GAMMA|C_GAMUT);
577	>	setcolrgam(cvts.gamcor);
578	>	if (CHK(C_TWRD)) {
579	>	cvts.tf = Color2GGry;
580	>	SET(C_RFLT);
581	>	} else if (CHK(C_TFLT)) {
582	>	TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
583	>	SAMPLEFORMAT_IEEEFP);
584	>	cvts.tf = Color2Gryf;
585	>	SET(C_RFLT);
586	>	} else
587	>	cvts.tf = Colr2Gry;
588	>	break;
589	>	default:
590	>	quiterr("internal error 4 in initfromrad");
591	>	break;
592		}
593	+	/* set other TIFF fields */
594	+	TIFFSetField(cvts.tif, TIFFTAG_IMAGEWIDTH, cvts.xmax);
595	+	TIFFSetField(cvts.tif, TIFFTAG_IMAGELENGTH, cvts.ymax);
596	+	TIFFSetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, CHK(C_GRY) ? 1 : 3);
597	+	TIFFSetField(cvts.tif, TIFFTAG_BITSPERSAMPLE,
598	+	CHK(C_TFLT) ? 32 : CHK(C_TWRD) ? 16 : 8);
599	+	TIFFSetField(cvts.tif, TIFFTAG_XRESOLUTION, 72.);
600	+	TIFFSetField(cvts.tif, TIFFTAG_YRESOLUTION, 72./cvts.pixrat);
601	+	TIFFSetField(cvts.tif, TIFFTAG_ORIENTATION, cvts.orient);
602	+	TIFFSetField(cvts.tif, TIFFTAG_RESOLUTIONUNIT, 2);
603	+	TIFFSetField(cvts.tif, TIFFTAG_PLANARCONFIG, cvts.pconf);
604	+	TIFFSetField(cvts.tif, TIFFTAG_STONITS,
605	+	cvts.stonits/pow(2.,(double)cvts.bradj));
606	+	if (cvts.capdate[0])
607	+	TIFFSetField(cvts.tif, TIFFTAG_DATETIME, cvts.capdate);
608	+	if (cvts.owner[0])
609	+	TIFFSetField(cvts.tif, TIFFTAG_ARTIST, cvts.owner);
610	+	if (cvts.comp == COMPRESSION_NONE)
611	+	i1 = TIFFScanlineSize(cvts.tif);
612	+	else
613	+	i1 = 3*cvts.xmax;       /* conservative guess */
614	+	i2 = 8192/i1;                           /* compute good strip size */
615	+	if (i2 < 1) i2 = 1;
616	+	TIFFSetField(cvts.tif, TIFFTAG_ROWSPERSTRIP, (uint32)i2);
617	+
618	+	allocbufs();                            /* allocate scanline buffers */
619	+	}
620	+
621	+
622	+	static void
623	+	ra2tiff(                /* convert Radiance picture to TIFF image */
624	+	int  ac,
625	+	char  *av[]
626	+	)
627	+	{
628	+	uint32  y;
629	+	/* open Radiance file */
630	+	if (!strcmp(av[ac], "-"))
631	+	cvts.rfp = stdin;
632	+	else if ((cvts.rfp = fopen(av[ac], "r")) == NULL)
633	+	quiterr("cannot open Radiance input picture");
634	+	/* open TIFF file */
635	+	if ((cvts.tif = TIFFOpen(av[ac+1], "w")) == NULL)
636	+	quiterr("cannot open TIFF output");
637	+
638	+	initfromrad();                          /* initialize conversion */
639	+
640	+	for (y = 0; y < cvts.ymax; y++)         /* convert image */
641	+	(*cvts.tf)(y);
642		/* clean up */
643	<	free((char *)scanin);
644	<	free((char *)scanout);
645	<	TIFFClose(tif);
643	>	TIFFClose(cvts.tif);
644	>	fclose(cvts.rfp);
645	>	}
646	>
647	>
648	>	static void
649	>	Luv2Color(                      /* read/convert/write Luv->COLOR scanline */
650	>	uint32  y
651	>	)
652	>	{
653	>	register int    x;
654	>
655	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != (C_RFLT|C_TFLT))
656	>	quiterr("internal error 1 in Luv2Color");
657	>
658	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
659	>	quiterr("error reading TIFF input");
660	>	/* also works for float RGB */
661	>	for (x = cvts.xmax; x--; ) {
662	>	setcolor(cvts.r.colors[x],
663	>	cvts.t.fp[3*x],
664	>	cvts.t.fp[3*x + 1],
665	>	cvts.t.fp[3*x + 2]);
666	>	if (CHK(C_CXFM))
667	>	colortrans(cvts.r.colors[x], cvts.cmat,
668	>	cvts.r.colors[x]);
669	>	if (CHK(C_GAMUT))
670	>	clipgamut(cvts.r.colors[x], cvts.t.fp[3*x + 1],
671	>	CGAMUT_LOWER, cblack, cwhite);
672	>	}
673	>	if (cvts.bradj) {
674	>	double  m = pow(2.,(double)cvts.bradj);
675	>	for (x = cvts.xmax; x--; )
676	>	scalecolor(cvts.r.colors[x], m);
677	>	}
678	>
679	>	if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
680	>	quiterr("error writing Radiance picture");
681	>	}
682	>
683	>
684	>	static void
685	>	RRGGBB2Color(                   /* read/convert/write RGB16->COLOR scanline */
686	>	uint32  y
687	>	)
688	>	{
689	>	int     dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01);
690	>	register double d;
691	>	register int    x;
692	>
693	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != (C_TWRD|C_RFLT))
694	>	quiterr("internal error 1 in RRGGBB2Color");
695	>
696	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
697	>	quiterr("error reading TIFF input");
698	>
699	>	for (x = cvts.xmax; x--; ) {
700	>	d = (cvts.t.wp[3*x] + 0.5)*(1./(1L<<16));
701	>	if (dogamma) d = pow(d, cvts.gamcor);
702	>	colval(cvts.r.colors[x],RED) = d;
703	>	d = (cvts.t.wp[3*x + 1] + 0.5)*(1./(1L<<16));
704	>	if (dogamma) d = pow(d, cvts.gamcor);
705	>	colval(cvts.r.colors[x],GRN) = d;
706	>	d = (cvts.t.wp[3*x + 2] + 0.5)*(1./(1L<<16));
707	>	if (dogamma) d = pow(d, cvts.gamcor);
708	>	colval(cvts.r.colors[x],BLU) = d;
709	>	if (CHK(C_CXFM))
710	>	colortrans(cvts.r.colors[x], cvts.cmat,
711	>	cvts.r.colors[x]);
712	>	if (CHK(C_GAMUT))
713	>	clipgamut(cvts.r.colors[x], cvts.t.fp[3*x + 1],
714	>	CGAMUT_LOWER, cblack, cwhite);
715	>	}
716	>	if (cvts.bradj) {
717	>	d = pow(2.,(double)cvts.bradj);
718	>	for (x = cvts.xmax; x--; )
719	>	scalecolor(cvts.r.colors[x], d);
720	>	}
721	>
722	>	if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
723	>	quiterr("error writing Radiance picture");
724	>	}
725	>
726	>
727	>	static void
728	>	L2Color(                        /* read/convert/write Lfloat->COLOR scanline */
729	>	uint32  y
730	>	)
731	>	{
732	>	float   m = pow(2., (double)cvts.bradj);
733	>	register int    x;
734	>
735	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != (C_RFLT|C_TFLT|C_GRY))
736	>	quiterr("internal error 1 in L2Color");
737	>
738	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
739	>	quiterr("error reading TIFF input");
740	>	/* also works for float greyscale */
741	>	for (x = cvts.xmax; x--; ) {
742	>	register float  f = cvts.t.fp[x];
743	>	if (cvts.bradj) f *= m;
744	>	setcolor(cvts.r.colors[x], f, f, f);
745	>	}
746	>	if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
747	>	quiterr("error writing Radiance picture");
748	>	}
749	>
750	>
751	>	static void
752	>	RGB2Colr(                       /* read/convert/write RGB->COLR scanline */
753	>	uint32  y
754	>	)
755	>	{
756	>	COLOR   ctmp;
757	>	register int    x;
758	>
759	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY))
760	>	quiterr("internal error 1 in RGB2Colr");
761	>
762	>	if (cvts.pconf == PLANARCONFIG_CONTIG) {
763	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
764	>	goto readerr;
765	>	for (x = cvts.xmax; x--; ) {
766	>	cvts.r.colrs[x][RED] = cvts.t.bp[3*x];
767	>	cvts.r.colrs[x][GRN] = cvts.t.bp[3*x + 1];
768	>	cvts.r.colrs[x][BLU] = cvts.t.bp[3*x + 2];
769	>	}
770	>	} else {
771	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
772	>	goto readerr;
773	>	if (TIFFReadScanline(cvts.tif,
774	>	(tdata_t)(cvts.t.bp + cvts.xmax), y, 1) < 0)
775	>	goto readerr;
776	>	if (TIFFReadScanline(cvts.tif,
777	>	(tdata_t)(cvts.t.bp + 2*cvts.xmax), y, 2) < 0)
778	>	goto readerr;
779	>	for (x = cvts.xmax; x--; ) {
780	>	cvts.r.colrs[x][RED] = cvts.t.bp[x];
781	>	cvts.r.colrs[x][GRN] = cvts.t.bp[cvts.xmax + x];
782	>	cvts.r.colrs[x][BLU] = cvts.t.bp[2*cvts.xmax + x];
783	>	}
784	>	}
785	>
786	>	gambs_colrs(cvts.r.colrs, cvts.xmax);
787	>	if (CHK(C_CXFM))
788	>	for (x = cvts.xmax; x--; ) {
789	>	colr_color(ctmp, cvts.r.colrs[x]);
790	>	colortrans(ctmp, cvts.cmat, ctmp);
791	>	if (CHK(C_GAMUT))       /* !CHK(C_XYZE) */
792	>	clipgamut(ctmp, bright(ctmp), CGAMUT_LOWER,
793	>	cblack, cwhite);
794	>	setcolr(cvts.r.colrs[x], colval(ctmp,RED),
795	>	colval(ctmp,GRN), colval(ctmp,BLU));
796	>	}
797	>	if (cvts.bradj)
798	>	shiftcolrs(cvts.r.colrs, cvts.xmax, cvts.bradj);
799	>
800	>	if (fwritecolrs(cvts.r.colrs, cvts.xmax, cvts.rfp) < 0)
801	>	quiterr("error writing Radiance picture");
802		return;
803		readerr:
804		quiterr("error reading TIFF input");
805		}
806
807
808	<	ra2tiff(inpf, outf)             /* convert Radiance file to 24-bit TIFF */
809	<	char    *inpf, *outf;
808	>	static void
809	>	Gry2Colr(                       /* read/convert/write G8->COLR scanline */
810	>	uint32  y
811	>	)
812		{
200	–	TIFF    *tif;
201	–	int     xmax, ymax;
202	–	BYTE    *scanout;
203	–	COLR    *scanin;
813		register int    x;
814	<	int     y;
815	<	/* open Radiance file */
816	<	if (strcmp(inpf, "-") && freopen(inpf, "r", stdin) == NULL)
817	<	quiterr("cannot open Radiance input file");
818	<	if (checkheader(stdin, COLRFMT, NULL) < 0 ||
819	<	fgetresolu(&xmax, &ymax, stdin) < 0)
820	<	quiterr("bad Radiance picture");
821	<	/* open TIFF file */
822	<	if ((tif = TIFFOpen(outf, "w")) == NULL)
823	<	quiterr("cannot open TIFF output");
824	<	TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, (unsigned long)xmax);
825	<	TIFFSetField(tif, TIFFTAG_IMAGELENGTH, (unsigned long)ymax);
826	<	TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, greyscale ? 1 : 3);
827	<	TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
828	<	TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, greyscale ? 1 : 2);
829	<	TIFFSetField(tif, TIFFTAG_PLANARCONFIG, 1);
830	<	if (lzcomp)
831	<	TIFFSetField(tif, TIFFTAG_COMPRESSION, (unsigned short)5);
832	<	/* allocate scanlines */
833	<	scanin = (COLR *)malloc(xmax*sizeof(COLR));
834	<	scanout = (BYTE *)malloc(TIFFScanlineSize(tif));
835	<	if (scanin == NULL || scanout == NULL)
836	<	quiterr("out of memory in ra2tiff");
837	<	/* convert image */
838	<	for (y = 0; y < ymax; y++) {
839	<	if (freadcolrs(scanin, xmax, stdin) < 0)
840	<	quiterr("error reading Radiance picture");
841	<	if (bradj)
842	<	shiftcolrs(scanin, xmax, bradj);
843	<	if (greyscale) {
844	<	for (x = 0; x < xmax; x++)
845	<	scanin[x][GRN] = normbright(scanin[x]);
846	<	colrs_gambs(scanin, xmax);
847	<	for (x = 0; x < xmax; x++)
848	<	scanout[x] = scanin[x][GRN];
849	<	} else {
850	<	colrs_gambs(scanin, xmax);
851	<	for (x = 0; x < xmax; x++) {
852	<	scanout[3*x] = scanin[x][RED];
853	<	scanout[3*x+1] = scanin[x][GRN];
854	<	scanout[3*x+2] = scanin[x][BLU];
855	<	}
814	>
815	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != C_GRY)
816	>	quiterr("internal error 1 in Gry2Colr");
817	>
818	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
819	>	quiterr("error reading TIFF input");
820	>
821	>	for (x = cvts.xmax; x--; )
822	>	cvts.r.colrs[x][RED] =
823	>	cvts.r.colrs[x][GRN] =
824	>	cvts.r.colrs[x][BLU] = cvts.t.bp[x];
825	>
826	>	gambs_colrs(cvts.r.colrs, cvts.xmax);
827	>	if (cvts.bradj)
828	>	shiftcolrs(cvts.r.colrs, cvts.xmax, cvts.bradj);
829	>
830	>	if (fwritecolrs(cvts.r.colrs, cvts.xmax, cvts.rfp) < 0)
831	>	quiterr("error writing Radiance picture");
832	>	}
833	>
834	>
835	>	static void
836	>	GGry2Color(                     /* read/convert/write G16->COLOR scanline */
837	>	uint32  y
838	>	)
839	>	{
840	>	int     dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01);
841	>	double  m;
842	>	register double d;
843	>	register int    x;
844	>
845	>	if (CHK(C_TFLT|C_TWRD|C_GRY|C_RFLT) != (C_GRY|C_RFLT|C_TWRD))
846	>	quiterr("internal error 1 in GGry2Color");
847	>
848	>	if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
849	>	quiterr("error reading TIFF input");
850	>
851	>	if (cvts.bradj)
852	>	m = pow(2., (double)cvts.bradj);
853	>	for (x = cvts.xmax; x--; ) {
854	>	d = (cvts.t.wp[x] + 0.5)*(1./(1L<<16));
855	>	if (dogamma) d = pow(d, cvts.gamcor);
856	>	if (cvts.bradj) d *= m;
857	>	colval(cvts.r.colors[x],RED) =
858	>	colval(cvts.r.colors[x],GRN) =
859	>	colval(cvts.r.colors[x],BLU) = d;
860	>	}
861	>	if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
862	>	quiterr("error writing Radiance picture");
863	>	}
864	>
865	>
866	>	static void
867	>	Color2GGry(                     /* read/convert/write COLOR->G16 scanline */
868	>	uint32  y
869	>	)
870	>	{
871	>	int     dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01);
872	>	float   m = pow(2.,(double)cvts.bradj);
873	>	register int    x;
874	>
875	>	if (CHK(C_RFLT|C_TFLT|C_TWRD|C_GRY) != (C_RFLT|C_TWRD|C_GRY))
876	>	quiterr("internal error 1 in Color2GGry");
877	>
878	>	if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
879	>	quiterr("error reading Radiance picture");
880	>
881	>	for (x = cvts.xmax; x--; ) {
882	>	register float  f = m*( CHK(C_XYZE) ?
883	>	colval(cvts.r.colors[x],CIEY)
884	>	: bright(cvts.r.colors[x]) );
885	>	if (f <= 0)
886	>	cvts.t.wp[x] = 0;
887	>	else if (f >= 1)
888	>	cvts.t.wp[x] = 0xffff;
889	>	else if (dogamma)
890	>	cvts.t.wp[x] = (int)((float)(1L<<16) *
891	>	pow(f, 1./cvts.gamcor));
892	>	else
893	>	cvts.t.wp[x] = (int)((float)(1L<<16) * f);
894	>	}
895	>
896	>	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
897	>	quiterr("error writing TIFF output");
898	>	}
899	>
900	>
901	>	static void
902	>	Color2L(                        /* read/convert/write COLOR->Lfloat scanline */
903	>	uint32  y
904	>	)
905	>	{
906	>	float   m = pow(2.,(double)cvts.bradj);
907	>	register int    x;
908	>
909	>	if (CHK(C_RFLT|C_TFLT|C_TWRD|C_GRY) != (C_RFLT|C_TFLT|C_GRY))
910	>	quiterr("internal error 1 in Color2L");
911	>
912	>	if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
913	>	quiterr("error reading Radiance picture");
914	>
915	>	for (x = cvts.xmax; x--; )
916	>	cvts.t.fp[x] = m*( CHK(C_XYZE) ? colval(cvts.r.colors[x],CIEY)
917	>	: bright(cvts.r.colors[x]) );
918	>
919	>	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
920	>	quiterr("error writing TIFF output");
921	>	}
922	>
923	>
924	>	static void
925	>	Color2Luv(                      /* read/convert/write COLOR->Luv scanline */
926	>	uint32  y
927	>	)
928	>	{
929	>	register int    x;
930	>
931	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != (C_RFLT|C_TFLT))
932	>	quiterr("internal error 1 in Color2Luv");
933	>
934	>	if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
935	>	quiterr("error reading Radiance picture");
936	>
937	>	if (CHK(C_CXFM))
938	>	for (x = cvts.xmax; x--; )
939	>	colortrans(cvts.r.colors[x], cvts.cmat,
940	>	cvts.r.colors[x]);
941	>	if (cvts.bradj) {
942	>	double  m = pow(2.,(double)cvts.bradj);
943	>	for (x = cvts.xmax; x--; )
944	>	scalecolor(cvts.r.colors[x], m);
945	>	}
946	>	/* also works for float RGB */
947	>	for (x = cvts.xmax; x--; ) {
948	>	cvts.t.fp[3*x] = colval(cvts.r.colors[x],CIEX);
949	>	cvts.t.fp[3*x+1] = colval(cvts.r.colors[x],CIEY);
950	>	cvts.t.fp[3*x+2] = colval(cvts.r.colors[x],CIEZ);
951	>	}
952	>
953	>	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
954	>	quiterr("error writing TIFF output");
955	>	}
956	>
957	>
958	>	static void
959	>	Color2RRGGBB(                   /* read/convert/write COLOR->RGB16 scanline */
960	>	uint32  y
961	>	)
962	>	{
963	>	int     dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01);
964	>	float   m = pow(2.,(double)cvts.bradj);
965	>	register int    x, i;
966	>
967	>	if (CHK(C_RFLT|C_TFLT|C_TWRD|C_GRY) != (C_RFLT|C_TWRD))
968	>	quiterr("internal error 1 in Color2RRGGBB");
969	>
970	>	if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
971	>	quiterr("error reading Radiance picture");
972	>
973	>	for (x = cvts.xmax; x--; )
974	>	for (i = 3; i--; ) {
975	>	register float  f = m*colval(cvts.r.colors[x],i);
976	>	if (f <= 0)
977	>	cvts.t.wp[3*x + i] = 0;
978	>	else if (f >= 1)
979	>	cvts.t.wp[3*x + i] = 0xffff;
980	>	else if (dogamma)
981	>	cvts.t.wp[3*x + i] = (int)((float)(1L<<16) *
982	>	pow(f, 1./cvts.gamcor));
983	>	else
984	>	cvts.t.wp[3*x + i] = (int)((float)(1L<<16)*f);
985	>	}
986	>
987	>	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
988	>	quiterr("error writing TIFF output");
989	>	}
990	>
991	>
992	>	static void
993	>	Colr2Gry(                       /* read/convert/write COLR->RGB scanline */
994	>	uint32  y
995	>	)
996	>	{
997	>	register int    x;
998	>
999	>	if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != C_GRY)
1000	>	quiterr("internal error 1 in Colr2Gry");
1001	>
1002	>	if (freadcolrs(cvts.r.colrs, cvts.xmax, cvts.rfp) < 0)
1003	>	quiterr("error reading Radiance picture");
1004	>
1005	>	if (cvts.bradj)
1006	>	shiftcolrs(cvts.r.colrs, cvts.xmax, cvts.bradj);
1007	>	for (x = cvts.xmax; x--; )
1008	>	colval(cvts.r.colrs[x],CIEY) = normbright(cvts.r.colrs[x]);
1009	>	colrs_gambs(cvts.r.colrs, cvts.xmax);
1010	>
1011	>	for (x = cvts.xmax; x--; )
1012	>	cvts.t.bp[x] = colval(cvts.r.colrs[x],CIEY);
1013	>
1014	>	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
1015	>	quiterr("error writing TIFF output");
1016	>	}
1017	>
1018	>
1019	>	static void
1020	>	Colr2RGB(                       /* read/convert/write COLR->RGB scanline */
1021	>	uint32  y
1022	>	)
1023	>	{
1024	>	COLOR   ctmp;
1025	>	register int    x;
1026	>
1027	>	if (CHK(C_RFLT|C_TFLT|C_TWRD|C_GRY))
1028	>	quiterr("internal error 1 in Colr2RGB");
1029	>
1030	>	if (freadcolrs(cvts.r.colrs, cvts.xmax, cvts.rfp) < 0)
1031	>	quiterr("error reading Radiance picture");
1032	>
1033	>	if (cvts.bradj)
1034	>	shiftcolrs(cvts.r.colrs, cvts.xmax, cvts.bradj);
1035	>	if (CHK(C_CXFM))
1036	>	for (x = cvts.xmax; x--; ) {
1037	>	colr_color(ctmp, cvts.r.colrs[x]);
1038	>	colortrans(ctmp, cvts.cmat, ctmp);
1039	>	if (CHK(C_GAMUT))
1040	>	clipgamut(ctmp, bright(ctmp), CGAMUT,
1041	>	cblack, cwhite);
1042	>	setcolr(cvts.r.colrs[x], colval(ctmp,RED),
1043	>	colval(ctmp,GRN), colval(ctmp,BLU));
1044		}
1045	<	if (TIFFWriteScanline(tif, scanout, y, 0) < 0)
1046	<	quiterr("error writing TIFF output");
1045	>	colrs_gambs(cvts.r.colrs, cvts.xmax);
1046	>
1047	>	for (x = cvts.xmax; x--; ) {
1048	>	cvts.t.bp[3*x] = cvts.r.colrs[x][RED];
1049	>	cvts.t.bp[3*x+1] = cvts.r.colrs[x][GRN];
1050	>	cvts.t.bp[3*x+2] = cvts.r.colrs[x][BLU];
1051		}
1052	<	/* clean up */
1053	<	free((char *)scanin);
1054	<	free((char *)scanout);
254	<	TIFFClose(tif);
1052	>
1053	>	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
1054	>	quiterr("error writing TIFF output");
1055		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)