Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: NITF Read/Write Library
4 : * Purpose: Module responsible for opening NITF file, populating NITFFile
5 : * structure, and instantiating segment specific access objects.
6 : * Author: Frank Warmerdam, warmerdam@pobox.com
7 : *
8 : **********************************************************************
9 : * Copyright (c) 2002, Frank Warmerdam
10 : * Copyright (c) 2007-2013, Even Rouault <even dot rouault at spatialys.com>
11 : *
12 : * SPDX-License-Identifier: MIT
13 : ****************************************************************************/
14 :
15 : #include "nitflib.h"
16 : #include "cpl_vsi.h"
17 : #include "cpl_conv.h"
18 : #include "cpl_string.h"
19 : #include <stdbool.h>
20 :
21 : #include <map>
22 :
23 : #ifdef EMBED_RESOURCE_FILES
24 : #include "embedded_resources.h"
25 : #endif
26 :
27 : static bool NITFWriteBLOCKA(VSILFILE *fp, vsi_l_offset nOffsetUDIDL,
28 : int *pnOffset, char **papszOptions);
29 : static bool NITFWriteTREsFromOptions(VSILFILE *fp, vsi_l_offset nOffsetUDIDL,
30 : int *pnOffset, char **papszOptions,
31 : const char *pszTREPrefix);
32 :
33 : static int NITFCollectSegmentInfo(NITFFile *psFile, int nFileHeaderLenSize,
34 : int nOffset, const char szType[3],
35 : int nHeaderLenSize, int nDataLenSize,
36 : GUIntBig *pnNextData);
37 :
38 : static void NITFExtractAndRecodeMetadata(char ***ppapszMetadata,
39 : const char *pachHeader, int nStart,
40 : int nLength, const char *pszName,
41 : const char *pszSrcEncoding);
42 :
43 : static bool NITFWriteOption(VSILFILE *fp, char **papszOptions, size_t nWidth,
44 : GUIntBig nLocation, const char *pszName,
45 : const char *pszText);
46 :
47 : /************************************************************************/
48 : /* NITFOpen() */
49 : /************************************************************************/
50 :
51 30 : NITFFile *NITFOpen(const char *pszFilename, int bUpdatable)
52 :
53 : {
54 : VSILFILE *fp;
55 :
56 : /* -------------------------------------------------------------------- */
57 : /* Open the file. */
58 : /* -------------------------------------------------------------------- */
59 30 : if (bUpdatable)
60 14 : fp = VSIFOpenL(pszFilename, "r+b");
61 : else
62 16 : fp = VSIFOpenL(pszFilename, "rb");
63 :
64 30 : if (fp == nullptr)
65 : {
66 0 : CPLError(CE_Failure, CPLE_OpenFailed, "Failed to open file %s.",
67 : pszFilename);
68 0 : return nullptr;
69 : }
70 :
71 30 : return NITFOpenEx(fp, pszFilename);
72 : }
73 :
74 : /************************************************************************/
75 : /* NITFOpenEx() */
76 : /************************************************************************/
77 :
78 640 : NITFFile *NITFOpenEx(VSILFILE *fp, const char *pszFilename)
79 :
80 : {
81 : char *pachHeader;
82 : NITFFile *psFile;
83 : int nHeaderLen, nOffset, nHeaderLenOffset;
84 : GUIntBig nNextData;
85 : char szTemp[128], achFSDWNG[6];
86 : GIntBig currentPos;
87 640 : int bTriedStreamingFileHeader = FALSE;
88 :
89 : /* -------------------------------------------------------------------- */
90 : /* Check file type. */
91 : /* -------------------------------------------------------------------- */
92 1280 : if (VSIFSeekL(fp, 0, SEEK_SET) != 0 || VSIFReadL(szTemp, 1, 9, fp) != 9 ||
93 640 : (!STARTS_WITH_CI(szTemp, "NITF") && !STARTS_WITH_CI(szTemp, "NSIF")))
94 : {
95 0 : CPLError(CE_Failure, CPLE_AppDefined,
96 : "The file %s is not an NITF file.", pszFilename);
97 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
98 0 : return nullptr;
99 : }
100 :
101 : /* -------------------------------------------------------------------- */
102 : /* Read the FSDWNG field. */
103 : /* -------------------------------------------------------------------- */
104 1280 : if (VSIFSeekL(fp, 280, SEEK_SET) != 0 ||
105 640 : VSIFReadL(achFSDWNG, 1, 6, fp) != 6)
106 : {
107 0 : CPLError(CE_Failure, CPLE_NotSupported,
108 : "Unable to read FSDWNG field from NITF file. File is either "
109 : "corrupt\n"
110 : "or empty.");
111 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
112 0 : return nullptr;
113 : }
114 :
115 : /* -------------------------------------------------------------------- */
116 : /* Get header length. */
117 : /* -------------------------------------------------------------------- */
118 640 : if (STARTS_WITH_CI(szTemp, "NITF01.") ||
119 639 : STARTS_WITH_CI(achFSDWNG, "999998"))
120 2 : nHeaderLenOffset = 394;
121 : else
122 638 : nHeaderLenOffset = 354;
123 :
124 1280 : if (VSIFSeekL(fp, nHeaderLenOffset, SEEK_SET) != 0 ||
125 640 : VSIFReadL(szTemp, 1, 6, fp) != 6)
126 : {
127 1 : CPLError(CE_Failure, CPLE_NotSupported,
128 : "Unable to read header length from NITF file. File is either "
129 : "corrupt\n"
130 : "or empty.");
131 1 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
132 1 : return nullptr;
133 : }
134 :
135 639 : szTemp[6] = '\0';
136 639 : nHeaderLen = atoi(szTemp);
137 :
138 639 : if (VSIFSeekL(fp, nHeaderLen, SEEK_SET) != 0)
139 0 : currentPos = 0;
140 : else
141 639 : currentPos = VSIFTellL(fp);
142 639 : if (nHeaderLen < nHeaderLenOffset || nHeaderLen > currentPos)
143 : {
144 0 : CPLError(CE_Failure, CPLE_NotSupported,
145 : "NITF Header Length (%d) seems to be corrupt.", nHeaderLen);
146 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
147 0 : return nullptr;
148 : }
149 :
150 : /* -------------------------------------------------------------------- */
151 : /* Read the whole file header. */
152 : /* -------------------------------------------------------------------- */
153 639 : pachHeader = static_cast<char *>(VSI_MALLOC_VERBOSE(nHeaderLen));
154 639 : if (pachHeader == nullptr)
155 : {
156 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
157 0 : return nullptr;
158 : }
159 1278 : if (VSIFSeekL(fp, 0, SEEK_SET) != 0 ||
160 639 : static_cast<int>(VSIFReadL(pachHeader, 1, nHeaderLen, fp)) !=
161 : nHeaderLen)
162 : {
163 0 : CPLError(CE_Failure, CPLE_FileIO,
164 : "Cannot read %d bytes for NITF header", (nHeaderLen));
165 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
166 0 : CPLFree(pachHeader);
167 0 : return nullptr;
168 : }
169 :
170 : /* -------------------------------------------------------------------- */
171 : /* Create and initialize info structure about file. */
172 : /* -------------------------------------------------------------------- */
173 639 : psFile = static_cast<NITFFile *>(CPLCalloc(sizeof(NITFFile), 1));
174 639 : psFile->fp = fp;
175 639 : psFile->pachHeader = pachHeader;
176 :
177 639 : retry_read_header:
178 : /* -------------------------------------------------------------------- */
179 : /* Get version. */
180 : /* -------------------------------------------------------------------- */
181 639 : NITFGetField(psFile->szVersion, pachHeader, 0, 9);
182 :
183 : /* -------------------------------------------------------------------- */
184 : /* Collect a variety of information as metadata. */
185 : /* -------------------------------------------------------------------- */
186 : #define GetMD(target, hdr, start, length, name) \
187 : NITFExtractMetadata(&(target->papszMetadata), hdr, start, length, \
188 : "NITF_" #name);
189 :
190 639 : if (EQUAL(psFile->szVersion, "NITF02.10") ||
191 57 : EQUAL(psFile->szVersion, "NSIF01.00"))
192 : {
193 : char szWork[100];
194 :
195 608 : GetMD(psFile, pachHeader, 0, 9, FHDR);
196 608 : GetMD(psFile, pachHeader, 9, 2, CLEVEL);
197 608 : GetMD(psFile, pachHeader, 11, 4, STYPE);
198 608 : GetMD(psFile, pachHeader, 15, 10, OSTAID);
199 608 : GetMD(psFile, pachHeader, 25, 14, FDT);
200 608 : GetMD(psFile, pachHeader, 39, 80, FTITLE);
201 608 : GetMD(psFile, pachHeader, 119, 1, FSCLAS);
202 608 : GetMD(psFile, pachHeader, 120, 2, FSCLSY);
203 608 : GetMD(psFile, pachHeader, 122, 11, FSCODE);
204 608 : GetMD(psFile, pachHeader, 133, 2, FSCTLH);
205 608 : GetMD(psFile, pachHeader, 135, 20, FSREL);
206 608 : GetMD(psFile, pachHeader, 155, 2, FSDCTP);
207 608 : GetMD(psFile, pachHeader, 157, 8, FSDCDT);
208 608 : GetMD(psFile, pachHeader, 165, 4, FSDCXM);
209 608 : GetMD(psFile, pachHeader, 169, 1, FSDG);
210 608 : GetMD(psFile, pachHeader, 170, 8, FSDGDT);
211 608 : GetMD(psFile, pachHeader, 178, 43, FSCLTX);
212 608 : GetMD(psFile, pachHeader, 221, 1, FSCATP);
213 608 : GetMD(psFile, pachHeader, 222, 40, FSCAUT);
214 608 : GetMD(psFile, pachHeader, 262, 1, FSCRSN);
215 608 : GetMD(psFile, pachHeader, 263, 8, FSSRDT);
216 608 : GetMD(psFile, pachHeader, 271, 15, FSCTLN);
217 608 : GetMD(psFile, pachHeader, 286, 5, FSCOP);
218 608 : GetMD(psFile, pachHeader, 291, 5, FSCPYS);
219 608 : GetMD(psFile, pachHeader, 296, 1, ENCRYP);
220 608 : snprintf(szWork, sizeof(szWork), "%3d,%3d,%3d",
221 608 : reinterpret_cast<GByte *>(pachHeader)[297],
222 608 : reinterpret_cast<GByte *>(pachHeader)[298],
223 608 : reinterpret_cast<GByte *>(pachHeader)[299]);
224 608 : GetMD(psFile, szWork, 0, 11, FBKGC);
225 608 : GetMD(psFile, pachHeader, 300, 24, ONAME);
226 608 : GetMD(psFile, pachHeader, 324, 18, OPHONE);
227 608 : NITFGetField(szTemp, pachHeader, 342, 12);
228 : }
229 31 : else if (EQUAL(psFile->szVersion, "NITF02.00"))
230 : {
231 30 : int nCOff = 0;
232 :
233 30 : GetMD(psFile, pachHeader, 0, 9, FHDR);
234 30 : GetMD(psFile, pachHeader, 9, 2, CLEVEL);
235 30 : GetMD(psFile, pachHeader, 11, 4, STYPE);
236 30 : GetMD(psFile, pachHeader, 15, 10, OSTAID);
237 30 : GetMD(psFile, pachHeader, 25, 14, FDT);
238 30 : GetMD(psFile, pachHeader, 39, 80, FTITLE);
239 30 : GetMD(psFile, pachHeader, 119, 1, FSCLAS);
240 30 : GetMD(psFile, pachHeader, 120, 40, FSCODE);
241 30 : GetMD(psFile, pachHeader, 160, 40, FSCTLH);
242 30 : GetMD(psFile, pachHeader, 200, 40, FSREL);
243 30 : GetMD(psFile, pachHeader, 240, 20, FSCAUT);
244 30 : GetMD(psFile, pachHeader, 260, 20, FSCTLN);
245 30 : GetMD(psFile, pachHeader, 280, 6, FSDWNG);
246 30 : if (STARTS_WITH_CI(pachHeader + 280, "999998"))
247 : {
248 1 : GetMD(psFile, pachHeader, 286, 40, FSDEVT);
249 1 : nCOff += 40;
250 : }
251 30 : GetMD(psFile, pachHeader, 286 + nCOff, 5, FSCOP);
252 30 : GetMD(psFile, pachHeader, 291 + nCOff, 5, FSCPYS);
253 30 : GetMD(psFile, pachHeader, 296 + nCOff, 1, ENCRYP);
254 30 : GetMD(psFile, pachHeader, 297 + nCOff, 27, ONAME);
255 30 : GetMD(psFile, pachHeader, 324 + nCOff, 18, OPHONE);
256 30 : NITFGetField(szTemp, pachHeader, 342 + nCOff, 12);
257 : }
258 : #undef GetMD
259 :
260 639 : if (!bTriedStreamingFileHeader && EQUAL(szTemp, "999999999999"))
261 : {
262 : GUIntBig nFileSize;
263 0 : GByte abyDELIM2_L2[12] = {0};
264 0 : GByte abyL1_DELIM1[11] = {0};
265 : bool bOK;
266 :
267 0 : bTriedStreamingFileHeader = TRUE;
268 0 : CPLDebug("NITF",
269 : "Total file unknown. Trying to get a STREAMING_FILE_HEADER");
270 :
271 0 : bOK = VSIFSeekL(fp, 0, SEEK_END) == 0;
272 0 : nFileSize = VSIFTellL(fp);
273 :
274 0 : bOK &= VSIFSeekL(fp, nFileSize - 11, SEEK_SET) == 0;
275 0 : abyDELIM2_L2[11] = '\0';
276 :
277 0 : if (bOK && VSIFReadL(abyDELIM2_L2, 1, 11, fp) == 11 &&
278 0 : abyDELIM2_L2[0] == 0x0E && abyDELIM2_L2[1] == 0xCA &&
279 0 : abyDELIM2_L2[2] == 0x14 && abyDELIM2_L2[3] == 0xBF)
280 : {
281 : int SFHL2 =
282 0 : atoi(reinterpret_cast<const char *>((abyDELIM2_L2 + 4)));
283 0 : if (SFHL2 > 0 && (nFileSize > static_cast<size_t>(11 + SFHL2 + 11)))
284 : {
285 0 : bOK &=
286 0 : VSIFSeekL(fp, nFileSize - 11 - SFHL2 - 11, SEEK_SET) == 0;
287 :
288 0 : if (bOK && VSIFReadL(abyL1_DELIM1, 1, 11, fp) == 11 &&
289 0 : abyL1_DELIM1[7] == 0x0A && abyL1_DELIM1[8] == 0x6E &&
290 0 : abyL1_DELIM1[9] == 0x1D && abyL1_DELIM1[10] == 0x97 &&
291 0 : memcmp(abyL1_DELIM1, abyDELIM2_L2 + 4, 7) == 0)
292 : {
293 0 : if (SFHL2 == nHeaderLen)
294 : {
295 0 : CSLDestroy(psFile->papszMetadata);
296 0 : psFile->papszMetadata = nullptr;
297 :
298 0 : if (static_cast<int>(
299 0 : VSIFReadL(pachHeader, 1, SFHL2, fp)) != SFHL2)
300 : {
301 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
302 0 : CPLFree(pachHeader);
303 0 : CPLFree(psFile);
304 0 : return nullptr;
305 : }
306 :
307 0 : goto retry_read_header;
308 : }
309 : }
310 : }
311 : }
312 0 : if (!bOK)
313 : {
314 0 : NITFClose(psFile);
315 0 : return nullptr;
316 : }
317 : }
318 :
319 : /* -------------------------------------------------------------------- */
320 : /* Collect segment info for the types we care about. */
321 : /* -------------------------------------------------------------------- */
322 639 : nNextData = nHeaderLen;
323 :
324 639 : nOffset = nHeaderLenOffset + 6;
325 :
326 639 : nOffset = NITFCollectSegmentInfo(psFile, nHeaderLen, nOffset, "IM", 6, 10,
327 : &nNextData);
328 :
329 639 : if (nOffset != -1)
330 639 : nOffset = NITFCollectSegmentInfo(psFile, nHeaderLen, nOffset, "GR", 4,
331 : 6, &nNextData);
332 :
333 : /* LA Called NUMX in NITF 2.1 */
334 639 : if (nOffset != -1)
335 639 : nOffset = NITFCollectSegmentInfo(psFile, nHeaderLen, nOffset, "LA", 4,
336 : 3, &nNextData);
337 :
338 639 : if (nOffset != -1)
339 639 : nOffset = NITFCollectSegmentInfo(psFile, nHeaderLen, nOffset, "TX", 4,
340 : 5, &nNextData);
341 :
342 639 : if (nOffset != -1)
343 639 : nOffset = NITFCollectSegmentInfo(psFile, nHeaderLen, nOffset, "DE", 4,
344 : 9, &nNextData);
345 :
346 639 : if (nOffset != -1)
347 639 : nOffset = NITFCollectSegmentInfo(psFile, nHeaderLen, nOffset, "RE", 4,
348 : 7, &nNextData);
349 :
350 639 : if (nOffset < 0)
351 : {
352 1 : NITFClose(psFile);
353 1 : return nullptr;
354 : }
355 :
356 : /* -------------------------------------------------------------------- */
357 : /* Is there User Define Header Data? (TREs) */
358 : /* -------------------------------------------------------------------- */
359 638 : if (nHeaderLen < nOffset + 5)
360 : {
361 0 : CPLError(CE_Failure, CPLE_AppDefined, "NITF header too small");
362 0 : NITFClose(psFile);
363 0 : return nullptr;
364 : }
365 :
366 638 : psFile->nTREBytes = atoi(NITFGetField(szTemp, pachHeader, nOffset, 5));
367 638 : if (psFile->nTREBytes < 0)
368 : {
369 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid TRE size : %d",
370 : psFile->nTREBytes);
371 0 : NITFClose(psFile);
372 0 : return nullptr;
373 : }
374 638 : nOffset += 5;
375 :
376 638 : if (psFile->nTREBytes == 3)
377 : {
378 0 : nOffset += 3; /* UDHOFL */
379 0 : psFile->nTREBytes = 0;
380 : }
381 638 : else if (psFile->nTREBytes > 3)
382 : {
383 25 : nOffset += 3; /* UDHOFL */
384 25 : psFile->nTREBytes -= 3;
385 :
386 25 : if (nHeaderLen < nOffset + psFile->nTREBytes)
387 : {
388 0 : CPLError(CE_Failure, CPLE_AppDefined, "NITF header too small");
389 0 : NITFClose(psFile);
390 0 : return nullptr;
391 : }
392 :
393 25 : psFile->pachTRE =
394 25 : static_cast<char *>(VSI_MALLOC_VERBOSE(psFile->nTREBytes));
395 25 : if (psFile->pachTRE == nullptr)
396 : {
397 0 : NITFClose(psFile);
398 0 : return nullptr;
399 : }
400 25 : memcpy(psFile->pachTRE, pachHeader + nOffset, psFile->nTREBytes);
401 25 : nOffset += psFile->nTREBytes;
402 : }
403 :
404 : /* -------------------------------------------------------------------- */
405 : /* Is there Extended Header Data? (More TREs) */
406 : /* -------------------------------------------------------------------- */
407 638 : if (nHeaderLen > nOffset + 8)
408 : {
409 35 : int nXHDL = atoi(NITFGetField(szTemp, pachHeader, nOffset, 5));
410 35 : if (nXHDL < 0)
411 : {
412 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid XHDL value : %d",
413 : nXHDL);
414 0 : NITFClose(psFile);
415 0 : return nullptr;
416 : }
417 :
418 35 : nOffset += 5; /* XHDL */
419 :
420 35 : if (nXHDL > 3)
421 : {
422 : char *pachNewTRE;
423 :
424 11 : nOffset += 3; /* XHDLOFL */
425 11 : nXHDL -= 3;
426 :
427 11 : if (nHeaderLen < nOffset + nXHDL)
428 : {
429 0 : CPLError(CE_Failure, CPLE_AppDefined, "NITF header too small");
430 0 : NITFClose(psFile);
431 0 : return nullptr;
432 : }
433 :
434 11 : pachNewTRE = static_cast<char *>(VSI_REALLOC_VERBOSE(
435 : psFile->pachTRE, psFile->nTREBytes + nXHDL));
436 11 : if (pachNewTRE == nullptr)
437 : {
438 0 : NITFClose(psFile);
439 0 : return nullptr;
440 : }
441 11 : psFile->pachTRE = pachNewTRE;
442 11 : memcpy(psFile->pachTRE + psFile->nTREBytes, pachHeader + nOffset,
443 : nXHDL);
444 11 : psFile->nTREBytes += nXHDL;
445 : }
446 : }
447 :
448 638 : return psFile;
449 : }
450 :
451 : /************************************************************************/
452 : /* NITFClose() */
453 : /************************************************************************/
454 :
455 639 : bool NITFClose(NITFFile *psFile)
456 :
457 : {
458 639 : bool ret = true;
459 : int iSegment;
460 :
461 10352 : for (iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++)
462 : {
463 9713 : NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
464 :
465 9713 : if (psSegInfo->hAccess == nullptr)
466 1097 : continue;
467 :
468 8616 : if (EQUAL(psSegInfo->szSegmentType, "IM"))
469 8616 : NITFImageDeaccess(static_cast<NITFImage *>(psSegInfo->hAccess));
470 0 : else if (EQUAL(psSegInfo->szSegmentType, "DE"))
471 0 : NITFDESDeaccess(static_cast<NITFDES *>(psSegInfo->hAccess));
472 : else
473 : {
474 0 : CPLAssert(FALSE);
475 : }
476 : }
477 :
478 639 : CPLFree(psFile->pasSegmentInfo);
479 639 : if (psFile->fp != nullptr)
480 631 : ret = VSIFCloseL(psFile->fp) == 0;
481 639 : CPLFree(psFile->pachHeader);
482 639 : CSLDestroy(psFile->papszMetadata);
483 639 : CPLFree(psFile->pachTRE);
484 :
485 639 : if (psFile->psNITFSpecNode)
486 615 : CPLDestroyXMLNode(psFile->psNITFSpecNode);
487 :
488 639 : CPLFree(psFile);
489 639 : return ret;
490 : }
491 :
492 291370 : static bool NITFGotoOffset(VSILFILE *fp, GUIntBig nLocation)
493 : {
494 291370 : bool bOK = true;
495 291370 : GUIntBig nCurrentLocation = VSIFTellL(fp);
496 291370 : if (nLocation > nCurrentLocation)
497 : {
498 : GUIntBig nFileSize;
499 : size_t iFill;
500 175015 : char cSpace = ' ';
501 :
502 175015 : bOK &= VSIFSeekL(fp, 0, SEEK_END) == 0;
503 175015 : nFileSize = VSIFTellL(fp);
504 175015 : if (bOK && nLocation > nFileSize)
505 : {
506 1353680 : for (iFill = 0; bOK && iFill < nLocation - nFileSize; iFill++)
507 1179430 : bOK &= VSIFWriteL(&cSpace, 1, 1, fp) == 1;
508 : }
509 : else
510 762 : bOK &= VSIFSeekL(fp, nLocation, SEEK_SET) == 0;
511 : }
512 116355 : else if (nLocation < nCurrentLocation)
513 : {
514 2087 : bOK &= VSIFSeekL(fp, nLocation, SEEK_SET) == 0;
515 : }
516 291370 : if (!bOK)
517 : {
518 522 : CPLError(CE_Failure, CPLE_FileIO, "I/O error");
519 : }
520 291370 : return bOK;
521 : }
522 :
523 : /************************************************************************/
524 : /* NITFCreate() */
525 : /* */
526 : /* Create a new uncompressed NITF file. */
527 : /************************************************************************/
528 :
529 0 : int NITFCreate(const char *pszFilename, int nPixels, int nLines, int nBands,
530 : int nBitsPerSample, const char *pszPVType, char **papszOptions)
531 :
532 : {
533 0 : return NITFCreateEx(pszFilename, nPixels, nLines, nBands, nBitsPerSample,
534 : pszPVType, papszOptions, nullptr, nullptr, nullptr,
535 0 : nullptr);
536 : }
537 :
538 262 : int NITFCreateEx(const char *pszFilename, int nPixels, int nLines, int nBands,
539 : int nBitsPerSample, const char *pszPVType, char **papszOptions,
540 : int *pnIndex, int *pnImageCount, vsi_l_offset *pnImageOffset,
541 : vsi_l_offset *pnICOffset)
542 :
543 : {
544 : VSILFILE *fp;
545 262 : GUIntBig nCur = 0;
546 262 : int nOffset = 0, iBand, nIHSize, nNPPBH, nNPPBV;
547 262 : GUIntBig nImageSize = 0;
548 : int nNBPR, nNBPC;
549 : const char *pszIREP;
550 262 : const char *pszIC = CSLFetchNameValue(papszOptions, "IC");
551 : int nCLevel;
552 : const char *pszNUMT;
553 262 : int nNUMT = 0;
554 : vsi_l_offset nOffsetUDIDL;
555 : const char *pszVersion;
556 262 : int iIM, nIM = 1;
557 : const char *pszNUMI;
558 262 : int iGS, nGS = 0; // number of graphic segment
559 : const char *pszNUMS; // graphic segment option string
560 262 : int iDES, nDES = 0;
561 : bool bOK;
562 :
563 262 : if (pnIndex)
564 262 : *pnIndex = 0;
565 :
566 262 : if (nBands <= 0 || nBands > 99999)
567 : {
568 1 : CPLError(CE_Failure, CPLE_NotSupported, "Invalid band number : %d",
569 : nBands);
570 1 : return FALSE;
571 : }
572 :
573 261 : if (pszIC == nullptr)
574 238 : pszIC = "NC";
575 :
576 : /* -------------------------------------------------------------------- */
577 : /* Fetch some parameter overrides. */
578 : /* -------------------------------------------------------------------- */
579 261 : pszIREP = CSLFetchNameValue(papszOptions, "IREP");
580 261 : if (pszIREP == nullptr)
581 153 : pszIREP = "MONO";
582 :
583 261 : pszNUMT = CSLFetchNameValue(papszOptions, "NUMT");
584 261 : if (pszNUMT != nullptr)
585 : {
586 4 : nNUMT = atoi(pszNUMT);
587 4 : if (nNUMT < 0 || nNUMT > 999)
588 : {
589 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid NUMT value : %s",
590 : pszNUMT);
591 0 : return FALSE;
592 : }
593 : }
594 :
595 : const bool bAppendSubdataset =
596 261 : CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "APPEND_SUBDATASET",
597 261 : "NO")) == TRUE;
598 : const bool bWriteAllImages =
599 261 : CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "WRITE_ALL_IMAGES",
600 261 : "NO")) == TRUE;
601 261 : pszNUMI = CSLFetchNameValue(papszOptions, "NUMI");
602 261 : if (pszNUMI != nullptr)
603 : {
604 7 : if (bAppendSubdataset)
605 : {
606 0 : CPLError(CE_Failure, CPLE_NotSupported,
607 : "NUMI not supported with APPEND_SUBDATASET");
608 0 : return FALSE;
609 : }
610 7 : nIM = atoi(pszNUMI);
611 7 : if (nIM == 0)
612 : {
613 1 : if (pnIndex)
614 1 : *pnIndex = -1;
615 : }
616 6 : else if (nIM < 0 || nIM > 999)
617 : {
618 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid NUMI value : %s",
619 : pszNUMI);
620 0 : return FALSE;
621 : }
622 7 : if (nIM != 1 && !EQUAL(pszIC, "NC") && bWriteAllImages)
623 : {
624 0 : CPLError(CE_Failure, CPLE_AppDefined,
625 : "Unable to create file with multiple images and "
626 : "compression at the same time");
627 0 : return FALSE;
628 : }
629 : }
630 254 : else if (bAppendSubdataset && bWriteAllImages)
631 : {
632 0 : CPLError(CE_Warning, CPLE_AppDefined,
633 : "WRITE_ALL_IMAGES=YES only supported for first image");
634 : }
635 :
636 261 : if (pnImageCount)
637 261 : *pnImageCount = nIM;
638 :
639 : // Reads and validates graphics segment number option
640 261 : pszNUMS = CSLFetchNameValue(papszOptions, "NUMS");
641 261 : if (pszNUMS != nullptr)
642 : {
643 12 : nGS = atoi(pszNUMS);
644 12 : if (nGS < 0 || nGS > 999)
645 : {
646 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid NUMS value : %s",
647 : pszNUMS);
648 0 : return FALSE;
649 : }
650 : }
651 :
652 261 : const char *pszNUMDES = CSLFetchNameValue(papszOptions, "NUMDES");
653 261 : if (pszNUMDES)
654 2 : nDES = atoi(pszNUMDES);
655 : else
656 : {
657 259 : char **papszSubList = CSLFetchNameValueMultiple(papszOptions, "DES");
658 259 : nDES = CSLCount(papszSubList);
659 259 : CSLDestroy(papszSubList);
660 : }
661 :
662 : /* -------------------------------------------------------------------- */
663 : /* Compute raw image size, blocking factors and so forth. */
664 : /* -------------------------------------------------------------------- */
665 261 : nNPPBH = nPixels;
666 261 : nNPPBV = nLines;
667 :
668 261 : if (CSLFetchNameValue(papszOptions, "BLOCKXSIZE") != nullptr)
669 19 : nNPPBH = atoi(CSLFetchNameValue(papszOptions, "BLOCKXSIZE"));
670 :
671 261 : if (CSLFetchNameValue(papszOptions, "BLOCKYSIZE") != nullptr)
672 17 : nNPPBV = atoi(CSLFetchNameValue(papszOptions, "BLOCKYSIZE"));
673 :
674 261 : if (CSLFetchNameValue(papszOptions, "NPPBH") != nullptr)
675 0 : nNPPBH = atoi(CSLFetchNameValue(papszOptions, "NPPBH"));
676 :
677 261 : if (CSLFetchNameValue(papszOptions, "NPPBV") != nullptr)
678 0 : nNPPBV = atoi(CSLFetchNameValue(papszOptions, "NPPBV"));
679 :
680 261 : if ((EQUAL(pszIC, "NC") || EQUAL(pszIC, "C8")) &&
681 251 : (nPixels > 8192 || nLines > 8192) && nNPPBH == nPixels &&
682 : nNPPBV == nLines)
683 : {
684 : /* See MIL-STD-2500-C, paragraph 5.4.2.2-d (#3263) */
685 4 : nNBPR = 1;
686 4 : nNBPC = 1;
687 4 : nNPPBH = 0;
688 4 : nNPPBV = 0;
689 :
690 4 : if (EQUAL(pszIC, "NC"))
691 : {
692 4 : nImageSize = ((nBitsPerSample) / 8) *
693 4 : (static_cast<GUIntBig>(nPixels) * nLines) * nBands;
694 : }
695 : }
696 257 : else if ((EQUAL(pszIC, "NC") || EQUAL(pszIC, "C8")) && nPixels > 8192 &&
697 : nNPPBH == nPixels)
698 : {
699 0 : if (nNPPBV <= 0)
700 0 : nNPPBV = 256;
701 :
702 : /* See MIL-STD-2500-C, paragraph 5.4.2.2-d */
703 0 : nNBPR = 1;
704 0 : nNPPBH = 0;
705 0 : nNBPC = nLines / nNPPBV + ((nLines % nNPPBV) == 0 ? 0 : 1);
706 :
707 0 : if (nNBPC > 9999)
708 : {
709 0 : CPLError(CE_Failure, CPLE_AppDefined,
710 : "Unable to create file %s,\n"
711 : "Too many blocks : %d x %d",
712 : pszFilename, nNBPR, nNBPC);
713 0 : return FALSE;
714 : }
715 :
716 0 : if (EQUAL(pszIC, "NC"))
717 : {
718 0 : nImageSize = ((nBitsPerSample) / 8) *
719 0 : (static_cast<GUIntBig>(nPixels) * (nNBPC * nNPPBV)) *
720 0 : nBands;
721 : }
722 : }
723 257 : else if ((EQUAL(pszIC, "NC") || EQUAL(pszIC, "C8")) && nLines > 8192 &&
724 : nNPPBV == nLines)
725 : {
726 1 : if (nNPPBH <= 0)
727 0 : nNPPBH = 256;
728 :
729 : /* See MIL-STD-2500-C, paragraph 5.4.2.2-d */
730 1 : nNBPC = 1;
731 1 : nNPPBV = 0;
732 1 : nNBPR = nPixels / nNPPBH + ((nPixels % nNPPBH) == 0 ? 0 : 1);
733 :
734 1 : if (nNBPR > 9999)
735 : {
736 0 : CPLError(CE_Failure, CPLE_AppDefined,
737 : "Unable to create file %s,\n"
738 : "Too many blocks : %d x %d",
739 : pszFilename, nNBPR, nNBPC);
740 0 : return FALSE;
741 : }
742 :
743 1 : if (EQUAL(pszIC, "NC"))
744 : {
745 1 : nImageSize = ((nBitsPerSample) / 8) *
746 1 : (static_cast<GUIntBig>(nLines) * (nNBPR * nNPPBH)) *
747 1 : nBands;
748 : }
749 : }
750 : else
751 : {
752 256 : if (nNPPBH <= 0 || nNPPBV <= 0 || nNPPBH > 9999 || nNPPBV > 9999)
753 1 : nNPPBH = nNPPBV = 256;
754 :
755 256 : nNBPR = nPixels / nNPPBH + ((nPixels % nNPPBH) == 0 ? 0 : 1);
756 256 : nNBPC = nLines / nNPPBV + ((nLines % nNPPBV) == 0 ? 0 : 1);
757 256 : if (nNBPR > 9999 || nNBPC > 9999)
758 : {
759 0 : CPLError(CE_Failure, CPLE_AppDefined,
760 : "Unable to create file %s,\n"
761 : "Too many blocks : %d x %d",
762 : pszFilename, nNBPR, nNBPC);
763 0 : return FALSE;
764 : }
765 :
766 256 : if (EQUAL(pszIC, "NC"))
767 : {
768 234 : nImageSize = ((nBitsPerSample) / 8) *
769 234 : (static_cast<GUIntBig>(nNBPR) * nNBPC) * nNPPBH *
770 234 : nNPPBV * nBands;
771 : }
772 : }
773 :
774 261 : if (EQUAL(pszIC, "NC"))
775 : {
776 239 : if (nImageSize >= NITF_MAX_IMAGE_SIZE)
777 : {
778 1 : CPLError(CE_Failure, CPLE_AppDefined,
779 : "Unable to create file %s,\n"
780 : "Too big image size : " CPL_FRMT_GUIB,
781 : pszFilename, nImageSize);
782 1 : return FALSE;
783 : }
784 238 : if (nImageSize * nIM >= NITF_MAX_FILE_SIZE)
785 : {
786 1 : CPLError(CE_Failure, CPLE_AppDefined,
787 : "Unable to create file %s,\n"
788 : "Too big file size : " CPL_FRMT_GUIB,
789 1 : pszFilename, nImageSize * nIM);
790 1 : return FALSE;
791 : }
792 : }
793 :
794 : /* -------------------------------------------------------------------- */
795 : /* Open new file. */
796 : /* -------------------------------------------------------------------- */
797 259 : fp = VSIFOpenL(pszFilename, bAppendSubdataset ? "rb+" : "wb+");
798 259 : if (fp == nullptr)
799 : {
800 3 : CPLError(CE_Failure, CPLE_OpenFailed,
801 : "Unable to create file %s,\n"
802 : "check path and permissions.",
803 : pszFilename);
804 3 : return FALSE;
805 : }
806 :
807 : /* -------------------------------------------------------------------- */
808 : /* Work out the version we are producing. For now we really */
809 : /* only support creating NITF02.10 or the nato analog */
810 : /* NSIF01.00. */
811 : /* -------------------------------------------------------------------- */
812 256 : pszVersion = CSLFetchNameValue(papszOptions, "FHDR");
813 256 : if (pszVersion == nullptr)
814 246 : pszVersion = "NITF02.10";
815 10 : else if (!EQUAL(pszVersion, "NITF02.10") && !EQUAL(pszVersion, "NSIF01.00"))
816 : {
817 0 : CPLError(CE_Warning, CPLE_AppDefined,
818 : "FHDR=%s not supported, switching to NITF02.10.", pszVersion);
819 0 : pszVersion = "NITF02.10";
820 : }
821 :
822 : /* -------------------------------------------------------------------- */
823 : /* Prepare the file header. */
824 : /* -------------------------------------------------------------------- */
825 :
826 256 : bOK = VSIFSeekL(fp, 0, SEEK_SET) == 0;
827 :
828 : #define PLACE(location, name, text) \
829 : do \
830 : { \
831 : const char *_text = text; \
832 : bOK &= NITFGotoOffset(fp, location); \
833 : bOK &= VSIFWriteL(_text, 1, strlen(_text), fp) == strlen(_text); \
834 : } while (0)
835 :
836 : #define OVR(width, location, name, text) \
837 : bOK &= NITFWriteOption(fp, papszOptions, width, location, #name, text);
838 :
839 : #define WRITE_BYTE(location, val) \
840 : do \
841 : { \
842 : char cVal = val; \
843 : bOK &= NITFGotoOffset(fp, location); \
844 : bOK &= VSIFWriteL(&cVal, 1, 1, fp) == 1; \
845 : } while (0)
846 :
847 256 : if (!bAppendSubdataset)
848 : {
849 251 : PLACE(0, FDHR_FVER, pszVersion);
850 251 : OVR(2, 9, CLEVEL, "03"); /* Patched at the end */
851 251 : PLACE(11, STYPE, "BF01");
852 251 : OVR(10, 15, OSTAID, "GDAL");
853 251 : OVR(14, 25, FDT, "20021216151629");
854 251 : OVR(80, 39, FTITLE, "");
855 251 : OVR(1, 119, FSCLAS, "U");
856 251 : OVR(2, 120, FSCLSY, "");
857 251 : OVR(11, 122, FSCODE, "");
858 251 : OVR(2, 133, FSCTLH, "");
859 251 : OVR(20, 135, FSREL, "");
860 251 : OVR(2, 155, FSDCTP, "");
861 251 : OVR(8, 157, FSDCDT, "");
862 251 : OVR(4, 165, FSDCXM, "");
863 251 : OVR(1, 169, FSDG, "");
864 251 : OVR(8, 170, FSDGDT, "");
865 251 : OVR(43, 178, FSCLTX, "");
866 251 : OVR(1, 221, FSCATP, "");
867 251 : OVR(40, 222, FSCAUT, "");
868 251 : OVR(1, 262, FSCRSN, "");
869 251 : OVR(8, 263, FSSRDT, "");
870 251 : OVR(15, 271, FSCTLN, "");
871 251 : OVR(5, 286, FSCOP, "00000");
872 251 : OVR(5, 291, FSCPYS, "00000");
873 251 : PLACE(296, ENCRYP, "0");
874 251 : WRITE_BYTE(297, 0x00); /* FBKGC */
875 251 : WRITE_BYTE(298, 0x00);
876 251 : WRITE_BYTE(299, 0x00);
877 251 : OVR(24, 300, ONAME, "");
878 251 : OVR(18, 324, OPHONE, "");
879 251 : PLACE(342, FL, "????????????");
880 251 : PLACE(354, HL, "??????");
881 251 : PLACE(360, NUMI, CPLSPrintf("%03d", nIM));
882 :
883 251 : int nHL = 363;
884 1504 : for (iIM = 0; iIM < nIM; iIM++)
885 : {
886 : /* Patched when image segments are written. */
887 1253 : PLACE(nHL, LISHi, "??????");
888 1253 : PLACE(nHL + 6, LIi, "??????????");
889 1253 : nHL += 6 + 10;
890 : }
891 :
892 : // Creates Header entries for graphic segment
893 : // NUMS: number of segment
894 : // For each segment:
895 : // LSSH[i]: subheader length (4 byte), set to be 258, the size for
896 : // minimal amount of information.
897 : // LS[i] data length (6 byte)
898 251 : PLACE(nHL, NUMS, CPLSPrintf("%03d", nGS));
899 251 : nHL += 3; // Move three characters
900 254 : for (iGS = 0; iGS < nGS; iGS++)
901 : {
902 : /* Patched when graphic segments are written. */
903 3 : PLACE(nHL, LSSHi, "????");
904 3 : nHL += 4;
905 3 : PLACE(nHL, LSi, "??????");
906 3 : nHL += 6;
907 : }
908 :
909 251 : PLACE(nHL, NUMX, "000");
910 251 : PLACE(nHL + 3, NUMT, CPLSPrintf("%03d", nNUMT));
911 :
912 : /* Patched when text segments are written. */
913 251 : PLACE(nHL + 6, LTSHnLTn, "");
914 :
915 251 : nHL += 6 + (4 + 5) * nNUMT;
916 :
917 251 : PLACE(nHL, NUMDES, CPLSPrintf("%03d", nDES));
918 251 : nHL += 3;
919 :
920 263 : for (iDES = 0; iDES < nDES; iDES++)
921 : {
922 : /* Patched when DESs are written. */
923 12 : PLACE(nHL, LDSH, "????");
924 12 : nHL += 4;
925 12 : PLACE(nHL, LD, "?????????");
926 12 : nHL += 9;
927 : }
928 :
929 251 : PLACE(nHL, NUMRES, "000");
930 251 : nHL += 3;
931 251 : PLACE(nHL, UDHDL, "00000");
932 251 : nHL += 5;
933 251 : PLACE(nHL, XHDL, "00000");
934 251 : nHL += 5;
935 :
936 251 : if (CSLFetchNameValue(papszOptions, "FILE_TRE") != nullptr)
937 : {
938 5 : bOK &= NITFWriteTREsFromOptions(fp, nHL - 10, &nHL, papszOptions,
939 5 : "FILE_TRE=");
940 : }
941 :
942 251 : if (nHL > 999999)
943 : {
944 0 : CPLError(CE_Failure, CPLE_AppDefined,
945 : "Too big file header length : %d", nHL);
946 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
947 0 : return FALSE;
948 : }
949 :
950 : // update header length
951 251 : PLACE(354, HL, CPLSPrintf("%06d", nHL));
952 :
953 251 : nCur = nHL;
954 251 : iIM = 0;
955 : }
956 : else
957 : {
958 : // Append subdataset
959 5 : NITFFile *psFile = NITFOpenEx(fp, pszFilename);
960 5 : if (psFile == nullptr)
961 0 : return FALSE;
962 :
963 5 : iIM = -1;
964 5 : nIM = 0;
965 20 : for (int i = 0; i < psFile->nSegmentCount; i++)
966 : {
967 15 : if (strcmp(psFile->pasSegmentInfo[i].szSegmentType, "IM") == 0)
968 : {
969 12 : nIM++;
970 12 : if (psFile->pasSegmentInfo[i].nSegmentHeaderSize == 0 &&
971 : iIM < 0)
972 : {
973 5 : iIM = i;
974 5 : if (pnIndex)
975 5 : *pnIndex = i;
976 : }
977 : }
978 : }
979 5 : if (pnImageCount)
980 5 : *pnImageCount = nIM;
981 :
982 5 : psFile->fp = nullptr;
983 5 : NITFClose(psFile);
984 :
985 5 : if (iIM < 0)
986 : {
987 0 : CPLError(CE_Failure, CPLE_AppDefined,
988 : "Did not find free image segment");
989 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
990 0 : return FALSE;
991 : }
992 5 : nIM = iIM + 1;
993 :
994 5 : bOK &= VSIFSeekL(fp, 0, SEEK_END) == 0;
995 5 : nCur = VSIFTellL(fp);
996 : }
997 :
998 : /* -------------------------------------------------------------------- */
999 : /* Prepare the image header. */
1000 : /* -------------------------------------------------------------------- */
1001 1255 : for (; iIM < nIM; iIM++)
1002 : {
1003 1253 : char **papszIREPBANDTokens = nullptr;
1004 1253 : char **papszISUBCATTokens = nullptr;
1005 :
1006 1253 : if (CSLFetchNameValue(papszOptions, "IREPBAND") != nullptr)
1007 : {
1008 2 : papszIREPBANDTokens = CSLTokenizeStringComplex(
1009 : CSLFetchNameValue(papszOptions, "IREPBAND"), ",", 0, 0);
1010 4 : if (papszIREPBANDTokens != nullptr &&
1011 2 : CSLCount(papszIREPBANDTokens) != nBands)
1012 : {
1013 0 : CSLDestroy(papszIREPBANDTokens);
1014 0 : papszIREPBANDTokens = nullptr;
1015 : }
1016 : }
1017 1253 : if (CSLFetchNameValue(papszOptions, "ISUBCAT") != nullptr)
1018 : {
1019 1 : papszISUBCATTokens = CSLTokenizeStringComplex(
1020 : CSLFetchNameValue(papszOptions, "ISUBCAT"), ",", 0, 0);
1021 2 : if (papszISUBCATTokens != nullptr &&
1022 1 : CSLCount(papszISUBCATTokens) != nBands)
1023 : {
1024 0 : CSLDestroy(papszISUBCATTokens);
1025 0 : papszISUBCATTokens = nullptr;
1026 : }
1027 : }
1028 :
1029 1253 : bOK &= VSIFSeekL(fp, nCur, SEEK_SET) == 0;
1030 :
1031 1253 : PLACE(nCur + 0, IM, "IM");
1032 1253 : OVR(10, nCur + 2, IID1, "Missing");
1033 1253 : OVR(14, nCur + 12, IDATIM, "20021216151629");
1034 1253 : OVR(17, nCur + 26, TGTID, "");
1035 1253 : OVR(80, nCur + 43, IID2, "");
1036 1253 : OVR(1, nCur + 123, ISCLAS, "U");
1037 1253 : OVR(2, nCur + 124, ISCLSY, "");
1038 1253 : OVR(11, nCur + 126, ISCODE, "");
1039 1253 : OVR(2, nCur + 137, ISCTLH, "");
1040 1253 : OVR(20, nCur + 139, ISREL, "");
1041 1253 : OVR(2, nCur + 159, ISDCTP, "");
1042 1253 : OVR(8, nCur + 161, ISDCDT, "");
1043 1253 : OVR(4, nCur + 169, ISDCXM, "");
1044 1253 : OVR(1, nCur + 173, ISDG, "");
1045 1253 : OVR(8, nCur + 174, ISDGDT, "");
1046 1253 : OVR(43, nCur + 182, ISCLTX, "");
1047 1253 : OVR(1, nCur + 225, ISCATP, "");
1048 1253 : OVR(40, nCur + 226, ISCAUT, "");
1049 1253 : OVR(1, nCur + 266, ISCRSN, "");
1050 1253 : OVR(8, nCur + 267, ISSRDT, "");
1051 1253 : OVR(15, nCur + 275, ISCTLN, "");
1052 1253 : PLACE(nCur + 290, ENCRYP, "0");
1053 1253 : OVR(42, nCur + 291, ISORCE, "Unknown");
1054 1253 : PLACE(nCur + 333, NROWS, CPLSPrintf("%08d", nLines));
1055 1253 : PLACE(nCur + 341, NCOLS, CPLSPrintf("%08d", nPixels));
1056 1253 : PLACE(nCur + 349, PVTYPE, pszPVType);
1057 1253 : PLACE(nCur + 352, IREP, pszIREP);
1058 1253 : OVR(8, nCur + 360, ICAT, "VIS");
1059 : {
1060 1253 : const char *pszParamValue = CSLFetchNameValue(papszOptions, "ABPP");
1061 1253 : PLACE(nCur + 368, ABPP,
1062 : CPLSPrintf("%02d", pszParamValue ? atoi(pszParamValue)
1063 : : nBitsPerSample));
1064 : }
1065 1253 : OVR(1, nCur + 370, PJUST, "R");
1066 1253 : OVR(1, nCur + 371, ICORDS, " ");
1067 :
1068 1253 : nOffset = 372;
1069 :
1070 : {
1071 : const char *pszParamValue;
1072 1253 : pszParamValue = CSLFetchNameValue(papszOptions, "ICORDS");
1073 1253 : if (pszParamValue == nullptr)
1074 1158 : pszParamValue = " ";
1075 1253 : if (*pszParamValue != ' ')
1076 : {
1077 95 : OVR(60, nCur + nOffset, IGEOLO, "");
1078 95 : nOffset += 60;
1079 : }
1080 : }
1081 :
1082 : {
1083 1253 : const char *pszICOM = CSLFetchNameValue(papszOptions, "ICOM");
1084 1253 : if (pszICOM != nullptr)
1085 : {
1086 : char *pszRecodedICOM =
1087 2 : CPLRecode(pszICOM, CPL_ENC_UTF8, CPL_ENC_ISO8859_1);
1088 2 : int nLenICOM = static_cast<int>(strlen(pszRecodedICOM));
1089 2 : int nICOM = (79 + nLenICOM) / 80;
1090 : size_t nToWrite;
1091 2 : if (nICOM > 9)
1092 : {
1093 0 : CPLError(CE_Warning, CPLE_NotSupported,
1094 : "ICOM will be truncated");
1095 0 : nICOM = 9;
1096 : }
1097 2 : PLACE(nCur + nOffset, NICOM, CPLSPrintf("%01d", nICOM));
1098 2 : nToWrite = MIN(nICOM * 80, nLenICOM);
1099 2 : bOK &= VSIFWriteL(pszRecodedICOM, 1, nToWrite, fp) == nToWrite;
1100 2 : nOffset += nICOM * 80;
1101 2 : CPLFree(pszRecodedICOM);
1102 : }
1103 : else
1104 : {
1105 1251 : PLACE(nCur + nOffset, NICOM, "0");
1106 : }
1107 : }
1108 :
1109 1253 : if (pnICOffset)
1110 : {
1111 1253 : if (iIM == 0 || bAppendSubdataset)
1112 255 : *pnICOffset = nCur + nOffset + 1;
1113 : }
1114 1253 : OVR(2, nCur + nOffset + 1, IC, "NC");
1115 :
1116 1253 : if (pszIC[0] != 'N')
1117 : {
1118 22 : OVR(4, nCur + nOffset + 3, COMRAT, " ");
1119 22 : nOffset += 4;
1120 : }
1121 :
1122 1253 : if (nBands <= 9)
1123 : {
1124 1252 : PLACE(nCur + nOffset + 3, NBANDS, CPLSPrintf("%d", nBands));
1125 : }
1126 : else
1127 : {
1128 1 : PLACE(nCur + nOffset + 3, NBANDS, "0");
1129 1 : PLACE(nCur + nOffset + 4, XBANDS, CPLSPrintf("%05d", nBands));
1130 1 : nOffset += 5;
1131 : }
1132 :
1133 1253 : nOffset += 4;
1134 :
1135 : /* --------------------------------------------------------------------
1136 : */
1137 : /* Per band info */
1138 : /* --------------------------------------------------------------------
1139 : */
1140 72622 : for (iBand = 0; iBand < nBands; iBand++)
1141 : {
1142 71369 : const char *pszIREPBAND = "M";
1143 :
1144 71369 : if (papszIREPBANDTokens != nullptr)
1145 : {
1146 7 : if (strlen(papszIREPBANDTokens[iBand]) > 2)
1147 : {
1148 0 : papszIREPBANDTokens[iBand][2] = '\0';
1149 0 : CPLError(CE_Warning, CPLE_NotSupported,
1150 : "Truncating IREPBAND[%d] to '%s'", iBand + 1,
1151 0 : papszIREPBANDTokens[iBand]);
1152 : }
1153 7 : pszIREPBAND = papszIREPBANDTokens[iBand];
1154 : }
1155 71362 : else if (EQUAL(pszIREP, "RGB/LUT"))
1156 2 : pszIREPBAND = "LU";
1157 71360 : else if (EQUAL(pszIREP, "RGB"))
1158 : {
1159 31 : if (iBand == 0)
1160 10 : pszIREPBAND = "R";
1161 21 : else if (iBand == 1)
1162 10 : pszIREPBAND = "G";
1163 11 : else if (iBand == 2)
1164 10 : pszIREPBAND = "B";
1165 : }
1166 71329 : else if (STARTS_WITH_CI(pszIREP, "YCbCr"))
1167 : {
1168 15 : if (iBand == 0)
1169 5 : pszIREPBAND = "Y";
1170 10 : else if (iBand == 1)
1171 5 : pszIREPBAND = "Cb";
1172 5 : else if (iBand == 2)
1173 5 : pszIREPBAND = "Cr";
1174 : }
1175 :
1176 71369 : PLACE(nCur + nOffset + 0, IREPBANDn, pszIREPBAND);
1177 :
1178 71369 : if (papszISUBCATTokens != nullptr)
1179 : {
1180 2 : if (strlen(papszISUBCATTokens[iBand]) > 6)
1181 : {
1182 0 : papszISUBCATTokens[iBand][6] = '\0';
1183 0 : CPLError(CE_Warning, CPLE_NotSupported,
1184 : "Truncating ISUBCAT[%d] to '%s'", iBand + 1,
1185 0 : papszISUBCATTokens[iBand]);
1186 : }
1187 2 : PLACE(nCur + nOffset + 2, ISUBCATn, papszISUBCATTokens[iBand]);
1188 : }
1189 : // else
1190 : // PLACE(nCur+nOffset+ 2, ISUBCATn, "" );
1191 :
1192 71369 : PLACE(nCur + nOffset + 8, IFCn, "N");
1193 : // PLACE(nCur+nOffset+ 9, IMFLTn, "" );
1194 :
1195 71369 : if (!EQUAL(pszIREP, "RGB/LUT"))
1196 : {
1197 71367 : PLACE(nCur + nOffset + 12, NLUTSn, "0");
1198 71367 : nOffset += 13;
1199 : }
1200 : else
1201 : {
1202 2 : int iC, nCount = 256;
1203 :
1204 2 : if (CSLFetchNameValue(papszOptions, "LUT_SIZE") != nullptr)
1205 2 : nCount = atoi(CSLFetchNameValue(papszOptions, "LUT_SIZE"));
1206 :
1207 2 : if (!(nCount >= 0 && nCount <= 99999))
1208 : {
1209 0 : CPLError(CE_Warning, CPLE_AppDefined,
1210 : "Invalid LUT value : %d. Defaulting to 256",
1211 : nCount);
1212 0 : nCount = 256;
1213 : }
1214 2 : PLACE(nCur + nOffset + 12, NLUTSn, "3");
1215 2 : PLACE(nCur + nOffset + 13, NELUTn, CPLSPrintf("%05d", nCount));
1216 :
1217 259 : for (iC = 0; iC < nCount; iC++)
1218 : {
1219 257 : WRITE_BYTE(nCur + nOffset + 18 + iC + 0,
1220 : static_cast<char>(iC));
1221 257 : WRITE_BYTE(nCur + nOffset + 18 + iC + nCount * 1,
1222 : static_cast<char>(iC));
1223 257 : WRITE_BYTE(nCur + nOffset + 18 + iC + nCount * 2,
1224 : static_cast<char>(iC));
1225 : }
1226 2 : nOffset += 18 + nCount * 3;
1227 : }
1228 : }
1229 :
1230 1253 : CSLDestroy(papszIREPBANDTokens);
1231 1253 : CSLDestroy(papszISUBCATTokens);
1232 :
1233 : /* --------------------------------------------------------------------
1234 : */
1235 : /* Remainder of image header info. */
1236 : /* --------------------------------------------------------------------
1237 : */
1238 1253 : PLACE(nCur + nOffset + 0, ISYNC, "0");
1239 :
1240 : /* RGB JPEG compressed NITF requires IMODE=P (see #3345) */
1241 1253 : if (nBands >= 3 && (EQUAL(pszIC, "C3") || EQUAL(pszIC, "M3")))
1242 : {
1243 6 : PLACE(nCur + nOffset + 1, IMODE, "P");
1244 : }
1245 : else
1246 : {
1247 1247 : PLACE(nCur + nOffset + 1, IMODE, "B");
1248 : }
1249 1253 : PLACE(nCur + nOffset + 2, NBPR, CPLSPrintf("%04d", nNBPR));
1250 1253 : PLACE(nCur + nOffset + 6, NBPC, CPLSPrintf("%04d", nNBPC));
1251 1253 : PLACE(nCur + nOffset + 10, NPPBH, CPLSPrintf("%04d", nNPPBH));
1252 1253 : PLACE(nCur + nOffset + 14, NPPBV, CPLSPrintf("%04d", nNPPBV));
1253 1253 : PLACE(nCur + nOffset + 18, NBPP, CPLSPrintf("%02d", nBitsPerSample));
1254 1253 : PLACE(nCur + nOffset + 20, IDLVL,
1255 : CPLSPrintf("%03d", atoi(CSLFetchNameValueDef(papszOptions,
1256 : "IDLVL", "1"))));
1257 1253 : PLACE(nCur + nOffset + 23, IALVL,
1258 : CPLSPrintf("%03d", atoi(CSLFetchNameValueDef(papszOptions,
1259 : "IALVL", "0"))));
1260 1253 : PLACE(nCur + nOffset + 26, ILOCROW,
1261 : CPLSPrintf("%05d", atoi(CSLFetchNameValueDef(papszOptions,
1262 : "ILOCROW", "0"))));
1263 1253 : PLACE(nCur + nOffset + 31, ILOCCOL,
1264 : CPLSPrintf("%05d", atoi(CSLFetchNameValueDef(papszOptions,
1265 : "ILOCCOL", "0"))));
1266 1253 : PLACE(nCur + nOffset + 36, IMAG, "1.0 ");
1267 1253 : PLACE(nCur + nOffset + 40, UDIDL, "00000");
1268 1253 : PLACE(nCur + nOffset + 45, IXSHDL, "00000");
1269 :
1270 1253 : nOffsetUDIDL = nCur + nOffset + 40;
1271 1253 : nOffset += 50;
1272 :
1273 : /* --------------------------------------------------------------------
1274 : */
1275 : /* Add BLOCKA TRE if requested. */
1276 : /* --------------------------------------------------------------------
1277 : */
1278 1253 : if (CSLFetchNameValue(papszOptions, "BLOCKA_BLOCK_COUNT") != nullptr)
1279 : {
1280 3 : NITFWriteBLOCKA(fp, nOffsetUDIDL, &nOffset, papszOptions);
1281 : }
1282 :
1283 2443 : if (CSLFetchNameValue(papszOptions, "TRE") != nullptr ||
1284 1190 : CSLFetchNameValue(papszOptions, "RESERVE_SPACE_FOR_TRE_OVERFLOW") !=
1285 : nullptr)
1286 : {
1287 65 : bOK &= NITFWriteTREsFromOptions(fp, nOffsetUDIDL, &nOffset,
1288 65 : papszOptions, "TRE=");
1289 : }
1290 :
1291 : /* --------------------------------------------------------------------
1292 : */
1293 : /* Update the image header length in the file header. */
1294 : /* --------------------------------------------------------------------
1295 : */
1296 1253 : nIHSize = nOffset;
1297 :
1298 1253 : if (nIHSize > 999999)
1299 : {
1300 0 : CPLError(CE_Failure, CPLE_AppDefined,
1301 : "Too big image header length : %d", nIHSize);
1302 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
1303 0 : return FALSE;
1304 : }
1305 :
1306 1253 : PLACE(363 + iIM * 16, LISH1, CPLSPrintf("%06d", nIHSize));
1307 1253 : if (EQUAL(pszIC, "NC"))
1308 : {
1309 1231 : PLACE(
1310 : 369 + iIM * 16, LIi,
1311 : CPLSPrintf("%010" CPL_FRMT_GB_WITHOUT_PREFIX "u", nImageSize));
1312 : }
1313 :
1314 1253 : nCur += nIHSize;
1315 1253 : if (pnImageOffset)
1316 : {
1317 1253 : if (iIM == 0 || bAppendSubdataset)
1318 255 : *pnImageOffset = nCur;
1319 : }
1320 1253 : nCur += nImageSize;
1321 :
1322 1253 : if (!bWriteAllImages)
1323 254 : break;
1324 : }
1325 :
1326 : /* -------------------------------------------------------------------- */
1327 : /* Fill in image data by writing one byte at the end */
1328 : /* -------------------------------------------------------------------- */
1329 256 : if (EQUAL(pszIC, "NC"))
1330 : {
1331 234 : char cNul = 0;
1332 234 : bOK &= VSIFSeekL(fp, nCur - 1, SEEK_SET) == 0;
1333 234 : bOK &= VSIFWriteL(&cNul, 1, 1, fp) == 1;
1334 : }
1335 :
1336 : /* -------------------------------------------------------------------- */
1337 : /* Compute and update CLEVEL ("complexity" level). */
1338 : /* See: http://164.214.2.51/ntb/baseline/docs/2500b/2500b_not2.pdf */
1339 : /* page 96u */
1340 : /* -------------------------------------------------------------------- */
1341 256 : nCLevel = 3;
1342 256 : if (bAppendSubdataset)
1343 : {
1344 : // Get existing CLEVEL
1345 5 : bOK &= VSIFSeekL(fp, 9, SEEK_SET) == 0;
1346 5 : char szCLEVEL[3] = {0};
1347 5 : bOK &= VSIFReadL(szCLEVEL, 1, 2, fp) != 0;
1348 5 : nCLevel = atoi(szCLEVEL);
1349 : }
1350 256 : if (nBands > 9 || nIM > 20 || nPixels > 2048 || nLines > 2048 ||
1351 239 : nNPPBH > 2048 || nNPPBV > 2048 || nCur > 52428799)
1352 : {
1353 18 : nCLevel = MAX(nCLevel, 5);
1354 : }
1355 256 : if (nPixels > 8192 || nLines > 8192 || nNPPBH > 8192 || nNPPBV > 8192 ||
1356 251 : nCur > 1073741833 || nDES > 10)
1357 : {
1358 5 : nCLevel = MAX(nCLevel, 6);
1359 : }
1360 256 : if (nBands > 256 || nPixels > 65536 || nLines > 65536 ||
1361 255 : nCur > 2147483647 || nDES > 50)
1362 : {
1363 1 : nCLevel = MAX(nCLevel, 7);
1364 : }
1365 256 : OVR(2, 9, CLEVEL, CPLSPrintf("%02d", nCLevel));
1366 :
1367 : /* -------------------------------------------------------------------- */
1368 : /* Update total file length */
1369 : /* -------------------------------------------------------------------- */
1370 :
1371 : /* According to the spec, CLEVEL 7 supports up to 10,737,418,330 bytes */
1372 : /* but we can support technically much more */
1373 256 : if (EQUAL(pszIC, "NC") && nCur >= 999999999999ULL)
1374 : {
1375 0 : CPLError(CE_Failure, CPLE_AppDefined, "Too big file : " CPL_FRMT_GUIB,
1376 : nCur);
1377 0 : CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
1378 0 : return FALSE;
1379 : }
1380 :
1381 256 : PLACE(342, FL, CPLSPrintf("%012" CPL_FRMT_GB_WITHOUT_PREFIX "d", nCur));
1382 :
1383 256 : if (VSIFCloseL(fp) != 0)
1384 0 : bOK = FALSE;
1385 :
1386 256 : CPL_IGNORE_RET_VAL(nOffset);
1387 :
1388 256 : return bOK;
1389 : }
1390 :
1391 37722 : static bool NITFWriteOption(VSILFILE *psFile, char **papszOptions,
1392 : size_t nWidth, GUIntBig nLocation,
1393 : const char *pszName, const char *pszText)
1394 : {
1395 : const char *pszParamValue;
1396 : char *pszRecodedValue;
1397 : size_t nToWrite;
1398 37722 : bool bOK = true;
1399 :
1400 37722 : pszParamValue = CSLFetchNameValue(papszOptions, pszName);
1401 37722 : if (pszParamValue == nullptr)
1402 : {
1403 37600 : pszRecodedValue = CPLRecode(pszText, CPL_ENC_UTF8, CPL_ENC_ISO8859_1);
1404 : }
1405 : else
1406 : {
1407 : pszRecodedValue =
1408 122 : CPLRecode(pszParamValue, CPL_ENC_UTF8, CPL_ENC_ISO8859_1);
1409 : }
1410 :
1411 37722 : bOK &= NITFGotoOffset(psFile, nLocation);
1412 37722 : nToWrite = MIN(nWidth, strlen(pszRecodedValue));
1413 37722 : bOK &= VSIFWriteL(pszRecodedValue, 1, nToWrite, psFile) == nToWrite;
1414 37722 : CPLFree(pszRecodedValue);
1415 37722 : return bOK;
1416 : }
1417 :
1418 : /************************************************************************/
1419 : /* NITFWriteTRE() */
1420 : /************************************************************************/
1421 :
1422 78 : static bool NITFWriteTRE(VSILFILE *fp, vsi_l_offset nOffsetUDIDL, int *pnOffset,
1423 : const char *pszTREName, char *pabyTREData,
1424 : int nTREDataSize)
1425 :
1426 : {
1427 : char szTemp[12];
1428 : int nOldOffset;
1429 78 : bool bOK = true;
1430 :
1431 : /* -------------------------------------------------------------------- */
1432 : /* Update IXSHDL. */
1433 : /* -------------------------------------------------------------------- */
1434 78 : bOK &= VSIFSeekL(fp, nOffsetUDIDL + 5, SEEK_SET) == 0;
1435 78 : bOK &= VSIFReadL(szTemp, 1, 5, fp) == 5;
1436 78 : szTemp[5] = 0;
1437 78 : nOldOffset = atoi(szTemp);
1438 :
1439 78 : if (nOldOffset == 0)
1440 : {
1441 70 : nOldOffset = 3;
1442 70 : PLACE(nOffsetUDIDL + 10, IXSOFL, "000");
1443 70 : *pnOffset += 3;
1444 : }
1445 :
1446 78 : if (nOldOffset + 11 + nTREDataSize > 99999 || nTREDataSize < 0 ||
1447 : nTREDataSize > 99999)
1448 : {
1449 0 : CPLError(CE_Failure, CPLE_AppDefined, "Too big TRE to be written");
1450 0 : return FALSE;
1451 : }
1452 :
1453 78 : snprintf(szTemp, sizeof(szTemp), "%05d", nOldOffset + 11 + nTREDataSize);
1454 78 : PLACE(nOffsetUDIDL + 5, IXSHDL, szTemp);
1455 :
1456 : /* -------------------------------------------------------------------- */
1457 : /* Create TRE prefix. */
1458 : /* -------------------------------------------------------------------- */
1459 78 : snprintf(szTemp, sizeof(szTemp), "%-6s%05d", pszTREName, nTREDataSize);
1460 78 : bOK &= VSIFSeekL(fp, nOffsetUDIDL + 10 + nOldOffset, SEEK_SET) == 0;
1461 78 : bOK &= VSIFWriteL(szTemp, 11, 1, fp) == 1;
1462 78 : bOK &= static_cast<int>(VSIFWriteL(pabyTREData, 1, nTREDataSize, fp)) ==
1463 78 : nTREDataSize;
1464 :
1465 : /* -------------------------------------------------------------------- */
1466 : /* Increment values. */
1467 : /* -------------------------------------------------------------------- */
1468 78 : *pnOffset += nTREDataSize + 11;
1469 :
1470 78 : return bOK;
1471 : }
1472 :
1473 : /************************************************************************/
1474 : /* NITFWriteTREsFromOptions() */
1475 : /************************************************************************/
1476 :
1477 70 : static bool NITFWriteTREsFromOptions(VSILFILE *fp, vsi_l_offset nOffsetUDIDL,
1478 : int *pnOffset, char **papszOptions,
1479 : const char *pszTREPrefix)
1480 :
1481 : {
1482 : int bIgnoreBLOCKA =
1483 70 : CSLFetchNameValue(papszOptions, "BLOCKA_BLOCK_COUNT") != nullptr;
1484 : int iOption;
1485 : const bool bReserveSpaceForTREOverflow =
1486 70 : CSLFetchNameValue(papszOptions, "RESERVE_SPACE_FOR_TRE_OVERFLOW") !=
1487 70 : nullptr;
1488 :
1489 70 : if (papszOptions == nullptr)
1490 0 : return true;
1491 :
1492 249 : for (iOption = 0; papszOptions[iOption] != nullptr; iOption++)
1493 : {
1494 : const char *pszEscapedContents;
1495 : char *pszUnescapedContents;
1496 : char *pszTREName;
1497 : int nContentLength;
1498 : const char *pszSpace;
1499 179 : int bIsHex = FALSE;
1500 179 : int nTREPrefixLen = static_cast<int>(strlen(pszTREPrefix));
1501 :
1502 179 : if (!EQUALN(papszOptions[iOption], pszTREPrefix, nTREPrefixLen))
1503 104 : continue;
1504 :
1505 76 : if (STARTS_WITH_CI(papszOptions[iOption] + nTREPrefixLen, "BLOCKA=") &&
1506 : bIgnoreBLOCKA)
1507 1 : continue;
1508 :
1509 75 : if (STARTS_WITH_CI(papszOptions[iOption] + nTREPrefixLen, "HEX/"))
1510 : {
1511 4 : bIsHex = TRUE;
1512 4 : nTREPrefixLen += 4;
1513 : }
1514 :
1515 : /* We do no longer use CPLParseNameValue() as it removes leading spaces
1516 : */
1517 : /* from the value (see #3088) */
1518 75 : pszSpace = strchr(papszOptions[iOption] + nTREPrefixLen, '=');
1519 75 : if (pszSpace == nullptr)
1520 : {
1521 0 : CPLError(CE_Failure, CPLE_AppDefined,
1522 : "Could not parse creation options %s",
1523 0 : papszOptions[iOption] + nTREPrefixLen);
1524 0 : return false;
1525 : }
1526 :
1527 75 : pszTREName = CPLStrdup(papszOptions[iOption] + nTREPrefixLen);
1528 75 : pszTREName[MIN(6, pszSpace - (papszOptions[iOption] + nTREPrefixLen))] =
1529 : '\0';
1530 75 : pszEscapedContents = pszSpace + 1;
1531 :
1532 75 : pszUnescapedContents = CPLUnescapeString(
1533 : pszEscapedContents, &nContentLength, CPLES_BackslashQuotable);
1534 :
1535 75 : if (bIsHex)
1536 : {
1537 : int i;
1538 : char pszSubStr[3];
1539 :
1540 4 : if (nContentLength % 2)
1541 : {
1542 0 : CPLError(
1543 : CE_Failure, CPLE_AppDefined,
1544 : "Could not parse creation options %s: invalid hex data",
1545 0 : papszOptions[iOption] + nTREPrefixLen);
1546 0 : CPLFree(pszTREName);
1547 0 : CPLFree(pszUnescapedContents);
1548 0 : return false;
1549 : }
1550 :
1551 4 : nContentLength = nContentLength / 2;
1552 1138 : for (i = 0; i < nContentLength; i++)
1553 : {
1554 1134 : CPLStrlcpy(pszSubStr, pszUnescapedContents + 2 * i, 3);
1555 1134 : reinterpret_cast<unsigned char *>(pszUnescapedContents)[i] =
1556 1134 : static_cast<unsigned char>(strtoul(pszSubStr, nullptr, 16));
1557 : }
1558 4 : pszUnescapedContents[nContentLength] = '\0';
1559 : }
1560 :
1561 75 : if (!NITFWriteTRE(fp, nOffsetUDIDL, pnOffset, pszTREName,
1562 : pszUnescapedContents, nContentLength))
1563 : {
1564 0 : CPLFree(pszTREName);
1565 0 : CPLFree(pszUnescapedContents);
1566 0 : return false;
1567 : }
1568 :
1569 75 : CPLFree(pszTREName);
1570 75 : CPLFree(pszUnescapedContents);
1571 : }
1572 :
1573 70 : if (bReserveSpaceForTREOverflow)
1574 : {
1575 : /* --------------------------------------------------------------------
1576 : */
1577 : /* Update IXSHDL. */
1578 : /* --------------------------------------------------------------------
1579 : */
1580 : int nOldOffset;
1581 : char szTemp[6];
1582 2 : bool bOK = VSIFSeekL(fp, nOffsetUDIDL + 5, SEEK_SET) == 0;
1583 2 : bOK &= VSIFReadL(szTemp, 1, 5, fp) == 5;
1584 2 : szTemp[5] = 0;
1585 2 : nOldOffset = atoi(szTemp);
1586 :
1587 2 : if (nOldOffset == 0)
1588 : {
1589 2 : PLACE(nOffsetUDIDL + 5, IXSHDL, "00003");
1590 :
1591 2 : PLACE(nOffsetUDIDL + 10, IXSOFL, "000");
1592 2 : *pnOffset += 3;
1593 : }
1594 :
1595 2 : return bOK;
1596 : }
1597 :
1598 68 : return true;
1599 : }
1600 :
1601 : /************************************************************************/
1602 : /* NITFWriteBLOCKA() */
1603 : /************************************************************************/
1604 :
1605 3 : static bool NITFWriteBLOCKA(VSILFILE *fp, vsi_l_offset nOffsetUDIDL,
1606 : int *pnOffset, char **papszOptions)
1607 :
1608 : {
1609 : static const char *const apszFields[] = {
1610 : "BLOCK_INSTANCE", "0", "2", "N_GRAY", "2", "5",
1611 : "L_LINES", "7", "5", "LAYOVER_ANGLE", "12", "3",
1612 : "SHADOW_ANGLE", "15", "3", "BLANKS", "18", "16",
1613 : "FRLC_LOC", "34", "21", "LRLC_LOC", "55", "21",
1614 : "LRFC_LOC", "76", "21", "FRFC_LOC", "97", "21",
1615 : nullptr, nullptr, nullptr};
1616 : int nBlockCount =
1617 3 : atoi(CSLFetchNameValue(papszOptions, "BLOCKA_BLOCK_COUNT"));
1618 : int iBlock;
1619 :
1620 : /* ==================================================================== */
1621 : /* Loop over all the blocks we have metadata for. */
1622 : /* ==================================================================== */
1623 6 : for (iBlock = 1; iBlock <= nBlockCount; iBlock++)
1624 : {
1625 : char szBLOCKA[123];
1626 : int iField;
1627 :
1628 : /* --------------------------------------------------------------------
1629 : */
1630 : /* Write all fields. */
1631 : /* --------------------------------------------------------------------
1632 : */
1633 33 : for (iField = 0; apszFields[iField * 3] != nullptr; iField++)
1634 : {
1635 : char szFullFieldName[64];
1636 30 : int iStart = atoi(apszFields[iField * 3 + 1]);
1637 30 : int iSize = atoi(apszFields[iField * 3 + 2]);
1638 : const char *pszValue;
1639 :
1640 30 : snprintf(szFullFieldName, sizeof(szFullFieldName), "BLOCKA_%s_%02d",
1641 30 : apszFields[iField * 3 + 0], iBlock);
1642 :
1643 30 : pszValue = CSLFetchNameValue(papszOptions, szFullFieldName);
1644 30 : if (pszValue == nullptr)
1645 6 : pszValue = "";
1646 :
1647 30 : if (iSize - static_cast<int>(strlen(pszValue)) < 0)
1648 : {
1649 0 : CPLError(
1650 : CE_Failure, CPLE_AppDefined,
1651 : "Too much data for %s. Got %d bytes, max allowed is %d",
1652 0 : szFullFieldName, static_cast<int>(strlen(pszValue)), iSize);
1653 0 : return false;
1654 : }
1655 :
1656 : /* Right align value and left pad with spaces */
1657 30 : memset(szBLOCKA + iStart, ' ', iSize);
1658 : /* unsigned is always >= 0 */
1659 : /* memcpy( szBLOCKA + iStart +
1660 : * MAX((size_t)0,iSize-strlen(pszValue)), */
1661 30 : memcpy(szBLOCKA + iStart +
1662 30 : (iSize - static_cast<int>(strlen(pszValue))),
1663 : pszValue, strlen(pszValue));
1664 : }
1665 :
1666 : // required field - semantics unknown.
1667 3 : memcpy(szBLOCKA + 118, "010.0", 5);
1668 :
1669 3 : if (!NITFWriteTRE(fp, nOffsetUDIDL, pnOffset, "BLOCKA", szBLOCKA, 123))
1670 0 : return false;
1671 : }
1672 :
1673 3 : return true;
1674 : }
1675 :
1676 : /************************************************************************/
1677 : /* NITFCollectSegmentInfo() */
1678 : /* */
1679 : /* Collect the information about a set of segments of a */
1680 : /* particular type from the NITF file header, and add them to */
1681 : /* the segment list in the NITFFile object. */
1682 : /************************************************************************/
1683 :
1684 3834 : static int NITFCollectSegmentInfo(NITFFile *psFile, int nFileHeaderLen,
1685 : int nOffset, const char szType[3],
1686 : int nHeaderLenSize, int nDataLenSize,
1687 : GUIntBig *pnNextData)
1688 :
1689 : {
1690 : char szTemp[12];
1691 : int nCount, nSegDefSize, iSegment;
1692 :
1693 : /* -------------------------------------------------------------------- */
1694 : /* Get the segment count, and grow the segmentinfo array */
1695 : /* accordingly. */
1696 : /* -------------------------------------------------------------------- */
1697 3834 : if (nFileHeaderLen < nOffset + 3)
1698 : {
1699 0 : CPLError(CE_Failure, CPLE_AppDefined,
1700 : "Not enough bytes to read segment count");
1701 0 : return -1;
1702 : }
1703 :
1704 3834 : NITFGetField(szTemp, psFile->pachHeader, nOffset, 3);
1705 3834 : nCount = atoi(szTemp);
1706 :
1707 3834 : if (nCount <= 0)
1708 3148 : return nOffset + 3;
1709 :
1710 686 : nSegDefSize = nCount * (nHeaderLenSize + nDataLenSize);
1711 686 : if (nFileHeaderLen < nOffset + 3 + nSegDefSize)
1712 : {
1713 1 : CPLError(CE_Failure, CPLE_AppDefined,
1714 : "Not enough bytes to read segment info");
1715 1 : return -1;
1716 : }
1717 :
1718 685 : if (psFile->pasSegmentInfo == nullptr)
1719 635 : psFile->pasSegmentInfo = static_cast<NITFSegmentInfo *>(
1720 635 : CPLMalloc(sizeof(NITFSegmentInfo) * nCount));
1721 : else
1722 50 : psFile->pasSegmentInfo = static_cast<NITFSegmentInfo *>(CPLRealloc(
1723 50 : psFile->pasSegmentInfo,
1724 50 : sizeof(NITFSegmentInfo) * (psFile->nSegmentCount + nCount)));
1725 :
1726 : /* -------------------------------------------------------------------- */
1727 : /* Collect detailed about segment. */
1728 : /* -------------------------------------------------------------------- */
1729 10398 : for (iSegment = 0; iSegment < nCount; iSegment++)
1730 : {
1731 9713 : NITFSegmentInfo *psInfo =
1732 9713 : psFile->pasSegmentInfo + psFile->nSegmentCount;
1733 :
1734 9713 : psInfo->nDLVL = -1;
1735 9713 : psInfo->nALVL = -1;
1736 9713 : psInfo->nLOC_R = -1;
1737 9713 : psInfo->nLOC_C = -1;
1738 9713 : psInfo->nCCS_R = -1;
1739 9713 : psInfo->nCCS_C = -1;
1740 :
1741 9713 : psInfo->hAccess = nullptr;
1742 9713 : strncpy(psInfo->szSegmentType, szType, sizeof(psInfo->szSegmentType));
1743 9713 : psInfo->szSegmentType[sizeof(psInfo->szSegmentType) - 1] = '\0';
1744 :
1745 19426 : psInfo->nSegmentHeaderSize = atoi(NITFGetField(
1746 9713 : szTemp, psFile->pachHeader,
1747 9713 : nOffset + 3 + iSegment * (nHeaderLenSize + nDataLenSize),
1748 : nHeaderLenSize));
1749 9713 : if (strchr(szTemp, '-') !=
1750 : nullptr) /* Avoid negative values being mapped
1751 : to huge unsigned values */
1752 : {
1753 0 : CPLError(CE_Failure, CPLE_AppDefined,
1754 : "Invalid segment header size : %s", szTemp);
1755 0 : return -1;
1756 : }
1757 :
1758 9713 : if (strcmp(szType, "DE") == 0 && psInfo->nSegmentHeaderSize == 207)
1759 : {
1760 : /* DMAAC A.TOC files have a wrong header size. It says 207 but it is
1761 : * 209 really */
1762 0 : psInfo->nSegmentHeaderSize = 209;
1763 : }
1764 :
1765 9713 : psInfo->nSegmentSize = CPLScanUIntBig(
1766 9713 : NITFGetField(szTemp, psFile->pachHeader,
1767 9713 : nOffset + 3 +
1768 9713 : iSegment * (nHeaderLenSize + nDataLenSize) +
1769 : nHeaderLenSize,
1770 : nDataLenSize),
1771 : nDataLenSize);
1772 9713 : if (strchr(szTemp, '-') !=
1773 : nullptr) /* Avoid negative values being mapped
1774 : to huge unsigned values */
1775 : {
1776 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid segment size : %s",
1777 : szTemp);
1778 0 : return -1;
1779 : }
1780 :
1781 9713 : psInfo->nSegmentHeaderStart = *pnNextData;
1782 9713 : psInfo->nSegmentStart = *pnNextData + psInfo->nSegmentHeaderSize;
1783 :
1784 9713 : *pnNextData += (psInfo->nSegmentHeaderSize + psInfo->nSegmentSize);
1785 9713 : psFile->nSegmentCount++;
1786 : }
1787 :
1788 685 : return nOffset + nSegDefSize + 3;
1789 : }
1790 :
1791 : /************************************************************************/
1792 : /* NITFGetField() */
1793 : /* */
1794 : /* Copy a field from a passed in header buffer into a temporary */
1795 : /* buffer and zero terminate it. */
1796 : /************************************************************************/
1797 :
1798 671520 : char *NITFGetField(char *pszTarget, const char *pszSource, int nStart,
1799 : int nLength)
1800 :
1801 : {
1802 671520 : memcpy(pszTarget, pszSource + nStart, nLength);
1803 671520 : pszTarget[nLength] = '\0';
1804 :
1805 671520 : return pszTarget;
1806 : }
1807 :
1808 : /************************************************************************/
1809 : /* NITFFindTRE() */
1810 : /************************************************************************/
1811 :
1812 65697 : const char *NITFFindTRE(const char *pszTREData, int nTREBytes,
1813 : const char *pszTag, int *pnFoundTRESize)
1814 :
1815 : {
1816 : char szTemp[100];
1817 :
1818 65697 : while (nTREBytes >= 11)
1819 : {
1820 7593 : int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5));
1821 7593 : if (nThisTRESize < 0)
1822 : {
1823 0 : NITFGetField(szTemp, pszTREData, 0, 6);
1824 0 : CPLError(CE_Failure, CPLE_AppDefined,
1825 : "Invalid size (%d) for TRE %s", nThisTRESize, szTemp);
1826 0 : return nullptr;
1827 : }
1828 7593 : if (nTREBytes - 11 < nThisTRESize)
1829 : {
1830 0 : NITFGetField(szTemp, pszTREData, 0, 6);
1831 0 : if (STARTS_WITH_CI(szTemp, "RPFIMG"))
1832 : {
1833 : /* See #3848 */
1834 0 : CPLDebug("NITF",
1835 : "Adjusting RPFIMG TRE size from %d to %d, which is "
1836 : "the remaining size",
1837 : nThisTRESize, nTREBytes - 11);
1838 0 : nThisTRESize = nTREBytes - 11;
1839 : }
1840 : else
1841 : {
1842 0 : CPLError(CE_Failure, CPLE_AppDefined,
1843 : "Cannot read %s TRE. Not enough bytes : remaining %d, "
1844 : "expected %d",
1845 : szTemp, nTREBytes - 11, nThisTRESize);
1846 0 : return nullptr;
1847 : }
1848 : }
1849 :
1850 7593 : if (EQUALN(pszTREData, pszTag, 6))
1851 : {
1852 187 : if (pnFoundTRESize != nullptr)
1853 187 : *pnFoundTRESize = nThisTRESize;
1854 :
1855 187 : return pszTREData + 11;
1856 : }
1857 :
1858 7406 : nTREBytes -= (nThisTRESize + 11);
1859 7406 : pszTREData += (nThisTRESize + 11);
1860 : }
1861 :
1862 58104 : return nullptr;
1863 : }
1864 :
1865 : /************************************************************************/
1866 : /* NITFFindTREByIndex() */
1867 : /************************************************************************/
1868 :
1869 849 : const char *NITFFindTREByIndex(const char *pszTREData, int nTREBytes,
1870 : const char *pszTag, int nTreIndex,
1871 : int *pnFoundTRESize)
1872 :
1873 : {
1874 : char szTemp[100];
1875 :
1876 849 : while (nTREBytes >= 11)
1877 : {
1878 237 : int nThisTRESize = atoi(NITFGetField(szTemp, pszTREData, 6, 5));
1879 237 : if (nThisTRESize < 0)
1880 : {
1881 0 : NITFGetField(szTemp, pszTREData, 0, 6);
1882 0 : CPLError(CE_Failure, CPLE_AppDefined,
1883 : "Invalid size (%d) for TRE %s", nThisTRESize, szTemp);
1884 0 : return nullptr;
1885 : }
1886 237 : if (nTREBytes - 11 < nThisTRESize)
1887 : {
1888 0 : NITFGetField(szTemp, pszTREData, 0, 6);
1889 0 : if (STARTS_WITH_CI(szTemp, "RPFIMG"))
1890 : {
1891 : /* See #3848 */
1892 0 : CPLDebug("NITF",
1893 : "Adjusting RPFIMG TRE size from %d to %d, which is "
1894 : "the remaining size",
1895 : nThisTRESize, nTREBytes - 11);
1896 0 : nThisTRESize = nTREBytes - 11;
1897 : }
1898 : else
1899 : {
1900 0 : CPLError(CE_Failure, CPLE_AppDefined,
1901 : "Cannot read %s TRE. Not enough bytes : remaining %d, "
1902 : "expected %d",
1903 : szTemp, nTREBytes - 11, nThisTRESize);
1904 0 : return nullptr;
1905 : }
1906 : }
1907 :
1908 237 : if (EQUALN(pszTREData, pszTag, 6))
1909 : {
1910 47 : if (nTreIndex <= 0)
1911 : {
1912 25 : if (pnFoundTRESize != nullptr)
1913 25 : *pnFoundTRESize = nThisTRESize;
1914 :
1915 25 : return pszTREData + 11;
1916 : }
1917 :
1918 : /* Found a previous one - skip it ... */
1919 22 : nTreIndex--;
1920 : }
1921 :
1922 212 : nTREBytes -= (nThisTRESize + 11);
1923 212 : pszTREData += (nThisTRESize + 11);
1924 : }
1925 :
1926 612 : return nullptr;
1927 : }
1928 :
1929 : /************************************************************************/
1930 : /* NITFExtractMetadata() */
1931 : /************************************************************************/
1932 :
1933 254359 : static void NITFExtractAndRecodeMetadata(char ***ppapszMetadata,
1934 : const char *pachHeader, int nStart,
1935 : int nLength, const char *pszName,
1936 : const char *pszSrcEncoding)
1937 :
1938 : {
1939 : char szWork[400];
1940 : char *pszWork;
1941 : char *pszRecode;
1942 :
1943 254359 : if (nLength <= 0)
1944 0 : return;
1945 :
1946 254359 : if (nLength >= static_cast<int>(sizeof(szWork) - 1))
1947 1 : pszWork = static_cast<char *>(CPLMalloc(nLength + 1));
1948 : else
1949 254358 : pszWork = szWork;
1950 :
1951 : /* trim white space */
1952 3134470 : while (nLength > 0 && pachHeader[nStart + nLength - 1] == ' ')
1953 2880110 : nLength--;
1954 :
1955 254359 : memcpy(pszWork, pachHeader + nStart, nLength);
1956 254359 : pszWork[nLength] = '\0';
1957 :
1958 254359 : if (strcmp(pszSrcEncoding, CPL_ENC_UTF8) != 0)
1959 : {
1960 250787 : pszRecode = CPLRecode(pszWork, pszSrcEncoding, CPL_ENC_UTF8);
1961 250787 : *ppapszMetadata = CSLSetNameValue(*ppapszMetadata, pszName, pszRecode);
1962 250787 : CPLFree(pszRecode);
1963 : }
1964 : else
1965 : {
1966 3572 : *ppapszMetadata = CSLSetNameValue(*ppapszMetadata, pszName, pszWork);
1967 : }
1968 :
1969 254359 : if (szWork != pszWork)
1970 1 : CPLFree(pszWork);
1971 : }
1972 :
1973 250787 : void NITFExtractMetadata(char ***ppapszMetadata, const char *pachHeader,
1974 : int nStart, int nLength, const char *pszName)
1975 :
1976 : {
1977 250787 : NITFExtractAndRecodeMetadata(ppapszMetadata, pachHeader, nStart, nLength,
1978 : pszName, CPL_ENC_ISO8859_1);
1979 250787 : }
1980 :
1981 : /************************************************************************/
1982 : /* NITF_WGS84_Geocentric_Latitude_To_Geodetic_Latitude() */
1983 : /* */
1984 : /* The input is a geocentric latitude in degrees. The output */
1985 : /* is a geodetic latitude in degrees. */
1986 : /************************************************************************/
1987 :
1988 : /*
1989 : * "The angle L' is called "geocentric latitude" and is defined as the
1990 : * angle between the equatorial plane and the radius from the geocenter.
1991 : *
1992 : * The angle L is called "geodetic latitude" and is defined as the angle
1993 : * between the equatorial plane and the normal to the surface of the
1994 : * ellipsoid. The word "latitude" usually means geodetic latitude. This
1995 : * is the basis for most of the maps and charts we use. The normal to the
1996 : * surface is the direction that a plumb bob would hang were it not for
1997 : * local anomalies in the earth's gravitational field."
1998 : */
1999 :
2000 0 : double NITF_WGS84_Geocentric_Latitude_To_Geodetic_Latitude(double dfLat)
2001 :
2002 : {
2003 : /* WGS84 Ellipsoid */
2004 0 : const double a = 6378137.0;
2005 0 : const double b = 6356752.3142;
2006 :
2007 : /* convert to radians */
2008 0 : dfLat = dfLat * M_PI / 180.0;
2009 :
2010 : /* convert to geodetic */
2011 0 : dfLat = atan(((a * a) / (b * b)) * tan(dfLat));
2012 :
2013 : /* convert back to degrees */
2014 0 : dfLat = dfLat * 180.0 / M_PI;
2015 :
2016 0 : return dfLat;
2017 : }
2018 :
2019 : /************************************************************************/
2020 : /* NITFGetSeriesInfo() */
2021 : /************************************************************************/
2022 :
2023 : /* From
2024 : * http://trac.osgeo.org/gdal/attachment/ticket/5353/MIL-STD-2411_1_CHG-3.pdf */
2025 : static const NITFSeries nitfSeries[] = {
2026 : {"A1", "CM", "1:10K", "Combat Charts (1:10K)", "CADRG"},
2027 : {"A2", "CM", "1:25K", "Combat Charts (1:25K)", "CADRG"},
2028 : {"A3", "CM", "1:50K", "Combat Charts (1:50K)", "CADRG"},
2029 : {"A4", "CM", "1:100K", "Combat Charts (1:100K)", "CADRG"},
2030 : {"AT", "ATC", "1:200K", "Series 200 Air Target Chart", "CADRG"},
2031 : {"C1", "CG", "1:10000", "City Graphics", "CADRG"},
2032 : {"C2", "CG", "1:10560", "City Graphics", "CADRG"},
2033 : {"C3", "CG", "1:11000", "City Graphics", "CADRG"},
2034 : {"C4", "CG", "1:11800", "City Graphics", "CADRG"},
2035 : {"C5", "CG", "1:12000", "City Graphics", "CADRG"},
2036 : {"C6", "CG", "1:12500", "City Graphics", "CADRG"},
2037 : {"C7", "CG", "1:12800", "City Graphics", "CADRG"},
2038 : {"C8", "CG", "1:14000", "City Graphics", "CADRG"},
2039 : {"C9", "CG", "1:14700", "City Graphics", "CADRG"},
2040 : {"CA", "CG", "1:15000", "City Graphics", "CADRG"},
2041 : {"CB", "CG", "1:15500", "City Graphics", "CADRG"},
2042 : {"CC", "CG", "1:16000", "City Graphics", "CADRG"},
2043 : {"CD", "CG", "1:16666", "City Graphics", "CADRG"},
2044 : {"CE", "CG", "1:17000", "City Graphics", "CADRG"},
2045 : {"CF", "CG", "1:17500", "City Graphics", "CADRG"},
2046 : {"CG", "CG", "Various", "City Graphics", "CADRG"},
2047 : {"CH", "CG", "1:18000", "City Graphics", "CADRG"},
2048 : {"CJ", "CG", "1:20000", "City Graphics", "CADRG"},
2049 : {"CK", "CG", "1:21000", "City Graphics", "CADRG"},
2050 : {"CL", "CG", "1:21120", "City Graphics", "CADRG"},
2051 : {"CM", "CM", "Various", "Combat Charts", "CADRG"},
2052 : {"CN", "CG", "1:22000", "City Graphics", "CADRG"},
2053 : {"CO", "CO", "Various", "Coastal Charts", "CADRG"},
2054 : {"CP", "CG", "1:23000", "City Graphics", "CADRG"},
2055 : {"CQ", "CG", "1:25000", "City Graphics", "CADRG"},
2056 : {"CR", "CG", "1:26000", "City Graphics", "CADRG"},
2057 : {"CS", "CG", "1:35000", "City Graphics", "CADRG"},
2058 : {"CT", "CG", "1:36000", "City Graphics", "CADRG"},
2059 : {"D1", "", "100m", "Elevation Data from DTED level 1", "CDTED"},
2060 : {"D2", "", "30m", "Elevation Data from DTED level 2", "CDTED"},
2061 : {"EG", "NARC", "1:11,000,000", "North Atlantic Route Chart", "CADRG"},
2062 : {"ES", "SEC", "1:500K", "VFR Sectional", "CADRG"},
2063 : {"ET", "SEC", "1:250K", "VFR Sectional Inserts", "CADRG"},
2064 : {"F1", "TFC-1", "1:250K", "Transit Flying Chart (TBD #1)", "CADRG"},
2065 : {"F2", "TFC-2", "1:250K", "Transit Flying Chart (TBD #2)", "CADRG"},
2066 : {"F3", "TFC-3", "1:250K", "Transit Flying Chart (TBD #3)", "CADRG"},
2067 : {"F4", "TFC-4", "1:250K", "Transit Flying Chart (TBD #4)", "CADRG"},
2068 : {"F5", "TFC-5", "1:250K", "Transit Flying Chart (TBD #5)", "CADRG"},
2069 : {"GN", "GNC", "1:5M", "Global Navigation Chart", "CADRG"},
2070 : {"HA", "HA", "Various", "Harbor and Approach Charts", "CADRG"},
2071 : {"I1", "", "10m", "Imagery, 10 meter resolution", "CIB"},
2072 : {"I2", "", "5m", "Imagery, 5 meter resolution", "CIB"},
2073 : {"I3", "", "2m", "Imagery, 2 meter resolution", "CIB"},
2074 : {"I4", "", "1m", "Imagery, 1 meter resolution", "CIB"},
2075 : {"I5", "", ".5m", "Imagery, .5 (half) meter resolution", "CIB"},
2076 : {"IV", "", "Various > 10m", "Imagery, greater than 10 meter resolution",
2077 : "CIB"},
2078 : {"JA", "JOG-A", "1:250K", "Joint Operation Graphic - Air", "CADRG"},
2079 : {"JG", "JOG", "1:250K", "Joint Operation Graphic", "CADRG"},
2080 : {"JN", "JNC", "1:2M", "Jet Navigation Chart", "CADRG"},
2081 : {"JO", "OPG", "1:250K", "Operational Planning Graphic", "CADRG"},
2082 : {"JR", "JOG-R", "1:250K", "Joint Operation Graphic - Radar", "CADRG"},
2083 : {"K1", "ICM", "1:8K", "Image City Maps", "CADRG"},
2084 : {"K2", "ICM", "1:10K", "Image City Maps", "CADRG"},
2085 : {"K3", "ICM", "1:10560", "Image City Maps", "CADRG"},
2086 : {"K7", "ICM", "1:12500", "Image City Maps", "CADRG"},
2087 : {"K8", "ICM", "1:12800", "Image City Maps", "CADRG"},
2088 : {"KB", "ICM", "1:15K", "Image City Maps", "CADRG"},
2089 : {"KE", "ICM", "1:16666", "Image City Maps", "CADRG"},
2090 : {"KM", "ICM", "1:21120", "Image City Maps", "CADRG"},
2091 : {"KR", "ICM", "1:25K", "Image City Maps", "CADRG"},
2092 : {"KS", "ICM", "1:26K", "Image City Maps", "CADRG"},
2093 : {"KU", "ICM", "1:36K", "Image City Maps", "CADRG"},
2094 : {"L1", "LFC-1", "1:500K", "Low Flying Chart (TBD #1)", "CADRG"},
2095 : {"L2", "LFC-2", "1:500K", "Low Flying Chart (TBD #2)", "CADRG"},
2096 : {"L3", "LFC-3", "1:500K", "Low Flying Chart (TBD #3)", "CADRG"},
2097 : {"L4", "LFC-4", "1:500K", "Low Flying Chart (TBD #4)", "CADRG"},
2098 : {"L5", "LFC-5", "1:500K", "Low Flying Chart (TBD #5)", "CADRG"},
2099 : {"LF", "LFC-FR (Day)", "1:500K", "Low Flying Chart (Day) - Host Nation",
2100 : "CADRG"},
2101 : {"LN", "LN (Night)", "1:500K", "Low Flying Chart (Night) - Host Nation",
2102 : "CADRG"},
2103 : {"M1", "MIM", "Various", "Military Installation Maps (TBD #1)", "CADRG"},
2104 : {"M2", "MIM", "Various", "Military Installation Maps (TBD #2)", "CADRG"},
2105 : {"MH", "MIM", "1:25K", "Military Installation Maps", "CADRG"},
2106 : {"MI", "MIM", "1:50K", "Military Installation Maps", "CADRG"},
2107 : {"MJ", "MIM", "1:100K", "Military Installation Maps", "CADRG"},
2108 : {"MM", "", "Various", "(Miscellaneous Maps & Charts)", "CADRG"},
2109 : {"OA", "OPAREA", "Various", "Naval Range Operation Area Chart", "CADRG"},
2110 : {"OH", "VHRC", "1:1M", "VFR Helicopter Route Chart", "CADRG"},
2111 : {"ON", "ONC", "1:1M", "Operational Navigation Chart", "CADRG"},
2112 : {"OW", "WAC", "1:1M", "High Flying Chart - Host Nation", "CADRG"},
2113 : {"P1", "", "1:25K", "Special Military Map - Overlay", "CADRG"},
2114 : {"P2", "", "1:25K", "Special Military Purpose", "CADRG"},
2115 : {"P3", "", "1:25K", "Special Military Purpose", "CADRG"},
2116 : {"P4", "", "1:25K", "Special Military Purpose", "CADRG"},
2117 : {"P5", "", "1:50K", "Special Military Map - Overlay", "CADRG"},
2118 : {"P6", "", "1:50K", "Special Military Purpose", "CADRG"},
2119 : {"P7", "", "1:50K", "Special Military Purpose", "CADRG"},
2120 : {"P8", "", "1:50K", "Special Military Purpose", "CADRG"},
2121 : {"P9", "", "1:100K", "Special Military Map - Overlay", "CADRG"},
2122 : {"PA", "", "1:100K", "Special Military Purpose", "CADRG"},
2123 : {"PB", "", "1:100K", "Special Military Purpose", "CADRG"},
2124 : {"PC", "", "1:100K", "Special Military Purpose", "CADRG"},
2125 : {"PD", "", "1:250K", "Special Military Map - Overlay", "CADRG"},
2126 : {"PE", "", "1:250K", "Special Military Purpose", "CADRG"},
2127 : {"PF", "", "1:250K", "Special Military Purpose", "CADRG"},
2128 : {"PG", "", "1:250K", "Special Military Purpose", "CADRG"},
2129 : {"PH", "", "1:500K", "Special Military Map - Overlay", "CADRG"},
2130 : {"PI", "", "1:500K", "Special Military Purpose", "CADRG"},
2131 : {"PJ", "", "1:500K", "Special Military Purpose", "CADRG"},
2132 : {"PK", "", "1:500K", "Special Military Purpose", "CADRG"},
2133 : {"PL", "", "1:1M", "Special Military Map - Overlay", "CADRG"},
2134 : {"PM", "", "1:1M", "Special Military Purpose", "CADRG"},
2135 : {"PN", "", "1:1M", "Special Military Purpose", "CADRG"},
2136 : {"PO", "", "1:1M", "Special Military Purpose", "CADRG"},
2137 : {"PP", "", "1:2M", "Special Military Map - Overlay", "CADRG"},
2138 : {"PQ", "", "1:2M", "Special Military Purpose", "CADRG"},
2139 : {"PR", "", "1:2M", "Special Military Purpose", "CADRG"},
2140 : {"PS", "", "1:5M", "Special Military Map - Overlay", "CADRG"},
2141 : {"PT", "", "1:5M", "Special Military Purpose", "CADRG"},
2142 : {"PU", "", "1:5M", "Special Military Purpose", "CADRG"},
2143 : {"PV", "", "1:5M", "Special Military Purpose", "CADRG"},
2144 : {"R1", "", "1:50K", "Range Charts", "CADRG"},
2145 : {"R2", "", "1:100K", "Range Charts", "CADRG"},
2146 : {"R3", "", "1:250K", "Range Charts", "CADRG"},
2147 : {"R4", "", "1:500K", "Range Charts", "CADRG"},
2148 : {"R5", "", "1:1M", "Range Charts", "CADRG"},
2149 : {"RC", "RGS-100", "1:100K", "Russian General Staff Maps", "CADRG"},
2150 : {"RL", "RGS-50", "1:50K", "Russian General Staff Maps", "CADRG"},
2151 : {"RR", "RGS-200", "1:200K", "Russian General Staff Maps", "CADRG"},
2152 : {"RV", "Riverine", "1:50K", "Riverine Map 1:50,000 scale", "CADRG"},
2153 : {"TC", "TLM 100", "1:100K", "Topographic Line Map 1:100,000 scale",
2154 : "CADRG"},
2155 : {"TF", "TFC (Day)", "1:250K", "Transit Flying Chart (Day)", "CADRG"},
2156 : {"TL", "TLM50", "1:50K", "Topographic Line Map", "CADRG"},
2157 : {"TN", "TFC (Night)", "1:250K",
2158 : "Transit Flying Chart (Night) - Host Nation", "CADRG"},
2159 : {"TP", "TPC", "1:500K", "Tactical Pilotage Chart", "CADRG"},
2160 : {"TQ", "TLM24", "1:24K", "Topographic Line Map 1:24,000 scale", "CADRG"},
2161 : {"TR", "TLM200", "1:200K", "Topographic Line Map 1:200,000 scale", "CADRG"},
2162 : {"TT", "TLM25", "1:25K", "Topographic Line Map 1:25,000 scale", "CADRG"},
2163 : {"UL", "TLM50 - Other", "1:50K",
2164 : "Topographic Line Map (other 1:50,000 scale)", "CADRG"},
2165 : {"V1", "Inset HRC", "1:50", "Helicopter Route Chart Inset", "CADRG"},
2166 : {"V2", "Inset HRC", "1:62500", "Helicopter Route Chart Inset", "CADRG"},
2167 : {"V3", "Inset HRC", "1:90K", "Helicopter Route Chart Inset", "CADRG"},
2168 : {"V4", "Inset HRC", "1:250K", "Helicopter Route Chart Inset", "CADRG"},
2169 : {"VH", "HRC", "1:125K", "Helicopter Route Chart", "CADRG"},
2170 : {"VN", "VNC", "1:500K", "Visual Navigation Charts", "CADRG"},
2171 : {"VT", "VTAC", "1:250K", "VFR Terminal Area Chart", "CADRG"},
2172 : {"WA", "", "1:250K", "IFR Enroute Low", "CADRG"},
2173 : {"WB", "", "1:500K", "IFR Enroute Low", "CADRG"},
2174 : {"WC", "", "1:750K", "IFR Enroute Low", "CADRG"},
2175 : {"WD", "", "1:1M", "IFR Enroute Low", "CADRG"},
2176 : {"WE", "", "1:1.5M", "IFR Enroute Low", "CADRG"},
2177 : {"WF", "", "1:2M", "IFR Enroute Low", "CADRG"},
2178 : {"WG", "", "1:2.5M", "IFR Enroute Low", "CADRG"},
2179 : {"WH", "", "1:3M", "IFR Enroute Low", "CADRG"},
2180 : {"WI", "", "1:3.5M", "IFR Enroute Low", "CADRG"},
2181 : {"WK", "", "1:4M", "IFR Enroute Low", "CADRG"},
2182 : {"XD", "", "1:1M", "IFR Enroute High", "CADRG"},
2183 : {"XE", "", "1:1.5M", "IFR Enroute High", "CADRG"},
2184 : {"XF", "", "1:2M", "IFR Enroute High", "CADRG"},
2185 : {"XG", "", "1:2.5M", "IFR Enroute High", "CADRG"},
2186 : {"XH", "", "1:3M", "IFR Enroute High", "CADRG"},
2187 : {"XI", "", "1:3.5M", "IFR Enroute High", "CADRG"},
2188 : {"XJ", "", "1:4M", "IFR Enroute High", "CADRG"},
2189 : {"XK", "", "1:4.5M", "IFR Enroute High", "CADRG"},
2190 : {"Y9", "", "1:16.5M", "IFR Enroute Area", "CADRG"},
2191 : {"YA", "", "1:250K", "IFR Enroute Area", "CADRG"},
2192 : {"YB", "", "1:500K", "IFR Enroute Area", "CADRG"},
2193 : {"YC", "", "1:750K", "IFR Enroute Area", "CADRG"},
2194 : {"YD", "", "1:1M", "IFR Enroute Area", "CADRG"},
2195 : {"YE", "", "1:1.5M", "IFR Enroute Area", "CADRG"},
2196 : {"YF", "", "1:2M", "IFR Enroute Area", "CADRG"},
2197 : {"YI", "", "1:3.5M", "IFR Enroute Area", "CADRG"},
2198 : {"YJ", "", "1:4M", "IFR Enroute Area", "CADRG"},
2199 : {"YZ", "", "1:12M", "IFR Enroute Area", "CADRG"},
2200 : {"ZA", "", "1:250K", "IFR Enroute High/Low", "CADRG"},
2201 : {"ZB", "", "1:500K", "IFR Enroute High/Low", "CADRG"},
2202 : {"ZC", "", "1:750K", "IFR Enroute High/Low", "CADRG"},
2203 : {"ZD", "", "1:1M", "IFR Enroute High/Low", "CADRG"},
2204 : {"ZE", "", "1:1.5M", "IFR Enroute High/Low", "CADRG"},
2205 : {"ZF", "", "1:2M", "IFR Enroute High/Low", "CADRG"},
2206 : {"ZG", "", "1:2.5M", "IFR Enroute High/Low", "CADRG"},
2207 : {"ZH", "", "1:3M", "IFR Enroute High/Low", "CADRG"},
2208 : {"ZI", "", "1:3.5M", "IFR Enroute High/Low", "CADRG"},
2209 : {"ZJ", "", "1:4M", "IFR Enroute High/Low", "CADRG"},
2210 : {"ZK", "", "1:4.5M", "IFR Enroute High/Low", "CADRG"},
2211 : {"ZT", "", "1:9M", "IFR Enroute High/Low", "CADRG"},
2212 : {"ZV", "", "1:10M", "IFR Enroute High/Low", "CADRG"},
2213 : {"ZZ", "", "1:12M", "IFR Enroute High/Low", "CADRG"}};
2214 :
2215 : /* See 24111CN1.pdf paragraph 5.1.4 */
2216 630 : const NITFSeries *NITFGetSeriesInfo(const char *pszFilename)
2217 : {
2218 : int i;
2219 630 : char seriesCode[3] = {0, 0, 0};
2220 630 : if (pszFilename == nullptr)
2221 0 : return nullptr;
2222 3885 : for (i = static_cast<int>(strlen(pszFilename)) - 1; i >= 0; i--)
2223 : {
2224 3833 : if (pszFilename[i] == '.')
2225 : {
2226 583 : if (i < static_cast<int>(strlen(pszFilename)) - 3)
2227 : {
2228 578 : seriesCode[0] = pszFilename[i + 1];
2229 578 : seriesCode[1] = pszFilename[i + 2];
2230 100514 : for (const auto &series : nitfSeries)
2231 : {
2232 99987 : if (EQUAL(seriesCode, series.code))
2233 : {
2234 51 : return &series;
2235 : }
2236 : }
2237 527 : return nullptr;
2238 : }
2239 : }
2240 : }
2241 52 : return nullptr;
2242 : }
2243 :
2244 : /************************************************************************/
2245 : /* NITFCollectAttachments() */
2246 : /* */
2247 : /* Collect attachment, display level and location info into the */
2248 : /* segmentinfo structures. */
2249 : /************************************************************************/
2250 :
2251 374 : int NITFCollectAttachments(NITFFile *psFile)
2252 :
2253 : {
2254 : int iSegment;
2255 :
2256 : /* ==================================================================== */
2257 : /* Loop over all segments. */
2258 : /* ==================================================================== */
2259 8771 : for (iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++)
2260 : {
2261 8397 : NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
2262 :
2263 : /* --------------------------------------------------------------------
2264 : */
2265 : /* For image segments, we use the normal image access stuff. */
2266 : /* --------------------------------------------------------------------
2267 : */
2268 8397 : if (EQUAL(psSegInfo->szSegmentType, "IM"))
2269 : {
2270 8371 : NITFImage *psImage = NITFImageAccess(psFile, iSegment);
2271 8371 : if (psImage == nullptr)
2272 0 : return FALSE;
2273 :
2274 8371 : psSegInfo->nDLVL = psImage->nIDLVL;
2275 8371 : psSegInfo->nALVL = psImage->nIALVL;
2276 8371 : psSegInfo->nLOC_R = psImage->nILOCRow;
2277 8371 : psSegInfo->nLOC_C = psImage->nILOCColumn;
2278 : }
2279 : /* --------------------------------------------------------------------
2280 : */
2281 : /* For graphic file we need to process the header. */
2282 : /* --------------------------------------------------------------------
2283 : */
2284 26 : else if (EQUAL(psSegInfo->szSegmentType, "SY") ||
2285 26 : EQUAL(psSegInfo->szSegmentType, "GR"))
2286 : {
2287 : char achSubheader[298];
2288 : int nSTYPEOffset;
2289 : char szTemp[100];
2290 :
2291 : /* --------------------------------------------------------------------
2292 : */
2293 : /* Load the graphic subheader. */
2294 : /* --------------------------------------------------------------------
2295 : */
2296 1 : if (VSIFSeekL(psFile->fp, psSegInfo->nSegmentHeaderStart,
2297 2 : SEEK_SET) != 0 ||
2298 1 : VSIFReadL(achSubheader, 1, sizeof(achSubheader), psFile->fp) <
2299 : 258)
2300 : {
2301 0 : CPLError(CE_Warning, CPLE_FileIO,
2302 : "Failed to read graphic subheader at " CPL_FRMT_GUIB
2303 : ".",
2304 : psSegInfo->nSegmentHeaderStart);
2305 0 : continue;
2306 : }
2307 :
2308 : // NITF 2.0. (also works for NITF 2.1)
2309 1 : nSTYPEOffset = 200;
2310 1 : if (STARTS_WITH_CI(achSubheader + 193, "999998"))
2311 0 : nSTYPEOffset += 40;
2312 :
2313 : /* --------------------------------------------------------------------
2314 : */
2315 : /* Report some standard info. */
2316 : /* --------------------------------------------------------------------
2317 : */
2318 1 : psSegInfo->nDLVL =
2319 1 : atoi(NITFGetField(szTemp, achSubheader, nSTYPEOffset + 14, 3));
2320 1 : psSegInfo->nALVL =
2321 1 : atoi(NITFGetField(szTemp, achSubheader, nSTYPEOffset + 17, 3));
2322 1 : psSegInfo->nLOC_R =
2323 1 : atoi(NITFGetField(szTemp, achSubheader, nSTYPEOffset + 20, 5));
2324 1 : psSegInfo->nLOC_C =
2325 1 : atoi(NITFGetField(szTemp, achSubheader, nSTYPEOffset + 25, 5));
2326 : }
2327 : }
2328 :
2329 374 : return TRUE;
2330 : }
2331 :
2332 : /************************************************************************/
2333 : /* NITFReconcileAttachments() */
2334 : /* */
2335 : /* Generate the CCS location information for all the segments */
2336 : /* if possible. */
2337 : /************************************************************************/
2338 :
2339 374 : int NITFReconcileAttachments(NITFFile *psFile)
2340 :
2341 : {
2342 : int iSegment;
2343 374 : int bSuccess = TRUE;
2344 374 : int bMadeProgress = FALSE;
2345 :
2346 8771 : for (iSegment = 0; iSegment < psFile->nSegmentCount; iSegment++)
2347 : {
2348 8397 : NITFSegmentInfo *psSegInfo = psFile->pasSegmentInfo + iSegment;
2349 : int iOther;
2350 :
2351 : // already processed?
2352 8397 : if (psSegInfo->nCCS_R != -1)
2353 0 : continue;
2354 :
2355 : // unattached segments are straight forward.
2356 8397 : if (psSegInfo->nALVL < 1)
2357 : {
2358 8396 : psSegInfo->nCCS_R = psSegInfo->nLOC_R;
2359 8396 : psSegInfo->nCCS_C = psSegInfo->nLOC_C;
2360 8396 : if (psSegInfo->nCCS_R != -1)
2361 8371 : bMadeProgress = TRUE;
2362 8396 : continue;
2363 : }
2364 :
2365 : // Loc for segment to which we are attached.
2366 1 : for (iOther = 0; iOther < psFile->nSegmentCount; iOther++)
2367 : {
2368 1 : NITFSegmentInfo *psOtherSegInfo = psFile->pasSegmentInfo + iOther;
2369 :
2370 1 : if (psSegInfo->nALVL == psOtherSegInfo->nDLVL)
2371 : {
2372 1 : if (psOtherSegInfo->nCCS_R != -1)
2373 : {
2374 1 : psSegInfo->nCCS_R =
2375 1 : psOtherSegInfo->nLOC_R + psSegInfo->nLOC_R;
2376 1 : psSegInfo->nCCS_C =
2377 1 : psOtherSegInfo->nLOC_C + psSegInfo->nLOC_C;
2378 1 : if (psSegInfo->nCCS_R != -1)
2379 1 : bMadeProgress = TRUE;
2380 : }
2381 : else
2382 : {
2383 0 : bSuccess = FALSE;
2384 : }
2385 1 : break;
2386 : }
2387 : }
2388 :
2389 1 : if (iOther == psFile->nSegmentCount)
2390 0 : bSuccess = FALSE;
2391 : }
2392 :
2393 : /* -------------------------------------------------------------------- */
2394 : /* If succeeded or made no progress then return our success */
2395 : /* flag. Otherwise make another pass, hopefully filling in */
2396 : /* more values. */
2397 : /* -------------------------------------------------------------------- */
2398 374 : if (bSuccess || !bMadeProgress)
2399 374 : return bSuccess;
2400 : else
2401 0 : return NITFReconcileAttachments(psFile);
2402 : }
2403 :
2404 : /************************************************************************/
2405 : /* NITFFindValFromEnd() */
2406 : /************************************************************************/
2407 :
2408 1827 : static const char *NITFFindValFromEnd(CSLConstList papszMD, int nMDSize,
2409 : const char *pszVar,
2410 : const char * /*pszDefault*/)
2411 : {
2412 1827 : const size_t nVarLen = strlen(pszVar);
2413 72420 : for (int nIter = nMDSize - 1; nIter >= 0; nIter--)
2414 : {
2415 71336 : if (strncmp(papszMD[nIter], pszVar, nVarLen) == 0 &&
2416 745 : papszMD[nIter][nVarLen] == '=')
2417 743 : return papszMD[nIter] + nVarLen + 1;
2418 : }
2419 1084 : return nullptr;
2420 : }
2421 :
2422 : /************************************************************************/
2423 : /* NITFFindValRecursive() */
2424 : /************************************************************************/
2425 :
2426 731 : static const char *NITFFindValRecursive(CSLConstList papszMD, int nMDSize,
2427 : const char *pszMDPrefix,
2428 : const char *pszVar)
2429 : {
2430 1462 : std::string osMDItemName = std::string(pszMDPrefix).append(pszVar);
2431 : const char *pszCondVal =
2432 731 : NITFFindValFromEnd(papszMD, nMDSize, osMDItemName.c_str(), nullptr);
2433 :
2434 731 : if (pszCondVal == nullptr)
2435 : {
2436 : /* Needed for SENSRB */
2437 : /* See https://github.com/OSGeo/gdal/issues/1520 */
2438 : /* If the condition variable is not found at this level, */
2439 : /* try to research it at upper levels by shortening on _ */
2440 : /* separators */
2441 668 : std::string osMDPrefixShortened(pszMDPrefix);
2442 334 : auto pos = osMDPrefixShortened.rfind('_');
2443 334 : if (pos != std::string::npos)
2444 : {
2445 334 : osMDPrefixShortened.resize(pos);
2446 334 : pos = osMDPrefixShortened.rfind('_');
2447 : }
2448 1084 : while (pos != std::string::npos)
2449 : {
2450 1081 : osMDPrefixShortened.resize(pos);
2451 1081 : osMDItemName = osMDPrefixShortened;
2452 1081 : osMDItemName += '_';
2453 1081 : osMDItemName += pszVar;
2454 1081 : pszCondVal = NITFFindValFromEnd(papszMD, nMDSize,
2455 : osMDItemName.c_str(), nullptr);
2456 1081 : if (pszCondVal)
2457 331 : break;
2458 750 : pos = osMDPrefixShortened.rfind('_');
2459 : }
2460 :
2461 334 : if (!pszCondVal)
2462 3 : pszCondVal = NITFFindValFromEnd(papszMD, nMDSize, pszVar, nullptr);
2463 : }
2464 :
2465 1462 : return pszCondVal;
2466 : }
2467 :
2468 : /************************************************************************/
2469 : /* CSLSplit() */
2470 : /************************************************************************/
2471 :
2472 0 : static char **CSLSplit(const char *pszStr, const char *pszSplitter)
2473 : {
2474 0 : char **papszRet = nullptr;
2475 0 : const char *pszIter = pszStr;
2476 : while (TRUE)
2477 : {
2478 0 : const char *pszNextSplitter = strstr(pszIter, pszSplitter);
2479 0 : if (pszNextSplitter == nullptr)
2480 : {
2481 0 : papszRet = CSLAddString(papszRet, pszIter);
2482 0 : break;
2483 : }
2484 0 : size_t nLen = static_cast<size_t>(pszNextSplitter - pszIter);
2485 0 : char *pszToken = static_cast<char *>(CPLMalloc(nLen + 1));
2486 0 : memcpy(pszToken, pszIter, nLen);
2487 0 : pszToken[nLen] = 0;
2488 0 : papszRet = CSLAddString(papszRet, pszToken);
2489 0 : CPLFree(pszToken);
2490 0 : pszIter = pszNextSplitter + strlen(pszSplitter);
2491 0 : }
2492 0 : return papszRet;
2493 : }
2494 :
2495 : /************************************************************************/
2496 : /* NITFEvaluateCond() */
2497 : /************************************************************************/
2498 :
2499 534 : static int NITFEvaluateCond(const char *pszCond, char **papszMD, int *pnMDSize,
2500 : const char *pszMDPrefix,
2501 : const char *pszDESOrTREKind,
2502 : const char *pszDESOrTREName)
2503 : {
2504 534 : const char *pszAnd = strstr(pszCond, " AND ");
2505 534 : const char *pszOr = strstr(pszCond, " OR ");
2506 534 : if (pszAnd && pszOr)
2507 : {
2508 0 : CPLError(CE_Warning, CPLE_AppDefined,
2509 : "Unsupported if condition in %s %s in XML resource: %s. "
2510 : "AND and OR conditions cannot be used at the same time",
2511 : pszDESOrTREName, pszDESOrTREKind, pszCond);
2512 0 : return -1;
2513 : }
2514 :
2515 534 : int nRet = 0;
2516 : const char *pszOperator;
2517 534 : if (pszAnd)
2518 : {
2519 0 : char **papszTokens = CSLSplit(pszCond, " AND ");
2520 0 : for (char **papszIter = papszTokens; *papszIter; ++papszIter)
2521 : {
2522 0 : nRet = NITFEvaluateCond(*papszIter, papszMD, pnMDSize, pszMDPrefix,
2523 : pszDESOrTREKind, pszDESOrTREName);
2524 : // exit early as soon as we have a negative evaluation (or error)
2525 0 : if (nRet != 1)
2526 0 : break;
2527 : }
2528 0 : CSLDestroy(papszTokens);
2529 : }
2530 534 : else if (pszOr)
2531 : {
2532 0 : char **papszTokens = CSLSplit(pszCond, " OR ");
2533 0 : for (char **papszIter = papszTokens; *papszIter; ++papszIter)
2534 : {
2535 0 : nRet = NITFEvaluateCond(*papszIter, papszMD, pnMDSize, pszMDPrefix,
2536 : pszDESOrTREKind, pszDESOrTREName);
2537 : // exit early as soon as we have a positive evaluation (or error)
2538 0 : if (nRet != 0)
2539 0 : break;
2540 : }
2541 0 : CSLDestroy(papszTokens);
2542 : }
2543 534 : else if ((pszOperator = strchr(pszCond, '=')) != nullptr)
2544 : {
2545 : char *pszCondVar =
2546 384 : static_cast<char *>(CPLMalloc(pszOperator - pszCond + 1));
2547 384 : const char *pszCondExpectedVal = pszOperator + 1;
2548 : const char *pszCondVal;
2549 384 : int bTestEqual = FALSE;
2550 384 : int bTestNotEqual = FALSE;
2551 384 : int bTestGreaterOrEqual = FALSE;
2552 384 : memcpy(pszCondVar, pszCond, pszOperator - pszCond);
2553 384 : if (pszOperator - pszCond > 1 &&
2554 384 : pszCondVar[pszOperator - pszCond - 1] == '!')
2555 : {
2556 64 : bTestNotEqual = TRUE;
2557 64 : pszCondVar[pszOperator - pszCond - 1] = '\0';
2558 : }
2559 320 : else if (pszOperator - pszCond > 1 &&
2560 320 : pszCondVar[pszOperator - pszCond - 1] == '>')
2561 : {
2562 0 : bTestGreaterOrEqual = TRUE;
2563 0 : pszCondVar[pszOperator - pszCond - 1] = '\0';
2564 : }
2565 : else
2566 : {
2567 320 : bTestEqual = TRUE;
2568 : }
2569 384 : pszCondVar[pszOperator - pszCond] = '\0';
2570 : pszCondVal =
2571 384 : NITFFindValRecursive(papszMD, *pnMDSize, pszMDPrefix, pszCondVar);
2572 384 : if (pszCondVal == nullptr)
2573 : {
2574 0 : CPLDebug("NITF", "Cannot find if cond variable %s", pszCondVar);
2575 : }
2576 384 : else if ((bTestEqual && strcmp(pszCondVal, pszCondExpectedVal) == 0) ||
2577 64 : (bTestNotEqual &&
2578 306 : strcmp(pszCondVal, pszCondExpectedVal) != 0) ||
2579 0 : (bTestGreaterOrEqual &&
2580 0 : strcmp(pszCondVal, pszCondExpectedVal) >= 0))
2581 : {
2582 110 : nRet = 1;
2583 : }
2584 384 : CPLFree(pszCondVar);
2585 : }
2586 150 : else if ((pszOperator = strchr(pszCond, ':')) != nullptr)
2587 : {
2588 : char *pszCondVar =
2589 150 : static_cast<char *>(CPLMalloc(pszOperator - pszCond + 1));
2590 150 : const char *pszCondTestBit = pszOperator + 1;
2591 : const char *pszCondVal;
2592 150 : memcpy(pszCondVar, pszCond, pszOperator - pszCond);
2593 150 : pszCondVar[pszOperator - pszCond] = '\0';
2594 : pszCondVal =
2595 150 : NITFFindValRecursive(papszMD, *pnMDSize, pszMDPrefix, pszCondVar);
2596 150 : if (pszCondVal == nullptr)
2597 : {
2598 0 : CPLDebug("NITF", "Cannot find if cond variable %s", pszCondVar);
2599 : }
2600 150 : else if (strtoul(pszCondVal, nullptr, 10) &
2601 150 : (1U << static_cast<unsigned>(atoi(pszCondTestBit))))
2602 : {
2603 30 : nRet = 1;
2604 : }
2605 150 : CPLFree(pszCondVar);
2606 : }
2607 : else
2608 : {
2609 0 : CPLError(CE_Warning, CPLE_AppDefined,
2610 : "Invalid if construct in %s %s in XML resource: %s. "
2611 : "invalid 'cond' attribute",
2612 : pszDESOrTREName, pszDESOrTREKind, pszCond);
2613 0 : return -1;
2614 : }
2615 534 : return nRet;
2616 : }
2617 :
2618 : /************************************************************************/
2619 : /* NITFGenericMetadataReadTREInternal() */
2620 : /************************************************************************/
2621 :
2622 2095 : static char **NITFGenericMetadataReadTREInternal(
2623 : char **papszMD, int *pnMDSize, int *pnMDAlloc, CPLXMLNode *psOutXMLNode,
2624 : const char *pszDESOrTREKind, const char *pszDESOrTREName,
2625 : const char *pachTRE, int nTRESize, const CPLXMLNode *psTreNode,
2626 : int *pnTreOffset, const char *pszMDPrefix, bool bValidate, VSILFILE *fp,
2627 : std::map<NITFLocId, const CPLXMLNode *> &oMapLocIdToXML, int *pbError)
2628 : {
2629 2095 : const bool bRPFIMG = psOutXMLNode && EQUAL(pszDESOrTREName, "RPFIMG");
2630 2095 : if (bRPFIMG && oMapLocIdToXML.empty())
2631 : {
2632 : #define LOCATION_ENTRY(x) \
2633 : { \
2634 : std::string(#x), LID_##x \
2635 : }
2636 : static const std::map<std::string, NITFLocId> goMapLocationNameToID = {
2637 2 : LOCATION_ENTRY(HeaderComponent),
2638 2 : LOCATION_ENTRY(LocationComponent),
2639 2 : LOCATION_ENTRY(CoverageSectionSubheader),
2640 2 : LOCATION_ENTRY(CompressionSectionSubsection),
2641 2 : LOCATION_ENTRY(CompressionLookupSubsection),
2642 2 : LOCATION_ENTRY(CompressionParameterSubsection),
2643 2 : LOCATION_ENTRY(ColorGrayscaleSectionSubheader),
2644 2 : LOCATION_ENTRY(ColormapSubsection),
2645 2 : LOCATION_ENTRY(ImageDescriptionSubheader),
2646 2 : LOCATION_ENTRY(ImageDisplayParametersSubheader),
2647 2 : LOCATION_ENTRY(MaskSubsection),
2648 2 : LOCATION_ENTRY(ColorConverterSubsection),
2649 2 : LOCATION_ENTRY(SpatialDataSubsection),
2650 2 : LOCATION_ENTRY(AttributeSectionSubheader),
2651 2 : LOCATION_ENTRY(AttributeSubsection),
2652 2 : LOCATION_ENTRY(ExplicitArealCoverageTable),
2653 2 : LOCATION_ENTRY(RelatedImagesSectionSubheader),
2654 2 : LOCATION_ENTRY(RelatedImagesSubsection),
2655 2 : LOCATION_ENTRY(ReplaceUpdateSectionSubheader),
2656 2 : LOCATION_ENTRY(ReplaceUpdateTable),
2657 2 : LOCATION_ENTRY(BoundaryRectangleSectionSubheader),
2658 2 : LOCATION_ENTRY(BoundaryRectangleTable),
2659 2 : LOCATION_ENTRY(FrameFileIndexSectionSubHeader),
2660 2 : LOCATION_ENTRY(FrameFileIndexSubsection),
2661 2 : LOCATION_ENTRY(ColorTableIndexSectionSubheader),
2662 2 : LOCATION_ENTRY(ColorTableIndexRecord),
2663 53 : };
2664 : #undef LOCATION_ENTRY
2665 :
2666 1 : for (const CPLXMLNode *psIter = psTreNode->psChild;
2667 22 : psIter != nullptr && *pbError == FALSE; psIter = psIter->psNext)
2668 : {
2669 21 : if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
2670 18 : strcmp(psIter->pszValue, "rpf_component") == 0)
2671 : {
2672 12 : const char *pszId = CPLGetXMLValue(psIter, "id", nullptr);
2673 12 : if (pszId)
2674 : {
2675 12 : auto oIterMap = goMapLocationNameToID.find(pszId);
2676 12 : if (oIterMap != goMapLocationNameToID.end())
2677 : {
2678 12 : oMapLocIdToXML[oIterMap->second] = psIter;
2679 : }
2680 : else
2681 : {
2682 0 : CPLError(CE_Warning, CPLE_AppDefined,
2683 : "rpf_component id=%s unknown", pszId);
2684 : }
2685 : }
2686 : }
2687 : }
2688 : }
2689 :
2690 2095 : int nRPFLocationId = 0;
2691 2095 : uint32_t nRPFLocationOffset = 0;
2692 2095 : uint32_t nRPFLocationSize = 0;
2693 :
2694 2095 : for (const CPLXMLNode *psIter = psTreNode->psChild;
2695 12606 : psIter != nullptr && *pbError == FALSE; psIter = psIter->psNext)
2696 : {
2697 10513 : if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
2698 4608 : strcmp(psIter->pszValue, "field") == 0)
2699 : {
2700 3782 : const char *pszName = CPLGetXMLValue(psIter, "name", nullptr);
2701 : const char *pszLongName =
2702 3782 : CPLGetXMLValue(psIter, "longname", nullptr);
2703 3782 : const char *pszLength = CPLGetXMLValue(psIter, "length", nullptr);
2704 3782 : const char *pszType = CPLGetXMLValue(psIter, "type", "string");
2705 3782 : const char *pszMinVal = CPLGetXMLValue(psIter, "minval", nullptr);
2706 3782 : const char *pszMaxVal = CPLGetXMLValue(psIter, "maxval", nullptr);
2707 3782 : int nLength = -1;
2708 3782 : if (pszLength != nullptr)
2709 3749 : nLength = atoi(pszLength);
2710 : else
2711 : {
2712 : const char *pszLengthVar =
2713 33 : CPLGetXMLValue(psIter, "length_var", nullptr);
2714 33 : if (pszLengthVar != nullptr)
2715 : {
2716 : // Preferably look for item at the same level as ours.
2717 33 : const char *pszLengthValue = CSLFetchNameValue(
2718 : papszMD, CPLSPrintf("%s%s", pszMDPrefix, pszLengthVar));
2719 33 : if (pszLengthValue != nullptr)
2720 : {
2721 30 : nLength = atoi(pszLengthValue);
2722 : }
2723 : else
2724 : {
2725 3 : char **papszMDIter = papszMD;
2726 191 : while (papszMDIter != nullptr &&
2727 191 : *papszMDIter != nullptr)
2728 : {
2729 188 : if (strstr(*papszMDIter, pszLengthVar) != nullptr)
2730 : {
2731 : const char *pszEqual =
2732 3 : strchr(*papszMDIter, '=');
2733 3 : if (pszEqual != nullptr)
2734 : {
2735 3 : nLength = atoi(pszEqual + 1);
2736 : // Voluntary missing break so as to find the
2737 : // "closest" item to ours in case it is not
2738 : // defined in the same level
2739 : }
2740 : }
2741 188 : papszMDIter++;
2742 : }
2743 : }
2744 : }
2745 : }
2746 3782 : if (pszName != nullptr && nLength > 0)
2747 : {
2748 3734 : char **papszTmp = nullptr;
2749 3734 : char *pszValue = nullptr;
2750 :
2751 3734 : if (*pnTreOffset + nLength > nTRESize)
2752 : {
2753 2 : *pbError = TRUE;
2754 2 : CPLError(bValidate ? CE_Failure : CE_Warning,
2755 : CPLE_AppDefined,
2756 : "Not enough bytes when reading %s %s "
2757 : "(at least %d needed, only %d available)",
2758 : pszDESOrTREName, pszDESOrTREKind,
2759 2 : *pnTreOffset + nLength, nTRESize);
2760 2 : break;
2761 : }
2762 :
2763 : const std::string osMDItemName =
2764 3732 : CPLSPrintf("%s%s", pszMDPrefix, pszName);
2765 :
2766 3732 : if (strcmp(pszType, "IEEE754_Float32_BigEndian") == 0)
2767 : {
2768 9 : if (nLength == 4)
2769 : {
2770 9 : const size_t nBufferSize = 128;
2771 : float f;
2772 9 : memcpy(&f, pachTRE + *pnTreOffset, sizeof(f));
2773 9 : CPL_MSBPTR32(&f);
2774 9 : pszValue = static_cast<char *>(CPLMalloc(nBufferSize));
2775 9 : CPLsnprintf(pszValue, nBufferSize, "%f", f);
2776 9 : papszTmp = CSLSetNameValue(
2777 : papszTmp, osMDItemName.c_str(), pszValue);
2778 : }
2779 : else
2780 : {
2781 0 : *pbError = TRUE;
2782 0 : CPLError(bValidate ? CE_Failure : CE_Warning,
2783 : CPLE_AppDefined,
2784 : "IEEE754_Float32_BigEndian field must be 4 "
2785 : "bytes in %s %s",
2786 : pszDESOrTREName, pszDESOrTREKind);
2787 0 : break;
2788 : }
2789 : }
2790 3723 : else if (strcmp(pszType, "IEEE754_Float64_BigEndian") == 0)
2791 : {
2792 12 : if (nLength == 8)
2793 : {
2794 : double df;
2795 12 : memcpy(&df, pachTRE + *pnTreOffset, sizeof(df));
2796 12 : CPL_MSBPTR64(&df);
2797 12 : const int nBufferSize = 24;
2798 12 : pszValue = static_cast<char *>(CPLMalloc(nBufferSize));
2799 12 : CPLsnprintf(pszValue, nBufferSize, "%.17g", df);
2800 12 : papszTmp = CSLSetNameValue(
2801 : papszTmp, osMDItemName.c_str(), pszValue);
2802 : }
2803 : else
2804 : {
2805 0 : *pbError = TRUE;
2806 0 : CPLError(bValidate ? CE_Failure : CE_Warning,
2807 : CPLE_AppDefined,
2808 : "IEEE754_Float64_BigEndian field must be 8 "
2809 : "bytes in %s %s",
2810 : pszDESOrTREName, pszDESOrTREKind);
2811 0 : break;
2812 : }
2813 : }
2814 3711 : else if (strcmp(pszType, "UnsignedInt_BigEndian") == 0 ||
2815 3619 : strcmp(pszType, "bitmask") == 0)
2816 : {
2817 98 : if (nLength <= 8)
2818 : {
2819 98 : const size_t nBufferSize = 21;
2820 98 : uint64_t nVal = 0;
2821 : GByte byData;
2822 :
2823 : int i;
2824 409 : for (i = 0; i < nLength; ++i)
2825 : {
2826 311 : memcpy(&byData, pachTRE + *pnTreOffset + i, 1);
2827 311 : nVal += static_cast<uint64_t>(byData)
2828 311 : << 8 * (nLength - i - 1);
2829 : }
2830 :
2831 98 : pszValue = static_cast<char *>(CPLMalloc(nBufferSize));
2832 98 : CPLsnprintf(pszValue, nBufferSize, CPL_FRMT_GUIB,
2833 : static_cast<GUIntBig>(nVal));
2834 98 : papszTmp = CSLSetNameValue(
2835 : papszTmp, osMDItemName.c_str(), pszValue);
2836 : }
2837 : else
2838 : {
2839 0 : *pbError = TRUE;
2840 0 : CPLError(bValidate ? CE_Failure : CE_Warning,
2841 : CPLE_AppDefined,
2842 : "UnsignedInt/bitmask field must be <= 8 bytes "
2843 : "in %s %s",
2844 : pszDESOrTREName, pszDESOrTREKind);
2845 0 : break;
2846 98 : }
2847 : }
2848 3613 : else if (strcmp(pszType, "ISO8859-1") == 0)
2849 : {
2850 41 : NITFExtractMetadata(&papszTmp, pachTRE, *pnTreOffset,
2851 : nLength, osMDItemName.c_str());
2852 :
2853 41 : pszValue = CPLStrdup(
2854 : CSLFetchNameValue(papszTmp, osMDItemName.c_str()));
2855 : }
2856 : else
2857 : {
2858 3572 : NITFExtractAndRecodeMetadata(
2859 : &papszTmp, pachTRE, *pnTreOffset, nLength,
2860 : osMDItemName.c_str(), CPL_ENC_UTF8);
2861 :
2862 3572 : pszValue = CPLStrdup(strchr(papszTmp[0], '=') + 1);
2863 : }
2864 :
2865 3732 : if (papszTmp)
2866 : {
2867 3732 : if (*pnMDSize + 1 >= *pnMDAlloc)
2868 : {
2869 157 : *pnMDAlloc = (*pnMDAlloc * 4 / 3) + 32;
2870 : papszMD = static_cast<char **>(
2871 157 : CPLRealloc(papszMD, *pnMDAlloc * sizeof(char *)));
2872 : }
2873 3732 : papszMD[*pnMDSize] = papszTmp[0];
2874 3732 : papszMD[(*pnMDSize) + 1] = nullptr;
2875 3732 : (*pnMDSize)++;
2876 3732 : papszTmp[0] = nullptr;
2877 3732 : CSLDestroy(papszTmp);
2878 : }
2879 :
2880 3732 : CPLXMLNode *psFieldNode = nullptr;
2881 3732 : if (pszValue != nullptr && psOutXMLNode != nullptr)
2882 : {
2883 : CPLXMLNode *psNameNode;
2884 : CPLXMLNode *psValueNode;
2885 :
2886 : psFieldNode =
2887 2974 : CPLCreateXMLNode(psOutXMLNode, CXT_Element, "field");
2888 : psNameNode =
2889 2974 : CPLCreateXMLNode(psFieldNode, CXT_Attribute, "name");
2890 : psValueNode =
2891 2974 : CPLCreateXMLNode(psFieldNode, CXT_Attribute, "value");
2892 2974 : CPLCreateXMLNode(psNameNode, CXT_Text,
2893 2974 : (pszName[0] || pszLongName == nullptr)
2894 : ? pszName
2895 : : pszLongName);
2896 2974 : CPLCreateXMLNode(psValueNode, CXT_Text, pszValue);
2897 : }
2898 :
2899 3732 : if (pszValue != nullptr)
2900 : {
2901 3732 : if (pszMinVal != nullptr)
2902 : {
2903 693 : bool bMinValConstraintOK = true;
2904 693 : if (strcmp(pszType, "real") == 0)
2905 : {
2906 183 : bMinValConstraintOK =
2907 183 : CPLAtof(pszValue) >= CPLAtof(pszMinVal);
2908 : }
2909 510 : else if (strcmp(pszType, "integer") == 0)
2910 : {
2911 504 : bMinValConstraintOK = CPLAtoGIntBig(pszValue) >=
2912 504 : CPLAtoGIntBig(pszMinVal);
2913 : }
2914 693 : if (!bMinValConstraintOK)
2915 : {
2916 68 : if (bValidate)
2917 : {
2918 2 : CPLError(CE_Failure, CPLE_AppDefined,
2919 : "%s %s: minimum value constraint of "
2920 : "%s for %s=%s not met",
2921 : pszDESOrTREKind, pszDESOrTREName,
2922 : pszMinVal, pszName, pszValue);
2923 : }
2924 68 : if (psFieldNode)
2925 : {
2926 68 : CPLCreateXMLElementAndValue(
2927 : psFieldNode,
2928 : bValidate ? "error" : "warning",
2929 : CPLSPrintf("Minimum value constraint of %s "
2930 : "not met",
2931 : pszMinVal));
2932 : }
2933 : }
2934 : }
2935 3732 : if (pszMaxVal != nullptr)
2936 : {
2937 660 : bool bMinValConstraintOK = true;
2938 660 : if (strcmp(pszType, "real") == 0)
2939 : {
2940 165 : bMinValConstraintOK =
2941 165 : CPLAtof(pszValue) <= CPLAtof(pszMaxVal);
2942 : }
2943 495 : else if (strcmp(pszType, "integer") == 0)
2944 : {
2945 489 : bMinValConstraintOK = CPLAtoGIntBig(pszValue) <=
2946 489 : CPLAtoGIntBig(pszMaxVal);
2947 : }
2948 660 : if (!bMinValConstraintOK)
2949 : {
2950 2 : if (bValidate)
2951 : {
2952 2 : CPLError(CE_Failure, CPLE_AppDefined,
2953 : "%s %s: maximum value constraint of "
2954 : "%s for %s=%s not met",
2955 : pszDESOrTREKind, pszDESOrTREName,
2956 : pszMaxVal, pszName, pszValue);
2957 : }
2958 2 : if (psFieldNode)
2959 : {
2960 2 : CPLCreateXMLElementAndValue(
2961 : psFieldNode,
2962 : bValidate ? "error" : "warning",
2963 : CPLSPrintf("Maximum value constraint of %s "
2964 : "not met",
2965 : pszMaxVal));
2966 : }
2967 : }
2968 : }
2969 : }
2970 :
2971 3732 : if (bRPFIMG && pszValue != nullptr)
2972 : {
2973 86 : if (EQUAL(pszName, "COMPONENT_ID"))
2974 : {
2975 10 : nRPFLocationId = atoi(pszValue);
2976 : }
2977 76 : else if (EQUAL(pszName, "COMPONENT_LENGTH"))
2978 : {
2979 10 : nRPFLocationSize = static_cast<uint32_t>(
2980 10 : strtoul(pszValue, nullptr, 10));
2981 : }
2982 66 : else if (EQUAL(pszName, "COMPONENT_LOCATION"))
2983 : {
2984 10 : nRPFLocationOffset = static_cast<uint32_t>(
2985 10 : strtoul(pszValue, nullptr, 10));
2986 : }
2987 : }
2988 :
2989 3732 : CPLFree(pszValue);
2990 :
2991 7464 : *pnTreOffset += nLength;
2992 : }
2993 48 : else if (nLength > 0)
2994 : {
2995 48 : *pnTreOffset += nLength;
2996 : }
2997 : else
2998 : {
2999 0 : *pbError = TRUE;
3000 0 : CPLError(bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3001 : "Invalid item construct in %s %s in XML resource",
3002 : pszDESOrTREName, pszDESOrTREKind);
3003 0 : break;
3004 3780 : }
3005 : }
3006 6731 : else if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
3007 826 : strcmp(psIter->pszValue, "loop") == 0)
3008 : {
3009 276 : const char *pszCounter = CPLGetXMLValue(psIter, "counter", nullptr);
3010 : const char *pszIterations =
3011 276 : CPLGetXMLValue(psIter, "iterations", nullptr);
3012 276 : const char *pszFormula = CPLGetXMLValue(psIter, "formula", nullptr);
3013 : const char *pszMDSubPrefix =
3014 276 : CPLGetXMLValue(psIter, "md_prefix", nullptr);
3015 276 : int nIterations = -1;
3016 :
3017 276 : if (pszCounter != nullptr)
3018 : {
3019 197 : const char *pszIterationsVal = NITFFindValRecursive(
3020 : papszMD, *pnMDSize, pszMDPrefix, pszCounter);
3021 394 : if (pszIterationsVal == nullptr ||
3022 197 : (nIterations = atoi(pszIterationsVal)) < 0)
3023 : {
3024 0 : CPLError(
3025 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3026 : "Invalid loop construct in %s %s in XML resource : "
3027 : "invalid 'counter' %s",
3028 : pszDESOrTREName, pszDESOrTREKind, pszCounter);
3029 0 : *pbError = TRUE;
3030 0 : break;
3031 : }
3032 : }
3033 79 : else if (pszIterations != nullptr)
3034 : {
3035 68 : nIterations = atoi(pszIterations);
3036 : }
3037 11 : else if (pszFormula != nullptr &&
3038 11 : strcmp(pszFormula, "NPAR*NPARO") == 0)
3039 : {
3040 : char *pszMDNPARName =
3041 1 : CPLStrdup(CPLSPrintf("%s%s", pszMDPrefix, "NPAR"));
3042 1 : int NPAR = atoi(NITFFindValFromEnd(papszMD, *pnMDSize,
3043 : pszMDNPARName, "-1"));
3044 : char *pszMDNPAROName =
3045 1 : CPLStrdup(CPLSPrintf("%s%s", pszMDPrefix, "NPARO"));
3046 1 : int NPARO = atoi(NITFFindValFromEnd(papszMD, *pnMDSize,
3047 : pszMDNPAROName, "-1"));
3048 1 : CPLFree(pszMDNPARName);
3049 1 : CPLFree(pszMDNPAROName);
3050 1 : if (NPAR < 0)
3051 : {
3052 0 : CPLError(
3053 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3054 : "Invalid loop construct in %s %s in XML resource : "
3055 : "invalid 'counter' %s",
3056 : pszDESOrTREName, pszDESOrTREKind, "NPAR");
3057 0 : *pbError = TRUE;
3058 0 : break;
3059 : }
3060 1 : if (NPARO < 0)
3061 : {
3062 0 : CPLError(
3063 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3064 : "Invalid loop construct in %s %s in XML resource : "
3065 : "invalid 'counter' %s",
3066 : pszDESOrTREName, pszDESOrTREKind, "NPAR0");
3067 0 : *pbError = TRUE;
3068 0 : break;
3069 : }
3070 1 : nIterations = NPAR * NPARO;
3071 : }
3072 10 : else if (pszFormula != nullptr && strcmp(pszFormula, "NPLN-1") == 0)
3073 : {
3074 : char *pszMDItemName =
3075 0 : CPLStrdup(CPLSPrintf("%s%s", pszMDPrefix, "NPLN"));
3076 0 : int NPLN = atoi(NITFFindValFromEnd(papszMD, *pnMDSize,
3077 : pszMDItemName, "-1"));
3078 0 : CPLFree(pszMDItemName);
3079 0 : if (NPLN < 0)
3080 : {
3081 0 : CPLError(
3082 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3083 : "Invalid loop construct in %s %s in XML resource : "
3084 : "invalid 'counter' %s",
3085 : pszDESOrTREName, pszDESOrTREKind, "NPLN");
3086 0 : *pbError = TRUE;
3087 0 : break;
3088 : }
3089 0 : nIterations = NPLN - 1;
3090 : }
3091 10 : else if (pszFormula != nullptr &&
3092 10 : strcmp(pszFormula, "NXPTS*NYPTS") == 0)
3093 : {
3094 : char *pszMDNPARName =
3095 0 : CPLStrdup(CPLSPrintf("%s%s", pszMDPrefix, "NXPTS"));
3096 0 : int NXPTS = atoi(NITFFindValFromEnd(papszMD, *pnMDSize,
3097 : pszMDNPARName, "-1"));
3098 : char *pszMDNPAROName =
3099 0 : CPLStrdup(CPLSPrintf("%s%s", pszMDPrefix, "NYPTS"));
3100 0 : int NYPTS = atoi(NITFFindValFromEnd(papszMD, *pnMDSize,
3101 : pszMDNPAROName, "-1"));
3102 0 : CPLFree(pszMDNPARName);
3103 0 : CPLFree(pszMDNPAROName);
3104 0 : if (NXPTS < 0)
3105 : {
3106 0 : CPLError(
3107 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3108 : "Invalid loop construct in %s %s in XML resource : "
3109 : "invalid 'counter' %s",
3110 : pszDESOrTREName, pszDESOrTREKind, "NXPTS");
3111 0 : *pbError = TRUE;
3112 0 : break;
3113 : }
3114 0 : if (NYPTS < 0)
3115 : {
3116 0 : CPLError(
3117 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3118 : "Invalid loop construct in %s %s in XML resource : "
3119 : "invalid 'counter' %s",
3120 : pszDESOrTREName, pszDESOrTREKind, "NYPTS");
3121 0 : *pbError = TRUE;
3122 0 : break;
3123 : }
3124 0 : nIterations = NXPTS * NYPTS;
3125 : }
3126 10 : else if (pszFormula)
3127 : {
3128 10 : const char *const apszVarAndFormulaNp1NDiv2[] = {
3129 : "NPAR", "(NPART+1)*(NPART)/2",
3130 : "NUMOPG", "(NUMOPG+1)*(NUMOPG)/2",
3131 : "NUM_ADJ_PARM", "(NUM_ADJ_PARM+1)*(NUM_ADJ_PARM)/2",
3132 : "N1_CAL", "(N1_CAL+1)*(N1_CAL)/2",
3133 : "NUM_PARA", "(NUM_PARA+1)*(NUM_PARA)/2",
3134 : nullptr, nullptr};
3135 :
3136 24 : for (int i = 0; apszVarAndFormulaNp1NDiv2[i]; i += 2)
3137 : {
3138 24 : if (strcmp(pszFormula, apszVarAndFormulaNp1NDiv2[i + 1]) ==
3139 : 0)
3140 : {
3141 10 : const char *pszVar = apszVarAndFormulaNp1NDiv2[i];
3142 : char *pszMDItemName =
3143 10 : CPLStrdup(CPLSPrintf("%s%s", pszMDPrefix, pszVar));
3144 10 : int var = atoi(NITFFindValFromEnd(papszMD, *pnMDSize,
3145 : pszMDItemName, "-1"));
3146 10 : CPLFree(pszMDItemName);
3147 10 : if (var < 0)
3148 : {
3149 0 : CPLError(bValidate ? CE_Failure : CE_Warning,
3150 : CPLE_AppDefined,
3151 : "Invalid loop construct in %s %s in XML "
3152 : "resource : "
3153 : "invalid 'counter' %s",
3154 : pszDESOrTREName, pszDESOrTREKind, pszVar);
3155 0 : *pbError = TRUE;
3156 0 : return papszMD;
3157 : }
3158 10 : nIterations = var * (var + 1) / 2;
3159 10 : break;
3160 : }
3161 : }
3162 :
3163 10 : if (nIterations < 0)
3164 : {
3165 0 : CPLError(
3166 : bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3167 : "Invalid loop construct in %s %s in XML resource : "
3168 : "missing or invalid 'counter' or 'iterations' or "
3169 : "'formula'",
3170 : pszDESOrTREName, pszDESOrTREKind);
3171 0 : *pbError = TRUE;
3172 0 : break;
3173 : }
3174 : }
3175 :
3176 276 : if (nIterations > 0)
3177 : {
3178 : int iIter;
3179 : const char *pszPercent;
3180 259 : int bHasValidPercentD = FALSE;
3181 259 : CPLXMLNode *psRepeatedNode = nullptr;
3182 259 : CPLXMLNode *psLastChild = nullptr;
3183 :
3184 : /* Check that md_prefix has one and only %XXXXd pattern */
3185 491 : if (pszMDSubPrefix != nullptr &&
3186 491 : (pszPercent = strchr(pszMDSubPrefix, '%')) != nullptr &&
3187 232 : strchr(pszPercent + 1, '%') == nullptr)
3188 : {
3189 232 : const char *pszIter = pszPercent + 1;
3190 678 : while (*pszIter != '\0')
3191 : {
3192 678 : if (*pszIter >= '0' && *pszIter <= '9')
3193 446 : pszIter++;
3194 232 : else if (*pszIter == 'd')
3195 : {
3196 232 : bHasValidPercentD = atoi(pszPercent + 1) <= 10;
3197 232 : break;
3198 : }
3199 : else
3200 0 : break;
3201 : }
3202 : }
3203 :
3204 259 : if (psOutXMLNode != nullptr)
3205 : {
3206 : CPLXMLNode *psNumberNode;
3207 : CPLXMLNode *psNameNode;
3208 : const char *pszName =
3209 166 : CPLGetXMLValue(psIter, "name", nullptr);
3210 : psRepeatedNode =
3211 166 : CPLCreateXMLNode(psOutXMLNode, CXT_Element, "repeated");
3212 166 : if (pszName)
3213 : {
3214 119 : psNameNode = CPLCreateXMLNode(psRepeatedNode,
3215 : CXT_Attribute, "name");
3216 119 : CPLCreateXMLNode(psNameNode, CXT_Text, pszName);
3217 : }
3218 166 : psNumberNode = CPLCreateXMLNode(psRepeatedNode,
3219 : CXT_Attribute, "number");
3220 166 : CPLCreateXMLNode(psNumberNode, CXT_Text,
3221 : CPLSPrintf("%d", nIterations));
3222 :
3223 166 : psLastChild = psRepeatedNode->psChild;
3224 285 : while (psLastChild->psNext != nullptr)
3225 119 : psLastChild = psLastChild->psNext;
3226 : }
3227 :
3228 2106 : for (iIter = 0; iIter < nIterations && *pbError == FALSE;
3229 : iIter++)
3230 : {
3231 1847 : char *pszMDNewPrefix = nullptr;
3232 1847 : CPLXMLNode *psGroupNode = nullptr;
3233 1847 : if (bRPFIMG)
3234 : {
3235 : // As we need to fetch metadata items that are in
3236 : // different RPF location, a prefix would hurt.
3237 13 : pszMDNewPrefix = CPLStrdup("");
3238 : }
3239 1834 : else if (pszMDSubPrefix != nullptr)
3240 : {
3241 1780 : if (bHasValidPercentD)
3242 : {
3243 1780 : const size_t nTmpLen =
3244 1780 : strlen(pszMDSubPrefix) + 10 + 1;
3245 : char *szTmp =
3246 1780 : static_cast<char *>(CPLMalloc(nTmpLen));
3247 1780 : snprintf(szTmp, nTmpLen, pszMDSubPrefix, iIter + 1);
3248 1780 : pszMDNewPrefix = CPLStrdup(
3249 : CPLSPrintf("%s%s", pszMDPrefix, szTmp));
3250 1780 : CPLFree(szTmp);
3251 : }
3252 : else
3253 0 : pszMDNewPrefix = CPLStrdup(
3254 : CPLSPrintf("%s%s%04d_", pszMDPrefix,
3255 : pszMDSubPrefix, iIter + 1));
3256 : }
3257 : else
3258 54 : pszMDNewPrefix = CPLStrdup(
3259 : CPLSPrintf("%s%04d_", pszMDPrefix, iIter + 1));
3260 :
3261 1847 : if (psRepeatedNode != nullptr)
3262 : {
3263 : CPLXMLNode *psIndexNode;
3264 : psGroupNode =
3265 1722 : CPLCreateXMLNode(nullptr, CXT_Element, "group");
3266 1722 : CPLAssert(psLastChild->psNext == nullptr);
3267 1722 : psLastChild->psNext = psGroupNode;
3268 1722 : psLastChild = psGroupNode;
3269 1722 : psIndexNode = CPLCreateXMLNode(psGroupNode,
3270 : CXT_Attribute, "index");
3271 1722 : CPLCreateXMLNode(psIndexNode, CXT_Text,
3272 : CPLSPrintf("%d", iIter));
3273 : }
3274 :
3275 1847 : papszMD = NITFGenericMetadataReadTREInternal(
3276 : papszMD, pnMDSize, pnMDAlloc, psGroupNode,
3277 : pszDESOrTREKind, pszDESOrTREName, pachTRE, nTRESize,
3278 : psIter, pnTreOffset, pszMDNewPrefix, bValidate, fp,
3279 : oMapLocIdToXML, pbError);
3280 :
3281 1847 : CPLFree(pszMDNewPrefix);
3282 : }
3283 276 : }
3284 : }
3285 6455 : else if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
3286 550 : strcmp(psIter->pszValue, "if") == 0)
3287 : {
3288 534 : const char *pszCond = CPLGetXMLValue(psIter, "cond", nullptr);
3289 534 : if (pszCond == nullptr)
3290 : {
3291 0 : CPLError(bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3292 : "Invalid if construct in %s %s in XML resource : "
3293 : "missing 'cond' attribute",
3294 : pszDESOrTREName, pszDESOrTREKind);
3295 0 : *pbError = TRUE;
3296 0 : break;
3297 : }
3298 :
3299 534 : int nRet = NITFEvaluateCond(pszCond, papszMD, pnMDSize, pszMDPrefix,
3300 : pszDESOrTREKind, pszDESOrTREName);
3301 534 : if (nRet < 0)
3302 : {
3303 0 : *pbError = TRUE;
3304 0 : break;
3305 : }
3306 534 : if (nRet > 0)
3307 : {
3308 140 : papszMD = NITFGenericMetadataReadTREInternal(
3309 : papszMD, pnMDSize, pnMDAlloc, psOutXMLNode, pszDESOrTREKind,
3310 : pszDESOrTREName, pachTRE, nTRESize, psIter, pnTreOffset,
3311 : pszMDPrefix, bValidate, fp, oMapLocIdToXML, pbError);
3312 534 : }
3313 : }
3314 5921 : else if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
3315 16 : strcmp(psIter->pszValue, "if_remaining_bytes") == 0)
3316 : {
3317 4 : if (*pnTreOffset < nTRESize)
3318 : {
3319 0 : papszMD = NITFGenericMetadataReadTREInternal(
3320 : papszMD, pnMDSize, pnMDAlloc, psOutXMLNode, pszDESOrTREKind,
3321 : pszDESOrTREName, pachTRE, nTRESize, psIter, pnTreOffset,
3322 : pszMDPrefix, bValidate, fp, oMapLocIdToXML, pbError);
3323 : }
3324 : }
3325 : else
3326 : {
3327 : // CPLDebug("NITF", "Unknown element : %s", psIter->pszValue ?
3328 : // psIter->pszValue : "null");
3329 : }
3330 : }
3331 :
3332 2095 : if (bRPFIMG && nRPFLocationId >= LID_HeaderComponent &&
3333 10 : nRPFLocationId <= LID_ColorTableIndexRecord &&
3334 10 : nRPFLocationSize < 1000 * 1000 && psOutXMLNode &&
3335 10 : strcmp(psOutXMLNode->pszValue, "group") == 0)
3336 : {
3337 : const auto oIter =
3338 10 : oMapLocIdToXML.find(static_cast<NITFLocId>(nRPFLocationId));
3339 10 : if (oIter != oMapLocIdToXML.end())
3340 : {
3341 7 : const CPLXMLNode *psRPFLocationXML = oIter->second;
3342 7 : VSIFSeekL(fp, nRPFLocationOffset, SEEK_SET);
3343 14 : std::vector<GByte> abyRPFLocationData;
3344 7 : abyRPFLocationData.resize(nRPFLocationSize);
3345 7 : if (VSIFReadL(abyRPFLocationData.data(), 1, nRPFLocationSize, fp) ==
3346 7 : nRPFLocationSize)
3347 : {
3348 6 : CPLXMLNode *psLastChild = psOutXMLNode->psChild;
3349 24 : while (psLastChild->psNext)
3350 18 : psLastChild = psLastChild->psNext;
3351 : CPLXMLNode *psContent =
3352 6 : CPLCreateXMLNode(nullptr, CXT_Element, "content");
3353 6 : psLastChild->psNext = psContent;
3354 6 : CPLAddXMLAttributeAndValue(
3355 : psContent, "ComponentName",
3356 : CPLGetXMLValue(psRPFLocationXML, "id", ""));
3357 6 : int nLocationOffset = 0;
3358 6 : papszMD = NITFGenericMetadataReadTREInternal(
3359 : papszMD, pnMDSize, pnMDAlloc, psContent, pszDESOrTREKind,
3360 : pszDESOrTREName,
3361 6 : reinterpret_cast<const char *>(abyRPFLocationData.data()),
3362 : nRPFLocationSize, psRPFLocationXML, &nLocationOffset,
3363 : pszMDPrefix, bValidate, fp, oMapLocIdToXML, pbError);
3364 : }
3365 : }
3366 : else
3367 : {
3368 3 : CPLDebug("NITF",
3369 : "No definition in nitf_spec.xml for location id %d",
3370 : nRPFLocationId);
3371 : }
3372 : }
3373 :
3374 2095 : return papszMD;
3375 : }
3376 :
3377 : /************************************************************************/
3378 : /* NITFGenericMetadataReadTRE() */
3379 : /************************************************************************/
3380 :
3381 39 : static char **NITFGenericMetadataReadTRE(char **papszMD, const char *pszTREName,
3382 : const char *pachTRE, int nTRESize,
3383 : CPLXMLNode *psTreNode, VSILFILE *fp)
3384 : {
3385 39 : int bError = FALSE;
3386 39 : int nTreOffset = 0;
3387 : const char *pszMDPrefix;
3388 : int nMDSize, nMDAlloc;
3389 :
3390 39 : int nTreLength = atoi(CPLGetXMLValue(psTreNode, "length", "-1"));
3391 39 : int nTreMinLength = atoi(CPLGetXMLValue(psTreNode, "minlength", "-1"));
3392 : /* int nTreMaxLength = atoi(CPLGetXMLValue(psTreNode, "maxlength", "-1"));
3393 : */
3394 :
3395 39 : if (nTreLength > 0 && nTRESize != nTreLength)
3396 : {
3397 0 : CPLError(CE_Warning, CPLE_AppDefined,
3398 : "%s TRE wrong size (%d). Expected %d.", pszTREName, nTRESize,
3399 : nTreLength);
3400 : }
3401 :
3402 39 : if (nTreMinLength > 0 && nTRESize < nTreMinLength)
3403 : {
3404 0 : CPLError(CE_Warning, CPLE_AppDefined,
3405 : "%s TRE wrong size (%d). Expected >= %d.", pszTREName,
3406 : nTRESize, nTreMinLength);
3407 : }
3408 :
3409 39 : pszMDPrefix = CPLGetXMLValue(psTreNode, "md_prefix", "");
3410 :
3411 39 : nMDSize = nMDAlloc = CSLCount(papszMD);
3412 :
3413 39 : std::map<NITFLocId, const CPLXMLNode *> oMapLocIdToXML;
3414 39 : papszMD = NITFGenericMetadataReadTREInternal(
3415 : papszMD, &nMDSize, &nMDAlloc, nullptr, "TRE", pszTREName, pachTRE,
3416 : nTRESize, psTreNode, &nTreOffset, pszMDPrefix,
3417 : false, // bValidate
3418 : fp, oMapLocIdToXML, &bError);
3419 :
3420 39 : if (bError == FALSE && nTreLength > 0 && nTreOffset != nTreLength)
3421 : {
3422 0 : CPLError(CE_Warning, CPLE_AppDefined,
3423 : "Inconsistent declaration of %s TRE", pszTREName);
3424 : }
3425 39 : if (nTreOffset < nTRESize)
3426 0 : CPLDebug("NITF", "%d remaining bytes at end of %s TRE",
3427 : nTRESize - nTreOffset, pszTREName);
3428 :
3429 78 : return papszMD;
3430 : }
3431 :
3432 : /************************************************************************/
3433 : /* NITFLoadXMLSpec() */
3434 : /************************************************************************/
3435 :
3436 : #define NITF_SPEC_FILE "nitf_spec.xml"
3437 :
3438 697 : static CPLXMLNode *NITFLoadXMLSpec(NITFFile *psFile)
3439 : {
3440 :
3441 697 : if (psFile->psNITFSpecNode == nullptr)
3442 : {
3443 : #ifndef USE_ONLY_EMBEDDED_RESOURCE_FILES
3444 : #ifdef EMBED_RESOURCE_FILES
3445 : CPLPushErrorHandler(CPLQuietErrorHandler);
3446 : #endif
3447 615 : const char *pszXMLDescFilename = CPLFindFile("gdal", NITF_SPEC_FILE);
3448 : #ifdef EMBED_RESOURCE_FILES
3449 : CPLPopErrorHandler();
3450 : CPLErrorReset();
3451 : #endif
3452 615 : if (pszXMLDescFilename == nullptr)
3453 : #endif
3454 : {
3455 : #ifdef EMBED_RESOURCE_FILES
3456 : CPLDebug("NITF", "Using embedded %s", NITF_SPEC_FILE);
3457 : psFile->psNITFSpecNode = CPLParseXMLString(NITFGetSpecFile());
3458 : CPLAssert(psFile->psNITFSpecNode);
3459 : return psFile->psNITFSpecNode;
3460 : #else
3461 0 : CPLDebug("NITF", "Cannot find XML file : %s", NITF_SPEC_FILE);
3462 0 : return nullptr;
3463 : #endif
3464 : }
3465 : #ifndef USE_ONLY_EMBEDDED_RESOURCE_FILES
3466 615 : psFile->psNITFSpecNode = CPLParseXMLFile(pszXMLDescFilename);
3467 615 : if (psFile->psNITFSpecNode == nullptr)
3468 : {
3469 0 : CPLDebug("NITF", "Invalid XML file : %s", pszXMLDescFilename);
3470 0 : return nullptr;
3471 : }
3472 : #endif
3473 : }
3474 :
3475 697 : return psFile->psNITFSpecNode;
3476 : }
3477 :
3478 : /************************************************************************/
3479 : /* NITFFindTREXMLDescFromName() */
3480 : /************************************************************************/
3481 :
3482 63 : static CPLXMLNode *NITFFindTREXMLDescFromName(NITFFile *psFile,
3483 : const char *pszTREName)
3484 : {
3485 : CPLXMLNode *psTreeNode;
3486 : CPLXMLNode *psTresNode;
3487 : CPLXMLNode *psIter;
3488 :
3489 63 : psTreeNode = NITFLoadXMLSpec(psFile);
3490 63 : if (psTreeNode == nullptr)
3491 0 : return nullptr;
3492 :
3493 63 : psTresNode = CPLGetXMLNode(psTreeNode, "=root.tres");
3494 63 : if (psTresNode == nullptr)
3495 : {
3496 0 : CPLDebug("NITF", "Cannot find <root><tres> root element");
3497 0 : return nullptr;
3498 : }
3499 :
3500 3259 : for (psIter = psTresNode->psChild; psIter != nullptr;
3501 3196 : psIter = psIter->psNext)
3502 : {
3503 3254 : if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
3504 2295 : strcmp(psIter->pszValue, "tre") == 0)
3505 : {
3506 2295 : const char *pszName = CPLGetXMLValue(psIter, "name", nullptr);
3507 2295 : if (pszName != nullptr && strcmp(pszName, pszTREName) == 0)
3508 : {
3509 58 : return psIter;
3510 : }
3511 : }
3512 : }
3513 :
3514 5 : return nullptr;
3515 : }
3516 :
3517 : /************************************************************************/
3518 : /* NITFCreateXMLTre() */
3519 : /************************************************************************/
3520 :
3521 63 : CPLXMLNode *NITFCreateXMLTre(NITFFile *psFile, const char *pszTREName,
3522 : const char *pachTRE, int nTRESize, bool bValidate,
3523 : bool *pbGotError)
3524 : {
3525 63 : int nTreLength, nTreMinLength = -1 /* , nTreMaxLength = -1 */;
3526 63 : int bError = FALSE;
3527 63 : int nTreOffset = 0;
3528 : CPLXMLNode *psTreNode;
3529 63 : CPLXMLNode *psOutXMLNode = nullptr;
3530 63 : int nMDSize = 0, nMDAlloc = 0;
3531 : const char *pszMDPrefix;
3532 :
3533 63 : psTreNode = NITFFindTREXMLDescFromName(psFile, pszTREName);
3534 63 : if (psTreNode == nullptr)
3535 : {
3536 5 : if (!(STARTS_WITH_CI(pszTREName, "RPF") ||
3537 5 : strcmp(pszTREName, "XXXXXX") == 0))
3538 : {
3539 5 : CPLDebug("NITF", "Cannot find definition of TRE %s in %s",
3540 : pszTREName, NITF_SPEC_FILE);
3541 : }
3542 5 : return nullptr;
3543 : }
3544 :
3545 58 : nTreLength = atoi(CPLGetXMLValue(psTreNode, "length", "-1"));
3546 58 : nTreMinLength = atoi(CPLGetXMLValue(psTreNode, "minlength", "-1"));
3547 : /* nTreMaxLength = atoi(CPLGetXMLValue(psTreNode, "maxlength", "-1")); */
3548 :
3549 58 : psOutXMLNode = CPLCreateXMLNode(nullptr, CXT_Element, "tre");
3550 58 : CPLCreateXMLNode(CPLCreateXMLNode(psOutXMLNode, CXT_Attribute, "name"),
3551 : CXT_Text, pszTREName);
3552 :
3553 58 : if (nTreLength > 0 && nTRESize != nTreLength)
3554 : {
3555 2 : CPLError(bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3556 : "%s TRE wrong size (%d). Expected %d.", pszTREName, nTRESize,
3557 : nTreLength);
3558 2 : CPLCreateXMLElementAndValue(
3559 : psOutXMLNode, bValidate ? "error" : "warning",
3560 : CPLSPrintf("%s TRE wrong size (%d). Expected %d.", pszTREName,
3561 : nTRESize, nTreLength));
3562 2 : if (pbGotError)
3563 2 : *pbGotError = true;
3564 : }
3565 :
3566 58 : if (nTreMinLength > 0 && nTRESize < nTreMinLength)
3567 : {
3568 0 : CPLError(bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3569 : "%s TRE wrong size (%d). Expected >= %d.", pszTREName,
3570 : nTRESize, nTreMinLength);
3571 0 : CPLCreateXMLElementAndValue(
3572 : psOutXMLNode, bValidate ? "error" : "warning",
3573 : CPLSPrintf("%s TRE wrong size (%d). Expected >= %d.", pszTREName,
3574 : nTRESize, nTreMinLength));
3575 0 : if (pbGotError)
3576 0 : *pbGotError = true;
3577 : }
3578 :
3579 58 : pszMDPrefix = CPLGetXMLValue(psTreNode, "md_prefix", "");
3580 58 : std::map<NITFLocId, const CPLXMLNode *> oMapLocIdToXML;
3581 58 : CSLDestroy(NITFGenericMetadataReadTREInternal(
3582 : nullptr, &nMDSize, &nMDAlloc, psOutXMLNode, "TRE", pszTREName, pachTRE,
3583 : nTRESize, psTreNode, &nTreOffset, pszMDPrefix, bValidate, psFile->fp,
3584 : oMapLocIdToXML, &bError));
3585 :
3586 58 : if (bError == FALSE && nTreLength > 0 && nTreOffset != nTreLength)
3587 : {
3588 0 : CPLError(CE_Warning, CPLE_AppDefined,
3589 : "Inconsistent declaration of %s TRE", pszTREName);
3590 : }
3591 58 : if (nTreOffset < nTRESize && !EQUAL(pszTREName, "RPFIMG"))
3592 : {
3593 0 : CPLCreateXMLElementAndValue(
3594 : psOutXMLNode, bValidate ? "error" : "warning",
3595 : CPLSPrintf("%d remaining bytes at end of %s TRE",
3596 : nTRESize - nTreOffset, pszTREName));
3597 : }
3598 58 : if (pbGotError && bError)
3599 0 : *pbGotError = true;
3600 :
3601 58 : return psOutXMLNode;
3602 : }
3603 :
3604 : /************************************************************************/
3605 : /* NITFFindTREXMLDescFromName() */
3606 : /************************************************************************/
3607 :
3608 19 : static CPLXMLNode *NITFFindDESXMLDescFromName(NITFFile *psFile,
3609 : const char *pszDESName)
3610 : {
3611 : CPLXMLNode *psTreeNode;
3612 : CPLXMLNode *psTresNode;
3613 : CPLXMLNode *psIter;
3614 :
3615 19 : psTreeNode = NITFLoadXMLSpec(psFile);
3616 19 : if (psTreeNode == nullptr)
3617 0 : return nullptr;
3618 :
3619 19 : psTresNode = CPLGetXMLNode(psTreeNode, "=root.des_list");
3620 19 : if (psTresNode == nullptr)
3621 : {
3622 0 : CPLDebug("NITF", "Cannot find <root><des_list> root element");
3623 0 : return nullptr;
3624 : }
3625 :
3626 263 : for (psIter = psTresNode->psChild; psIter != nullptr;
3627 244 : psIter = psIter->psNext)
3628 : {
3629 254 : if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
3630 112 : strcmp(psIter->pszValue, "des") == 0)
3631 : {
3632 112 : const char *pszName = CPLGetXMLValue(psIter, "name", nullptr);
3633 112 : if (pszName != nullptr && strcmp(pszName, pszDESName) == 0)
3634 : {
3635 10 : return psIter;
3636 : }
3637 : }
3638 : }
3639 :
3640 9 : return nullptr;
3641 : }
3642 :
3643 : /************************************************************************/
3644 : /* NITFCreateXMLDesUserDefinedSubHeader() */
3645 : /************************************************************************/
3646 :
3647 8 : CPLXMLNode *NITFCreateXMLDesUserDefinedSubHeader(NITFFile *psFile,
3648 : const NITFDES *psDES,
3649 : bool bValidate,
3650 : bool *pbGotError)
3651 : {
3652 8 : const char *pszDESID = CSLFetchNameValue(psDES->papszMetadata, "DESID");
3653 8 : CPLXMLNode *psDESDef = NITFFindDESXMLDescFromName(psFile, pszDESID);
3654 8 : if (psDESDef == nullptr)
3655 : {
3656 4 : CPLDebug("NITF", "Cannot find definition of DES %s in %s", pszDESID,
3657 : NITF_SPEC_FILE);
3658 4 : return nullptr;
3659 : }
3660 : CPLXMLNode *psUserDefinedFields =
3661 4 : CPLGetXMLNode(psDESDef, "subheader_fields");
3662 4 : if (psUserDefinedFields == nullptr)
3663 : {
3664 0 : return nullptr;
3665 : }
3666 :
3667 : CPLXMLNode *psOutXMLNode =
3668 4 : CPLCreateXMLNode(nullptr, CXT_Element, "user_defined_fields");
3669 :
3670 4 : int bError = FALSE;
3671 4 : int nOffset = 200;
3672 4 : char **papszMD = CSLDuplicate(psDES->papszMetadata);
3673 4 : int nMDSize = CSLCount(papszMD);
3674 4 : int nMDAlloc = nMDSize;
3675 4 : const int nDESSize =
3676 4 : psFile->pasSegmentInfo[psDES->iSegment].nSegmentHeaderSize;
3677 4 : std::map<NITFLocId, const CPLXMLNode *> oMapLocIdToXML;
3678 4 : CSLDestroy(NITFGenericMetadataReadTREInternal(
3679 : papszMD, &nMDSize, &nMDAlloc, psOutXMLNode, "DES", pszDESID,
3680 4 : psDES->pachHeader, nDESSize, psUserDefinedFields, &nOffset,
3681 : "", /* pszMDPrefix, */
3682 : bValidate, psFile->fp, oMapLocIdToXML, &bError));
3683 : int nDESSHL =
3684 4 : atoi(CSLFetchNameValueDef(psDES->papszMetadata, "DESSHL", "0"));
3685 :
3686 : const int nLength =
3687 4 : atoi(CPLGetXMLValue(psUserDefinedFields, "length", "-1"));
3688 : const int nMinLength =
3689 4 : atoi(CPLGetXMLValue(psUserDefinedFields, "minlength", "-1"));
3690 :
3691 4 : if (nLength > 0 && nDESSHL != nLength)
3692 : {
3693 2 : CPLError(bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3694 : "%s DES wrong header size (%d). Expected %d.", pszDESID,
3695 : nDESSHL, nLength);
3696 2 : CPLCreateXMLElementAndValue(
3697 : psOutXMLNode, bValidate ? "error" : "warning",
3698 : CPLSPrintf("%s DES wrong size (%d). Expected %d.", pszDESID,
3699 : nDESSHL, nLength));
3700 2 : if (pbGotError)
3701 2 : *pbGotError = true;
3702 : }
3703 :
3704 4 : if (nMinLength > 0 && nDESSHL < nMinLength)
3705 : {
3706 0 : CPLError(bValidate ? CE_Failure : CE_Warning, CPLE_AppDefined,
3707 : "%s DES wrong size (%d). Expected >= %d.", pszDESID, nDESSHL,
3708 : nMinLength);
3709 0 : CPLCreateXMLElementAndValue(
3710 : psOutXMLNode, bValidate ? "error" : "warning",
3711 : CPLSPrintf("%s DES wrong size (%d). Expected >= %d.", pszDESID,
3712 : nDESSHL, nMinLength));
3713 0 : if (pbGotError)
3714 0 : *pbGotError = true;
3715 : }
3716 :
3717 4 : if (nOffset < nDESSHL)
3718 : {
3719 0 : bError = TRUE;
3720 0 : CPLCreateXMLElementAndValue(
3721 : psOutXMLNode, bValidate ? "error" : "warning",
3722 : CPLSPrintf(
3723 : "%d remaining bytes at end of user defined subheader section",
3724 : nDESSHL - nOffset));
3725 : }
3726 4 : if (pbGotError && bError)
3727 2 : *pbGotError = true;
3728 :
3729 4 : return psOutXMLNode;
3730 : }
3731 :
3732 : /************************************************************************/
3733 : /* NITFCreateXMLDesDataFields() */
3734 : /************************************************************************/
3735 :
3736 11 : CPLXMLNode *NITFCreateXMLDesDataFields(NITFFile *psFile, const NITFDES *psDES,
3737 : const GByte *pabyData, int nDataLen,
3738 : bool bValidate, bool *pbGotError)
3739 : {
3740 11 : const char *pszDESID = CSLFetchNameValue(psDES->papszMetadata, "DESID");
3741 11 : CPLXMLNode *psDESDef = NITFFindDESXMLDescFromName(psFile, pszDESID);
3742 11 : if (psDESDef == nullptr)
3743 : {
3744 5 : CPLDebug("NITF", "Cannot find definition of DES %s in %s", pszDESID,
3745 : NITF_SPEC_FILE);
3746 5 : return nullptr;
3747 : }
3748 6 : CPLXMLNode *psFields = CPLGetXMLNode(psDESDef, "data_fields");
3749 6 : if (psFields == nullptr)
3750 : {
3751 5 : return nullptr;
3752 : }
3753 :
3754 : CPLXMLNode *psOutXMLNode =
3755 1 : CPLCreateXMLNode(nullptr, CXT_Element, "data_fields");
3756 :
3757 1 : int bError = FALSE;
3758 1 : int nOffset = 0;
3759 1 : char **papszMD = CSLDuplicate(psDES->papszMetadata);
3760 1 : int nMDSize = CSLCount(papszMD);
3761 1 : int nMDAlloc = nMDSize;
3762 1 : std::map<NITFLocId, const CPLXMLNode *> oMapLocIdToXML;
3763 1 : CSLDestroy(NITFGenericMetadataReadTREInternal(
3764 : papszMD, &nMDSize, &nMDAlloc, psOutXMLNode, "DES", pszDESID,
3765 : reinterpret_cast<const char *>(pabyData), nDataLen, psFields, &nOffset,
3766 : "", /* pszMDPrefix, */
3767 : bValidate, psFile->fp, oMapLocIdToXML, &bError));
3768 1 : if (nOffset < nDataLen)
3769 : {
3770 0 : bError = TRUE;
3771 0 : CPLCreateXMLElementAndValue(
3772 : psOutXMLNode, bValidate ? "error" : "warning",
3773 : CPLSPrintf("%d remaining bytes at end of data section",
3774 : nDataLen - nOffset));
3775 : }
3776 1 : if (pbGotError && bError)
3777 0 : *pbGotError = true;
3778 :
3779 1 : return psOutXMLNode;
3780 : }
3781 :
3782 : /************************************************************************/
3783 : /* NITFGenericMetadataRead() */
3784 : /* */
3785 : /* Add metadata from TREs of file and image objects in the papszMD list */
3786 : /* pszSpecificTRE can be nullptr, in which case all TREs listed in */
3787 : /* data/nitf_resources.xml that have md_prefix defined will be looked */
3788 : /* for. If not nullptr, only the specified one will be looked for. */
3789 : /************************************************************************/
3790 :
3791 615 : char **NITFGenericMetadataRead(char **papszMD, NITFFile *psFile,
3792 : NITFImage *psImage,
3793 : const char *pszSpecificTREName)
3794 : {
3795 615 : CPLXMLNode *psTreeNode = nullptr;
3796 615 : CPLXMLNode *psTresNode = nullptr;
3797 615 : CPLXMLNode *psIter = nullptr;
3798 :
3799 615 : if (psFile == nullptr)
3800 : {
3801 0 : if (psImage == nullptr)
3802 0 : return papszMD;
3803 0 : psTreeNode = NITFLoadXMLSpec(psImage->psFile);
3804 : }
3805 : else
3806 615 : psTreeNode = NITFLoadXMLSpec(psFile);
3807 :
3808 615 : if (psTreeNode == nullptr)
3809 0 : return papszMD;
3810 :
3811 615 : psTresNode = CPLGetXMLNode(psTreeNode, "=root.tres");
3812 615 : if (psTresNode == nullptr)
3813 : {
3814 0 : CPLDebug("NITF", "Cannot find <root><tres> root element");
3815 0 : return papszMD;
3816 : }
3817 :
3818 58425 : for (psIter = psTresNode->psChild; psIter != nullptr;
3819 57810 : psIter = psIter->psNext)
3820 : {
3821 57810 : if (psIter->eType == CXT_Element && psIter->pszValue != nullptr &&
3822 41205 : strcmp(psIter->pszValue, "tre") == 0)
3823 : {
3824 41205 : const char *pszName = CPLGetXMLValue(psIter, "name", nullptr);
3825 : const char *pszMDPrefix =
3826 41205 : CPLGetXMLValue(psIter, "md_prefix", nullptr);
3827 41205 : int bHasRightPrefix = FALSE;
3828 41205 : if (pszName == nullptr)
3829 0 : continue;
3830 41205 : if (pszSpecificTREName == nullptr)
3831 41205 : bHasRightPrefix = (pszMDPrefix != nullptr);
3832 : else
3833 0 : bHasRightPrefix = (strcmp(pszName, pszSpecificTREName) == 0);
3834 41205 : if (bHasRightPrefix)
3835 : {
3836 13530 : if (psFile != nullptr)
3837 : {
3838 13530 : const char *pachTRE = nullptr;
3839 13530 : int nTRESize = 0;
3840 :
3841 13530 : pachTRE = NITFFindTRE(psFile->pachTRE, psFile->nTREBytes,
3842 : pszName, &nTRESize);
3843 13530 : if (pachTRE != nullptr)
3844 2 : papszMD = NITFGenericMetadataReadTRE(
3845 : papszMD, pszName, pachTRE, nTRESize, psIter,
3846 : psFile->fp);
3847 : }
3848 13530 : if (psImage != nullptr)
3849 : {
3850 13530 : const char *pachTRE = nullptr;
3851 13530 : int nTRESize = 0;
3852 :
3853 13530 : pachTRE = NITFFindTRE(psImage->pachTRE, psImage->nTREBytes,
3854 : pszName, &nTRESize);
3855 13530 : if (pachTRE != nullptr)
3856 37 : papszMD = NITFGenericMetadataReadTRE(
3857 : papszMD, pszName, pachTRE, nTRESize, psIter,
3858 37 : psImage->psFile->fp);
3859 : }
3860 13530 : if (pszSpecificTREName)
3861 0 : break;
3862 : }
3863 : }
3864 : }
3865 :
3866 615 : return papszMD;
3867 : }
3868 :
3869 : #undef PLACE
|
