[wxWidgets.git] / src / tiff / tools / tiffcmp.c

/* $Id$ */

/*
 * Copyright (c) 1988-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 <stdlib.h>
#include <string.h>

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#include "tiffio.h"

#ifndef HAVE_GETOPT
extern int getopt(int, char**, char*);
#endif

static	int stopondiff = 1;
static	int stoponfirsttag = 1;
static	uint16 bitspersample = 1;
static	uint16 samplesperpixel = 1;
static	uint16 sampleformat = SAMPLEFORMAT_UINT;
static	uint32 imagewidth;
static	uint32 imagelength;

static	void usage(void);
static	int tiffcmp(TIFF*, TIFF*);
static	int cmptags(TIFF*, TIFF*);
static	int ContigCompare(int, uint32, unsigned char*, unsigned char*, int);
static	int SeparateCompare(int, int, uint32, unsigned char*, unsigned char*);
static	void PrintIntDiff(uint32, int, uint32, uint32, uint32);
static	void PrintFloatDiff(uint32, int, uint32, double, double);

static	void leof(const char*, uint32, int);

int
main(int argc, char* argv[])
{
	TIFF *tif1, *tif2;
	int c, dirnum;
	extern int optind;
	extern char* optarg;

	while ((c = getopt(argc, argv, "ltz:")) != -1)
		switch (c) {
		case 'l':
			stopondiff = 0;
			break;
		case 'z':
			stopondiff = atoi(optarg);
			break;
		case 't':
			stoponfirsttag = 0;
			break;
		case '?':
			usage();
			/*NOTREACHED*/
		}
	if (argc - optind < 2)
		usage();
	tif1 = TIFFOpen(argv[optind], "r");
	if (tif1 == NULL)
		return (-1);
	tif2 = TIFFOpen(argv[optind+1], "r");
	if (tif2 == NULL)
		return (-2);
	dirnum = 0;
	while (tiffcmp(tif1, tif2)) {
		if (!TIFFReadDirectory(tif1)) {
			if (!TIFFReadDirectory(tif2))
				break;
			printf("No more directories for %s\n",
			    TIFFFileName(tif1));
			return (1);
		} else if (!TIFFReadDirectory(tif2)) {
			printf("No more directories for %s\n",
			    TIFFFileName(tif2));
			return (1);
		}
		printf("Directory %d:\n", ++dirnum);
	}

	TIFFClose(tif1);
	TIFFClose(tif2);
	return (0);
}

char* stuff[] = {
"usage: tiffcmp [options] file1 file2",
"where options are:",
" -l		list each byte of image data that differs between the files",
" -z #		list specified number of bytes that differs between the files",
" -t		ignore any differences in directory tags",
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);
}

#define	checkEOF(tif, row, sample) { \
	leof(TIFFFileName(tif), row, sample); \
	goto bad; \
}

static	int CheckShortTag(TIFF*, TIFF*, int, char*);
static	int CheckShort2Tag(TIFF*, TIFF*, int, char*);
static	int CheckShortArrayTag(TIFF*, TIFF*, int, char*);
static	int CheckLongTag(TIFF*, TIFF*, int, char*);
static	int CheckFloatTag(TIFF*, TIFF*, int, char*);
static	int CheckStringTag(TIFF*, TIFF*, int, char*);

static int
tiffcmp(TIFF* tif1, TIFF* tif2)
{
	uint16 config1, config2;
	tsize_t size1;
	uint32 row;
	tsample_t s;
	unsigned char *buf1, *buf2;

	if (!CheckShortTag(tif1, tif2, TIFFTAG_BITSPERSAMPLE, "BitsPerSample"))
		return (0);
	if (!CheckShortTag(tif1, tif2, TIFFTAG_SAMPLESPERPIXEL, "SamplesPerPixel"))
		return (0);
	if (!CheckLongTag(tif1, tif2, TIFFTAG_IMAGEWIDTH, "ImageWidth"))
		return (0);
	if (!cmptags(tif1, tif2))
		return (1);
	(void) TIFFGetField(tif1, TIFFTAG_BITSPERSAMPLE, &bitspersample);
	(void) TIFFGetField(tif1, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
	(void) TIFFGetField(tif1, TIFFTAG_SAMPLEFORMAT, &sampleformat);
	(void) TIFFGetField(tif1, TIFFTAG_IMAGEWIDTH, &imagewidth);
	(void) TIFFGetField(tif1, TIFFTAG_IMAGELENGTH, &imagelength);
	(void) TIFFGetField(tif1, TIFFTAG_PLANARCONFIG, &config1);
	(void) TIFFGetField(tif2, TIFFTAG_PLANARCONFIG, &config2);
	buf1 = (unsigned char *)_TIFFmalloc(size1 = TIFFScanlineSize(tif1));
	buf2 = (unsigned char *)_TIFFmalloc(TIFFScanlineSize(tif2));
	if (buf1 == NULL || buf2 == NULL) {
		fprintf(stderr, "No space for scanline buffers\n");
		exit(-1);
	}
	if (config1 != config2 && bitspersample != 8 && samplesperpixel > 1) {
		fprintf(stderr,
"Can't handle different planar configuration w/ different bits/sample\n");
		goto bad;
	}
#define	pack(a,b)	((a)<<8)|(b)
	switch (pack(config1, config2)) {
	case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG):
		for (row = 0; row < imagelength; row++) {
			if (TIFFReadScanline(tif2, buf2, row, 0) < 0)
				checkEOF(tif2, row, -1)
			for (s = 0; s < samplesperpixel; s++) {
				if (TIFFReadScanline(tif1, buf1, row, s) < 0)
					checkEOF(tif1, row, s)
				if (SeparateCompare(1, s, row, buf2, buf1) < 0)
					goto bad1;
			}
		}
		break;
	case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE):
		for (row = 0; row < imagelength; row++) {
			if (TIFFReadScanline(tif1, buf1, row, 0) < 0)
				checkEOF(tif1, row, -1)
			for (s = 0; s < samplesperpixel; s++) {
				if (TIFFReadScanline(tif2, buf2, row, s) < 0)
					checkEOF(tif2, row, s)
				if (SeparateCompare(0, s, row, buf1, buf2) < 0)
					goto bad1;
			}
		}
		break;
	case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE):
		for (s = 0; s < samplesperpixel; s++)
			for (row = 0; row < imagelength; row++) {
				if (TIFFReadScanline(tif1, buf1, row, s) < 0)
					checkEOF(tif1, row, s)
				if (TIFFReadScanline(tif2, buf2, row, s) < 0)
					checkEOF(tif2, row, s)
				if (ContigCompare(s, row, buf1, buf2, size1) < 0)
					goto bad1;
			}
		break;
	case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG):
		for (row = 0; row < imagelength; row++) {
			if (TIFFReadScanline(tif1, buf1, row, 0) < 0)
				checkEOF(tif1, row, -1)
			if (TIFFReadScanline(tif2, buf2, row, 0) < 0)
				checkEOF(tif2, row, -1)
			if (ContigCompare(-1, row, buf1, buf2, size1) < 0)
				goto bad1;
		}
		break;
	}
	if (buf1) _TIFFfree(buf1);
	if (buf2) _TIFFfree(buf2);
	return (1);
bad:
	if (stopondiff)
		exit(1);
bad1:
	if (buf1) _TIFFfree(buf1);
	if (buf2) _TIFFfree(buf2);
	return (0);
}

#define	CmpShortField(tag, name) \
	if (!CheckShortTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
#define	CmpShortField2(tag, name) \
	if (!CheckShort2Tag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
#define	CmpLongField(tag, name) \
	if (!CheckLongTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
#define	CmpFloatField(tag, name) \
	if (!CheckFloatTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
#define	CmpStringField(tag, name) \
	if (!CheckStringTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
#define	CmpShortArrayField(tag, name) \
	if (!CheckShortArrayTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)

static int
cmptags(TIFF* tif1, TIFF* tif2)
{
	CmpLongField(TIFFTAG_SUBFILETYPE,	"SubFileType");
	CmpLongField(TIFFTAG_IMAGEWIDTH,	"ImageWidth");
	CmpLongField(TIFFTAG_IMAGELENGTH,	"ImageLength");
	CmpShortField(TIFFTAG_BITSPERSAMPLE,	"BitsPerSample");
	CmpShortField(TIFFTAG_COMPRESSION,	"Compression");
	CmpShortField(TIFFTAG_PREDICTOR,	"Predictor");
	CmpShortField(TIFFTAG_PHOTOMETRIC,	"PhotometricInterpretation");
	CmpShortField(TIFFTAG_THRESHHOLDING,	"Thresholding");
	CmpShortField(TIFFTAG_FILLORDER,	"FillOrder");
	CmpShortField(TIFFTAG_ORIENTATION,	"Orientation");
	CmpShortField(TIFFTAG_SAMPLESPERPIXEL,	"SamplesPerPixel");
	CmpShortField(TIFFTAG_MINSAMPLEVALUE,	"MinSampleValue");
	CmpShortField(TIFFTAG_MAXSAMPLEVALUE,	"MaxSampleValue");
	CmpShortField(TIFFTAG_SAMPLEFORMAT,	"SampleFormat");
	CmpFloatField(TIFFTAG_XRESOLUTION,	"XResolution");
	CmpFloatField(TIFFTAG_YRESOLUTION,	"YResolution");
	CmpLongField(TIFFTAG_GROUP3OPTIONS,	"Group3Options");
	CmpLongField(TIFFTAG_GROUP4OPTIONS,	"Group4Options");
	CmpShortField(TIFFTAG_RESOLUTIONUNIT,	"ResolutionUnit");
	CmpShortField(TIFFTAG_PLANARCONFIG,	"PlanarConfiguration");
	CmpLongField(TIFFTAG_ROWSPERSTRIP,	"RowsPerStrip");
	CmpFloatField(TIFFTAG_XPOSITION,	"XPosition");
	CmpFloatField(TIFFTAG_YPOSITION,	"YPosition");
	CmpShortField(TIFFTAG_GRAYRESPONSEUNIT, "GrayResponseUnit");
	CmpShortField(TIFFTAG_COLORRESPONSEUNIT, "ColorResponseUnit");
#ifdef notdef
	{ uint16 *graycurve;
	  CmpField(TIFFTAG_GRAYRESPONSECURVE, graycurve);
	}
	{ uint16 *red, *green, *blue;
	  CmpField3(TIFFTAG_COLORRESPONSECURVE, red, green, blue);
	}
	{ uint16 *red, *green, *blue;
	  CmpField3(TIFFTAG_COLORMAP, red, green, blue);
	}
#endif
	CmpShortField2(TIFFTAG_PAGENUMBER,	"PageNumber");
	CmpStringField(TIFFTAG_ARTIST,		"Artist");
	CmpStringField(TIFFTAG_IMAGEDESCRIPTION,"ImageDescription");
	CmpStringField(TIFFTAG_MAKE,		"Make");
	CmpStringField(TIFFTAG_MODEL,		"Model");
	CmpStringField(TIFFTAG_SOFTWARE,	"Software");
	CmpStringField(TIFFTAG_DATETIME,	"DateTime");
	CmpStringField(TIFFTAG_HOSTCOMPUTER,	"HostComputer");
	CmpStringField(TIFFTAG_PAGENAME,	"PageName");
	CmpStringField(TIFFTAG_DOCUMENTNAME,	"DocumentName");
	CmpShortField(TIFFTAG_MATTEING,		"Matteing");
	CmpShortArrayField(TIFFTAG_EXTRASAMPLES,"ExtraSamples");
	return (1);
}

static int
ContigCompare(int sample, uint32 row,
	      unsigned char* p1, unsigned char* p2, int size)
{
    uint32 pix;
    int ppb = 8 / bitspersample;
    int	 samples_to_test;

    if (memcmp(p1, p2, size) == 0)
        return 0;

    samples_to_test = (sample == -1) ? samplesperpixel : 1;

    switch (bitspersample) {
      case 1: case 2: case 4: case 8: 
      {
          unsigned char *pix1 = p1, *pix2 = p2;

          for (pix = 0; pix < imagewidth; pix += ppb) {
              int		s;

              for(s = 0; s < samples_to_test; s++) {
                  if (*pix1 != *pix2) {
                      if( sample == -1 )
                          PrintIntDiff(row, s, pix, *pix1, *pix2);
                      else
                          PrintIntDiff(row, sample, pix, *pix1, *pix2);
                  }

                  pix1++;
                  pix2++;
              }
          }
          break;
      }
      case 16: 
      {
          uint16 *pix1 = (uint16 *)p1, *pix2 = (uint16 *)p2;

          for (pix = 0; pix < imagewidth; pix++) {
              int	s;

              for(s = 0; s < samples_to_test; s++) {
                  if (*pix1 != *pix2)
                      PrintIntDiff(row, sample, pix, *pix1, *pix2);
                        
                  pix1++;
                  pix2++;
              }
          }
          break;
      }
      case 32: 
	if (sampleformat == SAMPLEFORMAT_UINT
	    || sampleformat == SAMPLEFORMAT_INT) {
		uint32 *pix1 = (uint32 *)p1, *pix2 = (uint32 *)p2;

		for (pix = 0; pix < imagewidth; pix++) {
			int	s;

			for(s = 0; s < samples_to_test; s++) {
				if (*pix1 != *pix2) {
					PrintIntDiff(row, sample, pix,
						     *pix1, *pix2);
				}
                        
				pix1++;
				pix2++;
			}
		}
	} else if (sampleformat == SAMPLEFORMAT_IEEEFP) {
		float *pix1 = (float *)p1, *pix2 = (float *)p2;

		for (pix = 0; pix < imagewidth; pix++) {
			int	s;

			for(s = 0; s < samples_to_test; s++) {
				if (*pix1 != *pix2) {
					PrintFloatDiff(row, sample, pix,
						       *pix1, *pix2);
				}
                        
				pix1++;
				pix2++;
			}
		}
	} else {
		  fprintf(stderr, "Sample format %d is not supported.\n",
			  sampleformat);
		  return -1;
	}
        break;
      default:
	fprintf(stderr, "Bit depth %d is not supported.\n", bitspersample);
	return -1;
    }

    return 0;
}

static void
PrintIntDiff(uint32 row, int sample, uint32 pix, uint32 w1, uint32 w2)
{
	if (sample < 0)
		sample = 0;
	switch (bitspersample) {
	case 1:
	case 2:
	case 4:
	    {
		int32 mask1, mask2, s;

		mask1 =  ~((-1) << bitspersample);
		s = (8 - bitspersample);
		mask2 = mask1 << s;
		for (; mask2 && pix < imagewidth;
		     mask2 >>= bitspersample, s -= bitspersample, pix++) {
			if ((w1 & mask2) ^ (w2 & mask2)) {
				printf(
			"Scanline %lu, pixel %lu, sample %d: %01x %01x\n",
	    				(unsigned long) row,
					(unsigned long) pix,
					sample,
					(unsigned int)((w1 >> s) & mask1),
					(unsigned int)((w2 >> s) & mask1));
				if (--stopondiff == 0)
					exit(1);
			}
		}
		break;
	    }
	case 8: 
		printf("Scanline %lu, pixel %lu, sample %d: %02x %02x\n",
		       (unsigned long) row, (unsigned long) pix, sample,
		       (unsigned int) w1, (unsigned int) w2);
		if (--stopondiff == 0)
			exit(1);
		break;
	case 16:
		printf("Scanline %lu, pixel %lu, sample %d: %04x %04x\n",
		    (unsigned long) row, (unsigned long) pix, sample,
		    (unsigned int) w1, (unsigned int) w2);
		if (--stopondiff == 0)
			exit(1);
		break;
	case 32:
		printf("Scanline %lu, pixel %lu, sample %d: %08x %08x\n",
		    (unsigned long) row, (unsigned long) pix, sample,
		    (unsigned int) w1, (unsigned int) w2);
		if (--stopondiff == 0)
			exit(1);
		break;
	default:
		break;
	}
}

static void
PrintFloatDiff(uint32 row, int sample, uint32 pix, double w1, double w2)
{
	if (sample < 0)
		sample = 0;
	switch (bitspersample) {
	case 32: 
		printf("Scanline %lu, pixel %lu, sample %d: %g %g\n",
		    (long) row, (long) pix, sample, w1, w2);
		if (--stopondiff == 0)
			exit(1);
		break;
	default:
		break;
	}
}

static int
SeparateCompare(int reversed, int sample, uint32 row,
		unsigned char* cp1, unsigned char* p2)
{
	uint32 npixels = imagewidth;
	int pixel;

	cp1 += sample;
	for (pixel = 0; npixels-- > 0; pixel++, cp1 += samplesperpixel, p2++) {
		if (*cp1 != *p2) {
			printf("Scanline %lu, pixel %lu, sample %ld: ",
			    (long) row, (long) pixel, (long) sample);
			if (reversed)
				printf("%02x %02x\n", *p2, *cp1);
			else
				printf("%02x %02x\n", *cp1, *p2);
			if (--stopondiff == 0)
				exit(1);
		}
	}

	return 0;
}

static int
checkTag(TIFF* tif1, TIFF* tif2, int tag, char* name, void* p1, void* p2)
{

	if (TIFFGetField(tif1, tag, p1)) {
		if (!TIFFGetField(tif2, tag, p2)) {
			printf("%s tag appears only in %s\n",
			    name, TIFFFileName(tif1));
			return (0);
		}
		return (1);
	} else if (TIFFGetField(tif2, tag, p2)) {
		printf("%s tag appears only in %s\n", name, TIFFFileName(tif2));
		return (0);
	}
	return (-1);
}

#define	CHECK(cmp, fmt) {				\
	switch (checkTag(tif1,tif2,tag,name,&v1,&v2)) {	\
	case 1:	if (cmp)				\
	case -1:	return (1);			\
		printf(fmt, name, v1, v2);		\
	}						\
	return (0);					\
}

static int
CheckShortTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
{
	uint16 v1, v2;
	CHECK(v1 == v2, "%s: %u %u\n");
}

static int
CheckShort2Tag(TIFF* tif1, TIFF* tif2, int tag, char* name)
{
	uint16 v11, v12, v21, v22;

	if (TIFFGetField(tif1, tag, &v11, &v12)) {
		if (!TIFFGetField(tif2, tag, &v21, &v22)) {
			printf("%s tag appears only in %s\n",
			    name, TIFFFileName(tif1));
			return (0);
		}
		if (v11 == v21 && v12 == v22)
			return (1);
		printf("%s: <%u,%u> <%u,%u>\n", name, v11, v12, v21, v22);
	} else if (TIFFGetField(tif2, tag, &v21, &v22))
		printf("%s tag appears only in %s\n", name, TIFFFileName(tif2));
	else
		return (1);
	return (0);
}

static int
CheckShortArrayTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
{
	uint16 n1, *a1;
	uint16 n2, *a2;

	if (TIFFGetField(tif1, tag, &n1, &a1)) {
		if (!TIFFGetField(tif2, tag, &n2, &a2)) {
			printf("%s tag appears only in %s\n",
			    name, TIFFFileName(tif1));
			return (0);
		}
		if (n1 == n2) {
			char* sep;
			uint16 i;

			if (memcmp(a1, a2, n1 * sizeof(uint16)) == 0)
				return (1);
			printf("%s: value mismatch, <%u:", name, n1);
			sep = "";
			for (i = 0; i < n1; i++)
				printf("%s%u", sep, a1[i]), sep = ",";
			printf("> and <%u: ", n2);
			sep = "";
			for (i = 0; i < n2; i++)
				printf("%s%u", sep, a2[i]), sep = ",";
			printf(">\n");
		} else
			printf("%s: %u items in %s, %u items in %s", name,
			    n1, TIFFFileName(tif1),
			    n2, TIFFFileName(tif2)
			);
	} else if (TIFFGetField(tif2, tag, &n2, &a2))
		printf("%s tag appears only in %s\n", name, TIFFFileName(tif2));
	else
		return (1);
	return (0);
}

static int
CheckLongTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
{
	uint32 v1, v2;
	CHECK(v1 == v2, "%s: %u %u\n");
}

static int
CheckFloatTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
{
	float v1, v2;
	CHECK(v1 == v2, "%s: %g %g\n");
}

static int
CheckStringTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
{
	char *v1, *v2;
	CHECK(strcmp(v1, v2) == 0, "%s: \"%s\" \"%s\"\n");
}

static void
leof(const char* name, uint32 row, int s)
{

	printf("%s: EOF at scanline %lu", name, (unsigned long)row);
	if (s >= 0)
		printf(", sample %d", s);
	printf("\n");
}

/* vim: set ts=8 sts=8 sw=8 noet: */
Commit	Line	Data
8414a40c VZ	1	/* $Id$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-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
	33	#ifdef HAVE_UNISTD_H
	34	# include <unistd.h>
	35	#endif
	36
	37	#include "tiffio.h"
	38
	39	#ifndef HAVE_GETOPT
	40	extern int getopt(int, char*, char);
	41	#endif
	42
	43	static int stopondiff = 1;
	44	static int stoponfirsttag = 1;
	45	static uint16 bitspersample = 1;
	46	static uint16 samplesperpixel = 1;
	47	static uint16 sampleformat = SAMPLEFORMAT_UINT;
	48	static uint32 imagewidth;
	49	static uint32 imagelength;
	50
	51	static void usage(void);
	52	static int tiffcmp(TIFF, TIFF);
	53	static int cmptags(TIFF, TIFF);
	54	static int ContigCompare(int, uint32, unsigned char, unsigned char, int);
	55	static int SeparateCompare(int, int, uint32, unsigned char, unsigned char);
	56	static void PrintIntDiff(uint32, int, uint32, uint32, uint32);
	57	static void PrintFloatDiff(uint32, int, uint32, double, double);
	58
	59	static void leof(const char*, uint32, int);
	60
	61	int
	62	main(int argc, char* argv[])
	63	{
	64	TIFF tif1, tif2;
65	int c, dirnum;
66	extern int optind;
67	extern char* optarg;
68
69	while ((c = getopt(argc, argv, "ltz:")) != -1)
70	switch (c) {
71	case 'l':
72	stopondiff = 0;
73	break;
74	case 'z':
75	stopondiff = atoi(optarg);
76	break;
77	case 't':
78	stoponfirsttag = 0;
79	break;
80	case '?':
81	usage();
82	/NOTREACHED/
83	}
84	if (argc - optind < 2)
85	usage();
86	tif1 = TIFFOpen(argv[optind], "r");
87	if (tif1 == NULL)
88	return (-1);
89	tif2 = TIFFOpen(argv[optind+1], "r");
90	if (tif2 == NULL)
91	return (-2);
92	dirnum = 0;
93	while (tiffcmp(tif1, tif2)) {
94	if (!TIFFReadDirectory(tif1)) {
95	if (!TIFFReadDirectory(tif2))
96	break;
97	printf("No more directories for %s\n",
98	TIFFFileName(tif1));
99	return (1);
100	} else if (!TIFFReadDirectory(tif2)) {
101	printf("No more directories for %s\n",
102	TIFFFileName(tif2));
103	return (1);
104	}
105	printf("Directory %d:\n", ++dirnum);
106	}
107
108	TIFFClose(tif1);
109	TIFFClose(tif2);
110	return (0);
111	}
112
113	char* stuff[] = {
114	"usage: tiffcmp [options] file1 file2",
115	"where options are:",
116	" -l list each byte of image data that differs between the files",
117	" -z # list specified number of bytes that differs between the files",
118	" -t ignore any differences in directory tags",
119	NULL
120	};
121
122	static void
123	usage(void)
124	{
125	char buf[BUFSIZ];
126	int i;
127
128	setbuf(stderr, buf);
129	fprintf(stderr, "%s\n\n", TIFFGetVersion());
130	for (i = 0; stuff[i] != NULL; i++)
131	fprintf(stderr, "%s\n", stuff[i]);
132	exit(-1);
133	}
134
135	#define checkEOF(tif, row, sample) { \
136	leof(TIFFFileName(tif), row, sample); \
137	goto bad; \
138	}
139
140	static int CheckShortTag(TIFF, TIFF, int, char*);
141	static int CheckShort2Tag(TIFF, TIFF, int, char*);
142	static int CheckShortArrayTag(TIFF, TIFF, int, char*);
143	static int CheckLongTag(TIFF, TIFF, int, char*);
144	static int CheckFloatTag(TIFF, TIFF, int, char*);
145	static int CheckStringTag(TIFF, TIFF, int, char*);
146
147	static int
148	tiffcmp(TIFF* tif1, TIFF* tif2)
149	{
150	uint16 config1, config2;
151	tsize_t size1;
152	uint32 row;
153	tsample_t s;
154	unsigned char buf1, buf2;
155
156	if (!CheckShortTag(tif1, tif2, TIFFTAG_BITSPERSAMPLE, "BitsPerSample"))
157	return (0);
158	if (!CheckShortTag(tif1, tif2, TIFFTAG_SAMPLESPERPIXEL, "SamplesPerPixel"))
159	return (0);
160	if (!CheckLongTag(tif1, tif2, TIFFTAG_IMAGEWIDTH, "ImageWidth"))
161	return (0);
162	if (!cmptags(tif1, tif2))
163	return (1);
164	(void) TIFFGetField(tif1, TIFFTAG_BITSPERSAMPLE, &bitspersample);
165	(void) TIFFGetField(tif1, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
166	(void) TIFFGetField(tif1, TIFFTAG_SAMPLEFORMAT, &sampleformat);
167	(void) TIFFGetField(tif1, TIFFTAG_IMAGEWIDTH, &imagewidth);
168	(void) TIFFGetField(tif1, TIFFTAG_IMAGELENGTH, &imagelength);
169	(void) TIFFGetField(tif1, TIFFTAG_PLANARCONFIG, &config1);
170	(void) TIFFGetField(tif2, TIFFTAG_PLANARCONFIG, &config2);
171	buf1 = (unsigned char *)_TIFFmalloc(size1 = TIFFScanlineSize(tif1));
172	buf2 = (unsigned char *)_TIFFmalloc(TIFFScanlineSize(tif2));
173	if (buf1 == NULL \|\| buf2 == NULL) {
174	fprintf(stderr, "No space for scanline buffers\n");
175	exit(-1);
176	}
177	if (config1 != config2 && bitspersample != 8 && samplesperpixel > 1) {
178	fprintf(stderr,
179	"Can't handle different planar configuration w/ different bits/sample\n");
180	goto bad;
181	}
182	#define pack(a,b) ((a)<<8)\|(b)
183	switch (pack(config1, config2)) {
184	case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_CONTIG):
185	for (row = 0; row < imagelength; row++) {
186	if (TIFFReadScanline(tif2, buf2, row, 0) < 0)
187	checkEOF(tif2, row, -1)
188	for (s = 0; s < samplesperpixel; s++) {
189	if (TIFFReadScanline(tif1, buf1, row, s) < 0)
190	checkEOF(tif1, row, s)
191	if (SeparateCompare(1, s, row, buf2, buf1) < 0)
192	goto bad1;
193	}
194	}
195	break;
196	case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_SEPARATE):
197	for (row = 0; row < imagelength; row++) {
198	if (TIFFReadScanline(tif1, buf1, row, 0) < 0)
199	checkEOF(tif1, row, -1)
200	for (s = 0; s < samplesperpixel; s++) {
201	if (TIFFReadScanline(tif2, buf2, row, s) < 0)
202	checkEOF(tif2, row, s)
203	if (SeparateCompare(0, s, row, buf1, buf2) < 0)
204	goto bad1;
205	}
206	}
207	break;
208	case pack(PLANARCONFIG_SEPARATE, PLANARCONFIG_SEPARATE):
209	for (s = 0; s < samplesperpixel; s++)
210	for (row = 0; row < imagelength; row++) {
211	if (TIFFReadScanline(tif1, buf1, row, s) < 0)
212	checkEOF(tif1, row, s)
213	if (TIFFReadScanline(tif2, buf2, row, s) < 0)
214	checkEOF(tif2, row, s)
215	if (ContigCompare(s, row, buf1, buf2, size1) < 0)
216	goto bad1;
217	}
218	break;
219	case pack(PLANARCONFIG_CONTIG, PLANARCONFIG_CONTIG):
220	for (row = 0; row < imagelength; row++) {
221	if (TIFFReadScanline(tif1, buf1, row, 0) < 0)
222	checkEOF(tif1, row, -1)
223	if (TIFFReadScanline(tif2, buf2, row, 0) < 0)
224	checkEOF(tif2, row, -1)
225	if (ContigCompare(-1, row, buf1, buf2, size1) < 0)
226	goto bad1;
227	}
228	break;
229	}
230	if (buf1) _TIFFfree(buf1);
231	if (buf2) _TIFFfree(buf2);
232	return (1);
233	bad:
234	if (stopondiff)
235	exit(1);
236	bad1:
237	if (buf1) _TIFFfree(buf1);
238	if (buf2) _TIFFfree(buf2);
239	return (0);
240	}
241
242	#define CmpShortField(tag, name) \
243	if (!CheckShortTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
244	#define CmpShortField2(tag, name) \
245	if (!CheckShort2Tag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
246	#define CmpLongField(tag, name) \
247	if (!CheckLongTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
248	#define CmpFloatField(tag, name) \
249	if (!CheckFloatTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
250	#define CmpStringField(tag, name) \
251	if (!CheckStringTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
252	#define CmpShortArrayField(tag, name) \
253	if (!CheckShortArrayTag(tif1, tif2, tag, name) && stoponfirsttag) return (0)
254
255	static int
256	cmptags(TIFF* tif1, TIFF* tif2)
257	{
258	CmpLongField(TIFFTAG_SUBFILETYPE, "SubFileType");
259	CmpLongField(TIFFTAG_IMAGEWIDTH, "ImageWidth");
260	CmpLongField(TIFFTAG_IMAGELENGTH, "ImageLength");
261	CmpShortField(TIFFTAG_BITSPERSAMPLE, "BitsPerSample");
262	CmpShortField(TIFFTAG_COMPRESSION, "Compression");
263	CmpShortField(TIFFTAG_PREDICTOR, "Predictor");
264	CmpShortField(TIFFTAG_PHOTOMETRIC, "PhotometricInterpretation");
265	CmpShortField(TIFFTAG_THRESHHOLDING, "Thresholding");
266	CmpShortField(TIFFTAG_FILLORDER, "FillOrder");
267	CmpShortField(TIFFTAG_ORIENTATION, "Orientation");
268	CmpShortField(TIFFTAG_SAMPLESPERPIXEL, "SamplesPerPixel");
269	CmpShortField(TIFFTAG_MINSAMPLEVALUE, "MinSampleValue");
270	CmpShortField(TIFFTAG_MAXSAMPLEVALUE, "MaxSampleValue");
271	CmpShortField(TIFFTAG_SAMPLEFORMAT, "SampleFormat");
272	CmpFloatField(TIFFTAG_XRESOLUTION, "XResolution");
273	CmpFloatField(TIFFTAG_YRESOLUTION, "YResolution");
274	CmpLongField(TIFFTAG_GROUP3OPTIONS, "Group3Options");
275	CmpLongField(TIFFTAG_GROUP4OPTIONS, "Group4Options");
276	CmpShortField(TIFFTAG_RESOLUTIONUNIT, "ResolutionUnit");
277	CmpShortField(TIFFTAG_PLANARCONFIG, "PlanarConfiguration");
278	CmpLongField(TIFFTAG_ROWSPERSTRIP, "RowsPerStrip");
279	CmpFloatField(TIFFTAG_XPOSITION, "XPosition");
280	CmpFloatField(TIFFTAG_YPOSITION, "YPosition");
281	CmpShortField(TIFFTAG_GRAYRESPONSEUNIT, "GrayResponseUnit");
282	CmpShortField(TIFFTAG_COLORRESPONSEUNIT, "ColorResponseUnit");
283	#ifdef notdef
284	{ uint16 *graycurve;
285	CmpField(TIFFTAG_GRAYRESPONSECURVE, graycurve);
286	}
287	{ uint16 red, green, *blue;
288	CmpField3(TIFFTAG_COLORRESPONSECURVE, red, green, blue);
289	}
290	{ uint16 red, green, *blue;
291	CmpField3(TIFFTAG_COLORMAP, red, green, blue);
292	}
293	#endif
294	CmpShortField2(TIFFTAG_PAGENUMBER, "PageNumber");
295	CmpStringField(TIFFTAG_ARTIST, "Artist");
296	CmpStringField(TIFFTAG_IMAGEDESCRIPTION,"ImageDescription");
297	CmpStringField(TIFFTAG_MAKE, "Make");
298	CmpStringField(TIFFTAG_MODEL, "Model");
299	CmpStringField(TIFFTAG_SOFTWARE, "Software");
300	CmpStringField(TIFFTAG_DATETIME, "DateTime");
301	CmpStringField(TIFFTAG_HOSTCOMPUTER, "HostComputer");
302	CmpStringField(TIFFTAG_PAGENAME, "PageName");
303	CmpStringField(TIFFTAG_DOCUMENTNAME, "DocumentName");
304	CmpShortField(TIFFTAG_MATTEING, "Matteing");
305	CmpShortArrayField(TIFFTAG_EXTRASAMPLES,"ExtraSamples");
306	return (1);
307	}
308
309	static int
310	ContigCompare(int sample, uint32 row,
311	unsigned char* p1, unsigned char* p2, int size)
312	{
313	uint32 pix;
314	int ppb = 8 / bitspersample;
315	int samples_to_test;
316
317	if (memcmp(p1, p2, size) == 0)
318	return 0;
319
320	samples_to_test = (sample == -1) ? samplesperpixel : 1;
321
322	switch (bitspersample) {
323	case 1: case 2: case 4: case 8:
324	{
325	unsigned char pix1 = p1, pix2 = p2;
326
327	for (pix = 0; pix < imagewidth; pix += ppb) {
328	int s;
329
330	for(s = 0; s < samples_to_test; s++) {
331	if (pix1 != pix2) {
332	if( sample == -1 )
333	PrintIntDiff(row, s, pix, pix1, pix2);
334	else
335	PrintIntDiff(row, sample, pix, pix1, pix2);
336	}
337
338	pix1++;
339	pix2++;
340	}
341	}
342	break;
343	}
344	case 16:
345	{
346	uint16 pix1 = (uint16 )p1, pix2 = (uint16 )p2;
347
348	for (pix = 0; pix < imagewidth; pix++) {
349	int s;
350
351	for(s = 0; s < samples_to_test; s++) {
352	if (pix1 != pix2)
353	PrintIntDiff(row, sample, pix, pix1, pix2);
354
355	pix1++;
356	pix2++;
357	}
358	}
359	break;
360	}
361	case 32:
362	if (sampleformat == SAMPLEFORMAT_UINT
363	\|\| sampleformat == SAMPLEFORMAT_INT) {
364	uint32 pix1 = (uint32 )p1, pix2 = (uint32 )p2;
365
366	for (pix = 0; pix < imagewidth; pix++) {
367	int s;
368
369	for(s = 0; s < samples_to_test; s++) {
370	if (pix1 != pix2) {
371	PrintIntDiff(row, sample, pix,
372	pix1, pix2);
373	}
374
375	pix1++;
376	pix2++;
377	}
378	}
379	} else if (sampleformat == SAMPLEFORMAT_IEEEFP) {
380	float pix1 = (float )p1, pix2 = (float )p2;
381
382	for (pix = 0; pix < imagewidth; pix++) {
383	int s;
384
385	for(s = 0; s < samples_to_test; s++) {
386	if (pix1 != pix2) {
387	PrintFloatDiff(row, sample, pix,
388	pix1, pix2);
389	}
390
391	pix1++;
392	pix2++;
393	}
394	}
395	} else {
396	fprintf(stderr, "Sample format %d is not supported.\n",
397	sampleformat);
398	return -1;
399	}
400	break;
401	default:
402	fprintf(stderr, "Bit depth %d is not supported.\n", bitspersample);
403	return -1;
404	}
405
406	return 0;
407	}
408
409	static void
410	PrintIntDiff(uint32 row, int sample, uint32 pix, uint32 w1, uint32 w2)
411	{
412	if (sample < 0)
413	sample = 0;
414	switch (bitspersample) {
415	case 1:
416	case 2:
417	case 4:
418	{
419	int32 mask1, mask2, s;
420
421	mask1 = ~((-1) << bitspersample);
422	s = (8 - bitspersample);
423	mask2 = mask1 << s;
424	for (; mask2 && pix < imagewidth;
425	mask2 >>= bitspersample, s -= bitspersample, pix++) {
426	if ((w1 & mask2) ^ (w2 & mask2)) {
427	printf(
428	"Scanline %lu, pixel %lu, sample %d: %01x %01x\n",
429	(unsigned long) row,
430	(unsigned long) pix,
431	sample,
432	(unsigned int)((w1 >> s) & mask1),
433	(unsigned int)((w2 >> s) & mask1));
434	if (--stopondiff == 0)
435	exit(1);
436	}
437	}
438	break;
439	}
440	case 8:
441	printf("Scanline %lu, pixel %lu, sample %d: %02x %02x\n",
442	(unsigned long) row, (unsigned long) pix, sample,
443	(unsigned int) w1, (unsigned int) w2);
444	if (--stopondiff == 0)
445	exit(1);
446	break;
447	case 16:
448	printf("Scanline %lu, pixel %lu, sample %d: %04x %04x\n",
449	(unsigned long) row, (unsigned long) pix, sample,
450	(unsigned int) w1, (unsigned int) w2);
451	if (--stopondiff == 0)
452	exit(1);
453	break;
454	case 32:
455	printf("Scanline %lu, pixel %lu, sample %d: %08x %08x\n",
456	(unsigned long) row, (unsigned long) pix, sample,
457	(unsigned int) w1, (unsigned int) w2);
458	if (--stopondiff == 0)
459	exit(1);
460	break;
461	default:
462	break;
463	}
464	}
465
466	static void
467	PrintFloatDiff(uint32 row, int sample, uint32 pix, double w1, double w2)
468	{
469	if (sample < 0)
470	sample = 0;
471	switch (bitspersample) {
472	case 32:
473	printf("Scanline %lu, pixel %lu, sample %d: %g %g\n",
474	(long) row, (long) pix, sample, w1, w2);
475	if (--stopondiff == 0)
476	exit(1);
477	break;
478	default:
479	break;
480	}
481	}
482
483	static int
484	SeparateCompare(int reversed, int sample, uint32 row,
485	unsigned char* cp1, unsigned char* p2)
486	{
487	uint32 npixels = imagewidth;
488	int pixel;
489
490	cp1 += sample;
491	for (pixel = 0; npixels-- > 0; pixel++, cp1 += samplesperpixel, p2++) {
492	if (cp1 != p2) {
493	printf("Scanline %lu, pixel %lu, sample %ld: ",
494	(long) row, (long) pixel, (long) sample);
495	if (reversed)
496	printf("%02x %02x\n", p2, cp1);
497	else
498	printf("%02x %02x\n", cp1, p2);
499	if (--stopondiff == 0)
500	exit(1);
501	}
502	}
503
504	return 0;
505	}
506
507	static int
508	checkTag(TIFF* tif1, TIFF* tif2, int tag, char* name, void* p1, void* p2)
509	{
510
511	if (TIFFGetField(tif1, tag, p1)) {
512	if (!TIFFGetField(tif2, tag, p2)) {
513	printf("%s tag appears only in %s\n",
514	name, TIFFFileName(tif1));
515	return (0);
516	}
517	return (1);
518	} else if (TIFFGetField(tif2, tag, p2)) {
519	printf("%s tag appears only in %s\n", name, TIFFFileName(tif2));
520	return (0);
521	}
522	return (-1);
523	}
524
525	#define CHECK(cmp, fmt) { \
526	switch (checkTag(tif1,tif2,tag,name,&v1,&v2)) { \
527	case 1: if (cmp) \
528	case -1: return (1); \
529	printf(fmt, name, v1, v2); \
530	} \
531	return (0); \
532	}
533
534	static int
535	CheckShortTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
536	{
537	uint16 v1, v2;
538	CHECK(v1 == v2, "%s: %u %u\n");
539	}
540
541	static int
542	CheckShort2Tag(TIFF* tif1, TIFF* tif2, int tag, char* name)
543	{
544	uint16 v11, v12, v21, v22;
545
546	if (TIFFGetField(tif1, tag, &v11, &v12)) {
547	if (!TIFFGetField(tif2, tag, &v21, &v22)) {
548	printf("%s tag appears only in %s\n",
549	name, TIFFFileName(tif1));
550	return (0);
551	}
552	if (v11 == v21 && v12 == v22)
553	return (1);
554	printf("%s: <%u,%u> <%u,%u>\n", name, v11, v12, v21, v22);
555	} else if (TIFFGetField(tif2, tag, &v21, &v22))
556	printf("%s tag appears only in %s\n", name, TIFFFileName(tif2));
557	else
558	return (1);
559	return (0);
560	}
561
562	static int
563	CheckShortArrayTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
564	{
565	uint16 n1, *a1;
566	uint16 n2, *a2;
567
568	if (TIFFGetField(tif1, tag, &n1, &a1)) {
569	if (!TIFFGetField(tif2, tag, &n2, &a2)) {
570	printf("%s tag appears only in %s\n",
571	name, TIFFFileName(tif1));
572	return (0);
573	}
574	if (n1 == n2) {
575	char* sep;
576	uint16 i;
577
578	if (memcmp(a1, a2, n1 * sizeof(uint16)) == 0)
579	return (1);
580	printf("%s: value mismatch, <%u:", name, n1);
581	sep = "";
582	for (i = 0; i < n1; i++)
583	printf("%s%u", sep, a1[i]), sep = ",";
584	printf("> and <%u: ", n2);
585	sep = "";
586	for (i = 0; i < n2; i++)
587	printf("%s%u", sep, a2[i]), sep = ",";
588	printf(">\n");
589	} else
590	printf("%s: %u items in %s, %u items in %s", name,
591	n1, TIFFFileName(tif1),
592	n2, TIFFFileName(tif2)
593	);
594	} else if (TIFFGetField(tif2, tag, &n2, &a2))
595	printf("%s tag appears only in %s\n", name, TIFFFileName(tif2));
596	else
597	return (1);
598	return (0);
599	}
600
601	static int
602	CheckLongTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
603	{
604	uint32 v1, v2;
605	CHECK(v1 == v2, "%s: %u %u\n");
606	}
607
608	static int
609	CheckFloatTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
610	{
611	float v1, v2;
612	CHECK(v1 == v2, "%s: %g %g\n");
613	}
614
615	static int
616	CheckStringTag(TIFF* tif1, TIFF* tif2, int tag, char* name)
617	{
618	char v1, v2;
619	CHECK(strcmp(v1, v2) == 0, "%s: \"%s\" \"%s\"\n");
620	}
621
622	static void
623	leof(const char* name, uint32 row, int s)
624	{
625
626	printf("%s: EOF at scanline %lu", name, (unsigned long)row);
627	if (s >= 0)
628	printf(", sample %d", s);
629	printf("\n");
630	}
631
632	/* vim: set ts=8 sts=8 sw=8 noet: */