1
2 /*
3 * Copyright (c) 1988-1997 Sam Leffler
4 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and
7 * its documentation for any purpose is hereby granted without fee, provided
8 * that (i) the above copyright notices and this permission notice appear in
9 * all copies of the software and related documentation, and (ii) the names of
10 * Sam Leffler and Silicon Graphics may not be used in any advertising or
11 * publicity relating to the software without the specific, prior written
12 * permission of Sam Leffler and Silicon Graphics.
13 *
14 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
15 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
16 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
17 *
18 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
19 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
20 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
21 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
22 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
23 * OF THIS SOFTWARE.
24 */
25
26 #include "tif_config.h"
27
28 #include <stdio.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <ctype.h>
32
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36
37 #ifdef NEED_LIBPORT
38 # include "libport.h"
39 #endif
40
41 #include "tiffio.h"
42
43 #define streq(a,b) (strcmp(a,b) == 0)
44 #define strneq(a,b,n) (strncmp(a,b,n) == 0)
45
46 static void usage(void);
47 static void cpTags(TIFF* in, TIFF* out);
48
49 static int
checkcmap(int n,uint16 * r,uint16 * g,uint16 * b)50 checkcmap(int n, uint16* r, uint16* g, uint16* b)
51 {
52 while (n-- > 0)
53 if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
54 return (16);
55 fprintf(stderr, "Warning, assuming 8-bit colormap.\n");
56 return (8);
57 }
58
59 #define CopyField(tag, v) \
60 if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
61 #define CopyField3(tag, v1, v2, v3) \
62 if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
63
64 static uint16 compression = (uint16) -1;
65 static uint16 predictor = 0;
66 static int quality = 75; /* JPEG quality */
67 static int jpegcolormode = JPEGCOLORMODE_RGB;
68 static int processCompressOptions(char*);
69
70 int
main(int argc,char * argv[])71 main(int argc, char* argv[])
72 {
73 uint16 bitspersample, shortv;
74 uint32 imagewidth, imagelength;
75 uint16 config = PLANARCONFIG_CONTIG;
76 uint32 rowsperstrip = (uint32) -1;
77 uint16 photometric = PHOTOMETRIC_RGB;
78 uint16 *rmap, *gmap, *bmap;
79 uint32 row;
80 int cmap = -1;
81 TIFF *in, *out;
82 int c;
83 extern int optind;
84 extern char* optarg;
85
86 while ((c = getopt(argc, argv, "C:c:p:r:")) != -1)
87 switch (c) {
88 case 'C': /* force colormap interpretation */
89 cmap = atoi(optarg);
90 break;
91 case 'c': /* compression scheme */
92 if (!processCompressOptions(optarg))
93 usage();
94 break;
95 case 'p': /* planar configuration */
96 if (streq(optarg, "separate"))
97 config = PLANARCONFIG_SEPARATE;
98 else if (streq(optarg, "contig"))
99 config = PLANARCONFIG_CONTIG;
100 else
101 usage();
102 break;
103 case 'r': /* rows/strip */
104 rowsperstrip = atoi(optarg);
105 break;
106 case '?':
107 usage();
108 /*NOTREACHED*/
109 }
110 if (argc - optind != 2)
111 usage();
112 in = TIFFOpen(argv[optind], "r");
113 if (in == NULL)
114 return (-1);
115 if (!TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &shortv) ||
116 shortv != PHOTOMETRIC_PALETTE) {
117 fprintf(stderr, "%s: Expecting a palette image.\n",
118 argv[optind]);
119 return (-1);
120 }
121 if (!TIFFGetField(in, TIFFTAG_COLORMAP, &rmap, &gmap, &bmap)) {
122 fprintf(stderr,
123 "%s: No colormap (not a valid palette image).\n",
124 argv[optind]);
125 return (-1);
126 }
127 bitspersample = 0;
128 TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
129 if (bitspersample != 8) {
130 fprintf(stderr, "%s: Sorry, can only handle 8-bit images.\n",
131 argv[optind]);
132 return (-1);
133 }
134 out = TIFFOpen(argv[optind+1], "w");
135 if (out == NULL)
136 return (-2);
137 cpTags(in, out);
138 TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &imagewidth);
139 TIFFGetField(in, TIFFTAG_IMAGELENGTH, &imagelength);
140 if (compression != (uint16)-1)
141 TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
142 else
143 TIFFGetField(in, TIFFTAG_COMPRESSION, &compression);
144 switch (compression) {
145 case COMPRESSION_JPEG:
146 if (jpegcolormode == JPEGCOLORMODE_RGB)
147 photometric = PHOTOMETRIC_YCBCR;
148 else
149 photometric = PHOTOMETRIC_RGB;
150 TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
151 TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
152 break;
153 case COMPRESSION_LZW:
154 case COMPRESSION_DEFLATE:
155 if (predictor != 0)
156 TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
157 break;
158 }
159 TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
160 TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
161 TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
162 TIFFSetField(out, TIFFTAG_ROWSPERSTRIP,
163 rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip));
164 (void) TIFFGetField(in, TIFFTAG_PLANARCONFIG, &shortv);
165 if (cmap == -1)
166 cmap = checkcmap(1<<bitspersample, rmap, gmap, bmap);
167 if (cmap == 16) {
168 /*
169 * Convert 16-bit colormap to 8-bit.
170 */
171 int i;
172
173 for (i = (1<<bitspersample)-1; i >= 0; i--) {
174 #define CVT(x) (((x) * 255) / ((1L<<16)-1))
175 rmap[i] = CVT(rmap[i]);
176 gmap[i] = CVT(gmap[i]);
177 bmap[i] = CVT(bmap[i]);
178 }
179 }
180 { unsigned char *ibuf, *obuf;
181 register unsigned char* pp;
182 register uint32 x;
183 ibuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(in));
184 obuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(out));
185 switch (config) {
186 case PLANARCONFIG_CONTIG:
187 for (row = 0; row < imagelength; row++) {
188 if (!TIFFReadScanline(in, ibuf, row, 0))
189 goto done;
190 pp = obuf;
191 for (x = 0; x < imagewidth; x++) {
192 *pp++ = (unsigned char) rmap[ibuf[x]];
193 *pp++ = (unsigned char) gmap[ibuf[x]];
194 *pp++ = (unsigned char) bmap[ibuf[x]];
195 }
196 if (!TIFFWriteScanline(out, obuf, row, 0))
197 goto done;
198 }
199 break;
200 case PLANARCONFIG_SEPARATE:
201 for (row = 0; row < imagelength; row++) {
202 if (!TIFFReadScanline(in, ibuf, row, 0))
203 goto done;
204 for (pp = obuf, x = 0; x < imagewidth; x++)
205 *pp++ = (unsigned char) rmap[ibuf[x]];
206 if (!TIFFWriteScanline(out, obuf, row, 0))
207 goto done;
208 for (pp = obuf, x = 0; x < imagewidth; x++)
209 *pp++ = (unsigned char) gmap[ibuf[x]];
210 if (!TIFFWriteScanline(out, obuf, row, 0))
211 goto done;
212 for (pp = obuf, x = 0; x < imagewidth; x++)
213 *pp++ = (unsigned char) bmap[ibuf[x]];
214 if (!TIFFWriteScanline(out, obuf, row, 0))
215 goto done;
216 }
217 break;
218 }
219 _TIFFfree(ibuf);
220 _TIFFfree(obuf);
221 }
222 done:
223 (void) TIFFClose(in);
224 (void) TIFFClose(out);
225 return (0);
226 }
227
228 static int
processCompressOptions(char * opt)229 processCompressOptions(char* opt)
230 {
231 if (streq(opt, "none"))
232 compression = COMPRESSION_NONE;
233 else if (streq(opt, "packbits"))
234 compression = COMPRESSION_PACKBITS;
235 else if (strneq(opt, "jpeg", 4)) {
236 char* cp = strchr(opt, ':');
237
238 compression = COMPRESSION_JPEG;
239 while( cp )
240 {
241 if (isdigit((int)cp[1]))
242 quality = atoi(cp+1);
243 else if (cp[1] == 'r' )
244 jpegcolormode = JPEGCOLORMODE_RAW;
245 else
246 usage();
247
248 cp = strchr(cp+1,':');
249 }
250 } else if (strneq(opt, "lzw", 3)) {
251 char* cp = strchr(opt, ':');
252 if (cp)
253 predictor = atoi(cp+1);
254 compression = COMPRESSION_LZW;
255 } else if (strneq(opt, "zip", 3)) {
256 char* cp = strchr(opt, ':');
257 if (cp)
258 predictor = atoi(cp+1);
259 compression = COMPRESSION_DEFLATE;
260 } else
261 return (0);
262 return (1);
263 }
264
265 #define CopyField(tag, v) \
266 if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
267 #define CopyField2(tag, v1, v2) \
268 if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
269 #define CopyField3(tag, v1, v2, v3) \
270 if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
271 #define CopyField4(tag, v1, v2, v3, v4) \
272 if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
273
274 static void
cpTag(TIFF * in,TIFF * out,uint16 tag,uint16 count,TIFFDataType type)275 cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
276 {
277 switch (type) {
278 case TIFF_SHORT:
279 if (count == 1) {
280 uint16 shortv;
281 CopyField(tag, shortv);
282 } else if (count == 2) {
283 uint16 shortv1, shortv2;
284 CopyField2(tag, shortv1, shortv2);
285 } else if (count == 4) {
286 uint16 *tr, *tg, *tb, *ta;
287 CopyField4(tag, tr, tg, tb, ta);
288 } else if (count == (uint16) -1) {
289 uint16 shortv1;
290 uint16* shortav;
291 CopyField2(tag, shortv1, shortav);
292 }
293 break;
294 case TIFF_LONG:
295 { uint32 longv;
296 CopyField(tag, longv);
297 }
298 break;
299 case TIFF_RATIONAL:
300 if (count == 1) {
301 float floatv;
302 CopyField(tag, floatv);
303 } else if (count == (uint16) -1) {
304 float* floatav;
305 CopyField(tag, floatav);
306 }
307 break;
308 case TIFF_ASCII:
309 { char* stringv;
310 CopyField(tag, stringv);
311 }
312 break;
313 case TIFF_DOUBLE:
314 if (count == 1) {
315 double doublev;
316 CopyField(tag, doublev);
317 } else if (count == (uint16) -1) {
318 double* doubleav;
319 CopyField(tag, doubleav);
320 }
321 break;
322 default:
323 TIFFError(TIFFFileName(in),
324 "Data type %d is not supported, tag %d skipped.",
325 tag, type);
326 }
327 }
328
329 #undef CopyField4
330 #undef CopyField3
331 #undef CopyField2
332 #undef CopyField
333
334 static struct cpTag {
335 uint16 tag;
336 uint16 count;
337 TIFFDataType type;
338 } tags[] = {
339 { TIFFTAG_IMAGEWIDTH, 1, TIFF_LONG },
340 { TIFFTAG_IMAGELENGTH, 1, TIFF_LONG },
341 { TIFFTAG_BITSPERSAMPLE, 1, TIFF_SHORT },
342 { TIFFTAG_COMPRESSION, 1, TIFF_SHORT },
343 { TIFFTAG_FILLORDER, 1, TIFF_SHORT },
344 { TIFFTAG_ROWSPERSTRIP, 1, TIFF_LONG },
345 { TIFFTAG_GROUP3OPTIONS, 1, TIFF_LONG },
346 { TIFFTAG_SUBFILETYPE, 1, TIFF_LONG },
347 { TIFFTAG_THRESHHOLDING, 1, TIFF_SHORT },
348 { TIFFTAG_DOCUMENTNAME, 1, TIFF_ASCII },
349 { TIFFTAG_IMAGEDESCRIPTION, 1, TIFF_ASCII },
350 { TIFFTAG_MAKE, 1, TIFF_ASCII },
351 { TIFFTAG_MODEL, 1, TIFF_ASCII },
352 { TIFFTAG_ORIENTATION, 1, TIFF_SHORT },
353 { TIFFTAG_MINSAMPLEVALUE, 1, TIFF_SHORT },
354 { TIFFTAG_MAXSAMPLEVALUE, 1, TIFF_SHORT },
355 { TIFFTAG_XRESOLUTION, 1, TIFF_RATIONAL },
356 { TIFFTAG_YRESOLUTION, 1, TIFF_RATIONAL },
357 { TIFFTAG_PAGENAME, 1, TIFF_ASCII },
358 { TIFFTAG_XPOSITION, 1, TIFF_RATIONAL },
359 { TIFFTAG_YPOSITION, 1, TIFF_RATIONAL },
360 { TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG },
361 { TIFFTAG_RESOLUTIONUNIT, 1, TIFF_SHORT },
362 { TIFFTAG_PAGENUMBER, 2, TIFF_SHORT },
363 { TIFFTAG_SOFTWARE, 1, TIFF_ASCII },
364 { TIFFTAG_DATETIME, 1, TIFF_ASCII },
365 { TIFFTAG_ARTIST, 1, TIFF_ASCII },
366 { TIFFTAG_HOSTCOMPUTER, 1, TIFF_ASCII },
367 { TIFFTAG_WHITEPOINT, 2, TIFF_RATIONAL },
368 { TIFFTAG_PRIMARYCHROMATICITIES, (uint16) -1,TIFF_RATIONAL },
369 { TIFFTAG_HALFTONEHINTS, 2, TIFF_SHORT },
370 { TIFFTAG_BADFAXLINES, 1, TIFF_LONG },
371 { TIFFTAG_CLEANFAXDATA, 1, TIFF_SHORT },
372 { TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG },
373 { TIFFTAG_INKSET, 1, TIFF_SHORT },
374 { TIFFTAG_INKNAMES, 1, TIFF_ASCII },
375 { TIFFTAG_DOTRANGE, 2, TIFF_SHORT },
376 { TIFFTAG_TARGETPRINTER, 1, TIFF_ASCII },
377 { TIFFTAG_SAMPLEFORMAT, 1, TIFF_SHORT },
378 { TIFFTAG_YCBCRCOEFFICIENTS, (uint16) -1,TIFF_RATIONAL },
379 { TIFFTAG_YCBCRSUBSAMPLING, 2, TIFF_SHORT },
380 { TIFFTAG_YCBCRPOSITIONING, 1, TIFF_SHORT },
381 { TIFFTAG_REFERENCEBLACKWHITE, (uint16) -1,TIFF_RATIONAL },
382 };
383 #define NTAGS (sizeof (tags) / sizeof (tags[0]))
384
385 static void
cpTags(TIFF * in,TIFF * out)386 cpTags(TIFF* in, TIFF* out)
387 {
388 struct cpTag *p;
389 for (p = tags; p < &tags[NTAGS]; p++)
390 cpTag(in, out, p->tag, p->count, p->type);
391 }
392 #undef NTAGS
393
394 char* stuff[] = {
395 "usage: pal2rgb [options] input.tif output.tif",
396 "where options are:",
397 " -p contig pack samples contiguously (e.g. RGBRGB...)",
398 " -p separate store samples separately (e.g. RRR...GGG...BBB...)",
399 " -r # make each strip have no more than # rows",
400 " -C 8 assume 8-bit colormap values (instead of 16-bit)",
401 " -C 16 assume 16-bit colormap values",
402 "",
403 " -c lzw[:opts] compress output with Lempel-Ziv & Welch encoding",
404 " -c zip[:opts] compress output with deflate encoding",
405 " -c packbits compress output with packbits encoding",
406 " -c none use no compression algorithm on output",
407 "",
408 "LZW and deflate options:",
409 " # set predictor value",
410 "For example, -c lzw:2 to get LZW-encoded data with horizontal differencing",
411 NULL
412 };
413
414 static void
usage(void)415 usage(void)
416 {
417 char buf[BUFSIZ];
418 int i;
419
420 setbuf(stderr, buf);
421 fprintf(stderr, "%s\n\n", TIFFGetVersion());
422 for (i = 0; stuff[i] != NULL; i++)
423 fprintf(stderr, "%s\n", stuff[i]);
424 exit(-1);
425 }
426
427 /* vim: set ts=8 sts=8 sw=8 noet: */
428 /*
429 * Local Variables:
430 * mode: c
431 * c-basic-offset: 8
432 * fill-column: 78
433 * End:
434 */
435