Line data Source code
1 : /******************************************************************************
2 : * $Id$
3 : *
4 : * Project: GDAL
5 : * Purpose: ECW (ERDAS Wavelet Compression Format) Driver Definitions
6 : * Author: Frank Warmerdam, warmerdam@pobox.com
7 : *
8 : ******************************************************************************
9 : * Copyright (c) 2001-2011, Frank Warmerdam <warmerdam@pobox.com>
10 : * Copyright (c) 2013, Even Rouault <even dot rouault at spatialys.com>
11 : *
12 : * SPDX-License-Identifier: MIT
13 : ****************************************************************************/
14 :
15 : #ifndef GDAL_ECW_H_INCLUDED
16 : #define GDAL_ECW_H_INCLUDED
17 :
18 : #include "gdaljp2abstractdataset.h"
19 : #include "gdal_frmts.h"
20 : #include "cpl_string.h"
21 : #include "cpl_conv.h"
22 : #include "cpl_multiproc.h"
23 : #include "cpl_vsi.h"
24 :
25 : #undef NOISY_DEBUG
26 :
27 : #include "ecwsdk_headers.h"
28 :
29 : #if ECWSDK_VERSION >= 55
30 : #include "NCSIOStreamOptions.h"
31 : #endif
32 :
33 : void ECWInitialize(void);
34 : GDALDataset *ECWDatasetOpenJPEG2000(GDALOpenInfo *poOpenInfo);
35 : const char *ECWGetColorInterpretationName(GDALColorInterp eColorInterpretation,
36 : int nBandNumber);
37 : GDALColorInterp ECWGetColorInterpretationByName(const char *pszName);
38 : const char *ECWGetColorSpaceName(NCSFileColorSpace colorSpace);
39 : #ifdef HAVE_COMPRESS
40 : GDALDataset *ECWCreateCopyECW(const char *pszFilename, GDALDataset *poSrcDS,
41 : int bStrict, char **papszOptions,
42 : GDALProgressFunc pfnProgress,
43 : void *pProgressData);
44 : GDALDataset *ECWCreateCopyJPEG2000(const char *pszFilename,
45 : GDALDataset *poSrcDS, int bStrict,
46 : char **papszOptions,
47 : GDALProgressFunc pfnProgress,
48 : void *pProgressData);
49 :
50 : GDALDataset *ECWCreateECW(const char *pszFilename, int nXSize, int nYSize,
51 : int nBands, GDALDataType eType, char **papszOptions);
52 : GDALDataset *ECWCreateJPEG2000(const char *pszFilename, int nXSize, int nYSize,
53 : int nBands, GDALDataType eType,
54 : char **papszOptions);
55 : #endif
56 :
57 : void ECWReportError(CNCSError &oErr, const char *pszMsg = "");
58 :
59 : /************************************************************************/
60 : /* ==================================================================== */
61 : /* JP2Userbox */
62 : /* ==================================================================== */
63 : /************************************************************************/
64 : #ifdef HAVE_COMPRESS
65 : #if ECWSDK_VERSION >= 50
66 : class JP2UserBox final : public CNCSSDKBox
67 : {
68 : #else
69 : class JP2UserBox final : public CNCSJP2Box
70 : {
71 : #endif
72 : private:
73 : int nDataLength;
74 : unsigned char *pabyData;
75 :
76 : public:
77 : JP2UserBox();
78 :
79 : virtual ~JP2UserBox();
80 :
81 : #if ECWSDK_VERSION >= 55
82 : CNCSError Parse(NCS::SDK::CFileBase &JP2File,
83 : const NCS::CIOStreamPtr &Stream) override;
84 : CNCSError UnParse(NCS::SDK::CFileBase &JP2File,
85 : const NCS::CIOStreamPtr &Stream) override;
86 : #elif ECWSDK_VERSION >= 40
87 : virtual CNCSError Parse(NCS::SDK::CFileBase &JP2File,
88 : NCS::CIOStream &Stream) override;
89 : virtual CNCSError UnParse(NCS::SDK::CFileBase &JP2File,
90 : NCS::CIOStream &Stream) override;
91 : #else
92 : virtual CNCSError Parse(class CNCSJP2File &JP2File,
93 : CNCSJPCIOStream &Stream) override;
94 : virtual CNCSError UnParse(class CNCSJP2File &JP2File,
95 : CNCSJPCIOStream &Stream) override;
96 : #endif
97 : virtual void UpdateXLBox() override;
98 :
99 : void SetData(int nDataLength, const unsigned char *pabyDataIn);
100 :
101 : int GetDataLength()
102 : {
103 : return nDataLength;
104 : }
105 :
106 : unsigned char *GetData()
107 : {
108 : return pabyData;
109 : }
110 : };
111 : #endif /* def HAVE_COMPRESS */
112 :
113 : /************************************************************************/
114 : /* ==================================================================== */
115 : /* VSIIOStream */
116 : /* ==================================================================== */
117 : /************************************************************************/
118 :
119 : class VSIIOStream final : public CNCSJPCIOStream
120 : {
121 : VSIIOStream(const VSIIOStream &) = delete;
122 : VSIIOStream &operator=(const VSIIOStream &) = delete;
123 : VSIIOStream(VSIIOStream &&) = delete;
124 : VSIIOStream &operator=(VSIIOStream &&) = delete;
125 :
126 : char *m_Filename = nullptr;
127 :
128 : public:
129 : INT64 startOfJPData = 0;
130 : INT64 lengthOfJPData = -1;
131 : VSILFILE *fpVSIL = nullptr;
132 : BOOLEAN bWritable = false;
133 : BOOLEAN bSeekable = false;
134 : int nFileViewCount = 0;
135 :
136 : int nCOMState = 0;
137 : int nCOMLength = 0;
138 : GByte abyCOMType[2]{};
139 :
140 : /* To fix ‘virtual bool NCS::CIOStream::Read(INT64, void*, UINT32)’ was
141 : * hidden' with SDK 5 */
142 : using CNCSJPCIOStream::Read;
143 :
144 121 : VSIIOStream()
145 121 : {
146 121 : if (CSLTestBoolean(CPLGetConfigOption(
147 121 : "GDAL_ECW_WRITE_COMPRESSION_SOFTWARE", "YES")))
148 121 : nCOMState = -1;
149 121 : abyCOMType[0] = 0;
150 121 : abyCOMType[1] = 0;
151 121 : }
152 :
153 174 : virtual ~VSIIOStream()
154 121 : {
155 121 : VSIIOStream::Close();
156 121 : if (m_Filename != nullptr)
157 : {
158 84 : CPLFree(m_Filename);
159 : }
160 174 : }
161 :
162 238 : CNCSError Close() override
163 : {
164 238 : CNCSError oErr = CNCSJPCIOStream::Close();
165 238 : if (fpVSIL != nullptr)
166 : {
167 84 : VSIFCloseL(fpVSIL);
168 84 : fpVSIL = nullptr;
169 : }
170 238 : return oErr;
171 : }
172 :
173 : #if ECWSDK_VERSION >= 40
174 : VSIIOStream *Clone() override
175 : {
176 : CPLDebug("ECW", "VSIIOStream::Clone()");
177 : VSILFILE *fpNewVSIL = VSIFOpenL(m_Filename, "rb");
178 : if (fpNewVSIL == nullptr)
179 : {
180 : return nullptr;
181 : }
182 :
183 : VSIIOStream *pDst = new VSIIOStream();
184 : pDst->Access(fpNewVSIL, bWritable, bSeekable, m_Filename, startOfJPData,
185 : lengthOfJPData);
186 : return pDst;
187 : }
188 : #endif /* ECWSDK_VERSION >= 4 */
189 :
190 84 : CNCSError Access(VSILFILE *fpVSILIn, BOOLEAN bWrite, BOOLEAN bSeekableIn,
191 : const char *pszFilename, INT64 start, INT64 size = -1)
192 : {
193 :
194 84 : fpVSIL = fpVSILIn;
195 84 : startOfJPData = start;
196 84 : lengthOfJPData = size;
197 84 : bWritable = bWrite;
198 84 : bSeekable = bSeekableIn;
199 84 : VSIFSeekL(fpVSIL, startOfJPData, SEEK_SET);
200 84 : m_Filename = CPLStrdup(pszFilename);
201 :
202 : #if ECWSDK_VERSION >= 55
203 : const std::string vsiStreamPrefix("STREAM=/vsi");
204 : const std::string vsiPrefix("/vsi");
205 : m_StreamOptions->SetIsRemoteStream(
206 : std::string(m_Filename).compare(0, vsiPrefix.length(), vsiPrefix) ==
207 : 0 ||
208 : std::string(m_Filename)
209 : .compare(0, vsiStreamPrefix.length(), vsiStreamPrefix) ==
210 : 0);
211 : #endif
212 : // the filename is used to establish where to put temporary files.
213 : // if it does not have a path to a real directory, we will
214 : // substitute something.
215 168 : CPLString osFilenameUsed = pszFilename;
216 :
217 : #if ECWSDK_VERSION < 55
218 168 : CPLString osPath = CPLGetPath(pszFilename);
219 : struct stat sStatBuf;
220 84 : if (!osPath.empty() && stat(osPath, &sStatBuf) != 0)
221 : {
222 69 : osFilenameUsed = CPLGenerateTempFilename(nullptr);
223 : // try to preserve the extension.
224 69 : if (strlen(CPLGetExtension(pszFilename)) > 0)
225 : {
226 68 : osFilenameUsed += ".";
227 68 : osFilenameUsed += CPLGetExtension(pszFilename);
228 : }
229 69 : CPLDebug("ECW",
230 : "Using filename '%s' for temporary directory "
231 : "determination purposes.",
232 : osFilenameUsed.c_str());
233 : }
234 : #endif
235 :
236 : #ifdef _WIN32
237 : if (CSLTestBoolean(CPLGetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")))
238 : {
239 : wchar_t *pwszFilename = CPLRecodeToWChar(
240 : osFilenameUsed.c_str(), CPL_ENC_UTF8, CPL_ENC_UCS2);
241 : CNCSError oError;
242 : oError = CNCSJPCIOStream::Open(pwszFilename, (bool)bWrite);
243 : CPLFree(pwszFilename);
244 : return oError;
245 : }
246 : else
247 : #endif
248 : {
249 84 : return (CNCSJPCIOStream::Open((char *)osFilenameUsed.c_str(),
250 168 : (bool)bWrite));
251 : }
252 : }
253 :
254 396 : virtual bool NCS_FASTCALL Seek() override
255 : {
256 396 : return bSeekable;
257 : }
258 :
259 1589 : virtual bool NCS_FASTCALL Seek(INT64 offset,
260 : Origin origin = CURRENT) override
261 : {
262 : #ifdef DEBUG_VERBOSE
263 : CPLDebug("ECW", "VSIIOStream::Seek(" CPL_FRMT_GIB ",%d)",
264 : static_cast<GIntBig>(offset), (int)origin);
265 : #endif
266 1589 : bool success = false;
267 1589 : switch (origin)
268 : {
269 1303 : case START:
270 1303 : success =
271 1303 : (0 == VSIFSeekL(fpVSIL, offset + startOfJPData, SEEK_SET));
272 1303 : break;
273 :
274 0 : case CURRENT:
275 0 : success = (0 == VSIFSeekL(fpVSIL, offset, SEEK_CUR));
276 0 : break;
277 :
278 286 : case END:
279 286 : success = (0 == VSIFSeekL(fpVSIL, offset, SEEK_END));
280 286 : break;
281 : }
282 1589 : if (!success)
283 0 : CPLDebug("ECW", "VSIIOStream::Seek(%d,%d) failed.", (int)offset,
284 : (int)origin);
285 1589 : return (success);
286 : }
287 :
288 6027 : virtual INT64 NCS_FASTCALL Tell() override
289 : {
290 6027 : return VSIFTellL(fpVSIL) - startOfJPData;
291 : }
292 :
293 286 : virtual INT64 NCS_FASTCALL Size() override
294 : {
295 286 : if (lengthOfJPData != -1)
296 0 : return lengthOfJPData;
297 : else
298 : {
299 286 : INT64 curPos = Tell(), size;
300 :
301 286 : Seek(0, END);
302 286 : size = Tell();
303 286 : Seek(curPos, START);
304 : #ifdef DEBUG_VERBOSE
305 : CPLDebug("ECW", "VSIIOStream::Size()=" CPL_FRMT_GIB,
306 : static_cast<GIntBig>(size));
307 : #endif
308 286 : return size;
309 : }
310 : }
311 :
312 : #if ECWSDK_VERSION >= 40
313 : /* New, and needed, in ECW SDK 4 */
314 : virtual bool Read(INT64 offset, void *buffer, UINT32 count) override
315 : {
316 : #ifdef DEBUG_VERBOSE
317 : CPLDebug("ECW", "VSIIOStream::Read(" CPL_FRMT_GIB ",%u)",
318 : static_cast<GIntBig>(offset), count);
319 : #endif
320 : /* SDK 4.3 doc says it is not supposed to update the file pointer. */
321 : /* Later versions have no comment... */
322 : INT64 curPos = Tell();
323 : Seek(offset, START);
324 : bool ret = Read(buffer, count);
325 : Seek(curPos, START);
326 : return ret;
327 : }
328 : #endif
329 :
330 10038 : virtual bool NCS_FASTCALL Read(void *buffer, UINT32 count) override
331 : {
332 : #ifdef DEBUG_VERBOSE
333 : CPLDebug("ECW", "VSIIOStream::Read(%u)", count);
334 : #endif
335 10038 : if (count == 0)
336 366 : return true;
337 :
338 : // return(1 == VSIFReadL( buffer, count, 1, fpVSIL ) );
339 :
340 : // The following is a hack
341 9672 : if (VSIFReadL(buffer, count, 1, fpVSIL) != 1)
342 : {
343 0 : CPLDebug("VSIIOSTREAM",
344 : "Read(%d) failed @ " CPL_FRMT_GIB ", ignoring failure.",
345 0 : count, (VSIFTellL(fpVSIL) - startOfJPData));
346 : }
347 :
348 9672 : return true;
349 : }
350 :
351 5350 : virtual bool NCS_FASTCALL Write(void *buffer, UINT32 count) override
352 : {
353 5350 : if (count == 0)
354 0 : return true;
355 :
356 5350 : GByte *paby = (GByte *)buffer;
357 5350 : if (nCOMState == 0)
358 : {
359 0 : if (count == 2 && paby[0] == 0xff && paby[1] == 0x64)
360 : {
361 0 : nCOMState++;
362 0 : return true;
363 : }
364 : }
365 5350 : else if (nCOMState == 1)
366 : {
367 0 : if (count == 2)
368 : {
369 0 : nCOMLength = (paby[0] << 8) | paby[1];
370 0 : nCOMState++;
371 0 : return true;
372 : }
373 : else
374 : {
375 0 : GByte prevBuffer[] = {0xff, 0x64};
376 0 : VSIFWriteL(prevBuffer, 2, 1, fpVSIL);
377 0 : nCOMState = 0;
378 : }
379 : }
380 5350 : else if (nCOMState == 2)
381 : {
382 0 : if (count == 2)
383 : {
384 0 : abyCOMType[0] = paby[0];
385 0 : abyCOMType[1] = paby[1];
386 0 : nCOMState++;
387 0 : return true;
388 : }
389 : else
390 : {
391 0 : GByte prevBuffer[] = {(GByte)(nCOMLength >> 8),
392 0 : (GByte)(nCOMLength & 0xff)};
393 0 : VSIFWriteL(prevBuffer, 2, 1, fpVSIL);
394 0 : nCOMState = 0;
395 : }
396 : }
397 5350 : else if (nCOMState == 3)
398 : {
399 0 : if (count == (UINT32)nCOMLength - 4)
400 : {
401 0 : nCOMState = 0;
402 0 : return true;
403 : }
404 : else
405 : {
406 0 : VSIFWriteL(abyCOMType, 2, 1, fpVSIL);
407 0 : nCOMState = 0;
408 : }
409 : }
410 :
411 5350 : if (1 != VSIFWriteL(buffer, count, 1, fpVSIL))
412 : {
413 0 : CPLDebug("ECW", "VSIIOStream::Write(%d) failed.", (int)count);
414 0 : return false;
415 : }
416 : else
417 5350 : return true;
418 : }
419 : };
420 :
421 : /************************************************************************/
422 : /* ==================================================================== */
423 : /* ECWAsyncReader */
424 : /* ==================================================================== */
425 : /************************************************************************/
426 : class ECWDataset;
427 :
428 : #if ECWSDK_VERSION >= 40
429 :
430 : class ECWAsyncReader final : public GDALAsyncReader
431 : {
432 : private:
433 : CNCSJP2FileView *poFileView = nullptr;
434 : CPLMutex *hMutex = nullptr;
435 : int bUsingCustomStream = false;
436 :
437 : int bUpdateReady = false;
438 : int bComplete = false;
439 :
440 : static NCSEcwReadStatus RefreshCB(NCSFileView *);
441 : NCSEcwReadStatus ReadToBuffer();
442 :
443 : public:
444 : ECWAsyncReader();
445 : virtual ~ECWAsyncReader();
446 : virtual GDALAsyncStatusType
447 : GetNextUpdatedRegion(double dfTimeout, int *pnXBufOff, int *pnYBufOff,
448 : int *pnXBufSize, int *pnYBufSize) override;
449 :
450 : friend class ECWDataset;
451 : };
452 : #endif /* ECWSDK_VERSION >= 40 */
453 :
454 : /************************************************************************/
455 : /* ==================================================================== */
456 : /* ECWDataset */
457 : /* ==================================================================== */
458 : /************************************************************************/
459 :
460 : class ECWRasterBand;
461 :
462 : typedef struct
463 : {
464 : int bEnabled;
465 : int nBandsTried;
466 :
467 : int nXOff;
468 : int nYOff;
469 : int nXSize;
470 : int nYSize;
471 : int nBufXSize;
472 : int nBufYSize;
473 : GDALDataType eBufType;
474 : GByte *pabyData;
475 : } ECWCachedMultiBandIO;
476 :
477 : class CPL_DLL ECWDataset final : public GDALJP2AbstractDataset
478 : {
479 : friend class ECWRasterBand;
480 : friend class ECWAsyncReader;
481 :
482 : int bIsJPEG2000;
483 :
484 : CNCSJP2FileView *poFileView;
485 : NCSFileViewFileInfoEx *psFileInfo;
486 :
487 : GDALDataType eRasterDataType;
488 : NCSEcwCellType eNCSRequestDataType;
489 :
490 : int bUsingCustomStream;
491 :
492 : // Current view window.
493 : int bWinActive;
494 : int nWinXOff, nWinYOff, nWinXSize, nWinYSize;
495 : int nWinBufXSize, nWinBufYSize;
496 : int nWinBandCount;
497 : int *panWinBandList;
498 : int nWinBufLoaded;
499 : void **papCurLineBuf;
500 :
501 : // Deferred advise read parameters
502 : int m_nAdviseReadXOff;
503 : int m_nAdviseReadYOff;
504 : int m_nAdviseReadXSize;
505 : int m_nAdviseReadYSize;
506 : int m_nAdviseReadBufXSize;
507 : int m_nAdviseReadBufYSize;
508 : int m_nAdviseReadBandCount;
509 : int *m_panAdviseReadBandList;
510 :
511 : char **papszGMLMetadata;
512 :
513 : ECWCachedMultiBandIO sCachedMultiBandIO;
514 :
515 : void ECW2WKTProjection();
516 :
517 : void CleanupWindow();
518 : CPLErr RunDeferredAdviseRead();
519 : int TryWinRasterIO(GDALRWFlag, int, int, int, int, GByte *, int, int,
520 : GDALDataType, int, const int *, GSpacing nPixelSpace,
521 : GSpacing nLineSpace, GSpacing nBandSpace,
522 : GDALRasterIOExtraArg *psExtraArg);
523 : CPLErr LoadNextLine();
524 :
525 : #if ECWSDK_VERSION >= 50
526 :
527 : NCSFileStatistics *pStatistics;
528 : int bStatisticsDirty;
529 : int bStatisticsInitialized;
530 : NCS::CError StatisticsEnsureInitialized();
531 : NCS::CError StatisticsWrite();
532 : void CleanupStatistics();
533 : void ReadFileMetaDataFromFile();
534 :
535 : int bFileMetaDataDirty;
536 : void WriteFileMetaData(NCSFileMetaData *pFileMetaDataCopy);
537 :
538 : #endif
539 :
540 : static CNCSJP2FileView *OpenFileView(const char *pszDatasetName,
541 : bool bProgressive,
542 : int &bUsingCustomStream,
543 : bool bWrite = false);
544 :
545 : int bHdrDirty;
546 : CPLString m_osDatumCode;
547 : CPLString m_osProjCode;
548 : CPLString m_osUnitsCode;
549 : int bGeoTransformChanged;
550 : int bProjectionChanged;
551 : int bProjCodeChanged;
552 : int bDatumCodeChanged;
553 : int bUnitsCodeChanged;
554 : void WriteHeader();
555 :
556 : int bUseOldBandRasterIOImplementation;
557 :
558 : int bPreventCopyingSomeMetadata;
559 :
560 : int nBandIndexToPromoteTo8Bit;
561 :
562 : CPLStringList oECWMetadataList;
563 : CPLErr ReadBands(void *pData, int nBufXSize, int nBufYSize,
564 : GDALDataType eBufType, int nBandCount,
565 : GSpacing nPixelSpace, GSpacing nLineSpace,
566 : GSpacing nBandSpace, GDALRasterIOExtraArg *psExtraArg);
567 : CPLErr ReadBandsDirectly(void *pData, int nBufXSize, int nBufYSize,
568 : GDALDataType eBufType, int nBandCount,
569 : GSpacing nPixelSpace, GSpacing nLineSpace,
570 : GSpacing nBandSpace,
571 : GDALRasterIOExtraArg *psExtraArg);
572 :
573 : public:
574 : explicit ECWDataset(int bIsJPEG2000);
575 : ~ECWDataset();
576 :
577 : static GDALDataset *Open(GDALOpenInfo *, int bIsJPEG2000);
578 : static GDALDataset *OpenJPEG2000(GDALOpenInfo *);
579 : static GDALDataset *OpenECW(GDALOpenInfo *);
580 :
581 62 : void SetPreventCopyingSomeMetadata(int b)
582 : {
583 62 : bPreventCopyingSomeMetadata = b;
584 62 : }
585 :
586 : virtual CPLErr IRasterIO(GDALRWFlag, int, int, int, int, void *, int, int,
587 : GDALDataType, int, BANDMAP_TYPE,
588 : GSpacing nPixelSpace, GSpacing nLineSpace,
589 : GSpacing nBandSpace,
590 : GDALRasterIOExtraArg *psExtraArg) override;
591 :
592 : virtual char **GetMetadataDomainList() override;
593 : virtual const char *GetMetadataItem(const char *pszName,
594 : const char *pszDomain = "") override;
595 : virtual char **GetMetadata(const char *pszDomain = "") override;
596 :
597 : virtual CPLErr SetGeoTransform(double *padfGeoTransform) override;
598 : CPLErr SetSpatialRef(const OGRSpatialReference *poSRS) override;
599 :
600 : virtual CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
601 : const char *pszDomain = "") override;
602 : virtual CPLErr SetMetadata(char **papszMetadata,
603 : const char *pszDomain = "") override;
604 :
605 : virtual CPLErr AdviseRead(int nXOff, int nYOff, int nXSize, int nYSize,
606 : int nBufXSize, int nBufYSize, GDALDataType eDT,
607 : int nBandCount, int *panBandList,
608 : char **papszOptions) override;
609 :
610 : // progressive methods
611 : #if ECWSDK_VERSION >= 40
612 : virtual GDALAsyncReader *
613 : BeginAsyncReader(int nXOff, int nYOff, int nXSize, int nYSize, void *pBuf,
614 : int nBufXSize, int nBufYSize, GDALDataType eBufType,
615 : int nBandCount, int *panBandMap, int nPixelSpace,
616 : int nLineSpace, int nBandSpace,
617 : char **papszOptions) override;
618 :
619 : virtual void EndAsyncReader(GDALAsyncReader *) override;
620 : #endif /* ECWSDK_VERSION > 40 */
621 : #if ECWSDK_VERSION >= 50
622 : int GetFormatVersion() const
623 : {
624 : return psFileInfo->nFormatVersion;
625 : }
626 : #endif
627 : };
628 :
629 : /************************************************************************/
630 : /* ==================================================================== */
631 : /* ECWRasterBand */
632 : /* ==================================================================== */
633 : /************************************************************************/
634 :
635 : class ECWRasterBand final : public GDALPamRasterBand
636 : {
637 : friend class ECWDataset;
638 :
639 : // NOTE: poDS may be altered for NITF/JPEG2000 files!
640 : ECWDataset *poGDS;
641 :
642 : GDALColorInterp eBandInterp;
643 :
644 : int iOverview; // -1 for base.
645 :
646 : std::vector<ECWRasterBand *> apoOverviews;
647 :
648 : #if ECWSDK_VERSION >= 50
649 :
650 : int nStatsBandIndex = 0;
651 : int nStatsBandCount = 0;
652 :
653 : #endif
654 :
655 : int bPromoteTo8Bit;
656 :
657 : // #if !defined(SDK_CAN_DO_SUPERSAMPLING)
658 : CPLErr OldIRasterIO(GDALRWFlag, int, int, int, int, void *, int, int,
659 : GDALDataType, GSpacing nPixelSpace, GSpacing nLineSpace,
660 : GDALRasterIOExtraArg *psExtraArg);
661 : // #endif
662 :
663 : virtual CPLErr IRasterIO(GDALRWFlag, int, int, int, int, void *, int, int,
664 : GDALDataType, GSpacing nPixelSpace,
665 : GSpacing nLineSpace,
666 : GDALRasterIOExtraArg *psExtraArg) override;
667 :
668 : public:
669 : ECWRasterBand(ECWDataset *, int, int iOverview, char **papszOpenOptions);
670 : ~ECWRasterBand();
671 :
672 : virtual CPLErr IReadBlock(int, int, void *) override;
673 :
674 0 : virtual int HasArbitraryOverviews() override
675 : {
676 0 : return apoOverviews.empty();
677 : }
678 :
679 3 : virtual int GetOverviewCount() override
680 : {
681 3 : return (int)apoOverviews.size();
682 : }
683 :
684 : virtual GDALRasterBand *GetOverview(int) override;
685 :
686 : virtual GDALColorInterp GetColorInterpretation() override;
687 : virtual CPLErr SetColorInterpretation(GDALColorInterp) override;
688 :
689 : virtual CPLErr AdviseRead(int nXOff, int nYOff, int nXSize, int nYSize,
690 : int nBufXSize, int nBufYSize, GDALDataType eDT,
691 : char **papszOptions) override;
692 : #if ECWSDK_VERSION >= 50
693 : void GetBandIndexAndCountForStatistics(int &bandIndex,
694 : int &bandCount) const;
695 : virtual CPLErr GetDefaultHistogram(double *pdfMin, double *pdfMax,
696 : int *pnBuckets, GUIntBig **ppanHistogram,
697 : int bForce, GDALProgressFunc,
698 : void *pProgressData) override;
699 : virtual CPLErr SetDefaultHistogram(double dfMin, double dfMax, int nBuckets,
700 : GUIntBig *panHistogram) override;
701 : virtual double GetMinimum(int *pbSuccess) override;
702 : virtual double GetMaximum(int *pbSuccess) override;
703 : virtual CPLErr GetStatistics(int bApproxOK, int bForce, double *pdfMin,
704 : double *pdfMax, double *pdfMean,
705 : double *padfStdDev) override;
706 : virtual CPLErr SetStatistics(double dfMin, double dfMax, double dfMean,
707 : double dfStdDev) override;
708 :
709 : virtual CPLErr SetMetadataItem(const char *pszName, const char *pszValue,
710 : const char *pszDomain = "") override;
711 : #endif
712 : };
713 :
714 : int ECWTranslateFromWKT(const OGRSpatialReference *poSRS, char *pszProjection,
715 : int nProjectionLen, char *pszDatum, int nDatumLen,
716 : char *pszUnits);
717 :
718 : CellSizeUnits ECWTranslateToCellSizeUnits(const char *pszUnits);
719 : const char *ECWTranslateFromCellSizeUnits(CellSizeUnits eUnits);
720 :
721 : #endif /* ndef GDAL_ECW_H_INCLUDED */
|
