ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/ra_tiff.c
Revision: 2.28
Committed: Sun Mar 28 20:33:14 2004 UTC (20 years ago) by schorsch
Content type: text/plain
Branch: MAIN
CVS Tags: rad3R6, rad3R6P1
Changes since 2.27: +87 -57 lines
Log Message:
Continued ANSIfication, and other fixes and clarifications.

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: ra_tiff.c,v 2.27 2004/01/02 12:47:01 schorsch Exp $";
3 #endif
4 /*
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>
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
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 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 */
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 #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 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 int
113 main(int argc, char *argv[])
114 {
115 int reverse = 0;
116 int i;
117
118 progname = argv[0];
119
120 for (i = 1; i < argc; i++)
121 if (argv[i][0] == '-')
122 switch (argv[i][1]) {
123 case 'g': /* gamma correction */
124 cvts.gamcor = atof(argv[++i]);
125 break;
126 case 'x': /* XYZE Radiance output */
127 TGL(C_XYZE);
128 break;
129 case 'z': /* LZW compressed output */
130 cvts.comp = COMPRESSION_LZW;
131 break;
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 cvts.bradj = atoi(argv[++i]);
153 break;
154 case 'r': /* reverse conversion? */
155 reverse = !reverse;
156 break;
157 case '\0':
158 goto doneopts;
159 default:
160 goto userr;
161 }
162 else
163 break;
164 doneopts:
165 if (reverse) {
166
167 if (i != argc-2 && i != argc-1)
168 goto userr;
169
170 tiff2ra(i, argv);
171
172 } else {
173
174 if (i != argc-2)
175 goto userr;
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 [-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 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);
210 exit(1);
211 }
212 exit(0);
213 }
214
215
216 static void
217 allocbufs(void) /* allocate scanline buffers */
218 {
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
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 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 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 static void
809 Gry2Colr( /* read/convert/write G8->COLR scanline */
810 uint32 y
811 )
812 {
813 register int x;
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 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
1053 if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
1054 quiterr("error writing TIFF output");
1055 }