CPLErr COSARRasterBand::IReadBlock(CPL_UNUSED int nBlockXOff, int nBlockYOff,
void *pImage) {
unsigned long nRSFV = 0;
unsigned long nRSLV = 0;
COSARDataset *pCDS = (COSARDataset *) poDS;
/* Find the line we want to be at */
/* To explain some magic numbers:
* 4 bytes for an entire sample (2 I, 2 Q)
* nBlockYOff + 4 = Y offset + 4 annotation lines at beginning
* of file
*/
VSIFSeek(pCDS->fp,(this->nRTNB * (nBlockYOff + 4)), SEEK_SET);
/* Read RSFV and RSLV (TX-GS-DD-3307) */
VSIFRead(&nRSFV,1,4,pCDS->fp);
VSIFRead(&nRSLV,1,4,pCDS->fp);
#ifdef CPL_LSB
nRSFV = CPL_SWAP32(nRSFV);
nRSLV = CPL_SWAP32(nRSLV);
#endif
if (nRSLV < nRSFV || nRSFV == 0
|| nRSFV - 1 >= ((unsigned long) nBlockXSize)
|| nRSLV - nRSFV > ((unsigned long) nBlockXSize)
|| nRSFV >= this->nRTNB || nRSLV > this->nRTNB)
{
/* throw an error */
CPLError(CE_Failure, CPLE_AppDefined,
"RSLV/RSFV values are not sane... oh dear.\n");
return CE_Failure;
}
/* zero out the range line */
for (int i = 0; i < this->nRasterXSize; i++)
{
((GUInt32 *)pImage)[i] = 0;
}
/* properly account for validity mask */
if (nRSFV > 1)
{
VSIFSeek(pCDS->fp,(this->nRTNB*(nBlockYOff+4)+(nRSFV+1)*4), SEEK_SET);
}
/* Read the valid samples: */
VSIFRead(((char *)pImage)+((nRSFV - 1)*4),1,((nRSLV-1)*4)-((nRSFV-1)*4),pCDS->fp);
#ifdef CPL_LSB
// GDALSwapWords( pImage, 4, nBlockXSize * nBlockYSize, 4 );
GDALSwapWords( pImage, 2, nBlockXSize * nBlockYSize * 2, 2 );
#endif
return CE_None;
}
HFAEntry::HFAEntry( HFAInfo_t * psHFAIn, GUInt32 nPos,
HFAEntry * poParentIn, HFAEntry * poPrevIn )
{
psHFA = psHFAIn;
nFilePos = nPos;
poParent = poParentIn;
poPrev = poPrevIn;
/* -------------------------------------------------------------------- */
/* Initialize fields to null values in case there is a read */
/* error, so the entry will be in a harmless state. */
/* -------------------------------------------------------------------- */
poNext = poChild = NULL;
nDataPos = nDataSize = 0;
nNextPos = nChildPos = 0;
szName[0] = szType[0] = '\0';
pabyData = NULL;
poType = NULL;
/* -------------------------------------------------------------------- */
/* Read the entry information from the file. */
/* -------------------------------------------------------------------- */
GInt32 anEntryNums[6];
int i;
if( VSIFSeek( psHFA->fp, nFilePos, SEEK_SET ) == -1
|| VSIFRead( anEntryNums, sizeof(GInt32), 6, psHFA->fp ) < 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"VSIFRead() failed in HFAEntry()." );
return;
}
for( i = 0; i < 6; i++ )
HFAStandard( 4, anEntryNums + i );
nNextPos = anEntryNums[0];
nChildPos = anEntryNums[3];
nDataPos = anEntryNums[4];
nDataSize = anEntryNums[5];
/* -------------------------------------------------------------------- */
/* Read the name, and type. */
/* -------------------------------------------------------------------- */
if( VSIFRead( szName, 1, 64, psHFA->fp ) < 1
|| VSIFRead( szType, 1, 32, psHFA->fp ) < 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"VSIFRead() failed in HFAEntry()." );
return;
}
}
GDALDataset *COSARDataset::Open( GDALOpenInfo * pOpenInfo ) {
long nRTNB;
/* Check if we're actually a COSAR data set. */
if( pOpenInfo->nHeaderBytes < 4 )
return NULL;
if (!EQUALN((char *)pOpenInfo->pabyHeader+MAGIC1_OFFSET, "CSAR",4))
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( pOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The COSAR driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* this is a cosar dataset */
COSARDataset *pDS;
pDS = new COSARDataset();
/* steal fp */
pDS->fp = pOpenInfo->fp;
pOpenInfo->fp = NULL;
/* Calculate the file size */
VSIFSeek(pDS->fp,0,SEEK_END);
pDS->nSize = VSIFTell(pDS->fp);
VSIFSeek(pDS->fp, RS_OFFSET, SEEK_SET);
VSIFRead(&pDS->nRasterXSize, 1, 4, pDS->fp);
#ifdef CPL_LSB
pDS->nRasterXSize = CPL_SWAP32(pDS->nRasterXSize);
#endif
VSIFRead(&pDS->nRasterYSize, 1, 4, pDS->fp);
#ifdef CPL_LSB
pDS->nRasterYSize = CPL_SWAP32(pDS->nRasterYSize);
#endif
VSIFSeek(pDS->fp, RTNB_OFFSET, SEEK_SET);
VSIFRead(&nRTNB, 1, 4, pDS->fp);
#ifdef CPL_LSB
nRTNB = CPL_SWAP32(nRTNB);
#endif
/* Add raster band */
pDS->SetBand(1, new COSARRasterBand(pDS, nRTNB));
return pDS;
}
/*!
\brief Read the file & load the data
\param pszFile pointer to a filename
\return TRUE on success
\return FALSE on error
*/
int VFKReader::LoadData()
{
FILE *fp;
long nLength;
if (m_pszFilename == NULL)
return FALSE;
/* load vfk file */
fp = VSIFOpen(m_pszFilename, "rb");
if (fp == NULL) {
CPLError(CE_Failure, CPLE_OpenFailed,
"Failed to open file %s.", m_pszFilename);
return FALSE;
}
/* get file length */
VSIFSeek(fp, 0, SEEK_END);
nLength = VSIFTell(fp);
VSIFSeek(fp, 0, SEEK_SET);
/* read file - is necessary to read the whole file? */
m_pszWholeText = (char *) VSIMalloc(nLength+1);
if (m_pszWholeText == NULL) {
CPLError(CE_Failure, CPLE_AppDefined,
"Failed to allocate %ld byte buffer for %s,\n"
"is this really a VFK file?",
nLength, m_pszFilename);
VSIFClose(fp);
return FALSE;
}
if (VSIFRead(m_pszWholeText, nLength, 1, fp) != 1) {
VSIFree(m_pszWholeText);
m_pszWholeText = NULL;
VSIFClose(fp);
CPLError(CE_Failure, CPLE_AppDefined,
"Read failed on %s.", m_pszFilename);
return FALSE;
}
m_pszWholeText[nLength] = '\0';
VSIFClose(fp);
/* split lines */
/* TODO: reduce chars */
for (char *poChar = m_pszWholeText; *poChar != '\0'; poChar++) {
if (*poChar == '\244' && *(poChar+1) != '\0' && *(poChar+2) != '\0') {
*(poChar++) = ' '; // \r
*(poChar++) = ' '; // \n
*poChar = ' ';
}
}
CPLDebug("OGR_VFK", "VFKReader::LoadData(): length=%ld", nLength);
return TRUE;
}
void HFAEntry::LoadData()
{
if( pabyData != NULL || nDataSize == 0 )
return;
/* -------------------------------------------------------------------- */
/* Allocate buffer, and read data. */
/* -------------------------------------------------------------------- */
pabyData = (GByte *) CPLMalloc(nDataSize);
if( VSIFSeek( psHFA->fp, nDataPos, SEEK_SET ) < 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"VSIFSeek() failed in HFAEntry::LoadData()." );
return;
}
if( VSIFRead( pabyData, 1, nDataSize, psHFA->fp ) < 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"VSIFRead() failed in HFAEntry::LoadData()." );
return;
}
/* -------------------------------------------------------------------- */
/* Get the type corresponding to this entry. */
/* -------------------------------------------------------------------- */
poType = psHFA->poDictionary->FindType( szType );
if( poType == NULL )
return;
}
CPLErr HFABand::GetPCT( int * pnColors,
double **ppadfRed,
double **ppadfGreen,
double **ppadfBlue )
{
*pnColors = 0;
*ppadfRed = NULL;
*ppadfGreen = NULL;
*ppadfBlue = NULL;
/* -------------------------------------------------------------------- */
/* If we haven't already tried to load the colors, do so now. */
/* -------------------------------------------------------------------- */
if( nPCTColors == -1 )
{
HFAEntry *poColumnEntry;
int i, iColumn;
nPCTColors = 0;
poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Red");
if( poColumnEntry == NULL )
return( CE_Failure );
nPCTColors = poColumnEntry->GetIntField( "numRows" );
for( iColumn = 0; iColumn < 3; iColumn++ )
{
apadfPCT[iColumn] = (double *)CPLMalloc(sizeof(double)*nPCTColors);
if( iColumn == 0 )
poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Red");
else if( iColumn == 1 )
poColumnEntry= poNode->GetNamedChild("Descriptor_Table.Green");
else if( iColumn == 2 )
poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Blue");
VSIFSeek( psInfo->fp, poColumnEntry->GetIntField("columnDataPtr"),
SEEK_SET );
VSIFRead( apadfPCT[iColumn], sizeof(double), nPCTColors,
psInfo->fp);
for( i = 0; i < nPCTColors; i++ )
HFAStandard( 8, apadfPCT[iColumn] + i );
}
}
/* -------------------------------------------------------------------- */
/* Return the values. */
/* -------------------------------------------------------------------- */
if( nPCTColors == 0 )
return( CE_Failure );
*pnColors = nPCTColors;
*ppadfRed = apadfPCT[0];
*ppadfGreen = apadfPCT[1];
*ppadfBlue = apadfPCT[2];
return( CE_None );
}
CPLErr ELASRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void * pImage )
{
ELASDataset *poGDS = (ELASDataset *) poDS;
CPLErr eErr = CE_None;
long nOffset;
int nDataSize;
CPLAssert( nBlockXOff == 0 );
nDataSize = GDALGetDataTypeSize(eDataType) * poGDS->GetRasterXSize() / 8;
nOffset = poGDS->nLineOffset * nBlockYOff + 1024 + (nBand-1) * nDataSize;
/* -------------------------------------------------------------------- */
/* If we can't seek to the data, we will assume this is a newly */
/* created file, and that the file hasn't been extended yet. */
/* Just read as zeros. */
/* -------------------------------------------------------------------- */
if( VSIFSeek( poGDS->fp, nOffset, SEEK_SET ) != 0
|| VSIFRead( pImage, 1, nDataSize, poGDS->fp ) != (size_t) nDataSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Seek or read of %d bytes at %ld failed.\n",
nDataSize, nOffset );
eErr = CE_Failure;
}
return eErr;
}
GDALDataset *NWT_GRDDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Look for the header */
/* -------------------------------------------------------------------- */
if( poOpenInfo->fp == NULL || poOpenInfo->nHeaderBytes < 50 )
return NULL;
if( poOpenInfo->pabyHeader[0] != 'H' ||
poOpenInfo->pabyHeader[1] != 'G' ||
poOpenInfo->pabyHeader[2] != 'P' ||
poOpenInfo->pabyHeader[3] != 'C' || poOpenInfo->pabyHeader[4] != '1' )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
NWT_GRDDataset *poDS;
poDS = new NWT_GRDDataset();
poDS->fp = poOpenInfo->fp;
poOpenInfo->fp = NULL;
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
VSIFSeek( poDS->fp, 0, SEEK_SET );
VSIFRead( poDS->abyHeader, 1, 1024, poDS->fp );
poDS->pGrd = (NWT_GRID *) malloc(sizeof(NWT_GRID));
if (!nwt_ParseHeader( poDS->pGrd, (char *) poDS->abyHeader ) ||
!GDALCheckDatasetDimensions(poDS->pGrd->nXSide, poDS->pGrd->nYSide) )
{
delete poDS;
return NULL;
}
poDS->nRasterXSize = poDS->pGrd->nXSide;
poDS->nRasterYSize = poDS->pGrd->nYSide;
// create a colorTable
// if( poDS->pGrd->iNumColorInflections > 0 )
// poDS->CreateColorTable();
nwt_LoadColors( poDS->ColorMap, 4096, poDS->pGrd );
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new NWT_GRDRasterBand( poDS, 1 ) ); //r
poDS->SetBand( 2, new NWT_GRDRasterBand( poDS, 2 ) ); //g
poDS->SetBand( 3, new NWT_GRDRasterBand( poDS, 3 ) ); //b
poDS->SetBand( 4, new NWT_GRDRasterBand( poDS, 4 ) ); //z
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
return (poDS);
}
OGRErr OGRMILayerAttrIndex::LoadConfigFromXML()
{
FILE *fp;
int nXMLSize;
char *pszRawXML;
CPLAssert( poINDFile == NULL );
/* -------------------------------------------------------------------- */
/* Read the XML file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszMetadataFilename, "rb" );
if( fp == NULL )
return OGRERR_NONE;
VSIFSeek( fp, 0, SEEK_END );
nXMLSize = VSIFTell( fp );
VSIFSeek( fp, 0, SEEK_SET );
pszRawXML = (char *) CPLMalloc(nXMLSize+1);
pszRawXML[nXMLSize] = '\0';
VSIFRead( pszRawXML, nXMLSize, 1, fp );
VSIFClose( fp );
OGRErr eErr = LoadConfigFromXML(pszRawXML);
CPLFree(pszRawXML);
return eErr;
}
static char * HFAGetDictionary( HFAHandle hHFA )
{
char *pszDictionary = (char *) CPLMalloc(100);
int nDictMax = 100;
int nDictSize = 0;
VSIFSeek( hHFA->fp, hHFA->nDictionaryPos, SEEK_SET );
while( TRUE )
{
if( nDictSize >= nDictMax-1 )
{
nDictMax = nDictSize * 2 + 100;
pszDictionary = (char *) CPLRealloc(pszDictionary, nDictMax );
}
if( VSIFRead( pszDictionary + nDictSize, 1, 1, hHFA->fp ) < 1
|| pszDictionary[nDictSize] == '\0'
|| (nDictSize > 2 && pszDictionary[nDictSize-2] == ','
&& pszDictionary[nDictSize-1] == '.') )
break;
nDictSize++;
}
pszDictionary[nDictSize] = '\0';
return( pszDictionary );
}
CPLErr HFABand::GetRasterBlock( int nXBlock, int nYBlock, void * pData )
{
int iBlock;
if( LoadBlockInfo() != CE_None )
return CE_Failure;
iBlock = nXBlock + nYBlock * nBlocksPerRow;
/* -------------------------------------------------------------------- */
/* If the block isn't valid, or is compressed we just return */
/* all zeros, and an indication of failure. */
/* -------------------------------------------------------------------- */
if( !(panBlockFlag[iBlock] & (BFLG_VALID|BFLG_COMPRESSED)) )
{
int nBytes;
nBytes = HFAGetDataTypeBits(nDataType)*nBlockXSize*nBlockYSize/8;
while( nBytes > 0 )
((GByte *) pData)[--nBytes] = 0;
return( CE_Failure );
}
/* -------------------------------------------------------------------- */
/* Otherwise we really read the data. */
/* -------------------------------------------------------------------- */
if( VSIFSeek( psInfo->fp, panBlockStart[iBlock], SEEK_SET ) != 0 )
return CE_Failure;
if( VSIFRead( pData, panBlockSize[iBlock], 1, psInfo->fp ) == 0 )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Byte swap to local byte order if required. It appears that */
/* raster data is always stored in Intel byte order in Imagine */
/* files. */
/* -------------------------------------------------------------------- */
#ifdef CPL_MSB
if( HFAGetDataTypeBits(nDataType) == 16 )
{
int ii;
for( ii = 0; ii < nBlockXSize*nBlockYSize; ii++ )
{
unsigned char *pabyData = (unsigned char *) pData;
int nTemp;
nTemp = pabyData[ii*2];
pabyData[ii*2] = pabyData[ii*2+1];
pabyData[ii*2+1] = nTemp;
}
}
#endif /* def CPL_MSB */
return( CE_None );
}
size_t RawRasterBand::Read( void *pBuffer, size_t nSize, size_t nCount )
{
if( bIsVSIL )
return VSIFReadL( pBuffer, nSize, nCount, fpRawL );
else
return VSIFRead( pBuffer, nSize, nCount, fpRaw );
}
GDALDataset *NWT_GRCDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Look for the header */
/* -------------------------------------------------------------------- */
if( poOpenInfo->fp == NULL || poOpenInfo->nHeaderBytes < 50 )
return NULL;
if( poOpenInfo->pabyHeader[0] != 'H' ||
poOpenInfo->pabyHeader[1] != 'G' ||
poOpenInfo->pabyHeader[2] != 'P' ||
poOpenInfo->pabyHeader[3] != 'C' ||
poOpenInfo->pabyHeader[4] != '8' )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
NWT_GRCDataset *poDS;
poDS = new NWT_GRCDataset();
poDS->fp = poOpenInfo->fp;
poOpenInfo->fp = NULL;
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
VSIFSeek( poDS->fp, 0, SEEK_SET );
VSIFRead( poDS->abyHeader, 1, 1024, poDS->fp );
poDS->pGrd = (NWT_GRID *) malloc( sizeof (NWT_GRID) );
poDS->pGrd->fp = poDS->fp;
if (!nwt_ParseHeader( poDS->pGrd, (char *) poDS->abyHeader ) ||
!GDALCheckDatasetDimensions(poDS->pGrd->nXSide, poDS->pGrd->nYSide) ||
poDS->pGrd->stClassDict == NULL)
{
delete poDS;
return NULL;
}
poDS->nRasterXSize = poDS->pGrd->nXSide;
poDS->nRasterYSize = poDS->pGrd->nYSide;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new NWT_GRCRasterBand( poDS, 1) ); //Class Indexes
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
return (poDS);
}
int OGRFMECacheIndex::Load()
{
/* -------------------------------------------------------------------- */
/* Lock the cache index file if not already locked. */
/* -------------------------------------------------------------------- */
if( hLock == NULL && !Lock() )
return FALSE;
if( psTree != NULL )
{
CPLDestroyXMLNode( psTree );
psTree = NULL;
}
/* -------------------------------------------------------------------- */
/* Open the index file. If we don't get it, we assume it is */
/* because it doesn't exist, and we create a "stub" tree in */
/* memory. */
/* -------------------------------------------------------------------- */
FILE *fpIndex;
int nLength;
char *pszIndexBuffer;
fpIndex = VSIFOpen( GetPath(), "rb" );
if( fpIndex == NULL )
{
psTree = CPLCreateXMLNode( NULL, CXT_Element, "OGRFMECacheIndex" );
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Load the data from the file. */
/* -------------------------------------------------------------------- */
VSIFSeek( fpIndex, 0, SEEK_END );
nLength = VSIFTell( fpIndex );
VSIFSeek( fpIndex, 0, SEEK_SET );
pszIndexBuffer = (char *) CPLMalloc(nLength+1);
if( (int) VSIFRead( pszIndexBuffer, 1, nLength, fpIndex ) != nLength )
{
CPLError( CE_Failure, CPLE_FileIO,
"Read of %d byte index file failed.", nLength );
return FALSE;
}
VSIFClose( fpIndex );
/* -------------------------------------------------------------------- */
/* Parse the result into an inmemory XML tree. */
/* -------------------------------------------------------------------- */
pszIndexBuffer[nLength] = '\0';
psTree = CPLParseXMLString( pszIndexBuffer );
CPLFree( pszIndexBuffer );
return psTree != NULL;
}
OGRFeature *TigerPoint::GetFeature( int nRecordId,
int nX0, int nX1,
int nY0, int nY1 )
{
char achRecord[OGR_TIGER_RECBUF_LEN];
if( nRecordId < 0 || nRecordId >= nFeatures ) {
CPLError( CE_Failure, CPLE_FileIO,
"Request for out-of-range feature %d of %sP",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the raw record data from the file. */
/* -------------------------------------------------------------------- */
if( fpPrimary == NULL )
return NULL;
if( VSIFSeek( fpPrimary, nRecordId * nRecordLength, SEEK_SET ) != 0 ) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %sP",
nRecordId * nRecordLength, pszModule );
return NULL;
}
if( VSIFRead( achRecord, psRTInfo->nRecordLength, 1, fpPrimary ) != 1 ) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %sP",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Set fields. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
SetFields( psRTInfo, poFeature, achRecord);
/* -------------------------------------------------------------------- */
/* Set geometry */
/* -------------------------------------------------------------------- */
double dfX, dfY;
dfX = atoi(GetField(achRecord, nX0, nX1)) / 1000000.0;
dfY = atoi(GetField(achRecord, nY0, nY1)) / 1000000.0;
if( dfX != 0.0 || dfY != 0.0 ) {
poFeature->SetGeometryDirectly( new OGRPoint( dfX, dfY ) );
}
return poFeature;
}
int TigerFileBase::EstablishRecordLength( FILE * fp )
{
char chCurrent;
int nRecLen = 0;
if( fp == NULL || VSIFSeek( fp, 0, SEEK_SET ) != 0 )
return -1;
/* -------------------------------------------------------------------- */
/* Read through to the end of line. */
/* -------------------------------------------------------------------- */
chCurrent = '\0';
while( VSIFRead( &chCurrent, 1, 1, fp ) == 1
&& chCurrent != 10
&& chCurrent != 13 )
{
nRecLen++;
}
/* -------------------------------------------------------------------- */
/* Is the file zero length? */
/* -------------------------------------------------------------------- */
if( nRecLen == 0 )
{
return -1;
}
nRecLen++; /* for the 10 or 13 we encountered */
/* -------------------------------------------------------------------- */
/* Read through line terminator characters. We are trying to */
/* handle cases of CR, CR/LF and LF/CR gracefully. */
/* -------------------------------------------------------------------- */
while( VSIFRead( &chCurrent, 1, 1, fp ) == 1
&& (chCurrent == 10 || chCurrent == 13 ) )
{
nRecLen++;
}
VSIFSeek( fp, 0, SEEK_SET );
return nRecLen;
}
void WCTSGetCapabilities( CPLXMLNode *psOperation )
{
/* -------------------------------------------------------------------- */
/* Verify the service. */
/* -------------------------------------------------------------------- */
if( !EQUAL(CPLGetXMLValue(psOperation,"service","WCTS"),"WCTS") )
{
WCTSEmitServiceException(
CPLSPrintf( "Attempt to GetCapabilities for unsupported '%.500s'\n"
"service. Only WCTS supported.",
CPLGetXMLValue(psOperation,"service","WCTS") ) );
}
/* -------------------------------------------------------------------- */
/* Search for our capabilities document. */
/* -------------------------------------------------------------------- */
const char *pszCapFilename;
FILE *fp;
pszCapFilename = CPLFindFile( "gdal", "wcts_capabilities.xml.0.1.0" );
if( pszCapFilename == NULL
|| (fp = VSIFOpen( pszCapFilename, "rt")) == NULL )
{
WCTSEmitServiceException( "WCTS server misconfigured, "
"unable to find capabilities document." );
}
/* -------------------------------------------------------------------- */
/* Emit the document. */
/* -------------------------------------------------------------------- */
int nLen;
char *pszDoc;
VSIFSeek( fp, 0, SEEK_END );
nLen = VSIFTell( fp );
VSIFSeek( fp, 0, SEEK_SET );
pszDoc = (char *) CPLMalloc(nLen);
VSIFRead( pszDoc, 1, nLen, fp );
VSIFClose( fp );
printf( "Content-type: text/xml%c%c", 10, 10 );
VSIFWrite( pszDoc, 1, nLen, stdout );
fflush( stdout );
CPLFree( pszDoc );
exit( 0 );
}
void TigerFileBase::SetupVersion()
{
char aszRecordHead[6];
VSIFSeek( fpPrimary, 0, SEEK_SET );
VSIFRead( aszRecordHead, 1, 5, fpPrimary );
aszRecordHead[5] = '\0';
nVersionCode = atoi(aszRecordHead+1);
VSIFSeek( fpPrimary, 0, SEEK_SET );
nVersion = TigerClassifyVersion( nVersionCode );
}
static GUInt16 GetRikString( FILE *fp,
char *str,
GUInt16 strLength )
{
GUInt16 actLength;
VSIFRead( &actLength, 1, sizeof(actLength), fp );
#ifdef CPL_MSB
CPL_SWAP16PTR( &actLength );
#endif
if( actLength + 2 > strLength )
{
return actLength;
}
VSIFRead( str, 1, actLength, fp );
str[actLength] = '\0';
return actLength;
}
OGRFeature *TigerFileBase::GetFeature( int nRecordId )
{
char achRecord[OGR_TIGER_RECBUF_LEN];
if (psRTInfo == NULL)
return NULL;
if( nRecordId < 0 || nRecordId >= nFeatures )
{
CPLError( CE_Failure, CPLE_FileIO,
"Request for out-of-range feature %d of %s",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the raw record data from the file. */
/* -------------------------------------------------------------------- */
if( fpPrimary == NULL )
return NULL;
if( VSIFSeek( fpPrimary, nRecordId * nRecordLength, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s",
nRecordId * nRecordLength, pszModule );
return NULL;
}
if( VSIFRead( achRecord, psRTInfo->nRecordLength, 1, fpPrimary ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %s",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Set fields. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
SetFields( psRTInfo, poFeature, achRecord );
return poFeature;
}
static double DConvert( FILE *fp, int nCharCount )
{
char szBuffer[100];
int i;
VSIFRead( szBuffer, nCharCount, 1, fp );
szBuffer[nCharCount] = '\0';
for( i = 0; i < nCharCount; i++ )
{
if( szBuffer[i] == 'D' )
szBuffer[i] = 'E';
}
return atof(szBuffer);
}
CPLErr MerisL2FlagBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void * pImage )
{
CPLAssert( nBlockXOff == 0 );
CPLAssert( pReadBuf != NULL );
off_t nOffset = nImgOffset + nPrefixBytes +
nBlockYOff * nBlockYSize * nRecordSize;
if ( VSIFSeek( fpImage, nOffset, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Seek to %d for scanline %d failed.\n",
(int)nOffset, nBlockYOff );
return CE_Failure;
}
if ( VSIFRead( pReadBuf, 1, nDataSize, fpImage ) != nDataSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Read of %d bytes for scanline %d failed.\n",
(int)nDataSize, nBlockYOff );
return CE_Failure;
}
unsigned iImg, iBuf;
for( iImg = 0, iBuf = 0;
iImg < nBlockXSize * sizeof(GDT_UInt32);
iImg += sizeof(GDT_UInt32), iBuf += nBytePerPixel )
{
#ifdef CPL_LSB
((GByte*) pImage)[iImg] = pReadBuf[iBuf + 2];
((GByte*) pImage)[iImg + 1] = pReadBuf[iBuf + 1];
((GByte*) pImage)[iImg + 2] = pReadBuf[iBuf];
((GByte*) pImage)[iImg + 3] = 0;
#else
((GByte*) pImage)[iImg] = 0;
((GByte*) pImage)[iImg + 1] = pReadBuf[iBuf];
((GByte*) pImage)[iImg + 2] = pReadBuf[iBuf + 1];
((GByte*) pImage)[iImg + 3] = pReadBuf[iBuf + 2];
#endif
}
return CE_None;
}
/**********************************************************************
* TABRawBinBlock::ReadFromFile()
*
* Load data from the specified file location and initialize the block.
*
* Returns 0 if succesful or -1 if an error happened, in which case
* CPLError() will have been called.
**********************************************************************/
int TABRawBinBlock::ReadFromFile(FILE *fpSrc, int nOffset,
int nSize /*= 512*/)
{
GByte *pabyBuf;
if (fpSrc == NULL || nSize == 0)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"TABRawBinBlock::ReadFromFile(): Assertion Failed!");
return -1;
}
m_fp = fpSrc;
m_nFileOffset = nOffset;
m_nCurPos = 0;
m_bModified = FALSE;
/*----------------------------------------------------------------
* Alloc a buffer to contain the data
*---------------------------------------------------------------*/
pabyBuf = (GByte*)CPLMalloc(nSize*sizeof(GByte));
/*----------------------------------------------------------------
* Read from the file
*---------------------------------------------------------------*/
if (VSIFSeek(fpSrc, nOffset, SEEK_SET) != 0 ||
(m_nSizeUsed = VSIFRead(pabyBuf, sizeof(GByte), nSize, fpSrc) ) == 0 ||
(m_bHardBlockSize && m_nSizeUsed != nSize ) )
{
CPLError(CE_Failure, CPLE_FileIO,
"ReadFromFile() failed reading %d bytes at offset %d.",
nSize, nOffset);
CPLFree(pabyBuf);
return -1;
}
/*----------------------------------------------------------------
* Init block with the data we just read
*---------------------------------------------------------------*/
return InitBlockFromData(pabyBuf, nSize, m_nSizeUsed,
FALSE, fpSrc, nOffset);
}
CPLErr NWT_GRCRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void *pImage )
{
NWT_GRCDataset *poGDS =(NWT_GRCDataset *) poDS;
int nRecordSize = nBlockXSize *( poGDS->pGrd->nBitsPerPixel / 8 );
if( nBand == 1 )
{ //grc's are just one band of indices
VSIFSeek( poGDS->fp, 1024 + nRecordSize * nBlockYOff, SEEK_SET );
VSIFRead( pImage, 1, nRecordSize, poGDS->fp );
}
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"No band number %d",
nBand );
return CE_Failure;
}
return CE_None;
}
int ILI1Reader::AddIliGeom(OGRFeature *feature, int iField, long fpos)
{
#if defined(_WIN32) || defined(__WIN32__)
//Other positions on Windows !?
#else
long nBlockLen = VSIFTell( fpItf )-fpos;
VSIFSeek( fpItf, fpos, SEEK_SET );
char *pszRawData = (char *) CPLMalloc(nBlockLen+1);
if( (int) VSIFRead( pszRawData, 1, nBlockLen, fpItf ) != nBlockLen )
{
CPLFree( pszRawData );
CPLError( CE_Failure, CPLE_FileIO, "Read of transfer file failed." );
return FALSE;
}
pszRawData[nBlockLen]= '\0';
feature->SetField(iField, pszRawData);
CPLFree( pszRawData );
#endif
return TRUE;
}
TigerVersion OGRTigerDataSource::TigerCheckVersion( TigerVersion nOldVersion,
const char *pszFilename )
{
if( nOldVersion != TIGER_2002 )
return nOldVersion;
char *pszRTCFilename = BuildFilename( pszFilename, "C" );
FILE *fp = VSIFOpen( pszRTCFilename, "rb" );
CPLFree( pszRTCFilename );
if( fp == NULL )
return nOldVersion;
char szHeader[115];
if( VSIFRead( szHeader, sizeof(szHeader)-1, 1, fp ) < 1 )
{
VSIFClose( fp );
return nOldVersion;
}
VSIFClose( fp );
/* -------------------------------------------------------------------- */
/* Is the record length 112? If so, it is an older version */
/* than 2002. */
/* -------------------------------------------------------------------- */
if( szHeader[112] == 10 || szHeader[112] == 13 )
{
CPLDebug( "TIGER", "Forcing version back to UA2000 since RTC records are short." );
return TIGER_UA2000;
}
else
return nOldVersion;
}
void AVCRawBinReadBytes(AVCRawBinFile *psFile, int nBytesToRead, GByte *pBuf)
{
int nTotalBytesToRead = nBytesToRead;
/* Make sure file is opened with Read access
*/
if (psFile == NULL ||
(psFile->eAccess != AVCRead && psFile->eAccess != AVCReadWrite))
{
CPLError(CE_Failure, CPLE_FileIO,
"AVCRawBinReadBytes(): call not compatible with access mode.");
return;
}
/* Quick method: check to see if we can satisfy the request with a
* simple memcpy... most calls should take this path.
*/
if (psFile->nCurPos + nBytesToRead <= psFile->nCurSize)
{
memcpy(pBuf, psFile->abyBuf+psFile->nCurPos, nBytesToRead);
psFile->nCurPos += nBytesToRead;
return;
}
/* This is the long method... it supports reading data that
* overlaps the input buffer boundaries.
*/
while(nBytesToRead > 0)
{
/* If we reached the end of our memory buffer then read another
* chunk from the file
*/
CPLAssert(psFile->nCurPos <= psFile->nCurSize);
if (psFile->nCurPos == psFile->nCurSize)
{
psFile->nOffset += psFile->nCurSize;
psFile->nCurSize = (int)VSIFRead(psFile->abyBuf, sizeof(GByte),
AVCRAWBIN_READBUFSIZE, psFile->fp);
psFile->nCurPos = 0;
}
if (psFile->nCurSize == 0)
{
/* Attempt to read past EOF... generate an error.
*
* Note: AVCRawBinEOF() can set bDisableReadBytesEOFError=TRUE
* to disable the error message while it is testing
* for EOF.
*
* TODO: We are not resetting the buffer. Also, there is no easy
* way to recover from the situation.
*/
if (bDisableReadBytesEOFError == FALSE)
CPLError(CE_Failure, CPLE_FileIO,
"EOF encountered in %s after reading %d bytes while "
"trying to read %d bytes. File may be corrupt.",
psFile->pszFname, nTotalBytesToRead-nBytesToRead,
nTotalBytesToRead);
return;
}
/* If the requested bytes are not all in the current buffer then
* just read the part that's in memory for now... the loop will
* take care of the rest.
*/
if (psFile->nCurPos + nBytesToRead > psFile->nCurSize)
{
int nBytes;
nBytes = psFile->nCurSize-psFile->nCurPos;
memcpy(pBuf, psFile->abyBuf+psFile->nCurPos, nBytes);
psFile->nCurPos += nBytes;
pBuf += nBytes;
nBytesToRead -= nBytes;
}
else
{
/* All the requested bytes are now in the buffer...
* simply copy them and return.
*/
memcpy(pBuf, psFile->abyBuf+psFile->nCurPos, nBytesToRead);
psFile->nCurPos += nBytesToRead;
nBytesToRead = 0; /* Terminate the loop */
}
}
}
int GMLReader::LoadClasses( const char *pszFile )
{
// Add logic later to determine reasonable default schema file.
if( pszFile == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Load the raw XML file. */
/* -------------------------------------------------------------------- */
FILE *fp;
int nLength;
char *pszWholeText;
fp = VSIFOpen( pszFile, "rb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open file %s.", pszFile );
return FALSE;
}
VSIFSeek( fp, 0, SEEK_END );
nLength = VSIFTell( fp );
VSIFSeek( fp, 0, SEEK_SET );
pszWholeText = (char *) VSIMalloc(nLength+1);
if( pszWholeText == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to allocate %d byte buffer for %s,\n"
"is this really a GMLFeatureClassList file?",
nLength, pszFile );
VSIFClose( fp );
return FALSE;
}
if( VSIFRead( pszWholeText, nLength, 1, fp ) != 1 )
{
VSIFree( pszWholeText );
VSIFClose( fp );
CPLError( CE_Failure, CPLE_AppDefined,
"Read failed on %s.", pszFile );
return FALSE;
}
pszWholeText[nLength] = '\0';
VSIFClose( fp );
if( strstr( pszWholeText, "<GMLFeatureClassList>" ) == NULL )
{
VSIFree( pszWholeText );
CPLError( CE_Failure, CPLE_AppDefined,
"File %s does not contain a GMLFeatureClassList tree.",
pszFile );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Convert to XML parse tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLParseXMLString( pszWholeText );
VSIFree( pszWholeText );
// We assume parser will report errors via CPL.
if( psRoot == NULL )
return FALSE;
if( psRoot->eType != CXT_Element
|| !EQUAL(psRoot->pszValue,"GMLFeatureClassList") )
{
CPLDestroyXMLNode(psRoot);
CPLError( CE_Failure, CPLE_AppDefined,
"File %s is not a GMLFeatureClassList document.",
pszFile );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Extract feature classes for all definitions found. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psThis;
for( psThis = psRoot->psChild; psThis != NULL; psThis = psThis->psNext )
{
if( psThis->eType == CXT_Element
&& EQUAL(psThis->pszValue,"GMLFeatureClass") )
{
GMLFeatureClass *poClass;
poClass = new GMLFeatureClass();
if( !poClass->InitializeFromXML( psThis ) )
{
delete poClass;
CPLDestroyXMLNode( psRoot );
return FALSE;
}
poClass->SetSchemaLocked( TRUE );
AddClass( poClass );
}
}
CPLDestroyXMLNode( psRoot );
SetClassListLocked( TRUE );
return TRUE;
}
HFAHandle HFAOpen( const char * pszFilename, const char * pszAccess )
{
FILE *fp;
char szHeader[16];
HFAInfo_t *psInfo;
GUInt32 nHeaderPos;
HFAEntry *poNode;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszAccess,"r") || EQUAL(pszAccess,"rb" ) )
fp = VSIFOpen( pszFilename, "rb" );
else
fp = VSIFOpen( pszFilename, "r+b" );
/* should this be changed to use some sort of CPLFOpen() which will
set the error? */
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File open of %s failed.",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read and verify the header. */
/* -------------------------------------------------------------------- */
if( VSIFRead( szHeader, 16, 1, fp ) < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to read 16 byte header failed for\n%s.",
pszFilename );
return NULL;
}
if( !EQUALN(szHeader,"EHFA_HEADER_TAG",15) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s is not an Imagine HFA file ... header wrong.",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the HFAInfo_t */
/* -------------------------------------------------------------------- */
psInfo = (HFAInfo_t *) CPLCalloc(sizeof(HFAInfo_t),1);
psInfo->fp = fp;
/* -------------------------------------------------------------------- */
/* Where is the header? */
/* -------------------------------------------------------------------- */
VSIFRead( &nHeaderPos, sizeof(GInt32), 1, fp );
HFAStandard( 4, &nHeaderPos );
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
VSIFSeek( fp, nHeaderPos, SEEK_SET );
VSIFRead( &(psInfo->nVersion), sizeof(GInt32), 1, fp );
HFAStandard( 4, &(psInfo->nVersion) );
VSIFRead( szHeader, 4, 1, fp ); /* skip freeList */
VSIFRead( &(psInfo->nRootPos), sizeof(GInt32), 1, fp );
HFAStandard( 4, &(psInfo->nRootPos) );
VSIFRead( &(psInfo->nEntryHeaderLength), sizeof(GInt16), 1, fp );
HFAStandard( 2, &(psInfo->nEntryHeaderLength) );
VSIFRead( &(psInfo->nDictionaryPos), sizeof(GInt32), 1, fp );
HFAStandard( 4, &(psInfo->nDictionaryPos) );
/* -------------------------------------------------------------------- */
/* Instantiate the root entry. */
/* -------------------------------------------------------------------- */
psInfo->poRoot = new HFAEntry( psInfo, psInfo->nRootPos, NULL, NULL );
/* -------------------------------------------------------------------- */
/* Read the dictionary */
/* -------------------------------------------------------------------- */
psInfo->pszDictionary = HFAGetDictionary( psInfo );
psInfo->poDictionary = new HFADictionary( psInfo->pszDictionary );
/* -------------------------------------------------------------------- */
/* Find the first band node. */
/* -------------------------------------------------------------------- */
psInfo->nBands = 0;
poNode = psInfo->poRoot->GetChild();
while( poNode != NULL )
{
if( EQUAL(poNode->GetType(),"Eimg_Layer") )
{
if( psInfo->nBands == 0 )
{
psInfo->nXSize = poNode->GetIntField("width");
psInfo->nYSize = poNode->GetIntField("height");
}
else if( poNode->GetIntField("width") != psInfo->nXSize
|| poNode->GetIntField("height") != psInfo->nYSize )
{
CPLAssert( FALSE );
continue;
}
psInfo->papoBand = (HFABand **)
CPLRealloc(psInfo->papoBand,
sizeof(HFABand *) * (psInfo->nBands+1));
psInfo->papoBand[psInfo->nBands] = new HFABand( psInfo, poNode );
psInfo->nBands++;
}
poNode = poNode->GetNext();
}
return psInfo;
}
GDALDataset *RIKDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->fp == NULL || poOpenInfo->nHeaderBytes < 50 )
return NULL;
bool rik3header = false;
if( EQUALN((const char *) poOpenInfo->pabyHeader, "RIK3", 4) )
{
rik3header = true;
}
if( rik3header )
VSIFSeek( poOpenInfo->fp, 4, SEEK_SET );
else
VSIFSeek( poOpenInfo->fp, 0, SEEK_SET );
/* -------------------------------------------------------------------- */
/* Read the map name. */
/* -------------------------------------------------------------------- */
char name[1024];
GUInt16 nameLength = GetRikString( poOpenInfo->fp, name, sizeof(name) );
if( nameLength > sizeof(name) - 1 )
{
return NULL;
}
if( !rik3header )
{
if( nameLength == 0 || nameLength != strlen(name) )
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
RIKHeader header;
double metersPerPixel;
const char *headerType = "RIK3";
if( rik3header )
{
/* -------------------------------------------------------------------- */
/* RIK3 header. */
/* -------------------------------------------------------------------- */
// Read projection name
char projection[1024];
GUInt16 projLength = GetRikString( poOpenInfo->fp,
projection, sizeof(projection) );
if( projLength > sizeof(projection) - 1 )
{
// Unreasonable string length, assume wrong format
return NULL;
}
// Read unknown string
projLength = GetRikString( poOpenInfo->fp, projection, sizeof(projection) );
// Read map north edge
char tmpStr[16];
GUInt16 tmpLength = GetRikString( poOpenInfo->fp,
tmpStr, sizeof(tmpStr) );
if( tmpLength > sizeof(tmpStr) - 1 )
{
// Unreasonable string length, assume wrong format
return NULL;
}
header.fNorth = atof( tmpStr );
// Read map west edge
tmpLength = GetRikString( poOpenInfo->fp,
tmpStr, sizeof(tmpStr) );
if( tmpLength > sizeof(tmpStr) - 1 )
{
// Unreasonable string length, assume wrong format
return NULL;
}
header.fWest = atof( tmpStr );
// Read binary values
VSIFRead( &header.iScale, 1, sizeof(header.iScale), poOpenInfo->fp );
VSIFRead( &header.iMPPNum, 1, sizeof(header.iMPPNum), poOpenInfo->fp );
VSIFRead( &header.iBlockWidth, 1, sizeof(header.iBlockWidth), poOpenInfo->fp );
VSIFRead( &header.iBlockHeight, 1, sizeof(header.iBlockHeight), poOpenInfo->fp );
VSIFRead( &header.iHorBlocks, 1, sizeof(header.iHorBlocks), poOpenInfo->fp );
VSIFRead( &header.iVertBlocks, 1, sizeof(header.iVertBlocks), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP32PTR( &header.iScale );
CPL_SWAP32PTR( &header.iMPPNum );
CPL_SWAP32PTR( &header.iBlockWidth );
CPL_SWAP32PTR( &header.iBlockHeight );
CPL_SWAP32PTR( &header.iHorBlocks );
CPL_SWAP32PTR( &header.iVertBlocks );
#endif
VSIFRead( &header.iBitsPerPixel, 1, sizeof(header.iBitsPerPixel), poOpenInfo->fp );
VSIFRead( &header.iOptions, 1, sizeof(header.iOptions), poOpenInfo->fp );
header.iUnknown = header.iOptions;
VSIFRead( &header.iOptions, 1, sizeof(header.iOptions), poOpenInfo->fp );
header.fSouth = header.fNorth -
header.iVertBlocks * header.iBlockHeight * header.iMPPNum;
header.fEast = header.fWest +
header.iHorBlocks * header.iBlockWidth * header.iMPPNum;
metersPerPixel = header.iMPPNum;
}
else
{
/* -------------------------------------------------------------------- */
/* Old RIK header. */
/* -------------------------------------------------------------------- */
VSIFRead( &header.iUnknown, 1, sizeof(header.iUnknown), poOpenInfo->fp );
VSIFRead( &header.fSouth, 1, sizeof(header.fSouth), poOpenInfo->fp );
VSIFRead( &header.fWest, 1, sizeof(header.fWest), poOpenInfo->fp );
VSIFRead( &header.fNorth, 1, sizeof(header.fNorth), poOpenInfo->fp );
VSIFRead( &header.fEast, 1, sizeof(header.fEast), poOpenInfo->fp );
VSIFRead( &header.iScale, 1, sizeof(header.iScale), poOpenInfo->fp );
VSIFRead( &header.iMPPNum, 1, sizeof(header.iMPPNum), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP64PTR( &header.fSouth );
CPL_SWAP64PTR( &header.fWest );
CPL_SWAP64PTR( &header.fNorth );
CPL_SWAP64PTR( &header.fEast );
CPL_SWAP32PTR( &header.iScale );
CPL_SWAP32PTR( &header.iMPPNum );
#endif
if (!CPLIsFinite(header.fSouth) |
!CPLIsFinite(header.fWest) |
!CPLIsFinite(header.fNorth) |
!CPLIsFinite(header.fEast))
return NULL;
bool offsetBounds;
offsetBounds = header.fSouth < 4000000;
header.iMPPDen = 1;
if( offsetBounds )
{
header.fSouth += 4002995;
header.fNorth += 5004000;
header.fWest += 201000;
header.fEast += 302005;
VSIFRead( &header.iMPPDen, 1, sizeof(header.iMPPDen), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP32PTR( &header.iMPPDen );
#endif
headerType = "RIK1";
}
else
{
headerType = "RIK2";
}
metersPerPixel = header.iMPPNum / double(header.iMPPDen);
VSIFRead( &header.iBlockWidth, 1, sizeof(header.iBlockWidth), poOpenInfo->fp );
VSIFRead( &header.iBlockHeight, 1, sizeof(header.iBlockHeight), poOpenInfo->fp );
VSIFRead( &header.iHorBlocks, 1, sizeof(header.iHorBlocks), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP32PTR( &header.iBlockWidth );
CPL_SWAP32PTR( &header.iBlockHeight );
CPL_SWAP32PTR( &header.iHorBlocks );
#endif
if(( header.iBlockWidth > 2000 ) || ( header.iBlockWidth < 10 ) ||
( header.iBlockHeight > 2000 ) || ( header.iBlockHeight < 10 ))
return NULL;
if( !offsetBounds )
{
VSIFRead( &header.iVertBlocks, 1, sizeof(header.iVertBlocks), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP32PTR( &header.iVertBlocks );
#endif
}
if( offsetBounds || !header.iVertBlocks )
{
header.iVertBlocks = (GUInt32)
ceil( (header.fNorth - header.fSouth) /
(header.iBlockHeight * metersPerPixel) );
}
#if RIK_HEADER_DEBUG
CPLDebug( "RIK",
"Original vertical blocks %d\n",
header.iVertBlocks );
#endif
VSIFRead( &header.iBitsPerPixel, 1, sizeof(header.iBitsPerPixel), poOpenInfo->fp );
if( header.iBitsPerPixel != 8 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s has unsupported number of bits per pixel.\n",
poOpenInfo->pszFilename );
return NULL;
}
VSIFRead( &header.iOptions, 1, sizeof(header.iOptions), poOpenInfo->fp );
if( !header.iHorBlocks || !header.iVertBlocks )
return NULL;
if( header.iOptions != 0x00 && // Uncompressed
header.iOptions != 0x40 && // Uncompressed
header.iOptions != 0x01 && // RLE
header.iOptions != 0x41 && // RLE
header.iOptions != 0x0B && // LZW
header.iOptions != 0x0D ) // ZLIB
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s. Unknown map options.\n",
poOpenInfo->pszFilename );
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Read the palette. */
/* -------------------------------------------------------------------- */
GByte palette[768];
GUInt16 i;
for( i = 0; i < 256; i++ )
{
VSIFRead( &palette[i * 3 + 2], 1, 1, poOpenInfo->fp );
VSIFRead( &palette[i * 3 + 1], 1, 1, poOpenInfo->fp );
VSIFRead( &palette[i * 3 + 0], 1, 1, poOpenInfo->fp );
}
/* -------------------------------------------------------------------- */
/* Find block offsets. */
/* -------------------------------------------------------------------- */
GUInt32 blocks;
GUInt32 *offsets;
blocks = header.iHorBlocks * header.iVertBlocks;
offsets = (GUInt32 *)CPLMalloc( blocks * sizeof(GUInt32) );
if( !offsets )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s. Unable to allocate offset table.\n",
poOpenInfo->pszFilename );
return NULL;
}
if( header.iOptions == 0x00 )
{
offsets[0] = VSIFTell( poOpenInfo->fp );
for( GUInt32 i = 1; i < blocks; i++ )
{
offsets[i] = offsets[i - 1] +
header.iBlockWidth * header.iBlockHeight;
}
}
else
{
for( GUInt32 i = 0; i < blocks; i++ )
{
VSIFRead( &offsets[i], 1, sizeof(offsets[i]), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP32PTR( &offsets[i] );
#endif
if( rik3header )
{
GUInt32 blockSize;
VSIFRead( &blockSize, 1, sizeof(blockSize), poOpenInfo->fp );
#ifdef CPL_MSB
CPL_SWAP32PTR( &blockSize );
#endif
}
}
}
/* -------------------------------------------------------------------- */
/* Final checks. */
/* -------------------------------------------------------------------- */
// File size
if( VSIFEof( poOpenInfo->fp ) )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s. Read past end of file.\n",
poOpenInfo->pszFilename );
return NULL;
}
VSIFSeek( poOpenInfo->fp, 0, SEEK_END );
GUInt32 fileSize = VSIFTell( poOpenInfo->fp );
#if RIK_HEADER_DEBUG
CPLDebug( "RIK",
"File size %d\n",
fileSize );
#endif
// Make sure the offset table is valid
GUInt32 lastoffset = 0;
for( GUInt32 y = 0; y < header.iVertBlocks; y++)
{
for( GUInt32 x = 0; x < header.iHorBlocks; x++)
{
if( !offsets[x + y * header.iHorBlocks] )
{
continue;
}
if( offsets[x + y * header.iHorBlocks] >= fileSize )
{
if( !y )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s too short.\n",
poOpenInfo->pszFilename );
return NULL;
}
header.iVertBlocks = y;
break;
}
if( offsets[x + y * header.iHorBlocks] < lastoffset )
{
if( !y )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s. Corrupt offset table.\n",
poOpenInfo->pszFilename );
return NULL;
}
header.iVertBlocks = y;
break;
}
lastoffset = offsets[x + y * header.iHorBlocks];
}
}
#if RIK_HEADER_DEBUG
CPLDebug( "RIK",
"first offset %d\n"
"last offset %d\n",
offsets[0],
lastoffset );
#endif
const char *compression = "RLE";
if( header.iOptions == 0x00 ||
header.iOptions == 0x40 )
compression = "Uncompressed";
if( header.iOptions == 0x0b )
compression = "LZW";
if( header.iOptions == 0x0d )
compression = "ZLIB";
CPLDebug( "RIK",
"RIK file parameters:\n"
" name: %s\n"
" header: %s\n"
" unknown: 0x%X\n"
" south: %f\n"
" west: %f\n"
" north: %f\n"
" east: %f\n"
" original scale: %d\n"
" meters per pixel: %f\n"
" block width: %d\n"
" block height: %d\n"
" horizontal blocks: %d\n"
" vertical blocks: %d\n"
" bits per pixel: %d\n"
" options: 0x%X\n"
" compression: %s\n",
name, headerType, header.iUnknown,
header.fSouth, header.fWest, header.fNorth, header.fEast,
header.iScale, metersPerPixel,
header.iBlockWidth, header.iBlockHeight,
header.iHorBlocks, header.iVertBlocks,
header.iBitsPerPixel, header.iOptions, compression);
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
RIKDataset *poDS;
poDS = new RIKDataset();
poDS->fp = poOpenInfo->fp;
poOpenInfo->fp = NULL;
poDS->fTransform[0] = header.fWest - metersPerPixel / 2.0;
poDS->fTransform[1] = metersPerPixel;
poDS->fTransform[2] = 0.0;
poDS->fTransform[3] = header.fNorth + metersPerPixel / 2.0;
poDS->fTransform[4] = 0.0;
poDS->fTransform[5] = -metersPerPixel;
poDS->nBlockXSize = header.iBlockWidth;
poDS->nBlockYSize = header.iBlockHeight;
poDS->nHorBlocks = header.iHorBlocks;
poDS->nVertBlocks = header.iVertBlocks;
poDS->pOffsets = offsets;
poDS->options = header.iOptions;
poDS->nFileSize = fileSize;
poDS->nRasterXSize = header.iBlockWidth * header.iHorBlocks;
poDS->nRasterYSize = header.iBlockHeight * header.iVertBlocks;
poDS->nBands = 1;
GDALColorEntry oEntry;
poDS->poColorTable = new GDALColorTable();
for( i = 0; i < 256; i++ )
{
oEntry.c1 = palette[i * 3 + 2]; // Red
oEntry.c2 = palette[i * 3 + 1]; // Green
oEntry.c3 = palette[i * 3]; // Blue
oEntry.c4 = 255;
poDS->poColorTable->SetColorEntry( i, &oEntry );
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new RIKRasterBand( poDS, 1 ));
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for external overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->papszSiblingFiles );
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError( CE_Failure, CPLE_NotSupported,
"The RIK driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
return( poDS );
}
