/****************************************************************************** * $Id: rawdataset.cpp,v 1.27 2005/05/23 06:53:45 fwarmerdam Exp $ * * Project: Generic Raw Binary Driver * Purpose: Implementation of RawDataset and RawRasterBand classes. * Author: Frank Warmerdam, warmerda@pobox.com * ****************************************************************************** * 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. ****************************************************************************** * * $Log: rawdataset.cpp,v $ * Revision 1.27 2005/05/23 06:53:45 fwarmerdam * Avoid IsBlockCached() * * Revision 1.26 2004/11/02 20:21:38 fwarmerdam * added support for category names * * Revision 1.25 2004/06/02 20:57:55 warmerda * centralize initialization * * Revision 1.24 2004/06/02 20:54:42 warmerda * Ensure poCT and eInterp are initialize in the *other* constructor. * * Revision 1.23 2004/05/28 18:16:22 warmerda * Added support for hold colortable and interp on RawRasterBand * * Revision 1.22 2004/04/06 19:25:31 dron * Use GDALRasterBand::IsBlockCached() instead of GDALRasterBlock::IsCached(). * * Revision 1.21 2003/07/27 11:08:19 dron * Added some heuristic to switch between cached and direct IRasterIO() * implementations. * * Revision 1.20 2003/07/16 19:29:09 warmerda * use overviews in IRasterIO() on reads when appropriate * * Revision 1.19 2003/07/08 21:10:19 warmerda * avoid warnings * * Revision 1.18 2003/05/18 11:05:07 dron * Fixed problem in IRasterIO(). * * Revision 1.17 2003/05/02 16:00:17 dron * Implemented RawRasterBand::IRasterIO() method. Introduced `dirty' flag. * * Revision 1.16 2003/03/18 05:59:41 warmerda * Added FlushCache() implementation that uses fflush() to force * everything out. * * Revision 1.15 2002/11/23 18:54:47 warmerda * added setnodatavalue * * Revision 1.14 2002/02/07 15:14:59 warmerda * ensure that no more bytes are read or written than necessary * * Revision 1.13 2001/12/14 19:18:38 ldjohn * Typecast offset parameter to Seek for large file support. * * Revision 1.12 2001/12/12 18:41:33 warmerda * don't pass vsi_l_offset values in debug calls * * Revision 1.11 2001/12/12 18:15:46 warmerda * preliminary update for large raw file support * * Revision 1.10 2001/07/18 04:51:57 warmerda * added CPL_CVSID * * Revision 1.9 2001/03/26 18:31:55 warmerda * Fixed nodata handling in first constructor. * * Revision 1.8 2001/03/23 03:25:32 warmerda * Added nodata support * * Revision 1.7 2001/01/03 18:54:25 warmerda * improved seek error message * * Revision 1.6 2000/08/16 15:51:17 warmerda * allow floating (datasetless) raw bands * * Revision 1.5 2000/08/09 16:26:27 warmerda * improved error checking * * Revision 1.4 2000/06/05 17:24:06 warmerda * added real complex support * * Revision 1.3 2000/03/31 13:36:40 warmerda * RawRasterBand no longer depends on RawDataset * * Revision 1.2 1999/08/13 02:36:57 warmerda * added write support * * Revision 1.1 1999/07/23 19:34:34 warmerda * New * */ #include "rawdataset.h" #include "cpl_conv.h" #include "cpl_string.h" CPL_CVSID("$Id: rawdataset.cpp,v 1.27 2005/05/23 06:53:45 fwarmerdam Exp $"); /************************************************************************/ /* RawRasterBand() */ /************************************************************************/ RawRasterBand::RawRasterBand( GDALDataset *poDS, int nBand, FILE * fpRaw, vsi_l_offset nImgOffset, int nPixelOffset, int nLineOffset, GDALDataType eDataType, int bNativeOrder, int bIsVSIL ) { Initialize(); this->poDS = poDS; this->nBand = nBand; this->eDataType = eDataType; this->bIsVSIL = bIsVSIL; this->fpRaw = fpRaw; this->nImgOffset = nImgOffset; this->nPixelOffset = nPixelOffset; this->nLineOffset = nLineOffset; this->bNativeOrder = bNativeOrder; CPLDebug( "GDALRaw", "RawRasterBand(%p,%d,%p,\n" " Off=%d,PixOff=%d,LineOff=%d,%s,%d)\n", poDS, nBand, fpRaw, (unsigned int) nImgOffset, nPixelOffset, nLineOffset, GDALGetDataTypeName(eDataType), bNativeOrder ); /* -------------------------------------------------------------------- */ /* Treat one scanline as the block size. */ /* -------------------------------------------------------------------- */ nBlockXSize = poDS->GetRasterXSize(); nBlockYSize = 1; /* -------------------------------------------------------------------- */ /* Allocate working scanline. */ /* -------------------------------------------------------------------- */ nLoadedScanline = -1; nLineSize = nPixelOffset * nBlockXSize; pLineBuffer = CPLMalloc( nLineSize ); } /************************************************************************/ /* RawRasterBand() */ /************************************************************************/ RawRasterBand::RawRasterBand( FILE * fpRaw, vsi_l_offset nImgOffset, int nPixelOffset, int nLineOffset, GDALDataType eDataType, int bNativeOrder, int nXSize, int nYSize, int bIsVSIL ) { Initialize(); this->poDS = NULL; this->nBand = 1; this->eDataType = eDataType; this->bIsVSIL = bIsVSIL; this->fpRaw = fpRaw; this->nImgOffset = nImgOffset; this->nPixelOffset = nPixelOffset; this->nLineOffset = nLineOffset; this->bNativeOrder = bNativeOrder; CPLDebug( "GDALRaw", "RawRasterBand(floating,Off=%d,PixOff=%d,LineOff=%d,%s,%d)\n", (unsigned int) nImgOffset, nPixelOffset, nLineOffset, GDALGetDataTypeName(eDataType), bNativeOrder ); /* -------------------------------------------------------------------- */ /* Treat one scanline as the block size. */ /* -------------------------------------------------------------------- */ nBlockXSize = nXSize; nBlockYSize = 1; nRasterXSize = nXSize; nRasterYSize = nYSize; /* -------------------------------------------------------------------- */ /* Allocate working scanline. */ /* -------------------------------------------------------------------- */ nLoadedScanline = -1; nLineSize = nPixelOffset * nBlockXSize; pLineBuffer = CPLMalloc( nLineSize ); } /************************************************************************/ /* Initialize() */ /************************************************************************/ void RawRasterBand::Initialize() { dfNoDataValue = 0.0; bNoDataSet = FALSE; poCT = NULL; eInterp = GCI_Undefined; papszCategoryNames = NULL; bDirty = FALSE; } /************************************************************************/ /* ~RawRasterBand() */ /************************************************************************/ RawRasterBand::~RawRasterBand() { CSLDestroy( papszCategoryNames ); FlushCache(); CPLFree( pLineBuffer ); } /************************************************************************/ /* FlushCache() */ /* */ /* We override this so we have the opportunity to call */ /* fflush(). We don't want to do this all the time in the */ /* write block function as it is kind of expensive. */ /************************************************************************/ CPLErr RawRasterBand::FlushCache() { CPLErr eErr; eErr = GDALRasterBand::FlushCache(); if( eErr != CE_None ) return eErr; // If we have unflushed raw, flush it to disk now. if ( bDirty ) { if( bIsVSIL ) VSIFFlushL( fpRaw ); else VSIFFlush( fpRaw ); bDirty = FALSE; } return CE_None; } /************************************************************************/ /* AccessLine() */ /************************************************************************/ CPLErr RawRasterBand::AccessLine( int iLine ) { if( nLoadedScanline == iLine ) return CE_None; /* -------------------------------------------------------------------- */ /* Seek to the right line. */ /* -------------------------------------------------------------------- */ if( Seek(nImgOffset + (vsi_l_offset)iLine * nLineOffset, SEEK_SET) == -1 ) { // for now I just set to zero under the assumption we might // be trying to read from a file past the data that has // actually been written out. Eventually we should differentiate // between newly created datasets, and existing datasets. Existing // datasets should generate an error in this case. memset( pLineBuffer, 0, nPixelOffset * nBlockXSize ); nLoadedScanline = iLine; return CE_None; } /* -------------------------------------------------------------------- */ /* Read the line. Take care not to request any more bytes than */ /* are needed, and not to lose a partially successful scanline */ /* read. */ /* -------------------------------------------------------------------- */ int nBytesToRead, nBytesActuallyRead; nBytesToRead = nPixelOffset * (nBlockXSize - 1) + GDALGetDataTypeSize(GetRasterDataType()) / 8; nBytesActuallyRead = Read( pLineBuffer, 1, nBytesToRead ); if( nBytesActuallyRead < nBlockXSize ) { // for now I just set to zero under the assumption we might // be trying to read from a file past the data that has // actually been written out. Eventually we should differentiate // between newly created datasets, and existing datasets. Existing // datasets should generate an error in this case. memset( ((GByte *) pLineBuffer) + nBytesActuallyRead, 0, nBytesToRead - nBytesActuallyRead ); } /* -------------------------------------------------------------------- */ /* Byte swap the interesting data, if required. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pLineBuffer, nWordSize, nBlockXSize, nPixelOffset ); GDALSwapWords( ((GByte *) pLineBuffer)+nWordSize, nWordSize, nBlockXSize, nPixelOffset ); } else GDALSwapWords( pLineBuffer, GDALGetDataTypeSize(eDataType)/8, nBlockXSize, nPixelOffset ); } nLoadedScanline = iLine; return CE_None; } /************************************************************************/ /* IReadBlock() */ /************************************************************************/ CPLErr RawRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { CPLErr eErr = CE_None; CPLAssert( nBlockXOff == 0 ); AccessLine( nBlockYOff ); /* -------------------------------------------------------------------- */ /* Copy data from disk buffer to user block buffer. */ /* -------------------------------------------------------------------- */ GDALCopyWords( pLineBuffer, eDataType, nPixelOffset, pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, nBlockXSize ); return eErr; } /************************************************************************/ /* IWriteBlock() */ /************************************************************************/ CPLErr RawRasterBand::IWriteBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { CPLErr eErr = CE_None; CPLAssert( nBlockXOff == 0 ); /* -------------------------------------------------------------------- */ /* If the data for this band is completely contiguous we don't */ /* have to worry about pre-reading from disk. */ /* -------------------------------------------------------------------- */ if( nPixelOffset > GDALGetDataTypeSize(eDataType) / 8 ) eErr = AccessLine( nBlockYOff ); /* -------------------------------------------------------------------- */ /* Copy data from user buffer into disk buffer. */ /* -------------------------------------------------------------------- */ GDALCopyWords( pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, pLineBuffer, eDataType, nPixelOffset, nBlockXSize ); /* -------------------------------------------------------------------- */ /* Byte swap (if necessary) back into disk order before writing. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pLineBuffer, nWordSize, nBlockXSize, nPixelOffset ); GDALSwapWords( ((GByte *) pLineBuffer)+nWordSize, nWordSize, nBlockXSize, nPixelOffset ); } else GDALSwapWords( pLineBuffer, GDALGetDataTypeSize(eDataType)/8, nBlockXSize, nPixelOffset ); } /* -------------------------------------------------------------------- */ /* Seek to correct location. */ /* -------------------------------------------------------------------- */ if( Seek( nImgOffset + (vsi_l_offset) nBlockYOff * nLineOffset, SEEK_SET ) == -1 ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to seek to scanline %d @ %d to write to file.\n", nBlockYOff, (int) (nImgOffset + nBlockYOff * nLineOffset) ); eErr = CE_Failure; } /* -------------------------------------------------------------------- */ /* Write data buffer. */ /* -------------------------------------------------------------------- */ int nBytesToWrite; nBytesToWrite = nPixelOffset * (nBlockXSize - 1) + GDALGetDataTypeSize(GetRasterDataType()) / 8; if( eErr == CE_None && Write( pLineBuffer, 1, nBytesToWrite ) < (size_t) nBytesToWrite ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to write scanline %d to file.\n", nBlockYOff ); eErr = CE_Failure; } /* -------------------------------------------------------------------- */ /* Byte swap (if necessary) back into machine order so the */ /* buffer is still usable for reading purposes. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { GDALSwapWords( pLineBuffer, GDALGetDataTypeSize(eDataType)/8, nBlockXSize, nPixelOffset ); } bDirty = TRUE; return eErr; } /************************************************************************/ /* AccessBlock() */ /************************************************************************/ CPLErr RawRasterBand::AccessBlock( vsi_l_offset nBlockOff, int nBlockSize, void * pData ) { int nBytesActuallyRead; /* -------------------------------------------------------------------- */ /* Seek to the right block. */ /* -------------------------------------------------------------------- */ if( Seek( nBlockOff, SEEK_SET ) == -1 ) { memset( pData, 0, nBlockSize ); return CE_None; } /* -------------------------------------------------------------------- */ /* Read the block. */ /* -------------------------------------------------------------------- */ nBytesActuallyRead = Read( pData, 1, nBlockSize ); if( nBytesActuallyRead < nBlockSize ) { memset( ((GByte *) pData) + nBytesActuallyRead, 0, nBlockSize - nBytesActuallyRead ); return CE_None; } /* -------------------------------------------------------------------- */ /* Byte swap the interesting data, if required. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pData, nWordSize, nBlockSize / nPixelOffset, nPixelOffset ); GDALSwapWords( ((GByte *) pData) + nWordSize, nWordSize, nBlockSize / nPixelOffset, nPixelOffset ); } else GDALSwapWords( pData, GDALGetDataTypeSize(eDataType) / 8, nBlockSize / nPixelOffset, nPixelOffset ); } return CE_None; } /************************************************************************/ /* IsLineLoaded() */ /* */ /* Check whether at least one scanline from the specified block of */ /* lines is cached. */ /************************************************************************/ int RawRasterBand::IsLineLoaded( int nLineOff, int nLines ) { int iLine; for ( iLine = nLineOff; iLine < nLineOff + nLines; iLine++ ) { GDALRasterBlock *poBlock = TryGetLockedBlockRef( 0, iLine ); if( poBlock != NULL ) { poBlock->DropLock(); return TRUE; } } return FALSE; } /************************************************************************/ /* IRasterIO() */ /************************************************************************/ CPLErr RawRasterBand::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { int nBandDataSize = GDALGetDataTypeSize(eDataType) / 8; int nBufDataSize = GDALGetDataTypeSize( eBufType ) / 8; int nBytesToRW = nPixelOffset * nXSize; /* -------------------------------------------------------------------- */ /* Use direct IO without caching if: */ /* */ /* GDAL_ONE_BIG_READ is enabled */ /* */ /* or */ /* */ /* the length of a scanline on disk is more than 50000 bytes, and the */ /* width of the requested chunk is less than 40% of the whole scanline */ /* and none of the requested scanlines are already in the cache. */ /* -------------------------------------------------------------------- */ if ( !CSLTestBoolean( CPLGetConfigOption( "GDAL_ONE_BIG_READ", "NO") ) ) { if ( nLineSize < 50000 || nBytesToRW > nLineSize / 5 * 2 || IsLineLoaded( nYOff, nYSize ) ) { return GDALRasterBand::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace ); } } /* ==================================================================== */ /* Read data. */ /* ==================================================================== */ if ( eRWFlag == GF_Read ) { /* -------------------------------------------------------------------- */ /* Do we have overviews that would be appropriate to satisfy */ /* this request? */ /* -------------------------------------------------------------------- */ if( (nBufXSize < nXSize || nBufYSize < nYSize) && GetOverviewCount() > 0 ) { if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace ) == CE_None ) return CE_None; } /* ==================================================================== */ /* 1. Simplest case when we should get contiguous block */ /* of uninterleaved pixels. */ /* ==================================================================== */ if ( nXSize == GetXSize() && nXSize == nBufXSize && nYSize == nBufYSize && eBufType == eDataType && nPixelOffset == nBandDataSize && nPixelSpace == nBufDataSize && nLineSpace == nPixelSpace * nXSize ) { if ( AccessBlock( nImgOffset + (vsi_l_offset)nYOff * nLineOffset + nXOff, nXSize * nYSize * nBandDataSize, pData ) != CE_None ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to read %d bytes at %d.", nXSize * nYSize * nBandDataSize, nImgOffset + (vsi_l_offset)nYOff * nLineOffset + nXOff ); } } /* ==================================================================== */ /* 2. Case when we need deinterleave and/or subsample data. */ /* ==================================================================== */ else { GByte *pabyData; double dfSrcXInc, dfSrcYInc; int iLine; dfSrcXInc = (double)nXSize / nBufXSize; dfSrcYInc = (double)nYSize / nBufYSize; pabyData = (GByte *) CPLMalloc( nBytesToRW ); for ( iLine = 0; iLine < nBufYSize; iLine++ ) { if ( AccessBlock( nImgOffset + ((vsi_l_offset)nYOff + (int)(iLine * dfSrcYInc)) * nLineOffset + nXOff * nPixelOffset, nBytesToRW, pabyData ) != CE_None ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to read %d bytes at %d.", nBytesToRW, nImgOffset + ((vsi_l_offset)nYOff + (int)(iLine * dfSrcYInc)) * nLineOffset + nXOff * nPixelOffset ); } /* -------------------------------------------------------------------- */ /* Copy data from disk buffer to user block buffer and subsample, */ /* if needed. */ /* -------------------------------------------------------------------- */ if ( nXSize == nBufXSize && nYSize == nBufYSize ) { GDALCopyWords( pabyData, eDataType, nPixelOffset, (GByte *)pData + iLine * nLineSpace, eBufType, nPixelSpace, nXSize ); } else { int iPixel; for ( iPixel = 0; iPixel < nBufXSize; iPixel++ ) { GDALCopyWords( pabyData + (int)(iPixel * dfSrcXInc) * nPixelOffset, eDataType, 0, (GByte *)pData + iLine * nLineSpace + iPixel * nBufDataSize, eBufType, nPixelSpace, 1 ); } } } CPLFree( pabyData ); } } /* ==================================================================== */ /* Write data. */ /* ==================================================================== */ else { int nBytesActuallyWritten; /* ==================================================================== */ /* 1. Simplest case when we should write contiguous block */ /* of uninterleaved pixels. */ /* ==================================================================== */ if ( nXSize == GetXSize() && nXSize == nBufXSize && nYSize == nBufYSize && eBufType == eDataType && nPixelOffset == nBandDataSize && nPixelSpace == nBufDataSize && nLineSpace == nPixelSpace * nXSize ) { /* -------------------------------------------------------------------- */ /* Byte swap the data buffer, if required. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pData, nWordSize, nXSize, nPixelOffset ); GDALSwapWords( ((GByte *) pData) + nWordSize, nWordSize, nXSize, nPixelOffset ); } else GDALSwapWords( pData, nBandDataSize, nXSize, nPixelOffset ); } /* -------------------------------------------------------------------- */ /* Seek to the right block. */ /* -------------------------------------------------------------------- */ if( Seek( nImgOffset + (vsi_l_offset)nYOff * nLineOffset + nXOff, SEEK_SET) == -1 ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to seek to %d to write data.\n", nImgOffset + (vsi_l_offset)nYOff * nLineOffset + nXOff ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Write the block. */ /* -------------------------------------------------------------------- */ nBytesToRW = nXSize * nYSize * nBandDataSize; nBytesActuallyWritten = Write( pData, 1, nBytesToRW ); if( nBytesActuallyWritten < nBytesToRW ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to write %d bytes to file. %d bytes written", nBytesToRW, nBytesActuallyWritten ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Byte swap (if necessary) back into machine order so the */ /* buffer is still usable for reading purposes. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pData, nWordSize, nXSize, nPixelOffset ); GDALSwapWords( ((GByte *) pData) + nWordSize, nWordSize, nXSize, nPixelOffset ); } else GDALSwapWords( pData, nBandDataSize, nXSize, nPixelOffset ); } } /* ==================================================================== */ /* 2. Case when we need deinterleave and/or subsample data. */ /* ==================================================================== */ else { GByte *pabyData; double dfSrcXInc, dfSrcYInc; vsi_l_offset nBlockOff; int iLine; dfSrcXInc = (double)nXSize / nBufXSize; dfSrcYInc = (double)nYSize / nBufYSize; pabyData = (GByte *) CPLMalloc( nBytesToRW ); for ( iLine = 0; iLine < nBufYSize; iLine++ ) { nBlockOff = nImgOffset + ((vsi_l_offset)nYOff + (int)(iLine*dfSrcYInc))*nLineOffset + nXOff * nPixelOffset; /* -------------------------------------------------------------------- */ /* If the data for this band is completely contiguous we don't */ /* have to worry about pre-reading from disk. */ /* -------------------------------------------------------------------- */ if( nPixelOffset > nBandDataSize ) AccessBlock( nBlockOff, nBytesToRW, pabyData ); /* -------------------------------------------------------------------- */ /* Copy data from user block buffer to disk buffer and subsample, */ /* if needed. */ /* -------------------------------------------------------------------- */ if ( nXSize == nBufXSize && nYSize == nBufYSize ) { GDALCopyWords( (GByte *)pData + iLine * nLineSpace, eBufType, nPixelSpace, pabyData, eDataType, nPixelOffset, nXSize ); } else { int iPixel; for ( iPixel = 0; iPixel < nBufXSize; iPixel++ ) { GDALCopyWords( (GByte *)pData+iLine*nLineSpace + iPixel * nBufDataSize, eBufType, nPixelSpace, pabyData + (int)(iPixel * dfSrcXInc) * nPixelOffset, eDataType, 0, 1 ); } } /* -------------------------------------------------------------------- */ /* Byte swap the data buffer, if required. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pabyData, nWordSize, nXSize, nPixelOffset ); GDALSwapWords( ((GByte *) pabyData) + nWordSize, nWordSize, nXSize, nPixelOffset ); } else GDALSwapWords( pabyData, nBandDataSize, nXSize, nPixelOffset ); } /* -------------------------------------------------------------------- */ /* Seek to the right line in block. */ /* -------------------------------------------------------------------- */ if( Seek( nBlockOff, SEEK_SET) == -1 ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to seek to %d to read.\n", nBlockOff ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Write the line of block. */ /* -------------------------------------------------------------------- */ nBytesActuallyWritten = Write( pabyData, 1, nBytesToRW ); if( nBytesActuallyWritten < nBytesToRW ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to write %d bytes to file. %d bytes written", nBytesToRW, nBytesActuallyWritten ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Byte swap (if necessary) back into machine order so the */ /* buffer is still usable for reading purposes. */ /* -------------------------------------------------------------------- */ if( !bNativeOrder && eDataType != GDT_Byte ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pabyData, nWordSize, nXSize, nPixelOffset ); GDALSwapWords( ((GByte *) pabyData) + nWordSize, nWordSize, nXSize, nPixelOffset ); } else GDALSwapWords( pabyData, nBandDataSize, nXSize, nPixelOffset ); } } bDirty = TRUE; CPLFree( pabyData ); } } return CE_None; } /************************************************************************/ /* Seek() */ /************************************************************************/ int RawRasterBand::Seek( vsi_l_offset nOffset, int nSeekMode ) { if( bIsVSIL ) return VSIFSeekL( fpRaw, nOffset, nSeekMode ); else return VSIFSeek( fpRaw, (long) nOffset, nSeekMode ); } /************************************************************************/ /* Read() */ /************************************************************************/ size_t RawRasterBand::Read( void *pBuffer, size_t nSize, size_t nCount ) { if( bIsVSIL ) return VSIFReadL( pBuffer, nSize, nCount, fpRaw ); else return VSIFRead( pBuffer, nSize, nCount, fpRaw ); } /************************************************************************/ /* Write() */ /************************************************************************/ size_t RawRasterBand::Write( void *pBuffer, size_t nSize, size_t nCount ) { if( bIsVSIL ) return VSIFWriteL( pBuffer, nSize, nCount, fpRaw ); else return VSIFWrite( pBuffer, nSize, nCount, fpRaw ); } /************************************************************************/ /* StoreNoDataValue() */ /* */ /* This is a helper function for datasets to associate a no */ /* data value with this band, it isn't intended to be called by */ /* applications. */ /************************************************************************/ void RawRasterBand::StoreNoDataValue( double dfValue ) { bNoDataSet = TRUE; dfNoDataValue = dfValue; } /************************************************************************/ /* SetNoDataValue() */ /************************************************************************/ CPLErr RawRasterBand::SetNoDataValue( double dfValue ) { bNoDataSet = TRUE; dfNoDataValue = dfValue; return CE_None; } /************************************************************************/ /* GetNoDataValue() */ /************************************************************************/ double RawRasterBand::GetNoDataValue( int * pbSuccess ) { if( pbSuccess ) *pbSuccess = bNoDataSet; return dfNoDataValue; } /************************************************************************/ /* GetCategoryNames() */ /************************************************************************/ char **RawRasterBand::GetCategoryNames() { return papszCategoryNames; } /************************************************************************/ /* SetCategoryNames() */ /************************************************************************/ CPLErr RawRasterBand::SetCategoryNames( char ** papszNewNames ) { CSLDestroy( papszCategoryNames ); papszCategoryNames = CSLDuplicate( papszNewNames ); return CE_None; } /************************************************************************/ /* SetColorTable() */ /************************************************************************/ CPLErr RawRasterBand::SetColorTable( GDALColorTable *poNewCT ) { if( poCT ) delete poCT; if( poNewCT == NULL ) poCT = NULL; else poCT = poNewCT->Clone(); return CE_None; } /************************************************************************/ /* GetColorTable() */ /************************************************************************/ GDALColorTable *RawRasterBand::GetColorTable() { return poCT; } /************************************************************************/ /* SetColorInterpretation() */ /************************************************************************/ CPLErr RawRasterBand::SetColorInterpretation( GDALColorInterp eNewInterp ) { eInterp = eNewInterp; return CE_None; } /************************************************************************/ /* GetColorInterpretation() */ /************************************************************************/ GDALColorInterp RawRasterBand::GetColorInterpretation() { return eInterp; } /************************************************************************/ /* ==================================================================== */ /* RawDataset */ /* ==================================================================== */ /************************************************************************/ /************************************************************************/ /* RawDataset() */ /************************************************************************/ RawDataset::RawDataset() { } /************************************************************************/ /* ~RawDataset() */ /************************************************************************/ RawDataset::~RawDataset() { } /************************************************************************/ /* IRasterIO() */ /* */ /* Multi-band raster io handler. */ /************************************************************************/ CPLErr RawDataset::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, int nPixelSpace, int nLineSpace, int nBandSpace ) { /* if( nBandCount > 1 ) return GDALDataset::BlockBasedRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace, nBandSpace ); else*/ return GDALDataset::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace, nBandSpace ); }