]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/tools/tiff2ps.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Correctly restore the originally used C locale in wxLocale dtor.
[wxWidgets.git] / src / tiff / tools / tiff2ps.c
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 <stdlib.h> /* for atof */
31 #include <math.h>
32 #include <time.h>
33 #include <string.h>
34
35 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif
38
39 #ifdef NEED_LIBPORT
40 # include "libport.h"
41 #endif
42
43 #include "tiffio.h"
44
45 /*
46 * Revision history
47 *
48 * 2010-Sep-17
49 * Richard Nolde: Reinstate code from Feb 2009 that never got
50 * accepted into CVS with major modifications to handle -H and -W
51 * options. Replaced original PlaceImage function with several
52 * new functions that make support for multiple output pages
53 * from a single image easier to understand. Added additional
54 * warning messages for incompatible command line options.
55 * Add new command line options to specify PageOrientation
56 * Document Structuring Comment for landscape or portrait
57 * and code to determine the values from ouput width and height
58 * if not specified on the command line.
59 * Add new command line option to specify document creator
60 * as an alterntive to the string "tiff2ps" following model
61 * of patch submitted by Thomas Jarosch for specifiying a
62 * document title which is also supported now.
63 *
64 * 2009-Feb-11
65 * Richard Nolde: Added support for rotations of 90, 180, 270
66 * and auto using -r <90|180|270|auto>. Auto picks the best
67 * fit for the image on the specified paper size (eg portrait
68 * or landscape) if -h or -w is specified. Rotation is in
69 * degrees counterclockwise since that is how Postscript does
70 * it. The auto opption rotates the image 90 degrees ccw to
71 * produce landscape if that is a better fit than portait.
72 *
73 * Cleaned up code in TIFF2PS and broke into smaller functions
74 * to simplify rotations.
75 *
76 * Identified incompatible options and returned errors, eg
77 * -i for imagemask operator is only available for Level2 or
78 * Level3 Postscript in the current implmentation since there
79 * is a difference in the way the operands are called for Level1
80 * and there is no function to provide the Level1 version.
81 * -H was not handled properly if -h and/or -w were specified.
82 * It should only clip the masked images if the scaled image
83 * exceeds the maxPageHeight specified with -H.
84 *
85 * New design allows for all of the following combinations:
86 * Conversion of TIFF to Postscript with optional rotations
87 * of 90, 180, 270, or auto degrees counterclockwise
88 * Conversion of TIFF to Postscript with entire image scaled
89 * to maximum of values spedified with -h or -w while
90 * maintaining aspect ratio. Same rotations apply.
91 * Conversion of TIFF to Postscript with clipping of output
92 * viewport to height specified with -H, producing multiple
93 * pages at this height and original width as needed.
94 * Same rotations apply.
95 * Conversion of TIFF to Postscript with image scaled to
96 * maximum specified by -h and -w and the resulting scaled
97 * image is presented in an output viewport clipped by -H height.
98 * The same rotations apply.
99 *
100 * Added maxPageWidth option using -W flag. MaxPageHeight and
101 * MaxPageWidth are mutually exclusive since the aspect ratio
102 * cannot be maintained if you set both.
103 * Rewrote PlaceImage to allow maxPageHeight and maxPageWidth
104 * options to work with values smaller or larger than the
105 * physical paper size and still preserve the aspect ratio.
106 * This is accomplished by creating multiple pages across
107 * as well as down if need be.
108 *
109 * 2001-Mar-21
110 * I (Bruce A. Mallett) added this revision history comment ;)
111 *
112 * Fixed PS_Lvl2page() code which outputs non-ASCII85 raw
113 * data. Moved test for when to output a line break to
114 * *after* the output of a character. This just serves
115 * to fix an eye-nuisance where the first line of raw
116 * data was one character shorter than subsequent lines.
117 *
118 * Added an experimental ASCII85 encoder which can be used
119 * only when there is a single buffer of bytes to be encoded.
120 * This version is much faster at encoding a straight-line
121 * buffer of data because it can avoid a lot of the loop
122 * overhead of the byte-by-byte version. To use this version
123 * you need to define EXP_ASCII85ENCODER (experimental ...).
124 *
125 * Added bug fix given by Michael Schmidt to PS_Lvl2page()
126 * in which an end-of-data marker ('>') was not being output
127 * when producing non-ASCII85 encoded PostScript Level 2
128 * data.
129 *
130 * Fixed PS_Lvl2colorspace() so that it no longer assumes that
131 * a TIFF having more than 2 planes is a CMYK. This routine
132 * no longer looks at the samples per pixel but instead looks
133 * at the "photometric" value. This change allows support of
134 * CMYK TIFFs.
135 *
136 * Modified the PostScript L2 imaging loop so as to test if
137 * the input stream is still open before attempting to do a
138 * flushfile on it. This was done because some RIPs close
139 * the stream after doing the image operation.
140 *
141 * Got rid of the realloc() being done inside a loop in the
142 * PSRawDataBW() routine. The code now walks through the
143 * byte-size array outside the loop to determine the largest
144 * size memory block that will be needed.
145 *
146 * Added "-m" switch to ask tiff2ps to, where possible, use the
147 * "imagemask" operator instead of the "image" operator.
148 *
149 * Added the "-i #" switch to allow interpolation to be disabled.
150 *
151 * Unrolled a loop or two to improve performance.
152 */
153
154 /*
155 * Define EXP_ASCII85ENCODER if you want to use an experimental
156 * version of the ASCII85 encoding routine. The advantage of
157 * using this routine is that tiff2ps will convert to ASCII85
158 * encoding at between 3 and 4 times the speed as compared to
159 * using the old (non-experimental) encoder. The disadvantage
160 * is that you will be using a new (and unproven) encoding
161 * routine. So user beware, you have been warned!
162 */
163
164 #define EXP_ASCII85ENCODER
165
166 /*
167 * NB: this code assumes uint32 works with printf's %l[ud].
168 */
169 #ifndef TRUE
170 #define TRUE 1
171 #define FALSE 0
172 #endif
173
174 int ascii85 = FALSE; /* use ASCII85 encoding */
175 int interpolate = TRUE; /* interpolate level2 image */
176 int level2 = FALSE; /* generate PostScript level 2 */
177 int level3 = FALSE; /* generate PostScript level 3 */
178 int printAll = FALSE; /* print all images in file */
179 int generateEPSF = TRUE; /* generate Encapsulated PostScript */
180 int PSduplex = FALSE; /* enable duplex printing */
181 int PStumble = FALSE; /* enable top edge binding */
182 int PSavoiddeadzone = TRUE; /* enable avoiding printer deadzone */
183 double maxPageHeight = 0; /* maximum height to select from image and print per page */
184 double maxPageWidth = 0; /* maximum width to select from image and print per page */
185 double splitOverlap = 0; /* amount for split pages to overlag */
186 int rotation = 0; /* optional value for rotation angle */
187 int auto_rotate = 0; /* rotate image for best fit on the page */
188 char *filename = NULL; /* input filename */
189 char *title = NULL; /* optional document title string */
190 char *creator = NULL; /* optional document creator string */
191 char pageOrientation[12]; /* set optional PageOrientation DSC to Landscape or Portrait */
192 int useImagemask = FALSE; /* Use imagemask instead of image operator */
193 uint16 res_unit = 0; /* Resolution units: 2 - inches, 3 - cm */
194
195 /*
196 * ASCII85 Encoding Support.
197 */
198 unsigned char ascii85buf[10];
199 int ascii85count;
200 int ascii85breaklen;
201
202 int TIFF2PS(FILE*, TIFF*, double, double, double, double, int);
203 void PSpage(FILE*, TIFF*, uint32, uint32);
204 void PSColorContigPreamble(FILE*, uint32, uint32, int);
205 void PSColorSeparatePreamble(FILE*, uint32, uint32, int);
206 void PSDataColorContig(FILE*, TIFF*, uint32, uint32, int);
207 void PSDataColorSeparate(FILE*, TIFF*, uint32, uint32, int);
208 void PSDataPalette(FILE*, TIFF*, uint32, uint32);
209 void PSDataBW(FILE*, TIFF*, uint32, uint32);
210 void PSRawDataBW(FILE*, TIFF*, uint32, uint32);
211 void Ascii85Init(void);
212 void Ascii85Put(unsigned char code, FILE* fd);
213 void Ascii85Flush(FILE* fd);
214 void PSHead(FILE*, double, double, double, double);
215 void PSTail(FILE*, int);
216 int psStart(FILE *, int, int, int *, double *, double, double, double,
217 double, double, double, double, double, double, double);
218 int psPageSize(FILE *, int, double, double, double, double, double, double);
219 int psRotateImage(FILE *, int, double, double, double, double);
220 int psMaskImage(FILE *, TIFF *, int, int, int *, double, double,
221 double, double, double, double, double, double, double);
222 int psScaleImage(FILE *, double, int, int, double, double, double, double,
223 double, double);
224 int get_viewport (double, double, double, double, double *, double *, int);
225 int exportMaskedImage(FILE *, double, double, double, double, int, int,
226 double, double, double, int, int);
227
228 #if defined( EXP_ASCII85ENCODER)
229 tsize_t Ascii85EncodeBlock( uint8 * ascii85_p, unsigned f_eod, const uint8 * raw_p, tsize_t raw_l );
230 #endif
231
232 static void usage(int);
233
234 int
235 main(int argc, char* argv[])
236 {
237 int dirnum = -1, c, np = 0;
238 int centered = 0;
239 double bottommargin = 0;
240 double leftmargin = 0;
241 double pageWidth = 0;
242 double pageHeight = 0;
243 uint32 diroff = 0;
244 extern char *optarg;
245 extern int optind;
246 FILE* output = stdout;
247
248 pageOrientation[0] = '\0';
249
250 while ((c = getopt(argc, argv, "b:d:h:H:W:L:i:w:l:o:O:P:C:r:t:acemxyzps1238DT")) != -1)
251 switch (c) {
252 case 'b':
253 bottommargin = atof(optarg);
254 break;
255 case 'c':
256 centered = 1;
257 break;
258 case 'C':
259 creator = optarg;
260 break;
261 case 'd': /* without -a, this only processes one image at this IFD */
262 dirnum = atoi(optarg);
263 break;
264 case 'D':
265 PSduplex = TRUE;
266 break;
267 case 'i':
268 interpolate = atoi(optarg) ? TRUE:FALSE;
269 break;
270 case 'T':
271 PStumble = TRUE;
272 break;
273 case 'e':
274 PSavoiddeadzone = FALSE;
275 generateEPSF = TRUE;
276 break;
277 case 'h':
278 pageHeight = atof(optarg);
279 break;
280 case 'H':
281 maxPageHeight = atof(optarg);
282 break;
283 case 'W':
284 maxPageWidth = atof(optarg);
285 break;
286 case 'L':
287 splitOverlap = atof(optarg);
288 break;
289 case 'm':
290 useImagemask = TRUE;
291 break;
292 case 'o':
293 switch (optarg[0])
294 {
295 case '0':
296 case '1':
297 case '2':
298 case '3':
299 case '4':
300 case '5':
301 case '6':
302 case '7':
303 case '8':
304 case '9': diroff = (uint32) strtoul(optarg, NULL, 0);
305 break;
306 default: TIFFError ("-o", "Offset must be a numeric value.");
307 exit (1);
308 }
309 break;
310 case 'O': /* XXX too bad -o is already taken */
311 output = fopen(optarg, "w");
312 if (output == NULL) {
313 fprintf(stderr,
314 "%s: %s: Cannot open output file.\n",
315 argv[0], optarg);
316 exit(-2);
317 }
318 break;
319 case 'P':
320 switch (optarg[0])
321 {
322 case 'l':
323 case 'L': strcpy (pageOrientation, "Landscape");
324 break;
325 case 'p':
326 case 'P': strcpy (pageOrientation, "Portrait");
327 break;
328 default: TIFFError ("-P", "Page orientation must be Landscape or Portrait");
329 exit (-1);
330 }
331 break;
332 case 'l':
333 leftmargin = atof(optarg);
334 break;
335 case 'a': /* removed fall through to generate warning below, R Nolde 09-01-2010 */
336 printAll = TRUE;
337 break;
338 case 'p':
339 generateEPSF = FALSE;
340 break;
341 case 'r':
342 if (strcmp (optarg, "auto") == 0)
343 {
344 rotation = 0;
345 auto_rotate = TRUE;
346 }
347 else
348 {
349 rotation = atoi(optarg);
350 auto_rotate = FALSE;
351 }
352 switch (rotation)
353 {
354 case 0:
355 case 90:
356 case 180:
357 case 270:
358 break;
359 default:
360 fprintf (stderr, "Rotation angle must be 90, 180, 270 (degrees ccw) or auto\n");
361 exit (-1);
362 }
363 break;
364 case 's':
365 printAll = FALSE;
366 break;
367 case 't':
368 title = optarg;
369 break;
370 case 'w':
371 pageWidth = atof(optarg);
372 break;
373 case 'z':
374 PSavoiddeadzone = FALSE;
375 break;
376 case '1':
377 level2 = FALSE;
378 level3 = FALSE;
379 ascii85 = FALSE;
380 break;
381 case '2':
382 level2 = TRUE;
383 ascii85 = TRUE; /* default to yes */
384 break;
385 case '3':
386 level3 = TRUE;
387 ascii85 = TRUE; /* default to yes */
388 break;
389 case '8':
390 ascii85 = FALSE;
391 break;
392 case 'x':
393 res_unit = RESUNIT_CENTIMETER;
394 break;
395 case 'y':
396 res_unit = RESUNIT_INCH;
397 break;
398 case '?':
399 usage(-1);
400 }
401
402 if (useImagemask == TRUE)
403 {
404 if ((level2 == FALSE) && (level3 == FALSE))
405 {
406 TIFFError ("-m "," imagemask operator requres Postscript Level2 or Level3");
407 exit (1);
408 }
409 }
410
411 if (pageWidth && (maxPageWidth > pageWidth))
412 {
413 TIFFError ("-W", "Max viewport width cannot exceed page width");
414 exit (1);
415 }
416
417 if (pageHeight && (maxPageHeight > pageHeight))
418 {
419 TIFFError ("-H", "Max viewport height cannot exceed page height");
420 exit (1);
421 }
422
423 /* auto rotate requires a specified page width and height */
424 if (auto_rotate == TRUE)
425 {
426 if ((pageWidth == 0) || (pageHeight == 0))
427 TIFFWarning ("-r auto", " requires page height and width specified with -h and -w");
428
429 if ((maxPageWidth > 0) || (maxPageHeight > 0))
430 {
431 TIFFError ("-r auto", " is incompatible with maximum page width/height specified by -H or -W");
432 exit (1);
433 }
434 }
435 if ((maxPageWidth > 0) && (maxPageHeight > 0))
436 {
437 TIFFError ("-H and -W", " Use only one of -H or -W to define a viewport");
438 exit (1);
439 }
440
441 if ((generateEPSF == TRUE) && (printAll == TRUE))
442 {
443 TIFFError(" -e and -a", "Warning: Cannot generate Encapsulated Postscript for multiple images");
444 generateEPSF = FALSE;
445 }
446
447 if ((generateEPSF == TRUE) && (PSduplex == TRUE))
448 {
449 TIFFError(" -e and -D", "Warning: Encapsulated Postscript does not support Duplex option");
450 PSduplex = FALSE;
451 }
452
453 if ((generateEPSF == TRUE) && (PStumble == TRUE))
454 {
455 TIFFError(" -e and -T", "Warning: Encapsulated Postscript does not support Top Edge Binding option");
456 PStumble = FALSE;
457 }
458
459 if ((generateEPSF == TRUE) && (PSavoiddeadzone == TRUE))
460 PSavoiddeadzone = FALSE;
461
462 for (; argc - optind > 0; optind++) {
463 TIFF* tif = TIFFOpen(filename = argv[optind], "r");
464 if (tif != NULL) {
465 if (dirnum != -1
466 && !TIFFSetDirectory(tif, (tdir_t)dirnum))
467 return (-1);
468 else if (diroff != 0 &&
469 !TIFFSetSubDirectory(tif, diroff))
470 return (-1);
471 np = TIFF2PS(output, tif, pageWidth, pageHeight,
472 leftmargin, bottommargin, centered);
473 if (np < 0)
474 {
475 TIFFError("Error", "Unable to process %s", filename);
476 }
477 TIFFClose(tif);
478 }
479 }
480 if (np)
481 PSTail(output, np);
482 else
483 usage(-1);
484 if (output != stdout)
485 fclose(output);
486 return (0);
487 }
488
489 static uint16 samplesperpixel;
490 static uint16 bitspersample;
491 static uint16 planarconfiguration;
492 static uint16 photometric;
493 static uint16 compression;
494 static uint16 extrasamples;
495 static int alpha;
496
497 static int
498 checkImage(TIFF* tif)
499 {
500 switch (photometric) {
501 case PHOTOMETRIC_YCBCR:
502 if ((compression == COMPRESSION_JPEG || compression == COMPRESSION_OJPEG)
503 && planarconfiguration == PLANARCONFIG_CONTIG) {
504 /* can rely on libjpeg to convert to RGB */
505 TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE,
506 JPEGCOLORMODE_RGB);
507 photometric = PHOTOMETRIC_RGB;
508 } else {
509 if (level2 || level3)
510 break;
511 TIFFError(filename, "Can not handle image with %s",
512 "PhotometricInterpretation=YCbCr");
513 return (0);
514 }
515 /* fall thru... */
516 case PHOTOMETRIC_RGB:
517 if (alpha && bitspersample != 8) {
518 TIFFError(filename,
519 "Can not handle %d-bit/sample RGB image with alpha",
520 bitspersample);
521 return (0);
522 }
523 /* fall thru... */
524 case PHOTOMETRIC_SEPARATED:
525 case PHOTOMETRIC_PALETTE:
526 case PHOTOMETRIC_MINISBLACK:
527 case PHOTOMETRIC_MINISWHITE:
528 break;
529 case PHOTOMETRIC_LOGL:
530 case PHOTOMETRIC_LOGLUV:
531 if (compression != COMPRESSION_SGILOG &&
532 compression != COMPRESSION_SGILOG24) {
533 TIFFError(filename,
534 "Can not handle %s data with compression other than SGILog",
535 (photometric == PHOTOMETRIC_LOGL) ?
536 "LogL" : "LogLuv"
537 );
538 return (0);
539 }
540 /* rely on library to convert to RGB/greyscale */
541 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
542 photometric = (photometric == PHOTOMETRIC_LOGL) ?
543 PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB;
544 bitspersample = 8;
545 break;
546 case PHOTOMETRIC_CIELAB:
547 /* fall thru... */
548 default:
549 TIFFError(filename,
550 "Can not handle image with PhotometricInterpretation=%d",
551 photometric);
552 return (0);
553 }
554 switch (bitspersample) {
555 case 1: case 2:
556 case 4: case 8:
557 case 16:
558 break;
559 default:
560 TIFFError(filename, "Can not handle %d-bit/sample image",
561 bitspersample);
562 return (0);
563 }
564 if (planarconfiguration == PLANARCONFIG_SEPARATE && extrasamples > 0)
565 TIFFWarning(filename, "Ignoring extra samples");
566 return (1);
567 }
568
569 #define PS_UNIT_SIZE 72.0F
570 #define PSUNITS(npix,res) ((npix) * (PS_UNIT_SIZE / (res)))
571
572 static char RGBcolorimage[] = "\
573 /bwproc {\n\
574 rgbproc\n\
575 dup length 3 idiv string 0 3 0\n\
576 5 -1 roll {\n\
577 add 2 1 roll 1 sub dup 0 eq {\n\
578 pop 3 idiv\n\
579 3 -1 roll\n\
580 dup 4 -1 roll\n\
581 dup 3 1 roll\n\
582 5 -1 roll put\n\
583 1 add 3 0\n\
584 } { 2 1 roll } ifelse\n\
585 } forall\n\
586 pop pop pop\n\
587 } def\n\
588 /colorimage where {pop} {\n\
589 /colorimage {pop pop /rgbproc exch def {bwproc} image} bind def\n\
590 } ifelse\n\
591 ";
592
593 /*
594 * Adobe Photoshop requires a comment line of the form:
595 *
596 * %ImageData: <cols> <rows> <depth> <main channels> <pad channels>
597 * <block size> <1 for binary|2 for hex> "data start"
598 *
599 * It is claimed to be part of some future revision of the EPS spec.
600 */
601 static void
602 PhotoshopBanner(FILE* fd, uint32 w, uint32 h, int bs, int nc, char* startline)
603 {
604 fprintf(fd, "%%ImageData: %ld %ld %d %d 0 %d 2 \"",
605 (long) w, (long) h, bitspersample, nc, bs);
606 fprintf(fd, startline, nc);
607 fprintf(fd, "\"\n");
608 }
609
610 /* Convert pixel width and height pw, ph, to points pprw, pprh
611 * using image resolution and resolution units from TIFF tags.
612 * pw : image width in pixels
613 * ph : image height in pixels
614 * pprw : image width in PS units (72 dpi)
615 * pprh : image height in PS units (72 dpi)
616 */
617 static void
618 setupPageState(TIFF* tif, uint32* pw, uint32* ph, double* pprw, double* pprh)
619 {
620 float xres = 0.0F, yres = 0.0F;
621
622 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, pw);
623 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, ph);
624 if (res_unit == 0) /* Not specified as command line option */
625 if (!TIFFGetFieldDefaulted(tif, TIFFTAG_RESOLUTIONUNIT, &res_unit))
626 res_unit = RESUNIT_INCH;
627 /*
628 * Calculate printable area.
629 */
630 if (!TIFFGetField(tif, TIFFTAG_XRESOLUTION, &xres)
631 || fabs(xres) < 0.0000001)
632 xres = PS_UNIT_SIZE;
633 if (!TIFFGetField(tif, TIFFTAG_YRESOLUTION, &yres)
634 || fabs(yres) < 0.0000001)
635 yres = PS_UNIT_SIZE;
636 switch (res_unit) {
637 case RESUNIT_CENTIMETER:
638 xres *= 2.54F, yres *= 2.54F;
639 break;
640 case RESUNIT_INCH:
641 break;
642 case RESUNIT_NONE: /* Subsequent code assumes we have converted to inches! */
643 res_unit = RESUNIT_INCH;
644 break;
645 default: /* Last ditch guess for unspecified RESUNIT case
646 * check that the resolution is not inches before scaling it.
647 * Moved to end of function with additional check, RJN, 08-31-2010
648 * if (xres != PS_UNIT_SIZE || yres != PS_UNIT_SIZE)
649 * xres *= PS_UNIT_SIZE, yres *= PS_UNIT_SIZE;
650 */
651 break;
652 }
653 /* This is a hack to deal with images that have no meaningful Resolution Size
654 * but may have x and/or y resolutions of 1 pixel per undefined unit.
655 */
656 if ((xres > 1.0) && (xres != PS_UNIT_SIZE))
657 *pprw = PSUNITS(*pw, xres);
658 else
659 *pprw = PSUNITS(*pw, PS_UNIT_SIZE);
660 if ((yres > 1.0) && (yres != PS_UNIT_SIZE))
661 *pprh = PSUNITS(*ph, yres);
662 else
663 *pprh = PSUNITS(*ph, PS_UNIT_SIZE);
664 }
665
666 static int
667 isCCITTCompression(TIFF* tif)
668 {
669 uint16 compress;
670 TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);
671 return (compress == COMPRESSION_CCITTFAX3 ||
672 compress == COMPRESSION_CCITTFAX4 ||
673 compress == COMPRESSION_CCITTRLE ||
674 compress == COMPRESSION_CCITTRLEW);
675 }
676
677 static tsize_t tf_bytesperrow;
678 static tsize_t ps_bytesperrow;
679 static tsize_t tf_rowsperstrip;
680 static tsize_t tf_numberstrips;
681 static char *hex = "0123456789abcdef";
682
683 /*
684 * Pagewidth and pageheight are the output size in points,
685 * may refer to values specified with -h and -w, or to
686 * values read from the image if neither -h nor -w are used.
687 * Imagewidth and imageheight are image size in points.
688 * Ximages and Yimages are number of pages across and down.
689 * Only one of maxPageHeight or maxPageWidth can be used.
690 * These are global variables unfortunately.
691 */
692 int get_subimage_count(double pagewidth, double pageheight,
693 double imagewidth, double imageheight,
694 int *ximages, int *yimages,
695 int rotation, double scale)
696 {
697 int pages = 1;
698 double splitheight = 0; /* Requested Max Height in points */
699 double splitwidth = 0; /* Requested Max Width in points */
700 double overlap = 0; /* Repeated edge width in points */
701
702 splitheight = maxPageHeight * PS_UNIT_SIZE;
703 splitwidth = maxPageWidth * PS_UNIT_SIZE;
704 overlap = splitOverlap * PS_UNIT_SIZE;
705 pagewidth *= PS_UNIT_SIZE;
706 pageheight *= PS_UNIT_SIZE;
707
708 if ((imagewidth < 1.0) || (imageheight < 1.0))
709 {
710 TIFFError("get_subimage_count", "Invalid image width or height");
711 return (0);
712 }
713
714 switch (rotation)
715 {
716 case 0:
717 case 180: if (splitheight > 0) /* -H maxPageHeight */
718 {
719 if (imageheight > splitheight) /* More than one vertical image segment */
720 {
721 if (pagewidth)
722 *ximages = (int)ceil((scale * imagewidth) / (pagewidth - overlap));
723 else
724 *ximages = 1;
725 *yimages = (int)ceil((scale * imageheight) / (splitheight - overlap)); /* Max vert pages needed */
726 }
727 else
728 {
729 if (pagewidth)
730 *ximages = (int)ceil((scale * imagewidth) / (pagewidth - overlap)); /* Max horz pages needed */
731 else
732 *ximages = 1;
733 *yimages = 1; /* Max vert pages needed */
734 }
735 }
736 else
737 {
738 if (splitwidth > 0) /* -W maxPageWidth */
739 {
740 if (imagewidth >splitwidth)
741 {
742 *ximages = (int)ceil((scale * imagewidth) / (splitwidth - overlap)); /* Max horz pages needed */
743 if (pageheight)
744 *yimages = (int)ceil((scale * imageheight) / (pageheight - overlap)); /* Max vert pages needed */
745 else
746 *yimages = 1;
747 }
748 else
749 {
750 *ximages = 1; /* Max vert pages needed */
751 if (pageheight)
752 *yimages = (int)ceil((scale * imageheight) / (pageheight - overlap)); /* Max vert pages needed */
753 else
754 *yimages = 1;
755 }
756 }
757 else
758 {
759 *ximages = 1;
760 *yimages = 1;
761 }
762 }
763 break;
764 case 90:
765 case 270: if (splitheight > 0) /* -H maxPageHeight */
766 {
767 if (imagewidth > splitheight) /* More than one vertical image segment */
768 {
769 *yimages = (int)ceil((scale * imagewidth) / (splitheight - overlap)); /* Max vert pages needed */
770 if (pagewidth)
771 *ximages = (int)ceil((scale * imageheight) / (pagewidth - overlap)); /* Max horz pages needed */
772 else
773 *ximages = 1;
774 }
775 else
776 {
777 *yimages = 1; /* Max vert pages needed */
778 if (pagewidth)
779 *ximages = (int)ceil((scale * imageheight) / (pagewidth - overlap)); /* Max horz pages needed */
780 else
781 *ximages = 1;
782 }
783 }
784 else
785 {
786 if (splitwidth > 0) /* -W maxPageWidth */
787 {
788 if (imageheight > splitwidth)
789 {
790 if (pageheight)
791 *yimages = (int)ceil((scale * imagewidth) / (pageheight - overlap)); /* Max vert pages needed */
792 else
793 *yimages = 1;
794 *ximages = (int)ceil((scale * imageheight) / (splitwidth - overlap)); /* Max horz pages needed */
795 }
796 else
797 {
798 if (pageheight)
799 *yimages = (int)ceil((scale * imagewidth) / (pageheight - overlap)); /* Max horz pages needed */
800 else
801 *yimages = 1;
802 *ximages = 1; /* Max vert pages needed */
803 }
804 }
805 else
806 {
807 *ximages = 1;
808 *yimages = 1;
809 }
810 }
811 break;
812 default: *ximages = 1;
813 *yimages = 1;
814 }
815 pages = (*ximages) * (*yimages);
816 return (pages);
817 }
818
819 /* New version of PlaceImage that handles only the translation and rotation
820 * for a single output page.
821 */
822 int exportMaskedImage(FILE *fp, double pagewidth, double pageheight,
823 double imagewidth, double imageheight,
824 int row, int column,
825 double left_offset, double bott_offset,
826 double scale, int center, int rotation)
827 {
828 double xtran = 0.0;
829 double ytran = 0.0;
830
831 double xscale = 1.0;
832 double yscale = 1.0;
833
834 double splitheight = 0; /* Requested Max Height in points */
835 double splitwidth = 0; /* Requested Max Width in points */
836 double overlap = 0; /* Repeated edge width in points */
837 double subimage_height = 0.0;
838
839 splitheight = maxPageHeight * PS_UNIT_SIZE;
840 splitwidth = maxPageWidth * PS_UNIT_SIZE;
841 overlap = splitOverlap * PS_UNIT_SIZE;
842 xscale = scale * imagewidth;
843 yscale = scale * imageheight;
844
845 if ((xscale < 0.0) || (yscale < 0.0))
846 {
847 TIFFError("exportMaskedImage", "Invalid parameters.");
848 return (-1);
849 }
850
851 /* If images are cropped to a vewport with -H or -W, the output pages are shifted to
852 * the top of each output page rather than the Postscript default lower edge.
853 */
854 switch (rotation)
855 {
856 case 0:
857 case 180: if (splitheight > 0) /* -H maxPageHeight */
858 {
859 if (splitheight < imageheight) /* More than one vertical image segments */
860 {
861 xtran = -1.0 * column * (pagewidth - overlap);
862 subimage_height = imageheight - ((splitheight - overlap) * row);
863 ytran = pageheight - subimage_height * (pageheight / splitheight);
864 }
865 else /* Only one page in vertical direction */
866 {
867 xtran = -1.0 * column * (pagewidth - overlap);
868 ytran = splitheight - imageheight;
869 }
870 }
871 else
872 {
873 if (splitwidth > 0) /* maxPageWidth */
874 {
875 if (splitwidth < imagewidth)
876 {
877 xtran = -1.0 * column * splitwidth;
878 ytran = -1.0 * row * (pageheight - overlap);
879 }
880 else /* Only one page in horizontal direction */
881 {
882 ytran = -1.0 * row * (pageheight - overlap);
883 xtran = 0;
884 }
885 }
886 else /* Simple case, no splitting */
887 {
888 ytran = pageheight - imageheight;
889 xtran = 0;
890 }
891 }
892 bott_offset += ytran / (center ? 2 : 1);
893 left_offset += xtran / (center ? 2 : 1);
894 break;
895 case 90:
896 case 270: if (splitheight > 0) /* -H maxPageHeight */
897 {
898 if (splitheight < imagewidth) /* More than one vertical image segments */
899 {
900 xtran = -1.0 * column * (pageheight - overlap);
901 /* Commented code places image at bottom of page instead of top.
902 ytran = -1.0 * row * splitheight;
903 */
904 if (row == 0)
905 ytran = -1.0 * (imagewidth - splitheight);
906 else
907 ytran = -1.0 * (imagewidth - (splitheight - overlap) * (row + 1));
908 }
909 else /* Only one page in vertical direction */
910 {
911 xtran = -1.0 * column * (pageheight - overlap);
912 ytran = splitheight - imagewidth;
913 }
914 }
915 else
916 {
917 if (splitwidth > 0) /* maxPageWidth */
918 {
919 if (splitwidth < imageheight)
920 {
921 xtran = -1.0 * column * splitwidth;
922 ytran = -1.0 * row * (pagewidth - overlap);
923 }
924 else /* Only one page in horizontal direction */
925 {
926 ytran = -1.0 * row * (pagewidth - overlap);
927 xtran = 0;
928 }
929 }
930 else /* Simple case, no splitting */
931 {
932 ytran = pageheight - imageheight;
933 xtran = 0; /* pagewidth - imagewidth; */
934 }
935 }
936 bott_offset += ytran / (center ? 2 : 1);
937 left_offset += xtran / (center ? 2 : 1);
938 break;
939 default: xtran = 0;
940 ytran = 0;
941 }
942
943 switch (rotation)
944 {
945 case 0: fprintf(fp, "%f %f translate\n", left_offset, bott_offset);
946 fprintf(fp, "%f %f scale\n", xscale, yscale);
947 break;
948 case 180: fprintf(fp, "%f %f translate\n", left_offset, bott_offset);
949 fprintf(fp, "%f %f scale\n1 1 translate 180 rotate\n", xscale, yscale);
950 break;
951 case 90: fprintf(fp, "%f %f translate\n", left_offset, bott_offset);
952 fprintf(fp, "%f %f scale\n1 0 translate 90 rotate\n", yscale, xscale);
953 break;
954 case 270: fprintf(fp, "%f %f translate\n", left_offset, bott_offset);
955 fprintf(fp, "%f %f scale\n0 1 translate 270 rotate\n", yscale, xscale);
956 break;
957 default: TIFFError ("exportMaskedImage", "Unsupported rotation angle %d. No rotation", rotation);
958 fprintf( fp, "%f %f scale\n", xscale, yscale);
959 break;
960 }
961
962 return (0);
963 }
964
965 /* Rotate an image without scaling or clipping */
966 int psRotateImage (FILE * fd, int rotation, double pswidth, double psheight,
967 double left_offset, double bottom_offset)
968 {
969 if ((left_offset != 0.0) || (bottom_offset != 0))
970 fprintf (fd, "%f %f translate\n", left_offset, bottom_offset);
971
972 /* Exchange width and height for 90/270 rotations */
973 switch (rotation)
974 {
975 case 0: fprintf (fd, "%f %f scale\n", pswidth, psheight);
976 break;
977 case 90: fprintf (fd, "%f %f scale\n1 0 translate 90 rotate\n", psheight, pswidth);
978 break;
979 case 180: fprintf (fd, "%f %f scale\n1 1 translate 180 rotate\n", pswidth, psheight);
980 break;
981 case 270: fprintf (fd, "%f %f scale\n0 1 translate 270 rotate\n", psheight, pswidth);
982 break;
983 default: TIFFError ("psRotateImage", "Unsupported rotation %d.", rotation);
984 fprintf( fd, "%f %f scale\n", pswidth, psheight);
985 return (1);
986 }
987 return (0);
988 }
989
990 /* Scale and rotate an image to a single output page. */
991 int psScaleImage(FILE * fd, double scale, int rotation, int center,
992 double reqwidth, double reqheight, double pswidth, double psheight,
993 double left_offset, double bottom_offset)
994 {
995 double hcenter = 0.0, vcenter = 0.0;
996
997 /* Adjust offsets for centering */
998 if (center)
999 {
1000 switch (rotation)
1001 {
1002 case 90: vcenter = (reqheight - pswidth * scale) / 2;
1003 hcenter = (reqwidth - psheight * scale) / 2;
1004 fprintf (fd, "%f %f translate\n", hcenter, vcenter);
1005 fprintf (fd, "%f %f scale\n1 0 translate 90 rotate\n", psheight * scale, pswidth * scale);
1006 break;
1007 case 180: hcenter = (reqwidth - pswidth * scale) / 2;
1008 vcenter = (reqheight - psheight * scale) / 2;
1009 fprintf (fd, "%f %f translate\n", hcenter, vcenter);
1010 fprintf (fd, "%f %f scale\n1 1 translate 180 rotate\n", pswidth * scale, psheight * scale);
1011 break;
1012 case 270: vcenter = (reqheight - pswidth * scale) / 2;
1013 hcenter = (reqwidth - psheight * scale) / 2;
1014 fprintf (fd, "%f %f translate\n", hcenter, vcenter);
1015 fprintf (fd, "%f %f scale\n0 1 translate 270 rotate\n", psheight * scale, pswidth * scale);
1016 break;
1017 case 0:
1018 default: hcenter = (reqwidth - pswidth * scale) / 2;
1019 vcenter = (reqheight - psheight * scale) / 2;
1020 fprintf (fd, "%f %f translate\n", hcenter, vcenter);
1021 fprintf (fd, "%f %f scale\n", pswidth * scale, psheight * scale);
1022 break;
1023 }
1024 }
1025 else /* Not centered */
1026 {
1027 switch (rotation)
1028 {
1029 case 0: fprintf (fd, "%f %f translate\n", left_offset ? left_offset : 0.0,
1030 bottom_offset ? bottom_offset : reqheight - (psheight * scale));
1031 fprintf (fd, "%f %f scale\n", pswidth * scale, psheight * scale);
1032 break;
1033 case 90: fprintf (fd, "%f %f translate\n", left_offset ? left_offset : 0.0,
1034 bottom_offset ? bottom_offset : reqheight - (pswidth * scale));
1035 fprintf (fd, "%f %f scale\n1 0 translate 90 rotate\n", psheight * scale, pswidth * scale);
1036 break;
1037 case 180: fprintf (fd, "%f %f translate\n", left_offset ? left_offset : 0.0,
1038 bottom_offset ? bottom_offset : reqheight - (psheight * scale));
1039 fprintf (fd, "%f %f scale\n1 1 translate 180 rotate\n", pswidth * scale, psheight * scale);
1040 break;
1041 case 270: fprintf (fd, "%f %f translate\n", left_offset ? left_offset : 0.0,
1042 bottom_offset ? bottom_offset : reqheight - (pswidth * scale));
1043 fprintf (fd, "%f %f scale\n0 1 translate 270 rotate\n", psheight * scale, pswidth * scale);
1044 break;
1045 default: TIFFError ("psScaleImage", "Unsupported rotation %d", rotation);
1046 fprintf (fd, "%f %f scale\n", pswidth * scale, psheight * scale);
1047 return (1);
1048 }
1049 }
1050
1051 return (0);
1052 }
1053
1054 /* This controls the visible portion of the page which is displayed.
1055 * N.B. Setting maxPageHeight no longer sets pageheight if not set explicitly
1056 */
1057 int psPageSize (FILE * fd, int rotation, double pgwidth, double pgheight,
1058 double reqwidth, double reqheight, double pswidth, double psheight)
1059 {
1060 double xscale = 1.0, yscale = 1.0, scale = 1.0;
1061 double splitheight;
1062 double splitwidth;
1063 double new_width;
1064 double new_height;
1065
1066 splitheight = maxPageHeight * PS_UNIT_SIZE;
1067 splitwidth = maxPageWidth * PS_UNIT_SIZE;
1068
1069 switch (rotation)
1070 {
1071 case 0:
1072 case 180: if ((splitheight > 0) || (splitwidth > 0))
1073 {
1074 if (pgwidth != 0 || pgheight != 0)
1075 {
1076 xscale = reqwidth / (splitwidth ? splitwidth : pswidth);
1077 yscale = reqheight / (splitheight ? splitheight : psheight);
1078 scale = (xscale < yscale) ? xscale : yscale;
1079 }
1080 new_width = splitwidth ? splitwidth : scale * pswidth;
1081 new_height = splitheight ? splitheight : scale * psheight;
1082 if (strlen(pageOrientation))
1083 fprintf (fd, "%%%%PageOrientation: %s\n", pageOrientation);
1084 else
1085 fprintf (fd, "%%%%PageOrientation: %s\n", (new_width > new_height) ? "Landscape" : "Portrait");
1086 fprintf (fd, "%%%%PageBoundingBox: 0 0 %ld %ld\n", (long)new_width, (long)new_height);
1087 fprintf (fd, "1 dict begin /PageSize [ %f %f ] def currentdict end setpagedevice\n",
1088 new_width, new_height);
1089 }
1090 else /* No viewport defined with -H or -W */
1091 {
1092 if ((pgwidth == 0) && (pgheight == 0)) /* Image not scaled */
1093 {
1094 if (strlen(pageOrientation))
1095 fprintf (fd, "%%%%PageOrientation: %s\n", pageOrientation);
1096 else
1097 fprintf (fd, "%%%%PageOrientation: %s\n", (pswidth > psheight) ? "Landscape" : "Portrait");
1098 fprintf (fd, "%%%%PageBoundingBox: 0 0 %ld %ld\n", (long)pswidth, (long)psheight);
1099 fprintf(fd, "1 dict begin /PageSize [ %f %f ] def currentdict end setpagedevice\n",
1100 pswidth, psheight);
1101 }
1102 else /* Image scaled */
1103 {
1104 if (strlen(pageOrientation))
1105 fprintf (fd, "%%%%PageOrientation: %s\n", pageOrientation);
1106 else
1107 fprintf (fd, "%%%%PageOrientation: %s\n", (reqwidth > reqheight) ? "Landscape" : "Portrait");
1108 fprintf (fd, "%%%%PageBoundingBox: 0 0 %ld %ld\n", (long)reqwidth, (long)reqheight);
1109 fprintf(fd, "1 dict begin /PageSize [ %f %f ] def currentdict end setpagedevice\n",
1110 reqwidth, reqheight);
1111 }
1112 }
1113 break;
1114 case 90:
1115 case 270: if ((splitheight > 0) || (splitwidth > 0))
1116 {
1117 if (pgwidth != 0 || pgheight != 0)
1118 {
1119 xscale = reqwidth / (splitwidth ? splitwidth : pswidth);
1120 yscale = reqheight / (splitheight ? splitheight : psheight);
1121 scale = (xscale < yscale) ? xscale : yscale;
1122 }
1123 new_width = splitwidth ? splitwidth : scale * psheight;
1124 new_height = splitheight ? splitheight : scale * pswidth;
1125
1126 if (strlen(pageOrientation))
1127 fprintf (fd, "%%%%PageOrientation: %s\n", pageOrientation);
1128 else
1129 fprintf (fd, "%%%%PageOrientation: %s\n", (new_width > new_height) ? "Landscape" : "Portrait");
1130 fprintf (fd, "%%%%PageBoundingBox: 0 0 %ld %ld\n", (long)new_width, (long)new_height);
1131 fprintf (fd, "1 dict begin /PageSize [ %f %f ] def currentdict end setpagedevice\n",
1132 new_width, new_height);
1133 }
1134 else
1135 {
1136 if ((pgwidth == 0) && (pgheight == 0)) /* Image not scaled */
1137 {
1138 if (strlen(pageOrientation))
1139 fprintf (fd, "%%%%PageOrientation: %s\n", pageOrientation);
1140 else
1141 fprintf (fd, "%%%%PageOrientation: %s\n", (psheight > pswidth) ? "Landscape" : "Portrait");
1142 fprintf (fd, "%%%%PageBoundingBox: 0 0 %ld %ld\n", (long)psheight, (long)pswidth);
1143 fprintf(fd, "1 dict begin /PageSize [ %f %f ] def currentdict end setpagedevice\n",
1144 psheight, pswidth);
1145 }
1146 else /* Image scaled */
1147 {
1148 if (strlen(pageOrientation))
1149 fprintf (fd, "%%%%PageOrientation: %s\n", pageOrientation);
1150 else
1151 fprintf (fd, "%%%%PageOrientation: %s\n", (reqwidth > reqheight) ? "Landscape" : "Portrait");
1152 fprintf (fd, "%%%%PageBoundingBox: 0 0 %ld %ld\n", (long)reqwidth, (long)reqheight);
1153 fprintf(fd, "1 dict begin /PageSize [ %f %f ] def currentdict end setpagedevice\n",
1154 reqwidth, reqheight);
1155 }
1156 }
1157 break;
1158 default: TIFFError ("psPageSize", "Invalid rotation %d", rotation);
1159 return (1);
1160 }
1161 fputs("<<\n /Policies <<\n /PageSize 3\n >>\n>> setpagedevice\n", fd);
1162
1163 return (0);
1164 } /* end psPageSize */
1165
1166 /* Mask an image as a series of pages, each only showing a section defined
1167 * by the maxPageHeight or maxPageWidth options.
1168 */
1169 int psMaskImage(FILE *fd, TIFF *tif, int rotation, int center,
1170 int *npages, double pixwidth, double pixheight,
1171 double left_margin, double bottom_margin,
1172 double pgwidth, double pgheight,
1173 double pswidth, double psheight, double scale)
1174 {
1175 int i, j;
1176 int ximages = 1, yimages = 1;
1177 int pages = *npages;
1178 double view_width = 0;
1179 double view_height = 0;
1180
1181 if (get_viewport (pgwidth, pgheight, pswidth, psheight, &view_width, &view_height, rotation))
1182 {
1183 TIFFError ("get_viewport", "Unable to set image viewport");
1184 return (-1);
1185 }
1186
1187 if (get_subimage_count(pgwidth, pgheight, pswidth, psheight,
1188 &ximages, &yimages, rotation, scale) < 1)
1189 {
1190 TIFFError("get_subimage_count", "Invalid image count: %d columns, %d rows", ximages, yimages);
1191 return (-1);
1192 }
1193
1194 for (i = 0; i < yimages; i++)
1195 {
1196 for (j = 0; j < ximages; j++)
1197 {
1198 pages++;
1199 *npages = pages;
1200 fprintf(fd, "%%%%Page: %d %d\n", pages, pages);
1201
1202 /* Write out the PageSize info for non EPS files */
1203 if (!generateEPSF && ( level2 || level3 ))
1204 {
1205 if (psPageSize(fd, rotation, pgwidth, pgheight,
1206 view_width, view_height, pswidth, psheight))
1207 return (-1);
1208 }
1209 fprintf(fd, "gsave\n");
1210 fprintf(fd, "100 dict begin\n");
1211 if (exportMaskedImage(fd, view_width, view_height, pswidth, psheight,
1212 i, j, left_margin, bottom_margin,
1213 scale, center, rotation))
1214 {
1215 TIFFError("exportMaskedImage", "Invalid image parameters.");
1216 return (-1);
1217 }
1218 PSpage(fd, tif, pixwidth, pixheight);
1219 fprintf(fd, "end\n");
1220 fprintf(fd, "grestore\n");
1221 fprintf(fd, "showpage\n");
1222 }
1223 }
1224
1225 return (pages);
1226 }
1227
1228 /* Compute scale factor and write out file header */
1229 int psStart(FILE *fd, int npages, int auto_rotate, int *rotation, double *scale,
1230 double ox, double oy, double pgwidth, double pgheight,
1231 double reqwidth, double reqheight, double pswidth, double psheight,
1232 double left_offset, double bottom_offset)
1233 {
1234 double maxsource = 0.0; /* Used for auto rotations */
1235 double maxtarget = 0.0;
1236 double xscale = 1.0, yscale = 1.0;
1237 double splitheight;
1238 double splitwidth;
1239 double view_width = 0.0, view_height = 0.0;
1240 double page_width = 0.0, page_height = 0.0;
1241
1242 /* Splitheight and splitwidth are in inches */
1243 splitheight = maxPageHeight * PS_UNIT_SIZE;
1244 splitwidth = maxPageWidth * PS_UNIT_SIZE;
1245
1246 page_width = pgwidth * PS_UNIT_SIZE;
1247 page_height = pgheight * PS_UNIT_SIZE;
1248
1249 /* If user has specified a page width and height and requested the
1250 * image to be auto-rotated to fit on that media, we match the
1251 * longest dimension of the image to the longest dimension of the
1252 * target media but we have to ignore auto rotate if user specified
1253 * maxPageHeight since this makes life way too complicated. */
1254 if (auto_rotate)
1255 {
1256 if ((splitheight != 0) || (splitwidth != 0))
1257 {
1258 TIFFError ("psStart", "Auto-rotate is incompatible with page splitting ");
1259 return (1);
1260 }
1261
1262 /* Find longest edges in image and output media */
1263 maxsource = (pswidth >= psheight) ? pswidth : psheight;
1264 maxtarget = (reqwidth >= reqheight) ? reqwidth : reqheight;
1265
1266 if (((maxsource == pswidth) && (maxtarget != reqwidth)) ||
1267 ((maxsource == psheight) && (maxtarget != reqheight)))
1268 { /* optimal orientaion does not match input orientation */
1269 *rotation = 90;
1270 xscale = (reqwidth - left_offset)/psheight;
1271 yscale = (reqheight - bottom_offset)/pswidth;
1272 }
1273 else /* optimal orientaion matches input orientation */
1274 {
1275 xscale = (reqwidth - left_offset)/pswidth;
1276 yscale = (reqheight - bottom_offset)/psheight;
1277 }
1278 *scale = (xscale < yscale) ? xscale : yscale;
1279
1280 /* Do not scale image beyound original size */
1281 if (*scale > 1.0)
1282 *scale = 1.0;
1283
1284 /* Set the size of the displayed image to requested page size
1285 * and optimal orientation.
1286 */
1287 if (!npages)
1288 PSHead(fd, reqwidth, reqheight, ox, oy);
1289
1290 return (0);
1291 }
1292
1293 /* N.B. If pgwidth or pgheight are set from maxPageHeight/Width,
1294 * we have a problem with the tests below under splitheight.
1295 */
1296
1297 switch (*rotation) /* Auto rotate has NOT been specified */
1298 {
1299 case 0:
1300 case 180: if ((splitheight != 0) || (splitwidth != 0))
1301 { /* Viewport clipped to maxPageHeight or maxPageWidth */
1302 if ((page_width != 0) || (page_height != 0)) /* Image scaled */
1303 {
1304 xscale = (reqwidth - left_offset) / (page_width ? page_width : pswidth);
1305 yscale = (reqheight - bottom_offset) / (page_height ? page_height : psheight);
1306 *scale = (xscale < yscale) ? xscale : yscale;
1307 /*
1308 if (*scale > 1.0)
1309 *scale = 1.0;
1310 */
1311 }
1312 else /* Image clipped but not scaled */
1313 *scale = 1.0;
1314
1315 view_width = splitwidth ? splitwidth : *scale * pswidth;
1316 view_height = splitheight ? splitheight: *scale * psheight;
1317 }
1318 else /* Viewport not clipped to maxPageHeight or maxPageWidth */
1319 {
1320 if ((page_width != 0) || (page_height != 0))
1321 { /* Image scaled */
1322 xscale = (reqwidth - left_offset) / pswidth;
1323 yscale = (reqheight - bottom_offset) / psheight;
1324
1325 view_width = reqwidth;
1326 view_height = reqheight;
1327 }
1328 else
1329 { /* Image not scaled */
1330 xscale = (pswidth - left_offset)/pswidth;
1331 yscale = (psheight - bottom_offset)/psheight;
1332
1333 view_width = pswidth;
1334 view_height = psheight;
1335 }
1336 }
1337 break;
1338 case 90:
1339 case 270: if ((splitheight != 0) || (splitwidth != 0))
1340 { /* Viewport clipped to maxPageHeight or maxPageWidth */
1341 if ((page_width != 0) || (page_height != 0)) /* Image scaled */
1342 {
1343 xscale = (reqwidth - left_offset)/ psheight;
1344 yscale = (reqheight - bottom_offset)/ pswidth;
1345 *scale = (xscale < yscale) ? xscale : yscale;
1346 /*
1347 if (*scale > 1.0)
1348 *scale = 1.0;
1349 */
1350 }
1351 else /* Image clipped but not scaled */
1352 *scale = 1.0;
1353 view_width = splitwidth ? splitwidth : *scale * psheight;
1354 view_height = splitheight ? splitheight : *scale * pswidth;
1355 }
1356 else /* Viewport not clipped to maxPageHeight or maxPageWidth */
1357 {
1358 if ((page_width != 0) || (page_height != 0)) /* Image scaled */
1359 {
1360 xscale = (reqwidth - left_offset) / psheight;
1361 yscale = (reqheight - bottom_offset) / pswidth;
1362
1363 view_width = reqwidth;
1364 view_height = reqheight;
1365 }
1366 else
1367 {
1368 xscale = (pswidth - left_offset)/ psheight;
1369 yscale = (psheight - bottom_offset)/ pswidth;
1370
1371 view_width = psheight;
1372 view_height = pswidth;
1373 }
1374 }
1375 break;
1376 default: TIFFError ("psPageSize", "Invalid rotation %d", *rotation);
1377 return (1);
1378 }
1379
1380 if (!npages)
1381 PSHead(fd, (page_width ? page_width : view_width), (page_height ? page_height : view_height), ox, oy);
1382
1383 *scale = (xscale < yscale) ? xscale : yscale;
1384 if (*scale > 1.0)
1385 *scale = 1.0;
1386
1387 return (0);
1388 }
1389
1390 int get_viewport (double pgwidth, double pgheight, double pswidth, double psheight,
1391 double *view_width, double *view_height, int rotation)
1392 {
1393 /* Only one of maxPageHeight or maxPageWidth can be specified */
1394 if (maxPageHeight != 0) /* Clip the viewport to maxPageHeight on each page */
1395 {
1396 *view_height = maxPageHeight * PS_UNIT_SIZE;
1397 /*
1398 * if (res_unit == RESUNIT_CENTIMETER)
1399 * *view_height /= 2.54F;
1400 */
1401 }
1402 else
1403 {
1404 if (pgheight != 0) /* User has set PageHeight with -h flag */
1405 {
1406 *view_height = pgheight * PS_UNIT_SIZE; /* Postscript size for Page Height in inches */
1407 /* if (res_unit == RESUNIT_CENTIMETER)
1408 * *view_height /= 2.54F;
1409 */
1410 }
1411 else /* If no width or height are specified, use the original size from image */
1412 switch (rotation)
1413 {
1414 default:
1415 case 0:
1416 case 180: *view_height = psheight;
1417 break;
1418 case 90:
1419 case 270: *view_height = pswidth;
1420 break;
1421 }
1422 }
1423
1424 if (maxPageWidth != 0) /* Clip the viewport to maxPageWidth on each page */
1425 {
1426 *view_width = maxPageWidth * PS_UNIT_SIZE;
1427 /* if (res_unit == RESUNIT_CENTIMETER)
1428 * *view_width /= 2.54F;
1429 */
1430 }
1431 else
1432 {
1433 if (pgwidth != 0) /* User has set PageWidth with -w flag */
1434 {
1435 *view_width = pgwidth * PS_UNIT_SIZE; /* Postscript size for Page Width in inches */
1436 /* if (res_unit == RESUNIT_CENTIMETER)
1437 * *view_width /= 2.54F;
1438 */
1439 }
1440 else /* If no width or height are specified, use the original size from image */
1441 switch (rotation)
1442 {
1443 default:
1444 case 0:
1445 case 180: *view_width = pswidth;
1446 break;
1447 case 90:
1448 case 270: *view_width = psheight; /* (*view_height / psheight) * psheight; */
1449 break;
1450 }
1451 }
1452
1453 return (0);
1454 }
1455
1456 /* pgwidth and pgheight specify page width and height in inches from -h and -w flags
1457 * lm and bm are the LeftMargin and BottomMargin in inches
1458 * center causes the image to be centered on the page if the paper size is
1459 * larger than the image size
1460 * returns the sequence number of the page processed or -1 on error
1461 */
1462
1463 int TIFF2PS(FILE* fd, TIFF* tif, double pgwidth, double pgheight, double lm, double bm, int center)
1464 {
1465 uint32 pixwidth = 0, pixheight = 0; /* Image width and height in pixels */
1466 double ox = 0.0, oy = 0.0; /* Offset from current Postscript origin */
1467 double pswidth, psheight; /* Original raw image width and height in points */
1468 double view_width, view_height; /* Viewport width and height in points */
1469 double scale = 1.0;
1470 double left_offset = lm * PS_UNIT_SIZE;
1471 double bottom_offset = bm * PS_UNIT_SIZE;
1472 uint32 subfiletype;
1473 uint16* sampleinfo;
1474 static int npages = 0;
1475
1476 if (!TIFFGetField(tif, TIFFTAG_XPOSITION, &ox))
1477 ox = 0;
1478 if (!TIFFGetField(tif, TIFFTAG_YPOSITION, &oy))
1479 oy = 0;
1480
1481 /* Consolidated all the tag information into one code segment, Richard Nolde */
1482 do {
1483 tf_numberstrips = TIFFNumberOfStrips(tif);
1484 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &tf_rowsperstrip);
1485 TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &bitspersample);
1486 TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
1487 TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfiguration);
1488 TIFFGetField(tif, TIFFTAG_COMPRESSION, &compression);
1489 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES, &extrasamples, &sampleinfo);
1490 alpha = (extrasamples == 1 && sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
1491 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric))
1492 {
1493 switch (samplesperpixel - extrasamples)
1494 {
1495 case 1: if (isCCITTCompression(tif))
1496 photometric = PHOTOMETRIC_MINISWHITE;
1497 else
1498 photometric = PHOTOMETRIC_MINISBLACK;
1499 break;
1500 case 3: photometric = PHOTOMETRIC_RGB;
1501 break;
1502 case 4: photometric = PHOTOMETRIC_SEPARATED;
1503 break;
1504 }
1505 }
1506
1507 /* Read image tags for width and height in pixels pixwidth, pixheight,
1508 * and convert to points pswidth, psheight
1509 */
1510 setupPageState(tif, &pixwidth, &pixheight, &pswidth, &psheight);
1511 view_width = pswidth;
1512 view_height = psheight;
1513
1514 if (get_viewport (pgwidth, pgheight, pswidth, psheight, &view_width, &view_height, rotation))
1515 {
1516 TIFFError("get_viewport", "Unable to set image viewport");
1517 return (1);
1518 }
1519
1520 /* Write the Postscript file header with Bounding Box and Page Size definitions */
1521 if (psStart(fd, npages, auto_rotate, &rotation, &scale, ox, oy,
1522 pgwidth, pgheight, view_width, view_height, pswidth, psheight,
1523 left_offset, bottom_offset))
1524 return (-1);
1525
1526 if (checkImage(tif)) /* Aborts if unsupported image parameters */
1527 {
1528 tf_bytesperrow = TIFFScanlineSize(tif);
1529
1530 /* Set viewport clipping and scaling options */
1531 if ((maxPageHeight) || (maxPageWidth) || (pgwidth != 0) || (pgheight != 0))
1532 {
1533 if ((maxPageHeight) || (maxPageWidth)) /* used -H or -W option */
1534 {
1535 if (psMaskImage(fd, tif, rotation, center, &npages, pixwidth, pixheight,
1536 left_offset, bottom_offset, pgwidth, pgheight,
1537 pswidth, psheight, scale) < 0)
1538 return (-1);
1539 }
1540 else /* N.B. Setting maxPageHeight no longer sets pgheight */
1541 {
1542 if (pgwidth != 0 || pgheight != 0)
1543 {
1544 /* User did not specify a maxium page height or width using -H or -W flag
1545 * but did use -h or -w flag to scale to a specific size page.
1546 */
1547 npages++;
1548 fprintf(fd, "%%%%Page: %d %d\n", npages, npages);
1549
1550 if (!generateEPSF && ( level2 || level3 ))
1551 {
1552 /* Write out the PageSize info for non EPS files */
1553 if (psPageSize(fd, rotation, pgwidth, pgheight,
1554 view_width, view_height, pswidth, psheight))
1555 return (-1);
1556 }
1557 fprintf(fd, "gsave\n");
1558 fprintf(fd, "100 dict begin\n");
1559 if (psScaleImage(fd, scale, rotation, center, view_width, view_height,
1560 pswidth, psheight, left_offset, bottom_offset))
1561 return (-1);
1562
1563 PSpage(fd, tif, pixwidth, pixheight);
1564 fprintf(fd, "end\n");
1565 fprintf(fd, "grestore\n");
1566 fprintf(fd, "showpage\n");
1567 }
1568 }
1569 }
1570 else /* Simple rotation: user did not use -H, -W, -h or -w */
1571 {
1572 npages++;
1573 fprintf(fd, "%%%%Page: %d %d\n", npages, npages);
1574
1575 if (!generateEPSF && ( level2 || level3 ))
1576 {
1577 /* Write out the PageSize info for non EPS files */
1578 if (psPageSize(fd, rotation, pgwidth, pgheight,
1579 view_width, view_height, pswidth, psheight))
1580 return (-1);
1581 }
1582 fprintf(fd, "gsave\n");
1583 fprintf(fd, "100 dict begin\n");
1584 if (psRotateImage(fd, rotation, pswidth, psheight, left_offset, bottom_offset))
1585 return (-1);
1586
1587 PSpage(fd, tif, pixwidth, pixheight);
1588 fprintf(fd, "end\n");
1589 fprintf(fd, "grestore\n");
1590 fprintf(fd, "showpage\n");
1591 }
1592 }
1593 if (generateEPSF)
1594 break;
1595 TIFFGetFieldDefaulted(tif, TIFFTAG_SUBFILETYPE, &subfiletype);
1596 } while (((subfiletype & FILETYPE_PAGE) || printAll) && TIFFReadDirectory(tif));
1597
1598 return(npages);
1599 }
1600
1601 static char DuplexPreamble[] = "\
1602 %%BeginFeature: *Duplex True\n\
1603 systemdict begin\n\
1604 /languagelevel where { pop languagelevel } { 1 } ifelse\n\
1605 2 ge { 1 dict dup /Duplex true put setpagedevice }\n\
1606 { statusdict /setduplex known { statusdict begin setduplex true end } if\n\
1607 } ifelse\n\
1608 end\n\
1609 %%EndFeature\n\
1610 ";
1611
1612 static char TumblePreamble[] = "\
1613 %%BeginFeature: *Tumble True\n\
1614 systemdict begin\n\
1615 /languagelevel where { pop languagelevel } { 1 } ifelse\n\
1616 2 ge { 1 dict dup /Tumble true put setpagedevice }\n\
1617 { statusdict /settumble known { statusdict begin true settumble end } if\n\
1618 } ifelse\n\
1619 end\n\
1620 %%EndFeature\n\
1621 ";
1622
1623 static char AvoidDeadZonePreamble[] = "\
1624 gsave newpath clippath pathbbox grestore\n\
1625 4 2 roll 2 copy translate\n\
1626 exch 3 1 roll sub 3 1 roll sub exch\n\
1627 currentpagedevice /PageSize get aload pop\n\
1628 exch 3 1 roll div 3 1 roll div abs exch abs\n\
1629 2 copy gt { exch } if pop\n\
1630 dup 1 lt { dup scale } { pop } ifelse\n\
1631 ";
1632
1633 void
1634 PSHead(FILE *fd, double pagewidth, double pageheight, double xoff, double yoff)
1635 {
1636 time_t t;
1637
1638 t = time(0);
1639 fprintf(fd, "%%!PS-Adobe-3.0%s\n", generateEPSF ? " EPSF-3.0" : "");
1640 fprintf(fd, "%%%%Creator: %s\n", creator ? creator : "tiff2ps");
1641 fprintf(fd, "%%%%Title: %s\n", title ? title : filename);
1642 fprintf(fd, "%%%%CreationDate: %s", ctime(&t));
1643 fprintf(fd, "%%%%DocumentData: Clean7Bit\n");
1644 /* NB: should use PageBoundingBox for each page instead of BoundingBox *
1645 * PageBoundingBox DSC added in PSPageSize function, R Nolde 09-01-2010
1646 */
1647 fprintf(fd, "%%%%Origin: %ld %ld\n", (long) xoff, (long) yoff);
1648 fprintf(fd, "%%%%BoundingBox: 0 0 %ld %ld\n",
1649 (long) ceil(pagewidth), (long) ceil(pageheight));
1650
1651 fprintf(fd, "%%%%LanguageLevel: %d\n", (level3 ? 3 : (level2 ? 2 : 1)));
1652 if (generateEPSF == TRUE)
1653 fprintf(fd, "%%%%Pages: 1 1\n");
1654 else
1655 fprintf(fd, "%%%%Pages: (atend)\n");
1656 fprintf(fd, "%%%%EndComments\n");
1657 if (generateEPSF == FALSE)
1658 {
1659 fprintf(fd, "%%%%BeginSetup\n");
1660 if (PSduplex)
1661 fprintf(fd, "%s", DuplexPreamble);
1662 if (PStumble)
1663 fprintf(fd, "%s", TumblePreamble);
1664 if (PSavoiddeadzone && (level2 || level3))
1665 fprintf(fd, "%s", AvoidDeadZonePreamble);
1666 fprintf(fd, "%%%%EndSetup\n");
1667 }
1668 }
1669
1670 void
1671 PSTail(FILE *fd, int npages)
1672 {
1673 fprintf(fd, "%%%%Trailer\n");
1674 if (generateEPSF == FALSE)
1675 fprintf(fd, "%%%%Pages: %d\n", npages);
1676 fprintf(fd, "%%%%EOF\n");
1677 }
1678
1679 static int
1680 checkcmap(TIFF* tif, int n, uint16* r, uint16* g, uint16* b)
1681 {
1682 (void) tif;
1683 while (n-- > 0)
1684 if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
1685 return (16);
1686 TIFFWarning(filename, "Assuming 8-bit colormap");
1687 return (8);
1688 }
1689
1690 static void
1691 PS_Lvl2colorspace(FILE* fd, TIFF* tif)
1692 {
1693 uint16 *rmap, *gmap, *bmap;
1694 int i, num_colors;
1695 const char * colorspace_p;
1696
1697 switch ( photometric )
1698 {
1699 case PHOTOMETRIC_SEPARATED:
1700 colorspace_p = "CMYK";
1701 break;
1702
1703 case PHOTOMETRIC_RGB:
1704 colorspace_p = "RGB";
1705 break;
1706
1707 default:
1708 colorspace_p = "Gray";
1709 }
1710
1711 /*
1712 * Set up PostScript Level 2 colorspace according to
1713 * section 4.8 in the PostScript refenence manual.
1714 */
1715 fputs("% PostScript Level 2 only.\n", fd);
1716 if (photometric != PHOTOMETRIC_PALETTE) {
1717 if (photometric == PHOTOMETRIC_YCBCR) {
1718 /* MORE CODE HERE */
1719 }
1720 fprintf(fd, "/Device%s setcolorspace\n", colorspace_p );
1721 return;
1722 }
1723
1724 /*
1725 * Set up an indexed/palette colorspace
1726 */
1727 num_colors = (1 << bitspersample);
1728 if (!TIFFGetField(tif, TIFFTAG_COLORMAP, &rmap, &gmap, &bmap)) {
1729 TIFFError(filename,
1730 "Palette image w/o \"Colormap\" tag");
1731 return;
1732 }
1733 if (checkcmap(tif, num_colors, rmap, gmap, bmap) == 16) {
1734 /*
1735 * Convert colormap to 8-bits values.
1736 */
1737 #define CVT(x) (((x) * 255) / ((1L<<16)-1))
1738 for (i = 0; i < num_colors; i++) {
1739 rmap[i] = CVT(rmap[i]);
1740 gmap[i] = CVT(gmap[i]);
1741 bmap[i] = CVT(bmap[i]);
1742 }
1743 #undef CVT
1744 }
1745 fprintf(fd, "[ /Indexed /DeviceRGB %d", num_colors - 1);
1746 if (ascii85) {
1747 Ascii85Init();
1748 fputs("\n<~", fd);
1749 ascii85breaklen -= 2;
1750 } else
1751 fputs(" <", fd);
1752 for (i = 0; i < num_colors; i++) {
1753 if (ascii85) {
1754 Ascii85Put((unsigned char)rmap[i], fd);
1755 Ascii85Put((unsigned char)gmap[i], fd);
1756 Ascii85Put((unsigned char)bmap[i], fd);
1757 } else {
1758 fputs((i % 8) ? " " : "\n ", fd);
1759 fprintf(fd, "%02x%02x%02x",
1760 rmap[i], gmap[i], bmap[i]);
1761 }
1762 }
1763 if (ascii85)
1764 Ascii85Flush(fd);
1765 else
1766 fputs(">\n", fd);
1767 fputs("] setcolorspace\n", fd);
1768 }
1769
1770 static int
1771 PS_Lvl2ImageDict(FILE* fd, TIFF* tif, uint32 w, uint32 h)
1772 {
1773 int use_rawdata;
1774 uint32 tile_width, tile_height;
1775 uint16 predictor, minsamplevalue, maxsamplevalue;
1776 int repeat_count;
1777 char im_h[64], im_x[64], im_y[64];
1778 char * imageOp = "image";
1779
1780 if ( useImagemask && (bitspersample == 1) )
1781 imageOp = "imagemask";
1782
1783 (void)strcpy(im_x, "0");
1784 (void)sprintf(im_y, "%lu", (long) h);
1785 (void)sprintf(im_h, "%lu", (long) h);
1786 tile_width = w;
1787 tile_height = h;
1788 if (TIFFIsTiled(tif)) {
1789 repeat_count = TIFFNumberOfTiles(tif);
1790 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width);
1791 TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height);
1792 if (tile_width > w || tile_height > h ||
1793 (w % tile_width) != 0 || (h % tile_height != 0)) {
1794 /*
1795 * The tiles does not fit image width and height.
1796 * Set up a clip rectangle for the image unit square.
1797 */
1798 fputs("0 0 1 1 rectclip\n", fd);
1799 }
1800 if (tile_width < w) {
1801 fputs("/im_x 0 def\n", fd);
1802 (void)strcpy(im_x, "im_x neg");
1803 }
1804 if (tile_height < h) {
1805 fputs("/im_y 0 def\n", fd);
1806 (void)sprintf(im_y, "%lu im_y sub", (unsigned long) h);
1807 }
1808 } else {
1809 repeat_count = tf_numberstrips;
1810 tile_height = tf_rowsperstrip;
1811 if (tile_height > h)
1812 tile_height = h;
1813 if (repeat_count > 1) {
1814 fputs("/im_y 0 def\n", fd);
1815 fprintf(fd, "/im_h %lu def\n",
1816 (unsigned long) tile_height);
1817 (void)strcpy(im_h, "im_h");
1818 (void)sprintf(im_y, "%lu im_y sub", (unsigned long) h);
1819 }
1820 }
1821
1822 /*
1823 * Output start of exec block
1824 */
1825 fputs("{ % exec\n", fd);
1826
1827 if (repeat_count > 1)
1828 fprintf(fd, "%d { %% repeat\n", repeat_count);
1829
1830 /*
1831 * Output filter options and image dictionary.
1832 */
1833 if (ascii85)
1834 fputs(" /im_stream currentfile /ASCII85Decode filter def\n",
1835 fd);
1836 fputs(" <<\n", fd);
1837 fputs(" /ImageType 1\n", fd);
1838 fprintf(fd, " /Width %lu\n", (unsigned long) tile_width);
1839 /*
1840 * Workaround for some software that may crash when last strip
1841 * of image contains fewer number of scanlines than specified
1842 * by the `/Height' variable. So for stripped images with multiple
1843 * strips we will set `/Height' as `im_h', because one is
1844 * recalculated for each strip - including the (smaller) final strip.
1845 * For tiled images and images with only one strip `/Height' will
1846 * contain number of scanlines in tile (or image height in case of
1847 * one-stripped image).
1848 */
1849 if (TIFFIsTiled(tif) || tf_numberstrips == 1)
1850 fprintf(fd, " /Height %lu\n", (unsigned long) tile_height);
1851 else
1852 fprintf(fd, " /Height im_h\n");
1853
1854 if (planarconfiguration == PLANARCONFIG_SEPARATE && samplesperpixel > 1)
1855 fputs(" /MultipleDataSources true\n", fd);
1856 fprintf(fd, " /ImageMatrix [ %lu 0 0 %ld %s %s ]\n",
1857 (unsigned long) w, - (long)h, im_x, im_y);
1858 fprintf(fd, " /BitsPerComponent %d\n", bitspersample);
1859 fprintf(fd, " /Interpolate %s\n", interpolate ? "true" : "false");
1860
1861 switch (samplesperpixel - extrasamples) {
1862 case 1:
1863 switch (photometric) {
1864 case PHOTOMETRIC_MINISBLACK:
1865 fputs(" /Decode [0 1]\n", fd);
1866 break;
1867 case PHOTOMETRIC_MINISWHITE:
1868 switch (compression) {
1869 case COMPRESSION_CCITTRLE:
1870 case COMPRESSION_CCITTRLEW:
1871 case COMPRESSION_CCITTFAX3:
1872 case COMPRESSION_CCITTFAX4:
1873 /*
1874 * Manage inverting with /Blackis1 flag
1875 * since there migth be uncompressed parts
1876 */
1877 fputs(" /Decode [0 1]\n", fd);
1878 break;
1879 default:
1880 /*
1881 * ERROR...
1882 */
1883 fputs(" /Decode [1 0]\n", fd);
1884 break;
1885 }
1886 break;
1887 case PHOTOMETRIC_PALETTE:
1888 TIFFGetFieldDefaulted(tif, TIFFTAG_MINSAMPLEVALUE,
1889 &minsamplevalue);
1890 TIFFGetFieldDefaulted(tif, TIFFTAG_MAXSAMPLEVALUE,
1891 &maxsamplevalue);
1892 fprintf(fd, " /Decode [%u %u]\n",
1893 minsamplevalue, maxsamplevalue);
1894 break;
1895 default:
1896 /*
1897 * ERROR ?
1898 */
1899 fputs(" /Decode [0 1]\n", fd);
1900 break;
1901 }
1902 break;
1903 case 3:
1904 switch (photometric) {
1905 case PHOTOMETRIC_RGB:
1906 fputs(" /Decode [0 1 0 1 0 1]\n", fd);
1907 break;
1908 case PHOTOMETRIC_MINISWHITE:
1909 case PHOTOMETRIC_MINISBLACK:
1910 default:
1911 /*
1912 * ERROR??
1913 */
1914 fputs(" /Decode [0 1 0 1 0 1]\n", fd);
1915 break;
1916 }
1917 break;
1918 case 4:
1919 /*
1920 * ERROR??
1921 */
1922 fputs(" /Decode [0 1 0 1 0 1 0 1]\n", fd);
1923 break;
1924 }
1925 fputs(" /DataSource", fd);
1926 if (planarconfiguration == PLANARCONFIG_SEPARATE &&
1927 samplesperpixel > 1)
1928 fputs(" [", fd);
1929 if (ascii85)
1930 fputs(" im_stream", fd);
1931 else
1932 fputs(" currentfile /ASCIIHexDecode filter", fd);
1933
1934 use_rawdata = TRUE;
1935 switch (compression) {
1936 case COMPRESSION_NONE: /* 1: uncompressed */
1937 break;
1938 case COMPRESSION_CCITTRLE: /* 2: CCITT modified Huffman RLE */
1939 case COMPRESSION_CCITTRLEW: /* 32771: #1 w/ word alignment */
1940 case COMPRESSION_CCITTFAX3: /* 3: CCITT Group 3 fax encoding */
1941 case COMPRESSION_CCITTFAX4: /* 4: CCITT Group 4 fax encoding */
1942 fputs("\n\t<<\n", fd);
1943 if (compression == COMPRESSION_CCITTFAX3) {
1944 uint32 g3_options;
1945
1946 fputs("\t /EndOfLine true\n", fd);
1947 fputs("\t /EndOfBlock false\n", fd);
1948 if (!TIFFGetField(tif, TIFFTAG_GROUP3OPTIONS,
1949 &g3_options))
1950 g3_options = 0;
1951 if (g3_options & GROUP3OPT_2DENCODING)
1952 fprintf(fd, "\t /K %s\n", im_h);
1953 if (g3_options & GROUP3OPT_UNCOMPRESSED)
1954 fputs("\t /Uncompressed true\n", fd);
1955 if (g3_options & GROUP3OPT_FILLBITS)
1956 fputs("\t /EncodedByteAlign true\n", fd);
1957 }
1958 if (compression == COMPRESSION_CCITTFAX4) {
1959 uint32 g4_options;
1960
1961 fputs("\t /K -1\n", fd);
1962 TIFFGetFieldDefaulted(tif, TIFFTAG_GROUP4OPTIONS,
1963 &g4_options);
1964 if (g4_options & GROUP4OPT_UNCOMPRESSED)
1965 fputs("\t /Uncompressed true\n", fd);
1966 }
1967 if (!(tile_width == w && w == 1728U))
1968 fprintf(fd, "\t /Columns %lu\n",
1969 (unsigned long) tile_width);
1970 fprintf(fd, "\t /Rows %s\n", im_h);
1971 if (compression == COMPRESSION_CCITTRLE ||
1972 compression == COMPRESSION_CCITTRLEW) {
1973 fputs("\t /EncodedByteAlign true\n", fd);
1974 fputs("\t /EndOfBlock false\n", fd);
1975 }
1976 if (photometric == PHOTOMETRIC_MINISBLACK)
1977 fputs("\t /BlackIs1 true\n", fd);
1978 fprintf(fd, "\t>> /CCITTFaxDecode filter");
1979 break;
1980 case COMPRESSION_LZW: /* 5: Lempel-Ziv & Welch */
1981 TIFFGetFieldDefaulted(tif, TIFFTAG_PREDICTOR, &predictor);
1982 if (predictor == 2) {
1983 fputs("\n\t<<\n", fd);
1984 fprintf(fd, "\t /Predictor %u\n", predictor);
1985 fprintf(fd, "\t /Columns %lu\n",
1986 (unsigned long) tile_width);
1987 fprintf(fd, "\t /Colors %u\n", samplesperpixel);
1988 fprintf(fd, "\t /BitsPerComponent %u\n",
1989 bitspersample);
1990 fputs("\t>>", fd);
1991 }
1992 fputs(" /LZWDecode filter", fd);
1993 break;
1994 case COMPRESSION_DEFLATE: /* 5: ZIP */
1995 case COMPRESSION_ADOBE_DEFLATE:
1996 if ( level3 ) {
1997 TIFFGetFieldDefaulted(tif, TIFFTAG_PREDICTOR, &predictor);
1998 if (predictor > 1) {
1999 fprintf(fd, "\t %% PostScript Level 3 only.");
2000 fputs("\n\t<<\n", fd);
2001 fprintf(fd, "\t /Predictor %u\n", predictor);
2002 fprintf(fd, "\t /Columns %lu\n",
2003 (unsigned long) tile_width);
2004 fprintf(fd, "\t /Colors %u\n", samplesperpixel);
2005 fprintf(fd, "\t /BitsPerComponent %u\n",
2006 bitspersample);
2007 fputs("\t>>", fd);
2008 }
2009 fputs(" /FlateDecode filter", fd);
2010 } else {
2011 use_rawdata = FALSE ;
2012 }
2013 break;
2014 case COMPRESSION_PACKBITS: /* 32773: Macintosh RLE */
2015 fputs(" /RunLengthDecode filter", fd);
2016 use_rawdata = TRUE;
2017 break;
2018 case COMPRESSION_OJPEG: /* 6: !6.0 JPEG */
2019 case COMPRESSION_JPEG: /* 7: %JPEG DCT compression */
2020 #ifdef notdef
2021 /*
2022 * Code not tested yet
2023 */
2024 fputs(" /DCTDecode filter", fd);
2025 use_rawdata = TRUE;
2026 #else
2027 use_rawdata = FALSE;
2028 #endif
2029 break;
2030 case COMPRESSION_NEXT: /* 32766: NeXT 2-bit RLE */
2031 case COMPRESSION_THUNDERSCAN: /* 32809: ThunderScan RLE */
2032 case COMPRESSION_PIXARFILM: /* 32908: Pixar companded 10bit LZW */
2033 case COMPRESSION_JBIG: /* 34661: ISO JBIG */
2034 use_rawdata = FALSE;
2035 break;
2036 case COMPRESSION_SGILOG: /* 34676: SGI LogL or LogLuv */
2037 case COMPRESSION_SGILOG24: /* 34677: SGI 24-bit LogLuv */
2038 use_rawdata = FALSE;
2039 break;
2040 default:
2041 /*
2042 * ERROR...
2043 */
2044 use_rawdata = FALSE;
2045 break;
2046 }
2047 if (planarconfiguration == PLANARCONFIG_SEPARATE &&
2048 samplesperpixel > 1) {
2049 uint16 i;
2050
2051 /*
2052 * NOTE: This code does not work yet...
2053 */
2054 for (i = 1; i < samplesperpixel; i++)
2055 fputs(" dup", fd);
2056 fputs(" ]", fd);
2057 }
2058
2059 fprintf( fd, "\n >> %s\n", imageOp );
2060 if (ascii85)
2061 fputs(" im_stream status { im_stream flushfile } if\n", fd);
2062 if (repeat_count > 1) {
2063 if (tile_width < w) {
2064 fprintf(fd, " /im_x im_x %lu add def\n",
2065 (unsigned long) tile_width);
2066 if (tile_height < h) {
2067 fprintf(fd, " im_x %lu ge {\n",
2068 (unsigned long) w);
2069 fputs(" /im_x 0 def\n", fd);
2070 fprintf(fd, " /im_y im_y %lu add def\n",
2071 (unsigned long) tile_height);
2072 fputs(" } if\n", fd);
2073 }
2074 }
2075 if (tile_height < h) {
2076 if (tile_width >= w) {
2077 fprintf(fd, " /im_y im_y %lu add def\n",
2078 (unsigned long) tile_height);
2079 if (!TIFFIsTiled(tif)) {
2080 fprintf(fd, " /im_h %lu im_y sub",
2081 (unsigned long) h);
2082 fprintf(fd, " dup %lu gt { pop",
2083 (unsigned long) tile_height);
2084 fprintf(fd, " %lu } if def\n",
2085 (unsigned long) tile_height);
2086 }
2087 }
2088 }
2089 fputs("} repeat\n", fd);
2090 }
2091 /*
2092 * End of exec function
2093 */
2094 fputs("}\n", fd);
2095
2096 return(use_rawdata);
2097 }
2098
2099 /* Flip the byte order of buffers with 16 bit samples */
2100 static void
2101 PS_FlipBytes(unsigned char* buf, tsize_t count)
2102 {
2103 int i;
2104 unsigned char temp;
2105
2106 if (count <= 0 || bitspersample <= 8) {
2107 return;
2108 }
2109
2110 count--;
2111
2112 for (i = 0; i < count; i += 2) {
2113 temp = buf[i];
2114 buf[i] = buf[i + 1];
2115 buf[i + 1] = temp;
2116 }
2117 }
2118
2119 #define MAXLINE 36
2120
2121 int
2122 PS_Lvl2page(FILE* fd, TIFF* tif, uint32 w, uint32 h)
2123 {
2124 uint16 fillorder;
2125 int use_rawdata, tiled_image, breaklen = MAXLINE;
2126 uint32 chunk_no, num_chunks;
2127 uint64 *bc;
2128 unsigned char *buf_data, *cp;
2129 tsize_t chunk_size, byte_count;
2130
2131 #if defined( EXP_ASCII85ENCODER )
2132 tsize_t ascii85_l; /* Length, in bytes, of ascii85_p[] data */
2133 uint8 * ascii85_p = 0; /* Holds ASCII85 encoded data */
2134 #endif
2135
2136 PS_Lvl2colorspace(fd, tif);
2137 use_rawdata = PS_Lvl2ImageDict(fd, tif, w, h);
2138
2139 /* See http://bugzilla.remotesensing.org/show_bug.cgi?id=80 */
2140 #ifdef ENABLE_BROKEN_BEGINENDDATA
2141 fputs("%%BeginData:\n", fd);
2142 #endif
2143 fputs("exec\n", fd);
2144
2145 tiled_image = TIFFIsTiled(tif);
2146 if (tiled_image) {
2147 num_chunks = TIFFNumberOfTiles(tif);
2148 TIFFGetField(tif, TIFFTAG_TILEBYTECOUNTS, &bc);
2149 } else {
2150 num_chunks = TIFFNumberOfStrips(tif);
2151 TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &bc);
2152 }
2153
2154 if (use_rawdata) {
2155 chunk_size = (tsize_t) bc[0];
2156 for (chunk_no = 1; chunk_no < num_chunks; chunk_no++)
2157 if ((tsize_t) bc[chunk_no] > chunk_size)
2158 chunk_size = (tsize_t) bc[chunk_no];
2159 } else {
2160 if (tiled_image)
2161 chunk_size = TIFFTileSize(tif);
2162 else
2163 chunk_size = TIFFStripSize(tif);
2164 }
2165 buf_data = (unsigned char *)_TIFFmalloc(chunk_size);
2166 if (!buf_data) {
2167 TIFFError(filename, "Can't alloc %lu bytes for %s.",
2168 (unsigned long) chunk_size, tiled_image ? "tiles" : "strips");
2169 return(FALSE);
2170 }
2171
2172 #if defined( EXP_ASCII85ENCODER )
2173 if ( ascii85 ) {
2174 /*
2175 * Allocate a buffer to hold the ASCII85 encoded data. Note
2176 * that it is allocated with sufficient room to hold the
2177 * encoded data (5*chunk_size/4) plus the EOD marker (+8)
2178 * and formatting line breaks. The line breaks are more
2179 * than taken care of by using 6*chunk_size/4 rather than
2180 * 5*chunk_size/4.
2181 */
2182
2183 ascii85_p = _TIFFmalloc( (chunk_size+(chunk_size/2)) + 8 );
2184
2185 if ( !ascii85_p ) {
2186 _TIFFfree( buf_data );
2187
2188 TIFFError( filename, "Cannot allocate ASCII85 encoding buffer." );
2189 return ( FALSE );
2190 }
2191 }
2192 #endif
2193
2194 TIFFGetFieldDefaulted(tif, TIFFTAG_FILLORDER, &fillorder);
2195 for (chunk_no = 0; chunk_no < num_chunks; chunk_no++) {
2196 if (ascii85)
2197 Ascii85Init();
2198 else
2199 breaklen = MAXLINE;
2200 if (use_rawdata) {
2201 if (tiled_image)
2202 byte_count = TIFFReadRawTile(tif, chunk_no,
2203 buf_data, chunk_size);
2204 else
2205 byte_count = TIFFReadRawStrip(tif, chunk_no,
2206 buf_data, chunk_size);
2207 if (fillorder == FILLORDER_LSB2MSB)
2208 TIFFReverseBits(buf_data, byte_count);
2209 } else {
2210 if (tiled_image)
2211 byte_count = TIFFReadEncodedTile(tif,
2212 chunk_no, buf_data,
2213 chunk_size);
2214 else
2215 byte_count = TIFFReadEncodedStrip(tif,
2216 chunk_no, buf_data,
2217 chunk_size);
2218 }
2219 if (byte_count < 0) {
2220 TIFFError(filename, "Can't read %s %d.",
2221 tiled_image ? "tile" : "strip", chunk_no);
2222 if (ascii85)
2223 Ascii85Put('\0', fd);
2224 }
2225 /*
2226 * for 16 bits, the two bytes must be most significant
2227 * byte first
2228 */
2229 if (bitspersample == 16 && !TIFFIsBigEndian(tif)) {
2230 PS_FlipBytes(buf_data, byte_count);
2231 }
2232 /*
2233 * For images with alpha, matte against a white background;
2234 * i.e. Cback * (1 - Aimage) where Cback = 1. We will fill the
2235 * lower part of the buffer with the modified values.
2236 *
2237 * XXX: needs better solution
2238 */
2239 if (alpha) {
2240 int adjust, i, j = 0;
2241 int ncomps = samplesperpixel - extrasamples;
2242 for (i = 0; i < byte_count; i+=samplesperpixel) {
2243 adjust = 255 - buf_data[i + ncomps];
2244 switch (ncomps) {
2245 case 1:
2246 buf_data[j++] = buf_data[i] + adjust;
2247 break;
2248 case 2:
2249 buf_data[j++] = buf_data[i] + adjust;
2250 buf_data[j++] = buf_data[i+1] + adjust;
2251 break;
2252 case 3:
2253 buf_data[j++] = buf_data[i] + adjust;
2254 buf_data[j++] = buf_data[i+1] + adjust;
2255 buf_data[j++] = buf_data[i+2] + adjust;
2256 break;
2257 }
2258 }
2259 byte_count -= j;
2260 }
2261
2262 if (ascii85) {
2263 #if defined( EXP_ASCII85ENCODER )
2264 ascii85_l = Ascii85EncodeBlock(ascii85_p, 1, buf_data, byte_count );
2265
2266 if ( ascii85_l > 0 )
2267 fwrite( ascii85_p, ascii85_l, 1, fd );
2268 #else
2269 for (cp = buf_data; byte_count > 0; byte_count--)
2270 Ascii85Put(*cp++, fd);
2271 #endif
2272 }
2273 else
2274 {
2275 for (cp = buf_data; byte_count > 0; byte_count--) {
2276 putc(hex[((*cp)>>4)&0xf], fd);
2277 putc(hex[(*cp)&0xf], fd);
2278 cp++;
2279
2280 if (--breaklen <= 0) {
2281 putc('\n', fd);
2282 breaklen = MAXLINE;
2283 }
2284 }
2285 }
2286
2287 if ( !ascii85 ) {
2288 if ( level2 || level3 )
2289 putc( '>', fd );
2290 putc('\n', fd);
2291 }
2292 #if !defined( EXP_ASCII85ENCODER )
2293 else
2294 Ascii85Flush(fd);
2295 #endif
2296 }
2297
2298 #if defined( EXP_ASCII85ENCODER )
2299 if ( ascii85_p )
2300 _TIFFfree( ascii85_p );
2301 #endif
2302
2303 _TIFFfree(buf_data);
2304 #ifdef ENABLE_BROKEN_BEGINENDDATA
2305 fputs("%%EndData\n", fd);
2306 #endif
2307 return(TRUE);
2308 }
2309
2310 void
2311 PSpage(FILE* fd, TIFF* tif, uint32 w, uint32 h)
2312 {
2313 char * imageOp = "image";
2314
2315 if ( useImagemask && (bitspersample == 1) )
2316 imageOp = "imagemask";
2317
2318 if ((level2 || level3) && PS_Lvl2page(fd, tif, w, h))
2319 return;
2320 ps_bytesperrow = tf_bytesperrow - (extrasamples * bitspersample / 8)*w;
2321 switch (photometric) {
2322 case PHOTOMETRIC_RGB:
2323 if (planarconfiguration == PLANARCONFIG_CONTIG) {
2324 fprintf(fd, "%s", RGBcolorimage);
2325 PSColorContigPreamble(fd, w, h, 3);
2326 PSDataColorContig(fd, tif, w, h, 3);
2327 } else {
2328 PSColorSeparatePreamble(fd, w, h, 3);
2329 PSDataColorSeparate(fd, tif, w, h, 3);
2330 }
2331 break;
2332 case PHOTOMETRIC_SEPARATED:
2333 /* XXX should emit CMYKcolorimage */
2334 if (planarconfiguration == PLANARCONFIG_CONTIG) {
2335 PSColorContigPreamble(fd, w, h, 4);
2336 PSDataColorContig(fd, tif, w, h, 4);
2337 } else {
2338 PSColorSeparatePreamble(fd, w, h, 4);
2339 PSDataColorSeparate(fd, tif, w, h, 4);
2340 }
2341 break;
2342 case PHOTOMETRIC_PALETTE:
2343 fprintf(fd, "%s", RGBcolorimage);
2344 PhotoshopBanner(fd, w, h, 1, 3, "false 3 colorimage");
2345 fprintf(fd, "/scanLine %ld string def\n",
2346 (long) ps_bytesperrow * 3L);
2347 fprintf(fd, "%lu %lu 8\n",
2348 (unsigned long) w, (unsigned long) h);
2349 fprintf(fd, "[%lu 0 0 -%lu 0 %lu]\n",
2350 (unsigned long) w, (unsigned long) h, (unsigned long) h);
2351 fprintf(fd, "{currentfile scanLine readhexstring pop} bind\n");
2352 fprintf(fd, "false 3 colorimage\n");
2353 PSDataPalette(fd, tif, w, h);
2354 break;
2355 case PHOTOMETRIC_MINISBLACK:
2356 case PHOTOMETRIC_MINISWHITE:
2357 PhotoshopBanner(fd, w, h, 1, 1, imageOp);
2358 fprintf(fd, "/scanLine %ld string def\n",
2359 (long) ps_bytesperrow);
2360 fprintf(fd, "%lu %lu %d\n",
2361 (unsigned long) w, (unsigned long) h, bitspersample);
2362 fprintf(fd, "[%lu 0 0 -%lu 0 %lu]\n",
2363 (unsigned long) w, (unsigned long) h, (unsigned long) h);
2364 fprintf(fd,
2365 "{currentfile scanLine readhexstring pop} bind\n");
2366 fprintf(fd, "%s\n", imageOp);
2367 PSDataBW(fd, tif, w, h);
2368 break;
2369 }
2370 putc('\n', fd);
2371 }
2372
2373 void
2374 PSColorContigPreamble(FILE* fd, uint32 w, uint32 h, int nc)
2375 {
2376 ps_bytesperrow = nc * (tf_bytesperrow / samplesperpixel);
2377 PhotoshopBanner(fd, w, h, 1, nc, "false %d colorimage");
2378 fprintf(fd, "/line %ld string def\n", (long) ps_bytesperrow);
2379 fprintf(fd, "%lu %lu %d\n",
2380 (unsigned long) w, (unsigned long) h, bitspersample);
2381 fprintf(fd, "[%lu 0 0 -%lu 0 %lu]\n",
2382 (unsigned long) w, (unsigned long) h, (unsigned long) h);
2383 fprintf(fd, "{currentfile line readhexstring pop} bind\n");
2384 fprintf(fd, "false %d colorimage\n", nc);
2385 }
2386
2387 void
2388 PSColorSeparatePreamble(FILE* fd, uint32 w, uint32 h, int nc)
2389 {
2390 int i;
2391
2392 PhotoshopBanner(fd, w, h, ps_bytesperrow, nc, "true %d colorimage");
2393 for (i = 0; i < nc; i++)
2394 fprintf(fd, "/line%d %ld string def\n",
2395 i, (long) ps_bytesperrow);
2396 fprintf(fd, "%lu %lu %d\n",
2397 (unsigned long) w, (unsigned long) h, bitspersample);
2398 fprintf(fd, "[%lu 0 0 -%lu 0 %lu] \n",
2399 (unsigned long) w, (unsigned long) h, (unsigned long) h);
2400 for (i = 0; i < nc; i++)
2401 fprintf(fd, "{currentfile line%d readhexstring pop}bind\n", i);
2402 fprintf(fd, "true %d colorimage\n", nc);
2403 }
2404
2405 #define DOBREAK(len, howmany, fd) \
2406 if (((len) -= (howmany)) <= 0) { \
2407 putc('\n', fd); \
2408 (len) = MAXLINE-(howmany); \
2409 }
2410 #define PUTHEX(c,fd) putc(hex[((c)>>4)&0xf],fd); putc(hex[(c)&0xf],fd)
2411
2412 void
2413 PSDataColorContig(FILE* fd, TIFF* tif, uint32 w, uint32 h, int nc)
2414 {
2415 uint32 row;
2416 int breaklen = MAXLINE, es = samplesperpixel - nc;
2417 tsize_t cc;
2418 unsigned char *tf_buf;
2419 unsigned char *cp, c;
2420
2421 (void) w;
2422 tf_buf = (unsigned char *) _TIFFmalloc(tf_bytesperrow);
2423 if (tf_buf == NULL) {
2424 TIFFError(filename, "No space for scanline buffer");
2425 return;
2426 }
2427 for (row = 0; row < h; row++) {
2428 if (TIFFReadScanline(tif, tf_buf, row, 0) < 0)
2429 break;
2430 cp = tf_buf;
2431 /*
2432 * for 16 bits, the two bytes must be most significant
2433 * byte first
2434 */
2435 if (bitspersample == 16 && !HOST_BIGENDIAN) {
2436 PS_FlipBytes(cp, tf_bytesperrow);
2437 }
2438 if (alpha) {
2439 int adjust;
2440 cc = 0;
2441 for (; cc < tf_bytesperrow; cc += samplesperpixel) {
2442 DOBREAK(breaklen, nc, fd);
2443 /*
2444 * For images with alpha, matte against
2445 * a white background; i.e.
2446 * Cback * (1 - Aimage)
2447 * where Cback = 1.
2448 */
2449 adjust = 255 - cp[nc];
2450 switch (nc) {
2451 case 4: c = *cp++ + adjust; PUTHEX(c,fd);
2452 case 3: c = *cp++ + adjust; PUTHEX(c,fd);
2453 case 2: c = *cp++ + adjust; PUTHEX(c,fd);
2454 case 1: c = *cp++ + adjust; PUTHEX(c,fd);
2455 }
2456 cp += es;
2457 }
2458 } else {
2459 cc = 0;
2460 for (; cc < tf_bytesperrow; cc += samplesperpixel) {
2461 DOBREAK(breaklen, nc, fd);
2462 switch (nc) {
2463 case 4: c = *cp++; PUTHEX(c,fd);
2464 case 3: c = *cp++; PUTHEX(c,fd);
2465 case 2: c = *cp++; PUTHEX(c,fd);
2466 case 1: c = *cp++; PUTHEX(c,fd);
2467 }
2468 cp += es;
2469 }
2470 }
2471 }
2472 _TIFFfree((char *) tf_buf);
2473 }
2474
2475 void
2476 PSDataColorSeparate(FILE* fd, TIFF* tif, uint32 w, uint32 h, int nc)
2477 {
2478 uint32 row;
2479 int breaklen = MAXLINE;
2480 tsize_t cc;
2481 tsample_t s, maxs;
2482 unsigned char *tf_buf;
2483 unsigned char *cp, c;
2484
2485 (void) w;
2486 tf_buf = (unsigned char *) _TIFFmalloc(tf_bytesperrow);
2487 if (tf_buf == NULL) {
2488 TIFFError(filename, "No space for scanline buffer");
2489 return;
2490 }
2491 maxs = (samplesperpixel > nc ? nc : samplesperpixel);
2492 for (row = 0; row < h; row++) {
2493 for (s = 0; s < maxs; s++) {
2494 if (TIFFReadScanline(tif, tf_buf, row, s) < 0)
2495 break;
2496 for (cp = tf_buf, cc = 0; cc < tf_bytesperrow; cc++) {
2497 DOBREAK(breaklen, 1, fd);
2498 c = *cp++;
2499 PUTHEX(c,fd);
2500 }
2501 }
2502 }
2503 _TIFFfree((char *) tf_buf);
2504 }
2505
2506 #define PUTRGBHEX(c,fd) \
2507 PUTHEX(rmap[c],fd); PUTHEX(gmap[c],fd); PUTHEX(bmap[c],fd)
2508
2509 void
2510 PSDataPalette(FILE* fd, TIFF* tif, uint32 w, uint32 h)
2511 {
2512 uint16 *rmap, *gmap, *bmap;
2513 uint32 row;
2514 int breaklen = MAXLINE, nc;
2515 tsize_t cc;
2516 unsigned char *tf_buf;
2517 unsigned char *cp, c;
2518
2519 (void) w;
2520 if (!TIFFGetField(tif, TIFFTAG_COLORMAP, &rmap, &gmap, &bmap)) {
2521 TIFFError(filename, "Palette image w/o \"Colormap\" tag");
2522 return;
2523 }
2524 switch (bitspersample) {
2525 case 8: case 4: case 2: case 1:
2526 break;
2527 default:
2528 TIFFError(filename, "Depth %d not supported", bitspersample);
2529 return;
2530 }
2531 nc = 3 * (8 / bitspersample);
2532 tf_buf = (unsigned char *) _TIFFmalloc(tf_bytesperrow);
2533 if (tf_buf == NULL) {
2534 TIFFError(filename, "No space for scanline buffer");
2535 return;
2536 }
2537 if (checkcmap(tif, 1<<bitspersample, rmap, gmap, bmap) == 16) {
2538 int i;
2539 #define CVT(x) ((unsigned short) (((x) * 255) / ((1U<<16)-1)))
2540 for (i = (1<<bitspersample)-1; i >= 0; i--) {
2541 rmap[i] = CVT(rmap[i]);
2542 gmap[i] = CVT(gmap[i]);
2543 bmap[i] = CVT(bmap[i]);
2544 }
2545 #undef CVT
2546 }
2547 for (row = 0; row < h; row++) {
2548 if (TIFFReadScanline(tif, tf_buf, row, 0) < 0)
2549 break;
2550 for (cp = tf_buf, cc = 0; cc < tf_bytesperrow; cc++) {
2551 DOBREAK(breaklen, nc, fd);
2552 switch (bitspersample) {
2553 case 8:
2554 c = *cp++; PUTRGBHEX(c, fd);
2555 break;
2556 case 4:
2557 c = *cp++; PUTRGBHEX(c&0xf, fd);
2558 c >>= 4; PUTRGBHEX(c, fd);
2559 break;
2560 case 2:
2561 c = *cp++; PUTRGBHEX(c&0x3, fd);
2562 c >>= 2; PUTRGBHEX(c&0x3, fd);
2563 c >>= 2; PUTRGBHEX(c&0x3, fd);
2564 c >>= 2; PUTRGBHEX(c, fd);
2565 break;
2566 case 1:
2567 c = *cp++; PUTRGBHEX(c&0x1, fd);
2568 c >>= 1; PUTRGBHEX(c&0x1, fd);
2569 c >>= 1; PUTRGBHEX(c&0x1, fd);
2570 c >>= 1; PUTRGBHEX(c&0x1, fd);
2571 c >>= 1; PUTRGBHEX(c&0x1, fd);
2572 c >>= 1; PUTRGBHEX(c&0x1, fd);
2573 c >>= 1; PUTRGBHEX(c&0x1, fd);
2574 c >>= 1; PUTRGBHEX(c, fd);
2575 break;
2576 }
2577 }
2578 }
2579 _TIFFfree((char *) tf_buf);
2580 }
2581
2582 void
2583 PSDataBW(FILE* fd, TIFF* tif, uint32 w, uint32 h)
2584 {
2585 int breaklen = MAXLINE;
2586 unsigned char* tf_buf;
2587 unsigned char* cp;
2588 tsize_t stripsize = TIFFStripSize(tif);
2589 tstrip_t s;
2590
2591 #if defined( EXP_ASCII85ENCODER )
2592 tsize_t ascii85_l; /* Length, in bytes, of ascii85_p[] data */
2593 uint8 *ascii85_p = 0; /* Holds ASCII85 encoded data */
2594 #endif
2595
2596 (void) w; (void) h;
2597 tf_buf = (unsigned char *) _TIFFmalloc(stripsize);
2598 if (tf_buf == NULL) {
2599 TIFFError(filename, "No space for scanline buffer");
2600 return;
2601 }
2602
2603 // FIXME
2604 memset(tf_buf, 0, stripsize);
2605
2606 #if defined( EXP_ASCII85ENCODER )
2607 if ( ascii85 ) {
2608 /*
2609 * Allocate a buffer to hold the ASCII85 encoded data. Note
2610 * that it is allocated with sufficient room to hold the
2611 * encoded data (5*stripsize/4) plus the EOD marker (+8)
2612 * and formatting line breaks. The line breaks are more
2613 * than taken care of by using 6*stripsize/4 rather than
2614 * 5*stripsize/4.
2615 */
2616
2617 ascii85_p = _TIFFmalloc( (stripsize+(stripsize/2)) + 8 );
2618
2619 if ( !ascii85_p ) {
2620 _TIFFfree( tf_buf );
2621
2622 TIFFError( filename, "Cannot allocate ASCII85 encoding buffer." );
2623 return;
2624 }
2625 }
2626 #endif
2627
2628 if (ascii85)
2629 Ascii85Init();
2630
2631 for (s = 0; s < TIFFNumberOfStrips(tif); s++) {
2632 tmsize_t cc = TIFFReadEncodedStrip(tif, s, tf_buf, stripsize);
2633 if (cc < 0) {
2634 TIFFError(filename, "Can't read strip");
2635 break;
2636 }
2637 cp = tf_buf;
2638 if (photometric == PHOTOMETRIC_MINISWHITE) {
2639 for (cp += cc; --cp >= tf_buf;)
2640 *cp = ~*cp;
2641 cp++;
2642 }
2643 /*
2644 * for 16 bits, the two bytes must be most significant
2645 * byte first
2646 */
2647 if (bitspersample == 16 && !HOST_BIGENDIAN) {
2648 PS_FlipBytes(cp, cc);
2649 }
2650 if (ascii85) {
2651 #if defined( EXP_ASCII85ENCODER )
2652 if (alpha) {
2653 int adjust, i;
2654 for (i = 0; i < cc; i+=2) {
2655 adjust = 255 - cp[i + 1];
2656 cp[i / 2] = cp[i] + adjust;
2657 }
2658 cc /= 2;
2659 }
2660
2661 ascii85_l = Ascii85EncodeBlock( ascii85_p, 1, cp, cc );
2662
2663 if ( ascii85_l > 0 )
2664 fwrite( ascii85_p, ascii85_l, 1, fd );
2665 #else
2666 while (cc-- > 0)
2667 Ascii85Put(*cp++, fd);
2668 #endif /* EXP_ASCII85_ENCODER */
2669 } else {
2670 unsigned char c;
2671
2672 if (alpha) {
2673 int adjust;
2674 while (cc-- > 0) {
2675 DOBREAK(breaklen, 1, fd);
2676 /*
2677 * For images with alpha, matte against
2678 * a white background; i.e.
2679 * Cback * (1 - Aimage)
2680 * where Cback = 1.
2681 */
2682 adjust = 255 - cp[1];
2683 c = *cp++ + adjust; PUTHEX(c,fd);
2684 cp++, cc--;
2685 }
2686 } else {
2687 while (cc-- > 0) {
2688 c = *cp++;
2689 DOBREAK(breaklen, 1, fd);
2690 PUTHEX(c, fd);
2691 }
2692 }
2693 }
2694 }
2695
2696 if ( !ascii85 )
2697 {
2698 if ( level2 || level3)
2699 fputs(">\n", fd);
2700 }
2701 #if !defined( EXP_ASCII85ENCODER )
2702 else
2703 Ascii85Flush(fd);
2704 #else
2705 if ( ascii85_p )
2706 _TIFFfree( ascii85_p );
2707 #endif
2708
2709 _TIFFfree(tf_buf);
2710 }
2711
2712 void
2713 PSRawDataBW(FILE* fd, TIFF* tif, uint32 w, uint32 h)
2714 {
2715 uint64 *bc;
2716 uint32 bufsize;
2717 int breaklen = MAXLINE;
2718 tmsize_t cc;
2719 uint16 fillorder;
2720 unsigned char *tf_buf;
2721 unsigned char *cp, c;
2722 tstrip_t s;
2723
2724 #if defined( EXP_ASCII85ENCODER )
2725 tsize_t ascii85_l; /* Length, in bytes, of ascii85_p[] data */
2726 uint8 * ascii85_p = 0; /* Holds ASCII85 encoded data */
2727 #endif
2728
2729 (void) w; (void) h;
2730 TIFFGetFieldDefaulted(tif, TIFFTAG_FILLORDER, &fillorder);
2731 TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &bc);
2732
2733 /*
2734 * Find largest strip:
2735 */
2736
2737 bufsize = (uint32) bc[0];
2738
2739 for ( s = 0; ++s < (tstrip_t)tf_numberstrips; ) {
2740 if ( bc[s] > bufsize )
2741 bufsize = (uint32) bc[s];
2742 }
2743
2744 tf_buf = (unsigned char*) _TIFFmalloc(bufsize);
2745 if (tf_buf == NULL) {
2746 TIFFError(filename, "No space for strip buffer");
2747 return;
2748 }
2749
2750 #if defined( EXP_ASCII85ENCODER )
2751 if ( ascii85 ) {
2752 /*
2753 * Allocate a buffer to hold the ASCII85 encoded data. Note
2754 * that it is allocated with sufficient room to hold the
2755 * encoded data (5*bufsize/4) plus the EOD marker (+8)
2756 * and formatting line breaks. The line breaks are more
2757 * than taken care of by using 6*bufsize/4 rather than
2758 * 5*bufsize/4.
2759 */
2760
2761 ascii85_p = _TIFFmalloc( (bufsize+(bufsize/2)) + 8 );
2762
2763 if ( !ascii85_p ) {
2764 _TIFFfree( tf_buf );
2765
2766 TIFFError( filename, "Cannot allocate ASCII85 encoding buffer." );
2767 return;
2768 }
2769 }
2770 #endif
2771
2772 for (s = 0; s < (tstrip_t) tf_numberstrips; s++) {
2773 cc = TIFFReadRawStrip(tif, s, tf_buf, (tmsize_t) bc[s]);
2774 if (cc < 0) {
2775 TIFFError(filename, "Can't read strip");
2776 break;
2777 }
2778 if (fillorder == FILLORDER_LSB2MSB)
2779 TIFFReverseBits(tf_buf, cc);
2780 if (!ascii85) {
2781 for (cp = tf_buf; cc > 0; cc--) {
2782 DOBREAK(breaklen, 1, fd);
2783 c = *cp++;
2784 PUTHEX(c, fd);
2785 }
2786 fputs(">\n", fd);
2787 breaklen = MAXLINE;
2788 } else {
2789 Ascii85Init();
2790 #if defined( EXP_ASCII85ENCODER )
2791 ascii85_l = Ascii85EncodeBlock( ascii85_p, 1, tf_buf, cc );
2792
2793 if ( ascii85_l > 0 )
2794 fwrite( ascii85_p, ascii85_l, 1, fd );
2795 #else
2796 for (cp = tf_buf; cc > 0; cc--)
2797 Ascii85Put(*cp++, fd);
2798 Ascii85Flush(fd);
2799 #endif /* EXP_ASCII85ENCODER */
2800 }
2801 }
2802 _TIFFfree((char *) tf_buf);
2803
2804 #if defined( EXP_ASCII85ENCODER )
2805 if ( ascii85_p )
2806 _TIFFfree( ascii85_p );
2807 #endif
2808 }
2809
2810 void
2811 Ascii85Init(void)
2812 {
2813 ascii85breaklen = 2*MAXLINE;
2814 ascii85count = 0;
2815 }
2816
2817 static char*
2818 Ascii85Encode(unsigned char* raw)
2819 {
2820 static char encoded[6];
2821 uint32 word;
2822
2823 word = (((raw[0]<<8)+raw[1])<<16) + (raw[2]<<8) + raw[3];
2824 if (word != 0L) {
2825 uint32 q;
2826 uint16 w1;
2827
2828 q = word / (85L*85*85*85); /* actually only a byte */
2829 encoded[0] = (char) (q + '!');
2830
2831 word -= q * (85L*85*85*85); q = word / (85L*85*85);
2832 encoded[1] = (char) (q + '!');
2833
2834 word -= q * (85L*85*85); q = word / (85*85);
2835 encoded[2] = (char) (q + '!');
2836
2837 w1 = (uint16) (word - q*(85L*85));
2838 encoded[3] = (char) ((w1 / 85) + '!');
2839 encoded[4] = (char) ((w1 % 85) + '!');
2840 encoded[5] = '\0';
2841 } else
2842 encoded[0] = 'z', encoded[1] = '\0';
2843 return (encoded);
2844 }
2845
2846 void
2847 Ascii85Put(unsigned char code, FILE* fd)
2848 {
2849 ascii85buf[ascii85count++] = code;
2850 if (ascii85count >= 4) {
2851 unsigned char* p;
2852 int n;
2853
2854 for (n = ascii85count, p = ascii85buf; n >= 4; n -= 4, p += 4) {
2855 char* cp;
2856 for (cp = Ascii85Encode(p); *cp; cp++) {
2857 putc(*cp, fd);
2858 if (--ascii85breaklen == 0) {
2859 putc('\n', fd);
2860 ascii85breaklen = 2*MAXLINE;
2861 }
2862 }
2863 }
2864 _TIFFmemcpy(ascii85buf, p, n);
2865 ascii85count = n;
2866 }
2867 }
2868
2869 void
2870 Ascii85Flush(FILE* fd)
2871 {
2872 if (ascii85count > 0) {
2873 char* res;
2874 _TIFFmemset(&ascii85buf[ascii85count], 0, 3);
2875 res = Ascii85Encode(ascii85buf);
2876 fwrite(res[0] == 'z' ? "!!!!" : res, ascii85count + 1, 1, fd);
2877 }
2878 fputs("~>\n", fd);
2879 }
2880 #if defined( EXP_ASCII85ENCODER)
2881 \f
2882 #define A85BREAKCNTR ascii85breaklen
2883 #define A85BREAKLEN (2*MAXLINE)
2884
2885 /*****************************************************************************
2886 *
2887 * Name: Ascii85EncodeBlock( ascii85_p, f_eod, raw_p, raw_l )
2888 *
2889 * Description: This routine will encode the raw data in the buffer described
2890 * by raw_p and raw_l into ASCII85 format and store the encoding
2891 * in the buffer given by ascii85_p.
2892 *
2893 * Parameters: ascii85_p - A buffer supplied by the caller which will
2894 * contain the encoded ASCII85 data.
2895 * f_eod - Flag: Nz means to end the encoded buffer with
2896 * an End-Of-Data marker.
2897 * raw_p - Pointer to the buffer of data to be encoded
2898 * raw_l - Number of bytes in raw_p[] to be encoded
2899 *
2900 * Returns: (int) < 0 Error, see errno
2901 * >= 0 Number of bytes written to ascii85_p[].
2902 *
2903 * Notes: An external variable given by A85BREAKCNTR is used to
2904 * determine when to insert newline characters into the
2905 * encoded data. As each byte is placed into ascii85_p this
2906 * external is decremented. If the variable is decrement to
2907 * or past zero then a newline is inserted into ascii85_p
2908 * and the A85BREAKCNTR is then reset to A85BREAKLEN.
2909 * Note: for efficiency reasons the A85BREAKCNTR variable
2910 * is not actually checked on *every* character
2911 * placed into ascii85_p but often only for every
2912 * 5 characters.
2913 *
2914 * THE CALLER IS RESPONSIBLE FOR ENSURING THAT ASCII85_P[] IS
2915 * SUFFICIENTLY LARGE TO THE ENCODED DATA!
2916 * You will need at least 5 * (raw_l/4) bytes plus space for
2917 * newline characters and space for an EOD marker (if
2918 * requested). A safe calculation is to use 6*(raw_l/4) + 8
2919 * to size ascii85_p.
2920 *
2921 *****************************************************************************/
2922
2923 tsize_t Ascii85EncodeBlock( uint8 * ascii85_p, unsigned f_eod, const uint8 * raw_p, tsize_t raw_l )
2924
2925 {
2926 char ascii85[5]; /* Encoded 5 tuple */
2927 tsize_t ascii85_l; /* Number of bytes written to ascii85_p[] */
2928 int rc; /* Return code */
2929 uint32 val32; /* Unencoded 4 tuple */
2930
2931 ascii85_l = 0; /* Nothing written yet */
2932
2933 if ( raw_p )
2934 {
2935 --raw_p; /* Prepare for pre-increment fetches */
2936
2937 for ( ; raw_l > 3; raw_l -= 4 )
2938 {
2939 val32 = *(++raw_p) << 24;
2940 val32 += *(++raw_p) << 16;
2941 val32 += *(++raw_p) << 8;
2942 val32 += *(++raw_p);
2943
2944 if ( val32 == 0 ) /* Special case */
2945 {
2946 ascii85_p[ascii85_l] = 'z';
2947 rc = 1;
2948 }
2949
2950 else
2951 {
2952 ascii85[4] = (char) ((val32 % 85) + 33);
2953 val32 /= 85;
2954
2955 ascii85[3] = (char) ((val32 % 85) + 33);
2956 val32 /= 85;
2957
2958 ascii85[2] = (char) ((val32 % 85) + 33);
2959 val32 /= 85;
2960
2961 ascii85[1] = (char) ((val32 % 85) + 33);
2962 ascii85[0] = (char) ((val32 / 85) + 33);
2963
2964 _TIFFmemcpy( &ascii85_p[ascii85_l], ascii85, sizeof(ascii85) );
2965 rc = sizeof(ascii85);
2966 }
2967
2968 ascii85_l += rc;
2969
2970 if ( (A85BREAKCNTR -= rc) <= 0 )
2971 {
2972 ascii85_p[ascii85_l] = '\n';
2973 ++ascii85_l;
2974 A85BREAKCNTR = A85BREAKLEN;
2975 }
2976 }
2977
2978 /*
2979 * Output any straggler bytes:
2980 */
2981
2982 if ( raw_l > 0 )
2983 {
2984 tsize_t len; /* Output this many bytes */
2985
2986 len = raw_l + 1;
2987 val32 = *++raw_p << 24; /* Prime the pump */
2988
2989 if ( --raw_l > 0 ) val32 += *(++raw_p) << 16;
2990 if ( --raw_l > 0 ) val32 += *(++raw_p) << 8;
2991
2992 val32 /= 85;
2993
2994 ascii85[3] = (char) ((val32 % 85) + 33);
2995 val32 /= 85;
2996
2997 ascii85[2] = (char) ((val32 % 85) + 33);
2998 val32 /= 85;
2999
3000 ascii85[1] = (char) ((val32 % 85) + 33);
3001 ascii85[0] = (char) ((val32 / 85) + 33);
3002
3003 _TIFFmemcpy( &ascii85_p[ascii85_l], ascii85, len );
3004 ascii85_l += len;
3005 }
3006 }
3007
3008 /*
3009 * If requested add an ASCII85 End Of Data marker:
3010 */
3011
3012 if ( f_eod )
3013 {
3014 ascii85_p[ascii85_l++] = '~';
3015 ascii85_p[ascii85_l++] = '>';
3016 ascii85_p[ascii85_l++] = '\n';
3017 }
3018
3019 return ( ascii85_l );
3020
3021 } /* Ascii85EncodeBlock() */
3022
3023 #endif /* EXP_ASCII85ENCODER */
3024
3025
3026 char* stuff[] = {
3027 "usage: tiff2ps [options] input.tif ...",
3028 "where options are:",
3029 " -1 generate PostScript Level 1 (default)",
3030 " -2 generate PostScript Level 2",
3031 " -3 generate PostScript Level 3",
3032 " -8 disable use of ASCII85 encoding with PostScript Level 2/3",
3033 " -a convert all directories in file (default is first), Not EPS",
3034 " -b # set the bottom margin to # inches",
3035 " -c center image (-b and -l still add to this)",
3036 " -d # set initial directory to # counting from zero",
3037 " -D enable duplex printing (two pages per sheet of paper)",
3038 " -e generate Encapsulated PostScript (EPS) (implies -z)",
3039 " -h # set printed page height to # inches (no default)",
3040 " -w # set printed page width to # inches (no default)",
3041 " -H # split image if height is more than # inches",
3042 " -P L or P set optional PageOrientation DSC comment to Landscape or Portrait",
3043 " -W # split image if width is more than # inches",
3044 " -L # overLap split images by # inches",
3045 " -i # enable/disable (Nz/0) pixel interpolation (default: enable)",
3046 " -l # set the left margin to # inches",
3047 " -m use \"imagemask\" operator instead of \"image\"",
3048 " -o # convert directory at file offset # bytes",
3049 " -O file write PostScript to file instead of standard output",
3050 " -p generate regular PostScript",
3051 " -r # or auto rotate by 90, 180, 270 degrees or auto",
3052 " -s generate PostScript for a single image",
3053 " -t name set postscript document title. Otherwise the filename is used",
3054 " -T print pages for top edge binding",
3055 " -x override resolution units as centimeters",
3056 " -y override resolution units as inches",
3057 " -z enable printing in the deadzone (only for PostScript Level 2/3)",
3058 NULL
3059 };
3060
3061 static void
3062 usage(int code)
3063 {
3064 char buf[BUFSIZ];
3065 int i;
3066
3067 setbuf(stderr, buf);
3068 fprintf(stderr, "%s\n\n", TIFFGetVersion());
3069 for (i = 0; stuff[i] != NULL; i++)
3070 fprintf(stderr, "%s\n", stuff[i]);
3071 exit(code);
3072 }
3073
wxWidgets (Impactor)