~ubuntu-branches/ubuntu/vivid/tiff/vivid-proposed
» Revision
34
: .pc/CVE-2013-1960.patch/tools/tiff2pdf.c
« back to all changes in this revision
Viewing changes to .pc/CVE-2013-1960.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-1960.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
uint16 ri =0;
3344
uint16 v_samp=1;
3345
uint16 h_samp=1;
3346
int j=0;
3347
3348
i++;
3349
3350
while(i<(*striplength)){
3351
switch( strip[i] ){
3352
case 0xd8:
3353
/* SOI - start of image */
3354
_TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), 2);
3355
*bufferoffset+=2;
3356
i+=2;
3357
break;
3358
case 0xc0:
3359
case 0xc1:
3360
case 0xc3:
3361
case 0xc9:
3362
case 0xca:
3363
if(no==0){
3364
_TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3365
for(j=0;j<buffer[*bufferoffset+9];j++){
3366
if( (buffer[*bufferoffset+11+(2*j)]>>4) > h_samp)
3367
h_samp = (buffer[*bufferoffset+11+(2*j)]>>4);
3368
if( (buffer[*bufferoffset+11+(2*j)] & 0x0f) > v_samp)
3369
v_samp = (buffer[*bufferoffset+11+(2*j)] & 0x0f);
3370
}
3371
v_samp*=8;
3372
h_samp*=8;
3373
ri=((( ((uint16)(buffer[*bufferoffset+5])<<8) |
3374
(uint16)(buffer[*bufferoffset+6]) )+v_samp-1)/
3375
v_samp);
3376
ri*=((( ((uint16)(buffer[*bufferoffset+7])<<8) |
3377
(uint16)(buffer[*bufferoffset+8]) )+h_samp-1)/
3378
h_samp);
3379
buffer[*bufferoffset+5]=
3380
(unsigned char) ((height>>8) & 0xff);
3381
buffer[*bufferoffset+6]=
3382
(unsigned char) (height & 0xff);
3383
*bufferoffset+=strip[i+2]+2;
3384
i+=strip[i+2]+2;
3385
3386
buffer[(*bufferoffset)++]=0xff;
3387
buffer[(*bufferoffset)++]=0xdd;
3388
buffer[(*bufferoffset)++]=0x00;
3389
buffer[(*bufferoffset)++]=0x04;
3390
buffer[(*bufferoffset)++]=(ri >> 8) & 0xff;
3391
buffer[(*bufferoffset)++]= ri & 0xff;
3392
} else {
3393
i+=strip[i+2]+2;
3394
}
3395
break;
3396
case 0xc4:
3397
case 0xdb:
3398
_TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3399
*bufferoffset+=strip[i+2]+2;
3400
i+=strip[i+2]+2;
3401
break;
3402
case 0xda:
3403
if(no==0){
3404
_TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), strip[i+2]+2);
3405
*bufferoffset+=strip[i+2]+2;
3406
i+=strip[i+2]+2;
3407
} else {
3408
buffer[(*bufferoffset)++]=0xff;
3409
buffer[(*bufferoffset)++]=
3410
(unsigned char)(0xd0 | ((no-1)%8));
3411
i+=strip[i+2]+2;
3412
}
3413
_TIFFmemcpy(&(buffer[*bufferoffset]), &(strip[i-1]), (*striplength)-i-1);
3414
*bufferoffset+=(*striplength)-i-1;
3415
return(1);
3416
default:
3417
i+=strip[i+2]+2;
3418
}
3419
}
3420
3421
3422
return(0);
3423
}
3424
#endif
3425
3426
/*
3427
This functions converts a tilewidth x tilelength buffer of samples into an edgetilewidth x
3428
tilelength buffer of samples.
3429
*/
3430
void t2p_tile_collapse_left(
3431
tdata_t buffer,
3432
tsize_t scanwidth,
3433
uint32 tilewidth,
3434
uint32 edgetilewidth,
3435
uint32 tilelength){
3436
3437
uint32 i;
3438
tsize_t edgescanwidth=0;
3439
3440
edgescanwidth = (scanwidth * edgetilewidth + (tilewidth - 1))/ tilewidth;
3441
for(i=0;i<tilelength;i++){
3442
_TIFFmemcpy(
3443
&(((char*)buffer)[edgescanwidth*i]),
3444
&(((char*)buffer)[scanwidth*i]),
3445
edgescanwidth);
3446
}
3447
3448
return;
3449
}
3450
3451
3452
/*
3453
* This function calls TIFFWriteDirectory on the output after blanking its
3454
* output by replacing the read, write, and seek procedures with empty
3455
* implementations, then it replaces the original implementations.
3456
*/
3457
3458
void
3459
t2p_write_advance_directory(T2P* t2p, TIFF* output)
3460
{
3461
t2p_disable(output);
3462
if(!TIFFWriteDirectory(output)){
3463
TIFFError(TIFF2PDF_MODULE,
3464
"Error writing virtual directory to output PDF %s",
3465
TIFFFileName(output));
3466
t2p->t2p_error = T2P_ERR_ERROR;
3467
return;
3468
}
3469
t2p_enable(output);
3470
return;
3471
}
3472
3473
tsize_t t2p_sample_planar_separate_to_contig(
3474
T2P* t2p,
3475
unsigned char* buffer,
3476
unsigned char* samplebuffer,
3477
tsize_t samplebuffersize){
3478
3479
tsize_t stride=0;
3480
tsize_t i=0;
3481
tsize_t j=0;
3482
3483
stride=samplebuffersize/t2p->tiff_samplesperpixel;
3484
for(i=0;i<stride;i++){
3485
for(j=0;j<t2p->tiff_samplesperpixel;j++){
3486
buffer[i*t2p->tiff_samplesperpixel + j] = samplebuffer[i + j*stride];
3487
}
3488
}
3489
3490
return(samplebuffersize);
3491
}
3492
3493
tsize_t t2p_sample_realize_palette(T2P* t2p, unsigned char* buffer){
3494
3495
uint32 sample_count=0;
3496
uint16 component_count=0;
3497
uint32 palette_offset=0;
3498
uint32 sample_offset=0;
3499
uint32 i=0;
3500
uint32 j=0;
3501
sample_count=t2p->tiff_width*t2p->tiff_length;
3502
component_count=t2p->tiff_samplesperpixel;
3503
3504
for(i=sample_count;i>0;i--){
3505
palette_offset=buffer[i-1] * component_count;
3506
sample_offset= (i-1) * component_count;
3507
for(j=0;j<component_count;j++){
3508
buffer[sample_offset+j]=t2p->pdf_palette[palette_offset+j];
3509
}
3510
}
3511
3512
return(0);
3513
}
3514
3515
/*
3516
This functions converts in place a buffer of ABGR interleaved data
3517
into RGB interleaved data, discarding A.
3518
*/
3519
3520
tsize_t t2p_sample_abgr_to_rgb(tdata_t data, uint32 samplecount)
3521
{
3522
uint32 i=0;
3523
uint32 sample=0;
3524
3525
for(i=0;i<samplecount;i++){
3526
sample=((uint32*)data)[i];
3527
((char*)data)[i*3]= (char) (sample & 0xff);
3528
((char*)data)[i*3+1]= (char) ((sample>>8) & 0xff);
3529
((char*)data)[i*3+2]= (char) ((sample>>16) & 0xff);
3530
}
3531
3532
return(i*3);
3533
}
3534
3535
/*
3536
* This functions converts in place a buffer of RGBA interleaved data
3537
* into RGB interleaved data, discarding A.
3538
*/
3539
3540
tsize_t
3541
t2p_sample_rgbaa_to_rgb(tdata_t data, uint32 samplecount)
3542
{
3543
uint32 i;
3544
3545
for(i = 0; i < samplecount; i++)
3546
memcpy((uint8*)data + i * 3, (uint8*)data + i * 4, 3);
3547
3548
return(i * 3);
3549
}
3550
3551
/*
3552
* This functions converts in place a buffer of RGBA interleaved data
3553
* into RGB interleaved data, adding 255-A to each component sample.
3554
*/
3555
3556
tsize_t
3557
t2p_sample_rgba_to_rgb(tdata_t data, uint32 samplecount)
3558
{
3559
uint32 i = 0;
3560
uint32 sample = 0;
3561
uint8 alpha = 0;
3562
3563
for (i = 0; i < samplecount; i++) {
3564
sample=((uint32*)data)[i];
3565
alpha=(uint8)((255 - ((sample >> 24) & 0xff)));
3566
((uint8 *)data)[i * 3] = (uint8) ((sample >> 16) & 0xff) + alpha;
3567
((uint8 *)data)[i * 3 + 1] = (uint8) ((sample >> 8) & 0xff) + alpha;
3568
((uint8 *)data)[i * 3 + 2] = (uint8) (sample & 0xff) + alpha;
3569
}
3570
3571
return (i * 3);
3572
}
3573
3574
/*
3575
This function converts the a and b samples of Lab data from signed
3576
to unsigned.
3577
*/
3578
3579
tsize_t t2p_sample_lab_signed_to_unsigned(tdata_t buffer, uint32 samplecount){
3580
3581
uint32 i=0;
3582
3583
for(i=0;i<samplecount;i++){
3584
if( (((unsigned char*)buffer)[(i*3)+1] & 0x80) !=0){
3585
((unsigned char*)buffer)[(i*3)+1] =
3586
(unsigned char)(0x80 + ((char*)buffer)[(i*3)+1]);
3587
} else {
3588
((unsigned char*)buffer)[(i*3)+1] |= 0x80;
3589
}
3590
if( (((unsigned char*)buffer)[(i*3)+2] & 0x80) !=0){
3591
((unsigned char*)buffer)[(i*3)+2] =
3592
(unsigned char)(0x80 + ((char*)buffer)[(i*3)+2]);
3593
} else {
3594
((unsigned char*)buffer)[(i*3)+2] |= 0x80;
3595
}
3596
}
3597
3598
return(samplecount*3);
3599
}
3600
3601
/*
3602
This function writes the PDF header to output.
3603
*/
3604
3605
tsize_t t2p_write_pdf_header(T2P* t2p, TIFF* output){
3606
3607
tsize_t written=0;
3608
char buffer[16];
3609
int buflen=0;
3610
3611
buflen=sprintf(buffer, "%%PDF-%u.%u ", t2p->pdf_majorversion&0xff, t2p->pdf_minorversion&0xff);
3612
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3613
written += t2pWriteFile(output, (tdata_t)"\n%\342\343\317\323\n", 7);
3614
3615
return(written);
3616
}
3617
3618
/*
3619
This function writes the beginning of a PDF object to output.
3620
*/
3621
3622
tsize_t t2p_write_pdf_obj_start(uint32 number, TIFF* output){
3623
3624
tsize_t written=0;
3625
char buffer[16];
3626
int buflen=0;
3627
3628
buflen=sprintf(buffer, "%lu", (unsigned long)number);
3629
written += t2pWriteFile(output, (tdata_t) buffer, buflen );
3630
written += t2pWriteFile(output, (tdata_t) " 0 obj\n", 7);
3631
3632
return(written);
3633
}
3634
3635
/*
3636
This function writes the end of a PDF object to output.
3637
*/
3638
3639
tsize_t t2p_write_pdf_obj_end(TIFF* output){
3640
3641
tsize_t written=0;
3642
3643
written += t2pWriteFile(output, (tdata_t) "endobj\n", 7);
3644
3645
return(written);
3646
}
3647
3648
/*
3649
This function writes a PDF name object to output.
3650
*/
3651
3652
tsize_t t2p_write_pdf_name(unsigned char* name, TIFF* output){
3653
3654
tsize_t written=0;
3655
uint32 i=0;
3656
char buffer[64];
3657
uint16 nextchar=0;
3658
size_t namelen=0;
3659
3660
namelen = strlen((char *)name);
3661
if (namelen>126) {
3662
namelen=126;
3663
}
3664
written += t2pWriteFile(output, (tdata_t) "/", 1);
3665
for (i=0;i<namelen;i++){
3666
if ( ((unsigned char)name[i]) < 0x21){
3667
sprintf(buffer, "#%.2X", name[i]);
3668
buffer[sizeof(buffer) - 1] = '\0';
3669
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3670
nextchar=1;
3671
}
3672
if ( ((unsigned char)name[i]) > 0x7E){
3673
sprintf(buffer, "#%.2X", name[i]);
3674
buffer[sizeof(buffer) - 1] = '\0';
3675
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3676
nextchar=1;
3677
}
3678
if (nextchar==0){
3679
switch (name[i]){
3680
case 0x23:
3681
sprintf(buffer, "#%.2X", name[i]);
3682
buffer[sizeof(buffer) - 1] = '\0';
3683
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3684
break;
3685
case 0x25:
3686
sprintf(buffer, "#%.2X", name[i]);
3687
buffer[sizeof(buffer) - 1] = '\0';
3688
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3689
break;
3690
case 0x28:
3691
sprintf(buffer, "#%.2X", name[i]);
3692
buffer[sizeof(buffer) - 1] = '\0';
3693
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3694
break;
3695
case 0x29:
3696
sprintf(buffer, "#%.2X", name[i]);
3697
buffer[sizeof(buffer) - 1] = '\0';
3698
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3699
break;
3700
case 0x2F:
3701
sprintf(buffer, "#%.2X", name[i]);
3702
buffer[sizeof(buffer) - 1] = '\0';
3703
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3704
break;
3705
case 0x3C:
3706
sprintf(buffer, "#%.2X", name[i]);
3707
buffer[sizeof(buffer) - 1] = '\0';
3708
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3709
break;
3710
case 0x3E:
3711
sprintf(buffer, "#%.2X", name[i]);
3712
buffer[sizeof(buffer) - 1] = '\0';
3713
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3714
break;
3715
case 0x5B:
3716
sprintf(buffer, "#%.2X", name[i]);
3717
buffer[sizeof(buffer) - 1] = '\0';
3718
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3719
break;
3720
case 0x5D:
3721
sprintf(buffer, "#%.2X", name[i]);
3722
buffer[sizeof(buffer) - 1] = '\0';
3723
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3724
break;
3725
case 0x7B:
3726
sprintf(buffer, "#%.2X", name[i]);
3727
buffer[sizeof(buffer) - 1] = '\0';
3728
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3729
break;
3730
case 0x7D:
3731
sprintf(buffer, "#%.2X", name[i]);
3732
buffer[sizeof(buffer) - 1] = '\0';
3733
written += t2pWriteFile(output, (tdata_t) buffer, 3);
3734
break;
3735
default:
3736
written += t2pWriteFile(output, (tdata_t) &name[i], 1);
3737
}
3738
}
3739
nextchar=0;
3740
}
3741
written += t2pWriteFile(output, (tdata_t) " ", 1);
3742
3743
return(written);
3744
}
3745
3746
/*
3747
* This function writes a PDF string object to output.
3748
*/
3749
3750
tsize_t t2p_write_pdf_string(char* pdfstr, TIFF* output)
3751
{
3752
tsize_t written = 0;
3753
uint32 i = 0;
3754
char buffer[64];
3755
size_t len = 0;
3756
3757
len = strlen(pdfstr);
3758
written += t2pWriteFile(output, (tdata_t) "(", 1);
3759
for (i=0; i<len; i++) {
3760
if((pdfstr[i]&0x80) || (pdfstr[i]==127) || (pdfstr[i]<32)){
3761
snprintf(buffer, sizeof(buffer), "\\%.3o", ((unsigned char)pdfstr[i]));
3762
written += t2pWriteFile(output, (tdata_t)buffer, 4);
3763
} else {
3764
switch (pdfstr[i]){
3765
case 0x08:
3766
written += t2pWriteFile(output, (tdata_t) "\\b", 2);
3767
break;
3768
case 0x09:
3769
written += t2pWriteFile(output, (tdata_t) "\\t", 2);
3770
break;
3771
case 0x0A:
3772
written += t2pWriteFile(output, (tdata_t) "\\n", 2);
3773
break;
3774
case 0x0C:
3775
written += t2pWriteFile(output, (tdata_t) "\\f", 2);
3776
break;
3777
case 0x0D:
3778
written += t2pWriteFile(output, (tdata_t) "\\r", 2);
3779
break;
3780
case 0x28:
3781
written += t2pWriteFile(output, (tdata_t) "\\(", 2);
3782
break;
3783
case 0x29:
3784
written += t2pWriteFile(output, (tdata_t) "\\)", 2);
3785
break;
3786
case 0x5C:
3787
written += t2pWriteFile(output, (tdata_t) "\\\\", 2);
3788
break;
3789
default:
3790
written += t2pWriteFile(output, (tdata_t) &pdfstr[i], 1);
3791
}
3792
}
3793
}
3794
written += t2pWriteFile(output, (tdata_t) ") ", 1);
3795
3796
return(written);
3797
}
3798
3799
3800
/*
3801
This function writes a buffer of data to output.
3802
*/
3803
3804
tsize_t t2p_write_pdf_stream(tdata_t buffer, tsize_t len, TIFF* output){
3805
3806
tsize_t written=0;
3807
3808
written += t2pWriteFile(output, (tdata_t) buffer, len);
3809
3810
return(written);
3811
}
3812
3813
/*
3814
This functions writes the beginning of a PDF stream to output.
3815
*/
3816
3817
tsize_t t2p_write_pdf_stream_start(TIFF* output){
3818
3819
tsize_t written=0;
3820
3821
written += t2pWriteFile(output, (tdata_t) "stream\n", 7);
3822
3823
return(written);
3824
}
3825
3826
/*
3827
This function writes the end of a PDF stream to output.
3828
*/
3829
3830
tsize_t t2p_write_pdf_stream_end(TIFF* output){
3831
3832
tsize_t written=0;
3833
3834
written += t2pWriteFile(output, (tdata_t) "\nendstream\n", 11);
3835
3836
return(written);
3837
}
3838
3839
/*
3840
This function writes a stream dictionary for a PDF stream to output.
3841
*/
3842
3843
tsize_t t2p_write_pdf_stream_dict(tsize_t len, uint32 number, TIFF* output){
3844
3845
tsize_t written=0;
3846
char buffer[16];
3847
int buflen=0;
3848
3849
written += t2pWriteFile(output, (tdata_t) "/Length ", 8);
3850
if(len!=0){
3851
written += t2p_write_pdf_stream_length(len, output);
3852
} else {
3853
buflen=sprintf(buffer, "%lu", (unsigned long)number);
3854
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3855
written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
3856
}
3857
3858
return(written);
3859
}
3860
3861
/*
3862
This functions writes the beginning of a PDF stream dictionary to output.
3863
*/
3864
3865
tsize_t t2p_write_pdf_stream_dict_start(TIFF* output){
3866
3867
tsize_t written=0;
3868
3869
written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
3870
3871
return(written);
3872
}
3873
3874
/*
3875
This function writes the end of a PDF stream dictionary to output.
3876
*/
3877
3878
tsize_t t2p_write_pdf_stream_dict_end(TIFF* output){
3879
3880
tsize_t written=0;
3881
3882
written += t2pWriteFile(output, (tdata_t) " >>\n", 4);
3883
3884
return(written);
3885
}
3886
3887
/*
3888
This function writes a number to output.
3889
*/
3890
3891
tsize_t t2p_write_pdf_stream_length(tsize_t len, TIFF* output){
3892
3893
tsize_t written=0;
3894
char buffer[16];
3895
int buflen=0;
3896
3897
buflen=sprintf(buffer, "%lu", (unsigned long)len);
3898
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
3899
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3900
3901
return(written);
3902
}
3903
3904
/*
3905
* This function writes the PDF Catalog structure to output.
3906
*/
3907
3908
tsize_t t2p_write_pdf_catalog(T2P* t2p, TIFF* output)
3909
{
3910
tsize_t written = 0;
3911
char buffer[16];
3912
int buflen = 0;
3913
3914
written += t2pWriteFile(output,
3915
(tdata_t)"<< \n/Type /Catalog \n/Pages ",
3916
27);
3917
buflen = snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)t2p->pdf_pages);
3918
written += t2pWriteFile(output, (tdata_t) buffer,
3919
TIFFmin((size_t)buflen, sizeof(buffer) - 1));
3920
written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
3921
if(t2p->pdf_fitwindow){
3922
written += t2pWriteFile(output,
3923
(tdata_t) "/ViewerPreferences <</FitWindow true>>\n",
3924
39);
3925
}
3926
written += t2pWriteFile(output, (tdata_t)">>\n", 3);
3927
3928
return(written);
3929
}
3930
3931
/*
3932
This function writes the PDF Info structure to output.
3933
*/
3934
3935
tsize_t t2p_write_pdf_info(T2P* t2p, TIFF* input, TIFF* output)
3936
{
3937
tsize_t written = 0;
3938
char* info;
3939
char buffer[512];
3940
3941
if(t2p->pdf_datetime[0] == '\0')
3942
t2p_pdf_tifftime(t2p, input);
3943
if (strlen(t2p->pdf_datetime) > 0) {
3944
written += t2pWriteFile(output, (tdata_t) "<< \n/CreationDate ", 18);
3945
written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3946
written += t2pWriteFile(output, (tdata_t) "\n/ModDate ", 10);
3947
written += t2p_write_pdf_string(t2p->pdf_datetime, output);
3948
}
3949
written += t2pWriteFile(output, (tdata_t) "\n/Producer ", 11);
3950
_TIFFmemset((tdata_t)buffer, 0x00, sizeof(buffer));
3951
snprintf(buffer, sizeof(buffer), "libtiff / tiff2pdf - %d", TIFFLIB_VERSION);
3952
written += t2p_write_pdf_string(buffer, output);
3953
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3954
if (t2p->pdf_creator[0] != '\0') {
3955
written += t2pWriteFile(output, (tdata_t) "/Creator ", 9);
3956
written += t2p_write_pdf_string(t2p->pdf_creator, output);
3957
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3958
} else {
3959
if (TIFFGetField(input, TIFFTAG_SOFTWARE, &info) != 0 && info) {
3960
if(strlen(info) >= sizeof(t2p->pdf_creator))
3961
info[sizeof(t2p->pdf_creator) - 1] = '\0';
3962
written += t2pWriteFile(output, (tdata_t) "/Creator ", 9);
3963
written += t2p_write_pdf_string(info, output);
3964
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3965
}
3966
}
3967
if (t2p->pdf_author[0] != '\0') {
3968
written += t2pWriteFile(output, (tdata_t) "/Author ", 8);
3969
written += t2p_write_pdf_string(t2p->pdf_author, output);
3970
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3971
} else {
3972
if ((TIFFGetField(input, TIFFTAG_ARTIST, &info) != 0
3973
|| TIFFGetField(input, TIFFTAG_COPYRIGHT, &info) != 0)
3974
&& info) {
3975
if (strlen(info) >= sizeof(t2p->pdf_author))
3976
info[sizeof(t2p->pdf_author) - 1] = '\0';
3977
written += t2pWriteFile(output, (tdata_t) "/Author ", 8);
3978
written += t2p_write_pdf_string(info, output);
3979
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3980
}
3981
}
3982
if (t2p->pdf_title[0] != '\0') {
3983
written += t2pWriteFile(output, (tdata_t) "/Title ", 7);
3984
written += t2p_write_pdf_string(t2p->pdf_title, output);
3985
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3986
} else {
3987
if (TIFFGetField(input, TIFFTAG_DOCUMENTNAME, &info) != 0){
3988
if(strlen(info) > 511) {
3989
info[512] = '\0';
3990
}
3991
written += t2pWriteFile(output, (tdata_t) "/Title ", 7);
3992
written += t2p_write_pdf_string(info, output);
3993
written += t2pWriteFile(output, (tdata_t) "\n", 1);
3994
}
3995
}
3996
if (t2p->pdf_subject[0] != '\0') {
3997
written += t2pWriteFile(output, (tdata_t) "/Subject ", 9);
3998
written += t2p_write_pdf_string(t2p->pdf_subject, output);
3999
written += t2pWriteFile(output, (tdata_t) "\n", 1);
4000
} else {
4001
if (TIFFGetField(input, TIFFTAG_IMAGEDESCRIPTION, &info) != 0 && info) {
4002
if (strlen(info) >= sizeof(t2p->pdf_subject))
4003
info[sizeof(t2p->pdf_subject) - 1] = '\0';
4004
written += t2pWriteFile(output, (tdata_t) "/Subject ", 9);
4005
written += t2p_write_pdf_string(info, output);
4006
written += t2pWriteFile(output, (tdata_t) "\n", 1);
4007
}
4008
}
4009
if (t2p->pdf_keywords[0] != '\0') {
4010
written += t2pWriteFile(output, (tdata_t) "/Keywords ", 10);
4011
written += t2p_write_pdf_string(t2p->pdf_keywords, output);
4012
written += t2pWriteFile(output, (tdata_t) "\n", 1);
4013
}
4014
written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
4015
4016
return(written);
4017
}
4018
4019
/*
4020
* This function fills a string of a T2P struct with the current time as a PDF
4021
* date string, it is called by t2p_pdf_tifftime.
4022
*/
4023
4024
void t2p_pdf_currenttime(T2P* t2p)
4025
{
4026
struct tm* currenttime;
4027
time_t timenow;
4028
4029
if (time(&timenow) == (time_t) -1) {
4030
TIFFError(TIFF2PDF_MODULE,
4031
"Can't get the current time: %s", strerror(errno));
4032
timenow = (time_t) 0;
4033
}
4034
4035
currenttime = localtime(&timenow);
4036
snprintf(t2p->pdf_datetime, sizeof(t2p->pdf_datetime),
4037
"D:%.4d%.2d%.2d%.2d%.2d%.2d",
4038
(currenttime->tm_year + 1900) % 65536,
4039
(currenttime->tm_mon + 1) % 256,
4040
(currenttime->tm_mday) % 256,
4041
(currenttime->tm_hour) % 256,
4042
(currenttime->tm_min) % 256,
4043
(currenttime->tm_sec) % 256);
4044
4045
return;
4046
}
4047
4048
/*
4049
* This function fills a string of a T2P struct with the date and time of a
4050
* TIFF file if it exists or the current time as a PDF date string.
4051
*/
4052
4053
void t2p_pdf_tifftime(T2P* t2p, TIFF* input)
4054
{
4055
char* datetime;
4056
4057
if (TIFFGetField(input, TIFFTAG_DATETIME, &datetime) != 0
4058
&& (strlen(datetime) >= 19) ){
4059
t2p->pdf_datetime[0]='D';
4060
t2p->pdf_datetime[1]=':';
4061
t2p->pdf_datetime[2]=datetime[0];
4062
t2p->pdf_datetime[3]=datetime[1];
4063
t2p->pdf_datetime[4]=datetime[2];
4064
t2p->pdf_datetime[5]=datetime[3];
4065
t2p->pdf_datetime[6]=datetime[5];
4066
t2p->pdf_datetime[7]=datetime[6];
4067
t2p->pdf_datetime[8]=datetime[8];
4068
t2p->pdf_datetime[9]=datetime[9];
4069
t2p->pdf_datetime[10]=datetime[11];
4070
t2p->pdf_datetime[11]=datetime[12];
4071
t2p->pdf_datetime[12]=datetime[14];
4072
t2p->pdf_datetime[13]=datetime[15];
4073
t2p->pdf_datetime[14]=datetime[17];
4074
t2p->pdf_datetime[15]=datetime[18];
4075
t2p->pdf_datetime[16] = '\0';
4076
} else {
4077
t2p_pdf_currenttime(t2p);
4078
}
4079
4080
return;
4081
}
4082
4083
/*
4084
* This function writes a PDF Pages Tree structure to output.
4085
*/
4086
4087
tsize_t t2p_write_pdf_pages(T2P* t2p, TIFF* output)
4088
{
4089
tsize_t written=0;
4090
tdir_t i=0;
4091
char buffer[16];
4092
int buflen=0;
4093
4094
int page=0;
4095
written += t2pWriteFile(output,
4096
(tdata_t) "<< \n/Type /Pages \n/Kids [ ", 26);
4097
page = t2p->pdf_pages+1;
4098
for (i=0;i<t2p->tiff_pagecount;i++){
4099
buflen=sprintf(buffer, "%d", page);
4100
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4101
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4102
if ( ((i+1)%8)==0 ) {
4103
written += t2pWriteFile(output, (tdata_t) "\n", 1);
4104
}
4105
page +=3;
4106
page += t2p->tiff_pages[i].page_extra;
4107
if(t2p->tiff_pages[i].page_tilecount>0){
4108
page += (2 * t2p->tiff_pages[i].page_tilecount);
4109
} else {
4110
page +=2;
4111
}
4112
}
4113
written += t2pWriteFile(output, (tdata_t) "] \n/Count ", 10);
4114
_TIFFmemset(buffer, 0x00, 16);
4115
buflen=sprintf(buffer, "%d", t2p->tiff_pagecount);
4116
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4117
written += t2pWriteFile(output, (tdata_t) " \n>> \n", 6);
4118
4119
return(written);
4120
}
4121
4122
/*
4123
This function writes a PDF Page structure to output.
4124
*/
4125
4126
tsize_t t2p_write_pdf_page(uint32 object, T2P* t2p, TIFF* output){
4127
4128
unsigned int i=0;
4129
tsize_t written=0;
4130
char buffer[16];
4131
int buflen=0;
4132
4133
written += t2pWriteFile(output, (tdata_t) "<<\n/Type /Page \n/Parent ", 24);
4134
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_pages);
4135
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4136
written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
4137
written += t2pWriteFile(output, (tdata_t) "/MediaBox [", 11);
4138
buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x1);
4139
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4140
written += t2pWriteFile(output, (tdata_t) " ", 1);
4141
buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y1);
4142
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4143
written += t2pWriteFile(output, (tdata_t) " ", 1);
4144
buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.x2);
4145
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4146
written += t2pWriteFile(output, (tdata_t) " ", 1);
4147
buflen=sprintf(buffer, "%.4f",t2p->pdf_mediabox.y2);
4148
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4149
written += t2pWriteFile(output, (tdata_t) "] \n", 3);
4150
written += t2pWriteFile(output, (tdata_t) "/Contents ", 10);
4151
buflen=sprintf(buffer, "%lu", (unsigned long)(object + 1));
4152
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4153
written += t2pWriteFile(output, (tdata_t) " 0 R \n", 6);
4154
written += t2pWriteFile(output, (tdata_t) "/Resources << \n", 15);
4155
if( t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount != 0 ){
4156
written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4157
for(i=0;i<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i++){
4158
written += t2pWriteFile(output, (tdata_t) "/Im", 3);
4159
buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
4160
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4161
written += t2pWriteFile(output, (tdata_t) "_", 1);
4162
buflen = sprintf(buffer, "%u", i+1);
4163
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4164
written += t2pWriteFile(output, (tdata_t) " ", 1);
4165
buflen = sprintf(
4166
buffer,
4167
"%lu",
4168
(unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
4169
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4170
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4171
if(i%4==3){
4172
written += t2pWriteFile(output, (tdata_t) "\n", 1);
4173
}
4174
}
4175
written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
4176
} else {
4177
written += t2pWriteFile(output, (tdata_t) "/XObject <<\n", 12);
4178
written += t2pWriteFile(output, (tdata_t) "/Im", 3);
4179
buflen = sprintf(buffer, "%u", t2p->pdf_page+1);
4180
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4181
written += t2pWriteFile(output, (tdata_t) " ", 1);
4182
buflen = sprintf(
4183
buffer,
4184
"%lu",
4185
(unsigned long)(object+3+(2*i)+t2p->tiff_pages[t2p->pdf_page].page_extra));
4186
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4187
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4188
written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
4189
}
4190
if(t2p->tiff_transferfunctioncount != 0) {
4191
written += t2pWriteFile(output, (tdata_t) "/ExtGState <<", 13);
4192
t2pWriteFile(output, (tdata_t) "/GS1 ", 5);
4193
buflen = sprintf(
4194
buffer,
4195
"%lu",
4196
(unsigned long)(object + 3));
4197
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4198
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4199
written += t2pWriteFile(output, (tdata_t) ">> \n", 4);
4200
}
4201
written += t2pWriteFile(output, (tdata_t) "/ProcSet [ ", 11);
4202
if(t2p->pdf_colorspace == T2P_CS_BILEVEL
4203
|| t2p->pdf_colorspace == T2P_CS_GRAY
4204
){
4205
written += t2pWriteFile(output, (tdata_t) "/ImageB ", 8);
4206
} else {
4207
written += t2pWriteFile(output, (tdata_t) "/ImageC ", 8);
4208
if(t2p->pdf_colorspace & T2P_CS_PALETTE){
4209
written += t2pWriteFile(output, (tdata_t) "/ImageI ", 8);
4210
}
4211
}
4212
written += t2pWriteFile(output, (tdata_t) "]\n>>\n>>\n", 8);
4213
4214
return(written);
4215
}
4216
4217
/*
4218
This function composes the page size and image and tile locations on a page.
4219
*/
4220
4221
void t2p_compose_pdf_page(T2P* t2p){
4222
4223
uint32 i=0;
4224
uint32 i2=0;
4225
T2P_TILE* tiles=NULL;
4226
T2P_BOX* boxp=NULL;
4227
uint32 tilecountx=0;
4228
uint32 tilecounty=0;
4229
uint32 tilewidth=0;
4230
uint32 tilelength=0;
4231
int istiled=0;
4232
float f=0;
4233
float width_ratio=0;
4234
float length_ratio=0;
4235
4236
t2p->pdf_xres = t2p->tiff_xres;
4237
t2p->pdf_yres = t2p->tiff_yres;
4238
if(t2p->pdf_overrideres) {
4239
t2p->pdf_xres = t2p->pdf_defaultxres;
4240
t2p->pdf_yres = t2p->pdf_defaultyres;
4241
}
4242
if(t2p->pdf_xres == 0.0)
4243
t2p->pdf_xres = t2p->pdf_defaultxres;
4244
if(t2p->pdf_yres == 0.0)
4245
t2p->pdf_yres = t2p->pdf_defaultyres;
4246
if (t2p->pdf_image_fillpage) {
4247
width_ratio = t2p->pdf_defaultpagewidth/t2p->tiff_width;
4248
length_ratio = t2p->pdf_defaultpagelength/t2p->tiff_length;
4249
if (width_ratio < length_ratio ) {
4250
t2p->pdf_imagewidth = t2p->pdf_defaultpagewidth;
4251
t2p->pdf_imagelength = t2p->tiff_length * width_ratio;
4252
} else {
4253
t2p->pdf_imagewidth = t2p->tiff_width * length_ratio;
4254
t2p->pdf_imagelength = t2p->pdf_defaultpagelength;
4255
}
4256
} else if (t2p->tiff_resunit != RESUNIT_CENTIMETER /* RESUNIT_NONE and */
4257
&& t2p->tiff_resunit != RESUNIT_INCH) { /* other cases */
4258
t2p->pdf_imagewidth = ((float)(t2p->tiff_width))/t2p->pdf_xres;
4259
t2p->pdf_imagelength = ((float)(t2p->tiff_length))/t2p->pdf_yres;
4260
} else {
4261
t2p->pdf_imagewidth =
4262
((float)(t2p->tiff_width))*PS_UNIT_SIZE/t2p->pdf_xres;
4263
t2p->pdf_imagelength =
4264
((float)(t2p->tiff_length))*PS_UNIT_SIZE/t2p->pdf_yres;
4265
}
4266
if(t2p->pdf_overridepagesize != 0) {
4267
t2p->pdf_pagewidth = t2p->pdf_defaultpagewidth;
4268
t2p->pdf_pagelength = t2p->pdf_defaultpagelength;
4269
} else {
4270
t2p->pdf_pagewidth = t2p->pdf_imagewidth;
4271
t2p->pdf_pagelength = t2p->pdf_imagelength;
4272
}
4273
t2p->pdf_mediabox.x1=0.0;
4274
t2p->pdf_mediabox.y1=0.0;
4275
t2p->pdf_mediabox.x2=t2p->pdf_pagewidth;
4276
t2p->pdf_mediabox.y2=t2p->pdf_pagelength;
4277
t2p->pdf_imagebox.x1=0.0;
4278
t2p->pdf_imagebox.y1=0.0;
4279
t2p->pdf_imagebox.x2=t2p->pdf_imagewidth;
4280
t2p->pdf_imagebox.y2=t2p->pdf_imagelength;
4281
if(t2p->pdf_overridepagesize!=0){
4282
t2p->pdf_imagebox.x1+=((t2p->pdf_pagewidth-t2p->pdf_imagewidth)/2.0F);
4283
t2p->pdf_imagebox.y1+=((t2p->pdf_pagelength-t2p->pdf_imagelength)/2.0F);
4284
t2p->pdf_imagebox.x2+=((t2p->pdf_pagewidth-t2p->pdf_imagewidth)/2.0F);
4285
t2p->pdf_imagebox.y2+=((t2p->pdf_pagelength-t2p->pdf_imagelength)/2.0F);
4286
}
4287
if(t2p->tiff_orientation > 4){
4288
f=t2p->pdf_mediabox.x2;
4289
t2p->pdf_mediabox.x2=t2p->pdf_mediabox.y2;
4290
t2p->pdf_mediabox.y2=f;
4291
}
4292
istiled=((t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount==0) ? 0 : 1;
4293
if(istiled==0){
4294
t2p_compose_pdf_page_orient(&(t2p->pdf_imagebox), t2p->tiff_orientation);
4295
return;
4296
} else {
4297
tilewidth=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilewidth;
4298
tilelength=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilelength;
4299
tilecountx=(t2p->tiff_width +
4300
tilewidth -1)/
4301
tilewidth;
4302
(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecountx=tilecountx;
4303
tilecounty=(t2p->tiff_length +
4304
tilelength -1)/
4305
tilelength;
4306
(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecounty=tilecounty;
4307
(t2p->tiff_tiles[t2p->pdf_page]).tiles_edgetilewidth=
4308
t2p->tiff_width % tilewidth;
4309
(t2p->tiff_tiles[t2p->pdf_page]).tiles_edgetilelength=
4310
t2p->tiff_length % tilelength;
4311
tiles=(t2p->tiff_tiles[t2p->pdf_page]).tiles_tiles;
4312
for(i2=0;i2<tilecounty-1;i2++){
4313
for(i=0;i<tilecountx-1;i++){
4314
boxp=&(tiles[i2*tilecountx+i].tile_box);
4315
boxp->x1 =
4316
t2p->pdf_imagebox.x1
4317
+ ((float)(t2p->pdf_imagewidth * i * tilewidth)
4318
/ (float)t2p->tiff_width);
4319
boxp->x2 =
4320
t2p->pdf_imagebox.x1
4321
+ ((float)(t2p->pdf_imagewidth * (i+1) * tilewidth)
4322
/ (float)t2p->tiff_width);
4323
boxp->y1 =
4324
t2p->pdf_imagebox.y2
4325
- ((float)(t2p->pdf_imagelength * (i2+1) * tilelength)
4326
/ (float)t2p->tiff_length);
4327
boxp->y2 =
4328
t2p->pdf_imagebox.y2
4329
- ((float)(t2p->pdf_imagelength * i2 * tilelength)
4330
/ (float)t2p->tiff_length);
4331
}
4332
boxp=&(tiles[i2*tilecountx+i].tile_box);
4333
boxp->x1 =
4334
t2p->pdf_imagebox.x1
4335
+ ((float)(t2p->pdf_imagewidth * i * tilewidth)
4336
/ (float)t2p->tiff_width);
4337
boxp->x2 = t2p->pdf_imagebox.x2;
4338
boxp->y1 =
4339
t2p->pdf_imagebox.y2
4340
- ((float)(t2p->pdf_imagelength * (i2+1) * tilelength)
4341
/ (float)t2p->tiff_length);
4342
boxp->y2 =
4343
t2p->pdf_imagebox.y2
4344
- ((float)(t2p->pdf_imagelength * i2 * tilelength)
4345
/ (float)t2p->tiff_length);
4346
}
4347
for(i=0;i<tilecountx-1;i++){
4348
boxp=&(tiles[i2*tilecountx+i].tile_box);
4349
boxp->x1 =
4350
t2p->pdf_imagebox.x1
4351
+ ((float)(t2p->pdf_imagewidth * i * tilewidth)
4352
/ (float)t2p->tiff_width);
4353
boxp->x2 =
4354
t2p->pdf_imagebox.x1
4355
+ ((float)(t2p->pdf_imagewidth * (i+1) * tilewidth)
4356
/ (float)t2p->tiff_width);
4357
boxp->y1 = t2p->pdf_imagebox.y1;
4358
boxp->y2 =
4359
t2p->pdf_imagebox.y2
4360
- ((float)(t2p->pdf_imagelength * i2 * tilelength)
4361
/ (float)t2p->tiff_length);
4362
}
4363
boxp=&(tiles[i2*tilecountx+i].tile_box);
4364
boxp->x1 =
4365
t2p->pdf_imagebox.x1
4366
+ ((float)(t2p->pdf_imagewidth * i * tilewidth)
4367
/ (float)t2p->tiff_width);
4368
boxp->x2 = t2p->pdf_imagebox.x2;
4369
boxp->y1 = t2p->pdf_imagebox.y1;
4370
boxp->y2 =
4371
t2p->pdf_imagebox.y2
4372
- ((float)(t2p->pdf_imagelength * i2 * tilelength)
4373
/ (float)t2p->tiff_length);
4374
}
4375
if(t2p->tiff_orientation==0 || t2p->tiff_orientation==1){
4376
for(i=0;i<(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount;i++){
4377
t2p_compose_pdf_page_orient( &(tiles[i].tile_box) , 0);
4378
}
4379
return;
4380
}
4381
for(i=0;i<(t2p->tiff_tiles[t2p->pdf_page]).tiles_tilecount;i++){
4382
boxp=&(tiles[i].tile_box);
4383
boxp->x1 -= t2p->pdf_imagebox.x1;
4384
boxp->x2 -= t2p->pdf_imagebox.x1;
4385
boxp->y1 -= t2p->pdf_imagebox.y1;
4386
boxp->y2 -= t2p->pdf_imagebox.y1;
4387
if(t2p->tiff_orientation==2 || t2p->tiff_orientation==3){
4388
boxp->x1 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x1;
4389
boxp->x2 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x2;
4390
}
4391
if(t2p->tiff_orientation==3 || t2p->tiff_orientation==4){
4392
boxp->y1 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y1;
4393
boxp->y2 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y2;
4394
}
4395
if(t2p->tiff_orientation==8 || t2p->tiff_orientation==5){
4396
boxp->y1 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y1;
4397
boxp->y2 = t2p->pdf_imagebox.y2 - t2p->pdf_imagebox.y1 - boxp->y2;
4398
}
4399
if(t2p->tiff_orientation==5 || t2p->tiff_orientation==6){
4400
boxp->x1 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x1;
4401
boxp->x2 = t2p->pdf_imagebox.x2 - t2p->pdf_imagebox.x1 - boxp->x2;
4402
}
4403
if(t2p->tiff_orientation > 4){
4404
f=boxp->x1;
4405
boxp->x1 = boxp->y1;
4406
boxp->y1 = f;
4407
f=boxp->x2;
4408
boxp->x2 = boxp->y2;
4409
boxp->y2 = f;
4410
t2p_compose_pdf_page_orient_flip(boxp, t2p->tiff_orientation);
4411
} else {
4412
t2p_compose_pdf_page_orient(boxp, t2p->tiff_orientation);
4413
}
4414
4415
}
4416
4417
return;
4418
}
4419
4420
void t2p_compose_pdf_page_orient(T2P_BOX* boxp, uint16 orientation){
4421
4422
float m1[9];
4423
float f=0.0;
4424
4425
if( boxp->x1 > boxp->x2){
4426
f=boxp->x1;
4427
boxp->x1=boxp->x2;
4428
boxp->x2 = f;
4429
}
4430
if( boxp->y1 > boxp->y2){
4431
f=boxp->y1;
4432
boxp->y1=boxp->y2;
4433
boxp->y2 = f;
4434
}
4435
boxp->mat[0]=m1[0]=boxp->x2-boxp->x1;
4436
boxp->mat[1]=m1[1]=0.0;
4437
boxp->mat[2]=m1[2]=0.0;
4438
boxp->mat[3]=m1[3]=0.0;
4439
boxp->mat[4]=m1[4]=boxp->y2-boxp->y1;
4440
boxp->mat[5]=m1[5]=0.0;
4441
boxp->mat[6]=m1[6]=boxp->x1;
4442
boxp->mat[7]=m1[7]=boxp->y1;
4443
boxp->mat[8]=m1[8]=1.0;
4444
switch(orientation){
4445
case 0:
4446
case 1:
4447
break;
4448
case 2:
4449
boxp->mat[0]=0.0F-m1[0];
4450
boxp->mat[6]+=m1[0];
4451
break;
4452
case 3:
4453
boxp->mat[0]=0.0F-m1[0];
4454
boxp->mat[4]=0.0F-m1[4];
4455
boxp->mat[6]+=m1[0];
4456
boxp->mat[7]+=m1[4];
4457
break;
4458
case 4:
4459
boxp->mat[4]=0.0F-m1[4];
4460
boxp->mat[7]+=m1[4];
4461
break;
4462
case 5:
4463
boxp->mat[0]=0.0F;
4464
boxp->mat[1]=0.0F-m1[0];
4465
boxp->mat[3]=0.0F-m1[4];
4466
boxp->mat[4]=0.0F;
4467
boxp->mat[6]+=m1[4];
4468
boxp->mat[7]+=m1[0];
4469
break;
4470
case 6:
4471
boxp->mat[0]=0.0F;
4472
boxp->mat[1]=0.0F-m1[0];
4473
boxp->mat[3]=m1[4];
4474
boxp->mat[4]=0.0F;
4475
boxp->mat[7]+=m1[0];
4476
break;
4477
case 7:
4478
boxp->mat[0]=0.0F;
4479
boxp->mat[1]=m1[0];
4480
boxp->mat[3]=m1[4];
4481
boxp->mat[4]=0.0F;
4482
break;
4483
case 8:
4484
boxp->mat[0]=0.0F;
4485
boxp->mat[1]=m1[0];
4486
boxp->mat[3]=0.0F-m1[4];
4487
boxp->mat[4]=0.0F;
4488
boxp->mat[6]+=m1[4];
4489
break;
4490
}
4491
4492
return;
4493
}
4494
4495
void t2p_compose_pdf_page_orient_flip(T2P_BOX* boxp, uint16 orientation){
4496
4497
float m1[9];
4498
float f=0.0;
4499
4500
if( boxp->x1 > boxp->x2){
4501
f=boxp->x1;
4502
boxp->x1=boxp->x2;
4503
boxp->x2 = f;
4504
}
4505
if( boxp->y1 > boxp->y2){
4506
f=boxp->y1;
4507
boxp->y1=boxp->y2;
4508
boxp->y2 = f;
4509
}
4510
boxp->mat[0]=m1[0]=boxp->x2-boxp->x1;
4511
boxp->mat[1]=m1[1]=0.0F;
4512
boxp->mat[2]=m1[2]=0.0F;
4513
boxp->mat[3]=m1[3]=0.0F;
4514
boxp->mat[4]=m1[4]=boxp->y2-boxp->y1;
4515
boxp->mat[5]=m1[5]=0.0F;
4516
boxp->mat[6]=m1[6]=boxp->x1;
4517
boxp->mat[7]=m1[7]=boxp->y1;
4518
boxp->mat[8]=m1[8]=1.0F;
4519
switch(orientation){
4520
case 5:
4521
boxp->mat[0]=0.0F;
4522
boxp->mat[1]=0.0F-m1[4];
4523
boxp->mat[3]=0.0F-m1[0];
4524
boxp->mat[4]=0.0F;
4525
boxp->mat[6]+=m1[0];
4526
boxp->mat[7]+=m1[4];
4527
break;
4528
case 6:
4529
boxp->mat[0]=0.0F;
4530
boxp->mat[1]=0.0F-m1[4];
4531
boxp->mat[3]=m1[0];
4532
boxp->mat[4]=0.0F;
4533
boxp->mat[7]+=m1[4];
4534
break;
4535
case 7:
4536
boxp->mat[0]=0.0F;
4537
boxp->mat[1]=m1[4];
4538
boxp->mat[3]=m1[0];
4539
boxp->mat[4]=0.0F;
4540
break;
4541
case 8:
4542
boxp->mat[0]=0.0F;
4543
boxp->mat[1]=m1[4];
4544
boxp->mat[3]=0.0F-m1[0];
4545
boxp->mat[4]=0.0F;
4546
boxp->mat[6]+=m1[0];
4547
break;
4548
}
4549
4550
return;
4551
}
4552
4553
/*
4554
This function writes a PDF Contents stream to output.
4555
*/
4556
4557
tsize_t t2p_write_pdf_page_content_stream(T2P* t2p, TIFF* output){
4558
4559
tsize_t written=0;
4560
ttile_t i=0;
4561
char buffer[512];
4562
int buflen=0;
4563
T2P_BOX box;
4564
4565
if(t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount>0){
4566
for(i=0;i<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount; i++){
4567
box=t2p->tiff_tiles[t2p->pdf_page].tiles_tiles[i].tile_box;
4568
buflen=sprintf(buffer,
4569
"q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d_%ld Do Q\n",
4570
t2p->tiff_transferfunctioncount?"/GS1 gs ":"",
4571
box.mat[0],
4572
box.mat[1],
4573
box.mat[3],
4574
box.mat[4],
4575
box.mat[6],
4576
box.mat[7],
4577
t2p->pdf_page + 1,
4578
(long)(i + 1));
4579
written += t2p_write_pdf_stream(buffer, buflen, output);
4580
}
4581
} else {
4582
box=t2p->pdf_imagebox;
4583
buflen=sprintf(buffer,
4584
"q %s %.4f %.4f %.4f %.4f %.4f %.4f cm /Im%d Do Q\n",
4585
t2p->tiff_transferfunctioncount?"/GS1 gs ":"",
4586
box.mat[0],
4587
box.mat[1],
4588
box.mat[3],
4589
box.mat[4],
4590
box.mat[6],
4591
box.mat[7],
4592
t2p->pdf_page+1);
4593
written += t2p_write_pdf_stream(buffer, buflen, output);
4594
}
4595
4596
return(written);
4597
}
4598
4599
/*
4600
This function writes a PDF Image XObject stream dictionary to output.
4601
*/
4602
4603
tsize_t t2p_write_pdf_xobject_stream_dict(ttile_t tile,
4604
T2P* t2p,
4605
TIFF* output){
4606
4607
tsize_t written=0;
4608
char buffer[16];
4609
int buflen=0;
4610
4611
written += t2p_write_pdf_stream_dict(0, t2p->pdf_xrefcount+1, output);
4612
written += t2pWriteFile(output,
4613
(tdata_t) "/Type /XObject \n/Subtype /Image \n/Name /Im",
4614
42);
4615
buflen=sprintf(buffer, "%u", t2p->pdf_page+1);
4616
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4617
if(tile != 0){
4618
written += t2pWriteFile(output, (tdata_t) "_", 1);
4619
buflen=sprintf(buffer, "%lu", (unsigned long)tile);
4620
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4621
}
4622
written += t2pWriteFile(output, (tdata_t) "\n/Width ", 8);
4623
_TIFFmemset((tdata_t)buffer, 0x00, 16);
4624
if(tile==0){
4625
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->tiff_width);
4626
} else {
4627
if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)!=0){
4628
buflen=sprintf(
4629
buffer,
4630
"%lu",
4631
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
4632
} else {
4633
buflen=sprintf(
4634
buffer,
4635
"%lu",
4636
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
4637
}
4638
}
4639
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4640
written += t2pWriteFile(output, (tdata_t) "\n/Height ", 9);
4641
_TIFFmemset((tdata_t)buffer, 0x00, 16);
4642
if(tile==0){
4643
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->tiff_length);
4644
} else {
4645
if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)!=0){
4646
buflen=sprintf(
4647
buffer,
4648
"%lu",
4649
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
4650
} else {
4651
buflen=sprintf(
4652
buffer,
4653
"%lu",
4654
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
4655
}
4656
}
4657
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4658
written += t2pWriteFile(output, (tdata_t) "\n/BitsPerComponent ", 19);
4659
_TIFFmemset((tdata_t)buffer, 0x00, 16);
4660
buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
4661
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4662
written += t2pWriteFile(output, (tdata_t) "\n/ColorSpace ", 13);
4663
written += t2p_write_pdf_xobject_cs(t2p, output);
4664
if (t2p->pdf_image_interpolate)
4665
written += t2pWriteFile(output,
4666
(tdata_t) "\n/Interpolate true", 18);
4667
if( (t2p->pdf_switchdecode != 0)
4668
#ifdef CCITT_SUPPORT
4669
&& ! (t2p->pdf_colorspace == T2P_CS_BILEVEL
4670
&& t2p->pdf_compression == T2P_COMPRESS_G4)
4671
#endif
4672
){
4673
written += t2p_write_pdf_xobject_decode(t2p, output);
4674
}
4675
written += t2p_write_pdf_xobject_stream_filter(tile, t2p, output);
4676
4677
return(written);
4678
}
4679
4680
/*
4681
* This function writes a PDF Image XObject Colorspace name to output.
4682
*/
4683
4684
4685
tsize_t t2p_write_pdf_xobject_cs(T2P* t2p, TIFF* output){
4686
4687
tsize_t written=0;
4688
char buffer[128];
4689
int buflen=0;
4690
4691
float X_W=1.0;
4692
float Y_W=1.0;
4693
float Z_W=1.0;
4694
4695
if( (t2p->pdf_colorspace & T2P_CS_ICCBASED) != 0){
4696
written += t2p_write_pdf_xobject_icccs(t2p, output);
4697
return(written);
4698
}
4699
if( (t2p->pdf_colorspace & T2P_CS_PALETTE) != 0){
4700
written += t2pWriteFile(output, (tdata_t) "[ /Indexed ", 11);
4701
t2p->pdf_colorspace ^= T2P_CS_PALETTE;
4702
written += t2p_write_pdf_xobject_cs(t2p, output);
4703
t2p->pdf_colorspace |= T2P_CS_PALETTE;
4704
buflen=sprintf(buffer, "%u", (0x0001 << t2p->tiff_bitspersample)-1 );
4705
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4706
written += t2pWriteFile(output, (tdata_t) " ", 1);
4707
_TIFFmemset(buffer, 0x00, 16);
4708
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_palettecs );
4709
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4710
written += t2pWriteFile(output, (tdata_t) " 0 R ]\n", 7);
4711
return(written);
4712
}
4713
if(t2p->pdf_colorspace & T2P_CS_BILEVEL){
4714
written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
4715
}
4716
if(t2p->pdf_colorspace & T2P_CS_GRAY){
4717
if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4718
written += t2p_write_pdf_xobject_calcs(t2p, output);
4719
} else {
4720
written += t2pWriteFile(output, (tdata_t) "/DeviceGray \n", 13);
4721
}
4722
}
4723
if(t2p->pdf_colorspace & T2P_CS_RGB){
4724
if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4725
written += t2p_write_pdf_xobject_calcs(t2p, output);
4726
} else {
4727
written += t2pWriteFile(output, (tdata_t) "/DeviceRGB \n", 12);
4728
}
4729
}
4730
if(t2p->pdf_colorspace & T2P_CS_CMYK){
4731
written += t2pWriteFile(output, (tdata_t) "/DeviceCMYK \n", 13);
4732
}
4733
if(t2p->pdf_colorspace & T2P_CS_LAB){
4734
written += t2pWriteFile(output, (tdata_t) "[/Lab << \n", 10);
4735
written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4736
X_W = t2p->tiff_whitechromaticities[0];
4737
Y_W = t2p->tiff_whitechromaticities[1];
4738
Z_W = 1.0F - (X_W + Y_W);
4739
X_W /= Y_W;
4740
Z_W /= Y_W;
4741
Y_W = 1.0F;
4742
buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4743
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4744
written += t2pWriteFile(output, (tdata_t) "/Range ", 7);
4745
buflen=sprintf(buffer, "[%d %d %d %d] \n",
4746
t2p->pdf_labrange[0],
4747
t2p->pdf_labrange[1],
4748
t2p->pdf_labrange[2],
4749
t2p->pdf_labrange[3]);
4750
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4751
written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
4752
4753
}
4754
4755
return(written);
4756
}
4757
4758
tsize_t t2p_write_pdf_transfer(T2P* t2p, TIFF* output){
4759
4760
tsize_t written=0;
4761
char buffer[16];
4762
int buflen=0;
4763
4764
written += t2pWriteFile(output, (tdata_t) "<< /Type /ExtGState \n/TR ", 25);
4765
if(t2p->tiff_transferfunctioncount == 1){
4766
buflen=sprintf(buffer, "%lu",
4767
(unsigned long)(t2p->pdf_xrefcount + 1));
4768
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4769
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4770
} else {
4771
written += t2pWriteFile(output, (tdata_t) "[ ", 2);
4772
buflen=sprintf(buffer, "%lu",
4773
(unsigned long)(t2p->pdf_xrefcount + 1));
4774
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4775
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4776
buflen=sprintf(buffer, "%lu",
4777
(unsigned long)(t2p->pdf_xrefcount + 2));
4778
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4779
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4780
buflen=sprintf(buffer, "%lu",
4781
(unsigned long)(t2p->pdf_xrefcount + 3));
4782
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4783
written += t2pWriteFile(output, (tdata_t) " 0 R ", 5);
4784
written += t2pWriteFile(output, (tdata_t) "/Identity ] ", 12);
4785
}
4786
4787
written += t2pWriteFile(output, (tdata_t) " >> \n", 5);
4788
4789
return(written);
4790
}
4791
4792
tsize_t t2p_write_pdf_transfer_dict(T2P* t2p, TIFF* output, uint16 i){
4793
4794
tsize_t written=0;
4795
char buffer[32];
4796
int buflen=0;
4797
(void)i; /* XXX */
4798
4799
written += t2pWriteFile(output, (tdata_t) "/FunctionType 0 \n", 17);
4800
written += t2pWriteFile(output, (tdata_t) "/Domain [0.0 1.0] \n", 19);
4801
written += t2pWriteFile(output, (tdata_t) "/Range [0.0 1.0] \n", 18);
4802
buflen=sprintf(buffer, "/Size [%u] \n", (1<<t2p->tiff_bitspersample));
4803
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4804
written += t2pWriteFile(output, (tdata_t) "/BitsPerSample 16 \n", 19);
4805
written += t2p_write_pdf_stream_dict(((tsize_t)1)<<(t2p->tiff_bitspersample+1), 0, output);
4806
4807
return(written);
4808
}
4809
4810
tsize_t t2p_write_pdf_transfer_stream(T2P* t2p, TIFF* output, uint16 i){
4811
4812
tsize_t written=0;
4813
4814
written += t2p_write_pdf_stream(
4815
t2p->tiff_transferfunction[i],
4816
(((tsize_t)1)<<(t2p->tiff_bitspersample+1)),
4817
output);
4818
4819
return(written);
4820
}
4821
4822
/*
4823
This function writes a PDF Image XObject Colorspace array to output.
4824
*/
4825
4826
tsize_t t2p_write_pdf_xobject_calcs(T2P* t2p, TIFF* output){
4827
4828
tsize_t written=0;
4829
char buffer[128];
4830
int buflen=0;
4831
4832
float X_W=0.0;
4833
float Y_W=0.0;
4834
float Z_W=0.0;
4835
float X_R=0.0;
4836
float Y_R=0.0;
4837
float Z_R=0.0;
4838
float X_G=0.0;
4839
float Y_G=0.0;
4840
float Z_G=0.0;
4841
float X_B=0.0;
4842
float Y_B=0.0;
4843
float Z_B=0.0;
4844
float x_w=0.0;
4845
float y_w=0.0;
4846
float z_w=0.0;
4847
float x_r=0.0;
4848
float y_r=0.0;
4849
float x_g=0.0;
4850
float y_g=0.0;
4851
float x_b=0.0;
4852
float y_b=0.0;
4853
float R=1.0;
4854
float G=1.0;
4855
float B=1.0;
4856
4857
written += t2pWriteFile(output, (tdata_t) "[", 1);
4858
if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4859
written += t2pWriteFile(output, (tdata_t) "/CalGray ", 9);
4860
X_W = t2p->tiff_whitechromaticities[0];
4861
Y_W = t2p->tiff_whitechromaticities[1];
4862
Z_W = 1.0F - (X_W + Y_W);
4863
X_W /= Y_W;
4864
Z_W /= Y_W;
4865
Y_W = 1.0F;
4866
}
4867
if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4868
written += t2pWriteFile(output, (tdata_t) "/CalRGB ", 8);
4869
x_w = t2p->tiff_whitechromaticities[0];
4870
y_w = t2p->tiff_whitechromaticities[1];
4871
x_r = t2p->tiff_primarychromaticities[0];
4872
y_r = t2p->tiff_primarychromaticities[1];
4873
x_g = t2p->tiff_primarychromaticities[2];
4874
y_g = t2p->tiff_primarychromaticities[3];
4875
x_b = t2p->tiff_primarychromaticities[4];
4876
y_b = t2p->tiff_primarychromaticities[5];
4877
z_w = y_w * ((x_g - x_b)*y_r - (x_r-x_b)*y_g + (x_r-x_g)*y_b);
4878
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;
4879
X_R = Y_R * x_r / y_r;
4880
Z_R = Y_R * (((1-x_r)/y_r)-1);
4881
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;
4882
X_G = Y_G * x_g / y_g;
4883
Z_G = Y_G * (((1-x_g)/y_g)-1);
4884
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;
4885
X_B = Y_B * x_b / y_b;
4886
Z_B = Y_B * (((1-x_b)/y_b)-1);
4887
X_W = (X_R * R) + (X_G * G) + (X_B * B);
4888
Y_W = (Y_R * R) + (Y_G * G) + (Y_B * B);
4889
Z_W = (Z_R * R) + (Z_G * G) + (Z_B * B);
4890
X_W /= Y_W;
4891
Z_W /= Y_W;
4892
Y_W = 1.0;
4893
}
4894
written += t2pWriteFile(output, (tdata_t) "<< \n", 4);
4895
if(t2p->pdf_colorspace & T2P_CS_CALGRAY){
4896
written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4897
buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4898
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4899
written += t2pWriteFile(output, (tdata_t) "/Gamma 2.2 \n", 12);
4900
}
4901
if(t2p->pdf_colorspace & T2P_CS_CALRGB){
4902
written += t2pWriteFile(output, (tdata_t) "/WhitePoint ", 12);
4903
buflen=sprintf(buffer, "[%.4f %.4f %.4f] \n", X_W, Y_W, Z_W);
4904
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4905
written += t2pWriteFile(output, (tdata_t) "/Matrix ", 8);
4906
buflen=sprintf(buffer, "[%.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f] \n",
4907
X_R, Y_R, Z_R,
4908
X_G, Y_G, Z_G,
4909
X_B, Y_B, Z_B);
4910
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4911
written += t2pWriteFile(output, (tdata_t) "/Gamma [2.2 2.2 2.2] \n", 22);
4912
}
4913
written += t2pWriteFile(output, (tdata_t) ">>] \n", 5);
4914
4915
return(written);
4916
}
4917
4918
/*
4919
This function writes a PDF Image XObject Colorspace array to output.
4920
*/
4921
4922
tsize_t t2p_write_pdf_xobject_icccs(T2P* t2p, TIFF* output){
4923
4924
tsize_t written=0;
4925
char buffer[16];
4926
int buflen=0;
4927
4928
written += t2pWriteFile(output, (tdata_t) "[/ICCBased ", 11);
4929
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_icccs);
4930
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4931
written += t2pWriteFile(output, (tdata_t) " 0 R] \n", 7);
4932
4933
return(written);
4934
}
4935
4936
tsize_t t2p_write_pdf_xobject_icccs_dict(T2P* t2p, TIFF* output){
4937
4938
tsize_t written=0;
4939
char buffer[16];
4940
int buflen=0;
4941
4942
written += t2pWriteFile(output, (tdata_t) "/N ", 3);
4943
buflen=sprintf(buffer, "%u \n", t2p->tiff_samplesperpixel);
4944
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
4945
written += t2pWriteFile(output, (tdata_t) "/Alternate ", 11);
4946
t2p->pdf_colorspace ^= T2P_CS_ICCBASED;
4947
written += t2p_write_pdf_xobject_cs(t2p, output);
4948
t2p->pdf_colorspace |= T2P_CS_ICCBASED;
4949
written += t2p_write_pdf_stream_dict(t2p->tiff_iccprofilelength, 0, output);
4950
4951
return(written);
4952
}
4953
4954
tsize_t t2p_write_pdf_xobject_icccs_stream(T2P* t2p, TIFF* output){
4955
4956
tsize_t written=0;
4957
4958
written += t2p_write_pdf_stream(
4959
(tdata_t) t2p->tiff_iccprofile,
4960
(tsize_t) t2p->tiff_iccprofilelength,
4961
output);
4962
4963
return(written);
4964
}
4965
4966
/*
4967
This function writes a palette stream for an indexed color space to output.
4968
*/
4969
4970
tsize_t t2p_write_pdf_xobject_palettecs_stream(T2P* t2p, TIFF* output){
4971
4972
tsize_t written=0;
4973
4974
written += t2p_write_pdf_stream(
4975
(tdata_t) t2p->pdf_palette,
4976
(tsize_t) t2p->pdf_palettesize,
4977
output);
4978
4979
return(written);
4980
}
4981
4982
/*
4983
This function writes a PDF Image XObject Decode array to output.
4984
*/
4985
4986
tsize_t t2p_write_pdf_xobject_decode(T2P* t2p, TIFF* output){
4987
4988
tsize_t written=0;
4989
int i=0;
4990
4991
written += t2pWriteFile(output, (tdata_t) "/Decode [ ", 10);
4992
for (i=0;i<t2p->tiff_samplesperpixel;i++){
4993
written += t2pWriteFile(output, (tdata_t) "1 0 ", 4);
4994
}
4995
written += t2pWriteFile(output, (tdata_t) "]\n", 2);
4996
4997
return(written);
4998
}
4999
5000
/*
5001
This function writes a PDF Image XObject stream filter name and parameters to
5002
output.
5003
*/
5004
5005
tsize_t t2p_write_pdf_xobject_stream_filter(ttile_t tile, T2P* t2p, TIFF* output){
5006
5007
tsize_t written=0;
5008
char buffer[16];
5009
int buflen=0;
5010
5011
if(t2p->pdf_compression==T2P_COMPRESS_NONE){
5012
return(written);
5013
}
5014
written += t2pWriteFile(output, (tdata_t) "/Filter ", 8);
5015
switch(t2p->pdf_compression){
5016
#ifdef CCITT_SUPPORT
5017
case T2P_COMPRESS_G4:
5018
written += t2pWriteFile(output, (tdata_t) "/CCITTFaxDecode ", 16);
5019
written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5020
written += t2pWriteFile(output, (tdata_t) "<< /K -1 ", 9);
5021
if(tile==0){
5022
written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5023
buflen=sprintf(buffer, "%lu",
5024
(unsigned long)t2p->tiff_width);
5025
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5026
written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5027
buflen=sprintf(buffer, "%lu",
5028
(unsigned long)t2p->tiff_length);
5029
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5030
} else {
5031
if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
5032
written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5033
buflen=sprintf(
5034
buffer,
5035
"%lu",
5036
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
5037
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5038
} else {
5039
written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
5040
buflen=sprintf(
5041
buffer,
5042
"%lu",
5043
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
5044
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5045
}
5046
if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
5047
written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5048
buflen=sprintf(
5049
buffer,
5050
"%lu",
5051
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
5052
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5053
} else {
5054
written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
5055
buflen=sprintf(
5056
buffer,
5057
"%lu",
5058
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
5059
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5060
}
5061
}
5062
if(t2p->pdf_switchdecode == 0){
5063
written += t2pWriteFile(output, (tdata_t) " /BlackIs1 true ", 16);
5064
}
5065
written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
5066
break;
5067
#endif
5068
#ifdef JPEG_SUPPORT
5069
case T2P_COMPRESS_JPEG:
5070
written += t2pWriteFile(output, (tdata_t) "/DCTDecode ", 11);
5071
5072
if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR) {
5073
written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5074
written += t2pWriteFile(output, (tdata_t) "<< /ColorTransform 0 >>\n", 24);
5075
}
5076
break;
5077
#endif
5078
#ifdef ZIP_SUPPORT
5079
case T2P_COMPRESS_ZIP:
5080
written += t2pWriteFile(output, (tdata_t) "/FlateDecode ", 13);
5081
if(t2p->pdf_compressionquality%100){
5082
written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
5083
written += t2pWriteFile(output, (tdata_t) "<< /Predictor ", 14);
5084
_TIFFmemset(buffer, 0x00, 16);
5085
buflen=sprintf(buffer, "%u", t2p->pdf_compressionquality%100);
5086
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5087
written += t2pWriteFile(output, (tdata_t) " /Columns ", 10);
5088
_TIFFmemset(buffer, 0x00, 16);
5089
buflen = sprintf(buffer, "%lu",
5090
(unsigned long)t2p->tiff_width);
5091
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5092
written += t2pWriteFile(output, (tdata_t) " /Colors ", 9);
5093
_TIFFmemset(buffer, 0x00, 16);
5094
buflen=sprintf(buffer, "%u", t2p->tiff_samplesperpixel);
5095
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5096
written += t2pWriteFile(output, (tdata_t) " /BitsPerComponent ", 19);
5097
_TIFFmemset(buffer, 0x00, 16);
5098
buflen=sprintf(buffer, "%u", t2p->tiff_bitspersample);
5099
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5100
written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
5101
}
5102
break;
5103
#endif
5104
default:
5105
break;
5106
}
5107
5108
return(written);
5109
}
5110
5111
/*
5112
This function writes a PDF xref table to output.
5113
*/
5114
5115
tsize_t t2p_write_pdf_xreftable(T2P* t2p, TIFF* output){
5116
5117
tsize_t written=0;
5118
char buffer[21];
5119
int buflen=0;
5120
uint32 i=0;
5121
5122
written += t2pWriteFile(output, (tdata_t) "xref\n0 ", 7);
5123
buflen=sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount + 1));
5124
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5125
written += t2pWriteFile(output, (tdata_t) " \n0000000000 65535 f \n", 22);
5126
for (i=0;i<t2p->pdf_xrefcount;i++){
5127
sprintf(buffer, "%.10lu 00000 n \n",
5128
(unsigned long)t2p->pdf_xrefoffsets[i]);
5129
written += t2pWriteFile(output, (tdata_t) buffer, 20);
5130
}
5131
5132
return(written);
5133
}
5134
5135
/*
5136
* This function writes a PDF trailer to output.
5137
*/
5138
5139
tsize_t t2p_write_pdf_trailer(T2P* t2p, TIFF* output)
5140
{
5141
5142
tsize_t written = 0;
5143
char buffer[32];
5144
int buflen = 0;
5145
size_t i = 0;
5146
5147
for (i = 0; i < sizeof(t2p->pdf_fileid) - 8; i += 8)
5148
snprintf(t2p->pdf_fileid + i, 9, "%.8X", rand());
5149
5150
written += t2pWriteFile(output, (tdata_t) "trailer\n<<\n/Size ", 17);
5151
buflen = sprintf(buffer, "%lu", (unsigned long)(t2p->pdf_xrefcount+1));
5152
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5153
_TIFFmemset(buffer, 0x00, 32);
5154
written += t2pWriteFile(output, (tdata_t) "\n/Root ", 7);
5155
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_catalog);
5156
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5157
_TIFFmemset(buffer, 0x00, 32);
5158
written += t2pWriteFile(output, (tdata_t) " 0 R \n/Info ", 12);
5159
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_info);
5160
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5161
_TIFFmemset(buffer, 0x00, 32);
5162
written += t2pWriteFile(output, (tdata_t) " 0 R \n/ID[<", 11);
5163
written += t2pWriteFile(output, (tdata_t) t2p->pdf_fileid,
5164
sizeof(t2p->pdf_fileid) - 1);
5165
written += t2pWriteFile(output, (tdata_t) "><", 2);
5166
written += t2pWriteFile(output, (tdata_t) t2p->pdf_fileid,
5167
sizeof(t2p->pdf_fileid) - 1);
5168
written += t2pWriteFile(output, (tdata_t) ">]\n>>\nstartxref\n", 16);
5169
buflen=sprintf(buffer, "%lu", (unsigned long)t2p->pdf_startxref);
5170
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
5171
_TIFFmemset(buffer, 0x00, 32);
5172
written += t2pWriteFile(output, (tdata_t) "\n%%EOF\n", 7);
5173
5174
return(written);
5175
}
5176
5177
/*
5178
5179
This function writes a PDF to a file given a pointer to a TIFF.
5180
5181
The idea with using a TIFF* as output for a PDF file is that the file
5182
can be created with TIFFClientOpen for memory-mapped use within the TIFF
5183
library, and TIFFWriteEncodedStrip can be used to write compressed data to
5184
the output. The output is not actually a TIFF file, it is a PDF file.
5185
5186
This function uses only t2pWriteFile and TIFFWriteEncodedStrip to write to
5187
the output TIFF file. When libtiff would otherwise be writing data to the
5188
output file, the write procedure of the TIFF structure is replaced with an
5189
empty implementation.
5190
5191
The first argument to the function is an initialized and validated T2P
5192
context struct pointer.
5193
5194
The second argument to the function is the TIFF* that is the input that has
5195
been opened for reading and no other functions have been called upon it.
5196
5197
The third argument to the function is the TIFF* that is the output that has
5198
been opened for writing. It has to be opened so that it hasn't written any
5199
data to the output. If the output is seekable then it's OK to seek to the
5200
beginning of the file. The function only writes to the output PDF and does
5201
not seek. See the example usage in the main() function.
5202
5203
TIFF* output = TIFFOpen("output.pdf", "w");
5204
assert(output != NULL);
5205
5206
if(output->tif_seekproc != NULL){
5207
t2pSeekFile(output, (toff_t) 0, SEEK_SET);
5208
}
5209
5210
This function returns the file size of the output PDF file. On error it
5211
returns zero and the t2p->t2p_error variable is set to T2P_ERR_ERROR.
5212
5213
After this function completes, call t2p_free on t2p, TIFFClose on input,
5214
and TIFFClose on output.
5215
*/
5216
5217
tsize_t t2p_write_pdf(T2P* t2p, TIFF* input, TIFF* output){
5218
5219
tsize_t written=0;
5220
ttile_t i2=0;
5221
tsize_t streamlen=0;
5222
uint16 i=0;
5223
5224
t2p_read_tiff_init(t2p, input);
5225
if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5226
t2p->pdf_xrefoffsets= (uint32*) _TIFFmalloc(t2p->pdf_xrefcount * sizeof(uint32) );
5227
if(t2p->pdf_xrefoffsets==NULL){
5228
TIFFError(
5229
TIFF2PDF_MODULE,
5230
"Can't allocate %u bytes of memory for t2p_write_pdf",
5231
(unsigned int) (t2p->pdf_xrefcount * sizeof(uint32)) );
5232
return(written);
5233
}
5234
t2p->pdf_xrefcount=0;
5235
t2p->pdf_catalog=1;
5236
t2p->pdf_info=2;
5237
t2p->pdf_pages=3;
5238
written += t2p_write_pdf_header(t2p, output);
5239
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5240
t2p->pdf_catalog=t2p->pdf_xrefcount;
5241
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5242
written += t2p_write_pdf_catalog(t2p, output);
5243
written += t2p_write_pdf_obj_end(output);
5244
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5245
t2p->pdf_info=t2p->pdf_xrefcount;
5246
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5247
written += t2p_write_pdf_info(t2p, input, output);
5248
written += t2p_write_pdf_obj_end(output);
5249
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5250
t2p->pdf_pages=t2p->pdf_xrefcount;
5251
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5252
written += t2p_write_pdf_pages(t2p, output);
5253
written += t2p_write_pdf_obj_end(output);
5254
for(t2p->pdf_page=0;t2p->pdf_page<t2p->tiff_pagecount;t2p->pdf_page++){
5255
t2p_read_tiff_data(t2p, input);
5256
if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5257
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5258
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5259
written += t2p_write_pdf_page(t2p->pdf_xrefcount, t2p, output);
5260
written += t2p_write_pdf_obj_end(output);
5261
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5262
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5263
written += t2p_write_pdf_stream_dict_start(output);
5264
written += t2p_write_pdf_stream_dict(0, t2p->pdf_xrefcount+1, output);
5265
written += t2p_write_pdf_stream_dict_end(output);
5266
written += t2p_write_pdf_stream_start(output);
5267
streamlen=written;
5268
written += t2p_write_pdf_page_content_stream(t2p, output);
5269
streamlen=written-streamlen;
5270
written += t2p_write_pdf_stream_end(output);
5271
written += t2p_write_pdf_obj_end(output);
5272
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5273
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5274
written += t2p_write_pdf_stream_length(streamlen, output);
5275
written += t2p_write_pdf_obj_end(output);
5276
if(t2p->tiff_transferfunctioncount != 0){
5277
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5278
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5279
written += t2p_write_pdf_transfer(t2p, output);
5280
written += t2p_write_pdf_obj_end(output);
5281
for(i=0; i < t2p->tiff_transferfunctioncount; i++){
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_transfer_dict(t2p, output, i);
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_transfer_stream(t2p, output, i);
5290
streamlen=written-streamlen;
5291
written += t2p_write_pdf_stream_end(output);
5292
written += t2p_write_pdf_obj_end(output);
5293
}
5294
}
5295
if( (t2p->pdf_colorspace & T2P_CS_PALETTE) != 0){
5296
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5297
t2p->pdf_palettecs=t2p->pdf_xrefcount;
5298
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5299
written += t2p_write_pdf_stream_dict_start(output);
5300
written += t2p_write_pdf_stream_dict(t2p->pdf_palettesize, 0, output);
5301
written += t2p_write_pdf_stream_dict_end(output);
5302
written += t2p_write_pdf_stream_start(output);
5303
streamlen=written;
5304
written += t2p_write_pdf_xobject_palettecs_stream(t2p, output);
5305
streamlen=written-streamlen;
5306
written += t2p_write_pdf_stream_end(output);
5307
written += t2p_write_pdf_obj_end(output);
5308
}
5309
if( (t2p->pdf_colorspace & T2P_CS_ICCBASED) != 0){
5310
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5311
t2p->pdf_icccs=t2p->pdf_xrefcount;
5312
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5313
written += t2p_write_pdf_stream_dict_start(output);
5314
written += t2p_write_pdf_xobject_icccs_dict(t2p, output);
5315
written += t2p_write_pdf_stream_dict_end(output);
5316
written += t2p_write_pdf_stream_start(output);
5317
streamlen=written;
5318
written += t2p_write_pdf_xobject_icccs_stream(t2p, output);
5319
streamlen=written-streamlen;
5320
written += t2p_write_pdf_stream_end(output);
5321
written += t2p_write_pdf_obj_end(output);
5322
}
5323
if(t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount !=0){
5324
for(i2=0;i2<t2p->tiff_tiles[t2p->pdf_page].tiles_tilecount;i2++){
5325
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5326
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5327
written += t2p_write_pdf_stream_dict_start(output);
5328
written += t2p_write_pdf_xobject_stream_dict(
5329
i2+1,
5330
t2p,
5331
output);
5332
written += t2p_write_pdf_stream_dict_end(output);
5333
written += t2p_write_pdf_stream_start(output);
5334
streamlen=written;
5335
t2p_read_tiff_size_tile(t2p, input, i2);
5336
written += t2p_readwrite_pdf_image_tile(t2p, input, output, i2);
5337
t2p_write_advance_directory(t2p, output);
5338
if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5339
streamlen=written-streamlen;
5340
written += t2p_write_pdf_stream_end(output);
5341
written += t2p_write_pdf_obj_end(output);
5342
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5343
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5344
written += t2p_write_pdf_stream_length(streamlen, output);
5345
written += t2p_write_pdf_obj_end(output);
5346
}
5347
} else {
5348
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5349
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5350
written += t2p_write_pdf_stream_dict_start(output);
5351
written += t2p_write_pdf_xobject_stream_dict(
5352
0,
5353
t2p,
5354
output);
5355
written += t2p_write_pdf_stream_dict_end(output);
5356
written += t2p_write_pdf_stream_start(output);
5357
streamlen=written;
5358
t2p_read_tiff_size(t2p, input);
5359
written += t2p_readwrite_pdf_image(t2p, input, output);
5360
t2p_write_advance_directory(t2p, output);
5361
if(t2p->t2p_error!=T2P_ERR_OK){return(0);}
5362
streamlen=written-streamlen;
5363
written += t2p_write_pdf_stream_end(output);
5364
written += t2p_write_pdf_obj_end(output);
5365
t2p->pdf_xrefoffsets[t2p->pdf_xrefcount++]=written;
5366
written += t2p_write_pdf_obj_start(t2p->pdf_xrefcount, output);
5367
written += t2p_write_pdf_stream_length(streamlen, output);
5368
written += t2p_write_pdf_obj_end(output);
5369
}
5370
}
5371
t2p->pdf_startxref = written;
5372
written += t2p_write_pdf_xreftable(t2p, output);
5373
written += t2p_write_pdf_trailer(t2p, output);
5374
t2p_disable(output);
5375
5376
return(written);
5377
}
5378
5379
/* vim: set ts=8 sts=8 sw=8 noet: */
5380
/*
5381
* Local Variables:
5382
* mode: c
5383
* c-basic-offset: 8
5384
* fill-column: 78
5385
* End:
5386
*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.1