src/tiff/tools/thumbnail.c

/* $Id$ */

/*
 * 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 },
    { 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++)
	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)
		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);
    raster = (unsigned char*)_TIFFmalloc(rastersize);
    if (!raster) {
	    TIFFError(TIFFFileName(in),
		      "Can't allocate space for raster buffer.");
	    return 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:
 */
Commit	Line	Data
	1	/* $Id$ */
	2
	3	/*
	4	* Copyright (c) 1994-1997 Sam Leffler
	5	* Copyright (c) 1994-1997 Silicon Graphics, Inc.
	6	*
	7	* Permission to use, copy, modify, distribute, and sell this software and
	8	* its documentation for any purpose is hereby granted without fee, provided
	9	* that (i) the above copyright notices and this permission notice appear in
	10	* all copies of the software and related documentation, and (ii) the names of
	11	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	12	* publicity relating to the software without the specific, prior written
	13	* permission of Sam Leffler and Silicon Graphics.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	16	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	17	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	18	*
	19	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	20	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	21	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	22	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	23	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	24	* OF THIS SOFTWARE.
	25	*/
	26
	27	#include "tif_config.h"
	28
	29	#include <stdio.h>
	30	#include <stdlib.h>
	31	#include <string.h>
	32	#include <math.h>
	33
	34	#ifdef HAVE_UNISTD_H
	35	# include <unistd.h>
	36	#endif
	37
	38	#ifdef NEED_LIBPORT
	39	# include "libport.h"
	40	#endif
	41
	42	#include "tiffio.h"
	43
	44	#ifndef HAVE_GETOPT
	45	extern int getopt(int, char*, char);
	46	#endif
	47
	48	#define streq(a,b) (strcmp(a,b) == 0)
	49
	50	#ifndef TIFFhowmany8
	51	# define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
	52	#endif
	53
	54	typedef enum {
	55	EXP50,
	56	EXP60,
	57	EXP70,
	58	EXP80,
	59	EXP90,
	60	EXP,
	61	LINEAR
	62	} Contrast;
	63
	64	static uint32 tnw = 216; /* thumbnail width */
	65	static uint32 tnh = 274; /* thumbnail height */
	66	static Contrast contrast = LINEAR; /* current contrast */
	67	static uint8* thumbnail;
	68
	69	static int cpIFD(TIFF, TIFF);
	70	static int generateThumbnail(TIFF, TIFF);
	71	static void initScale();
	72	static void usage(void);
	73
	74	extern char* optarg;
	75	extern int optind;
	76
	77	int
	78	main(int argc, char* argv[])
	79	{
	80	TIFF* in;
	81	TIFF* out;
	82	int c;
	83
	84	while ((c = getopt(argc, argv, "w:h:c:")) != -1) {
	85	switch (c) {
	86	case 'w': tnw = strtoul(optarg, NULL, 0); break;
	87	case 'h': tnh = strtoul(optarg, NULL, 0); break;
	88	case 'c': contrast = streq(optarg, "exp50") ? EXP50 :
	89	streq(optarg, "exp60") ? EXP60 :
	90	streq(optarg, "exp70") ? EXP70 :
	91	streq(optarg, "exp80") ? EXP80 :
	92	streq(optarg, "exp90") ? EXP90 :
	93	streq(optarg, "exp") ? EXP :
	94	streq(optarg, "linear")? LINEAR :
	95	EXP;
	96	break;
	97	default: usage();
	98	}
	99	}
	100	if (argc-optind != 2)
	101	usage();
	102
	103	out = TIFFOpen(argv[optind+1], "w");
	104	if (out == NULL)
	105	return 2;
	106	in = TIFFOpen(argv[optind], "r");
	107	if( in == NULL )
	108	return 2;
	109
	110	thumbnail = (uint8) _TIFFmalloc(tnw tnh);
	111	if (!thumbnail) {
	112	TIFFError(TIFFFileName(in),
	113	"Can't allocate space for thumbnail buffer.");
	114	return 1;
	115	}
	116
	117	if (in != NULL) {
	118	initScale();
	119	do {
	120	if (!generateThumbnail(in, out))
	121	goto bad;
	122	if (!cpIFD(in, out) \|\| !TIFFWriteDirectory(out))
	123	goto bad;
	124	} while (TIFFReadDirectory(in));
	125	(void) TIFFClose(in);
	126	}
	127	(void) TIFFClose(out);
	128	return 0;
	129	bad:
	130	(void) TIFFClose(out);
	131	return 1;
	132	}
	133
	134	#define CopyField(tag, v) \
	135	if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
	136	#define CopyField2(tag, v1, v2) \
	137	if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
	138	#define CopyField3(tag, v1, v2, v3) \
	139	if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
	140	#define CopyField4(tag, v1, v2, v3, v4) \
	141	if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
	142
	143	static void
	144	cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
	145	{
	146	switch (type) {
	147	case TIFF_SHORT:
	148	if (count == 1) {
	149	uint16 shortv;
	150	CopyField(tag, shortv);
	151	} else if (count == 2) {
	152	uint16 shortv1, shortv2;
	153	CopyField2(tag, shortv1, shortv2);
	154	} else if (count == 4) {
	155	uint16 tr, tg, tb, ta;
	156	CopyField4(tag, tr, tg, tb, ta);
	157	} else if (count == (uint16) -1) {
	158	uint16 shortv1;
	159	uint16* shortav;
	160	CopyField2(tag, shortv1, shortav);
	161	}
	162	break;
	163	case TIFF_LONG:
	164	{ uint32 longv;
	165	CopyField(tag, longv);
	166	}
	167	break;
	168	case TIFF_LONG8:
	169	{ uint64 longv8;
	170	CopyField(tag, longv8);
	171	}
	172	break;
	173	case TIFF_SLONG8:
	174	{ int64 longv8;
	175	CopyField(tag, longv8);
	176	}
	177	break;
	178	case TIFF_RATIONAL:
	179	if (count == 1) {
	180	float floatv;
	181	CopyField(tag, floatv);
	182	} else if (count == (uint16) -1) {
	183	float* floatav;
	184	CopyField(tag, floatav);
	185	}
	186	break;
	187	case TIFF_ASCII:
	188	{ char* stringv;
	189	CopyField(tag, stringv);
	190	}
	191	break;
	192	case TIFF_DOUBLE:
	193	if (count == 1) {
	194	double doublev;
	195	CopyField(tag, doublev);
	196	} else if (count == (uint16) -1) {
	197	double* doubleav;
	198	CopyField(tag, doubleav);
	199	}
	200	break;
	201	case TIFF_IFD8:
	202	{ toff_t ifd8;
	203	CopyField(tag, ifd8);
	204	}
	205	break; default:
	206	TIFFError(TIFFFileName(in),
	207	"Data type %d is not supported, tag %d skipped.",
	208	tag, type);
	209	}
	210	}
	211
	212	#undef CopyField4
	213	#undef CopyField3
	214	#undef CopyField2
	215	#undef CopyField
	216
	217	static struct cpTag {
	218	uint16 tag;
	219	uint16 count;
	220	TIFFDataType type;
	221	} tags[] = {
	222	{ TIFFTAG_IMAGEWIDTH, 1, TIFF_LONG },
	223	{ TIFFTAG_IMAGELENGTH, 1, TIFF_LONG },
	224	{ TIFFTAG_BITSPERSAMPLE, 1, TIFF_SHORT },
	225	{ TIFFTAG_COMPRESSION, 1, TIFF_SHORT },
	226	{ TIFFTAG_FILLORDER, 1, TIFF_SHORT },
	227	{ TIFFTAG_SAMPLESPERPIXEL, 1, TIFF_SHORT },
	228	{ TIFFTAG_ROWSPERSTRIP, 1, TIFF_LONG },
	229	{ TIFFTAG_PLANARCONFIG, 1, TIFF_SHORT },
	230	{ TIFFTAG_GROUP3OPTIONS, 1, TIFF_LONG },
	231	{ TIFFTAG_SUBFILETYPE, 1, TIFF_LONG },
	232	{ TIFFTAG_PHOTOMETRIC, 1, TIFF_SHORT },
	233	{ TIFFTAG_THRESHHOLDING, 1, TIFF_SHORT },
	234	{ TIFFTAG_DOCUMENTNAME, 1, TIFF_ASCII },
	235	{ TIFFTAG_IMAGEDESCRIPTION, 1, TIFF_ASCII },
	236	{ TIFFTAG_MAKE, 1, TIFF_ASCII },
	237	{ TIFFTAG_MODEL, 1, TIFF_ASCII },
	238	{ TIFFTAG_ORIENTATION, 1, TIFF_SHORT },
	239	{ TIFFTAG_MINSAMPLEVALUE, 1, TIFF_SHORT },
	240	{ TIFFTAG_MAXSAMPLEVALUE, 1, TIFF_SHORT },
	241	{ TIFFTAG_XRESOLUTION, 1, TIFF_RATIONAL },
	242	{ TIFFTAG_YRESOLUTION, 1, TIFF_RATIONAL },
	243	{ TIFFTAG_PAGENAME, 1, TIFF_ASCII },
	244	{ TIFFTAG_XPOSITION, 1, TIFF_RATIONAL },
	245	{ TIFFTAG_YPOSITION, 1, TIFF_RATIONAL },
	246	{ TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG },
	247	{ TIFFTAG_RESOLUTIONUNIT, 1, TIFF_SHORT },
	248	{ TIFFTAG_PAGENUMBER, 2, TIFF_SHORT },
	249	{ TIFFTAG_SOFTWARE, 1, TIFF_ASCII },
	250	{ TIFFTAG_DATETIME, 1, TIFF_ASCII },
	251	{ TIFFTAG_ARTIST, 1, TIFF_ASCII },
	252	{ TIFFTAG_HOSTCOMPUTER, 1, TIFF_ASCII },
	253	{ TIFFTAG_WHITEPOINT, 2, TIFF_RATIONAL },
	254	{ TIFFTAG_PRIMARYCHROMATICITIES, (uint16) -1,TIFF_RATIONAL },
	255	{ TIFFTAG_HALFTONEHINTS, 2, TIFF_SHORT },
	256	{ TIFFTAG_BADFAXLINES, 1, TIFF_LONG },
	257	{ TIFFTAG_CLEANFAXDATA, 1, TIFF_SHORT },
	258	{ TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG },
	259	{ TIFFTAG_INKSET, 1, TIFF_SHORT },
	260	{ TIFFTAG_INKNAMES, 1, TIFF_ASCII },
	261	{ TIFFTAG_DOTRANGE, 2, TIFF_SHORT },
	262	{ TIFFTAG_TARGETPRINTER, 1, TIFF_ASCII },
	263	{ TIFFTAG_SAMPLEFORMAT, 1, TIFF_SHORT },
	264	{ TIFFTAG_YCBCRCOEFFICIENTS, (uint16) -1,TIFF_RATIONAL },
	265	{ TIFFTAG_YCBCRSUBSAMPLING, 2, TIFF_SHORT },
	266	{ TIFFTAG_YCBCRPOSITIONING, 1, TIFF_SHORT },
	267	{ TIFFTAG_REFERENCEBLACKWHITE, (uint16) -1,TIFF_RATIONAL },
	268	{ TIFFTAG_EXTRASAMPLES, (uint16) -1, TIFF_SHORT },
	269	};
	270	#define NTAGS (sizeof (tags) / sizeof (tags[0]))
	271
	272	static void
	273	cpTags(TIFF* in, TIFF* out)
	274	{
	275	struct cpTag *p;
	276	for (p = tags; p < &tags[NTAGS]; p++)
	277	cpTag(in, out, p->tag, p->count, p->type);
	278	}
	279	#undef NTAGS
	280
	281	static int
	282	cpStrips(TIFF* in, TIFF* out)
	283	{
	284	tsize_t bufsize = TIFFStripSize(in);
	285	unsigned char buf = (unsigned char )_TIFFmalloc(bufsize);
	286
	287	if (buf) {
	288	tstrip_t s, ns = TIFFNumberOfStrips(in);
	289	uint64 *bytecounts;
	290
	291	TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts);
	292	for (s = 0; s < ns; s++) {
	293	if (bytecounts[s] > (uint64) bufsize) {
	294	buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[s]);
	295	if (!buf)
	296	goto bad;
	297	bufsize = (tmsize_t)bytecounts[s];
	298	}
	299	if (TIFFReadRawStrip(in, s, buf, (tmsize_t)bytecounts[s]) < 0 \|\|
	300	TIFFWriteRawStrip(out, s, buf, (tmsize_t)bytecounts[s]) < 0) {
	301	_TIFFfree(buf);
	302	return 0;
	303	}
	304	}
	305	_TIFFfree(buf);
	306	return 1;
	307	}
	308
	309	bad:
	310	TIFFError(TIFFFileName(in),
	311	"Can't allocate space for strip buffer.");
	312	return 0;
	313	}
	314
	315	static int
	316	cpTiles(TIFF* in, TIFF* out)
	317	{
	318	tsize_t bufsize = TIFFTileSize(in);
	319	unsigned char buf = (unsigned char )_TIFFmalloc(bufsize);
	320
	321	if (buf) {
	322	ttile_t t, nt = TIFFNumberOfTiles(in);
	323	uint64 *bytecounts;
	324
	325	TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts);
	326	for (t = 0; t < nt; t++) {
	327	if (bytecounts[t] > (uint64) bufsize) {
	328	buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[t]);
	329	if (!buf)
	330	goto bad;
	331	bufsize = (tmsize_t)bytecounts[t];
	332	}
	333	if (TIFFReadRawTile(in, t, buf, (tmsize_t)bytecounts[t]) < 0 \|\|
	334	TIFFWriteRawTile(out, t, buf, (tmsize_t)bytecounts[t]) < 0) {
	335	_TIFFfree(buf);
	336	return 0;
	337	}
	338	}
	339	_TIFFfree(buf);
	340	return 1;
	341	}
	342
	343	bad:
	344	TIFFError(TIFFFileName(in),
	345	"Can't allocate space for tile buffer.");
	346	return (0);
	347	}
	348
	349	static int
	350	cpIFD(TIFF* in, TIFF* out)
	351	{
	352	cpTags(in, out);
	353	if (TIFFIsTiled(in)) {
	354	if (!cpTiles(in, out))
	355	return (0);
	356	} else {
	357	if (!cpStrips(in, out))
	358	return (0);
	359	}
	360	return (1);
	361	}
	362
	363	static uint16 photometric; /* current photometric of raster */
	364	static uint16 filterWidth; /* filter width in pixels */
	365	static uint32 stepSrcWidth; /* src image stepping width */
	366	static uint32 stepDstWidth; /* dest stepping width */
	367	static uint8* src0; /* horizontal bit stepping (start) */
	368	static uint8* src1; /* horizontal bit stepping (middle) */
	369	static uint8* src2; /* horizontal bit stepping (end) */
	370	static uint32* rowoff; /* row offset for stepping */
	371	static uint8 cmap[256]; /* colormap indexes */
	372	static uint8 bits[256]; /* count of bits set */
	373
	374	static void
	375	setupBitsTables()
	376	{
	377	int i;
	378	for (i = 0; i < 256; i++) {
	379	int n = 0;
	380	if (i&0x01) n++;
	381	if (i&0x02) n++;
	382	if (i&0x04) n++;
	383	if (i&0x08) n++;
	384	if (i&0x10) n++;
	385	if (i&0x20) n++;
	386	if (i&0x40) n++;
	387	if (i&0x80) n++;
	388	bits[i] = n;
	389	}
	390	}
	391
	392	static int clamp(float v, int low, int high)
	393	{ return (v < low ? low : v > high ? high : (int)v); }
	394
	395	#ifndef M_E
	396	#define M_E 2.7182818284590452354
	397	#endif
	398
	399	static void
	400	expFill(float pct[], uint32 p, uint32 n)
	401	{
	402	uint32 i;
	403	uint32 c = (p * n) / 100;
	404	for (i = 1; i < c; i++)
	405	pct[i] = (float) (1-exp(i/((double)(n-1)))/ M_E);
	406	for (; i < n; i++)
	407	pct[i] = 0.;
	408	}
	409
	410	static void
	411	setupCmap()
	412	{
	413	float pct[256]; /* known to be large enough */
	414	uint32 i;
	415	pct[0] = 1; /* force white */
	416	switch (contrast) {
	417	case EXP50: expFill(pct, 50, 256); break;
	418	case EXP60: expFill(pct, 60, 256); break;
	419	case EXP70: expFill(pct, 70, 256); break;
	420	case EXP80: expFill(pct, 80, 256); break;
	421	case EXP90: expFill(pct, 90, 256); break;
	422	case EXP: expFill(pct, 100, 256); break;
	423	case LINEAR:
	424	for (i = 1; i < 256; i++)
	425	pct[i] = 1-((float)i)/(256-1);
	426	break;
	427	}
	428	switch (photometric) {
	429	case PHOTOMETRIC_MINISWHITE:
	430	for (i = 0; i < 256; i++)
	431	cmap[i] = clamp(255*pct[(256-1)-i], 0, 255);
	432	break;
	433	case PHOTOMETRIC_MINISBLACK:
	434	for (i = 0; i < 256; i++)
	435	cmap[i] = clamp(255*pct[i], 0, 255);
	436	break;
	437	}
	438	}
	439
	440	static void
	441	initScale()
	442	{
	443	src0 = (uint8) _TIFFmalloc(sizeof (uint8) tnw);
	444	src1 = (uint8) _TIFFmalloc(sizeof (uint8) tnw);
	445	src2 = (uint8) _TIFFmalloc(sizeof (uint8) tnw);
	446	rowoff = (uint32) _TIFFmalloc(sizeof (uint32) tnw);
	447	filterWidth = 0;
	448	stepDstWidth = stepSrcWidth = 0;
	449	setupBitsTables();
	450	}
	451
	452	/*
	453	* Calculate the horizontal accumulation parameteres
	454	* according to the widths of the src and dst images.
	455	*/
	456	static void
	457	setupStepTables(uint32 sw)
	458	{
	459	if (stepSrcWidth != sw \|\| stepDstWidth != tnw) {
	460	int step = sw;
	461	int limit = tnw;
	462	int err = 0;
	463	uint32 sx = 0;
	464	uint32 x;
	465	int fw;
	466	uint8 b;
	467	for (x = 0; x < tnw; x++) {
	468	uint32 sx0 = sx;
	469	err += step;
	470	while (err >= limit) {
	471	err -= limit;
	472	sx++;
	473	}
	474	rowoff[x] = sx0 >> 3;
	475	fw = sx - sx0; /* width */
	476	b = (fw < 8) ? 0xff<<(8-fw) : 0xff;
	477	src0[x] = b >> (sx0&7);
	478	fw -= 8 - (sx0&7);
	479	if (fw < 0)
	480	fw = 0;
	481	src1[x] = fw >> 3;
	482	fw -= (fw>>3)<<3;
	483	src2[x] = 0xff << (8-fw);
	484	}
	485	stepSrcWidth = sw;
	486	stepDstWidth = tnw;
	487	}
	488	}
	489
	490	static void
	491	setrow(uint8* row, uint32 nrows, const uint8* rows[])
	492	{
	493	uint32 x;
	494	uint32 area = nrows * filterWidth;
	495	for (x = 0; x < tnw; x++) {
	496	uint32 mask0 = src0[x];
	497	uint32 fw = src1[x];
	498	uint32 mask1 = src1[x];
	499	uint32 off = rowoff[x];
	500	uint32 acc = 0;
	501	uint32 y, i;
	502	for (y = 0; y < nrows; y++) {
	503	const uint8* src = rows[y] + off;
	504	acc += bits[*src++ & mask0];
	505	switch (fw) {
	506	default:
	507	for (i = fw; i > 8; i--)
	508	acc += bits[*src++];
	509	/* fall thru... */
	510	case 8: acc += bits[*src++];
	511	case 7: acc += bits[*src++];
	512	case 6: acc += bits[*src++];
	513	case 5: acc += bits[*src++];
	514	case 4: acc += bits[*src++];
	515	case 3: acc += bits[*src++];
	516	case 2: acc += bits[*src++];
	517	case 1: acc += bits[*src++];
	518	case 0: break;
	519	}
	520	acc += bits[*src & mask1];
	521	}
	522	row++ = cmap[(255acc)/area];
	523	}
	524	}
	525
	526	/*
	527	* Install the specified image. The
	528	* image is resized to fit the display page using
	529	* a box filter. The resultant pixels are mapped
	530	* with a user-selectable contrast curve.
	531	*/
	532	static void
	533	setImage1(const uint8* br, uint32 rw, uint32 rh)
	534	{
	535	int step = rh;
	536	int limit = tnh;
	537	int err = 0;
	538	int bpr = TIFFhowmany8(rw);
	539	int sy = 0;
	540	uint8* row = thumbnail;
	541	uint32 dy;
	542	for (dy = 0; dy < tnh; dy++) {
	543	const uint8* rows[256];
	544	uint32 nrows = 1;
	545	fprintf(stderr, "bpr=%d, sy=%d, bprsy=%d\n", bpr, sy, bprsy);
	546	rows[0] = br + bpr*sy;
	547	err += step;
	548	while (err >= limit) {
	549	err -= limit;
	550	sy++;
	551	if (err >= limit)
	552	rows[nrows++] = br + bpr*sy;
	553	}
	554	setrow(row, nrows, rows);
	555	row += tnw;
	556	}
	557	}
	558
	559	static void
	560	setImage(const uint8* br, uint32 rw, uint32 rh)
	561	{
	562	filterWidth = (uint16) ceil((double) rw / (double) tnw);
	563	setupStepTables(rw);
	564	setImage1(br, rw, rh);
	565	}
	566
	567	static int
	568	generateThumbnail(TIFF* in, TIFF* out)
	569	{
	570	unsigned char* raster;
	571	unsigned char* rp;
	572	uint32 sw, sh, rps;
	573	uint16 bps, spp;
	574	tsize_t rowsize, rastersize;
	575	tstrip_t s, ns = TIFFNumberOfStrips(in);
	576	toff_t diroff[1];
	577
	578	TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &sw);
	579	TIFFGetField(in, TIFFTAG_IMAGELENGTH, &sh);
	580	TIFFGetFieldDefaulted(in, TIFFTAG_BITSPERSAMPLE, &bps);
	581	TIFFGetFieldDefaulted(in, TIFFTAG_SAMPLESPERPIXEL, &spp);
	582	TIFFGetFieldDefaulted(in, TIFFTAG_ROWSPERSTRIP, &rps);
	583	if (spp != 1 \|\| bps != 1)
	584	return 0;
	585	rowsize = TIFFScanlineSize(in);
	586	rastersize = sh * rowsize;
	587	fprintf(stderr, "rastersize=%u\n", (unsigned int)rastersize);
	588	raster = (unsigned char*)_TIFFmalloc(rastersize);
	589	if (!raster) {
	590	TIFFError(TIFFFileName(in),
	591	"Can't allocate space for raster buffer.");
	592	return 0;
	593	}
	594	rp = raster;
	595	for (s = 0; s < ns; s++) {
	596	(void) TIFFReadEncodedStrip(in, s, rp, -1);
	597	rp += rps * rowsize;
	598	}
	599	TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &photometric);
	600	setupCmap();
	601	setImage(raster, sw, sh);
	602	_TIFFfree(raster);
	603
	604	TIFFSetField(out, TIFFTAG_SUBFILETYPE, FILETYPE_REDUCEDIMAGE);
	605	TIFFSetField(out, TIFFTAG_IMAGEWIDTH, (uint32) tnw);
	606	TIFFSetField(out, TIFFTAG_IMAGELENGTH, (uint32) tnh);
	607	TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, (uint16) 8);
	608	TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, (uint16) 1);
	609	TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
	610	TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
	611	TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
	612	TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
	613	cpTag(in, out, TIFFTAG_SOFTWARE, (uint16) -1, TIFF_ASCII);
	614	cpTag(in, out, TIFFTAG_IMAGEDESCRIPTION, (uint16) -1, TIFF_ASCII);
	615	cpTag(in, out, TIFFTAG_DATETIME, (uint16) -1, TIFF_ASCII);
	616	cpTag(in, out, TIFFTAG_HOSTCOMPUTER, (uint16) -1, TIFF_ASCII);
	617	diroff[0] = 0UL;
	618	TIFFSetField(out, TIFFTAG_SUBIFD, 1, diroff);
	619	return (TIFFWriteEncodedStrip(out, 0, thumbnail, tnw*tnh) != -1 &&
	620	TIFFWriteDirectory(out) != -1);
	621	}
	622
	623	char* stuff[] = {
	624	"usage: thumbnail [options] input.tif output.tif",
	625	"where options are:",
	626	" -h # specify thumbnail image height (default is 274)",
	627	" -w # specify thumbnail image width (default is 216)",
	628	"",
	629	" -c linear use linear contrast curve",
	630	" -c exp50 use 50% exponential contrast curve",
	631	" -c exp60 use 60% exponential contrast curve",
	632	" -c exp70 use 70% exponential contrast curve",
	633	" -c exp80 use 80% exponential contrast curve",
	634	" -c exp90 use 90% exponential contrast curve",
	635	" -c exp use pure exponential contrast curve",
	636	NULL
	637	};
	638
	639	static void
	640	usage(void)
	641	{
	642	char buf[BUFSIZ];
	643	int i;
	644
	645	setbuf(stderr, buf);
	646	fprintf(stderr, "%s\n\n", TIFFGetVersion());
	647	for (i = 0; stuff[i] != NULL; i++)
	648	fprintf(stderr, "%s\n", stuff[i]);
	649	exit(-1);
	650	}
	651
	652	/* vim: set ts=8 sts=8 sw=8 noet: */
	653	/*
	654	* Local Variables:
	655	* mode: c
	656	* c-basic-offset: 8
	657	* fill-column: 78
	658	* End:
	659	*/