Built SDL2_image and _mixer static
This commit is contained in:
928
libsdl2_image/external/tiff-4.0.9/contrib/addtiffo/tif_overview.c
vendored
Normal file
928
libsdl2_image/external/tiff-4.0.9/contrib/addtiffo/tif_overview.c
vendored
Normal file
@ -0,0 +1,928 @@
|
||||
/******************************************************************************
|
||||
* tif_overview.c,v 1.9 2005/05/25 09:03:16 dron Exp
|
||||
*
|
||||
* Project: TIFF Overview Builder
|
||||
* Purpose: Library function for building overviews in a TIFF file.
|
||||
* Author: Frank Warmerdam, warmerdam@pobox.com
|
||||
*
|
||||
* Notes:
|
||||
* o Currently only images with bits_per_sample of a multiple of eight
|
||||
* will work.
|
||||
*
|
||||
* o The downsampler currently just takes the top left pixel from the
|
||||
* source rectangle. Eventually sampling options of averaging, mode, and
|
||||
* ``center pixel'' should be offered.
|
||||
*
|
||||
* o The code will attempt to use the same kind of compression,
|
||||
* photometric interpretation, and organization as the source image, but
|
||||
* it doesn't copy geotiff tags to the reduced resolution images.
|
||||
*
|
||||
* o Reduced resolution overviews for multi-sample files will currently
|
||||
* always be generated as PLANARCONFIG_SEPARATE. This could be fixed
|
||||
* reasonable easily if needed to improve compatibility with other
|
||||
* packages. Many don't properly support PLANARCONFIG_SEPARATE.
|
||||
*
|
||||
******************************************************************************
|
||||
* Copyright (c) 1999, 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.
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* TODO: update notes in header above */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "tiffio.h"
|
||||
#include "tif_ovrcache.h"
|
||||
|
||||
#ifndef FALSE
|
||||
# define FALSE 0
|
||||
# define TRUE 1
|
||||
#endif
|
||||
|
||||
#ifndef MAX
|
||||
# define MIN(a,b) ((a<b) ? a : b)
|
||||
# define MAX(a,b) ((a>b) ? a : b)
|
||||
#endif
|
||||
|
||||
#define TIFF_DIR_MAX 65534
|
||||
|
||||
void TIFFBuildOverviews( TIFF *, int, int *, int, const char *,
|
||||
int (*)(double,void*), void * );
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_WriteOverview() */
|
||||
/* */
|
||||
/* Create a new directory, without any image data for an overview. */
|
||||
/* Returns offset of newly created overview directory, but the */
|
||||
/* current directory is reset to be the one in used when this */
|
||||
/* function is called. */
|
||||
/************************************************************************/
|
||||
|
||||
uint32 TIFF_WriteOverview( TIFF *hTIFF, uint32 nXSize, uint32 nYSize,
|
||||
int nBitsPerPixel, int nPlanarConfig, int nSamples,
|
||||
int nBlockXSize, int nBlockYSize,
|
||||
int bTiled, int nCompressFlag, int nPhotometric,
|
||||
int nSampleFormat,
|
||||
unsigned short *panRed,
|
||||
unsigned short *panGreen,
|
||||
unsigned short *panBlue,
|
||||
int bUseSubIFDs,
|
||||
int nHorSubsampling, int nVerSubsampling )
|
||||
|
||||
{
|
||||
toff_t nBaseDirOffset;
|
||||
toff_t nOffset;
|
||||
tdir_t iNumDir;
|
||||
|
||||
(void) bUseSubIFDs;
|
||||
|
||||
nBaseDirOffset = TIFFCurrentDirOffset( hTIFF );
|
||||
|
||||
TIFFCreateDirectory( hTIFF );
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Setup TIFF fields. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
TIFFSetField( hTIFF, TIFFTAG_IMAGEWIDTH, nXSize );
|
||||
TIFFSetField( hTIFF, TIFFTAG_IMAGELENGTH, nYSize );
|
||||
if( nSamples == 1 )
|
||||
TIFFSetField( hTIFF, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG );
|
||||
else
|
||||
TIFFSetField( hTIFF, TIFFTAG_PLANARCONFIG, nPlanarConfig );
|
||||
|
||||
TIFFSetField( hTIFF, TIFFTAG_BITSPERSAMPLE, nBitsPerPixel );
|
||||
TIFFSetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL, nSamples );
|
||||
TIFFSetField( hTIFF, TIFFTAG_COMPRESSION, nCompressFlag );
|
||||
TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, nPhotometric );
|
||||
TIFFSetField( hTIFF, TIFFTAG_SAMPLEFORMAT, nSampleFormat );
|
||||
|
||||
if( bTiled )
|
||||
{
|
||||
TIFFSetField( hTIFF, TIFFTAG_TILEWIDTH, nBlockXSize );
|
||||
TIFFSetField( hTIFF, TIFFTAG_TILELENGTH, nBlockYSize );
|
||||
}
|
||||
else
|
||||
TIFFSetField( hTIFF, TIFFTAG_ROWSPERSTRIP, nBlockYSize );
|
||||
|
||||
TIFFSetField( hTIFF, TIFFTAG_SUBFILETYPE, FILETYPE_REDUCEDIMAGE );
|
||||
|
||||
if( nPhotometric == PHOTOMETRIC_YCBCR || nPhotometric == PHOTOMETRIC_ITULAB )
|
||||
{
|
||||
TIFFSetField( hTIFF, TIFFTAG_YCBCRSUBSAMPLING, nHorSubsampling, nVerSubsampling);
|
||||
/* TODO: also write YCbCrPositioning and YCbCrCoefficients tag identical to source IFD */
|
||||
}
|
||||
/* TODO: add command-line parameter for selecting jpeg compression quality
|
||||
* that gets ignored when compression isn't jpeg */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Write color table if one is present. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
if( panRed != NULL )
|
||||
{
|
||||
TIFFSetField( hTIFF, TIFFTAG_COLORMAP, panRed, panGreen, panBlue );
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Write directory, and return byte offset. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
if( TIFFWriteCheck( hTIFF, bTiled, "TIFFBuildOverviews" ) == 0 )
|
||||
return 0;
|
||||
|
||||
TIFFWriteDirectory( hTIFF );
|
||||
iNumDir = TIFFNumberOfDirectories(hTIFF);
|
||||
if( iNumDir > TIFF_DIR_MAX )
|
||||
{
|
||||
TIFFErrorExt( TIFFClientdata(hTIFF),
|
||||
"TIFF_WriteOverview",
|
||||
"File `%s' has too many directories.\n",
|
||||
TIFFFileName(hTIFF) );
|
||||
exit(-1);
|
||||
}
|
||||
TIFFSetDirectory( hTIFF, (tdir_t) (iNumDir - 1) );
|
||||
|
||||
nOffset = TIFFCurrentDirOffset( hTIFF );
|
||||
|
||||
TIFFSetSubDirectory( hTIFF, nBaseDirOffset );
|
||||
|
||||
return nOffset;
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_GetSourceSamples() */
|
||||
/************************************************************************/
|
||||
|
||||
static void
|
||||
TIFF_GetSourceSamples( double * padfSamples, unsigned char *pabySrc,
|
||||
int nPixelBytes, int nSampleFormat,
|
||||
uint32 nXSize, uint32 nYSize,
|
||||
int nPixelOffset, int nLineOffset )
|
||||
{
|
||||
uint32 iXOff, iYOff;
|
||||
int iSample;
|
||||
|
||||
iSample = 0;
|
||||
|
||||
for( iYOff = 0; iYOff < nYSize; iYOff++ )
|
||||
{
|
||||
for( iXOff = 0; iXOff < nXSize; iXOff++ )
|
||||
{
|
||||
unsigned char *pabyData;
|
||||
|
||||
pabyData = pabySrc + iYOff * nLineOffset + iXOff * nPixelOffset;
|
||||
|
||||
if( nSampleFormat == SAMPLEFORMAT_UINT && nPixelBytes == 1 )
|
||||
{
|
||||
padfSamples[iSample++] = *pabyData;
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_UINT && nPixelBytes == 2 )
|
||||
{
|
||||
padfSamples[iSample++] = ((uint16 *) pabyData)[0];
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_UINT && nPixelBytes == 4 )
|
||||
{
|
||||
padfSamples[iSample++] = ((uint32 *) pabyData)[0];
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_INT && nPixelBytes == 2 )
|
||||
{
|
||||
padfSamples[iSample++] = ((int16 *) pabyData)[0];
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_INT && nPixelBytes == 32 )
|
||||
{
|
||||
padfSamples[iSample++] = ((int32 *) pabyData)[0];
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_IEEEFP && nPixelBytes == 4 )
|
||||
{
|
||||
padfSamples[iSample++] = ((float *) pabyData)[0];
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_IEEEFP && nPixelBytes == 8 )
|
||||
{
|
||||
padfSamples[iSample++] = ((double *) pabyData)[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_SetSample() */
|
||||
/************************************************************************/
|
||||
|
||||
static void
|
||||
TIFF_SetSample( unsigned char * pabyData, int nPixelBytes, int nSampleFormat,
|
||||
double dfValue )
|
||||
|
||||
{
|
||||
if( nSampleFormat == SAMPLEFORMAT_UINT && nPixelBytes == 1 )
|
||||
{
|
||||
*pabyData = (unsigned char) MAX(0,MIN(255,dfValue));
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_UINT && nPixelBytes == 2 )
|
||||
{
|
||||
*((uint16 *)pabyData) = (uint16) MAX(0,MIN(65535,dfValue));
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_UINT && nPixelBytes == 4 )
|
||||
{
|
||||
*((uint32 *)pabyData) = (uint32) dfValue;
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_INT && nPixelBytes == 2 )
|
||||
{
|
||||
*((int16 *)pabyData) = (int16) MAX(-32768,MIN(32767,dfValue));
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_INT && nPixelBytes == 32 )
|
||||
{
|
||||
*((int32 *)pabyData) = (int32) dfValue;
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_IEEEFP && nPixelBytes == 4 )
|
||||
{
|
||||
*((float *)pabyData) = (float) dfValue;
|
||||
}
|
||||
else if( nSampleFormat == SAMPLEFORMAT_IEEEFP && nPixelBytes == 8 )
|
||||
{
|
||||
*((double *)pabyData) = dfValue;
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_DownSample() */
|
||||
/* */
|
||||
/* Down sample a tile of full res data into a window of a tile */
|
||||
/* of downsampled data. */
|
||||
/************************************************************************/
|
||||
|
||||
static
|
||||
void TIFF_DownSample( unsigned char *pabySrcTile,
|
||||
uint32 nBlockXSize, uint32 nBlockYSize,
|
||||
int nPixelSkewBits, int nBitsPerPixel,
|
||||
unsigned char * pabyOTile,
|
||||
uint32 nOBlockXSize, uint32 nOBlockYSize,
|
||||
uint32 nTXOff, uint32 nTYOff, int nOMult,
|
||||
int nSampleFormat, const char * pszResampling )
|
||||
|
||||
{
|
||||
uint32 i, j;
|
||||
int k, nPixelBytes = (nBitsPerPixel) / 8;
|
||||
int nPixelGroupBytes = (nBitsPerPixel+nPixelSkewBits)/8;
|
||||
unsigned char *pabySrc, *pabyDst;
|
||||
double *padfSamples;
|
||||
size_t tpadfSamples_size, padfSamples_size;
|
||||
|
||||
assert( nBitsPerPixel >= 8 );
|
||||
|
||||
/* sizeof(double) * nOMult * nOMult */
|
||||
tpadfSamples_size=nOMult*nOMult;
|
||||
if ((nOMult != 0) && (tpadfSamples_size/nOMult == (size_t) nOMult)) {
|
||||
padfSamples_size=tpadfSamples_size;
|
||||
tpadfSamples_size=padfSamples_size*sizeof(double);
|
||||
if ((tpadfSamples_size / padfSamples_size) == sizeof(double))
|
||||
padfSamples_size=tpadfSamples_size;
|
||||
else
|
||||
padfSamples_size=0;
|
||||
} else {
|
||||
padfSamples_size=0;
|
||||
}
|
||||
if (padfSamples_size == 0) {
|
||||
/* TODO: This is an error condition */
|
||||
return;
|
||||
}
|
||||
padfSamples = (double *) malloc(padfSamples_size);
|
||||
|
||||
/* ==================================================================== */
|
||||
/* Loop over scanline chunks to process, establishing where the */
|
||||
/* data is going. */
|
||||
/* ==================================================================== */
|
||||
for( j = 0; j*nOMult < nBlockYSize; j++ )
|
||||
{
|
||||
if( j + nTYOff >= nOBlockYSize )
|
||||
break;
|
||||
|
||||
pabyDst = pabyOTile + ((j+nTYOff)*nOBlockXSize + nTXOff)
|
||||
* nPixelBytes * nPixelGroupBytes;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Handler nearest resampling ... we don't even care about the */
|
||||
/* data type, we just do a bytewise copy. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
if( strncmp(pszResampling,"nearest",4) == 0
|
||||
|| strncmp(pszResampling,"NEAR",4) == 0 )
|
||||
{
|
||||
pabySrc = pabySrcTile + j*nOMult*nBlockXSize * nPixelGroupBytes;
|
||||
|
||||
for( i = 0; i*nOMult < nBlockXSize; i++ )
|
||||
{
|
||||
if( i + nTXOff >= nOBlockXSize )
|
||||
break;
|
||||
|
||||
/*
|
||||
* For now use simple subsampling, from the top left corner
|
||||
* of the source block of pixels.
|
||||
*/
|
||||
|
||||
for( k = 0; k < nPixelBytes; k++ )
|
||||
pabyDst[k] = pabySrc[k];
|
||||
|
||||
pabyDst += nPixelBytes * nPixelGroupBytes;
|
||||
pabySrc += nOMult * nPixelGroupBytes;
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Handle the case of averaging. For this we also have to */
|
||||
/* handle each sample format we are concerned with. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
else if( strncmp(pszResampling,"averag",6) == 0
|
||||
|| strncmp(pszResampling,"AVERAG",6) == 0 )
|
||||
{
|
||||
pabySrc = pabySrcTile + j*nOMult*nBlockXSize * nPixelGroupBytes;
|
||||
|
||||
for( i = 0; i*nOMult < nBlockXSize; i++ )
|
||||
{
|
||||
double dfTotal;
|
||||
uint32 nXSize, nYSize, iSample;
|
||||
|
||||
if( i + nTXOff >= nOBlockXSize )
|
||||
break;
|
||||
|
||||
nXSize = MIN((uint32)nOMult,nBlockXSize-i);
|
||||
nYSize = MIN((uint32)nOMult,nBlockYSize-j);
|
||||
|
||||
TIFF_GetSourceSamples( padfSamples, pabySrc,
|
||||
nPixelBytes, nSampleFormat,
|
||||
nXSize, nYSize,
|
||||
nPixelGroupBytes,
|
||||
nPixelGroupBytes * nBlockXSize );
|
||||
|
||||
dfTotal = 0;
|
||||
for( iSample = 0; iSample < nXSize*nYSize; iSample++ )
|
||||
{
|
||||
dfTotal += padfSamples[iSample];
|
||||
}
|
||||
|
||||
TIFF_SetSample( pabyDst, nPixelBytes, nSampleFormat,
|
||||
dfTotal / (nXSize*nYSize) );
|
||||
|
||||
pabySrc += nOMult * nPixelGroupBytes;
|
||||
pabyDst += nPixelBytes;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
free( padfSamples );
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_DownSample_Subsampled() */
|
||||
/************************************************************************/
|
||||
static
|
||||
void TIFF_DownSample_Subsampled( unsigned char *pabySrcTile, int nSample,
|
||||
uint32 nBlockXSize, uint32 nBlockYSize,
|
||||
unsigned char * pabyOTile,
|
||||
uint32 nOBlockXSize, uint32 nOBlockYSize,
|
||||
uint32 nTXOff, uint32 nTYOff, int nOMult,
|
||||
const char *pszResampling,
|
||||
int nHorSubsampling, int nVerSubsampling )
|
||||
{
|
||||
/* TODO: test with variety of subsampling values, and incovinient tile/strip sizes */
|
||||
int nSampleBlockSize;
|
||||
int nSourceSampleRowSize;
|
||||
int nDestSampleRowSize;
|
||||
uint32 nSourceX, nSourceY;
|
||||
uint32 nSourceXSec, nSourceYSec;
|
||||
uint32 nSourceXSecEnd, nSourceYSecEnd;
|
||||
uint32 nDestX, nDestY;
|
||||
int nSampleOffsetInSampleBlock;
|
||||
unsigned int nCummulator;
|
||||
unsigned int nCummulatorCount;
|
||||
|
||||
nSampleBlockSize = nHorSubsampling * nVerSubsampling + 2;
|
||||
nSourceSampleRowSize =
|
||||
( ( nBlockXSize + nHorSubsampling - 1 ) / nHorSubsampling ) * nSampleBlockSize;
|
||||
nDestSampleRowSize =
|
||||
( ( nOBlockXSize + nHorSubsampling - 1 ) / nHorSubsampling ) * nSampleBlockSize;
|
||||
|
||||
if( strncmp(pszResampling,"nearest",4) == 0
|
||||
|| strncmp(pszResampling,"NEAR",4) == 0 )
|
||||
{
|
||||
if( nSample == 0 )
|
||||
{
|
||||
for( nSourceY = 0, nDestY = nTYOff;
|
||||
nSourceY < nBlockYSize;
|
||||
nSourceY += nOMult, nDestY ++)
|
||||
{
|
||||
if( nDestY >= nOBlockYSize )
|
||||
break;
|
||||
|
||||
for( nSourceX = 0, nDestX = nTXOff;
|
||||
nSourceX < nBlockXSize;
|
||||
nSourceX += nOMult, nDestX ++)
|
||||
{
|
||||
if( nDestX >= nOBlockXSize )
|
||||
break;
|
||||
|
||||
* ( pabyOTile + ( nDestY / nVerSubsampling ) * nDestSampleRowSize
|
||||
+ ( nDestY % nVerSubsampling ) * nHorSubsampling
|
||||
+ ( nDestX / nHorSubsampling ) * nSampleBlockSize
|
||||
+ ( nDestX % nHorSubsampling ) ) =
|
||||
* ( pabySrcTile + ( nSourceY / nVerSubsampling ) * nSourceSampleRowSize
|
||||
+ ( nSourceY % nVerSubsampling ) * nHorSubsampling
|
||||
+ ( nSourceX / nHorSubsampling ) * nSampleBlockSize
|
||||
+ ( nSourceX % nHorSubsampling ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nSampleOffsetInSampleBlock = nHorSubsampling * nVerSubsampling + nSample - 1;
|
||||
for( nSourceY = 0, nDestY = ( nTYOff / nVerSubsampling );
|
||||
nSourceY < ( nBlockYSize / nVerSubsampling );
|
||||
nSourceY += nOMult, nDestY ++)
|
||||
{
|
||||
if( nDestY*nVerSubsampling >= nOBlockYSize )
|
||||
break;
|
||||
|
||||
for( nSourceX = 0, nDestX = ( nTXOff / nHorSubsampling );
|
||||
nSourceX < ( nBlockXSize / nHorSubsampling );
|
||||
nSourceX += nOMult, nDestX ++)
|
||||
{
|
||||
if( nDestX*nHorSubsampling >= nOBlockXSize )
|
||||
break;
|
||||
|
||||
* ( pabyOTile + nDestY * nDestSampleRowSize
|
||||
+ nDestX * nSampleBlockSize
|
||||
+ nSampleOffsetInSampleBlock ) =
|
||||
* ( pabySrcTile + nSourceY * nSourceSampleRowSize
|
||||
+ nSourceX * nSampleBlockSize
|
||||
+ nSampleOffsetInSampleBlock );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if( strncmp(pszResampling,"averag",6) == 0
|
||||
|| strncmp(pszResampling,"AVERAG",6) == 0 )
|
||||
{
|
||||
if( nSample == 0 )
|
||||
{
|
||||
for( nSourceY = 0, nDestY = nTYOff; nSourceY < nBlockYSize; nSourceY += nOMult, nDestY ++)
|
||||
{
|
||||
if( nDestY >= nOBlockYSize )
|
||||
break;
|
||||
|
||||
for( nSourceX = 0, nDestX = nTXOff; nSourceX < nBlockXSize; nSourceX += nOMult, nDestX ++)
|
||||
{
|
||||
if( nDestX >= nOBlockXSize )
|
||||
break;
|
||||
|
||||
nSourceXSecEnd = nSourceX + nOMult;
|
||||
if( nSourceXSecEnd > nBlockXSize )
|
||||
nSourceXSecEnd = nBlockXSize;
|
||||
nSourceYSecEnd = nSourceY + nOMult;
|
||||
if( nSourceYSecEnd > nBlockYSize )
|
||||
nSourceYSecEnd = nBlockYSize;
|
||||
nCummulator = 0;
|
||||
for( nSourceYSec = nSourceY; nSourceYSec < nSourceYSecEnd; nSourceYSec ++)
|
||||
{
|
||||
for( nSourceXSec = nSourceX; nSourceXSec < nSourceXSecEnd; nSourceXSec ++)
|
||||
{
|
||||
nCummulator += * ( pabySrcTile + ( nSourceYSec / nVerSubsampling ) * nSourceSampleRowSize
|
||||
+ ( nSourceYSec % nVerSubsampling ) * nHorSubsampling
|
||||
+ ( nSourceXSec / nHorSubsampling ) * nSampleBlockSize
|
||||
+ ( nSourceXSec % nHorSubsampling ) );
|
||||
}
|
||||
}
|
||||
nCummulatorCount = ( nSourceXSecEnd - nSourceX ) * ( nSourceYSecEnd - nSourceY );
|
||||
* ( pabyOTile + ( nDestY / nVerSubsampling ) * nDestSampleRowSize
|
||||
+ ( nDestY % nVerSubsampling ) * nHorSubsampling
|
||||
+ ( nDestX / nHorSubsampling ) * nSampleBlockSize
|
||||
+ ( nDestX % nHorSubsampling ) ) =
|
||||
( ( nCummulator + ( nCummulatorCount >> 1 ) ) / nCummulatorCount );
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nSampleOffsetInSampleBlock = nHorSubsampling * nVerSubsampling + nSample - 1;
|
||||
for( nSourceY = 0, nDestY = ( nTYOff / nVerSubsampling ); nSourceY < ( nBlockYSize / nVerSubsampling );
|
||||
nSourceY += nOMult, nDestY ++)
|
||||
{
|
||||
if( nDestY*nVerSubsampling >= nOBlockYSize )
|
||||
break;
|
||||
|
||||
for( nSourceX = 0, nDestX = ( nTXOff / nHorSubsampling ); nSourceX < ( nBlockXSize / nHorSubsampling );
|
||||
nSourceX += nOMult, nDestX ++)
|
||||
{
|
||||
if( nDestX*nHorSubsampling >= nOBlockXSize )
|
||||
break;
|
||||
|
||||
nSourceXSecEnd = nSourceX + nOMult;
|
||||
if( nSourceXSecEnd > ( nBlockXSize / nHorSubsampling ) )
|
||||
nSourceXSecEnd = ( nBlockXSize / nHorSubsampling );
|
||||
nSourceYSecEnd = nSourceY + nOMult;
|
||||
if( nSourceYSecEnd > ( nBlockYSize / nVerSubsampling ) )
|
||||
nSourceYSecEnd = ( nBlockYSize / nVerSubsampling );
|
||||
nCummulator = 0;
|
||||
for( nSourceYSec = nSourceY; nSourceYSec < nSourceYSecEnd; nSourceYSec ++)
|
||||
{
|
||||
for( nSourceXSec = nSourceX; nSourceXSec < nSourceXSecEnd; nSourceXSec ++)
|
||||
{
|
||||
nCummulator += * ( pabySrcTile + nSourceYSec * nSourceSampleRowSize
|
||||
+ nSourceXSec * nSampleBlockSize
|
||||
+ nSampleOffsetInSampleBlock );
|
||||
}
|
||||
}
|
||||
nCummulatorCount = ( nSourceXSecEnd - nSourceX ) * ( nSourceYSecEnd - nSourceY );
|
||||
* ( pabyOTile + nDestY * nDestSampleRowSize
|
||||
+ nDestX * nSampleBlockSize
|
||||
+ nSampleOffsetInSampleBlock ) =
|
||||
( ( nCummulator + ( nCummulatorCount >> 1 ) ) / nCummulatorCount );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_ProcessFullResBlock() */
|
||||
/* */
|
||||
/* Process one block of full res data, downsampling into each */
|
||||
/* of the overviews. */
|
||||
/************************************************************************/
|
||||
|
||||
void TIFF_ProcessFullResBlock( TIFF *hTIFF, int nPlanarConfig,
|
||||
int bSubsampled,
|
||||
int nHorSubsampling, int nVerSubsampling,
|
||||
int nOverviews, int * panOvList,
|
||||
int nBitsPerPixel,
|
||||
int nSamples, TIFFOvrCache ** papoRawBIs,
|
||||
uint32 nSXOff, uint32 nSYOff,
|
||||
unsigned char *pabySrcTile,
|
||||
uint32 nBlockXSize, uint32 nBlockYSize,
|
||||
int nSampleFormat, const char * pszResampling )
|
||||
|
||||
{
|
||||
int iOverview, iSample;
|
||||
|
||||
for( iSample = 0; iSample < nSamples; iSample++ )
|
||||
{
|
||||
/*
|
||||
* We have to read a tile/strip for each sample for
|
||||
* PLANARCONFIG_SEPARATE. Otherwise, we just read all the samples
|
||||
* at once when handling the first sample.
|
||||
*/
|
||||
if( nPlanarConfig == PLANARCONFIG_SEPARATE || iSample == 0 )
|
||||
{
|
||||
if( TIFFIsTiled(hTIFF) )
|
||||
{
|
||||
TIFFReadEncodedTile( hTIFF,
|
||||
TIFFComputeTile(hTIFF, nSXOff, nSYOff,
|
||||
0, (tsample_t)iSample ),
|
||||
pabySrcTile,
|
||||
TIFFTileSize(hTIFF));
|
||||
}
|
||||
else
|
||||
{
|
||||
TIFFReadEncodedStrip( hTIFF,
|
||||
TIFFComputeStrip(hTIFF, nSYOff,
|
||||
(tsample_t) iSample),
|
||||
pabySrcTile,
|
||||
TIFFStripSize(hTIFF) );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Loop over destination overview layers
|
||||
*/
|
||||
for( iOverview = 0; iOverview < nOverviews; iOverview++ )
|
||||
{
|
||||
TIFFOvrCache *poRBI = papoRawBIs[iOverview];
|
||||
unsigned char *pabyOTile;
|
||||
uint32 nTXOff, nTYOff, nOXOff, nOYOff, nOMult;
|
||||
uint32 nOBlockXSize = poRBI->nBlockXSize;
|
||||
uint32 nOBlockYSize = poRBI->nBlockYSize;
|
||||
int nSkewBits, nSampleByteOffset;
|
||||
|
||||
/*
|
||||
* Fetch the destination overview tile
|
||||
*/
|
||||
nOMult = panOvList[iOverview];
|
||||
nOXOff = (nSXOff/nOMult) / nOBlockXSize;
|
||||
nOYOff = (nSYOff/nOMult) / nOBlockYSize;
|
||||
|
||||
if( bSubsampled )
|
||||
{
|
||||
pabyOTile = TIFFGetOvrBlock_Subsampled( poRBI, nOXOff, nOYOff );
|
||||
|
||||
/*
|
||||
* Establish the offset into this tile at which we should
|
||||
* start placing data.
|
||||
*/
|
||||
nTXOff = (nSXOff - nOXOff*nOMult*nOBlockXSize) / nOMult;
|
||||
nTYOff = (nSYOff - nOYOff*nOMult*nOBlockYSize) / nOMult;
|
||||
|
||||
|
||||
#ifdef DBMALLOC
|
||||
malloc_chain_check( 1 );
|
||||
#endif
|
||||
TIFF_DownSample_Subsampled( pabySrcTile, iSample,
|
||||
nBlockXSize, nBlockYSize,
|
||||
pabyOTile,
|
||||
poRBI->nBlockXSize, poRBI->nBlockYSize,
|
||||
nTXOff, nTYOff,
|
||||
nOMult, pszResampling,
|
||||
nHorSubsampling, nVerSubsampling );
|
||||
#ifdef DBMALLOC
|
||||
malloc_chain_check( 1 );
|
||||
#endif
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
pabyOTile = TIFFGetOvrBlock( poRBI, nOXOff, nOYOff, iSample );
|
||||
|
||||
/*
|
||||
* Establish the offset into this tile at which we should
|
||||
* start placing data.
|
||||
*/
|
||||
nTXOff = (nSXOff - nOXOff*nOMult*nOBlockXSize) / nOMult;
|
||||
nTYOff = (nSYOff - nOYOff*nOMult*nOBlockYSize) / nOMult;
|
||||
|
||||
/*
|
||||
* Figure out the skew (extra space between ``our samples'') and
|
||||
* the byte offset to the first sample.
|
||||
*/
|
||||
assert( (nBitsPerPixel % 8) == 0 );
|
||||
if( nPlanarConfig == PLANARCONFIG_SEPARATE )
|
||||
{
|
||||
nSkewBits = 0;
|
||||
nSampleByteOffset = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
nSkewBits = nBitsPerPixel * (nSamples-1);
|
||||
nSampleByteOffset = (nBitsPerPixel/8) * iSample;
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform the downsampling.
|
||||
*/
|
||||
#ifdef DBMALLOC
|
||||
malloc_chain_check( 1 );
|
||||
#endif
|
||||
TIFF_DownSample( pabySrcTile + nSampleByteOffset,
|
||||
nBlockXSize, nBlockYSize,
|
||||
nSkewBits, nBitsPerPixel, pabyOTile,
|
||||
poRBI->nBlockXSize, poRBI->nBlockYSize,
|
||||
nTXOff, nTYOff,
|
||||
nOMult, nSampleFormat, pszResampling );
|
||||
#ifdef DBMALLOC
|
||||
malloc_chain_check( 1 );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
/* TIFF_BuildOverviews() */
|
||||
/* */
|
||||
/* Build the requested list of overviews. Overviews are */
|
||||
/* maintained in a bunch of temporary files and then these are */
|
||||
/* written back to the TIFF file. Only one pass through the */
|
||||
/* source TIFF file is made for any number of output */
|
||||
/* overviews. */
|
||||
/************************************************************************/
|
||||
|
||||
void TIFFBuildOverviews( TIFF *hTIFF, int nOverviews, int * panOvList,
|
||||
int bUseSubIFDs, const char *pszResampleMethod,
|
||||
int (*pfnProgress)( double, void * ),
|
||||
void * pProgressData )
|
||||
|
||||
{
|
||||
TIFFOvrCache **papoRawBIs;
|
||||
uint32 nXSize, nYSize, nBlockXSize, nBlockYSize;
|
||||
uint16 nBitsPerPixel, nPhotometric, nCompressFlag, nSamples,
|
||||
nPlanarConfig, nSampleFormat;
|
||||
int bSubsampled;
|
||||
uint16 nHorSubsampling, nVerSubsampling;
|
||||
int bTiled, nSXOff, nSYOff, i;
|
||||
unsigned char *pabySrcTile;
|
||||
uint16 *panRedMap, *panGreenMap, *panBlueMap;
|
||||
TIFFErrorHandler pfnWarning;
|
||||
|
||||
(void) pfnProgress;
|
||||
(void) pProgressData;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Get the base raster size. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
TIFFGetField( hTIFF, TIFFTAG_IMAGEWIDTH, &nXSize );
|
||||
TIFFGetField( hTIFF, TIFFTAG_IMAGELENGTH, &nYSize );
|
||||
|
||||
TIFFGetField( hTIFF, TIFFTAG_BITSPERSAMPLE, &nBitsPerPixel );
|
||||
/* TODO: nBitsPerPixel seems misnomer and may need renaming to nBitsPerSample */
|
||||
TIFFGetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL, &nSamples );
|
||||
TIFFGetFieldDefaulted( hTIFF, TIFFTAG_PLANARCONFIG, &nPlanarConfig );
|
||||
|
||||
TIFFGetFieldDefaulted( hTIFF, TIFFTAG_PHOTOMETRIC, &nPhotometric );
|
||||
TIFFGetFieldDefaulted( hTIFF, TIFFTAG_COMPRESSION, &nCompressFlag );
|
||||
TIFFGetFieldDefaulted( hTIFF, TIFFTAG_SAMPLEFORMAT, &nSampleFormat );
|
||||
|
||||
if( nPhotometric == PHOTOMETRIC_YCBCR || nPhotometric == PHOTOMETRIC_ITULAB )
|
||||
{
|
||||
if( nBitsPerPixel != 8 || nSamples != 3 || nPlanarConfig != PLANARCONFIG_CONTIG ||
|
||||
nSampleFormat != SAMPLEFORMAT_UINT)
|
||||
{
|
||||
/* TODO: use of TIFFError is inconsistent with use of fprintf in addtiffo.c, sort out */
|
||||
TIFFErrorExt( TIFFClientdata(hTIFF), "TIFFBuildOverviews",
|
||||
"File `%s' has an unsupported subsampling configuration.\n",
|
||||
TIFFFileName(hTIFF) );
|
||||
/* If you need support for this particular flavor, please contact either
|
||||
* Frank Warmerdam warmerdam@pobox.com
|
||||
* Joris Van Damme info@awaresystems.be
|
||||
*/
|
||||
return;
|
||||
}
|
||||
bSubsampled = 1;
|
||||
TIFFGetField( hTIFF, TIFFTAG_YCBCRSUBSAMPLING, &nHorSubsampling, &nVerSubsampling );
|
||||
/* TODO: find out if maybe TIFFGetFieldDefaulted is better choice for YCbCrSubsampling tag */
|
||||
}
|
||||
else
|
||||
{
|
||||
if( nBitsPerPixel < 8 )
|
||||
{
|
||||
/* TODO: use of TIFFError is inconsistent with use of fprintf in addtiffo.c, sort out */
|
||||
TIFFErrorExt( TIFFClientdata(hTIFF), "TIFFBuildOverviews",
|
||||
"File `%s' has samples of %d bits per sample. Sample\n"
|
||||
"sizes of less than 8 bits per sample are not supported.\n",
|
||||
TIFFFileName(hTIFF), nBitsPerPixel );
|
||||
return;
|
||||
}
|
||||
bSubsampled = 0;
|
||||
nHorSubsampling = 1;
|
||||
nVerSubsampling = 1;
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Turn off warnings to avoid alot of repeated warnings while */
|
||||
/* rereading directories. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
pfnWarning = TIFFSetWarningHandler( NULL );
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Get the base raster block size. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
if( TIFFGetField( hTIFF, TIFFTAG_ROWSPERSTRIP, &(nBlockYSize) ) )
|
||||
{
|
||||
nBlockXSize = nXSize;
|
||||
bTiled = FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
TIFFGetField( hTIFF, TIFFTAG_TILEWIDTH, &nBlockXSize );
|
||||
TIFFGetField( hTIFF, TIFFTAG_TILELENGTH, &nBlockYSize );
|
||||
bTiled = TRUE;
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Capture the pallette if there is one. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
if( TIFFGetField( hTIFF, TIFFTAG_COLORMAP,
|
||||
&panRedMap, &panGreenMap, &panBlueMap ) )
|
||||
{
|
||||
uint16 *panRed2, *panGreen2, *panBlue2;
|
||||
int nColorCount = 1 << nBitsPerPixel;
|
||||
|
||||
panRed2 = (uint16 *) _TIFFmalloc(2*nColorCount);
|
||||
panGreen2 = (uint16 *) _TIFFmalloc(2*nColorCount);
|
||||
panBlue2 = (uint16 *) _TIFFmalloc(2*nColorCount);
|
||||
|
||||
memcpy( panRed2, panRedMap, 2 * nColorCount );
|
||||
memcpy( panGreen2, panGreenMap, 2 * nColorCount );
|
||||
memcpy( panBlue2, panBlueMap, 2 * nColorCount );
|
||||
|
||||
panRedMap = panRed2;
|
||||
panGreenMap = panGreen2;
|
||||
panBlueMap = panBlue2;
|
||||
}
|
||||
else
|
||||
{
|
||||
panRedMap = panGreenMap = panBlueMap = NULL;
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Initialize overviews. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
papoRawBIs = (TIFFOvrCache **) _TIFFmalloc(nOverviews*sizeof(void*));
|
||||
|
||||
for( i = 0; i < nOverviews; i++ )
|
||||
{
|
||||
uint32 nOXSize, nOYSize, nOBlockXSize, nOBlockYSize;
|
||||
toff_t nDirOffset;
|
||||
|
||||
nOXSize = (nXSize + panOvList[i] - 1) / panOvList[i];
|
||||
nOYSize = (nYSize + panOvList[i] - 1) / panOvList[i];
|
||||
|
||||
nOBlockXSize = MIN(nBlockXSize,nOXSize);
|
||||
nOBlockYSize = MIN(nBlockYSize,nOYSize);
|
||||
|
||||
if( bTiled )
|
||||
{
|
||||
if( (nOBlockXSize % 16) != 0 )
|
||||
nOBlockXSize = nOBlockXSize + 16 - (nOBlockXSize % 16);
|
||||
|
||||
if( (nOBlockYSize % 16) != 0 )
|
||||
nOBlockYSize = nOBlockYSize + 16 - (nOBlockYSize % 16);
|
||||
}
|
||||
|
||||
nDirOffset = TIFF_WriteOverview( hTIFF, nOXSize, nOYSize,
|
||||
nBitsPerPixel, nPlanarConfig,
|
||||
nSamples, nOBlockXSize, nOBlockYSize,
|
||||
bTiled, nCompressFlag, nPhotometric,
|
||||
nSampleFormat,
|
||||
panRedMap, panGreenMap, panBlueMap,
|
||||
bUseSubIFDs,
|
||||
nHorSubsampling, nVerSubsampling );
|
||||
|
||||
papoRawBIs[i] = TIFFCreateOvrCache( hTIFF, nDirOffset );
|
||||
}
|
||||
|
||||
if( panRedMap != NULL )
|
||||
{
|
||||
_TIFFfree( panRedMap );
|
||||
_TIFFfree( panGreenMap );
|
||||
_TIFFfree( panBlueMap );
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Allocate a buffer to hold a source block. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
if( bTiled )
|
||||
pabySrcTile = (unsigned char *) _TIFFmalloc(TIFFTileSize(hTIFF));
|
||||
else
|
||||
pabySrcTile = (unsigned char *) _TIFFmalloc(TIFFStripSize(hTIFF));
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Loop over the source raster, applying data to the */
|
||||
/* destination raster. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
for( nSYOff = 0; nSYOff < (int) nYSize; nSYOff += nBlockYSize )
|
||||
{
|
||||
for( nSXOff = 0; nSXOff < (int) nXSize; nSXOff += nBlockXSize )
|
||||
{
|
||||
/*
|
||||
* Read and resample into the various overview images.
|
||||
*/
|
||||
|
||||
TIFF_ProcessFullResBlock( hTIFF, nPlanarConfig,
|
||||
bSubsampled,nHorSubsampling,nVerSubsampling,
|
||||
nOverviews, panOvList,
|
||||
nBitsPerPixel, nSamples, papoRawBIs,
|
||||
nSXOff, nSYOff, pabySrcTile,
|
||||
nBlockXSize, nBlockYSize,
|
||||
nSampleFormat, pszResampleMethod );
|
||||
}
|
||||
}
|
||||
|
||||
_TIFFfree( pabySrcTile );
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Cleanup the rawblockedimage files. */
|
||||
/* -------------------------------------------------------------------- */
|
||||
for( i = 0; i < nOverviews; i++ )
|
||||
{
|
||||
TIFFDestroyOvrCache( papoRawBIs[i] );
|
||||
}
|
||||
|
||||
if( papoRawBIs != NULL )
|
||||
_TIFFfree( papoRawBIs );
|
||||
|
||||
TIFFSetWarningHandler( pfnWarning );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Local Variables:
|
||||
* mode: c
|
||||
* c-basic-offset: 4
|
||||
* fill-column: 78
|
||||
* End:
|
||||
*/
|
||||
Reference in New Issue
Block a user