src/SDL2/external/tiff-4.0.3/tools/tiffcrop.c

   1 /* $Id: tiffcrop.c,v 1.20 2010-12-14 02:03:24 faxguy Exp $ */
   2
   3 /* tiffcrop.c -- a port of tiffcp.c extended to include manipulations of
   4  * the image data through additional options listed below
   5  *
   6  * Original code:
   7  * Copyright (c) 1988-1997 Sam Leffler
   8  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
   9  * Additions (c) Richard Nolde 2006-2010
  10  *
  11  * Permission to use, copy, modify, distribute, and sell this software and
  12  * its documentation for any purpose is hereby granted without fee, provided
  13  * that (i) the above copyright notices and this permission notice appear in
  14  * all copies of the software and related documentation, and (ii) the names of
  15  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  16  * publicity relating to the software without the specific, prior written
  17  * permission of Sam Leffler and Silicon Graphics.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  20  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  21  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  22  *
  23  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS OR ANY OTHER COPYRIGHT
  24  * HOLDERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL
  25  * DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  26  * DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND
  27  * ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE
  28  * OR PERFORMANCE OF THIS SOFTWARE.
  29  *
  30  * Some portions of the current code are derived from tiffcp, primarly in
  31  * the areas of lowlevel reading and writing of TAGS, scanlines and tiles though
  32  * some of the original functions have been extended to support arbitrary bit
  33  * depths. These functions are presented at the top of this file.
  34  *
  35  * Add support for the options below to extract sections of image(s)
  36  * and to modify the whole image or selected portions of each image by
  37  * rotations, mirroring, and colorscale/colormap inversion of selected
  38  * types of TIFF images when appropriate. Some color model dependent
  39  * functions are restricted to bilevel or 8 bit per sample data.
  40  * See the man page for the full explanations.
  41  *
  42  * New Options:
  43  * -h             Display the syntax guide.
  44  * -v             Report the version and last build date for tiffcrop and libtiff.
  45  * -z x1,y1,x2,y2:x3,y3,x4,y4:..xN,yN,xN + 1, yN + 1
  46  *                Specify a series of coordinates to define rectangular
  47  *                regions by the top left and lower right corners.
  48  * -e c|d|i|m|s   export mode for images and selections from input images
  49  *   combined     All images and selections are written to a single file (default)
  50  *                with multiple selections from one image combined into a single image
  51  *   divided      All images and selections are written to a single file
  52  *                with each selection from one image written to a new image
  53  *   image        Each input image is written to a new file (numeric filename sequence)
  54  *                with multiple selections from the image combined into one image
  55  *   multiple     Each input image is written to a new file (numeric filename sequence)
  56  *                with each selection from the image written to a new image
  57  *   separated    Individual selections from each image are written to separate files
  58  * -U units       [in, cm, px ] inches, centimeters or pixels
  59  * -H #           Set horizontal resolution of output images to #
  60  * -V #           Set vertical resolution of output images to #
  61  * -J #           Horizontal margin of output page to # expressed in current
  62  *                units when sectioning image into columns x rows
  63  *                using the -S cols:rows option.
  64  * -K #           Vertical margin of output page to # expressed in current
  65  *                units when sectioning image into columns x rows
  66  *                using the -S cols:rows option.
  67  * -X #           Horizontal dimension of region to extract expressed in current
  68  *                units
  69  * -Y #           Vertical dimension of region to extract expressed in current
  70  *                units
  71  * -O orient      Orientation for output image, portrait, landscape, auto
  72  * -P page        Page size for output image segments, eg letter, legal, tabloid,
  73  *                etc.
  74  * -S cols:rows   Divide the image into equal sized segments using cols across
  75  *                and rows down
  76  * -E t|l|r|b     Edge to use as origin
  77  * -m #,#,#,#     Margins from edges for selection: top, left, bottom, right
  78  *                (commas separated)
  79  * -Z #:#,#:#     Zones of the image designated as zone X of Y,
  80  *                eg 1:3 would be first of three equal portions measured
  81  *                from reference edge
  82  * -N odd|even|#,#-#,#|last
  83  *                Select sequences and/or ranges of images within file
  84  *                to process. The words odd or even may be used to specify
  85  *                all odd or even numbered images the word last may be used
  86  *                in place of a number in the sequence to indicate the final
  87  *                image in the file without knowing how many images there are.
  88  * -R #           Rotate image or crop selection by 90,180,or 270 degrees
  89  *                clockwise
  90  * -F h|v         Flip (mirror) image or crop selection horizontally
  91  *                or vertically
  92  * -I [black|white|data|both]
  93  *                Invert color space, eg dark to light for bilevel and grayscale images
  94  *                If argument is white or black, set the PHOTOMETRIC_INTERPRETATION
  95  *                tag to MinIsBlack or MinIsWhite without altering the image data
  96  *                If the argument is data or both, the image data are modified:
  97  *                both inverts the data and the PHOTOMETRIC_INTERPRETATION tag,
  98  *                data inverts the data but not the PHOTOMETRIC_INTERPRETATION tag
  99  * -D input:<filename1>,output:<filename2>,format:<raw|txt>,level:N,debug:N
 100  *                Dump raw data for input and/or output images to individual files
 101  *                in raw (binary) format or text (ASCII) representing binary data
 102  *                as strings of 1s and 0s. The filename arguments are used as stems
 103  *                from which individual files are created for each image. Text format
 104  *                includes annotations for image parameters and scanline info. Level
 105  *                selects which functions dump data, with higher numbers selecting
 106  *                lower level, scanline level routines. Debug reports a limited set
 107  *                of messages to monitor progess without enabling dump logs.
 108  */
 109
 110 static   char tiffcrop_version_id[] = "2.4";
 111 static   char tiffcrop_rev_date[] = "12-13-2010";
 112
 113 #include "tif_config.h"
 114 #include "tiffiop.h"
 115
 116 #include <stdio.h>
 117 #include <stdlib.h>
 118 #include <string.h>
 119 #include <math.h>
 120 #include <ctype.h>
 121 #include <limits.h>
 122 #include <sys/stat.h>
 123 #include <assert.h>
 124
 125 #ifdef HAVE_UNISTD_H
 126 # include <unistd.h>
 127 #endif
 128
 129 #ifdef HAVE_STDINT_H
 130 # include <stdint.h>
 131 #endif
 132
 133 #ifndef HAVE_GETOPT
 134 extern int getopt(int, char**, char*);
 135 #endif
 136
 137 #ifdef NEED_LIBPORT
 138 # include "libport.h"
 139 #endif
 140
 141 #include "tiffio.h"
 142
 143 #if defined(VMS)
 144 # define unlink delete
 145 #endif
 146
 147 #ifndef PATH_MAX
 148 #define PATH_MAX 1024
 149 #endif
 150
 151 #ifndef streq
 152 #define streq(a,b)      (strcmp((a),(b)) == 0)
 153 #endif
 154 #define strneq(a,b,n)   (strncmp((a),(b),(n)) == 0)
 155
 156 #define TRUE    1
 157 #define FALSE   0
 158
 159 #ifndef TIFFhowmany
 160 #define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y)))
 161 #define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
 162 #endif
 163
 164 /*
 165  * Definitions and data structures required to support cropping and image
 166  * manipulations.
 167  */
 168
 169 #define EDGE_TOP      1
 170 #define EDGE_LEFT     2
 171 #define EDGE_BOTTOM   3
 172 #define EDGE_RIGHT    4
 173 #define EDGE_CENTER   5
 174
 175 #define MIRROR_HORIZ  1
 176 #define MIRROR_VERT   2
 177 #define MIRROR_BOTH   3
 178 #define ROTATECW_90   8
 179 #define ROTATECW_180 16
 180 #define ROTATECW_270 32
 181 #define ROTATE_ANY ROTATECW_90 || ROTATECW_180 || ROTATECW_270
 182
 183 #define CROP_NONE     0
 184 #define CROP_MARGINS  1
 185 #define CROP_WIDTH    2
 186 #define CROP_LENGTH   4
 187 #define CROP_ZONES    8
 188 #define CROP_REGIONS 16
 189 #define CROP_ROTATE  32
 190 #define CROP_MIRROR  64
 191 #define CROP_INVERT 128
 192
 193 /* Modes for writing out images and selections */
 194 #define ONE_FILE_COMPOSITE       0 /* One file, sections combined sections */
 195 #define ONE_FILE_SEPARATED       1 /* One file, sections to new IFDs */
 196 #define FILE_PER_IMAGE_COMPOSITE 2 /* One file per image, combined sections */
 197 #define FILE_PER_IMAGE_SEPARATED 3 /* One file per input image */
 198 #define FILE_PER_SELECTION       4 /* One file per selection */
 199
 200 #define COMPOSITE_IMAGES         0 /* Selections combined into one image */
 201 #define SEPARATED_IMAGES         1 /* Selections saved to separate images */
 202
 203 #define STRIP    1
 204 #define TILE     2
 205
 206 #define MAX_REGIONS   8  /* number of regions to extract from a single page */
 207 #define MAX_OUTBUFFS  8  /* must match larger of zones or regions */
 208 #define MAX_SECTIONS 32  /* number of sections per page to write to output */
 209 #define MAX_IMAGES 2048  /* number of images in descrete list, not in the file */
 210 #define MAX_SAMPLES   8  /* maximum number of samples per pixel supported */
 211 #define MAX_BITS_PER_SAMPLE 64 /* maximum bit depth supported */
 212 #define MAX_EXPORT_PAGES 999999  /* maximum number of export pages per file */
 213
 214 #define DUMP_NONE   0
 215 #define DUMP_TEXT   1
 216 #define DUMP_RAW    2
 217
 218 /* Offsets into buffer for margins and fixed width and length segments */
 219 struct offset {
 220   uint32  tmargin;
 221   uint32  lmargin;
 222   uint32  bmargin;
 223   uint32  rmargin;
 224   uint32  crop_width;
 225   uint32  crop_length;
 226   uint32  startx;
 227   uint32  endx;
 228   uint32  starty;
 229   uint32  endy;
 230 };
 231
 232 /* Description of a zone within the image. Position 1 of 3 zones would be
 233  * the first third of the image. These are computed after margins and
 234  * width/length requests are applied so that you can extract multiple
 235  * zones from within a larger region for OCR or barcode recognition.
 236  */
 237
 238 struct  buffinfo {
 239   uint32 size;           /* size of this buffer */
 240   unsigned char *buffer; /* address of the allocated buffer */
 241 };
 242
 243 struct  zone {
 244   int   position;  /* ordinal of segment to be extracted */
 245   int   total;     /* total equal sized divisions of crop area */
 246   };
 247
 248 struct  pageseg {
 249   uint32 x1;        /* index of left edge */
 250   uint32 x2;        /* index of right edge */
 251   uint32 y1;        /* index of top edge */
 252   uint32 y2;        /* index of bottom edge */
 253   int    position;  /* ordinal of segment to be extracted */
 254   int    total;     /* total equal sized divisions of crop area */
 255   uint32 buffsize;  /* size of buffer needed to hold the cropped zone */
 256 };
 257
 258 struct  coordpairs {
 259   double X1;        /* index of left edge in current units */
 260   double X2;        /* index of right edge in current units */
 261   double Y1;        /* index of top edge in current units */
 262   double Y2;        /* index of bottom edge in current units */
 263 };
 264
 265 struct  region {
 266   uint32 x1;        /* pixel offset of left edge */
 267   uint32 x2;        /* pixel offset of right edge */
 268   uint32 y1;        /* pixel offset of top edge */
 269   uint32 y2;        /* picel offset of bottom edge */
 270   uint32 width;     /* width in pixels */
 271   uint32 length;    /* length in pixels */
 272   uint32 buffsize;  /* size of buffer needed to hold the cropped region */
 273   unsigned char *buffptr; /* address of start of the region */
 274 };
 275
 276 /* Cropping parameters from command line and image data
 277  * Note: This should be renamed to proc_opts and expanded to include all current globals
 278  * if possible, but each function that accesses global variables will have to be redone.
 279  */
 280 struct crop_mask {
 281   double width;           /* Selection width for master crop region in requested units */
 282   double length;          /* Selection length for master crop region in requesed units */
 283   double margins[4];      /* Top, left, bottom, right margins */
 284   float  xres;            /* Horizontal resolution read from image*/
 285   float  yres;            /* Vertical resolution read from image */
 286   uint32 combined_width;  /* Width of combined cropped zones */
 287   uint32 combined_length; /* Length of combined cropped zones */
 288   uint32 bufftotal;       /* Size of buffer needed to hold all the cropped region */
 289   uint16 img_mode;        /* Composite or separate images created from zones or regions */
 290   uint16 exp_mode;        /* Export input images or selections to one or more files */
 291   uint16 crop_mode;       /* Crop options to be applied */
 292   uint16 res_unit;        /* Resolution unit for margins and selections */
 293   uint16 edge_ref;        /* Reference edge for sections extraction and combination */
 294   uint16 rotation;        /* Clockwise rotation of the extracted region or image */
 295   uint16 mirror;          /* Mirror extracted region or image horizontally or vertically */
 296   uint16 invert;          /* Invert the color map of image or region */
 297   uint16 photometric;     /* Status of photometric interpretation for inverted image */
 298   uint16 selections;      /* Number of regions or zones selected */
 299   uint16 regions;         /* Number of regions delimited by corner coordinates */
 300   struct region regionlist[MAX_REGIONS]; /* Regions within page or master crop region */
 301   uint16 zones;           /* Number of zones delimited by Ordinal:Total requested */
 302   struct zone zonelist[MAX_REGIONS]; /* Zones indices to define a region */
 303   struct coordpairs corners[MAX_REGIONS]; /* Coordinates of upper left and lower right corner */
 304 };
 305
 306 #define MAX_PAPERNAMES 49
 307 #define MAX_PAPERNAME_LENGTH 15
 308 #define DEFAULT_RESUNIT      RESUNIT_INCH
 309 #define DEFAULT_PAGE_HEIGHT   14.0
 310 #define DEFAULT_PAGE_WIDTH     8.5
 311 #define DEFAULT_RESOLUTION   300
 312 #define DEFAULT_PAPER_SIZE  "legal"
 313
 314 #define ORIENTATION_NONE       0
 315 #define ORIENTATION_PORTRAIT   1
 316 #define ORIENTATION_LANDSCAPE  2
 317 #define ORIENTATION_SEASCAPE   4
 318 #define ORIENTATION_AUTO      16
 319
 320 #define PAGE_MODE_NONE         0
 321 #define PAGE_MODE_RESOLUTION   1
 322 #define PAGE_MODE_PAPERSIZE    2
 323 #define PAGE_MODE_MARGINS      4
 324 #define PAGE_MODE_ROWSCOLS     8
 325
 326 #define INVERT_DATA_ONLY      10
 327 #define INVERT_DATA_AND_TAG   11
 328
 329 struct paperdef {
 330   char   name[MAX_PAPERNAME_LENGTH];
 331   double width;
 332   double length;
 333   double asratio;
 334   };
 335
 336 /* European page sizes corrected from update sent by
 337  * thomas . jarosch @ intra2net . com on 5/7/2010
 338  * Paper Size       Width   Length  Aspect Ratio */
 339 struct paperdef PaperTable[MAX_PAPERNAMES] = {
 340   {"default",         8.500,  14.000,  0.607},
 341   {"pa4",             8.264,  11.000,  0.751},
 342   {"letter",          8.500,  11.000,  0.773},
 343   {"legal",           8.500,  14.000,  0.607},
 344   {"half-letter",     8.500,   5.514,  1.542},
 345   {"executive",       7.264,  10.528,  0.690},
 346   {"tabloid",        11.000,  17.000,  0.647},
 347   {"11x17",          11.000,  17.000,  0.647},
 348   {"ledger",         17.000,  11.000,  1.545},
 349   {"archa",           9.000,  12.000,  0.750},
 350   {"archb",          12.000,  18.000,  0.667},
 351   {"archc",          18.000,  24.000,  0.750},
 352   {"archd",          24.000,  36.000,  0.667},
 353   {"arche",          36.000,  48.000,  0.750},
 354   {"csheet",         17.000,  22.000,  0.773},
 355   {"dsheet",         22.000,  34.000,  0.647},
 356   {"esheet",         34.000,  44.000,  0.773},
 357   {"superb",         11.708,  17.042,  0.687},
 358   {"commercial",      4.139,   9.528,  0.434},
 359   {"monarch",         3.889,   7.528,  0.517},
 360   {"envelope-dl",     4.333,   8.681,  0.499},
 361   {"envelope-c5",     6.389,   9.028,  0.708},
 362   {"europostcard",    4.139,   5.833,  0.710},
 363   {"a0",             33.110,  46.811,  0.707},
 364   {"a1",             23.386,  33.110,  0.706},
 365   {"a2",             16.535,  23.386,  0.707},
 366   {"a3",             11.693,  16.535,  0.707},
 367   {"a4",              8.268,  11.693,  0.707},
 368   {"a5",              5.827,   8.268,  0.705},
 369   {"a6",              4.134,   5.827,  0.709},
 370   {"a7",              2.913,   4.134,  0.705},
 371   {"a8",              2.047,   2.913,  0.703},
 372   {"a9",              1.457,   2.047,  0.712},
 373   {"a10",             1.024,   1.457,  0.703},
 374   {"b0",             39.370,  55.669,  0.707},
 375   {"b1",             27.835,  39.370,  0.707},
 376   {"b2",             19.685,  27.835,  0.707},
 377   {"b3",             13.898,  19.685,  0.706},
 378   {"b4",              9.843,  13.898,  0.708},
 379   {"b5",              6.929,   9.843,  0.704},
 380   {"b6",              4.921,   6.929,  0.710},
 381   {"c0",             36.102,  51.063,  0.707},
 382   {"c1",             25.512,  36.102,  0.707},
 383   {"c2",             18.031,  25.512,  0.707},
 384   {"c3",             12.756,  18.031,  0.707},
 385   {"c4",              9.016,  12.756,  0.707},
 386   {"c5",              6.378,   9.016,  0.707},
 387   {"c6",              4.488,   6.378,  0.704},
 388   {"",                0.000,   0.000,  1.000}
 389 };
 390
 391 /* Structure to define input image parameters */
 392 struct image_data {
 393   float  xres;
 394   float  yres;
 395   uint32 width;
 396   uint32 length;
 397   uint16 res_unit;
 398   uint16 bps;
 399   uint16 spp;
 400   uint16 planar;
 401   uint16 photometric;
 402   uint16 orientation;
 403   uint16 compression;
 404   uint16 adjustments;
 405 };
 406
 407 /* Structure to define the output image modifiers */
 408 struct pagedef {
 409   char          name[16];
 410   double        width;    /* width in pixels */
 411   double        length;   /* length in pixels */
 412   double        hmargin;  /* margins to subtract from width of sections */
 413   double        vmargin;  /* margins to subtract from height of sections */
 414   double        hres;     /* horizontal resolution for output */
 415   double        vres;     /* vertical resolution for output */
 416   uint32        mode;     /* bitmask of modifiers to page format */
 417   uint16        res_unit; /* resolution unit for output image */
 418   unsigned int  rows;     /* number of section rows */
 419   unsigned int  cols;     /* number of section cols */
 420   unsigned int  orient;   /* portrait, landscape, seascape, auto */
 421 };
 422
 423 struct dump_opts {
 424   int  debug;
 425   int  format;
 426   int  level;
 427   char mode[4];
 428   char infilename[PATH_MAX + 1];
 429   char outfilename[PATH_MAX + 1];
 430   FILE *infile;
 431   FILE *outfile;
 432   };
 433
 434 /* globals */
 435 static int    outtiled = -1;
 436 static uint32 tilewidth = 0;
 437 static uint32 tilelength = 0;
 438
 439 static uint16 config = 0;
 440 static uint16 compression = 0;
 441 static uint16 predictor = 0;
 442 static uint16 fillorder = 0;
 443 static uint32 rowsperstrip = 0;
 444 static uint32 g3opts = 0;
 445 static int    ignore = FALSE;           /* if true, ignore read errors */
 446 static uint32 defg3opts = (uint32) -1;
 447 static int    quality = 100;            /* JPEG quality */
 448 /* static int    jpegcolormode = -1;        was JPEGCOLORMODE_RGB;  */
 449 static int    jpegcolormode = JPEGCOLORMODE_RGB;
 450 static uint16 defcompression = (uint16) -1;
 451 static uint16 defpredictor = (uint16) -1;
 452 static int    pageNum = 0;
 453 static int    little_endian = 1;
 454
 455 /* Functions adapted from tiffcp with additions or significant modifications */
 456 static int  readContigStripsIntoBuffer   (TIFF*, uint8*);
 457 static int  readSeparateStripsIntoBuffer (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);
 458 static int  readContigTilesIntoBuffer    (TIFF*, uint8*, uint32, uint32, uint32, uint32, tsample_t, uint16);
 459 static int  readSeparateTilesIntoBuffer  (TIFF*, uint8*, uint32, uint32, uint32, uint32, tsample_t, uint16);
 460 static int  writeBufferToContigStrips    (TIFF*, uint8*, uint32);
 461 static int  writeBufferToContigTiles     (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);
 462 static int  writeBufferToSeparateStrips  (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);
 463 static int  writeBufferToSeparateTiles   (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *);
 464 static int  extractContigSamplesToBuffer (uint8 *, uint8 *, uint32, uint32, tsample_t,
 465                                          uint16, uint16, struct dump_opts *);
 466 static int processCompressOptions(char*);
 467 static void usage(void);
 468
 469 /* All other functions by Richard Nolde,  not found in tiffcp */
 470 static void initImageData (struct image_data *);
 471 static void initCropMasks (struct crop_mask *);
 472 static void initPageSetup (struct pagedef *, struct pageseg *, struct buffinfo []);
 473 static void initDumpOptions(struct dump_opts *);
 474
 475 /* Command line and file naming functions */
 476 void  process_command_opts (int, char *[], char *, char *, uint32 *,
 477                             uint16 *, uint16 *, uint32 *, uint32 *, uint32 *,
 478                             struct crop_mask *, struct pagedef *,
 479                             struct dump_opts *,
 480                             unsigned int *, unsigned int *);
 481 static  int update_output_file (TIFF **, char *, int, char *, unsigned int *);
 482
 483
 484 /*  * High level functions for whole image manipulation */
 485 static int  get_page_geometry (char *, struct pagedef*);
 486 static int  computeInputPixelOffsets(struct crop_mask *, struct image_data *,
 487                                      struct offset *);
 488 static int  computeOutputPixelOffsets (struct crop_mask *, struct image_data *,
 489                                        struct pagedef *, struct pageseg *,
 490                                        struct dump_opts *);
 491 static int  loadImage(TIFF *, struct image_data *, struct dump_opts *, unsigned char **);
 492 static int  correct_orientation(struct image_data *, unsigned char **);
 493 static int  getCropOffsets(struct image_data *, struct crop_mask *, struct dump_opts *);
 494 static int  processCropSelections(struct image_data *, struct crop_mask *,
 495                                   unsigned char **, struct buffinfo []);
 496 static int  writeSelections(TIFF *, TIFF **, struct crop_mask *, struct image_data *,
 497                             struct dump_opts *, struct buffinfo [],
 498                             char *, char *, unsigned int*, unsigned int);
 499
 500 /* Section functions */
 501 static int  createImageSection(uint32, unsigned char **);
 502 static int  extractImageSection(struct image_data *, struct pageseg *,
 503                                 unsigned char *, unsigned char *);
 504 static int  writeSingleSection(TIFF *, TIFF *, struct image_data *,
 505                                struct dump_opts *, uint32, uint32,
 506                                double, double, unsigned char *);
 507 static int  writeImageSections(TIFF *, TIFF *, struct image_data *,
 508                                struct pagedef *, struct pageseg *,
 509                                struct dump_opts *, unsigned char *,
 510                                unsigned char **);
 511 /* Whole image functions */
 512 static int  createCroppedImage(struct image_data *, struct crop_mask *,
 513                                unsigned char **, unsigned char **);
 514 static int  writeCroppedImage(TIFF *, TIFF *, struct image_data *image,
 515                               struct dump_opts * dump,
 516                               uint32, uint32, unsigned char *, int, int);
 517
 518 /* Image manipulation functions */
 519 static int rotateContigSamples8bits(uint16, uint16, uint16, uint32,
 520                                     uint32,   uint32, uint8 *, uint8 *);
 521 static int rotateContigSamples16bits(uint16, uint16, uint16, uint32,
 522                                      uint32,   uint32, uint8 *, uint8 *);
 523 static int rotateContigSamples24bits(uint16, uint16, uint16, uint32,
 524                                      uint32,   uint32, uint8 *, uint8 *);
 525 static int rotateContigSamples32bits(uint16, uint16, uint16, uint32,
 526                                      uint32,   uint32, uint8 *, uint8 *);
 527 static int rotateImage(uint16, struct image_data *, uint32 *, uint32 *,
 528                        unsigned char **);
 529 static int mirrorImage(uint16, uint16, uint16, uint32, uint32,
 530                        unsigned char *);
 531 static int invertImage(uint16, uint16, uint16, uint32, uint32,
 532                        unsigned char *);
 533
 534 /* Functions to reverse the sequence of samples in a scanline */
 535 static int reverseSamples8bits  (uint16, uint16, uint32, uint8 *, uint8 *);
 536 static int reverseSamples16bits (uint16, uint16, uint32, uint8 *, uint8 *);
 537 static int reverseSamples24bits (uint16, uint16, uint32, uint8 *, uint8 *);
 538 static int reverseSamples32bits (uint16, uint16, uint32, uint8 *, uint8 *);
 539 static int reverseSamplesBytes  (uint16, uint16, uint32, uint8 *, uint8 *);
 540
 541 /* Functions for manipulating individual samples in an image */
 542 static int extractSeparateRegion(struct image_data *, struct crop_mask *,
 543                                  unsigned char *, unsigned char *, int);
 544 static int extractCompositeRegions(struct image_data *,  struct crop_mask *,
 545                                    unsigned char *, unsigned char *);
 546 static int extractContigSamples8bits (uint8 *, uint8 *, uint32,
 547                                      tsample_t, uint16, uint16,
 548                                      tsample_t, uint32, uint32);
 549 static int extractContigSamples16bits (uint8 *, uint8 *, uint32,
 550                                       tsample_t, uint16, uint16,
 551                                       tsample_t, uint32, uint32);
 552 static int extractContigSamples24bits (uint8 *, uint8 *, uint32,
 553                                       tsample_t, uint16, uint16,
 554                                       tsample_t, uint32, uint32);
 555 static int extractContigSamples32bits (uint8 *, uint8 *, uint32,
 556                                       tsample_t, uint16, uint16,
 557                                       tsample_t, uint32, uint32);
 558 static int extractContigSamplesBytes (uint8 *, uint8 *, uint32,
 559                                       tsample_t, uint16, uint16,
 560                                       tsample_t, uint32, uint32);
 561 static int extractContigSamplesShifted8bits (uint8 *, uint8 *, uint32,
 562                                              tsample_t, uint16, uint16,
 563                                              tsample_t, uint32, uint32,
 564                                              int);
 565 static int extractContigSamplesShifted16bits (uint8 *, uint8 *, uint32,
 566                                               tsample_t, uint16, uint16,
 567                                               tsample_t, uint32, uint32,
 568                                               int);
 569 static int extractContigSamplesShifted24bits (uint8 *, uint8 *, uint32,
 570                                               tsample_t, uint16, uint16,
 571                                               tsample_t, uint32, uint32,
 572                                               int);
 573 static int extractContigSamplesShifted32bits (uint8 *, uint8 *, uint32,
 574                                               tsample_t, uint16, uint16,
 575                                               tsample_t, uint32, uint32,
 576                                               int);
 577 static int extractContigSamplesToTileBuffer(uint8 *, uint8 *, uint32, uint32,
 578                                             uint32, uint32, tsample_t, uint16,
 579                                             uint16, uint16, struct dump_opts *);
 580
 581 /* Functions to combine separate planes into interleaved planes */
 582 static int combineSeparateSamples8bits (uint8 *[], uint8 *, uint32, uint32,
 583                                         uint16, uint16, FILE *, int, int);
 584 static int combineSeparateSamples16bits (uint8 *[], uint8 *, uint32, uint32,
 585                                          uint16, uint16, FILE *, int, int);
 586 static int combineSeparateSamples24bits (uint8 *[], uint8 *, uint32, uint32,
 587                                          uint16, uint16, FILE *, int, int);
 588 static int combineSeparateSamples32bits (uint8 *[], uint8 *, uint32, uint32,
 589                                          uint16, uint16, FILE *, int, int);
 590 static int combineSeparateSamplesBytes (unsigned char *[], unsigned char *,
 591                                         uint32, uint32, tsample_t, uint16,
 592                                         FILE *, int, int);
 593
 594 static int combineSeparateTileSamples8bits (uint8 *[], uint8 *, uint32, uint32,
 595                                             uint32, uint32, uint16, uint16,
 596                                             FILE *, int, int);
 597 static int combineSeparateTileSamples16bits (uint8 *[], uint8 *, uint32, uint32,
 598                                              uint32, uint32, uint16, uint16,
 599                                              FILE *, int, int);
 600 static int combineSeparateTileSamples24bits (uint8 *[], uint8 *, uint32, uint32,
 601                                              uint32, uint32, uint16, uint16,
 602                                              FILE *, int, int);
 603 static int combineSeparateTileSamples32bits (uint8 *[], uint8 *, uint32, uint32,
 604                                              uint32, uint32, uint16, uint16,
 605                                              FILE *, int, int);
 606 static int combineSeparateTileSamplesBytes (unsigned char *[], unsigned char *,
 607                                             uint32, uint32, uint32, uint32,
 608                                             tsample_t, uint16, FILE *, int, int);
 609
 610 /* Dump functions for debugging */
 611 static void dump_info  (FILE *, int, char *, char *, ...);
 612 static int  dump_data  (FILE *, int, char *, unsigned char *, uint32);
 613 static int  dump_byte  (FILE *, int, char *, unsigned char);
 614 static int  dump_short (FILE *, int, char *, uint16);
 615 static int  dump_long  (FILE *, int, char *, uint32);
 616 static int  dump_wide  (FILE *, int, char *, uint64);
 617 static int  dump_buffer (FILE *, int, uint32, uint32, uint32, unsigned char *);
 618
 619 /* End function declarations */
 620 /* Functions derived in whole or in part from tiffcp */
 621 /* The following functions are taken largely intact from tiffcp */
 622
 623 static   char* usage_info[] = {
 624 "usage: tiffcrop [options] source1 ... sourceN  destination",
 625 "where options are:",
 626 " -h            Print this syntax listing",
 627 " -v            Print tiffcrop version identifier and last revision date",
 628 " ",
 629 " -a            Append to output instead of overwriting",
 630 " -d offset     Set initial directory offset, counting first image as one, not zero",
 631 " -p contig     Pack samples contiguously (e.g. RGBRGB...)",
 632 " -p separate   Store samples separately (e.g. RRR...GGG...BBB...)",
 633 " -s            Write output in strips",
 634 " -t            Write output in tiles",
 635 " -i            Ignore read errors",
 636 " ",
 637 " -r #          Make each strip have no more than # rows",
 638 " -w #          Set output tile width (pixels)",
 639 " -l #          Set output tile length (pixels)",
 640 " ",
 641 " -f lsb2msb    Force lsb-to-msb FillOrder for output",
 642 " -f msb2lsb    Force msb-to-lsb FillOrder for output",
 643 "",
 644 " -c lzw[:opts]  Compress output with Lempel-Ziv & Welch encoding",
 645 " -c zip[:opts]  Compress output with deflate encoding",
 646 " -c jpeg[:opts] Compress output with JPEG encoding",
 647 " -c packbits    Compress output with packbits encoding",
 648 " -c g3[:opts]   Compress output with CCITT Group 3 encoding",
 649 " -c g4          Compress output with CCITT Group 4 encoding",
 650 " -c none        Use no compression algorithm on output",
 651 " ",
 652 "Group 3 options:",
 653 " 1d            Use default CCITT Group 3 1D-encoding",
 654 " 2d            Use optional CCITT Group 3 2D-encoding",
 655 " fill          Byte-align EOL codes",
 656 "For example, -c g3:2d:fill to get G3-2D-encoded data with byte-aligned EOLs",
 657 " ",
 658 "JPEG options:",
 659 " #             Set compression quality level (0-100, default 100)",
 660 " raw           Output color image as raw YCbCr",
 661 " rgb           Output color image as RGB",
 662 "For example, -c jpeg:rgb:50 to get JPEG-encoded RGB data with 50% comp. quality",
 663 " ",
 664 "LZW and deflate options:",
 665 " #             Set predictor value",
 666 "For example, -c lzw:2 to get LZW-encoded data with horizontal differencing",
 667 " ",
 668 "Page and selection options:",
 669 " -N odd|even|#,#-#,#|last         sequences and ranges of images within file to process",
 670 "             The words odd or even may be used to specify all odd or even numbered images.",
 671 "             The word last may be used in place of a number in the sequence to indicate.",
 672 "             The final image in the file without knowing how many images there are.",
 673 "             Numbers are counted from one even though TIFF IFDs are counted from zero.",
 674 " ",
 675 " -E t|l|r|b  edge to use as origin for width and length of crop region",
 676 " -U units    [in, cm, px ] inches, centimeters or pixels",
 677 " ",
 678 " -m #,#,#,#  margins from edges for selection: top, left, bottom, right separated by commas",
 679 " -X #        horizontal dimension of region to extract expressed in current units",
 680 " -Y #        vertical dimension of region to extract expressed in current units",
 681 " -Z #:#,#:#  zones of the image designated as position X of Y,",
 682 "             eg 1:3 would be first of three equal portions measured from reference edge",
 683 " -z x1,y1,x2,y2:...:xN,yN,xN+1,yN+1",
 684 "             regions of the image designated by upper left and lower right coordinates",
 685 "",
 686 "Export grouping options:",
 687 " -e c|d|i|m|s    export mode for images and selections from input images.",
 688 "                 When exporting a composite image from multiple zones or regions",
 689 "                 (combined and image modes), the selections must have equal sizes",
 690 "                 for the axis perpendicular to the edge specified with -E.",
 691 "    c|combined   All images and selections are written to a single file (default).",
 692 "                 with multiple selections from one image combined into a single image.",
 693 "    d|divided    All images and selections are written to a single file",
 694 "                 with each selection from one image written to a new image.",
 695 "    i|image      Each input image is written to a new file (numeric filename sequence)",
 696 "                 with multiple selections from the image combined into one image.",
 697 "    m|multiple   Each input image is written to a new file (numeric filename sequence)",
 698 "                 with each selection from the image written to a new image.",
 699 "    s|separated  Individual selections from each image are written to separate files.",
 700 "",
 701 "Output options:",
 702 " -H #        Set horizontal resolution of output images to #",
 703 " -V #        Set vertical resolution of output images to #",
 704 " -J #        Set horizontal margin of output page to # expressed in current units",
 705 "             when sectioning image into columns x rows using the -S cols:rows option",
 706 " -K #        Set verticalal margin of output page to # expressed in current units",
 707 "             when sectioning image into columns x rows using the -S cols:rows option",
 708 " ",
 709 " -O orient    orientation for output image, portrait, landscape, auto",
 710 " -P page      page size for output image segments, eg letter, legal, tabloid, etc",
 711 "              use #.#x#.# to specify a custom page size in the currently defined units",
 712 "              where #.# represents the width and length",
 713 " -S cols:rows Divide the image into equal sized segments using cols across and rows down.",
 714 " ",
 715 " -F hor|vert|both",
 716 "             flip (mirror) image or region horizontally, vertically, or both",
 717 " -R #        [90,180,or 270] degrees clockwise rotation of image or extracted region",
 718 " -I [black|white|data|both]",
 719 "             invert color space, eg dark to light for bilevel and grayscale images",
 720 "             If argument is white or black, set the PHOTOMETRIC_INTERPRETATION ",
 721 "             tag to MinIsBlack or MinIsWhite without altering the image data",
 722 "             If the argument is data or both, the image data are modified:",
 723 "             both inverts the data and the PHOTOMETRIC_INTERPRETATION tag,",
 724 "             data inverts the data but not the PHOTOMETRIC_INTERPRETATION tag",
 725 " ",
 726 "-D opt1:value1,opt2:value2,opt3:value3:opt4:value4",
 727 "             Debug/dump program progress and/or data to non-TIFF files.",
 728 "             Options include the following and must be joined as a comma",
 729 "             separate list. The use of this option is generally limited to",
 730 "             program debugging and development of future options.",
 731 " ",
 732 "   debug:N   Display limited program progress indicators where larger N",
 733 "             increase the level of detail. Note: Tiffcrop may be compiled with",
 734 "             -DDEVELMODE to enable additional very low level debug reporting.",
 735 "",
 736 "   Format:txt|raw  Format any logged data as ASCII text or raw binary ",
 737 "             values. ASCII text dumps include strings of ones and zeroes",
 738 "             representing the binary values in the image data plus identifying headers.",
 739 " ",
 740 "   level:N   Specify the level of detail presented in the dump files.",
 741 "             This can vary from dumps of the entire input or output image data to dumps",
 742 "             of data processed by specific functions. Current range of levels is 1 to 3.",
 743 " ",
 744 "   input:full-path-to-directory/input-dumpname",
 745 " ",
 746 "   output:full-path-to-directory/output-dumpnaem",
 747 " ",
 748 "             When dump files are being written, each image will be written to a separate",
 749 "             file with the name built by adding a numeric sequence value to the dumpname",
 750 "             and an extension of .txt for ASCII dumps or .bin for binary dumps.",
 751 " ",
 752 "             The four debug/dump options are independent, though it makes little sense to",
 753 "             specify a dump file without specifying a detail level.",
 754 " ",
 755 NULL
 756 };
 757
 758 /* This function could be modified to pass starting sample offset
 759  * and number of samples as args to select fewer than spp
 760  * from input image. These would then be passed to individual
 761  * extractContigSampleXX routines.
 762  */
 763 static int readContigTilesIntoBuffer (TIFF* in, uint8* buf,
 764                                       uint32 imagelength,
 765                                       uint32 imagewidth,
 766                                       uint32 tw, uint32 tl,
 767                                       tsample_t spp, uint16 bps)
 768   {
 769   int status = 1;
 770   tsample_t sample = 0;
 771   tsample_t count = spp;
 772   uint32 row, col, trow;
 773   uint32 nrow, ncol;
 774   uint32 dst_rowsize, shift_width;
 775   uint32 bytes_per_sample, bytes_per_pixel;
 776   uint32 trailing_bits, prev_trailing_bits;
 777   uint32 tile_rowsize  = TIFFTileRowSize(in);
 778   uint32 src_offset, dst_offset;
 779   uint32 row_offset, col_offset;
 780   uint8 *bufp = (uint8*) buf;
 781   unsigned char *src = NULL;
 782   unsigned char *dst = NULL;
 783   tsize_t tbytes = 0, tile_buffsize = 0;
 784   tsize_t tilesize = TIFFTileSize(in);
 785   unsigned char *tilebuf = NULL;
 786
 787   bytes_per_sample = (bps + 7) / 8;
 788   bytes_per_pixel  = ((bps * spp) + 7) / 8;
 789
 790   if ((bps % 8) == 0)
 791     shift_width = 0;
 792   else
 793     {
 794     if (bytes_per_pixel < (bytes_per_sample + 1))
 795       shift_width = bytes_per_pixel;
 796     else
 797       shift_width = bytes_per_sample + 1;
 798     }
 799
 800   tile_buffsize = tilesize;
 801
 802   if (tilesize < (tsize_t)(tl * tile_rowsize))
 803     {
 804 #ifdef DEBUG2
 805     TIFFError("readContigTilesIntoBuffer",
 806               "Tilesize %lu is too small, using alternate calculation %u",
 807               tilesize, tl * tile_rowsize);
 808 #endif
 809     tile_buffsize = tl * tile_rowsize;
 810     }
 811
 812   tilebuf = _TIFFmalloc(tile_buffsize);
 813   if (tilebuf == 0)
 814     return 0;
 815
 816   dst_rowsize = ((imagewidth * bps * spp) + 7) / 8;
 817   for (row = 0; row < imagelength; row += tl)
 818     {
 819     nrow = (row + tl > imagelength) ? imagelength - row : tl;
 820     for (col = 0; col < imagewidth; col += tw)
 821       {
 822       tbytes = TIFFReadTile(in, tilebuf, col, row, 0, 0);
 823       if (tbytes < tilesize  && !ignore)
 824         {
 825         TIFFError(TIFFFileName(in),
 826                   "Error, can't read tile at row %lu col %lu, Read %lu bytes of %lu",
 827                   (unsigned long) col, (unsigned long) row, (unsigned long)tbytes,
 828                   (unsigned long)tilesize);
 829                   status = 0;
 830                   _TIFFfree(tilebuf);
 831                   return status;
 832         }
 833
 834       row_offset = row * dst_rowsize;
 835       col_offset = ((col * bps * spp) + 7)/ 8;
 836       bufp = buf + row_offset + col_offset;
 837
 838       if (col + tw > imagewidth)
 839         ncol = imagewidth - col;
 840       else
 841         ncol = tw;
 842
 843       /* Each tile scanline will start on a byte boundary but it
 844        * has to be merged into the scanline for the entire
 845        * image buffer and the previous segment may not have
 846        * ended on a byte boundary
 847        */
 848       /* Optimization for common bit depths, all samples */
 849       if (((bps % 8) == 0) && (count == spp))
 850         {
 851         for (trow = 0; trow < nrow; trow++)
 852           {
 853           src_offset = trow * tile_rowsize;
 854           _TIFFmemcpy (bufp, tilebuf + src_offset, (ncol * spp * bps) / 8);
 855           bufp += (imagewidth * bps * spp) / 8;
 856           }
 857         }
 858       else
 859         {
 860         /* Bit depths not a multiple of 8 and/or extract fewer than spp samples */
 861         prev_trailing_bits = trailing_bits = 0;
 862         trailing_bits = (ncol * bps * spp) % 8;
 863
 864         /*      for (trow = 0; tl < nrow; trow++) */
 865         for (trow = 0; trow < nrow; trow++)
 866           {
 867           src_offset = trow * tile_rowsize;
 868           src = tilebuf + src_offset;
 869           dst_offset = (row + trow) * dst_rowsize;
 870           dst = buf + dst_offset + col_offset;
 871           switch (shift_width)
 872             {
 873             case 0: if (extractContigSamplesBytes (src, dst, ncol, sample,
 874                                                    spp, bps, count, 0, ncol))
 875                       {
 876                       TIFFError("readContigTilesIntoBuffer",
 877                                 "Unable to extract row %d from tile %lu",
 878                                 row, (unsigned long)TIFFCurrentTile(in));
 879                       return 1;
 880                       }
 881                     break;
 882             case 1: if (bps == 1)
 883                       {
 884                       if (extractContigSamplesShifted8bits (src, dst, ncol,
 885                                                             sample, spp,
 886                                                             bps, count,
 887                                                             0, ncol,
 888                                                             prev_trailing_bits))
 889                         {
 890                         TIFFError("readContigTilesIntoBuffer",
 891                                   "Unable to extract row %d from tile %lu",
 892                                   row, (unsigned long)TIFFCurrentTile(in));
 893                         return 1;
 894                         }
 895                       break;
 896                       }
 897                     else
 898                       if (extractContigSamplesShifted16bits (src, dst, ncol,
 899                                                              sample, spp,
 900                                                              bps, count,
 901                                                              0, ncol,
 902                                                              prev_trailing_bits))
 903                         {
 904                         TIFFError("readContigTilesIntoBuffer",
 905                                   "Unable to extract row %d from tile %lu",
 906                                   row, (unsigned long)TIFFCurrentTile(in));
 907                         return 1;
 908                         }
 909                     break;
 910             case 2: if (extractContigSamplesShifted24bits (src, dst, ncol,
 911                                                            sample, spp,
 912                                                            bps, count,
 913                                                            0, ncol,
 914                                                            prev_trailing_bits))
 915                       {
 916                       TIFFError("readContigTilesIntoBuffer",
 917                                 "Unable to extract row %d from tile %lu",
 918                                 row, (unsigned long)TIFFCurrentTile(in));
 919                       return 1;
 920                       }
 921                     break;
 922             case 3:
 923             case 4:
 924             case 5: if (extractContigSamplesShifted32bits (src, dst, ncol,
 925                                                            sample, spp,
 926                                                            bps, count,
 927                                                            0, ncol,
 928                                                            prev_trailing_bits))
 929                       {
 930                       TIFFError("readContigTilesIntoBuffer",
 931                                 "Unable to extract row %d from tile %lu",
 932                                 row, (unsigned long)TIFFCurrentTile(in));
 933                       return 1;
 934                       }
 935                     break;
 936             default: TIFFError("readContigTilesIntoBuffer", "Unsupported bit depth %d", bps);
 937                      return 1;
 938             }
 939           }
 940         prev_trailing_bits += trailing_bits;
 941         if (prev_trailing_bits > 7)
 942           prev_trailing_bits-= 8;
 943         }
 944       }
 945     }
 946
 947   _TIFFfree(tilebuf);
 948   return status;
 949   }
 950
 951 static int  readSeparateTilesIntoBuffer (TIFF* in, uint8 *obuf,
 952                                          uint32 imagelength, uint32 imagewidth,
 953                                          uint32 tw, uint32 tl,
 954                                          uint16 spp, uint16 bps)
 955   {
 956   int     i, status = 1, sample;
 957   int     shift_width, bytes_per_pixel;
 958   uint16  bytes_per_sample;
 959   uint32  row, col;     /* Current row and col of image */
 960   uint32  nrow, ncol;   /* Number of rows and cols in current tile */
 961   uint32  row_offset, col_offset; /* Output buffer offsets */
 962   tsize_t tbytes = 0, tilesize = TIFFTileSize(in);
 963   tsample_t s;
 964   uint8*  bufp = (uint8*)obuf;
 965   unsigned char *srcbuffs[MAX_SAMPLES];
 966   unsigned char *tbuff = NULL;
 967
 968   bytes_per_sample = (bps + 7) / 8;
 969
 970   for (sample = 0; (sample < spp) && (sample < MAX_SAMPLES); sample++)
 971     {
 972     srcbuffs[sample] = NULL;
 973     tbuff = (unsigned char *)_TIFFmalloc(tilesize + 8);
 974     if (!tbuff)
 975       {
 976       TIFFError ("readSeparateTilesIntoBuffer",
 977                  "Unable to allocate tile read buffer for sample %d", sample);
 978       for (i = 0; i < sample; i++)
 979         _TIFFfree (srcbuffs[i]);
 980       return 0;
 981       }
 982     srcbuffs[sample] = tbuff;
 983     }
 984   /* Each tile contains only the data for a single plane
 985    * arranged in scanlines of tw * bytes_per_sample bytes.
 986    */
 987   for (row = 0; row < imagelength; row += tl)
 988     {
 989     nrow = (row + tl > imagelength) ? imagelength - row : tl;
 990     for (col = 0; col < imagewidth; col += tw)
 991       {
 992       for (s = 0; s < spp; s++)
 993         {  /* Read each plane of a tile set into srcbuffs[s] */
 994         tbytes = TIFFReadTile(in, srcbuffs[s], col, row, 0, s);
 995         if (tbytes < 0  && !ignore)
 996           {
 997           TIFFError(TIFFFileName(in),
 998                  "Error, can't read tile for row %lu col %lu, "
 999                  "sample %lu",
1000                  (unsigned long) col, (unsigned long) row,
1001                  (unsigned long) s);
1002                  status = 0;
1003           for (sample = 0; (sample < spp) && (sample < MAX_SAMPLES); sample++)
1004             {
1005             tbuff = srcbuffs[sample];
1006             if (tbuff != NULL)
1007               _TIFFfree(tbuff);
1008             }
1009           return status;
1010           }
1011         }
1012      /* Tiles on the right edge may be padded out to tw
1013       * which must be a multiple of 16.
1014       * Ncol represents the visible (non padding) portion.
1015       */
1016       if (col + tw > imagewidth)
1017         ncol = imagewidth - col;
1018       else
1019         ncol = tw;
1020
1021       row_offset = row * (((imagewidth * spp * bps) + 7) / 8);
1022       col_offset = ((col * spp * bps) + 7) / 8;
1023       bufp = obuf + row_offset + col_offset;
1024
1025       if ((bps % 8) == 0)
1026         {
1027         if (combineSeparateTileSamplesBytes(srcbuffs, bufp, ncol, nrow, imagewidth,
1028                                             tw, spp, bps, NULL, 0, 0))
1029           {
1030           status = 0;
1031           break;
1032           }
1033         }
1034       else
1035         {
1036         bytes_per_pixel  = ((bps * spp) + 7) / 8;
1037         if (bytes_per_pixel < (bytes_per_sample + 1))
1038           shift_width = bytes_per_pixel;
1039         else
1040           shift_width = bytes_per_sample + 1;
1041
1042         switch (shift_width)
1043           {
1044           case 1: if (combineSeparateTileSamples8bits (srcbuffs, bufp, ncol, nrow,
1045                                                        imagewidth, tw, spp, bps,
1046                                                        NULL, 0, 0))
1047                     {
1048                     status = 0;
1049                     break;
1050                     }
1051                   break;
1052           case 2: if (combineSeparateTileSamples16bits (srcbuffs, bufp, ncol, nrow,
1053                                                        imagewidth, tw, spp, bps,
1054                                                        NULL, 0, 0))
1055                     {
1056                     status = 0;
1057                     break;
1058                     }
1059                   break;
1060           case 3: if (combineSeparateTileSamples24bits (srcbuffs, bufp, ncol, nrow,
1061                                                        imagewidth, tw, spp, bps,
1062                                                        NULL, 0, 0))
1063                     {
1064                     status = 0;
1065                     break;
1066                     }
1067                   break;
1068           case 4:
1069           case 5:
1070           case 6:
1071           case 7:
1072           case 8: if (combineSeparateTileSamples32bits (srcbuffs, bufp, ncol, nrow,
1073                                                        imagewidth, tw, spp, bps,
1074                                                        NULL, 0, 0))
1075                     {
1076                     status = 0;
1077                     break;
1078                     }
1079                   break;
1080           default: TIFFError ("readSeparateTilesIntoBuffer", "Unsupported bit depth: %d", bps);
1081                   status = 0;
1082                   break;
1083           }
1084         }
1085       }
1086     }
1087
1088   for (sample = 0; (sample < spp) && (sample < MAX_SAMPLES); sample++)
1089     {
1090     tbuff = srcbuffs[sample];
1091     if (tbuff != NULL)
1092       _TIFFfree(tbuff);
1093     }
1094
1095   return status;
1096   }
1097
1098 static int writeBufferToContigStrips(TIFF* out, uint8* buf, uint32 imagelength)
1099   {
1100   uint32 row, nrows, rowsperstrip;
1101   tstrip_t strip = 0;
1102   tsize_t stripsize;
1103
1104   TIFFGetFieldDefaulted(out, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1105   for (row = 0; row < imagelength; row += rowsperstrip)
1106     {
1107     nrows = (row + rowsperstrip > imagelength) ?
1108              imagelength - row : rowsperstrip;
1109     stripsize = TIFFVStripSize(out, nrows);
1110     if (TIFFWriteEncodedStrip(out, strip++, buf, stripsize) < 0)
1111       {
1112       TIFFError(TIFFFileName(out), "Error, can't write strip %u", strip - 1);
1113       return 1;
1114       }
1115     buf += stripsize;
1116     }
1117
1118   return 0;
1119   }
1120
1121 /* Abandon plans to modify code so that plannar orientation separate images
1122  * do not have all samples for each channel written before all samples
1123  * for the next channel have been abandoned.
1124  * Libtiff internals seem to depend on all data for a given sample
1125  * being contiguous within a strip or tile when PLANAR_CONFIG is
1126  * separate. All strips or tiles of a given plane are written
1127  * before any strips or tiles of a different plane are stored.
1128  */
1129 static int
1130 writeBufferToSeparateStrips (TIFF* out, uint8* buf,
1131                              uint32 length, uint32 width, uint16 spp,
1132                              struct dump_opts *dump)
1133   {
1134   uint8   *src;
1135   uint16   bps;
1136   uint32   row, nrows, rowsize, rowsperstrip;
1137   uint32   bytes_per_sample;
1138   tsample_t s;
1139   tstrip_t strip = 0;
1140   tsize_t  stripsize = TIFFStripSize(out);
1141   tsize_t  rowstripsize,  scanlinesize = TIFFScanlineSize(out);
1142   tsize_t  total_bytes = 0;
1143   tdata_t  obuf;
1144
1145   (void) TIFFGetFieldDefaulted(out, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1146   (void) TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps);
1147   bytes_per_sample = (bps + 7) / 8;
1148   rowsize = ((bps * spp * width) + 7) / 8; /* source has interleaved samples */
1149   rowstripsize = rowsperstrip * bytes_per_sample * (width + 1);
1150
1151   obuf = _TIFFmalloc (rowstripsize);
1152   if (obuf == NULL)
1153     return 1;
1154
1155   for (s = 0; s < spp; s++)
1156     {
1157     for (row = 0; row < length; row += rowsperstrip)
1158       {
1159       nrows = (row + rowsperstrip > length) ? length - row : rowsperstrip;
1160
1161       stripsize = TIFFVStripSize(out, nrows);
1162       src = buf + (row * rowsize);
1163       total_bytes += stripsize;
1164       memset (obuf, '\0', rowstripsize);
1165       if (extractContigSamplesToBuffer(obuf, src, nrows, width, s, spp, bps, dump))
1166         {
1167         _TIFFfree(obuf);
1168         return 1;
1169         }
1170       if ((dump->outfile != NULL) && (dump->level == 1))
1171         {
1172         dump_info(dump->outfile, dump->format,"",
1173                   "Sample %2d, Strip: %2d, bytes: %4d, Row %4d, bytes: %4d, Input offset: %6d",
1174                   s + 1, strip + 1, stripsize, row + 1, scanlinesize, src - buf);
1175         dump_buffer(dump->outfile, dump->format, nrows, scanlinesize, row, obuf);
1176         }
1177
1178       if (TIFFWriteEncodedStrip(out, strip++, obuf, stripsize) < 0)
1179         {
1180         TIFFError(TIFFFileName(out), "Error, can't write strip %u", strip - 1);
1181         _TIFFfree(obuf);
1182         return 1;
1183         }
1184       }
1185     }
1186
1187   _TIFFfree(obuf);
1188   return 0;
1189 }
1190
1191 /* Extract all planes from contiguous buffer into a single tile buffer
1192  * to be written out as a tile.
1193  */
1194 static int writeBufferToContigTiles (TIFF* out, uint8* buf, uint32 imagelength,
1195                                        uint32 imagewidth, tsample_t spp,
1196                                        struct dump_opts* dump)
1197   {
1198   uint16 bps;
1199   uint32 tl, tw;
1200   uint32 row, col, nrow, ncol;
1201   uint32 src_rowsize, col_offset;
1202   uint32 tile_rowsize  = TIFFTileRowSize(out);
1203   uint8* bufp = (uint8*) buf;
1204   tsize_t tile_buffsize = 0;
1205   tsize_t tilesize = TIFFTileSize(out);
1206   unsigned char *tilebuf = NULL;
1207
1208   TIFFGetField(out, TIFFTAG_TILELENGTH, &tl);
1209   TIFFGetField(out, TIFFTAG_TILEWIDTH, &tw);
1210   TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps);
1211
1212   tile_buffsize = tilesize;
1213   if (tilesize < (tsize_t)(tl * tile_rowsize))
1214     {
1215 #ifdef DEBUG2
1216     TIFFError("writeBufferToContigTiles",
1217               "Tilesize %lu is too small, using alternate calculation %u",
1218               tilesize, tl * tile_rowsize);
1219 #endif
1220     tile_buffsize = tl * tile_rowsize;
1221     }
1222
1223   tilebuf = _TIFFmalloc(tile_buffsize);
1224   if (tilebuf == 0)
1225     return 1;
1226
1227   src_rowsize = ((imagewidth * spp * bps) + 7) / 8;
1228   for (row = 0; row < imagelength; row += tl)
1229     {
1230     nrow = (row + tl > imagelength) ? imagelength - row : tl;
1231     for (col = 0; col < imagewidth; col += tw)
1232       {
1233       /* Calculate visible portion of tile. */
1234       if (col + tw > imagewidth)
1235         ncol = imagewidth - col;
1236       else
1237         ncol = tw;
1238
1239       col_offset = (((col * bps * spp) + 7) / 8);
1240       bufp = buf + (row * src_rowsize) + col_offset;
1241       if (extractContigSamplesToTileBuffer(tilebuf, bufp, nrow, ncol, imagewidth,
1242                                            tw, 0, spp, spp, bps, dump) > 0)
1243         {
1244         TIFFError("writeBufferToContigTiles",
1245                   "Unable to extract data to tile for row %lu, col %lu",
1246                   (unsigned long) row, (unsigned long)col);
1247         _TIFFfree(tilebuf);
1248         return 1;
1249         }
1250
1251       if (TIFFWriteTile(out, tilebuf, col, row, 0, 0) < 0)
1252         {
1253         TIFFError("writeBufferToContigTiles",
1254                   "Cannot write tile at %lu %lu",
1255                   (unsigned long) col, (unsigned long) row);
1256          _TIFFfree(tilebuf);
1257         return 1;
1258         }
1259       }
1260     }
1261   _TIFFfree(tilebuf);
1262
1263   return 0;
1264   } /* end writeBufferToContigTiles */
1265
1266 /* Extract each plane from contiguous buffer into a single tile buffer
1267  * to be written out as a tile.
1268  */
1269 static int writeBufferToSeparateTiles (TIFF* out, uint8* buf, uint32 imagelength,
1270                                        uint32 imagewidth, tsample_t spp,
1271                                        struct dump_opts * dump)
1272   {
1273   tdata_t obuf = _TIFFmalloc(TIFFTileSize(out));
1274   uint32 tl, tw;
1275   uint32 row, col, nrow, ncol;
1276   uint32 src_rowsize, col_offset;
1277   uint16 bps;
1278   tsample_t s;
1279   uint8* bufp = (uint8*) buf;
1280
1281   if (obuf == NULL)
1282     return 1;
1283
1284   TIFFGetField(out, TIFFTAG_TILELENGTH, &tl);
1285   TIFFGetField(out, TIFFTAG_TILEWIDTH, &tw);
1286   TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps);
1287   src_rowsize = ((imagewidth * spp * bps) + 7) / 8;
1288
1289   for (row = 0; row < imagelength; row += tl)
1290     {
1291     nrow = (row + tl > imagelength) ? imagelength - row : tl;
1292     for (col = 0; col < imagewidth; col += tw)
1293       {
1294       /* Calculate visible portion of tile. */
1295       if (col + tw > imagewidth)
1296         ncol = imagewidth - col;
1297       else
1298         ncol = tw;
1299
1300       col_offset = (((col * bps * spp) + 7) / 8);
1301       bufp = buf + (row * src_rowsize) + col_offset;
1302
1303       for (s = 0; s < spp; s++)
1304         {
1305         if (extractContigSamplesToTileBuffer(obuf, bufp, nrow, ncol, imagewidth,
1306                                              tw, s, 1, spp, bps, dump) > 0)
1307           {
1308           TIFFError("writeBufferToSeparateTiles",
1309                     "Unable to extract data to tile for row %lu, col %lu sample %d",
1310                     (unsigned long) row, (unsigned long)col, (int)s);
1311           _TIFFfree(obuf);
1312           return 1;
1313           }
1314
1315         if (TIFFWriteTile(out, obuf, col, row, 0, s) < 0)
1316           {
1317            TIFFError("writeBufferToseparateTiles",
1318                      "Cannot write tile at %lu %lu sample %lu",
1319                      (unsigned long) col, (unsigned long) row,
1320                      (unsigned long) s);
1321            _TIFFfree(obuf);
1322            return 1;
1323           }
1324         }
1325       }
1326     }
1327   _TIFFfree(obuf);
1328
1329   return 0;
1330   } /* end writeBufferToSeparateTiles */
1331
1332 static void
1333 processG3Options(char* cp)
1334 {
1335         if( (cp = strchr(cp, ':')) ) {
1336                 if (defg3opts == (uint32) -1)
1337                         defg3opts = 0;
1338                 do {
1339                         cp++;
1340                         if (strneq(cp, "1d", 2))
1341                                 defg3opts &= ~GROUP3OPT_2DENCODING;
1342                         else if (strneq(cp, "2d", 2))
1343                                 defg3opts |= GROUP3OPT_2DENCODING;
1344                         else if (strneq(cp, "fill", 4))
1345                                 defg3opts |= GROUP3OPT_FILLBITS;
1346                         else
1347                                 usage();
1348                 } while( (cp = strchr(cp, ':')) );
1349         }
1350 }
1351
1352 static int
1353 processCompressOptions(char* opt)
1354   {
1355   char* cp = NULL;
1356
1357   if (strneq(opt, "none",4))
1358     {
1359     defcompression = COMPRESSION_NONE;
1360     }
1361   else if (streq(opt, "packbits"))
1362     {
1363     defcompression = COMPRESSION_PACKBITS;
1364     }
1365   else if (strneq(opt, "jpeg", 4))
1366     {
1367     cp = strchr(opt, ':');
1368     defcompression = COMPRESSION_JPEG;
1369
1370     while (cp)
1371       {
1372       if (isdigit((int)cp[1]))
1373         quality = atoi(cp + 1);
1374       else if (strneq(cp + 1, "raw", 3 ))
1375         jpegcolormode = JPEGCOLORMODE_RAW;
1376       else if (strneq(cp + 1, "rgb", 3 ))
1377         jpegcolormode = JPEGCOLORMODE_RGB;
1378       else
1379         usage();
1380       cp = strchr(cp + 1, ':');
1381       }
1382     }
1383   else if (strneq(opt, "g3", 2))
1384     {
1385     processG3Options(opt);
1386     defcompression = COMPRESSION_CCITTFAX3;
1387     }
1388   else if (streq(opt, "g4"))
1389     {
1390     defcompression = COMPRESSION_CCITTFAX4;
1391     }
1392   else if (strneq(opt, "lzw", 3))
1393     {
1394     cp = strchr(opt, ':');
1395     if (cp)
1396       defpredictor = atoi(cp+1);
1397     defcompression = COMPRESSION_LZW;
1398     }
1399   else if (strneq(opt, "zip", 3))
1400     {
1401     cp = strchr(opt, ':');
1402     if (cp)
1403       defpredictor = atoi(cp+1);
1404     defcompression = COMPRESSION_ADOBE_DEFLATE;
1405    }
1406   else
1407     return (0);
1408
1409   return (1);
1410   }
1411
1412 static void
1413 usage(void)
1414   {
1415   int i;
1416
1417   fprintf(stderr, "\n%s\n", TIFFGetVersion());
1418   for (i = 0; usage_info[i] != NULL; i++)
1419     fprintf(stderr, "%s\n", usage_info[i]);
1420   exit(-1);
1421   }
1422
1423 #define CopyField(tag, v) \
1424     if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
1425 #define CopyField2(tag, v1, v2) \
1426     if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
1427 #define CopyField3(tag, v1, v2, v3) \
1428     if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
1429 #define CopyField4(tag, v1, v2, v3, v4) \
1430     if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
1431
1432 static void
1433 cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
1434 {
1435         switch (type) {
1436         case TIFF_SHORT:
1437                 if (count == 1) {
1438                         uint16 shortv;
1439                         CopyField(tag, shortv);
1440                 } else if (count == 2) {
1441                         uint16 shortv1, shortv2;
1442                         CopyField2(tag, shortv1, shortv2);
1443                 } else if (count == 4) {
1444                         uint16 *tr, *tg, *tb, *ta;
1445                         CopyField4(tag, tr, tg, tb, ta);
1446                 } else if (count == (uint16) -1) {
1447                         uint16 shortv1;
1448                         uint16* shortav;
1449                         CopyField2(tag, shortv1, shortav);
1450                 }
1451                 break;
1452         case TIFF_LONG:
1453                 { uint32 longv;
1454                   CopyField(tag, longv);
1455                 }
1456                 break;
1457         case TIFF_RATIONAL:
1458                 if (count == 1) {
1459                         float floatv;
1460                         CopyField(tag, floatv);
1461                 } else if (count == (uint16) -1) {
1462                         float* floatav;
1463                         CopyField(tag, floatav);
1464                 }
1465                 break;
1466         case TIFF_ASCII:
1467                 { char* stringv;
1468                   CopyField(tag, stringv);
1469                 }
1470                 break;
1471         case TIFF_DOUBLE:
1472                 if (count == 1) {
1473                         double doublev;
1474                         CopyField(tag, doublev);
1475                 } else if (count == (uint16) -1) {
1476                         double* doubleav;
1477                         CopyField(tag, doubleav);
1478                 }
1479                 break;
1480           default:
1481                 TIFFError(TIFFFileName(in),
1482                           "Data type %d is not supported, tag %d skipped",
1483                           tag, type);
1484         }
1485 }
1486
1487 static struct cpTag {
1488         uint16  tag;
1489         uint16  count;
1490         TIFFDataType type;
1491 } tags[] = {
1492         { TIFFTAG_SUBFILETYPE,          1, TIFF_LONG },
1493         { TIFFTAG_THRESHHOLDING,        1, TIFF_SHORT },
1494         { TIFFTAG_DOCUMENTNAME,         1, TIFF_ASCII },
1495         { TIFFTAG_IMAGEDESCRIPTION,     1, TIFF_ASCII },
1496         { TIFFTAG_MAKE,                 1, TIFF_ASCII },
1497         { TIFFTAG_MODEL,                1, TIFF_ASCII },
1498         { TIFFTAG_MINSAMPLEVALUE,       1, TIFF_SHORT },
1499         { TIFFTAG_MAXSAMPLEVALUE,       1, TIFF_SHORT },
1500         { TIFFTAG_XRESOLUTION,          1, TIFF_RATIONAL },
1501         { TIFFTAG_YRESOLUTION,          1, TIFF_RATIONAL },
1502         { TIFFTAG_PAGENAME,             1, TIFF_ASCII },
1503         { TIFFTAG_XPOSITION,            1, TIFF_RATIONAL },
1504         { TIFFTAG_YPOSITION,            1, TIFF_RATIONAL },
1505         { TIFFTAG_RESOLUTIONUNIT,       1, TIFF_SHORT },
1506         { TIFFTAG_SOFTWARE,             1, TIFF_ASCII },
1507         { TIFFTAG_DATETIME,             1, TIFF_ASCII },
1508         { TIFFTAG_ARTIST,               1, TIFF_ASCII },
1509         { TIFFTAG_HOSTCOMPUTER,         1, TIFF_ASCII },
1510         { TIFFTAG_WHITEPOINT,           (uint16) -1, TIFF_RATIONAL },
1511         { TIFFTAG_PRIMARYCHROMATICITIES,(uint16) -1,TIFF_RATIONAL },
1512         { TIFFTAG_HALFTONEHINTS,        2, TIFF_SHORT },
1513         { TIFFTAG_INKSET,               1, TIFF_SHORT },
1514         { TIFFTAG_DOTRANGE,             2, TIFF_SHORT },
1515         { TIFFTAG_TARGETPRINTER,        1, TIFF_ASCII },
1516         { TIFFTAG_SAMPLEFORMAT,         1, TIFF_SHORT },
1517         { TIFFTAG_YCBCRCOEFFICIENTS,    (uint16) -1,TIFF_RATIONAL },
1518         { TIFFTAG_YCBCRSUBSAMPLING,     2, TIFF_SHORT },
1519         { TIFFTAG_YCBCRPOSITIONING,     1, TIFF_SHORT },
1520         { TIFFTAG_REFERENCEBLACKWHITE,  (uint16) -1,TIFF_RATIONAL },
1521         { TIFFTAG_EXTRASAMPLES,         (uint16) -1, TIFF_SHORT },
1522         { TIFFTAG_SMINSAMPLEVALUE,      1, TIFF_DOUBLE },
1523         { TIFFTAG_SMAXSAMPLEVALUE,      1, TIFF_DOUBLE },
1524         { TIFFTAG_STONITS,              1, TIFF_DOUBLE },
1525 };
1526 #define NTAGS   (sizeof (tags) / sizeof (tags[0]))
1527
1528 #define CopyTag(tag, count, type)       cpTag(in, out, tag, count, type)
1529
1530 /* Functions written by Richard Nolde, with exceptions noted. */
1531 void  process_command_opts (int argc, char *argv[], char *mp, char *mode, uint32 *dirnum,
1532                             uint16 *defconfig, uint16 *deffillorder, uint32 *deftilewidth,
1533                             uint32 *deftilelength, uint32 *defrowsperstrip,
1534                             struct crop_mask *crop_data, struct pagedef *page,
1535                             struct dump_opts *dump,
1536                             unsigned int     *imagelist, unsigned int   *image_count )
1537     {
1538     int   c, good_args = 0;
1539     char *opt_offset   = NULL;    /* Position in string of value sought */
1540     char *opt_ptr      = NULL;    /* Pointer to next token in option set */
1541     char *sep          = NULL;    /* Pointer to a token separator */
1542     unsigned int  i, j, start, end;
1543     extern int   optind;
1544     extern char* optarg;
1545
1546     *mp++ = 'w';
1547     *mp = '\0';
1548     while ((c = getopt(argc, argv,
1549        "ac:d:e:f:hil:m:p:r:stvw:z:BCD:E:F:H:I:J:K:LMN:O:P:R:S:U:V:X:Y:Z:")) != -1)
1550       {
1551     good_args++;
1552     switch (c) {
1553       case 'a': mode[0] = 'a';  /* append to output */
1554                 break;
1555       case 'c': if (!processCompressOptions(optarg)) /* compression scheme */
1556                   {
1557                   TIFFError ("Unknown compression option", "%s", optarg);
1558                   TIFFError ("For valid options type", "tiffcrop -h");
1559                   exit (-1);
1560                   }
1561                 break;
1562       case 'd': start = strtoul(optarg, NULL, 0); /* initial IFD offset */
1563                 if (start == 0)
1564                   {
1565                   TIFFError ("","Directory offset must be greater than zero");
1566                   TIFFError ("For valid options type", "tiffcrop -h");
1567                   exit (-1);
1568                   }
1569                 *dirnum = start - 1;
1570                 break;
1571       case 'e': switch (tolower(optarg[0])) /* image export modes*/
1572                   {
1573                   case 'c': crop_data->exp_mode = ONE_FILE_COMPOSITE;
1574                             crop_data->img_mode = COMPOSITE_IMAGES;
1575                             break; /* Composite */
1576                   case 'd': crop_data->exp_mode = ONE_FILE_SEPARATED;
1577                             crop_data->img_mode = SEPARATED_IMAGES;
1578                             break; /* Divided */
1579                   case 'i': crop_data->exp_mode = FILE_PER_IMAGE_COMPOSITE;
1580                             crop_data->img_mode = COMPOSITE_IMAGES;
1581                             break; /* Image */
1582                   case 'm': crop_data->exp_mode = FILE_PER_IMAGE_SEPARATED;
1583                             crop_data->img_mode = SEPARATED_IMAGES;
1584                             break; /* Multiple */
1585                   case 's': crop_data->exp_mode = FILE_PER_SELECTION;
1586                             crop_data->img_mode = SEPARATED_IMAGES;
1587                             break; /* Sections */
1588                   default:  TIFFError ("Unknown export mode","%s", optarg);
1589                             TIFFError ("For valid options type", "tiffcrop -h");
1590                             exit (-1);
1591                   }
1592                 break;
1593       case 'f': if (streq(optarg, "lsb2msb"))      /* fill order */
1594                   *deffillorder = FILLORDER_LSB2MSB;
1595                 else if (streq(optarg, "msb2lsb"))
1596                   *deffillorder = FILLORDER_MSB2LSB;
1597                 else
1598                   {
1599                   TIFFError ("Unknown fill order", "%s", optarg);
1600                   TIFFError ("For valid options type", "tiffcrop -h");
1601                   exit (-1);
1602                   }
1603                 break;
1604       case 'h': usage();
1605                 break;
1606       case 'i': ignore = TRUE;          /* ignore errors */
1607                 break;
1608       case 'l': outtiled = TRUE;         /* tile length */
1609                 *deftilelength = atoi(optarg);
1610                 break;
1611       case 'p': /* planar configuration */
1612                 if (streq(optarg, "separate"))
1613                   *defconfig = PLANARCONFIG_SEPARATE;
1614                 else if (streq(optarg, "contig"))
1615                   *defconfig = PLANARCONFIG_CONTIG;
1616                 else
1617                   {
1618                   TIFFError ("Unkown planar configuration", "%s", optarg);
1619                   TIFFError ("For valid options type", "tiffcrop -h");
1620                   exit (-1);
1621                   }
1622                 break;
1623       case 'r': /* rows/strip */
1624                 *defrowsperstrip = atol(optarg);
1625                 break;
1626       case 's': /* generate stripped output */
1627                 outtiled = FALSE;
1628                 break;
1629       case 't': /* generate tiled output */
1630                 outtiled = TRUE;
1631                 break;
1632       case 'v': TIFFError("Library Release", "%s", TIFFGetVersion());
1633                 TIFFError ("Tiffcrop version", "%s, last updated: %s",
1634                            tiffcrop_version_id, tiffcrop_rev_date);
1635                 TIFFError ("Tiffcp code", "Copyright (c) 1988-1997 Sam Leffler");
1636                 TIFFError ("           ", "Copyright (c) 1991-1997 Silicon Graphics, Inc");
1637                 TIFFError ("Tiffcrop additions", "Copyright (c) 2007-2010 Richard Nolde");
1638                 exit (0);
1639                 break;
1640       case 'w': /* tile width */
1641                 outtiled = TRUE;
1642                 *deftilewidth = atoi(optarg);
1643                 break;
1644       case 'z': /* regions of an image specified as x1,y1,x2,y2:x3,y3,x4,y4 etc */
1645                 crop_data->crop_mode |= CROP_REGIONS;
1646                 for (i = 0, opt_ptr = strtok (optarg, ":");
1647                    ((opt_ptr != NULL) &&  (i < MAX_REGIONS));
1648                     (opt_ptr = strtok (NULL, ":")), i++)
1649                     {
1650                     crop_data->regions++;
1651                     if (sscanf(opt_ptr, "%lf,%lf,%lf,%lf",
1652                                &crop_data->corners[i].X1, &crop_data->corners[i].Y1,
1653                                &crop_data->corners[i].X2, &crop_data->corners[i].Y2) != 4)
1654                       {
1655                       TIFFError ("Unable to parse coordinates for region", "%d %s", i, optarg);
1656                       TIFFError ("For valid options type", "tiffcrop -h");
1657                       exit (-1);
1658                       }
1659                     }
1660                 /*  check for remaining elements over MAX_REGIONS */
1661                 if ((opt_ptr != NULL) && (i >= MAX_REGIONS))
1662                   {
1663                   TIFFError ("Region list exceeds limit of", "%d regions %s", MAX_REGIONS, optarg);
1664                   TIFFError ("For valid options type", "tiffcrop -h");
1665                   exit (-1);;
1666                   }
1667                 break;
1668       /* options for file open modes */
1669       case 'B': *mp++ = 'b'; *mp = '\0';
1670                 break;
1671       case 'L': *mp++ = 'l'; *mp = '\0';
1672                 break;
1673       case 'M': *mp++ = 'm'; *mp = '\0';
1674                 break;
1675       case 'C': *mp++ = 'c'; *mp = '\0';
1676                 break;
1677       /* options for Debugging / data dump */
1678       case 'D': for (i = 0, opt_ptr = strtok (optarg, ",");
1679                     (opt_ptr != NULL);
1680                     (opt_ptr = strtok (NULL, ",")), i++)
1681                     {
1682                     opt_offset = strpbrk(opt_ptr, ":=");
1683                     if (opt_offset == NULL)
1684                       {
1685                       TIFFError("Invalid dump option", "%s", optarg);
1686                       TIFFError ("For valid options type", "tiffcrop -h");
1687                       exit (-1);
1688                       }
1689
1690                     *opt_offset = '\0';
1691                     /* convert option to lowercase */
1692                     end = strlen (opt_ptr);
1693                     for (i = 0; i < end; i++)
1694                       *(opt_ptr + i) = tolower(*(opt_ptr + i));
1695                     /* Look for dump format specification */
1696                     if (strncmp(opt_ptr, "for", 3) == 0)
1697                       {
1698                       /* convert value to lowercase */
1699                       end = strlen (opt_offset + 1);
1700                       for (i = 1; i <= end; i++)
1701                         *(opt_offset + i) = tolower(*(opt_offset + i));
1702                       /* check dump format value */
1703                       if (strncmp (opt_offset + 1, "txt", 3) == 0)
1704                         {
1705                         dump->format = DUMP_TEXT;
1706                         strcpy (dump->mode, "w");
1707                         }
1708                       else
1709                         {
1710                         if (strncmp(opt_offset + 1, "raw", 3) == 0)
1711                           {
1712                           dump->format = DUMP_RAW;
1713                           strcpy (dump->mode, "wb");
1714                           }
1715                         else
1716                           {
1717                           TIFFError("parse_command_opts", "Unknown dump format %s", opt_offset + 1);
1718                           TIFFError ("For valid options type", "tiffcrop -h");
1719                           exit (-1);
1720                           }
1721                         }
1722                       }
1723                     else
1724                       { /* Look for dump level specification */
1725                       if (strncmp (opt_ptr, "lev", 3) == 0)
1726                         dump->level = atoi(opt_offset + 1);
1727                         /* Look for input data dump file name */
1728                       if (strncmp (opt_ptr, "in", 2) == 0)
1729                         {
1730                         strncpy (dump->infilename, opt_offset + 1, PATH_MAX - 20);
1731                         dump->infilename[PATH_MAX - 20] = '\0';
1732                         }
1733                         /* Look for output data dump file name */
1734                       if (strncmp (opt_ptr, "out", 3) == 0)
1735                         {
1736                         strncpy (dump->outfilename, opt_offset + 1, PATH_MAX - 20);
1737                         dump->outfilename[PATH_MAX - 20] = '\0';
1738                         }
1739                       if (strncmp (opt_ptr, "deb", 3) == 0)
1740                         dump->debug = atoi(opt_offset + 1);
1741                       }
1742                     }
1743                 if ((strlen(dump->infilename)) || (strlen(dump->outfilename)))
1744                   {
1745                   if (dump->level == 1)
1746                     TIFFError("","Defaulting to dump level 1, no data.");
1747                   if (dump->format == DUMP_NONE)
1748                     {
1749                     TIFFError("", "You must specify a dump format for dump files");
1750                     TIFFError ("For valid options type", "tiffcrop -h");
1751                     exit (-1);
1752                     }
1753                   }
1754                 break;
1755
1756       /* image manipulation routine options */
1757       case 'm': /* margins to exclude from selection, uppercase M was already used */
1758                 /* order of values must be TOP, LEFT, BOTTOM, RIGHT */
1759                 crop_data->crop_mode |= CROP_MARGINS;
1760                 for (i = 0, opt_ptr = strtok (optarg, ",:");
1761                     ((opt_ptr != NULL) &&  (i < 4));
1762                      (opt_ptr = strtok (NULL, ",:")), i++)
1763                     {
1764                     crop_data->margins[i] = atof(opt_ptr);
1765                     }
1766                 break;
1767       case 'E': /* edge reference */
1768                 switch (tolower(optarg[0]))
1769                   {
1770                   case 't': crop_data->edge_ref = EDGE_TOP;
1771                             break;
1772                   case 'b': crop_data->edge_ref = EDGE_BOTTOM;
1773                              break;
1774                   case 'l': crop_data->edge_ref = EDGE_LEFT;
1775                             break;
1776                   case 'r': crop_data->edge_ref = EDGE_RIGHT;
1777                             break;
1778                   default:  TIFFError ("Edge reference must be top, bottom, left, or right", "%s", optarg);
1779                             TIFFError ("For valid options type", "tiffcrop -h");
1780                             exit (-1);
1781                   }
1782                 break;
1783       case 'F': /* flip eg mirror image or cropped segment, M was already used */
1784                 crop_data->crop_mode |= CROP_MIRROR;
1785                 switch (tolower(optarg[0]))
1786                   {
1787                   case  'h': crop_data->mirror = MIRROR_HORIZ;
1788                              break;
1789                   case  'v': crop_data->mirror = MIRROR_VERT;
1790                              break;
1791                   case  'b': crop_data->mirror = MIRROR_BOTH;
1792                              break;
1793                   default:   TIFFError ("Flip mode must be horiz, vert, or both", "%s", optarg);
1794                              TIFFError ("For valid options type", "tiffcrop -h");
1795                              exit (-1);
1796                   }
1797                 break;
1798       case 'H': /* set horizontal resolution to new value */
1799                 page->hres = atof (optarg);
1800                 page->mode |= PAGE_MODE_RESOLUTION;
1801                 break;
1802       case 'I': /* invert the color space, eg black to white */
1803                 crop_data->crop_mode |= CROP_INVERT;
1804                 /* The PHOTOMETIC_INTERPRETATION tag may be updated */
1805                 if (streq(optarg, "black"))
1806                   {
1807                   crop_data->photometric = PHOTOMETRIC_MINISBLACK;
1808                   continue;
1809                   }
1810                 if (streq(optarg, "white"))
1811                   {
1812                   crop_data->photometric = PHOTOMETRIC_MINISWHITE;
1813                   continue;
1814                   }
1815                 if (streq(optarg, "data"))
1816                   {
1817                   crop_data->photometric = INVERT_DATA_ONLY;
1818                   continue;
1819                   }
1820                 if (streq(optarg, "both"))
1821                   {
1822                   crop_data->photometric = INVERT_DATA_AND_TAG;
1823                   continue;
1824                   }
1825
1826                 TIFFError("Missing or unknown option for inverting PHOTOMETRIC_INTERPRETATION", "%s", optarg);
1827                 TIFFError ("For valid options type", "tiffcrop -h");
1828                 exit (-1);
1829                 break;
1830       case 'J': /* horizontal margin for sectioned ouput pages */
1831                 page->hmargin = atof(optarg);
1832                 page->mode |= PAGE_MODE_MARGINS;
1833                 break;
1834       case 'K': /* vertical margin for sectioned ouput pages*/
1835                 page->vmargin = atof(optarg);
1836                 page->mode |= PAGE_MODE_MARGINS;
1837                 break;
1838       case 'N': /* list of images to process */
1839                 for (i = 0, opt_ptr = strtok (optarg, ",");
1840                     ((opt_ptr != NULL) &&  (i < MAX_IMAGES));
1841                      (opt_ptr = strtok (NULL, ",")))
1842                      { /* We do not know how many images are in file yet
1843                         * so we build a list to include the maximum allowed
1844                         * and follow it until we hit the end of the file.
1845                         * Image count is not accurate for odd, even, last
1846                         * so page numbers won't be valid either.
1847                         */
1848                      if (streq(opt_ptr, "odd"))
1849                        {
1850                        for (j = 1; j <= MAX_IMAGES; j += 2)
1851                          imagelist[i++] = j;
1852                        *image_count = (MAX_IMAGES - 1) / 2;
1853                        break;
1854                        }
1855                      else
1856                        {
1857                        if (streq(opt_ptr, "even"))
1858                          {
1859                          for (j = 2; j <= MAX_IMAGES; j += 2)
1860                            imagelist[i++] = j;
1861                          *image_count = MAX_IMAGES / 2;
1862                          break;
1863                          }
1864                        else
1865                          {
1866                          if (streq(opt_ptr, "last"))
1867                            imagelist[i++] = MAX_IMAGES;
1868                          else  /* single value between commas */
1869                            {
1870                            sep = strpbrk(opt_ptr, ":-");
1871                            if (!sep)
1872                              imagelist[i++] = atoi(opt_ptr);
1873                            else
1874                              {
1875                              *sep = '\0';
1876                              start = atoi (opt_ptr);
1877                              if (!strcmp((sep + 1), "last"))
1878                                end = MAX_IMAGES;
1879                              else
1880                                end = atoi (sep + 1);
1881                              for (j = start; j <= end && j - start + i < MAX_IMAGES; j++)
1882                                imagelist[i++] = j;
1883                              }
1884                            }
1885                          }
1886                       }
1887                     }
1888                 *image_count = i;
1889                 break;
1890       case 'O': /* page orientation */
1891                 switch (tolower(optarg[0]))
1892                   {
1893                   case  'a': page->orient = ORIENTATION_AUTO;
1894                              break;
1895                   case  'p': page->orient = ORIENTATION_PORTRAIT;
1896                              break;
1897                   case  'l': page->orient = ORIENTATION_LANDSCAPE;
1898                              break;
1899                   default:  TIFFError ("Orientation must be portrait, landscape, or auto.", "%s", optarg);
1900                             TIFFError ("For valid options type", "tiffcrop -h");
1901                             exit (-1);
1902                   }
1903                 break;
1904       case 'P': /* page size selection */
1905                 if (sscanf(optarg, "%lfx%lf", &page->width, &page->length) == 2)
1906                   {
1907                   strcpy (page->name, "Custom");
1908                   page->mode |= PAGE_MODE_PAPERSIZE;
1909                   break;
1910                   }
1911                 if (get_page_geometry (optarg, page))
1912                   {
1913                   if (!strcmp(optarg, "list"))
1914                     {
1915                     TIFFError("", "Name            Width   Length (in inches)");
1916                     for (i = 0; i < MAX_PAPERNAMES - 1; i++)
1917                       TIFFError ("", "%-15.15s %5.2f   %5.2f",
1918                                PaperTable[i].name, PaperTable[i].width,
1919                                PaperTable[i].length);
1920                     exit (-1);
1921                     }
1922
1923                   TIFFError ("Invalid paper size", "%s", optarg);
1924                   TIFFError ("", "Select one of:");
1925                   TIFFError("", "Name            Width   Length (in inches)");
1926                   for (i = 0; i < MAX_PAPERNAMES - 1; i++)
1927                     TIFFError ("", "%-15.15s %5.2f   %5.2f",
1928                                PaperTable[i].name, PaperTable[i].width,
1929                                PaperTable[i].length);
1930                   exit (-1);
1931                   }
1932                 else
1933                   {
1934                   page->mode |= PAGE_MODE_PAPERSIZE;
1935                   }
1936                 break;
1937       case 'R': /* rotate image or cropped segment */
1938                 crop_data->crop_mode |= CROP_ROTATE;
1939                 switch (strtoul(optarg, NULL, 0))
1940                   {
1941                   case  90:  crop_data->rotation = (uint16)90;
1942                              break;
1943                   case  180: crop_data->rotation = (uint16)180;
1944                              break;
1945                   case  270: crop_data->rotation = (uint16)270;
1946                              break;
1947                   default:   TIFFError ("Rotation must be 90, 180, or 270 degrees clockwise", "%s", optarg);
1948                              TIFFError ("For valid options type", "tiffcrop -h");
1949                              exit (-1);
1950                   }
1951                 break;
1952       case 'S': /* subdivide into Cols:Rows sections, eg 3:2 would be 3 across and 2 down */
1953                 sep = strpbrk(optarg, ",:");
1954                 if (sep)
1955                   {
1956                   *sep = '\0';
1957                   page->cols = atoi(optarg);
1958                   page->rows = atoi(sep +1);
1959                   }
1960                 else
1961                   {
1962                   page->cols = atoi(optarg);
1963                   page->rows = atoi(optarg);
1964                   }
1965                 if ((page->cols * page->rows) > MAX_SECTIONS)
1966                   {
1967                   TIFFError ("Limit for subdivisions, ie rows x columns, exceeded", "%d", MAX_SECTIONS);
1968                   exit (-1);
1969                   }
1970                 page->mode |= PAGE_MODE_ROWSCOLS;
1971                 break;
1972       case 'U': /* units for measurements and offsets */
1973                 if (streq(optarg, "in"))
1974                   {
1975                   crop_data->res_unit = RESUNIT_INCH;
1976                   page->res_unit = RESUNIT_INCH;
1977                   }
1978                 else if (streq(optarg, "cm"))
1979                   {
1980                   crop_data->res_unit = RESUNIT_CENTIMETER;
1981                   page->res_unit = RESUNIT_CENTIMETER;
1982                   }
1983                 else if (streq(optarg, "px"))
1984                   {
1985                   crop_data->res_unit = RESUNIT_NONE;
1986                   page->res_unit = RESUNIT_NONE;
1987                   }
1988                 else
1989                   {
1990                   TIFFError ("Illegal unit of measure","%s", optarg);
1991                   TIFFError ("For valid options type", "tiffcrop -h");
1992                   exit (-1);
1993                   }
1994                 break;
1995       case 'V': /* set vertical resolution to new value */
1996                 page->vres = atof (optarg);
1997                 page->mode |= PAGE_MODE_RESOLUTION;
1998                 break;
1999       case 'X': /* selection width */
2000                 crop_data->crop_mode |= CROP_WIDTH;
2001                 crop_data->width = atof(optarg);
2002                 break;
2003       case 'Y': /* selection length */
2004                 crop_data->crop_mode |= CROP_LENGTH;
2005                 crop_data->length = atof(optarg);
2006                 break;
2007       case 'Z': /* zones of an image X:Y read as zone X of Y */
2008                 crop_data->crop_mode |= CROP_ZONES;
2009                 for (i = 0, opt_ptr = strtok (optarg, ",");
2010                    ((opt_ptr != NULL) &&  (i < MAX_REGIONS));
2011                     (opt_ptr = strtok (NULL, ",")), i++)
2012                     {
2013                     crop_data->zones++;
2014                     opt_offset = strchr(opt_ptr, ':');
2015                     *opt_offset = '\0';
2016                     crop_data->zonelist[i].position = atoi(opt_ptr);
2017                     crop_data->zonelist[i].total    = atoi(opt_offset + 1);
2018                     }
2019                 /*  check for remaining elements over MAX_REGIONS */
2020                 if ((opt_ptr != NULL) && (i >= MAX_REGIONS))
2021                   {
2022                   TIFFError("Zone list exceeds region limit", "%d",  MAX_REGIONS);
2023                   exit (-1);
2024                   }
2025                 break;
2026     case '?':   TIFFError ("For valid options type", "tiffcrop -h");
2027                 exit (-1);
2028                 /*NOTREACHED*/
2029       }
2030     }
2031   }  /* end process_command_opts */
2032
2033 /* Start a new output file if one has not been previously opened or
2034  * autoindex is set to non-zero. Update page and file counters
2035  * so TIFFTAG PAGENUM will be correct in image.
2036  */
2037 static int
2038 update_output_file (TIFF **tiffout, char *mode, int autoindex,
2039                     char *outname, unsigned int *page)
2040   {
2041   static int findex = 0;    /* file sequence indicator */
2042   char  *sep;
2043   char   filenum[16];
2044   char   export_ext[16];
2045   char   exportname[PATH_MAX];
2046
2047   if (autoindex && (*tiffout != NULL))
2048     {
2049     /* Close any export file that was previously opened */
2050     TIFFClose (*tiffout);
2051     *tiffout = NULL;
2052     }
2053
2054   strcpy (export_ext, ".tiff");
2055   memset (exportname, '\0', PATH_MAX);
2056
2057   /* Leave room for page number portion of the new filename */
2058   strncpy (exportname, outname, PATH_MAX - 16);
2059   if (*tiffout == NULL)   /* This is a new export file */
2060     {
2061     if (autoindex)
2062       { /* create a new filename for each export */
2063       findex++;
2064       if ((sep = strstr(exportname, ".tif")) || (sep = strstr(exportname, ".TIF")))
2065         {
2066         strncpy (export_ext, sep, 5);
2067         *sep = '\0';
2068         }
2069       else
2070         strncpy (export_ext, ".tiff", 5);
2071       export_ext[5] = '\0';
2072
2073       /* MAX_EXPORT_PAGES limited to 6 digits to prevent string overflow of pathname */
2074       if (findex > MAX_EXPORT_PAGES)
2075         {
2076         TIFFError("update_output_file", "Maximum of %d pages per file exceeded", MAX_EXPORT_PAGES);
2077         return 1;
2078         }
2079
2080       sprintf (filenum, "-%03d%s", findex, export_ext);
2081       filenum[14] = '\0';
2082       strncat (exportname, filenum, 15);
2083       }
2084     exportname[PATH_MAX - 1] = '\0';
2085
2086     *tiffout = TIFFOpen(exportname, mode);
2087     if (*tiffout == NULL)
2088       {
2089       TIFFError("update_output_file", "Unable to open output file %s", exportname);
2090       return 1;
2091       }
2092     *page = 0;
2093
2094     return 0;
2095     }
2096   else
2097     (*page)++;
2098
2099   return 0;
2100   } /* end update_output_file */
2101
2102
2103 int
2104 main(int argc, char* argv[])
2105   {
2106   extern int optind;
2107   uint16 defconfig = (uint16) -1;
2108   uint16 deffillorder = 0;
2109   uint32 deftilewidth = (uint32) 0;
2110   uint32 deftilelength = (uint32) 0;
2111   uint32 defrowsperstrip = (uint32) 0;
2112   uint32 dirnum = 0;
2113
2114   TIFF *in = NULL;
2115   TIFF *out = NULL;
2116   char  mode[10];
2117   char *mp = mode;
2118
2119   /** RJN additions **/
2120   struct image_data image;     /* Image parameters for one image */
2121   struct crop_mask  crop;      /* Cropping parameters for all images */
2122   struct pagedef    page;      /* Page definition for output pages */
2123   struct pageseg    sections[MAX_SECTIONS];  /* Sections of one output page */
2124   struct buffinfo   seg_buffs[MAX_SECTIONS]; /* Segment buffer sizes and pointers */
2125   struct dump_opts  dump;                  /* Data dump options */
2126   unsigned char *read_buff    = NULL;      /* Input image data buffer */
2127   unsigned char *crop_buff    = NULL;      /* Crop area buffer */
2128   unsigned char *sect_buff    = NULL;      /* Image section buffer */
2129   unsigned char *sect_src     = NULL;      /* Image section buffer pointer */
2130   unsigned int  imagelist[MAX_IMAGES + 1]; /* individually specified images */
2131   unsigned int  image_count  = 0;
2132   unsigned int  dump_images  = 0;
2133   unsigned int  next_image   = 0;
2134   unsigned int  next_page    = 0;
2135   unsigned int  total_pages  = 0;
2136   unsigned int  total_images = 0;
2137   unsigned int  end_of_input = FALSE;
2138   int    seg, length;
2139   char   temp_filename[PATH_MAX + 1];
2140
2141   little_endian = *((unsigned char *)&little_endian) & '1';
2142
2143   initImageData(&image);
2144   initCropMasks(&crop);
2145   initPageSetup(&page, sections, seg_buffs);
2146   initDumpOptions(&dump);
2147
2148   process_command_opts (argc, argv, mp, mode, &dirnum, &defconfig,
2149                         &deffillorder, &deftilewidth, &deftilelength, &defrowsperstrip,
2150                         &crop, &page, &dump, imagelist, &image_count);
2151
2152   if (argc - optind < 2)
2153     usage();
2154
2155   if ((argc - optind) == 2)
2156     pageNum = -1;
2157   else
2158     total_images = 0;
2159   /* read multiple input files and write to output file(s) */
2160   while (optind < argc - 1)
2161     {
2162     in = TIFFOpen (argv[optind], "r");
2163     if (in == NULL)
2164       return (-3);
2165
2166     /* If only one input file is specified, we can use directory count */
2167     total_images = TIFFNumberOfDirectories(in);
2168     if (image_count == 0)
2169       {
2170       dirnum = 0;
2171       total_pages = total_images; /* Only valid with single input file */
2172       }
2173     else
2174       {
2175       dirnum = (tdir_t)(imagelist[next_image] - 1);
2176       next_image++;
2177
2178       /* Total pages only valid for enumerated list of pages not derived
2179        * using odd, even, or last keywords.
2180        */
2181       if (image_count >  total_images)
2182         image_count = total_images;
2183
2184       total_pages = image_count;
2185       }
2186
2187     /* MAX_IMAGES is used for special case "last" in selection list */
2188     if (dirnum == (MAX_IMAGES - 1))
2189       dirnum = total_images - 1;
2190
2191     if (dirnum > (total_images))
2192       {
2193       TIFFError (TIFFFileName(in),
2194       "Invalid image number %d, File contains only %d images",
2195                  (int)dirnum + 1, total_images);
2196       if (out != NULL)
2197         (void) TIFFClose(out);
2198       return (1);
2199       }
2200
2201     if (dirnum != 0 && !TIFFSetDirectory(in, (tdir_t)dirnum))
2202       {
2203       TIFFError(TIFFFileName(in),"Error, setting subdirectory at %d", dirnum);
2204       if (out != NULL)
2205         (void) TIFFClose(out);
2206       return (1);
2207       }
2208
2209     end_of_input = FALSE;
2210     while (end_of_input == FALSE)
2211       {
2212       config = defconfig;
2213       compression = defcompression;
2214       predictor = defpredictor;
2215       fillorder = deffillorder;
2216       rowsperstrip = defrowsperstrip;
2217       tilewidth = deftilewidth;
2218       tilelength = deftilelength;
2219       g3opts = defg3opts;
2220
2221       if (dump.format != DUMP_NONE)
2222         {
2223         /* manage input and/or output dump files here */
2224         dump_images++;
2225         length = strlen(dump.infilename);
2226         if (length > 0)
2227           {
2228           if (dump.infile != NULL)
2229             fclose (dump.infile);
2230
2231           /* dump.infilename is guaranteed to be NUL termimated and have 20 bytes
2232              fewer than PATH_MAX */
2233           memset (temp_filename, '\0', PATH_MAX + 1);
2234           sprintf (temp_filename, "%s-read-%03d.%s", dump.infilename, dump_images,
2235                   (dump.format == DUMP_TEXT) ? "txt" : "raw");
2236           if ((dump.infile = fopen(temp_filename, dump.mode)) == NULL)
2237             {
2238             TIFFError ("Unable to open dump file for writing", "%s", temp_filename);
2239             exit (-1);
2240             }
2241           dump_info(dump.infile, dump.format, "Reading image","%d from %s",
2242                     dump_images, TIFFFileName(in));
2243           }
2244         length = strlen(dump.outfilename);
2245         if (length > 0)
2246           {
2247           if (dump.outfile != NULL)
2248             fclose (dump.outfile);
2249
2250           /* dump.outfilename is guaranteed to be NUL termimated and have 20 bytes
2251              fewer than PATH_MAX */
2252           memset (temp_filename, '\0', PATH_MAX + 1);
2253           sprintf (temp_filename, "%s-write-%03d.%s", dump.outfilename, dump_images,
2254                   (dump.format == DUMP_TEXT) ? "txt" : "raw");
2255           if ((dump.outfile = fopen(temp_filename, dump.mode)) == NULL)
2256             {
2257               TIFFError ("Unable to open dump file for writing", "%s", temp_filename);
2258             exit (-1);
2259             }
2260           dump_info(dump.outfile, dump.format, "Writing image","%d from %s",
2261                     dump_images, TIFFFileName(in));
2262           }
2263         }
2264
2265       if (dump.debug)
2266          TIFFError("main", "Reading image %4d of %4d total pages.", dirnum + 1, total_pages);
2267
2268       if (loadImage(in, &image, &dump, &read_buff))
2269         {
2270         TIFFError("main", "Unable to load source image");
2271         exit (-1);
2272         }
2273
2274       /* Correct the image orientation if it was not ORIENTATION_TOPLEFT.
2275        */
2276       if (image.adjustments != 0)
2277         {
2278         if (correct_orientation(&image, &read_buff))
2279             TIFFError("main", "Unable to correct image orientation");
2280         }
2281
2282       if (getCropOffsets(&image, &crop, &dump))
2283         {
2284         TIFFError("main", "Unable to define crop regions");
2285         exit (-1);
2286         }
2287
2288       if (crop.selections > 0)
2289         {
2290         if (processCropSelections(&image, &crop, &read_buff, seg_buffs))
2291           {
2292           TIFFError("main", "Unable to process image selections");
2293           exit (-1);
2294           }
2295         }
2296       else  /* Single image segment without zones or regions */
2297         {
2298         if (createCroppedImage(&image, &crop, &read_buff, &crop_buff))
2299           {
2300           TIFFError("main", "Unable to create output image");
2301           exit (-1);
2302           }
2303         }
2304       if (page.mode == PAGE_MODE_NONE)
2305         {  /* Whole image or sections not based on output page size */
2306         if (crop.selections > 0)
2307           {
2308           writeSelections(in, &out, &crop, &image, &dump, seg_buffs,
2309                           mp, argv[argc - 1], &next_page, total_pages);
2310           }
2311         else  /* One file all images and sections */
2312           {
2313           if (update_output_file (&out, mp, crop.exp_mode, argv[argc - 1],
2314                                   &next_page))
2315              exit (1);
2316           if (writeCroppedImage(in, out, &image, &dump,crop.combined_width,
2317                                 crop.combined_length, crop_buff, next_page, total_pages))
2318             {
2319              TIFFError("main", "Unable to write new image");
2320              exit (-1);
2321             }
2322           }
2323         }
2324       else
2325         {
2326         /* If we used a crop buffer, our data is there, otherwise it is
2327          * in the read_buffer
2328          */
2329         if (crop_buff != NULL)
2330           sect_src = crop_buff;
2331         else
2332           sect_src = read_buff;
2333         /* Break input image into pages or rows and columns */
2334         if (computeOutputPixelOffsets(&crop, &image, &page, sections, &dump))
2335           {
2336           TIFFError("main", "Unable to compute output section data");
2337           exit (-1);
2338           }
2339         /* If there are multiple files on the command line, the final one is assumed
2340          * to be the output filename into which the images are written.
2341          */
2342         if (update_output_file (&out, mp, crop.exp_mode, argv[argc - 1], &next_page))
2343           exit (1);
2344
2345         if (writeImageSections(in, out, &image, &page, sections, &dump, sect_src, &sect_buff))
2346           {
2347           TIFFError("main", "Unable to write image sections");
2348           exit (-1);
2349           }
2350         }
2351
2352       /* No image list specified, just read the next image */
2353       if (image_count == 0)
2354         dirnum++;
2355       else
2356         {
2357         dirnum = (tdir_t)(imagelist[next_image] - 1);
2358         next_image++;
2359         }
2360
2361       if (dirnum == MAX_IMAGES - 1)
2362         dirnum = TIFFNumberOfDirectories(in) - 1;
2363
2364       if (!TIFFSetDirectory(in, (tdir_t)dirnum))
2365         end_of_input = TRUE;
2366       }
2367     TIFFClose(in);
2368     optind++;
2369     }
2370
2371   /* If we did not use the read buffer as the crop buffer */
2372   if (read_buff)
2373     _TIFFfree(read_buff);
2374
2375   if (crop_buff)
2376     _TIFFfree(crop_buff);
2377
2378   if (sect_buff)
2379     _TIFFfree(sect_buff);
2380
2381    /* Clean up any segment buffers used for zones or regions */
2382   for (seg = 0; seg < crop.selections; seg++)
2383     _TIFFfree (seg_buffs[seg].buffer);
2384
2385   if (dump.format != DUMP_NONE)
2386     {
2387     if (dump.infile != NULL)
2388      fclose (dump.infile);
2389
2390     if (dump.outfile != NULL)
2391       {
2392       dump_info (dump.outfile, dump.format, "", "Completed run for %s", TIFFFileName(out));
2393       fclose (dump.outfile);
2394       }
2395     }
2396
2397   TIFFClose(out);
2398
2399   return (0);
2400   } /* end main */
2401
2402
2403 /* Debugging functions */
2404 static int dump_data (FILE *dumpfile, int format, char *dump_tag, unsigned char *data, uint32 count)
2405   {
2406   int j, k;
2407   uint32 i;
2408   char  dump_array[10];
2409   unsigned char bitset;
2410
2411   if (dumpfile == NULL)
2412     {
2413     TIFFError ("", "Invalid FILE pointer for dump file");
2414     return (1);
2415     }
2416
2417   if (format == DUMP_TEXT)
2418     {
2419     fprintf (dumpfile," %s  ", dump_tag);
2420     for (i = 0; i < count; i++)
2421       {
2422       for (j = 0, k = 7; j < 8; j++, k--)
2423         {
2424         bitset = (*(data + i)) & (((unsigned char)1 << k)) ? 1 : 0;
2425         sprintf(&dump_array[j], (bitset) ? "1" : "0");
2426         }
2427       dump_array[8] = '\0';
2428       fprintf (dumpfile," %s", dump_array);
2429       }
2430     fprintf (dumpfile,"\n");
2431     }
2432   else
2433     {
2434     if ((fwrite (data, 1, count, dumpfile)) != count)
2435       {
2436       TIFFError ("", "Unable to write binary data to dump file");
2437       return (1);
2438       }
2439     }
2440
2441   return (0);
2442   }
2443
2444 static int dump_byte (FILE *dumpfile, int format, char *dump_tag, unsigned char data)
2445   {
2446   int j, k;
2447   char  dump_array[10];
2448   unsigned char bitset;
2449
2450   if (dumpfile == NULL)
2451     {
2452     TIFFError ("", "Invalid FILE pointer for dump file");
2453     return (1);
2454     }
2455
2456   if (format == DUMP_TEXT)
2457     {
2458     fprintf (dumpfile," %s  ", dump_tag);
2459     for (j = 0, k = 7; j < 8; j++, k--)
2460       {
2461       bitset = data & (((unsigned char)1 << k)) ? 1 : 0;
2462       sprintf(&dump_array[j], (bitset) ? "1" : "0");
2463       }
2464     dump_array[8] = '\0';
2465     fprintf (dumpfile," %s\n", dump_array);
2466     }
2467   else
2468     {
2469     if ((fwrite (&data, 1, 1, dumpfile)) != 1)
2470       {
2471       TIFFError ("", "Unable to write binary data to dump file");
2472       return (1);
2473       }
2474     }
2475
2476   return (0);
2477   }
2478
2479 static int dump_short (FILE *dumpfile, int format, char *dump_tag, uint16 data)
2480   {
2481   int j, k;
2482   char  dump_array[20];
2483   unsigned char bitset;
2484
2485   if (dumpfile == NULL)
2486     {
2487     TIFFError ("", "Invalid FILE pointer for dump file");
2488     return (1);
2489     }
2490
2491   if (format == DUMP_TEXT)
2492     {
2493     fprintf (dumpfile," %s  ", dump_tag);
2494     for (j = 0, k = 15; k >= 0; j++, k--)
2495       {
2496       bitset = data & (((unsigned char)1 << k)) ? 1 : 0;
2497       sprintf(&dump_array[j], (bitset) ? "1" : "0");
2498       if ((k % 8) == 0)
2499           sprintf(&dump_array[++j], " ");
2500       }
2501     dump_array[17] = '\0';
2502     fprintf (dumpfile," %s\n", dump_array);
2503     }
2504   else
2505     {
2506     if ((fwrite (&data, 2, 1, dumpfile)) != 2)
2507       {
2508       TIFFError ("", "Unable to write binary data to dump file");
2509       return (1);
2510       }
2511     }
2512
2513   return (0);
2514   }
2515
2516 static int dump_long (FILE *dumpfile, int format, char *dump_tag, uint32 data)
2517   {
2518   int j, k;
2519   char  dump_array[40];
2520   unsigned char bitset;
2521
2522   if (dumpfile == NULL)
2523     {
2524     TIFFError ("", "Invalid FILE pointer for dump file");
2525     return (1);
2526     }
2527
2528   if (format == DUMP_TEXT)
2529     {
2530     fprintf (dumpfile," %s  ", dump_tag);
2531     for (j = 0, k = 31; k >= 0; j++, k--)
2532       {
2533       bitset = data & (((uint32)1 << k)) ? 1 : 0;
2534       sprintf(&dump_array[j], (bitset) ? "1" : "0");
2535       if ((k % 8) == 0)
2536           sprintf(&dump_array[++j], " ");
2537       }
2538     dump_array[35] = '\0';
2539     fprintf (dumpfile," %s\n", dump_array);
2540     }
2541   else
2542     {
2543     if ((fwrite (&data, 4, 1, dumpfile)) != 4)
2544       {
2545       TIFFError ("", "Unable to write binary data to dump file");
2546       return (1);
2547       }
2548     }
2549   return (0);
2550   }
2551
2552 static int dump_wide (FILE *dumpfile, int format, char *dump_tag, uint64 data)
2553   {
2554   int j, k;
2555   char  dump_array[80];
2556   unsigned char bitset;
2557
2558   if (dumpfile == NULL)
2559     {
2560     TIFFError ("", "Invalid FILE pointer for dump file");
2561     return (1);
2562     }
2563
2564   if (format == DUMP_TEXT)
2565     {
2566     fprintf (dumpfile," %s  ", dump_tag);
2567     for (j = 0, k = 63; k >= 0; j++, k--)
2568       {
2569       bitset = data & (((uint64)1 << k)) ? 1 : 0;
2570       sprintf(&dump_array[j], (bitset) ? "1" : "0");
2571       if ((k % 8) == 0)
2572           sprintf(&dump_array[++j], " ");
2573       }
2574     dump_array[71] = '\0';
2575     fprintf (dumpfile," %s\n", dump_array);
2576     }
2577   else
2578     {
2579     if ((fwrite (&data, 8, 1, dumpfile)) != 8)
2580       {
2581       TIFFError ("", "Unable to write binary data to dump file");
2582       return (1);
2583       }
2584     }
2585
2586   return (0);
2587   }
2588
2589 static void dump_info(FILE *dumpfile, int format, char *prefix, char *msg, ...)
2590   {
2591   if (format == DUMP_TEXT)
2592     {
2593     va_list ap;
2594     va_start(ap, msg);
2595     fprintf(dumpfile, "%s ", prefix);
2596     vfprintf(dumpfile, msg, ap);
2597     fprintf(dumpfile, "\n");
2598     }
2599   }
2600
2601 static int dump_buffer (FILE* dumpfile, int format, uint32 rows, uint32 width,
2602                  uint32 row, unsigned char *buff)
2603   {
2604   int j, k;
2605   uint32 i;
2606   unsigned char * dump_ptr;
2607
2608   if (dumpfile == NULL)
2609     {
2610     TIFFError ("", "Invalid FILE pointer for dump file");
2611     return (1);
2612     }
2613
2614   for (i = 0; i < rows; i++)
2615     {
2616     dump_ptr = buff + (i * width);
2617     if (format == DUMP_TEXT)
2618       dump_info (dumpfile, format, "",
2619                  "Row %4d, %d bytes at offset %d",
2620                  row + i + 1, width, row * width);
2621
2622     for (j = 0, k = width; k >= 10; j += 10, k -= 10, dump_ptr += 10)
2623       dump_data (dumpfile, format, "", dump_ptr, 10);
2624     if (k > 0)
2625       dump_data (dumpfile, format, "", dump_ptr, k);
2626     }
2627   return (0);
2628   }
2629
2630 /* Extract one or more samples from an interleaved buffer. If count == 1,
2631  * only the sample plane indicated by sample will be extracted.  If count > 1,
2632  * count samples beginning at sample will be extracted. Portions of a
2633  * scanline can be extracted by specifying a start and end value.
2634  */
2635
2636 static int
2637 extractContigSamplesBytes (uint8 *in, uint8 *out, uint32 cols,
2638                            tsample_t sample, uint16 spp, uint16 bps,
2639                            tsample_t count, uint32 start, uint32 end)
2640   {
2641   int i, bytes_per_sample, sindex;
2642   uint32 col, dst_rowsize, bit_offset;
2643   uint32 src_byte, src_bit;
2644   uint8 *src = in;
2645   uint8 *dst = out;
2646
2647   if ((src == NULL) || (dst == NULL))
2648     {
2649     TIFFError("extractContigSamplesBytes","Invalid input or output buffer");
2650     return (1);
2651     }
2652
2653   if ((start > end) || (start > cols))
2654     {
2655     TIFFError ("extractContigSamplesBytes",
2656                "Invalid start column value %d ignored", start);
2657     start = 0;
2658     }
2659   if ((end == 0) || (end > cols))
2660     {
2661     TIFFError ("extractContigSamplesBytes",
2662                "Invalid end column value %d ignored", end);
2663     end = cols;
2664     }
2665
2666   dst_rowsize = (bps * (end - start) * count) / 8;
2667
2668   bytes_per_sample = (bps + 7) / 8;
2669   /* Optimize case for copying all samples */
2670   if (count == spp)
2671     {
2672     src = in + (start * spp * bytes_per_sample);
2673     _TIFFmemcpy (dst, src, dst_rowsize);
2674     }
2675   else
2676     {
2677     for (col = start; col < end; col++)
2678       {
2679       for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
2680         {
2681         bit_offset = col * bps * spp;
2682         if (sindex == 0)
2683           {
2684           src_byte = bit_offset / 8;
2685           src_bit  = bit_offset % 8;
2686           }
2687         else
2688           {
2689           src_byte = (bit_offset + (sindex * bps)) / 8;
2690           src_bit  = (bit_offset + (sindex * bps)) % 8;
2691           }
2692         src = in + src_byte;
2693         for (i = 0; i < bytes_per_sample; i++)
2694             *dst++ = *src++;
2695         }
2696       }
2697     }
2698
2699   return (0);
2700   } /* end extractContigSamplesBytes */
2701
2702 static int
2703 extractContigSamples8bits (uint8 *in, uint8 *out, uint32 cols,
2704                            tsample_t sample, uint16 spp, uint16 bps,
2705                            tsample_t count, uint32 start, uint32 end)
2706   {
2707   int    ready_bits = 0, sindex = 0;
2708   uint32 col, src_byte, src_bit, bit_offset;
2709   uint8  maskbits = 0, matchbits = 0;
2710   uint8  buff1 = 0, buff2 = 0;
2711   uint8 *src = in;
2712   uint8 *dst = out;
2713
2714   if ((src == NULL) || (dst == NULL))
2715     {
2716     TIFFError("extractContigSamples8bits","Invalid input or output buffer");
2717     return (1);
2718     }
2719
2720   if ((start > end) || (start > cols))
2721     {
2722     TIFFError ("extractContigSamples8bits",
2723                "Invalid start column value %d ignored", start);
2724     start = 0;
2725     }
2726   if ((end == 0) || (end > cols))
2727     {
2728     TIFFError ("extractContigSamples8bits",
2729                "Invalid end column value %d ignored", end);
2730     end = cols;
2731     }
2732
2733   ready_bits = 0;
2734   maskbits =  (uint8)-1 >> ( 8 - bps);
2735   buff1 = buff2 = 0;
2736   for (col = start; col < end; col++)
2737     {    /* Compute src byte(s) and bits within byte(s) */
2738     bit_offset = col * bps * spp;
2739     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
2740       {
2741       if (sindex == 0)
2742         {
2743         src_byte = bit_offset / 8;
2744         src_bit  = bit_offset % 8;
2745         }
2746       else
2747         {
2748         src_byte = (bit_offset + (sindex * bps)) / 8;
2749         src_bit  = (bit_offset + (sindex * bps)) % 8;
2750         }
2751
2752       src = in + src_byte;
2753       matchbits = maskbits << (8 - src_bit - bps);
2754       buff1 = ((*src) & matchbits) << (src_bit);
2755
2756       /* If we have a full buffer's worth, write it out */
2757       if (ready_bits >= 8)
2758         {
2759         *dst++ = buff2;
2760         buff2 = buff1;
2761         ready_bits -= 8;
2762         }
2763       else
2764         buff2 = (buff2 | (buff1 >> ready_bits));
2765       ready_bits += bps;
2766       }
2767     }
2768
2769   while (ready_bits > 0)
2770     {
2771     buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits)));
2772     *dst++ = buff1;
2773     ready_bits -= 8;
2774     }
2775
2776   return (0);
2777   } /* end extractContigSamples8bits */
2778
2779 static int
2780 extractContigSamples16bits (uint8 *in, uint8 *out, uint32 cols,
2781                             tsample_t sample, uint16 spp, uint16 bps,
2782                             tsample_t count, uint32 start, uint32 end)
2783   {
2784   int    ready_bits = 0, sindex = 0;
2785   uint32 col, src_byte, src_bit, bit_offset;
2786   uint16 maskbits = 0, matchbits = 0;
2787   uint16 buff1 = 0, buff2 = 0;
2788   uint8  bytebuff = 0;
2789   uint8 *src = in;
2790   uint8 *dst = out;
2791
2792   if ((src == NULL) || (dst == NULL))
2793     {
2794     TIFFError("extractContigSamples16bits","Invalid input or output buffer");
2795     return (1);
2796     }
2797
2798   if ((start > end) || (start > cols))
2799     {
2800     TIFFError ("extractContigSamples16bits",
2801                "Invalid start column value %d ignored", start);
2802     start = 0;
2803     }
2804   if ((end == 0) || (end > cols))
2805     {
2806     TIFFError ("extractContigSamples16bits",
2807                "Invalid end column value %d ignored", end);
2808     end = cols;
2809     }
2810
2811   ready_bits = 0;
2812   maskbits = (uint16)-1 >> (16 - bps);
2813
2814   for (col = start; col < end; col++)
2815     {    /* Compute src byte(s) and bits within byte(s) */
2816     bit_offset = col * bps * spp;
2817     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
2818       {
2819       if (sindex == 0)
2820         {
2821         src_byte = bit_offset / 8;
2822         src_bit  = bit_offset % 8;
2823         }
2824       else
2825         {
2826         src_byte = (bit_offset + (sindex * bps)) / 8;
2827         src_bit  = (bit_offset + (sindex * bps)) % 8;
2828         }
2829
2830       src = in + src_byte;
2831       matchbits = maskbits << (16 - src_bit - bps);
2832
2833       if (little_endian)
2834         buff1 = (src[0] << 8) | src[1];
2835       else
2836         buff1 = (src[1] << 8) | src[0];
2837
2838       buff1 = (buff1 & matchbits) << (src_bit);
2839       if (ready_bits < 8) /* add another bps bits to the buffer */
2840         {
2841         bytebuff = 0;
2842         buff2 = (buff2 | (buff1 >> ready_bits));
2843         }
2844       else /* If we have a full buffer's worth, write it out */
2845         {
2846         bytebuff = (buff2 >> 8);
2847         *dst++ = bytebuff;
2848         ready_bits -= 8;
2849         /* shift in new bits */
2850         buff2 = ((buff2 << 8) | (buff1 >> ready_bits));
2851         }
2852       ready_bits += bps;
2853       }
2854     }
2855
2856   /* catch any trailing bits at the end of the line */
2857   while (ready_bits > 0)
2858     {
2859     bytebuff = (buff2 >> 8);
2860     *dst++ = bytebuff;
2861     ready_bits -= 8;
2862     }
2863
2864   return (0);
2865   } /* end extractContigSamples16bits */
2866
2867
2868 static int
2869 extractContigSamples24bits (uint8 *in, uint8 *out, uint32 cols,
2870                             tsample_t sample, uint16 spp, uint16 bps,
2871                             tsample_t count, uint32 start, uint32 end)
2872   {
2873   int    ready_bits = 0, sindex = 0;
2874   uint32 col, src_byte, src_bit, bit_offset;
2875   uint32 maskbits = 0, matchbits = 0;
2876   uint32 buff1 = 0, buff2 = 0;
2877   uint8  bytebuff1 = 0, bytebuff2 = 0;
2878   uint8 *src = in;
2879   uint8 *dst = out;
2880
2881   if ((in == NULL) || (out == NULL))
2882     {
2883     TIFFError("extractContigSamples24bits","Invalid input or output buffer");
2884     return (1);
2885     }
2886
2887   if ((start > end) || (start > cols))
2888     {
2889     TIFFError ("extractContigSamples24bits",
2890                "Invalid start column value %d ignored", start);
2891     start = 0;
2892     }
2893   if ((end == 0) || (end > cols))
2894     {
2895     TIFFError ("extractContigSamples24bits",
2896                "Invalid end column value %d ignored", end);
2897     end = cols;
2898     }
2899
2900   ready_bits = 0;
2901   maskbits =  (uint32)-1 >> ( 32 - bps);
2902   for (col = start; col < end; col++)
2903     {
2904     /* Compute src byte(s) and bits within byte(s) */
2905     bit_offset = col * bps * spp;
2906     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
2907       {
2908       if (sindex == 0)
2909         {
2910         src_byte = bit_offset / 8;
2911         src_bit  = bit_offset % 8;
2912         }
2913       else
2914         {
2915         src_byte = (bit_offset + (sindex * bps)) / 8;
2916         src_bit  = (bit_offset + (sindex * bps)) % 8;
2917         }
2918
2919       src = in + src_byte;
2920       matchbits = maskbits << (32 - src_bit - bps);
2921       if (little_endian)
2922         buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
2923       else
2924         buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
2925       buff1 = (buff1 & matchbits) << (src_bit);
2926
2927       if (ready_bits < 16) /* add another bps bits to the buffer */
2928         {
2929         bytebuff1 = bytebuff2 = 0;
2930         buff2 = (buff2 | (buff1 >> ready_bits));
2931         }
2932       else /* If we have a full buffer's worth, write it out */
2933         {
2934         bytebuff1 = (buff2 >> 24);
2935         *dst++ = bytebuff1;
2936         bytebuff2 = (buff2 >> 16);
2937         *dst++ = bytebuff2;
2938         ready_bits -= 16;
2939
2940         /* shift in new bits */
2941         buff2 = ((buff2 << 16) | (buff1 >> ready_bits));
2942         }
2943       ready_bits += bps;
2944       }
2945     }
2946
2947   /* catch any trailing bits at the end of the line */
2948   while (ready_bits > 0)
2949     {
2950     bytebuff1 = (buff2 >> 24);
2951     *dst++ = bytebuff1;
2952
2953     buff2 = (buff2 << 8);
2954     bytebuff2 = bytebuff1;
2955     ready_bits -= 8;
2956     }
2957
2958   return (0);
2959   } /* end extractContigSamples24bits */
2960
2961 static int
2962 extractContigSamples32bits (uint8 *in, uint8 *out, uint32 cols,
2963                             tsample_t sample, uint16 spp, uint16 bps,
2964                             tsample_t count, uint32 start, uint32 end)
2965   {
2966   int    ready_bits = 0, sindex = 0, shift_width = 0;
2967   uint32 col, src_byte, src_bit, bit_offset;
2968   uint32 longbuff1 = 0, longbuff2 = 0;
2969   uint64 maskbits = 0, matchbits = 0;
2970   uint64 buff1 = 0, buff2 = 0, buff3 = 0;
2971   uint8  bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0;
2972   uint8 *src = in;
2973   uint8 *dst = out;
2974
2975   if ((in == NULL) || (out == NULL))
2976     {
2977     TIFFError("extractContigSamples32bits","Invalid input or output buffer");
2978     return (1);
2979     }
2980
2981
2982   if ((start > end) || (start > cols))
2983     {
2984     TIFFError ("extractContigSamples32bits",
2985                "Invalid start column value %d ignored", start);
2986     start = 0;
2987     }
2988   if ((end == 0) || (end > cols))
2989     {
2990     TIFFError ("extractContigSamples32bits",
2991                "Invalid end column value %d ignored", end);
2992     end = cols;
2993     }
2994
2995   shift_width = ((bps + 7) / 8) + 1;
2996   ready_bits = 0;
2997   maskbits =  (uint64)-1 >> ( 64 - bps);
2998   for (col = start; col < end; col++)
2999     {
3000     /* Compute src byte(s) and bits within byte(s) */
3001     bit_offset = col * bps * spp;
3002     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
3003       {
3004       if (sindex == 0)
3005         {
3006         src_byte = bit_offset / 8;
3007         src_bit  = bit_offset % 8;
3008         }
3009       else
3010         {
3011         src_byte = (bit_offset + (sindex * bps)) / 8;
3012         src_bit  = (bit_offset + (sindex * bps)) % 8;
3013         }
3014
3015       src = in + src_byte;
3016       matchbits = maskbits << (64 - src_bit - bps);
3017       if (little_endian)
3018         {
3019         longbuff1 = (src[0] << 24) | (src[1] << 16)  | (src[2] << 8) | src[3];
3020         longbuff2 = longbuff1;
3021         }
3022       else
3023         {
3024         longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
3025         longbuff2 = longbuff1;
3026         }
3027
3028       buff3 = ((uint64)longbuff1 << 32) | longbuff2;
3029       buff1 = (buff3 & matchbits) << (src_bit);
3030
3031       /* If we have a full buffer's worth, write it out */
3032       if (ready_bits >= 32)
3033         {
3034         bytebuff1 = (buff2 >> 56);
3035         *dst++ = bytebuff1;
3036         bytebuff2 = (buff2 >> 48);
3037         *dst++ = bytebuff2;
3038         bytebuff3 = (buff2 >> 40);
3039         *dst++ = bytebuff3;
3040         bytebuff4 = (buff2 >> 32);
3041         *dst++ = bytebuff4;
3042         ready_bits -= 32;
3043
3044         /* shift in new bits */
3045         buff2 = ((buff2 << 32) | (buff1 >> ready_bits));
3046         }
3047       else
3048         { /* add another bps bits to the buffer */
3049         bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0;
3050         buff2 = (buff2 | (buff1 >> ready_bits));
3051         }
3052       ready_bits += bps;
3053       }
3054     }
3055   while (ready_bits > 0)
3056     {
3057     bytebuff1 = (buff2 >> 56);
3058     *dst++ = bytebuff1;
3059     buff2 = (buff2 << 8);
3060     ready_bits -= 8;
3061     }
3062
3063   return (0);
3064   } /* end extractContigSamples32bits */
3065
3066 static int
3067 extractContigSamplesShifted8bits (uint8 *in, uint8 *out, uint32 cols,
3068                                   tsample_t sample, uint16 spp, uint16 bps,
3069                                   tsample_t count, uint32 start, uint32 end,
3070                                   int shift)
3071   {
3072   int    ready_bits = 0, sindex = 0;
3073   uint32 col, src_byte, src_bit, bit_offset;
3074   uint8  maskbits = 0, matchbits = 0;
3075   uint8  buff1 = 0, buff2 = 0;
3076   uint8 *src = in;
3077   uint8 *dst = out;
3078
3079   if ((src == NULL) || (dst == NULL))
3080     {
3081     TIFFError("extractContigSamplesShifted8bits","Invalid input or output buffer");
3082     return (1);
3083     }
3084
3085   if ((start > end) || (start > cols))
3086     {
3087     TIFFError ("extractContigSamplesShifted8bits",
3088                "Invalid start column value %d ignored", start);
3089     start = 0;
3090     }
3091   if ((end == 0) || (end > cols))
3092     {
3093     TIFFError ("extractContigSamplesShifted8bits",
3094                "Invalid end column value %d ignored", end);
3095     end = cols;
3096     }
3097
3098   ready_bits = shift;
3099   maskbits =  (uint8)-1 >> ( 8 - bps);
3100   buff1 = buff2 = 0;
3101   for (col = start; col < end; col++)
3102     {    /* Compute src byte(s) and bits within byte(s) */
3103     bit_offset = col * bps * spp;
3104     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
3105       {
3106       if (sindex == 0)
3107         {
3108         src_byte = bit_offset / 8;
3109         src_bit  = bit_offset % 8;
3110         }
3111       else
3112         {
3113         src_byte = (bit_offset + (sindex * bps)) / 8;
3114         src_bit  = (bit_offset + (sindex * bps)) % 8;
3115         }
3116
3117       src = in + src_byte;
3118       matchbits = maskbits << (8 - src_bit - bps);
3119       buff1 = ((*src) & matchbits) << (src_bit);
3120       if ((col == start) && (sindex == sample))
3121         buff2 = *src & ((uint8)-1) << (shift);
3122
3123       /* If we have a full buffer's worth, write it out */
3124       if (ready_bits >= 8)
3125         {
3126         *dst++ |= buff2;
3127         buff2 = buff1;
3128         ready_bits -= 8;
3129         }
3130       else
3131         buff2 = buff2 | (buff1 >> ready_bits);
3132       ready_bits += bps;
3133       }
3134     }
3135
3136   while (ready_bits > 0)
3137     {
3138     buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits)));
3139     *dst++ = buff1;
3140     ready_bits -= 8;
3141     }
3142
3143   return (0);
3144   } /* end extractContigSamplesShifted8bits */
3145
3146 static int
3147 extractContigSamplesShifted16bits (uint8 *in, uint8 *out, uint32 cols,
3148                                    tsample_t sample, uint16 spp, uint16 bps,
3149                                    tsample_t count, uint32 start, uint32 end,
3150                                    int shift)
3151   {
3152   int    ready_bits = 0, sindex = 0;
3153   uint32 col, src_byte, src_bit, bit_offset;
3154   uint16 maskbits = 0, matchbits = 0;
3155   uint16 buff1 = 0, buff2 = 0;
3156   uint8  bytebuff = 0;
3157   uint8 *src = in;
3158   uint8 *dst = out;
3159
3160   if ((src == NULL) || (dst == NULL))
3161     {
3162     TIFFError("extractContigSamplesShifted16bits","Invalid input or output buffer");
3163     return (1);
3164     }
3165
3166   if ((start > end) || (start > cols))
3167     {
3168     TIFFError ("extractContigSamplesShifted16bits",
3169                "Invalid start column value %d ignored", start);
3170     start = 0;
3171     }
3172   if ((end == 0) || (end > cols))
3173     {
3174     TIFFError ("extractContigSamplesShifted16bits",
3175                "Invalid end column value %d ignored", end);
3176     end = cols;
3177     }
3178
3179   ready_bits = shift;
3180   maskbits = (uint16)-1 >> (16 - bps);
3181   for (col = start; col < end; col++)
3182     {    /* Compute src byte(s) and bits within byte(s) */
3183     bit_offset = col * bps * spp;
3184     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
3185       {
3186       if (sindex == 0)
3187         {
3188         src_byte = bit_offset / 8;
3189         src_bit  = bit_offset % 8;
3190         }
3191       else
3192         {
3193         src_byte = (bit_offset + (sindex * bps)) / 8;
3194         src_bit  = (bit_offset + (sindex * bps)) % 8;
3195         }
3196
3197       src = in + src_byte;
3198       matchbits = maskbits << (16 - src_bit - bps);
3199       if (little_endian)
3200         buff1 = (src[0] << 8) | src[1];
3201       else
3202         buff1 = (src[1] << 8) | src[0];
3203
3204       if ((col == start) && (sindex == sample))
3205         buff2 = buff1 & ((uint16)-1) << (8 - shift);
3206
3207       buff1 = (buff1 & matchbits) << (src_bit);
3208
3209       if (ready_bits < 8) /* add another bps bits to the buffer */
3210         buff2 = buff2 | (buff1 >> ready_bits);
3211       else  /* If we have a full buffer's worth, write it out */
3212         {
3213         bytebuff = (buff2 >> 8);
3214         *dst++ = bytebuff;
3215         ready_bits -= 8;
3216         /* shift in new bits */
3217         buff2 = ((buff2 << 8) | (buff1 >> ready_bits));
3218         }
3219
3220       ready_bits += bps;
3221       }
3222     }
3223
3224   /* catch any trailing bits at the end of the line */
3225   while (ready_bits > 0)
3226     {
3227     bytebuff = (buff2 >> 8);
3228     *dst++ = bytebuff;
3229     ready_bits -= 8;
3230     }
3231
3232   return (0);
3233   } /* end extractContigSamplesShifted16bits */
3234
3235
3236 static int
3237 extractContigSamplesShifted24bits (uint8 *in, uint8 *out, uint32 cols,
3238                                    tsample_t sample, uint16 spp, uint16 bps,
3239                                    tsample_t count, uint32 start, uint32 end,
3240                                    int shift)
3241   {
3242   int    ready_bits = 0, sindex = 0;
3243   uint32 col, src_byte, src_bit, bit_offset;
3244   uint32 maskbits = 0, matchbits = 0;
3245   uint32 buff1 = 0, buff2 = 0;
3246   uint8  bytebuff1 = 0, bytebuff2 = 0;
3247   uint8 *src = in;
3248   uint8 *dst = out;
3249
3250   if ((in == NULL) || (out == NULL))
3251     {
3252     TIFFError("extractContigSamplesShifted24bits","Invalid input or output buffer");
3253     return (1);
3254     }
3255
3256   if ((start > end) || (start > cols))
3257     {
3258     TIFFError ("extractContigSamplesShifted24bits",
3259                "Invalid start column value %d ignored", start);
3260     start = 0;
3261     }
3262   if ((end == 0) || (end > cols))
3263     {
3264     TIFFError ("extractContigSamplesShifted24bits",
3265                "Invalid end column value %d ignored", end);
3266     end = cols;
3267     }
3268
3269   ready_bits = shift;
3270   maskbits =  (uint32)-1 >> ( 32 - bps);
3271   for (col = start; col < end; col++)
3272     {
3273     /* Compute src byte(s) and bits within byte(s) */
3274     bit_offset = col * bps * spp;
3275     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
3276       {
3277       if (sindex == 0)
3278         {
3279         src_byte = bit_offset / 8;
3280         src_bit  = bit_offset % 8;
3281         }
3282       else
3283         {
3284         src_byte = (bit_offset + (sindex * bps)) / 8;
3285         src_bit  = (bit_offset + (sindex * bps)) % 8;
3286         }
3287
3288       src = in + src_byte;
3289       matchbits = maskbits << (32 - src_bit - bps);
3290       if (little_endian)
3291         buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
3292       else
3293         buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
3294
3295       if ((col == start) && (sindex == sample))
3296         buff2 = buff1 & ((uint32)-1) << (16 - shift);
3297
3298       buff1 = (buff1 & matchbits) << (src_bit);
3299
3300       if (ready_bits < 16)  /* add another bps bits to the buffer */
3301         {
3302         bytebuff1 = bytebuff2 = 0;
3303         buff2 = (buff2 | (buff1 >> ready_bits));
3304         }
3305       else /* If we have a full buffer's worth, write it out */
3306         {
3307         bytebuff1 = (buff2 >> 24);
3308         *dst++ = bytebuff1;
3309         bytebuff2 = (buff2 >> 16);
3310         *dst++ = bytebuff2;
3311         ready_bits -= 16;
3312
3313         /* shift in new bits */
3314         buff2 = ((buff2 << 16) | (buff1 >> ready_bits));
3315         }
3316       ready_bits += bps;
3317       }
3318     }
3319
3320   /* catch any trailing bits at the end of the line */
3321   while (ready_bits > 0)
3322     {
3323     bytebuff1 = (buff2 >> 24);
3324     *dst++ = bytebuff1;
3325
3326     buff2 = (buff2 << 8);
3327     bytebuff2 = bytebuff1;
3328     ready_bits -= 8;
3329     }
3330
3331   return (0);
3332   } /* end extractContigSamplesShifted24bits */
3333
3334 static int
3335 extractContigSamplesShifted32bits (uint8 *in, uint8 *out, uint32 cols,
3336                                    tsample_t sample, uint16 spp, uint16 bps,
3337                                    tsample_t count, uint32 start, uint32 end,
3338                                    int shift)
3339   {
3340   int    ready_bits = 0, sindex = 0, shift_width = 0;
3341   uint32 col, src_byte, src_bit, bit_offset;
3342   uint32 longbuff1 = 0, longbuff2 = 0;
3343   uint64 maskbits = 0, matchbits = 0;
3344   uint64 buff1 = 0, buff2 = 0, buff3 = 0;
3345   uint8  bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0;
3346   uint8 *src = in;
3347   uint8 *dst = out;
3348
3349   if ((in == NULL) || (out == NULL))
3350     {
3351     TIFFError("extractContigSamplesShifted32bits","Invalid input or output buffer");
3352     return (1);
3353     }
3354
3355
3356   if ((start > end) || (start > cols))
3357     {
3358     TIFFError ("extractContigSamplesShifted32bits",
3359                "Invalid start column value %d ignored", start);
3360     start = 0;
3361     }
3362   if ((end == 0) || (end > cols))
3363     {
3364     TIFFError ("extractContigSamplesShifted32bits",
3365                "Invalid end column value %d ignored", end);
3366     end = cols;
3367     }
3368
3369   shift_width = ((bps + 7) / 8) + 1;
3370   ready_bits = shift;
3371   maskbits =  (uint64)-1 >> ( 64 - bps);
3372   for (col = start; col < end; col++)
3373     {
3374     /* Compute src byte(s) and bits within byte(s) */
3375     bit_offset = col * bps * spp;
3376     for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++)
3377       {
3378       if (sindex == 0)
3379         {
3380         src_byte = bit_offset / 8;
3381         src_bit  = bit_offset % 8;
3382         }
3383       else
3384         {
3385         src_byte = (bit_offset + (sindex * bps)) / 8;
3386         src_bit  = (bit_offset + (sindex * bps)) % 8;
3387         }
3388
3389       src = in + src_byte;
3390       matchbits = maskbits << (64 - src_bit - bps);
3391       if (little_endian)
3392         {
3393         longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
3394         longbuff2 = longbuff1;
3395         }
3396       else
3397         {
3398         longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
3399         longbuff2 = longbuff1;
3400         }
3401
3402       buff3 = ((uint64)longbuff1 << 32) | longbuff2;
3403       if ((col == start) && (sindex == sample))
3404         buff2 = buff3 & ((uint64)-1) << (32 - shift);
3405
3406       buff1 = (buff3 & matchbits) << (src_bit);
3407
3408       if (ready_bits < 32)
3409         { /* add another bps bits to the buffer */
3410         bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0;
3411         buff2 = (buff2 | (buff1 >> ready_bits));
3412         }
3413       else  /* If we have a full buffer's worth, write it out */
3414         {
3415         bytebuff1 = (buff2 >> 56);
3416         *dst++ = bytebuff1;
3417         bytebuff2 = (buff2 >> 48);
3418         *dst++ = bytebuff2;
3419         bytebuff3 = (buff2 >> 40);
3420         *dst++ = bytebuff3;
3421         bytebuff4 = (buff2 >> 32);
3422         *dst++ = bytebuff4;
3423         ready_bits -= 32;
3424
3425         /* shift in new bits */
3426         buff2 = ((buff2 << 32) | (buff1 >> ready_bits));
3427         }
3428       ready_bits += bps;
3429       }
3430     }
3431   while (ready_bits > 0)
3432     {
3433     bytebuff1 = (buff2 >> 56);
3434     *dst++ = bytebuff1;
3435     buff2 = (buff2 << 8);
3436     ready_bits -= 8;
3437     }
3438
3439   return (0);
3440   } /* end extractContigSamplesShifted32bits */
3441
3442 static int
3443 extractContigSamplesToBuffer(uint8 *out, uint8 *in, uint32 rows, uint32 cols,
3444                              tsample_t sample, uint16 spp, uint16 bps,
3445                              struct dump_opts *dump)
3446   {
3447   int    shift_width, bytes_per_sample, bytes_per_pixel;
3448   uint32 src_rowsize, src_offset, row, first_col = 0;
3449   uint32 dst_rowsize, dst_offset;
3450   tsample_t count = 1;
3451   uint8 *src, *dst;
3452
3453   bytes_per_sample = (bps + 7) / 8;
3454   bytes_per_pixel  = ((bps * spp) + 7) / 8;
3455   if ((bps % 8) == 0)
3456     shift_width = 0;
3457   else
3458     {
3459     if (bytes_per_pixel < (bytes_per_sample + 1))
3460       shift_width = bytes_per_pixel;
3461     else
3462       shift_width = bytes_per_sample + 1;
3463     }
3464   src_rowsize = ((bps * spp * cols) + 7) / 8;
3465   dst_rowsize = ((bps * cols) + 7) / 8;
3466
3467   if ((dump->outfile != NULL) && (dump->level == 4))
3468     {
3469     dump_info  (dump->outfile, dump->format, "extractContigSamplesToBuffer",
3470                 "Sample %d, %d rows", sample + 1, rows + 1);
3471     }
3472   for (row = 0; row < rows; row++)
3473     {
3474     src_offset = row * src_rowsize;
3475     dst_offset = row * dst_rowsize;
3476     src = in + src_offset;
3477     dst = out + dst_offset;
3478
3479     /* pack the data into the scanline */
3480     switch (shift_width)
3481       {
3482       case 0: if (extractContigSamplesBytes (src, dst, cols, sample,
3483                                              spp, bps,  count, first_col, cols))
3484                 return (1);
3485               break;
3486       case 1: if (bps == 1)
3487                 {
3488                 if (extractContigSamples8bits (src, dst, cols, sample,
3489                                                spp, bps, count, first_col, cols))
3490                   return (1);
3491                 break;
3492                 }
3493               else
3494                  if (extractContigSamples16bits (src, dst, cols, sample,
3495                                                  spp, bps, count, first_col, cols))
3496                  return (1);
3497               break;
3498       case 2: if (extractContigSamples24bits (src, dst, cols, sample,
3499                                               spp, bps,  count, first_col, cols))
3500                  return (1);
3501               break;
3502       case 3:
3503       case 4:
3504       case 5: if (extractContigSamples32bits (src, dst, cols, sample,
3505                                               spp, bps,  count, first_col, cols))
3506                  return (1);
3507               break;
3508       default: TIFFError ("extractContigSamplesToBuffer", "Unsupported bit depth: %d", bps);
3509                return (1);
3510       }
3511     if ((dump->outfile != NULL) && (dump->level == 4))
3512       dump_buffer(dump->outfile, dump->format, 1, dst_rowsize, row, dst);
3513     }
3514
3515   return (0);
3516   } /* end extractContigSamplesToBuffer */
3517
3518 static int
3519 extractContigSamplesToTileBuffer(uint8 *out, uint8 *in, uint32 rows, uint32 cols,
3520                                  uint32 imagewidth, uint32 tilewidth, tsample_t sample,
3521                                  uint16 count, uint16 spp, uint16 bps, struct dump_opts *dump)
3522   {
3523   int    shift_width, bytes_per_sample, bytes_per_pixel;
3524   uint32 src_rowsize, src_offset, row;
3525   uint32 dst_rowsize, dst_offset;
3526   uint8 *src, *dst;
3527
3528   bytes_per_sample = (bps + 7) / 8;
3529   bytes_per_pixel  = ((bps * spp) + 7) / 8;
3530   if ((bps % 8) == 0)
3531     shift_width = 0;
3532   else
3533     {
3534     if (bytes_per_pixel < (bytes_per_sample + 1))
3535       shift_width = bytes_per_pixel;
3536     else
3537       shift_width = bytes_per_sample + 1;
3538     }
3539
3540   if ((dump->outfile != NULL) && (dump->level == 4))
3541     {
3542     dump_info  (dump->outfile, dump->format, "extractContigSamplesToTileBuffer",
3543                 "Sample %d, %d rows", sample + 1, rows + 1);
3544     }
3545
3546   src_rowsize = ((bps * spp * imagewidth) + 7) / 8;
3547   dst_rowsize = ((bps * tilewidth * count) + 7) / 8;
3548
3549   for (row = 0; row < rows; row++)
3550     {
3551     src_offset = row * src_rowsize;
3552     dst_offset = row * dst_rowsize;
3553     src = in + src_offset;
3554     dst = out + dst_offset;
3555
3556     /* pack the data into the scanline */
3557     switch (shift_width)
3558       {
3559       case 0: if (extractContigSamplesBytes (src, dst, cols, sample,
3560                                              spp, bps,  count, 0, cols))
3561                 return (1);
3562               break;
3563       case 1: if (bps == 1)
3564                 {
3565                 if (extractContigSamples8bits (src, dst, cols, sample,
3566                                                spp, bps, count, 0, cols))
3567                   return (1);
3568                 break;
3569                 }
3570               else
3571                  if (extractContigSamples16bits (src, dst, cols, sample,
3572                                                  spp, bps, count, 0, cols))
3573                  return (1);
3574               break;
3575       case 2: if (extractContigSamples24bits (src, dst, cols, sample,
3576                                               spp, bps,  count, 0, cols))
3577                  return (1);
3578               break;
3579       case 3:
3580       case 4:
3581       case 5: if (extractContigSamples32bits (src, dst, cols, sample,
3582                                               spp, bps,  count, 0, cols))
3583                  return (1);
3584               break;
3585       default: TIFFError ("extractContigSamplesToTileBuffer", "Unsupported bit depth: %d", bps);
3586                return (1);
3587       }
3588     if ((dump->outfile != NULL) && (dump->level == 4))
3589       dump_buffer(dump->outfile, dump->format, 1, dst_rowsize, row, dst);
3590     }
3591
3592   return (0);
3593   } /* end extractContigSamplesToTileBuffer */
3594
3595 static int readContigStripsIntoBuffer (TIFF* in, uint8* buf)
3596   {
3597   uint8* bufp = buf;
3598   int32  bytes_read = 0;
3599   uint16 strip, nstrips   = TIFFNumberOfStrips(in);
3600   uint32 stripsize = TIFFStripSize(in);
3601   uint32 rows = 0;
3602   uint32 rps = TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps);
3603   tsize_t scanline_size = TIFFScanlineSize(in);
3604
3605   for (strip = 0; strip < nstrips; strip++)
3606     {
3607     bytes_read = TIFFReadEncodedStrip (in, strip, bufp, -1);
3608     rows = bytes_read / scanline_size;
3609     if ((strip < (nstrips - 1)) && (bytes_read != (int32)stripsize))
3610       TIFFError("", "Strip %d: read %lu bytes, strip size %lu",
3611                 (int)strip + 1, (unsigned long) bytes_read, (unsigned long)stripsize);
3612
3613     if (bytes_read < 0 && !ignore)
3614       {
3615       TIFFError("", "Error reading strip %lu after %lu rows",
3616                 (unsigned long) strip, (unsigned long)rows);
3617       return 0;
3618       }
3619     bufp += bytes_read;
3620     }
3621
3622  return 1;
3623   } /* end readContigStripsIntoBuffer */
3624
3625 static int
3626 combineSeparateSamplesBytes (unsigned char *srcbuffs[], unsigned char *out,
3627                              uint32 cols, uint32 rows, uint16 spp, uint16 bps,
3628                              FILE *dumpfile, int format, int level)
3629   {
3630   int i, bytes_per_sample;
3631   uint32 row, col, col_offset, src_rowsize, dst_rowsize, row_offset;
3632   unsigned char *src;
3633   unsigned char *dst;
3634   tsample_t s;
3635
3636   src = srcbuffs[0];
3637   dst = out;
3638   if ((src == NULL) || (dst == NULL))
3639     {
3640     TIFFError("combineSeparateSamplesBytes","Invalid buffer address");
3641     return (1);
3642     }
3643
3644   bytes_per_sample = (bps + 7) / 8;
3645
3646   src_rowsize = ((bps * cols) + 7) / 8;
3647   dst_rowsize = ((bps * spp * cols) + 7) / 8;
3648   for (row = 0; row < rows; row++)
3649     {
3650     if ((dumpfile != NULL) && (level == 2))
3651       {
3652       for (s = 0; s < spp; s++)
3653         {
3654         dump_info (dumpfile, format, "combineSeparateSamplesBytes","Input data, Sample %d", s);
3655         dump_buffer(dumpfile, format, 1, cols, row, srcbuffs[s] + (row * src_rowsize));
3656         }
3657       }
3658     dst = out + (row * dst_rowsize);
3659     row_offset = row * src_rowsize;
3660     for (col = 0; col < cols; col++)
3661       {
3662       col_offset = row_offset + (col * (bps / 8));
3663       for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++)
3664         {
3665         src = srcbuffs[s] + col_offset;
3666         for (i = 0; i < bytes_per_sample; i++)
3667           *(dst + i) = *(src + i);
3668         src += bytes_per_sample;
3669         dst += bytes_per_sample;
3670         }
3671       }
3672
3673     if ((dumpfile != NULL) && (level == 2))
3674       {
3675       dump_info (dumpfile, format, "combineSeparateSamplesBytes","Output data, combined samples");
3676       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
3677       }
3678     }
3679
3680   return (0);
3681   } /* end combineSeparateSamplesBytes */
3682
3683 static int
3684 combineSeparateSamples8bits (uint8 *in[], uint8 *out, uint32 cols,
3685                             uint32 rows, uint16 spp, uint16 bps,
3686                             FILE *dumpfile, int format, int level)
3687   {
3688   int    ready_bits = 0;
3689   int    bytes_per_sample = 0;
3690   uint32 src_rowsize, dst_rowsize, src_offset;
3691   uint32 bit_offset;
3692   uint32 row, col, src_byte = 0, src_bit = 0;
3693   uint8  maskbits = 0, matchbits = 0;
3694   uint8  buff1 = 0, buff2 = 0;
3695   tsample_t s;
3696   unsigned char *src = in[0];
3697   unsigned char *dst = out;
3698   char           action[32];
3699
3700   if ((src == NULL) || (dst == NULL))
3701     {
3702     TIFFError("combineSeparateSamples8bits","Invalid input or output buffer");
3703     return (1);
3704     }
3705
3706   bytes_per_sample = (bps + 7) / 8;
3707   src_rowsize = ((bps * cols) + 7) / 8;
3708   dst_rowsize = ((bps * cols * spp) + 7) / 8;
3709   maskbits =  (uint8)-1 >> ( 8 - bps);
3710
3711   for (row = 0; row < rows; row++)
3712     {
3713     ready_bits = 0;
3714     buff1 = buff2 = 0;
3715     dst = out + (row * dst_rowsize);
3716     src_offset = row * src_rowsize;
3717     for (col = 0; col < cols; col++)
3718       {
3719       /* Compute src byte(s) and bits within byte(s) */
3720       bit_offset = col * bps;
3721       src_byte = bit_offset / 8;
3722       src_bit  = bit_offset % 8;
3723
3724       matchbits = maskbits << (8 - src_bit - bps);
3725       /* load up next sample from each plane */
3726       for (s = 0; s < spp; s++)
3727         {
3728         src = in[s] + src_offset + src_byte;
3729         buff1 = ((*src) & matchbits) << (src_bit);
3730
3731         /* If we have a full buffer's worth, write it out */
3732         if (ready_bits >= 8)
3733           {
3734           *dst++ = buff2;
3735           buff2 = buff1;
3736           ready_bits -= 8;
3737           strcpy (action, "Flush");
3738           }
3739         else
3740           {
3741           buff2 = (buff2 | (buff1 >> ready_bits));
3742           strcpy (action, "Update");
3743           }
3744         ready_bits += bps;
3745
3746         if ((dumpfile != NULL) && (level == 3))
3747           {
3748           dump_info (dumpfile, format, "",
3749                    "Row %3d, Col %3d, Samples %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
3750                    row + 1, col + 1, s, src_byte, src_bit, dst - out);
3751           dump_byte (dumpfile, format, "Match bits", matchbits);
3752           dump_byte (dumpfile, format, "Src   bits", *src);
3753           dump_byte (dumpfile, format, "Buff1 bits", buff1);
3754           dump_byte (dumpfile, format, "Buff2 bits", buff2);
3755           dump_info (dumpfile, format, "","%s", action);
3756           }
3757         }
3758       }
3759
3760     if (ready_bits > 0)
3761       {
3762       buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits)));
3763       *dst++ = buff1;
3764       if ((dumpfile != NULL) && (level == 3))
3765         {
3766         dump_info (dumpfile, format, "",
3767                  "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
3768                  row + 1, col + 1, src_byte, src_bit, dst - out);
3769                  dump_byte (dumpfile, format, "Final bits", buff1);
3770         }
3771       }
3772
3773     if ((dumpfile != NULL) && (level >= 2))
3774       {
3775       dump_info (dumpfile, format, "combineSeparateSamples8bits","Output data");
3776       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
3777       }
3778     }
3779
3780   return (0);
3781   } /* end combineSeparateSamples8bits */
3782
3783 static int
3784 combineSeparateSamples16bits (uint8 *in[], uint8 *out, uint32 cols,
3785                               uint32 rows, uint16 spp, uint16 bps,
3786                               FILE *dumpfile, int format, int level)
3787   {
3788   int    ready_bits = 0, bytes_per_sample = 0;
3789   uint32 src_rowsize, dst_rowsize;
3790   uint32 bit_offset, src_offset;
3791   uint32 row, col, src_byte = 0, src_bit = 0;
3792   uint16 maskbits = 0, matchbits = 0;
3793   uint16 buff1 = 0, buff2 = 0;
3794   uint8  bytebuff = 0;
3795   tsample_t s;
3796   unsigned char *src = in[0];
3797   unsigned char *dst = out;
3798   char           action[8];
3799
3800   if ((src == NULL) || (dst == NULL))
3801     {
3802     TIFFError("combineSeparateSamples16bits","Invalid input or output buffer");
3803     return (1);
3804     }
3805
3806   bytes_per_sample = (bps + 7) / 8;
3807   src_rowsize = ((bps * cols) + 7) / 8;
3808   dst_rowsize = ((bps * cols * spp) + 7) / 8;
3809   maskbits = (uint16)-1 >> (16 - bps);
3810
3811   for (row = 0; row < rows; row++)
3812     {
3813     ready_bits = 0;
3814     buff1 = buff2 = 0;
3815     dst = out + (row * dst_rowsize);
3816     src_offset = row * src_rowsize;
3817     for (col = 0; col < cols; col++)
3818       {
3819       /* Compute src byte(s) and bits within byte(s) */
3820       bit_offset = col * bps;
3821       src_byte = bit_offset / 8;
3822       src_bit  = bit_offset % 8;
3823
3824       matchbits = maskbits << (16 - src_bit - bps);
3825       for (s = 0; s < spp; s++)
3826         {
3827         src = in[s] + src_offset + src_byte;
3828         if (little_endian)
3829           buff1 = (src[0] << 8) | src[1];
3830         else
3831           buff1 = (src[1] << 8) | src[0];
3832
3833         buff1 = (buff1 & matchbits) << (src_bit);
3834
3835         /* If we have a full buffer's worth, write it out */
3836         if (ready_bits >= 8)
3837           {
3838             bytebuff = (buff2 >> 8);
3839             *dst++ = bytebuff;
3840             ready_bits -= 8;
3841             /* shift in new bits */
3842             buff2 = ((buff2 << 8) | (buff1 >> ready_bits));
3843             strcpy (action, "Flush");
3844           }
3845         else
3846           { /* add another bps bits to the buffer */
3847             bytebuff = 0;
3848             buff2 = (buff2 | (buff1 >> ready_bits));
3849             strcpy (action, "Update");
3850           }
3851         ready_bits += bps;
3852
3853         if ((dumpfile != NULL) && (level == 3))
3854           {
3855           dump_info (dumpfile, format, "",
3856                        "Row %3d, Col %3d, Samples %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
3857                        row + 1, col + 1, s, src_byte, src_bit, dst - out);
3858
3859           dump_short (dumpfile, format, "Match bits", matchbits);
3860           dump_data  (dumpfile, format, "Src   bits", src, 2);
3861           dump_short (dumpfile, format, "Buff1 bits", buff1);
3862           dump_short (dumpfile, format, "Buff2 bits", buff2);
3863           dump_byte  (dumpfile, format, "Write byte", bytebuff);
3864           dump_info  (dumpfile, format, "","Ready bits:  %d, %s", ready_bits, action);
3865           }
3866         }
3867       }
3868
3869     /* catch any trailing bits at the end of the line */
3870     if (ready_bits > 0)
3871       {
3872       bytebuff = (buff2 >> 8);
3873       *dst++ = bytebuff;
3874       if ((dumpfile != NULL) && (level == 3))
3875         {
3876         dump_info (dumpfile, format, "",
3877                        "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
3878                        row + 1, col + 1, src_byte, src_bit, dst - out);
3879         dump_byte (dumpfile, format, "Final bits", bytebuff);
3880         }
3881       }
3882
3883     if ((dumpfile != NULL) && (level == 2))
3884       {
3885       dump_info (dumpfile, format, "combineSeparateSamples16bits","Output data");
3886       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
3887       }
3888     }
3889
3890   return (0);
3891   } /* end combineSeparateSamples16bits */
3892
3893 static int
3894 combineSeparateSamples24bits (uint8 *in[], uint8 *out, uint32 cols,
3895                               uint32 rows, uint16 spp, uint16 bps,
3896                               FILE *dumpfile, int format, int level)
3897   {
3898   int    ready_bits = 0, bytes_per_sample = 0;
3899   uint32 src_rowsize, dst_rowsize;
3900   uint32 bit_offset, src_offset;
3901   uint32 row, col, src_byte = 0, src_bit = 0;
3902   uint32 maskbits = 0, matchbits = 0;
3903   uint32 buff1 = 0, buff2 = 0;
3904   uint8  bytebuff1 = 0, bytebuff2 = 0;
3905   tsample_t s;
3906   unsigned char *src = in[0];
3907   unsigned char *dst = out;
3908   char           action[8];
3909
3910   if ((src == NULL) || (dst == NULL))
3911     {
3912     TIFFError("combineSeparateSamples24bits","Invalid input or output buffer");
3913     return (1);
3914     }
3915
3916   bytes_per_sample = (bps + 7) / 8;
3917   src_rowsize = ((bps * cols) + 7) / 8;
3918   dst_rowsize = ((bps * cols * spp) + 7) / 8;
3919   maskbits =  (uint32)-1 >> ( 32 - bps);
3920
3921   for (row = 0; row < rows; row++)
3922     {
3923     ready_bits = 0;
3924     buff1 = buff2 = 0;
3925     dst = out + (row * dst_rowsize);
3926     src_offset = row * src_rowsize;
3927     for (col = 0; col < cols; col++)
3928       {
3929       /* Compute src byte(s) and bits within byte(s) */
3930       bit_offset = col * bps;
3931       src_byte = bit_offset / 8;
3932       src_bit  = bit_offset % 8;
3933
3934       matchbits = maskbits << (32 - src_bit - bps);
3935       for (s = 0; s < spp; s++)
3936         {
3937         src = in[s] + src_offset + src_byte;
3938         if (little_endian)
3939           buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
3940         else
3941           buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
3942         buff1 = (buff1 & matchbits) << (src_bit);
3943
3944         /* If we have a full buffer's worth, write it out */
3945         if (ready_bits >= 16)
3946           {
3947             bytebuff1 = (buff2 >> 24);
3948             *dst++ = bytebuff1;
3949             bytebuff2 = (buff2 >> 16);
3950             *dst++ = bytebuff2;
3951             ready_bits -= 16;
3952
3953             /* shift in new bits */
3954             buff2 = ((buff2 << 16) | (buff1 >> ready_bits));
3955             strcpy (action, "Flush");
3956           }
3957         else
3958           { /* add another bps bits to the buffer */
3959             bytebuff1 = bytebuff2 = 0;
3960             buff2 = (buff2 | (buff1 >> ready_bits));
3961             strcpy (action, "Update");
3962           }
3963         ready_bits += bps;
3964
3965         if ((dumpfile != NULL) && (level == 3))
3966           {
3967           dump_info (dumpfile, format, "",
3968                        "Row %3d, Col %3d, Samples %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
3969                        row + 1, col + 1, s, src_byte, src_bit, dst - out);
3970           dump_long (dumpfile, format, "Match bits ", matchbits);
3971           dump_data (dumpfile, format, "Src   bits ", src, 4);
3972           dump_long (dumpfile, format, "Buff1 bits ", buff1);
3973           dump_long (dumpfile, format, "Buff2 bits ", buff2);
3974           dump_byte (dumpfile, format, "Write bits1", bytebuff1);
3975           dump_byte (dumpfile, format, "Write bits2", bytebuff2);
3976           dump_info (dumpfile, format, "","Ready bits:   %d, %s", ready_bits, action);
3977           }
3978         }
3979       }
3980
3981     /* catch any trailing bits at the end of the line */
3982     while (ready_bits > 0)
3983       {
3984         bytebuff1 = (buff2 >> 24);
3985         *dst++ = bytebuff1;
3986
3987         buff2 = (buff2 << 8);
3988         bytebuff2 = bytebuff1;
3989         ready_bits -= 8;
3990       }
3991
3992     if ((dumpfile != NULL) && (level == 3))
3993       {
3994       dump_info (dumpfile, format, "",
3995                    "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
3996                    row + 1, col + 1, src_byte, src_bit, dst - out);
3997
3998       dump_long (dumpfile, format, "Match bits ", matchbits);
3999       dump_data (dumpfile, format, "Src   bits ", src, 4);
4000       dump_long (dumpfile, format, "Buff1 bits ", buff1);
4001       dump_long (dumpfile, format, "Buff2 bits ", buff2);
4002       dump_byte (dumpfile, format, "Write bits1", bytebuff1);
4003       dump_byte (dumpfile, format, "Write bits2", bytebuff2);
4004       dump_info (dumpfile, format, "", "Ready bits:  %2d", ready_bits);
4005       }
4006
4007     if ((dumpfile != NULL) && (level == 2))
4008       {
4009       dump_info (dumpfile, format, "combineSeparateSamples24bits","Output data");
4010       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
4011       }
4012     }
4013
4014   return (0);
4015   } /* end combineSeparateSamples24bits */
4016
4017 static int
4018 combineSeparateSamples32bits (uint8 *in[], uint8 *out, uint32 cols,
4019                               uint32 rows, uint16 spp, uint16 bps,
4020                               FILE *dumpfile, int format, int level)
4021   {
4022   int    ready_bits = 0, bytes_per_sample = 0, shift_width = 0;
4023   uint32 src_rowsize, dst_rowsize, bit_offset, src_offset;
4024   uint32 src_byte = 0, src_bit = 0;
4025   uint32 row, col;
4026   uint32 longbuff1 = 0, longbuff2 = 0;
4027   uint64 maskbits = 0, matchbits = 0;
4028   uint64 buff1 = 0, buff2 = 0, buff3 = 0;
4029   uint8  bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0;
4030   tsample_t s;
4031   unsigned char *src = in[0];
4032   unsigned char *dst = out;
4033   char           action[8];
4034
4035   if ((src == NULL) || (dst == NULL))
4036     {
4037     TIFFError("combineSeparateSamples32bits","Invalid input or output buffer");
4038     return (1);
4039     }
4040
4041   bytes_per_sample = (bps + 7) / 8;
4042   src_rowsize = ((bps * cols) + 7) / 8;
4043   dst_rowsize = ((bps * cols * spp) + 7) / 8;
4044   maskbits =  (uint64)-1 >> ( 64 - bps);
4045   shift_width = ((bps + 7) / 8) + 1;
4046
4047   for (row = 0; row < rows; row++)
4048     {
4049     ready_bits = 0;
4050     buff1 = buff2 = 0;
4051     dst = out + (row * dst_rowsize);
4052     src_offset = row * src_rowsize;
4053     for (col = 0; col < cols; col++)
4054       {
4055       /* Compute src byte(s) and bits within byte(s) */
4056       bit_offset = col * bps;
4057       src_byte = bit_offset / 8;
4058       src_bit  = bit_offset % 8;
4059
4060       matchbits = maskbits << (64 - src_bit - bps);
4061       for (s = 0; s < spp; s++)
4062         {
4063         src = in[s] + src_offset + src_byte;
4064         if (little_endian)
4065           {
4066           longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
4067           longbuff2 = longbuff1;
4068           }
4069         else
4070           {
4071           longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
4072           longbuff2 = longbuff1;
4073           }
4074         buff3 = ((uint64)longbuff1 << 32) | longbuff2;
4075         buff1 = (buff3 & matchbits) << (src_bit);
4076
4077         /* If we have a full buffer's worth, write it out */
4078         if (ready_bits >= 32)
4079           {
4080           bytebuff1 = (buff2 >> 56);
4081           *dst++ = bytebuff1;
4082           bytebuff2 = (buff2 >> 48);
4083           *dst++ = bytebuff2;
4084           bytebuff3 = (buff2 >> 40);
4085           *dst++ = bytebuff3;
4086           bytebuff4 = (buff2 >> 32);
4087           *dst++ = bytebuff4;
4088           ready_bits -= 32;
4089
4090           /* shift in new bits */
4091           buff2 = ((buff2 << 32) | (buff1 >> ready_bits));
4092           strcpy (action, "Flush");
4093           }
4094         else
4095           { /* add another bps bits to the buffer */
4096           bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0;
4097           buff2 = (buff2 | (buff1 >> ready_bits));
4098           strcpy (action, "Update");
4099           }
4100         ready_bits += bps;
4101
4102         if ((dumpfile != NULL) && (level == 3))
4103           {
4104           dump_info (dumpfile, format, "",
4105                      "Row %3d, Col %3d, Sample %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4106                      row + 1, col + 1, s, src_byte, src_bit, dst - out);
4107           dump_wide (dumpfile, format, "Match bits ", matchbits);
4108           dump_data (dumpfile, format, "Src   bits ", src, 8);
4109           dump_wide (dumpfile, format, "Buff1 bits ", buff1);
4110           dump_wide (dumpfile, format, "Buff2 bits ", buff2);
4111           dump_info (dumpfile, format, "", "Ready bits:   %d, %s", ready_bits, action);
4112           }
4113         }
4114       }
4115     while (ready_bits > 0)
4116       {
4117       bytebuff1 = (buff2 >> 56);
4118       *dst++ = bytebuff1;
4119       buff2 = (buff2 << 8);
4120       ready_bits -= 8;
4121       }
4122
4123     if ((dumpfile != NULL) && (level == 3))
4124       {
4125       dump_info (dumpfile, format, "",
4126                  "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4127                  row + 1, col + 1, src_byte, src_bit, dst - out);
4128
4129       dump_long (dumpfile, format, "Match bits ", matchbits);
4130       dump_data (dumpfile, format, "Src   bits ", src, 4);
4131       dump_long (dumpfile, format, "Buff1 bits ", buff1);
4132       dump_long (dumpfile, format, "Buff2 bits ", buff2);
4133       dump_byte (dumpfile, format, "Write bits1", bytebuff1);
4134       dump_byte (dumpfile, format, "Write bits2", bytebuff2);
4135       dump_info (dumpfile, format, "", "Ready bits:  %2d", ready_bits);
4136       }
4137
4138     if ((dumpfile != NULL) && (level == 2))
4139       {
4140       dump_info (dumpfile, format, "combineSeparateSamples32bits","Output data");
4141       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out);
4142       }
4143     }
4144
4145   return (0);
4146   } /* end combineSeparateSamples32bits */
4147
4148 static int
4149 combineSeparateTileSamplesBytes (unsigned char *srcbuffs[], unsigned char *out,
4150                                  uint32 cols, uint32 rows, uint32 imagewidth,
4151                                  uint32 tw, uint16 spp, uint16 bps,
4152                                  FILE *dumpfile, int format, int level)
4153   {
4154   int i, bytes_per_sample;
4155   uint32 row, col, col_offset, src_rowsize, dst_rowsize, src_offset;
4156   unsigned char *src;
4157   unsigned char *dst;
4158   tsample_t s;
4159
4160   src = srcbuffs[0];
4161   dst = out;
4162   if ((src == NULL) || (dst == NULL))
4163     {
4164     TIFFError("combineSeparateTileSamplesBytes","Invalid buffer address");
4165     return (1);
4166     }
4167
4168   bytes_per_sample = (bps + 7) / 8;
4169   src_rowsize = ((bps * tw) + 7) / 8;
4170   dst_rowsize = imagewidth * bytes_per_sample * spp;
4171   for (row = 0; row < rows; row++)
4172     {
4173     if ((dumpfile != NULL) && (level == 2))
4174       {
4175       for (s = 0; s < spp; s++)
4176         {
4177         dump_info (dumpfile, format, "combineSeparateTileSamplesBytes","Input data, Sample %d", s);
4178         dump_buffer(dumpfile, format, 1, cols, row, srcbuffs[s] + (row * src_rowsize));
4179         }
4180       }
4181     dst = out + (row * dst_rowsize);
4182     src_offset = row * src_rowsize;
4183 #ifdef DEVELMODE
4184     TIFFError("","Tile row %4d, Src offset %6d   Dst offset %6d",
4185               row, src_offset, dst - out);
4186 #endif
4187     for (col = 0; col < cols; col++)
4188       {
4189       col_offset = src_offset + (col * (bps / 8));
4190       for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++)
4191         {
4192         src = srcbuffs[s] + col_offset;
4193         for (i = 0; i < bytes_per_sample; i++)
4194           *(dst + i) = *(src + i);
4195         dst += bytes_per_sample;
4196         }
4197       }
4198
4199     if ((dumpfile != NULL) && (level == 2))
4200       {
4201       dump_info (dumpfile, format, "combineSeparateTileSamplesBytes","Output data, combined samples");
4202       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
4203       }
4204     }
4205
4206   return (0);
4207   } /* end combineSeparateTileSamplesBytes */
4208
4209 static int
4210 combineSeparateTileSamples8bits (uint8 *in[], uint8 *out, uint32 cols,
4211                                  uint32 rows, uint32 imagewidth,
4212                                  uint32 tw, uint16 spp, uint16 bps,
4213                                  FILE *dumpfile, int format, int level)
4214   {
4215   int    ready_bits = 0;
4216   uint32 src_rowsize, dst_rowsize, src_offset;
4217   uint32 bit_offset;
4218   uint32 row, col, src_byte = 0, src_bit = 0;
4219   uint8  maskbits = 0, matchbits = 0;
4220   uint8  buff1 = 0, buff2 = 0;
4221   tsample_t s;
4222   unsigned char *src = in[0];
4223   unsigned char *dst = out;
4224   char           action[32];
4225
4226   if ((src == NULL) || (dst == NULL))
4227     {
4228     TIFFError("combineSeparateTileSamples8bits","Invalid input or output buffer");
4229     return (1);
4230     }
4231
4232   src_rowsize = ((bps * tw) + 7) / 8;
4233   dst_rowsize = ((imagewidth * bps * spp) + 7) / 8;
4234   maskbits =  (uint8)-1 >> ( 8 - bps);
4235
4236   for (row = 0; row < rows; row++)
4237     {
4238     ready_bits = 0;
4239     buff1 = buff2 = 0;
4240     dst = out + (row * dst_rowsize);
4241     src_offset = row * src_rowsize;
4242     for (col = 0; col < cols; col++)
4243       {
4244       /* Compute src byte(s) and bits within byte(s) */
4245       bit_offset = col * bps;
4246       src_byte = bit_offset / 8;
4247       src_bit  = bit_offset % 8;
4248
4249       matchbits = maskbits << (8 - src_bit - bps);
4250       /* load up next sample from each plane */
4251       for (s = 0; s < spp; s++)
4252         {
4253         src = in[s] + src_offset + src_byte;
4254         buff1 = ((*src) & matchbits) << (src_bit);
4255
4256         /* If we have a full buffer's worth, write it out */
4257         if (ready_bits >= 8)
4258           {
4259           *dst++ = buff2;
4260           buff2 = buff1;
4261           ready_bits -= 8;
4262           strcpy (action, "Flush");
4263           }
4264         else
4265           {
4266           buff2 = (buff2 | (buff1 >> ready_bits));
4267           strcpy (action, "Update");
4268           }
4269         ready_bits += bps;
4270
4271         if ((dumpfile != NULL) && (level == 3))
4272           {
4273           dump_info (dumpfile, format, "",
4274                    "Row %3d, Col %3d, Samples %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4275                    row + 1, col + 1, s, src_byte, src_bit, dst - out);
4276           dump_byte (dumpfile, format, "Match bits", matchbits);
4277           dump_byte (dumpfile, format, "Src   bits", *src);
4278           dump_byte (dumpfile, format, "Buff1 bits", buff1);
4279           dump_byte (dumpfile, format, "Buff2 bits", buff2);
4280           dump_info (dumpfile, format, "","%s", action);
4281           }
4282         }
4283       }
4284
4285     if (ready_bits > 0)
4286       {
4287       buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits)));
4288       *dst++ = buff1;
4289       if ((dumpfile != NULL) && (level == 3))
4290         {
4291         dump_info (dumpfile, format, "",
4292                  "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4293                  row + 1, col + 1, src_byte, src_bit, dst - out);
4294                  dump_byte (dumpfile, format, "Final bits", buff1);
4295         }
4296       }
4297
4298     if ((dumpfile != NULL) && (level >= 2))
4299       {
4300       dump_info (dumpfile, format, "combineSeparateTileSamples8bits","Output data");
4301       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
4302       }
4303     }
4304
4305   return (0);
4306   } /* end combineSeparateTileSamples8bits */
4307
4308 static int
4309 combineSeparateTileSamples16bits (uint8 *in[], uint8 *out, uint32 cols,
4310                                   uint32 rows, uint32 imagewidth,
4311                                   uint32 tw, uint16 spp, uint16 bps,
4312                                   FILE *dumpfile, int format, int level)
4313   {
4314   int    ready_bits = 0;
4315   uint32 src_rowsize, dst_rowsize;
4316   uint32 bit_offset, src_offset;
4317   uint32 row, col, src_byte = 0, src_bit = 0;
4318   uint16 maskbits = 0, matchbits = 0;
4319   uint16 buff1 = 0, buff2 = 0;
4320   uint8  bytebuff = 0;
4321   tsample_t s;
4322   unsigned char *src = in[0];
4323   unsigned char *dst = out;
4324   char           action[8];
4325
4326   if ((src == NULL) || (dst == NULL))
4327     {
4328     TIFFError("combineSeparateTileSamples16bits","Invalid input or output buffer");
4329     return (1);
4330     }
4331
4332   src_rowsize = ((bps * tw) + 7) / 8;
4333   dst_rowsize = ((imagewidth * bps * spp) + 7) / 8;
4334   maskbits = (uint16)-1 >> (16 - bps);
4335
4336   for (row = 0; row < rows; row++)
4337     {
4338     ready_bits = 0;
4339     buff1 = buff2 = 0;
4340     dst = out + (row * dst_rowsize);
4341     src_offset = row * src_rowsize;
4342     for (col = 0; col < cols; col++)
4343       {
4344       /* Compute src byte(s) and bits within byte(s) */
4345       bit_offset = col * bps;
4346       src_byte = bit_offset / 8;
4347       src_bit  = bit_offset % 8;
4348
4349       matchbits = maskbits << (16 - src_bit - bps);
4350       for (s = 0; s < spp; s++)
4351         {
4352         src = in[s] + src_offset + src_byte;
4353         if (little_endian)
4354           buff1 = (src[0] << 8) | src[1];
4355         else
4356           buff1 = (src[1] << 8) | src[0];
4357         buff1 = (buff1 & matchbits) << (src_bit);
4358
4359         /* If we have a full buffer's worth, write it out */
4360         if (ready_bits >= 8)
4361           {
4362             bytebuff = (buff2 >> 8);
4363             *dst++ = bytebuff;
4364             ready_bits -= 8;
4365             /* shift in new bits */
4366             buff2 = ((buff2 << 8) | (buff1 >> ready_bits));
4367             strcpy (action, "Flush");
4368           }
4369         else
4370           { /* add another bps bits to the buffer */
4371             bytebuff = 0;
4372             buff2 = (buff2 | (buff1 >> ready_bits));
4373             strcpy (action, "Update");
4374           }
4375         ready_bits += bps;
4376
4377         if ((dumpfile != NULL) && (level == 3))
4378           {
4379           dump_info (dumpfile, format, "",
4380                        "Row %3d, Col %3d, Samples %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4381                        row + 1, col + 1, s, src_byte, src_bit, dst - out);
4382
4383           dump_short (dumpfile, format, "Match bits", matchbits);
4384           dump_data  (dumpfile, format, "Src   bits", src, 2);
4385           dump_short (dumpfile, format, "Buff1 bits", buff1);
4386           dump_short (dumpfile, format, "Buff2 bits", buff2);
4387           dump_byte  (dumpfile, format, "Write byte", bytebuff);
4388           dump_info  (dumpfile, format, "","Ready bits:  %d, %s", ready_bits, action);
4389           }
4390         }
4391       }
4392
4393     /* catch any trailing bits at the end of the line */
4394     if (ready_bits > 0)
4395       {
4396       bytebuff = (buff2 >> 8);
4397       *dst++ = bytebuff;
4398       if ((dumpfile != NULL) && (level == 3))
4399         {
4400         dump_info (dumpfile, format, "",
4401                        "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4402                        row + 1, col + 1, src_byte, src_bit, dst - out);
4403         dump_byte (dumpfile, format, "Final bits", bytebuff);
4404         }
4405       }
4406
4407     if ((dumpfile != NULL) && (level == 2))
4408       {
4409       dump_info (dumpfile, format, "combineSeparateTileSamples16bits","Output data");
4410       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
4411       }
4412     }
4413
4414   return (0);
4415   } /* end combineSeparateTileSamples16bits */
4416
4417 static int
4418 combineSeparateTileSamples24bits (uint8 *in[], uint8 *out, uint32 cols,
4419                                   uint32 rows, uint32 imagewidth,
4420                                   uint32 tw, uint16 spp, uint16 bps,
4421                                   FILE *dumpfile, int format, int level)
4422   {
4423   int    ready_bits = 0;
4424   uint32 src_rowsize, dst_rowsize;
4425   uint32 bit_offset, src_offset;
4426   uint32 row, col, src_byte = 0, src_bit = 0;
4427   uint32 maskbits = 0, matchbits = 0;
4428   uint32 buff1 = 0, buff2 = 0;
4429   uint8  bytebuff1 = 0, bytebuff2 = 0;
4430   tsample_t s;
4431   unsigned char *src = in[0];
4432   unsigned char *dst = out;
4433   char           action[8];
4434
4435   if ((src == NULL) || (dst == NULL))
4436     {
4437     TIFFError("combineSeparateTileSamples24bits","Invalid input or output buffer");
4438     return (1);
4439     }
4440
4441   src_rowsize = ((bps * tw) + 7) / 8;
4442   dst_rowsize = ((imagewidth * bps * spp) + 7) / 8;
4443   maskbits =  (uint32)-1 >> ( 32 - bps);
4444
4445   for (row = 0; row < rows; row++)
4446     {
4447     ready_bits = 0;
4448     buff1 = buff2 = 0;
4449     dst = out + (row * dst_rowsize);
4450     src_offset = row * src_rowsize;
4451     for (col = 0; col < cols; col++)
4452       {
4453       /* Compute src byte(s) and bits within byte(s) */
4454       bit_offset = col * bps;
4455       src_byte = bit_offset / 8;
4456       src_bit  = bit_offset % 8;
4457
4458       matchbits = maskbits << (32 - src_bit - bps);
4459       for (s = 0; s < spp; s++)
4460         {
4461         src = in[s] + src_offset + src_byte;
4462         if (little_endian)
4463           buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
4464         else
4465           buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
4466         buff1 = (buff1 & matchbits) << (src_bit);
4467
4468         /* If we have a full buffer's worth, write it out */
4469         if (ready_bits >= 16)
4470           {
4471             bytebuff1 = (buff2 >> 24);
4472             *dst++ = bytebuff1;
4473             bytebuff2 = (buff2 >> 16);
4474             *dst++ = bytebuff2;
4475             ready_bits -= 16;
4476
4477             /* shift in new bits */
4478             buff2 = ((buff2 << 16) | (buff1 >> ready_bits));
4479             strcpy (action, "Flush");
4480           }
4481         else
4482           { /* add another bps bits to the buffer */
4483             bytebuff1 = bytebuff2 = 0;
4484             buff2 = (buff2 | (buff1 >> ready_bits));
4485             strcpy (action, "Update");
4486           }
4487         ready_bits += bps;
4488
4489         if ((dumpfile != NULL) && (level == 3))
4490           {
4491           dump_info (dumpfile, format, "",
4492                        "Row %3d, Col %3d, Samples %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4493                        row + 1, col + 1, s, src_byte, src_bit, dst - out);
4494           dump_long (dumpfile, format, "Match bits ", matchbits);
4495           dump_data (dumpfile, format, "Src   bits ", src, 4);
4496           dump_long (dumpfile, format, "Buff1 bits ", buff1);
4497           dump_long (dumpfile, format, "Buff2 bits ", buff2);
4498           dump_byte (dumpfile, format, "Write bits1", bytebuff1);
4499           dump_byte (dumpfile, format, "Write bits2", bytebuff2);
4500           dump_info (dumpfile, format, "","Ready bits:   %d, %s", ready_bits, action);
4501           }
4502         }
4503       }
4504
4505     /* catch any trailing bits at the end of the line */
4506     while (ready_bits > 0)
4507       {
4508         bytebuff1 = (buff2 >> 24);
4509         *dst++ = bytebuff1;
4510
4511         buff2 = (buff2 << 8);
4512         bytebuff2 = bytebuff1;
4513         ready_bits -= 8;
4514       }
4515
4516     if ((dumpfile != NULL) && (level == 3))
4517       {
4518       dump_info (dumpfile, format, "",
4519                    "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4520                    row + 1, col + 1, src_byte, src_bit, dst - out);
4521
4522       dump_long (dumpfile, format, "Match bits ", matchbits);
4523       dump_data (dumpfile, format, "Src   bits ", src, 4);
4524       dump_long (dumpfile, format, "Buff1 bits ", buff1);
4525       dump_long (dumpfile, format, "Buff2 bits ", buff2);
4526       dump_byte (dumpfile, format, "Write bits1", bytebuff1);
4527       dump_byte (dumpfile, format, "Write bits2", bytebuff2);
4528       dump_info (dumpfile, format, "", "Ready bits:  %2d", ready_bits);
4529       }
4530
4531     if ((dumpfile != NULL) && (level == 2))
4532       {
4533       dump_info (dumpfile, format, "combineSeparateTileSamples24bits","Output data");
4534       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize));
4535       }
4536     }
4537
4538   return (0);
4539   } /* end combineSeparateTileSamples24bits */
4540
4541 static int
4542 combineSeparateTileSamples32bits (uint8 *in[], uint8 *out, uint32 cols,
4543                                   uint32 rows, uint32 imagewidth,
4544                                   uint32 tw, uint16 spp, uint16 bps,
4545                                   FILE *dumpfile, int format, int level)
4546   {
4547   int    ready_bits = 0, shift_width = 0;
4548   uint32 src_rowsize, dst_rowsize, bit_offset, src_offset;
4549   uint32 src_byte = 0, src_bit = 0;
4550   uint32 row, col;
4551   uint32 longbuff1 = 0, longbuff2 = 0;
4552   uint64 maskbits = 0, matchbits = 0;
4553   uint64 buff1 = 0, buff2 = 0, buff3 = 0;
4554   uint8  bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0;
4555   tsample_t s;
4556   unsigned char *src = in[0];
4557   unsigned char *dst = out;
4558   char           action[8];
4559
4560   if ((src == NULL) || (dst == NULL))
4561     {
4562     TIFFError("combineSeparateTileSamples32bits","Invalid input or output buffer");
4563     return (1);
4564     }
4565
4566   src_rowsize = ((bps * tw) + 7) / 8;
4567   dst_rowsize = ((imagewidth * bps * spp) + 7) / 8;
4568   maskbits =  (uint64)-1 >> ( 64 - bps);
4569   shift_width = ((bps + 7) / 8) + 1;
4570
4571   for (row = 0; row < rows; row++)
4572     {
4573     ready_bits = 0;
4574     buff1 = buff2 = 0;
4575     dst = out + (row * dst_rowsize);
4576     src_offset = row * src_rowsize;
4577     for (col = 0; col < cols; col++)
4578       {
4579       /* Compute src byte(s) and bits within byte(s) */
4580       bit_offset = col * bps;
4581       src_byte = bit_offset / 8;
4582       src_bit  = bit_offset % 8;
4583
4584       matchbits = maskbits << (64 - src_bit - bps);
4585       for (s = 0; s < spp; s++)
4586         {
4587         src = in[s] + src_offset + src_byte;
4588         if (little_endian)
4589           {
4590           longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
4591           longbuff2 = longbuff1;
4592           }
4593         else
4594           {
4595           longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
4596           longbuff2 = longbuff1;
4597           }
4598
4599         buff3 = ((uint64)longbuff1 << 32) | longbuff2;
4600         buff1 = (buff3 & matchbits) << (src_bit);
4601
4602         /* If we have a full buffer's worth, write it out */
4603         if (ready_bits >= 32)
4604           {
4605           bytebuff1 = (buff2 >> 56);
4606           *dst++ = bytebuff1;
4607           bytebuff2 = (buff2 >> 48);
4608           *dst++ = bytebuff2;
4609           bytebuff3 = (buff2 >> 40);
4610           *dst++ = bytebuff3;
4611           bytebuff4 = (buff2 >> 32);
4612           *dst++ = bytebuff4;
4613           ready_bits -= 32;
4614
4615           /* shift in new bits */
4616           buff2 = ((buff2 << 32) | (buff1 >> ready_bits));
4617           strcpy (action, "Flush");
4618           }
4619         else
4620           { /* add another bps bits to the buffer */
4621           bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0;
4622           buff2 = (buff2 | (buff1 >> ready_bits));
4623           strcpy (action, "Update");
4624           }
4625         ready_bits += bps;
4626
4627         if ((dumpfile != NULL) && (level == 3))
4628           {
4629           dump_info (dumpfile, format, "",
4630                      "Row %3d, Col %3d, Sample %d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4631                      row + 1, col + 1, s, src_byte, src_bit, dst - out);
4632           dump_wide (dumpfile, format, "Match bits ", matchbits);
4633           dump_data (dumpfile, format, "Src   bits ", src, 8);
4634           dump_wide (dumpfile, format, "Buff1 bits ", buff1);
4635           dump_wide (dumpfile, format, "Buff2 bits ", buff2);
4636           dump_info (dumpfile, format, "", "Ready bits:   %d, %s", ready_bits, action);
4637           }
4638         }
4639       }
4640     while (ready_bits > 0)
4641       {
4642       bytebuff1 = (buff2 >> 56);
4643       *dst++ = bytebuff1;
4644       buff2 = (buff2 << 8);
4645       ready_bits -= 8;
4646       }
4647
4648     if ((dumpfile != NULL) && (level == 3))
4649       {
4650       dump_info (dumpfile, format, "",
4651                  "Row %3d, Col %3d, Src byte offset %3d  bit offset %2d  Dst offset %3d",
4652                  row + 1, col + 1, src_byte, src_bit, dst - out);
4653
4654       dump_long (dumpfile, format, "Match bits ", matchbits);
4655       dump_data (dumpfile, format, "Src   bits ", src, 4);
4656       dump_long (dumpfile, format, "Buff1 bits ", buff1);
4657       dump_long (dumpfile, format, "Buff2 bits ", buff2);
4658       dump_byte (dumpfile, format, "Write bits1", bytebuff1);
4659       dump_byte (dumpfile, format, "Write bits2", bytebuff2);
4660       dump_info (dumpfile, format, "", "Ready bits:  %2d", ready_bits);
4661       }
4662
4663     if ((dumpfile != NULL) && (level == 2))
4664       {
4665       dump_info (dumpfile, format, "combineSeparateTileSamples32bits","Output data");
4666       dump_buffer(dumpfile, format, 1, dst_rowsize, row, out);
4667       }
4668     }
4669
4670   return (0);
4671   } /* end combineSeparateTileSamples32bits */
4672
4673
4674 static int readSeparateStripsIntoBuffer (TIFF *in, uint8 *obuf, uint32 length,
4675                                          uint32 width, uint16 spp,
4676                                          struct dump_opts *dump)
4677   {
4678   int i, j, bytes_per_sample, bytes_per_pixel, shift_width, result = 1;
4679   int32  bytes_read = 0;
4680   uint16 bps, nstrips, planar, strips_per_sample;
4681   uint32 src_rowsize, dst_rowsize, rows_processed, rps;
4682   uint32 rows_this_strip = 0;
4683   tsample_t s;
4684   tstrip_t  strip;
4685   tsize_t scanlinesize = TIFFScanlineSize(in);
4686   tsize_t stripsize    = TIFFStripSize(in);
4687   unsigned char *srcbuffs[MAX_SAMPLES];
4688   unsigned char *buff = NULL;
4689   unsigned char *dst = NULL;
4690
4691   if (obuf == NULL)
4692     {
4693     TIFFError("readSeparateStripsIntoBuffer","Invalid buffer argument");
4694     return (0);
4695     }
4696
4697   memset (srcbuffs, '\0', sizeof(srcbuffs));
4698   TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bps);
4699   TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &planar);
4700   TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps);
4701   if (rps > length)
4702     rps = length;
4703
4704   bytes_per_sample = (bps + 7) / 8;
4705   bytes_per_pixel  = ((bps * spp) + 7) / 8;
4706   if (bytes_per_pixel < (bytes_per_sample + 1))
4707     shift_width = bytes_per_pixel;
4708   else
4709     shift_width = bytes_per_sample + 1;
4710
4711   src_rowsize = ((bps * width) + 7) / 8;
4712   dst_rowsize = ((bps * width * spp) + 7) / 8;
4713   dst = obuf;
4714
4715   if ((dump->infile != NULL) && (dump->level == 3))
4716     {
4717     dump_info  (dump->infile, dump->format, "",
4718                 "Image width %d, length %d, Scanline size, %4d bytes",
4719                 width, length,  scanlinesize);
4720     dump_info  (dump->infile, dump->format, "",
4721                 "Bits per sample %d, Samples per pixel %d, Shift width %d",
4722                 bps, spp, shift_width);
4723     }
4724
4725   /* Libtiff seems to assume/require that data for separate planes are
4726    * written one complete plane after another and not interleaved in any way.
4727    * Multiple scanlines and possibly strips of the same plane must be
4728    * written before data for any other plane.
4729    */
4730   nstrips = TIFFNumberOfStrips(in);
4731   strips_per_sample = nstrips /spp;
4732
4733   for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++)
4734     {
4735     srcbuffs[s] = NULL;
4736     buff = _TIFFmalloc(stripsize);
4737     if (!buff)
4738       {
4739       TIFFError ("readSeparateStripsIntoBuffer",
4740                  "Unable to allocate strip read buffer for sample %d", s);
4741       for (i = 0; i < s; i++)
4742         _TIFFfree (srcbuffs[i]);
4743       return 0;
4744       }
4745     srcbuffs[s] = buff;
4746     }
4747
4748   rows_processed = 0;
4749   for (j = 0; (j < strips_per_sample) && (result == 1); j++)
4750     {
4751     for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++)
4752       {
4753       buff = srcbuffs[s];
4754       strip = (s * strips_per_sample) + j;
4755       bytes_read = TIFFReadEncodedStrip (in, strip, buff, stripsize);
4756       rows_this_strip = bytes_read / src_rowsize;
4757       if (bytes_read < 0 && !ignore)
4758         {
4759         TIFFError(TIFFFileName(in),
4760                   "Error, can't read strip %lu for sample %d",
4761                    (unsigned long) strip, s + 1);
4762         result = 0;
4763         break;
4764         }
4765 #ifdef DEVELMODE
4766       TIFFError("", "Strip %2d, read %5d bytes for %4d scanlines, shift width %d",
4767                 strip, bytes_read, rows_this_strip, shift_width);
4768 #endif
4769       }
4770
4771     if (rps > rows_this_strip)
4772       rps = rows_this_strip;
4773     dst = obuf + (dst_rowsize * rows_processed);
4774     if ((bps % 8) == 0)
4775       {
4776       if (combineSeparateSamplesBytes (srcbuffs, dst, width, rps,
4777                                        spp, bps, dump->infile,
4778                                        dump->format, dump->level))
4779         {
4780         result = 0;
4781         break;
4782         }
4783       }
4784     else
4785       {
4786       switch (shift_width)
4787         {
4788         case 1: if (combineSeparateSamples8bits (srcbuffs, dst, width, rps,
4789                                                  spp, bps, dump->infile,
4790                                                  dump->format, dump->level))
4791                   {
4792                   result = 0;
4793                   break;
4794                   }
4795                 break;
4796         case 2: if (combineSeparateSamples16bits (srcbuffs, dst, width, rps,
4797                                                   spp, bps, dump->infile,
4798                                                   dump->format, dump->level))
4799                   {
4800                   result = 0;
4801                   break;
4802                   }
4803                 break;
4804         case 3: if (combineSeparateSamples24bits (srcbuffs, dst, width, rps,
4805                                                   spp, bps, dump->infile,
4806                                                   dump->format, dump->level))
4807                   {
4808                   result = 0;
4809                   break;
4810                   }
4811                 break;
4812         case 4:
4813         case 5:
4814         case 6:
4815         case 7:
4816         case 8: if (combineSeparateSamples32bits (srcbuffs, dst, width, rps,
4817                                                   spp, bps, dump->infile,
4818                                                   dump->format, dump->level))
4819                   {
4820                   result = 0;
4821                   break;
4822                   }
4823                 break;
4824         default: TIFFError ("readSeparateStripsIntoBuffer", "Unsupported bit depth: %d", bps);
4825                   result = 0;
4826                   break;
4827         }
4828       }
4829
4830     if ((rows_processed + rps) > length)
4831       {
4832       rows_processed = length;
4833       rps = length - rows_processed;
4834       }
4835     else
4836       rows_processed += rps;
4837     }
4838
4839   /* free any buffers allocated for each plane or scanline and
4840    * any temporary buffers
4841    */
4842   for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++)
4843     {
4844     buff = srcbuffs[s];
4845     if (buff != NULL)
4846       _TIFFfree(buff);
4847     }
4848
4849   return (result);
4850   } /* end readSeparateStripsIntoBuffer */
4851
4852 static int
4853 get_page_geometry (char *name, struct pagedef *page)
4854     {
4855     char *ptr;
4856     int n;
4857
4858     for (ptr = name; *ptr; ptr++)
4859       *ptr = (char)tolower((int)*ptr);
4860
4861     for (n = 0; n < MAX_PAPERNAMES; n++)
4862       {
4863       if (strcmp(name, PaperTable[n].name) == 0)
4864         {
4865         page->width = PaperTable[n].width;
4866         page->length = PaperTable[n].length;
4867         strncpy (page->name, PaperTable[n].name, 15);
4868         page->name[15] = '\0';
4869         return (0);
4870         }
4871       }
4872
4873   return (1);
4874   }
4875
4876
4877 static void
4878 initPageSetup (struct pagedef *page, struct pageseg *pagelist,
4879                struct buffinfo seg_buffs[])
4880    {
4881    int i;
4882
4883    strcpy (page->name, "");
4884    page->mode = PAGE_MODE_NONE;
4885    page->res_unit = RESUNIT_NONE;
4886    page->hres = 0.0;
4887    page->vres = 0.0;
4888    page->width = 0.0;
4889    page->length = 0.0;
4890    page->hmargin = 0.0;
4891    page->vmargin = 0.0;
4892    page->rows = 0;
4893    page->cols = 0;
4894    page->orient = ORIENTATION_NONE;
4895
4896    for (i = 0; i < MAX_SECTIONS; i++)
4897      {
4898      pagelist[i].x1 = (uint32)0;
4899      pagelist[i].x2 = (uint32)0;
4900      pagelist[i].y1 = (uint32)0;
4901      pagelist[i].y2 = (uint32)0;
4902      pagelist[i].buffsize = (uint32)0;
4903      pagelist[i].position = 0;
4904      pagelist[i].total = 0;
4905      }
4906
4907    for (i = 0; i < MAX_OUTBUFFS; i++)
4908      {
4909      seg_buffs[i].size = 0;
4910      seg_buffs[i].buffer = NULL;
4911      }
4912    }
4913
4914 static void
4915 initImageData (struct image_data *image)
4916   {
4917   image->xres = 0.0;
4918   image->yres = 0.0;
4919   image->width = 0;
4920   image->length = 0;
4921   image->res_unit = RESUNIT_NONE;
4922   image->bps = 0;
4923   image->spp = 0;
4924   image->planar = 0;
4925   image->photometric = 0;
4926   image->orientation = 0;
4927   image->compression = COMPRESSION_NONE;
4928   image->adjustments = 0;
4929   }
4930
4931 static void
4932 initCropMasks (struct crop_mask *cps)
4933    {
4934    int i;
4935
4936    cps->crop_mode = CROP_NONE;
4937    cps->res_unit  = RESUNIT_NONE;
4938    cps->edge_ref  = EDGE_TOP;
4939    cps->width = 0;
4940    cps->length = 0;
4941    for (i = 0; i < 4; i++)
4942      cps->margins[i] = 0.0;
4943    cps->bufftotal = (uint32)0;
4944    cps->combined_width = (uint32)0;
4945    cps->combined_length = (uint32)0;
4946    cps->rotation = (uint16)0;
4947    cps->photometric = INVERT_DATA_AND_TAG;
4948    cps->mirror   = (uint16)0;
4949    cps->invert   = (uint16)0;
4950    cps->zones    = (uint32)0;
4951    cps->regions  = (uint32)0;
4952    for (i = 0; i < MAX_REGIONS; i++)
4953      {
4954      cps->corners[i].X1 = 0.0;
4955      cps->corners[i].X2 = 0.0;
4956      cps->corners[i].Y1 = 0.0;
4957      cps->corners[i].Y2 = 0.0;
4958      cps->regionlist[i].x1 = 0;
4959      cps->regionlist[i].x2 = 0;
4960      cps->regionlist[i].y1 = 0;
4961      cps->regionlist[i].y2 = 0;
4962      cps->regionlist[i].width = 0;
4963      cps->regionlist[i].length = 0;
4964      cps->regionlist[i].buffsize = 0;
4965      cps->regionlist[i].buffptr = NULL;
4966      cps->zonelist[i].position = 0;
4967      cps->zonelist[i].total = 0;
4968      }
4969    cps->exp_mode = ONE_FILE_COMPOSITE;
4970    cps->img_mode = COMPOSITE_IMAGES;
4971    }
4972
4973 static void initDumpOptions(struct dump_opts *dump)
4974   {
4975   dump->debug  = 0;
4976   dump->format = DUMP_NONE;
4977   dump->level  = 1;
4978   sprintf (dump->mode, "w");
4979   memset (dump->infilename, '\0', PATH_MAX + 1);
4980   memset (dump->outfilename, '\0',PATH_MAX + 1);
4981   dump->infile = NULL;
4982   dump->outfile = NULL;
4983   }
4984
4985 /* Compute pixel offsets into the image for margins and fixed regions */
4986 static int
4987 computeInputPixelOffsets(struct crop_mask *crop, struct image_data *image,
4988                          struct offset *off)
4989   {
4990   double scale;
4991   float xres, yres;
4992   /* Values for these offsets are in pixels from start of image, not bytes,
4993    * and are indexed from zero to width - 1 or length - 1 */
4994   uint32 tmargin, bmargin, lmargin, rmargin;
4995   uint32 startx, endx;   /* offsets of first and last columns to extract */
4996   uint32 starty, endy;   /* offsets of first and last row to extract */
4997   uint32 width, length, crop_width, crop_length;
4998   uint32 i, max_width, max_length, zwidth, zlength, buffsize;
4999   uint32 x1, x2, y1, y2;
5000
5001   if (image->res_unit != RESUNIT_INCH && image->res_unit != RESUNIT_CENTIMETER)
5002     {
5003     xres = 1.0;
5004     yres = 1.0;
5005     }
5006   else
5007     {
5008     if (((image->xres == 0) || (image->yres == 0)) &&
5009          (crop->res_unit != RESUNIT_NONE) &&
5010         ((crop->crop_mode & CROP_REGIONS) || (crop->crop_mode & CROP_MARGINS) ||
5011          (crop->crop_mode & CROP_LENGTH)  || (crop->crop_mode & CROP_WIDTH)))
5012       {
5013       TIFFError("computeInputPixelOffsets", "Cannot compute margins or fixed size sections without image resolution");
5014       TIFFError("computeInputPixelOffsets", "Specify units in pixels and try again");
5015       return (-1);
5016       }
5017     xres = image->xres;
5018     yres = image->yres;
5019     }
5020
5021   /* Translate user units to image units */
5022   scale = 1.0;
5023   switch (crop->res_unit) {
5024     case RESUNIT_CENTIMETER:
5025          if (image->res_unit == RESUNIT_INCH)
5026            scale = 1.0/2.54;
5027          break;
5028     case RESUNIT_INCH:
5029          if (image->res_unit == RESUNIT_CENTIMETER)
5030              scale = 2.54;
5031          break;
5032     case RESUNIT_NONE: /* Dimensions in pixels */
5033     default:
5034     break;
5035     }
5036
5037   if (crop->crop_mode & CROP_REGIONS)
5038     {
5039     max_width = max_length = 0;
5040     for (i = 0; i < crop->regions; i++)
5041       {
5042       if ((crop->res_unit == RESUNIT_INCH) || (crop->res_unit == RESUNIT_CENTIMETER))
5043         {
5044         x1 = (uint32) (crop->corners[i].X1 * scale * xres);
5045         x2 = (uint32) (crop->corners[i].X2 * scale * xres);
5046         y1 = (uint32) (crop->corners[i].Y1 * scale * yres);
5047         y2 = (uint32) (crop->corners[i].Y2 * scale * yres);
5048         }
5049       else
5050         {
5051         x1 = (uint32) (crop->corners[i].X1);
5052         x2 = (uint32) (crop->corners[i].X2);
5053         y1 = (uint32) (crop->corners[i].Y1);
5054         y2 = (uint32) (crop->corners[i].Y2);
5055         }
5056       if (x1 < 1)
5057         crop->regionlist[i].x1 = 0;
5058       else
5059         crop->regionlist[i].x1 = (uint32) (x1 - 1);
5060
5061       if (x2 > image->width - 1)
5062         crop->regionlist[i].x2 = image->width - 1;
5063       else
5064         crop->regionlist[i].x2 = (uint32) (x2 - 1);
5065       zwidth  = crop->regionlist[i].x2 - crop->regionlist[i].x1 + 1;
5066
5067       if (y1 < 1)
5068         crop->regionlist[i].y1 = 0;
5069       else
5070         crop->regionlist[i].y1 = (uint32) (y1 - 1);
5071
5072       if (y2 > image->length - 1)
5073         crop->regionlist[i].y2 = image->length - 1;
5074       else
5075         crop->regionlist[i].y2 = (uint32) (y2 - 1);
5076
5077       zlength = crop->regionlist[i].y2 - crop->regionlist[i].y1 + 1;
5078
5079       if (zwidth > max_width)
5080         max_width = zwidth;
5081       if (zlength > max_length)
5082         max_length = zlength;
5083
5084       buffsize = (uint32)
5085           (((zwidth * image->bps * image->spp + 7 ) / 8) * (zlength + 1));
5086
5087       crop->regionlist[i].buffsize = buffsize;
5088       crop->bufftotal += buffsize;
5089       if (crop->img_mode == COMPOSITE_IMAGES)
5090         {
5091         switch (crop->edge_ref)
5092           {
5093           case EDGE_LEFT:
5094           case EDGE_RIGHT:
5095                crop->combined_length = zlength;
5096                crop->combined_width += zwidth;
5097                break;
5098           case EDGE_BOTTOM:
5099           case EDGE_TOP:  /* width from left, length from top */
5100           default:
5101                crop->combined_width = zwidth;
5102                crop->combined_length += zlength;
5103                break;
5104           }
5105         }
5106       }
5107     return (0);
5108     }
5109
5110   /* Convert crop margins into offsets into image
5111    * Margins are expressed as pixel rows and columns, not bytes
5112    */
5113   if (crop->crop_mode & CROP_MARGINS)
5114     {
5115     if (crop->res_unit != RESUNIT_INCH && crop->res_unit != RESUNIT_CENTIMETER)
5116       { /* User has specified pixels as reference unit */
5117       tmargin = (uint32)(crop->margins[0]);
5118       lmargin = (uint32)(crop->margins[1]);
5119       bmargin = (uint32)(crop->margins[2]);
5120       rmargin = (uint32)(crop->margins[3]);
5121       }
5122     else
5123       { /* inches or centimeters specified */
5124       tmargin = (uint32)(crop->margins[0] * scale * yres);
5125       lmargin = (uint32)(crop->margins[1] * scale * xres);
5126       bmargin = (uint32)(crop->margins[2] * scale * yres);
5127       rmargin = (uint32)(crop->margins[3] * scale * xres);
5128       }
5129
5130     if ((lmargin + rmargin) > image->width)
5131       {
5132       TIFFError("computeInputPixelOffsets", "Combined left and right margins exceed image width");
5133       lmargin = (uint32) 0;
5134       rmargin = (uint32) 0;
5135       return (-1);
5136       }
5137     if ((tmargin + bmargin) > image->length)
5138       {
5139       TIFFError("computeInputPixelOffsets", "Combined top and bottom margins exceed image length");
5140       tmargin = (uint32) 0;
5141       bmargin = (uint32) 0;
5142       return (-1);
5143       }
5144     }
5145   else
5146     { /* no margins requested */
5147     tmargin = (uint32) 0;
5148     lmargin = (uint32) 0;
5149     bmargin = (uint32) 0;
5150     rmargin = (uint32) 0;
5151     }
5152
5153   /* Width, height, and margins are expressed as pixel offsets into image */
5154   if (crop->res_unit != RESUNIT_INCH && crop->res_unit != RESUNIT_CENTIMETER)
5155     {
5156     if (crop->crop_mode & CROP_WIDTH)
5157       width = (uint32)crop->width;
5158     else
5159       width = image->width - lmargin - rmargin;
5160
5161     if (crop->crop_mode & CROP_LENGTH)
5162       length  = (uint32)crop->length;
5163     else
5164       length = image->length - tmargin - bmargin;
5165     }
5166   else
5167     {
5168     if (crop->crop_mode & CROP_WIDTH)
5169       width = (uint32)(crop->width * scale * image->xres);
5170     else
5171       width = image->width - lmargin - rmargin;
5172
5173     if (crop->crop_mode & CROP_LENGTH)
5174       length  = (uint32)(crop->length * scale * image->yres);
5175     else
5176       length = image->length - tmargin - bmargin;
5177     }
5178
5179   off->tmargin = tmargin;
5180   off->bmargin = bmargin;
5181   off->lmargin = lmargin;
5182   off->rmargin = rmargin;
5183
5184   /* Calculate regions defined by margins, width, and length.
5185    * Coordinates expressed as 0 to imagewidth - 1, imagelength - 1,
5186    * since they are used to compute offsets into buffers */
5187   switch (crop->edge_ref) {
5188     case EDGE_BOTTOM:
5189          startx = lmargin;
5190          if ((startx + width) >= (image->width - rmargin))
5191            endx = image->width - rmargin - 1;
5192          else
5193            endx = startx + width - 1;
5194
5195          endy = image->length - bmargin - 1;
5196          if ((endy - length) <= tmargin)
5197            starty = tmargin;
5198          else
5199            starty = endy - length + 1;
5200          break;
5201     case EDGE_RIGHT:
5202          endx = image->width - rmargin - 1;
5203          if ((endx - width) <= lmargin)
5204            startx = lmargin;
5205          else
5206            startx = endx - width + 1;
5207
5208          starty = tmargin;
5209          if ((starty + length) >= (image->length - bmargin))
5210            endy = image->length - bmargin - 1;
5211          else
5212            endy = starty + length - 1;
5213          break;
5214     case EDGE_TOP:  /* width from left, length from top */
5215     case EDGE_LEFT:
5216     default:
5217          startx = lmargin;
5218          if ((startx + width) >= (image->width - rmargin))
5219            endx = image->width - rmargin - 1;
5220          else
5221            endx = startx + width - 1;
5222
5223          starty = tmargin;
5224          if ((starty + length) >= (image->length - bmargin))
5225            endy = image->length - bmargin - 1;
5226          else
5227            endy = starty + length - 1;
5228          break;
5229     }
5230   off->startx = startx;
5231   off->starty = starty;
5232   off->endx   = endx;
5233   off->endy   = endy;
5234
5235   crop_width  = endx - startx + 1;
5236   crop_length = endy - starty + 1;
5237
5238   if (crop_width <= 0)
5239     {
5240     TIFFError("computeInputPixelOffsets",
5241                "Invalid left/right margins and /or image crop width requested");
5242     return (-1);
5243     }
5244   if (crop_width > image->width)
5245     crop_width = image->width;
5246
5247   if (crop_length <= 0)
5248     {
5249     TIFFError("computeInputPixelOffsets",
5250               "Invalid top/bottom margins and /or image crop length requested");
5251     return (-1);
5252     }
5253   if (crop_length > image->length)
5254     crop_length = image->length;
5255
5256   off->crop_width = crop_width;
5257   off->crop_length = crop_length;
5258
5259   return (0);
5260   } /* end computeInputPixelOffsets */
5261
5262 /*
5263  * Translate crop options into pixel offsets for one or more regions of the image.
5264  * Options are applied in this order: margins, specific width and length, zones,
5265  * but all are optional. Margins are relative to each edge. Width, length and
5266  * zones are relative to the specified reference edge. Zones are expressed as
5267  * X:Y where X is the ordinal value in a set of Y equal sized portions. eg.
5268  * 2:3 would indicate the middle third of the region qualified by margins and
5269  * any explicit width and length specified. Regions are specified by coordinates
5270  * of the top left and lower right corners with range 1 to width or height.
5271  */
5272
5273 static int
5274 getCropOffsets(struct image_data *image, struct crop_mask *crop, struct dump_opts *dump)
5275   {
5276   struct offset offsets;
5277   int    i;
5278   int32  test;
5279   uint32 seg, total, need_buff = 0;
5280   uint32 buffsize;
5281   uint32 zwidth, zlength;
5282
5283   memset(&offsets, '\0', sizeof(struct offset));
5284   crop->bufftotal = 0;
5285   crop->combined_width  = (uint32)0;
5286   crop->combined_length = (uint32)0;
5287   crop->selections = 0;
5288
5289   /* Compute pixel offsets if margins or fixed width or length specified */
5290   if ((crop->crop_mode & CROP_MARGINS) ||
5291       (crop->crop_mode & CROP_REGIONS) ||
5292       (crop->crop_mode & CROP_LENGTH)  ||
5293       (crop->crop_mode & CROP_WIDTH))
5294     {
5295     if (computeInputPixelOffsets(crop, image, &offsets))
5296       {
5297       TIFFError ("getCropOffsets", "Unable to compute crop margins");
5298       return (-1);
5299       }
5300     need_buff = TRUE;
5301     crop->selections = crop->regions;
5302     /* Regions are only calculated from top and left edges with no margins */
5303     if (crop->crop_mode & CROP_REGIONS)
5304       return (0);
5305     }
5306   else
5307     { /* cropped area is the full image */
5308     offsets.tmargin = 0;
5309     offsets.lmargin = 0;
5310     offsets.bmargin = 0;
5311     offsets.rmargin = 0;
5312     offsets.crop_width = image->width;
5313     offsets.crop_length = image->length;
5314     offsets.startx = 0;
5315     offsets.endx = image->width - 1;
5316     offsets.starty = 0;
5317     offsets.endy = image->length - 1;
5318     need_buff = FALSE;
5319     }
5320
5321   if (dump->outfile != NULL)
5322     {
5323     dump_info (dump->outfile, dump->format, "", "Margins: Top: %d  Left: %d  Bottom: %d  Right: %d",
5324            offsets.tmargin, offsets.lmargin, offsets.bmargin, offsets.rmargin);
5325     dump_info (dump->outfile, dump->format, "", "Crop region within margins: Adjusted Width:  %6d  Length: %6d",
5326            offsets.crop_width, offsets.crop_length);
5327     }
5328
5329   if (!(crop->crop_mode & CROP_ZONES)) /* no crop zones requested */
5330     {
5331     if (need_buff == FALSE)  /* No margins or fixed width or length areas */
5332       {
5333       crop->selections = 0;
5334       crop->combined_width  = image->width;
5335       crop->combined_length = image->length;
5336       return (0);
5337       }
5338     else
5339       {
5340       /* Use one region for margins and fixed width or length areas
5341        * even though it was not formally declared as a region.
5342        */
5343       crop->selections = 1;
5344       crop->zones = 1;
5345       crop->zonelist[0].total = 1;
5346       crop->zonelist[0].position = 1;
5347       }
5348     }
5349   else
5350     crop->selections = crop->zones;
5351
5352   for (i = 0; i < crop->zones; i++)
5353     {
5354     seg = crop->zonelist[i].position;
5355     total = crop->zonelist[i].total;
5356
5357     switch (crop->edge_ref)
5358       {
5359       case EDGE_LEFT: /* zones from left to right, length from top */
5360            zlength = offsets.crop_length;
5361            crop->regionlist[i].y1 = offsets.starty;
5362            crop->regionlist[i].y2 = offsets.endy;
5363
5364            crop->regionlist[i].x1 = offsets.startx +
5365                                   (uint32)(offsets.crop_width * 1.0 * (seg - 1) / total);
5366            test = (int32)offsets.startx +
5367                   (int32)(offsets.crop_width * 1.0 * seg / total);
5368            if (test < 1 )
5369              crop->regionlist[i].x2 = 0;
5370            else
5371              {
5372              if (test > (int32)(image->width - 1))
5373                crop->regionlist[i].x2 = image->width - 1;
5374              else
5375                crop->regionlist[i].x2 = test - 1;
5376              }
5377            zwidth = crop->regionlist[i].x2 - crop->regionlist[i].x1  + 1;
5378
5379            /* This is passed to extractCropZone or extractCompositeZones */
5380            crop->combined_length = (uint32)zlength;
5381            if (crop->exp_mode == COMPOSITE_IMAGES)
5382              crop->combined_width += (uint32)zwidth;
5383            else
5384              crop->combined_width = (uint32)zwidth;
5385            break;
5386       case EDGE_BOTTOM: /* width from left, zones from bottom to top */
5387            zwidth = offsets.crop_width;
5388            crop->regionlist[i].x1 = offsets.startx;
5389            crop->regionlist[i].x2 = offsets.endx;
5390
5391            test = offsets.endy - (uint32)(offsets.crop_length * 1.0 * seg / total);
5392            if (test < 1 )
5393              crop->regionlist[i].y1 = 0;
5394            else
5395              crop->regionlist[i].y1 = test + 1;
5396
5397            test = offsets.endy - (offsets.crop_length * 1.0 * (seg - 1) / total);
5398            if (test < 1 )
5399              crop->regionlist[i].y2 = 0;
5400            else
5401              {
5402              if (test > (int32)(image->length - 1))
5403                crop->regionlist[i].y2 = image->length - 1;
5404              else
5405                crop->regionlist[i].y2 = test;
5406              }
5407            zlength = crop->regionlist[i].y2 - crop->regionlist[i].y1 + 1;
5408
5409            /* This is passed to extractCropZone or extractCompositeZones */
5410            if (crop->exp_mode == COMPOSITE_IMAGES)
5411              crop->combined_length += (uint32)zlength;
5412            else
5413              crop->combined_length = (uint32)zlength;
5414            crop->combined_width = (uint32)zwidth;
5415            break;
5416       case EDGE_RIGHT: /* zones from right to left, length from top */
5417            zlength = offsets.crop_length;
5418            crop->regionlist[i].y1 = offsets.starty;
5419            crop->regionlist[i].y2 = offsets.endy;
5420
5421            crop->regionlist[i].x1 = offsets.startx +
5422                                   (uint32)(offsets.crop_width  * (total - seg) * 1.0 / total);
5423            test = offsets.startx +
5424                   (offsets.crop_width * (total - seg + 1) * 1.0 / total);
5425            if (test < 1 )
5426              crop->regionlist[i].x2 = 0;
5427            else
5428              {
5429              if (test > (int32)(image->width - 1))
5430                crop->regionlist[i].x2 = image->width - 1;
5431              else
5432                crop->regionlist[i].x2 = test - 1;
5433              }
5434            zwidth = crop->regionlist[i].x2 - crop->regionlist[i].x1  + 1;
5435
5436            /* This is passed to extractCropZone or extractCompositeZones */
5437            crop->combined_length = (uint32)zlength;
5438            if (crop->exp_mode == COMPOSITE_IMAGES)
5439              crop->combined_width += (uint32)zwidth;
5440            else
5441              crop->combined_width = (uint32)zwidth;
5442            break;
5443       case EDGE_TOP: /* width from left, zones from top to bottom */
5444       default:
5445            zwidth = offsets.crop_width;
5446            crop->regionlist[i].x1 = offsets.startx;
5447            crop->regionlist[i].x2 = offsets.endx;
5448
5449            crop->regionlist[i].y1 = offsets.starty + (uint32)(offsets.crop_length * 1.0 * (seg - 1) / total);
5450            test = offsets.starty + (uint32)(offsets.crop_length * 1.0 * seg / total);
5451            if (test < 1 )
5452              crop->regionlist[i].y2 = 0;
5453            else
5454              {
5455              if (test > (int32)(image->length - 1))
5456                crop->regionlist[i].y2 = image->length - 1;
5457              else
5458                crop->regionlist[i].y2 = test - 1;
5459              }
5460            zlength = crop->regionlist[i].y2 - crop->regionlist[i].y1 + 1;
5461
5462            /* This is passed to extractCropZone or extractCompositeZones */
5463            if (crop->exp_mode == COMPOSITE_IMAGES)
5464              crop->combined_length += (uint32)zlength;
5465            else
5466              crop->combined_length = (uint32)zlength;
5467            crop->combined_width = (uint32)zwidth;
5468            break;
5469       } /* end switch statement */
5470
5471     buffsize = (uint32)
5472           ((((zwidth * image->bps * image->spp) + 7 ) / 8) * (zlength + 1));
5473     crop->regionlist[i].width = (uint32) zwidth;
5474     crop->regionlist[i].length = (uint32) zlength;
5475     crop->regionlist[i].buffsize = buffsize;
5476     crop->bufftotal += buffsize;
5477
5478
5479   if (dump->outfile != NULL)
5480     dump_info (dump->outfile, dump->format, "",  "Zone %d, width: %4d, length: %4d, x1: %4d  x2: %4d  y1: %4d  y2: %4d",
5481                     i + 1, (uint32)zwidth, (uint32)zlength,
5482                     crop->regionlist[i].x1, crop->regionlist[i].x2,
5483                     crop->regionlist[i].y1, crop->regionlist[i].y2);
5484     }
5485
5486   return (0);
5487   } /* end getCropOffsets */
5488
5489
5490 static int
5491 computeOutputPixelOffsets (struct crop_mask *crop, struct image_data *image,
5492                            struct pagedef *page, struct pageseg *sections,
5493                            struct dump_opts* dump)
5494   {
5495   double scale;
5496   double pwidth, plength;          /* Output page width and length in user units*/
5497   uint32 iwidth, ilength;          /* Input image width and length in pixels*/
5498   uint32 owidth, olength;          /* Output image width and length in pixels*/
5499   uint32 orows, ocols;             /* rows and cols for output */
5500   uint32 hmargin, vmargin;         /* Horizontal and vertical margins */
5501   uint32 x1, x2, y1, y2, line_bytes;
5502   unsigned int orientation;
5503   uint32 i, j, k;
5504
5505   scale = 1.0;
5506   if (page->res_unit == RESUNIT_NONE)
5507     page->res_unit = image->res_unit;
5508
5509   switch (image->res_unit) {
5510     case RESUNIT_CENTIMETER:
5511          if (page->res_unit == RESUNIT_INCH)
5512            scale = 1.0/2.54;
5513          break;
5514     case RESUNIT_INCH:
5515          if (page->res_unit == RESUNIT_CENTIMETER)
5516              scale = 2.54;
5517          break;
5518     case RESUNIT_NONE: /* Dimensions in pixels */
5519     default:
5520     break;
5521     }
5522
5523   /* get width, height, resolutions of input image selection */
5524   if (crop->combined_width > 0)
5525     iwidth = crop->combined_width;
5526   else
5527     iwidth = image->width;
5528   if (crop->combined_length > 0)
5529     ilength = crop->combined_length;
5530   else
5531     ilength = image->length;
5532
5533   if (page->hres <= 1.0)
5534     page->hres = image->xres;
5535   if (page->vres <= 1.0)
5536     page->vres = image->yres;
5537
5538   if ((page->hres < 1.0) || (page->vres < 1.0))
5539     {
5540     TIFFError("computeOutputPixelOffsets",
5541     "Invalid horizontal or vertical resolution specified or read from input image");
5542     return (1);
5543     }
5544
5545   /* If no page sizes are being specified, we just use the input image size to
5546    * calculate maximum margins that can be taken from image.
5547    */
5548   if (page->width <= 0)
5549     pwidth = iwidth;
5550   else
5551     pwidth = page->width;
5552
5553   if (page->length <= 0)
5554     plength = ilength;
5555   else
5556     plength = page->length;
5557
5558   if (dump->debug)
5559     {
5560     TIFFError("", "Page size: %s, Vres: %3.2f, Hres: %3.2f, "
5561                    "Hmargin: %3.2f, Vmargin: %3.2f",
5562              page->name, page->vres, page->hres,
5563              page->hmargin, page->vmargin);
5564     TIFFError("", "Res_unit: %d, Scale: %3.2f, Page width: %3.2f, length: %3.2f",
5565            page->res_unit, scale, pwidth, plength);
5566     }
5567
5568   /* compute margins at specified unit and resolution */
5569   if (page->mode & PAGE_MODE_MARGINS)
5570     {
5571     if (page->res_unit == RESUNIT_INCH || page->res_unit == RESUNIT_CENTIMETER)
5572       { /* inches or centimeters specified */
5573       hmargin = (uint32)(page->hmargin * scale * page->hres * ((image->bps + 7)/ 8));
5574       vmargin = (uint32)(page->vmargin * scale * page->vres * ((image->bps + 7)/ 8));
5575       }
5576     else
5577       { /* Otherwise user has specified pixels as reference unit */
5578       hmargin = (uint32)(page->hmargin * scale * ((image->bps + 7)/ 8));
5579       vmargin = (uint32)(page->vmargin * scale * ((image->bps + 7)/ 8));
5580       }
5581
5582     if ((hmargin * 2.0) > (pwidth * page->hres))
5583       {
5584       TIFFError("computeOutputPixelOffsets",
5585                 "Combined left and right margins exceed page width");
5586       hmargin = (uint32) 0;
5587       return (-1);
5588       }
5589     if ((vmargin * 2.0) > (plength * page->vres))
5590       {
5591       TIFFError("computeOutputPixelOffsets",
5592                 "Combined top and bottom margins exceed page length");
5593       vmargin = (uint32) 0;
5594       return (-1);
5595       }
5596     }
5597   else
5598     {
5599     hmargin = 0;
5600     vmargin = 0;
5601     }
5602
5603   if (page->mode & PAGE_MODE_ROWSCOLS )
5604     {
5605     /* Maybe someday but not for now */
5606     if (page->mode & PAGE_MODE_MARGINS)
5607       TIFFError("computeOutputPixelOffsets",
5608       "Output margins cannot be specified with rows and columns");
5609
5610     owidth  = TIFFhowmany(iwidth, page->cols);
5611     olength = TIFFhowmany(ilength, page->rows);
5612     }
5613   else
5614     {
5615     if (page->mode & PAGE_MODE_PAPERSIZE )
5616       {
5617       owidth  = (uint32)((pwidth * page->hres) - (hmargin * 2));
5618       olength = (uint32)((plength * page->vres) - (vmargin * 2));
5619       }
5620     else
5621       {
5622       owidth = (uint32)(iwidth - (hmargin * 2 * page->hres));
5623       olength = (uint32)(ilength - (vmargin * 2 * page->vres));
5624       }
5625     }
5626
5627   if (owidth > iwidth)
5628     owidth = iwidth;
5629   if (olength > ilength)
5630     olength = ilength;
5631
5632   /* Compute the number of pages required for Portrait or Landscape */
5633   switch (page->orient)
5634     {
5635     case ORIENTATION_NONE:
5636     case ORIENTATION_PORTRAIT:
5637          ocols = TIFFhowmany(iwidth, owidth);
5638          orows = TIFFhowmany(ilength, olength);
5639          orientation = ORIENTATION_PORTRAIT;
5640          break;
5641
5642     case ORIENTATION_LANDSCAPE:
5643          ocols = TIFFhowmany(iwidth, olength);
5644          orows = TIFFhowmany(ilength, owidth);
5645          x1 = olength;
5646          olength = owidth;
5647          owidth = x1;
5648          orientation = ORIENTATION_LANDSCAPE;
5649          break;
5650
5651     case ORIENTATION_AUTO:
5652     default:
5653          x1 = TIFFhowmany(iwidth, owidth);
5654          x2 = TIFFhowmany(ilength, olength);
5655          y1 = TIFFhowmany(iwidth, olength);
5656          y2 = TIFFhowmany(ilength, owidth);
5657
5658          if ( (x1 * x2) < (y1 * y2))
5659            { /* Portrait */
5660            ocols = x1;
5661            orows = x2;
5662            orientation = ORIENTATION_PORTRAIT;
5663            }
5664          else
5665            { /* Landscape */
5666            ocols = y1;
5667            orows = y2;
5668            x1 = olength;
5669            olength = owidth;
5670            owidth = x1;
5671            orientation = ORIENTATION_LANDSCAPE;
5672            }
5673     }
5674
5675   if (ocols < 1)
5676     ocols = 1;
5677   if (orows < 1)
5678     orows = 1;
5679
5680   /* If user did not specify rows and cols, set them from calcuation */
5681   if (page->rows < 1)
5682     page->rows = orows;
5683   if (page->cols < 1)
5684     page->cols = ocols;
5685
5686   line_bytes = TIFFhowmany8(owidth * image->bps) * image->spp;
5687
5688   if ((page->rows * page->cols) > MAX_SECTIONS)
5689    {
5690    TIFFError("computeOutputPixelOffsets",
5691              "Rows and Columns exceed maximum sections\nIncrease resolution or reduce sections");
5692    return (-1);
5693    }
5694
5695   /* build the list of offsets for each output section */
5696   for (k = 0, i = 0 && k <= MAX_SECTIONS; i < orows; i++)
5697     {
5698     y1 = (uint32)(olength * i);
5699     y2 = (uint32)(olength * (i +  1) - 1);
5700     if (y2 >= ilength)
5701       y2 = ilength - 1;
5702     for (j = 0; j < ocols; j++, k++)
5703       {
5704       x1 = (uint32)(owidth * j);
5705       x2 = (uint32)(owidth * (j + 1) - 1);
5706       if (x2 >= iwidth)
5707         x2 = iwidth - 1;
5708       sections[k].x1 = x1;
5709       sections[k].x2 = x2;
5710       sections[k].y1 = y1;
5711       sections[k].y2 = y2;
5712       sections[k].buffsize = line_bytes * olength;
5713       sections[k].position = k + 1;
5714       sections[k].total = orows * ocols;
5715       }
5716     }
5717   return (0);
5718   } /* end computeOutputPixelOffsets */
5719
5720 static int
5721 loadImage(TIFF* in, struct image_data *image, struct dump_opts *dump, unsigned char **read_ptr)
5722   {
5723   uint32   i;
5724   float    xres = 0.0, yres = 0.0;
5725   uint16   nstrips = 0, ntiles = 0, planar = 0;
5726   uint16   bps = 0, spp = 0, res_unit = 0;
5727   uint16   orientation = 0;
5728   uint16   input_compression = 0, input_photometric = 0;
5729   uint16   subsampling_horiz, subsampling_vert;
5730   uint32   width = 0, length = 0;
5731   uint32   stsize = 0, tlsize = 0, buffsize = 0, scanlinesize = 0;
5732   uint32   tw = 0, tl = 0;       /* Tile width and length */
5733   uint32   tile_rowsize = 0;
5734   unsigned char *read_buff = NULL;
5735   unsigned char *new_buff  = NULL;
5736   int      readunit = 0;
5737   static   uint32  prev_readsize = 0;
5738
5739   TIFFGetFieldDefaulted(in, TIFFTAG_BITSPERSAMPLE, &bps);
5740   TIFFGetFieldDefaulted(in, TIFFTAG_SAMPLESPERPIXEL, &spp);
5741   TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &planar);
5742   TIFFGetFieldDefaulted(in, TIFFTAG_ORIENTATION, &orientation);
5743   if (! TIFFGetFieldDefaulted(in, TIFFTAG_PHOTOMETRIC, &input_photometric))
5744     TIFFError("loadImage","Image lacks Photometric interpreation tag");
5745   if (! TIFFGetField(in, TIFFTAG_IMAGEWIDTH,  &width))
5746     TIFFError("loadimage","Image lacks image width tag");
5747   if(! TIFFGetField(in, TIFFTAG_IMAGELENGTH, &length))
5748     TIFFError("loadimage","Image lacks image length tag");
5749   TIFFGetFieldDefaulted(in, TIFFTAG_XRESOLUTION, &xres);
5750   TIFFGetFieldDefaulted(in, TIFFTAG_YRESOLUTION, &yres);
5751   if (!TIFFGetFieldDefaulted(in, TIFFTAG_RESOLUTIONUNIT, &res_unit))
5752     res_unit = RESUNIT_INCH;
5753   if (!TIFFGetField(in, TIFFTAG_COMPRESSION, &input_compression))
5754     input_compression = COMPRESSION_NONE;
5755
5756 #ifdef DEBUG2
5757   char compressionid[16];
5758
5759   switch (input_compression)
5760     {
5761     case COMPRESSION_NONE:      /* 1  dump mode */
5762          strcpy (compressionid, "None/dump");
5763          break;
5764     case COMPRESSION_CCITTRLE:    /* 2 CCITT modified Huffman RLE */
5765          strcpy (compressionid, "Huffman RLE");
5766          break;
5767     case COMPRESSION_CCITTFAX3:   /* 3 CCITT Group 3 fax encoding */
5768          strcpy (compressionid, "Group3 Fax");
5769          break;
5770     case COMPRESSION_CCITTFAX4:   /* 4 CCITT Group 4 fax encoding */
5771          strcpy (compressionid, "Group4 Fax");
5772          break;
5773     case COMPRESSION_LZW:         /* 5 Lempel-Ziv  & Welch */
5774          strcpy (compressionid, "LZW");
5775          break;
5776     case COMPRESSION_OJPEG:       /* 6 !6.0 JPEG */
5777          strcpy (compressionid, "Old Jpeg");
5778          break;
5779     case COMPRESSION_JPEG:        /* 7 %JPEG DCT compression */
5780          strcpy (compressionid, "New Jpeg");
5781          break;
5782     case COMPRESSION_NEXT:        /* 32766 NeXT 2-bit RLE */
5783          strcpy (compressionid, "Next RLE");
5784          break;
5785     case COMPRESSION_CCITTRLEW:   /* 32771 #1 w/ word alignment */
5786          strcpy (compressionid, "CITTRLEW");
5787          break;
5788     case COMPRESSION_PACKBITS:    /* 32773 Macintosh RLE */
5789          strcpy (compressionid, "Mac Packbits");
5790          break;
5791     case COMPRESSION_THUNDERSCAN: /* 32809 ThunderScan RLE */
5792          strcpy (compressionid, "Thunderscan");
5793          break;
5794     case COMPRESSION_IT8CTPAD:    /* 32895 IT8 CT w/padding */
5795          strcpy (compressionid, "IT8 padded");
5796          break;
5797     case COMPRESSION_IT8LW:       /* 32896 IT8 Linework RLE */
5798          strcpy (compressionid, "IT8 RLE");
5799          break;
5800     case COMPRESSION_IT8MP:       /* 32897 IT8 Monochrome picture */
5801          strcpy (compressionid, "IT8 mono");
5802          break;
5803     case COMPRESSION_IT8BL:       /* 32898 IT8 Binary line art */
5804          strcpy (compressionid, "IT8 lineart");
5805          break;
5806     case COMPRESSION_PIXARFILM:   /* 32908 Pixar companded 10bit LZW */
5807          strcpy (compressionid, "Pixar 10 bit");
5808          break;
5809     case COMPRESSION_PIXARLOG:    /* 32909 Pixar companded 11bit ZIP */
5810          strcpy (compressionid, "Pixar 11bit");
5811          break;
5812     case COMPRESSION_DEFLATE:     /* 32946 Deflate compression */
5813          strcpy (compressionid, "Deflate");
5814          break;
5815     case COMPRESSION_ADOBE_DEFLATE: /* 8 Deflate compression */
5816          strcpy (compressionid, "Adobe deflate");
5817          break;
5818     default:
5819          strcpy (compressionid, "None/unknown");
5820          break;
5821     }
5822   TIFFError("loadImage", "Input compression %s", compressionid);
5823 #endif
5824
5825   scanlinesize = TIFFScanlineSize(in);
5826   image->bps = bps;
5827   image->spp = spp;
5828   image->planar = planar;
5829   image->width = width;
5830   image->length = length;
5831   image->xres = xres;
5832   image->yres = yres;
5833   image->res_unit = res_unit;
5834   image->compression = input_compression;
5835   image->photometric = input_photometric;
5836 #ifdef DEBUG2
5837   char photometricid[12];
5838
5839   switch (input_photometric)
5840     {
5841     case PHOTOMETRIC_MINISWHITE:
5842          strcpy (photometricid, "MinIsWhite");
5843          break;
5844     case PHOTOMETRIC_MINISBLACK:
5845          strcpy (photometricid, "MinIsBlack");
5846          break;
5847     case PHOTOMETRIC_RGB:
5848          strcpy (photometricid, "RGB");
5849          break;
5850     case PHOTOMETRIC_PALETTE:
5851          strcpy (photometricid, "Palette");
5852          break;
5853     case PHOTOMETRIC_MASK:
5854          strcpy (photometricid, "Mask");
5855          break;
5856     case PHOTOMETRIC_SEPARATED:
5857          strcpy (photometricid, "Separated");
5858          break;
5859     case PHOTOMETRIC_YCBCR:
5860          strcpy (photometricid, "YCBCR");
5861          break;
5862     case PHOTOMETRIC_CIELAB:
5863          strcpy (photometricid, "CIELab");
5864          break;
5865     case PHOTOMETRIC_ICCLAB:
5866          strcpy (photometricid, "ICCLab");
5867          break;
5868     case PHOTOMETRIC_ITULAB:
5869          strcpy (photometricid, "ITULab");
5870          break;
5871     case PHOTOMETRIC_LOGL:
5872          strcpy (photometricid, "LogL");
5873          break;
5874     case PHOTOMETRIC_LOGLUV:
5875          strcpy (photometricid, "LOGLuv");
5876          break;
5877     default:
5878          strcpy (photometricid, "Unknown");
5879          break;
5880     }
5881   TIFFError("loadImage", "Input photometric interpretation %s", photometricid);
5882
5883 #endif
5884   image->orientation = orientation;
5885   switch (orientation)
5886     {
5887     case 0:
5888     case ORIENTATION_TOPLEFT:
5889          image->adjustments = 0;
5890          break;
5891     case ORIENTATION_TOPRIGHT:
5892          image->adjustments = MIRROR_HORIZ;
5893          break;
5894     case ORIENTATION_BOTRIGHT:
5895          image->adjustments = ROTATECW_180;
5896          break;
5897     case ORIENTATION_BOTLEFT:
5898          image->adjustments = MIRROR_VERT;
5899          break;
5900     case ORIENTATION_LEFTTOP:
5901          image->adjustments = MIRROR_VERT | ROTATECW_90;
5902          break;
5903     case ORIENTATION_RIGHTTOP:
5904          image->adjustments = ROTATECW_90;
5905          break;
5906     case ORIENTATION_RIGHTBOT:
5907          image->adjustments = MIRROR_VERT | ROTATECW_270;
5908          break;
5909     case ORIENTATION_LEFTBOT:
5910          image->adjustments = ROTATECW_270;
5911          break;
5912     default:
5913          image->adjustments = 0;
5914          image->orientation = ORIENTATION_TOPLEFT;
5915    }
5916
5917   if ((bps == 0) || (spp == 0))
5918     {
5919     TIFFError("loadImage", "Invalid samples per pixel (%d) or bits per sample (%d)",
5920                spp, bps);
5921     return (-1);
5922     }
5923
5924   if (TIFFIsTiled(in))
5925     {
5926     readunit = TILE;
5927     tlsize = TIFFTileSize(in);
5928     ntiles = TIFFNumberOfTiles(in);
5929     TIFFGetField(in, TIFFTAG_TILEWIDTH, &tw);
5930     TIFFGetField(in, TIFFTAG_TILELENGTH, &tl);
5931
5932     tile_rowsize  = TIFFTileRowSize(in);
5933     buffsize = tlsize * ntiles;
5934
5935
5936     if (buffsize < (uint32)(ntiles * tl * tile_rowsize))
5937       {
5938       buffsize = ntiles * tl * tile_rowsize;
5939 #ifdef DEBUG2
5940       TIFFError("loadImage",
5941                 "Tilesize %u is too small, using ntiles * tilelength * tilerowsize %lu",
5942                 tlsize, (unsigned long)buffsize);
5943 #endif
5944       }
5945
5946     if (dump->infile != NULL)
5947       dump_info (dump->infile, dump->format, "",
5948                  "Tilesize: %u, Number of Tiles: %u, Tile row size: %u",
5949                  tlsize, ntiles, tile_rowsize);
5950     }
5951   else
5952     {
5953     readunit = STRIP;
5954     TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
5955     stsize = TIFFStripSize(in);
5956     nstrips = TIFFNumberOfStrips(in);
5957     buffsize = stsize * nstrips;
5958
5959     if (buffsize < (uint32) (((length * width * spp * bps) + 7) / 8))
5960       {
5961       buffsize =  ((length * width * spp * bps) + 7) / 8;
5962 #ifdef DEBUG2
5963       TIFFError("loadImage",
5964                 "Stripsize %u is too small, using imagelength * width * spp * bps / 8 = %lu",
5965                 stsize, (unsigned long)buffsize);
5966 #endif
5967       }
5968
5969     if (dump->infile != NULL)
5970       dump_info (dump->infile, dump->format, "",
5971                  "Stripsize: %u, Number of Strips: %u, Rows per Strip: %u, Scanline size: %u",
5972                  stsize, nstrips, rowsperstrip, scanlinesize);
5973     }
5974
5975   if (input_compression == COMPRESSION_JPEG)
5976     {  /* Force conversion to RGB */
5977     jpegcolormode = JPEGCOLORMODE_RGB;
5978     TIFFSetField(in, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
5979     }
5980   /* The clause up to the read statement is taken from Tom Lane's tiffcp patch */
5981   else
5982     {   /* Otherwise, can't handle subsampled input */
5983     if (input_photometric == PHOTOMETRIC_YCBCR)
5984       {
5985       TIFFGetFieldDefaulted(in, TIFFTAG_YCBCRSUBSAMPLING,
5986                            &subsampling_horiz, &subsampling_vert);
5987       if (subsampling_horiz != 1 || subsampling_vert != 1)
5988         {
5989         TIFFError("loadImage",
5990                 "Can't copy/convert subsampled image with subsampling %d horiz %d vert",
5991                 subsampling_horiz, subsampling_vert);
5992         return (-1);
5993         }
5994         }
5995     }
5996
5997   read_buff = *read_ptr;
5998   if (!read_buff)
5999     read_buff = (unsigned char *)_TIFFmalloc(buffsize);
6000   else
6001     {
6002     if (prev_readsize < buffsize)
6003       {
6004       new_buff = _TIFFrealloc(read_buff, buffsize);
6005       if (!new_buff)
6006         {
6007         free (read_buff);
6008         read_buff = (unsigned char *)_TIFFmalloc(buffsize);
6009         }
6010       else
6011         read_buff = new_buff;
6012       }
6013     }
6014
6015   if (!read_buff)
6016     {
6017     TIFFError("loadImage", "Unable to allocate/reallocate read buffer");
6018     return (-1);
6019     }
6020
6021   prev_readsize = buffsize;
6022   *read_ptr = read_buff;
6023
6024   /* N.B. The read functions used copy separate plane data into a buffer as interleaved
6025    * samples rather than separate planes so the same logic works to extract regions
6026    * regardless of the way the data are organized in the input file.
6027    */
6028   switch (readunit) {
6029     case STRIP:
6030          if (planar == PLANARCONFIG_CONTIG)
6031            {
6032              if (!(readContigStripsIntoBuffer(in, read_buff)))
6033              {
6034              TIFFError("loadImage", "Unable to read contiguous strips into buffer");
6035              return (-1);
6036              }
6037            }
6038          else
6039            {
6040            if (!(readSeparateStripsIntoBuffer(in, read_buff, length, width, spp, dump)))
6041              {
6042              TIFFError("loadImage", "Unable to read separate strips into buffer");
6043              return (-1);
6044              }
6045            }
6046          break;
6047
6048     case TILE:
6049          if (planar == PLANARCONFIG_CONTIG)
6050            {
6051            if (!(readContigTilesIntoBuffer(in, read_buff, length, width, tw, tl, spp, bps)))
6052              {
6053              TIFFError("loadImage", "Unable to read contiguous tiles into buffer");
6054              return (-1);
6055              }
6056            }
6057          else
6058            {
6059            if (!(readSeparateTilesIntoBuffer(in, read_buff, length, width, tw, tl, spp, bps)))
6060              {
6061              TIFFError("loadImage", "Unable to read separate tiles into buffer");
6062              return (-1);
6063              }
6064            }
6065          break;
6066     default: TIFFError("loadImage", "Unsupported image file format");
6067           return (-1);
6068           break;
6069     }
6070   if ((dump->infile != NULL) && (dump->level == 2))
6071     {
6072     dump_info  (dump->infile, dump->format, "loadImage",
6073                 "Image width %d, length %d, Raw image data, %4d bytes",
6074                 width, length,  buffsize);
6075     dump_info  (dump->infile, dump->format, "",
6076                 "Bits per sample %d, Samples per pixel %d", bps, spp);
6077
6078     for (i = 0; i < length; i++)
6079       dump_buffer(dump->infile, dump->format, 1, scanlinesize,
6080                   i, read_buff + (i * scanlinesize));
6081     }
6082   return (0);
6083   }   /* end loadImage */
6084
6085 static int  correct_orientation(struct image_data *image, unsigned char **work_buff_ptr)
6086   {
6087   uint16 mirror, rotation;
6088   unsigned char *work_buff;
6089
6090   work_buff = *work_buff_ptr;
6091   if ((image == NULL) || (work_buff == NULL))
6092     {
6093     TIFFError ("correct_orientatin", "Invalid image or buffer pointer");
6094     return (-1);
6095     }
6096
6097   if ((image->adjustments & MIRROR_HORIZ) || (image->adjustments & MIRROR_VERT))
6098     {
6099     mirror = (uint16)(image->adjustments & MIRROR_BOTH);
6100     if (mirrorImage(image->spp, image->bps, mirror,
6101         image->width, image->length, work_buff))
6102       {
6103       TIFFError ("correct_orientation", "Unable to mirror image");
6104       return (-1);
6105       }
6106     }
6107
6108   if (image->adjustments & ROTATE_ANY)
6109     {
6110     if (image->adjustments & ROTATECW_90)
6111       rotation = (uint16) 90;
6112     else
6113     if (image->adjustments & ROTATECW_180)
6114       rotation = (uint16) 180;
6115     else
6116     if (image->adjustments & ROTATECW_270)
6117       rotation = (uint16) 270;
6118     else
6119       {
6120       TIFFError ("correct_orientation", "Invalid rotation value: %d",
6121                   image->adjustments & ROTATE_ANY);
6122       return (-1);
6123       }
6124
6125     if (rotateImage(rotation, image, &image->width, &image->length, work_buff_ptr))
6126       {
6127       TIFFError ("correct_orientation", "Unable to rotate image");
6128       return (-1);
6129       }
6130     image->orientation = ORIENTATION_TOPLEFT;
6131     }
6132
6133   return (0);
6134   } /* end correct_orientation */
6135
6136
6137 /* Extract multiple zones from an image and combine into a single composite image */
6138 static int
6139 extractCompositeRegions(struct image_data *image,  struct crop_mask *crop,
6140                         unsigned char *read_buff, unsigned char *crop_buff)
6141   {
6142   int       shift_width, bytes_per_sample, bytes_per_pixel;
6143   uint32    i, trailing_bits, prev_trailing_bits;
6144   uint32    row, first_row, last_row, first_col, last_col;
6145   uint32    src_rowsize, dst_rowsize, src_offset, dst_offset;
6146   uint32    crop_width, crop_length, img_width, img_length;
6147   uint32    prev_length, prev_width, composite_width;
6148   uint16    bps, spp;
6149   uint8    *src, *dst;
6150   tsample_t count, sample = 0;   /* Update to extract one or more samples */
6151
6152   img_width = image->width;
6153   img_length = image->length;
6154   bps = image->bps;
6155   spp = image->spp;
6156   count = spp;
6157
6158   bytes_per_sample = (bps + 7) / 8;
6159   bytes_per_pixel  = ((bps * spp) + 7) / 8;
6160   if ((bps % 8) == 0)
6161     shift_width = 0;
6162   else
6163     {
6164     if (bytes_per_pixel < (bytes_per_sample + 1))
6165       shift_width = bytes_per_pixel;
6166     else
6167       shift_width = bytes_per_sample + 1;
6168     }
6169   src = read_buff;
6170   dst = crop_buff;
6171
6172   /* These are setup for adding additional sections */
6173   prev_width = prev_length = 0;
6174   prev_trailing_bits = trailing_bits = 0;
6175   composite_width = crop->combined_width;
6176   crop->combined_width = 0;
6177   crop->combined_length = 0;
6178
6179   for (i = 0; i < crop->selections; i++)
6180     {
6181     /* rows, columns, width, length are expressed in pixels */
6182     first_row = crop->regionlist[i].y1;
6183     last_row  = crop->regionlist[i].y2;
6184     first_col = crop->regionlist[i].x1;
6185     last_col  = crop->regionlist[i].x2;
6186
6187     crop_width = last_col - first_col + 1;
6188     crop_length = last_row - first_row + 1;
6189
6190     /* These should not be needed for composite images */
6191     crop->regionlist[i].width = crop_width;
6192     crop->regionlist[i].length = crop_length;
6193     crop->regionlist[i].buffptr = crop_buff;
6194
6195     src_rowsize = ((img_width * bps * spp) + 7) / 8;
6196     dst_rowsize = (((crop_width * bps * count) + 7) / 8);
6197
6198     switch (crop->edge_ref)
6199       {
6200       default:
6201       case EDGE_TOP:
6202       case EDGE_BOTTOM:
6203            if ((i > 0) && (crop_width != crop->regionlist[i - 1].width))
6204              {
6205              TIFFError ("extractCompositeRegions",
6206                           "Only equal width regions can be combined for -E top or bottom");
6207              return (1);
6208              }
6209
6210            crop->combined_width = crop_width;
6211            crop->combined_length += crop_length;
6212
6213            for (row = first_row; row <= last_row; row++)
6214              {
6215              src_offset = row * src_rowsize;
6216              dst_offset = (row - first_row) * dst_rowsize;
6217              src = read_buff + src_offset;
6218              dst = crop_buff + dst_offset + (prev_length * dst_rowsize);
6219              switch (shift_width)
6220                {
6221                case 0: if (extractContigSamplesBytes (src, dst, img_width, sample,
6222                                                       spp, bps, count, first_col,
6223                                                       last_col + 1))
6224                          {
6225                          TIFFError("extractCompositeRegions",
6226                                    "Unable to extract row %d", row);
6227                          return (1);
6228                          }
6229                        break;
6230                case 1: if (bps == 1)
6231                          {
6232                          if (extractContigSamplesShifted8bits (src, dst, img_width,
6233                                                                sample, spp, bps, count,
6234                                                                first_col, last_col + 1,
6235                                                                prev_trailing_bits))
6236                            {
6237                            TIFFError("extractCompositeRegions",
6238                                      "Unable to extract row %d", row);
6239                            return (1);
6240                            }
6241                          break;
6242                          }
6243                        else
6244                          if (extractContigSamplesShifted16bits (src, dst, img_width,
6245                                                                 sample, spp, bps, count,
6246                                                                 first_col, last_col + 1,
6247                                                                 prev_trailing_bits))
6248                            {
6249                            TIFFError("extractCompositeRegions",
6250                                      "Unable to extract row %d", row);
6251                            return (1);
6252                            }
6253                         break;
6254                case 2:  if (extractContigSamplesShifted24bits (src, dst, img_width,
6255                                                                sample, spp, bps, count,
6256                                                                first_col, last_col + 1,
6257                                                                prev_trailing_bits))
6258                           {
6259                           TIFFError("extractCompositeRegions",
6260                                     "Unable to extract row %d", row);
6261                           return (1);
6262                           }
6263                         break;
6264                case 3:
6265                case 4:
6266                case 5:  if (extractContigSamplesShifted32bits (src, dst, img_width,
6267                                                                sample, spp, bps, count,
6268                                                                first_col, last_col + 1,
6269                                                                prev_trailing_bits))
6270                           {
6271                           TIFFError("extractCompositeRegions",
6272                                     "Unable to extract row %d", row);
6273                           return (1);
6274                           }
6275                         break;
6276                default: TIFFError("extractCompositeRegions", "Unsupported bit depth %d", bps);
6277                         return (1);
6278                }
6279              }
6280            prev_length += crop_length;
6281            break;
6282       case EDGE_LEFT:  /* splice the pieces of each row together, side by side */
6283       case EDGE_RIGHT:
6284            if ((i > 0) && (crop_length != crop->regionlist[i - 1].length))
6285              {
6286              TIFFError ("extractCompositeRegions",
6287                           "Only equal length regions can be combined for -E left or right");
6288              return (1);
6289              }
6290            crop->combined_width += crop_width;
6291            crop->combined_length = crop_length;
6292            dst_rowsize = (((composite_width * bps * count) + 7) / 8);
6293            trailing_bits = (crop_width * bps * count) % 8;
6294            for (row = first_row; row <= last_row; row++)
6295              {
6296              src_offset = row * src_rowsize;
6297              dst_offset = (row - first_row) * dst_rowsize;
6298              src = read_buff + src_offset;
6299              dst = crop_buff + dst_offset + prev_width;
6300
6301              switch (shift_width)
6302                {
6303                case 0: if (extractContigSamplesBytes (src, dst, img_width,
6304                                                       sample, spp, bps, count,
6305                                                       first_col, last_col + 1))
6306                          {
6307                          TIFFError("extractCompositeRegions",
6308                                    "Unable to extract row %d", row);
6309                          return (1);
6310                          }
6311                        break;
6312                case 1: if (bps == 1)
6313                          {
6314                          if (extractContigSamplesShifted8bits (src, dst, img_width,
6315                                                                sample, spp, bps, count,
6316                                                                first_col, last_col + 1,
6317                                                                prev_trailing_bits))
6318                            {
6319                            TIFFError("extractCompositeRegions",
6320                                      "Unable to extract row %d", row);
6321                            return (1);
6322                            }
6323                          break;
6324                          }
6325                        else
6326                          if (extractContigSamplesShifted16bits (src, dst, img_width,
6327                                                                 sample, spp, bps, count,
6328                                                                 first_col, last_col + 1,
6329                                                                 prev_trailing_bits))
6330                            {
6331                            TIFFError("extractCompositeRegions",
6332                                      "Unable to extract row %d", row);
6333                            return (1);
6334                            }
6335                         break;
6336               case 2:  if (extractContigSamplesShifted24bits (src, dst, img_width,
6337                                                                sample, spp, bps, count,
6338                                                                first_col, last_col + 1,
6339                                                                prev_trailing_bits))
6340                           {
6341                           TIFFError("extractCompositeRegions",
6342                                     "Unable to extract row %d", row);
6343                           return (1);
6344                           }
6345                         break;
6346                case 3:
6347                case 4:
6348                case 5:  if (extractContigSamplesShifted32bits (src, dst, img_width,
6349                                                                sample, spp, bps, count,
6350                                                                first_col, last_col + 1,
6351                                                                prev_trailing_bits))
6352                           {
6353                           TIFFError("extractCompositeRegions",
6354                                     "Unable to extract row %d", row);
6355                           return (1);
6356                           }
6357                         break;
6358                default: TIFFError("extractCompositeRegions", "Unsupported bit depth %d", bps);
6359                         return (1);
6360                }
6361              }
6362            prev_width += (crop_width * bps * count) / 8;
6363            prev_trailing_bits += trailing_bits;
6364            if (prev_trailing_bits > 7)
6365              prev_trailing_bits-= 8;
6366            break;
6367       }
6368     }
6369   if (crop->combined_width != composite_width)
6370     TIFFError("combineSeparateRegions","Combined width does not match composite width");
6371
6372   return (0);
6373   }  /* end extractCompositeRegions */
6374
6375 /* Copy a single region of input buffer to an output buffer.
6376  * The read functions used copy separate plane data into a buffer
6377  * as interleaved samples rather than separate planes so the same
6378  * logic works to extract regions regardless of the way the data
6379  * are organized in the input file. This function can be used to
6380  * extract one or more samples from the input image by updating the
6381  * parameters for starting sample and number of samples to copy in the
6382  * fifth and eighth arguments of the call to extractContigSamples.
6383  * They would be passed as new elements of the crop_mask struct.
6384  */
6385
6386 static int
6387 extractSeparateRegion(struct image_data *image,  struct crop_mask *crop,
6388                       unsigned char *read_buff, unsigned char *crop_buff,
6389                       int region)
6390   {
6391   int     shift_width, prev_trailing_bits = 0;
6392   uint32  bytes_per_sample, bytes_per_pixel;
6393   uint32  src_rowsize, dst_rowsize;
6394   uint32  row, first_row, last_row, first_col, last_col;
6395   uint32  src_offset, dst_offset;
6396   uint32  crop_width, crop_length, img_width, img_length;
6397   uint16  bps, spp;
6398   uint8  *src, *dst;
6399   tsample_t count, sample = 0;   /* Update to extract more or more samples */
6400
6401   img_width = image->width;
6402   img_length = image->length;
6403   bps = image->bps;
6404   spp = image->spp;
6405   count = spp;
6406
6407   bytes_per_sample = (bps + 7) / 8;
6408   bytes_per_pixel  = ((bps * spp) + 7) / 8;
6409   if ((bps % 8) == 0)
6410     shift_width = 0; /* Byte aligned data only */
6411   else
6412     {
6413     if (bytes_per_pixel < (bytes_per_sample + 1))
6414       shift_width = bytes_per_pixel;
6415     else
6416       shift_width = bytes_per_sample + 1;
6417     }
6418
6419   /* rows, columns, width, length are expressed in pixels */
6420   first_row = crop->regionlist[region].y1;
6421   last_row  = crop->regionlist[region].y2;
6422   first_col = crop->regionlist[region].x1;
6423   last_col  = crop->regionlist[region].x2;
6424
6425   crop_width = last_col - first_col + 1;
6426   crop_length = last_row - first_row + 1;
6427
6428   crop->regionlist[region].width = crop_width;
6429   crop->regionlist[region].length = crop_length;
6430   crop->regionlist[region].buffptr = crop_buff;
6431
6432   src = read_buff;
6433   dst = crop_buff;
6434   src_rowsize = ((img_width * bps * spp) + 7) / 8;
6435   dst_rowsize = (((crop_width * bps * spp) + 7) / 8);
6436
6437   for (row = first_row; row <= last_row; row++)
6438     {
6439     src_offset = row * src_rowsize;
6440     dst_offset = (row  - first_row) * dst_rowsize;
6441     src = read_buff + src_offset;
6442     dst = crop_buff + dst_offset;
6443
6444     switch (shift_width)
6445       {
6446       case 0: if (extractContigSamplesBytes (src, dst, img_width, sample,
6447                                              spp, bps, count, first_col,
6448                                              last_col + 1))
6449                 {
6450                 TIFFError("extractSeparateRegion",
6451                           "Unable to extract row %d", row);
6452                 return (1);
6453                 }
6454               break;
6455       case 1: if (bps == 1)
6456                 {
6457                 if (extractContigSamplesShifted8bits (src, dst, img_width,
6458                                                       sample, spp, bps, count,
6459                                                       first_col, last_col + 1,
6460                                                       prev_trailing_bits))
6461                   {
6462                   TIFFError("extractSeparateRegion",
6463                             "Unable to extract row %d", row);
6464                   return (1);
6465                   }
6466                   break;
6467                 }
6468               else
6469                 if (extractContigSamplesShifted16bits (src, dst, img_width,
6470                                                        sample, spp, bps, count,
6471                                                        first_col, last_col + 1,
6472                                                        prev_trailing_bits))
6473                   {
6474                   TIFFError("extractSeparateRegion",
6475                             "Unable to extract row %d", row);
6476                   return (1);
6477                   }
6478               break;
6479       case 2:  if (extractContigSamplesShifted24bits (src, dst, img_width,
6480                                                      sample, spp, bps, count,
6481                                                      first_col, last_col + 1,
6482                                                      prev_trailing_bits))
6483                 {
6484                 TIFFError("extractSeparateRegion",
6485                           "Unable to extract row %d", row);
6486                 return (1);
6487                 }
6488               break;
6489       case 3:
6490       case 4:
6491       case 5:  if (extractContigSamplesShifted32bits (src, dst, img_width,
6492                                                      sample, spp, bps, count,
6493                                                      first_col, last_col + 1,
6494                                                      prev_trailing_bits))
6495                 {
6496                 TIFFError("extractSeparateRegion",
6497                           "Unable to extract row %d", row);
6498                 return (1);
6499                 }
6500               break;
6501       default: TIFFError("extractSeparateRegion", "Unsupported bit depth %d", bps);
6502                return (1);
6503       }
6504     }
6505
6506   return (0);
6507   }  /* end extractSeparateRegion */
6508
6509 static int
6510 extractImageSection(struct image_data *image, struct pageseg *section,
6511                     unsigned char *src_buff, unsigned char *sect_buff)
6512   {
6513   unsigned  char  bytebuff1, bytebuff2;
6514   unsigned  char *src, *dst;
6515
6516   uint32    img_width, img_length, img_rowsize;
6517   uint32    j, shift1, shift2, trailing_bits;
6518   uint32    row, first_row, last_row, first_col, last_col;
6519   uint32    src_offset, dst_offset, row_offset, col_offset;
6520   uint32    offset1, offset2, full_bytes;
6521   uint32    sect_width, sect_length;
6522   uint16    bps, spp;
6523
6524 #ifdef DEVELMODE
6525   int      k;
6526   unsigned char bitset;
6527   static char *bitarray = NULL;
6528 #endif
6529
6530   img_width = image->width;
6531   img_length = image->length;
6532   bps = image->bps;
6533   spp = image->spp;
6534
6535   src = src_buff;
6536   dst = sect_buff;
6537   src_offset = 0;
6538   dst_offset = 0;
6539
6540 #ifdef DEVELMODE
6541   if (bitarray == NULL)
6542     {
6543     if ((bitarray = (char *)malloc(img_width)) == NULL)
6544       {
6545       TIFFError ("", "DEBUG: Unable to allocate debugging bitarray");
6546       return (-1);
6547       }
6548     }
6549 #endif
6550
6551   /* rows, columns, width, length are expressed in pixels */
6552   first_row = section->y1;
6553   last_row  = section->y2;
6554   first_col = section->x1;
6555   last_col  = section->x2;
6556
6557   sect_width = last_col - first_col + 1;
6558   sect_length = last_row - first_row + 1;
6559   img_rowsize = ((img_width * bps + 7) / 8) * spp;
6560   full_bytes = (sect_width * spp * bps) / 8;   /* number of COMPLETE bytes per row in section */
6561   trailing_bits = (sect_width * bps) % 8;
6562
6563 #ifdef DEVELMODE
6564     TIFFError ("", "First row: %d, last row: %d, First col: %d, last col: %d\n",
6565            first_row, last_row, first_col, last_col);
6566     TIFFError ("", "Image width: %d, Image length: %d, bps: %d, spp: %d\n",
6567            img_width, img_length, bps, spp);
6568     TIFFError ("", "Sect  width: %d,  Sect length: %d, full bytes: %d trailing bits %d\n",
6569            sect_width, sect_length, full_bytes, trailing_bits);
6570 #endif
6571
6572   if ((bps % 8) == 0)
6573     {
6574     col_offset = first_col * spp * bps / 8;
6575     for (row = first_row; row <= last_row; row++)
6576       {
6577       /* row_offset = row * img_width * spp * bps / 8; */
6578       row_offset = row * img_rowsize;
6579       src_offset = row_offset + col_offset;
6580
6581 #ifdef DEVELMODE
6582         TIFFError ("", "Src offset: %8d, Dst offset: %8d", src_offset, dst_offset);
6583 #endif
6584       _TIFFmemcpy (sect_buff + dst_offset, src_buff + src_offset, full_bytes);
6585       dst_offset += full_bytes;
6586       }
6587     }
6588   else
6589     { /* bps != 8 */
6590     shift1  = spp * ((first_col * bps) % 8);
6591     shift2  = spp * ((last_col * bps) % 8);
6592     for (row = first_row; row <= last_row; row++)
6593       {
6594       /* pull out the first byte */
6595       row_offset = row * img_rowsize;
6596       offset1 = row_offset + (first_col * bps / 8);
6597       offset2 = row_offset + (last_col * bps / 8);
6598
6599 #ifdef DEVELMODE
6600       for (j = 0, k = 7; j < 8; j++, k--)
6601         {
6602         bitset = *(src_buff + offset1) & (((unsigned char)1 << k)) ? 1 : 0;
6603         sprintf(&bitarray[j], (bitset) ? "1" : "0");
6604         }
6605       sprintf(&bitarray[8], " ");
6606       sprintf(&bitarray[9], " ");
6607       for (j = 10, k = 7; j < 18; j++, k--)
6608         {
6609         bitset = *(src_buff + offset2) & (((unsigned char)1 << k)) ? 1 : 0;
6610         sprintf(&bitarray[j], (bitset) ? "1" : "0");
6611         }
6612       bitarray[18] = '\0';
6613       TIFFError ("", "Row: %3d Offset1: %d,  Shift1: %d,    Offset2: %d,  Shift2:  %d\n",
6614                  row, offset1, shift1, offset2, shift2);
6615 #endif
6616
6617       bytebuff1 = bytebuff2 = 0;
6618       if (shift1 == 0) /* the region is byte and sample alligned */
6619         {
6620         _TIFFmemcpy (sect_buff + dst_offset, src_buff + offset1, full_bytes);
6621
6622 #ifdef DEVELMODE
6623         TIFFError ("", "        Alligned data src offset1: %8d, Dst offset: %8d\n", offset1, dst_offset);
6624         sprintf(&bitarray[18], "\n");
6625         sprintf(&bitarray[19], "\t");
6626         for (j = 20, k = 7; j < 28; j++, k--)
6627           {
6628           bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0;
6629           sprintf(&bitarray[j], (bitset) ? "1" : "0");
6630           }
6631         bitarray[28] = ' ';
6632         bitarray[29] = ' ';
6633 #endif
6634         dst_offset += full_bytes;
6635
6636         if (trailing_bits != 0)
6637           {
6638           bytebuff2 = src_buff[offset2] & ((unsigned char)255 << (7 - shift2));
6639           sect_buff[dst_offset] = bytebuff2;
6640 #ifdef DEVELMODE
6641           TIFFError ("", "        Trailing bits src offset:  %8d, Dst offset: %8d\n",
6642                               offset2, dst_offset);
6643           for (j = 30, k = 7; j < 38; j++, k--)
6644             {
6645             bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0;
6646             sprintf(&bitarray[j], (bitset) ? "1" : "0");
6647             }
6648           bitarray[38] = '\0';
6649           TIFFError ("", "\tFirst and last bytes before and after masking:\n\t%s\n\n", bitarray);
6650 #endif
6651           dst_offset++;
6652           }
6653         }
6654       else   /* each destination byte will have to be built from two source bytes*/
6655         {
6656 #ifdef DEVELMODE
6657           TIFFError ("", "        Unalligned data src offset: %8d, Dst offset: %8d\n", offset1 , dst_offset);
6658 #endif
6659         for (j = 0; j <= full_bytes; j++)
6660           {
6661           bytebuff1 = src_buff[offset1 + j] & ((unsigned char)255 >> shift1);
6662           bytebuff2 = src_buff[offset1 + j + 1] & ((unsigned char)255 << (7 - shift1));
6663           sect_buff[dst_offset + j] = (bytebuff1 << shift1) | (bytebuff2 >> (8 - shift1));
6664           }
6665 #ifdef DEVELMODE
6666         sprintf(&bitarray[18], "\n");
6667         sprintf(&bitarray[19], "\t");
6668         for (j = 20, k = 7; j < 28; j++, k--)
6669           {
6670           bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0;
6671           sprintf(&bitarray[j], (bitset) ? "1" : "0");
6672           }
6673         bitarray[28] = ' ';
6674         bitarray[29] = ' ';
6675 #endif
6676         dst_offset += full_bytes;
6677
6678         if (trailing_bits != 0)
6679           {
6680 #ifdef DEVELMODE
6681             TIFFError ("", "        Trailing bits   src offset: %8d, Dst offset: %8d\n", offset1 + full_bytes, dst_offset);
6682 #endif
6683           if (shift2 > shift1)
6684             {
6685             bytebuff1 = src_buff[offset1 + full_bytes] & ((unsigned char)255 << (7 - shift2));
6686             bytebuff2 = bytebuff1 & ((unsigned char)255 << shift1);
6687             sect_buff[dst_offset] = bytebuff2;
6688 #ifdef DEVELMODE
6689             TIFFError ("", "        Shift2 > Shift1\n");
6690 #endif
6691             }
6692           else
6693             {
6694             if (shift2 < shift1)
6695               {
6696               bytebuff2 = ((unsigned char)255 << (shift1 - shift2 - 1));
6697               sect_buff[dst_offset] &= bytebuff2;
6698 #ifdef DEVELMODE
6699               TIFFError ("", "        Shift2 < Shift1\n");
6700 #endif
6701               }
6702 #ifdef DEVELMODE
6703             else
6704               TIFFError ("", "        Shift2 == Shift1\n");
6705 #endif
6706             }
6707           }
6708 #ifdef DEVELMODE
6709           sprintf(&bitarray[28], " ");
6710           sprintf(&bitarray[29], " ");
6711           for (j = 30, k = 7; j < 38; j++, k--)
6712             {
6713             bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0;
6714             sprintf(&bitarray[j], (bitset) ? "1" : "0");
6715             }
6716           bitarray[38] = '\0';
6717           TIFFError ("", "\tFirst and last bytes before and after masking:\n\t%s\n\n", bitarray);
6718 #endif
6719         dst_offset++;
6720         }
6721       }
6722     }
6723
6724   return (0);
6725   } /* end extractImageSection */
6726
6727 static int
6728 writeSelections(TIFF *in, TIFF **out, struct crop_mask *crop,
6729                 struct image_data *image, struct dump_opts *dump,
6730                 struct buffinfo seg_buffs[], char *mp, char *filename,
6731                 unsigned int *page, unsigned int total_pages)
6732   {
6733   int i, page_count;
6734   int autoindex = 0;
6735   unsigned char *crop_buff = NULL;
6736
6737   /* Where we open a new file depends on the export mode */
6738   switch (crop->exp_mode)
6739     {
6740     case ONE_FILE_COMPOSITE: /* Regions combined into single image */
6741          autoindex = 0;
6742          crop_buff = seg_buffs[0].buffer;
6743          if (update_output_file (out, mp, autoindex, filename, page))
6744            return (1);
6745          page_count = total_pages;
6746          if (writeCroppedImage(in, *out, image, dump,
6747                                crop->combined_width,
6748                                crop->combined_length,
6749                                crop_buff, *page, total_pages))
6750             {
6751              TIFFError("writeRegions", "Unable to write new image");
6752              return (-1);
6753              }
6754          break;
6755     case ONE_FILE_SEPARATED: /* Regions as separated images */
6756          autoindex = 0;
6757          if (update_output_file (out, mp, autoindex, filename, page))
6758            return (1);
6759          page_count = crop->selections * total_pages;
6760          for (i = 0; i < crop->selections; i++)
6761            {
6762            crop_buff = seg_buffs[i].buffer;
6763            if (writeCroppedImage(in, *out, image, dump,
6764                                  crop->regionlist[i].width,
6765                                  crop->regionlist[i].length,
6766                                  crop_buff, *page, page_count))
6767              {
6768              TIFFError("writeRegions", "Unable to write new image");
6769              return (-1);
6770              }
6771            }
6772          break;
6773     case FILE_PER_IMAGE_COMPOSITE: /* Regions as composite image */
6774          autoindex = 1;
6775          if (update_output_file (out, mp, autoindex, filename, page))
6776            return (1);
6777
6778          crop_buff = seg_buffs[0].buffer;
6779          if (writeCroppedImage(in, *out, image, dump,
6780                                crop->combined_width,
6781                                crop->combined_length,
6782                                crop_buff, *page, total_pages))
6783            {
6784            TIFFError("writeRegions", "Unable to write new image");
6785            return (-1);
6786            }
6787          break;
6788     case FILE_PER_IMAGE_SEPARATED: /* Regions as separated images */
6789          autoindex = 1;
6790          page_count = crop->selections;
6791          if (update_output_file (out, mp, autoindex, filename, page))
6792            return (1);
6793
6794          for (i = 0; i < crop->selections; i++)
6795            {
6796            crop_buff = seg_buffs[i].buffer;
6797            /* Write the current region to the current file */
6798            if (writeCroppedImage(in, *out, image, dump,
6799                                  crop->regionlist[i].width,
6800                                  crop->regionlist[i].length,
6801                                  crop_buff, *page, page_count))
6802              {
6803              TIFFError("writeRegions", "Unable to write new image");
6804              return (-1);
6805              }
6806            }
6807          break;
6808     case FILE_PER_SELECTION:
6809          autoindex = 1;
6810          page_count = 1;
6811          for (i = 0; i < crop->selections; i++)
6812            {
6813            if (update_output_file (out, mp, autoindex, filename, page))
6814              return (1);
6815
6816            crop_buff = seg_buffs[i].buffer;
6817            /* Write the current region to the current file */
6818            if (writeCroppedImage(in, *out, image, dump,
6819                                  crop->regionlist[i].width,
6820                                  crop->regionlist[i].length,
6821                                  crop_buff, *page, page_count))
6822              {
6823              TIFFError("writeRegions", "Unable to write new image");
6824              return (-1);
6825              }
6826            }
6827          break;
6828     default: return (1);
6829     }
6830
6831   return (0);
6832   } /* end writeRegions */
6833
6834 static int
6835 writeImageSections(TIFF *in, TIFF *out, struct image_data *image,
6836                    struct pagedef *page, struct pageseg *sections,
6837                    struct dump_opts * dump, unsigned char *src_buff,
6838                    unsigned char **sect_buff_ptr)
6839   {
6840   double  hres, vres;
6841   uint32  i, k, width, length, sectsize;
6842   unsigned char *sect_buff = *sect_buff_ptr;
6843
6844   hres = page->hres;
6845   vres = page->vres;
6846
6847   k = page->cols * page->rows;
6848   if ((k < 1) || (k > MAX_SECTIONS))
6849    {
6850    TIFFError("writeImageSections",
6851              "%d Rows and Columns exceed maximum sections\nIncrease resolution or reduce sections", k);
6852    return (-1);
6853    }
6854
6855   for (i = 0; i < k; i++)
6856     {
6857     width  = sections[i].x2 - sections[i].x1 + 1;
6858     length = sections[i].y2 - sections[i].y1 + 1;
6859     sectsize = (uint32)
6860             ceil((width * image->bps + 7) / (double)8) * image->spp * length;
6861     /* allocate a buffer if we don't have one already */
6862     if (createImageSection(sectsize, sect_buff_ptr))
6863       {
6864       TIFFError("writeImageSections", "Unable to allocate section buffer");
6865       exit (-1);
6866       }
6867     sect_buff = *sect_buff_ptr;
6868
6869     if (extractImageSection (image, &sections[i], src_buff, sect_buff))
6870       {
6871       TIFFError("writeImageSections", "Unable to extract image sections");
6872       exit (-1);
6873       }
6874
6875   /* call the write routine here instead of outside the loop */
6876     if (writeSingleSection(in, out, image, dump, width, length, hres, vres, sect_buff))
6877       {
6878       TIFFError("writeImageSections", "Unable to write image section");
6879       exit (-1);
6880       }
6881     }
6882
6883   return (0);
6884   } /* end writeImageSections */
6885
6886 /* Code in this function is heavily indebted to code in tiffcp
6887  * with modifications by Richard Nolde to handle orientation correctly.
6888  * It will have to be updated significantly if support is added to
6889  * extract one or more samples from original image since the
6890  * original code assumes we are always copying all samples.
6891  */
6892 static int
6893 writeSingleSection(TIFF *in, TIFF *out, struct image_data *image,
6894                    struct dump_opts *dump, uint32 width, uint32 length,
6895                    double hres, double vres,
6896                    unsigned char *sect_buff)
6897   {
6898   uint16 bps, spp;
6899   uint16 input_compression, input_photometric;
6900   uint16 input_planar;
6901   struct cpTag* p;
6902
6903   /*  Calling this seems to reset the compression mode on the TIFF *in file.
6904   TIFFGetField(in, TIFFTAG_JPEGCOLORMODE, &input_jpeg_colormode);
6905   */
6906   input_compression = image->compression;
6907   input_photometric = image->photometric;
6908
6909   spp = image->spp;
6910   bps = image->bps;
6911   TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
6912   TIFFSetField(out, TIFFTAG_IMAGELENGTH, length);
6913   TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, bps);
6914   TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, spp);
6915
6916 #ifdef DEBUG2
6917   TIFFError("writeSingleSection", "Input compression: %s",
6918             (input_compression == COMPRESSION_OJPEG) ? "Old Jpeg" :
6919             ((input_compression == COMPRESSION_JPEG) ?  "New Jpeg" : "Non Jpeg"));
6920 #endif
6921   /* This is the global variable compression which is set
6922    * if the user has specified a command line option for
6923    * a compression option.  Should be passed around in one
6924    * of the parameters instead of as a global. If no user
6925    * option specified it will still be (uint16) -1. */
6926   if (compression != (uint16)-1)
6927     TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
6928   else
6929     { /* OJPEG is no longer supported for writing so upgrade to JPEG */
6930     if (input_compression == COMPRESSION_OJPEG)
6931       {
6932       compression = COMPRESSION_JPEG;
6933       jpegcolormode = JPEGCOLORMODE_RAW;
6934       TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
6935       }
6936     else /* Use the compression from the input file */
6937       TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
6938     }
6939
6940   if (compression == COMPRESSION_JPEG)
6941     {
6942     if ((input_photometric == PHOTOMETRIC_PALETTE) ||  /* color map indexed */
6943         (input_photometric == PHOTOMETRIC_MASK))       /* holdout mask */
6944       {
6945       TIFFError ("writeSingleSection",
6946                  "JPEG compression cannot be used with %s image data",
6947                  (input_photometric == PHOTOMETRIC_PALETTE) ?
6948                  "palette" : "mask");
6949       return (-1);
6950       }
6951     if ((input_photometric == PHOTOMETRIC_RGB) &&
6952         (jpegcolormode == JPEGCOLORMODE_RGB))
6953       TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
6954     else
6955         TIFFSetField(out, TIFFTAG_PHOTOMETRIC, input_photometric);
6956     }
6957   else
6958     {
6959     if (compression == COMPRESSION_SGILOG || compression == COMPRESSION_SGILOG24)
6960       TIFFSetField(out, TIFFTAG_PHOTOMETRIC, spp == 1 ?
6961                         PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV);
6962     else
6963       TIFFSetField(out, TIFFTAG_PHOTOMETRIC, image->photometric);
6964     }
6965
6966 #ifdef DEBUG2
6967   TIFFError("writeSingleSection", "Input photometric: %s",
6968             (input_photometric == PHOTOMETRIC_RGB) ? "RGB" :
6969             ((input_photometric == PHOTOMETRIC_YCBCR) ?  "YCbCr" : "Not RGB or YCbCr"));
6970 #endif
6971
6972   if (((input_photometric == PHOTOMETRIC_LOGL) ||
6973        (input_photometric ==  PHOTOMETRIC_LOGLUV)) &&
6974       ((compression != COMPRESSION_SGILOG) &&
6975        (compression != COMPRESSION_SGILOG24)))
6976     {
6977     TIFFError("writeSingleSection",
6978               "LogL and LogLuv source data require SGI_LOG or SGI_LOG24 compression");
6979     return (-1);
6980     }
6981
6982   if (fillorder != 0)
6983     TIFFSetField(out, TIFFTAG_FILLORDER, fillorder);
6984   else
6985     CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT);
6986
6987   /* The loadimage function reads input orientation and sets
6988    * image->orientation. The correct_image_orientation function
6989    * applies the required rotation and mirror operations to
6990    * present the data in TOPLEFT orientation and updates
6991    * image->orientation if any transforms are performed,
6992    * as per EXIF standard.
6993    */
6994   TIFFSetField(out, TIFFTAG_ORIENTATION, image->orientation);
6995
6996   /*
6997    * Choose tiles/strip for the output image according to
6998    * the command line arguments (-tiles, -strips) and the
6999    * structure of the input image.
7000    */
7001   if (outtiled == -1)
7002     outtiled = TIFFIsTiled(in);
7003   if (outtiled) {
7004     /*
7005      * Setup output file's tile width&height.  If either
7006      * is not specified, use either the value from the
7007      * input image or, if nothing is defined, use the
7008      * library default.
7009      */
7010     if (tilewidth == (uint32) 0)
7011       TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth);
7012     if (tilelength == (uint32) 0)
7013       TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength);
7014
7015     if (tilewidth == 0 || tilelength == 0)
7016       TIFFDefaultTileSize(out, &tilewidth, &tilelength);
7017     TIFFDefaultTileSize(out, &tilewidth, &tilelength);
7018     TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth);
7019     TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength);
7020     } else {
7021        /*
7022         * RowsPerStrip is left unspecified: use either the
7023         * value from the input image or, if nothing is defined,
7024         * use the library default.
7025         */
7026         if (rowsperstrip == (uint32) 0)
7027           {
7028           if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip))
7029             rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip);
7030           if (compression != COMPRESSION_JPEG)
7031             {
7032             if (rowsperstrip > length)
7033               rowsperstrip = length;
7034             }
7035           }
7036         else
7037           if (rowsperstrip == (uint32) -1)
7038             rowsperstrip = length;
7039         TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
7040         }
7041
7042   TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &input_planar);
7043   if (config != (uint16) -1)
7044     TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
7045   else
7046     CopyField(TIFFTAG_PLANARCONFIG, config);
7047   if (spp <= 4)
7048     CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT);
7049   CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT);
7050
7051 /* SMinSampleValue & SMaxSampleValue */
7052   switch (compression) {
7053     /* These are references to GLOBAL variables set by defaults
7054      * and /or the compression flag
7055      */
7056     case COMPRESSION_JPEG:
7057          if (((bps % 8) == 0) || ((bps % 12) == 0))
7058            {
7059            TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
7060            TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
7061            }
7062          else
7063            {
7064            TIFFError("writeSingleSection",
7065                      "JPEG compression requires 8 or 12 bits per sample");
7066            return (-1);
7067            }
7068          break;
7069    case COMPRESSION_LZW:
7070    case COMPRESSION_ADOBE_DEFLATE:
7071    case COMPRESSION_DEFLATE:
7072         if (predictor != (uint16)-1)
7073           TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
7074         else
7075           CopyField(TIFFTAG_PREDICTOR, predictor);
7076         break;
7077    case COMPRESSION_CCITTFAX3:
7078    case COMPRESSION_CCITTFAX4:
7079         if (compression == COMPRESSION_CCITTFAX3) {
7080           if (g3opts != (uint32) -1)
7081             TIFFSetField(out, TIFFTAG_GROUP3OPTIONS, g3opts);
7082           else
7083             CopyField(TIFFTAG_GROUP3OPTIONS, g3opts);
7084         } else
7085             CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG);
7086             CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG);
7087             CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG);
7088             CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG);
7089             CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);
7090             CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);
7091             CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);
7092         break;
7093    }
7094    { uint32 len32;
7095      void** data;
7096      if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data))
7097        TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data);
7098    }
7099    { uint16 ninks;
7100      const char* inknames;
7101      if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) {
7102        TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks);
7103        if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) {
7104          int inknameslen = strlen(inknames) + 1;
7105          const char* cp = inknames;
7106          while (ninks > 1) {
7107            cp = strchr(cp, '\0');
7108            if (cp) {
7109              cp++;
7110              inknameslen += (strlen(cp) + 1);
7111            }
7112            ninks--;
7113          }
7114          TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames);
7115        }
7116      }
7117    }
7118    {
7119    unsigned short pg0, pg1;
7120    if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) {
7121      if (pageNum < 0) /* only one input file */
7122         TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1);
7123      else
7124         TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0);
7125      }
7126    }
7127
7128   for (p = tags; p < &tags[NTAGS]; p++)
7129                 CopyTag(p->tag, p->count, p->type);
7130
7131   /* Update these since they are overwritten from input res by loop above */
7132   TIFFSetField(out, TIFFTAG_XRESOLUTION, (float)hres);
7133   TIFFSetField(out, TIFFTAG_YRESOLUTION, (float)vres);
7134
7135   /* Compute the tile or strip dimensions and write to disk */
7136   if (outtiled)
7137     {
7138     if (config == PLANARCONFIG_CONTIG)
7139       writeBufferToContigTiles (out, sect_buff, length, width, spp, dump);
7140     else
7141       writeBufferToSeparateTiles (out, sect_buff, length, width, spp, dump);
7142     }
7143   else
7144     {
7145     if (config == PLANARCONFIG_CONTIG)
7146       writeBufferToContigStrips (out, sect_buff, length);
7147     else
7148       writeBufferToSeparateStrips(out, sect_buff, length, width, spp, dump);
7149     }
7150
7151   if (!TIFFWriteDirectory(out))
7152     {
7153     TIFFClose(out);
7154     return (-1);
7155     }
7156
7157   return (0);
7158   } /* end writeSingleSection */
7159
7160
7161 /* Create a buffer to write one section at a time */
7162 static int
7163 createImageSection(uint32 sectsize, unsigned char **sect_buff_ptr)
7164   {
7165   unsigned  char *sect_buff = NULL;
7166   unsigned  char *new_buff  = NULL;
7167   static    uint32  prev_sectsize = 0;
7168
7169   sect_buff = *sect_buff_ptr;
7170
7171   if (!sect_buff)
7172     {
7173     sect_buff = (unsigned char *)_TIFFmalloc(sectsize);
7174     *sect_buff_ptr = sect_buff;
7175     _TIFFmemset(sect_buff, 0, sectsize);
7176     }
7177   else
7178     {
7179     if (prev_sectsize < sectsize)
7180       {
7181       new_buff = _TIFFrealloc(sect_buff, sectsize);
7182       if (!new_buff)
7183         {
7184         free (sect_buff);
7185         sect_buff = (unsigned char *)_TIFFmalloc(sectsize);
7186         }
7187       else
7188         sect_buff = new_buff;
7189
7190       _TIFFmemset(sect_buff, 0, sectsize);
7191       }
7192     }
7193
7194   if (!sect_buff)
7195     {
7196     TIFFError("createImageSection", "Unable to allocate/reallocate section buffer");
7197     return (-1);
7198     }
7199   prev_sectsize = sectsize;
7200   *sect_buff_ptr = sect_buff;
7201
7202   return (0);
7203   }  /* end createImageSection */
7204
7205
7206 /* Process selections defined by regions, zones, margins, or fixed sized areas */
7207 static int
7208 processCropSelections(struct image_data *image, struct crop_mask *crop,
7209                       unsigned char **read_buff_ptr, struct buffinfo seg_buffs[])
7210   {
7211   int       i;
7212   uint32    width, length, total_width, total_length;
7213   tsize_t   cropsize;
7214   unsigned  char *crop_buff = NULL;
7215   unsigned  char *read_buff = NULL;
7216   unsigned  char *next_buff = NULL;
7217   tsize_t   prev_cropsize = 0;
7218
7219   read_buff = *read_buff_ptr;
7220
7221   if (crop->img_mode == COMPOSITE_IMAGES)
7222     {
7223     cropsize = crop->bufftotal;
7224     crop_buff = seg_buffs[0].buffer;
7225     if (!crop_buff)
7226       crop_buff = (unsigned char *)_TIFFmalloc(cropsize);
7227     else
7228       {
7229       prev_cropsize = seg_buffs[0].size;
7230       if (prev_cropsize < cropsize)
7231         {
7232         next_buff = _TIFFrealloc(crop_buff, cropsize);
7233         if (! next_buff)
7234           {
7235           _TIFFfree (crop_buff);
7236           crop_buff = (unsigned char *)_TIFFmalloc(cropsize);
7237           }
7238         else
7239           crop_buff = next_buff;
7240         }
7241       }
7242
7243     if (!crop_buff)
7244       {
7245       TIFFError("processCropSelections", "Unable to allocate/reallocate crop buffer");
7246       return (-1);
7247       }
7248
7249     _TIFFmemset(crop_buff, 0, cropsize);
7250     seg_buffs[0].buffer = crop_buff;
7251     seg_buffs[0].size = cropsize;
7252
7253     /* Checks for matching width or length as required */
7254     if (extractCompositeRegions(image, crop, read_buff, crop_buff) != 0)
7255       return (1);
7256
7257     if (crop->crop_mode & CROP_INVERT)
7258       {
7259       switch (crop->photometric)
7260         {
7261         /* Just change the interpretation */
7262         case PHOTOMETRIC_MINISWHITE:
7263         case PHOTOMETRIC_MINISBLACK:
7264              image->photometric = crop->photometric;
7265              break;
7266         case INVERT_DATA_ONLY:
7267         case INVERT_DATA_AND_TAG:
7268              if (invertImage(image->photometric, image->spp, image->bps,
7269                              crop->combined_width, crop->combined_length, crop_buff))
7270                {
7271                TIFFError("processCropSelections",
7272                          "Failed to invert colorspace for composite regions");
7273                return (-1);
7274                }
7275              if (crop->photometric == INVERT_DATA_AND_TAG)
7276                {
7277                switch (image->photometric)
7278                  {
7279                  case PHOTOMETRIC_MINISWHITE:
7280                       image->photometric = PHOTOMETRIC_MINISBLACK;
7281                       break;
7282                  case PHOTOMETRIC_MINISBLACK:
7283                       image->photometric = PHOTOMETRIC_MINISWHITE;
7284                       break;
7285                  default:
7286                       break;
7287                  }
7288                }
7289              break;
7290         default: break;
7291         }
7292       }
7293
7294     /* Mirror and Rotate will not work with multiple regions unless they are the same width */
7295     if (crop->crop_mode & CROP_MIRROR)
7296       {
7297       if (mirrorImage(image->spp, image->bps, crop->mirror,
7298                       crop->combined_width, crop->combined_length, crop_buff))
7299         {
7300         TIFFError("processCropSelections", "Failed to mirror composite regions %s",
7301                  (crop->rotation == MIRROR_HORIZ) ? "horizontally" : "vertically");
7302         return (-1);
7303         }
7304       }
7305
7306     if (crop->crop_mode & CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */
7307       {
7308       if (rotateImage(crop->rotation, image, &crop->combined_width,
7309                       &crop->combined_length, &crop_buff))
7310         {
7311         TIFFError("processCropSelections",
7312                   "Failed to rotate composite regions by %d degrees", crop->rotation);
7313         return (-1);
7314         }
7315       seg_buffs[0].buffer = crop_buff;
7316       seg_buffs[0].size = (((crop->combined_width * image->bps + 7 ) / 8)
7317                             * image->spp) * crop->combined_length;
7318       }
7319     }
7320   else  /* Separated Images */
7321     {
7322     total_width = total_length = 0;
7323     for (i = 0; i < crop->selections; i++)
7324       {
7325       cropsize = crop->bufftotal;
7326       crop_buff = seg_buffs[i].buffer;
7327       if (!crop_buff)
7328         crop_buff = (unsigned char *)_TIFFmalloc(cropsize);
7329       else
7330         {
7331         prev_cropsize = seg_buffs[0].size;
7332         if (prev_cropsize < cropsize)
7333           {
7334           next_buff = _TIFFrealloc(crop_buff, cropsize);
7335           if (! next_buff)
7336             {
7337             _TIFFfree (crop_buff);
7338             crop_buff = (unsigned char *)_TIFFmalloc(cropsize);
7339             }
7340           else
7341             crop_buff = next_buff;
7342           }
7343         }
7344
7345       if (!crop_buff)
7346         {
7347         TIFFError("processCropSelections", "Unable to allocate/reallocate crop buffer");
7348         return (-1);
7349         }
7350
7351       _TIFFmemset(crop_buff, 0, cropsize);
7352       seg_buffs[i].buffer = crop_buff;
7353       seg_buffs[i].size = cropsize;
7354
7355       if (extractSeparateRegion(image, crop, read_buff, crop_buff, i))
7356         {
7357         TIFFError("processCropSelections", "Unable to extract cropped region %d from image", i);
7358         return (-1);
7359         }
7360
7361       width  = crop->regionlist[i].width;
7362       length = crop->regionlist[i].length;
7363
7364       if (crop->crop_mode & CROP_INVERT)
7365         {
7366         switch (crop->photometric)
7367           {
7368           /* Just change the interpretation */
7369           case PHOTOMETRIC_MINISWHITE:
7370           case PHOTOMETRIC_MINISBLACK:
7371                image->photometric = crop->photometric;
7372                break;
7373           case INVERT_DATA_ONLY:
7374           case INVERT_DATA_AND_TAG:
7375                if (invertImage(image->photometric, image->spp, image->bps,
7376                                width, length, crop_buff))
7377                  {
7378                  TIFFError("processCropSelections",
7379                            "Failed to invert colorspace for region");
7380                  return (-1);
7381                  }
7382                if (crop->photometric == INVERT_DATA_AND_TAG)
7383                  {
7384                  switch (image->photometric)
7385                    {
7386                    case PHOTOMETRIC_MINISWHITE:
7387                         image->photometric = PHOTOMETRIC_MINISBLACK;
7388                         break;
7389                    case PHOTOMETRIC_MINISBLACK:
7390                         image->photometric = PHOTOMETRIC_MINISWHITE;
7391                         break;
7392                    default:
7393                         break;
7394                    }
7395                  }
7396                break;
7397           default: break;
7398           }
7399         }
7400
7401       if (crop->crop_mode & CROP_MIRROR)
7402         {
7403         if (mirrorImage(image->spp, image->bps, crop->mirror,
7404                         width, length, crop_buff))
7405           {
7406           TIFFError("processCropSelections", "Failed to mirror crop region %s",
7407                    (crop->rotation == MIRROR_HORIZ) ? "horizontally" : "vertically");
7408           return (-1);
7409           }
7410         }
7411
7412       if (crop->crop_mode & CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */
7413         {
7414         if (rotateImage(crop->rotation, image, &crop->regionlist[i].width,
7415                         &crop->regionlist[i].length, &crop_buff))
7416           {
7417           TIFFError("processCropSelections",
7418                     "Failed to rotate crop region by %d degrees", crop->rotation);
7419           return (-1);
7420           }
7421         total_width  += crop->regionlist[i].width;
7422         total_length += crop->regionlist[i].length;
7423         crop->combined_width = total_width;
7424         crop->combined_length = total_length;
7425         seg_buffs[i].buffer = crop_buff;
7426         seg_buffs[i].size = (((crop->regionlist[i].width * image->bps + 7 ) / 8)
7427                                * image->spp) * crop->regionlist[i].length;
7428         }
7429       }
7430     }
7431   return (0);
7432   } /* end processCropSelections */
7433
7434 /* Copy the crop section of the data from the current image into a buffer
7435  * and adjust the IFD values to reflect the new size. If no cropping is
7436  * required, use the origial read buffer as the crop buffer.
7437  *
7438  * There is quite a bit of redundancy between this routine and the more
7439  * specialized processCropSelections, but this provides
7440  * the most optimized path when no Zones or Regions are required.
7441  */
7442 static int
7443 createCroppedImage(struct image_data *image, struct crop_mask *crop,
7444                    unsigned char **read_buff_ptr, unsigned char **crop_buff_ptr)
7445   {
7446   tsize_t   cropsize;
7447   unsigned  char *read_buff = NULL;
7448   unsigned  char *crop_buff = NULL;
7449   unsigned  char *new_buff  = NULL;
7450   static    tsize_t  prev_cropsize = 0;
7451
7452   read_buff = *read_buff_ptr;
7453
7454   /* process full image, no crop buffer needed */
7455   crop_buff = read_buff;
7456   *crop_buff_ptr = read_buff;
7457   crop->combined_width = image->width;
7458   crop->combined_length = image->length;
7459
7460   cropsize = crop->bufftotal;
7461   crop_buff = *crop_buff_ptr;
7462   if (!crop_buff)
7463     {
7464     crop_buff = (unsigned char *)_TIFFmalloc(cropsize);
7465     *crop_buff_ptr = crop_buff;
7466     _TIFFmemset(crop_buff, 0, cropsize);
7467     prev_cropsize = cropsize;
7468     }
7469   else
7470     {
7471     if (prev_cropsize < cropsize)
7472       {
7473       new_buff = _TIFFrealloc(crop_buff, cropsize);
7474       if (!new_buff)
7475         {
7476         free (crop_buff);
7477         crop_buff = (unsigned char *)_TIFFmalloc(cropsize);
7478         }
7479       else
7480         crop_buff = new_buff;
7481       _TIFFmemset(crop_buff, 0, cropsize);
7482       }
7483     }
7484
7485   if (!crop_buff)
7486     {
7487     TIFFError("createCroppedImage", "Unable to allocate/reallocate crop buffer");
7488     return (-1);
7489     }
7490   *crop_buff_ptr = crop_buff;
7491
7492   if (crop->crop_mode & CROP_INVERT)
7493     {
7494     switch (crop->photometric)
7495       {
7496       /* Just change the interpretation */
7497       case PHOTOMETRIC_MINISWHITE:
7498       case PHOTOMETRIC_MINISBLACK:
7499            image->photometric = crop->photometric;
7500            break;
7501       case INVERT_DATA_ONLY:
7502       case INVERT_DATA_AND_TAG:
7503            if (invertImage(image->photometric, image->spp, image->bps,
7504                            crop->combined_width, crop->combined_length, crop_buff))
7505              {
7506              TIFFError("createCroppedImage",
7507                        "Failed to invert colorspace for image or cropped selection");
7508              return (-1);
7509              }
7510            if (crop->photometric == INVERT_DATA_AND_TAG)
7511              {
7512              switch (image->photometric)
7513                {
7514                case PHOTOMETRIC_MINISWHITE:
7515                     image->photometric = PHOTOMETRIC_MINISBLACK;
7516                     break;
7517                case PHOTOMETRIC_MINISBLACK:
7518                     image->photometric = PHOTOMETRIC_MINISWHITE;
7519                     break;
7520                default:
7521                     break;
7522                }
7523              }
7524            break;
7525       default: break;
7526       }
7527     }
7528
7529   if (crop->crop_mode & CROP_MIRROR)
7530     {
7531     if (mirrorImage(image->spp, image->bps, crop->mirror,
7532                     crop->combined_width, crop->combined_length, crop_buff))
7533       {
7534       TIFFError("createCroppedImage", "Failed to mirror image or cropped selection %s",
7535                (crop->rotation == MIRROR_HORIZ) ? "horizontally" : "vertically");
7536       return (-1);
7537       }
7538     }
7539
7540   if (crop->crop_mode & CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */
7541     {
7542     if (rotateImage(crop->rotation, image, &crop->combined_width,
7543                     &crop->combined_length, crop_buff_ptr))
7544       {
7545       TIFFError("createCroppedImage",
7546                 "Failed to rotate image or cropped selection by %d degrees", crop->rotation);
7547       return (-1);
7548       }
7549     }
7550
7551   if (crop_buff == read_buff) /* we used the read buffer for the crop buffer */
7552     *read_buff_ptr = NULL;    /* so we don't try to free it later */
7553
7554   return (0);
7555   } /* end createCroppedImage */
7556
7557
7558 /* Code in this function is heavily indebted to code in tiffcp
7559  * with modifications by Richard Nolde to handle orientation correctly.
7560  * It will have to be updated significantly if support is added to
7561  * extract one or more samples from original image since the
7562  * original code assumes we are always copying all samples.
7563  * Use of global variables for config, compression and others
7564  * should be replaced by addition to the crop_mask struct (which
7565  * will be renamed to proc_opts indicating that is controlls
7566  * user supplied processing options, not just cropping) and
7567  * then passed in as an argument.
7568  */
7569 static int
7570 writeCroppedImage(TIFF *in, TIFF *out, struct image_data *image,
7571                   struct dump_opts *dump, uint32 width, uint32 length,
7572                   unsigned char *crop_buff, int pagenum, int total_pages)
7573   {
7574   uint16 bps, spp;
7575   uint16 input_compression, input_photometric;
7576   uint16 input_planar;
7577   struct cpTag* p;
7578
7579   input_compression = image->compression;
7580   input_photometric = image->photometric;
7581   spp = image->spp;
7582   bps = image->bps;
7583
7584   TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
7585   TIFFSetField(out, TIFFTAG_IMAGELENGTH, length);
7586   TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, bps);
7587   TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, spp);
7588
7589 #ifdef DEBUG2
7590   TIFFError("writeCroppedImage", "Input compression: %s",
7591             (input_compression == COMPRESSION_OJPEG) ? "Old Jpeg" :
7592             ((input_compression == COMPRESSION_JPEG) ?  "New Jpeg" : "Non Jpeg"));
7593 #endif
7594
7595   if (compression != (uint16)-1)
7596     TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
7597   else
7598     {
7599     if (input_compression == COMPRESSION_OJPEG)
7600       {
7601       compression = COMPRESSION_JPEG;
7602       jpegcolormode = JPEGCOLORMODE_RAW;
7603       TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
7604       }
7605     else
7606       CopyField(TIFFTAG_COMPRESSION, compression);
7607     }
7608
7609   if (compression == COMPRESSION_JPEG)
7610     {
7611     if ((input_photometric == PHOTOMETRIC_PALETTE) ||  /* color map indexed */
7612         (input_photometric == PHOTOMETRIC_MASK))       /* $holdout mask */
7613       {
7614       TIFFError ("writeCroppedImage",
7615                  "JPEG compression cannot be used with %s image data",
7616                 (input_photometric == PHOTOMETRIC_PALETTE) ?
7617                  "palette" : "mask");
7618       return (-1);
7619       }
7620     if ((input_photometric == PHOTOMETRIC_RGB) &&
7621         (jpegcolormode == JPEGCOLORMODE_RGB))
7622       TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
7623     else
7624         TIFFSetField(out, TIFFTAG_PHOTOMETRIC, input_photometric);
7625     }
7626   else
7627     {
7628     if (compression == COMPRESSION_SGILOG || compression == COMPRESSION_SGILOG24)
7629       {
7630       TIFFSetField(out, TIFFTAG_PHOTOMETRIC, spp == 1 ?
7631                         PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV);
7632       }
7633     else
7634       {
7635       if (input_compression == COMPRESSION_SGILOG ||
7636           input_compression == COMPRESSION_SGILOG24)
7637         {
7638         TIFFSetField(out, TIFFTAG_PHOTOMETRIC, spp == 1 ?
7639                           PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV);
7640         }
7641       else
7642         TIFFSetField(out, TIFFTAG_PHOTOMETRIC, image->photometric);
7643       }
7644     }
7645
7646   if (((input_photometric == PHOTOMETRIC_LOGL) ||
7647        (input_photometric ==  PHOTOMETRIC_LOGLUV)) &&
7648       ((compression != COMPRESSION_SGILOG) &&
7649        (compression != COMPRESSION_SGILOG24)))
7650     {
7651     TIFFError("writeCroppedImage",
7652               "LogL and LogLuv source data require SGI_LOG or SGI_LOG24 compression");
7653     return (-1);
7654     }
7655
7656   if (fillorder != 0)
7657     TIFFSetField(out, TIFFTAG_FILLORDER, fillorder);
7658   else
7659     CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT);
7660
7661   /* The loadimage function reads input orientation and sets
7662    * image->orientation. The correct_image_orientation function
7663    * applies the required rotation and mirror operations to
7664    * present the data in TOPLEFT orientation and updates
7665    * image->orientation if any transforms are performed,
7666    * as per EXIF standard.
7667    */
7668   TIFFSetField(out, TIFFTAG_ORIENTATION, image->orientation);
7669
7670   /*
7671    * Choose tiles/strip for the output image according to
7672    * the command line arguments (-tiles, -strips) and the
7673    * structure of the input image.
7674    */
7675   if (outtiled == -1)
7676     outtiled = TIFFIsTiled(in);
7677   if (outtiled) {
7678     /*
7679      * Setup output file's tile width&height.  If either
7680      * is not specified, use either the value from the
7681      * input image or, if nothing is defined, use the
7682      * library default.
7683      */
7684     if (tilewidth == (uint32) 0)
7685       TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth);
7686     if (tilelength == (uint32) 0)
7687       TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength);
7688
7689     if (tilewidth == 0 || tilelength == 0)
7690       TIFFDefaultTileSize(out, &tilewidth, &tilelength);
7691     TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth);
7692     TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength);
7693     } else {
7694        /*
7695         * RowsPerStrip is left unspecified: use either the
7696         * value from the input image or, if nothing is defined,
7697         * use the library default.
7698         */
7699         if (rowsperstrip == (uint32) 0)
7700           {
7701           if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip))
7702             rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip);
7703           if (compression != COMPRESSION_JPEG)
7704             {
7705             if (rowsperstrip > length)
7706               rowsperstrip = length;
7707             }
7708           }
7709         else
7710           if (rowsperstrip == (uint32) -1)
7711             rowsperstrip = length;
7712         TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
7713         }
7714
7715   TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &input_planar);
7716   if (config != (uint16) -1)
7717     TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
7718   else
7719     CopyField(TIFFTAG_PLANARCONFIG, config);
7720   if (spp <= 4)
7721     CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT);
7722   CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT);
7723
7724 /* SMinSampleValue & SMaxSampleValue */
7725   switch (compression) {
7726     case COMPRESSION_JPEG:
7727          if (((bps % 8) == 0) || ((bps % 12) == 0))
7728            {
7729            TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
7730            TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
7731            }
7732          else
7733            {
7734            TIFFError("writeCroppedImage",
7735                      "JPEG compression requires 8 or 12 bits per sample");
7736            return (-1);
7737            }
7738          break;
7739    case COMPRESSION_LZW:
7740    case COMPRESSION_ADOBE_DEFLATE:
7741    case COMPRESSION_DEFLATE:
7742         if (predictor != (uint16)-1)
7743           TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
7744         else
7745           CopyField(TIFFTAG_PREDICTOR, predictor);
7746         break;
7747    case COMPRESSION_CCITTFAX3:
7748    case COMPRESSION_CCITTFAX4:
7749         if (bps != 1)
7750           {
7751           TIFFError("writeCroppedImage",
7752             "Group 3/4 compression is not usable with bps > 1");
7753           return (-1);
7754           }
7755         if (compression == COMPRESSION_CCITTFAX3) {
7756           if (g3opts != (uint32) -1)
7757             TIFFSetField(out, TIFFTAG_GROUP3OPTIONS, g3opts);
7758           else
7759             CopyField(TIFFTAG_GROUP3OPTIONS, g3opts);
7760         } else
7761             CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG);
7762             CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG);
7763             CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG);
7764             CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG);
7765             CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);
7766             CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);
7767             CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);
7768          break;
7769     case COMPRESSION_NONE:
7770          break;
7771     default: break;
7772    }
7773    { uint32 len32;
7774      void** data;
7775      if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data))
7776        TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data);
7777    }
7778    { uint16 ninks;
7779      const char* inknames;
7780      if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) {
7781        TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks);
7782        if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) {
7783          int inknameslen = strlen(inknames) + 1;
7784          const char* cp = inknames;
7785          while (ninks > 1) {
7786            cp = strchr(cp, '\0');
7787            if (cp) {
7788              cp++;
7789              inknameslen += (strlen(cp) + 1);
7790            }
7791            ninks--;
7792          }
7793          TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames);
7794        }
7795      }
7796    }
7797    {
7798    unsigned short pg0, pg1;
7799    if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) {
7800      TIFFSetField(out, TIFFTAG_PAGENUMBER, pagenum, total_pages);
7801      }
7802    }
7803
7804   for (p = tags; p < &tags[NTAGS]; p++)
7805                 CopyTag(p->tag, p->count, p->type);
7806
7807   /* Compute the tile or strip dimensions and write to disk */
7808   if (outtiled)
7809     {
7810     if (config == PLANARCONFIG_CONTIG)
7811       {
7812       if (writeBufferToContigTiles (out, crop_buff, length, width, spp, dump))
7813         TIFFError("","Unable to write contiguous tile data for page %d", pagenum);
7814       }
7815     else
7816       {
7817       if (writeBufferToSeparateTiles (out, crop_buff, length, width, spp, dump))
7818         TIFFError("","Unable to write separate tile data for page %d", pagenum);
7819       }
7820     }
7821   else
7822     {
7823     if (config == PLANARCONFIG_CONTIG)
7824       {
7825       if (writeBufferToContigStrips (out, crop_buff, length))
7826         TIFFError("","Unable to write contiguous strip data for page %d", pagenum);
7827       }
7828     else
7829       {
7830       if (writeBufferToSeparateStrips(out, crop_buff, length, width, spp, dump))
7831         TIFFError("","Unable to write separate strip data for page %d", pagenum);
7832       }
7833     }
7834
7835   if (!TIFFWriteDirectory(out))
7836     {
7837     TIFFError("","Failed to write IFD for page number %d", pagenum);
7838     TIFFClose(out);
7839     return (-1);
7840     }
7841
7842   return (0);
7843   } /* end writeCroppedImage */
7844
7845 static int
7846 rotateContigSamples8bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width,
7847                          uint32 length,   uint32 col, uint8 *src, uint8 *dst)
7848   {
7849   int      ready_bits = 0;
7850   uint32   src_byte = 0, src_bit = 0;
7851   uint32   row, rowsize = 0, bit_offset = 0;
7852   uint8    matchbits = 0, maskbits = 0;
7853   uint8    buff1 = 0, buff2 = 0;
7854   uint8   *next;
7855   tsample_t sample;
7856
7857   if ((src == NULL) || (dst == NULL))
7858     {
7859     TIFFError("rotateContigSamples8bits","Invalid src or destination buffer");
7860     return (1);
7861     }
7862
7863   rowsize = ((bps * spp * width) + 7) / 8;
7864   ready_bits = 0;
7865   maskbits =  (uint8)-1 >> ( 8 - bps);
7866   buff1 = buff2 = 0;
7867
7868   for (row = 0; row < length ; row++)
7869     {
7870     bit_offset = col * bps * spp;
7871     for (sample = 0; sample < spp; sample++)
7872       {
7873       if (sample == 0)
7874         {
7875         src_byte = bit_offset / 8;
7876         src_bit  = bit_offset % 8;
7877         }
7878       else
7879         {
7880         src_byte = (bit_offset + (sample * bps)) / 8;
7881         src_bit  = (bit_offset + (sample * bps)) % 8;
7882         }
7883
7884       switch (rotation)
7885         {
7886         case  90: next = src + src_byte - (row * rowsize);
7887                   break;
7888         case 270: next = src + src_byte + (row * rowsize);
7889                   break;
7890         default:  TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation);
7891                   return (1);
7892         }
7893       matchbits = maskbits << (8 - src_bit - bps);
7894       buff1 = ((*next) & matchbits) << (src_bit);
7895
7896        /* If we have a full buffer's worth, write it out */
7897       if (ready_bits >= 8)
7898         {
7899         *dst++ = buff2;
7900         buff2 = buff1;
7901         ready_bits -= 8;
7902         }
7903       else
7904         {
7905         buff2 = (buff2 | (buff1 >> ready_bits));
7906         }
7907       ready_bits += bps;
7908       }
7909     }
7910
7911   if (ready_bits > 0)
7912     {
7913     buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits)));
7914     *dst++ = buff1;
7915     }
7916
7917   return (0);
7918   }  /* end rotateContigSamples8bits */
7919
7920
7921 static int
7922 rotateContigSamples16bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width,
7923                          uint32 length,   uint32 col, uint8 *src, uint8 *dst)
7924   {
7925   int      ready_bits = 0;
7926   uint32   row, rowsize, bit_offset;
7927   uint32   src_byte = 0, src_bit = 0;
7928   uint16   matchbits = 0, maskbits = 0;
7929   uint16   buff1 = 0, buff2 = 0;
7930   uint8    bytebuff = 0;
7931   uint8   *next;
7932   tsample_t sample;
7933
7934   if ((src == NULL) || (dst == NULL))
7935     {
7936     TIFFError("rotateContigSamples16bits","Invalid src or destination buffer");
7937     return (1);
7938     }
7939
7940   rowsize = ((bps * spp * width) + 7) / 8;
7941   ready_bits = 0;
7942   maskbits =  (uint16)-1 >> (16 - bps);
7943   buff1 = buff2 = 0;
7944   for (row = 0; row < length; row++)
7945     {
7946     bit_offset = col * bps * spp;
7947     for (sample = 0; sample < spp; sample++)
7948       {
7949       if (sample == 0)
7950         {
7951         src_byte = bit_offset / 8;
7952         src_bit  = bit_offset % 8;
7953         }
7954       else
7955         {
7956         src_byte = (bit_offset + (sample * bps)) / 8;
7957         src_bit  = (bit_offset + (sample * bps)) % 8;
7958         }
7959
7960       switch (rotation)
7961         {
7962         case  90: next = src + src_byte - (row * rowsize);
7963                   break;
7964         case 270: next = src + src_byte + (row * rowsize);
7965                   break;
7966         default:  TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation);
7967                   return (1);
7968         }
7969       matchbits = maskbits << (16 - src_bit - bps);
7970       if (little_endian)
7971         buff1 = (next[0] << 8) | next[1];
7972       else
7973         buff1 = (next[1] << 8) | next[0];
7974
7975       buff1 = (buff1 & matchbits) << (src_bit);
7976
7977       /* If we have a full buffer's worth, write it out */
7978       if (ready_bits >= 8)
7979         {
7980         bytebuff = (buff2 >> 8);
7981         *dst++ = bytebuff;
7982         ready_bits -= 8;
7983         /* shift in new bits */
7984         buff2 = ((buff2 << 8) | (buff1 >> ready_bits));
7985         }
7986       else
7987         { /* add another bps bits to the buffer */
7988         bytebuff = 0;
7989         buff2 = (buff2 | (buff1 >> ready_bits));
7990         }
7991       ready_bits += bps;
7992       }
7993     }
7994
7995   if (ready_bits > 0)
7996     {
7997     bytebuff = (buff2 >> 8);
7998     *dst++ = bytebuff;
7999     }
8000
8001   return (0);
8002   }  /* end rotateContigSamples16bits */
8003
8004 static int
8005 rotateContigSamples24bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width,
8006                           uint32 length,   uint32 col, uint8 *src, uint8 *dst)
8007   {
8008   int      ready_bits = 0;
8009   uint32   row, rowsize, bit_offset;
8010   uint32   src_byte = 0, src_bit = 0;
8011   uint32   matchbits = 0, maskbits = 0;
8012   uint32   buff1 = 0, buff2 = 0;
8013   uint8    bytebuff1 = 0, bytebuff2 = 0;
8014   uint8   *next;
8015   tsample_t sample;
8016
8017
8018   if ((src == NULL) || (dst == NULL))
8019     {
8020     TIFFError("rotateContigSamples24bits","Invalid src or destination buffer");
8021     return (1);
8022     }
8023
8024   rowsize = ((bps * spp * width) + 7) / 8;
8025   ready_bits = 0;
8026   maskbits =  (uint32)-1 >> (32 - bps);
8027   buff1 = buff2 = 0;
8028   for (row = 0; row < length; row++)
8029     {
8030     bit_offset = col * bps * spp;
8031     for (sample = 0; sample < spp; sample++)
8032       {
8033       if (sample == 0)
8034         {
8035         src_byte = bit_offset / 8;
8036         src_bit  = bit_offset % 8;
8037         }
8038       else
8039         {
8040         src_byte = (bit_offset + (sample * bps)) / 8;
8041         src_bit  = (bit_offset + (sample * bps)) % 8;
8042         }
8043
8044       switch (rotation)
8045         {
8046         case  90: next = src + src_byte - (row * rowsize);
8047                   break;
8048         case 270: next = src + src_byte + (row * rowsize);
8049                   break;
8050         default:  TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation);
8051                   return (1);
8052         }
8053       matchbits = maskbits << (32 - src_bit - bps);
8054       if (little_endian)
8055         buff1 = (next[0] << 24) | (next[1] << 16) | (next[2] << 8) | next[3];
8056       else
8057         buff1 = (next[3] << 24) | (next[2] << 16) | (next[1] << 8) | next[0];
8058       buff1 = (buff1 & matchbits) << (src_bit);
8059
8060       /* If we have a full buffer's worth, write it out */
8061       if (ready_bits >= 16)
8062         {
8063         bytebuff1 = (buff2 >> 24);
8064         *dst++ = bytebuff1;
8065         bytebuff2 = (buff2 >> 16);
8066         *dst++ = bytebuff2;
8067         ready_bits -= 16;
8068
8069         /* shift in new bits */
8070         buff2 = ((buff2 << 16) | (buff1 >> ready_bits));
8071         }
8072       else
8073         { /* add another bps bits to the buffer */
8074         bytebuff1 = bytebuff2 = 0;
8075         buff2 = (buff2 | (buff1 >> ready_bits));
8076         }
8077       ready_bits += bps;
8078       }
8079     }
8080
8081  /* catch any trailing bits at the end of the line */
8082   while (ready_bits > 0)
8083     {
8084     bytebuff1 = (buff2 >> 24);
8085     *dst++ = bytebuff1;
8086
8087     buff2 = (buff2 << 8);
8088     bytebuff2 = bytebuff1;
8089     ready_bits -= 8;
8090     }
8091
8092   return (0);
8093   }  /* end rotateContigSamples24bits */
8094
8095 static int
8096 rotateContigSamples32bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width,
8097                           uint32 length,   uint32 col, uint8 *src, uint8 *dst)
8098   {
8099   int    ready_bits = 0, shift_width = 0;
8100   int    bytes_per_sample, bytes_per_pixel;
8101   uint32 row, rowsize, bit_offset;
8102   uint32 src_byte, src_bit;
8103   uint32 longbuff1 = 0, longbuff2 = 0;
8104   uint64 maskbits = 0, matchbits = 0;
8105   uint64 buff1 = 0, buff2 = 0, buff3 = 0;
8106   uint8  bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0;
8107   uint8   *next;
8108   tsample_t sample;
8109
8110
8111   if ((src == NULL) || (dst == NULL))
8112     {
8113     TIFFError("rotateContigSamples24bits","Invalid src or destination buffer");
8114     return (1);
8115     }
8116
8117   bytes_per_sample = (bps + 7) / 8;
8118   bytes_per_pixel  = ((bps * spp) + 7) / 8;
8119   if (bytes_per_pixel < (bytes_per_sample + 1))
8120     shift_width = bytes_per_pixel;
8121   else
8122     shift_width = bytes_per_sample + 1;
8123
8124   rowsize = ((bps * spp * width) + 7) / 8;
8125   ready_bits = 0;
8126   maskbits =  (uint64)-1 >> (64 - bps);
8127   buff1 = buff2 = 0;
8128   for (row = 0; row < length; row++)
8129     {
8130     bit_offset = col * bps * spp;
8131     for (sample = 0; sample < spp; sample++)
8132       {
8133       if (sample == 0)
8134         {
8135         src_byte = bit_offset / 8;
8136         src_bit  = bit_offset % 8;
8137         }
8138       else
8139         {
8140         src_byte = (bit_offset + (sample * bps)) / 8;
8141         src_bit  = (bit_offset + (sample * bps)) % 8;
8142         }
8143
8144       switch (rotation)
8145         {
8146         case  90: next = src + src_byte - (row * rowsize);
8147                   break;
8148         case 270: next = src + src_byte + (row * rowsize);
8149                   break;
8150         default:  TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation);
8151                   return (1);
8152         }
8153       matchbits = maskbits << (64 - src_bit - bps);
8154       if (little_endian)
8155         {
8156         longbuff1 = (next[0] << 24) | (next[1] << 16) | (next[2] << 8) | next[3];
8157         longbuff2 = longbuff1;
8158         }
8159       else
8160         {
8161         longbuff1 = (next[3] << 24) | (next[2] << 16) | (next[1] << 8) | next[0];
8162         longbuff2 = longbuff1;
8163         }
8164
8165       buff3 = ((uint64)longbuff1 << 32) | longbuff2;
8166       buff1 = (buff3 & matchbits) << (src_bit);
8167
8168       if (ready_bits < 32)
8169         { /* add another bps bits to the buffer */
8170         bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0;
8171         buff2 = (buff2 | (buff1 >> ready_bits));
8172         }
8173       else /* If we have a full buffer's worth, write it out */
8174         {
8175         bytebuff1 = (buff2 >> 56);
8176         *dst++ = bytebuff1;
8177         bytebuff2 = (buff2 >> 48);
8178         *dst++ = bytebuff2;
8179         bytebuff3 = (buff2 >> 40);
8180         *dst++ = bytebuff3;
8181         bytebuff4 = (buff2 >> 32);
8182         *dst++ = bytebuff4;
8183         ready_bits -= 32;
8184
8185         /* shift in new bits */
8186         buff2 = ((buff2 << 32) | (buff1 >> ready_bits));
8187         }
8188       ready_bits += bps;
8189       }
8190     }
8191   while (ready_bits > 0)
8192     {
8193     bytebuff1 = (buff2 >> 56);
8194     *dst++ = bytebuff1;
8195     buff2 = (buff2 << 8);
8196     ready_bits -= 8;
8197     }
8198
8199   return (0);
8200   } /* end rotateContigSamples32bits */
8201
8202
8203 /* Rotate an image by a multiple of 90 degrees clockwise */
8204 static int
8205 rotateImage(uint16 rotation, struct image_data *image, uint32 *img_width,
8206             uint32 *img_length, unsigned char **ibuff_ptr)
8207   {
8208   int      shift_width;
8209   uint32   bytes_per_pixel, bytes_per_sample;
8210   uint32   row, rowsize, src_offset, dst_offset;
8211   uint32   i, col, width, length;
8212   uint32   colsize, buffsize, col_offset, pix_offset;
8213   unsigned char *ibuff;
8214   unsigned char *src;
8215   unsigned char *dst;
8216   uint16   spp, bps;
8217   float    res_temp;
8218   unsigned char *rbuff = NULL;
8219
8220   width  = *img_width;
8221   length = *img_length;
8222   spp = image->spp;
8223   bps = image->bps;
8224
8225   rowsize = ((bps * spp * width) + 7) / 8;
8226   colsize = ((bps * spp * length) + 7) / 8;
8227   if ((colsize * width) > (rowsize * length))
8228     buffsize = (colsize + 1) * width;
8229   else
8230     buffsize = (rowsize + 1) * length;
8231
8232   bytes_per_sample = (bps + 7) / 8;
8233   bytes_per_pixel  = ((bps * spp) + 7) / 8;
8234   if (bytes_per_pixel < (bytes_per_sample + 1))
8235     shift_width = bytes_per_pixel;
8236   else
8237     shift_width = bytes_per_sample + 1;
8238
8239   switch (rotation)
8240     {
8241     case 0:
8242     case 360: return (0);
8243     case 90:
8244     case 180:
8245     case 270: break;
8246     default:  TIFFError("rotateImage", "Invalid rotation angle %d", rotation);
8247               return (-1);
8248     }
8249
8250   if (!(rbuff = (unsigned char *)_TIFFmalloc(buffsize)))
8251     {
8252     TIFFError("rotateImage", "Unable to allocate rotation buffer of %1u bytes", buffsize);
8253     return (-1);
8254     }
8255   _TIFFmemset(rbuff, '\0', buffsize);
8256
8257   ibuff = *ibuff_ptr;
8258   switch (rotation)
8259     {
8260     case 180: if ((bps % 8) == 0) /* byte alligned data */
8261                 {
8262                 src = ibuff;
8263                 pix_offset = (spp * bps) / 8;
8264                 for (row = 0; row < length; row++)
8265                    {
8266                    dst_offset = (length - row - 1) * rowsize;
8267                    for (col = 0; col < width; col++)
8268                      {
8269                      col_offset = (width - col - 1) * pix_offset;
8270                      dst = rbuff + dst_offset + col_offset;
8271
8272                      for (i = 0; i  < bytes_per_pixel; i++)
8273                        *dst++ = *src++;
8274                      }
8275                    }
8276                 }
8277               else
8278                 { /* non 8 bit per sample data */
8279                 for (row = 0; row < length; row++)
8280                   {
8281                   src_offset = row * rowsize;
8282                   dst_offset = (length - row - 1) * rowsize;
8283                   src = ibuff + src_offset;
8284                   dst = rbuff + dst_offset;
8285                   switch (shift_width)
8286                     {
8287                     case 1: if (bps == 1)
8288                               {
8289                               if (reverseSamples8bits(spp, bps, width, src, dst))
8290                                 {
8291                                 _TIFFfree(rbuff);
8292                                 return (-1);
8293                                 }
8294                               break;
8295                               }
8296                             if (reverseSamples16bits(spp, bps, width, src, dst))
8297                               {
8298                               _TIFFfree(rbuff);
8299                               return (-1);
8300                               }
8301                              break;
8302                     case 2: if (reverseSamples24bits(spp, bps, width, src, dst))
8303                               {
8304                               _TIFFfree(rbuff);
8305                               return (-1);
8306                               }
8307                              break;
8308                     case 3:
8309                     case 4:
8310                     case 5: if (reverseSamples32bits(spp, bps, width, src, dst))
8311                               {
8312                               _TIFFfree(rbuff);
8313                               return (-1);
8314                               }
8315                              break;
8316                     default: TIFFError("rotateImage","Unsupported bit depth %d", bps);
8317                              _TIFFfree(rbuff);
8318                              return (-1);
8319                     }
8320                   }
8321                 }
8322               _TIFFfree(ibuff);
8323               *(ibuff_ptr) = rbuff;
8324               break;
8325
8326     case 90:  if ((bps % 8) == 0) /* byte aligned data */
8327                 {
8328                 for (col = 0; col < width; col++)
8329                   {
8330                   src_offset = ((length - 1) * rowsize) + (col * bytes_per_pixel);
8331                   dst_offset = col * colsize;
8332                   src = ibuff + src_offset;
8333                   dst = rbuff + dst_offset;
8334                   for (row = length; row > 0; row--)
8335                     {
8336                     for (i = 0; i < bytes_per_pixel; i++)
8337                       *dst++ = *(src + i);
8338                     src -= rowsize;
8339                     }
8340                   }
8341                 }
8342               else
8343                 { /* non 8 bit per sample data */
8344                 for (col = 0; col < width; col++)
8345                   {
8346                   src_offset = (length - 1) * rowsize;
8347                   dst_offset = col * colsize;
8348                   src = ibuff + src_offset;
8349                   dst = rbuff + dst_offset;
8350                   switch (shift_width)
8351                     {
8352                     case 1: if (bps == 1)
8353                               {
8354                               if (rotateContigSamples8bits(rotation, spp, bps, width,
8355                                                          length, col, src, dst))
8356                                 {
8357                                 _TIFFfree(rbuff);
8358                                 return (-1);
8359                                 }
8360                               break;
8361                               }
8362                             if (rotateContigSamples16bits(rotation, spp, bps, width,
8363                                                          length, col, src, dst))
8364                               {
8365                               _TIFFfree(rbuff);
8366                               return (-1);
8367                               }
8368                             break;
8369                     case 2: if (rotateContigSamples24bits(rotation, spp, bps, width,
8370                                                           length, col, src, dst))
8371                               {
8372                               _TIFFfree(rbuff);
8373                               return (-1);
8374                               }
8375                              break;
8376                     case 3:
8377                     case 4:
8378                     case 5: if (rotateContigSamples32bits(rotation, spp, bps, width,
8379                                                           length, col, src, dst))
8380                               {
8381                               _TIFFfree(rbuff);
8382                               return (-1);
8383                               }
8384                              break;
8385                     default: TIFFError("rotateImage","Unsupported bit depth %d", bps);
8386                              _TIFFfree(rbuff);
8387                              return (-1);
8388                     }
8389                   }
8390                 }
8391               _TIFFfree(ibuff);
8392               *(ibuff_ptr) = rbuff;
8393
8394               *img_width = length;
8395               *img_length = width;
8396               image->width = length;
8397               image->length = width;
8398               res_temp = image->xres;
8399               image->xres = image->yres;
8400               image->yres = res_temp;
8401               break;
8402
8403     case 270: if ((bps % 8) == 0) /* byte aligned data */
8404                 {
8405                 for (col = 0; col < width; col++)
8406                   {
8407                   src_offset = col * bytes_per_pixel;
8408                   dst_offset = (width - col - 1) * colsize;
8409                   src = ibuff + src_offset;
8410                   dst = rbuff + dst_offset;
8411                   for (row = length; row > 0; row--)
8412                     {
8413                     for (i = 0; i < bytes_per_pixel; i++)
8414                       *dst++ = *(src + i);
8415                     src += rowsize;
8416                     }
8417                   }
8418                 }
8419               else
8420                 { /* non 8 bit per sample data */
8421                 for (col = 0; col < width; col++)
8422                   {
8423                   src_offset = 0;
8424                   dst_offset = (width - col - 1) * colsize;
8425                   src = ibuff + src_offset;
8426                   dst = rbuff + dst_offset;
8427                   switch (shift_width)
8428                     {
8429                     case 1: if (bps == 1)
8430                               {
8431                               if (rotateContigSamples8bits(rotation, spp, bps, width,
8432                                                          length, col, src, dst))
8433                                 {
8434                                 _TIFFfree(rbuff);
8435                                 return (-1);
8436                                 }
8437                               break;
8438                               }
8439                             if (rotateContigSamples16bits(rotation, spp, bps, width,
8440                                                          length, col, src, dst))
8441                               {
8442                               _TIFFfree(rbuff);
8443                               return (-1);
8444                               }
8445                             break;
8446                     case 2: if (rotateContigSamples24bits(rotation, spp, bps, width,
8447                                                           length, col, src, dst))
8448                               {
8449                               _TIFFfree(rbuff);
8450                               return (-1);
8451                               }
8452                              break;
8453                     case 3:
8454                     case 4:
8455                     case 5: if (rotateContigSamples32bits(rotation, spp, bps, width,
8456                                                           length, col, src, dst))
8457                               {
8458                               _TIFFfree(rbuff);
8459                               return (-1);
8460                               }
8461                              break;
8462                     default: TIFFError("rotateImage","Unsupported bit depth %d", bps);
8463                              _TIFFfree(rbuff);
8464                              return (-1);
8465                     }
8466                   }
8467                 }
8468               _TIFFfree(ibuff);
8469               *(ibuff_ptr) = rbuff;
8470
8471               *img_width = length;
8472               *img_length = width;
8473               image->width = length;
8474               image->length = width;
8475               res_temp = image->xres;
8476               image->xres = image->yres;
8477               image->yres = res_temp;
8478               break;
8479     default:
8480               break;
8481     }
8482
8483   return (0);
8484   } /* end rotateImage */
8485
8486 static int
8487 reverseSamples8bits (uint16 spp, uint16 bps, uint32 width,
8488                      uint8 *ibuff, uint8 *obuff)
8489   {
8490   int      ready_bits = 0;
8491   uint32   col;
8492   uint32   src_byte, src_bit;
8493   uint32   bit_offset = 0;
8494   uint8    match_bits = 0, mask_bits = 0;
8495   uint8    buff1 = 0, buff2 = 0;
8496   unsigned char *src;
8497   unsigned char *dst;
8498   tsample_t sample;
8499
8500   if ((ibuff == NULL) || (obuff == NULL))
8501     {
8502     TIFFError("reverseSamples8bits","Invalid image or work buffer");
8503     return (1);
8504     }
8505
8506   ready_bits = 0;
8507   mask_bits =  (uint8)-1 >> ( 8 - bps);
8508   dst = obuff;
8509   for (col = width; col > 0; col--)
8510     {
8511     /* Compute src byte(s) and bits within byte(s) */
8512     bit_offset = (col - 1) * bps * spp;
8513     for (sample = 0; sample < spp; sample++)
8514       {
8515       if (sample == 0)
8516         {
8517         src_byte = bit_offset / 8;
8518         src_bit  = bit_offset % 8;
8519         }
8520       else
8521         {
8522         src_byte = (bit_offset + (sample * bps)) / 8;
8523         src_bit  = (bit_offset + (sample * bps)) % 8;
8524         }
8525
8526       src = ibuff + src_byte;
8527       match_bits = mask_bits << (8 - src_bit - bps);
8528       buff1 = ((*src) & match_bits) << (src_bit);
8529
8530       if (ready_bits < 8)
8531         buff2 = (buff2 | (buff1 >> ready_bits));
8532       else  /* If we have a full buffer's worth, write it out */
8533         {
8534         *dst++ = buff2;
8535         buff2 = buff1;
8536         ready_bits -= 8;
8537         }
8538       ready_bits += bps;
8539       }
8540     }
8541   if (ready_bits > 0)
8542     {
8543     buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits)));
8544     *dst++ = buff1;
8545     }
8546
8547   return (0);
8548   } /* end reverseSamples8bits */
8549
8550
8551 static int
8552 reverseSamples16bits (uint16 spp, uint16 bps, uint32 width,
8553                       uint8 *ibuff, uint8 *obuff)
8554   {
8555   int      ready_bits = 0;
8556   uint32   col;
8557   uint32   src_byte = 0, high_bit = 0;
8558   uint32   bit_offset = 0;
8559   uint16   match_bits = 0, mask_bits = 0;
8560   uint16   buff1 = 0, buff2 = 0;
8561   uint8    bytebuff = 0;
8562   unsigned char *src;
8563   unsigned char *dst;
8564   tsample_t sample;
8565
8566   if ((ibuff == NULL) || (obuff == NULL))
8567     {
8568     TIFFError("reverseSample16bits","Invalid image or work buffer");
8569     return (1);
8570     }
8571
8572   ready_bits = 0;
8573   mask_bits =  (uint16)-1 >> (16 - bps);
8574   dst = obuff;
8575   for (col = width; col > 0; col--)
8576     {
8577     /* Compute src byte(s) and bits within byte(s) */
8578     bit_offset = (col - 1) * bps * spp;
8579     for (sample = 0; sample < spp; sample++)
8580       {
8581       if (sample == 0)
8582         {
8583         src_byte = bit_offset / 8;
8584         high_bit  = bit_offset % 8;
8585         }
8586       else
8587         {
8588         src_byte = (bit_offset + (sample * bps)) / 8;
8589         high_bit  = (bit_offset + (sample * bps)) % 8;
8590         }
8591
8592       src = ibuff + src_byte;
8593       match_bits = mask_bits << (16 - high_bit - bps);
8594       if (little_endian)
8595         buff1 = (src[0] << 8) | src[1];
8596       else
8597         buff1 = (src[1] << 8) | src[0];
8598       buff1 = (buff1 & match_bits) << (high_bit);
8599
8600       if (ready_bits < 8)
8601         { /* add another bps bits to the buffer */
8602         bytebuff = 0;
8603         buff2 = (buff2 | (buff1 >> ready_bits));
8604         }
8605       else /* If we have a full buffer's worth, write it out */
8606         {
8607         bytebuff = (buff2 >> 8);
8608         *dst++ = bytebuff;
8609         ready_bits -= 8;
8610         /* shift in new bits */
8611         buff2 = ((buff2 << 8) | (buff1 >> ready_bits));
8612         }
8613       ready_bits += bps;
8614       }
8615     }
8616
8617   if (ready_bits > 0)
8618     {
8619     bytebuff = (buff2 >> 8);
8620     *dst++ = bytebuff;
8621     }
8622
8623   return (0);
8624   } /* end reverseSamples16bits */
8625
8626 static int
8627 reverseSamples24bits (uint16 spp, uint16 bps, uint32 width,
8628                       uint8 *ibuff, uint8 *obuff)
8629   {
8630   int      ready_bits = 0;
8631   uint32   col;
8632   uint32   src_byte = 0, high_bit = 0;
8633   uint32   bit_offset = 0;
8634   uint32   match_bits = 0, mask_bits = 0;
8635   uint32   buff1 = 0, buff2 = 0;
8636   uint8    bytebuff1 = 0, bytebuff2 = 0;
8637   unsigned char *src;
8638   unsigned char *dst;
8639   tsample_t sample;
8640
8641   if ((ibuff == NULL) || (obuff == NULL))
8642     {
8643     TIFFError("reverseSamples24bits","Invalid image or work buffer");
8644     return (1);
8645     }
8646
8647   ready_bits = 0;
8648   mask_bits =  (uint32)-1 >> (32 - bps);
8649   dst = obuff;
8650   for (col = width; col > 0; col--)
8651     {
8652     /* Compute src byte(s) and bits within byte(s) */
8653     bit_offset = (col - 1) * bps * spp;
8654     for (sample = 0; sample < spp; sample++)
8655       {
8656       if (sample == 0)
8657         {
8658         src_byte = bit_offset / 8;
8659         high_bit  = bit_offset % 8;
8660         }
8661       else
8662         {
8663         src_byte = (bit_offset + (sample * bps)) / 8;
8664         high_bit  = (bit_offset + (sample * bps)) % 8;
8665         }
8666
8667       src = ibuff + src_byte;
8668       match_bits = mask_bits << (32 - high_bit - bps);
8669       if (little_endian)
8670         buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
8671       else
8672         buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
8673       buff1 = (buff1 & match_bits) << (high_bit);
8674
8675       if (ready_bits < 16)
8676         { /* add another bps bits to the buffer */
8677         bytebuff1 = bytebuff2 = 0;
8678         buff2 = (buff2 | (buff1 >> ready_bits));
8679         }
8680       else /* If we have a full buffer's worth, write it out */
8681         {
8682         bytebuff1 = (buff2 >> 24);
8683         *dst++ = bytebuff1;
8684         bytebuff2 = (buff2 >> 16);
8685         *dst++ = bytebuff2;
8686         ready_bits -= 16;
8687
8688         /* shift in new bits */
8689         buff2 = ((buff2 << 16) | (buff1 >> ready_bits));
8690         }
8691       ready_bits += bps;
8692       }
8693     }
8694
8695  /* catch any trailing bits at the end of the line */
8696   while (ready_bits > 0)
8697     {
8698     bytebuff1 = (buff2 >> 24);
8699     *dst++ = bytebuff1;
8700
8701     buff2 = (buff2 << 8);
8702     bytebuff2 = bytebuff1;
8703     ready_bits -= 8;
8704     }
8705
8706   return (0);
8707   } /* end reverseSamples24bits */
8708
8709
8710 static int
8711 reverseSamples32bits (uint16 spp, uint16 bps, uint32 width,
8712                       uint8 *ibuff, uint8 *obuff)
8713   {
8714   int    ready_bits = 0, shift_width = 0;
8715   int    bytes_per_sample, bytes_per_pixel;
8716   uint32 bit_offset;
8717   uint32 src_byte = 0, high_bit = 0;
8718   uint32 col;
8719   uint32 longbuff1 = 0, longbuff2 = 0;
8720   uint64 mask_bits = 0, match_bits = 0;
8721   uint64 buff1 = 0, buff2 = 0, buff3 = 0;
8722   uint8  bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0;
8723   unsigned char *src;
8724   unsigned char *dst;
8725   tsample_t sample;
8726
8727   if ((ibuff == NULL) || (obuff == NULL))
8728     {
8729     TIFFError("reverseSamples32bits","Invalid image or work buffer");
8730     return (1);
8731     }
8732
8733   ready_bits = 0;
8734   mask_bits =  (uint64)-1 >> (64 - bps);
8735   dst = obuff;
8736
8737   bytes_per_sample = (bps + 7) / 8;
8738   bytes_per_pixel  = ((bps * spp) + 7) / 8;
8739   if (bytes_per_pixel < (bytes_per_sample + 1))
8740     shift_width = bytes_per_pixel;
8741   else
8742     shift_width = bytes_per_sample + 1;
8743
8744   for (col = width; col > 0; col--)
8745     {
8746     /* Compute src byte(s) and bits within byte(s) */
8747     bit_offset = (col - 1) * bps * spp;
8748     for (sample = 0; sample < spp; sample++)
8749       {
8750       if (sample == 0)
8751         {
8752         src_byte = bit_offset / 8;
8753         high_bit  = bit_offset % 8;
8754         }
8755       else
8756         {
8757         src_byte = (bit_offset + (sample * bps)) / 8;
8758         high_bit  = (bit_offset + (sample * bps)) % 8;
8759         }
8760
8761       src = ibuff + src_byte;
8762       match_bits = mask_bits << (64 - high_bit - bps);
8763       if (little_endian)
8764         {
8765         longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3];
8766         longbuff2 = longbuff1;
8767         }
8768       else
8769         {
8770         longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0];
8771         longbuff2 = longbuff1;
8772         }
8773       buff3 = ((uint64)longbuff1 << 32) | longbuff2;
8774       buff1 = (buff3 & match_bits) << (high_bit);
8775
8776       if (ready_bits < 32)
8777         { /* add another bps bits to the buffer */
8778         bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0;
8779         buff2 = (buff2 | (buff1 >> ready_bits));
8780         }
8781       else /* If we have a full buffer's worth, write it out */
8782         {
8783         bytebuff1 = (buff2 >> 56);
8784         *dst++ = bytebuff1;
8785         bytebuff2 = (buff2 >> 48);
8786         *dst++ = bytebuff2;
8787         bytebuff3 = (buff2 >> 40);
8788         *dst++ = bytebuff3;
8789         bytebuff4 = (buff2 >> 32);
8790         *dst++ = bytebuff4;
8791         ready_bits -= 32;
8792
8793         /* shift in new bits */
8794         buff2 = ((buff2 << 32) | (buff1 >> ready_bits));
8795         }
8796       ready_bits += bps;
8797       }
8798     }
8799   while (ready_bits > 0)
8800     {
8801     bytebuff1 = (buff2 >> 56);
8802     *dst++ = bytebuff1;
8803     buff2 = (buff2 << 8);
8804     ready_bits -= 8;
8805     }
8806
8807   return (0);
8808   } /* end reverseSamples32bits */
8809
8810 static int
8811 reverseSamplesBytes (uint16 spp, uint16 bps, uint32 width,
8812                      uint8 *src, uint8 *dst)
8813   {
8814   int i;
8815   uint32  col, bytes_per_pixel, col_offset;
8816   uint8   bytebuff1;
8817   unsigned char swapbuff[32];
8818
8819   if ((src == NULL) || (dst == NULL))
8820     {
8821     TIFFError("reverseSamplesBytes","Invalid input or output buffer");
8822     return (1);
8823     }
8824
8825   bytes_per_pixel  = ((bps * spp) + 7) / 8;
8826   switch (bps / 8)
8827      {
8828      case 8:  /* Use memcpy for multiple bytes per sample data */
8829      case 4:
8830      case 3:
8831      case 2: for (col = 0; col < (width / 2); col++)
8832                {
8833                col_offset = col * bytes_per_pixel;
8834                _TIFFmemcpy (swapbuff, src + col_offset, bytes_per_pixel);
8835                _TIFFmemcpy (src + col_offset, dst - col_offset - bytes_per_pixel, bytes_per_pixel);
8836                _TIFFmemcpy (dst - col_offset - bytes_per_pixel, swapbuff, bytes_per_pixel);
8837                }
8838              break;
8839      case 1: /* Use byte copy only for single byte per sample data */
8840              for (col = 0; col < (width / 2); col++)
8841                {
8842                for (i = 0; i < spp; i++)
8843                   {
8844                   bytebuff1 = *src;
8845                   *src++ = *(dst - spp + i);
8846                   *(dst - spp + i) = bytebuff1;
8847                   }
8848                 dst -= spp;
8849                 }
8850              break;
8851      default: TIFFError("reverseSamplesBytes","Unsupported bit depth %d", bps);
8852        return (1);
8853      }
8854   return (0);
8855   } /* end reverseSamplesBytes */
8856
8857
8858 /* Mirror an image horizontally or vertically */
8859 static int
8860 mirrorImage(uint16 spp, uint16 bps, uint16 mirror, uint32 width, uint32 length, unsigned char *ibuff)
8861   {
8862   int      shift_width;
8863   uint32   bytes_per_pixel, bytes_per_sample;
8864   uint32   row, rowsize, row_offset;
8865   unsigned char *line_buff = NULL;
8866   unsigned char *src;
8867   unsigned char *dst;
8868
8869   src = ibuff;
8870   rowsize = ((width * bps * spp) + 7) / 8;
8871   switch (mirror)
8872     {
8873     case MIRROR_BOTH:
8874     case MIRROR_VERT:
8875              line_buff = (unsigned char *)_TIFFmalloc(rowsize);
8876              if (line_buff == NULL)
8877                {
8878                TIFFError ("mirrorImage", "Unable to allocate mirror line buffer of %1u bytes", rowsize);
8879                return (-1);
8880                }
8881
8882              dst = ibuff + (rowsize * (length - 1));
8883              for (row = 0; row < length / 2; row++)
8884                {
8885               _TIFFmemcpy(line_buff, src, rowsize);
8886               _TIFFmemcpy(src, dst,  rowsize);
8887               _TIFFmemcpy(dst, line_buff, rowsize);
8888                src += (rowsize);
8889                dst -= (rowsize);
8890                }
8891              if (line_buff)
8892                _TIFFfree(line_buff);
8893              if (mirror == MIRROR_VERT)
8894                break;
8895     case MIRROR_HORIZ :
8896               if ((bps % 8) == 0) /* byte alligned data */
8897                 {
8898                 for (row = 0; row < length; row++)
8899                   {
8900                   row_offset = row * rowsize;
8901                   src = ibuff + row_offset;
8902                   dst = ibuff + row_offset + rowsize;
8903                   if (reverseSamplesBytes(spp, bps, width, src, dst))
8904                     {
8905                     return (-1);
8906                     }
8907                   }
8908                 }
8909               else
8910                 { /* non 8 bit per sample  data */
8911                 if (!(line_buff = (unsigned char *)_TIFFmalloc(rowsize + 1)))
8912                   {
8913                   TIFFError("mirrorImage", "Unable to allocate mirror line buffer");
8914                   return (-1);
8915                   }
8916                 bytes_per_sample = (bps + 7) / 8;
8917                 bytes_per_pixel  = ((bps * spp) + 7) / 8;
8918                 if (bytes_per_pixel < (bytes_per_sample + 1))
8919                   shift_width = bytes_per_pixel;
8920                 else
8921                   shift_width = bytes_per_sample + 1;
8922
8923                 for (row = 0; row < length; row++)
8924                   {
8925                   row_offset = row * rowsize;
8926                   src = ibuff + row_offset;
8927                   _TIFFmemset (line_buff, '\0', rowsize);
8928                   switch (shift_width)
8929                     {
8930                     case 1: if (reverseSamples16bits(spp, bps, width, src, line_buff))
8931                               {
8932                               _TIFFfree(line_buff);
8933                               return (-1);
8934                               }
8935                              _TIFFmemcpy (src, line_buff, rowsize);
8936                              break;
8937                     case 2: if (reverseSamples24bits(spp, bps, width, src, line_buff))
8938                               {
8939                               _TIFFfree(line_buff);
8940                               return (-1);
8941                               }
8942                              _TIFFmemcpy (src, line_buff, rowsize);
8943                              break;
8944                     case 3:
8945                     case 4:
8946                     case 5: if (reverseSamples32bits(spp, bps, width, src, line_buff))
8947                               {
8948                               _TIFFfree(line_buff);
8949                               return (-1);
8950                               }
8951                              _TIFFmemcpy (src, line_buff, rowsize);
8952                              break;
8953                     default: TIFFError("mirrorImage","Unsupported bit depth %d", bps);
8954                              _TIFFfree(line_buff);
8955                              return (-1);
8956                     }
8957                   }
8958                 if (line_buff)
8959                   _TIFFfree(line_buff);
8960                 }
8961              break;
8962
8963     default: TIFFError ("mirrorImage", "Invalid mirror axis %d", mirror);
8964              return (-1);
8965              break;
8966     }
8967
8968   return (0);
8969   }
8970
8971 /* Invert the light and dark values for a bilevel or grayscale image */
8972 static int
8973 invertImage(uint16 photometric, uint16 spp, uint16 bps, uint32 width, uint32 length, unsigned char *work_buff)
8974   {
8975   uint32   row, col;
8976   unsigned char  bytebuff1, bytebuff2, bytebuff3, bytebuff4;
8977   unsigned char *src;
8978   uint16        *src_uint16;
8979   uint32        *src_uint32;
8980
8981   if (spp != 1)
8982     {
8983     TIFFError("invertImage", "Image inversion not supported for more than one sample per pixel");
8984     return (-1);
8985     }
8986
8987   if (photometric !=  PHOTOMETRIC_MINISWHITE && photometric !=  PHOTOMETRIC_MINISBLACK)
8988     {
8989     TIFFError("invertImage", "Only black and white and grayscale images can be inverted");
8990     return (-1);
8991     }
8992
8993   src = work_buff;
8994   if (src == NULL)
8995     {
8996     TIFFError ("invertImage", "Invalid crop buffer passed to invertImage");
8997     return (-1);
8998     }
8999
9000   switch (bps)
9001     {
9002     case 32: src_uint32 = (uint32 *)src;
9003              for (row = 0; row < length; row++)
9004                for (col = 0; col < width; col++)
9005                  {
9006                  *src_uint32 = (uint32)0xFFFFFFFF - *src_uint32;
9007                   src_uint32++;
9008                  }
9009             break;
9010     case 16: src_uint16 = (uint16 *)src;
9011              for (row = 0; row < length; row++)
9012                for (col = 0; col < width; col++)
9013                  {
9014                  *src_uint16 = (uint16)0xFFFF - *src_uint16;
9015                   src_uint16++;
9016                  }
9017             break;
9018     case 8: for (row = 0; row < length; row++)
9019               for (col = 0; col < width; col++)
9020                 {
9021                 *src = (uint8)255 - *src;
9022                  src++;
9023                 }
9024             break;
9025     case 4: for (row = 0; row < length; row++)
9026               for (col = 0; col < width; col++)
9027                 {
9028                 bytebuff1 = 16 - (uint8)(*src & 240 >> 4);
9029                 bytebuff2 = 16 - (*src & 15);
9030                 *src = bytebuff1 << 4 & bytebuff2;
9031                 src++;
9032                 }
9033             break;
9034     case 2: for (row = 0; row < length; row++)
9035               for (col = 0; col < width; col++)
9036                 {
9037                 bytebuff1 = 4 - (uint8)(*src & 192 >> 6);
9038                 bytebuff2 = 4 - (uint8)(*src & 48  >> 4);
9039                 bytebuff3 = 4 - (uint8)(*src & 12  >> 2);
9040                 bytebuff4 = 4 - (uint8)(*src & 3);
9041                 *src = (bytebuff1 << 6) || (bytebuff2 << 4) || (bytebuff3 << 2) || bytebuff4;
9042                 src++;
9043                 }
9044             break;
9045     case 1: for (row = 0; row < length; row++)
9046               for (col = 0; col < width; col += 8 /(spp * bps))
9047                 {
9048                 *src = ~(*src);
9049                 src++;
9050                 }
9051             break;
9052     default: TIFFError("invertImage", "Unsupported bit depth %d", bps);
9053       return (-1);
9054     }
9055
9056   return (0);
9057   }
9058
9059 /* vim: set ts=8 sts=8 sw=8 noet: */
9060 /*
9061  * Local Variables:
9062  * mode: c
9063  * c-basic-offset: 8
9064  * fill-column: 78
9065  * End:
9066  */