CPLErr CMulPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int ii, iLine, iCol; /* ---- Init ---- */ if (nSources != 2) return CE_Failure; /* ---- Set pixels ---- */ if (GDALDataTypeIsComplex( eSrcType )) { double adfPixVal[2], dfReal0, dfImag0, dfReal1, dfImag1; int nOffset = GDALGetDataTypeSize( eSrcType ) / 8 / 2; void *pReal0 = papoSources[0]; void *pImag0 = ((GByte *)papoSources[0]) + nOffset; void *pReal1 = papoSources[1]; void *pImag1 = ((GByte *)papoSources[1]) + nOffset; for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ dfReal0 = SRCVAL(pReal0, eSrcType, ii); dfReal1 = SRCVAL(pReal1, eSrcType, ii); dfImag0 = SRCVAL(pImag0, eSrcType, ii); dfImag1 = SRCVAL(pImag1, eSrcType, ii); adfPixVal[0] = dfReal0 * dfReal1 + dfImag0 * dfImag1; adfPixVal[1] = dfReal1 * dfImag0 - dfReal0 * dfImag1; GDALCopyWords(adfPixVal, GDT_CFloat64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } else { /* non complex */ double adfPixVal[2] = {0, 0}; for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ adfPixVal[0] = SRCVAL(papoSources[0], eSrcType, ii) * SRCVAL(papoSources[1], eSrcType, ii); GDALCopyWords(adfPixVal, GDT_CFloat64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } /* ---- Return success ---- */ return CE_None; } /* CMulPixelFunc */
static CPLErr SumPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { /* ---- Init ---- */ if( nSources < 2 ) return CE_Failure; /* ---- Set pixels ---- */ if( GDALDataTypeIsComplex( eSrcType ) ) { const int nOffset = GDALGetDataTypeSizeBytes( eSrcType ) / 2; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { double adfSum[2] = { 0.0, 0.0 }; for( int iSrc = 0; iSrc < nSources; ++iSrc ) { const void * const pReal = papoSources[iSrc]; const void * const pImag = static_cast<const GByte *>(pReal) + nOffset; // Source raster pixels may be obtained with SRCVAL macro. adfSum[0] += SRCVAL(pReal, eSrcType, ii); adfSum[1] += SRCVAL(pImag, eSrcType, ii); } GDALCopyWords( adfSum, GDT_CFloat64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } else { /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { double dfSum = 0; // Not complex. for( int iSrc = 0; iSrc < nSources; ++iSrc ) { // Source raster pixels may be obtained with SRCVAL macro. dfSum += SRCVAL(papoSources[iSrc], eSrcType, ii); } GDALCopyWords( &dfSum, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } /* ---- Return success ---- */ return CE_None; } /* SumPixelFunc */
static CPLErr DiffPixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { /* ---- Init ---- */ if( nSources != 2 ) return CE_Failure; if( GDALDataTypeIsComplex( eSrcType ) ) { const int nOffset = GDALGetDataTypeSizeBytes( eSrcType ) / 2; const void * const pReal0 = papoSources[0]; const void * const pImag0 = static_cast<GByte *>(papoSources[0]) + nOffset; const void * const pReal1 = papoSources[1]; const void * const pImag1 = static_cast<GByte *>(papoSources[1]) + nOffset; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. double adfPixVal[2] = { SRCVAL(pReal0, eSrcType, ii) - SRCVAL(pReal1, eSrcType, ii), SRCVAL(pImag0, eSrcType, ii) - SRCVAL(pImag1, eSrcType, ii) }; GDALCopyWords( adfPixVal, GDT_CFloat64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1 ); } } } else { /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. // Not complex. const double dfPixVal = SRCVAL(papoSources[0], eSrcType, ii) - SRCVAL(papoSources[1], eSrcType, ii); GDALCopyWords( &dfPixVal, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } /* ---- Return success ---- */ return CE_None; } // DiffPixelFunc
static CPLErr Log10PixelFuncHelper( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace, double fact ) { /* ---- Init ---- */ if( nSources != 1 ) return CE_Failure; if( GDALDataTypeIsComplex( eSrcType ) ) { // Complex input datatype. const int nOffset = GDALGetDataTypeSizeBytes( eSrcType ) / 2; const void * const pReal = papoSources[0]; const void * const pImag = static_cast<GByte *>(papoSources[0]) + nOffset; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. const double dfReal = SRCVAL(pReal, eSrcType, ii); const double dfImag = SRCVAL(pImag, eSrcType, ii); const double dfPixVal = fact * log10( sqrt( dfReal * dfReal + dfImag * dfImag ) ); GDALCopyWords( &dfPixVal, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1 ); } } } else { /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. const double dfPixVal = fact * log10( fabs( SRCVAL(papoSources[0], eSrcType, ii) ) ); GDALCopyWords( &dfPixVal, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1 ); } } } /* ---- Return success ---- */ return CE_None; } // Log10PixelFuncHelper
CPLErr InvPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int iLine, iCol, ii; /* ---- Init ---- */ if (nSources != 1) return CE_Failure; /* ---- Set pixels ---- */ if (GDALDataTypeIsComplex( eSrcType )) { double adfPixVal[2], dfReal, dfImag, dfAux; int nOffset = GDALGetDataTypeSize( eSrcType ) / 8 / 2; void *pReal = papoSources[0]; void *pImag = ((GByte *)papoSources[0]) + nOffset; for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ dfReal = SRCVAL(pReal, eSrcType, ii); dfImag = SRCVAL(pImag, eSrcType, ii); dfAux = dfReal * dfReal + dfImag * dfImag; adfPixVal[0] = +dfReal / dfAux; adfPixVal[1] = -dfImag / dfAux; GDALCopyWords(adfPixVal, GDT_CFloat64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } else { /* non complex */ double dfPixVal; /* ---- Set pixels ---- */ for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ dfPixVal = 1. / SRCVAL(papoSources[0], eSrcType, ii); GDALCopyWords(&dfPixVal, GDT_Float64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } /* ---- Return success ---- */ return CE_None; } /* InvPixelFunc */
CPLErr MEMRasterBand::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, GSpacing nPixelSpaceBuf, GSpacing nLineSpaceBuf, GDALRasterIOExtraArg* psExtraArg ) { if( nXSize != nBufXSize || nYSize != nBufYSize ) { return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, static_cast<int>(nPixelSpaceBuf), nLineSpaceBuf, psExtraArg); } // In case block based I/O has been done before. FlushCache(); if( eRWFlag == GF_Read ) { for( int iLine=0; iLine < nYSize; iLine++ ) { GDALCopyWords( pabyData + nLineOffset*static_cast<size_t>(iLine + nYOff) + nXOff*nPixelOffset, eDataType, static_cast<int>(nPixelOffset), reinterpret_cast<GByte*>( pData ) + nLineSpaceBuf * static_cast<size_t>(iLine), eBufType, static_cast<int>(nPixelSpaceBuf), nXSize ); } } else { for( int iLine = 0; iLine < nYSize; iLine++ ) { GDALCopyWords( reinterpret_cast<GByte *>( pData ) + nLineSpaceBuf*(size_t)iLine, eBufType, static_cast<int>(nPixelSpaceBuf), pabyData + nLineOffset*static_cast<size_t>(iLine + nYOff) + nXOff*nPixelOffset, eDataType, static_cast<int>(nPixelOffset), nXSize ); } } return CE_None; }
CPLErr Log10PixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int ii, iLine, iCol; /* ---- Init ---- */ if (nSources != 1) return CE_Failure; if (GDALDataTypeIsComplex( eSrcType )) { /* complex input datatype */ double dfReal, dfImag, dfPixVal; int nOffset = GDALGetDataTypeSize( eSrcType ) / 8 / 2; void *pReal = papoSources[0]; void *pImag = ((GByte *)papoSources[0]) + nOffset; /* ---- Set pixels ---- */ for( iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ dfReal = SRCVAL(pReal, eSrcType, ii); dfImag = SRCVAL(pImag, eSrcType, ii); dfPixVal = log10( dfReal * dfReal + dfImag * dfImag ); GDALCopyWords(&dfPixVal, GDT_Float64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } else { double dfPixVal; /* ---- Set pixels ---- */ for( iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ dfPixVal = SRCVAL(papoSources[0], eSrcType, ii); dfPixVal = log10( abs( dfPixVal ) ); GDALCopyWords(&dfPixVal, GDT_Float64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } /* ---- Return success ---- */ return CE_None; } /* Log10PixelFunc */
static CPLErr PhasePixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* ---- Init ---- */ if( nSources != 1 ) return CE_Failure; if( GDALDataTypeIsComplex( eSrcType ) ) { const void * const pReal = papoSources[0]; const void * const pImag = static_cast<GByte *>(papoSources[0]) + GDALGetDataTypeSizeBytes( eSrcType ) / 2; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. const double dfReal = SRCVAL(pReal, eSrcType, ii); const double dfImag = SRCVAL(pImag, eSrcType, ii); const double dfPixVal = atan2(dfImag, dfReal); GDALCopyWords( &dfPixVal, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1 ); } } } else { /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { const void * const pReal = papoSources[0]; // Source raster pixels may be obtained with SRCVAL macro. const double dfReal = SRCVAL(pReal, eSrcType, ii); const double dfPixVal = (dfReal < 0) ? M_PI : 0.0; GDALCopyWords( &dfPixVal, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1 ); } } } /* ---- Return success ---- */ return CE_None; } // PhasePixelFunc
int main(int /* argc */, char* /* argv */ []) { void* in = calloc(1, 256 * 256 * 16); void* out = malloc(256 * 256 * 16); int i; int intype, outtype; clock_t start, end; for(intype=GDT_Byte;intype<=GDT_CFloat64;intype++) { for(outtype=GDT_Byte;outtype<=GDT_CFloat64;outtype++) { start = clock(); for(i=0;i<1000;i++) GDALCopyWords(in, (GDALDataType)intype, 16, out, (GDALDataType)outtype, 16, 256 * 256); end = clock(); printf("%s -> %s : %.2f s\n", GDALGetDataTypeName((GDALDataType)intype), GDALGetDataTypeName((GDALDataType)outtype), (end - start) * 1.0 / CLOCKS_PER_SEC); start = clock(); for(i=0;i<1000;i++) GDALCopyWords(in, (GDALDataType)intype, GDALGetDataTypeSize((GDALDataType)intype) / 8, out, (GDALDataType)outtype, GDALGetDataTypeSize((GDALDataType)outtype) / 8, 256 * 256); end = clock(); printf("%s -> %s (packed) : %.2f s\n", GDALGetDataTypeName((GDALDataType)intype), GDALGetDataTypeName((GDALDataType)outtype), (end - start) * 1.0 / CLOCKS_PER_SEC); } } return 0; }
CPLErr PowPixelFuncHelper(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace, double base, double fact) { int iLine, iCol, ii; double dfPixVal; /* ---- Init ---- */ if (nSources != 1) return CE_Failure; if (GDALDataTypeIsComplex( eSrcType )) return CE_Failure; /* ---- Set pixels ---- */ for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ dfPixVal = SRCVAL(papoSources[0], eSrcType, ii); dfPixVal = pow(base, dfPixVal / fact); GDALCopyWords(&dfPixVal, GDT_Float64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } /* ---- Return success ---- */ return CE_None; } /* PowPixelFuncHelper */
CPLErr ComplexPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int ii, iLine, iCol; double adfPixVal[2]; void *pReal = papoSources[0]; void *pImag = papoSources[1]; /* ---- Init ---- */ if (nSources != 2) return CE_Failure; /* ---- Set pixels ---- */ for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ adfPixVal[0] = SRCVAL(pReal, eSrcType, ii); /* re */ adfPixVal[1] = SRCVAL(pImag, eSrcType, ii); /* im */ GDALCopyWords(adfPixVal, GDT_CFloat64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } /* ---- Return success ---- */ return CE_None; } /* MakeComplexPixelFunc */
static CPLErr SqrtPixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* ---- Init ---- */ if( nSources != 1 ) return CE_Failure; if( GDALDataTypeIsComplex( eSrcType ) ) return CE_Failure; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. const double dfPixVal = sqrt( SRCVAL(papoSources[0], eSrcType, ii) ); GDALCopyWords( &dfPixVal, GDT_Float64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } /* ---- Return success ---- */ return CE_None; } // SqrtPixelFunc
static CPLErr ComplexPixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* ---- Init ---- */ if( nSources != 2 ) return CE_Failure; const void * const pReal = papoSources[0]; const void * const pImag = papoSources[1]; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. const double adfPixVal[2] = { SRCVAL(pReal, eSrcType, ii), // re SRCVAL(pImag, eSrcType, ii) // im }; GDALCopyWords(adfPixVal, GDT_CFloat64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } /* ---- Return success ---- */ return CE_None; } // MakeComplexPixelFunc
NCSEcwReadStatus ECWAsyncReader::ReadToBuffer() { /* -------------------------------------------------------------------- */ /* Setup working scanline, and the pointers into it. */ /* */ /* Should we try and optimize some cases that we could read */ /* directly into the application buffer? Perhaps in the */ /* future. */ /* -------------------------------------------------------------------- */ ECWDataset *poECWDS = (ECWDataset *) poDS; int i; int nDataTypeSize = (GDALGetDataTypeSize(poECWDS->eRasterDataType) / 8); GByte *pabyBILScanline = (GByte *) CPLMalloc(nBufXSize * nDataTypeSize * nBandCount); GByte **papabyBIL = (GByte**)CPLMalloc(nBandCount*sizeof(void*)); for( i = 0; i < nBandCount; i++ ) papabyBIL[i] = pabyBILScanline + i * nBufXSize * nDataTypeSize; /* -------------------------------------------------------------------- */ /* Read back the imagery into the buffer. */ /* -------------------------------------------------------------------- */ for( int iScanline = 0; iScanline < nBufYSize; iScanline++ ) { NCSEcwReadStatus eRStatus; eRStatus = poFileView->ReadLineBIL( poECWDS->eNCSRequestDataType, (UINT16) nBandCount, (void **) papabyBIL ); if( eRStatus != NCSECW_READ_OK ) { CPLFree( papabyBIL ); CPLFree( pabyBILScanline ); CPLError( CE_Failure, CPLE_AppDefined, "NCScbmReadViewLineBIL failed." ); return eRStatus; } for( i = 0; i < nBandCount; i++ ) { GDALCopyWords( pabyBILScanline + i * nDataTypeSize * nBufXSize, poECWDS->eRasterDataType, nDataTypeSize, ((GByte *) pBuf) + nLineSpace * iScanline + nBandSpace * i, eBufType, nPixelSpace, nBufXSize ); } } CPLFree( pabyBILScanline ); CPLFree( papabyBIL ); return NCSECW_READ_OK; }
static CPLErr ImagPixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* ---- Init ---- */ if( nSources != 1 ) return CE_Failure; if( GDALDataTypeIsComplex( eSrcType ) ) { const GDALDataType eSrcBaseType = GDALGetNonComplexDataType( eSrcType ); const int nPixelSpaceSrc = GDALGetDataTypeSizeBytes( eSrcType ); const int nLineSpaceSrc = nPixelSpaceSrc * nXSize; const void * const pImag = static_cast<GByte *>(papoSources[0]) + GDALGetDataTypeSizeBytes( eSrcType ) / 2; /* ---- Set pixels ---- */ for( int iLine = 0; iLine < nYSize; ++iLine ) { GDALCopyWords( static_cast<const GByte *>(pImag) + nLineSpaceSrc * iLine, eSrcBaseType, nPixelSpaceSrc, static_cast<GByte *>(pData) + nLineSpace * iLine, eBufType, nPixelSpace, nXSize ); } } else { const double dfImag = 0; /* ---- Set pixels ---- */ for( int iLine = 0; iLine < nYSize; ++iLine ) { // Always copy from the same location. GDALCopyWords( &dfImag, eSrcType, 0, static_cast<GByte *>(pData) + nLineSpace * iLine, eBufType, nPixelSpace, nXSize); } } /* ---- Return success ---- */ return CE_None; } // ImagPixelFunc
CPLErr ImagPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int iLine; /* ---- Init ---- */ if (nSources != 1) return CE_Failure; if (GDALDataTypeIsComplex( eSrcType )) { int nPixelSpaceSrc = GDALGetDataTypeSize( eSrcType ) / 8; int nLineSpaceSrc = nPixelSpaceSrc * nXSize; void* pImag = ((GByte *)papoSources[0]) + GDALGetDataTypeSize( eSrcType ) / 8 / 2; /* ---- Set pixels ---- */ for( iLine = 0; iLine < nYSize; ++iLine ) { GDALCopyWords(((GByte *)pImag) + nLineSpaceSrc * iLine, eSrcType, nPixelSpaceSrc, ((GByte *)pData) + nLineSpace * iLine, eBufType, nPixelSpace, nXSize); } } else { double dfImag = 0; /* ---- Set pixels ---- */ for( iLine = 0; iLine < nYSize; ++iLine ) { /* always copy from the same location */ GDALCopyWords(&dfImag, eSrcType, 0, ((GByte *)pData) + nLineSpace * iLine, eBufType, nPixelSpace, nXSize); } } /* ---- Return success ---- */ return CE_None; } /* ImagPixelFunc */
CPLErr GRASSRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { char *pachNullBuf; pachNullBuf = (char *) CPLMalloc(nBlockXSize); G_get_null_value_row( hCell, pachNullBuf, nBlockYOff ); if( eDataType == GDT_Float32 || eDataType == GDT_Float64 || eDataType == GDT_UInt32 ) { G_get_raster_row( hCell, pImage, nBlockYOff, nGRSType ); for( int i = 0; i < nBlockXSize; i++ ) { if( pachNullBuf[i] != 0 ) { if( eDataType == GDT_UInt32 ) ((GUInt32 *) pImage)[i] = (GUInt32) dfNoData; else if( eDataType == GDT_Float32 ) ((float *) pImage)[i] = dfNoData; else ((double *) pImage)[i] = dfNoData; } } } else { GUInt32 *panRow = (GUInt32 *) CPLMalloc(4 * nBlockXSize); G_get_raster_row( hCell, panRow, nBlockYOff, nGRSType ); for( int i = 0; i < nBlockXSize; i++ ) { if( pachNullBuf[i] != 0 ) panRow[i] = (GUInt32) dfNoData; } GDALCopyWords( panRow, GDT_UInt32, 4, pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, nBlockXSize ); CPLFree( panRow ); } CPLFree( pachNullBuf ); return CE_None; }
/*********************************************************************** * \brief Set the block data to the null value if it is set, or zero if * there is no null data value. * Parameters: * - void *: the block data * Returns: nothing **********************************************************************/ void PostGISRasterRasterBand::NullBlock(void *pData) { int nWords = nBlockXSize * nBlockYSize; int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8; int bNoDataSet; double dfNoData = GetNoDataValue(&bNoDataSet); if (!bNoDataSet) { memset(pData, 0, nWords * nDataTypeSize); } else { GDALCopyWords(&dfNoData, GDT_Float64, 0, pData, eDataType, nDataTypeSize, nWords); } }
/******************************************************** * \brief Set nodata value to a buffer ********************************************************/ void PostGISRasterRasterBand::NullBuffer(void* pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int j; for(j = 0; j < nBufYSize; j++) { double dfVal = 0.0; if( bNoDataValueSet ) dfVal = dfNoDataValue; GDALCopyWords(&dfVal, GDT_Float64, 0, (GByte*)pData + j * nLineSpace, eBufType, nPixelSpace, nBufXSize); } }
CPLErr GRASSRasterBand::IReadBlock( int /*nBlockXOff*/, int nBlockYOff, void *pImage ) { if ( ! this->valid ) return CE_Failure; // Reset window because IRasterIO could be previously called. if ( ResetReading ( &(((GRASSDataset *)poDS)->sCellInfo) ) != CE_None ) { return CE_Failure; } if ( eDataType == GDT_Byte || eDataType == GDT_UInt16 ) { CELL *cbuf = G_allocate_c_raster_buf(); G_get_c_raster_row ( hCell, cbuf, nBlockYOff ); /* Reset NULLs */ for ( int col = 0; col < nBlockXSize; col++ ) { if ( G_is_c_null_value(&(cbuf[col])) ) cbuf[col] = (CELL) dfNoData; } GDALCopyWords ( (void *) cbuf, GDT_Int32, sizeof(CELL), pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, nBlockXSize ); G_free ( cbuf ); } else if ( eDataType == GDT_Int32 ) { G_get_c_raster_row ( hCell, (CELL *) pImage, nBlockYOff ); } else if ( eDataType == GDT_Float32 ) { G_get_f_raster_row ( hCell, (FCELL *) pImage, nBlockYOff ); } else if ( eDataType == GDT_Float64 ) { G_get_d_raster_row ( hCell, (DCELL *) pImage, nBlockYOff ); } return CE_None; }
static CPLErr ConjPixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* ---- Init ---- */ if( nSources != 1 ) return CE_Failure; if( GDALDataTypeIsComplex( eSrcType ) && GDALDataTypeIsComplex( eBufType ) ) { const int nOffset = GDALGetDataTypeSizeBytes( eSrcType ) / 2; const void * const pReal = papoSources[0]; const void * const pImag = static_cast<GByte *>(papoSources[0]) + nOffset; /* ---- Set pixels ---- */ for( int iLine = 0, ii = 0; iLine < nYSize; ++iLine ) { for( int iCol = 0; iCol < nXSize; ++iCol, ++ii ) { // Source raster pixels may be obtained with SRCVAL macro. const double adfPixVal[2] = { +SRCVAL(pReal, eSrcType, ii), // re -SRCVAL(pImag, eSrcType, ii) // im }; GDALCopyWords( adfPixVal, GDT_CFloat64, 0, static_cast<GByte *>(pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1 ); } } } else { // No complex data type. return RealPixelFunc(papoSources, nSources, pData, nXSize, nYSize, eSrcType, eBufType, nPixelSpace, nLineSpace); } /* ---- Return success ---- */ return CE_None; } // ConjPixelFunc
CPLErr RawRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { CPLErr eErr; CPLAssert( nBlockXOff == 0 ); if (pLineBuffer == NULL) return CE_Failure; eErr = AccessLine( nBlockYOff ); /* -------------------------------------------------------------------- */ /* Copy data from disk buffer to user block buffer. */ /* -------------------------------------------------------------------- */ GDALCopyWords( pLineStart, eDataType, nPixelOffset, pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, nBlockXSize ); return eErr; }
CPLErr ConjPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { /* ---- Init ---- */ if (nSources != 1) return CE_Failure; if (GDALDataTypeIsComplex( eSrcType ) && GDALDataTypeIsComplex( eBufType )) { int iLine, iCol, ii; double adfPixVal[2]; int nOffset = GDALGetDataTypeSize( eSrcType ) / 8 / 2; void *pReal = papoSources[0]; void *pImag = ((GByte *)papoSources[0]) + nOffset; /* ---- Set pixels ---- */ for( iLine = 0, ii= 0; iLine < nYSize; ++iLine ) { for( iCol = 0; iCol < nXSize; ++iCol, ++ii ) { /* Source raster pixels may be obtained with SRCVAL macro */ adfPixVal[0] = +SRCVAL(pReal, eSrcType, ii); /* re */ adfPixVal[1] = -SRCVAL(pImag, eSrcType, ii); /* im */ GDALCopyWords(adfPixVal, GDT_CFloat64, 0, ((GByte *)pData) + nLineSpace * iLine + iCol * nPixelSpace, eBufType, nPixelSpace, 1); } } } else { /* no complex data type */ return RealPixelFunc(papoSources, nSources, pData, nXSize, nYSize, eSrcType, eBufType, nPixelSpace, nLineSpace); } /* ---- Return success ---- */ return CE_None; } /* ConjPixelFunc */
static CPLErr RealPixelFunc( void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* ---- Init ---- */ if( nSources != 1 ) return CE_Failure; const int nPixelSpaceSrc = GDALGetDataTypeSizeBytes( eSrcType ); const int nLineSpaceSrc = nPixelSpaceSrc * nXSize; /* ---- Set pixels ---- */ for( int iLine = 0; iLine < nYSize; ++iLine ) { GDALCopyWords( static_cast<GByte *>(papoSources[0]) + nLineSpaceSrc * iLine, eSrcType, nPixelSpaceSrc, static_cast<GByte *>(pData) + nLineSpace * iLine, eBufType, nPixelSpace, nXSize ); } /* ---- Return success ---- */ return CE_None; } // RealPixelFunc
CPLErr RealPixelFunc(void **papoSources, int nSources, void *pData, int nXSize, int nYSize, GDALDataType eSrcType, GDALDataType eBufType, int nPixelSpace, int nLineSpace) { int iLine, nPixelSpaceSrc, nLineSpaceSrc; /* ---- Init ---- */ if (nSources != 1) return CE_Failure; nPixelSpaceSrc = GDALGetDataTypeSize( eSrcType ) / 8; nLineSpaceSrc = nPixelSpaceSrc * nXSize; /* ---- Set pixels ---- */ for( iLine = 0; iLine < nYSize; ++iLine ) { GDALCopyWords(((GByte *)papoSources[0]) + nLineSpaceSrc * iLine, eSrcType, nPixelSpaceSrc, ((GByte *)pData) + nLineSpace * iLine, eBufType, nPixelSpace, nXSize); } /* ---- Return success ---- */ return CE_None; } /* RealPixelFunc */
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( nPixelOffset < 0 ) { return GDALRasterBand::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace ); } 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 %lu.", nXSize * nYSize * nBandDataSize, (unsigned long) (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 %lu.", nBytesToRW, (unsigned long)(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 %lu to write data.\n", (unsigned long)(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 %ld to read.\n", (long)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; }
CPLErr RawRasterBand::IWriteBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { CPLErr eErr = CE_None; CPLAssert( nBlockXOff == 0 ); if (pLineBuffer == NULL) return CE_Failure; /* -------------------------------------------------------------------- */ /* If the data for this band is completely contiguous we don't */ /* have to worry about pre-reading from disk. */ /* -------------------------------------------------------------------- */ if( ABS(nPixelOffset) > GDALGetDataTypeSize(eDataType) / 8 ) eErr = AccessLine( nBlockYOff ); /* -------------------------------------------------------------------- */ /* Copy data from user buffer into disk buffer. */ /* -------------------------------------------------------------------- */ GDALCopyWords( pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, pLineStart, 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, ABS(nPixelOffset) ); GDALSwapWords( ((GByte *) pLineBuffer)+nWordSize, nWordSize, nBlockXSize, ABS(nPixelOffset) ); } else GDALSwapWords( pLineBuffer, GDALGetDataTypeSize(eDataType)/8, nBlockXSize, ABS(nPixelOffset) ); } /* -------------------------------------------------------------------- */ /* Figure out where to start reading. */ /* -------------------------------------------------------------------- */ vsi_l_offset nWriteStart; if( nPixelOffset >= 0 ) nWriteStart = nImgOffset + (vsi_l_offset)nBlockYOff * nLineOffset; else { nWriteStart = nImgOffset + (vsi_l_offset)nBlockYOff * nLineOffset - ABS(nPixelOffset) * (nBlockXSize-1); } /* -------------------------------------------------------------------- */ /* Seek to correct location. */ /* -------------------------------------------------------------------- */ if( Seek( nWriteStart, 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 = ABS(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 ) { if( GDALDataTypeIsComplex( eDataType ) ) { int nWordSize; nWordSize = GDALGetDataTypeSize(eDataType)/16; GDALSwapWords( pLineBuffer, nWordSize, nBlockXSize, ABS(nPixelOffset) ); GDALSwapWords( ((GByte *) pLineBuffer)+nWordSize, nWordSize, nBlockXSize, ABS(nPixelOffset) ); } else GDALSwapWords( pLineBuffer, GDALGetDataTypeSize(eDataType)/8, nBlockXSize, ABS(nPixelOffset) ); } bDirty = TRUE; return eErr; }
/** * Read/write a region of image data for this band. * * Each of the sources for this derived band will be read and passed to * the derived band pixel function. The pixel function is responsible * for applying whatever algorithm is necessary to generate this band's * pixels from the sources. * * The sources will be read using the transfer type specified for sources * using SetSourceTransferType(). If no transfer type has been set for * this derived band, the band's data type will be used as the transfer type. * * @see gdalrasterband * * @param eRWFlag Either GF_Read to read a region of data, or GT_Write to * write a region of data. * * @param nXOff The pixel offset to the top left corner of the region * of the band to be accessed. This would be zero to start from the left side. * * @param nYOff The line offset to the top left corner of the region * of the band to be accessed. This would be zero to start from the top. * * @param nXSize The width of the region of the band to be accessed in pixels. * * @param nYSize The height of the region of the band to be accessed in lines. * * @param pData The buffer into which the data should be read, or from which * it should be written. This buffer must contain at least nBufXSize * * nBufYSize words of type eBufType. It is organized in left to right, * top to bottom pixel order. Spacing is controlled by the nPixelSpace, * and nLineSpace parameters. * * @param nBufXSize The width of the buffer image into which the desired * region is to be read, or from which it is to be written. * * @param nBufYSize The height of the buffer image into which the desired * region is to be read, or from which it is to be written. * * @param eBufType The type of the pixel values in the pData data buffer. The * pixel values will automatically be translated to/from the GDALRasterBand * data type as needed. * * @param nPixelSpace The byte offset from the start of one pixel value in * pData to the start of the next pixel value within a scanline. If defaulted * (0) the size of the datatype eBufType is used. * * @param nLineSpace The byte offset from the start of one scanline in * pData to the start of the next. If defaulted the size of the datatype * eBufType * nBufXSize is used. * * @return CE_Failure if the access fails, otherwise CE_None. */ CPLErr VRTDerivedRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { GDALDerivedPixelFunc pfnPixelFunc; void **pBuffers; CPLErr eErr = CE_None; int iSource, ii, typesize, sourcesize; GDALDataType eSrcType; if( eRWFlag == GF_Write ) { CPLError( CE_Failure, CPLE_AppDefined, "Writing through VRTSourcedRasterBand is not supported." ); return CE_Failure; } typesize = GDALGetDataTypeSize(eBufType) / 8; if (GDALGetDataTypeSize(eBufType) % 8 > 0) typesize++; eSrcType = this->eSourceTransferType; if ((eSrcType == GDT_Unknown) || (eSrcType >= GDT_TypeCount)) { eSrcType = eBufType; } sourcesize = GDALGetDataTypeSize(eSrcType) / 8; /* -------------------------------------------------------------------- */ /* Initialize the buffer to some background value. Use the */ /* nodata value if available. */ /* -------------------------------------------------------------------- */ if ( nPixelSpace == typesize && (!bNoDataValueSet || dfNoDataValue == 0) ) { memset( pData, 0, nBufXSize * nBufYSize * nPixelSpace ); } else if ( !bEqualAreas || bNoDataValueSet ) { double dfWriteValue = 0.0; int iLine; if( bNoDataValueSet ) dfWriteValue = dfNoDataValue; for( iLine = 0; iLine < nBufYSize; iLine++ ) { GDALCopyWords( &dfWriteValue, GDT_Float64, 0, ((GByte *)pData) + nLineSpace * iLine, eBufType, nPixelSpace, nBufXSize ); } } /* -------------------------------------------------------------------- */ /* 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; } /* ---- Get pixel function for band ---- */ pfnPixelFunc = VRTDerivedRasterBand::GetPixelFunction(this->pszFuncName); if (pfnPixelFunc == NULL) { CPLError( CE_Failure, CPLE_IllegalArg, "VRTDerivedRasterBand::IRasterIO:" \ "Derived band pixel function '%s' not registered.\n", this->pszFuncName); return CE_Failure; } /* TODO: It would be nice to use a MallocBlock function for each individual buffer that would recycle blocks of memory from a cache by reassigning blocks that are nearly the same size. A corresponding FreeBlock might only truly free if the total size of freed blocks gets to be too great of a percentage of the size of the allocated blocks. */ /* ---- Get buffers for each source ---- */ pBuffers = (void **) CPLMalloc(sizeof(void *) * nSources); for (iSource = 0; iSource < nSources; iSource++) { pBuffers[iSource] = (void *) VSIMalloc(sourcesize * nBufXSize * nBufYSize); if (pBuffers[iSource] == NULL) { for (ii = 0; ii < iSource; ii++) { VSIFree(pBuffers[iSource]); } CPLError( CE_Failure, CPLE_OutOfMemory, "VRTDerivedRasterBand::IRasterIO:" \ "Out of memory allocating %d bytes.\n", nPixelSpace * nBufXSize * nBufYSize); return CE_Failure; } /* ------------------------------------------------------------ */ /* #4045: Initialize the newly allocated buffers before handing */ /* them off to the sources. These buffers are packed, so we */ /* don't need any special line-by-line handling when a nonzero */ /* nodata value is set. */ /* ------------------------------------------------------------ */ if ( !bNoDataValueSet || dfNoDataValue == 0 ) { memset( pBuffers[iSource], 0, sourcesize * nBufXSize * nBufYSize ); } else { GDALCopyWords( &dfNoDataValue, GDT_Float64, 0, (GByte *) pBuffers[iSource], eSrcType, sourcesize, nBufXSize * nBufYSize); } } /* ---- Load values for sources into packed buffers ---- */ for(iSource = 0; iSource < nSources; iSource++) { eErr = ((VRTSource *)papoSources[iSource])->RasterIO (nXOff, nYOff, nXSize, nYSize, pBuffers[iSource], nBufXSize, nBufYSize, eSrcType, GDALGetDataTypeSize( eSrcType ) / 8, (GDALGetDataTypeSize( eSrcType ) / 8) * nBufXSize); } /* ---- Apply pixel function ---- */ if (eErr == CE_None) { eErr = pfnPixelFunc((void **)pBuffers, nSources, pData, nBufXSize, nBufYSize, eSrcType, eBufType, nPixelSpace, nLineSpace); } /* ---- Release buffers ---- */ for (iSource = 0; iSource < nSources; iSource++) { VSIFree(pBuffers[iSource]); } CPLFree(pBuffers); return eErr; }
CPLErr GRASSRasterBand::IRasterIO ( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { /* GRASS library does that, we have only calculate and reset the region in map units * and if the region has changed, reopen the raster */ /* Calculate the region */ struct Cell_head sWindow; struct Cell_head *psDsWindow; if ( ! this->valid ) return CE_Failure; psDsWindow = &(((GRASSDataset *)poDS)->sCellInfo); sWindow.north = psDsWindow->north - nYOff * psDsWindow->ns_res; sWindow.south = sWindow.north - nYSize * psDsWindow->ns_res; sWindow.west = psDsWindow->west + nXOff * psDsWindow->ew_res; sWindow.east = sWindow.west + nXSize * psDsWindow->ew_res; sWindow.proj = psDsWindow->proj; sWindow.zone = psDsWindow->zone; sWindow.cols = nBufXSize; sWindow.rows = nBufYSize; /* Reset resolution */ G_adjust_Cell_head ( &sWindow, 1, 1); if ( ResetReading ( &sWindow ) != CE_None ) { return CE_Failure; } /* Read Data */ CELL *cbuf = NULL; FCELL *fbuf = NULL; DCELL *dbuf = NULL; bool direct = false; /* Reset space if default (0) */ if ( nPixelSpace == 0 ) nPixelSpace = GDALGetDataTypeSize ( eBufType ) / 8; if ( nLineSpace == 0 ) nLineSpace = nBufXSize * nPixelSpace; if ( nGRSType == CELL_TYPE && ( !nativeNulls || eBufType != GDT_Int32 || sizeof(CELL) != 4 || nPixelSpace != sizeof(CELL) ) ) { cbuf = G_allocate_c_raster_buf(); } else if( nGRSType == FCELL_TYPE && ( eBufType != GDT_Float32 || nPixelSpace != sizeof(FCELL) ) ) { fbuf = G_allocate_f_raster_buf(); } else if( nGRSType == DCELL_TYPE && ( eBufType != GDT_Float64 || nPixelSpace != sizeof(DCELL) ) ) { dbuf = G_allocate_d_raster_buf(); } else { direct = true; } for ( int row = 0; row < nBufYSize; row++ ) { char *pnt = (char *)pData + row * nLineSpace; if ( nGRSType == CELL_TYPE ) { if ( direct ) { G_get_c_raster_row ( hCell, (CELL *) pnt, row ); } else { G_get_c_raster_row ( hCell, cbuf, row ); /* Reset NULLs */ for ( int col = 0; col < nBufXSize; col++ ) { if ( G_is_c_null_value(&(cbuf[col])) ) cbuf[col] = (CELL) dfNoData; } GDALCopyWords ( (void *) cbuf, GDT_Int32, sizeof(CELL), (void *) pnt, eBufType, nPixelSpace, nBufXSize ); } } else if( nGRSType == FCELL_TYPE ) { if ( direct ) { G_get_f_raster_row ( hCell, (FCELL *) pnt, row ); } else { G_get_f_raster_row ( hCell, fbuf, row ); GDALCopyWords ( (void *) fbuf, GDT_Float32, sizeof(FCELL), (void *) pnt, eBufType, nPixelSpace, nBufXSize ); } } else if( nGRSType == DCELL_TYPE ) { if ( direct ) { G_get_d_raster_row ( hCell, (DCELL *) pnt, row ); } else { G_get_d_raster_row ( hCell, dbuf, row ); GDALCopyWords ( (void *) dbuf, GDT_Float64, sizeof(DCELL), (void *) pnt, eBufType, nPixelSpace, nBufXSize ); } } } if ( cbuf ) G_free ( cbuf ); if ( fbuf ) G_free ( fbuf ); if ( dbuf ) G_free ( dbuf ); return CE_None; }
CPLErr VRTSourcedRasterBand::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nPixelSpace, int nLineSpace ) { int iSource; CPLErr eErr = CE_None; if( eRWFlag == GF_Write ) { CPLError( CE_Failure, CPLE_AppDefined, "Writing through VRTSourcedRasterBand is not supported." ); return CE_Failure; } /* When using GDALProxyPoolDataset for sources, the recusion will not be */ /* detected at VRT opening but when doing RasterIO. As the proxy pool will */ /* return the already opened dataset, we can just test a member variable. */ if ( bAlreadyInIRasterIO ) { CPLError( CE_Failure, CPLE_AppDefined, "VRTSourcedRasterBand::IRasterIO() called recursively on the same band. " "It looks like the VRT is referencing itself." ); return CE_Failure; } /* ==================================================================== */ /* 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; } /* -------------------------------------------------------------------- */ /* Initialize the buffer to some background value. Use the */ /* nodata value if available. */ /* -------------------------------------------------------------------- */ if ( nPixelSpace == GDALGetDataTypeSize(eBufType)/8 && (!bNoDataValueSet || (!CPLIsNan(dfNoDataValue) && dfNoDataValue == 0)) ) { if (nLineSpace == nBufXSize * nPixelSpace) { memset( pData, 0, nBufYSize * nLineSpace ); } else { int iLine; for( iLine = 0; iLine < nBufYSize; iLine++ ) { memset( ((GByte*)pData) + iLine * nLineSpace, 0, nBufXSize * nPixelSpace ); } } } else if ( !bEqualAreas || bNoDataValueSet ) { double dfWriteValue = 0.0; int iLine; if( bNoDataValueSet ) dfWriteValue = dfNoDataValue; for( iLine = 0; iLine < nBufYSize; iLine++ ) { GDALCopyWords( &dfWriteValue, GDT_Float64, 0, ((GByte *)pData) + nLineSpace * iLine, eBufType, nPixelSpace, nBufXSize ); } } /* -------------------------------------------------------------------- */ /* 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; } bAlreadyInIRasterIO = TRUE; /* -------------------------------------------------------------------- */ /* Overlay each source in turn over top this. */ /* -------------------------------------------------------------------- */ for( iSource = 0; eErr == CE_None && iSource < nSources; iSource++ ) { eErr = papoSources[iSource]->RasterIO( nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace); } bAlreadyInIRasterIO = FALSE; return eErr; }