7 |
|
* Added white-balance adjustment 10/01 (GW). |
8 |
|
*/ |
9 |
|
|
10 |
– |
#include <stdio.h> |
10 |
|
#include <math.h> |
11 |
|
#include <ctype.h> |
12 |
< |
#include <time.h> |
12 |
> |
|
13 |
> |
#include "rtio.h" |
14 |
> |
#include "platform.h" |
15 |
|
#include "tiffio.h" |
16 |
|
#include "color.h" |
17 |
|
#include "resolu.h" |
29 |
|
#define C_TWRD 0x80 /* TIFF data is 16-bit */ |
30 |
|
#define C_PRIM 0x100 /* has assigned primaries */ |
31 |
|
|
32 |
+ |
typedef void colcvf_t(uint32 y); |
33 |
+ |
|
34 |
|
struct { |
35 |
|
uint16 flags; /* conversion flags (defined above) */ |
36 |
|
char capdate[20]; /* capture date/time */ |
59 |
|
float *fp; /* float pointer */ |
60 |
|
char *p; /* generic pointer */ |
61 |
|
} t; /* TIFF scanline */ |
62 |
< |
void (*tf)(); /* translation procedure */ |
62 |
> |
colcvf_t *tf; /* translation procedure */ |
63 |
|
} cvts = { /* conversion structure */ |
64 |
|
0, "", "", COMPRESSION_NONE, PHOTOMETRIC_RGB, |
65 |
|
PLANARCONFIG_CONTIG, GAMCOR, 0, 1, 1., 1., |
70 |
|
#define CLR(f) (cvts.flags &= ~(f)) |
71 |
|
#define TGL(f) (cvts.flags ^= (f)) |
72 |
|
|
73 |
< |
void Luv2Color(), L2Color(), RGB2Colr(), Gry2Colr(); |
74 |
< |
void Color2Luv(), Color2L(), Colr2RGB(), Colr2Gry(); |
75 |
< |
void RRGGBB2Color(), GGry2Color(), Color2RRGGBB(), Color2GGry(); |
73 |
> |
static colcvf_t Luv2Color, L2Color, RGB2Colr, Gry2Colr; |
74 |
> |
static colcvf_t Color2Luv, Color2L, Colr2RGB, Colr2Gry; |
75 |
> |
static colcvf_t RRGGBB2Color, GGry2Color, Color2RRGGBB, Color2GGry; |
76 |
|
|
77 |
+ |
static gethfunc headline; |
78 |
+ |
static void quiterr(char *err); |
79 |
+ |
static void allocbufs(void); |
80 |
+ |
static void initfromtif(void); |
81 |
+ |
static void tiff2ra(int ac, char *av[]); |
82 |
+ |
static void initfromrad(void); |
83 |
+ |
static void ra2tiff(int ac, char *av[]); |
84 |
+ |
|
85 |
+ |
|
86 |
+ |
|
87 |
|
#define RfGfBf2Color Luv2Color |
88 |
|
#define Gryf2Color L2Color |
89 |
|
#define Color2Gryf Color2L |
108 |
|
char *progname; |
109 |
|
|
110 |
|
|
111 |
< |
main(argc, argv) |
112 |
< |
int argc; |
100 |
< |
char *argv[]; |
111 |
> |
int |
112 |
> |
main(int argc, char *argv[]) |
113 |
|
{ |
114 |
|
int reverse = 0; |
115 |
|
int i; |
173 |
|
if (i != argc-2) |
174 |
|
goto userr; |
175 |
|
/* consistency checks */ |
176 |
< |
if (CHK(C_GRY)) |
176 |
> |
if (CHK(C_GRY)) { |
177 |
|
if (cvts.phot == PHOTOMETRIC_RGB) |
178 |
|
cvts.phot = PHOTOMETRIC_MINISBLACK; |
179 |
|
else { |
180 |
|
cvts.phot = PHOTOMETRIC_LOGL; |
181 |
|
cvts.comp = COMPRESSION_SGILOG; |
182 |
|
} |
183 |
+ |
} |
184 |
|
if (CHK(C_TWRD|C_TFLT) == (C_TWRD|C_TFLT)) |
185 |
|
goto userr; |
186 |
|
|
190 |
|
exit(0); |
191 |
|
userr: |
192 |
|
fprintf(stderr, |
193 |
< |
"Usage: %s [-z|-L|-l|-f|-w][-b][-e +/-stops][-g gamma] {in.pic|-} out.tif\n", |
193 |
> |
"Usage: %s [-z|-L|-l|-f|-w][-b][-e +/-stops][-g gamma] {in.hdr|-} out.tif\n", |
194 |
|
progname); |
195 |
|
fprintf(stderr, |
196 |
< |
" Or: %s -r [-x][-e +/-stops][-g gamma] in.tif [out.pic|-]\n", |
196 |
> |
" Or: %s -r [-x][-e +/-stops][-g gamma] in.tif [out.hdr|-]\n", |
197 |
|
progname); |
198 |
|
exit(1); |
199 |
|
} |
200 |
|
|
201 |
|
|
202 |
< |
quiterr(err) /* print message and exit */ |
203 |
< |
char *err; |
202 |
> |
static void |
203 |
> |
quiterr( /* print message and exit */ |
204 |
> |
char *err |
205 |
> |
) |
206 |
|
{ |
207 |
|
if (err != NULL) { |
208 |
|
fprintf(stderr, "%s: %s\n", progname, err); |
212 |
|
} |
213 |
|
|
214 |
|
|
215 |
< |
allocbufs() /* allocate scanline buffers */ |
215 |
> |
static void |
216 |
> |
allocbufs(void) /* allocate scanline buffers */ |
217 |
|
{ |
218 |
|
int rsiz, tsiz; |
219 |
|
|
223 |
|
(CHK(C_GRY) ? 1 : 3); |
224 |
|
cvts.r.p = (char *)malloc(rsiz*cvts.xmax); |
225 |
|
cvts.t.p = (char *)malloc(tsiz*cvts.xmax); |
226 |
< |
if (cvts.r.p == NULL | cvts.t.p == NULL) |
226 |
> |
if ((cvts.r.p == NULL) | (cvts.t.p == NULL)) |
227 |
|
quiterr("no memory to allocate scanline buffers"); |
228 |
|
} |
229 |
|
|
230 |
|
|
231 |
< |
initfromtif() /* initialize conversion from TIFF input */ |
231 |
> |
static void |
232 |
> |
initfromtif(void) /* initialize conversion from TIFF input */ |
233 |
|
{ |
234 |
|
uint16 hi; |
235 |
|
char *cp; |
274 |
|
cpcolormat(cvts.cmat, xyz2rgbmat); |
275 |
|
SET(C_CXFM|C_GAMUT); |
276 |
|
} else if (cvts.comp == COMPRESSION_SGILOG) |
277 |
< |
SET(C_GAMUT); |
277 |
> |
SET(C_GAMUT); /* may be outside XYZ gamut */ |
278 |
|
if (cvts.pconf != PLANARCONFIG_CONTIG) |
279 |
|
quiterr("cannot handle separate Luv planes"); |
280 |
|
TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT, |
361 |
|
quiterr("unknown input image resolution"); |
362 |
|
|
363 |
|
if (!TIFFGetField(cvts.tif, TIFFTAG_STONITS, &cvts.stonits)) |
364 |
< |
cvts.stonits = 1.; |
364 |
> |
cvts.stonits = -1.; |
365 |
|
|
366 |
|
if (!TIFFGetField(cvts.tif, TIFFTAG_DATETIME, &cp)) |
367 |
|
cvts.capdate[0] = '\0'; |
379 |
|
if (cvts.pixrat < .99 || cvts.pixrat > 1.01) |
380 |
|
fputaspect(cvts.pixrat, cvts.rfp); |
381 |
|
if (CHK(C_XYZE)) { |
382 |
< |
fputexpos(pow(2.,(double)cvts.bradj)/cvts.stonits, cvts.rfp); |
382 |
> |
if (cvts.stonits > .0) |
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); |
388 |
> |
if (cvts.stonits > .0) |
389 |
> |
fputexpos(WHTEFFICACY*pow(2.,(double)cvts.bradj)/cvts.stonits, |
390 |
> |
cvts.rfp); |
391 |
|
fputformat(COLRFMT, cvts.rfp); |
392 |
|
} |
393 |
|
if (cvts.capdate[0]) |
399 |
|
} |
400 |
|
|
401 |
|
|
402 |
< |
tiff2ra(ac, av) /* convert TIFF image to Radiance picture */ |
403 |
< |
int ac; |
404 |
< |
char *av[]; |
402 |
> |
static void |
403 |
> |
tiff2ra( /* convert TIFF image to Radiance picture */ |
404 |
> |
int ac, |
405 |
> |
char *av[] |
406 |
> |
) |
407 |
|
{ |
408 |
|
int32 y; |
409 |
|
/* open TIFF input */ |
414 |
|
cvts.rfp = stdout; |
415 |
|
else if ((cvts.rfp = fopen(av[ac+1], "w")) == NULL) |
416 |
|
quiterr("cannot open Radiance output picture"); |
417 |
+ |
SET_FILE_BINARY(cvts.rfp); |
418 |
|
/* start output header */ |
419 |
|
newheader("RADIANCE", cvts.rfp); |
420 |
|
printargs(ac, av, cvts.rfp); |
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]; |
443 |
> |
char fmt[MAXFMTLEN]; |
444 |
|
|
445 |
|
if (!tmstrlen) |
446 |
|
tmstrlen = strlen(TMSTR); |
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 */ |
571 |
|
SAMPLEFORMAT_IEEEFP); |
572 |
|
cvts.tf = Color2RfGfBf; |
573 |
|
SET(C_RFLT); |
574 |
+ |
CLR(C_GAMUT); |
575 |
|
} else |
576 |
|
cvts.tf = Colr2RGB; |
577 |
|
break; |
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 */ |
634 |
|
cvts.rfp = stdin; |
635 |
|
else if ((cvts.rfp = fopen(av[ac], "r")) == NULL) |
636 |
|
quiterr("cannot open Radiance input picture"); |
637 |
+ |
SET_FILE_BINARY(cvts.rfp); |
638 |
|
/* open TIFF file */ |
639 |
|
if ((cvts.tif = TIFFOpen(av[ac+1], "w")) == NULL) |
640 |
|
quiterr("cannot open TIFF output"); |
649 |
|
} |
650 |
|
|
651 |
|
|
652 |
< |
void |
653 |
< |
Luv2Color(y) /* read/convert/write Luv->COLOR scanline */ |
654 |
< |
uint32 y; |
652 |
> |
static void |
653 |
> |
Luv2Color( /* read/convert/write Luv->COLOR scanline */ |
654 |
> |
uint32 y |
655 |
> |
) |
656 |
|
{ |
657 |
|
register int x; |
658 |
|
|
659 |
|
if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != (C_RFLT|C_TFLT)) |
660 |
|
quiterr("internal error 1 in Luv2Color"); |
661 |
|
|
662 |
+ |
if (cvts.pconf != PLANARCONFIG_CONTIG) |
663 |
+ |
quiterr("cannot handle separate 32-bit color planes"); |
664 |
+ |
|
665 |
|
if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0) |
666 |
|
quiterr("error reading TIFF input"); |
667 |
|
/* also works for float RGB */ |
688 |
|
} |
689 |
|
|
690 |
|
|
691 |
< |
void |
692 |
< |
RRGGBB2Color(y) /* read/convert/write RGB16->COLOR scanline */ |
693 |
< |
uint32 y; |
691 |
> |
static void |
692 |
> |
RRGGBB2Color( /* read/convert/write RGB16->COLOR scanline */ |
693 |
> |
uint32 y |
694 |
> |
) |
695 |
|
{ |
696 |
< |
int dogamma = cvts.gamcor < 0.99 | cvts.gamcor > 1.01; |
696 |
> |
int dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01); |
697 |
|
register double d; |
698 |
|
register int x; |
699 |
|
|
700 |
|
if (CHK(C_RFLT|C_TWRD|C_TFLT|C_GRY) != (C_TWRD|C_RFLT)) |
701 |
|
quiterr("internal error 1 in RRGGBB2Color"); |
702 |
|
|
703 |
+ |
if (cvts.pconf != PLANARCONFIG_CONTIG) |
704 |
+ |
quiterr("cannot handle separate 16-bit color planes"); |
705 |
+ |
|
706 |
|
if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0) |
707 |
|
quiterr("error reading TIFF input"); |
708 |
|
|
719 |
|
if (CHK(C_CXFM)) |
720 |
|
colortrans(cvts.r.colors[x], cvts.cmat, |
721 |
|
cvts.r.colors[x]); |
685 |
– |
if (CHK(C_GAMUT)) |
686 |
– |
clipgamut(cvts.r.colors[x], cvts.t.fp[3*x + 1], |
687 |
– |
CGAMUT_LOWER, cblack, cwhite); |
722 |
|
} |
723 |
|
if (cvts.bradj) { |
724 |
|
d = pow(2.,(double)cvts.bradj); |
731 |
|
} |
732 |
|
|
733 |
|
|
734 |
< |
void |
735 |
< |
L2Color(y) /* read/convert/write Lfloat->COLOR scanline */ |
736 |
< |
uint32 y; |
734 |
> |
static void |
735 |
> |
L2Color( /* read/convert/write Lfloat->COLOR scanline */ |
736 |
> |
uint32 y |
737 |
> |
) |
738 |
|
{ |
739 |
|
float m = pow(2., (double)cvts.bradj); |
740 |
|
register int x; |
755 |
|
} |
756 |
|
|
757 |
|
|
758 |
< |
void |
759 |
< |
RGB2Colr(y) /* read/convert/write RGB->COLR scanline */ |
760 |
< |
uint32 y; |
758 |
> |
static void |
759 |
> |
RGB2Colr( /* read/convert/write RGB->COLR scanline */ |
760 |
> |
uint32 y |
761 |
> |
) |
762 |
|
{ |
763 |
|
COLOR ctmp; |
764 |
|
register int x; |
812 |
|
} |
813 |
|
|
814 |
|
|
815 |
< |
void |
816 |
< |
Gry2Colr(y) /* read/convert/write G8->COLR scanline */ |
817 |
< |
uint32 y; |
815 |
> |
static void |
816 |
> |
Gry2Colr( /* read/convert/write G8->COLR scanline */ |
817 |
> |
uint32 y |
818 |
> |
) |
819 |
|
{ |
820 |
|
register int x; |
821 |
|
|
839 |
|
} |
840 |
|
|
841 |
|
|
842 |
< |
void |
843 |
< |
GGry2Color(y) /* read/convert/write G16->COLOR scanline */ |
844 |
< |
uint32 y; |
842 |
> |
static void |
843 |
> |
GGry2Color( /* read/convert/write G16->COLOR scanline */ |
844 |
> |
uint32 y |
845 |
> |
) |
846 |
|
{ |
847 |
< |
int dogamma = cvts.gamcor < 0.99 | cvts.gamcor > 1.01; |
847 |
> |
int dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01); |
848 |
|
double m; |
849 |
|
register double d; |
850 |
|
register int x; |
870 |
|
} |
871 |
|
|
872 |
|
|
873 |
< |
void |
874 |
< |
Color2GGry(y) /* read/convert/write COLOR->G16 scanline */ |
875 |
< |
uint32 y; |
873 |
> |
static void |
874 |
> |
Color2GGry( /* read/convert/write COLOR->G16 scanline */ |
875 |
> |
uint32 y |
876 |
> |
) |
877 |
|
{ |
878 |
< |
int dogamma = cvts.gamcor < 0.99 | cvts.gamcor > 1.01; |
878 |
> |
int dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01); |
879 |
|
float m = pow(2.,(double)cvts.bradj); |
880 |
|
register int x; |
881 |
|
|
905 |
|
} |
906 |
|
|
907 |
|
|
908 |
< |
void |
909 |
< |
Color2L(y) /* read/convert/write COLOR->Lfloat scanline */ |
910 |
< |
uint32 y; |
908 |
> |
static void |
909 |
> |
Color2L( /* read/convert/write COLOR->Lfloat scanline */ |
910 |
> |
uint32 y |
911 |
> |
) |
912 |
|
{ |
913 |
|
float m = pow(2.,(double)cvts.bradj); |
914 |
|
register int x; |
928 |
|
} |
929 |
|
|
930 |
|
|
931 |
< |
void |
932 |
< |
Color2Luv(y) /* read/convert/write COLOR->Luv scanline */ |
933 |
< |
uint32 y; |
931 |
> |
static void |
932 |
> |
Color2Luv( /* read/convert/write COLOR->Luv scanline */ |
933 |
> |
uint32 y |
934 |
> |
) |
935 |
|
{ |
936 |
|
register int x; |
937 |
|
|
962 |
|
} |
963 |
|
|
964 |
|
|
965 |
< |
void |
966 |
< |
Color2RRGGBB(y) /* read/convert/write COLOR->RGB16 scanline */ |
967 |
< |
uint32 y; |
965 |
> |
static void |
966 |
> |
Color2RRGGBB( /* read/convert/write COLOR->RGB16 scanline */ |
967 |
> |
uint32 y |
968 |
> |
) |
969 |
|
{ |
970 |
< |
int dogamma = cvts.gamcor < 0.99 | cvts.gamcor > 1.01; |
970 |
> |
int dogamma = (cvts.gamcor < 0.99) | (cvts.gamcor > 1.01); |
971 |
|
float m = pow(2.,(double)cvts.bradj); |
972 |
|
register int x, i; |
973 |
|
|
977 |
|
if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0) |
978 |
|
quiterr("error reading Radiance picture"); |
979 |
|
|
980 |
< |
for (x = cvts.xmax; x--; ) |
980 |
> |
for (x = cvts.xmax; x--; ) { |
981 |
> |
if (CHK(C_CXFM)) { |
982 |
> |
colortrans(cvts.r.colors[x], cvts.cmat, |
983 |
> |
cvts.r.colors[x]); |
984 |
> |
if (CHK(C_GAMUT)) |
985 |
> |
clipgamut(cvts.r.colors[x], bright(cvts.r.colors[x]), |
986 |
> |
CGAMUT_LOWER, cblack, cwhite); |
987 |
> |
} |
988 |
|
for (i = 3; i--; ) { |
989 |
|
register float f = m*colval(cvts.r.colors[x],i); |
990 |
|
if (f <= 0) |
997 |
|
else |
998 |
|
cvts.t.wp[3*x + i] = (int)((float)(1L<<16)*f); |
999 |
|
} |
1000 |
+ |
} |
1001 |
|
|
1002 |
|
if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0) |
1003 |
|
quiterr("error writing TIFF output"); |
1004 |
|
} |
1005 |
|
|
1006 |
|
|
1007 |
< |
void |
1008 |
< |
Colr2Gry(y) /* read/convert/write COLR->RGB scanline */ |
1009 |
< |
uint32 y; |
1007 |
> |
static void |
1008 |
> |
Colr2Gry( /* read/convert/write COLR->RGB scanline */ |
1009 |
> |
uint32 y |
1010 |
> |
) |
1011 |
|
{ |
1012 |
|
register int x; |
1013 |
|
|
1031 |
|
} |
1032 |
|
|
1033 |
|
|
1034 |
< |
void |
1035 |
< |
Colr2RGB(y) /* read/convert/write COLR->RGB scanline */ |
1036 |
< |
uint32 y; |
1034 |
> |
static void |
1035 |
> |
Colr2RGB( /* read/convert/write COLR->RGB scanline */ |
1036 |
> |
uint32 y |
1037 |
> |
) |
1038 |
|
{ |
1039 |
|
COLOR ctmp; |
1040 |
|
register int x; |