Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: PNG Driver
4 : * Purpose: Implement GDAL PNG Support
5 : * Author: Frank Warmerdam, warmerda@home.com
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 2000, Frank Warmerdam
9 : * Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
10 : *
11 : * SPDX-License-Identifier: MIT
12 : ******************************************************************************
13 : *
14 : * ISSUES:
15 : * o CollectMetadata() will only capture TEXT chunks before the image
16 : * data as the code is currently structured.
17 : * o Interlaced images are read entirely into memory for use. This is
18 : * bad for large images.
19 : * o Image reading is always strictly sequential. Reading backwards will
20 : * cause the file to be rewound, and access started again from the
21 : * beginning.
22 : * o 16 bit alpha values are not scaled by to eight bit.
23 : *
24 : */
25 :
26 : #include "pngdataset.h"
27 : #include "pngdrivercore.h"
28 :
29 : #include "cpl_string.h"
30 : #include "gdal_frmts.h"
31 : #include "gdal_pam.h"
32 : #include "png.h"
33 :
34 : #include <csetjmp>
35 :
36 : #include <algorithm>
37 : #include <limits>
38 :
39 : // Note: Callers must provide blocks in increasing Y order.
40 : // Disclaimer (E. Rouault): this code is not production ready at all. A lot of
41 : // issues remain: uninitialized variables, unclosed files, lack of proper
42 : // multiband handling, and an inability to read and write at the same time. Do
43 : // not use it unless you're ready to fix it.
44 :
45 : // Define SUPPORT_CREATE to enable use of the Create() call.
46 : // #define SUPPORT_CREATE
47 :
48 : #ifdef _MSC_VER
49 : #pragma warning(disable : 4611)
50 : #endif
51 :
52 : static void png_vsi_read_data(png_structp png_ptr, png_bytep data,
53 : png_size_t length);
54 :
55 : static void png_vsi_write_data(png_structp png_ptr, png_bytep data,
56 : png_size_t length);
57 :
58 : static void png_vsi_flush(png_structp png_ptr);
59 :
60 : static void png_gdal_error(png_structp png_ptr, const char *error_message);
61 : static void png_gdal_warning(png_structp png_ptr, const char *error_message);
62 :
63 : #ifdef ENABLE_WHOLE_IMAGE_OPTIMIZATION
64 :
65 : /************************************************************************/
66 : /* IsCompatibleOfSingleBlock() */
67 : /************************************************************************/
68 :
69 19917 : bool PNGDataset::IsCompatibleOfSingleBlock() const
70 : {
71 19733 : return nBitDepth == 8 && !bInterlaced && nRasterXSize <= 512 &&
72 19389 : nRasterYSize <= 512 &&
73 19387 : CPLTestBool(
74 39650 : CPLGetConfigOption("GDAL_PNG_WHOLE_IMAGE_OPTIM", "YES")) &&
75 39215 : CPLTestBool(CPLGetConfigOption("GDAL_PNG_SINGLE_BLOCK", "YES"));
76 : }
77 : #endif
78 :
79 : /************************************************************************/
80 : /* PNGRasterBand() */
81 : /************************************************************************/
82 :
83 19917 : PNGRasterBand::PNGRasterBand(PNGDataset *poDSIn, int nBandIn)
84 19917 : : bHaveNoData(FALSE), dfNoDataValue(-1)
85 : {
86 19917 : poDS = poDSIn;
87 19917 : nBand = nBandIn;
88 :
89 19917 : if (poDSIn->nBitDepth == 16)
90 176 : eDataType = GDT_UInt16;
91 : else
92 19741 : eDataType = GDT_Byte;
93 :
94 19917 : nBlockXSize = poDSIn->nRasterXSize;
95 : #ifdef ENABLE_WHOLE_IMAGE_OPTIMIZATION
96 19917 : if (poDSIn->IsCompatibleOfSingleBlock())
97 : {
98 19209 : nBlockYSize = poDSIn->nRasterYSize;
99 : }
100 : else
101 : #endif
102 : {
103 708 : nBlockYSize = 1;
104 : }
105 :
106 : #ifdef SUPPORT_CREATE
107 : reset_band_provision_flags();
108 : #endif
109 19917 : }
110 :
111 : /************************************************************************/
112 : /* IReadBlock() */
113 : /************************************************************************/
114 :
115 19043 : CPLErr PNGRasterBand::IReadBlock(int nBlockXOff, int nBlockYOff, void *pImage)
116 :
117 : {
118 : #ifdef ENABLE_WHOLE_IMAGE_OPTIMIZATION
119 19043 : if (nBlockYSize > 1)
120 : {
121 : GDALRasterIOExtraArg sExtraArg;
122 101 : INIT_RASTERIO_EXTRA_ARG(sExtraArg);
123 101 : const int nDTSize = GDALGetDataTypeSizeBytes(eDataType);
124 202 : return IRasterIO(GF_Read, 0, 0, nRasterXSize, nRasterYSize, pImage,
125 : nRasterXSize, nRasterYSize, eDataType, nDTSize,
126 101 : static_cast<GSpacing>(nDTSize) * nRasterXSize,
127 101 : &sExtraArg);
128 : }
129 : #endif
130 :
131 18942 : PNGDataset *poGDS = cpl::down_cast<PNGDataset *>(poDS);
132 : int nPixelSize;
133 18942 : CPLAssert(nBlockXOff == 0);
134 :
135 18942 : if (poGDS->nBitDepth == 16)
136 11002 : nPixelSize = 2;
137 : else
138 7940 : nPixelSize = 1;
139 :
140 18942 : const int nXSize = GetXSize();
141 18942 : if (poGDS->fpImage == nullptr)
142 : {
143 0 : memset(pImage, 0, cpl::fits_on<int>(nPixelSize * nXSize));
144 0 : return CE_None;
145 : }
146 :
147 : // Load the desired scanline into the working buffer.
148 18942 : CPLErr eErr = poGDS->LoadScanline(nBlockYOff);
149 18942 : if (eErr != CE_None)
150 2 : return eErr;
151 :
152 18940 : const int nPixelOffset = poGDS->nBands * nPixelSize;
153 :
154 18940 : GByte *pabyScanline =
155 18940 : poGDS->pabyBuffer +
156 18940 : (nBlockYOff - poGDS->nBufferStartLine) * nPixelOffset * nXSize +
157 18940 : nPixelSize * (nBand - 1);
158 :
159 : // Transfer between the working buffer and the caller's buffer.
160 18940 : if (nPixelSize == nPixelOffset)
161 10686 : memcpy(pImage, pabyScanline, cpl::fits_on<int>(nPixelSize * nXSize));
162 8254 : else if (nPixelSize == 1)
163 : {
164 3737490 : for (int i = 0; i < nXSize; i++)
165 3730210 : reinterpret_cast<GByte *>(pImage)[i] =
166 3730210 : pabyScanline[i * nPixelOffset];
167 : }
168 : else
169 : {
170 976 : CPLAssert(nPixelSize == 2);
171 21648 : for (int i = 0; i < nXSize; i++)
172 : {
173 20672 : reinterpret_cast<GUInt16 *>(pImage)[i] =
174 20672 : *reinterpret_cast<GUInt16 *>(pabyScanline + i * nPixelOffset);
175 : }
176 : }
177 :
178 : // Forcibly load the other bands associated with this scanline.
179 42346 : for (int iBand = 1; iBand < poGDS->GetRasterCount(); iBand++)
180 : {
181 : GDALRasterBlock *poBlock =
182 23406 : poGDS->GetRasterBand(iBand + 1)->GetLockedBlockRef(nBlockXOff,
183 23406 : nBlockYOff);
184 23406 : if (poBlock != nullptr)
185 23406 : poBlock->DropLock();
186 : }
187 :
188 18940 : return CE_None;
189 : }
190 :
191 : /************************************************************************/
192 : /* GetColorInterpretation() */
193 : /************************************************************************/
194 :
195 309 : GDALColorInterp PNGRasterBand::GetColorInterpretation()
196 :
197 : {
198 309 : PNGDataset *poGDS = reinterpret_cast<PNGDataset *>(poDS);
199 :
200 309 : if (poGDS->nColorType == PNG_COLOR_TYPE_GRAY)
201 16 : return GCI_GrayIndex;
202 :
203 293 : else if (poGDS->nColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
204 : {
205 18 : if (nBand == 1)
206 3 : return GCI_GrayIndex;
207 : else
208 15 : return GCI_AlphaBand;
209 : }
210 :
211 275 : else if (poGDS->nColorType == PNG_COLOR_TYPE_PALETTE)
212 42 : return GCI_PaletteIndex;
213 :
214 233 : else if (poGDS->nColorType == PNG_COLOR_TYPE_RGB ||
215 191 : poGDS->nColorType == PNG_COLOR_TYPE_RGB_ALPHA)
216 : {
217 233 : if (nBand == 1)
218 35 : return GCI_RedBand;
219 198 : else if (nBand == 2)
220 42 : return GCI_GreenBand;
221 156 : else if (nBand == 3)
222 33 : return GCI_BlueBand;
223 : else
224 123 : return GCI_AlphaBand;
225 : }
226 : else
227 0 : return GCI_GrayIndex;
228 : }
229 :
230 : /************************************************************************/
231 : /* GetColorTable() */
232 : /************************************************************************/
233 :
234 564 : GDALColorTable *PNGRasterBand::GetColorTable()
235 :
236 : {
237 564 : PNGDataset *poGDS = reinterpret_cast<PNGDataset *>(poDS);
238 :
239 564 : if (nBand == 1)
240 540 : return poGDS->poColorTable;
241 :
242 24 : return nullptr;
243 : }
244 :
245 : /************************************************************************/
246 : /* SetNoDataValue() */
247 : /************************************************************************/
248 :
249 282 : CPLErr PNGRasterBand::SetNoDataValue(double dfNewValue)
250 :
251 : {
252 282 : bHaveNoData = TRUE;
253 282 : dfNoDataValue = dfNewValue;
254 :
255 282 : return CE_None;
256 : }
257 :
258 : /************************************************************************/
259 : /* GetNoDataValue() */
260 : /************************************************************************/
261 :
262 161 : double PNGRasterBand::GetNoDataValue(int *pbSuccess)
263 :
264 : {
265 161 : if (bHaveNoData)
266 : {
267 34 : if (pbSuccess != nullptr)
268 30 : *pbSuccess = bHaveNoData;
269 34 : return dfNoDataValue;
270 : }
271 :
272 127 : return GDALPamRasterBand::GetNoDataValue(pbSuccess);
273 : }
274 :
275 : /************************************************************************/
276 : /* ==================================================================== */
277 : /* PNGDataset */
278 : /* ==================================================================== */
279 : /************************************************************************/
280 :
281 : /************************************************************************/
282 : /* PNGDataset() */
283 : /************************************************************************/
284 :
285 7232 : PNGDataset::PNGDataset()
286 : : fpImage(nullptr), hPNG(nullptr), psPNGInfo(nullptr), nBitDepth(8),
287 : nColorType(0), bInterlaced(FALSE), nBufferStartLine(0), nBufferLines(0),
288 : nLastLineRead(-1), pabyBuffer(nullptr), poColorTable(nullptr),
289 : bGeoTransformValid(FALSE), bHasReadXMPMetadata(FALSE),
290 7232 : bHasTriedLoadWorldFile(FALSE), bHasReadICCMetadata(FALSE)
291 : {
292 7232 : adfGeoTransform[0] = 0.0;
293 7232 : adfGeoTransform[1] = 1.0;
294 7232 : adfGeoTransform[2] = 0.0;
295 7232 : adfGeoTransform[3] = 0.0;
296 7232 : adfGeoTransform[4] = 0.0;
297 7232 : adfGeoTransform[5] = 1.0;
298 :
299 7232 : memset(&sSetJmpContext, 0, sizeof(sSetJmpContext));
300 7232 : }
301 :
302 : /************************************************************************/
303 : /* ~PNGDataset() */
304 : /************************************************************************/
305 :
306 14464 : PNGDataset::~PNGDataset()
307 :
308 : {
309 7232 : PNGDataset::FlushCache(true);
310 :
311 7232 : if (hPNG != nullptr)
312 7219 : png_destroy_read_struct(&hPNG, &psPNGInfo, nullptr);
313 :
314 7232 : if (fpImage)
315 7219 : VSIFCloseL(fpImage);
316 :
317 7232 : if (poColorTable != nullptr)
318 378 : delete poColorTable;
319 14464 : }
320 :
321 : /************************************************************************/
322 : /* LoadWholeImage() */
323 : /************************************************************************/
324 :
325 : #ifdef ENABLE_WHOLE_IMAGE_OPTIMIZATION
326 :
327 : #ifdef HAVE_SSE2
328 : #include "filter_sse2_intrinsics.c"
329 : #endif
330 :
331 : #if defined(__GNUC__) && !defined(__SSE2__) && !defined(USE_NEON_OPTIMIZATIONS)
332 : __attribute__((optimize("tree-vectorize"))) static inline void
333 : AddVectors(const GByte *CPL_RESTRICT pabyInputLine,
334 : GByte *CPL_RESTRICT pabyOutputLine, int nSize)
335 : {
336 : for (int iX = 0; iX < nSize; ++iX)
337 : pabyOutputLine[iX] =
338 : static_cast<GByte>(pabyInputLine[iX] + pabyOutputLine[iX]);
339 : }
340 :
341 : __attribute__((optimize("tree-vectorize"))) static inline void
342 : AddVectors(const GByte *CPL_RESTRICT pabyInputLine1,
343 : const GByte *CPL_RESTRICT pabyInputLine2,
344 : GByte *CPL_RESTRICT pabyOutputLine, int nSize)
345 : {
346 : for (int iX = 0; iX < nSize; ++iX)
347 : pabyOutputLine[iX] =
348 : static_cast<GByte>(pabyInputLine1[iX] + pabyInputLine2[iX]);
349 : }
350 : #endif // defined(__GNUC__) && !defined(__SSE2__)
351 :
352 2765 : CPLErr PNGDataset::LoadWholeImage(void *pSingleBuffer, GSpacing nPixelSpace,
353 : GSpacing nLineSpace, GSpacing nBandSpace,
354 : void *apabyBuffers[4])
355 : {
356 2765 : if (fpImage == nullptr)
357 : {
358 21 : for (int iY = 0; iY < nRasterYSize; ++iY)
359 : {
360 20 : if (pSingleBuffer)
361 : {
362 20 : GByte *pabyDest =
363 20 : static_cast<GByte *>(pSingleBuffer) + iY * nLineSpace;
364 420 : for (int x = 0; x < nRasterXSize; ++x)
365 : {
366 800 : for (int iBand = 0; iBand < nBands; iBand++)
367 : {
368 400 : pabyDest[(x * nPixelSpace) + iBand * nBandSpace] = 0;
369 : }
370 : }
371 : }
372 : else
373 : {
374 0 : for (int iBand = 0; iBand < nBands; iBand++)
375 : {
376 0 : GByte *l_pabyBuffer =
377 0 : static_cast<GByte *>(apabyBuffers[iBand]) +
378 0 : iY * nRasterXSize;
379 0 : memset(l_pabyBuffer, 0, nRasterXSize);
380 : }
381 : }
382 : }
383 1 : return CE_None;
384 : }
385 :
386 2764 : const bool bCanUseDeinterleave =
387 4376 : (nBands == 3 || nBands == 4) &&
388 1612 : (apabyBuffers != nullptr ||
389 1448 : (nPixelSpace == 1 &&
390 1448 : nBandSpace == static_cast<GSpacing>(nRasterXSize) * nRasterYSize));
391 :
392 : // Below should work without SSE2, but the lack of optimized
393 : // filters can sometimes make it slower than regular optimized libpng,
394 : // so restrict to when SSE2 is available.
395 :
396 : // CPLDebug("PNG", "Using libdeflate optimization");
397 :
398 2764 : char szChunkName[5] = {0};
399 2764 : bool bError = false;
400 :
401 : // We try to read the zlib compressed data into pData, if there is
402 : // enough room for that
403 2764 : size_t nDataSize = 0;
404 5528 : std::vector<GByte> abyCompressedData; // keep in this scope
405 2764 : GByte *pabyCompressedData = static_cast<GByte *>(pSingleBuffer);
406 2764 : size_t nCompressedDataSize = 0;
407 2764 : if (pSingleBuffer)
408 : {
409 2652 : if (nPixelSpace == nBands && nLineSpace == nPixelSpace * nRasterXSize &&
410 420 : (nBands == 1 || nBandSpace == 1))
411 : {
412 420 : nDataSize =
413 420 : static_cast<size_t>(nRasterXSize) * nRasterYSize * nBands;
414 : }
415 2232 : else if (nPixelSpace == 1 && nLineSpace == nRasterXSize &&
416 : nBandSpace ==
417 1961 : static_cast<GSpacing>(nRasterXSize) * nRasterYSize)
418 : {
419 1961 : nDataSize =
420 1961 : static_cast<size_t>(nRasterXSize) * nRasterYSize * nBands;
421 : }
422 : }
423 :
424 2764 : const auto nPosBefore = VSIFTellL(fpImage);
425 2764 : VSIFSeekL(fpImage, 8, SEEK_SET);
426 : // Iterate over PNG chunks
427 : while (true)
428 : {
429 : uint32_t nChunkSize;
430 10223 : if (VSIFReadL(&nChunkSize, sizeof(nChunkSize), 1, fpImage) == 0)
431 : {
432 0 : bError = true;
433 0 : break;
434 : }
435 10223 : CPL_MSBPTR32(&nChunkSize);
436 10223 : if (VSIFReadL(szChunkName, 4, 1, fpImage) == 0)
437 : {
438 0 : bError = true;
439 0 : break;
440 : }
441 10223 : if (strcmp(szChunkName, "IDAT") == 0)
442 : {
443 : // CPLDebug("PNG", "IDAT %u %u", unsigned(nCompressedDataSize),
444 : // unsigned(nChunkSize));
445 :
446 : // There can be several IDAT chunks: concatenate ZLib stream
447 7314 : if (nChunkSize >
448 3657 : std::numeric_limits<size_t>::max() - nCompressedDataSize)
449 : {
450 0 : CPLError(CE_Failure, CPLE_OutOfMemory,
451 : "Out of memory when reading compressed stream");
452 0 : bError = true;
453 0 : break;
454 : }
455 :
456 : // Sanity check to avoid allocating too much memory
457 3657 : if (nCompressedDataSize + nChunkSize > 100 * 1024 * 1024)
458 : {
459 0 : const auto nCurPos = VSIFTellL(fpImage);
460 0 : VSIFSeekL(fpImage, 0, SEEK_END);
461 0 : const auto nSize = VSIFTellL(fpImage);
462 0 : VSIFSeekL(fpImage, nCurPos, SEEK_SET);
463 0 : if (nSize < 100 * 1024 * 1024)
464 : {
465 0 : CPLError(CE_Failure, CPLE_OutOfMemory,
466 : "Attempt at reading more data than available in "
467 : "compressed stream");
468 0 : bError = true;
469 0 : break;
470 : }
471 : }
472 :
473 3657 : if (nCompressedDataSize + nChunkSize > nDataSize)
474 : {
475 882 : const bool bVectorEmptyBefore = abyCompressedData.empty();
476 : // unlikely situation: would mean that the zlib compressed
477 : // data is longer than the decompressed image
478 : try
479 : {
480 882 : abyCompressedData.resize(nCompressedDataSize + nChunkSize);
481 882 : pabyCompressedData = abyCompressedData.data();
482 : }
483 0 : catch (const std::exception &)
484 : {
485 0 : CPLError(CE_Failure, CPLE_OutOfMemory,
486 : "Out of memory when allocating compressed stream");
487 0 : bError = true;
488 0 : break;
489 : }
490 882 : if (bVectorEmptyBefore && pSingleBuffer &&
491 : nCompressedDataSize > 0)
492 : {
493 0 : memcpy(pabyCompressedData, pSingleBuffer,
494 : nCompressedDataSize);
495 : }
496 : }
497 3657 : VSIFReadL(pabyCompressedData + nCompressedDataSize, nChunkSize, 1,
498 : fpImage);
499 3657 : nCompressedDataSize += nChunkSize;
500 : }
501 6566 : else if (strcmp(szChunkName, "IEND") == 0)
502 2764 : break;
503 : else
504 : {
505 : // CPLDebug("PNG", "Skipping chunk %s of size %u", szChunkName,
506 : // nChunkSize);
507 3802 : VSIFSeekL(fpImage, nChunkSize, SEEK_CUR);
508 : }
509 7459 : VSIFSeekL(fpImage, 4, SEEK_CUR); // CRC
510 7459 : }
511 2764 : VSIFSeekL(fpImage, nPosBefore, SEEK_SET);
512 2764 : if (bError)
513 0 : return CE_Failure;
514 :
515 2764 : const int nSamplesPerLine = nRasterXSize * nBands;
516 : size_t nOutBytes;
517 2764 : constexpr int FILTER_TYPE_BYTE = 1;
518 2764 : const size_t nZlibDecompressedSize = static_cast<size_t>(nRasterYSize) *
519 2764 : (FILTER_TYPE_BYTE + nSamplesPerLine);
520 : GByte *pabyZlibDecompressed =
521 2764 : static_cast<GByte *>(VSI_MALLOC_VERBOSE(nZlibDecompressedSize));
522 2764 : if (pabyZlibDecompressed == nullptr)
523 : {
524 0 : return CE_Failure;
525 : }
526 :
527 2764 : if (CPLZLibInflate(pabyCompressedData, nCompressedDataSize,
528 : pabyZlibDecompressed, nZlibDecompressedSize,
529 2764 : &nOutBytes) == nullptr)
530 : {
531 0 : CPLError(CE_Failure, CPLE_AppDefined, "CPLZLibInflate() failed");
532 0 : CPLFree(pabyZlibDecompressed);
533 0 : return CE_Failure;
534 : }
535 :
536 : GByte *pabyOutputBuffer;
537 5528 : std::vector<GByte> abyTemp;
538 5528 : std::vector<GByte> abyLineUp;
539 :
540 2764 : if (pSingleBuffer != nullptr && nPixelSpace == nBands &&
541 430 : nLineSpace == nPixelSpace * nRasterXSize &&
542 420 : (nBands == 1 || nBandSpace == 1))
543 : {
544 420 : pabyOutputBuffer = static_cast<GByte *>(pSingleBuffer);
545 : }
546 : else
547 : {
548 2344 : abyTemp.resize(nSamplesPerLine);
549 2344 : pabyOutputBuffer = abyTemp.data();
550 : }
551 :
552 263619 : for (int iY = 0; iY < nRasterYSize; ++iY)
553 : {
554 : // Cf http://www.libpng.org/pub/png/spec/1.2/PNG-Filters.html
555 : // CPLDebug("PNG", "Line %d, filter type = %d", iY, nFilterType);
556 260855 : const GByte *CPL_RESTRICT pabyInputLine =
557 : pabyZlibDecompressed +
558 260855 : static_cast<size_t>(iY) * (FILTER_TYPE_BYTE + nSamplesPerLine);
559 260855 : const GByte nFilterType = pabyInputLine[0];
560 260855 : pabyInputLine++;
561 : GByte *const CPL_RESTRICT pabyOutputLine =
562 260855 : abyTemp.empty()
563 260855 : ? pabyOutputBuffer + static_cast<size_t>(iY) * nSamplesPerLine
564 170982 : : abyTemp.data();
565 260855 : if (nFilterType == 0)
566 : {
567 : // Filter type 0: None
568 119862 : memcpy(pabyOutputLine, pabyInputLine, nSamplesPerLine);
569 : }
570 140993 : else if (nFilterType == 1)
571 : {
572 : // Filter type 1: Sub (horizontal differencing)
573 : #ifdef HAVE_SSE2
574 11717 : if (nBands == 3)
575 : {
576 : png_row_info row_info;
577 3921 : memset(&row_info, 0, sizeof(row_info));
578 3921 : row_info.rowbytes = nSamplesPerLine;
579 :
580 3921 : gdal_png_read_filter_row_sub3_sse2(&row_info, pabyInputLine,
581 : pabyOutputLine);
582 : }
583 7796 : else if (nBands == 4)
584 : {
585 : png_row_info row_info;
586 6233 : memset(&row_info, 0, sizeof(row_info));
587 6233 : row_info.rowbytes = nSamplesPerLine;
588 :
589 6233 : gdal_png_read_filter_row_sub4_sse2(&row_info, pabyInputLine,
590 : pabyOutputLine);
591 : }
592 : else
593 : #endif
594 : {
595 : int iX;
596 4301 : for (iX = 0; iX < nBands; ++iX)
597 2738 : pabyOutputLine[iX] = pabyInputLine[iX];
598 : #if !defined(HAVE_SSE2)
599 : if (nBands == 3)
600 : {
601 : GByte nLast0 = pabyOutputLine[0];
602 : GByte nLast1 = pabyOutputLine[1];
603 : GByte nLast2 = pabyOutputLine[2];
604 : for (; iX + 5 < nSamplesPerLine; iX += 6)
605 : {
606 : nLast0 =
607 : static_cast<GByte>(nLast0 + pabyInputLine[iX + 0]);
608 : nLast1 =
609 : static_cast<GByte>(nLast1 + pabyInputLine[iX + 1]);
610 : nLast2 =
611 : static_cast<GByte>(nLast2 + pabyInputLine[iX + 2]);
612 : pabyOutputLine[iX + 0] = nLast0;
613 : pabyOutputLine[iX + 1] = nLast1;
614 : pabyOutputLine[iX + 2] = nLast2;
615 : nLast0 =
616 : static_cast<GByte>(nLast0 + pabyInputLine[iX + 3]);
617 : nLast1 =
618 : static_cast<GByte>(nLast1 + pabyInputLine[iX + 4]);
619 : nLast2 =
620 : static_cast<GByte>(nLast2 + pabyInputLine[iX + 5]);
621 : pabyOutputLine[iX + 3] = nLast0;
622 : pabyOutputLine[iX + 4] = nLast1;
623 : pabyOutputLine[iX + 5] = nLast2;
624 : }
625 : }
626 : else if (nBands == 4)
627 : {
628 : GByte nLast0 = pabyOutputLine[0];
629 : GByte nLast1 = pabyOutputLine[1];
630 : GByte nLast2 = pabyOutputLine[2];
631 : GByte nLast3 = pabyOutputLine[3];
632 : for (; iX + 7 < nSamplesPerLine; iX += 8)
633 : {
634 : nLast0 =
635 : static_cast<GByte>(nLast0 + pabyInputLine[iX + 0]);
636 : nLast1 =
637 : static_cast<GByte>(nLast1 + pabyInputLine[iX + 1]);
638 : nLast2 =
639 : static_cast<GByte>(nLast2 + pabyInputLine[iX + 2]);
640 : nLast3 =
641 : static_cast<GByte>(nLast3 + pabyInputLine[iX + 3]);
642 : pabyOutputLine[iX + 0] = nLast0;
643 : pabyOutputLine[iX + 1] = nLast1;
644 : pabyOutputLine[iX + 2] = nLast2;
645 : pabyOutputLine[iX + 3] = nLast3;
646 : nLast0 =
647 : static_cast<GByte>(nLast0 + pabyInputLine[iX + 4]);
648 : nLast1 =
649 : static_cast<GByte>(nLast1 + pabyInputLine[iX + 5]);
650 : nLast2 =
651 : static_cast<GByte>(nLast2 + pabyInputLine[iX + 6]);
652 : nLast3 =
653 : static_cast<GByte>(nLast3 + pabyInputLine[iX + 7]);
654 : pabyOutputLine[iX + 4] = nLast0;
655 : pabyOutputLine[iX + 5] = nLast1;
656 : pabyOutputLine[iX + 6] = nLast2;
657 : pabyOutputLine[iX + 7] = nLast3;
658 : }
659 : }
660 : #endif
661 190394 : for (; iX < nSamplesPerLine; ++iX)
662 188831 : pabyOutputLine[iX] = static_cast<GByte>(
663 188831 : pabyInputLine[iX] + pabyOutputLine[iX - nBands]);
664 : }
665 : }
666 129276 : else if (nFilterType == 2)
667 : {
668 : // Filter type 2: Up (vertical differencing)
669 62520 : if (iY == 0)
670 : {
671 0 : memcpy(pabyOutputLine, pabyInputLine, nSamplesPerLine);
672 : }
673 : else
674 : {
675 62520 : if (abyTemp.empty())
676 : {
677 22537 : const GByte *CPL_RESTRICT pabyOutputLineUp =
678 : pabyOutputBuffer +
679 22537 : (static_cast<size_t>(iY) - 1) * nSamplesPerLine;
680 : #if defined(__GNUC__) && !defined(__SSE2__) && !defined(USE_NEON_OPTIMIZATIONS)
681 : AddVectors(pabyInputLine, pabyOutputLineUp, pabyOutputLine,
682 : nSamplesPerLine);
683 : #else
684 : int iX;
685 : #ifdef HAVE_SSE2
686 215757 : for (iX = 0; iX + 31 < nSamplesPerLine; iX += 32)
687 : {
688 193220 : auto in = _mm_loadu_si128(
689 193220 : (__m128i const *)(pabyInputLine + iX));
690 193220 : auto in2 = _mm_loadu_si128(
691 193220 : (__m128i const *)(pabyInputLine + iX + 16));
692 193220 : auto up = _mm_loadu_si128(
693 193220 : (__m128i const *)(pabyOutputLineUp + iX));
694 193220 : auto up2 = _mm_loadu_si128(
695 193220 : (__m128i const *)(pabyOutputLineUp + iX + 16));
696 193220 : in = _mm_add_epi8(in, up);
697 193220 : in2 = _mm_add_epi8(in2, up2);
698 193220 : _mm_storeu_si128((__m128i *)(pabyOutputLine + iX), in);
699 193220 : _mm_storeu_si128((__m128i *)(pabyOutputLine + iX + 16),
700 : in2);
701 : }
702 : #endif
703 26451 : for (; iX < nSamplesPerLine; ++iX)
704 3914 : pabyOutputLine[iX] = static_cast<GByte>(
705 3914 : pabyInputLine[iX] + pabyOutputLineUp[iX]);
706 : #endif
707 : }
708 : else
709 : {
710 : #if defined(__GNUC__) && !defined(__SSE2__) && !defined(USE_NEON_OPTIMIZATIONS)
711 : AddVectors(pabyInputLine, pabyOutputLine, nSamplesPerLine);
712 : #else
713 : int iX;
714 : #ifdef HAVE_SSE2
715 797213 : for (iX = 0; iX + 31 < nSamplesPerLine; iX += 32)
716 : {
717 757230 : auto in = _mm_loadu_si128(
718 757230 : (__m128i const *)(pabyInputLine + iX));
719 757230 : auto in2 = _mm_loadu_si128(
720 757230 : (__m128i const *)(pabyInputLine + iX + 16));
721 1514460 : auto out = _mm_loadu_si128(
722 757230 : (__m128i const *)(pabyOutputLine + iX));
723 757230 : auto out2 = _mm_loadu_si128(
724 757230 : (__m128i const *)(pabyOutputLine + iX + 16));
725 757230 : out = _mm_add_epi8(out, in);
726 757230 : out2 = _mm_add_epi8(out2, in2);
727 757230 : _mm_storeu_si128((__m128i *)(pabyOutputLine + iX), out);
728 757230 : _mm_storeu_si128((__m128i *)(pabyOutputLine + iX + 16),
729 : out2);
730 : }
731 : #endif
732 208901 : for (; iX < nSamplesPerLine; ++iX)
733 168918 : pabyOutputLine[iX] = static_cast<GByte>(
734 168918 : pabyOutputLine[iX] + pabyInputLine[iX]);
735 : #endif
736 : }
737 : }
738 : }
739 66756 : else if (nFilterType == 3)
740 : {
741 : // Filter type 3: Average
742 8447 : if (iY == 0)
743 : {
744 166 : for (int iX = 0; iX < nBands; ++iX)
745 : {
746 114 : pabyOutputLine[iX] = pabyInputLine[iX];
747 : }
748 1522 : for (int iX = nBands; iX < nSamplesPerLine; ++iX)
749 : {
750 1470 : pabyOutputLine[iX] = static_cast<GByte>(
751 1470 : pabyInputLine[iX] + pabyOutputLine[iX - nBands] / 2);
752 : }
753 : }
754 : else
755 : {
756 : #ifdef HAVE_SSE2
757 8395 : if (nBands == 3)
758 : {
759 : png_row_info row_info;
760 3800 : memset(&row_info, 0, sizeof(row_info));
761 3800 : row_info.rowbytes = nSamplesPerLine;
762 3800 : if (!abyTemp.empty())
763 3800 : abyLineUp = abyTemp;
764 : const GByte *const pabyOutputLineUp =
765 3800 : abyTemp.empty()
766 3800 : ? pabyOutputBuffer + (static_cast<size_t>(iY) - 1) *
767 0 : nSamplesPerLine
768 3800 : : abyLineUp.data();
769 :
770 3800 : gdal_png_read_filter_row_avg3_sse2(&row_info, pabyInputLine,
771 : pabyOutputLine,
772 : pabyOutputLineUp);
773 : }
774 4595 : else if (nBands == 4)
775 : {
776 : png_row_info row_info;
777 3902 : memset(&row_info, 0, sizeof(row_info));
778 3902 : row_info.rowbytes = nSamplesPerLine;
779 3902 : if (!abyTemp.empty())
780 3780 : abyLineUp = abyTemp;
781 : const GByte *const pabyOutputLineUp =
782 3902 : abyTemp.empty()
783 3902 : ? pabyOutputBuffer + (static_cast<size_t>(iY) - 1) *
784 122 : nSamplesPerLine
785 3780 : : abyLineUp.data();
786 :
787 3902 : gdal_png_read_filter_row_avg4_sse2(&row_info, pabyInputLine,
788 : pabyOutputLine,
789 : pabyOutputLineUp);
790 : }
791 : else
792 : #endif
793 693 : if (abyTemp.empty())
794 : {
795 222 : const GByte *CPL_RESTRICT pabyOutputLineUp =
796 : pabyOutputBuffer +
797 222 : (static_cast<size_t>(iY) - 1) * nSamplesPerLine;
798 444 : for (int iX = 0; iX < nBands; ++iX)
799 : {
800 222 : pabyOutputLine[iX] = static_cast<GByte>(
801 222 : pabyInputLine[iX] + pabyOutputLineUp[iX] / 2);
802 : }
803 39384 : for (int iX = nBands; iX < nSamplesPerLine; ++iX)
804 : {
805 39162 : pabyOutputLine[iX] = static_cast<GByte>(
806 39162 : pabyInputLine[iX] + (pabyOutputLine[iX - nBands] +
807 39162 : pabyOutputLineUp[iX]) /
808 : 2);
809 : }
810 : }
811 : else
812 : {
813 1410 : for (int iX = 0; iX < nBands; ++iX)
814 : {
815 939 : pabyOutputLine[iX] = static_cast<GByte>(
816 939 : pabyInputLine[iX] + pabyOutputLine[iX] / 2);
817 : }
818 15276 : for (int iX = nBands; iX < nSamplesPerLine; ++iX)
819 : {
820 14805 : pabyOutputLine[iX] = static_cast<GByte>(
821 14805 : pabyInputLine[iX] +
822 14805 : (pabyOutputLine[iX - nBands] + pabyOutputLine[iX]) /
823 : 2);
824 : }
825 : }
826 : }
827 : }
828 58309 : else if (nFilterType == 4)
829 : {
830 : // Filter type 4: Paeth
831 58309 : if (iY == 0)
832 : {
833 158620 : for (int iX = 0; iX < nSamplesPerLine; ++iX)
834 : {
835 158464 : GByte a = iX < nBands ? 0 : pabyOutputLine[iX - nBands];
836 158464 : pabyOutputLine[iX] =
837 158464 : static_cast<GByte>(pabyInputLine[iX] + a);
838 : }
839 : }
840 : else
841 : {
842 58153 : if (!abyTemp.empty())
843 16801 : abyLineUp = abyTemp;
844 : const GByte *const pabyOutputLineUp =
845 58153 : abyTemp.empty()
846 58153 : ? pabyOutputBuffer +
847 41352 : (static_cast<size_t>(iY) - 1) * nSamplesPerLine
848 16801 : : abyLineUp.data();
849 : #ifdef HAVE_SSE2
850 58153 : if (nBands == 3)
851 : {
852 : png_row_info row_info;
853 5189 : memset(&row_info, 0, sizeof(row_info));
854 5189 : row_info.rowbytes = nSamplesPerLine;
855 5189 : gdal_png_read_filter_row_paeth3_sse2(
856 : &row_info, pabyInputLine, pabyOutputLine,
857 : pabyOutputLineUp);
858 : }
859 52964 : else if (nBands == 4)
860 : {
861 : png_row_info row_info;
862 46637 : memset(&row_info, 0, sizeof(row_info));
863 46637 : row_info.rowbytes = nSamplesPerLine;
864 46637 : gdal_png_read_filter_row_paeth4_sse2(
865 : &row_info, pabyInputLine, pabyOutputLine,
866 : pabyOutputLineUp);
867 : }
868 : else
869 : #endif
870 : {
871 6327 : int iX = 0;
872 16110 : for (; iX < nBands; ++iX)
873 : {
874 9783 : GByte b = pabyOutputLineUp[iX];
875 9783 : pabyOutputLine[iX] =
876 9783 : static_cast<GByte>(pabyInputLine[iX] + b);
877 : }
878 1259130 : for (; iX < nSamplesPerLine; ++iX)
879 : {
880 1252800 : GByte a = pabyOutputLine[iX - nBands];
881 1252800 : GByte b = pabyOutputLineUp[iX];
882 1252800 : GByte c = pabyOutputLineUp[iX - nBands];
883 1252800 : int p_minus_a = b - c;
884 1252800 : int p_minus_b = a - c;
885 1252800 : int p_minus_c = p_minus_a + p_minus_b;
886 1252800 : int pa = std::abs(p_minus_a);
887 1252800 : int pb = std::abs(p_minus_b);
888 1252800 : int pc = std::abs(p_minus_c);
889 1252800 : if (pa <= pb && pa <= pc)
890 1084520 : pabyOutputLine[iX] =
891 1084520 : static_cast<GByte>(pabyInputLine[iX] + a);
892 168281 : else if (pb <= pc)
893 121338 : pabyOutputLine[iX] =
894 121338 : static_cast<GByte>(pabyInputLine[iX] + b);
895 : else
896 46943 : pabyOutputLine[iX] =
897 46943 : static_cast<GByte>(pabyInputLine[iX] + c);
898 : }
899 : }
900 : }
901 : }
902 : else
903 : {
904 0 : CPLError(CE_Failure, CPLE_NotSupported, "Invalid filter type %d",
905 : nFilterType);
906 0 : CPLFree(pabyZlibDecompressed);
907 0 : return CE_Failure;
908 : }
909 :
910 260855 : if (!abyTemp.empty())
911 : {
912 170982 : if (pSingleBuffer)
913 : {
914 151985 : GByte *pabyDest =
915 151985 : static_cast<GByte *>(pSingleBuffer) + iY * nLineSpace;
916 151985 : if (bCanUseDeinterleave)
917 : {
918 : // Cache friendly way for typical band interleaved case.
919 : void *apDestBuffers[4];
920 45007 : apDestBuffers[0] = pabyDest;
921 45007 : apDestBuffers[1] = pabyDest + nBandSpace;
922 45007 : apDestBuffers[2] = pabyDest + 2 * nBandSpace;
923 45007 : apDestBuffers[3] = pabyDest + 3 * nBandSpace;
924 45007 : GDALDeinterleave(pabyOutputLine, GDT_Byte, nBands,
925 45007 : apDestBuffers, GDT_Byte, nRasterXSize);
926 : }
927 106978 : else if (nPixelSpace <= nBands && nBandSpace > nBands)
928 : {
929 : // Cache friendly way for typical band interleaved case.
930 104454 : for (int iBand = 0; iBand < nBands; iBand++)
931 : {
932 69636 : GByte *pabyDest2 = pabyDest + iBand * nBandSpace;
933 69636 : const GByte *pabyScanline2 = pabyOutputLine + iBand;
934 69636 : GDALCopyWords(pabyScanline2, GDT_Byte, nBands,
935 : pabyDest2, GDT_Byte,
936 : static_cast<int>(nPixelSpace),
937 : nRasterXSize);
938 34818 : }
939 : }
940 : else
941 : {
942 : // Generic method
943 18895300 : for (int x = 0; x < nRasterXSize; ++x)
944 : {
945 38694900 : for (int iBand = 0; iBand < nBands; iBand++)
946 : {
947 19871700 : pabyDest[(x * nPixelSpace) + iBand * nBandSpace] =
948 19871700 : pabyOutputLine[x * nBands + iBand];
949 : }
950 : }
951 : }
952 : }
953 : else
954 : {
955 : GByte *apabyDestBuffers[4];
956 91759 : for (int iBand = 0; iBand < nBands; iBand++)
957 : {
958 72762 : apabyDestBuffers[iBand] =
959 72762 : static_cast<GByte *>(apabyBuffers[iBand]) +
960 72762 : iY * nRasterXSize;
961 : }
962 18997 : if (bCanUseDeinterleave)
963 : {
964 : // Cache friendly way for typical band interleaved case.
965 18413 : GDALDeinterleave(
966 : pabyOutputLine, GDT_Byte, nBands,
967 : reinterpret_cast<void **>(apabyDestBuffers), GDT_Byte,
968 18413 : nRasterXSize);
969 : }
970 : else
971 : {
972 : // Generic method
973 66624 : for (int x = 0; x < nRasterXSize; ++x)
974 : {
975 198120 : for (int iBand = 0; iBand < nBands; iBand++)
976 : {
977 132080 : apabyDestBuffers[iBand][x] =
978 132080 : pabyOutputLine[x * nBands + iBand];
979 : }
980 : }
981 : }
982 : }
983 : }
984 : }
985 :
986 2764 : CPLFree(pabyZlibDecompressed);
987 :
988 2764 : return CE_None;
989 : }
990 :
991 : #endif // ENABLE_WHOLE_IMAGE_OPTIMIZATION
992 :
993 : /************************************************************************/
994 : /* IsFullBandMap() */
995 : /************************************************************************/
996 :
997 2623 : static int IsFullBandMap(const int *panBandMap, int nBands)
998 : {
999 9269 : for (int i = 0; i < nBands; i++)
1000 : {
1001 6646 : if (panBandMap[i] != i + 1)
1002 0 : return FALSE;
1003 : }
1004 2623 : return TRUE;
1005 : }
1006 :
1007 : /************************************************************************/
1008 : /* IRasterIO() */
1009 : /************************************************************************/
1010 :
1011 4022 : CPLErr PNGDataset::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
1012 : int nXSize, int nYSize, void *pData, int nBufXSize,
1013 : int nBufYSize, GDALDataType eBufType,
1014 : int nBandCount, BANDMAP_TYPE panBandMap,
1015 : GSpacing nPixelSpace, GSpacing nLineSpace,
1016 : GSpacing nBandSpace,
1017 : GDALRasterIOExtraArg *psExtraArg)
1018 :
1019 : {
1020 : // Coverity says that we cannot pass a nullptr to IRasterIO.
1021 4022 : if (panBandMap == nullptr)
1022 : {
1023 0 : return CE_Failure;
1024 : }
1025 :
1026 4022 : if ((eRWFlag == GF_Read) && (nBandCount == nBands) && (nXOff == 0) &&
1027 2700 : (nYOff == 0) && (nXSize == nBufXSize) && (nXSize == nRasterXSize) &&
1028 2697 : (nYSize == nBufYSize) && (nYSize == nRasterYSize) &&
1029 2623 : (eBufType == GDT_Byte) &&
1030 2623 : (eBufType == GetRasterBand(1)->GetRasterDataType()) &&
1031 8044 : (pData != nullptr) && IsFullBandMap(panBandMap, nBands))
1032 : {
1033 : #ifdef ENABLE_WHOLE_IMAGE_OPTIMIZATION
1034 : // Below should work without SSE2, but the lack of optimized
1035 : // filters can sometimes make it slower than regular optimized libpng,
1036 : // so restrict to when SSE2 is available.
1037 :
1038 5238 : if (!bInterlaced && nBitDepth == 8 &&
1039 2615 : CPLTestBool(
1040 : CPLGetConfigOption("GDAL_PNG_WHOLE_IMAGE_OPTIM", "YES")))
1041 : {
1042 2607 : return LoadWholeImage(pData, nPixelSpace, nLineSpace, nBandSpace,
1043 2607 : nullptr);
1044 : }
1045 16 : else if (cpl::down_cast<PNGRasterBand *>(papoBands[0])->nBlockYSize > 1)
1046 : {
1047 : // Below code requires scanline access in
1048 : // PNGRasterBand::IReadBlock()
1049 : }
1050 : else
1051 : #endif // ENABLE_WHOLE_IMAGE_OPTIMIZATION
1052 :
1053 : // Pixel interleaved case.
1054 16 : if (nBandSpace == 1)
1055 : {
1056 302 : for (int y = 0; y < nYSize; ++y)
1057 : {
1058 300 : CPLErr tmpError = LoadScanline(y);
1059 300 : if (tmpError != CE_None)
1060 0 : return tmpError;
1061 300 : const GByte *pabyScanline =
1062 300 : pabyBuffer + (y - nBufferStartLine) * nBands * nXSize;
1063 300 : if (nPixelSpace == nBandSpace * nBandCount)
1064 : {
1065 150 : memcpy(&(reinterpret_cast<GByte *>(
1066 150 : pData)[(y * nLineSpace)]),
1067 : pabyScanline,
1068 150 : cpl::fits_on<int>(nBandCount * nXSize));
1069 : }
1070 : else
1071 : {
1072 24450 : for (int x = 0; x < nXSize; ++x)
1073 : {
1074 24300 : memcpy(
1075 : &(reinterpret_cast<GByte *>(
1076 24300 : pData)[(y * nLineSpace) +
1077 24300 : (x * nPixelSpace)]),
1078 24300 : (const GByte *)&(pabyScanline[x * nBandCount]),
1079 : nBandCount);
1080 : }
1081 : }
1082 : }
1083 2 : return CE_None;
1084 : }
1085 : else
1086 : {
1087 14 : const bool bCanUseDeinterleave =
1088 19 : (nBands == 3 || nBands == 4) && nPixelSpace == 1 &&
1089 : nBandSpace ==
1090 5 : static_cast<GSpacing>(nRasterXSize) * nRasterYSize;
1091 :
1092 966 : for (int y = 0; y < nYSize; ++y)
1093 : {
1094 952 : CPLErr tmpError = LoadScanline(y);
1095 952 : if (tmpError != CE_None)
1096 0 : return tmpError;
1097 952 : const GByte *pabyScanline =
1098 952 : pabyBuffer + (y - nBufferStartLine) * nBands * nXSize;
1099 952 : GByte *pabyDest =
1100 952 : static_cast<GByte *>(pData) + y * nLineSpace;
1101 952 : if (bCanUseDeinterleave)
1102 : {
1103 : // Cache friendly way for typical band interleaved case.
1104 : void *apDestBuffers[4];
1105 176 : apDestBuffers[0] = pabyDest;
1106 176 : apDestBuffers[1] = pabyDest + nBandSpace;
1107 176 : apDestBuffers[2] = pabyDest + 2 * nBandSpace;
1108 176 : apDestBuffers[3] = pabyDest + 3 * nBandSpace;
1109 176 : GDALDeinterleave(pabyScanline, GDT_Byte, nBands,
1110 176 : apDestBuffers, GDT_Byte, nRasterXSize);
1111 : }
1112 776 : else if (nPixelSpace <= nBands && nBandSpace > nBands)
1113 : {
1114 : // Cache friendly way for typical band interleaved case.
1115 39 : for (int iBand = 0; iBand < nBands; iBand++)
1116 : {
1117 26 : GByte *pabyDest2 = pabyDest + iBand * nBandSpace;
1118 26 : const GByte *pabyScanline2 = pabyScanline + iBand;
1119 26 : GDALCopyWords(pabyScanline2, GDT_Byte, nBands,
1120 : pabyDest2, GDT_Byte,
1121 : static_cast<int>(nPixelSpace),
1122 : nXSize);
1123 13 : }
1124 : }
1125 : else
1126 : {
1127 : // Generic method
1128 124884 : for (int x = 0; x < nXSize; ++x)
1129 : {
1130 248242 : for (int iBand = 0; iBand < nBands; iBand++)
1131 : {
1132 124121 : pabyDest[(x * nPixelSpace) +
1133 124121 : iBand * nBandSpace] =
1134 124121 : pabyScanline[x * nBands + iBand];
1135 : }
1136 : }
1137 : }
1138 : }
1139 14 : return CE_None;
1140 : }
1141 : }
1142 :
1143 1399 : return GDALPamDataset::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
1144 : pData, nBufXSize, nBufYSize, eBufType,
1145 : nBandCount, panBandMap, nPixelSpace,
1146 1399 : nLineSpace, nBandSpace, psExtraArg);
1147 : }
1148 :
1149 : /************************************************************************/
1150 : /* IRasterIO() */
1151 : /************************************************************************/
1152 :
1153 4293 : CPLErr PNGRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
1154 : int nXSize, int nYSize, void *pData,
1155 : int nBufXSize, int nBufYSize,
1156 : GDALDataType eBufType, GSpacing nPixelSpace,
1157 : GSpacing nLineSpace,
1158 : GDALRasterIOExtraArg *psExtraArg)
1159 :
1160 : {
1161 : #ifdef ENABLE_WHOLE_IMAGE_OPTIMIZATION
1162 4293 : auto poGDS = cpl::down_cast<PNGDataset *>(poDS);
1163 4293 : if ((eRWFlag == GF_Read) && (nXOff == 0) && (nYOff == 0) &&
1164 662 : (nXSize == nBufXSize) && (nXSize == nRasterXSize) &&
1165 637 : (nYSize == nBufYSize) && (nYSize == nRasterYSize) &&
1166 332 : (eBufType == GDT_Byte) && (eBufType == eDataType))
1167 : {
1168 332 : bool bBlockAlreadyLoaded = false;
1169 332 : if (nBlockYSize > 1)
1170 : {
1171 194 : auto poBlock = TryGetLockedBlockRef(0, 0);
1172 194 : if (poBlock != nullptr)
1173 : {
1174 146 : bBlockAlreadyLoaded = poBlock->GetDataRef() != pData;
1175 146 : poBlock->DropLock();
1176 : }
1177 : }
1178 :
1179 332 : if (bBlockAlreadyLoaded)
1180 : {
1181 : // will got to general case
1182 : }
1183 52 : else if (poGDS->nBands == 1 && !poGDS->bInterlaced &&
1184 387 : poGDS->nBitDepth == 8 &&
1185 52 : CPLTestBool(
1186 : CPLGetConfigOption("GDAL_PNG_WHOLE_IMAGE_OPTIM", "YES")))
1187 : {
1188 46 : return poGDS->LoadWholeImage(pData, nPixelSpace, nLineSpace, 0,
1189 46 : nullptr);
1190 : }
1191 237 : else if (nBlockYSize > 1)
1192 : {
1193 : void *apabyBuffers[4];
1194 112 : GDALRasterBlock *apoBlocks[4] = {nullptr, nullptr, nullptr,
1195 : nullptr};
1196 112 : CPLErr eErr = CE_None;
1197 112 : bool bNeedToUseDefaultCase = true;
1198 512 : for (int i = 0; i < poGDS->nBands; ++i)
1199 : {
1200 400 : if (i + 1 == nBand && nPixelSpace == 1 &&
1201 112 : nLineSpace == nRasterXSize)
1202 : {
1203 110 : bNeedToUseDefaultCase = false;
1204 110 : apabyBuffers[i] = pData;
1205 : }
1206 : else
1207 : {
1208 290 : apoBlocks[i] =
1209 290 : poGDS->GetRasterBand(i + 1)->GetLockedBlockRef(0, 0,
1210 290 : TRUE);
1211 290 : apabyBuffers[i] =
1212 290 : apoBlocks[i] ? apoBlocks[i]->GetDataRef() : nullptr;
1213 290 : if (apabyBuffers[i] == nullptr)
1214 0 : eErr = CE_Failure;
1215 : }
1216 : }
1217 112 : if (eErr == CE_None)
1218 : {
1219 112 : eErr = poGDS->LoadWholeImage(nullptr, 0, 0, 0, apabyBuffers);
1220 : }
1221 512 : for (int i = 0; i < poGDS->nBands; ++i)
1222 : {
1223 400 : if (apoBlocks[i])
1224 290 : apoBlocks[i]->DropLock();
1225 : }
1226 112 : if (eErr != CE_None || !bNeedToUseDefaultCase)
1227 110 : return eErr;
1228 : }
1229 : }
1230 : #endif
1231 4137 : return GDALPamRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
1232 : pData, nBufXSize, nBufYSize, eBufType,
1233 4137 : nPixelSpace, nLineSpace, psExtraArg);
1234 : }
1235 :
1236 : /************************************************************************/
1237 : /* GetGeoTransform() */
1238 : /************************************************************************/
1239 :
1240 119 : CPLErr PNGDataset::GetGeoTransform(double *padfTransform)
1241 :
1242 : {
1243 119 : LoadWorldFile();
1244 :
1245 119 : if (bGeoTransformValid)
1246 : {
1247 3 : memcpy(padfTransform, adfGeoTransform, sizeof(double) * 6);
1248 3 : return CE_None;
1249 : }
1250 :
1251 116 : return GDALPamDataset::GetGeoTransform(padfTransform);
1252 : }
1253 :
1254 : /************************************************************************/
1255 : /* FlushCache() */
1256 : /* */
1257 : /* We override this so we can also flush out local TIFF strip */
1258 : /* cache if need be. */
1259 : /************************************************************************/
1260 :
1261 7237 : CPLErr PNGDataset::FlushCache(bool bAtClosing)
1262 :
1263 : {
1264 7237 : const CPLErr eErr = GDALPamDataset::FlushCache(bAtClosing);
1265 :
1266 7237 : if (pabyBuffer != nullptr)
1267 : {
1268 229 : CPLFree(pabyBuffer);
1269 229 : pabyBuffer = nullptr;
1270 229 : nBufferStartLine = 0;
1271 229 : nBufferLines = 0;
1272 : }
1273 7237 : return eErr;
1274 : }
1275 :
1276 : #ifdef DISABLE_CRC_CHECK
1277 : /************************************************************************/
1278 : /* PNGDatasetDisableCRCCheck() */
1279 : /************************************************************************/
1280 :
1281 : static void PNGDatasetDisableCRCCheck(png_structp hPNG)
1282 : {
1283 : hPNG->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
1284 : hPNG->flags |= PNG_FLAG_CRC_CRITICAL_IGNORE;
1285 :
1286 : hPNG->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
1287 : hPNG->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
1288 : }
1289 : #endif
1290 :
1291 : /************************************************************************/
1292 : /* Restart() */
1293 : /* */
1294 : /* Restart reading from the beginning of the file. */
1295 : /************************************************************************/
1296 :
1297 16 : void PNGDataset::Restart()
1298 :
1299 : {
1300 16 : png_destroy_read_struct(&hPNG, &psPNGInfo, nullptr);
1301 :
1302 16 : hPNG =
1303 16 : png_create_read_struct(PNG_LIBPNG_VER_STRING, this, nullptr, nullptr);
1304 :
1305 : #ifdef DISABLE_CRC_CHECK
1306 : PNGDatasetDisableCRCCheck(hPNG);
1307 : #endif
1308 :
1309 16 : png_set_error_fn(hPNG, &sSetJmpContext, png_gdal_error, png_gdal_warning);
1310 16 : if (setjmp(sSetJmpContext) != 0)
1311 0 : return;
1312 :
1313 16 : psPNGInfo = png_create_info_struct(hPNG);
1314 :
1315 16 : VSIFSeekL(fpImage, 0, SEEK_SET);
1316 16 : png_set_read_fn(hPNG, fpImage, png_vsi_read_data);
1317 16 : png_read_info(hPNG, psPNGInfo);
1318 :
1319 16 : if (nBitDepth < 8)
1320 0 : png_set_packing(hPNG);
1321 :
1322 16 : nLastLineRead = -1;
1323 : }
1324 :
1325 : /************************************************************************/
1326 : /* safe_png_read_image() */
1327 : /************************************************************************/
1328 :
1329 13 : static bool safe_png_read_image(png_structp hPNG, png_bytep *png_rows,
1330 : jmp_buf sSetJmpContext)
1331 : {
1332 13 : if (setjmp(sSetJmpContext) != 0)
1333 0 : return false;
1334 13 : png_read_image(hPNG, png_rows);
1335 13 : return true;
1336 : }
1337 :
1338 : /************************************************************************/
1339 : /* LoadInterlacedChunk() */
1340 : /************************************************************************/
1341 :
1342 13 : CPLErr PNGDataset::LoadInterlacedChunk(int iLine)
1343 :
1344 : {
1345 : const int nPixelOffset =
1346 13 : (nBitDepth == 16) ? 2 * GetRasterCount() : GetRasterCount();
1347 :
1348 : // What is the biggest chunk we can safely operate on?
1349 13 : constexpr int MAX_PNG_CHUNK_BYTES = 100000000;
1350 :
1351 : int nMaxChunkLines =
1352 13 : std::max(1, MAX_PNG_CHUNK_BYTES / (nPixelOffset * GetRasterXSize()));
1353 :
1354 13 : if (nMaxChunkLines > GetRasterYSize())
1355 13 : nMaxChunkLines = GetRasterYSize();
1356 :
1357 : // Allocate chunk buffer if we don't already have it from a previous
1358 : // request.
1359 13 : nBufferLines = nMaxChunkLines;
1360 13 : if (nMaxChunkLines + iLine > GetRasterYSize())
1361 0 : nBufferStartLine = GetRasterYSize() - nMaxChunkLines;
1362 : else
1363 13 : nBufferStartLine = iLine;
1364 :
1365 13 : if (pabyBuffer == nullptr)
1366 : {
1367 13 : pabyBuffer = reinterpret_cast<GByte *>(VSI_MALLOC3_VERBOSE(
1368 : nPixelOffset, GetRasterXSize(), nMaxChunkLines));
1369 :
1370 13 : if (pabyBuffer == nullptr)
1371 : {
1372 0 : return CE_Failure;
1373 : }
1374 : #ifdef notdef
1375 : if (nMaxChunkLines < GetRasterYSize())
1376 : CPLDebug("PNG",
1377 : "Interlaced file being handled in %d line chunks.\n"
1378 : "Performance is likely to be quite poor.",
1379 : nMaxChunkLines);
1380 : #endif
1381 : }
1382 :
1383 : // Do we need to restart reading? We do this if we aren't on the first
1384 : // attempt to read the image.
1385 13 : if (nLastLineRead != -1)
1386 : {
1387 0 : Restart();
1388 : }
1389 :
1390 : // Allocate and populate rows array. We create a row for each row in the
1391 : // image but use our dummy line for rows not in the target window.
1392 : png_bytep dummy_row = reinterpret_cast<png_bytep>(
1393 13 : CPLMalloc(cpl::fits_on<int>(nPixelOffset * GetRasterXSize())));
1394 : png_bytep *png_rows = reinterpret_cast<png_bytep *>(
1395 13 : CPLMalloc(sizeof(png_bytep) * GetRasterYSize()));
1396 :
1397 1833 : for (int i = 0; i < GetRasterYSize(); i++)
1398 : {
1399 1820 : if (i >= nBufferStartLine && i < nBufferStartLine + nBufferLines)
1400 3640 : png_rows[i] = pabyBuffer + (i - nBufferStartLine) * nPixelOffset *
1401 1820 : GetRasterXSize();
1402 : else
1403 0 : png_rows[i] = dummy_row;
1404 : }
1405 :
1406 13 : bool bRet = safe_png_read_image(hPNG, png_rows, sSetJmpContext);
1407 :
1408 : // Do swap on LSB machines. 16-bit PNG data is stored in MSB format.
1409 : #ifdef CPL_LSB
1410 13 : if (bRet && nBitDepth == 16)
1411 : {
1412 21 : for (int i = 0; i < GetRasterYSize(); i++)
1413 : {
1414 20 : if (i >= nBufferStartLine && i < nBufferStartLine + nBufferLines)
1415 : {
1416 20 : GDALSwapWords(png_rows[i], 2,
1417 20 : GetRasterXSize() * GetRasterCount(), 2);
1418 : }
1419 : }
1420 : }
1421 : #endif
1422 :
1423 13 : CPLFree(png_rows);
1424 13 : CPLFree(dummy_row);
1425 13 : if (!bRet)
1426 0 : return CE_Failure;
1427 :
1428 13 : nLastLineRead = nBufferStartLine + nBufferLines - 1;
1429 :
1430 13 : return CE_None;
1431 : }
1432 :
1433 : /************************************************************************/
1434 : /* safe_png_read_rows() */
1435 : /************************************************************************/
1436 :
1437 12207 : static bool safe_png_read_rows(png_structp hPNG, png_bytep row,
1438 : jmp_buf sSetJmpContext)
1439 : {
1440 12207 : if (setjmp(sSetJmpContext) != 0)
1441 2 : return false;
1442 12207 : png_read_rows(hPNG, &row, nullptr, 1);
1443 12205 : return true;
1444 : }
1445 :
1446 : /************************************************************************/
1447 : /* LoadScanline() */
1448 : /************************************************************************/
1449 :
1450 20194 : CPLErr PNGDataset::LoadScanline(int nLine)
1451 :
1452 : {
1453 20194 : CPLAssert(nLine >= 0 && nLine < GetRasterYSize());
1454 :
1455 20194 : if (nLine >= nBufferStartLine && nLine < nBufferStartLine + nBufferLines)
1456 8094 : return CE_None;
1457 :
1458 : const int nPixelOffset =
1459 12100 : (nBitDepth == 16) ? 2 * GetRasterCount() : GetRasterCount();
1460 :
1461 : // If the file is interlaced, we load the entire image into memory using the
1462 : // high-level API.
1463 12100 : if (bInterlaced)
1464 13 : return LoadInterlacedChunk(nLine);
1465 :
1466 : // Ensure we have space allocated for one scanline.
1467 12087 : if (pabyBuffer == nullptr)
1468 216 : pabyBuffer = reinterpret_cast<GByte *>(
1469 216 : CPLMalloc(cpl::fits_on<int>(nPixelOffset * GetRasterXSize())));
1470 :
1471 : // Otherwise we just try to read the requested row. Do we need to rewind and
1472 : // start over?
1473 12087 : if (nLine <= nLastLineRead)
1474 : {
1475 16 : Restart();
1476 : }
1477 :
1478 : // Read till we get the desired row.
1479 12087 : png_bytep row = pabyBuffer;
1480 12087 : const GUInt32 nErrorCounter = CPLGetErrorCounter();
1481 24292 : while (nLine > nLastLineRead)
1482 : {
1483 12207 : if (!safe_png_read_rows(hPNG, row, sSetJmpContext))
1484 : {
1485 2 : CPLError(CE_Failure, CPLE_AppDefined,
1486 : "Error while reading row %d%s", nLine,
1487 2 : (nErrorCounter != CPLGetErrorCounter())
1488 2 : ? CPLSPrintf(": %s", CPLGetLastErrorMsg())
1489 : : "");
1490 2 : return CE_Failure;
1491 : }
1492 12205 : nLastLineRead++;
1493 : }
1494 :
1495 12085 : nBufferStartLine = nLine;
1496 12085 : nBufferLines = 1;
1497 :
1498 : // Do swap on LSB machines. 16-bit PNG data is stored in MSB format.
1499 : #ifdef CPL_LSB
1500 12085 : if (nBitDepth == 16)
1501 10336 : GDALSwapWords(row, 2, GetRasterXSize() * GetRasterCount(), 2);
1502 : #endif
1503 :
1504 12085 : return CE_None;
1505 : }
1506 :
1507 : /************************************************************************/
1508 : /* CollectMetadata() */
1509 : /* */
1510 : /* We normally do this after reading up to the image, but be */
1511 : /* forewarned: we can miss text chunks this way. */
1512 : /* */
1513 : /* We turn each PNG text chunk into one metadata item. It */
1514 : /* might be nice to preserve language information though we */
1515 : /* don't try to now. */
1516 : /************************************************************************/
1517 :
1518 7218 : void PNGDataset::CollectMetadata()
1519 :
1520 : {
1521 7218 : if (nBitDepth < 8)
1522 : {
1523 16 : for (int iBand = 0; iBand < nBands; iBand++)
1524 : {
1525 16 : GetRasterBand(iBand + 1)->SetMetadataItem(
1526 16 : "NBITS", CPLString().Printf("%d", nBitDepth),
1527 8 : "IMAGE_STRUCTURE");
1528 : }
1529 : }
1530 :
1531 : int nTextCount;
1532 : png_textp text_ptr;
1533 7218 : if (png_get_text(hPNG, psPNGInfo, &text_ptr, &nTextCount) == 0)
1534 7212 : return;
1535 :
1536 14 : for (int iText = 0; iText < nTextCount; iText++)
1537 : {
1538 8 : char *pszTag = CPLStrdup(text_ptr[iText].key);
1539 :
1540 66 : for (int i = 0; pszTag[i] != '\0'; i++)
1541 : {
1542 58 : if (pszTag[i] == ' ' || pszTag[i] == '=' || pszTag[i] == ':')
1543 0 : pszTag[i] = '_';
1544 : }
1545 :
1546 8 : GDALDataset::SetMetadataItem(pszTag, text_ptr[iText].text);
1547 8 : CPLFree(pszTag);
1548 : }
1549 : }
1550 :
1551 : /************************************************************************/
1552 : /* CollectXMPMetadata() */
1553 : /************************************************************************/
1554 :
1555 : // See §2.1.5 of
1556 : // http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/xmp/pdfs/XMPSpecificationPart3.pdf.
1557 :
1558 13 : void PNGDataset::CollectXMPMetadata()
1559 :
1560 : {
1561 13 : if (fpImage == nullptr || bHasReadXMPMetadata)
1562 0 : return;
1563 :
1564 : // Save current position to avoid disturbing PNG stream decoding.
1565 13 : const vsi_l_offset nCurOffset = VSIFTellL(fpImage);
1566 :
1567 13 : vsi_l_offset nOffset = 8;
1568 13 : VSIFSeekL(fpImage, nOffset, SEEK_SET);
1569 :
1570 : // Loop over chunks.
1571 : while (true)
1572 : {
1573 : int nLength;
1574 :
1575 74 : if (VSIFReadL(&nLength, 4, 1, fpImage) != 1)
1576 0 : break;
1577 74 : nOffset += 4;
1578 74 : CPL_MSBPTR32(&nLength);
1579 74 : if (nLength <= 0)
1580 12 : break;
1581 :
1582 : char pszChunkType[5];
1583 62 : if (VSIFReadL(pszChunkType, 4, 1, fpImage) != 1)
1584 0 : break;
1585 62 : nOffset += 4;
1586 62 : pszChunkType[4] = 0;
1587 :
1588 62 : if (strcmp(pszChunkType, "iTXt") == 0 && nLength > 22 &&
1589 : // Does not make sense to have a XMP content larger than 10 MB
1590 : // (XMP in JPEG must fit in 65 KB...)
1591 1 : nLength < 10 * 1024 * 1024)
1592 : {
1593 1 : char *pszContent = reinterpret_cast<char *>(VSIMalloc(nLength + 1));
1594 1 : if (pszContent == nullptr)
1595 0 : break;
1596 1 : if (VSIFReadL(pszContent, nLength, 1, fpImage) != 1)
1597 : {
1598 0 : VSIFree(pszContent);
1599 0 : break;
1600 : }
1601 1 : nOffset += nLength;
1602 1 : pszContent[nLength] = '\0';
1603 1 : if (memcmp(pszContent, "XML:com.adobe.xmp\0\0\0\0\0", 22) == 0)
1604 : {
1605 : // Avoid setting the PAM dirty bit just for that.
1606 1 : const int nOldPamFlags = nPamFlags;
1607 :
1608 1 : char *apszMDList[2] = {pszContent + 22, nullptr};
1609 1 : SetMetadata(apszMDList, "xml:XMP");
1610 :
1611 : // cppcheck-suppress redundantAssignment
1612 1 : nPamFlags = nOldPamFlags;
1613 :
1614 1 : VSIFree(pszContent);
1615 :
1616 1 : break;
1617 : }
1618 : else
1619 : {
1620 0 : VSIFree(pszContent);
1621 0 : }
1622 : }
1623 : else
1624 : {
1625 61 : nOffset += nLength;
1626 61 : VSIFSeekL(fpImage, nOffset, SEEK_SET);
1627 : }
1628 :
1629 61 : nOffset += 4;
1630 : int nCRC;
1631 61 : if (VSIFReadL(&nCRC, 4, 1, fpImage) != 1)
1632 0 : break;
1633 61 : }
1634 :
1635 13 : VSIFSeekL(fpImage, nCurOffset, SEEK_SET);
1636 :
1637 13 : bHasReadXMPMetadata = TRUE;
1638 : }
1639 :
1640 : /************************************************************************/
1641 : /* LoadICCProfile() */
1642 : /************************************************************************/
1643 :
1644 24 : void PNGDataset::LoadICCProfile()
1645 : {
1646 24 : if (hPNG == nullptr || bHasReadICCMetadata)
1647 7 : return;
1648 24 : bHasReadICCMetadata = TRUE;
1649 :
1650 : png_charp pszProfileName;
1651 : png_uint_32 nProfileLength;
1652 : png_bytep pProfileData;
1653 : int nCompressionType;
1654 :
1655 : // Avoid setting the PAM dirty bit just for that.
1656 24 : int nOldPamFlags = nPamFlags;
1657 :
1658 24 : if (png_get_iCCP(hPNG, psPNGInfo, &pszProfileName, &nCompressionType,
1659 24 : &pProfileData, &nProfileLength) != 0)
1660 : {
1661 : // Escape the profile.
1662 : char *pszBase64Profile =
1663 5 : CPLBase64Encode(static_cast<int>(nProfileLength),
1664 : reinterpret_cast<const GByte *>(pProfileData));
1665 :
1666 : // Set ICC profile metadata.
1667 5 : SetMetadataItem("SOURCE_ICC_PROFILE", pszBase64Profile,
1668 5 : "COLOR_PROFILE");
1669 5 : SetMetadataItem("SOURCE_ICC_PROFILE_NAME", pszProfileName,
1670 5 : "COLOR_PROFILE");
1671 :
1672 5 : nPamFlags = nOldPamFlags;
1673 :
1674 5 : CPLFree(pszBase64Profile);
1675 :
1676 5 : return;
1677 : }
1678 :
1679 : int nsRGBIntent;
1680 19 : if (png_get_sRGB(hPNG, psPNGInfo, &nsRGBIntent) != 0)
1681 : {
1682 2 : SetMetadataItem("SOURCE_ICC_PROFILE_NAME", "sRGB", "COLOR_PROFILE");
1683 :
1684 2 : nPamFlags = nOldPamFlags;
1685 :
1686 2 : return;
1687 : }
1688 :
1689 : double dfGamma;
1690 17 : bool bGammaAvailable = false;
1691 17 : if (png_get_valid(hPNG, psPNGInfo, PNG_INFO_gAMA))
1692 : {
1693 6 : bGammaAvailable = true;
1694 :
1695 6 : png_get_gAMA(hPNG, psPNGInfo, &dfGamma);
1696 :
1697 6 : SetMetadataItem("PNG_GAMMA", CPLString().Printf("%.9f", dfGamma),
1698 6 : "COLOR_PROFILE");
1699 : }
1700 :
1701 : // Check that both cHRM and gAMA are available.
1702 17 : if (bGammaAvailable && png_get_valid(hPNG, psPNGInfo, PNG_INFO_cHRM))
1703 : {
1704 : double dfaWhitepoint[2];
1705 : double dfaCHR[6];
1706 :
1707 4 : png_get_cHRM(hPNG, psPNGInfo, &dfaWhitepoint[0], &dfaWhitepoint[1],
1708 : &dfaCHR[0], &dfaCHR[1], &dfaCHR[2], &dfaCHR[3], &dfaCHR[4],
1709 : &dfaCHR[5]);
1710 :
1711 : // Set all the colorimetric metadata.
1712 4 : SetMetadataItem(
1713 : "SOURCE_PRIMARIES_RED",
1714 8 : CPLString().Printf("%.9f, %.9f, 1.0", dfaCHR[0], dfaCHR[1]),
1715 4 : "COLOR_PROFILE");
1716 4 : SetMetadataItem(
1717 : "SOURCE_PRIMARIES_GREEN",
1718 8 : CPLString().Printf("%.9f, %.9f, 1.0", dfaCHR[2], dfaCHR[3]),
1719 4 : "COLOR_PROFILE");
1720 4 : SetMetadataItem(
1721 : "SOURCE_PRIMARIES_BLUE",
1722 8 : CPLString().Printf("%.9f, %.9f, 1.0", dfaCHR[4], dfaCHR[5]),
1723 4 : "COLOR_PROFILE");
1724 :
1725 4 : SetMetadataItem("SOURCE_WHITEPOINT",
1726 4 : CPLString().Printf("%.9f, %.9f, 1.0", dfaWhitepoint[0],
1727 4 : dfaWhitepoint[1]),
1728 4 : "COLOR_PROFILE");
1729 : }
1730 :
1731 17 : nPamFlags = nOldPamFlags;
1732 : }
1733 :
1734 : /************************************************************************/
1735 : /* GetMetadataDomainList() */
1736 : /************************************************************************/
1737 :
1738 3 : char **PNGDataset::GetMetadataDomainList()
1739 : {
1740 3 : return BuildMetadataDomainList(GDALPamDataset::GetMetadataDomainList(),
1741 3 : TRUE, "xml:XMP", "COLOR_PROFILE", nullptr);
1742 : }
1743 :
1744 : /************************************************************************/
1745 : /* GetMetadata() */
1746 : /************************************************************************/
1747 :
1748 107 : char **PNGDataset::GetMetadata(const char *pszDomain)
1749 : {
1750 107 : if (fpImage == nullptr)
1751 0 : return nullptr;
1752 107 : if (eAccess == GA_ReadOnly && !bHasReadXMPMetadata &&
1753 77 : pszDomain != nullptr && EQUAL(pszDomain, "xml:XMP"))
1754 13 : CollectXMPMetadata();
1755 107 : if (eAccess == GA_ReadOnly && !bHasReadICCMetadata &&
1756 47 : pszDomain != nullptr && EQUAL(pszDomain, "COLOR_PROFILE"))
1757 13 : LoadICCProfile();
1758 107 : return GDALPamDataset::GetMetadata(pszDomain);
1759 : }
1760 :
1761 : /************************************************************************/
1762 : /* GetMetadataItem() */
1763 : /************************************************************************/
1764 700 : const char *PNGDataset::GetMetadataItem(const char *pszName,
1765 : const char *pszDomain)
1766 : {
1767 700 : if (eAccess == GA_ReadOnly && !bHasReadICCMetadata &&
1768 176 : pszDomain != nullptr && EQUAL(pszDomain, "COLOR_PROFILE"))
1769 11 : LoadICCProfile();
1770 700 : return GDALPamDataset::GetMetadataItem(pszName, pszDomain);
1771 : }
1772 :
1773 : /************************************************************************/
1774 : /* Open() */
1775 : /************************************************************************/
1776 :
1777 7220 : GDALDataset *PNGDataset::Open(GDALOpenInfo *poOpenInfo)
1778 :
1779 : {
1780 : #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1781 : // During fuzzing, do not use Identify to reject crazy content.
1782 7220 : if (!PNGDriverIdentify(poOpenInfo))
1783 1 : return nullptr;
1784 : #else
1785 : if (poOpenInfo->fpL == nullptr)
1786 : return nullptr;
1787 : #endif
1788 :
1789 7219 : if (poOpenInfo->eAccess == GA_Update)
1790 : {
1791 0 : CPLError(CE_Failure, CPLE_NotSupported,
1792 : "The PNG driver does not support update access to existing"
1793 : " datasets.\n");
1794 0 : return nullptr;
1795 : }
1796 :
1797 : // Create a corresponding GDALDataset.
1798 7219 : PNGDataset *poDS = new PNGDataset();
1799 7219 : return OpenStage2(poOpenInfo, poDS);
1800 : }
1801 :
1802 7219 : GDALDataset *PNGDataset::OpenStage2(GDALOpenInfo *poOpenInfo, PNGDataset *&poDS)
1803 :
1804 : {
1805 7219 : poDS->fpImage = poOpenInfo->fpL;
1806 7219 : poOpenInfo->fpL = nullptr;
1807 7219 : poDS->eAccess = poOpenInfo->eAccess;
1808 :
1809 14438 : poDS->hPNG =
1810 7219 : png_create_read_struct(PNG_LIBPNG_VER_STRING, poDS, nullptr, nullptr);
1811 7219 : if (poDS->hPNG == nullptr)
1812 : {
1813 0 : int version = static_cast<int>(png_access_version_number());
1814 0 : CPLError(CE_Failure, CPLE_NotSupported,
1815 : "The PNG driver failed to access libpng with version '%s',"
1816 : " library is actually version '%d'.\n",
1817 : PNG_LIBPNG_VER_STRING, version);
1818 0 : delete poDS;
1819 0 : return nullptr;
1820 : }
1821 :
1822 : #ifdef DISABLE_CRC_CHECK
1823 : PNGDatasetDisableCRCCheck(poDS->hPNG);
1824 : #endif
1825 :
1826 7219 : poDS->psPNGInfo = png_create_info_struct(poDS->hPNG);
1827 :
1828 : // Set up error handling.
1829 7219 : png_set_error_fn(poDS->hPNG, &poDS->sSetJmpContext, png_gdal_error,
1830 : png_gdal_warning);
1831 :
1832 7219 : if (setjmp(poDS->sSetJmpContext) != 0)
1833 : {
1834 1 : delete poDS;
1835 1 : return nullptr;
1836 : }
1837 :
1838 : // Read pre-image data after ensuring the file is rewound.
1839 : // We should likely do a setjmp() here.
1840 :
1841 7219 : png_set_read_fn(poDS->hPNG, poDS->fpImage, png_vsi_read_data);
1842 7219 : png_read_info(poDS->hPNG, poDS->psPNGInfo);
1843 :
1844 : // Capture some information from the file that is of interest.
1845 7218 : poDS->nRasterXSize =
1846 7218 : static_cast<int>(png_get_image_width(poDS->hPNG, poDS->psPNGInfo));
1847 7218 : poDS->nRasterYSize =
1848 7218 : static_cast<int>(png_get_image_height(poDS->hPNG, poDS->psPNGInfo));
1849 :
1850 7218 : poDS->nBands = png_get_channels(poDS->hPNG, poDS->psPNGInfo);
1851 7218 : poDS->nBitDepth = png_get_bit_depth(poDS->hPNG, poDS->psPNGInfo);
1852 7218 : poDS->bInterlaced = png_get_interlace_type(poDS->hPNG, poDS->psPNGInfo) !=
1853 : PNG_INTERLACE_NONE;
1854 :
1855 7218 : poDS->nColorType = png_get_color_type(poDS->hPNG, poDS->psPNGInfo);
1856 :
1857 7218 : if (poDS->nColorType == PNG_COLOR_TYPE_PALETTE && poDS->nBands > 1)
1858 : {
1859 0 : CPLDebug("GDAL",
1860 : "PNG Driver got %d from png_get_channels(),\n"
1861 : "but this kind of image (paletted) can only have one band.\n"
1862 : "Correcting and continuing, but this may indicate a bug!",
1863 : poDS->nBands);
1864 0 : poDS->nBands = 1;
1865 : }
1866 :
1867 : // We want to treat 1-, 2-, and 4-bit images as eight bit. This call causes
1868 : // libpng to unpack the image.
1869 7218 : if (poDS->nBitDepth < 8)
1870 8 : png_set_packing(poDS->hPNG);
1871 :
1872 : // Create band information objects.
1873 27086 : for (int iBand = 0; iBand < poDS->nBands; iBand++)
1874 19868 : poDS->SetBand(iBand + 1, new PNGRasterBand(poDS, iBand + 1));
1875 :
1876 : // Is there a palette? Note: we should also read back and apply
1877 : // transparency values if available.
1878 7218 : if (poDS->nColorType == PNG_COLOR_TYPE_PALETTE)
1879 : {
1880 378 : png_color *pasPNGPalette = nullptr;
1881 378 : int nColorCount = 0;
1882 :
1883 378 : if (png_get_PLTE(poDS->hPNG, poDS->psPNGInfo, &pasPNGPalette,
1884 378 : &nColorCount) == 0)
1885 0 : nColorCount = 0;
1886 :
1887 378 : unsigned char *trans = nullptr;
1888 378 : png_color_16 *trans_values = nullptr;
1889 378 : int num_trans = 0;
1890 378 : png_get_tRNS(poDS->hPNG, poDS->psPNGInfo, &trans, &num_trans,
1891 : &trans_values);
1892 :
1893 378 : poDS->poColorTable = new GDALColorTable();
1894 :
1895 : GDALColorEntry oEntry;
1896 378 : int nNoDataIndex = -1;
1897 24724 : for (int iColor = nColorCount - 1; iColor >= 0; iColor--)
1898 : {
1899 24346 : oEntry.c1 = pasPNGPalette[iColor].red;
1900 24346 : oEntry.c2 = pasPNGPalette[iColor].green;
1901 24346 : oEntry.c3 = pasPNGPalette[iColor].blue;
1902 :
1903 24346 : if (iColor < num_trans)
1904 : {
1905 3309 : oEntry.c4 = trans[iColor];
1906 3309 : if (oEntry.c4 == 0)
1907 : {
1908 265 : if (nNoDataIndex == -1)
1909 265 : nNoDataIndex = iColor;
1910 : else
1911 0 : nNoDataIndex = -2;
1912 : }
1913 : }
1914 : else
1915 21037 : oEntry.c4 = 255;
1916 :
1917 24346 : poDS->poColorTable->SetColorEntry(iColor, &oEntry);
1918 : }
1919 :
1920 : // Special hack to use an index as the no data value, as long as it is
1921 : // the only transparent color in the palette.
1922 378 : if (nNoDataIndex > -1)
1923 : {
1924 265 : poDS->GetRasterBand(1)->SetNoDataValue(nNoDataIndex);
1925 : }
1926 : }
1927 :
1928 : // Check for transparency values in greyscale images.
1929 7218 : if (poDS->nColorType == PNG_COLOR_TYPE_GRAY)
1930 : {
1931 398 : png_color_16 *trans_values = nullptr;
1932 : unsigned char *trans;
1933 : int num_trans;
1934 :
1935 398 : if (png_get_tRNS(poDS->hPNG, poDS->psPNGInfo, &trans, &num_trans,
1936 403 : &trans_values) != 0 &&
1937 5 : trans_values != nullptr)
1938 : {
1939 5 : poDS->GetRasterBand(1)->SetNoDataValue(trans_values->gray);
1940 : }
1941 : }
1942 :
1943 : // Check for nodata color for RGB images.
1944 7218 : if (poDS->nColorType == PNG_COLOR_TYPE_RGB)
1945 : {
1946 5016 : png_color_16 *trans_values = nullptr;
1947 : unsigned char *trans;
1948 : int num_trans;
1949 :
1950 5016 : if (png_get_tRNS(poDS->hPNG, poDS->psPNGInfo, &trans, &num_trans,
1951 5020 : &trans_values) != 0 &&
1952 4 : trans_values != nullptr)
1953 : {
1954 8 : CPLString oNDValue;
1955 :
1956 4 : oNDValue.Printf("%d %d %d", trans_values->red, trans_values->green,
1957 4 : trans_values->blue);
1958 4 : poDS->SetMetadataItem("NODATA_VALUES", oNDValue.c_str());
1959 :
1960 4 : poDS->GetRasterBand(1)->SetNoDataValue(trans_values->red);
1961 4 : poDS->GetRasterBand(2)->SetNoDataValue(trans_values->green);
1962 4 : poDS->GetRasterBand(3)->SetNoDataValue(trans_values->blue);
1963 : }
1964 : }
1965 :
1966 : // Extract any text chunks as "metadata."
1967 7218 : poDS->CollectMetadata();
1968 :
1969 : // More metadata.
1970 7218 : if (poDS->nBands > 1)
1971 : {
1972 6442 : poDS->SetMetadataItem("INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE");
1973 : }
1974 :
1975 : // Initialize any PAM information.
1976 7218 : poDS->SetDescription(poOpenInfo->pszFilename);
1977 7218 : poDS->TryLoadXML(poOpenInfo->GetSiblingFiles());
1978 :
1979 : // Open overviews.
1980 7218 : poDS->oOvManager.Initialize(poDS, poOpenInfo);
1981 :
1982 7218 : return poDS;
1983 : }
1984 :
1985 : /************************************************************************/
1986 : /* LoadWorldFile() */
1987 : /************************************************************************/
1988 :
1989 164 : void PNGDataset::LoadWorldFile()
1990 : {
1991 164 : if (bHasTriedLoadWorldFile)
1992 5 : return;
1993 159 : bHasTriedLoadWorldFile = TRUE;
1994 :
1995 159 : char *pszWldFilename = nullptr;
1996 159 : bGeoTransformValid =
1997 159 : GDALReadWorldFile2(GetDescription(), nullptr, adfGeoTransform,
1998 159 : oOvManager.GetSiblingFiles(), &pszWldFilename);
1999 :
2000 159 : if (!bGeoTransformValid)
2001 159 : bGeoTransformValid =
2002 159 : GDALReadWorldFile2(GetDescription(), ".wld", adfGeoTransform,
2003 159 : oOvManager.GetSiblingFiles(), &pszWldFilename);
2004 :
2005 159 : if (pszWldFilename)
2006 : {
2007 3 : osWldFilename = pszWldFilename;
2008 3 : CPLFree(pszWldFilename);
2009 : }
2010 : }
2011 :
2012 : /************************************************************************/
2013 : /* GetFileList() */
2014 : /************************************************************************/
2015 :
2016 45 : char **PNGDataset::GetFileList()
2017 :
2018 : {
2019 45 : char **papszFileList = GDALPamDataset::GetFileList();
2020 :
2021 45 : LoadWorldFile();
2022 :
2023 46 : if (!osWldFilename.empty() &&
2024 1 : CSLFindString(papszFileList, osWldFilename) == -1)
2025 : {
2026 1 : papszFileList = CSLAddString(papszFileList, osWldFilename);
2027 : }
2028 :
2029 45 : return papszFileList;
2030 : }
2031 :
2032 : /************************************************************************/
2033 : /* WriteMetadataAsText() */
2034 : /************************************************************************/
2035 :
2036 3 : static bool IsASCII(const char *pszStr)
2037 : {
2038 28 : for (int i = 0; pszStr[i] != '\0'; i++)
2039 : {
2040 25 : if (reinterpret_cast<GByte *>(const_cast<char *>(pszStr))[i] >= 128)
2041 0 : return false;
2042 : }
2043 3 : return true;
2044 : }
2045 :
2046 3 : static bool safe_png_set_text(jmp_buf sSetJmpContext, png_structp png_ptr,
2047 : png_infop info_ptr, png_const_textp text_ptr,
2048 : int num_text)
2049 : {
2050 3 : if (setjmp(sSetJmpContext) != 0)
2051 : {
2052 0 : return false;
2053 : }
2054 3 : png_set_text(png_ptr, info_ptr, text_ptr, num_text);
2055 3 : return true;
2056 : }
2057 :
2058 3 : void PNGDataset::WriteMetadataAsText(jmp_buf sSetJmpContext, png_structp hPNG,
2059 : png_infop psPNGInfo, const char *pszKey,
2060 : const char *pszValue)
2061 : {
2062 : png_text sText;
2063 3 : memset(&sText, 0, sizeof(png_text));
2064 3 : sText.compression = PNG_TEXT_COMPRESSION_NONE;
2065 3 : sText.key = (png_charp)pszKey;
2066 3 : sText.text = (png_charp)pszValue;
2067 :
2068 : // UTF-8 values should be written in iTXt, whereas TEXT should be LATIN-1.
2069 3 : if (!IsASCII(pszValue) && CPLIsUTF8(pszValue, -1))
2070 0 : sText.compression = PNG_ITXT_COMPRESSION_NONE;
2071 :
2072 3 : safe_png_set_text(sSetJmpContext, hPNG, psPNGInfo, &sText, 1);
2073 3 : }
2074 :
2075 4185 : static bool safe_png_set_IHDR(jmp_buf sSetJmpContext, png_structp png_ptr,
2076 : png_infop info_ptr, png_uint_32 width,
2077 : png_uint_32 height, int bit_depth, int color_type,
2078 : int interlace_type, int compression_type,
2079 : int filter_type)
2080 : {
2081 4185 : if (setjmp(sSetJmpContext) != 0)
2082 : {
2083 0 : return false;
2084 : }
2085 4185 : png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, color_type,
2086 : interlace_type, compression_type, filter_type);
2087 4185 : return true;
2088 : }
2089 :
2090 3979 : static bool safe_png_set_compression_level(jmp_buf sSetJmpContext,
2091 : png_structp png_ptr, int level)
2092 : {
2093 3979 : if (setjmp(sSetJmpContext) != 0)
2094 : {
2095 0 : return false;
2096 : }
2097 3979 : png_set_compression_level(png_ptr, level);
2098 3979 : return true;
2099 : }
2100 :
2101 8 : static bool safe_png_set_tRNS(jmp_buf sSetJmpContext, png_structp png_ptr,
2102 : png_infop info_ptr, png_const_bytep trans,
2103 : int num_trans, png_color_16p trans_values)
2104 : {
2105 8 : if (setjmp(sSetJmpContext) != 0)
2106 : {
2107 0 : return false;
2108 : }
2109 8 : png_set_tRNS(png_ptr, info_ptr, trans, num_trans, trans_values);
2110 8 : return true;
2111 : }
2112 :
2113 2 : static bool safe_png_set_iCCP(jmp_buf sSetJmpContext, png_structp png_ptr,
2114 : png_infop info_ptr, png_const_charp name,
2115 : int compression_type, png_const_bytep profile,
2116 : png_uint_32 proflen)
2117 : {
2118 2 : if (setjmp(sSetJmpContext) != 0)
2119 : {
2120 0 : return false;
2121 : }
2122 2 : png_set_iCCP(png_ptr, info_ptr, name, compression_type, profile, proflen);
2123 2 : return true;
2124 : }
2125 :
2126 31 : static bool safe_png_set_PLTE(jmp_buf sSetJmpContext, png_structp png_ptr,
2127 : png_infop info_ptr, png_const_colorp palette,
2128 : int num_palette)
2129 : {
2130 31 : if (setjmp(sSetJmpContext) != 0)
2131 : {
2132 0 : return false;
2133 : }
2134 31 : png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
2135 31 : return true;
2136 : }
2137 :
2138 4185 : static bool safe_png_write_info(jmp_buf sSetJmpContext, png_structp png_ptr,
2139 : png_infop info_ptr)
2140 : {
2141 4185 : if (setjmp(sSetJmpContext) != 0)
2142 : {
2143 5 : return false;
2144 : }
2145 4185 : png_write_info(png_ptr, info_ptr);
2146 4180 : return true;
2147 : }
2148 :
2149 130335 : static bool safe_png_write_rows(jmp_buf sSetJmpContext, png_structp png_ptr,
2150 : png_bytepp row, png_uint_32 num_rows)
2151 : {
2152 130335 : if (setjmp(sSetJmpContext) != 0)
2153 : {
2154 4 : return false;
2155 : }
2156 130335 : png_write_rows(png_ptr, row, num_rows);
2157 130331 : return true;
2158 : }
2159 :
2160 4180 : static bool safe_png_write_end(jmp_buf sSetJmpContext, png_structp png_ptr,
2161 : png_infop info_ptr)
2162 : {
2163 4180 : if (setjmp(sSetJmpContext) != 0)
2164 : {
2165 7 : return false;
2166 : }
2167 4180 : png_write_end(png_ptr, info_ptr);
2168 4173 : return true;
2169 : }
2170 :
2171 : /************************************************************************/
2172 : /* CreateCopy() */
2173 : /************************************************************************/
2174 :
2175 4199 : GDALDataset *PNGDataset::CreateCopy(const char *pszFilename,
2176 : GDALDataset *poSrcDS, int bStrict,
2177 : char **papszOptions,
2178 : GDALProgressFunc pfnProgress,
2179 : void *pProgressData)
2180 :
2181 : {
2182 : // Perform some rudimentary checks.
2183 4199 : const int nBands = poSrcDS->GetRasterCount();
2184 4199 : if (nBands != 1 && nBands != 2 && nBands != 3 && nBands != 4)
2185 : {
2186 2 : CPLError(CE_Failure, CPLE_NotSupported,
2187 : "PNG driver doesn't support %d bands. Must be 1 (grey),\n"
2188 : "2 (grey+alpha), 3 (rgb) or 4 (rgba) bands.\n",
2189 : nBands);
2190 :
2191 2 : return nullptr;
2192 : }
2193 :
2194 4262 : if (poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte &&
2195 65 : poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_UInt16)
2196 : {
2197 9 : CPLError(
2198 : (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
2199 : "PNG driver doesn't support data type %s. "
2200 : "Only eight bit (Byte) and sixteen bit (UInt16) bands supported. "
2201 : "%s\n",
2202 : GDALGetDataTypeName(poSrcDS->GetRasterBand(1)->GetRasterDataType()),
2203 : (bStrict) ? "" : "Defaulting to Byte");
2204 :
2205 9 : if (bStrict)
2206 9 : return nullptr;
2207 : }
2208 :
2209 : // Create the dataset.
2210 4188 : VSILFILE *fpImage = VSIFOpenL(pszFilename, "wb");
2211 4188 : if (fpImage == nullptr)
2212 : {
2213 3 : CPLError(CE_Failure, CPLE_OpenFailed,
2214 : "Unable to create png file %s: %s\n", pszFilename,
2215 3 : VSIStrerror(errno));
2216 3 : return nullptr;
2217 : }
2218 :
2219 : // Initialize PNG access to the file.
2220 : jmp_buf sSetJmpContext;
2221 :
2222 : png_structp hPNG =
2223 4185 : png_create_write_struct(PNG_LIBPNG_VER_STRING, &sSetJmpContext,
2224 4185 : png_gdal_error, png_gdal_warning);
2225 4185 : png_infop psPNGInfo = png_create_info_struct(hPNG);
2226 :
2227 : // Set up some parameters.
2228 4185 : int nColorType = 0;
2229 :
2230 4185 : if (nBands == 1 && poSrcDS->GetRasterBand(1)->GetColorTable() == nullptr)
2231 147 : nColorType = PNG_COLOR_TYPE_GRAY;
2232 4038 : else if (nBands == 1)
2233 31 : nColorType = PNG_COLOR_TYPE_PALETTE;
2234 4007 : else if (nBands == 2)
2235 244 : nColorType = PNG_COLOR_TYPE_GRAY_ALPHA;
2236 3763 : else if (nBands == 3)
2237 3587 : nColorType = PNG_COLOR_TYPE_RGB;
2238 176 : else if (nBands == 4)
2239 176 : nColorType = PNG_COLOR_TYPE_RGB_ALPHA;
2240 :
2241 : int nBitDepth;
2242 : GDALDataType eType;
2243 4185 : if (poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_UInt16)
2244 : {
2245 4129 : eType = GDT_Byte;
2246 4129 : nBitDepth = 8;
2247 4129 : if (nBands == 1)
2248 : {
2249 125 : const char *pszNbits = poSrcDS->GetRasterBand(1)->GetMetadataItem(
2250 125 : "NBITS", "IMAGE_STRUCTURE");
2251 125 : if (pszNbits != nullptr)
2252 : {
2253 3 : nBitDepth = atoi(pszNbits);
2254 3 : if (!(nBitDepth == 1 || nBitDepth == 2 || nBitDepth == 4))
2255 0 : nBitDepth = 8;
2256 : }
2257 : }
2258 : }
2259 : else
2260 : {
2261 56 : eType = GDT_UInt16;
2262 56 : nBitDepth = 16;
2263 : }
2264 :
2265 4185 : const char *pszNbits = CSLFetchNameValue(papszOptions, "NBITS");
2266 4185 : if (eType == GDT_Byte && pszNbits != nullptr)
2267 : {
2268 13 : nBitDepth = atoi(pszNbits);
2269 13 : if (!(nBitDepth == 1 || nBitDepth == 2 || nBitDepth == 4 ||
2270 : nBitDepth == 8))
2271 : {
2272 1 : CPLError(CE_Warning, CPLE_NotSupported,
2273 : "Invalid bit depth. Using 8");
2274 1 : nBitDepth = 8;
2275 : }
2276 : }
2277 :
2278 4185 : png_set_write_fn(hPNG, fpImage, png_vsi_write_data, png_vsi_flush);
2279 :
2280 4185 : const int nXSize = poSrcDS->GetRasterXSize();
2281 4185 : const int nYSize = poSrcDS->GetRasterYSize();
2282 :
2283 4185 : if (!safe_png_set_IHDR(sSetJmpContext, hPNG, psPNGInfo, nXSize, nYSize,
2284 : nBitDepth, nColorType, PNG_INTERLACE_NONE,
2285 : PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE))
2286 : {
2287 0 : VSIFCloseL(fpImage);
2288 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2289 0 : return nullptr;
2290 : }
2291 :
2292 : // Do we want to control the compression level?
2293 4185 : const char *pszLevel = CSLFetchNameValue(papszOptions, "ZLEVEL");
2294 :
2295 4185 : if (pszLevel)
2296 : {
2297 3979 : const int nLevel = atoi(pszLevel);
2298 3979 : if (nLevel < 1 || nLevel > 9)
2299 : {
2300 0 : CPLError(CE_Failure, CPLE_AppDefined,
2301 : "Illegal ZLEVEL value '%s', should be 1-9.", pszLevel);
2302 0 : VSIFCloseL(fpImage);
2303 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2304 0 : return nullptr;
2305 : }
2306 :
2307 3979 : if (!safe_png_set_compression_level(sSetJmpContext, hPNG, nLevel))
2308 : {
2309 0 : VSIFCloseL(fpImage);
2310 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2311 0 : return nullptr;
2312 : }
2313 : }
2314 :
2315 : // Try to handle nodata values as a tRNS block (note that for paletted
2316 : // images, we save the effect to apply as part of palette).
2317 : png_color_16 sTRNSColor;
2318 :
2319 : // Gray nodata.
2320 4185 : if (nColorType == PNG_COLOR_TYPE_GRAY)
2321 : {
2322 147 : int bHaveNoData = FALSE;
2323 : const double dfNoDataValue =
2324 147 : poSrcDS->GetRasterBand(1)->GetNoDataValue(&bHaveNoData);
2325 :
2326 147 : if (bHaveNoData && dfNoDataValue >= 0 && dfNoDataValue < 65536)
2327 : {
2328 3 : sTRNSColor.gray = (png_uint_16)dfNoDataValue;
2329 3 : if (!safe_png_set_tRNS(sSetJmpContext, hPNG, psPNGInfo, nullptr, 0,
2330 : &sTRNSColor))
2331 : {
2332 0 : VSIFCloseL(fpImage);
2333 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2334 0 : return nullptr;
2335 : }
2336 : }
2337 : }
2338 :
2339 : // RGB nodata.
2340 4185 : if (nColorType == PNG_COLOR_TYPE_RGB)
2341 : {
2342 : // First try to use the NODATA_VALUES metadata item.
2343 3587 : if (poSrcDS->GetMetadataItem("NODATA_VALUES") != nullptr)
2344 : {
2345 : char **papszValues =
2346 1 : CSLTokenizeString(poSrcDS->GetMetadataItem("NODATA_VALUES"));
2347 :
2348 1 : if (CSLCount(papszValues) >= 3)
2349 : {
2350 1 : sTRNSColor.red = (png_uint_16)atoi(papszValues[0]);
2351 1 : sTRNSColor.green = (png_uint_16)atoi(papszValues[1]);
2352 1 : sTRNSColor.blue = (png_uint_16)atoi(papszValues[2]);
2353 1 : if (!safe_png_set_tRNS(sSetJmpContext, hPNG, psPNGInfo, nullptr,
2354 : 0, &sTRNSColor))
2355 : {
2356 0 : VSIFCloseL(fpImage);
2357 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2358 0 : CSLDestroy(papszValues);
2359 0 : return nullptr;
2360 : }
2361 : }
2362 :
2363 1 : CSLDestroy(papszValues);
2364 : }
2365 : // Otherwise, get the nodata value from the bands.
2366 : else
2367 : {
2368 3586 : int bHaveNoDataRed = FALSE;
2369 : const double dfNoDataValueRed =
2370 3586 : poSrcDS->GetRasterBand(1)->GetNoDataValue(&bHaveNoDataRed);
2371 :
2372 3586 : int bHaveNoDataGreen = FALSE;
2373 : const double dfNoDataValueGreen =
2374 3586 : poSrcDS->GetRasterBand(2)->GetNoDataValue(&bHaveNoDataGreen);
2375 :
2376 3586 : int bHaveNoDataBlue = FALSE;
2377 : const double dfNoDataValueBlue =
2378 3586 : poSrcDS->GetRasterBand(3)->GetNoDataValue(&bHaveNoDataBlue);
2379 :
2380 3586 : if ((bHaveNoDataRed && dfNoDataValueRed >= 0 &&
2381 0 : dfNoDataValueRed < 65536) &&
2382 0 : (bHaveNoDataGreen && dfNoDataValueGreen >= 0 &&
2383 0 : dfNoDataValueGreen < 65536) &&
2384 0 : (bHaveNoDataBlue && dfNoDataValueBlue >= 0 &&
2385 : dfNoDataValueBlue < 65536))
2386 : {
2387 0 : sTRNSColor.red = static_cast<png_uint_16>(dfNoDataValueRed);
2388 0 : sTRNSColor.green = static_cast<png_uint_16>(dfNoDataValueGreen);
2389 0 : sTRNSColor.blue = static_cast<png_uint_16>(dfNoDataValueBlue);
2390 0 : if (!safe_png_set_tRNS(sSetJmpContext, hPNG, psPNGInfo, nullptr,
2391 : 0, &sTRNSColor))
2392 : {
2393 0 : VSIFCloseL(fpImage);
2394 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2395 0 : return nullptr;
2396 : }
2397 : }
2398 : }
2399 : }
2400 :
2401 : // Copy color profile data.
2402 : const char *pszICCProfile =
2403 4185 : CSLFetchNameValue(papszOptions, "SOURCE_ICC_PROFILE");
2404 : const char *pszICCProfileName =
2405 4185 : CSLFetchNameValue(papszOptions, "SOURCE_ICC_PROFILE_NAME");
2406 4185 : if (pszICCProfileName == nullptr)
2407 4184 : pszICCProfileName = poSrcDS->GetMetadataItem("SOURCE_ICC_PROFILE_NAME",
2408 4184 : "COLOR_PROFILE");
2409 :
2410 4185 : if (pszICCProfile == nullptr)
2411 : pszICCProfile =
2412 4184 : poSrcDS->GetMetadataItem("SOURCE_ICC_PROFILE", "COLOR_PROFILE");
2413 :
2414 4185 : if ((pszICCProfileName != nullptr) && EQUAL(pszICCProfileName, "sRGB"))
2415 : {
2416 1 : pszICCProfile = nullptr;
2417 :
2418 : // assumes this can't fail ?
2419 1 : png_set_sRGB(hPNG, psPNGInfo, PNG_sRGB_INTENT_PERCEPTUAL);
2420 : }
2421 :
2422 4185 : if (pszICCProfile != nullptr)
2423 : {
2424 2 : char *pEmbedBuffer = CPLStrdup(pszICCProfile);
2425 : png_uint_32 nEmbedLen =
2426 2 : CPLBase64DecodeInPlace(reinterpret_cast<GByte *>(pEmbedBuffer));
2427 2 : const char *pszLocalICCProfileName =
2428 2 : (pszICCProfileName != nullptr) ? pszICCProfileName : "ICC Profile";
2429 :
2430 2 : if (!safe_png_set_iCCP(sSetJmpContext, hPNG, psPNGInfo,
2431 : pszLocalICCProfileName, 0,
2432 : (png_const_bytep)pEmbedBuffer, nEmbedLen))
2433 : {
2434 0 : CPLFree(pEmbedBuffer);
2435 0 : VSIFCloseL(fpImage);
2436 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2437 0 : return nullptr;
2438 : }
2439 :
2440 2 : CPLFree(pEmbedBuffer);
2441 : }
2442 4183 : else if ((pszICCProfileName == nullptr) ||
2443 1 : !EQUAL(pszICCProfileName, "sRGB"))
2444 : {
2445 : // Output gamma, primaries and whitepoint.
2446 4182 : const char *pszGamma = CSLFetchNameValue(papszOptions, "PNG_GAMMA");
2447 4182 : if (pszGamma == nullptr)
2448 4180 : pszGamma = poSrcDS->GetMetadataItem("PNG_GAMMA", "COLOR_PROFILE");
2449 :
2450 4182 : if (pszGamma != nullptr)
2451 : {
2452 4 : double dfGamma = CPLAtof(pszGamma);
2453 : // assumes this can't fail ?
2454 4 : png_set_gAMA(hPNG, psPNGInfo, dfGamma);
2455 : }
2456 :
2457 : const char *pszPrimariesRed =
2458 4182 : CSLFetchNameValue(papszOptions, "SOURCE_PRIMARIES_RED");
2459 4182 : if (pszPrimariesRed == nullptr)
2460 4181 : pszPrimariesRed = poSrcDS->GetMetadataItem("SOURCE_PRIMARIES_RED",
2461 4181 : "COLOR_PROFILE");
2462 : const char *pszPrimariesGreen =
2463 4182 : CSLFetchNameValue(papszOptions, "SOURCE_PRIMARIES_GREEN");
2464 4182 : if (pszPrimariesGreen == nullptr)
2465 4181 : pszPrimariesGreen = poSrcDS->GetMetadataItem(
2466 4181 : "SOURCE_PRIMARIES_GREEN", "COLOR_PROFILE");
2467 : const char *pszPrimariesBlue =
2468 4182 : CSLFetchNameValue(papszOptions, "SOURCE_PRIMARIES_BLUE");
2469 4182 : if (pszPrimariesBlue == nullptr)
2470 4181 : pszPrimariesBlue = poSrcDS->GetMetadataItem("SOURCE_PRIMARIES_BLUE",
2471 4181 : "COLOR_PROFILE");
2472 : const char *pszWhitepoint =
2473 4182 : CSLFetchNameValue(papszOptions, "SOURCE_WHITEPOINT");
2474 4182 : if (pszWhitepoint == nullptr)
2475 : pszWhitepoint =
2476 4181 : poSrcDS->GetMetadataItem("SOURCE_WHITEPOINT", "COLOR_PROFILE");
2477 :
2478 4182 : if ((pszPrimariesRed != nullptr) && (pszPrimariesGreen != nullptr) &&
2479 2 : (pszPrimariesBlue != nullptr) && (pszWhitepoint != nullptr))
2480 : {
2481 2 : bool bOk = true;
2482 2 : double faColour[8] = {0.0};
2483 2 : char **apapszTokenList[4] = {nullptr};
2484 :
2485 2 : apapszTokenList[0] = CSLTokenizeString2(pszWhitepoint, ",",
2486 : CSLT_ALLOWEMPTYTOKENS |
2487 : CSLT_STRIPLEADSPACES |
2488 : CSLT_STRIPENDSPACES);
2489 2 : apapszTokenList[1] = CSLTokenizeString2(pszPrimariesRed, ",",
2490 : CSLT_ALLOWEMPTYTOKENS |
2491 : CSLT_STRIPLEADSPACES |
2492 : CSLT_STRIPENDSPACES);
2493 2 : apapszTokenList[2] = CSLTokenizeString2(pszPrimariesGreen, ",",
2494 : CSLT_ALLOWEMPTYTOKENS |
2495 : CSLT_STRIPLEADSPACES |
2496 : CSLT_STRIPENDSPACES);
2497 2 : apapszTokenList[3] = CSLTokenizeString2(pszPrimariesBlue, ",",
2498 : CSLT_ALLOWEMPTYTOKENS |
2499 : CSLT_STRIPLEADSPACES |
2500 : CSLT_STRIPENDSPACES);
2501 :
2502 2 : if ((CSLCount(apapszTokenList[0]) == 3) &&
2503 2 : (CSLCount(apapszTokenList[1]) == 3) &&
2504 6 : (CSLCount(apapszTokenList[2]) == 3) &&
2505 2 : (CSLCount(apapszTokenList[3]) == 3))
2506 : {
2507 10 : for (int i = 0; i < 4; i++)
2508 : {
2509 32 : for (int j = 0; j < 3; j++)
2510 : {
2511 24 : const double v = CPLAtof(apapszTokenList[i][j]);
2512 :
2513 24 : if (j == 2)
2514 : {
2515 : /* Last term of xyY colour must be 1.0 */
2516 8 : if (v != 1.0)
2517 : {
2518 0 : bOk = false;
2519 0 : break;
2520 : }
2521 : }
2522 : else
2523 : {
2524 16 : faColour[i * 2 + j] = v;
2525 : }
2526 : }
2527 8 : if (!bOk)
2528 0 : break;
2529 : }
2530 :
2531 2 : if (bOk)
2532 : {
2533 : // assumes this can't fail ?
2534 2 : png_set_cHRM(hPNG, psPNGInfo, faColour[0], faColour[1],
2535 : faColour[2], faColour[3], faColour[4],
2536 : faColour[5], faColour[6], faColour[7]);
2537 : }
2538 : }
2539 :
2540 2 : CSLDestroy(apapszTokenList[0]);
2541 2 : CSLDestroy(apapszTokenList[1]);
2542 2 : CSLDestroy(apapszTokenList[2]);
2543 2 : CSLDestroy(apapszTokenList[3]);
2544 : }
2545 : }
2546 :
2547 : // Write the palette if there is one. Technically, it may be possible to
2548 : // write 16-bit palettes for PNG, but for now, this is omitted.
2549 4185 : if (nColorType == PNG_COLOR_TYPE_PALETTE)
2550 : {
2551 31 : int bHaveNoData = FALSE;
2552 : double dfNoDataValue =
2553 31 : poSrcDS->GetRasterBand(1)->GetNoDataValue(&bHaveNoData);
2554 :
2555 31 : GDALColorTable *poCT = poSrcDS->GetRasterBand(1)->GetColorTable();
2556 :
2557 31 : int nEntryCount = poCT->GetColorEntryCount();
2558 31 : int nMaxEntryCount = 1 << nBitDepth;
2559 31 : if (nEntryCount > nMaxEntryCount)
2560 0 : nEntryCount = nMaxEntryCount;
2561 :
2562 : png_color *pasPNGColors = reinterpret_cast<png_color *>(
2563 31 : CPLMalloc(sizeof(png_color) * nEntryCount));
2564 :
2565 : GDALColorEntry sEntry;
2566 31 : bool bFoundTrans = false;
2567 6493 : for (int iColor = 0; iColor < nEntryCount; iColor++)
2568 : {
2569 6462 : poCT->GetColorEntryAsRGB(iColor, &sEntry);
2570 6462 : if (sEntry.c4 != 255)
2571 266 : bFoundTrans = true;
2572 :
2573 6462 : pasPNGColors[iColor].red = static_cast<png_byte>(sEntry.c1);
2574 6462 : pasPNGColors[iColor].green = static_cast<png_byte>(sEntry.c2);
2575 6462 : pasPNGColors[iColor].blue = static_cast<png_byte>(sEntry.c3);
2576 : }
2577 :
2578 31 : if (!safe_png_set_PLTE(sSetJmpContext, hPNG, psPNGInfo, pasPNGColors,
2579 : nEntryCount))
2580 : {
2581 0 : CPLFree(pasPNGColors);
2582 0 : VSIFCloseL(fpImage);
2583 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2584 0 : return nullptr;
2585 : }
2586 :
2587 31 : CPLFree(pasPNGColors);
2588 :
2589 : // If we have transparent elements in the palette, we need to write a
2590 : // transparency block.
2591 31 : if (bFoundTrans || bHaveNoData)
2592 : {
2593 : unsigned char *pabyAlpha =
2594 4 : reinterpret_cast<unsigned char *>(CPLMalloc(nEntryCount));
2595 :
2596 571 : for (int iColor = 0; iColor < nEntryCount; iColor++)
2597 : {
2598 567 : poCT->GetColorEntryAsRGB(iColor, &sEntry);
2599 567 : pabyAlpha[iColor] = static_cast<unsigned char>(sEntry.c4);
2600 :
2601 567 : if (bHaveNoData && iColor == static_cast<int>(dfNoDataValue))
2602 3 : pabyAlpha[iColor] = 0;
2603 : }
2604 :
2605 4 : if (!safe_png_set_tRNS(sSetJmpContext, hPNG, psPNGInfo, pabyAlpha,
2606 : nEntryCount, nullptr))
2607 : {
2608 0 : CPLFree(pabyAlpha);
2609 0 : VSIFCloseL(fpImage);
2610 0 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2611 0 : return nullptr;
2612 : }
2613 :
2614 4 : CPLFree(pabyAlpha);
2615 : }
2616 : }
2617 :
2618 : // Add text info.
2619 : // These are predefined keywords. See "4.2.7 tEXt Textual data" of
2620 : // http://www.w3.org/TR/PNG-Chunks.html for more information.
2621 4185 : const char *apszKeywords[] = {"Title", "Author", "Description",
2622 : "Copyright", "Creation Time", "Software",
2623 : "Disclaimer", "Warning", "Source",
2624 : "Comment", nullptr};
2625 4185 : const bool bWriteMetadataAsText = CPLTestBool(
2626 : CSLFetchNameValueDef(papszOptions, "WRITE_METADATA_AS_TEXT", "FALSE"));
2627 46035 : for (int i = 0; apszKeywords[i] != nullptr; i++)
2628 : {
2629 41850 : const char *pszKey = apszKeywords[i];
2630 41850 : const char *pszValue = CSLFetchNameValue(papszOptions, pszKey);
2631 41850 : if (pszValue == nullptr && bWriteMetadataAsText)
2632 9 : pszValue = poSrcDS->GetMetadataItem(pszKey);
2633 41850 : if (pszValue != nullptr)
2634 : {
2635 2 : WriteMetadataAsText(sSetJmpContext, hPNG, psPNGInfo, pszKey,
2636 : pszValue);
2637 : }
2638 : }
2639 4185 : if (bWriteMetadataAsText)
2640 : {
2641 1 : char **papszSrcMD = poSrcDS->GetMetadata();
2642 4 : for (; papszSrcMD && *papszSrcMD; papszSrcMD++)
2643 : {
2644 3 : char *pszKey = nullptr;
2645 3 : const char *pszValue = CPLParseNameValue(*papszSrcMD, &pszKey);
2646 3 : if (pszKey && pszValue)
2647 : {
2648 3 : if (CSLFindString(const_cast<char **>(apszKeywords), pszKey) <
2649 1 : 0 &&
2650 4 : !EQUAL(pszKey, "AREA_OR_POINT") &&
2651 1 : !EQUAL(pszKey, "NODATA_VALUES"))
2652 : {
2653 1 : WriteMetadataAsText(sSetJmpContext, hPNG, psPNGInfo, pszKey,
2654 : pszValue);
2655 : }
2656 3 : CPLFree(pszKey);
2657 : }
2658 : }
2659 : }
2660 :
2661 : // Write the PNG info.
2662 4185 : if (!safe_png_write_info(sSetJmpContext, hPNG, psPNGInfo))
2663 : {
2664 5 : VSIFCloseL(fpImage);
2665 5 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2666 5 : return nullptr;
2667 : }
2668 :
2669 4180 : if (nBitDepth < 8)
2670 : {
2671 : // Assumes this can't fail
2672 6 : png_set_packing(hPNG);
2673 : }
2674 :
2675 : // Loop over the image, copying image data.
2676 4180 : CPLErr eErr = CE_None;
2677 4180 : const int nWordSize = GDALGetDataTypeSize(eType) / 8;
2678 :
2679 : GByte *pabyScanline = reinterpret_cast<GByte *>(
2680 4180 : CPLMalloc(cpl::fits_on<int>(nBands * nXSize * nWordSize)));
2681 :
2682 134516 : for (int iLine = 0; iLine < nYSize && eErr == CE_None; iLine++)
2683 : {
2684 130336 : png_bytep row = pabyScanline;
2685 :
2686 260672 : eErr = poSrcDS->RasterIO(
2687 : GF_Read, 0, iLine, nXSize, 1, pabyScanline, nXSize, 1, eType,
2688 130336 : nBands, nullptr, static_cast<GSpacing>(nBands) * nWordSize,
2689 130336 : static_cast<GSpacing>(nBands) * nXSize * nWordSize, nWordSize,
2690 : nullptr);
2691 :
2692 : #ifdef CPL_LSB
2693 130336 : if (nBitDepth == 16)
2694 12885 : GDALSwapWords(row, 2, nXSize * nBands, 2);
2695 : #endif
2696 130336 : if (eErr == CE_None)
2697 : {
2698 130335 : if (!safe_png_write_rows(sSetJmpContext, hPNG, &row, 1))
2699 : {
2700 4 : eErr = CE_Failure;
2701 : }
2702 : }
2703 :
2704 260667 : if (eErr == CE_None &&
2705 130331 : !pfnProgress((iLine + 1) / static_cast<double>(nYSize), nullptr,
2706 : pProgressData))
2707 : {
2708 1 : eErr = CE_Failure;
2709 1 : CPLError(CE_Failure, CPLE_UserInterrupt,
2710 : "User terminated CreateCopy()");
2711 : }
2712 : }
2713 :
2714 4180 : CPLFree(pabyScanline);
2715 :
2716 4180 : if (!safe_png_write_end(sSetJmpContext, hPNG, psPNGInfo))
2717 : {
2718 7 : eErr = CE_Failure;
2719 : }
2720 4180 : png_destroy_write_struct(&hPNG, &psPNGInfo);
2721 :
2722 4180 : VSIFCloseL(fpImage);
2723 :
2724 4180 : if (eErr != CE_None)
2725 7 : return nullptr;
2726 :
2727 : // Do we need a world file?
2728 4173 : if (CPLFetchBool(papszOptions, "WORLDFILE", false))
2729 : {
2730 : double adfGeoTransform[6];
2731 :
2732 0 : if (poSrcDS->GetGeoTransform(adfGeoTransform) == CE_None)
2733 0 : GDALWriteWorldFile(pszFilename, "wld", adfGeoTransform);
2734 : }
2735 :
2736 : // Re-open dataset and copy any auxiliary PAM information.
2737 :
2738 : /* If writing to stdout, we can't reopen it, so return */
2739 : /* a fake dataset to make the caller happy */
2740 4173 : if (CPLTestBool(CPLGetConfigOption("GDAL_OPEN_AFTER_COPY", "YES")))
2741 : {
2742 4161 : CPLPushErrorHandler(CPLQuietErrorHandler);
2743 4161 : GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
2744 : PNGDataset *poDS =
2745 4161 : reinterpret_cast<PNGDataset *>(PNGDataset::Open(&oOpenInfo));
2746 4161 : CPLPopErrorHandler();
2747 4161 : if (poDS)
2748 : {
2749 4160 : int nFlags = GCIF_PAM_DEFAULT & ~GCIF_METADATA;
2750 4160 : poDS->CloneInfo(poSrcDS, nFlags);
2751 :
2752 : char **papszExcludedDomains =
2753 4160 : CSLAddString(nullptr, "COLOR_PROFILE");
2754 4160 : if (bWriteMetadataAsText)
2755 1 : papszExcludedDomains = CSLAddString(papszExcludedDomains, "");
2756 4160 : GDALDriver::DefaultCopyMetadata(poSrcDS, poDS, papszOptions,
2757 : papszExcludedDomains);
2758 4160 : CSLDestroy(papszExcludedDomains);
2759 :
2760 4160 : return poDS;
2761 : }
2762 1 : CPLErrorReset();
2763 : }
2764 :
2765 13 : PNGDataset *poPNG_DS = new PNGDataset();
2766 13 : poPNG_DS->nRasterXSize = nXSize;
2767 13 : poPNG_DS->nRasterYSize = nYSize;
2768 13 : poPNG_DS->nBitDepth = nBitDepth;
2769 62 : for (int i = 0; i < nBands; i++)
2770 49 : poPNG_DS->SetBand(i + 1, new PNGRasterBand(poPNG_DS, i + 1));
2771 13 : return poPNG_DS;
2772 : }
2773 :
2774 : /************************************************************************/
2775 : /* png_vsi_read_data() */
2776 : /* */
2777 : /* Read data callback through VSI. */
2778 : /************************************************************************/
2779 64039 : static void png_vsi_read_data(png_structp png_ptr, png_bytep data,
2780 : png_size_t length)
2781 :
2782 : {
2783 : // fread() returns 0 on error, so it is OK to store this in a png_size_t
2784 : // instead of an int, which is what fread() actually returns.
2785 : const png_size_t check = static_cast<png_size_t>(
2786 128078 : VSIFReadL(data, (png_size_t)1, length,
2787 64039 : reinterpret_cast<VSILFILE *>(png_get_io_ptr(png_ptr))));
2788 :
2789 64039 : if (check != length)
2790 3 : png_error(png_ptr, "Read Error");
2791 64036 : }
2792 :
2793 : /************************************************************************/
2794 : /* png_vsi_write_data() */
2795 : /************************************************************************/
2796 :
2797 45682 : static void png_vsi_write_data(png_structp png_ptr, png_bytep data,
2798 : png_size_t length)
2799 : {
2800 91364 : const size_t check = VSIFWriteL(
2801 45682 : data, 1, length, reinterpret_cast<VSILFILE *>(png_get_io_ptr(png_ptr)));
2802 :
2803 45682 : if (check != length)
2804 10 : png_error(png_ptr, "Write Error");
2805 45672 : }
2806 :
2807 : /************************************************************************/
2808 : /* png_vsi_flush() */
2809 : /************************************************************************/
2810 0 : static void png_vsi_flush(png_structp png_ptr)
2811 : {
2812 0 : VSIFFlushL(reinterpret_cast<VSILFILE *>(png_get_io_ptr(png_ptr)));
2813 0 : }
2814 :
2815 : /************************************************************************/
2816 : /* png_gdal_error() */
2817 : /************************************************************************/
2818 :
2819 19 : static void png_gdal_error(png_structp png_ptr, const char *error_message)
2820 : {
2821 19 : CPLError(CE_Failure, CPLE_AppDefined, "libpng: %s", error_message);
2822 :
2823 : // Use longjmp instead of a C++ exception, because libpng is generally not
2824 : // built as C++ and so will not honor unwind semantics.
2825 :
2826 : jmp_buf *psSetJmpContext =
2827 19 : reinterpret_cast<jmp_buf *>(png_get_error_ptr(png_ptr));
2828 19 : if (psSetJmpContext)
2829 : {
2830 19 : longjmp(*psSetJmpContext, 1);
2831 : }
2832 0 : }
2833 :
2834 : /************************************************************************/
2835 : /* png_gdal_warning() */
2836 : /************************************************************************/
2837 :
2838 0 : static void png_gdal_warning(CPL_UNUSED png_structp png_ptr,
2839 : const char *error_message)
2840 : {
2841 0 : CPLError(CE_Warning, CPLE_AppDefined, "libpng: %s", error_message);
2842 0 : }
2843 :
2844 : /************************************************************************/
2845 : /* GDALRegister_PNG() */
2846 : /************************************************************************/
2847 :
2848 46 : void GDALRegister_PNG()
2849 :
2850 : {
2851 46 : if (GDALGetDriverByName(DRIVER_NAME) != nullptr)
2852 0 : return;
2853 :
2854 46 : GDALDriver *poDriver = new GDALDriver();
2855 46 : PNGDriverSetCommonMetadata(poDriver);
2856 :
2857 46 : poDriver->pfnOpen = PNGDataset::Open;
2858 46 : poDriver->pfnCreateCopy = PNGDataset::CreateCopy;
2859 : #ifdef SUPPORT_CREATE
2860 : poDriver->pfnCreate = PNGDataset::Create;
2861 : #endif
2862 :
2863 46 : GetGDALDriverManager()->RegisterDriver(poDriver);
2864 : }
2865 :
2866 : #ifdef SUPPORT_CREATE
2867 : /************************************************************************/
2868 : /* IWriteBlock() */
2869 : /************************************************************************/
2870 :
2871 : CPLErr PNGRasterBand::IWriteBlock(int x, int y, void *pvData)
2872 : {
2873 : PNGDataset &ds = *reinterpret_cast<PNGDataset *>(poDS);
2874 :
2875 : // Write the block (or consolidate into multichannel block) and then write.
2876 :
2877 : const GDALDataType dt = GetRasterDataType();
2878 : const size_t wordsize = ds.m_nBitDepth / 8;
2879 : GDALCopyWords(pvData, dt, wordsize,
2880 : ds.m_pabyBuffer + (nBand - 1) * wordsize, dt,
2881 : ds.nBands * wordsize, nBlockXSize);
2882 :
2883 : // See if we have all the bands.
2884 : m_bBandProvided[nBand - 1] = TRUE;
2885 : for (size_t i = 0; i < static_cast<size_t>(ds.nBands); i++)
2886 : {
2887 : if (!m_bBandProvided[i])
2888 : return CE_None;
2889 : }
2890 :
2891 : // We received all the bands, so reset band flags and write pixels out.
2892 : this->reset_band_provision_flags();
2893 :
2894 : // If it is the first block, write out the file header.
2895 : if (x == 0 && y == 0)
2896 : {
2897 : CPLErr err = ds.write_png_header();
2898 : if (err != CE_None)
2899 : return err;
2900 : }
2901 :
2902 : #ifdef CPL_LSB
2903 : if (ds.m_nBitDepth == 16)
2904 : GDALSwapWords(ds.m_pabyBuffer, 2, nBlockXSize * ds.nBands, 2);
2905 : #endif
2906 : png_write_rows(ds.m_hPNG, &ds.m_pabyBuffer, 1);
2907 :
2908 : return CE_None;
2909 : }
2910 :
2911 : /************************************************************************/
2912 : /* SetGeoTransform() */
2913 : /************************************************************************/
2914 :
2915 : CPLErr PNGDataset::SetGeoTransform(double *padfTransform)
2916 : {
2917 : memcpy(m_adfGeoTransform, padfTransform, sizeof(double) * 6);
2918 :
2919 : if (m_pszFilename)
2920 : {
2921 : if (GDALWriteWorldFile(m_pszFilename, "wld", m_adfGeoTransform) ==
2922 : FALSE)
2923 : {
2924 : CPLError(CE_Failure, CPLE_FileIO, "Can't write world file.");
2925 : return CE_Failure;
2926 : }
2927 : }
2928 :
2929 : return CE_None;
2930 : }
2931 :
2932 : /************************************************************************/
2933 : /* SetColorTable() */
2934 : /************************************************************************/
2935 :
2936 : CPLErr PNGRasterBand::SetColorTable(GDALColorTable *poCT)
2937 : {
2938 : if (poCT == NULL)
2939 : return CE_Failure;
2940 :
2941 : // We get called even for grayscale files, since some formats need a palette
2942 : // even then. PNG doesn't, so if a gray palette is given, just ignore it.
2943 :
2944 : GDALColorEntry sEntry;
2945 : for (size_t i = 0; i < static_cast<size_t>(poCT->GetColorEntryCount()); i++)
2946 : {
2947 : poCT->GetColorEntryAsRGB(i, &sEntry);
2948 : if (sEntry.c1 != sEntry.c2 || sEntry.c1 != sEntry.c3)
2949 : {
2950 : CPLErr err = GDALPamRasterBand::SetColorTable(poCT);
2951 : if (err != CE_None)
2952 : return err;
2953 :
2954 : PNGDataset &ds = *reinterpret_cast<PNGDataset *>(poDS);
2955 : ds.m_nColorType = PNG_COLOR_TYPE_PALETTE;
2956 : break;
2957 : // band::IWriteBlock will emit color table as part of the header
2958 : // preceding the first block write.
2959 : }
2960 : }
2961 :
2962 : return CE_None;
2963 : }
2964 :
2965 : /************************************************************************/
2966 : /* PNGDataset::write_png_header() */
2967 : /************************************************************************/
2968 :
2969 : CPLErr PNGDataset::write_png_header()
2970 : {
2971 : // Initialize PNG access to the file.
2972 : m_hPNG = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
2973 : png_gdal_error, png_gdal_warning);
2974 :
2975 : m_psPNGInfo = png_create_info_struct(m_hPNG);
2976 :
2977 : png_set_write_fn(m_hPNG, m_fpImage, png_vsi_write_data, png_vsi_flush);
2978 :
2979 : png_set_IHDR(m_hPNG, m_psPNGInfo, nRasterXSize, nRasterYSize, m_nBitDepth,
2980 : m_nColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
2981 : PNG_FILTER_TYPE_DEFAULT);
2982 :
2983 : png_set_compression_level(m_hPNG, Z_BEST_COMPRESSION);
2984 :
2985 : // png_set_swap_alpha(m_hPNG); // Use RGBA order, not ARGB.
2986 :
2987 : // Try to handle nodata values as a tRNS block (note that for paletted
2988 : // images, we save the effect to apply as part of the palette).
2989 : // m_bHaveNoData = FALSE;
2990 : // m_dfNoDataValue = -1;
2991 : png_color_16 sTRNSColor;
2992 :
2993 : int bHaveNoData = FALSE;
2994 : double dfNoDataValue = -1;
2995 :
2996 : if (m_nColorType == PNG_COLOR_TYPE_GRAY)
2997 : {
2998 : dfNoDataValue = GetRasterBand(1)->GetNoDataValue(&bHaveNoData);
2999 :
3000 : if (bHaveNoData && dfNoDataValue >= 0 && dfNoDataValue < 65536)
3001 : {
3002 : sTRNSColor.gray = static_cast<png_uint_16>(dfNoDataValue);
3003 : png_set_tRNS(m_hPNG, m_psPNGInfo, NULL, 0, &sTRNSColor);
3004 : }
3005 : }
3006 :
3007 : // RGB nodata.
3008 : if (nColorType == PNG_COLOR_TYPE_RGB)
3009 : {
3010 : // First, try to use the NODATA_VALUES metadata item.
3011 : if (GetMetadataItem("NODATA_VALUES") != NULL)
3012 : {
3013 : char **papszValues =
3014 : CSLTokenizeString(GetMetadataItem("NODATA_VALUES"));
3015 :
3016 : if (CSLCount(papszValues) >= 3)
3017 : {
3018 : sTRNSColor.red = static_cast<png_uint_16>(atoi(papszValues[0]));
3019 : sTRNSColor.green =
3020 : static_cast<png_uint_16>(atoi(papszValues[1]));
3021 : sTRNSColor.blue =
3022 : static_cast<png_uint_16>(atoi(papszValues[2]));
3023 : png_set_tRNS(m_hPNG, m_psPNGInfo, NULL, 0, &sTRNSColor);
3024 : }
3025 :
3026 : CSLDestroy(papszValues);
3027 : }
3028 : // Otherwise, get the nodata value from the bands.
3029 : else
3030 : {
3031 : int bHaveNoDataRed = FALSE;
3032 : const double dfNoDataValueRed =
3033 : GetRasterBand(1)->GetNoDataValue(&bHaveNoDataRed);
3034 :
3035 : int bHaveNoDataGreen = FALSE;
3036 : const double dfNoDataValueGreen =
3037 : GetRasterBand(2)->GetNoDataValue(&bHaveNoDataGreen);
3038 :
3039 : int bHaveNoDataBlue = FALSE;
3040 : const double dfNoDataValueBlue =
3041 : GetRasterBand(3)->GetNoDataValue(&bHaveNoDataBlue);
3042 :
3043 : if ((bHaveNoDataRed && dfNoDataValueRed >= 0 &&
3044 : dfNoDataValueRed < 65536) &&
3045 : (bHaveNoDataGreen && dfNoDataValueGreen >= 0 &&
3046 : dfNoDataValueGreen < 65536) &&
3047 : (bHaveNoDataBlue && dfNoDataValueBlue >= 0 &&
3048 : dfNoDataValueBlue < 65536))
3049 : {
3050 : sTRNSColor.red = static_cast<png_uint_16>(dfNoDataValueRed);
3051 : sTRNSColor.green = static_cast<png_uint_16>(dfNoDataValueGreen);
3052 : sTRNSColor.blue = static_cast<png_uint_16>(dfNoDataValueBlue);
3053 : png_set_tRNS(m_hPNG, m_psPNGInfo, NULL, 0, &sTRNSColor);
3054 : }
3055 : }
3056 : }
3057 :
3058 : // Write the palette if there is one. Technically, it may be possible
3059 : // to write 16-bit palettes for PNG, but for now, doing so is omitted.
3060 : if (nColorType == PNG_COLOR_TYPE_PALETTE)
3061 : {
3062 : GDALColorTable *poCT = GetRasterBand(1)->GetColorTable();
3063 :
3064 : int bHaveNoData = FALSE;
3065 : double dfNoDataValue = GetRasterBand(1)->GetNoDataValue(&bHaveNoData);
3066 :
3067 : m_pasPNGColors = reinterpret_cast<png_color *>(
3068 : CPLMalloc(sizeof(png_color) * poCT->GetColorEntryCount()));
3069 :
3070 : GDALColorEntry sEntry;
3071 : bool bFoundTrans = false;
3072 : for (int iColor = 0; iColor < poCT->GetColorEntryCount(); iColor++)
3073 : {
3074 : poCT->GetColorEntryAsRGB(iColor, &sEntry);
3075 : if (sEntry.c4 != 255)
3076 : bFoundTrans = true;
3077 :
3078 : m_pasPNGColors[iColor].red = static_cast<png_byte>(sEntry.c1);
3079 : m_pasPNGColors[iColor].green = static_cast<png_byte>(sEntry.c2);
3080 : m_pasPNGColors[iColor].blue = static_cast<png_byte>(sEntry.c3);
3081 : }
3082 :
3083 : png_set_PLTE(m_hPNG, m_psPNGInfo, m_pasPNGColors,
3084 : poCT->GetColorEntryCount());
3085 :
3086 : // If we have transparent elements in the palette, we need to write a
3087 : // transparency block.
3088 : if (bFoundTrans || bHaveNoData)
3089 : {
3090 : m_pabyAlpha = reinterpret_cast<unsigned char *>(
3091 : CPLMalloc(poCT->GetColorEntryCount()));
3092 :
3093 : for (int iColor = 0; iColor < poCT->GetColorEntryCount(); iColor++)
3094 : {
3095 : poCT->GetColorEntryAsRGB(iColor, &sEntry);
3096 : m_pabyAlpha[iColor] = static_cast<unsigned char>(sEntry.c4);
3097 :
3098 : if (bHaveNoData && iColor == static_cast<int>(dfNoDataValue))
3099 : m_pabyAlpha[iColor] = 0;
3100 : }
3101 :
3102 : png_set_tRNS(m_hPNG, m_psPNGInfo, m_pabyAlpha,
3103 : poCT->GetColorEntryCount(), NULL);
3104 : }
3105 : }
3106 :
3107 : png_write_info(m_hPNG, m_psPNGInfo);
3108 : return CE_None;
3109 : }
3110 :
3111 : /************************************************************************/
3112 : /* Create() */
3113 : /************************************************************************/
3114 :
3115 : GDALDataset *PNGDataset::Create(const char *pszFilename, int nXSize, int nYSize,
3116 : int nBands, GDALDataType eType,
3117 : char **papszOptions)
3118 : {
3119 : if (eType != GDT_Byte && eType != GDT_UInt16)
3120 : {
3121 : CPLError(
3122 : CE_Failure, CPLE_AppDefined,
3123 : "Attempt to create PNG dataset with an illegal\n"
3124 : "data type (%s), only Byte and UInt16 supported by the format.\n",
3125 : GDALGetDataTypeName(eType));
3126 :
3127 : return NULL;
3128 : }
3129 :
3130 : if (nBands < 1 || nBands > 4)
3131 : {
3132 : CPLError(CE_Failure, CPLE_NotSupported,
3133 : "PNG driver doesn't support %d bands. "
3134 : "Must be 1 (gray/indexed color),\n"
3135 : "2 (gray+alpha), 3 (rgb) or 4 (rgba) bands.\n",
3136 : nBands);
3137 :
3138 : return NULL;
3139 : }
3140 :
3141 : // Bands are:
3142 : // 1: Grayscale or indexed color.
3143 : // 2: Gray plus alpha.
3144 : // 3: RGB.
3145 : // 4: RGB plus alpha.
3146 :
3147 : if (nXSize < 1 || nYSize < 1)
3148 : {
3149 : CPLError(CE_Failure, CPLE_NotSupported,
3150 : "Specified pixel dimensions (% d x %d) are bad.\n", nXSize,
3151 : nYSize);
3152 : }
3153 :
3154 : // Set up some parameters.
3155 : PNGDataset *poDS = new PNGDataset();
3156 :
3157 : poDS->nRasterXSize = nXSize;
3158 : poDS->nRasterYSize = nYSize;
3159 : poDS->eAccess = GA_Update;
3160 : poDS->nBands = nBands;
3161 :
3162 : switch (nBands)
3163 : {
3164 : case 1:
3165 : poDS->m_nColorType = PNG_COLOR_TYPE_GRAY;
3166 : break; // If a non-gray palette is set, we'll change this.
3167 :
3168 : case 2:
3169 : poDS->m_nColorType = PNG_COLOR_TYPE_GRAY_ALPHA;
3170 : break;
3171 :
3172 : case 3:
3173 : poDS->m_nColorType = PNG_COLOR_TYPE_RGB;
3174 : break;
3175 :
3176 : case 4:
3177 : poDS->m_nColorType = PNG_COLOR_TYPE_RGB_ALPHA;
3178 : break;
3179 : }
3180 :
3181 : poDS->m_nBitDepth = (eType == GDT_Byte ? 8 : 16);
3182 :
3183 : poDS->m_pabyBuffer = reinterpret_cast<GByte *>(
3184 : CPLMalloc(nBands * nXSize * poDS->m_nBitDepth / 8));
3185 :
3186 : // Create band information objects.
3187 : for (int iBand = 1; iBand <= poDS->nBands; iBand++)
3188 : poDS->SetBand(iBand, new PNGRasterBand(poDS, iBand));
3189 :
3190 : // Do we need a world file?
3191 : if (CPLFetchBool(papszOptions, "WORLDFILE", false))
3192 : poDS->m_bGeoTransformValid = TRUE;
3193 :
3194 : // Create the file.
3195 :
3196 : poDS->m_fpImage = VSIFOpenL(pszFilename, "wb");
3197 : if (poDS->m_fpImage == NULL)
3198 : {
3199 : CPLError(CE_Failure, CPLE_OpenFailed,
3200 : "Unable to create PNG file %s: %s\n", pszFilename,
3201 : VSIStrerror(errno));
3202 : delete poDS;
3203 : return NULL;
3204 : }
3205 :
3206 : poDS->m_pszFilename = CPLStrdup(pszFilename);
3207 :
3208 : return poDS;
3209 : }
3210 :
3211 : #endif
|
