laag-libtiff 4.0.9.0

data/vendor/gitlab.com/libtiff/libtiff/contrib/tags/README

@@ -0,0 +1,132 @@
+
+NOTE:  Sept/2004 
+
+The following described approach to managing tag extensions has been
+mostly superceeded since libtiff 3.6.0.  The described approach requires
+internal knowledge of the libtiff API and tends to be very fragile 
+in the face of libtiff upgrades.  
+
+Please read over the html/addingtags.html in preference to the below
+described approach.
+
+
+
+==================================
+
+Client module for adding to LIBTIFF tagset
+-------------------------------------------
+  Author: Niles Ritter
+
+
+  
+
+In the past, users of the "libtiff" package had to modify the
+source code of the library if they required additional private tags
+or codes not recognized by libtiff. Thus, whenever
+a new revision of libtiff came out the client would have to
+perform modifications to six or seven different files to re-install
+their tags.
+
+The latest versions of libtiff now provide client software new routines, 
+giving them the opportunity to install private extensions at runtime,
+rather than compile-time. This means that the client may encapsulate
+all of their private tags into a separate module, which need only
+be recompiled when new versions of libtiff are released; no manual
+editing of files is required.
+
+How it works
+------------
+
+The mechanism for overriding the tag access has been enabled with
+a single new routine, which has the following calling sequence:
+
+  TIFFExtendProc old_extender;
+  
+  old_extender = TIFFSetTagExtender(tag_extender);
+
+which must be called prior to opening or creating TIFF files.
+
+This routine sets a static pointer to the user-specified function
+<tag_extender>, which in turn is called by TIFFDefaultDirectory(),
+just after the usual TIFFSetField() and TIFFGetField() methods
+are defined, and just before the compression tag is set. It also
+returns a pointer to the previously-defined value of the tag-extender,
+so that multiple clients may be installed.
+
+The TIFFExtendProc method that you define should be used to override
+the TIFF file's "vsetfield" and "vgetfield" methods, so that you
+can trap your new, private tags, and install their values into
+a private directory structure. For your convienience, a new pointer
+has also been added to the "TIFF" file structure:
+
+	tidata_t	tif_clientdir;	/* client TIFF directory */
+
+into which you may install whatever private directory structures you like.
+You should also override the tag-printing method from within your
+"vsetfield" method, to permit the symbolic printing of your new tags.
+
+
+Example Client Code:
+--------------------
+
+An example module has been provided as a template for installing
+your own tags into a client tag extender. The module is called
+"xtif_dir.c", and defines all of the interface routines, tag field
+access, tag printing, etc. for most purpose. 
+
+To see how the client module operates, there are three "fake"
+tags currently installed. If you use the existing makefile you can
+build them with:
+
+     make all -f Makefile.gcc  !or Makefile.mpw
+     maketif
+     listtif
+  
+This will build two example programs called "maketif" and "listtif" 
+and then run them. These programs do nothing more than create a small
+file called "newtif.tif", install the fake tags, and then list them out
+using TIFFPrintDirectory().
+
+Installing Private Tags
+-----------------------
+
+To use this module for installing your own tags, edit each of the files
+
+    xtif_dir.c
+    xtiffio.h
+    xtiffiop.h
+    
+and search for the string "XXX". At these locations the comments
+will direct you how to install your own tag values, define their
+types, etc. Three examples tags are currently installed, demonstrating
+how to implement multi-valued tags, single-valued tags, and ASCII tags.
+The examples are not valid, registered tags, so you must replace them with
+your own.
+
+To test the routines, also edit the test programs "maketif.c" and
+"listtif.c" and replace the portions of the code that set the
+private tag values and list them.
+
+Once you have edited these files, you may build the client module
+with the Makefile provided, and run the test programs.
+
+To use these files in your own code, the "xtif_dir.c" module defines
+replacement routines for the standard "TIFFOpen()" "TIFFFdOpen",
+and "TIFFClose()" routines, called XTIFFOpen, XTIFFFdOpen and XTIFFClose.
+You must use these routines in order to have the extended tag handlers
+installed. Once installed, the standard TIFFGetField() and TIFFSetField
+routines may be used as before.
+
+Adding Extended Tags to "tools"
+-------------------------------
+To create an extended-tag savvy "tiffinfo" program or other utility, you may
+simply recompile and link the tools to your "libxtiff" library, adding 
+
+   -DTIFFOpen=XTIFFOpen -DTIFFClose=XTIFFClose -DTIFFFdOpen=XTIFFFdOpen
+
+to the compile statement.
+
+Bugs, Comments Etc:
+------------------
+ Send all reports and suggestions to ndr@tazboy.jpl.nasa.gov
+ (Niles Ritter).

data/vendor/gitlab.com/libtiff/libtiff/contrib/tags/listtif.c

@@ -0,0 +1,39 @@
+/*
+ * listtif.c -- lists a tiff file.
+ */
+
+#include "xtiffio.h"
+#include <stdlib.h>
+
+void main(int argc,char *argv[])
+{
+	char *fname="newtif.tif";
+	int flags;
+
+	TIFF *tif=(TIFF*)0;  /* TIFF-level descriptor */
+
+	if (argc>1) fname=argv[1];
+	
+	tif=XTIFFOpen(fname,"r");
+	if (!tif) goto failure;
+	
+	/* We want the double array listed */
+	flags = TIFFPRINT_MYMULTIDOUBLES;
+	
+	TIFFPrintDirectory(tif,stdout,flags);
+	XTIFFClose(tif);
+	exit (0);
+	
+failure:
+	printf("failure in listtif\n");
+	if (tif) XTIFFClose(tif);
+	exit (-1);
+}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */

data/vendor/gitlab.com/libtiff/libtiff/contrib/tags/maketif.c

@@ -0,0 +1,77 @@
+/*
+ * maketif.c -- creates a little TIFF file, with
+ *   the XTIFF extended tiff example tags.
+ */
+
+#include <stdlib.h>
+#include "xtiffio.h"
+
+
+void SetUpTIFFDirectory(TIFF *tif);
+void WriteImage(TIFF *tif);
+
+#define WIDTH 20
+#define HEIGHT 20
+
+void main()
+{
+	TIFF *tif=(TIFF*)0;  /* TIFF-level descriptor */
+	
+	tif=XTIFFOpen("newtif.tif","w");
+	if (!tif) goto failure;
+	
+	SetUpTIFFDirectory(tif);
+	WriteImage(tif);
+	
+	XTIFFClose(tif);
+	exit (0);
+	
+failure:
+	printf("failure in maketif\n");
+	if (tif) XTIFFClose(tif);
+	exit (-1);
+}
+
+
+void SetUpTIFFDirectory(TIFF *tif)
+{
+	double mymulti[6]={0.0,1.0,2.0,  3.1415926, 5.0,1.0};
+	uint32 mysingle=3456;
+	char *ascii="This file was produced by Steven Spielberg. NOT";
+
+	TIFFSetField(tif,TIFFTAG_IMAGEWIDTH,WIDTH);
+	TIFFSetField(tif,TIFFTAG_IMAGELENGTH,HEIGHT);
+	TIFFSetField(tif,TIFFTAG_COMPRESSION,COMPRESSION_NONE);
+	TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,PHOTOMETRIC_MINISBLACK);
+	TIFFSetField(tif,TIFFTAG_PLANARCONFIG,PLANARCONFIG_CONTIG);
+	TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,8);
+	TIFFSetField(tif,TIFFTAG_ROWSPERSTRIP,20);
+
+	/* Install the extended TIFF tag examples */
+	TIFFSetField(tif,TIFFTAG_EXAMPLE_MULTI,6,mymulti);
+	TIFFSetField(tif,TIFFTAG_EXAMPLE_SINGLE,mysingle);
+	TIFFSetField(tif,TIFFTAG_EXAMPLE_ASCII,ascii);
+}
+
+
+void WriteImage(TIFF *tif)
+{
+	int i;
+	char buffer[WIDTH];
+	
+	memset(buffer,0,sizeof(buffer));
+	for (i=0;i<HEIGHT;i++)
+		if (!TIFFWriteScanline(tif, buffer, i, 0))
+			TIFFErrorExt(tif->tif_clientdata, "WriteImage","failure in WriteScanline\n");
+}
+
+
+
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */

data/vendor/gitlab.com/libtiff/libtiff/contrib/tags/xtif_dir.c

@@ -0,0 +1,350 @@
+/*
+ * xtif_dir.c
+ *
+ * Extended TIFF Directory Tag Support.
+ *
+ *  You may use this file as a template to add your own
+ *  extended tags to the library. Only the parts of the code
+ *  marked with "XXX" require modification. Three example tags
+ *  are shown; you should replace them with your own.
+ *
+ *  Author: Niles D. Ritter
+ */
+ 
+#include "xtiffiop.h"
+#include <stdio.h>
+
+/*  Tiff info structure.
+ *
+ *     Entry format:
+ *        { TAGNUMBER, ReadCount, WriteCount, DataType, FIELDNUM, 
+ *          OkToChange, PassDirCountOnSet, AsciiName }
+ *
+ *     For ReadCount, WriteCount, -1 = unknown; used for mult-valued
+ *         tags and ASCII.
+ */
+
+static const TIFFFieldInfo xtiffFieldInfo[] = {
+  
+  /* XXX Replace these example tags with your own extended tags */
+    { TIFFTAG_EXAMPLE_MULTI,	-1,-1, TIFF_DOUBLE,	FIELD_EXAMPLE_MULTI,
+      TRUE,	TRUE,	"MyMultivaluedTag" },
+    { TIFFTAG_EXAMPLE_SINGLE,	 1, 1, TIFF_LONG,	FIELD_EXAMPLE_SINGLE,
+      TRUE,	FALSE,	"MySingleLongTag" },
+    { TIFFTAG_EXAMPLE_ASCII,	-1,-1, TIFF_ASCII,	FIELD_EXAMPLE_ASCII,
+      TRUE,	FALSE,	"MyAsciiTag" },
+};
+#define	N(a)	(sizeof (a) / sizeof (a[0]))
+
+
+static void
+_XTIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
+{
+	xtiff *xt = XTIFFDIR(tif);
+	XTIFFDirectory *xd = &xt->xtif_dir;
+	int i,num;
+
+	/* call the inherited method */
+	if (PARENT(xt,printdir))
+		(PARENT(xt,printdir))(tif,fd,flags);
+
+	/* XXX Add field printing here. Replace the three example
+         *    tags implemented below with your own.
+         */
+
+	fprintf(fd,"--My Example Tags--\n");
+
+	/* Our first example tag may have a lot of values, so we
+         * will only print them out if the TIFFPRINT_MYMULTIDOUBLES
+         * flag is passed into the print method.
+         */
+	if (TIFFFieldSet(tif,FIELD_EXAMPLE_MULTI))
+	{
+		fprintf(fd, "  My Multi-Valued Doubles:");
+		if (flags & TIFFPRINT_MYMULTIDOUBLES) 
+		{
+			double *value = xd->xd_example_multi;
+	
+			num = xd->xd_num_multi;
+			fprintf(fd,"(");
+			for (i=0;i<num;i++) fprintf(fd, " %lg", *value++);
+			fprintf(fd,")\n");
+		} else
+			fprintf(fd, "(present)\n");
+	}
+
+	if (TIFFFieldSet(tif,FIELD_EXAMPLE_SINGLE))
+	{
+		fprintf(fd, "  My Single Long Tag:  %lu\n", xd->xd_example_single);
+	}
+
+	if (TIFFFieldSet(tif,FIELD_EXAMPLE_ASCII))
+	{
+		_TIFFprintAsciiTag(fd,"My ASCII Tag",
+			 xd->xd_example_ascii);
+	}
+}
+
+static int
+_XTIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
+{
+	xtiff *xt = XTIFFDIR(tif);
+	XTIFFDirectory* xd = &xt->xtif_dir;
+	int status = 1;
+	uint32 v32=0;
+	int i=0, v=0;
+	va_list ap1 = ap;
+
+	/* va_start is called by the calling routine */
+	
+	switch (tag) {
+		/* 
+                 * XXX put your extended tags here; replace the implemented
+                 *     example tags with your own. 
+                 */
+	case TIFFTAG_EXAMPLE_MULTI:
+		/* multi-valued tags need to store the count as well */
+		xd->xd_num_multi = (uint16) va_arg(ap, int);
+		_TIFFsetDoubleArray(&xd->xd_example_multi, va_arg(ap, double*),
+			(long) xd->xd_num_multi);
+		break;
+	case TIFFTAG_EXAMPLE_SINGLE:
+		xd->xd_example_single = va_arg(ap, uint32);
+		break;
+	case TIFFTAG_EXAMPLE_ASCII:
+		_TIFFsetString(&xd->xd_example_ascii, va_arg(ap, char*));
+		break;
+	default:
+		/* call the inherited method */
+		return (PARENT(xt,vsetfield))(tif,tag,ap);
+		break;
+	}
+	if (status) {
+		/* we have to override the print method here,
+ 		 * after the compression tags have gotten to it.
+		 * This makes sense because the only time we would
+		 * need the extended print method is if an extended
+		 * tag is set by the reader.
+		 */
+		if (!(xt->xtif_flags & XTIFFP_PRINT))
+		{
+	        	PARENT(xt,printdir) =  TIFFMEMBER(tif,printdir);
+      		  	TIFFMEMBER(tif,printdir) = _XTIFFPrintDirectory;
+			xt->xtif_flags |= XTIFFP_PRINT;
+		}
+		TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
+		tif->tif_flags |= TIFF_DIRTYDIRECT;
+	}
+	va_end(ap);
+	return (status);
+badvalue:
+	TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%d: Bad value for \"%s\"", v,
+	    _TIFFFieldWithTag(tif, tag)->field_name);
+	va_end(ap);
+	return (0);
+badvalue32:
+	TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%ld: Bad value for \"%s\"", v32,
+	    _TIFFFieldWithTag(tif, tag)->field_name);
+	va_end(ap);
+	return (0);
+}
+
+
+static int
+_XTIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
+{
+	xtiff *xt = XTIFFDIR(tif);
+	XTIFFDirectory* xd = &xt->xtif_dir;
+
+	switch (tag) {
+		/* 
+                 * XXX put your extended tags here; replace the implemented
+                 *     example tags with your own.
+                 */
+	case TIFFTAG_EXAMPLE_MULTI:
+		*va_arg(ap, uint16*) = xd->xd_num_multi;
+		*va_arg(ap, double**) = xd->xd_example_multi;
+		break;
+	case TIFFTAG_EXAMPLE_ASCII:
+		*va_arg(ap, char**) = xd->xd_example_ascii;
+		break;
+	case TIFFTAG_EXAMPLE_SINGLE:
+		*va_arg(ap, uint32*) = xd->xd_example_single;
+		break;
+	default:
+		/* return inherited method */
+		return (PARENT(xt,vgetfield))(tif,tag,ap);
+		break;
+	}
+	return (1);
+}
+
+#define	CleanupField(member) {		\
+    if (xd->member) {			\
+	_TIFFfree(xd->member);		\
+	xd->member = 0;			\
+    }					\
+}
+/*
+ * Release storage associated with a directory.
+ */
+static void
+_XTIFFFreeDirectory(xtiff* xt)
+{
+	XTIFFDirectory* xd = &xt->xtif_dir;
+
+	/* 
+	 *  XXX - Purge all Your allocated memory except
+	 *  for the xtiff directory itself. This includes
+	 *  all fields that require a _TIFFsetXXX call in
+	 *  _XTIFFVSetField().
+	 */
+	
+	CleanupField(xd_example_multi);
+	CleanupField(xd_example_ascii);
+	
+}
+#undef CleanupField
+
+static void _XTIFFLocalDefaultDirectory(TIFF *tif)
+{
+	xtiff *xt = XTIFFDIR(tif);
+	XTIFFDirectory* xd = &xt->xtif_dir;
+
+	/* Install the extended Tag field info */
+	_TIFFMergeFieldInfo(tif, xtiffFieldInfo, N(xtiffFieldInfo));
+
+	/*
+	 *  free up any dynamically allocated arrays
+	 *  before the new directory is read in.
+	 */
+	 
+	_XTIFFFreeDirectory(xt);	
+	_TIFFmemset(xt,0,sizeof(xtiff));
+
+	/* Override the tag access methods */
+
+	PARENT(xt,vsetfield) =  TIFFMEMBER(tif,vsetfield);
+	TIFFMEMBER(tif,vsetfield) = _XTIFFVSetField;
+	PARENT(xt,vgetfield) =  TIFFMEMBER(tif,vgetfield);
+	TIFFMEMBER(tif,vgetfield) = _XTIFFVGetField;
+
+	/* 
+	 * XXX Set up any default values here.
+	 */
+	
+	xd->xd_example_single = 234;
+}
+
+
+
+/**********************************************************************
+ *    Nothing below this line should need to be changed.
+ **********************************************************************/
+
+static TIFFExtendProc _ParentExtender;
+
+/*
+ *  This is the callback procedure, and is
+ *  called by the DefaultDirectory method
+ *  every time a new TIFF directory is opened.
+ */
+
+static void
+_XTIFFDefaultDirectory(TIFF *tif)
+{
+	xtiff *xt;
+	
+	/* Allocate Directory Structure if first time, and install it */
+	if (!(tif->tif_flags & XTIFF_INITIALIZED))
+	{
+		xt = _TIFFmalloc(sizeof(xtiff));
+		if (!xt)
+		{
+			/* handle memory allocation failure here ! */
+			return;
+		}
+		_TIFFmemset(xt,0,sizeof(xtiff));
+		/*
+		 * Install into TIFF structure.
+		 */
+		TIFFMEMBER(tif,clientdir) = (tidata_t)xt;
+		tif->tif_flags |= XTIFF_INITIALIZED; /* dont do this again! */
+	}
+	
+	/* set up our own defaults */
+	_XTIFFLocalDefaultDirectory(tif);
+
+	/* Since an XTIFF client module may have overridden
+	 * the default directory method, we call it now to
+	 * allow it to set up the rest of its own methods.
+         */
+
+	if (_ParentExtender) 
+		(*_ParentExtender)(tif);
+
+}
+
+/*
+ *  XTIFF Initializer -- sets up the callback
+ *   procedure for the TIFF module.
+ */
+
+static
+void _XTIFFInitialize(void)
+{
+	static first_time=1;
+	
+	if (! first_time) return; /* Been there. Done that. */
+	first_time = 0;
+	
+	/* Grab the inherited method and install */
+	_ParentExtender = TIFFSetTagExtender(_XTIFFDefaultDirectory);
+}
+
+
+/*
+ * Public File I/O Routines.
+ */
+TIFF*
+XTIFFOpen(const char* name, const char* mode)
+{
+	/* Set up the callback */
+	_XTIFFInitialize();	
+	
+	/* Open the file; the callback will set everything up
+	 */
+	return TIFFOpen(name, mode);
+}
+
+TIFF*
+XTIFFFdOpen(int fd, const char* name, const char* mode)
+{
+	/* Set up the callback */
+	_XTIFFInitialize();	
+
+	/* Open the file; the callback will set everything up
+	 */
+	return TIFFFdOpen(fd, name, mode);
+}
+
+
+void
+XTIFFClose(TIFF *tif)
+{
+	xtiff *xt = XTIFFDIR(tif);
+	
+	/* call inherited function first */
+	TIFFClose(tif);
+	
+	/* Free up extended allocated memory */
+	_XTIFFFreeDirectory(xt);
+	_TIFFfree(xt);
+}
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */