void *MEMDataset::GetInternalHandle( const char * pszRequest)
{
// check for MEMORYnnn string in pszRequest (nnnn can be up to 10
// digits, or even omitted)
if( EQUALN(pszRequest,"MEMORY",6))
{
if(int BandNumber = CPLScanLong(&pszRequest[6], 10))
{
MEMRasterBand *RequestedRasterBand =
(MEMRasterBand *)GetRasterBand(BandNumber);
// we're within a MEMDataset so the only thing a RasterBand
// could be is a MEMRasterBand
if( RequestedRasterBand != NULL )
{
// return the internal band data pointer
return(RequestedRasterBand->GetData());
}
}
}
return NULL;
}
void *MEMDataset::GetInternalHandle( const char * pszRequest )
{
// check for MEMORYnnn string in pszRequest (nnnn can be up to 10
// digits, or even omitted)
if( STARTS_WITH_CI(pszRequest, "MEMORY"))
{
if(int BandNumber = static_cast<int>(CPLScanLong(&pszRequest[6], 10)))
{
MEMRasterBand *RequestedRasterBand =
reinterpret_cast<MEMRasterBand *>( GetRasterBand(BandNumber) );
// we're within a MEMDataset so the only thing a RasterBand
// could be is a MEMRasterBand
if( RequestedRasterBand != NULL )
{
// return the internal band data pointer
return(RequestedRasterBand->GetData());
}
}
}
return NULL;
}
GDALDataset *XPMDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* First we check to see if the file has the expected header */
/* bytes. For now we expect the XPM file to start with a line */
/* containing the letters XPM, and to have "static" in the */
/* header. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 32
|| strstr((const char *) poOpenInfo->pabyHeader,"XPM") == NULL
|| strstr((const char *) poOpenInfo->pabyHeader,"static") == NULL )
return NULL;
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The XPM driver does not support update access to existing"
" files." );
return NULL;
}
if (poOpenInfo->fp == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Read the whole file into a memory strings. */
/* -------------------------------------------------------------------- */
unsigned int nFileSize;
char *pszFileContents;
VSIFSeek( poOpenInfo->fp, 0, SEEK_END );
nFileSize = VSIFTell( poOpenInfo->fp );
pszFileContents = (char *) VSIMalloc(nFileSize+1);
if( pszFileContents == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Insufficient memory for loading XPM file %s into memory.",
poOpenInfo->pszFilename );
return NULL;
}
pszFileContents[nFileSize] = '\0';
VSIFSeek( poOpenInfo->fp, 0, SEEK_SET );
if( VSIFRead( pszFileContents, 1, nFileSize, poOpenInfo->fp ) != nFileSize)
{
CPLFree( pszFileContents );
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read all %d bytes from file %s.",
nFileSize, poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Convert into a binary image. */
/* -------------------------------------------------------------------- */
GByte *pabyImage;
int nXSize, nYSize;
GDALColorTable *poCT = NULL;
CPLErrorReset();
pabyImage = ParseXPM( pszFileContents, &nXSize, &nYSize, &poCT );
CPLFree( pszFileContents );
if( pabyImage == NULL )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
XPMDataset *poDS;
poDS = new XPMDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nXSize;
poDS->nRasterYSize = nYSize;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
MEMRasterBand *poBand;
poBand = new MEMRasterBand( poDS, 1, pabyImage, GDT_Byte, 1, nXSize,
TRUE );
poBand->SetColorTable( poCT );
poDS->SetBand( 1, poBand );
delete poCT;
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
CPLErr MEMDataset::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nBandCount, int *panBandMap,
GSpacing nPixelSpaceBuf,
GSpacing nLineSpaceBuf,
GSpacing nBandSpaceBuf,
GDALRasterIOExtraArg* psExtraArg)
{
const int eBufTypeSize = GDALGetDataTypeSize(eBufType) / 8;
// Detect if we have a pixel-interleaved buffer and a pixel-interleaved
// dataset.
if( nXSize == nBufXSize && nYSize == nBufYSize &&
nBandCount == nBands && nBands > 1 &&
nBandSpaceBuf == eBufTypeSize &&
nPixelSpaceBuf == nBandSpaceBuf * nBands )
{
GDALDataType eDT = GDT_Unknown;
GByte* pabyData = NULL;
GSpacing nPixelOffset = 0;
GSpacing nLineOffset = 0;
int eDTSize = 0;
int iBandIndex;
for( iBandIndex = 0; iBandIndex < nBandCount; iBandIndex++ )
{
if( panBandMap[iBandIndex] != iBandIndex + 1 )
break;
MEMRasterBand *poBand = reinterpret_cast<MEMRasterBand *>(
GetRasterBand(iBandIndex + 1) );
if( iBandIndex == 0 )
{
eDT = poBand->GetRasterDataType();
pabyData = poBand->pabyData;
nPixelOffset = poBand->nPixelOffset;
nLineOffset = poBand->nLineOffset;
eDTSize = GDALGetDataTypeSize(eDT) / 8;
if( nPixelOffset != static_cast<GSpacing>(nBands) * eDTSize )
break;
}
else if( poBand->GetRasterDataType() != eDT ||
nPixelOffset != poBand->nPixelOffset ||
nLineOffset != poBand->nLineOffset ||
poBand->pabyData != pabyData + iBandIndex * eDTSize )
{
break;
}
}
if( iBandIndex == nBandCount )
{
FlushCache();
if( eRWFlag == GF_Read )
{
for(int iLine=0;iLine<nYSize;iLine++)
{
GDALCopyWords(
pabyData +
nLineOffset*static_cast<size_t>(iLine + nYOff) +
nXOff*nPixelOffset,
eDT,
eDTSize,
reinterpret_cast<GByte *>( pData ) +
nLineSpaceBuf * static_cast<size_t>(iLine),
eBufType,
eBufTypeSize,
nXSize * nBands );
}
}
else
{
for(int iLine=0;iLine<nYSize;iLine++)
{
GDALCopyWords(
reinterpret_cast<GByte *>( pData ) +
nLineSpaceBuf*(size_t)iLine,
eBufType,
eBufTypeSize,
pabyData +
nLineOffset * static_cast<size_t>(iLine + nYOff) +
nXOff*nPixelOffset,
eDT,
eDTSize,
nXSize * nBands);
}
}
return CE_None;
}
}
if( nBufXSize != nXSize || nBufYSize != nYSize )
return GDALDataset::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nBandCount, panBandMap,
nPixelSpaceBuf, nLineSpaceBuf, nBandSpaceBuf,
psExtraArg );
GDALProgressFunc pfnProgressGlobal = psExtraArg->pfnProgress;
void *pProgressDataGlobal = psExtraArg->pProgressData;
CPLErr eErr = CE_None;
for( int iBandIndex = 0;
iBandIndex < nBandCount && eErr == CE_None;
iBandIndex++ )
{
GDALRasterBand *poBand = GetRasterBand(panBandMap[iBandIndex]);
if (poBand == NULL)
{
eErr = CE_Failure;
break;
}
GByte *pabyBandData
= reinterpret_cast<GByte *>(pData) + iBandIndex * nBandSpaceBuf;
psExtraArg->pfnProgress = GDALScaledProgress;
psExtraArg->pProgressData =
GDALCreateScaledProgress( 1.0 * iBandIndex / nBandCount,
1.0 * (iBandIndex + 1) / nBandCount,
pfnProgressGlobal,
pProgressDataGlobal );
eErr = poBand->RasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
reinterpret_cast<void *>( pabyBandData ),
nBufXSize, nBufYSize,
eBufType, nPixelSpaceBuf, nLineSpaceBuf,
psExtraArg );
GDALDestroyScaledProgress( psExtraArg->pProgressData );
}
psExtraArg->pfnProgress = pfnProgressGlobal;
psExtraArg->pProgressData = pProgressDataGlobal;
return eErr;
}
