int NGSGEOIDDataset::GetHeaderInfo( const GByte* pBuffer,
double* padfGeoTransform,
int* pnRows,
int* pnCols,
int* pbIsLittleEndian )
{
double dfSLAT;
double dfWLON;
double dfDLAT;
double dfDLON;
int nNLAT;
int nNLON;
int nIKIND;
/* First check IKIND marker to determine if the file */
/* is in little or big-endian order, and if it is a valid */
/* NGSGEOID dataset */
memcpy(&nIKIND, pBuffer + HEADER_SIZE - 4, 4);
CPL_LSBPTR32(&nIKIND);
if (nIKIND == 1)
{
*pbIsLittleEndian = TRUE;
}
else
{
memcpy(&nIKIND, pBuffer + HEADER_SIZE - 4, 4);
CPL_MSBPTR32(&nIKIND);
if (nIKIND == 1)
{
*pbIsLittleEndian = FALSE;
}
else
{
return FALSE;
}
}
memcpy(&dfSLAT, pBuffer, 8);
if (*pbIsLittleEndian)
{
CPL_LSBPTR64(&dfSLAT);
}
else
{
CPL_MSBPTR64(&dfSLAT);
}
pBuffer += 8;
memcpy(&dfWLON, pBuffer, 8);
if (*pbIsLittleEndian)
{
CPL_LSBPTR64(&dfWLON);
}
else
{
CPL_MSBPTR64(&dfWLON);
}
pBuffer += 8;
memcpy(&dfDLAT, pBuffer, 8);
if (*pbIsLittleEndian)
{
CPL_LSBPTR64(&dfDLAT);
}
else
{
CPL_MSBPTR64(&dfDLAT);
}
pBuffer += 8;
memcpy(&dfDLON, pBuffer, 8);
if (*pbIsLittleEndian)
{
CPL_LSBPTR64(&dfDLON);
}
else
{
CPL_MSBPTR64(&dfDLON);
}
pBuffer += 8;
memcpy(&nNLAT, pBuffer, 4);
if (*pbIsLittleEndian)
{
CPL_LSBPTR32(&nNLAT);
}
else
{
CPL_MSBPTR32(&nNLAT);
}
pBuffer += 4;
memcpy(&nNLON, pBuffer, 4);
if (*pbIsLittleEndian)
{
CPL_LSBPTR32(&nNLON);
}
else
{
CPL_MSBPTR32(&nNLON);
}
pBuffer += 4;
/*CPLDebug("NGSGEOID", "SLAT=%f, WLON=%f, DLAT=%f, DLON=%f, NLAT=%d, NLON=%d, IKIND=%d",
dfSLAT, dfWLON, dfDLAT, dfDLON, nNLAT, nNLON, nIKIND);*/
if (nNLAT <= 0 || nNLON <= 0 || dfDLAT <= 0.0 || dfDLON <= 0.0)
return FALSE;
/* Grids go over +180 in longitude */
if (dfSLAT < -90.0 || dfSLAT + nNLAT * dfDLAT > 90.0 ||
dfWLON < -180.0 || dfWLON + nNLON * dfDLON > 360.0)
return FALSE;
padfGeoTransform[0] = dfWLON - dfDLON / 2;
padfGeoTransform[1] = dfDLON;
padfGeoTransform[2] = 0.0;
padfGeoTransform[3] = dfSLAT + nNLAT * dfDLAT - dfDLAT / 2;
padfGeoTransform[4] = 0.0;
padfGeoTransform[5] = -dfDLAT;
*pnRows = nNLAT;
*pnCols = nNLON;
return TRUE;
}
void GRIBRasterBand::FindPDSTemplate()
{
GRIBDataset *poGDS = (GRIBDataset *) poDS;
/* -------------------------------------------------------------------- */
/* Collect section 4 octet information ... we read the file */
/* ourselves since the GRIB API does not appear to preserve all */
/* this for us. */
/* -------------------------------------------------------------------- */
GIntBig nOffset = VSIFTellL( poGDS->fp );
GByte abyHead[5];
GUInt32 nSectSize;
VSIFSeekL( poGDS->fp, start+16, SEEK_SET );
VSIFReadL( abyHead, 5, 1, poGDS->fp );
while( abyHead[4] != 4 )
{
memcpy( &nSectSize, abyHead, 4 );
CPL_MSBPTR32( &nSectSize );
if( VSIFSeekL( poGDS->fp, nSectSize-5, SEEK_CUR ) != 0
|| VSIFReadL( abyHead, 5, 1, poGDS->fp ) != 1 )
break;
}
if( abyHead[4] == 4 )
{
GUInt16 nCoordCount;
GUInt16 nPDTN;
CPLString osOctet;
int i;
GByte *pabyBody;
memcpy( &nSectSize, abyHead, 4 );
CPL_MSBPTR32( &nSectSize );
pabyBody = (GByte *) CPLMalloc(nSectSize-5);
VSIFReadL( pabyBody, 1, nSectSize-5, poGDS->fp );
memcpy( &nCoordCount, pabyBody + 5 - 5, 2 );
CPL_MSBPTR16( &nCoordCount );
memcpy( &nPDTN, pabyBody + 7 - 5, 2 );
CPL_MSBPTR16( &nPDTN );
SetMetadataItem( "GRIB_PDS_PDTN",
CPLString().Printf( "%d", nPDTN ) );
for( i = 9; i < (int) nSectSize; i++ )
{
char szByte[10];
if( i == 9 )
sprintf( szByte, "%d", pabyBody[i-5] );
else
sprintf( szByte, " %d", pabyBody[i-5] );
osOctet += szByte;
}
SetMetadataItem( "GRIB_PDS_TEMPLATE_NUMBERS", osOctet );
CPLFree( pabyBody );
}
VSIFSeekL( poGDS->fp, nOffset, SEEK_SET );
}
int SDTSRasterReader::GetBlock( int nXOffset, int nYOffset, void * pData )
{
DDFRecord *poRecord;
int nBytesPerValue;
int iTry;
CPLAssert( nXOffset == 0 );
/* -------------------------------------------------------------------- */
/* Analyse the datatype. */
/* -------------------------------------------------------------------- */
CPLAssert( EQUAL(szFMT,"BI16") || EQUAL(szFMT,"BFP32") );
if( EQUAL(szFMT,"BI16") )
nBytesPerValue = 2;
else
nBytesPerValue = 4;
for(iTry=0;iTry<2;iTry++)
{
/* -------------------------------------------------------------------- */
/* Read through till we find the desired record. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
while( (poRecord = oDDFModule.ReadRecord()) != NULL )
{
if( poRecord->GetIntSubfield( "CELL", 0, "ROWI", 0 )
== nYOffset + nYStart )
{
break;
}
}
if( CPLGetLastErrorType() == CE_Failure )
return FALSE;
/* -------------------------------------------------------------------- */
/* If we didn't get what we needed just start over. */
/* -------------------------------------------------------------------- */
if( poRecord == NULL )
{
if (iTry == 0)
oDDFModule.Rewind();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot read scanline %d. Raster access failed.\n",
nYOffset );
return FALSE;
}
}
else
{
break;
}
}
/* -------------------------------------------------------------------- */
/* Validate the records size. Does it represent exactly one */
/* scanline? */
/* -------------------------------------------------------------------- */
DDFField *poCVLS;
poCVLS = poRecord->FindField( "CVLS" );
if( poCVLS == NULL )
return FALSE;
if( poCVLS->GetRepeatCount() != nXSize )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cell record is %d long, but we expected %d, the number\n"
"of pixels in a scanline. Raster access failed.\n",
poCVLS->GetRepeatCount(), nXSize );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Does the CVLS field consist of exactly 1 B(16) field? */
/* -------------------------------------------------------------------- */
if( poCVLS->GetDataSize() < nBytesPerValue * nXSize
|| poCVLS->GetDataSize() > nBytesPerValue * nXSize + 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cell record is not of expected format. Raster access "
"failed.\n" );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Copy the data to the application buffer, and byte swap if */
/* required. */
/* -------------------------------------------------------------------- */
memcpy( pData, poCVLS->GetData(), nXSize * nBytesPerValue );
#ifdef CPL_LSB
if( nBytesPerValue == 2 )
{
for( int i = 0; i < nXSize; i++ )
{
((GInt16 *) pData)[i] = CPL_MSBWORD16(((GInt16 *) pData)[i]);
}
}
else
{
for( int i = 0; i < nXSize; i++ )
{
CPL_MSBPTR32( ((GByte *)pData) + i*4 );
}
}
#endif
return TRUE;
}
GDALDataset *SGIDataset::Create( const char * pszFilename,
int nXSize, int nYSize, int nBands,
GDALDataType eType, CPL_UNUSED char **papszOptions )
{
if( eType != GDT_Byte )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create SGI dataset with an illegal\n"
"data type (%s), only Byte supported by the format.\n",
GDALGetDataTypeName(eType) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the file for output. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( pszFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create file '%s': %s",
pszFilename, VSIStrerror( errno ) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Prepare and write 512 byte header. */
/* -------------------------------------------------------------------- */
GByte abyHeader[512];
GInt16 nShortValue;
GInt32 nIntValue;
memset( abyHeader, 0, 512 );
abyHeader[0] = 1;
abyHeader[1] = 218;
abyHeader[2] = 1; // RLE
abyHeader[3] = 1; // 8bit
if( nBands == 1 )
nShortValue = CPL_MSBWORD16(2);
else
nShortValue = CPL_MSBWORD16(3);
memcpy( abyHeader + 4, &nShortValue, 2 );
nShortValue = CPL_MSBWORD16(nXSize);
memcpy( abyHeader + 6, &nShortValue, 2 );
nShortValue = CPL_MSBWORD16(nYSize);
memcpy( abyHeader + 8, &nShortValue, 2 );
nShortValue = CPL_MSBWORD16(nBands);
memcpy( abyHeader + 10, &nShortValue, 2 );
nIntValue = CPL_MSBWORD32(0);
memcpy( abyHeader + 12, &nIntValue, 4 );
nIntValue = CPL_MSBWORD32(255);
memcpy( abyHeader + 16, &nIntValue, 4 );
VSIFWriteL( abyHeader, 1, 512, fp );
/* -------------------------------------------------------------------- */
/* Create our RLE compressed zero-ed dummy line. */
/* -------------------------------------------------------------------- */
GByte *pabyRLELine;
GInt32 nRLEBytes = 0;
int nPixelsRemaining = nXSize;
pabyRLELine = (GByte *) CPLMalloc((nXSize/127) * 2 + 4);
while( nPixelsRemaining > 0 )
{
pabyRLELine[nRLEBytes] = (GByte) MIN(127,nPixelsRemaining);
pabyRLELine[nRLEBytes+1] = 0;
nPixelsRemaining -= pabyRLELine[nRLEBytes];
nRLEBytes += 2;
}
/* -------------------------------------------------------------------- */
/* Prepare and write RLE offset/size tables with everything */
/* zeroed indicating dummy lines. */
/* -------------------------------------------------------------------- */
int i;
int nTableLen = nYSize * nBands;
GInt32 nDummyRLEOffset = 512 + 4 * nTableLen * 2;
CPL_MSBPTR32( &nRLEBytes );
CPL_MSBPTR32( &nDummyRLEOffset );
for( i = 0; i < nTableLen; i++ )
VSIFWriteL( &nDummyRLEOffset, 1, 4, fp );
for( i = 0; i < nTableLen; i++ )
VSIFWriteL( &nRLEBytes, 1, 4, fp );
/* -------------------------------------------------------------------- */
/* write the dummy RLE blank line. */
/* -------------------------------------------------------------------- */
CPL_MSBPTR32( &nRLEBytes );
if( (GInt32) VSIFWriteL( pabyRLELine, 1, nRLEBytes, fp ) != nRLEBytes )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failure writing SGI file '%s'.\n%s",
pszFilename,
VSIStrerror( errno ) );
return NULL;
}
VSIFCloseL( fp );
CPLFree( pabyRLELine );
return (GDALDataset*) GDALOpen( pszFilename, GA_Update );
}
GDALDataset *KRODataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) || poOpenInfo->fpL == nullptr )
return nullptr;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
KRODataset *poDS = new KRODataset();
poDS->eAccess = poOpenInfo->eAccess;
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
/* -------------------------------------------------------------------- */
/* Read the file header. */
/* -------------------------------------------------------------------- */
char achHeader[20] = { '\0' };
CPL_IGNORE_RET_VAL(VSIFReadL( achHeader, 1, 20, poDS->fpImage ));
int nXSize;
memcpy(&nXSize, achHeader + 4, 4);
CPL_MSBPTR32( &nXSize );
int nYSize = 0;
memcpy(&nYSize, achHeader + 8, 4);
CPL_MSBPTR32( &nYSize );
int nDepth = 0;
memcpy(&nDepth, achHeader + 12, 4);
CPL_MSBPTR32( &nDepth );
int nComp = 0;
memcpy(&nComp, achHeader + 16, 4);
CPL_MSBPTR32( &nComp );
if( !GDALCheckDatasetDimensions(nXSize, nYSize) ||
!GDALCheckBandCount(nComp, FALSE) )
{
delete poDS;
return nullptr;
}
poDS->nRasterXSize = nXSize;
poDS->nRasterYSize = nYSize;
GDALDataType eDT = GDT_Unknown;
if( nDepth == 8 )
{
eDT = GDT_Byte;
}
else if( nDepth == 16 )
{
eDT = GDT_UInt16;
}
else if( nDepth == 32 )
{
eDT = GDT_Float32;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unhandled depth : %d", nDepth );
delete poDS;
return nullptr;
}
const int nDataTypeSize = nDepth / 8;
if( nComp == 0 || nDataTypeSize == 0 ||
poDS->nRasterXSize > INT_MAX / (nComp * nDataTypeSize) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Too large width / number of bands" );
delete poDS;
return nullptr;
}
vsi_l_offset nExpectedSize = static_cast<vsi_l_offset>(poDS->nRasterXSize)
* poDS->nRasterYSize * nComp * nDataTypeSize + 20;
VSIFSeekL(poDS->fpImage, 0, SEEK_END);
if( VSIFTellL(poDS->fpImage) < nExpectedSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"File too short" );
delete poDS;
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Create bands. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
for( int iBand = 0; iBand < nComp; iBand++ )
{
RawRasterBand *poBand =
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
20 + nDataTypeSize * iBand,
nComp * nDataTypeSize,
poDS->nRasterXSize * nComp * nDataTypeSize,
eDT, !CPL_IS_LSB, RawRasterBand::OwnFP::NO );
if( nComp == 3 || nComp == 4 )
{
poBand->SetColorInterpretation( static_cast<GDALColorInterp>(GCI_RedBand + iBand) );
}
poDS->SetBand( iBand+1, poBand );
if( CPLGetLastErrorType() != CE_None )
{
delete poDS;
return nullptr;
}
}
if( nComp > 1 )
poDS->SetMetadataItem( "INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE" );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *KRODataset::Create( const char * pszFilename,
int nXSize,
int nYSize,
int nBands,
GDALDataType eType,
char ** /* papszOptions */ )
{
if( eType != GDT_Byte && eType != GDT_UInt16 && eType != GDT_Float32 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create KRO file with unsupported data type '%s'.",
GDALGetDataTypeName( eType ) );
return nullptr;
}
if( nXSize == 0 || nYSize == 0 || nBands == 0 )
{
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Try to create file. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( pszFilename, "wb" );
if( fp == nullptr )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.",
pszFilename );
return nullptr;
}
size_t nRet = VSIFWriteL("KRO\01", 4, 1, fp);
/* -------------------------------------------------------------------- */
/* Create a file level header. */
/* -------------------------------------------------------------------- */
int nTmp = nXSize;
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
nTmp = nYSize;
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
nTmp = GDALGetDataTypeSizeBits(eType);
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
nTmp = nBands;
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
/* -------------------------------------------------------------------- */
/* Zero out image data */
/* -------------------------------------------------------------------- */
CPL_IGNORE_RET_VAL(
VSIFSeekL( fp,
static_cast<vsi_l_offset>(nXSize) * nYSize *
GDALGetDataTypeSizeBytes(eType) * nBands - 1,
SEEK_CUR));
GByte byNul = 0;
nRet += VSIFWriteL(&byNul, 1, 1, fp);
if( VSIFCloseL(fp) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO, "I/O error" );
return nullptr;
}
if( nRet != 6 )
return nullptr;
return
reinterpret_cast<GDALDataset *>( GDALOpen( pszFilename, GA_Update ) );
}
GDALDataset *GTXDataset::Create( const char * pszFilename,
int nXSize, int nYSize, int nBands,
GDALDataType eType,
char ** papszOptions )
{
if( eType != GDT_Float32 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create gtx file with unsupported data type '%s'.",
GDALGetDataTypeName( eType ) );
return NULL;
}
if( !EQUAL(CPLGetExtension(pszFilename),"gtx") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create gtx file with extension other than gtx." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to create the file. */
/* -------------------------------------------------------------------- */
VSILFILE *fp;
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Write out the header with stub georeferencing. */
/* -------------------------------------------------------------------- */
unsigned char header[40];
double dfXOrigin=0, dfYOrigin=0, dfXSize=0.01, dfYSize=0.01;
GInt32 nXSize32 = nXSize, nYSize32 = nYSize;
memcpy( header + 0, &dfYOrigin, 8 );
CPL_MSBPTR64( header + 0 );
memcpy( header + 8, &dfXOrigin, 8 );
CPL_MSBPTR64( header + 8 );
memcpy( header + 16, &dfYSize, 8 );
CPL_MSBPTR64( header + 16 );
memcpy( header + 24, &dfXSize, 8 );
CPL_MSBPTR64( header + 24 );
memcpy( header + 32, &nYSize32, 4 );
CPL_MSBPTR32( header + 32 );
memcpy( header + 36, &nXSize32, 4 );
CPL_MSBPTR32( header + 36 );
VSIFWriteL( header, 40, 1, fp );
VSIFCloseL( fp );
return (GDALDataset *) GDALOpen( pszFilename, GA_Update );
}
RPFToc* RPFTOCReadFromBuffer(const char* pszFilename, VSILFILE* fp, const char* tocHeader)
{
int i, j;
unsigned int locationSectionPhysicalLocation;
int nSections;
unsigned int boundaryRectangleSectionSubHeaderPhysIndex = 0;
unsigned int boundaryRectangleTablePhysIndex = 0;
unsigned int frameFileIndexSectionSubHeaderPhysIndex = 0;
unsigned int frameFileIndexSubsectionPhysIndex = 0;
unsigned int boundaryRectangleTableOffset;
unsigned short boundaryRectangleCount;
unsigned int frameIndexTableOffset;
unsigned int nFrameFileIndexRecords;
unsigned short nFrameFilePathnameRecords;
unsigned short frameFileIndexRecordLength;
int newBoundaryId = 0;
RPFToc* toc;
tocHeader += 1; /* skip endian */
tocHeader += 2; /* skip header length */
tocHeader += 12; /* skip file name : this should be A.TOC (padded) */
tocHeader += 1; /* skip new */
tocHeader += 15; /* skip standard_num */
tocHeader += 8; /* skip standard_date */
tocHeader += 1; /* skip classification */
tocHeader += 2; /* skip country */
tocHeader += 2; /* skip release */
memcpy(&locationSectionPhysicalLocation, tocHeader, sizeof(unsigned int));
CPL_MSBPTR32(&locationSectionPhysicalLocation);
if( VSIFSeekL( fp, locationSectionPhysicalLocation, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to locationSectionPhysicalLocation at offset %d.",
locationSectionPhysicalLocation );
return NULL;
}
NITFLocation* pasLocations = NITFReadRPFLocationTable(fp, &nSections);
for (i = 0; i < nSections; i++)
{
if (pasLocations[i].nLocId == LID_BoundaryRectangleSectionSubheader)
{
boundaryRectangleSectionSubHeaderPhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_BoundaryRectangleTable)
{
boundaryRectangleTablePhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_FrameFileIndexSectionSubHeader)
{
frameFileIndexSectionSubHeaderPhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_FrameFileIndexSubsection)
{
frameFileIndexSubsectionPhysIndex = pasLocations[i].nLocOffset;
}
}
CPLFree(pasLocations);
if (boundaryRectangleSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleSectionSubheader." );
return NULL;
}
if (boundaryRectangleTablePhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleTable." );
return NULL;
}
if (frameFileIndexSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSectionSubHeader." );
return NULL;
}
if (frameFileIndexSubsectionPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSubsection." );
return NULL;
}
if( VSIFSeekL( fp, boundaryRectangleSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleSectionSubHeaderPhysIndex at offset %d.",
boundaryRectangleSectionSubHeaderPhysIndex );
return NULL;
}
VSIFReadL( &boundaryRectangleTableOffset, 1, sizeof(boundaryRectangleTableOffset), fp);
CPL_MSBPTR32( &boundaryRectangleTableOffset );
VSIFReadL( &boundaryRectangleCount, 1, sizeof(boundaryRectangleCount), fp);
CPL_MSBPTR16( &boundaryRectangleCount );
if( VSIFSeekL( fp, boundaryRectangleTablePhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleTablePhysIndex at offset %d.",
boundaryRectangleTablePhysIndex );
return NULL;
}
toc = (RPFToc*)CPLMalloc(sizeof(RPFToc));
toc->nEntries = boundaryRectangleCount;
toc->entries = (RPFTocEntry*)CPLMalloc(boundaryRectangleCount * sizeof(RPFTocEntry));
memset(toc->entries, 0, boundaryRectangleCount * sizeof(RPFTocEntry));
for(i=0;i<toc->nEntries;i++)
{
toc->entries[i].isOverviewOrLegend = 0;
VSIFReadL( toc->entries[i].type, 1, 5, fp);
toc->entries[i].type[5] = 0;
RPFTOCTrim(toc->entries[i].type);
VSIFReadL( toc->entries[i].compression, 1, 5, fp);
toc->entries[i].compression[5] = 0;
RPFTOCTrim(toc->entries[i].compression);
VSIFReadL( toc->entries[i].scale, 1, 12, fp);
toc->entries[i].scale[12] = 0;
RPFTOCTrim(toc->entries[i].scale);
if (toc->entries[i].scale[0] == '1' &&
toc->entries[i].scale[1] == ':')
{
memmove(toc->entries[i].scale,
toc->entries[i].scale+2,
strlen(toc->entries[i].scale+2)+1);
}
VSIFReadL( toc->entries[i].zone, 1, 1, fp);
toc->entries[i].zone[1] = 0;
RPFTOCTrim(toc->entries[i].zone);
VSIFReadL( toc->entries[i].producer, 1, 5, fp);
toc->entries[i].producer[5] = 0;
RPFTOCTrim(toc->entries[i].producer);
VSIFReadL( &toc->entries[i].nwLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].nwLat);
VSIFReadL( &toc->entries[i].nwLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].nwLong);
VSIFReadL( &toc->entries[i].swLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].swLat);
VSIFReadL( &toc->entries[i].swLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].swLong);
VSIFReadL( &toc->entries[i].neLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].neLat);
VSIFReadL( &toc->entries[i].neLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].neLong);
VSIFReadL( &toc->entries[i].seLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].seLat);
VSIFReadL( &toc->entries[i].seLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].seLong);
VSIFReadL( &toc->entries[i].vertResolution, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].vertResolution);
VSIFReadL( &toc->entries[i].horizResolution, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].horizResolution);
VSIFReadL( &toc->entries[i].vertInterval, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].vertInterval);
VSIFReadL( &toc->entries[i].horizInterval, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].horizInterval);
VSIFReadL( &toc->entries[i].nVertFrames, 1, sizeof(int), fp);
CPL_MSBPTR32( &toc->entries[i].nVertFrames );
VSIFReadL( &toc->entries[i].nHorizFrames, 1, sizeof(int), fp);
CPL_MSBPTR32( &toc->entries[i].nHorizFrames );
toc->entries[i].frameEntries = (RPFTocFrameEntry*)
VSIMalloc3(toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames, sizeof(RPFTocFrameEntry));
if (toc->entries[i].frameEntries == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"RPFTOCReadFromBuffer : Out of memory. Probably due to corrupted TOC file.");
RPFTOCFree(toc);
return NULL;
}
memset(toc->entries[i].frameEntries, 0,
toc->entries[i].nVertFrames * toc->entries[i].nHorizFrames * sizeof(RPFTocFrameEntry));
CPLDebug("RPFTOC", "[%d] type=%s, compression=%s, scale=%s, zone=%s, producer=%s, nVertFrames=%d, nHorizFrames=%d",
i, toc->entries[i].type, toc->entries[i].compression, toc->entries[i].scale,
toc->entries[i].zone, toc->entries[i].producer, toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames);
}
if( VSIFSeekL( fp, frameFileIndexSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSectionSubHeaderPhysIndex at offset %d.",
frameFileIndexSectionSubHeaderPhysIndex );
RPFTOCFree(toc);
return NULL;
}
/* Skip 1 byte security classification */
VSIFSeekL( fp, 1, SEEK_CUR );
VSIFReadL( &frameIndexTableOffset, 1, sizeof(frameIndexTableOffset), fp);
CPL_MSBPTR32( &frameIndexTableOffset );
VSIFReadL( &nFrameFileIndexRecords, 1, sizeof(nFrameFileIndexRecords), fp);
CPL_MSBPTR32( &nFrameFileIndexRecords );
VSIFReadL( &nFrameFilePathnameRecords, 1, sizeof(nFrameFilePathnameRecords), fp);
CPL_MSBPTR16( &nFrameFilePathnameRecords );
VSIFReadL( &frameFileIndexRecordLength, 1, sizeof(frameFileIndexRecordLength), fp);
CPL_MSBPTR16( &frameFileIndexRecordLength );
for (i=0;i<(int)nFrameFileIndexRecords;i++)
{
RPFTocEntry* entry;
RPFTocFrameEntry* frameEntry;
unsigned short boundaryId, frameRow, frameCol;
unsigned int offsetFrameFilePathName;
unsigned short pathLength;
if( VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSubsectionPhysIndex(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i);
RPFTOCFree(toc);
return NULL;
}
VSIFReadL( &boundaryId, 1, sizeof(boundaryId), fp);
CPL_MSBPTR16( &boundaryId );
if (i == 0 && boundaryId == 0)
newBoundaryId = 1;
if (newBoundaryId == 0)
boundaryId--;
if (boundaryId >= toc->nEntries)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad boundary id (%d) for frame file index %d.",
boundaryId, i);
RPFTOCFree(toc);
return NULL;
}
entry = &toc->entries[boundaryId];
entry->boundaryId = boundaryId;
VSIFReadL( &frameRow, 1, sizeof(frameRow), fp);
CPL_MSBPTR16( &frameRow );
VSIFReadL( &frameCol, 1, sizeof(frameCol), fp);
CPL_MSBPTR16( &frameCol );
if (newBoundaryId == 0)
{
frameRow--;
frameCol--;
}
else
{
/* Trick so that frames are numbered north to south */
frameRow = (unsigned short)((entry->nVertFrames-1) - frameRow);
}
if (frameRow >= entry->nVertFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad row num (%d) for frame file index %d.",
frameRow, i);
RPFTOCFree(toc);
return NULL;
}
if (frameCol >= entry->nHorizFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad col num (%d) for frame file index %d.",
frameCol, i);
RPFTOCFree(toc);
return NULL;
}
frameEntry = &entry->frameEntries[frameRow * entry->nHorizFrames + frameCol ];
frameEntry->frameRow = frameRow;
frameEntry->frameCol = frameCol;
if (frameEntry->exists)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Frame entry(%d,%d) for frame file index %d was already found.",
frameRow, frameCol, i);
CPLFree(frameEntry->directory);
frameEntry->directory = NULL;
CPLFree(frameEntry->fullFilePath);
frameEntry->fullFilePath = NULL;
frameEntry->exists = 0;
}
VSIFReadL( &offsetFrameFilePathName, 1, sizeof(offsetFrameFilePathName), fp);
CPL_MSBPTR32( &offsetFrameFilePathName );
VSIFReadL( frameEntry->filename, 1, 12, fp);
frameEntry->filename[12] = '\0';
/* Check if the filename is an overview or legend */
for (j=0;j<12;j++)
{
if (strcmp(&(frameEntry->filename[j]),".OVR") == 0 ||
strcmp(&(frameEntry->filename[j]),".ovr") == 0 ||
strcmp(&(frameEntry->filename[j]),".LGD") == 0 ||
strcmp(&(frameEntry->filename[j]),".lgd") == 0)
{
entry->isOverviewOrLegend = TRUE;
break;
}
}
/* Extract series code */
if (entry->seriesAbbreviation == NULL)
{
const NITFSeries* series = NITFGetSeriesInfo(frameEntry->filename);
if (series)
{
entry->seriesAbbreviation = series->abbreviation;
entry->seriesName = series->name;
}
}
/* Get file geo reference */
VSIFReadL( frameEntry->georef, 1, 6, fp);
frameEntry->georef[6] = '\0';
/* Go to start of pathname record */
/* New path_off offset from start of frame file index section of TOC?? */
/* Add pathoffset wrt frame file index table subsection (loc[3]) */
if( VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName);
RPFTOCFree(toc);
return NULL;
}
VSIFReadL( &pathLength, 1, sizeof(pathLength), fp);
CPL_MSBPTR16( &pathLength );
/* if nFrameFileIndexRecords == 65535 and pathLength == 65535 for each record,
this leads to 4 GB allocation... Protect against this case */
if (pathLength > 256)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Path length is big : %d. Probably corrupted TOC file.", (int)pathLength);
RPFTOCFree(toc);
return NULL;
}
frameEntry->directory = (char *)CPLMalloc(pathLength+1);
VSIFReadL( frameEntry->directory, 1, pathLength, fp);
frameEntry->directory[pathLength] = 0;
if (pathLength > 0 && frameEntry->directory[pathLength-1] == '/')
frameEntry->directory[pathLength-1] = 0;
if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == '/')
memmove(frameEntry->directory, frameEntry->directory+2, strlen(frameEntry->directory+2)+1);
{
char* baseDir = CPLStrdup(CPLGetDirname(pszFilename));
VSIStatBufL sStatBuf;
char* subdir;
if (CPLIsFilenameRelative(frameEntry->directory) == FALSE)
subdir = CPLStrdup(frameEntry->directory);
else if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == 0)
subdir = CPLStrdup(baseDir);
else
subdir = CPLStrdup(CPLFormFilename(baseDir, frameEntry->directory, NULL));
#if !defined(_WIN32) && !defined(_WIN32_CE)
if( VSIStatL( subdir, &sStatBuf ) != 0 && subdir[strlen(baseDir)] != 0)
{
char* c = subdir + strlen(baseDir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
}
#endif
frameEntry->fullFilePath = CPLStrdup(CPLFormFilename(
subdir,
frameEntry->filename, NULL));
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
{
#if !defined(_WIN32) && !defined(_WIN32_CE)
char* c = frameEntry->fullFilePath + strlen(subdir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
#endif
{
frameEntry->fileExists = 0;
CPLError( CE_Warning, CPLE_AppDefined,
"File %s does not exist.", frameEntry->fullFilePath );
}
#if !defined(_WIN32) && !defined(_WIN32_CE)
else
{
frameEntry->fileExists = 1;
}
#endif
}
else
{
frameEntry->fileExists = 1;
}
CPLFree(subdir);
CPLFree(baseDir);
}
CPLDebug("RPFTOC", "Entry %d : %s,%s (%d, %d)", boundaryId, frameEntry->directory, frameEntry->filename, frameRow, frameCol);
frameEntry->exists = 1;
}
return toc;
}
int GDALJP2Box::ReadBox()
{
GUInt32 nLBox;
GUInt32 nTBox;
nBoxOffset = VSIFTellL( fpVSIL );
if( VSIFReadL( &nLBox, 4, 1, fpVSIL ) != 1
|| VSIFReadL( &nTBox, 4, 1, fpVSIL ) != 1 )
{
return FALSE;
}
memcpy( szBoxType, &nTBox, 4 );
szBoxType[4] = '\0';
nLBox = CPL_MSBWORD32( nLBox );
if( nLBox != 1 )
{
nBoxLength = nLBox;
nDataOffset = nBoxOffset + 8;
}
else
{
GByte abyXLBox[8];
if( VSIFReadL( abyXLBox, 8, 1, fpVSIL ) != 1 )
return FALSE;
if( sizeof(nBoxLength) == 8 )
{
CPL_MSBPTR64( abyXLBox );
memcpy( &nBoxLength, abyXLBox, 8 );
}
else
{
CPL_MSBPTR32( abyXLBox+4 );
memcpy( &nBoxLength, abyXLBox+4, 4 );
}
nDataOffset = nBoxOffset + 16;
}
if( nBoxLength == 0 )
{
VSIFSeekL( fpVSIL, 0, SEEK_END );
nBoxLength = VSIFTellL( fpVSIL ) - nBoxOffset;
}
if( EQUAL(szBoxType,"uuid") )
{
VSIFReadL( abyUUID, 16, 1, fpVSIL );
nDataOffset += 16;
}
if( GetDataLength() < 0 )
{
CPLDebug("GDALJP2", "Invalid length for box %s", szBoxType);
return FALSE;
}
return TRUE;
}
GDALDataset *GTXDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GTXDataset *poDS;
poDS = new GTXDataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
VSIFReadL( poDS->adfGeoTransform+3, 8, 1, poDS->fpImage );
VSIFReadL( poDS->adfGeoTransform+0, 8, 1, poDS->fpImage );
VSIFReadL( poDS->adfGeoTransform+5, 8, 1, poDS->fpImage );
VSIFReadL( poDS->adfGeoTransform+1, 8, 1, poDS->fpImage );
VSIFReadL( &(poDS->nRasterYSize), 4, 1, poDS->fpImage );
VSIFReadL( &(poDS->nRasterXSize), 4, 1, poDS->fpImage );
CPL_MSBPTR32( &(poDS->nRasterYSize) );
CPL_MSBPTR32( &(poDS->nRasterXSize) );
CPL_MSBPTR64( poDS->adfGeoTransform + 0 );
CPL_MSBPTR64( poDS->adfGeoTransform + 1 );
CPL_MSBPTR64( poDS->adfGeoTransform + 3 );
CPL_MSBPTR64( poDS->adfGeoTransform + 5 );
poDS->adfGeoTransform[3] +=
poDS->adfGeoTransform[5] * (poDS->nRasterYSize-1);
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[3] += poDS->adfGeoTransform[5] * 0.5;
poDS->adfGeoTransform[5] *= -1;
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* -------------------------------------------------------------------- */
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage,
(poDS->nRasterYSize-1)*poDS->nRasterXSize*4 + 40,
4, poDS->nRasterXSize * -4,
GDT_Float32,
!CPL_IS_LSB, TRUE, FALSE ) );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *GTXDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GTXDataset *poDS;
poDS = new GTXDataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
VSIFReadL( poDS->adfGeoTransform+3, 8, 1, poDS->fpImage );
VSIFReadL( poDS->adfGeoTransform+0, 8, 1, poDS->fpImage );
VSIFReadL( poDS->adfGeoTransform+5, 8, 1, poDS->fpImage );
VSIFReadL( poDS->adfGeoTransform+1, 8, 1, poDS->fpImage );
VSIFReadL( &(poDS->nRasterYSize), 4, 1, poDS->fpImage );
VSIFReadL( &(poDS->nRasterXSize), 4, 1, poDS->fpImage );
CPL_MSBPTR32( &(poDS->nRasterYSize) );
CPL_MSBPTR32( &(poDS->nRasterXSize) );
CPL_MSBPTR64( poDS->adfGeoTransform + 0 );
CPL_MSBPTR64( poDS->adfGeoTransform + 1 );
CPL_MSBPTR64( poDS->adfGeoTransform + 3 );
CPL_MSBPTR64( poDS->adfGeoTransform + 5 );
poDS->adfGeoTransform[3] +=
poDS->adfGeoTransform[5] * (poDS->nRasterYSize-1);
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[3] += poDS->adfGeoTransform[5] * 0.5;
poDS->adfGeoTransform[5] *= -1;
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Guess the data type. Since October 1, 2009, it should be */
/* Float32. Before it was double. */
/* -------------------------------------------------------------------- */
GDALDataType eDT = GDT_Float32;
VSIFSeekL(poDS->fpImage, 0, SEEK_END);
vsi_l_offset nSize = VSIFTellL(poDS->fpImage);
if( nSize == 40 + 8 * (vsi_l_offset)poDS->nRasterXSize * poDS->nRasterYSize )
eDT = GDT_Float64;
int nDTSize = GDALGetDataTypeSize(eDT) / 8;
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* -------------------------------------------------------------------- */
RawRasterBand *poBand = new RawRasterBand( poDS, 1, poDS->fpImage,
(poDS->nRasterYSize-1)*poDS->nRasterXSize*nDTSize + 40,
nDTSize, poDS->nRasterXSize * -nDTSize,
eDT,
!CPL_IS_LSB, TRUE, FALSE );
if (eDT == GDT_Float64)
poBand->SetNoDataValue( -88.8888 );
else
/* GDT_Float32 */
poBand->SetNoDataValue( (double)-88.8888f );
poDS->SetBand( 1, poBand );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *KRODataset::Create( const char * pszFilename,
int nXSize,
int nYSize,
int nBands,
GDALDataType eType,
CPL_UNUSED char ** papszOptions )
{
if( eType != GDT_Byte && eType != GDT_UInt16 && eType != GDT_Float32 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Attempt to create KRO file with unsupported data type '%s'.",
GDALGetDataTypeName( eType ) );
return NULL;
}
VSILFILE *fp;
/* -------------------------------------------------------------------- */
/* Try to create file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.\n",
pszFilename );
return NULL;
}
int nRet = 0;
nRet += VSIFWriteL("KRO\01", 4, 1, fp);
int nTmp;
/* -------------------------------------------------------------------- */
/* Create a file level header. */
/* -------------------------------------------------------------------- */
nTmp = nXSize;
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
nTmp = nYSize;
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
nTmp = GDALGetDataTypeSize(eType);
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
nTmp = nBands;
CPL_MSBPTR32(&nTmp);
nRet += VSIFWriteL(&nTmp, 4, 1, fp);
/* -------------------------------------------------------------------- */
/* Zero out image data */
/* -------------------------------------------------------------------- */
VSIFSeekL(fp, (vsi_l_offset)nXSize * nYSize * (GDALGetDataTypeSize(eType) / 8) * nBands - 1,
SEEK_CUR);
GByte byNul = 0;
nRet += VSIFWriteL(&byNul, 1, 1, fp);
VSIFCloseL(fp);
if( nRet != 6 )
return NULL;
return (GDALDataset *) GDALOpen( pszFilename, GA_Update );
}
GDALDataset *KRODataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
KRODataset *poDS;
poDS = new KRODataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the file header. */
/* -------------------------------------------------------------------- */
char achHeader[20];
int nXSize, nYSize, nDepth, nComp;
VSIFReadL( achHeader, 1, 20, poDS->fpImage );
memcpy(&nXSize, achHeader + 4, 4);
CPL_MSBPTR32( &nXSize );
memcpy(&nYSize, achHeader + 8, 4);
CPL_MSBPTR32( &nYSize );
memcpy(&nDepth, achHeader + 12, 4);
CPL_MSBPTR32( &nDepth );
memcpy(&nComp, achHeader + 16, 4);
CPL_MSBPTR32( &nComp );
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nComp, FALSE))
{
delete poDS;
return NULL;
}
poDS->nRasterXSize = nXSize;
poDS->nRasterYSize = nYSize;
GDALDataType eDT;
if( nDepth == 8 )
eDT = GDT_Byte;
else if( nDepth == 16 )
eDT = GDT_UInt16;
else if( nDepth == 32 )
eDT = GDT_Float32;
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unhandled depth : %d", nDepth);
delete poDS;
return NULL;
}
int nDataTypeSize = nDepth / 8;
/* -------------------------------------------------------------------- */
/* Create bands. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nComp; iBand++ )
{
RawRasterBand *poBand =
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
20 + nDataTypeSize * iBand,
nComp * nDataTypeSize,
poDS->nRasterXSize * nComp * nDataTypeSize,
eDT, !CPL_IS_LSB, TRUE, FALSE );
if( nComp == 3 || nComp == 4 )
{
poBand->SetColorInterpretation( (GDALColorInterp) (GCI_RedBand + iBand) );
}
poDS->SetBand( iBand+1, poBand );
}
if( nComp > 1 )
poDS->SetMetadataItem( "INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE" );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *ELASDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify(poOpenInfo) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
ELASDataset *poDS;
const char *pszAccess;
if( poOpenInfo->eAccess == GA_Update )
pszAccess = "r+b";
else
pszAccess = "rb";
poDS = new ELASDataset();
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, pszAccess );
if( poDS->fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to open `%s' with acces `%s' failed.\n",
poOpenInfo->pszFilename, pszAccess );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Read the header information. */
/* -------------------------------------------------------------------- */
poDS->bHeaderModified = FALSE;
if( VSIFReadL( &(poDS->sHeader), 1024, 1, poDS->fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Attempt to read 1024 byte header filed on file %s\n",
poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Extract information of interest from the header. */
/* -------------------------------------------------------------------- */
int nStart, nEnd, nELASDataType, nBytesPerSample;
poDS->nLineOffset = CPL_MSBWORD32( poDS->sHeader.NBPR );
nStart = CPL_MSBWORD32( poDS->sHeader.IL );
nEnd = CPL_MSBWORD32( poDS->sHeader.LL );
poDS->nRasterYSize = nEnd - nStart + 1;
nStart = CPL_MSBWORD32( poDS->sHeader.IE );
nEnd = CPL_MSBWORD32( poDS->sHeader.LE );
poDS->nRasterXSize = nEnd - nStart + 1;
poDS->nBands = CPL_MSBWORD32( poDS->sHeader.NC );
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(poDS->nBands, FALSE))
{
delete poDS;
return NULL;
}
nELASDataType = (poDS->sHeader.IH19[2] & 0x7e) >> 2;
nBytesPerSample = poDS->sHeader.IH19[3];
if( nELASDataType == 0 && nBytesPerSample == 1 )
poDS->eRasterDataType = GDT_Byte;
else if( nELASDataType == 1 && nBytesPerSample == 1 )
poDS->eRasterDataType = GDT_Byte;
else if( nELASDataType == 16 && nBytesPerSample == 4 )
poDS->eRasterDataType = GDT_Float32;
else if( nELASDataType == 17 && nBytesPerSample == 8 )
poDS->eRasterDataType = GDT_Float64;
else
{
delete poDS;
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised image data type %d, with BytesPerSample=%d.\n",
nELASDataType, nBytesPerSample );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Band offsets are always multiples of 256 within a multi-band */
/* scanline of data. */
/* -------------------------------------------------------------------- */
poDS->nBandOffset =
(poDS->nRasterXSize * GDALGetDataTypeSize(poDS->eRasterDataType)/8);
if( poDS->nBandOffset % 256 != 0 )
{
poDS->nBandOffset =
poDS->nBandOffset - (poDS->nBandOffset % 256) + 256;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int iBand;
for( iBand = 0; iBand < poDS->nBands; iBand++ )
{
poDS->SetBand( iBand+1, new ELASRasterBand( poDS, iBand+1 ) );
}
/* -------------------------------------------------------------------- */
/* Extract the projection coordinates, if present. */
/* -------------------------------------------------------------------- */
if( poDS->sHeader.XOffset != 0 )
{
CPL_MSBPTR32(&(poDS->sHeader.XPixSize));
CPL_MSBPTR32(&(poDS->sHeader.YPixSize));
poDS->adfGeoTransform[0] =
(GInt32) CPL_MSBWORD32(poDS->sHeader.XOffset);
poDS->adfGeoTransform[1] = poDS->sHeader.XPixSize;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] =
(GInt32) CPL_MSBWORD32(poDS->sHeader.YOffset);
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -1.0 * ABS(poDS->sHeader.YPixSize);
CPL_MSBPTR32(&(poDS->sHeader.XPixSize));
CPL_MSBPTR32(&(poDS->sHeader.YPixSize));
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[5] * 0.5;
}
else
{
poDS->adfGeoTransform[0] = 0.0;
poDS->adfGeoTransform[1] = 1.0;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = 1.0;
}
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for external overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->papszSiblingFiles );
return( poDS );
}
void GDALJP2Box::AppendUInt32( GUInt32 nVal )
{
CPL_MSBPTR32(&nVal);
AppendWritableData(4, &nVal);
}
