]> git.saurik.com Git - wxWidgets.git/blame - src/tiff/tools/tiff2pdf.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
removing 10.5 version checks
[wxWidgets.git] / src / tiff / tools / tiff2pdf.c
CommitLineData
8414a40c
VZ		 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>
80ed523f 34#include <errno.h>
8414a40c
VZ		 35
36#if HAVE_UNISTD_H
37# include <unistd.h>
38#endif
39
80ed523f
VZ		 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"
8414a40c
VZ		 50#endif
51
80ed523f
VZ		 52#include "tiffiop.h"
53#include "tiffio.h"
54
55#ifndef HAVE_GETOPT
56extern int getopt(int, char**, char*);
57#endif
58
59#ifndef EXIT_SUCCESS
60# define EXIT_SUCCESS 0
8414a40c 61#endif
80ed523f
VZ		 62#ifndef EXIT_FAILURE
63# define EXIT_FAILURE 1
8414a40c
VZ		 64#endif
65
66#define TIFF2PDF_MODULE "tiff2pdf"
80ed523f
VZ		 67
68#define PS_UNIT_SIZE 72.0F
8414a40c
VZ		 69
70/* This type is of PDF color spaces. */
80ed523f
VZ		 71typedef 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 */
8414a40c
VZ		 81} t2p_cs_t;
82
83/* This type is of PDF compression types. */
84typedef 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. */
98typedef 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. */
104typedef 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. */
118typedef 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. */
124typedef 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. */
132typedef 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. */
141typedef struct {
142 T2P_BOX tile_box;
143} T2P_TILE;
144
145/* This struct defines information about the tiles on a PDF page. */
146typedef 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. */
158typedef 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;
8414a40c
VZ		 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;
80ed523f 190 int pdf_image_fillpage; /* 0 (default: no scaling, 1:scale imagesize to pagesize */
8414a40c
VZ		 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;
80ed523f
VZ		 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];
8414a40c
VZ		 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;
80ed523f
VZ		 246
247 /* fields for custom read/write procedures */
248 FILE *outputfile;
249 int outputdisable;
250 tsize_t outputwritten;
8414a40c
VZ		 251} T2P;
252
253/* These functions are called by main. */
254
255void tiff2pdf_usage(void);
256int tiff2pdf_match_paper_size(float*, float*, char*);
257
258/* These functions are used to generate a PDF from a TIFF. */
259
260#ifdef __cplusplus
261extern "C" {
262#endif
263
264T2P* t2p_init(void);
265void t2p_validate(T2P*);
266tsize_t t2p_write_pdf(T2P*, TIFF*, TIFF*);
267void t2p_free(T2P*);
268
269#ifdef __cplusplus
270}
271#endif
272
8414a40c
VZ		 273void t2p_read_tiff_init(T2P*, TIFF*);
274int t2p_cmp_t2p_page(const void*, const void*);
275void t2p_read_tiff_data(T2P*, TIFF*);
276void t2p_read_tiff_size(T2P*, TIFF*);
277void t2p_read_tiff_size_tile(T2P*, TIFF*, ttile_t);
278int t2p_tile_is_right_edge(T2P_TILES, ttile_t);
279int t2p_tile_is_bottom_edge(T2P_TILES, ttile_t);
280int t2p_tile_is_edge(T2P_TILES, ttile_t);
281int t2p_tile_is_corner_edge(T2P_TILES, ttile_t);
282tsize_t t2p_readwrite_pdf_image(T2P*, TIFF*, TIFF*);
283tsize_t t2p_readwrite_pdf_image_tile(T2P*, TIFF*, TIFF*, ttile_t);
284#ifdef OJPEG_SUPPORT
285int t2p_process_ojpeg_tables(T2P*, TIFF*);
286#endif
287#ifdef JPEG_SUPPORT
288int t2p_process_jpeg_strip(unsigned char*, tsize_t*, unsigned char*, tsize_t*, tstrip_t, uint32);
289#endif
290void t2p_tile_collapse_left(tdata_t, tsize_t, uint32, uint32, uint32);
291void t2p_write_advance_directory(T2P*, TIFF*);
292tsize_t t2p_sample_planar_separate_to_contig(T2P*, unsigned char*, unsigned char*, tsize_t);
293tsize_t t2p_sample_realize_palette(T2P*, unsigned char*);
294tsize_t t2p_sample_abgr_to_rgb(tdata_t, uint32);
295tsize_t t2p_sample_rgba_to_rgb(tdata_t, uint32);
296tsize_t t2p_sample_rgbaa_to_rgb(tdata_t, uint32);
297tsize_t t2p_sample_lab_signed_to_unsigned(tdata_t, uint32);
298tsize_t t2p_write_pdf_header(T2P*, TIFF*);
299tsize_t t2p_write_pdf_obj_start(uint32, TIFF*);
300tsize_t t2p_write_pdf_obj_end(TIFF*);
80ed523f 301tsize_t t2p_write_pdf_name(unsigned char*, TIFF*);
8414a40c
VZ		 302tsize_t t2p_write_pdf_string(char*, TIFF*);
303tsize_t t2p_write_pdf_stream(tdata_t, tsize_t, TIFF*);
304tsize_t t2p_write_pdf_stream_start(TIFF*);
305tsize_t t2p_write_pdf_stream_end(TIFF*);
306tsize_t t2p_write_pdf_stream_dict(tsize_t, uint32, TIFF*);
307tsize_t t2p_write_pdf_stream_dict_start(TIFF*);
308tsize_t t2p_write_pdf_stream_dict_end(TIFF*);
309tsize_t t2p_write_pdf_stream_length(tsize_t, TIFF*);
310tsize_t t2p_write_pdf_catalog(T2P*, TIFF*);
311tsize_t t2p_write_pdf_info(T2P*, TIFF*, TIFF*);
312void t2p_pdf_currenttime(T2P*);
313void t2p_pdf_tifftime(T2P*, TIFF*);
314tsize_t t2p_write_pdf_pages(T2P*, TIFF*);
315tsize_t t2p_write_pdf_page(uint32, T2P*, TIFF*);
316void t2p_compose_pdf_page(T2P*);
317void t2p_compose_pdf_page_orient(T2P_BOX*, uint16);
318void t2p_compose_pdf_page_orient_flip(T2P_BOX*, uint16);
319tsize_t t2p_write_pdf_page_content(T2P*, TIFF*);
320tsize_t t2p_write_pdf_xobject_stream_dict(ttile_t, T2P*, TIFF*);
321tsize_t t2p_write_pdf_xobject_cs(T2P*, TIFF*);
322tsize_t t2p_write_pdf_transfer(T2P*, TIFF*);
323tsize_t t2p_write_pdf_transfer_dict(T2P*, TIFF*, uint16);
324tsize_t t2p_write_pdf_transfer_stream(T2P*, TIFF*, uint16);
325tsize_t t2p_write_pdf_xobject_calcs(T2P*, TIFF*);
326tsize_t t2p_write_pdf_xobject_icccs(T2P*, TIFF*);
327tsize_t t2p_write_pdf_xobject_icccs_dict(T2P*, TIFF*);
328tsize_t t2p_write_pdf_xobject_icccs_stream(T2P*, TIFF*);
329tsize_t t2p_write_pdf_xobject_cs_stream(T2P*, TIFF*);
330tsize_t t2p_write_pdf_xobject_decode(T2P*, TIFF*);
331tsize_t t2p_write_pdf_xobject_stream_filter(ttile_t, T2P*, TIFF*);
332tsize_t t2p_write_pdf_xreftable(T2P*, TIFF*);
333tsize_t t2p_write_pdf_trailer(T2P*, TIFF*);
334
80ed523f
VZ		 335static void
336t2p_disable(TIFF *tif)
337{
338 T2P *t2p = (T2P*) TIFFClientdata(tif);
339 t2p->outputdisable = 1;
340}
341
342static void
343t2p_enable(TIFF *tif)
344{
345 T2P *t2p = (T2P*) TIFFClientdata(tif);
346 t2p->outputdisable = 0;
347}
348
349/*
350 * Procs for TIFFClientOpen
351 */
352
353static tmsize_t
354t2pReadFile(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
363static tmsize_t
364t2pWriteFile(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
373static uint64
374t2pSeekFile(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
383static tmsize_t
384t2p_readproc(thandle_t handle, tdata_t data, tmsize_t size)
385{
386 (void) handle, (void) data, (void) size;
387 return -1;
388}
389
390static tmsize_t
391t2p_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
402static uint64
403t2p_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
411static int
412t2p_closeproc(thandle_t handle)
413{
414 (void) handle;
415 return 0;
416}
417
418static uint64
419t2p_sizeproc(thandle_t handle)
420{
421 (void) handle;
422 return -1;
423}
424
425static int
426t2p_mapproc(thandle_t handle, void **data, toff_t *offset)
427{
428 (void) handle, (void) data, (void) offset;
429 return -1;
430}
431
432static void
433t2p_unmapproc(thandle_t handle, void *data, toff_t offset)
434{
435 (void) handle, (void) data, (void) offset;
436}
437
438static uint64
439checkAdd64(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
452static uint64
453checkMultiply64(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
8414a40c
VZ		 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
80ed523f
VZ		 538 -j: compress with JPEG (requires libjpeg configured with libtiff)
539 -z: compress with Zip/Deflate (requires zlib configured with libtiff)
8414a40c 540 -q: compression quality
80ed523f
VZ		 541 -n: no compressed data passthrough
542 -d: do not compress (decompress)
543 -i: invert colors
8414a40c
VZ		 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
80ed523f
VZ		 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
8414a40c
VZ		 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
80ed523f 561 -h: usage
8414a40c
VZ		 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
80ed523f 571 The above example would generate PDF output from input.tiff and write it
8414a40c
VZ		 572 to standard output.
573
574 tiff2pdf -j -p letter -o output.pdf input.tiff
575
80ed523f
VZ		 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
8414a40c
VZ		 578 with JPEG.
579
580 Please report bugs through:
80ed523f 581
8414a40c
VZ		 582 http://bugzilla.remotesensing.org/buglist.cgi?product=libtiff
583
584 See also libtiff.3t, tiffcp.
585 */
586
587int main(int argc, char** argv){
588
8414a40c 589 extern char *optarg;
80ed523f
VZ		 590 extern int optind;
591 const char *outfilename = NULL;
8414a40c
VZ		 592 T2P *t2p = NULL;
593 TIFF *input = NULL, *output = NULL;
80ed523f
VZ		 594 int c, ret = EXIT_SUCCESS;
595
8414a40c
VZ		 596 t2p = t2p_init();
597
598 if (t2p == NULL){
80ed523f
VZ		 599 TIFFError(TIFF2PDF_MODULE, "Can't initialize context");
600 goto fail;
8414a40c
VZ		 601 }
602
80ed523f
VZ		 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){
8414a40c
VZ		 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 =
80ed523f 659 ((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);
8414a40c
VZ		 660 break;
661 case 'l':
662 t2p->pdf_overridepagesize=1;
663 t2p->pdf_defaultpagelength =
80ed523f 664 ((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);
8414a40c
VZ		 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;
80ed523f
VZ		 686 case 'F':
687 t2p->pdf_image_fillpage = 1;
688 break;
8414a40c
VZ		 689 case 'f':
690 t2p->pdf_fitwindow=1;
691 break;
692 case 'e':
80ed523f
VZ		 693 if (strlen(optarg) == 0) {
694 t2p->pdf_datetime[0] = '\0';
8414a40c 695 } else {
80ed523f
VZ		 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';
8414a40c
VZ		 701 }
702 break;
703 case 'c':
80ed523f
VZ		 704 strncpy(t2p->pdf_creator, optarg, sizeof(t2p->pdf_creator) - 1);
705 t2p->pdf_creator[sizeof(t2p->pdf_creator) - 1] = '\0';
8414a40c
VZ		 706 break;
707 case 'a':
80ed523f
VZ		 708 strncpy(t2p->pdf_author, optarg, sizeof(t2p->pdf_author) - 1);
709 t2p->pdf_author[sizeof(t2p->pdf_author) - 1] = '\0';
8414a40c
VZ		 710 break;
711 case 't':
80ed523f
VZ		 712 strncpy(t2p->pdf_title, optarg, sizeof(t2p->pdf_title) - 1);
713 t2p->pdf_title[sizeof(t2p->pdf_title) - 1] = '\0';
8414a40c
VZ		 714 break;
715 case 's':
80ed523f
VZ		 716 strncpy(t2p->pdf_subject, optarg, sizeof(t2p->pdf_subject) - 1);
717 t2p->pdf_subject[sizeof(t2p->pdf_subject) - 1] = '\0';
8414a40c
VZ		 718 break;
719 case 'k':
80ed523f
VZ		 720 strncpy(t2p->pdf_keywords, optarg, sizeof(t2p->pdf_keywords) - 1);
721 t2p->pdf_keywords[sizeof(t2p->pdf_keywords) - 1] = '\0';
722 break;
8414a40c
VZ		 723 case 'b':
724 t2p->pdf_image_interpolate = 1;
725 break;
726 case 'h':
727 case '?':
728 tiff2pdf_usage();
80ed523f 729 goto success;
8414a40c
VZ		 730 break;
731 }
732 }
733
80ed523f
VZ		 734 /*
735 * Input
736 */
737 if(argc > optind) {
8414a40c 738 input = TIFFOpen(argv[optind++], "r");
80ed523f
VZ		 739 if (input==NULL) {
740 TIFFError(TIFF2PDF_MODULE,
741 "Can't open input file %s for reading",
742 argv[optind-1]);
743 goto fail;
8414a40c
VZ		 744 }
745 } else {
80ed523f 746 TIFFError(TIFF2PDF_MODULE, "No input file specified");
8414a40c 747 tiff2pdf_usage();
80ed523f 748 goto fail;
8414a40c
VZ		 749 }
750
80ed523f
VZ		 751 if(argc > optind) {
752 TIFFError(TIFF2PDF_MODULE,
753 "No support for multiple input files");
8414a40c 754 tiff2pdf_usage();
80ed523f 755 goto fail;
8414a40c
VZ		 756 }
757
80ed523f
VZ		 758 /*
759 * Output
760 */
761 t2p->outputdisable = 0;
8414a40c 762 if (outfilename) {
80ed523f
VZ		 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;
8414a40c
VZ		 769 }
770 } else {
80ed523f
VZ		 771 outfilename = "-";
772 t2p->outputfile = stdout;
8414a40c
VZ		 773 }
774
80ed523f
VZ		 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;
8414a40c 783 }
80ed523f
VZ		 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;
802fail:
803 ret = EXIT_FAILURE;
804success:
805 if(input != NULL)
8414a40c 806 TIFFClose(input);
80ed523f 807 if (output != NULL)
8414a40c 808 TIFFClose(output);
80ed523f 809 if (t2p != NULL)
8414a40c 810 t2p_free(t2p);
80ed523f
VZ		 811 return ret;
812
8414a40c
VZ		 813}
814
815void tiff2pdf_usage(){
816 char* lines[]={
817 "usage: tiff2pdf [options] input.tiff",
818 "options:",
819 " -o: output to file name",
820#ifdef JPEG_SUPPORT
80ed523f 821 " -j: compress with JPEG",
8414a40c
VZ		 822#endif
823#ifdef ZIP_SUPPORT
80ed523f 824 " -z: compress with Zip/Deflate",
8414a40c
VZ		 825#endif
826 " -q: compression quality",
80ed523f
VZ		 827 " -n: no compressed data passthrough",
828 " -d: do not compress (decompress)",
829 " -i: invert colors",
8414a40c
VZ		 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\"",
80ed523f
VZ		 837 " -F: make the tiff fill the PDF page",
838 " -f: set PDF \"Fit Window\" user preference",
8414a40c
VZ		 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",
80ed523f
VZ		 845 " -b: set PDF \"Interpolate\" user preference",
846 " -h: usage",
8414a40c
VZ		 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
859int tiff2pdf_match_paper_size(float* width, float* length, char* papersize){
860
80ed523f 861 size_t i, len;
8414a40c
VZ		 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/*
80ed523f
VZ		 920 * This function allocates and initializes a T2P context struct pointer.
921 */
8414a40c 922
80ed523f
VZ		 923T2P* t2p_init()
924{
8414a40c
VZ		 925 T2P* t2p = (T2P*) _TIFFmalloc(sizeof(T2P));
926 if(t2p==NULL){
927 TIFFError(
928 TIFF2PDF_MODULE,
80ed523f
VZ		 929 "Can't allocate %lu bytes of memory for t2p_init",
930 (unsigned long) sizeof(T2P));
8414a40c
VZ		 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/*
80ed523f
VZ		 946 * This function frees a T2P context struct pointer and any allocated data fields of it.
947 */
8414a40c 948
80ed523f
VZ		 949void t2p_free(T2P* t2p)
950{
951 int i = 0;
8414a40c 952
80ed523f 953 if (t2p != NULL) {
8414a40c
VZ		 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 }
8414a40c
VZ		 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
987void t2p_validate(T2P* t2p){
988
989#ifdef JPEG_SUPPORT
990 if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
80ed523f 991 if(t2p->pdf_defaultcompressionquality>100 ||
8414a40c
VZ		 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){
80ed523f
VZ		 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;
8414a40c
VZ		 1003 }
1004 if(t2p->pdf_defaultcompressionquality%100 !=0){
80ed523f
VZ		 1005 t2p->pdf_defaultcompressionquality/=100;
1006 t2p->pdf_defaultcompressionquality*=100;
8414a40c
VZ		 1007 TIFFError(
1008 TIFF2PDF_MODULE,
80ed523f 1009 "PNG Group predictor differencing not implemented, assuming compression quality %u",
8414a40c
VZ		 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
1029void 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,
80ed523f
VZ		 1042 "Can't allocate %lu bytes of memory for tiff_pages array, %s",
1043 (unsigned long) directorycount * sizeof(T2P_PAGE),
8414a40c
VZ		 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,
80ed523f
VZ		 1053 "Can't allocate %lu bytes of memory for tiff_tiles array, %s",
1054 (unsigned long) directorycount * sizeof(T2P_TILES),
8414a40c
VZ		 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));
80ed523f 1069 t2p->t2p_error = T2P_ERR_ERROR;
8414a40c
VZ		 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,
80ed523f
VZ		 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),
8414a40c
VZ		 1188 TIFFFileName(input));
1189 t2p->t2p_error = T2P_ERR_ERROR;
1190 return;
1191 }
1192 }
1193 }
1194
1195 return;
1196}
1197
1198/*
80ed523f
VZ		 1199 * This function is used by qsort to sort a T2P_PAGE* array of page structures
1200 * by page number.
1201 */
8414a40c
VZ		 1202
1203int 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
1220void 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",
80ed523f 1427 TIFFFileName(input));
8414a40c
VZ		 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",
80ed523f 1496 TIFFFileName(input));
8414a40c
VZ		 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);
80ed523f 1529 t2p->pdf_palette[(i*4)+3]= (unsigned char) (a[i]>>8);
8414a40c
VZ		 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",
80ed523f 1575 TIFFFileName(input));
8414a40c
VZ		 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 }
80ed523f
VZ		 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;
8414a40c
VZ		 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
1800void t2p_read_tiff_size(T2P* t2p, TIFF* input){
1801
80ed523f 1802 uint64* sbc=NULL;
8414a40c
VZ		 1803#if defined(JPEG_SUPPORT) || defined (OJPEG_SUPPORT)
1804 unsigned char* jpt=NULL;
8414a40c
VZ		 1805 tstrip_t i=0;
1806 tstrip_t stripcount=0;
1807#endif
80ed523f 1808 uint64 k = 0;
8414a40c
VZ		 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);
80ed523f 1814 t2p->tiff_datasize=(tmsize_t)sbc[0];
8414a40c
VZ		 1815 return;
1816 }
1817#endif
1818#ifdef ZIP_SUPPORT
1819 if(t2p->pdf_compression == T2P_COMPRESS_ZIP){
1820 TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
80ed523f 1821 t2p->tiff_datasize=(tmsize_t)sbc[0];
8414a40c
VZ		 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++){
80ed523f 1836 k = checkAdd64(k, sbc[i], t2p);
8414a40c
VZ		 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){
80ed523f 1841 if((uint64)t2p->tiff_datasize < k) {
8414a40c
VZ		 1842 TIFFWarning(TIFF2PDF_MODULE,
1843 "Input file %s has short JPEG interchange file byte count",
1844 TIFFFileName(input));
80ed523f
VZ		 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 }
8414a40c
VZ		 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 }
80ed523f
VZ		 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 }
8414a40c
VZ		 1875 return;
1876 }
1877#endif
1878#ifdef JPEG_SUPPORT
80ed523f
VZ		 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 */
8414a40c
VZ		 1885 }
1886 } else {
80ed523f 1887 k = 2; /* SOI for first strip */
8414a40c
VZ		 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++){
80ed523f
VZ		 1898 k = checkAdd64(k, sbc[i], t2p);
1899 k -=4; /* don't use SOI or EOI of strip */
8414a40c 1900 }
80ed523f
VZ		 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;
8414a40c
VZ		 1908 }
1909#endif
1910 (void) 0;
1911 }
80ed523f 1912 k = checkMultiply64(TIFFScanlineSize(input), t2p->tiff_length, t2p);
8414a40c 1913 if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
80ed523f
VZ		 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;
8414a40c
VZ		 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
1935void t2p_read_tiff_size_tile(T2P* t2p, TIFF* input, ttile_t tile){
1936
80ed523f 1937 uint64* tbc = NULL;
8414a40c
VZ		 1938 uint16 edge=0;
1939#ifdef JPEG_SUPPORT
8414a40c
VZ		 1940 unsigned char* jpt;
1941#endif
80ed523f 1942 uint64 k;
8414a40c
VZ		 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);
80ed523f
VZ		 1954 if (t2p->tiff_datasize == 0) {
1955 /* Assume we had overflow inside TIFFTileSize */
1956 t2p->t2p_error = T2P_ERR_ERROR;
1957 }
8414a40c
VZ		 1958 return;
1959 } else {
1960 TIFFGetField(input, TIFFTAG_TILEBYTECOUNTS, &tbc);
80ed523f 1961 k=tbc[tile];
8414a40c
VZ		 1962#ifdef OJPEG_SUPPORT
1963 if(t2p->tiff_compression==COMPRESSION_OJPEG){
80ed523f 1964 k = checkAdd64(k, 2048, t2p);
8414a40c
VZ		 1965 }
1966#endif
1967#ifdef JPEG_SUPPORT
80ed523f
VZ		 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 */
8414a40c
VZ		 1974 }
1975 }
1976 }
1977#endif
80ed523f
VZ		 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 }
8414a40c
VZ		 1983 return;
1984 }
1985 }
80ed523f 1986 k = TIFFTileSize(input);
8414a40c 1987 if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
80ed523f
VZ		 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;
8414a40c
VZ		 1999 }
2000
2001 return;
2002}
2003
2004/*
80ed523f
VZ		 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 */
8414a40c
VZ		 2008
2009int 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 }
8414a40c
VZ		 2017}
2018
2019/*
80ed523f
VZ		 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 */
8414a40c
VZ		 2023
2024int 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 }
8414a40c
VZ		 2032}
2033
2034/*
80ed523f
VZ		 2035 * This function returns a non-zero value when the tile is a right edge tile
2036 * or a bottom edge tile.
2037 */
8414a40c
VZ		 2038
2039int 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
2049int 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
8414a40c
VZ		 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
2061tsize_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;
8414a40c 2084 float* xfloatp;
80ed523f 2085 uint64* sbc;
8414a40c
VZ		 2086 unsigned char* stripbuffer;
2087 tsize_t striplength=0;
2088 uint32 max_striplength=0;
2089#endif
2090
80ed523f
VZ		 2091 /* Fail if prior error (in particular, can't trust tiff_datasize) */
2092 if (t2p->t2p_error != T2P_ERR_OK)
2093 return(0);
2094
8414a40c
VZ		 2095 if(t2p->pdf_transcode == T2P_TRANSCODE_RAW){
2096#ifdef CCITT_SUPPORT
2097 if(t2p->pdf_compression == T2P_COMPRESS_G4){
80ed523f
VZ		 2098 buffer = (unsigned char*)
2099 _TIFFmalloc(t2p->tiff_datasize);
2100 if (buffer == NULL) {
8414a40c 2101 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2102 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2103 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2104 TIFFFileName(input));
2105 t2p->t2p_error = T2P_ERR_ERROR;
2106 return(0);
2107 }
80ed523f
VZ		 2108 TIFFReadRawStrip(input, 0, (tdata_t) buffer,
2109 t2p->tiff_datasize);
8414a40c 2110 if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
80ed523f
VZ		 2111 /*
2112 * make sure is lsb-to-msb
2113 * bit-endianness fill order
2114 */
2115 TIFFReverseBits(buffer,
2116 t2p->tiff_datasize);
8414a40c 2117 }
80ed523f
VZ		 2118 t2pWriteFile(output, (tdata_t) buffer,
2119 t2p->tiff_datasize);
8414a40c
VZ		 2120 _TIFFfree(buffer);
2121 return(t2p->tiff_datasize);
2122 }
2123#endif
2124#ifdef ZIP_SUPPORT
80ed523f
VZ		 2125 if (t2p->pdf_compression == T2P_COMPRESS_ZIP) {
2126 buffer = (unsigned char*)
2127 _TIFFmalloc(t2p->tiff_datasize);
2128 if(buffer == NULL){
8414a40c 2129 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2130 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2131 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2132 TIFFFileName(input));
2133 t2p->t2p_error = T2P_ERR_ERROR;
2134 return(0);
2135 }
80ed523f
VZ		 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);
8414a40c 2142 }
80ed523f
VZ		 2143 t2pWriteFile(output, (tdata_t) buffer,
2144 t2p->tiff_datasize);
8414a40c
VZ		 2145 _TIFFfree(buffer);
2146 return(t2p->tiff_datasize);
2147 }
2148#endif
2149#ifdef OJPEG_SUPPORT
80ed523f 2150 if(t2p->tiff_compression == COMPRESSION_OJPEG) {
8414a40c 2151
80ed523f
VZ		 2152 if(t2p->tiff_dataoffset != 0) {
2153 buffer = (unsigned char*)
2154 _TIFFmalloc(t2p->tiff_datasize);
2155 if(buffer == NULL) {
8414a40c 2156 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2157 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2158 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2159 TIFFFileName(input));
2160 t2p->t2p_error = T2P_ERR_ERROR;
2161 return(0);
2162 }
80ed523f 2163 memset(buffer, 0, t2p->tiff_datasize);
8414a40c 2164 if(t2p->pdf_ojpegiflength==0){
80ed523f
VZ		 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);
8414a40c
VZ		 2176 _TIFFfree(buffer);
2177 return(t2p->tiff_datasize);
2178 } else {
80ed523f
VZ		 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);
8414a40c
VZ		 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;
80ed523f
VZ		 2200 TIFFGetField(input,
2201 TIFFTAG_ROWSPERSTRIP,
2202 &rows);
8414a40c
VZ		 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 }
80ed523f 2217 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
8414a40c
VZ		 2218 _TIFFfree(buffer);
2219 return(bufferoffset);
2220 }
2221 } else {
2222 if(! t2p->pdf_ojpegdata){
2223 TIFFError(TIFF2PDF_MODULE,
80ed523f 2224 "No support for OJPEG image %s with bad tables",
8414a40c
VZ		 2225 TIFFFileName(input));
2226 t2p->t2p_error = T2P_ERR_ERROR;
2227 return(0);
2228 }
80ed523f
VZ		 2229 buffer = (unsigned char*)
2230 _TIFFmalloc(t2p->tiff_datasize);
8414a40c
VZ		 2231 if(buffer==NULL){
2232 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2233 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2234 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2235 TIFFFileName(input));
2236 t2p->t2p_error = T2P_ERR_ERROR;
2237 return(0);
2238 }
80ed523f 2239 memset(buffer, 0, t2p->tiff_datasize);
8414a40c
VZ		 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 }
80ed523f 2257 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
8414a40c
VZ		 2258 _TIFFfree(buffer);
2259 return(bufferoffset);
2260 TIFFError(TIFF2PDF_MODULE,
80ed523f 2261 "No support for OJPEG image %s with no JPEG File Interchange offset",
8414a40c
VZ		 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
80ed523f
VZ		 2270 if(t2p->tiff_compression == COMPRESSION_JPEG) {
2271 uint32 count = 0;
2272 buffer = (unsigned char*)
2273 _TIFFmalloc(t2p->tiff_datasize);
8414a40c
VZ		 2274 if(buffer==NULL){
2275 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2276 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2277 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2278 TIFFFileName(input));
2279 t2p->t2p_error = T2P_ERR_ERROR;
2280 return(0);
2281 }
80ed523f
VZ		 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;
8414a40c
VZ		 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 }
80ed523f
VZ		 2294 stripbuffer = (unsigned char*)
2295 _TIFFmalloc(max_striplength);
8414a40c
VZ		 2296 if(stripbuffer==NULL){
2297 TIFFError(TIFF2PDF_MODULE,
80ed523f 2298 "Can't allocate %u bytes of memory for t2p_readwrite_pdf_image, %s",
8414a40c
VZ		 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,
80ed523f 2315 "Can't process JPEG data in input file %s",
8414a40c
VZ		 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;
80ed523f 2325 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
8414a40c
VZ		 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);
8414a40c
VZ		 2336 if(buffer==NULL){
2337 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2338 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2339 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2340 TIFFFileName(input));
2341 t2p->t2p_error = T2P_ERR_ERROR;
2342 return(0);
2343 }
80ed523f 2344 memset(buffer, 0, t2p->tiff_datasize);
8414a40c
VZ		 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);
8414a40c
VZ		 2374 if(buffer==NULL){
2375 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2376 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2377 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2378 TIFFFileName(input));
2379 t2p->t2p_error = T2P_ERR_ERROR;
2380 return(0);
2381 }
80ed523f 2382 memset(buffer, 0, t2p->tiff_datasize);
8414a40c
VZ		 2383 samplebuffer = (unsigned char*) _TIFFmalloc(stripsize);
2384 if(samplebuffer==NULL){
2385 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2386 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2387 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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,
80ed523f 2402 "Error on decoding strip %u of %s",
8414a40c
VZ		 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);
8414a40c
VZ		 2423 if(buffer==NULL){
2424 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2425 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2426 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 2427 TIFFFileName(input));
2428 t2p->t2p_error = T2P_ERR_ERROR;
2429 return(0);
2430 }
80ed523f 2431 memset(buffer, 0, t2p->tiff_datasize);
8414a40c
VZ		 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){
80ed523f 2454 // FIXME: overflow?
8414a40c
VZ		 2455 samplebuffer=(unsigned char*)_TIFFrealloc(
2456 (tdata_t) buffer,
2457 t2p->tiff_datasize * t2p->tiff_samplesperpixel);
2458 if(samplebuffer==NULL){
2459 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2460 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2461 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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,
80ed523f
VZ		 2490 "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2491 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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,
80ed523f 2507 "Can't use TIFFReadRGBAImageOriented to extract RGB image from %s",
8414a40c
VZ		 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
80ed523f 2525dataready:
8414a40c 2526
80ed523f 2527 t2p_disable(output);
8414a40c
VZ		 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:
80ed523f
VZ		 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);
8414a40c
VZ		 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,
80ed523f 2561 "Unable to use JPEG compression for input %s and output %s",
8414a40c
VZ		 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 }
80ed523f
VZ		 2610
2611 t2p_enable(output);
2612 t2p->outputwritten = 0;
8414a40c 2613#ifdef JPEG_SUPPORT
80ed523f
VZ		 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);
8414a40c
VZ		 2619 } else
2620#endif
80ed523f
VZ		 2621 {
2622 bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t)0,
2623 buffer,
2624 t2p->tiff_datasize);
2625 }
2626 if (buffer != NULL) {
8414a40c
VZ		 2627 _TIFFfree(buffer);
2628 buffer=NULL;
2629 }
2630
80ed523f 2631 if (bufferoffset == (tsize_t)-1) {
8414a40c 2632 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 2633 "Error writing encoded strip to output PDF %s",
2634 TIFFFileName(output));
8414a40c
VZ		 2635 t2p->t2p_error = T2P_ERR_ERROR;
2636 return(0);
2637 }
2638
80ed523f 2639 written = t2p->outputwritten;
8414a40c
VZ		 2640 return(written);
2641}
2642
2643/*
80ed523f
VZ		 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 */
8414a40c
VZ		 2648
2649tsize_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;
8414a40c
VZ		 2665 float* xfloatp;
2666 uint32 xuint32=0;
2667#endif
2668
80ed523f
VZ		 2669 /* Fail if prior error (in particular, can't trust tiff_datasize) */
2670 if (t2p->t2p_error != T2P_ERR_OK)
2671 return(0);
2672
8414a40c
VZ		 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,
80ed523f 2687 "Can't allocate %lu bytes of memory "
8414a40c 2688 "for t2p_readwrite_pdf_image_tile, %s",
80ed523f 2689 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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 }
80ed523f 2698 t2pWriteFile(output, (tdata_t) buffer, t2p->tiff_datasize);
8414a40c
VZ		 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,
80ed523f 2708 "Can't allocate %lu bytes of memory "
8414a40c 2709 "for t2p_readwrite_pdf_image_tile, %s",
80ed523f 2710 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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 }
80ed523f 2719 t2pWriteFile(output, (tdata_t) buffer, t2p->tiff_datasize);
8414a40c
VZ		 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,
80ed523f 2737 "Can't allocate %lu bytes of memory "
8414a40c 2738 "for t2p_readwrite_pdf_image, %s",
80ed523f 2739 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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;
80ed523f 2766 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
8414a40c
VZ		 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];
80ed523f 2774 uint32 count = 0;
8414a40c
VZ		 2775 buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2776 if(buffer==NULL){
2777 TIFFError(TIFF2PDF_MODULE,
80ed523f 2778 "Can't allocate %lu bytes of memory "
8414a40c
VZ		 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 }
80ed523f
VZ		 2785 if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0) {
2786 if (count > 0) {
2787 _TIFFmemcpy(buffer, jpt, count);
2788 bufferoffset += count - 2;
8414a40c
VZ		 2789 table_end[0] = buffer[bufferoffset-2];
2790 table_end[1] = buffer[bufferoffset-1];
2791 }
80ed523f 2792 if (count > 0) {
8414a40c
VZ		 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 }
80ed523f 2809 t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
8414a40c
VZ		 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,
80ed523f 2821 "Can't allocate %lu bytes of memory for "
8414a40c 2822 "t2p_readwrite_pdf_image_tile, %s",
80ed523f 2823 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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,
80ed523f 2854 "Can't allocate %lu bytes of memory "
8414a40c 2855 "for t2p_readwrite_pdf_image_tile, %s",
80ed523f 2856 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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,
80ed523f 2864 "Can't allocate %lu bytes of memory "
8414a40c 2865 "for t2p_readwrite_pdf_image_tile, %s",
80ed523f 2866 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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,
80ed523f 2903 "Can't allocate %lu bytes of memory "
8414a40c 2904 "for t2p_readwrite_pdf_image_tile, %s",
80ed523f 2905 (unsigned long) t2p->tiff_datasize,
8414a40c
VZ		 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
8414a40c 2966
80ed523f 2967 t2p_disable(output);
8414a40c
VZ		 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:
80ed523f
VZ		 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);
8414a40c
VZ		 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 }
80ed523f
VZ		 3067
3068 t2p_enable(output);
3069 t2p->outputwritten = 0;
3070 bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t) 0, buffer,
3071 TIFFStripSize(output));
3072 if (buffer != NULL) {
8414a40c 3073 _TIFFfree(buffer);
80ed523f 3074 buffer = NULL;
8414a40c 3075 }
80ed523f 3076 if (bufferoffset == -1) {
8414a40c 3077 TIFFError(TIFF2PDF_MODULE,
80ed523f
VZ		 3078 "Error writing encoded tile to output PDF %s",
3079 TIFFFileName(output));
8414a40c
VZ		 3080 t2p->t2p_error = T2P_ERR_ERROR;
3081 return(0);
3082 }
3083
80ed523f 3084 written = t2p->outputwritten;
8414a40c
VZ		 3085
3086 return(written);
3087}
3088
3089#ifdef OJPEG_SUPPORT
3090int 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));
80ed523f 3185 t2p->t2p_error = T2P_ERR_ERROR;
8414a40c
VZ		 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
3335int 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:
80ed523f
VZ		 3354 /* SOI - start of image */
3355 _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), 2);
3356 *bufferoffset+=2;
8414a40c
VZ		 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*/
3431void t2p_tile_collapse_left(
3432 tdata_t buffer,
3433 tsize_t scanwidth,
3434 uint32 tilewidth,
3435 uint32 edgetilewidth,
3436 uint32 tilelength){
3437
80ed523f 3438 uint32 i;
8414a40c
VZ		 3439 tsize_t edgescanwidth=0;
3440
3441 edgescanwidth = (scanwidth * edgetilewidth + (tilewidth - 1))/ tilewidth;
80ed523f 3442 for(i=0;i<tilelength;i++){
8414a40c
VZ		 3443 _TIFFmemcpy(
3444 &(((char*)buffer)[edgescanwidth*i]),
3445 &(((char*)buffer)[scanwidth*i]),
3446 edgescanwidth);
3447 }
3448
3449 return;
3450}
3451
3452
3453/*
80ed523f
VZ		 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 */
8414a40c 3458
80ed523f
VZ		 3459void
3460t2p_write_advance_directory(T2P* t2p, TIFF* output)
3461{
3462 t2p_disable(output);
8414a40c
VZ		 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 }
80ed523f 3470 t2p_enable(output);
8414a40c
VZ		 3471 return;
3472}
3473
3474tsize_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
3494tsize_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
3521tsize_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
3541tsize_t
3542t2p_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
3557tsize_t
3558t2p_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];
80ed523f
VZ		 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;
8414a40c
VZ		 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
3580tsize_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
3606tsize_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);
80ed523f
VZ		 3613 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3614 written += t2pWriteFile(output, (tdata_t)"\n%\342\343\317\323\n", 7);
8414a40c
VZ		 3615
3616 return(written);
3617}
3618
3619/*
3620 This function writes the beginning of a PDF object to output.
3621*/
3622
3623tsize_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);
80ed523f
VZ		 3630 written += t2pWriteFile(output, (tdata_t) buffer, buflen );
3631 written += t2pWriteFile(output, (tdata_t) " 0 obj\n", 7);
8414a40c
VZ		 3632
3633 return(written);
3634}
3635
3636/*
3637 This function writes the end of a PDF object to output.
3638*/
3639
3640tsize_t t2p_write_pdf_obj_end(TIFF* output){
3641
3642 tsize_t written=0;
3643
80ed523f 3644 written += t2pWriteFile(output, (tdata_t) "endobj\n", 7);
8414a40c
VZ		 3645
3646 return(written);
3647}
3648
3649/*
3650 This function writes a PDF name object to output.
3651*/
3652
80ed523f 3653tsize_t t2p_write_pdf_name(unsigned char* name, TIFF* output){
8414a40c
VZ		 3654
3655 tsize_t written=0;
3656 uint32 i=0;
80ed523f 3657 char buffer[64];
8414a40c 3658 uint16 nextchar=0;
80ed523f 3659 size_t namelen=0;
8414a40c 3660
80ed523f 3661 namelen = strlen((char *)name);
8414a40c
VZ		 3662 if (namelen>126) {
3663 namelen=126;
3664 }
80ed523f 3665 written += t2pWriteFile(output, (tdata_t) "/", 1);
8414a40c
VZ		 3666 for (i=0;i<namelen;i++){
3667 if ( ((unsigned char)name[i]) < 0x21){
3668 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3669 buffer[sizeof(buffer) - 1] = '\0';
3670 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3671 nextchar=1;
3672 }
3673 if ( ((unsigned char)name[i]) > 0x7E){
80ed523f
VZ		 3674 sprintf(buffer, "#%.2X", name[i]);
3675 buffer[sizeof(buffer) - 1] = '\0';
3676 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3677 nextchar=1;
3678 }
3679 if (nextchar==0){
3680 switch (name[i]){
3681 case 0x23:
80ed523f
VZ		 3682 sprintf(buffer, "#%.2X", name[i]);
3683 buffer[sizeof(buffer) - 1] = '\0';
3684 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3685 break;
3686 case 0x25:
80ed523f
VZ		 3687 sprintf(buffer, "#%.2X", name[i]);
3688 buffer[sizeof(buffer) - 1] = '\0';
3689 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3690 break;
3691 case 0x28:
80ed523f
VZ		 3692 sprintf(buffer, "#%.2X", name[i]);
3693 buffer[sizeof(buffer) - 1] = '\0';
3694 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3695 break;
3696 case 0x29:
3697 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3698 buffer[sizeof(buffer) - 1] = '\0';
3699 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3700 break;
3701 case 0x2F:
3702 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3703 buffer[sizeof(buffer) - 1] = '\0';
3704 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3705 break;
3706 case 0x3C:
3707 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3708 buffer[sizeof(buffer) - 1] = '\0';
3709 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3710 break;
3711 case 0x3E:
80ed523f
VZ		 3712 sprintf(buffer, "#%.2X", name[i]);
3713 buffer[sizeof(buffer) - 1] = '\0';
3714 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3715 break;
3716 case 0x5B:
3717 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3718 buffer[sizeof(buffer) - 1] = '\0';
3719 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3720 break;
3721 case 0x5D:
80ed523f
VZ		 3722 sprintf(buffer, "#%.2X", name[i]);
3723 buffer[sizeof(buffer) - 1] = '\0';
3724 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3725 break;
3726 case 0x7B:
3727 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3728 buffer[sizeof(buffer) - 1] = '\0';
3729 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3730 break;
3731 case 0x7D:
3732 sprintf(buffer, "#%.2X", name[i]);
80ed523f
VZ		 3733 buffer[sizeof(buffer) - 1] = '\0';
3734 written += t2pWriteFile(output, (tdata_t) buffer, 3);
8414a40c
VZ		 3735 break;
3736 default:
80ed523f 3737 written += t2pWriteFile(output, (tdata_t) &name[i], 1);
8414a40c
VZ		 3738 }
3739 }
3740 nextchar=0;
3741 }
80ed523f 3742 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c
VZ		 3743
3744 return(written);
3745}
3746
3747/*
80ed523f
VZ		 3748 * This function writes a PDF string object to output.
3749 */
8414a40c 3750
80ed523f
VZ		 3751tsize_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;
8414a40c 3757
80ed523f
VZ		 3758 len = strlen(pdfstr);
3759 written += t2pWriteFile(output, (tdata_t) "(", 1);
3760 for (i=0; i<len; i++) {
8414a40c 3761 if((pdfstr[i]&0x80) || (pdfstr[i]==127) || (pdfstr[i]<32)){
80ed523f
VZ		 3762 snprintf(buffer, sizeof(buffer), "\\%.3o", ((unsigned char)pdfstr[i]));
3763 written += t2pWriteFile(output, (tdata_t)buffer, 4);
8414a40c
VZ		 3764 } else {
3765 switch (pdfstr[i]){
3766 case 0x08:
80ed523f 3767 written += t2pWriteFile(output, (tdata_t) "\\b", 2);
8414a40c
VZ		 3768 break;
3769 case 0x09:
80ed523f 3770 written += t2pWriteFile(output, (tdata_t) "\\t", 2);
8414a40c
VZ		 3771 break;
3772 case 0x0A:
80ed523f 3773 written += t2pWriteFile(output, (tdata_t) "\\n", 2);
8414a40c
VZ		 3774 break;
3775 case 0x0C:
80ed523f 3776 written += t2pWriteFile(output, (tdata_t) "\\f", 2);
8414a40c
VZ		 3777 break;
3778 case 0x0D:
80ed523f 3779 written += t2pWriteFile(output, (tdata_t) "\\r", 2);
8414a40c
VZ		 3780 break;
3781 case 0x28:
80ed523f 3782 written += t2pWriteFile(output, (tdata_t) "\\(", 2);
8414a40c
VZ		 3783 break;
3784 case 0x29:
80ed523f 3785 written += t2pWriteFile(output, (tdata_t) "\\)", 2);
8414a40c
VZ		 3786 break;
3787 case 0x5C:
80ed523f 3788 written += t2pWriteFile(output, (tdata_t) "\\\\", 2);
8414a40c
VZ		 3789 break;
3790 default:
80ed523f 3791 written += t2pWriteFile(output, (tdata_t) &pdfstr[i], 1);
8414a40c
VZ		 3792 }
3793 }
3794 }
80ed523f 3795 written += t2pWriteFile(output, (tdata_t) ") ", 1);
8414a40c
VZ		 3796
3797 return(written);
3798}
3799
3800
3801/*
3802 This function writes a buffer of data to output.
3803*/
3804
3805tsize_t t2p_write_pdf_stream(tdata_t buffer, tsize_t len, TIFF* output){
3806
3807 tsize_t written=0;
3808
80ed523f 3809 written += t2pWriteFile(output, (tdata_t) buffer, len);
8414a40c
VZ		 3810
3811 return(written);
3812}
3813
3814/*
3815 This functions writes the beginning of a PDF stream to output.
3816*/
3817
3818tsize_t t2p_write_pdf_stream_start(TIFF* output){
3819
3820 tsize_t written=0;
3821
80ed523f 3822 written += t2pWriteFile(output, (tdata_t) "stream\n", 7);
8414a40c
VZ		 3823
3824 return(written);
3825}
3826
3827/*
3828 This function writes the end of a PDF stream to output.
3829*/
3830
3831tsize_t t2p_write_pdf_stream_end(TIFF* output){
3832
3833 tsize_t written=0;
3834
80ed523f 3835 written += t2pWriteFile(output, (tdata_t) "\nendstream\n", 11);
8414a40c
VZ		 3836
3837 return(written);
3838}
3839
3840/*
3841 This function writes a stream dictionary for a PDF stream to output.
3842*/
3843
3844tsize_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
80ed523f 3850 written += t2pWriteFile(output, (tdata_t) "/Length ", 8);
8414a40c
VZ		 3851 if(len!=0){
3852 written += t2p_write_pdf_stream_length(len, output);
3853 } else {
3854 buflen=sprintf(buffer, "%lu", (unsigned long)number);
80ed523f
VZ		 3855 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3856 written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
8414a40c
VZ		 3857 }
3858
3859 return(written);
3860}
3861
3862/*
3863 This functions writes the beginning of a PDF stream dictionary to output.
3864*/
3865
3866tsize_t t2p_write_pdf_stream_dict_start(TIFF* output){
3867
3868 tsize_t written=0;
3869
80ed523f 3870 written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
8414a40c
VZ		 3871
3872 return(written);
3873}
3874
3875/*
3876 This function writes the end of a PDF stream dictionary to output.
3877*/
3878
3879tsize_t t2p_write_pdf_stream_dict_end(TIFF* output){
3880
3881 tsize_t written=0;
3882
80ed523f 3883 written += t2pWriteFile(output, (tdata_t) " >>\n", 4);
8414a40c
VZ		 3884
3885 return(written);
3886}
3887
3888/*
3889 This function writes a number to output.
3890*/
3891
3892tsize_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);
80ed523f
VZ		 3899 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3900 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c
VZ		 3901
3902 return(written);
3903}
3904
3905/*
80ed523f
VZ		 3906 * This function writes the PDF Catalog structure to output.
3907 */
8414a40c 3908
80ed523f
VZ		 3909tsize_t t2p_write_pdf_catalog(T2P* t2p, TIFF* output)
3910{
3911 tsize_t written = 0;
8414a40c 3912 char buffer[16];
80ed523f 3913 int buflen = 0;
8414a40c 3914
80ed523f
VZ		 3915 written += t2pWriteFile(output,
3916 (tdata_t)"<< \n/Type /Catalog \n/Pages ",
8414a40c 3917 27);
80ed523f
VZ		 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);
8414a40c 3922 if(t2p->pdf_fitwindow){
80ed523f
VZ		 3923 written += t2pWriteFile(output,
3924 (tdata_t) "/ViewerPreferences <</FitWindow true>>\n",
8414a40c
VZ		 3925 39);
3926 }
80ed523f 3927 written += t2pWriteFile(output, (tdata_t)">>\n", 3);
8414a40c
VZ		 3928
3929 return(written);
3930}
3931
3932/*
3933 This function writes the PDF Info structure to output.
3934*/
3935
80ed523f
VZ		 3936tsize_t t2p_write_pdf_info(T2P* t2p, TIFF* input, TIFF* output)
3937{
3938 tsize_t written = 0;
8414a40c
VZ		 3939 char* info;
3940 char buffer[512];
80ed523f
VZ		 3941
3942 if(t2p->pdf_datetime[0] == '\0')
8414a40c 3943 t2p_pdf_tifftime(t2p, input);
80ed523f
VZ		 3944 if (strlen(t2p->pdf_datetime) > 0) {
3945 written += t2pWriteFile(output, (tdata_t) "<< \n/CreationDate ", 18);
8414a40c 3946 written += t2p_write_pdf_string(t2p->pdf_datetime, output);
80ed523f 3947 written += t2pWriteFile(output, (tdata_t) "\n/ModDate ", 10);
8414a40c
VZ		 3948 written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3949 }
80ed523f
VZ		 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);
8414a40c 3953 written += t2p_write_pdf_string(buffer, output);
80ed523f
VZ		 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);
8414a40c 3964 written += t2p_write_pdf_string(info, output);
80ed523f 3965 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c
VZ		 3966 }
3967 }
80ed523f
VZ		 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);
8414a40c 3979 written += t2p_write_pdf_string(info, output);
80ed523f 3980 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c 3981 }
80ed523f
VZ		 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);
8414a40c 3993 written += t2p_write_pdf_string(info, output);
80ed523f 3994 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c
VZ		 3995 }
3996 }
80ed523f
VZ		 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);
8414a40c 4006 written += t2p_write_pdf_string(info, output);
80ed523f 4007 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c
VZ		 4008 }
4009 }
80ed523f
VZ		 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);
8414a40c 4014 }
80ed523f 4015 written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
8414a40c
VZ		 4016
4017 return(written);
4018}
4019
4020/*
80ed523f
VZ		 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 */
8414a40c 4024
80ed523f
VZ		 4025void t2p_pdf_currenttime(T2P* t2p)
4026{
8414a40c
VZ		 4027 struct tm* currenttime;
4028 time_t timenow;
4029
80ed523f
VZ		 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);
8414a40c
VZ		 4045
4046 return;
4047}
4048
4049/*
80ed523f
VZ		 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 */
8414a40c 4053
80ed523f
VZ		 4054void t2p_pdf_tifftime(T2P* t2p, TIFF* input)
4055{
8414a40c
VZ		 4056 char* datetime;
4057
80ed523f
VZ		 4058 if (TIFFGetField(input, TIFFTAG_DATETIME, &datetime) != 0
4059 && (strlen(datetime) >= 19) ){
8414a40c
VZ		 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];
80ed523f 4076 t2p->pdf_datetime[16] = '\0';
8414a40c
VZ		 4077 } else {
4078 t2p_pdf_currenttime(t2p);
4079 }
4080
4081 return;
4082}
4083
4084/*
80ed523f
VZ		 4085 * This function writes a PDF Pages Tree structure to output.
4086 */
8414a40c 4087
80ed523f
VZ		 4088tsize_t t2p_write_pdf_pages(T2P* t2p, TIFF* output)
4089{
8414a40c
VZ		 4090 tsize_t written=0;
4091 tdir_t i=0;
4092 char buffer[16];
4093 int buflen=0;
4094
4095 int page=0;
80ed523f
VZ		 4096 written += t2pWriteFile(output,
4097 (tdata_t) "<< \n/Type /Pages \n/Kids [ ", 26);
8414a40c
VZ		 4098 page = t2p->pdf_pages+1;
4099 for (i=0;i<t2p->tiff_pagecount;i++){
4100 buflen=sprintf(buffer, "%d", page);
80ed523f
VZ		 4101 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4102 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
8414a40c 4103 if ( ((i+1)%8)==0 ) {
80ed523f 4104 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c
VZ		 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 }
80ed523f 4114 written += t2pWriteFile(output, (tdata_t) "] \n/Count ", 10);
8414a40c
VZ		 4115 _TIFFmemset(buffer, 0x00, 16);
4116 buflen=sprintf(buffer, "%d", t2p->tiff_pagecount);
80ed523f
VZ		 4117 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4118 written += t2pWriteFile(output, (tdata_t) " \n>> \n", 6);
8414a40c
VZ		 4119
4120 return(written);
4121}
4122
4123/*
4124 This function writes a PDF Page structure to output.
4125*/
4126
4127tsize_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;
80ed523f
VZ		 4133
4134 written += t2pWriteFile(output, (tdata_t) "<<\n/Type /Page \n/Parent ", 24);
8414a40c 4135 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_pages);
80ed523f
VZ		 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);
8414a40c 4139 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x1);
80ed523f
VZ		 4140 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4141 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c 4142 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y1);
80ed523f
VZ		 4143 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4144 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c 4145 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x2);
80ed523f
VZ		 4146 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4147 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c 4148 buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y2);
80ed523f
VZ		 4149 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4150 written += t2pWriteFile(output, (tdata_t) "] \n", 3);
4151 written += t2pWriteFile(output, (tdata_t) "/Contents ", 10);
8414a40c 4152 buflen=sprintf(buffer, "%lu", (unsigned long)(object + 1));
80ed523f
VZ		 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);
8414a40c 4156 if( t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount != 0 ){
80ed523f 4157 written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
8414a40c 4158 for(i=0;i<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i++){
80ed523f 4159 written += t2pWriteFile(output, (tdata_t) "/Im", 3);
8414a40c 4160 buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
80ed523f
VZ		 4161 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4162 written += t2pWriteFile(output, (tdata_t) "_", 1);
8414a40c 4163 buflen = sprintf(buffer, "%u", i+1);
80ed523f
VZ		 4164 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4165 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c
VZ		 4166 buflen = sprintf(
4167 buffer,
4168 "%lu",
4169 (unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
80ed523f
VZ		 4170 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4171 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
8414a40c 4172 if(i%4==3){
80ed523f 4173 written += t2pWriteFile(output, (tdata_t) "\n", 1);
8414a40c
VZ		 4174 }
4175 }
80ed523f 4176 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
8414a40c 4177 } else {
80ed523f
VZ		 4178 written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4179 written += t2pWriteFile(output, (tdata_t) "/Im", 3);
8414a40c 4180 buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
80ed523f
VZ		 4181 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4182 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c
VZ		 4183 buflen = sprintf(
4184 buffer,
4185 "%lu",
4186 (unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
80ed523f
VZ		 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);
8414a40c
VZ		 4190 }
4191 if(t2p->tiff_transferfunctioncount != 0) {
80ed523f
VZ		 4192 written += t2pWriteFile(output, (tdata_t) "/ExtGState <<", 13);
4193 t2pWriteFile(output, (tdata_t) "/GS1 ", 5);
8414a40c
VZ		 4194 buflen = sprintf(
4195 buffer,
4196 "%lu",
4197 (unsigned long)(object + 3));
80ed523f
VZ		 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);
8414a40c 4201 }
80ed523f 4202 written += t2pWriteFile(output, (tdata_t) "/ProcSet [ ", 11);
8414a40c
VZ		 4203 if(t2p->pdf_colorspace == T2P_CS_BILEVEL
4204 || t2p->pdf_colorspace == T2P_CS_GRAY
4205 ){
80ed523f 4206 written += t2pWriteFile(output, (tdata_t) "/ImageB ", 8);
8414a40c 4207 } else {
80ed523f 4208 written += t2pWriteFile(output, (tdata_t) "/ImageC ", 8);
8414a40c 4209 if(t2p->pdf_colorspace & T2P_CS_PALETTE){
80ed523f 4210 written += t2pWriteFile(output, (tdata_t) "/ImageI ", 8);
8414a40c
VZ		 4211 }
4212 }
80ed523f 4213 written += t2pWriteFile(output, (tdata_t) "]\n>>\n>>\n", 8);
8414a40c
VZ		 4214
4215 return(written);
4216}
4217
4218/*
4219 This function composes the page size and image and tile locations on a page.
4220*/
4221
4222void 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;
80ed523f
VZ		 4234 float width_ratio=0;
4235 float length_ratio=0;
8414a40c
VZ		 4236
4237 t2p->pdf_xres = t2p->tiff_xres;
4238 t2p->pdf_yres = t2p->tiff_yres;
80ed523f 4239 if(t2p->pdf_overrideres) {
8414a40c
VZ		 4240 t2p->pdf_xres = t2p->pdf_defaultxres;
4241 t2p->pdf_yres = t2p->pdf_defaultyres;
4242 }
80ed523f 4243 if(t2p->pdf_xres == 0.0)
8414a40c 4244 t2p->pdf_xres = t2p->pdf_defaultxres;
80ed523f 4245 if(t2p->pdf_yres == 0.0)
8414a40c 4246 t2p->pdf_yres = t2p->pdf_defaultyres;
80ed523f
VZ		 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;
8414a40c 4266 }
80ed523f 4267 if(t2p->pdf_overridepagesize != 0) {
8414a40c
VZ		 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
4421void 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
4496void 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
4558tsize_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,
80ed523f 4570 "q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d_%ld Do Q\n",
8414a40c
VZ		 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,
80ed523f 4585 "q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d Do Q\n",
8414a40c
VZ		 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
4604tsize_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);
80ed523f
VZ		 4613 written += t2pWriteFile(output,
4614 (tdata_t) "/Type /XObject \n/Subtype /Image \n/Name /Im",
8414a40c
VZ		 4615 42);
4616 buflen=sprintf(buffer, "%u", t2p->pdf_page+1);
80ed523f 4617 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 4618 if(tile != 0){
80ed523f 4619 written += t2pWriteFile(output, (tdata_t) "_", 1);
8414a40c 4620 buflen=sprintf(buffer, "%lu", (unsigned long)tile);
80ed523f 4621 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 4622 }
80ed523f 4623 written += t2pWriteFile(output, (tdata_t) "\n/Width ", 8);
8414a40c
VZ		 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 }
80ed523f
VZ		 4640 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4641 written += t2pWriteFile(output, (tdata_t) "\n/Height ", 9);
8414a40c
VZ		 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 }
80ed523f
VZ		 4658 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4659 written += t2pWriteFile(output, (tdata_t) "\n/BitsPerComponent ", 19);
8414a40c
VZ		 4660 _TIFFmemset((tdata_t)buffer, 0x00, 16);
4661 buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
80ed523f
VZ		 4662 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4663 written += t2pWriteFile(output, (tdata_t) "\n/ColorSpace ", 13);
8414a40c
VZ		 4664 written += t2p_write_pdf_xobject_cs(t2p, output);
4665 if (t2p->pdf_image_interpolate)
80ed523f
VZ		 4666 written += t2pWriteFile(output,
4667 (tdata_t) "\n/Interpolate true", 18);
8414a40c
VZ		 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
4686tsize_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){
80ed523f 4701 written += t2pWriteFile(output, (tdata_t) "[ /Indexed ", 11);
8414a40c
VZ		 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 );
80ed523f
VZ		 4706 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4707 written += t2pWriteFile(output, (tdata_t) " ", 1);
8414a40c
VZ		 4708 _TIFFmemset(buffer, 0x00, 16);
4709 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_palettecs );
80ed523f
VZ		 4710 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4711 written += t2pWriteFile(output, (tdata_t) " 0 R ]\n", 7);
8414a40c
VZ		 4712 return(written);
4713 }
4714 if(t2p->pdf_colorspace & T2P_CS_BILEVEL){
80ed523f 4715 written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
8414a40c
VZ		 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 {
80ed523f 4721 written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
8414a40c
VZ		 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 {
80ed523f 4728 written += t2pWriteFile(output, (tdata_t) "/DeviceRGB \n", 12);
8414a40c
VZ		 4729 }
4730 }
4731 if(t2p->pdf_colorspace & T2P_CS_CMYK){
80ed523f 4732 written += t2pWriteFile(output, (tdata_t) "/DeviceCMYK \n", 13);
8414a40c
VZ		 4733 }
4734 if(t2p->pdf_colorspace & T2P_CS_LAB){
80ed523f
VZ		 4735 written += t2pWriteFile(output, (tdata_t) "[/Lab << \n", 10);
4736 written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
8414a40c
VZ		 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;
80ed523f
VZ		 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",
8414a40c
VZ		 4747 t2p->pdf_labrange[0],
4748 t2p->pdf_labrange[1],
4749 t2p->pdf_labrange[2],
4750 t2p->pdf_labrange[3]);
80ed523f
VZ		 4751 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4752 written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
8414a40c
VZ		 4753
4754 }
4755
4756 return(written);
4757}
4758
4759tsize_t t2p_write_pdf_transfer(T2P* t2p, TIFF* output){
4760
4761 tsize_t written=0;
4762 char buffer[16];
4763 int buflen=0;
4764
80ed523f 4765 written += t2pWriteFile(output, (tdata_t) "<< /Type /ExtGState \n/TR ", 25);
8414a40c
VZ		 4766 if(t2p->tiff_transferfunctioncount == 1){
4767 buflen=sprintf(buffer, "%lu",
4768 (unsigned long)(t2p->pdf_xrefcount + 1));
80ed523f
VZ		 4769 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4770 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
8414a40c 4771 } else {
80ed523f 4772 written += t2pWriteFile(output, (tdata_t) "[ ", 2);
8414a40c
VZ		 4773 buflen=sprintf(buffer, "%lu",
4774 (unsigned long)(t2p->pdf_xrefcount + 1));
80ed523f
VZ		 4775 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4776 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
8414a40c
VZ		 4777 buflen=sprintf(buffer, "%lu",
4778 (unsigned long)(t2p->pdf_xrefcount + 2));
80ed523f
VZ		 4779 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4780 written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
8414a40c
VZ		 4781 buflen=sprintf(buffer, "%lu",
4782 (unsigned long)(t2p->pdf_xrefcount + 3));
80ed523f
VZ		 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);
8414a40c
VZ		 4786 }
4787
80ed523f 4788 written += t2pWriteFile(output, (tdata_t) " >> \n", 5);
8414a40c
VZ		 4789
4790 return(written);
4791}
4792
4793tsize_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;
80ed523f 4798 (void)i; /* XXX */
8414a40c 4799
80ed523f
VZ		 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);
8414a40c
VZ		 4807
4808 return(written);
4809}
4810
4811tsize_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],
80ed523f 4817 (((tsize_t)1)<<(t2p->tiff_bitspersample+1)),
8414a40c
VZ		 4818 output);
4819
4820 return(written);
4821}
4822
4823/*
4824 This function writes a PDF Image XObject Colorspace array to output.
4825*/
4826
4827tsize_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
80ed523f 4858 written += t2pWriteFile(output, (tdata_t) "[", 1);
8414a40c 4859 if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
80ed523f 4860 written += t2pWriteFile(output, (tdata_t) "/CalGray ", 9);
8414a40c
VZ		 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){
80ed523f 4869 written += t2pWriteFile(output, (tdata_t) "/CalRGB ", 8);
8414a40c
VZ		 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 }
80ed523f 4895 written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
8414a40c 4896 if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
80ed523f
VZ		 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);
8414a40c
VZ		 4901 }
4902 if(t2p->pdf_colorspace & T2P_CS_CALRGB){
80ed523f
VZ		 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",
8414a40c
VZ		 4908 X_R, Y_R, Z_R,
4909 X_G, Y_G, Z_G,
4910 X_B, Y_B, Z_B);
80ed523f
VZ		 4911 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4912 written += t2pWriteFile(output, (tdata_t) "/Gamma [2.2 2.2 2.2] \n", 22);
8414a40c 4913 }
80ed523f 4914 written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
8414a40c
VZ		 4915
4916 return(written);
4917}
4918
4919/*
4920 This function writes a PDF Image XObject Colorspace array to output.
4921*/
4922
4923tsize_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
80ed523f 4929 written += t2pWriteFile(output, (tdata_t) "[/ICCBased ", 11);
8414a40c 4930 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_icccs);
80ed523f
VZ		 4931 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4932 written += t2pWriteFile(output, (tdata_t) " 0 R] \n", 7);
8414a40c
VZ		 4933
4934 return(written);
4935}
4936
4937tsize_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
80ed523f
VZ		 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);
8414a40c
VZ		 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
4955tsize_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
4971tsize_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
4987tsize_t t2p_write_pdf_xobject_decode(T2P* t2p, TIFF* output){
4988
4989 tsize_t written=0;
4990 int i=0;
4991
80ed523f 4992 written += t2pWriteFile(output, (tdata_t) "/Decode [ ", 10);
8414a40c 4993 for (i=0;i<t2p->tiff_samplesperpixel;i++){
80ed523f 4994 written += t2pWriteFile(output, (tdata_t) "1 0 ", 4);
8414a40c 4995 }
80ed523f 4996 written += t2pWriteFile(output, (tdata_t) "]\n", 2);
8414a40c
VZ		 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
5006tsize_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 }
80ed523f 5015 written += t2pWriteFile(output, (tdata_t) "/Filter ", 8);
8414a40c
VZ		 5016 switch(t2p->pdf_compression){
5017#ifdef CCITT_SUPPORT
5018 case T2P_COMPRESS_G4:
80ed523f
VZ		 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);
8414a40c 5022 if(tile==0){
80ed523f 5023 written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
8414a40c
VZ		 5024 buflen=sprintf(buffer, "%lu",
5025 (unsigned long)t2p->tiff_width);
80ed523f
VZ		 5026 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5027 written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
8414a40c
VZ		 5028 buflen=sprintf(buffer, "%lu",
5029 (unsigned long)t2p->tiff_length);
80ed523f 5030 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c
VZ		 5031 } else {
5032 if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
80ed523f 5033 written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
8414a40c
VZ		 5034 buflen=sprintf(
5035 buffer,
5036 "%lu",
5037 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
80ed523f 5038 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 5039 } else {
80ed523f 5040 written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
8414a40c
VZ		 5041 buflen=sprintf(
5042 buffer,
5043 "%lu",
5044 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
80ed523f 5045 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c
VZ		 5046 }
5047 if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
80ed523f 5048 written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
8414a40c
VZ		 5049 buflen=sprintf(
5050 buffer,
5051 "%lu",
5052 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
80ed523f 5053 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 5054 } else {
80ed523f 5055 written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
8414a40c
VZ		 5056 buflen=sprintf(
5057 buffer,
5058 "%lu",
5059 (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
80ed523f 5060 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c
VZ		 5061 }
5062 }
5063 if(t2p->pdf_switchdecode == 0){
80ed523f 5064 written += t2pWriteFile(output, (tdata_t) " /BlackIs1 true ", 16);
8414a40c 5065 }
80ed523f 5066 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
8414a40c
VZ		 5067 break;
5068#endif
5069#ifdef JPEG_SUPPORT
5070 case T2P_COMPRESS_JPEG:
80ed523f 5071 written += t2pWriteFile(output, (tdata_t) "/DCTDecode ", 11);
8414a40c
VZ		 5072
5073 if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR) {
80ed523f
VZ		 5074 written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5075 written += t2pWriteFile(output, (tdata_t) "<< /ColorTransform 0 >>\n", 24);
8414a40c
VZ		 5076 }
5077 break;
5078#endif
5079#ifdef ZIP_SUPPORT
5080 case T2P_COMPRESS_ZIP:
80ed523f 5081 written += t2pWriteFile(output, (tdata_t) "/FlateDecode ", 13);
8414a40c 5082 if(t2p->pdf_compressionquality%100){
80ed523f
VZ		 5083 written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5084 written += t2pWriteFile(output, (tdata_t) "<< /Predictor ", 14);
8414a40c
VZ		 5085 _TIFFmemset(buffer, 0x00, 16);
5086 buflen=sprintf(buffer, "%u", t2p->pdf_compressionquality%100);
80ed523f
VZ		 5087 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5088 written += t2pWriteFile(output, (tdata_t) " /Columns ", 10);
8414a40c
VZ		 5089 _TIFFmemset(buffer, 0x00, 16);
5090 buflen = sprintf(buffer, "%lu",
5091 (unsigned long)t2p->tiff_width);
80ed523f
VZ		 5092 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5093 written += t2pWriteFile(output, (tdata_t) " /Colors ", 9);
8414a40c
VZ		 5094 _TIFFmemset(buffer, 0x00, 16);
5095 buflen=sprintf(buffer, "%u", t2p->tiff_samplesperpixel);
80ed523f
VZ		 5096 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5097 written += t2pWriteFile(output, (tdata_t) " /BitsPerComponent ", 19);
8414a40c
VZ		 5098 _TIFFmemset(buffer, 0x00, 16);
5099 buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
80ed523f
VZ		 5100 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5101 written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
8414a40c
VZ		 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
5116tsize_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
80ed523f 5123 written += t2pWriteFile(output, (tdata_t) "xref\n0 ", 7);
8414a40c 5124 buflen=sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount + 1));
80ed523f
VZ		 5125 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5126 written += t2pWriteFile(output, (tdata_t) " \n0000000000 65535 f \n", 22);
8414a40c 5127 for (i=0;i<t2p->pdf_xrefcount;i++){
80ed523f 5128 sprintf(buffer, "%.10lu 00000 n \n",
8414a40c 5129 (unsigned long)t2p->pdf_xrefoffsets[i]);
80ed523f 5130 written += t2pWriteFile(output, (tdata_t) buffer, 20);
8414a40c
VZ		 5131 }
5132
5133 return(written);
5134}
5135
5136/*
80ed523f 5137 * This function writes a PDF trailer to output.
8414a40c
VZ		 5138 */
5139
5140tsize_t t2p_write_pdf_trailer(T2P* t2p, TIFF* output)
5141{
5142
5143 tsize_t written = 0;
5144 char buffer[32];
5145 int buflen = 0;
80ed523f 5146 size_t i = 0;
8414a40c 5147
80ed523f
VZ		 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);
8414a40c 5152 buflen = sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount+1));
80ed523f 5153 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 5154 _TIFFmemset(buffer, 0x00, 32);
80ed523f 5155 written += t2pWriteFile(output, (tdata_t) "\n/Root ", 7);
8414a40c 5156 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_catalog);
80ed523f 5157 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 5158 _TIFFmemset(buffer, 0x00, 32);
80ed523f 5159 written += t2pWriteFile(output, (tdata_t) " 0 R \n/Info ", 12);
8414a40c 5160 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_info);
80ed523f 5161 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 5162 _TIFFmemset(buffer, 0x00, 32);
80ed523f
VZ		 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);
8414a40c 5170 buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_startxref);
80ed523f 5171 written += t2pWriteFile(output, (tdata_t) buffer, buflen);
8414a40c 5172 _TIFFmemset(buffer, 0x00, 32);
80ed523f 5173 written += t2pWriteFile(output, (tdata_t) "\n%%EOF\n", 7);
8414a40c
VZ		 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
80ed523f 5187 This function uses only t2pWriteFile and TIFFWriteEncodedStrip to write to
8414a40c
VZ		 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){
80ed523f 5208 t2pSeekFile(output, (toff_t) 0, SEEK_SET);
8414a40c
VZ		 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
5218tsize_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,
80ed523f
VZ		 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;
8414a40c
VZ		 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 }
80ed523f 5373 t2p->pdf_startxref = written;
8414a40c
VZ		 5374 written += t2p_write_pdf_xreftable(t2p, output);
5375 written += t2p_write_pdf_trailer(t2p, output);
80ed523f 5376 t2p_disable(output);
8414a40c
VZ		 5377
5378 return(written);
5379}
5380
5381/* vim: set ts=8 sts=8 sw=8 noet: */
80ed523f
VZ		 5382/*
5383 * Local Variables:
5384 * mode: c
5385 * c-basic-offset: 8
5386 * fill-column: 78
5387 * End:
5388 */
wxWidgets (Impactor)