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