/* $Id: tiffcrop.c,v 1.20 2010-12-14 02:03:24 faxguy Exp $ */

/* tiffcrop.c -- a port of tiffcp.c extended to include manipulations of

 * the image data through additional options listed below

 *

 * Original code:

 * Copyright (c) 1988-1997 Sam Leffler

 * Copyright (c) 1991-1997 Silicon Graphics, Inc.

 * Additions (c) Richard Nolde 2006-2010 

 *

 * 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 names of

 * Sam Leffler and Silicon Graphics may not be used in any advertising or

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

 * permission of Sam Leffler and Silicon Graphics.

 * 

 * 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 SAM LEFFLER OR SILICON GRAPHICS OR ANY OTHER COPYRIGHT  

 * HOLDERS 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.

 *

 * Some portions of the current code are derived from tiffcp, primarly in 

 * the areas of lowlevel reading and writing of TAGS, scanlines and tiles though

 * some of the original functions have been extended to support arbitrary bit

 * depths. These functions are presented at the top of this file.

 *

 * Add support for the options below to extract sections of image(s) 

 * and to modify the whole image or selected portions of each image by

 * rotations, mirroring, and colorscale/colormap inversion of selected

 * types of TIFF images when appropriate. Some color model dependent 

 * functions are restricted to bilevel or 8 bit per sample data.

 * See the man page for the full explanations.

 *

 * New Options: 

 * -h             Display the syntax guide.

 * -v             Report the version and last build date for tiffcrop and libtiff.

 * -z x1,y1,x2,y2:x3,y3,x4,y4:..xN,yN,xN + 1, yN + 1 

 *                Specify a series of coordinates to define rectangular

 *                regions by the top left and lower right corners.

 * -e c|d|i|m|s   export mode for images and selections from input images

 *   combined     All images and selections are written to a single file (default)

 *                with multiple selections from one image combined into a single image

 *   divided      All images and selections are written to a single file

 *                with each selection from one image written to a new image

 *   image        Each input image is written to a new file (numeric filename sequence)

 *                with multiple selections from the image combined into one image

 *   multiple     Each input image is written to a new file (numeric filename sequence)

 *                with each selection from the image written to a new image

 *   separated    Individual selections from each image are written to separate files

 * -U units       [in, cm, px ] inches, centimeters or pixels

 * -H #           Set horizontal resolution of output images to #

 * -V #           Set vertical resolution of output images to #

 * -J #           Horizontal margin of output page to # expressed in current

 *                units when sectioning image into columns x rows 

 *                using the -S cols:rows option.

 * -K #           Vertical margin of output page to # expressed in current

 *                units when sectioning image into columns x rows

 *                using the -S cols:rows option.

 * -X #           Horizontal dimension of region to extract expressed in current

 *                units

 * -Y #           Vertical dimension of region to extract expressed in current

 *                units

 * -O orient      Orientation for output image, portrait, landscape, auto

 * -P page        Page size for output image segments, eg letter, legal, tabloid,

 *                etc.

 * -S cols:rows   Divide the image into equal sized segments using cols across

 *                and rows down

 * -E t|l|r|b     Edge to use as origin

 * -m #,#,#,#     Margins from edges for selection: top, left, bottom, right

 *                (commas separated)

 * -Z #:#,#:#     Zones of the image designated as zone X of Y, 

 *                eg 1:3 would be first of three equal portions measured

 *                from reference edge

 * -N odd|even|#,#-#,#|last 

 *                Select sequences and/or ranges of images within file

 *                to process. The words odd or even may be used to specify

 *                all odd or even numbered images the word last may be used

 *                in place of a number in the sequence to indicate the final

 *                image in the file without knowing how many images there are.

 * -R #           Rotate image or crop selection by 90,180,or 270 degrees

 *                clockwise  

 * -F h|v         Flip (mirror) image or crop selection horizontally

 *                or vertically 

 * -I [black|white|data|both]

 *                Invert color space, eg dark to light for bilevel and grayscale images

 *                If argument is white or black, set the PHOTOMETRIC_INTERPRETATION 

 *                tag to MinIsBlack or MinIsWhite without altering the image data

 *                If the argument is data or both, the image data are modified:

 *                both inverts the data and the PHOTOMETRIC_INTERPRETATION tag,

 *                data inverts the data but not the PHOTOMETRIC_INTERPRETATION tag

 * -D input:<filename1>,output:<filename2>,format:<raw|txt>,level:N,debug:N

 *                Dump raw data for input and/or output images to individual files

 *                in raw (binary) format or text (ASCII) representing binary data

 *                as strings of 1s and 0s. The filename arguments are used as stems

 *                from which individual files are created for each image. Text format

 *                includes annotations for image parameters and scanline info. Level

 *                selects which functions dump data, with higher numbers selecting

 *                lower level, scanline level routines. Debug reports a limited set

 *                of messages to monitor progess without enabling dump logs.

 */

static   char tiffcrop_version_id[] = "2.4";

static   char tiffcrop_rev_date[] = "12-13-2010";

#include "tif_config.h"

#include "tiffiop.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <ctype.h>

#include <limits.h>

#include <sys/stat.h>

#include <assert.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

#ifdef HAVE_STDINT_H

# include <stdint.h>

#endif

#ifndef HAVE_GETOPT

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

#endif

#ifdef NEED_LIBPORT

# include "libport.h"

#endif

#include "tiffio.h"

#if defined(VMS)

# define unlink delete

#endif

#ifndef PATH_MAX

#define PATH_MAX 1024

#endif

#ifndef streq

#define	streq(a,b)	(strcmp((a),(b)) == 0)

#endif

#define	strneq(a,b,n)	(strncmp((a),(b),(n)) == 0)

#define	TRUE	1

#define	FALSE	0

#ifndef TIFFhowmany

#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y)))

#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)

#endif

/*

 * Definitions and data structures required to support cropping and image

 * manipulations.

 */

#define EDGE_TOP      1

#define EDGE_LEFT     2

#define EDGE_BOTTOM   3

#define EDGE_RIGHT    4

#define EDGE_CENTER   5

#define MIRROR_HORIZ  1

#define MIRROR_VERT   2

#define MIRROR_BOTH   3

#define ROTATECW_90   8

#define ROTATECW_180 16

#define ROTATECW_270 32

#define ROTATE_ANY ROTATECW_90 || ROTATECW_180 || ROTATECW_270 

#define CROP_NONE     0

#define CROP_MARGINS  1

#define CROP_WIDTH    2

#define CROP_LENGTH   4

#define CROP_ZONES    8

#define CROP_REGIONS 16

#define CROP_ROTATE  32

#define CROP_MIRROR  64

#define CROP_INVERT 128

/* Modes for writing out images and selections */

#define ONE_FILE_COMPOSITE       0 /* One file, sections combined sections */

#define ONE_FILE_SEPARATED       1 /* One file, sections to new IFDs */

#define FILE_PER_IMAGE_COMPOSITE 2 /* One file per image, combined sections */

#define FILE_PER_IMAGE_SEPARATED 3 /* One file per input image */

#define FILE_PER_SELECTION       4 /* One file per selection */

#define COMPOSITE_IMAGES         0 /* Selections combined into one image */  

#define SEPARATED_IMAGES         1 /* Selections saved to separate images */

#define STRIP    1

#define TILE     2

#define MAX_REGIONS   8  /* number of regions to extract from a single page */

#define MAX_OUTBUFFS  8  /* must match larger of zones or regions */

#define MAX_SECTIONS 32  /* number of sections per page to write to output */

#define MAX_IMAGES 2048  /* number of images in descrete list, not in the file */

#define MAX_SAMPLES   8  /* maximum number of samples per pixel supported */

#define MAX_BITS_PER_SAMPLE 64 /* maximum bit depth supported */

#define MAX_EXPORT_PAGES 999999  /* maximum number of export pages per file */

#define DUMP_NONE   0

#define DUMP_TEXT   1

#define DUMP_RAW    2

/* Offsets into buffer for margins and fixed width and length segments */

struct offset {

  uint32  tmargin;

  uint32  lmargin;

  uint32  bmargin;

  uint32  rmargin;

  uint32  crop_width;

  uint32  crop_length;

  uint32  startx;

  uint32  endx;

  uint32  starty;

  uint32  endy;

};

/* Description of a zone within the image. Position 1 of 3 zones would be 

 * the first third of the image. These are computed after margins and 

 * width/length requests are applied so that you can extract multiple 

 * zones from within a larger region for OCR or barcode recognition.

 */

struct  buffinfo {

  uint32 size;           /* size of this buffer */

  unsigned char *buffer; /* address of the allocated buffer */

};

struct  zone {

  int   position;  /* ordinal of segment to be extracted */

  int   total;     /* total equal sized divisions of crop area */

  };

struct  pageseg {

  uint32 x1;        /* index of left edge */

  uint32 x2;        /* index of right edge */

  uint32 y1;        /* index of top edge */

  uint32 y2;        /* index of bottom edge */

  int    position;  /* ordinal of segment to be extracted */

  int    total;     /* total equal sized divisions of crop area */

  uint32 buffsize;  /* size of buffer needed to hold the cropped zone */

};

struct  coordpairs {

  double X1;        /* index of left edge in current units */

  double X2;        /* index of right edge in current units */

  double Y1;        /* index of top edge in current units */

  double Y2;        /* index of bottom edge in current units */

};

struct  region {

  uint32 x1;        /* pixel offset of left edge */

  uint32 x2;        /* pixel offset of right edge */

  uint32 y1;        /* pixel offset of top edge */

  uint32 y2;        /* picel offset of bottom edge */

  uint32 width;     /* width in pixels */

  uint32 length;    /* length in pixels */

  uint32 buffsize;  /* size of buffer needed to hold the cropped region */

  unsigned char *buffptr; /* address of start of the region */

};

/* Cropping parameters from command line and image data 

 * Note: This should be renamed to proc_opts and expanded to include all current globals

 * if possible, but each function that accesses global variables will have to be redone.

 */

struct crop_mask {

  double width;           /* Selection width for master crop region in requested units */

  double length;          /* Selection length for master crop region in requesed units */

  double margins[4];      /* Top, left, bottom, right margins */

  float  xres;            /* Horizontal resolution read from image*/

  float  yres;            /* Vertical resolution read from image */

  uint32 combined_width;  /* Width of combined cropped zones */

  uint32 combined_length; /* Length of combined cropped zones */

  uint32 bufftotal;       /* Size of buffer needed to hold all the cropped region */

  uint16 img_mode;        /* Composite or separate images created from zones or regions */

  uint16 exp_mode;        /* Export input images or selections to one or more files */

  uint16 crop_mode;       /* Crop options to be applied */

  uint16 res_unit;        /* Resolution unit for margins and selections */

  uint16 edge_ref;        /* Reference edge for sections extraction and combination */

  uint16 rotation;        /* Clockwise rotation of the extracted region or image */

  uint16 mirror;          /* Mirror extracted region or image horizontally or vertically */

  uint16 invert;          /* Invert the color map of image or region */

  uint16 photometric;     /* Status of photometric interpretation for inverted image */

  uint16 selections;      /* Number of regions or zones selected */

  uint16 regions;         /* Number of regions delimited by corner coordinates */

  struct region regionlist[MAX_REGIONS]; /* Regions within page or master crop region */

  uint16 zones;           /* Number of zones delimited by Ordinal:Total requested */

  struct zone zonelist[MAX_REGIONS]; /* Zones indices to define a region */

  struct coordpairs corners[MAX_REGIONS]; /* Coordinates of upper left and lower right corner */

};

#define MAX_PAPERNAMES 49

#define MAX_PAPERNAME_LENGTH 15

#define DEFAULT_RESUNIT      RESUNIT_INCH

#define DEFAULT_PAGE_HEIGHT   14.0

#define DEFAULT_PAGE_WIDTH     8.5

#define DEFAULT_RESOLUTION   300

#define DEFAULT_PAPER_SIZE  "legal"

#define ORIENTATION_NONE       0

#define ORIENTATION_PORTRAIT   1

#define ORIENTATION_LANDSCAPE  2

#define ORIENTATION_SEASCAPE   4

#define ORIENTATION_AUTO      16

#define PAGE_MODE_NONE         0

#define PAGE_MODE_RESOLUTION   1

#define PAGE_MODE_PAPERSIZE    2

#define PAGE_MODE_MARGINS      4

#define PAGE_MODE_ROWSCOLS     8

#define INVERT_DATA_ONLY      10

#define INVERT_DATA_AND_TAG   11

struct paperdef {

  char   name[MAX_PAPERNAME_LENGTH];

  double width;

  double length;

  double asratio;

  };

/* European page sizes corrected from update sent by 

 * thomas . jarosch @ intra2net . com on 5/7/2010

 * Paper Size       Width   Length  Aspect Ratio */

struct paperdef PaperTable[MAX_PAPERNAMES] = {

  {"default",         8.500,  14.000,  0.607},

  {"pa4",             8.264,  11.000,  0.751},

  {"letter",          8.500,  11.000,  0.773},

  {"legal",           8.500,  14.000,  0.607},

  {"half-letter",     8.500,   5.514,  1.542},

  {"executive",       7.264,  10.528,  0.690},

  {"tabloid",        11.000,  17.000,  0.647},

  {"11x17",          11.000,  17.000,  0.647},

  {"ledger",         17.000,  11.000,  1.545},

  {"archa",           9.000,  12.000,  0.750},

  {"archb",          12.000,  18.000,  0.667},

  {"archc",          18.000,  24.000,  0.750},

  {"archd",          24.000,  36.000,  0.667},

  {"arche",          36.000,  48.000,  0.750},

  {"csheet",         17.000,  22.000,  0.773},

  {"dsheet",         22.000,  34.000,  0.647},

  {"esheet",         34.000,  44.000,  0.773},

  {"superb",         11.708,  17.042,  0.687},

  {"commercial",      4.139,   9.528,  0.434},

  {"monarch",         3.889,   7.528,  0.517},

  {"envelope-dl",     4.333,   8.681,  0.499},

  {"envelope-c5",     6.389,   9.028,  0.708},

  {"europostcard",    4.139,   5.833,  0.710},

  {"a0",             33.110,  46.811,  0.707},

  {"a1",             23.386,  33.110,  0.706},

  {"a2",             16.535,  23.386,  0.707},

  {"a3",             11.693,  16.535,  0.707},

  {"a4",              8.268,  11.693,  0.707},

  {"a5",              5.827,   8.268,  0.705},

  {"a6",              4.134,   5.827,  0.709},

  {"a7",              2.913,   4.134,  0.705},

  {"a8",              2.047,   2.913,  0.703},

  {"a9",              1.457,   2.047,  0.712},

  {"a10",             1.024,   1.457,  0.703},

  {"b0",             39.370,  55.669,  0.707},

  {"b1",             27.835,  39.370,  0.707},

  {"b2",             19.685,  27.835,  0.707},

  {"b3",             13.898,  19.685,  0.706},

  {"b4",              9.843,  13.898,  0.708},

  {"b5",              6.929,   9.843,  0.704},

  {"b6",              4.921,   6.929,  0.710},

  {"c0",             36.102,  51.063,  0.707},

  {"c1",             25.512,  36.102,  0.707},

  {"c2",             18.031,  25.512,  0.707},

  {"c3",             12.756,  18.031,  0.707},

  {"c4",              9.016,  12.756,  0.707},

  {"c5",              6.378,   9.016,  0.707},

  {"c6",              4.488,   6.378,  0.704},

  {"",                0.000,   0.000,  1.000}

};

/* Structure to define input image parameters */

struct image_data {

  float  xres;

  float  yres;

  uint32 width;

  uint32 length;

  uint16 res_unit;

  uint16 bps;

  uint16 spp;

  uint16 planar;

  uint16 photometric;

  uint16 orientation;

  uint16 compression;

  uint16 adjustments;

};

/* Structure to define the output image modifiers */

struct pagedef {

  char          name[16];

  double        width;    /* width in pixels */

  double        length;   /* length in pixels */

  double        hmargin;  /* margins to subtract from width of sections */

  double        vmargin;  /* margins to subtract from height of sections */

  double        hres;     /* horizontal resolution for output */

  double        vres;     /* vertical resolution for output */

  uint32        mode;     /* bitmask of modifiers to page format */

  uint16        res_unit; /* resolution unit for output image */

  unsigned int  rows;     /* number of section rows */

  unsigned int  cols;     /* number of section cols */

  unsigned int  orient;   /* portrait, landscape, seascape, auto */

};

struct dump_opts {

  int  debug;

  int  format;

  int  level;

  char mode[4];

  char infilename[PATH_MAX + 1];

  char outfilename[PATH_MAX + 1];

  FILE *infile;

  FILE *outfile;

  };

/* globals */

static int    outtiled = -1;

static uint32 tilewidth = 0;

static uint32 tilelength = 0;

static uint16 config = 0;

static uint16 compression = 0;

static uint16 predictor = 0;

static uint16 fillorder = 0;

static uint32 rowsperstrip = 0;

static uint32 g3opts = 0;

static int    ignore = FALSE;		/* if true, ignore read errors */

static uint32 defg3opts = (uint32) -1;

static int    quality = 100;		/* JPEG quality */

/* static int    jpegcolormode = -1;        was JPEGCOLORMODE_RGB;  */

static int    jpegcolormode = JPEGCOLORMODE_RGB;

static uint16 defcompression = (uint16) -1;

static uint16 defpredictor = (uint16) -1;

static int    pageNum = 0;

static int    little_endian = 1;

/* Functions adapted from tiffcp with additions or significant modifications */

static int  readContigStripsIntoBuffer   (TIFF*, uint8*);

static int  readSeparateStripsIntoBuffer (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);

static int  readContigTilesIntoBuffer    (TIFF*, uint8*, uint32, uint32, uint32, uint32, tsample_t, uint16);

static int  readSeparateTilesIntoBuffer  (TIFF*, uint8*, uint32, uint32, uint32, uint32, tsample_t, uint16);

static int  writeBufferToContigStrips    (TIFF*, uint8*, uint32);

static int  writeBufferToContigTiles     (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);

static int  writeBufferToSeparateStrips  (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);

static int  writeBufferToSeparateTiles   (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);

static int  extractContigSamplesToBuffer (uint8 *, uint8 *, uint32, uint32, tsample_t, 

                                         uint16, uint16, struct dump_opts *);

static int processCompressOptions(char*);

static void usage(void);

/* All other functions by Richard Nolde,  not found in tiffcp */

static void initImageData (struct image_data *);

static void initCropMasks (struct crop_mask *);

static void initPageSetup (struct pagedef *, struct pageseg *, struct buffinfo []);

static void initDumpOptions(struct dump_opts *);

/* Command line and file naming functions */

void  process_command_opts (int, char *[], char *, char *, uint32 *,

	                    uint16 *, uint16 *, uint32 *, uint32 *, uint32 *,

		            struct crop_mask *, struct pagedef *, 

                            struct dump_opts *, 

                            unsigned int *, unsigned int *);

static  int update_output_file (TIFF **, char *, int, char *, unsigned int *);

/*  * High level functions for whole image manipulation */

static int  get_page_geometry (char *, struct pagedef*);

static int  computeInputPixelOffsets(struct crop_mask *, struct image_data *, 

                                     struct offset *);

static int  computeOutputPixelOffsets (struct crop_mask *, struct image_data *,

				       struct pagedef *, struct pageseg *,

                                       struct dump_opts *);

static int  loadImage(TIFF *, struct image_data *, struct dump_opts *, unsigned char **);

static int  correct_orientation(struct image_data *, unsigned char **);

static int  getCropOffsets(struct image_data *, struct crop_mask *, struct dump_opts *);

static int  processCropSelections(struct image_data *, struct crop_mask *, 

                                  unsigned char **, struct buffinfo []);

static int  writeSelections(TIFF *, TIFF **, struct crop_mask *, struct image_data *,

                            struct dump_opts *, struct buffinfo [],

                            char *, char *, unsigned int*, unsigned int);

/* Section functions */

static int  createImageSection(uint32, unsigned char **);

static int  extractImageSection(struct image_data *, struct pageseg *, 

                                unsigned char *, unsigned char *);

static int  writeSingleSection(TIFF *, TIFF *, struct image_data *,

                               struct dump_opts *, uint32, uint32,

			       double, double, unsigned char *);

static int  writeImageSections(TIFF *, TIFF *, struct image_data *,

                               struct pagedef *, struct pageseg *, 

                               struct dump_opts *, unsigned char *, 

                               unsigned char **);

/* Whole image functions */

static int  createCroppedImage(struct image_data *, struct crop_mask *, 

                               unsigned char **, unsigned char **);

static int  writeCroppedImage(TIFF *, TIFF *, struct image_data *image,

                              struct dump_opts * dump,

                              uint32, uint32, unsigned char *, int, int);

/* Image manipulation functions */

static int rotateContigSamples8bits(uint16, uint16, uint16, uint32, 

                                    uint32,   uint32, uint8 *, uint8 *);

static int rotateContigSamples16bits(uint16, uint16, uint16, uint32, 

                                     uint32,   uint32, uint8 *, uint8 *);

static int rotateContigSamples24bits(uint16, uint16, uint16, uint32, 

                                     uint32,   uint32, uint8 *, uint8 *);

static int rotateContigSamples32bits(uint16, uint16, uint16, uint32, 

                                     uint32,   uint32, uint8 *, uint8 *);

static int rotateImage(uint16, struct image_data *, uint32 *, uint32 *,

 		       unsigned char **);

static int mirrorImage(uint16, uint16, uint16, uint32, uint32,

		       unsigned char *);

static int invertImage(uint16, uint16, uint16, uint32, uint32,

		       unsigned char *);

/* Functions to reverse the sequence of samples in a scanline */

static int reverseSamples8bits  (uint16, uint16, uint32, uint8 *, uint8 *);

static int reverseSamples16bits (uint16, uint16, uint32, uint8 *, uint8 *);

static int reverseSamples24bits (uint16, uint16, uint32, uint8 *, uint8 *);

static int reverseSamples32bits (uint16, uint16, uint32, uint8 *, uint8 *);

static int reverseSamplesBytes  (uint16, uint16, uint32, uint8 *, uint8 *);

/* Functions for manipulating individual samples in an image */

static int extractSeparateRegion(struct image_data *, struct crop_mask *,

		 		 unsigned char *, unsigned char *, int);

static int extractCompositeRegions(struct image_data *,  struct crop_mask *,

				   unsigned char *, unsigned char *);

static int extractContigSamples8bits (uint8 *, uint8 *, uint32,

 	                             tsample_t, uint16, uint16, 

                                     tsample_t, uint32, uint32);

static int extractContigSamples16bits (uint8 *, uint8 *, uint32,

 	                              tsample_t, uint16, uint16, 

                                      tsample_t, uint32, uint32);

static int extractContigSamples24bits (uint8 *, uint8 *, uint32,

 	                              tsample_t, uint16, uint16, 

                                      tsample_t, uint32, uint32);

static int extractContigSamples32bits (uint8 *, uint8 *, uint32,

	                              tsample_t, uint16, uint16, 

                                      tsample_t, uint32, uint32);

static int extractContigSamplesBytes (uint8 *, uint8 *, uint32, 

                                      tsample_t, uint16, uint16, 

				      tsample_t, uint32, uint32);

static int extractContigSamplesShifted8bits (uint8 *, uint8 *, uint32,

 	                                     tsample_t, uint16, uint16,

                                             tsample_t, uint32, uint32,

                                             int);

static int extractContigSamplesShifted16bits (uint8 *, uint8 *, uint32,

 	                                      tsample_t, uint16, uint16, 

				              tsample_t, uint32, uint32,

                                              int);

static int extractContigSamplesShifted24bits (uint8 *, uint8 *, uint32,

 	                                      tsample_t, uint16, uint16, 

				              tsample_t, uint32, uint32,

                                              int);

static int extractContigSamplesShifted32bits (uint8 *, uint8 *, uint32,

	                                      tsample_t, uint16, uint16, 

				              tsample_t, uint32, uint32,

                                              int);

static int extractContigSamplesToTileBuffer(uint8 *, uint8 *, uint32, uint32,

  	                                    uint32, uint32, tsample_t, uint16,

					    uint16, uint16, struct dump_opts *);

/* Functions to combine separate planes into interleaved planes */

static int combineSeparateSamples8bits (uint8 *[], uint8 *, uint32, uint32,

                                        uint16, uint16, FILE *, int, int);

static int combineSeparateSamples16bits (uint8 *[], uint8 *, uint32, uint32,

                                         uint16, uint16, FILE *, int, int);

static int combineSeparateSamples24bits (uint8 *[], uint8 *, uint32, uint32,

                                         uint16, uint16, FILE *, int, int);

static int combineSeparateSamples32bits (uint8 *[], uint8 *, uint32, uint32,

                                         uint16, uint16, FILE *, int, int);

static int combineSeparateSamplesBytes (unsigned char *[], unsigned char *,

					uint32, uint32, tsample_t, uint16,

                                        FILE *, int, int);

static int combineSeparateTileSamples8bits (uint8 *[], uint8 *, uint32, uint32,

                                            uint32, uint32, uint16, uint16, 

                                            FILE *, int, int);

static int combineSeparateTileSamples16bits (uint8 *[], uint8 *, uint32, uint32,

                                             uint32, uint32, uint16, uint16,

                                             FILE *, int, int);

static int combineSeparateTileSamples24bits (uint8 *[], uint8 *, uint32, uint32,

                                             uint32, uint32, uint16, uint16,

                                             FILE *, int, int);

static int combineSeparateTileSamples32bits (uint8 *[], uint8 *, uint32, uint32,

                                             uint32, uint32, uint16, uint16,

                                             FILE *, int, int);

static int combineSeparateTileSamplesBytes (unsigned char *[], unsigned char *,

			  		    uint32, uint32, uint32, uint32, 

                                            tsample_t, uint16, FILE *, int, int);

/* Dump functions for debugging */

static void dump_info  (FILE *, int, char *, char *, ...);

static int  dump_data  (FILE *, int, char *, unsigned char *, uint32);

static int  dump_byte  (FILE *, int, char *, unsigned char);

static int  dump_short (FILE *, int, char *, uint16);

static int  dump_long  (FILE *, int, char *, uint32);

static int  dump_wide  (FILE *, int, char *, uint64);

static int  dump_buffer (FILE *, int, uint32, uint32, uint32, unsigned char *);

/* End function declarations */

/* Functions derived in whole or in part from tiffcp */

/* The following functions are taken largely intact from tiffcp */

static   char* usage_info[] = {

"usage: tiffcrop [options] source1 ... sourceN  destination",

"where options are:",

" -h		Print this syntax listing",

" -v		Print tiffcrop version identifier and last revision date",

" ",

" -a		Append to output instead of overwriting",

" -d offset	Set initial directory offset, counting first image as one, not zero",

" -p contig	Pack samples contiguously (e.g. RGBRGB...)",

" -p separate	Store samples separately (e.g. RRR...GGG...BBB...)",

" -s		Write output in strips",

" -t		Write output in tiles",

" -i		Ignore read errors",

" ",

" -r #		Make each strip have no more than # rows",

" -w #		Set output tile width (pixels)",

" -l #		Set output tile length (pixels)",

" ",

" -f lsb2msb	Force lsb-to-msb FillOrder for output",

" -f msb2lsb	Force msb-to-lsb FillOrder for output",

"",

" -c lzw[:opts]	 Compress output with Lempel-Ziv & Welch encoding",

" -c zip[:opts]	 Compress output with deflate encoding",

" -c jpeg[:opts] Compress output with JPEG encoding",

" -c packbits	 Compress output with packbits encoding",

" -c g3[:opts]	 Compress output with CCITT Group 3 encoding",

" -c g4		 Compress output with CCITT Group 4 encoding",

" -c none	 Use no compression algorithm on output",

" ",

"Group 3 options:",

" 1d		Use default CCITT Group 3 1D-encoding",

" 2d		Use optional CCITT Group 3 2D-encoding",

" fill		Byte-align EOL codes",

"For example, -c g3:2d:fill to get G3-2D-encoded data with byte-aligned EOLs",

" ",

"JPEG options:",

" #		Set compression quality level (0-100, default 100)",

" raw		Output color image as raw YCbCr",

" rgb		Output color image as RGB",

"For example, -c jpeg:rgb:50 to get JPEG-encoded RGB data with 50% comp. quality",

" ",

"LZW and deflate options:",

" #		Set predictor value",

"For example, -c lzw:2 to get LZW-encoded data with horizontal differencing",

" ",

"Page and selection options:",

" -N odd|even|#,#-#,#|last         sequences and ranges of images within file to process",

"             The words odd or even may be used to specify all odd or even numbered images.",

"             The word last may be used in place of a number in the sequence to indicate.",

"             The final image in the file without knowing how many images there are.",

"             Numbers are counted from one even though TIFF IFDs are counted from zero.",

" ",

" -E t|l|r|b  edge to use as origin for width and length of crop region",

" -U units    [in, cm, px ] inches, centimeters or pixels",

" ",

" -m #,#,#,#  margins from edges for selection: top, left, bottom, right separated by commas",

" -X #        horizontal dimension of region to extract expressed in current units",

" -Y #        vertical dimension of region to extract expressed in current units",

" -Z #:#,#:#  zones of the image designated as position X of Y,",

"             eg 1:3 would be first of three equal portions measured from reference edge",

" -z x1,y1,x2,y2:...:xN,yN,xN+1,yN+1",

"             regions of the image designated by upper left and lower right coordinates",

"",

"Export grouping options:",

" -e c|d|i|m|s    export mode for images and selections from input images.",

"                 When exporting a composite image from multiple zones or regions",

"                 (combined and image modes), the selections must have equal sizes",

"                 for the axis perpendicular to the edge specified with -E.",

"    c|combined   All images and selections are written to a single file (default).",

"                 with multiple selections from one image combined into a single image.",

"    d|divided    All images and selections are written to a single file",

"                 with each selection from one image written to a new image.",

"    i|image      Each input image is written to a new file (numeric filename sequence)",

"                 with multiple selections from the image combined into one image.",

"    m|multiple   Each input image is written to a new file (numeric filename sequence)",

"                 with each selection from the image written to a new image.",

"    s|separated  Individual selections from each image are written to separate files.",

"",

"Output options:",

" -H #        Set horizontal resolution of output images to #",

" -V #        Set vertical resolution of output images to #",

" -J #        Set horizontal margin of output page to # expressed in current units",

"             when sectioning image into columns x rows using the -S cols:rows option",

" -K #        Set verticalal margin of output page to # expressed in current units",

"             when sectioning image into columns x rows using the -S cols:rows option",

" ",

" -O orient    orientation for output image, portrait, landscape, auto",

" -P page      page size for output image segments, eg letter, legal, tabloid, etc",

"              use #.#x#.# to specify a custom page size in the currently defined units",

"              where #.# represents the width and length",        

" -S cols:rows Divide the image into equal sized segments using cols across and rows down.",

" ",

" -F hor|vert|both",

"             flip (mirror) image or region horizontally, vertically, or both",

" -R #        [90,180,or 270] degrees clockwise rotation of image or extracted region",

" -I [black|white|data|both]",

"             invert color space, eg dark to light for bilevel and grayscale images",

"             If argument is white or black, set the PHOTOMETRIC_INTERPRETATION ",

"             tag to MinIsBlack or MinIsWhite without altering the image data",

"             If the argument is data or both, the image data are modified:",

"             both inverts the data and the PHOTOMETRIC_INTERPRETATION tag,",

"             data inverts the data but not the PHOTOMETRIC_INTERPRETATION tag",

" ",

"-D opt1:value1,opt2:value2,opt3:value3:opt4:value4",

"             Debug/dump program progress and/or data to non-TIFF files.",

"             Options include the following and must be joined as a comma",

"             separate list. The use of this option is generally limited to",

"             program debugging and development of future options.",

" ",

"   debug:N   Display limited program progress indicators where larger N",

"             increase the level of detail. Note: Tiffcrop may be compiled with",

"             -DDEVELMODE to enable additional very low level debug reporting.",

"",

"   Format:txt|raw  Format any logged data as ASCII text or raw binary ",

"             values. ASCII text dumps include strings of ones and zeroes",

"             representing the binary values in the image data plus identifying headers.",

" ",

"   level:N   Specify the level of detail presented in the dump files.",

"             This can vary from dumps of the entire input or output image data to dumps",

"             of data processed by specific functions. Current range of levels is 1 to 3.",

" ",

"   input:full-path-to-directory/input-dumpname",

" ",

"   output:full-path-to-directory/output-dumpnaem",

" ",

"             When dump files are being written, each image will be written to a separate",

"             file with the name built by adding a numeric sequence value to the dumpname",

"             and an extension of .txt for ASCII dumps or .bin for binary dumps.",

" ",

"             The four debug/dump options are independent, though it makes little sense to",

"             specify a dump file without specifying a detail level.",

" ",

NULL

};

/* This function could be modified to pass starting sample offset 

 * and number of samples as args to select fewer than spp

 * from input image. These would then be passed to individual 

 * extractContigSampleXX routines.

 */

static int readContigTilesIntoBuffer (TIFF* in, uint8* buf, 

                                      uint32 imagelength, 

                                      uint32 imagewidth, 

                                      uint32 tw, uint32 tl,

                                      tsample_t spp, uint16 bps)

  {

  int status = 1;

  tsample_t sample = 0;

  tsample_t count = spp; 

  uint32 row, col, trow;

  uint32 nrow, ncol;

  uint32 dst_rowsize, shift_width;

  uint32 bytes_per_sample, bytes_per_pixel;

  uint32 trailing_bits, prev_trailing_bits;

  uint32 tile_rowsize  = TIFFTileRowSize(in);

  uint32 src_offset, dst_offset;

  uint32 row_offset, col_offset;

  uint8 *bufp = (uint8*) buf;

  unsigned char *src = NULL;

  unsigned char *dst = NULL;

  tsize_t tbytes = 0, tile_buffsize = 0;

  tsize_t tilesize = TIFFTileSize(in);

  unsigned char *tilebuf = NULL;

  bytes_per_sample = (bps + 7) / 8; 

  bytes_per_pixel  = ((bps * spp) + 7) / 8;

  if ((bps % 8) == 0)

    shift_width = 0;

  else

    {

    if (bytes_per_pixel < (bytes_per_sample + 1))

      shift_width = bytes_per_pixel;

    else

      shift_width = bytes_per_sample + 1;

    }

  tile_buffsize = tilesize;

  if (tilesize < (tsize_t)(tl * tile_rowsize))

    {

#ifdef DEBUG2

    TIFFError("readContigTilesIntoBuffer",

	      "Tilesize %lu is too small, using alternate calculation %u",

              tilesize, tl * tile_rowsize);

#endif

    tile_buffsize = tl * tile_rowsize;

    } 

  tilebuf = _TIFFmalloc(tile_buffsize);

  if (tilebuf == 0)

    return 0;

  dst_rowsize = ((imagewidth * bps * spp) + 7) / 8;  

  for (row = 0; row < imagelength; row += tl)

    {

    nrow = (row + tl > imagelength) ? imagelength - row : tl;

    for (col = 0; col < imagewidth; col += tw)

      {

      tbytes = TIFFReadTile(in, tilebuf, col, row, 0, 0);

      if (tbytes < tilesize  && !ignore)

        {

	TIFFError(TIFFFileName(in),

		  "Error, can't read tile at row %lu col %lu, Read %lu bytes of %lu",

		  (unsigned long) col, (unsigned long) row, (unsigned long)tbytes,

                  (unsigned long)tilesize);

		  status = 0;

                  _TIFFfree(tilebuf);

		  return status;

	}

      row_offset = row * dst_rowsize;

      col_offset = ((col * bps * spp) + 7)/ 8;

      bufp = buf + row_offset + col_offset;

      if (col + tw > imagewidth)

	ncol = imagewidth - col;

      else

        ncol = tw;

      /* Each tile scanline will start on a byte boundary but it

       * has to be merged into the scanline for the entire

       * image buffer and the previous segment may not have

       * ended on a byte boundary

       */

      /* Optimization for common bit depths, all samples */

      if (((bps % 8) == 0) && (count == spp))

        {

	for (trow = 0; trow < nrow; trow++)

          {

	  src_offset = trow * tile_rowsize;

	  _TIFFmemcpy (bufp, tilebuf + src_offset, (ncol * spp * bps) / 8);

          bufp += (imagewidth * bps * spp) / 8;

	  }

        }

      else

        {

	/* Bit depths not a multiple of 8 and/or extract fewer than spp samples */

        prev_trailing_bits = trailing_bits = 0;

        trailing_bits = (ncol * bps * spp) % 8;

	/*	for (trow = 0; tl < nrow; trow++) */

	for (trow = 0; trow < nrow; trow++)

          {

	  src_offset = trow * tile_rowsize;

          src = tilebuf + src_offset;

	  dst_offset = (row + trow) * dst_rowsize;

          dst = buf + dst_offset + col_offset;

          switch (shift_width)

            {

            case 0: if (extractContigSamplesBytes (src, dst, ncol, sample,

                                                   spp, bps, count, 0, ncol))

                      {

		      TIFFError("readContigTilesIntoBuffer",

                                "Unable to extract row %d from tile %lu", 

				row, (unsigned long)TIFFCurrentTile(in));