int main( int nArgc, char ** papszArgv )
{
NITFFile *psFile;
int iSegment, iFile;
char szTemp[100];
int bDisplayTRE = FALSE;
int bExtractSHP = FALSE, bExtractSHPInMem = FALSE;
if( nArgc < 2 )
{
printf( "Usage: nitfdump [-tre] [-extractshp | -extractshpinmem] <nitf_filename>*\n" );
exit( 1 );
}
for( iFile = 1; iFile < nArgc; iFile++ )
{
if ( EQUAL(papszArgv[iFile], "-tre") )
bDisplayTRE = TRUE;
else if ( EQUAL(papszArgv[iFile], "-extractshp") )
bExtractSHP = TRUE;
else if ( EQUAL(papszArgv[iFile], "-extractshpinmem") )
{
bExtractSHP = TRUE;
bExtractSHPInMem = TRUE;
}
}
/* ==================================================================== */
/* Loop over all files. */
/* ==================================================================== */
for( iFile = 1; iFile < nArgc; iFile++ )
{
int bHasFoundLocationTable = FALSE;
if ( EQUAL(papszArgv[iFile], "-tre") )
continue;
if ( EQUAL(papszArgv[iFile], "-extractshp") )
continue;
if ( EQUAL(papszArgv[iFile], "-extractshpinmem") )
continue;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
psFile = NITFOpen( papszArgv[iFile], FALSE );
if( psFile == NULL )
exit( 2 );
printf( "Dump for %s\n", papszArgv[iFile] );
/* -------------------------------------------------------------------- */
/* Dump first TRE list. */
/* -------------------------------------------------------------------- */
if( psFile->pachTRE != NULL )
{
int nTREBytes = psFile->nTREBytes;
const char *pszTREData = psFile->pachTRE;
printf( "File TREs:" );
while( nTREBytes > 10 )
{
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
NITFGetField(szTemp, pszTREData, 0, 6 );
printf(" Invalid size (%d) for TRE %s", nThisTRESize, szTemp);
break;
}
printf( " %6.6s(%d)", pszTREData, nThisTRESize );
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
printf( "\n" );
if (bDisplayTRE)
{
nTREBytes = psFile->nTREBytes;
pszTREData = psFile->pachTRE;
while( nTREBytes > 10 )
{
char *pszEscaped;
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
break;
}
pszEscaped = CPLEscapeString( pszTREData + 11, nThisTRESize,
CPLES_BackslashQuotable );
printf( "TRE '%6.6s' : %s\n", pszTREData, pszEscaped);
CPLFree(pszEscaped);
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
}
}
/* -------------------------------------------------------------------- */
/* Dump Metadata */
/* -------------------------------------------------------------------- */
DumpMetadata( "File Metadata:", " ", psFile->papszMetadata );
/* -------------------------------------------------------------------- */
/* Dump general info about segments. */
/* -------------------------------------------------------------------- */
NITFCollectAttachments( psFile );
NITFReconcileAttachments( psFile );
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
printf( "Segment %d (Type=%s):\n",
iSegment + 1, psSegInfo->szSegmentType );
printf( " HeaderStart=" CPL_FRMT_GUIB ", HeaderSize=%u, DataStart=" CPL_FRMT_GUIB ", DataSize=" CPL_FRMT_GUIB "\n",
psSegInfo->nSegmentHeaderStart,
psSegInfo->nSegmentHeaderSize,
psSegInfo->nSegmentStart,
psSegInfo->nSegmentSize );
printf( " DLVL=%d, ALVL=%d, LOC=C%d,R%d, CCS=C%d,R%d\n",
psSegInfo->nDLVL,
psSegInfo->nALVL,
psSegInfo->nLOC_C,
psSegInfo->nLOC_R,
psSegInfo->nCCS_C,
psSegInfo->nCCS_R );
printf( "\n" );
}
/* -------------------------------------------------------------------- */
/* Report details of images. */
/* -------------------------------------------------------------------- */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
NITFImage *psImage;
NITFRPC00BInfo sRPCInfo;
int iBand;
char **papszMD;
if( !EQUAL(psSegInfo->szSegmentType,"IM") )
continue;
psImage = NITFImageAccess( psFile, iSegment );
if( psImage == NULL )
{
printf( "NITFAccessImage(%d) failed!\n", iSegment );
continue;
}
printf( "Image Segment %d, %dPx%dLx%dB x %dbits:\n",
iSegment + 1, psImage->nCols, psImage->nRows,
psImage->nBands, psImage->nBitsPerSample );
printf( " PVTYPE=%s, IREP=%s, ICAT=%s, IMODE=%c, IC=%s, COMRAT=%s, ICORDS=%c\n",
psImage->szPVType, psImage->szIREP, psImage->szICAT,
psImage->chIMODE, psImage->szIC, psImage->szCOMRAT,
psImage->chICORDS );
if( psImage->chICORDS != ' ' )
{
printf( " UL=(%.15g,%.15g), UR=(%.15g,%.15g) Center=%d\n LL=(%.15g,%.15g), LR=(%.15g,%.15g)\n",
psImage->dfULX, psImage->dfULY,
psImage->dfURX, psImage->dfURY,
psImage->bIsBoxCenterOfPixel,
psImage->dfLLX, psImage->dfLLY,
psImage->dfLRX, psImage->dfLRY );
}
printf( " IDLVL=%d, IALVL=%d, ILOC R=%d,C=%d, IMAG=%s\n",
psImage->nIDLVL, psImage->nIALVL,
psImage->nILOCRow, psImage->nILOCColumn,
psImage->szIMAG );
printf( " %d x %d blocks of size %d x %d\n",
psImage->nBlocksPerRow, psImage->nBlocksPerColumn,
psImage->nBlockWidth, psImage->nBlockHeight );
if( psImage->pachTRE != NULL )
{
int nTREBytes = psImage->nTREBytes;
const char *pszTREData = psImage->pachTRE;
printf( " Image TREs:" );
while( nTREBytes > 10 )
{
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
NITFGetField(szTemp, pszTREData, 0, 6 );
printf(" Invalid size (%d) for TRE %s", nThisTRESize, szTemp);
break;
}
printf( " %6.6s(%d)", pszTREData, nThisTRESize );
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
printf( "\n" );
if (bDisplayTRE)
{
nTREBytes = psImage->nTREBytes;
pszTREData = psImage->pachTRE;
while( nTREBytes > 10 )
{
char *pszEscaped;
int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5 ));
if (nThisTRESize < 0 || nThisTRESize > nTREBytes - 11)
{
break;
}
pszEscaped = CPLEscapeString( pszTREData + 11, nThisTRESize,
CPLES_BackslashQuotable );
printf( " TRE '%6.6s' : %s\n", pszTREData, pszEscaped);
CPLFree(pszEscaped);
pszTREData += nThisTRESize + 11;
nTREBytes -= (nThisTRESize + 11);
}
}
}
/* Report info from location table, if found. */
if( psImage->nLocCount > 0 )
{
int i;
bHasFoundLocationTable = TRUE;
printf( " Location Table\n" );
for( i = 0; i < psImage->nLocCount; i++ )
{
printf( " LocName=%s, LocId=%d, Offset=%d, Size=%d\n",
GetLocationNameFromId(psImage->pasLocations[i].nLocId),
psImage->pasLocations[i].nLocId,
psImage->pasLocations[i].nLocOffset,
psImage->pasLocations[i].nLocSize );
}
printf( "\n" );
}
if( strlen(psImage->pszComments) > 0 )
printf( " Comments:\n%s\n", psImage->pszComments );
for( iBand = 0; iBand < psImage->nBands; iBand++ )
{
NITFBandInfo *psBandInfo = psImage->pasBandInfo + iBand;
printf( " Band %d: IREPBAND=%s, ISUBCAT=%s, %d LUT entries.\n",
iBand + 1, psBandInfo->szIREPBAND, psBandInfo->szISUBCAT,
psBandInfo->nSignificantLUTEntries );
}
if( NITFReadRPC00B( psImage, &sRPCInfo ) )
{
DumpRPC( psImage, &sRPCInfo );
}
papszMD = NITFReadUSE00A( psImage );
if( papszMD != NULL )
{
DumpMetadata( " USE00A TRE:", " ", papszMD );
CSLDestroy( papszMD );
}
papszMD = NITFReadBLOCKA( psImage );
if( papszMD != NULL )
{
DumpMetadata( " BLOCKA TRE:", " ", papszMD );
CSLDestroy( papszMD );
}
papszMD = NITFReadSTDIDC( psImage );
if( papszMD != NULL )
{
DumpMetadata( " STDIDC TRE:", " ", papszMD );
CSLDestroy( papszMD );
}
DumpMetadata( " Image Metadata:", " ", psImage->papszMetadata );
printf("\n");
}
/* ==================================================================== */
/* Report details of graphic segments. */
/* ==================================================================== */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
char achSubheader[298];
int nSTYPEOffset;
if( !EQUAL(psSegInfo->szSegmentType,"GR")
&& !EQUAL(psSegInfo->szSegmentType,"SY") )
continue;
/* -------------------------------------------------------------------- */
/* Load the graphic subheader. */
/* -------------------------------------------------------------------- */
if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart,
SEEK_SET ) != 0
|| VSIFReadL( achSubheader, 1, sizeof(achSubheader),
psFile->fp ) < 258 )
{
CPLError( CE_Warning, CPLE_FileIO,
"Failed to read graphic subheader at " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentHeaderStart );
continue;
}
// NITF 2.0. (also works for NITF 2.1)
nSTYPEOffset = 200;
if( STARTS_WITH_CI(achSubheader+193, "999998") )
nSTYPEOffset += 40;
/* -------------------------------------------------------------------- */
/* Report some standard info. */
/* -------------------------------------------------------------------- */
printf( "Graphic Segment %d, type=%2.2s, sfmt=%c, sid=%10.10s\n",
iSegment + 1,
achSubheader + 0,
achSubheader[nSTYPEOffset],
achSubheader + 2 );
printf( " sname=%20.20s\n", achSubheader + 12 );
printf("\n");
}
/* ==================================================================== */
/* Report details of text segments. */
/* ==================================================================== */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
char *pabyHeaderData;
char *pabyTextData;
NITFSegmentInfo *psSegment = psFile->pasSegmentInfo + iSegment;
if( !EQUAL(psSegment->szSegmentType,"TX") )
continue;
printf( "Text Segment %d\n", iSegment + 1);
/* -------------------------------------------------------------------- */
/* Load the text header */
/* -------------------------------------------------------------------- */
/* Allocate one extra byte for the NULL terminating character */
pabyHeaderData = (char *) CPLCalloc(1,
(size_t) psSegment->nSegmentHeaderSize + 1);
if (VSIFSeekL(psFile->fp, psSegment->nSegmentHeaderStart,
SEEK_SET) != 0 ||
VSIFReadL(pabyHeaderData, 1, (size_t) psSegment->nSegmentHeaderSize,
psFile->fp) != psSegment->nSegmentHeaderSize)
{
CPLError( CE_Warning, CPLE_FileIO,
"Failed to read %d bytes of text header data at " CPL_FRMT_GUIB ".",
psSegment->nSegmentHeaderSize,
psSegment->nSegmentHeaderStart);
CPLFree(pabyHeaderData);
continue;
}
printf(" Header : %s\n", pabyHeaderData);
CPLFree(pabyHeaderData);
/* -------------------------------------------------------------------- */
/* Load the raw TEXT data itself. */
/* -------------------------------------------------------------------- */
/* Allocate one extra byte for the NULL terminating character */
pabyTextData = (char *) CPLCalloc(1,(size_t)psSegment->nSegmentSize+1);
if( VSIFSeekL( psFile->fp, psSegment->nSegmentStart,
SEEK_SET ) != 0
|| VSIFReadL( pabyTextData, 1, (size_t)psSegment->nSegmentSize,
psFile->fp ) != psSegment->nSegmentSize )
{
CPLError( CE_Warning, CPLE_FileIO,
"Failed to read " CPL_FRMT_GUIB " bytes of text data at " CPL_FRMT_GUIB ".",
psSegment->nSegmentSize,
psSegment->nSegmentStart );
CPLFree( pabyTextData );
continue;
}
printf(" Data : %s\n", pabyTextData);
printf("\n");
CPLFree( pabyTextData );
}
/* -------------------------------------------------------------------- */
/* Report details of DES. */
/* -------------------------------------------------------------------- */
for( iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++ )
{
NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
NITFDES *psDES;
int nOffset = 0;
char szTREName[7];
int nThisTRESize;
int nRPFDESOffset = -1;
if( !EQUAL(psSegInfo->szSegmentType,"DE") )
continue;
psDES = NITFDESAccess( psFile, iSegment );
if( psDES == NULL )
{
printf( "NITFDESAccess(%d) failed!\n", iSegment );
continue;
}
printf( "DE Segment %d:\n", iSegment + 1 );
printf( " Segment TREs:" );
nOffset = 0;
while (NITFDESGetTRE( psDES, nOffset, szTREName, NULL, &nThisTRESize))
{
printf( " %6.6s(%d)", szTREName, nThisTRESize );
if (strcmp(szTREName, "RPFDES") == 0)
nRPFDESOffset = nOffset + 11;
nOffset += 11 + nThisTRESize;
}
printf( "\n" );
if (bDisplayTRE)
{
char* pabyTREData = NULL;
nOffset = 0;
while (NITFDESGetTRE( psDES, nOffset, szTREName, &pabyTREData, &nThisTRESize))
{
char* pszEscaped = CPLEscapeString( pabyTREData, nThisTRESize,
CPLES_BackslashQuotable );
printf( " TRE '%6.6s' : %s\n", szTREName, pszEscaped);
CPLFree(pszEscaped);
nOffset += 11 + nThisTRESize;
NITFDESFreeTREData(pabyTREData);
}
}
/* Report info from location table, if found. */
if( !bHasFoundLocationTable && nRPFDESOffset >= 0 )
{
int i;
int nLocCount = 0;
NITFLocation* pasLocations;
VSIFSeekL(psFile->fp, psSegInfo->nSegmentStart + nRPFDESOffset, SEEK_SET);
pasLocations = NITFReadRPFLocationTable(psFile->fp, &nLocCount);
if (pasLocations)
{
printf( " Location Table\n" );
for( i = 0; i < nLocCount; i++ )
{
printf( " LocName=%s, LocId=%d, Offset=%d, Size=%d\n",
GetLocationNameFromId(pasLocations[i].nLocId),
pasLocations[i].nLocId,
pasLocations[i].nLocOffset,
pasLocations[i].nLocSize );
}
CPLFree(pasLocations);
printf( "\n" );
}
}
DumpMetadata( " DES Metadata:", " ", psDES->papszMetadata );
if ( bExtractSHP && CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE_USE") != NULL )
{
char szFilename[32];
char szRadix[32];
if (bExtractSHPInMem)
snprintf(szRadix, sizeof(szRadix), "/vsimem/nitf_segment_%d", iSegment + 1);
else
snprintf(szRadix, sizeof(szRadix), "nitf_segment_%d", iSegment + 1);
if (NITFDESExtractShapefile(psDES, szRadix))
{
OGRDataSourceH hDS;
OGRRegisterAll();
snprintf(szFilename, sizeof(szFilename), "%s.SHP", szRadix);
hDS = OGROpen(szFilename, FALSE, NULL);
if (hDS)
{
int nGeom = 0;
OGRLayerH hLayer = OGR_DS_GetLayer(hDS, 0);
if (hLayer)
{
OGRFeatureH hFeat;
printf("\n");
while ( (hFeat = OGR_L_GetNextFeature(hLayer)) != NULL )
{
OGRGeometryH hGeom = OGR_F_GetGeometryRef(hFeat);
if (hGeom)
{
char* pszWKT = NULL;
OGR_G_ExportToWkt(hGeom, &pszWKT);
if (pszWKT)
printf(" Geometry %d : %s\n", nGeom ++, pszWKT);
CPLFree(pszWKT);
}
OGR_F_Destroy(hFeat);
}
}
OGR_DS_Destroy(hDS);
}
}
if (bExtractSHPInMem)
{
snprintf(szFilename, sizeof(szFilename), "%s.SHP", szRadix);
VSIUnlink(szFilename);
snprintf(szFilename, sizeof(szFilename), "%s.SHX", szRadix);
VSIUnlink(szFilename);
snprintf(szFilename, sizeof(szFilename), "%s.DBF", szRadix);
VSIUnlink(szFilename);
}
}
}
/* -------------------------------------------------------------------- */
/* Close. */
/* -------------------------------------------------------------------- */
NITFClose( psFile );
}
CPLFinderClean();
CPLCleanupTLS();
VSICleanupFileManager();
OGRCleanupAll();
exit( 0 );
}
NITFDES *NITFDESAccess( NITFFile *psFile, int iSegment )
{
NITFDES *psDES;
char *pachHeader;
NITFSegmentInfo *psSegInfo;
char szDESID[26];
char szTemp[128];
int nOffset;
int bHasDESOFLW;
int nDESSHL;
/* -------------------------------------------------------------------- */
/* Verify segment, and return existing DES accessor if there */
/* is one. */
/* -------------------------------------------------------------------- */
if( iSegment < 0 || iSegment >= psFile->nSegmentCount )
return NULL;
psSegInfo = psFile->pasSegmentInfo + iSegment;
if( !EQUAL(psSegInfo->szSegmentType,"DE") )
return NULL;
if( psSegInfo->hAccess != NULL )
return (NITFDES *) psSegInfo->hAccess;
/* -------------------------------------------------------------------- */
/* Read the DES subheader. */
/* -------------------------------------------------------------------- */
if (psSegInfo->nSegmentHeaderSize < 200)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
return NULL;
}
pachHeader = (char*) VSIMalloc(psSegInfo->nSegmentHeaderSize);
if (pachHeader == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Cannot allocate memory for segment header");
return NULL;
}
retry:
if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart,
SEEK_SET ) != 0
|| VSIFReadL( pachHeader, 1, psSegInfo->nSegmentHeaderSize,
psFile->fp ) != psSegInfo->nSegmentHeaderSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %u byte DES subheader from " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentHeaderSize,
psSegInfo->nSegmentHeaderStart );
CPLFree(pachHeader);
return NULL;
}
if (!EQUALN(pachHeader, "DE", 2))
{
if (EQUALN(pachHeader + 4, "DERegistered", 12))
{
/* BAO_46_Ed1/rpf/conc/concz10/000fz010.ona and cie are buggy */
CPLDebug("NITF", "Patching nSegmentHeaderStart and nSegmentStart for DE segment %d", iSegment);
psSegInfo->nSegmentHeaderStart += 4;
psSegInfo->nSegmentStart += 4;
goto retry;
}
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid segment prefix for DE segment %d", iSegment);
CPLFree(pachHeader);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Initialize DES object. */
/* -------------------------------------------------------------------- */
psDES = (NITFDES *) CPLCalloc(sizeof(NITFDES),1);
psDES->psFile = psFile;
psDES->iSegment = iSegment;
psDES->pachHeader = pachHeader;
psSegInfo->hAccess = psDES;
/* -------------------------------------------------------------------- */
/* Collect a variety of information as metadata. */
/* -------------------------------------------------------------------- */
#define GetMD( length, name ) \
do { NITFExtractMetadata( &(psDES->papszMetadata), pachHeader, \
nOffset, length, \
"NITF_" #name ); \
nOffset += length; } while(0)
nOffset = 2;
GetMD( 25, DESID );
GetMD( 2, DESVER );
GetMD( 1, DECLAS );
GetMD( 2, DESCLSY );
GetMD( 11, DESCODE );
GetMD( 2, DESCTLH );
GetMD( 20, DESREL );
GetMD( 2, DESDCTP );
GetMD( 8, DESDCDT );
GetMD( 4, DESDCXM );
GetMD( 1, DESDG );
GetMD( 8, DESDGDT );
GetMD( 43, DESCLTX );
GetMD( 1, DESCATP );
GetMD( 40, DESCAUT );
GetMD( 1, DESCRSN );
GetMD( 8, DESSRDT );
GetMD( 15, DESCTLN );
/* Load DESID */
NITFGetField( szDESID, pachHeader, 2, 25);
/* For NITF < 02.10, we cannot rely on DESID=TRE_OVERFLOW to detect */
/* if DESOFLW and DESITEM are present. So if the next 4 bytes are non */
/* numeric, we'll assume that DESOFLW is there */
bHasDESOFLW = EQUALN(szDESID, "TRE_OVERFLOW", strlen("TRE_OVERFLOW")) ||
(!((pachHeader[nOffset+0] >= '0' && pachHeader[nOffset+0] <= '9') &&
(pachHeader[nOffset+1] >= '0' && pachHeader[nOffset+1] <= '9') &&
(pachHeader[nOffset+2] >= '0' && pachHeader[nOffset+2] <= '9') &&
(pachHeader[nOffset+3] >= '0' && pachHeader[nOffset+3] <= '9')));
if (bHasDESOFLW)
{
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 6 + 3 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 6, DESOFLW );
GetMD( 3, DESITEM );
}
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 4 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
nDESSHL = atoi(NITFGetField( szTemp, pachHeader, nOffset, 4));
nOffset += 4;
if (nDESSHL < 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid value for DESSHL");
NITFDESDeaccess(psDES);
return NULL;
}
if ( (int)psSegInfo->nSegmentHeaderSize < nOffset + nDESSHL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
if (EQUALN(szDESID, "CSSHPA DES", strlen("CSSHPA DES")))
{
if ( nDESSHL != 62 && nDESSHL != 80)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid DESSHL for CSSHPA DES");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 25, SHAPE_USE );
GetMD( 10, SHAPE_CLASS );
if (nDESSHL == 80)
GetMD( 18, CC_SOURCE );
GetMD( 3, SHAPE1_NAME );
GetMD( 6, SHAPE1_START );
GetMD( 3, SHAPE2_NAME );
GetMD( 6, SHAPE2_START );
GetMD( 3, SHAPE3_NAME );
GetMD( 6, SHAPE3_START );
}
else if (nDESSHL > 0)
GetMD( nDESSHL, DESSHF );
if ((int)psSegInfo->nSegmentHeaderSize > nOffset)
{
char* pszEscapedDESDATA =
CPLEscapeString( pachHeader + nOffset,
(int)psSegInfo->nSegmentHeaderSize - nOffset,
CPLES_BackslashQuotable );
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA",
pszEscapedDESDATA );
CPLFree(pszEscapedDESDATA);
}
return psDES;
}
NITFDES *NITFDESAccess( NITFFile *psFile, int iSegment )
{
NITFDES *psDES;
char *pachHeader;
NITFSegmentInfo *psSegInfo;
char szDESID[26];
int nOffset;
int bHasDESOFLW;
int nDESSHL;
/* -------------------------------------------------------------------- */
/* Verify segment, and return existing DES accessor if there */
/* is one. */
/* -------------------------------------------------------------------- */
if( iSegment < 0 || iSegment >= psFile->nSegmentCount )
return NULL;
psSegInfo = psFile->pasSegmentInfo + iSegment;
if( !EQUAL(psSegInfo->szSegmentType,"DE") )
return NULL;
if( psSegInfo->hAccess != NULL )
return (NITFDES *) psSegInfo->hAccess;
/* -------------------------------------------------------------------- */
/* Read the DES subheader. */
/* -------------------------------------------------------------------- */
if (psSegInfo->nSegmentHeaderSize < 200)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
return NULL;
}
pachHeader = (char*) VSI_MALLOC_VERBOSE(psSegInfo->nSegmentHeaderSize);
if (pachHeader == NULL)
{
return NULL;
}
retry:
if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart,
SEEK_SET ) != 0
|| VSIFReadL( pachHeader, 1, psSegInfo->nSegmentHeaderSize,
psFile->fp ) != psSegInfo->nSegmentHeaderSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %u byte DES subheader from " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentHeaderSize,
psSegInfo->nSegmentHeaderStart );
CPLFree(pachHeader);
return NULL;
}
if (!STARTS_WITH_CI(pachHeader, "DE"))
{
if (STARTS_WITH_CI(pachHeader + 4, "DERegistered"))
{
/* BAO_46_Ed1/rpf/conc/concz10/000fz010.ona and cie are buggy */
CPLDebug("NITF", "Patching nSegmentHeaderStart and nSegmentStart for DE segment %d", iSegment);
psSegInfo->nSegmentHeaderStart += 4;
psSegInfo->nSegmentStart += 4;
goto retry;
}
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid segment prefix for DE segment %d", iSegment);
CPLFree(pachHeader);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Initialize DES object. */
/* -------------------------------------------------------------------- */
psDES = (NITFDES *) CPLCalloc(sizeof(NITFDES),1);
psDES->psFile = psFile;
psDES->iSegment = iSegment;
psDES->pachHeader = pachHeader;
psSegInfo->hAccess = psDES;
/* -------------------------------------------------------------------- */
/* Collect a variety of information as metadata. */
/* -------------------------------------------------------------------- */
#define GetMD( length, name ) \
do { NITFExtractMetadata( &(psDES->papszMetadata), pachHeader, \
nOffset, length, \
"NITF_" #name ); \
nOffset += length; } while(0)
nOffset = 2;
GetMD( 25, DESID );
GetMD( 2, DESVER );
GetMD( 1, DECLAS );
GetMD( 2, DESCLSY );
GetMD( 11, DESCODE );
GetMD( 2, DESCTLH );
GetMD( 20, DESREL );
GetMD( 2, DESDCTP );
GetMD( 8, DESDCDT );
GetMD( 4, DESDCXM );
GetMD( 1, DESDG );
GetMD( 8, DESDGDT );
GetMD( 43, DESCLTX );
GetMD( 1, DESCATP );
GetMD( 40, DESCAUT );
GetMD( 1, DESCRSN );
GetMD( 8, DESSRDT );
GetMD( 15, DESCTLN );
/* Load DESID */
NITFGetField( szDESID, pachHeader, 2, 25);
/* For NITF < 02.10, we cannot rely on DESID=TRE_OVERFLOW to detect */
/* if DESOFLW and DESITEM are present. So if the next 4 bytes are non */
/* numeric, we'll assume that DESOFLW is there */
bHasDESOFLW = STARTS_WITH_CI(szDESID, "TRE_OVERFLOW") ||
(!((pachHeader[nOffset+0] >= '0' && pachHeader[nOffset+0] <= '9') &&
(pachHeader[nOffset+1] >= '0' && pachHeader[nOffset+1] <= '9') &&
(pachHeader[nOffset+2] >= '0' && pachHeader[nOffset+2] <= '9') &&
(pachHeader[nOffset+3] >= '0' && pachHeader[nOffset+3] <= '9')));
if (bHasDESOFLW)
{
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 6 + 3 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 6, DESOFLW );
GetMD( 3, DESITEM );
}
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 4 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 4, DESSHL );
nDESSHL = atoi(CSLFetchNameValue( psDES->papszMetadata, "NITF_DESSHL" ) );
if (nDESSHL < 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid value for DESSHL");
NITFDESDeaccess(psDES);
return NULL;
}
if ( (int)psSegInfo->nSegmentHeaderSize < nOffset + nDESSHL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
if (STARTS_WITH_CI(szDESID, "CSSHPA DES"))
{
if ( nDESSHL != 62 && nDESSHL != 80)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid DESSHL for CSSHPA DES");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 25, SHAPE_USE );
GetMD( 10, SHAPE_CLASS );
if (nDESSHL == 80)
GetMD( 18, CC_SOURCE );
GetMD( 3, SHAPE1_NAME );
GetMD( 6, SHAPE1_START );
GetMD( 3, SHAPE2_NAME );
GetMD( 6, SHAPE2_START );
GetMD( 3, SHAPE3_NAME );
GetMD( 6, SHAPE3_START );
}
else if (STARTS_WITH_CI(szDESID, "XML_DATA_CONTENT"))
{
/* TODO : handle nDESSHL = 0005 and 0283 */
if (nDESSHL >= 5)
{
GetMD( 5, DESCRC );
if (nDESSHL >= 283)
{
GetMD( 8, DESSHFT );
GetMD( 20, DESSHDT );
GetMD( 40, DESSHRP );
GetMD( 60, DESSHSI );
GetMD( 10, DESSHSV );
GetMD( 20, DESSHSD );
GetMD( 120, DESSHTN );
if (nDESSHL >= 773)
{
GetMD( 125, DESSHLPG );
GetMD( 25, DESSHLPT );
GetMD( 20, DESSHLI );
GetMD( 120, DESSHLIN );
GetMD( 200, DESSHABS );
}
}
}
}
else if (STARTS_WITH_CI(szDESID, "CSATTA DES") && nDESSHL == 52)
{
GetMD( 12, ATT_TYPE );
GetMD( 14, DT_ATT );
GetMD( 8, DATE_ATT );
GetMD( 13, T0_ATT );
GetMD( 5, NUM_ATT );
}
else if (nDESSHL > 0)
GetMD( nDESSHL, DESSHF );
if ((int)psSegInfo->nSegmentHeaderSize > nOffset)
{
char* pszEscapedDESDATA =
CPLEscapeString( pachHeader + nOffset,
(int)psSegInfo->nSegmentHeaderSize - nOffset,
CPLES_BackslashQuotable );
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA",
pszEscapedDESDATA );
CPLFree(pszEscapedDESDATA);
}
else
{
#define TEN_MEGABYTES 10485760
if (psSegInfo->nSegmentSize > TEN_MEGABYTES)
{
const char* pszOffset = CPLSPrintf(CPL_FRMT_GUIB, psFile->pasSegmentInfo[iSegment].nSegmentStart);
const char* pszSize = CPLSPrintf(CPL_FRMT_GUIB, psFile->pasSegmentInfo[iSegment].nSegmentSize);
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA_OFFSET",
pszOffset );
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA_LENGTH",
pszSize);
}
else
{
char* pachData = (char*)VSI_MALLOC_VERBOSE((size_t)psSegInfo->nSegmentSize);
if (pachData == NULL )
{
/* nothing */
}
else if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentStart,
SEEK_SET ) != 0
|| VSIFReadL( pachData, 1, (size_t)psSegInfo->nSegmentSize,
psFile->fp ) != psSegInfo->nSegmentSize )
{
CPLDebug("NITF",
"Failed to read " CPL_FRMT_GUIB" bytes DES data from " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentSize,
psSegInfo->nSegmentStart );
}
else
{
char* pszEscapedDESDATA =
CPLEscapeString( pachData,
(int)psSegInfo->nSegmentSize,
CPLES_BackslashQuotable );
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA",
pszEscapedDESDATA );
CPLFree(pszEscapedDESDATA);
}
CPLFree(pachData);
}
#ifdef notdef
/* Disabled because might generate a huge amount of elements */
if (STARTS_WITH_CI(szDESID, "CSATTA DES"))
{
int nNumAtt = atoi(CSLFetchNameValueDef(psDES->papszMetadata, "NITF_NUM_ATT", "0"));
if (nNumAtt * 8 * 4 == psSegInfo->nSegmentSize)
{
int nMDSize = CSLCount(psDES->papszMetadata);
char** papszMD = (char**)VSIRealloc(psDES->papszMetadata, (nMDSize + nNumAtt * 4 + 1) * sizeof(char*));
if (papszMD)
{
int i, j;
const GByte* pachDataIter = pachData;
psDES->papszMetadata = papszMD;
for(i=0;i<nNumAtt;i++)
{
char szAttrNameValue[64+1+256+1];
double dfVal;
for(j=0;j<4;j++)
{
memcpy(&dfVal, pachDataIter, 8);
CPL_MSBPTR64(&dfVal);
pachDataIter += 8;
CPLsprintf(szAttrNameValue, "NITF_ATT_Q%d_%d=%.16g", j+1, i, dfVal);
papszMD[nMDSize + i * 4 + j] = CPLStrdup(szAttrNameValue);
}
}
papszMD[nMDSize + nNumAtt * 4] = NULL;
}
}
}
#endif
}
return psDES;
}
