src/tiff/contrib/addtiffo/tif_ovrcache.c

/******************************************************************************
 * $Id$
 *
 * Project:  TIFF Overview Builder
 * Purpose:  Library functions to maintain two rows of tiles or two strips
 *           of data for output overviews as an output cache.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2000, Frank Warmerdam
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ******************************************************************************
 */

#include "tiffiop.h"
#include "tif_ovrcache.h"
#include <assert.h>

/************************************************************************/
/*                         TIFFCreateOvrCache()                         */
/*                                                                      */
/*      Create an overview cache to hold two rows of blocks from an     */
/*      existing TIFF directory.                                        */
/************************************************************************/

TIFFOvrCache *TIFFCreateOvrCache( TIFF *hTIFF, int nDirOffset )

{
    TIFFOvrCache	*psCache;
    uint32		nBaseDirOffset;

    psCache = (TIFFOvrCache *) _TIFFmalloc(sizeof(TIFFOvrCache));
    psCache->nDirOffset = nDirOffset;
    psCache->hTIFF = hTIFF;

/* -------------------------------------------------------------------- */
/*      Get definition of this raster from the TIFF file itself.        */
/* -------------------------------------------------------------------- */
    nBaseDirOffset = TIFFCurrentDirOffset( psCache->hTIFF );
    TIFFSetSubDirectory( hTIFF, nDirOffset );

    TIFFGetField( hTIFF, TIFFTAG_IMAGEWIDTH, &(psCache->nXSize) );
    TIFFGetField( hTIFF, TIFFTAG_IMAGELENGTH, &(psCache->nYSize) );

    TIFFGetField( hTIFF, TIFFTAG_BITSPERSAMPLE, &(psCache->nBitsPerPixel) );
    TIFFGetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL, &(psCache->nSamples) );
    TIFFGetField( hTIFF, TIFFTAG_PLANARCONFIG, &(psCache->nPlanarConfig) );

    if( !TIFFIsTiled( hTIFF ) )
    {
        TIFFGetField( hTIFF, TIFFTAG_ROWSPERSTRIP, &(psCache->nBlockYSize) );
        psCache->nBlockXSize = psCache->nXSize;
        psCache->nBytesPerBlock = TIFFStripSize(hTIFF);
        psCache->bTiled = FALSE;
    }
    else
    {
        TIFFGetField( hTIFF, TIFFTAG_TILEWIDTH, &(psCache->nBlockXSize) );
        TIFFGetField( hTIFF, TIFFTAG_TILELENGTH, &(psCache->nBlockYSize) );
        psCache->nBytesPerBlock = TIFFTileSize(hTIFF);
        psCache->bTiled = TRUE;
    }

/* -------------------------------------------------------------------- */
/*      Compute some values from this.                                  */
/* -------------------------------------------------------------------- */

    psCache->nBlocksPerRow = (psCache->nXSize + psCache->nBlockXSize - 1)
        		/ psCache->nBlockXSize;
    psCache->nBlocksPerColumn = (psCache->nYSize + psCache->nBlockYSize - 1)
        		/ psCache->nBlockYSize;

    if (psCache->nPlanarConfig == PLANARCONFIG_SEPARATE)
        psCache->nBytesPerRow = psCache->nBytesPerBlock
            * psCache->nBlocksPerRow * psCache->nSamples;
    else
        psCache->nBytesPerRow =
            psCache->nBytesPerBlock * psCache->nBlocksPerRow;


/* -------------------------------------------------------------------- */
/*      Allocate and initialize the data buffers.                       */
/* -------------------------------------------------------------------- */

    psCache->pabyRow1Blocks =
        (unsigned char *) _TIFFmalloc(psCache->nBytesPerRow);
    psCache->pabyRow2Blocks =
        (unsigned char *) _TIFFmalloc(psCache->nBytesPerRow);

    if( psCache->pabyRow1Blocks == NULL
        || psCache->pabyRow2Blocks == NULL )
    {
		TIFFErrorExt( hTIFF->tif_clientdata, hTIFF->tif_name,
					  "Can't allocate memory for overview cache." );
        /* TODO: use of TIFFError is inconsistent with use of fprintf in addtiffo.c, sort out */
        return NULL;
    }

    _TIFFmemset( psCache->pabyRow1Blocks, 0, psCache->nBytesPerRow );
    _TIFFmemset( psCache->pabyRow2Blocks, 0, psCache->nBytesPerRow );

    psCache->nBlockOffset = 0;

    TIFFSetSubDirectory( psCache->hTIFF, nBaseDirOffset );

    return psCache;
}

/************************************************************************/
/*                          TIFFWriteOvrRow()                           */
/*                                                                      */
/*      Write one entire row of blocks (row 1) to the tiff file, and    */
/*      then rotate the block buffers, essentially moving things        */
/*      down by one block.                                              */
/************************************************************************/

static void TIFFWriteOvrRow( TIFFOvrCache * psCache )

{
    int		nRet, iTileX, iTileY = psCache->nBlockOffset;
    unsigned char *pabyData;
    uint32	nBaseDirOffset;

/* -------------------------------------------------------------------- */
/*      If the output cache is multi-byte per sample, and the file      */
/*      being written to is of a different byte order than the current  */
/*      platform, we will need to byte swap the data.                   */
/* -------------------------------------------------------------------- */
    if( TIFFIsByteSwapped(psCache->hTIFF) )
    {
        if( psCache->nBitsPerPixel == 16 )
            TIFFSwabArrayOfShort( (uint16 *) psCache->pabyRow1Blocks,
                      (psCache->nBytesPerBlock * psCache->nSamples) / 2 );

        else if( psCache->nBitsPerPixel == 32 )
            TIFFSwabArrayOfLong( (uint32 *) psCache->pabyRow1Blocks,
                         (psCache->nBytesPerBlock * psCache->nSamples) / 4 );

        else if( psCache->nBitsPerPixel == 64 )
            TIFFSwabArrayOfDouble( (double *) psCache->pabyRow1Blocks,
                         (psCache->nBytesPerBlock * psCache->nSamples) / 8 );
    }

/* -------------------------------------------------------------------- */
/*      Record original directory position, so we can restore it at     */
/*      end.                                                            */
/* -------------------------------------------------------------------- */
    nBaseDirOffset = TIFFCurrentDirOffset( psCache->hTIFF );
    nRet = TIFFSetSubDirectory( psCache->hTIFF, psCache->nDirOffset );
    assert( nRet == 1 );

/* -------------------------------------------------------------------- */
/*      Write blocks to TIFF file.                                      */
/* -------------------------------------------------------------------- */
    for( iTileX = 0; iTileX < psCache->nBlocksPerRow; iTileX++ )
    {
        int nTileID;

        if (psCache->nPlanarConfig == PLANARCONFIG_SEPARATE)
        {
            int iSample;

            for( iSample = 0; iSample < psCache->nSamples; iSample++ )
            {
                pabyData = TIFFGetOvrBlock( psCache, iTileX, iTileY, iSample );

                if( psCache->bTiled )
                {
                    nTileID =
                        TIFFComputeTile( psCache->hTIFF,
                                         iTileX * psCache->nBlockXSize,
                                         iTileY * psCache->nBlockYSize,
                                         0, (tsample_t) iSample );
                    TIFFWriteEncodedTile( psCache->hTIFF, nTileID,
                                          pabyData,
                                          TIFFTileSize(psCache->hTIFF) );
                }
                else
                {
                    nTileID =
                        TIFFComputeStrip( psCache->hTIFF,
                                          iTileY * psCache->nBlockYSize,
                                          (tsample_t) iSample );

                    TIFFWriteEncodedStrip( psCache->hTIFF, nTileID,
                                           pabyData,
                                           TIFFStripSize(psCache->hTIFF) );
                }
            }

        }
        else
        {
            pabyData = TIFFGetOvrBlock( psCache, iTileX, iTileY, 0 );

            if( psCache->bTiled )
            {
                nTileID =
                    TIFFComputeTile( psCache->hTIFF,
                                     iTileX * psCache->nBlockXSize,
                                     iTileY * psCache->nBlockYSize,
                                     0, 0 );
                TIFFWriteEncodedTile( psCache->hTIFF, nTileID,
                                      pabyData,
                                      TIFFTileSize(psCache->hTIFF) );
            }
            else
            {
                nTileID =
                    TIFFComputeStrip( psCache->hTIFF,
                                      iTileY * psCache->nBlockYSize,
                                      0 );

                TIFFWriteEncodedStrip( psCache->hTIFF, nTileID,
                                       pabyData,
                                       TIFFStripSize(psCache->hTIFF) );
            }
        }
    }
    /* TODO: add checks on error status return of TIFFWriteEncodedTile and TIFFWriteEncodedStrip */

/* -------------------------------------------------------------------- */
/*      Rotate buffers.                                                 */
/* -------------------------------------------------------------------- */
    pabyData = psCache->pabyRow1Blocks;
    psCache->pabyRow1Blocks = psCache->pabyRow2Blocks;
    psCache->pabyRow2Blocks = pabyData;

    _TIFFmemset( pabyData, 0, psCache->nBytesPerRow );

    psCache->nBlockOffset++;

/* -------------------------------------------------------------------- */
/*      Restore access to original directory.                           */
/* -------------------------------------------------------------------- */
    TIFFFlush( psCache->hTIFF );
    /* TODO: add checks on error status return of TIFFFlush */
    TIFFSetSubDirectory( psCache->hTIFF, nBaseDirOffset );
    /* TODO: add checks on error status return of TIFFSetSubDirectory */
}

/************************************************************************/
/*                          TIFFGetOvrBlock()                           */
/************************************************************************/

/* TODO: make TIFF_Downsample handle iSample offset, so that we can
 * do with a single TIFFGetOvrBlock and no longer need TIFFGetOvrBlock_Subsampled */
unsigned char *TIFFGetOvrBlock( TIFFOvrCache *psCache, int iTileX, int iTileY,
                                int iSample )

{
    int		nRowOffset;

    if( iTileY > psCache->nBlockOffset + 1 )
        TIFFWriteOvrRow( psCache );

    assert( iTileX >= 0 && iTileX < psCache->nBlocksPerRow );
    assert( iTileY >= 0 && iTileY < psCache->nBlocksPerColumn );
    assert( iTileY >= psCache->nBlockOffset
            && iTileY < psCache->nBlockOffset+2 );
    assert( iSample >= 0 && iSample < psCache->nSamples );

    if (psCache->nPlanarConfig == PLANARCONFIG_SEPARATE)
        nRowOffset = ((iTileX * psCache->nSamples) + iSample)
            * psCache->nBytesPerBlock;
    else
        nRowOffset = iTileX * psCache->nBytesPerBlock +
            (psCache->nBitsPerPixel + 7) / 8 * iSample;

    if( iTileY == psCache->nBlockOffset )
        return psCache->pabyRow1Blocks + nRowOffset;
    else
        return psCache->pabyRow2Blocks + nRowOffset;
}

/************************************************************************/
/*                     TIFFGetOvrBlock_Subsampled()                     */
/************************************************************************/

unsigned char *TIFFGetOvrBlock_Subsampled( TIFFOvrCache *psCache,
                                           int iTileX, int iTileY )

{
    int		nRowOffset;

    if( iTileY > psCache->nBlockOffset + 1 )
        TIFFWriteOvrRow( psCache );

    assert( iTileX >= 0 && iTileX < psCache->nBlocksPerRow );
    assert( iTileY >= 0 && iTileY < psCache->nBlocksPerColumn );
    assert( iTileY >= psCache->nBlockOffset
            && iTileY < psCache->nBlockOffset+2 );
    assert( psCache->nPlanarConfig != PLANARCONFIG_SEPARATE );

    nRowOffset = iTileX * psCache->nBytesPerBlock;

    if( iTileY == psCache->nBlockOffset )
        return psCache->pabyRow1Blocks + nRowOffset;
    else
        return psCache->pabyRow2Blocks + nRowOffset;
}

/************************************************************************/
/*                        TIFFDestroyOvrCache()                         */
/************************************************************************/

void TIFFDestroyOvrCache( TIFFOvrCache * psCache )

{
    while( psCache->nBlockOffset < psCache->nBlocksPerColumn )
        TIFFWriteOvrRow( psCache );

    _TIFFfree( psCache->pabyRow1Blocks );
    _TIFFfree( psCache->pabyRow2Blocks );
    _TIFFfree( psCache );
}
Commit	Line	Data
	1	/******************************************************************************
	2	* $Id$
	3	*
	4	* Project: TIFF Overview Builder
	5	* Purpose: Library functions to maintain two rows of tiles or two strips
	6	* of data for output overviews as an output cache.
	7	* Author: Frank Warmerdam, warmerdam@pobox.com
	8	*
	9	******************************************************************************
	10	* Copyright (c) 2000, Frank Warmerdam
	11	*
	12	* Permission is hereby granted, free of charge, to any person obtaining a
	13	* copy of this software and associated documentation files (the "Software"),
	14	* to deal in the Software without restriction, including without limitation
	15	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	16	* and/or sell copies of the Software, and to permit persons to whom the
	17	* Software is furnished to do so, subject to the following conditions:
	18	*
	19	* The above copyright notice and this permission notice shall be included
	20	* in all copies or substantial portions of the Software.
	21	*
	22	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	23	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	24	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	25	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	26	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	27	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	28	* DEALINGS IN THE SOFTWARE.
	29	******************************************************************************
	30	*/
	31
	32	#include "tiffiop.h"
	33	#include "tif_ovrcache.h"
	34	#include <assert.h>
	35
	36	/************************************************************************/
	37	/* TIFFCreateOvrCache() */
	38	/* */
	39	/* Create an overview cache to hold two rows of blocks from an */
	40	/* existing TIFF directory. */
	41	/************************************************************************/
	42
	43	TIFFOvrCache TIFFCreateOvrCache( TIFF hTIFF, int nDirOffset )
	44
	45	{
	46	TIFFOvrCache *psCache;
	47	uint32 nBaseDirOffset;
	48
	49	psCache = (TIFFOvrCache *) _TIFFmalloc(sizeof(TIFFOvrCache));
	50	psCache->nDirOffset = nDirOffset;
	51	psCache->hTIFF = hTIFF;
	52
	53	/* -------------------------------------------------------------------- */
	54	/* Get definition of this raster from the TIFF file itself. */
	55	/* -------------------------------------------------------------------- */
	56	nBaseDirOffset = TIFFCurrentDirOffset( psCache->hTIFF );
	57	TIFFSetSubDirectory( hTIFF, nDirOffset );
	58
	59	TIFFGetField( hTIFF, TIFFTAG_IMAGEWIDTH, &(psCache->nXSize) );
	60	TIFFGetField( hTIFF, TIFFTAG_IMAGELENGTH, &(psCache->nYSize) );
	61
	62	TIFFGetField( hTIFF, TIFFTAG_BITSPERSAMPLE, &(psCache->nBitsPerPixel) );
	63	TIFFGetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL, &(psCache->nSamples) );
	64	TIFFGetField( hTIFF, TIFFTAG_PLANARCONFIG, &(psCache->nPlanarConfig) );
	65
	66	if( !TIFFIsTiled( hTIFF ) )
	67	{
	68	TIFFGetField( hTIFF, TIFFTAG_ROWSPERSTRIP, &(psCache->nBlockYSize) );
	69	psCache->nBlockXSize = psCache->nXSize;
	70	psCache->nBytesPerBlock = TIFFStripSize(hTIFF);
	71	psCache->bTiled = FALSE;
	72	}
	73	else
	74	{
	75	TIFFGetField( hTIFF, TIFFTAG_TILEWIDTH, &(psCache->nBlockXSize) );
	76	TIFFGetField( hTIFF, TIFFTAG_TILELENGTH, &(psCache->nBlockYSize) );
	77	psCache->nBytesPerBlock = TIFFTileSize(hTIFF);
	78	psCache->bTiled = TRUE;
	79	}
	80
	81	/* -------------------------------------------------------------------- */
	82	/* Compute some values from this. */
	83	/* -------------------------------------------------------------------- */
	84
	85	psCache->nBlocksPerRow = (psCache->nXSize + psCache->nBlockXSize - 1)
	86	/ psCache->nBlockXSize;
	87	psCache->nBlocksPerColumn = (psCache->nYSize + psCache->nBlockYSize - 1)
	88	/ psCache->nBlockYSize;
	89
	90	if (psCache->nPlanarConfig == PLANARCONFIG_SEPARATE)
	91	psCache->nBytesPerRow = psCache->nBytesPerBlock
	92	* psCache->nBlocksPerRow * psCache->nSamples;
	93	else
	94	psCache->nBytesPerRow =
	95	psCache->nBytesPerBlock * psCache->nBlocksPerRow;
	96
	97
	98	/* -------------------------------------------------------------------- */
	99	/* Allocate and initialize the data buffers. */
	100	/* -------------------------------------------------------------------- */
	101
	102	psCache->pabyRow1Blocks =
	103	(unsigned char *) _TIFFmalloc(psCache->nBytesPerRow);
	104	psCache->pabyRow2Blocks =
	105	(unsigned char *) _TIFFmalloc(psCache->nBytesPerRow);
	106
	107	if( psCache->pabyRow1Blocks == NULL
	108	\|\| psCache->pabyRow2Blocks == NULL )
	109	{
	110	TIFFErrorExt( hTIFF->tif_clientdata, hTIFF->tif_name,
	111	"Can't allocate memory for overview cache." );
	112	/* TODO: use of TIFFError is inconsistent with use of fprintf in addtiffo.c, sort out */
	113	return NULL;
	114	}
	115
	116	_TIFFmemset( psCache->pabyRow1Blocks, 0, psCache->nBytesPerRow );
	117	_TIFFmemset( psCache->pabyRow2Blocks, 0, psCache->nBytesPerRow );
	118
	119	psCache->nBlockOffset = 0;
	120
	121	TIFFSetSubDirectory( psCache->hTIFF, nBaseDirOffset );
	122
	123	return psCache;
	124	}
	125
	126	/************************************************************************/
	127	/* TIFFWriteOvrRow() */
	128	/* */
	129	/* Write one entire row of blocks (row 1) to the tiff file, and */
	130	/* then rotate the block buffers, essentially moving things */
	131	/* down by one block. */
	132	/************************************************************************/
	133
	134	static void TIFFWriteOvrRow( TIFFOvrCache * psCache )
	135
	136	{
	137	int nRet, iTileX, iTileY = psCache->nBlockOffset;
	138	unsigned char *pabyData;
	139	uint32 nBaseDirOffset;
	140
	141	/* -------------------------------------------------------------------- */
	142	/* If the output cache is multi-byte per sample, and the file */
	143	/* being written to is of a different byte order than the current */
	144	/* platform, we will need to byte swap the data. */
	145	/* -------------------------------------------------------------------- */
	146	if( TIFFIsByteSwapped(psCache->hTIFF) )
	147	{
	148	if( psCache->nBitsPerPixel == 16 )
	149	TIFFSwabArrayOfShort( (uint16 *) psCache->pabyRow1Blocks,
	150	(psCache->nBytesPerBlock * psCache->nSamples) / 2 );
	151
	152	else if( psCache->nBitsPerPixel == 32 )
	153	TIFFSwabArrayOfLong( (uint32 *) psCache->pabyRow1Blocks,
	154	(psCache->nBytesPerBlock * psCache->nSamples) / 4 );
	155
	156	else if( psCache->nBitsPerPixel == 64 )
	157	TIFFSwabArrayOfDouble( (double *) psCache->pabyRow1Blocks,
	158	(psCache->nBytesPerBlock * psCache->nSamples) / 8 );
	159	}
	160
	161	/* -------------------------------------------------------------------- */
	162	/* Record original directory position, so we can restore it at */
	163	/* end. */
	164	/* -------------------------------------------------------------------- */
	165	nBaseDirOffset = TIFFCurrentDirOffset( psCache->hTIFF );
	166	nRet = TIFFSetSubDirectory( psCache->hTIFF, psCache->nDirOffset );
	167	assert( nRet == 1 );
	168
	169	/* -------------------------------------------------------------------- */
	170	/* Write blocks to TIFF file. */
	171	/* -------------------------------------------------------------------- */
	172	for( iTileX = 0; iTileX < psCache->nBlocksPerRow; iTileX++ )
	173	{
	174	int nTileID;
	175
	176	if (psCache->nPlanarConfig == PLANARCONFIG_SEPARATE)
	177	{
	178	int iSample;
	179
	180	for( iSample = 0; iSample < psCache->nSamples; iSample++ )
	181	{
	182	pabyData = TIFFGetOvrBlock( psCache, iTileX, iTileY, iSample );
	183
	184	if( psCache->bTiled )
	185	{
	186	nTileID =
	187	TIFFComputeTile( psCache->hTIFF,
	188	iTileX * psCache->nBlockXSize,
	189	iTileY * psCache->nBlockYSize,
	190	0, (tsample_t) iSample );
	191	TIFFWriteEncodedTile( psCache->hTIFF, nTileID,
	192	pabyData,
	193	TIFFTileSize(psCache->hTIFF) );
	194	}
	195	else
	196	{
	197	nTileID =
	198	TIFFComputeStrip( psCache->hTIFF,
	199	iTileY * psCache->nBlockYSize,
	200	(tsample_t) iSample );
	201
	202	TIFFWriteEncodedStrip( psCache->hTIFF, nTileID,
	203	pabyData,
	204	TIFFStripSize(psCache->hTIFF) );
	205	}
	206	}
	207
	208	}
	209	else
	210	{
	211	pabyData = TIFFGetOvrBlock( psCache, iTileX, iTileY, 0 );
	212
	213	if( psCache->bTiled )
	214	{
	215	nTileID =
	216	TIFFComputeTile( psCache->hTIFF,
	217	iTileX * psCache->nBlockXSize,
	218	iTileY * psCache->nBlockYSize,
	219	0, 0 );
	220	TIFFWriteEncodedTile( psCache->hTIFF, nTileID,
	221	pabyData,
	222	TIFFTileSize(psCache->hTIFF) );
	223	}
	224	else
	225	{
	226	nTileID =
	227	TIFFComputeStrip( psCache->hTIFF,
	228	iTileY * psCache->nBlockYSize,
	229	0 );
	230
	231	TIFFWriteEncodedStrip( psCache->hTIFF, nTileID,
	232	pabyData,
	233	TIFFStripSize(psCache->hTIFF) );
	234	}
	235	}
	236	}
	237	/* TODO: add checks on error status return of TIFFWriteEncodedTile and TIFFWriteEncodedStrip */
	238
	239	/* -------------------------------------------------------------------- */
	240	/* Rotate buffers. */
	241	/* -------------------------------------------------------------------- */
	242	pabyData = psCache->pabyRow1Blocks;
	243	psCache->pabyRow1Blocks = psCache->pabyRow2Blocks;
	244	psCache->pabyRow2Blocks = pabyData;
	245
	246	_TIFFmemset( pabyData, 0, psCache->nBytesPerRow );
	247
	248	psCache->nBlockOffset++;
	249
	250	/* -------------------------------------------------------------------- */
	251	/* Restore access to original directory. */
	252	/* -------------------------------------------------------------------- */
	253	TIFFFlush( psCache->hTIFF );
	254	/* TODO: add checks on error status return of TIFFFlush */
	255	TIFFSetSubDirectory( psCache->hTIFF, nBaseDirOffset );
	256	/* TODO: add checks on error status return of TIFFSetSubDirectory */
	257	}
	258
	259	/************************************************************************/
	260	/* TIFFGetOvrBlock() */
	261	/************************************************************************/
	262
	263	/* TODO: make TIFF_Downsample handle iSample offset, so that we can
	264	* do with a single TIFFGetOvrBlock and no longer need TIFFGetOvrBlock_Subsampled */
	265	unsigned char TIFFGetOvrBlock( TIFFOvrCache psCache, int iTileX, int iTileY,
	266	int iSample )
	267
	268	{
	269	int nRowOffset;
	270
	271	if( iTileY > psCache->nBlockOffset + 1 )
	272	TIFFWriteOvrRow( psCache );
	273
	274	assert( iTileX >= 0 && iTileX < psCache->nBlocksPerRow );
	275	assert( iTileY >= 0 && iTileY < psCache->nBlocksPerColumn );
	276	assert( iTileY >= psCache->nBlockOffset
	277	&& iTileY < psCache->nBlockOffset+2 );
	278	assert( iSample >= 0 && iSample < psCache->nSamples );
	279
	280	if (psCache->nPlanarConfig == PLANARCONFIG_SEPARATE)
	281	nRowOffset = ((iTileX * psCache->nSamples) + iSample)
	282	* psCache->nBytesPerBlock;
	283	else
	284	nRowOffset = iTileX * psCache->nBytesPerBlock +
	285	(psCache->nBitsPerPixel + 7) / 8 * iSample;
	286
	287	if( iTileY == psCache->nBlockOffset )
	288	return psCache->pabyRow1Blocks + nRowOffset;
	289	else
	290	return psCache->pabyRow2Blocks + nRowOffset;
	291	}
	292
	293	/************************************************************************/
	294	/* TIFFGetOvrBlock_Subsampled() */
	295	/************************************************************************/
	296
	297	unsigned char TIFFGetOvrBlock_Subsampled( TIFFOvrCache psCache,
	298	int iTileX, int iTileY )
	299
	300	{
	301	int nRowOffset;
	302
	303	if( iTileY > psCache->nBlockOffset + 1 )
	304	TIFFWriteOvrRow( psCache );
	305
	306	assert( iTileX >= 0 && iTileX < psCache->nBlocksPerRow );
	307	assert( iTileY >= 0 && iTileY < psCache->nBlocksPerColumn );
	308	assert( iTileY >= psCache->nBlockOffset
	309	&& iTileY < psCache->nBlockOffset+2 );
	310	assert( psCache->nPlanarConfig != PLANARCONFIG_SEPARATE );
	311
	312	nRowOffset = iTileX * psCache->nBytesPerBlock;
	313
	314	if( iTileY == psCache->nBlockOffset )
	315	return psCache->pabyRow1Blocks + nRowOffset;
	316	else
	317	return psCache->pabyRow2Blocks + nRowOffset;
	318	}
	319
	320	/************************************************************************/
	321	/* TIFFDestroyOvrCache() */
	322	/************************************************************************/
	323
	324	void TIFFDestroyOvrCache( TIFFOvrCache * psCache )
	325
	326	{
	327	while( psCache->nBlockOffset < psCache->nBlocksPerColumn )
	328	TIFFWriteOvrRow( psCache );
	329
	330	_TIFFfree( psCache->pabyRow1Blocks );
	331	_TIFFfree( psCache->pabyRow2Blocks );
	332	_TIFFfree( psCache );
	333	}