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;
}
/*!
\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;
}
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;
}
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;
}
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;
}
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 );
}
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;
}
CPLErr ELASRasterBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
void * pImage )
{
ELASDataset *poGDS = (ELASDataset *) poDS;
CPLErr eErr = CE_None;
long nOffset;
int nDataSize;
CPLAssert( nBlockXOff == 0 );
CPLAssert( eAccess == GA_Update );
nDataSize = GDALGetDataTypeSize(eDataType) * poGDS->GetRasterXSize() / 8;
nOffset = poGDS->nLineOffset * nBlockYOff + 1024 + (nBand-1) * nDataSize;
if( VSIFSeek( poGDS->fp, nOffset, SEEK_SET ) != 0
|| VSIFWrite( pImage, 1, nDataSize, poGDS->fp ) != (size_t) nDataSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Seek or write of %d bytes at %ld failed.\n",
nDataSize, nOffset );
eErr = CE_Failure;
}
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 );
}
void TigerFileBase::EstablishFeatureCount()
{
if( fpPrimary == NULL )
return;
nRecordLength = EstablishRecordLength( fpPrimary );
if( nRecordLength == -1 )
{
nRecordLength = 1;
nFeatures = 0;
return;
}
/* -------------------------------------------------------------------- */
/* Now we think we know the fixed record length for the file */
/* (including line terminators). Get the total file size, and */
/* divide by this length to get the presumed number of records. */
/* -------------------------------------------------------------------- */
long nFileSize;
VSIFSeek( fpPrimary, 0, SEEK_END );
nFileSize = VSIFTell( fpPrimary );
if( (nFileSize % nRecordLength) != 0 )
{
CPLError( CE_Warning, CPLE_FileIO,
"TigerFileBase::EstablishFeatureCount(): "
"File length %d doesn't divide by record length %d.\n",
(int) nFileSize, (int) nRecordLength );
}
nFeatures = nFileSize / nRecordLength;
}
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);
}
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 );
}
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;
}
}
int RawRasterBand::Seek( vsi_l_offset nOffset, int nSeekMode )
{
if( bIsVSIL )
return VSIFSeekL( fpRawL, nOffset, nSeekMode );
else
return VSIFSeek( fpRaw, (long) nOffset, nSeekMode );
}
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);
}
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 ELASDataset::FlushCache()
{
GDALDataset::FlushCache();
if( bHeaderModified )
{
VSIFSeek( fp, 0, SEEK_SET );
VSIFWrite( &sHeader, 1024, 1, fp );
bHeaderModified = FALSE;
}
}
void IDADataset::FlushCache()
{
RawDataset::FlushCache();
if( bHeaderDirty )
{
VSIFSeek( fpRaw, 0, SEEK_SET );
VSIFWrite( abyHeader, 512, 1, fpRaw );
bHeaderDirty = FALSE;
}
}
/**********************************************************************
* TABDATFile::Close()
*
* Close current file, and release all memory used.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::Close()
{
if (m_fp == NULL)
return 0;
/*----------------------------------------------------------------
* Write access: Update the header with number of records, etc.
* and add a CTRL-Z char at the end of the file.
*---------------------------------------------------------------*/
if (m_eAccessMode == TABWrite)
{
WriteHeader();
char cEOF = 26;
if (VSIFSeek(m_fp, 0L, SEEK_END) == 0)
VSIFWrite(&cEOF, 1, 1, m_fp);
}
// Delete all structures
if (m_poHeaderBlock)
{
delete m_poHeaderBlock;
m_poHeaderBlock = NULL;
}
if (m_poRecordBlock)
{
delete m_poRecordBlock;
m_poRecordBlock = NULL;
}
// Close file
VSIFClose(m_fp);
m_fp = NULL;
CPLFree(m_pszFname);
m_pszFname = NULL;
CPLFree(m_pasFieldDef);
m_pasFieldDef = NULL;
m_numFields = -1;
m_numRecords = -1;
m_nFirstRecordPtr = 0;
m_nBlockSize = 0;
m_nRecordSize = -1;
m_nCurRecordId = -1;
m_bWriteHeaderInitialized = FALSE;
return 0;
}
void DDFModule::Rewind( long nOffset )
{
if( nOffset == -1 )
nOffset = nFirstRecordOffset;
if( fpDDF == NULL )
return;
VSIFSeek( fpDDF, nOffset, SEEK_SET );
if( nOffset == nFirstRecordOffset && poRecord != NULL )
poRecord->Clear();
}
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;
}
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;
}
OGRGMLDataSource::~OGRGMLDataSource()
{
if( fpOutput != NULL )
{
VSIFPrintf( fpOutput, "%s",
"</ogr:FeatureCollection>\n" );
InsertHeader();
if( nBoundedByLocation != -1
&& sBoundingRect.IsInit()
&& VSIFSeek( fpOutput, nBoundedByLocation, SEEK_SET ) == 0 )
{
VSIFPrintf( fpOutput, " <gml:boundedBy>\n" );
VSIFPrintf( fpOutput, " <gml:Box>\n" );
VSIFPrintf( fpOutput,
" <gml:coord><gml:X>%.16g</gml:X>"
"<gml:Y>%.16g</gml:Y></gml:coord>\n",
sBoundingRect.MinX, sBoundingRect.MinY );
VSIFPrintf( fpOutput,
" <gml:coord><gml:X>%.16g</gml:X>"
"<gml:Y>%.16g</gml:Y></gml:coord>\n",
sBoundingRect.MaxX, sBoundingRect.MaxY );
VSIFPrintf( fpOutput, " </gml:Box>\n" );
VSIFPrintf( fpOutput, " </gml:boundedBy>" );
}
if( fpOutput != stdout )
VSIFClose( fpOutput );
}
CSLDestroy( papszCreateOptions );
CPLFree( pszName );
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if( poReader )
delete poReader;
}
/**********************************************************************
* AVCRawBinFSeek()
*
* Move the read pointer to the specified location.
*
* As with fseek(), the specified position can be relative to the
* beginning of the file (SEEK_SET), or the current position (SEEK_CUR).
* SEEK_END is not supported.
**********************************************************************/
void AVCRawBinFSeek(AVCRawBinFile *psFile, int nOffset, int nFrom)
{
int nTarget = 0;
CPLAssert(nFrom == SEEK_SET || nFrom == SEEK_CUR);
/* Supported only with read access for now
*/
CPLAssert(psFile && psFile->eAccess != AVCWrite);
if (psFile == NULL || psFile->eAccess == AVCWrite)
return;
/* Compute destination relative to current memory buffer
*/
if (nFrom == SEEK_SET)
nTarget = nOffset - psFile->nOffset;
else if (nFrom == SEEK_CUR)
nTarget = nOffset + psFile->nCurPos;
/* Is the destination located inside the current buffer?
*/
if (nTarget > 0 && nTarget <= psFile->nCurSize)
{
/* Requested location is already in memory... just move the
* read pointer
*/
psFile->nCurPos = nTarget;
}
else
{
/* Requested location is not part of the memory buffer...
* move the FILE * to the right location and be ready to
* read from there.
*/
psFile->nCurPos = 0;
psFile->nCurSize = 0;
psFile->nOffset = psFile->nOffset+nTarget;
if( VSIFSeek(psFile->fp, psFile->nOffset, SEEK_SET) < 0 )
return;
}
}
/**********************************************************************
* 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;
}