laag-libtiff 4.0.9.0

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

@@ -0,0 +1,356 @@
+/******************************************************************************
+ * $Id: tiffset.c,v 1.19 2017-10-01 17:38:12 erouault Exp $
+ *
+ * Project:  libtiff tools
+ * Purpose:  Mainline for setting metadata in existing TIFF files.
+ * Author:   Frank Warmerdam, warmerdam@pobox.com
+ *
+ ******************************************************************************
+ * Copyright (c) 2000, Frank Warmerdam
+ *
+ * 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "tiffio.h"
+
+static char* usageMsg[] = {
+"usage: tiffset [options] filename",
+"where options are:",
+" -s <tagname> [count] <value>...   set the tag value",
+" -u <tagname> to unset the tag",
+" -d <dirno> set the directory",
+" -sd <diroff> set the subdirectory",
+" -sf <tagname> <filename>  read the tag value from file (for ASCII tags only)",
+NULL
+};
+
+static void
+usage(void)
+{
+	int i;
+	for (i = 0; usageMsg[i]; i++)
+		fprintf(stderr, "%s\n", usageMsg[i]);
+	exit(-1);
+}
+
+static const TIFFField *
+GetField(TIFF *tiff, const char *tagname)
+{
+    const TIFFField *fip;
+
+    if( atoi(tagname) > 0 )
+        fip = TIFFFieldWithTag(tiff, (ttag_t)atoi(tagname));
+    else
+        fip = TIFFFieldWithName(tiff, tagname);
+
+    if (!fip) {
+        fprintf( stderr, "Field name \"%s\" is not recognised.\n", tagname );
+        return (TIFFField *)NULL;
+    }
+
+    return fip;
+}
+
+int
+main(int argc, char* argv[])
+{
+    TIFF *tiff;
+    int  arg_index;
+
+    if (argc < 2)
+        usage();
+
+    tiff = TIFFOpen(argv[argc-1], "r+");
+    if (tiff == NULL)
+        return 2;
+
+    for( arg_index = 1; arg_index < argc-1; arg_index++ ) {
+	if (strcmp(argv[arg_index],"-d") == 0 && arg_index < argc-2) {
+	    arg_index++;
+	    if( TIFFSetDirectory(tiff, atoi(argv[arg_index]) ) != 1 )
+            {
+               fprintf( stderr, "Failed to set directory=%s\n", argv[arg_index] );
+               return 6;
+            }
+	    arg_index++;
+	}
+	if (strcmp(argv[arg_index],"-sd") == 0 && arg_index < argc-2) {
+	    arg_index++;
+	    if( TIFFSetSubDirectory(tiff, atoi(argv[arg_index]) ) != 1 )
+            {
+               fprintf( stderr, "Failed to set sub directory=%s\n", argv[arg_index] );
+               return 7;
+            }
+	    arg_index++;
+	}
+    /* Add unset option to tiffset -- Zach Baker (niquil@niquil.net) 11/14/2012 */ 
+    if (strcmp(argv[arg_index],"-u") == 0 && arg_index < argc-2) {
+            const TIFFField *fip;
+            const char *tagname;
+            arg_index++;
+            tagname = argv[arg_index];
+            fip = GetField(tiff, tagname);
+            if (!fip)
+                return 3;
+
+            if (TIFFUnsetField(tiff, TIFFFieldTag(fip)) != 1)
+            {
+                    fprintf(stderr, "Failed to unset %s\n", TIFFFieldName(fip));
+            }
+            arg_index++;
+    } else if (strcmp(argv[arg_index],"-s") == 0 && arg_index < argc-3) {
+            const TIFFField *fip;
+            const char *tagname;
+
+            arg_index++;
+            tagname = argv[arg_index];
+            fip = GetField(tiff, tagname);
+
+            if (!fip)
+                return 3;
+
+            arg_index++;
+            if (TIFFFieldDataType(fip) == TIFF_ASCII) {
+                if (TIFFSetField(tiff, TIFFFieldTag(fip), argv[arg_index]) != 1)
+                    fprintf( stderr, "Failed to set %s=%s\n",
+                             TIFFFieldName(fip), argv[arg_index] );
+            } else if (TIFFFieldWriteCount(fip) > 0
+		       || TIFFFieldWriteCount(fip) == TIFF_VARIABLE) {
+                int     ret = 1;
+                short   wc;
+
+                if (TIFFFieldWriteCount(fip) == TIFF_VARIABLE)
+                        wc = atoi(argv[arg_index++]);
+                else
+                        wc = TIFFFieldWriteCount(fip);
+
+                if (argc - arg_index < wc) {
+                    fprintf( stderr,
+                             "Number of tag values is not enough. "
+                             "Expected %d values for %s tag, got %d\n",
+                             wc, TIFFFieldName(fip), argc - arg_index);
+                    return 4;
+                }
+                    
+                if (wc > 1 || TIFFFieldWriteCount(fip) == TIFF_VARIABLE) {
+                        int     i, size;
+                        void    *array;
+
+                        switch (TIFFFieldDataType(fip)) {
+                                /*
+                                 * XXX: We can't use TIFFDataWidth()
+                                 * to determine the space needed to store
+                                 * the value. For TIFF_RATIONAL values
+                                 * TIFFDataWidth() returns 8, but we use 4-byte
+                                 * float to represent rationals.
+                                 */
+                                case TIFF_BYTE:
+                                case TIFF_ASCII:
+                                case TIFF_SBYTE:
+                                case TIFF_UNDEFINED:
+				default:
+                                    size = 1;
+                                    break;
+
+                                case TIFF_SHORT:
+                                case TIFF_SSHORT:
+                                    size = 2;
+                                    break;
+
+                                case TIFF_LONG:
+                                case TIFF_SLONG:
+                                case TIFF_FLOAT:
+                                case TIFF_IFD:
+                                case TIFF_RATIONAL:
+                                case TIFF_SRATIONAL:
+                                    size = 4;
+                                    break;
+
+                                case TIFF_DOUBLE:
+                                    size = 8;
+                                    break;
+                        }
+
+                        array = _TIFFmalloc(wc * size);
+                        if (!array) {
+                                fprintf(stderr, "No space for %s tag\n",
+                                        tagname);
+                                return 4;
+                        }
+
+                        switch (TIFFFieldDataType(fip)) {
+                            case TIFF_BYTE:
+                                for (i = 0; i < wc; i++)
+                                    ((uint8 *)array)[i] = atoi(argv[arg_index+i]);
+                                break;
+                            case TIFF_SHORT:
+                                for (i = 0; i < wc; i++)
+                                    ((uint16 *)array)[i] = atoi(argv[arg_index+i]);
+                                break;
+                            case TIFF_SBYTE:
+                                for (i = 0; i < wc; i++)
+                                    ((int8 *)array)[i] = atoi(argv[arg_index+i]);
+                                break;
+                            case TIFF_SSHORT:
+                                for (i = 0; i < wc; i++)
+                                    ((int16 *)array)[i] = atoi(argv[arg_index+i]);
+                                break;
+                            case TIFF_LONG:
+                                for (i = 0; i < wc; i++)
+                                    ((uint32 *)array)[i] = atol(argv[arg_index+i]);
+                                break;
+                            case TIFF_SLONG:
+                            case TIFF_IFD:
+                                for (i = 0; i < wc; i++)
+                                    ((uint32 *)array)[i] = atol(argv[arg_index+i]);
+                                break;
+                            case TIFF_DOUBLE:
+                                for (i = 0; i < wc; i++)
+                                    ((double *)array)[i] = atof(argv[arg_index+i]);
+                                break;
+                            case TIFF_RATIONAL:
+                            case TIFF_SRATIONAL:
+                            case TIFF_FLOAT:
+                                for (i = 0; i < wc; i++)
+                                    ((float *)array)[i] = (float)atof(argv[arg_index+i]);
+                                break;
+                            default:
+                                break;
+                        }
+                
+                        if (TIFFFieldPassCount(fip)) {
+                                ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+                                                   wc, array);
+                        } else if (TIFFFieldTag(fip) == TIFFTAG_PAGENUMBER
+				   || TIFFFieldTag(fip) == TIFFTAG_HALFTONEHINTS
+				   || TIFFFieldTag(fip) == TIFFTAG_YCBCRSUBSAMPLING
+				   || TIFFFieldTag(fip) == TIFFTAG_DOTRANGE) {
+       				if (TIFFFieldDataType(fip) == TIFF_BYTE) {
+					ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+						((uint8 *)array)[0], ((uint8 *)array)[1]);
+				} else if (TIFFFieldDataType(fip) == TIFF_SHORT) {
+					ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+						((uint16 *)array)[0], ((uint16 *)array)[1]);
+				}
+			} else {
+                                ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+                                                   array);
+                        }
+
+                        _TIFFfree(array);
+                } else {
+                        switch (TIFFFieldDataType(fip)) {
+                            case TIFF_BYTE:
+                            case TIFF_SHORT:
+                            case TIFF_SBYTE:
+                            case TIFF_SSHORT:
+                                ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+                                                   atoi(argv[arg_index++]));
+                                break;
+                            case TIFF_LONG:
+                            case TIFF_SLONG:
+                            case TIFF_IFD:
+                                ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+                                                   atol(argv[arg_index++]));
+                                break;
+                            case TIFF_DOUBLE:
+                                ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+                                                   atof(argv[arg_index++]));
+                                break;
+                            case TIFF_RATIONAL:
+                            case TIFF_SRATIONAL:
+                            case TIFF_FLOAT:
+                                ret = TIFFSetField(tiff, TIFFFieldTag(fip),
+                                                   (float)atof(argv[arg_index++]));
+                                break;
+                            default:
+                                break;
+                        }
+                }
+
+                if (ret != 1)
+                    fprintf(stderr, "Failed to set %s\n", TIFFFieldName(fip));
+                arg_index += wc;
+            }
+        } else if (strcmp(argv[arg_index],"-sf") == 0 && arg_index < argc-3) {
+            FILE    *fp;
+            const TIFFField *fip;
+            char    *text;
+            size_t  len;
+
+            arg_index++;
+            fip = GetField(tiff, argv[arg_index]);
+
+            if (!fip)
+                return 3;
+
+            if (TIFFFieldDataType(fip) != TIFF_ASCII) {
+                fprintf( stderr,
+                         "Only ASCII tags can be set from file. "
+                         "%s is not ASCII tag.\n", TIFFFieldName(fip) );
+                return 5;
+            }
+
+            arg_index++;
+            fp = fopen( argv[arg_index], "rt" );
+            if(fp == NULL) {
+                perror( argv[arg_index] );
+                continue;
+            }
+
+            text = (char *) malloc(1000000);
+            len = fread( text, 1, 999999, fp );
+            text[len] = '\0';
+
+            fclose( fp );
+
+            if(TIFFSetField( tiff, TIFFFieldTag(fip), text ) != 1) {
+                fprintf(stderr, "Failed to set %s from file %s\n", 
+                        TIFFFieldName(fip), argv[arg_index]);
+            }
+
+            _TIFFfree( text );
+            arg_index++;
+        } else {
+            fprintf(stderr, "Unrecognised option: %s\n",
+                    argv[arg_index]);
+            usage();
+        }
+    }
+
+    TIFFRewriteDirectory(tiff);
+    TIFFClose(tiff);
+    return 0;
+}
+
+/* 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/tiffsplit.c

@@ -0,0 +1,305 @@
+/* $Id: tiffsplit.c,v 1.23 2015-05-28 13:10:26 bfriesen Exp $ */
+
+/*
+ * Copyright (c) 1992-1997 Sam Leffler
+ * Copyright (c) 1992-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 "tiffio.h"
+
+#ifndef HAVE_GETOPT
+extern int getopt(int, char**, char*);
+#endif
+
+#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 PATH_LENGTH 8192
+
+static const char TIFF_SUFFIX[] = ".tif";
+
+static	char fname[PATH_LENGTH];
+
+static	int tiffcp(TIFF*, TIFF*);
+static	void newfilename(void);
+static	int cpStrips(TIFF*, TIFF*);
+static	int cpTiles(TIFF*, TIFF*);
+
+int
+main(int argc, char* argv[])
+{
+	TIFF *in, *out;
+
+	if (argc < 2) {
+                fprintf(stderr, "%s\n\n", TIFFGetVersion());
+		fprintf(stderr, "usage: tiffsplit input.tif [prefix]\n");
+		return (-3);
+	}
+	if (argc > 2) {
+		strncpy(fname, argv[2], sizeof(fname));
+		fname[sizeof(fname) - 1] = '\0';
+	}
+	in = TIFFOpen(argv[1], "r");
+	if (in != NULL) {
+		do {
+			size_t path_len;
+			char *path;
+			
+			newfilename();
+
+			path_len = strlen(fname) + sizeof(TIFF_SUFFIX);
+			path = (char *) _TIFFmalloc(path_len);
+			strncpy(path, fname, path_len);
+			path[path_len - 1] = '\0';
+			strncat(path, TIFF_SUFFIX, path_len - strlen(path) - 1);
+			out = TIFFOpen(path, TIFFIsBigEndian(in)?"wb":"wl");
+			_TIFFfree(path);
+
+			if (out == NULL)
+				return (-2);
+			if (!tiffcp(in, out))
+				return (-1);
+			TIFFClose(out);
+		} while (TIFFReadDirectory(in));
+		(void) TIFFClose(in);
+	}
+	return (0);
+}
+
+static void
+newfilename(void)
+{
+	static int first = 1;
+	static long lastTurn;
+	static long fnum;
+	static short defname;
+	static char *fpnt;
+
+	if (first) {
+		if (fname[0]) {
+			fpnt = fname + strlen(fname);
+			defname = 0;
+		} else {
+			fname[0] = 'x';
+			fpnt = fname + 1;
+			defname = 1;
+		}
+		first = 0;
+	}
+#define	MAXFILES	17576
+	if (fnum == MAXFILES) {
+		if (!defname || fname[0] == 'z') {
+			fprintf(stderr, "tiffsplit: too many files.\n");
+			exit(1);
+		}
+		fname[0]++;
+		fnum = 0;
+	}
+	if (fnum % 676 == 0) {
+		if (fnum != 0) {
+			/*
+                         * advance to next letter every 676 pages
+			 * condition for 'z'++ will be covered above
+                         */
+			fpnt[0]++;
+		} else {
+			/*
+                         * set to 'a' if we are on the very first file
+                         */
+			fpnt[0] = 'a';
+		}
+		/*
+                 * set the value of the last turning point
+                 */
+		lastTurn = fnum;
+	}
+	/* 
+         * start from 0 every 676 times (provided by lastTurn)
+         * this keeps us within a-z boundaries
+         */
+	fpnt[1] = (char)((fnum - lastTurn) / 26) + 'a';
+	/* 
+         * cycle last letter every file, from a-z, then repeat
+         */
+	fpnt[2] = (char)(fnum % 26) + 'a';
+	fnum++;
+}
+
+static int
+tiffcp(TIFF* in, TIFF* out)
+{
+	uint16 bitspersample, samplesperpixel, compression, shortv, *shortav;
+	uint32 w, l;
+	float floatv;
+	char *stringv;
+	uint32 longv;
+
+	CopyField(TIFFTAG_SUBFILETYPE, longv);
+	CopyField(TIFFTAG_TILEWIDTH, w);
+	CopyField(TIFFTAG_TILELENGTH, l);
+	CopyField(TIFFTAG_IMAGEWIDTH, w);
+	CopyField(TIFFTAG_IMAGELENGTH, l);
+	CopyField(TIFFTAG_BITSPERSAMPLE, bitspersample);
+	CopyField(TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
+	CopyField(TIFFTAG_COMPRESSION, compression);
+	if (compression == COMPRESSION_JPEG) {
+		uint32 count = 0;
+		void *table = NULL;
+		if (TIFFGetField(in, TIFFTAG_JPEGTABLES, &count, &table)
+		    && count > 0 && table) {
+		    TIFFSetField(out, TIFFTAG_JPEGTABLES, count, table);
+		}
+	}
+        CopyField(TIFFTAG_PHOTOMETRIC, shortv);
+	CopyField(TIFFTAG_PREDICTOR, shortv);
+	CopyField(TIFFTAG_THRESHHOLDING, shortv);
+	CopyField(TIFFTAG_FILLORDER, shortv);
+	CopyField(TIFFTAG_ORIENTATION, shortv);
+	CopyField(TIFFTAG_MINSAMPLEVALUE, shortv);
+	CopyField(TIFFTAG_MAXSAMPLEVALUE, shortv);
+	CopyField(TIFFTAG_XRESOLUTION, floatv);
+	CopyField(TIFFTAG_YRESOLUTION, floatv);
+	CopyField(TIFFTAG_GROUP3OPTIONS, longv);
+	CopyField(TIFFTAG_GROUP4OPTIONS, longv);
+	CopyField(TIFFTAG_RESOLUTIONUNIT, shortv);
+	CopyField(TIFFTAG_PLANARCONFIG, shortv);
+	CopyField(TIFFTAG_ROWSPERSTRIP, longv);
+	CopyField(TIFFTAG_XPOSITION, floatv);
+	CopyField(TIFFTAG_YPOSITION, floatv);
+	CopyField(TIFFTAG_IMAGEDEPTH, longv);
+	CopyField(TIFFTAG_TILEDEPTH, longv);
+	CopyField(TIFFTAG_SAMPLEFORMAT, shortv);
+	CopyField2(TIFFTAG_EXTRASAMPLES, shortv, shortav);
+	{ uint16 *red, *green, *blue;
+	  CopyField3(TIFFTAG_COLORMAP, red, green, blue);
+	}
+	{ uint16 shortv2;
+	  CopyField2(TIFFTAG_PAGENUMBER, shortv, shortv2);
+	}
+	CopyField(TIFFTAG_ARTIST, stringv);
+	CopyField(TIFFTAG_IMAGEDESCRIPTION, stringv);
+	CopyField(TIFFTAG_MAKE, stringv);
+	CopyField(TIFFTAG_MODEL, stringv);
+	CopyField(TIFFTAG_SOFTWARE, stringv);
+	CopyField(TIFFTAG_DATETIME, stringv);
+	CopyField(TIFFTAG_HOSTCOMPUTER, stringv);
+	CopyField(TIFFTAG_PAGENAME, stringv);
+	CopyField(TIFFTAG_DOCUMENTNAME, stringv);
+	CopyField(TIFFTAG_BADFAXLINES, longv);
+	CopyField(TIFFTAG_CLEANFAXDATA, longv);
+	CopyField(TIFFTAG_CONSECUTIVEBADFAXLINES, longv);
+	CopyField(TIFFTAG_FAXRECVPARAMS, longv);
+	CopyField(TIFFTAG_FAXRECVTIME, longv);
+	CopyField(TIFFTAG_FAXSUBADDRESS, stringv);
+	CopyField(TIFFTAG_FAXDCS, stringv);
+	if (TIFFIsTiled(in))
+		return (cpTiles(in, out));
+	else
+		return (cpStrips(in, out));
+}
+
+static int
+cpStrips(TIFF* in, TIFF* out)
+{
+	tmsize_t bufsize  = TIFFStripSize(in);
+	unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
+
+	if (buf) {
+		tstrip_t s, ns = TIFFNumberOfStrips(in);
+		uint64 *bytecounts;
+
+		if (!TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts)) {
+			fprintf(stderr, "tiffsplit: strip byte counts are missing\n");
+                        _TIFFfree(buf);
+			return (0);
+		}
+		for (s = 0; s < ns; s++) {
+			if (bytecounts[s] > (uint64)bufsize) {
+				buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[s]);
+				if (!buf)
+					return (0);
+				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);
+	}
+	return (0);
+}
+
+static int
+cpTiles(TIFF* in, TIFF* out)
+{
+	tmsize_t bufsize = TIFFTileSize(in);
+	unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
+
+	if (buf) {
+		ttile_t t, nt = TIFFNumberOfTiles(in);
+		uint64 *bytecounts;
+
+		if (!TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts)) {
+			fprintf(stderr, "tiffsplit: tile byte counts are missing\n");
+                        _TIFFfree(buf);
+			return (0);
+		}
+		for (t = 0; t < nt; t++) {
+			if (bytecounts[t] > (uint64) bufsize) {
+				buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[t]);
+				if (!buf)
+					return (0);
+				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);
+	}
+	return (0);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */