laag-libtiff 4.0.9.0

data/vendor/gitlab.com/libtiff/libtiff/tools/rgb2ycbcr.c

@@ -0,0 +1,397 @@
+/* $Id: rgb2ycbcr.c,v 1.17 2016-08-15 21:26:56 erouault Exp $ */
+
+/*
+ * Copyright (c) 1991-1997 Sam Leffler
+ * Copyright (c) 1991-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 <string.h>
+#include <stdlib.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffiop.h"
+#include "tiffio.h"
+
+#define	streq(a,b)	(strcmp(a,b) == 0)
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+
+#ifndef howmany
+#define	howmany(x, y)	(((x)+((y)-1))/(y))
+#endif
+#define	roundup(x, y)	(howmany(x,y)*((uint32)(y)))
+
+#define	LumaRed		ycbcrCoeffs[0]
+#define	LumaGreen	ycbcrCoeffs[1]
+#define	LumaBlue	ycbcrCoeffs[2]
+
+uint16	compression = COMPRESSION_PACKBITS;
+uint32	rowsperstrip = (uint32) -1;
+
+uint16	horizSubSampling = 2;		/* YCbCr horizontal subsampling */
+uint16	vertSubSampling = 2;		/* YCbCr vertical subsampling */
+float	ycbcrCoeffs[3] = { .299F, .587F, .114F };
+/* default coding range is CCIR Rec 601-1 with no headroom/footroom */
+float	refBlackWhite[6] = { 0.F, 255.F, 128.F, 255.F, 128.F, 255.F };
+
+static	int tiffcvt(TIFF* in, TIFF* out);
+static	void usage(int code);
+static	void setupLumaTables(void);
+
+int
+main(int argc, char* argv[])
+{
+	TIFF *in, *out;
+	int c;
+#if !HAVE_DECL_OPTARG
+	extern int optind;
+	extern char *optarg;
+#endif
+
+	while ((c = getopt(argc, argv, "c:h:r:v:z")) != -1)
+		switch (c) {
+		case 'c':
+			if (streq(optarg, "none"))
+			    compression = COMPRESSION_NONE;
+			else if (streq(optarg, "packbits"))
+			    compression = COMPRESSION_PACKBITS;
+			else if (streq(optarg, "lzw"))
+			    compression = COMPRESSION_LZW;
+			else if (streq(optarg, "jpeg"))
+			    compression = COMPRESSION_JPEG;
+			else if (streq(optarg, "zip"))
+			    compression = COMPRESSION_ADOBE_DEFLATE;
+			else
+			    usage(-1);
+			break;
+		case 'h':
+			horizSubSampling = atoi(optarg);
+            if( horizSubSampling != 1 && horizSubSampling != 2 && horizSubSampling != 4 )
+                usage(-1);
+			break;
+		case 'v':
+			vertSubSampling = atoi(optarg);
+            if( vertSubSampling != 1 && vertSubSampling != 2 && vertSubSampling != 4 )
+                usage(-1);
+			break;
+		case 'r':
+			rowsperstrip = atoi(optarg);
+			break;
+		case 'z':	/* CCIR Rec 601-1 w/ headroom/footroom */
+			refBlackWhite[0] = 16.;
+			refBlackWhite[1] = 235.;
+			refBlackWhite[2] = 128.;
+			refBlackWhite[3] = 240.;
+			refBlackWhite[4] = 128.;
+			refBlackWhite[5] = 240.;
+			break;
+		case '?':
+			usage(0);
+			/*NOTREACHED*/
+		}
+	if (argc - optind < 2)
+		usage(-1);
+	out = TIFFOpen(argv[argc-1], "w");
+	if (out == NULL)
+		return (-2);
+	setupLumaTables();
+	for (; optind < argc-1; optind++) {
+		in = TIFFOpen(argv[optind], "r");
+		if (in != NULL) {
+			do {
+				if (!tiffcvt(in, out) ||
+				    !TIFFWriteDirectory(out)) {
+					(void) TIFFClose(out);
+					return (1);
+				}
+			} while (TIFFReadDirectory(in));
+			(void) TIFFClose(in);
+		}
+	}
+	(void) TIFFClose(out);
+	return (0);
+}
+
+float	*lumaRed;
+float	*lumaGreen;
+float	*lumaBlue;
+float	D1, D2;
+int	Yzero;
+
+static float*
+setupLuma(float c)
+{
+	float *v = (float *)_TIFFmalloc(256 * sizeof (float));
+	int i;
+	for (i = 0; i < 256; i++)
+		v[i] = c * i;
+	return (v);
+}
+
+static unsigned
+V2Code(float f, float RB, float RW, int CR)
+{
+	unsigned int c = (unsigned int)((((f)*(RW-RB)/CR)+RB)+.5);
+	return (c > 255 ? 255 : c);
+}
+
+static void
+setupLumaTables(void)
+{
+	lumaRed = setupLuma(LumaRed);
+	lumaGreen = setupLuma(LumaGreen);
+	lumaBlue = setupLuma(LumaBlue);
+	D1 = 1.F/(2.F - 2.F*LumaBlue);
+	D2 = 1.F/(2.F - 2.F*LumaRed);
+	Yzero = V2Code(0, refBlackWhite[0], refBlackWhite[1], 255);
+}
+
+static void
+cvtClump(unsigned char* op, uint32* raster, uint32 ch, uint32 cw, uint32 w)
+{
+	float Y, Cb = 0, Cr = 0;
+	uint32 j, k;
+	/*
+	 * Convert ch-by-cw block of RGB
+	 * to YCbCr and sample accordingly.
+	 */
+	for (k = 0; k < ch; k++) {
+		for (j = 0; j < cw; j++) {
+			uint32 RGB = (raster - k*w)[j];
+			Y = lumaRed[TIFFGetR(RGB)] +
+			    lumaGreen[TIFFGetG(RGB)] +
+			    lumaBlue[TIFFGetB(RGB)];
+			/* accumulate chrominance */
+			Cb += (TIFFGetB(RGB) - Y) * D1;
+			Cr += (TIFFGetR(RGB) - Y) * D2;
+			/* emit luminence */
+			*op++ = V2Code(Y,
+			    refBlackWhite[0], refBlackWhite[1], 255);
+		}
+		for (; j < horizSubSampling; j++)
+			*op++ = Yzero;
+	}
+	for (; k < vertSubSampling; k++) {
+		for (j = 0; j < horizSubSampling; j++)
+			*op++ = Yzero;
+	}
+	/* emit sampled chrominance values */
+	*op++ = V2Code(Cb / (ch*cw), refBlackWhite[2], refBlackWhite[3], 127);
+	*op++ = V2Code(Cr / (ch*cw), refBlackWhite[4], refBlackWhite[5], 127);
+}
+#undef LumaRed
+#undef LumaGreen
+#undef LumaBlue
+#undef V2Code
+
+/*
+ * Convert a strip of RGB data to YCbCr and
+ * sample to generate the output data.
+ */
+static void
+cvtStrip(unsigned char* op, uint32* raster, uint32 nrows, uint32 width)
+{
+	uint32 x;
+	int clumpSize = vertSubSampling * horizSubSampling + 2;
+	uint32 *tp;
+
+	for (; nrows >= vertSubSampling; nrows -= vertSubSampling) {
+		tp = raster;
+		for (x = width; x >= horizSubSampling; x -= horizSubSampling) {
+			cvtClump(op, tp,
+			    vertSubSampling, horizSubSampling, width);
+			op += clumpSize;
+			tp += horizSubSampling;
+		}
+		if (x > 0) {
+			cvtClump(op, tp, vertSubSampling, x, width);
+			op += clumpSize;
+		}
+		raster -= vertSubSampling*width;
+	}
+	if (nrows > 0) {
+		tp = raster;
+		for (x = width; x >= horizSubSampling; x -= horizSubSampling) {
+			cvtClump(op, tp, nrows, horizSubSampling, width);
+			op += clumpSize;
+			tp += horizSubSampling;
+		}
+		if (x > 0)
+			cvtClump(op, tp, nrows, x, width);
+	}
+}
+
+static int
+cvtRaster(TIFF* tif, uint32* raster, uint32 width, uint32 height)
+{
+	uint32 y;
+	tstrip_t strip = 0;
+	tsize_t cc, acc;
+	unsigned char* buf;
+	uint32 rwidth = roundup(width, horizSubSampling);
+	uint32 rheight = roundup(height, vertSubSampling);
+	uint32 nrows = (rowsperstrip > rheight ? rheight : rowsperstrip);
+        uint32 rnrows = roundup(nrows,vertSubSampling);
+
+	cc = rnrows*rwidth +
+	    2*((rnrows*rwidth) / (horizSubSampling*vertSubSampling));
+	buf = (unsigned char*)_TIFFmalloc(cc);
+	// FIXME unchecked malloc
+	for (y = height; (int32) y > 0; y -= nrows) {
+		uint32 nr = (y > nrows ? nrows : y);
+		cvtStrip(buf, raster + (y-1)*width, nr, width);
+		nr = roundup(nr, vertSubSampling);
+		acc = nr*rwidth +
+			2*((nr*rwidth)/(horizSubSampling*vertSubSampling));
+		if (!TIFFWriteEncodedStrip(tif, strip++, buf, acc)) {
+			_TIFFfree(buf);
+			return (0);
+		}
+	}
+	_TIFFfree(buf);
+	return (1);
+}
+
+static int
+tiffcvt(TIFF* in, TIFF* out)
+{
+	uint32 width, height;		/* image width & height */
+	uint32* raster;			/* retrieve RGBA image */
+	uint16 shortv;
+	float floatv;
+	char *stringv;
+	uint32 longv;
+	int result;
+	size_t pixel_count;
+
+	TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
+	TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
+	pixel_count = width * height;
+
+ 	/* XXX: Check the integer overflow. */
+ 	if (!width || !height || pixel_count / width != height) {
+ 		TIFFError(TIFFFileName(in),
+ 			  "Malformed input file; "
+ 			  "can't allocate buffer for raster of %lux%lu size",
+ 			  (unsigned long)width, (unsigned long)height);
+ 		return 0;
+ 	}
+ 
+ 	raster = (uint32*)_TIFFCheckMalloc(in, pixel_count, sizeof(uint32),
+ 					   "raster buffer");
+  	if (raster == 0) {
+ 		TIFFError(TIFFFileName(in),
+ 			  "Failed to allocate buffer (%lu elements of %lu each)",
+ 			  (unsigned long)pixel_count,
+ 			  (unsigned long)sizeof(uint32));
+  		return (0);
+  	}
+
+	if (!TIFFReadRGBAImage(in, width, height, raster, 0)) {
+		_TIFFfree(raster);
+		return (0);
+	}
+
+	CopyField(TIFFTAG_SUBFILETYPE, longv);
+	TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
+	TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
+	TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
+	TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
+	TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
+	if (compression == COMPRESSION_JPEG)
+		TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RAW);
+	CopyField(TIFFTAG_FILLORDER, shortv);
+	TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+	TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
+	CopyField(TIFFTAG_XRESOLUTION, floatv);
+	CopyField(TIFFTAG_YRESOLUTION, floatv);
+	CopyField(TIFFTAG_RESOLUTIONUNIT, shortv);
+	TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+	{ char buf[2048];
+	  char *cp = strrchr(TIFFFileName(in), '/');
+	  snprintf(buf, sizeof(buf), "YCbCr conversion of %s",
+		   cp ? cp+1 : TIFFFileName(in));
+	  TIFFSetField(out, TIFFTAG_IMAGEDESCRIPTION, buf);
+	}
+	TIFFSetField(out, TIFFTAG_SOFTWARE, TIFFGetVersion());
+	CopyField(TIFFTAG_DOCUMENTNAME, stringv);
+
+	TIFFSetField(out, TIFFTAG_REFERENCEBLACKWHITE, refBlackWhite);
+	TIFFSetField(out, TIFFTAG_YCBCRSUBSAMPLING,
+	    horizSubSampling, vertSubSampling);
+	TIFFSetField(out, TIFFTAG_YCBCRPOSITIONING, YCBCRPOSITION_CENTERED);
+	TIFFSetField(out, TIFFTAG_YCBCRCOEFFICIENTS, ycbcrCoeffs);
+	rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip);
+	TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
+
+	result = cvtRaster(out, raster, width, height);
+        _TIFFfree(raster);
+        return result;
+}
+
+char* stuff[] = {
+    "usage: rgb2ycbcr [-c comp] [-r rows] [-h N] [-v N] input... output\n",
+    "where comp is one of the following compression algorithms:\n",
+    " jpeg\t\tJPEG encoding\n",
+    " lzw\t\tLempel-Ziv & Welch encoding\n",
+    " zip\t\tdeflate encoding\n",
+    " packbits\tPackBits encoding (default)\n",
+    " none\t\tno compression\n",
+    "and the other options are:\n",
+    " -r\trows/strip\n",
+    " -h\thorizontal sampling factor (1,2,4)\n",
+    " -v\tvertical sampling factor (1,2,4)\n",
+    NULL
+};
+
+static void
+usage(int code)
+{
+	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(code);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */

data/vendor/gitlab.com/libtiff/libtiff/tools/thumbnail.c

@@ -0,0 +1,691 @@
+/* $Id: thumbnail.c,v 1.21 2015-06-21 01:09:10 bfriesen 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);
+
+#if !HAVE_DECL_OPTARG
+extern	char* optarg;
+extern	int optind;
+#endif
+
+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:
+ */