LCOV - code coverage report
Current view: top level - frmts/gtiff - gtiffdataset_read.cpp (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 3221 3526 91.3 %
Date: 2025-10-21 22:35:35 Functions: 54 54 100.0 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  GeoTIFF Driver
       4             :  * Purpose:  Read/get operations on GTiffDataset
       5             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 1998, 2002, Frank Warmerdam <warmerdam@pobox.com>
       9             :  * Copyright (c) 2007-2015, Even Rouault <even dot rouault at spatialys dot com>
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #include "gtiffdataset.h"
      15             : #include "gtiffrasterband.h"
      16             : #include "gtiffjpegoverviewds.h"
      17             : #include "gtiffrgbaband.h"
      18             : #include "gtiffbitmapband.h"
      19             : #include "gtiffsplitband.h"
      20             : #include "gtiffsplitbitmapband.h"
      21             : 
      22             : #include <algorithm>
      23             : #include <cassert>
      24             : #include <limits>
      25             : #include <memory>
      26             : #include <mutex>
      27             : #include <set>
      28             : #include <string>
      29             : #include <queue>
      30             : #include <tuple>
      31             : #include <utility>
      32             : 
      33             : #include "cpl_error.h"
      34             : #include "cpl_error_internal.h"  // CPLErrorHandlerAccumulatorStruct
      35             : #include "cpl_vsi.h"
      36             : #include "cpl_vsi_virtual.h"
      37             : #include "cpl_worker_thread_pool.h"
      38             : #include "fetchbufferdirectio.h"
      39             : #include "gdal_mdreader.h"  // MD_DOMAIN_RPC
      40             : #include "gdal_priv.h"
      41             : #include "geovalues.h"        // RasterPixelIsPoint
      42             : #include "gt_wkt_srs_priv.h"  // GDALGTIFKeyGetSHORT()
      43             : #include "tif_jxl.h"
      44             : #include "tifvsi.h"
      45             : #include "xtiffio.h"
      46             : 
      47             : #include "tiff_common.h"
      48             : 
      49             : /************************************************************************/
      50             : /*                        GetJPEGOverviewCount()                        */
      51             : /************************************************************************/
      52             : 
      53     1044380 : int GTiffDataset::GetJPEGOverviewCount()
      54             : {
      55     1044380 :     if (m_nJPEGOverviewCount >= 0)
      56     1044080 :         return m_nJPEGOverviewCount;
      57             : 
      58         298 :     m_nJPEGOverviewCount = 0;
      59         274 :     if (m_poBaseDS || eAccess != GA_ReadOnly ||
      60         226 :         m_nCompression != COMPRESSION_JPEG ||
      61          22 :         (nRasterXSize < 256 && nRasterYSize < 256) ||
      62         594 :         !CPLTestBool(CPLGetConfigOption("GTIFF_IMPLICIT_JPEG_OVR", "YES")) ||
      63          22 :         GDALGetDriverByName("JPEG") == nullptr)
      64             :     {
      65         276 :         return 0;
      66             :     }
      67             :     const char *pszSourceColorSpace =
      68          22 :         m_oGTiffMDMD.GetMetadataItem("SOURCE_COLOR_SPACE", "IMAGE_STRUCTURE");
      69          22 :     if (pszSourceColorSpace != nullptr && EQUAL(pszSourceColorSpace, "CMYK"))
      70             :     {
      71             :         // We cannot handle implicit overviews on JPEG CMYK datasets converted
      72             :         // to RGBA This would imply doing the conversion in
      73             :         // GTiffJPEGOverviewBand.
      74           1 :         return 0;
      75             :     }
      76             : 
      77             :     // libjpeg-6b only supports 2, 4 and 8 scale denominators.
      78             :     // TODO: Later versions support more.
      79          24 :     for (signed char i = 2; i >= 0; i--)
      80             :     {
      81          24 :         if (nRasterXSize >= (256 << i) || nRasterYSize >= (256 << i))
      82             :         {
      83          21 :             m_nJPEGOverviewCount = i + 1;
      84          21 :             break;
      85             :         }
      86             :     }
      87          21 :     if (m_nJPEGOverviewCount == 0)
      88           0 :         return 0;
      89             : 
      90             :     // Get JPEG tables.
      91          21 :     uint32_t nJPEGTableSize = 0;
      92          21 :     void *pJPEGTable = nullptr;
      93          21 :     GByte abyFFD8[] = {0xFF, 0xD8};
      94          21 :     if (TIFFGetField(m_hTIFF, TIFFTAG_JPEGTABLES, &nJPEGTableSize, &pJPEGTable))
      95             :     {
      96          20 :         if (pJPEGTable == nullptr || nJPEGTableSize < 2 ||
      97          20 :             nJPEGTableSize > INT_MAX ||
      98          20 :             static_cast<GByte *>(pJPEGTable)[nJPEGTableSize - 1] != 0xD9)
      99             :         {
     100           0 :             m_nJPEGOverviewCount = 0;
     101           0 :             return 0;
     102             :         }
     103          20 :         nJPEGTableSize--;  // Remove final 0xD9.
     104             :     }
     105             :     else
     106             :     {
     107           1 :         pJPEGTable = abyFFD8;
     108           1 :         nJPEGTableSize = 2;
     109             :     }
     110             : 
     111          21 :     m_papoJPEGOverviewDS = static_cast<GTiffJPEGOverviewDS **>(
     112          21 :         CPLMalloc(sizeof(GTiffJPEGOverviewDS *) * m_nJPEGOverviewCount));
     113          81 :     for (int i = 0; i < m_nJPEGOverviewCount; ++i)
     114             :     {
     115          60 :         m_papoJPEGOverviewDS[i] = new GTiffJPEGOverviewDS(
     116          60 :             this, i + 1, pJPEGTable, static_cast<int>(nJPEGTableSize));
     117             :     }
     118             : 
     119          21 :     m_nJPEGOverviewCountOri = m_nJPEGOverviewCount;
     120             : 
     121          21 :     return m_nJPEGOverviewCount;
     122             : }
     123             : 
     124             : /************************************************************************/
     125             : /*                       GetCompressionFormats()                        */
     126             : /************************************************************************/
     127             : 
     128           6 : CPLStringList GTiffDataset::GetCompressionFormats(int nXOff, int nYOff,
     129             :                                                   int nXSize, int nYSize,
     130             :                                                   int nBandCount,
     131             :                                                   const int *panBandList)
     132             : {
     133          18 :     if (m_nCompression != COMPRESSION_NONE &&
     134          11 :         IsWholeBlock(nXOff, nYOff, nXSize, nYSize) &&
     135           3 :         ((nBandCount == 1 && (panBandList || nBands == 1) &&
     136           3 :           m_nPlanarConfig == PLANARCONFIG_SEPARATE) ||
     137           5 :          (IsAllBands(nBandCount, panBandList) &&
     138           3 :           m_nPlanarConfig == PLANARCONFIG_CONTIG)))
     139             :     {
     140           6 :         CPLStringList aosList;
     141           3 :         int nBlockId =
     142           3 :             (nXOff / m_nBlockXSize) + (nYOff / m_nBlockYSize) * m_nBlocksPerRow;
     143           3 :         if (m_nPlanarConfig == PLANARCONFIG_SEPARATE && panBandList != nullptr)
     144           0 :             nBlockId += panBandList[0] * m_nBlocksPerBand;
     145             : 
     146           3 :         vsi_l_offset nOffset = 0;
     147           3 :         vsi_l_offset nSize = 0;
     148           6 :         if (IsBlockAvailable(nBlockId, &nOffset, &nSize, nullptr) &&
     149           3 :             nSize <
     150           3 :                 static_cast<vsi_l_offset>(std::numeric_limits<tmsize_t>::max()))
     151             :         {
     152           3 :             switch (m_nCompression)
     153             :             {
     154           3 :                 case COMPRESSION_JPEG:
     155             :                 {
     156           3 :                     if (m_nPlanarConfig == PLANARCONFIG_CONTIG && nBands == 4 &&
     157           7 :                         m_nPhotometric == PHOTOMETRIC_RGB &&
     158           1 :                         GetRasterBand(4)->GetColorInterpretation() ==
     159             :                             GCI_AlphaBand)
     160             :                     {
     161             :                         // as a hint for the JPEG and JPEGXL drivers to not use it!
     162           1 :                         aosList.AddString("JPEG;colorspace=RGBA");
     163             :                     }
     164             :                     else
     165             :                     {
     166           2 :                         aosList.AddString("JPEG");
     167             :                     }
     168           3 :                     break;
     169             :                 }
     170             : 
     171           0 :                 case COMPRESSION_WEBP:
     172           0 :                     aosList.AddString("WEBP");
     173           0 :                     break;
     174             : 
     175           0 :                 case COMPRESSION_JXL:
     176           0 :                     aosList.AddString("JXL");
     177           0 :                     break;
     178             : 
     179           0 :                 default:
     180           0 :                     break;
     181             :             }
     182             :         }
     183           3 :         return aosList;
     184             :     }
     185           3 :     return CPLStringList();
     186             : }
     187             : 
     188             : /************************************************************************/
     189             : /*                       ReadCompressedData()                           */
     190             : /************************************************************************/
     191             : 
     192          80 : CPLErr GTiffDataset::ReadCompressedData(const char *pszFormat, int nXOff,
     193             :                                         int nYOff, int nXSize, int nYSize,
     194             :                                         int nBandCount, const int *panBandList,
     195             :                                         void **ppBuffer, size_t *pnBufferSize,
     196             :                                         char **ppszDetailedFormat)
     197             : {
     198         185 :     if (m_nCompression != COMPRESSION_NONE &&
     199         104 :         IsWholeBlock(nXOff, nYOff, nXSize, nYSize) &&
     200           8 :         ((nBandCount == 1 && (panBandList != nullptr || nBands == 1) &&
     201           8 :           m_nPlanarConfig == PLANARCONFIG_SEPARATE) ||
     202          24 :          (IsAllBands(nBandCount, panBandList) &&
     203          24 :           m_nPlanarConfig == PLANARCONFIG_CONTIG)))
     204             :     {
     205          12 :         const CPLStringList aosTokens(CSLTokenizeString2(pszFormat, ";", 0));
     206          12 :         if (aosTokens.size() != 1)
     207           0 :             return CE_Failure;
     208             : 
     209             :         // We don't want to handle CMYK JPEG for now
     210          35 :         if ((m_nCompression == COMPRESSION_JPEG &&
     211          11 :              EQUAL(aosTokens[0], "JPEG") &&
     212          10 :              (m_nPlanarConfig == PLANARCONFIG_SEPARATE ||
     213          10 :               m_nPhotometric != PHOTOMETRIC_SEPARATED)) ||
     214           2 :             (m_nCompression == COMPRESSION_WEBP &&
     215          24 :              EQUAL(aosTokens[0], "WEBP")) ||
     216           2 :             ((m_nCompression == COMPRESSION_JXL ||
     217           2 :               m_nCompression == COMPRESSION_JXL_DNG_1_7) &&
     218           1 :              EQUAL(aosTokens[0], "JXL")))
     219             :         {
     220          11 :             std::string osDetailedFormat = aosTokens[0];
     221             : 
     222          11 :             int nBlockId = (nXOff / m_nBlockXSize) +
     223          11 :                            (nYOff / m_nBlockYSize) * m_nBlocksPerRow;
     224          11 :             if (m_nPlanarConfig == PLANARCONFIG_SEPARATE &&
     225             :                 panBandList != nullptr)
     226           0 :                 nBlockId += panBandList[0] * m_nBlocksPerBand;
     227             : 
     228          11 :             vsi_l_offset nOffset = 0;
     229          11 :             vsi_l_offset nSize = 0;
     230          22 :             if (IsBlockAvailable(nBlockId, &nOffset, &nSize, nullptr) &&
     231          11 :                 nSize < static_cast<vsi_l_offset>(
     232          11 :                             std::numeric_limits<tmsize_t>::max()))
     233             :             {
     234          11 :                 uint32_t nJPEGTableSize = 0;
     235          11 :                 void *pJPEGTable = nullptr;
     236          11 :                 if (m_nCompression == COMPRESSION_JPEG)
     237             :                 {
     238          10 :                     if (TIFFGetField(m_hTIFF, TIFFTAG_JPEGTABLES,
     239          10 :                                      &nJPEGTableSize, &pJPEGTable) &&
     240          10 :                         pJPEGTable != nullptr && nJPEGTableSize > 4 &&
     241          10 :                         static_cast<GByte *>(pJPEGTable)[0] == 0xFF &&
     242          10 :                         static_cast<GByte *>(pJPEGTable)[1] == 0xD8 &&
     243          10 :                         static_cast<GByte *>(pJPEGTable)[nJPEGTableSize - 2] ==
     244          20 :                             0xFF &&
     245          10 :                         static_cast<GByte *>(pJPEGTable)[nJPEGTableSize - 1] ==
     246             :                             0xD9)
     247             :                     {
     248          10 :                         pJPEGTable = static_cast<GByte *>(pJPEGTable) + 2;
     249          10 :                         nJPEGTableSize -= 4;
     250             :                     }
     251             :                     else
     252             :                     {
     253           0 :                         nJPEGTableSize = 0;
     254             :                     }
     255             :                 }
     256             : 
     257          11 :                 size_t nSizeSize = static_cast<size_t>(nSize + nJPEGTableSize);
     258          11 :                 if (ppBuffer)
     259             :                 {
     260           9 :                     if (!pnBufferSize)
     261           1 :                         return CE_Failure;
     262           8 :                     bool bFreeOnError = false;
     263           8 :                     if (*ppBuffer)
     264             :                     {
     265           3 :                         if (*pnBufferSize < nSizeSize)
     266           1 :                             return CE_Failure;
     267             :                     }
     268             :                     else
     269             :                     {
     270           5 :                         *ppBuffer = VSI_MALLOC_VERBOSE(nSizeSize);
     271           5 :                         if (*ppBuffer == nullptr)
     272           0 :                             return CE_Failure;
     273           5 :                         bFreeOnError = true;
     274             :                     }
     275           7 :                     const auto nTileSize = static_cast<tmsize_t>(nSize);
     276             :                     bool bOK;
     277           7 :                     if (TIFFIsTiled(m_hTIFF))
     278             :                     {
     279           3 :                         bOK = TIFFReadRawTile(m_hTIFF, nBlockId, *ppBuffer,
     280             :                                               nTileSize) == nTileSize;
     281             :                     }
     282             :                     else
     283             :                     {
     284           4 :                         bOK = TIFFReadRawStrip(m_hTIFF, nBlockId, *ppBuffer,
     285             :                                                nTileSize) == nTileSize;
     286             :                     }
     287           7 :                     if (!bOK)
     288             :                     {
     289           0 :                         if (bFreeOnError)
     290             :                         {
     291           0 :                             VSIFree(*ppBuffer);
     292           0 :                             *ppBuffer = nullptr;
     293             :                         }
     294           0 :                         return CE_Failure;
     295             :                     }
     296           7 :                     if (nJPEGTableSize > 0)
     297             :                     {
     298           6 :                         GByte *pabyBuffer = static_cast<GByte *>(*ppBuffer);
     299           6 :                         memmove(pabyBuffer + 2 + nJPEGTableSize, pabyBuffer + 2,
     300           6 :                                 static_cast<size_t>(nSize) - 2);
     301           6 :                         memcpy(pabyBuffer + 2, pJPEGTable, nJPEGTableSize);
     302             :                     }
     303             : 
     304           7 :                     if (m_nCompression == COMPRESSION_JPEG)
     305             :                     {
     306          12 :                         osDetailedFormat = GDALGetCompressionFormatForJPEG(
     307           6 :                             *ppBuffer, nSizeSize);
     308             :                         const CPLStringList aosTokens2(CSLTokenizeString2(
     309          12 :                             osDetailedFormat.c_str(), ";", 0));
     310          18 :                         if (m_nPlanarConfig == PLANARCONFIG_CONTIG &&
     311           7 :                             nBands == 4 && m_nPhotometric == PHOTOMETRIC_RGB &&
     312           1 :                             GetRasterBand(4)->GetColorInterpretation() ==
     313             :                                 GCI_AlphaBand)
     314             :                         {
     315           1 :                             osDetailedFormat = aosTokens2[0];
     316           5 :                             for (int i = 1; i < aosTokens2.size(); ++i)
     317             :                             {
     318           4 :                                 if (!STARTS_WITH_CI(aosTokens2[i],
     319             :                                                     "colorspace="))
     320             :                                 {
     321           3 :                                     osDetailedFormat += ';';
     322           3 :                                     osDetailedFormat += aosTokens2[i];
     323             :                                 }
     324             :                             }
     325           1 :                             osDetailedFormat += ";colorspace=RGBA";
     326             :                         }
     327             :                     }
     328             :                 }
     329           9 :                 if (ppszDetailedFormat)
     330           3 :                     *ppszDetailedFormat = VSIStrdup(osDetailedFormat.c_str());
     331           9 :                 if (pnBufferSize)
     332           8 :                     *pnBufferSize = nSizeSize;
     333           9 :                 return CE_None;
     334             :             }
     335             :         }
     336             :     }
     337          69 :     return CE_Failure;
     338             : }
     339             : 
     340             : struct GTiffDecompressContext
     341             : {
     342             :     // The mutex must be recursive because ThreadDecompressionFuncErrorHandler()
     343             :     // which acquires the mutex can be called from a section where the mutex is
     344             :     // already acquired.
     345             :     std::recursive_mutex oMutex{};
     346             :     bool bSuccess = true;
     347             :     CPLErrorAccumulator oErrorAccumulator{};
     348             : 
     349             :     VSIVirtualHandle *poHandle = nullptr;
     350             :     GTiffDataset *poDS = nullptr;
     351             :     GDALDataType eDT = GDT_Unknown;
     352             :     int nXOff = 0;
     353             :     int nYOff = 0;
     354             :     int nXSize = 0;
     355             :     int nYSize = 0;
     356             :     int nBlockXStart = 0;
     357             :     int nBlockYStart = 0;
     358             :     int nBlockXEnd = 0;
     359             :     int nBlockYEnd = 0;
     360             :     GByte *pabyData = nullptr;
     361             :     GDALDataType eBufType = GDT_Unknown;
     362             :     int nBufDTSize = 0;
     363             :     int nBandCount = 0;
     364             :     const int *panBandMap = nullptr;
     365             :     GSpacing nPixelSpace = 0;
     366             :     GSpacing nLineSpace = 0;
     367             :     GSpacing nBandSpace = 0;
     368             :     bool bHasPRead = false;
     369             :     bool bCacheAllBands = false;
     370             :     bool bSkipBlockCache = false;
     371             :     bool bUseBIPOptim = false;
     372             :     bool bUseDeinterleaveOptimNoBlockCache = false;
     373             :     bool bUseDeinterleaveOptimBlockCache = false;
     374             :     bool bIsTiled = false;
     375             :     bool bTIFFIsBigEndian = false;
     376             :     int nBlocksPerRow = 0;
     377             : 
     378             :     uint16_t nPredictor = 0;
     379             : 
     380             :     uint32_t nJPEGTableSize = 0;
     381             :     void *pJPEGTable = nullptr;
     382             :     uint16_t nYCrbCrSubSampling0 = 2;
     383             :     uint16_t nYCrbCrSubSampling1 = 2;
     384             : 
     385             :     uint16_t *pExtraSamples = nullptr;
     386             :     uint16_t nExtraSampleCount = 0;
     387             : };
     388             : 
     389             : struct GTiffDecompressJob
     390             : {
     391             :     GTiffDecompressContext *psContext = nullptr;
     392             :     int iSrcBandIdxSeparate =
     393             :         0;  // in [0, GetRasterCount()-1] in PLANARCONFIG_SEPARATE, or -1 in PLANARCONFIG_CONTIG
     394             :     int iDstBandIdxSeparate =
     395             :         0;  // in [0, nBandCount-1] in PLANARCONFIG_SEPARATE, or -1 in PLANARCONFIG_CONTIG
     396             :     int nXBlock = 0;
     397             :     int nYBlock = 0;
     398             :     vsi_l_offset nOffset = 0;
     399             :     vsi_l_offset nSize = 0;
     400             : };
     401             : 
     402             : /************************************************************************/
     403             : /*                     ThreadDecompressionFunc()                        */
     404             : /************************************************************************/
     405             : 
     406        3774 : /* static */ void GTiffDataset::ThreadDecompressionFunc(void *pData)
     407             : {
     408        3774 :     const auto psJob = static_cast<const GTiffDecompressJob *>(pData);
     409        3774 :     auto psContext = psJob->psContext;
     410        3774 :     auto poDS = psContext->poDS;
     411             : 
     412        3774 :     auto oAccumulator = psContext->oErrorAccumulator.InstallForCurrentScope();
     413             : 
     414        3800 :     const int nBandsPerStrile =
     415        3800 :         poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG ? poDS->nBands : 1;
     416        7600 :     const int nBandsToWrite = poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     417        3800 :                                   ? psContext->nBandCount
     418             :                                   : 1;
     419             : 
     420        7600 :     const int nXOffsetInBlock = psJob->nXBlock == psContext->nBlockXStart
     421        3800 :                                     ? psContext->nXOff % poDS->m_nBlockXSize
     422             :                                     : 0;
     423        3800 :     const int nXOffsetInData =
     424        3800 :         psJob->nXBlock == psContext->nBlockXStart
     425        3800 :             ? 0
     426        2439 :             : (psJob->nXBlock - psContext->nBlockXStart) * poDS->m_nBlockXSize -
     427        2439 :                   (psContext->nXOff % poDS->m_nBlockXSize);
     428        3800 :     const int nXSize =
     429        3800 :         psJob->nXBlock == psContext->nBlockXStart
     430        7600 :             ? (psJob->nXBlock == psContext->nBlockXEnd
     431        1363 :                    ? psContext->nXSize
     432         471 :                    : poDS->m_nBlockXSize -
     433         471 :                          (psContext->nXOff % poDS->m_nBlockXSize))
     434        2437 :         : psJob->nXBlock == psContext->nBlockXEnd
     435        2908 :             ? (((psContext->nXOff + psContext->nXSize) % poDS->m_nBlockXSize) ==
     436             :                        0
     437         471 :                    ? poDS->m_nBlockXSize
     438         400 :                    : ((psContext->nXOff + psContext->nXSize) %
     439         400 :                       poDS->m_nBlockXSize))
     440        1966 :             : poDS->m_nBlockXSize;
     441             : 
     442        7600 :     const int nYOffsetInBlock = psJob->nYBlock == psContext->nBlockYStart
     443        3800 :                                     ? psContext->nYOff % poDS->m_nBlockYSize
     444             :                                     : 0;
     445        3800 :     const int nYOffsetInData =
     446        3800 :         psJob->nYBlock == psContext->nBlockYStart
     447        3800 :             ? 0
     448        2884 :             : (psJob->nYBlock - psContext->nBlockYStart) * poDS->m_nBlockYSize -
     449        2884 :                   (psContext->nYOff % poDS->m_nBlockYSize);
     450        3800 :     const int nYSize =
     451        3800 :         psJob->nYBlock == psContext->nBlockYStart
     452        7600 :             ? (psJob->nYBlock == psContext->nBlockYEnd
     453         915 :                    ? psContext->nYSize
     454         915 :                    : poDS->m_nBlockYSize -
     455         915 :                          (psContext->nYOff % poDS->m_nBlockYSize))
     456        2885 :         : psJob->nYBlock == psContext->nBlockYEnd
     457        3801 :             ? (((psContext->nYOff + psContext->nYSize) % poDS->m_nBlockYSize) ==
     458             :                        0
     459         916 :                    ? poDS->m_nBlockYSize
     460         801 :                    : ((psContext->nYOff + psContext->nYSize) %
     461         801 :                       poDS->m_nBlockYSize))
     462        1969 :             : poDS->m_nBlockYSize;
     463             : #if 0
     464             :     CPLDebug("GTiff",
     465             :              "nXBlock = %d, nYBlock = %d, "
     466             :              "nXOffsetInBlock = %d, nXOffsetInData = %d, nXSize = %d, "
     467             :              "nYOffsetInBlock = %d, nYOffsetInData = %d, nYSize = %d\n",
     468             :              psJob->nXBlock, psJob->nYBlock,
     469             :              nXOffsetInBlock, nXOffsetInData, nXSize,
     470             :              nYOffsetInBlock, nYOffsetInData, nYSize);
     471             : #endif
     472             : 
     473        3800 :     if (psJob->nSize == 0)
     474             :     {
     475             :         {
     476           2 :             std::lock_guard<std::recursive_mutex> oLock(psContext->oMutex);
     477           2 :             if (!psContext->bSuccess)
     478           0 :                 return;
     479             :         }
     480           2 :         const double dfNoDataValue =
     481           2 :             poDS->m_bNoDataSet ? poDS->m_dfNoDataValue : 0;
     482         102 :         for (int y = 0; y < nYSize; ++y)
     483             :         {
     484         200 :             for (int i = 0; i < nBandsToWrite; ++i)
     485             :             {
     486         100 :                 const int iDstBandIdx =
     487         100 :                     poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     488         100 :                         ? i
     489           0 :                         : psJob->iDstBandIdxSeparate;
     490         100 :                 GDALCopyWords64(
     491             :                     &dfNoDataValue, GDT_Float64, 0,
     492         100 :                     psContext->pabyData + iDstBandIdx * psContext->nBandSpace +
     493         100 :                         (y + nYOffsetInData) * psContext->nLineSpace +
     494         100 :                         nXOffsetInData * psContext->nPixelSpace,
     495             :                     psContext->eBufType,
     496         100 :                     static_cast<int>(psContext->nPixelSpace), nXSize);
     497             :             }
     498             :         }
     499           2 :         return;
     500             :     }
     501             : 
     502        3798 :     const int nBandsToCache =
     503        3798 :         psContext->bCacheAllBands ? poDS->nBands : nBandsToWrite;
     504        3798 :     std::vector<GDALRasterBlock *> apoBlocks(nBandsToCache);
     505        3790 :     std::vector<bool> abAlreadyLoadedBlocks(nBandsToCache);
     506        3782 :     int nAlreadyLoadedBlocks = 0;
     507        3782 :     std::vector<GByte> abyInput;
     508             : 
     509             :     struct FreeBlocks
     510             :     {
     511             :         std::vector<GDALRasterBlock *> &m_apoBlocks;
     512             : 
     513        3789 :         explicit FreeBlocks(std::vector<GDALRasterBlock *> &apoBlocksIn)
     514        3789 :             : m_apoBlocks(apoBlocksIn)
     515             :         {
     516        3789 :         }
     517             : 
     518        3800 :         ~FreeBlocks()
     519        3800 :         {
     520       10442 :             for (auto *poBlock : m_apoBlocks)
     521             :             {
     522        6642 :                 if (poBlock)
     523        3964 :                     poBlock->DropLock();
     524             :             }
     525        3800 :         }
     526             :     };
     527             : 
     528        3777 :     FreeBlocks oFreeBlocks(apoBlocks);
     529             : 
     530        1752 :     const auto LoadBlocks = [&]()
     531             :     {
     532        5716 :         for (int i = 0; i < nBandsToCache; ++i)
     533             :         {
     534        6244 :             const int iBand = psContext->bCacheAllBands ? i + 1
     535        7256 :                               : poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     536        2280 :                                   ? psContext->panBandMap[i]
     537         660 :                                   : psJob->iSrcBandIdxSeparate + 1;
     538        7928 :             apoBlocks[i] = poDS->GetRasterBand(iBand)->TryGetLockedBlockRef(
     539        3964 :                 psJob->nXBlock, psJob->nYBlock);
     540        3964 :             if (apoBlocks[i] == nullptr)
     541             :             {
     542             :                 // Temporary disabling of dirty block flushing, otherwise
     543             :                 // we can be in a deadlock situation, where the
     544             :                 // GTiffDataset::SubmitCompressionJob() method waits for jobs
     545             :                 // to be finished, that can't finish (actually be started)
     546             :                 // because this task and its siblings are taking all the
     547             :                 // available workers allowed by the global thread pool.
     548        1012 :                 GDALRasterBlock::EnterDisableDirtyBlockFlush();
     549        2024 :                 apoBlocks[i] = poDS->GetRasterBand(iBand)->GetLockedBlockRef(
     550        1012 :                     psJob->nXBlock, psJob->nYBlock, TRUE);
     551        1012 :                 GDALRasterBlock::LeaveDisableDirtyBlockFlush();
     552        1012 :                 if (apoBlocks[i] == nullptr)
     553           0 :                     return false;
     554             :             }
     555             :             else
     556             :             {
     557        2952 :                 abAlreadyLoadedBlocks[i] = true;
     558        2952 :                 nAlreadyLoadedBlocks++;
     559             :             }
     560             :         }
     561        1752 :         return true;
     562        3785 :     };
     563             : 
     564        2580 :     const auto AllocInputBuffer = [&]()
     565             :     {
     566        2580 :         bool bError = false;
     567             : #if SIZEOF_VOIDP == 4
     568             :         if (psJob->nSize != static_cast<size_t>(psJob->nSize))
     569             :         {
     570             :             bError = true;
     571             :         }
     572             :         else
     573             : #endif
     574             :         {
     575             :             try
     576             :             {
     577        2580 :                 abyInput.resize(static_cast<size_t>(psJob->nSize));
     578             :             }
     579           0 :             catch (const std::exception &)
     580             :             {
     581           0 :                 bError = true;
     582             :             }
     583             :         }
     584        2573 :         if (bError)
     585             :         {
     586           0 :             CPLError(CE_Failure, CPLE_OutOfMemory,
     587             :                      "Cannot allocate working buffer of size " CPL_FRMT_GUIB,
     588           0 :                      static_cast<GUIntBig>(psJob->nSize));
     589           0 :             return false;
     590             :         }
     591        2573 :         return true;
     592        3785 :     };
     593             : 
     594        3785 :     if (psContext->bHasPRead)
     595             :     {
     596             :         {
     597        3785 :             std::lock_guard<std::recursive_mutex> oLock(psContext->oMutex);
     598        3800 :             if (!psContext->bSuccess)
     599           0 :                 return;
     600             : 
     601             :             // Coverity Scan notices that GDALRasterBlock::Internalize() calls
     602             :             // CPLSleep() in a debug code path, and warns about that while
     603             :             // holding the above mutex.
     604             :             // coverity[sleep]
     605        3800 :             if (!psContext->bSkipBlockCache && !LoadBlocks())
     606             :             {
     607           0 :                 psContext->bSuccess = false;
     608           0 :                 return;
     609             :             }
     610             :         }
     611        3800 :         if (nAlreadyLoadedBlocks != nBandsToCache)
     612             :         {
     613        2580 :             if (!AllocInputBuffer())
     614             :             {
     615           0 :                 std::lock_guard<std::recursive_mutex> oLock(psContext->oMutex);
     616           0 :                 psContext->bSuccess = false;
     617           0 :                 return;
     618             :             }
     619        2575 :             if (psContext->poHandle->PRead(abyInput.data(), abyInput.size(),
     620        5130 :                                            psJob->nOffset) != abyInput.size())
     621             :             {
     622           0 :                 CPLError(CE_Failure, CPLE_AppDefined,
     623             :                          "Cannot read " CPL_FRMT_GUIB
     624             :                          " bytes at offset " CPL_FRMT_GUIB,
     625           0 :                          static_cast<GUIntBig>(psJob->nSize),
     626           0 :                          static_cast<GUIntBig>(psJob->nOffset));
     627             : 
     628           0 :                 std::lock_guard<std::recursive_mutex> oLock(psContext->oMutex);
     629           0 :                 psContext->bSuccess = false;
     630           0 :                 return;
     631             :             }
     632             :         }
     633             :     }
     634             :     else
     635             :     {
     636           0 :         std::lock_guard<std::recursive_mutex> oLock(psContext->oMutex);
     637           0 :         if (!psContext->bSuccess)
     638           0 :             return;
     639             : 
     640             :         // Coverity Scan notices that GDALRasterBlock::Internalize() calls
     641             :         // CPLSleep() in a debug code path, and warns about that while
     642             :         // holding the above mutex.
     643             :         // coverity[sleep]
     644           0 :         if (!psContext->bSkipBlockCache && !LoadBlocks())
     645             :         {
     646           0 :             psContext->bSuccess = false;
     647           0 :             return;
     648             :         }
     649             : 
     650           0 :         if (nAlreadyLoadedBlocks != nBandsToCache)
     651             :         {
     652           0 :             if (!AllocInputBuffer())
     653             :             {
     654           0 :                 psContext->bSuccess = false;
     655           0 :                 return;
     656             :             }
     657           0 :             if (psContext->poHandle->Seek(psJob->nOffset, SEEK_SET) != 0 ||
     658           0 :                 psContext->poHandle->Read(abyInput.data(), abyInput.size(),
     659           0 :                                           1) != 1)
     660             :             {
     661           0 :                 CPLError(CE_Failure, CPLE_AppDefined,
     662             :                          "Cannot read " CPL_FRMT_GUIB
     663             :                          " bytes at offset " CPL_FRMT_GUIB,
     664           0 :                          static_cast<GUIntBig>(psJob->nSize),
     665           0 :                          static_cast<GUIntBig>(psJob->nOffset));
     666           0 :                 psContext->bSuccess = false;
     667           0 :                 return;
     668             :             }
     669             :         }
     670             :     }
     671             : 
     672        3785 :     const int nDTSize = GDALGetDataTypeSizeBytes(psContext->eDT);
     673        3795 :     GByte *pDstPtr = psContext->pabyData +
     674        3795 :                      nYOffsetInData * psContext->nLineSpace +
     675        3795 :                      nXOffsetInData * psContext->nPixelSpace;
     676             : 
     677        3795 :     if (nAlreadyLoadedBlocks != nBandsToCache)
     678             :     {
     679             :         // Generate a dummy in-memory TIFF file that has all the needed tags
     680             :         // from the original file
     681             :         const CPLString osTmpFilename(
     682        2572 :             VSIMemGenerateHiddenFilename("decompress.tif"));
     683        2577 :         VSILFILE *fpTmp = VSIFOpenL(osTmpFilename.c_str(), "wb+");
     684             :         TIFF *hTIFFTmp =
     685        2580 :             VSI_TIFFOpen(osTmpFilename.c_str(),
     686        2580 :                          psContext->bTIFFIsBigEndian ? "wb+" : "wl+", fpTmp);
     687        2580 :         CPLAssert(hTIFFTmp != nullptr);
     688        2580 :         const int nBlockYSize =
     689        3036 :             (psContext->bIsTiled ||
     690         456 :              psJob->nYBlock < poDS->m_nBlocksPerColumn - 1)
     691        3036 :                 ? poDS->m_nBlockYSize
     692          53 :             : (poDS->nRasterYSize % poDS->m_nBlockYSize) == 0
     693          53 :                 ? poDS->m_nBlockYSize
     694          42 :                 : poDS->nRasterYSize % poDS->m_nBlockYSize;
     695        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_IMAGEWIDTH, poDS->m_nBlockXSize);
     696        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_IMAGELENGTH, nBlockYSize);
     697        2579 :         TIFFSetField(hTIFFTmp, TIFFTAG_BITSPERSAMPLE, poDS->m_nBitsPerSample);
     698        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_COMPRESSION, poDS->m_nCompression);
     699        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_PHOTOMETRIC, poDS->m_nPhotometric);
     700        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_SAMPLEFORMAT, poDS->m_nSampleFormat);
     701        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_SAMPLESPERPIXEL,
     702        2580 :                      poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     703         760 :                          ? poDS->m_nSamplesPerPixel
     704             :                          : 1);
     705        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_ROWSPERSTRIP, nBlockYSize);
     706        2580 :         TIFFSetField(hTIFFTmp, TIFFTAG_PLANARCONFIG, poDS->m_nPlanarConfig);
     707        2580 :         if (psContext->nPredictor != PREDICTOR_NONE)
     708          60 :             TIFFSetField(hTIFFTmp, TIFFTAG_PREDICTOR, psContext->nPredictor);
     709        2580 :         if (poDS->m_nCompression == COMPRESSION_LERC)
     710             :         {
     711          30 :             TIFFSetField(hTIFFTmp, TIFFTAG_LERC_PARAMETERS, 2,
     712          30 :                          poDS->m_anLercAddCompressionAndVersion);
     713             :         }
     714        2550 :         else if (poDS->m_nCompression == COMPRESSION_JPEG)
     715             :         {
     716          14 :             if (psContext->pJPEGTable)
     717             :             {
     718          14 :                 TIFFSetField(hTIFFTmp, TIFFTAG_JPEGTABLES,
     719             :                              psContext->nJPEGTableSize, psContext->pJPEGTable);
     720             :             }
     721          14 :             if (poDS->m_nPhotometric == PHOTOMETRIC_YCBCR)
     722             :             {
     723           7 :                 TIFFSetField(hTIFFTmp, TIFFTAG_YCBCRSUBSAMPLING,
     724           7 :                              psContext->nYCrbCrSubSampling0,
     725           7 :                              psContext->nYCrbCrSubSampling1);
     726             :             }
     727             :         }
     728        2580 :         if (poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG)
     729             :         {
     730         760 :             if (psContext->pExtraSamples)
     731             :             {
     732          66 :                 TIFFSetField(hTIFFTmp, TIFFTAG_EXTRASAMPLES,
     733          66 :                              psContext->nExtraSampleCount,
     734             :                              psContext->pExtraSamples);
     735             :             }
     736             :             else
     737             :             {
     738         694 :                 const int nSamplesAccountedFor =
     739         916 :                     poDS->m_nPhotometric == PHOTOMETRIC_RGB          ? 3
     740         222 :                     : poDS->m_nPhotometric == PHOTOMETRIC_MINISBLACK ? 1
     741             :                                                                      : 0;
     742         694 :                 if (nSamplesAccountedFor > 0 &&
     743         687 :                     poDS->m_nSamplesPerPixel > nSamplesAccountedFor)
     744             :                 {
     745             :                     // If the input image is not compliant regarndig ExtraSamples,
     746             :                     // generate a synthetic one to avoid gazillons of warnings
     747           0 :                     const auto nExtraSampleCount = static_cast<uint16_t>(
     748           0 :                         poDS->m_nSamplesPerPixel - nSamplesAccountedFor);
     749             :                     std::vector<uint16_t> anExtraSamples(
     750           0 :                         nExtraSampleCount, EXTRASAMPLE_UNSPECIFIED);
     751           0 :                     TIFFSetField(hTIFFTmp, TIFFTAG_EXTRASAMPLES,
     752             :                                  nExtraSampleCount, anExtraSamples.data());
     753             :                 }
     754             :             }
     755             :         }
     756        2580 :         TIFFWriteCheck(hTIFFTmp, FALSE, "ThreadDecompressionFunc");
     757        2580 :         TIFFWriteDirectory(hTIFFTmp);
     758        2580 :         XTIFFClose(hTIFFTmp);
     759             : 
     760             :         // Re-open file
     761        2580 :         hTIFFTmp = VSI_TIFFOpen(osTmpFilename.c_str(), "r", fpTmp);
     762        2580 :         CPLAssert(hTIFFTmp != nullptr);
     763        2580 :         poDS->RestoreVolatileParameters(hTIFFTmp);
     764             : 
     765        2580 :         bool bRet = true;
     766             :         // Request m_nBlockYSize line in the block, except on the bottom-most
     767             :         // tile/strip.
     768        2580 :         const int nBlockReqYSize =
     769        2580 :             (psJob->nYBlock < poDS->m_nBlocksPerColumn - 1)
     770        3169 :                 ? poDS->m_nBlockYSize
     771         589 :             : (poDS->nRasterYSize % poDS->m_nBlockYSize) == 0
     772         589 :                 ? poDS->m_nBlockYSize
     773         546 :                 : poDS->nRasterYSize % poDS->m_nBlockYSize;
     774             : 
     775        2580 :         const size_t nReqSize = static_cast<size_t>(poDS->m_nBlockXSize) *
     776        2580 :                                 nBlockReqYSize * nBandsPerStrile * nDTSize;
     777             : 
     778             :         GByte *pabyOutput;
     779        2580 :         std::vector<GByte> abyOutput;
     780        5384 :         if (poDS->m_nCompression == COMPRESSION_NONE &&
     781        2804 :             !TIFFIsByteSwapped(poDS->m_hTIFF) && abyInput.size() >= nReqSize &&
     782         224 :             (psContext->bSkipBlockCache || nBandsPerStrile > 1))
     783             :         {
     784         224 :             pabyOutput = abyInput.data();
     785             :         }
     786             :         else
     787             :         {
     788        2356 :             if (psContext->bSkipBlockCache || nBandsPerStrile > 1)
     789             :             {
     790        2060 :                 abyOutput.resize(nReqSize);
     791        2060 :                 pabyOutput = abyOutput.data();
     792             :             }
     793             :             else
     794             :             {
     795         296 :                 pabyOutput = static_cast<GByte *>(apoBlocks[0]->GetDataRef());
     796             :             }
     797        2356 :             if (!TIFFReadFromUserBuffer(hTIFFTmp, 0, abyInput.data(),
     798        2355 :                                         abyInput.size(), pabyOutput,
     799        2356 :                                         nReqSize) &&
     800           0 :                 !poDS->m_bIgnoreReadErrors)
     801             :             {
     802           0 :                 bRet = false;
     803             :             }
     804             :         }
     805        2580 :         XTIFFClose(hTIFFTmp);
     806        2580 :         CPL_IGNORE_RET_VAL(VSIFCloseL(fpTmp));
     807        2578 :         VSIUnlink(osTmpFilename.c_str());
     808             : 
     809        2580 :         if (!bRet)
     810             :         {
     811           0 :             std::lock_guard<std::recursive_mutex> oLock(psContext->oMutex);
     812           0 :             psContext->bSuccess = false;
     813           0 :             return;
     814             :         }
     815             : 
     816        2580 :         if (!psContext->bSkipBlockCache && nBandsPerStrile > 1)
     817             :         {
     818             :             // Copy pixel-interleaved all-band buffer to cached blocks
     819             : 
     820         236 :             if (psContext->bUseDeinterleaveOptimBlockCache)
     821             :             {
     822             :                 // Optimization
     823         232 :                 std::vector<void *> ppDestBuffers(poDS->nBands);
     824         464 :                 for (int i = 0; i < poDS->nBands; ++i)
     825             :                 {
     826         348 :                     ppDestBuffers[i] = apoBlocks[i]->GetDataRef();
     827             :                 }
     828         116 :                 GDALDeinterleave(pabyOutput, psContext->eDT, poDS->nBands,
     829             :                                  ppDestBuffers.data(), psContext->eDT,
     830         116 :                                  static_cast<size_t>(nBlockReqYSize) *
     831         116 :                                      poDS->m_nBlockXSize);
     832             :             }
     833             :             else
     834             :             {
     835             :                 // General case
     836         488 :                 for (int i = 0; i < nBandsToCache; ++i)
     837             :                 {
     838         368 :                     if (!abAlreadyLoadedBlocks[i])
     839             :                     {
     840         736 :                         const int iBand = psContext->bCacheAllBands
     841         368 :                                               ? i
     842         368 :                                               : psContext->panBandMap[i] - 1;
     843         368 :                         GDALCopyWords64(pabyOutput + iBand * nDTSize,
     844         368 :                                         psContext->eDT, nDTSize * poDS->nBands,
     845         368 :                                         apoBlocks[i]->GetDataRef(),
     846             :                                         psContext->eDT, nDTSize,
     847         368 :                                         static_cast<size_t>(nBlockReqYSize) *
     848         368 :                                             poDS->m_nBlockXSize);
     849             :                     }
     850             :                 }
     851             :             }
     852             :         }
     853             : 
     854        2580 :         const GByte *pSrcPtr =
     855             :             pabyOutput +
     856        2580 :             (static_cast<size_t>(nYOffsetInBlock) * poDS->m_nBlockXSize +
     857        2580 :              nXOffsetInBlock) *
     858        2580 :                 nDTSize * nBandsPerStrile;
     859        2580 :         const size_t nSrcLineInc = static_cast<size_t>(poDS->m_nBlockXSize) *
     860        2580 :                                    nDTSize * nBandsPerStrile;
     861             : 
     862             :         // Optimization when writing to BIP buffer.
     863        2580 :         if (psContext->bUseBIPOptim)
     864             :         {
     865        9557 :             for (int y = 0; y < nYSize; ++y)
     866             :             {
     867        9252 :                 GDALCopyWords64(pSrcPtr, psContext->eDT, nDTSize, pDstPtr,
     868             :                                 psContext->eBufType, psContext->nBufDTSize,
     869        9252 :                                 static_cast<size_t>(nXSize) * poDS->nBands);
     870        9252 :                 pSrcPtr += nSrcLineInc;
     871        9252 :                 pDstPtr += psContext->nLineSpace;
     872             :             }
     873         305 :             return;
     874             :         }
     875             : 
     876        2275 :         if (psContext->bSkipBlockCache)
     877             :         {
     878             :             // Copy from pixel-interleaved all-band buffer (or temporary buffer
     879             :             // for single-band/separate case) into final buffer
     880        1759 :             if (psContext->bUseDeinterleaveOptimNoBlockCache)
     881             :             {
     882             :                 // Optimization
     883         215 :                 std::vector<void *> ppDestBuffers(psContext->nBandCount);
     884         860 :                 for (int i = 0; i < psContext->nBandCount; ++i)
     885             :                 {
     886         645 :                     ppDestBuffers[i] =
     887         645 :                         pDstPtr +
     888         645 :                         (psContext->panBandMap[i] - 1) * psContext->nBandSpace;
     889             :                 }
     890       12274 :                 for (int y = 0; y < nYSize; ++y)
     891             :                 {
     892       12059 :                     GDALDeinterleave(
     893             :                         pSrcPtr, psContext->eDT, psContext->nBandCount,
     894             :                         ppDestBuffers.data(), psContext->eDT, nXSize);
     895       12060 :                     pSrcPtr += nSrcLineInc;
     896       48205 :                     for (int i = 0; i < psContext->nBandCount; ++i)
     897             :                     {
     898       36145 :                         ppDestBuffers[i] =
     899       36146 :                             static_cast<GByte *>(ppDestBuffers[i]) +
     900       36149 :                             psContext->nLineSpace;
     901             :                     }
     902             :                 }
     903         215 :                 return;
     904             :             }
     905             : 
     906             :             // General case
     907       40244 :             for (int y = 0; y < nYSize; ++y)
     908             :             {
     909       78200 :                 for (int i = 0; i < nBandsToWrite; ++i)
     910             :                 {
     911       39500 :                     const int iSrcBandIdx =
     912       39500 :                         poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     913       39500 :                             ? psContext->panBandMap[i] - 1
     914             :                             : 0;
     915       39500 :                     const int iDstBandIdx =
     916       39500 :                         poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     917       39500 :                             ? i
     918       38500 :                             : psJob->iDstBandIdxSeparate;
     919       39500 :                     GDALCopyWords64(
     920       39500 :                         pSrcPtr + iSrcBandIdx * nDTSize + y * nSrcLineInc,
     921             :                         psContext->eDT, nDTSize * nBandsPerStrile,
     922       39500 :                         pDstPtr + iDstBandIdx * psContext->nBandSpace +
     923       39500 :                             y * psContext->nLineSpace,
     924             :                         psContext->eBufType,
     925       39500 :                         static_cast<int>(psContext->nPixelSpace), nXSize);
     926             :                 }
     927             :             }
     928        1544 :             return;
     929             :         }
     930             :     }
     931             : 
     932        1739 :     CPLAssert(!psContext->bSkipBlockCache);
     933             : 
     934             :     // Compose cached blocks into final buffer
     935        4548 :     for (int i = 0; i < nBandsToWrite; ++i)
     936             :     {
     937        2812 :         const int iSrcBandIdx =
     938        5076 :             psContext->bCacheAllBands ? psContext->panBandMap[i] - 1
     939        2264 :             : poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG ? i
     940             :                                                            : 0;
     941        2812 :         assert(iSrcBandIdx >= 0);
     942        5624 :         const int iDstBandIdx = poDS->m_nPlanarConfig == PLANARCONFIG_CONTIG
     943        2812 :                                     ? i
     944         661 :                                     : psJob->iDstBandIdxSeparate;
     945             :         const GByte *pSrcPtr =
     946        2812 :             static_cast<GByte *>(apoBlocks[iSrcBandIdx]->GetDataRef()) +
     947        2813 :             (static_cast<size_t>(nYOffsetInBlock) * poDS->m_nBlockXSize +
     948        2813 :              nXOffsetInBlock) *
     949        2813 :                 nDTSize;
     950       68193 :         for (int y = 0; y < nYSize; ++y)
     951             :         {
     952       65384 :             GDALCopyWords64(pSrcPtr + static_cast<size_t>(y) *
     953       65384 :                                           poDS->m_nBlockXSize * nDTSize,
     954             :                             psContext->eDT, nDTSize,
     955       65384 :                             pDstPtr + iDstBandIdx * psContext->nBandSpace +
     956       65384 :                                 y * psContext->nLineSpace,
     957             :                             psContext->eBufType,
     958       65384 :                             static_cast<int>(psContext->nPixelSpace), nXSize);
     959             :         }
     960             :     }
     961             : }
     962             : 
     963             : /************************************************************************/
     964             : /*                    IsMultiThreadedReadCompatible()                   */
     965             : /************************************************************************/
     966             : 
     967         265 : bool GTiffDataset::IsMultiThreadedReadCompatible() const
     968             : {
     969         265 :     return cpl::down_cast<GTiffRasterBand *>(papoBands[0])
     970         265 :                ->IsBaseGTiffClass() &&
     971         528 :            !m_bStreamingIn && !m_bStreamingOut &&
     972         263 :            (m_nCompression == COMPRESSION_NONE ||
     973         240 :             m_nCompression == COMPRESSION_ADOBE_DEFLATE ||
     974         221 :             m_nCompression == COMPRESSION_LZW ||
     975          86 :             m_nCompression == COMPRESSION_PACKBITS ||
     976          72 :             m_nCompression == COMPRESSION_LZMA ||
     977          58 :             m_nCompression == COMPRESSION_ZSTD ||
     978          44 :             m_nCompression == COMPRESSION_LERC ||
     979          30 :             m_nCompression == COMPRESSION_JXL ||
     980          30 :             m_nCompression == COMPRESSION_JXL_DNG_1_7 ||
     981          16 :             m_nCompression == COMPRESSION_WEBP ||
     982         267 :             m_nCompression == COMPRESSION_JPEG);
     983             : }
     984             : 
     985             : /************************************************************************/
     986             : /*                        MultiThreadedRead()                           */
     987             : /************************************************************************/
     988             : 
     989         247 : CPLErr GTiffDataset::MultiThreadedRead(int nXOff, int nYOff, int nXSize,
     990             :                                        int nYSize, void *pData,
     991             :                                        GDALDataType eBufType, int nBandCount,
     992             :                                        const int *panBandMap,
     993             :                                        GSpacing nPixelSpace,
     994             :                                        GSpacing nLineSpace, GSpacing nBandSpace)
     995             : {
     996         494 :     auto poQueue = m_poThreadPool->CreateJobQueue();
     997         247 :     if (poQueue == nullptr)
     998             :     {
     999           0 :         return CE_Failure;
    1000             :     }
    1001             : 
    1002         247 :     const int nBlockXStart = nXOff / m_nBlockXSize;
    1003         247 :     const int nBlockYStart = nYOff / m_nBlockYSize;
    1004         247 :     const int nBlockXEnd = (nXOff + nXSize - 1) / m_nBlockXSize;
    1005         247 :     const int nBlockYEnd = (nYOff + nYSize - 1) / m_nBlockYSize;
    1006         247 :     const int nXBlocks = nBlockXEnd - nBlockXStart + 1;
    1007         247 :     const int nYBlocks = nBlockYEnd - nBlockYStart + 1;
    1008         247 :     const int nStrilePerBlock =
    1009         247 :         m_nPlanarConfig == PLANARCONFIG_CONTIG ? 1 : nBandCount;
    1010         247 :     const int nBlocks = nXBlocks * nYBlocks * nStrilePerBlock;
    1011             : 
    1012         494 :     GTiffDecompressContext sContext;
    1013         247 :     sContext.poHandle = VSI_TIFFGetVSILFile(TIFFClientdata(m_hTIFF));
    1014         247 :     sContext.bHasPRead =
    1015         247 :         sContext.poHandle->HasPRead()
    1016             : #ifdef DEBUG
    1017         247 :         && CPLTestBool(CPLGetConfigOption("GTIFF_ALLOW_PREAD", "YES"))
    1018             : #endif
    1019             :         ;
    1020         247 :     sContext.poDS = this;
    1021         247 :     sContext.eDT = GetRasterBand(1)->GetRasterDataType();
    1022         247 :     sContext.nXOff = nXOff;
    1023         247 :     sContext.nYOff = nYOff;
    1024         247 :     sContext.nXSize = nXSize;
    1025         247 :     sContext.nYSize = nYSize;
    1026         247 :     sContext.nBlockXStart = nBlockXStart;
    1027         247 :     sContext.nBlockXEnd = nBlockXEnd;
    1028         247 :     sContext.nBlockYStart = nBlockYStart;
    1029         247 :     sContext.nBlockYEnd = nBlockYEnd;
    1030         247 :     sContext.pabyData = static_cast<GByte *>(pData);
    1031         247 :     sContext.eBufType = eBufType;
    1032         247 :     sContext.nBufDTSize = GDALGetDataTypeSizeBytes(eBufType);
    1033         247 :     sContext.nBandCount = nBandCount;
    1034         247 :     sContext.panBandMap = panBandMap;
    1035         247 :     sContext.nPixelSpace = nPixelSpace;
    1036         247 :     sContext.nLineSpace = nLineSpace;
    1037             :     // Setting nBandSpace to a dummy value when nBandCount == 1 helps detecting
    1038             :     // bad computations of target buffer address
    1039             :     // (https://github.com/rasterio/rasterio/issues/2847)
    1040         247 :     sContext.nBandSpace = nBandCount == 1 ? 0xDEADBEEF : nBandSpace;
    1041         247 :     sContext.bIsTiled = CPL_TO_BOOL(TIFFIsTiled(m_hTIFF));
    1042         247 :     sContext.bTIFFIsBigEndian = CPL_TO_BOOL(TIFFIsBigEndian(m_hTIFF));
    1043         247 :     sContext.nPredictor = PREDICTOR_NONE;
    1044         247 :     sContext.nBlocksPerRow = m_nBlocksPerRow;
    1045             : 
    1046         247 :     if (m_bDirectIO)
    1047             :     {
    1048           0 :         sContext.bSkipBlockCache = true;
    1049             :     }
    1050         247 :     else if (nXOff == 0 && nYOff == 0 && nXSize == nRasterXSize &&
    1051         191 :              nYSize == nRasterYSize)
    1052             :     {
    1053         190 :         if (m_nPlanarConfig == PLANARCONFIG_SEPARATE)
    1054             :         {
    1055          40 :             sContext.bSkipBlockCache = true;
    1056             :         }
    1057         150 :         else if (nBandCount == nBands)
    1058             :         {
    1059          74 :             sContext.bSkipBlockCache = true;
    1060         208 :             for (int i = 0; i < nBands; ++i)
    1061             :             {
    1062         158 :                 if (panBandMap[i] != i + 1)
    1063             :                 {
    1064          24 :                     sContext.bSkipBlockCache = false;
    1065          24 :                     break;
    1066             :                 }
    1067             :             }
    1068             :         }
    1069             :     }
    1070             : 
    1071         247 :     if (m_nPlanarConfig == PLANARCONFIG_CONTIG && nBandCount == nBands &&
    1072         115 :         nPixelSpace == nBands * static_cast<GSpacing>(sContext.nBufDTSize))
    1073             :     {
    1074          37 :         sContext.bUseBIPOptim = true;
    1075         126 :         for (int i = 0; i < nBands; ++i)
    1076             :         {
    1077          89 :             if (panBandMap[i] != i + 1)
    1078             :             {
    1079           0 :                 sContext.bUseBIPOptim = false;
    1080           0 :                 break;
    1081             :             }
    1082             :         }
    1083             :     }
    1084             : 
    1085         247 :     if (m_nPlanarConfig == PLANARCONFIG_CONTIG &&
    1086         191 :         (nBands == 3 || nBands == 4) && nBands == nBandCount &&
    1087          94 :         (sContext.eDT == GDT_Byte || sContext.eDT == GDT_Int16 ||
    1088           9 :          sContext.eDT == GDT_UInt16))
    1089             :     {
    1090          94 :         if (sContext.bSkipBlockCache)
    1091             :         {
    1092          36 :             if (sContext.eBufType == sContext.eDT &&
    1093          35 :                 nPixelSpace == sContext.nBufDTSize)
    1094             :             {
    1095          24 :                 sContext.bUseDeinterleaveOptimNoBlockCache = true;
    1096             :             }
    1097             :         }
    1098             :         else
    1099             :         {
    1100          58 :             sContext.bUseDeinterleaveOptimBlockCache = true;
    1101         166 :             for (int i = 0; i < nBands; ++i)
    1102             :             {
    1103         130 :                 if (panBandMap[i] != i + 1)
    1104             :                 {
    1105          22 :                     sContext.bUseDeinterleaveOptimBlockCache = false;
    1106          22 :                     break;
    1107             :                 }
    1108             :             }
    1109             :         }
    1110             :     }
    1111             : 
    1112             :     // In contig mode, if only one band is requested, check if we have
    1113             :     // enough cache to cache all bands.
    1114         247 :     if (!sContext.bSkipBlockCache && nBands != 1 &&
    1115         151 :         m_nPlanarConfig == PLANARCONFIG_CONTIG && nBandCount == 1)
    1116             :     {
    1117          76 :         const GIntBig nRequiredMem = static_cast<GIntBig>(nBands) * nXBlocks *
    1118          76 :                                      nYBlocks * m_nBlockXSize * m_nBlockYSize *
    1119          76 :                                      GDALGetDataTypeSizeBytes(sContext.eDT);
    1120          76 :         if (nRequiredMem > GDALGetCacheMax64())
    1121             :         {
    1122           0 :             if (!m_bHasWarnedDisableAggressiveBandCaching)
    1123             :             {
    1124           0 :                 CPLDebug("GTiff",
    1125             :                          "Disable aggressive band caching. "
    1126             :                          "Cache not big enough. "
    1127             :                          "At least " CPL_FRMT_GIB " bytes necessary",
    1128             :                          nRequiredMem);
    1129           0 :                 m_bHasWarnedDisableAggressiveBandCaching = true;
    1130             :             }
    1131             :         }
    1132             :         else
    1133             :         {
    1134          76 :             sContext.bCacheAllBands = true;
    1135          76 :             if ((nBands == 3 || nBands == 4) &&
    1136          66 :                 (sContext.eDT == GDT_Byte || sContext.eDT == GDT_Int16 ||
    1137           6 :                  sContext.eDT == GDT_UInt16))
    1138             :             {
    1139          66 :                 sContext.bUseDeinterleaveOptimBlockCache = true;
    1140             :             }
    1141             :         }
    1142             :     }
    1143             : 
    1144         247 :     if (eAccess == GA_Update)
    1145             :     {
    1146         234 :         std::vector<int> anBandsToCheck;
    1147         234 :         if (m_nPlanarConfig == PLANARCONFIG_CONTIG && nBands > 1)
    1148             :         {
    1149         740 :             for (int i = 0; i < nBands; ++i)
    1150             :             {
    1151         564 :                 anBandsToCheck.push_back(i);
    1152         176 :             }
    1153             :         }
    1154             :         else
    1155             :         {
    1156         170 :             for (int i = 0; i < nBandCount; ++i)
    1157             :             {
    1158         112 :                 anBandsToCheck.push_back(panBandMap[i] - 1);
    1159             :             }
    1160             :         }
    1161         234 :         if (!anBandsToCheck.empty())
    1162             :         {
    1163             :             // If at least one block in the region of intersest is dirty,
    1164             :             // fallback to normal reading code path to be able to retrieve
    1165             :             // content partly from the block cache.
    1166             :             // An alternative that was implemented in GDAL 3.6 to 3.8.0 was
    1167             :             // to flush dirty blocks, but this could cause many write&read&write
    1168             :             // cycles in some gdalwarp scenarios.
    1169             :             // Cf https://github.com/OSGeo/gdal/issues/8729
    1170         234 :             bool bUseBaseImplementation = false;
    1171        1225 :             for (int y = 0; y < nYBlocks; ++y)
    1172             :             {
    1173        3521 :                 for (int x = 0; x < nXBlocks; ++x)
    1174             :                 {
    1175        8912 :                     for (const int iBand : anBandsToCheck)
    1176             :                     {
    1177        6400 :                         if (m_nLoadedBlock >= 0 && m_bLoadedBlockDirty &&
    1178           0 :                             cpl::down_cast<GTiffRasterBand *>(papoBands[iBand])
    1179           0 :                                     ->ComputeBlockId(nBlockXStart + x,
    1180             :                                                      nBlockYStart + y) ==
    1181           0 :                                 m_nLoadedBlock)
    1182             :                         {
    1183           0 :                             bUseBaseImplementation = true;
    1184          18 :                             goto after_loop;
    1185             :                         }
    1186       12800 :                         auto poBlock = papoBands[iBand]->TryGetLockedBlockRef(
    1187        6400 :                             nBlockXStart + x, nBlockYStart + y);
    1188        6400 :                         if (poBlock)
    1189             :                         {
    1190        3868 :                             if (poBlock->GetDirty())
    1191             :                             {
    1192          18 :                                 poBlock->DropLock();
    1193          18 :                                 bUseBaseImplementation = true;
    1194          18 :                                 goto after_loop;
    1195             :                             }
    1196        3850 :                             poBlock->DropLock();
    1197             :                         }
    1198             :                     }
    1199             :                 }
    1200             :             }
    1201         216 :         after_loop:
    1202         234 :             if (bUseBaseImplementation)
    1203             :             {
    1204          18 :                 ++m_nDisableMultiThreadedRead;
    1205             :                 GDALRasterIOExtraArg sExtraArg;
    1206          18 :                 INIT_RASTERIO_EXTRA_ARG(sExtraArg);
    1207          18 :                 const CPLErr eErr = GDALDataset::IRasterIO(
    1208             :                     GF_Read, nXOff, nYOff, nXSize, nYSize, pData, nXSize,
    1209             :                     nYSize, eBufType, nBandCount, const_cast<int *>(panBandMap),
    1210             :                     nPixelSpace, nLineSpace, nBandSpace, &sExtraArg);
    1211          18 :                 --m_nDisableMultiThreadedRead;
    1212          18 :                 return eErr;
    1213             :             }
    1214             :         }
    1215             : 
    1216             :         // Make sure that all blocks that we are going to read and that are
    1217             :         // being written by a worker thread are completed.
    1218             :         // cppcheck-suppress constVariableReference
    1219         216 :         auto &oQueue =
    1220         216 :             m_poBaseDS ? m_poBaseDS->m_asQueueJobIdx : m_asQueueJobIdx;
    1221         216 :         if (!oQueue.empty())
    1222             :         {
    1223          85 :             for (int y = 0; y < nYBlocks; ++y)
    1224             :             {
    1225         192 :                 for (int x = 0; x < nXBlocks; ++x)
    1226             :                 {
    1227         296 :                     for (int i = 0; i < nStrilePerBlock; ++i)
    1228             :                     {
    1229         176 :                         int nBlockId =
    1230         176 :                             nBlockXStart + x +
    1231         176 :                             (nBlockYStart + y) * sContext.nBlocksPerRow;
    1232         176 :                         if (m_nPlanarConfig == PLANARCONFIG_SEPARATE)
    1233          84 :                             nBlockId += (panBandMap[i] - 1) * m_nBlocksPerBand;
    1234             : 
    1235         176 :                         WaitCompletionForBlock(nBlockId);
    1236             :                     }
    1237             :                 }
    1238             :             }
    1239             :         }
    1240             : 
    1241             :         // Flush to file, and then to disk if using pread() interface
    1242         216 :         VSI_TIFFFlushBufferedWrite(TIFFClientdata(m_hTIFF));
    1243         216 :         if (sContext.bHasPRead)
    1244         216 :             sContext.poHandle->Flush();
    1245             :     }
    1246             : 
    1247         229 :     if (GTIFFSupportsPredictor(m_nCompression))
    1248             :     {
    1249         148 :         TIFFGetField(m_hTIFF, TIFFTAG_PREDICTOR, &sContext.nPredictor);
    1250             :     }
    1251          81 :     else if (m_nCompression == COMPRESSION_JPEG)
    1252             :     {
    1253           2 :         TIFFGetField(m_hTIFF, TIFFTAG_JPEGTABLES, &sContext.nJPEGTableSize,
    1254             :                      &sContext.pJPEGTable);
    1255           2 :         if (m_nPhotometric == PHOTOMETRIC_YCBCR)
    1256             :         {
    1257           1 :             TIFFGetFieldDefaulted(m_hTIFF, TIFFTAG_YCBCRSUBSAMPLING,
    1258             :                                   &sContext.nYCrbCrSubSampling0,
    1259             :                                   &sContext.nYCrbCrSubSampling1);
    1260             :         }
    1261             :     }
    1262         229 :     if (m_nPlanarConfig == PLANARCONFIG_CONTIG)
    1263             :     {
    1264         182 :         TIFFGetField(m_hTIFF, TIFFTAG_EXTRASAMPLES, &sContext.nExtraSampleCount,
    1265             :                      &sContext.pExtraSamples);
    1266             :     }
    1267             : 
    1268             :     // Create one job per tile/strip
    1269         229 :     vsi_l_offset nFileSize = 0;
    1270         458 :     std::vector<GTiffDecompressJob> asJobs(nBlocks);
    1271         458 :     std::vector<vsi_l_offset> anOffsets(nBlocks);
    1272         458 :     std::vector<size_t> anSizes(nBlocks);
    1273         229 :     int iJob = 0;
    1274         229 :     int nAdviseReadRanges = 0;
    1275             :     const size_t nAdviseReadTotalBytesLimit =
    1276         229 :         sContext.poHandle->GetAdviseReadTotalBytesLimit();
    1277         229 :     size_t nAdviseReadAccBytes = 0;
    1278        8674 :     for (int y = 0; y < nYBlocks; ++y)
    1279             :     {
    1280       18441 :         for (int x = 0; x < nXBlocks; ++x)
    1281             :         {
    1282       21057 :             for (int i = 0; i < nStrilePerBlock; ++i)
    1283             :             {
    1284       11064 :                 asJobs[iJob].psContext = &sContext;
    1285       11064 :                 asJobs[iJob].iSrcBandIdxSeparate =
    1286       11064 :                     m_nPlanarConfig == PLANARCONFIG_CONTIG ? -1
    1287        2200 :                                                            : panBandMap[i] - 1;
    1288       11064 :                 asJobs[iJob].iDstBandIdxSeparate =
    1289       11064 :                     m_nPlanarConfig == PLANARCONFIG_CONTIG ? -1 : i;
    1290       11064 :                 asJobs[iJob].nXBlock = nBlockXStart + x;
    1291       11064 :                 asJobs[iJob].nYBlock = nBlockYStart + y;
    1292             : 
    1293       11064 :                 int nBlockId = asJobs[iJob].nXBlock +
    1294       11064 :                                asJobs[iJob].nYBlock * sContext.nBlocksPerRow;
    1295       11064 :                 if (m_nPlanarConfig == PLANARCONFIG_SEPARATE)
    1296        2200 :                     nBlockId +=
    1297        2200 :                         asJobs[iJob].iSrcBandIdxSeparate * m_nBlocksPerBand;
    1298             : 
    1299       11064 :                 bool bErrorInIsBlockAvailable = false;
    1300       11064 :                 if (!sContext.bHasPRead)
    1301             :                 {
    1302             :                     // Taking the mutex here is only needed when bHasPRead ==
    1303             :                     // false since we could have concurrent uses of the handle,
    1304             :                     // when when reading the TIFF TileOffsets / TileByteCounts
    1305             :                     // array
    1306             :                     std::lock_guard<std::recursive_mutex> oLock(
    1307           0 :                         sContext.oMutex);
    1308             : 
    1309           0 :                     CPL_IGNORE_RET_VAL(IsBlockAvailable(
    1310           0 :                         nBlockId, &asJobs[iJob].nOffset, &asJobs[iJob].nSize,
    1311             :                         &bErrorInIsBlockAvailable));
    1312             :                 }
    1313             :                 else
    1314             :                 {
    1315       11064 :                     CPL_IGNORE_RET_VAL(IsBlockAvailable(
    1316       11064 :                         nBlockId, &asJobs[iJob].nOffset, &asJobs[iJob].nSize,
    1317             :                         &bErrorInIsBlockAvailable));
    1318             :                 }
    1319       11064 :                 if (bErrorInIsBlockAvailable)
    1320             :                 {
    1321           2 :                     ReportError(CE_Failure, CPLE_AppDefined,
    1322             :                                 "Error while getting location of block %d",
    1323             :                                 nBlockId);
    1324             :                     std::lock_guard<std::recursive_mutex> oLock(
    1325           2 :                         sContext.oMutex);
    1326           2 :                     sContext.bSuccess = false;
    1327           2 :                     return CE_Failure;
    1328             :                 }
    1329             : 
    1330             :                 // Sanity check on block size
    1331       11062 :                 if (asJobs[iJob].nSize > 100U * 1024 * 1024)
    1332             :                 {
    1333           0 :                     if (nFileSize == 0)
    1334             :                     {
    1335             :                         std::lock_guard<std::recursive_mutex> oLock(
    1336           0 :                             sContext.oMutex);
    1337           0 :                         sContext.poHandle->Seek(0, SEEK_END);
    1338           0 :                         nFileSize = sContext.poHandle->Tell();
    1339             :                     }
    1340           0 :                     if (asJobs[iJob].nSize > nFileSize)
    1341             :                     {
    1342           0 :                         CPLError(CE_Failure, CPLE_AppDefined,
    1343             :                                  "Cannot read " CPL_FRMT_GUIB
    1344             :                                  " bytes at offset " CPL_FRMT_GUIB,
    1345           0 :                                  static_cast<GUIntBig>(asJobs[iJob].nSize),
    1346           0 :                                  static_cast<GUIntBig>(asJobs[iJob].nOffset));
    1347             : 
    1348             :                         std::lock_guard<std::recursive_mutex> oLock(
    1349           0 :                             sContext.oMutex);
    1350           0 :                         sContext.bSuccess = false;
    1351           0 :                         return CE_Failure;
    1352             :                     }
    1353             :                 }
    1354             : 
    1355             :                 // Only request in AdviseRead() ranges for blocks we don't
    1356             :                 // have in cache.
    1357       11062 :                 bool bAddToAdviseRead = true;
    1358       11062 :                 if (m_nPlanarConfig == PLANARCONFIG_SEPARATE)
    1359             :                 {
    1360             :                     auto poBlock =
    1361        2200 :                         GetRasterBand(panBandMap[i])
    1362        2200 :                             ->TryGetLockedBlockRef(asJobs[iJob].nXBlock,
    1363        2200 :                                                    asJobs[iJob].nYBlock);
    1364        2200 :                     if (poBlock)
    1365             :                     {
    1366         968 :                         poBlock->DropLock();
    1367         968 :                         bAddToAdviseRead = false;
    1368             :                     }
    1369             :                 }
    1370             :                 else
    1371             :                 {
    1372        8862 :                     bool bAllCached = true;
    1373       10572 :                     for (int iBand = 0; iBand < nBandCount; ++iBand)
    1374             :                     {
    1375             :                         auto poBlock =
    1376        9642 :                             GetRasterBand(panBandMap[iBand])
    1377        9642 :                                 ->TryGetLockedBlockRef(asJobs[iJob].nXBlock,
    1378        9642 :                                                        asJobs[iJob].nYBlock);
    1379        9642 :                         if (poBlock)
    1380             :                         {
    1381        1710 :                             poBlock->DropLock();
    1382             :                         }
    1383             :                         else
    1384             :                         {
    1385        7932 :                             bAllCached = false;
    1386        7932 :                             break;
    1387             :                         }
    1388             :                     }
    1389        8862 :                     if (bAllCached)
    1390         930 :                         bAddToAdviseRead = false;
    1391             :                 }
    1392             : 
    1393       11062 :                 if (bAddToAdviseRead)
    1394             :                 {
    1395        9164 :                     anOffsets[nAdviseReadRanges] = asJobs[iJob].nOffset;
    1396       18328 :                     anSizes[nAdviseReadRanges] =
    1397        9164 :                         static_cast<size_t>(std::min<vsi_l_offset>(
    1398       27492 :                             std::numeric_limits<size_t>::max(),
    1399        9164 :                             asJobs[iJob].nSize));
    1400             : 
    1401             :                     // If the total number of bytes we must read excess the
    1402             :                     // capacity of AdviseRead(), then split the RasterIO()
    1403             :                     // request in 2 halves.
    1404       16632 :                     if (nAdviseReadTotalBytesLimit > 0 &&
    1405        7468 :                         anSizes[nAdviseReadRanges] <
    1406        7468 :                             nAdviseReadTotalBytesLimit &&
    1407        7468 :                         anSizes[nAdviseReadRanges] >
    1408       16632 :                             nAdviseReadTotalBytesLimit - nAdviseReadAccBytes &&
    1409             :                         nYBlocks >= 2)
    1410             :                     {
    1411           1 :                         const int nYOff2 =
    1412           1 :                             (nBlockYStart + nYBlocks / 2) * m_nBlockYSize;
    1413           1 :                         CPLDebugOnly("GTiff",
    1414             :                                      "Splitting request (%d,%d,%dx%d) into "
    1415             :                                      "(%d,%d,%dx%d) and (%d,%d,%dx%d)",
    1416             :                                      nXOff, nYOff, nXSize, nYSize, nXOff, nYOff,
    1417             :                                      nXSize, nYOff2 - nYOff, nXOff, nYOff2,
    1418             :                                      nXSize, nYOff + nYSize - nYOff2);
    1419             : 
    1420           1 :                         asJobs.clear();
    1421           1 :                         anOffsets.clear();
    1422           1 :                         anSizes.clear();
    1423           1 :                         poQueue.reset();
    1424             : 
    1425           1 :                         CPLErr eErr = MultiThreadedRead(
    1426             :                             nXOff, nYOff, nXSize, nYOff2 - nYOff, pData,
    1427             :                             eBufType, nBandCount, panBandMap, nPixelSpace,
    1428             :                             nLineSpace, nBandSpace);
    1429           1 :                         if (eErr == CE_None)
    1430             :                         {
    1431           1 :                             eErr = MultiThreadedRead(
    1432           1 :                                 nXOff, nYOff2, nXSize, nYOff + nYSize - nYOff2,
    1433             :                                 static_cast<GByte *>(pData) +
    1434           1 :                                     (nYOff2 - nYOff) * nLineSpace,
    1435             :                                 eBufType, nBandCount, panBandMap, nPixelSpace,
    1436             :                                 nLineSpace, nBandSpace);
    1437             :                         }
    1438           1 :                         return eErr;
    1439             :                     }
    1440        9163 :                     nAdviseReadAccBytes += anSizes[nAdviseReadRanges];
    1441             : 
    1442        9163 :                     ++nAdviseReadRanges;
    1443             :                 }
    1444             : 
    1445       11061 :                 ++iJob;
    1446             :             }
    1447             :         }
    1448             :     }
    1449             : 
    1450         226 :     if (sContext.bSuccess)
    1451             :     {
    1452             :         // Potentially start asynchronous fetching of ranges depending on file
    1453             :         // implementation
    1454         226 :         if (nAdviseReadRanges > 0)
    1455             :         {
    1456          99 :             sContext.poHandle->AdviseRead(nAdviseReadRanges, anOffsets.data(),
    1457          99 :                                           anSizes.data());
    1458             :         }
    1459             : 
    1460             :         // We need to do that as threads will access the block cache
    1461         226 :         TemporarilyDropReadWriteLock();
    1462             : 
    1463        4028 :         for (auto &sJob : asJobs)
    1464             :         {
    1465        3802 :             poQueue->SubmitJob(ThreadDecompressionFunc, &sJob);
    1466             :         }
    1467             : 
    1468             :         // Wait for all jobs to have been completed
    1469         226 :         poQueue->WaitCompletion();
    1470             : 
    1471             :         // Undo effect of above TemporarilyDropReadWriteLock()
    1472         226 :         ReacquireReadWriteLock();
    1473             : 
    1474         226 :         sContext.oErrorAccumulator.ReplayErrors();
    1475             :     }
    1476             : 
    1477         226 :     return sContext.bSuccess ? CE_None : CE_Failure;
    1478             : }
    1479             : 
    1480             : /************************************************************************/
    1481             : /*                        FetchBufferVirtualMemIO                       */
    1482             : /************************************************************************/
    1483             : 
    1484             : class FetchBufferVirtualMemIO final
    1485             : {
    1486             :     const GByte *pabySrcData;
    1487             :     size_t nMappingSize;
    1488             :     GByte *pTempBuffer;
    1489             : 
    1490             :   public:
    1491         971 :     FetchBufferVirtualMemIO(const GByte *pabySrcDataIn, size_t nMappingSizeIn,
    1492             :                             GByte *pTempBufferIn)
    1493         971 :         : pabySrcData(pabySrcDataIn), nMappingSize(nMappingSizeIn),
    1494         971 :           pTempBuffer(pTempBufferIn)
    1495             :     {
    1496         971 :     }
    1497             : 
    1498      897395 :     const GByte *FetchBytes(vsi_l_offset nOffset, int nPixels, int nDTSize,
    1499             :                             bool bIsByteSwapped, bool bIsComplex, int nBlockId)
    1500             :     {
    1501      897395 :         if (nOffset + static_cast<size_t>(nPixels) * nDTSize > nMappingSize)
    1502             :         {
    1503          24 :             CPLError(CE_Failure, CPLE_FileIO, "Missing data for block %d",
    1504             :                      nBlockId);
    1505          24 :             return nullptr;
    1506             :         }
    1507      897371 :         if (!bIsByteSwapped)
    1508      572847 :             return pabySrcData + nOffset;
    1509      324524 :         memcpy(pTempBuffer, pabySrcData + nOffset,
    1510      324524 :                static_cast<size_t>(nPixels) * nDTSize);
    1511      324524 :         if (bIsComplex)
    1512      159940 :             GDALSwapWords(pTempBuffer, nDTSize / 2, 2 * nPixels, nDTSize / 2);
    1513             :         else
    1514      164584 :             GDALSwapWords(pTempBuffer, nDTSize, nPixels, nDTSize);
    1515      324524 :         return pTempBuffer;
    1516             :     }
    1517             : 
    1518      115046 :     bool FetchBytes(GByte *pabyDstBuffer, vsi_l_offset nOffset, int nPixels,
    1519             :                     int nDTSize, bool bIsByteSwapped, bool bIsComplex,
    1520             :                     int nBlockId)
    1521             :     {
    1522      115046 :         if (nOffset + static_cast<size_t>(nPixels) * nDTSize > nMappingSize)
    1523             :         {
    1524          11 :             CPLError(CE_Failure, CPLE_FileIO, "Missing data for block %d",
    1525             :                      nBlockId);
    1526          11 :             return false;
    1527             :         }
    1528      115035 :         memcpy(pabyDstBuffer, pabySrcData + nOffset,
    1529      115035 :                static_cast<size_t>(nPixels) * nDTSize);
    1530      115035 :         if (bIsByteSwapped)
    1531             :         {
    1532       48082 :             if (bIsComplex)
    1533       26390 :                 GDALSwapWords(pabyDstBuffer, nDTSize / 2, 2 * nPixels,
    1534             :                               nDTSize / 2);
    1535             :             else
    1536       21692 :                 GDALSwapWords(pabyDstBuffer, nDTSize, nPixels, nDTSize);
    1537             :         }
    1538      115035 :         return true;
    1539             :     }
    1540             : 
    1541             :     // cppcheck-suppress unusedStructMember
    1542             :     static const bool bMinimizeIO = false;
    1543             : };
    1544             : 
    1545             : /************************************************************************/
    1546             : /*                         VirtualMemIO()                               */
    1547             : /************************************************************************/
    1548             : 
    1549        1101 : int GTiffDataset::VirtualMemIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
    1550             :                                int nXSize, int nYSize, void *pData,
    1551             :                                int nBufXSize, int nBufYSize,
    1552             :                                GDALDataType eBufType, int nBandCount,
    1553             :                                const int *panBandMap, GSpacing nPixelSpace,
    1554             :                                GSpacing nLineSpace, GSpacing nBandSpace,
    1555             :                                GDALRasterIOExtraArg *psExtraArg)
    1556             : {
    1557        1101 :     if (eAccess == GA_Update || eRWFlag == GF_Write || m_bStreamingIn)
    1558           0 :         return -1;
    1559             : 
    1560             :     // Only know how to deal with nearest neighbour in this optimized routine.
    1561        1101 :     if ((nXSize != nBufXSize || nYSize != nBufYSize) && psExtraArg != nullptr &&
    1562         417 :         psExtraArg->eResampleAlg != GRIORA_NearestNeighbour)
    1563             :     {
    1564         130 :         return -1;
    1565             :     }
    1566             : 
    1567         971 :     const GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType();
    1568         971 :     const int nDTSizeBits = GDALGetDataTypeSizeBits(eDataType);
    1569         971 :     if (!(m_nCompression == COMPRESSION_NONE &&
    1570         971 :           (m_nPhotometric == PHOTOMETRIC_MINISBLACK ||
    1571         392 :            m_nPhotometric == PHOTOMETRIC_RGB ||
    1572           0 :            m_nPhotometric == PHOTOMETRIC_PALETTE) &&
    1573         971 :           m_nBitsPerSample == nDTSizeBits))
    1574             :     {
    1575           0 :         m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
    1576           0 :         return -1;
    1577             :     }
    1578             : 
    1579         971 :     size_t nMappingSize = 0;
    1580         971 :     GByte *pabySrcData = nullptr;
    1581         971 :     if (STARTS_WITH(m_osFilename.c_str(), "/vsimem/"))
    1582             :     {
    1583         708 :         vsi_l_offset nDataLength = 0;
    1584             :         pabySrcData =
    1585         708 :             VSIGetMemFileBuffer(m_osFilename.c_str(), &nDataLength, FALSE);
    1586         708 :         nMappingSize = static_cast<size_t>(nDataLength);
    1587         708 :         if (pabySrcData == nullptr)
    1588           0 :             return -1;
    1589             :     }
    1590         263 :     else if (m_psVirtualMemIOMapping == nullptr)
    1591             :     {
    1592          11 :         VSILFILE *fp = VSI_TIFFGetVSILFile(TIFFClientdata(m_hTIFF));
    1593          22 :         if (!CPLIsVirtualMemFileMapAvailable() ||
    1594          11 :             VSIFGetNativeFileDescriptorL(fp) == nullptr)
    1595             :         {
    1596           0 :             m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
    1597           0 :             return -1;
    1598             :         }
    1599          11 :         if (VSIFSeekL(fp, 0, SEEK_END) != 0)
    1600             :         {
    1601           0 :             m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
    1602           0 :             return -1;
    1603             :         }
    1604          11 :         const vsi_l_offset nLength = VSIFTellL(fp);
    1605             :         if (static_cast<size_t>(nLength) != nLength)
    1606             :         {
    1607             :             m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
    1608             :             return -1;
    1609             :         }
    1610          11 :         if (m_eVirtualMemIOUsage == VirtualMemIOEnum::IF_ENOUGH_RAM)
    1611             :         {
    1612           0 :             GIntBig nRAM = CPLGetUsablePhysicalRAM();
    1613           0 :             if (static_cast<GIntBig>(nLength) > nRAM)
    1614             :             {
    1615           0 :                 CPLDebug("GTiff",
    1616             :                          "Not enough RAM to map whole file into memory.");
    1617           0 :                 m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
    1618           0 :                 return -1;
    1619             :             }
    1620             :         }
    1621          11 :         m_psVirtualMemIOMapping = CPLVirtualMemFileMapNew(
    1622             :             fp, 0, nLength, VIRTUALMEM_READONLY, nullptr, nullptr);
    1623          11 :         if (m_psVirtualMemIOMapping == nullptr)
    1624             :         {
    1625           0 :             m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
    1626           0 :             return -1;
    1627             :         }
    1628          11 :         m_eVirtualMemIOUsage = VirtualMemIOEnum::YES;
    1629             :     }
    1630             : 
    1631         971 :     if (m_psVirtualMemIOMapping)
    1632             :     {
    1633             : #ifdef DEBUG
    1634         263 :         CPLDebug("GTiff", "Using VirtualMemIO");
    1635             : #endif
    1636         263 :         nMappingSize = CPLVirtualMemGetSize(m_psVirtualMemIOMapping);
    1637             :         pabySrcData =
    1638         263 :             static_cast<GByte *>(CPLVirtualMemGetAddr(m_psVirtualMemIOMapping));
    1639             :     }
    1640             : 
    1641         971 :     if (TIFFIsByteSwapped(m_hTIFF) && m_pTempBufferForCommonDirectIO == nullptr)
    1642             :     {
    1643          12 :         const int nDTSize = nDTSizeBits / 8;
    1644          12 :         size_t nTempBufferForCommonDirectIOSize = static_cast<size_t>(
    1645          24 :             m_nBlockXSize * nDTSize *
    1646          12 :             (m_nPlanarConfig == PLANARCONFIG_CONTIG ? nBands : 1));
    1647          12 :         if (TIFFIsTiled(m_hTIFF))
    1648           6 :             nTempBufferForCommonDirectIOSize *= m_nBlockYSize;
    1649             : 
    1650          12 :         m_pTempBufferForCommonDirectIO = static_cast<GByte *>(
    1651          12 :             VSI_MALLOC_VERBOSE(nTempBufferForCommonDirectIOSize));
    1652          12 :         if (m_pTempBufferForCommonDirectIO == nullptr)
    1653           0 :             return CE_Failure;
    1654             :     }
    1655             :     FetchBufferVirtualMemIO oFetcher(pabySrcData, nMappingSize,
    1656         971 :                                      m_pTempBufferForCommonDirectIO);
    1657             : 
    1658         971 :     return CommonDirectIO(oFetcher, nXOff, nYOff, nXSize, nYSize, pData,
    1659             :                           nBufXSize, nBufYSize, eBufType, nBandCount,
    1660         971 :                           panBandMap, nPixelSpace, nLineSpace, nBandSpace);
    1661             : }
    1662             : 
    1663             : /************************************************************************/
    1664             : /*                   CopyContigByteMultiBand()                          */
    1665             : /************************************************************************/
    1666             : 
    1667        2754 : static inline void CopyContigByteMultiBand(const GByte *CPL_RESTRICT pabySrc,
    1668             :                                            int nSrcStride,
    1669             :                                            GByte *CPL_RESTRICT pabyDest,
    1670             :                                            int nDestStride, int nIters,
    1671             :                                            int nBandCount)
    1672             : {
    1673        2754 :     if (nBandCount == 3)
    1674             :     {
    1675        1620 :         if (nSrcStride == 3 && nDestStride == 4)
    1676             :         {
    1677        2106 :             while (nIters >= 8)
    1678             :             {
    1679        1620 :                 pabyDest[4 * 0 + 0] = pabySrc[3 * 0 + 0];
    1680        1620 :                 pabyDest[4 * 0 + 1] = pabySrc[3 * 0 + 1];
    1681        1620 :                 pabyDest[4 * 0 + 2] = pabySrc[3 * 0 + 2];
    1682        1620 :                 pabyDest[4 * 1 + 0] = pabySrc[3 * 1 + 0];
    1683        1620 :                 pabyDest[4 * 1 + 1] = pabySrc[3 * 1 + 1];
    1684        1620 :                 pabyDest[4 * 1 + 2] = pabySrc[3 * 1 + 2];
    1685        1620 :                 pabyDest[4 * 2 + 0] = pabySrc[3 * 2 + 0];
    1686        1620 :                 pabyDest[4 * 2 + 1] = pabySrc[3 * 2 + 1];
    1687        1620 :                 pabyDest[4 * 2 + 2] = pabySrc[3 * 2 + 2];
    1688        1620 :                 pabyDest[4 * 3 + 0] = pabySrc[3 * 3 + 0];
    1689        1620 :                 pabyDest[4 * 3 + 1] = pabySrc[3 * 3 + 1];
    1690        1620 :                 pabyDest[4 * 3 + 2] = pabySrc[3 * 3 + 2];
    1691        1620 :                 pabyDest[4 * 4 + 0] = pabySrc[3 * 4 + 0];
    1692        1620 :                 pabyDest[4 * 4 + 1] = pabySrc[3 * 4 + 1];
    1693        1620 :                 pabyDest[4 * 4 + 2] = pabySrc[3 * 4 + 2];
    1694        1620 :                 pabyDest[4 * 5 + 0] = pabySrc[3 * 5 + 0];
    1695        1620 :                 pabyDest[4 * 5 + 1] = pabySrc[3 * 5 + 1];
    1696        1620 :                 pabyDest[4 * 5 + 2] = pabySrc[3 * 5 + 2];
    1697        1620 :                 pabyDest[4 * 6 + 0] = pabySrc[3 * 6 + 0];
    1698        1620 :                 pabyDest[4 * 6 + 1] = pabySrc[3 * 6 + 1];
    1699        1620 :                 pabyDest[4 * 6 + 2] = pabySrc[3 * 6 + 2];
    1700        1620 :                 pabyDest[4 * 7 + 0] = pabySrc[3 * 7 + 0];
    1701        1620 :                 pabyDest[4 * 7 + 1] = pabySrc[3 * 7 + 1];
    1702        1620 :                 pabyDest[4 * 7 + 2] = pabySrc[3 * 7 + 2];
    1703        1620 :                 pabySrc += 3 * 8;
    1704        1620 :                 pabyDest += 4 * 8;
    1705        1620 :                 nIters -= 8;
    1706             :             }
    1707         648 :             while (nIters-- > 0)
    1708             :             {
    1709         162 :                 pabyDest[0] = pabySrc[0];
    1710         162 :                 pabyDest[1] = pabySrc[1];
    1711         162 :                 pabyDest[2] = pabySrc[2];
    1712         162 :                 pabySrc += 3;
    1713         162 :                 pabyDest += 4;
    1714             :             }
    1715             :         }
    1716             :         else
    1717             :         {
    1718       53622 :             while (nIters-- > 0)
    1719             :             {
    1720       52488 :                 pabyDest[0] = pabySrc[0];
    1721       52488 :                 pabyDest[1] = pabySrc[1];
    1722       52488 :                 pabyDest[2] = pabySrc[2];
    1723       52488 :                 pabySrc += nSrcStride;
    1724       52488 :                 pabyDest += nDestStride;
    1725             :             }
    1726             :         }
    1727             :     }
    1728             :     else
    1729             :     {
    1730       53622 :         while (nIters-- > 0)
    1731             :         {
    1732      236196 :             for (int iBand = 0; iBand < nBandCount; ++iBand)
    1733      183708 :                 pabyDest[iBand] = pabySrc[iBand];
    1734       52488 :             pabySrc += nSrcStride;
    1735       52488 :             pabyDest += nDestStride;
    1736             :         }
    1737             :     }
    1738        2754 : }
    1739             : 
    1740             : /************************************************************************/
    1741             : /*                         CommonDirectIO()                             */
    1742             : /************************************************************************/
    1743             : 
    1744             : // #define DEBUG_REACHED_VIRTUAL_MEM_IO
    1745             : #ifdef DEBUG_REACHED_VIRTUAL_MEM_IO
    1746             : static int anReachedVirtualMemIO[52] = {0};
    1747             : #define REACHED(x) anReachedVirtualMemIO[x] = 1
    1748             : #else
    1749             : #define REACHED(x)
    1750             : #endif
    1751             : 
    1752             : template <class FetchBuffer>
    1753        1742 : CPLErr GTiffDataset::CommonDirectIO(FetchBuffer &oFetcher, int nXOff, int nYOff,
    1754             :                                     int nXSize, int nYSize, void *pData,
    1755             :                                     int nBufXSize, int nBufYSize,
    1756             :                                     GDALDataType eBufType, int nBandCount,
    1757             :                                     const int *panBandMap, GSpacing nPixelSpace,
    1758             :                                     GSpacing nLineSpace, GSpacing nBandSpace)
    1759             : {
    1760             :     const auto poFirstBand =
    1761        1742 :         cpl::down_cast<GTiffRasterBand *>(GetRasterBand(1));
    1762        1742 :     const GDALDataType eDataType = poFirstBand->GetRasterDataType();
    1763        1742 :     const int nDTSize = GDALGetDataTypeSizeBytes(eDataType);
    1764        1742 :     const bool bIsComplex = CPL_TO_BOOL(GDALDataTypeIsComplex(eDataType));
    1765        1742 :     const int nBufDTSize = GDALGetDataTypeSizeBytes(eBufType);
    1766             : 
    1767             :     // Get strip offsets.
    1768        1742 :     toff_t *panOffsets = nullptr;
    1769        1742 :     if (!TIFFGetField(m_hTIFF,
    1770        1742 :                       (TIFFIsTiled(m_hTIFF)) ? TIFFTAG_TILEOFFSETS
    1771             :                                              : TIFFTAG_STRIPOFFSETS,
    1772        3484 :                       &panOffsets) ||
    1773        1742 :         panOffsets == nullptr)
    1774             :     {
    1775           0 :         return CE_Failure;
    1776             :     }
    1777             : 
    1778         346 :     bool bUseContigImplementation = m_nPlanarConfig == PLANARCONFIG_CONTIG &&
    1779        2088 :                                     nBandCount > 1 && nBandSpace == nBufDTSize;
    1780        1742 :     if (bUseContigImplementation)
    1781             :     {
    1782         470 :         for (int iBand = 0; iBand < nBandCount; ++iBand)
    1783             :         {
    1784         370 :             const int nBand = panBandMap[iBand];
    1785         370 :             if (nBand != iBand + 1)
    1786             :             {
    1787           0 :                 bUseContigImplementation = false;
    1788           0 :                 break;
    1789             :             }
    1790             :         }
    1791             :     }
    1792             : 
    1793        1742 :     const int nBandsPerBlock =
    1794        1742 :         m_nPlanarConfig == PLANARCONFIG_SEPARATE ? 1 : nBands;
    1795        1742 :     const int nBandsPerBlockDTSize = nBandsPerBlock * nDTSize;
    1796        1742 :     const bool bNoTypeChange = (eDataType == eBufType);
    1797        1742 :     const bool bNoXResampling = (nXSize == nBufXSize);
    1798        1742 :     const bool bNoXResamplingNoTypeChange = (bNoTypeChange && bNoXResampling);
    1799        1742 :     const bool bByteOnly = (bNoTypeChange && nDTSize == 1);
    1800        1742 :     const bool bByteNoXResampling = (bByteOnly && bNoXResamplingNoTypeChange);
    1801        1742 :     const bool bIsByteSwapped = CPL_TO_BOOL(TIFFIsByteSwapped(m_hTIFF));
    1802        1742 :     const double dfSrcXInc = nXSize / static_cast<double>(nBufXSize);
    1803        1742 :     const double dfSrcYInc = nYSize / static_cast<double>(nBufYSize);
    1804             : 
    1805        1742 :     int bNoDataSetIn = FALSE;
    1806        1742 :     double dfNoData = poFirstBand->GetNoDataValue(&bNoDataSetIn);
    1807        1742 :     GByte abyNoData = 0;
    1808        1742 :     if (!bNoDataSetIn)
    1809        1742 :         dfNoData = 0;
    1810           0 :     else if (dfNoData >= 0 && dfNoData <= 255)
    1811           0 :         abyNoData = static_cast<GByte>(dfNoData + 0.5);
    1812             : 
    1813             :     // cppcheck-suppress knownConditionTrueFalse
    1814        1542 :     if (FetchBuffer::bMinimizeIO && TIFFIsTiled(m_hTIFF) && bNoXResampling &&
    1815        1542 :         (nYSize == nBufYSize) && m_nPlanarConfig == PLANARCONFIG_CONTIG &&
    1816             :         nBandCount > 1)
    1817             :     {
    1818          35 :         GByte *pabyData = static_cast<GByte *>(pData);
    1819         275 :         for (int y = 0; y < nBufYSize;)
    1820             :         {
    1821         242 :             const int nSrcLine = nYOff + y;
    1822         242 :             const int nBlockYOff = nSrcLine / m_nBlockYSize;
    1823         242 :             const int nYOffsetInBlock = nSrcLine % m_nBlockYSize;
    1824         242 :             const int nUsedBlockHeight =
    1825         242 :                 std::min(nBufYSize - y, m_nBlockYSize - nYOffsetInBlock);
    1826             : 
    1827         242 :             int nBlockXOff = nXOff / m_nBlockXSize;
    1828         242 :             int nXOffsetInBlock = nXOff % m_nBlockXSize;
    1829         242 :             int nBlockId = poFirstBand->ComputeBlockId(nBlockXOff, nBlockYOff);
    1830             : 
    1831         242 :             int x = 0;
    1832        1200 :             while (x < nBufXSize)
    1833             :             {
    1834         960 :                 const toff_t nCurOffset = panOffsets[nBlockId];
    1835         960 :                 const int nUsedBlockWidth =
    1836         960 :                     std::min(m_nBlockXSize - nXOffsetInBlock, nBufXSize - x);
    1837             : 
    1838         960 :                 if (nCurOffset == 0)
    1839             :                 {
    1840             :                     REACHED(30);
    1841        7287 :                     for (int k = 0; k < nUsedBlockHeight; ++k)
    1842             :                     {
    1843        6813 :                         GByte *pabyLocalData =
    1844        6813 :                             pabyData + (y + k) * nLineSpace + x * nPixelSpace;
    1845       33573 :                         for (int iBand = 0; iBand < nBandCount; ++iBand)
    1846             :                         {
    1847       26760 :                             GByte *pabyLocalDataBand =
    1848       26760 :                                 pabyLocalData + iBand * nBandSpace;
    1849             : 
    1850       26760 :                             GDALCopyWords(&dfNoData, GDT_Float64, 0,
    1851             :                                           pabyLocalDataBand, eBufType,
    1852             :                                           static_cast<int>(nPixelSpace),
    1853             :                                           nUsedBlockWidth);
    1854             :                         }
    1855             :                     }
    1856             :                 }
    1857             :                 else
    1858             :                 {
    1859         486 :                     const int nByteOffsetInBlock =
    1860         486 :                         nYOffsetInBlock * m_nBlockXSize * nBandsPerBlockDTSize;
    1861         972 :                     const GByte *pabyLocalSrcDataK0 = oFetcher.FetchBytes(
    1862         486 :                         nCurOffset + nByteOffsetInBlock,
    1863         486 :                         m_nBlockXSize * nUsedBlockHeight * nBandsPerBlock,
    1864             :                         nDTSize, bIsByteSwapped, bIsComplex, nBlockId);
    1865         486 :                     if (pabyLocalSrcDataK0 == nullptr)
    1866           2 :                         return CE_Failure;
    1867             : 
    1868        7468 :                     for (int k = 0; k < nUsedBlockHeight; ++k)
    1869             :                     {
    1870        6984 :                         GByte *pabyLocalData =
    1871        6984 :                             pabyData + (y + k) * nLineSpace + x * nPixelSpace;
    1872        6984 :                         const GByte *pabyLocalSrcData =
    1873             :                             pabyLocalSrcDataK0 +
    1874        6984 :                             (k * m_nBlockXSize + nXOffsetInBlock) *
    1875             :                                 nBandsPerBlockDTSize;
    1876             : 
    1877        6984 :                         if (bUseContigImplementation && nBands == nBandCount &&
    1878        3234 :                             nPixelSpace == nBandsPerBlockDTSize)
    1879             :                         {
    1880             :                             REACHED(31);
    1881        2262 :                             GDALCopyWords(pabyLocalSrcData, eDataType, nDTSize,
    1882             :                                           pabyLocalData, eBufType, nBufDTSize,
    1883        2262 :                                           nUsedBlockWidth * nBands);
    1884             :                         }
    1885             :                         else
    1886             :                         {
    1887             :                             REACHED(32);
    1888       22608 :                             for (int iBand = 0; iBand < nBandCount; ++iBand)
    1889             :                             {
    1890       17886 :                                 GByte *pabyLocalDataBand =
    1891       17886 :                                     pabyLocalData + iBand * nBandSpace;
    1892       17886 :                                 const GByte *pabyLocalSrcDataBand =
    1893             :                                     pabyLocalSrcData +
    1894       17886 :                                     (panBandMap[iBand] - 1) * nDTSize;
    1895             : 
    1896       17886 :                                 GDALCopyWords(pabyLocalSrcDataBand, eDataType,
    1897             :                                               nBandsPerBlockDTSize,
    1898             :                                               pabyLocalDataBand, eBufType,
    1899             :                                               static_cast<int>(nPixelSpace),
    1900             :                                               nUsedBlockWidth);
    1901             :                             }
    1902             :                         }
    1903             :                     }
    1904             :                 }
    1905             : 
    1906         958 :                 nXOffsetInBlock = 0;
    1907         958 :                 ++nBlockXOff;
    1908         958 :                 ++nBlockId;
    1909         958 :                 x += nUsedBlockWidth;
    1910             :             }
    1911             : 
    1912         240 :             y += nUsedBlockHeight;
    1913             :         }
    1914             :     }
    1915             :     // cppcheck-suppress knownConditionTrueFalse
    1916        1472 :     else if (FetchBuffer::bMinimizeIO && TIFFIsTiled(m_hTIFF) &&
    1917        1472 :              bNoXResampling && (nYSize == nBufYSize))
    1918             :     // && (m_nPlanarConfig == PLANARCONFIG_SEPARATE || nBandCount == 1) )
    1919             :     {
    1920         967 :         for (int iBand = 0; iBand < nBandCount; ++iBand)
    1921             :         {
    1922         488 :             GByte *pabyData = static_cast<GByte *>(pData) + iBand * nBandSpace;
    1923         488 :             const int nBand = panBandMap[iBand];
    1924             :             auto poCurBand =
    1925         488 :                 cpl::down_cast<GTiffRasterBand *>(GetRasterBand(nBand));
    1926        3783 :             for (int y = 0; y < nBufYSize;)
    1927             :             {
    1928        3304 :                 const int nSrcLine = nYOff + y;
    1929        3304 :                 const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    1930        3304 :                 const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    1931        3304 :                 const int nUsedBlockHeight =
    1932        3304 :                     std::min(nBufYSize - y, m_nBlockYSize - nYOffsetIm_nBlock);
    1933             : 
    1934        3304 :                 int nBlockXOff = nXOff / m_nBlockXSize;
    1935        3304 :                 int nXOffsetInBlock = nXOff % m_nBlockXSize;
    1936             :                 int nBlockId =
    1937        3304 :                     poCurBand->ComputeBlockId(nBlockXOff, m_nBlockYOff);
    1938             : 
    1939        3304 :                 int x = 0;
    1940       16000 :                 while (x < nBufXSize)
    1941             :                 {
    1942       12705 :                     const toff_t nCurOffset = panOffsets[nBlockId];
    1943       12705 :                     const int nUsedBlockWidth = std::min(
    1944       12705 :                         m_nBlockXSize - nXOffsetInBlock, nBufXSize - x);
    1945             : 
    1946       12705 :                     if (nCurOffset == 0)
    1947             :                     {
    1948             :                         REACHED(35);
    1949       42642 :                         for (int k = 0; k < nUsedBlockHeight; ++k)
    1950             :                         {
    1951       39858 :                             GByte *pabyLocalData = pabyData +
    1952       39858 :                                                    (y + k) * nLineSpace +
    1953       39858 :                                                    x * nPixelSpace;
    1954             : 
    1955       39858 :                             GDALCopyWords(&dfNoData, GDT_Float64, 0,
    1956             :                                           pabyLocalData, eBufType,
    1957             :                                           static_cast<int>(nPixelSpace),
    1958             :                                           nUsedBlockWidth);
    1959             :                         }
    1960             :                     }
    1961             :                     else
    1962             :                     {
    1963        9921 :                         const int nByteOffsetIm_nBlock = nYOffsetIm_nBlock *
    1964        9921 :                                                          m_nBlockXSize *
    1965             :                                                          nBandsPerBlockDTSize;
    1966       19842 :                         const GByte *pabyLocalSrcDataK0 = oFetcher.FetchBytes(
    1967        9921 :                             nCurOffset + nByteOffsetIm_nBlock,
    1968        9921 :                             m_nBlockXSize * nUsedBlockHeight * nBandsPerBlock,
    1969             :                             nDTSize, bIsByteSwapped, bIsComplex, nBlockId);
    1970        9921 :                         if (pabyLocalSrcDataK0 == nullptr)
    1971           9 :                             return CE_Failure;
    1972             : 
    1973        9912 :                         if (m_nPlanarConfig == PLANARCONFIG_CONTIG)
    1974             :                         {
    1975             :                             REACHED(36);
    1976         512 :                             pabyLocalSrcDataK0 += (nBand - 1) * nDTSize;
    1977             :                         }
    1978             :                         else
    1979             :                         {
    1980             :                             REACHED(37);
    1981             :                         }
    1982             : 
    1983      151464 :                         for (int k = 0; k < nUsedBlockHeight; ++k)
    1984             :                         {
    1985      141552 :                             GByte *pabyLocalData = pabyData +
    1986      141552 :                                                    (y + k) * nLineSpace +
    1987      141552 :                                                    x * nPixelSpace;
    1988      141552 :                             const GByte *pabyLocalSrcData =
    1989             :                                 pabyLocalSrcDataK0 +
    1990      141552 :                                 (k * m_nBlockXSize + nXOffsetInBlock) *
    1991             :                                     nBandsPerBlockDTSize;
    1992             : 
    1993      141552 :                             GDALCopyWords(
    1994             :                                 pabyLocalSrcData, eDataType,
    1995             :                                 nBandsPerBlockDTSize, pabyLocalData, eBufType,
    1996             :                                 static_cast<int>(nPixelSpace), nUsedBlockWidth);
    1997             :                         }
    1998             :                     }
    1999             : 
    2000       12696 :                     nXOffsetInBlock = 0;
    2001       12696 :                     ++nBlockXOff;
    2002       12696 :                     ++nBlockId;
    2003       12696 :                     x += nUsedBlockWidth;
    2004             :                 }
    2005             : 
    2006        3295 :                 y += nUsedBlockHeight;
    2007             :             }
    2008             :         }
    2009             :     }
    2010             :     // cppcheck-suppress knownConditionTrueFalse
    2011         248 :     else if (FetchBuffer::bMinimizeIO && TIFFIsTiled(m_hTIFF) &&
    2012         248 :              m_nPlanarConfig == PLANARCONFIG_CONTIG && nBandCount > 1)
    2013             :     {
    2014          20 :         GByte *pabyData = static_cast<GByte *>(pData);
    2015          20 :         int anSrcYOffset[256] = {0};
    2016         119 :         for (int y = 0; y < nBufYSize;)
    2017             :         {
    2018         100 :             const double dfYOffStart = nYOff + (y + 0.5) * dfSrcYInc;
    2019         100 :             const int nSrcLine = static_cast<int>(dfYOffStart);
    2020         100 :             const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    2021         100 :             const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    2022         100 :             const int nBaseByteOffsetIm_nBlock =
    2023         100 :                 nYOffsetIm_nBlock * m_nBlockXSize * nBandsPerBlockDTSize;
    2024         100 :             int ychunk = 1;
    2025         100 :             int nLastSrcLineK = nSrcLine;
    2026         100 :             anSrcYOffset[0] = 0;
    2027       12064 :             for (int k = 1; k < nBufYSize - y; ++k)
    2028             :             {
    2029       12044 :                 int nSrcLineK =
    2030       12044 :                     nYOff + static_cast<int>((y + k + 0.5) * dfSrcYInc);
    2031       12044 :                 const int nBlockYOffK = nSrcLineK / m_nBlockYSize;
    2032       12044 :                 if (k < 256)
    2033        7544 :                     anSrcYOffset[k] =
    2034        7544 :                         ((nSrcLineK % m_nBlockYSize) - nYOffsetIm_nBlock) *
    2035        7544 :                         m_nBlockXSize * nBandsPerBlockDTSize;
    2036       12044 :                 if (nBlockYOffK != m_nBlockYOff)
    2037             :                 {
    2038          80 :                     break;
    2039             :                 }
    2040       11964 :                 ++ychunk;
    2041       11964 :                 nLastSrcLineK = nSrcLineK;
    2042             :             }
    2043         100 :             const int nUsedBlockHeight = nLastSrcLineK - nSrcLine + 1;
    2044             :             // CPLAssert(nUsedBlockHeight <= m_nBlockYSize);
    2045             : 
    2046         100 :             double dfSrcX = nXOff + 0.5 * dfSrcXInc;
    2047         100 :             int nCurBlockXOff = 0;
    2048         100 :             int nNextBlockXOff = 0;
    2049         100 :             toff_t nCurOffset = 0;
    2050         100 :             const GByte *pabyLocalSrcDataStartLine = nullptr;
    2051       10843 :             for (int x = 0; x < nBufXSize; ++x, dfSrcX += dfSrcXInc)
    2052             :             {
    2053       10744 :                 const int nSrcPixel = static_cast<int>(dfSrcX);
    2054       10744 :                 if (nSrcPixel >= nNextBlockXOff)
    2055             :                 {
    2056         292 :                     const int nBlockXOff = nSrcPixel / m_nBlockXSize;
    2057         292 :                     nCurBlockXOff = nBlockXOff * m_nBlockXSize;
    2058         292 :                     nNextBlockXOff = nCurBlockXOff + m_nBlockXSize;
    2059             :                     const int nBlockId =
    2060         292 :                         poFirstBand->ComputeBlockId(nBlockXOff, m_nBlockYOff);
    2061         292 :                     nCurOffset = panOffsets[nBlockId];
    2062         292 :                     if (nCurOffset != 0)
    2063             :                     {
    2064         292 :                         pabyLocalSrcDataStartLine = oFetcher.FetchBytes(
    2065         146 :                             nCurOffset + nBaseByteOffsetIm_nBlock,
    2066         146 :                             m_nBlockXSize * nBandsPerBlock * nUsedBlockHeight,
    2067             :                             nDTSize, bIsByteSwapped, bIsComplex, nBlockId);
    2068         146 :                         if (pabyLocalSrcDataStartLine == nullptr)
    2069           1 :                             return CE_Failure;
    2070             :                     }
    2071             :                 }
    2072             : 
    2073       10743 :                 if (nCurOffset == 0)
    2074             :                 {
    2075             :                     REACHED(38);
    2076             : 
    2077      442476 :                     for (int k = 0; k < ychunk; ++k)
    2078             :                     {
    2079      437062 :                         GByte *const pabyLocalData =
    2080      437062 :                             pabyData + (y + k) * nLineSpace + x * nPixelSpace;
    2081     2185310 :                         for (int iBand = 0; iBand < nBandCount; ++iBand)
    2082             :                         {
    2083     1748250 :                             GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2084     1748250 :                                           pabyLocalData + nBandSpace * iBand,
    2085             :                                           eBufType, 0, 1);
    2086             :                         }
    2087             :                     }
    2088             :                 }
    2089             :                 else
    2090             :                 {
    2091        5329 :                     const int nXOffsetInBlock = nSrcPixel - nCurBlockXOff;
    2092        5329 :                     double dfYOff = dfYOffStart;
    2093        5329 :                     const GByte *const pabyLocalSrcDataK0 =
    2094             :                         pabyLocalSrcDataStartLine +
    2095        5329 :                         nXOffsetInBlock * nBandsPerBlockDTSize;
    2096        5329 :                     GByte *pabyLocalData =
    2097        5329 :                         pabyData + y * nLineSpace + x * nPixelSpace;
    2098      429042 :                     for (int k = 0; k < ychunk;
    2099      423713 :                          ++k, pabyLocalData += nLineSpace)
    2100             :                     {
    2101      423713 :                         const GByte *pabyLocalSrcData = nullptr;
    2102      423713 :                         if (ychunk <= 256)
    2103             :                         {
    2104             :                             REACHED(39);
    2105      231713 :                             pabyLocalSrcData =
    2106      231713 :                                 pabyLocalSrcDataK0 + anSrcYOffset[k];
    2107             :                         }
    2108             :                         else
    2109             :                         {
    2110             :                             REACHED(40);
    2111      192000 :                             const int nYOffsetIm_nBlockK =
    2112      192000 :                                 static_cast<int>(dfYOff) % m_nBlockYSize;
    2113             :                             // CPLAssert(
    2114             :                             //     nYOffsetIm_nBlockK - nYOffsetIm_nBlock <=
    2115             :                             //     nUsedBlockHeight);
    2116      192000 :                             pabyLocalSrcData =
    2117             :                                 pabyLocalSrcDataK0 +
    2118      192000 :                                 (nYOffsetIm_nBlockK - nYOffsetIm_nBlock) *
    2119      192000 :                                     m_nBlockXSize * nBandsPerBlockDTSize;
    2120      192000 :                             dfYOff += dfSrcYInc;
    2121             :                         }
    2122             : 
    2123      423713 :                         if (bByteOnly)
    2124             :                         {
    2125             :                             REACHED(41);
    2126     2118560 :                             for (int iBand = 0; iBand < nBandCount; ++iBand)
    2127             :                             {
    2128     1694850 :                                 GByte *pabyLocalDataBand =
    2129     1694850 :                                     pabyLocalData + iBand * nBandSpace;
    2130     1694850 :                                 const GByte *pabyLocalSrcDataBand =
    2131     1694850 :                                     pabyLocalSrcData + (panBandMap[iBand] - 1);
    2132     1694850 :                                 *pabyLocalDataBand = *pabyLocalSrcDataBand;
    2133             :                             }
    2134             :                         }
    2135             :                         else
    2136             :                         {
    2137             :                             REACHED(42);
    2138           0 :                             for (int iBand = 0; iBand < nBandCount; ++iBand)
    2139             :                             {
    2140           0 :                                 GByte *pabyLocalDataBand =
    2141           0 :                                     pabyLocalData + iBand * nBandSpace;
    2142           0 :                                 const GByte *pabyLocalSrcDataBand =
    2143             :                                     pabyLocalSrcData +
    2144           0 :                                     (panBandMap[iBand] - 1) * nDTSize;
    2145             : 
    2146           0 :                                 GDALCopyWords(pabyLocalSrcDataBand, eDataType,
    2147             :                                               0, pabyLocalDataBand, eBufType, 0,
    2148             :                                               1);
    2149             :                             }
    2150             :                         }
    2151             :                     }
    2152             :                 }
    2153             :             }
    2154             : 
    2155          99 :             y += ychunk;
    2156             :         }
    2157             :     }
    2158             :     // cppcheck-suppress knownConditionTrueFalse
    2159         228 :     else if (FetchBuffer::bMinimizeIO && TIFFIsTiled(m_hTIFF))
    2160             :     // && (m_nPlanarConfig == PLANARCONFIG_SEPARATE || nBandCount == 1) )
    2161             :     {
    2162         452 :         for (int iBand = 0; iBand < nBandCount; ++iBand)
    2163             :         {
    2164         228 :             GByte *pabyData = static_cast<GByte *>(pData) + iBand * nBandSpace;
    2165         228 :             const int nBand = panBandMap[iBand];
    2166             :             auto poCurBand =
    2167         228 :                 cpl::down_cast<GTiffRasterBand *>(GetRasterBand(nBand));
    2168         228 :             int anSrcYOffset[256] = {0};
    2169        1392 :             for (int y = 0; y < nBufYSize;)
    2170             :             {
    2171        1168 :                 const double dfYOffStart = nYOff + (y + 0.5) * dfSrcYInc;
    2172        1168 :                 const int nSrcLine = static_cast<int>(dfYOffStart);
    2173        1168 :                 const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    2174        1168 :                 const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    2175        1168 :                 const int nBaseByteOffsetIm_nBlock =
    2176        1168 :                     nYOffsetIm_nBlock * m_nBlockXSize * nBandsPerBlockDTSize;
    2177        1168 :                 int ychunk = 1;
    2178        1168 :                 int nLastSrcLineK = nSrcLine;
    2179        1168 :                 anSrcYOffset[0] = 0;
    2180      125300 :                 for (int k = 1; k < nBufYSize - y; ++k)
    2181             :                 {
    2182      125072 :                     const int nSrcLineK =
    2183      125072 :                         nYOff + static_cast<int>((y + k + 0.5) * dfSrcYInc);
    2184      125072 :                     const int nBlockYOffK = nSrcLineK / m_nBlockYSize;
    2185      125072 :                     if (k < 256)
    2186       80072 :                         anSrcYOffset[k] =
    2187       80072 :                             ((nSrcLineK % m_nBlockYSize) - nYOffsetIm_nBlock) *
    2188       80072 :                             m_nBlockXSize * nBandsPerBlockDTSize;
    2189      125072 :                     if (nBlockYOffK != m_nBlockYOff)
    2190             :                     {
    2191         940 :                         break;
    2192             :                     }
    2193      124132 :                     ++ychunk;
    2194      124132 :                     nLastSrcLineK = nSrcLineK;
    2195             :                 }
    2196        1168 :                 const int nUsedBlockHeight = nLastSrcLineK - nSrcLine + 1;
    2197             :                 // CPLAssert(nUsedBlockHeight <= m_nBlockYSize);
    2198             : 
    2199        1168 :                 double dfSrcX = nXOff + 0.5 * dfSrcXInc;
    2200        1168 :                 int nCurBlockXOff = 0;
    2201        1168 :                 int nNextBlockXOff = 0;
    2202        1168 :                 toff_t nCurOffset = 0;
    2203        1168 :                 const GByte *pabyLocalSrcDataStartLine = nullptr;
    2204      138796 :                 for (int x = 0; x < nBufXSize; ++x, dfSrcX += dfSrcXInc)
    2205             :                 {
    2206      137632 :                     int nSrcPixel = static_cast<int>(dfSrcX);
    2207      137632 :                     if (nSrcPixel >= nNextBlockXOff)
    2208             :                     {
    2209        3424 :                         const int nBlockXOff = nSrcPixel / m_nBlockXSize;
    2210        3424 :                         nCurBlockXOff = nBlockXOff * m_nBlockXSize;
    2211        3424 :                         nNextBlockXOff = nCurBlockXOff + m_nBlockXSize;
    2212             :                         const int nBlockId =
    2213        3424 :                             poCurBand->ComputeBlockId(nBlockXOff, m_nBlockYOff);
    2214        3424 :                         nCurOffset = panOffsets[nBlockId];
    2215        3424 :                         if (nCurOffset != 0)
    2216             :                         {
    2217        5392 :                             pabyLocalSrcDataStartLine = oFetcher.FetchBytes(
    2218        2696 :                                 nCurOffset + nBaseByteOffsetIm_nBlock,
    2219        2696 :                                 m_nBlockXSize * nBandsPerBlock *
    2220             :                                     nUsedBlockHeight,
    2221             :                                 nDTSize, bIsByteSwapped, bIsComplex, nBlockId);
    2222        2696 :                             if (pabyLocalSrcDataStartLine == nullptr)
    2223           4 :                                 return CE_Failure;
    2224             : 
    2225        2692 :                             if (m_nPlanarConfig == PLANARCONFIG_CONTIG)
    2226             :                             {
    2227             :                                 REACHED(45);
    2228          72 :                                 pabyLocalSrcDataStartLine +=
    2229          72 :                                     (nBand - 1) * nDTSize;
    2230             :                             }
    2231             :                             else
    2232             :                             {
    2233             :                                 REACHED(46);
    2234             :                             }
    2235             :                         }
    2236             :                     }
    2237             : 
    2238      137628 :                     if (nCurOffset == 0)
    2239             :                     {
    2240             :                         REACHED(47);
    2241             : 
    2242     2215820 :                         for (int k = 0; k < ychunk; ++k)
    2243             :                         {
    2244     2185310 :                             GByte *const pabyLocalData = pabyData +
    2245     2185310 :                                                          (y + k) * nLineSpace +
    2246     2185310 :                                                          x * nPixelSpace;
    2247             : 
    2248     2185310 :                             GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2249             :                                           pabyLocalData, eBufType, 0, 1);
    2250             :                         }
    2251             :                     }
    2252             :                     else
    2253             :                     {
    2254      107116 :                         const int nXOffsetInBlock = nSrcPixel - nCurBlockXOff;
    2255      107116 :                         double dfYOff = dfYOffStart;
    2256      107116 :                         const GByte *const pabyLocalSrcDataK0 =
    2257             :                             pabyLocalSrcDataStartLine +
    2258      107116 :                             nXOffsetInBlock * nBandsPerBlockDTSize;
    2259      107116 :                         GByte *pabyLocalData =
    2260      107116 :                             pabyData + y * nLineSpace + x * nPixelSpace;
    2261     7952300 :                         for (int k = 0; k < ychunk;
    2262     7845180 :                              ++k, pabyLocalData += nLineSpace)
    2263             :                         {
    2264     7845180 :                             const GByte *pabyLocalSrcData = nullptr;
    2265     7845180 :                             if (ychunk <= 256)
    2266             :                             {
    2267             :                                 REACHED(48);
    2268     4773180 :                                 pabyLocalSrcData =
    2269     4773180 :                                     pabyLocalSrcDataK0 + anSrcYOffset[k];
    2270             :                             }
    2271             :                             else
    2272             :                             {
    2273             :                                 REACHED(49);
    2274     3072000 :                                 const int nYOffsetIm_nBlockK =
    2275     3072000 :                                     static_cast<int>(dfYOff) % m_nBlockYSize;
    2276             :                                 // CPLAssert(
    2277             :                                 //     nYOffsetIm_nBlockK - nYOffsetIm_nBlock <=
    2278             :                                 //     nUsedBlockHeight);
    2279     3072000 :                                 pabyLocalSrcData =
    2280             :                                     pabyLocalSrcDataK0 +
    2281     3072000 :                                     (nYOffsetIm_nBlockK - nYOffsetIm_nBlock) *
    2282     3072000 :                                         m_nBlockXSize * nBandsPerBlockDTSize;
    2283     3072000 :                                 dfYOff += dfSrcYInc;
    2284             :                             }
    2285             : 
    2286     7845180 :                             if (bByteOnly)
    2287             :                             {
    2288             :                                 REACHED(50);
    2289             : 
    2290     2121160 :                                 *pabyLocalData = *pabyLocalSrcData;
    2291             :                             }
    2292             :                             else
    2293             :                             {
    2294             :                                 REACHED(51);
    2295             : 
    2296     5724020 :                                 GDALCopyWords(pabyLocalSrcData, eDataType, 0,
    2297             :                                               pabyLocalData, eBufType, 0, 1);
    2298             :                             }
    2299             :                         }
    2300             :                     }
    2301             :                 }
    2302             : 
    2303        1164 :                 y += ychunk;
    2304             :             }
    2305             :         }
    2306             :     }
    2307         971 :     else if (bUseContigImplementation)
    2308             :     {
    2309             :         // cppcheck-suppress knownConditionTrueFalse
    2310          72 :         if (!FetchBuffer::bMinimizeIO && TIFFIsTiled(m_hTIFF))
    2311             :         {
    2312          37 :             GByte *pabyData = static_cast<GByte *>(pData);
    2313        2777 :             for (int y = 0; y < nBufYSize; ++y)
    2314             :             {
    2315        2742 :                 const int nSrcLine =
    2316        2742 :                     nYOff + static_cast<int>((y + 0.5) * dfSrcYInc);
    2317        2742 :                 const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    2318        2742 :                 const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    2319        2742 :                 const int nBaseByteOffsetIm_nBlock =
    2320        2742 :                     nYOffsetIm_nBlock * m_nBlockXSize * nBandsPerBlockDTSize;
    2321             : 
    2322        2742 :                 if (bNoXResampling)
    2323             :                 {
    2324        2535 :                     GByte *pabyLocalData = pabyData + y * nLineSpace;
    2325        2535 :                     int nBlockXOff = nXOff / m_nBlockXSize;
    2326        2535 :                     int nXOffsetInBlock = nXOff % m_nBlockXSize;
    2327             :                     int nBlockId =
    2328        2535 :                         poFirstBand->ComputeBlockId(nBlockXOff, m_nBlockYOff);
    2329             : 
    2330        2535 :                     int x = 0;
    2331       12372 :                     while (x < nBufXSize)
    2332             :                     {
    2333        9838 :                         const int nByteOffsetIm_nBlock =
    2334             :                             nBaseByteOffsetIm_nBlock +
    2335        9838 :                             nXOffsetInBlock * nBandsPerBlockDTSize;
    2336        9838 :                         const toff_t nCurOffset = panOffsets[nBlockId];
    2337        9838 :                         const int nUsedBlockWidth = std::min(
    2338        9838 :                             m_nBlockXSize - nXOffsetInBlock, nBufXSize - x);
    2339             : 
    2340        9838 :                         int nIters = nUsedBlockWidth;
    2341        9838 :                         if (nCurOffset == 0)
    2342             :                         {
    2343        3768 :                             if (bByteNoXResampling)
    2344             :                             {
    2345             :                                 REACHED(0);
    2346       46560 :                                 while (nIters-- > 0)
    2347             :                                 {
    2348      217886 :                                     for (int iBand = 0; iBand < nBandCount;
    2349             :                                          ++iBand)
    2350             :                                     {
    2351      172964 :                                         pabyLocalData[iBand] = abyNoData;
    2352             :                                     }
    2353       44922 :                                     pabyLocalData += nPixelSpace;
    2354             :                                 }
    2355             :                             }
    2356             :                             else
    2357             :                             {
    2358             :                                 REACHED(1);
    2359       60500 :                                 while (nIters-- > 0)
    2360             :                                 {
    2361       58370 :                                     GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2362             :                                                   pabyLocalData, eBufType,
    2363             :                                                   static_cast<int>(nBandSpace),
    2364             :                                                   nBandCount);
    2365       58370 :                                     pabyLocalData += nPixelSpace;
    2366             :                                 }
    2367             :                             }
    2368             :                         }
    2369             :                         else
    2370             :                         {
    2371        6070 :                             if (bNoTypeChange && nBands == nBandCount &&
    2372        4612 :                                 nPixelSpace == nBandsPerBlockDTSize)
    2373             :                             {
    2374             :                                 REACHED(2);
    2375        3397 :                                 if (!oFetcher.FetchBytes(
    2376             :                                         pabyLocalData,
    2377        3397 :                                         nCurOffset + nByteOffsetIm_nBlock,
    2378             :                                         nIters * nBandsPerBlock, nDTSize,
    2379             :                                         bIsByteSwapped, bIsComplex, nBlockId))
    2380             :                                 {
    2381           1 :                                     return CE_Failure;
    2382             :                                 }
    2383        3396 :                                 pabyLocalData +=
    2384        3396 :                                     nIters * nBandsPerBlock * nDTSize;
    2385             :                             }
    2386             :                             else
    2387             :                             {
    2388        5346 :                                 const GByte *pabyLocalSrcData =
    2389             :                                     oFetcher.FetchBytes(
    2390        2673 :                                         nCurOffset + nByteOffsetIm_nBlock,
    2391             :                                         nIters * nBandsPerBlock, nDTSize,
    2392             :                                         bIsByteSwapped, bIsComplex, nBlockId);
    2393        2673 :                                 if (pabyLocalSrcData == nullptr)
    2394           0 :                                     return CE_Failure;
    2395        2673 :                                 if (bByteNoXResampling)
    2396             :                                 {
    2397             :                                     REACHED(3);
    2398        1944 :                                     CopyContigByteMultiBand(
    2399             :                                         pabyLocalSrcData, nBandsPerBlockDTSize,
    2400             :                                         pabyLocalData,
    2401             :                                         static_cast<int>(nPixelSpace), nIters,
    2402             :                                         nBandCount);
    2403        1944 :                                     pabyLocalData += nIters * nPixelSpace;
    2404             :                                 }
    2405             :                                 else
    2406             :                                 {
    2407             :                                     REACHED(4);
    2408       20412 :                                     while (nIters-- > 0)
    2409             :                                     {
    2410       19683 :                                         GDALCopyWords(
    2411             :                                             pabyLocalSrcData, eDataType,
    2412             :                                             nDTSize, pabyLocalData, eBufType,
    2413             :                                             static_cast<int>(nBandSpace),
    2414             :                                             nBandCount);
    2415       19683 :                                         pabyLocalSrcData +=
    2416       19683 :                                             nBandsPerBlockDTSize;
    2417       19683 :                                         pabyLocalData += nPixelSpace;
    2418             :                                     }
    2419             :                                 }
    2420             :                             }
    2421             :                         }
    2422             : 
    2423        9837 :                         nXOffsetInBlock = 0;
    2424        9837 :                         ++nBlockXOff;
    2425        9837 :                         ++nBlockId;
    2426        9837 :                         x += nUsedBlockWidth;
    2427             :                     }
    2428             :                 }
    2429             :                 else  // Contig, tiled, potential resampling & data type change.
    2430             :                 {
    2431         207 :                     const GByte *pabyLocalSrcDataStartLine = nullptr;
    2432         207 :                     GByte *pabyLocalData = pabyData + y * nLineSpace;
    2433         207 :                     double dfSrcX = nXOff + 0.5 * dfSrcXInc;
    2434         207 :                     int nCurBlockXOff = 0;
    2435         207 :                     int nNextBlockXOff = 0;
    2436         207 :                     toff_t nCurOffset = 0;
    2437        8373 :                     for (int x = 0; x < nBufXSize; ++x, dfSrcX += dfSrcXInc)
    2438             :                     {
    2439        8167 :                         int nSrcPixel = static_cast<int>(dfSrcX);
    2440        8167 :                         if (nSrcPixel >= nNextBlockXOff)
    2441             :                         {
    2442         611 :                             const int nBlockXOff = nSrcPixel / m_nBlockXSize;
    2443         611 :                             nCurBlockXOff = nBlockXOff * m_nBlockXSize;
    2444         611 :                             nNextBlockXOff = nCurBlockXOff + m_nBlockXSize;
    2445         611 :                             const int nBlockId = poFirstBand->ComputeBlockId(
    2446             :                                 nBlockXOff, m_nBlockYOff);
    2447         611 :                             nCurOffset = panOffsets[nBlockId];
    2448         611 :                             if (nCurOffset != 0)
    2449             :                             {
    2450         726 :                                 pabyLocalSrcDataStartLine = oFetcher.FetchBytes(
    2451         363 :                                     nCurOffset + nBaseByteOffsetIm_nBlock,
    2452         363 :                                     m_nBlockXSize * nBandsPerBlock, nDTSize,
    2453             :                                     bIsByteSwapped, bIsComplex, nBlockId);
    2454         363 :                                 if (pabyLocalSrcDataStartLine == nullptr)
    2455           1 :                                     return CE_Failure;
    2456             :                             }
    2457             :                         }
    2458        8166 :                         const int nXOffsetInBlock = nSrcPixel - nCurBlockXOff;
    2459             : 
    2460        8166 :                         if (nCurOffset == 0)
    2461             :                         {
    2462             :                             REACHED(5);
    2463        3364 :                             GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2464             :                                           pabyLocalData, eBufType,
    2465             :                                           static_cast<int>(nBandSpace),
    2466             :                                           nBandCount);
    2467        3364 :                             pabyLocalData += nPixelSpace;
    2468             :                         }
    2469             :                         else
    2470             :                         {
    2471        4802 :                             const GByte *pabyLocalSrcData =
    2472             :                                 pabyLocalSrcDataStartLine +
    2473        4802 :                                 nXOffsetInBlock * nBandsPerBlockDTSize;
    2474             : 
    2475             :                             REACHED(6);
    2476        4802 :                             if (bByteOnly)
    2477             :                             {
    2478       20809 :                                 for (int iBand = 0; iBand < nBands; ++iBand)
    2479       16007 :                                     pabyLocalData[iBand] =
    2480       16007 :                                         pabyLocalSrcData[iBand];
    2481             :                             }
    2482             :                             else
    2483             :                             {
    2484           0 :                                 GDALCopyWords(pabyLocalSrcData, eDataType,
    2485             :                                               nDTSize, pabyLocalData, eBufType,
    2486             :                                               static_cast<int>(nBandSpace),
    2487             :                                               nBandCount);
    2488             :                             }
    2489        4802 :                             pabyLocalData += nPixelSpace;
    2490             :                         }
    2491             :                     }
    2492             :                 }
    2493             :             }
    2494             :         }
    2495             :         else  // Contig, striped organized.
    2496             :         {
    2497          35 :             GByte *pabyData = static_cast<GByte *>(pData);
    2498        2618 :             for (int y = 0; y < nBufYSize; ++y)
    2499             :             {
    2500        2585 :                 const int nSrcLine =
    2501        2585 :                     nYOff + static_cast<int>((y + 0.5) * dfSrcYInc);
    2502        2585 :                 const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    2503        2585 :                 const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    2504        2585 :                 const int nBlockId = m_nBlockYOff;
    2505        2585 :                 const toff_t nCurOffset = panOffsets[nBlockId];
    2506        2585 :                 if (nCurOffset == 0)
    2507             :                 {
    2508             :                     REACHED(7);
    2509      107696 :                     for (int x = 0; x < nBufXSize; ++x)
    2510             :                     {
    2511      106656 :                         GDALCopyWords(
    2512             :                             &dfNoData, GDT_Float64, 0,
    2513      106656 :                             pabyData + y * nLineSpace + x * nPixelSpace,
    2514             :                             eBufType, static_cast<int>(nBandSpace), nBandCount);
    2515             :                     }
    2516             :                 }
    2517             :                 else
    2518             :                 {
    2519        1545 :                     GByte *pabyLocalData = pabyData + y * nLineSpace;
    2520        1545 :                     const int nBaseByteOffsetIm_nBlock =
    2521        1545 :                         (nYOffsetIm_nBlock * m_nBlockXSize + nXOff) *
    2522             :                         nBandsPerBlockDTSize;
    2523             : 
    2524        1545 :                     if (bNoXResamplingNoTypeChange && nBands == nBandCount &&
    2525         936 :                         nPixelSpace == nBandsPerBlockDTSize)
    2526             :                     {
    2527             :                         REACHED(8);
    2528         693 :                         if (!oFetcher.FetchBytes(
    2529             :                                 pabyLocalData,
    2530         693 :                                 nCurOffset + nBaseByteOffsetIm_nBlock,
    2531             :                                 nXSize * nBandsPerBlock, nDTSize,
    2532             :                                 bIsByteSwapped, bIsComplex, nBlockId))
    2533             :                         {
    2534           1 :                             return CE_Failure;
    2535             :                         }
    2536             :                     }
    2537             :                     else
    2538             :                     {
    2539        1704 :                         const GByte *pabyLocalSrcData = oFetcher.FetchBytes(
    2540         852 :                             nCurOffset + nBaseByteOffsetIm_nBlock,
    2541             :                             nXSize * nBandsPerBlock, nDTSize, bIsByteSwapped,
    2542             :                             bIsComplex, nBlockId);
    2543         852 :                         if (pabyLocalSrcData == nullptr)
    2544           1 :                             return CE_Failure;
    2545             : 
    2546         851 :                         if (bByteNoXResampling)
    2547             :                         {
    2548             :                             REACHED(9);
    2549         486 :                             CopyContigByteMultiBand(
    2550             :                                 pabyLocalSrcData, nBandsPerBlockDTSize,
    2551             :                                 pabyLocalData, static_cast<int>(nPixelSpace),
    2552             :                                 nBufXSize, nBandCount);
    2553             :                         }
    2554         365 :                         else if (bByteOnly)
    2555             :                         {
    2556             :                             REACHED(10);
    2557         122 :                             double dfSrcX = 0.5 * dfSrcXInc;
    2558        4924 :                             for (int x = 0; x < nBufXSize;
    2559             :                                  ++x, dfSrcX += dfSrcXInc)
    2560             :                             {
    2561        4802 :                                 const int nSrcPixelMinusXOff =
    2562             :                                     static_cast<int>(dfSrcX);
    2563       24010 :                                 for (int iBand = 0; iBand < nBandCount; ++iBand)
    2564             :                                 {
    2565       19208 :                                     pabyLocalData[x * nPixelSpace + iBand] =
    2566             :                                         pabyLocalSrcData
    2567       19208 :                                             [nSrcPixelMinusXOff *
    2568       19208 :                                                  nBandsPerBlockDTSize +
    2569             :                                              iBand];
    2570             :                                 }
    2571             :                             }
    2572             :                         }
    2573             :                         else
    2574             :                         {
    2575             :                             REACHED(11);
    2576         243 :                             double dfSrcX = 0.5 * dfSrcXInc;
    2577       19926 :                             for (int x = 0; x < nBufXSize;
    2578             :                                  ++x, dfSrcX += dfSrcXInc)
    2579             :                             {
    2580       19683 :                                 int nSrcPixelMinusXOff =
    2581             :                                     static_cast<int>(dfSrcX);
    2582       19683 :                                 GDALCopyWords(
    2583       19683 :                                     pabyLocalSrcData + nSrcPixelMinusXOff *
    2584             :                                                            nBandsPerBlockDTSize,
    2585             :                                     eDataType, nDTSize,
    2586       19683 :                                     pabyLocalData + x * nPixelSpace, eBufType,
    2587             :                                     static_cast<int>(nBandSpace), nBandCount);
    2588             :                             }
    2589             :                         }
    2590             :                     }
    2591             :                 }
    2592             :             }
    2593             :         }
    2594             :     }
    2595             :     else  // Non-contig reading case.
    2596             :     {
    2597             :         // cppcheck-suppress knownConditionTrueFalse
    2598         899 :         if (!FetchBuffer::bMinimizeIO && TIFFIsTiled(m_hTIFF))
    2599             :         {
    2600        1455 :             for (int iBand = 0; iBand < nBandCount; ++iBand)
    2601             :             {
    2602        1059 :                 const int nBand = panBandMap[iBand];
    2603             :                 auto poCurBand =
    2604        1059 :                     cpl::down_cast<GTiffRasterBand *>(GetRasterBand(nBand));
    2605        1059 :                 GByte *const pabyData =
    2606        1059 :                     static_cast<GByte *>(pData) + iBand * nBandSpace;
    2607      284551 :                 for (int y = 0; y < nBufYSize; ++y)
    2608             :                 {
    2609      283506 :                     const int nSrcLine =
    2610      283506 :                         nYOff + static_cast<int>((y + 0.5) * dfSrcYInc);
    2611      283506 :                     const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    2612      283506 :                     const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    2613             : 
    2614      283506 :                     int nBaseByteOffsetIm_nBlock = nYOffsetIm_nBlock *
    2615      283506 :                                                    m_nBlockXSize *
    2616             :                                                    nBandsPerBlockDTSize;
    2617      283506 :                     if (m_nPlanarConfig == PLANARCONFIG_CONTIG)
    2618             :                     {
    2619             :                         REACHED(12);
    2620       66004 :                         nBaseByteOffsetIm_nBlock += (nBand - 1) * nDTSize;
    2621             :                     }
    2622             :                     else
    2623             :                     {
    2624             :                         REACHED(13);
    2625             :                     }
    2626             : 
    2627      283506 :                     if (bNoXResampling)
    2628             :                     {
    2629       67404 :                         GByte *pabyLocalData = pabyData + y * nLineSpace;
    2630       67404 :                         int nBlockXOff = nXOff / m_nBlockXSize;
    2631             :                         int nBlockId =
    2632       67404 :                             poCurBand->ComputeBlockId(nBlockXOff, m_nBlockYOff);
    2633       67404 :                         int nXOffsetInBlock = nXOff % m_nBlockXSize;
    2634             : 
    2635       67404 :                         int x = 0;
    2636      331986 :                         while (x < nBufXSize)
    2637             :                         {
    2638      264592 :                             const int nByteOffsetIm_nBlock =
    2639             :                                 nBaseByteOffsetIm_nBlock +
    2640      264592 :                                 nXOffsetInBlock * nBandsPerBlockDTSize;
    2641      264592 :                             const toff_t nCurOffset = panOffsets[nBlockId];
    2642      264592 :                             const int nUsedBlockWidth = std::min(
    2643      264592 :                                 m_nBlockXSize - nXOffsetInBlock, nBufXSize - x);
    2644      264592 :                             int nIters = nUsedBlockWidth;
    2645             : 
    2646      264592 :                             if (nCurOffset == 0)
    2647             :                             {
    2648             :                                 REACHED(16);
    2649       52038 :                                 GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2650             :                                               pabyLocalData, eBufType,
    2651             :                                               static_cast<int>(nPixelSpace),
    2652             :                                               nIters);
    2653       52038 :                                 pabyLocalData += nIters * nPixelSpace;
    2654             :                             }
    2655             :                             else
    2656             :                             {
    2657      212554 :                                 if (bNoTypeChange &&
    2658      177871 :                                     nPixelSpace == nBandsPerBlockDTSize)
    2659             :                                 {
    2660             :                                     REACHED(17);
    2661       84112 :                                     if (!oFetcher.FetchBytes(
    2662             :                                             pabyLocalData,
    2663       84112 :                                             nCurOffset + nByteOffsetIm_nBlock,
    2664       84112 :                                             (nIters - 1) * nBandsPerBlock + 1,
    2665             :                                             nDTSize, bIsByteSwapped, bIsComplex,
    2666             :                                             nBlockId))
    2667             :                                     {
    2668           4 :                                         return CE_Failure;
    2669             :                                     }
    2670       84108 :                                     pabyLocalData += nIters * nPixelSpace;
    2671             :                                 }
    2672             :                                 else
    2673             :                                 {
    2674      256884 :                                     const GByte *pabyLocalSrcData =
    2675             :                                         oFetcher.FetchBytes(
    2676      128442 :                                             nCurOffset + nByteOffsetIm_nBlock,
    2677      128442 :                                             (nIters - 1) * nBandsPerBlock + 1,
    2678             :                                             nDTSize, bIsByteSwapped, bIsComplex,
    2679             :                                             nBlockId);
    2680      128442 :                                     if (pabyLocalSrcData == nullptr)
    2681           6 :                                         return CE_Failure;
    2682             : 
    2683             :                                     REACHED(18);
    2684      128436 :                                     GDALCopyWords(pabyLocalSrcData, eDataType,
    2685             :                                                   nBandsPerBlockDTSize,
    2686             :                                                   pabyLocalData, eBufType,
    2687             :                                                   static_cast<int>(nPixelSpace),
    2688             :                                                   nIters);
    2689      128436 :                                     pabyLocalData += nIters * nPixelSpace;
    2690             :                                 }
    2691             :                             }
    2692             : 
    2693      264582 :                             nXOffsetInBlock = 0;
    2694      264582 :                             ++nBlockXOff;
    2695      264582 :                             ++nBlockId;
    2696      264582 :                             x += nUsedBlockWidth;
    2697             :                         }
    2698             :                     }
    2699             :                     else
    2700             :                     {
    2701             :                         // Non-contig reading, tiled, potential resampling and
    2702             :                         // data type change.
    2703             : 
    2704      216102 :                         const GByte *pabyLocalSrcDataStartLine = nullptr;
    2705      216102 :                         GByte *pabyLocalData = pabyData + y * nLineSpace;
    2706      216102 :                         double dfSrcX = nXOff + 0.5 * dfSrcXInc;
    2707      216102 :                         int nCurBlockXOff = 0;
    2708      216102 :                         int nNextBlockXOff = 0;
    2709      216102 :                         toff_t nCurOffset = 0;
    2710    16883500 :                         for (int x = 0; x < nBufXSize; ++x, dfSrcX += dfSrcXInc)
    2711             :                         {
    2712    16667400 :                             const int nSrcPixel = static_cast<int>(dfSrcX);
    2713    16667400 :                             if (nSrcPixel >= nNextBlockXOff)
    2714             :                             {
    2715      648202 :                                 const int nBlockXOff =
    2716      648202 :                                     nSrcPixel / m_nBlockXSize;
    2717      648202 :                                 nCurBlockXOff = nBlockXOff * m_nBlockXSize;
    2718      648202 :                                 nNextBlockXOff = nCurBlockXOff + m_nBlockXSize;
    2719      648202 :                                 const int nBlockId = poCurBand->ComputeBlockId(
    2720             :                                     nBlockXOff, m_nBlockYOff);
    2721      648202 :                                 nCurOffset = panOffsets[nBlockId];
    2722      648202 :                                 if (nCurOffset != 0)
    2723             :                                 {
    2724      998236 :                                     pabyLocalSrcDataStartLine =
    2725             :                                         oFetcher.FetchBytes(
    2726      499118 :                                             nCurOffset +
    2727      499118 :                                                 nBaseByteOffsetIm_nBlock,
    2728      499118 :                                             m_nBlockXSize * nBandsPerBlock,
    2729             :                                             nDTSize, bIsByteSwapped, bIsComplex,
    2730             :                                             nBlockId);
    2731      499118 :                                     if (pabyLocalSrcDataStartLine == nullptr)
    2732           4 :                                         return CE_Failure;
    2733             :                                 }
    2734             :                             }
    2735    16667400 :                             const int nXOffsetInBlock =
    2736             :                                 nSrcPixel - nCurBlockXOff;
    2737             : 
    2738    16667400 :                             if (nCurOffset == 0)
    2739             :                             {
    2740             :                                 REACHED(21);
    2741     3920100 :                                 GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2742             :                                               pabyLocalData, eBufType, 0, 1);
    2743     3920100 :                                 pabyLocalData += nPixelSpace;
    2744             :                             }
    2745             :                             else
    2746             :                             {
    2747    12747300 :                                 const GByte *pabyLocalSrcData =
    2748             :                                     pabyLocalSrcDataStartLine +
    2749    12747300 :                                     nXOffsetInBlock * nBandsPerBlockDTSize;
    2750             : 
    2751             :                                 REACHED(22);
    2752    12747300 :                                 if (bByteOnly)
    2753             :                                 {
    2754     5192440 :                                     *pabyLocalData = *pabyLocalSrcData;
    2755             :                                 }
    2756             :                                 else
    2757             :                                 {
    2758     7554900 :                                     GDALCopyWords(pabyLocalSrcData, eDataType,
    2759             :                                                   0, pabyLocalData, eBufType, 0,
    2760             :                                                   1);
    2761             :                                 }
    2762    12747300 :                                 pabyLocalData += nPixelSpace;
    2763             :                             }
    2764             :                         }
    2765             :                     }
    2766             :                 }
    2767             :             }
    2768             :         }
    2769             :         else  // Non-contig reading, striped.
    2770             :         {
    2771        1796 :             for (int iBand = 0; iBand < nBandCount; ++iBand)
    2772             :             {
    2773        1324 :                 const int nBand = panBandMap[iBand];
    2774        1324 :                 GByte *pabyData =
    2775        1324 :                     static_cast<GByte *>(pData) + iBand * nBandSpace;
    2776      356944 :                 for (int y = 0; y < nBufYSize; ++y)
    2777             :                 {
    2778      355637 :                     const int nSrcLine =
    2779      355637 :                         nYOff + static_cast<int>((y + 0.5) * dfSrcYInc);
    2780      355637 :                     const int m_nBlockYOff = nSrcLine / m_nBlockYSize;
    2781      355637 :                     const int nYOffsetIm_nBlock = nSrcLine % m_nBlockYSize;
    2782      355637 :                     int nBlockId = m_nBlockYOff;
    2783      355637 :                     if (m_nPlanarConfig == PLANARCONFIG_SEPARATE)
    2784             :                     {
    2785             :                         REACHED(23);
    2786      282397 :                         nBlockId += m_nBlocksPerBand * (nBand - 1);
    2787             :                     }
    2788             :                     else
    2789             :                     {
    2790             :                         REACHED(24);
    2791             :                     }
    2792      355637 :                     const toff_t nCurOffset = panOffsets[nBlockId];
    2793      355637 :                     if (nCurOffset == 0)
    2794             :                     {
    2795             :                         REACHED(25);
    2796       62846 :                         GDALCopyWords(&dfNoData, GDT_Float64, 0,
    2797       62846 :                                       pabyData + y * nLineSpace, eBufType,
    2798             :                                       static_cast<int>(nPixelSpace), nBufXSize);
    2799             :                     }
    2800             :                     else
    2801             :                     {
    2802      292791 :                         int nBaseByteOffsetIm_nBlock =
    2803      292791 :                             (nYOffsetIm_nBlock * m_nBlockXSize + nXOff) *
    2804             :                             nBandsPerBlockDTSize;
    2805      292791 :                         if (m_nPlanarConfig == PLANARCONFIG_CONTIG)
    2806       43815 :                             nBaseByteOffsetIm_nBlock += (nBand - 1) * nDTSize;
    2807             : 
    2808      292791 :                         GByte *pabyLocalData = pabyData + y * nLineSpace;
    2809      292791 :                         if (bNoXResamplingNoTypeChange &&
    2810       56217 :                             nPixelSpace == nBandsPerBlockDTSize)
    2811             :                         {
    2812             :                             REACHED(26);
    2813       26844 :                             if (!oFetcher.FetchBytes(
    2814             :                                     pabyLocalData,
    2815       26844 :                                     nCurOffset + nBaseByteOffsetIm_nBlock,
    2816       26844 :                                     (nXSize - 1) * nBandsPerBlock + 1, nDTSize,
    2817             :                                     bIsByteSwapped, bIsComplex, nBlockId))
    2818             :                             {
    2819           5 :                                 return CE_Failure;
    2820             :                             }
    2821             :                         }
    2822             :                         else
    2823             :                         {
    2824      531894 :                             const GByte *pabyLocalSrcData = oFetcher.FetchBytes(
    2825      265947 :                                 nCurOffset + nBaseByteOffsetIm_nBlock,
    2826      265947 :                                 (nXSize - 1) * nBandsPerBlock + 1, nDTSize,
    2827             :                                 bIsByteSwapped, bIsComplex, nBlockId);
    2828      265947 :                             if (pabyLocalSrcData == nullptr)
    2829          12 :                                 return CE_Failure;
    2830             : 
    2831      265935 :                             if (bNoXResamplingNoTypeChange)
    2832             :                             {
    2833             :                                 REACHED(27);
    2834       29366 :                                 GDALCopyWords(pabyLocalSrcData, eDataType,
    2835             :                                               nBandsPerBlockDTSize,
    2836             :                                               pabyLocalData, eBufType,
    2837             :                                               static_cast<int>(nPixelSpace),
    2838             :                                               nBufXSize);
    2839             :                             }
    2840      236569 :                             else if (bByteOnly)
    2841             :                             {
    2842             :                                 REACHED(28);
    2843       73619 :                                 double dfSrcX = 0.5 * dfSrcXInc;
    2844     5778430 :                                 for (int x = 0; x < nBufXSize;
    2845             :                                      ++x, dfSrcX += dfSrcXInc)
    2846             :                                 {
    2847     5704810 :                                     const int nSrcPixelMinusXOff =
    2848             :                                         static_cast<int>(dfSrcX);
    2849     5704810 :                                     pabyLocalData[x * nPixelSpace] =
    2850     5704810 :                                         pabyLocalSrcData[nSrcPixelMinusXOff *
    2851             :                                                          nBandsPerBlockDTSize];
    2852             :                                 }
    2853             :                             }
    2854             :                             else
    2855             :                             {
    2856             :                                 REACHED(29);
    2857      162950 :                                 double dfSrcX = 0.5 * dfSrcXInc;
    2858    12817000 :                                 for (int x = 0; x < nBufXSize;
    2859             :                                      ++x, dfSrcX += dfSrcXInc)
    2860             :                                 {
    2861    12654100 :                                     const int nSrcPixelMinusXOff =
    2862             :                                         static_cast<int>(dfSrcX);
    2863    12654100 :                                     GDALCopyWords(pabyLocalSrcData +
    2864    12654100 :                                                       nSrcPixelMinusXOff *
    2865             :                                                           nBandsPerBlockDTSize,
    2866             :                                                   eDataType, 0,
    2867    12654100 :                                                   pabyLocalData +
    2868    12654100 :                                                       x * nPixelSpace,
    2869             :                                                   eBufType, 0, 1);
    2870             :                                 }
    2871             :                             }
    2872             :                         }
    2873             :                     }
    2874             :                 }
    2875             :             }
    2876             :         }
    2877             :     }
    2878             : 
    2879        1691 :     return CE_None;
    2880             : }
    2881             : 
    2882             : /************************************************************************/
    2883             : /*                           DirectIO()                                 */
    2884             : /************************************************************************/
    2885             : 
    2886         771 : CPLErr GTiffDataset::CommonDirectIOClassic(
    2887             :     FetchBufferDirectIO &oFetcher, int nXOff, int nYOff, int nXSize, int nYSize,
    2888             :     void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
    2889             :     int nBandCount, const int *panBandMap, GSpacing nPixelSpace,
    2890             :     GSpacing nLineSpace, GSpacing nBandSpace)
    2891             : {
    2892         771 :     return CommonDirectIO<FetchBufferDirectIO>(
    2893             :         oFetcher, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize,
    2894         771 :         eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace, nBandSpace);
    2895             : }
    2896             : 
    2897             : /************************************************************************/
    2898             : /*                           DirectIO()                                 */
    2899             : /************************************************************************/
    2900             : 
    2901             : // Reads directly bytes from the file using ReadMultiRange(), and by-pass
    2902             : // block reading. Restricted to simple TIFF configurations
    2903             : // (uncompressed data, standard data types). Particularly useful to extract
    2904             : // sub-windows of data on a large /vsicurl dataset).
    2905             : // Returns -1 if DirectIO() can't be supported on that file.
    2906             : 
    2907         471 : int GTiffDataset::DirectIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
    2908             :                            int nYSize, void *pData, int nBufXSize,
    2909             :                            int nBufYSize, GDALDataType eBufType, int nBandCount,
    2910             :                            const int *panBandMap, GSpacing nPixelSpace,
    2911             :                            GSpacing nLineSpace, GSpacing nBandSpace,
    2912             :                            GDALRasterIOExtraArg *psExtraArg)
    2913             : {
    2914         471 :     auto poProtoBand = cpl::down_cast<GTiffRasterBand *>(papoBands[0]);
    2915         471 :     const GDALDataType eDataType = poProtoBand->GetRasterDataType();
    2916         471 :     const int nDTSizeBits = GDALGetDataTypeSizeBits(eDataType);
    2917         942 :     if (!(eRWFlag == GF_Read && m_nCompression == COMPRESSION_NONE &&
    2918         471 :           (m_nPhotometric == PHOTOMETRIC_MINISBLACK ||
    2919         188 :            m_nPhotometric == PHOTOMETRIC_RGB ||
    2920           0 :            m_nPhotometric == PHOTOMETRIC_PALETTE) &&
    2921         471 :           poProtoBand->IsBaseGTiffClass()))
    2922             :     {
    2923           0 :         return -1;
    2924             :     }
    2925         471 :     Crystalize();
    2926             : 
    2927             :     // Only know how to deal with nearest neighbour in this optimized routine.
    2928         471 :     if ((nXSize != nBufXSize || nYSize != nBufYSize) && psExtraArg != nullptr &&
    2929         181 :         psExtraArg->eResampleAlg != GRIORA_NearestNeighbour)
    2930             :     {
    2931          30 :         return -1;
    2932             :     }
    2933             : 
    2934             :     // If the file is band interleave or only one band is requested, then
    2935             :     // fallback to band DirectIO.
    2936         441 :     bool bUseBandRasterIO = false;
    2937         441 :     if (m_nPlanarConfig == PLANARCONFIG_SEPARATE || nBandCount == 1)
    2938             :     {
    2939         323 :         bUseBandRasterIO = true;
    2940             :     }
    2941             :     else
    2942             :     {
    2943             :         // For simplicity, only deals with "naturally ordered" bands.
    2944         546 :         for (int iBand = 0; iBand < nBandCount; ++iBand)
    2945             :         {
    2946         436 :             if (panBandMap[iBand] != iBand + 1)
    2947             :             {
    2948           8 :                 bUseBandRasterIO = true;
    2949           8 :                 break;
    2950             :             }
    2951             :         }
    2952             :     }
    2953         441 :     if (bUseBandRasterIO)
    2954             :     {
    2955         331 :         CPLErr eErr = CE_None;
    2956        1626 :         for (int iBand = 0; eErr == CE_None && iBand < nBandCount; ++iBand)
    2957             :         {
    2958             :             eErr =
    2959        1295 :                 GetRasterBand(panBandMap[iBand])
    2960        2590 :                     ->RasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
    2961        1295 :                                static_cast<GByte *>(pData) + iBand * nBandSpace,
    2962             :                                nBufXSize, nBufYSize, eBufType, nPixelSpace,
    2963             :                                nLineSpace, psExtraArg);
    2964             :         }
    2965         331 :         return eErr;
    2966             :     }
    2967             : 
    2968             : #if DEBUG_VERBOSE
    2969             :     CPLDebug("GTiff", "DirectIO(%d,%d,%d,%d -> %dx%d)", nXOff, nYOff, nXSize,
    2970             :              nYSize, nBufXSize, nBufYSize);
    2971             : #endif
    2972             : 
    2973             :     // No need to look if overviews can satisfy the request as it has already */
    2974             :     // been done in GTiffDataset::IRasterIO().
    2975             : 
    2976             :     // Make sure that TIFFTAG_STRIPOFFSETS is up-to-date.
    2977         110 :     if (eAccess == GA_Update)
    2978             :     {
    2979           0 :         FlushCache(false);
    2980           0 :         VSI_TIFFFlushBufferedWrite(TIFFClientdata(m_hTIFF));
    2981             :     }
    2982             : 
    2983         110 :     if (TIFFIsTiled(m_hTIFF))
    2984             :     {
    2985          55 :         const int nDTSize = nDTSizeBits / 8;
    2986          55 :         const size_t nTempBufferForCommonDirectIOSize = static_cast<size_t>(
    2987         110 :             static_cast<GPtrDiff_t>(m_nBlockXSize) * m_nBlockYSize * nDTSize *
    2988          55 :             ((m_nPlanarConfig == PLANARCONFIG_CONTIG) ? nBands : 1));
    2989          55 :         if (m_pTempBufferForCommonDirectIO == nullptr)
    2990             :         {
    2991           0 :             m_pTempBufferForCommonDirectIO = static_cast<GByte *>(
    2992           0 :                 VSI_MALLOC_VERBOSE(nTempBufferForCommonDirectIOSize));
    2993           0 :             if (m_pTempBufferForCommonDirectIO == nullptr)
    2994           0 :                 return CE_Failure;
    2995             :         }
    2996             : 
    2997          55 :         VSILFILE *fp = VSI_TIFFGetVSILFile(TIFFClientdata(m_hTIFF));
    2998             :         FetchBufferDirectIO oFetcher(fp, m_pTempBufferForCommonDirectIO,
    2999          55 :                                      nTempBufferForCommonDirectIOSize);
    3000             : 
    3001          55 :         return CommonDirectIOClassic(oFetcher, nXOff, nYOff, nXSize, nYSize,
    3002             :                                      pData, nBufXSize, nBufYSize, eBufType,
    3003             :                                      nBandCount, panBandMap, nPixelSpace,
    3004          55 :                                      nLineSpace, nBandSpace);
    3005             :     }
    3006             : 
    3007             :     // Get strip offsets.
    3008          55 :     toff_t *panTIFFOffsets = nullptr;
    3009         110 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_STRIPOFFSETS, &panTIFFOffsets) ||
    3010          55 :         panTIFFOffsets == nullptr)
    3011             :     {
    3012           0 :         return CE_Failure;
    3013             :     }
    3014             : 
    3015             :     // Sub-sampling or over-sampling can only be done at last stage.
    3016          55 :     int nReqXSize = nXSize;
    3017             :     // Can do sub-sampling at the extraction stage.
    3018          55 :     const int nReqYSize = std::min(nBufYSize, nYSize);
    3019             :     void **ppData =
    3020          55 :         static_cast<void **>(VSI_MALLOC_VERBOSE(nReqYSize * sizeof(void *)));
    3021             :     vsi_l_offset *panOffsets = static_cast<vsi_l_offset *>(
    3022          55 :         VSI_MALLOC_VERBOSE(nReqYSize * sizeof(vsi_l_offset)));
    3023             :     size_t *panSizes =
    3024          55 :         static_cast<size_t *>(VSI_MALLOC_VERBOSE(nReqYSize * sizeof(size_t)));
    3025          55 :     const int nDTSize = GDALGetDataTypeSizeBytes(eDataType);
    3026          55 :     void *pTmpBuffer = nullptr;
    3027          55 :     int eErr = CE_None;
    3028          55 :     int nContigBands = nBands;
    3029          55 :     const int nSrcPixelSize = nDTSize * nContigBands;
    3030             : 
    3031          55 :     if (ppData == nullptr || panOffsets == nullptr || panSizes == nullptr)
    3032             :     {
    3033           0 :         eErr = CE_Failure;
    3034             :     }
    3035             :     // For now we always allocate a temp buffer as it is easier.
    3036             :     else
    3037             :     // if( nXSize != nBufXSize || nYSize != nBufYSize ||
    3038             :     //   eBufType != eDataType ||
    3039             :     //   nPixelSpace != GDALGetDataTypeSizeBytes(eBufType) ||
    3040             :     //   check if the user buffer is large enough )
    3041             :     {
    3042             :         // We need a temporary buffer for over-sampling/sub-sampling
    3043             :         // and/or data type conversion.
    3044          55 :         pTmpBuffer = VSI_MALLOC3_VERBOSE(nReqXSize, nReqYSize, nSrcPixelSize);
    3045          55 :         if (pTmpBuffer == nullptr)
    3046           0 :             eErr = CE_Failure;
    3047             :     }
    3048             : 
    3049             :     // Prepare data extraction.
    3050          55 :     const double dfSrcYInc = nYSize / static_cast<double>(nBufYSize);
    3051             : 
    3052        2312 :     for (int iLine = 0; eErr == CE_None && iLine < nReqYSize; ++iLine)
    3053             :     {
    3054        2257 :         ppData[iLine] = static_cast<GByte *>(pTmpBuffer) +
    3055        2257 :                         static_cast<size_t>(iLine) * nReqXSize * nSrcPixelSize;
    3056        2257 :         int nSrcLine = 0;
    3057        2257 :         if (nBufYSize < nYSize)  // Sub-sampling in y.
    3058         164 :             nSrcLine = nYOff + static_cast<int>((iLine + 0.5) * dfSrcYInc);
    3059             :         else
    3060        2093 :             nSrcLine = nYOff + iLine;
    3061             : 
    3062        2257 :         const int nBlockXOff = 0;
    3063        2257 :         const int nBlockYOff = nSrcLine / m_nBlockYSize;
    3064        2257 :         const int nYOffsetInBlock = nSrcLine % m_nBlockYSize;
    3065             :         const int nBlockId =
    3066        2257 :             poProtoBand->ComputeBlockId(nBlockXOff, nBlockYOff);
    3067             : 
    3068        2257 :         panOffsets[iLine] = panTIFFOffsets[nBlockId];
    3069        2257 :         if (panOffsets[iLine] == 0)  // We don't support sparse files.
    3070          27 :             eErr = -1;
    3071             : 
    3072        2257 :         panOffsets[iLine] +=
    3073        2257 :             (nXOff +
    3074        2257 :              static_cast<vsi_l_offset>(nYOffsetInBlock) * m_nBlockXSize) *
    3075        2257 :             nSrcPixelSize;
    3076        2257 :         panSizes[iLine] = static_cast<size_t>(nReqXSize) * nSrcPixelSize;
    3077             :     }
    3078             : 
    3079             :     // Extract data from the file.
    3080          55 :     if (eErr == CE_None)
    3081             :     {
    3082          28 :         VSILFILE *fp = VSI_TIFFGetVSILFile(TIFFClientdata(m_hTIFF));
    3083             :         const int nRet =
    3084          28 :             VSIFReadMultiRangeL(nReqYSize, ppData, panOffsets, panSizes, fp);
    3085          28 :         if (nRet != 0)
    3086           3 :             eErr = CE_Failure;
    3087             :     }
    3088             : 
    3089             :     // Byte-swap if necessary.
    3090          55 :     if (eErr == CE_None && TIFFIsByteSwapped(m_hTIFF))
    3091             :     {
    3092           0 :         for (int iLine = 0; iLine < nReqYSize; ++iLine)
    3093             :         {
    3094           0 :             if (GDALDataTypeIsComplex(eDataType))
    3095           0 :                 GDALSwapWords(ppData[iLine], nDTSize / 2,
    3096           0 :                               2 * nReqXSize * nContigBands, nDTSize / 2);
    3097             :             else
    3098           0 :                 GDALSwapWords(ppData[iLine], nDTSize, nReqXSize * nContigBands,
    3099             :                               nDTSize);
    3100             :         }
    3101             :     }
    3102             : 
    3103             :     // Over-sampling/sub-sampling and/or data type conversion.
    3104          55 :     const double dfSrcXInc = nXSize / static_cast<double>(nBufXSize);
    3105          55 :     if (eErr == CE_None && pTmpBuffer != nullptr)
    3106             :     {
    3107        7462 :         for (int iY = 0; iY < nBufYSize; ++iY)
    3108             :         {
    3109       14874 :             const int iSrcY = nBufYSize <= nYSize
    3110        7437 :                                   ? iY
    3111        5832 :                                   : static_cast<int>((iY + 0.5) * dfSrcYInc);
    3112             :             // Optimization: no resampling, no data type change, number of
    3113             :             // bands requested == number of bands and buffer is packed
    3114             :             // pixel-interleaved.
    3115        7437 :             if (nBufXSize == nXSize && nContigBands == nBandCount &&
    3116         786 :                 eDataType == eBufType && nBandSpace == nDTSize &&
    3117         474 :                 nPixelSpace == nBandCount * nBandSpace)
    3118             :             {
    3119         312 :                 memcpy(static_cast<GByte *>(pData) + iY * nLineSpace,
    3120         312 :                        ppData[iSrcY],
    3121         312 :                        static_cast<size_t>(nReqXSize * nPixelSpace));
    3122             :             }
    3123             :             // Other optimization: no resampling, no data type change,
    3124             :             // data type is Byte/Int8.
    3125        7125 :             else if (nBufXSize == nXSize && eDataType == eBufType &&
    3126           0 :                      (eDataType == GDT_Byte || eDataType == GDT_Int8))
    3127             :             {
    3128         808 :                 GByte *pabySrcData = static_cast<GByte *>(ppData[iSrcY]);
    3129         808 :                 GByte *pabyDstData =
    3130         808 :                     static_cast<GByte *>(pData) + iY * nLineSpace;
    3131         808 :                 if (nBandSpace == 1 && nPixelSpace > nBandCount)
    3132             :                 {
    3133             :                     // Buffer is pixel-interleaved (with some stridding
    3134             :                     // between pixels).
    3135         324 :                     CopyContigByteMultiBand(
    3136             :                         pabySrcData, nSrcPixelSize, pabyDstData,
    3137             :                         static_cast<int>(nPixelSpace), nBufXSize, nBandCount);
    3138             :                 }
    3139             :                 else
    3140             :                 {
    3141        2248 :                     for (int iBand = 0; iBand < nBandCount; ++iBand)
    3142             :                     {
    3143        1764 :                         GDALCopyWords(
    3144        1764 :                             pabySrcData + iBand, GDT_Byte, nSrcPixelSize,
    3145        1764 :                             pabyDstData + iBand * nBandSpace, GDT_Byte,
    3146             :                             static_cast<int>(nPixelSpace), nBufXSize);
    3147             :                     }
    3148         808 :                 }
    3149             :             }
    3150             :             else  // General case.
    3151             :             {
    3152       31585 :                 for (int iBand = 0; iBand < nBandCount; ++iBand)
    3153             :                 {
    3154       25268 :                     GByte *pabySrcData =
    3155       25268 :                         static_cast<GByte *>(ppData[iSrcY]) + iBand * nDTSize;
    3156       25268 :                     GByte *pabyDstData = static_cast<GByte *>(pData) +
    3157       25268 :                                          iBand * nBandSpace + iY * nLineSpace;
    3158       25268 :                     if ((eDataType == GDT_Byte && eBufType == GDT_Byte) ||
    3159           0 :                         (eDataType == GDT_Int8 && eBufType == GDT_Int8))
    3160             :                     {
    3161       23972 :                         double dfSrcX = 0.5 * dfSrcXInc;
    3162     1718820 :                         for (int iX = 0; iX < nBufXSize;
    3163     1694850 :                              ++iX, dfSrcX += dfSrcXInc)
    3164             :                         {
    3165     1694850 :                             int iSrcX = static_cast<int>(dfSrcX);
    3166     1694850 :                             pabyDstData[iX * nPixelSpace] =
    3167     1694850 :                                 pabySrcData[iSrcX * nSrcPixelSize];
    3168       23972 :                         }
    3169             :                     }
    3170             :                     else
    3171             :                     {
    3172        1296 :                         double dfSrcX = 0.5 * dfSrcXInc;
    3173      106272 :                         for (int iX = 0; iX < nBufXSize;
    3174      104976 :                              ++iX, dfSrcX += dfSrcXInc)
    3175             :                         {
    3176      104976 :                             int iSrcX = static_cast<int>(dfSrcX);
    3177      104976 :                             GDALCopyWords(pabySrcData + iSrcX * nSrcPixelSize,
    3178             :                                           eDataType, 0,
    3179      104976 :                                           pabyDstData + iX * nPixelSpace,
    3180             :                                           eBufType, 0, 1);
    3181             :                         }
    3182             :                     }
    3183             :                 }
    3184             :             }
    3185             :         }
    3186             :     }
    3187             : 
    3188          55 :     CPLFree(pTmpBuffer);
    3189          55 :     CPLFree(ppData);
    3190          55 :     CPLFree(panOffsets);
    3191          55 :     CPLFree(panSizes);
    3192             : 
    3193          55 :     return eErr;
    3194             : }
    3195             : 
    3196             : /************************************************************************/
    3197             : /*                             ReadStrile()                             */
    3198             : /************************************************************************/
    3199             : 
    3200     2125840 : bool GTiffDataset::ReadStrile(int nBlockId, void *pOutputBuffer,
    3201             :                               GPtrDiff_t nBlockReqSize)
    3202             : {
    3203             :     // Optimization by which we can save some libtiff buffer copy
    3204     2125840 :     std::pair<vsi_l_offset, vsi_l_offset> oPair;
    3205     2125830 :     if (
    3206             : #if TIFFLIB_VERSION <= 20220520 && !defined(INTERNAL_LIBTIFF)
    3207             :         // There's a bug, up to libtiff 4.4.0, in TIFFReadFromUserBuffer()
    3208             :         // which clears the TIFF_CODERSETUP flag of tif->tif_flags, which
    3209             :         // causes the codec SetupDecode method to be called for each strile,
    3210             :         // whereas it should normally be called only for the first decoded one.
    3211             :         // For JPEG, that causes TIFFjpeg_read_header() to be called. Most
    3212             :         // of the time, that works. But for some files, at some point, the
    3213             :         // libjpeg machinery is not in the appropriate state for that.
    3214             :         m_nCompression != COMPRESSION_JPEG &&
    3215             : #endif
    3216     2125840 :         m_oCacheStrileToOffsetByteCount.tryGet(nBlockId, oPair))
    3217             :     {
    3218             :         // For the mask, use the parent TIFF handle to get cached ranges
    3219         333 :         auto th = TIFFClientdata(m_poImageryDS && m_bMaskInterleavedWithImagery
    3220          93 :                                      ? m_poImageryDS->m_hTIFF
    3221             :                                      : m_hTIFF);
    3222         480 :         void *pInputBuffer = VSI_TIFFGetCachedRange(
    3223         240 :             th, oPair.first, static_cast<size_t>(oPair.second));
    3224         480 :         if (pInputBuffer &&
    3225         240 :             TIFFReadFromUserBuffer(m_hTIFF, nBlockId, pInputBuffer,
    3226         240 :                                    static_cast<size_t>(oPair.second),
    3227             :                                    pOutputBuffer, nBlockReqSize))
    3228             :         {
    3229         240 :             return true;
    3230             :         }
    3231             :     }
    3232             : 
    3233             :     // For debugging
    3234     2125590 :     if (m_poBaseDS)
    3235        3484 :         m_poBaseDS->m_bHasUsedReadEncodedAPI = true;
    3236             :     else
    3237     2122100 :         m_bHasUsedReadEncodedAPI = true;
    3238             : 
    3239             : #if 0
    3240             :     // Can be useful to test TIFFReadFromUserBuffer() for local files
    3241             :     VSILFILE* fpTIF = VSI_TIFFGetVSILFile(TIFFClientdata( m_hTIFF ));
    3242             :     std::vector<GByte> tmp(TIFFGetStrileByteCount(m_hTIFF, nBlockId));
    3243             :     VSIFSeekL(fpTIF, TIFFGetStrileOffset(m_hTIFF, nBlockId), SEEK_SET);
    3244             :     VSIFReadL(&tmp[0], 1, TIFFGetStrileByteCount(m_hTIFF, nBlockId), fpTIF);
    3245             :     if( !TIFFReadFromUserBuffer( m_hTIFF, nBlockId,
    3246             :                                 &tmp[0], tmp.size(),
    3247             :                                 pOutputBuffer, nBlockReqSize ) )
    3248             :     {
    3249             :         return false;
    3250             :     }
    3251             : #else
    3252             :     // Set to 1 to allow GTiffErrorHandler to implement limitation on error
    3253             :     // messages
    3254     2125590 :     GTIFFGetThreadLocalLibtiffError() = 1;
    3255     2125590 :     if (TIFFIsTiled(m_hTIFF))
    3256             :     {
    3257       30119 :         if (TIFFReadEncodedTile(m_hTIFF, nBlockId, pOutputBuffer,
    3258       30149 :                                 nBlockReqSize) == -1 &&
    3259          30 :             !m_bIgnoreReadErrors)
    3260             :         {
    3261          30 :             CPLError(CE_Failure, CPLE_AppDefined,
    3262             :                      "TIFFReadEncodedTile() failed.");
    3263          30 :             GTIFFGetThreadLocalLibtiffError() = 0;
    3264          30 :             return false;
    3265             :         }
    3266             :     }
    3267             :     else
    3268             :     {
    3269     2095460 :         if (TIFFReadEncodedStrip(m_hTIFF, nBlockId, pOutputBuffer,
    3270     2095550 :                                  nBlockReqSize) == -1 &&
    3271          77 :             !m_bIgnoreReadErrors)
    3272             :         {
    3273          76 :             CPLError(CE_Failure, CPLE_AppDefined,
    3274             :                      "TIFFReadEncodedStrip() failed.");
    3275          76 :             GTIFFGetThreadLocalLibtiffError() = 0;
    3276          76 :             return false;
    3277             :         }
    3278             :     }
    3279     2125490 :     GTIFFGetThreadLocalLibtiffError() = 0;
    3280             : #endif
    3281     2125500 :     return true;
    3282             : }
    3283             : 
    3284             : /************************************************************************/
    3285             : /*                            LoadBlockBuf()                            */
    3286             : /*                                                                      */
    3287             : /*      Load working block buffer with request block (tile/strip).      */
    3288             : /************************************************************************/
    3289             : 
    3290      231107 : CPLErr GTiffDataset::LoadBlockBuf(int nBlockId, bool bReadFromDisk)
    3291             : 
    3292             : {
    3293      231107 :     if (m_nLoadedBlock == nBlockId && m_pabyBlockBuf != nullptr)
    3294      140286 :         return CE_None;
    3295             : 
    3296             :     /* -------------------------------------------------------------------- */
    3297             :     /*      If we have a dirty loaded block, flush it out first.            */
    3298             :     /* -------------------------------------------------------------------- */
    3299       90821 :     if (m_nLoadedBlock != -1 && m_bLoadedBlockDirty)
    3300             :     {
    3301        4577 :         const CPLErr eErr = FlushBlockBuf();
    3302        4577 :         if (eErr != CE_None)
    3303           0 :             return eErr;
    3304             :     }
    3305             : 
    3306             :     /* -------------------------------------------------------------------- */
    3307             :     /*      Get block size.                                                 */
    3308             :     /* -------------------------------------------------------------------- */
    3309       90821 :     const GPtrDiff_t nBlockBufSize = static_cast<GPtrDiff_t>(
    3310       90821 :         TIFFIsTiled(m_hTIFF) ? TIFFTileSize(m_hTIFF) : TIFFStripSize(m_hTIFF));
    3311       90821 :     if (!nBlockBufSize)
    3312             :     {
    3313           0 :         ReportError(CE_Failure, CPLE_AppDefined,
    3314             :                     "Bogus block size; unable to allocate a buffer.");
    3315           0 :         return CE_Failure;
    3316             :     }
    3317             : 
    3318             :     /* -------------------------------------------------------------------- */
    3319             :     /*      Allocate a temporary buffer for this strip.                     */
    3320             :     /* -------------------------------------------------------------------- */
    3321       90821 :     if (m_pabyBlockBuf == nullptr)
    3322             :     {
    3323        7168 :         m_pabyBlockBuf =
    3324        7168 :             static_cast<GByte *>(VSI_CALLOC_VERBOSE(1, nBlockBufSize));
    3325        7168 :         if (m_pabyBlockBuf == nullptr)
    3326             :         {
    3327           1 :             return CE_Failure;
    3328             :         }
    3329             :     }
    3330             : 
    3331       90820 :     if (m_nLoadedBlock == nBlockId)
    3332        4799 :         return CE_None;
    3333             : 
    3334             :     /* -------------------------------------------------------------------- */
    3335             :     /*  When called from ::IWriteBlock in separate cases (or in single band */
    3336             :     /*  geotiffs), the ::IWriteBlock will override the content of the buffer*/
    3337             :     /*  with pImage, so we don't need to read data from disk                */
    3338             :     /* -------------------------------------------------------------------- */
    3339       86021 :     if (!bReadFromDisk || m_bStreamingOut)
    3340             :     {
    3341       35253 :         m_nLoadedBlock = nBlockId;
    3342       35253 :         return CE_None;
    3343             :     }
    3344             : 
    3345             :     // libtiff 3.X doesn't like mixing read&write of JPEG compressed blocks
    3346             :     // The below hack is necessary due to another hack that consist in
    3347             :     // writing zero block to force creation of JPEG tables.
    3348       50768 :     if (nBlockId == 0 && m_bDontReloadFirstBlock)
    3349             :     {
    3350           0 :         m_bDontReloadFirstBlock = false;
    3351           0 :         memset(m_pabyBlockBuf, 0, nBlockBufSize);
    3352           0 :         m_nLoadedBlock = nBlockId;
    3353           0 :         return CE_None;
    3354             :     }
    3355             : 
    3356             :     /* -------------------------------------------------------------------- */
    3357             :     /*      The bottom most partial tiles and strips are sometimes only     */
    3358             :     /*      partially encoded.  This code reduces the requested data so     */
    3359             :     /*      an error won't be reported in this case. (#1179)                */
    3360             :     /*      We exclude tiled WEBP, because as it is a new codec, whole tiles*/
    3361             :     /*      are written by libtiff. This helps avoiding creating a temporary*/
    3362             :     /*      decode buffer.                                                  */
    3363             :     /* -------------------------------------------------------------------- */
    3364       50768 :     auto nBlockReqSize = nBlockBufSize;
    3365       50768 :     const int nBlockYOff = (nBlockId % m_nBlocksPerBand) / m_nBlocksPerRow;
    3366             : 
    3367       52076 :     if (nBlockYOff * m_nBlockYSize > nRasterYSize - m_nBlockYSize &&
    3368        1308 :         !(m_nCompression == COMPRESSION_WEBP && TIFFIsTiled(m_hTIFF)))
    3369             :     {
    3370        1305 :         nBlockReqSize =
    3371        1305 :             (nBlockBufSize / m_nBlockYSize) *
    3372        1305 :             (m_nBlockYSize -
    3373             :              static_cast<int>(
    3374        1305 :                  (static_cast<GIntBig>(nBlockYOff + 1) * m_nBlockYSize) %
    3375        1305 :                  nRasterYSize));
    3376        1305 :         memset(m_pabyBlockBuf, 0, nBlockBufSize);
    3377             :     }
    3378             : 
    3379             :     /* -------------------------------------------------------------------- */
    3380             :     /*      If we don't have this block already loaded, and we know it      */
    3381             :     /*      doesn't yet exist on disk, just zero the memory buffer and      */
    3382             :     /*      pretend we loaded it.                                           */
    3383             :     /* -------------------------------------------------------------------- */
    3384       50768 :     bool bErrOccurred = false;
    3385       50768 :     if (!IsBlockAvailable(nBlockId, nullptr, nullptr, &bErrOccurred))
    3386             :     {
    3387         796 :         memset(m_pabyBlockBuf, 0, nBlockBufSize);
    3388         796 :         m_nLoadedBlock = nBlockId;
    3389         796 :         if (bErrOccurred)
    3390           0 :             return CE_Failure;
    3391         796 :         return CE_None;
    3392             :     }
    3393             : 
    3394             :     /* -------------------------------------------------------------------- */
    3395             :     /*      Load the block, if it isn't our current block.                  */
    3396             :     /* -------------------------------------------------------------------- */
    3397       49972 :     CPLErr eErr = CE_None;
    3398             : 
    3399       49972 :     if (!ReadStrile(nBlockId, m_pabyBlockBuf, nBlockReqSize))
    3400             :     {
    3401          25 :         memset(m_pabyBlockBuf, 0, nBlockBufSize);
    3402          25 :         eErr = CE_Failure;
    3403             :     }
    3404             : 
    3405       49972 :     if (eErr == CE_None)
    3406             :     {
    3407       50757 :         if (m_nCompression == COMPRESSION_WEBP && TIFFIsTiled(m_hTIFF) &&
    3408         810 :             nBlockYOff * m_nBlockYSize > nRasterYSize - m_nBlockYSize)
    3409             :         {
    3410           3 :             const auto nValidBytes =
    3411           3 :                 (nBlockBufSize / m_nBlockYSize) *
    3412           3 :                 (m_nBlockYSize -
    3413             :                  static_cast<int>(
    3414           3 :                      (static_cast<GIntBig>(nBlockYOff + 1) * m_nBlockYSize) %
    3415           3 :                      nRasterYSize));
    3416             :             // Zero-out unused area
    3417           3 :             memset(m_pabyBlockBuf + nValidBytes, 0,
    3418           3 :                    nBlockBufSize - nValidBytes);
    3419             :         }
    3420             : 
    3421       49947 :         m_nLoadedBlock = nBlockId;
    3422             :     }
    3423             :     else
    3424             :     {
    3425          25 :         m_nLoadedBlock = -1;
    3426             :     }
    3427       49972 :     m_bLoadedBlockDirty = false;
    3428             : 
    3429       49972 :     return eErr;
    3430             : }
    3431             : 
    3432             : /************************************************************************/
    3433             : /*                              Identify()                              */
    3434             : /************************************************************************/
    3435             : 
    3436      118109 : int GTiffDataset::Identify(GDALOpenInfo *poOpenInfo)
    3437             : 
    3438             : {
    3439      118109 :     const char *pszFilename = poOpenInfo->pszFilename;
    3440      118109 :     if (STARTS_WITH_CI(pszFilename, "GTIFF_RAW:"))
    3441             :     {
    3442          20 :         pszFilename += strlen("GTIFF_RAW:");
    3443          40 :         GDALOpenInfo oOpenInfo(pszFilename, poOpenInfo->eAccess);
    3444          20 :         return Identify(&oOpenInfo);
    3445             :     }
    3446             : 
    3447             :     /* -------------------------------------------------------------------- */
    3448             :     /*      We have a special hook for handling opening a specific          */
    3449             :     /*      directory of a TIFF file.                                       */
    3450             :     /* -------------------------------------------------------------------- */
    3451      118089 :     if (STARTS_WITH_CI(pszFilename, "GTIFF_DIR:"))
    3452          50 :         return TRUE;
    3453             : 
    3454             :     /* -------------------------------------------------------------------- */
    3455             :     /*      First we check to see if the file has the expected header       */
    3456             :     /*      bytes.                                                          */
    3457             :     /* -------------------------------------------------------------------- */
    3458      118039 :     if (poOpenInfo->fpL == nullptr || poOpenInfo->nHeaderBytes < 2)
    3459       60485 :         return FALSE;
    3460             : 
    3461       57554 :     if ((poOpenInfo->pabyHeader[0] != 'I' ||
    3462       47386 :          poOpenInfo->pabyHeader[1] != 'I') &&
    3463       10188 :         (poOpenInfo->pabyHeader[0] != 'M' || poOpenInfo->pabyHeader[1] != 'M'))
    3464        9921 :         return FALSE;
    3465             : 
    3466       47633 :     if ((poOpenInfo->pabyHeader[2] != 0x2A || poOpenInfo->pabyHeader[3] != 0) &&
    3467         546 :         (poOpenInfo->pabyHeader[3] != 0x2A || poOpenInfo->pabyHeader[2] != 0) &&
    3468         300 :         (poOpenInfo->pabyHeader[2] != 0x2B || poOpenInfo->pabyHeader[3] != 0) &&
    3469          20 :         (poOpenInfo->pabyHeader[3] != 0x2B || poOpenInfo->pabyHeader[2] != 0))
    3470           0 :         return FALSE;
    3471             : 
    3472       47633 :     return TRUE;
    3473             : }
    3474             : 
    3475             : /************************************************************************/
    3476             : /*                          GTIFFExtendMemoryFile()                     */
    3477             : /************************************************************************/
    3478             : 
    3479          14 : static bool GTIFFExtendMemoryFile(const CPLString &osTmpFilename,
    3480             :                                   VSILFILE *fpTemp, VSILFILE *fpL,
    3481             :                                   int nNewLength, GByte *&pabyBuffer,
    3482             :                                   vsi_l_offset &nDataLength)
    3483             : {
    3484          14 :     if (nNewLength <= static_cast<int>(nDataLength))
    3485          10 :         return true;
    3486           4 :     if (VSIFSeekL(fpTemp, nNewLength - 1, SEEK_SET) != 0)
    3487           0 :         return false;
    3488           4 :     char ch = 0;
    3489           4 :     if (VSIFWriteL(&ch, 1, 1, fpTemp) != 1)
    3490           0 :         return false;
    3491           4 :     const int nOldDataLength = static_cast<int>(nDataLength);
    3492           4 :     pabyBuffer = static_cast<GByte *>(
    3493           4 :         VSIGetMemFileBuffer(osTmpFilename, &nDataLength, FALSE));
    3494           4 :     const int nToRead = nNewLength - nOldDataLength;
    3495             :     const int nRead = static_cast<int>(
    3496           4 :         VSIFReadL(pabyBuffer + nOldDataLength, 1, nToRead, fpL));
    3497           4 :     if (nRead != nToRead)
    3498             :     {
    3499           0 :         CPLError(CE_Failure, CPLE_FileIO,
    3500             :                  "Needed to read %d bytes. Only %d got", nToRead, nRead);
    3501           0 :         return false;
    3502             :     }
    3503           4 :     return true;
    3504             : }
    3505             : 
    3506             : /************************************************************************/
    3507             : /*                         GTIFFMakeBufferedStream()                    */
    3508             : /************************************************************************/
    3509             : 
    3510           9 : static bool GTIFFMakeBufferedStream(GDALOpenInfo *poOpenInfo)
    3511             : {
    3512             :     const CPLString osTmpFilename(
    3513          18 :         VSIMemGenerateHiddenFilename("GTIFFMakeBufferedStream.tif"));
    3514           9 :     VSILFILE *fpTemp = VSIFOpenL(osTmpFilename, "wb+");
    3515           9 :     if (fpTemp == nullptr)
    3516           0 :         return false;
    3517             :     // The seek is needed for /vsistdin/ that has some rewind capabilities.
    3518           9 :     if (VSIFSeekL(poOpenInfo->fpL, poOpenInfo->nHeaderBytes, SEEK_SET) != 0)
    3519             :     {
    3520           0 :         CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3521           0 :         return false;
    3522             :     }
    3523           9 :     CPLAssert(static_cast<int>(VSIFTellL(poOpenInfo->fpL)) ==
    3524             :               poOpenInfo->nHeaderBytes);
    3525           9 :     if (VSIFWriteL(poOpenInfo->pabyHeader, poOpenInfo->nHeaderBytes, 1,
    3526           9 :                    fpTemp) != 1)
    3527             :     {
    3528           0 :         CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3529           0 :         return false;
    3530             :     }
    3531           9 :     vsi_l_offset nDataLength = 0;
    3532             :     GByte *pabyBuffer = static_cast<GByte *>(
    3533           9 :         VSIGetMemFileBuffer(osTmpFilename, &nDataLength, FALSE));
    3534           9 :     const bool bLittleEndian = (pabyBuffer[0] == 'I');
    3535             : #if CPL_IS_LSB
    3536           9 :     const bool bSwap = !bLittleEndian;
    3537             : #else
    3538             :     const bool bSwap = bLittleEndian;
    3539             : #endif
    3540           9 :     const bool bBigTIFF = pabyBuffer[2] == 43 || pabyBuffer[3] == 43;
    3541           9 :     vsi_l_offset nMaxOffset = 0;
    3542           9 :     if (bBigTIFF)
    3543             :     {
    3544           2 :         GUInt64 nTmp = 0;
    3545           2 :         memcpy(&nTmp, pabyBuffer + 8, 8);
    3546           2 :         if (bSwap)
    3547           0 :             CPL_SWAP64PTR(&nTmp);
    3548           2 :         if (nTmp != 16)
    3549             :         {
    3550           1 :             CPLError(CE_Failure, CPLE_NotSupported,
    3551             :                      "IFD start should be at offset 16 for a streamed BigTIFF");
    3552           1 :             CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3553           1 :             VSIUnlink(osTmpFilename);
    3554           1 :             return false;
    3555             :         }
    3556           1 :         memcpy(&nTmp, pabyBuffer + 16, 8);
    3557           1 :         if (bSwap)
    3558           0 :             CPL_SWAP64PTR(&nTmp);
    3559           1 :         if (nTmp > 1024)
    3560             :         {
    3561           0 :             CPLError(CE_Failure, CPLE_NotSupported,
    3562             :                      "Too many tags : " CPL_FRMT_GIB, nTmp);
    3563           0 :             CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3564           0 :             VSIUnlink(osTmpFilename);
    3565           0 :             return false;
    3566             :         }
    3567           1 :         const int nTags = static_cast<int>(nTmp);
    3568           1 :         const int nSpaceForTags = nTags * 20;
    3569           1 :         if (!GTIFFExtendMemoryFile(osTmpFilename, fpTemp, poOpenInfo->fpL,
    3570             :                                    24 + nSpaceForTags, pabyBuffer, nDataLength))
    3571             :         {
    3572           0 :             CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3573           0 :             VSIUnlink(osTmpFilename);
    3574           0 :             return false;
    3575             :         }
    3576           1 :         nMaxOffset = 24 + nSpaceForTags + 8;
    3577          18 :         for (int i = 0; i < nTags; ++i)
    3578             :         {
    3579          17 :             GUInt16 nTmp16 = 0;
    3580          17 :             memcpy(&nTmp16, pabyBuffer + 24 + i * 20, 2);
    3581          17 :             if (bSwap)
    3582           0 :                 CPL_SWAP16PTR(&nTmp16);
    3583          17 :             const int nTag = nTmp16;
    3584          17 :             memcpy(&nTmp16, pabyBuffer + 24 + i * 20 + 2, 2);
    3585          17 :             if (bSwap)
    3586           0 :                 CPL_SWAP16PTR(&nTmp16);
    3587          17 :             const int nDataType = nTmp16;
    3588          17 :             memcpy(&nTmp, pabyBuffer + 24 + i * 20 + 4, 8);
    3589          17 :             if (bSwap)
    3590           0 :                 CPL_SWAP64PTR(&nTmp);
    3591          17 :             if (nTmp >= 16 * 1024 * 1024)
    3592             :             {
    3593           0 :                 CPLError(CE_Failure, CPLE_NotSupported,
    3594             :                          "Too many elements for tag %d : " CPL_FRMT_GUIB, nTag,
    3595             :                          nTmp);
    3596           0 :                 CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3597           0 :                 VSIUnlink(osTmpFilename);
    3598           0 :                 return false;
    3599             :             }
    3600          17 :             const GUInt32 nCount = static_cast<GUInt32>(nTmp);
    3601             :             const GUInt32 nTagSize =
    3602          17 :                 TIFFDataWidth(static_cast<TIFFDataType>(nDataType)) * nCount;
    3603          17 :             if (nTagSize > 8)
    3604             :             {
    3605           7 :                 memcpy(&nTmp, pabyBuffer + 24 + i * 20 + 12, 8);
    3606           7 :                 if (bSwap)
    3607           0 :                     CPL_SWAP64PTR(&nTmp);
    3608           7 :                 if (nTmp > GUINT64_MAX - nTagSize)
    3609             :                 {
    3610           0 :                     CPLError(CE_Failure, CPLE_NotSupported,
    3611             :                              "Overflow with tag %d", nTag);
    3612           0 :                     CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3613           0 :                     VSIUnlink(osTmpFilename);
    3614           0 :                     return false;
    3615             :                 }
    3616           7 :                 if (static_cast<vsi_l_offset>(nTmp + nTagSize) > nMaxOffset)
    3617           6 :                     nMaxOffset = nTmp + nTagSize;
    3618             :             }
    3619             :         }
    3620             :     }
    3621             :     else
    3622             :     {
    3623           7 :         GUInt32 nTmp = 0;
    3624           7 :         memcpy(&nTmp, pabyBuffer + 4, 4);
    3625           7 :         if (bSwap)
    3626           0 :             CPL_SWAP32PTR(&nTmp);
    3627           7 :         if (nTmp != 8)
    3628             :         {
    3629           1 :             CPLError(CE_Failure, CPLE_NotSupported,
    3630             :                      "IFD start should be at offset 8 for a streamed TIFF");
    3631           1 :             CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3632           1 :             VSIUnlink(osTmpFilename);
    3633           1 :             return false;
    3634             :         }
    3635           6 :         GUInt16 nTmp16 = 0;
    3636           6 :         memcpy(&nTmp16, pabyBuffer + 8, 2);
    3637           6 :         if (bSwap)
    3638           0 :             CPL_SWAP16PTR(&nTmp16);
    3639           6 :         if (nTmp16 > 1024)
    3640             :         {
    3641           0 :             CPLError(CE_Failure, CPLE_NotSupported, "Too many tags : %d",
    3642             :                      nTmp16);
    3643           0 :             CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3644           0 :             VSIUnlink(osTmpFilename);
    3645           0 :             return false;
    3646             :         }
    3647           6 :         const int nTags = nTmp16;
    3648           6 :         const int nSpaceForTags = nTags * 12;
    3649           6 :         if (!GTIFFExtendMemoryFile(osTmpFilename, fpTemp, poOpenInfo->fpL,
    3650             :                                    10 + nSpaceForTags, pabyBuffer, nDataLength))
    3651             :         {
    3652           0 :             CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3653           0 :             VSIUnlink(osTmpFilename);
    3654           0 :             return false;
    3655             :         }
    3656           6 :         nMaxOffset = 10 + nSpaceForTags + 4;
    3657          95 :         for (int i = 0; i < nTags; ++i)
    3658             :         {
    3659          89 :             memcpy(&nTmp16, pabyBuffer + 10 + i * 12, 2);
    3660          89 :             if (bSwap)
    3661           0 :                 CPL_SWAP16PTR(&nTmp16);
    3662          89 :             const int nTag = nTmp16;
    3663          89 :             memcpy(&nTmp16, pabyBuffer + 10 + i * 12 + 2, 2);
    3664          89 :             if (bSwap)
    3665           0 :                 CPL_SWAP16PTR(&nTmp16);
    3666          89 :             const int nDataType = nTmp16;
    3667          89 :             memcpy(&nTmp, pabyBuffer + 10 + i * 12 + 4, 4);
    3668          89 :             if (bSwap)
    3669           0 :                 CPL_SWAP32PTR(&nTmp);
    3670          89 :             if (nTmp >= 16 * 1024 * 1024)
    3671             :             {
    3672           0 :                 CPLError(CE_Failure, CPLE_NotSupported,
    3673             :                          "Too many elements for tag %d : %u", nTag, nTmp);
    3674           0 :                 CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3675           0 :                 VSIUnlink(osTmpFilename);
    3676           0 :                 return false;
    3677             :             }
    3678          89 :             const GUInt32 nCount = nTmp;
    3679             :             const GUInt32 nTagSize =
    3680          89 :                 TIFFDataWidth(static_cast<TIFFDataType>(nDataType)) * nCount;
    3681          89 :             if (nTagSize > 4)
    3682             :             {
    3683          37 :                 memcpy(&nTmp, pabyBuffer + 10 + i * 12 + 8, 4);
    3684          37 :                 if (bSwap)
    3685           0 :                     CPL_SWAP32PTR(&nTmp);
    3686          37 :                 if (nTmp > static_cast<GUInt32>(UINT_MAX - nTagSize))
    3687             :                 {
    3688           0 :                     CPLError(CE_Failure, CPLE_NotSupported,
    3689             :                              "Overflow with tag %d", nTag);
    3690           0 :                     CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3691           0 :                     VSIUnlink(osTmpFilename);
    3692           0 :                     return false;
    3693             :                 }
    3694          37 :                 if (nTmp + nTagSize > nMaxOffset)
    3695          32 :                     nMaxOffset = nTmp + nTagSize;
    3696             :             }
    3697             :         }
    3698             :     }
    3699           7 :     if (nMaxOffset > 10 * 1024 * 1024)
    3700             :     {
    3701           0 :         CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3702           0 :         VSIUnlink(osTmpFilename);
    3703           0 :         return false;
    3704             :     }
    3705           7 :     if (!GTIFFExtendMemoryFile(osTmpFilename, fpTemp, poOpenInfo->fpL,
    3706             :                                static_cast<int>(nMaxOffset), pabyBuffer,
    3707             :                                nDataLength))
    3708             :     {
    3709           0 :         CPL_IGNORE_RET_VAL(VSIFCloseL(fpTemp));
    3710           0 :         VSIUnlink(osTmpFilename);
    3711           0 :         return false;
    3712             :     }
    3713           7 :     CPLAssert(nDataLength == VSIFTellL(poOpenInfo->fpL));
    3714           7 :     poOpenInfo->fpL = VSICreateBufferedReaderHandle(
    3715             :         poOpenInfo->fpL, pabyBuffer, static_cast<vsi_l_offset>(INT_MAX) << 32);
    3716           7 :     if (VSIFCloseL(fpTemp) != 0)
    3717           0 :         return false;
    3718           7 :     VSIUnlink(osTmpFilename);
    3719             : 
    3720           7 :     return true;
    3721             : }
    3722             : 
    3723             : /************************************************************************/
    3724             : /*                       AssociateExternalMask()                        */
    3725             : /************************************************************************/
    3726             : 
    3727             : // Used by GTIFFBuildOverviewsEx() for the COG driver
    3728           5 : bool GTiffDataset::AssociateExternalMask()
    3729             : {
    3730           5 :     if (m_poMaskExtOvrDS->GetRasterBand(1)->GetOverviewCount() !=
    3731           5 :         GetRasterBand(1)->GetOverviewCount())
    3732           0 :         return false;
    3733           5 :     if (m_papoOverviewDS == nullptr)
    3734           0 :         return false;
    3735           5 :     if (m_poMaskDS)
    3736           0 :         return false;
    3737          10 :     if (m_poMaskExtOvrDS->GetRasterXSize() != nRasterXSize ||
    3738           5 :         m_poMaskExtOvrDS->GetRasterYSize() != nRasterYSize)
    3739           0 :         return false;
    3740           5 :     m_poExternalMaskDS = m_poMaskExtOvrDS.get();
    3741          13 :     for (int i = 0; i < m_nOverviewCount; i++)
    3742             :     {
    3743           8 :         if (m_papoOverviewDS[i]->m_poMaskDS)
    3744           0 :             return false;
    3745          16 :         m_papoOverviewDS[i]->m_poExternalMaskDS =
    3746           8 :             m_poMaskExtOvrDS->GetRasterBand(1)->GetOverview(i)->GetDataset();
    3747           8 :         if (!m_papoOverviewDS[i]->m_poExternalMaskDS)
    3748           0 :             return false;
    3749           8 :         auto poOvrBand = m_papoOverviewDS[i]->GetRasterBand(1);
    3750           8 :         if (m_papoOverviewDS[i]->m_poExternalMaskDS->GetRasterXSize() !=
    3751          16 :                 poOvrBand->GetXSize() ||
    3752           8 :             m_papoOverviewDS[i]->m_poExternalMaskDS->GetRasterYSize() !=
    3753           8 :                 poOvrBand->GetYSize())
    3754           0 :             return false;
    3755             :     }
    3756           5 :     return true;
    3757             : }
    3758             : 
    3759             : /************************************************************************/
    3760             : /*                                Open()                                */
    3761             : /************************************************************************/
    3762             : 
    3763       23591 : GDALDataset *GTiffDataset::Open(GDALOpenInfo *poOpenInfo)
    3764             : 
    3765             : {
    3766       23591 :     const char *pszFilename = poOpenInfo->pszFilename;
    3767             : 
    3768             :     /* -------------------------------------------------------------------- */
    3769             :     /*      Check if it looks like a TIFF file.                             */
    3770             :     /* -------------------------------------------------------------------- */
    3771       23591 :     if (!Identify(poOpenInfo))
    3772           0 :         return nullptr;
    3773             : 
    3774       23559 :     bool bAllowRGBAInterface = true;
    3775       23559 :     if (STARTS_WITH_CI(pszFilename, "GTIFF_RAW:"))
    3776             :     {
    3777          10 :         bAllowRGBAInterface = false;
    3778          10 :         pszFilename += strlen("GTIFF_RAW:");
    3779             :     }
    3780             : 
    3781             :     /* -------------------------------------------------------------------- */
    3782             :     /*      We have a special hook for handling opening a specific          */
    3783             :     /*      directory of a TIFF file.                                       */
    3784             :     /* -------------------------------------------------------------------- */
    3785       23559 :     if (STARTS_WITH_CI(pszFilename, "GTIFF_DIR:"))
    3786          25 :         return OpenDir(poOpenInfo);
    3787             : 
    3788       23534 :     GTiffOneTimeInit();
    3789             : 
    3790             :     /* -------------------------------------------------------------------- */
    3791             :     /*      Try opening the dataset.                                        */
    3792             :     /* -------------------------------------------------------------------- */
    3793       23574 :     bool bStreaming = false;
    3794             :     const char *pszReadStreaming =
    3795       23574 :         CPLGetConfigOption("TIFF_READ_STREAMING", nullptr);
    3796       23574 :     if (poOpenInfo->fpL == nullptr)
    3797             :     {
    3798           9 :         poOpenInfo->fpL = VSIFOpenL(
    3799           9 :             pszFilename, poOpenInfo->eAccess == GA_ReadOnly ? "rb" : "r+b");
    3800           9 :         if (poOpenInfo->fpL == nullptr)
    3801           0 :             return nullptr;
    3802             :     }
    3803           7 :     else if (!(pszReadStreaming && !CPLTestBool(pszReadStreaming)) &&
    3804       47132 :              poOpenInfo->nHeaderBytes >= 24 &&
    3805             :              // A pipe has no seeking capability, so its position is 0 despite
    3806             :              // having read bytes.
    3807       23564 :              (static_cast<int>(VSIFTellL(poOpenInfo->fpL)) ==
    3808       23560 :                   poOpenInfo->nHeaderBytes ||
    3809       23559 :               strcmp(pszFilename, "/vsistdin/") == 0 ||
    3810             :               // STARTS_WITH(pszFilename, "/vsicurl_streaming/") ||
    3811           7 :               (pszReadStreaming && CPLTestBool(pszReadStreaming))))
    3812             :     {
    3813           9 :         bStreaming = true;
    3814           9 :         if (!GTIFFMakeBufferedStream(poOpenInfo))
    3815           2 :             return nullptr;
    3816             :     }
    3817             : 
    3818             :     // Store errors/warnings and emit them later.
    3819             :     TIFF *l_hTIFF;
    3820       47140 :     CPLErrorAccumulator oErrorAccumulator;
    3821             :     {
    3822       23472 :         auto oAccumulator = oErrorAccumulator.InstallForCurrentScope();
    3823       23546 :         CPL_IGNORE_RET_VAL(oAccumulator);
    3824       23472 :         CPLSetCurrentErrorHandlerCatchDebug(FALSE);
    3825       23459 :         const bool bDeferStrileLoading = CPLTestBool(
    3826             :             CPLGetConfigOption("GTIFF_USE_DEFER_STRILE_LOADING", "YES"));
    3827       23572 :         l_hTIFF = VSI_TIFFOpen(
    3828             :             pszFilename,
    3829       23572 :             poOpenInfo->eAccess == GA_ReadOnly
    3830       22784 :                 ? ((bStreaming || !bDeferStrileLoading) ? "rC" : "rDOC")
    3831         788 :                 : (!bDeferStrileLoading ? "r+C" : "r+DC"),
    3832             :             poOpenInfo->fpL);
    3833             :     };
    3834             : 
    3835             :     // Now emit errors and change their criticality if needed
    3836             :     // We only emit failures if we didn't manage to open the file.
    3837             :     // Otherwise it makes Python bindings unhappy (#5616).
    3838       23546 :     for (const auto &oError : oErrorAccumulator.GetErrors())
    3839             :     {
    3840          78 :         ReportError(pszFilename,
    3841           1 :                     (l_hTIFF == nullptr && oError.type == CE_Failure)
    3842             :                         ? CE_Failure
    3843             :                         : CE_Warning,
    3844          39 :                     oError.no, "%s", oError.msg.c_str());
    3845             :     }
    3846             : 
    3847       23377 :     if (l_hTIFF == nullptr)
    3848           2 :         return nullptr;
    3849             : 
    3850       23375 :     uint32_t nXSize = 0;
    3851       23375 :     TIFFGetField(l_hTIFF, TIFFTAG_IMAGEWIDTH, &nXSize);
    3852       23525 :     uint32_t nYSize = 0;
    3853       23525 :     TIFFGetField(l_hTIFF, TIFFTAG_IMAGELENGTH, &nYSize);
    3854             : 
    3855       23496 :     if (nXSize > INT_MAX || nYSize > INT_MAX)
    3856             :     {
    3857             :         // GDAL only supports signed 32bit dimensions.
    3858          64 :         ReportError(pszFilename, CE_Failure, CPLE_NotSupported,
    3859             :                     "Too large image size: %u x %u", nXSize, nYSize);
    3860           1 :         XTIFFClose(l_hTIFF);
    3861           1 :         return nullptr;
    3862             :     }
    3863             : 
    3864       23432 :     uint16_t l_nCompression = 0;
    3865       23432 :     if (!TIFFGetField(l_hTIFF, TIFFTAG_COMPRESSION, &(l_nCompression)))
    3866           0 :         l_nCompression = COMPRESSION_NONE;
    3867             : 
    3868             :     /* -------------------------------------------------------------------- */
    3869             :     /*      Create a corresponding GDALDataset.                             */
    3870             :     /* -------------------------------------------------------------------- */
    3871       23497 :     GTiffDataset *poDS = new GTiffDataset();
    3872       23486 :     poDS->SetDescription(pszFilename);
    3873       23419 :     poDS->m_osFilename = pszFilename;
    3874       23382 :     poDS->m_fpL = poOpenInfo->fpL;
    3875       23382 :     poOpenInfo->fpL = nullptr;
    3876       23382 :     poDS->m_bStreamingIn = bStreaming;
    3877       23382 :     poDS->m_nCompression = l_nCompression;
    3878             : 
    3879             :     // Check structural metadata (for COG)
    3880       23382 :     const int nOffsetOfStructuralMetadata =
    3881       23483 :         poOpenInfo->nHeaderBytes && ((poOpenInfo->pabyHeader[2] == 0x2B ||
    3882       23345 :                                       poOpenInfo->pabyHeader[3] == 0x2B))
    3883       46865 :             ? 16
    3884             :             : 8;
    3885       23382 :     if (poOpenInfo->nHeaderBytes >
    3886       23382 :             nOffsetOfStructuralMetadata +
    3887       23445 :                 static_cast<int>(strlen("GDAL_STRUCTURAL_METADATA_SIZE=")) &&
    3888       23445 :         memcmp(poOpenInfo->pabyHeader + nOffsetOfStructuralMetadata,
    3889             :                "GDAL_STRUCTURAL_METADATA_SIZE=",
    3890             :                strlen("GDAL_STRUCTURAL_METADATA_SIZE=")) == 0)
    3891             :     {
    3892         233 :         const char *pszStructuralMD = reinterpret_cast<const char *>(
    3893         233 :             poOpenInfo->pabyHeader + nOffsetOfStructuralMetadata);
    3894         233 :         poDS->m_bLayoutIFDSBeforeData =
    3895         233 :             strstr(pszStructuralMD, "LAYOUT=IFDS_BEFORE_DATA") != nullptr;
    3896         233 :         poDS->m_bBlockOrderRowMajor =
    3897         233 :             strstr(pszStructuralMD, "BLOCK_ORDER=ROW_MAJOR") != nullptr;
    3898         233 :         poDS->m_bLeaderSizeAsUInt4 =
    3899         466 :             strstr(pszStructuralMD, "BLOCK_LEADER=SIZE_AS_UINT4") != nullptr &&
    3900         233 :             (strstr(pszStructuralMD, "INTERLEAVE=") == nullptr ||
    3901          23 :              strstr(pszStructuralMD, "INTERLEAVE=BAND") != nullptr ||
    3902           0 :              strstr(pszStructuralMD, "INTERLEAVE=TILE") != nullptr);
    3903         233 :         poDS->m_bTrailerRepeatedLast4BytesRepeated =
    3904         233 :             strstr(pszStructuralMD, "BLOCK_TRAILER=LAST_4_BYTES_REPEATED") !=
    3905         466 :                 nullptr &&
    3906         233 :             (strstr(pszStructuralMD, "INTERLEAVE=") == nullptr ||
    3907          23 :              strstr(pszStructuralMD, "INTERLEAVE=BAND") != nullptr ||
    3908           0 :              strstr(pszStructuralMD, "INTERLEAVE=TILE") != nullptr);
    3909         233 :         poDS->m_bMaskInterleavedWithImagery =
    3910         233 :             strstr(pszStructuralMD, "MASK_INTERLEAVED_WITH_IMAGERY=YES") !=
    3911         274 :                 nullptr &&
    3912          41 :             strstr(pszStructuralMD, "INTERLEAVE=") == nullptr;
    3913         233 :         poDS->m_bKnownIncompatibleEdition =
    3914         233 :             strstr(pszStructuralMD, "KNOWN_INCOMPATIBLE_EDITION=YES") !=
    3915             :             nullptr;
    3916         233 :         if (poDS->m_bKnownIncompatibleEdition)
    3917             :         {
    3918           7 :             poDS->ReportError(
    3919             :                 CE_Warning, CPLE_AppDefined,
    3920             :                 "This file used to have optimizations in its layout, "
    3921             :                 "but those have been, at least partly, invalidated by "
    3922             :                 "later changes");
    3923             :         }
    3924         226 :         else if (poDS->m_bLayoutIFDSBeforeData && poDS->m_bBlockOrderRowMajor &&
    3925         226 :                  poDS->m_bLeaderSizeAsUInt4 &&
    3926         226 :                  poDS->m_bTrailerRepeatedLast4BytesRepeated)
    3927             :         {
    3928         237 :             if (poOpenInfo->eAccess == GA_Update &&
    3929          11 :                 !CPLTestBool(CSLFetchNameValueDef(poOpenInfo->papszOpenOptions,
    3930             :                                                   "IGNORE_COG_LAYOUT_BREAK",
    3931             :                                                   "FALSE")))
    3932             :             {
    3933           3 :                 CPLError(CE_Failure, CPLE_AppDefined,
    3934             :                          "File %s has C(loud) O(ptimized) G(eoTIFF) layout. "
    3935             :                          "Updating it will generally result in losing part of "
    3936             :                          "the optimizations (but will still produce a valid "
    3937             :                          "GeoTIFF file). If this is acceptable, open the file "
    3938             :                          "with the IGNORE_COG_LAYOUT_BREAK open option set "
    3939             :                          "to YES.",
    3940             :                          pszFilename);
    3941           3 :                 XTIFFClose(l_hTIFF);
    3942           3 :                 delete poDS;
    3943           3 :                 return nullptr;
    3944             :             }
    3945         223 :             poDS->m_oGTiffMDMD.SetMetadataItem("LAYOUT", "COG",
    3946             :                                                "IMAGE_STRUCTURE");
    3947             :         }
    3948             :     }
    3949             : 
    3950             :     // In the case of GDAL_DISABLE_READDIR_ON_OPEN = NO / EMPTY_DIR
    3951       23547 :     if (poOpenInfo->AreSiblingFilesLoaded() &&
    3952         168 :         CSLCount(poOpenInfo->GetSiblingFiles()) <= 1)
    3953             :     {
    3954          73 :         poDS->oOvManager.TransferSiblingFiles(
    3955          73 :             CSLDuplicate(poOpenInfo->GetSiblingFiles()));
    3956          73 :         poDS->m_bHasGotSiblingFiles = true;
    3957             :     }
    3958             : 
    3959             :     // Should be capped by 257, to avoid 65535 / m_nColorTableMultiplier to overflow 255
    3960       23334 :     poDS->m_nColorTableMultiplier = std::max(
    3961       70115 :         0, std::min(257,
    3962       23464 :                     atoi(CSLFetchNameValueDef(poOpenInfo->papszOpenOptions,
    3963       23410 :                                               "COLOR_TABLE_MULTIPLIER", "0"))));
    3964             : 
    3965       23334 :     if (poDS->OpenOffset(l_hTIFF, TIFFCurrentDirOffset(l_hTIFF),
    3966             :                          poOpenInfo->eAccess, bAllowRGBAInterface,
    3967       23501 :                          true) != CE_None)
    3968             :     {
    3969           9 :         delete poDS;
    3970           9 :         return nullptr;
    3971             :     }
    3972             : 
    3973             :     // Do we want blocks that are set to zero and that haven't yet being
    3974             :     // allocated as tile/strip to remain implicit?
    3975       23492 :     if (CPLFetchBool(poOpenInfo->papszOpenOptions, "SPARSE_OK", false))
    3976          46 :         poDS->m_bWriteEmptyTiles = false;
    3977             : 
    3978       23382 :     poDS->InitCreationOrOpenOptions(poOpenInfo->eAccess == GA_Update,
    3979       23382 :                                     poOpenInfo->papszOpenOptions);
    3980             : 
    3981       23343 :     poDS->m_bLoadPam = true;
    3982       23343 :     poDS->m_bColorProfileMetadataChanged = false;
    3983       23343 :     poDS->m_bMetadataChanged = false;
    3984       23343 :     poDS->m_bGeoTIFFInfoChanged = false;
    3985       23343 :     poDS->m_bNoDataChanged = false;
    3986       23343 :     poDS->m_bForceUnsetGTOrGCPs = false;
    3987       23343 :     poDS->m_bForceUnsetProjection = false;
    3988             : 
    3989             :     // Used by GTIFFBuildOverviewsEx() for the COG driver
    3990       46760 :     const char *pszMaskOverviewDS = CSLFetchNameValue(
    3991       23343 :         poOpenInfo->papszOpenOptions, "MASK_OVERVIEW_DATASET");
    3992       23417 :     if (pszMaskOverviewDS)
    3993             :     {
    3994           5 :         poDS->m_poMaskExtOvrDS.reset(GDALDataset::Open(
    3995             :             pszMaskOverviewDS, GDAL_OF_RASTER | GDAL_OF_INTERNAL));
    3996           5 :         if (!poDS->m_poMaskExtOvrDS || !poDS->AssociateExternalMask())
    3997             :         {
    3998           0 :             CPLDebug("GTiff",
    3999             :                      "Association with external mask overview file failed");
    4000             :         }
    4001             :     }
    4002             : 
    4003             :     /* -------------------------------------------------------------------- */
    4004             :     /*      Initialize info for external overviews.                         */
    4005             :     /* -------------------------------------------------------------------- */
    4006       23417 :     poDS->oOvManager.Initialize(poDS, poOpenInfo, pszFilename);
    4007             : 
    4008             :     // For backward compatibility, in case GTIFF_POINT_GEO_IGNORE is defined
    4009             :     // load georeferencing right now so as to not require it to be defined
    4010             :     // at the GetGeoTransform() time.
    4011       23401 :     if (CPLGetConfigOption("GTIFF_POINT_GEO_IGNORE", nullptr) != nullptr)
    4012             :     {
    4013          14 :         poDS->LoadGeoreferencingAndPamIfNeeded();
    4014             :     }
    4015             : 
    4016       23557 :     return poDS;
    4017             : }
    4018             : 
    4019             : /************************************************************************/
    4020             : /*                      GTiffDatasetSetAreaOrPointMD()                  */
    4021             : /************************************************************************/
    4022             : 
    4023       13785 : static void GTiffDatasetSetAreaOrPointMD(GTIF *hGTIF,
    4024             :                                          GDALMultiDomainMetadata &m_oGTiffMDMD)
    4025             : {
    4026             :     // Is this a pixel-is-point dataset?
    4027       13785 :     unsigned short nRasterType = 0;
    4028             : 
    4029       13785 :     if (GDALGTIFKeyGetSHORT(hGTIF, GTRasterTypeGeoKey, &nRasterType, 0, 1) == 1)
    4030             :     {
    4031        8498 :         if (nRasterType == static_cast<short>(RasterPixelIsPoint))
    4032         256 :             m_oGTiffMDMD.SetMetadataItem(GDALMD_AREA_OR_POINT,
    4033             :                                          GDALMD_AOP_POINT);
    4034             :         else
    4035        8242 :             m_oGTiffMDMD.SetMetadataItem(GDALMD_AREA_OR_POINT, GDALMD_AOP_AREA);
    4036             :     }
    4037       13785 : }
    4038             : 
    4039             : /************************************************************************/
    4040             : /*                         LoadMDAreaOrPoint()                          */
    4041             : /************************************************************************/
    4042             : 
    4043             : // This is a light version of LookForProjection(), which saves the
    4044             : // potential costly cost of GTIFGetOGISDefn(), since we just need to
    4045             : // access to a raw GeoTIFF key, and not build the full projection object.
    4046             : 
    4047       16479 : void GTiffDataset::LoadMDAreaOrPoint()
    4048             : {
    4049       17531 :     if (m_bLookedForProjection || m_bLookedForMDAreaOrPoint ||
    4050        1052 :         m_oGTiffMDMD.GetMetadataItem(GDALMD_AREA_OR_POINT) != nullptr)
    4051       15427 :         return;
    4052             : 
    4053        1052 :     m_bLookedForMDAreaOrPoint = true;
    4054             : 
    4055        1052 :     GTIF *hGTIF = GTiffDataset::GTIFNew(m_hTIFF);
    4056             : 
    4057        1052 :     if (!hGTIF)
    4058             :     {
    4059           0 :         ReportError(CE_Warning, CPLE_AppDefined,
    4060             :                     "GeoTIFF tags apparently corrupt, they are being ignored.");
    4061             :     }
    4062             :     else
    4063             :     {
    4064        1052 :         GTiffDatasetSetAreaOrPointMD(hGTIF, m_oGTiffMDMD);
    4065             : 
    4066        1052 :         GTIFFree(hGTIF);
    4067             :     }
    4068             : }
    4069             : 
    4070             : /************************************************************************/
    4071             : /*                         LookForProjection()                          */
    4072             : /************************************************************************/
    4073             : 
    4074      330914 : void GTiffDataset::LookForProjection()
    4075             : 
    4076             : {
    4077      330914 :     if (m_bLookedForProjection)
    4078      318174 :         return;
    4079             : 
    4080       12740 :     m_bLookedForProjection = true;
    4081             : 
    4082       12740 :     IdentifyAuthorizedGeoreferencingSources();
    4083             : 
    4084       12740 :     m_oSRS.Clear();
    4085             : 
    4086       25480 :     std::set<signed char> aoSetPriorities;
    4087       12740 :     if (m_nINTERNALGeorefSrcIndex >= 0)
    4088       12733 :         aoSetPriorities.insert(m_nINTERNALGeorefSrcIndex);
    4089       12740 :     if (m_nXMLGeorefSrcIndex >= 0)
    4090       12703 :         aoSetPriorities.insert(m_nXMLGeorefSrcIndex);
    4091       38176 :     for (const auto nIndex : aoSetPriorities)
    4092             :     {
    4093       25436 :         if (m_nINTERNALGeorefSrcIndex == nIndex)
    4094             :         {
    4095       12733 :             LookForProjectionFromGeoTIFF();
    4096             :         }
    4097       12703 :         else if (m_nXMLGeorefSrcIndex == nIndex)
    4098             :         {
    4099       12703 :             LookForProjectionFromXML();
    4100             :         }
    4101             :     }
    4102             : }
    4103             : 
    4104             : /************************************************************************/
    4105             : /*                      LookForProjectionFromGeoTIFF()                  */
    4106             : /************************************************************************/
    4107             : 
    4108       12733 : void GTiffDataset::LookForProjectionFromGeoTIFF()
    4109             : {
    4110             :     /* -------------------------------------------------------------------- */
    4111             :     /*      Capture the GeoTIFF projection, if available.                   */
    4112             :     /* -------------------------------------------------------------------- */
    4113             : 
    4114       12733 :     GTIF *hGTIF = GTiffDataset::GTIFNew(m_hTIFF);
    4115             : 
    4116       12733 :     if (!hGTIF)
    4117             :     {
    4118           0 :         ReportError(CE_Warning, CPLE_AppDefined,
    4119             :                     "GeoTIFF tags apparently corrupt, they are being ignored.");
    4120             :     }
    4121             :     else
    4122             :     {
    4123       12733 :         GTIFDefn *psGTIFDefn = GTIFAllocDefn();
    4124             : 
    4125       12733 :         bool bHasErrorBefore = CPLGetLastErrorType() != 0;
    4126             :         // Collect (PROJ) error messages and remit them later as warnings
    4127             :         int ret;
    4128       25466 :         CPLErrorAccumulator oErrorAccumulator;
    4129             :         {
    4130       12733 :             auto oAccumulator = oErrorAccumulator.InstallForCurrentScope();
    4131       12733 :             ret = GTIFGetDefn(hGTIF, psGTIFDefn);
    4132             :         }
    4133             : 
    4134       12733 :         bool bWarnAboutEllipsoid = true;
    4135             : 
    4136       12733 :         if (ret)
    4137             :         {
    4138       16064 :             auto oAccumulator = oErrorAccumulator.InstallForCurrentScope();
    4139             : 
    4140        8032 :             if (psGTIFDefn->Ellipsoid == 4326 &&
    4141           1 :                 psGTIFDefn->SemiMajor == 6378137 &&
    4142           1 :                 psGTIFDefn->SemiMinor == 6356752.314245)
    4143             :             {
    4144             :                 // Buggy Sentinel1 geotiff files use a wrong 4326 code for the
    4145             :                 // ellipsoid instead of 7030.
    4146           1 :                 psGTIFDefn->Ellipsoid = 7030;
    4147           1 :                 bWarnAboutEllipsoid = false;
    4148             :             }
    4149             : 
    4150        8032 :             OGRSpatialReferenceH hSRS = GTIFGetOGISDefnAsOSR(hGTIF, psGTIFDefn);
    4151             : 
    4152        8032 :             if (hSRS)
    4153             :             {
    4154        8032 :                 CPLFree(m_pszXMLFilename);
    4155        8032 :                 m_pszXMLFilename = nullptr;
    4156             : 
    4157        8032 :                 m_oSRS = *(OGRSpatialReference::FromHandle(hSRS));
    4158        8032 :                 OSRDestroySpatialReference(hSRS);
    4159             :             }
    4160             :         }
    4161             : 
    4162       25466 :         std::set<std::string> oSetErrorMsg;
    4163       12745 :         for (const auto &oError : oErrorAccumulator.GetErrors())
    4164             :         {
    4165          13 :             if (!bWarnAboutEllipsoid &&
    4166           1 :                 oError.msg.find("ellipsoid not found") != std::string::npos)
    4167             :             {
    4168           1 :                 continue;
    4169             :             }
    4170             : 
    4171             :             // Some error messages might be duplicated in GTIFGetDefn()
    4172             :             // and GTIFGetOGISDefnAsOSR(). Emit them just once.
    4173          11 :             if (oSetErrorMsg.find(oError.msg) == oSetErrorMsg.end())
    4174             :             {
    4175           8 :                 oSetErrorMsg.insert(oError.msg);
    4176          16 :                 CPLError(oError.type == CE_Failure ? CE_Warning : oError.type,
    4177           8 :                          oError.no, "%s", oError.msg.c_str());
    4178             :             }
    4179             :         }
    4180             : 
    4181       12733 :         if (!bHasErrorBefore && oSetErrorMsg.empty())
    4182             :         {
    4183       12658 :             CPLErrorReset();
    4184             :         }
    4185             : 
    4186       12733 :         if (ret && m_oSRS.IsCompound())
    4187             :         {
    4188          35 :             const char *pszVertUnit = nullptr;
    4189          35 :             m_oSRS.GetTargetLinearUnits("COMPD_CS|VERT_CS", &pszVertUnit);
    4190          35 :             if (pszVertUnit && !EQUAL(pszVertUnit, "unknown"))
    4191             :             {
    4192          35 :                 CPLFree(m_pszVertUnit);
    4193          35 :                 m_pszVertUnit = CPLStrdup(pszVertUnit);
    4194             :             }
    4195             : 
    4196             :             int versions[3];
    4197          35 :             GTIFDirectoryInfo(hGTIF, versions, nullptr);
    4198             : 
    4199             :             // If GeoTIFF 1.0, strip vertical by default
    4200          35 :             const char *pszDefaultReportCompdCS =
    4201          35 :                 (versions[0] == 1 && versions[1] == 1 && versions[2] == 0)
    4202          70 :                     ? "NO"
    4203             :                     : "YES";
    4204             : 
    4205             :             // Should we simplify away vertical CS stuff?
    4206          35 :             if (!CPLTestBool(CPLGetConfigOption("GTIFF_REPORT_COMPD_CS",
    4207             :                                                 pszDefaultReportCompdCS)))
    4208             :             {
    4209          10 :                 CPLDebug("GTiff", "Got COMPD_CS, but stripping it.");
    4210             : 
    4211          10 :                 m_oSRS.StripVertical();
    4212             :             }
    4213             :         }
    4214             : 
    4215       12733 :         GTIFFreeDefn(psGTIFDefn);
    4216             : 
    4217       12733 :         GTiffDatasetSetAreaOrPointMD(hGTIF, m_oGTiffMDMD);
    4218             : 
    4219       12733 :         GTIFFree(hGTIF);
    4220             :     }
    4221       12733 : }
    4222             : 
    4223             : /************************************************************************/
    4224             : /*                      LookForProjectionFromXML()                      */
    4225             : /************************************************************************/
    4226             : 
    4227       12703 : void GTiffDataset::LookForProjectionFromXML()
    4228             : {
    4229       12703 :     if (m_poBaseDS != nullptr)
    4230       12701 :         return;
    4231             : 
    4232       12671 :     CSLConstList papszSiblingFiles = GetSiblingFiles();
    4233             : 
    4234       12671 :     if (!GDALCanFileAcceptSidecarFile(m_osFilename.c_str()))
    4235           0 :         return;
    4236             : 
    4237             :     const std::string osXMLFilenameLowerCase =
    4238       12671 :         CPLResetExtensionSafe(m_osFilename.c_str(), "xml");
    4239             : 
    4240       12671 :     CPLString osXMLFilename;
    4241       25312 :     if (papszSiblingFiles &&
    4242       12641 :         GDALCanReliablyUseSiblingFileList(osXMLFilenameLowerCase.c_str()))
    4243             :     {
    4244       12641 :         const int iSibling = CSLFindString(
    4245             :             papszSiblingFiles, CPLGetFilename(osXMLFilenameLowerCase.c_str()));
    4246       12641 :         if (iSibling >= 0)
    4247             :         {
    4248           4 :             osXMLFilename = m_osFilename.c_str();
    4249           4 :             osXMLFilename.resize(m_osFilename.size() -
    4250           4 :                                  strlen(CPLGetFilename(m_osFilename.c_str())));
    4251           4 :             osXMLFilename += papszSiblingFiles[iSibling];
    4252             :         }
    4253             :         else
    4254             :         {
    4255       12637 :             return;
    4256             :         }
    4257             :     }
    4258             : 
    4259          34 :     if (osXMLFilename.empty())
    4260             :     {
    4261             :         VSIStatBufL sStatBuf;
    4262          30 :         bool bGotXML = VSIStatExL(osXMLFilenameLowerCase.c_str(), &sStatBuf,
    4263          30 :                                   VSI_STAT_EXISTS_FLAG) == 0;
    4264             : 
    4265          30 :         if (bGotXML)
    4266             :         {
    4267           0 :             osXMLFilename = osXMLFilenameLowerCase;
    4268             :         }
    4269          30 :         else if (VSIIsCaseSensitiveFS(osXMLFilenameLowerCase.c_str()))
    4270             :         {
    4271             :             const std::string osXMLFilenameUpperCase =
    4272          60 :                 CPLResetExtensionSafe(m_osFilename.c_str(), "XML");
    4273          30 :             bGotXML = VSIStatExL(osXMLFilenameUpperCase.c_str(), &sStatBuf,
    4274             :                                  VSI_STAT_EXISTS_FLAG) == 0;
    4275          30 :             if (bGotXML)
    4276             :             {
    4277           0 :                 osXMLFilename = osXMLFilenameUpperCase;
    4278             :             }
    4279             :         }
    4280             : 
    4281          30 :         if (osXMLFilename.empty())
    4282             :         {
    4283          30 :             return;
    4284             :         }
    4285             :     }
    4286             : 
    4287           4 :     GByte *pabyRet = nullptr;
    4288           4 :     vsi_l_offset nSize = 0;
    4289           4 :     constexpr int nMaxSize = 10 * 1024 * 1024;
    4290           4 :     if (!VSIIngestFile(nullptr, osXMLFilename.c_str(), &pabyRet, &nSize,
    4291             :                        nMaxSize))
    4292           0 :         return;
    4293             :     CPLXMLTreeCloser oXML(
    4294           4 :         CPLParseXMLString(reinterpret_cast<const char *>(pabyRet)));
    4295           4 :     VSIFree(pabyRet);
    4296           4 :     if (!oXML.get())
    4297           0 :         return;
    4298           4 :     const char *pszCode = CPLGetXMLValue(
    4299           4 :         oXML.get(), "=metadata.refSysInfo.RefSystem.refSysID.identCode.code",
    4300             :         "0");
    4301           4 :     const int nCode = atoi(pszCode);
    4302           4 :     if (nCode <= 0)
    4303           2 :         return;
    4304           2 :     if (nCode <= 32767)
    4305           2 :         m_oSRS.importFromEPSG(nCode);
    4306             :     else
    4307           0 :         m_oSRS.SetFromUserInput(CPLSPrintf("ESRI:%d", nCode));
    4308             : 
    4309           2 :     CPLFree(m_pszXMLFilename);
    4310           2 :     m_pszXMLFilename = CPLStrdup(osXMLFilename.c_str());
    4311             : }
    4312             : 
    4313             : /************************************************************************/
    4314             : /*                            ApplyPamInfo()                            */
    4315             : /*                                                                      */
    4316             : /*      PAM Information, if available, overrides the GeoTIFF            */
    4317             : /*      geotransform and projection definition.  Check for them         */
    4318             : /*      now.                                                            */
    4319             : /************************************************************************/
    4320             : 
    4321       14681 : void GTiffDataset::ApplyPamInfo()
    4322             : 
    4323             : {
    4324       14681 :     bool bGotGTFromPAM = false;
    4325             : 
    4326       14681 :     if (m_nPAMGeorefSrcIndex >= 0 &&
    4327       14680 :         ((m_bGeoTransformValid &&
    4328        9251 :           m_nPAMGeorefSrcIndex < m_nGeoTransformGeorefSrcIndex) ||
    4329        5439 :          m_nGeoTransformGeorefSrcIndex < 0 || !m_bGeoTransformValid))
    4330             :     {
    4331       14672 :         GDALGeoTransform pamGT;
    4332       14672 :         if (GDALPamDataset::GetGeoTransform(pamGT) == CE_None)
    4333             :         {
    4334          44 :             if (m_nGeoTransformGeorefSrcIndex == m_nWORLDFILEGeorefSrcIndex)
    4335             :             {
    4336          12 :                 CPLFree(m_pszGeorefFilename);
    4337          12 :                 m_pszGeorefFilename = nullptr;
    4338             :             }
    4339          44 :             m_gt = pamGT;
    4340          44 :             m_bGeoTransformValid = true;
    4341          44 :             bGotGTFromPAM = true;
    4342             :         }
    4343             :     }
    4344             : 
    4345       14680 :     if (m_nPAMGeorefSrcIndex >= 0)
    4346             :     {
    4347       14681 :         if ((m_nTABFILEGeorefSrcIndex < 0 ||
    4348       14647 :              m_nPAMGeorefSrcIndex < m_nTABFILEGeorefSrcIndex) &&
    4349       14679 :             (m_nINTERNALGeorefSrcIndex < 0 ||
    4350       14664 :              m_nPAMGeorefSrcIndex < m_nINTERNALGeorefSrcIndex))
    4351             :         {
    4352       14667 :             const auto *poPamSRS = GDALPamDataset::GetSpatialRef();
    4353       14668 :             if (poPamSRS)
    4354             :             {
    4355          46 :                 m_oSRS = *poPamSRS;
    4356          46 :                 m_bLookedForProjection = true;
    4357             :                 // m_nProjectionGeorefSrcIndex = m_nPAMGeorefSrcIndex;
    4358       14668 :             }
    4359             :         }
    4360             :         else
    4361             :         {
    4362          14 :             if (m_nINTERNALGeorefSrcIndex >= 0)
    4363          12 :                 LookForProjection();
    4364          14 :             if (m_oSRS.IsEmpty())
    4365             :             {
    4366           8 :                 const auto *poPamSRS = GDALPamDataset::GetSpatialRef();
    4367           8 :                 if (poPamSRS)
    4368             :                 {
    4369           9 :                     m_oSRS = *poPamSRS;
    4370           8 :                     m_bLookedForProjection = true;
    4371             :                     // m_nProjectionGeorefSrcIndex = m_nPAMGeorefSrcIndex;
    4372             :                 }
    4373             :             }
    4374             :         }
    4375             :     }
    4376             : 
    4377             :     int nPamGCPCount;
    4378       14680 :     if (m_nPAMGeorefSrcIndex >= 0 && !oMDMD.GetMetadata("xml:ESRI") &&
    4379       29379 :         (nPamGCPCount = GDALPamDataset::GetGCPCount()) > 0 &&
    4380          19 :         ((!m_aoGCPs.empty() &&
    4381          11 :           m_nPAMGeorefSrcIndex < m_nGeoTransformGeorefSrcIndex) ||
    4382          10 :          m_nGeoTransformGeorefSrcIndex < 0 || m_aoGCPs.empty()))
    4383             :     {
    4384          17 :         m_aoGCPs = gdal::GCP::fromC(GDALPamDataset::GetGCPs(), nPamGCPCount);
    4385             : 
    4386             :         // Invalidate Geotransorm got from less prioritary sources
    4387          19 :         if (!m_aoGCPs.empty() && m_bGeoTransformValid && !bGotGTFromPAM &&
    4388           2 :             m_nPAMGeorefSrcIndex == 0)
    4389             :         {
    4390           2 :             m_bGeoTransformValid = false;
    4391             :         }
    4392             : 
    4393             :         // m_nProjectionGeorefSrcIndex = m_nPAMGeorefSrcIndex;
    4394             : 
    4395          17 :         const auto *poPamGCPSRS = GDALPamDataset::GetGCPSpatialRef();
    4396          17 :         if (poPamGCPSRS)
    4397          15 :             m_oSRS = *poPamGCPSRS;
    4398             :         else
    4399           2 :             m_oSRS.Clear();
    4400             : 
    4401          17 :         m_bLookedForProjection = true;
    4402             :     }
    4403             : 
    4404       14681 :     if (m_nPAMGeorefSrcIndex >= 0)
    4405             :     {
    4406       14682 :         CPLXMLNode *psValueAsXML = nullptr;
    4407       14682 :         CPLXMLNode *psGeodataXform = nullptr;
    4408       14682 :         char **papszXML = oMDMD.GetMetadata("xml:ESRI");
    4409       14680 :         if (CSLCount(papszXML) == 1)
    4410             :         {
    4411           9 :             psValueAsXML = CPLParseXMLString(papszXML[0]);
    4412           9 :             if (psValueAsXML)
    4413           9 :                 psGeodataXform = CPLGetXMLNode(psValueAsXML, "=GeodataXform");
    4414             :         }
    4415             : 
    4416             :         const char *pszTIFFTagResUnit =
    4417       14681 :             GetMetadataItem("TIFFTAG_RESOLUTIONUNIT");
    4418       14681 :         const char *pszTIFFTagXRes = GetMetadataItem("TIFFTAG_XRESOLUTION");
    4419       14681 :         const char *pszTIFFTagYRes = GetMetadataItem("TIFFTAG_YRESOLUTION");
    4420       14682 :         if (psGeodataXform && pszTIFFTagXRes && pszTIFFTagYRes &&
    4421           1 :             pszTIFFTagResUnit && atoi(pszTIFFTagResUnit) == 2)
    4422             :         {
    4423             :             CPLXMLNode *psSourceGCPs =
    4424           1 :                 CPLGetXMLNode(psGeodataXform, "SourceGCPs");
    4425             :             CPLXMLNode *psTargetGCPs =
    4426           1 :                 CPLGetXMLNode(psGeodataXform, "TargetGCPs");
    4427           1 :             if (psSourceGCPs && psTargetGCPs)
    4428             :             {
    4429           2 :                 std::vector<double> adfSourceGCPs, adfTargetGCPs;
    4430           1 :                 for (CPLXMLNode *psIter = psSourceGCPs->psChild;
    4431          34 :                      psIter != nullptr; psIter = psIter->psNext)
    4432             :                 {
    4433          33 :                     if (psIter->eType == CXT_Element &&
    4434          32 :                         EQUAL(psIter->pszValue, "Double"))
    4435             :                     {
    4436          32 :                         adfSourceGCPs.push_back(
    4437          32 :                             CPLAtof(CPLGetXMLValue(psIter, nullptr, "")));
    4438             :                     }
    4439             :                 }
    4440           1 :                 for (CPLXMLNode *psIter = psTargetGCPs->psChild;
    4441          34 :                      psIter != nullptr; psIter = psIter->psNext)
    4442             :                 {
    4443          33 :                     if (psIter->eType == CXT_Element &&
    4444          32 :                         EQUAL(psIter->pszValue, "Double"))
    4445             :                     {
    4446          32 :                         adfTargetGCPs.push_back(
    4447          32 :                             CPLAtof(CPLGetXMLValue(psIter, nullptr, "")));
    4448             :                     }
    4449             :                 }
    4450           2 :                 if (adfSourceGCPs.size() == adfTargetGCPs.size() &&
    4451           1 :                     (adfSourceGCPs.size() % 2) == 0)
    4452             :                 {
    4453           1 :                     const char *pszESRI_WKT = CPLGetXMLValue(
    4454             :                         psGeodataXform, "SpatialReference.WKT", nullptr);
    4455           1 :                     if (pszESRI_WKT)
    4456             :                     {
    4457           1 :                         m_bLookedForProjection = true;
    4458           1 :                         m_oSRS.SetAxisMappingStrategy(
    4459             :                             OAMS_TRADITIONAL_GIS_ORDER);
    4460           1 :                         if (m_oSRS.importFromWkt(pszESRI_WKT) != OGRERR_NONE)
    4461             :                         {
    4462           0 :                             m_oSRS.Clear();
    4463             :                         }
    4464             :                     }
    4465             : 
    4466           1 :                     m_aoGCPs.clear();
    4467           1 :                     const size_t nNewGCPCount = adfSourceGCPs.size() / 2;
    4468          17 :                     for (size_t i = 0; i < nNewGCPCount; ++i)
    4469             :                     {
    4470             :                         m_aoGCPs.emplace_back(
    4471             :                             "", "",
    4472             :                             // The origin used is the bottom left corner,
    4473             :                             // and raw values to be multiplied by the
    4474             :                             // TIFFTAG_XRESOLUTION/TIFFTAG_YRESOLUTION
    4475             :                             /* pixel  = */
    4476          16 :                             adfSourceGCPs[2 * i] * CPLAtof(pszTIFFTagXRes),
    4477             :                             /* line = */
    4478          32 :                             nRasterYSize - adfSourceGCPs[2 * i + 1] *
    4479          16 :                                                CPLAtof(pszTIFFTagYRes),
    4480          16 :                             /* X = */ adfTargetGCPs[2 * i],
    4481          32 :                             /* Y = */ adfTargetGCPs[2 * i + 1]);
    4482             :                     }
    4483             : 
    4484             :                     // Invalidate Geotransform got from less prioritary sources
    4485           2 :                     if (!m_aoGCPs.empty() && m_bGeoTransformValid &&
    4486           2 :                         !bGotGTFromPAM && m_nPAMGeorefSrcIndex == 0)
    4487             :                     {
    4488           0 :                         m_bGeoTransformValid = false;
    4489             :                     }
    4490             :                 }
    4491             :             }
    4492             :         }
    4493             : 
    4494       14682 :         if (psValueAsXML)
    4495           9 :             CPLDestroyXMLNode(psValueAsXML);
    4496             :     }
    4497             : 
    4498             :     /* -------------------------------------------------------------------- */
    4499             :     /*      Copy any PAM metadata into our GeoTIFF context, and with        */
    4500             :     /*      the PAM info overriding the GeoTIFF context.                    */
    4501             :     /* -------------------------------------------------------------------- */
    4502       14681 :     CSLConstList papszPamDomains = oMDMD.GetDomainList();
    4503             : 
    4504       14709 :     for (int iDomain = 0;
    4505       14709 :          papszPamDomains && papszPamDomains[iDomain] != nullptr; ++iDomain)
    4506             :     {
    4507          28 :         const char *pszDomain = papszPamDomains[iDomain];
    4508          28 :         char **papszGT_MD = CSLDuplicate(m_oGTiffMDMD.GetMetadata(pszDomain));
    4509          28 :         char **papszPAM_MD = oMDMD.GetMetadata(pszDomain);
    4510             : 
    4511          28 :         papszGT_MD = CSLMerge(papszGT_MD, papszPAM_MD);
    4512             : 
    4513          28 :         m_oGTiffMDMD.SetMetadata(papszGT_MD, pszDomain);
    4514          28 :         CSLDestroy(papszGT_MD);
    4515             :     }
    4516             : 
    4517      398634 :     for (int i = 1; i <= GetRasterCount(); ++i)
    4518             :     {
    4519             :         GTiffRasterBand *poBand =
    4520      383952 :             cpl::down_cast<GTiffRasterBand *>(GetRasterBand(i));
    4521      383953 :         papszPamDomains = poBand->oMDMD.GetDomainList();
    4522             : 
    4523      384015 :         for (int iDomain = 0;
    4524      384015 :              papszPamDomains && papszPamDomains[iDomain] != nullptr; ++iDomain)
    4525             :         {
    4526          62 :             const char *pszDomain = papszPamDomains[iDomain];
    4527             :             char **papszGT_MD =
    4528          62 :                 CSLDuplicate(poBand->m_oGTiffMDMD.GetMetadata(pszDomain));
    4529          62 :             char **papszPAM_MD = poBand->oMDMD.GetMetadata(pszDomain);
    4530             : 
    4531          62 :             papszGT_MD = CSLMerge(papszGT_MD, papszPAM_MD);
    4532             : 
    4533          62 :             poBand->m_oGTiffMDMD.SetMetadata(papszGT_MD, pszDomain);
    4534          62 :             CSLDestroy(papszGT_MD);
    4535             :         }
    4536             :     }
    4537             : 
    4538      398632 :     for (int i = 1; i <= nBands; ++i)
    4539             :     {
    4540             :         GTiffRasterBand *poBand =
    4541      383952 :             cpl::down_cast<GTiffRasterBand *>(GetRasterBand(i));
    4542             : 
    4543             :         /* Load scale, offset and unittype from PAM if available */
    4544      383953 :         int nHaveOffsetScale = false;
    4545      383953 :         double dfScale = poBand->GDALPamRasterBand::GetScale(&nHaveOffsetScale);
    4546      383953 :         if (nHaveOffsetScale)
    4547             :         {
    4548           2 :             poBand->m_bHaveOffsetScale = true;
    4549           2 :             poBand->m_dfScale = dfScale;
    4550           2 :             poBand->m_dfOffset = poBand->GDALPamRasterBand::GetOffset();
    4551             :         }
    4552             : 
    4553      383953 :         const char *pszUnitType = poBand->GDALPamRasterBand::GetUnitType();
    4554      383952 :         if (pszUnitType && pszUnitType[0])
    4555           3 :             poBand->m_osUnitType = pszUnitType;
    4556             : 
    4557             :         const char *pszDescription =
    4558      383952 :             poBand->GDALPamRasterBand::GetDescription();
    4559      383953 :         if (pszDescription && pszDescription[0])
    4560           4 :             poBand->m_osDescription = pszDescription;
    4561             : 
    4562             :         GDALColorInterp ePAMColorInterp =
    4563      383953 :             poBand->GDALPamRasterBand::GetColorInterpretation();
    4564      383952 :         if (ePAMColorInterp != GCI_Undefined)
    4565          51 :             poBand->m_eBandInterp = ePAMColorInterp;
    4566             : 
    4567      383952 :         if (i == 1)
    4568             :         {
    4569       14680 :             const auto poCT = poBand->GDALPamRasterBand::GetColorTable();
    4570       14680 :             if (poCT)
    4571             :             {
    4572           4 :                 m_poColorTable.reset(poCT->Clone());
    4573             :             }
    4574             :         }
    4575             :     }
    4576       14680 : }
    4577             : 
    4578             : /************************************************************************/
    4579             : /*                              OpenDir()                               */
    4580             : /*                                                                      */
    4581             : /*      Open a specific directory as encoded into a filename.           */
    4582             : /************************************************************************/
    4583             : 
    4584          25 : GDALDataset *GTiffDataset::OpenDir(GDALOpenInfo *poOpenInfo)
    4585             : 
    4586             : {
    4587          25 :     bool bAllowRGBAInterface = true;
    4588          25 :     const char *pszFilename = poOpenInfo->pszFilename;
    4589          25 :     if (STARTS_WITH_CI(pszFilename, "GTIFF_RAW:"))
    4590             :     {
    4591           1 :         bAllowRGBAInterface = false;
    4592           1 :         pszFilename += strlen("GTIFF_RAW:");
    4593             :     }
    4594             : 
    4595          25 :     if (!STARTS_WITH_CI(pszFilename, "GTIFF_DIR:") ||
    4596          25 :         pszFilename[strlen("GTIFF_DIR:")] == '\0')
    4597             :     {
    4598           5 :         return nullptr;
    4599             :     }
    4600             : 
    4601             :     /* -------------------------------------------------------------------- */
    4602             :     /*      Split out filename, and dir#/offset.                            */
    4603             :     /* -------------------------------------------------------------------- */
    4604          20 :     pszFilename += strlen("GTIFF_DIR:");
    4605          20 :     bool bAbsolute = false;
    4606             : 
    4607          20 :     if (STARTS_WITH_CI(pszFilename, "off:"))
    4608             :     {
    4609           2 :         bAbsolute = true;
    4610           2 :         pszFilename += 4;
    4611             :     }
    4612             : 
    4613          20 :     toff_t nOffset = atol(pszFilename);
    4614          20 :     pszFilename += 1;
    4615             : 
    4616          44 :     while (*pszFilename != '\0' && pszFilename[-1] != ':')
    4617          24 :         ++pszFilename;
    4618             : 
    4619          20 :     if (*pszFilename == '\0' || nOffset == 0)
    4620             :     {
    4621           0 :         ReportError(
    4622             :             pszFilename, CE_Failure, CPLE_OpenFailed,
    4623             :             "Unable to extract offset or filename, should take the form:\n"
    4624             :             "GTIFF_DIR:<dir>:filename or GTIFF_DIR:off:<dir_offset>:filename");
    4625           0 :         return nullptr;
    4626             :     }
    4627             : 
    4628          20 :     if (poOpenInfo->eAccess == GA_Update)
    4629             :     {
    4630           1 :         ReportError(pszFilename, CE_Warning, CPLE_AppDefined,
    4631             :                     "Opening a specific TIFF directory is not supported in "
    4632             :                     "update mode. Switching to read-only");
    4633             :     }
    4634             : 
    4635             :     /* -------------------------------------------------------------------- */
    4636             :     /*      Try opening the dataset.                                        */
    4637             :     /* -------------------------------------------------------------------- */
    4638          20 :     GTiffOneTimeInit();
    4639             : 
    4640          20 :     const char *pszFlag = poOpenInfo->eAccess == GA_Update ? "r+DC" : "rDOC";
    4641          20 :     VSILFILE *l_fpL = VSIFOpenL(pszFilename, pszFlag);
    4642          20 :     if (l_fpL == nullptr)
    4643           0 :         return nullptr;
    4644          20 :     TIFF *l_hTIFF = VSI_TIFFOpen(pszFilename, pszFlag, l_fpL);
    4645          20 :     if (l_hTIFF == nullptr)
    4646             :     {
    4647           0 :         CPL_IGNORE_RET_VAL(VSIFCloseL(l_fpL));
    4648           0 :         return nullptr;
    4649             :     }
    4650             : 
    4651             :     /* -------------------------------------------------------------------- */
    4652             :     /*      If a directory was requested by index, advance to it now.       */
    4653             :     /* -------------------------------------------------------------------- */
    4654          20 :     if (!bAbsolute)
    4655             :     {
    4656          18 :         const toff_t nOffsetRequested = nOffset;
    4657          31 :         while (nOffset > 1)
    4658             :         {
    4659          13 :             if (TIFFReadDirectory(l_hTIFF) == 0)
    4660             :             {
    4661           0 :                 XTIFFClose(l_hTIFF);
    4662           0 :                 ReportError(pszFilename, CE_Failure, CPLE_OpenFailed,
    4663             :                             "Requested directory %lu not found.",
    4664             :                             static_cast<long unsigned int>(nOffsetRequested));
    4665           0 :                 CPL_IGNORE_RET_VAL(VSIFCloseL(l_fpL));
    4666           0 :                 return nullptr;
    4667             :             }
    4668          13 :             nOffset--;
    4669             :         }
    4670             : 
    4671          18 :         nOffset = TIFFCurrentDirOffset(l_hTIFF);
    4672             :     }
    4673             : 
    4674             :     /* -------------------------------------------------------------------- */
    4675             :     /*      Create a corresponding GDALDataset.                             */
    4676             :     /* -------------------------------------------------------------------- */
    4677          20 :     GTiffDataset *poDS = new GTiffDataset();
    4678          20 :     poDS->SetDescription(poOpenInfo->pszFilename);
    4679          20 :     poDS->m_osFilename = pszFilename;
    4680          20 :     poDS->m_fpL = l_fpL;
    4681          20 :     poDS->m_hTIFF = l_hTIFF;
    4682          20 :     poDS->m_bSingleIFDOpened = true;
    4683             : 
    4684          20 :     if (!EQUAL(pszFilename, poOpenInfo->pszFilename) &&
    4685          20 :         !STARTS_WITH_CI(poOpenInfo->pszFilename, "GTIFF_RAW:"))
    4686             :     {
    4687          19 :         poDS->SetPhysicalFilename(pszFilename);
    4688          19 :         poDS->SetSubdatasetName(poOpenInfo->pszFilename);
    4689             :     }
    4690             : 
    4691          20 :     if (poOpenInfo->AreSiblingFilesLoaded())
    4692          20 :         poDS->oOvManager.TransferSiblingFiles(poOpenInfo->StealSiblingFiles());
    4693             : 
    4694          20 :     if (poDS->OpenOffset(l_hTIFF, nOffset, poOpenInfo->eAccess,
    4695          20 :                          bAllowRGBAInterface, true) != CE_None)
    4696             :     {
    4697           1 :         delete poDS;
    4698           1 :         return nullptr;
    4699             :     }
    4700             : 
    4701          19 :     return poDS;
    4702             : }
    4703             : 
    4704             : /************************************************************************/
    4705             : /*                   ConvertTransferFunctionToString()                  */
    4706             : /*                                                                      */
    4707             : /*      Convert a transfer function table into a string.                */
    4708             : /*      Used by LoadICCProfile().                                       */
    4709             : /************************************************************************/
    4710          21 : static CPLString ConvertTransferFunctionToString(const uint16_t *pTable,
    4711             :                                                  uint32_t nTableEntries)
    4712             : {
    4713          21 :     CPLString sValue;
    4714             : 
    4715        5397 :     for (uint32_t i = 0; i < nTableEntries; ++i)
    4716             :     {
    4717        5376 :         if (i > 0)
    4718        5355 :             sValue += ", ";
    4719        5376 :         sValue += CPLSPrintf("%d", static_cast<uint32_t>(pTable[i]));
    4720             :     }
    4721             : 
    4722          21 :     return sValue;
    4723             : }
    4724             : 
    4725             : /************************************************************************/
    4726             : /*                             LoadICCProfile()                         */
    4727             : /*                                                                      */
    4728             : /*      Load ICC Profile or colorimetric data into metadata             */
    4729             : /************************************************************************/
    4730             : 
    4731        5272 : void GTiffDataset::LoadICCProfile()
    4732             : {
    4733        5272 :     if (m_bICCMetadataLoaded)
    4734        4765 :         return;
    4735         520 :     m_bICCMetadataLoaded = true;
    4736             : 
    4737         520 :     uint32_t nEmbedLen = 0;
    4738         520 :     uint8_t *pEmbedBuffer = nullptr;
    4739             : 
    4740         520 :     if (TIFFGetField(m_hTIFF, TIFFTAG_ICCPROFILE, &nEmbedLen, &pEmbedBuffer))
    4741             :     {
    4742          12 :         char *pszBase64Profile = CPLBase64Encode(
    4743             :             nEmbedLen, reinterpret_cast<const GByte *>(pEmbedBuffer));
    4744             : 
    4745          12 :         m_oGTiffMDMD.SetMetadataItem("SOURCE_ICC_PROFILE", pszBase64Profile,
    4746             :                                      "COLOR_PROFILE");
    4747             : 
    4748          12 :         CPLFree(pszBase64Profile);
    4749             : 
    4750          12 :         return;
    4751             :     }
    4752             : 
    4753             :     // Check for colorimetric tiff.
    4754         508 :     float *pCHR = nullptr;
    4755         508 :     float *pWP = nullptr;
    4756         508 :     uint16_t *pTFR = nullptr;
    4757         508 :     uint16_t *pTFG = nullptr;
    4758         508 :     uint16_t *pTFB = nullptr;
    4759         508 :     uint16_t *pTransferRange = nullptr;
    4760             : 
    4761         508 :     if (TIFFGetField(m_hTIFF, TIFFTAG_PRIMARYCHROMATICITIES, &pCHR))
    4762             :     {
    4763           8 :         if (TIFFGetField(m_hTIFF, TIFFTAG_WHITEPOINT, &pWP))
    4764             :         {
    4765          24 :             if (m_nBitsPerSample > 24 ||
    4766           8 :                 !TIFFGetFieldDefaulted(m_hTIFF, TIFFTAG_TRANSFERFUNCTION, &pTFR,
    4767           8 :                                        &pTFG, &pTFB) ||
    4768          16 :                 pTFR == nullptr || pTFG == nullptr || pTFB == nullptr)
    4769             :             {
    4770           1 :                 return;
    4771             :             }
    4772             : 
    4773           7 :             const int TIFFTAG_TRANSFERRANGE = 0x0156;
    4774           7 :             TIFFGetFieldDefaulted(m_hTIFF, TIFFTAG_TRANSFERRANGE,
    4775             :                                   &pTransferRange);
    4776             : 
    4777             :             // Set all the colorimetric metadata.
    4778           7 :             m_oGTiffMDMD.SetMetadataItem(
    4779             :                 "SOURCE_PRIMARIES_RED",
    4780          14 :                 CPLString().Printf("%.9f, %.9f, 1.0",
    4781           7 :                                    static_cast<double>(pCHR[0]),
    4782           7 :                                    static_cast<double>(pCHR[1])),
    4783             :                 "COLOR_PROFILE");
    4784           7 :             m_oGTiffMDMD.SetMetadataItem(
    4785             :                 "SOURCE_PRIMARIES_GREEN",
    4786          14 :                 CPLString().Printf("%.9f, %.9f, 1.0",
    4787           7 :                                    static_cast<double>(pCHR[2]),
    4788           7 :                                    static_cast<double>(pCHR[3])),
    4789             :                 "COLOR_PROFILE");
    4790           7 :             m_oGTiffMDMD.SetMetadataItem(
    4791             :                 "SOURCE_PRIMARIES_BLUE",
    4792          14 :                 CPLString().Printf("%.9f, %.9f, 1.0",
    4793           7 :                                    static_cast<double>(pCHR[4]),
    4794           7 :                                    static_cast<double>(pCHR[5])),
    4795             :                 "COLOR_PROFILE");
    4796             : 
    4797           7 :             m_oGTiffMDMD.SetMetadataItem(
    4798             :                 "SOURCE_WHITEPOINT",
    4799          14 :                 CPLString().Printf("%.9f, %.9f, 1.0",
    4800           7 :                                    static_cast<double>(pWP[0]),
    4801           7 :                                    static_cast<double>(pWP[1])),
    4802             :                 "COLOR_PROFILE");
    4803             : 
    4804             :             // Set transfer function metadata.
    4805             : 
    4806             :             // Get length of table.
    4807           7 :             const uint32_t nTransferFunctionLength = 1 << m_nBitsPerSample;
    4808             : 
    4809           7 :             m_oGTiffMDMD.SetMetadataItem(
    4810             :                 "TIFFTAG_TRANSFERFUNCTION_RED",
    4811          14 :                 ConvertTransferFunctionToString(pTFR, nTransferFunctionLength),
    4812             :                 "COLOR_PROFILE");
    4813             : 
    4814           7 :             m_oGTiffMDMD.SetMetadataItem(
    4815             :                 "TIFFTAG_TRANSFERFUNCTION_GREEN",
    4816          14 :                 ConvertTransferFunctionToString(pTFG, nTransferFunctionLength),
    4817             :                 "COLOR_PROFILE");
    4818             : 
    4819           7 :             m_oGTiffMDMD.SetMetadataItem(
    4820             :                 "TIFFTAG_TRANSFERFUNCTION_BLUE",
    4821          14 :                 ConvertTransferFunctionToString(pTFB, nTransferFunctionLength),
    4822             :                 "COLOR_PROFILE");
    4823             : 
    4824             :             // Set transfer range.
    4825           7 :             if (pTransferRange)
    4826             :             {
    4827           0 :                 m_oGTiffMDMD.SetMetadataItem(
    4828             :                     "TIFFTAG_TRANSFERRANGE_BLACK",
    4829           0 :                     CPLString().Printf("%d, %d, %d",
    4830           0 :                                        static_cast<int>(pTransferRange[0]),
    4831           0 :                                        static_cast<int>(pTransferRange[2]),
    4832           0 :                                        static_cast<int>(pTransferRange[4])),
    4833             :                     "COLOR_PROFILE");
    4834           0 :                 m_oGTiffMDMD.SetMetadataItem(
    4835             :                     "TIFFTAG_TRANSFERRANGE_WHITE",
    4836           0 :                     CPLString().Printf("%d, %d, %d",
    4837           0 :                                        static_cast<int>(pTransferRange[1]),
    4838           0 :                                        static_cast<int>(pTransferRange[3]),
    4839           0 :                                        static_cast<int>(pTransferRange[5])),
    4840             :                     "COLOR_PROFILE");
    4841             :             }
    4842             :         }
    4843             :     }
    4844             : }
    4845             : 
    4846             : /************************************************************************/
    4847             : /*                             OpenOffset()                             */
    4848             : /*                                                                      */
    4849             : /*      Initialize the GTiffDataset based on a passed in file           */
    4850             : /*      handle, and directory offset to utilize.  This is called for    */
    4851             : /*      full res, and overview pages.                                   */
    4852             : /************************************************************************/
    4853             : 
    4854       27352 : CPLErr GTiffDataset::OpenOffset(TIFF *hTIFFIn, toff_t nDirOffsetIn,
    4855             :                                 GDALAccess eAccessIn, bool bAllowRGBAInterface,
    4856             :                                 bool bReadGeoTransform)
    4857             : 
    4858             : {
    4859       27352 :     if (!hTIFFIn)
    4860           0 :         return CE_Failure;
    4861             : 
    4862       27352 :     eAccess = eAccessIn;
    4863             : 
    4864       27352 :     m_hTIFF = hTIFFIn;
    4865             : 
    4866       27352 :     m_nDirOffset = nDirOffsetIn;
    4867             : 
    4868       27352 :     if (!SetDirectory())
    4869           0 :         return CE_Failure;
    4870             : 
    4871             :     /* -------------------------------------------------------------------- */
    4872             :     /*      Capture some information from the file that is of interest.     */
    4873             :     /* -------------------------------------------------------------------- */
    4874       27268 :     uint32_t nXSize = 0;
    4875       27268 :     uint32_t nYSize = 0;
    4876       27268 :     TIFFGetField(m_hTIFF, TIFFTAG_IMAGEWIDTH, &nXSize);
    4877       27283 :     TIFFGetField(m_hTIFF, TIFFTAG_IMAGELENGTH, &nYSize);
    4878             : 
    4879             :     // Unlikely to occur, but could happen on a disk full situation.
    4880       27328 :     if (nXSize == 0 || nYSize == 0)
    4881          78 :         return CE_Failure;
    4882             : 
    4883       27250 :     if (nXSize > INT_MAX || nYSize > INT_MAX)
    4884             :     {
    4885             :         // GDAL only supports signed 32bit dimensions.
    4886          29 :         ReportError(CE_Failure, CPLE_NotSupported,
    4887             :                     "Too large image size: %u x %u", nXSize, nYSize);
    4888           1 :         return CE_Failure;
    4889             :     }
    4890       27221 :     nRasterXSize = nXSize;
    4891       27221 :     nRasterYSize = nYSize;
    4892             : 
    4893       27221 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_SAMPLESPERPIXEL, &m_nSamplesPerPixel))
    4894           6 :         nBands = 1;
    4895             :     else
    4896       27268 :         nBands = m_nSamplesPerPixel;
    4897             : 
    4898       27274 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_BITSPERSAMPLE, &(m_nBitsPerSample)))
    4899           6 :         m_nBitsPerSample = 1;
    4900             : 
    4901       27281 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_PLANARCONFIG, &(m_nPlanarConfig)))
    4902           0 :         m_nPlanarConfig = PLANARCONFIG_CONTIG;
    4903             : 
    4904       27271 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_PHOTOMETRIC, &(m_nPhotometric)))
    4905           9 :         m_nPhotometric = PHOTOMETRIC_MINISBLACK;
    4906             : 
    4907       27303 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_SAMPLEFORMAT, &(m_nSampleFormat)))
    4908         146 :         m_nSampleFormat = SAMPLEFORMAT_UINT;
    4909             : 
    4910       27265 :     if (!TIFFGetField(m_hTIFF, TIFFTAG_COMPRESSION, &(m_nCompression)))
    4911           0 :         m_nCompression = COMPRESSION_NONE;
    4912             : 
    4913       31037 :     if (m_nCompression != COMPRESSION_NONE &&
    4914        3711 :         !TIFFIsCODECConfigured(m_nCompression))
    4915             :     {
    4916             :         const char *pszCompressionMethodName =
    4917           3 :             GTIFFGetCompressionMethodName(m_nCompression);
    4918           3 :         if (pszCompressionMethodName)
    4919             :         {
    4920           1 :             ReportError(CE_Failure, CPLE_AppDefined,
    4921             :                         "Cannot open TIFF file due to missing codec %s.",
    4922             :                         pszCompressionMethodName);
    4923             :         }
    4924             :         else
    4925             :         {
    4926           2 :             ReportError(
    4927             :                 CE_Failure, CPLE_AppDefined,
    4928             :                 "Cannot open TIFF file due to missing codec of code %d.",
    4929           2 :                 m_nCompression);
    4930             :         }
    4931           3 :         return CE_Failure;
    4932             :     }
    4933             : 
    4934             :     /* -------------------------------------------------------------------- */
    4935             :     /*      YCbCr JPEG compressed images should be translated on the fly    */
    4936             :     /*      to RGB by libtiff/libjpeg unless specifically requested         */
    4937             :     /*      otherwise.                                                      */
    4938             :     /* -------------------------------------------------------------------- */
    4939       55110 :     if (m_nCompression == COMPRESSION_JPEG &&
    4940       27575 :         m_nPhotometric == PHOTOMETRIC_YCBCR &&
    4941         252 :         CPLTestBool(CPLGetConfigOption("CONVERT_YCBCR_TO_RGB", "YES")))
    4942             :     {
    4943         252 :         m_oGTiffMDMD.SetMetadataItem("SOURCE_COLOR_SPACE", "YCbCr",
    4944             :                                      "IMAGE_STRUCTURE");
    4945         252 :         int nColorMode = 0;
    4946         504 :         if (!TIFFGetField(m_hTIFF, TIFFTAG_JPEGCOLORMODE, &nColorMode) ||
    4947         252 :             nColorMode != JPEGCOLORMODE_RGB)
    4948             :         {
    4949         252 :             TIFFSetField(m_hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
    4950             :         }
    4951             :     }
    4952             : 
    4953             :     /* -------------------------------------------------------------------- */
    4954             :     /*      Get strip/tile layout.                                          */
    4955             :     /* -------------------------------------------------------------------- */
    4956       27323 :     if (TIFFIsTiled(m_hTIFF))
    4957             :     {
    4958        3713 :         uint32_t l_nBlockXSize = 0;
    4959        3713 :         uint32_t l_nBlockYSize = 0;
    4960        3713 :         TIFFGetField(m_hTIFF, TIFFTAG_TILEWIDTH, &(l_nBlockXSize));
    4961        3713 :         TIFFGetField(m_hTIFF, TIFFTAG_TILELENGTH, &(l_nBlockYSize));
    4962        3713 :         if (l_nBlockXSize > INT_MAX || l_nBlockYSize > INT_MAX)
    4963             :         {
    4964           2 :             ReportError(CE_Failure, CPLE_NotSupported,
    4965             :                         "Too large block size: %u x %u", l_nBlockXSize,
    4966             :                         l_nBlockYSize);
    4967           2 :             return CE_Failure;
    4968             :         }
    4969        3711 :         m_nBlockXSize = static_cast<int>(l_nBlockXSize);
    4970        3711 :         m_nBlockYSize = static_cast<int>(l_nBlockYSize);
    4971             :     }
    4972             :     else
    4973             :     {
    4974       23488 :         if (!TIFFGetField(m_hTIFF, TIFFTAG_ROWSPERSTRIP, &(m_nRowsPerStrip)))
    4975             :         {
    4976           5 :             ReportError(CE_Warning, CPLE_AppDefined,
    4977             :                         "RowsPerStrip not defined ... assuming all one strip.");
    4978           5 :             m_nRowsPerStrip = nYSize;  // Dummy value.
    4979             :         }
    4980             : 
    4981             :         // If the rows per strip is larger than the file we will get
    4982             :         // confused.  libtiff internally will treat the rowsperstrip as
    4983             :         // the image height and it is best if we do too. (#4468)
    4984       23567 :         if (m_nRowsPerStrip > static_cast<uint32_t>(nRasterYSize))
    4985          24 :             m_nRowsPerStrip = nRasterYSize;
    4986             : 
    4987       23567 :         m_nBlockXSize = nRasterXSize;
    4988       23567 :         m_nBlockYSize = m_nRowsPerStrip;
    4989             :     }
    4990             : 
    4991       27278 :     if (!ComputeBlocksPerColRowAndBand(nBands))
    4992           2 :         return CE_Failure;
    4993             : 
    4994             :     /* -------------------------------------------------------------------- */
    4995             :     /*      Should we handle this using the GTiffBitmapBand?                */
    4996             :     /* -------------------------------------------------------------------- */
    4997       27299 :     bool bTreatAsBitmap = false;
    4998             : 
    4999       27299 :     if (m_nBitsPerSample == 1 && nBands == 1)
    5000             :     {
    5001         408 :         bTreatAsBitmap = true;
    5002             : 
    5003             :         // Lets treat large "one row" bitmaps using the scanline api.
    5004         570 :         if (!TIFFIsTiled(m_hTIFF) && m_nBlockYSize == nRasterYSize &&
    5005         134 :             nRasterYSize > 2000
    5006             :             // libtiff does not support reading JBIG files with
    5007             :             // TIFFReadScanline().
    5008         570 :             && m_nCompression != COMPRESSION_JBIG)
    5009             :         {
    5010          10 :             m_bTreatAsSplitBitmap = true;
    5011             :         }
    5012             :     }
    5013             : 
    5014             :     /* -------------------------------------------------------------------- */
    5015             :     /*      Should we treat this via the RGBA interface?                    */
    5016             :     /* -------------------------------------------------------------------- */
    5017       27299 :     bool bTreatAsRGBA = false;
    5018       27385 :     if (
    5019             : #ifdef DEBUG
    5020       52618 :         CPLTestBool(CPLGetConfigOption("GTIFF_FORCE_RGBA", "NO")) ||
    5021             : #endif
    5022       25319 :         (bAllowRGBAInterface && !bTreatAsBitmap && !(m_nBitsPerSample > 8) &&
    5023       19428 :          (m_nPhotometric == PHOTOMETRIC_CIELAB ||
    5024       19426 :           m_nPhotometric == PHOTOMETRIC_LOGL ||
    5025       19426 :           m_nPhotometric == PHOTOMETRIC_LOGLUV ||
    5026       19426 :           m_nPhotometric == PHOTOMETRIC_SEPARATED ||
    5027       19415 :           (m_nPhotometric == PHOTOMETRIC_YCBCR &&
    5028         230 :            m_nCompression != COMPRESSION_JPEG))))
    5029             :     {
    5030          35 :         char szMessage[1024] = {};
    5031             : 
    5032          35 :         if (TIFFRGBAImageOK(m_hTIFF, szMessage) == 1)
    5033             :         {
    5034          35 :             const char *pszSourceColorSpace = nullptr;
    5035          35 :             nBands = 4;
    5036          35 :             switch (m_nPhotometric)
    5037             :             {
    5038           1 :                 case PHOTOMETRIC_CIELAB:
    5039           1 :                     pszSourceColorSpace = "CIELAB";
    5040           1 :                     break;
    5041           1 :                 case PHOTOMETRIC_LOGL:
    5042           1 :                     pszSourceColorSpace = "LOGL";
    5043           1 :                     break;
    5044           0 :                 case PHOTOMETRIC_LOGLUV:
    5045           0 :                     pszSourceColorSpace = "LOGLUV";
    5046           0 :                     break;
    5047          10 :                 case PHOTOMETRIC_SEPARATED:
    5048          10 :                     pszSourceColorSpace = "CMYK";
    5049          10 :                     break;
    5050          13 :                 case PHOTOMETRIC_YCBCR:
    5051          13 :                     pszSourceColorSpace = "YCbCr";
    5052          13 :                     nBands = 3;  // probably true for other photometric values
    5053          13 :                     break;
    5054             :             }
    5055          35 :             if (pszSourceColorSpace)
    5056          25 :                 m_oGTiffMDMD.SetMetadataItem("SOURCE_COLOR_SPACE",
    5057             :                                              pszSourceColorSpace,
    5058             :                                              "IMAGE_STRUCTURE");
    5059          35 :             bTreatAsRGBA = true;
    5060             :         }
    5061             :         else
    5062             :         {
    5063           0 :             CPLDebug("GTiff", "TIFFRGBAImageOK says:\n%s", szMessage);
    5064             :         }
    5065             :     }
    5066             : 
    5067             :     // libtiff has various issues with OJPEG compression and chunky-strip
    5068             :     // support with the "classic" scanline/strip/tile interfaces, and that
    5069             :     // wouldn't work either, so better bail out.
    5070       27385 :     if (m_nCompression == COMPRESSION_OJPEG && !bTreatAsRGBA)
    5071             :     {
    5072           0 :         ReportError(
    5073             :             CE_Failure, CPLE_NotSupported,
    5074             :             "Old-JPEG compression only supported through RGBA interface, "
    5075             :             "which cannot be used probably because the file is corrupted");
    5076           0 :         return CE_Failure;
    5077             :     }
    5078             : 
    5079             :     // If photometric is YCbCr, scanline/strip/tile interfaces assumes that
    5080             :     // we are ready with downsampled data. And we are not.
    5081       27385 :     if (m_nCompression != COMPRESSION_JPEG &&
    5082       26917 :         m_nCompression != COMPRESSION_OJPEG &&
    5083       26915 :         m_nPhotometric == PHOTOMETRIC_YCBCR &&
    5084          12 :         m_nPlanarConfig == PLANARCONFIG_CONTIG && !bTreatAsRGBA)
    5085             :     {
    5086             :         uint16_t nF1, nF2;
    5087           1 :         TIFFGetFieldDefaulted(m_hTIFF, TIFFTAG_YCBCRSUBSAMPLING, &nF1, &nF2);
    5088           1 :         if (nF1 != 1 || nF2 != 1)
    5089             :         {
    5090           1 :             ReportError(CE_Failure, CPLE_AppDefined,
    5091             :                         "Cannot open TIFF file with YCbCr, subsampling and "
    5092             :                         "BitsPerSample > 8 that is not JPEG compressed");
    5093           1 :             return CE_Failure;
    5094             :         }
    5095             :     }
    5096             : 
    5097             :     /* -------------------------------------------------------------------- */
    5098             :     /*      Should we treat this via the split interface?                   */
    5099             :     /* -------------------------------------------------------------------- */
    5100       51053 :     if (!TIFFIsTiled(m_hTIFF) && m_nBitsPerSample == 8 &&
    5101       51072 :         m_nBlockYSize == nRasterYSize && nRasterYSize > 2000 && !bTreatAsRGBA &&
    5102          24 :         CPLTestBool(CPLGetConfigOption("GDAL_ENABLE_TIFF_SPLIT", "YES")))
    5103             :     {
    5104          24 :         m_bTreatAsSplit = true;
    5105             :     }
    5106             : 
    5107             :     /* -------------------------------------------------------------------- */
    5108             :     /*      Should we treat this via the odd bits interface?                */
    5109             :     /* -------------------------------------------------------------------- */
    5110       27379 :     bool bTreatAsOdd = false;
    5111       27379 :     if (m_nSampleFormat == SAMPLEFORMAT_IEEEFP)
    5112             :     {
    5113        1774 :         if (m_nBitsPerSample == 24)
    5114           2 :             bTreatAsOdd = true;
    5115        1772 :         else if (m_nBitsPerSample != 16 && m_nBitsPerSample != 32 &&
    5116         627 :                  m_nBitsPerSample != 64)
    5117             :         {
    5118           0 :             ReportError(CE_Failure, CPLE_AppDefined,
    5119             :                         "Cannot open TIFF file with SampleFormat=IEEEFP "
    5120             :                         "and BitsPerSample=%d",
    5121           0 :                         m_nBitsPerSample);
    5122           0 :             return CE_Failure;
    5123             :         }
    5124             :     }
    5125       25605 :     else if (!bTreatAsRGBA && !bTreatAsBitmap && m_nBitsPerSample != 8 &&
    5126        4127 :              m_nBitsPerSample != 16 && m_nBitsPerSample != 32 &&
    5127        1346 :              m_nBitsPerSample != 64 && m_nBitsPerSample != 128)
    5128             :     {
    5129         203 :         bTreatAsOdd = true;
    5130             :     }
    5131             : 
    5132             : /* -------------------------------------------------------------------- */
    5133             : /*      We can't support 'chunks' bigger than 2GB on 32 bit builds      */
    5134             : /* -------------------------------------------------------------------- */
    5135             : #if SIZEOF_VOIDP == 4
    5136             :     uint64_t nChunkSize = 0;
    5137             :     if (m_bTreatAsSplit || m_bTreatAsSplitBitmap)
    5138             :     {
    5139             :         nChunkSize = TIFFScanlineSize64(m_hTIFF);
    5140             :     }
    5141             :     else
    5142             :     {
    5143             :         if (TIFFIsTiled(m_hTIFF))
    5144             :             nChunkSize = TIFFTileSize64(m_hTIFF);
    5145             :         else
    5146             :             nChunkSize = TIFFStripSize64(m_hTIFF);
    5147             :     }
    5148             :     if (bTreatAsRGBA)
    5149             :     {
    5150             :         nChunkSize =
    5151             :             std::max(nChunkSize,
    5152             :                      4 * static_cast<uint64_t>(m_nBlockXSize) * m_nBlockYSize);
    5153             :     }
    5154             :     if (nChunkSize > static_cast<uint64_t>(INT_MAX))
    5155             :     {
    5156             :         ReportError(CE_Failure, CPLE_NotSupported,
    5157             :                     "Scanline/tile/strip size bigger than 2GB unsupported "
    5158             :                     "on 32-bit builds.");
    5159             :         return CE_Failure;
    5160             :     }
    5161             : #endif
    5162             : 
    5163       27379 :     const bool bMinIsWhite = m_nPhotometric == PHOTOMETRIC_MINISWHITE;
    5164             : 
    5165             :     /* -------------------------------------------------------------------- */
    5166             :     /*      Check for NODATA                                                */
    5167             :     /* -------------------------------------------------------------------- */
    5168       27379 :     char *pszText = nullptr;
    5169       28778 :     if (TIFFGetField(m_hTIFF, TIFFTAG_GDAL_NODATA, &pszText) &&
    5170        1399 :         !EQUAL(pszText, ""))
    5171             :     {
    5172        1398 :         if (m_nBitsPerSample > 32 && m_nBitsPerSample <= 64 &&
    5173         104 :             m_nSampleFormat == SAMPLEFORMAT_INT)
    5174             :         {
    5175           5 :             m_bNoDataSetAsInt64 = true;
    5176           5 :             m_nNoDataValueInt64 =
    5177           5 :                 static_cast<int64_t>(std::strtoll(pszText, nullptr, 10));
    5178             :         }
    5179        1393 :         else if (m_nBitsPerSample > 32 && m_nBitsPerSample <= 64 &&
    5180          99 :                  m_nSampleFormat == SAMPLEFORMAT_UINT)
    5181             :         {
    5182           5 :             m_bNoDataSetAsUInt64 = true;
    5183           5 :             m_nNoDataValueUInt64 =
    5184           5 :                 static_cast<uint64_t>(std::strtoull(pszText, nullptr, 10));
    5185             :         }
    5186             :         else
    5187             :         {
    5188        1388 :             m_bNoDataSet = true;
    5189        1388 :             m_dfNoDataValue = CPLAtofM(pszText);
    5190        1388 :             if (m_nBitsPerSample == 32 &&
    5191         197 :                 m_nSampleFormat == SAMPLEFORMAT_IEEEFP)
    5192             :             {
    5193         139 :                 m_dfNoDataValue =
    5194         139 :                     GDALAdjustNoDataCloseToFloatMax(m_dfNoDataValue);
    5195         139 :                 m_dfNoDataValue =
    5196         139 :                     static_cast<double>(static_cast<float>(m_dfNoDataValue));
    5197             :             }
    5198             :         }
    5199             :     }
    5200             : 
    5201             :     /* -------------------------------------------------------------------- */
    5202             :     /*      Capture the color table if there is one.                        */
    5203             :     /* -------------------------------------------------------------------- */
    5204       27367 :     unsigned short *panRed = nullptr;
    5205       27367 :     unsigned short *panGreen = nullptr;
    5206       27367 :     unsigned short *panBlue = nullptr;
    5207             : 
    5208       50608 :     if (bTreatAsRGBA || m_nBitsPerSample > 16 ||
    5209       23219 :         TIFFGetField(m_hTIFF, TIFFTAG_COLORMAP, &panRed, &panGreen, &panBlue) ==
    5210             :             0)
    5211             :     {
    5212             :         // Build inverted palette if we have inverted photometric.
    5213             :         // Pixel values remains unchanged.  Avoid doing this for *deep*
    5214             :         // data types (per #1882)
    5215       27153 :         if (m_nBitsPerSample <= 16 && m_nPhotometric == PHOTOMETRIC_MINISWHITE)
    5216             :         {
    5217          13 :             m_poColorTable = std::make_unique<GDALColorTable>();
    5218          13 :             const int nColorCount = 1 << m_nBitsPerSample;
    5219             : 
    5220          39 :             for (int iColor = 0; iColor < nColorCount; ++iColor)
    5221             :             {
    5222          26 :                 const short nValue = static_cast<short>(
    5223          26 :                     ((255 * (nColorCount - 1 - iColor)) / (nColorCount - 1)));
    5224          26 :                 const GDALColorEntry oEntry = {nValue, nValue, nValue,
    5225          26 :                                                static_cast<short>(255)};
    5226          26 :                 m_poColorTable->SetColorEntry(iColor, &oEntry);
    5227             :             }
    5228             : 
    5229          13 :             m_nPhotometric = PHOTOMETRIC_PALETTE;
    5230             :         }
    5231             :         else
    5232             :         {
    5233       27140 :             m_poColorTable.reset();
    5234             :         }
    5235             :     }
    5236             :     else
    5237             :     {
    5238         236 :         const int nColorCount = 1 << m_nBitsPerSample;
    5239         154 :         m_poColorTable = gdal::tiff_common::TIFFColorMapTagToColorTable(
    5240         236 :             panRed, panGreen, panBlue, nColorCount, m_nColorTableMultiplier,
    5241         236 :             DEFAULT_COLOR_TABLE_MULTIPLIER_257, m_bNoDataSet, m_dfNoDataValue);
    5242             :     }
    5243             : 
    5244             :     /* -------------------------------------------------------------------- */
    5245             :     /*      Create band information objects.                                */
    5246             :     /* -------------------------------------------------------------------- */
    5247      756856 :     for (int iBand = 0; iBand < nBands; ++iBand)
    5248             :     {
    5249      729711 :         if (bTreatAsRGBA)
    5250         127 :             SetBand(iBand + 1, new GTiffRGBABand(this, iBand + 1));
    5251      729584 :         else if (m_bTreatAsSplitBitmap)
    5252          10 :             SetBand(iBand + 1, new GTiffSplitBitmapBand(this, iBand + 1));
    5253      729574 :         else if (m_bTreatAsSplit)
    5254      131118 :             SetBand(iBand + 1, new GTiffSplitBand(this, iBand + 1));
    5255      598456 :         else if (bTreatAsBitmap)
    5256         398 :             SetBand(iBand + 1, new GTiffBitmapBand(this, iBand + 1));
    5257      598058 :         else if (bTreatAsOdd)
    5258         346 :             SetBand(iBand + 1, new GTiffOddBitsBand(this, iBand + 1));
    5259             :         else
    5260      597712 :             SetBand(iBand + 1, new GTiffRasterBand(this, iBand + 1));
    5261             :     }
    5262             : 
    5263       27145 :     if (GetRasterBand(1)->GetRasterDataType() == GDT_Unknown)
    5264             :     {
    5265           1 :         ReportError(CE_Failure, CPLE_NotSupported,
    5266             :                     "Unsupported TIFF configuration: BitsPerSample(=%d) and "
    5267             :                     "SampleType(=%d)",
    5268           1 :                     m_nBitsPerSample, m_nSampleFormat);
    5269           1 :         return CE_Failure;
    5270             :     }
    5271             : 
    5272       27263 :     m_bReadGeoTransform = bReadGeoTransform;
    5273             : 
    5274             :     /* -------------------------------------------------------------------- */
    5275             :     /*      Capture some other potentially interesting information.         */
    5276             :     /* -------------------------------------------------------------------- */
    5277       27263 :     char szWorkMDI[200] = {};
    5278       27263 :     uint16_t nShort = 0;
    5279             : 
    5280       27263 :     const auto *pasTIFFTags = GetTIFFTags();
    5281      410094 :     for (size_t iTag = 0; pasTIFFTags[iTag].pszTagName; ++iTag)
    5282             :     {
    5283      382749 :         if (pasTIFFTags[iTag].eType == GTIFFTAGTYPE_STRING)
    5284             :         {
    5285      218681 :             if (TIFFGetField(m_hTIFF, pasTIFFTags[iTag].nTagVal, &pszText))
    5286         120 :                 m_oGTiffMDMD.SetMetadataItem(pasTIFFTags[iTag].pszTagName,
    5287             :                                              pszText);
    5288             :         }
    5289      164068 :         else if (pasTIFFTags[iTag].eType == GTIFFTAGTYPE_FLOAT)
    5290             :         {
    5291       54659 :             float fVal = 0.0;
    5292       54659 :             if (TIFFGetField(m_hTIFF, pasTIFFTags[iTag].nTagVal, &fVal))
    5293             :             {
    5294         172 :                 CPLsnprintf(szWorkMDI, sizeof(szWorkMDI), "%.8g",
    5295             :                             static_cast<double>(fVal));
    5296         172 :                 m_oGTiffMDMD.SetMetadataItem(pasTIFFTags[iTag].pszTagName,
    5297             :                                              szWorkMDI);
    5298             :             }
    5299             :         }
    5300      109409 :         else if (pasTIFFTags[iTag].eType == GTIFFTAGTYPE_SHORT &&
    5301       81978 :                  pasTIFFTags[iTag].nTagVal != TIFFTAG_RESOLUTIONUNIT)
    5302             :         {
    5303       54562 :             if (TIFFGetField(m_hTIFF, pasTIFFTags[iTag].nTagVal, &nShort))
    5304             :             {
    5305           8 :                 snprintf(szWorkMDI, sizeof(szWorkMDI), "%d", nShort);
    5306           8 :                 m_oGTiffMDMD.SetMetadataItem(pasTIFFTags[iTag].pszTagName,
    5307             :                                              szWorkMDI);
    5308             :             }
    5309             :         }
    5310       54847 :         else if (pasTIFFTags[iTag].eType == GTIFFTAGTYPE_BYTE_STRING)
    5311             :         {
    5312       27320 :             uint32_t nCount = 0;
    5313       27320 :             if (TIFFGetField(m_hTIFF, pasTIFFTags[iTag].nTagVal, &nCount,
    5314       27355 :                              &pszText))
    5315             :             {
    5316           2 :                 std::string osStr;
    5317           1 :                 osStr.assign(pszText, nCount);
    5318           1 :                 m_oGTiffMDMD.SetMetadataItem(pasTIFFTags[iTag].pszTagName,
    5319             :                                              osStr.c_str());
    5320             :             }
    5321             :         }
    5322             :     }
    5323             : 
    5324       27345 :     if (TIFFGetField(m_hTIFF, TIFFTAG_RESOLUTIONUNIT, &nShort))
    5325             :     {
    5326          88 :         if (nShort == RESUNIT_NONE)
    5327          34 :             snprintf(szWorkMDI, sizeof(szWorkMDI), "%d (unitless)", nShort);
    5328          54 :         else if (nShort == RESUNIT_INCH)
    5329          53 :             snprintf(szWorkMDI, sizeof(szWorkMDI), "%d (pixels/inch)", nShort);
    5330           1 :         else if (nShort == RESUNIT_CENTIMETER)
    5331           1 :             snprintf(szWorkMDI, sizeof(szWorkMDI), "%d (pixels/cm)", nShort);
    5332             :         else
    5333           0 :             snprintf(szWorkMDI, sizeof(szWorkMDI), "%d", nShort);
    5334          88 :         m_oGTiffMDMD.SetMetadataItem("TIFFTAG_RESOLUTIONUNIT", szWorkMDI);
    5335             :     }
    5336             : 
    5337       27337 :     int nTagSize = 0;
    5338       27337 :     void *pData = nullptr;
    5339       27337 :     if (TIFFGetField(m_hTIFF, TIFFTAG_XMLPACKET, &nTagSize, &pData))
    5340             :     {
    5341          35 :         char *pszXMP = static_cast<char *>(VSI_MALLOC_VERBOSE(nTagSize + 1));
    5342          35 :         if (pszXMP)
    5343             :         {
    5344          35 :             memcpy(pszXMP, pData, nTagSize);
    5345          35 :             pszXMP[nTagSize] = '\0';
    5346             : 
    5347          35 :             char *apszMDList[2] = {pszXMP, nullptr};
    5348          35 :             m_oGTiffMDMD.SetMetadata(apszMDList, "xml:XMP");
    5349             : 
    5350          35 :             CPLFree(pszXMP);
    5351             :         }
    5352             :     }
    5353             : 
    5354       27347 :     if (m_nCompression != COMPRESSION_NONE)
    5355             :     {
    5356             :         const char *pszCompressionMethodName =
    5357        3708 :             GTIFFGetCompressionMethodName(m_nCompression);
    5358        3708 :         if (pszCompressionMethodName)
    5359             :         {
    5360        3708 :             m_oGTiffMDMD.SetMetadataItem(
    5361             :                 "COMPRESSION", pszCompressionMethodName, "IMAGE_STRUCTURE");
    5362             :         }
    5363             :         else
    5364             :         {
    5365           0 :             CPLString oComp;
    5366           0 :             oComp.Printf("%d", m_nCompression);
    5367           0 :             m_oGTiffMDMD.SetMetadataItem("COMPRESSION", oComp.c_str());
    5368             :         }
    5369             :     }
    5370             : 
    5371       27347 :     if (m_nCompression == COMPRESSION_JPEG &&
    5372         464 :         m_nPhotometric == PHOTOMETRIC_YCBCR)
    5373             :     {
    5374         252 :         m_oGTiffMDMD.SetMetadataItem("COMPRESSION", "YCbCr JPEG",
    5375             :                                      "IMAGE_STRUCTURE");
    5376             :     }
    5377       27095 :     else if (m_nCompression == COMPRESSION_LERC)
    5378             :     {
    5379         317 :         uint32_t nLercParamCount = 0;
    5380         317 :         uint32_t *panLercParams = nullptr;
    5381         317 :         if (TIFFGetField(m_hTIFF, TIFFTAG_LERC_PARAMETERS, &nLercParamCount,
    5382         634 :                          &panLercParams) &&
    5383         317 :             nLercParamCount == 2)
    5384             :         {
    5385         317 :             memcpy(m_anLercAddCompressionAndVersion, panLercParams,
    5386             :                    sizeof(m_anLercAddCompressionAndVersion));
    5387             :         }
    5388             : 
    5389         317 :         uint32_t nAddVersion = LERC_ADD_COMPRESSION_NONE;
    5390         634 :         if (TIFFGetField(m_hTIFF, TIFFTAG_LERC_ADD_COMPRESSION, &nAddVersion) &&
    5391         317 :             nAddVersion != LERC_ADD_COMPRESSION_NONE)
    5392             :         {
    5393         173 :             if (nAddVersion == LERC_ADD_COMPRESSION_DEFLATE)
    5394             :             {
    5395          90 :                 m_oGTiffMDMD.SetMetadataItem("COMPRESSION", "LERC_DEFLATE",
    5396             :                                              "IMAGE_STRUCTURE");
    5397             :             }
    5398          83 :             else if (nAddVersion == LERC_ADD_COMPRESSION_ZSTD)
    5399             :             {
    5400          83 :                 m_oGTiffMDMD.SetMetadataItem("COMPRESSION", "LERC_ZSTD",
    5401             :                                              "IMAGE_STRUCTURE");
    5402             :             }
    5403             :         }
    5404         317 :         uint32_t nLercVersion = LERC_VERSION_2_4;
    5405         317 :         if (TIFFGetField(m_hTIFF, TIFFTAG_LERC_VERSION, &nLercVersion))
    5406             :         {
    5407         317 :             if (nLercVersion == LERC_VERSION_2_4)
    5408             :             {
    5409         317 :                 m_oGTiffMDMD.SetMetadataItem("LERC_VERSION", "2.4",
    5410             :                                              "IMAGE_STRUCTURE");
    5411             :             }
    5412             :             else
    5413             :             {
    5414           0 :                 ReportError(CE_Warning, CPLE_AppDefined,
    5415             :                             "Unknown Lerc version: %d", nLercVersion);
    5416             :             }
    5417             :         }
    5418             :     }
    5419             : 
    5420       27347 :     if (m_nPlanarConfig == PLANARCONFIG_CONTIG && nBands != 1)
    5421        2974 :         m_oGTiffMDMD.SetMetadataItem("INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE");
    5422             :     else
    5423       24373 :         m_oGTiffMDMD.SetMetadataItem("INTERLEAVE", "BAND", "IMAGE_STRUCTURE");
    5424             : 
    5425       27265 :     if ((GetRasterBand(1)->GetRasterDataType() == GDT_Byte &&
    5426       21196 :          m_nBitsPerSample != 8) ||
    5427       26791 :         (GetRasterBand(1)->GetRasterDataType() == GDT_UInt16 &&
    5428       55022 :          m_nBitsPerSample != 16) ||
    5429       26629 :         ((GetRasterBand(1)->GetRasterDataType() == GDT_UInt32 ||
    5430       26218 :           GetRasterBand(1)->GetRasterDataType() == GDT_Float32) &&
    5431        1410 :          m_nBitsPerSample != 32))
    5432             :     {
    5433        1370 :         for (int i = 0; i < nBands; ++i)
    5434         757 :             cpl::down_cast<GTiffRasterBand *>(GetRasterBand(i + 1))
    5435         757 :                 ->m_oGTiffMDMD.SetMetadataItem(
    5436             :                     "NBITS",
    5437        1514 :                     CPLString().Printf("%d",
    5438         757 :                                        static_cast<int>(m_nBitsPerSample)),
    5439             :                     "IMAGE_STRUCTURE");
    5440             :     }
    5441             : 
    5442       27145 :     if (bMinIsWhite)
    5443          15 :         m_oGTiffMDMD.SetMetadataItem("MINISWHITE", "YES", "IMAGE_STRUCTURE");
    5444             : 
    5445       27145 :     if (TIFFGetField(m_hTIFF, TIFFTAG_GDAL_METADATA, &pszText))
    5446             :     {
    5447        6562 :         auto psRoot = CPLXMLTreeCloser(CPLParseXMLString(pszText));
    5448             :         const CPLXMLNode *psItem =
    5449        3281 :             psRoot.get() ? CPLGetXMLNode(psRoot.get(), "=GDALMetadata")
    5450        3280 :                          : nullptr;
    5451        3280 :         if (psItem)
    5452        3280 :             psItem = psItem->psChild;
    5453        3280 :         bool bMaxZErrorFound = false;
    5454        3280 :         bool bMaxZErrorOverviewFound = false;
    5455       18183 :         for (; psItem != nullptr; psItem = psItem->psNext)
    5456             :         {
    5457             : 
    5458       14902 :             if (psItem->eType != CXT_Element ||
    5459       14902 :                 !EQUAL(psItem->pszValue, "Item"))
    5460           6 :                 continue;
    5461             : 
    5462       14896 :             const char *pszKey = CPLGetXMLValue(psItem, "name", nullptr);
    5463       14896 :             const char *pszValue = CPLGetXMLValue(psItem, nullptr, nullptr);
    5464       14902 :             int nBand = atoi(CPLGetXMLValue(psItem, "sample", "-1"));
    5465       14903 :             if (nBand < -1 || nBand > nBands - 1)
    5466           4 :                 continue;
    5467       14899 :             nBand++;
    5468       14899 :             const char *pszRole = CPLGetXMLValue(psItem, "role", "");
    5469       14903 :             const char *pszDomain = CPLGetXMLValue(psItem, "domain", "");
    5470             : 
    5471       14906 :             if (nBand > 0 && pszKey &&
    5472        3808 :                 strcmp(pszKey, DEFAULT_RASTER_ATTRIBUTE_TABLE) == 0 &&
    5473          11 :                 strcmp(pszRole, RAT_ROLE) == 0)
    5474             :             {
    5475          11 :                 const CPLXMLNode *psValueNode = psItem->psChild;
    5476          44 :                 while (psValueNode && psValueNode->eType != CXT_Element)
    5477          33 :                     psValueNode = psValueNode->psNext;
    5478          11 :                 if (psValueNode && psValueNode->eType == CXT_Element)
    5479             :                 {
    5480             :                     auto poRAT =
    5481          22 :                         std::make_unique<GDALDefaultRasterAttributeTable>();
    5482          11 :                     if (poRAT->XMLInit(psValueNode, nullptr) == CE_None)
    5483             :                     {
    5484             :                         GTiffRasterBand *poBand =
    5485          11 :                             cpl::down_cast<GTiffRasterBand *>(
    5486             :                                 GetRasterBand(nBand));
    5487          11 :                         if (poBand != nullptr)
    5488             :                         {
    5489          11 :                             poBand->m_poRAT = std::move(poRAT);
    5490          11 :                             poBand->m_bRATSet = true;
    5491             :                         }
    5492             :                     }
    5493             :                 }
    5494             :             }
    5495             : 
    5496       14906 :             if (pszKey == nullptr || pszValue == nullptr)
    5497         298 :                 continue;
    5498       14608 :             if (EQUAL(pszDomain, "IMAGE_STRUCTURE"))
    5499             :             {
    5500         848 :                 if (EQUAL(pszKey, "OVERVIEW_RESAMPLING"))
    5501             :                 {
    5502         104 :                     m_oGTiffMDMD.SetMetadataItem(pszKey, pszValue,
    5503             :                                                  "IMAGE_STRUCTURE");
    5504             :                 }
    5505         744 :                 else if (EQUAL(pszKey, "INTERLEAVE"))
    5506             :                 {
    5507          39 :                     if (EQUAL(pszValue, "TILE"))
    5508             :                     {
    5509          17 :                         m_bTileInterleave = true;
    5510          17 :                         m_oGTiffMDMD.SetMetadataItem("INTERLEAVE", "TILE",
    5511             :                                                      "IMAGE_STRUCTURE");
    5512             :                     }
    5513             :                     else
    5514             :                     {
    5515          22 :                         CPLDebug("GTiff",
    5516             :                                  "Unhandled INTERLEAVE=%s found in "
    5517             :                                  "GDAL_METADATA tag",
    5518             :                                  pszValue);
    5519             :                     }
    5520             :                 }
    5521         705 :                 else if (m_nCompression == COMPRESSION_WEBP &&
    5522          73 :                          EQUAL(pszKey, "COMPRESSION_REVERSIBILITY"))
    5523             :                 {
    5524          13 :                     if (EQUAL(pszValue, "LOSSLESS"))
    5525          13 :                         m_bWebPLossless = true;
    5526           0 :                     else if (EQUAL(pszValue, "LOSSY"))
    5527           0 :                         m_bWebPLossless = false;
    5528             :                 }
    5529         692 :                 else if (m_nCompression == COMPRESSION_WEBP &&
    5530          60 :                          EQUAL(pszKey, "WEBP_LEVEL"))
    5531             :                 {
    5532          60 :                     const int nLevel = atoi(pszValue);
    5533          60 :                     if (nLevel >= 1 && nLevel <= 100)
    5534             :                     {
    5535          60 :                         m_oGTiffMDMD.SetMetadataItem(
    5536             :                             "COMPRESSION_REVERSIBILITY", "LOSSY",
    5537             :                             "IMAGE_STRUCTURE");
    5538          60 :                         m_bWebPLossless = false;
    5539          60 :                         m_nWebPLevel = static_cast<signed char>(nLevel);
    5540          60 :                     }
    5541             :                 }
    5542         632 :                 else if (m_nCompression == COMPRESSION_LERC &&
    5543         196 :                          EQUAL(pszKey, "MAX_Z_ERROR"))
    5544             :                 {
    5545          28 :                     bMaxZErrorFound = true;
    5546          28 :                     m_dfMaxZError = CPLAtof(pszValue);
    5547             :                 }
    5548         604 :                 else if (m_nCompression == COMPRESSION_LERC &&
    5549         168 :                          EQUAL(pszKey, "MAX_Z_ERROR_OVERVIEW"))
    5550             :                 {
    5551           4 :                     bMaxZErrorOverviewFound = true;
    5552           4 :                     m_dfMaxZErrorOverview = CPLAtof(pszValue);
    5553             :                 }
    5554             : #if HAVE_JXL
    5555         600 :                 else if ((m_nCompression == COMPRESSION_JXL ||
    5556         598 :                           m_nCompression == COMPRESSION_JXL_DNG_1_7) &&
    5557         420 :                          EQUAL(pszKey, "COMPRESSION_REVERSIBILITY"))
    5558             :                 {
    5559         169 :                     if (EQUAL(pszValue, "LOSSLESS"))
    5560         169 :                         m_bJXLLossless = true;
    5561           0 :                     else if (EQUAL(pszValue, "LOSSY"))
    5562           0 :                         m_bJXLLossless = false;
    5563             :                 }
    5564         431 :                 else if ((m_nCompression == COMPRESSION_JXL ||
    5565         430 :                           m_nCompression == COMPRESSION_JXL_DNG_1_7) &&
    5566         251 :                          EQUAL(pszKey, "JXL_DISTANCE"))
    5567             :                 {
    5568          39 :                     const double dfVal = CPLAtof(pszValue);
    5569          39 :                     if (dfVal > 0 && dfVal <= 15)
    5570             :                     {
    5571          39 :                         m_oGTiffMDMD.SetMetadataItem(
    5572             :                             "COMPRESSION_REVERSIBILITY", "LOSSY",
    5573             :                             "IMAGE_STRUCTURE");
    5574          39 :                         m_bJXLLossless = false;
    5575          39 :                         m_fJXLDistance = static_cast<float>(dfVal);
    5576          39 :                     }
    5577             :                 }
    5578         392 :                 else if ((m_nCompression == COMPRESSION_JXL ||
    5579         391 :                           m_nCompression == COMPRESSION_JXL_DNG_1_7) &&
    5580         212 :                          EQUAL(pszKey, "JXL_ALPHA_DISTANCE"))
    5581             :                 {
    5582           4 :                     const double dfVal = CPLAtof(pszValue);
    5583           4 :                     if (dfVal > 0 && dfVal <= 15)
    5584             :                     {
    5585           0 :                         m_oGTiffMDMD.SetMetadataItem(
    5586             :                             "COMPRESSION_REVERSIBILITY", "LOSSY",
    5587             :                             "IMAGE_STRUCTURE");
    5588           0 :                         m_fJXLAlphaDistance = static_cast<float>(dfVal);
    5589           4 :                     }
    5590             :                 }
    5591         388 :                 else if ((m_nCompression == COMPRESSION_JXL ||
    5592         387 :                           m_nCompression == COMPRESSION_JXL_DNG_1_7) &&
    5593         208 :                          EQUAL(pszKey, "JXL_EFFORT"))
    5594             :                 {
    5595         208 :                     const int nEffort = atoi(pszValue);
    5596         208 :                     if (nEffort >= 1 && nEffort <= 9)
    5597             :                     {
    5598         208 :                         m_nJXLEffort = nEffort;
    5599         208 :                     }
    5600             :                 }
    5601             : #endif
    5602             :                 else
    5603             :                 {
    5604         180 :                     continue;
    5605             :                 }
    5606             :             }
    5607             : 
    5608       14428 :             bool bIsXMLOrJSON = false;
    5609             : 
    5610       14428 :             if (STARTS_WITH_CI(pszDomain, "xml:") ||
    5611       14426 :                 STARTS_WITH_CI(pszDomain, "json:"))
    5612          20 :                 bIsXMLOrJSON = true;
    5613             : 
    5614             :             // Note: this un-escaping should not normally be done, as the
    5615             :             // deserialization of the tree from XML also does it, so we end up
    5616             :             // width double XML escaping, but keep it for backward
    5617             :             // compatibility.
    5618             :             char *pszUnescapedValue =
    5619       14428 :                 CPLUnescapeString(pszValue, nullptr, CPLES_XML);
    5620       14420 :             if (nBand == 0)
    5621             :             {
    5622       10627 :                 if (bIsXMLOrJSON)
    5623             :                 {
    5624          20 :                     char *apszMD[2] = {pszUnescapedValue, nullptr};
    5625          20 :                     m_oGTiffMDMD.SetMetadata(apszMD, pszDomain);
    5626             :                 }
    5627             :                 else
    5628             :                 {
    5629       10607 :                     m_oGTiffMDMD.SetMetadataItem(pszKey, pszUnescapedValue,
    5630             :                                                  pszDomain);
    5631             :                 }
    5632             :             }
    5633             :             else
    5634             :             {
    5635             :                 GTiffRasterBand *poBand =
    5636        3793 :                     cpl::down_cast<GTiffRasterBand *>(GetRasterBand(nBand));
    5637        3792 :                 if (poBand != nullptr)
    5638             :                 {
    5639        3792 :                     if (EQUAL(pszRole, "scale"))
    5640             :                     {
    5641          40 :                         poBand->m_bHaveOffsetScale = true;
    5642          40 :                         poBand->m_dfScale = CPLAtofM(pszUnescapedValue);
    5643             :                     }
    5644        3752 :                     else if (EQUAL(pszRole, "offset"))
    5645             :                     {
    5646          40 :                         poBand->m_bHaveOffsetScale = true;
    5647          40 :                         poBand->m_dfOffset = CPLAtofM(pszUnescapedValue);
    5648             :                     }
    5649        3712 :                     else if (EQUAL(pszRole, "unittype"))
    5650             :                     {
    5651         304 :                         poBand->m_osUnitType = pszUnescapedValue;
    5652             :                     }
    5653        3408 :                     else if (EQUAL(pszRole, "description"))
    5654             :                     {
    5655          55 :                         poBand->m_osDescription = pszUnescapedValue;
    5656             :                     }
    5657        3353 :                     else if (EQUAL(pszRole, "colorinterp"))
    5658             :                     {
    5659         644 :                         if (EQUAL(pszUnescapedValue, "undefined"))
    5660         192 :                             poBand->m_eBandInterp = GCI_Undefined;
    5661             :                         else
    5662             :                         {
    5663         452 :                             poBand->m_eBandInterp =
    5664         452 :                                 GDALGetColorInterpretationByName(
    5665             :                                     pszUnescapedValue);
    5666         452 :                             if (poBand->m_eBandInterp == GCI_Undefined)
    5667             :                             {
    5668           1 :                                 poBand->m_oGTiffMDMD.SetMetadataItem(
    5669             :                                     "COLOR_INTERPRETATION", pszUnescapedValue);
    5670             :                             }
    5671             :                         }
    5672             :                     }
    5673             :                     else
    5674             :                     {
    5675        2709 :                         if (bIsXMLOrJSON)
    5676             :                         {
    5677           0 :                             char *apszMD[2] = {pszUnescapedValue, nullptr};
    5678           0 :                             poBand->m_oGTiffMDMD.SetMetadata(apszMD, pszDomain);
    5679             :                         }
    5680             :                         else
    5681             :                         {
    5682        2709 :                             poBand->m_oGTiffMDMD.SetMetadataItem(
    5683             :                                 pszKey, pszUnescapedValue, pszDomain);
    5684             :                         }
    5685             :                     }
    5686             :                 }
    5687             :             }
    5688       14421 :             CPLFree(pszUnescapedValue);
    5689             :         }
    5690             : 
    5691        3281 :         if (bMaxZErrorFound && !bMaxZErrorOverviewFound)
    5692             :         {
    5693          27 :             m_dfMaxZErrorOverview = m_dfMaxZError;
    5694             :         }
    5695             :     }
    5696             : 
    5697       27341 :     if (m_bStreamingIn)
    5698             :     {
    5699           7 :         toff_t *panOffsets = nullptr;
    5700           7 :         TIFFGetField(m_hTIFF,
    5701           7 :                      TIFFIsTiled(m_hTIFF) ? TIFFTAG_TILEOFFSETS
    5702             :                                           : TIFFTAG_STRIPOFFSETS,
    5703             :                      &panOffsets);
    5704           7 :         if (panOffsets)
    5705             :         {
    5706           7 :             int nBlockCount = TIFFIsTiled(m_hTIFF)
    5707           7 :                                   ? TIFFNumberOfTiles(m_hTIFF)
    5708           6 :                                   : TIFFNumberOfStrips(m_hTIFF);
    5709        1437 :             for (int i = 1; i < nBlockCount; ++i)
    5710             :             {
    5711        1431 :                 if (panOffsets[i] < panOffsets[i - 1])
    5712             :                 {
    5713           1 :                     m_oGTiffMDMD.SetMetadataItem("UNORDERED_BLOCKS", "YES",
    5714             :                                                  "TIFF");
    5715           1 :                     CPLDebug("GTIFF",
    5716             :                              "Offset of block %d is lower than previous block. "
    5717             :                              "Reader must be careful",
    5718             :                              i);
    5719           1 :                     break;
    5720             :                 }
    5721             :             }
    5722             :         }
    5723             :     }
    5724             : 
    5725       27341 :     if (m_nCompression == COMPRESSION_JPEG)
    5726             :     {
    5727         464 :         bool bHasQuantizationTable = false;
    5728         464 :         bool bHasHuffmanTable = false;
    5729             :         int nQuality =
    5730         464 :             GuessJPEGQuality(bHasQuantizationTable, bHasHuffmanTable);
    5731         464 :         if (nQuality > 0)
    5732             :         {
    5733         440 :             m_oGTiffMDMD.SetMetadataItem(
    5734             :                 "JPEG_QUALITY", CPLSPrintf("%d", nQuality), "IMAGE_STRUCTURE");
    5735         440 :             int nJpegTablesMode = JPEGTABLESMODE_QUANT;
    5736         440 :             if (bHasHuffmanTable)
    5737             :             {
    5738          91 :                 nJpegTablesMode |= JPEGTABLESMODE_HUFF;
    5739             :             }
    5740         440 :             m_oGTiffMDMD.SetMetadataItem("JPEGTABLESMODE",
    5741             :                                          CPLSPrintf("%d", nJpegTablesMode),
    5742             :                                          "IMAGE_STRUCTURE");
    5743             :         }
    5744         464 :         if (eAccess == GA_Update)
    5745             :         {
    5746         161 :             SetJPEGQualityAndTablesModeFromFile(nQuality, bHasQuantizationTable,
    5747             :                                                 bHasHuffmanTable);
    5748             :         }
    5749             :     }
    5750       30440 :     else if (eAccess == GA_Update &&
    5751        3563 :              m_oGTiffMDMD.GetMetadataItem("COMPRESSION_REVERSIBILITY",
    5752             :                                           "IMAGE_STRUCTURE") == nullptr)
    5753             :     {
    5754        3456 :         if (m_nCompression == COMPRESSION_WEBP)
    5755             :         {
    5756             :             const char *pszReversibility =
    5757          37 :                 GetMetadataItem("COMPRESSION_REVERSIBILITY", "IMAGE_STRUCTURE");
    5758          37 :             if (pszReversibility && strstr(pszReversibility, "LOSSLESS"))
    5759             :             {
    5760           2 :                 m_bWebPLossless = true;
    5761             :             }
    5762          35 :             else if (pszReversibility && strstr(pszReversibility, "LOSSY"))
    5763             :             {
    5764           8 :                 m_bWebPLossless = false;
    5765             :             }
    5766             :         }
    5767             : #ifdef HAVE_JXL
    5768        3419 :         else if (m_nCompression == COMPRESSION_JXL ||
    5769        3419 :                  m_nCompression == COMPRESSION_JXL_DNG_1_7)
    5770             :         {
    5771             :             const char *pszReversibility =
    5772          16 :                 GetMetadataItem("COMPRESSION_REVERSIBILITY", "IMAGE_STRUCTURE");
    5773          16 :             if (pszReversibility && strstr(pszReversibility, "LOSSLESS"))
    5774             :             {
    5775           2 :                 m_bJXLLossless = true;
    5776             :             }
    5777          14 :             else if (pszReversibility && strstr(pszReversibility, "LOSSY"))
    5778             :             {
    5779           6 :                 m_bJXLLossless = false;
    5780             :             }
    5781             :         }
    5782             : #endif
    5783             :     }
    5784             : 
    5785       27341 :     if (GTIFFSupportsPredictor(m_nCompression))
    5786             :     {
    5787        2079 :         uint16_t nPredictor = 0;
    5788        4126 :         if (TIFFGetField(m_hTIFF, TIFFTAG_PREDICTOR, &nPredictor) &&
    5789        2047 :             nPredictor > 1)
    5790             :         {
    5791          93 :             m_oGTiffMDMD.SetMetadataItem(
    5792             :                 "PREDICTOR", CPLSPrintf("%d", nPredictor), "IMAGE_STRUCTURE");
    5793             :         }
    5794             :     }
    5795             : 
    5796       27322 :     CPLAssert(m_bReadGeoTransform == bReadGeoTransform);
    5797       27322 :     CPLAssert(!m_bMetadataChanged);
    5798       27322 :     m_bMetadataChanged = false;
    5799             : 
    5800       27322 :     return CE_None;
    5801             : }
    5802             : 
    5803             : /************************************************************************/
    5804             : /*                         GetSiblingFiles()                            */
    5805             : /************************************************************************/
    5806             : 
    5807      344686 : CSLConstList GTiffDataset::GetSiblingFiles()
    5808             : {
    5809      344686 :     if (m_poBaseDS != nullptr)
    5810           0 :         return nullptr;
    5811             : 
    5812      344686 :     if (m_bHasGotSiblingFiles)
    5813             :     {
    5814      322512 :         return oOvManager.GetSiblingFiles();
    5815             :     }
    5816             : 
    5817       22174 :     m_bHasGotSiblingFiles = true;
    5818             :     const int nMaxFiles =
    5819       22174 :         atoi(CPLGetConfigOption("GDAL_READDIR_LIMIT_ON_OPEN", "1000"));
    5820       44347 :     const std::string osDirname = CPLGetDirnameSafe(m_osFilename.c_str());
    5821       44345 :     CPLStringList aosSiblingFiles(VSIReadDirEx(osDirname.c_str(), nMaxFiles));
    5822       22174 :     if (nMaxFiles > 0 && aosSiblingFiles.size() > nMaxFiles)
    5823             :     {
    5824           1 :         CPLDebug("GTiff", "GDAL_READDIR_LIMIT_ON_OPEN reached on %s",
    5825             :                  osDirname.c_str());
    5826           1 :         aosSiblingFiles.clear();
    5827             :     }
    5828       22173 :     oOvManager.TransferSiblingFiles(aosSiblingFiles.StealList());
    5829             : 
    5830       22172 :     return oOvManager.GetSiblingFiles();
    5831             : }
    5832             : 
    5833             : /************************************************************************/
    5834             : /*                   IdentifyAuthorizedGeoreferencingSources()          */
    5835             : /************************************************************************/
    5836             : 
    5837       29497 : void GTiffDataset::IdentifyAuthorizedGeoreferencingSources()
    5838             : {
    5839       29497 :     if (m_bHasIdentifiedAuthorizedGeoreferencingSources)
    5840       12708 :         return;
    5841       16789 :     m_bHasIdentifiedAuthorizedGeoreferencingSources = true;
    5842             :     CPLString osGeorefSources = CSLFetchNameValueDef(
    5843       16789 :         papszOpenOptions, "GEOREF_SOURCES",
    5844             :         CPLGetConfigOption("GDAL_GEOREF_SOURCES",
    5845       33578 :                            "PAM,INTERNAL,TABFILE,WORLDFILE,XML"));
    5846       16789 :     char **papszTokens = CSLTokenizeString2(osGeorefSources, ",", 0);
    5847       16789 :     m_nPAMGeorefSrcIndex =
    5848       16788 :         static_cast<signed char>(CSLFindString(papszTokens, "PAM"));
    5849       16788 :     m_nINTERNALGeorefSrcIndex =
    5850       16789 :         static_cast<signed char>(CSLFindString(papszTokens, "INTERNAL"));
    5851       16788 :     m_nTABFILEGeorefSrcIndex =
    5852       16788 :         static_cast<signed char>(CSLFindString(papszTokens, "TABFILE"));
    5853       16789 :     m_nWORLDFILEGeorefSrcIndex =
    5854       16788 :         static_cast<signed char>(CSLFindString(papszTokens, "WORLDFILE"));
    5855       16789 :     m_nXMLGeorefSrcIndex =
    5856       16789 :         static_cast<signed char>(CSLFindString(papszTokens, "XML"));
    5857       16789 :     CSLDestroy(papszTokens);
    5858             : }
    5859             : 
    5860             : /************************************************************************/
    5861             : /*                     LoadGeoreferencingAndPamIfNeeded()               */
    5862             : /************************************************************************/
    5863             : 
    5864     3485300 : void GTiffDataset::LoadGeoreferencingAndPamIfNeeded()
    5865             : 
    5866             : {
    5867     3485300 :     if (!m_bReadGeoTransform && !m_bLoadPam)
    5868     3468550 :         return;
    5869       16749 :     if (m_poBaseDS != nullptr)
    5870           0 :         return;
    5871             : 
    5872       16749 :     IdentifyAuthorizedGeoreferencingSources();
    5873             : 
    5874             :     /* -------------------------------------------------------------------- */
    5875             :     /*      Get the transform or gcps from the GeoTIFF file.                */
    5876             :     /* -------------------------------------------------------------------- */
    5877       16756 :     if (m_bReadGeoTransform)
    5878             :     {
    5879       16756 :         m_bReadGeoTransform = false;
    5880             : 
    5881       16756 :         char *pszTabWKT = nullptr;
    5882       16756 :         double *padfTiePoints = nullptr;
    5883       16756 :         double *padfScale = nullptr;
    5884       16756 :         double *padfMatrix = nullptr;
    5885       16756 :         uint16_t nCount = 0;
    5886       16756 :         bool bPixelIsPoint = false;
    5887       16756 :         unsigned short nRasterType = 0;
    5888       16756 :         bool bPointGeoIgnore = false;
    5889             : 
    5890       33512 :         std::set<signed char> aoSetPriorities;
    5891       16756 :         if (m_nINTERNALGeorefSrcIndex >= 0)
    5892       16730 :             aoSetPriorities.insert(m_nINTERNALGeorefSrcIndex);
    5893       16756 :         if (m_nTABFILEGeorefSrcIndex >= 0)
    5894       16704 :             aoSetPriorities.insert(m_nTABFILEGeorefSrcIndex);
    5895       16757 :         if (m_nWORLDFILEGeorefSrcIndex >= 0)
    5896       16720 :             aoSetPriorities.insert(m_nWORLDFILEGeorefSrcIndex);
    5897       34343 :         for (const auto nIndex : aoSetPriorities)
    5898             :         {
    5899       28472 :             if (m_nINTERNALGeorefSrcIndex == nIndex)
    5900             :             {
    5901             :                 GTIF *psGTIF =
    5902       16722 :                     GTiffDataset::GTIFNew(m_hTIFF);  // How expensive this is?
    5903             : 
    5904       16723 :                 if (psGTIF)
    5905             :                 {
    5906       16723 :                     if (GDALGTIFKeyGetSHORT(psGTIF, GTRasterTypeGeoKey,
    5907       26651 :                                             &nRasterType, 0, 1) == 1 &&
    5908        9928 :                         nRasterType == static_cast<short>(RasterPixelIsPoint))
    5909             :                     {
    5910         277 :                         bPixelIsPoint = true;
    5911         277 :                         bPointGeoIgnore = CPLTestBool(CPLGetConfigOption(
    5912             :                             "GTIFF_POINT_GEO_IGNORE", "FALSE"));
    5913             :                     }
    5914             : 
    5915       16723 :                     GTIFFree(psGTIF);
    5916             :                 }
    5917             : 
    5918       16723 :                 m_gt = GDALGeoTransform();
    5919             : 
    5920       16722 :                 uint16_t nCountScale = 0;
    5921       16722 :                 if (TIFFGetField(m_hTIFF, TIFFTAG_GEOPIXELSCALE, &nCountScale,
    5922       10704 :                                  &padfScale) &&
    5923       27428 :                     nCountScale >= 2 && padfScale[0] != 0.0 &&
    5924       10705 :                     padfScale[1] != 0.0)
    5925             :                 {
    5926       10705 :                     m_gt[1] = padfScale[0];
    5927       10705 :                     if (padfScale[1] < 0)
    5928             :                     {
    5929           3 :                         const char *pszOptionVal = CPLGetConfigOption(
    5930             :                             "GTIFF_HONOUR_NEGATIVE_SCALEY", nullptr);
    5931           3 :                         if (pszOptionVal == nullptr)
    5932             :                         {
    5933           1 :                             ReportError(
    5934             :                                 CE_Warning, CPLE_AppDefined,
    5935             :                                 "File with negative value for ScaleY in "
    5936             :                                 "GeoPixelScale tag. This is rather "
    5937             :                                 "unusual. GDAL, contrary to the GeoTIFF "
    5938             :                                 "specification, assumes that the file "
    5939             :                                 "was intended to be north-up, and will "
    5940             :                                 "treat this file as if ScaleY was "
    5941             :                                 "positive. You may override this behavior "
    5942             :                                 "by setting the GTIFF_HONOUR_NEGATIVE_SCALEY "
    5943             :                                 "configuration option to YES");
    5944           1 :                             m_gt[5] = padfScale[1];
    5945             :                         }
    5946           2 :                         else if (CPLTestBool(pszOptionVal))
    5947             :                         {
    5948           1 :                             m_gt[5] = -padfScale[1];
    5949             :                         }
    5950             :                         else
    5951             :                         {
    5952           1 :                             m_gt[5] = padfScale[1];
    5953             :                         }
    5954             :                     }
    5955             :                     else
    5956             :                     {
    5957       10702 :                         m_gt[5] = -padfScale[1];
    5958             :                     }
    5959             : 
    5960       10704 :                     if (TIFFGetField(m_hTIFF, TIFFTAG_GEOTIEPOINTS, &nCount,
    5961       21408 :                                      &padfTiePoints) &&
    5962       10704 :                         nCount >= 6)
    5963             :                     {
    5964       10704 :                         m_gt[0] = padfTiePoints[3] - padfTiePoints[0] * m_gt[1];
    5965       10704 :                         m_gt[3] = padfTiePoints[4] - padfTiePoints[1] * m_gt[5];
    5966             : 
    5967       10704 :                         if (bPixelIsPoint && !bPointGeoIgnore)
    5968             :                         {
    5969         240 :                             m_gt[0] -= (m_gt[1] * 0.5 + m_gt[2] * 0.5);
    5970         240 :                             m_gt[3] -= (m_gt[4] * 0.5 + m_gt[5] * 0.5);
    5971             :                         }
    5972             : 
    5973       10704 :                         m_bGeoTransformValid = true;
    5974       10704 :                         m_nGeoTransformGeorefSrcIndex = nIndex;
    5975             : 
    5976       17770 :                         if (nCountScale >= 3 && GetRasterCount() == 1 &&
    5977        7066 :                             (padfScale[2] != 0.0 || padfTiePoints[2] != 0.0 ||
    5978        7040 :                              padfTiePoints[5] != 0.0))
    5979             :                         {
    5980          28 :                             LookForProjection();
    5981          28 :                             if (!m_oSRS.IsEmpty() && m_oSRS.IsVertical())
    5982             :                             {
    5983             :                                 /* modelTiePointTag = (pixel, line, z0, X, Y,
    5984             :                                  * Z0) */
    5985             :                                 /* thus Z(some_point) = (z(some_point) - z0) *
    5986             :                                  * scaleZ + Z0 */
    5987             :                                 /* equivalently written as */
    5988             :                                 /* Z(some_point) = z(some_point) * scaleZ +
    5989             :                                  * offsetZ with */
    5990             :                                 /* offsetZ = - z0 * scaleZ + Z0 */
    5991          18 :                                 double dfScale = padfScale[2];
    5992          18 :                                 double dfOffset = -padfTiePoints[2] * dfScale +
    5993          18 :                                                   padfTiePoints[5];
    5994             :                                 GTiffRasterBand *poBand =
    5995          18 :                                     cpl::down_cast<GTiffRasterBand *>(
    5996             :                                         GetRasterBand(1));
    5997          18 :                                 poBand->m_bHaveOffsetScale = true;
    5998          18 :                                 poBand->m_dfScale = dfScale;
    5999          18 :                                 poBand->m_dfOffset = dfOffset;
    6000             :                             }
    6001             :                         }
    6002             :                     }
    6003             :                 }
    6004             : 
    6005        6018 :                 else if (TIFFGetField(m_hTIFF, TIFFTAG_GEOTRANSMATRIX, &nCount,
    6006        6149 :                                       &padfMatrix) &&
    6007         131 :                          nCount == 16)
    6008             :                 {
    6009         131 :                     m_gt[0] = padfMatrix[3];
    6010         131 :                     m_gt[1] = padfMatrix[0];
    6011         131 :                     m_gt[2] = padfMatrix[1];
    6012         131 :                     m_gt[3] = padfMatrix[7];
    6013         131 :                     m_gt[4] = padfMatrix[4];
    6014         131 :                     m_gt[5] = padfMatrix[5];
    6015             : 
    6016         131 :                     if (bPixelIsPoint && !bPointGeoIgnore)
    6017             :                     {
    6018           6 :                         m_gt[0] -= m_gt[1] * 0.5 + m_gt[2] * 0.5;
    6019           6 :                         m_gt[3] -= m_gt[4] * 0.5 + m_gt[5] * 0.5;
    6020             :                     }
    6021             : 
    6022         131 :                     m_bGeoTransformValid = true;
    6023         131 :                     m_nGeoTransformGeorefSrcIndex = nIndex;
    6024             :                 }
    6025       16722 :                 if (m_bGeoTransformValid)
    6026       10836 :                     break;
    6027             :             }
    6028             : 
    6029             :             /* --------------------------------------------------------------------
    6030             :              */
    6031             :             /*      Otherwise try looking for a .tab, .tfw, .tifw or .wld file.
    6032             :              */
    6033             :             /* --------------------------------------------------------------------
    6034             :              */
    6035       17636 :             if (m_nTABFILEGeorefSrcIndex == nIndex)
    6036             :             {
    6037        5871 :                 char *pszGeorefFilename = nullptr;
    6038             : 
    6039        5871 :                 CSLConstList papszSiblingFiles = GetSiblingFiles();
    6040             : 
    6041             :                 // Begin with .tab since it can also have projection info.
    6042        5871 :                 int nGCPCount = 0;
    6043        5871 :                 GDAL_GCP *pasGCPList = nullptr;
    6044        5871 :                 const int bTabFileOK = GDALReadTabFile2(
    6045             :                     m_osFilename.c_str(), m_gt.data(), &pszTabWKT, &nGCPCount,
    6046             :                     &pasGCPList, papszSiblingFiles, &pszGeorefFilename);
    6047             : 
    6048        5871 :                 if (bTabFileOK)
    6049             :                 {
    6050          14 :                     m_nGeoTransformGeorefSrcIndex = nIndex;
    6051             :                     // if( pszTabWKT )
    6052             :                     // {
    6053             :                     //     m_nProjectionGeorefSrcIndex = nIndex;
    6054             :                     // }
    6055          14 :                     m_aoGCPs = gdal::GCP::fromC(pasGCPList, nGCPCount);
    6056          14 :                     if (m_aoGCPs.empty())
    6057             :                     {
    6058          14 :                         m_bGeoTransformValid = true;
    6059             :                     }
    6060             :                 }
    6061             : 
    6062        5871 :                 if (nGCPCount)
    6063             :                 {
    6064           0 :                     GDALDeinitGCPs(nGCPCount, pasGCPList);
    6065           0 :                     CPLFree(pasGCPList);
    6066             :                 }
    6067             : 
    6068        5871 :                 if (pszGeorefFilename)
    6069             :                 {
    6070          14 :                     CPLFree(m_pszGeorefFilename);
    6071          14 :                     m_pszGeorefFilename = pszGeorefFilename;
    6072          14 :                     pszGeorefFilename = nullptr;
    6073             :                 }
    6074        5871 :                 if (m_bGeoTransformValid)
    6075          14 :                     break;
    6076             :             }
    6077             : 
    6078       17622 :             if (m_nWORLDFILEGeorefSrcIndex == nIndex)
    6079             :             {
    6080        5879 :                 char *pszGeorefFilename = nullptr;
    6081             : 
    6082        5879 :                 CSLConstList papszSiblingFiles = GetSiblingFiles();
    6083             : 
    6084        5879 :                 m_bGeoTransformValid = CPL_TO_BOOL(
    6085        5879 :                     GDALReadWorldFile2(m_osFilename.c_str(), nullptr, m_gt,
    6086             :                                        papszSiblingFiles, &pszGeorefFilename));
    6087             : 
    6088        5879 :                 if (!m_bGeoTransformValid)
    6089             :                 {
    6090        5847 :                     m_bGeoTransformValid = CPL_TO_BOOL(GDALReadWorldFile2(
    6091        5847 :                         m_osFilename.c_str(), "wld", m_gt, papszSiblingFiles,
    6092             :                         &pszGeorefFilename));
    6093             :                 }
    6094        5879 :                 if (m_bGeoTransformValid)
    6095          37 :                     m_nGeoTransformGeorefSrcIndex = nIndex;
    6096             : 
    6097        5879 :                 if (pszGeorefFilename)
    6098             :                 {
    6099          37 :                     CPLFree(m_pszGeorefFilename);
    6100          37 :                     m_pszGeorefFilename = pszGeorefFilename;
    6101          37 :                     pszGeorefFilename = nullptr;
    6102             :                 }
    6103        5879 :                 if (m_bGeoTransformValid)
    6104          37 :                     break;
    6105             :             }
    6106             :         }
    6107             : 
    6108             :         /* --------------------------------------------------------------------
    6109             :          */
    6110             :         /*      Check for GCPs. */
    6111             :         /* --------------------------------------------------------------------
    6112             :          */
    6113       50245 :         if (m_nINTERNALGeorefSrcIndex >= 0 &&
    6114       16731 :             TIFFGetField(m_hTIFF, TIFFTAG_GEOTIEPOINTS, &nCount,
    6115       33488 :                          &padfTiePoints) &&
    6116       10841 :             !m_bGeoTransformValid)
    6117             :         {
    6118         136 :             m_aoGCPs.clear();
    6119         136 :             const int nNewGCPCount = nCount / 6;
    6120         640 :             for (int iGCP = 0; iGCP < nNewGCPCount; ++iGCP)
    6121             :             {
    6122           0 :                 m_aoGCPs.emplace_back(CPLSPrintf("%d", iGCP + 1), "",
    6123         504 :                                       /* pixel = */ padfTiePoints[iGCP * 6 + 0],
    6124         504 :                                       /* line = */ padfTiePoints[iGCP * 6 + 1],
    6125         504 :                                       /* X = */ padfTiePoints[iGCP * 6 + 3],
    6126         504 :                                       /* Y = */ padfTiePoints[iGCP * 6 + 4],
    6127         504 :                                       /* Z = */ padfTiePoints[iGCP * 6 + 5]);
    6128             : 
    6129         504 :                 if (bPixelIsPoint && !bPointGeoIgnore)
    6130             :                 {
    6131          48 :                     m_aoGCPs.back().Pixel() += 0.5;
    6132          48 :                     m_aoGCPs.back().Line() += 0.5;
    6133             :                 }
    6134             :             }
    6135         136 :             m_nGeoTransformGeorefSrcIndex = m_nINTERNALGeorefSrcIndex;
    6136             :         }
    6137             : 
    6138             :         /* --------------------------------------------------------------------
    6139             :          */
    6140             :         /*      Did we find a tab file?  If so we will use its coordinate */
    6141             :         /*      system and give it precedence. */
    6142             :         /* --------------------------------------------------------------------
    6143             :          */
    6144       16757 :         if (pszTabWKT != nullptr && m_oSRS.IsEmpty())
    6145             :         {
    6146          14 :             m_oSRS.importFromWkt(pszTabWKT);
    6147          14 :             m_bLookedForProjection = true;
    6148             :         }
    6149             : 
    6150       16757 :         CPLFree(pszTabWKT);
    6151             :     }
    6152             : 
    6153       16757 :     if (m_bLoadPam && m_nPAMGeorefSrcIndex >= 0)
    6154             :     {
    6155             :         /* --------------------------------------------------------------------
    6156             :          */
    6157             :         /*      Initialize any PAM information. */
    6158             :         /* --------------------------------------------------------------------
    6159             :          */
    6160       14680 :         CPLAssert(!m_bColorProfileMetadataChanged);
    6161       14680 :         CPLAssert(!m_bMetadataChanged);
    6162       14680 :         CPLAssert(!m_bGeoTIFFInfoChanged);
    6163       14680 :         CPLAssert(!m_bNoDataChanged);
    6164             : 
    6165             :         // We must absolutely unset m_bLoadPam now, otherwise calling
    6166             :         // GetFileList() on a .tif with a .aux will result in an (almost)
    6167             :         // endless sequence of calls.
    6168       14680 :         m_bLoadPam = false;
    6169             : 
    6170       14680 :         TryLoadXML(GetSiblingFiles());
    6171       14682 :         ApplyPamInfo();
    6172             : 
    6173       14680 :         m_bColorProfileMetadataChanged = false;
    6174       14680 :         m_bMetadataChanged = false;
    6175       14680 :         m_bGeoTIFFInfoChanged = false;
    6176       14680 :         m_bNoDataChanged = false;
    6177             :     }
    6178       16757 :     m_bLoadPam = false;
    6179             : }
    6180             : 
    6181             : /************************************************************************/
    6182             : /*                          GetSpatialRef()                             */
    6183             : /************************************************************************/
    6184             : 
    6185       20237 : const OGRSpatialReference *GTiffDataset::GetSpatialRef() const
    6186             : 
    6187             : {
    6188       20237 :     const_cast<GTiffDataset *>(this)->LoadGeoreferencingAndPamIfNeeded();
    6189       20237 :     if (m_aoGCPs.empty())
    6190             :     {
    6191       19711 :         const_cast<GTiffDataset *>(this)->LookForProjection();
    6192             :     }
    6193             : 
    6194       20237 :     return m_aoGCPs.empty() && !m_oSRS.IsEmpty() ? &m_oSRS : nullptr;
    6195             : }
    6196             : 
    6197             : /************************************************************************/
    6198             : /*                          GetGeoTransform()                           */
    6199             : /************************************************************************/
    6200             : 
    6201      319355 : CPLErr GTiffDataset::GetGeoTransform(GDALGeoTransform &gt) const
    6202             : 
    6203             : {
    6204      319355 :     const_cast<GTiffDataset *>(this)->LoadGeoreferencingAndPamIfNeeded();
    6205             : 
    6206      319353 :     gt = m_gt;
    6207             : 
    6208      319353 :     if (!m_bGeoTransformValid)
    6209      303831 :         return CE_Failure;
    6210             : 
    6211             :     // Same logic as in the .gtx driver, for the benefit of
    6212             :     // GDALOpenVerticalShiftGrid() when used with PROJ-data's US geoids.
    6213       15522 :     if (CPLFetchBool(papszOpenOptions, "SHIFT_ORIGIN_IN_MINUS_180_PLUS_180",
    6214             :                      false))
    6215             :     {
    6216           0 :         if (gt[0] < -180.0 - gt[1])
    6217           0 :             gt[0] += 360.0;
    6218           0 :         else if (gt[0] > 180.0)
    6219           1 :             gt[0] -= 360.0;
    6220             :     }
    6221             : 
    6222       15521 :     return CE_None;
    6223             : }
    6224             : 
    6225             : /************************************************************************/
    6226             : /*                            GetGCPCount()                             */
    6227             : /************************************************************************/
    6228             : 
    6229        7524 : int GTiffDataset::GetGCPCount()
    6230             : 
    6231             : {
    6232        7524 :     LoadGeoreferencingAndPamIfNeeded();
    6233             : 
    6234        7524 :     return static_cast<int>(m_aoGCPs.size());
    6235             : }
    6236             : 
    6237             : /************************************************************************/
    6238             : /*                          GetGCPSpatialRef()                          */
    6239             : /************************************************************************/
    6240             : 
    6241         626 : const OGRSpatialReference *GTiffDataset::GetGCPSpatialRef() const
    6242             : 
    6243             : {
    6244         626 :     const_cast<GTiffDataset *>(this)->LoadGeoreferencingAndPamIfNeeded();
    6245             : 
    6246         626 :     if (!m_aoGCPs.empty())
    6247             :     {
    6248         153 :         const_cast<GTiffDataset *>(this)->LookForProjection();
    6249             :     }
    6250         626 :     return !m_aoGCPs.empty() && !m_oSRS.IsEmpty() ? &m_oSRS : nullptr;
    6251             : }
    6252             : 
    6253             : /************************************************************************/
    6254             : /*                               GetGCPs()                              */
    6255             : /************************************************************************/
    6256             : 
    6257         492 : const GDAL_GCP *GTiffDataset::GetGCPs()
    6258             : 
    6259             : {
    6260         492 :     LoadGeoreferencingAndPamIfNeeded();
    6261             : 
    6262         492 :     return gdal::GCP::c_ptr(m_aoGCPs);
    6263             : }
    6264             : 
    6265             : /************************************************************************/
    6266             : /*                      GetMetadataDomainList()                         */
    6267             : /************************************************************************/
    6268             : 
    6269          33 : char **GTiffDataset::GetMetadataDomainList()
    6270             : {
    6271          33 :     LoadGeoreferencingAndPamIfNeeded();
    6272             : 
    6273          33 :     char **papszDomainList = CSLDuplicate(m_oGTiffMDMD.GetDomainList());
    6274          33 :     char **papszBaseList = GDALDataset::GetMetadataDomainList();
    6275             : 
    6276          33 :     const int nbBaseDomains = CSLCount(papszBaseList);
    6277             : 
    6278          66 :     for (int domainId = 0; domainId < nbBaseDomains; ++domainId)
    6279             :     {
    6280          33 :         if (CSLFindString(papszDomainList, papszBaseList[domainId]) < 0)
    6281             :         {
    6282             :             papszDomainList =
    6283          33 :                 CSLAddString(papszDomainList, papszBaseList[domainId]);
    6284             :         }
    6285             :     }
    6286             : 
    6287          33 :     CSLDestroy(papszBaseList);
    6288             : 
    6289          33 :     return BuildMetadataDomainList(papszDomainList, TRUE, "",
    6290             :                                    "ProxyOverviewRequest", MD_DOMAIN_RPC,
    6291             :                                    MD_DOMAIN_IMD, "SUBDATASETS", "EXIF",
    6292          33 :                                    "xml:XMP", "COLOR_PROFILE", nullptr);
    6293             : }
    6294             : 
    6295             : /************************************************************************/
    6296             : /*                            GetMetadata()                             */
    6297             : /************************************************************************/
    6298             : 
    6299       35228 : char **GTiffDataset::GetMetadata(const char *pszDomain)
    6300             : 
    6301             : {
    6302       35228 :     if (pszDomain != nullptr && EQUAL(pszDomain, "IMAGE_STRUCTURE"))
    6303             :     {
    6304         133 :         GTiffDataset::GetMetadataItem("COMPRESSION_REVERSIBILITY", pszDomain);
    6305             :     }
    6306             :     else
    6307             :     {
    6308       35095 :         LoadGeoreferencingAndPamIfNeeded();
    6309             :     }
    6310             : 
    6311       35228 :     if (pszDomain != nullptr && EQUAL(pszDomain, "ProxyOverviewRequest"))
    6312          33 :         return GDALPamDataset::GetMetadata(pszDomain);
    6313             : 
    6314       35195 :     if (pszDomain != nullptr && EQUAL(pszDomain, "DERIVED_SUBDATASETS"))
    6315             :     {
    6316           6 :         return GDALDataset::GetMetadata(pszDomain);
    6317             :     }
    6318             : 
    6319       35189 :     else if (pszDomain != nullptr && (EQUAL(pszDomain, MD_DOMAIN_RPC) ||
    6320       22258 :                                       EQUAL(pszDomain, MD_DOMAIN_IMD) ||
    6321       15892 :                                       EQUAL(pszDomain, MD_DOMAIN_IMAGERY)))
    6322       18631 :         LoadMetadata();
    6323             : 
    6324       16558 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "SUBDATASETS"))
    6325        1279 :         ScanDirectories();
    6326             : 
    6327       15279 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "EXIF"))
    6328          58 :         LoadEXIFMetadata();
    6329             : 
    6330       15221 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "COLOR_PROFILE"))
    6331          48 :         LoadICCProfile();
    6332             : 
    6333       15173 :     else if (pszDomain == nullptr || EQUAL(pszDomain, ""))
    6334        7860 :         LoadMDAreaOrPoint();  // To set GDALMD_AREA_OR_POINT.
    6335             : 
    6336       35189 :     return m_oGTiffMDMD.GetMetadata(pszDomain);
    6337             : }
    6338             : 
    6339             : /************************************************************************/
    6340             : /*                          GetMetadataItem()                           */
    6341             : /************************************************************************/
    6342             : 
    6343      148102 : const char *GTiffDataset::GetMetadataItem(const char *pszName,
    6344             :                                           const char *pszDomain)
    6345             : 
    6346             : {
    6347      148102 :     if (pszDomain != nullptr && EQUAL(pszDomain, "IMAGE_STRUCTURE"))
    6348             :     {
    6349      216604 :         if ((m_nCompression == COMPRESSION_WEBP ||
    6350       70818 :              m_nCompression == COMPRESSION_JXL ||
    6351       70817 :              m_nCompression == COMPRESSION_JXL_DNG_1_7) &&
    6352      143788 :             EQUAL(pszName, "COMPRESSION_REVERSIBILITY") &&
    6353          77 :             m_oGTiffMDMD.GetMetadataItem("COMPRESSION_REVERSIBILITY",
    6354             :                                          "IMAGE_STRUCTURE") == nullptr)
    6355             :         {
    6356          60 :             const char *pszDriverName =
    6357          60 :                 m_nCompression == COMPRESSION_WEBP ? "WEBP" : "JPEGXL";
    6358          60 :             auto poTileDriver = GDALGetDriverByName(pszDriverName);
    6359          60 :             if (poTileDriver)
    6360             :             {
    6361          60 :                 vsi_l_offset nOffset = 0;
    6362          60 :                 vsi_l_offset nSize = 0;
    6363          60 :                 IsBlockAvailable(0, &nOffset, &nSize, nullptr);
    6364          60 :                 if (nSize > 0)
    6365             :                 {
    6366             :                     const std::string osSubfile(
    6367             :                         CPLSPrintf("/vsisubfile/" CPL_FRMT_GUIB "_%d,%s",
    6368             :                                    static_cast<GUIntBig>(nOffset),
    6369          25 :                                    static_cast<int>(std::min(
    6370          50 :                                        static_cast<vsi_l_offset>(1024), nSize)),
    6371          75 :                                    m_osFilename.c_str()));
    6372          25 :                     const char *const apszDrivers[] = {pszDriverName, nullptr};
    6373             :                     auto poWebPDataset =
    6374             :                         std::unique_ptr<GDALDataset>(GDALDataset::Open(
    6375          50 :                             osSubfile.c_str(), GDAL_OF_RASTER, apszDrivers));
    6376          25 :                     if (poWebPDataset)
    6377             :                     {
    6378             :                         const char *pszReversibility =
    6379          25 :                             poWebPDataset->GetMetadataItem(
    6380          25 :                                 "COMPRESSION_REVERSIBILITY", "IMAGE_STRUCTURE");
    6381          25 :                         if (pszReversibility)
    6382          25 :                             m_oGTiffMDMD.SetMetadataItem(
    6383             :                                 "COMPRESSION_REVERSIBILITY", pszReversibility,
    6384             :                                 "IMAGE_STRUCTURE");
    6385             :                     }
    6386             :                 }
    6387             :             }
    6388       72893 :         }
    6389             :     }
    6390             :     else
    6391             :     {
    6392       75209 :         LoadGeoreferencingAndPamIfNeeded();
    6393             :     }
    6394             : 
    6395      148104 :     if (pszDomain != nullptr && EQUAL(pszDomain, "ProxyOverviewRequest"))
    6396             :     {
    6397           4 :         return GDALPamDataset::GetMetadataItem(pszName, pszDomain);
    6398             :     }
    6399      148100 :     else if (pszDomain != nullptr && (EQUAL(pszDomain, MD_DOMAIN_RPC) ||
    6400      148046 :                                       EQUAL(pszDomain, MD_DOMAIN_IMD) ||
    6401      148044 :                                       EQUAL(pszDomain, MD_DOMAIN_IMAGERY)))
    6402             :     {
    6403          51 :         LoadMetadata();
    6404             :     }
    6405      148049 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "SUBDATASETS"))
    6406             :     {
    6407           0 :         ScanDirectories();
    6408             :     }
    6409      148049 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "EXIF"))
    6410             :     {
    6411           1 :         LoadEXIFMetadata();
    6412             :     }
    6413      148048 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "COLOR_PROFILE"))
    6414             :     {
    6415        5224 :         LoadICCProfile();
    6416             :     }
    6417      142824 :     else if ((pszDomain == nullptr || EQUAL(pszDomain, "")) &&
    6418       63410 :              pszName != nullptr && EQUAL(pszName, GDALMD_AREA_OR_POINT))
    6419             :     {
    6420        8619 :         LoadMDAreaOrPoint();  // To set GDALMD_AREA_OR_POINT.
    6421             :     }
    6422      134205 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "_DEBUG_") &&
    6423             :              pszName != nullptr)
    6424             :     {
    6425             : #ifdef DEBUG_REACHED_VIRTUAL_MEM_IO
    6426             :         if (EQUAL(pszName, "UNREACHED_VIRTUALMEMIO_CODE_PATH"))
    6427             :         {
    6428             :             CPLString osMissing;
    6429             :             for (int i = 0;
    6430             :                  i < static_cast<int>(CPL_ARRAYSIZE(anReachedVirtualMemIO));
    6431             :                  ++i)
    6432             :             {
    6433             :                 if (!anReachedVirtualMemIO[i])
    6434             :                 {
    6435             :                     if (!osMissing.empty())
    6436             :                         osMissing += ",";
    6437             :                     osMissing += CPLSPrintf("%d", i);
    6438             :                 }
    6439             :             }
    6440             :             return (osMissing.size()) ? CPLSPrintf("%s", osMissing.c_str())
    6441             :                                       : nullptr;
    6442             :         }
    6443             :         else
    6444             : #endif
    6445          79 :             if (EQUAL(pszName, "TIFFTAG_EXTRASAMPLES"))
    6446             :         {
    6447          18 :             CPLString osRet;
    6448          18 :             uint16_t *v = nullptr;
    6449          18 :             uint16_t count = 0;
    6450             : 
    6451          18 :             if (TIFFGetField(m_hTIFF, TIFFTAG_EXTRASAMPLES, &count, &v))
    6452             :             {
    6453          53 :                 for (int i = 0; i < static_cast<int>(count); ++i)
    6454             :                 {
    6455          37 :                     if (i > 0)
    6456          21 :                         osRet += ",";
    6457          37 :                     osRet += CPLSPrintf("%d", v[i]);
    6458             :                 }
    6459             :             }
    6460          18 :             return (osRet.size()) ? CPLSPrintf("%s", osRet.c_str()) : nullptr;
    6461             :         }
    6462          61 :         else if (EQUAL(pszName, "TIFFTAG_PHOTOMETRIC"))
    6463             :         {
    6464           6 :             return CPLSPrintf("%d", m_nPhotometric);
    6465             :         }
    6466             : 
    6467          55 :         else if (EQUAL(pszName, "TIFFTAG_GDAL_METADATA"))
    6468             :         {
    6469           7 :             char *pszText = nullptr;
    6470           7 :             if (!TIFFGetField(m_hTIFF, TIFFTAG_GDAL_METADATA, &pszText))
    6471           6 :                 return nullptr;
    6472             : 
    6473           1 :             return pszText;
    6474             :         }
    6475          48 :         else if (EQUAL(pszName, "HAS_USED_READ_ENCODED_API"))
    6476             :         {
    6477           6 :             return m_bHasUsedReadEncodedAPI ? "1" : "0";
    6478             :         }
    6479          42 :         else if (EQUAL(pszName, "WEBP_LOSSLESS"))
    6480             :         {
    6481           6 :             return m_bWebPLossless ? "1" : "0";
    6482             :         }
    6483          36 :         else if (EQUAL(pszName, "WEBP_LEVEL"))
    6484             :         {
    6485           2 :             return CPLSPrintf("%d", m_nWebPLevel);
    6486             :         }
    6487          34 :         else if (EQUAL(pszName, "MAX_Z_ERROR"))
    6488             :         {
    6489          10 :             return CPLSPrintf("%f", m_dfMaxZError);
    6490             :         }
    6491          24 :         else if (EQUAL(pszName, "MAX_Z_ERROR_OVERVIEW"))
    6492             :         {
    6493           6 :             return CPLSPrintf("%f", m_dfMaxZErrorOverview);
    6494             :         }
    6495             : #if HAVE_JXL
    6496          18 :         else if (EQUAL(pszName, "JXL_LOSSLESS"))
    6497             :         {
    6498           9 :             return m_bJXLLossless ? "1" : "0";
    6499             :         }
    6500           9 :         else if (EQUAL(pszName, "JXL_DISTANCE"))
    6501             :         {
    6502           4 :             return CPLSPrintf("%f", static_cast<double>(m_fJXLDistance));
    6503             :         }
    6504           5 :         else if (EQUAL(pszName, "JXL_ALPHA_DISTANCE"))
    6505             :         {
    6506           0 :             return CPLSPrintf("%f", static_cast<double>(m_fJXLAlphaDistance));
    6507             :         }
    6508           5 :         else if (EQUAL(pszName, "JXL_EFFORT"))
    6509             :         {
    6510           4 :             return CPLSPrintf("%u", m_nJXLEffort);
    6511             :         }
    6512             : #endif
    6513           1 :         return nullptr;
    6514             :     }
    6515             : 
    6516      134126 :     else if (pszDomain != nullptr && EQUAL(pszDomain, "TIFF") &&
    6517             :              pszName != nullptr)
    6518             :     {
    6519           7 :         if (EQUAL(pszName, "GDAL_STRUCTURAL_METADATA"))
    6520             :         {
    6521           2 :             const auto nOffset = VSIFTellL(m_fpL);
    6522           2 :             VSIFSeekL(m_fpL, 0, SEEK_SET);
    6523             :             GByte abyData[1024];
    6524           2 :             size_t nRead = VSIFReadL(abyData, 1, sizeof(abyData) - 1, m_fpL);
    6525           2 :             abyData[nRead] = 0;
    6526           2 :             VSIFSeekL(m_fpL, nOffset, SEEK_SET);
    6527           2 :             if (nRead > 4)
    6528             :             {
    6529           2 :                 const int nOffsetOfStructuralMetadata =
    6530           2 :                     (abyData[2] == 0x2B || abyData[3] == 0x2B) ? 16 : 8;
    6531           2 :                 const int nSizePatternLen =
    6532             :                     static_cast<int>(strlen("XXXXXX bytes\n"));
    6533           2 :                 if (nRead > nOffsetOfStructuralMetadata +
    6534           2 :                                 strlen("GDAL_STRUCTURAL_METADATA_SIZE=") +
    6535           2 :                                 nSizePatternLen &&
    6536           2 :                     memcmp(abyData + nOffsetOfStructuralMetadata,
    6537             :                            "GDAL_STRUCTURAL_METADATA_SIZE=",
    6538             :                            strlen("GDAL_STRUCTURAL_METADATA_SIZE=")) == 0)
    6539             :                 {
    6540           1 :                     char *pszStructuralMD = reinterpret_cast<char *>(
    6541           1 :                         abyData + nOffsetOfStructuralMetadata);
    6542             :                     const int nLenMD =
    6543           1 :                         atoi(pszStructuralMD +
    6544             :                              strlen("GDAL_STRUCTURAL_METADATA_SIZE="));
    6545           1 :                     if (nOffsetOfStructuralMetadata +
    6546             :                             strlen("GDAL_STRUCTURAL_METADATA_SIZE=") +
    6547           1 :                             nSizePatternLen + nLenMD <=
    6548             :                         nRead)
    6549             :                     {
    6550             :                         pszStructuralMD[strlen(
    6551             :                                             "GDAL_STRUCTURAL_METADATA_SIZE=") +
    6552           1 :                                         nSizePatternLen + nLenMD] = 0;
    6553           1 :                         return CPLSPrintf("%s", pszStructuralMD);
    6554             :                     }
    6555             :                 }
    6556             :             }
    6557           1 :             return nullptr;
    6558             :         }
    6559             :     }
    6560             : 
    6561      148021 :     return m_oGTiffMDMD.GetMetadataItem(pszName, pszDomain);
    6562             : }
    6563             : 
    6564             : /************************************************************************/
    6565             : /*                         LoadEXIFMetadata()                           */
    6566             : /************************************************************************/
    6567             : 
    6568          59 : void GTiffDataset::LoadEXIFMetadata()
    6569             : {
    6570          59 :     if (m_bEXIFMetadataLoaded)
    6571           7 :         return;
    6572          52 :     m_bEXIFMetadataLoaded = true;
    6573             : 
    6574          52 :     VSILFILE *fp = VSI_TIFFGetVSILFile(TIFFClientdata(m_hTIFF));
    6575             : 
    6576          52 :     GByte abyHeader[2] = {0};
    6577          52 :     if (VSIFSeekL(fp, 0, SEEK_SET) != 0 || VSIFReadL(abyHeader, 1, 2, fp) != 2)
    6578           0 :         return;
    6579             : 
    6580          52 :     const bool bLittleEndian = abyHeader[0] == 'I' && abyHeader[1] == 'I';
    6581          52 :     const bool bLeastSignificantBit = CPL_IS_LSB != 0;
    6582          52 :     const bool bSwabflag = bLittleEndian != bLeastSignificantBit;  // != is XOR.
    6583             : 
    6584          52 :     char **papszMetadata = nullptr;
    6585          52 :     toff_t nOffset = 0;  // TODO(b/28199387): Refactor to simplify casting.
    6586             : 
    6587          52 :     if (TIFFGetField(m_hTIFF, TIFFTAG_EXIFIFD, &nOffset))
    6588             :     {
    6589           3 :         int nExifOffset = static_cast<int>(nOffset);
    6590           3 :         int nInterOffset = 0;
    6591           3 :         int nGPSOffset = 0;
    6592           3 :         EXIFExtractMetadata(papszMetadata, fp, static_cast<int>(nOffset),
    6593             :                             bSwabflag, 0, nExifOffset, nInterOffset,
    6594             :                             nGPSOffset);
    6595             :     }
    6596             : 
    6597          52 :     if (TIFFGetField(m_hTIFF, TIFFTAG_GPSIFD, &nOffset))
    6598             :     {
    6599           3 :         int nExifOffset = 0;  // TODO(b/28199387): Refactor to simplify casting.
    6600           3 :         int nInterOffset = 0;
    6601           3 :         int nGPSOffset = static_cast<int>(nOffset);
    6602           3 :         EXIFExtractMetadata(papszMetadata, fp, static_cast<int>(nOffset),
    6603             :                             bSwabflag, 0, nExifOffset, nInterOffset,
    6604             :                             nGPSOffset);
    6605             :     }
    6606             : 
    6607          52 :     if (papszMetadata)
    6608             :     {
    6609           3 :         m_oGTiffMDMD.SetMetadata(papszMetadata, "EXIF");
    6610           3 :         CSLDestroy(papszMetadata);
    6611             :     }
    6612             : }
    6613             : 
    6614             : /************************************************************************/
    6615             : /*                           LoadMetadata()                             */
    6616             : /************************************************************************/
    6617       21191 : void GTiffDataset::LoadMetadata()
    6618             : {
    6619       21191 :     if (m_bIMDRPCMetadataLoaded)
    6620       16503 :         return;
    6621        4764 :     m_bIMDRPCMetadataLoaded = true;
    6622             : 
    6623        4764 :     if (EQUAL(CPLGetExtensionSafe(GetDescription()).c_str(), "ovr"))
    6624             :     {
    6625             :         // Do not attempt to retrieve metadata files on .tif.ovr files.
    6626             :         // For example the Pleiades metadata reader might wrongly associate a
    6627             :         // DIM_xxx.XML file that was meant to be associated with the main
    6628             :         // TIFF file. The consequence of that wrong association is that if
    6629             :         // one cleans overviews, then the Delete() method would then delete
    6630             :         // that DIM_xxx.XML file since it would be reported in the GetFileList()
    6631             :         // of the overview dataset.
    6632          76 :         return;
    6633             :     }
    6634             : 
    6635        9376 :     GDALMDReaderManager mdreadermanager;
    6636             :     GDALMDReaderBase *mdreader =
    6637        4688 :         m_poBaseDS == nullptr
    6638        4688 :             ? mdreadermanager.GetReader(m_osFilename.c_str(),
    6639             :                                         oOvManager.GetSiblingFiles(), MDR_ANY)
    6640        4688 :             : nullptr;
    6641             : 
    6642        4688 :     if (nullptr != mdreader)
    6643             :     {
    6644          65 :         mdreader->FillMetadata(&m_oGTiffMDMD);
    6645             : 
    6646          65 :         if (mdreader->GetMetadataDomain(MD_DOMAIN_RPC) == nullptr)
    6647             :         {
    6648          36 :             char **papszRPCMD = GTiffDatasetReadRPCTag(m_hTIFF);
    6649          36 :             if (papszRPCMD)
    6650             :             {
    6651          12 :                 m_oGTiffMDMD.SetMetadata(papszRPCMD, MD_DOMAIN_RPC);
    6652          12 :                 CSLDestroy(papszRPCMD);
    6653             :             }
    6654             :         }
    6655             : 
    6656          65 :         m_papszMetadataFiles = mdreader->GetMetadataFiles();
    6657             :     }
    6658             :     else
    6659             :     {
    6660        4623 :         char **papszRPCMD = GTiffDatasetReadRPCTag(m_hTIFF);
    6661        4623 :         if (papszRPCMD)
    6662             :         {
    6663          20 :             m_oGTiffMDMD.SetMetadata(papszRPCMD, MD_DOMAIN_RPC);
    6664          20 :             CSLDestroy(papszRPCMD);
    6665             :         }
    6666             :     }
    6667             : }
    6668             : 
    6669             : /************************************************************************/
    6670             : /*                     HasOptimizedReadMultiRange()                     */
    6671             : /************************************************************************/
    6672             : 
    6673     2896020 : bool GTiffDataset::HasOptimizedReadMultiRange()
    6674             : {
    6675     2896020 :     if (m_nHasOptimizedReadMultiRange >= 0)
    6676     2880580 :         return m_nHasOptimizedReadMultiRange != 0;
    6677       15470 :     m_nHasOptimizedReadMultiRange = static_cast<signed char>(
    6678       15449 :         VSIHasOptimizedReadMultiRange(m_osFilename.c_str())
    6679             :         // Config option for debug and testing purposes only
    6680       15468 :         || CPLTestBool(CPLGetConfigOption(
    6681             :                "GTIFF_HAS_OPTIMIZED_READ_MULTI_RANGE", "NO")));
    6682       15470 :     return m_nHasOptimizedReadMultiRange != 0;
    6683             : }
    6684             : 
    6685             : /************************************************************************/
    6686             : /*                         CacheMultiRange()                            */
    6687             : /************************************************************************/
    6688             : 
    6689         256 : static bool CheckTrailer(const GByte *strileData, vsi_l_offset nStrileSize)
    6690             : {
    6691             :     GByte abyTrailer[4];
    6692         256 :     memcpy(abyTrailer, strileData + nStrileSize, 4);
    6693         256 :     GByte abyLastBytes[4] = {};
    6694         256 :     if (nStrileSize >= 4)
    6695         256 :         memcpy(abyLastBytes, strileData + nStrileSize - 4, 4);
    6696             :     else
    6697             :     {
    6698             :         // The last bytes will be zero due to the above {} initialization,
    6699             :         // and that's what should be in abyTrailer too when the trailer is
    6700             :         // correct.
    6701           0 :         memcpy(abyLastBytes, strileData, static_cast<size_t>(nStrileSize));
    6702             :     }
    6703         256 :     return memcmp(abyTrailer, abyLastBytes, 4) == 0;
    6704             : }
    6705             : 
    6706         268 : void *GTiffDataset::CacheMultiRange(int nXOff, int nYOff, int nXSize,
    6707             :                                     int nYSize, int nBufXSize, int nBufYSize,
    6708             :                                     const int *panBandMap, int nBandCount,
    6709             :                                     GDALRasterIOExtraArg *psExtraArg)
    6710             : {
    6711         268 :     void *pBufferedData = nullptr;
    6712             :     // Same logic as in GDALRasterBand::IRasterIO()
    6713         268 :     double dfXOff = nXOff;
    6714         268 :     double dfYOff = nYOff;
    6715         268 :     double dfXSize = nXSize;
    6716         268 :     double dfYSize = nYSize;
    6717         268 :     if (psExtraArg->bFloatingPointWindowValidity)
    6718             :     {
    6719          48 :         dfXOff = psExtraArg->dfXOff;
    6720          48 :         dfYOff = psExtraArg->dfYOff;
    6721          48 :         dfXSize = psExtraArg->dfXSize;
    6722          48 :         dfYSize = psExtraArg->dfYSize;
    6723             :     }
    6724         268 :     const double dfSrcXInc = dfXSize / static_cast<double>(nBufXSize);
    6725         268 :     const double dfSrcYInc = dfYSize / static_cast<double>(nBufYSize);
    6726         268 :     const double EPS = 1e-10;
    6727             :     const int nBlockX1 =
    6728         268 :         static_cast<int>(std::max(0.0, (0 + 0.5) * dfSrcXInc + dfXOff + EPS)) /
    6729         268 :         m_nBlockXSize;
    6730             :     const int nBlockY1 =
    6731         268 :         static_cast<int>(std::max(0.0, (0 + 0.5) * dfSrcYInc + dfYOff + EPS)) /
    6732         268 :         m_nBlockYSize;
    6733             :     const int nBlockX2 =
    6734         268 :         static_cast<int>(
    6735         536 :             std::min(static_cast<double>(nRasterXSize - 1),
    6736         268 :                      (nBufXSize - 1 + 0.5) * dfSrcXInc + dfXOff + EPS)) /
    6737         268 :         m_nBlockXSize;
    6738             :     const int nBlockY2 =
    6739         268 :         static_cast<int>(
    6740         536 :             std::min(static_cast<double>(nRasterYSize - 1),
    6741         268 :                      (nBufYSize - 1 + 0.5) * dfSrcYInc + dfYOff + EPS)) /
    6742         268 :         m_nBlockYSize;
    6743             : 
    6744             :     struct StrileData
    6745             :     {
    6746             :         vsi_l_offset nOffset;
    6747             :         vsi_l_offset nByteCount;
    6748             :         bool bTryMask;
    6749             :     };
    6750             : 
    6751         536 :     std::map<int, StrileData> oMapStrileToOffsetByteCount;
    6752             : 
    6753             :     // Dedicated method to retrieved the offset and size in an efficient way
    6754             :     // when m_bBlockOrderRowMajor and m_bLeaderSizeAsUInt4 conditions are
    6755             :     // met.
    6756             :     // Except for the last block, we just read the offset from the TIFF offset
    6757             :     // array, and retrieve the size in the leader 4 bytes that come before the
    6758             :     // payload.
    6759             :     auto OptimizedRetrievalOfOffsetSize =
    6760         218 :         [&](int nBand, int nBlockId, vsi_l_offset &nOffset, vsi_l_offset &nSize,
    6761             :             size_t nTotalSize, size_t nMaxRawBlockCacheSize)
    6762             :     {
    6763        1224 :         bool bTryMask = m_bMaskInterleavedWithImagery;
    6764         218 :         nOffset = TIFFGetStrileOffset(m_hTIFF, nBlockId);
    6765         218 :         if (nOffset >= 4)
    6766             :         {
    6767         155 :             if ((m_nPlanarConfig == PLANARCONFIG_CONTIG &&
    6768         131 :                  nBlockId == m_nBlocksPerBand - 1) ||
    6769         129 :                 (m_nPlanarConfig == PLANARCONFIG_SEPARATE &&
    6770          24 :                  nBlockId == m_nBlocksPerBand * nBands - 1))
    6771             :             {
    6772             :                 // Special case for the last block. As there is no next block
    6773             :                 // from which to retrieve an offset, use the good old method
    6774             :                 // that consists in reading the ByteCount array.
    6775          26 :                 if (m_nPlanarConfig == PLANARCONFIG_CONTIG && bTryMask &&
    6776          54 :                     GetRasterBand(1)->GetMaskBand() && m_poMaskDS)
    6777             :                 {
    6778             :                     auto nMaskOffset =
    6779          23 :                         TIFFGetStrileOffset(m_poMaskDS->m_hTIFF, nBlockId);
    6780          23 :                     if (nMaskOffset)
    6781             :                     {
    6782          23 :                         nSize = nMaskOffset +
    6783          23 :                                 TIFFGetStrileByteCount(m_poMaskDS->m_hTIFF,
    6784          23 :                                                        nBlockId) -
    6785          23 :                                 nOffset;
    6786             :                     }
    6787             :                     else
    6788             :                     {
    6789           0 :                         bTryMask = false;
    6790             :                     }
    6791             :                 }
    6792          28 :                 if (nSize == 0)
    6793             :                 {
    6794           5 :                     nSize = TIFFGetStrileByteCount(m_hTIFF, nBlockId);
    6795             :                 }
    6796          28 :                 if (nSize && m_bTrailerRepeatedLast4BytesRepeated)
    6797             :                 {
    6798          28 :                     nSize += 4;
    6799          28 :                 }
    6800             :             }
    6801             :             else
    6802             :             {
    6803         127 :                 const auto nNextBlockId =
    6804          11 :                     (m_bTileInterleave && nBand < nBands)
    6805         254 :                         ? nBlockId + m_nBlocksPerBand
    6806           3 :                     : (m_bTileInterleave && nBand == nBands)
    6807         122 :                         ? nBlockId - (nBand - 1) * m_nBlocksPerBand + 1
    6808         116 :                         : nBlockId + 1;
    6809         127 :                 auto nOffsetNext = TIFFGetStrileOffset(m_hTIFF, nNextBlockId);
    6810         127 :                 if (nOffsetNext > nOffset)
    6811             :                 {
    6812         119 :                     nSize = nOffsetNext - nOffset;
    6813             :                 }
    6814             :                 else
    6815             :                 {
    6816             :                     // Shouldn't happen for a compliant file
    6817           8 :                     if (nOffsetNext != 0)
    6818             :                     {
    6819           0 :                         CPLDebug("GTiff", "Tile %d is not located after %d",
    6820             :                                  nNextBlockId, nBlockId);
    6821             :                     }
    6822           8 :                     bTryMask = false;
    6823           8 :                     nSize = TIFFGetStrileByteCount(m_hTIFF, nBlockId);
    6824           8 :                     if (m_bTrailerRepeatedLast4BytesRepeated)
    6825           8 :                         nSize += 4;
    6826             :                 }
    6827             :             }
    6828         155 :             if (nSize)
    6829             :             {
    6830         155 :                 nOffset -= 4;
    6831         155 :                 nSize += 4;
    6832         155 :                 if (nTotalSize + nSize < nMaxRawBlockCacheSize)
    6833             :                 {
    6834             :                     StrileData data;
    6835         155 :                     data.nOffset = nOffset;
    6836         155 :                     data.nByteCount = nSize;
    6837         155 :                     data.bTryMask = bTryMask;
    6838         155 :                     oMapStrileToOffsetByteCount[nBlockId] = data;
    6839             :                 }
    6840             :             }
    6841             :         }
    6842             :         else
    6843             :         {
    6844             :             // Sparse tile
    6845             :             StrileData data;
    6846          63 :             data.nOffset = 0;
    6847          63 :             data.nByteCount = 0;
    6848          63 :             data.bTryMask = false;
    6849          63 :             oMapStrileToOffsetByteCount[nBlockId] = data;
    6850             :         }
    6851         218 :     };
    6852             : 
    6853             :     // This lambda fills m_poDS->m_oCacheStrileToOffsetByteCount (and
    6854             :     // m_poDS->m_poMaskDS->m_oCacheStrileToOffsetByteCount, when there is a
    6855             :     // mask) from the temporary oMapStrileToOffsetByteCount.
    6856             :     auto FillCacheStrileToOffsetByteCount =
    6857          37 :         [&](const std::vector<vsi_l_offset> &anOffsets,
    6858             :             const std::vector<size_t> &anSizes,
    6859             :             const std::vector<void *> &apData)
    6860             :     {
    6861          37 :         CPLAssert(m_bLeaderSizeAsUInt4);
    6862          37 :         size_t i = 0;
    6863          37 :         vsi_l_offset nLastOffset = 0;
    6864         215 :         for (const auto &entry : oMapStrileToOffsetByteCount)
    6865             :         {
    6866         178 :             const auto nBlockId = entry.first;
    6867         178 :             const auto nOffset = entry.second.nOffset;
    6868         178 :             const auto nSize = entry.second.nByteCount;
    6869         178 :             if (nOffset == 0)
    6870             :             {
    6871             :                 // Sparse tile
    6872             :                 m_oCacheStrileToOffsetByteCount.insert(nBlockId,
    6873          23 :                                                        std::pair(0, 0));
    6874          77 :                 continue;
    6875             :             }
    6876             : 
    6877         155 :             if (nOffset < nLastOffset)
    6878             :             {
    6879             :                 // shouldn't happen normally if tiles are sorted
    6880           2 :                 i = 0;
    6881             :             }
    6882         155 :             nLastOffset = nOffset;
    6883         318 :             while (i < anOffsets.size() &&
    6884         159 :                    !(nOffset >= anOffsets[i] &&
    6885         159 :                      nOffset + nSize <= anOffsets[i] + anSizes[i]))
    6886             :             {
    6887           4 :                 i++;
    6888             :             }
    6889         155 :             CPLAssert(i < anOffsets.size());
    6890         155 :             CPLAssert(nOffset >= anOffsets[i]);
    6891         155 :             CPLAssert(nOffset + nSize <= anOffsets[i] + anSizes[i]);
    6892             :             GUInt32 nSizeFromLeader;
    6893         155 :             memcpy(&nSizeFromLeader,
    6894             :                    // cppcheck-suppress containerOutOfBounds
    6895         155 :                    static_cast<GByte *>(apData[i]) + nOffset - anOffsets[i],
    6896             :                    sizeof(nSizeFromLeader));
    6897         155 :             CPL_LSBPTR32(&nSizeFromLeader);
    6898         155 :             bool bOK = true;
    6899         155 :             constexpr int nLeaderSize = 4;
    6900         155 :             const int nTrailerSize =
    6901         155 :                 (m_bTrailerRepeatedLast4BytesRepeated ? 4 : 0);
    6902         155 :             if (nSizeFromLeader > nSize - nLeaderSize - nTrailerSize)
    6903             :             {
    6904           0 :                 CPLDebug("GTiff",
    6905             :                          "Inconsistent block size from in leader of block %d",
    6906             :                          nBlockId);
    6907           0 :                 bOK = false;
    6908             :             }
    6909         155 :             else if (m_bTrailerRepeatedLast4BytesRepeated)
    6910             :             {
    6911             :                 // Check trailer consistency
    6912         155 :                 const GByte *strileData = static_cast<GByte *>(apData[i]) +
    6913         155 :                                           nOffset - anOffsets[i] + nLeaderSize;
    6914         155 :                 if (!CheckTrailer(strileData, nSizeFromLeader))
    6915             :                 {
    6916           0 :                     CPLDebug("GTiff", "Inconsistent trailer of block %d",
    6917             :                              nBlockId);
    6918           0 :                     bOK = false;
    6919             :                 }
    6920             :             }
    6921         155 :             if (!bOK)
    6922             :             {
    6923           0 :                 return false;
    6924             :             }
    6925             : 
    6926             :             {
    6927         155 :                 const vsi_l_offset nRealOffset = nOffset + nLeaderSize;
    6928         155 :                 const vsi_l_offset nRealSize = nSizeFromLeader;
    6929             : #ifdef DEBUG_VERBOSE
    6930             :                 CPLDebug("GTiff",
    6931             :                          "Block %d found at offset " CPL_FRMT_GUIB
    6932             :                          " with size " CPL_FRMT_GUIB,
    6933             :                          nBlockId, nRealOffset, nRealSize);
    6934             : #endif
    6935             :                 m_oCacheStrileToOffsetByteCount.insert(
    6936         155 :                     nBlockId, std::pair(nRealOffset, nRealSize));
    6937             :             }
    6938             : 
    6939             :             // Processing of mask
    6940         256 :             if (!(entry.second.bTryMask && m_bMaskInterleavedWithImagery &&
    6941         101 :                   GetRasterBand(1)->GetMaskBand() && m_poMaskDS))
    6942             :             {
    6943          54 :                 continue;
    6944             :             }
    6945             : 
    6946         101 :             bOK = false;
    6947         101 :             const vsi_l_offset nMaskOffsetWithLeader =
    6948         101 :                 nOffset + nLeaderSize + nSizeFromLeader + nTrailerSize;
    6949         202 :             if (nMaskOffsetWithLeader + nLeaderSize <=
    6950         101 :                 anOffsets[i] + anSizes[i])
    6951             :             {
    6952             :                 GUInt32 nMaskSizeFromLeader;
    6953         101 :                 memcpy(&nMaskSizeFromLeader,
    6954         101 :                        static_cast<GByte *>(apData[i]) + nMaskOffsetWithLeader -
    6955         101 :                            anOffsets[i],
    6956             :                        sizeof(nMaskSizeFromLeader));
    6957         101 :                 CPL_LSBPTR32(&nMaskSizeFromLeader);
    6958         202 :                 if (nMaskOffsetWithLeader + nLeaderSize + nMaskSizeFromLeader +
    6959         202 :                         nTrailerSize <=
    6960         101 :                     anOffsets[i] + anSizes[i])
    6961             :                 {
    6962         101 :                     bOK = true;
    6963         101 :                     if (m_bTrailerRepeatedLast4BytesRepeated)
    6964             :                     {
    6965             :                         // Check trailer consistency
    6966             :                         const GByte *strileMaskData =
    6967         101 :                             static_cast<GByte *>(apData[i]) + nOffset -
    6968         202 :                             anOffsets[i] + nLeaderSize + nSizeFromLeader +
    6969         101 :                             nTrailerSize + nLeaderSize;
    6970         101 :                         if (!CheckTrailer(strileMaskData, nMaskSizeFromLeader))
    6971             :                         {
    6972           0 :                             CPLDebug("GTiff",
    6973             :                                      "Inconsistent trailer of mask of block %d",
    6974             :                                      nBlockId);
    6975           0 :                             bOK = false;
    6976             :                         }
    6977             :                     }
    6978             :                 }
    6979         101 :                 if (bOK)
    6980             :                 {
    6981         101 :                     const vsi_l_offset nRealOffset = nOffset + nLeaderSize +
    6982         101 :                                                      nSizeFromLeader +
    6983         101 :                                                      nTrailerSize + nLeaderSize;
    6984         101 :                     const vsi_l_offset nRealSize = nMaskSizeFromLeader;
    6985             : #ifdef DEBUG_VERBOSE
    6986             :                     CPLDebug("GTiff",
    6987             :                              "Mask of block %d found at offset " CPL_FRMT_GUIB
    6988             :                              " with size " CPL_FRMT_GUIB,
    6989             :                              nBlockId, nRealOffset, nRealSize);
    6990             : #endif
    6991             : 
    6992         101 :                     m_poMaskDS->m_oCacheStrileToOffsetByteCount.insert(
    6993         101 :                         nBlockId, std::pair(nRealOffset, nRealSize));
    6994             :                 }
    6995             :             }
    6996         101 :             if (!bOK)
    6997             :             {
    6998           0 :                 CPLDebug("GTiff",
    6999             :                          "Mask for block %d is not properly interleaved with "
    7000             :                          "imagery block",
    7001             :                          nBlockId);
    7002             :             }
    7003             :         }
    7004          37 :         return true;
    7005         268 :     };
    7006             : 
    7007         268 :     thandle_t th = TIFFClientdata(m_hTIFF);
    7008         268 :     if (!VSI_TIFFHasCachedRanges(th))
    7009             :     {
    7010         234 :         std::vector<std::pair<vsi_l_offset, size_t>> aOffsetSize;
    7011         234 :         size_t nTotalSize = 0;
    7012         234 :         const unsigned int nMaxRawBlockCacheSize = atoi(
    7013         234 :             CPLGetConfigOption("GDAL_MAX_RAW_BLOCK_CACHE_SIZE", "10485760"));
    7014         234 :         bool bGoOn = true;
    7015         472 :         for (int iBand = 0; iBand < nBandCount; ++iBand)
    7016             :         {
    7017         238 :             const int nBand = panBandMap[iBand];
    7018             :             GTiffRasterBand *poBand =
    7019         238 :                 cpl::down_cast<GTiffRasterBand *>(papoBands[nBand - 1]);
    7020         557 :             for (int iY = nBlockY1; bGoOn && iY <= nBlockY2; iY++)
    7021             :             {
    7022        1042 :                 for (int iX = nBlockX1; bGoOn && iX <= nBlockX2; iX++)
    7023             :                 {
    7024             :                     GDALRasterBlock *poBlock =
    7025         723 :                         poBand->TryGetLockedBlockRef(iX, iY);
    7026         723 :                     if (poBlock != nullptr)
    7027             :                     {
    7028         299 :                         poBlock->DropLock();
    7029         299 :                         continue;
    7030             :                     }
    7031         424 :                     int nBlockId = iX + iY * m_nBlocksPerRow;
    7032         424 :                     if (m_nPlanarConfig == PLANARCONFIG_SEPARATE)
    7033          24 :                         nBlockId += (nBand - 1) * m_nBlocksPerBand;
    7034         424 :                     vsi_l_offset nOffset = 0;
    7035         424 :                     vsi_l_offset nSize = 0;
    7036             : 
    7037         424 :                     if (!m_bStreamingIn && m_bBlockOrderRowMajor &&
    7038         218 :                         m_bLeaderSizeAsUInt4)
    7039             :                     {
    7040         218 :                         OptimizedRetrievalOfOffsetSize(nBand, nBlockId, nOffset,
    7041             :                                                        nSize, nTotalSize,
    7042             :                                                        nMaxRawBlockCacheSize);
    7043             :                     }
    7044             :                     else
    7045             :                     {
    7046         206 :                         CPL_IGNORE_RET_VAL(IsBlockAvailable(nBlockId, &nOffset,
    7047             :                                                             &nSize, nullptr));
    7048             :                     }
    7049         424 :                     if (nSize)
    7050             :                     {
    7051         166 :                         if (nTotalSize + nSize < nMaxRawBlockCacheSize)
    7052             :                         {
    7053             : #ifdef DEBUG_VERBOSE
    7054             :                             CPLDebug(
    7055             :                                 "GTiff",
    7056             :                                 "Precaching for block (%d, %d), " CPL_FRMT_GUIB
    7057             :                                 "-" CPL_FRMT_GUIB,
    7058             :                                 iX, iY, nOffset,
    7059             :                                 nOffset + static_cast<size_t>(nSize) - 1);
    7060             : #endif
    7061         166 :                             aOffsetSize.push_back(
    7062         166 :                                 std::pair(nOffset, static_cast<size_t>(nSize)));
    7063         166 :                             nTotalSize += static_cast<size_t>(nSize);
    7064             :                         }
    7065             :                         else
    7066             :                         {
    7067           0 :                             bGoOn = false;
    7068             :                         }
    7069             :                     }
    7070             :                 }
    7071             :             }
    7072             :         }
    7073             : 
    7074         234 :         std::sort(aOffsetSize.begin(), aOffsetSize.end());
    7075             : 
    7076         234 :         if (nTotalSize > 0)
    7077             :         {
    7078          42 :             pBufferedData = VSI_MALLOC_VERBOSE(nTotalSize);
    7079          42 :             if (pBufferedData)
    7080             :             {
    7081          42 :                 std::vector<vsi_l_offset> anOffsets;
    7082          42 :                 std::vector<size_t> anSizes;
    7083          42 :                 std::vector<void *> apData;
    7084          42 :                 anOffsets.push_back(aOffsetSize[0].first);
    7085          42 :                 apData.push_back(static_cast<GByte *>(pBufferedData));
    7086          42 :                 size_t nChunkSize = aOffsetSize[0].second;
    7087          42 :                 size_t nAccOffset = 0;
    7088             :                 // Try to merge contiguous or slightly overlapping ranges
    7089         166 :                 for (size_t i = 0; i < aOffsetSize.size() - 1; i++)
    7090             :                 {
    7091         248 :                     if (aOffsetSize[i].first < aOffsetSize[i + 1].first &&
    7092         124 :                         aOffsetSize[i].first + aOffsetSize[i].second >=
    7093         124 :                             aOffsetSize[i + 1].first)
    7094             :                     {
    7095         120 :                         const auto overlap = aOffsetSize[i].first +
    7096         120 :                                              aOffsetSize[i].second -
    7097         120 :                                              aOffsetSize[i + 1].first;
    7098             :                         // That should always be the case for well behaved
    7099             :                         // TIFF files.
    7100         120 :                         if (aOffsetSize[i + 1].second > overlap)
    7101             :                         {
    7102         120 :                             nChunkSize += static_cast<size_t>(
    7103         120 :                                 aOffsetSize[i + 1].second - overlap);
    7104             :                         }
    7105             :                     }
    7106             :                     else
    7107             :                     {
    7108             :                         // terminate current block
    7109           4 :                         anSizes.push_back(nChunkSize);
    7110             : #ifdef DEBUG_VERBOSE
    7111             :                         CPLDebug("GTiff",
    7112             :                                  "Requesting range [" CPL_FRMT_GUIB
    7113             :                                  "-" CPL_FRMT_GUIB "]",
    7114             :                                  anOffsets.back(),
    7115             :                                  anOffsets.back() + anSizes.back() - 1);
    7116             : #endif
    7117           4 :                         nAccOffset += nChunkSize;
    7118             :                         // start a new range
    7119           4 :                         anOffsets.push_back(aOffsetSize[i + 1].first);
    7120           4 :                         apData.push_back(static_cast<GByte *>(pBufferedData) +
    7121             :                                          nAccOffset);
    7122           4 :                         nChunkSize = aOffsetSize[i + 1].second;
    7123             :                     }
    7124             :                 }
    7125             :                 // terminate last block
    7126          42 :                 anSizes.push_back(nChunkSize);
    7127             : #ifdef DEBUG_VERBOSE
    7128             :                 CPLDebug(
    7129             :                     "GTiff",
    7130             :                     "Requesting range [" CPL_FRMT_GUIB "-" CPL_FRMT_GUIB "]",
    7131             :                     anOffsets.back(), anOffsets.back() + anSizes.back() - 1);
    7132             : #endif
    7133             : 
    7134          42 :                 VSILFILE *fp = VSI_TIFFGetVSILFile(th);
    7135             : 
    7136             :                 // An error in VSIFReadMultiRangeL() will not be critical,
    7137             :                 // as this method is an optimization, and if it fails,
    7138             :                 // tile-by-tile data acquisition will be done, so we can
    7139             :                 // temporary turn failures into warnings.
    7140             :                 bool ok;
    7141             :                 {
    7142             :                     CPLTurnFailureIntoWarningBackuper
    7143          42 :                         oFailureToWarningBackuper{};
    7144          42 :                     ok = VSIFReadMultiRangeL(static_cast<int>(anSizes.size()),
    7145          42 :                                              &apData[0], &anOffsets[0],
    7146          42 :                                              &anSizes[0], fp) == 0;
    7147             :                 }
    7148             : 
    7149          42 :                 if (ok)
    7150             :                 {
    7151          79 :                     if (!oMapStrileToOffsetByteCount.empty() &&
    7152          37 :                         !FillCacheStrileToOffsetByteCount(anOffsets, anSizes,
    7153             :                                                           apData))
    7154             :                     {
    7155             :                         // Retry without optimization
    7156           0 :                         CPLFree(pBufferedData);
    7157           0 :                         m_bLeaderSizeAsUInt4 = false;
    7158           0 :                         void *pRet = CacheMultiRange(
    7159             :                             nXOff, nYOff, nXSize, nYSize, nBufXSize, nBufYSize,
    7160             :                             panBandMap, nBandCount, psExtraArg);
    7161           0 :                         m_bLeaderSizeAsUInt4 = true;
    7162           0 :                         return pRet;
    7163             :                     }
    7164             : 
    7165          42 :                     VSI_TIFFSetCachedRanges(
    7166          42 :                         th, static_cast<int>(anSizes.size()), &apData[0],
    7167          42 :                         &anOffsets[0], &anSizes[0]);
    7168             :                 }
    7169             :                 else
    7170             :                 {
    7171           0 :                     CPLFree(pBufferedData);
    7172           0 :                     pBufferedData = nullptr;
    7173             :                 }
    7174             :             }
    7175             :         }
    7176             :     }
    7177         268 :     return pBufferedData;
    7178             : }

Generated by: LCOV version 1.14