/******************************************************************************

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

 */