342 lines
13 KiB
C
342 lines
13 KiB
C
/******************************************************************************
|
|
* $Id: tif_ovrcache.c,v 1.9 2010-06-08 18:55:15 bfriesen Exp $
|
|
*
|
|
* 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, toff_t nDirOffset )
|
|
|
|
{
|
|
TIFFOvrCache *psCache;
|
|
toff_t 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;
|
|
toff_t nBaseDirOffset;
|
|
uint32 RowsInStrip;
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/* 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 );
|
|
RowsInStrip=psCache->nBlockYSize;
|
|
if ((iTileY+1)*psCache->nBlockYSize>psCache->nYSize)
|
|
RowsInStrip=psCache->nYSize-iTileY*psCache->nBlockYSize;
|
|
TIFFWriteEncodedStrip( psCache->hTIFF, nTileID,
|
|
pabyData,
|
|
TIFFVStripSize(psCache->hTIFF,RowsInStrip) );
|
|
}
|
|
}
|
|
|
|
}
|
|
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 );
|
|
RowsInStrip=psCache->nBlockYSize;
|
|
if ((iTileY+1)*psCache->nBlockYSize>psCache->nYSize)
|
|
RowsInStrip=psCache->nYSize-iTileY*psCache->nBlockYSize;
|
|
TIFFWriteEncodedStrip( psCache->hTIFF, nTileID,
|
|
pabyData,
|
|
TIFFVStripSize(psCache->hTIFF,RowsInStrip) );
|
|
}
|
|
}
|
|
}
|
|
/* 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 );
|
|
}
|
|
/*
|
|
* Local Variables:
|
|
* mode: c
|
|
* c-basic-offset: 8
|
|
* fill-column: 78
|
|
* End:
|
|
*/
|