Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: GeoTIFF Driver
4 : * Purpose: GDAL GeoTIFF support.
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 : #ifndef GTIFFDATASET_H_INCLUDED
15 : #define GTIFFDATASET_H_INCLUDED
16 :
17 : #include "gdal_pam.h"
18 :
19 : #include <mutex>
20 : #include <queue>
21 :
22 : #include "cpl_mem_cache.h"
23 : #include "cpl_worker_thread_pool.h" // CPLJobQueue, CPLWorkerThreadPool
24 : #include "fetchbufferdirectio.h"
25 : #include "gtiff.h"
26 : #include "gt_wkt_srs.h" // GTIFFKeysFlavorEnum
27 : #include "tiffio.h" // TIFF*
28 :
29 : enum class GTiffProfile : GByte
30 : {
31 : BASELINE,
32 : GEOTIFF,
33 : GDALGEOTIFF
34 : };
35 :
36 : // This must be a #define, since it is used in a XSTRINGIFY() macro
37 : #define DEFAULT_WEBP_LEVEL 75
38 :
39 : class GTiffBitmapBand;
40 : class GTiffDataset;
41 : class GTiffJPEGOverviewBand;
42 : class GTiffJPEGOverviewDS;
43 : class GTiffRasterBand;
44 : class GTiffRGBABand;
45 :
46 : typedef struct
47 : {
48 : GTiffDataset *poDS;
49 : char *pszTmpFilename;
50 : GByte *pabyBuffer;
51 : GByte *pabyCompressedBuffer; // Owned by pszTmpFilename.
52 : GPtrDiff_t nBufferSize;
53 : GPtrDiff_t nCompressedBufferSize;
54 : int nHeight;
55 : int nStripOrTile;
56 : uint16_t nPredictor;
57 : bool bTIFFIsBigEndian;
58 : bool bReady;
59 : uint16_t *pExtraSamples;
60 : uint16_t nExtraSampleCount;
61 : } GTiffCompressionJob;
62 :
63 : typedef enum
64 : {
65 : GTIFFTAGTYPE_STRING,
66 : GTIFFTAGTYPE_SHORT,
67 : GTIFFTAGTYPE_FLOAT,
68 : GTIFFTAGTYPE_BYTE_STRING
69 : } GTIFFTagTypes;
70 :
71 : struct GTIFFTag
72 : {
73 : const char *pszTagName;
74 : int nTagVal;
75 : GTIFFTagTypes eType;
76 : };
77 :
78 : /************************************************************************/
79 : /* ==================================================================== */
80 : /* GTiffDataset */
81 : /* ==================================================================== */
82 : /************************************************************************/
83 :
84 : class GTiffDataset final : public GDALPamDataset
85 : {
86 : public:
87 : struct MaskOffset
88 : {
89 : uint64_t nMask;
90 : uint64_t nRoundUpBitTest;
91 : };
92 :
93 : private:
94 : CPL_DISALLOW_COPY_ASSIGN(GTiffDataset)
95 :
96 : friend class GTiffBitmapBand;
97 : friend class GTiffJPEGOverviewDS;
98 : friend class GTiffJPEGOverviewBand;
99 : friend class GTiffOddBitsBand;
100 : friend class GTiffRasterBand;
101 : friend class GTiffRGBABand;
102 : friend class GTiffSplitBand;
103 : friend class GTiffSplitBitmapBand;
104 :
105 : friend void GTIFFSetJpegQuality(GDALDatasetH hGTIFFDS, int nJpegQuality);
106 : friend void GTIFFSetJpegTablesMode(GDALDatasetH hGTIFFDS,
107 : int nJpegTablesMode);
108 : friend void GTIFFSetWebPLevel(GDALDatasetH hGTIFFDS, int nWebPLevel);
109 : friend void GTIFFSetWebPLossless(GDALDatasetH hGTIFFDS, bool bWebPLossless);
110 : friend void GTIFFSetZLevel(GDALDatasetH hGTIFFDS, int nZLevel);
111 : friend void GTIFFSetZSTDLevel(GDALDatasetH hGTIFFDS, int nZSTDLevel);
112 : friend void GTIFFSetMaxZError(GDALDatasetH hGTIFFDS, double dfMaxZError);
113 : #if HAVE_JXL
114 : friend void GTIFFSetJXLLossless(GDALDatasetH hGTIFFDS, bool bIsLossless);
115 : friend void GTIFFSetJXLEffort(GDALDatasetH hGTIFFDS, int nEffort);
116 : friend void GTIFFSetJXLDistance(GDALDatasetH hGTIFFDS, float fDistance);
117 : friend void GTIFFSetJXLAlphaDistance(GDALDatasetH hGTIFFDS,
118 : float fAlphaDistance);
119 : #endif
120 :
121 : TIFF *m_hTIFF = nullptr;
122 : VSILFILE *m_fpL = nullptr;
123 : VSILFILE *m_fpToWrite = nullptr;
124 : std::vector<std::shared_ptr<GTiffDataset>> m_apoOverviewDS{};
125 : // For a non-mask dataset, points to the corresponding (internal) mask
126 : std::shared_ptr<GTiffDataset> m_poMaskDS{};
127 : // Points to a dataset within m_poMaskExtOvrDS
128 : GDALDataset *m_poExternalMaskDS = nullptr;
129 : // For a mask dataset, points to the corresponding imagery dataset
130 : GTiffDataset *m_poImageryDS = nullptr;
131 : // For an overview or mask dataset, points to the root dataset
132 : GTiffDataset *m_poBaseDS = nullptr;
133 : // Used with MASK_OVERVIEW_DATASET open option
134 : std::unique_ptr<GDALDataset> m_poMaskExtOvrDS{};
135 : std::vector<std::unique_ptr<GTiffJPEGOverviewDS>> m_apoJPEGOverviewDS{};
136 : std::vector<std::unique_ptr<GTiffJPEGOverviewDS>> m_apoJPEGOverviewDSOld{};
137 : std::vector<gdal::GCP> m_aoGCPs{};
138 : std::unique_ptr<GDALColorTable> m_poColorTable{};
139 : char **m_papszMetadataFiles = nullptr;
140 : GByte *m_pabyBlockBuf = nullptr;
141 : char **m_papszCreationOptions = nullptr;
142 : void *m_pabyTempWriteBuffer = nullptr;
143 : CPLVirtualMem *m_pBaseMapping = nullptr;
144 : GByte *m_pTempBufferForCommonDirectIO = nullptr;
145 : CPLVirtualMem *m_psVirtualMemIOMapping = nullptr;
146 : CPLWorkerThreadPool *m_poThreadPool = nullptr;
147 : std::unique_ptr<CPLJobQueue> m_poCompressQueue{};
148 : std::mutex m_oCompressThreadPoolMutex{};
149 :
150 : lru11::Cache<int, std::pair<vsi_l_offset, vsi_l_offset>>
151 : m_oCacheStrileToOffsetByteCount{1024};
152 :
153 : MaskOffset *m_panMaskOffsetLsb = nullptr;
154 : char *m_pszVertUnit = nullptr;
155 : std::string m_osFilename{};
156 : char *m_pszTmpFilename = nullptr;
157 : char *m_pszGeorefFilename = nullptr;
158 : char *m_pszXMLFilename = nullptr;
159 :
160 : GDALGeoTransform m_gt{};
161 : double m_dfMaxZError = 0.0;
162 : double m_dfMaxZErrorOverview = 0.0;
163 : uint32_t m_anLercAddCompressionAndVersion[2]{0, 0};
164 : #if HAVE_JXL
165 : bool m_bJXLLossless = true;
166 : float m_fJXLDistance = 1.0f;
167 : float m_fJXLAlphaDistance = -1.0f; // -1 = same as non-alpha channel
168 : uint32_t m_nJXLEffort = 5;
169 : #endif
170 : double m_dfNoDataValue = DEFAULT_NODATA_VALUE;
171 : int64_t m_nNoDataValueInt64 = GDAL_PAM_DEFAULT_NODATA_VALUE_INT64;
172 : uint64_t m_nNoDataValueUInt64 = GDAL_PAM_DEFAULT_NODATA_VALUE_UINT64;
173 :
174 : toff_t m_nDirOffset = 0;
175 :
176 : int m_nBlocksPerRow = 0;
177 : int m_nBlocksPerColumn = 0;
178 : int m_nBlocksPerBand = 0;
179 : int m_nBlockXSize = 0;
180 : int m_nBlockYSize = 0;
181 : int m_nLoadedBlock = -1; // Or tile, or scanline
182 : uint32_t m_nRowsPerStrip = 0;
183 : int m_nLastBandRead = -1; // Used for the all-in-on-strip case.
184 : int m_nLastWrittenBlockId = -1; // used for m_bStreamingOut
185 : int m_nRefBaseMapping = 0;
186 : int m_nDisableMultiThreadedRead = 0;
187 :
188 : struct JPEGOverviewVisibilitySetter
189 : {
190 : signed char &nCounter_;
191 :
192 6719600 : explicit JPEGOverviewVisibilitySetter(signed char &nCounter)
193 6719600 : : nCounter_(nCounter)
194 : {
195 6719600 : ++nCounter_;
196 6719600 : }
197 :
198 6719600 : ~JPEGOverviewVisibilitySetter()
199 6719600 : {
200 6719600 : --nCounter_;
201 6719600 : }
202 : };
203 :
204 : std::unique_ptr<JPEGOverviewVisibilitySetter>
205 6719600 : MakeJPEGOverviewVisible() CPL_WARN_UNUSED_RESULT
206 : {
207 : return std::make_unique<JPEGOverviewVisibilitySetter>(
208 6719600 : m_nJPEGOverviewVisibilityCounter);
209 : }
210 :
211 : public:
212 : static constexpr int DEFAULT_COLOR_TABLE_MULTIPLIER_257 = 257;
213 :
214 : private:
215 : //! Multiplication factor to go from GDAL [0,255] color table range to
216 : // TIFF [0,65535] color map one.
217 : // 0 is not a valid value, and means not specified by user through the
218 : // COLOR_TABLE_MULTIPLIER open / creation option.
219 : int m_nColorTableMultiplier = 0;
220 :
221 : GTIFFKeysFlavorEnum m_eGeoTIFFKeysFlavor = GEOTIFF_KEYS_STANDARD;
222 : GeoTIFFVersionEnum m_eGeoTIFFVersion = GEOTIFF_VERSION_AUTO;
223 :
224 : uint16_t m_nPlanarConfig = 0;
225 : uint16_t m_nSamplesPerPixel = 0;
226 : uint16_t m_nBitsPerSample = 0;
227 : uint16_t m_nPhotometric = 0;
228 : uint16_t m_nSampleFormat = 0;
229 : uint16_t m_nCompression = 0;
230 :
231 : // If > 0, the implicit JPEG overviews are visible through
232 : // GetOverviewCount().
233 : signed char m_nJPEGOverviewVisibilityCounter = 0;
234 : signed char m_nPAMGeorefSrcIndex = -1;
235 : signed char m_nINTERNALGeorefSrcIndex = -1;
236 : signed char m_nTABFILEGeorefSrcIndex = -1;
237 : signed char m_nWORLDFILEGeorefSrcIndex = -1;
238 : signed char m_nXMLGeorefSrcIndex = -1;
239 : signed char m_nGeoTransformGeorefSrcIndex = -1;
240 :
241 : signed char m_nHasOptimizedReadMultiRange = -1;
242 :
243 : signed char m_nZLevel = -1;
244 : signed char m_nLZMAPreset = -1;
245 : signed char m_nZSTDLevel = -1;
246 : signed char m_nWebPLevel = DEFAULT_WEBP_LEVEL;
247 : signed char m_nJpegQuality = -1;
248 : signed char m_nJpegTablesMode = -1;
249 :
250 : enum class VirtualMemIOEnum : GByte
251 : {
252 : NO,
253 : YES,
254 : IF_ENOUGH_RAM
255 : };
256 :
257 : VirtualMemIOEnum m_eVirtualMemIOUsage = VirtualMemIOEnum::NO;
258 :
259 : GTiffProfile m_eProfile = GTiffProfile::GDALGEOTIFF;
260 :
261 : OGRSpatialReference m_oSRS{};
262 :
263 : GDALMultiDomainMetadata m_oGTiffMDMD{};
264 :
265 : std::vector<GTiffCompressionJob> m_asCompressionJobs{};
266 : std::queue<int> m_asQueueJobIdx{}; // queue of index of m_asCompressionJobs
267 : // being compressed in worker threads
268 :
269 : bool m_bStreamingIn : 1;
270 : bool m_bStreamingOut : 1;
271 : bool m_bScanDeferred : 1;
272 : bool m_bSingleIFDOpened = false;
273 : bool m_bLoadedBlockDirty : 1;
274 : bool m_bWriteError : 1;
275 : bool m_bLookedForProjection : 1;
276 : bool m_bLookedForMDAreaOrPoint : 1;
277 : bool m_bGeoTransformValid : 1;
278 : bool m_bCrystalized : 1;
279 : bool m_bGeoTIFFInfoChanged : 1;
280 : bool m_bForceUnsetGTOrGCPs : 1;
281 : bool m_bForceUnsetProjection : 1;
282 : bool m_bNoDataChanged : 1;
283 : bool m_bNoDataSet : 1;
284 : bool m_bNoDataSetAsInt64 : 1;
285 : bool m_bNoDataSetAsUInt64 : 1;
286 : bool m_bMetadataChanged : 1;
287 : bool m_bColorProfileMetadataChanged : 1;
288 : bool m_bForceUnsetRPC : 1;
289 : bool m_bNeedsRewrite : 1;
290 : bool m_bLoadingOtherBands : 1;
291 : bool m_bIsOverview : 1;
292 : bool m_bWriteEmptyTiles : 1; // Whether a write of a tile entirely at
293 : // nodata/0 should go to the disk. Default is
294 : // true, unless SPARSE_OK is set
295 : bool m_bFillEmptyTilesAtClosing : 1; // Might only be set to true on newly
296 : // created files, when SPARSE_OK is
297 : // not set
298 : bool m_bTreatAsSplit : 1;
299 : bool m_bTreatAsSplitBitmap : 1;
300 : bool m_bClipWarn : 1;
301 : bool m_bIMDRPCMetadataLoaded : 1;
302 : bool m_bEXIFMetadataLoaded : 1;
303 : bool m_bICCMetadataLoaded : 1;
304 : bool m_bHasWarnedDisableAggressiveBandCaching : 1;
305 : bool m_bDontReloadFirstBlock : 1; // Hack for libtiff 3.X and #3633.
306 : bool m_bWebPLossless : 1;
307 : bool m_bPromoteTo8Bits : 1;
308 : bool m_bDebugDontWriteBlocks : 1;
309 : bool m_bIsFinalized : 1;
310 : bool m_bIgnoreReadErrors : 1;
311 : bool m_bDirectIO : 1;
312 : bool m_bReadGeoTransform : 1;
313 : bool m_bLoadPam : 1;
314 : bool m_bENVIHdrTried : 1;
315 : bool m_bENVIHdrFound : 1;
316 : bool m_bHasGotSiblingFiles : 1;
317 : bool m_bHasIdentifiedAuthorizedGeoreferencingSources : 1;
318 : bool m_bLayoutIFDSBeforeData : 1;
319 : bool m_bBlockOrderRowMajor : 1;
320 : bool m_bLeaderSizeAsUInt4 : 1;
321 : bool m_bTrailerRepeatedLast4BytesRepeated : 1;
322 : bool m_bMaskInterleavedWithImagery : 1;
323 : bool m_bKnownIncompatibleEdition : 1;
324 : bool m_bWriteKnownIncompatibleEdition : 1;
325 : bool m_bHasUsedReadEncodedAPI : 1; // for debugging
326 : bool m_bWriteCOGLayout : 1;
327 : bool m_bTileInterleave : 1;
328 : bool m_bLayoutChecked : 1;
329 :
330 : void ScanDirectories();
331 : bool ReadStrile(int nBlockId, void *pOutputBuffer,
332 : GPtrDiff_t nBlockReqSize);
333 : CPLErr LoadBlockBuf(int nBlockId, bool bReadFromDisk = true);
334 : CPLErr FlushBlockBuf();
335 :
336 : void LoadMDAreaOrPoint();
337 : void LookForProjection();
338 : void LookForProjectionFromGeoTIFF();
339 : void LookForProjectionFromXML();
340 :
341 : void Crystalize(); // TODO: Spelling.
342 : void RestoreVolatileParameters(TIFF *hTIFF);
343 :
344 : void WriteGeoTIFFInfo();
345 : bool SetDirectory();
346 : void ReloadDirectory(bool bReopenHandle = false);
347 :
348 : int GetJPEGOverviewCount();
349 :
350 : bool IsBlockAvailable(int nBlockId, vsi_l_offset *pnOffset,
351 : vsi_l_offset *pnSize, bool *pbErrOccurred);
352 :
353 : void ApplyPamInfo();
354 : void PushMetadataToPam();
355 :
356 : bool WriteEncodedTile(uint32_t tile, GByte *pabyData,
357 : int bPreserveDataBuffer);
358 : bool WriteEncodedStrip(uint32_t strip, GByte *pabyData,
359 : int bPreserveDataBuffer);
360 :
361 : template <typename T>
362 : void WriteDealWithLercAndNan(T *pBuffer, int nActualBlockWidth,
363 : int nActualBlockHeight, int nStrileHeight);
364 :
365 : bool HasOnlyNoData(const void *pBuffer, int nWidth, int nHeight,
366 : int nLineStride, int nComponents);
367 : inline bool IsFirstPixelEqualToNoData(const void *pBuffer);
368 :
369 : CPLErr FillEmptyTiles();
370 :
371 : CPLErr FlushDirectory();
372 : CPLErr CleanOverviews();
373 :
374 : void LoadMetadata();
375 : void LoadEXIFMetadata();
376 : void LoadICCProfile();
377 :
378 : CPLErr RegisterNewOverviewDataset(toff_t nOverviewOffset,
379 : int l_nJpegQuality,
380 : CSLConstList papszOptions);
381 : CPLErr CreateOverviewsFromSrcOverviews(GDALDataset *poSrcDS,
382 : GDALDataset *poOvrDS,
383 : int nOverviews);
384 : CPLErr CreateInternalMaskOverviews(int nOvrBlockXSize, int nOvrBlockYSize);
385 : std::tuple<CPLErr, bool> Finalize();
386 :
387 : void DiscardLsb(GByte *pabyBuffer, GPtrDiff_t nBytes, int iBand) const;
388 : void GetDiscardLsbOption(char **papszOptions);
389 : void InitCompressionThreads(bool bUpdateMode, CSLConstList papszOptions);
390 : void InitCreationOrOpenOptions(bool bUpdateMode, CSLConstList papszOptions);
391 : static void ThreadCompressionFunc(void *pData);
392 : void WaitCompletionForJobIdx(int i);
393 : void WaitCompletionForBlock(int nBlockId);
394 : void WriteRawStripOrTile(int nStripOrTile, GByte *pabyCompressedBuffer,
395 : GPtrDiff_t nCompressedBufferSize);
396 : bool SubmitCompressionJob(int nStripOrTile, GByte *pabyData, GPtrDiff_t cc,
397 : int nHeight);
398 :
399 : int GuessJPEGQuality(bool &bOutHasQuantizationTable,
400 : bool &bOutHasHuffmanTable);
401 :
402 : void SetJPEGQualityAndTablesModeFromFile(int nQuality,
403 : bool bHasQuantizationTable,
404 : bool bHasHuffmanTable);
405 :
406 : int DirectIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
407 : int nYSize, void *pData, int nBufXSize, int nBufYSize,
408 : GDALDataType eBufType, int nBandCount, const int *panBandMap,
409 : GSpacing nPixelSpace, GSpacing nLineSpace, GSpacing nBandSpace,
410 : GDALRasterIOExtraArg *psExtraArg);
411 :
412 : int VirtualMemIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
413 : int nYSize, void *pData, int nBufXSize, int nBufYSize,
414 : GDALDataType eBufType, int nBandCount,
415 : const int *panBandMap, GSpacing nPixelSpace,
416 : GSpacing nLineSpace, GSpacing nBandSpace,
417 : GDALRasterIOExtraArg *psExtraArg);
418 :
419 : void SetStructuralMDFromParent(GTiffDataset *poParentDS);
420 :
421 : template <class FetchBuffer>
422 : CPLErr CommonDirectIO(FetchBuffer &oFetcher, int nXOff, int nYOff,
423 : int nXSize, int nYSize, void *pData, int nBufXSize,
424 : int nBufYSize, GDALDataType eBufType, int nBandCount,
425 : const int *panBandMap, GSpacing nPixelSpace,
426 : GSpacing nLineSpace, GSpacing nBandSpace);
427 :
428 : CPLErr CommonDirectIOClassic(FetchBufferDirectIO &oFetcher, int nXOff,
429 : int nYOff, int nXSize, int nYSize, void *pData,
430 : int nBufXSize, int nBufYSize,
431 : GDALDataType eBufType, int nBandCount,
432 : const int *panBandMap, GSpacing nPixelSpace,
433 : GSpacing nLineSpace, GSpacing nBandSpace);
434 :
435 : std::string GetSidecarFilenameWithReplacedExtension(const char *pszExt);
436 :
437 : void LoadGeoreferencingAndPamIfNeeded();
438 :
439 : void LoadENVIHdrIfNeeded();
440 :
441 : CSLConstList GetSiblingFiles();
442 :
443 : void IdentifyAuthorizedGeoreferencingSources();
444 :
445 : CPLErr FlushCacheInternal(bool bAtClosing, bool bFlushDirectory);
446 : bool HasOptimizedReadMultiRange();
447 :
448 : bool AssociateExternalMask();
449 :
450 : static bool MustCreateInternalMask();
451 :
452 : static CPLErr CopyImageryAndMask(GTiffDataset *poDstDS,
453 : GDALDataset *poSrcDS,
454 : GDALRasterBand *poSrcMaskBand,
455 : GDALProgressFunc pfnProgress,
456 : void *pProgressData);
457 :
458 : bool GetOverviewParameters(int &nCompression, uint16_t &nPlanarConfig,
459 : uint16_t &nPredictor, uint16_t &nPhotometric,
460 : int &nOvrJpegQuality, std::string &osNoData,
461 : uint16_t *&panExtraSampleValues,
462 : uint16_t &nExtraSamples,
463 : CSLConstList papszOptions) const;
464 :
465 : bool IsWholeBlock(int nXOff, int nYOff, int nXSize, int nYSize) const;
466 :
467 : void *CacheMultiRange(int nXOff, int nYOff, int nXSize, int nYSize,
468 : int nBufXSize, int nBufYSize, const int *panBandMap,
469 : int nBandCount, GDALRasterIOExtraArg *psExtraArg);
470 :
471 : bool CheckCOGLayout();
472 :
473 : static void ThreadDecompressionFunc(void *pData);
474 :
475 : static GTIF *GTIFNew(TIFF *hTIFF);
476 :
477 : static constexpr const char *DEFAULT_RASTER_ATTRIBUTE_TABLE =
478 : "DEFAULT_RASTER_ATTRIBUTE_TABLE";
479 : static constexpr const char *RAT_ROLE = "rat";
480 :
481 : protected:
482 : int CloseDependentDatasets() override;
483 :
484 : public:
485 : GTiffDataset();
486 : ~GTiffDataset() override;
487 :
488 : CPLErr Close(GDALProgressFunc = nullptr, void * = nullptr) override;
489 :
490 : const OGRSpatialReference *GetSpatialRef() const override;
491 : CPLErr SetSpatialRef(const OGRSpatialReference *poSRS) override;
492 :
493 : CPLErr GetGeoTransform(GDALGeoTransform >) const override;
494 : CPLErr SetGeoTransform(const GDALGeoTransform >) override;
495 :
496 : int GetGCPCount() override;
497 : const OGRSpatialReference *GetGCPSpatialRef() const override;
498 : const GDAL_GCP *GetGCPs() override;
499 : CPLErr SetGCPs(int nGCPCountIn, const GDAL_GCP *pasGCPListIn,
500 : const OGRSpatialReference *poSRS) override;
501 :
502 : bool IsMultiThreadedReadCompatible() const;
503 : CPLErr MultiThreadedRead(int nXOff, int nYOff, int nXSize, int nYSize,
504 : void *pData, GDALDataType eBufType, int nBandCount,
505 : const int *panBandMap, GSpacing nPixelSpace,
506 : GSpacing nLineSpace, GSpacing nBandSpace);
507 :
508 : CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
509 : int nYSize, void *pData, int nBufXSize, int nBufYSize,
510 : GDALDataType eBufType, int nBandCount,
511 : BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
512 : GSpacing nLineSpace, GSpacing nBandSpace,
513 : GDALRasterIOExtraArg *psExtraArg) override;
514 :
515 : virtual CPLStringList
516 : GetCompressionFormats(int nXOff, int nYOff, int nXSize, int nYSize,
517 : int nBandCount, const int *panBandList) override;
518 : virtual CPLErr ReadCompressedData(const char *pszFormat, int nXOff,
519 : int nYOff, int nXSize, int nYSize,
520 : int nBandCount, const int *panBandList,
521 : void **ppBuffer, size_t *pnBufferSize,
522 : char **ppszDetailedFormat) override;
523 :
524 : char **GetFileList() override;
525 :
526 : CPLErr IBuildOverviews(const char *, int, const int *, int, const int *,
527 : GDALProgressFunc, void *,
528 : CSLConstList papszOptions) override;
529 :
530 : virtual CPLErr AddOverviews(const std::vector<GDALDataset *> &apoSrcOvrDS,
531 : GDALProgressFunc pfnProgress,
532 : void *pProgressData,
533 : CSLConstList papszOptions) override;
534 :
535 : bool ComputeBlocksPerColRowAndBand(int l_nBands);
536 :
537 : CPLErr OpenOffset(TIFF *, toff_t nDirOffset, GDALAccess,
538 : bool bAllowRGBAInterface = true,
539 : bool bReadGeoTransform = false);
540 :
541 : static GDALDataset *OpenDir(GDALOpenInfo *);
542 : static GDALDataset *Open(GDALOpenInfo *);
543 : static int Identify(GDALOpenInfo *);
544 : static GDALDataset *Create(const char *pszFilename, int nXSize, int nYSize,
545 : int nBands, GDALDataType eType,
546 : char **papszParamList);
547 : static GDALDataset *CreateCopy(const char *pszFilename,
548 : GDALDataset *poSrcDS, int bStrict,
549 : char **papszOptions,
550 : GDALProgressFunc pfnProgress,
551 : void *pProgressData);
552 : CPLErr FlushCache(bool bAtClosing) override;
553 :
554 : char **GetMetadataDomainList() override;
555 : CPLErr SetMetadata(char **, const char * = "") override;
556 : char **GetMetadata(const char *pszDomain = "") override;
557 : CPLErr SetMetadataItem(const char *, const char *,
558 : const char * = "") override;
559 : virtual const char *GetMetadataItem(const char *pszName,
560 : const char *pszDomain = "") override;
561 : void *GetInternalHandle(const char *) override;
562 :
563 : CPLErr CreateMaskBand(int nFlags) override;
564 :
565 : bool GetRawBinaryLayout(GDALDataset::RawBinaryLayout &) override;
566 :
567 : // Only needed by createcopy and close code.
568 : static void WriteRPC(GDALDataset *, TIFF *, int, GTiffProfile, const char *,
569 : CSLConstList papszCreationOptions,
570 : bool bWriteOnlyInPAMIfNeeded = false);
571 : static bool WriteMetadata(GDALDataset *, TIFF *, bool, GTiffProfile,
572 : const char *, CSLConstList papszCreationOptions,
573 : bool bExcludeRPBandIMGFileWriting = false);
574 : static void WriteNoDataValue(TIFF *, double);
575 : static void WriteNoDataValue(TIFF *, int64_t);
576 : static void WriteNoDataValue(TIFF *, uint64_t);
577 : static void UnsetNoDataValue(TIFF *);
578 :
579 : static TIFF *CreateLL(const char *pszFilename, int nXSize, int nYSize,
580 : int nBands, GDALDataType eType,
581 : double dfExtraSpaceForOverviews,
582 : int nColorTableMultiplier, char **papszParamList,
583 : VSILFILE **pfpL, CPLString &osTmpFilename,
584 : bool bCreateCopy, bool &bTileInterleavingOut);
585 :
586 : CPLErr WriteEncodedTileOrStrip(uint32_t tile_or_strip, void *data,
587 : int bPreserveDataBuffer);
588 :
589 : static void SaveICCProfile(GTiffDataset *pDS, TIFF *hTIFF,
590 : char **papszParamList, uint32_t nBitsPerSample);
591 :
592 : static const GTIFFTag *GetTIFFTags();
593 :
594 : static unsigned short ClampCTEntry(int iColor, int iComp, int nCTEntryVal,
595 : int nMultFactor);
596 : };
597 :
598 : GTIFFKeysFlavorEnum GetGTIFFKeysFlavor(CSLConstList papszOptions);
599 : GeoTIFFVersionEnum GetGeoTIFFVersion(CSLConstList papszOptions);
600 : void GTiffSetDeflateSubCodec(TIFF *hTIFF);
601 :
602 : #endif // GTIFFDATASET_H_INCLUDED
|
