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