Imported Upstream version 1.8.3

1 files changed, 525 insertions, 0 deletions

diff --git a/tiff/contrib/pds/tif_imageiter.c b/tiff/contrib/pds/tif_imageiter.c
new file mode 100755
index 0000000..e025dc5
--- /dev/null
+++ b/tiff/contrib/pds/tif_imageiter.c
@@ -0,0 +1,525 @@
+/* $Header: /cvs/maptools/cvsroot/libtiff/contrib/pds/tif_imageiter.c,v 1.4 2010-06-08 18:55:15 bfriesen Exp $ */
+
+/*
+ * Copyright (c) 1991-1996 Sam Leffler
+ * Copyright (c) 1991-1996 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.
+ */
+
+/*
+ * TIFF Library
+ *
+ * Written by Conrad J. Poelman, PL/WSAT, Kirtland AFB, NM on 26 Mar 96.
+ *
+ * This file contains code to allow a calling program to "iterate" over each
+ * pixels in an image as it is read from the file. The iterator takes care of
+ * reading strips versus (possibly clipped) tiles, decoding the information
+ * according to the decoding method, and so on, so that calling program can
+ * ignore those details. The calling program does, however, need to be
+ * conscious of the type of the pixel data that it is receiving.
+ *
+ * For reasons of efficiency, the callback function actually gets called for 
+ * "blocks" of pixels rather than for individual pixels. The format of the
+ * callback arguments is given below.
+ *
+ * This code was taken from TIFFReadRGBAImage() in tif_getimage.c of the original
+ * TIFF distribution, and simplified and generalized to provide this general
+ * iteration capability. Those routines could certainly be re-implemented in terms
+ * of a TIFFImageIter if desired.
+ *
+ */
+#include "tiffiop.h"
+#include "tif_imageiter.h"
+#include <assert.h>
+#include <stdio.h>
+
+static	int gtTileContig(TIFFImageIter*, void *udata, uint32, uint32);
+static	int gtTileSeparate(TIFFImageIter*, void *udata, uint32, uint32);
+static	int gtStripContig(TIFFImageIter*, void *udata, uint32, uint32);
+static	int gtStripSeparate(TIFFImageIter*, void *udata, uint32, uint32);
+
+static	const char photoTag[] = "PhotometricInterpretation";
+
+static int
+isCCITTCompression(TIFF* tif)
+{
+    uint16 compress;
+    TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);
+    return (compress == COMPRESSION_CCITTFAX3 ||
+	    compress == COMPRESSION_CCITTFAX4 ||
+	    compress == COMPRESSION_CCITTRLE ||
+	    compress == COMPRESSION_CCITTRLEW);
+}
+
+int
+TIFFImageIterBegin(TIFFImageIter* img, TIFF* tif, int stop, char emsg[1024])
+{
+    uint16* sampleinfo;
+    uint16 extrasamples;
+    uint16 planarconfig;
+    int colorchannels;
+
+    img->tif = tif;
+    img->stoponerr = stop;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
+    img->alpha = 0;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
+    TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
+	&extrasamples, &sampleinfo);
+    if (extrasamples == 1)
+	switch (sampleinfo[0]) {
+	case EXTRASAMPLE_ASSOCALPHA:	/* data is pre-multiplied */
+	case EXTRASAMPLE_UNASSALPHA:	/* data is not pre-multiplied */
+	    img->alpha = sampleinfo[0];
+	    break;
+	}
+    colorchannels = img->samplesperpixel - extrasamples;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
+    if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {
+	switch (colorchannels) {
+	case 1:
+	    if (isCCITTCompression(tif))
+		img->photometric = PHOTOMETRIC_MINISWHITE;
+	    else
+		img->photometric = PHOTOMETRIC_MINISBLACK;
+	    break;
+	case 3:
+	    img->photometric = PHOTOMETRIC_RGB;
+	    break;
+	default:
+	    sprintf(emsg, "Missing needed %s tag", photoTag);
+	    return (0);
+	}
+    }
+    switch (img->photometric) {
+    case PHOTOMETRIC_PALETTE:
+	if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
+	    &img->redcmap, &img->greencmap, &img->bluecmap)) {
+		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Missing required \"Colormap\" tag");
+	    return (0);
+	}
+	/* fall thru... */
+    case PHOTOMETRIC_MINISWHITE:
+    case PHOTOMETRIC_MINISBLACK:
+/* This should work now so skip the check - BSR
+	if (planarconfig == PLANARCONFIG_CONTIG && img->samplesperpixel != 1) {
+	    sprintf(emsg,
+		"Sorry, can not handle contiguous data with %s=%d, and %s=%d",
+		photoTag, img->photometric,
+		"Samples/pixel", img->samplesperpixel);
+	    return (0);
+	}
+ */
+	break;
+    case PHOTOMETRIC_YCBCR:
+	if (planarconfig != PLANARCONFIG_CONTIG) {
+	    sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d",
+		"Planarconfiguration", planarconfig);
+	    return (0);
+	}
+	/* It would probably be nice to have a reality check here. */
+	{ uint16 compress;
+	  TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);
+	  if (compress == COMPRESSION_JPEG && planarconfig == PLANARCONFIG_CONTIG) {
+	    /* can rely on libjpeg to convert to RGB */
+	    /* XXX should restore current state on exit */
+	    TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
+	    img->photometric = PHOTOMETRIC_RGB;
+	  }
+	}
+	break;
+    case PHOTOMETRIC_RGB: 
+	if (colorchannels < 3) {
+	    sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
+		"Color channels", colorchannels);
+	    return (0);
+	}
+	break;
+    case PHOTOMETRIC_SEPARATED: {
+	uint16 inkset;
+	TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
+	if (inkset != INKSET_CMYK) {
+	    sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
+		"InkSet", inkset);
+	    return (0);
+	}
+	if (img->samplesperpixel != 4) {
+	    sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
+		"Samples/pixel", img->samplesperpixel);
+	    return (0);
+	}
+	break;
+    }
+    default:
+	sprintf(emsg, "Sorry, can not handle image with %s=%d",
+	    photoTag, img->photometric);
+	return (0);
+    }
+    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);
+    TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);
+
+    TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);
+    switch (img->orientation) {
+    case ORIENTATION_BOTRIGHT:
+    case ORIENTATION_RIGHTBOT:	/* XXX */
+    case ORIENTATION_LEFTBOT:	/* XXX */
+	TIFFWarning(TIFFFileName(tif), "using bottom-left orientation");
+	img->orientation = ORIENTATION_BOTLEFT;
+	/* fall thru... */
+    case ORIENTATION_BOTLEFT:
+	break;
+    case ORIENTATION_TOPRIGHT:
+    case ORIENTATION_RIGHTTOP:	/* XXX */
+    case ORIENTATION_LEFTTOP:	/* XXX */
+    default:
+	TIFFWarning(TIFFFileName(tif), "using top-left orientation");
+	img->orientation = ORIENTATION_TOPLEFT;
+	/* fall thru... */
+    case ORIENTATION_TOPLEFT:
+	break;
+    }
+
+    img->isContig =
+	!(planarconfig == PLANARCONFIG_SEPARATE && colorchannels > 1);
+    if (img->isContig) {
+	img->get = TIFFIsTiled(tif) ? gtTileContig : gtStripContig;
+    } else {
+	img->get = TIFFIsTiled(tif) ? gtTileSeparate : gtStripSeparate;
+    }
+    return (1);
+}
+
+int
+TIFFImageIterGet(TIFFImageIter* img, void *udata, uint32 w, uint32 h)
+{
+    if (img->get == NULL) {
+	TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No \"get\" routine setup");
+	return (0);
+    }
+    if (img->callback.any == NULL) {
+	TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif),
+		"No \"put\" routine setupl; probably can not handle image format");
+	return (0);
+    }
+    return (*img->get)(img, udata, w, h);
+}
+
+TIFFImageIterEnd(TIFFImageIter* img)
+{
+    /* Nothing to free... ? */
+}
+
+/*
+ * Read the specified image into an ABGR-format raster.
+ */
+int
+TIFFReadImageIter(TIFF* tif,
+    uint32 rwidth, uint32 rheight, uint8* raster, int stop)
+{
+    char emsg[1024];
+    TIFFImageIter img;
+    int ok;
+
+    if (TIFFImageIterBegin(&img, tif, stop, emsg)) {
+	/* XXX verify rwidth and rheight against width and height */
+	ok = TIFFImageIterGet(&img, raster, rwidth, img.height);
+	TIFFImageIterEnd(&img);
+    } else {
+	TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), emsg);
+	ok = 0;
+    }
+    return (ok);
+}
+
+
+/*
+ * Get an tile-organized image that has
+ *	PlanarConfiguration contiguous if SamplesPerPixel > 1
+ * or
+ *	SamplesPerPixel == 1
+ */	
+static int
+gtTileContig(TIFFImageIter* img, void *udata, uint32 w, uint32 h)
+{
+    TIFF* tif = img->tif;
+    ImageIterTileContigRoutine callback = img->callback.contig;
+    uint16 orientation;
+    uint32 col, row;
+    uint32 tw, th;
+    u_char* buf;
+    int32 fromskew;
+    uint32 nrow;
+
+    buf = (u_char*) _TIFFmalloc(TIFFTileSize(tif));
+    if (buf == 0) {
+	TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
+	return (0);
+    }
+    TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
+    TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
+    orientation = img->orientation;
+    for (row = 0; row < h; row += th) {
+	nrow = (row + th > h ? h - row : th);
+	for (col = 0; col < w; col += tw) {
+	    if (TIFFReadTile(tif, buf, col, row, 0, 0) < 0 && img->stoponerr)
+		break;
+	    if (col + tw > w) {
+		/*
+		 * Tile is clipped horizontally.  Calculate
+		 * visible portion and skewing factors.
+		 */
+		uint32 npix = w - col;
+		fromskew = tw - npix;
+		(*callback)(img, udata, col, row, npix, nrow, fromskew, buf);
+	    } else {
+		(*callback)(img, udata, col, row, tw, nrow, 0, buf);
+	    }
+	}
+    }
+    _TIFFfree(buf);
+    return (1);
+}
+
+/*
+ * Get an tile-organized image that has
+ *	 SamplesPerPixel > 1
+ *	 PlanarConfiguration separated
+ * We assume that all such images are RGB.
+ */	
+static int
+gtTileSeparate(TIFFImageIter* img, void *udata, uint32 w, uint32 h)
+{
+    TIFF* tif = img->tif;
+    ImageIterTileSeparateRoutine callback = img->callback.separate;
+    uint16 orientation;
+    uint32 col, row;
+    uint32 tw, th;
+    u_char* buf;
+    u_char* r;
+    u_char* g;
+    u_char* b;
+    u_char* a;
+    tsize_t tilesize;
+    int32 fromskew;
+    int alpha = img->alpha;
+    uint32 nrow;
+
+    tilesize = TIFFTileSize(tif);
+    buf = (u_char*) _TIFFmalloc(4*tilesize);
+    if (buf == 0) {
+	TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
+	return (0);
+    }
+    r = buf;
+    g = r + tilesize;
+    b = g + tilesize;
+    a = b + tilesize;
+    if (!alpha)
+	memset(a, 0xff, tilesize);
+    TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
+    TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
+    orientation = img->orientation;
+    for (row = 0; row < h; row += th) {
+	nrow = (row + th > h ? h - row : th);
+	for (col = 0; col < w; col += tw) {
+	    if (TIFFReadTile(tif, r, col, row,0,0) < 0 && img->stoponerr)
+		break;
+	    if (TIFFReadTile(tif, g, col, row,0,1) < 0 && img->stoponerr)
+		break;
+	    if (TIFFReadTile(tif, b, col, row,0,2) < 0 && img->stoponerr)
+		break;
+	    if (alpha && TIFFReadTile(tif,a,col,row,0,3) < 0 && img->stoponerr)
+		break;
+	    if (col + tw > w) {
+		/*
+		 * Tile is clipped horizontally.  Calculate
+		 * visible portion and skewing factors.
+		 */
+		uint32 npix = w - col;
+		fromskew = tw - npix;
+		(*callback)(img, udata, col, row, npix, nrow, fromskew, r, g, b, a);
+	    } else {
+		(*callback)(img, udata, col, row, tw, nrow, 0, r, g, b, a);
+	    }
+	}
+    }
+    _TIFFfree(buf);
+    return (1);
+}
+
+/*
+ * Get a strip-organized image that has
+ *	PlanarConfiguration contiguous if SamplesPerPixel > 1
+ * or
+ *	SamplesPerPixel == 1
+ */	
+static int
+gtStripContig(TIFFImageIter* img, void *udata, uint32 w, uint32 h)
+{
+    TIFF* tif = img->tif;
+    ImageIterTileContigRoutine callback = img->callback.contig;
+    uint16 orientation;
+    uint32 row, nrow;
+    u_char* buf;
+    uint32 rowsperstrip;
+    uint32 imagewidth = img->width;
+    tsize_t scanline;
+    int32 fromskew;
+
+    buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
+    if (buf == 0) {
+	TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
+	return (0);
+    }
+    orientation = img->orientation;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
+    scanline = TIFFScanlineSize(tif);
+    fromskew = (w < imagewidth ? imagewidth - w : 0);
+    for (row = 0; row < h; row += rowsperstrip) {
+	nrow = (row + rowsperstrip > h ? h - row : rowsperstrip);
+	if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),
+	    buf, nrow*scanline) < 0 && img->stoponerr)
+		break;
+	(*callback)(img, udata, 0, row, w, nrow, fromskew, buf);
+    }
+    _TIFFfree(buf);
+    return (1);
+}
+
+/*
+ * Get a strip-organized image with
+ *	 SamplesPerPixel > 1
+ *	 PlanarConfiguration separated
+ * We assume that all such images are RGB.
+ */
+static int
+gtStripSeparate(TIFFImageIter* img, void *udata, uint32 w, uint32 h)
+{
+    TIFF* tif = img->tif;
+    ImageIterTileSeparateRoutine callback = img->callback.separate;
+    uint16 orientation;
+    u_char *buf;
+    u_char *r, *g, *b, *a;
+    uint32 row, nrow;
+    tsize_t scanline;
+    uint32 rowsperstrip;
+    uint32 imagewidth = img->width;
+    tsize_t stripsize;
+    int32 fromskew;
+    int alpha = img->alpha;
+
+    stripsize = TIFFStripSize(tif);
+    r = buf = (u_char *)_TIFFmalloc(4*stripsize);
+    if (buf == 0) {
+	TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
+	return (0);
+    }
+    g = r + stripsize;
+    b = g + stripsize;
+    a = b + stripsize;
+    if (!alpha)
+	memset(a, 0xff, stripsize);
+    orientation = img->orientation;
+    TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
+    scanline = TIFFScanlineSize(tif);
+    fromskew = (w < imagewidth ? imagewidth - w : 0);
+    for (row = 0; row < h; row += rowsperstrip) {
+	nrow = (row + rowsperstrip > h ? h - row : rowsperstrip);
+	if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),
+	    r, nrow*scanline) < 0 && img->stoponerr)
+	    break;
+	if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 1),
+	    g, nrow*scanline) < 0 && img->stoponerr)
+	    break;
+	if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 2),
+	    b, nrow*scanline) < 0 && img->stoponerr)
+	    break;
+	if (alpha &&
+	    (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 3),
+	    a, nrow*scanline) < 0 && img->stoponerr))
+	    break;
+	(*callback)(img, udata, 0, row, w, nrow, fromskew, r, g, b, a);
+    }
+    _TIFFfree(buf);
+    return (1);
+}
+
+DECLAREContigCallbackFunc(TestContigCallback)
+{
+    printf("Contig Callback called with x = %d, y = %d, w = %d, h = %d, fromskew = %d\n",
+	   x, y, w, h, fromskew);
+}
+
+
+DECLARESepCallbackFunc(TestSepCallback)
+{
+    printf("Sep Callback called with x = %d, y = %d, w = %d, h = %d, fromskew = %d\n",
+	   x, y, w, h, fromskew);
+}
+
+
+#ifdef MAIN
+main(int argc, char **argv)
+{
+    char emsg[1024];
+    TIFFImageIter img;
+    int ok;
+    int stop = 1;
+
+    TIFF *tif;
+    unsigned long nx, ny;
+    unsigned short BitsPerSample, SamplesPerPixel;
+    int isColorMapped, isPliFile;
+    unsigned char *ColorMap;
+    unsigned char *data;
+
+    if (argc < 2) {
+	fprintf(stderr,"usage: %s tiff_file\n",argv[0]);
+	exit(1);
+    }
+    tif = (TIFF *)PLIGetImage(argv[1], (void *) &data, &ColorMap, 
+			      &nx, &ny, &BitsPerSample, &SamplesPerPixel, 
+			      &isColorMapped, &isPliFile);
+    if (tif != NULL) {
+
+	if (TIFFImageIterBegin(&img, tif, stop, emsg)) {
+	    /* Here need to set data and callback function! */
+	    if (img.isContig) {
+		img.callback = TestContigCallback;
+	    } else {
+		img.callback = TestSepCallback;
+	    }
+	    ok = TIFFImageIterGet(&img, NULL, img.width, img.height);
+	    TIFFImageIterEnd(&img);
+	} else {
+	    TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), emsg);
+	}
+    }
+    
+}
+#endif
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */