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