/* $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:

 */