[ViewVC] Diff of: radiance/ray/src/px/ra

Comparing ray/src/px/ra_tiff.c (file contents):
Revision 2.19 by gwlarson, Wed Jun 2 10:57:53 1999 UTC vs.
Revision 2.32 by greg, Fri Aug 19 02:31:32 2005 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1997 Silicon Graphics, Inc. */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ SGI";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Program to convert between RADIANCE and TIFF files.
6	<	* Added experimental LogLuv encodings 7/97 (GWL).
6	>	* Added LogLuv encodings 7/97 (GWL).
7	>	* Added white-balance adjustment 10/01 (GW).
8		*/
9
10		#include <stdio.h>
11		#include <math.h>
12	+	#include <ctype.h>
13	+	#include <time.h>
14	+	#include <string.h>
15	+
16		#include "tiffio.h"
17		#include "color.h"
18		#include "resolu.h"
19
20		#define GAMCOR 2.2 /* default gamma */
21
20	–	#ifndef malloc
21	–	extern char *malloc();
22	–	#endif
22		/* conversion flags */
23		#define C_CXFM 0x1 /* needs color transformation */
24		#define C_GAMUT 0x2 /* needs gamut mapping */
#	Line 31 \| Line 30 \| *extern char malloc();**
30		#define C_TWRD 0x80 /* TIFF data is 16-bit */
31		#define C_PRIM 0x100 /* has assigned primaries */
32
33	+	typedef void colcvf_t(uint32 y);
34	+
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 */
#	Line 57 \| Line 60 \| struct {
60		float fp; / float pointer */
61		char p; / generic pointer */
62		} t; /* TIFF scanline */
63	<	int (tf)(); / translation procedure */
63	>	colcvf_t tf; / translation procedure */
64		} cvts = { /* conversion structure */
65	<	0, COMPRESSION_NONE, PHOTOMETRIC_RGB,
65	>	0, "", "", COMPRESSION_NONE, PHOTOMETRIC_RGB,
66		PLANARCONFIG_CONTIG, GAMCOR, 0, 1, 1., 1.,
67		};
68
#	Line 68 \| Line 71 \| struct {
71		#define CLR(f) (cvts.flags &= ~(f))
72		#define TGL(f) (cvts.flags ^= (f))
73
74	<	int Luv2Color(), L2Color(), RGB2Colr(), Gry2Colr();
75	<	int Color2Luv(), Color2L(), Colr2RGB(), Colr2Gry();
76	<	int RRGGBB2Color(), GGry2Color();
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,
#	Line 85 \| Line 103 \| *short ortab[8] = { / orientation conversion table /*
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;
93	<	char *argv[];
112	>	int
113	>	main(int argc, char *argv[])
114		{
115		int reverse = 0;
116		int i;
#	Line 117 \| Line 137 \| *char argv[];**
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;
#	Line 147 \| Line 173 \| doneopts:
173
174		if (i != argc-2)
175		goto userr;
176	<
177	<	if (CHK(C_GRY)) /* consistency corrections */
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		}
#	Line 162 \| Line 191 \| doneopts:
191		exit(0);
192		userr:
193		fprintf(stderr,
194	<	"Usage: %s [-z\|-L\|-l][-b][-e +/-stops][-g gamma] {in.pic\|-} out.tif\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",
#	Line 171 \| Line 200 \| userr:
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 182 \| Line 213 \| *char err;**
213		}
214
215
216	<	allocbufs() /* allocate scanline buffers */
216	>	static void
217	>	allocbufs(void) /* allocate scanline buffers */
218		{
219		int rsiz, tsiz;
220
#	Line 192 \| Line 224 \| *allocbufs() / allocate scanline buffers /*
224		(CHK(C_GRY) ? 1 : 3);
225		cvts.r.p = (char )malloc(rsizcvts.xmax);
226		cvts.t.p = (char )malloc(tsizcvts.xmax);
227	<	if (cvts.r.p == NULL \| cvts.t.p == NULL)
227	>	if ((cvts.r.p == NULL) \| (cvts.t.p == NULL))
228		quiterr("no memory to allocate scanline buffers");
229		}
230
231
232	<	initfromtif() /* initialize conversion from TIFF input */
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_CXFM);
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
#	Line 241 \| Line 275 \| *initfromtif() / initialize conversion from TIFF inpu**
275		cpcolormat(cvts.cmat, xyz2rgbmat);
276		SET(C_CXFM\|C_GAMUT);
277		} else if (cvts.comp == COMPRESSION_SGILOG)
278	<	SET(C_GAMUT);
278	>	SET(C_GAMUT); /* may be outside XYZ gamut */
279		if (cvts.pconf != PLANARCONFIG_CONTIG)
280		quiterr("cannot handle separate Luv planes");
281		TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
#	Line 268 \| Line 302 \| *initfromtif() / initialize conversion from TIFF inpu**
302		SET(C_GAMMA);
303		setcolrgam(cvts.gamcor);
304		if (CHK(C_XYZE)) {
305	<	comprgb2xyzmat(cvts.cmat,
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 != 8 & hi != 16)
314	<	quiterr("unsupported bits per sample for RGB");
315	<	if (hi == 8)
312	>	if (!TIFFGetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, &hi))
313	>	hi = -1;
314	>	switch (hi) {
315	>	case 8:
316		cvts.tf = RGB2Colr;
317	<	else {
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:
#	Line 292 \| Line 334 \| *initfromtif() / initialize conversion from TIFF inpu**
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 != 8 & hi != 16)
339	<	quiterr("unsupported bits per sample for greyscale");
340	<	if (hi == 8)
337	>	if (!TIFFGetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, &hi))
338	>	hi = -1;
339	>	switch (hi) {
340	>	case 8:
341		cvts.tf = Gry2Colr;
342	<	else {
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:
#	Line 312 \| Line 362 \| *initfromtif() / initialize conversion from TIFF inpu**
362		quiterr("unknown input image resolution");
363
364		if (!TIFFGetField(cvts.tif, TIFFTAG_STONITS, &cvts.stonits))
365	<	cvts.stonits = 1.;
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);
383	>	if (cvts.stonits > .0)
384	>	fputexpos(pow(2.,(double)cvts.bradj)/cvts.stonits, cvts.rfp);
385		fputformat(CIEFMT, cvts.rfp);
386		} else {
387		if (CHK(C_PRIM))
388		fputprims(cvts.prims, cvts.rfp);
389	<	fputexpos(WHTEFFICACY*pow(2.,(double)cvts.bradj)/cvts.stonits,
390	<	cvts.rfp);
389	>	if (cvts.stonits > .0)
390	>	fputexpos(WHTEFFICACY*pow(2.,(double)cvts.bradj)/cvts.stonits,
391	>	cvts.rfp);
392		fputformat(COLRFMT, cvts.rfp);
393		}
394	+	if (cvts.capdate[0])
395	+	fprintf(cvts.rfp, "%s %s\n", TMSTR, cvts.capdate);
396	+	if (cvts.owner[0])
397	+	fprintf(cvts.rfp, "%s %s\n", OWNSTR, cvts.owner);
398
399		allocbufs(); /* allocate scanline buffers */
400		}
401
402
403	<	tiff2ra(ac, av) /* convert TIFF image to Radiance picture */
404	<	int ac;
405	<	char *av[];
403	>	static void
404	>	tiff2ra( /* convert TIFF image to Radiance picture */
405	>	int ac,
406	>	char *av[]
407	>	)
408		{
409		int32 y;
410		/* open TIFF input */
#	Line 361 \| Line 432 \| *char av[];**
432		}
433
434
435	<	int
436	<	headline(s) /* process Radiance input header line */
437	<	char *s;
435	>	static int
436	>	headline( /* process Radiance input header line */
437	>	char *s,
438	>	void *p
439	>	)
440		{
441	+	static int tmstrlen = 0;
442	+	static int ownstrlen = 0;
443		char fmt[32];
444
445	+	if (!tmstrlen)
446	+	tmstrlen = strlen(TMSTR);
447	+	if (!ownstrlen)
448	+	ownstrlen = strlen(OWNSTR);
449		if (formatval(fmt, s)) {
450		if (!strcmp(fmt, COLRFMT))
451		CLR(C_XYZE);
#	Line 389 \| Line 468 \| *char s;**
468		SET(C_PRIM);
469		return(1);
470		}
471	+	if (isdate(s)) {
472	+	if (s[tmstrlen] == ' ')
473	+	strncpy(cvts.capdate, s+tmstrlen+1, 19);
474	+	else
475	+	strncpy(cvts.capdate, s+tmstrlen, 19);
476	+	cvts.capdate[19] = '\0';
477	+	return(1);
478	+	}
479	+	if (!strncmp(s, OWNSTR, ownstrlen)) {
480	+	register char *cp = s + ownstrlen;
481	+
482	+	while (isspace(*cp))
483	+	++cp;
484	+	strncpy(cvts.owner, cp, sizeof(cvts.owner));
485	+	cvts.owner[sizeof(cvts.owner)-1] = '\0';
486	+	for (cp = cvts.owner; *cp; cp++)
487	+	;
488	+	while (cp > cvts.owner && isspace(cp[-1]))
489	+	*--cp = '\0';
490	+	return(1);
491	+	}
492		return(0);
493		}
494
495
496	<	initfromrad() /* initialize input from a Radiance picture */
496	>	static void
497	>	initfromrad(void) /* initialize input from a Radiance picture */
498		{
499		int i1, i2, po;
500		/* read Radiance header */
501	<	CLR(C_RFLT\|C_TFLT\|C_XYZE\|C_PRIM\|C_GAMMA\|C_CXFM);
501	>	CLR(C_RFLT\|C_XYZE\|C_PRIM\|C_GAMMA\|C_CXFM);
502	>	cvts.capdate[0] = '\0';
503	>	cvts.owner[0] = '\0';
504		cvts.stonits = 1.;
505		cvts.pixrat = 1.;
506		cvts.pconf = PLANARCONFIG_CONTIG;
#	Line 423 \| Line 526 \| *initfromrad() / initialize input from a Radiance pi**
526		switch (cvts.phot) {
527		case PHOTOMETRIC_LOGLUV:
528		SET(C_RFLT\|C_TFLT);
529	<	CLR(C_GRY);
529	>	CLR(C_GRY\|C_TWRD);
530		if (!CHK(C_XYZE)) {
531	<	cpcolormat(cvts.cmat, rgb2xyzmat);
531	>	comprgb2xyzWBmat(cvts.cmat,
532	>	CHK(C_PRIM) ? cvts.prims : stdprims);
533		SET(C_CXFM);
534		}
535		if (cvts.comp != COMPRESSION_SGILOG &&
#	Line 437 \| Line 541 \| *initfromrad() / initialize input from a Radiance pi**
541		break;
542		case PHOTOMETRIC_LOGL:
543		SET(C_GRY\|C_RFLT\|C_TFLT);
544	+	CLR(C_TWRD);
545		if (cvts.comp != COMPRESSION_SGILOG)
546		quiterr("internal error 3 in initfromrad");
547		TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
#	Line 448 \| Line 553 \| *initfromrad() / initialize input from a Radiance pi**
553		CLR(C_GRY);
554		setcolrgam(cvts.gamcor);
555		if (CHK(C_XYZE)) {
556	<	compxyz2rgbmat(cvts.cmat,
556	>	compxyz2rgbWBmat(cvts.cmat,
557		CHK(C_PRIM) ? cvts.prims : stdprims);
558		SET(C_CXFM);
559		}
#	Line 458 \| Line 563 \| *initfromrad() / initialize input from a Radiance pi**
563		TIFFSetField(cvts.tif, TIFFTAG_WHITEPOINT,
564		(float *)cvts.prims[WHT]);
565		}
566	<	cvts.tf = Colr2RGB;
566	>	if (CHK(C_TWRD)) {
567	>	cvts.tf = Color2RRGGBB;
568	>	SET(C_RFLT);
569	>	} else if (CHK(C_TFLT)) {
570	>	TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
571	>	SAMPLEFORMAT_IEEEFP);
572	>	cvts.tf = Color2RfGfBf;
573	>	SET(C_RFLT);
574	>	CLR(C_GAMUT);
575	>	} else
576	>	cvts.tf = Colr2RGB;
577		break;
578		case PHOTOMETRIC_MINISBLACK:
579		SET(C_GRY\|C_GAMMA\|C_GAMUT);
580		setcolrgam(cvts.gamcor);
581	<	cvts.tf = Colr2Gry;
581	>	if (CHK(C_TWRD)) {
582	>	cvts.tf = Color2GGry;
583	>	SET(C_RFLT);
584	>	} else if (CHK(C_TFLT)) {
585	>	TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
586	>	SAMPLEFORMAT_IEEEFP);
587	>	cvts.tf = Color2Gryf;
588	>	SET(C_RFLT);
589	>	} else
590	>	cvts.tf = Colr2Gry;
591		break;
592		default:
593		quiterr("internal error 4 in initfromrad");
#	Line 473 \| Line 597 \| *initfromrad() / initialize input from a Radiance pi**
597		TIFFSetField(cvts.tif, TIFFTAG_IMAGEWIDTH, cvts.xmax);
598		TIFFSetField(cvts.tif, TIFFTAG_IMAGELENGTH, cvts.ymax);
599		TIFFSetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, CHK(C_GRY) ? 1 : 3);
600	<	TIFFSetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, CHK(C_TFLT) ? 32 : 8);
600	>	TIFFSetField(cvts.tif, TIFFTAG_BITSPERSAMPLE,
601	>	CHK(C_TFLT) ? 32 : CHK(C_TWRD) ? 16 : 8);
602		TIFFSetField(cvts.tif, TIFFTAG_XRESOLUTION, 72.);
603		TIFFSetField(cvts.tif, TIFFTAG_YRESOLUTION, 72./cvts.pixrat);
604		TIFFSetField(cvts.tif, TIFFTAG_ORIENTATION, cvts.orient);
#	Line 481 \| Line 606 \| *initfromrad() / initialize input from a Radiance pi**
606		TIFFSetField(cvts.tif, TIFFTAG_PLANARCONFIG, cvts.pconf);
607		TIFFSetField(cvts.tif, TIFFTAG_STONITS,
608		cvts.stonits/pow(2.,(double)cvts.bradj));
609	+	if (cvts.capdate[0])
610	+	TIFFSetField(cvts.tif, TIFFTAG_DATETIME, cvts.capdate);
611	+	if (cvts.owner[0])
612	+	TIFFSetField(cvts.tif, TIFFTAG_ARTIST, cvts.owner);
613		if (cvts.comp == COMPRESSION_NONE)
614		i1 = TIFFScanlineSize(cvts.tif);
615		else
#	Line 493 \| Line 622 \| *initfromrad() / initialize input from a Radiance pi**
622		}
623
624
625	<	ra2tiff(ac, av) /* convert Radiance picture to TIFF image */
626	<	int ac;
627	<	char *av[];
625	>	static void
626	>	ra2tiff( /* convert Radiance picture to TIFF image */
627	>	int ac,
628	>	char *av[]
629	>	)
630		{
631		uint32 y;
632		/* open Radiance file */
#	Line 517 \| Line 648 \| *char av[];**
648		}
649
650
651	<	int
652	<	Luv2Color(y) /* read/convert/write Luv->COLOR scanline */
653	<	uint32 y;
651	>	static void
652	>	Luv2Color( /* read/convert/write Luv->COLOR scanline */
653	>	uint32 y
654	>	)
655		{
656		register int x;
657
658		if (CHK(C_RFLT\|C_TWRD\|C_TFLT\|C_GRY) != (C_RFLT\|C_TFLT))
659		quiterr("internal error 1 in Luv2Color");
660
661	+	if (cvts.pconf != PLANARCONFIG_CONTIG)
662	+	quiterr("cannot handle separate 32-bit color planes");
663	+
664		if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
665		quiterr("error reading TIFF input");
666	<
666	>	/* also works for float RGB */
667		for (x = cvts.xmax; x--; ) {
668	<	colval(cvts.r.colors[x],CIEX) = cvts.t.fp[3*x];
669	<	colval(cvts.r.colors[x],CIEY) = cvts.t.fp[3*x + 1];
670	<	colval(cvts.r.colors[x],CIEZ) = cvts.t.fp[3*x + 2];
668	>	setcolor(cvts.r.colors[x],
669	>	cvts.t.fp[3*x],
670	>	cvts.t.fp[3*x + 1],
671	>	cvts.t.fp[3*x + 2]);
672		if (CHK(C_CXFM))
673		colortrans(cvts.r.colors[x], cvts.cmat,
674		cvts.r.colors[x]);
#	Line 551 \| Line 687 \| uint32 y;
687		}
688
689
690	<	int
691	<	RRGGBB2Color(y) /* read/convert/write RGB16->COLOR scanline */
692	<	uint32 y;
690	>	static void
691	>	RRGGBB2Color( /* read/convert/write RGB16->COLOR scanline */
692	>	uint32 y
693	>	)
694		{
695	<	int dogamma = cvts.gamcor < 0.99 \| cvts.gamcor > 1.01;
695	>	int dogamma = (cvts.gamcor < 0.99) \| (cvts.gamcor > 1.01);
696		register double d;
697		register int x;
698
699		if (CHK(C_RFLT\|C_TWRD\|C_TFLT\|C_GRY) != (C_TWRD\|C_RFLT))
700		quiterr("internal error 1 in RRGGBB2Color");
701
702	+	if (cvts.pconf != PLANARCONFIG_CONTIG)
703	+	quiterr("cannot handle separate 16-bit color planes");
704	+
705		if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
706		quiterr("error reading TIFF input");
707
#	Line 578 \| Line 718 \| uint32 y;
718		if (CHK(C_CXFM))
719		colortrans(cvts.r.colors[x], cvts.cmat,
720		cvts.r.colors[x]);
581	–	if (CHK(C_GAMUT))
582	–	clipgamut(cvts.r.colors[x], cvts.t.fp[3*x + 1],
583	–	CGAMUT_LOWER, cblack, cwhite);
721		}
722		if (cvts.bradj) {
723		d = pow(2.,(double)cvts.bradj);
#	Line 593 \| Line 730 \| uint32 y;
730		}
731
732
733	<	int
734	<	L2Color(y) /* read/convert/write L16->COLOR scanline */
735	<	uint32 y;
733	>	static void
734	>	L2Color( /* read/convert/write Lfloat->COLOR scanline */
735	>	uint32 y
736	>	)
737		{
738	+	float m = pow(2., (double)cvts.bradj);
739		register int x;
740
741		if (CHK(C_RFLT\|C_TWRD\|C_TFLT\|C_GRY) != (C_RFLT\|C_TFLT\|C_GRY))
#	Line 604 \| Line 743 \| uint32 y;
743
744		if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
745		quiterr("error reading TIFF input");
746	<
747	<	for (x = cvts.xmax; x--; )
748	<	colval(cvts.r.colors[x],RED) =
749	<	colval(cvts.r.colors[x],GRN) =
750	<	colval(cvts.r.colors[x],BLU) =
751	<	cvts.t.fp[x] > 0. ? cvts.t.fp[x] : 0.;
613	<
746	>	/* also works for float greyscale */
747	>	for (x = cvts.xmax; x--; ) {
748	>	register float f = cvts.t.fp[x];
749	>	if (cvts.bradj) f *= m;
750	>	setcolor(cvts.r.colors[x], f, f, f);
751	>	}
752		if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
753		quiterr("error writing Radiance picture");
754		}
755
756
757	<	int
758	<	RGB2Colr(y) /* read/convert/write RGB->COLR scanline */
759	<	uint32 y;
757	>	static void
758	>	RGB2Colr( /* read/convert/write RGB->COLR scanline */
759	>	uint32 y
760	>	)
761		{
762		COLOR ctmp;
763		register int x;
#	Line 672 \| Line 811 \| readerr:
811		}
812
813
814	<	int
815	<	Gry2Colr(y) /* read/convert/write G8->COLR scanline */
816	<	uint32 y;
814	>	static void
815	>	Gry2Colr( /* read/convert/write G8->COLR scanline */
816	>	uint32 y
817	>	)
818		{
819		register int x;
820
#	Line 698 \| Line 838 \| uint32 y;
838		}
839
840
841	<	int
842	<	GGry2Color(y) /* read/convert/write G16->COLOR scanline */
843	<	uint32 y;
841	>	static void
842	>	GGry2Color( /* read/convert/write G16->COLOR scanline */
843	>	uint32 y
844	>	)
845		{
846	<	int dogamma = cvts.gamcor < 0.99 \| cvts.gamcor > 1.01;
846	>	int dogamma = (cvts.gamcor < 0.99) \| (cvts.gamcor > 1.01);
847		double m;
848		register double d;
849		register int x;
#	Line 728 \| Line 869 \| uint32 y;
869		}
870
871
872	<	int
873	<	Color2L(y) /* read/convert/write COLOR->L16 scanline */
874	<	uint32 y;
872	>	static void
873	>	Color2GGry( /* read/convert/write COLOR->G16 scanline */
874	>	uint32 y
875	>	)
876		{
877	<	double m = pow(2.,(double)cvts.bradj);
877	>	int dogamma = (cvts.gamcor < 0.99) \| (cvts.gamcor > 1.01);
878	>	float m = pow(2.,(double)cvts.bradj);
879		register int x;
880
881	+	if (CHK(C_RFLT\|C_TFLT\|C_TWRD\|C_GRY) != (C_RFLT\|C_TWRD\|C_GRY))
882	+	quiterr("internal error 1 in Color2GGry");
883	+
884	+	if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
885	+	quiterr("error reading Radiance picture");
886	+
887	+	for (x = cvts.xmax; x--; ) {
888	+	register float f = m*( CHK(C_XYZE) ?
889	+	colval(cvts.r.colors[x],CIEY)
890	+	: bright(cvts.r.colors[x]) );
891	+	if (f <= 0)
892	+	cvts.t.wp[x] = 0;
893	+	else if (f >= 1)
894	+	cvts.t.wp[x] = 0xffff;
895	+	else if (dogamma)
896	+	cvts.t.wp[x] = (int)((float)(1L<<16) *
897	+	pow(f, 1./cvts.gamcor));
898	+	else
899	+	cvts.t.wp[x] = (int)((float)(1L<<16) * f);
900	+	}
901	+
902	+	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
903	+	quiterr("error writing TIFF output");
904	+	}
905	+
906	+
907	+	static void
908	+	Color2L( /* read/convert/write COLOR->Lfloat scanline */
909	+	uint32 y
910	+	)
911	+	{
912	+	float m = pow(2.,(double)cvts.bradj);
913	+	register int x;
914	+
915		if (CHK(C_RFLT\|C_TFLT\|C_TWRD\|C_GRY) != (C_RFLT\|C_TFLT\|C_GRY))
916		quiterr("internal error 1 in Color2L");
917
#	Line 750 \| Line 927 \| uint32 y;
927		}
928
929
930	<	int
931	<	Color2Luv(y) /* read/convert/write COLOR->Luv scanline */
932	<	uint32 y;
930	>	static void
931	>	Color2Luv( /* read/convert/write COLOR->Luv scanline */
932	>	uint32 y
933	>	)
934		{
935		register int x;
936
#	Line 771 \| Line 949 \| uint32 y;
949		for (x = cvts.xmax; x--; )
950		scalecolor(cvts.r.colors[x], m);
951		}
952	<
952	>	/* also works for float RGB */
953		for (x = cvts.xmax; x--; ) {
954		cvts.t.fp[3*x] = colval(cvts.r.colors[x],CIEX);
955		cvts.t.fp[3*x+1] = colval(cvts.r.colors[x],CIEY);
#	Line 783 \| Line 961 \| uint32 y;
961		}
962
963
964	<	int
965	<	Colr2Gry(y) /* read/convert/write COLR->RGB scanline */
966	<	uint32 y;
964	>	static void
965	>	Color2RRGGBB( /* read/convert/write COLOR->RGB16 scanline */
966	>	uint32 y
967	>	)
968		{
969	+	int dogamma = (cvts.gamcor < 0.99) \| (cvts.gamcor > 1.01);
970	+	float m = pow(2.,(double)cvts.bradj);
971	+	register int x, i;
972	+
973	+	if (CHK(C_RFLT\|C_TFLT\|C_TWRD\|C_GRY) != (C_RFLT\|C_TWRD))
974	+	quiterr("internal error 1 in Color2RRGGBB");
975	+
976	+	if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
977	+	quiterr("error reading Radiance picture");
978	+
979	+	for (x = cvts.xmax; x--; ) {
980	+	if (CHK(C_CXFM)) {
981	+	colortrans(cvts.r.colors[x], cvts.cmat,
982	+	cvts.r.colors[x]);
983	+	if (CHK(C_GAMUT))
984	+	clipgamut(cvts.r.colors[x], bright(cvts.r.colors[x]),
985	+	CGAMUT_LOWER, cblack, cwhite);
986	+	}
987	+	for (i = 3; i--; ) {
988	+	register float f = m*colval(cvts.r.colors[x],i);
989	+	if (f <= 0)
990	+	cvts.t.wp[3*x + i] = 0;
991	+	else if (f >= 1)
992	+	cvts.t.wp[3*x + i] = 0xffff;
993	+	else if (dogamma)
994	+	cvts.t.wp[3x + i] = (int)((float)(1L<<16)
995	+	pow(f, 1./cvts.gamcor));
996	+	else
997	+	cvts.t.wp[3x + i] = (int)((float)(1L<<16)f);
998	+	}
999	+	}
1000	+
1001	+	if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
1002	+	quiterr("error writing TIFF output");
1003	+	}
1004	+
1005	+
1006	+	static void
1007	+	Colr2Gry( /* read/convert/write COLR->RGB scanline */
1008	+	uint32 y
1009	+	)
1010	+	{
1011		register int x;
1012
1013		if (CHK(C_RFLT\|C_TWRD\|C_TFLT\|C_GRY) != C_GRY)
#	Line 809 \| Line 1030 \| uint32 y;
1030		}
1031
1032
1033	<	int
1034	<	Colr2RGB(y) /* read/convert/write COLR->RGB scanline */
1035	<	uint32 y;
1033	>	static void
1034	>	Colr2RGB( /* read/convert/write COLR->RGB scanline */
1035	>	uint32 y
1036	>	)
1037		{
1038		COLOR ctmp;
1039		register int x;

Diff Legend

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

Comparing ray/src/px/ra_tiff.c (file contents): Revision 2.19 by gwlarson, Wed Jun 2 10:57:53 1999 UTC vs. Revision 2.32 by greg, Fri Aug 19 02:31:32 2005 UTC

Diff Legend

Comparing ray/src/px/ra_tiff.c (file contents):
Revision 2.19 by gwlarson, Wed Jun 2 10:57:53 1999 UTC vs.
Revision 2.32 by greg, Fri Aug 19 02:31:32 2005 UTC