src/tiff/contrib/addtiffo/tif_ovrcache.c

   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 }