本文整理汇总了C++中Identify函数的典型用法代码示例。如果您正苦于以下问题：C++ Identify函数的具体用法？C++ Identify怎么用？C++ Identify使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Identify函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: if
GDALDataset *SNODASDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify(poOpenInfo) )
return NULL;
VSILFILE *fp;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
{
return NULL;
}
const char * pszLine;
int nRows = -1, nCols = -1;
CPLString osDataFilename;
int bIsInteger = FALSE, bIs2Bytes = FALSE;
double dfNoData = 0;
int bHasNoData = FALSE;
double dfMin = 0;
int bHasMin = FALSE;
double dfMax = 0;
int bHasMax = FALSE;
double dfMinX = 0.0, dfMinY = 0.0, dfMaxX = 0.0, dfMaxY = 0.0;
int bHasMinX = FALSE, bHasMinY = FALSE, bHasMaxX = FALSE, bHasMaxY = FALSE;
int bNotProjected = FALSE, bIsWGS84 = FALSE;
CPLString osDescription, osDataUnits;
int nStartYear = -1, nStartMonth = -1, nStartDay = -1,
nStartHour = -1, nStartMinute = -1, nStartSecond = -1;
int nStopYear = -1, nStopMonth = -1, nStopDay = -1,
nStopHour = -1, nStopMinute = -1, nStopSecond = -1;
while( (pszLine = CPLReadLine2L( fp, 256, NULL )) != NULL )
{
char** papszTokens = CSLTokenizeStringComplex( pszLine, ":", TRUE, FALSE );
if( CSLCount( papszTokens ) != 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( papszTokens[1][0] == ' ' )
memmove(papszTokens[1], papszTokens[1] + 1, strlen(papszTokens[1] + 1) + 1);
if( EQUAL(papszTokens[0],"Data file pathname") )
{
osDataFilename = papszTokens[1];
}
else if( EQUAL(papszTokens[0],"Description") )
{
osDescription = papszTokens[1];
}
else if( EQUAL(papszTokens[0],"Data units") )
{
osDataUnits= papszTokens[1];
}
else if( EQUAL(papszTokens[0],"Start year") )
nStartYear = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start month") )
nStartMonth = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start day") )
nStartDay = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start hour") )
nStartHour = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start minute") )
nStartMinute = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Start second") )
nStartSecond = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop year") )
nStopYear = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop month") )
nStopMonth = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop day") )
nStopDay = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop hour") )
nStopHour = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop minute") )
nStopMinute = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Stop second") )
nStopSecond = atoi(papszTokens[1]);
else if( EQUAL(papszTokens[0],"Number of columns") )
{
nCols = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Number of rows") )
{
nRows = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"Data type"))
{
bIsInteger = EQUAL(papszTokens[1],"integer");
}
else if( EQUAL(papszTokens[0],"Data bytes per pixel"))
{
bIs2Bytes = EQUAL(papszTokens[1],"2");
}
//.........这里部分代码省略.........
示例2: while
void TiXmlElement::StreamIn (TIXML_ISTREAM * in, TIXML_STRING * tag)
{
// We're called with some amount of pre-parsing. That is, some of "this"
// element is in "tag". Go ahead and stream to the closing ">"
while( in->good() )
{
int c = in->get();
(*tag) += (TCHAR) c ;
if ( c == '>' )
break;
}
if ( tag->length() < 3 ) return;
// Okay...if we are a "/>" tag, then we're done. We've read a complete tag.
// If not, identify and stream.
if ( tag->at( tag->length() - 1 ) == '>'
&& tag->at( tag->length() - 2 ) == '/' )
{
// All good!
return;
}
else if ( tag->at( tag->length() - 1 ) == '>' )
{
// There is more. Could be:
// text
// closing tag
// another node.
for ( ;; )
{
StreamWhiteSpace( in, tag );
// Do we have text?
if ( in->good() && in->peek() != '<' )
{
// Yep, text.
TiXmlText text( TEXT("") );
text.StreamIn( in, tag );
// What follows text is a closing tag or another node.
// Go around again and figure it out.
continue;
}
// We now have either a closing tag...or another node.
// We should be at a "<", regardless.
if ( !in->good() ) return;
assert( in->peek() == '<' );
int tagIndex = tag->length();
bool closingTag = false;
bool firstCharFound = false;
for( ;; )
{
if ( !in->good() )
return;
int c = in->peek();
if ( c == '>' )
break;
*tag += (TCHAR)c;
in->get();
if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )
{
firstCharFound = true;
if ( c == '/' )
closingTag = true;
}
}
// If it was a closing tag, then read in the closing '>' to clean up the input stream.
// If it was not, the streaming will be done by the tag.
if ( closingTag )
{
int c = in->get();
assert( c == '>' );
*tag += (TCHAR)c;
// We are done, once we've found our closing tag.
return;
}
else
{
// If not a closing tag, id it, and stream.
const TCHAR* tagloc = tag->c_str() + tagIndex;
TiXmlNode* node = Identify( tagloc );
if ( !node )
return;
node->StreamIn( in, tag );
delete node;
node = 0;
// No return: go around from the beginning: text, closing tag, or node.
}
}
//.........这里部分代码省略.........
示例3: strstr
GDALDataset *CALSDataset::Open( GDALOpenInfo * poOpenInfo )
{
if (!Identify(poOpenInfo) || poOpenInfo->fpL == NULL )
return NULL;
const char* pszRPelCnt = strstr((const char*) poOpenInfo->pabyHeader, "rpelcnt:");
int nXSize, nYSize;
if( sscanf(pszRPelCnt+strlen("rpelcnt:"),"%d,%d",&nXSize,&nYSize) != 2 ||
nXSize <= 0 || nYSize <= 0 )
return NULL;
const char* pszOrient = strstr((const char*) poOpenInfo->pabyHeader, "rorient:");
int nAngle1, nAngle2;
if( sscanf(pszOrient+strlen("rorient:"),"%d,%d",&nAngle1,&nAngle2) != 2 )
return NULL;
const char* pszDensity = strstr((const char*) poOpenInfo->pabyHeader, "rdensty:");
int nDensity = 0;
if( pszDensity )
sscanf(pszDensity+strlen("rdensty:"), "%d", &nDensity);
VSIFSeekL(poOpenInfo->fpL, 0, SEEK_END);
int nFAX4BlobSize = (int)VSIFTellL(poOpenInfo->fpL) - 2048;
if( nFAX4BlobSize < 0 )
return NULL;
CALSDataset* poDS = new CALSDataset();
poDS->nRasterXSize = nXSize;
poDS->nRasterYSize = nYSize;
// Create a TIFF header for a single-strip CCITTFAX4 file
poDS->osTIFFHeaderFilename = CPLSPrintf("/vsimem/cals/header_%p.tiff", poDS);
VSILFILE* fp = VSIFOpenL(poDS->osTIFFHeaderFilename, "wb");
const int nTagCount = 10;
const int nHeaderSize = 4 + 4 + 2 + nTagCount * 12 + 4;
WriteLEInt16(fp, TIFF_LITTLEENDIAN); /* TIFF little-endian signature */
WriteLEInt16(fp, 42); // TIFF classic
WriteLEInt32(fp, 8); /* Offset of IFD0 */
WriteLEInt16(fp, nTagCount); /* Number of entries */
WriteTIFFTAG(fp, TIFFTAG_IMAGEWIDTH, TIFF_LONG, nXSize);
WriteTIFFTAG(fp, TIFFTAG_IMAGELENGTH, TIFF_LONG, nYSize);
WriteTIFFTAG(fp, TIFFTAG_BITSPERSAMPLE, TIFF_SHORT, 1);
WriteTIFFTAG(fp, TIFFTAG_COMPRESSION, TIFF_SHORT, COMPRESSION_CCITTFAX4);
WriteTIFFTAG(fp, TIFFTAG_PHOTOMETRIC, TIFF_SHORT, PHOTOMETRIC_MINISWHITE);
WriteTIFFTAG(fp, TIFFTAG_STRIPOFFSETS, TIFF_LONG, nHeaderSize);
WriteTIFFTAG(fp, TIFFTAG_SAMPLESPERPIXEL, TIFF_SHORT, 1);
WriteTIFFTAG(fp, TIFFTAG_ROWSPERSTRIP, TIFF_LONG, nYSize);
WriteTIFFTAG(fp, TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG, nFAX4BlobSize);
WriteTIFFTAG(fp, TIFFTAG_PLANARCONFIG, TIFF_SHORT, PLANARCONFIG_CONTIG);
WriteLEInt32(fp, 0); /* Offset of next IFD */
VSIFCloseL(fp);
// Create a /vsisparse/ description file assembling the TIFF header
// with the FAX4 codestream that starts at offset 2048 of the CALS file
poDS->osSparseFilename = CPLSPrintf("/vsimem/cals/sparse_%p.xml", poDS);
fp = VSIFOpenL(poDS->osSparseFilename, "wb");
CPLAssert(fp);
VSIFPrintfL(fp, "<VSISparseFile>"
"<Length>%d</Length>"
"<SubfileRegion>"
"<Filename relative='0'>%s</Filename>"
"<DestinationOffset>0</DestinationOffset>"
"<SourceOffset>0</SourceOffset>"
"<RegionLength>%d</RegionLength>"
"</SubfileRegion>"
"<SubfileRegion>"
"<Filename relative='0'>%s</Filename>"
"<DestinationOffset>%d</DestinationOffset>"
"<SourceOffset>%d</SourceOffset>"
"<RegionLength>%d</RegionLength>"
"</SubfileRegion>"
"</VSISparseFile>",
nHeaderSize + nFAX4BlobSize,
poDS->osTIFFHeaderFilename.c_str(),
nHeaderSize,
poOpenInfo->pszFilename,
nHeaderSize,
2048,
nFAX4BlobSize);
VSIFCloseL(fp);
poDS->poUnderlyingDS = (GDALDataset*) GDALOpenEx(
CPLSPrintf("/vsisparse/%s", poDS->osSparseFilename.c_str()),
GDAL_OF_RASTER | GDAL_OF_INTERNAL, NULL, NULL, NULL);
if( poDS->poUnderlyingDS == NULL )
{
delete poDS;
return NULL;
}
if( nAngle1 != 0 || nAngle2 != 270 )
{
poDS->SetMetadataItem("PIXEL_PATH", CPLSPrintf("%d", nAngle1));
poDS->SetMetadataItem("LINE_PROGRESSION", CPLSPrintf("%d", nAngle2));
//.........这里部分代码省略.........
示例4: MAIN_START
MAIN_START(argc, argv)
{
char *pszDriver = nullptr;
GDALDriverH hDriver = nullptr;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
if( argc < 3 )
Usage();
if( EQUAL(argv[1], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
/* -------------------------------------------------------------------- */
/* Do we have a driver specifier? */
/* -------------------------------------------------------------------- */
char **papszRemainingArgv = argv + 2;
int nRemainingArgc = argc - 2;
if( EQUAL(papszRemainingArgv[0],"-f") && nRemainingArgc > 1 )
{
pszDriver = papszRemainingArgv[1];
papszRemainingArgv += 2;
nRemainingArgc -= 2;
}
if( pszDriver != nullptr )
{
hDriver = GDALGetDriverByName( pszDriver );
if( hDriver == nullptr )
{
fprintf( stderr, "Unable to find driver named '%s'.\n",
pszDriver );
exit( 1 );
}
}
/* -------------------------------------------------------------------- */
/* Split out based on operation. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(argv[1],"ident" /* identify" */ ) )
Identify( nRemainingArgc, papszRemainingArgv );
else if( EQUAL(argv[1],"copy") )
Copy( hDriver, nRemainingArgc, papszRemainingArgv, "copy" );
else if( EQUAL(argv[1],"rename") )
Copy( hDriver, nRemainingArgc, papszRemainingArgv, "rename" );
else if( EQUAL(argv[1],"delete") )
Delete( hDriver, nRemainingArgc, papszRemainingArgv );
else
Usage();
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
CSLDestroy( argv );
GDALDestroyDriverManager();
exit( 0 );
}示例5: CPLError
GDALDataset *BAGDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Confirm that this appears to be a BAG file. */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The BAG driver does not support update access." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the file as an HDF5 file. */
/* -------------------------------------------------------------------- */
hid_t hHDF5 = H5Fopen( poOpenInfo->pszFilename,
H5F_ACC_RDONLY, H5P_DEFAULT );
if( hHDF5 < 0 )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm it is a BAG dataset by checking for the */
/* BAG_Root/Bag Version attribute. */
/* -------------------------------------------------------------------- */
hid_t hBagRoot = H5Gopen( hHDF5, "/BAG_root" );
hid_t hVersion = -1;
if( hBagRoot >= 0 )
hVersion = H5Aopen_name( hBagRoot, "Bag Version" );
if( hVersion < 0 )
{
if( hBagRoot >= 0 )
H5Gclose( hBagRoot );
H5Fclose( hHDF5 );
return NULL;
}
H5Aclose( hVersion );
/* -------------------------------------------------------------------- */
/* Create a corresponding dataset. */
/* -------------------------------------------------------------------- */
BAGDataset *poDS = new BAGDataset();
poDS->hHDF5 = hHDF5;
/* -------------------------------------------------------------------- */
/* Extract version as metadata. */
/* -------------------------------------------------------------------- */
CPLString osVersion;
if( GH5_FetchAttribute( hBagRoot, "Bag Version", osVersion ) )
poDS->SetMetadataItem( "BagVersion", osVersion );
H5Gclose( hBagRoot );
/* -------------------------------------------------------------------- */
/* Fetch the elevation dataset and attach as a band. */
/* -------------------------------------------------------------------- */
int nNextBand = 1;
hid_t hElevation = H5Dopen( hHDF5, "/BAG_root/elevation" );
if( hElevation < 0 )
{
delete poDS;
return NULL;
}
BAGRasterBand *poElevBand = new BAGRasterBand( poDS, nNextBand );
if( !poElevBand->Initialize( hElevation, "elevation" ) )
{
delete poElevBand;
delete poDS;
return NULL;
}
poDS->nRasterXSize = poElevBand->nRasterXSize;
poDS->nRasterYSize = poElevBand->nRasterYSize;
poDS->SetBand( nNextBand++, poElevBand );
/* -------------------------------------------------------------------- */
/* Try to do the same for the uncertainty band. */
/* -------------------------------------------------------------------- */
hid_t hUncertainty = H5Dopen( hHDF5, "/BAG_root/uncertainty" );
BAGRasterBand *poUBand = new BAGRasterBand( poDS, nNextBand );
if( hUncertainty >= 0 && poUBand->Initialize( hUncertainty, "uncertainty") )
{
poDS->SetBand( nNextBand++, poUBand );
}
else
//.........这里部分代码省略.........
示例6: GSBGDataset
GDALDataset *GSBGDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify(poOpenInfo) )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GSBGDataset *poDS = new GSBGDataset();
/* -------------------------------------------------------------------- */
/* Open file with large file API. */
/* -------------------------------------------------------------------- */
poDS->eAccess = poOpenInfo->eAccess;
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "r+b" );
if( poDS->fp == NULL )
{
delete poDS;
CPLError( CE_Failure, CPLE_OpenFailed,
"VSIFOpenL(%s) failed unexpectedly.",
poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
if( VSIFSeekL( poDS->fp, 4, SEEK_SET ) != 0 )
{
delete poDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to seek to start of grid file header.\n" );
return NULL;
}
/* Parse number of X axis grid rows */
GInt16 nTemp;
if( VSIFReadL( (void *)&nTemp, 2, 1, poDS->fp ) != 1 )
{
delete poDS;
CPLError( CE_Failure, CPLE_FileIO, "Unable to read raster X size.\n" );
return NULL;
}
poDS->nRasterXSize = CPL_LSBWORD16( nTemp );
if( VSIFReadL( (void *)&nTemp, 2, 1, poDS->fp ) != 1 )
{
delete poDS;
CPLError( CE_Failure, CPLE_FileIO, "Unable to read raster Y size.\n" );
return NULL;
}
poDS->nRasterYSize = CPL_LSBWORD16( nTemp );
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
GSBGRasterBand *poBand = new GSBGRasterBand( poDS, 1 );
double dfTemp;
if( VSIFReadL( (void *)&dfTemp, 8, 1, poDS->fp ) != 1 )
{
delete poDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to read minimum X value.\n" );
return NULL;
}
CPL_LSBPTR64( &dfTemp );
poBand->dfMinX = dfTemp;
if( VSIFReadL( (void *)&dfTemp, 8, 1, poDS->fp ) != 1 )
{
delete poDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to read maximum X value.\n" );
return NULL;
}
CPL_LSBPTR64( &dfTemp );
poBand->dfMaxX = dfTemp;
if( VSIFReadL( (void *)&dfTemp, 8, 1, poDS->fp ) != 1 )
{
delete poDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to read minimum Y value.\n" );
return NULL;
}
CPL_LSBPTR64( &dfTemp );
//.........这里部分代码省略.........
示例7: memcpy
GDALDataset *OZIDataset::Open( GDALOpenInfo * poOpenInfo )
{
if (!Identify(poOpenInfo))
return NULL;
GByte abyHeader[14];
memcpy(abyHeader, poOpenInfo->pabyHeader, 14);
int bOzi3 = (abyHeader[0] == 0x80 &&
abyHeader[1] == 0x77);
const CPLString osImgFilename = poOpenInfo->pszFilename;
VSILFILE* fp = VSIFOpenL(osImgFilename.c_str(), "rb");
if (fp == NULL)
return NULL;
OZIDataset* poDS = new OZIDataset();
poDS->fp = fp;
GByte nKeyInit = 0;
if (bOzi3)
{
VSIFSeekL(fp, 14, SEEK_SET);
GByte nRandomNumber = 0;
VSIFReadL(&nRandomNumber, 1, 1, fp);
//printf("nRandomNumber = %d\n", nRandomNumber);
if (nRandomNumber < 0x94)
{
delete poDS;
return NULL;
}
VSIFSeekL(fp, 0x93, SEEK_CUR);
VSIFReadL(&nKeyInit, 1, 1, fp);
VSIFSeekL(fp, 0, SEEK_SET);
VSIFReadL(abyHeader, 1, 14, fp);
OZIDecrypt(abyHeader, 14, nKeyInit);
if (!(abyHeader[6] == 0x40 &&
abyHeader[7] == 0x00 &&
abyHeader[8] == 0x01 &&
abyHeader[9] == 0x00 &&
abyHeader[10] == 0x36 &&
abyHeader[11] == 0x04 &&
abyHeader[12] == 0x00 &&
abyHeader[13] == 0x00))
{
delete poDS;
return NULL;
}
VSIFSeekL(fp, 14 + 1 + nRandomNumber, SEEK_SET);
const int nMagic = ReadInt(fp, bOzi3, nKeyInit);
CPLDebug("OZI", "OZI version code : 0x%08X", nMagic);
poDS->bOzi3 = bOzi3;
}
else
{
VSIFSeekL(fp, 14, SEEK_SET);
}
GByte abyHeader2[40], abyHeader2_Backup[40];
VSIFReadL(abyHeader2, 40, 1, fp);
memcpy(abyHeader2_Backup, abyHeader2, 40);
/* There's apparently a relationship between the nMagic number */
/* and the nKeyInit, but I'm too lazy to add switch/cases that might */
/* be not exhaustive, so let's try the 'brute force' attack !!! */
/* It is much so funny to be able to run one in a few microseconds :-) */
for( int i = 0; i < 256; i++ )
{
nKeyInit = static_cast<GByte>( i );
GByte* pabyHeader2 = abyHeader2;
if (bOzi3)
OZIDecrypt(abyHeader2, 40, nKeyInit);
const int nHeaderSize = ReadInt(&pabyHeader2); /* should be 40 */
poDS->nRasterXSize = ReadInt(&pabyHeader2);
poDS->nRasterYSize = ReadInt(&pabyHeader2);
const int nDepth = ReadShort(&pabyHeader2); /* should be 1 */
const int nBPP = ReadShort(&pabyHeader2); /* should be 8 */
ReadInt(&pabyHeader2); /* reserved */
ReadInt(&pabyHeader2); /* pixel number (height * width) : unused */
ReadInt(&pabyHeader2); /* reserved */
ReadInt(&pabyHeader2); /* reserved */
ReadInt(&pabyHeader2); /* ?? 0x100 */
ReadInt(&pabyHeader2); /* ?? 0x100 */
if (nHeaderSize != 40 || nDepth != 1 || nBPP != 8)
{
if (bOzi3)
{
if (nKeyInit != 255)
{
memcpy(abyHeader2, abyHeader2_Backup,40);
continue;
}
else
//.........这里部分代码省略.........
示例8: Open
GDALDataset* OGRPLScenesDataset::Open(GDALOpenInfo* poOpenInfo)
{
if( !Identify(poOpenInfo) || poOpenInfo->eAccess == GA_Update )
return NULL;
OGRPLScenesDataset* poDS = new OGRPLScenesDataset();
poDS->osBaseURL = CPLGetConfigOption("PL_URL", "https://api.planet.com/v0/scenes/");
char** papszOptions = CSLTokenizeStringComplex(
poOpenInfo->pszFilename+strlen("PLScenes:"), ",", TRUE, FALSE );
poDS->osAPIKey = CSLFetchNameValueDef(papszOptions, "api_key",
CSLFetchNameValueDef(poOpenInfo->papszOpenOptions, "API_KEY",
CPLGetConfigOption("PL_API_KEY","")) );
if( poDS->osAPIKey.size() == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Missing PL_API_KEY configuration option or API_KEY open option");
delete poDS;
CSLDestroy(papszOptions);
return NULL;
}
const char* pszScene = CSLFetchNameValueDef(papszOptions, "scene",
CSLFetchNameValue(poOpenInfo->papszOpenOptions, "SCENE"));
if( pszScene )
{
GDALDataset* poRasterDS = poDS->OpenRasterScene(poOpenInfo, pszScene,
papszOptions);
delete poDS;
CSLDestroy(papszOptions);
return poRasterDS;
}
for( char** papszIter = papszOptions; papszIter && *papszIter; papszIter ++ )
{
char* pszKey;
const char* pszValue = CPLParseNameValue(*papszIter, &pszKey);
if( pszValue != NULL )
{
if( !EQUAL(pszKey, "api_key") &&
!EQUAL(pszKey, "spat") )
{
CPLError(CE_Failure, CPLE_NotSupported, "Unsupported option %s", pszKey);
CPLFree(pszKey);
delete poDS;
CSLDestroy(papszOptions);
return NULL;
}
CPLFree(pszKey);
}
}
json_object* poObj = poDS->RunRequest(poDS->osBaseURL);
if( poObj == NULL )
{
delete poDS;
CSLDestroy(papszOptions);
return NULL;
}
json_object_iter it;
it.key = NULL;
it.val = NULL;
it.entry = NULL;
json_object_object_foreachC( poObj, it )
{
if( it.val != NULL && json_object_get_type(it.val) == json_type_string )
{
const char* pszSceneType = it.key;
const char* pszSceneTypeURL = json_object_get_string(it.val);
json_object* poObj = NULL;
if( !EQUAL(pszSceneType, "ortho") )
poObj = poDS->RunRequest( (CPLString(pszSceneTypeURL) + CPLString("?count=10")).c_str() );
OGRPLScenesLayer* poLayer = new OGRPLScenesLayer(poDS, pszSceneType, pszSceneTypeURL, poObj);
if( poObj )
json_object_put(poObj);
poDS->papoLayers = (OGRPLScenesLayer**) CPLRealloc(poDS->papoLayers,
sizeof(OGRPLScenesLayer*) * (poDS->nLayers + 1));
poDS->papoLayers[poDS->nLayers ++] = poLayer;
const char* pszSpat = CSLFetchNameValue(papszOptions, "spat");
if( pszSpat )
{
char** papszTokens = CSLTokenizeString2(pszSpat, " ", 0);
if( CSLCount(papszTokens) >= 4 )
{
poLayer->SetMainFilterRect(CPLAtof(papszTokens[0]),
CPLAtof(papszTokens[1]),
CPLAtof(papszTokens[2]),
CPLAtof(papszTokens[3]));
}
CSLDestroy(papszTokens);
}
}
}
//.........这里部分代码省略.........
示例9: CSLCount
GDALDataset *HDF5Dataset::Open( GDALOpenInfo * poOpenInfo )
{
HDF5Dataset *poDS;
CPLErr Err;
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create datasource. */
/* -------------------------------------------------------------------- */
poDS = new HDF5Dataset();
poDS->SetDescription( poOpenInfo->pszFilename );
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
poDS->hHDF5 = H5Fopen( poOpenInfo->pszFilename,
H5F_ACC_RDONLY,
H5P_DEFAULT );
if( poDS->hHDF5 < 0 ) {
delete poDS;
return NULL;
}
poDS->hGroupID = H5Gopen( poDS->hHDF5, "/" );
if( poDS->hGroupID < 0 ) {
poDS->bIsHDFEOS=false;
delete poDS;
return NULL;
}
poDS->bIsHDFEOS=true;
Err = poDS->ReadGlobalAttributes( true );
poDS->SetMetadata( poDS->papszMetadata );
if ( CSLCount( poDS->papszSubDatasets ) / 2 >= 1 )
poDS->SetMetadata( poDS->papszSubDatasets, "SUBDATASETS" );
// Make sure we don't try to do any pam stuff with this dataset.
poDS->nPamFlags |= GPF_NOSAVE;
/* -------------------------------------------------------------------- */
/* If we have single subdataset only, open it immediately */
/* -------------------------------------------------------------------- */
int nSubDatasets = CSLCount( poDS->papszSubDatasets ) / 2;
if( nSubDatasets == 1 )
{
CPLString osDSName = CSLFetchNameValue( poDS->papszSubDatasets,
"SUBDATASET_1_NAME" );
delete poDS;
return (GDALDataset *) GDALOpen( osDSName, poOpenInfo->eAccess );
}
else
{
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError( CE_Failure, CPLE_NotSupported,
"The HDF5 driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
}
return( poDS );
}示例10: if
GDALDataset *ECRGTOCDataset::Open( GDALOpenInfo * poOpenInfo )
{
const char *pszFilename = poOpenInfo->pszFilename;
CPLString osFilename;
CPLString osProduct, osDiscId, osScale;
if( !Identify( poOpenInfo ) )
return NULL;
if( EQUALN(pszFilename, "ECRG_TOC_ENTRY:",strlen("ECRG_TOC_ENTRY:")))
{
pszFilename += strlen("ECRG_TOC_ENTRY:");
/* PRODUCT:DISK:SCALE:FILENAME (or PRODUCT:DISK:FILENAME historically) */
/* with FILENAME potentially C:\BLA... */
char** papszTokens = CSLTokenizeString2(pszFilename, ":", 0);
int nTokens = CSLCount(papszTokens);
if( nTokens != 3 && nTokens != 4 && nTokens != 5 )
{
CSLDestroy(papszTokens);
return NULL;
}
osProduct = papszTokens[0];
osDiscId = papszTokens[1];
if( nTokens == 3 )
osFilename = papszTokens[2];
else if( nTokens == 4 )
{
if( strlen(papszTokens[2]) == 1 &&
(papszTokens[3][0] == '\\' ||
papszTokens[3][0] == '/') )
{
osFilename = papszTokens[2];
osFilename += ":";
osFilename = papszTokens[3];
}
else
{
osScale = papszTokens[2];
osFilename = papszTokens[3];
}
}
else if( nTokens == 5 &&
strlen(papszTokens[3]) == 1 &&
(papszTokens[4][0] == '\\' ||
papszTokens[4][0] == '/') )
{
osScale = papszTokens[2];
osFilename = papszTokens[3];
osFilename += ":";
osFilename = papszTokens[4];
}
else
{
CSLDestroy(papszTokens);
return NULL;
}
CSLDestroy(papszTokens);
pszFilename = osFilename.c_str();
}
/* -------------------------------------------------------------------- */
/* Parse the XML file */
/* -------------------------------------------------------------------- */
CPLXMLNode* psXML = CPLParseXMLFile(pszFilename);
if (psXML == NULL)
{
return NULL;
}
GDALDataset* poDS = Build( pszFilename, psXML, osProduct, osDiscId,
osScale,
poOpenInfo->pszFilename);
CPLDestroyXMLNode(psXML);
if (poDS && poOpenInfo->eAccess == GA_Update)
{
CPLError(CE_Failure, CPLE_NotSupported,
"ECRGTOC driver does not support update mode");
delete poDS;
return NULL;
}
return poDS;
}示例11: VSIFSeekL
GDALDataset *RIKDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( Identify(poOpenInfo) == FALSE )
return NULL;
bool rik3header = false;
if( EQUALN((const char *) poOpenInfo->pabyHeader, "RIK3", 4) )
{
rik3header = true;
VSIFSeekL( poOpenInfo->fpL, 4, SEEK_SET );
}
else
VSIFSeekL( poOpenInfo->fpL, 0, SEEK_SET );
/* -------------------------------------------------------------------- */
/* Read the map name. */
/* -------------------------------------------------------------------- */
char name[1024];
GUInt16 nameLength = GetRikString( poOpenInfo->fpL, 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->fpL,
projection, sizeof(projection) );
if( projLength > sizeof(projection) - 1 )
{
// Unreasonable string length, assume wrong format
return NULL;
}
// Read unknown string
projLength = GetRikString( poOpenInfo->fpL, projection, sizeof(projection) );
// Read map north edge
char tmpStr[16];
GUInt16 tmpLength = GetRikString( poOpenInfo->fpL,
tmpStr, sizeof(tmpStr) );
if( tmpLength > sizeof(tmpStr) - 1 )
{
// Unreasonable string length, assume wrong format
return NULL;
}
header.fNorth = CPLAtof( tmpStr );
// Read map west edge
tmpLength = GetRikString( poOpenInfo->fpL,
tmpStr, sizeof(tmpStr) );
if( tmpLength > sizeof(tmpStr) - 1 )
{
// Unreasonable string length, assume wrong format
return NULL;
}
header.fWest = CPLAtof( tmpStr );
// Read binary values
VSIFReadL( &header.iScale, 1, sizeof(header.iScale), poOpenInfo->fpL );
VSIFReadL( &header.iMPPNum, 1, sizeof(header.iMPPNum), poOpenInfo->fpL );
VSIFReadL( &header.iBlockWidth, 1, sizeof(header.iBlockWidth), poOpenInfo->fpL );
//.........这里部分代码省略.........
示例12: if
GDALDataset *ISIS3Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a CUBE dataset? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
FILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
ISIS3Dataset *poDS;
poDS = new ISIS3Dataset();
if( ! poDS->oKeywords.Ingest( fpQube, 0 ) )
{
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
/* -------------------------------------------------------------------- */
/* Assume user is pointing to label (ie .lbl) file for detached option */
/* -------------------------------------------------------------------- */
// Image can be inline or detached and point to an image name
// the Format can be Tiled or Raw
// Object = Core
// StartByte = 65537
// Format = Tile
// TileSamples = 128
// TileLines = 128
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detatched.cub
// Format = BandSequential
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detached_tiled.cub
// Format = Tile
// TileSamples = 128
// TileLines = 128
/* -------------------------------------------------------------------- */
/* What file contains the actual data? */
/* -------------------------------------------------------------------- */
const char *pszCore = poDS->GetKeyword( "IsisCube.Core.^Core" );
CPLString osQubeFile;
if( EQUAL(pszCore,"") )
osQubeFile = poOpenInfo->pszFilename;
else
{
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
osQubeFile = CPLFormFilename( osPath, pszCore, NULL );
poDS->osExternalCube = osQubeFile;
}
/* -------------------------------------------------------------------- */
/* Check if file an ISIS3 header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
GDALDataType eDataType = GDT_Byte;
OGRSpatialReference oSRS;
int nRows = -1;
int nCols = -1;
int nBands = 1;
int nSkipBytes = 0;
int tileSizeX = 0;
int tileSizeY = 0;
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double scaleFactor = 1.0;
double dfNoData = 0.0;
int bNoDataSet = FALSE;
char chByteOrder = 'M'; //default to MSB
char szLayout[32] = "BandSequential"; //default to band seq.
const char *target_name; //planet name
//projection parameters
const char *map_proj_name;
int bProjectionSet = TRUE;
char proj_target_name[200];
char geog_name[60];
char datum_name[60];
char sphere_name[60];
char bIsGeographic = TRUE;
double semi_major = 0.0;
double semi_minor = 0.0;
//.........这里部分代码省略.........
示例13: if
GDALDataset *EIRDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
VSILFILE *fp;
const char * pszLine;
if( !Identify( poOpenInfo ) )
return NULL;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
return NULL;
/* header example and description
IMAGINE_RAW_FILE // must be on first line, by itself
WIDTH 581 // number of columns in the image
HEIGHT 695 // number of rows in the image
NUM_LAYERS 3 // number of spectral bands in the image; default 1
PIXEL_FILES raw8_3n_ui_sanjack.bl // raster file
// default: same name with no extension
FORMAT BIL // BIL BIP BSQ; default BIL
DATATYPE U8 // U1 U2 U4 U8 U16 U32 S16 S32 F32 F64; default U8
BYTE_ORDER // LSB MSB; required for U16 U32 S16 S32 F32 F64
DATA_OFFSET // start of image data in raster file; default 0 bytes
END_RAW_FILE // end RAW file - stop reading
For a true color image with three bands (R, G, B) stored using 8 bits
for each pixel in each band, DATA_TYPE equals U8 and NUM_LAYERS equals
3 for a total of 24 bits per pixel.
Note that the current version of ERDAS Raw Raster Reader/Writer does
not support the LAYER_SKIP_BYTES, RECORD_SKIP_BYTES, TILE_WIDTH and
TILE_HEIGHT directives. Since the reader does not read the PIXEL_FILES
directive, the reader always assumes that the raw binary file is the
dataset, and the name of this file is the name of the header without the
extension. Currently, the reader does not support multiple raw binary
files in one dataset or a single file with both the header and the raw
binary data at the same time.
*/
bool bDone = FALSE;
int nRows = -1, nCols = -1, nBands = 1;
int nSkipBytes = 0;
int nLineCount = 0;
GDALDataType eDataType = GDT_Byte;
int nBits = 8;
char chByteOrder = 'M';
char szLayout[10] = "BIL";
char **papszHDR = NULL;
// default raster file: same name with no extension
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetBasename( poOpenInfo->pszFilename );
CPLString osRasterFilename = CPLFormCIFilename( osPath, osName, "" );
// parse the header file
while( !bDone && (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if ( (nLineCount == 1) && !EQUAL(pszLine,"IMAGINE_RAW_FILE") ) {
return NULL;
}
if ( (nLineCount > 50) || EQUAL(pszLine,"END_RAW_FILE") ) {
bDone = TRUE;
break;
}
if( strlen(pszLine) > 1000 )
break;
papszHDR = CSLAddString( papszHDR, pszLine );
papszTokens = CSLTokenizeStringComplex( pszLine, " \t", TRUE, FALSE );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( EQUAL(papszTokens[0],"WIDTH") )
{
nCols = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"HEIGHT") )
{
nRows = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"NUM_LAYERS") )
{
nBands = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"PIXEL_FILES") )
{
//.........这里部分代码省略.........
示例14: if
GDALDataset *VICARDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a VICAR dataset? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
VSILFILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
VICARDataset *poDS;
poDS = new VICARDataset();
if( ! poDS->oKeywords.Ingest( fpQube, poOpenInfo->pabyHeader ) ) {
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
CPLString osQubeFile;
osQubeFile = poOpenInfo->pszFilename;
GDALDataType eDataType = GDT_Byte;
int nRows = -1;
int nCols = -1;
int nBands = 1;
int nSkipBytes = 0;
int bIsDTM = FALSE;
char chByteOrder = 'M';
double dfNoData = 0.0;
const char *value;
/***** CHECK ENDIANNESS **************/
value = poDS->GetKeyword( "INTFMT" );
if (!EQUAL(value,"LOW") ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
return FALSE;
}
value = poDS->GetKeyword( "REALFMT" );
if (!EQUAL(value,"RIEEE") ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
return FALSE;
}
value = poDS->GetKeyword( "BREALFMT" );
if (EQUAL(value,"VAX") ) {
chByteOrder = 'I';
}
/************ CHECK INSTRUMENT *****************/
/************ ONLY HRSC TESTED *****************/
value = poDS->GetKeyword( "DTM.DTM_OFFSET" );
if (!EQUAL(value,"") ) {
bIsDTM = TRUE;
}
value = poDS->GetKeyword( "BLTYPE" );
if (!EQUAL(value,"M94_HRSC") && bIsDTM==FALSE ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s instrument not tested. Continue with caution!\n\n", value);
}
/*********** Grab layout type (BSQ, BIP, BIL) ************/
char szLayout[10] = "BSQ"; //default to band seq.
value = poDS->GetKeyword( "ORG" );
if (EQUAL(value,"BSQ") ) {
strcpy(szLayout,"BSQ");
nCols = atoi(poDS->GetKeyword("NS"));
nRows = atoi(poDS->GetKeyword("NL"));
nBands = atoi(poDS->GetKeyword("NB"));
}
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
return FALSE;
}
/*********** Grab record bytes **********/
nSkipBytes = atoi(poDS->GetKeyword("NBB"));
if (EQUAL( poDS->GetKeyword( "FORMAT" ), "BYTE" )) {
eDataType = GDT_Byte;
dfNoData = NULL1;
}
else if (EQUAL( poDS->GetKeyword( "FORMAT" ), "HALF" )) {
eDataType = GDT_Int16;
dfNoData = NULL2;
//.........这里部分代码省略.........
示例15: osOriginalFilename
GDALDataset *HF2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
CPLString osOriginalFilename(poOpenInfo->pszFilename);
if (!Identify(poOpenInfo))
return NULL;
GDALOpenInfo* poOpenInfoToDelete = NULL;
/* GZipped .hf2 files are common, so automagically open them */
/* if the /vsigzip/ has not been explicitly passed */
CPLString osFilename(poOpenInfo->pszFilename);
if ((EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "hfz") ||
(strlen(poOpenInfo->pszFilename) > 6 &&
EQUAL(poOpenInfo->pszFilename + strlen(poOpenInfo->pszFilename) - 6, "hf2.gz"))) &&
!EQUALN(poOpenInfo->pszFilename, "/vsigzip/", 9))
{
osFilename = "/vsigzip/";
osFilename += poOpenInfo->pszFilename;
poOpenInfo = poOpenInfoToDelete =
new GDALOpenInfo(osFilename.c_str(), GA_ReadOnly,
poOpenInfo->GetSiblingFiles());
}
/* -------------------------------------------------------------------- */
/* Parse header */
/* -------------------------------------------------------------------- */
int nXSize, nYSize;
memcpy(&nXSize, poOpenInfo->pabyHeader + 6, 4);
CPL_LSBPTR32(&nXSize);
memcpy(&nYSize, poOpenInfo->pabyHeader + 10, 4);
CPL_LSBPTR32(&nYSize);
GUInt16 nTileSize;
memcpy(&nTileSize, poOpenInfo->pabyHeader + 14, 2);
CPL_LSBPTR16(&nTileSize);
float fVertPres, fHorizScale;
memcpy(&fVertPres, poOpenInfo->pabyHeader + 16, 4);
CPL_LSBPTR32(&fVertPres);
memcpy(&fHorizScale, poOpenInfo->pabyHeader + 20, 4);
CPL_LSBPTR32(&fHorizScale);
GUInt32 nExtendedHeaderLen;
memcpy(&nExtendedHeaderLen, poOpenInfo->pabyHeader + 24, 4);
CPL_LSBPTR32(&nExtendedHeaderLen);
delete poOpenInfoToDelete;
poOpenInfoToDelete = NULL;
if (nTileSize < 8)
return NULL;
if (nXSize <= 0 || nXSize > INT_MAX - nTileSize ||
nYSize <= 0 || nYSize > INT_MAX - nTileSize)
return NULL;
/* To avoid later potential int overflows */
if (nExtendedHeaderLen > 1024 * 65536)
return NULL;
if (!GDALCheckDatasetDimensions(nXSize, nYSize))
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Parse extended blocks */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(osFilename.c_str(), "rb");
if (fp == NULL)
return NULL;
VSIFSeekL(fp, 28, SEEK_SET);
int bHasExtent = FALSE;
double dfMinX = 0, dfMaxX = 0, dfMinY = 0, dfMaxY = 0;
int bHasUTMZone = FALSE;
GInt16 nUTMZone = 0;
int bHasEPSGDatumCode = FALSE;
GInt16 nEPSGDatumCode = 0;
int bHasEPSGCode = FALSE;
GInt16 nEPSGCode = 0;
int bHasRelativePrecision = FALSE;
float fRelativePrecision = 0;
char szApplicationName[256];
szApplicationName[0] = 0;
GUInt32 nExtendedHeaderOff = 0;
while(nExtendedHeaderOff < nExtendedHeaderLen)
{
char pabyBlockHeader[24];
VSIFReadL(pabyBlockHeader, 24, 1, fp);
char szBlockName[16 + 1];
memcpy(szBlockName, pabyBlockHeader + 4, 16);
szBlockName[16] = 0;
GUInt32 nBlockSize;
memcpy(&nBlockSize, pabyBlockHeader + 20, 4);
CPL_LSBPTR32(&nBlockSize);
//.........这里部分代码省略.........