]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/tools/tiff2pdf.c
projects / wxWidgets.git / blob
? search:


b9a6075afe62888385ca8d39bd79a7486789d10a
[wxWidgets.git] / src / tiff / tools / tiff2pdf.c
1 /* $Id$
2 *
3 * tiff2pdf - converts a TIFF image to a PDF document
4 *
5 * Copyright (c) 2003 Ross Finlayson
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 name of
11 * Ross Finlayson may not be used in any advertising or
12 * publicity relating to the software without the specific, prior written
13 * permission of Ross Finlayson.
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 ROSS FINLAYSON 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>
31 #include <string.h>
32 #include <ctype.h>
33 #include <time.h>
34 #include <errno.h>
35
36 #if HAVE_UNISTD_H
37 # include <unistd.h>
38 #endif
39
40 #ifdef HAVE_FCNTL_H
41 # include <fcntl.h>
42 #endif
43
44 #ifdef HAVE_IO_H
45 # include <io.h>
46 #endif
47
48 #ifdef NEED_LIBPORT
49 # include "libport.h"
50 #endif
51
52 #include "tiffiop.h"
53 #include "tiffio.h"
54
55 #ifndef HAVE_GETOPT
56 extern int getopt(int, char**, char*);
57 #endif
58
59 #ifndef EXIT_SUCCESS
60 # define EXIT_SUCCESS 0
61 #endif
62 #ifndef EXIT_FAILURE
63 # define EXIT_FAILURE 1
64 #endif
65
66 #define TIFF2PDF_MODULE "tiff2pdf"
67
68 #define PS_UNIT_SIZE 72.0F
69
70 /* This type is of PDF color spaces. */
71 typedef enum {
72 T2P_CS_BILEVEL = 0x01, /* Bilevel, black and white */
73 T2P_CS_GRAY = 0x02, /* Single channel */
74 T2P_CS_RGB = 0x04, /* Three channel tristimulus RGB */
75 T2P_CS_CMYK = 0x08, /* Four channel CMYK print inkset */
76 T2P_CS_LAB = 0x10, /* Three channel L*a*b* color space */
77 T2P_CS_PALETTE = 0x1000,/* One of the above with a color map */
78 T2P_CS_CALGRAY = 0x20, /* Calibrated single channel */
79 T2P_CS_CALRGB = 0x40, /* Calibrated three channel tristimulus RGB */
80 T2P_CS_ICCBASED = 0x80 /* ICC profile color specification */
81 } t2p_cs_t;
82
83 /* This type is of PDF compression types. */
84 typedef enum{
85 T2P_COMPRESS_NONE=0x00
86 #ifdef CCITT_SUPPORT
87 , T2P_COMPRESS_G4=0x01
88 #endif
89 #if defined(JPEG_SUPPORT) || defined(OJPEG_SUPPORT)
90 , T2P_COMPRESS_JPEG=0x02
91 #endif
92 #ifdef ZIP_SUPPORT
93 , T2P_COMPRESS_ZIP=0x04
94 #endif
95 } t2p_compress_t;
96
97 /* This type is whether TIFF image data can be used in PDF without transcoding. */
98 typedef enum{
99 T2P_TRANSCODE_RAW=0x01, /* The raw data from the input can be used without recompressing */
100 T2P_TRANSCODE_ENCODE=0x02 /* The data from the input is perhaps unencoded and reencoded */
101 } t2p_transcode_t;
102
103 /* This type is of information about the data samples of the input image. */
104 typedef enum{
105 T2P_SAMPLE_NOTHING=0x0000, /* The unencoded samples are normal for the output colorspace */
106 T2P_SAMPLE_ABGR_TO_RGB=0x0001, /* The unencoded samples are the result of ReadRGBAImage */
107 T2P_SAMPLE_RGBA_TO_RGB=0x0002, /* The unencoded samples are contiguous RGBA */
108 T2P_SAMPLE_RGBAA_TO_RGB=0x0004, /* The unencoded samples are RGBA with premultiplied alpha */
109 T2P_SAMPLE_YCBCR_TO_RGB=0x0008,
110 T2P_SAMPLE_YCBCR_TO_LAB=0x0010,
111 T2P_SAMPLE_REALIZE_PALETTE=0x0020, /* The unencoded samples are indexes into the color map */
112 T2P_SAMPLE_SIGNED_TO_UNSIGNED=0x0040, /* The unencoded samples are signed instead of unsignd */
113 T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED=0x0040, /* The L*a*b* samples have a* and b* signed */
114 T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG=0x0100 /* The unencoded samples are separate instead of contiguous */
115 } t2p_sample_t;
116
117 /* This type is of error status of the T2P struct. */
118 typedef enum{
119 T2P_ERR_OK = 0, /* This is the value of t2p->t2p_error when there is no error */
120 T2P_ERR_ERROR = 1 /* This is the value of t2p->t2p_error when there was an error */
121 } t2p_err_t;
122
123 /* This struct defines a logical page of a TIFF. */
124 typedef struct {
125 tdir_t page_directory;
126 uint32 page_number;
127 ttile_t page_tilecount;
128 uint32 page_extra;
129 } T2P_PAGE;
130
131 /* This struct defines a PDF rectangle's coordinates. */
132 typedef struct {
133 float x1;
134 float y1;
135 float x2;
136 float y2;
137 float mat[9];
138 } T2P_BOX;
139
140 /* This struct defines a tile of a PDF. */
141 typedef struct {
142 T2P_BOX tile_box;
143 } T2P_TILE;
144
145 /* This struct defines information about the tiles on a PDF page. */
146 typedef struct {
147 ttile_t tiles_tilecount;
148 uint32 tiles_tilewidth;
149 uint32 tiles_tilelength;
150 uint32 tiles_tilecountx;
151 uint32 tiles_tilecounty;
152 uint32 tiles_edgetilewidth;
153 uint32 tiles_edgetilelength;
154 T2P_TILE* tiles_tiles;
155 } T2P_TILES;
156
157 /* This struct is the context of a function to generate PDF from a TIFF. */
158 typedef struct {
159 t2p_err_t t2p_error;
160 T2P_PAGE* tiff_pages;
161 T2P_TILES* tiff_tiles;
162 tdir_t tiff_pagecount;
163 uint16 tiff_compression;
164 uint16 tiff_photometric;
165 uint16 tiff_fillorder;
166 uint16 tiff_bitspersample;
167 uint16 tiff_samplesperpixel;
168 uint16 tiff_planar;
169 uint32 tiff_width;
170 uint32 tiff_length;
171 float tiff_xres;
172 float tiff_yres;
173 uint16 tiff_orientation;
174 toff_t tiff_dataoffset;
175 tsize_t tiff_datasize;
176 uint16 tiff_resunit;
177 uint16 pdf_centimeters;
178 uint16 pdf_overrideres;
179 uint16 pdf_overridepagesize;
180 float pdf_defaultxres;
181 float pdf_defaultyres;
182 float pdf_xres;
183 float pdf_yres;
184 float pdf_defaultpagewidth;
185 float pdf_defaultpagelength;
186 float pdf_pagewidth;
187 float pdf_pagelength;
188 float pdf_imagewidth;
189 float pdf_imagelength;
190 int pdf_image_fillpage; /* 0 (default: no scaling, 1:scale imagesize to pagesize */
191 T2P_BOX pdf_mediabox;
192 T2P_BOX pdf_imagebox;
193 uint16 pdf_majorversion;
194 uint16 pdf_minorversion;
195 uint32 pdf_catalog;
196 uint32 pdf_pages;
197 uint32 pdf_info;
198 uint32 pdf_palettecs;
199 uint16 pdf_fitwindow;
200 uint32 pdf_startxref;
201 #define TIFF2PDF_FILEID_SIZE 33
202 char pdf_fileid[TIFF2PDF_FILEID_SIZE];
203 #define TIFF2PDF_DATETIME_SIZE 17
204 char pdf_datetime[TIFF2PDF_DATETIME_SIZE];
205 #define TIFF2PDF_CREATOR_SIZE 512
206 char pdf_creator[TIFF2PDF_CREATOR_SIZE];
207 #define TIFF2PDF_AUTHOR_SIZE 512
208 char pdf_author[TIFF2PDF_AUTHOR_SIZE];
209 #define TIFF2PDF_TITLE_SIZE 512
210 char pdf_title[TIFF2PDF_TITLE_SIZE];
211 #define TIFF2PDF_SUBJECT_SIZE 512
212 char pdf_subject[TIFF2PDF_SUBJECT_SIZE];
213 #define TIFF2PDF_KEYWORDS_SIZE 512
214 char pdf_keywords[TIFF2PDF_KEYWORDS_SIZE];
215 t2p_cs_t pdf_colorspace;
216 uint16 pdf_colorspace_invert;
217 uint16 pdf_switchdecode;
218 uint16 pdf_palettesize;
219 unsigned char* pdf_palette;
220 int pdf_labrange[4];
221 t2p_compress_t pdf_defaultcompression;
222 uint16 pdf_defaultcompressionquality;
223 t2p_compress_t pdf_compression;
224 uint16 pdf_compressionquality;
225 uint16 pdf_nopassthrough;
226 t2p_transcode_t pdf_transcode;
227 t2p_sample_t pdf_sample;
228 uint32* pdf_xrefoffsets;
229 uint32 pdf_xrefcount;
230 tdir_t pdf_page;
231 #ifdef OJPEG_SUPPORT
232 tdata_t pdf_ojpegdata;
233 uint32 pdf_ojpegdatalength;
234 uint32 pdf_ojpegiflength;
235 #endif
236 float tiff_whitechromaticities[2];
237 float tiff_primarychromaticities[6];
238 float tiff_referenceblackwhite[2];
239 float* tiff_transferfunction[3];
240 int pdf_image_interpolate; /* 0 (default) : do not interpolate,
241 1 : interpolate */
242 uint16 tiff_transferfunctioncount;
243 uint32 pdf_icccs;
244 uint32 tiff_iccprofilelength;
245 tdata_t tiff_iccprofile;
246
247 /* fields for custom read/write procedures */
248 FILE *outputfile;
249 int outputdisable;
250 tsize_t outputwritten;
251 } T2P;
252
253 /* These functions are called by main. */
254
255 void tiff2pdf_usage(void);
256 int tiff2pdf_match_paper_size(float*, float*, char*);
257
258 /* These functions are used to generate a PDF from a TIFF. */
259
260 #ifdef __cplusplus
261 extern "C" {
262 #endif
263
264 T2P* t2p_init(void);
265 void t2p_validate(T2P*);
266 tsize_t t2p_write_pdf(T2P*, TIFF*, TIFF*);
267 void t2p_free(T2P*);
268
269 #ifdef __cplusplus
270 }
271 #endif
272
273 void t2p_read_tiff_init(T2P*, TIFF*);
274 int t2p_cmp_t2p_page(const void*, const void*);
275 void t2p_read_tiff_data(T2P*, TIFF*);
276 void t2p_read_tiff_size(T2P*, TIFF*);
277 void t2p_read_tiff_size_tile(T2P*, TIFF*, ttile_t);
278 int t2p_tile_is_right_edge(T2P_TILES, ttile_t);
279 int t2p_tile_is_bottom_edge(T2P_TILES, ttile_t);
280 int t2p_tile_is_edge(T2P_TILES, ttile_t);
281 int t2p_tile_is_corner_edge(T2P_TILES, ttile_t);
282 tsize_t t2p_readwrite_pdf_image(T2P*, TIFF*, TIFF*);
283 tsize_t t2p_readwrite_pdf_image_tile(T2P*, TIFF*, TIFF*, ttile_t);
284 #ifdef OJPEG_SUPPORT
285 int t2p_process_ojpeg_tables(T2P*, TIFF*);
286 #endif
287 #ifdef JPEG_SUPPORT
288 int t2p_process_jpeg_strip(unsigned char*, tsize_t*, unsigned char*, tsize_t*, tstrip_t, uint32);
289 #endif
290 void t2p_tile_collapse_left(tdata_t, tsize_t, uint32, uint32, uint32);
291 void t2p_write_advance_directory(T2P*, TIFF*);
292 tsize_t t2p_sample_planar_separate_to_contig(T2P*, unsigned char*, unsigned char*, tsize_t);
293 tsize_t t2p_sample_realize_palette(T2P*, unsigned char*);
294 tsize_t t2p_sample_abgr_to_rgb(tdata_t, uint32);
295 tsize_t t2p_sample_rgba_to_rgb(tdata_t, uint32);
296 tsize_t t2p_sample_rgbaa_to_rgb(tdata_t, uint32);
297 tsize_t t2p_sample_lab_signed_to_unsigned(tdata_t, uint32);
298 tsize_t t2p_write_pdf_header(T2P*, TIFF*);
299 tsize_t t2p_write_pdf_obj_start(uint32, TIFF*);
300 tsize_t t2p_write_pdf_obj_end(TIFF*);
301 tsize_t t2p_write_pdf_name(unsigned char*, TIFF*);
302 tsize_t t2p_write_pdf_string(char*, TIFF*);
303 tsize_t t2p_write_pdf_stream(tdata_t, tsize_t, TIFF*);
304 tsize_t t2p_write_pdf_stream_start(TIFF*);
305 tsize_t t2p_write_pdf_stream_end(TIFF*);
306 tsize_t t2p_write_pdf_stream_dict(tsize_t, uint32, TIFF*);
307 tsize_t t2p_write_pdf_stream_dict_start(TIFF*);
308 tsize_t t2p_write_pdf_stream_dict_end(TIFF*);
309 tsize_t t2p_write_pdf_stream_length(tsize_t, TIFF*);
310 tsize_t t2p_write_pdf_catalog(T2P*, TIFF*);
311 tsize_t t2p_write_pdf_info(T2P*, TIFF*, TIFF*);
312 void t2p_pdf_currenttime(T2P*);
313 void t2p_pdf_tifftime(T2P*, TIFF*);
314 tsize_t t2p_write_pdf_pages(T2P*, TIFF*);
315 tsize_t t2p_write_pdf_page(uint32, T2P*, TIFF*);
316 void t2p_compose_pdf_page(T2P*);
317 void t2p_compose_pdf_page_orient(T2P_BOX*, uint16);
318 void t2p_compose_pdf_page_orient_flip(T2P_BOX*, uint16);
319 tsize_t t2p_write_pdf_page_content(T2P*, TIFF*);
320 tsize_t t2p_write_pdf_xobject_stream_dict(ttile_t, T2P*, TIFF*);
321 tsize_t t2p_write_pdf_xobject_cs(T2P*, TIFF*);
322 tsize_t t2p_write_pdf_transfer(T2P*, TIFF*);
323 tsize_t t2p_write_pdf_transfer_dict(T2P*, TIFF*, uint16);
324 tsize_t t2p_write_pdf_transfer_stream(T2P*, TIFF*, uint16);
325 tsize_t t2p_write_pdf_xobject_calcs(T2P*, TIFF*);
326 tsize_t t2p_write_pdf_xobject_icccs(T2P*, TIFF*);
327 tsize_t t2p_write_pdf_xobject_icccs_dict(T2P*, TIFF*);
328 tsize_t t2p_write_pdf_xobject_icccs_stream(T2P*, TIFF*);
329 tsize_t t2p_write_pdf_xobject_cs_stream(T2P*, TIFF*);
330 tsize_t t2p_write_pdf_xobject_decode(T2P*, TIFF*);
331 tsize_t t2p_write_pdf_xobject_stream_filter(ttile_t, T2P*, TIFF*);
332 tsize_t t2p_write_pdf_xreftable(T2P*, TIFF*);
333 tsize_t t2p_write_pdf_trailer(T2P*, TIFF*);
334
335 static void
336 t2p_disable(TIFF *tif)
337 {
338 T2P *t2p = (T2P*) TIFFClientdata(tif);
339 t2p->outputdisable = 1;
340 }
341
342 static void
343 t2p_enable(TIFF *tif)
344 {
345 T2P *t2p = (T2P*) TIFFClientdata(tif);
346 t2p->outputdisable = 0;
347 }
348
349 /*
350 * Procs for TIFFClientOpen
351 */
352
353 static tmsize_t
354 t2pReadFile(TIFF *tif, tdata_t data, tmsize_t size)
355 {
356 thandle_t client = TIFFClientdata(tif);
357 TIFFReadWriteProc proc = TIFFGetReadProc(tif);
358 if (proc)
359 return proc(client, data, size);
360 return -1;
361 }
362
363 static tmsize_t
364 t2pWriteFile(TIFF *tif, tdata_t data, tmsize_t size)
365 {
366 thandle_t client = TIFFClientdata(tif);
367 TIFFReadWriteProc proc = TIFFGetWriteProc(tif);
368 if (proc)
369 return proc(client, data, size);
370 return -1;
371 }
372
373 static uint64
374 t2pSeekFile(TIFF *tif, toff_t offset, int whence)
375 {
376 thandle_t client = TIFFClientdata(tif);
377 TIFFSeekProc proc = TIFFGetSeekProc(tif);
378 if (proc)
379 return proc(client, offset, whence);
380 return -1;
381 }
382
383 static tmsize_t
384 t2p_readproc(thandle_t handle, tdata_t data, tmsize_t size)
385 {
386 (void) handle, (void) data, (void) size;
387 return -1;
388 }
389
390 static tmsize_t
391 t2p_writeproc(thandle_t handle, tdata_t data, tmsize_t size)
392 {
393 T2P *t2p = (T2P*) handle;
394 if (t2p->outputdisable <= 0 && t2p->outputfile) {
395 tsize_t written = fwrite(data, 1, size, t2p->outputfile);
396 t2p->outputwritten += written;
397 return written;
398 }
399 return size;
400 }
401
402 static uint64
403 t2p_seekproc(thandle_t handle, uint64 offset, int whence)
404 {
405 T2P *t2p = (T2P*) handle;
406 if (t2p->outputdisable <= 0 && t2p->outputfile)
407 return fseek(t2p->outputfile, (long) offset, whence);
408 return offset;
409 }
410
411 static int
412 t2p_closeproc(thandle_t handle)
413 {
414 (void) handle;
415 return 0;
416 }
417
418 static uint64
419 t2p_sizeproc(thandle_t handle)
420 {
421 (void) handle;
422 return -1;
423 }
424
425 static int
426 t2p_mapproc(thandle_t handle, void **data, toff_t *offset)
427 {
428 (void) handle, (void) data, (void) offset;
429 return -1;
430 }
431
432 static void
433 t2p_unmapproc(thandle_t handle, void *data, toff_t offset)
434 {
435 (void) handle, (void) data, (void) offset;
436 }
437
438 static uint64
439 checkAdd64(uint64 summand1, uint64 summand2, T2P* t2p)
440 {
441 uint64 bytes = summand1 + summand2;
442
443 if (bytes - summand1 != summand2) {
444 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
445 t2p->t2p_error = T2P_ERR_ERROR;
446 bytes = 0;
447 }
448
449 return bytes;
450 }
451
452 static uint64
453 checkMultiply64(uint64 first, uint64 second, T2P* t2p)
454 {
455 uint64 bytes = first * second;
456
457 if (second && bytes / second != first) {
458 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
459 t2p->t2p_error = T2P_ERR_ERROR;
460 bytes = 0;
461 }
462
463 return bytes;
464 }
465
466 /*
467
468 This is the main function.
469
470 The program converts one TIFF file to one PDF file, including multiple page
471 TIFF files, tiled TIFF files, black and white. grayscale, and color TIFF
472 files that contain data of TIFF photometric interpretations of bilevel,
473 grayscale, RGB, YCbCr, CMYK separation, and ICC L*a*b* as supported by
474 libtiff and PDF.
475
476 If you have multiple TIFF files to convert into one PDF file then use tiffcp
477 or other program to concatenate the files into a multiple page TIFF file.
478 If the input TIFF file is of huge dimensions (greater than 10000 pixels height
479 or width) convert the input image to a tiled TIFF if it is not already.
480
481 The standard output is standard output. Set the output file name with the
482 "-o output.pdf" option.
483
484 All black and white files are compressed into a single strip CCITT G4 Fax
485 compressed PDF, unless tiled, where tiled black and white images are
486 compressed into tiled CCITT G4 Fax compressed PDF, libtiff CCITT support
487 is assumed.
488
489 Color and grayscale data can be compressed using either JPEG compression,
490 ITU-T T.81, or Zip/Deflate LZ77 compression, per PNG 1.2 and RFC 1951. Set
491 the compression type using the -j or -z options. JPEG compression support
492 requires that libtiff be configured with JPEG support, and Zip/Deflate
493 compression support requires that libtiff is configured with Zip support,
494 in tiffconf.h. Use only one or the other of -j and -z. The -q option
495 sets the image compression quality, that is 1-100 with libjpeg JPEG
496 compression and one of 1, 10, 11, 12, 13, 14, or 15 for PNG group compression
497 predictor methods, add 100, 200, ..., 900 to set zlib compression quality 1-9.
498 PNG Group differencing predictor methods are not currently implemented.
499
500 If the input TIFF contains single strip CCITT G4 Fax compressed information,
501 then that is written to the PDF file without transcoding, unless the options
502 of no compression and no passthrough are set, -d and -n.
503
504 If the input TIFF contains JPEG or single strip Zip/Deflate compressed
505 information, and they are configured, then that is written to the PDF file
506 without transcoding, unless the options of no compression and no passthrough
507 are set.
508
509 The default page size upon which the TIFF image is placed is determined by
510 the resolution and extent of the image data. Default values for the TIFF
511 image resolution can be set using the -x and -y options. The page size can
512 be set using the -p option for paper size, or -w and -l for paper width and
513 length, then each page of the TIFF image is centered on its page. The
514 distance unit for default resolution and page width and length can be set
515 by the -u option, the default unit is inch.
516
517 Various items of the output document information can be set with the -e, -c,
518 -a, -t, -s, and -k tags. Setting the argument of the option to "" for these
519 tags causes the relevant document information field to be not written. Some
520 of the document information values otherwise get their information from the
521 input TIFF image, the software, author, document name, and image description.
522
523 The output PDF file conforms to the PDF 1.1 specification or PDF 1.2 if using
524 Zip/Deflate compression.
525
526 The Portable Document Format (PDF) specification is copyrighted by Adobe
527 Systems, Incorporated. Todos derechos reservados.
528
529 Here is a listing of the usage example and the options to the tiff2pdf
530 program that is part of the libtiff distribution. Options followed by
531 a colon have a required argument.
532
533 usage: tiff2pdf [options] input.tif
534
535 options:
536 -o: output to file name
537
538 -j: compress with JPEG (requires libjpeg configured with libtiff)
539 -z: compress with Zip/Deflate (requires zlib configured with libtiff)
540 -q: compression quality
541 -n: no compressed data passthrough
542 -d: do not compress (decompress)
543 -i: invert colors
544 -u: set distance unit, 'i' for inch, 'm' for centimeter
545 -x: set x resolution default
546 -y: set y resolution default
547 -w: width in units
548 -l: length in units
549 -r: 'd' for resolution default, 'o' for resolution override
550 -p: paper size, eg "letter", "legal", "a4"
551 -F: make the tiff fill the PDF page
552 -f: set pdf "fit window" user preference
553 -b: set PDF "Interpolate" user preference
554 -e: date, overrides image or current date/time default, YYYYMMDDHHMMSS
555 -c: creator, overrides image software default
556 -a: author, overrides image artist default
557 -t: title, overrides image document name default
558 -s: subject, overrides image image description default
559 -k: keywords
560
561 -h: usage
562
563 examples:
564
565 tiff2pdf -o output.pdf input.tiff
566
567 The above example would generate the file output.pdf from input.tiff.
568
569 tiff2pdf input.tiff
570
571 The above example would generate PDF output from input.tiff and write it
572 to standard output.
573
574 tiff2pdf -j -p letter -o output.pdf input.tiff
575
576 The above example would generate the file output.pdf from input.tiff,
577 putting the image pages on a letter sized page, compressing the output
578 with JPEG.
579
580 Please report bugs through:
581
582 http://bugzilla.remotesensing.org/buglist.cgi?product=libtiff
583
584 See also libtiff.3t, tiffcp.
585 */
586
587 int main(int argc, char** argv){
588
589 extern char *optarg;
590 extern int optind;
591 const char *outfilename = NULL;
592 T2P *t2p = NULL;
593 TIFF *input = NULL, *output = NULL;
594 int c, ret = EXIT_SUCCESS;
595
596 t2p = t2p_init();
597
598 if (t2p == NULL){
599 TIFFError(TIFF2PDF_MODULE, "Can't initialize context");
600 goto fail;
601 }
602
603 while (argv &&
604 (c = getopt(argc, argv,
605 "o:q:u:x:y:w:l:r:p:e:c:a:t:s:k:jzndifbhF")) != -1){
606 switch (c) {
607 case 'o':
608 outfilename = optarg;
609 break;
610 #ifdef JPEG_SUPPORT
611 case 'j':
612 t2p->pdf_defaultcompression=T2P_COMPRESS_JPEG;
613 break;
614 #endif
615 #ifndef JPEG_SUPPORT
616 case 'j':
617 TIFFWarning(
618 TIFF2PDF_MODULE,
619 "JPEG support in libtiff required for JPEG compression, ignoring option");
620 break;
621 #endif
622 #ifdef ZIP_SUPPORT
623 case 'z':
624 t2p->pdf_defaultcompression=T2P_COMPRESS_ZIP;
625 break;
626 #endif
627 #ifndef ZIP_SUPPORT
628 case 'z':
629 TIFFWarning(
630 TIFF2PDF_MODULE,
631 "Zip support in libtiff required for Zip compression, ignoring option");
632 break;
633 #endif
634 case 'q':
635 t2p->pdf_defaultcompressionquality=atoi(optarg);
636 break;
637 case 'n':
638 t2p->pdf_nopassthrough=1;
639 break;
640 case 'd':
641 t2p->pdf_defaultcompression=T2P_COMPRESS_NONE;
642 break;
643 case 'u':
644 if(optarg[0]=='m'){
645 t2p->pdf_centimeters=1;
646 }
647 break;
648 case 'x':
649 t2p->pdf_defaultxres =
650 (float)atof(optarg) / (t2p->pdf_centimeters?2.54F:1.0F);
651 break;
652 case 'y':
653 t2p->pdf_defaultyres =
654 (float)atof(optarg) / (t2p->pdf_centimeters?2.54F:1.0F);
655 break;
656 case 'w':
657 t2p->pdf_overridepagesize=1;
658 t2p->pdf_defaultpagewidth =
659 ((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);
660 break;
661 case 'l':
662 t2p->pdf_overridepagesize=1;
663 t2p->pdf_defaultpagelength =
664 ((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);
665 break;
666 case 'r':
667 if(optarg[0]=='o'){
668 t2p->pdf_overrideres=1;
669 }
670 break;
671 case 'p':
672 if(tiff2pdf_match_paper_size(
673 &(t2p->pdf_defaultpagewidth),
674 &(t2p->pdf_defaultpagelength),
675 optarg)){
676 t2p->pdf_overridepagesize=1;
677 } else {
678 TIFFWarning(TIFF2PDF_MODULE,
679 "Unknown paper size %s, ignoring option",
680 optarg);
681 }
682 break;
683 case 'i':
684 t2p->pdf_colorspace_invert=1;
685 break;
686 case 'F':
687 t2p->pdf_image_fillpage = 1;
688 break;
689 case 'f':
690 t2p->pdf_fitwindow=1;
691 break;
692 case 'e':
693 if (strlen(optarg) == 0) {
694 t2p->pdf_datetime[0] = '\0';
695 } else {
696 t2p->pdf_datetime[0] = 'D';
697 t2p->pdf_datetime[1] = ':';
698 strncpy(t2p->pdf_datetime + 2, optarg,
699 sizeof(t2p->pdf_datetime) - 3);
700 t2p->pdf_datetime[sizeof(t2p->pdf_datetime) - 1] = '\0';
701 }
702 break;
703 case 'c':
704 strncpy(t2p->pdf_creator, optarg, sizeof(t2p->pdf_creator) - 1);
705 t2p->pdf_creator[sizeof(t2p->pdf_creator) - 1] = '\0';
706 break;
707 case 'a':
708 strncpy(t2p->pdf_author, optarg, sizeof(t2p->pdf_author) - 1);
709 t2p->pdf_author[sizeof(t2p->pdf_author) - 1] = '\0';
710 break;
711 case 't':
712 strncpy(t2p->pdf_title, optarg, sizeof(t2p->pdf_title) - 1);
713 t2p->pdf_title[sizeof(t2p->pdf_title) - 1] = '\0';
714 break;
715 case 's':
716 strncpy(t2p->pdf_subject, optarg, sizeof(t2p->pdf_subject) - 1);
717 t2p->pdf_subject[sizeof(t2p->pdf_subject) - 1] = '\0';
718 break;
719 case 'k':
720 strncpy(t2p->pdf_keywords, optarg, sizeof(t2p->pdf_keywords) - 1);
721 t2p->pdf_keywords[sizeof(t2p->pdf_keywords) - 1] = '\0';
722 break;
723 case 'b':
724 t2p->pdf_image_interpolate = 1;
725 break;
726 case 'h':
727 case '?':
728 tiff2pdf_usage();
729 goto success;
730 break;
731 }
732 }
733
734 /*
735 * Input
736 */
737 if(argc > optind) {
738 input = TIFFOpen(argv[optind++], "r");
739 if (input==NULL) {
740 TIFFError(TIFF2PDF_MODULE,
741 "Can't open input file %s for reading",
742 argv[optind-1]);
743 goto fail;
744 }
745 } else {
746 TIFFError(TIFF2PDF_MODULE, "No input file specified");
747 tiff2pdf_usage();
748 goto fail;
749 }
750
751 if(argc > optind) {
752 TIFFError(TIFF2PDF_MODULE,
753 "No support for multiple input files");
754 tiff2pdf_usage();
755 goto fail;
756 }
757
758 /*
759 * Output
760 */
761 t2p->outputdisable = 0;
762 if (outfilename) {
763 t2p->outputfile = fopen(outfilename, "wb");
764 if (t2p->outputfile == NULL) {
765 TIFFError(TIFF2PDF_MODULE,
766 "Can't open output file %s for writing",
767 outfilename);
768 goto fail;
769 }
770 } else {
771 outfilename = "-";
772 t2p->outputfile = stdout;
773 }
774
775 output = TIFFClientOpen(outfilename, "w", (thandle_t) t2p,
776 t2p_readproc, t2p_writeproc, t2p_seekproc,
777 t2p_closeproc, t2p_sizeproc,
778 t2p_mapproc, t2p_unmapproc);
779 if (output == NULL) {
780 TIFFError(TIFF2PDF_MODULE,
781 "Can't initialize output descriptor");
782 goto fail;
783 }
784
785 /*
786 * Validate
787 */
788 t2p_validate(t2p);
789 t2pSeekFile(output, (toff_t) 0, SEEK_SET);
790
791 /*
792 * Write
793 */
794 t2p_write_pdf(t2p, input, output);
795 if (t2p->t2p_error != 0) {
796 TIFFError(TIFF2PDF_MODULE,
797 "An error occurred creating output PDF file");
798 goto fail;
799 }
800
801 goto success;
802 fail:
803 ret = EXIT_FAILURE;
804 success:
805 if(input != NULL)
806 TIFFClose(input);
807 if (output != NULL)
808 TIFFClose(output);
809 if (t2p != NULL)
810 t2p_free(t2p);
811 return ret;
812
813 }
814
815 void tiff2pdf_usage(){
816 char* lines[]={
817 "usage: tiff2pdf [options] input.tiff",
818 "options:",
819 " -o: output to file name",
820 #ifdef JPEG_SUPPORT
821 " -j: compress with JPEG",
822 #endif
823 #ifdef ZIP_SUPPORT
824 " -z: compress with Zip/Deflate",
825 #endif
826 " -q: compression quality",
827 " -n: no compressed data passthrough",
828 " -d: do not compress (decompress)",
829 " -i: invert colors",
830 " -u: set distance unit, 'i' for inch, 'm' for centimeter",
831 " -x: set x resolution default in dots per unit",
832 " -y: set y resolution default in dots per unit",
833 " -w: width in units",
834 " -l: length in units",
835 " -r: 'd' for resolution default, 'o' for resolution override",
836 " -p: paper size, eg \"letter\", \"legal\", \"A4\"",
837 " -F: make the tiff fill the PDF page",
838 " -f: set PDF \"Fit Window\" user preference",
839 " -e: date, overrides image or current date/time default, YYYYMMDDHHMMSS",
840 " -c: sets document creator, overrides image software default",
841 " -a: sets document author, overrides image artist default",
842 " -t: sets document title, overrides image document name default",
843 " -s: sets document subject, overrides image image description default",
844 " -k: sets document keywords",
845 " -b: set PDF \"Interpolate\" user preference",
846 " -h: usage",
847 NULL
848 };
849 int i=0;
850
851 fprintf(stderr, "%s\n\n", TIFFGetVersion());
852 for (i=0;lines[i]!=NULL;i++){
853 fprintf(stderr, "%s\n", lines[i]);
854 }
855
856 return;
857 }
858
859 int tiff2pdf_match_paper_size(float* width, float* length, char* papersize){
860
861 size_t i, len;
862 const char* sizes[]={
863 "LETTER", "A4", "LEGAL",
864 "EXECUTIVE", "LETTER", "LEGAL", "LEDGER", "TABLOID",
865 "A", "B", "C", "D", "E", "F", "G", "H", "J", "K",
866 "A10", "A9", "A8", "A7", "A6", "A5", "A4", "A3", "A2", "A1", "A0",
867 "2A0", "4A0", "2A", "4A",
868 "B10", "B9", "B8", "B7", "B6", "B5", "B4", "B3", "B2", "B1", "B0",
869 "JISB10", "JISB9", "JISB8", "JISB7", "JISB6", "JISB5", "JISB4",
870 "JISB3", "JISB2", "JISB1", "JISB0",
871 "C10", "C9", "C8", "C7", "C6", "C5", "C4", "C3", "C2", "C1", "C0",
872 "RA2", "RA1", "RA0", "SRA4", "SRA3", "SRA2", "SRA1", "SRA0",
873 "A3EXTRA", "A4EXTRA",
874 "STATEMENT", "FOLIO", "QUARTO",
875 NULL
876 } ;
877 const int widths[]={
878 612, 595, 612,
879 522, 612,612,792,792,
880 612,792,1224,1584,2448,2016,792,2016,2448,2880,
881 74,105,147,210,298,420,595,842,1191,1684,2384,3370,4768,3370,4768,
882 88,125,176,249,354,499,709,1001,1417,2004,2835,
883 91,128,181,258,363,516,729,1032,1460,2064,2920,
884 79,113,162,230,323,459,649,918,1298,1298,2599,
885 1219,1729,2438,638,907,1276,1814,2551,
886 914,667,
887 396, 612, 609,
888 0
889 };
890 const int lengths[]={
891 792,842,1008,
892 756,792,1008,1224,1224,
893 792,1224,1584,2448,3168,2880,6480,10296,12672,10296,
894 105,147,210,298,420,595,842,1191,1684,2384,3370,4768,6741,4768,6741,
895 125,176,249,354,499,709,1001,1417,2004,2835,4008,
896 128,181,258,363,516,729,1032,1460,2064,2920,4127,
897 113,162,230,323,459,649,918,1298,1837,1837,3677,
898 1729,2438,3458,907,1276,1814,2551,3628,
899 1262,914,
900 612, 936, 780,
901 0
902 };
903
904 len=strlen(papersize);
905 for(i=0;i<len;i++){
906 papersize[i]=toupper(papersize[i]);
907 }
908 for(i=0;sizes[i]!=NULL; i++){
909 if (strcmp( (const char*)papersize, sizes[i])==0){
910 *width=(float)widths[i];
911 *length=(float)lengths[i];
912 return(1);
913 }
914 }
915
916 return(0);
917 }
918
919 /*
920 * This function allocates and initializes a T2P context struct pointer.
921 */
922
923 T2P* t2p_init()
924 {
925 T2P* t2p = (T2P*) _TIFFmalloc(sizeof(T2P));
926 if(t2p==NULL){
927 TIFFError(
928 TIFF2PDF_MODULE,
929 "Can't allocate %lu bytes of memory for t2p_init",
930 (unsigned long) sizeof(T2P));
931 return( (T2P*) NULL );
932 }
933 _TIFFmemset(t2p, 0x00, sizeof(T2P));
934 t2p->pdf_majorversion=1;
935 t2p->pdf_minorversion=1;
936 t2p->pdf_defaultxres=300.0;
937 t2p->pdf_defaultyres=300.0;
938 t2p->pdf_defaultpagewidth=612.0;
939 t2p->pdf_defaultpagelength=792.0;
940 t2p->pdf_xrefcount=3; /* Catalog, Info, Pages */
941
942 return(t2p);
943 }
944
945 /*
946 * This function frees a T2P context struct pointer and any allocated data fields of it.
947 */
948
949 void t2p_free(T2P* t2p)
950 {
951 int i = 0;
952
953 if (t2p != NULL) {
954 if(t2p->pdf_xrefoffsets != NULL){
955 _TIFFfree( (tdata_t) t2p->pdf_xrefoffsets);
956 }
957 if(t2p->tiff_pages != NULL){
958 _TIFFfree( (tdata_t) t2p->tiff_pages);
959 }
960 for(i=0;i<t2p->tiff_pagecount;i++){
961 if(t2p->tiff_tiles[i].tiles_tiles != NULL){
962 _TIFFfree( (tdata_t) t2p->tiff_tiles[i].tiles_tiles);
963 }
964 }
965 if(t2p->tiff_tiles != NULL){
966 _TIFFfree( (tdata_t) t2p->tiff_tiles);
967 }
968 if(t2p->pdf_palette != NULL){
969 _TIFFfree( (tdata_t) t2p->pdf_palette);
970 }
971 #ifdef OJPEG_SUPPORT
972 if(t2p->pdf_ojpegdata != NULL){
973 _TIFFfree( (tdata_t) t2p->pdf_ojpegdata);
974 }
975 #endif
976 _TIFFfree( (tdata_t) t2p );
977 }
978
979 return;
980 }
981
982 /*
983 This function validates the values of a T2P context struct pointer
984 before calling t2p_write_pdf with it.
985 */
986
987 void t2p_validate(T2P* t2p){
988
989 #ifdef JPEG_SUPPORT
990 if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
991 if(t2p->pdf_defaultcompressionquality>100 ||
992 t2p->pdf_defaultcompressionquality<1){
993 t2p->pdf_defaultcompressionquality=0;
994 }
995 }
996 #endif
997 #ifdef ZIP_SUPPORT
998 if(t2p->pdf_defaultcompression==T2P_COMPRESS_ZIP){
999 uint16 m=t2p->pdf_defaultcompressionquality%100;
1000 if(t2p->pdf_defaultcompressionquality/100 > 9 ||
1001 (m>1 && m<10) || m>15){
1002 t2p->pdf_defaultcompressionquality=0;
1003 }
1004 if(t2p->pdf_defaultcompressionquality%100 !=0){
1005 t2p->pdf_defaultcompressionquality/=100;
1006 t2p->pdf_defaultcompressionquality*=100;
1007 TIFFError(
1008 TIFF2PDF_MODULE,
1009 "PNG Group predictor differencing not implemented, assuming compression quality %u",
1010 t2p->pdf_defaultcompressionquality);
1011 }
1012 t2p->pdf_defaultcompressionquality%=100;
1013 if(t2p->pdf_minorversion<2){t2p->pdf_minorversion=2;}
1014 }
1015 #endif
1016 (void)0;
1017
1018 return;
1019 }
1020
1021
1022 /*
1023 This function scans the input TIFF file for pages. It attempts
1024 to determine which IFD's of the TIFF file contain image document
1025 pages. For each, it gathers some information that has to do
1026 with the output of the PDF document as a whole.
1027 */
1028
1029 void t2p_read_tiff_init(T2P* t2p, TIFF* input){
1030
1031 tdir_t directorycount=0;
1032 tdir_t i=0;
1033 uint16 pagen=0;
1034 uint16 paged=0;
1035 uint16 xuint16=0;
1036
1037 directorycount=TIFFNumberOfDirectories(input);
1038 t2p->tiff_pages = (T2P_PAGE*) _TIFFmalloc(directorycount * sizeof(T2P_PAGE));
1039 if(t2p->tiff_pages==NULL){
1040 TIFFError(
1041 TIFF2PDF_MODULE,
1042 "Can't allocate %lu bytes of memory for tiff_pages array, %s",
1043 (unsigned long) directorycount * sizeof(T2P_PAGE),
1044 TIFFFileName(input));
1045 t2p->t2p_error = T2P_ERR_ERROR;
1046 return;
1047 }
1048 _TIFFmemset( t2p->tiff_pages, 0x00, directorycount * sizeof(T2P_PAGE));
1049 t2p->tiff_tiles = (T2P_TILES*) _TIFFmalloc(directorycount * sizeof(T2P_TILES));
1050 if(t2p->tiff_tiles==NULL){
1051 TIFFError(
1052 TIFF2PDF_MODULE,
1053 "Can't allocate %lu bytes of memory for tiff_tiles array, %s",
1054 (unsigned long) directorycount * sizeof(T2P_TILES),
1055 TIFFFileName(input));
1056 t2p->t2p_error = T2P_ERR_ERROR;
1057 return;
1058 }
1059 _TIFFmemset( t2p->tiff_tiles, 0x00, directorycount * sizeof(T2P_TILES));
1060 for(i=0;i<directorycount;i++){
1061 uint32 subfiletype = 0;
1062
1063 if(!TIFFSetDirectory(input, i)){
1064 TIFFError(
1065 TIFF2PDF_MODULE,
1066 "Can't set directory %u of input file %s",
1067 i,
1068 TIFFFileName(input));
1069 t2p->t2p_error = T2P_ERR_ERROR;
1070 return;
1071 }
1072 if(TIFFGetField(input, TIFFTAG_PAGENUMBER, &pagen, &paged)){
1073 if((pagen>paged) && (paged != 0)){
1074 t2p->tiff_pages[t2p->tiff_pagecount].page_number =
1075 paged;
1076 } else {
1077 t2p->tiff_pages[t2p->tiff_pagecount].page_number =
1078 pagen;
1079 }
1080 goto ispage2;
1081 }
1082 if(TIFFGetField(input, TIFFTAG_SUBFILETYPE, &subfiletype)){
1083 if ( ((subfiletype & FILETYPE_PAGE) != 0)
1084 || (subfiletype == 0)){
1085 goto ispage;
1086 } else {
1087 goto isnotpage;
1088 }
1089 }
1090 if(TIFFGetField(input, TIFFTAG_OSUBFILETYPE, &subfiletype)){
1091 if ((subfiletype == OFILETYPE_IMAGE)
1092 || (subfiletype == OFILETYPE_PAGE)
1093 || (subfiletype == 0) ){
1094 goto ispage;
1095 } else {
1096 goto isnotpage;
1097 }
1098 }
1099 ispage:
1100 t2p->tiff_pages[t2p->tiff_pagecount].page_number=t2p->tiff_pagecount;
1101 ispage2:
1102 t2p->tiff_pages[t2p->tiff_pagecount].page_directory=i;
1103 if(TIFFIsTiled(input)){
1104 t2p->tiff_pages[t2p->tiff_pagecount].page_tilecount =
1105 TIFFNumberOfTiles(input);
1106 }
1107 t2p->tiff_pagecount++;
1108 isnotpage:
1109 (void)0;
1110 }
1111
1112 qsort((void*) t2p->tiff_pages, t2p->tiff_pagecount,
1113 sizeof(T2P_PAGE), t2p_cmp_t2p_page);
1114
1115 for(i=0;i<t2p->tiff_pagecount;i++){
1116 t2p->pdf_xrefcount += 5;
1117 TIFFSetDirectory(input, t2p->tiff_pages[i].page_directory );
1118 if((TIFFGetField(input, TIFFTAG_PHOTOMETRIC, &xuint16)
1119 && (xuint16==PHOTOMETRIC_PALETTE))
1120 || TIFFGetField(input, TIFFTAG_INDEXED, &xuint16)) {
1121 t2p->tiff_pages[i].page_extra++;
1122 t2p->pdf_xrefcount++;
1123 }
1124 #ifdef ZIP_SUPPORT
1125 if (TIFFGetField(input, TIFFTAG_COMPRESSION, &xuint16)) {
1126 if( (xuint16== COMPRESSION_DEFLATE ||
1127 xuint16== COMPRESSION_ADOBE_DEFLATE) &&
1128 ((t2p->tiff_pages[i].page_tilecount != 0)
1129 || TIFFNumberOfStrips(input)==1) &&
1130 (t2p->pdf_nopassthrough==0) ){
1131 if(t2p->pdf_minorversion<2){t2p->pdf_minorversion=2;}
1132 }
1133 }
1134 #endif
1135 if (TIFFGetField(input, TIFFTAG_TRANSFERFUNCTION,
1136 &(t2p->tiff_transferfunction[0]),
1137 &(t2p->tiff_transferfunction[1]),
1138 &(t2p->tiff_transferfunction[2]))) {
1139 if(t2p->tiff_transferfunction[1] !=
1140 t2p->tiff_transferfunction[0]) {
1141 t2p->tiff_transferfunctioncount = 3;
1142 t2p->tiff_pages[i].page_extra += 4;
1143 t2p->pdf_xrefcount += 4;
1144 } else {
1145 t2p->tiff_transferfunctioncount = 1;
1146 t2p->tiff_pages[i].page_extra += 2;
1147 t2p->pdf_xrefcount += 2;
1148 }
1149 if(t2p->pdf_minorversion < 2)
1150 t2p->pdf_minorversion = 2;
1151 } else {
1152 t2p->tiff_transferfunctioncount=0;
1153 }
1154 if( TIFFGetField(
1155 input,
1156 TIFFTAG_ICCPROFILE,
1157 &(t2p->tiff_iccprofilelength),
1158 &(t2p->tiff_iccprofile)) != 0){
1159 t2p->tiff_pages[i].page_extra++;
1160 t2p->pdf_xrefcount++;
1161 if(t2p->pdf_minorversion<3){t2p->pdf_minorversion=3;}
1162 }
1163 t2p->tiff_tiles[i].tiles_tilecount=
1164 t2p->tiff_pages[i].page_tilecount;
1165 if( (TIFFGetField(input, TIFFTAG_PLANARCONFIG, &xuint16) != 0)
1166 && (xuint16 == PLANARCONFIG_SEPARATE ) ){
1167 TIFFGetField(input, TIFFTAG_SAMPLESPERPIXEL, &xuint16);
1168 t2p->tiff_tiles[i].tiles_tilecount/= xuint16;
1169 }
1170 if( t2p->tiff_tiles[i].tiles_tilecount > 0){
1171 t2p->pdf_xrefcount +=
1172 (t2p->tiff_tiles[i].tiles_tilecount -1)*2;
1173 TIFFGetField(input,
1174 TIFFTAG_TILEWIDTH,
1175 &( t2p->tiff_tiles[i].tiles_tilewidth) );
1176 TIFFGetField(input,
1177 TIFFTAG_TILELENGTH,
1178 &( t2p->tiff_tiles[i].tiles_tilelength) );
1179 t2p->tiff_tiles[i].tiles_tiles =
1180 (T2P_TILE*) _TIFFmalloc(
1181 t2p->tiff_tiles[i].tiles_tilecount
1182 * sizeof(T2P_TILE) );
1183 if( t2p->tiff_tiles[i].tiles_tiles == NULL){
1184 TIFFError(
1185 TIFF2PDF_MODULE,
1186 "Can't allocate %lu bytes of memory for t2p_read_tiff_init, %s",
1187 (unsigned long) t2p->tiff_tiles[i].tiles_tilecount * sizeof(T2P_TILE),
1188 TIFFFileName(input));
1189 t2p->t2p_error = T2P_ERR_ERROR;
1190 return;
1191 }
1192 }
1193 }
1194
1195 return;
1196 }
1197
1198 /*
1199 * This function is used by qsort to sort a T2P_PAGE* array of page structures
1200 * by page number.
1201 */
1202
1203 int t2p_cmp_t2p_page(const void* e1, const void* e2){
1204
1205 return( ((T2P_PAGE*)e1)->page_number - ((T2P_PAGE*)e2)->page_number );
1206 }
1207
1208 /*
1209 This function sets the input directory to the directory of a given
1210 page and determines information about the image. It checks
1211 the image characteristics to determine if it is possible to convert
1212 the image data into a page of PDF output, setting values of the T2P
1213 struct for this page. It determines what color space is used in
1214 the output PDF to represent the image.
1215
1216 It determines if the image can be converted as raw data without
1217 requiring transcoding of the image data.
1218 */
1219
1220 void t2p_read_tiff_data(T2P* t2p, TIFF* input){
1221
1222 int i=0;
1223 uint16* r;
1224 uint16* g;
1225 uint16* b;
1226 uint16* a;
1227 uint16 xuint16;
1228 uint16* xuint16p;
1229 float* xfloatp;
1230
1231 t2p->pdf_transcode = T2P_TRANSCODE_ENCODE;
1232 t2p->pdf_sample = T2P_SAMPLE_NOTHING;
1233 t2p->pdf_switchdecode = t2p->pdf_colorspace_invert;
1234
1235
1236 TIFFSetDirectory(input, t2p->tiff_pages[t2p->pdf_page].page_directory);
1237
1238 TIFFGetField(input, TIFFTAG_IMAGEWIDTH, &(t2p->tiff_width));
1239 if(t2p->tiff_width == 0){
1240 TIFFError(
1241 TIFF2PDF_MODULE,
1242 "No support for %s with zero width",
1243 TIFFFileName(input) );
1244 t2p->t2p_error = T2P_ERR_ERROR;
1245 return;
1246 }
1247
1248 TIFFGetField(input, TIFFTAG_IMAGELENGTH, &(t2p->tiff_length));
1249 if(t2p->tiff_length == 0){
1250 TIFFError(
1251 TIFF2PDF_MODULE,
1252 "No support for %s with zero length",
1253 TIFFFileName(input) );
1254 t2p->t2p_error = T2P_ERR_ERROR;
1255 return;
1256 }
1257
1258 if(TIFFGetField(input, TIFFTAG_COMPRESSION, &(t2p->tiff_compression)) == 0){
1259 TIFFError(
1260 TIFF2PDF_MODULE,
1261 "No support for %s with no compression tag",
1262 TIFFFileName(input) );
1263 t2p->t2p_error = T2P_ERR_ERROR;
1264 return;
1265
1266 }
1267 if( TIFFIsCODECConfigured(t2p->tiff_compression) == 0){
1268 TIFFError(
1269 TIFF2PDF_MODULE,
1270 "No support for %s with compression type %u: not configured",
1271 TIFFFileName(input),
1272 t2p->tiff_compression
1273 );
1274 t2p->t2p_error = T2P_ERR_ERROR;
1275 return;
1276
1277 }
1278
1279 TIFFGetFieldDefaulted(input, TIFFTAG_BITSPERSAMPLE, &(t2p->tiff_bitspersample));
1280 switch(t2p->tiff_bitspersample){
1281 case 1:
1282 case 2:
1283 case 4:
1284 case 8:
1285 break;
1286 case 0:
1287 TIFFWarning(
1288 TIFF2PDF_MODULE,
1289 "Image %s has 0 bits per sample, assuming 1",
1290 TIFFFileName(input));
1291 t2p->tiff_bitspersample=1;
1292 break;
1293 default:
1294 TIFFError(
1295 TIFF2PDF_MODULE,
1296 "No support for %s with %u bits per sample",
1297 TIFFFileName(input),
1298 t2p->tiff_bitspersample);
1299 t2p->t2p_error = T2P_ERR_ERROR;
1300 return;
1301 }
1302
1303 TIFFGetFieldDefaulted(input, TIFFTAG_SAMPLESPERPIXEL, &(t2p->tiff_samplesperpixel));
1304 if(t2p->tiff_samplesperpixel>4){
1305 TIFFError(
1306 TIFF2PDF_MODULE,
1307 "No support for %s with %u samples per pixel",
1308 TIFFFileName(input),
1309 t2p->tiff_samplesperpixel);
1310 t2p->t2p_error = T2P_ERR_ERROR;
1311 return;
1312 }
1313 if(t2p->tiff_samplesperpixel==0){
1314 TIFFWarning(
1315 TIFF2PDF_MODULE,
1316 "Image %s has 0 samples per pixel, assuming 1",
1317 TIFFFileName(input));
1318 t2p->tiff_samplesperpixel=1;
1319 }
1320
1321 if(TIFFGetField(input, TIFFTAG_SAMPLEFORMAT, &xuint16) != 0 ){
1322 switch(xuint16){
1323 case 0:
1324 case 1:
1325 case 4:
1326 break;
1327 default:
1328 TIFFError(
1329 TIFF2PDF_MODULE,
1330 "No support for %s with sample format %u",
1331 TIFFFileName(input),
1332 xuint16);
1333 t2p->t2p_error = T2P_ERR_ERROR;
1334 return;
1335 break;
1336 }
1337 }
1338
1339 TIFFGetFieldDefaulted(input, TIFFTAG_FILLORDER, &(t2p->tiff_fillorder));
1340
1341 if(TIFFGetField(input, TIFFTAG_PHOTOMETRIC, &(t2p->tiff_photometric)) == 0){
1342 TIFFError(
1343 TIFF2PDF_MODULE,
1344 "No support for %s with no photometric interpretation tag",
1345 TIFFFileName(input) );
1346 t2p->t2p_error = T2P_ERR_ERROR;
1347 return;
1348
1349 }
1350
1351 switch(t2p->tiff_photometric){
1352 case PHOTOMETRIC_MINISWHITE:
1353 case PHOTOMETRIC_MINISBLACK:
1354 if (t2p->tiff_bitspersample==1){
1355 t2p->pdf_colorspace=T2P_CS_BILEVEL;
1356 if(t2p->tiff_photometric==PHOTOMETRIC_MINISWHITE){
1357 t2p->pdf_switchdecode ^= 1;
1358 }
1359 } else {
1360 t2p->pdf_colorspace=T2P_CS_GRAY;
1361 if(t2p->tiff_photometric==PHOTOMETRIC_MINISWHITE){
1362 t2p->pdf_switchdecode ^= 1;
1363 }
1364 }
1365 break;
1366 case PHOTOMETRIC_RGB:
1367 t2p->pdf_colorspace=T2P_CS_RGB;
1368 if(t2p->tiff_samplesperpixel == 3){
1369 break;
1370 }
1371 if(TIFFGetField(input, TIFFTAG_INDEXED, &xuint16)){
1372 if(xuint16==1)
1373 goto photometric_palette;
1374 }
1375 if(t2p->tiff_samplesperpixel > 3) {
1376 if(t2p->tiff_samplesperpixel == 4) {
1377 t2p->pdf_colorspace = T2P_CS_RGB;
1378 if(TIFFGetField(input,
1379 TIFFTAG_EXTRASAMPLES,
1380 &xuint16, &xuint16p)
1381 && xuint16 == 1) {
1382 if(xuint16p[0] == EXTRASAMPLE_ASSOCALPHA){
1383 t2p->pdf_sample=T2P_SAMPLE_RGBAA_TO_RGB;
1384 break;
1385 }
1386 if(xuint16p[0] == EXTRASAMPLE_UNASSALPHA){
1387 t2p->pdf_sample=T2P_SAMPLE_RGBA_TO_RGB;
1388 break;
1389 }
1390 TIFFWarning(
1391 TIFF2PDF_MODULE,
1392 "RGB image %s has 4 samples per pixel, assuming RGBA",
1393 TIFFFileName(input));
1394 break;
1395 }
1396 t2p->pdf_colorspace=T2P_CS_CMYK;
1397 t2p->pdf_switchdecode ^= 1;
1398 TIFFWarning(
1399 TIFF2PDF_MODULE,
1400 "RGB image %s has 4 samples per pixel, assuming inverse CMYK",
1401 TIFFFileName(input));
1402 break;
1403 } else {
1404 TIFFError(
1405 TIFF2PDF_MODULE,
1406 "No support for RGB image %s with %u samples per pixel",
1407 TIFFFileName(input),
1408 t2p->tiff_samplesperpixel);
1409 t2p->t2p_error = T2P_ERR_ERROR;
1410 break;
1411 }
1412 } else {
1413 TIFFError(
1414 TIFF2PDF_MODULE,
1415 "No support for RGB image %s with %u samples per pixel",
1416 TIFFFileName(input),
1417 t2p->tiff_samplesperpixel);
1418 t2p->t2p_error = T2P_ERR_ERROR;
1419 break;
1420 }
1421 case PHOTOMETRIC_PALETTE:
1422 photometric_palette:
1423 if(t2p->tiff_samplesperpixel!=1){
1424 TIFFError(
1425 TIFF2PDF_MODULE,
1426 "No support for palettized image %s with not one sample per pixel",
1427 TIFFFileName(input));
1428 t2p->t2p_error = T2P_ERR_ERROR;
1429 return;
1430 }
1431 t2p->pdf_colorspace=T2P_CS_RGB | T2P_CS_PALETTE;
1432 t2p->pdf_palettesize=0x0001<<t2p->tiff_bitspersample;
1433 if(!TIFFGetField(input, TIFFTAG_COLORMAP, &r, &g, &b)){
1434 TIFFError(
1435 TIFF2PDF_MODULE,
1436 "Palettized image %s has no color map",
1437 TIFFFileName(input));
1438 t2p->t2p_error = T2P_ERR_ERROR;
1439 return;
1440 }
1441 if(t2p->pdf_palette != NULL){
1442 _TIFFfree(t2p->pdf_palette);
1443 t2p->pdf_palette=NULL;
1444 }
1445 t2p->pdf_palette = (unsigned char*)
1446 _TIFFmalloc(t2p->pdf_palettesize*3);
1447 if(t2p->pdf_palette==NULL){
1448 TIFFError(
1449 TIFF2PDF_MODULE,
1450 "Can't allocate %u bytes of memory for t2p_read_tiff_image, %s",
1451 t2p->pdf_palettesize,
1452 TIFFFileName(input));
1453 t2p->t2p_error = T2P_ERR_ERROR;
1454 return;
1455 }
1456 for(i=0;i<t2p->pdf_palettesize;i++){
1457 t2p->pdf_palette[(i*3)] = (unsigned char) (r[i]>>8);
1458 t2p->pdf_palette[(i*3)+1]= (unsigned char) (g[i]>>8);
1459 t2p->pdf_palette[(i*3)+2]= (unsigned char) (b[i]>>8);
1460 }
1461 t2p->pdf_palettesize *= 3;
1462 break;
1463 case PHOTOMETRIC_SEPARATED:
1464 if(TIFFGetField(input, TIFFTAG_INDEXED, &xuint16)){
1465 if(xuint16==1){
1466 goto photometric_palette_cmyk;
1467 }
1468 }
1469 if( TIFFGetField(input, TIFFTAG_INKSET, &xuint16) ){
1470 if(xuint16 != INKSET_CMYK){
1471 TIFFError(
1472 TIFF2PDF_MODULE,
1473 "No support for %s because its inkset is not CMYK",
1474 TIFFFileName(input) );
1475 t2p->t2p_error = T2P_ERR_ERROR;
1476 return;
1477 }
1478 }
1479 if(t2p->tiff_samplesperpixel==4){
1480 t2p->pdf_colorspace=T2P_CS_CMYK;
1481 } else {
1482 TIFFError(
1483 TIFF2PDF_MODULE,
1484 "No support for %s because it has %u samples per pixel",
1485 TIFFFileName(input),
1486 t2p->tiff_samplesperpixel);
1487 t2p->t2p_error = T2P_ERR_ERROR;
1488 return;
1489 }
1490 break;
1491 photometric_palette_cmyk:
1492 if(t2p->tiff_samplesperpixel!=1){
1493 TIFFError(
1494 TIFF2PDF_MODULE,
1495 "No support for palettized CMYK image %s with not one sample per pixel",
1496 TIFFFileName(input));
1497 t2p->t2p_error = T2P_ERR_ERROR;
1498 return;
1499 }
1500 t2p->pdf_colorspace=T2P_CS_CMYK | T2P_CS_PALETTE;
1501 t2p->pdf_palettesize=0x0001<<t2p->tiff_bitspersample;
1502 if(!TIFFGetField(input, TIFFTAG_COLORMAP, &r, &g, &b, &a)){
1503 TIFFError(
1504 TIFF2PDF_MODULE,
1505 "Palettized image %s has no color map",
1506 TIFFFileName(input));
1507 t2p->t2p_error = T2P_ERR_ERROR;
1508 return;
1509 }
1510 if(t2p->pdf_palette != NULL){
1511 _TIFFfree(t2p->pdf_palette);
1512 t2p->pdf_palette=NULL;
1513 }
1514 t2p->pdf_palette = (unsigned char*)
1515 _TIFFmalloc(t2p->pdf_palettesize*4);
1516 if(t2p->pdf_palette==NULL){
1517 TIFFError(
1518 TIFF2PDF_MODULE,
1519 "Can't allocate %u bytes of memory for t2p_read_tiff_image, %s",
1520 t2p->pdf_palettesize,
1521 TIFFFileName(input));
1522 t2p->t2p_error = T2P_ERR_ERROR;
1523 return;
1524 }
1525 for(i=0;i<t2p->pdf_palettesize;i++){
1526 t2p->pdf_palette[(i*4)] = (unsigned char) (r[i]>>8);
1527 t2p->pdf_palette[(i*4)+1]= (unsigned char) (g[i]>>8);
1528 t2p->pdf_palette[(i*4)+2]= (unsigned char) (b[i]>>8);
1529 t2p->pdf_palette[(i*4)+3]= (unsigned char) (a[i]>>8);
1530 }
1531 t2p->pdf_palettesize *= 4;
1532 break;
1533 case PHOTOMETRIC_YCBCR:
1534 t2p->pdf_colorspace=T2P_CS_RGB;
1535 if(t2p->tiff_samplesperpixel==1){
1536 t2p->pdf_colorspace=T2P_CS_GRAY;
1537 t2p->tiff_photometric=PHOTOMETRIC_MINISBLACK;
1538 break;
1539 }
1540 t2p->pdf_sample=T2P_SAMPLE_YCBCR_TO_RGB;
1541 #ifdef JPEG_SUPPORT
1542 if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
1543 t2p->pdf_sample=T2P_SAMPLE_NOTHING;
1544 }
1545 #endif
1546 break;
1547 case PHOTOMETRIC_CIELAB:
1548 t2p->pdf_labrange[0]= -127;
1549 t2p->pdf_labrange[1]= 127;
1550 t2p->pdf_labrange[2]= -127;
1551 t2p->pdf_labrange[3]= 127;
1552 t2p->pdf_sample=T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED;
1553 t2p->pdf_colorspace=T2P_CS_LAB;
1554 break;
1555 case PHOTOMETRIC_ICCLAB:
1556 t2p->pdf_labrange[0]= 0;
1557 t2p->pdf_labrange[1]= 255;
1558 t2p->pdf_labrange[2]= 0;
1559 t2p->pdf_labrange[3]= 255;
1560 t2p->pdf_colorspace=T2P_CS_LAB;
1561 break;
1562 case PHOTOMETRIC_ITULAB:
1563 t2p->pdf_labrange[0]=-85;
1564 t2p->pdf_labrange[1]=85;
1565 t2p->pdf_labrange[2]=-75;
1566 t2p->pdf_labrange[3]=124;
1567 t2p->pdf_sample=T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED;
1568 t2p->pdf_colorspace=T2P_CS_LAB;
1569 break;
1570 case PHOTOMETRIC_LOGL:
1571 case PHOTOMETRIC_LOGLUV:
1572 TIFFError(
1573 TIFF2PDF_MODULE,
1574 "No support for %s with photometric interpretation LogL/LogLuv",
1575 TIFFFileName(input));
1576 t2p->t2p_error = T2P_ERR_ERROR;
1577 return;
1578 default:
1579 TIFFError(
1580 TIFF2PDF_MODULE,
1581 "No support for %s with photometric interpretation %u",
1582 TIFFFileName(input),
1583 t2p->tiff_photometric);
1584 t2p->t2p_error = T2P_ERR_ERROR;
1585 return;
1586 }
1587
1588 if(TIFFGetField(input, TIFFTAG_PLANARCONFIG, &(t2p->tiff_planar))){
1589 switch(t2p->tiff_planar){
1590 case 0:
1591 TIFFWarning(
1592 TIFF2PDF_MODULE,
1593 "Image %s has planar configuration 0, assuming 1",
1594 TIFFFileName(input));
1595 t2p->tiff_planar=PLANARCONFIG_CONTIG;
1596 case PLANARCONFIG_CONTIG:
1597 break;
1598 case PLANARCONFIG_SEPARATE:
1599 t2p->pdf_sample=T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG;
1600 if(t2p->tiff_bitspersample!=8){
1601 TIFFError(
1602 TIFF2PDF_MODULE,
1603 "No support for %s with separated planar configuration and %u bits per sample",
1604 TIFFFileName(input),
1605 t2p->tiff_bitspersample);
1606 t2p->t2p_error = T2P_ERR_ERROR;
1607 return;
1608 }
1609 break;
1610 default:
1611 TIFFError(
1612 TIFF2PDF_MODULE,
1613 "No support for %s with planar configuration %u",
1614 TIFFFileName(input),
1615 t2p->tiff_planar);
1616 t2p->t2p_error = T2P_ERR_ERROR;
1617 return;
1618 }
1619 }
1620
1621 TIFFGetFieldDefaulted(input, TIFFTAG_ORIENTATION,
1622 &(t2p->tiff_orientation));
1623 if(t2p->tiff_orientation>8){
1624 TIFFWarning(TIFF2PDF_MODULE,
1625 "Image %s has orientation %u, assuming 0",
1626 TIFFFileName(input), t2p->tiff_orientation);
1627 t2p->tiff_orientation=0;
1628 }
1629
1630 if(TIFFGetField(input, TIFFTAG_XRESOLUTION, &(t2p->tiff_xres) ) == 0){
1631 t2p->tiff_xres=0.0;
1632 }
1633 if(TIFFGetField(input, TIFFTAG_YRESOLUTION, &(t2p->tiff_yres) ) == 0){
1634 t2p->tiff_yres=0.0;
1635 }
1636 TIFFGetFieldDefaulted(input, TIFFTAG_RESOLUTIONUNIT,
1637 &(t2p->tiff_resunit));
1638 if(t2p->tiff_resunit == RESUNIT_CENTIMETER) {
1639 t2p->tiff_xres *= 2.54F;
1640 t2p->tiff_yres *= 2.54F;
1641 } else if (t2p->tiff_resunit != RESUNIT_INCH
1642 && t2p->pdf_centimeters != 0) {
1643 t2p->tiff_xres *= 2.54F;
1644 t2p->tiff_yres *= 2.54F;
1645 }
1646
1647 t2p_compose_pdf_page(t2p);
1648
1649 t2p->pdf_transcode = T2P_TRANSCODE_ENCODE;
1650 if(t2p->pdf_nopassthrough==0){
1651 #ifdef CCITT_SUPPORT
1652 if(t2p->tiff_compression==COMPRESSION_CCITTFAX4
1653 ){
1654 if(TIFFIsTiled(input) || (TIFFNumberOfStrips(input)==1) ){
1655 t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1656 t2p->pdf_compression=T2P_COMPRESS_G4;
1657 }
1658 }
1659 #endif
1660 #ifdef ZIP_SUPPORT
1661 if(t2p->tiff_compression== COMPRESSION_ADOBE_DEFLATE
1662 || t2p->tiff_compression==COMPRESSION_DEFLATE){
1663 if(TIFFIsTiled(input) || (TIFFNumberOfStrips(input)==1) ){
1664 t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1665 t2p->pdf_compression=T2P_COMPRESS_ZIP;
1666 }
1667 }
1668 #endif
1669 #ifdef OJPEG_SUPPORT
1670 if(t2p->tiff_compression==COMPRESSION_OJPEG){
1671 t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1672 t2p->pdf_compression=T2P_COMPRESS_JPEG;
1673 t2p_process_ojpeg_tables(t2p, input);
1674 }
1675 #endif
1676 #ifdef JPEG_SUPPORT
1677 if(t2p->tiff_compression==COMPRESSION_JPEG){
1678 t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1679 t2p->pdf_compression=T2P_COMPRESS_JPEG;
1680 }
1681 #endif
1682 (void)0;
1683 }
1684
1685 if(t2p->pdf_transcode!=T2P_TRANSCODE_RAW){
1686 t2p->pdf_compression = t2p->pdf_defaultcompression;
1687 }
1688
1689 #ifdef JPEG_SUPPORT
1690 if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
1691 if(t2p->pdf_colorspace & T2P_CS_PALETTE){
1692 t2p->pdf_sample|=T2P_SAMPLE_REALIZE_PALETTE;
1693 t2p->pdf_colorspace ^= T2P_CS_PALETTE;
1694 t2p->tiff_pages[t2p->pdf_page].page_extra--;
1695 }
1696 }
1697 if(t2p->tiff_compression==COMPRESSION_JPEG){
1698 if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1699 TIFFError(
1700 TIFF2PDF_MODULE,
1701 "No support for %s with JPEG compression and separated planar configuration",
1702 TIFFFileName(input));
1703 t2p->t2p_error=T2P_ERR_ERROR;
1704 return;
1705 }
1706 }
1707 #endif
1708 #ifdef OJPEG_SUPPORT
1709 if(t2p->tiff_compression==COMPRESSION_OJPEG){
1710 if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1711 TIFFError(
1712 TIFF2PDF_MODULE,
1713 "No support for %s with OJPEG compression and separated planar configuration",
1714 TIFFFileName(input));
1715 t2p->t2p_error=T2P_ERR_ERROR;
1716 return;
1717 }
1718 }
1719 #endif
1720
1721 if(t2p->pdf_sample & T2P_SAMPLE_REALIZE_PALETTE){
1722 if(t2p->pdf_colorspace & T2P_CS_CMYK){
1723 t2p->tiff_samplesperpixel=4;
1724 t2p->tiff_photometric=PHOTOMETRIC_SEPARATED;
1725 } else {
1726 t2p->tiff_samplesperpixel=3;
1727 t2p->tiff_photometric=PHOTOMETRIC_RGB;
1728 }
1729 }
1730
1731 if (TIFFGetField(input, TIFFTAG_TRANSFERFUNCTION,
1732 &(t2p->tiff_transferfunction[0]),
1733 &(t2p->tiff_transferfunction[1]),
1734 &(t2p->tiff_transferfunction[2]))) {
1735 if(t2p->tiff_transferfunction[1] !=
1736 t2p->tiff_transferfunction[0]) {
1737 t2p->tiff_transferfunctioncount=3;
1738 } else {
1739 t2p->tiff_transferfunctioncount=1;
1740 }
1741 } else {
1742 t2p->tiff_transferfunctioncount=0;
1743 }
1744 if(TIFFGetField(input, TIFFTAG_WHITEPOINT, &xfloatp)!=0){
1745 t2p->tiff_whitechromaticities[0]=xfloatp[0];
1746 t2p->tiff_whitechromaticities[1]=xfloatp[1];
1747 if(t2p->pdf_colorspace & T2P_CS_GRAY){
1748 t2p->pdf_colorspace |= T2P_CS_CALGRAY;
1749 }
1750 if(t2p->pdf_colorspace & T2P_CS_RGB){
1751 t2p->pdf_colorspace |= T2P_CS_CALRGB;
1752 }
1753 }
1754 if(TIFFGetField(input, TIFFTAG_PRIMARYCHROMATICITIES, &xfloatp)!=0){
1755 t2p->tiff_primarychromaticities[0]=xfloatp[0];
1756 t2p->tiff_primarychromaticities[1]=xfloatp[1];
1757 t2p->tiff_primarychromaticities[2]=xfloatp[2];
1758 t2p->tiff_primarychromaticities[3]=xfloatp[3];
1759 t2p->tiff_primarychromaticities[4]=xfloatp[4];
1760 t2p->tiff_primarychromaticities[5]=xfloatp[5];
1761 if(t2p->pdf_colorspace & T2P_CS_RGB){
1762 t2p->pdf_colorspace |= T2P_CS_CALRGB;
1763 }
1764 }
1765 if(t2p->pdf_colorspace & T2P_CS_LAB){
1766 if(TIFFGetField(input, TIFFTAG_WHITEPOINT, &xfloatp) != 0){
1767 t2p->tiff_whitechromaticities[0]=xfloatp[0];
1768 t2p->tiff_whitechromaticities[1]=xfloatp[1];
1769 } else {
1770 t2p->tiff_whitechromaticities[0]=0.3457F; /* 0.3127F; */
1771 t2p->tiff_whitechromaticities[1]=0.3585F; /* 0.3290F; */
1772 }
1773 }
1774 if(TIFFGetField(input,
1775 TIFFTAG_ICCPROFILE,
1776 &(t2p->tiff_iccprofilelength),
1777 &(t2p->tiff_iccprofile))!=0){
1778 t2p->pdf_colorspace |= T2P_CS_ICCBASED;
1779 } else {
1780 t2p->tiff_iccprofilelength=0;
1781 t2p->tiff_iccprofile=NULL;
1782 }
1783
1784 #ifdef CCITT_SUPPORT
1785 if( t2p->tiff_bitspersample==1 &&
1786 t2p->tiff_samplesperpixel==1){
1787 t2p->pdf_compression = T2P_COMPRESS_G4;
1788 }
1789 #endif
1790
1791
1792 return;
1793 }
1794
1795 /*
1796 This function returns the necessary size of a data buffer to contain the raw or
1797 uncompressed image data from the input TIFF for a page.
1798 */
1799
1800 void t2p_read_tiff_size(T2P* t2p, TIFF* input){
1801
1802 uint64* sbc=NULL;
1803 #if defined(JPEG_SUPPORT) || defined (OJPEG_SUPPORT)
1804 unsigned char* jpt=NULL;
1805 tstrip_t i=0;
1806 tstrip_t stripcount=0;
1807 #endif
1808 uint64 k = 0;
1809
1810 if(t2p->pdf_transcode == T2P_TRANSCODE_RAW){
1811 #ifdef CCITT_SUPPORT
1812 if(t2p->pdf_compression == T2P_COMPRESS_G4 ){
1813 TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
1814 t2p->tiff_datasize=(tmsize_t)sbc[0];
1815 return;
1816 }
1817 #endif
1818 #ifdef ZIP_SUPPORT
1819 if(t2p->pdf_compression == T2P_COMPRESS_ZIP){
1820 TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
1821 t2p->tiff_datasize=(tmsize_t)sbc[0];
1822 return;
1823 }
1824 #endif
1825 #ifdef OJPEG_SUPPORT
1826 if(t2p->tiff_compression == COMPRESSION_OJPEG){
1827 if(!TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc)){
1828 TIFFError(TIFF2PDF_MODULE,
1829 "Input file %s missing field: TIFFTAG_STRIPBYTECOUNTS",
1830 TIFFFileName(input));
1831 t2p->t2p_error = T2P_ERR_ERROR;
1832 return;
1833 }
1834 stripcount=TIFFNumberOfStrips(input);
1835 for(i=0;i<stripcount;i++){
1836 k = checkAdd64(k, sbc[i], t2p);
1837 }
1838 if(TIFFGetField(input, TIFFTAG_JPEGIFOFFSET, &(t2p->tiff_dataoffset))){
1839 if(t2p->tiff_dataoffset != 0){
1840 if(TIFFGetField(input, TIFFTAG_JPEGIFBYTECOUNT, &(t2p->tiff_datasize))!=0){
1841 if((uint64)t2p->tiff_datasize < k) {
1842 TIFFWarning(TIFF2PDF_MODULE,
1843 "Input file %s has short JPEG interchange file byte count",
1844 TIFFFileName(input));
1845 t2p->pdf_ojpegiflength=t2p->tiff_datasize;
1846 k = checkAdd64(k, t2p->tiff_datasize, t2p);
1847 k = checkAdd64(k, 6, t2p);
1848 k = checkAdd64(k, stripcount, t2p);
1849 k = checkAdd64(k, stripcount, t2p);
1850 t2p->tiff_datasize = (tsize_t) k;
1851 if ((uint64) t2p->tiff_datasize != k) {
1852 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1853 t2p->t2p_error = T2P_ERR_ERROR;
1854 }
1855 return;
1856 }
1857 return;
1858 }else {
1859 TIFFError(TIFF2PDF_MODULE,
1860 "Input file %s missing field: TIFFTAG_JPEGIFBYTECOUNT",
1861 TIFFFileName(input));
1862 t2p->t2p_error = T2P_ERR_ERROR;
1863 return;
1864 }
1865 }
1866 }
1867 k = checkAdd64(k, stripcount, t2p);
1868 k = checkAdd64(k, stripcount, t2p);
1869 k = checkAdd64(k, 2048, t2p);
1870 t2p->tiff_datasize = (tsize_t) k;
1871 if ((uint64) t2p->tiff_datasize != k) {
1872 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1873 t2p->t2p_error = T2P_ERR_ERROR;
1874 }
1875 return;
1876 }
1877 #endif
1878 #ifdef JPEG_SUPPORT
1879 if(t2p->tiff_compression == COMPRESSION_JPEG) {
1880 uint32 count = 0;
1881 if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0 ){
1882 if(count > 4){
1883 k += count;
1884 k -= 2; /* don't use EOI of header */
1885 }
1886 } else {
1887 k = 2; /* SOI for first strip */
1888 }
1889 stripcount=TIFFNumberOfStrips(input);
1890 if(!TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc)){
1891 TIFFError(TIFF2PDF_MODULE,
1892 "Input file %s missing field: TIFFTAG_STRIPBYTECOUNTS",
1893 TIFFFileName(input));
1894 t2p->t2p_error = T2P_ERR_ERROR;
1895 return;
1896 }
1897 for(i=0;i<stripcount;i++){
1898 k = checkAdd64(k, sbc[i], t2p);
1899 k -=4; /* don't use SOI or EOI of strip */
1900 }
1901 k = checkAdd64(k, 2, t2p); /* use EOI of last strip */
1902 t2p->tiff_datasize = (tsize_t) k;
1903 if ((uint64) t2p->tiff_datasize != k) {
1904 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1905 t2p->t2p_error = T2P_ERR_ERROR;
1906 }
1907 return;
1908 }
1909 #endif
1910 (void) 0;
1911 }
1912 k = checkMultiply64(TIFFScanlineSize(input), t2p->tiff_length, t2p);
1913 if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1914 k = checkMultiply64(k, t2p->tiff_samplesperpixel, t2p);
1915 }
1916 if (k == 0) {
1917 /* Assume we had overflow inside TIFFScanlineSize */
1918 t2p->t2p_error = T2P_ERR_ERROR;
1919 }
1920
1921 t2p->tiff_datasize = (tsize_t) k;
1922 if ((uint64) t2p->tiff_datasize != k) {
1923 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1924 t2p->t2p_error = T2P_ERR_ERROR;
1925 }
1926
1927 return;
1928 }
1929
1930 /*
1931 This function returns the necessary size of a data buffer to contain the raw or
1932 uncompressed image data from the input TIFF for a tile of a page.
1933 */
1934
1935 void t2p_read_tiff_size_tile(T2P* t2p, TIFF* input, ttile_t tile){
1936
1937 uint64* tbc = NULL;
1938 uint16 edge=0;
1939 #ifdef JPEG_SUPPORT
1940 unsigned char* jpt;
1941 #endif
1942 uint64 k;
1943
1944 edge |= t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
1945 edge |= t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
1946
1947 if(t2p->pdf_transcode==T2P_TRANSCODE_RAW){
1948 if(edge
1949 #if defined(JPEG_SUPPORT) || defined(OJPEG_SUPPORT)
1950 && !(t2p->pdf_compression==T2P_COMPRESS_JPEG)
1951 #endif
1952 ){
1953 t2p->tiff_datasize=TIFFTileSize(input);
1954 if (t2p->tiff_datasize == 0) {
1955 /* Assume we had overflow inside TIFFTileSize */
1956 t2p->t2p_error = T2P_ERR_ERROR;
1957 }
1958 return;
1959 } else {
1960 TIFFGetField(input, TIFFTAG_TILEBYTECOUNTS, &tbc);
1961 k=tbc[tile];
1962 #ifdef OJPEG_SUPPORT
1963 if(t2p->tiff_compression==COMPRESSION_OJPEG){
1964 k = checkAdd64(k, 2048, t2p);
1965 }
1966 #endif
1967 #ifdef JPEG_SUPPORT
1968 if(t2p->tiff_compression==COMPRESSION_JPEG) {
1969 uint32 count = 0;
1970 if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt)!=0){
1971 if(count > 4){
1972 k = checkAdd64(k, count, t2p);
1973 k -= 2; /* don't use EOI of header or SOI of tile */
1974 }
1975 }
1976 }
1977 #endif
1978 t2p->tiff_datasize = (tsize_t) k;
1979 if ((uint64) t2p->tiff_datasize != k) {
1980 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1981 t2p->t2p_error = T2P_ERR_ERROR;
1982 }
1983 return;
1984 }
1985 }
1986 k = TIFFTileSize(input);
1987 if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1988 k = checkMultiply64(k, t2p->tiff_samplesperpixel, t2p);
1989 }
1990 if (k == 0) {
1991 /* Assume we had overflow inside TIFFTileSize */
1992 t2p->t2p_error = T2P_ERR_ERROR;
1993 }
1994
1995 t2p->tiff_datasize = (tsize_t) k;
1996 if ((uint64) t2p->tiff_datasize != k) {
1997 TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1998 t2p->t2p_error = T2P_ERR_ERROR;
1999 }
2000
2001 return;
2002 }
2003
2004 /*
2005 * This functions returns a non-zero value when the tile is on the right edge
2006 * and does not have full imaged tile width.
2007 */
2008
2009 int t2p_tile_is_right_edge(T2P_TILES tiles, ttile_t tile){
2010
2011 if( ((tile+1) % tiles.tiles_tilecountx == 0)
2012 && (tiles.tiles_edgetilewidth != 0) ){
2013 return(1);
2014 } else {
2015 return(0);
2016 }
2017 }
2018
2019 /*
2020 * This functions returns a non-zero value when the tile is on the bottom edge
2021 * and does not have full imaged tile length.
2022 */
2023
2024 int t2p_tile_is_bottom_edge(T2P_TILES tiles, ttile_t tile){
2025
2026 if( ((tile+1) > (tiles.tiles_tilecount-tiles.tiles_tilecountx) )
2027 && (tiles.tiles_edgetilelength != 0) ){
2028 return(1);
2029 } else {
2030 return(0);
2031 }
2032 }
2033
2034 /*
2035 * This function returns a non-zero value when the tile is a right edge tile
2036 * or a bottom edge tile.
2037 */
2038
2039 int t2p_tile_is_edge(T2P_TILES tiles, ttile_t tile){
2040
2041 return(t2p_tile_is_right_edge(tiles, tile) | t2p_tile_is_bottom_edge(tiles, tile) );
2042 }
2043
2044 /*
2045 This function returns a non-zero value when the tile is a right edge tile and a bottom
2046 edge tile.
2047 */
2048
2049 int t2p_tile_is_corner_edge(T2P_TILES tiles, ttile_t tile){
2050
2051 return(t2p_tile_is_right_edge(tiles, tile) & t2p_tile_is_bottom_edge(tiles, tile) );
2052 }
2053
2054
2055 /*
2056 This function reads the raster image data from the input TIFF for an image and writes
2057 the data to the output PDF XObject image dictionary stream. It returns the amount written
2058 or zero on error.
2059 */
2060
2061 tsize_t t2p_readwrite_pdf_image(T2P* t2p, TIFF* input, TIFF* output){
2062
2063 tsize_t written=0;
2064 unsigned char* buffer=NULL;
2065 unsigned char* samplebuffer=NULL;
2066 tsize_t bufferoffset=0;
2067 tsize_t samplebufferoffset=0;
2068 tsize_t read=0;
2069 tstrip_t i=0;
2070 tstrip_t j=0;
2071 tstrip_t stripcount=0;
2072 tsize_t stripsize=0;
2073 tsize_t sepstripcount=0;
2074 tsize_t sepstripsize=0;
2075 #ifdef OJPEG_SUPPORT
2076 toff_t inputoffset=0;
2077 uint16 h_samp=1;
2078 uint16 v_samp=1;
2079 uint16 ri=1;
2080 uint32 rows=0;
2081 #endif
2082 #ifdef JPEG_SUPPORT
2083 unsigned char* jpt;
2084 float* xfloatp;
2085 uint64* sbc;
2086 unsigned char* stripbuffer;
2087 tsize_t striplength=0;
2088 uint32 max_striplength=0;
2089 #endif
2090
2091 /* Fail if prior error (in particular, can't trust tiff_datasize) */
2092 if (t2p->t2p_error != T2P_ERR_OK)
2093 return(0);
2094
2095 if(t2p->pdf_transcode == T2P_TRANSCODE_RAW){
2096 #ifdef CCITT_SUPPORT
2097 if(t2p->pdf_compression == T2P_COMPRESS_G4){
2098 buffer = (unsigned char*)
2099 _TIFFmalloc(t2p->tiff_datasize);
2100 if (buffer == NULL) {
2101 TIFFError(TIFF2PDF_MODULE,
2102 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2103 (unsigned long) t2p->tiff_datasize,
2104 TIFFFileName(input));
2105 t2p->t2p_error = T2P_ERR_ERROR;
2106 return(0);
2107 }
2108 TIFFReadRawStrip(input, 0, (tdata_t) buffer,
2109 t2p->tiff_datasize);
2110 if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
2111 /*
2112 * make sure is lsb-to-msb
2113 * bit-endianness fill order
2114 */
2115 TIFFReverseBits(buffer,
2116 t2p->tiff_datasize);
2117 }
2118 t2pWriteFile(output, (tdata_t) buffer,
2119 t2p->tiff_datasize);
2120 _TIFFfree(buffer);
2121 return(t2p->tiff_datasize);
2122 }
2123 #endif
2124 #ifdef ZIP_SUPPORT
2125 if (t2p->pdf_compression == T2P_COMPRESS_ZIP) {
2126 buffer = (unsigned char*)
2127 _TIFFmalloc(t2p->tiff_datasize);
2128 if(buffer == NULL){
2129 TIFFError(TIFF2PDF_MODULE,
2130 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2131 (unsigned long) t2p->tiff_datasize,
2132 TIFFFileName(input));
2133 t2p->t2p_error = T2P_ERR_ERROR;
2134 return(0);
2135 }
2136 memset(buffer, 0, t2p->tiff_datasize);
2137 TIFFReadRawStrip(input, 0, (tdata_t) buffer,
2138 t2p->tiff_datasize);
2139 if (t2p->tiff_fillorder==FILLORDER_LSB2MSB) {
2140 TIFFReverseBits(buffer,
2141 t2p->tiff_datasize);
2142 }
2143 t2pWriteFile(output, (tdata_t) buffer,
2144 t2p->tiff_datasize);
2145 _TIFFfree(buffer);
2146 return(t2p->tiff_datasize);
2147 }
2148 #endif
2149 #ifdef OJPEG_SUPPORT
2150 if(t2p->tiff_compression == COMPRESSION_OJPEG) {
2151
2152 if(t2p->tiff_dataoffset != 0) {
2153 buffer = (unsigned char*)
2154 _TIFFmalloc(t2p->tiff_datasize);
2155 if(buffer == NULL) {
2156 TIFFError(TIFF2PDF_MODULE,
2157 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2158 (unsigned long) t2p->tiff_datasize,
2159 TIFFFileName(input));
2160 t2p->t2p_error = T2P_ERR_ERROR;
2161 return(0);
2162 }
2163 memset(buffer, 0, t2p->tiff_datasize);
2164 if(t2p->pdf_ojpegiflength==0){
2165 inputoffset=t2pSeekFile(input, 0,
2166 SEEK_CUR);
2167 t2pSeekFile(input,
2168 t2p->tiff_dataoffset,
2169 SEEK_SET);
2170 t2pReadFile(input, (tdata_t) buffer,
2171 t2p->tiff_datasize);
2172 t2pSeekFile(input, inputoffset,
2173 SEEK_SET);
2174 t2pWriteFile(output, (tdata_t) buffer,
2175 t2p->tiff_datasize);
2176 _TIFFfree(buffer);
2177 return(t2p->tiff_datasize);
2178 } else {
2179 inputoffset=t2pSeekFile(input, 0,
2180 SEEK_CUR);
2181 t2pSeekFile(input,
2182 t2p->tiff_dataoffset,
2183 SEEK_SET);
2184 bufferoffset = t2pReadFile(input,
2185 (tdata_t) buffer,
2186 t2p->pdf_ojpegiflength);
2187 t2p->pdf_ojpegiflength = 0;
2188 t2pSeekFile(input, inputoffset,
2189 SEEK_SET);
2190 TIFFGetField(input,
2191 TIFFTAG_YCBCRSUBSAMPLING,
2192 &h_samp, &v_samp);
2193 buffer[bufferoffset++]= 0xff;
2194 buffer[bufferoffset++]= 0xdd;
2195 buffer[bufferoffset++]= 0x00;
2196 buffer[bufferoffset++]= 0x04;
2197 h_samp*=8;
2198 v_samp*=8;
2199 ri=(t2p->tiff_width+h_samp-1) / h_samp;
2200 TIFFGetField(input,
2201 TIFFTAG_ROWSPERSTRIP,
2202 &rows);
2203 ri*=(rows+v_samp-1)/v_samp;
2204 buffer[bufferoffset++]= (ri>>8) & 0xff;
2205 buffer[bufferoffset++]= ri & 0xff;
2206 stripcount=TIFFNumberOfStrips(input);
2207 for(i=0;i<stripcount;i++){
2208 if(i != 0 ){
2209 buffer[bufferoffset++]=0xff;
2210 buffer[bufferoffset++]=(0xd0 | ((i-1)%8));
2211 }
2212 bufferoffset+=TIFFReadRawStrip(input,
2213 i,
2214 (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2215 -1);
2216 }
2217 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2218 _TIFFfree(buffer);
2219 return(bufferoffset);
2220 }
2221 } else {
2222 if(! t2p->pdf_ojpegdata){
2223 TIFFError(TIFF2PDF_MODULE,
2224 "No support for OJPEG image %s with bad tables",
2225 TIFFFileName(input));
2226 t2p->t2p_error = T2P_ERR_ERROR;
2227 return(0);
2228 }
2229 buffer = (unsigned char*)
2230 _TIFFmalloc(t2p->tiff_datasize);
2231 if(buffer==NULL){
2232 TIFFError(TIFF2PDF_MODULE,
2233 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2234 (unsigned long) t2p->tiff_datasize,
2235 TIFFFileName(input));
2236 t2p->t2p_error = T2P_ERR_ERROR;
2237 return(0);
2238 }
2239 memset(buffer, 0, t2p->tiff_datasize);
2240 _TIFFmemcpy(buffer, t2p->pdf_ojpegdata, t2p->pdf_ojpegdatalength);
2241 bufferoffset=t2p->pdf_ojpegdatalength;
2242 stripcount=TIFFNumberOfStrips(input);
2243 for(i=0;i<stripcount;i++){
2244 if(i != 0){
2245 buffer[bufferoffset++]=0xff;
2246 buffer[bufferoffset++]=(0xd0 | ((i-1)%8));
2247 }
2248 bufferoffset+=TIFFReadRawStrip(input,
2249 i,
2250 (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2251 -1);
2252 }
2253 if( ! ( (buffer[bufferoffset-1]==0xd9) && (buffer[bufferoffset-2]==0xff) ) ){
2254 buffer[bufferoffset++]=0xff;
2255 buffer[bufferoffset++]=0xd9;
2256 }
2257 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2258 _TIFFfree(buffer);
2259 return(bufferoffset);
2260 TIFFError(TIFF2PDF_MODULE,
2261 "No support for OJPEG image %s with no JPEG File Interchange offset",
2262 TIFFFileName(input));
2263 t2p->t2p_error = T2P_ERR_ERROR;
2264 return(0);
2265 }
2266 return(t2p->tiff_datasize);
2267 }
2268 #endif
2269 #ifdef JPEG_SUPPORT
2270 if(t2p->tiff_compression == COMPRESSION_JPEG) {
2271 uint32 count = 0;
2272 buffer = (unsigned char*)
2273 _TIFFmalloc(t2p->tiff_datasize);
2274 if(buffer==NULL){
2275 TIFFError(TIFF2PDF_MODULE,
2276 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2277 (unsigned long) t2p->tiff_datasize,
2278 TIFFFileName(input));
2279 t2p->t2p_error = T2P_ERR_ERROR;
2280 return(0);
2281 }
2282 memset(buffer, 0, t2p->tiff_datasize);
2283 if (TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0) {
2284 if(count > 4) {
2285 _TIFFmemcpy(buffer, jpt, count);
2286 bufferoffset += count - 2;
2287 }
2288 }
2289 stripcount=TIFFNumberOfStrips(input);
2290 TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
2291 for(i=0;i<stripcount;i++){
2292 if(sbc[i]>max_striplength) max_striplength=sbc[i];
2293 }
2294 stripbuffer = (unsigned char*)
2295 _TIFFmalloc(max_striplength);
2296 if(stripbuffer==NULL){
2297 TIFFError(TIFF2PDF_MODULE,
2298 "Can't allocate %u bytes of memory for t2p_readwrite_pdf_image, %s",
2299 max_striplength,
2300 TIFFFileName(input));
2301 _TIFFfree(buffer);
2302 t2p->t2p_error = T2P_ERR_ERROR;
2303 return(0);
2304 }
2305 for(i=0;i<stripcount;i++){
2306 striplength=TIFFReadRawStrip(input, i, (tdata_t) stripbuffer, -1);
2307 if(!t2p_process_jpeg_strip(
2308 stripbuffer,
2309 &striplength,
2310 buffer,
2311 &bufferoffset,
2312 i,
2313 t2p->tiff_length)){
2314 TIFFError(TIFF2PDF_MODULE,
2315 "Can't process JPEG data in input file %s",
2316 TIFFFileName(input));
2317 _TIFFfree(samplebuffer);
2318 _TIFFfree(buffer);
2319 t2p->t2p_error = T2P_ERR_ERROR;
2320 return(0);
2321 }
2322 }
2323 buffer[bufferoffset++]=0xff;
2324 buffer[bufferoffset++]=0xd9;
2325 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2326 _TIFFfree(stripbuffer);
2327 _TIFFfree(buffer);
2328 return(bufferoffset);
2329 }
2330 #endif
2331 (void)0;
2332 }
2333
2334 if(t2p->pdf_sample==T2P_SAMPLE_NOTHING){
2335 buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2336 if(buffer==NULL){
2337 TIFFError(TIFF2PDF_MODULE,
2338 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2339 (unsigned long) t2p->tiff_datasize,
2340 TIFFFileName(input));
2341 t2p->t2p_error = T2P_ERR_ERROR;
2342 return(0);
2343 }
2344 memset(buffer, 0, t2p->tiff_datasize);
2345 stripsize=TIFFStripSize(input);
2346 stripcount=TIFFNumberOfStrips(input);
2347 for(i=0;i<stripcount;i++){
2348 read =
2349 TIFFReadEncodedStrip(input,
2350 i,
2351 (tdata_t) &buffer[bufferoffset],
2352 stripsize);
2353 if(read==-1){
2354 TIFFError(TIFF2PDF_MODULE,
2355 "Error on decoding strip %u of %s",
2356 i,
2357 TIFFFileName(input));
2358 _TIFFfree(buffer);
2359 t2p->t2p_error=T2P_ERR_ERROR;
2360 return(0);
2361 }
2362 bufferoffset+=read;
2363 }
2364 } else {
2365 if(t2p->pdf_sample & T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG){
2366
2367 sepstripsize=TIFFStripSize(input);
2368 sepstripcount=TIFFNumberOfStrips(input);
2369
2370 stripsize=sepstripsize*t2p->tiff_samplesperpixel;
2371 stripcount=sepstripcount/t2p->tiff_samplesperpixel;
2372
2373 buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2374 if(buffer==NULL){
2375 TIFFError(TIFF2PDF_MODULE,
2376 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2377 (unsigned long) t2p->tiff_datasize,
2378 TIFFFileName(input));
2379 t2p->t2p_error = T2P_ERR_ERROR;
2380 return(0);
2381 }
2382 memset(buffer, 0, t2p->tiff_datasize);
2383 samplebuffer = (unsigned char*) _TIFFmalloc(stripsize);
2384 if(samplebuffer==NULL){
2385 TIFFError(TIFF2PDF_MODULE,
2386 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2387 (unsigned long) t2p->tiff_datasize,
2388 TIFFFileName(input));
2389 t2p->t2p_error = T2P_ERR_ERROR;
2390 return(0);
2391 }
2392 for(i=0;i<stripcount;i++){
2393 samplebufferoffset=0;
2394 for(j=0;j<t2p->tiff_samplesperpixel;j++){
2395 read =
2396 TIFFReadEncodedStrip(input,
2397 i + j*stripcount,
2398 (tdata_t) &(samplebuffer[samplebufferoffset]),
2399 sepstripsize);
2400 if(read==-1){
2401 TIFFError(TIFF2PDF_MODULE,
2402 "Error on decoding strip %u of %s",
2403 i + j*stripcount,
2404 TIFFFileName(input));
2405 _TIFFfree(buffer);
2406 t2p->t2p_error=T2P_ERR_ERROR;
2407 return(0);
2408 }
2409 samplebufferoffset+=read;
2410 }
2411 t2p_sample_planar_separate_to_contig(
2412 t2p,
2413 &(buffer[bufferoffset]),
2414 samplebuffer,
2415 samplebufferoffset);
2416 bufferoffset+=samplebufferoffset;
2417 }
2418 _TIFFfree(samplebuffer);
2419 goto dataready;
2420 }
2421
2422 buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2423 if(buffer==NULL){
2424 TIFFError(TIFF2PDF_MODULE,
2425 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2426 (unsigned long) t2p->tiff_datasize,
2427 TIFFFileName(input));
2428 t2p->t2p_error = T2P_ERR_ERROR;
2429 return(0);
2430 }
2431 memset(buffer, 0, t2p->tiff_datasize);
2432 stripsize=TIFFStripSize(input);
2433 stripcount=TIFFNumberOfStrips(input);
2434 for(i=0;i<stripcount;i++){
2435 read =
2436 TIFFReadEncodedStrip(input,
2437 i,
2438 (tdata_t) &buffer[bufferoffset],
2439 stripsize);
2440 if(read==-1){
2441 TIFFError(TIFF2PDF_MODULE,
2442 "Error on decoding strip %u of %s",
2443 i,
2444 TIFFFileName(input));
2445 _TIFFfree(samplebuffer);
2446 _TIFFfree(buffer);
2447 t2p->t2p_error=T2P_ERR_ERROR;
2448 return(0);
2449 }
2450 bufferoffset+=read;
2451 }
2452
2453 if(t2p->pdf_sample & T2P_SAMPLE_REALIZE_PALETTE){
2454 // FIXME: overflow?
2455 samplebuffer=(unsigned char*)_TIFFrealloc(
2456 (tdata_t) buffer,
2457 t2p->tiff_datasize * t2p->tiff_samplesperpixel);
2458 if(samplebuffer==NULL){
2459 TIFFError(TIFF2PDF_MODULE,
2460 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2461 (unsigned long) t2p->tiff_datasize,
2462 TIFFFileName(input));
2463 t2p->t2p_error = T2P_ERR_ERROR;
2464 _TIFFfree(buffer);
2465 } else {
2466 buffer=samplebuffer;
2467 t2p->tiff_datasize *= t2p->tiff_samplesperpixel;
2468 }
2469 t2p_sample_realize_palette(t2p, buffer);
2470 }
2471
2472 if(t2p->pdf_sample & T2P_SAMPLE_RGBA_TO_RGB){
2473 t2p->tiff_datasize=t2p_sample_rgba_to_rgb(
2474 (tdata_t)buffer,
2475 t2p->tiff_width*t2p->tiff_length);
2476 }
2477
2478 if(t2p->pdf_sample & T2P_SAMPLE_RGBAA_TO_RGB){
2479 t2p->tiff_datasize=t2p_sample_rgbaa_to_rgb(
2480 (tdata_t)buffer,
2481 t2p->tiff_width*t2p->tiff_length);
2482 }
2483
2484 if(t2p->pdf_sample & T2P_SAMPLE_YCBCR_TO_RGB){
2485 samplebuffer=(unsigned char*)_TIFFrealloc(
2486 (tdata_t)buffer,
2487 t2p->tiff_width*t2p->tiff_length*4);
2488 if(samplebuffer==NULL){
2489 TIFFError(TIFF2PDF_MODULE,
2490 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2491 (unsigned long) t2p->tiff_datasize,
2492 TIFFFileName(input));
2493 t2p->t2p_error = T2P_ERR_ERROR;
2494 _TIFFfree(buffer);
2495 return(0);
2496 } else {
2497 buffer=samplebuffer;
2498 }
2499 if(!TIFFReadRGBAImageOriented(
2500 input,
2501 t2p->tiff_width,
2502 t2p->tiff_length,
2503 (uint32*)buffer,
2504 ORIENTATION_TOPLEFT,
2505 0)){
2506 TIFFError(TIFF2PDF_MODULE,
2507 "Can't use TIFFReadRGBAImageOriented to extract RGB image from %s",
2508 TIFFFileName(input));
2509 t2p->t2p_error = T2P_ERR_ERROR;
2510 return(0);
2511 }
2512 t2p->tiff_datasize=t2p_sample_abgr_to_rgb(
2513 (tdata_t) buffer,
2514 t2p->tiff_width*t2p->tiff_length);
2515
2516 }
2517
2518 if(t2p->pdf_sample & T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED){
2519 t2p->tiff_datasize=t2p_sample_lab_signed_to_unsigned(
2520 (tdata_t)buffer,
2521 t2p->tiff_width*t2p->tiff_length);
2522 }
2523 }
2524
2525 dataready:
2526
2527 t2p_disable(output);
2528 TIFFSetField(output, TIFFTAG_PHOTOMETRIC, t2p->tiff_photometric);
2529 TIFFSetField(output, TIFFTAG_BITSPERSAMPLE, t2p->tiff_bitspersample);
2530 TIFFSetField(output, TIFFTAG_SAMPLESPERPIXEL, t2p->tiff_samplesperpixel);
2531 TIFFSetField(output, TIFFTAG_IMAGEWIDTH, t2p->tiff_width);
2532 TIFFSetField(output, TIFFTAG_IMAGELENGTH, t2p->tiff_length);
2533 TIFFSetField(output, TIFFTAG_ROWSPERSTRIP, t2p->tiff_length);
2534 TIFFSetField(output, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
2535 TIFFSetField(output, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
2536
2537 switch(t2p->pdf_compression){
2538 case T2P_COMPRESS_NONE:
2539 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
2540 break;
2541 #ifdef CCITT_SUPPORT
2542 case T2P_COMPRESS_G4:
2543 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
2544 break;
2545 #endif
2546 #ifdef JPEG_SUPPORT
2547 case T2P_COMPRESS_JPEG:
2548 if(t2p->tiff_photometric==PHOTOMETRIC_YCBCR) {
2549 uint16 hor = 0, ver = 0;
2550 if (TIFFGetField(input, TIFFTAG_YCBCRSUBSAMPLING, &hor, &ver) !=0 ) {
2551 if(hor != 0 && ver != 0){
2552 TIFFSetField(output, TIFFTAG_YCBCRSUBSAMPLING, hor, ver);
2553 }
2554 }
2555 if(TIFFGetField(input, TIFFTAG_REFERENCEBLACKWHITE, &xfloatp)!=0){
2556 TIFFSetField(output, TIFFTAG_REFERENCEBLACKWHITE, xfloatp);
2557 }
2558 }
2559 if(TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_JPEG)==0){
2560 TIFFError(TIFF2PDF_MODULE,
2561 "Unable to use JPEG compression for input %s and output %s",
2562 TIFFFileName(input),
2563 TIFFFileName(output));
2564 _TIFFfree(buffer);
2565 t2p->t2p_error = T2P_ERR_ERROR;
2566 return(0);
2567 }
2568 TIFFSetField(output, TIFFTAG_JPEGTABLESMODE, 0);
2569
2570 if(t2p->pdf_colorspace & (T2P_CS_RGB | T2P_CS_LAB)){
2571 TIFFSetField(output, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
2572 if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR){
2573 TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
2574 } else {
2575 TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
2576 }
2577 }
2578 if(t2p->pdf_colorspace & T2P_CS_GRAY){
2579 (void)0;
2580 }
2581 if(t2p->pdf_colorspace & T2P_CS_CMYK){
2582 (void)0;
2583 }
2584 if(t2p->pdf_defaultcompressionquality != 0){
2585 TIFFSetField(output,
2586 TIFFTAG_JPEGQUALITY,
2587 t2p->pdf_defaultcompressionquality);
2588 }
2589
2590 break;
2591 #endif
2592 #ifdef ZIP_SUPPORT
2593 case T2P_COMPRESS_ZIP:
2594 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
2595 if(t2p->pdf_defaultcompressionquality%100 != 0){
2596 TIFFSetField(output,
2597 TIFFTAG_PREDICTOR,
2598 t2p->pdf_defaultcompressionquality % 100);
2599 }
2600 if(t2p->pdf_defaultcompressionquality/100 != 0){
2601 TIFFSetField(output,
2602 TIFFTAG_ZIPQUALITY,
2603 (t2p->pdf_defaultcompressionquality / 100));
2604 }
2605 break;
2606 #endif
2607 default:
2608 break;
2609 }
2610
2611 t2p_enable(output);
2612 t2p->outputwritten = 0;
2613 #ifdef JPEG_SUPPORT
2614 if(t2p->pdf_compression == T2P_COMPRESS_JPEG
2615 && t2p->tiff_photometric == PHOTOMETRIC_YCBCR){
2616 bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t)0,
2617 buffer,
2618 stripsize * stripcount);
2619 } else
2620 #endif
2621 {
2622 bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t)0,
2623 buffer,
2624 t2p->tiff_datasize);
2625 }
2626 if (buffer != NULL) {
2627 _TIFFfree(buffer);
2628 buffer=NULL;
2629 }
2630
2631 if (bufferoffset == (tsize_t)-1) {
2632 TIFFError(TIFF2PDF_MODULE,
2633 "Error writing encoded strip to output PDF %s",
2634 TIFFFileName(output));
2635 t2p->t2p_error = T2P_ERR_ERROR;
2636 return(0);
2637 }
2638
2639 written = t2p->outputwritten;
2640 return(written);
2641 }
2642
2643 /*
2644 * This function reads the raster image data from the input TIFF for an image
2645 * tile and writes the data to the output PDF XObject image dictionary stream
2646 * for the tile. It returns the amount written or zero on error.
2647 */
2648
2649 tsize_t t2p_readwrite_pdf_image_tile(T2P* t2p, TIFF* input, TIFF* output, ttile_t tile){
2650
2651 uint16 edge=0;
2652 tsize_t written=0;
2653 unsigned char* buffer=NULL;
2654 tsize_t bufferoffset=0;
2655 unsigned char* samplebuffer=NULL;
2656 tsize_t samplebufferoffset=0;
2657 tsize_t read=0;
2658 uint16 i=0;
2659 ttile_t tilecount=0;
2660 tsize_t tilesize=0;
2661 ttile_t septilecount=0;
2662 tsize_t septilesize=0;
2663 #ifdef JPEG_SUPPORT
2664 unsigned char* jpt;
2665 float* xfloatp;
2666 uint32 xuint32=0;
2667 #endif
2668
2669 /* Fail if prior error (in particular, can't trust tiff_datasize) */
2670 if (t2p->t2p_error != T2P_ERR_OK)
2671 return(0);
2672
2673 edge |= t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
2674 edge |= t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
2675
2676 if( (t2p->pdf_transcode == T2P_TRANSCODE_RAW) && ((edge == 0)
2677 #if defined(JPEG_SUPPORT) || defined(OJPEG_SUPPORT)
2678 || (t2p->pdf_compression == T2P_COMPRESS_JPEG)
2679 #endif
2680 )
2681 ){
2682 #ifdef CCITT_SUPPORT
2683 if(t2p->pdf_compression == T2P_COMPRESS_G4){
2684 buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2685 if(buffer==NULL){
2686 TIFFError(TIFF2PDF_MODULE,
2687 "Can't allocate %lu bytes of memory "
2688 "for t2p_readwrite_pdf_image_tile, %s",
2689 (unsigned long) t2p->tiff_datasize,
2690 TIFFFileName(input));
2691 t2p->t2p_error = T2P_ERR_ERROR;
2692 return(0);
2693 }
2694 TIFFReadRawTile(input, tile, (tdata_t) buffer, t2p->tiff_datasize);
2695 if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
2696 TIFFReverseBits(buffer, t2p->tiff_datasize);
2697 }
2698 t2pWriteFile(output, (tdata_t) buffer, t2p->tiff_datasize);
2699 _TIFFfree(buffer);
2700 return(t2p->tiff_datasize);
2701 }
2702 #endif
2703 #ifdef ZIP_SUPPORT
2704 if(t2p->pdf_compression == T2P_COMPRESS_ZIP){
2705 buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2706 if(buffer==NULL){
2707 TIFFError(TIFF2PDF_MODULE,
2708 "Can't allocate %lu bytes of memory "
2709 "for t2p_readwrite_pdf_image_tile, %s",
2710 (unsigned long) t2p->tiff_datasize,
2711 TIFFFileName(input));
2712 t2p->t2p_error = T2P_ERR_ERROR;
2713 return(0);
2714 }
2715 TIFFReadRawTile(input, tile, (tdata_t) buffer, t2p->tiff_datasize);
2716 if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
2717 TIFFReverseBits(buffer, t2p->tiff_datasize);
2718 }
2719 t2pWriteFile(output, (tdata_t) buffer, t2p->tiff_datasize);
2720 _TIFFfree(buffer);
2721 return(t2p->tiff_datasize);
2722 }
2723 #endif
2724 #ifdef OJPEG_SUPPORT
2725 if(t2p->tiff_compression == COMPRESSION_OJPEG){
2726 if(! t2p->pdf_ojpegdata){
2727 TIFFError(TIFF2PDF_MODULE,
2728 "No support for OJPEG image %s with "
2729 "bad tables",
2730 TIFFFileName(input));
2731 t2p->t2p_error = T2P_ERR_ERROR;
2732 return(0);
2733 }
2734 buffer=(unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2735 if(buffer==NULL){
2736 TIFFError(TIFF2PDF_MODULE,
2737 "Can't allocate %lu bytes of memory "
2738 "for t2p_readwrite_pdf_image, %s",
2739 (unsigned long) t2p->tiff_datasize,
2740 TIFFFileName(input));
2741 t2p->t2p_error = T2P_ERR_ERROR;
2742 return(0);
2743 }
2744 _TIFFmemcpy(buffer, t2p->pdf_ojpegdata, t2p->pdf_ojpegdatalength);
2745 if(edge!=0){
2746 if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile)){
2747 buffer[7]=
2748 (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength >> 8) & 0xff;
2749 buffer[8]=
2750 (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength ) & 0xff;
2751 }
2752 if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile)){
2753 buffer[9]=
2754 (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth >> 8) & 0xff;
2755 buffer[10]=
2756 (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth ) & 0xff;
2757 }
2758 }
2759 bufferoffset=t2p->pdf_ojpegdatalength;
2760 bufferoffset+=TIFFReadRawTile(input,
2761 tile,
2762 (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2763 -1);
2764 ((unsigned char*)buffer)[bufferoffset++]=0xff;
2765 ((unsigned char*)buffer)[bufferoffset++]=0xd9;
2766 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2767 _TIFFfree(buffer);
2768 return(bufferoffset);
2769 }
2770 #endif
2771 #ifdef JPEG_SUPPORT
2772 if(t2p->tiff_compression == COMPRESSION_JPEG){
2773 unsigned char table_end[2];
2774 uint32 count = 0;
2775 buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2776 if(buffer==NULL){
2777 TIFFError(TIFF2PDF_MODULE,
2778 "Can't allocate %lu bytes of memory "
2779 "for t2p_readwrite_pdf_image_tile, %s",
2780 t2p->tiff_datasize,
2781 TIFFFileName(input));
2782 t2p->t2p_error = T2P_ERR_ERROR;
2783 return(0);
2784 }
2785 if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0) {
2786 if (count > 0) {
2787 _TIFFmemcpy(buffer, jpt, count);
2788 bufferoffset += count - 2;
2789 table_end[0] = buffer[bufferoffset-2];
2790 table_end[1] = buffer[bufferoffset-1];
2791 }
2792 if (count > 0) {
2793 xuint32 = bufferoffset;
2794 bufferoffset += TIFFReadRawTile(
2795 input,
2796 tile,
2797 (tdata_t) &(((unsigned char*)buffer)[bufferoffset-2]),
2798 -1);
2799 buffer[xuint32-2]=table_end[0];
2800 buffer[xuint32-1]=table_end[1];
2801 } else {
2802 bufferoffset += TIFFReadRawTile(
2803 input,
2804 tile,
2805 (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2806 -1);
2807 }
2808 }
2809 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2810 _TIFFfree(buffer);
2811 return(bufferoffset);
2812 }
2813 #endif
2814 (void)0;
2815 }
2816
2817 if(t2p->pdf_sample==T2P_SAMPLE_NOTHING){
2818 buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2819 if(buffer==NULL){
2820 TIFFError(TIFF2PDF_MODULE,
2821 "Can't allocate %lu bytes of memory for "
2822 "t2p_readwrite_pdf_image_tile, %s",
2823 (unsigned long) t2p->tiff_datasize,
2824 TIFFFileName(input));
2825 t2p->t2p_error = T2P_ERR_ERROR;
2826 return(0);
2827 }
2828
2829 read = TIFFReadEncodedTile(
2830 input,
2831 tile,
2832 (tdata_t) &buffer[bufferoffset],
2833 t2p->tiff_datasize);
2834 if(read==-1){
2835 TIFFError(TIFF2PDF_MODULE,
2836 "Error on decoding tile %u of %s",
2837 tile,
2838 TIFFFileName(input));
2839 _TIFFfree(buffer);
2840 t2p->t2p_error=T2P_ERR_ERROR;
2841 return(0);
2842 }
2843
2844 } else {
2845
2846 if(t2p->pdf_sample == T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG){
2847 septilesize=TIFFTileSize(input);
2848 septilecount=TIFFNumberOfTiles(input);
2849 tilesize=septilesize*t2p->tiff_samplesperpixel;
2850 tilecount=septilecount/t2p->tiff_samplesperpixel;
2851 buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2852 if(buffer==NULL){
2853 TIFFError(TIFF2PDF_MODULE,
2854 "Can't allocate %lu bytes of memory "
2855 "for t2p_readwrite_pdf_image_tile, %s",
2856 (unsigned long) t2p->tiff_datasize,
2857 TIFFFileName(input));
2858 t2p->t2p_error = T2P_ERR_ERROR;
2859 return(0);
2860 }
2861 samplebuffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2862 if(samplebuffer==NULL){
2863 TIFFError(TIFF2PDF_MODULE,
2864 "Can't allocate %lu bytes of memory "
2865 "for t2p_readwrite_pdf_image_tile, %s",
2866 (unsigned long) t2p->tiff_datasize,
2867 TIFFFileName(input));
2868 t2p->t2p_error = T2P_ERR_ERROR;
2869 return(0);
2870 }
2871 samplebufferoffset=0;
2872 for(i=0;i<t2p->tiff_samplesperpixel;i++){
2873 read =
2874 TIFFReadEncodedTile(input,
2875 tile + i*tilecount,
2876 (tdata_t) &(samplebuffer[samplebufferoffset]),
2877 septilesize);
2878 if(read==-1){
2879 TIFFError(TIFF2PDF_MODULE,
2880 "Error on decoding tile %u of %s",
2881 tile + i*tilecount,
2882 TIFFFileName(input));
2883 _TIFFfree(samplebuffer);
2884 _TIFFfree(buffer);
2885 t2p->t2p_error=T2P_ERR_ERROR;
2886 return(0);
2887 }
2888 samplebufferoffset+=read;
2889 }
2890 t2p_sample_planar_separate_to_contig(
2891 t2p,
2892 &(buffer[bufferoffset]),
2893 samplebuffer,
2894 samplebufferoffset);
2895 bufferoffset+=samplebufferoffset;
2896 _TIFFfree(samplebuffer);
2897 }
2898
2899 if(buffer==NULL){
2900 buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2901 if(buffer==NULL){
2902 TIFFError(TIFF2PDF_MODULE,
2903 "Can't allocate %lu bytes of memory "
2904 "for t2p_readwrite_pdf_image_tile, %s",
2905 (unsigned long) t2p->tiff_datasize,
2906 TIFFFileName(input));
2907 t2p->t2p_error = T2P_ERR_ERROR;
2908 return(0);
2909 }
2910 read = TIFFReadEncodedTile(
2911 input,
2912 tile,
2913 (tdata_t) &buffer[bufferoffset],
2914 t2p->tiff_datasize);
2915 if(read==-1){
2916 TIFFError(TIFF2PDF_MODULE,
2917 "Error on decoding tile %u of %s",
2918 tile,
2919 TIFFFileName(input));
2920 _TIFFfree(buffer);
2921 t2p->t2p_error=T2P_ERR_ERROR;
2922 return(0);
2923 }
2924 }
2925
2926 if(t2p->pdf_sample & T2P_SAMPLE_RGBA_TO_RGB){
2927 t2p->tiff_datasize=t2p_sample_rgba_to_rgb(
2928 (tdata_t)buffer,
2929 t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth
2930 *t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2931 }
2932
2933 if(t2p->pdf_sample & T2P_SAMPLE_RGBAA_TO_RGB){
2934 t2p->tiff_datasize=t2p_sample_rgbaa_to_rgb(
2935 (tdata_t)buffer,
2936 t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth
2937 *t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2938 }
2939
2940 if(t2p->pdf_sample & T2P_SAMPLE_YCBCR_TO_RGB){
2941 TIFFError(TIFF2PDF_MODULE,
2942 "No support for YCbCr to RGB in tile for %s",
2943 TIFFFileName(input));
2944 _TIFFfree(buffer);
2945 t2p->t2p_error = T2P_ERR_ERROR;
2946 return(0);
2947 }
2948
2949 if(t2p->pdf_sample & T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED){
2950 t2p->tiff_datasize=t2p_sample_lab_signed_to_unsigned(
2951 (tdata_t)buffer,
2952 t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth
2953 *t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2954 }
2955 }
2956
2957 if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile) != 0){
2958 t2p_tile_collapse_left(
2959 buffer,
2960 TIFFTileRowSize(input),
2961 t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth,
2962 t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth,
2963 t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2964 }
2965
2966
2967 t2p_disable(output);
2968 TIFFSetField(output, TIFFTAG_PHOTOMETRIC, t2p->tiff_photometric);
2969 TIFFSetField(output, TIFFTAG_BITSPERSAMPLE, t2p->tiff_bitspersample);
2970 TIFFSetField(output, TIFFTAG_SAMPLESPERPIXEL, t2p->tiff_samplesperpixel);
2971 if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile) == 0){
2972 TIFFSetField(
2973 output,
2974 TIFFTAG_IMAGEWIDTH,
2975 t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
2976 } else {
2977 TIFFSetField(
2978 output,
2979 TIFFTAG_IMAGEWIDTH,
2980 t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
2981 }
2982 if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile) == 0){
2983 TIFFSetField(
2984 output,
2985 TIFFTAG_IMAGELENGTH,
2986 t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2987 TIFFSetField(
2988 output,
2989 TIFFTAG_ROWSPERSTRIP,
2990 t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2991 } else {
2992 TIFFSetField(
2993 output,
2994 TIFFTAG_IMAGELENGTH,
2995 t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
2996 TIFFSetField(
2997 output,
2998 TIFFTAG_ROWSPERSTRIP,
2999 t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
3000 }
3001 TIFFSetField(output, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
3002 TIFFSetField(output, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
3003
3004 switch(t2p->pdf_compression){
3005 case T2P_COMPRESS_NONE:
3006 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
3007 break;
3008 #ifdef CCITT_SUPPORT
3009 case T2P_COMPRESS_G4:
3010 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
3011 break;
3012 #endif
3013 #ifdef JPEG_SUPPORT
3014 case T2P_COMPRESS_JPEG:
3015 if (t2p->tiff_photometric==PHOTOMETRIC_YCBCR) {
3016 uint16 hor = 0, ver = 0;
3017 if (TIFFGetField(input, TIFFTAG_YCBCRSUBSAMPLING, &hor, &ver)!=0) {
3018 if (hor != 0 && ver != 0) {
3019 TIFFSetField(output, TIFFTAG_YCBCRSUBSAMPLING, hor, ver);
3020 }
3021 }
3022 if(TIFFGetField(input, TIFFTAG_REFERENCEBLACKWHITE, &xfloatp)!=0){
3023 TIFFSetField(output, TIFFTAG_REFERENCEBLACKWHITE, xfloatp);
3024 }
3025 }
3026 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
3027 TIFFSetField(output, TIFFTAG_JPEGTABLESMODE, 0); /* JPEGTABLESMODE_NONE */
3028 if(t2p->pdf_colorspace & (T2P_CS_RGB | T2P_CS_LAB)){
3029 TIFFSetField(output, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
3030 if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR){
3031 TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
3032 } else {
3033 TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
3034 }
3035 }
3036 if(t2p->pdf_colorspace & T2P_CS_GRAY){
3037 (void)0;
3038 }
3039 if(t2p->pdf_colorspace & T2P_CS_CMYK){
3040 (void)0;
3041 }
3042 if(t2p->pdf_defaultcompressionquality != 0){
3043 TIFFSetField(output,
3044 TIFFTAG_JPEGQUALITY,
3045 t2p->pdf_defaultcompressionquality);
3046 }
3047 break;
3048 #endif
3049 #ifdef ZIP_SUPPORT
3050 case T2P_COMPRESS_ZIP:
3051 TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
3052 if(t2p->pdf_defaultcompressionquality%100 != 0){
3053 TIFFSetField(output,
3054 TIFFTAG_PREDICTOR,
3055 t2p->pdf_defaultcompressionquality % 100);
3056 }
3057 if(t2p->pdf_defaultcompressionquality/100 != 0){
3058 TIFFSetField(output,
3059 TIFFTAG_ZIPQUALITY,
3060 (t2p->pdf_defaultcompressionquality / 100));
3061 }
3062 break;
3063 #endif
3064 default:
3065 break;
3066 }
3067
3068 t2p_enable(output);
3069 t2p->outputwritten = 0;
3070 bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t) 0, buffer,
3071 TIFFStripSize(output));
3072 if (buffer != NULL) {
3073 _TIFFfree(buffer);
3074 buffer = NULL;
3075 }
3076 if (bufferoffset == -1) {
3077 TIFFError(TIFF2PDF_MODULE,
3078 "Error writing encoded tile to output PDF %s",
3079 TIFFFileName(output));
3080 t2p->t2p_error = T2P_ERR_ERROR;
3081 return(0);
3082 }
3083
3084 written = t2p->outputwritten;
3085
3086 return(written);
3087 }
3088
3089 #ifdef OJPEG_SUPPORT
3090 int t2p_process_ojpeg_tables(T2P* t2p, TIFF* input){
3091 uint16 proc=0;
3092 void* q;
3093 uint32 q_length=0;
3094 void* dc;
3095 uint32 dc_length=0;
3096 void* ac;
3097 uint32 ac_length=0;
3098 uint16* lp;
3099 uint16* pt;
3100 uint16 h_samp=1;
3101 uint16 v_samp=1;
3102 unsigned char* ojpegdata;
3103 uint16 table_count;
3104 uint32 offset_table;
3105 uint32 offset_ms_l;
3106 uint32 code_count;
3107 uint32 i=0;
3108 uint32 dest=0;
3109 uint16 ri=0;
3110 uint32 rows=0;
3111
3112 if(!TIFFGetField(input, TIFFTAG_JPEGPROC, &proc)){
3113 TIFFError(TIFF2PDF_MODULE,
3114 "Missing JPEGProc field in OJPEG image %s",
3115 TIFFFileName(input));
3116 t2p->t2p_error = T2P_ERR_ERROR;
3117 return(0);
3118 }
3119 if(proc!=JPEGPROC_BASELINE && proc!=JPEGPROC_LOSSLESS){
3120 TIFFError(TIFF2PDF_MODULE,
3121 "Bad JPEGProc field in OJPEG image %s",
3122 TIFFFileName(input));
3123 t2p->t2p_error = T2P_ERR_ERROR;
3124 return(0);
3125 }
3126 if(!TIFFGetField(input, TIFFTAG_JPEGQTABLES, &q_length, &q)){
3127 TIFFError(TIFF2PDF_MODULE,
3128 "Missing JPEGQTables field in OJPEG image %s",
3129 TIFFFileName(input));
3130 t2p->t2p_error = T2P_ERR_ERROR;
3131 return(0);
3132 }
3133 if(q_length < (64U * t2p->tiff_samplesperpixel)){
3134 TIFFError(TIFF2PDF_MODULE,
3135 "Bad JPEGQTables field in OJPEG image %s",
3136 TIFFFileName(input));
3137 t2p->t2p_error = T2P_ERR_ERROR;
3138 return(0);
3139 }
3140 if(!TIFFGetField(input, TIFFTAG_JPEGDCTABLES, &dc_length, &dc)){
3141 TIFFError(TIFF2PDF_MODULE,
3142 "Missing JPEGDCTables field in OJPEG image %s",
3143 TIFFFileName(input));
3144 t2p->t2p_error = T2P_ERR_ERROR;
3145 return(0);
3146 }
3147 if(proc==JPEGPROC_BASELINE){
3148 if(!TIFFGetField(input, TIFFTAG_JPEGACTABLES, &ac_length, &ac)){
3149 TIFFError(TIFF2PDF_MODULE,
3150 "Missing JPEGACTables field in OJPEG image %s",
3151 TIFFFileName(input));
3152 t2p->t2p_error = T2P_ERR_ERROR;
3153 return(0);
3154 }
3155 } else {
3156 if(!TIFFGetField(input, TIFFTAG_JPEGLOSSLESSPREDICTORS, &lp)){
3157 TIFFError(TIFF2PDF_MODULE,
3158 "Missing JPEGLosslessPredictors field in OJPEG image %s",
3159 TIFFFileName(input));
3160 t2p->t2p_error = T2P_ERR_ERROR;
3161 return(0);
3162 }
3163 if(!TIFFGetField(input, TIFFTAG_JPEGPOINTTRANSFORM, &pt)){
3164 TIFFError(TIFF2PDF_MODULE,
3165 "Missing JPEGPointTransform field in OJPEG image %s",
3166 TIFFFileName(input));
3167 t2p->t2p_error = T2P_ERR_ERROR;
3168 return(0);
3169 }
3170 }
3171 if(!TIFFGetField(input, TIFFTAG_YCBCRSUBSAMPLING, &h_samp, &v_samp)){
3172 h_samp=1;
3173 v_samp=1;
3174 }
3175 if(t2p->pdf_ojpegdata != NULL){
3176 _TIFFfree(t2p->pdf_ojpegdata);
3177 t2p->pdf_ojpegdata=NULL;
3178 }
3179 t2p->pdf_ojpegdata = _TIFFmalloc(2048);
3180 if(t2p->pdf_ojpegdata == NULL){
3181 TIFFError(TIFF2PDF_MODULE,
3182 "Can't allocate %u bytes of memory for t2p_process_ojpeg_tables, %s",
3183 2048,
3184 TIFFFileName(input));
3185 t2p->t2p_error = T2P_ERR_ERROR;
3186 return(0);
3187 }
3188 _TIFFmemset(t2p->pdf_ojpegdata, 0x00, 2048);
3189 t2p->pdf_ojpegdatalength = 0;
3190 table_count=t2p->tiff_samplesperpixel;
3191 if(proc==JPEGPROC_BASELINE){
3192 if(table_count>2) table_count=2;
3193 }
3194 ojpegdata=(unsigned char*)t2p->pdf_ojpegdata;
3195 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3196 ojpegdata[t2p->pdf_ojpegdatalength++]=0xd8;
3197 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3198 if(proc==JPEGPROC_BASELINE){
3199 ojpegdata[t2p->pdf_ojpegdatalength++]=0xc0;
3200 } else {
3201 ojpegdata[t2p->pdf_ojpegdatalength++]=0xc3;
3202 }
3203 ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3204 ojpegdata[t2p->pdf_ojpegdatalength++]=(8 + 3*t2p->tiff_samplesperpixel);
3205 ojpegdata[t2p->pdf_ojpegdatalength++]=(t2p->tiff_bitspersample & 0xff);
3206 if(TIFFIsTiled(input)){
3207 ojpegdata[t2p->pdf_ojpegdatalength++]=
3208 (t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength >> 8) & 0xff;
3209 ojpegdata[t2p->pdf_ojpegdatalength++]=
3210 (t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength ) & 0xff;
3211 ojpegdata[t2p->pdf_ojpegdatalength++]=
3212 (t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth >> 8) & 0xff;
3213 ojpegdata[t2p->pdf_ojpegdatalength++]=
3214 (t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth ) & 0xff;
3215 } else {
3216 ojpegdata[t2p->pdf_ojpegdatalength++]=
3217 (t2p->tiff_length >> 8) & 0xff;
3218 ojpegdata[t2p->pdf_ojpegdatalength++]=
3219 (t2p->tiff_length ) & 0xff;
3220 ojpegdata[t2p->pdf_ojpegdatalength++]=
3221 (t2p->tiff_width >> 8) & 0xff;
3222 ojpegdata[t2p->pdf_ojpegdatalength++]=
3223 (t2p->tiff_width ) & 0xff;
3224 }
3225 ojpegdata[t2p->pdf_ojpegdatalength++]=(t2p->tiff_samplesperpixel & 0xff);
3226 for(i=0;i<t2p->tiff_samplesperpixel;i++){
3227 ojpegdata[t2p->pdf_ojpegdatalength++]=i;
3228 if(i==0){
3229 ojpegdata[t2p->pdf_ojpegdatalength] |= h_samp<<4 & 0xf0;;
3230 ojpegdata[t2p->pdf_ojpegdatalength++] |= v_samp & 0x0f;
3231 } else {
3232 ojpegdata[t2p->pdf_ojpegdatalength++]= 0x11;
3233 }
3234 ojpegdata[t2p->pdf_ojpegdatalength++]=i;
3235 }
3236 for(dest=0;dest<t2p->tiff_samplesperpixel;dest++){
3237 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3238 ojpegdata[t2p->pdf_ojpegdatalength++]=0xdb;
3239 ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3240 ojpegdata[t2p->pdf_ojpegdatalength++]=0x43;
3241 ojpegdata[t2p->pdf_ojpegdatalength++]=dest;
3242 _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength++]),
3243 &(((unsigned char*)q)[64*dest]), 64);
3244 t2p->pdf_ojpegdatalength+=64;
3245 }
3246 offset_table=0;
3247 for(dest=0;dest<table_count;dest++){
3248 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3249 ojpegdata[t2p->pdf_ojpegdatalength++]=0xc4;
3250 offset_ms_l=t2p->pdf_ojpegdatalength;
3251 t2p->pdf_ojpegdatalength+=2;
3252 ojpegdata[t2p->pdf_ojpegdatalength++]=dest & 0x0f;
3253 _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3254 &(((unsigned char*)dc)[offset_table]), 16);
3255 code_count=0;
3256 offset_table+=16;
3257 for(i=0;i<16;i++){
3258 code_count+=ojpegdata[t2p->pdf_ojpegdatalength++];
3259 }
3260 ojpegdata[offset_ms_l]=((19+code_count)>>8) & 0xff;
3261 ojpegdata[offset_ms_l+1]=(19+code_count) & 0xff;
3262 _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3263 &(((unsigned char*)dc)[offset_table]), code_count);
3264 offset_table+=code_count;
3265 t2p->pdf_ojpegdatalength+=code_count;
3266 }
3267 if(proc==JPEGPROC_BASELINE){
3268 offset_table=0;
3269 for(dest=0;dest<table_count;dest++){
3270 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3271 ojpegdata[t2p->pdf_ojpegdatalength++]=0xc4;
3272 offset_ms_l=t2p->pdf_ojpegdatalength;
3273 t2p->pdf_ojpegdatalength+=2;
3274 ojpegdata[t2p->pdf_ojpegdatalength] |= 0x10;
3275 ojpegdata[t2p->pdf_ojpegdatalength++] |=dest & 0x0f;
3276 _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3277 &(((unsigned char*)ac)[offset_table]), 16);
3278 code_count=0;
3279 offset_table+=16;
3280 for(i=0;i<16;i++){
3281 code_count+=ojpegdata[t2p->pdf_ojpegdatalength++];
3282 }
3283 ojpegdata[offset_ms_l]=((19+code_count)>>8) & 0xff;
3284 ojpegdata[offset_ms_l+1]=(19+code_count) & 0xff;
3285 _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3286 &(((unsigned char*)ac)[offset_table]), code_count);
3287 offset_table+=code_count;
3288 t2p->pdf_ojpegdatalength+=code_count;
3289 }
3290 }
3291 if(TIFFNumberOfStrips(input)>1){
3292 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3293 ojpegdata[t2p->pdf_ojpegdatalength++]=0xdd;
3294 ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3295 ojpegdata[t2p->pdf_ojpegdatalength++]=0x04;
3296 h_samp*=8;
3297 v_samp*=8;
3298 ri=(t2p->tiff_width+h_samp-1) / h_samp;
3299 TIFFGetField(input, TIFFTAG_ROWSPERSTRIP, &rows);
3300 ri*=(rows+v_samp-1)/v_samp;
3301 ojpegdata[t2p->pdf_ojpegdatalength++]= (ri>>8) & 0xff;
3302 ojpegdata[t2p->pdf_ojpegdatalength++]= ri & 0xff;
3303 }
3304 ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3305 ojpegdata[t2p->pdf_ojpegdatalength++]=0xda;
3306 ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3307 ojpegdata[t2p->pdf_ojpegdatalength++]=(6 + 2*t2p->tiff_samplesperpixel);
3308 ojpegdata[t2p->pdf_ojpegdatalength++]=t2p->tiff_samplesperpixel & 0xff;
3309 for(i=0;i<t2p->tiff_samplesperpixel;i++){
3310 ojpegdata[t2p->pdf_ojpegdatalength++]= i & 0xff;
3311 if(proc==JPEGPROC_BASELINE){
3312 ojpegdata[t2p->pdf_ojpegdatalength] |=
3313 ( ( (i>(table_count-1U)) ? (table_count-1U) : i) << 4U) & 0xf0;
3314 ojpegdata[t2p->pdf_ojpegdatalength++] |=
3315 ( (i>(table_count-1U)) ? (table_count-1U) : i) & 0x0f;
3316 } else {
3317 ojpegdata[t2p->pdf_ojpegdatalength++] = (i << 4) & 0xf0;
3318 }
3319 }
3320 if(proc==JPEGPROC_BASELINE){
3321 t2p->pdf_ojpegdatalength++;
3322 ojpegdata[t2p->pdf_ojpegdatalength++]=0x3f;
3323 t2p->pdf_ojpegdatalength++;
3324 } else {
3325 ojpegdata[t2p->pdf_ojpegdatalength++]= (lp[0] & 0xff);
3326 t2p->pdf_ojpegdatalength++;
3327 ojpegdata[t2p->pdf_ojpegdatalength++]= (pt[0] & 0x0f);
3328 }
3329
3330 return(1);
3331 }
3332 #endif
3333
3334 #ifdef JPEG_SUPPORT
3335 int t2p_process_jpeg_strip(
3336 unsigned char* strip,
3337 tsize_t* striplength,
3338 unsigned char* buffer,
3339 tsize_t* bufferoffset,
3340 tstrip_t no,
3341 uint32 height){
3342
3343 tsize_t i=0;
3344 uint16 ri =0;
3345 uint16 v_samp=1;
3346 uint16 h_samp=1;
3347 int j=0;
3348
3349 i++;
3350
3351 while(i<(*striplength)){
3352 switch( strip[i] ){
3353 case 0xd8:
3354 /* SOI - start of image */
3355 _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), 2);
3356 *bufferoffset+=2;
3357 i+=2;
3358 break;
3359 case 0xc0:
3360 case 0xc1:
3361 case 0xc3:
3362 case 0xc9:
3363 case 0xca:
3364 if(no==0){
3365 _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3366 for(j=0;j<buffer[*bufferoffset+9];j++){
3367 if( (buffer[*bufferoffset+11+(2*j)]>>4) > h_samp)
3368 h_samp = (buffer[*bufferoffset+11+(2*j)]>>4);
3369 if( (buffer[*bufferoffset+11+(2*j)] & 0x0f) > v_samp)
3370 v_samp = (buffer[*bufferoffset+11+(2*j)] & 0x0f);
3371 }
3372 v_samp*=8;
3373 h_samp*=8;
3374 ri=((( ((uint16)(buffer[*bufferoffset+5])<<8) |
3375 (uint16)(buffer[*bufferoffset+6]) )+v_samp-1)/
3376 v_samp);
3377 ri*=((( ((uint16)(buffer[*bufferoffset+7])<<8) |
3378 (uint16)(buffer[*bufferoffset+8]) )+h_samp-1)/
3379 h_samp);
3380 buffer[*bufferoffset+5]=
3381 (unsigned char) ((height>>8) & 0xff);
3382 buffer[*bufferoffset+6]=
3383 (unsigned char) (height & 0xff);
3384 *bufferoffset+=strip[i+2]+2;
3385 i+=strip[i+2]+2;
3386
3387 buffer[(*bufferoffset)++]=0xff;
3388 buffer[(*bufferoffset)++]=0xdd;
3389 buffer[(*bufferoffset)++]=0x00;
3390 buffer[(*bufferoffset)++]=0x04;
3391 buffer[(*bufferoffset)++]=(ri >> 8) & 0xff;
3392 buffer[(*bufferoffset)++]= ri & 0xff;
3393 } else {
3394 i+=strip[i+2]+2;
3395 }
3396 break;
3397 case 0xc4:
3398 case 0xdb:
3399 _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3400 *bufferoffset+=strip[i+2]+2;
3401 i+=strip[i+2]+2;
3402 break;
3403 case 0xda:
3404 if(no==0){
3405 _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3406 *bufferoffset+=strip[i+2]+2;
3407 i+=strip[i+2]+2;
3408 } else {
3409 buffer[(*bufferoffset)++]=0xff;
3410 buffer[(*bufferoffset)++]=
3411 (unsigned char)(0xd0 | ((no-1)%8));
3412 i+=strip[i+2]+2;
3413 }
3414 _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), (*striplength)-i-1);
3415 *bufferoffset+=(*striplength)-i-1;
3416 return(1);
3417 default:
3418 i+=strip[i+2]+2;
3419 }
3420 }
3421
3422
3423 return(0);
3424 }
3425 #endif
3426
3427 /*
3428 This functions converts a tilewidth x tilelength buffer of samples into an edgetilewidth x
3429 tilelength buffer of samples.
3430 */
3431 void t2p_tile_collapse_left(
3432 tdata_t buffer,
3433 tsize_t scanwidth,
3434 uint32 tilewidth,
3435 uint32 edgetilewidth,
3436 uint32 tilelength){
3437
3438 uint32 i;
3439 tsize_t edgescanwidth=0;
3440
3441 edgescanwidth = (scanwidth * edgetilewidth + (tilewidth - 1))/ tilewidth;
3442 for(i=0;i<tilelength;i++){
3443 _TIFFmemcpy(
3444 &(((char*)buffer)[edgescanwidth*i]),
3445 &(((char*)buffer)[scanwidth*i]),
3446 edgescanwidth);
3447 }
3448
3449 return;
3450 }
3451
3452
3453 /*
3454 * This function calls TIFFWriteDirectory on the output after blanking its
3455 * output by replacing the read, write, and seek procedures with empty
3456 * implementations, then it replaces the original implementations.
3457 */
3458
3459 void
3460 t2p_write_advance_directory(T2P* t2p, TIFF* output)
3461 {
3462 t2p_disable(output);
3463 if(!TIFFWriteDirectory(output)){
3464 TIFFError(TIFF2PDF_MODULE,
3465 "Error writing virtual directory to output PDF %s",
3466 TIFFFileName(output));
3467 t2p->t2p_error = T2P_ERR_ERROR;
3468 return;
3469 }
3470 t2p_enable(output);
3471 return;
3472 }
3473
3474 tsize_t t2p_sample_planar_separate_to_contig(
3475 T2P* t2p,
3476 unsigned char* buffer,
3477 unsigned char* samplebuffer,
3478 tsize_t samplebuffersize){
3479
3480 tsize_t stride=0;
3481 tsize_t i=0;
3482 tsize_t j=0;
3483
3484 stride=samplebuffersize/t2p->tiff_samplesperpixel;
3485 for(i=0;i<stride;i++){
3486 for(j=0;j<t2p->tiff_samplesperpixel;j++){
3487 buffer[i*t2p->tiff_samplesperpixel + j] = samplebuffer[i + j*stride];
3488 }
3489 }
3490
3491 return(samplebuffersize);
3492 }
3493
3494 tsize_t t2p_sample_realize_palette(T2P* t2p, unsigned char* buffer){
3495
3496 uint32 sample_count=0;
3497 uint16 component_count=0;
3498 uint32 palette_offset=0;
3499 uint32 sample_offset=0;
3500 uint32 i=0;
3501 uint32 j=0;
3502 sample_count=t2p->tiff_width*t2p->tiff_length;
3503 component_count=t2p->tiff_samplesperpixel;
3504
3505 for(i=sample_count;i>0;i--){
3506 palette_offset=buffer[i-1] * component_count;
3507 sample_offset= (i-1) * component_count;
3508 for(j=0;j<component_count;j++){
3509 buffer[sample_offset+j]=t2p->pdf_palette[palette_offset+j];
3510 }
3511 }
3512
3513 return(0);
3514 }
3515
3516 /*
3517 This functions converts in place a buffer of ABGR interleaved data
3518 into RGB interleaved data, discarding A.
3519 */
3520
3521 tsize_t t2p_sample_abgr_to_rgb(tdata_t data, uint32 samplecount)
3522 {
3523 uint32 i=0;
3524 uint32 sample=0;
3525
3526 for(i=0;i<samplecount;i++){
3527 sample=((uint32*)data)[i];
3528 ((char*)data)[i*3]= (char) (sample & 0xff);
3529 ((char*)data)[i*3+1]= (char) ((sample>>8) & 0xff);
3530 ((char*)data)[i*3+2]= (char) ((sample>>16) & 0xff);
3531 }
3532
3533 return(i*3);
3534 }
3535
3536 /*
3537 * This functions converts in place a buffer of RGBA interleaved data
3538 * into RGB interleaved data, discarding A.
3539 */
3540
3541 tsize_t
3542 t2p_sample_rgbaa_to_rgb(tdata_t data, uint32 samplecount)
3543 {
3544 uint32 i;
3545
3546 for(i = 0; i < samplecount; i++)
3547 memcpy((uint8*)data + i * 3, (uint8*)data + i * 4, 3);
3548
3549 return(i * 3);
3550 }
3551
3552 /*
3553 * This functions converts in place a buffer of RGBA interleaved data
3554 * into RGB interleaved data, adding 255-A to each component sample.
3555 */
3556
3557 tsize_t
3558 t2p_sample_rgba_to_rgb(tdata_t data, uint32 samplecount)
3559 {
3560 uint32 i = 0;
3561 uint32 sample = 0;
3562 uint8 alpha = 0;
3563
3564 for (i = 0; i < samplecount; i++) {
3565 sample=((uint32*)data)[i];
3566 alpha=(uint8)((255 - ((sample >> 24) & 0xff)));
3567 ((uint8 *)data)[i * 3] = (uint8) ((sample >> 16) & 0xff) + alpha;
3568 ((uint8 *)data)[i * 3 + 1] = (uint8) ((sample >> 8) & 0xff) + alpha;
3569 ((uint8 *)data)[i * 3 + 2] = (uint8) (sample & 0xff) + alpha;
3570 }
3571
3572 return (i * 3);
3573 }
3574
3575 /*
3576 This function converts the a and b samples of Lab data from signed
3577 to unsigned.
3578 */
3579
3580 tsize_t t2p_sample_lab_signed_to_unsigned(tdata_t buffer, uint32 samplecount){
3581
3582 uint32 i=0;
3583
3584 for(i=0;i<samplecount;i++){
3585 if( (((unsigned char*)buffer)[(i*3)+1] & 0x80) !=0){
3586 ((unsigned char*)buffer)[(i*3)+1] =
3587 (unsigned char)(0x80 + ((char*)buffer)[(i*3)+1]);
3588 } else {
3589 ((unsigned char*)buffer)[(i*3)+1] |= 0x80;
3590 }
3591 if( (((unsigned char*)buffer)[(i*3)+2] & 0x80) !=0){
3592 ((unsigned char*)buffer)[(i*3)+2] =
3593 (unsigned char)(0x80 + ((char*)buffer)[(i*3)+2]);
3594 } else {
3595 ((unsigned char*)buffer)[(i*3)+2] |= 0x80;
3596 }
3597 }
3598
3599 return(samplecount*3);
3600 }
3601
3602 /*
3603 This function writes the PDF header to output.
3604 */
3605
3606 tsize_t t2p_write_pdf_header(T2P* t2p, TIFF* output){
3607
3608 tsize_t written=0;
3609 char buffer[16];
3610 int buflen=0;
3611
3612 buflen=sprintf(buffer, "%%PDF-%u.%u ", t2p->pdf_majorversion&0xff, t2p->pdf_minorversion&0xff);
3613 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3614 written += t2pWriteFile(output, (tdata_t)"\n%\342\343\317\323\n", 7);
3615
3616 return(written);
3617 }
3618
3619 /*
3620 This function writes the beginning of a PDF object to output.
3621 */
3622
3623 tsize_t t2p_write_pdf_obj_start(uint32 number, TIFF* output){
3624
3625 tsize_t written=0;
3626 char buffer[16];
3627 int buflen=0;
3628
3629 buflen=sprintf(buffer, "%lu", (unsigned long)number);
3630 written += t2pWriteFile(output, (tdata_t) buffer, buflen );
3631 written += t2pWriteFile(output, (tdata_t) " 0 obj\n", 7);
3632
3633 return(written);
3634 }
3635
3636 /*
3637 This function writes the end of a PDF object to output.
3638 */
3639
3640 tsize_t t2p_write_pdf_obj_end(TIFF* output){
3641
3642 tsize_t written=0;
3643
3644 written += t2pWriteFile(output, (tdata_t) "endobj\n", 7);
3645
3646 return(written);
3647 }
3648
3649 /*
3650 This function writes a PDF name object to output.
3651 */
3652
3653 tsize_t t2p_write_pdf_name(unsigned char* name, TIFF* output){
3654
3655 tsize_t written=0;
3656 uint32 i=0;
3657 char buffer[64];
3658 uint16 nextchar=0;
3659 size_t namelen=0;
3660
3661 namelen = strlen((char *)name);
3662 if (namelen>126) {
3663 namelen=126;
3664 }
3665 written += t2pWriteFile(output, (tdata_t) "/", 1);
3666 for (i=0;i<namelen;i++){
3667 if ( ((unsigned char)name[i]) < 0x21){
3668 sprintf(buffer, "#%.2X", name[i]);
3669 buffer[sizeof(buffer) - 1] = '\0';
3670 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3671 nextchar=1;
3672 }
3673 if ( ((unsigned char)name[i]) > 0x7E){
3674 sprintf(buffer, "#%.2X", name[i]);
3675 buffer[sizeof(buffer) - 1] = '\0';
3676 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3677 nextchar=1;
3678 }
3679 if (nextchar==0){
3680 switch (name[i]){
3681 case 0x23:
3682 sprintf(buffer, "#%.2X", name[i]);
3683 buffer[sizeof(buffer) - 1] = '\0';
3684 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3685 break;
3686 case 0x25:
3687 sprintf(buffer, "#%.2X", name[i]);
3688 buffer[sizeof(buffer) - 1] = '\0';
3689 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3690 break;
3691 case 0x28:
3692 sprintf(buffer, "#%.2X", name[i]);
3693 buffer[sizeof(buffer) - 1] = '\0';
3694 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3695 break;
3696 case 0x29:
3697 sprintf(buffer, "#%.2X", name[i]);
3698 buffer[sizeof(buffer) - 1] = '\0';
3699 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3700 break;
3701 case 0x2F:
3702 sprintf(buffer, "#%.2X", name[i]);
3703 buffer[sizeof(buffer) - 1] = '\0';
3704 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3705 break;
3706 case 0x3C:
3707 sprintf(buffer, "#%.2X", name[i]);
3708 buffer[sizeof(buffer) - 1] = '\0';
3709 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3710 break;
3711 case 0x3E:
3712 sprintf(buffer, "#%.2X", name[i]);
3713 buffer[sizeof(buffer) - 1] = '\0';
3714 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3715 break;
3716 case 0x5B:
3717 sprintf(buffer, "#%.2X", name[i]);
3718 buffer[sizeof(buffer) - 1] = '\0';
3719 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3720 break;
3721 case 0x5D:
3722 sprintf(buffer, "#%.2X", name[i]);
3723 buffer[sizeof(buffer) - 1] = '\0';
3724 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3725 break;
3726 case 0x7B:
3727 sprintf(buffer, "#%.2X", name[i]);
3728 buffer[sizeof(buffer) - 1] = '\0';
3729 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3730 break;
3731 case 0x7D:
3732 sprintf(buffer, "#%.2X", name[i]);
3733 buffer[sizeof(buffer) - 1] = '\0';
3734 written += t2pWriteFile(output, (tdata_t) buffer, 3);
3735 break;
3736 default:
3737 written += t2pWriteFile(output, (tdata_t) &name[i], 1);
3738 }
3739 }
3740 nextchar=0;
3741 }
3742 written += t2pWriteFile(output, (tdata_t) " ", 1);
3743
3744 return(written);
3745 }
3746
3747 /*
3748 * This function writes a PDF string object to output.
3749 */
3750
3751 tsize_t t2p_write_pdf_string(char* pdfstr, TIFF* output)
3752 {
3753 tsize_t written = 0;
3754 uint32 i = 0;
3755 char buffer[64];
3756 size_t len = 0;
3757
3758 len = strlen(pdfstr);
3759 written += t2pWriteFile(output, (tdata_t) "(", 1);
3760 for (i=0; i<len; i++) {
3761 if((pdfstr[i]&0x80) || (pdfstr[i]==127) || (pdfstr[i]<32)){
3762 snprintf(buffer, sizeof(buffer), "\\%.3o", ((unsigned char)pdfstr[i]));
3763 written += t2pWriteFile(output, (tdata_t)buffer, 4);
3764 } else {
3765 switch (pdfstr[i]){
3766 case 0x08:
3767 written += t2pWriteFile(output, (tdata_t) "\\b", 2);
3768 break;
3769 case 0x09:
3770 written += t2pWriteFile(output, (tdata_t) "\\t", 2);
3771 break;
3772 case 0x0A:
3773 written += t2pWriteFile(output, (tdata_t) "\\n", 2);
3774 break;
3775 case 0x0C:
3776 written += t2pWriteFile(output, (tdata_t) "\\f", 2);
3777 break;
3778 case 0x0D:
3779 written += t2pWriteFile(output, (tdata_t) "\\r", 2);
3780 break;
3781 case 0x28:
3782 written += t2pWriteFile(output, (tdata_t) "\\(", 2);
3783 break;
3784 case 0x29:
3785 written += t2pWriteFile(output, (tdata_t) "\\)", 2);
3786 break;
3787 case 0x5C:
3788 written += t2pWriteFile(output, (tdata_t) "\\\\", 2);
3789 break;
3790 default:
3791 written += t2pWriteFile(output, (tdata_t) &pdfstr[i], 1);
3792 }
3793 }
3794 }
3795 written += t2pWriteFile(output, (tdata_t) ") ", 1);
3796
3797 return(written);
3798 }
3799
3800
3801 /*
3802 This function writes a buffer of data to output.
3803 */
3804
3805 tsize_t t2p_write_pdf_stream(tdata_t buffer, tsize_t len, TIFF* output){
3806
3807 tsize_t written=0;
3808
3809 written += t2pWriteFile(output, (tdata_t) buffer, len);
3810
3811 return(written);
3812 }
3813
3814 /*
3815 This functions writes the beginning of a PDF stream to output.
3816 */
3817
3818 tsize_t t2p_write_pdf_stream_start(TIFF* output){
3819
3820 tsize_t written=0;
3821
3822 written += t2pWriteFile(output, (tdata_t) "stream\n", 7);
3823
3824 return(written);
3825 }
3826
3827 /*
3828 This function writes the end of a PDF stream to output.
3829 */
3830
3831 tsize_t t2p_write_pdf_stream_end(TIFF* output){
3832
3833 tsize_t written=0;
3834
3835 written += t2pWriteFile(output, (tdata_t) "\nendstream\n", 11);
3836
3837 return(written);
3838 }
3839
3840 /*
3841 This function writes a stream dictionary for a PDF stream to output.
3842 */
3843
3844 tsize_t t2p_write_pdf_stream_dict(tsize_t len, uint32 number, TIFF* output){
3845
3846 tsize_t written=0;
3847 char buffer[16];
3848 int buflen=0;
3849
3850 written += t2pWriteFile(output, (tdata_t) "/Length ", 8);
3851 if(len!=0){
3852 written += t2p_write_pdf_stream_length(len, output);
3853 } else {
3854 buflen=sprintf(buffer, "%lu", (unsigned long)number);
3855 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3856 written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
3857 }
3858
3859 return(written);
3860 }
3861
3862 /*
3863 This functions writes the beginning of a PDF stream dictionary to output.
3864 */
3865
3866 tsize_t t2p_write_pdf_stream_dict_start(TIFF* output){
3867
3868 tsize_t written=0;
3869
3870 written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
3871
3872 return(written);
3873 }
3874
3875 /*
3876 This function writes the end of a PDF stream dictionary to output.
3877 */
3878
3879 tsize_t t2p_write_pdf_stream_dict_end(TIFF* output){
3880
3881 tsize_t written=0;
3882
3883 written += t2pWriteFile(output, (tdata_t) " >>\n", 4);
3884
3885 return(written);
3886 }
3887
3888 /*
3889 This function writes a number to output.
3890 */
3891
3892 tsize_t t2p_write_pdf_stream_length(tsize_t len, TIFF* output){
3893
3894 tsize_t written=0;
3895 char buffer[16];
3896 int buflen=0;
3897
3898 buflen=sprintf(buffer, "%lu", (unsigned long)len);
3899 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3900 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3901
3902 return(written);
3903 }
3904
3905 /*
3906 * This function writes the PDF Catalog structure to output.
3907 */
3908
3909 tsize_t t2p_write_pdf_catalog(T2P* t2p, TIFF* output)
3910 {
3911 tsize_t written = 0;
3912 char buffer[16];
3913 int buflen = 0;
3914
3915 written += t2pWriteFile(output,
3916 (tdata_t)"<< \n/Type /Catalog \n/Pages ",
3917 27);
3918 buflen = snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)t2p->pdf_pages);
3919 written += t2pWriteFile(output, (tdata_t) buffer,
3920 TIFFmin((size_t)buflen, sizeof(buffer) - 1));
3921 written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
3922 if(t2p->pdf_fitwindow){
3923 written += t2pWriteFile(output,
3924 (tdata_t) "/ViewerPreferences <</FitWindow true>>\n",
3925 39);
3926 }
3927 written += t2pWriteFile(output, (tdata_t)">>\n", 3);
3928
3929 return(written);
3930 }
3931
3932 /*
3933 This function writes the PDF Info structure to output.
3934 */
3935
3936 tsize_t t2p_write_pdf_info(T2P* t2p, TIFF* input, TIFF* output)
3937 {
3938 tsize_t written = 0;
3939 char* info;
3940 char buffer[512];
3941
3942 if(t2p->pdf_datetime[0] == '\0')
3943 t2p_pdf_tifftime(t2p, input);
3944 if (strlen(t2p->pdf_datetime) > 0) {
3945 written += t2pWriteFile(output, (tdata_t) "<< \n/CreationDate ", 18);
3946 written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3947 written += t2pWriteFile(output, (tdata_t) "\n/ModDate ", 10);
3948 written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3949 }
3950 written += t2pWriteFile(output, (tdata_t) "\n/Producer ", 11);
3951 _TIFFmemset((tdata_t)buffer, 0x00, sizeof(buffer));
3952 snprintf(buffer, sizeof(buffer), "libtiff / tiff2pdf - %d", TIFFLIB_VERSION);
3953 written += t2p_write_pdf_string(buffer, output);
3954 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3955 if (t2p->pdf_creator[0] != '\0') {
3956 written += t2pWriteFile(output, (tdata_t) "/Creator ", 9);
3957 written += t2p_write_pdf_string(t2p->pdf_creator, output);
3958 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3959 } else {
3960 if (TIFFGetField(input, TIFFTAG_SOFTWARE, &info) != 0 && info) {
3961 if(strlen(info) >= sizeof(t2p->pdf_creator))
3962 info[sizeof(t2p->pdf_creator) - 1] = '\0';
3963 written += t2pWriteFile(output, (tdata_t) "/Creator ", 9);
3964 written += t2p_write_pdf_string(info, output);
3965 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3966 }
3967 }
3968 if (t2p->pdf_author[0] != '\0') {
3969 written += t2pWriteFile(output, (tdata_t) "/Author ", 8);
3970 written += t2p_write_pdf_string(t2p->pdf_author, output);
3971 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3972 } else {
3973 if ((TIFFGetField(input, TIFFTAG_ARTIST, &info) != 0
3974 || TIFFGetField(input, TIFFTAG_COPYRIGHT, &info) != 0)
3975 && info) {
3976 if (strlen(info) >= sizeof(t2p->pdf_author))
3977 info[sizeof(t2p->pdf_author) - 1] = '\0';
3978 written += t2pWriteFile(output, (tdata_t) "/Author ", 8);
3979 written += t2p_write_pdf_string(info, output);
3980 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3981 }
3982 }
3983 if (t2p->pdf_title[0] != '\0') {
3984 written += t2pWriteFile(output, (tdata_t) "/Title ", 7);
3985 written += t2p_write_pdf_string(t2p->pdf_title, output);
3986 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3987 } else {
3988 if (TIFFGetField(input, TIFFTAG_DOCUMENTNAME, &info) != 0){
3989 if(strlen(info) > 511) {
3990 info[512] = '\0';
3991 }
3992 written += t2pWriteFile(output, (tdata_t) "/Title ", 7);
3993 written += t2p_write_pdf_string(info, output);
3994 written += t2pWriteFile(output, (tdata_t) "\n", 1);
3995 }
3996 }
3997 if (t2p->pdf_subject[0] != '\0') {
3998 written += t2pWriteFile(output, (tdata_t) "/Subject ", 9);
3999 written += t2p_write_pdf_string(t2p->pdf_subject, output);
4000 written += t2pWriteFile(output, (tdata_t) "\n", 1);
4001 } else {
4002 if (TIFFGetField(input, TIFFTAG_IMAGEDESCRIPTION, &info) != 0 && info) {
4003 if (strlen(info) >= sizeof(t2p->pdf_subject))
4004 info[sizeof(t2p->pdf_subject) - 1] = '\0';
4005 written += t2pWriteFile(output, (tdata_t) "/Subject ", 9);
4006 written += t2p_write_pdf_string(info, output);
4007 written += t2pWriteFile(output, (tdata_t) "\n", 1);
4008 }
4009 }
4010 if (t2p->pdf_keywords[0] != '\0') {
4011 written += t2pWriteFile(output, (tdata_t) "/Keywords ", 10);
4012 written += t2p_write_pdf_string(t2p->pdf_keywords, output);
4013 written += t2pWriteFile(output, (tdata_t) "\n", 1);
4014 }
4015 written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
4016
4017 return(written);
4018 }
4019
4020 /*
4021 * This function fills a string of a T2P struct with the current time as a PDF
4022 * date string, it is called by t2p_pdf_tifftime.
4023 */
4024
4025 void t2p_pdf_currenttime(T2P* t2p)
4026 {
4027 struct tm* currenttime;
4028 time_t timenow;
4029
4030 if (time(&timenow) == (time_t) -1) {
4031 TIFFError(TIFF2PDF_MODULE,
4032 "Can't get the current time: %s", strerror(errno));
4033 timenow = (time_t) 0;
4034 }
4035
4036 currenttime = localtime(&timenow);
4037 snprintf(t2p->pdf_datetime, sizeof(t2p->pdf_datetime),
4038 "D:%.4d%.2d%.2d%.2d%.2d%.2d",
4039 (currenttime->tm_year + 1900) % 65536,
4040 (currenttime->tm_mon + 1) % 256,
4041 (currenttime->tm_mday) % 256,
4042 (currenttime->tm_hour) % 256,
4043 (currenttime->tm_min) % 256,
4044 (currenttime->tm_sec) % 256);
4045
4046 return;
4047 }
4048
4049 /*
4050 * This function fills a string of a T2P struct with the date and time of a
4051 * TIFF file if it exists or the current time as a PDF date string.
4052 */
4053
4054 void t2p_pdf_tifftime(T2P* t2p, TIFF* input)
4055 {
4056 char* datetime;
4057
4058 if (TIFFGetField(input, TIFFTAG_DATETIME, &datetime) != 0
4059 && (strlen(datetime) >= 19) ){
4060 t2p->pdf_datetime[0]='D';
4061 t2p->pdf_datetime[1]=':';
4062 t2p->pdf_datetime[2]=datetime[0];
4063 t2p->pdf_datetime[3]=datetime[1];
4064 t2p->pdf_datetime[4]=datetime[2];
4065 t2p->pdf_datetime[5]=datetime[3];
4066 t2p->pdf_datetime[6]=datetime[5];
4067 t2p->pdf_datetime[7]=datetime[6];
4068 t2p->pdf_datetime[8]=datetime[8];
4069 t2p->pdf_datetime[9]=datetime[9];
4070 t2p->pdf_datetime[10]=datetime[11];
4071 t2p->pdf_datetime[11]=datetime[12];
4072 t2p->pdf_datetime[12]=datetime[14];
4073 t2p->pdf_datetime[13]=datetime[15];
4074 t2p->pdf_datetime[14]=datetime[17];
4075 t2p->pdf_datetime[15]=datetime[18];
4076 t2p->pdf_datetime[16] = '\0';
4077 } else {
4078 t2p_pdf_currenttime(t2p);
4079 }
4080
4081 return;
4082 }
4083
4084 /*
4085 * This function writes a PDF Pages Tree structure to output.
4086 */
4087
4088 tsize_t t2p_write_pdf_pages(T2P* t2p, TIFF* output)
4089 {
4090 tsize_t written=0;
4091 tdir_t i=0;
4092 char buffer[16];
4093 int buflen=0;
4094
4095 int page=0;
4096 written += t2pWriteFile(output,
4097 (tdata_t) "<< \n/Type /Pages \n/Kids [ ", 26);
4098 page = t2p->pdf_pages+1;
4099 for (i=0;i<t2p->tiff_pagecount;i++){
4100 buflen=sprintf(buffer, "%d", page);
4101 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4102 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4103 if ( ((i+1)%8)==0 ) {
4104 written += t2pWriteFile(output, (tdata_t) "\n", 1);
4105 }
4106 page +=3;
4107 page += t2p->tiff_pages[i].page_extra;
4108 if(t2p->tiff_pages[i].page_tilecount>0){
4109 page += (2 * t2p->tiff_pages[i].page_tilecount);
4110 } else {
4111 page +=2;
4112 }
4113 }
4114 written += t2pWriteFile(output, (tdata_t) "] \n/Count ", 10);
4115 _TIFFmemset(buffer, 0x00, 16);
4116 buflen=sprintf(buffer, "%d", t2p->tiff_pagecount);
4117 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4118 written += t2pWriteFile(output, (tdata_t) " \n>> \n", 6);
4119
4120 return(written);
4121 }
4122
4123 /*
4124 This function writes a PDF Page structure to output.
4125 */
4126
4127 tsize_t t2p_write_pdf_page(uint32 object, T2P* t2p, TIFF* output){
4128
4129 unsigned int i=0;
4130 tsize_t written=0;
4131 char buffer[16];
4132 int buflen=0;
4133
4134 written += t2pWriteFile(output, (tdata_t) "<<\n/Type /Page \n/Parent ", 24);
4135 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_pages);
4136 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4137 written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
4138 written += t2pWriteFile(output, (tdata_t) "/MediaBox [", 11);
4139 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x1);
4140 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4141 written += t2pWriteFile(output, (tdata_t) " ", 1);
4142 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y1);
4143 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4144 written += t2pWriteFile(output, (tdata_t) " ", 1);
4145 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x2);
4146 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4147 written += t2pWriteFile(output, (tdata_t) " ", 1);
4148 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y2);
4149 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4150 written += t2pWriteFile(output, (tdata_t) "] \n", 3);
4151 written += t2pWriteFile(output, (tdata_t) "/Contents ", 10);
4152 buflen=sprintf(buffer, "%lu", (unsigned long)(object + 1));
4153 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4154 written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
4155 written += t2pWriteFile(output, (tdata_t) "/Resources << \n", 15);
4156 if( t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount != 0 ){
4157 written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4158 for(i=0;i<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i++){
4159 written += t2pWriteFile(output, (tdata_t) "/Im", 3);
4160 buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
4161 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4162 written += t2pWriteFile(output, (tdata_t) "_", 1);
4163 buflen = sprintf(buffer, "%u", i+1);
4164 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4165 written += t2pWriteFile(output, (tdata_t) " ", 1);
4166 buflen = sprintf(
4167 buffer,
4168 "%lu",
4169 (unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
4170 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4171 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4172 if(i%4==3){
4173 written += t2pWriteFile(output, (tdata_t) "\n", 1);
4174 }
4175 }
4176 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
4177 } else {
4178 written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4179 written += t2pWriteFile(output, (tdata_t) "/Im", 3);
4180 buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
4181 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4182 written += t2pWriteFile(output, (tdata_t) " ", 1);
4183 buflen = sprintf(
4184 buffer,
4185 "%lu",
4186 (unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
4187 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4188 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4189 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
4190 }
4191 if(t2p->tiff_transferfunctioncount != 0) {
4192 written += t2pWriteFile(output, (tdata_t) "/ExtGState <<", 13);
4193 t2pWriteFile(output, (tdata_t) "/GS1 ", 5);
4194 buflen = sprintf(
4195 buffer,
4196 "%lu",
4197 (unsigned long)(object + 3));
4198 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4199 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4200 written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
4201 }
4202 written += t2pWriteFile(output, (tdata_t) "/ProcSet [ ", 11);
4203 if(t2p->pdf_colorspace == T2P_CS_BILEVEL
4204 || t2p->pdf_colorspace == T2P_CS_GRAY
4205 ){
4206 written += t2pWriteFile(output, (tdata_t) "/ImageB ", 8);
4207 } else {
4208 written += t2pWriteFile(output, (tdata_t) "/ImageC ", 8);
4209 if(t2p->pdf_colorspace & T2P_CS_PALETTE){
4210 written += t2pWriteFile(output, (tdata_t) "/ImageI ", 8);
4211 }
4212 }
4213 written += t2pWriteFile(output, (tdata_t) "]\n>>\n>>\n", 8);
4214
4215 return(written);
4216 }
4217
4218 /*
4219 This function composes the page size and image and tile locations on a page.
4220 */
4221
4222 void t2p_compose_pdf_page(T2P* t2p){
4223
4224 uint32 i=0;
4225 uint32 i2=0;
4226 T2P_TILE* tiles=NULL;
4227 T2P_BOX* boxp=NULL;
4228 uint32 tilecountx=0;
4229 uint32 tilecounty=0;
4230 uint32 tilewidth=0;
4231 uint32 tilelength=0;
4232 int istiled=0;
4233 float f=0;
4234 float width_ratio=0;
4235 float length_ratio=0;
4236
4237 t2p->pdf_xres = t2p->tiff_xres;
4238 t2p->pdf_yres = t2p->tiff_yres;
4239 if(t2p->pdf_overrideres) {
4240 t2p->pdf_xres = t2p->pdf_defaultxres;
4241 t2p->pdf_yres = t2p->pdf_defaultyres;
4242 }
4243 if(t2p->pdf_xres == 0.0)
4244 t2p->pdf_xres = t2p->pdf_defaultxres;
4245 if(t2p->pdf_yres == 0.0)
4246 t2p->pdf_yres = t2p->pdf_defaultyres;
4247 if (t2p->pdf_image_fillpage) {
4248 width_ratio = t2p->pdf_defaultpagewidth/t2p->tiff_width;
4249 length_ratio = t2p->pdf_defaultpagelength/t2p->tiff_length;
4250 if (width_ratio < length_ratio ) {
4251 t2p->pdf_imagewidth = t2p->pdf_defaultpagewidth;
4252 t2p->pdf_imagelength = t2p->tiff_length * width_ratio;
4253 } else {
4254 t2p->pdf_imagewidth = t2p->tiff_width * length_ratio;
4255 t2p->pdf_imagelength = t2p->pdf_defaultpagelength;
4256 }
4257 } else if (t2p->tiff_resunit != RESUNIT_CENTIMETER /* RESUNIT_NONE and */
4258 && t2p->tiff_resunit != RESUNIT_INCH) { /* other cases */
4259 t2p->pdf_imagewidth = ((float)(t2p->tiff_width))/t2p->pdf_xres;
4260 t2p->pdf_imagelength = ((float)(t2p->tiff_length))/t2p->pdf_yres;
4261 } else {
4262 t2p->pdf_imagewidth =
4263 ((float)(t2p->tiff_width))*PS_UNIT_SIZE/t2p->pdf_xres;
4264 t2p->pdf_imagelength =
4265 ((float)(t2p->tiff_length))*PS_UNIT_SIZE/t2p->pdf_yres;
4266 }
4267 if(t2p->pdf_overridepagesize != 0) {
4268 t2p->pdf_pagewidth = t2p->pdf_defaultpagewidth;
4269 t2p->pdf_pagelength = t2p->pdf_defaultpagelength;
4270 } else {
4271 t2p->pdf_pagewidth = t2p->pdf_imagewidth;
4272 t2p->pdf_pagelength = t2p->pdf_imagelength;
4273 }
4274 t2p->pdf_mediabox.x1=0.0;
4275 t2p->pdf_mediabox.y1=0.0;
4276 t2p->pdf_mediabox.x2=t2p->pdf_pagewidth;
4277 t2p->pdf_mediabox.y2=t2p->pdf_pagelength;
4278 t2p->pdf_imagebox.x1=0.0;
4279 t2p->pdf_imagebox.y1=0.0;
4280 t2p->pdf_imagebox.x2=t2p->pdf_imagewidth;
4281 t2p->pdf_imagebox.y2=t2p->pdf_imagelength;
4282 if(t2p->pdf_overridepagesize!=0){
4283 t2p->pdf_imagebox.x1+=((t2p->pdf_pagewidth-t2p->pdf_imagewidth)/2.0F);
4284 t2p->pdf_imagebox.y1+=((t2p->pdf_pagelength-t2p->pdf_imagelength)/2.0F);
4285 t2p->pdf_imagebox.x2+=((t2p->pdf_pagewidth-t2p->pdf_imagewidth)/2.0F);
4286 t2p->pdf_imagebox.y2+=((t2p->pdf_pagelength-t2p->pdf_imagelength)/2.0F);
4287 }
4288 if(t2p->tiff_orientation > 4){
4289 f=t2p->pdf_mediabox.x2;
4290 t2p->pdf_mediabox.x2=t2p->pdf_mediabox.y2;
4291 t2p->pdf_mediabox.y2=f;
4292 }
4293 istiled=((t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount==0) ? 0 : 1;
4294 if(istiled==0){
4295 t2p_compose_pdf_page_orient(&(t2p->pdf_imagebox), t2p->tiff_orientation);
4296 return;
4297 } else {
4298 tilewidth=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilewidth;
4299 tilelength=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilelength;
4300 tilecountx=(t2p->tiff_width +
4301 tilewidth -1)/
4302 tilewidth;
4303 (t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecountx=tilecountx;
4304 tilecounty=(t2p->tiff_length +
4305 tilelength -1)/
4306 tilelength;
4307 (t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecounty=tilecounty;
4308 (t2p->tiff_tiles[t2p->pdf_page]).tiles_edgetilewidth=
4309 t2p->tiff_width % tilewidth;
4310 (t2p->tiff_tiles[t2p->pdf_page]).tiles_edgetilelength=
4311 t2p->tiff_length % tilelength;
4312 tiles=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tiles;
4313 for(i2=0;i2<tilecounty-1;i2++){
4314 for(i=0;i<tilecountx-1;i++){
4315 boxp=&(tiles[i2*tilecountx+i].tile_box);
4316 boxp->x1 =
4317 t2p->pdf_imagebox.x1
4318 + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4319 / (float)t2p->tiff_width);
4320 boxp->x2 =
4321 t2p->pdf_imagebox.x1
4322 + ((float)(t2p->pdf_imagewidth * (i+1) * tilewidth)
4323 / (float)t2p->tiff_width);
4324 boxp->y1 =
4325 t2p->pdf_imagebox.y2
4326 - ((float)(t2p->pdf_imagelength * (i2+1) * tilelength)
4327 / (float)t2p->tiff_length);
4328 boxp->y2 =
4329 t2p->pdf_imagebox.y2
4330 - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4331 / (float)t2p->tiff_length);
4332 }
4333 boxp=&(tiles[i2*tilecountx+i].tile_box);
4334 boxp->x1 =
4335 t2p->pdf_imagebox.x1
4336 + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4337 / (float)t2p->tiff_width);
4338 boxp->x2 = t2p->pdf_imagebox.x2;
4339 boxp->y1 =
4340 t2p->pdf_imagebox.y2
4341 - ((float)(t2p->pdf_imagelength * (i2+1) * tilelength)
4342 / (float)t2p->tiff_length);
4343 boxp->y2 =
4344 t2p->pdf_imagebox.y2
4345 - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4346 / (float)t2p->tiff_length);
4347 }
4348 for(i=0;i<tilecountx-1;i++){
4349 boxp=&(tiles[i2*tilecountx+i].tile_box);
4350 boxp->x1 =
4351 t2p->pdf_imagebox.x1
4352 + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4353 / (float)t2p->tiff_width);
4354 boxp->x2 =
4355 t2p->pdf_imagebox.x1
4356 + ((float)(t2p->pdf_imagewidth * (i+1) * tilewidth)
4357 / (float)t2p->tiff_width);
4358 boxp->y1 = t2p->pdf_imagebox.y1;
4359 boxp->y2 =
4360 t2p->pdf_imagebox.y2
4361 - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4362 / (float)t2p->tiff_length);
4363 }
4364 boxp=&(tiles[i2*tilecountx+i].tile_box);
4365 boxp->x1 =
4366 t2p->pdf_imagebox.x1
4367 + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4368 / (float)t2p->tiff_width);
4369 boxp->x2 = t2p->pdf_imagebox.x2;
4370 boxp->y1 = t2p->pdf_imagebox.y1;
4371 boxp->y2 =
4372 t2p->pdf_imagebox.y2
4373 - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4374 / (float)t2p->tiff_length);
4375 }
4376 if(t2p->tiff_orientation==0 || t2p->tiff_orientation==1){
4377 for(i=0;i<(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount;i++){
4378 t2p_compose_pdf_page_orient( &(tiles[i].tile_box) , 0);
4379 }
4380 return;
4381 }
4382 for(i=0;i<(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount;i++){
4383 boxp=&(tiles[i].tile_box);
4384 boxp->x1 -= t2p->pdf_imagebox.x1;
4385 boxp->x2 -= t2p->pdf_imagebox.x1;
4386 boxp->y1 -= t2p->pdf_imagebox.y1;
4387 boxp->y2 -= t2p->pdf_imagebox.y1;
4388 if(t2p->tiff_orientation==2 || t2p->tiff_orientation==3){
4389 boxp->x1 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x1;
4390 boxp->x2 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x2;
4391 }
4392 if(t2p->tiff_orientation==3 || t2p->tiff_orientation==4){
4393 boxp->y1 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y1;
4394 boxp->y2 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y2;
4395 }
4396 if(t2p->tiff_orientation==8 || t2p->tiff_orientation==5){
4397 boxp->y1 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y1;
4398 boxp->y2 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y2;
4399 }
4400 if(t2p->tiff_orientation==5 || t2p->tiff_orientation==6){
4401 boxp->x1 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x1;
4402 boxp->x2 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x2;
4403 }
4404 if(t2p->tiff_orientation > 4){
4405 f=boxp->x1;
4406 boxp->x1 = boxp->y1;
4407 boxp->y1 = f;
4408 f=boxp->x2;
4409 boxp->x2 = boxp->y2;
4410 boxp->y2 = f;
4411 t2p_compose_pdf_page_orient_flip(boxp, t2p->tiff_orientation);
4412 } else {
4413 t2p_compose_pdf_page_orient(boxp, t2p->tiff_orientation);
4414 }
4415
4416 }
4417
4418 return;
4419 }
4420
4421 void t2p_compose_pdf_page_orient(T2P_BOX* boxp, uint16 orientation){
4422
4423 float m1[9];
4424 float f=0.0;
4425
4426 if( boxp->x1 > boxp->x2){
4427 f=boxp->x1;
4428 boxp->x1=boxp->x2;
4429 boxp->x2 = f;
4430 }
4431 if( boxp->y1 > boxp->y2){
4432 f=boxp->y1;
4433 boxp->y1=boxp->y2;
4434 boxp->y2 = f;
4435 }
4436 boxp->mat[0]=m1[0]=boxp->x2-boxp->x1;
4437 boxp->mat[1]=m1[1]=0.0;
4438 boxp->mat[2]=m1[2]=0.0;
4439 boxp->mat[3]=m1[3]=0.0;
4440 boxp->mat[4]=m1[4]=boxp->y2-boxp->y1;
4441 boxp->mat[5]=m1[5]=0.0;
4442 boxp->mat[6]=m1[6]=boxp->x1;
4443 boxp->mat[7]=m1[7]=boxp->y1;
4444 boxp->mat[8]=m1[8]=1.0;
4445 switch(orientation){
4446 case 0:
4447 case 1:
4448 break;
4449 case 2:
4450 boxp->mat[0]=0.0F-m1[0];
4451 boxp->mat[6]+=m1[0];
4452 break;
4453 case 3:
4454 boxp->mat[0]=0.0F-m1[0];
4455 boxp->mat[4]=0.0F-m1[4];
4456 boxp->mat[6]+=m1[0];
4457 boxp->mat[7]+=m1[4];
4458 break;
4459 case 4:
4460 boxp->mat[4]=0.0F-m1[4];
4461 boxp->mat[7]+=m1[4];
4462 break;
4463 case 5:
4464 boxp->mat[0]=0.0F;
4465 boxp->mat[1]=0.0F-m1[0];
4466 boxp->mat[3]=0.0F-m1[4];
4467 boxp->mat[4]=0.0F;
4468 boxp->mat[6]+=m1[4];
4469 boxp->mat[7]+=m1[0];
4470 break;
4471 case 6:
4472 boxp->mat[0]=0.0F;
4473 boxp->mat[1]=0.0F-m1[0];
4474 boxp->mat[3]=m1[4];
4475 boxp->mat[4]=0.0F;
4476 boxp->mat[7]+=m1[0];
4477 break;
4478 case 7:
4479 boxp->mat[0]=0.0F;
4480 boxp->mat[1]=m1[0];
4481 boxp->mat[3]=m1[4];
4482 boxp->mat[4]=0.0F;
4483 break;
4484 case 8:
4485 boxp->mat[0]=0.0F;
4486 boxp->mat[1]=m1[0];
4487 boxp->mat[3]=0.0F-m1[4];
4488 boxp->mat[4]=0.0F;
4489 boxp->mat[6]+=m1[4];
4490 break;
4491 }
4492
4493 return;
4494 }
4495
4496 void t2p_compose_pdf_page_orient_flip(T2P_BOX* boxp, uint16 orientation){
4497
4498 float m1[9];
4499 float f=0.0;
4500
4501 if( boxp->x1 > boxp->x2){
4502 f=boxp->x1;
4503 boxp->x1=boxp->x2;
4504 boxp->x2 = f;
4505 }
4506 if( boxp->y1 > boxp->y2){
4507 f=boxp->y1;
4508 boxp->y1=boxp->y2;
4509 boxp->y2 = f;
4510 }
4511 boxp->mat[0]=m1[0]=boxp->x2-boxp->x1;
4512 boxp->mat[1]=m1[1]=0.0F;
4513 boxp->mat[2]=m1[2]=0.0F;
4514 boxp->mat[3]=m1[3]=0.0F;
4515 boxp->mat[4]=m1[4]=boxp->y2-boxp->y1;
4516 boxp->mat[5]=m1[5]=0.0F;
4517 boxp->mat[6]=m1[6]=boxp->x1;
4518 boxp->mat[7]=m1[7]=boxp->y1;
4519 boxp->mat[8]=m1[8]=1.0F;
4520 switch(orientation){
4521 case 5:
4522 boxp->mat[0]=0.0F;
4523 boxp->mat[1]=0.0F-m1[4];
4524 boxp->mat[3]=0.0F-m1[0];
4525 boxp->mat[4]=0.0F;
4526 boxp->mat[6]+=m1[0];
4527 boxp->mat[7]+=m1[4];
4528 break;
4529 case 6:
4530 boxp->mat[0]=0.0F;
4531 boxp->mat[1]=0.0F-m1[4];
4532 boxp->mat[3]=m1[0];
4533 boxp->mat[4]=0.0F;
4534 boxp->mat[7]+=m1[4];
4535 break;
4536 case 7:
4537 boxp->mat[0]=0.0F;
4538 boxp->mat[1]=m1[4];
4539 boxp->mat[3]=m1[0];
4540 boxp->mat[4]=0.0F;
4541 break;
4542 case 8:
4543 boxp->mat[0]=0.0F;
4544 boxp->mat[1]=m1[4];
4545 boxp->mat[3]=0.0F-m1[0];
4546 boxp->mat[4]=0.0F;
4547 boxp->mat[6]+=m1[0];
4548 break;
4549 }
4550
4551 return;
4552 }
4553
4554 /*
4555 This function writes a PDF Contents stream to output.
4556 */
4557
4558 tsize_t t2p_write_pdf_page_content_stream(T2P* t2p, TIFF* output){
4559
4560 tsize_t written=0;
4561 ttile_t i=0;
4562 char buffer[512];
4563 int buflen=0;
4564 T2P_BOX box;
4565
4566 if(t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount>0){
4567 for(i=0;i<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount; i++){
4568 box=t2p->tiff_tiles[t2p->pdf_page].tiles_tiles[i].tile_box;
4569 buflen=sprintf(buffer,
4570 "q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d_%ld Do Q\n",
4571 t2p->tiff_transferfunctioncount?"/GS1 gs ":"",
4572 box.mat[0],
4573 box.mat[1],
4574 box.mat[3],
4575 box.mat[4],
4576 box.mat[6],
4577 box.mat[7],
4578 t2p->pdf_page + 1,
4579 (long)(i + 1));
4580 written += t2p_write_pdf_stream(buffer, buflen, output);
4581 }
4582 } else {
4583 box=t2p->pdf_imagebox;
4584 buflen=sprintf(buffer,
4585 "q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d Do Q\n",
4586 t2p->tiff_transferfunctioncount?"/GS1 gs ":"",
4587 box.mat[0],
4588 box.mat[1],
4589 box.mat[3],
4590 box.mat[4],
4591 box.mat[6],
4592 box.mat[7],
4593 t2p->pdf_page+1);
4594 written += t2p_write_pdf_stream(buffer, buflen, output);
4595 }
4596
4597 return(written);
4598 }
4599
4600 /*
4601 This function writes a PDF Image XObject stream dictionary to output.
4602 */
4603
4604 tsize_t t2p_write_pdf_xobject_stream_dict(ttile_t tile,
4605 T2P* t2p,
4606 TIFF* output){
4607
4608 tsize_t written=0;
4609 char buffer[16];
4610 int buflen=0;
4611
4612 written += t2p_write_pdf_stream_dict(0, t2p->pdf_xrefcount+1, output);
4613 written += t2pWriteFile(output,
4614 (tdata_t) "/Type /XObject \n/Subtype /Image \n/Name /Im",
4615 42);
4616 buflen=sprintf(buffer, "%u", t2p->pdf_page+1);
4617 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4618 if(tile != 0){
4619 written += t2pWriteFile(output, (tdata_t) "_", 1);
4620 buflen=sprintf(buffer, "%lu", (unsigned long)tile);
4621 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4622 }
4623 written += t2pWriteFile(output, (tdata_t) "\n/Width ", 8);
4624 _TIFFmemset((tdata_t)buffer, 0x00, 16);
4625 if(tile==0){
4626 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->tiff_width);
4627 } else {
4628 if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)!=0){
4629 buflen=sprintf(
4630 buffer,
4631 "%lu",
4632 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
4633 } else {
4634 buflen=sprintf(
4635 buffer,
4636 "%lu",
4637 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
4638 }
4639 }
4640 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4641 written += t2pWriteFile(output, (tdata_t) "\n/Height ", 9);
4642 _TIFFmemset((tdata_t)buffer, 0x00, 16);
4643 if(tile==0){
4644 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->tiff_length);
4645 } else {
4646 if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)!=0){
4647 buflen=sprintf(
4648 buffer,
4649 "%lu",
4650 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
4651 } else {
4652 buflen=sprintf(
4653 buffer,
4654 "%lu",
4655 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
4656 }
4657 }
4658 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4659 written += t2pWriteFile(output, (tdata_t) "\n/BitsPerComponent ", 19);
4660 _TIFFmemset((tdata_t)buffer, 0x00, 16);
4661 buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
4662 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4663 written += t2pWriteFile(output, (tdata_t) "\n/ColorSpace ", 13);
4664 written += t2p_write_pdf_xobject_cs(t2p, output);
4665 if (t2p->pdf_image_interpolate)
4666 written += t2pWriteFile(output,
4667 (tdata_t) "\n/Interpolate true", 18);
4668 if( (t2p->pdf_switchdecode != 0)
4669 #ifdef CCITT_SUPPORT
4670 && ! (t2p->pdf_colorspace == T2P_CS_BILEVEL
4671 && t2p->pdf_compression == T2P_COMPRESS_G4)
4672 #endif
4673 ){
4674 written += t2p_write_pdf_xobject_decode(t2p, output);
4675 }
4676 written += t2p_write_pdf_xobject_stream_filter(tile, t2p, output);
4677
4678 return(written);
4679 }
4680
4681 /*
4682 * This function writes a PDF Image XObject Colorspace name to output.
4683 */
4684
4685
4686 tsize_t t2p_write_pdf_xobject_cs(T2P* t2p, TIFF* output){
4687
4688 tsize_t written=0;
4689 char buffer[128];
4690 int buflen=0;
4691
4692 float X_W=1.0;
4693 float Y_W=1.0;
4694 float Z_W=1.0;
4695
4696 if( (t2p->pdf_colorspace & T2P_CS_ICCBASED) != 0){
4697 written += t2p_write_pdf_xobject_icccs(t2p, output);
4698 return(written);
4699 }
4700 if( (t2p->pdf_colorspace & T2P_CS_PALETTE) != 0){
4701 written += t2pWriteFile(output, (tdata_t) "[ /Indexed ", 11);
4702 t2p->pdf_colorspace ^= T2P_CS_PALETTE;
4703 written += t2p_write_pdf_xobject_cs(t2p, output);
4704 t2p->pdf_colorspace |= T2P_CS_PALETTE;
4705 buflen=sprintf(buffer, "%u", (0x0001 << t2p->tiff_bitspersample)-1 );
4706 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4707 written += t2pWriteFile(output, (tdata_t) " ", 1);
4708 _TIFFmemset(buffer, 0x00, 16);
4709 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_palettecs );
4710 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4711 written += t2pWriteFile(output, (tdata_t) " 0 R ]\n", 7);
4712 return(written);
4713 }
4714 if(t2p->pdf_colorspace & T2P_CS_BILEVEL){
4715 written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
4716 }
4717 if(t2p->pdf_colorspace & T2P_CS_GRAY){
4718 if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4719 written += t2p_write_pdf_xobject_calcs(t2p, output);
4720 } else {
4721 written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
4722 }
4723 }
4724 if(t2p->pdf_colorspace & T2P_CS_RGB){
4725 if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4726 written += t2p_write_pdf_xobject_calcs(t2p, output);
4727 } else {
4728 written += t2pWriteFile(output, (tdata_t) "/DeviceRGB \n", 12);
4729 }
4730 }
4731 if(t2p->pdf_colorspace & T2P_CS_CMYK){
4732 written += t2pWriteFile(output, (tdata_t) "/DeviceCMYK \n", 13);
4733 }
4734 if(t2p->pdf_colorspace & T2P_CS_LAB){
4735 written += t2pWriteFile(output, (tdata_t) "[/Lab << \n", 10);
4736 written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4737 X_W = t2p->tiff_whitechromaticities[0];
4738 Y_W = t2p->tiff_whitechromaticities[1];
4739 Z_W = 1.0F - (X_W + Y_W);
4740 X_W /= Y_W;
4741 Z_W /= Y_W;
4742 Y_W = 1.0F;
4743 buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4744 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4745 written += t2pWriteFile(output, (tdata_t) "/Range ", 7);
4746 buflen=sprintf(buffer, "[%d %d %d %d] \n",
4747 t2p->pdf_labrange[0],
4748 t2p->pdf_labrange[1],
4749 t2p->pdf_labrange[2],
4750 t2p->pdf_labrange[3]);
4751 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4752 written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
4753
4754 }
4755
4756 return(written);
4757 }
4758
4759 tsize_t t2p_write_pdf_transfer(T2P* t2p, TIFF* output){
4760
4761 tsize_t written=0;
4762 char buffer[16];
4763 int buflen=0;
4764
4765 written += t2pWriteFile(output, (tdata_t) "<< /Type /ExtGState \n/TR ", 25);
4766 if(t2p->tiff_transferfunctioncount == 1){
4767 buflen=sprintf(buffer, "%lu",
4768 (unsigned long)(t2p->pdf_xrefcount + 1));
4769 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4770 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4771 } else {
4772 written += t2pWriteFile(output, (tdata_t) "[ ", 2);
4773 buflen=sprintf(buffer, "%lu",
4774 (unsigned long)(t2p->pdf_xrefcount + 1));
4775 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4776 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4777 buflen=sprintf(buffer, "%lu",
4778 (unsigned long)(t2p->pdf_xrefcount + 2));
4779 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4780 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4781 buflen=sprintf(buffer, "%lu",
4782 (unsigned long)(t2p->pdf_xrefcount + 3));
4783 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4784 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4785 written += t2pWriteFile(output, (tdata_t) "/Identity ] ", 12);
4786 }
4787
4788 written += t2pWriteFile(output, (tdata_t) " >> \n", 5);
4789
4790 return(written);
4791 }
4792
4793 tsize_t t2p_write_pdf_transfer_dict(T2P* t2p, TIFF* output, uint16 i){
4794
4795 tsize_t written=0;
4796 char buffer[32];
4797 int buflen=0;
4798 (void)i; /* XXX */
4799
4800 written += t2pWriteFile(output, (tdata_t) "/FunctionType 0 \n", 17);
4801 written += t2pWriteFile(output, (tdata_t) "/Domain [0.0 1.0] \n", 19);
4802 written += t2pWriteFile(output, (tdata_t) "/Range [0.0 1.0] \n", 18);
4803 buflen=sprintf(buffer, "/Size [%u] \n", (1<<t2p->tiff_bitspersample));
4804 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4805 written += t2pWriteFile(output, (tdata_t) "/BitsPerSample 16 \n", 19);
4806 written += t2p_write_pdf_stream_dict(((tsize_t)1)<<(t2p->tiff_bitspersample+1), 0, output);
4807
4808 return(written);
4809 }
4810
4811 tsize_t t2p_write_pdf_transfer_stream(T2P* t2p, TIFF* output, uint16 i){
4812
4813 tsize_t written=0;
4814
4815 written += t2p_write_pdf_stream(
4816 t2p->tiff_transferfunction[i],
4817 (((tsize_t)1)<<(t2p->tiff_bitspersample+1)),
4818 output);
4819
4820 return(written);
4821 }
4822
4823 /*
4824 This function writes a PDF Image XObject Colorspace array to output.
4825 */
4826
4827 tsize_t t2p_write_pdf_xobject_calcs(T2P* t2p, TIFF* output){
4828
4829 tsize_t written=0;
4830 char buffer[128];
4831 int buflen=0;
4832
4833 float X_W=0.0;
4834 float Y_W=0.0;
4835 float Z_W=0.0;
4836 float X_R=0.0;
4837 float Y_R=0.0;
4838 float Z_R=0.0;
4839 float X_G=0.0;
4840 float Y_G=0.0;
4841 float Z_G=0.0;
4842 float X_B=0.0;
4843 float Y_B=0.0;
4844 float Z_B=0.0;
4845 float x_w=0.0;
4846 float y_w=0.0;
4847 float z_w=0.0;
4848 float x_r=0.0;
4849 float y_r=0.0;
4850 float x_g=0.0;
4851 float y_g=0.0;
4852 float x_b=0.0;
4853 float y_b=0.0;
4854 float R=1.0;
4855 float G=1.0;
4856 float B=1.0;
4857
4858 written += t2pWriteFile(output, (tdata_t) "[", 1);
4859 if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4860 written += t2pWriteFile(output, (tdata_t) "/CalGray ", 9);
4861 X_W = t2p->tiff_whitechromaticities[0];
4862 Y_W = t2p->tiff_whitechromaticities[1];
4863 Z_W = 1.0F - (X_W + Y_W);
4864 X_W /= Y_W;
4865 Z_W /= Y_W;
4866 Y_W = 1.0F;
4867 }
4868 if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4869 written += t2pWriteFile(output, (tdata_t) "/CalRGB ", 8);
4870 x_w = t2p->tiff_whitechromaticities[0];
4871 y_w = t2p->tiff_whitechromaticities[1];
4872 x_r = t2p->tiff_primarychromaticities[0];
4873 y_r = t2p->tiff_primarychromaticities[1];
4874 x_g = t2p->tiff_primarychromaticities[2];
4875 y_g = t2p->tiff_primarychromaticities[3];
4876 x_b = t2p->tiff_primarychromaticities[4];
4877 y_b = t2p->tiff_primarychromaticities[5];
4878 z_w = y_w * ((x_g - x_b)*y_r - (x_r-x_b)*y_g + (x_r-x_g)*y_b);
4879 Y_R = (y_r/R) * ((x_g-x_b)*y_w - (x_w-x_b)*y_g + (x_w-x_g)*y_b) / z_w;
4880 X_R = Y_R * x_r / y_r;
4881 Z_R = Y_R * (((1-x_r)/y_r)-1);
4882 Y_G = ((0.0F-(y_g))/G) * ((x_r-x_b)*y_w - (x_w-x_b)*y_r + (x_w-x_r)*y_b) / z_w;
4883 X_G = Y_G * x_g / y_g;
4884 Z_G = Y_G * (((1-x_g)/y_g)-1);
4885 Y_B = (y_b/B) * ((x_r-x_g)*y_w - (x_w-x_g)*y_r + (x_w-x_r)*y_g) / z_w;
4886 X_B = Y_B * x_b / y_b;
4887 Z_B = Y_B * (((1-x_b)/y_b)-1);
4888 X_W = (X_R * R) + (X_G * G) + (X_B * B);
4889 Y_W = (Y_R * R) + (Y_G * G) + (Y_B * B);
4890 Z_W = (Z_R * R) + (Z_G * G) + (Z_B * B);
4891 X_W /= Y_W;
4892 Z_W /= Y_W;
4893 Y_W = 1.0;
4894 }
4895 written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
4896 if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4897 written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4898 buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4899 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4900 written += t2pWriteFile(output, (tdata_t) "/Gamma 2.2 \n", 12);
4901 }
4902 if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4903 written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4904 buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4905 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4906 written += t2pWriteFile(output, (tdata_t) "/Matrix ", 8);
4907 buflen=sprintf(buffer, "[%.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f] \n",
4908 X_R, Y_R, Z_R,
4909 X_G, Y_G, Z_G,
4910 X_B, Y_B, Z_B);
4911 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4912 written += t2pWriteFile(output, (tdata_t) "/Gamma [2.2 2.2 2.2] \n", 22);
4913 }
4914 written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
4915
4916 return(written);
4917 }
4918
4919 /*
4920 This function writes a PDF Image XObject Colorspace array to output.
4921 */
4922
4923 tsize_t t2p_write_pdf_xobject_icccs(T2P* t2p, TIFF* output){
4924
4925 tsize_t written=0;
4926 char buffer[16];
4927 int buflen=0;
4928
4929 written += t2pWriteFile(output, (tdata_t) "[/ICCBased ", 11);
4930 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_icccs);
4931 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4932 written += t2pWriteFile(output, (tdata_t) " 0 R] \n", 7);
4933
4934 return(written);
4935 }
4936
4937 tsize_t t2p_write_pdf_xobject_icccs_dict(T2P* t2p, TIFF* output){
4938
4939 tsize_t written=0;
4940 char buffer[16];
4941 int buflen=0;
4942
4943 written += t2pWriteFile(output, (tdata_t) "/N ", 3);
4944 buflen=sprintf(buffer, "%u \n", t2p->tiff_samplesperpixel);
4945 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4946 written += t2pWriteFile(output, (tdata_t) "/Alternate ", 11);
4947 t2p->pdf_colorspace ^= T2P_CS_ICCBASED;
4948 written += t2p_write_pdf_xobject_cs(t2p, output);
4949 t2p->pdf_colorspace |= T2P_CS_ICCBASED;
4950 written += t2p_write_pdf_stream_dict(t2p->tiff_iccprofilelength, 0, output);
4951
4952 return(written);
4953 }
4954
4955 tsize_t t2p_write_pdf_xobject_icccs_stream(T2P* t2p, TIFF* output){
4956
4957 tsize_t written=0;
4958
4959 written += t2p_write_pdf_stream(
4960 (tdata_t) t2p->tiff_iccprofile,
4961 (tsize_t) t2p->tiff_iccprofilelength,
4962 output);
4963
4964 return(written);
4965 }
4966
4967 /*
4968 This function writes a palette stream for an indexed color space to output.
4969 */
4970
4971 tsize_t t2p_write_pdf_xobject_palettecs_stream(T2P* t2p, TIFF* output){
4972
4973 tsize_t written=0;
4974
4975 written += t2p_write_pdf_stream(
4976 (tdata_t) t2p->pdf_palette,
4977 (tsize_t) t2p->pdf_palettesize,
4978 output);
4979
4980 return(written);
4981 }
4982
4983 /*
4984 This function writes a PDF Image XObject Decode array to output.
4985 */
4986
4987 tsize_t t2p_write_pdf_xobject_decode(T2P* t2p, TIFF* output){
4988
4989 tsize_t written=0;
4990 int i=0;
4991
4992 written += t2pWriteFile(output, (tdata_t) "/Decode [ ", 10);
4993 for (i=0;i<t2p->tiff_samplesperpixel;i++){
4994 written += t2pWriteFile(output, (tdata_t) "1 0 ", 4);
4995 }
4996 written += t2pWriteFile(output, (tdata_t) "]\n", 2);
4997
4998 return(written);
4999 }
5000
5001 /*
5002 This function writes a PDF Image XObject stream filter name and parameters to
5003 output.
5004 */
5005
5006 tsize_t t2p_write_pdf_xobject_stream_filter(ttile_t tile, T2P* t2p, TIFF* output){
5007
5008 tsize_t written=0;
5009 char buffer[16];
5010 int buflen=0;
5011
5012 if(t2p->pdf_compression==T2P_COMPRESS_NONE){
5013 return(written);
5014 }
5015 written += t2pWriteFile(output, (tdata_t) "/Filter ", 8);
5016 switch(t2p->pdf_compression){
5017 #ifdef CCITT_SUPPORT
5018 case T2P_COMPRESS_G4:
5019 written += t2pWriteFile(output, (tdata_t) "/CCITTFaxDecode ", 16);
5020 written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5021 written += t2pWriteFile(output, (tdata_t) "<< /K -1 ", 9);
5022 if(tile==0){
5023 written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5024 buflen=sprintf(buffer, "%lu",
5025 (unsigned long)t2p->tiff_width);
5026 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5027 written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5028 buflen=sprintf(buffer, "%lu",
5029 (unsigned long)t2p->tiff_length);
5030 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5031 } else {
5032 if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
5033 written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5034 buflen=sprintf(
5035 buffer,
5036 "%lu",
5037 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
5038 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5039 } else {
5040 written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5041 buflen=sprintf(
5042 buffer,
5043 "%lu",
5044 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
5045 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5046 }
5047 if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
5048 written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5049 buflen=sprintf(
5050 buffer,
5051 "%lu",
5052 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
5053 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5054 } else {
5055 written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5056 buflen=sprintf(
5057 buffer,
5058 "%lu",
5059 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
5060 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5061 }
5062 }
5063 if(t2p->pdf_switchdecode == 0){
5064 written += t2pWriteFile(output, (tdata_t) " /BlackIs1 true ", 16);
5065 }
5066 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
5067 break;
5068 #endif
5069 #ifdef JPEG_SUPPORT
5070 case T2P_COMPRESS_JPEG:
5071 written += t2pWriteFile(output, (tdata_t) "/DCTDecode ", 11);
5072
5073 if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR) {
5074 written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5075 written += t2pWriteFile(output, (tdata_t) "<< /ColorTransform 0 >>\n", 24);
5076 }
5077 break;
5078 #endif
5079 #ifdef ZIP_SUPPORT
5080 case T2P_COMPRESS_ZIP:
5081 written += t2pWriteFile(output, (tdata_t) "/FlateDecode ", 13);
5082 if(t2p->pdf_compressionquality%100){
5083 written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5084 written += t2pWriteFile(output, (tdata_t) "<< /Predictor ", 14);
5085 _TIFFmemset(buffer, 0x00, 16);
5086 buflen=sprintf(buffer, "%u", t2p->pdf_compressionquality%100);
5087 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5088 written += t2pWriteFile(output, (tdata_t) " /Columns ", 10);
5089 _TIFFmemset(buffer, 0x00, 16);
5090 buflen = sprintf(buffer, "%lu",
5091 (unsigned long)t2p->tiff_width);
5092 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5093 written += t2pWriteFile(output, (tdata_t) " /Colors ", 9);
5094 _TIFFmemset(buffer, 0x00, 16);
5095 buflen=sprintf(buffer, "%u", t2p->tiff_samplesperpixel);
5096 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5097 written += t2pWriteFile(output, (tdata_t) " /BitsPerComponent ", 19);
5098 _TIFFmemset(buffer, 0x00, 16);
5099 buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
5100 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5101 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
5102 }
5103 break;
5104 #endif
5105 default:
5106 break;
5107 }
5108
5109 return(written);
5110 }
5111
5112 /*
5113 This function writes a PDF xref table to output.
5114 */
5115
5116 tsize_t t2p_write_pdf_xreftable(T2P* t2p, TIFF* output){
5117
5118 tsize_t written=0;
5119 char buffer[21];
5120 int buflen=0;
5121 uint32 i=0;
5122
5123 written += t2pWriteFile(output, (tdata_t) "xref\n0 ", 7);
5124 buflen=sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount + 1));
5125 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5126 written += t2pWriteFile(output, (tdata_t) " \n0000000000 65535 f \n", 22);
5127 for (i=0;i<t2p->pdf_xrefcount;i++){
5128 sprintf(buffer, "%.10lu 00000 n \n",
5129 (unsigned long)t2p->pdf_xrefoffsets[i]);
5130 written += t2pWriteFile(output, (tdata_t) buffer, 20);
5131 }
5132
5133 return(written);
5134 }
5135
5136 /*
5137 * This function writes a PDF trailer to output.
5138 */
5139
5140 tsize_t t2p_write_pdf_trailer(T2P* t2p, TIFF* output)
5141 {
5142
5143 tsize_t written = 0;
5144 char buffer[32];
5145 int buflen = 0;
5146 size_t i = 0;
5147
5148 for (i = 0; i < sizeof(t2p->pdf_fileid) - 8; i += 8)
5149 snprintf(t2p->pdf_fileid + i, 9, "%.8X", rand());
5150
5151 written += t2pWriteFile(output, (tdata_t) "trailer\n<<\n/Size ", 17);
5152 buflen = sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount+1));
5153 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5154 _TIFFmemset(buffer, 0x00, 32);
5155 written += t2pWriteFile(output, (tdata_t) "\n/Root ", 7);
5156 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_catalog);
5157 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5158 _TIFFmemset(buffer, 0x00, 32);
5159 written += t2pWriteFile(output, (tdata_t) " 0 R \n/Info ", 12);
5160 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_info);
5161 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5162 _TIFFmemset(buffer, 0x00, 32);
5163 written += t2pWriteFile(output, (tdata_t) " 0 R \n/ID[<", 11);
5164 written += t2pWriteFile(output, (tdata_t) t2p->pdf_fileid,
5165 sizeof(t2p->pdf_fileid) - 1);
5166 written += t2pWriteFile(output, (tdata_t) "><", 2);
5167 written += t2pWriteFile(output, (tdata_t) t2p->pdf_fileid,
5168 sizeof(t2p->pdf_fileid) - 1);
5169 written += t2pWriteFile(output, (tdata_t) ">]\n>>\nstartxref\n", 16);
5170 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_startxref);
5171 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5172 _TIFFmemset(buffer, 0x00, 32);
5173 written += t2pWriteFile(output, (tdata_t) "\n%%EOF\n", 7);
5174
5175 return(written);
5176 }
5177
5178 /*
5179
5180 This function writes a PDF to a file given a pointer to a TIFF.
5181
5182 The idea with using a TIFF* as output for a PDF file is that the file
5183 can be created with TIFFClientOpen for memory-mapped use within the TIFF
5184 library, and TIFFWriteEncodedStrip can be used to write compressed data to
5185 the output. The output is not actually a TIFF file, it is a PDF file.
5186
5187 This function uses only t2pWriteFile and TIFFWriteEncodedStrip to write to
5188 the output TIFF file. When libtiff would otherwise be writing data to the
5189 output file, the write procedure of the TIFF structure is replaced with an
5190 empty implementation.
5191
5192 The first argument to the function is an initialized and validated T2P
5193 context struct pointer.
5194
5195 The second argument to the function is the TIFF* that is the input that has
5196 been opened for reading and no other functions have been called upon it.
5197
5198 The third argument to the function is the TIFF* that is the output that has
5199 been opened for writing. It has to be opened so that it hasn't written any
5200 data to the output. If the output is seekable then it's OK to seek to the
5201 beginning of the file. The function only writes to the output PDF and does
5202 not seek. See the example usage in the main() function.
5203
5204 TIFF* output = TIFFOpen("output.pdf", "w");
5205 assert(output != NULL);
5206
5207 if(output->tif_seekproc != NULL){
5208 t2pSeekFile(output, (toff_t) 0, SEEK_SET);
5209 }
5210
5211 This function returns the file size of the output PDF file. On error it
5212 returns zero and the t2p->t2p_error variable is set to T2P_ERR_ERROR.
5213
5214 After this function completes, call t2p_free on t2p, TIFFClose on input,
5215 and TIFFClose on output.
5216 */
5217
5218 tsize_t t2p_write_pdf(T2P* t2p, TIFF* input, TIFF* output){
5219
5220 tsize_t written=0;
5221 ttile_t i2=0;
5222 tsize_t streamlen=0;
5223 uint16 i=0;
5224
5225 t2p_read_tiff_init(t2p, input);
5226 if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5227 t2p->pdf_xrefoffsets= (uint32*) _TIFFmalloc(t2p->pdf_xrefcount * sizeof(uint32) );
5228 if(t2p->pdf_xrefoffsets==NULL){
5229 TIFFError(
5230 TIFF2PDF_MODULE,
5231 "Can't allocate %u bytes of memory for t2p_write_pdf",
5232 (unsigned int) (t2p->pdf_xrefcount * sizeof(uint32)) );
5233 t2p->t2p_error = T2P_ERR_ERROR;
5234 return(written);
5235 }
5236 t2p->pdf_xrefcount=0;
5237 t2p->pdf_catalog=1;
5238 t2p->pdf_info=2;
5239 t2p->pdf_pages=3;
5240 written += t2p_write_pdf_header(t2p, output);
5241 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5242 t2p->pdf_catalog=t2p->pdf_xrefcount;
5243 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5244 written += t2p_write_pdf_catalog(t2p, output);
5245 written += t2p_write_pdf_obj_end(output);
5246 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5247 t2p->pdf_info=t2p->pdf_xrefcount;
5248 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5249 written += t2p_write_pdf_info(t2p, input, output);
5250 written += t2p_write_pdf_obj_end(output);
5251 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5252 t2p->pdf_pages=t2p->pdf_xrefcount;
5253 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5254 written += t2p_write_pdf_pages(t2p, output);
5255 written += t2p_write_pdf_obj_end(output);
5256 for(t2p->pdf_page=0;t2p->pdf_page<t2p->tiff_pagecount;t2p->pdf_page++){
5257 t2p_read_tiff_data(t2p, input);
5258 if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5259 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5260 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5261 written += t2p_write_pdf_page(t2p->pdf_xrefcount, t2p, output);
5262 written += t2p_write_pdf_obj_end(output);
5263 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5264 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5265 written += t2p_write_pdf_stream_dict_start(output);
5266 written += t2p_write_pdf_stream_dict(0, t2p->pdf_xrefcount+1, output);
5267 written += t2p_write_pdf_stream_dict_end(output);
5268 written += t2p_write_pdf_stream_start(output);
5269 streamlen=written;
5270 written += t2p_write_pdf_page_content_stream(t2p, output);
5271 streamlen=written-streamlen;
5272 written += t2p_write_pdf_stream_end(output);
5273 written += t2p_write_pdf_obj_end(output);
5274 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5275 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5276 written += t2p_write_pdf_stream_length(streamlen, output);
5277 written += t2p_write_pdf_obj_end(output);
5278 if(t2p->tiff_transferfunctioncount != 0){
5279 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5280 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5281 written += t2p_write_pdf_transfer(t2p, output);
5282 written += t2p_write_pdf_obj_end(output);
5283 for(i=0; i < t2p->tiff_transferfunctioncount; i++){
5284 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5285 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5286 written += t2p_write_pdf_stream_dict_start(output);
5287 written += t2p_write_pdf_transfer_dict(t2p, output, i);
5288 written += t2p_write_pdf_stream_dict_end(output);
5289 written += t2p_write_pdf_stream_start(output);
5290 streamlen=written;
5291 written += t2p_write_pdf_transfer_stream(t2p, output, i);
5292 streamlen=written-streamlen;
5293 written += t2p_write_pdf_stream_end(output);
5294 written += t2p_write_pdf_obj_end(output);
5295 }
5296 }
5297 if( (t2p->pdf_colorspace & T2P_CS_PALETTE) != 0){
5298 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5299 t2p->pdf_palettecs=t2p->pdf_xrefcount;
5300 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5301 written += t2p_write_pdf_stream_dict_start(output);
5302 written += t2p_write_pdf_stream_dict(t2p->pdf_palettesize, 0, output);
5303 written += t2p_write_pdf_stream_dict_end(output);
5304 written += t2p_write_pdf_stream_start(output);
5305 streamlen=written;
5306 written += t2p_write_pdf_xobject_palettecs_stream(t2p, output);
5307 streamlen=written-streamlen;
5308 written += t2p_write_pdf_stream_end(output);
5309 written += t2p_write_pdf_obj_end(output);
5310 }
5311 if( (t2p->pdf_colorspace & T2P_CS_ICCBASED) != 0){
5312 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5313 t2p->pdf_icccs=t2p->pdf_xrefcount;
5314 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5315 written += t2p_write_pdf_stream_dict_start(output);
5316 written += t2p_write_pdf_xobject_icccs_dict(t2p, output);
5317 written += t2p_write_pdf_stream_dict_end(output);
5318 written += t2p_write_pdf_stream_start(output);
5319 streamlen=written;
5320 written += t2p_write_pdf_xobject_icccs_stream(t2p, output);
5321 streamlen=written-streamlen;
5322 written += t2p_write_pdf_stream_end(output);
5323 written += t2p_write_pdf_obj_end(output);
5324 }
5325 if(t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount !=0){
5326 for(i2=0;i2<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i2++){
5327 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5328 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5329 written += t2p_write_pdf_stream_dict_start(output);
5330 written += t2p_write_pdf_xobject_stream_dict(
5331 i2+1,
5332 t2p,
5333 output);
5334 written += t2p_write_pdf_stream_dict_end(output);
5335 written += t2p_write_pdf_stream_start(output);
5336 streamlen=written;
5337 t2p_read_tiff_size_tile(t2p, input, i2);
5338 written += t2p_readwrite_pdf_image_tile(t2p, input, output, i2);
5339 t2p_write_advance_directory(t2p, output);
5340 if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5341 streamlen=written-streamlen;
5342 written += t2p_write_pdf_stream_end(output);
5343 written += t2p_write_pdf_obj_end(output);
5344 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5345 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5346 written += t2p_write_pdf_stream_length(streamlen, output);
5347 written += t2p_write_pdf_obj_end(output);
5348 }
5349 } else {
5350 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5351 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5352 written += t2p_write_pdf_stream_dict_start(output);
5353 written += t2p_write_pdf_xobject_stream_dict(
5354 0,
5355 t2p,
5356 output);
5357 written += t2p_write_pdf_stream_dict_end(output);
5358 written += t2p_write_pdf_stream_start(output);
5359 streamlen=written;
5360 t2p_read_tiff_size(t2p, input);
5361 written += t2p_readwrite_pdf_image(t2p, input, output);
5362 t2p_write_advance_directory(t2p, output);
5363 if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5364 streamlen=written-streamlen;
5365 written += t2p_write_pdf_stream_end(output);
5366 written += t2p_write_pdf_obj_end(output);
5367 t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5368 written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5369 written += t2p_write_pdf_stream_length(streamlen, output);
5370 written += t2p_write_pdf_obj_end(output);
5371 }
5372 }
5373 t2p->pdf_startxref = written;
5374 written += t2p_write_pdf_xreftable(t2p, output);
5375 written += t2p_write_pdf_trailer(t2p, output);
5376 t2p_disable(output);
5377
5378 return(written);
5379 }
5380
5381 /* vim: set ts=8 sts=8 sw=8 noet: */
5382 /*
5383 * Local Variables:
5384 * mode: c
5385 * c-basic-offset: 8
5386 * fill-column: 78
5387 * End:
5388 */
wxWidgets (Impactor)