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

#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");

    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_RATIONAL:
		if (count == 1) {
			float floatv;
			CopyField(tag, floatv);
		} else if (count == (uint16) -1) {
			float* floatav;
			CopyField(tag, floatav);
		}
		break;
	case TIFF_ASCII:
		{ char* stringv;
		  CopyField(tag, stringv);
		}
		break;
	case TIFF_DOUBLE:
		if (count == 1) {
			double doublev;
			CopyField(tag, doublev);
		} else if (count == (uint16) -1) {
			double* doubleav;
			CopyField(tag, doubleav);
		}
		break;
          default:
                TIFFError(TIFFFileName(in),
                          "Data type %d is not supported, tag %d skipped.",
                          tag, type);
	}
}

#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,		1, 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);
	tsize_t *bytecounts;

	TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts);
	for (s = 0; s < ns; s++) {
	    if (bytecounts[s] > bufsize) {
		buf = (unsigned char *)_TIFFrealloc(buf, bytecounts[s]);
		if (!buf)
		    goto bad;
		bufsize = bytecounts[s];
	    }
	    if (TIFFReadRawStrip(in, s, buf, bytecounts[s]) < 0 ||
		TIFFWriteRawStrip(out, s, buf, 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);
	tsize_t *bytecounts;

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