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