/* $Id: tiff2pdf.c,v 1.69 2012-07-19 15:43:41 tgl Exp $

*

* tiff2pdf - converts a TIFF image to a PDF document

*

* Copyright (c) 2003 Ross Finlayson

*

* Permission to use, copy, modify, distribute, and sell this software and

* its documentation for any purpose is hereby granted without fee, provided

* that (i) the above copyright notices and this permission notice appear in

* all copies of the software and related documentation, and (ii) the name of

* Ross Finlayson may not be used in any advertising or

* publicity relating to the software without the specific, prior written

* permission of Ross Finlayson.

*

* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

*

* IN NO EVENT SHALL ROSS FINLAYSON BE LIABLE FOR

* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

* OF THIS SOFTWARE.

*/

#include "tif_config.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include <errno.h>

#if HAVE_UNISTD_H

# include <unistd.h>

#endif

#ifdef HAVE_FCNTL_H

# include <fcntl.h>

#endif

#ifdef HAVE_IO_H

# include <io.h>

#endif

#ifdef NEED_LIBPORT

# include "libport.h"

#endif

#include "tiffiop.h"

#include "tiffio.h"

#ifndef HAVE_GETOPT

extern int getopt(int, char**, char*);

#endif

#ifndef EXIT_SUCCESS

# define EXIT_SUCCESS 0

#endif

#ifndef EXIT_FAILURE

# define EXIT_FAILURE 1

#endif

#define TIFF2PDF_MODULE "tiff2pdf"

#define PS_UNIT_SIZE 72.0F

/* This type is of PDF color spaces. */

typedef enum {

T2P_CS_BILEVEL = 0x01, /* Bilevel, black and white */

T2P_CS_GRAY = 0x02, /* Single channel */

T2P_CS_RGB = 0x04, /* Three channel tristimulus RGB */

T2P_CS_CMYK = 0x08, /* Four channel CMYK print inkset */

T2P_CS_LAB = 0x10, /* Three channel L*a*b* color space */

T2P_CS_PALETTE = 0x1000,/* One of the above with a color map */

T2P_CS_CALGRAY = 0x20, /* Calibrated single channel */

T2P_CS_CALRGB = 0x40, /* Calibrated three channel tristimulus RGB */

T2P_CS_ICCBASED = 0x80 /* ICC profile color specification */

} t2p_cs_t;

/* This type is of PDF compression types. */

typedef enum{

T2P_COMPRESS_NONE=0x00

#ifdef CCITT_SUPPORT

, T2P_COMPRESS_G4=0x01

#endif

#if defined(JPEG_SUPPORT) || defined(OJPEG_SUPPORT)

, T2P_COMPRESS_JPEG=0x02

#endif

#ifdef ZIP_SUPPORT

, T2P_COMPRESS_ZIP=0x04

#endif

} t2p_compress_t;

/* This type is whether TIFF image data can be used in PDF without transcoding. */

typedef enum{

T2P_TRANSCODE_RAW=0x01, /* The raw data from the input can be used without recompressing */

T2P_TRANSCODE_ENCODE=0x02 /* The data from the input is perhaps unencoded and reencoded */

} t2p_transcode_t;

/* This type is of information about the data samples of the input image. */

typedef enum{

T2P_SAMPLE_NOTHING=0x0000, /* The unencoded samples are normal for the output colorspace */

T2P_SAMPLE_ABGR_TO_RGB=0x0001, /* The unencoded samples are the result of ReadRGBAImage */

T2P_SAMPLE_RGBA_TO_RGB=0x0002, /* The unencoded samples are contiguous RGBA */

T2P_SAMPLE_RGBAA_TO_RGB=0x0004, /* The unencoded samples are RGBA with premultiplied alpha */

T2P_SAMPLE_YCBCR_TO_RGB=0x0008,

T2P_SAMPLE_YCBCR_TO_LAB=0x0010,

T2P_SAMPLE_REALIZE_PALETTE=0x0020, /* The unencoded samples are indexes into the color map */

T2P_SAMPLE_SIGNED_TO_UNSIGNED=0x0040, /* The unencoded samples are signed instead of unsignd */

T2P_SAMPLE_LAB_SIGNED_TO_UNSIGNED=0x0040, /* The L*a*b* samples have a* and b* signed */

T2P_SAMPLE_PLANAR_SEPARATE_TO_CONTIG=0x0100 /* The unencoded samples are separate instead of contiguous */

} t2p_sample_t;

/* This type is of error status of the T2P struct. */

typedef enum{

T2P_ERR_OK = 0, /* This is the value of t2p->t2p_error when there is no error */

T2P_ERR_ERROR = 1 /* This is the value of t2p->t2p_error when there was an error */

} t2p_err_t;

/* This struct defines a logical page of a TIFF. */

typedef struct {

tdir_t page_directory;

uint32 page_number;

ttile_t page_tilecount;

uint32 page_extra;

} T2P_PAGE;

/* This struct defines a PDF rectangle's coordinates. */

typedef struct {

float x1;

float y1;

float x2;

float y2;

float mat[9];

} T2P_BOX;

/* This struct defines a tile of a PDF. */

typedef struct {

T2P_BOX tile_box;

} T2P_TILE;

/* This struct defines information about the tiles on a PDF page. */

typedef struct {

ttile_t tiles_tilecount;

uint32 tiles_tilewidth;

uint32 tiles_tilelength;

uint32 tiles_tilecountx;

uint32 tiles_tilecounty;

uint32 tiles_edgetilewidth;

uint32 tiles_edgetilelength;

T2P_TILE* tiles_tiles;

} T2P_TILES;

/* This struct is the context of a function to generate PDF from a TIFF. */

typedef struct {

t2p_err_t t2p_error;

T2P_PAGE* tiff_pages;

T2P_TILES* tiff_tiles;

tdir_t tiff_pagecount;

uint16 tiff_compression;

uint16 tiff_photometric;

uint16 tiff_fillorder;

uint16 tiff_bitspersample;

uint16 tiff_samplesperpixel;

uint16 tiff_planar;

uint32 tiff_width;

uint32 tiff_length;

float tiff_xres;

float tiff_yres;

uint16 tiff_orientation;

toff_t tiff_dataoffset;

tsize_t tiff_datasize;

uint16 tiff_resunit;

uint16 pdf_centimeters;

uint16 pdf_overrideres;

uint16 pdf_overridepagesize;

float pdf_defaultxres;

float pdf_defaultyres;

float pdf_xres;

float pdf_yres;

float pdf_defaultpagewidth;

float pdf_defaultpagelength;

float pdf_pagewidth;

float pdf_pagelength;

float pdf_imagewidth;

float pdf_imagelength;

int pdf_image_fillpage; /* 0 (default: no scaling, 1:scale imagesize to pagesize */

T2P_BOX pdf_mediabox;

T2P_BOX pdf_imagebox;

uint16 pdf_majorversion;

uint16 pdf_minorversion;

uint32 pdf_catalog;

uint32 pdf_pages;

uint32 pdf_info;

uint32 pdf_palettecs;

uint16 pdf_fitwindow;

uint32 pdf_startxref;

#define TIFF2PDF_FILEID_SIZE 33

char pdf_fileid[TIFF2PDF_FILEID_SIZE];

#define TIFF2PDF_DATETIME_SIZE 17

char pdf_datetime[TIFF2PDF_DATETIME_SIZE];

#define TIFF2PDF_CREATOR_SIZE 512

char pdf_creator[TIFF2PDF_CREATOR_SIZE];

#define TIFF2PDF_AUTHOR_SIZE 512

char pdf_author[TIFF2PDF_AUTHOR_SIZE];

#define TIFF2PDF_TITLE_SIZE 512

char pdf_title[TIFF2PDF_TITLE_SIZE];

#define TIFF2PDF_SUBJECT_SIZE 512

char pdf_subject[TIFF2PDF_SUBJECT_SIZE];

#define TIFF2PDF_KEYWORDS_SIZE 512

char pdf_keywords[TIFF2PDF_KEYWORDS_SIZE];

t2p_cs_t pdf_colorspace;

uint16 pdf_colorspace_invert;

uint16 pdf_switchdecode;

uint16 pdf_palettesize;

unsigned char* pdf_palette;

int pdf_labrange[4];

t2p_compress_t pdf_defaultcompression;

uint16 pdf_defaultcompressionquality;

t2p_compress_t pdf_compression;

uint16 pdf_compressionquality;

uint16 pdf_nopassthrough;

t2p_transcode_t pdf_transcode;

t2p_sample_t pdf_sample;

uint32* pdf_xrefoffsets;

uint32 pdf_xrefcount;

tdir_t pdf_page;

#ifdef OJPEG_SUPPORT

tdata_t pdf_ojpegdata;

uint32 pdf_ojpegdatalength;

uint32 pdf_ojpegiflength;

#endif

float tiff_whitechromaticities[2];

float tiff_primarychromaticities[6];

float tiff_referenceblackwhite[2];

float* tiff_transferfunction[3];

int pdf_image_interpolate; /* 0 (default) : do not interpolate,

1 : interpolate */

uint16 tiff_transferfunctioncount;

uint32 pdf_icccs;

uint32 tiff_iccprofilelength;

tdata_t tiff_iccprofile;

/* fields for custom read/write procedures */

FILE *outputfile;

int outputdisable;

tsize_t outputwritten;

} T2P;

/* These functions are called by main. */

void tiff2pdf_usage(void);

int tiff2pdf_match_paper_size(float*, float*, char*);

/* These functions are used to generate a PDF from a TIFF. */

#ifdef __cplusplus

extern "C" {

#endif

T2P* t2p_init(void);

void t2p_validate(T2P*);

tsize_t t2p_write_pdf(T2P*, TIFF*, TIFF*);

void t2p_free(T2P*);

#ifdef __cplusplus

}

#endif

void t2p_read_tiff_init(T2P*, TIFF*);

int t2p_cmp_t2p_page(const void*, const void*);

void t2p_read_tiff_data(T2P*, TIFF*);

void t2p_read_tiff_size(T2P*, TIFF*);

void t2p_read_tiff_size_tile(T2P*, TIFF*, ttile_t);

int t2p_tile_is_right_edge(T2P_TILES, ttile_t);

int t2p_tile_is_bottom_edge(T2P_TILES, ttile_t);

int t2p_tile_is_edge(T2P_TILES, ttile_t);

int t2p_tile_is_corner_edge(T2P_TILES, ttile_t);

tsize_t t2p_readwrite_pdf_image(T2P*, TIFF*, TIFF*);

tsize_t t2p_readwrite_pdf_image_tile(T2P*, TIFF*, TIFF*, ttile_t);

#ifdef OJPEG_SUPPORT

int t2p_process_ojpeg_tables(T2P*, TIFF*);

#endif

#ifdef JPEG_SUPPORT

int t2p_process_jpeg_strip(unsigned char*, tsize_t*, unsigned char*, tsize_t, tsize_t*, tstrip_t, uint32);

#endif

void t2p_tile_collapse_left(tdata_t, tsize_t, uint32, uint32, uint32);

void t2p_write_advance_directory(T2P*, TIFF*);

tsize_t t2p_sample_planar_separate_to_contig(T2P*, unsigned char*, unsigned char*, tsize_t);

tsize_t t2p_sample_realize_palette(T2P*, unsigned char*);

tsize_t t2p_sample_abgr_to_rgb(tdata_t, uint32);

tsize_t t2p_sample_rgba_to_rgb(tdata_t, uint32);

tsize_t t2p_sample_rgbaa_to_rgb(tdata_t, uint32);

tsize_t t2p_sample_lab_signed_to_unsigned(tdata_t, uint32);

tsize_t t2p_write_pdf_header(T2P*, TIFF*);

tsize_t t2p_write_pdf_obj_start(uint32, TIFF*);

tsize_t t2p_write_pdf_obj_end(TIFF*);

tsize_t t2p_write_pdf_name(unsigned char*, TIFF*);

tsize_t t2p_write_pdf_string(char*, TIFF*);

tsize_t t2p_write_pdf_stream(tdata_t, tsize_t, TIFF*);

tsize_t t2p_write_pdf_stream_start(TIFF*);

tsize_t t2p_write_pdf_stream_end(TIFF*);

tsize_t t2p_write_pdf_stream_dict(tsize_t, uint32, TIFF*);

tsize_t t2p_write_pdf_stream_dict_start(TIFF*);

tsize_t t2p_write_pdf_stream_dict_end(TIFF*);

tsize_t t2p_write_pdf_stream_length(tsize_t, TIFF*);

tsize_t t2p_write_pdf_catalog(T2P*, TIFF*);

tsize_t t2p_write_pdf_info(T2P*, TIFF*, TIFF*);

void t2p_pdf_currenttime(T2P*);

void t2p_pdf_tifftime(T2P*, TIFF*);

tsize_t t2p_write_pdf_pages(T2P*, TIFF*);

tsize_t t2p_write_pdf_page(uint32, T2P*, TIFF*);

void t2p_compose_pdf_page(T2P*);

void t2p_compose_pdf_page_orient(T2P_BOX*, uint16);

void t2p_compose_pdf_page_orient_flip(T2P_BOX*, uint16);

tsize_t t2p_write_pdf_page_content(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_stream_dict(ttile_t, T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_cs(T2P*, TIFF*);

tsize_t t2p_write_pdf_transfer(T2P*, TIFF*);

tsize_t t2p_write_pdf_transfer_dict(T2P*, TIFF*, uint16);

tsize_t t2p_write_pdf_transfer_stream(T2P*, TIFF*, uint16);

tsize_t t2p_write_pdf_xobject_calcs(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_icccs(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_icccs_dict(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_icccs_stream(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_cs_stream(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_decode(T2P*, TIFF*);

tsize_t t2p_write_pdf_xobject_stream_filter(ttile_t, T2P*, TIFF*);

tsize_t t2p_write_pdf_xreftable(T2P*, TIFF*);

tsize_t t2p_write_pdf_trailer(T2P*, TIFF*);

static void

t2p_disable(TIFF *tif)

{

T2P *t2p = (T2P*) TIFFClientdata(tif);

t2p->outputdisable = 1;

}

static void

t2p_enable(TIFF *tif)

{

T2P *t2p = (T2P*) TIFFClientdata(tif);

t2p->outputdisable = 0;

}

/*

* Procs for TIFFClientOpen

*/

static tmsize_t

t2pReadFile(TIFF *tif, tdata_t data, tmsize_t size)

{

thandle_t client = TIFFClientdata(tif);

TIFFReadWriteProc proc = TIFFGetReadProc(tif);

if (proc)

return proc(client, data, size);

return -1;

}

static tmsize_t

t2pWriteFile(TIFF *tif, tdata_t data, tmsize_t size)

{

thandle_t client = TIFFClientdata(tif);

TIFFReadWriteProc proc = TIFFGetWriteProc(tif);

if (proc)

return proc(client, data, size);

return -1;

}

static uint64

t2pSeekFile(TIFF *tif, toff_t offset, int whence)

{

thandle_t client = TIFFClientdata(tif);

TIFFSeekProc proc = TIFFGetSeekProc(tif);

if (proc)

return proc(client, offset, whence);

return -1;

}

static tmsize_t

t2p_readproc(thandle_t handle, tdata_t data, tmsize_t size)

{

(void) handle, (void) data, (void) size;

return -1;

}

static tmsize_t

t2p_writeproc(thandle_t handle, tdata_t data, tmsize_t size)

{

T2P *t2p = (T2P*) handle;

if (t2p->outputdisable <= 0 && t2p->outputfile) {

tsize_t written = fwrite(data, 1, size, t2p->outputfile);

t2p->outputwritten += written;

return written;

}

return size;

}

static uint64

t2p_seekproc(thandle_t handle, uint64 offset, int whence)

{

T2P *t2p = (T2P*) handle;

if (t2p->outputdisable <= 0 && t2p->outputfile)

return fseek(t2p->outputfile, (long) offset, whence);

return offset;

}

static int

t2p_closeproc(thandle_t handle)

{

(void) handle;

return 0;

}

static uint64

t2p_sizeproc(thandle_t handle)

{

(void) handle;

return -1;

}

static int

t2p_mapproc(thandle_t handle, void **data, toff_t *offset)

{

(void) handle, (void) data, (void) offset;

return -1;

}

static void

t2p_unmapproc(thandle_t handle, void *data, toff_t offset)

{

(void) handle, (void) data, (void) offset;

}

static uint64

checkAdd64(uint64 summand1, uint64 summand2, T2P* t2p)

{

uint64 bytes = summand1 + summand2;

if (bytes - summand1 != summand2) {

TIFFError(TIFF2PDF_MODULE, "Integer overflow");

t2p->t2p_error = T2P_ERR_ERROR;

bytes = 0;

}

return bytes;

}

static uint64

checkMultiply64(uint64 first, uint64 second, T2P* t2p)

{

uint64 bytes = first * second;

if (second && bytes / second != first) {

TIFFError(TIFF2PDF_MODULE, "Integer overflow");

t2p->t2p_error = T2P_ERR_ERROR;

bytes = 0;

}

return bytes;

}

/*

This is the main function.

The program converts one TIFF file to one PDF file, including multiple page

TIFF files, tiled TIFF files, black and white. grayscale, and color TIFF

files that contain data of TIFF photometric interpretations of bilevel,

grayscale, RGB, YCbCr, CMYK separation, and ICC L*a*b* as supported by

libtiff and PDF.

If you have multiple TIFF files to convert into one PDF file then use tiffcp

or other program to concatenate the files into a multiple page TIFF file.

If the input TIFF file is of huge dimensions (greater than 10000 pixels height

or width) convert the input image to a tiled TIFF if it is not already.

The standard output is standard output. Set the output file name with the

"-o output.pdf" option.

All black and white files are compressed into a single strip CCITT G4 Fax

compressed PDF, unless tiled, where tiled black and white images are

compressed into tiled CCITT G4 Fax compressed PDF, libtiff CCITT support

is assumed.

Color and grayscale data can be compressed using either JPEG compression,

ITU-T T.81, or Zip/Deflate LZ77 compression, per PNG 1.2 and RFC 1951. Set

the compression type using the -j or -z options. JPEG compression support

requires that libtiff be configured with JPEG support, and Zip/Deflate

compression support requires that libtiff is configured with Zip support,

in tiffconf.h. Use only one or the other of -j and -z. The -q option

sets the image compression quality, that is 1-100 with libjpeg JPEG

compression and one of 1, 10, 11, 12, 13, 14, or 15 for PNG group compression

predictor methods, add 100, 200, ..., 900 to set zlib compression quality 1-9.

PNG Group differencing predictor methods are not currently implemented.

If the input TIFF contains single strip CCITT G4 Fax compressed information,

then that is written to the PDF file without transcoding, unless the options

of no compression and no passthrough are set, -d and -n.

If the input TIFF contains JPEG or single strip Zip/Deflate compressed

information, and they are configured, then that is written to the PDF file

without transcoding, unless the options of no compression and no passthrough

are set.

The default page size upon which the TIFF image is placed is determined by

the resolution and extent of the image data. Default values for the TIFF

image resolution can be set using the -x and -y options. The page size can

be set using the -p option for paper size, or -w and -l for paper width and

length, then each page of the TIFF image is centered on its page. The

distance unit for default resolution and page width and length can be set

by the -u option, the default unit is inch.

Various items of the output document information can be set with the -e, -c,

-a, -t, -s, and -k tags. Setting the argument of the option to "" for these

tags causes the relevant document information field to be not written. Some

of the document information values otherwise get their information from the

input TIFF image, the software, author, document name, and image description.

The output PDF file conforms to the PDF 1.1 specification or PDF 1.2 if using

Zip/Deflate compression.

The Portable Document Format (PDF) specification is copyrighted by Adobe

Systems, Incorporated. Todos derechos reservados.

Here is a listing of the usage example and the options to the tiff2pdf

program that is part of the libtiff distribution. Options followed by

a colon have a required argument.

usage: tiff2pdf [options] input.tif

options:

-o: output to file name

-j: compress with JPEG (requires libjpeg configured with libtiff)

-z: compress with Zip/Deflate (requires zlib configured with libtiff)

-q: compression quality

-n: no compressed data passthrough

-d: do not compress (decompress)

-i: invert colors

-u: set distance unit, 'i' for inch, 'm' for centimeter

-x: set x resolution default

-y: set y resolution default

-w: width in units

-l: length in units

-r: 'd' for resolution default, 'o' for resolution override

-p: paper size, eg "letter", "legal", "a4"

-F: make the tiff fill the PDF page

-f: set pdf "fit window" user preference

-b: set PDF "Interpolate" user preference

-e: date, overrides image or current date/time default, YYYYMMDDHHMMSS

-c: creator, overrides image software default

-a: author, overrides image artist default

-t: title, overrides image document name default

-s: subject, overrides image image description default

-k: keywords

-h: usage

examples:

tiff2pdf -o output.pdf input.tiff

The above example would generate the file output.pdf from input.tiff.

tiff2pdf input.tiff

The above example would generate PDF output from input.tiff and write it

to standard output.

tiff2pdf -j -p letter -o output.pdf input.tiff

The above example would generate the file output.pdf from input.tiff,

putting the image pages on a letter sized page, compressing the output

with JPEG.

Please report bugs through:

http://bugzilla.remotesensing.org/buglist.cgi?product=libtiff

See also libtiff.3t, tiffcp.

*/

int main(int argc, char** argv){

extern char *optarg;

extern int optind;

const char *outfilename = NULL;

T2P *t2p = NULL;

TIFF *input = NULL, *output = NULL;

int c, ret = EXIT_SUCCESS;

t2p = t2p_init();

if (t2p == NULL){

TIFFError(TIFF2PDF_MODULE, "Can't initialize context");

goto fail;

}

while (argv &&

(c = getopt(argc, argv,

"o:q:u:x:y:w:l:r:p:e:c:a:t:s:k:jzndifbhF")) != -1){

switch (c) {

case 'o':

outfilename = optarg;

break;

#ifdef JPEG_SUPPORT

case 'j':

t2p->pdf_defaultcompression=T2P_COMPRESS_JPEG;

break;

#endif

#ifndef JPEG_SUPPORT

case 'j':

TIFFWarning(

TIFF2PDF_MODULE,

"JPEG support in libtiff required for JPEG compression, ignoring option");

break;

#endif

#ifdef ZIP_SUPPORT

case 'z':

t2p->pdf_defaultcompression=T2P_COMPRESS_ZIP;

break;

#endif

#ifndef ZIP_SUPPORT

case 'z':

TIFFWarning(

TIFF2PDF_MODULE,

"Zip support in libtiff required for Zip compression, ignoring option");

break;

#endif

case 'q':

t2p->pdf_defaultcompressionquality=atoi(optarg);

break;

case 'n':

t2p->pdf_nopassthrough=1;

break;

case 'd':

t2p->pdf_defaultcompression=T2P_COMPRESS_NONE;

break;

case 'u':

if(optarg[0]=='m'){

t2p->pdf_centimeters=1;

}

break;

case 'x':

t2p->pdf_defaultxres =

(float)atof(optarg) / (t2p->pdf_centimeters?2.54F:1.0F);

break;

case 'y':

t2p->pdf_defaultyres =

(float)atof(optarg) / (t2p->pdf_centimeters?2.54F:1.0F);

break;

case 'w':

t2p->pdf_overridepagesize=1;

t2p->pdf_defaultpagewidth =

((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);

break;

case 'l':

t2p->pdf_overridepagesize=1;

t2p->pdf_defaultpagelength =

((float)atof(optarg) * PS_UNIT_SIZE) / (t2p->pdf_centimeters?2.54F:1.0F);

break;

case 'r':

if(optarg[0]=='o'){

t2p->pdf_overrideres=1;

}

break;

case 'p':

if(tiff2pdf_match_paper_size(

&(t2p->pdf_defaultpagewidth),

&(t2p->pdf_defaultpagelength),

optarg)){

t2p->pdf_overridepagesize=1;

} else {

TIFFWarning(TIFF2PDF_MODULE,

"Unknown paper size %s, ignoring option",

optarg);

}

break;

case 'i':

t2p->pdf_colorspace_invert=1;

break;

case 'F':

t2p->pdf_image_fillpage = 1;

break;

case 'f':

t2p->pdf_fitwindow=1;

break;

case 'e':

if (strlen(optarg) == 0) {

t2p->pdf_datetime[0] = '\0';

} else {

t2p->pdf_datetime[0] = 'D';

t2p->pdf_datetime[1] = ':';

strncpy(t2p->pdf_datetime + 2, optarg,

sizeof(t2p->pdf_datetime) - 3);

t2p->pdf_datetime[sizeof(t2p->pdf_datetime) - 1] = '\0';

}

break;

case 'c':

strncpy(t2p->pdf_creator, optarg, sizeof(t2p->pdf_creator) - 1);

t2p->pdf_creator[sizeof(t2p->pdf_creator) - 1] = '\0';

break;

case 'a':

strncpy(t2p->pdf_author, optarg, sizeof(t2p->pdf_author) - 1);

t2p->pdf_author[sizeof(t2p->pdf_author) - 1] = '\0';

break;

case 't':

strncpy(t2p->pdf_title, optarg, sizeof(t2p->pdf_title) - 1);

t2p->pdf_title[sizeof(t2p->pdf_title) - 1] = '\0';

break;

case 's':

strncpy(t2p->pdf_subject, optarg, sizeof(t2p->pdf_subject) - 1);

t2p->pdf_subject[sizeof(t2p->pdf_subject) - 1] = '\0';

break;

case 'k':

strncpy(t2p->pdf_keywords, optarg, sizeof(t2p->pdf_keywords) - 1);

t2p->pdf_keywords[sizeof(t2p->pdf_keywords) - 1] = '\0';

break;

case 'b':

t2p->pdf_image_interpolate = 1;

break;

case 'h':

case '?':

tiff2pdf_usage();

goto success;

break;

}

}

/*

* Input

*/

if(argc > optind) {

input = TIFFOpen(argv[optind++], "r");

if (input==NULL) {

TIFFError(TIFF2PDF_MODULE,

"Can't open input file %s for reading",

argv[optind-1]);

goto fail;

}

} else {

TIFFError(TIFF2PDF_MODULE, "No input file specified");

tiff2pdf_usage();

goto fail;

}

if(argc > optind) {

TIFFError(TIFF2PDF_MODULE,

"No support for multiple input files");

tiff2pdf_usage();

goto fail;

}

/*

* Output

*/

t2p->outputdisable = 0;

if (outfilename) {

t2p->outputfile = fopen(outfilename, "wb");

if (t2p->outputfile == NULL) {

TIFFError(TIFF2PDF_MODULE,

"Can't open output file %s for writing",

outfilename);

goto fail;

}

} else {

outfilename = "-";

t2p->outputfile = stdout;

}

output = TIFFClientOpen(outfilename, "w", (thandle_t) t2p,

t2p_readproc, t2p_writeproc, t2p_seekproc,

t2p_closeproc, t2p_sizeproc,

t2p_mapproc, t2p_unmapproc);

if (output == NULL) {

TIFFError(TIFF2PDF_MODULE,

"Can't initialize output descriptor");

goto fail;

}

/*

* Validate

*/

t2p_validate(t2p);

t2pSeekFile(output, (toff_t) 0, SEEK_SET);

/*

* Write

*/

t2p_write_pdf(t2p, input, output);

if (t2p->t2p_error != 0) {

TIFFError(TIFF2PDF_MODULE,

"An error occurred creating output PDF file");

goto fail;

}

goto success;

fail:

ret = EXIT_FAILURE;

success:

if(input != NULL)

TIFFClose(input);

if (output != NULL)

TIFFClose(output);

if (t2p != NULL)

t2p_free(t2p);

return ret;

}

void tiff2pdf_usage(){

char* lines[]={

"usage: tiff2pdf [options] input.tiff",

"options:",

" -o: output to file name",

#ifdef JPEG_SUPPORT

" -j: compress with JPEG",

#endif

#ifdef ZIP_SUPPORT

" -z: compress with Zip/Deflate",

#endif

" -q: compression quality",

" -n: no compressed data passthrough",

" -d: do not compress (decompress)",

" -i: invert colors",

" -u: set distance unit, 'i' for inch, 'm' for centimeter",

" -x: set x resolution default in dots per unit",

" -y: set y resolution default in dots per unit",

" -w: width in units",

" -l: length in units",

" -r: 'd' for resolution default, 'o' for resolution override",

" -p: paper size, eg \"letter\", \"legal\", \"A4\"",

" -F: make the tiff fill the PDF page",

" -f: set PDF \"Fit Window\" user preference",

" -e: date, overrides image or current date/time default, YYYYMMDDHHMMSS",

" -c: sets document creator, overrides image software default",

" -a: sets document author, overrides image artist default",

" -t: sets document title, overrides image document name default",

" -s: sets document subject, overrides image image description default",

" -k: sets document keywords",

" -b: set PDF \"Interpolate\" user preference",

" -h: usage",

NULL

};

int i=0;

fprintf(stderr, "%s\n\n", TIFFGetVersion());

for (i=0;lines[i]!=NULL;i++){

fprintf(stderr, "%s\n", lines[i]);

}

return;

}

int tiff2pdf_match_paper_size(float* width, float* length, char* papersize){

size_t i, len;

const char* sizes[]={

"LETTER", "A4", "LEGAL",

"EXECUTIVE", "LETTER", "LEGAL", "LEDGER", "TABLOID",

"A", "B", "C", "D", "E", "F", "G", "H", "J", "K",

"A10", "A9", "A8", "A7", "A6", "A5", "A4", "A3", "A2", "A1", "A0",

"2A0", "4A0", "2A", "4A",

"B10", "B9", "B8", "B7", "B6", "B5", "B4", "B3", "B2", "B1", "B0",

"JISB10", "JISB9", "JISB8", "JISB7", "JISB6", "JISB5", "JISB4",

"JISB3", "JISB2", "JISB1", "JISB0",

"C10", "C9", "C8", "C7", "C6", "C5", "C4", "C3", "C2", "C1", "C0",

"RA2", "RA1", "RA0", "SRA4", "SRA3", "SRA2", "SRA1", "SRA0",

"A3EXTRA", "A4EXTRA",

"STATEMENT", "FOLIO", "QUARTO",

NULL

} ;

const int widths[]={

612, 595, 612,

522, 612,612,792,792,

612,792,1224,1584,2448,2016,792,2016,2448,2880,

74,105,147,210,298,420,595,842,1191,1684,2384,3370,4768,3370,4768,

88,125,176,249,354,499,709,1001,1417,2004,2835,

91,128,181,258,363,516,729,1032,1460,2064,2920,

79,113,162,230,323,459,649,918,1298,1298,2599,

1219,1729,2438,638,907,1276,1814,2551,

914,667,

396, 612, 609,

0

};

const int lengths[]={

792,842,1008,

756,792,1008,1224,1224,

792,1224,1584,2448,3168,2880,6480,10296,12672,10296,

105,147,210,298,420,595,842,1191,1684,2384,3370,4768,6741,4768,6741,

125,176,249,354,499,709,1001,1417,2004,2835,4008,

128,181,258,363,516,729,1032,1460,2064,2920,4127,

113,162,230,323,459,649,918,1298,1837,1837,3677,

1729,2438,3458,907,1276,1814,2551,3628,

1262,914,

612, 936, 780,

0

};

len=strlen(papersize);

for(i=0;i<len;i++){

papersize[i]=toupper(papersize[i]);

}

for(i=0;sizes[i]!=NULL; i++){

if (strcmp( (const char*)papersize, sizes[i])==0){

*width=(float)widths[i];

*length=(float)lengths[i];

return(1);

}

}

return(0);

}

/*

* This function allocates and initializes a T2P context struct pointer.

*/

T2P* t2p_init()

{

T2P* t2p = (T2P*) _TIFFmalloc(sizeof(T2P));

if(t2p==NULL){

TIFFError(

TIFF2PDF_MODULE,

"Can't allocate %lu bytes of memory for t2p_init",

(unsigned long) sizeof(T2P));

return( (T2P*) NULL );

}

_TIFFmemset(t2p, 0x00, sizeof(T2P));

t2p->pdf_majorversion=1;

t2p->pdf_minorversion=1;

t2p->pdf_defaultxres=300.0;

t2p->pdf_defaultyres=300.0;

t2p->pdf_defaultpagewidth=612.0;

t2p->pdf_defaultpagelength=792.0;

t2p->pdf_xrefcount=3; /* Catalog, Info, Pages */

return(t2p);

}

/*

* This function frees a T2P context struct pointer and any allocated data fields of it.

*/

void t2p_free(T2P* t2p)

{

int i = 0;

if (t2p != NULL) {

if(t2p->pdf_xrefoffsets != NULL){

_TIFFfree( (tdata_t) t2p->pdf_xrefoffsets);

}

if(t2p->tiff_pages != NULL){

_TIFFfree( (tdata_t) t2p->tiff_pages);

}

for(i=0;i<t2p->tiff_pagecount;i++){

if(t2p->tiff_tiles[i].tiles_tiles != NULL){

_TIFFfree( (tdata_t) t2p->tiff_tiles[i].tiles_tiles);

}

}

if(t2p->tiff_tiles != NULL){

_TIFFfree( (tdata_t) t2p->tiff_tiles);

}

if(t2p->pdf_palette != NULL){

_TIFFfree( (tdata_t) t2p->pdf_palette);

}

#ifdef OJPEG_SUPPORT

if(t2p->pdf_ojpegdata != NULL){

_TIFFfree( (tdata_t) t2p->pdf_ojpegdata);

}

#endif

_TIFFfree( (tdata_t) t2p );

}

return;

}

/*

This function validates the values of a T2P context struct pointer

before calling t2p_write_pdf with it.

*/

void t2p_validate(T2P* t2p){

#ifdef JPEG_SUPPORT

if(t2p->pdf_defaultcompression==T2P_COMPRESS_JPEG){

if(t2p->pdf_defaultcompressionquality>100 ||

t2p->pdf_defaultcompressionquality<1){

t2p->pdf_defaultcompressionquality=0;

}

}

#endif

#ifdef ZIP_SUPPORT

if(t2p->pdf_defaultcompression==T2P_COMPRESS_ZIP){

uint16 m=t2p->pdf_defaultcompressionquality%100;

if(t2p->pdf_defaultcompressionquality/100 > 9 ||