From d479dd1aab1c1cb907932c6595b0ef33523fc797 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Fri, 6 Nov 2015 07:14:47 +0100 Subject: Imported Upstream version 1.8.3 --- tiff/tools/tiffcrop.c | 9091 ------------------------------------------------- 1 file changed, 9091 deletions(-) delete mode 100755 tiff/tools/tiffcrop.c (limited to 'tiff/tools/tiffcrop.c') diff --git a/tiff/tools/tiffcrop.c b/tiff/tools/tiffcrop.c deleted file mode 100755 index 1d6b561..0000000 --- a/tiff/tools/tiffcrop.c +++ /dev/null @@ -1,9091 +0,0 @@ -/* $Id: tiffcrop.c,v 1.25 2014-12-26 16:32:32 bfriesen Exp $ */ - -/* tiffcrop.c -- a port of tiffcp.c extended to include manipulations of - * the image data through additional options listed below - * - * Original code: - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-1997 Silicon Graphics, Inc. - * Additions (c) Richard Nolde 2006-2010 - * - * Permission to use, copy, modify, distribute, and sell this software and - * its documentation for any purpose is hereby granted without fee, provided - * that (i) the above copyright notices and this permission notice appear in - * all copies of the software and related documentation, and (ii) the names of - * Sam Leffler and Silicon Graphics may not be used in any advertising or - * publicity relating to the software without the specific, prior written - * permission of Sam Leffler and Silicon Graphics. - * - * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, - * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY - * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. - * - * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS OR ANY OTHER COPYRIGHT - * HOLDERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL - * DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, - * DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND - * ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE - * OR PERFORMANCE OF THIS SOFTWARE. - * - * Some portions of the current code are derived from tiffcp, primarly in - * the areas of lowlevel reading and writing of TAGS, scanlines and tiles though - * some of the original functions have been extended to support arbitrary bit - * depths. These functions are presented at the top of this file. - * - * Add support for the options below to extract sections of image(s) - * and to modify the whole image or selected portions of each image by - * rotations, mirroring, and colorscale/colormap inversion of selected - * types of TIFF images when appropriate. Some color model dependent - * functions are restricted to bilevel or 8 bit per sample data. - * See the man page for the full explanations. - * - * New Options: - * -h Display the syntax guide. - * -v Report the version and last build date for tiffcrop and libtiff. - * -z x1,y1,x2,y2:x3,y3,x4,y4:..xN,yN,xN + 1, yN + 1 - * Specify a series of coordinates to define rectangular - * regions by the top left and lower right corners. - * -e c|d|i|m|s export mode for images and selections from input images - * combined All images and selections are written to a single file (default) - * with multiple selections from one image combined into a single image - * divided All images and selections are written to a single file - * with each selection from one image written to a new image - * image Each input image is written to a new file (numeric filename sequence) - * with multiple selections from the image combined into one image - * multiple Each input image is written to a new file (numeric filename sequence) - * with each selection from the image written to a new image - * separated Individual selections from each image are written to separate files - * -U units [in, cm, px ] inches, centimeters or pixels - * -H # Set horizontal resolution of output images to # - * -V # Set vertical resolution of output images to # - * -J # Horizontal margin of output page to # expressed in current - * units when sectioning image into columns x rows - * using the -S cols:rows option. - * -K # Vertical margin of output page to # expressed in current - * units when sectioning image into columns x rows - * using the -S cols:rows option. - * -X # Horizontal dimension of region to extract expressed in current - * units - * -Y # Vertical dimension of region to extract expressed in current - * units - * -O orient Orientation for output image, portrait, landscape, auto - * -P page Page size for output image segments, eg letter, legal, tabloid, - * etc. - * -S cols:rows Divide the image into equal sized segments using cols across - * and rows down - * -E t|l|r|b Edge to use as origin - * -m #,#,#,# Margins from edges for selection: top, left, bottom, right - * (commas separated) - * -Z #:#,#:# Zones of the image designated as zone X of Y, - * eg 1:3 would be first of three equal portions measured - * from reference edge - * -N odd|even|#,#-#,#|last - * Select sequences and/or ranges of images within file - * to process. The words odd or even may be used to specify - * all odd or even numbered images the word last may be used - * in place of a number in the sequence to indicate the final - * image in the file without knowing how many images there are. - * -R # Rotate image or crop selection by 90,180,or 270 degrees - * clockwise - * -F h|v Flip (mirror) image or crop selection horizontally - * or vertically - * -I [black|white|data|both] - * Invert color space, eg dark to light for bilevel and grayscale images - * If argument is white or black, set the PHOTOMETRIC_INTERPRETATION - * tag to MinIsBlack or MinIsWhite without altering the image data - * If the argument is data or both, the image data are modified: - * both inverts the data and the PHOTOMETRIC_INTERPRETATION tag, - * data inverts the data but not the PHOTOMETRIC_INTERPRETATION tag - * -D input:,output:,format:,level:N,debug:N - * Dump raw data for input and/or output images to individual files - * in raw (binary) format or text (ASCII) representing binary data - * as strings of 1s and 0s. The filename arguments are used as stems - * from which individual files are created for each image. Text format - * includes annotations for image parameters and scanline info. Level - * selects which functions dump data, with higher numbers selecting - * lower level, scanline level routines. Debug reports a limited set - * of messages to monitor progess without enabling dump logs. - */ - -static char tiffcrop_version_id[] = "2.4"; -static char tiffcrop_rev_date[] = "12-13-2010"; - -#include "tif_config.h" -#include "tiffiop.h" - -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef HAVE_UNISTD_H -# include -#endif - -#ifdef HAVE_STDINT_H -# include -#endif - -#ifndef HAVE_GETOPT -extern int getopt(int, char**, char*); -#endif - -#ifdef NEED_LIBPORT -# include "libport.h" -#endif - -#include "tiffio.h" - -#if defined(VMS) -# define unlink delete -#endif - -#ifndef PATH_MAX -#define PATH_MAX 1024 -#endif - -#ifndef streq -#define streq(a,b) (strcmp((a),(b)) == 0) -#endif -#define strneq(a,b,n) (strncmp((a),(b),(n)) == 0) - -#define TRUE 1 -#define FALSE 0 - -#ifndef TIFFhowmany -#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) -#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3) -#endif - -/* - * Definitions and data structures required to support cropping and image - * manipulations. - */ - -#define EDGE_TOP 1 -#define EDGE_LEFT 2 -#define EDGE_BOTTOM 3 -#define EDGE_RIGHT 4 -#define EDGE_CENTER 5 - -#define MIRROR_HORIZ 1 -#define MIRROR_VERT 2 -#define MIRROR_BOTH 3 -#define ROTATECW_90 8 -#define ROTATECW_180 16 -#define ROTATECW_270 32 -#define ROTATE_ANY ROTATECW_90 || ROTATECW_180 || ROTATECW_270 - -#define CROP_NONE 0 -#define CROP_MARGINS 1 -#define CROP_WIDTH 2 -#define CROP_LENGTH 4 -#define CROP_ZONES 8 -#define CROP_REGIONS 16 -#define CROP_ROTATE 32 -#define CROP_MIRROR 64 -#define CROP_INVERT 128 - -/* Modes for writing out images and selections */ -#define ONE_FILE_COMPOSITE 0 /* One file, sections combined sections */ -#define ONE_FILE_SEPARATED 1 /* One file, sections to new IFDs */ -#define FILE_PER_IMAGE_COMPOSITE 2 /* One file per image, combined sections */ -#define FILE_PER_IMAGE_SEPARATED 3 /* One file per input image */ -#define FILE_PER_SELECTION 4 /* One file per selection */ - -#define COMPOSITE_IMAGES 0 /* Selections combined into one image */ -#define SEPARATED_IMAGES 1 /* Selections saved to separate images */ - -#define STRIP 1 -#define TILE 2 - -#define MAX_REGIONS 8 /* number of regions to extract from a single page */ -#define MAX_OUTBUFFS 8 /* must match larger of zones or regions */ -#define MAX_SECTIONS 32 /* number of sections per page to write to output */ -#define MAX_IMAGES 2048 /* number of images in descrete list, not in the file */ -#define MAX_SAMPLES 8 /* maximum number of samples per pixel supported */ -#define MAX_BITS_PER_SAMPLE 64 /* maximum bit depth supported */ -#define MAX_EXPORT_PAGES 999999 /* maximum number of export pages per file */ - -#define DUMP_NONE 0 -#define DUMP_TEXT 1 -#define DUMP_RAW 2 - -/* Offsets into buffer for margins and fixed width and length segments */ -struct offset { - uint32 tmargin; - uint32 lmargin; - uint32 bmargin; - uint32 rmargin; - uint32 crop_width; - uint32 crop_length; - uint32 startx; - uint32 endx; - uint32 starty; - uint32 endy; -}; - -/* Description of a zone within the image. Position 1 of 3 zones would be - * the first third of the image. These are computed after margins and - * width/length requests are applied so that you can extract multiple - * zones from within a larger region for OCR or barcode recognition. - */ - -struct buffinfo { - uint32 size; /* size of this buffer */ - unsigned char *buffer; /* address of the allocated buffer */ -}; - -struct zone { - int position; /* ordinal of segment to be extracted */ - int total; /* total equal sized divisions of crop area */ - }; - -struct pageseg { - uint32 x1; /* index of left edge */ - uint32 x2; /* index of right edge */ - uint32 y1; /* index of top edge */ - uint32 y2; /* index of bottom edge */ - int position; /* ordinal of segment to be extracted */ - int total; /* total equal sized divisions of crop area */ - uint32 buffsize; /* size of buffer needed to hold the cropped zone */ -}; - -struct coordpairs { - double X1; /* index of left edge in current units */ - double X2; /* index of right edge in current units */ - double Y1; /* index of top edge in current units */ - double Y2; /* index of bottom edge in current units */ -}; - -struct region { - uint32 x1; /* pixel offset of left edge */ - uint32 x2; /* pixel offset of right edge */ - uint32 y1; /* pixel offset of top edge */ - uint32 y2; /* picel offset of bottom edge */ - uint32 width; /* width in pixels */ - uint32 length; /* length in pixels */ - uint32 buffsize; /* size of buffer needed to hold the cropped region */ - unsigned char *buffptr; /* address of start of the region */ -}; - -/* Cropping parameters from command line and image data - * Note: This should be renamed to proc_opts and expanded to include all current globals - * if possible, but each function that accesses global variables will have to be redone. - */ -struct crop_mask { - double width; /* Selection width for master crop region in requested units */ - double length; /* Selection length for master crop region in requesed units */ - double margins[4]; /* Top, left, bottom, right margins */ - float xres; /* Horizontal resolution read from image*/ - float yres; /* Vertical resolution read from image */ - uint32 combined_width; /* Width of combined cropped zones */ - uint32 combined_length; /* Length of combined cropped zones */ - uint32 bufftotal; /* Size of buffer needed to hold all the cropped region */ - uint16 img_mode; /* Composite or separate images created from zones or regions */ - uint16 exp_mode; /* Export input images or selections to one or more files */ - uint16 crop_mode; /* Crop options to be applied */ - uint16 res_unit; /* Resolution unit for margins and selections */ - uint16 edge_ref; /* Reference edge for sections extraction and combination */ - uint16 rotation; /* Clockwise rotation of the extracted region or image */ - uint16 mirror; /* Mirror extracted region or image horizontally or vertically */ - uint16 invert; /* Invert the color map of image or region */ - uint16 photometric; /* Status of photometric interpretation for inverted image */ - uint16 selections; /* Number of regions or zones selected */ - uint16 regions; /* Number of regions delimited by corner coordinates */ - struct region regionlist[MAX_REGIONS]; /* Regions within page or master crop region */ - uint16 zones; /* Number of zones delimited by Ordinal:Total requested */ - struct zone zonelist[MAX_REGIONS]; /* Zones indices to define a region */ - struct coordpairs corners[MAX_REGIONS]; /* Coordinates of upper left and lower right corner */ -}; - -#define MAX_PAPERNAMES 49 -#define MAX_PAPERNAME_LENGTH 15 -#define DEFAULT_RESUNIT RESUNIT_INCH -#define DEFAULT_PAGE_HEIGHT 14.0 -#define DEFAULT_PAGE_WIDTH 8.5 -#define DEFAULT_RESOLUTION 300 -#define DEFAULT_PAPER_SIZE "legal" - -#define ORIENTATION_NONE 0 -#define ORIENTATION_PORTRAIT 1 -#define ORIENTATION_LANDSCAPE 2 -#define ORIENTATION_SEASCAPE 4 -#define ORIENTATION_AUTO 16 - -#define PAGE_MODE_NONE 0 -#define PAGE_MODE_RESOLUTION 1 -#define PAGE_MODE_PAPERSIZE 2 -#define PAGE_MODE_MARGINS 4 -#define PAGE_MODE_ROWSCOLS 8 - -#define INVERT_DATA_ONLY 10 -#define INVERT_DATA_AND_TAG 11 - -struct paperdef { - char name[MAX_PAPERNAME_LENGTH]; - double width; - double length; - double asratio; - }; - -/* European page sizes corrected from update sent by - * thomas . jarosch @ intra2net . com on 5/7/2010 - * Paper Size Width Length Aspect Ratio */ -struct paperdef PaperTable[MAX_PAPERNAMES] = { - {"default", 8.500, 14.000, 0.607}, - {"pa4", 8.264, 11.000, 0.751}, - {"letter", 8.500, 11.000, 0.773}, - {"legal", 8.500, 14.000, 0.607}, - {"half-letter", 8.500, 5.514, 1.542}, - {"executive", 7.264, 10.528, 0.690}, - {"tabloid", 11.000, 17.000, 0.647}, - {"11x17", 11.000, 17.000, 0.647}, - {"ledger", 17.000, 11.000, 1.545}, - {"archa", 9.000, 12.000, 0.750}, - {"archb", 12.000, 18.000, 0.667}, - {"archc", 18.000, 24.000, 0.750}, - {"archd", 24.000, 36.000, 0.667}, - {"arche", 36.000, 48.000, 0.750}, - {"csheet", 17.000, 22.000, 0.773}, - {"dsheet", 22.000, 34.000, 0.647}, - {"esheet", 34.000, 44.000, 0.773}, - {"superb", 11.708, 17.042, 0.687}, - {"commercial", 4.139, 9.528, 0.434}, - {"monarch", 3.889, 7.528, 0.517}, - {"envelope-dl", 4.333, 8.681, 0.499}, - {"envelope-c5", 6.389, 9.028, 0.708}, - {"europostcard", 4.139, 5.833, 0.710}, - {"a0", 33.110, 46.811, 0.707}, - {"a1", 23.386, 33.110, 0.706}, - {"a2", 16.535, 23.386, 0.707}, - {"a3", 11.693, 16.535, 0.707}, - {"a4", 8.268, 11.693, 0.707}, - {"a5", 5.827, 8.268, 0.705}, - {"a6", 4.134, 5.827, 0.709}, - {"a7", 2.913, 4.134, 0.705}, - {"a8", 2.047, 2.913, 0.703}, - {"a9", 1.457, 2.047, 0.712}, - {"a10", 1.024, 1.457, 0.703}, - {"b0", 39.370, 55.669, 0.707}, - {"b1", 27.835, 39.370, 0.707}, - {"b2", 19.685, 27.835, 0.707}, - {"b3", 13.898, 19.685, 0.706}, - {"b4", 9.843, 13.898, 0.708}, - {"b5", 6.929, 9.843, 0.704}, - {"b6", 4.921, 6.929, 0.710}, - {"c0", 36.102, 51.063, 0.707}, - {"c1", 25.512, 36.102, 0.707}, - {"c2", 18.031, 25.512, 0.707}, - {"c3", 12.756, 18.031, 0.707}, - {"c4", 9.016, 12.756, 0.707}, - {"c5", 6.378, 9.016, 0.707}, - {"c6", 4.488, 6.378, 0.704}, - {"", 0.000, 0.000, 1.000} -}; - -/* Structure to define input image parameters */ -struct image_data { - float xres; - float yres; - uint32 width; - uint32 length; - uint16 res_unit; - uint16 bps; - uint16 spp; - uint16 planar; - uint16 photometric; - uint16 orientation; - uint16 compression; - uint16 adjustments; -}; - -/* Structure to define the output image modifiers */ -struct pagedef { - char name[16]; - double width; /* width in pixels */ - double length; /* length in pixels */ - double hmargin; /* margins to subtract from width of sections */ - double vmargin; /* margins to subtract from height of sections */ - double hres; /* horizontal resolution for output */ - double vres; /* vertical resolution for output */ - uint32 mode; /* bitmask of modifiers to page format */ - uint16 res_unit; /* resolution unit for output image */ - unsigned int rows; /* number of section rows */ - unsigned int cols; /* number of section cols */ - unsigned int orient; /* portrait, landscape, seascape, auto */ -}; - -struct dump_opts { - int debug; - int format; - int level; - char mode[4]; - char infilename[PATH_MAX + 1]; - char outfilename[PATH_MAX + 1]; - FILE *infile; - FILE *outfile; - }; - -/* globals */ -static int outtiled = -1; -static uint32 tilewidth = 0; -static uint32 tilelength = 0; - -static uint16 config = 0; -static uint16 compression = 0; -static uint16 predictor = 0; -static uint16 fillorder = 0; -static uint32 rowsperstrip = 0; -static uint32 g3opts = 0; -static int ignore = FALSE; /* if true, ignore read errors */ -static uint32 defg3opts = (uint32) -1; -static int quality = 100; /* JPEG quality */ -/* static int jpegcolormode = -1; was JPEGCOLORMODE_RGB; */ -static int jpegcolormode = JPEGCOLORMODE_RGB; -static uint16 defcompression = (uint16) -1; -static uint16 defpredictor = (uint16) -1; -static int pageNum = 0; -static int little_endian = 1; - -/* Functions adapted from tiffcp with additions or significant modifications */ -static int readContigStripsIntoBuffer (TIFF*, uint8*); -static int readSeparateStripsIntoBuffer (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *); -static int readContigTilesIntoBuffer (TIFF*, uint8*, uint32, uint32, uint32, uint32, tsample_t, uint16); -static int readSeparateTilesIntoBuffer (TIFF*, uint8*, uint32, uint32, uint32, uint32, tsample_t, uint16); -static int writeBufferToContigStrips (TIFF*, uint8*, uint32); -static int writeBufferToContigTiles (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *); -static int writeBufferToSeparateStrips (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *); -static int writeBufferToSeparateTiles (TIFF*, uint8*, uint32, uint32, tsample_t, struct dump_opts *); -static int extractContigSamplesToBuffer (uint8 *, uint8 *, uint32, uint32, tsample_t, - uint16, uint16, struct dump_opts *); -static int processCompressOptions(char*); -static void usage(void); - -/* All other functions by Richard Nolde, not found in tiffcp */ -static void initImageData (struct image_data *); -static void initCropMasks (struct crop_mask *); -static void initPageSetup (struct pagedef *, struct pageseg *, struct buffinfo []); -static void initDumpOptions(struct dump_opts *); - -/* Command line and file naming functions */ -void process_command_opts (int, char *[], char *, char *, uint32 *, - uint16 *, uint16 *, uint32 *, uint32 *, uint32 *, - struct crop_mask *, struct pagedef *, - struct dump_opts *, - unsigned int *, unsigned int *); -static int update_output_file (TIFF **, char *, int, char *, unsigned int *); - - -/* * High level functions for whole image manipulation */ -static int get_page_geometry (char *, struct pagedef*); -static int computeInputPixelOffsets(struct crop_mask *, struct image_data *, - struct offset *); -static int computeOutputPixelOffsets (struct crop_mask *, struct image_data *, - struct pagedef *, struct pageseg *, - struct dump_opts *); -static int loadImage(TIFF *, struct image_data *, struct dump_opts *, unsigned char **); -static int correct_orientation(struct image_data *, unsigned char **); -static int getCropOffsets(struct image_data *, struct crop_mask *, struct dump_opts *); -static int processCropSelections(struct image_data *, struct crop_mask *, - unsigned char **, struct buffinfo []); -static int writeSelections(TIFF *, TIFF **, struct crop_mask *, struct image_data *, - struct dump_opts *, struct buffinfo [], - char *, char *, unsigned int*, unsigned int); - -/* Section functions */ -static int createImageSection(uint32, unsigned char **); -static int extractImageSection(struct image_data *, struct pageseg *, - unsigned char *, unsigned char *); -static int writeSingleSection(TIFF *, TIFF *, struct image_data *, - struct dump_opts *, uint32, uint32, - double, double, unsigned char *); -static int writeImageSections(TIFF *, TIFF *, struct image_data *, - struct pagedef *, struct pageseg *, - struct dump_opts *, unsigned char *, - unsigned char **); -/* Whole image functions */ -static int createCroppedImage(struct image_data *, struct crop_mask *, - unsigned char **, unsigned char **); -static int writeCroppedImage(TIFF *, TIFF *, struct image_data *image, - struct dump_opts * dump, - uint32, uint32, unsigned char *, int, int); - -/* Image manipulation functions */ -static int rotateContigSamples8bits(uint16, uint16, uint16, uint32, - uint32, uint32, uint8 *, uint8 *); -static int rotateContigSamples16bits(uint16, uint16, uint16, uint32, - uint32, uint32, uint8 *, uint8 *); -static int rotateContigSamples24bits(uint16, uint16, uint16, uint32, - uint32, uint32, uint8 *, uint8 *); -static int rotateContigSamples32bits(uint16, uint16, uint16, uint32, - uint32, uint32, uint8 *, uint8 *); -static int rotateImage(uint16, struct image_data *, uint32 *, uint32 *, - unsigned char **); -static int mirrorImage(uint16, uint16, uint16, uint32, uint32, - unsigned char *); -static int invertImage(uint16, uint16, uint16, uint32, uint32, - unsigned char *); - -/* Functions to reverse the sequence of samples in a scanline */ -static int reverseSamples8bits (uint16, uint16, uint32, uint8 *, uint8 *); -static int reverseSamples16bits (uint16, uint16, uint32, uint8 *, uint8 *); -static int reverseSamples24bits (uint16, uint16, uint32, uint8 *, uint8 *); -static int reverseSamples32bits (uint16, uint16, uint32, uint8 *, uint8 *); -static int reverseSamplesBytes (uint16, uint16, uint32, uint8 *, uint8 *); - -/* Functions for manipulating individual samples in an image */ -static int extractSeparateRegion(struct image_data *, struct crop_mask *, - unsigned char *, unsigned char *, int); -static int extractCompositeRegions(struct image_data *, struct crop_mask *, - unsigned char *, unsigned char *); -static int extractContigSamples8bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32); -static int extractContigSamples16bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32); -static int extractContigSamples24bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32); -static int extractContigSamples32bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32); -static int extractContigSamplesBytes (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32); -static int extractContigSamplesShifted8bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32, - int); -static int extractContigSamplesShifted16bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32, - int); -static int extractContigSamplesShifted24bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32, - int); -static int extractContigSamplesShifted32bits (uint8 *, uint8 *, uint32, - tsample_t, uint16, uint16, - tsample_t, uint32, uint32, - int); -static int extractContigSamplesToTileBuffer(uint8 *, uint8 *, uint32, uint32, - uint32, uint32, tsample_t, uint16, - uint16, uint16, struct dump_opts *); - -/* Functions to combine separate planes into interleaved planes */ -static int combineSeparateSamples8bits (uint8 *[], uint8 *, uint32, uint32, - uint16, uint16, FILE *, int, int); -static int combineSeparateSamples16bits (uint8 *[], uint8 *, uint32, uint32, - uint16, uint16, FILE *, int, int); -static int combineSeparateSamples24bits (uint8 *[], uint8 *, uint32, uint32, - uint16, uint16, FILE *, int, int); -static int combineSeparateSamples32bits (uint8 *[], uint8 *, uint32, uint32, - uint16, uint16, FILE *, int, int); -static int combineSeparateSamplesBytes (unsigned char *[], unsigned char *, - uint32, uint32, tsample_t, uint16, - FILE *, int, int); - -static int combineSeparateTileSamples8bits (uint8 *[], uint8 *, uint32, uint32, - uint32, uint32, uint16, uint16, - FILE *, int, int); -static int combineSeparateTileSamples16bits (uint8 *[], uint8 *, uint32, uint32, - uint32, uint32, uint16, uint16, - FILE *, int, int); -static int combineSeparateTileSamples24bits (uint8 *[], uint8 *, uint32, uint32, - uint32, uint32, uint16, uint16, - FILE *, int, int); -static int combineSeparateTileSamples32bits (uint8 *[], uint8 *, uint32, uint32, - uint32, uint32, uint16, uint16, - FILE *, int, int); -static int combineSeparateTileSamplesBytes (unsigned char *[], unsigned char *, - uint32, uint32, uint32, uint32, - tsample_t, uint16, FILE *, int, int); - -/* Dump functions for debugging */ -static void dump_info (FILE *, int, char *, char *, ...); -static int dump_data (FILE *, int, char *, unsigned char *, uint32); -static int dump_byte (FILE *, int, char *, unsigned char); -static int dump_short (FILE *, int, char *, uint16); -static int dump_long (FILE *, int, char *, uint32); -static int dump_wide (FILE *, int, char *, uint64); -static int dump_buffer (FILE *, int, uint32, uint32, uint32, unsigned char *); - -/* End function declarations */ -/* Functions derived in whole or in part from tiffcp */ -/* The following functions are taken largely intact from tiffcp */ - -static char* usage_info[] = { -"usage: tiffcrop [options] source1 ... sourceN destination", -"where options are:", -" -h Print this syntax listing", -" -v Print tiffcrop version identifier and last revision date", -" ", -" -a Append to output instead of overwriting", -" -d offset Set initial directory offset, counting first image as one, not zero", -" -p contig Pack samples contiguously (e.g. RGBRGB...)", -" -p separate Store samples separately (e.g. RRR...GGG...BBB...)", -" -s Write output in strips", -" -t Write output in tiles", -" -i Ignore read errors", -" ", -" -r # Make each strip have no more than # rows", -" -w # Set output tile width (pixels)", -" -l # Set output tile length (pixels)", -" ", -" -f lsb2msb Force lsb-to-msb FillOrder for output", -" -f msb2lsb Force msb-to-lsb FillOrder for output", -"", -" -c lzw[:opts] Compress output with Lempel-Ziv & Welch encoding", -" -c zip[:opts] Compress output with deflate encoding", -" -c jpeg[:opts] Compress output with JPEG encoding", -" -c packbits Compress output with packbits encoding", -" -c g3[:opts] Compress output with CCITT Group 3 encoding", -" -c g4 Compress output with CCITT Group 4 encoding", -" -c none Use no compression algorithm on output", -" ", -"Group 3 options:", -" 1d Use default CCITT Group 3 1D-encoding", -" 2d Use optional CCITT Group 3 2D-encoding", -" fill Byte-align EOL codes", -"For example, -c g3:2d:fill to get G3-2D-encoded data with byte-aligned EOLs", -" ", -"JPEG options:", -" # Set compression quality level (0-100, default 100)", -" raw Output color image as raw YCbCr", -" rgb Output color image as RGB", -"For example, -c jpeg:rgb:50 to get JPEG-encoded RGB data with 50% comp. quality", -" ", -"LZW and deflate options:", -" # Set predictor value", -"For example, -c lzw:2 to get LZW-encoded data with horizontal differencing", -" ", -"Page and selection options:", -" -N odd|even|#,#-#,#|last sequences and ranges of images within file to process", -" The words odd or even may be used to specify all odd or even numbered images.", -" The word last may be used in place of a number in the sequence to indicate.", -" The final image in the file without knowing how many images there are.", -" Numbers are counted from one even though TIFF IFDs are counted from zero.", -" ", -" -E t|l|r|b edge to use as origin for width and length of crop region", -" -U units [in, cm, px ] inches, centimeters or pixels", -" ", -" -m #,#,#,# margins from edges for selection: top, left, bottom, right separated by commas", -" -X # horizontal dimension of region to extract expressed in current units", -" -Y # vertical dimension of region to extract expressed in current units", -" -Z #:#,#:# zones of the image designated as position X of Y,", -" eg 1:3 would be first of three equal portions measured from reference edge", -" -z x1,y1,x2,y2:...:xN,yN,xN+1,yN+1", -" regions of the image designated by upper left and lower right coordinates", -"", -"Export grouping options:", -" -e c|d|i|m|s export mode for images and selections from input images.", -" When exporting a composite image from multiple zones or regions", -" (combined and image modes), the selections must have equal sizes", -" for the axis perpendicular to the edge specified with -E.", -" c|combined All images and selections are written to a single file (default).", -" with multiple selections from one image combined into a single image.", -" d|divided All images and selections are written to a single file", -" with each selection from one image written to a new image.", -" i|image Each input image is written to a new file (numeric filename sequence)", -" with multiple selections from the image combined into one image.", -" m|multiple Each input image is written to a new file (numeric filename sequence)", -" with each selection from the image written to a new image.", -" s|separated Individual selections from each image are written to separate files.", -"", -"Output options:", -" -H # Set horizontal resolution of output images to #", -" -V # Set vertical resolution of output images to #", -" -J # Set horizontal margin of output page to # expressed in current units", -" when sectioning image into columns x rows using the -S cols:rows option", -" -K # Set verticalal margin of output page to # expressed in current units", -" when sectioning image into columns x rows using the -S cols:rows option", -" ", -" -O orient orientation for output image, portrait, landscape, auto", -" -P page page size for output image segments, eg letter, legal, tabloid, etc", -" use #.#x#.# to specify a custom page size in the currently defined units", -" where #.# represents the width and length", -" -S cols:rows Divide the image into equal sized segments using cols across and rows down.", -" ", -" -F hor|vert|both", -" flip (mirror) image or region horizontally, vertically, or both", -" -R # [90,180,or 270] degrees clockwise rotation of image or extracted region", -" -I [black|white|data|both]", -" invert color space, eg dark to light for bilevel and grayscale images", -" If argument is white or black, set the PHOTOMETRIC_INTERPRETATION ", -" tag to MinIsBlack or MinIsWhite without altering the image data", -" If the argument is data or both, the image data are modified:", -" both inverts the data and the PHOTOMETRIC_INTERPRETATION tag,", -" data inverts the data but not the PHOTOMETRIC_INTERPRETATION tag", -" ", -"-D opt1:value1,opt2:value2,opt3:value3:opt4:value4", -" Debug/dump program progress and/or data to non-TIFF files.", -" Options include the following and must be joined as a comma", -" separate list. The use of this option is generally limited to", -" program debugging and development of future options.", -" ", -" debug:N Display limited program progress indicators where larger N", -" increase the level of detail. Note: Tiffcrop may be compiled with", -" -DDEVELMODE to enable additional very low level debug reporting.", -"", -" Format:txt|raw Format any logged data as ASCII text or raw binary ", -" values. ASCII text dumps include strings of ones and zeroes", -" representing the binary values in the image data plus identifying headers.", -" ", -" level:N Specify the level of detail presented in the dump files.", -" This can vary from dumps of the entire input or output image data to dumps", -" of data processed by specific functions. Current range of levels is 1 to 3.", -" ", -" input:full-path-to-directory/input-dumpname", -" ", -" output:full-path-to-directory/output-dumpnaem", -" ", -" When dump files are being written, each image will be written to a separate", -" file with the name built by adding a numeric sequence value to the dumpname", -" and an extension of .txt for ASCII dumps or .bin for binary dumps.", -" ", -" The four debug/dump options are independent, though it makes little sense to", -" specify a dump file without specifying a detail level.", -" ", -NULL -}; - -/* This function could be modified to pass starting sample offset - * and number of samples as args to select fewer than spp - * from input image. These would then be passed to individual - * extractContigSampleXX routines. - */ -static int readContigTilesIntoBuffer (TIFF* in, uint8* buf, - uint32 imagelength, - uint32 imagewidth, - uint32 tw, uint32 tl, - tsample_t spp, uint16 bps) - { - int status = 1; - tsample_t sample = 0; - tsample_t count = spp; - uint32 row, col, trow; - uint32 nrow, ncol; - uint32 dst_rowsize, shift_width; - uint32 bytes_per_sample, bytes_per_pixel; - uint32 trailing_bits, prev_trailing_bits; - uint32 tile_rowsize = TIFFTileRowSize(in); - uint32 src_offset, dst_offset; - uint32 row_offset, col_offset; - uint8 *bufp = (uint8*) buf; - unsigned char *src = NULL; - unsigned char *dst = NULL; - tsize_t tbytes = 0, tile_buffsize = 0; - tsize_t tilesize = TIFFTileSize(in); - unsigned char *tilebuf = NULL; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - - if ((bps % 8) == 0) - shift_width = 0; - else - { - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - } - - tile_buffsize = tilesize; - - if (tilesize < (tsize_t)(tl * tile_rowsize)) - { -#ifdef DEBUG2 - TIFFError("readContigTilesIntoBuffer", - "Tilesize %lu is too small, using alternate calculation %u", - tilesize, tl * tile_rowsize); -#endif - tile_buffsize = tl * tile_rowsize; - } - - tilebuf = _TIFFmalloc(tile_buffsize); - if (tilebuf == 0) - return 0; - - dst_rowsize = ((imagewidth * bps * spp) + 7) / 8; - for (row = 0; row < imagelength; row += tl) - { - nrow = (row + tl > imagelength) ? imagelength - row : tl; - for (col = 0; col < imagewidth; col += tw) - { - tbytes = TIFFReadTile(in, tilebuf, col, row, 0, 0); - if (tbytes < tilesize && !ignore) - { - TIFFError(TIFFFileName(in), - "Error, can't read tile at row %lu col %lu, Read %lu bytes of %lu", - (unsigned long) col, (unsigned long) row, (unsigned long)tbytes, - (unsigned long)tilesize); - status = 0; - _TIFFfree(tilebuf); - return status; - } - - row_offset = row * dst_rowsize; - col_offset = ((col * bps * spp) + 7)/ 8; - bufp = buf + row_offset + col_offset; - - if (col + tw > imagewidth) - ncol = imagewidth - col; - else - ncol = tw; - - /* Each tile scanline will start on a byte boundary but it - * has to be merged into the scanline for the entire - * image buffer and the previous segment may not have - * ended on a byte boundary - */ - /* Optimization for common bit depths, all samples */ - if (((bps % 8) == 0) && (count == spp)) - { - for (trow = 0; trow < nrow; trow++) - { - src_offset = trow * tile_rowsize; - _TIFFmemcpy (bufp, tilebuf + src_offset, (ncol * spp * bps) / 8); - bufp += (imagewidth * bps * spp) / 8; - } - } - else - { - /* Bit depths not a multiple of 8 and/or extract fewer than spp samples */ - prev_trailing_bits = trailing_bits = 0; - trailing_bits = (ncol * bps * spp) % 8; - - /* for (trow = 0; tl < nrow; trow++) */ - for (trow = 0; trow < nrow; trow++) - { - src_offset = trow * tile_rowsize; - src = tilebuf + src_offset; - dst_offset = (row + trow) * dst_rowsize; - dst = buf + dst_offset + col_offset; - switch (shift_width) - { - case 0: if (extractContigSamplesBytes (src, dst, ncol, sample, - spp, bps, count, 0, ncol)) - { - TIFFError("readContigTilesIntoBuffer", - "Unable to extract row %d from tile %lu", - row, (unsigned long)TIFFCurrentTile(in)); - return 1; - } - break; - case 1: if (bps == 1) - { - if (extractContigSamplesShifted8bits (src, dst, ncol, - sample, spp, - bps, count, - 0, ncol, - prev_trailing_bits)) - { - TIFFError("readContigTilesIntoBuffer", - "Unable to extract row %d from tile %lu", - row, (unsigned long)TIFFCurrentTile(in)); - return 1; - } - break; - } - else - if (extractContigSamplesShifted16bits (src, dst, ncol, - sample, spp, - bps, count, - 0, ncol, - prev_trailing_bits)) - { - TIFFError("readContigTilesIntoBuffer", - "Unable to extract row %d from tile %lu", - row, (unsigned long)TIFFCurrentTile(in)); - return 1; - } - break; - case 2: if (extractContigSamplesShifted24bits (src, dst, ncol, - sample, spp, - bps, count, - 0, ncol, - prev_trailing_bits)) - { - TIFFError("readContigTilesIntoBuffer", - "Unable to extract row %d from tile %lu", - row, (unsigned long)TIFFCurrentTile(in)); - return 1; - } - break; - case 3: - case 4: - case 5: if (extractContigSamplesShifted32bits (src, dst, ncol, - sample, spp, - bps, count, - 0, ncol, - prev_trailing_bits)) - { - TIFFError("readContigTilesIntoBuffer", - "Unable to extract row %d from tile %lu", - row, (unsigned long)TIFFCurrentTile(in)); - return 1; - } - break; - default: TIFFError("readContigTilesIntoBuffer", "Unsupported bit depth %d", bps); - return 1; - } - } - prev_trailing_bits += trailing_bits; - if (prev_trailing_bits > 7) - prev_trailing_bits-= 8; - } - } - } - - _TIFFfree(tilebuf); - return status; - } - -static int readSeparateTilesIntoBuffer (TIFF* in, uint8 *obuf, - uint32 imagelength, uint32 imagewidth, - uint32 tw, uint32 tl, - uint16 spp, uint16 bps) - { - int i, status = 1, sample; - int shift_width, bytes_per_pixel; - uint16 bytes_per_sample; - uint32 row, col; /* Current row and col of image */ - uint32 nrow, ncol; /* Number of rows and cols in current tile */ - uint32 row_offset, col_offset; /* Output buffer offsets */ - tsize_t tbytes = 0, tilesize = TIFFTileSize(in); - tsample_t s; - uint8* bufp = (uint8*)obuf; - unsigned char *srcbuffs[MAX_SAMPLES]; - unsigned char *tbuff = NULL; - - bytes_per_sample = (bps + 7) / 8; - - for (sample = 0; (sample < spp) && (sample < MAX_SAMPLES); sample++) - { - srcbuffs[sample] = NULL; - tbuff = (unsigned char *)_TIFFmalloc(tilesize + 8); - if (!tbuff) - { - TIFFError ("readSeparateTilesIntoBuffer", - "Unable to allocate tile read buffer for sample %d", sample); - for (i = 0; i < sample; i++) - _TIFFfree (srcbuffs[i]); - return 0; - } - srcbuffs[sample] = tbuff; - } - /* Each tile contains only the data for a single plane - * arranged in scanlines of tw * bytes_per_sample bytes. - */ - for (row = 0; row < imagelength; row += tl) - { - nrow = (row + tl > imagelength) ? imagelength - row : tl; - for (col = 0; col < imagewidth; col += tw) - { - for (s = 0; s < spp; s++) - { /* Read each plane of a tile set into srcbuffs[s] */ - tbytes = TIFFReadTile(in, srcbuffs[s], col, row, 0, s); - if (tbytes < 0 && !ignore) - { - TIFFError(TIFFFileName(in), - "Error, can't read tile for row %lu col %lu, " - "sample %lu", - (unsigned long) col, (unsigned long) row, - (unsigned long) s); - status = 0; - for (sample = 0; (sample < spp) && (sample < MAX_SAMPLES); sample++) - { - tbuff = srcbuffs[sample]; - if (tbuff != NULL) - _TIFFfree(tbuff); - } - return status; - } - } - /* Tiles on the right edge may be padded out to tw - * which must be a multiple of 16. - * Ncol represents the visible (non padding) portion. - */ - if (col + tw > imagewidth) - ncol = imagewidth - col; - else - ncol = tw; - - row_offset = row * (((imagewidth * spp * bps) + 7) / 8); - col_offset = ((col * spp * bps) + 7) / 8; - bufp = obuf + row_offset + col_offset; - - if ((bps % 8) == 0) - { - if (combineSeparateTileSamplesBytes(srcbuffs, bufp, ncol, nrow, imagewidth, - tw, spp, bps, NULL, 0, 0)) - { - status = 0; - break; - } - } - else - { - bytes_per_pixel = ((bps * spp) + 7) / 8; - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - - switch (shift_width) - { - case 1: if (combineSeparateTileSamples8bits (srcbuffs, bufp, ncol, nrow, - imagewidth, tw, spp, bps, - NULL, 0, 0)) - { - status = 0; - break; - } - break; - case 2: if (combineSeparateTileSamples16bits (srcbuffs, bufp, ncol, nrow, - imagewidth, tw, spp, bps, - NULL, 0, 0)) - { - status = 0; - break; - } - break; - case 3: if (combineSeparateTileSamples24bits (srcbuffs, bufp, ncol, nrow, - imagewidth, tw, spp, bps, - NULL, 0, 0)) - { - status = 0; - break; - } - break; - case 4: - case 5: - case 6: - case 7: - case 8: if (combineSeparateTileSamples32bits (srcbuffs, bufp, ncol, nrow, - imagewidth, tw, spp, bps, - NULL, 0, 0)) - { - status = 0; - break; - } - break; - default: TIFFError ("readSeparateTilesIntoBuffer", "Unsupported bit depth: %d", bps); - status = 0; - break; - } - } - } - } - - for (sample = 0; (sample < spp) && (sample < MAX_SAMPLES); sample++) - { - tbuff = srcbuffs[sample]; - if (tbuff != NULL) - _TIFFfree(tbuff); - } - - return status; - } - -static int writeBufferToContigStrips(TIFF* out, uint8* buf, uint32 imagelength) - { - uint32 row, nrows, rowsperstrip; - tstrip_t strip = 0; - tsize_t stripsize; - - TIFFGetFieldDefaulted(out, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); - for (row = 0; row < imagelength; row += rowsperstrip) - { - nrows = (row + rowsperstrip > imagelength) ? - imagelength - row : rowsperstrip; - stripsize = TIFFVStripSize(out, nrows); - if (TIFFWriteEncodedStrip(out, strip++, buf, stripsize) < 0) - { - TIFFError(TIFFFileName(out), "Error, can't write strip %u", strip - 1); - return 1; - } - buf += stripsize; - } - - return 0; - } - -/* Abandon plans to modify code so that plannar orientation separate images - * do not have all samples for each channel written before all samples - * for the next channel have been abandoned. - * Libtiff internals seem to depend on all data for a given sample - * being contiguous within a strip or tile when PLANAR_CONFIG is - * separate. All strips or tiles of a given plane are written - * before any strips or tiles of a different plane are stored. - */ -static int -writeBufferToSeparateStrips (TIFF* out, uint8* buf, - uint32 length, uint32 width, uint16 spp, - struct dump_opts *dump) - { - uint8 *src; - uint16 bps; - uint32 row, nrows, rowsize, rowsperstrip; - uint32 bytes_per_sample; - tsample_t s; - tstrip_t strip = 0; - tsize_t stripsize = TIFFStripSize(out); - tsize_t rowstripsize, scanlinesize = TIFFScanlineSize(out); - tsize_t total_bytes = 0; - tdata_t obuf; - - (void) TIFFGetFieldDefaulted(out, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); - (void) TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps); - bytes_per_sample = (bps + 7) / 8; - rowsize = ((bps * spp * width) + 7) / 8; /* source has interleaved samples */ - rowstripsize = rowsperstrip * bytes_per_sample * (width + 1); - - obuf = _TIFFmalloc (rowstripsize); - if (obuf == NULL) - return 1; - - for (s = 0; s < spp; s++) - { - for (row = 0; row < length; row += rowsperstrip) - { - nrows = (row + rowsperstrip > length) ? length - row : rowsperstrip; - - stripsize = TIFFVStripSize(out, nrows); - src = buf + (row * rowsize); - total_bytes += stripsize; - memset (obuf, '\0', rowstripsize); - if (extractContigSamplesToBuffer(obuf, src, nrows, width, s, spp, bps, dump)) - { - _TIFFfree(obuf); - return 1; - } - if ((dump->outfile != NULL) && (dump->level == 1)) - { - dump_info(dump->outfile, dump->format,"", - "Sample %2d, Strip: %2d, bytes: %4d, Row %4d, bytes: %4d, Input offset: %6d", - s + 1, strip + 1, stripsize, row + 1, scanlinesize, src - buf); - dump_buffer(dump->outfile, dump->format, nrows, scanlinesize, row, obuf); - } - - if (TIFFWriteEncodedStrip(out, strip++, obuf, stripsize) < 0) - { - TIFFError(TIFFFileName(out), "Error, can't write strip %u", strip - 1); - _TIFFfree(obuf); - return 1; - } - } - } - - _TIFFfree(obuf); - return 0; -} - -/* Extract all planes from contiguous buffer into a single tile buffer - * to be written out as a tile. - */ -static int writeBufferToContigTiles (TIFF* out, uint8* buf, uint32 imagelength, - uint32 imagewidth, tsample_t spp, - struct dump_opts* dump) - { - uint16 bps; - uint32 tl, tw; - uint32 row, col, nrow, ncol; - uint32 src_rowsize, col_offset; - uint32 tile_rowsize = TIFFTileRowSize(out); - uint8* bufp = (uint8*) buf; - tsize_t tile_buffsize = 0; - tsize_t tilesize = TIFFTileSize(out); - unsigned char *tilebuf = NULL; - - if( !TIFFGetField(out, TIFFTAG_TILELENGTH, &tl) || - !TIFFGetField(out, TIFFTAG_TILEWIDTH, &tw) || - !TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps) ) - return 1; - - tile_buffsize = tilesize; - if (tilesize < (tsize_t)(tl * tile_rowsize)) - { -#ifdef DEBUG2 - TIFFError("writeBufferToContigTiles", - "Tilesize %lu is too small, using alternate calculation %u", - tilesize, tl * tile_rowsize); -#endif - tile_buffsize = tl * tile_rowsize; - } - - tilebuf = _TIFFmalloc(tile_buffsize); - if (tilebuf == 0) - return 1; - - src_rowsize = ((imagewidth * spp * bps) + 7) / 8; - for (row = 0; row < imagelength; row += tl) - { - nrow = (row + tl > imagelength) ? imagelength - row : tl; - for (col = 0; col < imagewidth; col += tw) - { - /* Calculate visible portion of tile. */ - if (col + tw > imagewidth) - ncol = imagewidth - col; - else - ncol = tw; - - col_offset = (((col * bps * spp) + 7) / 8); - bufp = buf + (row * src_rowsize) + col_offset; - if (extractContigSamplesToTileBuffer(tilebuf, bufp, nrow, ncol, imagewidth, - tw, 0, spp, spp, bps, dump) > 0) - { - TIFFError("writeBufferToContigTiles", - "Unable to extract data to tile for row %lu, col %lu", - (unsigned long) row, (unsigned long)col); - _TIFFfree(tilebuf); - return 1; - } - - if (TIFFWriteTile(out, tilebuf, col, row, 0, 0) < 0) - { - TIFFError("writeBufferToContigTiles", - "Cannot write tile at %lu %lu", - (unsigned long) col, (unsigned long) row); - _TIFFfree(tilebuf); - return 1; - } - } - } - _TIFFfree(tilebuf); - - return 0; - } /* end writeBufferToContigTiles */ - -/* Extract each plane from contiguous buffer into a single tile buffer - * to be written out as a tile. - */ -static int writeBufferToSeparateTiles (TIFF* out, uint8* buf, uint32 imagelength, - uint32 imagewidth, tsample_t spp, - struct dump_opts * dump) - { - tdata_t obuf = _TIFFmalloc(TIFFTileSize(out)); - uint32 tl, tw; - uint32 row, col, nrow, ncol; - uint32 src_rowsize, col_offset; - uint16 bps; - tsample_t s; - uint8* bufp = (uint8*) buf; - - if (obuf == NULL) - return 1; - - TIFFGetField(out, TIFFTAG_TILELENGTH, &tl); - TIFFGetField(out, TIFFTAG_TILEWIDTH, &tw); - TIFFGetField(out, TIFFTAG_BITSPERSAMPLE, &bps); - src_rowsize = ((imagewidth * spp * bps) + 7) / 8; - - for (row = 0; row < imagelength; row += tl) - { - nrow = (row + tl > imagelength) ? imagelength - row : tl; - for (col = 0; col < imagewidth; col += tw) - { - /* Calculate visible portion of tile. */ - if (col + tw > imagewidth) - ncol = imagewidth - col; - else - ncol = tw; - - col_offset = (((col * bps * spp) + 7) / 8); - bufp = buf + (row * src_rowsize) + col_offset; - - for (s = 0; s < spp; s++) - { - if (extractContigSamplesToTileBuffer(obuf, bufp, nrow, ncol, imagewidth, - tw, s, 1, spp, bps, dump) > 0) - { - TIFFError("writeBufferToSeparateTiles", - "Unable to extract data to tile for row %lu, col %lu sample %d", - (unsigned long) row, (unsigned long)col, (int)s); - _TIFFfree(obuf); - return 1; - } - - if (TIFFWriteTile(out, obuf, col, row, 0, s) < 0) - { - TIFFError("writeBufferToseparateTiles", - "Cannot write tile at %lu %lu sample %lu", - (unsigned long) col, (unsigned long) row, - (unsigned long) s); - _TIFFfree(obuf); - return 1; - } - } - } - } - _TIFFfree(obuf); - - return 0; - } /* end writeBufferToSeparateTiles */ - -static void -processG3Options(char* cp) -{ - if( (cp = strchr(cp, ':')) ) { - if (defg3opts == (uint32) -1) - defg3opts = 0; - do { - cp++; - if (strneq(cp, "1d", 2)) - defg3opts &= ~GROUP3OPT_2DENCODING; - else if (strneq(cp, "2d", 2)) - defg3opts |= GROUP3OPT_2DENCODING; - else if (strneq(cp, "fill", 4)) - defg3opts |= GROUP3OPT_FILLBITS; - else - usage(); - } while( (cp = strchr(cp, ':')) ); - } -} - -static int -processCompressOptions(char* opt) - { - char* cp = NULL; - - if (strneq(opt, "none",4)) - { - defcompression = COMPRESSION_NONE; - } - else if (streq(opt, "packbits")) - { - defcompression = COMPRESSION_PACKBITS; - } - else if (strneq(opt, "jpeg", 4)) - { - cp = strchr(opt, ':'); - defcompression = COMPRESSION_JPEG; - - while (cp) - { - if (isdigit((int)cp[1])) - quality = atoi(cp + 1); - else if (strneq(cp + 1, "raw", 3 )) - jpegcolormode = JPEGCOLORMODE_RAW; - else if (strneq(cp + 1, "rgb", 3 )) - jpegcolormode = JPEGCOLORMODE_RGB; - else - usage(); - cp = strchr(cp + 1, ':'); - } - } - else if (strneq(opt, "g3", 2)) - { - processG3Options(opt); - defcompression = COMPRESSION_CCITTFAX3; - } - else if (streq(opt, "g4")) - { - defcompression = COMPRESSION_CCITTFAX4; - } - else if (strneq(opt, "lzw", 3)) - { - cp = strchr(opt, ':'); - if (cp) - defpredictor = atoi(cp+1); - defcompression = COMPRESSION_LZW; - } - else if (strneq(opt, "zip", 3)) - { - cp = strchr(opt, ':'); - if (cp) - defpredictor = atoi(cp+1); - defcompression = COMPRESSION_ADOBE_DEFLATE; - } - else - return (0); - - return (1); - } - -static void -usage(void) - { - int i; - - fprintf(stderr, "\n%s\n", TIFFGetVersion()); - for (i = 0; usage_info[i] != NULL; i++) - fprintf(stderr, "%s\n", usage_info[i]); - exit(-1); - } - -#define CopyField(tag, v) \ - if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v) -#define CopyField2(tag, v1, v2) \ - if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2) -#define CopyField3(tag, v1, v2, v3) \ - if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3) -#define CopyField4(tag, v1, v2, v3, v4) \ - if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4) - -static void -cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type) -{ - switch (type) { - case TIFF_SHORT: - if (count == 1) { - uint16 shortv; - CopyField(tag, shortv); - } else if (count == 2) { - uint16 shortv1, shortv2; - CopyField2(tag, shortv1, shortv2); - } else if (count == 4) { - uint16 *tr, *tg, *tb, *ta; - CopyField4(tag, tr, tg, tb, ta); - } else if (count == (uint16) -1) { - uint16 shortv1; - uint16* shortav; - CopyField2(tag, shortv1, shortav); - } - break; - case TIFF_LONG: - { uint32 longv; - CopyField(tag, longv); - } - break; - case TIFF_RATIONAL: - if (count == 1) { - float floatv; - CopyField(tag, floatv); - } else if (count == (uint16) -1) { - float* floatav; - CopyField(tag, floatav); - } - break; - case TIFF_ASCII: - { char* stringv; - CopyField(tag, stringv); - } - break; - case TIFF_DOUBLE: - if (count == 1) { - double doublev; - CopyField(tag, doublev); - } else if (count == (uint16) -1) { - double* doubleav; - CopyField(tag, doubleav); - } - break; - default: - TIFFError(TIFFFileName(in), - "Data type %d is not supported, tag %d skipped", - tag, type); - } -} - -static struct cpTag { - uint16 tag; - uint16 count; - TIFFDataType type; -} tags[] = { - { TIFFTAG_SUBFILETYPE, 1, TIFF_LONG }, - { TIFFTAG_THRESHHOLDING, 1, TIFF_SHORT }, - { TIFFTAG_DOCUMENTNAME, 1, TIFF_ASCII }, - { TIFFTAG_IMAGEDESCRIPTION, 1, TIFF_ASCII }, - { TIFFTAG_MAKE, 1, TIFF_ASCII }, - { TIFFTAG_MODEL, 1, TIFF_ASCII }, - { TIFFTAG_MINSAMPLEVALUE, 1, TIFF_SHORT }, - { TIFFTAG_MAXSAMPLEVALUE, 1, TIFF_SHORT }, - { TIFFTAG_XRESOLUTION, 1, TIFF_RATIONAL }, - { TIFFTAG_YRESOLUTION, 1, TIFF_RATIONAL }, - { TIFFTAG_PAGENAME, 1, TIFF_ASCII }, - { TIFFTAG_XPOSITION, 1, TIFF_RATIONAL }, - { TIFFTAG_YPOSITION, 1, TIFF_RATIONAL }, - { TIFFTAG_RESOLUTIONUNIT, 1, TIFF_SHORT }, - { TIFFTAG_SOFTWARE, 1, TIFF_ASCII }, - { TIFFTAG_DATETIME, 1, TIFF_ASCII }, - { TIFFTAG_ARTIST, 1, TIFF_ASCII }, - { TIFFTAG_HOSTCOMPUTER, 1, TIFF_ASCII }, - { TIFFTAG_WHITEPOINT, (uint16) -1, TIFF_RATIONAL }, - { TIFFTAG_PRIMARYCHROMATICITIES,(uint16) -1,TIFF_RATIONAL }, - { TIFFTAG_HALFTONEHINTS, 2, TIFF_SHORT }, - { TIFFTAG_INKSET, 1, TIFF_SHORT }, - { TIFFTAG_DOTRANGE, 2, TIFF_SHORT }, - { TIFFTAG_TARGETPRINTER, 1, TIFF_ASCII }, - { TIFFTAG_SAMPLEFORMAT, 1, TIFF_SHORT }, - { TIFFTAG_YCBCRCOEFFICIENTS, (uint16) -1,TIFF_RATIONAL }, - { TIFFTAG_YCBCRSUBSAMPLING, 2, TIFF_SHORT }, - { TIFFTAG_YCBCRPOSITIONING, 1, TIFF_SHORT }, - { TIFFTAG_REFERENCEBLACKWHITE, (uint16) -1,TIFF_RATIONAL }, - { TIFFTAG_EXTRASAMPLES, (uint16) -1, TIFF_SHORT }, - { TIFFTAG_SMINSAMPLEVALUE, 1, TIFF_DOUBLE }, - { TIFFTAG_SMAXSAMPLEVALUE, 1, TIFF_DOUBLE }, - { TIFFTAG_STONITS, 1, TIFF_DOUBLE }, -}; -#define NTAGS (sizeof (tags) / sizeof (tags[0])) - -#define CopyTag(tag, count, type) cpTag(in, out, tag, count, type) - -/* Functions written by Richard Nolde, with exceptions noted. */ -void process_command_opts (int argc, char *argv[], char *mp, char *mode, uint32 *dirnum, - uint16 *defconfig, uint16 *deffillorder, uint32 *deftilewidth, - uint32 *deftilelength, uint32 *defrowsperstrip, - struct crop_mask *crop_data, struct pagedef *page, - struct dump_opts *dump, - unsigned int *imagelist, unsigned int *image_count ) - { - int c, good_args = 0; - char *opt_offset = NULL; /* Position in string of value sought */ - char *opt_ptr = NULL; /* Pointer to next token in option set */ - char *sep = NULL; /* Pointer to a token separator */ - unsigned int i, j, start, end; - extern int optind; - extern char* optarg; - - *mp++ = 'w'; - *mp = '\0'; - while ((c = getopt(argc, argv, - "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) - { - good_args++; - switch (c) { - case 'a': mode[0] = 'a'; /* append to output */ - break; - case 'c': if (!processCompressOptions(optarg)) /* compression scheme */ - { - TIFFError ("Unknown compression option", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'd': start = strtoul(optarg, NULL, 0); /* initial IFD offset */ - if (start == 0) - { - TIFFError ("","Directory offset must be greater than zero"); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - *dirnum = start - 1; - break; - case 'e': switch (tolower(optarg[0])) /* image export modes*/ - { - case 'c': crop_data->exp_mode = ONE_FILE_COMPOSITE; - crop_data->img_mode = COMPOSITE_IMAGES; - break; /* Composite */ - case 'd': crop_data->exp_mode = ONE_FILE_SEPARATED; - crop_data->img_mode = SEPARATED_IMAGES; - break; /* Divided */ - case 'i': crop_data->exp_mode = FILE_PER_IMAGE_COMPOSITE; - crop_data->img_mode = COMPOSITE_IMAGES; - break; /* Image */ - case 'm': crop_data->exp_mode = FILE_PER_IMAGE_SEPARATED; - crop_data->img_mode = SEPARATED_IMAGES; - break; /* Multiple */ - case 's': crop_data->exp_mode = FILE_PER_SELECTION; - crop_data->img_mode = SEPARATED_IMAGES; - break; /* Sections */ - default: TIFFError ("Unknown export mode","%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'f': if (streq(optarg, "lsb2msb")) /* fill order */ - *deffillorder = FILLORDER_LSB2MSB; - else if (streq(optarg, "msb2lsb")) - *deffillorder = FILLORDER_MSB2LSB; - else - { - TIFFError ("Unknown fill order", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'h': usage(); - break; - case 'i': ignore = TRUE; /* ignore errors */ - break; - case 'l': outtiled = TRUE; /* tile length */ - *deftilelength = atoi(optarg); - break; - case 'p': /* planar configuration */ - if (streq(optarg, "separate")) - *defconfig = PLANARCONFIG_SEPARATE; - else if (streq(optarg, "contig")) - *defconfig = PLANARCONFIG_CONTIG; - else - { - TIFFError ("Unkown planar configuration", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'r': /* rows/strip */ - *defrowsperstrip = atol(optarg); - break; - case 's': /* generate stripped output */ - outtiled = FALSE; - break; - case 't': /* generate tiled output */ - outtiled = TRUE; - break; - case 'v': TIFFError("Library Release", "%s", TIFFGetVersion()); - TIFFError ("Tiffcrop version", "%s, last updated: %s", - tiffcrop_version_id, tiffcrop_rev_date); - TIFFError ("Tiffcp code", "Copyright (c) 1988-1997 Sam Leffler"); - TIFFError (" ", "Copyright (c) 1991-1997 Silicon Graphics, Inc"); - TIFFError ("Tiffcrop additions", "Copyright (c) 2007-2010 Richard Nolde"); - exit (0); - break; - case 'w': /* tile width */ - outtiled = TRUE; - *deftilewidth = atoi(optarg); - break; - case 'z': /* regions of an image specified as x1,y1,x2,y2:x3,y3,x4,y4 etc */ - crop_data->crop_mode |= CROP_REGIONS; - for (i = 0, opt_ptr = strtok (optarg, ":"); - ((opt_ptr != NULL) && (i < MAX_REGIONS)); - (opt_ptr = strtok (NULL, ":")), i++) - { - crop_data->regions++; - if (sscanf(opt_ptr, "%lf,%lf,%lf,%lf", - &crop_data->corners[i].X1, &crop_data->corners[i].Y1, - &crop_data->corners[i].X2, &crop_data->corners[i].Y2) != 4) - { - TIFFError ("Unable to parse coordinates for region", "%d %s", i, optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - } - /* check for remaining elements over MAX_REGIONS */ - if ((opt_ptr != NULL) && (i >= MAX_REGIONS)) - { - TIFFError ("Region list exceeds limit of", "%d regions %s", MAX_REGIONS, optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1);; - } - break; - /* options for file open modes */ - case 'B': *mp++ = 'b'; *mp = '\0'; - break; - case 'L': *mp++ = 'l'; *mp = '\0'; - break; - case 'M': *mp++ = 'm'; *mp = '\0'; - break; - case 'C': *mp++ = 'c'; *mp = '\0'; - break; - /* options for Debugging / data dump */ - case 'D': for (i = 0, opt_ptr = strtok (optarg, ","); - (opt_ptr != NULL); - (opt_ptr = strtok (NULL, ",")), i++) - { - opt_offset = strpbrk(opt_ptr, ":="); - if (opt_offset == NULL) - { - TIFFError("Invalid dump option", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - - *opt_offset = '\0'; - /* convert option to lowercase */ - end = strlen (opt_ptr); - for (i = 0; i < end; i++) - *(opt_ptr + i) = tolower(*(opt_ptr + i)); - /* Look for dump format specification */ - if (strncmp(opt_ptr, "for", 3) == 0) - { - /* convert value to lowercase */ - end = strlen (opt_offset + 1); - for (i = 1; i <= end; i++) - *(opt_offset + i) = tolower(*(opt_offset + i)); - /* check dump format value */ - if (strncmp (opt_offset + 1, "txt", 3) == 0) - { - dump->format = DUMP_TEXT; - strcpy (dump->mode, "w"); - } - else - { - if (strncmp(opt_offset + 1, "raw", 3) == 0) - { - dump->format = DUMP_RAW; - strcpy (dump->mode, "wb"); - } - else - { - TIFFError("parse_command_opts", "Unknown dump format %s", opt_offset + 1); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - } - } - else - { /* Look for dump level specification */ - if (strncmp (opt_ptr, "lev", 3) == 0) - dump->level = atoi(opt_offset + 1); - /* Look for input data dump file name */ - if (strncmp (opt_ptr, "in", 2) == 0) - { - strncpy (dump->infilename, opt_offset + 1, PATH_MAX - 20); - dump->infilename[PATH_MAX - 20] = '\0'; - } - /* Look for output data dump file name */ - if (strncmp (opt_ptr, "out", 3) == 0) - { - strncpy (dump->outfilename, opt_offset + 1, PATH_MAX - 20); - dump->outfilename[PATH_MAX - 20] = '\0'; - } - if (strncmp (opt_ptr, "deb", 3) == 0) - dump->debug = atoi(opt_offset + 1); - } - } - if ((strlen(dump->infilename)) || (strlen(dump->outfilename))) - { - if (dump->level == 1) - TIFFError("","Defaulting to dump level 1, no data."); - if (dump->format == DUMP_NONE) - { - TIFFError("", "You must specify a dump format for dump files"); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - } - break; - - /* image manipulation routine options */ - case 'm': /* margins to exclude from selection, uppercase M was already used */ - /* order of values must be TOP, LEFT, BOTTOM, RIGHT */ - crop_data->crop_mode |= CROP_MARGINS; - for (i = 0, opt_ptr = strtok (optarg, ",:"); - ((opt_ptr != NULL) && (i < 4)); - (opt_ptr = strtok (NULL, ",:")), i++) - { - crop_data->margins[i] = atof(opt_ptr); - } - break; - case 'E': /* edge reference */ - switch (tolower(optarg[0])) - { - case 't': crop_data->edge_ref = EDGE_TOP; - break; - case 'b': crop_data->edge_ref = EDGE_BOTTOM; - break; - case 'l': crop_data->edge_ref = EDGE_LEFT; - break; - case 'r': crop_data->edge_ref = EDGE_RIGHT; - break; - default: TIFFError ("Edge reference must be top, bottom, left, or right", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'F': /* flip eg mirror image or cropped segment, M was already used */ - crop_data->crop_mode |= CROP_MIRROR; - switch (tolower(optarg[0])) - { - case 'h': crop_data->mirror = MIRROR_HORIZ; - break; - case 'v': crop_data->mirror = MIRROR_VERT; - break; - case 'b': crop_data->mirror = MIRROR_BOTH; - break; - default: TIFFError ("Flip mode must be horiz, vert, or both", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'H': /* set horizontal resolution to new value */ - page->hres = atof (optarg); - page->mode |= PAGE_MODE_RESOLUTION; - break; - case 'I': /* invert the color space, eg black to white */ - crop_data->crop_mode |= CROP_INVERT; - /* The PHOTOMETIC_INTERPRETATION tag may be updated */ - if (streq(optarg, "black")) - { - crop_data->photometric = PHOTOMETRIC_MINISBLACK; - continue; - } - if (streq(optarg, "white")) - { - crop_data->photometric = PHOTOMETRIC_MINISWHITE; - continue; - } - if (streq(optarg, "data")) - { - crop_data->photometric = INVERT_DATA_ONLY; - continue; - } - if (streq(optarg, "both")) - { - crop_data->photometric = INVERT_DATA_AND_TAG; - continue; - } - - TIFFError("Missing or unknown option for inverting PHOTOMETRIC_INTERPRETATION", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - break; - case 'J': /* horizontal margin for sectioned ouput pages */ - page->hmargin = atof(optarg); - page->mode |= PAGE_MODE_MARGINS; - break; - case 'K': /* vertical margin for sectioned ouput pages*/ - page->vmargin = atof(optarg); - page->mode |= PAGE_MODE_MARGINS; - break; - case 'N': /* list of images to process */ - for (i = 0, opt_ptr = strtok (optarg, ","); - ((opt_ptr != NULL) && (i < MAX_IMAGES)); - (opt_ptr = strtok (NULL, ","))) - { /* We do not know how many images are in file yet - * so we build a list to include the maximum allowed - * and follow it until we hit the end of the file. - * Image count is not accurate for odd, even, last - * so page numbers won't be valid either. - */ - if (streq(opt_ptr, "odd")) - { - for (j = 1; j <= MAX_IMAGES; j += 2) - imagelist[i++] = j; - *image_count = (MAX_IMAGES - 1) / 2; - break; - } - else - { - if (streq(opt_ptr, "even")) - { - for (j = 2; j <= MAX_IMAGES; j += 2) - imagelist[i++] = j; - *image_count = MAX_IMAGES / 2; - break; - } - else - { - if (streq(opt_ptr, "last")) - imagelist[i++] = MAX_IMAGES; - else /* single value between commas */ - { - sep = strpbrk(opt_ptr, ":-"); - if (!sep) - imagelist[i++] = atoi(opt_ptr); - else - { - *sep = '\0'; - start = atoi (opt_ptr); - if (!strcmp((sep + 1), "last")) - end = MAX_IMAGES; - else - end = atoi (sep + 1); - for (j = start; j <= end && j - start + i < MAX_IMAGES; j++) - imagelist[i++] = j; - } - } - } - } - } - *image_count = i; - break; - case 'O': /* page orientation */ - switch (tolower(optarg[0])) - { - case 'a': page->orient = ORIENTATION_AUTO; - break; - case 'p': page->orient = ORIENTATION_PORTRAIT; - break; - case 'l': page->orient = ORIENTATION_LANDSCAPE; - break; - default: TIFFError ("Orientation must be portrait, landscape, or auto.", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'P': /* page size selection */ - if (sscanf(optarg, "%lfx%lf", &page->width, &page->length) == 2) - { - strcpy (page->name, "Custom"); - page->mode |= PAGE_MODE_PAPERSIZE; - break; - } - if (get_page_geometry (optarg, page)) - { - if (!strcmp(optarg, "list")) - { - TIFFError("", "Name Width Length (in inches)"); - for (i = 0; i < MAX_PAPERNAMES - 1; i++) - TIFFError ("", "%-15.15s %5.2f %5.2f", - PaperTable[i].name, PaperTable[i].width, - PaperTable[i].length); - exit (-1); - } - - TIFFError ("Invalid paper size", "%s", optarg); - TIFFError ("", "Select one of:"); - TIFFError("", "Name Width Length (in inches)"); - for (i = 0; i < MAX_PAPERNAMES - 1; i++) - TIFFError ("", "%-15.15s %5.2f %5.2f", - PaperTable[i].name, PaperTable[i].width, - PaperTable[i].length); - exit (-1); - } - else - { - page->mode |= PAGE_MODE_PAPERSIZE; - } - break; - case 'R': /* rotate image or cropped segment */ - crop_data->crop_mode |= CROP_ROTATE; - switch (strtoul(optarg, NULL, 0)) - { - case 90: crop_data->rotation = (uint16)90; - break; - case 180: crop_data->rotation = (uint16)180; - break; - case 270: crop_data->rotation = (uint16)270; - break; - default: TIFFError ("Rotation must be 90, 180, or 270 degrees clockwise", "%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'S': /* subdivide into Cols:Rows sections, eg 3:2 would be 3 across and 2 down */ - sep = strpbrk(optarg, ",:"); - if (sep) - { - *sep = '\0'; - page->cols = atoi(optarg); - page->rows = atoi(sep +1); - } - else - { - page->cols = atoi(optarg); - page->rows = atoi(optarg); - } - if ((page->cols * page->rows) > MAX_SECTIONS) - { - TIFFError ("Limit for subdivisions, ie rows x columns, exceeded", "%d", MAX_SECTIONS); - exit (-1); - } - page->mode |= PAGE_MODE_ROWSCOLS; - break; - case 'U': /* units for measurements and offsets */ - if (streq(optarg, "in")) - { - crop_data->res_unit = RESUNIT_INCH; - page->res_unit = RESUNIT_INCH; - } - else if (streq(optarg, "cm")) - { - crop_data->res_unit = RESUNIT_CENTIMETER; - page->res_unit = RESUNIT_CENTIMETER; - } - else if (streq(optarg, "px")) - { - crop_data->res_unit = RESUNIT_NONE; - page->res_unit = RESUNIT_NONE; - } - else - { - TIFFError ("Illegal unit of measure","%s", optarg); - TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - } - break; - case 'V': /* set vertical resolution to new value */ - page->vres = atof (optarg); - page->mode |= PAGE_MODE_RESOLUTION; - break; - case 'X': /* selection width */ - crop_data->crop_mode |= CROP_WIDTH; - crop_data->width = atof(optarg); - break; - case 'Y': /* selection length */ - crop_data->crop_mode |= CROP_LENGTH; - crop_data->length = atof(optarg); - break; - case 'Z': /* zones of an image X:Y read as zone X of Y */ - crop_data->crop_mode |= CROP_ZONES; - for (i = 0, opt_ptr = strtok (optarg, ","); - ((opt_ptr != NULL) && (i < MAX_REGIONS)); - (opt_ptr = strtok (NULL, ",")), i++) - { - crop_data->zones++; - opt_offset = strchr(opt_ptr, ':'); - if (!opt_offset) { - TIFFError("Wrong parameter syntax for -Z", "tiffcrop -h"); - exit(-1); - } - *opt_offset = '\0'; - crop_data->zonelist[i].position = atoi(opt_ptr); - crop_data->zonelist[i].total = atoi(opt_offset + 1); - } - /* check for remaining elements over MAX_REGIONS */ - if ((opt_ptr != NULL) && (i >= MAX_REGIONS)) - { - TIFFError("Zone list exceeds region limit", "%d", MAX_REGIONS); - exit (-1); - } - break; - case '?': TIFFError ("For valid options type", "tiffcrop -h"); - exit (-1); - /*NOTREACHED*/ - } - } - } /* end process_command_opts */ - -/* Start a new output file if one has not been previously opened or - * autoindex is set to non-zero. Update page and file counters - * so TIFFTAG PAGENUM will be correct in image. - */ -static int -update_output_file (TIFF **tiffout, char *mode, int autoindex, - char *outname, unsigned int *page) - { - static int findex = 0; /* file sequence indicator */ - char *sep; - char filenum[16]; - char export_ext[16]; - char exportname[PATH_MAX]; - - if (autoindex && (*tiffout != NULL)) - { - /* Close any export file that was previously opened */ - TIFFClose (*tiffout); - *tiffout = NULL; - } - - strcpy (export_ext, ".tiff"); - memset (exportname, '\0', PATH_MAX); - - /* Leave room for page number portion of the new filename */ - strncpy (exportname, outname, PATH_MAX - 16); - if (*tiffout == NULL) /* This is a new export file */ - { - if (autoindex) - { /* create a new filename for each export */ - findex++; - if ((sep = strstr(exportname, ".tif")) || (sep = strstr(exportname, ".TIF"))) - { - strncpy (export_ext, sep, 5); - *sep = '\0'; - } - else - strncpy (export_ext, ".tiff", 5); - export_ext[5] = '\0'; - - /* MAX_EXPORT_PAGES limited to 6 digits to prevent string overflow of pathname */ - if (findex > MAX_EXPORT_PAGES) - { - TIFFError("update_output_file", "Maximum of %d pages per file exceeded", MAX_EXPORT_PAGES); - return 1; - } - - snprintf(filenum, sizeof(filenum), "-%03d%s", findex, export_ext); - filenum[14] = '\0'; - strncat (exportname, filenum, 15); - } - exportname[PATH_MAX - 1] = '\0'; - - *tiffout = TIFFOpen(exportname, mode); - if (*tiffout == NULL) - { - TIFFError("update_output_file", "Unable to open output file %s", exportname); - return 1; - } - *page = 0; - - return 0; - } - else - (*page)++; - - return 0; - } /* end update_output_file */ - - -int -main(int argc, char* argv[]) - { - extern int optind; - uint16 defconfig = (uint16) -1; - uint16 deffillorder = 0; - uint32 deftilewidth = (uint32) 0; - uint32 deftilelength = (uint32) 0; - uint32 defrowsperstrip = (uint32) 0; - uint32 dirnum = 0; - - TIFF *in = NULL; - TIFF *out = NULL; - char mode[10]; - char *mp = mode; - - /** RJN additions **/ - struct image_data image; /* Image parameters for one image */ - struct crop_mask crop; /* Cropping parameters for all images */ - struct pagedef page; /* Page definition for output pages */ - struct pageseg sections[MAX_SECTIONS]; /* Sections of one output page */ - struct buffinfo seg_buffs[MAX_SECTIONS]; /* Segment buffer sizes and pointers */ - struct dump_opts dump; /* Data dump options */ - unsigned char *read_buff = NULL; /* Input image data buffer */ - unsigned char *crop_buff = NULL; /* Crop area buffer */ - unsigned char *sect_buff = NULL; /* Image section buffer */ - unsigned char *sect_src = NULL; /* Image section buffer pointer */ - unsigned int imagelist[MAX_IMAGES + 1]; /* individually specified images */ - unsigned int image_count = 0; - unsigned int dump_images = 0; - unsigned int next_image = 0; - unsigned int next_page = 0; - unsigned int total_pages = 0; - unsigned int total_images = 0; - unsigned int end_of_input = FALSE; - int seg, length; - char temp_filename[PATH_MAX + 1]; - - little_endian = *((unsigned char *)&little_endian) & '1'; - - initImageData(&image); - initCropMasks(&crop); - initPageSetup(&page, sections, seg_buffs); - initDumpOptions(&dump); - - process_command_opts (argc, argv, mp, mode, &dirnum, &defconfig, - &deffillorder, &deftilewidth, &deftilelength, &defrowsperstrip, - &crop, &page, &dump, imagelist, &image_count); - - if (argc - optind < 2) - usage(); - - if ((argc - optind) == 2) - pageNum = -1; - else - total_images = 0; - /* read multiple input files and write to output file(s) */ - while (optind < argc - 1) - { - in = TIFFOpen (argv[optind], "r"); - if (in == NULL) - return (-3); - - /* If only one input file is specified, we can use directory count */ - total_images = TIFFNumberOfDirectories(in); - if (image_count == 0) - { - dirnum = 0; - total_pages = total_images; /* Only valid with single input file */ - } - else - { - dirnum = (tdir_t)(imagelist[next_image] - 1); - next_image++; - - /* Total pages only valid for enumerated list of pages not derived - * using odd, even, or last keywords. - */ - if (image_count > total_images) - image_count = total_images; - - total_pages = image_count; - } - - /* MAX_IMAGES is used for special case "last" in selection list */ - if (dirnum == (MAX_IMAGES - 1)) - dirnum = total_images - 1; - - if (dirnum > (total_images)) - { - TIFFError (TIFFFileName(in), - "Invalid image number %d, File contains only %d images", - (int)dirnum + 1, total_images); - if (out != NULL) - (void) TIFFClose(out); - return (1); - } - - if (dirnum != 0 && !TIFFSetDirectory(in, (tdir_t)dirnum)) - { - TIFFError(TIFFFileName(in),"Error, setting subdirectory at %d", dirnum); - if (out != NULL) - (void) TIFFClose(out); - return (1); - } - - end_of_input = FALSE; - while (end_of_input == FALSE) - { - config = defconfig; - compression = defcompression; - predictor = defpredictor; - fillorder = deffillorder; - rowsperstrip = defrowsperstrip; - tilewidth = deftilewidth; - tilelength = deftilelength; - g3opts = defg3opts; - - if (dump.format != DUMP_NONE) - { - /* manage input and/or output dump files here */ - dump_images++; - length = strlen(dump.infilename); - if (length > 0) - { - if (dump.infile != NULL) - fclose (dump.infile); - - /* dump.infilename is guaranteed to be NUL termimated and have 20 bytes - fewer than PATH_MAX */ - snprintf(temp_filename, sizeof(temp_filename), "%s-read-%03d.%s", - dump.infilename, dump_images, - (dump.format == DUMP_TEXT) ? "txt" : "raw"); - if ((dump.infile = fopen(temp_filename, dump.mode)) == NULL) - { - TIFFError ("Unable to open dump file for writing", "%s", temp_filename); - exit (-1); - } - dump_info(dump.infile, dump.format, "Reading image","%d from %s", - dump_images, TIFFFileName(in)); - } - length = strlen(dump.outfilename); - if (length > 0) - { - if (dump.outfile != NULL) - fclose (dump.outfile); - - /* dump.outfilename is guaranteed to be NUL termimated and have 20 bytes - fewer than PATH_MAX */ - snprintf(temp_filename, sizeof(temp_filename), "%s-write-%03d.%s", - dump.outfilename, dump_images, - (dump.format == DUMP_TEXT) ? "txt" : "raw"); - if ((dump.outfile = fopen(temp_filename, dump.mode)) == NULL) - { - TIFFError ("Unable to open dump file for writing", "%s", temp_filename); - exit (-1); - } - dump_info(dump.outfile, dump.format, "Writing image","%d from %s", - dump_images, TIFFFileName(in)); - } - } - - if (dump.debug) - TIFFError("main", "Reading image %4d of %4d total pages.", dirnum + 1, total_pages); - - if (loadImage(in, &image, &dump, &read_buff)) - { - TIFFError("main", "Unable to load source image"); - exit (-1); - } - - /* Correct the image orientation if it was not ORIENTATION_TOPLEFT. - */ - if (image.adjustments != 0) - { - if (correct_orientation(&image, &read_buff)) - TIFFError("main", "Unable to correct image orientation"); - } - - if (getCropOffsets(&image, &crop, &dump)) - { - TIFFError("main", "Unable to define crop regions"); - exit (-1); - } - - if (crop.selections > 0) - { - if (processCropSelections(&image, &crop, &read_buff, seg_buffs)) - { - TIFFError("main", "Unable to process image selections"); - exit (-1); - } - } - else /* Single image segment without zones or regions */ - { - if (createCroppedImage(&image, &crop, &read_buff, &crop_buff)) - { - TIFFError("main", "Unable to create output image"); - exit (-1); - } - } - if (page.mode == PAGE_MODE_NONE) - { /* Whole image or sections not based on output page size */ - if (crop.selections > 0) - { - writeSelections(in, &out, &crop, &image, &dump, seg_buffs, - mp, argv[argc - 1], &next_page, total_pages); - } - else /* One file all images and sections */ - { - if (update_output_file (&out, mp, crop.exp_mode, argv[argc - 1], - &next_page)) - exit (1); - if (writeCroppedImage(in, out, &image, &dump,crop.combined_width, - crop.combined_length, crop_buff, next_page, total_pages)) - { - TIFFError("main", "Unable to write new image"); - exit (-1); - } - } - } - else - { - /* If we used a crop buffer, our data is there, otherwise it is - * in the read_buffer - */ - if (crop_buff != NULL) - sect_src = crop_buff; - else - sect_src = read_buff; - /* Break input image into pages or rows and columns */ - if (computeOutputPixelOffsets(&crop, &image, &page, sections, &dump)) - { - TIFFError("main", "Unable to compute output section data"); - exit (-1); - } - /* If there are multiple files on the command line, the final one is assumed - * to be the output filename into which the images are written. - */ - if (update_output_file (&out, mp, crop.exp_mode, argv[argc - 1], &next_page)) - exit (1); - - if (writeImageSections(in, out, &image, &page, sections, &dump, sect_src, §_buff)) - { - TIFFError("main", "Unable to write image sections"); - exit (-1); - } - } - - /* No image list specified, just read the next image */ - if (image_count == 0) - dirnum++; - else - { - dirnum = (tdir_t)(imagelist[next_image] - 1); - next_image++; - } - - if (dirnum == MAX_IMAGES - 1) - dirnum = TIFFNumberOfDirectories(in) - 1; - - if (!TIFFSetDirectory(in, (tdir_t)dirnum)) - end_of_input = TRUE; - } - TIFFClose(in); - optind++; - } - - /* If we did not use the read buffer as the crop buffer */ - if (read_buff) - _TIFFfree(read_buff); - - if (crop_buff) - _TIFFfree(crop_buff); - - if (sect_buff) - _TIFFfree(sect_buff); - - /* Clean up any segment buffers used for zones or regions */ - for (seg = 0; seg < crop.selections; seg++) - _TIFFfree (seg_buffs[seg].buffer); - - if (dump.format != DUMP_NONE) - { - if (dump.infile != NULL) - fclose (dump.infile); - - if (dump.outfile != NULL) - { - dump_info (dump.outfile, dump.format, "", "Completed run for %s", TIFFFileName(out)); - fclose (dump.outfile); - } - } - - TIFFClose(out); - - return (0); - } /* end main */ - - -/* Debugging functions */ -static int dump_data (FILE *dumpfile, int format, char *dump_tag, unsigned char *data, uint32 count) - { - int j, k; - uint32 i; - char dump_array[10]; - unsigned char bitset; - - if (dumpfile == NULL) - { - TIFFError ("", "Invalid FILE pointer for dump file"); - return (1); - } - - if (format == DUMP_TEXT) - { - fprintf (dumpfile," %s ", dump_tag); - for (i = 0; i < count; i++) - { - for (j = 0, k = 7; j < 8; j++, k--) - { - bitset = (*(data + i)) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&dump_array[j], (bitset) ? "1" : "0"); - } - dump_array[8] = '\0'; - fprintf (dumpfile," %s", dump_array); - } - fprintf (dumpfile,"\n"); - } - else - { - if ((fwrite (data, 1, count, dumpfile)) != count) - { - TIFFError ("", "Unable to write binary data to dump file"); - return (1); - } - } - - return (0); - } - -static int dump_byte (FILE *dumpfile, int format, char *dump_tag, unsigned char data) - { - int j, k; - char dump_array[10]; - unsigned char bitset; - - if (dumpfile == NULL) - { - TIFFError ("", "Invalid FILE pointer for dump file"); - return (1); - } - - if (format == DUMP_TEXT) - { - fprintf (dumpfile," %s ", dump_tag); - for (j = 0, k = 7; j < 8; j++, k--) - { - bitset = data & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&dump_array[j], (bitset) ? "1" : "0"); - } - dump_array[8] = '\0'; - fprintf (dumpfile," %s\n", dump_array); - } - else - { - if ((fwrite (&data, 1, 1, dumpfile)) != 1) - { - TIFFError ("", "Unable to write binary data to dump file"); - return (1); - } - } - - return (0); - } - -static int dump_short (FILE *dumpfile, int format, char *dump_tag, uint16 data) - { - int j, k; - char dump_array[20]; - unsigned char bitset; - - if (dumpfile == NULL) - { - TIFFError ("", "Invalid FILE pointer for dump file"); - return (1); - } - - if (format == DUMP_TEXT) - { - fprintf (dumpfile," %s ", dump_tag); - for (j = 0, k = 15; k >= 0; j++, k--) - { - bitset = data & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&dump_array[j], (bitset) ? "1" : "0"); - if ((k % 8) == 0) - sprintf(&dump_array[++j], " "); - } - dump_array[17] = '\0'; - fprintf (dumpfile," %s\n", dump_array); - } - else - { - if ((fwrite (&data, 2, 1, dumpfile)) != 2) - { - TIFFError ("", "Unable to write binary data to dump file"); - return (1); - } - } - - return (0); - } - -static int dump_long (FILE *dumpfile, int format, char *dump_tag, uint32 data) - { - int j, k; - char dump_array[40]; - unsigned char bitset; - - if (dumpfile == NULL) - { - TIFFError ("", "Invalid FILE pointer for dump file"); - return (1); - } - - if (format == DUMP_TEXT) - { - fprintf (dumpfile," %s ", dump_tag); - for (j = 0, k = 31; k >= 0; j++, k--) - { - bitset = data & (((uint32)1 << k)) ? 1 : 0; - sprintf(&dump_array[j], (bitset) ? "1" : "0"); - if ((k % 8) == 0) - sprintf(&dump_array[++j], " "); - } - dump_array[35] = '\0'; - fprintf (dumpfile," %s\n", dump_array); - } - else - { - if ((fwrite (&data, 4, 1, dumpfile)) != 4) - { - TIFFError ("", "Unable to write binary data to dump file"); - return (1); - } - } - return (0); - } - -static int dump_wide (FILE *dumpfile, int format, char *dump_tag, uint64 data) - { - int j, k; - char dump_array[80]; - unsigned char bitset; - - if (dumpfile == NULL) - { - TIFFError ("", "Invalid FILE pointer for dump file"); - return (1); - } - - if (format == DUMP_TEXT) - { - fprintf (dumpfile," %s ", dump_tag); - for (j = 0, k = 63; k >= 0; j++, k--) - { - bitset = data & (((uint64)1 << k)) ? 1 : 0; - sprintf(&dump_array[j], (bitset) ? "1" : "0"); - if ((k % 8) == 0) - sprintf(&dump_array[++j], " "); - } - dump_array[71] = '\0'; - fprintf (dumpfile," %s\n", dump_array); - } - else - { - if ((fwrite (&data, 8, 1, dumpfile)) != 8) - { - TIFFError ("", "Unable to write binary data to dump file"); - return (1); - } - } - - return (0); - } - -static void dump_info(FILE *dumpfile, int format, char *prefix, char *msg, ...) - { - if (format == DUMP_TEXT) - { - va_list ap; - va_start(ap, msg); - fprintf(dumpfile, "%s ", prefix); - vfprintf(dumpfile, msg, ap); - fprintf(dumpfile, "\n"); - va_end(ap); - } - } - -static int dump_buffer (FILE* dumpfile, int format, uint32 rows, uint32 width, - uint32 row, unsigned char *buff) - { - int j, k; - uint32 i; - unsigned char * dump_ptr; - - if (dumpfile == NULL) - { - TIFFError ("", "Invalid FILE pointer for dump file"); - return (1); - } - - for (i = 0; i < rows; i++) - { - dump_ptr = buff + (i * width); - if (format == DUMP_TEXT) - dump_info (dumpfile, format, "", - "Row %4d, %d bytes at offset %d", - row + i + 1, width, row * width); - - for (j = 0, k = width; k >= 10; j += 10, k -= 10, dump_ptr += 10) - dump_data (dumpfile, format, "", dump_ptr, 10); - if (k > 0) - dump_data (dumpfile, format, "", dump_ptr, k); - } - return (0); - } - -/* Extract one or more samples from an interleaved buffer. If count == 1, - * only the sample plane indicated by sample will be extracted. If count > 1, - * count samples beginning at sample will be extracted. Portions of a - * scanline can be extracted by specifying a start and end value. - */ - -static int -extractContigSamplesBytes (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end) - { - int i, bytes_per_sample, sindex; - uint32 col, dst_rowsize, bit_offset; - uint32 src_byte /*, src_bit */; - uint8 *src = in; - uint8 *dst = out; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("extractContigSamplesBytes","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamplesBytes", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamplesBytes", - "Invalid end column value %d ignored", end); - end = cols; - } - - dst_rowsize = (bps * (end - start) * count) / 8; - - bytes_per_sample = (bps + 7) / 8; - /* Optimize case for copying all samples */ - if (count == spp) - { - src = in + (start * spp * bytes_per_sample); - _TIFFmemcpy (dst, src, dst_rowsize); - } - else - { - for (col = start; col < end; col++) - { - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - bit_offset = col * bps * spp; - if (sindex == 0) - { - src_byte = bit_offset / 8; - /* src_bit = bit_offset % 8; */ - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - /* src_bit = (bit_offset + (sindex * bps)) % 8; */ - } - src = in + src_byte; - for (i = 0; i < bytes_per_sample; i++) - *dst++ = *src++; - } - } - } - - return (0); - } /* end extractContigSamplesBytes */ - -static int -extractContigSamples8bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end) - { - int ready_bits = 0, sindex = 0; - uint32 col, src_byte, src_bit, bit_offset; - uint8 maskbits = 0, matchbits = 0; - uint8 buff1 = 0, buff2 = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("extractContigSamples8bits","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamples8bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamples8bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - ready_bits = 0; - maskbits = (uint8)-1 >> ( 8 - bps); - buff1 = buff2 = 0; - for (col = start; col < end; col++) - { /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (8 - src_bit - bps); - buff1 = ((*src) & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - *dst++ = buff2; - buff2 = buff1; - ready_bits -= 8; - } - else - buff2 = (buff2 | (buff1 >> ready_bits)); - ready_bits += bps; - } - } - - while (ready_bits > 0) - { - buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits))); - *dst++ = buff1; - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamples8bits */ - -static int -extractContigSamples16bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end) - { - int ready_bits = 0, sindex = 0; - uint32 col, src_byte, src_bit, bit_offset; - uint16 maskbits = 0, matchbits = 0; - uint16 buff1 = 0, buff2 = 0; - uint8 bytebuff = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("extractContigSamples16bits","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamples16bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamples16bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - ready_bits = 0; - maskbits = (uint16)-1 >> (16 - bps); - - for (col = start; col < end; col++) - { /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (16 - src_bit - bps); - - if (little_endian) - buff1 = (src[0] << 8) | src[1]; - else - buff1 = (src[1] << 8) | src[0]; - - buff1 = (buff1 & matchbits) << (src_bit); - if (ready_bits < 8) /* add another bps bits to the buffer */ - { - bytebuff = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - /* shift in new bits */ - buff2 = ((buff2 << 8) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamples16bits */ - - -static int -extractContigSamples24bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end) - { - int ready_bits = 0, sindex = 0; - uint32 col, src_byte, src_bit, bit_offset; - uint32 maskbits = 0, matchbits = 0; - uint32 buff1 = 0, buff2 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((in == NULL) || (out == NULL)) - { - TIFFError("extractContigSamples24bits","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamples24bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamples24bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - ready_bits = 0; - maskbits = (uint32)-1 >> ( 32 - bps); - for (col = start; col < end; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (32 - src_bit - bps); - if (little_endian) - buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - else - buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - buff1 = (buff1 & matchbits) << (src_bit); - - if (ready_bits < 16) /* add another bps bits to the buffer */ - { - bytebuff1 = bytebuff2 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 16); - *dst++ = bytebuff2; - ready_bits -= 16; - - /* shift in new bits */ - buff2 = ((buff2 << 16) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - - buff2 = (buff2 << 8); - bytebuff2 = bytebuff1; - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamples24bits */ - -static int -extractContigSamples32bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end) - { - int ready_bits = 0, sindex = 0 /*, shift_width = 0 */; - uint32 col, src_byte, src_bit, bit_offset; - uint32 longbuff1 = 0, longbuff2 = 0; - uint64 maskbits = 0, matchbits = 0; - uint64 buff1 = 0, buff2 = 0, buff3 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((in == NULL) || (out == NULL)) - { - TIFFError("extractContigSamples32bits","Invalid input or output buffer"); - return (1); - } - - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamples32bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamples32bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - /* shift_width = ((bps + 7) / 8) + 1; */ - ready_bits = 0; - maskbits = (uint64)-1 >> ( 64 - bps); - for (col = start; col < end; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (64 - src_bit - bps); - if (little_endian) - { - longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - longbuff2 = longbuff1; - } - else - { - longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - longbuff2 = longbuff1; - } - - buff3 = ((uint64)longbuff1 << 32) | longbuff2; - buff1 = (buff3 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 32) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 48); - *dst++ = bytebuff2; - bytebuff3 = (buff2 >> 40); - *dst++ = bytebuff3; - bytebuff4 = (buff2 >> 32); - *dst++ = bytebuff4; - ready_bits -= 32; - - /* shift in new bits */ - buff2 = ((buff2 << 32) | (buff1 >> ready_bits)); - } - else - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - buff2 = (buff2 << 8); - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamples32bits */ - -static int -extractContigSamplesShifted8bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end, - int shift) - { - int ready_bits = 0, sindex = 0; - uint32 col, src_byte, src_bit, bit_offset; - uint8 maskbits = 0, matchbits = 0; - uint8 buff1 = 0, buff2 = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("extractContigSamplesShifted8bits","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamplesShifted8bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamplesShifted8bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - ready_bits = shift; - maskbits = (uint8)-1 >> ( 8 - bps); - buff1 = buff2 = 0; - for (col = start; col < end; col++) - { /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (8 - src_bit - bps); - buff1 = ((*src) & matchbits) << (src_bit); - if ((col == start) && (sindex == sample)) - buff2 = *src & ((uint8)-1) << (shift); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - *dst++ |= buff2; - buff2 = buff1; - ready_bits -= 8; - } - else - buff2 = buff2 | (buff1 >> ready_bits); - ready_bits += bps; - } - } - - while (ready_bits > 0) - { - buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits))); - *dst++ = buff1; - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamplesShifted8bits */ - -static int -extractContigSamplesShifted16bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end, - int shift) - { - int ready_bits = 0, sindex = 0; - uint32 col, src_byte, src_bit, bit_offset; - uint16 maskbits = 0, matchbits = 0; - uint16 buff1 = 0, buff2 = 0; - uint8 bytebuff = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("extractContigSamplesShifted16bits","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamplesShifted16bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamplesShifted16bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - ready_bits = shift; - maskbits = (uint16)-1 >> (16 - bps); - for (col = start; col < end; col++) - { /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (16 - src_bit - bps); - if (little_endian) - buff1 = (src[0] << 8) | src[1]; - else - buff1 = (src[1] << 8) | src[0]; - - if ((col == start) && (sindex == sample)) - buff2 = buff1 & ((uint16)-1) << (8 - shift); - - buff1 = (buff1 & matchbits) << (src_bit); - - if (ready_bits < 8) /* add another bps bits to the buffer */ - buff2 = buff2 | (buff1 >> ready_bits); - else /* If we have a full buffer's worth, write it out */ - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - /* shift in new bits */ - buff2 = ((buff2 << 8) | (buff1 >> ready_bits)); - } - - ready_bits += bps; - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamplesShifted16bits */ - - -static int -extractContigSamplesShifted24bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end, - int shift) - { - int ready_bits = 0, sindex = 0; - uint32 col, src_byte, src_bit, bit_offset; - uint32 maskbits = 0, matchbits = 0; - uint32 buff1 = 0, buff2 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((in == NULL) || (out == NULL)) - { - TIFFError("extractContigSamplesShifted24bits","Invalid input or output buffer"); - return (1); - } - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamplesShifted24bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamplesShifted24bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - ready_bits = shift; - maskbits = (uint32)-1 >> ( 32 - bps); - for (col = start; col < end; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (32 - src_bit - bps); - if (little_endian) - buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - else - buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - - if ((col == start) && (sindex == sample)) - buff2 = buff1 & ((uint32)-1) << (16 - shift); - - buff1 = (buff1 & matchbits) << (src_bit); - - if (ready_bits < 16) /* add another bps bits to the buffer */ - { - bytebuff1 = bytebuff2 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 16); - *dst++ = bytebuff2; - ready_bits -= 16; - - /* shift in new bits */ - buff2 = ((buff2 << 16) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - - buff2 = (buff2 << 8); - bytebuff2 = bytebuff1; - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamplesShifted24bits */ - -static int -extractContigSamplesShifted32bits (uint8 *in, uint8 *out, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - tsample_t count, uint32 start, uint32 end, - int shift) - { - int ready_bits = 0, sindex = 0 /*, shift_width = 0 */; - uint32 col, src_byte, src_bit, bit_offset; - uint32 longbuff1 = 0, longbuff2 = 0; - uint64 maskbits = 0, matchbits = 0; - uint64 buff1 = 0, buff2 = 0, buff3 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0; - uint8 *src = in; - uint8 *dst = out; - - if ((in == NULL) || (out == NULL)) - { - TIFFError("extractContigSamplesShifted32bits","Invalid input or output buffer"); - return (1); - } - - - if ((start > end) || (start > cols)) - { - TIFFError ("extractContigSamplesShifted32bits", - "Invalid start column value %d ignored", start); - start = 0; - } - if ((end == 0) || (end > cols)) - { - TIFFError ("extractContigSamplesShifted32bits", - "Invalid end column value %d ignored", end); - end = cols; - } - - /* shift_width = ((bps + 7) / 8) + 1; */ - ready_bits = shift; - maskbits = (uint64)-1 >> ( 64 - bps); - for (col = start; col < end; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps * spp; - for (sindex = sample; (sindex < spp) && (sindex < (sample + count)); sindex++) - { - if (sindex == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sindex * bps)) / 8; - src_bit = (bit_offset + (sindex * bps)) % 8; - } - - src = in + src_byte; - matchbits = maskbits << (64 - src_bit - bps); - if (little_endian) - { - longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - longbuff2 = longbuff1; - } - else - { - longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - longbuff2 = longbuff1; - } - - buff3 = ((uint64)longbuff1 << 32) | longbuff2; - if ((col == start) && (sindex == sample)) - buff2 = buff3 & ((uint64)-1) << (32 - shift); - - buff1 = (buff3 & matchbits) << (src_bit); - - if (ready_bits < 32) - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 48); - *dst++ = bytebuff2; - bytebuff3 = (buff2 >> 40); - *dst++ = bytebuff3; - bytebuff4 = (buff2 >> 32); - *dst++ = bytebuff4; - ready_bits -= 32; - - /* shift in new bits */ - buff2 = ((buff2 << 32) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - buff2 = (buff2 << 8); - ready_bits -= 8; - } - - return (0); - } /* end extractContigSamplesShifted32bits */ - -static int -extractContigSamplesToBuffer(uint8 *out, uint8 *in, uint32 rows, uint32 cols, - tsample_t sample, uint16 spp, uint16 bps, - struct dump_opts *dump) - { - int shift_width, bytes_per_sample, bytes_per_pixel; - uint32 src_rowsize, src_offset, row, first_col = 0; - uint32 dst_rowsize, dst_offset; - tsample_t count = 1; - uint8 *src, *dst; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if ((bps % 8) == 0) - shift_width = 0; - else - { - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - } - src_rowsize = ((bps * spp * cols) + 7) / 8; - dst_rowsize = ((bps * cols) + 7) / 8; - - if ((dump->outfile != NULL) && (dump->level == 4)) - { - dump_info (dump->outfile, dump->format, "extractContigSamplesToBuffer", - "Sample %d, %d rows", sample + 1, rows + 1); - } - for (row = 0; row < rows; row++) - { - src_offset = row * src_rowsize; - dst_offset = row * dst_rowsize; - src = in + src_offset; - dst = out + dst_offset; - - /* pack the data into the scanline */ - switch (shift_width) - { - case 0: if (extractContigSamplesBytes (src, dst, cols, sample, - spp, bps, count, first_col, cols)) - return (1); - break; - case 1: if (bps == 1) - { - if (extractContigSamples8bits (src, dst, cols, sample, - spp, bps, count, first_col, cols)) - return (1); - break; - } - else - if (extractContigSamples16bits (src, dst, cols, sample, - spp, bps, count, first_col, cols)) - return (1); - break; - case 2: if (extractContigSamples24bits (src, dst, cols, sample, - spp, bps, count, first_col, cols)) - return (1); - break; - case 3: - case 4: - case 5: if (extractContigSamples32bits (src, dst, cols, sample, - spp, bps, count, first_col, cols)) - return (1); - break; - default: TIFFError ("extractContigSamplesToBuffer", "Unsupported bit depth: %d", bps); - return (1); - } - if ((dump->outfile != NULL) && (dump->level == 4)) - dump_buffer(dump->outfile, dump->format, 1, dst_rowsize, row, dst); - } - - return (0); - } /* end extractContigSamplesToBuffer */ - -static int -extractContigSamplesToTileBuffer(uint8 *out, uint8 *in, uint32 rows, uint32 cols, - uint32 imagewidth, uint32 tilewidth, tsample_t sample, - uint16 count, uint16 spp, uint16 bps, struct dump_opts *dump) - { - int shift_width, bytes_per_sample, bytes_per_pixel; - uint32 src_rowsize, src_offset, row; - uint32 dst_rowsize, dst_offset; - uint8 *src, *dst; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if ((bps % 8) == 0) - shift_width = 0; - else - { - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - } - - if ((dump->outfile != NULL) && (dump->level == 4)) - { - dump_info (dump->outfile, dump->format, "extractContigSamplesToTileBuffer", - "Sample %d, %d rows", sample + 1, rows + 1); - } - - src_rowsize = ((bps * spp * imagewidth) + 7) / 8; - dst_rowsize = ((bps * tilewidth * count) + 7) / 8; - - for (row = 0; row < rows; row++) - { - src_offset = row * src_rowsize; - dst_offset = row * dst_rowsize; - src = in + src_offset; - dst = out + dst_offset; - - /* pack the data into the scanline */ - switch (shift_width) - { - case 0: if (extractContigSamplesBytes (src, dst, cols, sample, - spp, bps, count, 0, cols)) - return (1); - break; - case 1: if (bps == 1) - { - if (extractContigSamples8bits (src, dst, cols, sample, - spp, bps, count, 0, cols)) - return (1); - break; - } - else - if (extractContigSamples16bits (src, dst, cols, sample, - spp, bps, count, 0, cols)) - return (1); - break; - case 2: if (extractContigSamples24bits (src, dst, cols, sample, - spp, bps, count, 0, cols)) - return (1); - break; - case 3: - case 4: - case 5: if (extractContigSamples32bits (src, dst, cols, sample, - spp, bps, count, 0, cols)) - return (1); - break; - default: TIFFError ("extractContigSamplesToTileBuffer", "Unsupported bit depth: %d", bps); - return (1); - } - if ((dump->outfile != NULL) && (dump->level == 4)) - dump_buffer(dump->outfile, dump->format, 1, dst_rowsize, row, dst); - } - - return (0); - } /* end extractContigSamplesToTileBuffer */ - -static int readContigStripsIntoBuffer (TIFF* in, uint8* buf) - { - uint8* bufp = buf; - int32 bytes_read = 0; - uint16 strip, nstrips = TIFFNumberOfStrips(in); - uint32 stripsize = TIFFStripSize(in); - uint32 rows = 0; - uint32 rps = TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps); - tsize_t scanline_size = TIFFScanlineSize(in); - - for (strip = 0; strip < nstrips; strip++) - { - bytes_read = TIFFReadEncodedStrip (in, strip, bufp, -1); - rows = bytes_read / scanline_size; - if ((strip < (nstrips - 1)) && (bytes_read != (int32)stripsize)) - TIFFError("", "Strip %d: read %lu bytes, strip size %lu", - (int)strip + 1, (unsigned long) bytes_read, (unsigned long)stripsize); - - if (bytes_read < 0 && !ignore) - { - TIFFError("", "Error reading strip %lu after %lu rows", - (unsigned long) strip, (unsigned long)rows); - return 0; - } - bufp += bytes_read; - } - - return 1; - } /* end readContigStripsIntoBuffer */ - -static int -combineSeparateSamplesBytes (unsigned char *srcbuffs[], unsigned char *out, - uint32 cols, uint32 rows, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int i, bytes_per_sample; - uint32 row, col, col_offset, src_rowsize, dst_rowsize, row_offset; - unsigned char *src; - unsigned char *dst; - tsample_t s; - - src = srcbuffs[0]; - dst = out; - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateSamplesBytes","Invalid buffer address"); - return (1); - } - - bytes_per_sample = (bps + 7) / 8; - - src_rowsize = ((bps * cols) + 7) / 8; - dst_rowsize = ((bps * spp * cols) + 7) / 8; - for (row = 0; row < rows; row++) - { - if ((dumpfile != NULL) && (level == 2)) - { - for (s = 0; s < spp; s++) - { - dump_info (dumpfile, format, "combineSeparateSamplesBytes","Input data, Sample %d", s); - dump_buffer(dumpfile, format, 1, cols, row, srcbuffs[s] + (row * src_rowsize)); - } - } - dst = out + (row * dst_rowsize); - row_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - col_offset = row_offset + (col * (bps / 8)); - for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++) - { - src = srcbuffs[s] + col_offset; - for (i = 0; i < bytes_per_sample; i++) - *(dst + i) = *(src + i); - src += bytes_per_sample; - dst += bytes_per_sample; - } - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateSamplesBytes","Output data, combined samples"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateSamplesBytes */ - -static int -combineSeparateSamples8bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0; - /* int bytes_per_sample = 0; */ - uint32 src_rowsize, dst_rowsize, src_offset; - uint32 bit_offset; - uint32 row, col, src_byte = 0, src_bit = 0; - uint8 maskbits = 0, matchbits = 0; - uint8 buff1 = 0, buff2 = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[32]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateSamples8bits","Invalid input or output buffer"); - return (1); - } - - /* bytes_per_sample = (bps + 7) / 8; */ - src_rowsize = ((bps * cols) + 7) / 8; - dst_rowsize = ((bps * cols * spp) + 7) / 8; - maskbits = (uint8)-1 >> ( 8 - bps); - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (8 - src_bit - bps); - /* load up next sample from each plane */ - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - buff1 = ((*src) & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - *dst++ = buff2; - buff2 = buff1; - ready_bits -= 8; - strcpy (action, "Flush"); - } - else - { - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Samples %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - dump_byte (dumpfile, format, "Match bits", matchbits); - dump_byte (dumpfile, format, "Src bits", *src); - dump_byte (dumpfile, format, "Buff1 bits", buff1); - dump_byte (dumpfile, format, "Buff2 bits", buff2); - dump_info (dumpfile, format, "","%s", action); - } - } - } - - if (ready_bits > 0) - { - buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits))); - *dst++ = buff1; - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - dump_byte (dumpfile, format, "Final bits", buff1); - } - } - - if ((dumpfile != NULL) && (level >= 2)) - { - dump_info (dumpfile, format, "combineSeparateSamples8bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateSamples8bits */ - -static int -combineSeparateSamples16bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0 /*, bytes_per_sample = 0 */; - uint32 src_rowsize, dst_rowsize; - uint32 bit_offset, src_offset; - uint32 row, col, src_byte = 0, src_bit = 0; - uint16 maskbits = 0, matchbits = 0; - uint16 buff1 = 0, buff2 = 0; - uint8 bytebuff = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[8]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateSamples16bits","Invalid input or output buffer"); - return (1); - } - - /* bytes_per_sample = (bps + 7) / 8; */ - src_rowsize = ((bps * cols) + 7) / 8; - dst_rowsize = ((bps * cols * spp) + 7) / 8; - maskbits = (uint16)-1 >> (16 - bps); - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (16 - src_bit - bps); - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - if (little_endian) - buff1 = (src[0] << 8) | src[1]; - else - buff1 = (src[1] << 8) | src[0]; - - buff1 = (buff1 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - /* shift in new bits */ - buff2 = ((buff2 << 8) | (buff1 >> ready_bits)); - strcpy (action, "Flush"); - } - else - { /* add another bps bits to the buffer */ - bytebuff = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Samples %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - - dump_short (dumpfile, format, "Match bits", matchbits); - dump_data (dumpfile, format, "Src bits", src, 2); - dump_short (dumpfile, format, "Buff1 bits", buff1); - dump_short (dumpfile, format, "Buff2 bits", buff2); - dump_byte (dumpfile, format, "Write byte", bytebuff); - dump_info (dumpfile, format, "","Ready bits: %d, %s", ready_bits, action); - } - } - } - - /* catch any trailing bits at the end of the line */ - if (ready_bits > 0) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - dump_byte (dumpfile, format, "Final bits", bytebuff); - } - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateSamples16bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateSamples16bits */ - -static int -combineSeparateSamples24bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0 /*, bytes_per_sample = 0 */; - uint32 src_rowsize, dst_rowsize; - uint32 bit_offset, src_offset; - uint32 row, col, src_byte = 0, src_bit = 0; - uint32 maskbits = 0, matchbits = 0; - uint32 buff1 = 0, buff2 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[8]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateSamples24bits","Invalid input or output buffer"); - return (1); - } - - /* bytes_per_sample = (bps + 7) / 8; */ - src_rowsize = ((bps * cols) + 7) / 8; - dst_rowsize = ((bps * cols * spp) + 7) / 8; - maskbits = (uint32)-1 >> ( 32 - bps); - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (32 - src_bit - bps); - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - if (little_endian) - buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - else - buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - buff1 = (buff1 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 16) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 16); - *dst++ = bytebuff2; - ready_bits -= 16; - - /* shift in new bits */ - buff2 = ((buff2 << 16) | (buff1 >> ready_bits)); - strcpy (action, "Flush"); - } - else - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Samples %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - dump_long (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 4); - dump_long (dumpfile, format, "Buff1 bits ", buff1); - dump_long (dumpfile, format, "Buff2 bits ", buff2); - dump_byte (dumpfile, format, "Write bits1", bytebuff1); - dump_byte (dumpfile, format, "Write bits2", bytebuff2); - dump_info (dumpfile, format, "","Ready bits: %d, %s", ready_bits, action); - } - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - - buff2 = (buff2 << 8); - bytebuff2 = bytebuff1; - ready_bits -= 8; - } - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - - dump_long (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 4); - dump_long (dumpfile, format, "Buff1 bits ", buff1); - dump_long (dumpfile, format, "Buff2 bits ", buff2); - dump_byte (dumpfile, format, "Write bits1", bytebuff1); - dump_byte (dumpfile, format, "Write bits2", bytebuff2); - dump_info (dumpfile, format, "", "Ready bits: %2d", ready_bits); - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateSamples24bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateSamples24bits */ - -static int -combineSeparateSamples32bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0 /*, bytes_per_sample = 0, shift_width = 0 */; - uint32 src_rowsize, dst_rowsize, bit_offset, src_offset; - uint32 src_byte = 0, src_bit = 0; - uint32 row, col; - uint32 longbuff1 = 0, longbuff2 = 0; - uint64 maskbits = 0, matchbits = 0; - uint64 buff1 = 0, buff2 = 0, buff3 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[8]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateSamples32bits","Invalid input or output buffer"); - return (1); - } - - /* bytes_per_sample = (bps + 7) / 8; */ - src_rowsize = ((bps * cols) + 7) / 8; - dst_rowsize = ((bps * cols * spp) + 7) / 8; - maskbits = (uint64)-1 >> ( 64 - bps); - /* shift_width = ((bps + 7) / 8) + 1; */ - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (64 - src_bit - bps); - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - if (little_endian) - { - longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - longbuff2 = longbuff1; - } - else - { - longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - longbuff2 = longbuff1; - } - buff3 = ((uint64)longbuff1 << 32) | longbuff2; - buff1 = (buff3 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 32) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 48); - *dst++ = bytebuff2; - bytebuff3 = (buff2 >> 40); - *dst++ = bytebuff3; - bytebuff4 = (buff2 >> 32); - *dst++ = bytebuff4; - ready_bits -= 32; - - /* shift in new bits */ - buff2 = ((buff2 << 32) | (buff1 >> ready_bits)); - strcpy (action, "Flush"); - } - else - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Sample %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - dump_wide (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 8); - dump_wide (dumpfile, format, "Buff1 bits ", buff1); - dump_wide (dumpfile, format, "Buff2 bits ", buff2); - dump_info (dumpfile, format, "", "Ready bits: %d, %s", ready_bits, action); - } - } - } - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - buff2 = (buff2 << 8); - ready_bits -= 8; - } - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - - dump_long (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 4); - dump_long (dumpfile, format, "Buff1 bits ", buff1); - dump_long (dumpfile, format, "Buff2 bits ", buff2); - dump_byte (dumpfile, format, "Write bits1", bytebuff1); - dump_byte (dumpfile, format, "Write bits2", bytebuff2); - dump_info (dumpfile, format, "", "Ready bits: %2d", ready_bits); - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateSamples32bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out); - } - } - - return (0); - } /* end combineSeparateSamples32bits */ - -static int -combineSeparateTileSamplesBytes (unsigned char *srcbuffs[], unsigned char *out, - uint32 cols, uint32 rows, uint32 imagewidth, - uint32 tw, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int i, bytes_per_sample; - uint32 row, col, col_offset, src_rowsize, dst_rowsize, src_offset; - unsigned char *src; - unsigned char *dst; - tsample_t s; - - src = srcbuffs[0]; - dst = out; - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateTileSamplesBytes","Invalid buffer address"); - return (1); - } - - bytes_per_sample = (bps + 7) / 8; - src_rowsize = ((bps * tw) + 7) / 8; - dst_rowsize = imagewidth * bytes_per_sample * spp; - for (row = 0; row < rows; row++) - { - if ((dumpfile != NULL) && (level == 2)) - { - for (s = 0; s < spp; s++) - { - dump_info (dumpfile, format, "combineSeparateTileSamplesBytes","Input data, Sample %d", s); - dump_buffer(dumpfile, format, 1, cols, row, srcbuffs[s] + (row * src_rowsize)); - } - } - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; -#ifdef DEVELMODE - TIFFError("","Tile row %4d, Src offset %6d Dst offset %6d", - row, src_offset, dst - out); -#endif - for (col = 0; col < cols; col++) - { - col_offset = src_offset + (col * (bps / 8)); - for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++) - { - src = srcbuffs[s] + col_offset; - for (i = 0; i < bytes_per_sample; i++) - *(dst + i) = *(src + i); - dst += bytes_per_sample; - } - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateTileSamplesBytes","Output data, combined samples"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateTileSamplesBytes */ - -static int -combineSeparateTileSamples8bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint32 imagewidth, - uint32 tw, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0; - uint32 src_rowsize, dst_rowsize, src_offset; - uint32 bit_offset; - uint32 row, col, src_byte = 0, src_bit = 0; - uint8 maskbits = 0, matchbits = 0; - uint8 buff1 = 0, buff2 = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[32]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateTileSamples8bits","Invalid input or output buffer"); - return (1); - } - - src_rowsize = ((bps * tw) + 7) / 8; - dst_rowsize = ((imagewidth * bps * spp) + 7) / 8; - maskbits = (uint8)-1 >> ( 8 - bps); - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (8 - src_bit - bps); - /* load up next sample from each plane */ - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - buff1 = ((*src) & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - *dst++ = buff2; - buff2 = buff1; - ready_bits -= 8; - strcpy (action, "Flush"); - } - else - { - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Samples %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - dump_byte (dumpfile, format, "Match bits", matchbits); - dump_byte (dumpfile, format, "Src bits", *src); - dump_byte (dumpfile, format, "Buff1 bits", buff1); - dump_byte (dumpfile, format, "Buff2 bits", buff2); - dump_info (dumpfile, format, "","%s", action); - } - } - } - - if (ready_bits > 0) - { - buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits))); - *dst++ = buff1; - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - dump_byte (dumpfile, format, "Final bits", buff1); - } - } - - if ((dumpfile != NULL) && (level >= 2)) - { - dump_info (dumpfile, format, "combineSeparateTileSamples8bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateTileSamples8bits */ - -static int -combineSeparateTileSamples16bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint32 imagewidth, - uint32 tw, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0; - uint32 src_rowsize, dst_rowsize; - uint32 bit_offset, src_offset; - uint32 row, col, src_byte = 0, src_bit = 0; - uint16 maskbits = 0, matchbits = 0; - uint16 buff1 = 0, buff2 = 0; - uint8 bytebuff = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[8]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateTileSamples16bits","Invalid input or output buffer"); - return (1); - } - - src_rowsize = ((bps * tw) + 7) / 8; - dst_rowsize = ((imagewidth * bps * spp) + 7) / 8; - maskbits = (uint16)-1 >> (16 - bps); - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (16 - src_bit - bps); - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - if (little_endian) - buff1 = (src[0] << 8) | src[1]; - else - buff1 = (src[1] << 8) | src[0]; - buff1 = (buff1 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - /* shift in new bits */ - buff2 = ((buff2 << 8) | (buff1 >> ready_bits)); - strcpy (action, "Flush"); - } - else - { /* add another bps bits to the buffer */ - bytebuff = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Samples %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - - dump_short (dumpfile, format, "Match bits", matchbits); - dump_data (dumpfile, format, "Src bits", src, 2); - dump_short (dumpfile, format, "Buff1 bits", buff1); - dump_short (dumpfile, format, "Buff2 bits", buff2); - dump_byte (dumpfile, format, "Write byte", bytebuff); - dump_info (dumpfile, format, "","Ready bits: %d, %s", ready_bits, action); - } - } - } - - /* catch any trailing bits at the end of the line */ - if (ready_bits > 0) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - dump_byte (dumpfile, format, "Final bits", bytebuff); - } - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateTileSamples16bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateTileSamples16bits */ - -static int -combineSeparateTileSamples24bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint32 imagewidth, - uint32 tw, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0; - uint32 src_rowsize, dst_rowsize; - uint32 bit_offset, src_offset; - uint32 row, col, src_byte = 0, src_bit = 0; - uint32 maskbits = 0, matchbits = 0; - uint32 buff1 = 0, buff2 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[8]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateTileSamples24bits","Invalid input or output buffer"); - return (1); - } - - src_rowsize = ((bps * tw) + 7) / 8; - dst_rowsize = ((imagewidth * bps * spp) + 7) / 8; - maskbits = (uint32)-1 >> ( 32 - bps); - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (32 - src_bit - bps); - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - if (little_endian) - buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - else - buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - buff1 = (buff1 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 16) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 16); - *dst++ = bytebuff2; - ready_bits -= 16; - - /* shift in new bits */ - buff2 = ((buff2 << 16) | (buff1 >> ready_bits)); - strcpy (action, "Flush"); - } - else - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Samples %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - dump_long (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 4); - dump_long (dumpfile, format, "Buff1 bits ", buff1); - dump_long (dumpfile, format, "Buff2 bits ", buff2); - dump_byte (dumpfile, format, "Write bits1", bytebuff1); - dump_byte (dumpfile, format, "Write bits2", bytebuff2); - dump_info (dumpfile, format, "","Ready bits: %d, %s", ready_bits, action); - } - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - - buff2 = (buff2 << 8); - bytebuff2 = bytebuff1; - ready_bits -= 8; - } - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - - dump_long (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 4); - dump_long (dumpfile, format, "Buff1 bits ", buff1); - dump_long (dumpfile, format, "Buff2 bits ", buff2); - dump_byte (dumpfile, format, "Write bits1", bytebuff1); - dump_byte (dumpfile, format, "Write bits2", bytebuff2); - dump_info (dumpfile, format, "", "Ready bits: %2d", ready_bits); - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateTileSamples24bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out + (row * dst_rowsize)); - } - } - - return (0); - } /* end combineSeparateTileSamples24bits */ - -static int -combineSeparateTileSamples32bits (uint8 *in[], uint8 *out, uint32 cols, - uint32 rows, uint32 imagewidth, - uint32 tw, uint16 spp, uint16 bps, - FILE *dumpfile, int format, int level) - { - int ready_bits = 0 /*, shift_width = 0 */; - uint32 src_rowsize, dst_rowsize, bit_offset, src_offset; - uint32 src_byte = 0, src_bit = 0; - uint32 row, col; - uint32 longbuff1 = 0, longbuff2 = 0; - uint64 maskbits = 0, matchbits = 0; - uint64 buff1 = 0, buff2 = 0, buff3 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0; - tsample_t s; - unsigned char *src = in[0]; - unsigned char *dst = out; - char action[8]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("combineSeparateTileSamples32bits","Invalid input or output buffer"); - return (1); - } - - src_rowsize = ((bps * tw) + 7) / 8; - dst_rowsize = ((imagewidth * bps * spp) + 7) / 8; - maskbits = (uint64)-1 >> ( 64 - bps); - /* shift_width = ((bps + 7) / 8) + 1; */ - - for (row = 0; row < rows; row++) - { - ready_bits = 0; - buff1 = buff2 = 0; - dst = out + (row * dst_rowsize); - src_offset = row * src_rowsize; - for (col = 0; col < cols; col++) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = col * bps; - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - - matchbits = maskbits << (64 - src_bit - bps); - for (s = 0; s < spp; s++) - { - src = in[s] + src_offset + src_byte; - if (little_endian) - { - longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - longbuff2 = longbuff1; - } - else - { - longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - longbuff2 = longbuff1; - } - - buff3 = ((uint64)longbuff1 << 32) | longbuff2; - buff1 = (buff3 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 32) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 48); - *dst++ = bytebuff2; - bytebuff3 = (buff2 >> 40); - *dst++ = bytebuff3; - bytebuff4 = (buff2 >> 32); - *dst++ = bytebuff4; - ready_bits -= 32; - - /* shift in new bits */ - buff2 = ((buff2 << 32) | (buff1 >> ready_bits)); - strcpy (action, "Flush"); - } - else - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - strcpy (action, "Update"); - } - ready_bits += bps; - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Sample %d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, s, src_byte, src_bit, dst - out); - dump_wide (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 8); - dump_wide (dumpfile, format, "Buff1 bits ", buff1); - dump_wide (dumpfile, format, "Buff2 bits ", buff2); - dump_info (dumpfile, format, "", "Ready bits: %d, %s", ready_bits, action); - } - } - } - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - buff2 = (buff2 << 8); - ready_bits -= 8; - } - - if ((dumpfile != NULL) && (level == 3)) - { - dump_info (dumpfile, format, "", - "Row %3d, Col %3d, Src byte offset %3d bit offset %2d Dst offset %3d", - row + 1, col + 1, src_byte, src_bit, dst - out); - - dump_long (dumpfile, format, "Match bits ", matchbits); - dump_data (dumpfile, format, "Src bits ", src, 4); - dump_long (dumpfile, format, "Buff1 bits ", buff1); - dump_long (dumpfile, format, "Buff2 bits ", buff2); - dump_byte (dumpfile, format, "Write bits1", bytebuff1); - dump_byte (dumpfile, format, "Write bits2", bytebuff2); - dump_info (dumpfile, format, "", "Ready bits: %2d", ready_bits); - } - - if ((dumpfile != NULL) && (level == 2)) - { - dump_info (dumpfile, format, "combineSeparateTileSamples32bits","Output data"); - dump_buffer(dumpfile, format, 1, dst_rowsize, row, out); - } - } - - return (0); - } /* end combineSeparateTileSamples32bits */ - - -static int readSeparateStripsIntoBuffer (TIFF *in, uint8 *obuf, uint32 length, - uint32 width, uint16 spp, - struct dump_opts *dump) - { - int i, j, bytes_per_sample, bytes_per_pixel, shift_width, result = 1; - int32 bytes_read = 0; - uint16 bps, nstrips, planar, strips_per_sample; - uint32 src_rowsize, dst_rowsize, rows_processed, rps; - uint32 rows_this_strip = 0; - tsample_t s; - tstrip_t strip; - tsize_t scanlinesize = TIFFScanlineSize(in); - tsize_t stripsize = TIFFStripSize(in); - unsigned char *srcbuffs[MAX_SAMPLES]; - unsigned char *buff = NULL; - unsigned char *dst = NULL; - - if (obuf == NULL) - { - TIFFError("readSeparateStripsIntoBuffer","Invalid buffer argument"); - return (0); - } - - memset (srcbuffs, '\0', sizeof(srcbuffs)); - TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bps); - TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &planar); - TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps); - if (rps > length) - rps = length; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - - src_rowsize = ((bps * width) + 7) / 8; - dst_rowsize = ((bps * width * spp) + 7) / 8; - dst = obuf; - - if ((dump->infile != NULL) && (dump->level == 3)) - { - dump_info (dump->infile, dump->format, "", - "Image width %d, length %d, Scanline size, %4d bytes", - width, length, scanlinesize); - dump_info (dump->infile, dump->format, "", - "Bits per sample %d, Samples per pixel %d, Shift width %d", - bps, spp, shift_width); - } - - /* Libtiff seems to assume/require that data for separate planes are - * written one complete plane after another and not interleaved in any way. - * Multiple scanlines and possibly strips of the same plane must be - * written before data for any other plane. - */ - nstrips = TIFFNumberOfStrips(in); - strips_per_sample = nstrips /spp; - - for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++) - { - srcbuffs[s] = NULL; - buff = _TIFFmalloc(stripsize); - if (!buff) - { - TIFFError ("readSeparateStripsIntoBuffer", - "Unable to allocate strip read buffer for sample %d", s); - for (i = 0; i < s; i++) - _TIFFfree (srcbuffs[i]); - return 0; - } - srcbuffs[s] = buff; - } - - rows_processed = 0; - for (j = 0; (j < strips_per_sample) && (result == 1); j++) - { - for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++) - { - buff = srcbuffs[s]; - strip = (s * strips_per_sample) + j; - bytes_read = TIFFReadEncodedStrip (in, strip, buff, stripsize); - rows_this_strip = bytes_read / src_rowsize; - if (bytes_read < 0 && !ignore) - { - TIFFError(TIFFFileName(in), - "Error, can't read strip %lu for sample %d", - (unsigned long) strip, s + 1); - result = 0; - break; - } -#ifdef DEVELMODE - TIFFError("", "Strip %2d, read %5d bytes for %4d scanlines, shift width %d", - strip, bytes_read, rows_this_strip, shift_width); -#endif - } - - if (rps > rows_this_strip) - rps = rows_this_strip; - dst = obuf + (dst_rowsize * rows_processed); - if ((bps % 8) == 0) - { - if (combineSeparateSamplesBytes (srcbuffs, dst, width, rps, - spp, bps, dump->infile, - dump->format, dump->level)) - { - result = 0; - break; - } - } - else - { - switch (shift_width) - { - case 1: if (combineSeparateSamples8bits (srcbuffs, dst, width, rps, - spp, bps, dump->infile, - dump->format, dump->level)) - { - result = 0; - break; - } - break; - case 2: if (combineSeparateSamples16bits (srcbuffs, dst, width, rps, - spp, bps, dump->infile, - dump->format, dump->level)) - { - result = 0; - break; - } - break; - case 3: if (combineSeparateSamples24bits (srcbuffs, dst, width, rps, - spp, bps, dump->infile, - dump->format, dump->level)) - { - result = 0; - break; - } - break; - case 4: - case 5: - case 6: - case 7: - case 8: if (combineSeparateSamples32bits (srcbuffs, dst, width, rps, - spp, bps, dump->infile, - dump->format, dump->level)) - { - result = 0; - break; - } - break; - default: TIFFError ("readSeparateStripsIntoBuffer", "Unsupported bit depth: %d", bps); - result = 0; - break; - } - } - - if ((rows_processed + rps) > length) - { - rows_processed = length; - rps = length - rows_processed; - } - else - rows_processed += rps; - } - - /* free any buffers allocated for each plane or scanline and - * any temporary buffers - */ - for (s = 0; (s < spp) && (s < MAX_SAMPLES); s++) - { - buff = srcbuffs[s]; - if (buff != NULL) - _TIFFfree(buff); - } - - return (result); - } /* end readSeparateStripsIntoBuffer */ - -static int -get_page_geometry (char *name, struct pagedef *page) - { - char *ptr; - int n; - - for (ptr = name; *ptr; ptr++) - *ptr = (char)tolower((int)*ptr); - - for (n = 0; n < MAX_PAPERNAMES; n++) - { - if (strcmp(name, PaperTable[n].name) == 0) - { - page->width = PaperTable[n].width; - page->length = PaperTable[n].length; - strncpy (page->name, PaperTable[n].name, 15); - page->name[15] = '\0'; - return (0); - } - } - - return (1); - } - - -static void -initPageSetup (struct pagedef *page, struct pageseg *pagelist, - struct buffinfo seg_buffs[]) - { - int i; - - strcpy (page->name, ""); - page->mode = PAGE_MODE_NONE; - page->res_unit = RESUNIT_NONE; - page->hres = 0.0; - page->vres = 0.0; - page->width = 0.0; - page->length = 0.0; - page->hmargin = 0.0; - page->vmargin = 0.0; - page->rows = 0; - page->cols = 0; - page->orient = ORIENTATION_NONE; - - for (i = 0; i < MAX_SECTIONS; i++) - { - pagelist[i].x1 = (uint32)0; - pagelist[i].x2 = (uint32)0; - pagelist[i].y1 = (uint32)0; - pagelist[i].y2 = (uint32)0; - pagelist[i].buffsize = (uint32)0; - pagelist[i].position = 0; - pagelist[i].total = 0; - } - - for (i = 0; i < MAX_OUTBUFFS; i++) - { - seg_buffs[i].size = 0; - seg_buffs[i].buffer = NULL; - } - } - -static void -initImageData (struct image_data *image) - { - image->xres = 0.0; - image->yres = 0.0; - image->width = 0; - image->length = 0; - image->res_unit = RESUNIT_NONE; - image->bps = 0; - image->spp = 0; - image->planar = 0; - image->photometric = 0; - image->orientation = 0; - image->compression = COMPRESSION_NONE; - image->adjustments = 0; - } - -static void -initCropMasks (struct crop_mask *cps) - { - int i; - - cps->crop_mode = CROP_NONE; - cps->res_unit = RESUNIT_NONE; - cps->edge_ref = EDGE_TOP; - cps->width = 0; - cps->length = 0; - for (i = 0; i < 4; i++) - cps->margins[i] = 0.0; - cps->bufftotal = (uint32)0; - cps->combined_width = (uint32)0; - cps->combined_length = (uint32)0; - cps->rotation = (uint16)0; - cps->photometric = INVERT_DATA_AND_TAG; - cps->mirror = (uint16)0; - cps->invert = (uint16)0; - cps->zones = (uint32)0; - cps->regions = (uint32)0; - for (i = 0; i < MAX_REGIONS; i++) - { - cps->corners[i].X1 = 0.0; - cps->corners[i].X2 = 0.0; - cps->corners[i].Y1 = 0.0; - cps->corners[i].Y2 = 0.0; - cps->regionlist[i].x1 = 0; - cps->regionlist[i].x2 = 0; - cps->regionlist[i].y1 = 0; - cps->regionlist[i].y2 = 0; - cps->regionlist[i].width = 0; - cps->regionlist[i].length = 0; - cps->regionlist[i].buffsize = 0; - cps->regionlist[i].buffptr = NULL; - cps->zonelist[i].position = 0; - cps->zonelist[i].total = 0; - } - cps->exp_mode = ONE_FILE_COMPOSITE; - cps->img_mode = COMPOSITE_IMAGES; - } - -static void initDumpOptions(struct dump_opts *dump) - { - dump->debug = 0; - dump->format = DUMP_NONE; - dump->level = 1; - sprintf (dump->mode, "w"); - memset (dump->infilename, '\0', PATH_MAX + 1); - memset (dump->outfilename, '\0',PATH_MAX + 1); - dump->infile = NULL; - dump->outfile = NULL; - } - -/* Compute pixel offsets into the image for margins and fixed regions */ -static int -computeInputPixelOffsets(struct crop_mask *crop, struct image_data *image, - struct offset *off) - { - double scale; - float xres, yres; - /* Values for these offsets are in pixels from start of image, not bytes, - * and are indexed from zero to width - 1 or length - 1 */ - uint32 tmargin, bmargin, lmargin, rmargin; - uint32 startx, endx; /* offsets of first and last columns to extract */ - uint32 starty, endy; /* offsets of first and last row to extract */ - uint32 width, length, crop_width, crop_length; - uint32 i, max_width, max_length, zwidth, zlength, buffsize; - uint32 x1, x2, y1, y2; - - if (image->res_unit != RESUNIT_INCH && image->res_unit != RESUNIT_CENTIMETER) - { - xres = 1.0; - yres = 1.0; - } - else - { - if (((image->xres == 0) || (image->yres == 0)) && - (crop->res_unit != RESUNIT_NONE) && - ((crop->crop_mode & CROP_REGIONS) || (crop->crop_mode & CROP_MARGINS) || - (crop->crop_mode & CROP_LENGTH) || (crop->crop_mode & CROP_WIDTH))) - { - TIFFError("computeInputPixelOffsets", "Cannot compute margins or fixed size sections without image resolution"); - TIFFError("computeInputPixelOffsets", "Specify units in pixels and try again"); - return (-1); - } - xres = image->xres; - yres = image->yres; - } - - /* Translate user units to image units */ - scale = 1.0; - switch (crop->res_unit) { - case RESUNIT_CENTIMETER: - if (image->res_unit == RESUNIT_INCH) - scale = 1.0/2.54; - break; - case RESUNIT_INCH: - if (image->res_unit == RESUNIT_CENTIMETER) - scale = 2.54; - break; - case RESUNIT_NONE: /* Dimensions in pixels */ - default: - break; - } - - if (crop->crop_mode & CROP_REGIONS) - { - max_width = max_length = 0; - for (i = 0; i < crop->regions; i++) - { - if ((crop->res_unit == RESUNIT_INCH) || (crop->res_unit == RESUNIT_CENTIMETER)) - { - x1 = (uint32) (crop->corners[i].X1 * scale * xres); - x2 = (uint32) (crop->corners[i].X2 * scale * xres); - y1 = (uint32) (crop->corners[i].Y1 * scale * yres); - y2 = (uint32) (crop->corners[i].Y2 * scale * yres); - } - else - { - x1 = (uint32) (crop->corners[i].X1); - x2 = (uint32) (crop->corners[i].X2); - y1 = (uint32) (crop->corners[i].Y1); - y2 = (uint32) (crop->corners[i].Y2); - } - if (x1 < 1) - crop->regionlist[i].x1 = 0; - else - crop->regionlist[i].x1 = (uint32) (x1 - 1); - - if (x2 > image->width - 1) - crop->regionlist[i].x2 = image->width - 1; - else - crop->regionlist[i].x2 = (uint32) (x2 - 1); - zwidth = crop->regionlist[i].x2 - crop->regionlist[i].x1 + 1; - - if (y1 < 1) - crop->regionlist[i].y1 = 0; - else - crop->regionlist[i].y1 = (uint32) (y1 - 1); - - if (y2 > image->length - 1) - crop->regionlist[i].y2 = image->length - 1; - else - crop->regionlist[i].y2 = (uint32) (y2 - 1); - - zlength = crop->regionlist[i].y2 - crop->regionlist[i].y1 + 1; - - if (zwidth > max_width) - max_width = zwidth; - if (zlength > max_length) - max_length = zlength; - - buffsize = (uint32) - (((zwidth * image->bps * image->spp + 7 ) / 8) * (zlength + 1)); - - crop->regionlist[i].buffsize = buffsize; - crop->bufftotal += buffsize; - if (crop->img_mode == COMPOSITE_IMAGES) - { - switch (crop->edge_ref) - { - case EDGE_LEFT: - case EDGE_RIGHT: - crop->combined_length = zlength; - crop->combined_width += zwidth; - break; - case EDGE_BOTTOM: - case EDGE_TOP: /* width from left, length from top */ - default: - crop->combined_width = zwidth; - crop->combined_length += zlength; - break; - } - } - } - return (0); - } - - /* Convert crop margins into offsets into image - * Margins are expressed as pixel rows and columns, not bytes - */ - if (crop->crop_mode & CROP_MARGINS) - { - if (crop->res_unit != RESUNIT_INCH && crop->res_unit != RESUNIT_CENTIMETER) - { /* User has specified pixels as reference unit */ - tmargin = (uint32)(crop->margins[0]); - lmargin = (uint32)(crop->margins[1]); - bmargin = (uint32)(crop->margins[2]); - rmargin = (uint32)(crop->margins[3]); - } - else - { /* inches or centimeters specified */ - tmargin = (uint32)(crop->margins[0] * scale * yres); - lmargin = (uint32)(crop->margins[1] * scale * xres); - bmargin = (uint32)(crop->margins[2] * scale * yres); - rmargin = (uint32)(crop->margins[3] * scale * xres); - } - - if ((lmargin + rmargin) > image->width) - { - TIFFError("computeInputPixelOffsets", "Combined left and right margins exceed image width"); - lmargin = (uint32) 0; - rmargin = (uint32) 0; - return (-1); - } - if ((tmargin + bmargin) > image->length) - { - TIFFError("computeInputPixelOffsets", "Combined top and bottom margins exceed image length"); - tmargin = (uint32) 0; - bmargin = (uint32) 0; - return (-1); - } - } - else - { /* no margins requested */ - tmargin = (uint32) 0; - lmargin = (uint32) 0; - bmargin = (uint32) 0; - rmargin = (uint32) 0; - } - - /* Width, height, and margins are expressed as pixel offsets into image */ - if (crop->res_unit != RESUNIT_INCH && crop->res_unit != RESUNIT_CENTIMETER) - { - if (crop->crop_mode & CROP_WIDTH) - width = (uint32)crop->width; - else - width = image->width - lmargin - rmargin; - - if (crop->crop_mode & CROP_LENGTH) - length = (uint32)crop->length; - else - length = image->length - tmargin - bmargin; - } - else - { - if (crop->crop_mode & CROP_WIDTH) - width = (uint32)(crop->width * scale * image->xres); - else - width = image->width - lmargin - rmargin; - - if (crop->crop_mode & CROP_LENGTH) - length = (uint32)(crop->length * scale * image->yres); - else - length = image->length - tmargin - bmargin; - } - - off->tmargin = tmargin; - off->bmargin = bmargin; - off->lmargin = lmargin; - off->rmargin = rmargin; - - /* Calculate regions defined by margins, width, and length. - * Coordinates expressed as 0 to imagewidth - 1, imagelength - 1, - * since they are used to compute offsets into buffers */ - switch (crop->edge_ref) { - case EDGE_BOTTOM: - startx = lmargin; - if ((startx + width) >= (image->width - rmargin)) - endx = image->width - rmargin - 1; - else - endx = startx + width - 1; - - endy = image->length - bmargin - 1; - if ((endy - length) <= tmargin) - starty = tmargin; - else - starty = endy - length + 1; - break; - case EDGE_RIGHT: - endx = image->width - rmargin - 1; - if ((endx - width) <= lmargin) - startx = lmargin; - else - startx = endx - width + 1; - - starty = tmargin; - if ((starty + length) >= (image->length - bmargin)) - endy = image->length - bmargin - 1; - else - endy = starty + length - 1; - break; - case EDGE_TOP: /* width from left, length from top */ - case EDGE_LEFT: - default: - startx = lmargin; - if ((startx + width) >= (image->width - rmargin)) - endx = image->width - rmargin - 1; - else - endx = startx + width - 1; - - starty = tmargin; - if ((starty + length) >= (image->length - bmargin)) - endy = image->length - bmargin - 1; - else - endy = starty + length - 1; - break; - } - off->startx = startx; - off->starty = starty; - off->endx = endx; - off->endy = endy; - - crop_width = endx - startx + 1; - crop_length = endy - starty + 1; - - if (crop_width <= 0) - { - TIFFError("computeInputPixelOffsets", - "Invalid left/right margins and /or image crop width requested"); - return (-1); - } - if (crop_width > image->width) - crop_width = image->width; - - if (crop_length <= 0) - { - TIFFError("computeInputPixelOffsets", - "Invalid top/bottom margins and /or image crop length requested"); - return (-1); - } - if (crop_length > image->length) - crop_length = image->length; - - off->crop_width = crop_width; - off->crop_length = crop_length; - - return (0); - } /* end computeInputPixelOffsets */ - -/* - * Translate crop options into pixel offsets for one or more regions of the image. - * Options are applied in this order: margins, specific width and length, zones, - * but all are optional. Margins are relative to each edge. Width, length and - * zones are relative to the specified reference edge. Zones are expressed as - * X:Y where X is the ordinal value in a set of Y equal sized portions. eg. - * 2:3 would indicate the middle third of the region qualified by margins and - * any explicit width and length specified. Regions are specified by coordinates - * of the top left and lower right corners with range 1 to width or height. - */ - -static int -getCropOffsets(struct image_data *image, struct crop_mask *crop, struct dump_opts *dump) - { - struct offset offsets; - int i; - int32 test; - uint32 seg, total, need_buff = 0; - uint32 buffsize; - uint32 zwidth, zlength; - - memset(&offsets, '\0', sizeof(struct offset)); - crop->bufftotal = 0; - crop->combined_width = (uint32)0; - crop->combined_length = (uint32)0; - crop->selections = 0; - - /* Compute pixel offsets if margins or fixed width or length specified */ - if ((crop->crop_mode & CROP_MARGINS) || - (crop->crop_mode & CROP_REGIONS) || - (crop->crop_mode & CROP_LENGTH) || - (crop->crop_mode & CROP_WIDTH)) - { - if (computeInputPixelOffsets(crop, image, &offsets)) - { - TIFFError ("getCropOffsets", "Unable to compute crop margins"); - return (-1); - } - need_buff = TRUE; - crop->selections = crop->regions; - /* Regions are only calculated from top and left edges with no margins */ - if (crop->crop_mode & CROP_REGIONS) - return (0); - } - else - { /* cropped area is the full image */ - offsets.tmargin = 0; - offsets.lmargin = 0; - offsets.bmargin = 0; - offsets.rmargin = 0; - offsets.crop_width = image->width; - offsets.crop_length = image->length; - offsets.startx = 0; - offsets.endx = image->width - 1; - offsets.starty = 0; - offsets.endy = image->length - 1; - need_buff = FALSE; - } - - if (dump->outfile != NULL) - { - dump_info (dump->outfile, dump->format, "", "Margins: Top: %d Left: %d Bottom: %d Right: %d", - offsets.tmargin, offsets.lmargin, offsets.bmargin, offsets.rmargin); - dump_info (dump->outfile, dump->format, "", "Crop region within margins: Adjusted Width: %6d Length: %6d", - offsets.crop_width, offsets.crop_length); - } - - if (!(crop->crop_mode & CROP_ZONES)) /* no crop zones requested */ - { - if (need_buff == FALSE) /* No margins or fixed width or length areas */ - { - crop->selections = 0; - crop->combined_width = image->width; - crop->combined_length = image->length; - return (0); - } - else - { - /* Use one region for margins and fixed width or length areas - * even though it was not formally declared as a region. - */ - crop->selections = 1; - crop->zones = 1; - crop->zonelist[0].total = 1; - crop->zonelist[0].position = 1; - } - } - else - crop->selections = crop->zones; - - for (i = 0; i < crop->zones; i++) - { - seg = crop->zonelist[i].position; - total = crop->zonelist[i].total; - - switch (crop->edge_ref) - { - case EDGE_LEFT: /* zones from left to right, length from top */ - zlength = offsets.crop_length; - crop->regionlist[i].y1 = offsets.starty; - crop->regionlist[i].y2 = offsets.endy; - - crop->regionlist[i].x1 = offsets.startx + - (uint32)(offsets.crop_width * 1.0 * (seg - 1) / total); - test = (int32)offsets.startx + - (int32)(offsets.crop_width * 1.0 * seg / total); - if (test < 1 ) - crop->regionlist[i].x2 = 0; - else - { - if (test > (int32)(image->width - 1)) - crop->regionlist[i].x2 = image->width - 1; - else - crop->regionlist[i].x2 = test - 1; - } - zwidth = crop->regionlist[i].x2 - crop->regionlist[i].x1 + 1; - - /* This is passed to extractCropZone or extractCompositeZones */ - crop->combined_length = (uint32)zlength; - if (crop->exp_mode == COMPOSITE_IMAGES) - crop->combined_width += (uint32)zwidth; - else - crop->combined_width = (uint32)zwidth; - break; - case EDGE_BOTTOM: /* width from left, zones from bottom to top */ - zwidth = offsets.crop_width; - crop->regionlist[i].x1 = offsets.startx; - crop->regionlist[i].x2 = offsets.endx; - - test = offsets.endy - (uint32)(offsets.crop_length * 1.0 * seg / total); - if (test < 1 ) - crop->regionlist[i].y1 = 0; - else - crop->regionlist[i].y1 = test + 1; - - test = offsets.endy - (offsets.crop_length * 1.0 * (seg - 1) / total); - if (test < 1 ) - crop->regionlist[i].y2 = 0; - else - { - if (test > (int32)(image->length - 1)) - crop->regionlist[i].y2 = image->length - 1; - else - crop->regionlist[i].y2 = test; - } - zlength = crop->regionlist[i].y2 - crop->regionlist[i].y1 + 1; - - /* This is passed to extractCropZone or extractCompositeZones */ - if (crop->exp_mode == COMPOSITE_IMAGES) - crop->combined_length += (uint32)zlength; - else - crop->combined_length = (uint32)zlength; - crop->combined_width = (uint32)zwidth; - break; - case EDGE_RIGHT: /* zones from right to left, length from top */ - zlength = offsets.crop_length; - crop->regionlist[i].y1 = offsets.starty; - crop->regionlist[i].y2 = offsets.endy; - - crop->regionlist[i].x1 = offsets.startx + - (uint32)(offsets.crop_width * (total - seg) * 1.0 / total); - test = offsets.startx + - (offsets.crop_width * (total - seg + 1) * 1.0 / total); - if (test < 1 ) - crop->regionlist[i].x2 = 0; - else - { - if (test > (int32)(image->width - 1)) - crop->regionlist[i].x2 = image->width - 1; - else - crop->regionlist[i].x2 = test - 1; - } - zwidth = crop->regionlist[i].x2 - crop->regionlist[i].x1 + 1; - - /* This is passed to extractCropZone or extractCompositeZones */ - crop->combined_length = (uint32)zlength; - if (crop->exp_mode == COMPOSITE_IMAGES) - crop->combined_width += (uint32)zwidth; - else - crop->combined_width = (uint32)zwidth; - break; - case EDGE_TOP: /* width from left, zones from top to bottom */ - default: - zwidth = offsets.crop_width; - crop->regionlist[i].x1 = offsets.startx; - crop->regionlist[i].x2 = offsets.endx; - - crop->regionlist[i].y1 = offsets.starty + (uint32)(offsets.crop_length * 1.0 * (seg - 1) / total); - test = offsets.starty + (uint32)(offsets.crop_length * 1.0 * seg / total); - if (test < 1 ) - crop->regionlist[i].y2 = 0; - else - { - if (test > (int32)(image->length - 1)) - crop->regionlist[i].y2 = image->length - 1; - else - crop->regionlist[i].y2 = test - 1; - } - zlength = crop->regionlist[i].y2 - crop->regionlist[i].y1 + 1; - - /* This is passed to extractCropZone or extractCompositeZones */ - if (crop->exp_mode == COMPOSITE_IMAGES) - crop->combined_length += (uint32)zlength; - else - crop->combined_length = (uint32)zlength; - crop->combined_width = (uint32)zwidth; - break; - } /* end switch statement */ - - buffsize = (uint32) - ((((zwidth * image->bps * image->spp) + 7 ) / 8) * (zlength + 1)); - crop->regionlist[i].width = (uint32) zwidth; - crop->regionlist[i].length = (uint32) zlength; - crop->regionlist[i].buffsize = buffsize; - crop->bufftotal += buffsize; - - - if (dump->outfile != NULL) - dump_info (dump->outfile, dump->format, "", "Zone %d, width: %4d, length: %4d, x1: %4d x2: %4d y1: %4d y2: %4d", - i + 1, (uint32)zwidth, (uint32)zlength, - crop->regionlist[i].x1, crop->regionlist[i].x2, - crop->regionlist[i].y1, crop->regionlist[i].y2); - } - - return (0); - } /* end getCropOffsets */ - - -static int -computeOutputPixelOffsets (struct crop_mask *crop, struct image_data *image, - struct pagedef *page, struct pageseg *sections, - struct dump_opts* dump) - { - double scale; - double pwidth, plength; /* Output page width and length in user units*/ - uint32 iwidth, ilength; /* Input image width and length in pixels*/ - uint32 owidth, olength; /* Output image width and length in pixels*/ - uint32 orows, ocols; /* rows and cols for output */ - uint32 hmargin, vmargin; /* Horizontal and vertical margins */ - uint32 x1, x2, y1, y2, line_bytes; - /* unsigned int orientation; */ - uint32 i, j, k; - - scale = 1.0; - if (page->res_unit == RESUNIT_NONE) - page->res_unit = image->res_unit; - - switch (image->res_unit) { - case RESUNIT_CENTIMETER: - if (page->res_unit == RESUNIT_INCH) - scale = 1.0/2.54; - break; - case RESUNIT_INCH: - if (page->res_unit == RESUNIT_CENTIMETER) - scale = 2.54; - break; - case RESUNIT_NONE: /* Dimensions in pixels */ - default: - break; - } - - /* get width, height, resolutions of input image selection */ - if (crop->combined_width > 0) - iwidth = crop->combined_width; - else - iwidth = image->width; - if (crop->combined_length > 0) - ilength = crop->combined_length; - else - ilength = image->length; - - if (page->hres <= 1.0) - page->hres = image->xres; - if (page->vres <= 1.0) - page->vres = image->yres; - - if ((page->hres < 1.0) || (page->vres < 1.0)) - { - TIFFError("computeOutputPixelOffsets", - "Invalid horizontal or vertical resolution specified or read from input image"); - return (1); - } - - /* If no page sizes are being specified, we just use the input image size to - * calculate maximum margins that can be taken from image. - */ - if (page->width <= 0) - pwidth = iwidth; - else - pwidth = page->width; - - if (page->length <= 0) - plength = ilength; - else - plength = page->length; - - if (dump->debug) - { - TIFFError("", "Page size: %s, Vres: %3.2f, Hres: %3.2f, " - "Hmargin: %3.2f, Vmargin: %3.2f", - page->name, page->vres, page->hres, - page->hmargin, page->vmargin); - TIFFError("", "Res_unit: %d, Scale: %3.2f, Page width: %3.2f, length: %3.2f", - page->res_unit, scale, pwidth, plength); - } - - /* compute margins at specified unit and resolution */ - if (page->mode & PAGE_MODE_MARGINS) - { - if (page->res_unit == RESUNIT_INCH || page->res_unit == RESUNIT_CENTIMETER) - { /* inches or centimeters specified */ - hmargin = (uint32)(page->hmargin * scale * page->hres * ((image->bps + 7)/ 8)); - vmargin = (uint32)(page->vmargin * scale * page->vres * ((image->bps + 7)/ 8)); - } - else - { /* Otherwise user has specified pixels as reference unit */ - hmargin = (uint32)(page->hmargin * scale * ((image->bps + 7)/ 8)); - vmargin = (uint32)(page->vmargin * scale * ((image->bps + 7)/ 8)); - } - - if ((hmargin * 2.0) > (pwidth * page->hres)) - { - TIFFError("computeOutputPixelOffsets", - "Combined left and right margins exceed page width"); - hmargin = (uint32) 0; - return (-1); - } - if ((vmargin * 2.0) > (plength * page->vres)) - { - TIFFError("computeOutputPixelOffsets", - "Combined top and bottom margins exceed page length"); - vmargin = (uint32) 0; - return (-1); - } - } - else - { - hmargin = 0; - vmargin = 0; - } - - if (page->mode & PAGE_MODE_ROWSCOLS ) - { - /* Maybe someday but not for now */ - if (page->mode & PAGE_MODE_MARGINS) - TIFFError("computeOutputPixelOffsets", - "Output margins cannot be specified with rows and columns"); - - owidth = TIFFhowmany(iwidth, page->cols); - olength = TIFFhowmany(ilength, page->rows); - } - else - { - if (page->mode & PAGE_MODE_PAPERSIZE ) - { - owidth = (uint32)((pwidth * page->hres) - (hmargin * 2)); - olength = (uint32)((plength * page->vres) - (vmargin * 2)); - } - else - { - owidth = (uint32)(iwidth - (hmargin * 2 * page->hres)); - olength = (uint32)(ilength - (vmargin * 2 * page->vres)); - } - } - - if (owidth > iwidth) - owidth = iwidth; - if (olength > ilength) - olength = ilength; - - /* Compute the number of pages required for Portrait or Landscape */ - switch (page->orient) - { - case ORIENTATION_NONE: - case ORIENTATION_PORTRAIT: - ocols = TIFFhowmany(iwidth, owidth); - orows = TIFFhowmany(ilength, olength); - /* orientation = ORIENTATION_PORTRAIT; */ - break; - - case ORIENTATION_LANDSCAPE: - ocols = TIFFhowmany(iwidth, olength); - orows = TIFFhowmany(ilength, owidth); - x1 = olength; - olength = owidth; - owidth = x1; - /* orientation = ORIENTATION_LANDSCAPE; */ - break; - - case ORIENTATION_AUTO: - default: - x1 = TIFFhowmany(iwidth, owidth); - x2 = TIFFhowmany(ilength, olength); - y1 = TIFFhowmany(iwidth, olength); - y2 = TIFFhowmany(ilength, owidth); - - if ( (x1 * x2) < (y1 * y2)) - { /* Portrait */ - ocols = x1; - orows = x2; - /* orientation = ORIENTATION_PORTRAIT; */ - } - else - { /* Landscape */ - ocols = y1; - orows = y2; - x1 = olength; - olength = owidth; - owidth = x1; - /* orientation = ORIENTATION_LANDSCAPE; */ - } - } - - if (ocols < 1) - ocols = 1; - if (orows < 1) - orows = 1; - - /* If user did not specify rows and cols, set them from calcuation */ - if (page->rows < 1) - page->rows = orows; - if (page->cols < 1) - page->cols = ocols; - - line_bytes = TIFFhowmany8(owidth * image->bps) * image->spp; - - if ((page->rows * page->cols) > MAX_SECTIONS) - { - TIFFError("computeOutputPixelOffsets", - "Rows and Columns exceed maximum sections\nIncrease resolution or reduce sections"); - return (-1); - } - - /* build the list of offsets for each output section */ - for (k = 0, i = 0 && k <= MAX_SECTIONS; i < orows; i++) - { - y1 = (uint32)(olength * i); - y2 = (uint32)(olength * (i + 1) - 1); - if (y2 >= ilength) - y2 = ilength - 1; - for (j = 0; j < ocols; j++, k++) - { - x1 = (uint32)(owidth * j); - x2 = (uint32)(owidth * (j + 1) - 1); - if (x2 >= iwidth) - x2 = iwidth - 1; - sections[k].x1 = x1; - sections[k].x2 = x2; - sections[k].y1 = y1; - sections[k].y2 = y2; - sections[k].buffsize = line_bytes * olength; - sections[k].position = k + 1; - sections[k].total = orows * ocols; - } - } - return (0); - } /* end computeOutputPixelOffsets */ - -static int -loadImage(TIFF* in, struct image_data *image, struct dump_opts *dump, unsigned char **read_ptr) - { - uint32 i; - float xres = 0.0, yres = 0.0; - uint16 nstrips = 0, ntiles = 0, planar = 0; - uint16 bps = 0, spp = 0, res_unit = 0; - uint16 orientation = 0; - uint16 input_compression = 0, input_photometric = 0; - uint16 subsampling_horiz, subsampling_vert; - uint32 width = 0, length = 0; - uint32 stsize = 0, tlsize = 0, buffsize = 0, scanlinesize = 0; - uint32 tw = 0, tl = 0; /* Tile width and length */ - uint32 tile_rowsize = 0; - unsigned char *read_buff = NULL; - unsigned char *new_buff = NULL; - int readunit = 0; - static uint32 prev_readsize = 0; - - TIFFGetFieldDefaulted(in, TIFFTAG_BITSPERSAMPLE, &bps); - TIFFGetFieldDefaulted(in, TIFFTAG_SAMPLESPERPIXEL, &spp); - TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &planar); - TIFFGetFieldDefaulted(in, TIFFTAG_ORIENTATION, &orientation); - if (! TIFFGetFieldDefaulted(in, TIFFTAG_PHOTOMETRIC, &input_photometric)) - TIFFError("loadImage","Image lacks Photometric interpreation tag"); - if (! TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width)) - TIFFError("loadimage","Image lacks image width tag"); - if(! TIFFGetField(in, TIFFTAG_IMAGELENGTH, &length)) - TIFFError("loadimage","Image lacks image length tag"); - TIFFGetFieldDefaulted(in, TIFFTAG_XRESOLUTION, &xres); - TIFFGetFieldDefaulted(in, TIFFTAG_YRESOLUTION, &yres); - if (!TIFFGetFieldDefaulted(in, TIFFTAG_RESOLUTIONUNIT, &res_unit)) - res_unit = RESUNIT_INCH; - if (!TIFFGetField(in, TIFFTAG_COMPRESSION, &input_compression)) - input_compression = COMPRESSION_NONE; - -#ifdef DEBUG2 - char compressionid[16]; - - switch (input_compression) - { - case COMPRESSION_NONE: /* 1 dump mode */ - strcpy (compressionid, "None/dump"); - break; - case COMPRESSION_CCITTRLE: /* 2 CCITT modified Huffman RLE */ - strcpy (compressionid, "Huffman RLE"); - break; - case COMPRESSION_CCITTFAX3: /* 3 CCITT Group 3 fax encoding */ - strcpy (compressionid, "Group3 Fax"); - break; - case COMPRESSION_CCITTFAX4: /* 4 CCITT Group 4 fax encoding */ - strcpy (compressionid, "Group4 Fax"); - break; - case COMPRESSION_LZW: /* 5 Lempel-Ziv & Welch */ - strcpy (compressionid, "LZW"); - break; - case COMPRESSION_OJPEG: /* 6 !6.0 JPEG */ - strcpy (compressionid, "Old Jpeg"); - break; - case COMPRESSION_JPEG: /* 7 %JPEG DCT compression */ - strcpy (compressionid, "New Jpeg"); - break; - case COMPRESSION_NEXT: /* 32766 NeXT 2-bit RLE */ - strcpy (compressionid, "Next RLE"); - break; - case COMPRESSION_CCITTRLEW: /* 32771 #1 w/ word alignment */ - strcpy (compressionid, "CITTRLEW"); - break; - case COMPRESSION_PACKBITS: /* 32773 Macintosh RLE */ - strcpy (compressionid, "Mac Packbits"); - break; - case COMPRESSION_THUNDERSCAN: /* 32809 ThunderScan RLE */ - strcpy (compressionid, "Thunderscan"); - break; - case COMPRESSION_IT8CTPAD: /* 32895 IT8 CT w/padding */ - strcpy (compressionid, "IT8 padded"); - break; - case COMPRESSION_IT8LW: /* 32896 IT8 Linework RLE */ - strcpy (compressionid, "IT8 RLE"); - break; - case COMPRESSION_IT8MP: /* 32897 IT8 Monochrome picture */ - strcpy (compressionid, "IT8 mono"); - break; - case COMPRESSION_IT8BL: /* 32898 IT8 Binary line art */ - strcpy (compressionid, "IT8 lineart"); - break; - case COMPRESSION_PIXARFILM: /* 32908 Pixar companded 10bit LZW */ - strcpy (compressionid, "Pixar 10 bit"); - break; - case COMPRESSION_PIXARLOG: /* 32909 Pixar companded 11bit ZIP */ - strcpy (compressionid, "Pixar 11bit"); - break; - case COMPRESSION_DEFLATE: /* 32946 Deflate compression */ - strcpy (compressionid, "Deflate"); - break; - case COMPRESSION_ADOBE_DEFLATE: /* 8 Deflate compression */ - strcpy (compressionid, "Adobe deflate"); - break; - default: - strcpy (compressionid, "None/unknown"); - break; - } - TIFFError("loadImage", "Input compression %s", compressionid); -#endif - - scanlinesize = TIFFScanlineSize(in); - image->bps = bps; - image->spp = spp; - image->planar = planar; - image->width = width; - image->length = length; - image->xres = xres; - image->yres = yres; - image->res_unit = res_unit; - image->compression = input_compression; - image->photometric = input_photometric; -#ifdef DEBUG2 - char photometricid[12]; - - switch (input_photometric) - { - case PHOTOMETRIC_MINISWHITE: - strcpy (photometricid, "MinIsWhite"); - break; - case PHOTOMETRIC_MINISBLACK: - strcpy (photometricid, "MinIsBlack"); - break; - case PHOTOMETRIC_RGB: - strcpy (photometricid, "RGB"); - break; - case PHOTOMETRIC_PALETTE: - strcpy (photometricid, "Palette"); - break; - case PHOTOMETRIC_MASK: - strcpy (photometricid, "Mask"); - break; - case PHOTOMETRIC_SEPARATED: - strcpy (photometricid, "Separated"); - break; - case PHOTOMETRIC_YCBCR: - strcpy (photometricid, "YCBCR"); - break; - case PHOTOMETRIC_CIELAB: - strcpy (photometricid, "CIELab"); - break; - case PHOTOMETRIC_ICCLAB: - strcpy (photometricid, "ICCLab"); - break; - case PHOTOMETRIC_ITULAB: - strcpy (photometricid, "ITULab"); - break; - case PHOTOMETRIC_LOGL: - strcpy (photometricid, "LogL"); - break; - case PHOTOMETRIC_LOGLUV: - strcpy (photometricid, "LOGLuv"); - break; - default: - strcpy (photometricid, "Unknown"); - break; - } - TIFFError("loadImage", "Input photometric interpretation %s", photometricid); - -#endif - image->orientation = orientation; - switch (orientation) - { - case 0: - case ORIENTATION_TOPLEFT: - image->adjustments = 0; - break; - case ORIENTATION_TOPRIGHT: - image->adjustments = MIRROR_HORIZ; - break; - case ORIENTATION_BOTRIGHT: - image->adjustments = ROTATECW_180; - break; - case ORIENTATION_BOTLEFT: - image->adjustments = MIRROR_VERT; - break; - case ORIENTATION_LEFTTOP: - image->adjustments = MIRROR_VERT | ROTATECW_90; - break; - case ORIENTATION_RIGHTTOP: - image->adjustments = ROTATECW_90; - break; - case ORIENTATION_RIGHTBOT: - image->adjustments = MIRROR_VERT | ROTATECW_270; - break; - case ORIENTATION_LEFTBOT: - image->adjustments = ROTATECW_270; - break; - default: - image->adjustments = 0; - image->orientation = ORIENTATION_TOPLEFT; - } - - if ((bps == 0) || (spp == 0)) - { - TIFFError("loadImage", "Invalid samples per pixel (%d) or bits per sample (%d)", - spp, bps); - return (-1); - } - - if (TIFFIsTiled(in)) - { - readunit = TILE; - tlsize = TIFFTileSize(in); - ntiles = TIFFNumberOfTiles(in); - TIFFGetField(in, TIFFTAG_TILEWIDTH, &tw); - TIFFGetField(in, TIFFTAG_TILELENGTH, &tl); - - tile_rowsize = TIFFTileRowSize(in); - buffsize = tlsize * ntiles; - - - if (buffsize < (uint32)(ntiles * tl * tile_rowsize)) - { - buffsize = ntiles * tl * tile_rowsize; -#ifdef DEBUG2 - TIFFError("loadImage", - "Tilesize %u is too small, using ntiles * tilelength * tilerowsize %lu", - tlsize, (unsigned long)buffsize); -#endif - } - - if (dump->infile != NULL) - dump_info (dump->infile, dump->format, "", - "Tilesize: %u, Number of Tiles: %u, Tile row size: %u", - tlsize, ntiles, tile_rowsize); - } - else - { - readunit = STRIP; - TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); - stsize = TIFFStripSize(in); - nstrips = TIFFNumberOfStrips(in); - buffsize = stsize * nstrips; - - if (buffsize < (uint32) (((length * width * spp * bps) + 7) / 8)) - { - buffsize = ((length * width * spp * bps) + 7) / 8; -#ifdef DEBUG2 - TIFFError("loadImage", - "Stripsize %u is too small, using imagelength * width * spp * bps / 8 = %lu", - stsize, (unsigned long)buffsize); -#endif - } - - if (dump->infile != NULL) - dump_info (dump->infile, dump->format, "", - "Stripsize: %u, Number of Strips: %u, Rows per Strip: %u, Scanline size: %u", - stsize, nstrips, rowsperstrip, scanlinesize); - } - - if (input_compression == COMPRESSION_JPEG) - { /* Force conversion to RGB */ - jpegcolormode = JPEGCOLORMODE_RGB; - TIFFSetField(in, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); - } - /* The clause up to the read statement is taken from Tom Lane's tiffcp patch */ - else - { /* Otherwise, can't handle subsampled input */ - if (input_photometric == PHOTOMETRIC_YCBCR) - { - TIFFGetFieldDefaulted(in, TIFFTAG_YCBCRSUBSAMPLING, - &subsampling_horiz, &subsampling_vert); - if (subsampling_horiz != 1 || subsampling_vert != 1) - { - TIFFError("loadImage", - "Can't copy/convert subsampled image with subsampling %d horiz %d vert", - subsampling_horiz, subsampling_vert); - return (-1); - } - } - } - - read_buff = *read_ptr; - /* +3 : add a few guard bytes since reverseSamples16bits() can read a bit */ - /* outside buffer */ - if (!read_buff) - read_buff = (unsigned char *)_TIFFmalloc(buffsize+3); - else - { - if (prev_readsize < buffsize) - { - new_buff = _TIFFrealloc(read_buff, buffsize); - if (!new_buff) - { - free (read_buff); - read_buff = (unsigned char *)_TIFFmalloc(buffsize+3); - } - else - read_buff = new_buff; - } - } - read_buff[buffsize] = 0; - read_buff[buffsize+1] = 0; - read_buff[buffsize+2] = 0; - - if (!read_buff) - { - TIFFError("loadImage", "Unable to allocate/reallocate read buffer"); - return (-1); - } - - prev_readsize = buffsize; - *read_ptr = read_buff; - - /* N.B. The read functions used copy separate plane data into a buffer as interleaved - * samples rather than separate planes so the same logic works to extract regions - * regardless of the way the data are organized in the input file. - */ - switch (readunit) { - case STRIP: - if (planar == PLANARCONFIG_CONTIG) - { - if (!(readContigStripsIntoBuffer(in, read_buff))) - { - TIFFError("loadImage", "Unable to read contiguous strips into buffer"); - return (-1); - } - } - else - { - if (!(readSeparateStripsIntoBuffer(in, read_buff, length, width, spp, dump))) - { - TIFFError("loadImage", "Unable to read separate strips into buffer"); - return (-1); - } - } - break; - - case TILE: - if (planar == PLANARCONFIG_CONTIG) - { - if (!(readContigTilesIntoBuffer(in, read_buff, length, width, tw, tl, spp, bps))) - { - TIFFError("loadImage", "Unable to read contiguous tiles into buffer"); - return (-1); - } - } - else - { - if (!(readSeparateTilesIntoBuffer(in, read_buff, length, width, tw, tl, spp, bps))) - { - TIFFError("loadImage", "Unable to read separate tiles into buffer"); - return (-1); - } - } - break; - default: TIFFError("loadImage", "Unsupported image file format"); - return (-1); - break; - } - if ((dump->infile != NULL) && (dump->level == 2)) - { - dump_info (dump->infile, dump->format, "loadImage", - "Image width %d, length %d, Raw image data, %4d bytes", - width, length, buffsize); - dump_info (dump->infile, dump->format, "", - "Bits per sample %d, Samples per pixel %d", bps, spp); - - for (i = 0; i < length; i++) - dump_buffer(dump->infile, dump->format, 1, scanlinesize, - i, read_buff + (i * scanlinesize)); - } - return (0); - } /* end loadImage */ - -static int correct_orientation(struct image_data *image, unsigned char **work_buff_ptr) - { - uint16 mirror, rotation; - unsigned char *work_buff; - - work_buff = *work_buff_ptr; - if ((image == NULL) || (work_buff == NULL)) - { - TIFFError ("correct_orientatin", "Invalid image or buffer pointer"); - return (-1); - } - - if ((image->adjustments & MIRROR_HORIZ) || (image->adjustments & MIRROR_VERT)) - { - mirror = (uint16)(image->adjustments & MIRROR_BOTH); - if (mirrorImage(image->spp, image->bps, mirror, - image->width, image->length, work_buff)) - { - TIFFError ("correct_orientation", "Unable to mirror image"); - return (-1); - } - } - - if (image->adjustments & ROTATE_ANY) - { - if (image->adjustments & ROTATECW_90) - rotation = (uint16) 90; - else - if (image->adjustments & ROTATECW_180) - rotation = (uint16) 180; - else - if (image->adjustments & ROTATECW_270) - rotation = (uint16) 270; - else - { - TIFFError ("correct_orientation", "Invalid rotation value: %d", - image->adjustments & ROTATE_ANY); - return (-1); - } - - if (rotateImage(rotation, image, &image->width, &image->length, work_buff_ptr)) - { - TIFFError ("correct_orientation", "Unable to rotate image"); - return (-1); - } - image->orientation = ORIENTATION_TOPLEFT; - } - - return (0); - } /* end correct_orientation */ - - -/* Extract multiple zones from an image and combine into a single composite image */ -static int -extractCompositeRegions(struct image_data *image, struct crop_mask *crop, - unsigned char *read_buff, unsigned char *crop_buff) - { - int shift_width, bytes_per_sample, bytes_per_pixel; - uint32 i, trailing_bits, prev_trailing_bits; - uint32 row, first_row, last_row, first_col, last_col; - uint32 src_rowsize, dst_rowsize, src_offset, dst_offset; - uint32 crop_width, crop_length, img_width /*, img_length */; - uint32 prev_length, prev_width, composite_width; - uint16 bps, spp; - uint8 *src, *dst; - tsample_t count, sample = 0; /* Update to extract one or more samples */ - - img_width = image->width; - /* img_length = image->length; */ - bps = image->bps; - spp = image->spp; - count = spp; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if ((bps % 8) == 0) - shift_width = 0; - else - { - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - } - src = read_buff; - dst = crop_buff; - - /* These are setup for adding additional sections */ - prev_width = prev_length = 0; - prev_trailing_bits = trailing_bits = 0; - composite_width = crop->combined_width; - crop->combined_width = 0; - crop->combined_length = 0; - - for (i = 0; i < crop->selections; i++) - { - /* rows, columns, width, length are expressed in pixels */ - first_row = crop->regionlist[i].y1; - last_row = crop->regionlist[i].y2; - first_col = crop->regionlist[i].x1; - last_col = crop->regionlist[i].x2; - - crop_width = last_col - first_col + 1; - crop_length = last_row - first_row + 1; - - /* These should not be needed for composite images */ - crop->regionlist[i].width = crop_width; - crop->regionlist[i].length = crop_length; - crop->regionlist[i].buffptr = crop_buff; - - src_rowsize = ((img_width * bps * spp) + 7) / 8; - dst_rowsize = (((crop_width * bps * count) + 7) / 8); - - switch (crop->edge_ref) - { - default: - case EDGE_TOP: - case EDGE_BOTTOM: - if ((i > 0) && (crop_width != crop->regionlist[i - 1].width)) - { - TIFFError ("extractCompositeRegions", - "Only equal width regions can be combined for -E top or bottom"); - return (1); - } - - crop->combined_width = crop_width; - crop->combined_length += crop_length; - - for (row = first_row; row <= last_row; row++) - { - src_offset = row * src_rowsize; - dst_offset = (row - first_row) * dst_rowsize; - src = read_buff + src_offset; - dst = crop_buff + dst_offset + (prev_length * dst_rowsize); - switch (shift_width) - { - case 0: if (extractContigSamplesBytes (src, dst, img_width, sample, - spp, bps, count, first_col, - last_col + 1)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - case 1: if (bps == 1) - { - if (extractContigSamplesShifted8bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - } - else - if (extractContigSamplesShifted16bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - case 2: if (extractContigSamplesShifted24bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - case 3: - case 4: - case 5: if (extractContigSamplesShifted32bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - default: TIFFError("extractCompositeRegions", "Unsupported bit depth %d", bps); - return (1); - } - } - prev_length += crop_length; - break; - case EDGE_LEFT: /* splice the pieces of each row together, side by side */ - case EDGE_RIGHT: - if ((i > 0) && (crop_length != crop->regionlist[i - 1].length)) - { - TIFFError ("extractCompositeRegions", - "Only equal length regions can be combined for -E left or right"); - return (1); - } - crop->combined_width += crop_width; - crop->combined_length = crop_length; - dst_rowsize = (((composite_width * bps * count) + 7) / 8); - trailing_bits = (crop_width * bps * count) % 8; - for (row = first_row; row <= last_row; row++) - { - src_offset = row * src_rowsize; - dst_offset = (row - first_row) * dst_rowsize; - src = read_buff + src_offset; - dst = crop_buff + dst_offset + prev_width; - - switch (shift_width) - { - case 0: if (extractContigSamplesBytes (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - case 1: if (bps == 1) - { - if (extractContigSamplesShifted8bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - } - else - if (extractContigSamplesShifted16bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - case 2: if (extractContigSamplesShifted24bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - case 3: - case 4: - case 5: if (extractContigSamplesShifted32bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractCompositeRegions", - "Unable to extract row %d", row); - return (1); - } - break; - default: TIFFError("extractCompositeRegions", "Unsupported bit depth %d", bps); - return (1); - } - } - prev_width += (crop_width * bps * count) / 8; - prev_trailing_bits += trailing_bits; - if (prev_trailing_bits > 7) - prev_trailing_bits-= 8; - break; - } - } - if (crop->combined_width != composite_width) - TIFFError("combineSeparateRegions","Combined width does not match composite width"); - - return (0); - } /* end extractCompositeRegions */ - -/* Copy a single region of input buffer to an output buffer. - * The read functions used copy separate plane data into a buffer - * as interleaved samples rather than separate planes so the same - * logic works to extract regions regardless of the way the data - * are organized in the input file. This function can be used to - * extract one or more samples from the input image by updating the - * parameters for starting sample and number of samples to copy in the - * fifth and eighth arguments of the call to extractContigSamples. - * They would be passed as new elements of the crop_mask struct. - */ - -static int -extractSeparateRegion(struct image_data *image, struct crop_mask *crop, - unsigned char *read_buff, unsigned char *crop_buff, - int region) - { - int shift_width, prev_trailing_bits = 0; - uint32 bytes_per_sample, bytes_per_pixel; - uint32 src_rowsize, dst_rowsize; - uint32 row, first_row, last_row, first_col, last_col; - uint32 src_offset, dst_offset; - uint32 crop_width, crop_length, img_width /*, img_length */; - uint16 bps, spp; - uint8 *src, *dst; - tsample_t count, sample = 0; /* Update to extract more or more samples */ - - img_width = image->width; - /* img_length = image->length; */ - bps = image->bps; - spp = image->spp; - count = spp; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if ((bps % 8) == 0) - shift_width = 0; /* Byte aligned data only */ - else - { - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - } - - /* rows, columns, width, length are expressed in pixels */ - first_row = crop->regionlist[region].y1; - last_row = crop->regionlist[region].y2; - first_col = crop->regionlist[region].x1; - last_col = crop->regionlist[region].x2; - - crop_width = last_col - first_col + 1; - crop_length = last_row - first_row + 1; - - crop->regionlist[region].width = crop_width; - crop->regionlist[region].length = crop_length; - crop->regionlist[region].buffptr = crop_buff; - - src = read_buff; - dst = crop_buff; - src_rowsize = ((img_width * bps * spp) + 7) / 8; - dst_rowsize = (((crop_width * bps * spp) + 7) / 8); - - for (row = first_row; row <= last_row; row++) - { - src_offset = row * src_rowsize; - dst_offset = (row - first_row) * dst_rowsize; - src = read_buff + src_offset; - dst = crop_buff + dst_offset; - - switch (shift_width) - { - case 0: if (extractContigSamplesBytes (src, dst, img_width, sample, - spp, bps, count, first_col, - last_col + 1)) - { - TIFFError("extractSeparateRegion", - "Unable to extract row %d", row); - return (1); - } - break; - case 1: if (bps == 1) - { - if (extractContigSamplesShifted8bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractSeparateRegion", - "Unable to extract row %d", row); - return (1); - } - break; - } - else - if (extractContigSamplesShifted16bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractSeparateRegion", - "Unable to extract row %d", row); - return (1); - } - break; - case 2: if (extractContigSamplesShifted24bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractSeparateRegion", - "Unable to extract row %d", row); - return (1); - } - break; - case 3: - case 4: - case 5: if (extractContigSamplesShifted32bits (src, dst, img_width, - sample, spp, bps, count, - first_col, last_col + 1, - prev_trailing_bits)) - { - TIFFError("extractSeparateRegion", - "Unable to extract row %d", row); - return (1); - } - break; - default: TIFFError("extractSeparateRegion", "Unsupported bit depth %d", bps); - return (1); - } - } - - return (0); - } /* end extractSeparateRegion */ - -static int -extractImageSection(struct image_data *image, struct pageseg *section, - unsigned char *src_buff, unsigned char *sect_buff) - { - unsigned char bytebuff1, bytebuff2; -#ifdef DEVELMODE - /* unsigned char *src, *dst; */ -#endif - - uint32 img_width, img_rowsize; -#ifdef DEVELMODE - uint32 img_length; -#endif - uint32 j, shift1, shift2, trailing_bits; - uint32 row, first_row, last_row, first_col, last_col; - uint32 src_offset, dst_offset, row_offset, col_offset; - uint32 offset1, offset2, full_bytes; - uint32 sect_width; -#ifdef DEVELMODE - uint32 sect_length; -#endif - uint16 bps, spp; - -#ifdef DEVELMODE - int k; - unsigned char bitset; - static char *bitarray = NULL; -#endif - - img_width = image->width; -#ifdef DEVELMODE - img_length = image->length; -#endif - bps = image->bps; - spp = image->spp; - -#ifdef DEVELMODE - /* src = src_buff; */ - /* dst = sect_buff; */ -#endif - src_offset = 0; - dst_offset = 0; - -#ifdef DEVELMODE - if (bitarray == NULL) - { - if ((bitarray = (char *)malloc(img_width)) == NULL) - { - TIFFError ("", "DEBUG: Unable to allocate debugging bitarray"); - return (-1); - } - } -#endif - - /* rows, columns, width, length are expressed in pixels */ - first_row = section->y1; - last_row = section->y2; - first_col = section->x1; - last_col = section->x2; - - sect_width = last_col - first_col + 1; -#ifdef DEVELMODE - sect_length = last_row - first_row + 1; -#endif - img_rowsize = ((img_width * bps + 7) / 8) * spp; - full_bytes = (sect_width * spp * bps) / 8; /* number of COMPLETE bytes per row in section */ - trailing_bits = (sect_width * bps) % 8; - -#ifdef DEVELMODE - TIFFError ("", "First row: %d, last row: %d, First col: %d, last col: %d\n", - first_row, last_row, first_col, last_col); - TIFFError ("", "Image width: %d, Image length: %d, bps: %d, spp: %d\n", - img_width, img_length, bps, spp); - TIFFError ("", "Sect width: %d, Sect length: %d, full bytes: %d trailing bits %d\n", - sect_width, sect_length, full_bytes, trailing_bits); -#endif - - if ((bps % 8) == 0) - { - col_offset = first_col * spp * bps / 8; - for (row = first_row; row <= last_row; row++) - { - /* row_offset = row * img_width * spp * bps / 8; */ - row_offset = row * img_rowsize; - src_offset = row_offset + col_offset; - -#ifdef DEVELMODE - TIFFError ("", "Src offset: %8d, Dst offset: %8d", src_offset, dst_offset); -#endif - _TIFFmemcpy (sect_buff + dst_offset, src_buff + src_offset, full_bytes); - dst_offset += full_bytes; - } - } - else - { /* bps != 8 */ - shift1 = spp * ((first_col * bps) % 8); - shift2 = spp * ((last_col * bps) % 8); - for (row = first_row; row <= last_row; row++) - { - /* pull out the first byte */ - row_offset = row * img_rowsize; - offset1 = row_offset + (first_col * bps / 8); - offset2 = row_offset + (last_col * bps / 8); - -#ifdef DEVELMODE - for (j = 0, k = 7; j < 8; j++, k--) - { - bitset = *(src_buff + offset1) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&bitarray[j], (bitset) ? "1" : "0"); - } - sprintf(&bitarray[8], " "); - sprintf(&bitarray[9], " "); - for (j = 10, k = 7; j < 18; j++, k--) - { - bitset = *(src_buff + offset2) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&bitarray[j], (bitset) ? "1" : "0"); - } - bitarray[18] = '\0'; - TIFFError ("", "Row: %3d Offset1: %d, Shift1: %d, Offset2: %d, Shift2: %d\n", - row, offset1, shift1, offset2, shift2); -#endif - - bytebuff1 = bytebuff2 = 0; - if (shift1 == 0) /* the region is byte and sample alligned */ - { - _TIFFmemcpy (sect_buff + dst_offset, src_buff + offset1, full_bytes); - -#ifdef DEVELMODE - TIFFError ("", " Alligned data src offset1: %8d, Dst offset: %8d\n", offset1, dst_offset); - sprintf(&bitarray[18], "\n"); - sprintf(&bitarray[19], "\t"); - for (j = 20, k = 7; j < 28; j++, k--) - { - bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&bitarray[j], (bitset) ? "1" : "0"); - } - bitarray[28] = ' '; - bitarray[29] = ' '; -#endif - dst_offset += full_bytes; - - if (trailing_bits != 0) - { - bytebuff2 = src_buff[offset2] & ((unsigned char)255 << (7 - shift2)); - sect_buff[dst_offset] = bytebuff2; -#ifdef DEVELMODE - TIFFError ("", " Trailing bits src offset: %8d, Dst offset: %8d\n", - offset2, dst_offset); - for (j = 30, k = 7; j < 38; j++, k--) - { - bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&bitarray[j], (bitset) ? "1" : "0"); - } - bitarray[38] = '\0'; - TIFFError ("", "\tFirst and last bytes before and after masking:\n\t%s\n\n", bitarray); -#endif - dst_offset++; - } - } - else /* each destination byte will have to be built from two source bytes*/ - { -#ifdef DEVELMODE - TIFFError ("", " Unalligned data src offset: %8d, Dst offset: %8d\n", offset1 , dst_offset); -#endif - for (j = 0; j <= full_bytes; j++) - { - bytebuff1 = src_buff[offset1 + j] & ((unsigned char)255 >> shift1); - bytebuff2 = src_buff[offset1 + j + 1] & ((unsigned char)255 << (7 - shift1)); - sect_buff[dst_offset + j] = (bytebuff1 << shift1) | (bytebuff2 >> (8 - shift1)); - } -#ifdef DEVELMODE - sprintf(&bitarray[18], "\n"); - sprintf(&bitarray[19], "\t"); - for (j = 20, k = 7; j < 28; j++, k--) - { - bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&bitarray[j], (bitset) ? "1" : "0"); - } - bitarray[28] = ' '; - bitarray[29] = ' '; -#endif - dst_offset += full_bytes; - - if (trailing_bits != 0) - { -#ifdef DEVELMODE - TIFFError ("", " Trailing bits src offset: %8d, Dst offset: %8d\n", offset1 + full_bytes, dst_offset); -#endif - if (shift2 > shift1) - { - bytebuff1 = src_buff[offset1 + full_bytes] & ((unsigned char)255 << (7 - shift2)); - bytebuff2 = bytebuff1 & ((unsigned char)255 << shift1); - sect_buff[dst_offset] = bytebuff2; -#ifdef DEVELMODE - TIFFError ("", " Shift2 > Shift1\n"); -#endif - } - else - { - if (shift2 < shift1) - { - bytebuff2 = ((unsigned char)255 << (shift1 - shift2 - 1)); - sect_buff[dst_offset] &= bytebuff2; -#ifdef DEVELMODE - TIFFError ("", " Shift2 < Shift1\n"); -#endif - } -#ifdef DEVELMODE - else - TIFFError ("", " Shift2 == Shift1\n"); -#endif - } - } -#ifdef DEVELMODE - sprintf(&bitarray[28], " "); - sprintf(&bitarray[29], " "); - for (j = 30, k = 7; j < 38; j++, k--) - { - bitset = *(sect_buff + dst_offset) & (((unsigned char)1 << k)) ? 1 : 0; - sprintf(&bitarray[j], (bitset) ? "1" : "0"); - } - bitarray[38] = '\0'; - TIFFError ("", "\tFirst and last bytes before and after masking:\n\t%s\n\n", bitarray); -#endif - dst_offset++; - } - } - } - - return (0); - } /* end extractImageSection */ - -static int -writeSelections(TIFF *in, TIFF **out, struct crop_mask *crop, - struct image_data *image, struct dump_opts *dump, - struct buffinfo seg_buffs[], char *mp, char *filename, - unsigned int *page, unsigned int total_pages) - { - int i, page_count; - int autoindex = 0; - unsigned char *crop_buff = NULL; - - /* Where we open a new file depends on the export mode */ - switch (crop->exp_mode) - { - case ONE_FILE_COMPOSITE: /* Regions combined into single image */ - autoindex = 0; - crop_buff = seg_buffs[0].buffer; - if (update_output_file (out, mp, autoindex, filename, page)) - return (1); - page_count = total_pages; - if (writeCroppedImage(in, *out, image, dump, - crop->combined_width, - crop->combined_length, - crop_buff, *page, total_pages)) - { - TIFFError("writeRegions", "Unable to write new image"); - return (-1); - } - break; - case ONE_FILE_SEPARATED: /* Regions as separated images */ - autoindex = 0; - if (update_output_file (out, mp, autoindex, filename, page)) - return (1); - page_count = crop->selections * total_pages; - for (i = 0; i < crop->selections; i++) - { - crop_buff = seg_buffs[i].buffer; - if (writeCroppedImage(in, *out, image, dump, - crop->regionlist[i].width, - crop->regionlist[i].length, - crop_buff, *page, page_count)) - { - TIFFError("writeRegions", "Unable to write new image"); - return (-1); - } - } - break; - case FILE_PER_IMAGE_COMPOSITE: /* Regions as composite image */ - autoindex = 1; - if (update_output_file (out, mp, autoindex, filename, page)) - return (1); - - crop_buff = seg_buffs[0].buffer; - if (writeCroppedImage(in, *out, image, dump, - crop->combined_width, - crop->combined_length, - crop_buff, *page, total_pages)) - { - TIFFError("writeRegions", "Unable to write new image"); - return (-1); - } - break; - case FILE_PER_IMAGE_SEPARATED: /* Regions as separated images */ - autoindex = 1; - page_count = crop->selections; - if (update_output_file (out, mp, autoindex, filename, page)) - return (1); - - for (i = 0; i < crop->selections; i++) - { - crop_buff = seg_buffs[i].buffer; - /* Write the current region to the current file */ - if (writeCroppedImage(in, *out, image, dump, - crop->regionlist[i].width, - crop->regionlist[i].length, - crop_buff, *page, page_count)) - { - TIFFError("writeRegions", "Unable to write new image"); - return (-1); - } - } - break; - case FILE_PER_SELECTION: - autoindex = 1; - page_count = 1; - for (i = 0; i < crop->selections; i++) - { - if (update_output_file (out, mp, autoindex, filename, page)) - return (1); - - crop_buff = seg_buffs[i].buffer; - /* Write the current region to the current file */ - if (writeCroppedImage(in, *out, image, dump, - crop->regionlist[i].width, - crop->regionlist[i].length, - crop_buff, *page, page_count)) - { - TIFFError("writeRegions", "Unable to write new image"); - return (-1); - } - } - break; - default: return (1); - } - - return (0); - } /* end writeRegions */ - -static int -writeImageSections(TIFF *in, TIFF *out, struct image_data *image, - struct pagedef *page, struct pageseg *sections, - struct dump_opts * dump, unsigned char *src_buff, - unsigned char **sect_buff_ptr) - { - double hres, vres; - uint32 i, k, width, length, sectsize; - unsigned char *sect_buff = *sect_buff_ptr; - - hres = page->hres; - vres = page->vres; - - k = page->cols * page->rows; - if ((k < 1) || (k > MAX_SECTIONS)) - { - TIFFError("writeImageSections", - "%d Rows and Columns exceed maximum sections\nIncrease resolution or reduce sections", k); - return (-1); - } - - for (i = 0; i < k; i++) - { - width = sections[i].x2 - sections[i].x1 + 1; - length = sections[i].y2 - sections[i].y1 + 1; - sectsize = (uint32) - ceil((width * image->bps + 7) / (double)8) * image->spp * length; - /* allocate a buffer if we don't have one already */ - if (createImageSection(sectsize, sect_buff_ptr)) - { - TIFFError("writeImageSections", "Unable to allocate section buffer"); - exit (-1); - } - sect_buff = *sect_buff_ptr; - - if (extractImageSection (image, §ions[i], src_buff, sect_buff)) - { - TIFFError("writeImageSections", "Unable to extract image sections"); - exit (-1); - } - - /* call the write routine here instead of outside the loop */ - if (writeSingleSection(in, out, image, dump, width, length, hres, vres, sect_buff)) - { - TIFFError("writeImageSections", "Unable to write image section"); - exit (-1); - } - } - - return (0); - } /* end writeImageSections */ - -/* Code in this function is heavily indebted to code in tiffcp - * with modifications by Richard Nolde to handle orientation correctly. - * It will have to be updated significantly if support is added to - * extract one or more samples from original image since the - * original code assumes we are always copying all samples. - */ -static int -writeSingleSection(TIFF *in, TIFF *out, struct image_data *image, - struct dump_opts *dump, uint32 width, uint32 length, - double hres, double vres, - unsigned char *sect_buff) - { - uint16 bps, spp; - uint16 input_compression, input_photometric; - uint16 input_planar; - struct cpTag* p; - - /* Calling this seems to reset the compression mode on the TIFF *in file. - TIFFGetField(in, TIFFTAG_JPEGCOLORMODE, &input_jpeg_colormode); - */ - input_compression = image->compression; - input_photometric = image->photometric; - - spp = image->spp; - bps = image->bps; - TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width); - TIFFSetField(out, TIFFTAG_IMAGELENGTH, length); - TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, bps); - TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, spp); - -#ifdef DEBUG2 - TIFFError("writeSingleSection", "Input compression: %s", - (input_compression == COMPRESSION_OJPEG) ? "Old Jpeg" : - ((input_compression == COMPRESSION_JPEG) ? "New Jpeg" : "Non Jpeg")); -#endif - /* This is the global variable compression which is set - * if the user has specified a command line option for - * a compression option. Should be passed around in one - * of the parameters instead of as a global. If no user - * option specified it will still be (uint16) -1. */ - if (compression != (uint16)-1) - TIFFSetField(out, TIFFTAG_COMPRESSION, compression); - else - { /* OJPEG is no longer supported for writing so upgrade to JPEG */ - if (input_compression == COMPRESSION_OJPEG) - { - compression = COMPRESSION_JPEG; - jpegcolormode = JPEGCOLORMODE_RAW; - TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_JPEG); - } - else /* Use the compression from the input file */ - TIFFSetField(out, TIFFTAG_COMPRESSION, compression); - } - - if (compression == COMPRESSION_JPEG) - { - if ((input_photometric == PHOTOMETRIC_PALETTE) || /* color map indexed */ - (input_photometric == PHOTOMETRIC_MASK)) /* holdout mask */ - { - TIFFError ("writeSingleSection", - "JPEG compression cannot be used with %s image data", - (input_photometric == PHOTOMETRIC_PALETTE) ? - "palette" : "mask"); - return (-1); - } - if ((input_photometric == PHOTOMETRIC_RGB) && - (jpegcolormode == JPEGCOLORMODE_RGB)) - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR); - else - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, input_photometric); - } - else - { - if (compression == COMPRESSION_SGILOG || compression == COMPRESSION_SGILOG24) - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, spp == 1 ? - PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV); - else - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, image->photometric); - } - -#ifdef DEBUG2 - TIFFError("writeSingleSection", "Input photometric: %s", - (input_photometric == PHOTOMETRIC_RGB) ? "RGB" : - ((input_photometric == PHOTOMETRIC_YCBCR) ? "YCbCr" : "Not RGB or YCbCr")); -#endif - - if (((input_photometric == PHOTOMETRIC_LOGL) || - (input_photometric == PHOTOMETRIC_LOGLUV)) && - ((compression != COMPRESSION_SGILOG) && - (compression != COMPRESSION_SGILOG24))) - { - TIFFError("writeSingleSection", - "LogL and LogLuv source data require SGI_LOG or SGI_LOG24 compression"); - return (-1); - } - - if (fillorder != 0) - TIFFSetField(out, TIFFTAG_FILLORDER, fillorder); - else - CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT); - - /* The loadimage function reads input orientation and sets - * image->orientation. The correct_image_orientation function - * applies the required rotation and mirror operations to - * present the data in TOPLEFT orientation and updates - * image->orientation if any transforms are performed, - * as per EXIF standard. - */ - TIFFSetField(out, TIFFTAG_ORIENTATION, image->orientation); - - /* - * Choose tiles/strip for the output image according to - * the command line arguments (-tiles, -strips) and the - * structure of the input image. - */ - if (outtiled == -1) - outtiled = TIFFIsTiled(in); - if (outtiled) { - /* - * Setup output file's tile width&height. If either - * is not specified, use either the value from the - * input image or, if nothing is defined, use the - * library default. - */ - if (tilewidth == (uint32) 0) - TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth); - if (tilelength == (uint32) 0) - TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength); - - if (tilewidth == 0 || tilelength == 0) - TIFFDefaultTileSize(out, &tilewidth, &tilelength); - TIFFDefaultTileSize(out, &tilewidth, &tilelength); - TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth); - TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength); - } else { - /* - * RowsPerStrip is left unspecified: use either the - * value from the input image or, if nothing is defined, - * use the library default. - */ - if (rowsperstrip == (uint32) 0) - { - if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip)) - rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip); - if (compression != COMPRESSION_JPEG) - { - if (rowsperstrip > length) - rowsperstrip = length; - } - } - else - if (rowsperstrip == (uint32) -1) - rowsperstrip = length; - TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip); - } - - TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &input_planar); - if (config != (uint16) -1) - TIFFSetField(out, TIFFTAG_PLANARCONFIG, config); - else - CopyField(TIFFTAG_PLANARCONFIG, config); - if (spp <= 4) - CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT); - CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT); - -/* SMinSampleValue & SMaxSampleValue */ - switch (compression) { - /* These are references to GLOBAL variables set by defaults - * and /or the compression flag - */ - case COMPRESSION_JPEG: - if (((bps % 8) == 0) || ((bps % 12) == 0)) - { - TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality); - TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); - } - else - { - TIFFError("writeSingleSection", - "JPEG compression requires 8 or 12 bits per sample"); - return (-1); - } - break; - case COMPRESSION_LZW: - case COMPRESSION_ADOBE_DEFLATE: - case COMPRESSION_DEFLATE: - if (predictor != (uint16)-1) - TIFFSetField(out, TIFFTAG_PREDICTOR, predictor); - else - CopyField(TIFFTAG_PREDICTOR, predictor); - break; - case COMPRESSION_CCITTFAX3: - case COMPRESSION_CCITTFAX4: - if (compression == COMPRESSION_CCITTFAX3) { - if (g3opts != (uint32) -1) - TIFFSetField(out, TIFFTAG_GROUP3OPTIONS, g3opts); - else - CopyField(TIFFTAG_GROUP3OPTIONS, g3opts); - } else - CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG); - CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG); - CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG); - CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG); - CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG); - CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG); - CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII); - break; - } - { uint32 len32; - void** data; - if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data)) - TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data); - } - { uint16 ninks; - const char* inknames; - if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) { - TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks); - if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) { - int inknameslen = strlen(inknames) + 1; - const char* cp = inknames; - while (ninks > 1) { - cp = strchr(cp, '\0'); - if (cp) { - cp++; - inknameslen += (strlen(cp) + 1); - } - ninks--; - } - TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames); - } - } - } - { - unsigned short pg0, pg1; - if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) { - if (pageNum < 0) /* only one input file */ - TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1); - else - TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0); - } - } - - for (p = tags; p < &tags[NTAGS]; p++) - CopyTag(p->tag, p->count, p->type); - - /* Update these since they are overwritten from input res by loop above */ - TIFFSetField(out, TIFFTAG_XRESOLUTION, (float)hres); - TIFFSetField(out, TIFFTAG_YRESOLUTION, (float)vres); - - /* Compute the tile or strip dimensions and write to disk */ - if (outtiled) - { - if (config == PLANARCONFIG_CONTIG) - writeBufferToContigTiles (out, sect_buff, length, width, spp, dump); - else - writeBufferToSeparateTiles (out, sect_buff, length, width, spp, dump); - } - else - { - if (config == PLANARCONFIG_CONTIG) - writeBufferToContigStrips (out, sect_buff, length); - else - writeBufferToSeparateStrips(out, sect_buff, length, width, spp, dump); - } - - if (!TIFFWriteDirectory(out)) - { - TIFFClose(out); - return (-1); - } - - return (0); - } /* end writeSingleSection */ - - -/* Create a buffer to write one section at a time */ -static int -createImageSection(uint32 sectsize, unsigned char **sect_buff_ptr) - { - unsigned char *sect_buff = NULL; - unsigned char *new_buff = NULL; - static uint32 prev_sectsize = 0; - - sect_buff = *sect_buff_ptr; - - if (!sect_buff) - { - sect_buff = (unsigned char *)_TIFFmalloc(sectsize); - *sect_buff_ptr = sect_buff; - _TIFFmemset(sect_buff, 0, sectsize); - } - else - { - if (prev_sectsize < sectsize) - { - new_buff = _TIFFrealloc(sect_buff, sectsize); - if (!new_buff) - { - free (sect_buff); - sect_buff = (unsigned char *)_TIFFmalloc(sectsize); - } - else - sect_buff = new_buff; - - _TIFFmemset(sect_buff, 0, sectsize); - } - } - - if (!sect_buff) - { - TIFFError("createImageSection", "Unable to allocate/reallocate section buffer"); - return (-1); - } - prev_sectsize = sectsize; - *sect_buff_ptr = sect_buff; - - return (0); - } /* end createImageSection */ - - -/* Process selections defined by regions, zones, margins, or fixed sized areas */ -static int -processCropSelections(struct image_data *image, struct crop_mask *crop, - unsigned char **read_buff_ptr, struct buffinfo seg_buffs[]) - { - int i; - uint32 width, length, total_width, total_length; - tsize_t cropsize; - unsigned char *crop_buff = NULL; - unsigned char *read_buff = NULL; - unsigned char *next_buff = NULL; - tsize_t prev_cropsize = 0; - - read_buff = *read_buff_ptr; - - if (crop->img_mode == COMPOSITE_IMAGES) - { - cropsize = crop->bufftotal; - crop_buff = seg_buffs[0].buffer; - if (!crop_buff) - crop_buff = (unsigned char *)_TIFFmalloc(cropsize); - else - { - prev_cropsize = seg_buffs[0].size; - if (prev_cropsize < cropsize) - { - next_buff = _TIFFrealloc(crop_buff, cropsize); - if (! next_buff) - { - _TIFFfree (crop_buff); - crop_buff = (unsigned char *)_TIFFmalloc(cropsize); - } - else - crop_buff = next_buff; - } - } - - if (!crop_buff) - { - TIFFError("processCropSelections", "Unable to allocate/reallocate crop buffer"); - return (-1); - } - - _TIFFmemset(crop_buff, 0, cropsize); - seg_buffs[0].buffer = crop_buff; - seg_buffs[0].size = cropsize; - - /* Checks for matching width or length as required */ - if (extractCompositeRegions(image, crop, read_buff, crop_buff) != 0) - return (1); - - if (crop->crop_mode & CROP_INVERT) - { - switch (crop->photometric) - { - /* Just change the interpretation */ - case PHOTOMETRIC_MINISWHITE: - case PHOTOMETRIC_MINISBLACK: - image->photometric = crop->photometric; - break; - case INVERT_DATA_ONLY: - case INVERT_DATA_AND_TAG: - if (invertImage(image->photometric, image->spp, image->bps, - crop->combined_width, crop->combined_length, crop_buff)) - { - TIFFError("processCropSelections", - "Failed to invert colorspace for composite regions"); - return (-1); - } - if (crop->photometric == INVERT_DATA_AND_TAG) - { - switch (image->photometric) - { - case PHOTOMETRIC_MINISWHITE: - image->photometric = PHOTOMETRIC_MINISBLACK; - break; - case PHOTOMETRIC_MINISBLACK: - image->photometric = PHOTOMETRIC_MINISWHITE; - break; - default: - break; - } - } - break; - default: break; - } - } - - /* Mirror and Rotate will not work with multiple regions unless they are the same width */ - if (crop->crop_mode & CROP_MIRROR) - { - if (mirrorImage(image->spp, image->bps, crop->mirror, - crop->combined_width, crop->combined_length, crop_buff)) - { - TIFFError("processCropSelections", "Failed to mirror composite regions %s", - (crop->rotation == MIRROR_HORIZ) ? "horizontally" : "vertically"); - return (-1); - } - } - - if (crop->crop_mode & CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */ - { - if (rotateImage(crop->rotation, image, &crop->combined_width, - &crop->combined_length, &crop_buff)) - { - TIFFError("processCropSelections", - "Failed to rotate composite regions by %d degrees", crop->rotation); - return (-1); - } - seg_buffs[0].buffer = crop_buff; - seg_buffs[0].size = (((crop->combined_width * image->bps + 7 ) / 8) - * image->spp) * crop->combined_length; - } - } - else /* Separated Images */ - { - total_width = total_length = 0; - for (i = 0; i < crop->selections; i++) - { - cropsize = crop->bufftotal; - crop_buff = seg_buffs[i].buffer; - if (!crop_buff) - crop_buff = (unsigned char *)_TIFFmalloc(cropsize); - else - { - prev_cropsize = seg_buffs[0].size; - if (prev_cropsize < cropsize) - { - next_buff = _TIFFrealloc(crop_buff, cropsize); - if (! next_buff) - { - _TIFFfree (crop_buff); - crop_buff = (unsigned char *)_TIFFmalloc(cropsize); - } - else - crop_buff = next_buff; - } - } - - if (!crop_buff) - { - TIFFError("processCropSelections", "Unable to allocate/reallocate crop buffer"); - return (-1); - } - - _TIFFmemset(crop_buff, 0, cropsize); - seg_buffs[i].buffer = crop_buff; - seg_buffs[i].size = cropsize; - - if (extractSeparateRegion(image, crop, read_buff, crop_buff, i)) - { - TIFFError("processCropSelections", "Unable to extract cropped region %d from image", i); - return (-1); - } - - width = crop->regionlist[i].width; - length = crop->regionlist[i].length; - - if (crop->crop_mode & CROP_INVERT) - { - switch (crop->photometric) - { - /* Just change the interpretation */ - case PHOTOMETRIC_MINISWHITE: - case PHOTOMETRIC_MINISBLACK: - image->photometric = crop->photometric; - break; - case INVERT_DATA_ONLY: - case INVERT_DATA_AND_TAG: - if (invertImage(image->photometric, image->spp, image->bps, - width, length, crop_buff)) - { - TIFFError("processCropSelections", - "Failed to invert colorspace for region"); - return (-1); - } - if (crop->photometric == INVERT_DATA_AND_TAG) - { - switch (image->photometric) - { - case PHOTOMETRIC_MINISWHITE: - image->photometric = PHOTOMETRIC_MINISBLACK; - break; - case PHOTOMETRIC_MINISBLACK: - image->photometric = PHOTOMETRIC_MINISWHITE; - break; - default: - break; - } - } - break; - default: break; - } - } - - if (crop->crop_mode & CROP_MIRROR) - { - if (mirrorImage(image->spp, image->bps, crop->mirror, - width, length, crop_buff)) - { - TIFFError("processCropSelections", "Failed to mirror crop region %s", - (crop->rotation == MIRROR_HORIZ) ? "horizontally" : "vertically"); - return (-1); - } - } - - if (crop->crop_mode & CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */ - { - if (rotateImage(crop->rotation, image, &crop->regionlist[i].width, - &crop->regionlist[i].length, &crop_buff)) - { - TIFFError("processCropSelections", - "Failed to rotate crop region by %d degrees", crop->rotation); - return (-1); - } - total_width += crop->regionlist[i].width; - total_length += crop->regionlist[i].length; - crop->combined_width = total_width; - crop->combined_length = total_length; - seg_buffs[i].buffer = crop_buff; - seg_buffs[i].size = (((crop->regionlist[i].width * image->bps + 7 ) / 8) - * image->spp) * crop->regionlist[i].length; - } - } - } - return (0); - } /* end processCropSelections */ - -/* Copy the crop section of the data from the current image into a buffer - * and adjust the IFD values to reflect the new size. If no cropping is - * required, use the origial read buffer as the crop buffer. - * - * There is quite a bit of redundancy between this routine and the more - * specialized processCropSelections, but this provides - * the most optimized path when no Zones or Regions are required. - */ -static int -createCroppedImage(struct image_data *image, struct crop_mask *crop, - unsigned char **read_buff_ptr, unsigned char **crop_buff_ptr) - { - tsize_t cropsize; - unsigned char *read_buff = NULL; - unsigned char *crop_buff = NULL; - unsigned char *new_buff = NULL; - static tsize_t prev_cropsize = 0; - - read_buff = *read_buff_ptr; - - /* process full image, no crop buffer needed */ - crop_buff = read_buff; - *crop_buff_ptr = read_buff; - crop->combined_width = image->width; - crop->combined_length = image->length; - - cropsize = crop->bufftotal; - crop_buff = *crop_buff_ptr; - if (!crop_buff) - { - crop_buff = (unsigned char *)_TIFFmalloc(cropsize); - *crop_buff_ptr = crop_buff; - _TIFFmemset(crop_buff, 0, cropsize); - prev_cropsize = cropsize; - } - else - { - if (prev_cropsize < cropsize) - { - new_buff = _TIFFrealloc(crop_buff, cropsize); - if (!new_buff) - { - free (crop_buff); - crop_buff = (unsigned char *)_TIFFmalloc(cropsize); - } - else - crop_buff = new_buff; - _TIFFmemset(crop_buff, 0, cropsize); - } - } - - if (!crop_buff) - { - TIFFError("createCroppedImage", "Unable to allocate/reallocate crop buffer"); - return (-1); - } - *crop_buff_ptr = crop_buff; - - if (crop->crop_mode & CROP_INVERT) - { - switch (crop->photometric) - { - /* Just change the interpretation */ - case PHOTOMETRIC_MINISWHITE: - case PHOTOMETRIC_MINISBLACK: - image->photometric = crop->photometric; - break; - case INVERT_DATA_ONLY: - case INVERT_DATA_AND_TAG: - if (invertImage(image->photometric, image->spp, image->bps, - crop->combined_width, crop->combined_length, crop_buff)) - { - TIFFError("createCroppedImage", - "Failed to invert colorspace for image or cropped selection"); - return (-1); - } - if (crop->photometric == INVERT_DATA_AND_TAG) - { - switch (image->photometric) - { - case PHOTOMETRIC_MINISWHITE: - image->photometric = PHOTOMETRIC_MINISBLACK; - break; - case PHOTOMETRIC_MINISBLACK: - image->photometric = PHOTOMETRIC_MINISWHITE; - break; - default: - break; - } - } - break; - default: break; - } - } - - if (crop->crop_mode & CROP_MIRROR) - { - if (mirrorImage(image->spp, image->bps, crop->mirror, - crop->combined_width, crop->combined_length, crop_buff)) - { - TIFFError("createCroppedImage", "Failed to mirror image or cropped selection %s", - (crop->rotation == MIRROR_HORIZ) ? "horizontally" : "vertically"); - return (-1); - } - } - - if (crop->crop_mode & CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */ - { - if (rotateImage(crop->rotation, image, &crop->combined_width, - &crop->combined_length, crop_buff_ptr)) - { - TIFFError("createCroppedImage", - "Failed to rotate image or cropped selection by %d degrees", crop->rotation); - return (-1); - } - } - - if (crop_buff == read_buff) /* we used the read buffer for the crop buffer */ - *read_buff_ptr = NULL; /* so we don't try to free it later */ - - return (0); - } /* end createCroppedImage */ - - -/* Code in this function is heavily indebted to code in tiffcp - * with modifications by Richard Nolde to handle orientation correctly. - * It will have to be updated significantly if support is added to - * extract one or more samples from original image since the - * original code assumes we are always copying all samples. - * Use of global variables for config, compression and others - * should be replaced by addition to the crop_mask struct (which - * will be renamed to proc_opts indicating that is controlls - * user supplied processing options, not just cropping) and - * then passed in as an argument. - */ -static int -writeCroppedImage(TIFF *in, TIFF *out, struct image_data *image, - struct dump_opts *dump, uint32 width, uint32 length, - unsigned char *crop_buff, int pagenum, int total_pages) - { - uint16 bps, spp; - uint16 input_compression, input_photometric; - uint16 input_planar; - struct cpTag* p; - - input_compression = image->compression; - input_photometric = image->photometric; - spp = image->spp; - bps = image->bps; - - TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width); - TIFFSetField(out, TIFFTAG_IMAGELENGTH, length); - TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, bps); - TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, spp); - -#ifdef DEBUG2 - TIFFError("writeCroppedImage", "Input compression: %s", - (input_compression == COMPRESSION_OJPEG) ? "Old Jpeg" : - ((input_compression == COMPRESSION_JPEG) ? "New Jpeg" : "Non Jpeg")); -#endif - - if (compression != (uint16)-1) - TIFFSetField(out, TIFFTAG_COMPRESSION, compression); - else - { - if (input_compression == COMPRESSION_OJPEG) - { - compression = COMPRESSION_JPEG; - jpegcolormode = JPEGCOLORMODE_RAW; - TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_JPEG); - } - else - CopyField(TIFFTAG_COMPRESSION, compression); - } - - if (compression == COMPRESSION_JPEG) - { - if ((input_photometric == PHOTOMETRIC_PALETTE) || /* color map indexed */ - (input_photometric == PHOTOMETRIC_MASK)) /* $holdout mask */ - { - TIFFError ("writeCroppedImage", - "JPEG compression cannot be used with %s image data", - (input_photometric == PHOTOMETRIC_PALETTE) ? - "palette" : "mask"); - return (-1); - } - if ((input_photometric == PHOTOMETRIC_RGB) && - (jpegcolormode == JPEGCOLORMODE_RGB)) - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR); - else - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, input_photometric); - } - else - { - if (compression == COMPRESSION_SGILOG || compression == COMPRESSION_SGILOG24) - { - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, spp == 1 ? - PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV); - } - else - { - if (input_compression == COMPRESSION_SGILOG || - input_compression == COMPRESSION_SGILOG24) - { - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, spp == 1 ? - PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV); - } - else - TIFFSetField(out, TIFFTAG_PHOTOMETRIC, image->photometric); - } - } - - if (((input_photometric == PHOTOMETRIC_LOGL) || - (input_photometric == PHOTOMETRIC_LOGLUV)) && - ((compression != COMPRESSION_SGILOG) && - (compression != COMPRESSION_SGILOG24))) - { - TIFFError("writeCroppedImage", - "LogL and LogLuv source data require SGI_LOG or SGI_LOG24 compression"); - return (-1); - } - - if (fillorder != 0) - TIFFSetField(out, TIFFTAG_FILLORDER, fillorder); - else - CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT); - - /* The loadimage function reads input orientation and sets - * image->orientation. The correct_image_orientation function - * applies the required rotation and mirror operations to - * present the data in TOPLEFT orientation and updates - * image->orientation if any transforms are performed, - * as per EXIF standard. - */ - TIFFSetField(out, TIFFTAG_ORIENTATION, image->orientation); - - /* - * Choose tiles/strip for the output image according to - * the command line arguments (-tiles, -strips) and the - * structure of the input image. - */ - if (outtiled == -1) - outtiled = TIFFIsTiled(in); - if (outtiled) { - /* - * Setup output file's tile width&height. If either - * is not specified, use either the value from the - * input image or, if nothing is defined, use the - * library default. - */ - if (tilewidth == (uint32) 0) - TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth); - if (tilelength == (uint32) 0) - TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength); - - if (tilewidth == 0 || tilelength == 0) - TIFFDefaultTileSize(out, &tilewidth, &tilelength); - TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth); - TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength); - } else { - /* - * RowsPerStrip is left unspecified: use either the - * value from the input image or, if nothing is defined, - * use the library default. - */ - if (rowsperstrip == (uint32) 0) - { - if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip)) - rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip); - if (compression != COMPRESSION_JPEG) - { - if (rowsperstrip > length) - rowsperstrip = length; - } - } - else - if (rowsperstrip == (uint32) -1) - rowsperstrip = length; - TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip); - } - - TIFFGetFieldDefaulted(in, TIFFTAG_PLANARCONFIG, &input_planar); - if (config != (uint16) -1) - TIFFSetField(out, TIFFTAG_PLANARCONFIG, config); - else - CopyField(TIFFTAG_PLANARCONFIG, config); - if (spp <= 4) - CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT); - CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT); - -/* SMinSampleValue & SMaxSampleValue */ - switch (compression) { - case COMPRESSION_JPEG: - if (((bps % 8) == 0) || ((bps % 12) == 0)) - { - TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality); - TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); - } - else - { - TIFFError("writeCroppedImage", - "JPEG compression requires 8 or 12 bits per sample"); - return (-1); - } - break; - case COMPRESSION_LZW: - case COMPRESSION_ADOBE_DEFLATE: - case COMPRESSION_DEFLATE: - if (predictor != (uint16)-1) - TIFFSetField(out, TIFFTAG_PREDICTOR, predictor); - else - CopyField(TIFFTAG_PREDICTOR, predictor); - break; - case COMPRESSION_CCITTFAX3: - case COMPRESSION_CCITTFAX4: - if (bps != 1) - { - TIFFError("writeCroppedImage", - "Group 3/4 compression is not usable with bps > 1"); - return (-1); - } - if (compression == COMPRESSION_CCITTFAX3) { - if (g3opts != (uint32) -1) - TIFFSetField(out, TIFFTAG_GROUP3OPTIONS, g3opts); - else - CopyField(TIFFTAG_GROUP3OPTIONS, g3opts); - } else - CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG); - CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG); - CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG); - CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG); - CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG); - CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG); - CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII); - break; - case COMPRESSION_NONE: - break; - default: break; - } - { uint32 len32; - void** data; - if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data)) - TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data); - } - { uint16 ninks; - const char* inknames; - if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) { - TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks); - if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) { - int inknameslen = strlen(inknames) + 1; - const char* cp = inknames; - while (ninks > 1) { - cp = strchr(cp, '\0'); - if (cp) { - cp++; - inknameslen += (strlen(cp) + 1); - } - ninks--; - } - TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames); - } - } - } - { - unsigned short pg0, pg1; - if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) { - TIFFSetField(out, TIFFTAG_PAGENUMBER, pagenum, total_pages); - } - } - - for (p = tags; p < &tags[NTAGS]; p++) - CopyTag(p->tag, p->count, p->type); - - /* Compute the tile or strip dimensions and write to disk */ - if (outtiled) - { - if (config == PLANARCONFIG_CONTIG) - { - if (writeBufferToContigTiles (out, crop_buff, length, width, spp, dump)) - TIFFError("","Unable to write contiguous tile data for page %d", pagenum); - } - else - { - if (writeBufferToSeparateTiles (out, crop_buff, length, width, spp, dump)) - TIFFError("","Unable to write separate tile data for page %d", pagenum); - } - } - else - { - if (config == PLANARCONFIG_CONTIG) - { - if (writeBufferToContigStrips (out, crop_buff, length)) - TIFFError("","Unable to write contiguous strip data for page %d", pagenum); - } - else - { - if (writeBufferToSeparateStrips(out, crop_buff, length, width, spp, dump)) - TIFFError("","Unable to write separate strip data for page %d", pagenum); - } - } - - if (!TIFFWriteDirectory(out)) - { - TIFFError("","Failed to write IFD for page number %d", pagenum); - TIFFClose(out); - return (-1); - } - - return (0); - } /* end writeCroppedImage */ - -static int -rotateContigSamples8bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width, - uint32 length, uint32 col, uint8 *src, uint8 *dst) - { - int ready_bits = 0; - uint32 src_byte = 0, src_bit = 0; - uint32 row, rowsize = 0, bit_offset = 0; - uint8 matchbits = 0, maskbits = 0; - uint8 buff1 = 0, buff2 = 0; - uint8 *next; - tsample_t sample; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("rotateContigSamples8bits","Invalid src or destination buffer"); - return (1); - } - - rowsize = ((bps * spp * width) + 7) / 8; - ready_bits = 0; - maskbits = (uint8)-1 >> ( 8 - bps); - buff1 = buff2 = 0; - - for (row = 0; row < length ; row++) - { - bit_offset = col * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - src_bit = (bit_offset + (sample * bps)) % 8; - } - - switch (rotation) - { - case 90: next = src + src_byte - (row * rowsize); - break; - case 270: next = src + src_byte + (row * rowsize); - break; - default: TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation); - return (1); - } - matchbits = maskbits << (8 - src_bit - bps); - buff1 = ((*next) & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - *dst++ = buff2; - buff2 = buff1; - ready_bits -= 8; - } - else - { - buff2 = (buff2 | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - if (ready_bits > 0) - { - buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits))); - *dst++ = buff1; - } - - return (0); - } /* end rotateContigSamples8bits */ - - -static int -rotateContigSamples16bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width, - uint32 length, uint32 col, uint8 *src, uint8 *dst) - { - int ready_bits = 0; - uint32 row, rowsize, bit_offset; - uint32 src_byte = 0, src_bit = 0; - uint16 matchbits = 0, maskbits = 0; - uint16 buff1 = 0, buff2 = 0; - uint8 bytebuff = 0; - uint8 *next; - tsample_t sample; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("rotateContigSamples16bits","Invalid src or destination buffer"); - return (1); - } - - rowsize = ((bps * spp * width) + 7) / 8; - ready_bits = 0; - maskbits = (uint16)-1 >> (16 - bps); - buff1 = buff2 = 0; - for (row = 0; row < length; row++) - { - bit_offset = col * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - src_bit = (bit_offset + (sample * bps)) % 8; - } - - switch (rotation) - { - case 90: next = src + src_byte - (row * rowsize); - break; - case 270: next = src + src_byte + (row * rowsize); - break; - default: TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation); - return (1); - } - matchbits = maskbits << (16 - src_bit - bps); - if (little_endian) - buff1 = (next[0] << 8) | next[1]; - else - buff1 = (next[1] << 8) | next[0]; - - buff1 = (buff1 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 8) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - /* shift in new bits */ - buff2 = ((buff2 << 8) | (buff1 >> ready_bits)); - } - else - { /* add another bps bits to the buffer */ - bytebuff = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - if (ready_bits > 0) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - } - - return (0); - } /* end rotateContigSamples16bits */ - -static int -rotateContigSamples24bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width, - uint32 length, uint32 col, uint8 *src, uint8 *dst) - { - int ready_bits = 0; - uint32 row, rowsize, bit_offset; - uint32 src_byte = 0, src_bit = 0; - uint32 matchbits = 0, maskbits = 0; - uint32 buff1 = 0, buff2 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0; - uint8 *next; - tsample_t sample; - - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("rotateContigSamples24bits","Invalid src or destination buffer"); - return (1); - } - - rowsize = ((bps * spp * width) + 7) / 8; - ready_bits = 0; - maskbits = (uint32)-1 >> (32 - bps); - buff1 = buff2 = 0; - for (row = 0; row < length; row++) - { - bit_offset = col * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - src_bit = (bit_offset + (sample * bps)) % 8; - } - - switch (rotation) - { - case 90: next = src + src_byte - (row * rowsize); - break; - case 270: next = src + src_byte + (row * rowsize); - break; - default: TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation); - return (1); - } - matchbits = maskbits << (32 - src_bit - bps); - if (little_endian) - buff1 = (next[0] << 24) | (next[1] << 16) | (next[2] << 8) | next[3]; - else - buff1 = (next[3] << 24) | (next[2] << 16) | (next[1] << 8) | next[0]; - buff1 = (buff1 & matchbits) << (src_bit); - - /* If we have a full buffer's worth, write it out */ - if (ready_bits >= 16) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 16); - *dst++ = bytebuff2; - ready_bits -= 16; - - /* shift in new bits */ - buff2 = ((buff2 << 16) | (buff1 >> ready_bits)); - } - else - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - - buff2 = (buff2 << 8); - bytebuff2 = bytebuff1; - ready_bits -= 8; - } - - return (0); - } /* end rotateContigSamples24bits */ - -static int -rotateContigSamples32bits(uint16 rotation, uint16 spp, uint16 bps, uint32 width, - uint32 length, uint32 col, uint8 *src, uint8 *dst) - { - int ready_bits = 0 /*, shift_width = 0 */; - /* int bytes_per_sample, bytes_per_pixel; */ - uint32 row, rowsize, bit_offset; - uint32 src_byte, src_bit; - uint32 longbuff1 = 0, longbuff2 = 0; - uint64 maskbits = 0, matchbits = 0; - uint64 buff1 = 0, buff2 = 0, buff3 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0; - uint8 *next; - tsample_t sample; - - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("rotateContigSamples24bits","Invalid src or destination buffer"); - return (1); - } - - /* bytes_per_sample = (bps + 7) / 8; */ - /* bytes_per_pixel = ((bps * spp) + 7) / 8; */ - /* if (bytes_per_pixel < (bytes_per_sample + 1)) */ - /* shift_width = bytes_per_pixel; */ - /* else */ - /* shift_width = bytes_per_sample + 1; */ - - rowsize = ((bps * spp * width) + 7) / 8; - ready_bits = 0; - maskbits = (uint64)-1 >> (64 - bps); - buff1 = buff2 = 0; - for (row = 0; row < length; row++) - { - bit_offset = col * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - src_bit = (bit_offset + (sample * bps)) % 8; - } - - switch (rotation) - { - case 90: next = src + src_byte - (row * rowsize); - break; - case 270: next = src + src_byte + (row * rowsize); - break; - default: TIFFError("rotateContigSamples8bits", "Invalid rotation %d", rotation); - return (1); - } - matchbits = maskbits << (64 - src_bit - bps); - if (little_endian) - { - longbuff1 = (next[0] << 24) | (next[1] << 16) | (next[2] << 8) | next[3]; - longbuff2 = longbuff1; - } - else - { - longbuff1 = (next[3] << 24) | (next[2] << 16) | (next[1] << 8) | next[0]; - longbuff2 = longbuff1; - } - - buff3 = ((uint64)longbuff1 << 32) | longbuff2; - buff1 = (buff3 & matchbits) << (src_bit); - - if (ready_bits < 32) - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 48); - *dst++ = bytebuff2; - bytebuff3 = (buff2 >> 40); - *dst++ = bytebuff3; - bytebuff4 = (buff2 >> 32); - *dst++ = bytebuff4; - ready_bits -= 32; - - /* shift in new bits */ - buff2 = ((buff2 << 32) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - buff2 = (buff2 << 8); - ready_bits -= 8; - } - - return (0); - } /* end rotateContigSamples32bits */ - - -/* Rotate an image by a multiple of 90 degrees clockwise */ -static int -rotateImage(uint16 rotation, struct image_data *image, uint32 *img_width, - uint32 *img_length, unsigned char **ibuff_ptr) - { - int shift_width; - uint32 bytes_per_pixel, bytes_per_sample; - uint32 row, rowsize, src_offset, dst_offset; - uint32 i, col, width, length; - uint32 colsize, buffsize, col_offset, pix_offset; - unsigned char *ibuff; - unsigned char *src; - unsigned char *dst; - uint16 spp, bps; - float res_temp; - unsigned char *rbuff = NULL; - - width = *img_width; - length = *img_length; - spp = image->spp; - bps = image->bps; - - rowsize = ((bps * spp * width) + 7) / 8; - colsize = ((bps * spp * length) + 7) / 8; - if ((colsize * width) > (rowsize * length)) - buffsize = (colsize + 1) * width; - else - buffsize = (rowsize + 1) * length; - - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - - switch (rotation) - { - case 0: - case 360: return (0); - case 90: - case 180: - case 270: break; - default: TIFFError("rotateImage", "Invalid rotation angle %d", rotation); - return (-1); - } - - if (!(rbuff = (unsigned char *)_TIFFmalloc(buffsize))) - { - TIFFError("rotateImage", "Unable to allocate rotation buffer of %1u bytes", buffsize); - return (-1); - } - _TIFFmemset(rbuff, '\0', buffsize); - - ibuff = *ibuff_ptr; - switch (rotation) - { - case 180: if ((bps % 8) == 0) /* byte alligned data */ - { - src = ibuff; - pix_offset = (spp * bps) / 8; - for (row = 0; row < length; row++) - { - dst_offset = (length - row - 1) * rowsize; - for (col = 0; col < width; col++) - { - col_offset = (width - col - 1) * pix_offset; - dst = rbuff + dst_offset + col_offset; - - for (i = 0; i < bytes_per_pixel; i++) - *dst++ = *src++; - } - } - } - else - { /* non 8 bit per sample data */ - for (row = 0; row < length; row++) - { - src_offset = row * rowsize; - dst_offset = (length - row - 1) * rowsize; - src = ibuff + src_offset; - dst = rbuff + dst_offset; - switch (shift_width) - { - case 1: if (bps == 1) - { - if (reverseSamples8bits(spp, bps, width, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - } - if (reverseSamples16bits(spp, bps, width, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - case 2: if (reverseSamples24bits(spp, bps, width, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - case 3: - case 4: - case 5: if (reverseSamples32bits(spp, bps, width, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - default: TIFFError("rotateImage","Unsupported bit depth %d", bps); - _TIFFfree(rbuff); - return (-1); - } - } - } - _TIFFfree(ibuff); - *(ibuff_ptr) = rbuff; - break; - - case 90: if ((bps % 8) == 0) /* byte aligned data */ - { - for (col = 0; col < width; col++) - { - src_offset = ((length - 1) * rowsize) + (col * bytes_per_pixel); - dst_offset = col * colsize; - src = ibuff + src_offset; - dst = rbuff + dst_offset; - for (row = length; row > 0; row--) - { - for (i = 0; i < bytes_per_pixel; i++) - *dst++ = *(src + i); - src -= rowsize; - } - } - } - else - { /* non 8 bit per sample data */ - for (col = 0; col < width; col++) - { - src_offset = (length - 1) * rowsize; - dst_offset = col * colsize; - src = ibuff + src_offset; - dst = rbuff + dst_offset; - switch (shift_width) - { - case 1: if (bps == 1) - { - if (rotateContigSamples8bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - } - if (rotateContigSamples16bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - case 2: if (rotateContigSamples24bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - case 3: - case 4: - case 5: if (rotateContigSamples32bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - default: TIFFError("rotateImage","Unsupported bit depth %d", bps); - _TIFFfree(rbuff); - return (-1); - } - } - } - _TIFFfree(ibuff); - *(ibuff_ptr) = rbuff; - - *img_width = length; - *img_length = width; - image->width = length; - image->length = width; - res_temp = image->xres; - image->xres = image->yres; - image->yres = res_temp; - break; - - case 270: if ((bps % 8) == 0) /* byte aligned data */ - { - for (col = 0; col < width; col++) - { - src_offset = col * bytes_per_pixel; - dst_offset = (width - col - 1) * colsize; - src = ibuff + src_offset; - dst = rbuff + dst_offset; - for (row = length; row > 0; row--) - { - for (i = 0; i < bytes_per_pixel; i++) - *dst++ = *(src + i); - src += rowsize; - } - } - } - else - { /* non 8 bit per sample data */ - for (col = 0; col < width; col++) - { - src_offset = 0; - dst_offset = (width - col - 1) * colsize; - src = ibuff + src_offset; - dst = rbuff + dst_offset; - switch (shift_width) - { - case 1: if (bps == 1) - { - if (rotateContigSamples8bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - } - if (rotateContigSamples16bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - case 2: if (rotateContigSamples24bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - case 3: - case 4: - case 5: if (rotateContigSamples32bits(rotation, spp, bps, width, - length, col, src, dst)) - { - _TIFFfree(rbuff); - return (-1); - } - break; - default: TIFFError("rotateImage","Unsupported bit depth %d", bps); - _TIFFfree(rbuff); - return (-1); - } - } - } - _TIFFfree(ibuff); - *(ibuff_ptr) = rbuff; - - *img_width = length; - *img_length = width; - image->width = length; - image->length = width; - res_temp = image->xres; - image->xres = image->yres; - image->yres = res_temp; - break; - default: - break; - } - - return (0); - } /* end rotateImage */ - -static int -reverseSamples8bits (uint16 spp, uint16 bps, uint32 width, - uint8 *ibuff, uint8 *obuff) - { - int ready_bits = 0; - uint32 col; - uint32 src_byte, src_bit; - uint32 bit_offset = 0; - uint8 match_bits = 0, mask_bits = 0; - uint8 buff1 = 0, buff2 = 0; - unsigned char *src; - unsigned char *dst; - tsample_t sample; - - if ((ibuff == NULL) || (obuff == NULL)) - { - TIFFError("reverseSamples8bits","Invalid image or work buffer"); - return (1); - } - - ready_bits = 0; - mask_bits = (uint8)-1 >> ( 8 - bps); - dst = obuff; - for (col = width; col > 0; col--) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = (col - 1) * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - src_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - src_bit = (bit_offset + (sample * bps)) % 8; - } - - src = ibuff + src_byte; - match_bits = mask_bits << (8 - src_bit - bps); - buff1 = ((*src) & match_bits) << (src_bit); - - if (ready_bits < 8) - buff2 = (buff2 | (buff1 >> ready_bits)); - else /* If we have a full buffer's worth, write it out */ - { - *dst++ = buff2; - buff2 = buff1; - ready_bits -= 8; - } - ready_bits += bps; - } - } - if (ready_bits > 0) - { - buff1 = (buff2 & ((unsigned int)255 << (8 - ready_bits))); - *dst++ = buff1; - } - - return (0); - } /* end reverseSamples8bits */ - - -static int -reverseSamples16bits (uint16 spp, uint16 bps, uint32 width, - uint8 *ibuff, uint8 *obuff) - { - int ready_bits = 0; - uint32 col; - uint32 src_byte = 0, high_bit = 0; - uint32 bit_offset = 0; - uint16 match_bits = 0, mask_bits = 0; - uint16 buff1 = 0, buff2 = 0; - uint8 bytebuff = 0; - unsigned char *src; - unsigned char *dst; - tsample_t sample; - - if ((ibuff == NULL) || (obuff == NULL)) - { - TIFFError("reverseSample16bits","Invalid image or work buffer"); - return (1); - } - - ready_bits = 0; - mask_bits = (uint16)-1 >> (16 - bps); - dst = obuff; - for (col = width; col > 0; col--) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = (col - 1) * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - high_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - high_bit = (bit_offset + (sample * bps)) % 8; - } - - src = ibuff + src_byte; - match_bits = mask_bits << (16 - high_bit - bps); - if (little_endian) - buff1 = (src[0] << 8) | src[1]; - else - buff1 = (src[1] << 8) | src[0]; - buff1 = (buff1 & match_bits) << (high_bit); - - if (ready_bits < 8) - { /* add another bps bits to the buffer */ - bytebuff = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - ready_bits -= 8; - /* shift in new bits */ - buff2 = ((buff2 << 8) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - if (ready_bits > 0) - { - bytebuff = (buff2 >> 8); - *dst++ = bytebuff; - } - - return (0); - } /* end reverseSamples16bits */ - -static int -reverseSamples24bits (uint16 spp, uint16 bps, uint32 width, - uint8 *ibuff, uint8 *obuff) - { - int ready_bits = 0; - uint32 col; - uint32 src_byte = 0, high_bit = 0; - uint32 bit_offset = 0; - uint32 match_bits = 0, mask_bits = 0; - uint32 buff1 = 0, buff2 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0; - unsigned char *src; - unsigned char *dst; - tsample_t sample; - - if ((ibuff == NULL) || (obuff == NULL)) - { - TIFFError("reverseSamples24bits","Invalid image or work buffer"); - return (1); - } - - ready_bits = 0; - mask_bits = (uint32)-1 >> (32 - bps); - dst = obuff; - for (col = width; col > 0; col--) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = (col - 1) * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - high_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - high_bit = (bit_offset + (sample * bps)) % 8; - } - - src = ibuff + src_byte; - match_bits = mask_bits << (32 - high_bit - bps); - if (little_endian) - buff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - else - buff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - buff1 = (buff1 & match_bits) << (high_bit); - - if (ready_bits < 16) - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 16); - *dst++ = bytebuff2; - ready_bits -= 16; - - /* shift in new bits */ - buff2 = ((buff2 << 16) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - - /* catch any trailing bits at the end of the line */ - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 24); - *dst++ = bytebuff1; - - buff2 = (buff2 << 8); - bytebuff2 = bytebuff1; - ready_bits -= 8; - } - - return (0); - } /* end reverseSamples24bits */ - - -static int -reverseSamples32bits (uint16 spp, uint16 bps, uint32 width, - uint8 *ibuff, uint8 *obuff) - { - int ready_bits = 0 /*, shift_width = 0 */; - /* int bytes_per_sample, bytes_per_pixel; */ - uint32 bit_offset; - uint32 src_byte = 0, high_bit = 0; - uint32 col; - uint32 longbuff1 = 0, longbuff2 = 0; - uint64 mask_bits = 0, match_bits = 0; - uint64 buff1 = 0, buff2 = 0, buff3 = 0; - uint8 bytebuff1 = 0, bytebuff2 = 0, bytebuff3 = 0, bytebuff4 = 0; - unsigned char *src; - unsigned char *dst; - tsample_t sample; - - if ((ibuff == NULL) || (obuff == NULL)) - { - TIFFError("reverseSamples32bits","Invalid image or work buffer"); - return (1); - } - - ready_bits = 0; - mask_bits = (uint64)-1 >> (64 - bps); - dst = obuff; - - /* bytes_per_sample = (bps + 7) / 8; */ - /* bytes_per_pixel = ((bps * spp) + 7) / 8; */ - /* if (bytes_per_pixel < (bytes_per_sample + 1)) */ - /* shift_width = bytes_per_pixel; */ - /* else */ - /* shift_width = bytes_per_sample + 1; */ - - for (col = width; col > 0; col--) - { - /* Compute src byte(s) and bits within byte(s) */ - bit_offset = (col - 1) * bps * spp; - for (sample = 0; sample < spp; sample++) - { - if (sample == 0) - { - src_byte = bit_offset / 8; - high_bit = bit_offset % 8; - } - else - { - src_byte = (bit_offset + (sample * bps)) / 8; - high_bit = (bit_offset + (sample * bps)) % 8; - } - - src = ibuff + src_byte; - match_bits = mask_bits << (64 - high_bit - bps); - if (little_endian) - { - longbuff1 = (src[0] << 24) | (src[1] << 16) | (src[2] << 8) | src[3]; - longbuff2 = longbuff1; - } - else - { - longbuff1 = (src[3] << 24) | (src[2] << 16) | (src[1] << 8) | src[0]; - longbuff2 = longbuff1; - } - buff3 = ((uint64)longbuff1 << 32) | longbuff2; - buff1 = (buff3 & match_bits) << (high_bit); - - if (ready_bits < 32) - { /* add another bps bits to the buffer */ - bytebuff1 = bytebuff2 = bytebuff3 = bytebuff4 = 0; - buff2 = (buff2 | (buff1 >> ready_bits)); - } - else /* If we have a full buffer's worth, write it out */ - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - bytebuff2 = (buff2 >> 48); - *dst++ = bytebuff2; - bytebuff3 = (buff2 >> 40); - *dst++ = bytebuff3; - bytebuff4 = (buff2 >> 32); - *dst++ = bytebuff4; - ready_bits -= 32; - - /* shift in new bits */ - buff2 = ((buff2 << 32) | (buff1 >> ready_bits)); - } - ready_bits += bps; - } - } - while (ready_bits > 0) - { - bytebuff1 = (buff2 >> 56); - *dst++ = bytebuff1; - buff2 = (buff2 << 8); - ready_bits -= 8; - } - - return (0); - } /* end reverseSamples32bits */ - -static int -reverseSamplesBytes (uint16 spp, uint16 bps, uint32 width, - uint8 *src, uint8 *dst) - { - int i; - uint32 col, bytes_per_pixel, col_offset; - uint8 bytebuff1; - unsigned char swapbuff[32]; - - if ((src == NULL) || (dst == NULL)) - { - TIFFError("reverseSamplesBytes","Invalid input or output buffer"); - return (1); - } - - bytes_per_pixel = ((bps * spp) + 7) / 8; - switch (bps / 8) - { - case 8: /* Use memcpy for multiple bytes per sample data */ - case 4: - case 3: - case 2: for (col = 0; col < (width / 2); col++) - { - col_offset = col * bytes_per_pixel; - _TIFFmemcpy (swapbuff, src + col_offset, bytes_per_pixel); - _TIFFmemcpy (src + col_offset, dst - col_offset - bytes_per_pixel, bytes_per_pixel); - _TIFFmemcpy (dst - col_offset - bytes_per_pixel, swapbuff, bytes_per_pixel); - } - break; - case 1: /* Use byte copy only for single byte per sample data */ - for (col = 0; col < (width / 2); col++) - { - for (i = 0; i < spp; i++) - { - bytebuff1 = *src; - *src++ = *(dst - spp + i); - *(dst - spp + i) = bytebuff1; - } - dst -= spp; - } - break; - default: TIFFError("reverseSamplesBytes","Unsupported bit depth %d", bps); - return (1); - } - return (0); - } /* end reverseSamplesBytes */ - - -/* Mirror an image horizontally or vertically */ -static int -mirrorImage(uint16 spp, uint16 bps, uint16 mirror, uint32 width, uint32 length, unsigned char *ibuff) - { - int shift_width; - uint32 bytes_per_pixel, bytes_per_sample; - uint32 row, rowsize, row_offset; - unsigned char *line_buff = NULL; - unsigned char *src; - unsigned char *dst; - - src = ibuff; - rowsize = ((width * bps * spp) + 7) / 8; - switch (mirror) - { - case MIRROR_BOTH: - case MIRROR_VERT: - line_buff = (unsigned char *)_TIFFmalloc(rowsize); - if (line_buff == NULL) - { - TIFFError ("mirrorImage", "Unable to allocate mirror line buffer of %1u bytes", rowsize); - return (-1); - } - - dst = ibuff + (rowsize * (length - 1)); - for (row = 0; row < length / 2; row++) - { - _TIFFmemcpy(line_buff, src, rowsize); - _TIFFmemcpy(src, dst, rowsize); - _TIFFmemcpy(dst, line_buff, rowsize); - src += (rowsize); - dst -= (rowsize); - } - if (line_buff) - _TIFFfree(line_buff); - if (mirror == MIRROR_VERT) - break; - case MIRROR_HORIZ : - if ((bps % 8) == 0) /* byte alligned data */ - { - for (row = 0; row < length; row++) - { - row_offset = row * rowsize; - src = ibuff + row_offset; - dst = ibuff + row_offset + rowsize; - if (reverseSamplesBytes(spp, bps, width, src, dst)) - { - return (-1); - } - } - } - else - { /* non 8 bit per sample data */ - if (!(line_buff = (unsigned char *)_TIFFmalloc(rowsize + 1))) - { - TIFFError("mirrorImage", "Unable to allocate mirror line buffer"); - return (-1); - } - bytes_per_sample = (bps + 7) / 8; - bytes_per_pixel = ((bps * spp) + 7) / 8; - if (bytes_per_pixel < (bytes_per_sample + 1)) - shift_width = bytes_per_pixel; - else - shift_width = bytes_per_sample + 1; - - for (row = 0; row < length; row++) - { - row_offset = row * rowsize; - src = ibuff + row_offset; - _TIFFmemset (line_buff, '\0', rowsize); - switch (shift_width) - { - case 1: if (reverseSamples16bits(spp, bps, width, src, line_buff)) - { - _TIFFfree(line_buff); - return (-1); - } - _TIFFmemcpy (src, line_buff, rowsize); - break; - case 2: if (reverseSamples24bits(spp, bps, width, src, line_buff)) - { - _TIFFfree(line_buff); - return (-1); - } - _TIFFmemcpy (src, line_buff, rowsize); - break; - case 3: - case 4: - case 5: if (reverseSamples32bits(spp, bps, width, src, line_buff)) - { - _TIFFfree(line_buff); - return (-1); - } - _TIFFmemcpy (src, line_buff, rowsize); - break; - default: TIFFError("mirrorImage","Unsupported bit depth %d", bps); - _TIFFfree(line_buff); - return (-1); - } - } - if (line_buff) - _TIFFfree(line_buff); - } - break; - - default: TIFFError ("mirrorImage", "Invalid mirror axis %d", mirror); - return (-1); - break; - } - - return (0); - } - -/* Invert the light and dark values for a bilevel or grayscale image */ -static int -invertImage(uint16 photometric, uint16 spp, uint16 bps, uint32 width, uint32 length, unsigned char *work_buff) - { - uint32 row, col; - unsigned char bytebuff1, bytebuff2, bytebuff3, bytebuff4; - unsigned char *src; - uint16 *src_uint16; - uint32 *src_uint32; - - if (spp != 1) - { - TIFFError("invertImage", "Image inversion not supported for more than one sample per pixel"); - return (-1); - } - - if (photometric != PHOTOMETRIC_MINISWHITE && photometric != PHOTOMETRIC_MINISBLACK) - { - TIFFError("invertImage", "Only black and white and grayscale images can be inverted"); - return (-1); - } - - src = work_buff; - if (src == NULL) - { - TIFFError ("invertImage", "Invalid crop buffer passed to invertImage"); - return (-1); - } - - switch (bps) - { - case 32: src_uint32 = (uint32 *)src; - for (row = 0; row < length; row++) - for (col = 0; col < width; col++) - { - *src_uint32 = (uint32)0xFFFFFFFF - *src_uint32; - src_uint32++; - } - break; - case 16: src_uint16 = (uint16 *)src; - for (row = 0; row < length; row++) - for (col = 0; col < width; col++) - { - *src_uint16 = (uint16)0xFFFF - *src_uint16; - src_uint16++; - } - break; - case 8: for (row = 0; row < length; row++) - for (col = 0; col < width; col++) - { - *src = (uint8)255 - *src; - src++; - } - break; - case 4: for (row = 0; row < length; row++) - for (col = 0; col < width; col++) - { - bytebuff1 = 16 - (uint8)(*src & 240 >> 4); - bytebuff2 = 16 - (*src & 15); - *src = bytebuff1 << 4 & bytebuff2; - src++; - } - break; - case 2: for (row = 0; row < length; row++) - for (col = 0; col < width; col++) - { - bytebuff1 = 4 - (uint8)(*src & 192 >> 6); - bytebuff2 = 4 - (uint8)(*src & 48 >> 4); - bytebuff3 = 4 - (uint8)(*src & 12 >> 2); - bytebuff4 = 4 - (uint8)(*src & 3); - *src = (bytebuff1 << 6) || (bytebuff2 << 4) || (bytebuff3 << 2) || bytebuff4; - src++; - } - break; - case 1: for (row = 0; row < length; row++) - for (col = 0; col < width; col += 8 /(spp * bps)) - { - *src = ~(*src); - src++; - } - break; - default: TIFFError("invertImage", "Unsupported bit depth %d", bps); - return (-1); - } - - return (0); - } - -/* vim: set ts=8 sts=8 sw=8 noet: */ -/* - * Local Variables: - * mode: c - * c-basic-offset: 8 - * fill-column: 78 - * End: - */ -- cgit v1.2.3