source: tiff/trunk/tools/tiff2pdf.c @ 9472

Revision 9472, 156.4 KB checked in by cristy, 22 months ago (diff)
Line 
1/* $Id: tiff2pdf.c,v 1.69 2012-07-19 15:43:41 tgl Exp $
2 *
3 * tiff2pdf - converts a TIFF image to a PDF document
4 *
5 * Copyright (c) 2003 Ross Finlayson
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and
8 * its documentation for any purpose is hereby granted without fee, provided
9 * that (i) the above copyright notices and this permission notice appear in
10 * all copies of the software and related documentation, and (ii) the name of
11 * Ross Finlayson may not be used in any advertising or
12 * publicity relating to the software without the specific, prior written
13 * permission of Ross Finlayson.
14 *
15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
18 *
19 * IN NO EVENT SHALL ROSS FINLAYSON BE LIABLE FOR
20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 */
26
27#include "tif_config.h"
28
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <ctype.h>
33#include <time.h>
34#include <errno.h>
35
36#if HAVE_UNISTD_H
37# include <unistd.h>
38#endif
39
40#ifdef HAVE_FCNTL_H
41# include <fcntl.h>
42#endif
43
44#ifdef HAVE_IO_H
45# include <io.h>
46#endif
47
48#ifdef NEED_LIBPORT
49# include "libport.h"
50#endif
51
52#include "tiffiop.h"
53#include "tiffio.h"
54
55#ifndef HAVE_GETOPT
56extern int getopt(int, char**, char*);
57#endif
58
59#ifndef EXIT_SUCCESS
60# define EXIT_SUCCESS   0
61#endif
62#ifndef EXIT_FAILURE
63# define EXIT_FAILURE   1
64#endif
65
66#define TIFF2PDF_MODULE "tiff2pdf"
67
68#define PS_UNIT_SIZE    72.0F
69
70/* This type is of PDF color spaces. */
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 */
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;
176        uint16 tiff_resunit;
177        uint16 pdf_centimeters;
178        uint16 pdf_overrideres;
179        uint16 pdf_overridepagesize;
180        float pdf_defaultxres;
181        float pdf_defaultyres;
182        float pdf_xres;
183        float pdf_yres;
184        float pdf_defaultpagewidth;
185        float pdf_defaultpagelength;
186        float pdf_pagewidth;
187        float pdf_pagelength;
188        float pdf_imagewidth;
189        float pdf_imagelength;
190        int pdf_image_fillpage; /* 0 (default: no scaling, 1:scale imagesize to pagesize */
191        T2P_BOX pdf_mediabox;
192        T2P_BOX pdf_imagebox;
193        uint16 pdf_majorversion;
194        uint16 pdf_minorversion;
195        uint32 pdf_catalog;
196        uint32 pdf_pages;
197        uint32 pdf_info;
198        uint32 pdf_palettecs;
199        uint16 pdf_fitwindow;
200        uint32 pdf_startxref;
201#define TIFF2PDF_FILEID_SIZE 33
202        char pdf_fileid[TIFF2PDF_FILEID_SIZE];
203#define TIFF2PDF_DATETIME_SIZE 17
204        char pdf_datetime[TIFF2PDF_DATETIME_SIZE];
205#define TIFF2PDF_CREATOR_SIZE 512
206        char pdf_creator[TIFF2PDF_CREATOR_SIZE];
207#define TIFF2PDF_AUTHOR_SIZE 512
208        char pdf_author[TIFF2PDF_AUTHOR_SIZE];
209#define TIFF2PDF_TITLE_SIZE 512
210        char pdf_title[TIFF2PDF_TITLE_SIZE];
211#define TIFF2PDF_SUBJECT_SIZE 512
212        char pdf_subject[TIFF2PDF_SUBJECT_SIZE];
213#define TIFF2PDF_KEYWORDS_SIZE 512
214        char pdf_keywords[TIFF2PDF_KEYWORDS_SIZE];
215        t2p_cs_t pdf_colorspace;
216        uint16 pdf_colorspace_invert;
217        uint16 pdf_switchdecode;
218        uint16 pdf_palettesize;
219        unsigned char* pdf_palette;
220        int pdf_labrange[4];
221        t2p_compress_t pdf_defaultcompression;
222        uint16 pdf_defaultcompressionquality;
223        t2p_compress_t pdf_compression;
224        uint16 pdf_compressionquality;
225        uint16 pdf_nopassthrough;
226        t2p_transcode_t pdf_transcode;
227        t2p_sample_t pdf_sample;
228        uint32* pdf_xrefoffsets;
229        uint32 pdf_xrefcount;
230        tdir_t pdf_page;
231#ifdef OJPEG_SUPPORT
232        tdata_t pdf_ojpegdata;
233        uint32 pdf_ojpegdatalength;
234        uint32 pdf_ojpegiflength;
235#endif
236        float tiff_whitechromaticities[2];
237        float tiff_primarychromaticities[6];
238        float tiff_referenceblackwhite[2];
239        float* tiff_transferfunction[3];
240        int pdf_image_interpolate;      /* 0 (default) : do not interpolate,
241                                           1 : interpolate */
242        uint16 tiff_transferfunctioncount;
243        uint32 pdf_icccs;
244        uint32 tiff_iccprofilelength;
245        tdata_t tiff_iccprofile;
246
247        /* fields for custom read/write procedures */
248        FILE *outputfile;
249        int outputdisable;
250        tsize_t outputwritten;
251} T2P;
252
253/* These functions are called by main. */
254
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
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*);
301tsize_t t2p_write_pdf_name(unsigned char*, TIFF*);
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
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
466/*
467
468  This is the main function.
469
470  The program converts one TIFF file to one PDF file, including multiple page
471  TIFF files, tiled TIFF files, black and white. grayscale, and color TIFF
472  files that contain data of TIFF photometric interpretations of bilevel,
473  grayscale, RGB, YCbCr, CMYK separation, and ICC L*a*b* as supported by
474  libtiff and PDF.
475
476  If you have multiple TIFF files to convert into one PDF file then use tiffcp
477  or other program to concatenate the files into a multiple page TIFF file. 
478  If the input TIFF file is of huge dimensions (greater than 10000 pixels height
479  or width) convert the input image to a tiled TIFF if it is not already.
480
481  The standard output is standard output.  Set the output file name with the
482  "-o output.pdf" option.
483
484  All black and white files are compressed into a single strip CCITT G4 Fax
485  compressed PDF, unless tiled, where tiled black and white images are
486  compressed into tiled CCITT G4 Fax compressed PDF, libtiff CCITT support
487  is assumed.
488
489  Color and grayscale data can be compressed using either JPEG compression,
490  ITU-T T.81, or Zip/Deflate LZ77 compression, per PNG 1.2 and RFC 1951.  Set
491  the compression type using the -j or -z options.  JPEG compression support
492  requires that libtiff be configured with JPEG support, and Zip/Deflate
493  compression support requires that libtiff is configured with Zip support,
494  in tiffconf.h.  Use only one or the other of -j and -z.  The -q option
495  sets the image compression quality, that is 1-100 with libjpeg JPEG
496  compression and one of 1, 10, 11, 12, 13, 14, or 15 for PNG group compression
497  predictor methods, add 100, 200, ..., 900 to set zlib compression quality 1-9.
498  PNG Group differencing predictor methods are not currently implemented.
499
500  If the input TIFF contains single strip CCITT G4 Fax compressed information,
501  then that is written to the PDF file without transcoding, unless the options
502  of no compression and no passthrough are set, -d and -n.
503
504  If the input TIFF contains JPEG or single strip Zip/Deflate compressed
505  information, and they are configured, then that is written to the PDF file
506  without transcoding, unless the options of no compression and no passthrough
507  are set.
508
509  The default page size upon which the TIFF image is placed is determined by
510  the resolution and extent of the image data.  Default values for the TIFF
511  image resolution can be set using the -x and -y options.  The page size can
512  be set using the -p option for paper size, or -w and -l for paper width and
513  length, then each page of the TIFF image is centered on its page.  The
514  distance unit for default resolution and page width and length can be set
515  by the -u option, the default unit is inch.
516
517  Various items of the output document information can be set with the -e, -c,
518  -a, -t, -s, and -k tags.  Setting the argument of the option to "" for these
519  tags causes the relevant document information field to be not written.  Some
520  of the document information values otherwise get their information from the
521  input TIFF image, the software, author, document name, and image description.
522
523  The output PDF file conforms to the PDF 1.1 specification or PDF 1.2 if using
524  Zip/Deflate compression. 
525 
526  The Portable Document Format (PDF) specification is copyrighted by Adobe
527  Systems, Incorporated.  Todos derechos reservados.
528
529  Here is a listing of the usage example and the options to the tiff2pdf
530  program that is part of the libtiff distribution.  Options followed by
531  a colon have a required argument.
532 
533    usage:  tiff2pdf [options] input.tif
534
535    options:
536    -o: output to file name
537
538    -j: compress with JPEG (requires libjpeg configured with libtiff)
539    -z: compress with Zip/Deflate (requires zlib configured with libtiff)
540    -q: compression quality
541    -n: no compressed data passthrough
542    -d: do not compress (decompress)
543    -i: invert colors
544    -u: set distance unit, 'i' for inch, 'm' for centimeter
545    -x: set x resolution default
546    -y: set y resolution default
547    -w: width in units
548    -l: length in units
549    -r: 'd' for resolution default, 'o' for resolution override
550    -p: paper size, eg "letter", "legal", "a4"
551    -F: make the tiff fill the PDF page
552    -f: set pdf "fit window" user preference
553    -b: set PDF "Interpolate" user preference
554    -e: date, overrides image or current date/time default, YYYYMMDDHHMMSS
555    -c: creator, overrides image software default
556    -a: author, overrides image artist default
557    -t: title, overrides image document name default
558    -s: subject, overrides image image description default
559    -k: keywords
560
561    -h: usage
562
563    examples:
564
565        tiff2pdf -o output.pdf input.tiff
566
567    The above example would generate the file output.pdf from input.tiff.
568
569        tiff2pdf input.tiff
570
571    The above example would generate PDF output from input.tiff and write it
572    to standard output.
573
574        tiff2pdf -j -p letter -o output.pdf input.tiff
575
576    The above example would generate the file output.pdf from input.tiff,
577    putting the image pages on a letter sized page, compressing the output
578    with JPEG.
579
580        Please report bugs through:
581
582        http://bugzilla.remotesensing.org/buglist.cgi?product=libtiff
583
584    See also libtiff.3t, tiffcp.
585  */
586
587int main(int argc, char** argv){
588
589        extern char *optarg;
590        extern int optind;
591        const char *outfilename = NULL;
592        T2P *t2p = NULL;
593        TIFF *input = NULL, *output = NULL;
594        int c, ret = EXIT_SUCCESS;
595
596        t2p = t2p_init();
597
598        if (t2p == NULL){
599                TIFFError(TIFF2PDF_MODULE, "Can't initialize context");
600                goto fail;
601        }
602
603        while (argv &&
604               (c = getopt(argc, argv,
605                           "o:q:u:x:y:w:l:r:p:e:c:a:t:s:k:jzndifbhF")) != -1){
606                switch (c) {
607                        case 'o':
608                                outfilename = optarg;
609                                break;
610#ifdef JPEG_SUPPORT
611                        case 'j': 
612                                t2p->pdf_defaultcompression=T2P_COMPRESS_JPEG;
613                                break;
614#endif
615#ifndef JPEG_SUPPORT
616                        case 'j': 
617                                TIFFWarning(
618                                        TIFF2PDF_MODULE,
619                                        "JPEG support in libtiff required for JPEG compression, ignoring option");
620                                break;
621#endif
622#ifdef ZIP_SUPPORT
623                        case 'z': 
624                                t2p->pdf_defaultcompression=T2P_COMPRESS_ZIP;
625                                break;
626#endif
627#ifndef ZIP_SUPPORT
628                        case 'z': 
629                                TIFFWarning(
630                                        TIFF2PDF_MODULE,
631                                        "Zip support in libtiff required for Zip compression, ignoring option");
632                                break;
633#endif
634                        case 'q':
635                                t2p->pdf_defaultcompressionquality=atoi(optarg);
636                                break;
637                        case 'n':
638                                t2p->pdf_nopassthrough=1;
639                                break;
640                        case 'd':
641                                t2p->pdf_defaultcompression=T2P_COMPRESS_NONE;
642                                break;
643                        case 'u':
644                                if(optarg[0]=='m'){
645                                        t2p->pdf_centimeters=1;
646                                }
647                                break;
648                        case 'x':
649                                t2p->pdf_defaultxres =
650                                        (float)atof(optarg) / (t2p->pdf_centimeters?2.54F:1.0F);
651                                break;
652                        case 'y':
653                                t2p->pdf_defaultyres =
654                                        (float)atof(optarg) / (t2p->pdf_centimeters?2.54F:1.0F);
655                                break;
656                        case 'w':
657                                t2p->pdf_overridepagesize=1;
658                                t2p->pdf_defaultpagewidth =
659                                        ((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);
660                                break;
661                        case 'l':
662                                t2p->pdf_overridepagesize=1;
663                                t2p->pdf_defaultpagelength =
664                                        ((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);
665                                break;
666                        case 'r':
667                                if(optarg[0]=='o'){
668                                        t2p->pdf_overrideres=1;
669                                }
670                                break;
671                        case 'p':
672                                if(tiff2pdf_match_paper_size(
673                                        &(t2p->pdf_defaultpagewidth),
674                                        &(t2p->pdf_defaultpagelength),
675                                        optarg)){
676                                        t2p->pdf_overridepagesize=1;
677                                } else {
678                                        TIFFWarning(TIFF2PDF_MODULE,
679                                        "Unknown paper size %s, ignoring option",
680                                                optarg);
681                                }
682                                break;
683                        case 'i':
684                                t2p->pdf_colorspace_invert=1;
685                                break;
686                        case 'F':
687                                t2p->pdf_image_fillpage = 1;
688                                break;
689                        case 'f':
690                                t2p->pdf_fitwindow=1;
691                                break;
692                        case 'e':
693                                if (strlen(optarg) == 0) {
694                                        t2p->pdf_datetime[0] = '\0';
695                                } else {
696                                        t2p->pdf_datetime[0] = 'D';
697                                        t2p->pdf_datetime[1] = ':';
698                                        strncpy(t2p->pdf_datetime + 2, optarg,
699                                                sizeof(t2p->pdf_datetime) - 3);
700                                        t2p->pdf_datetime[sizeof(t2p->pdf_datetime) - 1] = '\0';
701                                }
702                                break;
703                        case 'c':
704                                strncpy(t2p->pdf_creator, optarg, sizeof(t2p->pdf_creator) - 1);
705                                t2p->pdf_creator[sizeof(t2p->pdf_creator) - 1] = '\0';
706                                break;
707                        case 'a':
708                                strncpy(t2p->pdf_author, optarg, sizeof(t2p->pdf_author) - 1);
709                                t2p->pdf_author[sizeof(t2p->pdf_author) - 1] = '\0';
710                                break;
711                        case 't':
712                                strncpy(t2p->pdf_title, optarg, sizeof(t2p->pdf_title) - 1);
713                                t2p->pdf_title[sizeof(t2p->pdf_title) - 1] = '\0';
714                                break;
715                        case 's':
716                                strncpy(t2p->pdf_subject, optarg, sizeof(t2p->pdf_subject) - 1);
717                                t2p->pdf_subject[sizeof(t2p->pdf_subject) - 1] = '\0';
718                                break;
719                        case 'k':
720                                strncpy(t2p->pdf_keywords, optarg, sizeof(t2p->pdf_keywords) - 1);
721                                t2p->pdf_keywords[sizeof(t2p->pdf_keywords) - 1] = '\0';
722                                break;
723                        case 'b':
724                                t2p->pdf_image_interpolate = 1;
725                                break;
726                        case 'h':
727                        case '?':
728                                tiff2pdf_usage();
729                                goto success;
730                                break;
731                }
732        }
733
734        /*
735         * Input
736         */
737        if(argc > optind) {
738                input = TIFFOpen(argv[optind++], "r");
739                if (input==NULL) {
740                        TIFFError(TIFF2PDF_MODULE,
741                                  "Can't open input file %s for reading",
742                                  argv[optind-1]);
743                        goto fail;
744                }
745        } else {
746                TIFFError(TIFF2PDF_MODULE, "No input file specified");
747                tiff2pdf_usage();
748                goto fail;
749        }
750
751        if(argc > optind) {
752                TIFFError(TIFF2PDF_MODULE,
753                          "No support for multiple input files");
754                tiff2pdf_usage();
755                goto fail;
756        }
757
758        /*
759         * Output
760         */
761        t2p->outputdisable = 0;
762        if (outfilename) {
763                t2p->outputfile = fopen(outfilename, "wb");
764                if (t2p->outputfile == NULL) {
765                        TIFFError(TIFF2PDF_MODULE,
766                                  "Can't open output file %s for writing",
767                                  outfilename);
768                        goto fail;
769                }
770        } else {
771                outfilename = "-";
772                t2p->outputfile = stdout;
773        }
774
775        output = TIFFClientOpen(outfilename, "w", (thandle_t) t2p,
776                                t2p_readproc, t2p_writeproc, t2p_seekproc,
777                                t2p_closeproc, t2p_sizeproc,
778                                t2p_mapproc, t2p_unmapproc);
779        if (output == NULL) {
780                TIFFError(TIFF2PDF_MODULE,
781                          "Can't initialize output descriptor");
782                goto fail;
783        }
784       
785        /*
786         * Validate
787         */
788        t2p_validate(t2p);
789        t2pSeekFile(output, (toff_t) 0, SEEK_SET);
790
791        /*
792         * Write
793         */
794        t2p_write_pdf(t2p, input, output);
795        if (t2p->t2p_error != 0) {
796                TIFFError(TIFF2PDF_MODULE,
797                          "An error occurred creating output PDF file");
798                goto fail;
799        }
800
801        goto success;
802fail:
803        ret = EXIT_FAILURE;
804success:
805        if(input != NULL)
806                TIFFClose(input);
807        if (output != NULL)
808                TIFFClose(output);
809        if (t2p != NULL)
810                t2p_free(t2p);
811        return ret;
812 
813}
814
815void tiff2pdf_usage(){
816        char* lines[]={
817        "usage:  tiff2pdf [options] input.tiff",
818        "options:",
819        " -o: output to file name",
820#ifdef JPEG_SUPPORT
821        " -j: compress with JPEG",
822#endif
823#ifdef ZIP_SUPPORT
824        " -z: compress with Zip/Deflate",
825#endif
826        " -q: compression quality",
827        " -n: no compressed data passthrough",
828        " -d: do not compress (decompress)",
829        " -i: invert colors",
830        " -u: set distance unit, 'i' for inch, 'm' for centimeter",
831        " -x: set x resolution default in dots per unit",
832        " -y: set y resolution default in dots per unit",
833        " -w: width in units",
834        " -l: length in units",
835        " -r: 'd' for resolution default, 'o' for resolution override",
836        " -p: paper size, eg \"letter\", \"legal\", \"A4\"",
837  " -F: make the tiff fill the PDF page",
838        " -f: set PDF \"Fit Window\" user preference",
839        " -e: date, overrides image or current date/time default, YYYYMMDDHHMMSS",
840        " -c: sets document creator, overrides image software default",
841        " -a: sets document author, overrides image artist default",
842        " -t: sets document title, overrides image document name default",
843        " -s: sets document subject, overrides image image description default",
844        " -k: sets document keywords",
845        " -b: set PDF \"Interpolate\" user preference",
846        " -h: usage",
847        NULL
848        };
849        int i=0;
850
851        fprintf(stderr, "%s\n\n", TIFFGetVersion());
852        for (i=0;lines[i]!=NULL;i++){
853                fprintf(stderr, "%s\n", lines[i]);
854        }
855
856        return;
857}
858
859int tiff2pdf_match_paper_size(float* width, float* length, char* papersize){
860
861        size_t i, len;
862        const char* sizes[]={
863                "LETTER", "A4", "LEGAL",
864                "EXECUTIVE", "LETTER", "LEGAL", "LEDGER", "TABLOID",
865                "A", "B", "C", "D", "E", "F", "G", "H", "J", "K",
866                "A10", "A9", "A8", "A7", "A6", "A5", "A4", "A3", "A2", "A1", "A0",
867                "2A0", "4A0", "2A", "4A",
868                "B10", "B9", "B8", "B7", "B6", "B5", "B4", "B3", "B2", "B1", "B0",
869                "JISB10", "JISB9", "JISB8", "JISB7", "JISB6", "JISB5", "JISB4",
870                "JISB3", "JISB2", "JISB1", "JISB0",
871                "C10", "C9", "C8", "C7", "C6", "C5", "C4", "C3", "C2", "C1", "C0",
872                "RA2", "RA1", "RA0", "SRA4", "SRA3", "SRA2", "SRA1", "SRA0",
873                "A3EXTRA", "A4EXTRA",
874                "STATEMENT", "FOLIO", "QUARTO",
875                NULL
876        } ;
877        const int widths[]={
878                612, 595, 612,
879                522, 612,612,792,792,
880                612,792,1224,1584,2448,2016,792,2016,2448,2880,
881                74,105,147,210,298,420,595,842,1191,1684,2384,3370,4768,3370,4768,
882                88,125,176,249,354,499,709,1001,1417,2004,2835,
883                91,128,181,258,363,516,729,1032,1460,2064,2920,
884                79,113,162,230,323,459,649,918,1298,1298,2599,
885                1219,1729,2438,638,907,1276,1814,2551,
886                914,667,
887                396, 612, 609,
888                0
889        };
890        const int lengths[]={
891                792,842,1008,
892                756,792,1008,1224,1224,
893                792,1224,1584,2448,3168,2880,6480,10296,12672,10296,
894                105,147,210,298,420,595,842,1191,1684,2384,3370,4768,6741,4768,6741,
895                125,176,249,354,499,709,1001,1417,2004,2835,4008,
896                128,181,258,363,516,729,1032,1460,2064,2920,4127,
897                113,162,230,323,459,649,918,1298,1837,1837,3677,
898                1729,2438,3458,907,1276,1814,2551,3628,
899                1262,914,
900                612, 936, 780,
901                0
902        };
903
904        len=strlen(papersize);
905        for(i=0;i<len;i++){
906                papersize[i]=toupper(papersize[i]);
907        }
908        for(i=0;sizes[i]!=NULL; i++){
909                if (strcmp( (const char*)papersize, sizes[i])==0){
910                        *width=(float)widths[i];
911                        *length=(float)lengths[i];
912                        return(1);
913                }
914        }
915
916        return(0);
917}
918
919/*
920 * This function allocates and initializes a T2P context struct pointer.
921 */
922
923T2P* t2p_init()
924{
925        T2P* t2p = (T2P*) _TIFFmalloc(sizeof(T2P));
926        if(t2p==NULL){
927                TIFFError(
928                        TIFF2PDF_MODULE,
929                        "Can't allocate %lu bytes of memory for t2p_init",
930                        (unsigned long) sizeof(T2P));
931                return( (T2P*) NULL );
932        }
933        _TIFFmemset(t2p, 0x00, sizeof(T2P));
934        t2p->pdf_majorversion=1;
935        t2p->pdf_minorversion=1;
936        t2p->pdf_defaultxres=300.0;
937        t2p->pdf_defaultyres=300.0;
938        t2p->pdf_defaultpagewidth=612.0;
939        t2p->pdf_defaultpagelength=792.0;
940        t2p->pdf_xrefcount=3; /* Catalog, Info, Pages */
941       
942        return(t2p);
943}
944
945/*
946 * This function frees a T2P context struct pointer and any allocated data fields of it.
947 */
948
949void t2p_free(T2P* t2p)
950{
951        int i = 0;
952
953        if (t2p != NULL) {
954                if(t2p->pdf_xrefoffsets != NULL){
955                        _TIFFfree( (tdata_t) t2p->pdf_xrefoffsets);
956                }
957                if(t2p->tiff_pages != NULL){
958                        _TIFFfree( (tdata_t) t2p->tiff_pages);
959                }
960                for(i=0;i<t2p->tiff_pagecount;i++){
961                        if(t2p->tiff_tiles[i].tiles_tiles != NULL){
962                                _TIFFfree( (tdata_t) t2p->tiff_tiles[i].tiles_tiles);
963                        }
964                }
965                if(t2p->tiff_tiles != NULL){
966                        _TIFFfree( (tdata_t) t2p->tiff_tiles);
967                }
968                if(t2p->pdf_palette != NULL){
969                        _TIFFfree( (tdata_t) t2p->pdf_palette);
970                }
971#ifdef OJPEG_SUPPORT
972                if(t2p->pdf_ojpegdata != NULL){
973                        _TIFFfree( (tdata_t) t2p->pdf_ojpegdata);
974                }
975#endif
976                _TIFFfree( (tdata_t) t2p );
977        }
978
979        return;
980}
981
982/*
983        This function validates the values of a T2P context struct pointer
984        before calling t2p_write_pdf with it.
985*/
986
987void t2p_validate(T2P* t2p){
988
989#ifdef JPEG_SUPPORT
990        if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
991                if(t2p->pdf_defaultcompressionquality>100 ||
992                        t2p->pdf_defaultcompressionquality<1){
993                        t2p->pdf_defaultcompressionquality=0;
994                }
995        }
996#endif
997#ifdef ZIP_SUPPORT
998        if(t2p->pdf_defaultcompression==T2P_COMPRESS_ZIP){
999                uint16 m=t2p->pdf_defaultcompressionquality%100;
1000                if(t2p->pdf_defaultcompressionquality/100 > 9 ||
1001                        (m>1 && m<10) || m>15){
1002                        t2p->pdf_defaultcompressionquality=0;
1003                }
1004                if(t2p->pdf_defaultcompressionquality%100 !=0){
1005                        t2p->pdf_defaultcompressionquality/=100;
1006                        t2p->pdf_defaultcompressionquality*=100;
1007                        TIFFError(
1008                                TIFF2PDF_MODULE,
1009                                "PNG Group predictor differencing not implemented, assuming compression quality %u",
1010                                t2p->pdf_defaultcompressionquality);
1011                }
1012                t2p->pdf_defaultcompressionquality%=100;
1013                if(t2p->pdf_minorversion<2){t2p->pdf_minorversion=2;}
1014        }
1015#endif
1016        (void)0;
1017
1018        return;
1019}
1020
1021
1022/*
1023        This function scans the input TIFF file for pages.  It attempts
1024        to determine which IFD's of the TIFF file contain image document
1025        pages.  For each, it gathers some information that has to do
1026        with the output of the PDF document as a whole. 
1027*/
1028
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,
1042                        "Can't allocate %lu bytes of memory for tiff_pages array, %s",
1043                        (unsigned long) directorycount * sizeof(T2P_PAGE),
1044                        TIFFFileName(input));
1045                t2p->t2p_error = T2P_ERR_ERROR;
1046                return;
1047        }
1048        _TIFFmemset( t2p->tiff_pages, 0x00, directorycount * sizeof(T2P_PAGE));
1049        t2p->tiff_tiles = (T2P_TILES*) _TIFFmalloc(directorycount * sizeof(T2P_TILES));
1050        if(t2p->tiff_tiles==NULL){
1051                TIFFError(
1052                        TIFF2PDF_MODULE,
1053                        "Can't allocate %lu bytes of memory for tiff_tiles array, %s",
1054                        (unsigned long) directorycount * sizeof(T2P_TILES),
1055                        TIFFFileName(input));
1056                t2p->t2p_error = T2P_ERR_ERROR;
1057                return;
1058        }
1059        _TIFFmemset( t2p->tiff_tiles, 0x00, directorycount * sizeof(T2P_TILES));
1060        for(i=0;i<directorycount;i++){
1061                uint32 subfiletype = 0;
1062               
1063                if(!TIFFSetDirectory(input, i)){
1064                        TIFFError(
1065                                TIFF2PDF_MODULE,
1066                                "Can't set directory %u of input file %s",
1067                                i,
1068                                TIFFFileName(input));
1069                        t2p->t2p_error = T2P_ERR_ERROR;
1070                        return;
1071                }
1072                if(TIFFGetField(input, TIFFTAG_PAGENUMBER, &pagen, &paged)){
1073                        if((pagen>paged) && (paged != 0)){
1074                                t2p->tiff_pages[t2p->tiff_pagecount].page_number =
1075                                        paged;
1076                        } else {
1077                                t2p->tiff_pages[t2p->tiff_pagecount].page_number =
1078                                        pagen;
1079                        }
1080                        goto ispage2;
1081                }
1082                if(TIFFGetField(input, TIFFTAG_SUBFILETYPE, &subfiletype)){
1083                        if ( ((subfiletype & FILETYPE_PAGE) != 0)
1084                             || (subfiletype == 0)){
1085                                goto ispage;
1086                        } else {
1087                                goto isnotpage;
1088                        }
1089                }
1090                if(TIFFGetField(input, TIFFTAG_OSUBFILETYPE, &subfiletype)){
1091                        if ((subfiletype == OFILETYPE_IMAGE)
1092                                || (subfiletype == OFILETYPE_PAGE)
1093                                || (subfiletype == 0) ){
1094                                goto ispage;
1095                        } else {
1096                                goto isnotpage;
1097                        }
1098                }
1099                ispage:
1100                t2p->tiff_pages[t2p->tiff_pagecount].page_number=t2p->tiff_pagecount;
1101                ispage2:
1102                t2p->tiff_pages[t2p->tiff_pagecount].page_directory=i;
1103                if(TIFFIsTiled(input)){
1104                        t2p->tiff_pages[t2p->tiff_pagecount].page_tilecount =
1105                                TIFFNumberOfTiles(input);
1106                }
1107                t2p->tiff_pagecount++;
1108                isnotpage:
1109                (void)0;
1110        }
1111       
1112        qsort((void*) t2p->tiff_pages, t2p->tiff_pagecount,
1113              sizeof(T2P_PAGE), t2p_cmp_t2p_page);
1114
1115        for(i=0;i<t2p->tiff_pagecount;i++){
1116                t2p->pdf_xrefcount += 5;
1117                TIFFSetDirectory(input, t2p->tiff_pages[i].page_directory );
1118                if((TIFFGetField(input, TIFFTAG_PHOTOMETRIC, &xuint16)
1119                    && (xuint16==PHOTOMETRIC_PALETTE))
1120                   || TIFFGetField(input, TIFFTAG_INDEXED, &xuint16)) {
1121                        t2p->tiff_pages[i].page_extra++;
1122                        t2p->pdf_xrefcount++;
1123                }
1124#ifdef ZIP_SUPPORT
1125                if (TIFFGetField(input, TIFFTAG_COMPRESSION, &xuint16)) {
1126                        if( (xuint16== COMPRESSION_DEFLATE ||
1127                             xuint16== COMPRESSION_ADOBE_DEFLATE) &&
1128                            ((t2p->tiff_pages[i].page_tilecount != 0)
1129                             || TIFFNumberOfStrips(input)==1) &&
1130                            (t2p->pdf_nopassthrough==0) ){
1131                                if(t2p->pdf_minorversion<2){t2p->pdf_minorversion=2;}
1132                        }
1133                }
1134#endif
1135                if (TIFFGetField(input, TIFFTAG_TRANSFERFUNCTION,
1136                                 &(t2p->tiff_transferfunction[0]),
1137                                 &(t2p->tiff_transferfunction[1]),
1138                                 &(t2p->tiff_transferfunction[2]))) {
1139                        if(t2p->tiff_transferfunction[1] !=
1140                           t2p->tiff_transferfunction[0]) {
1141                                t2p->tiff_transferfunctioncount = 3;
1142                                t2p->tiff_pages[i].page_extra += 4;
1143                                t2p->pdf_xrefcount += 4;
1144                        } else {
1145                                t2p->tiff_transferfunctioncount = 1;
1146                                t2p->tiff_pages[i].page_extra += 2;
1147                                t2p->pdf_xrefcount += 2;
1148                        }
1149                        if(t2p->pdf_minorversion < 2)
1150                                t2p->pdf_minorversion = 2;
1151                } else {
1152                        t2p->tiff_transferfunctioncount=0;
1153                }
1154                if( TIFFGetField(
1155                        input,
1156                        TIFFTAG_ICCPROFILE,
1157                        &(t2p->tiff_iccprofilelength),
1158                        &(t2p->tiff_iccprofile)) != 0){
1159                        t2p->tiff_pages[i].page_extra++;
1160                        t2p->pdf_xrefcount++;
1161                        if(t2p->pdf_minorversion<3){t2p->pdf_minorversion=3;}
1162                }
1163                t2p->tiff_tiles[i].tiles_tilecount=
1164                        t2p->tiff_pages[i].page_tilecount;
1165                if( (TIFFGetField(input, TIFFTAG_PLANARCONFIG, &xuint16) != 0)
1166                        && (xuint16 == PLANARCONFIG_SEPARATE ) ){
1167                                TIFFGetField(input, TIFFTAG_SAMPLESPERPIXEL, &xuint16);
1168                                t2p->tiff_tiles[i].tiles_tilecount/= xuint16;
1169                }
1170                if( t2p->tiff_tiles[i].tiles_tilecount > 0){
1171                        t2p->pdf_xrefcount +=
1172                                (t2p->tiff_tiles[i].tiles_tilecount -1)*2;
1173                        TIFFGetField(input,
1174                                TIFFTAG_TILEWIDTH,
1175                                &( t2p->tiff_tiles[i].tiles_tilewidth) );
1176                        TIFFGetField(input,
1177                                TIFFTAG_TILELENGTH,
1178                                &( t2p->tiff_tiles[i].tiles_tilelength) );
1179                        t2p->tiff_tiles[i].tiles_tiles =
1180                        (T2P_TILE*) _TIFFmalloc(
1181                                t2p->tiff_tiles[i].tiles_tilecount
1182                                * sizeof(T2P_TILE) );
1183                        if( t2p->tiff_tiles[i].tiles_tiles == NULL){
1184                                TIFFError(
1185                                        TIFF2PDF_MODULE,
1186                                        "Can't allocate %lu bytes of memory for t2p_read_tiff_init, %s",
1187                                        (unsigned long) t2p->tiff_tiles[i].tiles_tilecount * sizeof(T2P_TILE),
1188                                        TIFFFileName(input));
1189                                t2p->t2p_error = T2P_ERR_ERROR;
1190                                return;
1191                        }
1192                }
1193        }
1194
1195        return;
1196}
1197
1198/*
1199 * This function is used by qsort to sort a T2P_PAGE* array of page structures
1200 * by page number.
1201 */
1202
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",
1427                                        TIFFFileName(input));
1428                                t2p->t2p_error = T2P_ERR_ERROR;
1429                                return;
1430                        }
1431                        t2p->pdf_colorspace=T2P_CS_RGB | T2P_CS_PALETTE;
1432                        t2p->pdf_palettesize=0x0001<<t2p->tiff_bitspersample;
1433                        if(!TIFFGetField(input, TIFFTAG_COLORMAP, &r, &g, &b)){
1434                                TIFFError(
1435                                        TIFF2PDF_MODULE,
1436                                        "Palettized image %s has no color map",
1437                                        TIFFFileName(input));
1438                                t2p->t2p_error = T2P_ERR_ERROR;
1439                                return;
1440                        }
1441                        if(t2p->pdf_palette != NULL){
1442                                _TIFFfree(t2p->pdf_palette);
1443                                t2p->pdf_palette=NULL;
1444                        }
1445                        t2p->pdf_palette = (unsigned char*)
1446                                _TIFFmalloc(t2p->pdf_palettesize*3);
1447                        if(t2p->pdf_palette==NULL){
1448                                TIFFError(
1449                                        TIFF2PDF_MODULE,
1450                                        "Can't allocate %u bytes of memory for t2p_read_tiff_image, %s",
1451                                        t2p->pdf_palettesize,
1452                                        TIFFFileName(input));
1453                                t2p->t2p_error = T2P_ERR_ERROR;
1454                                return;
1455                        }
1456                        for(i=0;i<t2p->pdf_palettesize;i++){
1457                                t2p->pdf_palette[(i*3)]  = (unsigned char) (r[i]>>8);
1458                                t2p->pdf_palette[(i*3)+1]= (unsigned char) (g[i]>>8);
1459                                t2p->pdf_palette[(i*3)+2]= (unsigned char) (b[i]>>8);
1460                        }
1461                        t2p->pdf_palettesize *= 3;
1462                        break;
1463                case PHOTOMETRIC_SEPARATED:
1464                        if(TIFFGetField(input, TIFFTAG_INDEXED, &xuint16)){
1465                                if(xuint16==1){
1466                                                goto photometric_palette_cmyk;
1467                                }
1468                        }
1469                        if( TIFFGetField(input, TIFFTAG_INKSET, &xuint16) ){
1470                                if(xuint16 != INKSET_CMYK){
1471                                        TIFFError(
1472                                                TIFF2PDF_MODULE,
1473                                                "No support for %s because its inkset is not CMYK",
1474                                                TIFFFileName(input) );
1475                                        t2p->t2p_error = T2P_ERR_ERROR;
1476                                        return;
1477                                }
1478                        }
1479                        if(t2p->tiff_samplesperpixel==4){
1480                                t2p->pdf_colorspace=T2P_CS_CMYK;
1481                        } else {
1482                                TIFFError(
1483                                        TIFF2PDF_MODULE,
1484                                        "No support for %s because it has %u samples per pixel",
1485                                        TIFFFileName(input),
1486                                        t2p->tiff_samplesperpixel);
1487                                t2p->t2p_error = T2P_ERR_ERROR;
1488                                return;
1489                        }
1490                        break;
1491                        photometric_palette_cmyk:
1492                        if(t2p->tiff_samplesperpixel!=1){
1493                                TIFFError(
1494                                        TIFF2PDF_MODULE,
1495                                        "No support for palettized CMYK image %s with not one sample per pixel",
1496                                        TIFFFileName(input));
1497                                t2p->t2p_error = T2P_ERR_ERROR;
1498                                return;
1499                        }
1500                        t2p->pdf_colorspace=T2P_CS_CMYK | T2P_CS_PALETTE;
1501                        t2p->pdf_palettesize=0x0001<<t2p->tiff_bitspersample;
1502                        if(!TIFFGetField(input, TIFFTAG_COLORMAP, &r, &g, &b, &a)){
1503                                TIFFError(
1504                                        TIFF2PDF_MODULE,
1505                                        "Palettized image %s has no color map",
1506                                        TIFFFileName(input));
1507                                t2p->t2p_error = T2P_ERR_ERROR;
1508                                return;
1509                        }
1510                        if(t2p->pdf_palette != NULL){
1511                                _TIFFfree(t2p->pdf_palette);
1512                                t2p->pdf_palette=NULL;
1513                        }
1514                        t2p->pdf_palette = (unsigned char*)
1515                                _TIFFmalloc(t2p->pdf_palettesize*4);
1516                        if(t2p->pdf_palette==NULL){
1517                                TIFFError(
1518                                        TIFF2PDF_MODULE,
1519                                        "Can't allocate %u bytes of memory for t2p_read_tiff_image, %s",
1520                                        t2p->pdf_palettesize,
1521                                        TIFFFileName(input));
1522                                t2p->t2p_error = T2P_ERR_ERROR;
1523                                return;
1524                        }
1525                        for(i=0;i<t2p->pdf_palettesize;i++){
1526                                t2p->pdf_palette[(i*4)]  = (unsigned char) (r[i]>>8);
1527                                t2p->pdf_palette[(i*4)+1]= (unsigned char) (g[i]>>8);
1528                                t2p->pdf_palette[(i*4)+2]= (unsigned char) (b[i]>>8);
1529                                t2p->pdf_palette[(i*4)+3]= (unsigned char) (a[i]>>8);
1530                        }
1531                        t2p->pdf_palettesize *= 4;
1532                        break;
1533                case PHOTOMETRIC_YCBCR:
1534                        t2p->pdf_colorspace=T2P_CS_RGB;
1535                        if(t2p->tiff_samplesperpixel==1){
1536                                t2p->pdf_colorspace=T2P_CS_GRAY;
1537                                t2p->tiff_photometric=PHOTOMETRIC_MINISBLACK;
1538                                break;
1539                        }
1540                        t2p->pdf_sample=T2P_SAMPLE_YCBCR_TO_RGB;
1541#ifdef JPEG_SUPPORT
1542                        if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
1543                                t2p->pdf_sample=T2P_SAMPLE_NOTHING;
1544                        }
1545#endif
1546                        break;
1547                case PHOTOMETRIC_CIELAB:
1548                        t2p->pdf_labrange[0]= -127;
1549                        t2p->pdf_labrange[1]= 127;
1550                        t2p->pdf_labrange[2]= -127;
1551                        t2p->pdf_labrange[3]= 127;
1552                        t2p->pdf_sample=T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED;
1553                        t2p->pdf_colorspace=T2P_CS_LAB;
1554                        break;
1555                case PHOTOMETRIC_ICCLAB:
1556                        t2p->pdf_labrange[0]= 0;
1557                        t2p->pdf_labrange[1]= 255;
1558                        t2p->pdf_labrange[2]= 0;
1559                        t2p->pdf_labrange[3]= 255;
1560                        t2p->pdf_colorspace=T2P_CS_LAB;
1561                        break;
1562                case PHOTOMETRIC_ITULAB:
1563                        t2p->pdf_labrange[0]=-85;
1564                        t2p->pdf_labrange[1]=85;
1565                        t2p->pdf_labrange[2]=-75;
1566                        t2p->pdf_labrange[3]=124;
1567                        t2p->pdf_sample=T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED;
1568                        t2p->pdf_colorspace=T2P_CS_LAB;
1569                        break;
1570                case PHOTOMETRIC_LOGL:
1571                case PHOTOMETRIC_LOGLUV:
1572                        TIFFError(
1573                                TIFF2PDF_MODULE,
1574                                "No support for %s with photometric interpretation LogL/LogLuv",
1575                                TIFFFileName(input));
1576                        t2p->t2p_error = T2P_ERR_ERROR;
1577                        return;
1578                default:
1579                        TIFFError(
1580                                TIFF2PDF_MODULE,
1581                                "No support for %s with photometric interpretation %u",
1582                                TIFFFileName(input),
1583                                t2p->tiff_photometric);
1584                        t2p->t2p_error = T2P_ERR_ERROR;
1585                        return;
1586        }
1587
1588        if(TIFFGetField(input, TIFFTAG_PLANARCONFIG, &(t2p->tiff_planar))){
1589                switch(t2p->tiff_planar){
1590                        case 0:
1591                                TIFFWarning(
1592                                        TIFF2PDF_MODULE,
1593                                        "Image %s has planar configuration 0, assuming 1",
1594                                        TIFFFileName(input));
1595                                t2p->tiff_planar=PLANARCONFIG_CONTIG;
1596                        case PLANARCONFIG_CONTIG:
1597                                break;
1598                        case PLANARCONFIG_SEPARATE:
1599                                t2p->pdf_sample=T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG;
1600                                if(t2p->tiff_bitspersample!=8){
1601                                        TIFFError(
1602                                                TIFF2PDF_MODULE,
1603                                                "No support for %s with separated planar configuration and %u bits per sample",
1604                                                TIFFFileName(input),
1605                                                t2p->tiff_bitspersample);
1606                                        t2p->t2p_error = T2P_ERR_ERROR;
1607                                        return;
1608                                }
1609                                break;
1610                        default:
1611                                TIFFError(
1612                                        TIFF2PDF_MODULE,
1613                                        "No support for %s with planar configuration %u",
1614                                        TIFFFileName(input),
1615                                        t2p->tiff_planar);
1616                                t2p->t2p_error = T2P_ERR_ERROR;
1617                                return;
1618                }
1619        }
1620
1621        TIFFGetFieldDefaulted(input, TIFFTAG_ORIENTATION,
1622                              &(t2p->tiff_orientation));
1623        if(t2p->tiff_orientation>8){
1624                TIFFWarning(TIFF2PDF_MODULE,
1625                            "Image %s has orientation %u, assuming 0",
1626                            TIFFFileName(input), t2p->tiff_orientation);
1627                t2p->tiff_orientation=0;
1628        }
1629
1630        if(TIFFGetField(input, TIFFTAG_XRESOLUTION, &(t2p->tiff_xres) ) == 0){
1631                t2p->tiff_xres=0.0;
1632        }
1633        if(TIFFGetField(input, TIFFTAG_YRESOLUTION, &(t2p->tiff_yres) ) == 0){
1634                t2p->tiff_yres=0.0;
1635        }
1636        TIFFGetFieldDefaulted(input, TIFFTAG_RESOLUTIONUNIT,
1637                              &(t2p->tiff_resunit));
1638        if(t2p->tiff_resunit == RESUNIT_CENTIMETER) {
1639                t2p->tiff_xres *= 2.54F;
1640                t2p->tiff_yres *= 2.54F;
1641        } else if (t2p->tiff_resunit != RESUNIT_INCH
1642                   && t2p->pdf_centimeters != 0) {
1643                t2p->tiff_xres *= 2.54F;
1644                t2p->tiff_yres *= 2.54F;
1645        }
1646
1647        t2p_compose_pdf_page(t2p);
1648
1649        t2p->pdf_transcode = T2P_TRANSCODE_ENCODE;
1650        if(t2p->pdf_nopassthrough==0){
1651#ifdef CCITT_SUPPORT
1652                if(t2p->tiff_compression==COMPRESSION_CCITTFAX4 
1653                        ){
1654                        if(TIFFIsTiled(input) || (TIFFNumberOfStrips(input)==1) ){
1655                                t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1656                                t2p->pdf_compression=T2P_COMPRESS_G4;
1657                        }
1658                }
1659#endif
1660#ifdef ZIP_SUPPORT
1661                if(t2p->tiff_compression== COMPRESSION_ADOBE_DEFLATE
1662                        || t2p->tiff_compression==COMPRESSION_DEFLATE){
1663                        if(TIFFIsTiled(input) || (TIFFNumberOfStrips(input)==1) ){
1664                                t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1665                                t2p->pdf_compression=T2P_COMPRESS_ZIP;
1666                        }
1667                }
1668#endif
1669#ifdef OJPEG_SUPPORT
1670                if(t2p->tiff_compression==COMPRESSION_OJPEG){
1671                        t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1672                        t2p->pdf_compression=T2P_COMPRESS_JPEG;
1673                        t2p_process_ojpeg_tables(t2p, input);
1674                }
1675#endif
1676#ifdef JPEG_SUPPORT
1677                if(t2p->tiff_compression==COMPRESSION_JPEG){
1678                        t2p->pdf_transcode = T2P_TRANSCODE_RAW;
1679                        t2p->pdf_compression=T2P_COMPRESS_JPEG;
1680                }
1681#endif
1682                (void)0;
1683        }
1684
1685        if(t2p->pdf_transcode!=T2P_TRANSCODE_RAW){
1686                t2p->pdf_compression = t2p->pdf_defaultcompression;
1687        }
1688
1689#ifdef JPEG_SUPPORT
1690        if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){
1691                if(t2p->pdf_colorspace & T2P_CS_PALETTE){
1692                        t2p->pdf_sample|=T2P_SAMPLE_REALIZE_PALETTE;
1693                        t2p->pdf_colorspace ^= T2P_CS_PALETTE;
1694                        t2p->tiff_pages[t2p->pdf_page].page_extra--;
1695                }
1696        }
1697        if(t2p->tiff_compression==COMPRESSION_JPEG){
1698                if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1699                        TIFFError(
1700                                TIFF2PDF_MODULE,
1701                                "No support for %s with JPEG compression and separated planar configuration",
1702                                TIFFFileName(input));
1703                                t2p->t2p_error=T2P_ERR_ERROR;
1704                        return;
1705                }
1706        }
1707#endif
1708#ifdef OJPEG_SUPPORT
1709        if(t2p->tiff_compression==COMPRESSION_OJPEG){
1710                if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1711                        TIFFError(
1712                                TIFF2PDF_MODULE,
1713                                "No support for %s with OJPEG compression and separated planar configuration",
1714                                TIFFFileName(input));
1715                                t2p->t2p_error=T2P_ERR_ERROR;
1716                        return;
1717                }
1718        }
1719#endif
1720
1721        if(t2p->pdf_sample & T2P_SAMPLE_REALIZE_PALETTE){
1722                if(t2p->pdf_colorspace & T2P_CS_CMYK){
1723                        t2p->tiff_samplesperpixel=4;
1724                        t2p->tiff_photometric=PHOTOMETRIC_SEPARATED;
1725                } else {
1726                        t2p->tiff_samplesperpixel=3;
1727                        t2p->tiff_photometric=PHOTOMETRIC_RGB;
1728                }
1729        }
1730
1731        if (TIFFGetField(input, TIFFTAG_TRANSFERFUNCTION,
1732                         &(t2p->tiff_transferfunction[0]),
1733                         &(t2p->tiff_transferfunction[1]),
1734                         &(t2p->tiff_transferfunction[2]))) {
1735                if(t2p->tiff_transferfunction[1] !=
1736                   t2p->tiff_transferfunction[0]) {
1737                        t2p->tiff_transferfunctioncount=3;
1738                } else {
1739                        t2p->tiff_transferfunctioncount=1;
1740                }
1741        } else {
1742                t2p->tiff_transferfunctioncount=0;
1743        }
1744        if(TIFFGetField(input, TIFFTAG_WHITEPOINT, &xfloatp)!=0){
1745                t2p->tiff_whitechromaticities[0]=xfloatp[0];
1746                t2p->tiff_whitechromaticities[1]=xfloatp[1];
1747                if(t2p->pdf_colorspace & T2P_CS_GRAY){
1748                        t2p->pdf_colorspace |= T2P_CS_CALGRAY;
1749                }
1750                if(t2p->pdf_colorspace & T2P_CS_RGB){
1751                        t2p->pdf_colorspace |= T2P_CS_CALRGB;
1752                }
1753        }
1754        if(TIFFGetField(input, TIFFTAG_PRIMARYCHROMATICITIES, &xfloatp)!=0){
1755                t2p->tiff_primarychromaticities[0]=xfloatp[0];
1756                t2p->tiff_primarychromaticities[1]=xfloatp[1];
1757                t2p->tiff_primarychromaticities[2]=xfloatp[2];
1758                t2p->tiff_primarychromaticities[3]=xfloatp[3];
1759                t2p->tiff_primarychromaticities[4]=xfloatp[4];
1760                t2p->tiff_primarychromaticities[5]=xfloatp[5];
1761                if(t2p->pdf_colorspace & T2P_CS_RGB){
1762                        t2p->pdf_colorspace |= T2P_CS_CALRGB;
1763                }
1764        }
1765        if(t2p->pdf_colorspace & T2P_CS_LAB){
1766                if(TIFFGetField(input, TIFFTAG_WHITEPOINT, &xfloatp) != 0){
1767                        t2p->tiff_whitechromaticities[0]=xfloatp[0];
1768                        t2p->tiff_whitechromaticities[1]=xfloatp[1];
1769                } else {
1770                        t2p->tiff_whitechromaticities[0]=0.3457F; /* 0.3127F; */
1771                        t2p->tiff_whitechromaticities[1]=0.3585F; /* 0.3290F; */
1772                }
1773        }
1774        if(TIFFGetField(input,
1775                TIFFTAG_ICCPROFILE,
1776                &(t2p->tiff_iccprofilelength),
1777                &(t2p->tiff_iccprofile))!=0){
1778                t2p->pdf_colorspace |= T2P_CS_ICCBASED;
1779        } else {
1780                t2p->tiff_iccprofilelength=0;
1781                t2p->tiff_iccprofile=NULL;
1782        }
1783       
1784#ifdef CCITT_SUPPORT
1785        if( t2p->tiff_bitspersample==1 &&
1786                t2p->tiff_samplesperpixel==1){
1787                t2p->pdf_compression = T2P_COMPRESS_G4;
1788        }
1789#endif
1790
1791
1792        return;
1793}
1794
1795/*
1796        This function returns the necessary size of a data buffer to contain the raw or
1797        uncompressed image data from the input TIFF for a page.
1798*/
1799
1800void t2p_read_tiff_size(T2P* t2p, TIFF* input){
1801
1802        uint64* sbc=NULL;
1803#if defined(JPEG_SUPPORT) || defined (OJPEG_SUPPORT)
1804        unsigned char* jpt=NULL;
1805        tstrip_t i=0;
1806        tstrip_t stripcount=0;
1807#endif
1808        uint64 k = 0;
1809
1810        if(t2p->pdf_transcode == T2P_TRANSCODE_RAW){
1811#ifdef CCITT_SUPPORT
1812                if(t2p->pdf_compression == T2P_COMPRESS_G4 ){
1813                        TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
1814                        t2p->tiff_datasize=(tmsize_t)sbc[0];
1815                        return;
1816                }
1817#endif
1818#ifdef ZIP_SUPPORT
1819                if(t2p->pdf_compression == T2P_COMPRESS_ZIP){
1820                        TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
1821                        t2p->tiff_datasize=(tmsize_t)sbc[0];
1822                        return;
1823                }
1824#endif
1825#ifdef OJPEG_SUPPORT
1826                if(t2p->tiff_compression == COMPRESSION_OJPEG){
1827                        if(!TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc)){
1828                                TIFFError(TIFF2PDF_MODULE,
1829                                        "Input file %s missing field: TIFFTAG_STRIPBYTECOUNTS",
1830                                        TIFFFileName(input));
1831                                t2p->t2p_error = T2P_ERR_ERROR;
1832                                return;
1833                        }
1834                        stripcount=TIFFNumberOfStrips(input);
1835                        for(i=0;i<stripcount;i++){
1836                                k = checkAdd64(k, sbc[i], t2p);
1837                        }
1838                        if(TIFFGetField(input, TIFFTAG_JPEGIFOFFSET, &(t2p->tiff_dataoffset))){
1839                                if(t2p->tiff_dataoffset != 0){
1840                                        if(TIFFGetField(input, TIFFTAG_JPEGIFBYTECOUNT, &(t2p->tiff_datasize))!=0){
1841                                                if((uint64)t2p->tiff_datasize < k) {
1842                                                        TIFFWarning(TIFF2PDF_MODULE,
1843                                                                "Input file %s has short JPEG interchange file byte count",
1844                                                                TIFFFileName(input));
1845                                                        t2p->pdf_ojpegiflength=t2p->tiff_datasize;
1846                                                        k = checkAdd64(k, t2p->tiff_datasize, t2p);
1847                                                        k = checkAdd64(k, 6, t2p);
1848                                                        k = checkAdd64(k, stripcount, t2p);
1849                                                        k = checkAdd64(k, stripcount, t2p);
1850                                                        t2p->tiff_datasize = (tsize_t) k;
1851                                                        if ((uint64) t2p->tiff_datasize != k) {
1852                                                                TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1853                                                                t2p->t2p_error = T2P_ERR_ERROR;
1854                                                        }
1855                                                        return;
1856                                                }
1857                                                return;
1858                                        }else {
1859                                                TIFFError(TIFF2PDF_MODULE,
1860                                                        "Input file %s missing field: TIFFTAG_JPEGIFBYTECOUNT",
1861                                                        TIFFFileName(input));
1862                                                        t2p->t2p_error = T2P_ERR_ERROR;
1863                                                        return;
1864                                        }
1865                                }
1866                        }
1867                        k = checkAdd64(k, stripcount, t2p);
1868                        k = checkAdd64(k, stripcount, t2p);
1869                        k = checkAdd64(k, 2048, t2p);
1870                        t2p->tiff_datasize = (tsize_t) k;
1871                        if ((uint64) t2p->tiff_datasize != k) {
1872                                TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1873                                t2p->t2p_error = T2P_ERR_ERROR;
1874                        }
1875                        return;
1876                }
1877#endif
1878#ifdef JPEG_SUPPORT
1879                if(t2p->tiff_compression == COMPRESSION_JPEG) {
1880                        uint32 count = 0;
1881                        if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0 ){
1882                                if(count > 4){
1883                                        k += count;
1884                                        k -= 2; /* don't use EOI of header */
1885                                }
1886                        } else {
1887                                k = 2; /* SOI for first strip */
1888                        }
1889                        stripcount=TIFFNumberOfStrips(input);
1890                        if(!TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc)){
1891                                TIFFError(TIFF2PDF_MODULE,
1892                                        "Input file %s missing field: TIFFTAG_STRIPBYTECOUNTS",
1893                                        TIFFFileName(input));
1894                                t2p->t2p_error = T2P_ERR_ERROR;
1895                                return;
1896                        }
1897                        for(i=0;i<stripcount;i++){
1898                                k = checkAdd64(k, sbc[i], t2p);
1899                                k -=4; /* don't use SOI or EOI of strip */
1900                        }
1901                        k = checkAdd64(k, 2, t2p); /* use EOI of last strip */
1902                        t2p->tiff_datasize = (tsize_t) k;
1903                        if ((uint64) t2p->tiff_datasize != k) {
1904                                TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1905                                t2p->t2p_error = T2P_ERR_ERROR;
1906                        }
1907                        return;
1908                }
1909#endif
1910                (void) 0;
1911        }
1912        k = checkMultiply64(TIFFScanlineSize(input), t2p->tiff_length, t2p);
1913        if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1914                k = checkMultiply64(k, t2p->tiff_samplesperpixel, t2p);
1915        }
1916        if (k == 0) {
1917                /* Assume we had overflow inside TIFFScanlineSize */
1918                t2p->t2p_error = T2P_ERR_ERROR;
1919        }
1920
1921        t2p->tiff_datasize = (tsize_t) k;
1922        if ((uint64) t2p->tiff_datasize != k) {
1923                TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1924                t2p->t2p_error = T2P_ERR_ERROR;
1925        }
1926
1927        return;
1928}
1929
1930/*
1931        This function returns the necessary size of a data buffer to contain the raw or
1932        uncompressed image data from the input TIFF for a tile of a page.
1933*/
1934
1935void t2p_read_tiff_size_tile(T2P* t2p, TIFF* input, ttile_t tile){
1936
1937        uint64* tbc = NULL;
1938        uint16 edge=0;
1939#ifdef JPEG_SUPPORT
1940        unsigned char* jpt;
1941#endif
1942        uint64 k;
1943
1944        edge |= t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
1945        edge |= t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
1946       
1947        if(t2p->pdf_transcode==T2P_TRANSCODE_RAW){
1948                if(edge
1949#if defined(JPEG_SUPPORT) || defined(OJPEG_SUPPORT)
1950                && !(t2p->pdf_compression==T2P_COMPRESS_JPEG)
1951#endif
1952                ){
1953                        t2p->tiff_datasize=TIFFTileSize(input);
1954                        if (t2p->tiff_datasize == 0) {
1955                                /* Assume we had overflow inside TIFFTileSize */
1956                                t2p->t2p_error = T2P_ERR_ERROR;
1957                        }
1958                        return;
1959                } else {
1960                        TIFFGetField(input, TIFFTAG_TILEBYTECOUNTS, &tbc);
1961                        k=tbc[tile];
1962#ifdef OJPEG_SUPPORT
1963                        if(t2p->tiff_compression==COMPRESSION_OJPEG){
1964                                k = checkAdd64(k, 2048, t2p);
1965                        }
1966#endif
1967#ifdef JPEG_SUPPORT
1968                        if(t2p->tiff_compression==COMPRESSION_JPEG) {
1969                                uint32 count = 0;
1970                                if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt)!=0){
1971                                        if(count > 4){
1972                                                k = checkAdd64(k, count, t2p);
1973                                                k -= 2; /* don't use EOI of header or SOI of tile */
1974                                        }
1975                                }
1976                        }
1977#endif
1978                        t2p->tiff_datasize = (tsize_t) k;
1979                        if ((uint64) t2p->tiff_datasize != k) {
1980                                TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1981                                t2p->t2p_error = T2P_ERR_ERROR;
1982                        }
1983                        return;
1984                }
1985        }
1986        k = TIFFTileSize(input);
1987        if(t2p->tiff_planar==PLANARCONFIG_SEPARATE){
1988                k = checkMultiply64(k, t2p->tiff_samplesperpixel, t2p);
1989        }
1990        if (k == 0) {
1991                /* Assume we had overflow inside TIFFTileSize */
1992                t2p->t2p_error = T2P_ERR_ERROR;
1993        }
1994
1995        t2p->tiff_datasize = (tsize_t) k;
1996        if ((uint64) t2p->tiff_datasize != k) {
1997                TIFFError(TIFF2PDF_MODULE, "Integer overflow");
1998                t2p->t2p_error = T2P_ERR_ERROR;
1999        }
2000
2001        return;
2002}
2003
2004/*
2005 * This functions returns a non-zero value when the tile is on the right edge
2006 * and does not have full imaged tile width.
2007 */
2008
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        }
2017}
2018
2019/*
2020 * This functions returns a non-zero value when the tile is on the bottom edge
2021 * and does not have full imaged tile length.
2022 */
2023
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        }
2032}
2033
2034/*
2035 * This function returns a non-zero value when the tile is a right edge tile
2036 * or a bottom edge tile.
2037 */
2038
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
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;
2084        float* xfloatp;
2085        uint64* sbc;
2086        unsigned char* stripbuffer;
2087        tsize_t striplength=0;
2088        uint32 max_striplength=0;
2089#endif
2090
2091        /* Fail if prior error (in particular, can't trust tiff_datasize) */
2092        if (t2p->t2p_error != T2P_ERR_OK)
2093                return(0);
2094
2095        if(t2p->pdf_transcode == T2P_TRANSCODE_RAW){
2096#ifdef CCITT_SUPPORT
2097                if(t2p->pdf_compression == T2P_COMPRESS_G4){
2098                        buffer = (unsigned char*)
2099                                _TIFFmalloc(t2p->tiff_datasize);
2100                        if (buffer == NULL) {
2101                                TIFFError(TIFF2PDF_MODULE,
2102        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2103                                        (unsigned long) t2p->tiff_datasize,
2104                                        TIFFFileName(input));
2105                                t2p->t2p_error = T2P_ERR_ERROR;
2106                                return(0);
2107                        }
2108                        TIFFReadRawStrip(input, 0, (tdata_t) buffer,
2109                                         t2p->tiff_datasize);
2110                        if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
2111                                        /*
2112                                         * make sure is lsb-to-msb
2113                                         * bit-endianness fill order
2114                                         */
2115                                        TIFFReverseBits(buffer,
2116                                                        t2p->tiff_datasize);
2117                        }
2118                        t2pWriteFile(output, (tdata_t) buffer,
2119                                      t2p->tiff_datasize);
2120                        _TIFFfree(buffer);
2121                        return(t2p->tiff_datasize);
2122                }
2123#endif
2124#ifdef ZIP_SUPPORT
2125                if (t2p->pdf_compression == T2P_COMPRESS_ZIP) {
2126                        buffer = (unsigned char*)
2127                                _TIFFmalloc(t2p->tiff_datasize);
2128                        if(buffer == NULL){
2129                                TIFFError(TIFF2PDF_MODULE,
2130        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2131                                        (unsigned long) t2p->tiff_datasize,
2132                                        TIFFFileName(input));
2133                                t2p->t2p_error = T2P_ERR_ERROR;
2134                                return(0);
2135                        }
2136                        memset(buffer, 0, t2p->tiff_datasize);
2137                        TIFFReadRawStrip(input, 0, (tdata_t) buffer,
2138                                         t2p->tiff_datasize);
2139                        if (t2p->tiff_fillorder==FILLORDER_LSB2MSB) {
2140                                        TIFFReverseBits(buffer,
2141                                                        t2p->tiff_datasize);
2142                        }
2143                        t2pWriteFile(output, (tdata_t) buffer,
2144                                      t2p->tiff_datasize);
2145                        _TIFFfree(buffer);
2146                        return(t2p->tiff_datasize);
2147                }
2148#endif
2149#ifdef OJPEG_SUPPORT
2150                if(t2p->tiff_compression == COMPRESSION_OJPEG) {
2151
2152                        if(t2p->tiff_dataoffset != 0) {
2153                                buffer = (unsigned char*)
2154                                        _TIFFmalloc(t2p->tiff_datasize);
2155                                if(buffer == NULL) {
2156                                        TIFFError(TIFF2PDF_MODULE,
2157        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2158                                                (unsigned long) t2p->tiff_datasize,
2159                                                TIFFFileName(input));
2160                                        t2p->t2p_error = T2P_ERR_ERROR;
2161                                        return(0);
2162                                }
2163                                memset(buffer, 0, t2p->tiff_datasize);
2164                                if(t2p->pdf_ojpegiflength==0){
2165                                        inputoffset=t2pSeekFile(input, 0,
2166                                                                 SEEK_CUR);
2167                                        t2pSeekFile(input,
2168                                                     t2p->tiff_dataoffset,
2169                                                     SEEK_SET);
2170                                        t2pReadFile(input, (tdata_t) buffer,
2171                                                     t2p->tiff_datasize);
2172                                        t2pSeekFile(input, inputoffset,
2173                                                     SEEK_SET);
2174                                        t2pWriteFile(output, (tdata_t) buffer,
2175                                                      t2p->tiff_datasize);
2176                                        _TIFFfree(buffer);
2177                                        return(t2p->tiff_datasize);
2178                                } else {
2179                                        inputoffset=t2pSeekFile(input, 0,
2180                                                                 SEEK_CUR);
2181                                        t2pSeekFile(input,
2182                                                     t2p->tiff_dataoffset,
2183                                                     SEEK_SET);
2184                                        bufferoffset = t2pReadFile(input,
2185                                                (tdata_t) buffer,
2186                                                t2p->pdf_ojpegiflength);
2187                                        t2p->pdf_ojpegiflength = 0;
2188                                        t2pSeekFile(input, inputoffset,
2189                                                     SEEK_SET);
2190                                        TIFFGetField(input,
2191                                                     TIFFTAG_YCBCRSUBSAMPLING,
2192                                                     &h_samp, &v_samp);
2193                                        buffer[bufferoffset++]= 0xff;
2194                                        buffer[bufferoffset++]= 0xdd;
2195                                        buffer[bufferoffset++]= 0x00;
2196                                        buffer[bufferoffset++]= 0x04;
2197                                        h_samp*=8;
2198                                        v_samp*=8;
2199                                        ri=(t2p->tiff_width+h_samp-1) / h_samp;
2200                                        TIFFGetField(input,
2201                                                     TIFFTAG_ROWSPERSTRIP,
2202                                                     &rows);
2203                                        ri*=(rows+v_samp-1)/v_samp;
2204                                        buffer[bufferoffset++]= (ri>>8) & 0xff;
2205                                        buffer[bufferoffset++]= ri & 0xff;
2206                                        stripcount=TIFFNumberOfStrips(input);
2207                                        for(i=0;i<stripcount;i++){
2208                                                if(i != 0 ){
2209                                                        buffer[bufferoffset++]=0xff;
2210                                                        buffer[bufferoffset++]=(0xd0 | ((i-1)%8));
2211                                                }
2212                                                bufferoffset+=TIFFReadRawStrip(input,
2213                                                        i,
2214                                                        (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2215                                                        -1);
2216                                        }
2217                                        t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2218                                        _TIFFfree(buffer);
2219                                        return(bufferoffset);
2220                                }
2221                        } else {
2222                                if(! t2p->pdf_ojpegdata){
2223                                        TIFFError(TIFF2PDF_MODULE,
2224                                "No support for OJPEG image %s with bad tables",
2225                                                TIFFFileName(input));
2226                                        t2p->t2p_error = T2P_ERR_ERROR;
2227                                        return(0);
2228                                }
2229                                buffer = (unsigned char*)
2230                                        _TIFFmalloc(t2p->tiff_datasize);
2231                                if(buffer==NULL){
2232                                        TIFFError(TIFF2PDF_MODULE,
2233        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2234                                                (unsigned long) t2p->tiff_datasize,
2235                                                TIFFFileName(input));
2236                                        t2p->t2p_error = T2P_ERR_ERROR;
2237                                        return(0);
2238                                }
2239                                memset(buffer, 0, t2p->tiff_datasize);
2240                                _TIFFmemcpy(buffer, t2p->pdf_ojpegdata, t2p->pdf_ojpegdatalength);
2241                                bufferoffset=t2p->pdf_ojpegdatalength;
2242                                stripcount=TIFFNumberOfStrips(input);
2243                                for(i=0;i<stripcount;i++){
2244                                        if(i != 0){
2245                                                buffer[bufferoffset++]=0xff;
2246                                                buffer[bufferoffset++]=(0xd0 | ((i-1)%8));
2247                                        }
2248                                        bufferoffset+=TIFFReadRawStrip(input,
2249                                                i,
2250                                                (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2251                                                -1);
2252                                }
2253                                if( ! ( (buffer[bufferoffset-1]==0xd9) && (buffer[bufferoffset-2]==0xff) ) ){
2254                                                buffer[bufferoffset++]=0xff;
2255                                                buffer[bufferoffset++]=0xd9;
2256                                }
2257                                t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2258                                _TIFFfree(buffer);
2259                                return(bufferoffset);
2260                                TIFFError(TIFF2PDF_MODULE,
2261        "No support for OJPEG image %s with no JPEG File Interchange offset",
2262                                        TIFFFileName(input));
2263                                t2p->t2p_error = T2P_ERR_ERROR;
2264                                return(0);
2265                        }
2266                        return(t2p->tiff_datasize);
2267                }
2268#endif
2269#ifdef JPEG_SUPPORT
2270                if(t2p->tiff_compression == COMPRESSION_JPEG) {
2271                        uint32 count = 0;
2272                        buffer = (unsigned char*)
2273                                _TIFFmalloc(t2p->tiff_datasize);
2274                        if(buffer==NULL){
2275                                TIFFError(TIFF2PDF_MODULE,
2276        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2277                                        (unsigned long) t2p->tiff_datasize,
2278                                        TIFFFileName(input));
2279                                t2p->t2p_error = T2P_ERR_ERROR;
2280                                return(0);
2281                        }
2282                        memset(buffer, 0, t2p->tiff_datasize);
2283                        if (TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0) {
2284                                if(count > 4) {
2285                                        _TIFFmemcpy(buffer, jpt, count);
2286                                        bufferoffset += count - 2;
2287                                }
2288                        }
2289                        stripcount=TIFFNumberOfStrips(input);
2290                        TIFFGetField(input, TIFFTAG_STRIPBYTECOUNTS, &sbc);
2291                        for(i=0;i<stripcount;i++){
2292                                if(sbc[i]>max_striplength) max_striplength=sbc[i];
2293                        }
2294                        stripbuffer = (unsigned char*)
2295                                _TIFFmalloc(max_striplength);
2296                        if(stripbuffer==NULL){
2297                                TIFFError(TIFF2PDF_MODULE,
2298        "Can't allocate %u bytes of memory for t2p_readwrite_pdf_image, %s",
2299                                        max_striplength,
2300                                        TIFFFileName(input));
2301                                _TIFFfree(buffer);
2302                                t2p->t2p_error = T2P_ERR_ERROR;
2303                                return(0);
2304                        }
2305                        for(i=0;i<stripcount;i++){
2306                                striplength=TIFFReadRawStrip(input, i, (tdata_t) stripbuffer, -1);
2307                                if(!t2p_process_jpeg_strip(
2308                                        stripbuffer,
2309                                        &striplength,
2310                                        buffer,
2311                                        &bufferoffset,
2312                                        i,
2313                                        t2p->tiff_length)){
2314                                                TIFFError(TIFF2PDF_MODULE,
2315                                "Can't process JPEG data in input file %s",
2316                                                        TIFFFileName(input));
2317                                                _TIFFfree(samplebuffer);
2318                                                _TIFFfree(buffer);
2319                                                t2p->t2p_error = T2P_ERR_ERROR;
2320                                                return(0);
2321                                }
2322                        }
2323                        buffer[bufferoffset++]=0xff;
2324                        buffer[bufferoffset++]=0xd9;
2325                        t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2326                        _TIFFfree(stripbuffer);
2327                        _TIFFfree(buffer);
2328                        return(bufferoffset);
2329                }
2330#endif
2331                (void)0;
2332        }
2333
2334        if(t2p->pdf_sample==T2P_SAMPLE_NOTHING){
2335                buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2336                if(buffer==NULL){
2337                        TIFFError(TIFF2PDF_MODULE,
2338        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2339                                (unsigned long) t2p->tiff_datasize,
2340                                TIFFFileName(input));
2341                        t2p->t2p_error = T2P_ERR_ERROR;
2342                        return(0);
2343                }
2344                memset(buffer, 0, t2p->tiff_datasize);
2345                stripsize=TIFFStripSize(input);
2346                stripcount=TIFFNumberOfStrips(input);
2347                for(i=0;i<stripcount;i++){
2348                        read =
2349                                TIFFReadEncodedStrip(input,
2350                                i,
2351                                (tdata_t) &buffer[bufferoffset],
2352                                stripsize);
2353                        if(read==-1){
2354                                TIFFError(TIFF2PDF_MODULE,
2355                                        "Error on decoding strip %u of %s",
2356                                        i,
2357                                        TIFFFileName(input));
2358                                _TIFFfree(buffer);
2359                                t2p->t2p_error=T2P_ERR_ERROR;
2360                                return(0);
2361                        }
2362                        bufferoffset+=read;
2363                }
2364        } else {
2365                if(t2p->pdf_sample & T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG){
2366               
2367                        sepstripsize=TIFFStripSize(input);
2368                        sepstripcount=TIFFNumberOfStrips(input);
2369               
2370                        stripsize=sepstripsize*t2p->tiff_samplesperpixel;
2371                        stripcount=sepstripcount/t2p->tiff_samplesperpixel;
2372                       
2373                        buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2374                        if(buffer==NULL){
2375                                TIFFError(TIFF2PDF_MODULE,
2376        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2377                                        (unsigned long) t2p->tiff_datasize,
2378                                        TIFFFileName(input));
2379                                t2p->t2p_error = T2P_ERR_ERROR;
2380                                return(0);
2381                        }
2382                        memset(buffer, 0, t2p->tiff_datasize);
2383                        samplebuffer = (unsigned char*) _TIFFmalloc(stripsize);
2384                        if(samplebuffer==NULL){
2385                                TIFFError(TIFF2PDF_MODULE,
2386        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2387                                        (unsigned long) t2p->tiff_datasize,
2388                                        TIFFFileName(input));
2389                                t2p->t2p_error = T2P_ERR_ERROR;
2390                                return(0);
2391                        }
2392                        for(i=0;i<stripcount;i++){
2393                                samplebufferoffset=0;
2394                                for(j=0;j<t2p->tiff_samplesperpixel;j++){
2395                                        read =
2396                                                TIFFReadEncodedStrip(input,
2397                                                        i + j*stripcount,
2398                                                        (tdata_t) &(samplebuffer[samplebufferoffset]),
2399                                                        sepstripsize);
2400                                        if(read==-1){
2401                                                TIFFError(TIFF2PDF_MODULE,
2402                                        "Error on decoding strip %u of %s",
2403                                                        i + j*stripcount,
2404                                                        TIFFFileName(input));
2405                                                        _TIFFfree(buffer);
2406                                                t2p->t2p_error=T2P_ERR_ERROR;
2407                                                return(0);
2408                                        }
2409                                        samplebufferoffset+=read;
2410                                }
2411                                t2p_sample_planar_separate_to_contig(
2412                                        t2p,
2413                                        &(buffer[bufferoffset]),
2414                                        samplebuffer,
2415                                        samplebufferoffset);
2416                                bufferoffset+=samplebufferoffset;
2417                        }
2418                        _TIFFfree(samplebuffer);
2419                        goto dataready;
2420                }
2421
2422                buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2423                if(buffer==NULL){
2424                        TIFFError(TIFF2PDF_MODULE,
2425        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2426                                (unsigned long) t2p->tiff_datasize,
2427                                TIFFFileName(input));
2428                        t2p->t2p_error = T2P_ERR_ERROR;
2429                        return(0);
2430                }
2431                memset(buffer, 0, t2p->tiff_datasize);
2432                stripsize=TIFFStripSize(input);
2433                stripcount=TIFFNumberOfStrips(input);
2434                for(i=0;i<stripcount;i++){
2435                        read =
2436                                TIFFReadEncodedStrip(input,
2437                                i,
2438                                (tdata_t) &buffer[bufferoffset],
2439                                stripsize);
2440                        if(read==-1){
2441                                TIFFError(TIFF2PDF_MODULE,
2442                                        "Error on decoding strip %u of %s",
2443                                        i,
2444                                        TIFFFileName(input));
2445                                _TIFFfree(samplebuffer);
2446                                _TIFFfree(buffer);
2447                                t2p->t2p_error=T2P_ERR_ERROR;
2448                                return(0);
2449                        }
2450                        bufferoffset+=read;
2451                }
2452
2453                if(t2p->pdf_sample & T2P_SAMPLE_REALIZE_PALETTE){
2454                        // FIXME: overflow?
2455                        samplebuffer=(unsigned char*)_TIFFrealloc(
2456                                (tdata_t) buffer,
2457                                t2p->tiff_datasize * t2p->tiff_samplesperpixel);
2458                        if(samplebuffer==NULL){
2459                                TIFFError(TIFF2PDF_MODULE,
2460        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2461                                        (unsigned long) t2p->tiff_datasize,
2462                                        TIFFFileName(input));
2463                                t2p->t2p_error = T2P_ERR_ERROR;
2464                          _TIFFfree(buffer);
2465                        } else {
2466                                buffer=samplebuffer;
2467                                t2p->tiff_datasize *= t2p->tiff_samplesperpixel;
2468                        }
2469                        t2p_sample_realize_palette(t2p, buffer);
2470                }
2471
2472                if(t2p->pdf_sample & T2P_SAMPLE_RGBA_TO_RGB){
2473                        t2p->tiff_datasize=t2p_sample_rgba_to_rgb(
2474                                (tdata_t)buffer,
2475                                t2p->tiff_width*t2p->tiff_length);
2476                }
2477
2478                if(t2p->pdf_sample & T2P_SAMPLE_RGBAA_TO_RGB){
2479                        t2p->tiff_datasize=t2p_sample_rgbaa_to_rgb(
2480                                (tdata_t)buffer,
2481                                t2p->tiff_width*t2p->tiff_length);
2482                }
2483
2484                if(t2p->pdf_sample & T2P_SAMPLE_YCBCR_TO_RGB){
2485                        samplebuffer=(unsigned char*)_TIFFrealloc(
2486                                (tdata_t)buffer,
2487                                t2p->tiff_width*t2p->tiff_length*4);
2488                        if(samplebuffer==NULL){
2489                                TIFFError(TIFF2PDF_MODULE,
2490        "Can't allocate %lu bytes of memory for t2p_readwrite_pdf_image, %s",
2491                                        (unsigned long) t2p->tiff_datasize,
2492                                        TIFFFileName(input));
2493                                t2p->t2p_error = T2P_ERR_ERROR;
2494                                _TIFFfree(buffer);
2495                                return(0);
2496                        } else {
2497                                buffer=samplebuffer;
2498                        }
2499                        if(!TIFFReadRGBAImageOriented(
2500                                input,
2501                                t2p->tiff_width,
2502                                t2p->tiff_length,
2503                                (uint32*)buffer,
2504                                ORIENTATION_TOPLEFT,
2505                                0)){
2506                                TIFFError(TIFF2PDF_MODULE,
2507        "Can't use TIFFReadRGBAImageOriented to extract RGB image from %s",
2508                                        TIFFFileName(input));
2509                                t2p->t2p_error = T2P_ERR_ERROR;
2510                                return(0);
2511                        }
2512                        t2p->tiff_datasize=t2p_sample_abgr_to_rgb(
2513                                (tdata_t) buffer,
2514                                t2p->tiff_width*t2p->tiff_length);
2515
2516                }
2517
2518                if(t2p->pdf_sample & T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED){
2519                        t2p->tiff_datasize=t2p_sample_lab_signed_to_unsigned(
2520                                (tdata_t)buffer,
2521                                t2p->tiff_width*t2p->tiff_length);
2522                }
2523        }
2524
2525dataready:
2526
2527        t2p_disable(output);
2528        TIFFSetField(output, TIFFTAG_PHOTOMETRIC, t2p->tiff_photometric);
2529        TIFFSetField(output, TIFFTAG_BITSPERSAMPLE, t2p->tiff_bitspersample);
2530        TIFFSetField(output, TIFFTAG_SAMPLESPERPIXEL, t2p->tiff_samplesperpixel);
2531        TIFFSetField(output, TIFFTAG_IMAGEWIDTH, t2p->tiff_width);
2532        TIFFSetField(output, TIFFTAG_IMAGELENGTH, t2p->tiff_length);
2533        TIFFSetField(output, TIFFTAG_ROWSPERSTRIP, t2p->tiff_length);
2534        TIFFSetField(output, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
2535        TIFFSetField(output, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
2536
2537        switch(t2p->pdf_compression){
2538        case T2P_COMPRESS_NONE:
2539                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
2540                break;
2541#ifdef CCITT_SUPPORT
2542        case T2P_COMPRESS_G4:
2543                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
2544                break;
2545#endif
2546#ifdef JPEG_SUPPORT
2547        case T2P_COMPRESS_JPEG:
2548                if(t2p->tiff_photometric==PHOTOMETRIC_YCBCR) {
2549                        uint16 hor = 0, ver = 0;
2550                        if (TIFFGetField(input, TIFFTAG_YCBCRSUBSAMPLING, &hor, &ver) !=0 ) {
2551                                if(hor != 0 && ver != 0){
2552                                        TIFFSetField(output, TIFFTAG_YCBCRSUBSAMPLING, hor, ver);
2553                                }
2554                        }
2555                        if(TIFFGetField(input, TIFFTAG_REFERENCEBLACKWHITE, &xfloatp)!=0){
2556                                TIFFSetField(output, TIFFTAG_REFERENCEBLACKWHITE, xfloatp);
2557                        }
2558                }
2559                if(TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_JPEG)==0){
2560                        TIFFError(TIFF2PDF_MODULE,
2561                "Unable to use JPEG compression for input %s and output %s",
2562                                TIFFFileName(input),
2563                                TIFFFileName(output));
2564                        _TIFFfree(buffer);
2565                        t2p->t2p_error = T2P_ERR_ERROR;
2566                        return(0);
2567                }
2568                TIFFSetField(output, TIFFTAG_JPEGTABLESMODE, 0);
2569
2570                if(t2p->pdf_colorspace & (T2P_CS_RGB | T2P_CS_LAB)){
2571                        TIFFSetField(output, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
2572                        if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR){
2573                                TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
2574                        } else {
2575                                TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
2576                        }
2577                }
2578                if(t2p->pdf_colorspace & T2P_CS_GRAY){
2579                        (void)0;
2580                }
2581                if(t2p->pdf_colorspace & T2P_CS_CMYK){
2582                        (void)0;
2583                }
2584                if(t2p->pdf_defaultcompressionquality != 0){
2585                        TIFFSetField(output,
2586                                TIFFTAG_JPEGQUALITY,
2587                                t2p->pdf_defaultcompressionquality);
2588                }
2589       
2590                break;
2591#endif
2592#ifdef ZIP_SUPPORT
2593        case T2P_COMPRESS_ZIP:
2594                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
2595                if(t2p->pdf_defaultcompressionquality%100 != 0){
2596                        TIFFSetField(output,
2597                                TIFFTAG_PREDICTOR,
2598                                t2p->pdf_defaultcompressionquality % 100);
2599                }
2600                if(t2p->pdf_defaultcompressionquality/100 != 0){
2601                        TIFFSetField(output,
2602                                TIFFTAG_ZIPQUALITY,
2603                                (t2p->pdf_defaultcompressionquality / 100));
2604                }
2605                break;
2606#endif
2607        default:
2608                break;
2609        }
2610
2611        t2p_enable(output);
2612        t2p->outputwritten = 0;
2613#ifdef JPEG_SUPPORT
2614        if(t2p->pdf_compression == T2P_COMPRESS_JPEG
2615           && t2p->tiff_photometric == PHOTOMETRIC_YCBCR){
2616                bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t)0,
2617                                                     buffer,
2618                                                     stripsize * stripcount);
2619        } else
2620#endif
2621        {
2622                bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t)0,
2623                                                     buffer,
2624                                                     t2p->tiff_datasize);
2625        }
2626        if (buffer != NULL) {
2627                _TIFFfree(buffer);
2628                buffer=NULL;
2629        }
2630
2631        if (bufferoffset == (tsize_t)-1) {
2632                TIFFError(TIFF2PDF_MODULE,
2633                          "Error writing encoded strip to output PDF %s",
2634                          TIFFFileName(output));
2635                t2p->t2p_error = T2P_ERR_ERROR;
2636                return(0);
2637        }
2638       
2639        written = t2p->outputwritten;
2640        return(written);
2641}
2642
2643/*
2644 * This function reads the raster image data from the input TIFF for an image
2645 * tile and writes the data to the output PDF XObject image dictionary stream
2646 * for the tile.  It returns the amount written or zero on error.
2647 */
2648
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;
2665        float* xfloatp;
2666        uint32 xuint32=0;
2667#endif
2668
2669        /* Fail if prior error (in particular, can't trust tiff_datasize) */
2670        if (t2p->t2p_error != T2P_ERR_OK)
2671                return(0);
2672
2673        edge |= t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
2674        edge |= t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile);
2675
2676        if( (t2p->pdf_transcode == T2P_TRANSCODE_RAW) && ((edge == 0)
2677#if defined(JPEG_SUPPORT) || defined(OJPEG_SUPPORT)
2678                || (t2p->pdf_compression == T2P_COMPRESS_JPEG)
2679#endif
2680        )
2681        ){
2682#ifdef CCITT_SUPPORT
2683                if(t2p->pdf_compression == T2P_COMPRESS_G4){
2684                        buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2685                        if(buffer==NULL){
2686                                TIFFError(TIFF2PDF_MODULE,
2687                                        "Can't allocate %lu bytes of memory "
2688                                        "for t2p_readwrite_pdf_image_tile, %s",
2689                                        (unsigned long) t2p->tiff_datasize,
2690                                        TIFFFileName(input));
2691                                t2p->t2p_error = T2P_ERR_ERROR;
2692                                return(0);
2693                        }
2694                        TIFFReadRawTile(input, tile, (tdata_t) buffer, t2p->tiff_datasize);
2695                        if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
2696                                        TIFFReverseBits(buffer, t2p->tiff_datasize);
2697                        }
2698                        t2pWriteFile(output, (tdata_t) buffer, t2p->tiff_datasize);
2699                        _TIFFfree(buffer);
2700                        return(t2p->tiff_datasize);
2701                }
2702#endif
2703#ifdef ZIP_SUPPORT
2704                if(t2p->pdf_compression == T2P_COMPRESS_ZIP){
2705                        buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2706                        if(buffer==NULL){
2707                                TIFFError(TIFF2PDF_MODULE,
2708                                        "Can't allocate %lu bytes of memory "
2709                                        "for t2p_readwrite_pdf_image_tile, %s",
2710                                        (unsigned long) t2p->tiff_datasize,
2711                                        TIFFFileName(input));
2712                                t2p->t2p_error = T2P_ERR_ERROR;
2713                                return(0);
2714                        }
2715                        TIFFReadRawTile(input, tile, (tdata_t) buffer, t2p->tiff_datasize);
2716                        if (t2p->tiff_fillorder==FILLORDER_LSB2MSB){
2717                                        TIFFReverseBits(buffer, t2p->tiff_datasize);
2718                        }
2719                        t2pWriteFile(output, (tdata_t) buffer, t2p->tiff_datasize);
2720                        _TIFFfree(buffer);
2721                        return(t2p->tiff_datasize);
2722                }
2723#endif
2724#ifdef OJPEG_SUPPORT
2725                if(t2p->tiff_compression == COMPRESSION_OJPEG){
2726                        if(! t2p->pdf_ojpegdata){
2727                                TIFFError(TIFF2PDF_MODULE,
2728                                        "No support for OJPEG image %s with "
2729                                        "bad tables",
2730                                        TIFFFileName(input));
2731                                t2p->t2p_error = T2P_ERR_ERROR;
2732                                return(0);
2733                        }
2734                        buffer=(unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2735                        if(buffer==NULL){
2736                                TIFFError(TIFF2PDF_MODULE,
2737                                        "Can't allocate %lu bytes of memory "
2738                                        "for t2p_readwrite_pdf_image, %s",
2739                                        (unsigned long) t2p->tiff_datasize,
2740                                        TIFFFileName(input));
2741                                t2p->t2p_error = T2P_ERR_ERROR;
2742                                return(0);
2743                        }
2744                        _TIFFmemcpy(buffer, t2p->pdf_ojpegdata, t2p->pdf_ojpegdatalength);
2745                        if(edge!=0){
2746                                if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile)){
2747                                        buffer[7]=
2748                                                (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength >> 8) & 0xff;
2749                                        buffer[8]=
2750                                                (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength ) & 0xff;
2751                                }
2752                                if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile)){
2753                                        buffer[9]=
2754                                                (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth >> 8) & 0xff;
2755                                        buffer[10]=
2756                                                (t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth ) & 0xff;
2757                                }
2758                        }
2759                        bufferoffset=t2p->pdf_ojpegdatalength;
2760                        bufferoffset+=TIFFReadRawTile(input,
2761                                        tile,
2762                                        (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2763                                        -1);
2764                        ((unsigned char*)buffer)[bufferoffset++]=0xff;
2765                        ((unsigned char*)buffer)[bufferoffset++]=0xd9;
2766                        t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2767                        _TIFFfree(buffer);
2768                        return(bufferoffset);
2769                }
2770#endif
2771#ifdef JPEG_SUPPORT
2772                if(t2p->tiff_compression == COMPRESSION_JPEG){
2773                        unsigned char table_end[2];
2774                        uint32 count = 0;
2775                        buffer= (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2776                        if(buffer==NULL){
2777                                TIFFError(TIFF2PDF_MODULE,
2778                                        "Can't allocate %lu bytes of memory "
2779                                        "for t2p_readwrite_pdf_image_tile, %s",
2780                                        t2p->tiff_datasize,
2781                                        TIFFFileName(input));
2782                                t2p->t2p_error = T2P_ERR_ERROR;
2783                                return(0);
2784                        }
2785                        if(TIFFGetField(input, TIFFTAG_JPEGTABLES, &count, &jpt) != 0) {
2786                                if (count > 0) {
2787                                        _TIFFmemcpy(buffer, jpt, count);
2788                                        bufferoffset += count - 2;
2789                                        table_end[0] = buffer[bufferoffset-2];
2790                                        table_end[1] = buffer[bufferoffset-1];
2791                                }
2792                                if (count > 0) {
2793                                        xuint32 = bufferoffset;
2794                                        bufferoffset += TIFFReadRawTile(
2795                                                input,
2796                                                tile,
2797                                                (tdata_t) &(((unsigned char*)buffer)[bufferoffset-2]),
2798                                                -1);
2799                                                buffer[xuint32-2]=table_end[0];
2800                                                buffer[xuint32-1]=table_end[1];
2801                                } else {
2802                                        bufferoffset += TIFFReadRawTile(
2803                                                input,
2804                                                tile,
2805                                                (tdata_t) &(((unsigned char*)buffer)[bufferoffset]),
2806                                                -1);
2807                                }
2808                        }
2809                        t2pWriteFile(output, (tdata_t) buffer, bufferoffset);
2810                        _TIFFfree(buffer);
2811                        return(bufferoffset);
2812                }
2813#endif
2814                (void)0;
2815        }
2816
2817        if(t2p->pdf_sample==T2P_SAMPLE_NOTHING){
2818                buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2819                if(buffer==NULL){
2820                        TIFFError(TIFF2PDF_MODULE,
2821                                "Can't allocate %lu bytes of memory for "
2822                                "t2p_readwrite_pdf_image_tile, %s",
2823                                (unsigned long) t2p->tiff_datasize,
2824                                TIFFFileName(input));
2825                        t2p->t2p_error = T2P_ERR_ERROR;
2826                        return(0);
2827                }
2828
2829                read = TIFFReadEncodedTile(
2830                        input,
2831                        tile,
2832                        (tdata_t) &buffer[bufferoffset],
2833                        t2p->tiff_datasize);
2834                if(read==-1){
2835                        TIFFError(TIFF2PDF_MODULE,
2836                                "Error on decoding tile %u of %s",
2837                                tile,
2838                                TIFFFileName(input));
2839                        _TIFFfree(buffer);
2840                        t2p->t2p_error=T2P_ERR_ERROR;
2841                        return(0);
2842                }
2843
2844        } else {
2845
2846                if(t2p->pdf_sample == T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG){
2847                        septilesize=TIFFTileSize(input);
2848                        septilecount=TIFFNumberOfTiles(input);
2849                        tilesize=septilesize*t2p->tiff_samplesperpixel;
2850                        tilecount=septilecount/t2p->tiff_samplesperpixel;
2851                        buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2852                        if(buffer==NULL){
2853                                TIFFError(TIFF2PDF_MODULE,
2854                                        "Can't allocate %lu bytes of memory "
2855                                        "for t2p_readwrite_pdf_image_tile, %s",
2856                                        (unsigned long) t2p->tiff_datasize,
2857                                        TIFFFileName(input));
2858                                t2p->t2p_error = T2P_ERR_ERROR;
2859                                return(0);
2860                        }
2861                        samplebuffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2862                        if(samplebuffer==NULL){
2863                                TIFFError(TIFF2PDF_MODULE,
2864                                        "Can't allocate %lu bytes of memory "
2865                                        "for t2p_readwrite_pdf_image_tile, %s",
2866                                        (unsigned long) t2p->tiff_datasize,
2867                                        TIFFFileName(input));
2868                                t2p->t2p_error = T2P_ERR_ERROR;
2869                                return(0);
2870                        }
2871                        samplebufferoffset=0;
2872                        for(i=0;i<t2p->tiff_samplesperpixel;i++){
2873                                read =
2874                                        TIFFReadEncodedTile(input,
2875                                                tile + i*tilecount,
2876                                                (tdata_t) &(samplebuffer[samplebufferoffset]),
2877                                                septilesize);
2878                                if(read==-1){
2879                                        TIFFError(TIFF2PDF_MODULE,
2880                                                "Error on decoding tile %u of %s",
2881                                                tile + i*tilecount,
2882                                                TIFFFileName(input));
2883                                                _TIFFfree(samplebuffer);
2884                                                _TIFFfree(buffer);
2885                                        t2p->t2p_error=T2P_ERR_ERROR;
2886                                        return(0);
2887                                }
2888                                samplebufferoffset+=read;
2889                        }
2890                        t2p_sample_planar_separate_to_contig(
2891                                t2p,
2892                                &(buffer[bufferoffset]),
2893                                samplebuffer,
2894                                samplebufferoffset);
2895                        bufferoffset+=samplebufferoffset;
2896                        _TIFFfree(samplebuffer);
2897                }
2898
2899                if(buffer==NULL){
2900                        buffer = (unsigned char*) _TIFFmalloc(t2p->tiff_datasize);
2901                        if(buffer==NULL){
2902                                TIFFError(TIFF2PDF_MODULE,
2903                                        "Can't allocate %lu bytes of memory "
2904                                        "for t2p_readwrite_pdf_image_tile, %s",
2905                                        (unsigned long) t2p->tiff_datasize,
2906                                        TIFFFileName(input));
2907                                t2p->t2p_error = T2P_ERR_ERROR;
2908                                return(0);
2909                        }
2910                        read = TIFFReadEncodedTile(
2911                                input,
2912                                tile,
2913                                (tdata_t) &buffer[bufferoffset],
2914                                t2p->tiff_datasize);
2915                        if(read==-1){
2916                                TIFFError(TIFF2PDF_MODULE,
2917                                        "Error on decoding tile %u of %s",
2918                                        tile,
2919                                        TIFFFileName(input));
2920                                _TIFFfree(buffer);
2921                                t2p->t2p_error=T2P_ERR_ERROR;
2922                                return(0);
2923                        }
2924                }
2925
2926                if(t2p->pdf_sample & T2P_SAMPLE_RGBA_TO_RGB){
2927                        t2p->tiff_datasize=t2p_sample_rgba_to_rgb(
2928                                (tdata_t)buffer,
2929                                t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth
2930                                *t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2931                }
2932
2933                if(t2p->pdf_sample & T2P_SAMPLE_RGBAA_TO_RGB){
2934                        t2p->tiff_datasize=t2p_sample_rgbaa_to_rgb(
2935                                (tdata_t)buffer,
2936                                t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth
2937                                *t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2938                }
2939
2940                if(t2p->pdf_sample & T2P_SAMPLE_YCBCR_TO_RGB){
2941                        TIFFError(TIFF2PDF_MODULE,
2942                                "No support for YCbCr to RGB in tile for %s",
2943                                TIFFFileName(input));
2944                        _TIFFfree(buffer);
2945                        t2p->t2p_error = T2P_ERR_ERROR;
2946                        return(0);
2947                }
2948
2949                if(t2p->pdf_sample & T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED){
2950                        t2p->tiff_datasize=t2p_sample_lab_signed_to_unsigned(
2951                                (tdata_t)buffer,
2952                                t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth
2953                                *t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2954                }
2955        }
2956
2957        if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile) != 0){
2958                t2p_tile_collapse_left(
2959                        buffer,
2960                        TIFFTileRowSize(input),
2961                        t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth,
2962                        t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth,
2963                        t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2964        }
2965
2966
2967        t2p_disable(output);
2968        TIFFSetField(output, TIFFTAG_PHOTOMETRIC, t2p->tiff_photometric);
2969        TIFFSetField(output, TIFFTAG_BITSPERSAMPLE, t2p->tiff_bitspersample);
2970        TIFFSetField(output, TIFFTAG_SAMPLESPERPIXEL, t2p->tiff_samplesperpixel);
2971        if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile) == 0){
2972                TIFFSetField(
2973                        output,
2974                        TIFFTAG_IMAGEWIDTH,
2975                        t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
2976        } else {
2977                TIFFSetField(
2978                        output,
2979                        TIFFTAG_IMAGEWIDTH,
2980                        t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
2981        }
2982        if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile) == 0){
2983                TIFFSetField(
2984                        output,
2985                        TIFFTAG_IMAGELENGTH,
2986                        t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2987                TIFFSetField(
2988                        output,
2989                        TIFFTAG_ROWSPERSTRIP,
2990                        t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
2991        } else {
2992                TIFFSetField(
2993                        output,
2994                        TIFFTAG_IMAGELENGTH,
2995                        t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
2996                TIFFSetField(
2997                        output,
2998                        TIFFTAG_ROWSPERSTRIP,
2999                        t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
3000        }
3001        TIFFSetField(output, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
3002        TIFFSetField(output, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
3003
3004        switch(t2p->pdf_compression){
3005        case T2P_COMPRESS_NONE:
3006                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
3007                break;
3008#ifdef CCITT_SUPPORT
3009        case T2P_COMPRESS_G4:
3010                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
3011                break;
3012#endif
3013#ifdef JPEG_SUPPORT
3014        case T2P_COMPRESS_JPEG:
3015                if (t2p->tiff_photometric==PHOTOMETRIC_YCBCR) {
3016                        uint16 hor = 0, ver = 0;
3017                        if (TIFFGetField(input, TIFFTAG_YCBCRSUBSAMPLING, &hor, &ver)!=0) {
3018                                if (hor != 0 && ver != 0) {
3019                                        TIFFSetField(output, TIFFTAG_YCBCRSUBSAMPLING, hor, ver);
3020                                }
3021                        }
3022                        if(TIFFGetField(input, TIFFTAG_REFERENCEBLACKWHITE, &xfloatp)!=0){
3023                                TIFFSetField(output, TIFFTAG_REFERENCEBLACKWHITE, xfloatp);
3024                        }
3025                }
3026                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
3027                TIFFSetField(output, TIFFTAG_JPEGTABLESMODE, 0); /* JPEGTABLESMODE_NONE */
3028                if(t2p->pdf_colorspace & (T2P_CS_RGB | T2P_CS_LAB)){
3029                        TIFFSetField(output, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
3030                        if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR){
3031                                TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
3032                        } else {
3033                                TIFFSetField(output, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
3034                        }
3035                }
3036                if(t2p->pdf_colorspace & T2P_CS_GRAY){
3037                        (void)0;
3038                }
3039                if(t2p->pdf_colorspace & T2P_CS_CMYK){
3040                        (void)0;
3041                }
3042                if(t2p->pdf_defaultcompressionquality != 0){
3043                        TIFFSetField(output,
3044                                TIFFTAG_JPEGQUALITY,
3045                                t2p->pdf_defaultcompressionquality);
3046                }
3047                break;
3048#endif
3049#ifdef ZIP_SUPPORT
3050        case T2P_COMPRESS_ZIP:
3051                TIFFSetField(output, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
3052                if(t2p->pdf_defaultcompressionquality%100 != 0){
3053                        TIFFSetField(output,
3054                                TIFFTAG_PREDICTOR,
3055                                t2p->pdf_defaultcompressionquality % 100);
3056                }
3057                if(t2p->pdf_defaultcompressionquality/100 != 0){
3058                        TIFFSetField(output,
3059                                TIFFTAG_ZIPQUALITY,
3060                                (t2p->pdf_defaultcompressionquality / 100));
3061                }
3062                break;
3063#endif
3064        default:
3065                break;
3066        }
3067
3068        t2p_enable(output);
3069        t2p->outputwritten = 0;
3070        bufferoffset = TIFFWriteEncodedStrip(output, (tstrip_t) 0, buffer,
3071                                             TIFFStripSize(output));
3072        if (buffer != NULL) {
3073                _TIFFfree(buffer);
3074                buffer = NULL;
3075        }
3076        if (bufferoffset == -1) {
3077                TIFFError(TIFF2PDF_MODULE,
3078                          "Error writing encoded tile to output PDF %s",
3079                          TIFFFileName(output));
3080                t2p->t2p_error = T2P_ERR_ERROR;
3081                return(0);
3082        }
3083       
3084        written = t2p->outputwritten;
3085       
3086        return(written);
3087}
3088
3089#ifdef OJPEG_SUPPORT
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));
3185                t2p->t2p_error = T2P_ERR_ERROR;
3186                return(0);
3187        }
3188        _TIFFmemset(t2p->pdf_ojpegdata, 0x00, 2048);
3189        t2p->pdf_ojpegdatalength = 0;
3190        table_count=t2p->tiff_samplesperpixel;
3191        if(proc==JPEGPROC_BASELINE){
3192                if(table_count>2) table_count=2;
3193        }
3194        ojpegdata=(unsigned char*)t2p->pdf_ojpegdata;
3195        ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3196        ojpegdata[t2p->pdf_ojpegdatalength++]=0xd8;
3197        ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3198        if(proc==JPEGPROC_BASELINE){
3199                ojpegdata[t2p->pdf_ojpegdatalength++]=0xc0;
3200        } else {
3201                ojpegdata[t2p->pdf_ojpegdatalength++]=0xc3;
3202        }
3203        ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3204        ojpegdata[t2p->pdf_ojpegdatalength++]=(8 + 3*t2p->tiff_samplesperpixel);
3205        ojpegdata[t2p->pdf_ojpegdatalength++]=(t2p->tiff_bitspersample & 0xff);
3206        if(TIFFIsTiled(input)){
3207                ojpegdata[t2p->pdf_ojpegdatalength++]=
3208                        (t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength >> 8) & 0xff;
3209                ojpegdata[t2p->pdf_ojpegdatalength++]=
3210                        (t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength ) & 0xff;
3211                ojpegdata[t2p->pdf_ojpegdatalength++]=
3212                        (t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth >> 8) & 0xff;
3213                ojpegdata[t2p->pdf_ojpegdatalength++]=
3214                        (t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth ) & 0xff;
3215        } else {
3216                ojpegdata[t2p->pdf_ojpegdatalength++]=
3217                        (t2p->tiff_length >> 8) & 0xff;
3218                ojpegdata[t2p->pdf_ojpegdatalength++]=
3219                        (t2p->tiff_length ) & 0xff;
3220                ojpegdata[t2p->pdf_ojpegdatalength++]=
3221                        (t2p->tiff_width >> 8) & 0xff;
3222                ojpegdata[t2p->pdf_ojpegdatalength++]=
3223                        (t2p->tiff_width ) & 0xff;
3224        }
3225        ojpegdata[t2p->pdf_ojpegdatalength++]=(t2p->tiff_samplesperpixel & 0xff);
3226        for(i=0;i<t2p->tiff_samplesperpixel;i++){
3227                ojpegdata[t2p->pdf_ojpegdatalength++]=i;
3228                if(i==0){
3229                        ojpegdata[t2p->pdf_ojpegdatalength] |= h_samp<<4 & 0xf0;;
3230                        ojpegdata[t2p->pdf_ojpegdatalength++] |= v_samp & 0x0f;
3231                } else {
3232                                ojpegdata[t2p->pdf_ojpegdatalength++]= 0x11;
3233                }
3234                ojpegdata[t2p->pdf_ojpegdatalength++]=i;
3235        }
3236        for(dest=0;dest<t2p->tiff_samplesperpixel;dest++){
3237                ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3238                ojpegdata[t2p->pdf_ojpegdatalength++]=0xdb;
3239                ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3240                ojpegdata[t2p->pdf_ojpegdatalength++]=0x43;
3241                ojpegdata[t2p->pdf_ojpegdatalength++]=dest;
3242                _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength++]),
3243                        &(((unsigned char*)q)[64*dest]), 64);
3244                t2p->pdf_ojpegdatalength+=64;
3245        }
3246        offset_table=0;
3247        for(dest=0;dest<table_count;dest++){
3248                ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3249                ojpegdata[t2p->pdf_ojpegdatalength++]=0xc4;
3250                offset_ms_l=t2p->pdf_ojpegdatalength;
3251                t2p->pdf_ojpegdatalength+=2;
3252                ojpegdata[t2p->pdf_ojpegdatalength++]=dest & 0x0f;
3253                _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3254                        &(((unsigned char*)dc)[offset_table]), 16);
3255                code_count=0;
3256                offset_table+=16;
3257                for(i=0;i<16;i++){
3258                        code_count+=ojpegdata[t2p->pdf_ojpegdatalength++];
3259                }
3260                ojpegdata[offset_ms_l]=((19+code_count)>>8) & 0xff;
3261                ojpegdata[offset_ms_l+1]=(19+code_count) & 0xff;
3262                _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3263                        &(((unsigned char*)dc)[offset_table]), code_count);
3264                offset_table+=code_count;
3265                t2p->pdf_ojpegdatalength+=code_count;
3266        }
3267        if(proc==JPEGPROC_BASELINE){
3268        offset_table=0;
3269                for(dest=0;dest<table_count;dest++){
3270                        ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3271                        ojpegdata[t2p->pdf_ojpegdatalength++]=0xc4;
3272                        offset_ms_l=t2p->pdf_ojpegdatalength;
3273                        t2p->pdf_ojpegdatalength+=2;
3274                        ojpegdata[t2p->pdf_ojpegdatalength] |= 0x10;
3275                        ojpegdata[t2p->pdf_ojpegdatalength++] |=dest & 0x0f;
3276                        _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3277                                &(((unsigned char*)ac)[offset_table]), 16);
3278                        code_count=0;
3279                        offset_table+=16;
3280                        for(i=0;i<16;i++){
3281                                code_count+=ojpegdata[t2p->pdf_ojpegdatalength++];
3282                        }       
3283                        ojpegdata[offset_ms_l]=((19+code_count)>>8) & 0xff;
3284                        ojpegdata[offset_ms_l+1]=(19+code_count) & 0xff;
3285                        _TIFFmemcpy( &(ojpegdata[t2p->pdf_ojpegdatalength]),
3286                                &(((unsigned char*)ac)[offset_table]), code_count);
3287                        offset_table+=code_count;
3288                        t2p->pdf_ojpegdatalength+=code_count;
3289                }
3290        }
3291        if(TIFFNumberOfStrips(input)>1){
3292                ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3293                ojpegdata[t2p->pdf_ojpegdatalength++]=0xdd;
3294                ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3295                ojpegdata[t2p->pdf_ojpegdatalength++]=0x04;
3296                h_samp*=8;
3297                v_samp*=8;
3298                ri=(t2p->tiff_width+h_samp-1) / h_samp;
3299                TIFFGetField(input, TIFFTAG_ROWSPERSTRIP, &rows);
3300                ri*=(rows+v_samp-1)/v_samp;
3301                ojpegdata[t2p->pdf_ojpegdatalength++]= (ri>>8) & 0xff;
3302                ojpegdata[t2p->pdf_ojpegdatalength++]= ri & 0xff;
3303        }
3304        ojpegdata[t2p->pdf_ojpegdatalength++]=0xff;
3305        ojpegdata[t2p->pdf_ojpegdatalength++]=0xda;
3306        ojpegdata[t2p->pdf_ojpegdatalength++]=0x00;
3307        ojpegdata[t2p->pdf_ojpegdatalength++]=(6 + 2*t2p->tiff_samplesperpixel);
3308        ojpegdata[t2p->pdf_ojpegdatalength++]=t2p->tiff_samplesperpixel & 0xff;
3309        for(i=0;i<t2p->tiff_samplesperpixel;i++){
3310                ojpegdata[t2p->pdf_ojpegdatalength++]= i & 0xff;
3311                if(proc==JPEGPROC_BASELINE){
3312                        ojpegdata[t2p->pdf_ojpegdatalength] |=
3313                                ( ( (i>(table_count-1U)) ? (table_count-1U) : i) << 4U) & 0xf0;
3314                        ojpegdata[t2p->pdf_ojpegdatalength++] |=
3315                                ( (i>(table_count-1U)) ? (table_count-1U) : i) & 0x0f;
3316                } else {
3317                        ojpegdata[t2p->pdf_ojpegdatalength++] =  (i << 4) & 0xf0;
3318                }
3319        }
3320        if(proc==JPEGPROC_BASELINE){
3321                t2p->pdf_ojpegdatalength++;
3322                ojpegdata[t2p->pdf_ojpegdatalength++]=0x3f;
3323                t2p->pdf_ojpegdatalength++;
3324        } else {
3325                ojpegdata[t2p->pdf_ojpegdatalength++]= (lp[0] & 0xff);
3326                t2p->pdf_ojpegdatalength++;
3327                ojpegdata[t2p->pdf_ojpegdatalength++]= (pt[0] & 0x0f);
3328        }
3329
3330        return(1);
3331}
3332#endif
3333
3334#ifdef JPEG_SUPPORT
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:
3354                                /* SOI - start of image */
3355                                _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), 2);
3356                                *bufferoffset+=2;
3357                                i+=2;
3358                                break;
3359                        case 0xc0:
3360                        case 0xc1:
3361                        case 0xc3:
3362                        case 0xc9:
3363                        case 0xca:
3364                                if(no==0){
3365                                        _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3366                                        for(j=0;j<buffer[*bufferoffset+9];j++){
3367                                                if( (buffer[*bufferoffset+11+(2*j)]>>4) > h_samp)
3368                                                        h_samp = (buffer[*bufferoffset+11+(2*j)]>>4);
3369                                                if( (buffer[*bufferoffset+11+(2*j)] & 0x0f) > v_samp)
3370                                                        v_samp = (buffer[*bufferoffset+11+(2*j)] & 0x0f);
3371                                        }
3372                                        v_samp*=8;
3373                                        h_samp*=8;
3374                                        ri=((( ((uint16)(buffer[*bufferoffset+5])<<8) |
3375                                        (uint16)(buffer[*bufferoffset+6]) )+v_samp-1)/
3376                                        v_samp);
3377                                        ri*=((( ((uint16)(buffer[*bufferoffset+7])<<8) |
3378                                        (uint16)(buffer[*bufferoffset+8]) )+h_samp-1)/
3379                                        h_samp);
3380                                        buffer[*bufferoffset+5]=
3381                                          (unsigned char) ((height>>8) & 0xff);
3382                                        buffer[*bufferoffset+6]=
3383                                            (unsigned char) (height & 0xff);
3384                                        *bufferoffset+=strip[i+2]+2;
3385                                        i+=strip[i+2]+2;
3386
3387                                        buffer[(*bufferoffset)++]=0xff;
3388                                        buffer[(*bufferoffset)++]=0xdd;
3389                                        buffer[(*bufferoffset)++]=0x00;
3390                                        buffer[(*bufferoffset)++]=0x04;
3391                                        buffer[(*bufferoffset)++]=(ri >> 8) & 0xff;
3392                                        buffer[(*bufferoffset)++]= ri & 0xff;
3393                                } else {
3394                                        i+=strip[i+2]+2;
3395                                }
3396                                break;
3397                        case 0xc4:
3398                        case 0xdb:
3399                                _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3400                                *bufferoffset+=strip[i+2]+2;
3401                                i+=strip[i+2]+2;
3402                                break;
3403                        case 0xda:
3404                                if(no==0){
3405                                        _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3406                                        *bufferoffset+=strip[i+2]+2;
3407                                        i+=strip[i+2]+2;
3408                                } else {
3409                                        buffer[(*bufferoffset)++]=0xff;
3410                                        buffer[(*bufferoffset)++]=
3411                                            (unsigned char)(0xd0 | ((no-1)%8));
3412                                        i+=strip[i+2]+2;
3413                                }
3414                                _TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), (*striplength)-i-1);
3415                                *bufferoffset+=(*striplength)-i-1;
3416                                return(1);
3417                        default:
3418                                i+=strip[i+2]+2;
3419                }
3420        }
3421       
3422
3423        return(0);
3424}
3425#endif
3426
3427/*
3428        This functions converts a tilewidth x tilelength buffer of samples into an edgetilewidth x
3429        tilelength buffer of samples.
3430*/
3431void t2p_tile_collapse_left(
3432        tdata_t buffer,
3433        tsize_t scanwidth,
3434        uint32 tilewidth,
3435        uint32 edgetilewidth,
3436        uint32 tilelength){
3437       
3438        uint32 i;
3439        tsize_t edgescanwidth=0;
3440       
3441        edgescanwidth = (scanwidth * edgetilewidth + (tilewidth - 1))/ tilewidth;
3442        for(i=0;i<tilelength;i++){
3443                _TIFFmemcpy(
3444                        &(((char*)buffer)[edgescanwidth*i]),
3445                        &(((char*)buffer)[scanwidth*i]),
3446                        edgescanwidth);
3447        }
3448       
3449        return;
3450}
3451
3452
3453/*
3454 * This function calls TIFFWriteDirectory on the output after blanking its
3455 * output by replacing the read, write, and seek procedures with empty
3456 * implementations, then it replaces the original implementations.
3457 */
3458
3459void
3460t2p_write_advance_directory(T2P* t2p, TIFF* output)
3461{
3462        t2p_disable(output);
3463        if(!TIFFWriteDirectory(output)){
3464                TIFFError(TIFF2PDF_MODULE,
3465                        "Error writing virtual directory to output PDF %s",
3466                        TIFFFileName(output));
3467                t2p->t2p_error = T2P_ERR_ERROR;
3468                return;
3469        }
3470        t2p_enable(output);
3471        return;
3472}
3473
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];
3566                alpha=(uint8)((255 - ((sample >> 24) & 0xff)));
3567                ((uint8 *)data)[i * 3] = (uint8) ((sample >> 16) & 0xff) + alpha;
3568                ((uint8 *)data)[i * 3 + 1] = (uint8) ((sample >> 8) & 0xff) + alpha;
3569                ((uint8 *)data)[i * 3 + 2] = (uint8) (sample & 0xff) + alpha;
3570        }
3571
3572        return (i * 3);
3573}
3574
3575/*
3576        This function converts the a and b samples of Lab data from signed
3577        to unsigned.
3578*/
3579
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);
3613        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3614        written += t2pWriteFile(output, (tdata_t)"\n%\342\343\317\323\n", 7);
3615
3616        return(written);
3617}
3618
3619/*
3620        This function writes the beginning of a PDF object to output.
3621*/
3622
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);
3630        written += t2pWriteFile(output, (tdata_t) buffer, buflen );
3631        written += t2pWriteFile(output, (tdata_t) " 0 obj\n", 7);
3632
3633        return(written);
3634}
3635
3636/*
3637        This function writes the end of a PDF object to output.
3638*/
3639
3640tsize_t t2p_write_pdf_obj_end(TIFF* output){
3641
3642        tsize_t written=0;
3643
3644        written += t2pWriteFile(output, (tdata_t) "endobj\n", 7);
3645
3646        return(written);
3647}
3648
3649/*
3650        This function writes a PDF name object to output.
3651*/
3652
3653tsize_t t2p_write_pdf_name(unsigned char* name, TIFF* output){
3654
3655        tsize_t written=0;
3656        uint32 i=0;
3657        char buffer[64];
3658        uint16 nextchar=0;
3659        size_t namelen=0;
3660       
3661        namelen = strlen((char *)name);
3662        if (namelen>126) {
3663                namelen=126;
3664        }
3665        written += t2pWriteFile(output, (tdata_t) "/", 1);
3666        for (i=0;i<namelen;i++){
3667                if ( ((unsigned char)name[i]) < 0x21){
3668                        sprintf(buffer, "#%.2X", name[i]);
3669                        buffer[sizeof(buffer) - 1] = '\0';
3670                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3671                        nextchar=1;
3672                }
3673                if ( ((unsigned char)name[i]) > 0x7E){
3674                        sprintf(buffer, "#%.2X", name[i]);
3675                        buffer[sizeof(buffer) - 1] = '\0';
3676                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3677                        nextchar=1;
3678                }
3679                if (nextchar==0){
3680                        switch (name[i]){
3681                                case 0x23:
3682                                        sprintf(buffer, "#%.2X", name[i]);
3683                                        buffer[sizeof(buffer) - 1] = '\0';
3684                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3685                                        break;
3686                                case 0x25:
3687                                        sprintf(buffer, "#%.2X", name[i]);
3688                                        buffer[sizeof(buffer) - 1] = '\0';
3689                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3690                                        break;
3691                                case 0x28:
3692                                        sprintf(buffer, "#%.2X", name[i]);
3693                                        buffer[sizeof(buffer) - 1] = '\0';
3694                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3695                                        break;
3696                                case 0x29:
3697                                        sprintf(buffer, "#%.2X", name[i]);
3698                                        buffer[sizeof(buffer) - 1] = '\0';
3699                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3700                                        break;
3701                                case 0x2F:
3702                                        sprintf(buffer, "#%.2X", name[i]);
3703                                        buffer[sizeof(buffer) - 1] = '\0';
3704                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3705                                        break;
3706                                case 0x3C:
3707                                        sprintf(buffer, "#%.2X", name[i]);
3708                                        buffer[sizeof(buffer) - 1] = '\0';
3709                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3710                                        break;
3711                                case 0x3E:
3712                                        sprintf(buffer, "#%.2X", name[i]);
3713                                        buffer[sizeof(buffer) - 1] = '\0';
3714                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3715                                        break;
3716                                case 0x5B:
3717                                        sprintf(buffer, "#%.2X", name[i]);
3718                                        buffer[sizeof(buffer) - 1] = '\0';
3719                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3720                                        break;
3721                                case 0x5D:
3722                                        sprintf(buffer, "#%.2X", name[i]);
3723                                        buffer[sizeof(buffer) - 1] = '\0';
3724                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3725                                        break;
3726                                case 0x7B:
3727                                        sprintf(buffer, "#%.2X", name[i]);
3728                                        buffer[sizeof(buffer) - 1] = '\0';
3729                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3730                                        break;
3731                                case 0x7D:
3732                                        sprintf(buffer, "#%.2X", name[i]);
3733                                        buffer[sizeof(buffer) - 1] = '\0';
3734                                        written += t2pWriteFile(output, (tdata_t) buffer, 3);
3735                                        break;
3736                                default:
3737                                        written += t2pWriteFile(output, (tdata_t) &name[i], 1);
3738                        }
3739                }
3740                nextchar=0;
3741        }
3742        written += t2pWriteFile(output, (tdata_t) " ", 1);
3743
3744        return(written);
3745}
3746
3747/*
3748 * This function writes a PDF string object to output.
3749 */
3750       
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;
3757       
3758        len = strlen(pdfstr);
3759        written += t2pWriteFile(output, (tdata_t) "(", 1);
3760        for (i=0; i<len; i++) {
3761                if((pdfstr[i]&0x80) || (pdfstr[i]==127) || (pdfstr[i]<32)){
3762                        snprintf(buffer, sizeof(buffer), "\\%.3o", ((unsigned char)pdfstr[i]));
3763                        written += t2pWriteFile(output, (tdata_t)buffer, 4);
3764                } else {
3765                        switch (pdfstr[i]){
3766                                case 0x08:
3767                                        written += t2pWriteFile(output, (tdata_t) "\\b", 2);
3768                                        break;
3769                                case 0x09:
3770                                        written += t2pWriteFile(output, (tdata_t) "\\t", 2);
3771                                        break;
3772                                case 0x0A:
3773                                        written += t2pWriteFile(output, (tdata_t) "\\n", 2);
3774                                        break;
3775                                case 0x0C:
3776                                        written += t2pWriteFile(output, (tdata_t) "\\f", 2);
3777                                        break;
3778                                case 0x0D:
3779                                        written += t2pWriteFile(output, (tdata_t) "\\r", 2);
3780                                        break;
3781                                case 0x28:
3782                                        written += t2pWriteFile(output, (tdata_t) "\\(", 2);
3783                                        break;
3784                                case 0x29:
3785                                        written += t2pWriteFile(output, (tdata_t) "\\)", 2);
3786                                        break;
3787                                case 0x5C:
3788                                        written += t2pWriteFile(output, (tdata_t) "\\\\", 2);
3789                                        break;
3790                                default:
3791                                        written += t2pWriteFile(output, (tdata_t) &pdfstr[i], 1);
3792                        }
3793                }
3794        }
3795        written += t2pWriteFile(output, (tdata_t) ") ", 1);
3796
3797        return(written);
3798}
3799
3800
3801/*
3802        This function writes a buffer of data to output.
3803*/
3804
3805tsize_t t2p_write_pdf_stream(tdata_t buffer, tsize_t len, TIFF* output){
3806
3807        tsize_t written=0;
3808
3809        written += t2pWriteFile(output, (tdata_t) buffer, len);
3810
3811        return(written);
3812}
3813
3814/*
3815        This functions writes the beginning of a PDF stream to output.
3816*/
3817
3818tsize_t t2p_write_pdf_stream_start(TIFF* output){
3819
3820        tsize_t written=0;
3821
3822        written += t2pWriteFile(output, (tdata_t) "stream\n", 7);
3823
3824        return(written);
3825}
3826
3827/*
3828        This function writes the end of a PDF stream to output.
3829*/
3830
3831tsize_t t2p_write_pdf_stream_end(TIFF* output){
3832
3833        tsize_t written=0;
3834
3835        written += t2pWriteFile(output, (tdata_t) "\nendstream\n", 11);
3836
3837        return(written);
3838}
3839
3840/*
3841        This function writes a stream dictionary for a PDF stream to output.
3842*/
3843
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       
3850        written += t2pWriteFile(output, (tdata_t) "/Length ", 8);
3851        if(len!=0){
3852                written += t2p_write_pdf_stream_length(len, output);
3853        } else {
3854                buflen=sprintf(buffer, "%lu", (unsigned long)number);
3855                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3856                written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
3857        }
3858       
3859        return(written);
3860}
3861
3862/*
3863        This functions writes the beginning of a PDF stream dictionary to output.
3864*/
3865
3866tsize_t t2p_write_pdf_stream_dict_start(TIFF* output){
3867
3868        tsize_t written=0;
3869
3870        written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
3871
3872        return(written);
3873}
3874
3875/*
3876        This function writes the end of a PDF stream dictionary to output.
3877*/
3878
3879tsize_t t2p_write_pdf_stream_dict_end(TIFF* output){
3880
3881        tsize_t written=0;
3882
3883        written += t2pWriteFile(output, (tdata_t) " >>\n", 4);
3884
3885        return(written);
3886}
3887
3888/*
3889        This function writes a number to output.
3890*/
3891
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);
3899        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3900        written += t2pWriteFile(output, (tdata_t) "\n", 1);
3901
3902        return(written);
3903}
3904
3905/*
3906 * This function writes the PDF Catalog structure to output.
3907 */
3908
3909tsize_t t2p_write_pdf_catalog(T2P* t2p, TIFF* output)
3910{
3911        tsize_t written = 0;
3912        char buffer[16];
3913        int buflen = 0;
3914
3915        written += t2pWriteFile(output,
3916                (tdata_t)"<< \n/Type /Catalog \n/Pages ",
3917                27);
3918        buflen = snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)t2p->pdf_pages);
3919        written += t2pWriteFile(output, (tdata_t) buffer,
3920                                TIFFmin((size_t)buflen, sizeof(buffer) - 1));
3921        written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
3922        if(t2p->pdf_fitwindow){
3923                written += t2pWriteFile(output,
3924                        (tdata_t) "/ViewerPreferences <</FitWindow true>>\n",
3925                        39);
3926        }
3927        written += t2pWriteFile(output, (tdata_t)">>\n", 3);
3928
3929        return(written);
3930}
3931
3932/*
3933        This function writes the PDF Info structure to output.
3934*/
3935
3936tsize_t t2p_write_pdf_info(T2P* t2p, TIFF* input, TIFF* output)
3937{
3938        tsize_t written = 0;
3939        char* info;
3940        char buffer[512];
3941
3942        if(t2p->pdf_datetime[0] == '\0')
3943                t2p_pdf_tifftime(t2p, input);
3944        if (strlen(t2p->pdf_datetime) > 0) {
3945                written += t2pWriteFile(output, (tdata_t) "<< \n/CreationDate ", 18);
3946                written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3947                written += t2pWriteFile(output, (tdata_t) "\n/ModDate ", 10);
3948                written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3949        }
3950        written += t2pWriteFile(output, (tdata_t) "\n/Producer ", 11);
3951        _TIFFmemset((tdata_t)buffer, 0x00, sizeof(buffer));
3952        snprintf(buffer, sizeof(buffer), "libtiff / tiff2pdf - %d", TIFFLIB_VERSION);
3953        written += t2p_write_pdf_string(buffer, output);
3954        written += t2pWriteFile(output, (tdata_t) "\n", 1);
3955        if (t2p->pdf_creator[0] != '\0') {
3956                written += t2pWriteFile(output, (tdata_t) "/Creator ", 9);
3957                written += t2p_write_pdf_string(t2p->pdf_creator, output);
3958                written += t2pWriteFile(output, (tdata_t) "\n", 1);
3959        } else {
3960                if (TIFFGetField(input, TIFFTAG_SOFTWARE, &info) != 0 && info) {
3961                        if(strlen(info) >= sizeof(t2p->pdf_creator))
3962                                info[sizeof(t2p->pdf_creator) - 1] = '\0';
3963                        written += t2pWriteFile(output, (tdata_t) "/Creator ", 9);
3964                        written += t2p_write_pdf_string(info, output);
3965                        written += t2pWriteFile(output, (tdata_t) "\n", 1);
3966                }
3967        }
3968        if (t2p->pdf_author[0] != '\0') {
3969                written += t2pWriteFile(output, (tdata_t) "/Author ", 8);
3970                written += t2p_write_pdf_string(t2p->pdf_author, output);
3971                written += t2pWriteFile(output, (tdata_t) "\n", 1);
3972        } else {
3973                if ((TIFFGetField(input, TIFFTAG_ARTIST, &info) != 0
3974                     || TIFFGetField(input, TIFFTAG_COPYRIGHT, &info) != 0)
3975                    && info) {
3976                        if (strlen(info) >= sizeof(t2p->pdf_author))
3977                                info[sizeof(t2p->pdf_author) - 1] = '\0';
3978                        written += t2pWriteFile(output, (tdata_t) "/Author ", 8);
3979                        written += t2p_write_pdf_string(info, output);
3980                        written += t2pWriteFile(output, (tdata_t) "\n", 1);
3981                }
3982        }
3983        if (t2p->pdf_title[0] != '\0') {
3984                written += t2pWriteFile(output, (tdata_t) "/Title ", 7);
3985                written += t2p_write_pdf_string(t2p->pdf_title, output);
3986                written += t2pWriteFile(output, (tdata_t) "\n", 1);
3987        } else {
3988                if (TIFFGetField(input, TIFFTAG_DOCUMENTNAME, &info) != 0){
3989                        if(strlen(info) > 511) {
3990                                info[512] = '\0';
3991                        }
3992                        written += t2pWriteFile(output, (tdata_t) "/Title ", 7);
3993                        written += t2p_write_pdf_string(info, output);
3994                        written += t2pWriteFile(output, (tdata_t) "\n", 1);
3995                }
3996        }
3997        if (t2p->pdf_subject[0] != '\0') {
3998                written += t2pWriteFile(output, (tdata_t) "/Subject ", 9);
3999                written += t2p_write_pdf_string(t2p->pdf_subject, output);
4000                written += t2pWriteFile(output, (tdata_t) "\n", 1);
4001        } else {
4002                if (TIFFGetField(input, TIFFTAG_IMAGEDESCRIPTION, &info) != 0 && info) {
4003                        if (strlen(info) >= sizeof(t2p->pdf_subject))
4004                                info[sizeof(t2p->pdf_subject) - 1] = '\0';
4005                        written += t2pWriteFile(output, (tdata_t) "/Subject ", 9);
4006                        written += t2p_write_pdf_string(info, output);
4007                        written += t2pWriteFile(output, (tdata_t) "\n", 1);
4008                }
4009        }
4010        if (t2p->pdf_keywords[0] != '\0') {
4011                written += t2pWriteFile(output, (tdata_t) "/Keywords ", 10);
4012                written += t2p_write_pdf_string(t2p->pdf_keywords, output);
4013                written += t2pWriteFile(output, (tdata_t) "\n", 1);
4014        }
4015        written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
4016
4017        return(written);
4018}
4019
4020/*
4021 * This function fills a string of a T2P struct with the current time as a PDF
4022 * date string, it is called by t2p_pdf_tifftime.
4023 */
4024
4025void t2p_pdf_currenttime(T2P* t2p)
4026{
4027        struct tm* currenttime;
4028        time_t timenow;
4029
4030        if (time(&timenow) == (time_t) -1) {
4031                TIFFError(TIFF2PDF_MODULE,
4032                          "Can't get the current time: %s", strerror(errno));
4033                timenow = (time_t) 0;
4034        }
4035
4036        currenttime = localtime(&timenow);
4037        snprintf(t2p->pdf_datetime, sizeof(t2p->pdf_datetime),
4038                 "D:%.4d%.2d%.2d%.2d%.2d%.2d",
4039                 (currenttime->tm_year + 1900) % 65536,
4040                 (currenttime->tm_mon + 1) % 256,
4041                 (currenttime->tm_mday) % 256,
4042                 (currenttime->tm_hour) % 256,
4043                 (currenttime->tm_min) % 256,
4044                 (currenttime->tm_sec) % 256);
4045
4046        return;
4047}
4048
4049/*
4050 * This function fills a string of a T2P struct with the date and time of a
4051 * TIFF file if it exists or the current time as a PDF date string.
4052 */
4053
4054void t2p_pdf_tifftime(T2P* t2p, TIFF* input)
4055{
4056        char* datetime;
4057
4058        if (TIFFGetField(input, TIFFTAG_DATETIME, &datetime) != 0
4059            && (strlen(datetime) >= 19) ){
4060                t2p->pdf_datetime[0]='D';
4061                t2p->pdf_datetime[1]=':';
4062                t2p->pdf_datetime[2]=datetime[0];
4063                t2p->pdf_datetime[3]=datetime[1];
4064                t2p->pdf_datetime[4]=datetime[2];
4065                t2p->pdf_datetime[5]=datetime[3];
4066                t2p->pdf_datetime[6]=datetime[5];
4067                t2p->pdf_datetime[7]=datetime[6];
4068                t2p->pdf_datetime[8]=datetime[8];
4069                t2p->pdf_datetime[9]=datetime[9];
4070                t2p->pdf_datetime[10]=datetime[11];
4071                t2p->pdf_datetime[11]=datetime[12];
4072                t2p->pdf_datetime[12]=datetime[14];
4073                t2p->pdf_datetime[13]=datetime[15];
4074                t2p->pdf_datetime[14]=datetime[17];
4075                t2p->pdf_datetime[15]=datetime[18];
4076                t2p->pdf_datetime[16] = '\0';
4077        } else {
4078                t2p_pdf_currenttime(t2p);
4079        }
4080
4081        return;
4082}
4083
4084/*
4085 * This function writes a PDF Pages Tree structure to output.
4086 */
4087
4088tsize_t t2p_write_pdf_pages(T2P* t2p, TIFF* output)
4089{
4090        tsize_t written=0;
4091        tdir_t i=0;
4092        char buffer[16];
4093        int buflen=0;
4094
4095        int page=0;
4096        written += t2pWriteFile(output,
4097                (tdata_t) "<< \n/Type /Pages \n/Kids [ ", 26);
4098        page = t2p->pdf_pages+1;
4099        for (i=0;i<t2p->tiff_pagecount;i++){
4100                buflen=sprintf(buffer, "%d", page);
4101                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4102                written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4103                if ( ((i+1)%8)==0 ) {
4104                        written += t2pWriteFile(output, (tdata_t) "\n", 1);
4105                }
4106                page +=3;
4107                page += t2p->tiff_pages[i].page_extra;
4108                if(t2p->tiff_pages[i].page_tilecount>0){
4109                        page += (2 * t2p->tiff_pages[i].page_tilecount);
4110                } else {
4111                        page +=2;
4112                }
4113        }
4114        written += t2pWriteFile(output, (tdata_t) "] \n/Count ", 10);
4115        _TIFFmemset(buffer, 0x00, 16);
4116        buflen=sprintf(buffer, "%d", t2p->tiff_pagecount);
4117        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4118        written += t2pWriteFile(output, (tdata_t) " \n>> \n", 6);
4119
4120        return(written);
4121}
4122
4123/*
4124        This function writes a PDF Page structure to output.
4125*/
4126
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;
4133
4134        written += t2pWriteFile(output, (tdata_t) "<<\n/Type /Page \n/Parent ", 24);
4135        buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_pages);
4136        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4137        written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
4138        written += t2pWriteFile(output, (tdata_t) "/MediaBox [", 11);
4139        buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x1);
4140        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4141        written += t2pWriteFile(output, (tdata_t) " ", 1);
4142        buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y1);
4143        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4144        written += t2pWriteFile(output, (tdata_t) " ", 1);
4145        buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x2);
4146        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4147        written += t2pWriteFile(output, (tdata_t) " ", 1);
4148        buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y2);
4149        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4150        written += t2pWriteFile(output, (tdata_t) "] \n", 3);
4151        written += t2pWriteFile(output, (tdata_t) "/Contents ", 10);
4152        buflen=sprintf(buffer, "%lu", (unsigned long)(object + 1));
4153        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4154        written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
4155        written += t2pWriteFile(output, (tdata_t) "/Resources << \n", 15);
4156        if( t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount != 0 ){
4157                written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4158                for(i=0;i<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i++){
4159                        written += t2pWriteFile(output, (tdata_t) "/Im", 3);
4160                        buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
4161                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4162                        written += t2pWriteFile(output, (tdata_t) "_", 1);
4163                        buflen = sprintf(buffer, "%u", i+1);
4164                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4165                        written += t2pWriteFile(output, (tdata_t) " ", 1);
4166                        buflen = sprintf(
4167                                buffer,
4168                                "%lu",
4169                                (unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
4170                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4171                        written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4172                        if(i%4==3){
4173                                written += t2pWriteFile(output, (tdata_t) "\n", 1);
4174                        }
4175                }
4176                written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
4177        } else {
4178                        written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4179                        written += t2pWriteFile(output, (tdata_t) "/Im", 3);
4180                        buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
4181                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4182                        written += t2pWriteFile(output, (tdata_t) " ", 1);
4183                        buflen = sprintf(
4184                                buffer,
4185                                "%lu",
4186                                (unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
4187                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4188                        written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4189                written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
4190        }
4191        if(t2p->tiff_transferfunctioncount != 0) {
4192                written += t2pWriteFile(output, (tdata_t) "/ExtGState <<", 13);
4193                t2pWriteFile(output, (tdata_t) "/GS1 ", 5);
4194                buflen = sprintf(
4195                        buffer,
4196                        "%lu",
4197                        (unsigned long)(object + 3));
4198                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4199                written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4200                written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
4201        }
4202        written += t2pWriteFile(output, (tdata_t) "/ProcSet [ ", 11);
4203        if(t2p->pdf_colorspace == T2P_CS_BILEVEL
4204                || t2p->pdf_colorspace == T2P_CS_GRAY
4205                ){
4206                written += t2pWriteFile(output, (tdata_t) "/ImageB ", 8);
4207        } else {
4208                written += t2pWriteFile(output, (tdata_t) "/ImageC ", 8);
4209                if(t2p->pdf_colorspace & T2P_CS_PALETTE){
4210                        written += t2pWriteFile(output, (tdata_t) "/ImageI ", 8);
4211                }
4212        }
4213        written += t2pWriteFile(output, (tdata_t) "]\n>>\n>>\n", 8);
4214
4215        return(written);
4216}
4217
4218/*
4219        This function composes the page size and image and tile locations on a page.
4220*/
4221
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;
4234        float width_ratio=0;
4235        float length_ratio=0;
4236       
4237        t2p->pdf_xres = t2p->tiff_xres;
4238        t2p->pdf_yres = t2p->tiff_yres;
4239        if(t2p->pdf_overrideres) {
4240                t2p->pdf_xres = t2p->pdf_defaultxres;
4241                t2p->pdf_yres = t2p->pdf_defaultyres;
4242        }
4243        if(t2p->pdf_xres == 0.0)
4244                t2p->pdf_xres = t2p->pdf_defaultxres;
4245        if(t2p->pdf_yres == 0.0)
4246                t2p->pdf_yres = t2p->pdf_defaultyres;
4247        if (t2p->pdf_image_fillpage) {
4248                width_ratio = t2p->pdf_defaultpagewidth/t2p->tiff_width;
4249                length_ratio = t2p->pdf_defaultpagelength/t2p->tiff_length;
4250                if (width_ratio < length_ratio ) {
4251                        t2p->pdf_imagewidth = t2p->pdf_defaultpagewidth;
4252                        t2p->pdf_imagelength = t2p->tiff_length * width_ratio;
4253                } else {
4254                        t2p->pdf_imagewidth = t2p->tiff_width * length_ratio;
4255                        t2p->pdf_imagelength = t2p->pdf_defaultpagelength;
4256                }
4257        } else if (t2p->tiff_resunit != RESUNIT_CENTIMETER      /* RESUNIT_NONE and */
4258                && t2p->tiff_resunit != RESUNIT_INCH) { /* other cases */
4259                t2p->pdf_imagewidth = ((float)(t2p->tiff_width))/t2p->pdf_xres;
4260                t2p->pdf_imagelength = ((float)(t2p->tiff_length))/t2p->pdf_yres;
4261        } else {
4262                t2p->pdf_imagewidth =
4263                        ((float)(t2p->tiff_width))*PS_UNIT_SIZE/t2p->pdf_xres;
4264                t2p->pdf_imagelength =
4265                        ((float)(t2p->tiff_length))*PS_UNIT_SIZE/t2p->pdf_yres;
4266        }
4267        if(t2p->pdf_overridepagesize != 0) {
4268                t2p->pdf_pagewidth = t2p->pdf_defaultpagewidth;
4269                t2p->pdf_pagelength = t2p->pdf_defaultpagelength;
4270        } else {
4271                t2p->pdf_pagewidth = t2p->pdf_imagewidth;
4272                t2p->pdf_pagelength = t2p->pdf_imagelength;
4273        }
4274        t2p->pdf_mediabox.x1=0.0;
4275        t2p->pdf_mediabox.y1=0.0;
4276        t2p->pdf_mediabox.x2=t2p->pdf_pagewidth;
4277        t2p->pdf_mediabox.y2=t2p->pdf_pagelength;
4278        t2p->pdf_imagebox.x1=0.0;
4279        t2p->pdf_imagebox.y1=0.0;
4280        t2p->pdf_imagebox.x2=t2p->pdf_imagewidth;
4281        t2p->pdf_imagebox.y2=t2p->pdf_imagelength;
4282        if(t2p->pdf_overridepagesize!=0){
4283                t2p->pdf_imagebox.x1+=((t2p->pdf_pagewidth-t2p->pdf_imagewidth)/2.0F);
4284                t2p->pdf_imagebox.y1+=((t2p->pdf_pagelength-t2p->pdf_imagelength)/2.0F);
4285                t2p->pdf_imagebox.x2+=((t2p->pdf_pagewidth-t2p->pdf_imagewidth)/2.0F);
4286                t2p->pdf_imagebox.y2+=((t2p->pdf_pagelength-t2p->pdf_imagelength)/2.0F);
4287        }
4288        if(t2p->tiff_orientation > 4){
4289                f=t2p->pdf_mediabox.x2;
4290                t2p->pdf_mediabox.x2=t2p->pdf_mediabox.y2;
4291                t2p->pdf_mediabox.y2=f;
4292        }
4293        istiled=((t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount==0) ? 0 : 1;
4294        if(istiled==0){
4295                t2p_compose_pdf_page_orient(&(t2p->pdf_imagebox), t2p->tiff_orientation);
4296                return;
4297        } else {
4298                tilewidth=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilewidth;
4299                tilelength=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilelength;
4300                tilecountx=(t2p->tiff_width +
4301                        tilewidth -1)/
4302                        tilewidth;
4303                (t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecountx=tilecountx;
4304                tilecounty=(t2p->tiff_length +
4305                        tilelength -1)/
4306                        tilelength;
4307                (t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecounty=tilecounty;
4308                (t2p->tiff_tiles[t2p->pdf_page]).tiles_edgetilewidth=
4309                        t2p->tiff_width % tilewidth;
4310                (t2p->tiff_tiles[t2p->pdf_page]).tiles_edgetilelength=
4311                        t2p->tiff_length % tilelength;
4312                tiles=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tiles;
4313                for(i2=0;i2<tilecounty-1;i2++){
4314                        for(i=0;i<tilecountx-1;i++){
4315                                boxp=&(tiles[i2*tilecountx+i].tile_box);
4316                                boxp->x1 =
4317                                        t2p->pdf_imagebox.x1
4318                                        + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4319                                        / (float)t2p->tiff_width);
4320                                boxp->x2 =
4321                                        t2p->pdf_imagebox.x1
4322                                        + ((float)(t2p->pdf_imagewidth * (i+1) * tilewidth)
4323                                        / (float)t2p->tiff_width);
4324                                boxp->y1 =
4325                                        t2p->pdf_imagebox.y2
4326                                        - ((float)(t2p->pdf_imagelength * (i2+1) * tilelength)
4327                                        / (float)t2p->tiff_length);
4328                                boxp->y2 =
4329                                        t2p->pdf_imagebox.y2
4330                                        - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4331                                        / (float)t2p->tiff_length);
4332                        }
4333                        boxp=&(tiles[i2*tilecountx+i].tile_box);
4334                        boxp->x1 =
4335                                t2p->pdf_imagebox.x1
4336                                + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4337                                / (float)t2p->tiff_width);
4338                        boxp->x2 = t2p->pdf_imagebox.x2;
4339                        boxp->y1 =
4340                                t2p->pdf_imagebox.y2
4341                                - ((float)(t2p->pdf_imagelength * (i2+1) * tilelength)
4342                                / (float)t2p->tiff_length);
4343                        boxp->y2 =
4344                                t2p->pdf_imagebox.y2
4345                                - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4346                                / (float)t2p->tiff_length);
4347                }
4348                for(i=0;i<tilecountx-1;i++){
4349                        boxp=&(tiles[i2*tilecountx+i].tile_box);
4350                        boxp->x1 =
4351                                t2p->pdf_imagebox.x1
4352                                + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4353                                / (float)t2p->tiff_width);
4354                        boxp->x2 =
4355                                t2p->pdf_imagebox.x1
4356                                + ((float)(t2p->pdf_imagewidth * (i+1) * tilewidth)
4357                                / (float)t2p->tiff_width);
4358                        boxp->y1 = t2p->pdf_imagebox.y1;
4359                        boxp->y2 =
4360                                t2p->pdf_imagebox.y2
4361                                - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4362                                / (float)t2p->tiff_length);
4363                }
4364                boxp=&(tiles[i2*tilecountx+i].tile_box);
4365                boxp->x1 =
4366                        t2p->pdf_imagebox.x1
4367                        + ((float)(t2p->pdf_imagewidth * i * tilewidth)
4368                        / (float)t2p->tiff_width);
4369                boxp->x2 = t2p->pdf_imagebox.x2;
4370                boxp->y1 = t2p->pdf_imagebox.y1;
4371                boxp->y2 =
4372                        t2p->pdf_imagebox.y2
4373                        - ((float)(t2p->pdf_imagelength * i2 * tilelength)
4374                        / (float)t2p->tiff_length);
4375        }
4376        if(t2p->tiff_orientation==0 || t2p->tiff_orientation==1){
4377                for(i=0;i<(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount;i++){
4378                        t2p_compose_pdf_page_orient( &(tiles[i].tile_box) , 0);
4379                }
4380                return;
4381        }
4382        for(i=0;i<(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount;i++){
4383                boxp=&(tiles[i].tile_box);
4384                boxp->x1 -= t2p->pdf_imagebox.x1;
4385                boxp->x2 -= t2p->pdf_imagebox.x1;
4386                boxp->y1 -= t2p->pdf_imagebox.y1;
4387                boxp->y2 -= t2p->pdf_imagebox.y1;
4388                if(t2p->tiff_orientation==2 || t2p->tiff_orientation==3){
4389                        boxp->x1 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x1;
4390                        boxp->x2 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x2;
4391                }
4392                if(t2p->tiff_orientation==3 || t2p->tiff_orientation==4){
4393                        boxp->y1 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y1;
4394                        boxp->y2 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y2;
4395                }
4396                if(t2p->tiff_orientation==8 || t2p->tiff_orientation==5){
4397                        boxp->y1 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y1;
4398                        boxp->y2 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y2;
4399                }
4400                if(t2p->tiff_orientation==5 || t2p->tiff_orientation==6){
4401                        boxp->x1 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x1;
4402                        boxp->x2 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x2;
4403                }
4404                if(t2p->tiff_orientation > 4){
4405                        f=boxp->x1;
4406                        boxp->x1 = boxp->y1;
4407                        boxp->y1 = f;
4408                        f=boxp->x2;
4409                        boxp->x2 = boxp->y2;
4410                        boxp->y2 = f;
4411                        t2p_compose_pdf_page_orient_flip(boxp, t2p->tiff_orientation);
4412                } else {
4413                        t2p_compose_pdf_page_orient(boxp, t2p->tiff_orientation);
4414                }
4415               
4416        }
4417
4418        return;
4419}
4420
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,
4570                                "q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d_%ld Do Q\n",
4571                                t2p->tiff_transferfunctioncount?"/GS1 gs ":"",
4572                                box.mat[0],
4573                                box.mat[1],
4574                                box.mat[3],
4575                                box.mat[4],
4576                                box.mat[6],
4577                                box.mat[7],
4578                                t2p->pdf_page + 1,
4579                                (long)(i + 1));
4580                        written += t2p_write_pdf_stream(buffer, buflen, output);
4581                }
4582        } else {
4583                box=t2p->pdf_imagebox;
4584                buflen=sprintf(buffer,
4585                        "q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d Do Q\n",
4586                        t2p->tiff_transferfunctioncount?"/GS1 gs ":"",
4587                        box.mat[0],
4588                        box.mat[1],
4589                        box.mat[3],
4590                        box.mat[4],
4591                        box.mat[6],
4592                        box.mat[7],
4593                        t2p->pdf_page+1);
4594                written += t2p_write_pdf_stream(buffer, buflen, output);
4595        }
4596
4597        return(written);
4598}
4599
4600/*
4601        This function writes a PDF Image XObject stream dictionary to output.
4602*/
4603
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);
4613        written += t2pWriteFile(output,
4614                (tdata_t) "/Type /XObject \n/Subtype /Image \n/Name /Im",
4615                42);
4616        buflen=sprintf(buffer, "%u", t2p->pdf_page+1);
4617        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4618        if(tile != 0){
4619                written += t2pWriteFile(output, (tdata_t) "_", 1);
4620                buflen=sprintf(buffer, "%lu", (unsigned long)tile);
4621                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4622        }
4623        written += t2pWriteFile(output, (tdata_t) "\n/Width ", 8);
4624        _TIFFmemset((tdata_t)buffer, 0x00, 16);
4625        if(tile==0){
4626                buflen=sprintf(buffer, "%lu", (unsigned long)t2p->tiff_width);
4627        } else {
4628                if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)!=0){
4629                        buflen=sprintf(
4630                                buffer,
4631                                "%lu",
4632                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
4633                } else {
4634                        buflen=sprintf(
4635                                buffer,
4636                                "%lu",
4637                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
4638                }
4639        }
4640        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4641        written += t2pWriteFile(output, (tdata_t) "\n/Height ", 9);
4642        _TIFFmemset((tdata_t)buffer, 0x00, 16);
4643        if(tile==0){
4644                buflen=sprintf(buffer, "%lu", (unsigned long)t2p->tiff_length);
4645        } else {
4646                if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)!=0){
4647                        buflen=sprintf(
4648                                buffer,
4649                                "%lu",
4650                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
4651                } else {
4652                        buflen=sprintf(
4653                                buffer,
4654                                "%lu",
4655                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
4656                }
4657        }
4658        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4659        written += t2pWriteFile(output, (tdata_t) "\n/BitsPerComponent ", 19);
4660        _TIFFmemset((tdata_t)buffer, 0x00, 16);
4661        buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
4662        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4663        written += t2pWriteFile(output, (tdata_t) "\n/ColorSpace ", 13);
4664        written += t2p_write_pdf_xobject_cs(t2p, output);
4665        if (t2p->pdf_image_interpolate)
4666                written += t2pWriteFile(output,
4667                                         (tdata_t) "\n/Interpolate true", 18);
4668        if( (t2p->pdf_switchdecode != 0)
4669#ifdef CCITT_SUPPORT
4670                && ! (t2p->pdf_colorspace == T2P_CS_BILEVEL
4671                && t2p->pdf_compression == T2P_COMPRESS_G4)
4672#endif
4673                ){
4674                written += t2p_write_pdf_xobject_decode(t2p, output);
4675        }
4676        written += t2p_write_pdf_xobject_stream_filter(tile, t2p, output);
4677       
4678        return(written);
4679}
4680
4681/*
4682 *      This function writes a PDF Image XObject Colorspace name to output.
4683 */
4684
4685
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){
4701                written += t2pWriteFile(output, (tdata_t) "[ /Indexed ", 11);
4702                t2p->pdf_colorspace ^= T2P_CS_PALETTE;
4703                written += t2p_write_pdf_xobject_cs(t2p, output);
4704                t2p->pdf_colorspace |= T2P_CS_PALETTE;
4705                buflen=sprintf(buffer, "%u", (0x0001 << t2p->tiff_bitspersample)-1 );
4706                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4707                written += t2pWriteFile(output, (tdata_t) " ", 1);
4708                _TIFFmemset(buffer, 0x00, 16);
4709                buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_palettecs );
4710                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4711                written += t2pWriteFile(output, (tdata_t) " 0 R ]\n", 7);
4712                return(written);
4713        }
4714        if(t2p->pdf_colorspace & T2P_CS_BILEVEL){
4715                        written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
4716        }
4717        if(t2p->pdf_colorspace & T2P_CS_GRAY){
4718                        if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4719                                written += t2p_write_pdf_xobject_calcs(t2p, output);
4720                        } else {
4721                                written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
4722                        }
4723        }
4724        if(t2p->pdf_colorspace & T2P_CS_RGB){
4725                        if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4726                                written += t2p_write_pdf_xobject_calcs(t2p, output);
4727                        } else {
4728                                written += t2pWriteFile(output, (tdata_t) "/DeviceRGB \n", 12);
4729                        }
4730        }
4731        if(t2p->pdf_colorspace & T2P_CS_CMYK){
4732                        written += t2pWriteFile(output, (tdata_t) "/DeviceCMYK \n", 13);
4733        }
4734        if(t2p->pdf_colorspace & T2P_CS_LAB){
4735                        written += t2pWriteFile(output, (tdata_t) "[/Lab << \n", 10);
4736                        written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4737                        X_W = t2p->tiff_whitechromaticities[0];
4738                        Y_W = t2p->tiff_whitechromaticities[1];
4739                        Z_W = 1.0F - (X_W + Y_W);
4740                        X_W /= Y_W;
4741                        Z_W /= Y_W;
4742                        Y_W = 1.0F;
4743                        buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4744                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4745                        written += t2pWriteFile(output, (tdata_t) "/Range ", 7);
4746                        buflen=sprintf(buffer, "[%d %d %d %d] \n",
4747                                t2p->pdf_labrange[0],
4748                                t2p->pdf_labrange[1],
4749                                t2p->pdf_labrange[2],
4750                                t2p->pdf_labrange[3]);
4751                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4752                        written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
4753                       
4754        }
4755       
4756        return(written);
4757}
4758
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
4765        written += t2pWriteFile(output, (tdata_t) "<< /Type /ExtGState \n/TR ", 25);
4766        if(t2p->tiff_transferfunctioncount == 1){
4767                buflen=sprintf(buffer, "%lu",
4768                               (unsigned long)(t2p->pdf_xrefcount + 1));
4769                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4770                written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4771        } else {
4772                written += t2pWriteFile(output, (tdata_t) "[ ", 2);
4773                buflen=sprintf(buffer, "%lu",
4774                               (unsigned long)(t2p->pdf_xrefcount + 1));
4775                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4776                written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4777                buflen=sprintf(buffer, "%lu",
4778                               (unsigned long)(t2p->pdf_xrefcount + 2));
4779                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4780                written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4781                buflen=sprintf(buffer, "%lu",
4782                               (unsigned long)(t2p->pdf_xrefcount + 3));
4783                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4784                written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4785                written += t2pWriteFile(output, (tdata_t) "/Identity ] ", 12);
4786        }
4787
4788        written += t2pWriteFile(output, (tdata_t) " >> \n", 5);
4789
4790        return(written);
4791}
4792
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;
4798        (void)i; /* XXX */
4799
4800        written += t2pWriteFile(output, (tdata_t) "/FunctionType 0 \n", 17);
4801        written += t2pWriteFile(output, (tdata_t) "/Domain [0.0 1.0] \n", 19);
4802        written += t2pWriteFile(output, (tdata_t) "/Range [0.0 1.0] \n", 18);
4803        buflen=sprintf(buffer, "/Size [%u] \n", (1<<t2p->tiff_bitspersample));
4804        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4805        written += t2pWriteFile(output, (tdata_t) "/BitsPerSample 16 \n", 19);
4806        written += t2p_write_pdf_stream_dict(((tsize_t)1)<<(t2p->tiff_bitspersample+1), 0, output);
4807
4808        return(written);
4809}
4810
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],
4817                (((tsize_t)1)<<(t2p->tiff_bitspersample+1)),
4818                output);
4819
4820        return(written);
4821}
4822
4823/*
4824        This function writes a PDF Image XObject Colorspace array to output.
4825*/
4826
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       
4858        written += t2pWriteFile(output, (tdata_t) "[", 1);
4859        if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4860                written += t2pWriteFile(output, (tdata_t) "/CalGray ", 9);
4861                X_W = t2p->tiff_whitechromaticities[0];
4862                Y_W = t2p->tiff_whitechromaticities[1];
4863                Z_W = 1.0F - (X_W + Y_W);
4864                X_W /= Y_W;
4865                Z_W /= Y_W;
4866                Y_W = 1.0F;
4867        }
4868        if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4869                written += t2pWriteFile(output, (tdata_t) "/CalRGB ", 8);
4870                x_w = t2p->tiff_whitechromaticities[0];
4871                y_w = t2p->tiff_whitechromaticities[1];
4872                x_r = t2p->tiff_primarychromaticities[0];
4873                y_r = t2p->tiff_primarychromaticities[1];
4874                x_g = t2p->tiff_primarychromaticities[2];
4875                y_g = t2p->tiff_primarychromaticities[3];
4876                x_b = t2p->tiff_primarychromaticities[4];
4877                y_b = t2p->tiff_primarychromaticities[5];
4878                z_w = y_w * ((x_g - x_b)*y_r - (x_r-x_b)*y_g + (x_r-x_g)*y_b);
4879                Y_R = (y_r/R) * ((x_g-x_b)*y_w - (x_w-x_b)*y_g + (x_w-x_g)*y_b) / z_w;
4880                X_R = Y_R * x_r / y_r;
4881                Z_R = Y_R * (((1-x_r)/y_r)-1);
4882                Y_G = ((0.0F-(y_g))/G) * ((x_r-x_b)*y_w - (x_w-x_b)*y_r + (x_w-x_r)*y_b) / z_w;
4883                X_G = Y_G * x_g / y_g;
4884                Z_G = Y_G * (((1-x_g)/y_g)-1);
4885                Y_B = (y_b/B) * ((x_r-x_g)*y_w - (x_w-x_g)*y_r + (x_w-x_r)*y_g) / z_w;
4886                X_B = Y_B * x_b / y_b;
4887                Z_B = Y_B * (((1-x_b)/y_b)-1);
4888                X_W = (X_R * R) + (X_G * G) + (X_B * B);
4889                Y_W = (Y_R * R) + (Y_G * G) + (Y_B * B);
4890                Z_W = (Z_R * R) + (Z_G * G) + (Z_B * B);
4891                X_W /= Y_W;
4892                Z_W /= Y_W;
4893                Y_W = 1.0;
4894        }
4895        written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
4896        if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4897                written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4898                buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4899                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4900                written += t2pWriteFile(output, (tdata_t) "/Gamma 2.2 \n", 12);
4901        }
4902        if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4903                written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4904                buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4905                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4906                written += t2pWriteFile(output, (tdata_t) "/Matrix ", 8);
4907                buflen=sprintf(buffer, "[%.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f] \n",
4908                        X_R, Y_R, Z_R,
4909                        X_G, Y_G, Z_G,
4910                        X_B, Y_B, Z_B);
4911                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4912                written += t2pWriteFile(output, (tdata_t) "/Gamma [2.2 2.2 2.2] \n", 22);
4913        }
4914        written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
4915
4916        return(written);
4917}
4918
4919/*
4920        This function writes a PDF Image XObject Colorspace array to output.
4921*/
4922
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       
4929        written += t2pWriteFile(output, (tdata_t) "[/ICCBased ", 11);
4930        buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_icccs);
4931        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4932        written += t2pWriteFile(output, (tdata_t) " 0 R] \n", 7);
4933
4934        return(written);
4935}
4936
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       
4943        written += t2pWriteFile(output, (tdata_t) "/N ", 3);
4944        buflen=sprintf(buffer, "%u \n", t2p->tiff_samplesperpixel);
4945        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4946        written += t2pWriteFile(output, (tdata_t) "/Alternate ", 11);
4947        t2p->pdf_colorspace ^= T2P_CS_ICCBASED;
4948        written += t2p_write_pdf_xobject_cs(t2p, output);
4949        t2p->pdf_colorspace |= T2P_CS_ICCBASED;
4950        written += t2p_write_pdf_stream_dict(t2p->tiff_iccprofilelength, 0, output);
4951       
4952        return(written);
4953}
4954
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
4992        written += t2pWriteFile(output, (tdata_t) "/Decode [ ", 10);
4993        for (i=0;i<t2p->tiff_samplesperpixel;i++){
4994                written += t2pWriteFile(output, (tdata_t) "1 0 ", 4);
4995        }
4996        written += t2pWriteFile(output, (tdata_t) "]\n", 2);
4997
4998        return(written);
4999}
5000
5001/*
5002        This function writes a PDF Image XObject stream filter name and parameters to
5003        output.
5004*/
5005
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        }
5015        written += t2pWriteFile(output, (tdata_t) "/Filter ", 8);
5016        switch(t2p->pdf_compression){
5017#ifdef CCITT_SUPPORT
5018                case T2P_COMPRESS_G4:
5019                        written += t2pWriteFile(output, (tdata_t) "/CCITTFaxDecode ", 16);
5020                        written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5021                        written += t2pWriteFile(output, (tdata_t) "<< /K -1 ", 9);
5022                        if(tile==0){
5023                                written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5024                                buflen=sprintf(buffer, "%lu",
5025                                               (unsigned long)t2p->tiff_width);
5026                                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5027                                written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5028                                buflen=sprintf(buffer, "%lu",
5029                                               (unsigned long)t2p->tiff_length);
5030                                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5031                        } else {
5032                                if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
5033                                        written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5034                                        buflen=sprintf(
5035                                                buffer,
5036                                                "%lu",
5037                                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
5038                                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5039                                } else {
5040                                        written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5041                                        buflen=sprintf(
5042                                                buffer,
5043                                                "%lu",
5044                                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
5045                                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5046                                }
5047                                if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
5048                                        written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5049                                        buflen=sprintf(
5050                                                buffer,
5051                                                "%lu",
5052                                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
5053                                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5054                                } else {
5055                                        written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5056                                        buflen=sprintf(
5057                                                buffer,
5058                                                "%lu",
5059                                                (unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
5060                                        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5061                                }
5062                        }
5063                        if(t2p->pdf_switchdecode == 0){
5064                                written += t2pWriteFile(output, (tdata_t) " /BlackIs1 true ", 16);
5065                        }
5066                        written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
5067                        break;
5068#endif
5069#ifdef JPEG_SUPPORT
5070                case T2P_COMPRESS_JPEG:
5071                        written += t2pWriteFile(output, (tdata_t) "/DCTDecode ", 11);
5072
5073                        if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR) {
5074                                written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5075                                written += t2pWriteFile(output, (tdata_t) "<< /ColorTransform 0 >>\n", 24);
5076                        }
5077                        break;
5078#endif
5079#ifdef ZIP_SUPPORT
5080                case T2P_COMPRESS_ZIP:
5081                        written += t2pWriteFile(output, (tdata_t) "/FlateDecode ", 13);
5082                        if(t2p->pdf_compressionquality%100){
5083                                written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5084                                written += t2pWriteFile(output, (tdata_t) "<< /Predictor ", 14);
5085                                _TIFFmemset(buffer, 0x00, 16);
5086                                buflen=sprintf(buffer, "%u", t2p->pdf_compressionquality%100);
5087                                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5088                                written += t2pWriteFile(output, (tdata_t) " /Columns ", 10);
5089                                _TIFFmemset(buffer, 0x00, 16);
5090                                buflen = sprintf(buffer, "%lu",
5091                                                 (unsigned long)t2p->tiff_width);
5092                                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5093                                written += t2pWriteFile(output, (tdata_t) " /Colors ", 9);
5094                                _TIFFmemset(buffer, 0x00, 16);
5095                                buflen=sprintf(buffer, "%u", t2p->tiff_samplesperpixel);
5096                                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5097                                written += t2pWriteFile(output, (tdata_t) " /BitsPerComponent ", 19);
5098                                _TIFFmemset(buffer, 0x00, 16);
5099                                buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
5100                                written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5101                                written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
5102                        }
5103                        break;
5104#endif
5105                default:
5106                        break;
5107        }
5108
5109        return(written);
5110}
5111
5112/*
5113        This function writes a PDF xref table to output.
5114*/
5115
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
5123        written += t2pWriteFile(output, (tdata_t) "xref\n0 ", 7);
5124        buflen=sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount + 1));
5125        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5126        written += t2pWriteFile(output, (tdata_t) " \n0000000000 65535 f \n", 22);
5127        for (i=0;i<t2p->pdf_xrefcount;i++){
5128                sprintf(buffer, "%.10lu 00000 n \n",
5129                        (unsigned long)t2p->pdf_xrefoffsets[i]);
5130                written += t2pWriteFile(output, (tdata_t) buffer, 20);
5131        }
5132
5133        return(written);
5134}
5135
5136/*
5137 * This function writes a PDF trailer to output.
5138 */
5139
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;
5146        size_t i = 0;
5147
5148        for (i = 0; i < sizeof(t2p->pdf_fileid) - 8; i += 8)
5149                snprintf(t2p->pdf_fileid + i, 9, "%.8X", rand());
5150
5151        written += t2pWriteFile(output, (tdata_t) "trailer\n<<\n/Size ", 17);
5152        buflen = sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount+1));
5153        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5154        _TIFFmemset(buffer, 0x00, 32); 
5155        written += t2pWriteFile(output, (tdata_t) "\n/Root ", 7);
5156        buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_catalog);
5157        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5158        _TIFFmemset(buffer, 0x00, 32); 
5159        written += t2pWriteFile(output, (tdata_t) " 0 R \n/Info ", 12);
5160        buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_info);
5161        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5162        _TIFFmemset(buffer, 0x00, 32); 
5163        written += t2pWriteFile(output, (tdata_t) " 0 R \n/ID[<", 11);
5164        written += t2pWriteFile(output, (tdata_t) t2p->pdf_fileid,
5165                                sizeof(t2p->pdf_fileid) - 1);
5166        written += t2pWriteFile(output, (tdata_t) "><", 2);
5167        written += t2pWriteFile(output, (tdata_t) t2p->pdf_fileid,
5168                                sizeof(t2p->pdf_fileid) - 1);
5169        written += t2pWriteFile(output, (tdata_t) ">]\n>>\nstartxref\n", 16);
5170        buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_startxref);
5171        written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5172        _TIFFmemset(buffer, 0x00, 32); 
5173        written += t2pWriteFile(output, (tdata_t) "\n%%EOF\n", 7);
5174
5175        return(written);
5176}
5177 
5178/*
5179
5180  This function writes a PDF to a file given a pointer to a TIFF.
5181
5182  The idea with using a TIFF* as output for a PDF file is that the file
5183  can be created with TIFFClientOpen for memory-mapped use within the TIFF
5184  library, and TIFFWriteEncodedStrip can be used to write compressed data to
5185  the output.  The output is not actually a TIFF file, it is a PDF file. 
5186
5187  This function uses only t2pWriteFile and TIFFWriteEncodedStrip to write to
5188  the output TIFF file.  When libtiff would otherwise be writing data to the
5189  output file, the write procedure of the TIFF structure is replaced with an
5190  empty implementation.
5191
5192  The first argument to the function is an initialized and validated T2P
5193  context struct pointer.
5194
5195  The second argument to the function is the TIFF* that is the input that has
5196  been opened for reading and no other functions have been called upon it.
5197
5198  The third argument to the function is the TIFF* that is the output that has
5199  been opened for writing.  It has to be opened so that it hasn't written any
5200  data to the output.  If the output is seekable then it's OK to seek to the
5201  beginning of the file.  The function only writes to the output PDF and does
5202  not seek.  See the example usage in the main() function.
5203
5204        TIFF* output = TIFFOpen("output.pdf", "w");
5205        assert(output != NULL);
5206
5207        if(output->tif_seekproc != NULL){
5208                t2pSeekFile(output, (toff_t) 0, SEEK_SET);
5209        }
5210
5211  This function returns the file size of the output PDF file.  On error it
5212  returns zero and the t2p->t2p_error variable is set to T2P_ERR_ERROR.
5213
5214  After this function completes, call t2p_free on t2p, TIFFClose on input,
5215  and TIFFClose on output.
5216*/
5217
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,
5231                        "Can't allocate %u bytes of memory for t2p_write_pdf",
5232                        (unsigned int) (t2p->pdf_xrefcount * sizeof(uint32)) );
5233                t2p->t2p_error = T2P_ERR_ERROR;
5234                return(written);
5235        }
5236        t2p->pdf_xrefcount=0;
5237        t2p->pdf_catalog=1;
5238        t2p->pdf_info=2;
5239        t2p->pdf_pages=3;
5240        written += t2p_write_pdf_header(t2p, output);
5241        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5242        t2p->pdf_catalog=t2p->pdf_xrefcount;
5243        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5244        written += t2p_write_pdf_catalog(t2p, output);
5245        written += t2p_write_pdf_obj_end(output);
5246        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5247        t2p->pdf_info=t2p->pdf_xrefcount;
5248        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5249        written += t2p_write_pdf_info(t2p, input, output);
5250        written += t2p_write_pdf_obj_end(output);
5251        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5252        t2p->pdf_pages=t2p->pdf_xrefcount;
5253        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5254        written += t2p_write_pdf_pages(t2p, output);
5255        written += t2p_write_pdf_obj_end(output);
5256        for(t2p->pdf_page=0;t2p->pdf_page<t2p->tiff_pagecount;t2p->pdf_page++){
5257                t2p_read_tiff_data(t2p, input);
5258                if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5259                t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5260                written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5261                written += t2p_write_pdf_page(t2p->pdf_xrefcount, t2p, output);
5262                written += t2p_write_pdf_obj_end(output);
5263                t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5264                written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5265                written += t2p_write_pdf_stream_dict_start(output);
5266                written += t2p_write_pdf_stream_dict(0, t2p->pdf_xrefcount+1, output);
5267                written += t2p_write_pdf_stream_dict_end(output);
5268                written += t2p_write_pdf_stream_start(output);
5269                streamlen=written;
5270                written += t2p_write_pdf_page_content_stream(t2p, output);
5271                streamlen=written-streamlen;
5272                written += t2p_write_pdf_stream_end(output);
5273                written += t2p_write_pdf_obj_end(output);
5274                t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5275                written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5276                written += t2p_write_pdf_stream_length(streamlen, output);
5277                written += t2p_write_pdf_obj_end(output);
5278                if(t2p->tiff_transferfunctioncount != 0){
5279                        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5280                        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5281                        written += t2p_write_pdf_transfer(t2p, output);
5282                        written += t2p_write_pdf_obj_end(output);
5283                        for(i=0; i < t2p->tiff_transferfunctioncount; i++){
5284                                t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5285                                written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5286                                written += t2p_write_pdf_stream_dict_start(output);
5287                                written += t2p_write_pdf_transfer_dict(t2p, output, i);
5288                                written += t2p_write_pdf_stream_dict_end(output);
5289                                written += t2p_write_pdf_stream_start(output);
5290                                streamlen=written;
5291                                written += t2p_write_pdf_transfer_stream(t2p, output, i);
5292                                streamlen=written-streamlen;
5293                                written += t2p_write_pdf_stream_end(output);
5294                                written += t2p_write_pdf_obj_end(output);
5295                        }
5296                }
5297                if( (t2p->pdf_colorspace & T2P_CS_PALETTE) != 0){
5298                        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5299                        t2p->pdf_palettecs=t2p->pdf_xrefcount;
5300                        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5301                        written += t2p_write_pdf_stream_dict_start(output);
5302                        written += t2p_write_pdf_stream_dict(t2p->pdf_palettesize, 0, output);
5303                        written += t2p_write_pdf_stream_dict_end(output);
5304                        written += t2p_write_pdf_stream_start(output);
5305                        streamlen=written;
5306                        written += t2p_write_pdf_xobject_palettecs_stream(t2p, output);
5307                        streamlen=written-streamlen;
5308                        written += t2p_write_pdf_stream_end(output);
5309                        written += t2p_write_pdf_obj_end(output);
5310                }
5311                if( (t2p->pdf_colorspace & T2P_CS_ICCBASED) != 0){
5312                        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5313                        t2p->pdf_icccs=t2p->pdf_xrefcount;
5314                        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5315                        written += t2p_write_pdf_stream_dict_start(output);
5316                        written += t2p_write_pdf_xobject_icccs_dict(t2p, output);
5317                        written += t2p_write_pdf_stream_dict_end(output);
5318                        written += t2p_write_pdf_stream_start(output);
5319                        streamlen=written;
5320                        written += t2p_write_pdf_xobject_icccs_stream(t2p, output);
5321                        streamlen=written-streamlen;
5322                        written += t2p_write_pdf_stream_end(output);
5323                        written += t2p_write_pdf_obj_end(output);
5324                }
5325                if(t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount !=0){
5326                        for(i2=0;i2<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i2++){
5327                                t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5328                                written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5329                                written += t2p_write_pdf_stream_dict_start(output);
5330                                written += t2p_write_pdf_xobject_stream_dict(
5331                                        i2+1,
5332                                        t2p,
5333                                        output);
5334                                written += t2p_write_pdf_stream_dict_end(output);
5335                                written += t2p_write_pdf_stream_start(output);
5336                                streamlen=written;
5337                                t2p_read_tiff_size_tile(t2p, input, i2);
5338                                written += t2p_readwrite_pdf_image_tile(t2p, input, output, i2);
5339                                t2p_write_advance_directory(t2p, output);
5340                                if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5341                                streamlen=written-streamlen;
5342                                written += t2p_write_pdf_stream_end(output);
5343                                written += t2p_write_pdf_obj_end(output);
5344                                t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5345                                written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5346                                written += t2p_write_pdf_stream_length(streamlen, output);
5347                                written += t2p_write_pdf_obj_end(output);
5348                        }
5349                } else {
5350                        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5351                        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5352                        written += t2p_write_pdf_stream_dict_start(output);
5353                        written += t2p_write_pdf_xobject_stream_dict(
5354                                0,
5355                                t2p,
5356                                output);
5357                        written += t2p_write_pdf_stream_dict_end(output);
5358                        written += t2p_write_pdf_stream_start(output);
5359                        streamlen=written;
5360                        t2p_read_tiff_size(t2p, input);
5361                        written += t2p_readwrite_pdf_image(t2p, input, output);
5362                        t2p_write_advance_directory(t2p, output);
5363                        if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5364                        streamlen=written-streamlen;
5365                        written += t2p_write_pdf_stream_end(output);
5366                        written += t2p_write_pdf_obj_end(output);
5367                        t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5368                        written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5369                        written += t2p_write_pdf_stream_length(streamlen, output);
5370                        written += t2p_write_pdf_obj_end(output);
5371                }
5372        }
5373        t2p->pdf_startxref = written;
5374        written += t2p_write_pdf_xreftable(t2p, output);
5375        written += t2p_write_pdf_trailer(t2p, output);
5376        t2p_disable(output);
5377
5378        return(written);
5379}
5380
5381/* vim: set ts=8 sts=8 sw=8 noet: */
5382/*
5383 * Local Variables:
5384 * mode: c
5385 * c-basic-offset: 8
5386 * fill-column: 78
5387 * End:
5388 */
Note: See TracBrowser for help on using the repository browser.