[wxWidgets.git] / 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
8414a40c VZ	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	}