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