summaryrefslogtreecommitdiff
path: root/tiff/tools/thumbnail.c
diff options
context:
space:
mode:
Diffstat (limited to 'tiff/tools/thumbnail.c')
-rwxr-xr-xtiff/tools/thumbnail.c689
1 files changed, 689 insertions, 0 deletions
diff --git a/tiff/tools/thumbnail.c b/tiff/tools/thumbnail.c
new file mode 100755
index 0000000..2699324
--- /dev/null
+++ b/tiff/tools/thumbnail.c
@@ -0,0 +1,689 @@
+/* $Id: thumbnail.c,v 1.20 2014-12-21 20:04:31 erouault Exp $ */
+
+/*
+ * Copyright (c) 1994-1997 Sam Leffler
+ * Copyright (c) 1994-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffio.h"
+
+#ifndef HAVE_GETOPT
+extern int getopt(int, char**, char*);
+#endif
+
+#define streq(a,b) (strcmp(a,b) == 0)
+
+#ifndef TIFFhowmany8
+# define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
+#endif
+
+typedef enum {
+ EXP50,
+ EXP60,
+ EXP70,
+ EXP80,
+ EXP90,
+ EXP,
+ LINEAR
+} Contrast;
+
+static uint32 tnw = 216; /* thumbnail width */
+static uint32 tnh = 274; /* thumbnail height */
+static Contrast contrast = LINEAR; /* current contrast */
+static uint8* thumbnail;
+
+static int cpIFD(TIFF*, TIFF*);
+static int generateThumbnail(TIFF*, TIFF*);
+static void initScale();
+static void usage(void);
+
+extern char* optarg;
+extern int optind;
+
+int
+main(int argc, char* argv[])
+{
+ TIFF* in;
+ TIFF* out;
+ int c;
+
+ while ((c = getopt(argc, argv, "w:h:c:")) != -1) {
+ switch (c) {
+ case 'w': tnw = strtoul(optarg, NULL, 0); break;
+ case 'h': tnh = strtoul(optarg, NULL, 0); break;
+ case 'c': contrast = streq(optarg, "exp50") ? EXP50 :
+ streq(optarg, "exp60") ? EXP60 :
+ streq(optarg, "exp70") ? EXP70 :
+ streq(optarg, "exp80") ? EXP80 :
+ streq(optarg, "exp90") ? EXP90 :
+ streq(optarg, "exp") ? EXP :
+ streq(optarg, "linear")? LINEAR :
+ EXP;
+ break;
+ default: usage();
+ }
+ }
+ if (argc-optind != 2)
+ usage();
+
+ out = TIFFOpen(argv[optind+1], "w");
+ if (out == NULL)
+ return 2;
+ in = TIFFOpen(argv[optind], "r");
+ if( in == NULL )
+ return 2;
+
+ thumbnail = (uint8*) _TIFFmalloc(tnw * tnh);
+ if (!thumbnail) {
+ TIFFError(TIFFFileName(in),
+ "Can't allocate space for thumbnail buffer.");
+ return 1;
+ }
+
+ if (in != NULL) {
+ initScale();
+ do {
+ if (!generateThumbnail(in, out))
+ goto bad;
+ if (!cpIFD(in, out) || !TIFFWriteDirectory(out))
+ goto bad;
+ } while (TIFFReadDirectory(in));
+ (void) TIFFClose(in);
+ }
+ (void) TIFFClose(out);
+ return 0;
+bad:
+ (void) TIFFClose(out);
+ return 1;
+}
+
+#define CopyField(tag, v) \
+ if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define CopyField2(tag, v1, v2) \
+ if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
+#define CopyField3(tag, v1, v2, v3) \
+ if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+#define CopyField4(tag, v1, v2, v3, v4) \
+ if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
+
+static void
+cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
+{
+ switch (type) {
+ case TIFF_SHORT:
+ if (count == 1) {
+ uint16 shortv;
+ CopyField(tag, shortv);
+ } else if (count == 2) {
+ uint16 shortv1, shortv2;
+ CopyField2(tag, shortv1, shortv2);
+ } else if (count == 4) {
+ uint16 *tr, *tg, *tb, *ta;
+ CopyField4(tag, tr, tg, tb, ta);
+ } else if (count == (uint16) -1) {
+ uint16 shortv1;
+ uint16* shortav;
+ CopyField2(tag, shortv1, shortav);
+ }
+ break;
+ case TIFF_LONG:
+ { uint32 longv;
+ CopyField(tag, longv);
+ }
+ break;
+ case TIFF_LONG8:
+ { uint64 longv8;
+ CopyField(tag, longv8);
+ }
+ break;
+ case TIFF_SLONG8:
+ { int64 longv8;
+ CopyField(tag, longv8);
+ }
+ break;
+ case TIFF_RATIONAL:
+ if (count == 1) {
+ float floatv;
+ CopyField(tag, floatv);
+ } else if (count == (uint16) -1) {
+ float* floatav;
+ CopyField(tag, floatav);
+ }
+ break;
+ case TIFF_ASCII:
+ { char* stringv;
+ CopyField(tag, stringv);
+ }
+ break;
+ case TIFF_DOUBLE:
+ if (count == 1) {
+ double doublev;
+ CopyField(tag, doublev);
+ } else if (count == (uint16) -1) {
+ double* doubleav;
+ CopyField(tag, doubleav);
+ }
+ break;
+ case TIFF_IFD8:
+ { toff_t ifd8;
+ CopyField(tag, ifd8);
+ }
+ break; default:
+ TIFFError(TIFFFileName(in),
+ "Data type %d is not supported, tag %d skipped.",
+ tag, type);
+ }
+}
+
+#undef CopyField4
+#undef CopyField3
+#undef CopyField2
+#undef CopyField
+
+static struct cpTag {
+ uint16 tag;
+ uint16 count;
+ TIFFDataType type;
+} tags[] = {
+ { TIFFTAG_IMAGEWIDTH, 1, TIFF_LONG },
+ { TIFFTAG_IMAGELENGTH, 1, TIFF_LONG },
+ { TIFFTAG_BITSPERSAMPLE, 1, TIFF_SHORT },
+ { TIFFTAG_COMPRESSION, 1, TIFF_SHORT },
+ { TIFFTAG_FILLORDER, 1, TIFF_SHORT },
+ { TIFFTAG_SAMPLESPERPIXEL, 1, TIFF_SHORT },
+ { TIFFTAG_ROWSPERSTRIP, 1, TIFF_LONG },
+ { TIFFTAG_PLANARCONFIG, 1, TIFF_SHORT },
+ { TIFFTAG_GROUP3OPTIONS, 1, TIFF_LONG },
+ { TIFFTAG_SUBFILETYPE, 1, TIFF_LONG },
+ { TIFFTAG_PHOTOMETRIC, 1, TIFF_SHORT },
+ { TIFFTAG_THRESHHOLDING, 1, TIFF_SHORT },
+ { TIFFTAG_DOCUMENTNAME, 1, TIFF_ASCII },
+ { TIFFTAG_IMAGEDESCRIPTION, 1, TIFF_ASCII },
+ { TIFFTAG_MAKE, 1, TIFF_ASCII },
+ { TIFFTAG_MODEL, 1, TIFF_ASCII },
+ { TIFFTAG_ORIENTATION, 1, TIFF_SHORT },
+ { TIFFTAG_MINSAMPLEVALUE, 1, TIFF_SHORT },
+ { TIFFTAG_MAXSAMPLEVALUE, 1, TIFF_SHORT },
+ { TIFFTAG_XRESOLUTION, 1, TIFF_RATIONAL },
+ { TIFFTAG_YRESOLUTION, 1, TIFF_RATIONAL },
+ { TIFFTAG_PAGENAME, 1, TIFF_ASCII },
+ { TIFFTAG_XPOSITION, 1, TIFF_RATIONAL },
+ { TIFFTAG_YPOSITION, 1, TIFF_RATIONAL },
+ { TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG },
+ { TIFFTAG_RESOLUTIONUNIT, 1, TIFF_SHORT },
+ { TIFFTAG_PAGENUMBER, 2, TIFF_SHORT },
+ { TIFFTAG_SOFTWARE, 1, TIFF_ASCII },
+ { TIFFTAG_DATETIME, 1, TIFF_ASCII },
+ { TIFFTAG_ARTIST, 1, TIFF_ASCII },
+ { TIFFTAG_HOSTCOMPUTER, 1, TIFF_ASCII },
+ { TIFFTAG_WHITEPOINT, 2, TIFF_RATIONAL },
+ { TIFFTAG_PRIMARYCHROMATICITIES, (uint16) -1,TIFF_RATIONAL },
+ { TIFFTAG_HALFTONEHINTS, 2, TIFF_SHORT },
+ { TIFFTAG_BADFAXLINES, 1, TIFF_LONG },
+ { TIFFTAG_CLEANFAXDATA, 1, TIFF_SHORT },
+ { TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG },
+ { TIFFTAG_INKSET, 1, TIFF_SHORT },
+ /*{ TIFFTAG_INKNAMES, 1, TIFF_ASCII },*/ /* Needs much more complicated logic. See tiffcp */
+ { TIFFTAG_DOTRANGE, 2, TIFF_SHORT },
+ { TIFFTAG_TARGETPRINTER, 1, TIFF_ASCII },
+ { TIFFTAG_SAMPLEFORMAT, 1, TIFF_SHORT },
+ { TIFFTAG_YCBCRCOEFFICIENTS, (uint16) -1,TIFF_RATIONAL },
+ { TIFFTAG_YCBCRSUBSAMPLING, 2, TIFF_SHORT },
+ { TIFFTAG_YCBCRPOSITIONING, 1, TIFF_SHORT },
+ { TIFFTAG_REFERENCEBLACKWHITE, (uint16) -1,TIFF_RATIONAL },
+ { TIFFTAG_EXTRASAMPLES, (uint16) -1, TIFF_SHORT },
+};
+#define NTAGS (sizeof (tags) / sizeof (tags[0]))
+
+static void
+cpTags(TIFF* in, TIFF* out)
+{
+ struct cpTag *p;
+ for (p = tags; p < &tags[NTAGS]; p++)
+ {
+ /* Horrible: but TIFFGetField() expects 2 arguments to be passed */
+ /* if we request a tag that is defined in a codec, but that codec */
+ /* isn't used */
+ if( p->tag == TIFFTAG_GROUP3OPTIONS )
+ {
+ uint16 compression;
+ if( !TIFFGetField(in, TIFFTAG_COMPRESSION, &compression) ||
+ compression != COMPRESSION_CCITTFAX3 )
+ continue;
+ }
+ if( p->tag == TIFFTAG_GROUP4OPTIONS )
+ {
+ uint16 compression;
+ if( !TIFFGetField(in, TIFFTAG_COMPRESSION, &compression) ||
+ compression != COMPRESSION_CCITTFAX4 )
+ continue;
+ }
+ cpTag(in, out, p->tag, p->count, p->type);
+ }
+}
+#undef NTAGS
+
+static int
+cpStrips(TIFF* in, TIFF* out)
+{
+ tsize_t bufsize = TIFFStripSize(in);
+ unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
+
+ if (buf) {
+ tstrip_t s, ns = TIFFNumberOfStrips(in);
+ uint64 *bytecounts;
+
+ TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts);
+ for (s = 0; s < ns; s++) {
+ if (bytecounts[s] > (uint64) bufsize) {
+ buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[s]);
+ if (!buf)
+ goto bad;
+ bufsize = (tmsize_t)bytecounts[s];
+ }
+ if (TIFFReadRawStrip(in, s, buf, (tmsize_t)bytecounts[s]) < 0 ||
+ TIFFWriteRawStrip(out, s, buf, (tmsize_t)bytecounts[s]) < 0) {
+ _TIFFfree(buf);
+ return 0;
+ }
+ }
+ _TIFFfree(buf);
+ return 1;
+ }
+
+bad:
+ TIFFError(TIFFFileName(in),
+ "Can't allocate space for strip buffer.");
+ return 0;
+}
+
+static int
+cpTiles(TIFF* in, TIFF* out)
+{
+ tsize_t bufsize = TIFFTileSize(in);
+ unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
+
+ if (buf) {
+ ttile_t t, nt = TIFFNumberOfTiles(in);
+ uint64 *bytecounts;
+
+ TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts);
+ for (t = 0; t < nt; t++) {
+ if (bytecounts[t] > (uint64) bufsize) {
+ buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[t]);
+ if (!buf)
+ goto bad;
+ bufsize = (tmsize_t)bytecounts[t];
+ }
+ if (TIFFReadRawTile(in, t, buf, (tmsize_t)bytecounts[t]) < 0 ||
+ TIFFWriteRawTile(out, t, buf, (tmsize_t)bytecounts[t]) < 0) {
+ _TIFFfree(buf);
+ return 0;
+ }
+ }
+ _TIFFfree(buf);
+ return 1;
+ }
+
+bad:
+ TIFFError(TIFFFileName(in),
+ "Can't allocate space for tile buffer.");
+ return (0);
+}
+
+static int
+cpIFD(TIFF* in, TIFF* out)
+{
+ cpTags(in, out);
+ if (TIFFIsTiled(in)) {
+ if (!cpTiles(in, out))
+ return (0);
+ } else {
+ if (!cpStrips(in, out))
+ return (0);
+ }
+ return (1);
+}
+
+static uint16 photometric; /* current photometric of raster */
+static uint16 filterWidth; /* filter width in pixels */
+static uint32 stepSrcWidth; /* src image stepping width */
+static uint32 stepDstWidth; /* dest stepping width */
+static uint8* src0; /* horizontal bit stepping (start) */
+static uint8* src1; /* horizontal bit stepping (middle) */
+static uint8* src2; /* horizontal bit stepping (end) */
+static uint32* rowoff; /* row offset for stepping */
+static uint8 cmap[256]; /* colormap indexes */
+static uint8 bits[256]; /* count of bits set */
+
+static void
+setupBitsTables()
+{
+ int i;
+ for (i = 0; i < 256; i++) {
+ int n = 0;
+ if (i&0x01) n++;
+ if (i&0x02) n++;
+ if (i&0x04) n++;
+ if (i&0x08) n++;
+ if (i&0x10) n++;
+ if (i&0x20) n++;
+ if (i&0x40) n++;
+ if (i&0x80) n++;
+ bits[i] = n;
+ }
+}
+
+static int clamp(float v, int low, int high)
+ { return (v < low ? low : v > high ? high : (int)v); }
+
+#ifndef M_E
+#define M_E 2.7182818284590452354
+#endif
+
+static void
+expFill(float pct[], uint32 p, uint32 n)
+{
+ uint32 i;
+ uint32 c = (p * n) / 100;
+ for (i = 1; i < c; i++)
+ pct[i] = (float) (1-exp(i/((double)(n-1)))/ M_E);
+ for (; i < n; i++)
+ pct[i] = 0.;
+}
+
+static void
+setupCmap()
+{
+ float pct[256]; /* known to be large enough */
+ uint32 i;
+ pct[0] = 1; /* force white */
+ switch (contrast) {
+ case EXP50: expFill(pct, 50, 256); break;
+ case EXP60: expFill(pct, 60, 256); break;
+ case EXP70: expFill(pct, 70, 256); break;
+ case EXP80: expFill(pct, 80, 256); break;
+ case EXP90: expFill(pct, 90, 256); break;
+ case EXP: expFill(pct, 100, 256); break;
+ case LINEAR:
+ for (i = 1; i < 256; i++)
+ pct[i] = 1-((float)i)/(256-1);
+ break;
+ }
+ switch (photometric) {
+ case PHOTOMETRIC_MINISWHITE:
+ for (i = 0; i < 256; i++)
+ cmap[i] = clamp(255*pct[(256-1)-i], 0, 255);
+ break;
+ case PHOTOMETRIC_MINISBLACK:
+ for (i = 0; i < 256; i++)
+ cmap[i] = clamp(255*pct[i], 0, 255);
+ break;
+ }
+}
+
+static void
+initScale()
+{
+ src0 = (uint8*) _TIFFmalloc(sizeof (uint8) * tnw);
+ src1 = (uint8*) _TIFFmalloc(sizeof (uint8) * tnw);
+ src2 = (uint8*) _TIFFmalloc(sizeof (uint8) * tnw);
+ rowoff = (uint32*) _TIFFmalloc(sizeof (uint32) * tnw);
+ filterWidth = 0;
+ stepDstWidth = stepSrcWidth = 0;
+ setupBitsTables();
+}
+
+/*
+ * Calculate the horizontal accumulation parameteres
+ * according to the widths of the src and dst images.
+ */
+static void
+setupStepTables(uint32 sw)
+{
+ if (stepSrcWidth != sw || stepDstWidth != tnw) {
+ int step = sw;
+ int limit = tnw;
+ int err = 0;
+ uint32 sx = 0;
+ uint32 x;
+ int fw;
+ uint8 b;
+ for (x = 0; x < tnw; x++) {
+ uint32 sx0 = sx;
+ err += step;
+ while (err >= limit) {
+ err -= limit;
+ sx++;
+ }
+ rowoff[x] = sx0 >> 3;
+ fw = sx - sx0; /* width */
+ b = (fw < 8) ? 0xff<<(8-fw) : 0xff;
+ src0[x] = b >> (sx0&7);
+ fw -= 8 - (sx0&7);
+ if (fw < 0)
+ fw = 0;
+ src1[x] = fw >> 3;
+ fw -= (fw>>3)<<3;
+ src2[x] = 0xff << (8-fw);
+ }
+ stepSrcWidth = sw;
+ stepDstWidth = tnw;
+ }
+}
+
+static void
+setrow(uint8* row, uint32 nrows, const uint8* rows[])
+{
+ uint32 x;
+ uint32 area = nrows * filterWidth;
+ for (x = 0; x < tnw; x++) {
+ uint32 mask0 = src0[x];
+ uint32 fw = src1[x];
+ uint32 mask1 = src1[x];
+ uint32 off = rowoff[x];
+ uint32 acc = 0;
+ uint32 y, i;
+ for (y = 0; y < nrows; y++) {
+ const uint8* src = rows[y] + off;
+ acc += bits[*src++ & mask0];
+ switch (fw) {
+ default:
+ for (i = fw; i > 8; i--)
+ acc += bits[*src++];
+ /* fall thru... */
+ case 8: acc += bits[*src++];
+ case 7: acc += bits[*src++];
+ case 6: acc += bits[*src++];
+ case 5: acc += bits[*src++];
+ case 4: acc += bits[*src++];
+ case 3: acc += bits[*src++];
+ case 2: acc += bits[*src++];
+ case 1: acc += bits[*src++];
+ case 0: break;
+ }
+ acc += bits[*src & mask1];
+ }
+ *row++ = cmap[(255*acc)/area];
+ }
+}
+
+/*
+ * Install the specified image. The
+ * image is resized to fit the display page using
+ * a box filter. The resultant pixels are mapped
+ * with a user-selectable contrast curve.
+ */
+static void
+setImage1(const uint8* br, uint32 rw, uint32 rh)
+{
+ int step = rh;
+ int limit = tnh;
+ int err = 0;
+ int bpr = TIFFhowmany8(rw);
+ int sy = 0;
+ uint8* row = thumbnail;
+ uint32 dy;
+ for (dy = 0; dy < tnh; dy++) {
+ const uint8* rows[256];
+ uint32 nrows = 1;
+ fprintf(stderr, "bpr=%d, sy=%d, bpr*sy=%d\n", bpr, sy, bpr*sy);
+ rows[0] = br + bpr*sy;
+ err += step;
+ while (err >= limit) {
+ err -= limit;
+ sy++;
+ if (err >= limit)
+ {
+ /* We should perhaps error loudly, but I can't make sense of that */
+ /* code... */
+ if( nrows == 256 )
+ break;
+ rows[nrows++] = br + bpr*sy;
+ }
+ }
+ setrow(row, nrows, rows);
+ row += tnw;
+ }
+}
+
+static void
+setImage(const uint8* br, uint32 rw, uint32 rh)
+{
+ filterWidth = (uint16) ceil((double) rw / (double) tnw);
+ setupStepTables(rw);
+ setImage1(br, rw, rh);
+}
+
+static int
+generateThumbnail(TIFF* in, TIFF* out)
+{
+ unsigned char* raster;
+ unsigned char* rp;
+ uint32 sw, sh, rps;
+ uint16 bps, spp;
+ tsize_t rowsize, rastersize;
+ tstrip_t s, ns = TIFFNumberOfStrips(in);
+ toff_t diroff[1];
+
+ TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &sw);
+ TIFFGetField(in, TIFFTAG_IMAGELENGTH, &sh);
+ TIFFGetFieldDefaulted(in, TIFFTAG_BITSPERSAMPLE, &bps);
+ TIFFGetFieldDefaulted(in, TIFFTAG_SAMPLESPERPIXEL, &spp);
+ TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps);
+ if (spp != 1 || bps != 1)
+ return 0;
+ rowsize = TIFFScanlineSize(in);
+ rastersize = sh * rowsize;
+ fprintf(stderr, "rastersize=%u\n", (unsigned int)rastersize);
+ /* +3 : add a few guard bytes since setrow() can read a bit */
+ /* outside buffer */
+ raster = (unsigned char*)_TIFFmalloc(rastersize+3);
+ if (!raster) {
+ TIFFError(TIFFFileName(in),
+ "Can't allocate space for raster buffer.");
+ return 0;
+ }
+ raster[rastersize] = 0;
+ raster[rastersize+1] = 0;
+ raster[rastersize+2] = 0;
+ rp = raster;
+ for (s = 0; s < ns; s++) {
+ (void) TIFFReadEncodedStrip(in, s, rp, -1);
+ rp += rps * rowsize;
+ }
+ TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &photometric);
+ setupCmap();
+ setImage(raster, sw, sh);
+ _TIFFfree(raster);
+
+ TIFFSetField(out, TIFFTAG_SUBFILETYPE, FILETYPE_REDUCEDIMAGE);
+ TIFFSetField(out, TIFFTAG_IMAGEWIDTH, (uint32) tnw);
+ TIFFSetField(out, TIFFTAG_IMAGELENGTH, (uint32) tnh);
+ TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, (uint16) 8);
+ TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, (uint16) 1);
+ TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
+ TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
+ TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+ TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+ cpTag(in, out, TIFFTAG_SOFTWARE, (uint16) -1, TIFF_ASCII);
+ cpTag(in, out, TIFFTAG_IMAGEDESCRIPTION, (uint16) -1, TIFF_ASCII);
+ cpTag(in, out, TIFFTAG_DATETIME, (uint16) -1, TIFF_ASCII);
+ cpTag(in, out, TIFFTAG_HOSTCOMPUTER, (uint16) -1, TIFF_ASCII);
+ diroff[0] = 0UL;
+ TIFFSetField(out, TIFFTAG_SUBIFD, 1, diroff);
+ return (TIFFWriteEncodedStrip(out, 0, thumbnail, tnw*tnh) != -1 &&
+ TIFFWriteDirectory(out) != -1);
+}
+
+char* stuff[] = {
+"usage: thumbnail [options] input.tif output.tif",
+"where options are:",
+" -h # specify thumbnail image height (default is 274)",
+" -w # specify thumbnail image width (default is 216)",
+"",
+" -c linear use linear contrast curve",
+" -c exp50 use 50% exponential contrast curve",
+" -c exp60 use 60% exponential contrast curve",
+" -c exp70 use 70% exponential contrast curve",
+" -c exp80 use 80% exponential contrast curve",
+" -c exp90 use 90% exponential contrast curve",
+" -c exp use pure exponential contrast curve",
+NULL
+};
+
+static void
+usage(void)
+{
+ char buf[BUFSIZ];
+ int i;
+
+ setbuf(stderr, buf);
+ fprintf(stderr, "%s\n\n", TIFFGetVersion());
+ for (i = 0; stuff[i] != NULL; i++)
+ fprintf(stderr, "%s\n", stuff[i]);
+ exit(-1);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 05:26:20 +0000