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