Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: JPEG JFIF Driver
4 : * Purpose: Implement GDAL JPEG Support based on IJG libjpeg.
5 : * Author: Frank Warmerdam, warmerdam@pobox.com
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 2000, Frank Warmerdam
9 : * Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
10 : *
11 : * Portions Copyright (c) Her majesty the Queen in right of Canada as
12 : * represented by the Minister of National Defence, 2006.
13 : *
14 : * SPDX-License-Identifier: MIT
15 : ****************************************************************************/
16 :
17 : #include "cpl_port.h"
18 : #include "jpgdataset.h"
19 :
20 : #include <cerrno>
21 : #include <climits>
22 : #include <cstddef>
23 : #include <cstdio>
24 : #include <cstdint>
25 : #include <cstdlib>
26 : #include <cstring>
27 : #if HAVE_FCNTL_H
28 : #include <fcntl.h>
29 : #endif
30 : #include <limits>
31 : #include <setjmp.h>
32 :
33 : #include <algorithm>
34 : #include <string>
35 :
36 : #include "gdalorienteddataset.h"
37 :
38 : #include "cpl_conv.h"
39 : #include "cpl_error.h"
40 : #include "cpl_md5.h"
41 : #include "cpl_minixml.h"
42 : #include "quant_table_md5sum.h"
43 : #include "quant_table_md5sum_jpeg9e.h"
44 : #include "cpl_progress.h"
45 : #include "cpl_string.h"
46 : #include "cpl_time.h"
47 : #include "cpl_vsi.h"
48 : #include "gdal.h"
49 : #include "gdal_frmts.h"
50 : #include "gdal_pam.h"
51 : #include "gdal_priv.h"
52 : #include "gdalexif.h"
53 : CPL_C_START
54 : #ifdef LIBJPEG_12_PATH
55 : #include LIBJPEG_12_PATH
56 : #else
57 : #include "jpeglib.h"
58 : #endif
59 : CPL_C_END
60 : #include "memdataset.h"
61 : #include "rawdataset.h"
62 : #include "vsidataio.h"
63 : #include "vrt/vrtdataset.h"
64 : #include "jpegdrivercore.h"
65 :
66 : #if defined(EXPECTED_JPEG_LIB_VERSION) && !defined(LIBJPEG_12_PATH)
67 : #if EXPECTED_JPEG_LIB_VERSION != JPEG_LIB_VERSION
68 : #error EXPECTED_JPEG_LIB_VERSION != JPEG_LIB_VERSION
69 : #endif
70 : #endif
71 :
72 : constexpr int TIFF_VERSION = 42;
73 :
74 : constexpr int TIFF_BIGENDIAN = 0x4d4d;
75 : constexpr int TIFF_LITTLEENDIAN = 0x4949;
76 :
77 : constexpr int JPEG_TIFF_IMAGEWIDTH = 0x100;
78 : constexpr int JPEG_TIFF_IMAGEHEIGHT = 0x101;
79 : constexpr int JPEG_TIFF_COMPRESSION = 0x103;
80 : constexpr int JPEG_EXIF_JPEGIFOFSET = 0x201;
81 : constexpr int JPEG_EXIF_JPEGIFBYTECOUNT = 0x202;
82 :
83 : // Ok to use setjmp().
84 : #ifdef _MSC_VER
85 : #pragma warning(disable : 4611)
86 : #endif
87 :
88 : // Do we want to do special processing suitable for when JSAMPLE is a
89 : // 16bit value?
90 :
91 : /* HAVE_JPEGTURBO_DUAL_MODE_8_12 is defined for libjpeg-turbo >= 2.2 which
92 : * adds a dual-mode 8/12 bit API in the same library.
93 : */
94 :
95 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
96 : /* Start by undefining BITS_IN_JSAMPLE which is always set to 8 in libjpeg-turbo
97 : * >= 2.2 Cf
98 : * https://github.com/libjpeg-turbo/libjpeg-turbo/commit/8b9bc4b9635a2a047fb23ebe70c9acd728d3f99b
99 : */
100 : #undef BITS_IN_JSAMPLE
101 : /* libjpeg-turbo >= 2.2 adds J12xxxx datatypes for the 12-bit mode. */
102 : #if defined(JPGDataset)
103 : #define BITS_IN_JSAMPLE 12
104 : #define GDAL_JSAMPLE J12SAMPLE
105 : #else
106 : #define BITS_IN_JSAMPLE 8
107 : #define GDAL_JSAMPLE JSAMPLE
108 : #endif
109 : #else
110 : #define GDAL_JSAMPLE JSAMPLE
111 : #endif
112 :
113 : #if defined(JPEG_LIB_MK1)
114 : #define JPEG_LIB_MK1_OR_12BIT 1
115 : #elif BITS_IN_JSAMPLE == 12
116 : #define JPEG_LIB_MK1_OR_12BIT 1
117 : #endif
118 :
119 : /************************************************************************/
120 : /* SetMaxMemoryToUse() */
121 : /************************************************************************/
122 :
123 11870 : static void SetMaxMemoryToUse(struct jpeg_decompress_struct *psDInfo)
124 : {
125 : // This is to address bug related in ticket #1795.
126 11870 : if (CPLGetConfigOption("JPEGMEM", nullptr) == nullptr)
127 : {
128 : // If the user doesn't provide a value for JPEGMEM, we want to be sure
129 : // that at least 500 MB will be used before creating the temporary file.
130 11869 : const long nMinMemory = 500 * 1024 * 1024;
131 11869 : psDInfo->mem->max_memory_to_use =
132 11869 : std::max(psDInfo->mem->max_memory_to_use, nMinMemory);
133 : }
134 11870 : }
135 :
136 : #if !defined(JPGDataset)
137 :
138 : /************************************************************************/
139 : /* ReadImageStructureMetadata() */
140 : /************************************************************************/
141 :
142 5 : void JPGDatasetCommon::ReadImageStructureMetadata()
143 : {
144 5 : if (bHasReadImageStructureMetadata)
145 0 : return;
146 :
147 5 : bHasReadImageStructureMetadata = true;
148 5 : if (GetDataPrecision() != 8)
149 0 : return; // quality guessing not implemented for 12-bit JPEG for now
150 :
151 : // Save current position to avoid disturbing JPEG stream decoding.
152 5 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
153 :
154 : GByte abyChunkHeader[4];
155 5 : int nChunkLoc = 2;
156 5 : constexpr GByte MARKER_QUANT_TABLE = 0xDB;
157 : struct CPLMD5Context context;
158 5 : CPLMD5Init(&context);
159 :
160 : while (true)
161 : {
162 20 : if (VSIFSeekL(m_fpImage, nChunkLoc, SEEK_SET) != 0)
163 0 : break;
164 :
165 20 : if (VSIFReadL(abyChunkHeader, sizeof(abyChunkHeader), 1, m_fpImage) !=
166 : 1)
167 0 : break;
168 :
169 20 : const int nChunkLength = abyChunkHeader[2] * 256 + abyChunkHeader[3];
170 20 : if (abyChunkHeader[0] == 0xFF &&
171 20 : abyChunkHeader[1] == MARKER_QUANT_TABLE && nChunkLength > 2)
172 : {
173 14 : std::vector<GByte> abyTable(nChunkLength);
174 7 : abyTable[0] = abyChunkHeader[2];
175 7 : abyTable[1] = abyChunkHeader[3];
176 7 : if (VSIFReadL(&abyTable[2], nChunkLength - 2, 1, m_fpImage) == 1)
177 : {
178 7 : CPLMD5Update(&context, &abyTable[0], nChunkLength);
179 7 : }
180 : }
181 : else
182 : {
183 13 : if (abyChunkHeader[0] != 0xFF || (abyChunkHeader[1] & 0xf0) != 0xe0)
184 : break; // Not an APP chunk.
185 : }
186 :
187 15 : nChunkLoc += 2 + nChunkLength;
188 15 : }
189 :
190 5 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
191 :
192 : GByte digest[16];
193 5 : CPLMD5Final(digest, &context);
194 :
195 5 : const bool bIsYCbCr = nBands == 3 && GetJPEGColorSpace() == JCS_YCbCr;
196 410 : for (int i = 0; i < 100; i++)
197 : {
198 410 : if ((bIsYCbCr &&
199 160 : (memcmp(md5JPEGQuantTable_3_YCBCR_8bit[i], digest, 16) == 0 ||
200 158 : memcmp(md5JPEGQuantTable_3_YCBCR_8bit_jpeg9e[i], digest, 16) ==
201 408 : 0)) ||
202 408 : (!bIsYCbCr &&
203 250 : memcmp(md5JPEGQuantTable_generic_8bit[i], digest, 16) == 0))
204 : {
205 5 : GDALDataset::SetMetadataItem(
206 : "JPEG_QUALITY", CPLSPrintf("%d", i + 1), "IMAGE_STRUCTURE");
207 5 : break;
208 : }
209 : }
210 : }
211 :
212 : /************************************************************************/
213 : /* ReadEXIFMetadata() */
214 : /************************************************************************/
215 107 : void JPGDatasetCommon::ReadEXIFMetadata()
216 : {
217 107 : if (bHasReadEXIFMetadata)
218 0 : return;
219 :
220 107 : CPLAssert(papszMetadata == nullptr);
221 :
222 : // Save current position to avoid disturbing JPEG stream decoding.
223 107 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
224 :
225 107 : if (EXIFInit(m_fpImage))
226 : {
227 44 : EXIFExtractMetadata(papszMetadata, m_fpImage, nTiffDirStart, bSwabflag,
228 44 : nTIFFHEADER, nExifOffset, nInterOffset, nGPSOffset);
229 :
230 44 : if (nExifOffset > 0)
231 : {
232 33 : EXIFExtractMetadata(papszMetadata, m_fpImage, nExifOffset,
233 33 : bSwabflag, nTIFFHEADER, nExifOffset,
234 33 : nInterOffset, nGPSOffset);
235 : }
236 44 : if (nInterOffset > 0)
237 : {
238 0 : EXIFExtractMetadata(papszMetadata, m_fpImage, nInterOffset,
239 0 : bSwabflag, nTIFFHEADER, nExifOffset,
240 0 : nInterOffset, nGPSOffset);
241 : }
242 44 : if (nGPSOffset > 0)
243 : {
244 18 : EXIFExtractMetadata(papszMetadata, m_fpImage, nGPSOffset, bSwabflag,
245 18 : nTIFFHEADER, nExifOffset, nInterOffset,
246 18 : nGPSOffset);
247 : }
248 :
249 : // Pix4D Mapper files have both DNG_CameraSerialNumber and EXIF_BodySerialNumber
250 : // set at the same value. Only expose the later in that situation.
251 44 : if (const char *pszDNG_CameraSerialNumber =
252 44 : CSLFetchNameValue(papszMetadata, "DNG_CameraSerialNumber"))
253 : {
254 : const char *pszEXIF_BodySerialNumber =
255 2 : CSLFetchNameValue(papszMetadata, "EXIF_BodySerialNumber");
256 2 : if (pszEXIF_BodySerialNumber &&
257 1 : EQUAL(pszDNG_CameraSerialNumber, pszEXIF_BodySerialNumber))
258 : {
259 1 : CPLDebug("JPEG", "Unsetting DNG_CameraSerialNumber as it has "
260 : "the same value as EXIF_BodySerialNumber");
261 1 : papszMetadata = CSLSetNameValue(
262 : papszMetadata, "DNG_CameraSerialNumber", nullptr);
263 : }
264 : }
265 :
266 : // Pix4D Mapper files have both DNG_UniqueCameraModel and EXIF_Model
267 : // set at the same value. Only expose the later in that situation.
268 44 : if (const char *pszDNG_UniqueCameraModel =
269 44 : CSLFetchNameValue(papszMetadata, "DNG_UniqueCameraModel"))
270 : {
271 : const char *pszEXIF_Model =
272 2 : CSLFetchNameValue(papszMetadata, "EXIF_Model");
273 2 : if (pszEXIF_Model && EQUAL(pszDNG_UniqueCameraModel, pszEXIF_Model))
274 : {
275 1 : CPLDebug("JPEG", "Unsetting DNG_UniqueCameraModel as it has "
276 : "the same value as EXIF_Model");
277 1 : papszMetadata = CSLSetNameValue(
278 : papszMetadata, "DNG_UniqueCameraModel", nullptr);
279 : }
280 : }
281 :
282 : // Avoid setting the PAM dirty bit just for that.
283 44 : const int nOldPamFlags = nPamFlags;
284 :
285 : // Append metadata from PAM after EXIF metadata.
286 44 : papszMetadata = CSLMerge(papszMetadata, GDALPamDataset::GetMetadata());
287 :
288 : // Expose XMP in EXIF in xml:XMP metadata domain
289 44 : if (GDALDataset::GetMetadata("xml:XMP") == nullptr)
290 : {
291 : const char *pszXMP =
292 44 : CSLFetchNameValue(papszMetadata, "EXIF_XmlPacket");
293 44 : if (pszXMP)
294 : {
295 0 : CPLDebug("JPEG", "Read XMP metadata from EXIF tag");
296 0 : const char *const apszMDList[2] = {pszXMP, nullptr};
297 0 : SetMetadata(const_cast<char **>(apszMDList), "xml:XMP");
298 :
299 0 : papszMetadata =
300 0 : CSLSetNameValue(papszMetadata, "EXIF_XmlPacket", nullptr);
301 : }
302 : }
303 :
304 44 : SetMetadata(papszMetadata);
305 :
306 44 : nPamFlags = nOldPamFlags;
307 : }
308 :
309 107 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
310 :
311 107 : bHasReadEXIFMetadata = true;
312 : }
313 :
314 : /************************************************************************/
315 : /* ReadXMPMetadata() */
316 : /************************************************************************/
317 :
318 : // See ยง2.1.3 of
319 : // http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/xmp/pdfs/XMPSpecificationPart3.pdf
320 :
321 69 : void JPGDatasetCommon::ReadXMPMetadata()
322 : {
323 69 : if (bHasReadXMPMetadata)
324 0 : return;
325 :
326 : // Save current position to avoid disturbing JPEG stream decoding.
327 69 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
328 :
329 : // Search for APP1 chunk.
330 69 : constexpr int APP1_BYTE = 0xe1;
331 69 : constexpr int JFIF_MARKER_SIZE = 2 + 2; // ID + size
332 69 : constexpr const char APP1_XMP_SIGNATURE[] = "http://ns.adobe.com/xap/1.0/";
333 69 : constexpr int APP1_XMP_SIGNATURE_LEN =
334 : static_cast<int>(sizeof(APP1_XMP_SIGNATURE));
335 69 : GByte abyChunkHeader[JFIF_MARKER_SIZE + APP1_XMP_SIGNATURE_LEN] = {};
336 69 : int nChunkLoc = 2;
337 69 : bool bFoundXMP = false;
338 :
339 : while (true)
340 : {
341 451 : if (VSIFSeekL(m_fpImage, nChunkLoc, SEEK_SET) != 0)
342 0 : break;
343 :
344 451 : if (VSIFReadL(abyChunkHeader, sizeof(abyChunkHeader), 1, m_fpImage) !=
345 : 1)
346 7 : break;
347 :
348 444 : nChunkLoc += 2 + abyChunkHeader[2] * 256 + abyChunkHeader[3];
349 :
350 : // Not a marker
351 444 : if (abyChunkHeader[0] != 0xFF)
352 0 : break;
353 :
354 : // Stop on Start of Scan
355 444 : if (abyChunkHeader[1] == 0xDA)
356 48 : break;
357 :
358 396 : if (abyChunkHeader[1] == APP1_BYTE &&
359 32 : memcmp(reinterpret_cast<char *>(abyChunkHeader) + JFIF_MARKER_SIZE,
360 : APP1_XMP_SIGNATURE, APP1_XMP_SIGNATURE_LEN) == 0)
361 : {
362 14 : bFoundXMP = true;
363 14 : break; // APP1 - XMP.
364 : }
365 : }
366 :
367 69 : if (bFoundXMP)
368 : {
369 14 : const int nXMPLength = abyChunkHeader[2] * 256 + abyChunkHeader[3] - 2 -
370 : APP1_XMP_SIGNATURE_LEN;
371 14 : if (nXMPLength > 0)
372 : {
373 14 : char *pszXMP = static_cast<char *>(VSIMalloc(nXMPLength + 1));
374 14 : if (pszXMP)
375 : {
376 14 : if (VSIFReadL(pszXMP, nXMPLength, 1, m_fpImage) == 1)
377 : {
378 14 : pszXMP[nXMPLength] = '\0';
379 :
380 : // Avoid setting the PAM dirty bit just for that.
381 14 : const int nOldPamFlags = nPamFlags;
382 :
383 14 : char *apszMDList[2] = {pszXMP, nullptr};
384 14 : SetMetadata(apszMDList, "xml:XMP");
385 :
386 : // cppcheck-suppress redundantAssignment
387 14 : nPamFlags = nOldPamFlags;
388 : }
389 14 : VSIFree(pszXMP);
390 : }
391 : }
392 : }
393 :
394 69 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
395 :
396 69 : bHasReadXMPMetadata = true;
397 : }
398 :
399 : /************************************************************************/
400 : /* ReadFLIRMetadata() */
401 : /************************************************************************/
402 :
403 : // See https://exiftool.org/TagNames/FLIR.html
404 :
405 10 : void JPGDatasetCommon::ReadFLIRMetadata()
406 : {
407 10 : if (bHasReadFLIRMetadata)
408 6 : return;
409 9 : bHasReadFLIRMetadata = true;
410 :
411 : // Save current position to avoid disturbing JPEG stream decoding.
412 9 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
413 :
414 9 : int nChunkLoc = 2;
415 : // size of APP1 segment marker + size of "FLIR\0"
416 : GByte abyChunkHeader[4 + 5];
417 9 : std::vector<GByte> abyFLIR;
418 :
419 : while (true)
420 : {
421 71 : if (VSIFSeekL(m_fpImage, nChunkLoc, SEEK_SET) != 0)
422 0 : break;
423 :
424 71 : if (VSIFReadL(abyChunkHeader, sizeof(abyChunkHeader), 1, m_fpImage) !=
425 : 1)
426 0 : break;
427 :
428 71 : const int nMarkerLength =
429 71 : abyChunkHeader[2] * 256 + abyChunkHeader[3] - 2;
430 71 : nChunkLoc += 4 + nMarkerLength;
431 :
432 : // Not a marker
433 71 : if (abyChunkHeader[0] != 0xFF)
434 0 : break;
435 :
436 : // Stop on Start of Scan
437 71 : if (abyChunkHeader[1] == 0xDA)
438 9 : break;
439 :
440 62 : if (abyChunkHeader[1] == 0xe1 &&
441 10 : memcmp(abyChunkHeader + 4, "FLIR\0", 5) == 0)
442 : {
443 : // Somewhat arbitrary limit
444 4 : if (abyFLIR.size() > 10 * 1024 * 1024)
445 : {
446 0 : CPLError(CE_Warning, CPLE_AppDefined,
447 : "Too large FLIR data compared to hardcoded limit");
448 0 : abyFLIR.clear();
449 0 : break;
450 : }
451 :
452 : // 8 = sizeof("FLIR\0") + '\1' + chunk_idx + chunk_count
453 4 : if (nMarkerLength < 8)
454 : {
455 0 : abyFLIR.clear();
456 0 : break;
457 : }
458 4 : size_t nOldSize = abyFLIR.size();
459 4 : abyFLIR.resize(nOldSize + nMarkerLength - 8);
460 : GByte abyIgnored[3]; // skip '\1' + chunk_idx + chunk_count
461 8 : if (VSIFReadL(abyIgnored, 3, 1, m_fpImage) != 1 ||
462 4 : VSIFReadL(&abyFLIR[nOldSize], nMarkerLength - 8, 1,
463 : m_fpImage) != 1)
464 : {
465 0 : abyFLIR.clear();
466 0 : break;
467 : }
468 : }
469 62 : }
470 : // Restore file pointer
471 9 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
472 :
473 9 : constexpr size_t FLIR_HEADER_SIZE = 64;
474 9 : if (abyFLIR.size() < FLIR_HEADER_SIZE)
475 5 : return;
476 4 : if (memcmp(&abyFLIR[0], "FFF\0", 4) != 0)
477 0 : return;
478 :
479 104 : const auto ReadString = [&abyFLIR](size_t nOffset, size_t nLen)
480 : {
481 : std::string osStr(
482 52 : reinterpret_cast<const char *>(abyFLIR.data()) + nOffset, nLen);
483 52 : osStr.resize(strlen(osStr.c_str()));
484 52 : return osStr;
485 4 : };
486 :
487 4 : bool bLittleEndian = false;
488 :
489 192 : const auto ReadUInt16 = [&abyFLIR, &bLittleEndian](size_t nOffset)
490 : {
491 : std::uint16_t nVal;
492 96 : memcpy(&nVal, &abyFLIR[nOffset], sizeof(nVal));
493 96 : if (bLittleEndian)
494 32 : CPL_LSBPTR16(&nVal);
495 : else
496 64 : CPL_MSBPTR16(&nVal);
497 96 : return nVal;
498 4 : };
499 :
500 8 : const auto ReadInt16 = [&abyFLIR, &bLittleEndian](size_t nOffset)
501 : {
502 : std::int16_t nVal;
503 4 : memcpy(&nVal, &abyFLIR[nOffset], sizeof(nVal));
504 4 : if (bLittleEndian)
505 4 : CPL_LSBPTR16(&nVal);
506 : else
507 0 : CPL_MSBPTR16(&nVal);
508 4 : return nVal;
509 4 : };
510 :
511 264 : const auto ReadUInt32 = [&abyFLIR, &bLittleEndian](size_t nOffset)
512 : {
513 : std::uint32_t nVal;
514 132 : memcpy(&nVal, &abyFLIR[nOffset], sizeof(nVal));
515 132 : if (bLittleEndian)
516 8 : CPL_LSBPTR32(&nVal);
517 : else
518 124 : CPL_MSBPTR32(&nVal);
519 132 : return nVal;
520 4 : };
521 :
522 8 : const auto ReadInt32 = [&abyFLIR, &bLittleEndian](size_t nOffset)
523 : {
524 : std::int32_t nVal;
525 4 : memcpy(&nVal, &abyFLIR[nOffset], sizeof(nVal));
526 4 : if (bLittleEndian)
527 4 : CPL_LSBPTR32(&nVal);
528 : else
529 0 : CPL_MSBPTR32(&nVal);
530 4 : return nVal;
531 4 : };
532 :
533 208 : const auto ReadFloat32 = [&abyFLIR, &bLittleEndian](size_t nOffset)
534 : {
535 : float fVal;
536 104 : memcpy(&fVal, &abyFLIR[nOffset], sizeof(fVal));
537 104 : if (bLittleEndian)
538 104 : CPL_LSBPTR32(&fVal);
539 : else
540 0 : CPL_MSBPTR32(&fVal);
541 104 : return fVal;
542 4 : };
543 :
544 0 : const auto ReadFloat64 = [&abyFLIR, &bLittleEndian](size_t nOffset)
545 : {
546 : double fVal;
547 0 : memcpy(&fVal, &abyFLIR[nOffset], sizeof(fVal));
548 0 : if (bLittleEndian)
549 0 : CPL_LSBPTR64(&fVal);
550 : else
551 0 : CPL_MSBPTR64(&fVal);
552 0 : return fVal;
553 4 : };
554 :
555 : // Avoid setting the PAM dirty bit just for that.
556 : struct PamFlagKeeper
557 : {
558 : int &m_nPamFlagsRef;
559 : int m_nOldPamFlags;
560 :
561 4 : explicit PamFlagKeeper(int &nPamFlagsRef)
562 4 : : m_nPamFlagsRef(nPamFlagsRef), m_nOldPamFlags(nPamFlagsRef)
563 : {
564 4 : }
565 :
566 4 : ~PamFlagKeeper()
567 4 : {
568 4 : m_nPamFlagsRef = m_nOldPamFlags;
569 4 : }
570 : };
571 :
572 4 : PamFlagKeeper oKeeper(nPamFlags);
573 :
574 : const auto SetStringIfNotEmpty =
575 52 : [&](const char *pszItemName, int nOffset, int nLength)
576 : {
577 104 : const auto str = ReadString(nOffset, nLength);
578 52 : if (!str.empty())
579 28 : SetMetadataItem(pszItemName, str.c_str(), "FLIR");
580 52 : };
581 4 : SetStringIfNotEmpty("CreatorSoftware", 4, 16);
582 :
583 : // Check file format version (big endian most of the time)
584 4 : const auto nFileFormatVersion = ReadUInt32(20);
585 4 : if (!(nFileFormatVersion >= 100 && nFileFormatVersion < 200))
586 : {
587 0 : bLittleEndian = true; // retry with little-endian
588 0 : const auto nFileFormatVersionOtherEndianness = ReadUInt32(20);
589 0 : if (!(nFileFormatVersionOtherEndianness >= 100 &&
590 : nFileFormatVersionOtherEndianness < 200))
591 : {
592 0 : CPLDebug("JPEG", "FLIR: Unknown file format version: %u",
593 : nFileFormatVersion);
594 0 : return;
595 : }
596 : }
597 :
598 4 : const auto nOffsetRecordDirectory = ReadUInt32(24);
599 4 : const auto nEntryCountRecordDirectory = ReadUInt32(28);
600 :
601 4 : CPLDebugOnly("JPEG", "FLIR: record offset %u, entry count %u",
602 : nOffsetRecordDirectory, nEntryCountRecordDirectory);
603 4 : constexpr size_t SIZE_RECORD_DIRECTORY = 32;
604 8 : if (nOffsetRecordDirectory < FLIR_HEADER_SIZE ||
605 4 : nOffsetRecordDirectory +
606 4 : SIZE_RECORD_DIRECTORY * nEntryCountRecordDirectory >
607 4 : abyFLIR.size())
608 : {
609 0 : CPLDebug("JPEG", "Invalid FLIR FFF directory");
610 0 : return;
611 : }
612 :
613 : // Read the RawData record
614 : const auto ReadRawData =
615 4 : [&](std::uint32_t nRecOffset, std::uint32_t nRecLength)
616 : {
617 4 : if (!(nRecLength >= 32 && nRecOffset + nRecLength <= abyFLIR.size()))
618 0 : return;
619 :
620 4 : const int nByteOrder = ReadUInt16(nRecOffset);
621 4 : if (nByteOrder == 512)
622 4 : bLittleEndian = !bLittleEndian;
623 0 : else if (nByteOrder != 2)
624 0 : return;
625 4 : const auto nImageWidth = ReadUInt16(nRecOffset + 2);
626 4 : SetMetadataItem("RawThermalImageWidth", CPLSPrintf("%d", nImageWidth),
627 4 : "FLIR");
628 4 : const auto nImageHeight = ReadUInt16(nRecOffset + 4);
629 4 : SetMetadataItem("RawThermalImageHeight", CPLSPrintf("%d", nImageHeight),
630 4 : "FLIR");
631 4 : m_bRawThermalLittleEndian = bLittleEndian;
632 4 : m_nRawThermalImageWidth = nImageWidth;
633 4 : m_nRawThermalImageHeight = nImageHeight;
634 4 : m_abyRawThermalImage.clear();
635 4 : m_abyRawThermalImage.insert(m_abyRawThermalImage.end(),
636 4 : abyFLIR.begin() + nRecOffset + 32,
637 12 : abyFLIR.begin() + nRecOffset + nRecLength);
638 :
639 4 : if (!STARTS_WITH(GetDescription(), "JPEG:"))
640 : {
641 4 : m_nSubdatasetCount++;
642 4 : SetMetadataItem(
643 : CPLSPrintf("SUBDATASET_%d_NAME", m_nSubdatasetCount),
644 : CPLSPrintf("JPEG:\"%s\":FLIR_RAW_THERMAL_IMAGE",
645 4 : GetDescription()),
646 4 : "SUBDATASETS");
647 4 : SetMetadataItem(
648 : CPLSPrintf("SUBDATASET_%d_DESC", m_nSubdatasetCount),
649 4 : "FLIR raw thermal image", "SUBDATASETS");
650 : }
651 4 : };
652 :
653 : // Read the Camera Info record
654 : const auto ReadCameraInfo =
655 4 : [&](std::uint32_t nRecOffset, std::uint32_t nRecLength)
656 : {
657 4 : if (!(nRecLength >= 1126 && nRecOffset + nRecLength <= abyFLIR.size()))
658 0 : return;
659 :
660 4 : const int nByteOrder = ReadUInt16(nRecOffset);
661 4 : if (nByteOrder == 512)
662 4 : bLittleEndian = !bLittleEndian;
663 0 : else if (nByteOrder != 2)
664 0 : return;
665 :
666 44 : const auto ReadFloat32FromKelvin = [=](std::uint32_t nOffset)
667 : {
668 44 : constexpr float ZERO_CELCIUS_IN_KELVIN = 273.15f;
669 44 : return ReadFloat32(nOffset) - ZERO_CELCIUS_IN_KELVIN;
670 4 : };
671 4 : SetMetadataItem("Emissivity",
672 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 32)), "FLIR");
673 4 : SetMetadataItem("ObjectDistance",
674 4 : CPLSPrintf("%f m", ReadFloat32(nRecOffset + 36)),
675 4 : "FLIR");
676 4 : SetMetadataItem(
677 : "ReflectedApparentTemperature",
678 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 40)), "FLIR");
679 4 : SetMetadataItem(
680 : "AtmosphericTemperature",
681 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 44)), "FLIR");
682 4 : SetMetadataItem(
683 : "IRWindowTemperature",
684 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 48)), "FLIR");
685 4 : SetMetadataItem("IRWindowTemperature",
686 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 52)), "FLIR");
687 4 : auto fRelativeHumidity = ReadFloat32(nRecOffset + 60);
688 4 : if (fRelativeHumidity > 2)
689 0 : fRelativeHumidity /= 100.0f; // Sometimes expressed in percentage
690 4 : SetMetadataItem("RelativeHumidity",
691 4 : CPLSPrintf("%f %%", 100.0f * fRelativeHumidity));
692 4 : SetMetadataItem("PlanckR1",
693 4 : CPLSPrintf("%.8g", ReadFloat32(nRecOffset + 88)),
694 4 : "FLIR");
695 4 : SetMetadataItem("PlanckB",
696 4 : CPLSPrintf("%.8g", ReadFloat32(nRecOffset + 92)),
697 4 : "FLIR");
698 4 : SetMetadataItem("PlanckF",
699 4 : CPLSPrintf("%.8g", ReadFloat32(nRecOffset + 96)),
700 4 : "FLIR");
701 4 : SetMetadataItem("AtmosphericTransAlpha1",
702 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 112)),
703 4 : "FLIR");
704 4 : SetMetadataItem("AtmosphericTransAlpha2",
705 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 116)),
706 4 : "FLIR");
707 4 : SetMetadataItem("AtmosphericTransBeta1",
708 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 120)),
709 4 : "FLIR");
710 4 : SetMetadataItem("AtmosphericTransBeta2",
711 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 124)),
712 4 : "FLIR");
713 4 : SetMetadataItem("AtmosphericTransX",
714 4 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 128)),
715 4 : "FLIR");
716 4 : SetMetadataItem(
717 : "CameraTemperatureRangeMax",
718 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 144)),
719 4 : "FLIR");
720 4 : SetMetadataItem(
721 : "CameraTemperatureRangeMin",
722 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 148)),
723 4 : "FLIR");
724 4 : SetMetadataItem(
725 : "CameraTemperatureMaxClip",
726 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 152)),
727 4 : "FLIR");
728 4 : SetMetadataItem(
729 : "CameraTemperatureMinClip",
730 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 156)),
731 4 : "FLIR");
732 4 : SetMetadataItem(
733 : "CameraTemperatureMaxWarn",
734 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 160)),
735 4 : "FLIR");
736 4 : SetMetadataItem(
737 : "CameraTemperatureMinWarn",
738 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 164)),
739 4 : "FLIR");
740 4 : SetMetadataItem(
741 : "CameraTemperatureMaxSaturated",
742 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 168)),
743 4 : "FLIR");
744 4 : SetMetadataItem(
745 : "CameraTemperatureMinSaturated",
746 4 : CPLSPrintf("%f C", ReadFloat32FromKelvin(nRecOffset + 172)),
747 4 : "FLIR");
748 :
749 4 : SetStringIfNotEmpty("CameraModel", nRecOffset + 212, 32);
750 4 : SetStringIfNotEmpty("CameraPartNumber", nRecOffset + 244, 16);
751 4 : SetStringIfNotEmpty("CameraSerialNumber", nRecOffset + 260, 16);
752 4 : SetStringIfNotEmpty("CameraSoftware", nRecOffset + 276, 16);
753 4 : SetStringIfNotEmpty("LensModel", nRecOffset + 368, 32);
754 4 : SetStringIfNotEmpty("LensPartNumber", nRecOffset + 400, 16);
755 4 : SetStringIfNotEmpty("LensSerialNumber", nRecOffset + 416, 16);
756 4 : SetMetadataItem("FieldOfView",
757 4 : CPLSPrintf("%f deg", ReadFloat32(nRecOffset + 436)),
758 4 : "FLIR");
759 4 : SetStringIfNotEmpty("FilterModel", nRecOffset + 492, 16);
760 4 : SetStringIfNotEmpty("FilterPartNumber", nRecOffset + 508, 32);
761 4 : SetStringIfNotEmpty("FilterSerialNumber", nRecOffset + 540, 32);
762 4 : SetMetadataItem("PlanckO",
763 4 : CPLSPrintf("%d", ReadInt32(nRecOffset + 776)), "FLIR");
764 4 : SetMetadataItem("PlanckR2",
765 4 : CPLSPrintf("%.8g", ReadFloat32(nRecOffset + 780)),
766 4 : "FLIR");
767 4 : SetMetadataItem("RawValueRangeMin",
768 4 : CPLSPrintf("%d", ReadUInt16(nRecOffset + 784)), "FLIR");
769 4 : SetMetadataItem("RawValueRangeMax",
770 4 : CPLSPrintf("%d", ReadUInt16(nRecOffset + 786)), "FLIR");
771 4 : SetMetadataItem("RawValueMedian",
772 4 : CPLSPrintf("%d", ReadUInt16(nRecOffset + 824)), "FLIR");
773 4 : SetMetadataItem("RawValueRange",
774 4 : CPLSPrintf("%d", ReadUInt16(nRecOffset + 828)), "FLIR");
775 4 : const auto nUnixTime = ReadUInt32(nRecOffset + 900);
776 4 : const auto nSS = ReadUInt32(nRecOffset + 904) & 0xffff;
777 4 : const auto nTZ = ReadInt16(nRecOffset + 908);
778 : struct tm brokenDown;
779 4 : CPLUnixTimeToYMDHMS(static_cast<GIntBig>(nUnixTime) - nTZ * 60,
780 : &brokenDown);
781 : std::string osDateTime(CPLSPrintf(
782 4 : "%04d-%02d-%02dT%02d:%02d:%02d.%03d", brokenDown.tm_year + 1900,
783 4 : brokenDown.tm_mon + 1, brokenDown.tm_mday, brokenDown.tm_hour,
784 8 : brokenDown.tm_min, brokenDown.tm_sec, nSS));
785 4 : if (nTZ <= 0)
786 4 : osDateTime += CPLSPrintf("+%02d:%02d", (-nTZ) / 60, (-nTZ) % 60);
787 : else
788 0 : osDateTime += CPLSPrintf("-%02d:%02d", nTZ / 60, nTZ % 60);
789 4 : SetMetadataItem("DateTimeOriginal", osDateTime.c_str(), "FLIR");
790 4 : SetMetadataItem("FocusStepCount",
791 4 : CPLSPrintf("%d", ReadUInt16(nRecOffset + 912)), "FLIR");
792 4 : SetMetadataItem("FocusDistance",
793 4 : CPLSPrintf("%f m", ReadFloat32(nRecOffset + 1116)),
794 4 : "FLIR");
795 4 : SetMetadataItem("FrameRate",
796 4 : CPLSPrintf("%d", ReadUInt16(nRecOffset + 1124)),
797 4 : "FLIR");
798 4 : };
799 :
800 : // Read the Palette Info record
801 : const auto ReadPaletteInfo =
802 4 : [&](std::uint32_t nRecOffset, std::uint32_t nRecLength)
803 : {
804 4 : if (!(nRecLength >= 112 && nRecOffset + nRecLength <= abyFLIR.size()))
805 0 : return;
806 4 : const int nPaletteColors = abyFLIR[nRecOffset];
807 4 : SetMetadataItem("PaletteColors", CPLSPrintf("%d", nPaletteColors),
808 4 : "FLIR");
809 :
810 : const auto SetColorItem =
811 72 : [this, &abyFLIR](const char *pszItem, std::uint32_t nOffset)
812 : {
813 24 : SetMetadataItem(pszItem,
814 24 : CPLSPrintf("%d %d %d", abyFLIR[nOffset],
815 24 : abyFLIR[nOffset + 1],
816 24 : abyFLIR[nOffset + 2]),
817 24 : "FLIR");
818 28 : };
819 4 : SetColorItem("AboveColor", nRecOffset + 6);
820 4 : SetColorItem("BelowColor", nRecOffset + 9);
821 4 : SetColorItem("OverflowColor", nRecOffset + 12);
822 4 : SetColorItem("UnderflowColor", nRecOffset + 15);
823 4 : SetColorItem("Isotherm1Color", nRecOffset + 18);
824 4 : SetColorItem("Isotherm2Color", nRecOffset + 21);
825 4 : SetMetadataItem("PaletteMethod",
826 4 : CPLSPrintf("%d", abyFLIR[nRecOffset + 26]), "FLIR");
827 4 : SetMetadataItem("PaletteStretch",
828 4 : CPLSPrintf("%d", abyFLIR[nRecOffset + 27]), "FLIR");
829 4 : SetStringIfNotEmpty("PaletteFileName", nRecOffset + 48, 32);
830 4 : SetStringIfNotEmpty("PaletteName", nRecOffset + 80, 32);
831 4 : if (nRecLength < static_cast<std::uint32_t>(112 + nPaletteColors * 3))
832 0 : return;
833 8 : std::string osPalette;
834 900 : for (int i = 0; i < nPaletteColors; i++)
835 : {
836 896 : if (!osPalette.empty())
837 892 : osPalette += ", ";
838 : osPalette +=
839 896 : CPLSPrintf("(%d %d %d)", abyFLIR[nRecOffset + 112 + 3 * i + 0],
840 896 : abyFLIR[nRecOffset + 112 + 3 * i + 1],
841 896 : abyFLIR[nRecOffset + 112 + 3 * i + 2]);
842 : }
843 4 : SetMetadataItem("Palette", osPalette.c_str(), "FLIR");
844 4 : };
845 :
846 : // Read the GPS Info record
847 : const auto ReadGPSInfo =
848 0 : [&](std::uint32_t nRecOffset, std::uint32_t nRecLength)
849 : {
850 0 : if (!(nRecLength >= 104 && nRecOffset + nRecLength <= abyFLIR.size()))
851 0 : return;
852 0 : auto nGPSValid = ReadUInt32(nRecOffset);
853 0 : if (nGPSValid == 0x01000000)
854 : {
855 0 : bLittleEndian = !bLittleEndian;
856 0 : nGPSValid = 1;
857 : }
858 0 : if (nGPSValid != 1)
859 0 : return;
860 0 : SetMetadataItem("GPSVersionID",
861 0 : CPLSPrintf("%c%c%c%c", abyFLIR[nRecOffset + 4],
862 0 : abyFLIR[nRecOffset + 5],
863 0 : abyFLIR[nRecOffset + 6],
864 0 : abyFLIR[nRecOffset + 7]),
865 0 : "FLIR");
866 0 : SetStringIfNotEmpty("GPSLatitudeRef", nRecOffset + 8, 1);
867 0 : SetStringIfNotEmpty("GPSLongitudeRef", nRecOffset + 10, 1);
868 0 : SetMetadataItem("GPSLatitude",
869 0 : CPLSPrintf("%.10f", ReadFloat64(nRecOffset + 16)),
870 0 : "FLIR");
871 0 : SetMetadataItem("GPSLongitude",
872 0 : CPLSPrintf("%.10f", ReadFloat64(nRecOffset + 24)),
873 0 : "FLIR");
874 0 : SetMetadataItem("GPSAltitude",
875 0 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 32)), "FLIR");
876 0 : SetMetadataItem("GPSDOP",
877 0 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 64)), "FLIR");
878 0 : SetStringIfNotEmpty("GPSSpeedRef", nRecOffset + 68, 1);
879 0 : SetStringIfNotEmpty("GPSTrackRef", nRecOffset + 70, 1);
880 0 : SetMetadataItem("GPSSpeed",
881 0 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 76)), "FLIR");
882 0 : SetMetadataItem("GPSTrack",
883 0 : CPLSPrintf("%f", ReadFloat32(nRecOffset + 80)), "FLIR");
884 0 : SetStringIfNotEmpty("GPSMapDatum", nRecOffset + 88, 16);
885 4 : };
886 :
887 4 : size_t nOffsetDirEntry = nOffsetRecordDirectory;
888 :
889 : enum FLIRRecordType
890 : {
891 : FLIR_REC_FREE = 0,
892 : FLIR_REC_RAWDATA = 1,
893 : FLIR_REC_CAMERA_INFO = 32,
894 : FLIR_REC_PALETTE_INFO = 34,
895 : FLIR_REC_GPS_INFO = 43,
896 : };
897 :
898 : // Iterate over records
899 60 : for (std::uint32_t iRec = 0; iRec < nEntryCountRecordDirectory; iRec++)
900 : {
901 56 : const auto nRecType = ReadUInt16(nOffsetDirEntry);
902 56 : const auto nRecOffset = ReadUInt32(nOffsetDirEntry + 12);
903 56 : const auto nRecLength = ReadUInt32(nOffsetDirEntry + 16);
904 56 : if (nRecType == FLIR_REC_FREE && nRecLength == 0)
905 40 : continue; // silently keep empty records of type 0
906 16 : CPLDebugOnly("JPEG", "FLIR: record %u, type %u, offset %u, length %u",
907 : iRec, nRecType, nRecOffset, nRecLength);
908 16 : if (nRecOffset + nRecLength > abyFLIR.size())
909 : {
910 0 : CPLDebug("JPEG",
911 : "Invalid record %u, type %u, offset %u, length %u "
912 : "w.r.t total FLIR segment size (%u)",
913 : iRec, nRecType, nRecOffset, nRecLength,
914 0 : static_cast<unsigned>(abyFLIR.size()));
915 0 : continue;
916 : }
917 16 : switch (nRecType)
918 : {
919 4 : case FLIR_REC_RAWDATA:
920 : {
921 4 : const auto bLittleEndianBackup = bLittleEndian;
922 4 : ReadRawData(nRecOffset, nRecLength);
923 4 : bLittleEndian = bLittleEndianBackup;
924 4 : break;
925 : }
926 4 : case FLIR_REC_CAMERA_INFO:
927 : {
928 4 : const auto bLittleEndianBackup = bLittleEndian;
929 4 : ReadCameraInfo(nRecOffset, nRecLength);
930 4 : bLittleEndian = bLittleEndianBackup;
931 4 : break;
932 : }
933 4 : case FLIR_REC_PALETTE_INFO:
934 : {
935 4 : ReadPaletteInfo(nRecOffset, nRecLength);
936 4 : break;
937 : }
938 0 : case FLIR_REC_GPS_INFO:
939 : {
940 0 : const auto bLittleEndianBackup = bLittleEndian;
941 0 : ReadGPSInfo(nRecOffset, nRecLength);
942 0 : bLittleEndian = bLittleEndianBackup;
943 0 : break;
944 : }
945 4 : default:
946 : {
947 4 : CPLDebugOnly("JPEG", "FLIR record ignored");
948 4 : break;
949 : }
950 : }
951 16 : nOffsetDirEntry += SIZE_RECORD_DIRECTORY;
952 : }
953 :
954 4 : CPLDebug("JPEG", "FLIR metadata read");
955 : }
956 :
957 : /************************************************************************/
958 : /* GetMetadataDomainList() */
959 : /************************************************************************/
960 :
961 5 : char **JPGDatasetCommon::GetMetadataDomainList()
962 : {
963 5 : ReadFLIRMetadata();
964 5 : return BuildMetadataDomainList(GDALPamDataset::GetMetadataDomainList(),
965 : TRUE, "xml:XMP", "COLOR_PROFILE", "FLIR",
966 5 : nullptr);
967 : }
968 :
969 : /************************************************************************/
970 : /* LoadForMetadataDomain() */
971 : /************************************************************************/
972 3444 : void JPGDatasetCommon::LoadForMetadataDomain(const char *pszDomain)
973 : {
974 3444 : if (m_fpImage == nullptr)
975 0 : return;
976 3444 : if (eAccess == GA_ReadOnly && !bHasReadEXIFMetadata &&
977 2809 : (pszDomain == nullptr || EQUAL(pszDomain, "")))
978 76 : ReadEXIFMetadata();
979 3444 : if (eAccess == GA_ReadOnly && !bHasReadImageStructureMetadata &&
980 3436 : pszDomain != nullptr && EQUAL(pszDomain, "IMAGE_STRUCTURE"))
981 5 : ReadImageStructureMetadata();
982 3444 : if (eAccess == GA_ReadOnly && pszDomain != nullptr &&
983 3436 : EQUAL(pszDomain, "xml:XMP"))
984 : {
985 144 : if (!bHasReadXMPMetadata)
986 : {
987 17 : ReadXMPMetadata();
988 : }
989 182 : if (!bHasReadEXIFMetadata &&
990 38 : GDALPamDataset::GetMetadata("xml:XMP") == nullptr)
991 : {
992 : // XMP can sometimes be embedded in a EXIF TIFF tag
993 31 : ReadEXIFMetadata();
994 : }
995 : }
996 3444 : if (eAccess == GA_ReadOnly && !bHasReadICCMetadata &&
997 2884 : pszDomain != nullptr && EQUAL(pszDomain, "COLOR_PROFILE"))
998 36 : ReadICCProfile();
999 3444 : if (eAccess == GA_ReadOnly && !bHasReadFLIRMetadata &&
1000 3418 : pszDomain != nullptr && EQUAL(pszDomain, "FLIR"))
1001 0 : ReadFLIRMetadata();
1002 3444 : if (pszDomain != nullptr && EQUAL(pszDomain, "SUBDATASETS"))
1003 2 : ReadFLIRMetadata();
1004 : }
1005 :
1006 : /************************************************************************/
1007 : /* GetMetadata() */
1008 : /************************************************************************/
1009 514 : char **JPGDatasetCommon::GetMetadata(const char *pszDomain)
1010 : {
1011 514 : LoadForMetadataDomain(pszDomain);
1012 514 : return GDALPamDataset::GetMetadata(pszDomain);
1013 : }
1014 :
1015 : /************************************************************************/
1016 : /* GetMetadataItem() */
1017 : /************************************************************************/
1018 3234 : const char *JPGDatasetCommon::GetMetadataItem(const char *pszName,
1019 : const char *pszDomain)
1020 : {
1021 3234 : if (pszDomain != nullptr && EQUAL(pszDomain, "IMAGE_STRUCTURE"))
1022 : {
1023 307 : if (EQUAL(pszName, "JPEG_QUALITY"))
1024 3 : LoadForMetadataDomain(pszDomain);
1025 : }
1026 : else
1027 : {
1028 2927 : LoadForMetadataDomain(pszDomain);
1029 : }
1030 3234 : return GDALPamDataset::GetMetadataItem(pszName, pszDomain);
1031 : }
1032 :
1033 : /************************************************************************/
1034 : /* ReadICCProfile() */
1035 : /* */
1036 : /* Read ICC Profile from APP2 data */
1037 : /************************************************************************/
1038 36 : void JPGDatasetCommon::ReadICCProfile()
1039 : {
1040 36 : if (bHasReadICCMetadata)
1041 0 : return;
1042 36 : bHasReadICCMetadata = true;
1043 :
1044 36 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
1045 :
1046 36 : int nChunkCount = -1;
1047 36 : int anChunkSize[256] = {};
1048 36 : char *apChunk[256] = {};
1049 :
1050 : // Search for APP2 chunk.
1051 36 : GByte abyChunkHeader[18] = {};
1052 36 : int nChunkLoc = 2;
1053 36 : bool bOk = true;
1054 :
1055 : while (true)
1056 : {
1057 351 : if (VSIFSeekL(m_fpImage, nChunkLoc, SEEK_SET) != 0)
1058 0 : break;
1059 :
1060 351 : if (VSIFReadL(abyChunkHeader, sizeof(abyChunkHeader), 1, m_fpImage) !=
1061 : 1)
1062 3 : break;
1063 :
1064 348 : if (abyChunkHeader[0] != 0xFF)
1065 33 : break; // Not a valid tag
1066 :
1067 315 : if (abyChunkHeader[1] == 0xD9)
1068 0 : break; // End of image
1069 :
1070 315 : if ((abyChunkHeader[1] >= 0xD0) && (abyChunkHeader[1] <= 0xD8))
1071 : {
1072 : // Restart tags have no length
1073 0 : nChunkLoc += 2;
1074 0 : continue;
1075 : }
1076 :
1077 315 : const int nChunkLength = abyChunkHeader[2] * 256 + abyChunkHeader[3];
1078 :
1079 315 : if (abyChunkHeader[1] == 0xe2 &&
1080 19 : memcmp(reinterpret_cast<char *>(abyChunkHeader) + 4,
1081 : "ICC_PROFILE\0", 12) == 0)
1082 : {
1083 : // Get length and segment ID
1084 : // Header:
1085 : // APP2 tag: 2 bytes
1086 : // App Length: 2 bytes
1087 : // ICC_PROFILE\0 tag: 12 bytes
1088 : // Segment index: 1 bytes
1089 : // Total segments: 1 bytes
1090 19 : const int nICCChunkLength = nChunkLength - 16;
1091 19 : if (nICCChunkLength < 0)
1092 : {
1093 0 : CPLError(CE_Failure, CPLE_FileIO,
1094 : "nICCChunkLength unreasonable: %d", nICCChunkLength);
1095 0 : bOk = false;
1096 0 : break;
1097 : }
1098 19 : const int nICCChunkID = abyChunkHeader[16];
1099 19 : const int nICCMaxChunkID = abyChunkHeader[17];
1100 :
1101 19 : if (nChunkCount == -1)
1102 7 : nChunkCount = nICCMaxChunkID;
1103 :
1104 : // Check that all max segment counts are the same.
1105 19 : if (nICCMaxChunkID != nChunkCount)
1106 : {
1107 0 : bOk = false;
1108 0 : break;
1109 : }
1110 :
1111 : // Check that no segment ID is larger than the total segment count.
1112 19 : if ((nICCChunkID > nChunkCount) || (nICCChunkID == 0) ||
1113 : (nChunkCount == 0))
1114 : {
1115 0 : bOk = false;
1116 0 : break;
1117 : }
1118 :
1119 : // Check if ICC segment already loaded.
1120 19 : if (apChunk[nICCChunkID - 1] != nullptr)
1121 : {
1122 0 : bOk = false;
1123 0 : break;
1124 : }
1125 :
1126 : // Load it.
1127 38 : apChunk[nICCChunkID - 1] =
1128 19 : static_cast<char *>(VSIMalloc(nICCChunkLength));
1129 19 : if (apChunk[nICCChunkID - 1] == nullptr)
1130 : {
1131 0 : bOk = false;
1132 0 : break;
1133 : }
1134 19 : anChunkSize[nICCChunkID - 1] = nICCChunkLength;
1135 :
1136 19 : if (VSIFReadL(apChunk[nICCChunkID - 1], nICCChunkLength, 1,
1137 19 : m_fpImage) != 1)
1138 : {
1139 0 : bOk = false;
1140 0 : break;
1141 : }
1142 : }
1143 :
1144 315 : nChunkLoc += 2 + nChunkLength;
1145 315 : }
1146 :
1147 36 : int nTotalSize = 0;
1148 :
1149 : // Get total size and verify that there are no missing segments.
1150 36 : if (bOk)
1151 : {
1152 55 : for (int i = 0; i < nChunkCount; i++)
1153 : {
1154 19 : if (apChunk[i] == nullptr)
1155 : {
1156 : // Missing segment - abort.
1157 0 : bOk = false;
1158 0 : break;
1159 : }
1160 19 : const int nSize = anChunkSize[i];
1161 38 : if (nSize < 0 ||
1162 19 : nTotalSize > std::numeric_limits<int>::max() - nSize)
1163 : {
1164 0 : CPLError(CE_Failure, CPLE_FileIO, "nTotalSize nonsensical");
1165 0 : bOk = false;
1166 0 : break;
1167 : }
1168 19 : nTotalSize += anChunkSize[i];
1169 : }
1170 : }
1171 :
1172 : // TODO(schwehr): Can we know what the maximum reasonable size is?
1173 36 : if (nTotalSize > 2 << 28)
1174 : {
1175 0 : CPLError(CE_Failure, CPLE_FileIO, "nTotalSize unreasonable: %d",
1176 : nTotalSize);
1177 0 : bOk = false;
1178 : }
1179 :
1180 : // Merge all segments together and set metadata.
1181 36 : if (bOk && nChunkCount > 0)
1182 : {
1183 7 : char *pBuffer = static_cast<char *>(VSIMalloc(nTotalSize));
1184 7 : if (pBuffer == nullptr)
1185 : {
1186 0 : CPLError(CE_Failure, CPLE_OutOfMemory,
1187 : "ICCProfile too large. nTotalSize: %d", nTotalSize);
1188 : }
1189 : else
1190 : {
1191 7 : char *pBufferPtr = pBuffer;
1192 26 : for (int i = 0; i < nChunkCount; i++)
1193 : {
1194 19 : memcpy(pBufferPtr, apChunk[i], anChunkSize[i]);
1195 19 : pBufferPtr += anChunkSize[i];
1196 : }
1197 :
1198 : // Escape the profile.
1199 : char *pszBase64Profile =
1200 7 : CPLBase64Encode(nTotalSize, reinterpret_cast<GByte *>(pBuffer));
1201 :
1202 : // Avoid setting the PAM dirty bit just for that.
1203 7 : const int nOldPamFlags = nPamFlags;
1204 :
1205 : // Set ICC profile metadata.
1206 7 : SetMetadataItem("SOURCE_ICC_PROFILE", pszBase64Profile,
1207 7 : "COLOR_PROFILE");
1208 :
1209 7 : nPamFlags = nOldPamFlags;
1210 :
1211 7 : VSIFree(pBuffer);
1212 7 : CPLFree(pszBase64Profile);
1213 : }
1214 : }
1215 :
1216 55 : for (int i = 0; i < nChunkCount; i++)
1217 : {
1218 19 : if (apChunk[i] != nullptr)
1219 19 : VSIFree(apChunk[i]);
1220 : }
1221 :
1222 36 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
1223 : }
1224 :
1225 : /************************************************************************/
1226 : /* EXIFInit() */
1227 : /* */
1228 : /* Create Metadata from Information file directory APP1 */
1229 : /************************************************************************/
1230 2153 : bool JPGDatasetCommon::EXIFInit(VSILFILE *fp)
1231 : {
1232 2153 : if (nTiffDirStart == 0)
1233 0 : return false;
1234 2153 : if (nTiffDirStart > 0)
1235 2 : return true;
1236 2151 : nTiffDirStart = 0;
1237 :
1238 : #ifdef CPL_MSB
1239 : constexpr bool bigendian = true;
1240 : #else
1241 2151 : constexpr bool bigendian = false;
1242 : #endif
1243 :
1244 : // Search for APP1 chunk.
1245 2151 : GByte abyChunkHeader[10] = {};
1246 2151 : int nChunkLoc = 2;
1247 :
1248 : while (true)
1249 : {
1250 2329 : if (VSIFSeekL(fp, nChunkLoc, SEEK_SET) != 0)
1251 0 : return false;
1252 :
1253 2329 : if (VSIFReadL(abyChunkHeader, sizeof(abyChunkHeader), 1, fp) != 1)
1254 0 : return false;
1255 :
1256 2329 : const int nChunkLength = abyChunkHeader[2] * 256 + abyChunkHeader[3];
1257 : // COM marker
1258 2329 : if (abyChunkHeader[0] == 0xFF && abyChunkHeader[1] == 0xFE &&
1259 : nChunkLength >= 2)
1260 : {
1261 : char *pszComment =
1262 4 : static_cast<char *>(CPLMalloc(nChunkLength - 2 + 1));
1263 8 : if (nChunkLength > 2 &&
1264 8 : VSIFSeekL(fp, nChunkLoc + 4, SEEK_SET) == 0 &&
1265 4 : VSIFReadL(pszComment, nChunkLength - 2, 1, fp) == 1)
1266 : {
1267 4 : pszComment[nChunkLength - 2] = 0;
1268 : // Avoid setting the PAM dirty bit just for that.
1269 4 : const int nOldPamFlags = nPamFlags;
1270 : // Set ICC profile metadata.
1271 4 : SetMetadataItem("COMMENT", pszComment);
1272 4 : nPamFlags = nOldPamFlags;
1273 : }
1274 4 : CPLFree(pszComment);
1275 : }
1276 : else
1277 : {
1278 2325 : if (abyChunkHeader[0] != 0xFF || (abyChunkHeader[1] & 0xf0) != 0xe0)
1279 : break; // Not an APP chunk.
1280 :
1281 174 : if (abyChunkHeader[1] == 0xe1 &&
1282 57 : STARTS_WITH(reinterpret_cast<char *>(abyChunkHeader) + 4,
1283 : "Exif"))
1284 : {
1285 49 : if (nTIFFHEADER < 0)
1286 : {
1287 49 : nTIFFHEADER = nChunkLoc + 10;
1288 : }
1289 : else
1290 : {
1291 0 : CPLDebug(
1292 : "JPEG",
1293 : "Another Exif directory found at offset %u. Ignoring "
1294 : "it and only taking into account the one at offset %u",
1295 0 : unsigned(nChunkLoc + 10), unsigned(nTIFFHEADER));
1296 : }
1297 : }
1298 : }
1299 :
1300 178 : nChunkLoc += 2 + nChunkLength;
1301 178 : }
1302 :
1303 2151 : if (nTIFFHEADER < 0)
1304 2102 : return false;
1305 :
1306 : // Read TIFF header.
1307 49 : TIFFHeader hdr = {0, 0, 0};
1308 :
1309 49 : VSIFSeekL(fp, nTIFFHEADER, SEEK_SET);
1310 49 : if (VSIFReadL(&hdr, 1, sizeof(hdr), fp) != sizeof(hdr))
1311 : {
1312 0 : CPLError(CE_Failure, CPLE_FileIO,
1313 : "Failed to read %d byte from image header.",
1314 : static_cast<int>(sizeof(hdr)));
1315 0 : return false;
1316 : }
1317 :
1318 49 : if (hdr.tiff_magic != TIFF_BIGENDIAN && hdr.tiff_magic != TIFF_LITTLEENDIAN)
1319 : {
1320 0 : CPLError(CE_Failure, CPLE_AppDefined,
1321 0 : "Not a TIFF file, bad magic number %u (%#x)", hdr.tiff_magic,
1322 0 : hdr.tiff_magic);
1323 0 : return false;
1324 : }
1325 :
1326 49 : if (hdr.tiff_magic == TIFF_BIGENDIAN)
1327 4 : bSwabflag = !bigendian;
1328 49 : if (hdr.tiff_magic == TIFF_LITTLEENDIAN)
1329 45 : bSwabflag = bigendian;
1330 :
1331 49 : if (bSwabflag)
1332 : {
1333 4 : CPL_SWAP16PTR(&hdr.tiff_version);
1334 4 : CPL_SWAP32PTR(&hdr.tiff_diroff);
1335 : }
1336 :
1337 49 : if (hdr.tiff_version != TIFF_VERSION)
1338 : {
1339 0 : CPLError(CE_Failure, CPLE_AppDefined,
1340 : "Not a TIFF file, bad version number %u (%#x)",
1341 0 : hdr.tiff_version, hdr.tiff_version);
1342 0 : return false;
1343 : }
1344 49 : nTiffDirStart = hdr.tiff_diroff;
1345 :
1346 49 : CPLDebug("JPEG", "Magic: %#x <%s-endian> Version: %#x\n", hdr.tiff_magic,
1347 49 : hdr.tiff_magic == TIFF_BIGENDIAN ? "big" : "little",
1348 49 : hdr.tiff_version);
1349 :
1350 49 : return true;
1351 : }
1352 :
1353 : /************************************************************************/
1354 : /* JPGMaskBand() */
1355 : /************************************************************************/
1356 :
1357 15 : JPGMaskBand::JPGMaskBand(JPGDatasetCommon *poDSIn)
1358 :
1359 : {
1360 15 : poDS = poDSIn;
1361 15 : nBand = 0;
1362 :
1363 15 : nRasterXSize = poDS->GetRasterXSize();
1364 15 : nRasterYSize = poDS->GetRasterYSize();
1365 :
1366 15 : eDataType = GDT_Byte;
1367 15 : nBlockXSize = nRasterXSize;
1368 15 : nBlockYSize = 1;
1369 15 : }
1370 :
1371 : /************************************************************************/
1372 : /* IReadBlock() */
1373 : /************************************************************************/
1374 :
1375 4261 : CPLErr JPGMaskBand::IReadBlock(int /* nBlockX */, int nBlockY, void *pImage)
1376 : {
1377 4261 : JPGDatasetCommon *poJDS = cpl::down_cast<JPGDatasetCommon *>(poDS);
1378 :
1379 : // Make sure the mask is loaded and decompressed.
1380 4261 : poJDS->DecompressMask();
1381 4261 : if (poJDS->pabyBitMask == nullptr)
1382 0 : return CE_Failure;
1383 :
1384 : // Set mask based on bitmask for this scanline.
1385 4261 : GUInt32 iBit =
1386 4261 : static_cast<GUInt32>(nBlockY) * static_cast<GUInt32>(nBlockXSize);
1387 :
1388 4261 : GByte *const pbyImage = static_cast<GByte *>(pImage);
1389 4261 : if (poJDS->bMaskLSBOrder)
1390 : {
1391 2104220 : for (int iX = 0; iX < nBlockXSize; iX++)
1392 : {
1393 2100020 : if (poJDS->pabyBitMask[iBit >> 3] & (0x1 << (iBit & 7)))
1394 1582040 : pbyImage[iX] = 255;
1395 : else
1396 517974 : pbyImage[iX] = 0;
1397 2100020 : iBit++;
1398 : }
1399 : }
1400 : else
1401 : {
1402 1706 : for (int iX = 0; iX < nBlockXSize; iX++)
1403 : {
1404 1649 : if (poJDS->pabyBitMask[iBit >> 3] & (0x1 << (7 - (iBit & 7))))
1405 584 : pbyImage[iX] = 255;
1406 : else
1407 1065 : pbyImage[iX] = 0;
1408 1649 : iBit++;
1409 : }
1410 : }
1411 :
1412 4261 : return CE_None;
1413 : }
1414 :
1415 : /************************************************************************/
1416 : /* JPGRasterBand() */
1417 : /************************************************************************/
1418 :
1419 25245 : JPGRasterBand::JPGRasterBand(JPGDatasetCommon *poDSIn, int nBandIn)
1420 25245 : : poGDS(poDSIn)
1421 : {
1422 25245 : poDS = poDSIn;
1423 :
1424 25245 : nBand = nBandIn;
1425 25245 : if (poDSIn->GetDataPrecision() == 12)
1426 381 : eDataType = GDT_UInt16;
1427 : else
1428 24864 : eDataType = GDT_Byte;
1429 :
1430 25245 : nBlockXSize = poDSIn->nRasterXSize;
1431 25245 : nBlockYSize = 1;
1432 :
1433 25245 : GDALMajorObject::SetMetadataItem("COMPRESSION", "JPEG", "IMAGE_STRUCTURE");
1434 25245 : if (eDataType == GDT_UInt16)
1435 381 : GDALMajorObject::SetMetadataItem("NBITS", "12", "IMAGE_STRUCTURE");
1436 25245 : }
1437 :
1438 : /************************************************************************/
1439 : /* JPGCreateBand() */
1440 : /************************************************************************/
1441 :
1442 25245 : GDALRasterBand *JPGCreateBand(JPGDatasetCommon *poDS, int nBand)
1443 : {
1444 25245 : return new JPGRasterBand(poDS, nBand);
1445 : }
1446 :
1447 : /************************************************************************/
1448 : /* IReadBlock() */
1449 : /************************************************************************/
1450 :
1451 200361 : CPLErr JPGRasterBand::IReadBlock(int nBlockXOff, int nBlockYOff, void *pImage)
1452 :
1453 : {
1454 200361 : CPLAssert(nBlockXOff == 0);
1455 :
1456 200361 : const int nXSize = GetXSize();
1457 200363 : const int nWordSize = GDALGetDataTypeSizeBytes(eDataType);
1458 200360 : if (poGDS->m_fpImage == nullptr)
1459 : {
1460 70 : memset(pImage, 0, cpl::fits_on<int>(nXSize * nWordSize));
1461 70 : return CE_None;
1462 : }
1463 :
1464 : // Load the desired scanline into the working buffer.
1465 200290 : CPLErr eErr = poGDS->LoadScanline(nBlockYOff);
1466 200290 : if (eErr != CE_None)
1467 5 : return eErr;
1468 :
1469 : // Transfer between the working buffer the callers buffer.
1470 200285 : if (poGDS->GetRasterCount() == 1)
1471 : {
1472 : #ifdef JPEG_LIB_MK1
1473 : GDALCopyWords(poGDS->m_pabyScanline, GDT_UInt16, 2, pImage, eDataType,
1474 : nWordSize, nXSize);
1475 : #else
1476 32951 : memcpy(pImage, poGDS->m_pabyScanline,
1477 32950 : cpl::fits_on<int>(nXSize * nWordSize));
1478 : #endif
1479 : }
1480 : else
1481 : {
1482 : #ifdef JPEG_LIB_MK1
1483 : GDALCopyWords(poGDS->m_pabyScanline + (nBand - 1) * 2, GDT_UInt16, 6,
1484 : pImage, eDataType, nWordSize, nXSize);
1485 : #else
1486 498026 : if (poGDS->eGDALColorSpace == JCS_RGB &&
1487 167338 : poGDS->GetOutColorSpace() == JCS_CMYK && eDataType == GDT_Byte)
1488 : {
1489 150 : GByte *const pbyImage = static_cast<GByte *>(pImage);
1490 150 : if (nBand == 1)
1491 : {
1492 2550 : for (int i = 0; i < nXSize; i++)
1493 : {
1494 2500 : const int C = poGDS->m_pabyScanline[i * 4 + 0];
1495 2500 : const int K = poGDS->m_pabyScanline[i * 4 + 3];
1496 2500 : pbyImage[i] = static_cast<GByte>((C * K) / 255);
1497 : }
1498 : }
1499 100 : else if (nBand == 2)
1500 : {
1501 2550 : for (int i = 0; i < nXSize; i++)
1502 : {
1503 2500 : const int M = poGDS->m_pabyScanline[i * 4 + 1];
1504 2500 : const int K = poGDS->m_pabyScanline[i * 4 + 3];
1505 2500 : pbyImage[i] = static_cast<GByte>((M * K) / 255);
1506 : }
1507 : }
1508 50 : else if (nBand == 3)
1509 : {
1510 2550 : for (int i = 0; i < nXSize; i++)
1511 : {
1512 2500 : const int Y = poGDS->m_pabyScanline[i * 4 + 2];
1513 2500 : const int K = poGDS->m_pabyScanline[i * 4 + 3];
1514 2500 : pbyImage[i] = static_cast<GByte>((Y * K) / 255);
1515 : }
1516 : }
1517 : }
1518 : else
1519 : {
1520 334376 : GDALCopyWords(poGDS->m_pabyScanline + (nBand - 1) * nWordSize,
1521 167188 : eDataType, nWordSize * poGDS->GetRasterCount(),
1522 : pImage, eDataType, nWordSize, nXSize);
1523 : }
1524 : #endif
1525 : }
1526 :
1527 : // Forcibly load the other bands associated with this scanline.
1528 200290 : if (nBand == 1)
1529 : {
1530 189907 : for (int iBand = 2; iBand <= poGDS->GetRasterCount(); iBand++)
1531 : {
1532 : GDALRasterBlock *const poBlock =
1533 104952 : poGDS->GetRasterBand(iBand)->GetLockedBlockRef(nBlockXOff,
1534 104952 : nBlockYOff);
1535 104952 : if (poBlock != nullptr)
1536 104952 : poBlock->DropLock();
1537 : }
1538 : }
1539 :
1540 200289 : return CE_None;
1541 : }
1542 :
1543 : /************************************************************************/
1544 : /* GetColorInterpretation() */
1545 : /************************************************************************/
1546 :
1547 470 : GDALColorInterp JPGRasterBand::GetColorInterpretation()
1548 :
1549 : {
1550 470 : if (poGDS->eGDALColorSpace == JCS_GRAYSCALE)
1551 91 : return GCI_GrayIndex;
1552 :
1553 379 : else if (poGDS->eGDALColorSpace == JCS_RGB)
1554 : {
1555 255 : if (nBand == 1)
1556 86 : return GCI_RedBand;
1557 169 : else if (nBand == 2)
1558 80 : return GCI_GreenBand;
1559 : else
1560 89 : return GCI_BlueBand;
1561 : }
1562 124 : else if (poGDS->eGDALColorSpace == JCS_CMYK)
1563 : {
1564 124 : if (nBand == 1)
1565 30 : return GCI_CyanBand;
1566 94 : else if (nBand == 2)
1567 26 : return GCI_MagentaBand;
1568 68 : else if (nBand == 3)
1569 26 : return GCI_YellowBand;
1570 : else
1571 42 : return GCI_BlackBand;
1572 : }
1573 0 : else if (poGDS->eGDALColorSpace == JCS_YCbCr ||
1574 0 : poGDS->eGDALColorSpace == JCS_YCCK)
1575 : {
1576 0 : if (nBand == 1)
1577 0 : return GCI_YCbCr_YBand;
1578 0 : else if (nBand == 2)
1579 0 : return GCI_YCbCr_CbBand;
1580 0 : else if (nBand == 3)
1581 0 : return GCI_YCbCr_CrBand;
1582 : else
1583 0 : return GCI_BlackBand;
1584 : }
1585 :
1586 0 : CPLAssert(false);
1587 : return GCI_Undefined;
1588 : }
1589 :
1590 : /************************************************************************/
1591 : /* GetMaskBand() */
1592 : /************************************************************************/
1593 :
1594 301 : GDALRasterBand *JPGRasterBand::GetMaskBand()
1595 :
1596 : {
1597 301 : if (poGDS->nScaleFactor > 1)
1598 0 : return GDALPamRasterBand::GetMaskBand();
1599 :
1600 301 : if (poGDS->m_fpImage == nullptr)
1601 0 : return nullptr;
1602 :
1603 301 : if (!poGDS->bHasCheckedForMask)
1604 : {
1605 62 : if (CPLTestBool(CPLGetConfigOption("JPEG_READ_MASK", "YES")))
1606 62 : poGDS->CheckForMask();
1607 62 : poGDS->bHasCheckedForMask = true;
1608 : }
1609 301 : if (poGDS->pabyCMask)
1610 : {
1611 42 : if (poGDS->poMaskBand == nullptr)
1612 15 : poGDS->poMaskBand = new JPGMaskBand(poGDS);
1613 :
1614 42 : return poGDS->poMaskBand;
1615 : }
1616 :
1617 259 : return GDALPamRasterBand::GetMaskBand();
1618 : }
1619 :
1620 : /************************************************************************/
1621 : /* GetMaskFlags() */
1622 : /************************************************************************/
1623 :
1624 281 : int JPGRasterBand::GetMaskFlags()
1625 :
1626 : {
1627 281 : if (poGDS->nScaleFactor > 1)
1628 0 : return GDALPamRasterBand::GetMaskFlags();
1629 :
1630 281 : if (poGDS->m_fpImage == nullptr)
1631 0 : return 0;
1632 :
1633 281 : GetMaskBand();
1634 281 : if (poGDS->poMaskBand != nullptr)
1635 25 : return GMF_PER_DATASET;
1636 :
1637 256 : return GDALPamRasterBand::GetMaskFlags();
1638 : }
1639 :
1640 : /************************************************************************/
1641 : /* GetOverview() */
1642 : /************************************************************************/
1643 :
1644 7934 : GDALRasterBand *JPGRasterBand::GetOverview(int i)
1645 : {
1646 7934 : if (i < 0 || i >= GetOverviewCount())
1647 2 : return nullptr;
1648 :
1649 7932 : if (poGDS->nInternalOverviewsCurrent == 0)
1650 2 : return GDALPamRasterBand::GetOverview(i);
1651 :
1652 7930 : return poGDS->papoInternalOverviews[i]->GetRasterBand(nBand);
1653 : }
1654 :
1655 : /************************************************************************/
1656 : /* GetOverviewCount() */
1657 : /************************************************************************/
1658 :
1659 18427 : int JPGRasterBand::GetOverviewCount()
1660 : {
1661 18427 : if (!poGDS->AreOverviewsEnabled())
1662 0 : return 0;
1663 :
1664 18427 : poGDS->InitInternalOverviews();
1665 :
1666 18427 : if (poGDS->nInternalOverviewsCurrent == 0)
1667 2502 : return GDALPamRasterBand::GetOverviewCount();
1668 :
1669 15925 : return poGDS->nInternalOverviewsCurrent;
1670 : }
1671 :
1672 : /************************************************************************/
1673 : /* ==================================================================== */
1674 : /* JPGDataset */
1675 : /* ==================================================================== */
1676 : /************************************************************************/
1677 :
1678 11256 : JPGDatasetCommon::JPGDatasetCommon()
1679 : : nScaleFactor(1), bHasInitInternalOverviews(false),
1680 : nInternalOverviewsCurrent(0), nInternalOverviewsToFree(0),
1681 : papoInternalOverviews(nullptr), bGeoTransformValid(false),
1682 : m_fpImage(nullptr), nSubfileOffset(0), nLoadedScanline(-1),
1683 : m_pabyScanline(nullptr), bHasReadEXIFMetadata(false),
1684 : bHasReadXMPMetadata(false), bHasReadICCMetadata(false),
1685 : papszMetadata(nullptr), nExifOffset(-1), nInterOffset(-1), nGPSOffset(-1),
1686 : bSwabflag(false), nTiffDirStart(-1), nTIFFHEADER(-1),
1687 : bHasDoneJpegCreateDecompress(false), bHasDoneJpegStartDecompress(false),
1688 : bHasCheckedForMask(false), poMaskBand(nullptr), pabyBitMask(nullptr),
1689 : bMaskLSBOrder(true), pabyCMask(nullptr), nCMaskSize(0),
1690 : eGDALColorSpace(JCS_UNKNOWN), bIsSubfile(false),
1691 11256 : bHasTriedLoadWorldFileOrTab(false)
1692 : {
1693 11256 : adfGeoTransform[0] = 0.0;
1694 11256 : adfGeoTransform[1] = 1.0;
1695 11256 : adfGeoTransform[2] = 0.0;
1696 11256 : adfGeoTransform[3] = 0.0;
1697 11256 : adfGeoTransform[4] = 0.0;
1698 11256 : adfGeoTransform[5] = 1.0;
1699 11256 : }
1700 :
1701 : /************************************************************************/
1702 : /* ~JPGDataset() */
1703 : /************************************************************************/
1704 :
1705 11256 : JPGDatasetCommon::~JPGDatasetCommon()
1706 :
1707 : {
1708 11256 : if (m_fpImage != nullptr)
1709 11053 : VSIFCloseL(m_fpImage);
1710 :
1711 11256 : if (m_pabyScanline != nullptr)
1712 3166 : CPLFree(m_pabyScanline);
1713 11256 : if (papszMetadata != nullptr)
1714 44 : CSLDestroy(papszMetadata);
1715 :
1716 11256 : CPLFree(pabyBitMask);
1717 11256 : CPLFree(pabyCMask);
1718 11256 : delete poMaskBand;
1719 :
1720 11256 : JPGDatasetCommon::CloseDependentDatasets();
1721 11256 : }
1722 :
1723 : /************************************************************************/
1724 : /* CloseDependentDatasets() */
1725 : /************************************************************************/
1726 :
1727 11256 : int JPGDatasetCommon::CloseDependentDatasets()
1728 : {
1729 11256 : int bRet = GDALPamDataset::CloseDependentDatasets();
1730 11256 : if (nInternalOverviewsToFree)
1731 : {
1732 2472 : bRet = TRUE;
1733 9888 : for (int i = 0; i < nInternalOverviewsToFree; i++)
1734 7416 : delete papoInternalOverviews[i];
1735 2472 : nInternalOverviewsToFree = 0;
1736 : }
1737 11256 : CPLFree(papoInternalOverviews);
1738 11256 : papoInternalOverviews = nullptr;
1739 :
1740 11256 : return bRet;
1741 : }
1742 :
1743 : /************************************************************************/
1744 : /* InitEXIFOverview() */
1745 : /************************************************************************/
1746 :
1747 2046 : GDALDataset *JPGDatasetCommon::InitEXIFOverview()
1748 : {
1749 2046 : if (!EXIFInit(m_fpImage))
1750 2039 : return nullptr;
1751 :
1752 : // Read number of entry in directory.
1753 7 : GUInt16 nEntryCount = 0;
1754 21 : if (nTiffDirStart > (INT_MAX - nTIFFHEADER) ||
1755 14 : VSIFSeekL(m_fpImage, nTiffDirStart + nTIFFHEADER, SEEK_SET) != 0 ||
1756 7 : VSIFReadL(&nEntryCount, 1, sizeof(GUInt16), m_fpImage) !=
1757 : sizeof(GUInt16))
1758 : {
1759 0 : CPLError(CE_Failure, CPLE_AppDefined,
1760 : "Error reading EXIF Directory count at " CPL_FRMT_GUIB,
1761 0 : static_cast<vsi_l_offset>(nTiffDirStart) + nTIFFHEADER);
1762 0 : return nullptr;
1763 : }
1764 :
1765 7 : if (bSwabflag)
1766 1 : CPL_SWAP16PTR(&nEntryCount);
1767 :
1768 : // Some files are corrupt, a large entry count is a sign of this.
1769 7 : if (nEntryCount > 125)
1770 : {
1771 0 : CPLError(CE_Warning, CPLE_AppDefined,
1772 : "Ignoring EXIF directory with unlikely entry count (%d).",
1773 : nEntryCount);
1774 0 : return nullptr;
1775 : }
1776 :
1777 : // Skip EXIF entries.
1778 7 : VSIFSeekL(m_fpImage, nEntryCount * sizeof(GDALEXIFTIFFDirEntry), SEEK_CUR);
1779 :
1780 : // Read offset of next directory (IFD1).
1781 7 : GUInt32 nNextDirOff = 0;
1782 7 : if (VSIFReadL(&nNextDirOff, 1, sizeof(GUInt32), m_fpImage) !=
1783 : sizeof(GUInt32))
1784 0 : return nullptr;
1785 7 : if (bSwabflag)
1786 1 : CPL_SWAP32PTR(&nNextDirOff);
1787 7 : if (nNextDirOff == 0 || nNextDirOff > UINT_MAX - nTIFFHEADER)
1788 0 : return nullptr;
1789 :
1790 : // Seek to IFD1.
1791 14 : if (VSIFSeekL(m_fpImage, nTIFFHEADER + nNextDirOff, SEEK_SET) != 0 ||
1792 7 : VSIFReadL(&nEntryCount, 1, sizeof(GUInt16), m_fpImage) !=
1793 : sizeof(GUInt16))
1794 : {
1795 0 : CPLError(CE_Failure, CPLE_AppDefined,
1796 : "Error reading IFD1 Directory count at %d.",
1797 0 : nTIFFHEADER + nNextDirOff);
1798 0 : return nullptr;
1799 : }
1800 :
1801 7 : if (bSwabflag)
1802 1 : CPL_SWAP16PTR(&nEntryCount);
1803 7 : if (nEntryCount > 125)
1804 : {
1805 0 : CPLError(CE_Warning, CPLE_AppDefined,
1806 : "Ignoring IFD1 directory with unlikely entry count (%d).",
1807 : nEntryCount);
1808 0 : return nullptr;
1809 : }
1810 : #if DEBUG_VERBOSE
1811 : CPLDebug("JPEG", "IFD1 entry count = %d", nEntryCount);
1812 : #endif
1813 :
1814 7 : int nImageWidth = 0;
1815 7 : int nImageHeight = 0;
1816 7 : int nCompression = 6;
1817 7 : GUInt32 nJpegIFOffset = 0;
1818 7 : GUInt32 nJpegIFByteCount = 0;
1819 39 : for (int i = 0; i < nEntryCount; i++)
1820 : {
1821 : GDALEXIFTIFFDirEntry sEntry;
1822 32 : if (VSIFReadL(&sEntry, 1, sizeof(sEntry), m_fpImage) != sizeof(sEntry))
1823 : {
1824 0 : CPLError(CE_Warning, CPLE_AppDefined,
1825 : "Cannot read entry %d of IFD1", i);
1826 0 : return nullptr;
1827 : }
1828 32 : if (bSwabflag)
1829 : {
1830 2 : CPL_SWAP16PTR(&sEntry.tdir_tag);
1831 2 : CPL_SWAP16PTR(&sEntry.tdir_type);
1832 2 : CPL_SWAP32PTR(&sEntry.tdir_count);
1833 2 : CPL_SWAP32PTR(&sEntry.tdir_offset);
1834 : }
1835 :
1836 : #ifdef DEBUG_VERBOSE
1837 : CPLDebug("JPEG", "tag = %d (0x%4X), type = %d, count = %d, offset = %d",
1838 : sEntry.tdir_tag, sEntry.tdir_tag, sEntry.tdir_type,
1839 : sEntry.tdir_count, sEntry.tdir_offset);
1840 : #endif
1841 :
1842 32 : if ((sEntry.tdir_type == TIFF_SHORT || sEntry.tdir_type == TIFF_LONG) &&
1843 32 : sEntry.tdir_count == 1)
1844 : {
1845 32 : switch (sEntry.tdir_tag)
1846 : {
1847 6 : case JPEG_TIFF_IMAGEWIDTH:
1848 6 : nImageWidth = sEntry.tdir_offset;
1849 6 : break;
1850 6 : case JPEG_TIFF_IMAGEHEIGHT:
1851 6 : nImageHeight = sEntry.tdir_offset;
1852 6 : break;
1853 6 : case JPEG_TIFF_COMPRESSION:
1854 6 : nCompression = sEntry.tdir_offset;
1855 6 : break;
1856 7 : case JPEG_EXIF_JPEGIFOFSET:
1857 7 : nJpegIFOffset = sEntry.tdir_offset;
1858 7 : break;
1859 7 : case JPEG_EXIF_JPEGIFBYTECOUNT:
1860 7 : nJpegIFByteCount = sEntry.tdir_offset;
1861 7 : break;
1862 0 : default:
1863 0 : break;
1864 : }
1865 : }
1866 : }
1867 7 : if (nCompression != 6 || nImageWidth >= nRasterXSize ||
1868 7 : nImageHeight >= nRasterYSize || nJpegIFOffset == 0 ||
1869 7 : nJpegIFOffset > UINT_MAX - nTIFFHEADER ||
1870 7 : static_cast<int>(nJpegIFByteCount) <= 0)
1871 : {
1872 0 : return nullptr;
1873 : }
1874 :
1875 : const char *pszSubfile =
1876 7 : CPLSPrintf("JPEG_SUBFILE:%u,%d,%s", nTIFFHEADER + nJpegIFOffset,
1877 7 : nJpegIFByteCount, GetDescription());
1878 7 : JPGDatasetOpenArgs sArgs;
1879 7 : sArgs.pszFilename = pszSubfile;
1880 7 : return JPGDataset::Open(&sArgs);
1881 : }
1882 :
1883 : /************************************************************************/
1884 : /* InitInternalOverviews() */
1885 : /************************************************************************/
1886 :
1887 18427 : void JPGDatasetCommon::InitInternalOverviews()
1888 : {
1889 18427 : if (bHasInitInternalOverviews)
1890 15945 : return;
1891 2482 : bHasInitInternalOverviews = true;
1892 :
1893 : // Instantiate on-the-fly overviews (if no external ones).
1894 2482 : if (nScaleFactor == 1 && GetRasterBand(1)->GetOverviewCount() == 0)
1895 : {
1896 : // EXIF overview.
1897 2481 : GDALDataset *poEXIFOverview = nullptr;
1898 2481 : if (nRasterXSize > 512 || nRasterYSize > 512)
1899 : {
1900 2046 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
1901 2046 : poEXIFOverview = InitEXIFOverview();
1902 2046 : if (poEXIFOverview != nullptr)
1903 : {
1904 7 : if (poEXIFOverview->GetRasterCount() != nBands ||
1905 14 : poEXIFOverview->GetRasterXSize() >= nRasterXSize ||
1906 7 : poEXIFOverview->GetRasterYSize() >= nRasterYSize)
1907 : {
1908 0 : GDALClose(poEXIFOverview);
1909 0 : poEXIFOverview = nullptr;
1910 : }
1911 : else
1912 : {
1913 7 : CPLDebug("JPEG", "EXIF overview (%d x %d) detected",
1914 : poEXIFOverview->GetRasterXSize(),
1915 : poEXIFOverview->GetRasterYSize());
1916 : }
1917 : }
1918 2046 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
1919 : }
1920 :
1921 : // libjpeg-6b only supports 2, 4 and 8 scale denominators.
1922 : // TODO: Later versions support more.
1923 :
1924 2481 : int nImplicitOverviews = 0;
1925 :
1926 : // For the needs of the implicit JPEG-in-TIFF overview mechanism.
1927 2481 : if (CPLTestBool(
1928 : CPLGetConfigOption("JPEG_FORCE_INTERNAL_OVERVIEWS", "NO")))
1929 : {
1930 2459 : nImplicitOverviews = 3;
1931 : }
1932 : else
1933 : {
1934 55 : for (int i = 2; i >= 0; i--)
1935 : {
1936 46 : if (nRasterXSize >= (256 << i) || nRasterYSize >= (256 << i))
1937 : {
1938 13 : nImplicitOverviews = i + 1;
1939 13 : break;
1940 : }
1941 : }
1942 : }
1943 :
1944 2481 : if (nImplicitOverviews > 0)
1945 : {
1946 2472 : ppoActiveDS = &poActiveDS;
1947 2472 : papoInternalOverviews = static_cast<GDALDataset **>(
1948 2472 : CPLMalloc((nImplicitOverviews + (poEXIFOverview ? 1 : 0)) *
1949 : sizeof(GDALDataset *)));
1950 9881 : for (int i = 0; i < nImplicitOverviews; i++)
1951 : {
1952 7431 : if (poEXIFOverview != nullptr &&
1953 21 : poEXIFOverview->GetRasterXSize() >= nRasterXSize >> (i + 1))
1954 : {
1955 1 : break;
1956 : }
1957 7409 : JPGDatasetOpenArgs sArgs;
1958 7409 : sArgs.pszFilename = GetDescription();
1959 7409 : sArgs.nScaleFactor = 1 << (i + 1);
1960 7409 : JPGDatasetCommon *poImplicitOverview = JPGDataset::Open(&sArgs);
1961 7409 : if (poImplicitOverview == nullptr)
1962 0 : break;
1963 7409 : poImplicitOverview->ppoActiveDS = &poActiveDS;
1964 7409 : papoInternalOverviews[nInternalOverviewsCurrent] =
1965 : poImplicitOverview;
1966 7409 : nInternalOverviewsCurrent++;
1967 7409 : nInternalOverviewsToFree++;
1968 : }
1969 2472 : if (poEXIFOverview != nullptr)
1970 : {
1971 7 : papoInternalOverviews[nInternalOverviewsCurrent] =
1972 : poEXIFOverview;
1973 7 : nInternalOverviewsCurrent++;
1974 7 : nInternalOverviewsToFree++;
1975 : }
1976 : }
1977 9 : else if (poEXIFOverview)
1978 : {
1979 0 : papoInternalOverviews =
1980 0 : static_cast<GDALDataset **>(CPLMalloc(sizeof(GDALDataset *)));
1981 0 : papoInternalOverviews[0] = poEXIFOverview;
1982 0 : nInternalOverviewsCurrent++;
1983 0 : nInternalOverviewsToFree++;
1984 : }
1985 : }
1986 : }
1987 :
1988 : /************************************************************************/
1989 : /* IBuildOverviews() */
1990 : /************************************************************************/
1991 :
1992 1 : CPLErr JPGDatasetCommon::IBuildOverviews(const char *pszResampling,
1993 : int nOverviewsListCount,
1994 : const int *panOverviewList,
1995 : int nListBands, const int *panBandList,
1996 : GDALProgressFunc pfnProgress,
1997 : void *pProgressData,
1998 : CSLConstList papszOptions)
1999 : {
2000 1 : bHasInitInternalOverviews = true;
2001 1 : nInternalOverviewsCurrent = 0;
2002 :
2003 1 : return GDALPamDataset::IBuildOverviews(
2004 : pszResampling, nOverviewsListCount, panOverviewList, nListBands,
2005 1 : panBandList, pfnProgress, pProgressData, papszOptions);
2006 : }
2007 :
2008 : /************************************************************************/
2009 : /* FlushCache() */
2010 : /************************************************************************/
2011 :
2012 5 : CPLErr JPGDatasetCommon::FlushCache(bool bAtClosing)
2013 :
2014 : {
2015 5 : CPLErr eErr = GDALPamDataset::FlushCache(bAtClosing);
2016 :
2017 5 : if (bHasDoneJpegStartDecompress)
2018 : {
2019 0 : Restart();
2020 : }
2021 :
2022 : // For the needs of the implicit JPEG-in-TIFF overview mechanism.
2023 5 : for (int i = 0; i < nInternalOverviewsCurrent; i++)
2024 : {
2025 0 : if (papoInternalOverviews[i]->FlushCache(bAtClosing) != CE_None)
2026 0 : eErr = CE_Failure;
2027 : }
2028 5 : return eErr;
2029 : }
2030 :
2031 : #endif // !defined(JPGDataset)
2032 :
2033 : /************************************************************************/
2034 : /* JPGDataset() */
2035 : /************************************************************************/
2036 :
2037 11256 : JPGDataset::JPGDataset() : nQLevel(0)
2038 : {
2039 11256 : memset(&sDInfo, 0, sizeof(sDInfo));
2040 11256 : sDInfo.data_precision = 8;
2041 :
2042 11256 : memset(&sJErr, 0, sizeof(sJErr));
2043 11256 : memset(&sJProgress, 0, sizeof(sJProgress));
2044 11256 : }
2045 :
2046 : /************************************************************************/
2047 : /* ~JPGDataset() */
2048 : /************************************************************************/
2049 :
2050 22512 : JPGDataset::~JPGDataset()
2051 :
2052 : {
2053 11256 : GDALPamDataset::FlushCache(true);
2054 11256 : JPGDataset::StopDecompress();
2055 22512 : }
2056 :
2057 : /************************************************************************/
2058 : /* StopDecompress() */
2059 : /************************************************************************/
2060 :
2061 11941 : void JPGDataset::StopDecompress()
2062 : {
2063 11941 : if (bHasDoneJpegStartDecompress)
2064 : {
2065 3575 : jpeg_abort_decompress(&sDInfo);
2066 3575 : bHasDoneJpegStartDecompress = false;
2067 : }
2068 11941 : if (bHasDoneJpegCreateDecompress)
2069 : {
2070 11870 : jpeg_destroy_decompress(&sDInfo);
2071 11870 : bHasDoneJpegCreateDecompress = false;
2072 : }
2073 11941 : nLoadedScanline = INT_MAX;
2074 11941 : if (ppoActiveDS)
2075 10182 : *ppoActiveDS = nullptr;
2076 11941 : }
2077 :
2078 : /************************************************************************/
2079 : /* ErrorOutOnNonFatalError() */
2080 : /************************************************************************/
2081 :
2082 113202 : bool JPGDataset::ErrorOutOnNonFatalError()
2083 : {
2084 113202 : if (sUserData.bNonFatalErrorEncountered)
2085 : {
2086 4 : sUserData.bNonFatalErrorEncountered = false;
2087 4 : return true;
2088 : }
2089 113198 : return false;
2090 : }
2091 :
2092 : /************************************************************************/
2093 : /* StartDecompress() */
2094 : /************************************************************************/
2095 :
2096 3577 : CPLErr JPGDataset::StartDecompress()
2097 : {
2098 : /* In some cases, libjpeg needs to allocate a lot of memory */
2099 : /* http://www.libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf
2100 : */
2101 3577 : if (jpeg_has_multiple_scans(&(sDInfo)))
2102 : {
2103 : /* In this case libjpeg will need to allocate memory or backing */
2104 : /* store for all coefficients */
2105 : /* See call to jinit_d_coef_controller() from master_selection() */
2106 : /* in libjpeg */
2107 :
2108 : // 1 MB for regular libjpeg usage
2109 10 : vsi_l_offset nRequiredMemory = 1024 * 1024;
2110 :
2111 22 : for (int ci = 0; ci < sDInfo.num_components; ci++)
2112 : {
2113 12 : const jpeg_component_info *compptr = &(sDInfo.comp_info[ci]);
2114 12 : if (compptr->h_samp_factor <= 0 || compptr->v_samp_factor <= 0)
2115 : {
2116 0 : CPLError(CE_Failure, CPLE_AppDefined,
2117 : "Invalid sampling factor(s)");
2118 0 : return CE_Failure;
2119 : }
2120 12 : nRequiredMemory +=
2121 12 : static_cast<vsi_l_offset>(DIV_ROUND_UP(
2122 12 : compptr->width_in_blocks, compptr->h_samp_factor)) *
2123 12 : DIV_ROUND_UP(compptr->height_in_blocks,
2124 12 : compptr->v_samp_factor) *
2125 : sizeof(JBLOCK);
2126 : }
2127 :
2128 10 : if (nRequiredMemory > 10 * 1024 * 1024 && ppoActiveDS &&
2129 4 : *ppoActiveDS != this)
2130 : {
2131 : // If another overview was active, stop it to limit memory
2132 : // consumption
2133 4 : if (*ppoActiveDS)
2134 1 : (*ppoActiveDS)->StopDecompress();
2135 4 : *ppoActiveDS = this;
2136 : }
2137 :
2138 30 : if (sDInfo.mem->max_memory_to_use > 0 &&
2139 : nRequiredMemory >
2140 11 : static_cast<vsi_l_offset>(sDInfo.mem->max_memory_to_use) &&
2141 1 : CPLGetConfigOption("GDAL_ALLOW_LARGE_LIBJPEG_MEM_ALLOC", nullptr) ==
2142 : nullptr)
2143 : {
2144 1 : CPLError(CE_Failure, CPLE_NotSupported,
2145 : "Reading this image would require libjpeg to allocate "
2146 : "at least " CPL_FRMT_GUIB " bytes. "
2147 : "This is disabled since above the " CPL_FRMT_GUIB
2148 : " threshold. "
2149 : "You may override this restriction by defining the "
2150 : "GDAL_ALLOW_LARGE_LIBJPEG_MEM_ALLOC environment variable, "
2151 : "or setting the JPEGMEM environment variable to a value "
2152 : "greater "
2153 : "or equal to '" CPL_FRMT_GUIB "M'",
2154 : static_cast<GUIntBig>(nRequiredMemory),
2155 1 : static_cast<GUIntBig>(sDInfo.mem->max_memory_to_use),
2156 1 : static_cast<GUIntBig>((nRequiredMemory + 1000000 - 1) /
2157 : 1000000));
2158 1 : return CE_Failure;
2159 : }
2160 : }
2161 :
2162 3576 : sDInfo.progress = &sJProgress;
2163 3576 : sJProgress.progress_monitor = JPGDataset::ProgressMonitor;
2164 3576 : jpeg_start_decompress(&sDInfo);
2165 3575 : bHasDoneJpegStartDecompress = true;
2166 :
2167 3575 : return CE_None;
2168 : }
2169 :
2170 : /************************************************************************/
2171 : /* LoadScanline() */
2172 : /************************************************************************/
2173 :
2174 215986 : CPLErr JPGDataset::LoadScanline(int iLine, GByte *outBuffer)
2175 :
2176 : {
2177 215986 : if (nLoadedScanline == iLine)
2178 104904 : return CE_None;
2179 :
2180 : // code path triggered when an active reader has been stopped by another
2181 : // one, in case of multiple scans datasets and overviews
2182 111082 : if (!bHasDoneJpegCreateDecompress && Restart() != CE_None)
2183 0 : return CE_Failure;
2184 :
2185 : // setup to trap a fatal error.
2186 111082 : if (setjmp(sUserData.setjmp_buffer))
2187 1 : return CE_Failure;
2188 :
2189 111081 : if (!bHasDoneJpegStartDecompress && StartDecompress() != CE_None)
2190 1 : return CE_Failure;
2191 :
2192 111079 : if (outBuffer == nullptr && m_pabyScanline == nullptr)
2193 : {
2194 3166 : int nJPEGBands = 0;
2195 3166 : switch (sDInfo.out_color_space)
2196 : {
2197 1141 : case JCS_GRAYSCALE:
2198 1141 : nJPEGBands = 1;
2199 1141 : break;
2200 1917 : case JCS_RGB:
2201 : case JCS_YCbCr:
2202 1917 : nJPEGBands = 3;
2203 1917 : break;
2204 108 : case JCS_CMYK:
2205 : case JCS_YCCK:
2206 108 : nJPEGBands = 4;
2207 108 : break;
2208 :
2209 0 : default:
2210 0 : CPLAssert(false);
2211 : }
2212 :
2213 3166 : m_pabyScanline = static_cast<GByte *>(
2214 3166 : CPLMalloc(cpl::fits_on<int>(nJPEGBands * GetRasterXSize() * 2)));
2215 : }
2216 :
2217 111079 : if (iLine < nLoadedScanline)
2218 : {
2219 296 : if (Restart() != CE_None)
2220 0 : return CE_Failure;
2221 : }
2222 :
2223 224274 : while (nLoadedScanline < iLine)
2224 : {
2225 113200 : GDAL_JSAMPLE *ppSamples = reinterpret_cast<GDAL_JSAMPLE *>(
2226 82010 : outBuffer ? outBuffer : m_pabyScanline);
2227 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) && BITS_IN_JSAMPLE == 12
2228 : jpeg12_read_scanlines(&sDInfo, &ppSamples, 1);
2229 : #else
2230 113200 : jpeg_read_scanlines(&sDInfo, &ppSamples, 1);
2231 : #endif
2232 113205 : if (ErrorOutOnNonFatalError())
2233 4 : return CE_Failure;
2234 113195 : nLoadedScanline++;
2235 : }
2236 :
2237 111074 : return CE_None;
2238 : }
2239 :
2240 : /************************************************************************/
2241 : /* LoadDefaultTables() */
2242 : /************************************************************************/
2243 :
2244 : #if !defined(JPGDataset)
2245 :
2246 : #define Q1table GDALJPEG_Q1table
2247 : #define Q2table GDALJPEG_Q2table
2248 : #define Q3table GDALJPEG_Q3table
2249 : #define Q4table GDALJPEG_Q4table
2250 : #define Q5table GDALJPEG_Q5table
2251 : #define AC_BITS GDALJPEG_AC_BITS
2252 : #define AC_HUFFVAL GDALJPEG_AC_HUFFVAL
2253 : #define DC_BITS GDALJPEG_DC_BITS
2254 : #define DC_HUFFVAL GDALJPEG_DC_HUFFVAL
2255 :
2256 : constexpr GByte Q1table[64] = {
2257 : 8, 72, 72, 72, 72, 72, 72, 72, // 0 - 7
2258 : 72, 72, 78, 74, 76, 74, 78, 89, // 8 - 15
2259 : 81, 84, 84, 81, 89, 106, 93, 94, // 16 - 23
2260 : 99, 94, 93, 106, 129, 111, 108, 116, // 24 - 31
2261 : 116, 108, 111, 129, 135, 128, 136, 145, // 32 - 39
2262 : 136, 128, 135, 155, 160, 177, 177, 160, // 40 - 47
2263 : 155, 193, 213, 228, 213, 193, 255, 255, // 48 - 55
2264 : 255, 255, 255, 255, 255, 255, 255, 255 // 56 - 63
2265 : };
2266 :
2267 : constexpr GByte Q2table[64] = {
2268 : 8, 36, 36, 36, 36, 36, 36, 36, 36, 36, 39, 37, 38,
2269 : 37, 39, 45, 41, 42, 42, 41, 45, 53, 47, 47, 50, 47,
2270 : 47, 53, 65, 56, 54, 59, 59, 54, 56, 65, 68, 64, 69,
2271 : 73, 69, 64, 68, 78, 81, 89, 89, 81, 78, 98, 108, 115,
2272 : 108, 98, 130, 144, 144, 130, 178, 190, 178, 243, 243, 255};
2273 :
2274 : constexpr GByte Q3table[64] = {
2275 : 8, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 10, 11, 10, 11, 13,
2276 : 11, 12, 12, 11, 13, 15, 13, 13, 14, 13, 13, 15, 18, 16, 15, 16,
2277 : 16, 15, 16, 18, 19, 18, 19, 21, 19, 18, 19, 22, 23, 25, 25, 23,
2278 : 22, 27, 30, 32, 30, 27, 36, 40, 40, 36, 50, 53, 50, 68, 68, 91};
2279 :
2280 : constexpr GByte Q4table[64] = {
2281 : 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 7, 8, 9,
2282 : 8, 8, 8, 8, 9, 11, 9, 9, 10, 9, 9, 11, 13, 11, 11, 12,
2283 : 12, 11, 11, 13, 14, 13, 14, 15, 14, 13, 14, 16, 16, 18, 18, 16,
2284 : 16, 20, 22, 23, 22, 20, 26, 29, 29, 26, 36, 38, 36, 49, 49, 65};
2285 :
2286 : constexpr GByte Q5table[64] = {
2287 : 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5,
2288 : 5, 5, 5, 5, 5, 6, 5, 5, 6, 5, 5, 6, 7, 6, 6, 6,
2289 : 6, 6, 6, 7, 8, 7, 8, 8, 8, 7, 8, 9, 9, 10, 10, 9,
2290 : 9, 11, 12, 13, 12, 11, 14, 16, 16, 14, 20, 21, 20, 27, 27, 36};
2291 :
2292 : constexpr GByte AC_BITS[16] = {0, 2, 1, 3, 3, 2, 4, 3,
2293 : 5, 5, 4, 4, 0, 0, 1, 125};
2294 :
2295 : constexpr GByte AC_HUFFVAL[256] = {
2296 : 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
2297 : 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
2298 : 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72,
2299 : 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
2300 : 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45,
2301 : 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
2302 : 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75,
2303 : 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
2304 : 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3,
2305 : 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
2306 : 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
2307 : 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
2308 : 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4,
2309 : 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2310 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2311 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2312 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2313 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2314 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2315 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
2316 :
2317 : constexpr GByte DC_BITS[16] = {0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0};
2318 :
2319 : constexpr GByte DC_HUFFVAL[256] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
2320 : 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B};
2321 :
2322 46932 : void JPGDataset::LoadDefaultTables(int n)
2323 : {
2324 46932 : if (nQLevel < 1)
2325 46932 : return;
2326 :
2327 : // Load quantization table.
2328 0 : JQUANT_TBL *quant_ptr = nullptr;
2329 0 : const GByte *pabyQTable = nullptr;
2330 :
2331 0 : if (nQLevel == 1)
2332 0 : pabyQTable = Q1table;
2333 0 : else if (nQLevel == 2)
2334 0 : pabyQTable = Q2table;
2335 0 : else if (nQLevel == 3)
2336 0 : pabyQTable = Q3table;
2337 0 : else if (nQLevel == 4)
2338 0 : pabyQTable = Q4table;
2339 0 : else if (nQLevel == 5)
2340 0 : pabyQTable = Q5table;
2341 : else
2342 0 : return;
2343 :
2344 0 : if (sDInfo.quant_tbl_ptrs[n] == nullptr)
2345 0 : sDInfo.quant_tbl_ptrs[n] =
2346 0 : jpeg_alloc_quant_table(reinterpret_cast<j_common_ptr>(&sDInfo));
2347 :
2348 0 : quant_ptr = sDInfo.quant_tbl_ptrs[n]; // quant_ptr is JQUANT_TBL.
2349 0 : for (int i = 0; i < 64; i++)
2350 : {
2351 : // Qtable[] is desired quantization table, in natural array order.
2352 0 : quant_ptr->quantval[i] = pabyQTable[i];
2353 : }
2354 :
2355 : // Load AC huffman table.
2356 0 : if (sDInfo.ac_huff_tbl_ptrs[n] == nullptr)
2357 0 : sDInfo.ac_huff_tbl_ptrs[n] =
2358 0 : jpeg_alloc_huff_table(reinterpret_cast<j_common_ptr>(&sDInfo));
2359 :
2360 : // huff_ptr is JHUFF_TBL*.
2361 0 : JHUFF_TBL *huff_ptr = sDInfo.ac_huff_tbl_ptrs[n];
2362 :
2363 0 : for (int i = 1; i <= 16; i++)
2364 : {
2365 : // counts[i] is number of Huffman codes of length i bits, i=1..16
2366 0 : huff_ptr->bits[i] = AC_BITS[i - 1];
2367 : }
2368 :
2369 0 : for (int i = 0; i < 256; i++)
2370 : {
2371 : // symbols[] is the list of Huffman symbols, in code-length order.
2372 0 : huff_ptr->huffval[i] = AC_HUFFVAL[i];
2373 : }
2374 :
2375 : // Load DC huffman table.
2376 : // TODO(schwehr): Revisit this "sideways" cast.
2377 0 : if (sDInfo.dc_huff_tbl_ptrs[n] == nullptr)
2378 0 : sDInfo.dc_huff_tbl_ptrs[n] =
2379 0 : jpeg_alloc_huff_table(reinterpret_cast<j_common_ptr>(&sDInfo));
2380 :
2381 0 : huff_ptr = sDInfo.dc_huff_tbl_ptrs[n]; // huff_ptr is JHUFF_TBL*
2382 :
2383 0 : for (int i = 1; i <= 16; i++)
2384 : {
2385 : // counts[i] is number of Huffman codes of length i bits, i=1..16
2386 0 : huff_ptr->bits[i] = DC_BITS[i - 1];
2387 : }
2388 :
2389 0 : for (int i = 0; i < 256; i++)
2390 : {
2391 : // symbols[] is the list of Huffman symbols, in code-length order.
2392 0 : huff_ptr->huffval[i] = DC_HUFFVAL[i];
2393 : }
2394 : }
2395 : #endif // !defined(JPGDataset)
2396 :
2397 : /************************************************************************/
2398 : /* SetScaleNumAndDenom() */
2399 : /************************************************************************/
2400 :
2401 11733 : void JPGDataset::SetScaleNumAndDenom()
2402 : {
2403 : #if JPEG_LIB_VERSION > 62
2404 11596 : sDInfo.scale_num = 8 / nScaleFactor;
2405 11596 : sDInfo.scale_denom = 8;
2406 : #else
2407 137 : sDInfo.scale_num = 1;
2408 137 : sDInfo.scale_denom = nScaleFactor;
2409 : #endif
2410 11733 : }
2411 :
2412 : /************************************************************************/
2413 : /* Restart() */
2414 : /* */
2415 : /* Restart compressor at the beginning of the file. */
2416 : /************************************************************************/
2417 :
2418 681 : CPLErr JPGDataset::Restart()
2419 :
2420 : {
2421 681 : if (ppoActiveDS && *ppoActiveDS != this && *ppoActiveDS != nullptr)
2422 : {
2423 3 : (*ppoActiveDS)->StopDecompress();
2424 : }
2425 :
2426 : // Setup to trap a fatal error.
2427 681 : if (setjmp(sUserData.setjmp_buffer))
2428 0 : return CE_Failure;
2429 :
2430 681 : J_COLOR_SPACE colorSpace = sDInfo.out_color_space;
2431 681 : J_COLOR_SPACE jpegColorSpace = sDInfo.jpeg_color_space;
2432 :
2433 681 : StopDecompress();
2434 681 : jpeg_create_decompress(&sDInfo);
2435 681 : bHasDoneJpegCreateDecompress = true;
2436 :
2437 681 : SetMaxMemoryToUse(&sDInfo);
2438 :
2439 : #if !defined(JPGDataset)
2440 681 : LoadDefaultTables(0);
2441 681 : LoadDefaultTables(1);
2442 681 : LoadDefaultTables(2);
2443 681 : LoadDefaultTables(3);
2444 : #endif // !defined(JPGDataset)
2445 :
2446 : // Restart IO.
2447 681 : VSIFSeekL(m_fpImage, nSubfileOffset, SEEK_SET);
2448 :
2449 681 : jpeg_vsiio_src(&sDInfo, m_fpImage);
2450 681 : jpeg_read_header(&sDInfo, TRUE);
2451 :
2452 681 : sDInfo.out_color_space = colorSpace;
2453 681 : nLoadedScanline = -1;
2454 681 : SetScaleNumAndDenom();
2455 :
2456 : // The following errors could happen when "recycling" an existing dataset
2457 : // particularly when triggered by the implicit overviews of JPEG-in-TIFF
2458 : // with a corrupted TIFF file.
2459 681 : if (nRasterXSize !=
2460 681 : static_cast<int>(sDInfo.image_width + nScaleFactor - 1) /
2461 681 : nScaleFactor ||
2462 681 : nRasterYSize !=
2463 681 : static_cast<int>(sDInfo.image_height + nScaleFactor - 1) /
2464 681 : nScaleFactor)
2465 : {
2466 0 : CPLError(CE_Failure, CPLE_AppDefined,
2467 : "Unexpected image dimension (%d x %d), "
2468 : "where as (%d x %d) was expected",
2469 0 : static_cast<int>(sDInfo.image_width + nScaleFactor - 1) /
2470 0 : nScaleFactor,
2471 0 : static_cast<int>(sDInfo.image_height + nScaleFactor - 1) /
2472 0 : nScaleFactor,
2473 : nRasterXSize, nRasterYSize);
2474 0 : bHasDoneJpegStartDecompress = false;
2475 : }
2476 681 : else if (jpegColorSpace != sDInfo.jpeg_color_space)
2477 : {
2478 0 : CPLError(CE_Failure, CPLE_AppDefined,
2479 0 : "Unexpected jpeg color space : %d", sDInfo.jpeg_color_space);
2480 0 : bHasDoneJpegStartDecompress = false;
2481 : }
2482 : else
2483 : {
2484 681 : if (StartDecompress() != CE_None)
2485 0 : return CE_Failure;
2486 681 : if (ppoActiveDS)
2487 297 : *ppoActiveDS = this;
2488 : }
2489 :
2490 681 : return CE_None;
2491 : }
2492 :
2493 : #if !defined(JPGDataset)
2494 :
2495 : /************************************************************************/
2496 : /* GetGeoTransform() */
2497 : /************************************************************************/
2498 :
2499 145 : CPLErr JPGDatasetCommon::GetGeoTransform(double *padfTransform)
2500 :
2501 : {
2502 145 : CPLErr eErr = GDALPamDataset::GetGeoTransform(padfTransform);
2503 145 : if (eErr != CE_Failure)
2504 0 : return eErr;
2505 :
2506 145 : LoadWorldFileOrTab();
2507 :
2508 145 : if (bGeoTransformValid)
2509 : {
2510 3 : memcpy(padfTransform, adfGeoTransform, sizeof(double) * 6);
2511 :
2512 3 : return CE_None;
2513 : }
2514 :
2515 142 : return eErr;
2516 : }
2517 :
2518 : /************************************************************************/
2519 : /* GetGCPCount() */
2520 : /************************************************************************/
2521 :
2522 172 : int JPGDatasetCommon::GetGCPCount()
2523 :
2524 : {
2525 172 : const int nPAMGCPCount = GDALPamDataset::GetGCPCount();
2526 172 : if (nPAMGCPCount != 0)
2527 6 : return nPAMGCPCount;
2528 :
2529 166 : LoadWorldFileOrTab();
2530 :
2531 166 : return static_cast<int>(m_aoGCPs.size());
2532 : }
2533 :
2534 : /************************************************************************/
2535 : /* GetGCPSpatialRef() */
2536 : /************************************************************************/
2537 :
2538 3 : const OGRSpatialReference *JPGDatasetCommon::GetGCPSpatialRef() const
2539 :
2540 : {
2541 : const int nPAMGCPCount =
2542 3 : const_cast<JPGDatasetCommon *>(this)->GDALPamDataset::GetGCPCount();
2543 3 : if (nPAMGCPCount != 0)
2544 3 : return GDALPamDataset::GetGCPSpatialRef();
2545 :
2546 0 : const_cast<JPGDatasetCommon *>(this)->LoadWorldFileOrTab();
2547 :
2548 0 : if (!m_oSRS.IsEmpty() && !m_aoGCPs.empty())
2549 0 : return &m_oSRS;
2550 :
2551 0 : return nullptr;
2552 : }
2553 :
2554 : /************************************************************************/
2555 : /* GetGCPs() */
2556 : /************************************************************************/
2557 :
2558 3 : const GDAL_GCP *JPGDatasetCommon::GetGCPs()
2559 :
2560 : {
2561 3 : const int nPAMGCPCount = GDALPamDataset::GetGCPCount();
2562 3 : if (nPAMGCPCount != 0)
2563 3 : return GDALPamDataset::GetGCPs();
2564 :
2565 0 : LoadWorldFileOrTab();
2566 :
2567 0 : return gdal::GCP::c_ptr(m_aoGCPs);
2568 : }
2569 :
2570 : /************************************************************************/
2571 : /* GetSpatialRef() */
2572 : /************************************************************************/
2573 :
2574 94 : const OGRSpatialReference *JPGDatasetCommon::GetSpatialRef() const
2575 :
2576 : {
2577 94 : const auto poSRS = GDALPamDataset::GetSpatialRef();
2578 94 : if (poSRS)
2579 0 : return poSRS;
2580 :
2581 94 : auto poThis = const_cast<JPGDatasetCommon *>(this);
2582 94 : if (poThis->GetGCPCount() == 0)
2583 : {
2584 94 : if (!m_oSRS.IsEmpty())
2585 0 : return &m_oSRS;
2586 :
2587 94 : if (!bHasReadXMPMetadata)
2588 52 : poThis->ReadXMPMetadata();
2589 94 : CSLConstList papszXMP = poThis->GetMetadata("xml:XMP");
2590 94 : if (papszXMP && papszXMP[0])
2591 : {
2592 18 : CPLXMLTreeCloser poXML(CPLParseXMLString(papszXMP[0]));
2593 18 : if (poXML)
2594 : {
2595 : const auto psRDF =
2596 18 : CPLGetXMLNode(poXML.get(), "=x:xmpmeta.rdf:RDF");
2597 18 : if (psRDF)
2598 : {
2599 68 : for (const CPLXMLNode *psIter = psRDF->psChild; psIter;
2600 50 : psIter = psIter->psNext)
2601 : {
2602 138 : if (psIter->eType == CXT_Element &&
2603 86 : EQUAL(psIter->pszValue, "rdf:Description") &&
2604 34 : EQUAL(CPLGetXMLValue(psIter, "xmlns:Camera", ""),
2605 : "http://pix4d.com/camera/1.0/"))
2606 : {
2607 2 : if (const char *pszHorizCS = CPLGetXMLValue(
2608 : psIter, "Camera:HorizCS", nullptr))
2609 : {
2610 2 : if (m_oSRS.SetFromUserInput(
2611 : pszHorizCS,
2612 : OGRSpatialReference::
2613 2 : SET_FROM_USER_INPUT_LIMITATIONS_get()) ==
2614 : OGRERR_NONE)
2615 : {
2616 2 : if (const char *pszVertCS = CPLGetXMLValue(
2617 : psIter, "Camera:VertCS", nullptr))
2618 : {
2619 2 : if (EQUAL(pszVertCS, "ellipsoidal"))
2620 1 : m_oSRS.PromoteTo3D(nullptr);
2621 : else
2622 : {
2623 2 : OGRSpatialReference oVertCRS;
2624 1 : if (oVertCRS.SetFromUserInput(
2625 : pszVertCS,
2626 : OGRSpatialReference::
2627 1 : SET_FROM_USER_INPUT_LIMITATIONS_get()) ==
2628 : OGRERR_NONE)
2629 : {
2630 2 : OGRSpatialReference oTmpCRS;
2631 1 : oTmpCRS.SetCompoundCS(
2632 2 : std::string(
2633 : m_oSRS.GetName())
2634 1 : .append(" + ")
2635 : .append(
2636 1 : oVertCRS.GetName())
2637 : .c_str(),
2638 1 : &m_oSRS, &oVertCRS);
2639 1 : m_oSRS = std::move(oTmpCRS);
2640 : }
2641 : }
2642 : }
2643 2 : m_oSRS.SetAxisMappingStrategy(
2644 : OAMS_TRADITIONAL_GIS_ORDER);
2645 2 : return &m_oSRS;
2646 : }
2647 : }
2648 : }
2649 : }
2650 : }
2651 : }
2652 : }
2653 : }
2654 :
2655 92 : return nullptr;
2656 : }
2657 :
2658 : /************************************************************************/
2659 : /* IRasterIO() */
2660 : /* */
2661 : /* Checks for what might be the most common read case */
2662 : /* (reading an entire 8bit, RGB JPEG), and */
2663 : /* optimizes for that case */
2664 : /************************************************************************/
2665 :
2666 803 : CPLErr JPGDatasetCommon::IRasterIO(
2667 : GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
2668 : void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
2669 : int nBandCount, BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
2670 : GSpacing nLineSpace, GSpacing nBandSpace, GDALRasterIOExtraArg *psExtraArg)
2671 :
2672 : {
2673 : // Coverity says that we cannot pass a nullptr to IRasterIO.
2674 803 : if (panBandMap == nullptr)
2675 : {
2676 0 : return CE_Failure;
2677 : }
2678 :
2679 : #ifndef JPEG_LIB_MK1
2680 803 : if ((eRWFlag == GF_Read) && (nBandCount == 3) && (nBands == 3) &&
2681 542 : (nXOff == 0) && (nYOff == 0) && (nXSize == nBufXSize) &&
2682 540 : (nXSize == nRasterXSize) && (nYSize == nBufYSize) &&
2683 531 : (nYSize == nRasterYSize) && (eBufType == GDT_Byte) &&
2684 407 : (GetDataPrecision() != 12) && (pData != nullptr) &&
2685 407 : (panBandMap[0] == 1) && (panBandMap[1] == 2) && (panBandMap[2] == 3) &&
2686 : // These color spaces need to be transformed to RGB.
2687 1606 : GetOutColorSpace() != JCS_YCCK && GetOutColorSpace() != JCS_CMYK)
2688 : {
2689 383 : Restart();
2690 :
2691 : // Pixel interleaved case.
2692 383 : if (nBandSpace == 1)
2693 : {
2694 5925 : for (int y = 0; y < nYSize; ++y)
2695 : {
2696 5815 : if (nPixelSpace == 3)
2697 : {
2698 : CPLErr tmpError =
2699 5555 : LoadScanline(y, &(((GByte *)pData)[(y * nLineSpace)]));
2700 5555 : if (tmpError != CE_None)
2701 1 : return tmpError;
2702 : }
2703 : else
2704 : {
2705 260 : CPLErr tmpError = LoadScanline(y);
2706 260 : if (tmpError != CE_None)
2707 0 : return tmpError;
2708 :
2709 94120 : for (int x = 0; x < nXSize; ++x)
2710 : {
2711 93860 : memcpy(&(((GByte *)pData)[(y * nLineSpace) +
2712 93860 : (x * nPixelSpace)]),
2713 93860 : (const GByte *)&(m_pabyScanline[x * 3]), 3);
2714 : }
2715 : }
2716 : }
2717 110 : nLoadedScanline = nRasterYSize;
2718 : }
2719 : else
2720 : {
2721 10152 : for (int y = 0; y < nYSize; ++y)
2722 : {
2723 9880 : CPLErr tmpError = LoadScanline(y);
2724 9880 : if (tmpError != CE_None)
2725 0 : return tmpError;
2726 1795390 : for (int x = 0; x < nXSize; ++x)
2727 : {
2728 : static_cast<GByte *>(
2729 1785510 : pData)[(y * nLineSpace) + (x * nPixelSpace)] =
2730 1785510 : m_pabyScanline[x * 3];
2731 1785510 : ((GByte *)pData)[(y * nLineSpace) + (x * nPixelSpace) +
2732 1785510 : nBandSpace] = m_pabyScanline[x * 3 + 1];
2733 1785510 : ((GByte *)pData)[(y * nLineSpace) + (x * nPixelSpace) +
2734 1785510 : 2 * nBandSpace] =
2735 1785510 : m_pabyScanline[x * 3 + 2];
2736 : }
2737 : }
2738 : }
2739 :
2740 382 : return CE_None;
2741 : }
2742 : #endif
2743 :
2744 420 : return GDALPamDataset::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
2745 : pData, nBufXSize, nBufYSize, eBufType,
2746 : nBandCount, panBandMap, nPixelSpace,
2747 420 : nLineSpace, nBandSpace, psExtraArg);
2748 : }
2749 :
2750 : /************************************************************************/
2751 : /* Open() */
2752 : /************************************************************************/
2753 :
2754 3459 : GDALDataset *JPGDatasetCommon::Open(GDALOpenInfo *poOpenInfo)
2755 :
2756 : {
2757 : #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2758 : // During fuzzing, do not use Identify to reject crazy content.
2759 3459 : if (!JPEGDriverIdentify(poOpenInfo))
2760 0 : return nullptr;
2761 : #endif
2762 :
2763 3459 : if (poOpenInfo->eAccess == GA_Update)
2764 : {
2765 0 : CPLError(CE_Failure, CPLE_NotSupported,
2766 : "The JPEG driver does not support update access to existing"
2767 : " datasets.");
2768 0 : return nullptr;
2769 : }
2770 :
2771 6918 : CPLString osFilename(poOpenInfo->pszFilename);
2772 3459 : bool bFLIRRawThermalImage = false;
2773 3459 : if (STARTS_WITH(poOpenInfo->pszFilename, "JPEG:"))
2774 : {
2775 5 : CPLStringList aosTokens(CSLTokenizeString2(poOpenInfo->pszFilename, ":",
2776 5 : CSLT_HONOURSTRINGS));
2777 5 : if (aosTokens.size() != 3)
2778 1 : return nullptr;
2779 :
2780 4 : osFilename = aosTokens[1];
2781 4 : if (std::string(aosTokens[2]) != "FLIR_RAW_THERMAL_IMAGE")
2782 1 : return nullptr;
2783 3 : bFLIRRawThermalImage = true;
2784 : }
2785 :
2786 3457 : VSILFILE *fpL = poOpenInfo->fpL;
2787 3457 : poOpenInfo->fpL = nullptr;
2788 :
2789 3457 : JPGDatasetOpenArgs sArgs;
2790 3457 : sArgs.pszFilename = osFilename.c_str();
2791 3457 : sArgs.fpLin = fpL;
2792 3457 : sArgs.papszSiblingFiles = poOpenInfo->GetSiblingFiles();
2793 3457 : sArgs.bDoPAMInitialize = true;
2794 3457 : sArgs.bUseInternalOverviews = CPLFetchBool(poOpenInfo->papszOpenOptions,
2795 : "USE_INTERNAL_OVERVIEWS", true);
2796 : #ifdef D_LOSSLESS_SUPPORTED
2797 : sArgs.bIsLossless = JPEGDatasetIsJPEGLS(poOpenInfo);
2798 : #endif
2799 :
2800 3457 : auto poJPG_DS = JPGDataset::Open(&sArgs);
2801 6914 : auto poDS = std::unique_ptr<GDALDataset>(poJPG_DS);
2802 3456 : if (poDS == nullptr)
2803 : {
2804 1 : return nullptr;
2805 : }
2806 3455 : if (bFLIRRawThermalImage)
2807 : {
2808 3 : poDS.reset(poJPG_DS->OpenFLIRRawThermalImage());
2809 : }
2810 :
2811 6909 : if (poDS &&
2812 6909 : CPLFetchBool(poOpenInfo->papszOpenOptions, "APPLY_ORIENTATION", false))
2813 : {
2814 8 : const char *pszOrientation = poDS->GetMetadataItem("EXIF_Orientation");
2815 8 : if (pszOrientation && !EQUAL(pszOrientation, "1"))
2816 : {
2817 7 : int nOrientation = atoi(pszOrientation);
2818 7 : if (nOrientation >= 2 && nOrientation <= 8)
2819 : {
2820 : auto poOrientedDS = std::make_unique<GDALOrientedDataset>(
2821 7 : std::move(poDS),
2822 14 : static_cast<GDALOrientedDataset::Origin>(nOrientation));
2823 7 : poDS = std::move(poOrientedDS);
2824 : }
2825 : }
2826 : }
2827 :
2828 3455 : return poDS.release();
2829 : }
2830 :
2831 : /************************************************************************/
2832 : /* OpenFLIRRawThermalImage() */
2833 : /************************************************************************/
2834 :
2835 3 : GDALDataset *JPGDatasetCommon::OpenFLIRRawThermalImage()
2836 : {
2837 3 : ReadFLIRMetadata();
2838 3 : if (m_abyRawThermalImage.empty())
2839 : {
2840 1 : CPLError(CE_Failure, CPLE_AppDefined,
2841 : "Cannot find FLIR raw thermal image");
2842 1 : return nullptr;
2843 : }
2844 :
2845 : GByte *pabyData =
2846 2 : static_cast<GByte *>(CPLMalloc(m_abyRawThermalImage.size()));
2847 : const std::string osTmpFilename(
2848 4 : VSIMemGenerateHiddenFilename("jpeg_flir_raw"));
2849 2 : memcpy(pabyData, m_abyRawThermalImage.data(), m_abyRawThermalImage.size());
2850 2 : VSILFILE *fpRaw = VSIFileFromMemBuffer(osTmpFilename.c_str(), pabyData,
2851 2 : m_abyRawThermalImage.size(), true);
2852 :
2853 : // Termal image as uncompressed data
2854 2 : if (m_nRawThermalImageWidth * m_nRawThermalImageHeight * 2 ==
2855 2 : static_cast<int>(m_abyRawThermalImage.size()))
2856 : {
2857 1 : CPLDebug("JPEG", "Raw thermal image");
2858 :
2859 : class JPEGRawDataset : public RawDataset
2860 : {
2861 : public:
2862 1 : JPEGRawDataset(int nXSizeIn, int nYSizeIn)
2863 1 : {
2864 1 : nRasterXSize = nXSizeIn;
2865 1 : nRasterYSize = nYSizeIn;
2866 1 : }
2867 :
2868 1 : CPLErr Close() override
2869 : {
2870 1 : return GDALPamDataset::Close();
2871 : }
2872 :
2873 2 : ~JPEGRawDataset() = default;
2874 :
2875 1 : void SetBand(int nBand, std::unique_ptr<GDALRasterBand> &&poBand)
2876 : {
2877 1 : RawDataset::SetBand(nBand, std::move(poBand));
2878 1 : }
2879 : };
2880 :
2881 : auto poBand = RawRasterBand::Create(
2882 : fpRaw,
2883 : 0, // image offset
2884 : 2, // pixel offset
2885 1 : 2 * m_nRawThermalImageWidth, // line offset
2886 : GDT_UInt16,
2887 1 : m_bRawThermalLittleEndian
2888 : ? RawRasterBand::ByteOrder::ORDER_LITTLE_ENDIAN
2889 : : RawRasterBand::ByteOrder::ORDER_BIG_ENDIAN,
2890 : m_nRawThermalImageWidth, m_nRawThermalImageHeight,
2891 2 : RawRasterBand::OwnFP::YES);
2892 1 : if (!poBand)
2893 0 : return nullptr;
2894 :
2895 : auto poRawDS = new JPEGRawDataset(m_nRawThermalImageWidth,
2896 1 : m_nRawThermalImageHeight);
2897 1 : poRawDS->SetDescription(osTmpFilename.c_str());
2898 1 : poRawDS->SetBand(1, std::move(poBand));
2899 1 : poRawDS->MarkSuppressOnClose();
2900 1 : return poRawDS;
2901 : }
2902 :
2903 1 : VSIFCloseL(fpRaw);
2904 :
2905 : // Termal image as PNG
2906 2 : if (m_abyRawThermalImage.size() > 4 &&
2907 1 : memcmp(m_abyRawThermalImage.data(), "\x89PNG", 4) == 0)
2908 : {
2909 1 : auto poRawDS = GDALDataset::Open(osTmpFilename.c_str());
2910 1 : if (poRawDS == nullptr)
2911 : {
2912 0 : CPLError(CE_Failure, CPLE_AppDefined, "Invalid raw thermal image");
2913 0 : VSIUnlink(osTmpFilename.c_str());
2914 0 : return nullptr;
2915 : }
2916 1 : poRawDS->MarkSuppressOnClose();
2917 1 : return poRawDS;
2918 : }
2919 :
2920 0 : CPLError(CE_Failure, CPLE_AppDefined,
2921 : "Unrecognized format for raw thermal image");
2922 0 : VSIUnlink(osTmpFilename.c_str());
2923 0 : return nullptr;
2924 : }
2925 :
2926 : #endif // !defined(JPGDataset)
2927 :
2928 : /************************************************************************/
2929 : /* Open() */
2930 : /************************************************************************/
2931 :
2932 11191 : JPGDatasetCommon *JPGDataset::Open(JPGDatasetOpenArgs *psArgs)
2933 :
2934 : {
2935 11191 : JPGDataset *poDS = new JPGDataset();
2936 22381 : return OpenStage2(psArgs, poDS);
2937 : }
2938 :
2939 11191 : JPGDatasetCommon *JPGDataset::OpenStage2(JPGDatasetOpenArgs *psArgs,
2940 : JPGDataset *&poDS)
2941 : {
2942 : // Will detect mismatch between compile-time and run-time libjpeg versions.
2943 11191 : if (setjmp(poDS->sUserData.setjmp_buffer))
2944 : {
2945 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(JPGDataset)
2946 :
2947 137 : if (poDS->sDInfo.data_precision == 12 && poDS->m_fpImage != nullptr)
2948 : {
2949 136 : VSILFILE *fpImage = poDS->m_fpImage;
2950 136 : poDS->m_fpImage = nullptr;
2951 136 : delete poDS;
2952 136 : psArgs->fpLin = fpImage;
2953 136 : return JPEGDataset12Open(psArgs);
2954 : }
2955 : #endif
2956 1 : delete poDS;
2957 1 : return nullptr;
2958 : }
2959 :
2960 11191 : const char *pszFilename = psArgs->pszFilename;
2961 11191 : VSILFILE *fpLin = psArgs->fpLin;
2962 11191 : CSLConstList papszSiblingFiles = psArgs->papszSiblingFiles;
2963 11191 : const int nScaleFactor = psArgs->nScaleFactor;
2964 11191 : const bool bDoPAMInitialize = psArgs->bDoPAMInitialize;
2965 11191 : const bool bUseInternalOverviews = psArgs->bUseInternalOverviews;
2966 :
2967 : // If it is a subfile, read the JPEG header.
2968 11191 : bool bIsSubfile = false;
2969 11191 : GUIntBig subfile_offset = 0;
2970 11191 : GUIntBig subfile_size = 0;
2971 11191 : const char *real_filename = pszFilename;
2972 11191 : int nQLevel = -1;
2973 :
2974 11191 : if (STARTS_WITH_CI(pszFilename, "JPEG_SUBFILE:"))
2975 : {
2976 282 : bool bScan = false;
2977 :
2978 282 : if (STARTS_WITH_CI(pszFilename, "JPEG_SUBFILE:Q"))
2979 : {
2980 275 : char **papszTokens = CSLTokenizeString2(pszFilename + 14, ",", 0);
2981 275 : if (CSLCount(papszTokens) >= 3)
2982 : {
2983 275 : nQLevel = atoi(papszTokens[0]);
2984 550 : subfile_offset = CPLScanUIntBig(
2985 275 : papszTokens[1], static_cast<int>(strlen(papszTokens[1])));
2986 550 : subfile_size = CPLScanUIntBig(
2987 275 : papszTokens[2], static_cast<int>(strlen(papszTokens[2])));
2988 275 : bScan = true;
2989 : }
2990 275 : CSLDestroy(papszTokens);
2991 : }
2992 : else
2993 : {
2994 7 : char **papszTokens = CSLTokenizeString2(pszFilename + 13, ",", 0);
2995 7 : if (CSLCount(papszTokens) >= 2)
2996 : {
2997 14 : subfile_offset = CPLScanUIntBig(
2998 7 : papszTokens[0], static_cast<int>(strlen(papszTokens[0])));
2999 14 : subfile_size = CPLScanUIntBig(
3000 7 : papszTokens[1], static_cast<int>(strlen(papszTokens[1])));
3001 7 : bScan = true;
3002 : }
3003 7 : CSLDestroy(papszTokens);
3004 : }
3005 :
3006 282 : if (!bScan)
3007 : {
3008 0 : CPLError(CE_Failure, CPLE_OpenFailed,
3009 : "Corrupt subfile definition: %s", pszFilename);
3010 0 : delete poDS;
3011 0 : return nullptr;
3012 : }
3013 :
3014 282 : real_filename = strstr(pszFilename, ",");
3015 282 : if (real_filename != nullptr)
3016 282 : real_filename = strstr(real_filename + 1, ",");
3017 282 : if (real_filename != nullptr && nQLevel != -1)
3018 275 : real_filename = strstr(real_filename + 1, ",");
3019 282 : if (real_filename != nullptr)
3020 282 : real_filename++;
3021 : else
3022 : {
3023 0 : CPLError(CE_Failure, CPLE_OpenFailed,
3024 : "Could not find filename in subfile definition.");
3025 0 : delete poDS;
3026 0 : return nullptr;
3027 : }
3028 :
3029 282 : CPLDebug("JPG",
3030 : "real_filename %s, offset=" CPL_FRMT_GUIB
3031 : ", size=" CPL_FRMT_GUIB "\n",
3032 : real_filename, subfile_offset, subfile_size);
3033 :
3034 282 : bIsSubfile = true;
3035 : }
3036 :
3037 : // Open the file using the large file api if necessary.
3038 11191 : VSILFILE *fpImage = fpLin;
3039 :
3040 11191 : if (!fpImage)
3041 : {
3042 7751 : fpImage = VSIFOpenL(real_filename, "rb");
3043 :
3044 7751 : if (fpImage == nullptr)
3045 : {
3046 2 : CPLError(CE_Failure, CPLE_OpenFailed,
3047 : "VSIFOpenL(%s) failed unexpectedly in jpgdataset.cpp",
3048 : real_filename);
3049 2 : delete poDS;
3050 2 : return nullptr;
3051 : }
3052 : }
3053 :
3054 : // Create a corresponding GDALDataset.
3055 11189 : poDS->nQLevel = nQLevel;
3056 11189 : poDS->m_fpImage = fpImage;
3057 :
3058 : // Move to the start of jpeg data.
3059 11189 : poDS->nSubfileOffset = subfile_offset;
3060 11189 : VSIFSeekL(poDS->m_fpImage, poDS->nSubfileOffset, SEEK_SET);
3061 :
3062 11189 : poDS->eAccess = GA_ReadOnly;
3063 :
3064 11189 : poDS->sDInfo.err = jpeg_std_error(&poDS->sJErr);
3065 11188 : poDS->sJErr.error_exit = JPGDataset::ErrorExit;
3066 11188 : poDS->sJErr.output_message = JPGDataset::OutputMessage;
3067 11188 : poDS->sUserData.p_previous_emit_message = poDS->sJErr.emit_message;
3068 11188 : poDS->sJErr.emit_message = JPGDataset::EmitMessage;
3069 11188 : poDS->sDInfo.client_data = &poDS->sUserData;
3070 :
3071 11188 : jpeg_create_decompress(&poDS->sDInfo);
3072 11189 : poDS->bHasDoneJpegCreateDecompress = true;
3073 :
3074 11189 : SetMaxMemoryToUse(&poDS->sDInfo);
3075 :
3076 : #if !defined(JPGDataset)
3077 : // Preload default NITF JPEG quantization tables.
3078 11052 : poDS->LoadDefaultTables(0);
3079 11052 : poDS->LoadDefaultTables(1);
3080 11052 : poDS->LoadDefaultTables(2);
3081 11052 : poDS->LoadDefaultTables(3);
3082 : #endif // !defined(JPGDataset)
3083 :
3084 : // Read pre-image data after ensuring the file is rewound.
3085 11189 : VSIFSeekL(poDS->m_fpImage, poDS->nSubfileOffset, SEEK_SET);
3086 :
3087 11189 : jpeg_vsiio_src(&poDS->sDInfo, poDS->m_fpImage);
3088 11189 : jpeg_read_header(&poDS->sDInfo, TRUE);
3089 :
3090 11052 : if (poDS->sDInfo.data_precision != 8 && poDS->sDInfo.data_precision != 12)
3091 : {
3092 0 : CPLError(CE_Failure, CPLE_NotSupported,
3093 : "GDAL JPEG Driver doesn't support files with precision of "
3094 : "other than 8 or 12 bits.");
3095 0 : delete poDS;
3096 0 : return nullptr;
3097 : }
3098 :
3099 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(JPGDataset)
3100 10915 : if (poDS->sDInfo.data_precision == 12 && poDS->m_fpImage != nullptr)
3101 : {
3102 0 : poDS->m_fpImage = nullptr;
3103 0 : delete poDS;
3104 0 : psArgs->fpLin = fpImage;
3105 0 : return JPEGDataset12Open(psArgs);
3106 : }
3107 : #endif
3108 :
3109 : // Capture some information from the file that is of interest.
3110 :
3111 11052 : poDS->nScaleFactor = nScaleFactor;
3112 11052 : poDS->SetScaleNumAndDenom();
3113 11052 : poDS->nRasterXSize =
3114 11052 : (poDS->sDInfo.image_width + nScaleFactor - 1) / nScaleFactor;
3115 11052 : poDS->nRasterYSize =
3116 11052 : (poDS->sDInfo.image_height + nScaleFactor - 1) / nScaleFactor;
3117 :
3118 11052 : poDS->sDInfo.out_color_space = poDS->sDInfo.jpeg_color_space;
3119 11052 : poDS->eGDALColorSpace = poDS->sDInfo.jpeg_color_space;
3120 :
3121 11052 : if (poDS->sDInfo.jpeg_color_space == JCS_GRAYSCALE)
3122 : {
3123 4176 : poDS->nBands = 1;
3124 : }
3125 6876 : else if (poDS->sDInfo.jpeg_color_space == JCS_RGB)
3126 : {
3127 3103 : poDS->nBands = 3;
3128 : }
3129 3773 : else if (poDS->sDInfo.jpeg_color_space == JCS_YCbCr)
3130 : {
3131 3476 : poDS->nBands = 3;
3132 3476 : if (CPLTestBool(CPLGetConfigOption("GDAL_JPEG_TO_RGB", "YES")))
3133 : {
3134 3476 : poDS->sDInfo.out_color_space = JCS_RGB;
3135 3476 : poDS->eGDALColorSpace = JCS_RGB;
3136 3476 : poDS->SetMetadataItem("SOURCE_COLOR_SPACE", "YCbCr",
3137 3476 : "IMAGE_STRUCTURE");
3138 : }
3139 : }
3140 297 : else if (poDS->sDInfo.jpeg_color_space == JCS_CMYK)
3141 : {
3142 594 : if (poDS->sDInfo.data_precision == 8 &&
3143 297 : CPLTestBool(CPLGetConfigOption("GDAL_JPEG_TO_RGB", "YES")))
3144 : {
3145 5 : poDS->eGDALColorSpace = JCS_RGB;
3146 5 : poDS->nBands = 3;
3147 5 : poDS->SetMetadataItem("SOURCE_COLOR_SPACE", "CMYK",
3148 5 : "IMAGE_STRUCTURE");
3149 : }
3150 : else
3151 : {
3152 292 : poDS->nBands = 4;
3153 : }
3154 : }
3155 0 : else if (poDS->sDInfo.jpeg_color_space == JCS_YCCK)
3156 : {
3157 0 : if (poDS->sDInfo.data_precision == 8 &&
3158 0 : CPLTestBool(CPLGetConfigOption("GDAL_JPEG_TO_RGB", "YES")))
3159 : {
3160 0 : poDS->eGDALColorSpace = JCS_RGB;
3161 0 : poDS->nBands = 3;
3162 0 : poDS->SetMetadataItem("SOURCE_COLOR_SPACE", "YCbCrK",
3163 0 : "IMAGE_STRUCTURE");
3164 :
3165 : // libjpeg does the translation from YCrCbK -> CMYK internally
3166 : // and we'll do the translation to RGB in IReadBlock().
3167 0 : poDS->sDInfo.out_color_space = JCS_CMYK;
3168 : }
3169 : else
3170 : {
3171 0 : poDS->nBands = 4;
3172 : }
3173 : }
3174 : else
3175 : {
3176 0 : CPLError(CE_Failure, CPLE_NotSupported,
3177 : "Unrecognized jpeg_color_space value of %d.\n",
3178 0 : poDS->sDInfo.jpeg_color_space);
3179 0 : delete poDS;
3180 0 : return nullptr;
3181 : }
3182 :
3183 : // Create band information objects.
3184 36147 : for (int iBand = 0; iBand < poDS->nBands; iBand++)
3185 25096 : poDS->SetBand(iBand + 1, JPGCreateBand(poDS, iBand + 1));
3186 :
3187 : // More metadata.
3188 11051 : if (poDS->nBands > 1)
3189 : {
3190 6876 : poDS->SetMetadataItem("INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE");
3191 6876 : poDS->SetMetadataItem("COMPRESSION", "JPEG", "IMAGE_STRUCTURE");
3192 : }
3193 :
3194 11051 : if (psArgs->bIsLossless)
3195 : {
3196 0 : poDS->SetMetadataItem("COMPRESSION_REVERSIBILITY", "LOSSLESS",
3197 0 : "IMAGE_STRUCTURE");
3198 : }
3199 :
3200 : // Initialize any PAM information.
3201 11051 : poDS->SetDescription(pszFilename);
3202 :
3203 11051 : if (nScaleFactor == 1 && bDoPAMInitialize)
3204 : {
3205 3636 : if (!bIsSubfile)
3206 3486 : poDS->TryLoadXML(papszSiblingFiles);
3207 : else
3208 150 : poDS->nPamFlags |= GPF_NOSAVE;
3209 :
3210 : // Open (external) overviews.
3211 3636 : poDS->oOvManager.Initialize(poDS, real_filename, papszSiblingFiles);
3212 :
3213 3636 : if (!bUseInternalOverviews)
3214 0 : poDS->bHasInitInternalOverviews = true;
3215 :
3216 : // In the case of a file downloaded through the HTTP driver, this one
3217 : // will unlink the temporary /vsimem file just after GDALOpen(), so
3218 : // later VSIFOpenL() when reading internal overviews would fail.
3219 : // Initialize them now.
3220 3636 : if (STARTS_WITH(real_filename, "/vsimem/") &&
3221 3356 : strstr(real_filename, "_gdal_http_"))
3222 : {
3223 0 : poDS->InitInternalOverviews();
3224 : }
3225 : }
3226 : else
3227 : {
3228 7415 : poDS->nPamFlags |= GPF_NOSAVE;
3229 : }
3230 :
3231 11050 : poDS->bIsSubfile = bIsSubfile;
3232 :
3233 11050 : return poDS;
3234 : }
3235 :
3236 : #if !defined(JPGDataset)
3237 :
3238 : /************************************************************************/
3239 : /* LoadWorldFileOrTab() */
3240 : /************************************************************************/
3241 :
3242 385 : void JPGDatasetCommon::LoadWorldFileOrTab()
3243 : {
3244 385 : if (bIsSubfile)
3245 239 : return;
3246 385 : if (bHasTriedLoadWorldFileOrTab)
3247 239 : return;
3248 146 : bHasTriedLoadWorldFileOrTab = true;
3249 :
3250 146 : char *pszWldFilename = nullptr;
3251 :
3252 : // TIROS3 JPEG files have a .wld extension, so don't look for .wld as
3253 : // as worldfile.
3254 : const bool bEndsWithWld =
3255 292 : strlen(GetDescription()) > 4 &&
3256 146 : EQUAL(GetDescription() + strlen(GetDescription()) - 4, ".wld");
3257 146 : bGeoTransformValid =
3258 146 : GDALReadWorldFile2(GetDescription(), nullptr, adfGeoTransform,
3259 146 : oOvManager.GetSiblingFiles(), &pszWldFilename) ||
3260 146 : GDALReadWorldFile2(GetDescription(), ".jpw", adfGeoTransform,
3261 292 : oOvManager.GetSiblingFiles(), &pszWldFilename) ||
3262 146 : (!bEndsWithWld &&
3263 146 : GDALReadWorldFile2(GetDescription(), ".wld", adfGeoTransform,
3264 146 : oOvManager.GetSiblingFiles(), &pszWldFilename));
3265 :
3266 146 : if (!bGeoTransformValid)
3267 : {
3268 142 : char *pszProjection = nullptr;
3269 142 : int nGCPCount = 0;
3270 142 : GDAL_GCP *pasGCPList = nullptr;
3271 142 : const bool bTabFileOK = CPL_TO_BOOL(GDALReadTabFile2(
3272 142 : GetDescription(), adfGeoTransform, &pszProjection, &nGCPCount,
3273 142 : &pasGCPList, oOvManager.GetSiblingFiles(), &pszWldFilename));
3274 142 : if (pszProjection)
3275 0 : m_oSRS.importFromWkt(pszProjection);
3276 142 : CPLFree(pszProjection);
3277 142 : m_aoGCPs = gdal::GCP::fromC(pasGCPList, nGCPCount);
3278 142 : GDALDeinitGCPs(nGCPCount, pasGCPList);
3279 142 : CPLFree(pasGCPList);
3280 :
3281 142 : if (bTabFileOK && nGCPCount == 0)
3282 0 : bGeoTransformValid = true;
3283 : }
3284 :
3285 146 : if (pszWldFilename)
3286 : {
3287 4 : osWldFilename = pszWldFilename;
3288 4 : CPLFree(pszWldFilename);
3289 : }
3290 : }
3291 :
3292 : /************************************************************************/
3293 : /* GetFileList() */
3294 : /************************************************************************/
3295 :
3296 74 : char **JPGDatasetCommon::GetFileList()
3297 :
3298 : {
3299 74 : char **papszFileList = GDALPamDataset::GetFileList();
3300 :
3301 74 : LoadWorldFileOrTab();
3302 :
3303 76 : if (!osWldFilename.empty() &&
3304 2 : CSLFindString(papszFileList, osWldFilename) == -1)
3305 : {
3306 2 : papszFileList = CSLAddString(papszFileList, osWldFilename);
3307 : }
3308 :
3309 74 : return papszFileList;
3310 : }
3311 :
3312 : /************************************************************************/
3313 : /* CheckForMask() */
3314 : /************************************************************************/
3315 :
3316 62 : void JPGDatasetCommon::CheckForMask()
3317 :
3318 : {
3319 : // Save current position to avoid disturbing JPEG stream decoding.
3320 62 : const vsi_l_offset nCurOffset = VSIFTellL(m_fpImage);
3321 :
3322 : // Go to the end of the file, pull off four bytes, and see if
3323 : // it is plausibly the size of the real image data.
3324 62 : VSIFSeekL(m_fpImage, 0, SEEK_END);
3325 62 : GIntBig nFileSize = VSIFTellL(m_fpImage);
3326 62 : VSIFSeekL(m_fpImage, nFileSize - 4, SEEK_SET);
3327 :
3328 62 : GUInt32 nImageSize = 0;
3329 62 : VSIFReadL(&nImageSize, 4, 1, m_fpImage);
3330 62 : CPL_LSBPTR32(&nImageSize);
3331 :
3332 62 : GByte abyEOD[2] = {0, 0};
3333 :
3334 62 : if (nImageSize >= 2 && nImageSize >= nFileSize / 2 &&
3335 62 : nImageSize <= nFileSize - 4)
3336 : {
3337 : // If that seems okay, seek back, and verify that just preceding
3338 : // the bitmask is an apparent end-of-jpeg-data marker.
3339 15 : VSIFSeekL(m_fpImage, nImageSize - 2, SEEK_SET);
3340 15 : VSIFReadL(abyEOD, 2, 1, m_fpImage);
3341 15 : if (abyEOD[0] == 0xff && abyEOD[1] == 0xd9)
3342 : {
3343 : // We seem to have a mask. Read it in.
3344 15 : nCMaskSize = static_cast<int>(nFileSize - nImageSize - 4);
3345 15 : pabyCMask = static_cast<GByte *>(VSI_MALLOC_VERBOSE(nCMaskSize));
3346 15 : if (pabyCMask)
3347 : {
3348 15 : VSIFReadL(pabyCMask, nCMaskSize, 1, m_fpImage);
3349 :
3350 15 : CPLDebug("JPEG", "Got %d byte compressed bitmask.", nCMaskSize);
3351 : }
3352 : }
3353 : }
3354 :
3355 62 : VSIFSeekL(m_fpImage, nCurOffset, SEEK_SET);
3356 62 : }
3357 :
3358 : /************************************************************************/
3359 : /* DecompressMask() */
3360 : /************************************************************************/
3361 :
3362 4261 : void JPGDatasetCommon::DecompressMask()
3363 :
3364 : {
3365 4261 : if (pabyCMask == nullptr || pabyBitMask != nullptr)
3366 4246 : return;
3367 :
3368 : // Allocate 1bit buffer - may be slightly larger than needed.
3369 15 : const int nBufSize = nRasterYSize * ((nRasterXSize + 7) / 8);
3370 15 : pabyBitMask = static_cast<GByte *>(VSI_MALLOC_VERBOSE(nBufSize));
3371 15 : if (pabyBitMask == nullptr)
3372 : {
3373 0 : CPLFree(pabyCMask);
3374 0 : pabyCMask = nullptr;
3375 0 : return;
3376 : }
3377 :
3378 : // Decompress.
3379 : void *pOut =
3380 15 : CPLZLibInflate(pabyCMask, nCMaskSize, pabyBitMask, nBufSize, nullptr);
3381 :
3382 : // Cleanup if an error occurs.
3383 15 : if (pOut == nullptr)
3384 : {
3385 0 : CPLError(CE_Failure, CPLE_AppDefined,
3386 : "Failure decoding JPEG validity bitmask.");
3387 0 : CPLFree(pabyCMask);
3388 0 : pabyCMask = nullptr;
3389 :
3390 0 : CPLFree(pabyBitMask);
3391 0 : pabyBitMask = nullptr;
3392 :
3393 0 : return;
3394 : }
3395 :
3396 : const char *pszJPEGMaskBitOrder =
3397 15 : CPLGetConfigOption("JPEG_MASK_BIT_ORDER", "AUTO");
3398 15 : if (EQUAL(pszJPEGMaskBitOrder, "LSB"))
3399 0 : bMaskLSBOrder = true;
3400 15 : else if (EQUAL(pszJPEGMaskBitOrder, "MSB"))
3401 0 : bMaskLSBOrder = false;
3402 15 : else if (nRasterXSize > 8 && nRasterYSize > 1)
3403 : {
3404 : // Test MSB ordering hypothesis in a very restrictive case where it is
3405 : // *obviously* ordered as MSB ! (unless someone coded something
3406 : // specifically to defeat the below logic)
3407 : // The case considered here is dop_465_6100.jpg from #5102.
3408 : // The mask is identical for each line, starting with 1's and ending
3409 : // with 0's (or starting with 0's and ending with 1's), and no other
3410 : // intermediate change.
3411 : // We can detect the MSB ordering since the lsb bits at the end of the
3412 : // first line will be set with the 1's of the beginning of the second
3413 : // line.
3414 : // We can only be sure of this heuristics if the change of value occurs
3415 : // in the middle of a byte, or if the raster width is not a multiple of
3416 : // 8.
3417 : //
3418 : // TODO(schwehr): Check logic in this section that was added in r26063.
3419 15 : int nPrevValBit = 0;
3420 15 : int nChangedValBit = 0;
3421 15 : int iX = 0; // Used after for.
3422 2101 : for (; iX < nRasterXSize; iX++)
3423 : {
3424 2098 : const int nValBit =
3425 2098 : (pabyBitMask[iX >> 3] & (0x1 << (7 - (iX & 7)))) != 0;
3426 2098 : if (iX == 0)
3427 15 : nPrevValBit = nValBit;
3428 2083 : else if (nValBit != nPrevValBit)
3429 : {
3430 13 : nPrevValBit = nValBit;
3431 13 : nChangedValBit++;
3432 13 : if (nChangedValBit == 1)
3433 : {
3434 13 : const bool bValChangedOnByteBoundary = (iX % 8) == 0;
3435 13 : if (bValChangedOnByteBoundary && (nRasterXSize % 8) == 0)
3436 11 : break;
3437 : }
3438 : else
3439 : {
3440 0 : break;
3441 : }
3442 : }
3443 2087 : const int iNextLineX = iX + nRasterXSize;
3444 2087 : const int nNextLineValBit = (pabyBitMask[iNextLineX >> 3] &
3445 2087 : (0x1 << (7 - (iNextLineX & 7)))) != 0;
3446 2087 : if (nValBit != nNextLineValBit)
3447 1 : break;
3448 : }
3449 :
3450 15 : if (iX == nRasterXSize && nChangedValBit == 1)
3451 : {
3452 2 : CPLDebug("JPEG",
3453 : "Bit ordering in mask is guessed to be msb (unusual)");
3454 2 : bMaskLSBOrder = false;
3455 : }
3456 : else
3457 : {
3458 13 : bMaskLSBOrder = true;
3459 15 : }
3460 : }
3461 : else
3462 : {
3463 0 : bMaskLSBOrder = true;
3464 : }
3465 : }
3466 :
3467 : /************************************************************************/
3468 : /* GetCompressionFormats() */
3469 : /************************************************************************/
3470 :
3471 1 : CPLStringList JPGDatasetCommon::GetCompressionFormats(int nXOff, int nYOff,
3472 : int nXSize, int nYSize,
3473 : int nBandCount,
3474 : const int *panBandList)
3475 : {
3476 1 : CPLStringList aosRet;
3477 1 : if (m_fpImage && nXOff == 0 && nYOff == 0 && nXSize == nRasterXSize &&
3478 2 : nYSize == nRasterYSize && IsAllBands(nBandCount, panBandList))
3479 : {
3480 1 : aosRet.AddString(GDALGetCompressionFormatForJPEG(m_fpImage).c_str());
3481 : }
3482 1 : return aosRet;
3483 : }
3484 :
3485 : /************************************************************************/
3486 : /* ReadCompressedData() */
3487 : /************************************************************************/
3488 :
3489 20 : CPLErr JPGDatasetCommon::ReadCompressedData(
3490 : const char *pszFormat, int nXOff, int nYOff, int nXSize, int nYSize,
3491 : int nBandCount, const int *panBandList, void **ppBuffer,
3492 : size_t *pnBufferSize, char **ppszDetailedFormat)
3493 : {
3494 20 : if (m_fpImage && nXOff == 0 && nYOff == 0 && nXSize == nRasterXSize &&
3495 40 : nYSize == nRasterYSize && IsAllBands(nBandCount, panBandList))
3496 : {
3497 20 : const CPLStringList aosTokens(CSLTokenizeString2(pszFormat, ";", 0));
3498 20 : if (aosTokens.size() != 1)
3499 0 : return CE_Failure;
3500 :
3501 20 : if (EQUAL(aosTokens[0], "JPEG"))
3502 : {
3503 15 : if (ppszDetailedFormat)
3504 6 : *ppszDetailedFormat = VSIStrdup(
3505 12 : GDALGetCompressionFormatForJPEG(m_fpImage).c_str());
3506 :
3507 15 : const auto nSavedPos = VSIFTellL(m_fpImage);
3508 15 : VSIFSeekL(m_fpImage, 0, SEEK_END);
3509 15 : auto nFileSize = VSIFTellL(m_fpImage);
3510 15 : if (nFileSize > std::numeric_limits<size_t>::max() / 2)
3511 0 : return CE_Failure;
3512 15 : if (nFileSize > 4)
3513 : {
3514 15 : VSIFSeekL(m_fpImage, nFileSize - 4, SEEK_SET);
3515 : // Detect zlib compress mask band at end of file
3516 : // and remove it if found
3517 15 : uint32_t nImageSize = 0;
3518 15 : VSIFReadL(&nImageSize, 4, 1, m_fpImage);
3519 15 : CPL_LSBPTR32(&nImageSize);
3520 15 : if (nImageSize > 2 && nImageSize >= nFileSize / 2 &&
3521 15 : nImageSize < nFileSize - 4)
3522 : {
3523 2 : VSIFSeekL(m_fpImage, nImageSize - 2, SEEK_SET);
3524 : GByte abyTwoBytes[2];
3525 2 : if (VSIFReadL(abyTwoBytes, 2, 1, m_fpImage) == 1 &&
3526 2 : abyTwoBytes[0] == 0xFF && abyTwoBytes[1] == 0xD9)
3527 : {
3528 2 : nFileSize = nImageSize;
3529 : }
3530 : }
3531 : }
3532 15 : auto nSize = static_cast<size_t>(nFileSize);
3533 15 : if (ppBuffer)
3534 : {
3535 14 : if (pnBufferSize == nullptr)
3536 : {
3537 1 : VSIFSeekL(m_fpImage, nSavedPos, SEEK_SET);
3538 2 : return CE_Failure;
3539 : }
3540 13 : bool bFreeOnError = false;
3541 13 : if (*ppBuffer)
3542 : {
3543 3 : if (*pnBufferSize < nSize)
3544 : {
3545 1 : VSIFSeekL(m_fpImage, nSavedPos, SEEK_SET);
3546 1 : return CE_Failure;
3547 : }
3548 : }
3549 : else
3550 : {
3551 10 : *ppBuffer = VSI_MALLOC_VERBOSE(nSize);
3552 10 : if (*ppBuffer == nullptr)
3553 : {
3554 0 : VSIFSeekL(m_fpImage, nSavedPos, SEEK_SET);
3555 0 : return CE_Failure;
3556 : }
3557 10 : bFreeOnError = true;
3558 : }
3559 12 : VSIFSeekL(m_fpImage, 0, SEEK_SET);
3560 12 : if (VSIFReadL(*ppBuffer, nSize, 1, m_fpImage) != 1)
3561 : {
3562 0 : if (bFreeOnError)
3563 : {
3564 0 : VSIFree(*ppBuffer);
3565 0 : *ppBuffer = nullptr;
3566 : }
3567 0 : VSIFSeekL(m_fpImage, nSavedPos, SEEK_SET);
3568 0 : return CE_Failure;
3569 : }
3570 :
3571 12 : constexpr GByte EXIF_SIGNATURE[] = {'E', 'x', 'i',
3572 : 'f', '\0', '\0'};
3573 12 : constexpr char APP1_XMP_SIGNATURE[] =
3574 : "http://ns.adobe.com/xap/1.0/";
3575 12 : size_t nChunkLoc = 2;
3576 12 : GByte *pabyJPEG = static_cast<GByte *>(*ppBuffer);
3577 104 : while (nChunkLoc + 4 <= nSize)
3578 : {
3579 104 : if (pabyJPEG[nChunkLoc + 0] != 0xFF)
3580 0 : break;
3581 104 : if (pabyJPEG[nChunkLoc + 1] == 0xDA)
3582 12 : break;
3583 92 : const int nChunkLength =
3584 92 : pabyJPEG[nChunkLoc + 2] * 256 + pabyJPEG[nChunkLoc + 3];
3585 92 : if (nChunkLength < 2 || static_cast<size_t>(nChunkLength) >
3586 92 : nSize - (nChunkLoc + 2))
3587 : break;
3588 92 : if (pabyJPEG[nChunkLoc + 1] == 0xE1 &&
3589 7 : nChunkLoc + 4 + sizeof(EXIF_SIGNATURE) <= nSize &&
3590 7 : memcmp(pabyJPEG + nChunkLoc + 4, EXIF_SIGNATURE,
3591 : sizeof(EXIF_SIGNATURE)) == 0)
3592 : {
3593 6 : CPLDebug("JPEG", "Remove existing EXIF from "
3594 : "source compressed data");
3595 6 : memmove(pabyJPEG + nChunkLoc,
3596 6 : pabyJPEG + nChunkLoc + 2 + nChunkLength,
3597 6 : nSize - (nChunkLoc + 2 + nChunkLength));
3598 6 : nSize -= 2 + nChunkLength;
3599 6 : continue;
3600 : }
3601 86 : else if (pabyJPEG[nChunkLoc + 1] == 0xE1 &&
3602 1 : nChunkLoc + 4 + sizeof(APP1_XMP_SIGNATURE) <=
3603 2 : nSize &&
3604 1 : memcmp(pabyJPEG + nChunkLoc + 4,
3605 : APP1_XMP_SIGNATURE,
3606 : sizeof(APP1_XMP_SIGNATURE)) == 0)
3607 : {
3608 1 : CPLDebug("JPEG", "Remove existing XMP from "
3609 : "source compressed data");
3610 1 : memmove(pabyJPEG + nChunkLoc,
3611 1 : pabyJPEG + nChunkLoc + 2 + nChunkLength,
3612 1 : nSize - (nChunkLoc + 2 + nChunkLength));
3613 1 : nSize -= 2 + nChunkLength;
3614 1 : continue;
3615 : }
3616 85 : nChunkLoc += 2 + nChunkLength;
3617 : }
3618 : }
3619 13 : VSIFSeekL(m_fpImage, nSavedPos, SEEK_SET);
3620 13 : if (pnBufferSize)
3621 13 : *pnBufferSize = nSize;
3622 13 : return CE_None;
3623 : }
3624 : }
3625 5 : return CE_Failure;
3626 : }
3627 :
3628 : #endif // !defined(JPGDataset)
3629 :
3630 : /************************************************************************/
3631 : /* ErrorExit() */
3632 : /************************************************************************/
3633 :
3634 148 : void JPGDataset::ErrorExit(j_common_ptr cinfo)
3635 : {
3636 148 : GDALJPEGUserData *psUserData =
3637 : static_cast<GDALJPEGUserData *>(cinfo->client_data);
3638 148 : char buffer[JMSG_LENGTH_MAX] = {};
3639 :
3640 : // Create the message.
3641 148 : (*cinfo->err->format_message)(cinfo, buffer);
3642 :
3643 : // Avoid error for a 12bit JPEG if reading from the 8bit JPEG driver and
3644 : // we have JPEG_DUAL_MODE_8_12 support, as we'll try again with 12bit JPEG
3645 : // driver.
3646 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(JPGDataset)
3647 148 : if (strstr(buffer, "Unsupported JPEG data precision 12") == nullptr)
3648 : #endif
3649 12 : CPLError(CE_Failure, CPLE_AppDefined, "libjpeg: %s", buffer);
3650 :
3651 : // Return control to the setjmp point.
3652 148 : longjmp(psUserData->setjmp_buffer, 1);
3653 : }
3654 :
3655 : /************************************************************************/
3656 : /* OutputMessage() */
3657 : /************************************************************************/
3658 :
3659 0 : void JPGDataset::OutputMessage(j_common_ptr cinfo)
3660 : {
3661 0 : char buffer[JMSG_LENGTH_MAX] = {};
3662 :
3663 : // Create the message.
3664 0 : (*cinfo->err->format_message)(cinfo, buffer);
3665 :
3666 0 : CPLDebug("JPEG", "libjpeg: %s", buffer);
3667 0 : }
3668 :
3669 : /************************************************************************/
3670 : /* EmitMessage() */
3671 : /************************************************************************/
3672 :
3673 219923 : void JPGDataset::EmitMessage(j_common_ptr cinfo, int msg_level)
3674 : {
3675 219923 : GDALJPEGUserData *psUserData =
3676 : static_cast<GDALJPEGUserData *>(cinfo->client_data);
3677 219923 : if (msg_level >= 0) // Trace message.
3678 : {
3679 219910 : if (psUserData->p_previous_emit_message != nullptr)
3680 219910 : psUserData->p_previous_emit_message(cinfo, msg_level);
3681 : }
3682 : else
3683 : {
3684 : // Warning : libjpeg will try to recover but the image will be likely
3685 : // corrupted.
3686 :
3687 13 : struct jpeg_error_mgr *err = cinfo->err;
3688 :
3689 : // It's a warning message. Since corrupt files may generate many
3690 : // warnings, the policy implemented here is to show only the first
3691 : // warning, unless trace_level >= 3.
3692 13 : if (err->num_warnings == 0 || err->trace_level >= 3)
3693 : {
3694 9 : char buffer[JMSG_LENGTH_MAX] = {};
3695 :
3696 : // Create the message.
3697 9 : (*cinfo->err->format_message)(cinfo, buffer);
3698 :
3699 : const char *pszVal =
3700 9 : CPLGetConfigOption("GDAL_ERROR_ON_LIBJPEG_WARNING", nullptr);
3701 9 : if (strstr(buffer, "Premature end of JPEG file"))
3702 : {
3703 : // Consider this an error by default
3704 6 : if (pszVal == nullptr || CPLTestBool(pszVal))
3705 : {
3706 5 : psUserData->bNonFatalErrorEncountered = true;
3707 5 : if (pszVal == nullptr)
3708 : {
3709 3 : CPLError(CE_Failure, CPLE_AppDefined,
3710 : "libjpeg: %s (this error can be turned as a "
3711 : "warning "
3712 : "by setting GDAL_ERROR_ON_LIBJPEG_WARNING to "
3713 : "FALSE)",
3714 : buffer);
3715 : }
3716 : else
3717 : {
3718 2 : CPLError(CE_Failure, CPLE_AppDefined, "libjpeg: %s",
3719 : buffer);
3720 : }
3721 : }
3722 : else
3723 : {
3724 1 : CPLError(CE_Warning, CPLE_AppDefined, "libjpeg: %s",
3725 : buffer);
3726 : }
3727 : }
3728 3 : else if (pszVal == nullptr || !CPLTestBool(pszVal))
3729 : {
3730 2 : if (pszVal == nullptr)
3731 : {
3732 1 : CPLError(
3733 : CE_Warning, CPLE_AppDefined,
3734 : "libjpeg: %s (this warning can be turned as an error "
3735 : "by setting GDAL_ERROR_ON_LIBJPEG_WARNING to TRUE)",
3736 : buffer);
3737 : }
3738 : else
3739 : {
3740 1 : CPLError(CE_Warning, CPLE_AppDefined, "libjpeg: %s",
3741 : buffer);
3742 : }
3743 : }
3744 : else
3745 : {
3746 1 : psUserData->bNonFatalErrorEncountered = true;
3747 1 : CPLError(CE_Failure, CPLE_AppDefined, "libjpeg: %s", buffer);
3748 : }
3749 : }
3750 :
3751 : // Always count warnings in num_warnings.
3752 13 : err->num_warnings++;
3753 : }
3754 219923 : }
3755 :
3756 : /************************************************************************/
3757 : /* ProgressMonitor() */
3758 : /************************************************************************/
3759 :
3760 : /* Avoid the risk of denial-of-service on crafted JPEGs with an insane */
3761 : /* number of scans. */
3762 : /* See
3763 : * http://www.libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf
3764 : */
3765 219156 : void JPGDataset::ProgressMonitor(j_common_ptr cinfo)
3766 : {
3767 219156 : if (cinfo->is_decompressor)
3768 : {
3769 219158 : GDALJPEGUserData *psUserData =
3770 : static_cast<GDALJPEGUserData *>(cinfo->client_data);
3771 219158 : const int scan_no =
3772 : reinterpret_cast<j_decompress_ptr>(cinfo)->input_scan_number;
3773 219158 : if (scan_no >= psUserData->nMaxScans)
3774 : {
3775 1 : CPLError(CE_Failure, CPLE_AppDefined,
3776 : "Scan number %d exceeds maximum scans (%d)", scan_no,
3777 : psUserData->nMaxScans);
3778 :
3779 : // Return control to the setjmp point.
3780 1 : longjmp(psUserData->setjmp_buffer, 1);
3781 : }
3782 : }
3783 219155 : }
3784 :
3785 : #if !defined(JPGDataset)
3786 :
3787 : /************************************************************************/
3788 : /* JPGAddICCProfile() */
3789 : /* */
3790 : /* This function adds an ICC profile to a JPEG file. */
3791 : /************************************************************************/
3792 :
3793 3 : void JPGAddICCProfile(void *pInfo, const char *pszICCProfile,
3794 : my_jpeg_write_m_header p_jpeg_write_m_header,
3795 : my_jpeg_write_m_byte p_jpeg_write_m_byte)
3796 : {
3797 3 : if (pszICCProfile == nullptr)
3798 0 : return;
3799 :
3800 : // Write out each segment of the ICC profile.
3801 3 : char *pEmbedBuffer = CPLStrdup(pszICCProfile);
3802 3 : GInt32 nEmbedLen = CPLBase64DecodeInPlace((GByte *)pEmbedBuffer);
3803 3 : char *pEmbedPtr = pEmbedBuffer;
3804 3 : char const *const paHeader = "ICC_PROFILE";
3805 3 : int nSegments = (nEmbedLen + 65518) / 65519;
3806 3 : int nSegmentID = 1;
3807 :
3808 10 : while (nEmbedLen != 0)
3809 : {
3810 : // 65535 - 16 bytes for header = 65519
3811 7 : const int nChunkLen = (nEmbedLen > 65519) ? 65519 : nEmbedLen;
3812 7 : nEmbedLen -= nChunkLen;
3813 :
3814 : // Write marker and length.
3815 7 : p_jpeg_write_m_header(pInfo, JPEG_APP0 + 2,
3816 7 : static_cast<unsigned int>(nChunkLen + 14));
3817 :
3818 : // Write identifier.
3819 91 : for (int i = 0; i < 12; i++)
3820 84 : p_jpeg_write_m_byte(pInfo, paHeader[i]);
3821 :
3822 : // Write ID and max ID.
3823 7 : p_jpeg_write_m_byte(pInfo, nSegmentID);
3824 7 : p_jpeg_write_m_byte(pInfo, nSegments);
3825 :
3826 : // Write ICC Profile.
3827 304295 : for (int i = 0; i < nChunkLen; i++)
3828 304288 : p_jpeg_write_m_byte(pInfo, pEmbedPtr[i]);
3829 :
3830 7 : nSegmentID++;
3831 :
3832 7 : pEmbedPtr += nChunkLen;
3833 : }
3834 :
3835 3 : CPLFree(pEmbedBuffer);
3836 : }
3837 :
3838 : /************************************************************************/
3839 : /* JPGAppendMask() */
3840 : /* */
3841 : /* This function appends a zlib compressed bitmask to a JPEG */
3842 : /* file (or really any file) pulled from an existing mask band. */
3843 : /************************************************************************/
3844 :
3845 : // MSVC does not know that memset() has initialized sStream.
3846 : #ifdef _MSC_VER
3847 : #pragma warning(disable : 4701)
3848 : #endif
3849 :
3850 8 : CPLErr JPGAppendMask(const char *pszJPGFilename, GDALRasterBand *poMask,
3851 : GDALProgressFunc pfnProgress, void *pProgressData)
3852 :
3853 : {
3854 8 : const int nXSize = poMask->GetXSize();
3855 8 : const int nYSize = poMask->GetYSize();
3856 8 : const int nBitBufSize = nYSize * ((nXSize + 7) / 8);
3857 8 : CPLErr eErr = CE_None;
3858 :
3859 : // Allocate uncompressed bit buffer.
3860 : GByte *pabyBitBuf =
3861 8 : static_cast<GByte *>(VSI_CALLOC_VERBOSE(1, nBitBufSize));
3862 :
3863 8 : GByte *pabyMaskLine = static_cast<GByte *>(VSI_MALLOC_VERBOSE(nXSize));
3864 8 : if (pabyBitBuf == nullptr || pabyMaskLine == nullptr)
3865 : {
3866 0 : eErr = CE_Failure;
3867 : }
3868 :
3869 : // No reason to set it to MSB, unless for debugging purposes
3870 : // to be able to generate a unusual LSB ordered mask (#5102).
3871 : const char *pszJPEGMaskBitOrder =
3872 8 : CPLGetConfigOption("JPEG_WRITE_MASK_BIT_ORDER", "LSB");
3873 8 : const bool bMaskLSBOrder = EQUAL(pszJPEGMaskBitOrder, "LSB");
3874 :
3875 : // Set bit buffer from mask band, scanline by scanline.
3876 8 : GUInt32 iBit = 0;
3877 688 : for (int iY = 0; eErr == CE_None && iY < nYSize; iY++)
3878 : {
3879 680 : eErr = poMask->RasterIO(GF_Read, 0, iY, nXSize, 1, pabyMaskLine, nXSize,
3880 : 1, GDT_Byte, 0, 0, nullptr);
3881 680 : if (eErr != CE_None)
3882 0 : break;
3883 :
3884 680 : if (bMaskLSBOrder)
3885 : {
3886 265051 : for (int iX = 0; iX < nXSize; iX++)
3887 : {
3888 264453 : if (pabyMaskLine[iX] != 0)
3889 198418 : pabyBitBuf[iBit >> 3] |= (0x1 << (iBit & 7));
3890 :
3891 264453 : iBit++;
3892 : }
3893 : }
3894 : else
3895 : {
3896 2331 : for (int iX = 0; iX < nXSize; iX++)
3897 : {
3898 2249 : if (pabyMaskLine[iX] != 0)
3899 784 : pabyBitBuf[iBit >> 3] |= (0x1 << (7 - (iBit & 7)));
3900 :
3901 2249 : iBit++;
3902 : }
3903 : }
3904 :
3905 848 : if (pfnProgress != nullptr &&
3906 168 : !pfnProgress((iY + 1) / static_cast<double>(nYSize), nullptr,
3907 : pProgressData))
3908 : {
3909 0 : eErr = CE_Failure;
3910 0 : CPLError(CE_Failure, CPLE_UserInterrupt,
3911 : "User terminated JPGAppendMask()");
3912 : }
3913 : }
3914 :
3915 8 : CPLFree(pabyMaskLine);
3916 :
3917 : // Compress.
3918 8 : GByte *pabyCMask = nullptr;
3919 :
3920 8 : if (eErr == CE_None)
3921 : {
3922 8 : pabyCMask = static_cast<GByte *>(VSI_MALLOC_VERBOSE(nBitBufSize + 30));
3923 8 : if (pabyCMask == nullptr)
3924 : {
3925 0 : eErr = CE_Failure;
3926 : }
3927 : }
3928 :
3929 8 : size_t nTotalOut = 0;
3930 8 : if (eErr == CE_None)
3931 : {
3932 16 : if (CPLZLibDeflate(pabyBitBuf, nBitBufSize, -1, pabyCMask,
3933 8 : nBitBufSize + 30, &nTotalOut) == nullptr)
3934 : {
3935 0 : CPLError(CE_Failure, CPLE_AppDefined,
3936 : "Deflate compression of jpeg bit mask failed.");
3937 0 : eErr = CE_Failure;
3938 : }
3939 : }
3940 :
3941 : // Write to disk, along with image file size.
3942 8 : if (eErr == CE_None)
3943 : {
3944 8 : VSILFILE *fpOut = VSIFOpenL(pszJPGFilename, "r+");
3945 8 : if (fpOut == nullptr)
3946 : {
3947 0 : CPLError(CE_Failure, CPLE_AppDefined,
3948 : "Failed to open jpeg to append bitmask.");
3949 0 : eErr = CE_Failure;
3950 : }
3951 : else
3952 : {
3953 8 : VSIFSeekL(fpOut, 0, SEEK_END);
3954 :
3955 8 : GUInt32 nImageSize = static_cast<GUInt32>(VSIFTellL(fpOut));
3956 8 : CPL_LSBPTR32(&nImageSize);
3957 :
3958 8 : if (VSIFWriteL(pabyCMask, 1, nTotalOut, fpOut) != nTotalOut)
3959 : {
3960 0 : CPLError(CE_Failure, CPLE_FileIO,
3961 : "Failure writing compressed bitmask.\n%s",
3962 0 : VSIStrerror(errno));
3963 0 : eErr = CE_Failure;
3964 : }
3965 : else
3966 : {
3967 8 : VSIFWriteL(&nImageSize, 4, 1, fpOut);
3968 : }
3969 :
3970 8 : VSIFCloseL(fpOut);
3971 : }
3972 : }
3973 :
3974 8 : CPLFree(pabyBitBuf);
3975 8 : CPLFree(pabyCMask);
3976 :
3977 8 : return eErr;
3978 : }
3979 :
3980 : /************************************************************************/
3981 : /* JPGAddEXIF() */
3982 : /************************************************************************/
3983 :
3984 247 : void JPGAddEXIF(GDALDataType eWorkDT, GDALDataset *poSrcDS, char **papszOptions,
3985 : void *cinfo, my_jpeg_write_m_header p_jpeg_write_m_header,
3986 : my_jpeg_write_m_byte p_jpeg_write_m_byte,
3987 : GDALDataset *(pCreateCopy)(const char *, GDALDataset *, int,
3988 : char **,
3989 : GDALProgressFunc pfnProgress,
3990 : void *pProgressData))
3991 : {
3992 247 : const int nBands = poSrcDS->GetRasterCount();
3993 247 : const int nXSize = poSrcDS->GetRasterXSize();
3994 247 : const int nYSize = poSrcDS->GetRasterYSize();
3995 :
3996 : bool bGenerateEXIFThumbnail =
3997 247 : CPLTestBool(CSLFetchNameValueDef(papszOptions, "EXIF_THUMBNAIL", "NO"));
3998 : const char *pszThumbnailWidth =
3999 247 : CSLFetchNameValue(papszOptions, "THUMBNAIL_WIDTH");
4000 : const char *pszThumbnailHeight =
4001 247 : CSLFetchNameValue(papszOptions, "THUMBNAIL_HEIGHT");
4002 247 : int nOvrWidth = 0;
4003 247 : int nOvrHeight = 0;
4004 247 : if (pszThumbnailWidth == nullptr && pszThumbnailHeight == nullptr)
4005 : {
4006 243 : if (nXSize >= nYSize)
4007 : {
4008 236 : nOvrWidth = 128;
4009 : }
4010 : else
4011 : {
4012 7 : nOvrHeight = 128;
4013 : }
4014 : }
4015 247 : if (pszThumbnailWidth != nullptr)
4016 : {
4017 3 : nOvrWidth = atoi(pszThumbnailWidth);
4018 3 : if (nOvrWidth < 32)
4019 0 : nOvrWidth = 32;
4020 3 : if (nOvrWidth > 1024)
4021 0 : nOvrWidth = 1024;
4022 : }
4023 247 : if (pszThumbnailHeight != nullptr)
4024 : {
4025 3 : nOvrHeight = atoi(pszThumbnailHeight);
4026 3 : if (nOvrHeight < 32)
4027 0 : nOvrHeight = 32;
4028 3 : if (nOvrHeight > 1024)
4029 0 : nOvrHeight = 1024;
4030 : }
4031 247 : if (nOvrWidth == 0)
4032 : {
4033 8 : nOvrWidth = static_cast<int>(static_cast<GIntBig>(nOvrHeight) * nXSize /
4034 8 : nYSize);
4035 8 : if (nOvrWidth == 0)
4036 0 : nOvrWidth = 1;
4037 : }
4038 239 : else if (nOvrHeight == 0)
4039 : {
4040 237 : nOvrHeight =
4041 237 : static_cast<int>(static_cast<GIntBig>(nOvrWidth) * nYSize / nXSize);
4042 237 : if (nOvrHeight == 0)
4043 0 : nOvrHeight = 1;
4044 : }
4045 :
4046 247 : vsi_l_offset nJPEGIfByteCount = 0;
4047 247 : GByte *pabyOvr = nullptr;
4048 :
4049 247 : if (bGenerateEXIFThumbnail && nXSize > nOvrWidth && nYSize > nOvrHeight)
4050 : {
4051 6 : GDALDataset *poMemDS = MEMDataset::Create("", nOvrWidth, nOvrHeight,
4052 : nBands, eWorkDT, nullptr);
4053 : GDALRasterBand **papoSrcBands = static_cast<GDALRasterBand **>(
4054 6 : CPLMalloc(nBands * sizeof(GDALRasterBand *)));
4055 : GDALRasterBand ***papapoOverviewBands = static_cast<GDALRasterBand ***>(
4056 6 : CPLMalloc(nBands * sizeof(GDALRasterBand **)));
4057 14 : for (int i = 0; i < nBands; i++)
4058 : {
4059 8 : papoSrcBands[i] = poSrcDS->GetRasterBand(i + 1);
4060 16 : papapoOverviewBands[i] = static_cast<GDALRasterBand **>(
4061 8 : CPLMalloc(sizeof(GDALRasterBand *)));
4062 8 : papapoOverviewBands[i][0] = poMemDS->GetRasterBand(i + 1);
4063 : }
4064 6 : CPLErr eErr = GDALRegenerateOverviewsMultiBand(
4065 : nBands, papoSrcBands, 1, papapoOverviewBands, "AVERAGE", nullptr,
4066 : nullptr,
4067 : /* papszOptions = */ nullptr);
4068 6 : CPLFree(papoSrcBands);
4069 14 : for (int i = 0; i < nBands; i++)
4070 : {
4071 8 : CPLFree(papapoOverviewBands[i]);
4072 : }
4073 6 : CPLFree(papapoOverviewBands);
4074 :
4075 6 : if (eErr != CE_None)
4076 : {
4077 0 : GDALClose(poMemDS);
4078 0 : return;
4079 : }
4080 :
4081 12 : const CPLString osTmpFile(VSIMemGenerateHiddenFilename("ovrjpg"));
4082 6 : GDALDataset *poOutDS = pCreateCopy(osTmpFile, poMemDS, 0, nullptr,
4083 : GDALDummyProgress, nullptr);
4084 6 : const bool bExifOverviewSuccess = poOutDS != nullptr;
4085 6 : delete poOutDS;
4086 6 : poOutDS = nullptr;
4087 6 : GDALClose(poMemDS);
4088 6 : if (bExifOverviewSuccess)
4089 6 : pabyOvr = VSIGetMemFileBuffer(osTmpFile, &nJPEGIfByteCount, TRUE);
4090 6 : VSIUnlink(osTmpFile);
4091 :
4092 : // cppcheck-suppress knownConditionTrueFalse
4093 6 : if (pabyOvr == nullptr)
4094 : {
4095 0 : nJPEGIfByteCount = 0;
4096 0 : CPLError(CE_Warning, CPLE_AppDefined,
4097 : "Could not generate EXIF overview");
4098 : }
4099 : }
4100 :
4101 : GUInt32 nMarkerSize;
4102 : const bool bWriteExifMetadata =
4103 247 : CPLFetchBool(papszOptions, "WRITE_EXIF_METADATA", true);
4104 :
4105 : GByte *pabyEXIF =
4106 247 : EXIFCreate(bWriteExifMetadata ? poSrcDS->GetMetadata() : nullptr,
4107 : pabyOvr, static_cast<GUInt32>(nJPEGIfByteCount), nOvrWidth,
4108 : nOvrHeight, &nMarkerSize);
4109 247 : if (pabyEXIF)
4110 : {
4111 22 : p_jpeg_write_m_header(cinfo, JPEG_APP0 + 1, nMarkerSize);
4112 4783 : for (GUInt32 i = 0; i < nMarkerSize; i++)
4113 : {
4114 4761 : p_jpeg_write_m_byte(cinfo, pabyEXIF[i]);
4115 : }
4116 22 : VSIFree(pabyEXIF);
4117 : }
4118 247 : CPLFree(pabyOvr);
4119 : }
4120 :
4121 : #endif // !defined(JPGDataset)
4122 :
4123 : /************************************************************************/
4124 : /* CreateCopy() */
4125 : /************************************************************************/
4126 :
4127 273 : GDALDataset *JPGDataset::CreateCopy(const char *pszFilename,
4128 : GDALDataset *poSrcDS, int bStrict,
4129 : char **papszOptions,
4130 : GDALProgressFunc pfnProgress,
4131 : void *pProgressData)
4132 :
4133 : {
4134 273 : const int nBands = poSrcDS->GetRasterCount();
4135 :
4136 : const char *pszLossLessCopy =
4137 273 : CSLFetchNameValueDef(papszOptions, "LOSSLESS_COPY", "AUTO");
4138 273 : if (EQUAL(pszLossLessCopy, "AUTO") || CPLTestBool(pszLossLessCopy))
4139 : {
4140 273 : void *pJPEGContent = nullptr;
4141 273 : size_t nJPEGContent = 0;
4142 273 : if (poSrcDS->ReadCompressedData("JPEG", 0, 0, poSrcDS->GetRasterXSize(),
4143 : poSrcDS->GetRasterYSize(), nBands,
4144 : nullptr, &pJPEGContent, &nJPEGContent,
4145 555 : nullptr) == CE_None &&
4146 282 : GDALGetCompressionFormatForJPEG(pJPEGContent, nJPEGContent)
4147 9 : .find(";colorspace=RGBA") == std::string::npos)
4148 : {
4149 9 : if (!pfnProgress(0.0, nullptr, pProgressData))
4150 9 : return nullptr;
4151 :
4152 9 : CPLDebug("JPEG", "Lossless copy from source dataset");
4153 9 : std::vector<GByte> abyJPEG;
4154 : try
4155 : {
4156 9 : abyJPEG.assign(static_cast<const GByte *>(pJPEGContent),
4157 9 : static_cast<const GByte *>(pJPEGContent) +
4158 9 : nJPEGContent);
4159 :
4160 : const bool bWriteExifMetadata =
4161 9 : CPLFetchBool(papszOptions, "WRITE_EXIF_METADATA", true);
4162 9 : if (bWriteExifMetadata)
4163 : {
4164 9 : char **papszEXIF_MD = poSrcDS->GetMetadata("EXIF");
4165 9 : if (papszEXIF_MD == nullptr)
4166 : {
4167 9 : papszEXIF_MD = poSrcDS->GetMetadata();
4168 : }
4169 9 : GUInt32 nEXIFContentSize = 0;
4170 9 : GByte *pabyEXIF = EXIFCreate(papszEXIF_MD, nullptr, 0, 0, 0,
4171 : &nEXIFContentSize);
4172 9 : if (nEXIFContentSize > 0 && nEXIFContentSize + 2 <= 65535U)
4173 : {
4174 1 : size_t nChunkLoc = 2;
4175 1 : size_t nInsertPos = 0;
4176 1 : constexpr GByte JFIF_SIGNATURE[] = {'J', 'F', 'I', 'F',
4177 : '\0'};
4178 1 : constexpr GByte EXIF_SIGNATURE[] = {'E', 'x', 'i',
4179 : 'f', '\0', '\0'};
4180 9 : while (nChunkLoc + 4 <= abyJPEG.size())
4181 : {
4182 9 : if (abyJPEG[nChunkLoc + 0] != 0xFF)
4183 0 : break;
4184 9 : if (abyJPEG[nChunkLoc + 1] == 0xDA)
4185 : {
4186 1 : if (nInsertPos == 0)
4187 0 : nInsertPos = nChunkLoc;
4188 1 : break;
4189 : }
4190 : const int nChunkLength =
4191 8 : abyJPEG[nChunkLoc + 2] * 256 +
4192 8 : abyJPEG[nChunkLoc + 3];
4193 8 : if (nChunkLength < 2)
4194 0 : break;
4195 9 : if (abyJPEG[nChunkLoc + 1] == 0xE0 &&
4196 1 : nChunkLoc + 4 + sizeof(JFIF_SIGNATURE) <=
4197 9 : abyJPEG.size() &&
4198 1 : memcmp(abyJPEG.data() + nChunkLoc + 4,
4199 : JFIF_SIGNATURE,
4200 : sizeof(JFIF_SIGNATURE)) == 0)
4201 : {
4202 1 : if (nInsertPos == 0)
4203 1 : nInsertPos = nChunkLoc + 2 + nChunkLength;
4204 : }
4205 7 : else if (abyJPEG[nChunkLoc + 1] == 0xE1 &&
4206 0 : nChunkLoc + 4 + sizeof(EXIF_SIGNATURE) <=
4207 7 : abyJPEG.size() &&
4208 0 : memcmp(abyJPEG.data() + nChunkLoc + 4,
4209 : EXIF_SIGNATURE,
4210 : sizeof(EXIF_SIGNATURE)) == 0)
4211 : {
4212 0 : CPLDebug("JPEG",
4213 : "Remove existing EXIF from source "
4214 : "compressed data");
4215 0 : abyJPEG.erase(abyJPEG.begin() + nChunkLoc,
4216 0 : abyJPEG.begin() + nChunkLoc + 2 +
4217 0 : nChunkLength);
4218 0 : continue;
4219 : }
4220 8 : nChunkLoc += 2 + nChunkLength;
4221 : }
4222 1 : if (nInsertPos > 0)
4223 : {
4224 2 : std::vector<GByte> abyNew;
4225 1 : const size_t nMarkerSize = 2 + nEXIFContentSize;
4226 1 : abyNew.reserve(abyJPEG.size() + 2 + nMarkerSize);
4227 1 : abyNew.insert(abyNew.end(), abyJPEG.data(),
4228 2 : abyJPEG.data() + nInsertPos);
4229 0 : abyNew.insert(abyNew.end(),
4230 1 : static_cast<GByte>(0xFF));
4231 0 : abyNew.insert(abyNew.end(),
4232 1 : static_cast<GByte>(0xE1));
4233 0 : abyNew.insert(abyNew.end(),
4234 1 : static_cast<GByte>(nMarkerSize >> 8));
4235 : abyNew.insert(
4236 0 : abyNew.end(),
4237 1 : static_cast<GByte>(nMarkerSize & 0xFF));
4238 0 : abyNew.insert(abyNew.end(), pabyEXIF,
4239 1 : pabyEXIF + nEXIFContentSize);
4240 0 : abyNew.insert(abyNew.end(),
4241 1 : abyJPEG.data() + nInsertPos,
4242 1 : abyJPEG.data() + abyJPEG.size());
4243 1 : abyJPEG = std::move(abyNew);
4244 : }
4245 : }
4246 9 : VSIFree(pabyEXIF);
4247 : }
4248 :
4249 : const bool bWriteXMP =
4250 9 : CPLFetchBool(papszOptions, "WRITE_XMP", true);
4251 : char **papszXMP =
4252 9 : bWriteXMP ? poSrcDS->GetMetadata("xml:XMP") : nullptr;
4253 9 : if (papszXMP && papszXMP[0])
4254 : {
4255 1 : size_t nChunkLoc = 2;
4256 1 : size_t nInsertPos = 0;
4257 1 : constexpr GByte JFIF_SIGNATURE[] = {'J', 'F', 'I', 'F',
4258 : '\0'};
4259 1 : constexpr const char APP1_XMP_SIGNATURE[] =
4260 : "http://ns.adobe.com/xap/1.0/";
4261 6 : while (nChunkLoc + 4 <= abyJPEG.size())
4262 : {
4263 6 : if (abyJPEG[nChunkLoc + 0] != 0xFF)
4264 0 : break;
4265 6 : if (abyJPEG[nChunkLoc + 1] == 0xDA)
4266 : {
4267 1 : if (nInsertPos == 0)
4268 0 : nInsertPos = nChunkLoc;
4269 1 : break;
4270 : }
4271 5 : const int nChunkLength = abyJPEG[nChunkLoc + 2] * 256 +
4272 5 : abyJPEG[nChunkLoc + 3];
4273 5 : if (nChunkLength < 2)
4274 0 : break;
4275 6 : if (abyJPEG[nChunkLoc + 1] == 0xE0 &&
4276 1 : nChunkLoc + 4 + sizeof(JFIF_SIGNATURE) <=
4277 6 : abyJPEG.size() &&
4278 1 : memcmp(abyJPEG.data() + nChunkLoc + 4,
4279 : JFIF_SIGNATURE, sizeof(JFIF_SIGNATURE)) == 0)
4280 : {
4281 1 : if (nInsertPos == 0)
4282 1 : nInsertPos = nChunkLoc + 2 + nChunkLength;
4283 : }
4284 4 : else if (abyJPEG[nChunkLoc + 1] == 0xE1 &&
4285 0 : nChunkLoc + 4 + sizeof(APP1_XMP_SIGNATURE) <=
4286 4 : abyJPEG.size() &&
4287 0 : memcmp(abyJPEG.data() + nChunkLoc + 4,
4288 : APP1_XMP_SIGNATURE,
4289 : sizeof(APP1_XMP_SIGNATURE)) == 0)
4290 : {
4291 0 : CPLDebug("JPEG", "Remove existing XMP from source "
4292 : "compressed data");
4293 0 : abyJPEG.erase(abyJPEG.begin() + nChunkLoc,
4294 0 : abyJPEG.begin() + nChunkLoc + 2 +
4295 0 : nChunkLength);
4296 0 : continue;
4297 : }
4298 5 : nChunkLoc += 2 + nChunkLength;
4299 : }
4300 1 : const size_t nMarkerSize =
4301 1 : 2 + sizeof(APP1_XMP_SIGNATURE) + strlen(papszXMP[0]);
4302 1 : if (nInsertPos > 0 && nMarkerSize <= 65535U)
4303 : {
4304 2 : std::vector<GByte> abyNew;
4305 1 : abyNew.reserve(abyJPEG.size() + 2 + nMarkerSize);
4306 1 : abyNew.insert(abyNew.end(), abyJPEG.data(),
4307 2 : abyJPEG.data() + nInsertPos);
4308 1 : abyNew.insert(abyNew.end(), static_cast<GByte>(0xFF));
4309 1 : abyNew.insert(abyNew.end(), static_cast<GByte>(0xE1));
4310 0 : abyNew.insert(abyNew.end(),
4311 1 : static_cast<GByte>(nMarkerSize >> 8));
4312 0 : abyNew.insert(abyNew.end(),
4313 1 : static_cast<GByte>(nMarkerSize & 0xFF));
4314 0 : abyNew.insert(abyNew.end(), APP1_XMP_SIGNATURE,
4315 : APP1_XMP_SIGNATURE +
4316 1 : sizeof(APP1_XMP_SIGNATURE));
4317 0 : abyNew.insert(abyNew.end(), papszXMP[0],
4318 1 : papszXMP[0] + strlen(papszXMP[0]));
4319 0 : abyNew.insert(abyNew.end(), abyJPEG.data() + nInsertPos,
4320 1 : abyJPEG.data() + abyJPEG.size());
4321 1 : abyJPEG = std::move(abyNew);
4322 : }
4323 : }
4324 : }
4325 0 : catch (const std::exception &)
4326 : {
4327 0 : abyJPEG.clear();
4328 : }
4329 9 : VSIFree(pJPEGContent);
4330 :
4331 9 : if (!abyJPEG.empty())
4332 : {
4333 9 : VSILFILE *fpImage = VSIFOpenL(pszFilename, "wb");
4334 9 : if (fpImage == nullptr)
4335 : {
4336 0 : CPLError(CE_Failure, CPLE_OpenFailed,
4337 : "Unable to create jpeg file %s.", pszFilename);
4338 :
4339 0 : return nullptr;
4340 : }
4341 18 : if (VSIFWriteL(abyJPEG.data(), 1, abyJPEG.size(), fpImage) !=
4342 9 : abyJPEG.size())
4343 : {
4344 0 : CPLError(CE_Failure, CPLE_FileIO,
4345 0 : "Failure writing data: %s", VSIStrerror(errno));
4346 0 : VSIFCloseL(fpImage);
4347 0 : return nullptr;
4348 : }
4349 9 : if (VSIFCloseL(fpImage) != 0)
4350 : {
4351 0 : CPLError(CE_Failure, CPLE_FileIO,
4352 0 : "Failure writing data: %s", VSIStrerror(errno));
4353 0 : return nullptr;
4354 : }
4355 :
4356 9 : pfnProgress(1.0, nullptr, pProgressData);
4357 :
4358 : // Append masks to the jpeg file if necessary.
4359 9 : const auto poLastSrcBand = poSrcDS->GetRasterBand(nBands);
4360 : const bool bAppendMask =
4361 9 : poLastSrcBand != nullptr &&
4362 10 : poLastSrcBand->GetColorInterpretation() == GCI_AlphaBand &&
4363 1 : CPLFetchBool(papszOptions, "INTERNAL_MASK", true);
4364 :
4365 9 : if (bAppendMask)
4366 : {
4367 1 : CPLDebug("JPEG", "Appending Mask Bitmap");
4368 :
4369 1 : CPLErr eErr = JPGAppendMask(pszFilename, poLastSrcBand,
4370 : nullptr, nullptr);
4371 :
4372 1 : if (eErr != CE_None)
4373 : {
4374 0 : VSIUnlink(pszFilename);
4375 0 : return nullptr;
4376 : }
4377 : }
4378 :
4379 : // Do we need a world file?
4380 9 : if (CPLFetchBool(papszOptions, "WORLDFILE", false))
4381 : {
4382 0 : double adfGeoTransform[6] = {};
4383 :
4384 0 : poSrcDS->GetGeoTransform(adfGeoTransform);
4385 0 : GDALWriteWorldFile(pszFilename, "wld", adfGeoTransform);
4386 : }
4387 :
4388 : // Re-open dataset, and copy any auxiliary pam information.
4389 :
4390 : // If writing to stdout, we can't reopen it, so return
4391 : // a fake dataset to make the caller happy.
4392 9 : if (CPLTestBool(
4393 : CPLGetConfigOption("GDAL_OPEN_AFTER_COPY", "YES")))
4394 : {
4395 9 : CPLPushErrorHandler(CPLQuietErrorHandler);
4396 :
4397 9 : JPGDatasetOpenArgs sArgs;
4398 9 : sArgs.pszFilename = pszFilename;
4399 9 : sArgs.bDoPAMInitialize = true;
4400 9 : sArgs.bUseInternalOverviews = true;
4401 :
4402 9 : auto poDS = Open(&sArgs);
4403 9 : CPLPopErrorHandler();
4404 9 : if (poDS)
4405 : {
4406 8 : poDS->CloneInfo(poSrcDS, GCIF_PAM_DEFAULT);
4407 8 : return poDS;
4408 : }
4409 :
4410 1 : CPLErrorReset();
4411 : }
4412 :
4413 1 : JPGDataset *poJPG_DS = new JPGDataset();
4414 1 : poJPG_DS->nRasterXSize = poSrcDS->GetRasterXSize();
4415 1 : poJPG_DS->nRasterYSize = poSrcDS->GetRasterYSize();
4416 2 : for (int i = 0; i < nBands; i++)
4417 1 : poJPG_DS->SetBand(i + 1, JPGCreateBand(poJPG_DS, i + 1));
4418 1 : return poJPG_DS;
4419 : }
4420 : }
4421 : }
4422 :
4423 264 : if (!EQUAL(pszLossLessCopy, "AUTO") && CPLTestBool(pszLossLessCopy))
4424 : {
4425 0 : CPLError(CE_Failure, CPLE_AppDefined,
4426 : "LOSSLESS_COPY=YES requested but not possible");
4427 0 : return nullptr;
4428 : }
4429 :
4430 : // Some some rudimentary checks.
4431 264 : if (nBands != 1 && nBands != 3 && nBands != 4)
4432 : {
4433 3 : CPLError(CE_Failure, CPLE_NotSupported,
4434 : "JPEG driver doesn't support %d bands. Must be 1 (grey), "
4435 : "3 (RGB) or 4 bands (CMYK).\n",
4436 : nBands);
4437 :
4438 3 : return nullptr;
4439 : }
4440 :
4441 261 : if (nBands == 1 && poSrcDS->GetRasterBand(1)->GetColorTable() != nullptr)
4442 : {
4443 0 : CPLError(bStrict ? CE_Failure : CE_Warning, CPLE_NotSupported,
4444 : "JPEG driver ignores color table. "
4445 : "The source raster band will be considered as grey level.\n"
4446 : "Consider using color table expansion "
4447 : "(-expand option in gdal_translate)");
4448 0 : if (bStrict)
4449 0 : return nullptr;
4450 : }
4451 :
4452 263 : if (nBands == 4 &&
4453 2 : poSrcDS->GetRasterBand(1)->GetColorInterpretation() != GCI_CyanBand)
4454 : {
4455 2 : CPLError(CE_Warning, CPLE_AppDefined,
4456 : "4-band JPEGs will be interpreted on reading as in CMYK "
4457 : "colorspace");
4458 : }
4459 :
4460 261 : VSILFILE *fpImage = nullptr;
4461 261 : GDALJPEGUserData sUserData;
4462 261 : sUserData.bNonFatalErrorEncountered = false;
4463 261 : GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
4464 :
4465 : #if defined(JPEG_LIB_MK1_OR_12BIT) || defined(JPEG_DUAL_MODE_8_12)
4466 261 : if (eDT != GDT_Byte && eDT != GDT_UInt16)
4467 : {
4468 9 : CPLError(bStrict ? CE_Failure : CE_Warning, CPLE_NotSupported,
4469 : "JPEG driver doesn't support data type %s. "
4470 : "Only eight and twelve bit bands supported.",
4471 : GDALGetDataTypeName(
4472 : poSrcDS->GetRasterBand(1)->GetRasterDataType()));
4473 :
4474 9 : if (bStrict)
4475 9 : return nullptr;
4476 : }
4477 :
4478 252 : if (eDT == GDT_UInt16 || eDT == GDT_Int16)
4479 : {
4480 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(JPGDataset)
4481 1 : return JPEGDataset12CreateCopy(pszFilename, poSrcDS, bStrict,
4482 : papszOptions, pfnProgress,
4483 1 : pProgressData);
4484 : #else
4485 1 : eDT = GDT_UInt16;
4486 : #endif // defined(JPEG_DUAL_MODE_8_12) && !defined(JPGDataset)
4487 : }
4488 : else
4489 : {
4490 250 : eDT = GDT_Byte;
4491 : }
4492 :
4493 : #else // !(defined(JPEG_LIB_MK1_OR_12BIT) || defined(JPEG_DUAL_MODE_8_12))
4494 : if (eDT != GDT_Byte)
4495 : {
4496 : CPLError(bStrict ? CE_Failure : CE_Warning, CPLE_NotSupported,
4497 : "JPEG driver doesn't support data type %s. "
4498 : "Only eight bit byte bands supported.\n",
4499 : GDALGetDataTypeName(
4500 : poSrcDS->GetRasterBand(1)->GetRasterDataType()));
4501 :
4502 : if (bStrict)
4503 : return nullptr;
4504 : }
4505 :
4506 : eDT = GDT_Byte; // force to 8bit.
4507 : #endif // !(defined(JPEG_LIB_MK1_OR_12BIT) || defined(JPEG_DUAL_MODE_8_12))
4508 :
4509 : // What options has the caller selected?
4510 251 : int nQuality = 75;
4511 251 : const char *pszQuality = CSLFetchNameValue(papszOptions, "QUALITY");
4512 251 : if (pszQuality)
4513 : {
4514 113 : nQuality = atoi(pszQuality);
4515 113 : if (nQuality < 1 || nQuality > 100)
4516 : {
4517 0 : CPLError(CE_Failure, CPLE_IllegalArg,
4518 : "QUALITY=%s is not a legal value in the range 1-100.",
4519 : pszQuality);
4520 0 : return nullptr;
4521 : }
4522 : }
4523 :
4524 : // Create the dataset.
4525 251 : fpImage = VSIFOpenL(pszFilename, "wb");
4526 251 : if (fpImage == nullptr)
4527 : {
4528 3 : CPLError(CE_Failure, CPLE_OpenFailed,
4529 : "Unable to create jpeg file %s.\n", pszFilename);
4530 3 : return nullptr;
4531 : }
4532 :
4533 : struct jpeg_compress_struct sCInfo;
4534 : struct jpeg_error_mgr sJErr;
4535 : GByte *pabyScanline;
4536 :
4537 : // Does the source have a mask? If so, we will append it to the
4538 : // jpeg file after the imagery.
4539 248 : const int nMaskFlags = poSrcDS->GetRasterBand(1)->GetMaskFlags();
4540 7 : const bool bAppendMask = !(nMaskFlags & GMF_ALL_VALID) &&
4541 256 : (nBands == 1 || (nMaskFlags & GMF_PER_DATASET)) &&
4542 7 : CPLFetchBool(papszOptions, "INTERNAL_MASK", true);
4543 :
4544 : // Nasty trick to avoid variable clobbering issues with setjmp/longjmp.
4545 248 : return CreateCopyStage2(pszFilename, poSrcDS, papszOptions, pfnProgress,
4546 : pProgressData, fpImage, eDT, nQuality, bAppendMask,
4547 248 : sUserData, sCInfo, sJErr, pabyScanline);
4548 : }
4549 :
4550 248 : GDALDataset *JPGDataset::CreateCopyStage2(
4551 : const char *pszFilename, GDALDataset *poSrcDS, char **papszOptions,
4552 : GDALProgressFunc pfnProgress, void *pProgressData, VSILFILE *fpImage,
4553 : GDALDataType eDT, int nQuality, bool bAppendMask,
4554 : GDALJPEGUserData &sUserData, struct jpeg_compress_struct &sCInfo,
4555 : struct jpeg_error_mgr &sJErr, GByte *&pabyScanline)
4556 :
4557 : {
4558 248 : if (setjmp(sUserData.setjmp_buffer))
4559 : {
4560 0 : if (fpImage)
4561 0 : VSIFCloseL(fpImage);
4562 0 : return nullptr;
4563 : }
4564 :
4565 248 : if (!pfnProgress(0.0, nullptr, pProgressData))
4566 0 : return nullptr;
4567 :
4568 : // Initialize JPG access to the file.
4569 248 : sCInfo.err = jpeg_std_error(&sJErr);
4570 248 : sJErr.error_exit = JPGDataset::ErrorExit;
4571 248 : sJErr.output_message = JPGDataset::OutputMessage;
4572 248 : sUserData.p_previous_emit_message = sJErr.emit_message;
4573 248 : sJErr.emit_message = JPGDataset::EmitMessage;
4574 248 : sCInfo.client_data = &sUserData;
4575 :
4576 248 : jpeg_create_compress(&sCInfo);
4577 248 : if (setjmp(sUserData.setjmp_buffer))
4578 : {
4579 1 : if (fpImage)
4580 1 : VSIFCloseL(fpImage);
4581 1 : jpeg_destroy_compress(&sCInfo);
4582 1 : return nullptr;
4583 : }
4584 :
4585 248 : jpeg_vsiio_dest(&sCInfo, fpImage);
4586 :
4587 248 : const int nXSize = poSrcDS->GetRasterXSize();
4588 248 : const int nYSize = poSrcDS->GetRasterYSize();
4589 248 : const int nBands = poSrcDS->GetRasterCount();
4590 248 : sCInfo.image_width = nXSize;
4591 248 : sCInfo.image_height = nYSize;
4592 248 : sCInfo.input_components = nBands;
4593 :
4594 248 : if (nBands == 3)
4595 156 : sCInfo.in_color_space = JCS_RGB;
4596 92 : else if (nBands == 1)
4597 90 : sCInfo.in_color_space = JCS_GRAYSCALE;
4598 : else
4599 2 : sCInfo.in_color_space = JCS_UNKNOWN;
4600 :
4601 248 : jpeg_set_defaults(&sCInfo);
4602 :
4603 : // libjpeg turbo 1.5.2 honours max_memory_to_use, but has no backing
4604 : // store implementation, so better not set max_memory_to_use ourselves.
4605 : // See https://github.com/libjpeg-turbo/libjpeg-turbo/issues/162
4606 248 : if (sCInfo.mem->max_memory_to_use > 0)
4607 : {
4608 : // This is to address bug related in ticket #1795.
4609 0 : if (CPLGetConfigOption("JPEGMEM", nullptr) == nullptr)
4610 : {
4611 : // If the user doesn't provide a value for JPEGMEM, we want to be
4612 : // sure that at least 500 MB will be used before creating the
4613 : // temporary file.
4614 0 : const long nMinMemory = 500 * 1024 * 1024;
4615 0 : sCInfo.mem->max_memory_to_use =
4616 0 : std::max(sCInfo.mem->max_memory_to_use, nMinMemory);
4617 : }
4618 : }
4619 :
4620 248 : if (eDT == GDT_UInt16)
4621 : {
4622 1 : sCInfo.data_precision = 12;
4623 : }
4624 : else
4625 : {
4626 247 : sCInfo.data_precision = 8;
4627 : }
4628 :
4629 248 : const char *pszVal = CSLFetchNameValue(papszOptions, "ARITHMETIC");
4630 248 : if (pszVal)
4631 1 : sCInfo.arith_code = CPLTestBool(pszVal);
4632 :
4633 : // Optimized Huffman coding. Supposedly slower according to libjpeg doc
4634 : // but no longer significant with today computer standards.
4635 248 : if (!sCInfo.arith_code)
4636 247 : sCInfo.optimize_coding = TRUE;
4637 :
4638 : #if JPEG_LIB_VERSION_MAJOR >= 8 && \
4639 : (JPEG_LIB_VERSION_MAJOR > 8 || JPEG_LIB_VERSION_MINOR >= 3)
4640 : pszVal = CSLFetchNameValue(papszOptions, "BLOCK");
4641 : if (pszVal)
4642 : sCInfo.block_size = atoi(pszVal);
4643 : #endif
4644 :
4645 : #if JPEG_LIB_VERSION_MAJOR >= 9
4646 : pszVal = CSLFetchNameValue(papszOptions, "COLOR_TRANSFORM");
4647 : if (pszVal)
4648 : {
4649 : sCInfo.color_transform =
4650 : EQUAL(pszVal, "RGB1") ? JCT_SUBTRACT_GREEN : JCT_NONE;
4651 : jpeg_set_colorspace(&sCInfo, JCS_RGB);
4652 : }
4653 : else
4654 : #endif
4655 :
4656 : // Mostly for debugging purposes.
4657 404 : if (nBands == 3 &&
4658 156 : CPLTestBool(CPLGetConfigOption("JPEG_WRITE_RGB", "NO")))
4659 : {
4660 0 : jpeg_set_colorspace(&sCInfo, JCS_RGB);
4661 : }
4662 :
4663 : #ifdef JPEG_LIB_MK1
4664 : sCInfo.bits_in_jsample = sCInfo.data_precision;
4665 : // Always force to 16 bit for JPEG_LIB_MK1
4666 : const GDALDataType eWorkDT = GDT_UInt16;
4667 : #else
4668 248 : const GDALDataType eWorkDT = eDT;
4669 : #endif
4670 :
4671 248 : jpeg_set_quality(&sCInfo, nQuality, TRUE);
4672 :
4673 248 : const bool bProgressive = CPLFetchBool(papszOptions, "PROGRESSIVE", false);
4674 248 : if (bProgressive)
4675 3 : jpeg_simple_progression(&sCInfo);
4676 :
4677 248 : jpeg_start_compress(&sCInfo, TRUE);
4678 :
4679 247 : JPGAddEXIF(eWorkDT, poSrcDS, papszOptions, &sCInfo,
4680 : (my_jpeg_write_m_header)jpeg_write_m_header,
4681 : (my_jpeg_write_m_byte)jpeg_write_m_byte, CreateCopy);
4682 :
4683 : // Add comment if available.
4684 247 : const char *pszComment = CSLFetchNameValue(papszOptions, "COMMENT");
4685 247 : if (pszComment)
4686 3 : jpeg_write_marker(&sCInfo, JPEG_COM,
4687 : reinterpret_cast<const JOCTET *>(pszComment),
4688 3 : static_cast<unsigned int>(strlen(pszComment)));
4689 :
4690 : // Save ICC profile if available.
4691 : const char *pszICCProfile =
4692 247 : CSLFetchNameValue(papszOptions, "SOURCE_ICC_PROFILE");
4693 247 : if (pszICCProfile == nullptr)
4694 : pszICCProfile =
4695 246 : poSrcDS->GetMetadataItem("SOURCE_ICC_PROFILE", "COLOR_PROFILE");
4696 :
4697 247 : if (pszICCProfile != nullptr)
4698 3 : JPGAddICCProfile(&sCInfo, pszICCProfile,
4699 : (my_jpeg_write_m_header)jpeg_write_m_header,
4700 : (my_jpeg_write_m_byte)jpeg_write_m_byte);
4701 :
4702 : // Loop over image, copying image data.
4703 247 : const int nWorkDTSize = GDALGetDataTypeSizeBytes(eWorkDT);
4704 247 : pabyScanline = static_cast<GByte *>(
4705 247 : CPLMalloc(cpl::fits_on<int>(nBands * nXSize * nWorkDTSize)));
4706 :
4707 247 : if (setjmp(sUserData.setjmp_buffer))
4708 : {
4709 10 : VSIFCloseL(fpImage);
4710 10 : CPLFree(pabyScanline);
4711 10 : jpeg_destroy_compress(&sCInfo);
4712 10 : return nullptr;
4713 : }
4714 :
4715 247 : CPLErr eErr = CE_None;
4716 247 : bool bClipWarn = false;
4717 35994 : for (int iLine = 0; iLine < nYSize && eErr == CE_None; iLine++)
4718 : {
4719 142988 : eErr = poSrcDS->RasterIO(
4720 : GF_Read, 0, iLine, nXSize, 1, pabyScanline, nXSize, 1, eWorkDT,
4721 35747 : nBands, nullptr, cpl::fits_on<int>(nBands * nWorkDTSize),
4722 35747 : cpl::fits_on<int>(nBands * nXSize * nWorkDTSize), nWorkDTSize,
4723 : nullptr);
4724 :
4725 : // Clamp 16bit values to 12bit.
4726 35747 : if (nWorkDTSize == 2)
4727 : {
4728 10 : GUInt16 *panScanline = reinterpret_cast<GUInt16 *>(pabyScanline);
4729 :
4730 110 : for (int iPixel = 0; iPixel < nXSize * nBands; iPixel++)
4731 : {
4732 100 : if (panScanline[iPixel] > 4095)
4733 : {
4734 0 : panScanline[iPixel] = 4095;
4735 0 : if (!bClipWarn)
4736 : {
4737 0 : bClipWarn = true;
4738 0 : CPLError(CE_Warning, CPLE_AppDefined,
4739 : "One or more pixels clipped to fit "
4740 : "12bit domain for jpeg output.");
4741 : }
4742 : }
4743 : }
4744 : }
4745 :
4746 35747 : GDAL_JSAMPLE *ppSamples =
4747 35747 : reinterpret_cast<GDAL_JSAMPLE *>(pabyScanline);
4748 :
4749 35747 : if (eErr == CE_None)
4750 : {
4751 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) && BITS_IN_JSAMPLE == 12
4752 : jpeg12_write_scanlines(&sCInfo, &ppSamples, 1);
4753 : #else
4754 35747 : jpeg_write_scanlines(&sCInfo, &ppSamples, 1);
4755 : #endif
4756 : }
4757 71494 : if (eErr == CE_None &&
4758 71494 : !pfnProgress((iLine + 1) / ((bAppendMask ? 2 : 1) *
4759 35747 : static_cast<double>(nYSize)),
4760 : nullptr, pProgressData))
4761 : {
4762 1 : eErr = CE_Failure;
4763 1 : CPLError(CE_Failure, CPLE_UserInterrupt,
4764 : "User terminated CreateCopy()");
4765 : }
4766 : }
4767 :
4768 : // Cleanup and close.
4769 247 : if (eErr == CE_None)
4770 246 : jpeg_finish_compress(&sCInfo);
4771 237 : jpeg_destroy_compress(&sCInfo);
4772 :
4773 : // Free scanline and image after jpeg_finish_compress since this could
4774 : // cause a longjmp to occur.
4775 237 : CPLFree(pabyScanline);
4776 :
4777 237 : VSIFCloseL(fpImage);
4778 :
4779 237 : if (eErr != CE_None)
4780 : {
4781 1 : VSIUnlink(pszFilename);
4782 1 : return nullptr;
4783 : }
4784 :
4785 : // Append masks to the jpeg file if necessary.
4786 236 : int nCloneFlags = GCIF_PAM_DEFAULT & ~GCIF_METADATA;
4787 236 : if (bAppendMask)
4788 : {
4789 7 : CPLDebug("JPEG", "Appending Mask Bitmap");
4790 :
4791 : void *pScaledData =
4792 7 : GDALCreateScaledProgress(0.5, 1, pfnProgress, pProgressData);
4793 : eErr =
4794 7 : JPGAppendMask(pszFilename, poSrcDS->GetRasterBand(1)->GetMaskBand(),
4795 : GDALScaledProgress, pScaledData);
4796 7 : GDALDestroyScaledProgress(pScaledData);
4797 7 : nCloneFlags &= (~GCIF_MASK);
4798 :
4799 7 : if (eErr != CE_None)
4800 : {
4801 0 : VSIUnlink(pszFilename);
4802 0 : return nullptr;
4803 : }
4804 : }
4805 :
4806 : // Do we need a world file?
4807 236 : if (CPLFetchBool(papszOptions, "WORLDFILE", false))
4808 : {
4809 1 : double adfGeoTransform[6] = {};
4810 :
4811 1 : poSrcDS->GetGeoTransform(adfGeoTransform);
4812 1 : GDALWriteWorldFile(pszFilename, "wld", adfGeoTransform);
4813 : }
4814 :
4815 : // Re-open dataset, and copy any auxiliary pam information.
4816 :
4817 : // If writing to stdout, we can't reopen it, so return
4818 : // a fake dataset to make the caller happy.
4819 236 : if (CPLTestBool(CPLGetConfigOption("GDAL_OPEN_AFTER_COPY", "YES")))
4820 : {
4821 173 : CPLPushErrorHandler(CPLQuietErrorHandler);
4822 :
4823 173 : JPGDatasetOpenArgs sArgs;
4824 173 : sArgs.pszFilename = pszFilename;
4825 173 : sArgs.bDoPAMInitialize = true;
4826 173 : sArgs.bUseInternalOverviews = true;
4827 :
4828 173 : auto poDS = Open(&sArgs);
4829 173 : CPLPopErrorHandler();
4830 173 : if (poDS)
4831 : {
4832 172 : poDS->CloneInfo(poSrcDS, nCloneFlags);
4833 :
4834 : char **papszExcludedDomains =
4835 172 : CSLAddString(nullptr, "COLOR_PROFILE");
4836 172 : char **papszMD = poSrcDS->GetMetadata();
4837 172 : bool bOnlyEXIF = true;
4838 209 : for (char **papszIter = papszMD; papszIter && *papszIter;
4839 : ++papszIter)
4840 : {
4841 55 : if (!STARTS_WITH_CI(*papszIter, "EXIF_"))
4842 : {
4843 18 : bOnlyEXIF = false;
4844 18 : break;
4845 : }
4846 : }
4847 172 : if (bOnlyEXIF)
4848 154 : papszExcludedDomains = CSLAddString(papszExcludedDomains, "");
4849 172 : GDALDriver::DefaultCopyMetadata(poSrcDS, poDS, papszOptions,
4850 : papszExcludedDomains);
4851 172 : CSLDestroy(papszExcludedDomains);
4852 :
4853 172 : return poDS;
4854 : }
4855 :
4856 1 : CPLErrorReset();
4857 : }
4858 :
4859 64 : JPGDataset *poJPG_DS = new JPGDataset();
4860 64 : poJPG_DS->nRasterXSize = nXSize;
4861 64 : poJPG_DS->nRasterYSize = nYSize;
4862 212 : for (int i = 0; i < nBands; i++)
4863 148 : poJPG_DS->SetBand(i + 1, JPGCreateBand(poJPG_DS, i + 1));
4864 64 : return poJPG_DS;
4865 : }
4866 :
4867 : /************************************************************************/
4868 : /* GDALRegister_JPEG() */
4869 : /************************************************************************/
4870 :
4871 : #if !defined(JPGDataset)
4872 :
4873 35 : char **GDALJPGDriver::GetMetadata(const char *pszDomain)
4874 : {
4875 35 : GetMetadataItem(GDAL_DMD_CREATIONOPTIONLIST);
4876 35 : return GDALDriver::GetMetadata(pszDomain);
4877 : }
4878 :
4879 : // C_ARITH_CODING_SUPPORTED is defined in libjpeg-turbo's jconfig.h
4880 : #ifndef C_ARITH_CODING_SUPPORTED
4881 : static void GDALJPEGIsArithmeticCodingAvailableErrorExit(j_common_ptr cinfo)
4882 : {
4883 : jmp_buf *p_setjmp_buffer = static_cast<jmp_buf *>(cinfo->client_data);
4884 : // Return control to the setjmp point.
4885 : longjmp(*p_setjmp_buffer, 1);
4886 : }
4887 :
4888 : // Runtime check if arithmetic coding is available.
4889 : static bool GDALJPEGIsArithmeticCodingAvailable()
4890 : {
4891 : struct jpeg_compress_struct sCInfo;
4892 : struct jpeg_error_mgr sJErr;
4893 : jmp_buf setjmp_buffer;
4894 : if (setjmp(setjmp_buffer))
4895 : {
4896 : jpeg_destroy_compress(&sCInfo);
4897 : return false;
4898 : }
4899 : sCInfo.err = jpeg_std_error(&sJErr);
4900 : sJErr.error_exit = GDALJPEGIsArithmeticCodingAvailableErrorExit;
4901 : sCInfo.client_data = &setjmp_buffer;
4902 : jpeg_create_compress(&sCInfo);
4903 : // Hopefully nothing will be written.
4904 : jpeg_stdio_dest(&sCInfo, stderr);
4905 : sCInfo.image_width = 1;
4906 : sCInfo.image_height = 1;
4907 : sCInfo.input_components = 1;
4908 : sCInfo.in_color_space = JCS_UNKNOWN;
4909 : jpeg_set_defaults(&sCInfo);
4910 : sCInfo.arith_code = TRUE;
4911 : jpeg_start_compress(&sCInfo, FALSE);
4912 : jpeg_abort_compress(&sCInfo);
4913 : jpeg_destroy_compress(&sCInfo);
4914 :
4915 : return true;
4916 : }
4917 : #endif
4918 :
4919 63743 : const char *GDALJPGDriver::GetMetadataItem(const char *pszName,
4920 : const char *pszDomain)
4921 : {
4922 63743 : if (pszName != nullptr && EQUAL(pszName, GDAL_DMD_CREATIONOPTIONLIST) &&
4923 127801 : (pszDomain == nullptr || EQUAL(pszDomain, "")) &&
4924 315 : GDALDriver::GetMetadataItem(pszName, pszDomain) == nullptr)
4925 : {
4926 : CPLString osCreationOptions =
4927 : "<CreationOptionList>\n"
4928 : " <Option name='PROGRESSIVE' type='boolean' description='whether "
4929 : "to generate a progressive JPEG' default='NO'/>\n"
4930 : " <Option name='QUALITY' type='int' description='good=100, "
4931 : "bad=1, default=75'/>\n"
4932 : " <Option name='LOSSLESS_COPY' type='string-select' "
4933 : "description='Whether conversion should be lossless' "
4934 : "default='AUTO'>"
4935 : " <Value>AUTO</Value>"
4936 : " <Value>YES</Value>"
4937 : " <Value>NO</Value>"
4938 : " </Option>"
4939 : " <Option name='WORLDFILE' type='boolean' description='whether "
4940 : "to generate a worldfile' default='NO'/>\n"
4941 : " <Option name='INTERNAL_MASK' type='boolean' "
4942 : "description='whether to generate a validity mask' "
4943 22 : "default='YES'/>\n";
4944 : #ifndef C_ARITH_CODING_SUPPORTED
4945 : if (GDALJPEGIsArithmeticCodingAvailable())
4946 : #endif
4947 : {
4948 : osCreationOptions += " <Option name='ARITHMETIC' type='boolean' "
4949 : "description='whether to use arithmetic "
4950 11 : "encoding' default='NO'/>\n";
4951 : }
4952 : osCreationOptions +=
4953 : #if JPEG_LIB_VERSION_MAJOR >= 8 && \
4954 : (JPEG_LIB_VERSION_MAJOR > 8 || JPEG_LIB_VERSION_MINOR >= 3)
4955 : " <Option name='BLOCK' type='int' description='between 1 and "
4956 : "16'/>\n"
4957 : #endif
4958 : #if JPEG_LIB_VERSION_MAJOR >= 9
4959 : " <Option name='COLOR_TRANSFORM' type='string-select'>\n"
4960 : " <Value>RGB</Value>"
4961 : " <Value>RGB1</Value>"
4962 : " </Option>"
4963 : #endif
4964 : " <Option name='COMMENT' description='Comment' type='string'/>\n"
4965 : " <Option name='SOURCE_ICC_PROFILE' description='ICC profile "
4966 : "encoded in Base64' type='string'/>\n"
4967 : " <Option name='EXIF_THUMBNAIL' type='boolean' "
4968 : "description='whether to generate an EXIF thumbnail(overview). By "
4969 : "default its max dimension will be 128' default='NO'/>\n"
4970 : " <Option name='THUMBNAIL_WIDTH' type='int' description='Forced "
4971 : "thumbnail width' min='32' max='512'/>\n"
4972 : " <Option name='THUMBNAIL_HEIGHT' type='int' description='Forced "
4973 : "thumbnail height' min='32' max='512'/>\n"
4974 : " <Option name='WRITE_EXIF_METADATA' type='boolean' "
4975 : "description='whether to write EXIF_ metadata in a EXIF segment' "
4976 : "default='YES'/>"
4977 11 : "</CreationOptionList>\n";
4978 11 : SetMetadataItem(GDAL_DMD_CREATIONOPTIONLIST, osCreationOptions);
4979 : }
4980 63743 : return GDALDriver::GetMetadataItem(pszName, pszDomain);
4981 : }
4982 :
4983 1682 : void GDALRegister_JPEG()
4984 :
4985 : {
4986 1682 : if (GDALGetDriverByName(DRIVER_NAME) != nullptr)
4987 301 : return;
4988 :
4989 1381 : GDALDriver *poDriver = new GDALJPGDriver();
4990 1381 : JPEGDriverSetCommonMetadata(poDriver);
4991 :
4992 1381 : poDriver->pfnOpen = JPGDatasetCommon::Open;
4993 1381 : poDriver->pfnCreateCopy = JPGDataset::CreateCopy;
4994 :
4995 1381 : GetGDALDriverManager()->RegisterDriver(poDriver);
4996 : }
4997 : #endif
|
