]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/tools/tiffcp.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import libtiff 3.8.2 into the trunk
[wxWidgets.git] / src / tiff / tools / tiffcp.c
1 /* $Id$ */
2
3 /*
4 * Copyright (c) 1988-1997 Sam Leffler
5 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6 *
7 * Revised: 2/18/01 BAR -- added syntax for extracting single images from
8 * multi-image TIFF files.
9 *
10 * New syntax is: sourceFileName,image#
11 *
12 * image# ranges from 0..<n-1> where n is the # of images in the file.
13 * There may be no white space between the comma and the filename or
14 * image number.
15 *
16 * Example: tiffcp source.tif,1 destination.tif
17 *
18 * Copies the 2nd image in source.tif to the destination.
19 *
20 *****
21 * Permission to use, copy, modify, distribute, and sell this software and
22 * its documentation for any purpose is hereby granted without fee, provided
23 * that (i) the above copyright notices and this permission notice appear in
24 * all copies of the software and related documentation, and (ii) the names of
25 * Sam Leffler and Silicon Graphics may not be used in any advertising or
26 * publicity relating to the software without the specific, prior written
27 * permission of Sam Leffler and Silicon Graphics.
28 *
29 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
30 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
31 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
32 *
33 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
34 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
35 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
36 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
37 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
38 * OF THIS SOFTWARE.
39 */
40
41 #include "tif_config.h"
42
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46
47 #include <ctype.h>
48 #include <assert.h>
49
50 #ifdef HAVE_UNISTD_H
51 # include <unistd.h>
52 #endif
53
54 #include "tiffio.h"
55
56 #if defined(VMS)
57 #define unlink delete
58 #endif
59
60 #define streq(a,b) (strcmp(a,b) == 0)
61 #define strneq(a,b,n) (strncmp(a,b,n) == 0)
62
63 #define TRUE 1
64 #define FALSE 0
65
66 static int outtiled = -1;
67 static uint32 tilewidth;
68 static uint32 tilelength;
69
70 static uint16 config;
71 static uint16 compression;
72 static uint16 predictor;
73 static uint16 fillorder;
74 static uint16 orientation;
75 static uint32 rowsperstrip;
76 static uint32 g3opts;
77 static int ignore = FALSE; /* if true, ignore read errors */
78 static uint32 defg3opts = (uint32) -1;
79 static int quality = 75; /* JPEG quality */
80 static int jpegcolormode = JPEGCOLORMODE_RGB;
81 static uint16 defcompression = (uint16) -1;
82 static uint16 defpredictor = (uint16) -1;
83
84 static int tiffcp(TIFF*, TIFF*);
85 static int processCompressOptions(char*);
86 static void usage(void);
87
88 static char comma = ','; /* (default) comma separator character */
89 static TIFF* bias = NULL;
90 static int pageNum = 0;
91
92 static int nextSrcImage (TIFF *tif, char **imageSpec)
93 /*
94 seek to the next image specified in *imageSpec
95 returns 1 if success, 0 if no more images to process
96 *imageSpec=NULL if subsequent images should be processed in sequence
97 */
98 {
99 if (**imageSpec == comma) { /* if not @comma, we've done all images */
100 char *start = *imageSpec + 1;
101 tdir_t nextImage = (tdir_t)strtol(start, imageSpec, 0);
102 if (start == *imageSpec) nextImage = TIFFCurrentDirectory (tif);
103 if (**imageSpec)
104 {
105 if (**imageSpec == comma) {
106 /* a trailing comma denotes remaining images in sequence */
107 if ((*imageSpec)[1] == '\0') *imageSpec = NULL;
108 }else{
109 fprintf (stderr,
110 "Expected a %c separated image # list after %s\n",
111 comma, TIFFFileName (tif));
112 exit (-4); /* syntax error */
113 }
114 }
115 if (TIFFSetDirectory (tif, nextImage)) return 1;
116 fprintf (stderr, "%s%c%d not found!\n",
117 TIFFFileName(tif), comma, (int) nextImage);
118 }
119 return 0;
120 }
121
122
123 static TIFF* openSrcImage (char **imageSpec)
124 /*
125 imageSpec points to a pointer to a filename followed by optional ,image#'s
126 Open the TIFF file and assign *imageSpec to either NULL if there are
127 no images specified, or a pointer to the next image number text
128 */
129 {
130 TIFF *tif;
131 char *fn = *imageSpec;
132 *imageSpec = strchr (fn, comma);
133 if (*imageSpec) { /* there is at least one image number specifier */
134 **imageSpec = '\0';
135 tif = TIFFOpen (fn, "r");
136 /* but, ignore any single trailing comma */
137 if (!(*imageSpec)[1]) {*imageSpec = NULL; return tif;}
138 if (tif) {
139 **imageSpec = comma; /* replace the comma */
140 if (!nextSrcImage(tif, imageSpec)) {
141 TIFFClose (tif);
142 tif = NULL;
143 }
144 }
145 }else
146 tif = TIFFOpen (fn, "r");
147 return tif;
148 }
149
150
151 int
152 main(int argc, char* argv[])
153 {
154 uint16 defconfig = (uint16) -1;
155 uint16 deffillorder = 0;
156 uint32 deftilewidth = (uint32) -1;
157 uint32 deftilelength = (uint32) -1;
158 uint32 defrowsperstrip = (uint32) 0;
159 uint32 diroff = 0;
160 TIFF* in;
161 TIFF* out;
162 char mode[10];
163 char* mp = mode;
164 int c;
165 extern int optind;
166 extern char* optarg;
167
168 *mp++ = 'w';
169 *mp = '\0';
170 while ((c = getopt(argc, argv, ",:b:c:f:l:o:z:p:r:w:aistBLMC")) != -1)
171 switch (c) {
172 case ',':
173 if (optarg[0] != '=') usage();
174 comma = optarg[1];
175 break;
176 case 'b': /* this file is bias image subtracted from others */
177 if (bias) {
178 fputs ("Only 1 bias image may be specified\n", stderr);
179 exit (-2);
180 }
181 {
182 uint16 samples = (uint16) -1;
183 char **biasFn = &optarg;
184 bias = openSrcImage (biasFn);
185 if (!bias) exit (-5);
186 if (TIFFIsTiled (bias)) {
187 fputs ("Bias image must be organized in strips\n", stderr);
188 exit (-7);
189 }
190 TIFFGetField(bias, TIFFTAG_SAMPLESPERPIXEL, &samples);
191 if (samples != 1) {
192 fputs ("Bias image must be monochrome\n", stderr);
193 exit (-7);
194 }
195 }
196 break;
197 case 'a': /* append to output */
198 mode[0] = 'a';
199 break;
200 case 'c': /* compression scheme */
201 if (!processCompressOptions(optarg))
202 usage();
203 break;
204 case 'f': /* fill order */
205 if (streq(optarg, "lsb2msb"))
206 deffillorder = FILLORDER_LSB2MSB;
207 else if (streq(optarg, "msb2lsb"))
208 deffillorder = FILLORDER_MSB2LSB;
209 else
210 usage();
211 break;
212 case 'i': /* ignore errors */
213 ignore = TRUE;
214 break;
215 case 'l': /* tile length */
216 outtiled = TRUE;
217 deftilelength = atoi(optarg);
218 break;
219 case 'o': /* initial directory offset */
220 diroff = strtoul(optarg, NULL, 0);
221 break;
222 case 'p': /* planar configuration */
223 if (streq(optarg, "separate"))
224 defconfig = PLANARCONFIG_SEPARATE;
225 else if (streq(optarg, "contig"))
226 defconfig = PLANARCONFIG_CONTIG;
227 else
228 usage();
229 break;
230 case 'r': /* rows/strip */
231 defrowsperstrip = atol(optarg);
232 break;
233 case 's': /* generate stripped output */
234 outtiled = FALSE;
235 break;
236 case 't': /* generate tiled output */
237 outtiled = TRUE;
238 break;
239 case 'w': /* tile width */
240 outtiled = TRUE;
241 deftilewidth = atoi(optarg);
242 break;
243 case 'B':
244 *mp++ = 'b'; *mp = '\0';
245 break;
246 case 'L':
247 *mp++ = 'l'; *mp = '\0';
248 break;
249 case 'M':
250 *mp++ = 'm'; *mp = '\0';
251 break;
252 case 'C':
253 *mp++ = 'c'; *mp = '\0';
254 break;
255 case '?':
256 usage();
257 /*NOTREACHED*/
258 }
259 if (argc - optind < 2)
260 usage();
261 out = TIFFOpen(argv[argc-1], mode);
262 if (out == NULL)
263 return (-2);
264 if ((argc - optind) == 2)
265 pageNum = -1;
266 for (; optind < argc-1 ; optind++) {
267 char *imageCursor = argv[optind];
268 in = openSrcImage (&imageCursor);
269 if (in == NULL)
270 return (-3);
271 if (diroff != 0 && !TIFFSetSubDirectory(in, diroff)) {
272 TIFFError(TIFFFileName(in),
273 "Error, setting subdirectory at %#x", diroff);
274 (void) TIFFClose(out);
275 return (1);
276 }
277 for (;;) {
278 config = defconfig;
279 compression = defcompression;
280 predictor = defpredictor;
281 fillorder = deffillorder;
282 rowsperstrip = defrowsperstrip;
283 tilewidth = deftilewidth;
284 tilelength = deftilelength;
285 g3opts = defg3opts;
286 if (!tiffcp(in, out) || !TIFFWriteDirectory(out)) {
287 TIFFClose(out);
288 return (1);
289 }
290 if (imageCursor) { /* seek next image directory */
291 if (!nextSrcImage(in, &imageCursor)) break;
292 }else
293 if (!TIFFReadDirectory(in)) break;
294 }
295 TIFFClose(in);
296 }
297
298 TIFFClose(out);
299 return (0);
300 }
301
302
303 static void
304 processG3Options(char* cp)
305 {
306 if( (cp = strchr(cp, ':')) ) {
307 if (defg3opts == (uint32) -1)
308 defg3opts = 0;
309 do {
310 cp++;
311 if (strneq(cp, "1d", 2))
312 defg3opts &= ~GROUP3OPT_2DENCODING;
313 else if (strneq(cp, "2d", 2))
314 defg3opts |= GROUP3OPT_2DENCODING;
315 else if (strneq(cp, "fill", 4))
316 defg3opts |= GROUP3OPT_FILLBITS;
317 else
318 usage();
319 } while( (cp = strchr(cp, ':')) );
320 }
321 }
322
323 static int
324 processCompressOptions(char* opt)
325 {
326 if (streq(opt, "none")) {
327 defcompression = COMPRESSION_NONE;
328 } else if (streq(opt, "packbits")) {
329 defcompression = COMPRESSION_PACKBITS;
330 } else if (strneq(opt, "jpeg", 4)) {
331 char* cp = strchr(opt, ':');
332
333 defcompression = COMPRESSION_JPEG;
334 while( cp )
335 {
336 if (isdigit((int)cp[1]))
337 quality = atoi(cp+1);
338 else if (cp[1] == 'r' )
339 jpegcolormode = JPEGCOLORMODE_RAW;
340 else
341 usage();
342
343 cp = strchr(cp+1,':');
344 }
345 } else if (strneq(opt, "g3", 2)) {
346 processG3Options(opt);
347 defcompression = COMPRESSION_CCITTFAX3;
348 } else if (streq(opt, "g4")) {
349 defcompression = COMPRESSION_CCITTFAX4;
350 } else if (strneq(opt, "lzw", 3)) {
351 char* cp = strchr(opt, ':');
352 if (cp)
353 defpredictor = atoi(cp+1);
354 defcompression = COMPRESSION_LZW;
355 } else if (strneq(opt, "zip", 3)) {
356 char* cp = strchr(opt, ':');
357 if (cp)
358 defpredictor = atoi(cp+1);
359 defcompression = COMPRESSION_ADOBE_DEFLATE;
360 } else
361 return (0);
362 return (1);
363 }
364
365 char* stuff[] = {
366 "usage: tiffcp [options] input... output",
367 "where options are:",
368 " -a append to output instead of overwriting",
369 " -o offset set initial directory offset",
370 " -p contig pack samples contiguously (e.g. RGBRGB...)",
371 " -p separate store samples separately (e.g. RRR...GGG...BBB...)",
372 " -s write output in strips",
373 " -t write output in tiles",
374 " -i ignore read errors",
375 " -b file[,#] bias (dark) monochrome image to be subtracted from all others",
376 " -,=% use % rather than , to separate image #'s (per Note below)",
377 "",
378 " -r # make each strip have no more than # rows",
379 " -w # set output tile width (pixels)",
380 " -l # set output tile length (pixels)",
381 "",
382 " -f lsb2msb force lsb-to-msb FillOrder for output",
383 " -f msb2lsb force msb-to-lsb FillOrder for output",
384 "",
385 " -c lzw[:opts] compress output with Lempel-Ziv & Welch encoding",
386 " -c zip[:opts] compress output with deflate encoding",
387 " -c jpeg[:opts] compress output with JPEG encoding",
388 " -c packbits compress output with packbits encoding",
389 " -c g3[:opts] compress output with CCITT Group 3 encoding",
390 " -c g4 compress output with CCITT Group 4 encoding",
391 " -c none use no compression algorithm on output",
392 "",
393 "Group 3 options:",
394 " 1d use default CCITT Group 3 1D-encoding",
395 " 2d use optional CCITT Group 3 2D-encoding",
396 " fill byte-align EOL codes",
397 "For example, -c g3:2d:fill to get G3-2D-encoded data with byte-aligned EOLs",
398 "",
399 "JPEG options:",
400 " # set compression quality level (0-100, default 75)",
401 " r output color image as RGB rather than YCbCr",
402 "For example, -c jpeg:r:50 to get JPEG-encoded RGB data with 50% comp. quality",
403 "",
404 "LZW and deflate options:",
405 " # set predictor value",
406 "For example, -c lzw:2 to get LZW-encoded data with horizontal differencing",
407 "",
408 "Note that input filenames may be of the form filename,x,y,z",
409 "where x, y, and z specify image numbers in the filename to copy.",
410 "example: tiffcp -c none -b esp.tif,1 esp.tif,0 test.tif",
411 " subtract 2nd image in esp.tif from 1st yielding uncompressed result test.tif",
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 #define CopyField(tag, v) \
429 if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
430 #define CopyField2(tag, v1, v2) \
431 if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
432 #define CopyField3(tag, v1, v2, v3) \
433 if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
434 #define CopyField4(tag, v1, v2, v3, v4) \
435 if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
436
437 static void
438 cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
439 {
440 switch (type) {
441 case TIFF_SHORT:
442 if (count == 1) {
443 uint16 shortv;
444 CopyField(tag, shortv);
445 } else if (count == 2) {
446 uint16 shortv1, shortv2;
447 CopyField2(tag, shortv1, shortv2);
448 } else if (count == 4) {
449 uint16 *tr, *tg, *tb, *ta;
450 CopyField4(tag, tr, tg, tb, ta);
451 } else if (count == (uint16) -1) {
452 uint16 shortv1;
453 uint16* shortav;
454 CopyField2(tag, shortv1, shortav);
455 }
456 break;
457 case TIFF_LONG:
458 { uint32 longv;
459 CopyField(tag, longv);
460 }
461 break;
462 case TIFF_RATIONAL:
463 if (count == 1) {
464 float floatv;
465 CopyField(tag, floatv);
466 } else if (count == (uint16) -1) {
467 float* floatav;
468 CopyField(tag, floatav);
469 }
470 break;
471 case TIFF_ASCII:
472 { char* stringv;
473 CopyField(tag, stringv);
474 }
475 break;
476 case TIFF_DOUBLE:
477 if (count == 1) {
478 double doublev;
479 CopyField(tag, doublev);
480 } else if (count == (uint16) -1) {
481 double* doubleav;
482 CopyField(tag, doubleav);
483 }
484 break;
485 default:
486 TIFFError(TIFFFileName(in),
487 "Data type %d is not supported, tag %d skipped.",
488 tag, type);
489 }
490 }
491
492 static struct cpTag {
493 uint16 tag;
494 uint16 count;
495 TIFFDataType type;
496 } tags[] = {
497 { TIFFTAG_SUBFILETYPE, 1, TIFF_LONG },
498 { TIFFTAG_THRESHHOLDING, 1, TIFF_SHORT },
499 { TIFFTAG_DOCUMENTNAME, 1, TIFF_ASCII },
500 { TIFFTAG_IMAGEDESCRIPTION, 1, TIFF_ASCII },
501 { TIFFTAG_MAKE, 1, TIFF_ASCII },
502 { TIFFTAG_MODEL, 1, TIFF_ASCII },
503 { TIFFTAG_MINSAMPLEVALUE, 1, TIFF_SHORT },
504 { TIFFTAG_MAXSAMPLEVALUE, 1, TIFF_SHORT },
505 { TIFFTAG_XRESOLUTION, 1, TIFF_RATIONAL },
506 { TIFFTAG_YRESOLUTION, 1, TIFF_RATIONAL },
507 { TIFFTAG_PAGENAME, 1, TIFF_ASCII },
508 { TIFFTAG_XPOSITION, 1, TIFF_RATIONAL },
509 { TIFFTAG_YPOSITION, 1, TIFF_RATIONAL },
510 { TIFFTAG_RESOLUTIONUNIT, 1, TIFF_SHORT },
511 { TIFFTAG_SOFTWARE, 1, TIFF_ASCII },
512 { TIFFTAG_DATETIME, 1, TIFF_ASCII },
513 { TIFFTAG_ARTIST, 1, TIFF_ASCII },
514 { TIFFTAG_HOSTCOMPUTER, 1, TIFF_ASCII },
515 { TIFFTAG_WHITEPOINT, (uint16) -1, TIFF_RATIONAL },
516 { TIFFTAG_PRIMARYCHROMATICITIES,(uint16) -1,TIFF_RATIONAL },
517 { TIFFTAG_HALFTONEHINTS, 2, TIFF_SHORT },
518 { TIFFTAG_INKSET, 1, TIFF_SHORT },
519 { TIFFTAG_DOTRANGE, 2, TIFF_SHORT },
520 { TIFFTAG_TARGETPRINTER, 1, TIFF_ASCII },
521 { TIFFTAG_SAMPLEFORMAT, 1, TIFF_SHORT },
522 { TIFFTAG_YCBCRCOEFFICIENTS, (uint16) -1,TIFF_RATIONAL },
523 { TIFFTAG_YCBCRSUBSAMPLING, 2, TIFF_SHORT },
524 { TIFFTAG_YCBCRPOSITIONING, 1, TIFF_SHORT },
525 { TIFFTAG_REFERENCEBLACKWHITE, (uint16) -1,TIFF_RATIONAL },
526 { TIFFTAG_EXTRASAMPLES, (uint16) -1, TIFF_SHORT },
527 { TIFFTAG_SMINSAMPLEVALUE, 1, TIFF_DOUBLE },
528 { TIFFTAG_SMAXSAMPLEVALUE, 1, TIFF_DOUBLE },
529 { TIFFTAG_STONITS, 1, TIFF_DOUBLE },
530 };
531 #define NTAGS (sizeof (tags) / sizeof (tags[0]))
532
533 #define CopyTag(tag, count, type) cpTag(in, out, tag, count, type)
534
535 typedef int (*copyFunc)
536 (TIFF* in, TIFF* out, uint32 l, uint32 w, uint16 samplesperpixel);
537 static copyFunc pickCopyFunc(TIFF*, TIFF*, uint16, uint16);
538
539 static int
540 tiffcp(TIFF* in, TIFF* out)
541 {
542 uint16 bitspersample, samplesperpixel;
543 copyFunc cf;
544 uint32 width, length;
545 struct cpTag* p;
546
547 CopyField(TIFFTAG_IMAGEWIDTH, width);
548 CopyField(TIFFTAG_IMAGELENGTH, length);
549 CopyField(TIFFTAG_BITSPERSAMPLE, bitspersample);
550 CopyField(TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
551 if (compression != (uint16)-1)
552 TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
553 else
554 CopyField(TIFFTAG_COMPRESSION, compression);
555 if (compression == COMPRESSION_JPEG) {
556 uint16 input_compression, input_photometric;
557
558 if (TIFFGetField(in, TIFFTAG_COMPRESSION, &input_compression)
559 && input_compression == COMPRESSION_JPEG) {
560 TIFFSetField(in, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
561 }
562 if (TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &input_photometric)) {
563 if(input_photometric == PHOTOMETRIC_RGB) {
564 if (jpegcolormode == JPEGCOLORMODE_RGB)
565 TIFFSetField(out, TIFFTAG_PHOTOMETRIC,
566 PHOTOMETRIC_YCBCR);
567 else
568 TIFFSetField(out, TIFFTAG_PHOTOMETRIC,
569 PHOTOMETRIC_RGB);
570 } else
571 TIFFSetField(out, TIFFTAG_PHOTOMETRIC,
572 input_photometric);
573 }
574 }
575 else if (compression == COMPRESSION_SGILOG
576 || compression == COMPRESSION_SGILOG24)
577 TIFFSetField(out, TIFFTAG_PHOTOMETRIC,
578 samplesperpixel == 1 ?
579 PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV);
580 else
581 CopyTag(TIFFTAG_PHOTOMETRIC, 1, TIFF_SHORT);
582 if (fillorder != 0)
583 TIFFSetField(out, TIFFTAG_FILLORDER, fillorder);
584 else
585 CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT);
586 /*
587 * Will copy `Orientation' tag from input image
588 */
589 TIFFGetFieldDefaulted(in, TIFFTAG_ORIENTATION, &orientation);
590 switch (orientation) {
591 case ORIENTATION_BOTRIGHT:
592 case ORIENTATION_RIGHTBOT: /* XXX */
593 TIFFWarning(TIFFFileName(in), "using bottom-left orientation");
594 orientation = ORIENTATION_BOTLEFT;
595 /* fall thru... */
596 case ORIENTATION_LEFTBOT: /* XXX */
597 case ORIENTATION_BOTLEFT:
598 break;
599 case ORIENTATION_TOPRIGHT:
600 case ORIENTATION_RIGHTTOP: /* XXX */
601 default:
602 TIFFWarning(TIFFFileName(in), "using top-left orientation");
603 orientation = ORIENTATION_TOPLEFT;
604 /* fall thru... */
605 case ORIENTATION_LEFTTOP: /* XXX */
606 case ORIENTATION_TOPLEFT:
607 break;
608 }
609 TIFFSetField(out, TIFFTAG_ORIENTATION, orientation);
610 /*
611 * Choose tiles/strip for the output image according to
612 * the command line arguments (-tiles, -strips) and the
613 * structure of the input image.
614 */
615 if (outtiled == -1)
616 outtiled = TIFFIsTiled(in);
617 if (outtiled) {
618 /*
619 * Setup output file's tile width&height. If either
620 * is not specified, use either the value from the
621 * input image or, if nothing is defined, use the
622 * library default.
623 */
624 if (tilewidth == (uint32) -1)
625 TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth);
626 if (tilelength == (uint32) -1)
627 TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength);
628 TIFFDefaultTileSize(out, &tilewidth, &tilelength);
629 TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth);
630 TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength);
631 } else {
632 /*
633 * RowsPerStrip is left unspecified: use either the
634 * value from the input image or, if nothing is defined,
635 * use the library default.
636 */
637 if (rowsperstrip == (uint32) 0) {
638 if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP,
639 &rowsperstrip)) {
640 rowsperstrip =
641 TIFFDefaultStripSize(out, rowsperstrip);
642 }
643 if (rowsperstrip > length)
644 rowsperstrip = length;
645 }
646 else if (rowsperstrip == (uint32) -1)
647 rowsperstrip = length;
648 TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
649 }
650 if (config != (uint16) -1)
651 TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
652 else
653 CopyField(TIFFTAG_PLANARCONFIG, config);
654 if (samplesperpixel <= 4)
655 CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT);
656 CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT);
657 /* SMinSampleValue & SMaxSampleValue */
658 switch (compression) {
659 case COMPRESSION_JPEG:
660 TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
661 TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
662 break;
663 case COMPRESSION_LZW:
664 case COMPRESSION_ADOBE_DEFLATE:
665 case COMPRESSION_DEFLATE:
666 if (predictor != (uint16)-1)
667 TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
668 else
669 CopyField(TIFFTAG_PREDICTOR, predictor);
670 break;
671 case COMPRESSION_CCITTFAX3:
672 case COMPRESSION_CCITTFAX4:
673 if (compression == COMPRESSION_CCITTFAX3) {
674 if (g3opts != (uint32) -1)
675 TIFFSetField(out, TIFFTAG_GROUP3OPTIONS,
676 g3opts);
677 else
678 CopyField(TIFFTAG_GROUP3OPTIONS, g3opts);
679 } else
680 CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG);
681 CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG);
682 CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG);
683 CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG);
684 CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);
685 CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);
686 CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);
687 break;
688 }
689 { uint32 len32;
690 void** data;
691 if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data))
692 TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data);
693 }
694 { uint16 ninks;
695 const char* inknames;
696 if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) {
697 TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks);
698 if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) {
699 int inknameslen = strlen(inknames) + 1;
700 const char* cp = inknames;
701 while (ninks > 1) {
702 cp = strchr(cp, '\0');
703 if (cp) {
704 cp++;
705 inknameslen += (strlen(cp) + 1);
706 }
707 ninks--;
708 }
709 TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames);
710 }
711 }
712 }
713 {
714 unsigned short pg0, pg1;
715 if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) {
716 if (pageNum < 0) /* only one input file */
717 TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1);
718 else
719 TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0);
720 }
721 }
722
723 for (p = tags; p < &tags[NTAGS]; p++)
724 CopyTag(p->tag, p->count, p->type);
725
726 cf = pickCopyFunc(in, out, bitspersample, samplesperpixel);
727 return (cf ? (*cf)(in, out, length, width, samplesperpixel) : FALSE);
728 }
729
730 /*
731 * Copy Functions.
732 */
733 #define DECLAREcpFunc(x) \
734 static int x(TIFF* in, TIFF* out, \
735 uint32 imagelength, uint32 imagewidth, tsample_t spp)
736
737 #define DECLAREreadFunc(x) \
738 static int x(TIFF* in, \
739 uint8* buf, uint32 imagelength, uint32 imagewidth, tsample_t spp)
740 typedef int (*readFunc)(TIFF*, uint8*, uint32, uint32, tsample_t);
741
742 #define DECLAREwriteFunc(x) \
743 static int x(TIFF* out, \
744 uint8* buf, uint32 imagelength, uint32 imagewidth, tsample_t spp)
745 typedef int (*writeFunc)(TIFF*, uint8*, uint32, uint32, tsample_t);
746
747 /*
748 * Contig -> contig by scanline for rows/strip change.
749 */
750 DECLAREcpFunc(cpContig2ContigByRow)
751 {
752 tdata_t buf = _TIFFmalloc(TIFFScanlineSize(in));
753 uint32 row;
754
755 (void) imagewidth; (void) spp;
756 for (row = 0; row < imagelength; row++) {
757 if (TIFFReadScanline(in, buf, row, 0) < 0 && !ignore) {
758 TIFFError(TIFFFileName(in),
759 "Error, can't read scanline %lu",
760 (unsigned long) row);
761 goto bad;
762 }
763 if (TIFFWriteScanline(out, buf, row, 0) < 0) {
764 TIFFError(TIFFFileName(out),
765 "Error, can't write scanline %lu",
766 (unsigned long) row);
767 goto bad;
768 }
769 }
770 _TIFFfree(buf);
771 return 1;
772 bad:
773 _TIFFfree(buf);
774 return 0;
775 }
776
777
778 typedef void biasFn (void *image, void *bias, uint32 pixels);
779
780 #define subtract(bits) \
781 static void subtract##bits (void *i, void *b, uint32 pixels)\
782 {\
783 uint##bits *image = i;\
784 uint##bits *bias = b;\
785 while (pixels--) {\
786 *image = *image > *bias ? *image-*bias : 0;\
787 image++, bias++; \
788 } \
789 }
790
791 subtract(8)
792 subtract(16)
793 subtract(32)
794
795 static biasFn *lineSubtractFn (unsigned bits)
796 {
797 switch (bits) {
798 case 8: return subtract8;
799 case 16: return subtract16;
800 case 32: return subtract32;
801 }
802 return NULL;
803 }
804
805 /*
806 * Contig -> contig by scanline while subtracting a bias image.
807 */
808 DECLAREcpFunc(cpBiasedContig2Contig)
809 {
810 if (spp == 1) {
811 tsize_t biasSize = TIFFScanlineSize(bias);
812 tsize_t bufSize = TIFFScanlineSize(in);
813 tdata_t buf, biasBuf;
814 uint32 biasWidth = 0, biasLength = 0;
815 TIFFGetField(bias, TIFFTAG_IMAGEWIDTH, &biasWidth);
816 TIFFGetField(bias, TIFFTAG_IMAGELENGTH, &biasLength);
817 if (biasSize == bufSize &&
818 imagelength == biasLength && imagewidth == biasWidth) {
819 uint16 sampleBits = 0;
820 biasFn *subtractLine;
821 TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &sampleBits);
822 subtractLine = lineSubtractFn (sampleBits);
823 if (subtractLine) {
824 uint32 row;
825 buf = _TIFFmalloc(bufSize);
826 biasBuf = _TIFFmalloc(bufSize);
827 for (row = 0; row < imagelength; row++) {
828 if (TIFFReadScanline(in, buf, row, 0) < 0
829 && !ignore) {
830 TIFFError(TIFFFileName(in),
831 "Error, can't read scanline %lu",
832 (unsigned long) row);
833 goto bad;
834 }
835 if (TIFFReadScanline(bias, biasBuf, row, 0) < 0
836 && !ignore) {
837 TIFFError(TIFFFileName(in),
838 "Error, can't read biased scanline %lu",
839 (unsigned long) row);
840 goto bad;
841 }
842 subtractLine (buf, biasBuf, imagewidth);
843 if (TIFFWriteScanline(out, buf, row, 0) < 0) {
844 TIFFError(TIFFFileName(out),
845 "Error, can't write scanline %lu",
846 (unsigned long) row);
847 goto bad;
848 }
849 }
850
851 _TIFFfree(buf);
852 _TIFFfree(biasBuf);
853 TIFFSetDirectory(bias,
854 TIFFCurrentDirectory(bias)); /* rewind */
855 return 1;
856 bad:
857 _TIFFfree(buf);
858 _TIFFfree(biasBuf);
859 return 0;
860 } else {
861 TIFFError(TIFFFileName(in),
862 "No support for biasing %d bit pixels\n",
863 sampleBits);
864 return 0;
865 }
866 }
867 TIFFError(TIFFFileName(in),
868 "Bias image %s,%d\nis not the same size as %s,%d\n",
869 TIFFFileName(bias), TIFFCurrentDirectory(bias),
870 TIFFFileName(in), TIFFCurrentDirectory(in));
871 return 0;
872 } else {
873 TIFFError(TIFFFileName(in),
874 "Can't bias %s,%d as it has >1 Sample/Pixel\n",
875 TIFFFileName(in), TIFFCurrentDirectory(in));
876 return 0;
877 }
878
879 }
880
881
882 /*
883 * Strip -> strip for change in encoding.
884 */
885 DECLAREcpFunc(cpDecodedStrips)
886 {
887 tsize_t stripsize = TIFFStripSize(in);
888 tdata_t buf = _TIFFmalloc(stripsize);
889
890 (void) imagewidth; (void) spp;
891 if (buf) {
892 tstrip_t s, ns = TIFFNumberOfStrips(in);
893 uint32 row = 0;
894 for (s = 0; s < ns; s++) {
895 tsize_t cc = (row + rowsperstrip > imagelength) ?
896 TIFFVStripSize(in, imagelength - row) : stripsize;
897 if (TIFFReadEncodedStrip(in, s, buf, cc) < 0
898 && !ignore) {
899 TIFFError(TIFFFileName(in),
900 "Error, can't read strip %lu",
901 (unsigned long) s);
902 goto bad;
903 }
904 if (TIFFWriteEncodedStrip(out, s, buf, cc) < 0) {
905 TIFFError(TIFFFileName(out),
906 "Error, can't write strip %lu",
907 (unsigned long) s);
908 goto bad;
909 }
910 row += rowsperstrip;
911 }
912 _TIFFfree(buf);
913 return 1;
914 } else {
915 TIFFError(TIFFFileName(in),
916 "Error, can't allocate memory buffer of size %lu "
917 "to read strips", (unsigned long) stripsize);
918 return 0;
919 }
920
921 bad:
922 _TIFFfree(buf);
923 return 0;
924 }
925
926 /*
927 * Separate -> separate by row for rows/strip change.
928 */
929 DECLAREcpFunc(cpSeparate2SeparateByRow)
930 {
931 tdata_t buf = _TIFFmalloc(TIFFScanlineSize(in));
932 uint32 row;
933 tsample_t s;
934
935 (void) imagewidth;
936 for (s = 0; s < spp; s++) {
937 for (row = 0; row < imagelength; row++) {
938 if (TIFFReadScanline(in, buf, row, s) < 0 && !ignore) {
939 TIFFError(TIFFFileName(in),
940 "Error, can't read scanline %lu",
941 (unsigned long) row);
942 goto bad;
943 }
944 if (TIFFWriteScanline(out, buf, row, s) < 0) {
945 TIFFError(TIFFFileName(out),
946 "Error, can't write scanline %lu",
947 (unsigned long) row);
948 goto bad;
949 }
950 }
951 }
952 _TIFFfree(buf);
953 return 1;
954 bad:
955 _TIFFfree(buf);
956 return 0;
957 }
958
959 /*
960 * Contig -> separate by row.
961 */
962 DECLAREcpFunc(cpContig2SeparateByRow)
963 {
964 tdata_t inbuf = _TIFFmalloc(TIFFScanlineSize(in));
965 tdata_t outbuf = _TIFFmalloc(TIFFScanlineSize(out));
966 register uint8 *inp, *outp;
967 register uint32 n;
968 uint32 row;
969 tsample_t s;
970
971 /* unpack channels */
972 for (s = 0; s < spp; s++) {
973 for (row = 0; row < imagelength; row++) {
974 if (TIFFReadScanline(in, inbuf, row, 0) < 0
975 && !ignore) {
976 TIFFError(TIFFFileName(in),
977 "Error, can't read scanline %lu",
978 (unsigned long) row);
979 goto bad;
980 }
981 inp = ((uint8*)inbuf) + s;
982 outp = (uint8*)outbuf;
983 for (n = imagewidth; n-- > 0;) {
984 *outp++ = *inp;
985 inp += spp;
986 }
987 if (TIFFWriteScanline(out, outbuf, row, s) < 0) {
988 TIFFError(TIFFFileName(out),
989 "Error, can't write scanline %lu",
990 (unsigned long) row);
991 goto bad;
992 }
993 }
994 }
995 if (inbuf) _TIFFfree(inbuf);
996 if (outbuf) _TIFFfree(outbuf);
997 return 1;
998 bad:
999 if (inbuf) _TIFFfree(inbuf);
1000 if (outbuf) _TIFFfree(outbuf);
1001 return 0;
1002 }
1003
1004 /*
1005 * Separate -> contig by row.
1006 */
1007 DECLAREcpFunc(cpSeparate2ContigByRow)
1008 {
1009 tdata_t inbuf = _TIFFmalloc(TIFFScanlineSize(in));
1010 tdata_t outbuf = _TIFFmalloc(TIFFScanlineSize(out));
1011 register uint8 *inp, *outp;
1012 register uint32 n;
1013 uint32 row;
1014 tsample_t s;
1015
1016 for (row = 0; row < imagelength; row++) {
1017 /* merge channels */
1018 for (s = 0; s < spp; s++) {
1019 if (TIFFReadScanline(in, inbuf, row, s) < 0
1020 && !ignore) {
1021 TIFFError(TIFFFileName(in),
1022 "Error, can't read scanline %lu",
1023 (unsigned long) row);
1024 goto bad;
1025 }
1026 inp = (uint8*)inbuf;
1027 outp = ((uint8*)outbuf) + s;
1028 for (n = imagewidth; n-- > 0;) {
1029 *outp = *inp++;
1030 outp += spp;
1031 }
1032 }
1033 if (TIFFWriteScanline(out, outbuf, row, 0) < 0) {
1034 TIFFError(TIFFFileName(out),
1035 "Error, can't write scanline %lu",
1036 (unsigned long) row);
1037 goto bad;
1038 }
1039 }
1040 if (inbuf) _TIFFfree(inbuf);
1041 if (outbuf) _TIFFfree(outbuf);
1042 return 1;
1043 bad:
1044 if (inbuf) _TIFFfree(inbuf);
1045 if (outbuf) _TIFFfree(outbuf);
1046 return 0;
1047 }
1048
1049 static void
1050 cpStripToTile(uint8* out, uint8* in,
1051 uint32 rows, uint32 cols, int outskew, int inskew)
1052 {
1053 while (rows-- > 0) {
1054 uint32 j = cols;
1055 while (j-- > 0)
1056 *out++ = *in++;
1057 out += outskew;
1058 in += inskew;
1059 }
1060 }
1061
1062 static void
1063 cpContigBufToSeparateBuf(uint8* out, uint8* in,
1064 uint32 rows, uint32 cols, int outskew, int inskew, tsample_t spp,
1065 int bytes_per_sample )
1066 {
1067 while (rows-- > 0) {
1068 uint32 j = cols;
1069 while (j-- > 0)
1070 {
1071 int n = bytes_per_sample;
1072
1073 while( n-- ) {
1074 *out++ = *in++;
1075 }
1076 in += (spp-1) * bytes_per_sample;
1077 }
1078 out += outskew;
1079 in += inskew;
1080 }
1081 }
1082
1083 static void
1084 cpSeparateBufToContigBuf(uint8* out, uint8* in,
1085 uint32 rows, uint32 cols, int outskew, int inskew, tsample_t spp,
1086 int bytes_per_sample)
1087 {
1088 while (rows-- > 0) {
1089 uint32 j = cols;
1090 while (j-- > 0) {
1091 int n = bytes_per_sample;
1092
1093 while( n-- ) {
1094 *out++ = *in++;
1095 }
1096 out += (spp-1)*bytes_per_sample;
1097 }
1098 out += outskew;
1099 in += inskew;
1100 }
1101 }
1102
1103 static int
1104 cpImage(TIFF* in, TIFF* out, readFunc fin, writeFunc fout,
1105 uint32 imagelength, uint32 imagewidth, tsample_t spp)
1106 {
1107 int status = 0;
1108 tdata_t buf = NULL;
1109 tsize_t scanlinesize = TIFFRasterScanlineSize(in);
1110 tsize_t bytes = scanlinesize * (tsize_t)imagelength;
1111 /*
1112 * XXX: Check for integer overflow.
1113 */
1114 if (scanlinesize
1115 && imagelength
1116 && bytes / (tsize_t)imagelength == scanlinesize) {
1117 buf = _TIFFmalloc(bytes);
1118 if (buf) {
1119 if ((*fin)(in, (uint8*)buf, imagelength,
1120 imagewidth, spp)) {
1121 status = (*fout)(out, (uint8*)buf,
1122 imagelength, imagewidth, spp);
1123 }
1124 _TIFFfree(buf);
1125 } else {
1126 TIFFError(TIFFFileName(in),
1127 "Error, can't allocate space for image buffer");
1128 }
1129 } else {
1130 TIFFError(TIFFFileName(in), "Error, no space for image buffer");
1131 }
1132
1133 return status;
1134 }
1135
1136 DECLAREreadFunc(readContigStripsIntoBuffer)
1137 {
1138 tsize_t scanlinesize = TIFFScanlineSize(in);
1139 uint8* bufp = buf;
1140 uint32 row;
1141
1142 (void) imagewidth; (void) spp;
1143 for (row = 0; row < imagelength; row++) {
1144 if (TIFFReadScanline(in, (tdata_t) bufp, row, 0) < 0
1145 && !ignore) {
1146 TIFFError(TIFFFileName(in),
1147 "Error, can't read scanline %lu",
1148 (unsigned long) row);
1149 return 0;
1150 }
1151 bufp += scanlinesize;
1152 }
1153
1154 return 1;
1155 }
1156
1157 DECLAREreadFunc(readSeparateStripsIntoBuffer)
1158 {
1159 int status = 1;
1160 tsize_t scanlinesize = TIFFScanlineSize(in);
1161 tdata_t scanline = _TIFFmalloc(scanlinesize);
1162 if (!scanlinesize)
1163 return 0;
1164
1165 (void) imagewidth;
1166 if (scanline) {
1167 uint8* bufp = (uint8*) buf;
1168 uint32 row;
1169 tsample_t s;
1170 for (row = 0; row < imagelength; row++) {
1171 /* merge channels */
1172 for (s = 0; s < spp; s++) {
1173 uint8* bp = bufp + s;
1174 tsize_t n = scanlinesize;
1175 uint8* sbuf = scanline;
1176
1177 if (TIFFReadScanline(in, scanline, row, s) < 0
1178 && !ignore) {
1179 TIFFError(TIFFFileName(in),
1180 "Error, can't read scanline %lu",
1181 (unsigned long) row);
1182 status = 0;
1183 goto done;
1184 }
1185 while (n-- > 0)
1186 *bp = *sbuf++, bp += spp;
1187 }
1188 bufp += scanlinesize * spp;
1189 }
1190 }
1191
1192 done:
1193 _TIFFfree(scanline);
1194 return status;
1195 }
1196
1197 DECLAREreadFunc(readContigTilesIntoBuffer)
1198 {
1199 int status = 1;
1200 tdata_t tilebuf = _TIFFmalloc(TIFFTileSize(in));
1201 uint32 imagew = TIFFScanlineSize(in);
1202 uint32 tilew = TIFFTileRowSize(in);
1203 int iskew = imagew - tilew;
1204 uint8* bufp = (uint8*) buf;
1205 uint32 tw, tl;
1206 uint32 row;
1207
1208 (void) spp;
1209 if (tilebuf == 0)
1210 return 0;
1211 (void) TIFFGetField(in, TIFFTAG_TILEWIDTH, &tw);
1212 (void) TIFFGetField(in, TIFFTAG_TILELENGTH, &tl);
1213
1214 for (row = 0; row < imagelength; row += tl) {
1215 uint32 nrow = (row+tl > imagelength) ? imagelength-row : tl;
1216 uint32 colb = 0;
1217 uint32 col;
1218
1219 for (col = 0; col < imagewidth; col += tw) {
1220 if (TIFFReadTile(in, tilebuf, col, row, 0, 0) < 0
1221 && !ignore) {
1222 TIFFError(TIFFFileName(in),
1223 "Error, can't read tile at %lu %lu",
1224 (unsigned long) col,
1225 (unsigned long) row);
1226 status = 0;
1227 goto done;
1228 }
1229 if (colb + tilew > imagew) {
1230 uint32 width = imagew - colb;
1231 uint32 oskew = tilew - width;
1232 cpStripToTile(bufp + colb,
1233 tilebuf, nrow, width,
1234 oskew + iskew, oskew );
1235 } else
1236 cpStripToTile(bufp + colb,
1237 tilebuf, nrow, tilew,
1238 iskew, 0);
1239 colb += tilew;
1240 }
1241 bufp += imagew * nrow;
1242 }
1243 done:
1244 _TIFFfree(tilebuf);
1245 return status;
1246 }
1247
1248 DECLAREreadFunc(readSeparateTilesIntoBuffer)
1249 {
1250 int status = 1;
1251 uint32 imagew = TIFFRasterScanlineSize(in);
1252 uint32 tilew = TIFFTileRowSize(in);
1253 int iskew = imagew - tilew*spp;
1254 tdata_t tilebuf = _TIFFmalloc(TIFFTileSize(in));
1255 uint8* bufp = (uint8*) buf;
1256 uint32 tw, tl;
1257 uint32 row;
1258 uint16 bps, bytes_per_sample;
1259
1260 if (tilebuf == 0)
1261 return 0;
1262 (void) TIFFGetField(in, TIFFTAG_TILEWIDTH, &tw);
1263 (void) TIFFGetField(in, TIFFTAG_TILELENGTH, &tl);
1264 (void) TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bps);
1265 assert( bps % 8 == 0 );
1266 bytes_per_sample = bps/8;
1267
1268 for (row = 0; row < imagelength; row += tl) {
1269 uint32 nrow = (row+tl > imagelength) ? imagelength-row : tl;
1270 uint32 colb = 0;
1271 uint32 col;
1272
1273 for (col = 0; col < imagewidth; col += tw) {
1274 tsample_t s;
1275
1276 for (s = 0; s < spp; s++) {
1277 if (TIFFReadTile(in, tilebuf, col, row, 0, s) < 0
1278 && !ignore) {
1279 TIFFError(TIFFFileName(in),
1280 "Error, can't read tile at %lu %lu, "
1281 "sample %lu",
1282 (unsigned long) col,
1283 (unsigned long) row,
1284 (unsigned long) s);
1285 status = 0;
1286 goto done;
1287 }
1288 /*
1289 * Tile is clipped horizontally. Calculate
1290 * visible portion and skewing factors.
1291 */
1292 if (colb + tilew*spp > imagew) {
1293 uint32 width = imagew - colb;
1294 int oskew = tilew*spp - width;
1295 cpSeparateBufToContigBuf(
1296 bufp+colb+s*bytes_per_sample,
1297 tilebuf, nrow,
1298 width/(spp*bytes_per_sample),
1299 oskew + iskew,
1300 oskew/spp, spp,
1301 bytes_per_sample);
1302 } else
1303 cpSeparateBufToContigBuf(
1304 bufp+colb+s*bytes_per_sample,
1305 tilebuf, nrow, tw,
1306 iskew, 0, spp,
1307 bytes_per_sample);
1308 }
1309 colb += tilew*spp;
1310 }
1311 bufp += imagew * nrow;
1312 }
1313 done:
1314 _TIFFfree(tilebuf);
1315 return status;
1316 }
1317
1318 DECLAREwriteFunc(writeBufferToContigStrips)
1319 {
1320 uint32 row, rowsperstrip;
1321 tstrip_t strip = 0;
1322
1323 (void) imagewidth; (void) spp;
1324 (void) TIFFGetFieldDefaulted(out, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1325 for (row = 0; row < imagelength; row += rowsperstrip) {
1326 uint32 nrows = (row+rowsperstrip > imagelength) ?
1327 imagelength-row : rowsperstrip;
1328 tsize_t stripsize = TIFFVStripSize(out, nrows);
1329 if (TIFFWriteEncodedStrip(out, strip++, buf, stripsize) < 0) {
1330 TIFFError(TIFFFileName(out),
1331 "Error, can't write strip %lu", strip - 1);
1332 return 0;
1333 }
1334 buf += stripsize;
1335 }
1336 return 1;
1337 }
1338
1339 DECLAREwriteFunc(writeBufferToSeparateStrips)
1340 {
1341 uint32 rowsize = imagewidth * spp;
1342 uint32 rowsperstrip;
1343 tdata_t obuf = _TIFFmalloc(TIFFStripSize(out));
1344 tstrip_t strip = 0;
1345 tsample_t s;
1346
1347 if (obuf == NULL)
1348 return (0);
1349 (void) TIFFGetFieldDefaulted(out, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1350 for (s = 0; s < spp; s++) {
1351 uint32 row;
1352 for (row = 0; row < imagelength; row += rowsperstrip) {
1353 uint32 nrows = (row+rowsperstrip > imagelength) ?
1354 imagelength-row : rowsperstrip;
1355 tsize_t stripsize = TIFFVStripSize(out, nrows);
1356
1357 cpContigBufToSeparateBuf(
1358 obuf, (uint8*) buf + row*rowsize + s,
1359 nrows, imagewidth, 0, 0, spp, 1);
1360 if (TIFFWriteEncodedStrip(out, strip++, obuf, stripsize) < 0) {
1361 TIFFError(TIFFFileName(out),
1362 "Error, can't write strip %lu",
1363 strip - 1);
1364 _TIFFfree(obuf);
1365 return 0;
1366 }
1367 }
1368 }
1369 _TIFFfree(obuf);
1370 return 1;
1371
1372 }
1373
1374 DECLAREwriteFunc(writeBufferToContigTiles)
1375 {
1376 uint32 imagew = TIFFScanlineSize(out);
1377 uint32 tilew = TIFFTileRowSize(out);
1378 int iskew = imagew - tilew;
1379 tdata_t obuf = _TIFFmalloc(TIFFTileSize(out));
1380 uint8* bufp = (uint8*) buf;
1381 uint32 tl, tw;
1382 uint32 row;
1383
1384 (void) spp;
1385 if (obuf == NULL)
1386 return 0;
1387 (void) TIFFGetField(out, TIFFTAG_TILELENGTH, &tl);
1388 (void) TIFFGetField(out, TIFFTAG_TILEWIDTH, &tw);
1389 for (row = 0; row < imagelength; row += tilelength) {
1390 uint32 nrow = (row+tl > imagelength) ? imagelength-row : tl;
1391 uint32 colb = 0;
1392 uint32 col;
1393
1394 for (col = 0; col < imagewidth; col += tw) {
1395 /*
1396 * Tile is clipped horizontally. Calculate
1397 * visible portion and skewing factors.
1398 */
1399 if (colb + tilew > imagew) {
1400 uint32 width = imagew - colb;
1401 int oskew = tilew - width;
1402 cpStripToTile(obuf, bufp + colb, nrow, width,
1403 oskew, oskew + iskew);
1404 } else
1405 cpStripToTile(obuf, bufp + colb, nrow, tilew,
1406 0, iskew);
1407 if (TIFFWriteTile(out, obuf, col, row, 0, 0) < 0) {
1408 TIFFError(TIFFFileName(out),
1409 "Error, can't write tile at %lu %lu",
1410 (unsigned long) col,
1411 (unsigned long) row);
1412 _TIFFfree(obuf);
1413 return 0;
1414 }
1415 colb += tilew;
1416 }
1417 bufp += nrow * imagew;
1418 }
1419 _TIFFfree(obuf);
1420 return 1;
1421 }
1422
1423 DECLAREwriteFunc(writeBufferToSeparateTiles)
1424 {
1425 uint32 imagew = TIFFScanlineSize(out);
1426 tsize_t tilew = TIFFTileRowSize(out);
1427 uint32 iimagew = TIFFRasterScanlineSize(out);
1428 int iskew = iimagew - tilew*spp;
1429 tdata_t obuf = _TIFFmalloc(TIFFTileSize(out));
1430 uint8* bufp = (uint8*) buf;
1431 uint32 tl, tw;
1432 uint32 row;
1433 uint16 bps, bytes_per_sample;
1434
1435 if (obuf == NULL)
1436 return 0;
1437 (void) TIFFGetField(out, TIFFTAG_TILELENGTH, &tl);
1438 (void) TIFFGetField(out, TIFFTAG_TILEWIDTH, &tw);
1439 (void) TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps);
1440 assert( bps % 8 == 0 );
1441 bytes_per_sample = bps/8;
1442
1443 for (row = 0; row < imagelength; row += tl) {
1444 uint32 nrow = (row+tl > imagelength) ? imagelength-row : tl;
1445 uint32 colb = 0;
1446 uint32 col;
1447
1448 for (col = 0; col < imagewidth; col += tw) {
1449 tsample_t s;
1450 for (s = 0; s < spp; s++) {
1451 /*
1452 * Tile is clipped horizontally. Calculate
1453 * visible portion and skewing factors.
1454 */
1455 if (colb + tilew > imagew) {
1456 uint32 width = (imagew - colb);
1457 int oskew = tilew - width;
1458
1459 cpContigBufToSeparateBuf(obuf,
1460 bufp + (colb*spp) + s,
1461 nrow, width/bytes_per_sample,
1462 oskew, (oskew*spp)+iskew, spp,
1463 bytes_per_sample);
1464 } else
1465 cpContigBufToSeparateBuf(obuf,
1466 bufp + (colb*spp) + s,
1467 nrow, tilewidth,
1468 0, iskew, spp,
1469 bytes_per_sample);
1470 if (TIFFWriteTile(out, obuf, col, row, 0, s) < 0) {
1471 TIFFError(TIFFFileName(out),
1472 "Error, can't write tile at %lu %lu "
1473 "sample %lu",
1474 (unsigned long) col,
1475 (unsigned long) row,
1476 (unsigned long) s);
1477 _TIFFfree(obuf);
1478 return 0;
1479 }
1480 }
1481 colb += tilew;
1482 }
1483 bufp += nrow * iimagew;
1484 }
1485 _TIFFfree(obuf);
1486 return 1;
1487 }
1488
1489 /*
1490 * Contig strips -> contig tiles.
1491 */
1492 DECLAREcpFunc(cpContigStrips2ContigTiles)
1493 {
1494 return cpImage(in, out,
1495 readContigStripsIntoBuffer,
1496 writeBufferToContigTiles,
1497 imagelength, imagewidth, spp);
1498 }
1499
1500 /*
1501 * Contig strips -> separate tiles.
1502 */
1503 DECLAREcpFunc(cpContigStrips2SeparateTiles)
1504 {
1505 return cpImage(in, out,
1506 readContigStripsIntoBuffer,
1507 writeBufferToSeparateTiles,
1508 imagelength, imagewidth, spp);
1509 }
1510
1511 /*
1512 * Separate strips -> contig tiles.
1513 */
1514 DECLAREcpFunc(cpSeparateStrips2ContigTiles)
1515 {
1516 return cpImage(in, out,
1517 readSeparateStripsIntoBuffer,
1518 writeBufferToContigTiles,
1519 imagelength, imagewidth, spp);
1520 }
1521
1522 /*
1523 * Separate strips -> separate tiles.
1524 */
1525 DECLAREcpFunc(cpSeparateStrips2SeparateTiles)
1526 {
1527 return cpImage(in, out,
1528 readSeparateStripsIntoBuffer,
1529 writeBufferToSeparateTiles,
1530 imagelength, imagewidth, spp);
1531 }
1532
1533 /*
1534 * Contig strips -> contig tiles.
1535 */
1536 DECLAREcpFunc(cpContigTiles2ContigTiles)
1537 {
1538 return cpImage(in, out,
1539 readContigTilesIntoBuffer,
1540 writeBufferToContigTiles,
1541 imagelength, imagewidth, spp);
1542 }
1543
1544 /*
1545 * Contig tiles -> separate tiles.
1546 */
1547 DECLAREcpFunc(cpContigTiles2SeparateTiles)
1548 {
1549 return cpImage(in, out,
1550 readContigTilesIntoBuffer,
1551 writeBufferToSeparateTiles,
1552 imagelength, imagewidth, spp);
1553 }
1554
1555 /*
1556 * Separate tiles -> contig tiles.
1557 */
1558 DECLAREcpFunc(cpSeparateTiles2ContigTiles)
1559 {
1560 return cpImage(in, out,
1561 readSeparateTilesIntoBuffer,
1562 writeBufferToContigTiles,
1563 imagelength, imagewidth, spp);
1564 }
1565
1566 /*
1567 * Separate tiles -> separate tiles (tile dimension change).
1568 */
1569 DECLAREcpFunc(cpSeparateTiles2SeparateTiles)
1570 {
1571 return cpImage(in, out,
1572 readSeparateTilesIntoBuffer,
1573 writeBufferToSeparateTiles,
1574 imagelength, imagewidth, spp);
1575 }
1576
1577 /*
1578 * Contig tiles -> contig tiles (tile dimension change).
1579 */
1580 DECLAREcpFunc(cpContigTiles2ContigStrips)
1581 {
1582 return cpImage(in, out,
1583 readContigTilesIntoBuffer,
1584 writeBufferToContigStrips,
1585 imagelength, imagewidth, spp);
1586 }
1587
1588 /*
1589 * Contig tiles -> separate strips.
1590 */
1591 DECLAREcpFunc(cpContigTiles2SeparateStrips)
1592 {
1593 return cpImage(in, out,
1594 readContigTilesIntoBuffer,
1595 writeBufferToSeparateStrips,
1596 imagelength, imagewidth, spp);
1597 }
1598
1599 /*
1600 * Separate tiles -> contig strips.
1601 */
1602 DECLAREcpFunc(cpSeparateTiles2ContigStrips)
1603 {
1604 return cpImage(in, out,
1605 readSeparateTilesIntoBuffer,
1606 writeBufferToContigStrips,
1607 imagelength, imagewidth, spp);
1608 }
1609
1610 /*
1611 * Separate tiles -> separate strips.
1612 */
1613 DECLAREcpFunc(cpSeparateTiles2SeparateStrips)
1614 {
1615 return cpImage(in, out,
1616 readSeparateTilesIntoBuffer,
1617 writeBufferToSeparateStrips,
1618 imagelength, imagewidth, spp);
1619 }
1620
1621 /*
1622 * Select the appropriate copy function to use.
1623 */
1624 static copyFunc
1625 pickCopyFunc(TIFF* in, TIFF* out, uint16 bitspersample, uint16 samplesperpixel)
1626 {
1627 uint16 shortv;
1628 uint32 w, l, tw, tl;
1629 int bychunk;
1630
1631 (void) TIFFGetField(in, TIFFTAG_PLANARCONFIG, &shortv);
1632 if (shortv != config && bitspersample != 8 && samplesperpixel > 1) {
1633 fprintf(stderr,
1634 "%s: Cannot handle different planar configuration w/ bits/sample != 8\n",
1635 TIFFFileName(in));
1636 return (NULL);
1637 }
1638 TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &w);
1639 TIFFGetField(in, TIFFTAG_IMAGELENGTH, &l);
1640 if (!(TIFFIsTiled(out) || TIFFIsTiled(in))) {
1641 uint32 irps = (uint32) -1L;
1642 TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &irps);
1643 /* if biased, force decoded copying to allow image subtraction */
1644 bychunk = !bias && (rowsperstrip == irps);
1645 }else{ /* either in or out is tiled */
1646 if (bias) {
1647 fprintf(stderr,
1648 "%s: Cannot handle tiled configuration w/bias image\n",
1649 TIFFFileName(in));
1650 return (NULL);
1651 }
1652 if (TIFFIsTiled(out)) {
1653 if (!TIFFGetField(in, TIFFTAG_TILEWIDTH, &tw))
1654 tw = w;
1655 if (!TIFFGetField(in, TIFFTAG_TILELENGTH, &tl))
1656 tl = l;
1657 bychunk = (tw == tilewidth && tl == tilelength);
1658 } else { /* out's not, so in must be tiled */
1659 TIFFGetField(in, TIFFTAG_TILEWIDTH, &tw);
1660 TIFFGetField(in, TIFFTAG_TILELENGTH, &tl);
1661 bychunk = (tw == w && tl == rowsperstrip);
1662 }
1663 }
1664 #define T 1
1665 #define F 0
1666 #define pack(a,b,c,d,e) ((long)(((a)<<11)|((b)<<3)|((c)<<2)|((d)<<1)|(e)))
1667 switch(pack(shortv,config,TIFFIsTiled(in),TIFFIsTiled(out),bychunk)) {
1668 /* Strips -> Tiles */
1669 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, F,T,F):
1670 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, F,T,T):
1671 return cpContigStrips2ContigTiles;
1672 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, F,T,F):
1673 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, F,T,T):
1674 return cpContigStrips2SeparateTiles;
1675 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, F,T,F):
1676 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, F,T,T):
1677 return cpSeparateStrips2ContigTiles;
1678 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, F,T,F):
1679 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, F,T,T):
1680 return cpSeparateStrips2SeparateTiles;
1681 /* Tiles -> Tiles */
1682 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, T,T,F):
1683 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, T,T,T):
1684 return cpContigTiles2ContigTiles;
1685 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, T,T,F):
1686 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, T,T,T):
1687 return cpContigTiles2SeparateTiles;
1688 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, T,T,F):
1689 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, T,T,T):
1690 return cpSeparateTiles2ContigTiles;
1691 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, T,T,F):
1692 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, T,T,T):
1693 return cpSeparateTiles2SeparateTiles;
1694 /* Tiles -> Strips */
1695 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, T,F,F):
1696 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, T,F,T):
1697 return cpContigTiles2ContigStrips;
1698 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, T,F,F):
1699 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, T,F,T):
1700 return cpContigTiles2SeparateStrips;
1701 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, T,F,F):
1702 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, T,F,T):
1703 return cpSeparateTiles2ContigStrips;
1704 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, T,F,F):
1705 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, T,F,T):
1706 return cpSeparateTiles2SeparateStrips;
1707 /* Strips -> Strips */
1708 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, F,F,F):
1709 return bias ? cpBiasedContig2Contig : cpContig2ContigByRow;
1710 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG, F,F,T):
1711 return cpDecodedStrips;
1712 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, F,F,F):
1713 case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE, F,F,T):
1714 return cpContig2SeparateByRow;
1715 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, F,F,F):
1716 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG, F,F,T):
1717 return cpSeparate2ContigByRow;
1718 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, F,F,F):
1719 case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE, F,F,T):
1720 return cpSeparate2SeparateByRow;
1721 }
1722 #undef pack
1723 #undef F
1724 #undef T
1725 fprintf(stderr, "tiffcp: %s: Don't know how to copy/convert image.\n",
1726 TIFFFileName(in));
1727 return (NULL);
1728 }
1729
1730 /* vim: set ts=8 sts=8 sw=8 noet: */
wxWidgets (Impactor)