1 : /******************************************************************************
2 : * $Id: geotiff.cpp 19997 2010-07-09 17:43:54Z rouault $
3 : *
4 : * Project: GeoTIFF Driver
5 : * Purpose: GDAL GeoTIFF support.
6 : * Author: Frank Warmerdam, warmerdam@pobox.com
7 : *
8 : ******************************************************************************
9 : * Copyright (c) 1998, 2002, Frank Warmerdam <warmerdam@pobox.com>
10 : *
11 : * Permission is hereby granted, free of charge, to any person obtaining a
12 : * copy of this software and associated documentation files (the "Software"),
13 : * to deal in the Software without restriction, including without limitation
14 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 : * and/or sell copies of the Software, and to permit persons to whom the
16 : * Software is furnished to do so, subject to the following conditions:
17 : *
18 : * The above copyright notice and this permission notice shall be included
19 : * in all copies or substantial portions of the Software.
20 : *
21 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 : * DEALINGS IN THE SOFTWARE.
28 : ****************************************************************************/
29 :
30 : #include "gdal_pam.h"
31 : #define CPL_SERV_H_INCLUDED
32 :
33 : #include "tiffio.h"
34 : #include "xtiffio.h"
35 : #include "geotiff.h"
36 : #include "geo_normalize.h"
37 : #include "geovalues.h"
38 : #include "cpl_string.h"
39 : #include "cpl_csv.h"
40 : #include "cpl_minixml.h"
41 : #include "gt_overview.h"
42 : #include "ogr_spatialref.h"
43 :
44 : CPL_CVSID("$Id: geotiff.cpp 19997 2010-07-09 17:43:54Z rouault $");
45 :
46 : CPL_C_START
47 : char CPL_DLL * GTIFGetOGISDefn( GTIF *, GTIFDefn * );
48 : int CPL_DLL GTIFSetFromOGISDefn( GTIF *, const char * );
49 : const char * GDALDefaultCSVFilename( const char *pszBasename );
50 : GUInt32 HalfToFloat( GUInt16 );
51 : GUInt32 TripleToFloat( GUInt32 );
52 : void GTiffOneTimeInit();
53 : void GTIFFGetOverviewBlockSize(int* pnBlockXSize, int* pnBlockYSize);
54 : CPL_C_END
55 :
56 : #define TIFFTAG_GDAL_METADATA 42112
57 : #define TIFFTAG_GDAL_NODATA 42113
58 : #define TIFFTAG_RPCCOEFFICIENT 50844
59 :
60 : #if defined(TIFFLIB_VERSION) && TIFFLIB_VERSION >= 20081217 && defined(BIGTIFF_SUPPORT)
61 : # define HAVE_UNSETFIELD
62 : #endif
63 :
64 : #if defined(TIFFLIB_VERSION) && TIFFLIB_VERSION > 20041016
65 : /* We need at least TIFF 3.7.0 for TIFFGetSizeProc and TIFFClientdata */
66 : # define HAVE_TIFFGETSIZEPROC
67 : #endif
68 :
69 : #if !defined(PREDICTOR_NONE)
70 : #define PREDICTOR_NONE 1
71 : #endif
72 :
73 : TIFF* VSI_TIFFOpen(const char* name, const char* mode);
74 :
75 :
76 : /************************************************************************/
77 : /* IsPowerOfTwo() */
78 : /************************************************************************/
79 :
80 127 : static int IsPowerOfTwo(unsigned int i)
81 : {
82 127 : int nBitSet = 0;
83 1274 : while(i != 0)
84 : {
85 1020 : if ((i & 1))
86 127 : nBitSet ++;
87 1020 : i >>= 1;
88 : }
89 127 : return nBitSet == 1;
90 : }
91 :
92 : /************************************************************************/
93 : /* GTIFFGetOverviewBlockSize() */
94 : /************************************************************************/
95 :
96 127 : void GTIFFGetOverviewBlockSize(int* pnBlockXSize, int* pnBlockYSize)
97 : {
98 : static int bHasWarned = FALSE;
99 127 : const char* pszVal = CPLGetConfigOption("GDAL_TIFF_OVR_BLOCKSIZE", "128");
100 127 : int nOvrBlockSize = atoi(pszVal);
101 127 : if (nOvrBlockSize < 64 || nOvrBlockSize > 4096 ||
102 : !IsPowerOfTwo(nOvrBlockSize))
103 : {
104 0 : if (!bHasWarned)
105 : {
106 : CPLError(CE_Warning, CPLE_NotSupported,
107 : "Wrong value for GDAL_TIFF_OVR_BLOCKSIZE : %s. "
108 : "Should be a power of 2 between 64 and 4096. Defaulting to 128",
109 0 : pszVal);
110 0 : bHasWarned = TRUE;
111 : }
112 0 : nOvrBlockSize = 128;
113 : }
114 :
115 127 : *pnBlockXSize = nOvrBlockSize;
116 127 : *pnBlockYSize = nOvrBlockSize;
117 127 : }
118 :
119 : enum
120 : {
121 : ENDIANNESS_NATIVE,
122 : ENDIANNESS_LITTLE,
123 : ENDIANNESS_BIG
124 : };
125 :
126 : /************************************************************************/
127 : /* ==================================================================== */
128 : /* GTiffDataset */
129 : /* ==================================================================== */
130 : /************************************************************************/
131 :
132 : class GTiffRasterBand;
133 : class GTiffRGBABand;
134 : class GTiffBitmapBand;
135 :
136 : class GTiffDataset : public GDALPamDataset
137 : {
138 : friend class GTiffRasterBand;
139 : friend class GTiffSplitBand;
140 : friend class GTiffRGBABand;
141 : friend class GTiffBitmapBand;
142 : friend class GTiffSplitBitmapBand;
143 : friend class GTiffOddBitsBand;
144 :
145 : TIFF *hTIFF;
146 : GTiffDataset **ppoActiveDSRef;
147 : GTiffDataset *poActiveDS; /* only used in actual base */
148 :
149 : toff_t nDirOffset;
150 : int bBase;
151 : int bCloseTIFFHandle; /* usefull for closing TIFF handle opened by GTIFF_DIR: */
152 :
153 : uint16 nPlanarConfig;
154 : uint16 nSamplesPerPixel;
155 : uint16 nBitsPerSample;
156 : uint32 nRowsPerStrip;
157 : uint16 nPhotometric;
158 : uint16 nSampleFormat;
159 : uint16 nCompression;
160 :
161 : int nBlocksPerBand;
162 :
163 : uint32 nBlockXSize;
164 : uint32 nBlockYSize;
165 :
166 : int nLoadedBlock; /* or tile */
167 : int bLoadedBlockDirty;
168 : GByte *pabyBlockBuf;
169 :
170 : CPLErr LoadBlockBuf( int nBlockId, int bReadFromDisk = TRUE );
171 : CPLErr FlushBlockBuf();
172 :
173 : char *pszProjection;
174 : int bLookedForProjection;
175 :
176 : void LookForProjection();
177 :
178 : double adfGeoTransform[6];
179 : int bGeoTransformValid;
180 :
181 : int bTreatAsRGBA;
182 : int bCrystalized;
183 :
184 : void Crystalize();
185 :
186 : GDALColorTable *poColorTable;
187 :
188 : void WriteGeoTIFFInfo();
189 : int SetDirectory( toff_t nDirOffset = 0 );
190 :
191 : int nOverviewCount;
192 : GTiffDataset **papoOverviewDS;
193 :
194 : int nGCPCount;
195 : GDAL_GCP *pasGCPList;
196 :
197 : int IsBlockAvailable( int nBlockId );
198 :
199 : int bGeoTIFFInfoChanged;
200 : int bNoDataSet;
201 : double dfNoDataValue;
202 :
203 : int bMetadataChanged;
204 :
205 : int bNeedsRewrite;
206 :
207 : void ApplyPamInfo();
208 : void PushMetadataToPam();
209 :
210 : GDALMultiDomainMetadata oGTiffMDMD;
211 :
212 : CPLString osProfile;
213 : char **papszCreationOptions;
214 :
215 : int bLoadingOtherBands;
216 :
217 : static void WriteRPCTag( TIFF *, char ** );
218 : void ReadRPCTag();
219 :
220 : void* pabyTempWriteBuffer;
221 : int nTempWriteBufferSize;
222 : int WriteEncodedTile(uint32 tile, void* data, int bPreserveDataBuffer);
223 : int WriteEncodedStrip(uint32 strip, void* data, int bPreserveDataBuffer);
224 :
225 : GTiffDataset* poMaskDS;
226 : GTiffDataset* poBaseDS;
227 :
228 : CPLString osFilename;
229 :
230 : int bFillEmptyTiles;
231 : void FillEmptyTiles(void);
232 :
233 : void FlushDirectory();
234 : CPLErr CleanOverviews();
235 :
236 : /* Used for the all-in-on-strip case */
237 : int nLastLineRead;
238 : int nLastBandRead;
239 : int bTreatAsSplit;
240 : int bTreatAsSplitBitmap;
241 :
242 : int bClipWarn;
243 :
244 : CPLString osRPBFile;
245 : int FindRPBFile(char** papszSiblingFiles);
246 : CPLString osRPCFile;
247 : int FindRPCFile(char** papszSiblingFiles);
248 : CPLString osIMDFile;
249 : int FindIMDFile(char** papszSiblingFiles);
250 :
251 : public:
252 : GTiffDataset();
253 : ~GTiffDataset();
254 :
255 : virtual const char *GetProjectionRef(void);
256 : virtual CPLErr SetProjection( const char * );
257 : virtual CPLErr GetGeoTransform( double * );
258 : virtual CPLErr SetGeoTransform( double * );
259 :
260 : virtual int GetGCPCount();
261 : virtual const char *GetGCPProjection();
262 : virtual const GDAL_GCP *GetGCPs();
263 : CPLErr SetGCPs( int, const GDAL_GCP *, const char * );
264 :
265 : virtual char **GetFileList(void);
266 :
267 : virtual CPLErr IBuildOverviews( const char *, int, int *, int, int *,
268 : GDALProgressFunc, void * );
269 :
270 : CPLErr OpenOffset( TIFF *, GTiffDataset **ppoActiveDSRef,
271 : toff_t nDirOffset, int bBaseIn, GDALAccess,
272 : int bAllowRGBAInterface = TRUE, int bReadGeoTransform = FALSE,
273 : char** papszSiblingFiles = NULL);
274 :
275 : static GDALDataset *OpenDir( GDALOpenInfo * );
276 : static GDALDataset *Open( GDALOpenInfo * );
277 : static int Identify( GDALOpenInfo * );
278 : static GDALDataset *Create( const char * pszFilename,
279 : int nXSize, int nYSize, int nBands,
280 : GDALDataType eType, char ** papszParmList );
281 : static GDALDataset *CreateCopy( const char * pszFilename,
282 : GDALDataset *poSrcDS,
283 : int bStrict, char ** papszOptions,
284 : GDALProgressFunc pfnProgress,
285 : void * pProgressData );
286 : virtual void FlushCache( void );
287 :
288 : virtual CPLErr SetMetadata( char **, const char * = "" );
289 : virtual char **GetMetadata( const char * pszDomain = "" );
290 : virtual CPLErr SetMetadataItem( const char*, const char*,
291 : const char* = "" );
292 : virtual const char *GetMetadataItem( const char * pszName,
293 : const char * pszDomain = "" );
294 : virtual void *GetInternalHandle( const char * );
295 :
296 : virtual CPLErr CreateMaskBand( int nFlags );
297 :
298 : // only needed by createcopy and close code.
299 : static int WriteMetadata( GDALDataset *, TIFF *, int, const char *,
300 : const char *, char **, int bExcludeRPBandIMGFileWriting = FALSE );
301 : static void WriteNoDataValue( TIFF *, double );
302 :
303 : static TIFF * CreateLL( const char * pszFilename,
304 : int nXSize, int nYSize, int nBands,
305 : GDALDataType eType, char **papszParmList );
306 :
307 : CPLErr WriteEncodedTileOrStrip(uint32 tile_or_strip, void* data, int bPreserveDataBuffer);
308 : };
309 :
310 : /************************************************************************/
311 : /* ==================================================================== */
312 : /* GTiffRasterBand */
313 : /* ==================================================================== */
314 : /************************************************************************/
315 :
316 : class GTiffRasterBand : public GDALPamRasterBand
317 399204 : {
318 : friend class GTiffDataset;
319 :
320 : GDALColorInterp eBandInterp;
321 :
322 : int bHaveOffsetScale;
323 : double dfOffset;
324 : double dfScale;
325 : CPLString osUnitType;
326 :
327 : protected:
328 : GTiffDataset *poGDS;
329 : GDALMultiDomainMetadata oGTiffMDMD;
330 :
331 : int bNoDataSet;
332 : double dfNoDataValue;
333 :
334 : void NullBlock( void *pData );
335 :
336 : public:
337 : GTiffRasterBand( GTiffDataset *, int );
338 :
339 : // should override RasterIO eventually.
340 :
341 : virtual CPLErr IReadBlock( int, int, void * );
342 : virtual CPLErr IWriteBlock( int, int, void * );
343 :
344 : virtual GDALColorInterp GetColorInterpretation();
345 : virtual GDALColorTable *GetColorTable();
346 : virtual CPLErr SetColorTable( GDALColorTable * );
347 : virtual double GetNoDataValue( int * );
348 : virtual CPLErr SetNoDataValue( double );
349 :
350 : virtual double GetOffset( int *pbSuccess = NULL );
351 : virtual CPLErr SetOffset( double dfNewValue );
352 : virtual double GetScale( int *pbSuccess = NULL );
353 : virtual CPLErr SetScale( double dfNewValue );
354 : virtual const char* GetUnitType();
355 : virtual CPLErr SetUnitType( const char *pszNewValue );
356 : virtual CPLErr SetColorInterpretation( GDALColorInterp );
357 :
358 : virtual CPLErr SetMetadata( char **, const char * = "" );
359 : virtual char **GetMetadata( const char * pszDomain = "" );
360 : virtual CPLErr SetMetadataItem( const char*, const char*,
361 : const char* = "" );
362 : virtual const char *GetMetadataItem( const char * pszName,
363 : const char * pszDomain = "" );
364 : virtual int GetOverviewCount();
365 : virtual GDALRasterBand *GetOverview( int );
366 :
367 : virtual GDALRasterBand *GetMaskBand();
368 : virtual int GetMaskFlags();
369 : virtual CPLErr CreateMaskBand( int nFlags );
370 : };
371 :
372 : /************************************************************************/
373 : /* GTiffRasterBand() */
374 : /************************************************************************/
375 :
376 399204 : GTiffRasterBand::GTiffRasterBand( GTiffDataset *poDS, int nBand )
377 :
378 : {
379 399204 : poGDS = poDS;
380 :
381 399204 : this->poDS = poDS;
382 399204 : this->nBand = nBand;
383 :
384 399204 : bHaveOffsetScale = FALSE;
385 399204 : dfOffset = 0.0;
386 399204 : dfScale = 1.0;
387 :
388 : /* -------------------------------------------------------------------- */
389 : /* Get the GDAL data type. */
390 : /* -------------------------------------------------------------------- */
391 399204 : uint16 nSampleFormat = poDS->nSampleFormat;
392 :
393 399204 : eDataType = GDT_Unknown;
394 :
395 399204 : if( poDS->nBitsPerSample <= 8 )
396 : {
397 396207 : eDataType = GDT_Byte;
398 396207 : if( nSampleFormat == SAMPLEFORMAT_INT )
399 5 : SetMetadataItem( "PIXELTYPE", "SIGNEDBYTE", "IMAGE_STRUCTURE" );
400 :
401 : }
402 2997 : else if( poDS->nBitsPerSample <= 16 )
403 : {
404 691 : if( nSampleFormat == SAMPLEFORMAT_INT )
405 294 : eDataType = GDT_Int16;
406 : else
407 397 : eDataType = GDT_UInt16;
408 : }
409 2306 : else if( poDS->nBitsPerSample == 32 )
410 : {
411 1313 : if( nSampleFormat == SAMPLEFORMAT_COMPLEXINT )
412 215 : eDataType = GDT_CInt16;
413 1098 : else if( nSampleFormat == SAMPLEFORMAT_IEEEFP )
414 590 : eDataType = GDT_Float32;
415 508 : else if( nSampleFormat == SAMPLEFORMAT_INT )
416 253 : eDataType = GDT_Int32;
417 : else
418 255 : eDataType = GDT_UInt32;
419 : }
420 993 : else if( poDS->nBitsPerSample == 64 )
421 : {
422 695 : if( nSampleFormat == SAMPLEFORMAT_IEEEFP )
423 255 : eDataType = GDT_Float64;
424 440 : else if( nSampleFormat == SAMPLEFORMAT_COMPLEXIEEEFP )
425 226 : eDataType = GDT_CFloat32;
426 214 : else if( nSampleFormat == SAMPLEFORMAT_COMPLEXINT )
427 214 : eDataType = GDT_CInt32;
428 : }
429 298 : else if( poDS->nBitsPerSample == 128 )
430 : {
431 230 : if( nSampleFormat == SAMPLEFORMAT_COMPLEXIEEEFP )
432 230 : eDataType = GDT_CFloat64;
433 : }
434 :
435 : /* -------------------------------------------------------------------- */
436 : /* Try to work out band color interpretation. */
437 : /* -------------------------------------------------------------------- */
438 399300 : if( poDS->poColorTable != NULL && nBand == 1 )
439 96 : eBandInterp = GCI_PaletteIndex;
440 399108 : else if( poDS->nPhotometric == PHOTOMETRIC_RGB
441 : || (poDS->nPhotometric == PHOTOMETRIC_YCBCR
442 : && poDS->nCompression == COMPRESSION_JPEG
443 : && CSLTestBoolean( CPLGetConfigOption("CONVERT_YCBCR_TO_RGB",
444 : "YES") )) )
445 : {
446 1267 : if( nBand == 1 )
447 396 : eBandInterp = GCI_RedBand;
448 871 : else if( nBand == 2 )
449 396 : eBandInterp = GCI_GreenBand;
450 475 : else if( nBand == 3 )
451 396 : eBandInterp = GCI_BlueBand;
452 : else
453 : {
454 : uint16 *v;
455 79 : uint16 count = 0;
456 :
457 79 : if( TIFFGetField( poDS->hTIFF, TIFFTAG_EXTRASAMPLES, &count, &v) )
458 : {
459 141 : if( nBand - 3 <= count && v[nBand-4] == EXTRASAMPLE_ASSOCALPHA )
460 62 : eBandInterp = GCI_AlphaBand;
461 : else
462 17 : eBandInterp = GCI_Undefined;
463 : }
464 0 : else if( nBand == 4 )
465 0 : eBandInterp = GCI_AlphaBand;
466 : else
467 0 : eBandInterp = GCI_Undefined;
468 : }
469 : }
470 397841 : else if( poDS->nPhotometric == PHOTOMETRIC_YCBCR )
471 : {
472 0 : if( nBand == 1 )
473 0 : eBandInterp = GCI_YCbCr_YBand;
474 0 : else if( nBand == 2 )
475 0 : eBandInterp = GCI_YCbCr_CbBand;
476 0 : else if( nBand == 3 )
477 0 : eBandInterp = GCI_YCbCr_CrBand;
478 : else
479 : {
480 : uint16 *v;
481 0 : uint16 count = 0;
482 :
483 0 : if( TIFFGetField( poDS->hTIFF, TIFFTAG_EXTRASAMPLES, &count, &v) )
484 : {
485 0 : if( nBand - 3 <= count && v[nBand-4] == EXTRASAMPLE_ASSOCALPHA )
486 0 : eBandInterp = GCI_AlphaBand;
487 : else
488 0 : eBandInterp = GCI_Undefined;
489 : }
490 0 : else if( nBand == 4 )
491 0 : eBandInterp = GCI_AlphaBand;
492 : else
493 0 : eBandInterp = GCI_Undefined;
494 : }
495 : }
496 397841 : else if( poDS->nPhotometric == PHOTOMETRIC_SEPARATED )
497 : {
498 40 : if( nBand == 1 )
499 10 : eBandInterp = GCI_CyanBand;
500 30 : else if( nBand == 2 )
501 10 : eBandInterp = GCI_MagentaBand;
502 20 : else if( nBand == 3 )
503 10 : eBandInterp = GCI_YellowBand;
504 : else
505 10 : eBandInterp = GCI_BlackBand;
506 : }
507 401875 : else if( poDS->nPhotometric == PHOTOMETRIC_MINISBLACK && nBand == 1 )
508 4074 : eBandInterp = GCI_GrayIndex;
509 : else
510 : {
511 : uint16 *v;
512 393727 : uint16 count = 0;
513 :
514 393727 : if( TIFFGetField( poDS->hTIFF, TIFFTAG_EXTRASAMPLES, &count, &v ) )
515 : {
516 : int nBaseSamples;
517 393602 : nBaseSamples = poDS->nSamplesPerPixel - count;
518 :
519 393609 : if( nBand > nBaseSamples
520 : && v[nBand-nBaseSamples-1] == EXTRASAMPLE_ASSOCALPHA )
521 7 : eBandInterp = GCI_AlphaBand;
522 : else
523 393595 : eBandInterp = GCI_Undefined;
524 : }
525 : else
526 125 : eBandInterp = GCI_Undefined;
527 : }
528 :
529 : /* -------------------------------------------------------------------- */
530 : /* Establish block size for strip or tiles. */
531 : /* -------------------------------------------------------------------- */
532 399204 : nBlockXSize = poDS->nBlockXSize;
533 399204 : nBlockYSize = poDS->nBlockYSize;
534 :
535 399204 : bNoDataSet = FALSE;
536 399204 : dfNoDataValue = -9999.0;
537 399204 : }
538 :
539 : /************************************************************************/
540 : /* IReadBlock() */
541 : /************************************************************************/
542 :
543 : CPLErr GTiffRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
544 82260 : void * pImage )
545 :
546 : {
547 : int nBlockBufSize, nBlockId, nBlockIdBand0;
548 82260 : CPLErr eErr = CE_None;
549 :
550 82260 : if (!poGDS->SetDirectory())
551 0 : return CE_Failure;
552 :
553 82260 : if( TIFFIsTiled(poGDS->hTIFF) )
554 10164 : nBlockBufSize = TIFFTileSize( poGDS->hTIFF );
555 : else
556 : {
557 72096 : CPLAssert( nBlockXOff == 0 );
558 72096 : nBlockBufSize = TIFFStripSize( poGDS->hTIFF );
559 : }
560 :
561 82260 : nBlockIdBand0 = nBlockXOff + nBlockYOff * nBlocksPerRow;
562 82260 : if( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE )
563 478 : nBlockId = nBlockIdBand0 + (nBand-1) * poGDS->nBlocksPerBand;
564 : else
565 81782 : nBlockId = nBlockIdBand0;
566 :
567 : /* -------------------------------------------------------------------- */
568 : /* The bottom most partial tiles and strips are sometimes only */
569 : /* partially encoded. This code reduces the requested data so */
570 : /* an error won't be reported in this case. (#1179) */
571 : /* -------------------------------------------------------------------- */
572 82260 : int nBlockReqSize = nBlockBufSize;
573 :
574 82260 : if( (nBlockYOff+1) * nBlockYSize > nRasterYSize )
575 : {
576 : nBlockReqSize = (nBlockBufSize / nBlockYSize)
577 1179 : * (nBlockYSize - (((nBlockYOff+1) * nBlockYSize) % nRasterYSize));
578 : }
579 :
580 : /* -------------------------------------------------------------------- */
581 : /* Handle the case of a strip or tile that doesn't exist yet. */
582 : /* Just set to zeros and return. */
583 : /* -------------------------------------------------------------------- */
584 82260 : if( !poGDS->IsBlockAvailable(nBlockId) )
585 : {
586 1942 : NullBlock( pImage );
587 1942 : return CE_None;
588 : }
589 :
590 : /* -------------------------------------------------------------------- */
591 : /* Handle simple case (separate, onesampleperpixel) */
592 : /* -------------------------------------------------------------------- */
593 80318 : if( poGDS->nBands == 1
594 : || poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE )
595 : {
596 12014 : if( nBlockReqSize < nBlockBufSize )
597 375 : memset( pImage, 0, nBlockBufSize );
598 :
599 12014 : if( TIFFIsTiled( poGDS->hTIFF ) )
600 : {
601 8531 : if( TIFFReadEncodedTile( poGDS->hTIFF, nBlockId, pImage,
602 : nBlockReqSize ) == -1 )
603 : {
604 0 : memset( pImage, 0, nBlockBufSize );
605 : CPLError( CE_Failure, CPLE_AppDefined,
606 0 : "TIFFReadEncodedTile() failed.\n" );
607 :
608 0 : eErr = CE_Failure;
609 : }
610 : }
611 : else
612 : {
613 3483 : if( TIFFReadEncodedStrip( poGDS->hTIFF, nBlockId, pImage,
614 : nBlockReqSize ) == -1 )
615 : {
616 0 : memset( pImage, 0, nBlockBufSize );
617 : CPLError( CE_Failure, CPLE_AppDefined,
618 0 : "TIFFReadEncodedStrip() failed.\n" );
619 :
620 0 : eErr = CE_Failure;
621 : }
622 : }
623 :
624 12014 : return eErr;
625 : }
626 :
627 : /* -------------------------------------------------------------------- */
628 : /* Load desired block */
629 : /* -------------------------------------------------------------------- */
630 68304 : eErr = poGDS->LoadBlockBuf( nBlockId );
631 68304 : if( eErr != CE_None )
632 : {
633 : memset( pImage, 0,
634 : nBlockXSize * nBlockYSize
635 0 : * (GDALGetDataTypeSize(eDataType) / 8) );
636 0 : return eErr;
637 : }
638 :
639 : /* -------------------------------------------------------------------- */
640 : /* Special case for YCbCr subsampled data. */
641 : /* -------------------------------------------------------------------- */
642 : #ifdef notdef
643 : if( (eBandInterp == GCI_YCbCr_YBand
644 : || eBandInterp == GCI_YCbCr_CbBand
645 : || eBandInterp == GCI_YCbCr_CrBand)
646 : && poGDS->nBitsPerSample == 8 )
647 : {
648 : uint16 hs, vs;
649 : int iX, iY;
650 :
651 : TIFFGetFieldDefaulted( poGDS->hTIFF, TIFFTAG_YCBCRSUBSAMPLING,
652 : &hs, &vs);
653 :
654 : for( iY = 0; iY < nBlockYSize; iY++ )
655 : {
656 : for( iX = 0; iX < nBlockXSize; iX++ )
657 : {
658 : int iBlock = (iY / vs) * (nBlockXSize/hs) + (iX / hs);
659 : GByte *pabySrcBlock = poGDS->pabyBlockBuf +
660 : (vs * hs + 2) * iBlock;
661 :
662 : if( eBandInterp == GCI_YCbCr_YBand )
663 : ((GByte *)pImage)[iY*nBlockXSize + iX] =
664 : pabySrcBlock[(iX % hs) + (iY % vs) * hs];
665 : else if( eBandInterp == GCI_YCbCr_CbBand )
666 : ((GByte *)pImage)[iY*nBlockXSize + iX] =
667 : pabySrcBlock[vs * hs + 0];
668 : else if( eBandInterp == GCI_YCbCr_CrBand )
669 : ((GByte *)pImage)[iY*nBlockXSize + iX] =
670 : pabySrcBlock[vs * hs + 1];
671 : }
672 : }
673 :
674 : return CE_None;
675 : }
676 : #endif
677 :
678 : /* -------------------------------------------------------------------- */
679 : /* Handle simple case of eight bit data, and pixel interleaving. */
680 : /* -------------------------------------------------------------------- */
681 68304 : if( poGDS->nBitsPerSample == 8 )
682 : {
683 : int i, nBlockPixels;
684 : GByte *pabyImage;
685 68165 : GByte *pabyImageDest = (GByte*)pImage;
686 68165 : int nBands = poGDS->nBands;
687 :
688 68165 : pabyImage = poGDS->pabyBlockBuf + nBand - 1;
689 :
690 68165 : nBlockPixels = nBlockXSize * nBlockYSize;
691 :
692 : /* ==================================================================== */
693 : /* Optimization for high number of words to transfer and some */
694 : /* typical band numbers : we unroll the loop. */
695 : /* ==================================================================== */
696 : #define COPY_TO_DST_BUFFER(nBands) \
697 : if (nBlockPixels > 100) \
698 : { \
699 : for ( i = nBlockPixels / 16; i != 0; i -- ) \
700 : { \
701 : pabyImageDest[0] = pabyImage[0*nBands]; \
702 : pabyImageDest[1] = pabyImage[1*nBands]; \
703 : pabyImageDest[2] = pabyImage[2*nBands]; \
704 : pabyImageDest[3] = pabyImage[3*nBands]; \
705 : pabyImageDest[4] = pabyImage[4*nBands]; \
706 : pabyImageDest[5] = pabyImage[5*nBands]; \
707 : pabyImageDest[6] = pabyImage[6*nBands]; \
708 : pabyImageDest[7] = pabyImage[7*nBands]; \
709 : pabyImageDest[8] = pabyImage[8*nBands]; \
710 : pabyImageDest[9] = pabyImage[9*nBands]; \
711 : pabyImageDest[10] = pabyImage[10*nBands]; \
712 : pabyImageDest[11] = pabyImage[11*nBands]; \
713 : pabyImageDest[12] = pabyImage[12*nBands]; \
714 : pabyImageDest[13] = pabyImage[13*nBands]; \
715 : pabyImageDest[14] = pabyImage[14*nBands]; \
716 : pabyImageDest[15] = pabyImage[15*nBands]; \
717 : pabyImageDest += 16; \
718 : pabyImage += 16*nBands; \
719 : } \
720 : nBlockPixels = nBlockPixels % 16; \
721 : } \
722 : for( i = 0; i < nBlockPixels; i++ ) \
723 : { \
724 : pabyImageDest[i] = *pabyImage; \
725 : pabyImage += nBands; \
726 : }
727 :
728 68165 : switch (nBands)
729 : {
730 2113 : case 3: COPY_TO_DST_BUFFER(3); break;
731 452 : case 4: COPY_TO_DST_BUFFER(4); break;
732 : default:
733 : {
734 507415 : for( i = 0; i < nBlockPixels; i++ )
735 : {
736 441815 : pabyImageDest[i] = *pabyImage;
737 441815 : pabyImage += nBands;
738 : }
739 : }
740 : }
741 : }
742 :
743 : else
744 : {
745 : int i, nBlockPixels, nWordBytes;
746 : GByte *pabyImage;
747 :
748 139 : nWordBytes = poGDS->nBitsPerSample / 8;
749 139 : pabyImage = poGDS->pabyBlockBuf + (nBand - 1) * nWordBytes;
750 :
751 139 : nBlockPixels = nBlockXSize * nBlockYSize;
752 566627 : for( i = 0; i < nBlockPixels; i++ )
753 : {
754 2866200 : for( int j = 0; j < nWordBytes; j++ )
755 : {
756 2299712 : ((GByte *) pImage)[i*nWordBytes + j] = pabyImage[j];
757 : }
758 566488 : pabyImage += poGDS->nBands * nWordBytes;
759 : }
760 : }
761 :
762 : /* -------------------------------------------------------------------- */
763 : /* In the fairly common case of pixel interleaved 8bit data */
764 : /* that is multi-band, lets push the rest of the data into the */
765 : /* block cache too, to avoid (hopefully) having to redecode it. */
766 : /* */
767 : /* Our following logic actually depends on the fact that the */
768 : /* this block is already loaded, so subsequent calls will end */
769 : /* up back in this method and pull from the loaded block. */
770 : /* */
771 : /* Be careful not entering this portion of code from */
772 : /* the other bands, otherwise we'll get very deep nested calls */
773 : /* and O(nBands^2) performance ! */
774 : /* */
775 : /* If there are many bands and the block cache size is not big */
776 : /* enough to accomodate the size of all the blocks, don't enter */
777 : /* -------------------------------------------------------------------- */
778 68304 : if( poGDS->nBands != 1 && eErr == CE_None && !poGDS->bLoadingOtherBands &&
779 : nBlockXSize * nBlockYSize * (GDALGetDataTypeSize(eDataType) / 8) < GDALGetCacheMax() / poGDS->nBands)
780 : {
781 : int iOtherBand;
782 :
783 896 : poGDS->bLoadingOtherBands = TRUE;
784 :
785 69197 : for( iOtherBand = 1; iOtherBand <= poGDS->nBands; iOtherBand++ )
786 : {
787 68301 : if( iOtherBand == nBand )
788 896 : continue;
789 :
790 : GDALRasterBlock *poBlock;
791 :
792 : poBlock = poGDS->GetRasterBand(iOtherBand)->
793 67405 : GetLockedBlockRef(nBlockXOff,nBlockYOff);
794 67405 : if (poBlock == NULL)
795 : {
796 0 : eErr = CE_Failure;
797 0 : break;
798 : }
799 67405 : poBlock->DropLock();
800 : }
801 :
802 896 : poGDS->bLoadingOtherBands = FALSE;
803 : }
804 :
805 68304 : return eErr;
806 : }
807 :
808 : /************************************************************************/
809 : /* IWriteBlock() */
810 : /************************************************************************/
811 :
812 : CPLErr GTiffRasterBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
813 13217 : void * pImage )
814 :
815 : {
816 : int nBlockId;
817 13217 : CPLErr eErr = CE_None;
818 :
819 13217 : if (!poGDS->SetDirectory())
820 0 : return CE_Failure;
821 :
822 13217 : CPLAssert( poGDS != NULL
823 : && nBlockXOff >= 0
824 : && nBlockYOff >= 0
825 : && pImage != NULL );
826 :
827 : /* -------------------------------------------------------------------- */
828 : /* Handle case of "separate" images */
829 : /* -------------------------------------------------------------------- */
830 13217 : if( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE
831 : || poGDS->nBands == 1 )
832 : {
833 : nBlockId = nBlockXOff + nBlockYOff * nBlocksPerRow
834 12475 : + (nBand-1) * poGDS->nBlocksPerBand;
835 :
836 12475 : eErr = poGDS->WriteEncodedTileOrStrip(nBlockId, pImage, TRUE);
837 :
838 12475 : return eErr;
839 : }
840 :
841 : /* -------------------------------------------------------------------- */
842 : /* Handle case of pixel interleaved (PLANARCONFIG_CONTIG) images. */
843 : /* -------------------------------------------------------------------- */
844 :
845 742 : nBlockId = nBlockXOff + nBlockYOff * nBlocksPerRow;
846 :
847 742 : eErr = poGDS->LoadBlockBuf( nBlockId );
848 742 : if( eErr != CE_None )
849 0 : return eErr;
850 :
851 : /* -------------------------------------------------------------------- */
852 : /* On write of pixel interleaved data, we might as well flush */
853 : /* out any other bands that are dirty in our cache. This is */
854 : /* especially helpful when writing compressed blocks. */
855 : /* -------------------------------------------------------------------- */
856 : int iBand;
857 742 : int nWordBytes = poGDS->nBitsPerSample / 8;
858 :
859 3044 : for( iBand = 0; iBand < poGDS->nBands; iBand++ )
860 : {
861 2302 : const GByte *pabyThisImage = NULL;
862 2302 : GDALRasterBlock *poBlock = NULL;
863 :
864 2302 : if( iBand+1 == nBand )
865 742 : pabyThisImage = (GByte *) pImage;
866 : else
867 : {
868 : poBlock = ((GTiffRasterBand *)poGDS->GetRasterBand( iBand+1 ))
869 1560 : ->TryGetLockedBlockRef( nBlockXOff, nBlockYOff );
870 :
871 1560 : if( poBlock == NULL )
872 117 : continue;
873 :
874 1443 : if( !poBlock->GetDirty() )
875 : {
876 89 : poBlock->DropLock();
877 89 : continue;
878 : }
879 :
880 1354 : pabyThisImage = (GByte *) poBlock->GetDataRef();
881 : }
882 :
883 2096 : int i, nBlockPixels = nBlockXSize * nBlockYSize;
884 2096 : GByte *pabyOut = poGDS->pabyBlockBuf + iBand*nWordBytes;
885 :
886 11560355 : for( i = 0; i < nBlockPixels; i++ )
887 : {
888 11558259 : memcpy( pabyOut, pabyThisImage, nWordBytes );
889 :
890 11558259 : pabyOut += nWordBytes * poGDS->nBands;
891 11558259 : pabyThisImage += nWordBytes;
892 : }
893 :
894 2096 : if( poBlock != NULL )
895 : {
896 1354 : poBlock->MarkClean();
897 1354 : poBlock->DropLock();
898 : }
899 : }
900 :
901 742 : poGDS->bLoadedBlockDirty = TRUE;
902 :
903 742 : return CE_None;
904 : }
905 :
906 : /************************************************************************/
907 : /* GetOffset() */
908 : /************************************************************************/
909 :
910 133248 : double GTiffRasterBand::GetOffset( int *pbSuccess )
911 :
912 : {
913 133248 : if( pbSuccess )
914 132944 : *pbSuccess = bHaveOffsetScale;
915 133248 : return dfOffset;
916 : }
917 :
918 : /************************************************************************/
919 : /* SetOffset() */
920 : /************************************************************************/
921 :
922 10 : CPLErr GTiffRasterBand::SetOffset( double dfNewValue )
923 :
924 : {
925 10 : if( !bHaveOffsetScale || dfNewValue != dfOffset )
926 10 : poGDS->bMetadataChanged = TRUE;
927 :
928 10 : bHaveOffsetScale = TRUE;
929 10 : dfOffset = dfNewValue;
930 10 : return CE_None;
931 : }
932 :
933 : /************************************************************************/
934 : /* GetScale() */
935 : /************************************************************************/
936 :
937 133248 : double GTiffRasterBand::GetScale( int *pbSuccess )
938 :
939 : {
940 133248 : if( pbSuccess )
941 705 : *pbSuccess = bHaveOffsetScale;
942 133248 : return dfScale;
943 : }
944 :
945 : /************************************************************************/
946 : /* SetScale() */
947 : /************************************************************************/
948 :
949 10 : CPLErr GTiffRasterBand::SetScale( double dfNewValue )
950 :
951 : {
952 10 : if( !bHaveOffsetScale || dfNewValue != dfScale )
953 10 : poGDS->bMetadataChanged = TRUE;
954 :
955 10 : bHaveOffsetScale = TRUE;
956 10 : dfScale = dfNewValue;
957 10 : return CE_None;
958 : }
959 :
960 : /************************************************************************/
961 : /* GetUnitType() */
962 : /************************************************************************/
963 :
964 132726 : const char* GTiffRasterBand::GetUnitType()
965 :
966 : {
967 132726 : return osUnitType.c_str();
968 : }
969 :
970 : /************************************************************************/
971 : /* SetUnitType() */
972 : /************************************************************************/
973 :
974 17 : CPLErr GTiffRasterBand::SetUnitType( const char* pszNewValue )
975 :
976 : {
977 17 : CPLString osNewValue(pszNewValue ? pszNewValue : "");
978 17 : if( osNewValue.compare(osUnitType) != 0 )
979 17 : poGDS->bMetadataChanged = TRUE;
980 :
981 17 : osUnitType = osNewValue;
982 17 : return CE_None;
983 : }
984 :
985 : /************************************************************************/
986 : /* GetMetadata() */
987 : /************************************************************************/
988 :
989 1498 : char **GTiffRasterBand::GetMetadata( const char * pszDomain )
990 :
991 : {
992 1498 : return oGTiffMDMD.GetMetadata( pszDomain );
993 : }
994 :
995 : /************************************************************************/
996 : /* SetMetadata() */
997 : /************************************************************************/
998 :
999 258 : CPLErr GTiffRasterBand::SetMetadata( char ** papszMD, const char *pszDomain )
1000 :
1001 : {
1002 258 : if( pszDomain == NULL || !EQUAL(pszDomain,"_temporary_") )
1003 : {
1004 258 : if( papszMD != NULL )
1005 33 : poGDS->bMetadataChanged = TRUE;
1006 : }
1007 :
1008 258 : return oGTiffMDMD.SetMetadata( papszMD, pszDomain );
1009 : }
1010 :
1011 : /************************************************************************/
1012 : /* GetMetadataItem() */
1013 : /************************************************************************/
1014 :
1015 : const char *GTiffRasterBand::GetMetadataItem( const char * pszName,
1016 1664 : const char * pszDomain )
1017 :
1018 : {
1019 1664 : return oGTiffMDMD.GetMetadataItem( pszName, pszDomain );
1020 : }
1021 :
1022 : /************************************************************************/
1023 : /* SetMetadataItem() */
1024 : /************************************************************************/
1025 :
1026 : CPLErr GTiffRasterBand::SetMetadataItem( const char *pszName,
1027 : const char *pszValue,
1028 583 : const char *pszDomain )
1029 :
1030 : {
1031 583 : if( pszDomain == NULL || !EQUAL(pszDomain,"_temporary_") )
1032 583 : poGDS->bMetadataChanged = TRUE;
1033 :
1034 583 : return oGTiffMDMD.SetMetadataItem( pszName, pszValue, pszDomain );
1035 : }
1036 :
1037 : /************************************************************************/
1038 : /* GetColorInterpretation() */
1039 : /************************************************************************/
1040 :
1041 2362 : GDALColorInterp GTiffRasterBand::GetColorInterpretation()
1042 :
1043 : {
1044 2362 : return eBandInterp;
1045 : }
1046 :
1047 : /************************************************************************/
1048 : /* SetColorInterpretation() */
1049 : /************************************************************************/
1050 :
1051 20 : CPLErr GTiffRasterBand::SetColorInterpretation( GDALColorInterp eInterp )
1052 :
1053 : {
1054 20 : if( eInterp == eBandInterp )
1055 12 : return CE_None;
1056 :
1057 8 : if( poGDS->bCrystalized )
1058 0 : return GDALPamRasterBand::SetColorInterpretation( eInterp );
1059 :
1060 : /* greyscale + alpha */
1061 8 : else if( eInterp == GCI_AlphaBand
1062 : && nBand == 2
1063 : && poGDS->nSamplesPerPixel == 2
1064 : && poGDS->nPhotometric == PHOTOMETRIC_MINISBLACK )
1065 : {
1066 1 : uint16 v[1] = { EXTRASAMPLE_ASSOCALPHA };
1067 :
1068 1 : TIFFSetField(poGDS->hTIFF, TIFFTAG_EXTRASAMPLES, 1, v);
1069 1 : eBandInterp = eInterp;
1070 1 : return CE_None;
1071 : }
1072 :
1073 : /* RGB + alpha */
1074 7 : else if( eInterp == GCI_AlphaBand
1075 : && nBand == 4
1076 : && poGDS->nSamplesPerPixel == 4
1077 : && poGDS->nPhotometric == PHOTOMETRIC_RGB )
1078 : {
1079 1 : uint16 v[1] = { EXTRASAMPLE_ASSOCALPHA };
1080 :
1081 1 : TIFFSetField(poGDS->hTIFF, TIFFTAG_EXTRASAMPLES, 1, v);
1082 1 : eBandInterp = eInterp;
1083 1 : return CE_None;
1084 : }
1085 :
1086 : else
1087 6 : return GDALPamRasterBand::SetColorInterpretation( eInterp );
1088 : }
1089 :
1090 : /************************************************************************/
1091 : /* GetColorTable() */
1092 : /************************************************************************/
1093 :
1094 1712 : GDALColorTable *GTiffRasterBand::GetColorTable()
1095 :
1096 : {
1097 1712 : if( nBand == 1 )
1098 1397 : return poGDS->poColorTable;
1099 : else
1100 315 : return NULL;
1101 : }
1102 :
1103 : /************************************************************************/
1104 : /* SetColorTable() */
1105 : /************************************************************************/
1106 :
1107 14 : CPLErr GTiffRasterBand::SetColorTable( GDALColorTable * poCT )
1108 :
1109 : {
1110 : /* -------------------------------------------------------------------- */
1111 : /* Check if this is even a candidate for applying a PCT. */
1112 : /* -------------------------------------------------------------------- */
1113 14 : if( nBand != 1)
1114 : {
1115 : CPLError( CE_Failure, CPLE_NotSupported,
1116 0 : "SetColorTable() can only be called on band 1." );
1117 0 : return CE_Failure;
1118 : }
1119 :
1120 14 : if( poGDS->nSamplesPerPixel != 1 && poGDS->nSamplesPerPixel != 2)
1121 : {
1122 : CPLError( CE_Failure, CPLE_NotSupported,
1123 0 : "SetColorTable() not supported for multi-sample TIFF files." );
1124 0 : return CE_Failure;
1125 : }
1126 :
1127 14 : if( eDataType != GDT_Byte && eDataType != GDT_UInt16 )
1128 : {
1129 : CPLError( CE_Failure, CPLE_NotSupported,
1130 0 : "SetColorTable() only supported for Byte or UInt16 bands in TIFF format." );
1131 0 : return CE_Failure;
1132 : }
1133 :
1134 : /* -------------------------------------------------------------------- */
1135 : /* We are careful about calling SetDirectory() to avoid */
1136 : /* prematurely crystalizing the directory. (#2820) */
1137 : /* -------------------------------------------------------------------- */
1138 14 : if( poGDS->bCrystalized )
1139 : {
1140 4 : if (!poGDS->SetDirectory())
1141 0 : return CE_Failure;
1142 : }
1143 :
1144 : /* -------------------------------------------------------------------- */
1145 : /* Is this really a request to clear the color table? */
1146 : /* -------------------------------------------------------------------- */
1147 14 : if( poCT == NULL || poCT->GetColorEntryCount() == 0 )
1148 : {
1149 : TIFFSetField( poGDS->hTIFF, TIFFTAG_PHOTOMETRIC,
1150 1 : PHOTOMETRIC_MINISBLACK );
1151 :
1152 : #ifdef HAVE_UNSETFIELD
1153 1 : TIFFUnsetField( poGDS->hTIFF, TIFFTAG_COLORMAP );
1154 : #else
1155 : CPLDebug( "GTiff",
1156 : "TIFFUnsetField() not supported, colormap may not be cleared." );
1157 : #endif
1158 :
1159 1 : if( poGDS->poColorTable )
1160 : {
1161 1 : delete poGDS->poColorTable;
1162 1 : poGDS->poColorTable = NULL;
1163 : }
1164 :
1165 1 : return CE_None;
1166 : }
1167 :
1168 : /* -------------------------------------------------------------------- */
1169 : /* Write out the colortable, and update the configuration. */
1170 : /* -------------------------------------------------------------------- */
1171 : int nColors;
1172 :
1173 13 : if( eDataType == GDT_Byte )
1174 12 : nColors = 256;
1175 : else
1176 1 : nColors = 65536;
1177 :
1178 : unsigned short *panTRed, *panTGreen, *panTBlue;
1179 :
1180 13 : panTRed = (unsigned short *) CPLMalloc(sizeof(unsigned short)*nColors);
1181 13 : panTGreen = (unsigned short *) CPLMalloc(sizeof(unsigned short)*nColors);
1182 13 : panTBlue = (unsigned short *) CPLMalloc(sizeof(unsigned short)*nColors);
1183 :
1184 68621 : for( int iColor = 0; iColor < nColors; iColor++ )
1185 : {
1186 68608 : if( iColor < poCT->GetColorEntryCount() )
1187 : {
1188 : GDALColorEntry sRGB;
1189 :
1190 696 : poCT->GetColorEntryAsRGB( iColor, &sRGB );
1191 :
1192 696 : panTRed[iColor] = (unsigned short) (257 * sRGB.c1);
1193 696 : panTGreen[iColor] = (unsigned short) (257 * sRGB.c2);
1194 696 : panTBlue[iColor] = (unsigned short) (257 * sRGB.c3);
1195 : }
1196 : else
1197 : {
1198 67912 : panTRed[iColor] = panTGreen[iColor] = panTBlue[iColor] = 0;
1199 : }
1200 : }
1201 :
1202 13 : TIFFSetField( poGDS->hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE );
1203 : TIFFSetField( poGDS->hTIFF, TIFFTAG_COLORMAP,
1204 13 : panTRed, panTGreen, panTBlue );
1205 :
1206 13 : CPLFree( panTRed );
1207 13 : CPLFree( panTGreen );
1208 13 : CPLFree( panTBlue );
1209 :
1210 13 : if( poGDS->poColorTable )
1211 3 : delete poGDS->poColorTable;
1212 :
1213 : /* libtiff 3.X needs setting this in all cases (creation or update) */
1214 : /* whereas libtiff 4.X would just need it if there */
1215 : /* was no color table before */
1216 : #if 0
1217 : else
1218 : #endif
1219 13 : poGDS->bNeedsRewrite = TRUE;
1220 :
1221 13 : poGDS->poColorTable = poCT->Clone();
1222 :
1223 13 : return CE_None;
1224 : }
1225 :
1226 : /************************************************************************/
1227 : /* GetNoDataValue() */
1228 : /************************************************************************/
1229 :
1230 4745 : double GTiffRasterBand::GetNoDataValue( int * pbSuccess )
1231 :
1232 : {
1233 4745 : if( bNoDataSet )
1234 : {
1235 91 : if( pbSuccess )
1236 82 : *pbSuccess = TRUE;
1237 :
1238 91 : return dfNoDataValue;
1239 : }
1240 :
1241 4654 : if( poGDS->bNoDataSet )
1242 : {
1243 222 : if( pbSuccess )
1244 215 : *pbSuccess = TRUE;
1245 :
1246 222 : return poGDS->dfNoDataValue;
1247 : }
1248 :
1249 4432 : return GDALPamRasterBand::GetNoDataValue( pbSuccess );
1250 : }
1251 :
1252 : /************************************************************************/
1253 : /* SetNoDataValue() */
1254 : /************************************************************************/
1255 :
1256 64 : CPLErr GTiffRasterBand::SetNoDataValue( double dfNoData )
1257 :
1258 : {
1259 64 : if( poGDS->bNoDataSet && poGDS->dfNoDataValue == dfNoData )
1260 16 : return CE_None;
1261 :
1262 48 : if (!poGDS->SetDirectory()) // needed to call TIFFSetField().
1263 0 : return CE_Failure;
1264 :
1265 48 : poGDS->bNoDataSet = TRUE;
1266 48 : poGDS->dfNoDataValue = dfNoData;
1267 :
1268 48 : poGDS->WriteNoDataValue( poGDS->hTIFF, dfNoData );
1269 48 : poGDS->bNeedsRewrite = TRUE;
1270 :
1271 48 : bNoDataSet = TRUE;
1272 48 : dfNoDataValue = dfNoData;
1273 48 : return CE_None;
1274 : }
1275 :
1276 : /************************************************************************/
1277 : /* NullBlock() */
1278 : /* */
1279 : /* Set the block data to the null value if it is set, or zero */
1280 : /* if there is no null data value. */
1281 : /************************************************************************/
1282 :
1283 1961 : void GTiffRasterBand::NullBlock( void *pData )
1284 :
1285 : {
1286 1961 : int nWords = nBlockXSize * nBlockYSize;
1287 1961 : int nChunkSize = MAX(1,GDALGetDataTypeSize(eDataType)/8);
1288 :
1289 : int bNoDataSet;
1290 1961 : double dfNoData = GetNoDataValue( &bNoDataSet );
1291 1961 : if( !bNoDataSet )
1292 : {
1293 1877 : memset( pData, 0, nWords*nChunkSize );
1294 : }
1295 : else
1296 : {
1297 : /* Will convert nodata value to the right type and copy efficiently */
1298 : GDALCopyWords( &dfNoData, GDT_Float64, 0,
1299 84 : pData, eDataType, nChunkSize, nWords);
1300 : }
1301 1961 : }
1302 :
1303 : /************************************************************************/
1304 : /* GetOverviewCount() */
1305 : /************************************************************************/
1306 :
1307 300184 : int GTiffRasterBand::GetOverviewCount()
1308 :
1309 : {
1310 300184 : if( poGDS->nOverviewCount > 0 )
1311 674 : return poGDS->nOverviewCount;
1312 : else
1313 299510 : return GDALRasterBand::GetOverviewCount();
1314 : }
1315 :
1316 : /************************************************************************/
1317 : /* GetOverview() */
1318 : /************************************************************************/
1319 :
1320 707 : GDALRasterBand *GTiffRasterBand::GetOverview( int i )
1321 :
1322 : {
1323 707 : if( poGDS->nOverviewCount > 0 )
1324 : {
1325 479 : if( i < 0 || i >= poGDS->nOverviewCount )
1326 0 : return NULL;
1327 : else
1328 479 : return poGDS->papoOverviewDS[i]->GetRasterBand(nBand);
1329 : }
1330 : else
1331 228 : return GDALRasterBand::GetOverview( i );
1332 : }
1333 :
1334 : /************************************************************************/
1335 : /* GetMaskFlags() */
1336 : /************************************************************************/
1337 :
1338 1238 : int GTiffRasterBand::GetMaskFlags()
1339 : {
1340 1238 : if( poGDS->poMaskDS != NULL )
1341 : {
1342 : int iBand;
1343 24 : int nMaskFlag = 0;
1344 24 : if( poGDS->poMaskDS->GetRasterCount() == 1)
1345 : {
1346 18 : iBand = 1;
1347 18 : nMaskFlag = GMF_PER_DATASET;
1348 : }
1349 : else
1350 : {
1351 6 : iBand = nBand;
1352 : }
1353 24 : if( poGDS->poMaskDS->GetRasterBand(iBand)->GetMetadataItem( "NBITS", "IMAGE_STRUCTURE" ) != NULL
1354 : && atoi(poGDS->poMaskDS->GetRasterBand(iBand)->GetMetadataItem( "NBITS", "IMAGE_STRUCTURE" )) == 1)
1355 : {
1356 20 : return nMaskFlag;
1357 : }
1358 : else
1359 : {
1360 4 : return nMaskFlag | GMF_ALPHA;
1361 : }
1362 : }
1363 : else
1364 1214 : return GDALPamRasterBand::GetMaskFlags();
1365 : }
1366 :
1367 : /************************************************************************/
1368 : /* GetMaskBand() */
1369 : /************************************************************************/
1370 :
1371 476 : GDALRasterBand *GTiffRasterBand::GetMaskBand()
1372 : {
1373 476 : if( poGDS->poMaskDS != NULL )
1374 : {
1375 43 : if( poGDS->poMaskDS->GetRasterCount() == 1)
1376 37 : return poGDS->poMaskDS->GetRasterBand(1);
1377 : else
1378 6 : return poGDS->poMaskDS->GetRasterBand(nBand);
1379 : }
1380 : else
1381 433 : return GDALPamRasterBand::GetMaskBand();
1382 : }
1383 :
1384 : /************************************************************************/
1385 : /* ==================================================================== */
1386 : /* GTiffSplitBand */
1387 : /* ==================================================================== */
1388 : /************************************************************************/
1389 :
1390 : class GTiffSplitBand : public GTiffRasterBand
1391 : {
1392 : friend class GTiffDataset;
1393 :
1394 : public:
1395 :
1396 : GTiffSplitBand( GTiffDataset *, int );
1397 : virtual ~GTiffSplitBand();
1398 :
1399 : virtual CPLErr IReadBlock( int, int, void * );
1400 : virtual CPLErr IWriteBlock( int, int, void * );
1401 : };
1402 :
1403 : /************************************************************************/
1404 : /* GTiffSplitBand() */
1405 : /************************************************************************/
1406 :
1407 24 : GTiffSplitBand::GTiffSplitBand( GTiffDataset *poDS, int nBand )
1408 24 : : GTiffRasterBand( poDS, nBand )
1409 :
1410 : {
1411 24 : nBlockXSize = poDS->GetRasterXSize();
1412 24 : nBlockYSize = 1;
1413 24 : }
1414 :
1415 : /************************************************************************/
1416 : /* ~GTiffSplitBand() */
1417 : /************************************************************************/
1418 :
1419 24 : GTiffSplitBand::~GTiffSplitBand()
1420 : {
1421 24 : }
1422 :
1423 : /************************************************************************/
1424 : /* IReadBlock() */
1425 : /************************************************************************/
1426 :
1427 : CPLErr GTiffSplitBand::IReadBlock( int nBlockXOff, int nBlockYOff,
1428 66144 : void * pImage )
1429 :
1430 : {
1431 : (void) nBlockXOff;
1432 :
1433 : /* Optimization when reading the same line in a contig multi-band TIFF */
1434 66144 : if( poGDS->nPlanarConfig == PLANARCONFIG_CONTIG && poGDS->nBands > 1 &&
1435 : poGDS->nLastLineRead == nBlockYOff )
1436 : {
1437 9 : goto extract_band_data;
1438 : }
1439 :
1440 66135 : if (!poGDS->SetDirectory())
1441 0 : return CE_Failure;
1442 :
1443 102270 : if (poGDS->nPlanarConfig == PLANARCONFIG_CONTIG &&
1444 : poGDS->nBands > 1)
1445 : {
1446 36135 : if (poGDS->pabyBlockBuf == NULL)
1447 3 : poGDS->pabyBlockBuf = (GByte *) CPLMalloc(TIFFScanlineSize(poGDS->hTIFF));
1448 : }
1449 : else
1450 : {
1451 30000 : CPLAssert(TIFFScanlineSize(poGDS->hTIFF) == nBlockXSize);
1452 : }
1453 :
1454 : /* -------------------------------------------------------------------- */
1455 : /* Read through to target scanline. */
1456 : /* -------------------------------------------------------------------- */
1457 66135 : if( poGDS->nLastLineRead >= nBlockYOff )
1458 31 : poGDS->nLastLineRead = -1;
1459 :
1460 66135 : if( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE && poGDS->nBands > 1 )
1461 : {
1462 : /* If we change of band, we must start reading the */
1463 : /* new strip from its beginning */
1464 30000 : if ( poGDS->nLastBandRead != nBand )
1465 20 : poGDS->nLastLineRead = -1;
1466 30000 : poGDS->nLastBandRead = nBand;
1467 : }
1468 :
1469 247718 : while( poGDS->nLastLineRead < nBlockYOff )
1470 : {
1471 115448 : if( TIFFReadScanline( poGDS->hTIFF,
1472 : poGDS->pabyBlockBuf ? poGDS->pabyBlockBuf : pImage,
1473 : ++poGDS->nLastLineRead,
1474 : (poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE) ? nBand-1 : 0 ) == -1 )
1475 : {
1476 : CPLError( CE_Failure, CPLE_AppDefined,
1477 0 : "TIFFReadScanline() failed." );
1478 0 : return CE_Failure;
1479 : }
1480 : }
1481 :
1482 66144 : extract_band_data:
1483 : /* -------------------------------------------------------------------- */
1484 : /* Extract band data from contig buffer. */
1485 : /* -------------------------------------------------------------------- */
1486 66144 : if ( poGDS->pabyBlockBuf != NULL )
1487 : {
1488 36144 : int iPixel, iSrcOffset= nBand - 1, iDstOffset=0;
1489 :
1490 164448 : for( iPixel = 0; iPixel < nBlockXSize; iPixel++, iSrcOffset+=poGDS->nBands, iDstOffset++ )
1491 : {
1492 128304 : ((GByte *) pImage)[iDstOffset] = poGDS->pabyBlockBuf[iSrcOffset];
1493 : }
1494 : }
1495 :
1496 66144 : return CE_None;
1497 : }
1498 :
1499 : /************************************************************************/
1500 : /* IWriteBlock() */
1501 : /************************************************************************/
1502 :
1503 : CPLErr GTiffSplitBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
1504 0 : void * pImage )
1505 :
1506 : {
1507 : (void) nBlockXOff;
1508 : (void) nBlockYOff;
1509 : (void) pImage;
1510 :
1511 : CPLError( CE_Failure, CPLE_AppDefined,
1512 0 : "Split bands are read-only." );
1513 0 : return CE_Failure;
1514 : }
1515 :
1516 : /************************************************************************/
1517 : /* ==================================================================== */
1518 : /* GTiffRGBABand */
1519 : /* ==================================================================== */
1520 : /************************************************************************/
1521 :
1522 : class GTiffRGBABand : public GTiffRasterBand
1523 16 : {
1524 : friend class GTiffDataset;
1525 :
1526 : public:
1527 :
1528 : GTiffRGBABand( GTiffDataset *, int );
1529 :
1530 : virtual CPLErr IReadBlock( int, int, void * );
1531 : virtual CPLErr IWriteBlock( int, int, void * );
1532 :
1533 : virtual GDALColorInterp GetColorInterpretation();
1534 : };
1535 :
1536 :
1537 : /************************************************************************/
1538 : /* GTiffRGBABand() */
1539 : /************************************************************************/
1540 :
1541 16 : GTiffRGBABand::GTiffRGBABand( GTiffDataset *poDS, int nBand )
1542 16 : : GTiffRasterBand( poDS, nBand )
1543 :
1544 : {
1545 16 : eDataType = GDT_Byte;
1546 16 : }
1547 :
1548 : /************************************************************************/
1549 : /* IWriteBlock() */
1550 : /************************************************************************/
1551 :
1552 0 : CPLErr GTiffRGBABand::IWriteBlock( int, int, void * )
1553 :
1554 : {
1555 : CPLError( CE_Failure, CPLE_AppDefined,
1556 0 : "RGBA interpreted raster bands are read-only." );
1557 0 : return CE_Failure;
1558 : }
1559 :
1560 : /************************************************************************/
1561 : /* IReadBlock() */
1562 : /************************************************************************/
1563 :
1564 : CPLErr GTiffRGBABand::IReadBlock( int nBlockXOff, int nBlockYOff,
1565 6 : void * pImage )
1566 :
1567 : {
1568 : int nBlockBufSize, nBlockId;
1569 6 : CPLErr eErr = CE_None;
1570 :
1571 6 : if (!poGDS->SetDirectory())
1572 0 : return CE_Failure;
1573 :
1574 6 : nBlockBufSize = 4 * nBlockXSize * nBlockYSize;
1575 6 : nBlockId = nBlockXOff + nBlockYOff * nBlocksPerRow;
1576 :
1577 : /* -------------------------------------------------------------------- */
1578 : /* Allocate a temporary buffer for this strip. */
1579 : /* -------------------------------------------------------------------- */
1580 6 : if( poGDS->pabyBlockBuf == NULL )
1581 : {
1582 2 : poGDS->pabyBlockBuf = (GByte *) VSIMalloc3( 4, nBlockXSize, nBlockYSize );
1583 2 : if( poGDS->pabyBlockBuf == NULL )
1584 0 : return( CE_Failure );
1585 : }
1586 :
1587 : /* -------------------------------------------------------------------- */
1588 : /* Read the strip */
1589 : /* -------------------------------------------------------------------- */
1590 6 : if( poGDS->nLoadedBlock != nBlockId )
1591 : {
1592 3 : if( TIFFIsTiled( poGDS->hTIFF ) )
1593 : {
1594 0 : if( TIFFReadRGBATile(poGDS->hTIFF,
1595 : nBlockXOff * nBlockXSize,
1596 : nBlockYOff * nBlockYSize,
1597 : (uint32 *) poGDS->pabyBlockBuf) == -1 )
1598 : {
1599 : /* Once TIFFError() is properly hooked, this can go away */
1600 : CPLError( CE_Failure, CPLE_AppDefined,
1601 0 : "TIFFReadRGBATile() failed." );
1602 :
1603 0 : memset( poGDS->pabyBlockBuf, 0, nBlockBufSize );
1604 :
1605 0 : eErr = CE_Failure;
1606 : }
1607 : }
1608 : else
1609 : {
1610 3 : if( TIFFReadRGBAStrip(poGDS->hTIFF,
1611 : nBlockId * nBlockYSize,
1612 : (uint32 *) poGDS->pabyBlockBuf) == -1 )
1613 : {
1614 : /* Once TIFFError() is properly hooked, this can go away */
1615 : CPLError( CE_Failure, CPLE_AppDefined,
1616 0 : "TIFFReadRGBAStrip() failed." );
1617 :
1618 0 : memset( poGDS->pabyBlockBuf, 0, nBlockBufSize );
1619 :
1620 0 : eErr = CE_Failure;
1621 : }
1622 : }
1623 : }
1624 :
1625 6 : poGDS->nLoadedBlock = nBlockId;
1626 :
1627 : /* -------------------------------------------------------------------- */
1628 : /* Handle simple case of eight bit data, and pixel interleaving. */
1629 : /* -------------------------------------------------------------------- */
1630 : int iDestLine, nBO;
1631 : int nThisBlockYSize;
1632 :
1633 6 : if( (nBlockYOff+1) * nBlockYSize > GetYSize()
1634 : && !TIFFIsTiled( poGDS->hTIFF ) )
1635 1 : nThisBlockYSize = GetYSize() - nBlockYOff * nBlockYSize;
1636 : else
1637 5 : nThisBlockYSize = nBlockYSize;
1638 :
1639 : #ifdef CPL_LSB
1640 6 : nBO = nBand - 1;
1641 : #else
1642 : nBO = 4 - nBand;
1643 : #endif
1644 :
1645 60 : for( iDestLine = 0; iDestLine < nThisBlockYSize; iDestLine++ )
1646 : {
1647 : int nSrcOffset;
1648 :
1649 54 : nSrcOffset = (nThisBlockYSize - iDestLine - 1) * nBlockXSize * 4;
1650 :
1651 : GDALCopyWords( poGDS->pabyBlockBuf + nBO + nSrcOffset, GDT_Byte, 4,
1652 : ((GByte *) pImage)+iDestLine*nBlockXSize, GDT_Byte, 1,
1653 54 : nBlockXSize );
1654 : }
1655 :
1656 6 : return eErr;
1657 : }
1658 :
1659 : /************************************************************************/
1660 : /* GetColorInterpretation() */
1661 : /************************************************************************/
1662 :
1663 5 : GDALColorInterp GTiffRGBABand::GetColorInterpretation()
1664 :
1665 : {
1666 5 : if( nBand == 1 )
1667 2 : return GCI_RedBand;
1668 3 : else if( nBand == 2 )
1669 1 : return GCI_GreenBand;
1670 2 : else if( nBand == 3 )
1671 1 : return GCI_BlueBand;
1672 : else
1673 1 : return GCI_AlphaBand;
1674 : }
1675 :
1676 : /************************************************************************/
1677 : /* ==================================================================== */
1678 : /* GTiffOddBitsBand */
1679 : /* ==================================================================== */
1680 : /************************************************************************/
1681 :
1682 : class GTiffOddBitsBand : public GTiffRasterBand
1683 : {
1684 : friend class GTiffDataset;
1685 : public:
1686 :
1687 : GTiffOddBitsBand( GTiffDataset *, int );
1688 : virtual ~GTiffOddBitsBand();
1689 :
1690 : virtual CPLErr IReadBlock( int, int, void * );
1691 : virtual CPLErr IWriteBlock( int, int, void * );
1692 : };
1693 :
1694 :
1695 : /************************************************************************/
1696 : /* GTiffOddBitsBand() */
1697 : /************************************************************************/
1698 :
1699 330 : GTiffOddBitsBand::GTiffOddBitsBand( GTiffDataset *poGDS, int nBand )
1700 330 : : GTiffRasterBand( poGDS, nBand )
1701 :
1702 : {
1703 330 : eDataType = GDT_Byte;
1704 330 : if( poGDS->nSampleFormat == SAMPLEFORMAT_IEEEFP )
1705 2 : eDataType = GDT_Float32;
1706 425 : else if( poGDS->nBitsPerSample > 8 && poGDS->nBitsPerSample < 16 )
1707 97 : eDataType = GDT_UInt16;
1708 231 : else if( poGDS->nBitsPerSample > 16 )
1709 67 : eDataType = GDT_UInt32;
1710 330 : }
1711 :
1712 : /************************************************************************/
1713 : /* ~GTiffOddBitsBand() */
1714 : /************************************************************************/
1715 :
1716 330 : GTiffOddBitsBand::~GTiffOddBitsBand()
1717 :
1718 : {
1719 330 : }
1720 :
1721 : /************************************************************************/
1722 : /* IWriteBlock() */
1723 : /************************************************************************/
1724 :
1725 : CPLErr GTiffOddBitsBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
1726 69 : void *pImage )
1727 :
1728 : {
1729 : int nBlockId;
1730 69 : CPLErr eErr = CE_None;
1731 :
1732 69 : if (!poGDS->SetDirectory())
1733 0 : return CE_Failure;
1734 :
1735 69 : CPLAssert( poGDS != NULL
1736 : && nBlockXOff >= 0
1737 : && nBlockYOff >= 0
1738 : && pImage != NULL );
1739 :
1740 69 : if( eDataType == GDT_Float32 && poGDS->nBitsPerSample < 32 )
1741 : {
1742 : CPLError(CE_Failure, CPLE_NotSupported,
1743 0 : "Writing float data with nBitsPerSample < 32 is unsupported");
1744 0 : return CE_Failure;
1745 : }
1746 :
1747 : /* -------------------------------------------------------------------- */
1748 : /* Load the block buffer. */
1749 : /* -------------------------------------------------------------------- */
1750 69 : nBlockId = nBlockXOff + nBlockYOff * nBlocksPerRow;
1751 :
1752 69 : if( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE )
1753 18 : nBlockId += (nBand-1) * poGDS->nBlocksPerBand;
1754 :
1755 : /* Only read content from disk in the CONTIG case */
1756 : eErr = poGDS->LoadBlockBuf( nBlockId,
1757 69 : poGDS->nPlanarConfig == PLANARCONFIG_CONTIG && poGDS->nBands > 1 );
1758 69 : if( eErr != CE_None )
1759 0 : return eErr;
1760 :
1761 69 : GUInt32 nMaxVal = (1 << poGDS->nBitsPerSample) - 1;
1762 :
1763 : /* -------------------------------------------------------------------- */
1764 : /* Handle case of "separate" images or single band images where */
1765 : /* no interleaving with other data is required. */
1766 : /* -------------------------------------------------------------------- */
1767 69 : if( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE
1768 : || poGDS->nBands == 1 )
1769 : {
1770 53 : int iBit, iPixel, iBitOffset = 0;
1771 : int iX, iY, nBitsPerLine;
1772 :
1773 : // bits per line rounds up to next byte boundary.
1774 53 : nBitsPerLine = nBlockXSize * poGDS->nBitsPerSample;
1775 53 : if( (nBitsPerLine & 7) != 0 )
1776 28 : nBitsPerLine = (nBitsPerLine + 7) & (~7);
1777 :
1778 : /* Initialize to zero as we set the buffer with binary or operations */
1779 53 : if (poGDS->nBitsPerSample != 24)
1780 48 : memset(poGDS->pabyBlockBuf, 0, (nBitsPerLine / 8) * nBlockYSize);
1781 :
1782 53 : iPixel = 0;
1783 9854 : for( iY = 0; iY < nBlockYSize; iY++ )
1784 : {
1785 9801 : iBitOffset = iY * nBitsPerLine;
1786 :
1787 : /* Small optimization in 1 bit case */
1788 9801 : if (poGDS->nBitsPerSample == 1)
1789 : {
1790 7437914 : for( iX = 0; iX < nBlockXSize; iX++ )
1791 : {
1792 7428711 : if (((GByte *) pImage)[iPixel++])
1793 7107766 : poGDS->pabyBlockBuf[iBitOffset>>3] |= (0x80 >>(iBitOffset & 7));
1794 7428711 : iBitOffset++;
1795 : }
1796 :
1797 9203 : continue;
1798 : }
1799 :
1800 39368 : for( iX = 0; iX < nBlockXSize; iX++ )
1801 : {
1802 38770 : GUInt32 nInWord = 0;
1803 38770 : if( eDataType == GDT_Byte )
1804 400 : nInWord = ((GByte *) pImage)[iPixel++];
1805 38370 : else if( eDataType == GDT_UInt16 )
1806 35569 : nInWord = ((GUInt16 *) pImage)[iPixel++];
1807 2801 : else if( eDataType == GDT_UInt32 )
1808 2801 : nInWord = ((GUInt32 *) pImage)[iPixel++];
1809 : else
1810 0 : CPLAssert(0);
1811 :
1812 38770 : if (nInWord > nMaxVal)
1813 : {
1814 400 : nInWord = nMaxVal;
1815 400 : if( !poGDS->bClipWarn )
1816 : {
1817 1 : poGDS->bClipWarn = TRUE;
1818 : CPLError( CE_Warning, CPLE_AppDefined,
1819 1 : "One or more pixels clipped to fit %d bit domain.", poGDS->nBitsPerSample );
1820 : }
1821 : }
1822 :
1823 38770 : if (poGDS->nBitsPerSample == 24)
1824 : {
1825 : /* -------------------------------------------------------------------- */
1826 : /* Special case for 24bit data which is pre-byteswapped since */
1827 : /* the size falls on a byte boundary ... ugg (#2361). */
1828 : /* -------------------------------------------------------------------- */
1829 : #ifdef CPL_MSB
1830 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 0] =
1831 : (GByte) nInWord;
1832 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 1] =
1833 : (GByte) (nInWord >> 8);
1834 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 2] =
1835 : (GByte) (nInWord >> 16);
1836 : #else
1837 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 0] =
1838 1400 : (GByte) (nInWord >> 16);
1839 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 1] =
1840 1400 : (GByte) (nInWord >> 8);
1841 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 2] =
1842 1400 : (GByte) nInWord;
1843 : #endif
1844 1400 : iBitOffset += 24;
1845 : }
1846 : else
1847 : {
1848 485812 : for( iBit = 0; iBit < poGDS->nBitsPerSample; iBit++ )
1849 : {
1850 448442 : if (nInWord & (1 << (poGDS->nBitsPerSample - 1 - iBit)))
1851 18485 : poGDS->pabyBlockBuf[iBitOffset>>3] |= (0x80 >>(iBitOffset & 7));
1852 448442 : iBitOffset++;
1853 : }
1854 : }
1855 : }
1856 : }
1857 :
1858 53 : poGDS->bLoadedBlockDirty = TRUE;
1859 :
1860 53 : return eErr;
1861 : }
1862 :
1863 : /* -------------------------------------------------------------------- */
1864 : /* Handle case of pixel interleaved (PLANARCONFIG_CONTIG) images. */
1865 : /* -------------------------------------------------------------------- */
1866 :
1867 : /* -------------------------------------------------------------------- */
1868 : /* On write of pixel interleaved data, we might as well flush */
1869 : /* out any other bands that are dirty in our cache. This is */
1870 : /* especially helpful when writing compressed blocks. */
1871 : /* -------------------------------------------------------------------- */
1872 : int iBand;
1873 :
1874 54 : for( iBand = 0; iBand < poGDS->nBands; iBand++ )
1875 : {
1876 38 : const GByte *pabyThisImage = NULL;
1877 38 : GDALRasterBlock *poBlock = NULL;
1878 38 : int iBit, iPixel, iBitOffset = 0;
1879 : int iPixelBitSkip, iBandBitOffset, iX, iY, nBitsPerLine;
1880 :
1881 38 : if( iBand+1 == nBand )
1882 16 : pabyThisImage = (GByte *) pImage;
1883 : else
1884 : {
1885 : poBlock = ((GTiffOddBitsBand *)poGDS->GetRasterBand( iBand+1 ))
1886 22 : ->TryGetLockedBlockRef( nBlockXOff, nBlockYOff );
1887 :
1888 22 : if( poBlock == NULL )
1889 10 : continue;
1890 :
1891 12 : if( !poBlock->GetDirty() )
1892 : {
1893 0 : poBlock->DropLock();
1894 0 : continue;
1895 : }
1896 :
1897 12 : pabyThisImage = (GByte *) poBlock->GetDataRef();
1898 : }
1899 :
1900 28 : iPixelBitSkip = poGDS->nBitsPerSample * poGDS->nBands;
1901 28 : iBandBitOffset = iBand * poGDS->nBitsPerSample;
1902 :
1903 : // bits per line rounds up to next byte boundary.
1904 28 : nBitsPerLine = nBlockXSize * iPixelBitSkip;
1905 28 : if( (nBitsPerLine & 7) != 0 )
1906 15 : nBitsPerLine = (nBitsPerLine + 7) & (~7);
1907 :
1908 28 : iPixel = 0;
1909 671 : for( iY = 0; iY < nBlockYSize; iY++ )
1910 : {
1911 643 : iBitOffset = iBandBitOffset + iY * nBitsPerLine;
1912 :
1913 22616 : for( iX = 0; iX < nBlockXSize; iX++ )
1914 : {
1915 21973 : GUInt32 nInWord = 0;
1916 21973 : if( eDataType == GDT_Byte )
1917 4085 : nInWord = ((GByte *) pabyThisImage)[iPixel++];
1918 17888 : else if( eDataType == GDT_UInt16 )
1919 15088 : nInWord = ((GUInt16 *) pabyThisImage)[iPixel++];
1920 2800 : else if( eDataType == GDT_UInt32 )
1921 2800 : nInWord = ((GUInt32 *) pabyThisImage)[iPixel++];
1922 : else
1923 0 : CPLAssert(0);
1924 :
1925 21973 : if (nInWord > nMaxVal)
1926 : {
1927 0 : nInWord = nMaxVal;
1928 0 : if( !poGDS->bClipWarn )
1929 : {
1930 0 : poGDS->bClipWarn = TRUE;
1931 : CPLError( CE_Warning, CPLE_AppDefined,
1932 0 : "One or more pixels clipped to fit %d bit domain.", poGDS->nBitsPerSample );
1933 : }
1934 : }
1935 :
1936 21973 : if (poGDS->nBitsPerSample == 24)
1937 : {
1938 : /* -------------------------------------------------------------------- */
1939 : /* Special case for 24bit data which is pre-byteswapped since */
1940 : /* the size falls on a byte boundary ... ugg (#2361). */
1941 : /* -------------------------------------------------------------------- */
1942 : #ifdef CPL_MSB
1943 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 0] =
1944 : (GByte) nInWord;
1945 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 1] =
1946 : (GByte) (nInWord >> 8);
1947 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 2] =
1948 : (GByte) (nInWord >> 16);
1949 : #else
1950 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 0] =
1951 1400 : (GByte) (nInWord >> 16);
1952 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 1] =
1953 1400 : (GByte) (nInWord >> 8);
1954 : poGDS->pabyBlockBuf[(iBitOffset>>3) + 2] =
1955 1400 : (GByte) nInWord;
1956 : #endif
1957 1400 : iBitOffset += 24;
1958 : }
1959 : else
1960 : {
1961 248624 : for( iBit = 0; iBit < poGDS->nBitsPerSample; iBit++ )
1962 : {
1963 228051 : if (nInWord & (1 << (poGDS->nBitsPerSample - 1 - iBit)))
1964 101895 : poGDS->pabyBlockBuf[iBitOffset>>3] |= (0x80 >>(iBitOffset & 7));
1965 : else
1966 : {
1967 : /* We must explictly unset the bit as we may update an existing block */
1968 126156 : poGDS->pabyBlockBuf[iBitOffset>>3] &= ~(0x80 >>(iBitOffset & 7));
1969 : }
1970 :
1971 228051 : iBitOffset++;
1972 : }
1973 : }
1974 :
1975 21973 : iBitOffset= iBitOffset + iPixelBitSkip - poGDS->nBitsPerSample;
1976 : }
1977 : }
1978 :
1979 28 : if( poBlock != NULL )
1980 : {
1981 12 : poBlock->MarkClean();
1982 12 : poBlock->DropLock();
1983 : }
1984 : }
1985 :
1986 16 : poGDS->bLoadedBlockDirty = TRUE;
1987 :
1988 16 : return CE_None;
1989 : }
1990 :
1991 : /************************************************************************/
1992 : /* IReadBlock() */
1993 : /************************************************************************/
1994 :
1995 : CPLErr GTiffOddBitsBand::IReadBlock( int nBlockXOff, int nBlockYOff,
1996 133 : void * pImage )
1997 :
1998 : {
1999 : int nBlockId;
2000 133 : CPLErr eErr = CE_None;
2001 :
2002 133 : if (!poGDS->SetDirectory())
2003 0 : return CE_Failure;
2004 :
2005 133 : nBlockId = nBlockXOff + nBlockYOff * nBlocksPerRow;
2006 :
2007 133 : if( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE )
2008 20 : nBlockId += (nBand-1) * poGDS->nBlocksPerBand;
2009 :
2010 : /* -------------------------------------------------------------------- */
2011 : /* Handle the case of a strip in a writable file that doesn't */
2012 : /* exist yet, but that we want to read. Just set to zeros and */
2013 : /* return. */
2014 : /* -------------------------------------------------------------------- */
2015 133 : if( !poGDS->IsBlockAvailable(nBlockId) )
2016 : {
2017 19 : NullBlock( pImage );
2018 19 : return CE_None;
2019 : }
2020 :
2021 : /* -------------------------------------------------------------------- */
2022 : /* Load the block buffer. */
2023 : /* -------------------------------------------------------------------- */
2024 114 : eErr = poGDS->LoadBlockBuf( nBlockId );
2025 114 : if( eErr != CE_None )
2026 0 : return eErr;
2027 :
2028 146 : if ( poGDS->nBitsPerSample == 1 && (poGDS->nBands == 1 || poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE ) )
2029 : {
2030 : /* -------------------------------------------------------------------- */
2031 : /* Translate 1bit data to eight bit. */
2032 : /* -------------------------------------------------------------------- */
2033 32 : int iDstOffset=0, iLine;
2034 32 : register GByte *pabyBlockBuf = poGDS->pabyBlockBuf;
2035 :
2036 2103 : for( iLine = 0; iLine < nBlockYSize; iLine++ )
2037 : {
2038 : int iSrcOffset, iPixel;
2039 :
2040 2071 : iSrcOffset = ((nBlockXSize+7) >> 3) * 8 * iLine;
2041 :
2042 235030 : for( iPixel = 0; iPixel < nBlockXSize; iPixel++, iSrcOffset++ )
2043 : {
2044 232959 : if( pabyBlockBuf[iSrcOffset >>3] & (0x80 >> (iSrcOffset & 0x7)) )
2045 52867 : ((GByte *) pImage)[iDstOffset++] = 1;
2046 : else
2047 180092 : ((GByte *) pImage)[iDstOffset++] = 0;
2048 : }
2049 : }
2050 : }
2051 : /* -------------------------------------------------------------------- */
2052 : /* Handle the case of 16- and 24-bit floating point data as per */
2053 : /* TIFF Technical Note 3. */
2054 : /* -------------------------------------------------------------------- */
2055 84 : else if( eDataType == GDT_Float32 && poGDS->nBitsPerSample < 32 )
2056 : {
2057 : int i, nBlockPixels, nWordBytes, iSkipBytes;
2058 : GByte *pabyImage;
2059 :
2060 2 : nWordBytes = poGDS->nBitsPerSample / 8;
2061 2 : pabyImage = poGDS->pabyBlockBuf + (nBand - 1) * nWordBytes;
2062 : iSkipBytes = ( poGDS->nPlanarConfig == PLANARCONFIG_SEPARATE ) ?
2063 2 : nWordBytes : poGDS->nBands * nWordBytes;
2064 :
2065 2 : nBlockPixels = nBlockXSize * nBlockYSize;
2066 2 : if ( poGDS->nBitsPerSample == 16 )
2067 : {
2068 401 : for( i = 0; i < nBlockPixels; i++ )
2069 : {
2070 : ((GUInt32 *) pImage)[i] =
2071 400 : HalfToFloat( *((GUInt16 *)pabyImage) );
2072 400 : pabyImage += iSkipBytes;
2073 : }
2074 : }
2075 1 : else if ( poGDS->nBitsPerSample == 24 )
2076 : {
2077 401 : for( i = 0; i < nBlockPixels; i++ )
2078 : {
2079 : #ifdef CPL_MSB
2080 : ((GUInt32 *) pImage)[i] =
2081 : TripleToFloat( ((GUInt32)*(pabyImage + 0) << 16)
2082 : | ((GUInt32)*(pabyImage + 1) << 8)
2083 : | (GUInt32)*(pabyImage + 2) );
2084 : #else
2085 : ((GUInt32 *) pImage)[i] =
2086 : TripleToFloat( ((GUInt32)*(pabyImage + 2) << 16)
2087 : | ((GUInt32)*(pabyImage + 1) << 8)
2088 400 : | (GUInt32)*pabyImage );
2089 : #endif
2090 400 : pabyImage += iSkipBytes;
2091 : }
2092 : }
2093 : }
2094 :
2095 : /* -------------------------------------------------------------------- */
2096 : /* Special case for moving 12bit data somewhat more efficiently. */
2097 : /* -------------------------------------------------------------------- */
2098 80 : else if( poGDS->nBitsPerSample == 12 )
2099 : {
2100 20 : int iPixel, iBitOffset = 0;
2101 : int iPixelBitSkip, iBandBitOffset, iX, iY, nBitsPerLine;
2102 :
2103 20 : if( poGDS->nPlanarConfig == PLANARCONFIG_CONTIG )
2104 : {
2105 17 : iPixelBitSkip = poGDS->nBands * poGDS->nBitsPerSample;
2106 17 : iBandBitOffset = (nBand-1) * poGDS->nBitsPerSample;
2107 : }
2108 : else
2109 : {
2110 3 : iPixelBitSkip = poGDS->nBitsPerSample;
2111 3 : iBandBitOffset = 0;
2112 : }
2113 :
2114 : // bits per line rounds up to next byte boundary.
2115 20 : nBitsPerLine = nBlockXSize * iPixelBitSkip;
2116 20 : if( (nBitsPerLine & 7) != 0 )
2117 0 : nBitsPerLine = (nBitsPerLine + 7) & (~7);
2118 :
2119 20 : iPixel = 0;
2120 904 : for( iY = 0; iY < nBlockYSize; iY++ )
2121 : {
2122 884 : iBitOffset = iBandBitOffset + iY * nBitsPerLine;
2123 :
2124 65524 : for( iX = 0; iX < nBlockXSize; iX++ )
2125 : {
2126 64640 : int iByte = iBitOffset>>3;
2127 :
2128 64640 : if( (iBitOffset & 0x7) == 0 )
2129 : {
2130 : /* starting on byte boundary */
2131 :
2132 : ((GUInt16 *) pImage)[iPixel++] =
2133 : (poGDS->pabyBlockBuf[iByte] << 4)
2134 32420 : | (poGDS->pabyBlockBuf[iByte+1] >> 4);
2135 : }
2136 : else
2137 : {
2138 : /* starting off byte boundary */
2139 :
2140 : ((GUInt16 *) pImage)[iPixel++] =
2141 : ((poGDS->pabyBlockBuf[iByte] & 0xf) << 8)
2142 32220 : | (poGDS->pabyBlockBuf[iByte+1]);
2143 : }
2144 64640 : iBitOffset += iPixelBitSkip;
2145 : }
2146 : }
2147 : }
2148 :
2149 : /* -------------------------------------------------------------------- */
2150 : /* Special case for 24bit data which is pre-byteswapped since */
2151 : /* the size falls on a byte boundary ... ugg (#2361). */
2152 : /* -------------------------------------------------------------------- */
2153 60 : else if( poGDS->nBitsPerSample == 24 )
2154 : {
2155 : int iPixel;
2156 : int iPixelByteSkip, iBandByteOffset, iX, iY, nBytesPerLine;
2157 :
2158 11 : if( poGDS->nPlanarConfig == PLANARCONFIG_CONTIG )
2159 : {
2160 8 : iPixelByteSkip = (poGDS->nBands * poGDS->nBitsPerSample) / 8;
2161 8 : iBandByteOffset = ((nBand-1) * poGDS->nBitsPerSample) / 8;
2162 : }
2163 : else
2164 : {
2165 3 : iPixelByteSkip = poGDS->nBitsPerSample / 8;
2166 3 : iBandByteOffset = 0;
2167 : }
2168 :
2169 11 : nBytesPerLine = nBlockXSize * iPixelByteSkip;
2170 :
2171 11 : iPixel = 0;
2172 191 : for( iY = 0; iY < nBlockYSize; iY++ )
2173 : {
2174 : GByte *pabyImage =
2175 180 : poGDS->pabyBlockBuf + iBandByteOffset + iY * nBytesPerLine;
2176 :
2177 3380 : for( iX = 0; iX < nBlockXSize; iX++ )
2178 : {
2179 : #ifdef CPL_MSB
2180 : ((GUInt32 *) pImage)[iPixel++] =
2181 : ((GUInt32)*(pabyImage + 2) << 16)
2182 : | ((GUInt32)*(pabyImage + 1) << 8)
2183 : | (GUInt32)*(pabyImage + 0);
2184 : #else
2185 : ((GUInt32 *) pImage)[iPixel++] =
2186 : ((GUInt32)*(pabyImage + 0) << 16)
2187 : | ((GUInt32)*(pabyImage + 1) << 8)
2188 3200 : | (GUInt32)*(pabyImage + 2);
2189 : #endif
2190 3200 : pabyImage += iPixelByteSkip;
2191 : }
2192 : }
2193 : }
2194 :
2195 : /* -------------------------------------------------------------------- */
2196 : /* Handle 1-32 bit integer data. */
2197 : /* -------------------------------------------------------------------- */
2198 : else
2199 : {
2200 49 : int iBit, iPixel, iBitOffset = 0;
2201 : int iPixelBitSkip, iBandBitOffset, iX, iY, nBitsPerLine;
2202 :
2203 49 : if( poGDS->nPlanarConfig == PLANARCONFIG_CONTIG )
2204 : {
2205 43 : iPixelBitSkip = poGDS->nBands * poGDS->nBitsPerSample;
2206 43 : iBandBitOffset = (nBand-1) * poGDS->nBitsPerSample;
2207 : }
2208 : else
2209 : {
2210 6 : iPixelBitSkip = poGDS->nBitsPerSample;
2211 6 : iBandBitOffset = 0;
2212 : }
2213 :
2214 : // bits per line rounds up to next byte boundary.
2215 49 : nBitsPerLine = nBlockXSize * iPixelBitSkip;
2216 49 : if( (nBitsPerLine & 7) != 0 )
2217 48 : nBitsPerLine = (nBitsPerLine + 7) & (~7);
2218 :
2219 49 : register GByte *pabyBlockBuf = poGDS->pabyBlockBuf;
2220 49 : iPixel = 0;
2221 :
2222 2285 : for( iY = 0; iY < nBlockYSize; iY++ )
2223 : {
2224 2236 : iBitOffset = iBandBitOffset + iY * nBitsPerLine;
2225 :
2226 180540 : for( iX = 0; iX < nBlockXSize; iX++ )
2227 : {
2228 178304 : int nOutWord = 0;
2229 :
2230 452342 : for( iBit = 0; iBit < poGDS->nBitsPerSample; iBit++ )
2231 : {
2232 274038 : if( pabyBlockBuf[iBitOffset>>3]
2233 : & (0x80 >>(iBitOffset & 7)) )
2234 137696 : nOutWord |= (1 << (poGDS->nBitsPerSample - 1 - iBit));
2235 274038 : iBitOffset++;
2236 : }
2237 :
2238 178304 : iBitOffset= iBitOffset + iPixelBitSkip - poGDS->nBitsPerSample;
2239 :
2240 178304 : if( eDataType == GDT_Byte )
2241 172302 : ((GByte *) pImage)[iPixel++] = (GByte) nOutWord;
2242 6002 : else if( eDataType == GDT_UInt16 )
2243 3201 : ((GUInt16 *) pImage)[iPixel++] = (GUInt16) nOutWord;
2244 2801 : else if( eDataType == GDT_UInt32 )
2245 2801 : ((GUInt32 *) pImage)[iPixel++] = nOutWord;
2246 : else
2247 0 : CPLAssert(0);
2248 : }
2249 : }
2250 : }
2251 :
2252 114 : return CE_None;
2253 : }
2254 :
2255 :
2256 : /************************************************************************/
2257 : /* ==================================================================== */
2258 : /* GTiffBitmapBand */
2259 : /* ==================================================================== */
2260 : /************************************************************************/
2261 :
2262 : class GTiffBitmapBand : public GTiffOddBitsBand
2263 : {
2264 : friend class GTiffDataset;
2265 :
2266 : GDALColorTable *poColorTable;
2267 :
2268 : public:
2269 :
2270 : GTiffBitmapBand( GTiffDataset *, int );
2271 : virtual ~GTiffBitmapBand();
2272 :
2273 : virtual GDALColorInterp GetColorInterpretation();
2274 : virtual GDALColorTable *GetColorTable();
2275 : };
2276 :
2277 :
2278 : /************************************************************************/
2279 : /* GTiffBitmapBand() */
2280 : /************************************************************************/
2281 :
2282 76 : GTiffBitmapBand::GTiffBitmapBand( GTiffDataset *poDS, int nBand )
2283 76 : : GTiffOddBitsBand( poDS, nBand )
2284 :
2285 : {
2286 76 : eDataType = GDT_Byte;
2287 :
2288 76 : if( poDS->poColorTable != NULL )
2289 17 : poColorTable = poDS->poColorTable->Clone();
2290 : else
2291 : {
2292 : GDALColorEntry oWhite, oBlack;
2293 :
2294 59 : oWhite.c1 = 255;
2295 59 : oWhite.c2 = 255;
2296 59 : oWhite.c3 = 255;
2297 59 : oWhite.c4 = 255;
2298 :
2299 59 : oBlack.c1 = 0;
2300 59 : oBlack.c2 = 0;
2301 59 : oBlack.c3 = 0;
2302 59 : oBlack.c4 = 255;
2303 :
2304 59 : poColorTable = new GDALColorTable();
2305 :
2306 59 : if( poDS->nPhotometric == PHOTOMETRIC_MINISWHITE )
2307 : {
2308 0 : poColorTable->SetColorEntry( 0, &oWhite );
2309 0 : poColorTable->SetColorEntry( 1, &oBlack );
2310 : }
2311 : else
2312 : {
2313 59 : poColorTable->SetColorEntry( 0, &oBlack );
2314 59 : poColorTable->SetColorEntry( 1, &oWhite );
2315 : }
2316 : }
2317 76 : }
2318 :
2319 : /************************************************************************/
2320 : /* ~GTiffBitmapBand() */
2321 : /************************************************************************/
2322 :
2323 76 : GTiffBitmapBand::~GTiffBitmapBand()
2324 :
2325 : {
2326 76 : delete poColorTable;
2327 76 : }
2328 :
2329 : /************************************************************************/
2330 : /* GetColorInterpretation() */
2331 : /************************************************************************/
2332 :
2333 8 : GDALColorInterp GTiffBitmapBand::GetColorInterpretation()
2334 :
2335 : {
2336 8 : return GCI_PaletteIndex;
2337 : }
2338 :
2339 : /************************************************************************/
2340 : /* GetColorTable() */
2341 : /************************************************************************/
2342 :
2343 10 : GDALColorTable *GTiffBitmapBand::GetColorTable()
2344 :
2345 : {
2346 10 : return poColorTable;
2347 : }
2348 :
2349 : /************************************************************************/
2350 : /* ==================================================================== */
2351 : /* GTiffSplitBitmapBand */
2352 : /* ==================================================================== */
2353 : /************************************************************************/
2354 :
2355 : class GTiffSplitBitmapBand : public GTiffBitmapBand
2356 : {
2357 : friend class GTiffDataset;
2358 :
2359 : public:
2360 :
2361 : GTiffSplitBitmapBand( GTiffDataset *, int );
2362 : virtual ~GTiffSplitBitmapBand();
2363 :
2364 : virtual CPLErr IReadBlock( int, int, void * );
2365 : virtual CPLErr IWriteBlock( int, int, void * );
2366 : };
2367 :
2368 :
2369 : /************************************************************************/
2370 : /* GTiffSplitBitmapBand() */
2371 : /************************************************************************/
2372 :
2373 4 : GTiffSplitBitmapBand::GTiffSplitBitmapBand( GTiffDataset *poDS, int nBand )
2374 4 : : GTiffBitmapBand( poDS, nBand )
2375 :
2376 : {
2377 4 : nBlockXSize = poDS->GetRasterXSize();
2378 4 : nBlockYSize = 1;
2379 4 : }
2380 :
2381 : /************************************************************************/
2382 : /* ~GTiffSplitBitmapBand() */
2383 : /************************************************************************/
2384 :
2385 4 : GTiffSplitBitmapBand::~GTiffSplitBitmapBand()
2386 :
2387 : {
2388 4 : }
2389 :
2390 :
2391 : /************************************************************************/
2392 : /* IReadBlock() */
2393 : /************************************************************************/
2394 :
2395 : CPLErr GTiffSplitBitmapBand::IReadBlock( int nBlockXOff, int nBlockYOff,
2396 21600 : void * pImage )
2397 :
2398 : {
2399 : (void) nBlockXOff;
2400 :
2401 21600 : if (!poGDS->SetDirectory())
2402 0 : return CE_Failure;
2403 :
2404 21600 : if (poGDS->pabyBlockBuf == NULL)
2405 3 : poGDS->pabyBlockBuf = (GByte *) CPLMalloc(TIFFScanlineSize(poGDS->hTIFF));
2406 :
2407 : /* -------------------------------------------------------------------- */
2408 : /* Read through to target scanline. */
2409 : /* -------------------------------------------------------------------- */
2410 21600 : if( poGDS->nLastLineRead >= nBlockYOff )
2411 0 : poGDS->nLastLineRead = -1;
2412 :
2413 64800 : while( poGDS->nLastLineRead < nBlockYOff )
2414 : {
2415 21600 : if( TIFFReadScanline( poGDS->hTIFF, poGDS->pabyBlockBuf, ++poGDS->nLastLineRead, 0 ) == -1 )
2416 : {
2417 : CPLError( CE_Failure, CPLE_AppDefined,
2418 0 : "TIFFReadScanline() failed." );
2419 0 : return CE_Failure;
2420 : }
2421 : }
2422 :
2423 : /* -------------------------------------------------------------------- */
2424 : /* Translate 1bit data to eight bit. */
2425 : /* -------------------------------------------------------------------- */
2426 21600 : int iPixel, iSrcOffset=0, iDstOffset=0;
2427 :
2428 21621600 : for( iPixel = 0; iPixel < nBlockXSize; iPixel++, iSrcOffset++ )
2429 : {
2430 21600000 : if( poGDS->pabyBlockBuf[iSrcOffset >>3] & (0x80 >> (iSrcOffset & 0x7)) )
2431 21243630 : ((GByte *) pImage)[iDstOffset++] = 1;
2432 : else
2433 356370 : ((GByte *) pImage)[iDstOffset++] = 0;
2434 : }
2435 :
2436 21600 : return CE_None;
2437 : }
2438 :
2439 : /************************************************************************/
2440 : /* IWriteBlock() */
2441 : /************************************************************************/
2442 :
2443 : CPLErr GTiffSplitBitmapBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
2444 0 : void * pImage )
2445 :
2446 : {
2447 : (void) nBlockXOff;
2448 : (void) nBlockYOff;
2449 : (void) pImage;
2450 :
2451 : CPLError( CE_Failure, CPLE_AppDefined,
2452 0 : "Split bitmap bands are read-only." );
2453 0 : return CE_Failure;
2454 : }
2455 :
2456 : /************************************************************************/
2457 : /* ==================================================================== */
2458 : /* GTiffDataset */
2459 : /* ==================================================================== */
2460 : /************************************************************************/
2461 :
2462 :
2463 : /************************************************************************/
2464 : /* GTiffDataset() */
2465 : /************************************************************************/
2466 :
2467 4635 : GTiffDataset::GTiffDataset()
2468 :
2469 : {
2470 4635 : nLoadedBlock = -1;
2471 4635 : bLoadedBlockDirty = FALSE;
2472 4635 : pabyBlockBuf = NULL;
2473 4635 : hTIFF = NULL;
2474 4635 : bNeedsRewrite = FALSE;
2475 4635 : bMetadataChanged = FALSE;
2476 4635 : bGeoTIFFInfoChanged = FALSE;
2477 4635 : bCrystalized = TRUE;
2478 4635 : poColorTable = NULL;
2479 4635 : bNoDataSet = FALSE;
2480 4635 : dfNoDataValue = -9999.0;
2481 4635 : pszProjection = CPLStrdup("");
2482 4635 : bLookedForProjection = FALSE;
2483 4635 : bBase = TRUE;
2484 4635 : bCloseTIFFHandle = FALSE;
2485 4635 : bTreatAsRGBA = FALSE;
2486 4635 : nOverviewCount = 0;
2487 4635 : papoOverviewDS = NULL;
2488 4635 : nDirOffset = 0;
2489 4635 : poActiveDS = NULL;
2490 4635 : ppoActiveDSRef = NULL;
2491 :
2492 4635 : bGeoTransformValid = FALSE;
2493 4635 : adfGeoTransform[0] = 0.0;
2494 4635 : adfGeoTransform[1] = 1.0;
2495 4635 : adfGeoTransform[2] = 0.0;
2496 4635 : adfGeoTransform[3] = 0.0;
2497 4635 : adfGeoTransform[4] = 0.0;
2498 4635 : adfGeoTransform[5] = 1.0;
2499 :
2500 4635 : nGCPCount = 0;
2501 4635 : pasGCPList = NULL;
2502 :
2503 4635 : osProfile = "GDALGeoTIFF";
2504 :
2505 4635 : papszCreationOptions = NULL;
2506 :
2507 4635 : nTempWriteBufferSize = 0;
2508 4635 : pabyTempWriteBuffer = NULL;
2509 :
2510 4635 : poMaskDS = NULL;
2511 4635 : poBaseDS = NULL;
2512 :
2513 4635 : bFillEmptyTiles = FALSE;
2514 4635 : bLoadingOtherBands = FALSE;
2515 4635 : nLastLineRead = -1;
2516 4635 : nLastBandRead = -1;
2517 4635 : bTreatAsSplit = FALSE;
2518 4635 : bTreatAsSplitBitmap = FALSE;
2519 4635 : bClipWarn = FALSE;
2520 4635 : }
2521 :
2522 : /************************************************************************/
2523 : /* ~GTiffDataset() */
2524 : /************************************************************************/
2525 :
2526 4635 : GTiffDataset::~GTiffDataset()
2527 :
2528 : {
2529 4635 : Crystalize();
2530 :
2531 : /* -------------------------------------------------------------------- */
2532 : /* Ensure any blocks write cached by GDAL gets pushed through libtiff.*/
2533 : /* -------------------------------------------------------------------- */
2534 4635 : GDALPamDataset::FlushCache();
2535 :
2536 : /* -------------------------------------------------------------------- */
2537 : /* Fill in missing blocks with empty data. */
2538 : /* -------------------------------------------------------------------- */
2539 4635 : if( bFillEmptyTiles )
2540 : {
2541 764 : FillEmptyTiles();
2542 764 : bFillEmptyTiles = FALSE;
2543 : }
2544 :
2545 : /* -------------------------------------------------------------------- */
2546 : /* Force a complete flush, including either rewriting(moving) */
2547 : /* of writing in place the current directory. */
2548 : /* -------------------------------------------------------------------- */
2549 4635 : FlushCache();
2550 :
2551 : /* -------------------------------------------------------------------- */
2552 : /* If there is still changed metadata, then presumably we want */
2553 : /* to push it into PAM. */
2554 : /* -------------------------------------------------------------------- */
2555 4635 : if( bMetadataChanged )
2556 : {
2557 26 : PushMetadataToPam();
2558 26 : bMetadataChanged = FALSE;
2559 26 : GDALPamDataset::FlushCache();
2560 : }
2561 :
2562 : /* -------------------------------------------------------------------- */
2563 : /* Cleanup overviews. */
2564 : /* -------------------------------------------------------------------- */
2565 4635 : if( bBase )
2566 : {
2567 4518 : for( int i = 0; i < nOverviewCount; i++ )
2568 : {
2569 251 : delete papoOverviewDS[i];
2570 : }
2571 : }
2572 :
2573 : /* If we are a mask dataset, we can have overviews, but we don't */
2574 : /* own them. We can only free the array, not the overviews themselves */
2575 4635 : CPLFree( papoOverviewDS );
2576 :
2577 : /* poMaskDS is owned by the main image and the overviews */
2578 : /* so because of the latter case, we can delete it even if */
2579 : /* we are not the base image */
2580 4635 : if (poMaskDS)
2581 57 : delete poMaskDS;
2582 :
2583 4635 : if( poColorTable != NULL )
2584 105 : delete poColorTable;
2585 :
2586 4635 : if( bBase || bCloseTIFFHandle )
2587 : {
2588 4271 : XTIFFClose( hTIFF );
2589 : }
2590 :
2591 4635 : if( nGCPCount > 0 )
2592 : {
2593 44 : GDALDeinitGCPs( nGCPCount, pasGCPList );
2594 44 : CPLFree( pasGCPList );
2595 : }
2596 :
2597 4635 : CPLFree( pszProjection );
2598 :
2599 4635 : CSLDestroy( papszCreationOptions );
2600 :
2601 4635 : CPLFree(pabyTempWriteBuffer);
2602 :
2603 4635 : if( *ppoActiveDSRef == this )
2604 4395 : *ppoActiveDSRef = NULL;
2605 4635 : }
2606 :
2607 : /************************************************************************/
2608 : /* FillEmptyTiles() */
2609 : /************************************************************************/
2610 :
2611 764 : void GTiffDataset::FillEmptyTiles()
2612 :
2613 : {
2614 764 : toff_t *panByteCounts = NULL;
2615 : int nBlockCount, iBlock;
2616 :
2617 764 : if (!SetDirectory())
2618 0 : return;
2619 :
2620 : /* -------------------------------------------------------------------- */
2621 : /* How many blocks are there in this file? */
2622 : /* -------------------------------------------------------------------- */
2623 764 : if( nPlanarConfig == PLANARCONFIG_SEPARATE )
2624 5 : nBlockCount = nBlocksPerBand * nBands;
2625 : else
2626 759 : nBlockCount = nBlocksPerBand;
2627 :
2628 : /* -------------------------------------------------------------------- */
2629 : /* Fetch block maps. */
2630 : /* -------------------------------------------------------------------- */
2631 764 : if( TIFFIsTiled( hTIFF ) )
2632 15 : TIFFGetField( hTIFF, TIFFTAG_TILEBYTECOUNTS, &panByteCounts );
2633 : else
2634 749 : TIFFGetField( hTIFF, TIFFTAG_STRIPBYTECOUNTS, &panByteCounts );
2635 :
2636 764 : if (panByteCounts == NULL)
2637 : {
2638 : /* Got here with libtiff 3.9.3 and tiff_write_8 test */
2639 0 : CPLError(CE_Failure, CPLE_AppDefined, "FillEmptyTiles() failed because panByteCounts == NULL");
2640 0 : return;
2641 : }
2642 :
2643 : /* -------------------------------------------------------------------- */
2644 : /* Prepare a blank data buffer to write for uninitialized blocks. */
2645 : /* -------------------------------------------------------------------- */
2646 : int nBlockBytes;
2647 :
2648 764 : if( TIFFIsTiled( hTIFF ) )
2649 15 : nBlockBytes = TIFFTileSize(hTIFF);
2650 : else
2651 749 : nBlockBytes = TIFFStripSize(hTIFF);
2652 :
2653 764 : GByte *pabyData = (GByte *) VSICalloc(nBlockBytes,1);
2654 764 : if (pabyData == NULL)
2655 : {
2656 : CPLError(CE_Failure, CPLE_OutOfMemory,
2657 0 : "Cannot allocate %d bytes", nBlockBytes);
2658 0 : return;
2659 : }
2660 :
2661 : /* -------------------------------------------------------------------- */
2662 : /* Check all blocks, writing out data for uninitialized blocks. */
2663 : /* -------------------------------------------------------------------- */
2664 81051 : for( iBlock = 0; iBlock < nBlockCount; iBlock++ )
2665 : {
2666 80287 : if( panByteCounts[iBlock] == 0 )
2667 70098 : WriteEncodedTileOrStrip( iBlock, pabyData, FALSE );
2668 : }
2669 :
2670 764 : CPLFree( pabyData );
2671 : }
2672 :
2673 : /************************************************************************/
2674 : /* WriteEncodedTile() */
2675 : /************************************************************************/
2676 :
2677 : int GTiffDataset::WriteEncodedTile(uint32 tile, void* data,
2678 8620 : int bPreserveDataBuffer)
2679 : {
2680 : /* TIFFWriteEncodedTile can alter the passed buffer if byte-swapping is necessary */
2681 : /* so we use a temporary buffer before calling it */
2682 8620 : int cc = TIFFTileSize( hTIFF );
2683 8620 : if (bPreserveDataBuffer && TIFFIsByteSwapped(hTIFF))
2684 : {
2685 40 : if (cc != nTempWriteBufferSize)
2686 : {
2687 21 : pabyTempWriteBuffer = CPLRealloc(pabyTempWriteBuffer, cc);
2688 21 : nTempWriteBufferSize = cc;
2689 : }
2690 40 : memcpy(pabyTempWriteBuffer, data, cc);
2691 40 : return TIFFWriteEncodedTile(hTIFF, tile, pabyTempWriteBuffer, cc);
2692 : }
2693 : else
2694 8580 : return TIFFWriteEncodedTile(hTIFF, tile, data, cc);
2695 : }
2696 :
2697 : /************************************************************************/
2698 : /* WriteEncodedStrip() */
2699 : /************************************************************************/
2700 :
2701 : int GTiffDataset::WriteEncodedStrip(uint32 strip, void* data,
2702 74764 : int bPreserveDataBuffer)
2703 : {
2704 74764 : int cc = TIFFStripSize( hTIFF );
2705 :
2706 : /* -------------------------------------------------------------------- */
2707 : /* If this is the last strip in the image, and is partial, then */
2708 : /* we need to trim the number of scanlines written to the */
2709 : /* amount of valid data we have. (#2748) */
2710 : /* -------------------------------------------------------------------- */
2711 74764 : int nStripWithinBand = strip % nBlocksPerBand;
2712 :
2713 74764 : if( (int) ((nStripWithinBand+1) * nRowsPerStrip) > GetRasterYSize() )
2714 : {
2715 : cc = (cc / nRowsPerStrip)
2716 85 : * (GetRasterYSize() - nStripWithinBand * nRowsPerStrip);
2717 : CPLDebug( "GTiff", "Adjusted bytes to write from %d to %d.",
2718 85 : (int) TIFFStripSize(hTIFF), cc );
2719 : }
2720 :
2721 : /* -------------------------------------------------------------------- */
2722 : /* TIFFWriteEncodedStrip can alter the passed buffer if */
2723 : /* byte-swapping is necessary so we use a temporary buffer */
2724 : /* before calling it. */
2725 : /* -------------------------------------------------------------------- */
2726 74764 : if (bPreserveDataBuffer && TIFFIsByteSwapped(hTIFF))
2727 : {
2728 28 : if (cc != nTempWriteBufferSize)
2729 : {
2730 22 : pabyTempWriteBuffer = CPLRealloc(pabyTempWriteBuffer, cc);
2731 22 : nTempWriteBufferSize = cc;
2732 : }
2733 28 : memcpy(pabyTempWriteBuffer, data, cc);
2734 28 : return TIFFWriteEncodedStrip(hTIFF, strip, pabyTempWriteBuffer, cc);
2735 : }
2736 : else
2737 74736 : return TIFFWriteEncodedStrip(hTIFF, strip, data, cc);
2738 : }
2739 :
2740 : /************************************************************************/
2741 : /* WriteEncodedTileOrStrip() */
2742 : /************************************************************************/
2743 :
2744 : CPLErr GTiffDataset::WriteEncodedTileOrStrip(uint32 tile_or_strip, void* data,
2745 83384 : int bPreserveDataBuffer)
2746 : {
2747 83384 : CPLErr eErr = CE_None;
2748 :
2749 83384 : if( TIFFIsTiled( hTIFF ) )
2750 : {
2751 8620 : if( WriteEncodedTile(tile_or_strip, data, bPreserveDataBuffer) == -1 )
2752 : {
2753 0 : eErr = CE_Failure;
2754 : }
2755 : }
2756 : else
2757 : {
2758 74764 : if( WriteEncodedStrip(tile_or_strip, data, bPreserveDataBuffer) == -1 )
2759 : {
2760 0 : eErr = CE_Failure;
2761 : }
2762 : }
2763 :
2764 83384 : return eErr;
2765 : }
2766 :
2767 : /************************************************************************/
2768 : /* FlushBlockBuf() */
2769 : /************************************************************************/
2770 :
2771 195077 : CPLErr GTiffDataset::FlushBlockBuf()
2772 :
2773 : {
2774 195077 : CPLErr eErr = CE_None;
2775 :
2776 195077 : if( nLoadedBlock < 0 || !bLoadedBlockDirty )
2777 194266 : return CE_None;
2778 :
2779 811 : bLoadedBlockDirty = FALSE;
2780 :
2781 811 : if (!SetDirectory())
2782 0 : return CE_Failure;
2783 :
2784 811 : eErr = WriteEncodedTileOrStrip(nLoadedBlock, pabyBlockBuf, TRUE);
2785 811 : if (eErr != CE_None)
2786 : {
2787 : CPLError( CE_Failure, CPLE_AppDefined,
2788 0 : "WriteEncodedTile/Strip() failed." );
2789 : }
2790 :
2791 811 : return eErr;
2792 : }
2793 :
2794 : /************************************************************************/
2795 : /* LoadBlockBuf() */
2796 : /* */
2797 : /* Load working block buffer with request block (tile/strip). */
2798 : /************************************************************************/
2799 :
2800 69229 : CPLErr GTiffDataset::LoadBlockBuf( int nBlockId, int bReadFromDisk )
2801 :
2802 : {
2803 : int nBlockBufSize;
2804 69229 : CPLErr eErr = CE_None;
2805 :
2806 69229 : if( nLoadedBlock == nBlockId )
2807 67494 : return CE_None;
2808 :
2809 : /* -------------------------------------------------------------------- */
2810 : /* If we have a dirty loaded block, flush it out first. */
2811 : /* -------------------------------------------------------------------- */
2812 1735 : if( nLoadedBlock != -1 && bLoadedBlockDirty )
2813 : {
2814 0 : eErr = FlushBlockBuf();
2815 0 : if( eErr != CE_None )
2816 0 : return eErr;
2817 : }
2818 :
2819 : /* -------------------------------------------------------------------- */
2820 : /* Get block size. */
2821 : /* -------------------------------------------------------------------- */
2822 1735 : if( TIFFIsTiled(hTIFF) )
2823 152 : nBlockBufSize = TIFFTileSize( hTIFF );
2824 : else
2825 1583 : nBlockBufSize = TIFFStripSize( hTIFF );
2826 :
2827 1735 : if ( !nBlockBufSize )
2828 : {
2829 : CPLError( CE_Failure, CPLE_AppDefined,
2830 0 : "Bogus block size; unable to allocate a buffer.");
2831 0 : return CE_Failure;
2832 : }
2833 :
2834 : /* -------------------------------------------------------------------- */
2835 : /* Allocate a temporary buffer for this strip. */
2836 : /* -------------------------------------------------------------------- */
2837 1735 : if( pabyBlockBuf == NULL )
2838 : {
2839 385 : pabyBlockBuf = (GByte *) VSICalloc( 1, nBlockBufSize );
2840 385 : if( pabyBlockBuf == NULL )
2841 : {
2842 : CPLError( CE_Failure, CPLE_OutOfMemory,
2843 : "Unable to allocate %d bytes for a temporary strip "
2844 : "buffer in GTIFF driver.",
2845 0 : nBlockBufSize );
2846 :
2847 0 : return( CE_Failure );
2848 : }
2849 : }
2850 :
2851 : /* -------------------------------------------------------------------- */
2852 : /* When called from ::IWriteBlock in separate cases (or in single band */
2853 : /* geotiffs), the ::IWriteBlock will override the content of the buffer*/
2854 : /* with pImage, so we don't need to read data from disk */
2855 : /* -------------------------------------------------------------------- */
2856 1735 : if( !bReadFromDisk )
2857 : {
2858 47 : nLoadedBlock = nBlockId;
2859 47 : return CE_None;
2860 : }
2861 :
2862 : /* -------------------------------------------------------------------- */
2863 : /* The bottom most partial tiles and strips are sometimes only */
2864 : /* partially encoded. This code reduces the requested data so */
2865 : /* an error won't be reported in this case. (#1179) */
2866 : /* -------------------------------------------------------------------- */
2867 1688 : int nBlockReqSize = nBlockBufSize;
2868 1688 : int nBlocksPerRow = (nRasterXSize + nBlockXSize - 1) / nBlockXSize;
2869 1688 : int nBlockYOff = (nBlockId % nBlocksPerBand) / nBlocksPerRow;
2870 :
2871 1688 : if( (int)((nBlockYOff+1) * nBlockYSize) > nRasterYSize )
2872 : {
2873 : nBlockReqSize = (nBlockBufSize / nBlockYSize)
2874 151 : * (nBlockYSize - (((nBlockYOff+1) * nBlockYSize) % nRasterYSize));
2875 151 : memset( pabyBlockBuf, 0, nBlockBufSize );
2876 : }
2877 :
2878 : /* -------------------------------------------------------------------- */
2879 : /* If we don't have this block already loaded, and we know it */
2880 : /* doesn't yet exist on disk, just zero the memory buffer and */
2881 : /* pretend we loaded it. */
2882 : /* -------------------------------------------------------------------- */
2883 1688 : if( !IsBlockAvailable( nBlockId ) )
2884 : {
2885 698 : memset( pabyBlockBuf, 0, nBlockBufSize );
2886 698 : nLoadedBlock = nBlockId;
2887 698 : return CE_None;
2888 : }
2889 :
2890 : /* -------------------------------------------------------------------- */
2891 : /* Load the block, if it isn't our current block. */
2892 : /* -------------------------------------------------------------------- */
2893 990 : if( TIFFIsTiled( hTIFF ) )
2894 : {
2895 84 : if( TIFFReadEncodedTile(hTIFF, nBlockId, pabyBlockBuf,
2896 : nBlockReqSize) == -1 )
2897 : {
2898 : /* Once TIFFError() is properly hooked, this can go away */
2899 : CPLError( CE_Failure, CPLE_AppDefined,
2900 0 : "TIFFReadEncodedTile() failed." );
2901 :
2902 0 : memset( pabyBlockBuf, 0, nBlockBufSize );
2903 :
2904 0 : eErr = CE_Failure;
2905 : }
2906 : }
2907 : else
2908 : {
2909 906 : if( TIFFReadEncodedStrip(hTIFF, nBlockId, pabyBlockBuf,
2910 : nBlockReqSize) == -1 )
2911 : {
2912 : /* Once TIFFError() is properly hooked, this can go away */
2913 : CPLError( CE_Failure, CPLE_AppDefined,
2914 0 : "TIFFReadEncodedStrip() failed." );
2915 :
2916 0 : memset( pabyBlockBuf, 0, nBlockBufSize );
2917 :
2918 0 : eErr = CE_Failure;
2919 : }
2920 : }
2921 :
2922 990 : nLoadedBlock = nBlockId;
2923 990 : bLoadedBlockDirty = FALSE;
2924 :
2925 990 : return eErr;
2926 : }
2927 :
2928 :
2929 : /************************************************************************/
2930 : /* Crystalize() */
2931 : /* */
2932 : /* Make sure that the directory information is written out for */
2933 : /* a new file, require before writing any imagery data. */
2934 : /************************************************************************/
2935 :
2936 199621 : void GTiffDataset::Crystalize()
2937 :
2938 : {
2939 199621 : if( !bCrystalized )
2940 : {
2941 : WriteMetadata( this, hTIFF, TRUE, osProfile, osFilename,
2942 779 : papszCreationOptions );
2943 779 : WriteGeoTIFFInfo();
2944 :
2945 779 : bMetadataChanged = FALSE;
2946 779 : bGeoTIFFInfoChanged = FALSE;
2947 779 : bNeedsRewrite = FALSE;
2948 :
2949 779 : bCrystalized = TRUE;
2950 :
2951 779 : TIFFWriteCheck( hTIFF, TIFFIsTiled(hTIFF), "GTiffDataset::Crystalize");
2952 :
2953 : // Keep zip and tiff quality, and jpegcolormode which get reset when we call
2954 : // TIFFWriteDirectory
2955 779 : int jquality = -1, zquality = -1, nColorMode = -1;
2956 779 : TIFFGetField(hTIFF, TIFFTAG_JPEGQUALITY, &jquality);
2957 779 : TIFFGetField(hTIFF, TIFFTAG_ZIPQUALITY, &zquality);
2958 779 : TIFFGetField( hTIFF, TIFFTAG_JPEGCOLORMODE, &nColorMode );
2959 :
2960 779 : TIFFWriteDirectory( hTIFF );
2961 779 : TIFFSetDirectory( hTIFF, 0 );
2962 :
2963 :
2964 : // Now, reset zip and tiff quality and jpegcolormode.
2965 779 : if(jquality > 0)
2966 2 : TIFFSetField(hTIFF, TIFFTAG_JPEGQUALITY, jquality);
2967 779 : if(zquality > 0)
2968 0 : TIFFSetField(hTIFF, TIFFTAG_ZIPQUALITY, zquality);
2969 779 : if (nColorMode >= 0)
2970 2 : TIFFSetField(hTIFF, TIFFTAG_JPEGCOLORMODE, nColorMode);
2971 :
2972 779 : nDirOffset = TIFFCurrentDirOffset( hTIFF );
2973 : }
2974 199621 : }
2975 :
2976 :
2977 : /************************************************************************/
2978 : /* IsBlockAvailable() */
2979 : /* */
2980 : /* Return TRUE if the indicated strip/tile is available. We */
2981 : /* establish this by testing if the stripbytecount is zero. If */
2982 : /* zero then the block has never been committed to disk. */
2983 : /************************************************************************/
2984 :
2985 84081 : int GTiffDataset::IsBlockAvailable( int nBlockId )
2986 :
2987 : {
2988 84081 : toff_t *panByteCounts = NULL;
2989 :
2990 84081 : if( ( TIFFIsTiled( hTIFF )
2991 : && TIFFGetField( hTIFF, TIFFTAG_TILEBYTECOUNTS, &panByteCounts ) )
2992 : || ( !TIFFIsTiled( hTIFF )
2993 : && TIFFGetField( hTIFF, TIFFTAG_STRIPBYTECOUNTS, &panByteCounts ) ) )
2994 : {
2995 84081 : if( panByteCounts == NULL )
2996 0 : return FALSE;
2997 : else
2998 84081 : return panByteCounts[nBlockId] != 0;
2999 : }
3000 : else
3001 0 : return FALSE;
3002 : }
3003 :
3004 : /************************************************************************/
3005 : /* FlushCache() */
3006 : /* */
3007 : /* We override this so we can also flush out local tiff strip */
3008 : /* cache if need be. */
3009 : /************************************************************************/
3010 :
3011 4892 : void GTiffDataset::FlushCache()
3012 :
3013 : {
3014 4892 : GDALPamDataset::FlushCache();
3015 :
3016 4892 : if( bLoadedBlockDirty && nLoadedBlock != -1 )
3017 91 : FlushBlockBuf();
3018 :
3019 4892 : CPLFree( pabyBlockBuf );
3020 4892 : pabyBlockBuf = NULL;
3021 4892 : nLoadedBlock = -1;
3022 4892 : bLoadedBlockDirty = FALSE;
3023 :
3024 4892 : if (!SetDirectory())
3025 0 : return;
3026 4892 : FlushDirectory();
3027 : }
3028 :
3029 : /************************************************************************/
3030 : /* FlushDirectory() */
3031 : /************************************************************************/
3032 :
3033 9132 : void GTiffDataset::FlushDirectory()
3034 :
3035 : {
3036 9132 : if( GetAccess() == GA_Update )
3037 : {
3038 2591 : if( bMetadataChanged )
3039 : {
3040 14 : if (!SetDirectory())
3041 0 : return;
3042 : bNeedsRewrite =
3043 : WriteMetadata( this, hTIFF, TRUE, osProfile, osFilename,
3044 14 : papszCreationOptions );
3045 14 : bMetadataChanged = FALSE;
3046 : }
3047 :
3048 2591 : if( bGeoTIFFInfoChanged )
3049 : {
3050 18 : if (!SetDirectory())
3051 0 : return;
3052 18 : WriteGeoTIFFInfo();
3053 : }
3054 :
3055 2591 : if( bNeedsRewrite )
3056 : {
3057 : #if defined(TIFFLIB_VERSION)
3058 : #if defined(HAVE_TIFFGETSIZEPROC)
3059 73 : if (!SetDirectory())
3060 0 : return;
3061 :
3062 73 : TIFFSizeProc pfnSizeProc = TIFFGetSizeProc( hTIFF );
3063 :
3064 73 : nDirOffset = pfnSizeProc( TIFFClientdata( hTIFF ) );
3065 73 : if( (nDirOffset % 2) == 1 )
3066 14 : nDirOffset++;
3067 :
3068 73 : TIFFRewriteDirectory( hTIFF );
3069 :
3070 73 : TIFFSetSubDirectory( hTIFF, nDirOffset );
3071 : #elif TIFFLIB_VERSION > 20010925 && TIFFLIB_VERSION != 20011807
3072 : if (!SetDirectory())
3073 : return;
3074 :
3075 : TIFFRewriteDirectory( hTIFF );
3076 : #endif
3077 : #endif
3078 73 : bNeedsRewrite = FALSE;
3079 : }
3080 : }
3081 :
3082 : // there are some circumstances in which we can reach this point
3083 : // without having made this our directory (SetDirectory()) in which
3084 : // case we should not risk a flush.
3085 9132 : if( TIFFCurrentDirOffset(hTIFF) == nDirOffset )
3086 : {
3087 : #if defined(HAVE_TIFFGETSIZEPROC)
3088 9121 : TIFFSizeProc pfnSizeProc = TIFFGetSizeProc( hTIFF );
3089 :
3090 9121 : toff_t nNewDirOffset = pfnSizeProc( TIFFClientdata( hTIFF ) );
3091 9121 : if( (nNewDirOffset % 2) == 1 )
3092 870 : nNewDirOffset++;
3093 : #endif
3094 9121 : TIFFFlush( hTIFF );
3095 : #if defined(HAVE_TIFFGETSIZEPROC)
3096 9121 : if( nDirOffset != TIFFCurrentDirOffset( hTIFF ) )
3097 : {
3098 14 : nDirOffset = nNewDirOffset;
3099 : CPLDebug( "GTiff",
3100 14 : "directory moved during flush in FlushDirectory()" );
3101 : }
3102 : #endif
3103 : }
3104 : }
3105 :
3106 : /************************************************************************/
3107 : /* TIFF_OvLevelAdjust() */
3108 : /* */
3109 : /* Some overview levels cannot be achieved closely enough to be */
3110 : /* recognised as the desired overview level. This function */
3111 : /* will adjust an overview level to one that is achievable on */
3112 : /* the given raster size. */
3113 : /* */
3114 : /* For instance a 1200x1200 image on which a 256 level overview */
3115 : /* is request will end up generating a 5x5 overview. However, */
3116 : /* this will appear to the system be a level 240 overview. */
3117 : /* This function will adjust 256 to 240 based on knowledge of */
3118 : /* the image size. */
3119 : /* */
3120 : /* This is a copy of the GDALOvLevelAdjust() function in */
3121 : /* gdaldefaultoverviews.cpp. */
3122 : /************************************************************************/
3123 :
3124 65 : static int TIFF_OvLevelAdjust( int nOvLevel, int nXSize )
3125 :
3126 : {
3127 65 : int nOXSize = (nXSize + nOvLevel - 1) / nOvLevel;
3128 :
3129 65 : return (int) (0.5 + nXSize / (double) nOXSize);
3130 : }
3131 :
3132 : /************************************************************************/
3133 : /* CleanOverviews() */
3134 : /************************************************************************/
3135 :
3136 2 : CPLErr GTiffDataset::CleanOverviews()
3137 :
3138 : {
3139 2 : CPLAssert( bBase );
3140 :
3141 2 : FlushDirectory();
3142 2 : *ppoActiveDSRef = NULL;
3143 :
3144 : /* -------------------------------------------------------------------- */
3145 : /* Cleanup overviews objects, and get offsets to all overview */
3146 : /* directories. */
3147 : /* -------------------------------------------------------------------- */
3148 2 : std::vector<toff_t> anOvDirOffsets;
3149 : int i;
3150 :
3151 4 : for( i = 0; i < nOverviewCount; i++ )
3152 : {
3153 2 : anOvDirOffsets.push_back( papoOverviewDS[i]->nDirOffset );
3154 2 : delete papoOverviewDS[i];
3155 : }
3156 :
3157 : /* -------------------------------------------------------------------- */
3158 : /* Loop through all the directories, translating the offsets */
3159 : /* into indexes we can use with TIFFUnlinkDirectory(). */
3160 : /* -------------------------------------------------------------------- */
3161 2 : std::vector<uint16> anOvDirIndexes;
3162 2 : int iThisOffset = 1;
3163 :
3164 2 : TIFFSetDirectory( hTIFF, 0 );
3165 :
3166 2 : for( ; TRUE; )
3167 : {
3168 8 : for( i = 0; i < nOverviewCount; i++ )
3169 : {
3170 4 : if( anOvDirOffsets[i] == TIFFCurrentDirOffset( hTIFF ) )
3171 : {
3172 : CPLDebug( "GTiff", "%d -> %d",
3173 2 : (int) anOvDirOffsets[i], iThisOffset );
3174 2 : anOvDirIndexes.push_back( iThisOffset );
3175 : }
3176 : }
3177 :
3178 4 : if( TIFFLastDirectory( hTIFF ) )
3179 2 : break;
3180 :
3181 2 : TIFFReadDirectory( hTIFF );
3182 2 : iThisOffset++;
3183 : }
3184 :
3185 : /* -------------------------------------------------------------------- */
3186 : /* Actually unlink the target directories. Note that we do */
3187 : /* this from last to first so as to avoid renumbering any of */
3188 : /* the earlier directories we need to remove. */
3189 : /* -------------------------------------------------------------------- */
3190 6 : while( !anOvDirIndexes.empty() )
3191 : {
3192 2 : TIFFUnlinkDirectory( hTIFF, anOvDirIndexes.back() );
3193 2 : anOvDirIndexes.pop_back();
3194 : }
3195 :
3196 2 : CPLFree( papoOverviewDS );
3197 :
3198 2 : nOverviewCount = 0;
3199 2 : papoOverviewDS = NULL;
3200 :
3201 2 : if (!SetDirectory())
3202 0 : return CE_Failure;
3203 :
3204 2 : return CE_None;
3205 : }
3206 :
3207 : /************************************************************************/
3208 : /* IBuildOverviews() */
3209 : /************************************************************************/
3210 :
3211 : CPLErr GTiffDataset::IBuildOverviews(
3212 : const char * pszResampling,
3213 : int nOverviews, int * panOverviewList,
3214 : int nBands, int * panBandList,
3215 122 : GDALProgressFunc pfnProgress, void * pProgressData )
3216 :
3217 : {
3218 122 : CPLErr eErr = CE_None;
3219 : int i;
3220 : GTiffDataset *poODS;
3221 :
3222 : /* -------------------------------------------------------------------- */
3223 : /* If we don't have read access, then create the overviews */
3224 : /* externally. */
3225 : /* -------------------------------------------------------------------- */
3226 122 : if( GetAccess() != GA_Update )
3227 : {
3228 : CPLDebug( "GTiff",
3229 : "File open for read-only accessing, "
3230 58 : "creating overviews externally." );
3231 :
3232 : return GDALDataset::IBuildOverviews(
3233 : pszResampling, nOverviews, panOverviewList,
3234 58 : nBands, panBandList, pfnProgress, pProgressData );
3235 : }
3236 :
3237 : /* -------------------------------------------------------------------- */
3238 : /* If RRD overviews requested, then invoke generic handling. */
3239 : /* -------------------------------------------------------------------- */
3240 64 : if( CSLTestBoolean(CPLGetConfigOption( "USE_RRD", "NO" )) )
3241 : {
3242 : return GDALDataset::IBuildOverviews(
3243 : pszResampling, nOverviews, panOverviewList,
3244 2 : nBands, panBandList, pfnProgress, pProgressData );
3245 : }
3246 :
3247 : /* -------------------------------------------------------------------- */
3248 : /* Our TIFF overview support currently only works safely if all */
3249 : /* bands are handled at the same time. */
3250 : /* -------------------------------------------------------------------- */
3251 62 : if( nBands != GetRasterCount() )
3252 : {
3253 : CPLError( CE_Failure, CPLE_NotSupported,
3254 : "Generation of overviews in TIFF currently only"
3255 : " supported when operating on all bands.\n"
3256 0 : "Operation failed.\n" );
3257 0 : return CE_Failure;
3258 : }
3259 :
3260 : /* -------------------------------------------------------------------- */
3261 : /* Initialize progress counter. */
3262 : /* -------------------------------------------------------------------- */
3263 62 : if( !pfnProgress( 0.0, NULL, pProgressData ) )
3264 : {
3265 0 : CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
3266 0 : return CE_Failure;
3267 : }
3268 :
3269 : /* -------------------------------------------------------------------- */
3270 : /* If zero overviews were requested, we need to clear all */
3271 : /* existing overviews. */
3272 : /* -------------------------------------------------------------------- */
3273 62 : if( nOverviews == 0 )
3274 : {
3275 3 : if( nOverviewCount == 0 )
3276 : return GDALDataset::IBuildOverviews(
3277 : pszResampling, nOverviews, panOverviewList,
3278 1 : nBands, panBandList, pfnProgress, pProgressData );
3279 : else
3280 2 : return CleanOverviews();
3281 : }
3282 :
3283 : /* -------------------------------------------------------------------- */
3284 : /* Move to the directory for this dataset. */
3285 : /* -------------------------------------------------------------------- */
3286 59 : if (!SetDirectory())
3287 0 : return CE_Failure;
3288 59 : FlushDirectory();
3289 :
3290 : /* -------------------------------------------------------------------- */
3291 : /* If we are averaging bit data to grayscale we need to create */
3292 : /* 8bit overviews. */
3293 : /* -------------------------------------------------------------------- */
3294 59 : int nOvBitsPerSample = nBitsPerSample;
3295 :
3296 59 : if( EQUALN(pszResampling,"AVERAGE_BIT2",12) )
3297 2 : nOvBitsPerSample = 8;
3298 :
3299 : /* -------------------------------------------------------------------- */
3300 : /* Do we have a palette? If so, create a TIFF compatible version. */
3301 : /* -------------------------------------------------------------------- */
3302 59 : std::vector<unsigned short> anTRed, anTGreen, anTBlue;
3303 59 : unsigned short *panRed=NULL, *panGreen=NULL, *panBlue=NULL;
3304 :
3305 68 : if( nPhotometric == PHOTOMETRIC_PALETTE && poColorTable != NULL )
3306 : {
3307 : int nColors;
3308 :
3309 9 : if( nOvBitsPerSample == 8 )
3310 9 : nColors = 256;
3311 0 : else if( nOvBitsPerSample < 8 )
3312 0 : nColors = 1 << nOvBitsPerSample;
3313 : else
3314 0 : nColors = 65536;
3315 :
3316 9 : anTRed.resize(nColors,0);
3317 9 : anTGreen.resize(nColors,0);
3318 9 : anTBlue.resize(nColors,0);
3319 :
3320 2313 : for( int iColor = 0; iColor < nColors; iColor++ )
3321 : {
3322 2304 : if( iColor < poColorTable->GetColorEntryCount() )
3323 : {
3324 : GDALColorEntry sRGB;
3325 :
3326 2304 : poColorTable->GetColorEntryAsRGB( iColor, &sRGB );
3327 :
3328 2304 : anTRed[iColor] = (unsigned short) (256 * sRGB.c1);
3329 2304 : anTGreen[iColor] = (unsigned short) (256 * sRGB.c2);
3330 2304 : anTBlue[iColor] = (unsigned short) (256 * sRGB.c3);
3331 : }
3332 : else
3333 : {
3334 0 : anTRed[iColor] = anTGreen[iColor] = anTBlue[iColor] = 0;
3335 : }
3336 : }
3337 :
3338 9 : panRed = &(anTRed[0]);
3339 9 : panGreen = &(anTGreen[0]);
3340 9 : panBlue = &(anTBlue[0]);
3341 : }
3342 :
3343 : /* -------------------------------------------------------------------- */
3344 : /* Do we need some metadata for the overviews? */
3345 : /* -------------------------------------------------------------------- */
3346 59 : CPLString osMetadata;
3347 :
3348 59 : GTIFFBuildOverviewMetadata( pszResampling, this, osMetadata );
3349 :
3350 : /* -------------------------------------------------------------------- */
3351 : /* Fetch extra sample tag */
3352 : /* -------------------------------------------------------------------- */
3353 59 : uint16 *panExtraSampleValues = NULL;
3354 59 : uint16 nExtraSamples = 0;
3355 :
3356 59 : if( TIFFGetField( hTIFF, TIFFTAG_EXTRASAMPLES, &nExtraSamples, &panExtraSampleValues) )
3357 : {
3358 8 : uint16* panExtraSampleValuesNew = (uint16*) CPLMalloc(nExtraSamples * sizeof(uint16));
3359 8 : memcpy(panExtraSampleValuesNew, panExtraSampleValues, nExtraSamples * sizeof(uint16));
3360 8 : panExtraSampleValues = panExtraSampleValuesNew;
3361 : }
3362 : else
3363 : {
3364 51 : panExtraSampleValues = NULL;
3365 51 : nExtraSamples = 0;
3366 : }
3367 :
3368 : /* -------------------------------------------------------------------- */
3369 : /* Fetch predictor tag */
3370 : /* -------------------------------------------------------------------- */
3371 59 : uint16 nPredictor = PREDICTOR_NONE;
3372 59 : if ( nCompression == COMPRESSION_LZW ||
3373 : nCompression == COMPRESSION_ADOBE_DEFLATE )
3374 7 : TIFFGetField( hTIFF, TIFFTAG_PREDICTOR, &nPredictor );
3375 :
3376 : /* -------------------------------------------------------------------- */
3377 : /* Establish which of the overview levels we already have, and */
3378 : /* which are new. We assume that band 1 of the file is */
3379 : /* representative. */
3380 : /* -------------------------------------------------------------------- */
3381 : int nOvrBlockXSize, nOvrBlockYSize;
3382 59 : GTIFFGetOverviewBlockSize(&nOvrBlockXSize, &nOvrBlockYSize);
3383 140 : for( i = 0; i < nOverviews && eErr == CE_None; i++ )
3384 : {
3385 : int j;
3386 :
3387 114 : for( j = 0; j < nOverviewCount; j++ )
3388 : {
3389 : int nOvFactor;
3390 :
3391 33 : poODS = papoOverviewDS[j];
3392 :
3393 : nOvFactor = (int)
3394 33 : (0.5 + GetRasterXSize() / (double) poODS->GetRasterXSize());
3395 :
3396 33 : if( nOvFactor == panOverviewList[i]
3397 : || nOvFactor == TIFF_OvLevelAdjust( panOverviewList[i],
3398 : GetRasterXSize() ) )
3399 8 : panOverviewList[i] *= -1;
3400 : }
3401 :
3402 81 : if( panOverviewList[i] > 0 )
3403 : {
3404 : toff_t nOverviewOffset;
3405 : int nOXSize, nOYSize;
3406 :
3407 : nOXSize = (GetRasterXSize() + panOverviewList[i] - 1)
3408 73 : / panOverviewList[i];
3409 : nOYSize = (GetRasterYSize() + panOverviewList[i] - 1)
3410 73 : / panOverviewList[i];
3411 :
3412 : nOverviewOffset =
3413 : GTIFFWriteDirectory(hTIFF, FILETYPE_REDUCEDIMAGE,
3414 : nOXSize, nOYSize,
3415 : nOvBitsPerSample, nPlanarConfig,
3416 : nSamplesPerPixel, nOvrBlockXSize, nOvrBlockYSize, TRUE,
3417 : nCompression, nPhotometric, nSampleFormat,
3418 : nPredictor,
3419 : panRed, panGreen, panBlue,
3420 : nExtraSamples, panExtraSampleValues,
3421 73 : osMetadata );
3422 :
3423 73 : if( nOverviewOffset == 0 )
3424 : {
3425 0 : eErr = CE_Failure;
3426 0 : continue;
3427 : }
3428 :
3429 73 : poODS = new GTiffDataset();
3430 146 : if( poODS->OpenOffset( hTIFF, ppoActiveDSRef, nOverviewOffset, FALSE,
3431 : GA_Update ) != CE_None )
3432 : {
3433 0 : delete poODS;
3434 0 : eErr = CE_Failure;
3435 : }
3436 : else
3437 : {
3438 73 : nOverviewCount++;
3439 : papoOverviewDS = (GTiffDataset **)
3440 : CPLRealloc(papoOverviewDS,
3441 73 : nOverviewCount * (sizeof(void*)));
3442 73 : papoOverviewDS[nOverviewCount-1] = poODS;
3443 73 : poODS->poBaseDS = this;
3444 : }
3445 : }
3446 : else
3447 8 : panOverviewList[i] *= -1;
3448 : }
3449 :
3450 59 : CPLFree(panExtraSampleValues);
3451 59 : panExtraSampleValues = NULL;
3452 :
3453 : /* -------------------------------------------------------------------- */
3454 : /* Create overviews for the mask. */
3455 : /* -------------------------------------------------------------------- */
3456 :
3457 59 : if (poMaskDS != NULL &&
3458 : poMaskDS->GetRasterCount() == 1 &&
3459 : CSLTestBoolean(CPLGetConfigOption("GDAL_TIFF_INTERNAL_MASK", "NO")))
3460 : {
3461 3 : for( i = 0; i < nOverviewCount; i++ )
3462 : {
3463 2 : if (papoOverviewDS[i]->poMaskDS == NULL)
3464 : {
3465 : toff_t nOverviewOffset;
3466 :
3467 : nOverviewOffset =
3468 : GTIFFWriteDirectory(hTIFF, FILETYPE_REDUCEDIMAGE | FILETYPE_MASK,
3469 : papoOverviewDS[i]->nRasterXSize, papoOverviewDS[i]->nRasterYSize,
3470 : 1, PLANARCONFIG_CONTIG,
3471 : 1, nOvrBlockXSize, nOvrBlockYSize, TRUE,
3472 : COMPRESSION_NONE, PHOTOMETRIC_MASK, SAMPLEFORMAT_UINT, PREDICTOR_NONE,
3473 : NULL, NULL, NULL, 0, NULL,
3474 2 : "" );
3475 :
3476 2 : if( nOverviewOffset == 0 )
3477 : {
3478 0 : eErr = CE_Failure;
3479 0 : continue;
3480 : }
3481 :
3482 2 : poODS = new GTiffDataset();
3483 4 : if( poODS->OpenOffset( hTIFF, ppoActiveDSRef,
3484 : nOverviewOffset, FALSE,
3485 : GA_Update ) != CE_None )
3486 : {
3487 0 : delete poODS;
3488 0 : eErr = CE_Failure;
3489 : }
3490 : else
3491 : {
3492 2 : poODS->poBaseDS = this;
3493 2 : papoOverviewDS[i]->poMaskDS = poODS;
3494 2 : poMaskDS->nOverviewCount++;
3495 : poMaskDS->papoOverviewDS = (GTiffDataset **)
3496 : CPLRealloc(poMaskDS->papoOverviewDS,
3497 2 : poMaskDS->nOverviewCount * (sizeof(void*)));
3498 2 : poMaskDS->papoOverviewDS[poMaskDS->nOverviewCount-1] = poODS;
3499 : }
3500 : }
3501 : }
3502 : }
3503 :
3504 : /* -------------------------------------------------------------------- */
3505 : /* Refresh overviews for the mask */
3506 : /* -------------------------------------------------------------------- */
3507 59 : if (poMaskDS != NULL &&
3508 : poMaskDS->GetRasterCount() == 1)
3509 : {
3510 : GDALRasterBand **papoOverviewBands;
3511 5 : int nMaskOverviews = 0;
3512 :
3513 5 : papoOverviewBands = (GDALRasterBand **) CPLCalloc(sizeof(void*),nOverviewCount);
3514 15 : for( i = 0; i < nOverviewCount; i++ )
3515 : {
3516 10 : if (papoOverviewDS[i]->poMaskDS != NULL)
3517 : {
3518 : papoOverviewBands[nMaskOverviews ++] =
3519 8 : papoOverviewDS[i]->poMaskDS->GetRasterBand(1);
3520 : }
3521 : }
3522 : eErr = GDALRegenerateOverviews( (GDALRasterBandH)
3523 : poMaskDS->GetRasterBand(1),
3524 : nMaskOverviews,
3525 : (GDALRasterBandH *) papoOverviewBands,
3526 5 : pszResampling, GDALDummyProgress, NULL);
3527 5 : CPLFree(papoOverviewBands);
3528 : }
3529 :
3530 :
3531 : /* -------------------------------------------------------------------- */
3532 : /* Refresh old overviews that were listed. */
3533 : /* -------------------------------------------------------------------- */
3534 59 : if (nCompression != COMPRESSION_NONE &&
3535 : nPlanarConfig == PLANARCONFIG_CONTIG &&
3536 : GDALDataTypeIsComplex(GetRasterBand( panBandList[0] )->GetRasterDataType()) == FALSE &&
3537 : GetRasterBand( panBandList[0] )->GetColorTable() == NULL &&
3538 : (EQUALN(pszResampling, "NEAR", 4) || EQUAL(pszResampling, "AVERAGE") || EQUAL(pszResampling, "GAUSS")))
3539 : {
3540 : /* In the case of pixel interleaved compressed overviews, we want to generate */
3541 : /* the overviews for all the bands block by block, and not band after band, */
3542 : /* in order to write the block once and not loose space in the TIFF file */
3543 :
3544 : GDALRasterBand ***papapoOverviewBands;
3545 : GDALRasterBand **papoBandList;
3546 :
3547 8 : int nNewOverviews = 0;
3548 : int iBand;
3549 :
3550 8 : papapoOverviewBands = (GDALRasterBand ***) CPLCalloc(sizeof(void*),nBands);
3551 8 : papoBandList = (GDALRasterBand **) CPLCalloc(sizeof(void*),nBands);
3552 28 : for( iBand = 0; iBand < nBands; iBand++ )
3553 : {
3554 20 : GDALRasterBand* poBand = GetRasterBand( panBandList[iBand] );
3555 :
3556 20 : papoBandList[iBand] = poBand;
3557 20 : papapoOverviewBands[iBand] = (GDALRasterBand **) CPLCalloc(sizeof(void*), poBand->GetOverviewCount());
3558 :
3559 20 : int iCurOverview = 0;
3560 42 : for( i = 0; i < nOverviews; i++ )
3561 : {
3562 : int j;
3563 :
3564 24 : for( j = 0; j < poBand->GetOverviewCount(); j++ )
3565 : {
3566 : int nOvFactor;
3567 24 : GDALRasterBand * poOverview = poBand->GetOverview( j );
3568 :
3569 : nOvFactor = (int)
3570 24 : (0.5 + poBand->GetXSize() / (double) poOverview->GetXSize());
3571 :
3572 : int bHasNoData;
3573 24 : double noDataValue = poBand->GetNoDataValue(&bHasNoData);
3574 :
3575 24 : if (bHasNoData)
3576 18 : poOverview->SetNoDataValue(noDataValue);
3577 :
3578 24 : if( nOvFactor == panOverviewList[i]
3579 : || nOvFactor == TIFF_OvLevelAdjust( panOverviewList[i],
3580 : poBand->GetXSize() ) )
3581 : {
3582 22 : papapoOverviewBands[iBand][iCurOverview] = poOverview;
3583 22 : iCurOverview++ ;
3584 22 : break;
3585 : }
3586 : }
3587 : }
3588 :
3589 20 : if (nNewOverviews == 0)
3590 8 : nNewOverviews = iCurOverview;
3591 12 : else if (nNewOverviews != iCurOverview)
3592 : {
3593 0 : CPLAssert(0);
3594 59 : return CE_Failure;
3595 : }
3596 : }
3597 :
3598 : GDALRegenerateOverviewsMultiBand(nBands, papoBandList,
3599 : nNewOverviews, papapoOverviewBands,
3600 8 : pszResampling, pfnProgress, pProgressData );
3601 :
3602 28 : for( iBand = 0; iBand < nBands; iBand++ )
3603 : {
3604 20 : CPLFree(papapoOverviewBands[iBand]);
3605 : }
3606 8 : CPLFree(papapoOverviewBands);
3607 8 : CPLFree(papoBandList);
3608 : }
3609 : else
3610 : {
3611 : GDALRasterBand **papoOverviewBands;
3612 :
3613 : papoOverviewBands = (GDALRasterBand **)
3614 51 : CPLCalloc(sizeof(void*),nOverviews);
3615 :
3616 124 : for( int iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
3617 : {
3618 : GDALRasterBand *poBand;
3619 : int nNewOverviews;
3620 :
3621 73 : poBand = GetRasterBand( panBandList[iBand] );
3622 :
3623 73 : nNewOverviews = 0;
3624 184 : for( i = 0; i < nOverviews && poBand != NULL; i++ )
3625 : {
3626 : int j;
3627 :
3628 149 : for( j = 0; j < poBand->GetOverviewCount(); j++ )
3629 : {
3630 : int nOvFactor;
3631 149 : GDALRasterBand * poOverview = poBand->GetOverview( j );
3632 :
3633 : int bHasNoData;
3634 149 : double noDataValue = poBand->GetNoDataValue(&bHasNoData);
3635 :
3636 149 : if (bHasNoData)
3637 7 : poOverview->SetNoDataValue(noDataValue);
3638 :
3639 : nOvFactor = (int)
3640 149 : (0.5 + poBand->GetXSize() / (double) poOverview->GetXSize());
3641 :
3642 149 : if( nOvFactor == panOverviewList[i]
3643 : || nOvFactor == TIFF_OvLevelAdjust( panOverviewList[i],
3644 : poBand->GetXSize() ) )
3645 : {
3646 111 : papoOverviewBands[nNewOverviews++] = poOverview;
3647 111 : break;
3648 : }
3649 : }
3650 : }
3651 :
3652 : void *pScaledProgressData;
3653 :
3654 : pScaledProgressData =
3655 : GDALCreateScaledProgress( iBand / (double) nBands,
3656 : (iBand+1) / (double) nBands,
3657 73 : pfnProgress, pProgressData );
3658 :
3659 : eErr = GDALRegenerateOverviews( (GDALRasterBandH) poBand,
3660 : nNewOverviews,
3661 : (GDALRasterBandH *) papoOverviewBands,
3662 : pszResampling,
3663 : GDALScaledProgress,
3664 73 : pScaledProgressData);
3665 :
3666 73 : GDALDestroyScaledProgress( pScaledProgressData );
3667 : }
3668 :
3669 : /* -------------------------------------------------------------------- */
3670 : /* Cleanup */
3671 : /* -------------------------------------------------------------------- */
3672 51 : CPLFree( papoOverviewBands );
3673 : }
3674 :
3675 :
3676 59 : pfnProgress( 1.0, NULL, pProgressData );
3677 :
3678 59 : return eErr;
3679 : }
3680 :
3681 :
3682 : /************************************************************************/
3683 : /* WriteGeoTIFFInfo() */
3684 : /************************************************************************/
3685 :
3686 797 : void GTiffDataset::WriteGeoTIFFInfo()
3687 :
3688 : {
3689 : /* -------------------------------------------------------------------- */
3690 : /* If the geotransform is the default, don't bother writing it. */
3691 : /* -------------------------------------------------------------------- */
3692 1389 : if( adfGeoTransform[0] != 0.0 || adfGeoTransform[1] != 1.0
3693 : || adfGeoTransform[2] != 0.0 || adfGeoTransform[3] != 0.0
3694 : || adfGeoTransform[4] != 0.0 || ABS(adfGeoTransform[5]) != 1.0 )
3695 : {
3696 592 : bNeedsRewrite = TRUE;
3697 :
3698 : /* -------------------------------------------------------------------- */
3699 : /* Clear old tags to ensure we don't end up with conflicting */
3700 : /* information. (#2625) */
3701 : /* -------------------------------------------------------------------- */
3702 : #ifdef HAVE_UNSETFIELD
3703 592 : TIFFUnsetField( hTIFF, TIFFTAG_GEOPIXELSCALE );
3704 592 : TIFFUnsetField( hTIFF, TIFFTAG_GEOTIEPOINTS );
3705 592 : TIFFUnsetField( hTIFF, TIFFTAG_GEOTRANSMATRIX );
3706 : #endif
3707 :
3708 : /* -------------------------------------------------------------------- */
3709 : /* Write the transform. If we have a normal north-up image we */
3710 : /* use the tiepoint plus pixelscale otherwise we use a matrix. */
3711 : /* -------------------------------------------------------------------- */
3712 1181 : if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0
3713 : && adfGeoTransform[5] < 0.0 )
3714 : {
3715 : double adfPixelScale[3], adfTiePoints[6];
3716 :
3717 589 : adfPixelScale[0] = adfGeoTransform[1];
3718 589 : adfPixelScale[1] = fabs(adfGeoTransform[5]);
3719 589 : adfPixelScale[2] = 0.0;
3720 :
3721 589 : if( !EQUAL(osProfile,"BASELINE") )
3722 584 : TIFFSetField( hTIFF, TIFFTAG_GEOPIXELSCALE, 3, adfPixelScale );
3723 :
3724 589 : adfTiePoints[0] = 0.0;
3725 589 : adfTiePoints[1] = 0.0;
3726 589 : adfTiePoints[2] = 0.0;
3727 589 : adfTiePoints[3] = adfGeoTransform[0];
3728 589 : adfTiePoints[4] = adfGeoTransform[3];
3729 589 : adfTiePoints[5] = 0.0;
3730 :
3731 589 : if( !EQUAL(osProfile,"BASELINE") )
3732 584 : TIFFSetField( hTIFF, TIFFTAG_GEOTIEPOINTS, 6, adfTiePoints );
3733 : }
3734 : else
3735 : {
3736 : double adfMatrix[16];
3737 :
3738 3 : memset(adfMatrix,0,sizeof(double) * 16);
3739 :
3740 3 : adfMatrix[0] = adfGeoTransform[1];
3741 3 : adfMatrix[1] = adfGeoTransform[2];
3742 3 : adfMatrix[3] = adfGeoTransform[0];
3743 3 : adfMatrix[4] = adfGeoTransform[4];
3744 3 : adfMatrix[5] = adfGeoTransform[5];
3745 3 : adfMatrix[7] = adfGeoTransform[3];
3746 3 : adfMatrix[15] = 1.0;
3747 :
3748 3 : if( !EQUAL(osProfile,"BASELINE") )
3749 3 : TIFFSetField( hTIFF, TIFFTAG_GEOTRANSMATRIX, 16, adfMatrix );
3750 : }
3751 :
3752 : // Do we need a world file?
3753 592 : if( CSLFetchBoolean( papszCreationOptions, "TFW", FALSE ) )
3754 2 : GDALWriteWorldFile( osFilename, "tfw", adfGeoTransform );
3755 590 : else if( CSLFetchBoolean( papszCreationOptions, "WORLDFILE", FALSE ) )
3756 2 : GDALWriteWorldFile( osFilename, "wld", adfGeoTransform );
3757 : }
3758 205 : else if( GetGCPCount() > 0 )
3759 : {
3760 : double *padfTiePoints;
3761 : int iGCP;
3762 2 : bNeedsRewrite = TRUE;
3763 :
3764 : padfTiePoints = (double *)
3765 2 : CPLMalloc( 6 * sizeof(double) * GetGCPCount() );
3766 :
3767 14 : for( iGCP = 0; iGCP < GetGCPCount(); iGCP++ )
3768 : {
3769 :
3770 12 : padfTiePoints[iGCP*6+0] = pasGCPList[iGCP].dfGCPPixel;
3771 12 : padfTiePoints[iGCP*6+1] = pasGCPList[iGCP].dfGCPLine;
3772 12 : padfTiePoints[iGCP*6+2] = 0;
3773 12 : padfTiePoints[iGCP*6+3] = pasGCPList[iGCP].dfGCPX;
3774 12 : padfTiePoints[iGCP*6+4] = pasGCPList[iGCP].dfGCPY;
3775 12 : padfTiePoints[iGCP*6+5] = pasGCPList[iGCP].dfGCPZ;
3776 : }
3777 :
3778 2 : if( !EQUAL(osProfile,"BASELINE") )
3779 : TIFFSetField( hTIFF, TIFFTAG_GEOTIEPOINTS,
3780 2 : 6 * GetGCPCount(), padfTiePoints );
3781 2 : CPLFree( padfTiePoints );
3782 : }
3783 :
3784 : /* -------------------------------------------------------------------- */
3785 : /* Write out projection definition. */
3786 : /* -------------------------------------------------------------------- */
3787 797 : if( pszProjection != NULL && !EQUAL( pszProjection, "" )
3788 : && !EQUAL(osProfile,"BASELINE") )
3789 : {
3790 : GTIF *psGTIF;
3791 :
3792 596 : bNeedsRewrite = TRUE;
3793 :
3794 : // If we have existing geokeys, try to wipe them
3795 : // by writing a dummy goekey directory. (#2546)
3796 596 : uint16 *panVI = NULL;
3797 : uint16 nKeyCount;
3798 :
3799 596 : if( TIFFGetField( hTIFF, TIFFTAG_GEOKEYDIRECTORY,
3800 : &nKeyCount, &panVI ) )
3801 : {
3802 11 : GUInt16 anGKVersionInfo[4] = { 1, 1, 0, 0 };
3803 11 : double adfDummyDoubleParams[1] = { 0.0 };
3804 : TIFFSetField( hTIFF, TIFFTAG_GEOKEYDIRECTORY,
3805 11 : 4, anGKVersionInfo );
3806 : TIFFSetField( hTIFF, TIFFTAG_GEODOUBLEPARAMS,
3807 11 : 1, adfDummyDoubleParams );
3808 11 : TIFFSetField( hTIFF, TIFFTAG_GEOASCIIPARAMS, "" );
3809 : }
3810 :
3811 596 : psGTIF = GTIFNew( hTIFF );
3812 :
3813 : // set according to coordinate system.
3814 596 : GTIFSetFromOGISDefn( psGTIF, pszProjection );
3815 :
3816 596 : if( GetMetadataItem( GDALMD_AREA_OR_POINT )
3817 : && EQUAL(GetMetadataItem(GDALMD_AREA_OR_POINT),
3818 : GDALMD_AOP_POINT) )
3819 : {
3820 : GTIFKeySet(psGTIF, GTRasterTypeGeoKey, TYPE_SHORT, 1,
3821 4 : RasterPixelIsPoint);
3822 : }
3823 :
3824 596 : GTIFWriteKeys( psGTIF );
3825 596 : GTIFFree( psGTIF );
3826 : }
3827 797 : }
3828 :
3829 : /************************************************************************/
3830 : /* AppendMetadataItem() */
3831 : /************************************************************************/
3832 :
3833 : static void AppendMetadataItem( CPLXMLNode **ppsRoot, CPLXMLNode **ppsTail,
3834 : const char *pszKey, const char *pszValue,
3835 : int nBand, const char *pszRole,
3836 184 : const char *pszDomain )
3837 :
3838 : {
3839 : char szBandId[32];
3840 : CPLXMLNode *psItem;
3841 :
3842 : /* -------------------------------------------------------------------- */
3843 : /* Create the Item element, and subcomponents. */
3844 : /* -------------------------------------------------------------------- */
3845 184 : psItem = CPLCreateXMLNode( NULL, CXT_Element, "Item" );
3846 : CPLCreateXMLNode( CPLCreateXMLNode( psItem, CXT_Attribute, "name"),
3847 184 : CXT_Text, pszKey );
3848 :
3849 184 : if( nBand > 0 )
3850 : {
3851 39 : sprintf( szBandId, "%d", nBand - 1 );
3852 : CPLCreateXMLNode( CPLCreateXMLNode( psItem,CXT_Attribute,"sample"),
3853 39 : CXT_Text, szBandId );
3854 : }
3855 :
3856 184 : if( pszRole != NULL )
3857 : CPLCreateXMLNode( CPLCreateXMLNode( psItem,CXT_Attribute,"role"),
3858 9 : CXT_Text, pszRole );
3859 :
3860 184 : if( pszDomain != NULL && strlen(pszDomain) > 0 )
3861 : CPLCreateXMLNode( CPLCreateXMLNode( psItem,CXT_Attribute,"domain"),
3862 1 : CXT_Text, pszDomain );
3863 :
3864 184 : char *pszEscapedItemValue = CPLEscapeString(pszValue,-1,CPLES_XML);
3865 184 : CPLCreateXMLNode( psItem, CXT_Text, pszEscapedItemValue );
3866 184 : CPLFree( pszEscapedItemValue );
3867 :
3868 : /* -------------------------------------------------------------------- */
3869 : /* Create root, if missing. */
3870 : /* -------------------------------------------------------------------- */
3871 184 : if( *ppsRoot == NULL )
3872 54 : *ppsRoot = CPLCreateXMLNode( NULL, CXT_Element, "GDALMetadata" );
3873 :
3874 : /* -------------------------------------------------------------------- */
3875 : /* Append item to tail. We keep track of the tail to avoid */
3876 : /* O(nsquared) time as the list gets longer. */
3877 : /* -------------------------------------------------------------------- */
3878 184 : if( *ppsTail == NULL )
3879 54 : CPLAddXMLChild( *ppsRoot, psItem );
3880 : else
3881 130 : CPLAddXMLSibling( *ppsTail, psItem );
3882 :
3883 184 : *ppsTail = psItem;
3884 184 : }
3885 :
3886 : /************************************************************************/
3887 : /* WriteMDMDMetadata() */
3888 : /************************************************************************/
3889 :
3890 : static void WriteMDMetadata( GDALMultiDomainMetadata *poMDMD, TIFF *hTIFF,
3891 : CPLXMLNode **ppsRoot, CPLXMLNode **ppsTail,
3892 132971 : int nBand, const char *pszProfile )
3893 :
3894 : {
3895 : int iDomain;
3896 : char **papszDomainList;
3897 :
3898 : (void) pszProfile;
3899 :
3900 : /* ==================================================================== */
3901 : /* Process each domain. */
3902 : /* ==================================================================== */
3903 132971 : papszDomainList = poMDMD->GetDomainList();
3904 133166 : for( iDomain = 0; papszDomainList && papszDomainList[iDomain]; iDomain++ )
3905 : {
3906 195 : char **papszMD = poMDMD->GetMetadata( papszDomainList[iDomain] );
3907 : int iItem;
3908 195 : int bIsXML = FALSE;
3909 :
3910 195 : if( EQUAL(papszDomainList[iDomain], "IMAGE_STRUCTURE") )
3911 42 : continue; // ignored
3912 153 : if( EQUAL(papszDomainList[iDomain], "RPC") )
3913 0 : continue; // handled elsewhere
3914 153 : if( EQUALN(papszDomainList[iDomain], "xml:",4 ) )
3915 1 : bIsXML = TRUE;
3916 :
3917 : /* -------------------------------------------------------------------- */
3918 : /* Process each item in this domain. */
3919 : /* -------------------------------------------------------------------- */
3920 428 : for( iItem = 0; papszMD && papszMD[iItem]; iItem++ )
3921 : {
3922 : const char *pszItemValue;
3923 275 : char *pszItemName = NULL;
3924 :
3925 275 : if( bIsXML )
3926 : {
3927 1 : pszItemName = CPLStrdup("doc");
3928 1 : pszItemValue = papszMD[iItem];
3929 : }
3930 : else
3931 : {
3932 274 : pszItemValue = CPLParseNameValue( papszMD[iItem], &pszItemName);
3933 : }
3934 :
3935 : /* -------------------------------------------------------------------- */
3936 : /* Convert into XML item or handle as a special TIFF tag. */
3937 : /* -------------------------------------------------------------------- */
3938 304 : if( strlen(papszDomainList[iDomain]) == 0
3939 : && nBand == 0 && EQUALN(pszItemName,"TIFFTAG_",8) )
3940 : {
3941 29 : if( EQUAL(pszItemName,"TIFFTAG_DOCUMENTNAME") )
3942 4 : TIFFSetField( hTIFF, TIFFTAG_DOCUMENTNAME, pszItemValue );
3943 25 : else if( EQUAL(pszItemName,"TIFFTAG_IMAGEDESCRIPTION") )
3944 1 : TIFFSetField( hTIFF, TIFFTAG_IMAGEDESCRIPTION, pszItemValue );
3945 24 : else if( EQUAL(pszItemName,"TIFFTAG_SOFTWARE") )
3946 2 : TIFFSetField( hTIFF, TIFFTAG_SOFTWARE, pszItemValue );
3947 22 : else if( EQUAL(pszItemName,"TIFFTAG_DATETIME") )
3948 1 : TIFFSetField( hTIFF, TIFFTAG_DATETIME, pszItemValue );
3949 21 : else if( EQUAL(pszItemName,"TIFFTAG_ARTIST") )
3950 1 : TIFFSetField( hTIFF, TIFFTAG_ARTIST, pszItemValue );
3951 20 : else if( EQUAL(pszItemName,"TIFFTAG_HOSTCOMPUTER") )
3952 1 : TIFFSetField( hTIFF, TIFFTAG_HOSTCOMPUTER, pszItemValue );
3953 19 : else if( EQUAL(pszItemName,"TIFFTAG_COPYRIGHT") )
3954 1 : TIFFSetField( hTIFF, TIFFTAG_COPYRIGHT, pszItemValue );
3955 18 : else if( EQUAL(pszItemName,"TIFFTAG_XRESOLUTION") )
3956 6 : TIFFSetField( hTIFF, TIFFTAG_XRESOLUTION, atof(pszItemValue) );
3957 12 : else if( EQUAL(pszItemName,"TIFFTAG_YRESOLUTION") )
3958 6 : TIFFSetField( hTIFF, TIFFTAG_YRESOLUTION, atof(pszItemValue) );
3959 6 : else if( EQUAL(pszItemName,"TIFFTAG_RESOLUTIONUNIT") )
3960 6 : TIFFSetField( hTIFF, TIFFTAG_RESOLUTIONUNIT, atoi(pszItemValue) );
3961 : else
3962 : CPLError(CE_Warning, CPLE_NotSupported,
3963 : "%s metadata item is unhandled and will not be written",
3964 0 : pszItemName);
3965 : }
3966 246 : else if( nBand == 0 && EQUAL(pszItemName,GDALMD_AREA_OR_POINT) )
3967 : /* do nothing, handled elsewhere */;
3968 : else
3969 : AppendMetadataItem( ppsRoot, ppsTail,
3970 : pszItemName, pszItemValue,
3971 175 : nBand, NULL, papszDomainList[iDomain] );
3972 :
3973 275 : CPLFree( pszItemName );
3974 : }
3975 : }
3976 132971 : }
3977 :
3978 : /************************************************************************/
3979 : /* WriteMetadata() */
3980 : /************************************************************************/
3981 :
3982 : int GTiffDataset::WriteMetadata( GDALDataset *poSrcDS, TIFF *hTIFF,
3983 : int bSrcIsGeoTIFF,
3984 : const char *pszProfile,
3985 : const char *pszTIFFFilename,
3986 : char **papszCreationOptions,
3987 954 : int bExcludeRPBandIMGFileWriting)
3988 :
3989 : {
3990 : /* -------------------------------------------------------------------- */
3991 : /* Convert all the remaining metadata into a simple XML */
3992 : /* format. */
3993 : /* -------------------------------------------------------------------- */
3994 954 : CPLXMLNode *psRoot = NULL, *psTail = NULL;
3995 :
3996 954 : if( bSrcIsGeoTIFF )
3997 : {
3998 : WriteMDMetadata( &(((GTiffDataset *)poSrcDS)->oGTiffMDMD),
3999 797 : hTIFF, &psRoot, &psTail, 0, pszProfile );
4000 : }
4001 : else
4002 : {
4003 157 : char **papszMD = poSrcDS->GetMetadata();
4004 :
4005 157 : if( CSLCount(papszMD) > 0 )
4006 : {
4007 86 : GDALMultiDomainMetadata oMDMD;
4008 86 : oMDMD.SetMetadata( papszMD );
4009 :
4010 86 : WriteMDMetadata( &oMDMD, hTIFF, &psRoot, &psTail, 0, pszProfile );
4011 : }
4012 : }
4013 :
4014 : /* -------------------------------------------------------------------- */
4015 : /* Handle RPC data written to an RPB file. */
4016 : /* -------------------------------------------------------------------- */
4017 954 : char **papszRPCMD = poSrcDS->GetMetadata("RPC");
4018 954 : if( papszRPCMD != NULL && !bExcludeRPBandIMGFileWriting )
4019 : {
4020 2 : if( EQUAL(pszProfile,"GDALGeoTIFF") )
4021 1 : WriteRPCTag( hTIFF, papszRPCMD );
4022 :
4023 2 : if( !EQUAL(pszProfile,"GDALGeoTIFF")
4024 : || CSLFetchBoolean( papszCreationOptions, "RPB", FALSE ) )
4025 : {
4026 1 : GDALWriteRPBFile( pszTIFFFilename, papszRPCMD );
4027 : }
4028 : }
4029 :
4030 : /* -------------------------------------------------------------------- */
4031 : /* Handle metadata data written to an IMD file. */
4032 : /* -------------------------------------------------------------------- */
4033 954 : char **papszIMDMD = poSrcDS->GetMetadata("IMD");
4034 954 : if( papszIMDMD != NULL && !bExcludeRPBandIMGFileWriting)
4035 : {
4036 2 : GDALWriteIMDFile( pszTIFFFilename, papszIMDMD );
4037 : }
4038 :
4039 : /* -------------------------------------------------------------------- */
4040 : /* We also need to address band specific metadata, and special */
4041 : /* "role" metadata. */
4042 : /* -------------------------------------------------------------------- */
4043 : int nBand;
4044 133267 : for( nBand = 1; nBand <= poSrcDS->GetRasterCount(); nBand++ )
4045 : {
4046 132313 : GDALRasterBand *poBand = poSrcDS->GetRasterBand( nBand );
4047 :
4048 132313 : if( bSrcIsGeoTIFF )
4049 : {
4050 : WriteMDMetadata( &(((GTiffRasterBand *)poBand)->oGTiffMDMD),
4051 132062 : hTIFF, &psRoot, &psTail, nBand, pszProfile );
4052 : }
4053 : else
4054 : {
4055 251 : char **papszMD = poBand->GetMetadata();
4056 :
4057 251 : if( CSLCount(papszMD) > 0 )
4058 : {
4059 26 : GDALMultiDomainMetadata oMDMD;
4060 26 : oMDMD.SetMetadata( papszMD );
4061 :
4062 : WriteMDMetadata( &oMDMD, hTIFF, &psRoot, &psTail, nBand,
4063 26 : pszProfile );
4064 : }
4065 : }
4066 :
4067 : int bSuccess;
4068 132313 : double dfOffset = poBand->GetOffset( &bSuccess );
4069 132313 : double dfScale = poBand->GetScale();
4070 :
4071 132313 : if( bSuccess && (dfOffset != 0.0 || dfScale != 1.0) )
4072 : {
4073 : char szValue[128];
4074 :
4075 2 : sprintf( szValue, "%.18g", dfOffset );
4076 : AppendMetadataItem( &psRoot, &psTail, "OFFSET", szValue, nBand,
4077 2 : "offset", "" );
4078 2 : sprintf( szValue, "%.18g", dfScale );
4079 : AppendMetadataItem( &psRoot, &psTail, "SCALE", szValue, nBand,
4080 2 : "scale", "" );
4081 : }
4082 :
4083 132313 : const char* pszUnitType = poBand->GetUnitType();
4084 132313 : if (pszUnitType != NULL && pszUnitType[0] != '\0')
4085 : AppendMetadataItem( &psRoot, &psTail, "UNITTYPE", pszUnitType, nBand,
4086 5 : "unittype", "" );
4087 : }
4088 :
4089 : /* -------------------------------------------------------------------- */
4090 : /* Write out the generic XML metadata if there is any. */
4091 : /* -------------------------------------------------------------------- */
4092 954 : if( psRoot != NULL )
4093 : {
4094 54 : int bRet = TRUE;
4095 :
4096 54 : if( EQUAL(pszProfile,"GDALGeoTIFF") )
4097 : {
4098 44 : char *pszXML_MD = CPLSerializeXMLTree( psRoot );
4099 44 : if( strlen(pszXML_MD) > 32000 )
4100 : {
4101 1 : if( bSrcIsGeoTIFF )
4102 1 : ((GTiffDataset *) poSrcDS)->PushMetadataToPam();
4103 : else
4104 0 : bRet = FALSE;
4105 : CPLError( CE_Warning, CPLE_AppDefined,
4106 1 : "Lost metadata writing to GeoTIFF ... too large to fit in tag." );
4107 : }
4108 : else
4109 : {
4110 43 : TIFFSetField( hTIFF, TIFFTAG_GDAL_METADATA, pszXML_MD );
4111 : }
4112 44 : CPLFree( pszXML_MD );
4113 : }
4114 : else
4115 : {
4116 10 : if( bSrcIsGeoTIFF )
4117 6 : ((GTiffDataset *) poSrcDS)->PushMetadataToPam();
4118 : else
4119 4 : bRet = FALSE;
4120 : }
4121 :
4122 54 : CPLDestroyXMLNode( psRoot );
4123 :
4124 54 : return bRet;
4125 : }
4126 : else
4127 : {
4128 : /* If we have no more metadata but it existed before, remove the GDAL_METADATA tag */
4129 900 : if( EQUAL(pszProfile,"GDALGeoTIFF") )
4130 : {
4131 895 : char* pszText = NULL;
4132 895 : if( TIFFGetField( hTIFF, TIFFTAG_GDAL_METADATA, &pszText ) )
4133 : {
4134 : #ifdef HAVE_UNSETFIELD
4135 2 : TIFFUnsetField( hTIFF, TIFFTAG_GDAL_METADATA );
4136 : #else
4137 : TIFFSetField( hTIFF, TIFFTAG_GDAL_METADATA, "" );
4138 : #endif
4139 : }
4140 : }
4141 : }
4142 :
4143 900 : return TRUE;
4144 : }
4145 :
4146 : /************************************************************************/
4147 : /* PushMetadataToPam() */
4148 : /* */
4149 : /* When producing a strict profile TIFF or if our aggregate */
4150 : /* metadata is too big for a single tiff tag we may end up */
4151 : /* needing to write it via the PAM mechanisms. This method */
4152 : /* copies all the appropriate metadata into the PAM level */
4153 : /* metadata object but with special care to avoid copying */
4154 : /* metadata handled in other ways in TIFF format. */
4155 : /************************************************************************/
4156 :
4157 33 : void GTiffDataset::PushMetadataToPam()
4158 :
4159 : {
4160 : int nBand;
4161 111 : for( nBand = 0; nBand <= GetRasterCount(); nBand++ )
4162 : {
4163 : GDALMultiDomainMetadata *poSrcMDMD;
4164 78 : GTiffRasterBand *poBand = NULL;
4165 :
4166 78 : if( nBand == 0 )
4167 33 : poSrcMDMD = &(this->oGTiffMDMD);
4168 : else
4169 : {
4170 45 : poBand = (GTiffRasterBand *) GetRasterBand(nBand);
4171 45 : poSrcMDMD = &(poBand->oGTiffMDMD);
4172 : }
4173 :
4174 : /* -------------------------------------------------------------------- */
4175 : /* Loop over the available domains. */
4176 : /* -------------------------------------------------------------------- */
4177 : int iDomain, i;
4178 : char **papszDomainList;
4179 :
4180 78 : papszDomainList = poSrcMDMD->GetDomainList();
4181 171 : for( iDomain = 0;
4182 : papszDomainList && papszDomainList[iDomain];
4183 : iDomain++ )
4184 : {
4185 93 : char **papszMD = poSrcMDMD->GetMetadata( papszDomainList[iDomain] );
4186 :
4187 93 : if( EQUAL(papszDomainList[iDomain],"RPC")
4188 : || EQUAL(papszDomainList[iDomain],"IMD")
4189 : || EQUAL(papszDomainList[iDomain],"_temporary_")
4190 : || EQUAL(papszDomainList[iDomain],"IMAGE_STRUCTURE") )
4191 36 : continue;
4192 :
4193 57 : papszMD = CSLDuplicate(papszMD);
4194 :
4195 197 : for( i = CSLCount(papszMD)-1; i >= 0; i-- )
4196 : {
4197 140 : if( EQUALN(papszMD[i],"TIFFTAG_",8)
4198 : || EQUALN(papszMD[i],GDALMD_AREA_OR_POINT,
4199 : strlen(GDALMD_AREA_OR_POINT)) )
4200 25 : papszMD = CSLRemoveStrings( papszMD, i, 1, NULL );
4201 : }
4202 :
4203 57 : if( nBand == 0 )
4204 25 : GDALPamDataset::SetMetadata( papszMD, papszDomainList[iDomain]);
4205 : else
4206 32 : poBand->GDALPamRasterBand::SetMetadata( papszMD, papszDomainList[iDomain]);
4207 :
4208 57 : CSLDestroy( papszMD );
4209 : }
4210 :
4211 : /* -------------------------------------------------------------------- */
4212 : /* Handle some "special domain" stuff. */
4213 : /* -------------------------------------------------------------------- */
4214 78 : if( poBand != NULL )
4215 : {
4216 : int bSuccess;
4217 45 : double dfOffset = poBand->GetOffset( &bSuccess );
4218 45 : double dfScale = poBand->GetScale();
4219 :
4220 45 : if( bSuccess )
4221 : {
4222 42 : poBand->GDALPamRasterBand::SetScale( dfScale );
4223 42 : poBand->GDALPamRasterBand::SetOffset( dfOffset );
4224 : }
4225 :
4226 45 : poBand->GDALPamRasterBand::SetUnitType( poBand->GetUnitType() );
4227 : }
4228 : }
4229 33 : }
4230 :
4231 : /************************************************************************/
4232 : /* WriteRPCTag() */
4233 : /* */
4234 : /* Format a TAG according to: */
4235 : /* */
4236 : /* http://geotiff.maptools.org/rpc_prop.html */
4237 : /************************************************************************/
4238 :
4239 : /* static */
4240 1 : void GTiffDataset::WriteRPCTag( TIFF *hTIFF, char **papszRPCMD )
4241 :
4242 : {
4243 : double adfRPCTag[92];
4244 : GDALRPCInfo sRPC;
4245 :
4246 1 : if( !GDALExtractRPCInfo( papszRPCMD, &sRPC ) )
4247 0 : return;
4248 :
4249 1 : adfRPCTag[0] = -1.0; // Error Bias
4250 1 : adfRPCTag[1] = -1.0; // Error Random
4251 :
4252 1 : adfRPCTag[2] = sRPC.dfLINE_OFF;
4253 1 : adfRPCTag[3] = sRPC.dfSAMP_OFF;
4254 1 : adfRPCTag[4] = sRPC.dfLAT_OFF;
4255 1 : adfRPCTag[5] = sRPC.dfLONG_OFF;
4256 1 : adfRPCTag[6] = sRPC.dfHEIGHT_OFF;
4257 1 : adfRPCTag[7] = sRPC.dfLINE_SCALE;
4258 1 : adfRPCTag[8] = sRPC.dfSAMP_SCALE;
4259 1 : adfRPCTag[9] = sRPC.dfLAT_SCALE;
4260 1 : adfRPCTag[10] = sRPC.dfLONG_SCALE;
4261 1 : adfRPCTag[11] = sRPC.dfHEIGHT_SCALE;
4262 :
4263 1 : memcpy( adfRPCTag + 12, sRPC.adfLINE_NUM_COEFF, sizeof(double) * 20 );
4264 1 : memcpy( adfRPCTag + 32, sRPC.adfLINE_DEN_COEFF, sizeof(double) * 20 );
4265 1 : memcpy( adfRPCTag + 52, sRPC.adfSAMP_NUM_COEFF, sizeof(double) * 20 );
4266 1 : memcpy( adfRPCTag + 72, sRPC.adfSAMP_DEN_COEFF, sizeof(double) * 20 );
4267 :
4268 1 : TIFFSetField( hTIFF, TIFFTAG_RPCCOEFFICIENT, 92, adfRPCTag );
4269 : }
4270 :
4271 : /************************************************************************/
4272 : /* ReadRPCTag() */
4273 : /* */
4274 : /* Format a TAG according to: */
4275 : /* */
4276 : /* http://geotiff.maptools.org/rpc_prop.html */
4277 : /************************************************************************/
4278 :
4279 3485 : void GTiffDataset::ReadRPCTag()
4280 :
4281 : {
4282 : double *padfRPCTag;
4283 3485 : char **papszMD = NULL;
4284 3485 : CPLString osField;
4285 3485 : CPLString osMultiField;
4286 : int i;
4287 : uint16 nCount;
4288 :
4289 3485 : if( !TIFFGetField( hTIFF, TIFFTAG_RPCCOEFFICIENT, &nCount, &padfRPCTag )
4290 : || nCount != 92 )
4291 3482 : return;
4292 :
4293 3 : osField.Printf( "%.15g", padfRPCTag[2] );
4294 3 : papszMD = CSLSetNameValue( papszMD, "LINE_OFF", osField );
4295 :
4296 3 : osField.Printf( "%.15g", padfRPCTag[3] );
4297 3 : papszMD = CSLSetNameValue( papszMD, "SAMP_OFF", osField );
4298 :
4299 3 : osField.Printf( "%.15g", padfRPCTag[4] );
4300 3 : papszMD = CSLSetNameValue( papszMD, "LAT_OFF", osField );
4301 :
4302 3 : osField.Printf( "%.15g", padfRPCTag[5] );
4303 3 : papszMD = CSLSetNameValue( papszMD, "LONG_OFF", osField );
4304 :
4305 3 : osField.Printf( "%.15g", padfRPCTag[6] );
4306 3 : papszMD = CSLSetNameValue( papszMD, "HEIGHT_OFF", osField );
4307 :
4308 3 : osField.Printf( "%.15g", padfRPCTag[7] );
4309 3 : papszMD = CSLSetNameValue( papszMD, "LINE_SCALE", osField );
4310 :
4311 3 : osField.Printf( "%.15g", padfRPCTag[8] );
4312 3 : papszMD = CSLSetNameValue( papszMD, "SAMP_SCALE", osField );
4313 :
4314 3 : osField.Printf( "%.15g", padfRPCTag[9] );
4315 3 : papszMD = CSLSetNameValue( papszMD, "LAT_SCALE", osField );
4316 :
4317 3 : osField.Printf( "%.15g", padfRPCTag[10] );
4318 3 : papszMD = CSLSetNameValue( papszMD, "LONG_SCALE", osField );
4319 :
4320 3 : osField.Printf( "%.15g", padfRPCTag[11] );
4321 3 : papszMD = CSLSetNameValue( papszMD, "HEIGHT_SCALE", osField );
4322 :
4323 63 : for( i = 0; i < 20; i++ )
4324 : {
4325 60 : osField.Printf( "%.15g", padfRPCTag[12+i] );
4326 60 : if( i > 0 )
4327 57 : osMultiField += " ";
4328 : else
4329 3 : osMultiField = "";
4330 60 : osMultiField += osField;
4331 : }
4332 3 : papszMD = CSLSetNameValue( papszMD, "LINE_NUM_COEFF", osMultiField );
4333 :
4334 63 : for( i = 0; i < 20; i++ )
4335 : {
4336 60 : osField.Printf( "%.15g", padfRPCTag[32+i] );
4337 60 : if( i > 0 )
4338 57 : osMultiField += " ";
4339 : else
4340 3 : osMultiField = "";
4341 60 : osMultiField += osField;
4342 : }
4343 3 : papszMD = CSLSetNameValue( papszMD, "LINE_DEN_COEFF", osMultiField );
4344 :
4345 63 : for( i = 0; i < 20; i++ )
4346 : {
4347 60 : osField.Printf( "%.15g", padfRPCTag[52+i] );
4348 60 : if( i > 0 )
4349 57 : osMultiField += " ";
4350 : else
4351 3 : osMultiField = "";
4352 60 : osMultiField += osField;
4353 : }
4354 3 : papszMD = CSLSetNameValue( papszMD, "SAMP_NUM_COEFF", osMultiField );
4355 :
4356 63 : for( i = 0; i < 20; i++ )
4357 : {
4358 60 : osField.Printf( "%.15g", padfRPCTag[72+i] );
4359 60 : if( i > 0 )
4360 57 : osMultiField += " ";
4361 : else
4362 3 : osMultiField = "";
4363 60 : osMultiField += osField;
4364 : }
4365 3 : papszMD = CSLSetNameValue( papszMD, "SAMP_DEN_COEFF", osMultiField );
4366 :
4367 3 : oGTiffMDMD.SetMetadata( papszMD, "RPC" );
4368 3 : CSLDestroy( papszMD );
4369 : }
4370 :
4371 : /************************************************************************/
4372 : /* WriteNoDataValue() */
4373 : /************************************************************************/
4374 :
4375 68 : void GTiffDataset::WriteNoDataValue( TIFF *hTIFF, double dfNoData )
4376 :
4377 : {
4378 : char szVal[400];
4379 68 : if (CPLIsNan(dfNoData))
4380 1 : strcpy(szVal, "nan");
4381 : else
4382 67 : snprintf(szVal, sizeof(szVal), "%.18g", dfNoData);
4383 68 : TIFFSetField( hTIFF, TIFFTAG_GDAL_NODATA, szVal );
4384 68 : }
4385 :
4386 : /************************************************************************/
4387 : /* SetDirectory() */
4388 : /************************************************************************/
4389 :
4390 194986 : int GTiffDataset::SetDirectory( toff_t nNewOffset )
4391 :
4392 : {
4393 194986 : Crystalize();
4394 :
4395 194986 : FlushBlockBuf();
4396 :
4397 194986 : if( nNewOffset == 0 )
4398 191130 : nNewOffset = nDirOffset;
4399 :
4400 194986 : if( TIFFCurrentDirOffset(hTIFF) == nNewOffset )
4401 : {
4402 193902 : CPLAssert( *ppoActiveDSRef == this || *ppoActiveDSRef == NULL );
4403 193902 : *ppoActiveDSRef = this;
4404 193902 : return TRUE;
4405 : }
4406 :
4407 1084 : int jquality = -1, zquality = -1;
4408 :
4409 1084 : if( GetAccess() == GA_Update )
4410 : {
4411 766 : TIFFGetField(hTIFF, TIFFTAG_JPEGQUALITY, &jquality);
4412 766 : TIFFGetField(hTIFF, TIFFTAG_ZIPQUALITY, &zquality);
4413 :
4414 766 : if( *ppoActiveDSRef != NULL )
4415 691 : (*ppoActiveDSRef)->FlushDirectory();
4416 : }
4417 :
4418 1084 : if( nNewOffset == 0)
4419 0 : return TRUE;
4420 :
4421 1084 : (*ppoActiveDSRef) = this;
4422 :
4423 1084 : int nSetDirResult = TIFFSetSubDirectory( hTIFF, nNewOffset );
4424 1084 : if (!nSetDirResult)
4425 0 : return nSetDirResult;
4426 :
4427 : /* -------------------------------------------------------------------- */
4428 : /* YCbCr JPEG compressed images should be translated on the fly */
4429 : /* to RGB by libtiff/libjpeg unless specifically requested */
4430 : /* otherwise. */
4431 : /* -------------------------------------------------------------------- */
4432 1084 : if( !TIFFGetField( hTIFF, TIFFTAG_COMPRESSION, &(nCompression) ) )
4433 0 : nCompression = COMPRESSION_NONE;
4434 :
4435 1084 : if( !TIFFGetField( hTIFF, TIFFTAG_PHOTOMETRIC, &(nPhotometric) ) )
4436 0 : nPhotometric = PHOTOMETRIC_MINISBLACK;
4437 :
4438 1084 : if( nCompression == COMPRESSION_JPEG
4439 : && nPhotometric == PHOTOMETRIC_YCBCR
4440 : && CSLTestBoolean( CPLGetConfigOption("CONVERT_YCBCR_TO_RGB",
4441 : "YES") ) )
4442 : {
4443 : int nColorMode;
4444 :
4445 18 : TIFFGetField( hTIFF, TIFFTAG_JPEGCOLORMODE, &nColorMode );
4446 18 : if( nColorMode != JPEGCOLORMODE_RGB )
4447 18 : TIFFSetField(hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
4448 : }
4449 :
4450 : /* -------------------------------------------------------------------- */
4451 : /* Propogate any quality settings. */
4452 : /* -------------------------------------------------------------------- */
4453 1084 : if( GetAccess() == GA_Update )
4454 : {
4455 : // Now, reset zip and jpeg quality.
4456 766 : if(jquality > 0)
4457 : {
4458 : CPLDebug( "GTiff", "Propgate JPEG_QUALITY(%d) in SetDirectory()",
4459 4 : jquality );
4460 4 : TIFFSetField(hTIFF, TIFFTAG_JPEGQUALITY, jquality);
4461 : }
4462 766 : if(zquality > 0)
4463 0 : TIFFSetField(hTIFF, TIFFTAG_ZIPQUALITY, zquality);
4464 : }
4465 :
4466 1084 : return nSetDirResult;
4467 : }
4468 :
4469 : /************************************************************************/
4470 : /* Identify() */
4471 : /************************************************************************/
4472 :
4473 15799 : int GTiffDataset::Identify( GDALOpenInfo * poOpenInfo )
4474 :
4475 : {
4476 15799 : const char *pszFilename = poOpenInfo->pszFilename;
4477 15799 : if( EQUALN(pszFilename,"GTIFF_RAW:", strlen("GTIFF_RAW:")) )
4478 : {
4479 162 : pszFilename += strlen("GTIFF_RAW:");
4480 162 : GDALOpenInfo oOpenInfo( pszFilename, poOpenInfo->eAccess );
4481 162 : return Identify(&oOpenInfo);
4482 : }
4483 :
4484 : /* -------------------------------------------------------------------- */
4485 : /* We have a special hook for handling opening a specific */
4486 : /* directory of a TIFF file. */
4487 : /* -------------------------------------------------------------------- */
4488 15637 : if( EQUALN(pszFilename,"GTIFF_DIR:",strlen("GTIFF_DIR:")) )
4489 4 : return TRUE;
4490 :
4491 : /* -------------------------------------------------------------------- */
4492 : /* First we check to see if the file has the expected header */
4493 : /* bytes. */
4494 : /* -------------------------------------------------------------------- */
4495 15633 : if( poOpenInfo->nHeaderBytes < 2 )
4496 9690 : return FALSE;
4497 :
4498 5943 : if( (poOpenInfo->pabyHeader[0] != 'I' || poOpenInfo->pabyHeader[1] != 'I')
4499 : && (poOpenInfo->pabyHeader[0] != 'M' || poOpenInfo->pabyHeader[1] != 'M'))
4500 2425 : return FALSE;
4501 :
4502 : #ifndef BIGTIFF_SUPPORT
4503 : if( (poOpenInfo->pabyHeader[2] == 0x2B && poOpenInfo->pabyHeader[3] == 0) ||
4504 : (poOpenInfo->pabyHeader[2] == 0 && poOpenInfo->pabyHeader[3] == 0x2B) )
4505 : {
4506 : CPLError( CE_Failure, CPLE_OpenFailed,
4507 : "This is a BigTIFF file. BigTIFF is not supported by this\n"
4508 : "version of GDAL and libtiff." );
4509 : return FALSE;
4510 : }
4511 : #endif
4512 :
4513 3518 : if( (poOpenInfo->pabyHeader[2] != 0x2A || poOpenInfo->pabyHeader[3] != 0)
4514 : && (poOpenInfo->pabyHeader[3] != 0x2A || poOpenInfo->pabyHeader[2] != 0)
4515 : && (poOpenInfo->pabyHeader[2] != 0x2B || poOpenInfo->pabyHeader[3] != 0)
4516 : && (poOpenInfo->pabyHeader[3] != 0x2B || poOpenInfo->pabyHeader[2] != 0))
4517 0 : return FALSE;
4518 :
4519 3518 : return TRUE;
4520 : }
4521 :
4522 : /************************************************************************/
4523 : /* Open() */
4524 : /************************************************************************/
4525 :
4526 7277 : GDALDataset *GTiffDataset::Open( GDALOpenInfo * poOpenInfo )
4527 :
4528 : {
4529 : TIFF *hTIFF;
4530 7277 : int bAllowRGBAInterface = TRUE;
4531 7277 : const char *pszFilename = poOpenInfo->pszFilename;
4532 :
4533 : /* -------------------------------------------------------------------- */
4534 : /* Check if it looks like a TIFF file. */
4535 : /* -------------------------------------------------------------------- */
4536 7277 : if (!Identify(poOpenInfo))
4537 3785 : return NULL;
4538 :
4539 3492 : if( EQUALN(pszFilename,"GTIFF_RAW:", strlen("GTIFF_RAW:")) )
4540 : {
4541 162 : bAllowRGBAInterface = FALSE;
4542 162 : pszFilename += strlen("GTIFF_RAW:");
4543 : }
4544 :
4545 : /* -------------------------------------------------------------------- */
4546 : /* We have a special hook for handling opening a specific */
4547 : /* directory of a TIFF file. */
4548 : /* -------------------------------------------------------------------- */
4549 3492 : if( EQUALN(pszFilename,"GTIFF_DIR:",strlen("GTIFF_DIR:")) )
4550 4 : return OpenDir( poOpenInfo );
4551 :
4552 3488 : GTiffOneTimeInit();
4553 :
4554 : /* -------------------------------------------------------------------- */
4555 : /* Try opening the dataset. */
4556 : /* -------------------------------------------------------------------- */
4557 3488 : if( poOpenInfo->eAccess == GA_ReadOnly )
4558 3124 : hTIFF = VSI_TIFFOpen( pszFilename, "r" );
4559 : else
4560 364 : hTIFF = VSI_TIFFOpen( pszFilename, "r+" );
4561 :
4562 3488 : if( hTIFF == NULL )
4563 0 : return( NULL );
4564 :
4565 : /* -------------------------------------------------------------------- */
4566 : /* Create a corresponding GDALDataset. */
4567 : /* -------------------------------------------------------------------- */
4568 : GTiffDataset *poDS;
4569 :
4570 3488 : poDS = new GTiffDataset();
4571 3488 : poDS->SetDescription( pszFilename );
4572 6976 : poDS->osFilename = pszFilename;
4573 3488 : poDS->poActiveDS = poDS;
4574 :
4575 3488 : if( poDS->OpenOffset( hTIFF, &(poDS->poActiveDS),
4576 : TIFFCurrentDirOffset(hTIFF), TRUE,
4577 : poOpenInfo->eAccess,
4578 : bAllowRGBAInterface, TRUE,
4579 : poOpenInfo->papszSiblingFiles) != CE_None )
4580 : {
4581 0 : delete poDS;
4582 0 : return NULL;
4583 : }
4584 :
4585 : /* -------------------------------------------------------------------- */
4586 : /* Initialize any PAM information. */
4587 : /* -------------------------------------------------------------------- */
4588 3488 : poDS->TryLoadXML();
4589 3488 : poDS->ApplyPamInfo();
4590 :
4591 : int i;
4592 270010 : for(i=1;i<=poDS->nBands;i++)
4593 : {
4594 266522 : GTiffRasterBand* poBand = (GTiffRasterBand*) poDS->GetRasterBand(i);
4595 :
4596 : /* Load scale, offset and unittype from PAM if available */
4597 266522 : if (!poBand->bHaveOffsetScale)
4598 : {
4599 266516 : poBand->dfScale = poBand->GDALPamRasterBand::GetScale(&poBand->bHaveOffsetScale);
4600 266516 : poBand->dfOffset = poBand->GDALPamRasterBand::GetOffset();
4601 : }
4602 266522 : if (poBand->osUnitType.size() == 0)
4603 : {
4604 266509 : const char* pszUnitType = poBand->GDALPamRasterBand::GetUnitType();
4605 266509 : if (pszUnitType)
4606 266509 : poBand->osUnitType = pszUnitType;
4607 : }
4608 : }
4609 :
4610 3488 : poDS->bMetadataChanged = FALSE;
4611 3488 : poDS->bGeoTIFFInfoChanged = FALSE;
4612 :
4613 : /* -------------------------------------------------------------------- */
4614 : /* Check for external overviews. */
4615 : /* -------------------------------------------------------------------- */
4616 3488 : poDS->oOvManager.Initialize( poDS, pszFilename );
4617 :
4618 3488 : return poDS;
4619 : }
4620 :
4621 : /************************************************************************/
4622 : /* LookForProjection() */
4623 : /************************************************************************/
4624 :
4625 4618 : void GTiffDataset::LookForProjection()
4626 :
4627 : {
4628 4618 : if( bLookedForProjection )
4629 3610 : return;
4630 :
4631 1008 : bLookedForProjection = TRUE;
4632 1008 : if (!SetDirectory())
4633 0 : return;
4634 :
4635 : /* -------------------------------------------------------------------- */
4636 : /* Capture the GeoTIFF projection, if available. */
4637 : /* -------------------------------------------------------------------- */
4638 : GTIF *hGTIF;
4639 : GTIFDefn sGTIFDefn;
4640 :
4641 1008 : CPLFree( pszProjection );
4642 1008 : pszProjection = NULL;
4643 :
4644 1008 : hGTIF = GTIFNew(hTIFF);
4645 :
4646 1008 : if ( !hGTIF )
4647 : {
4648 : CPLError( CE_Warning, CPLE_AppDefined,
4649 0 : "GeoTIFF tags apparently corrupt, they are being ignored." );
4650 : }
4651 : else
4652 : {
4653 1008 : if( GTIFGetDefn( hGTIF, &sGTIFDefn ) )
4654 : {
4655 975 : pszProjection = GTIFGetOGISDefn( hGTIF, &sGTIFDefn );
4656 :
4657 : // Should we simplify away vertical CS stuff?
4658 975 : if( EQUALN(pszProjection,"COMPD_CS",8)
4659 : && !CSLTestBoolean( CPLGetConfigOption("GTIFF_REPORT_COMPD_CS",
4660 : "NO") ) )
4661 : {
4662 0 : OGRSpatialReference oSRS;
4663 :
4664 0 : CPLDebug( "GTiff", "Got COMPD_CS, but stripping it." );
4665 0 : char *pszWKT = pszProjection;
4666 0 : oSRS.importFromWkt( &pszWKT );
4667 0 : CPLFree( pszProjection );
4668 :
4669 0 : oSRS.StripVertical();
4670 0 : oSRS.exportToWkt( &pszProjection );
4671 : }
4672 : }
4673 :
4674 : // Is this a pixel-is-point dataset?
4675 : short nRasterType;
4676 :
4677 1008 : if( GTIFKeyGet(hGTIF, GTRasterTypeGeoKey, &nRasterType,
4678 : 0, 1 ) == 1 )
4679 : {
4680 974 : if( nRasterType == (short) RasterPixelIsPoint )
4681 13 : oGTiffMDMD.SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_POINT );
4682 : else
4683 961 : oGTiffMDMD.SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_AREA );
4684 : }
4685 :
4686 1008 : GTIFFree( hGTIF );
4687 : }
4688 :
4689 1008 : if( pszProjection == NULL )
4690 : {
4691 33 : pszProjection = CPLStrdup( "" );
4692 : }
4693 :
4694 1008 : bGeoTIFFInfoChanged = FALSE;
4695 : }
4696 :
4697 : /************************************************************************/
4698 : /* ApplyPamInfo() */
4699 : /* */
4700 : /* PAM Information, if available, overrides the GeoTIFF */
4701 : /* geotransform and projection definition. Check for them */
4702 : /* now. */
4703 : /************************************************************************/
4704 :
4705 3488 : void GTiffDataset::ApplyPamInfo()
4706 :
4707 : {
4708 : double adfPamGeoTransform[6];
4709 :
4710 3488 : if( GDALPamDataset::GetGeoTransform( adfPamGeoTransform ) == CE_None
4711 : && (adfPamGeoTransform[0] != 0.0 || adfPamGeoTransform[1] != 1.0
4712 : || adfPamGeoTransform[2] != 0.0 || adfPamGeoTransform[3] != 0.0
4713 : || adfPamGeoTransform[4] != 0.0 || adfPamGeoTransform[5] != 1.0 ))
4714 : {
4715 0 : memcpy( adfGeoTransform, adfPamGeoTransform, sizeof(double)*6 );
4716 0 : bGeoTransformValid = TRUE;
4717 : }
4718 :
4719 3488 : const char *pszPamSRS = GDALPamDataset::GetProjectionRef();
4720 :
4721 3488 : if( pszPamSRS != NULL && strlen(pszPamSRS) > 0 )
4722 : {
4723 0 : CPLFree( pszProjection );
4724 0 : pszProjection = CPLStrdup( pszPamSRS );
4725 0 : bLookedForProjection = TRUE;
4726 : }
4727 :
4728 3488 : int nPamGCPCount = GDALPamDataset::GetGCPCount();
4729 3488 : if( nPamGCPCount > 0 )
4730 : {
4731 2 : if( nGCPCount > 0 )
4732 : {
4733 0 : GDALDeinitGCPs( nGCPCount, pasGCPList );
4734 0 : CPLFree( pasGCPList );
4735 0 : pasGCPList = NULL;
4736 : }
4737 :
4738 2 : nGCPCount = nPamGCPCount;
4739 2 : pasGCPList = GDALDuplicateGCPs(nGCPCount, GDALPamDataset::GetGCPs());
4740 :
4741 2 : CPLFree( pszProjection );
4742 2 : pszProjection = NULL;
4743 :
4744 2 : const char *pszPamGCPProjection = GDALPamDataset::GetGCPProjection();
4745 2 : if( pszPamGCPProjection != NULL && strlen(pszPamGCPProjection) > 0 )
4746 2 : pszProjection = CPLStrdup(pszPamGCPProjection);
4747 :
4748 2 : bLookedForProjection = TRUE;
4749 : }
4750 :
4751 : /* -------------------------------------------------------------------- */
4752 : /* Copy any PAM metadata into our GeoTIFF context, but with the */
4753 : /* GeoTIFF context overriding the PAM info. */
4754 : /* -------------------------------------------------------------------- */
4755 3488 : char **papszPamDomains = oMDMD.GetDomainList();
4756 :
4757 3496 : for( int iDomain = 0; papszPamDomains && papszPamDomains[iDomain] != NULL; iDomain++ )
4758 : {
4759 8 : const char *pszDomain = papszPamDomains[iDomain];
4760 8 : char **papszGT_MD = oGTiffMDMD.GetMetadata( pszDomain );
4761 8 : char **papszPAM_MD = CSLDuplicate(oMDMD.GetMetadata( pszDomain ));
4762 :
4763 8 : papszPAM_MD = CSLMerge( papszPAM_MD, papszGT_MD );
4764 :
4765 8 : oGTiffMDMD.SetMetadata( papszPAM_MD, pszDomain );
4766 8 : CSLDestroy( papszPAM_MD );
4767 : }
4768 :
4769 270010 : for( int i = 1; i <= GetRasterCount(); i++)
4770 : {
4771 266522 : GTiffRasterBand* poBand = (GTiffRasterBand *)GetRasterBand(i);
4772 266522 : papszPamDomains = poBand->oMDMD.GetDomainList();
4773 :
4774 266548 : for( int iDomain = 0; papszPamDomains && papszPamDomains[iDomain] != NULL; iDomain++ )
4775 : {
4776 26 : const char *pszDomain = papszPamDomains[iDomain];
4777 26 : char **papszGT_MD = poBand->oGTiffMDMD.GetMetadata( pszDomain );
4778 26 : char **papszPAM_MD = CSLDuplicate(poBand->oMDMD.GetMetadata( pszDomain ));
4779 :
4780 26 : papszPAM_MD = CSLMerge( papszPAM_MD, papszGT_MD );
4781 :
4782 26 : poBand->oGTiffMDMD.SetMetadata( papszPAM_MD, pszDomain );
4783 26 : CSLDestroy( papszPAM_MD );
4784 : }
4785 : }
4786 3488 : }
4787 :
4788 : /************************************************************************/
4789 : /* OpenDir() */
4790 : /* */
4791 : /* Open a specific directory as encoded into a filename. */
4792 : /************************************************************************/
4793 :
4794 4 : GDALDataset *GTiffDataset::OpenDir( GDALOpenInfo * poOpenInfo )
4795 :
4796 : {
4797 4 : int bAllowRGBAInterface = TRUE;
4798 4 : const char* pszFilename = poOpenInfo->pszFilename;
4799 4 : if( EQUALN(pszFilename,"GTIFF_RAW:", strlen("GTIFF_RAW:")) )
4800 : {
4801 0 : bAllowRGBAInterface = FALSE;
4802 0 : pszFilename += strlen("GTIFF_RAW:");
4803 : }
4804 :
4805 4 : if( !EQUALN(pszFilename,"GTIFF_DIR:",strlen("GTIFF_DIR:")) )
4806 0 : return NULL;
4807 :
4808 : /* -------------------------------------------------------------------- */
4809 : /* Split out filename, and dir#/offset. */
4810 : /* -------------------------------------------------------------------- */
4811 4 : pszFilename += strlen("GTIFF_DIR:");
4812 4 : int bAbsolute = FALSE;
4813 : toff_t nOffset;
4814 :
4815 4 : if( EQUALN(pszFilename,"off:",4) )
4816 : {
4817 1 : bAbsolute = TRUE;
4818 1 : pszFilename += 4;
4819 : }
4820 :
4821 4 : nOffset = atol(pszFilename);
4822 4 : pszFilename += 1;
4823 :
4824 14 : while( *pszFilename != '\0' && pszFilename[-1] != ':' )
4825 6 : pszFilename++;
4826 :
4827 4 : if( *pszFilename == '\0' || nOffset == 0 )
4828 : {
4829 : CPLError( CE_Failure, CPLE_OpenFailed,
4830 : "Unable to extract offset or filename, should take the form\n"
4831 0 : "GTIFF_DIR:<dir>:filename or GTIFF_DIR:off:<dir_offset>:filename" );
4832 0 : return NULL;
4833 : }
4834 :
4835 : /* -------------------------------------------------------------------- */
4836 : /* Try opening the dataset. */
4837 : /* -------------------------------------------------------------------- */
4838 : TIFF *hTIFF;
4839 :
4840 4 : GTiffOneTimeInit();
4841 :
4842 4 : hTIFF = VSI_TIFFOpen( pszFilename, "r" );
4843 4 : if( hTIFF == NULL )
4844 0 : return( NULL );
4845 :
4846 : /* -------------------------------------------------------------------- */
4847 : /* If a directory was requested by index, advance to it now. */
4848 : /* -------------------------------------------------------------------- */
4849 4 : if( !bAbsolute )
4850 : {
4851 7 : while( nOffset > 1 )
4852 : {
4853 1 : if( TIFFReadDirectory( hTIFF ) == 0 )
4854 : {
4855 0 : XTIFFClose( hTIFF );
4856 : CPLError( CE_Failure, CPLE_OpenFailed,
4857 0 : "Requested directory %lu not found.", (long unsigned int)nOffset );
4858 0 : return NULL;
4859 : }
4860 1 : nOffset--;
4861 : }
4862 :
4863 3 : nOffset = TIFFCurrentDirOffset( hTIFF );
4864 : }
4865 :
4866 : /* -------------------------------------------------------------------- */
4867 : /* Create a corresponding GDALDataset. */
4868 : /* -------------------------------------------------------------------- */
4869 : GTiffDataset *poDS;
4870 :
4871 4 : poDS = new GTiffDataset();
4872 4 : poDS->SetDescription( poOpenInfo->pszFilename );
4873 8 : poDS->osFilename = poOpenInfo->pszFilename;
4874 4 : poDS->poActiveDS = poDS;
4875 :
4876 8 : if( !EQUAL(pszFilename,poOpenInfo->pszFilename)
4877 : && !EQUALN(poOpenInfo->pszFilename,"GTIFF_RAW:",10) )
4878 : {
4879 4 : poDS->SetPhysicalFilename( pszFilename );
4880 4 : poDS->SetSubdatasetName( poOpenInfo->pszFilename );
4881 4 : poDS->osFilename = pszFilename;
4882 : }
4883 :
4884 4 : if (poOpenInfo->eAccess == GA_Update)
4885 : {
4886 : CPLError( CE_Warning, CPLE_AppDefined,
4887 0 : "Opening a specific TIFF directory is not supported in update mode. Switching to read-only" );
4888 : }
4889 :
4890 4 : if( poDS->OpenOffset( hTIFF, &(poDS->poActiveDS),
4891 : nOffset, FALSE, GA_ReadOnly,
4892 : bAllowRGBAInterface, TRUE,
4893 : poOpenInfo->papszSiblingFiles ) != CE_None )
4894 : {
4895 0 : delete poDS;
4896 0 : return NULL;
4897 : }
4898 : else
4899 : {
4900 4 : poDS->bCloseTIFFHandle = TRUE;
4901 4 : return poDS;
4902 : }
4903 : }
4904 :
4905 : /************************************************************************/
4906 : /* OpenOffset() */
4907 : /* */
4908 : /* Initialize the GTiffDataset based on a passed in file */
4909 : /* handle, and directory offset to utilize. This is called for */
4910 : /* full res, and overview pages. */
4911 : /************************************************************************/
4912 :
4913 : CPLErr GTiffDataset::OpenOffset( TIFF *hTIFFIn,
4914 : GTiffDataset **ppoActiveDSRef,
4915 : toff_t nDirOffsetIn,
4916 : int bBaseIn, GDALAccess eAccess,
4917 : int bAllowRGBAInterface,
4918 : int bReadGeoTransform,
4919 3856 : char** papszSiblingFiles )
4920 :
4921 : {
4922 : uint32 nXSize, nYSize;
4923 3856 : int bTreatAsBitmap = FALSE;
4924 3856 : int bTreatAsOdd = FALSE;
4925 :
4926 3856 : this->eAccess = eAccess;
4927 :
4928 3856 : hTIFF = hTIFFIn;
4929 3856 : this->ppoActiveDSRef = ppoActiveDSRef;
4930 :
4931 3856 : nDirOffset = nDirOffsetIn;
4932 :
4933 3856 : if (!SetDirectory( nDirOffsetIn ))
4934 0 : return CE_Failure;
4935 :
4936 3856 : bBase = bBaseIn;
4937 :
4938 3856 : this->eAccess = eAccess;
4939 :
4940 : /* -------------------------------------------------------------------- */
4941 : /* Capture some information from the file that is of interest. */
4942 : /* -------------------------------------------------------------------- */
4943 3856 : TIFFGetField( hTIFF, TIFFTAG_IMAGEWIDTH, &nXSize );
4944 3856 : TIFFGetField( hTIFF, TIFFTAG_IMAGELENGTH, &nYSize );
4945 3856 : nRasterXSize = nXSize;
4946 3856 : nRasterYSize = nYSize;
4947 :
4948 3856 : if( !TIFFGetField(hTIFF, TIFFTAG_SAMPLESPERPIXEL, &nSamplesPerPixel ) )
4949 0 : nBands = 1;
4950 : else
4951 3856 : nBands = nSamplesPerPixel;
4952 :
4953 3856 : if( !TIFFGetField(hTIFF, TIFFTAG_BITSPERSAMPLE, &(nBitsPerSample)) )
4954 0 : nBitsPerSample = 1;
4955 :
4956 3856 : if( !TIFFGetField( hTIFF, TIFFTAG_PLANARCONFIG, &(nPlanarConfig) ) )
4957 0 : nPlanarConfig = PLANARCONFIG_CONTIG;
4958 :
4959 3856 : if( !TIFFGetField( hTIFF, TIFFTAG_PHOTOMETRIC, &(nPhotometric) ) )
4960 0 : nPhotometric = PHOTOMETRIC_MINISBLACK;
4961 :
4962 3856 : if( !TIFFGetField( hTIFF, TIFFTAG_SAMPLEFORMAT, &(nSampleFormat) ) )
4963 10 : nSampleFormat = SAMPLEFORMAT_UINT;
4964 :
4965 3856 : if( !TIFFGetField( hTIFF, TIFFTAG_COMPRESSION, &(nCompression) ) )
4966 0 : nCompression = COMPRESSION_NONE;
4967 :
4968 : #if defined(TIFFLIB_VERSION) && TIFFLIB_VERSION > 20031007 /* 3.6.0 */
4969 3856 : if (nCompression != COMPRESSION_NONE &&
4970 : !TIFFIsCODECConfigured(nCompression))
4971 : {
4972 : CPLError( CE_Failure, CPLE_AppDefined,
4973 0 : "Cannot open TIFF file due to missing codec." );
4974 0 : return CE_Failure;
4975 : }
4976 : #endif
4977 :
4978 : /* -------------------------------------------------------------------- */
4979 : /* YCbCr JPEG compressed images should be translated on the fly */
4980 : /* to RGB by libtiff/libjpeg unless specifically requested */
4981 : /* otherwise. */
4982 : /* -------------------------------------------------------------------- */
4983 3856 : if( nCompression == COMPRESSION_JPEG
4984 : && nPhotometric == PHOTOMETRIC_YCBCR
4985 : && CSLTestBoolean( CPLGetConfigOption("CONVERT_YCBCR_TO_RGB",
4986 : "YES") ) )
4987 : {
4988 : int nColorMode;
4989 :
4990 51 : SetMetadataItem( "SOURCE_COLOR_SPACE", "YCbCr", "IMAGE_STRUCTURE" );
4991 51 : if ( !TIFFGetField( hTIFF, TIFFTAG_JPEGCOLORMODE, &nColorMode ) ||
4992 : nColorMode != JPEGCOLORMODE_RGB )
4993 49 : TIFFSetField(hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
4994 : }
4995 :
4996 : /* -------------------------------------------------------------------- */
4997 : /* Get strip/tile layout. */
4998 : /* -------------------------------------------------------------------- */
4999 3856 : if( TIFFIsTiled(hTIFF) )
5000 : {
5001 637 : TIFFGetField( hTIFF, TIFFTAG_TILEWIDTH, &(nBlockXSize) );
5002 637 : TIFFGetField( hTIFF, TIFFTAG_TILELENGTH, &(nBlockYSize) );
5003 : }
5004 : else
5005 : {
5006 3219 : if( !TIFFGetField( hTIFF, TIFFTAG_ROWSPERSTRIP,
5007 : &(nRowsPerStrip) ) )
5008 : {
5009 : CPLError( CE_Warning, CPLE_AppDefined,
5010 0 : "RowsPerStrip not defined ... assuming all one strip." );
5011 0 : nRowsPerStrip = nYSize; /* dummy value */
5012 : }
5013 :
5014 3219 : nBlockXSize = nRasterXSize;
5015 3219 : nBlockYSize = MIN(nRowsPerStrip,nYSize);
5016 : }
5017 :
5018 : nBlocksPerBand =
5019 : ((nYSize + nBlockYSize - 1) / nBlockYSize)
5020 3856 : * ((nXSize + nBlockXSize - 1) / nBlockXSize);
5021 :
5022 : /* -------------------------------------------------------------------- */
5023 : /* Should we handle this using the GTiffBitmapBand? */
5024 : /* -------------------------------------------------------------------- */
5025 3856 : if( nBitsPerSample == 1 && nBands == 1 )
5026 : {
5027 76 : bTreatAsBitmap = TRUE;
5028 :
5029 : // Lets treat large "one row" bitmaps using the scanline api.
5030 76 : if( !TIFFIsTiled(hTIFF)
5031 : && nBlockYSize == nYSize
5032 : && nYSize > 2000
5033 : && bAllowRGBAInterface )
5034 4 : bTreatAsSplitBitmap = TRUE;
5035 : }
5036 :
5037 : /* -------------------------------------------------------------------- */
5038 : /* Should we treat this via the RGBA interface? */
5039 : /* -------------------------------------------------------------------- */
5040 3856 : if( bAllowRGBAInterface &&
5041 : !bTreatAsBitmap && !(nBitsPerSample > 8)
5042 : && (nPhotometric == PHOTOMETRIC_CIELAB ||
5043 : nPhotometric == PHOTOMETRIC_LOGL ||
5044 : nPhotometric == PHOTOMETRIC_LOGLUV ||
5045 : nPhotometric == PHOTOMETRIC_SEPARATED ||
5046 : ( nPhotometric == PHOTOMETRIC_YCBCR
5047 : && nCompression != COMPRESSION_JPEG )) )
5048 : {
5049 : char szMessage[1024];
5050 :
5051 4 : if( TIFFRGBAImageOK( hTIFF, szMessage ) == 1 )
5052 : {
5053 4 : const char* pszSourceColorSpace = NULL;
5054 4 : switch (nPhotometric)
5055 : {
5056 : case PHOTOMETRIC_CIELAB:
5057 1 : pszSourceColorSpace = "CIELAB";
5058 1 : break;
5059 : case PHOTOMETRIC_LOGL:
5060 0 : pszSourceColorSpace = "LOGL";
5061 0 : break;
5062 : case PHOTOMETRIC_LOGLUV:
5063 0 : pszSourceColorSpace = "LOGLUV";
5064 0 : break;
5065 : case PHOTOMETRIC_SEPARATED:
5066 3 : pszSourceColorSpace = "CMYK";
5067 3 : break;
5068 : case PHOTOMETRIC_YCBCR:
5069 0 : pszSourceColorSpace = "YCbCr";
5070 : break;
5071 : }
5072 4 : if (pszSourceColorSpace)
5073 4 : SetMetadataItem( "SOURCE_COLOR_SPACE", pszSourceColorSpace, "IMAGE_STRUCTURE" );
5074 4 : bTreatAsRGBA = TRUE;
5075 4 : nBands = 4;
5076 : }
5077 : else
5078 : {
5079 0 : CPLDebug( "GTiff", "TIFFRGBAImageOK says:\n%s", szMessage );
5080 : }
5081 : }
5082 :
5083 : /* -------------------------------------------------------------------- */
5084 : /* Should we treat this via the split interface? */
5085 : /* -------------------------------------------------------------------- */
5086 3856 : if( !TIFFIsTiled(hTIFF)
5087 : && nBitsPerSample == 8
5088 : && nBlockYSize == nYSize
5089 : && nYSize > 2000
5090 : && !bTreatAsRGBA
5091 : && CSLTestBoolean(CPLGetConfigOption("GDAL_ENABLE_TIFF_SPLIT", "YES")))
5092 : {
5093 : /* libtiff 3.9.2 (20091104) and older, libtiff 4.0.0beta5 (also 20091104) */
5094 : /* and older will crash when trying to open a all-in-one-strip */
5095 : /* YCbCr JPEG compressed TIFF (see #3259). */
5096 : #if (TIFFLIB_VERSION <= 20091104 && !defined(BIGTIFF_SUPPORT)) || \
5097 : (TIFFLIB_VERSION <= 20091104 && defined(BIGTIFF_SUPPORT))
5098 : if (nPhotometric == PHOTOMETRIC_YCBCR &&
5099 : nCompression == COMPRESSION_JPEG)
5100 : {
5101 : CPLDebug("GTiff", "Avoid using split band to open all-in-one-strip "
5102 : "YCbCr JPEG compressed TIFF because of older libtiff");
5103 : }
5104 : else
5105 : #endif
5106 8 : bTreatAsSplit = TRUE;
5107 : }
5108 :
5109 : /* -------------------------------------------------------------------- */
5110 : /* Should we treat this via the odd bits interface? */
5111 : /* -------------------------------------------------------------------- */
5112 3856 : if ( nSampleFormat == SAMPLEFORMAT_IEEEFP )
5113 : {
5114 513 : if ( nBitsPerSample == 16 || nBitsPerSample == 24 )
5115 2 : bTreatAsOdd = TRUE;
5116 : }
5117 3343 : else if ( !bTreatAsRGBA && !bTreatAsBitmap
5118 : && nBitsPerSample != 8
5119 : && nBitsPerSample != 16
5120 : && nBitsPerSample != 32
5121 : && nBitsPerSample != 64
5122 : && nBitsPerSample != 128 )
5123 115 : bTreatAsOdd = TRUE;
5124 :
5125 3856 : int bMinIsWhite = nPhotometric == PHOTOMETRIC_MINISWHITE;
5126 :
5127 : /* -------------------------------------------------------------------- */
5128 : /* Capture the color table if there is one. */
5129 : /* -------------------------------------------------------------------- */
5130 : unsigned short *panRed, *panGreen, *panBlue;
5131 :
5132 3856 : if( bTreatAsRGBA
5133 : || TIFFGetField( hTIFF, TIFFTAG_COLORMAP,
5134 : &panRed, &panGreen, &panBlue) == 0 )
5135 : {
5136 : // Build inverted palette if we have inverted photometric.
5137 : // Pixel values remains unchanged. Avoid doing this for *deep*
5138 : // data types (per #1882)
5139 3777 : if( nBitsPerSample <= 16 && nPhotometric == PHOTOMETRIC_MINISWHITE )
5140 : {
5141 : GDALColorEntry oEntry;
5142 : int iColor, nColorCount;
5143 :
5144 7 : poColorTable = new GDALColorTable();
5145 7 : nColorCount = 1 << nBitsPerSample;
5146 :
5147 21 : for ( iColor = 0; iColor < nColorCount; iColor++ )
5148 : {
5149 : oEntry.c1 = oEntry.c2 = oEntry.c3 = (short)
5150 14 : ((255 * (nColorCount - 1 - iColor)) / (nColorCount-1));
5151 14 : oEntry.c4 = 255;
5152 14 : poColorTable->SetColorEntry( iColor, &oEntry );
5153 : }
5154 :
5155 7 : nPhotometric = PHOTOMETRIC_PALETTE;
5156 : }
5157 : else
5158 3763 : poColorTable = NULL;
5159 : }
5160 : else
5161 : {
5162 86 : int nColorCount, nMaxColor = 0;
5163 : GDALColorEntry oEntry;
5164 :
5165 86 : poColorTable = new GDALColorTable();
5166 :
5167 86 : nColorCount = 1 << nBitsPerSample;
5168 :
5169 345962 : for( int iColor = nColorCount - 1; iColor >= 0; iColor-- )
5170 : {
5171 345876 : oEntry.c1 = panRed[iColor] / 256;
5172 345876 : oEntry.c2 = panGreen[iColor] / 256;
5173 345876 : oEntry.c3 = panBlue[iColor] / 256;
5174 345876 : oEntry.c4 = 255;
5175 :
5176 345876 : poColorTable->SetColorEntry( iColor, &oEntry );
5177 :
5178 345876 : nMaxColor = MAX(nMaxColor,panRed[iColor]);
5179 345876 : nMaxColor = MAX(nMaxColor,panGreen[iColor]);
5180 345876 : nMaxColor = MAX(nMaxColor,panBlue[iColor]);
5181 : }
5182 :
5183 : // Bug 1384 - Some TIFF files are generated with color map entry
5184 : // values in range 0-255 instead of 0-65535 - try to handle these
5185 : // gracefully.
5186 86 : if( nMaxColor > 0 && nMaxColor < 256 )
5187 : {
5188 0 : CPLDebug( "GTiff", "TIFF ColorTable seems to be improperly scaled, fixing up." );
5189 :
5190 0 : for( int iColor = nColorCount - 1; iColor >= 0; iColor-- )
5191 : {
5192 0 : oEntry.c1 = panRed[iColor];
5193 0 : oEntry.c2 = panGreen[iColor];
5194 0 : oEntry.c3 = panBlue[iColor];
5195 0 : oEntry.c4 = 255;
5196 :
5197 0 : poColorTable->SetColorEntry( iColor, &oEntry );
5198 : }
5199 : }
5200 : }
5201 :
5202 : /* -------------------------------------------------------------------- */
5203 : /* Create band information objects. */
5204 : /* -------------------------------------------------------------------- */
5205 271018 : for( int iBand = 0; iBand < nBands; iBand++ )
5206 : {
5207 267162 : if( bTreatAsRGBA )
5208 16 : SetBand( iBand+1, new GTiffRGBABand( this, iBand+1 ) );
5209 267146 : else if( bTreatAsSplitBitmap )
5210 4 : SetBand( iBand+1, new GTiffSplitBitmapBand( this, iBand+1 ) );
5211 267142 : else if( bTreatAsSplit )
5212 24 : SetBand( iBand+1, new GTiffSplitBand( this, iBand+1 ) );
5213 267118 : else if( bTreatAsBitmap )
5214 72 : SetBand( iBand+1, new GTiffBitmapBand( this, iBand+1 ) );
5215 267046 : else if( bTreatAsOdd )
5216 231 : SetBand( iBand+1, new GTiffOddBitsBand( this, iBand+1 ) );
5217 : else
5218 266815 : SetBand( iBand+1, new GTiffRasterBand( this, iBand+1 ) );
5219 : }
5220 :
5221 3856 : if( GetRasterBand(1)->GetRasterDataType() == GDT_Unknown )
5222 : {
5223 : CPLError( CE_Failure, CPLE_NotSupported,
5224 0 : "Unsupported TIFF configuration." );
5225 0 : return CE_Failure;
5226 : }
5227 :
5228 : /* -------------------------------------------------------------------- */
5229 : /* Get the transform or gcps from the GeoTIFF file. */
5230 : /* -------------------------------------------------------------------- */
5231 3856 : if( bReadGeoTransform )
5232 : {
5233 3492 : char *pszTabWKT = NULL;
5234 : double *padfTiePoints, *padfScale, *padfMatrix;
5235 : uint16 nCount;
5236 :
5237 3492 : adfGeoTransform[0] = 0.0;
5238 3492 : adfGeoTransform[1] = 1.0;
5239 3492 : adfGeoTransform[2] = 0.0;
5240 3492 : adfGeoTransform[3] = 0.0;
5241 3492 : adfGeoTransform[4] = 0.0;
5242 3492 : adfGeoTransform[5] = 1.0;
5243 :
5244 3492 : if( TIFFGetField(hTIFF,TIFFTAG_GEOPIXELSCALE,&nCount,&padfScale )
5245 : && nCount >= 2
5246 : && padfScale[0] != 0.0 && padfScale[1] != 0.0 )
5247 : {
5248 2568 : adfGeoTransform[1] = padfScale[0];
5249 2568 : adfGeoTransform[5] = - ABS(padfScale[1]);
5250 :
5251 2568 : if( TIFFGetField(hTIFF,TIFFTAG_GEOTIEPOINTS,&nCount,&padfTiePoints )
5252 : && nCount >= 6 )
5253 : {
5254 : adfGeoTransform[0] =
5255 2568 : padfTiePoints[3] - padfTiePoints[0] * adfGeoTransform[1];
5256 : adfGeoTransform[3] =
5257 2568 : padfTiePoints[4] - padfTiePoints[1] * adfGeoTransform[5];
5258 :
5259 2568 : bGeoTransformValid = TRUE;
5260 : }
5261 : }
5262 :
5263 924 : else if( TIFFGetField(hTIFF,TIFFTAG_GEOTRANSMATRIX,&nCount,&padfMatrix )
5264 : && nCount == 16 )
5265 : {
5266 8 : adfGeoTransform[0] = padfMatrix[3];
5267 8 : adfGeoTransform[1] = padfMatrix[0];
5268 8 : adfGeoTransform[2] = padfMatrix[1];
5269 8 : adfGeoTransform[3] = padfMatrix[7];
5270 8 : adfGeoTransform[4] = padfMatrix[4];
5271 8 : adfGeoTransform[5] = padfMatrix[5];
5272 8 : bGeoTransformValid = TRUE;
5273 : }
5274 :
5275 : /* -------------------------------------------------------------------- */
5276 : /* Otherwise try looking for a .tfw, .tifw or .wld file. */
5277 : /* -------------------------------------------------------------------- */
5278 : else
5279 : {
5280 : bGeoTransformValid =
5281 916 : GDALReadWorldFile( osFilename, NULL, adfGeoTransform );
5282 :
5283 916 : if( !bGeoTransformValid )
5284 : {
5285 : bGeoTransformValid =
5286 911 : GDALReadWorldFile( osFilename, "wld", adfGeoTransform );
5287 : }
5288 :
5289 916 : if( !bGeoTransformValid )
5290 : {
5291 : int bTabFileOK =
5292 : GDALReadTabFile( osFilename, adfGeoTransform,
5293 906 : &pszTabWKT, &nGCPCount, &pasGCPList );
5294 :
5295 906 : if( bTabFileOK && nGCPCount == 0 )
5296 2 : bGeoTransformValid = TRUE;
5297 : }
5298 : }
5299 :
5300 : /* -------------------------------------------------------------------- */
5301 : /* Check for GCPs. Note, we will allow there to be GCPs and a */
5302 : /* transform in some circumstances. */
5303 : /* -------------------------------------------------------------------- */
5304 3492 : if( TIFFGetField(hTIFF,TIFFTAG_GEOTIEPOINTS,&nCount,&padfTiePoints )
5305 : && !bGeoTransformValid )
5306 : {
5307 40 : nGCPCount = nCount / 6;
5308 40 : pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPCount);
5309 :
5310 208 : for( int iGCP = 0; iGCP < nGCPCount; iGCP++ )
5311 : {
5312 : char szID[32];
5313 :
5314 168 : sprintf( szID, "%d", iGCP+1 );
5315 168 : pasGCPList[iGCP].pszId = CPLStrdup( szID );
5316 168 : pasGCPList[iGCP].pszInfo = CPLStrdup("");
5317 168 : pasGCPList[iGCP].dfGCPPixel = padfTiePoints[iGCP*6+0];
5318 168 : pasGCPList[iGCP].dfGCPLine = padfTiePoints[iGCP*6+1];
5319 168 : pasGCPList[iGCP].dfGCPX = padfTiePoints[iGCP*6+3];
5320 168 : pasGCPList[iGCP].dfGCPY = padfTiePoints[iGCP*6+4];
5321 168 : pasGCPList[iGCP].dfGCPZ = padfTiePoints[iGCP*6+5];
5322 : }
5323 : }
5324 :
5325 : /* -------------------------------------------------------------------- */
5326 : /* Did we find a tab file? If so we will use it's coordinate */
5327 : /* system and give it precidence. */
5328 : /* -------------------------------------------------------------------- */
5329 3492 : if( pszTabWKT != NULL
5330 : && (pszProjection == NULL || pszProjection[0] == '\0') )
5331 : {
5332 2 : CPLFree( pszProjection );
5333 2 : pszProjection = pszTabWKT;
5334 2 : pszTabWKT = NULL;
5335 2 : bLookedForProjection = TRUE;
5336 : }
5337 :
5338 3492 : CPLFree( pszTabWKT );
5339 3492 : bGeoTIFFInfoChanged = FALSE;
5340 : }
5341 :
5342 : /* -------------------------------------------------------------------- */
5343 : /* Capture some other potentially interesting information. */
5344 : /* -------------------------------------------------------------------- */
5345 : char *pszText, szWorkMDI[200];
5346 : float fResolution;
5347 : uint16 nShort;
5348 :
5349 3856 : if( TIFFGetField( hTIFF, TIFFTAG_DOCUMENTNAME, &pszText ) )
5350 16 : SetMetadataItem( "TIFFTAG_DOCUMENTNAME", pszText );
5351 :
5352 3856 : if( TIFFGetField( hTIFF, TIFFTAG_IMAGEDESCRIPTION, &pszText ) )
5353 2 : SetMetadataItem( "TIFFTAG_IMAGEDESCRIPTION", pszText );
5354 :
5355 3856 : if( TIFFGetField( hTIFF, TIFFTAG_SOFTWARE, &pszText ) )
5356 8 : SetMetadataItem( "TIFFTAG_SOFTWARE", pszText );
5357 :
5358 3856 : if( TIFFGetField( hTIFF, TIFFTAG_DATETIME, &pszText ) )
5359 3 : SetMetadataItem( "TIFFTAG_DATETIME", pszText );
5360 :
5361 3856 : if( TIFFGetField( hTIFF, TIFFTAG_ARTIST, &pszText ) )
5362 2 : SetMetadataItem( "TIFFTAG_ARTIST", pszText );
5363 :
5364 3856 : if( TIFFGetField( hTIFF, TIFFTAG_HOSTCOMPUTER, &pszText ) )
5365 2 : SetMetadataItem( "TIFFTAG_HOSTCOMPUTER", pszText );
5366 :
5367 3856 : if( TIFFGetField( hTIFF, TIFFTAG_COPYRIGHT, &pszText ) )
5368 2 : SetMetadataItem( "TIFFTAG_COPYRIGHT", pszText );
5369 :
5370 3856 : if( TIFFGetField( hTIFF, TIFFTAG_XRESOLUTION, &fResolution ) )
5371 : {
5372 35 : sprintf( szWorkMDI, "%.8g", fResolution );
5373 35 : SetMetadataItem( "TIFFTAG_XRESOLUTION", szWorkMDI );
5374 : }
5375 :
5376 3856 : if( TIFFGetField( hTIFF, TIFFTAG_YRESOLUTION, &fResolution ) )
5377 : {
5378 35 : sprintf( szWorkMDI, "%.8g", fResolution );
5379 35 : SetMetadataItem( "TIFFTAG_YRESOLUTION", szWorkMDI );
5380 : }
5381 :
5382 3856 : if( TIFFGetField( hTIFF, TIFFTAG_MINSAMPLEVALUE, &nShort ) )
5383 : {
5384 0 : sprintf( szWorkMDI, "%d", nShort );
5385 0 : SetMetadataItem( "TIFFTAG_MINSAMPLEVALUE", szWorkMDI );
5386 : }
5387 :
5388 3856 : if( TIFFGetField( hTIFF, TIFFTAG_MAXSAMPLEVALUE, &nShort ) )
5389 : {
5390 0 : sprintf( szWorkMDI, "%d", nShort );
5391 0 : SetMetadataItem( "TIFFTAG_MAXSAMPLEVALUE", szWorkMDI );
5392 : }
5393 :
5394 3856 : if( TIFFGetField( hTIFF, TIFFTAG_RESOLUTIONUNIT, &nShort ) )
5395 : {
5396 35 : if( nShort == RESUNIT_NONE )
5397 13 : sprintf( szWorkMDI, "%d (unitless)", nShort );
5398 22 : else if( nShort == RESUNIT_INCH )
5399 22 : sprintf( szWorkMDI, "%d (pixels/inch)", nShort );
5400 0 : else if( nShort == RESUNIT_CENTIMETER )
5401 0 : sprintf( szWorkMDI, "%d (pixels/cm)", nShort );
5402 : else
5403 0 : sprintf( szWorkMDI, "%d", nShort );
5404 35 : SetMetadataItem( "TIFFTAG_RESOLUTIONUNIT", szWorkMDI );
5405 : }
5406 :
5407 3856 : if( nCompression == COMPRESSION_NONE )
5408 : /* no compression tag */;
5409 227 : else if( nCompression == COMPRESSION_CCITTRLE )
5410 0 : SetMetadataItem( "COMPRESSION", "CCITTRLE", "IMAGE_STRUCTURE" );
5411 227 : else if( nCompression == COMPRESSION_CCITTFAX3 )
5412 0 : SetMetadataItem( "COMPRESSION", "CCITTFAX3", "IMAGE_STRUCTURE" );
5413 227 : else if( nCompression == COMPRESSION_CCITTFAX4 )
5414 9 : SetMetadataItem( "COMPRESSION", "CCITTFAX4", "IMAGE_STRUCTURE" );
5415 218 : else if( nCompression == COMPRESSION_LZW )
5416 42 : SetMetadataItem( "COMPRESSION", "LZW", "IMAGE_STRUCTURE" );
5417 176 : else if( nCompression == COMPRESSION_OJPEG )
5418 0 : SetMetadataItem( "COMPRESSION", "OJPEG", "IMAGE_STRUCTURE" );
5419 176 : else if( nCompression == COMPRESSION_JPEG )
5420 : {
5421 64 : if ( nPhotometric == PHOTOMETRIC_YCBCR )
5422 51 : SetMetadataItem( "COMPRESSION", "YCbCr JPEG", "IMAGE_STRUCTURE" );
5423 : else
5424 13 : SetMetadataItem( "COMPRESSION", "JPEG", "IMAGE_STRUCTURE" );
5425 : }
5426 112 : else if( nCompression == COMPRESSION_NEXT )
5427 0 : SetMetadataItem( "COMPRESSION", "NEXT", "IMAGE_STRUCTURE" );
5428 112 : else if( nCompression == COMPRESSION_CCITTRLEW )
5429 0 : SetMetadataItem( "COMPRESSION", "CCITTRLEW", "IMAGE_STRUCTURE" );
5430 112 : else if( nCompression == COMPRESSION_PACKBITS )
5431 8 : SetMetadataItem( "COMPRESSION", "PACKBITS", "IMAGE_STRUCTURE" );
5432 104 : else if( nCompression == COMPRESSION_THUNDERSCAN )
5433 0 : SetMetadataItem( "COMPRESSION", "THUNDERSCAN", "IMAGE_STRUCTURE" );
5434 104 : else if( nCompression == COMPRESSION_PIXARFILM )
5435 0 : SetMetadataItem( "COMPRESSION", "PIXARFILM", "IMAGE_STRUCTURE" );
5436 104 : else if( nCompression == COMPRESSION_PIXARLOG )
5437 0 : SetMetadataItem( "COMPRESSION", "PIXARLOG", "IMAGE_STRUCTURE" );
5438 104 : else if( nCompression == COMPRESSION_DEFLATE )
5439 45 : SetMetadataItem( "COMPRESSION", "DEFLATE", "IMAGE_STRUCTURE" );
5440 59 : else if( nCompression == COMPRESSION_ADOBE_DEFLATE )
5441 59 : SetMetadataItem( "COMPRESSION", "DEFLATE", "IMAGE_STRUCTURE" );
5442 0 : else if( nCompression == COMPRESSION_DCS )
5443 0 : SetMetadataItem( "COMPRESSION", "DCS", "IMAGE_STRUCTURE" );
5444 0 : else if( nCompression == COMPRESSION_JBIG )
5445 0 : SetMetadataItem( "COMPRESSION", "JBIG", "IMAGE_STRUCTURE" );
5446 0 : else if( nCompression == COMPRESSION_SGILOG )
5447 0 : SetMetadataItem( "COMPRESSION", "SGILOG", "IMAGE_STRUCTURE" );
5448 0 : else if( nCompression == COMPRESSION_SGILOG24 )
5449 0 : SetMetadataItem( "COMPRESSION", "SGILOG24", "IMAGE_STRUCTURE" );
5450 0 : else if( nCompression == COMPRESSION_JP2000 )
5451 0 : SetMetadataItem( "COMPRESSION", "JP2000", "IMAGE_STRUCTURE" );
5452 : else
5453 : {
5454 0 : CPLString oComp;
5455 : SetMetadataItem( "COMPRESSION",
5456 0 : (const char *) oComp.Printf( "%d", nCompression));
5457 : }
5458 :
5459 4267 : if( nPlanarConfig == PLANARCONFIG_CONTIG && nBands != 1 )
5460 411 : SetMetadataItem( "INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE" );
5461 : else
5462 3445 : SetMetadataItem( "INTERLEAVE", "BAND", "IMAGE_STRUCTURE" );
5463 :
5464 3856 : if( (GetRasterBand(1)->GetRasterDataType() == GDT_Byte && nBitsPerSample != 8 ) ||
5465 : (GetRasterBand(1)->GetRasterDataType() == GDT_UInt16 && nBitsPerSample != 16) ||
5466 : (GetRasterBand(1)->GetRasterDataType() == GDT_UInt32 && nBitsPerSample != 32) )
5467 : {
5468 992 : for (int i = 0; i < nBands; ++i)
5469 : GetRasterBand(i+1)->SetMetadataItem( "NBITS",
5470 : CPLString().Printf( "%d", (int)nBitsPerSample ),
5471 305 : "IMAGE_STRUCTURE" );
5472 : }
5473 :
5474 3856 : if( bMinIsWhite )
5475 8 : SetMetadataItem( "MINISWHITE", "YES", "IMAGE_STRUCTURE" );
5476 :
5477 3856 : if( TIFFGetField( hTIFF, TIFFTAG_GDAL_METADATA, &pszText ) )
5478 : {
5479 195 : CPLXMLNode *psRoot = CPLParseXMLString( pszText );
5480 195 : CPLXMLNode *psItem = NULL;
5481 :
5482 195 : if( psRoot != NULL && psRoot->eType == CXT_Element
5483 : && EQUAL(psRoot->pszValue,"GDALMetadata") )
5484 195 : psItem = psRoot->psChild;
5485 :
5486 893 : for( ; psItem != NULL; psItem = psItem->psNext )
5487 : {
5488 : const char *pszKey, *pszValue, *pszRole, *pszDomain;
5489 : char *pszUnescapedValue;
5490 698 : int nBand, bIsXML = FALSE;
5491 :
5492 698 : if( psItem->eType != CXT_Element
5493 : || !EQUAL(psItem->pszValue,"Item") )
5494 0 : continue;
5495 :
5496 698 : pszKey = CPLGetXMLValue( psItem, "name", NULL );
5497 698 : pszValue = CPLGetXMLValue( psItem, NULL, NULL );
5498 698 : nBand = atoi(CPLGetXMLValue( psItem, "sample", "-1" )) + 1;
5499 698 : pszRole = CPLGetXMLValue( psItem, "role", "" );
5500 698 : pszDomain = CPLGetXMLValue( psItem, "domain", "" );
5501 :
5502 698 : if( pszKey == NULL || pszValue == NULL )
5503 25 : continue;
5504 :
5505 673 : if( EQUALN(pszDomain,"xml:",4) )
5506 2 : bIsXML = TRUE;
5507 :
5508 : pszUnescapedValue = CPLUnescapeString( pszValue, NULL,
5509 673 : CPLES_XML );
5510 673 : if( nBand == 0 )
5511 : {
5512 502 : if( bIsXML )
5513 : {
5514 2 : char *apszMD[2] = { pszUnescapedValue, NULL };
5515 2 : SetMetadata( apszMD, pszDomain );
5516 : }
5517 : else
5518 500 : SetMetadataItem( pszKey, pszUnescapedValue, pszDomain );
5519 : }
5520 : else
5521 : {
5522 171 : GDALRasterBand *poBand = GetRasterBand(nBand);
5523 171 : if( poBand != NULL )
5524 : {
5525 171 : if( EQUAL(pszRole,"scale") )
5526 6 : poBand->SetScale( CPLAtofM(pszUnescapedValue) );
5527 165 : else if( EQUAL(pszRole,"offset") )
5528 6 : poBand->SetOffset( CPLAtofM(pszUnescapedValue) );
5529 159 : else if( EQUAL(pszRole,"unittype") )
5530 13 : poBand->SetUnitType( pszUnescapedValue );
5531 : else
5532 : {
5533 146 : if( bIsXML )
5534 : {
5535 0 : char *apszMD[2] = { pszUnescapedValue, NULL };
5536 0 : poBand->SetMetadata( apszMD, pszDomain );
5537 : }
5538 : else
5539 : poBand->SetMetadataItem(pszKey,pszUnescapedValue,
5540 146 : pszDomain );
5541 : }
5542 : }
5543 : }
5544 673 : CPLFree( pszUnescapedValue );
5545 : }
5546 :
5547 195 : CPLDestroyXMLNode( psRoot );
5548 : }
5549 :
5550 3856 : bMetadataChanged = FALSE;
5551 :
5552 : /* -------------------------------------------------------------------- */
5553 : /* Check for RPC metadata in an RPB or _rpc.txt file. */
5554 : /* -------------------------------------------------------------------- */
5555 3856 : if( bBaseIn )
5556 : {
5557 3488 : char **papszRPCMD = NULL;
5558 : /* Read Digital Globe .RPB file */
5559 3488 : if (FindRPBFile(papszSiblingFiles))
5560 3 : papszRPCMD = GDALLoadRPBFile( osRPBFile.c_str(), NULL );
5561 : /* Read GeoEye _rpc.txt file */
5562 3488 : if(papszRPCMD == NULL && FindRPCFile(papszSiblingFiles))
5563 0 : papszRPCMD = GDALLoadRPCFile( osRPCFile.c_str(), NULL );
5564 :
5565 3488 : if( papszRPCMD != NULL )
5566 : {
5567 3 : oGTiffMDMD.SetMetadata( papszRPCMD, "RPC" );
5568 3 : CSLDestroy( papszRPCMD );
5569 3 : bMetadataChanged = FALSE;
5570 : }
5571 : else
5572 3485 : ReadRPCTag();
5573 : }
5574 :
5575 : /* -------------------------------------------------------------------- */
5576 : /* Check for RPC metadata in an RPB file. */
5577 : /* -------------------------------------------------------------------- */
5578 3856 : if( bBaseIn && FindIMDFile(papszSiblingFiles) )
5579 : {
5580 6 : char **papszIMDMD = GDALLoadIMDFile( osIMDFile.c_str(), NULL );
5581 :
5582 6 : if( papszIMDMD != NULL )
5583 : {
5584 6 : oGTiffMDMD.SetMetadata( papszIMDMD, "IMD" );
5585 6 : CSLDestroy( papszIMDMD );
5586 6 : bMetadataChanged = FALSE;
5587 : }
5588 : }
5589 :
5590 : /* -------------------------------------------------------------------- */
5591 : /* Check for NODATA */
5592 : /* -------------------------------------------------------------------- */
5593 3856 : if( TIFFGetField( hTIFF, TIFFTAG_GDAL_NODATA, &pszText ) )
5594 : {
5595 169 : bNoDataSet = TRUE;
5596 169 : dfNoDataValue = CPLAtofM( pszText );
5597 : }
5598 :
5599 : /* -------------------------------------------------------------------- */
5600 : /* If this is a "base" raster, we should scan for any */
5601 : /* associated overviews, internal mask bands and subdatasets. */
5602 : /* -------------------------------------------------------------------- */
5603 3856 : if( bBase )
5604 : {
5605 3488 : char **papszSubdatasets = NULL;
5606 3488 : int iDirIndex = 0;
5607 :
5608 3488 : FlushDirectory();
5609 7357 : while( !TIFFLastDirectory( hTIFF )
5610 : && (iDirIndex == 0 || TIFFReadDirectory( hTIFF ) != 0) )
5611 : {
5612 381 : toff_t nThisDir = TIFFCurrentDirOffset(hTIFF);
5613 381 : uint32 nSubType = 0;
5614 :
5615 381 : *ppoActiveDSRef = NULL; // our directory no longer matches this ds
5616 :
5617 381 : iDirIndex++;
5618 :
5619 381 : if( !TIFFGetField(hTIFF, TIFFTAG_SUBFILETYPE, &nSubType) )
5620 103 : nSubType = 0;
5621 :
5622 : /* Embedded overview of the main image */
5623 561 : if ((nSubType & FILETYPE_REDUCEDIMAGE) != 0 &&
5624 : (nSubType & FILETYPE_MASK) == 0 &&
5625 : iDirIndex != 1 )
5626 : {
5627 : GTiffDataset *poODS;
5628 :
5629 180 : poODS = new GTiffDataset();
5630 360 : if( poODS->OpenOffset( hTIFF, ppoActiveDSRef, nThisDir, FALSE,
5631 : eAccess ) != CE_None
5632 : || poODS->GetRasterCount() != GetRasterCount() )
5633 : {
5634 0 : delete poODS;
5635 : }
5636 : else
5637 : {
5638 : CPLDebug( "GTiff", "Opened %dx%d overview.\n",
5639 180 : poODS->GetRasterXSize(), poODS->GetRasterYSize());
5640 180 : nOverviewCount++;
5641 : papoOverviewDS = (GTiffDataset **)
5642 : CPLRealloc(papoOverviewDS,
5643 180 : nOverviewCount * (sizeof(void*)));
5644 180 : papoOverviewDS[nOverviewCount-1] = poODS;
5645 180 : poODS->poBaseDS = this;
5646 : }
5647 : }
5648 :
5649 : /* Embedded mask of the main image */
5650 221 : else if ((nSubType & FILETYPE_MASK) != 0 &&
5651 : (nSubType & FILETYPE_REDUCEDIMAGE) == 0 &&
5652 : poMaskDS == NULL )
5653 : {
5654 20 : poMaskDS = new GTiffDataset();
5655 :
5656 : /* The TIFF6 specification - page 37 - only allows 1 SamplesPerPixel and 1 BitsPerSample
5657 : Here we support either 1 or 8 bit per sample
5658 : and we support either 1 sample per pixel or as many samples as in the main image
5659 : We don't check the value of the PhotometricInterpretation tag, which should be
5660 : set to "Transparency mask" (4) according to the specification (page 36)
5661 : ... But the TIFF6 specification allows image masks to have a higher resolution than
5662 : the main image, what we don't support here
5663 : */
5664 :
5665 40 : if( poMaskDS->OpenOffset( hTIFF, ppoActiveDSRef, nThisDir,
5666 : FALSE, eAccess ) != CE_None
5667 : || poMaskDS->GetRasterCount() == 0
5668 : || !(poMaskDS->GetRasterCount() == 1 || poMaskDS->GetRasterCount() == GetRasterCount())
5669 : || poMaskDS->GetRasterXSize() != GetRasterXSize()
5670 : || poMaskDS->GetRasterYSize() != GetRasterYSize()
5671 : || poMaskDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte)
5672 : {
5673 0 : delete poMaskDS;
5674 0 : poMaskDS = NULL;
5675 : }
5676 : else
5677 : {
5678 20 : CPLDebug( "GTiff", "Opened band mask.\n");
5679 20 : poMaskDS->poBaseDS = this;
5680 : }
5681 : }
5682 :
5683 : /* Embedded mask of an overview */
5684 : /* The TIFF6 specification allows the combination of the FILETYPE_xxxx masks */
5685 181 : else if (nSubType & (FILETYPE_REDUCEDIMAGE | FILETYPE_MASK))
5686 : {
5687 78 : GTiffDataset* poDS = new GTiffDataset();
5688 156 : if( poDS->OpenOffset( hTIFF, ppoActiveDSRef, nThisDir, FALSE,
5689 : eAccess ) != CE_None
5690 : || poDS->GetRasterCount() == 0
5691 : || poDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte)
5692 : {
5693 21 : delete poDS;
5694 : }
5695 : else
5696 : {
5697 : int i;
5698 68 : for(i=0;i<nOverviewCount;i++)
5699 : {
5700 35 : if (((GTiffDataset*)papoOverviewDS[i])->poMaskDS == NULL &&
5701 : poDS->GetRasterXSize() == papoOverviewDS[i]->GetRasterXSize() &&
5702 : poDS->GetRasterYSize() == papoOverviewDS[i]->GetRasterYSize() &&
5703 : (poDS->GetRasterCount() == 1 || poDS->GetRasterCount() == GetRasterCount()))
5704 : {
5705 : CPLDebug( "GTiff", "Opened band mask for %dx%d overview.\n",
5706 24 : poDS->GetRasterXSize(), poDS->GetRasterYSize());
5707 24 : ((GTiffDataset*)papoOverviewDS[i])->poMaskDS = poDS;
5708 24 : poDS->poBaseDS = this;
5709 24 : break;
5710 : }
5711 : }
5712 57 : if (i == nOverviewCount)
5713 : {
5714 33 : delete poDS;
5715 : }
5716 : }
5717 : }
5718 103 : else if( nSubType == 0 ) {
5719 103 : CPLString osName, osDesc;
5720 : uint32 nXSize, nYSize;
5721 : uint16 nSPP;
5722 :
5723 103 : TIFFGetField( hTIFF, TIFFTAG_IMAGEWIDTH, &nXSize );
5724 103 : TIFFGetField( hTIFF, TIFFTAG_IMAGELENGTH, &nYSize );
5725 103 : if( !TIFFGetField(hTIFF, TIFFTAG_SAMPLESPERPIXEL, &nSPP ) )
5726 0 : nSPP = 1;
5727 :
5728 : osName.Printf( "SUBDATASET_%d_NAME=GTIFF_DIR:%d:%s",
5729 103 : iDirIndex, iDirIndex, osFilename.c_str() );
5730 : osDesc.Printf( "SUBDATASET_%d_DESC=Page %d (%dP x %dL x %dB)",
5731 : iDirIndex, iDirIndex,
5732 103 : (int)nXSize, (int)nYSize, nSPP );
5733 :
5734 : papszSubdatasets =
5735 103 : CSLAddString( papszSubdatasets, osName );
5736 : papszSubdatasets =
5737 103 : CSLAddString( papszSubdatasets, osDesc );
5738 : }
5739 :
5740 : // Make sure we are stepping from the expected directory regardless
5741 : // of churn done processing the above.
5742 381 : if( TIFFCurrentDirOffset(hTIFF) != nThisDir )
5743 0 : TIFFSetSubDirectory( hTIFF, nThisDir );
5744 381 : *ppoActiveDSRef = NULL;
5745 : }
5746 :
5747 : /* If we have a mask for the main image, loop over the overviews, and if they */
5748 : /* have a mask, let's set this mask as an overview of the main mask... */
5749 3488 : if (poMaskDS != NULL)
5750 : {
5751 : int i;
5752 44 : for(i=0;i<nOverviewCount;i++)
5753 : {
5754 24 : if (((GTiffDataset*)papoOverviewDS[i])->poMaskDS != NULL)
5755 : {
5756 24 : poMaskDS->nOverviewCount++;
5757 : poMaskDS->papoOverviewDS = (GTiffDataset **)
5758 : CPLRealloc(poMaskDS->papoOverviewDS,
5759 24 : poMaskDS->nOverviewCount * (sizeof(void*)));
5760 : poMaskDS->papoOverviewDS[poMaskDS->nOverviewCount-1] =
5761 24 : ((GTiffDataset*)papoOverviewDS[i])->poMaskDS;
5762 : }
5763 : }
5764 : }
5765 :
5766 : /* -------------------------------------------------------------------- */
5767 : /* Only keep track of subdatasets if we have more than one */
5768 : /* subdataset (pair). */
5769 : /* -------------------------------------------------------------------- */
5770 3488 : if( CSLCount(papszSubdatasets) > 2 )
5771 : {
5772 1 : oGTiffMDMD.SetMetadata( papszSubdatasets, "SUBDATASETS" );
5773 : }
5774 3488 : CSLDestroy( papszSubdatasets );
5775 : }
5776 :
5777 3856 : return( CE_None );
5778 : }
5779 :
5780 941 : static int GTiffGetZLevel(char** papszOptions)
5781 : {
5782 941 : int nZLevel = -1;
5783 941 : const char* pszValue = CSLFetchNameValue( papszOptions, "ZLEVEL" );
5784 941 : if( pszValue != NULL )
5785 : {
5786 0 : nZLevel = atoi( pszValue );
5787 0 : if (!(nZLevel >= 1 && nZLevel <= 9))
5788 : {
5789 : CPLError( CE_Warning, CPLE_IllegalArg,
5790 : "ZLEVEL=%s value not recognised, ignoring.",
5791 0 : pszValue );
5792 0 : nZLevel = -1;
5793 : }
5794 : }
5795 941 : return nZLevel;
5796 : }
5797 :
5798 942 : static int GTiffGetJpegQuality(char** papszOptions)
5799 : {
5800 942 : int nJpegQuality = -1;
5801 942 : const char* pszValue = CSLFetchNameValue( papszOptions, "JPEG_QUALITY" );
5802 942 : if( pszValue != NULL )
5803 : {
5804 4 : nJpegQuality = atoi( pszValue );
5805 4 : if (!(nJpegQuality >= 1 && nJpegQuality <= 100))
5806 : {
5807 : CPLError( CE_Warning, CPLE_IllegalArg,
5808 : "JPEG_QUALITY=%s value not recognised, ignoring.",
5809 0 : pszValue );
5810 0 : nJpegQuality = -1;
5811 : }
5812 : }
5813 942 : return nJpegQuality;
5814 : }
5815 :
5816 : /************************************************************************/
5817 : /* GTiffCreate() */
5818 : /* */
5819 : /* Shared functionality between GTiffDataset::Create() and */
5820 : /* GTiffCreateCopy() for creating TIFF file based on a set of */
5821 : /* options and a configuration. */
5822 : /************************************************************************/
5823 :
5824 : TIFF *GTiffDataset::CreateLL( const char * pszFilename,
5825 : int nXSize, int nYSize, int nBands,
5826 : GDALDataType eType,
5827 938 : char **papszParmList )
5828 :
5829 : {
5830 : TIFF *hTIFF;
5831 938 : int nBlockXSize = 0, nBlockYSize = 0;
5832 938 : int bTiled = FALSE;
5833 938 : uint16 nCompression = COMPRESSION_NONE;
5834 938 : int nPredictor = PREDICTOR_NONE, nJpegQuality = -1, nZLevel = -1;
5835 : uint16 nSampleFormat;
5836 : int nPlanar;
5837 : const char *pszValue;
5838 : const char *pszProfile;
5839 938 : int bCreateBigTIFF = FALSE;
5840 :
5841 938 : GTiffOneTimeInit();
5842 :
5843 : /* -------------------------------------------------------------------- */
5844 : /* Blow on a few errors. */
5845 : /* -------------------------------------------------------------------- */
5846 938 : if( nXSize < 1 || nYSize < 1 || nBands < 1 )
5847 : {
5848 : CPLError( CE_Failure, CPLE_AppDefined,
5849 : "Attempt to create %dx%dx%d TIFF file, but width, height and bands\n"
5850 : "must be positive.",
5851 1 : nXSize, nYSize, nBands );
5852 :
5853 1 : return NULL;
5854 : }
5855 :
5856 937 : if (nBands > 65535)
5857 : {
5858 : CPLError( CE_Failure, CPLE_AppDefined,
5859 : "Attempt to create %dx%dx%d TIFF file, but bands\n"
5860 : "must be lesser or equal to 65535.",
5861 0 : nXSize, nYSize, nBands );
5862 :
5863 0 : return NULL;
5864 : }
5865 :
5866 : /* -------------------------------------------------------------------- */
5867 : /* Setup values based on options. */
5868 : /* -------------------------------------------------------------------- */
5869 937 : pszProfile = CSLFetchNameValue(papszParmList,"PROFILE");
5870 937 : if( pszProfile == NULL )
5871 925 : pszProfile = "GDALGeoTIFF";
5872 :
5873 937 : if( CSLFetchBoolean( papszParmList, "TILED", FALSE ) )
5874 18 : bTiled = TRUE;
5875 :
5876 937 : pszValue = CSLFetchNameValue(papszParmList,"BLOCKXSIZE");
5877 937 : if( pszValue != NULL )
5878 10 : nBlockXSize = atoi( pszValue );
5879 :
5880 937 : pszValue = CSLFetchNameValue(papszParmList,"BLOCKYSIZE");
5881 937 : if( pszValue != NULL )
5882 14 : nBlockYSize = atoi( pszValue );
5883 :
5884 937 : pszValue = CSLFetchNameValue(papszParmList,"INTERLEAVE");
5885 937 : if( pszValue != NULL )
5886 : {
5887 23 : if( EQUAL( pszValue, "PIXEL" ) )
5888 13 : nPlanar = PLANARCONFIG_CONTIG;
5889 10 : else if( EQUAL( pszValue, "BAND" ) )
5890 10 : nPlanar = PLANARCONFIG_SEPARATE;
5891 : else
5892 : {
5893 : CPLError( CE_Failure, CPLE_AppDefined,
5894 : "INTERLEAVE=%s unsupported, value must be PIXEL or BAND.",
5895 0 : pszValue );
5896 0 : return NULL;
5897 : }
5898 : }
5899 : else
5900 : {
5901 914 : nPlanar = PLANARCONFIG_CONTIG;
5902 : }
5903 :
5904 937 : pszValue = CSLFetchNameValue( papszParmList, "COMPRESS" );
5905 937 : if( pszValue != NULL )
5906 : {
5907 36 : if( EQUAL( pszValue, "NONE" ) )
5908 1 : nCompression = COMPRESSION_NONE;
5909 35 : else if( EQUAL( pszValue, "JPEG" ) )
5910 7 : nCompression = COMPRESSION_JPEG;
5911 28 : else if( EQUAL( pszValue, "LZW" ) )
5912 15 : nCompression = COMPRESSION_LZW;
5913 13 : else if( EQUAL( pszValue, "PACKBITS" ))
5914 2 : nCompression = COMPRESSION_PACKBITS;
5915 20 : else if( EQUAL( pszValue, "DEFLATE" ) || EQUAL( pszValue, "ZIP" ))
5916 9 : nCompression = COMPRESSION_ADOBE_DEFLATE;
5917 2 : else if( EQUAL( pszValue, "FAX3" )
5918 : || EQUAL( pszValue, "CCITTFAX3" ))
5919 0 : nCompression = COMPRESSION_CCITTFAX3;
5920 4 : else if( EQUAL( pszValue, "FAX4" )
5921 : || EQUAL( pszValue, "CCITTFAX4" ))
5922 2 : nCompression = COMPRESSION_CCITTFAX4;
5923 0 : else if( EQUAL( pszValue, "CCITTRLE" ) )
5924 0 : nCompression = COMPRESSION_CCITTRLE;
5925 : else
5926 : CPLError( CE_Warning, CPLE_IllegalArg,
5927 : "COMPRESS=%s value not recognised, ignoring.",
5928 0 : pszValue );
5929 :
5930 : #if defined(TIFFLIB_VERSION) && TIFFLIB_VERSION > 20031007 /* 3.6.0 */
5931 36 : if (nCompression != COMPRESSION_NONE &&
5932 : !TIFFIsCODECConfigured(nCompression))
5933 : {
5934 : CPLError( CE_Failure, CPLE_AppDefined,
5935 0 : "Cannot create TIFF file due to missing codec for %s.", pszValue );
5936 0 : return NULL;
5937 : }
5938 : #endif
5939 : }
5940 :
5941 937 : pszValue = CSLFetchNameValue( papszParmList, "PREDICTOR" );
5942 937 : if( pszValue != NULL )
5943 4 : nPredictor = atoi( pszValue );
5944 :
5945 937 : nZLevel = GTiffGetZLevel(papszParmList);
5946 :
5947 937 : nJpegQuality = GTiffGetJpegQuality(papszParmList);
5948 :
5949 : /* -------------------------------------------------------------------- */
5950 : /* Compute the uncompressed size. */
5951 : /* -------------------------------------------------------------------- */
5952 : double dfUncompressedImageSize;
5953 :
5954 : dfUncompressedImageSize =
5955 937 : nXSize * ((double)nYSize) * nBands * (GDALGetDataTypeSize(eType)/8);
5956 :
5957 : if( nCompression == COMPRESSION_NONE
5958 : && dfUncompressedImageSize > 4200000000.0 )
5959 : {
5960 : #ifndef BIGTIFF_SUPPORT
5961 : CPLError( CE_Failure, CPLE_NotSupported,
5962 : "A %d pixels x %d lines x %d bands %s image would be larger than 4GB\n"
5963 : "but this is the largest size a TIFF can be, and BigTIFF is unavailable.\n"
5964 : "Creation failed.",
5965 : nXSize, nYSize, nBands, GDALGetDataTypeName(eType) );
5966 : return NULL;
5967 : #endif
5968 : }
5969 :
5970 : /* -------------------------------------------------------------------- */
5971 : /* Should the file be created as a bigtiff file? */
5972 : /* -------------------------------------------------------------------- */
5973 937 : const char *pszBIGTIFF = CSLFetchNameValue(papszParmList, "BIGTIFF");
5974 :
5975 937 : if( pszBIGTIFF == NULL )
5976 933 : pszBIGTIFF = "IF_NEEDED";
5977 :
5978 937 : if( EQUAL(pszBIGTIFF,"IF_NEEDED") )
5979 : {
5980 934 : if( nCompression == COMPRESSION_NONE
5981 : && dfUncompressedImageSize > 4200000000.0 )
5982 9 : bCreateBigTIFF = TRUE;
5983 : }
5984 3 : else if( EQUAL(pszBIGTIFF,"IF_SAFER") )
5985 : {
5986 1 : if( dfUncompressedImageSize > 2000000000.0 )
5987 1 : bCreateBigTIFF = TRUE;
5988 : }
5989 :
5990 : else
5991 : {
5992 2 : bCreateBigTIFF = CSLTestBoolean( pszBIGTIFF );
5993 2 : if (!bCreateBigTIFF && nCompression == COMPRESSION_NONE &&
5994 : dfUncompressedImageSize > 4200000000.0 )
5995 : {
5996 : CPLError( CE_Failure, CPLE_NotSupported,
5997 : "The TIFF file will be larger than 4GB, so BigTIFF is necessary.\n"
5998 1 : "Creation failed.");
5999 1 : return NULL;
6000 : }
6001 : }
6002 :
6003 : #ifndef BIGTIFF_SUPPORT
6004 : if( bCreateBigTIFF )
6005 : {
6006 : CPLError( CE_Warning, CPLE_NotSupported,
6007 : "BigTIFF requested, but GDAL built without BigTIFF\n"
6008 : "enabled libtiff, request ignored." );
6009 : bCreateBigTIFF = FALSE;
6010 : }
6011 : #endif
6012 :
6013 936 : if( bCreateBigTIFF )
6014 11 : CPLDebug( "GTiff", "File being created as a BigTIFF." );
6015 :
6016 : /* -------------------------------------------------------------------- */
6017 : /* Check if the user wishes a particular endianness */
6018 : /* -------------------------------------------------------------------- */
6019 :
6020 936 : int eEndianness = ENDIANNESS_NATIVE;
6021 936 : pszValue = CSLFetchNameValue(papszParmList, "ENDIANNESS");
6022 936 : if ( pszValue == NULL )
6023 932 : pszValue = CPLGetConfigOption( "GDAL_TIFF_ENDIANNESS", NULL );
6024 936 : if ( pszValue != NULL )
6025 : {
6026 413 : if (EQUAL(pszValue, "LITTLE"))
6027 4 : eEndianness = ENDIANNESS_LITTLE;
6028 409 : else if (EQUAL(pszValue, "BIG"))
6029 0 : eEndianness = ENDIANNESS_BIG;
6030 409 : else if (EQUAL(pszValue, "INVERTED"))
6031 : {
6032 : #ifdef CPL_LSB
6033 26 : eEndianness = ENDIANNESS_BIG;
6034 : #else
6035 : eEndianness = ENDIANNESS_LITTLE;
6036 : #endif
6037 : }
6038 383 : else if (!EQUAL(pszValue, "NATIVE"))
6039 : {
6040 : CPLError( CE_Warning, CPLE_NotSupported,
6041 0 : "ENDIANNESS=%s not supported. Defaulting to NATIVE", pszValue );
6042 : }
6043 : }
6044 :
6045 : /* -------------------------------------------------------------------- */
6046 : /* Try opening the dataset. */
6047 : /* -------------------------------------------------------------------- */
6048 :
6049 : char szOpeningFlag[5];
6050 936 : strcpy(szOpeningFlag, "w+");
6051 936 : if (bCreateBigTIFF)
6052 11 : strcat(szOpeningFlag, "8");
6053 936 : if (eEndianness == ENDIANNESS_BIG)
6054 26 : strcat(szOpeningFlag, "b");
6055 910 : else if (eEndianness == ENDIANNESS_LITTLE)
6056 4 : strcat(szOpeningFlag, "l");
6057 936 : hTIFF = VSI_TIFFOpen( pszFilename, szOpeningFlag );
6058 936 : if( hTIFF == NULL )
6059 : {
6060 0 : if( CPLGetLastErrorNo() == 0 )
6061 : CPLError( CE_Failure, CPLE_OpenFailed,
6062 : "Attempt to create new tiff file `%s'\n"
6063 : "failed in XTIFFOpen().\n",
6064 0 : pszFilename );
6065 0 : return NULL;
6066 : }
6067 :
6068 : /* -------------------------------------------------------------------- */
6069 : /* How many bits per sample? We have a special case if NBITS */
6070 : /* specified for GDT_Byte, GDT_UInt16, GDT_UInt32. */
6071 : /* -------------------------------------------------------------------- */
6072 936 : int nBitsPerSample = GDALGetDataTypeSize(eType);
6073 936 : if (CSLFetchNameValue(papszParmList, "NBITS") != NULL)
6074 : {
6075 38 : int nMinBits = 0, nMaxBits = 0;
6076 38 : nBitsPerSample = atoi(CSLFetchNameValue(papszParmList, "NBITS"));
6077 38 : if( eType == GDT_Byte )
6078 : {
6079 13 : nMinBits = 1;
6080 13 : nMaxBits = 8;
6081 : }
6082 25 : else if( eType == GDT_UInt16 )
6083 : {
6084 13 : nMinBits = 9;
6085 13 : nMaxBits = 16;
6086 : }
6087 12 : else if( eType == GDT_UInt32 )
6088 : {
6089 12 : nMinBits = 17;
6090 12 : nMaxBits = 32;
6091 : }
6092 : else
6093 : {
6094 : CPLError(CE_Warning, CPLE_NotSupported,
6095 : "NBITS is not supported for data type %s",
6096 0 : GDALGetDataTypeName(eType));
6097 0 : nBitsPerSample = GDALGetDataTypeSize(eType);
6098 : }
6099 :
6100 38 : if (nMinBits != 0)
6101 : {
6102 38 : if (nBitsPerSample < nMinBits)
6103 : {
6104 : CPLError(CE_Warning, CPLE_AppDefined,
6105 : "NBITS=%d is invalid for data type %s. Using NBITS=%d",
6106 0 : nBitsPerSample, GDALGetDataTypeName(eType), nMinBits);
6107 0 : nBitsPerSample = nMinBits;
6108 : }
6109 38 : else if (nBitsPerSample > nMaxBits)
6110 : {
6111 : CPLError(CE_Warning, CPLE_AppDefined,
6112 : "NBITS=%d is invalid for data type %s. Using NBITS=%d",
6113 0 : nBitsPerSample, GDALGetDataTypeName(eType), nMaxBits);
6114 0 : nBitsPerSample = nMaxBits;
6115 : }
6116 : }
6117 : }
6118 :
6119 : /* -------------------------------------------------------------------- */
6120 : /* Do we have a custom pixel type (just used for signed byte now). */
6121 : /* -------------------------------------------------------------------- */
6122 936 : const char *pszPixelType = CSLFetchNameValue( papszParmList, "PIXELTYPE" );
6123 936 : if( pszPixelType == NULL )
6124 934 : pszPixelType = "";
6125 :
6126 : /* -------------------------------------------------------------------- */
6127 : /* Setup some standard flags. */
6128 : /* -------------------------------------------------------------------- */
6129 936 : TIFFSetField( hTIFF, TIFFTAG_IMAGEWIDTH, nXSize );
6130 936 : TIFFSetField( hTIFF, TIFFTAG_IMAGELENGTH, nYSize );
6131 936 : TIFFSetField( hTIFF, TIFFTAG_BITSPERSAMPLE, nBitsPerSample );
6132 :
6133 1057 : if( (eType == GDT_Byte && EQUAL(pszPixelType,"SIGNEDBYTE"))
6134 : || eType == GDT_Int16 || eType == GDT_Int32 )
6135 121 : nSampleFormat = SAMPLEFORMAT_INT;
6136 917 : else if( eType == GDT_CInt16 || eType == GDT_CInt32 )
6137 102 : nSampleFormat = SAMPLEFORMAT_COMPLEXINT;
6138 835 : else if( eType == GDT_Float32 || eType == GDT_Float64 )
6139 122 : nSampleFormat = SAMPLEFORMAT_IEEEFP;
6140 698 : else if( eType == GDT_CFloat32 || eType == GDT_CFloat64 )
6141 107 : nSampleFormat = SAMPLEFORMAT_COMPLEXIEEEFP;
6142 : else
6143 484 : nSampleFormat = SAMPLEFORMAT_UINT;
6144 :
6145 936 : TIFFSetField( hTIFF, TIFFTAG_SAMPLEFORMAT, nSampleFormat );
6146 936 : TIFFSetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL, nBands );
6147 936 : TIFFSetField( hTIFF, TIFFTAG_PLANARCONFIG, nPlanar );
6148 :
6149 : /* -------------------------------------------------------------------- */
6150 : /* Setup Photometric Interpretation. Take this value from the user */
6151 : /* passed option or guess correct value otherwise. */
6152 : /* -------------------------------------------------------------------- */
6153 936 : int nSamplesAccountedFor = 1;
6154 936 : int bForceColorTable = FALSE;
6155 :
6156 936 : pszValue = CSLFetchNameValue(papszParmList,"PHOTOMETRIC");
6157 936 : if( pszValue != NULL )
6158 : {
6159 15 : if( EQUAL( pszValue, "MINISBLACK" ) )
6160 0 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK );
6161 15 : else if( EQUAL( pszValue, "MINISWHITE" ) )
6162 2 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE );
6163 13 : else if( EQUAL( pszValue, "PALETTE" ))
6164 : {
6165 3 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE );
6166 3 : nSamplesAccountedFor = 1;
6167 3 : bForceColorTable = TRUE;
6168 : }
6169 10 : else if( EQUAL( pszValue, "RGB" ))
6170 : {
6171 2 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB );
6172 2 : nSamplesAccountedFor = 3;
6173 : }
6174 8 : else if( EQUAL( pszValue, "CMYK" ))
6175 : {
6176 2 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_SEPARATED );
6177 2 : nSamplesAccountedFor = 4;
6178 : }
6179 6 : else if( EQUAL( pszValue, "YCBCR" ))
6180 : {
6181 : /* Because of subsampling, setting YCBCR without JPEG compression leads */
6182 : /* to a crash currently. Would need to make GTiffRasterBand::IWriteBlock() */
6183 : /* aware of subsampling so that it doesn't overrun buffer size returned */
6184 : /* by libtiff */
6185 6 : if ( nCompression != COMPRESSION_JPEG )
6186 : {
6187 : CPLError(CE_Failure, CPLE_NotSupported,
6188 0 : "Currently, PHOTOMETRIC=YCBCR requires COMPRESS=JPEG");
6189 0 : XTIFFClose(hTIFF);
6190 0 : return NULL;
6191 : }
6192 :
6193 6 : if ( nPlanar == PLANARCONFIG_SEPARATE )
6194 : {
6195 : CPLError(CE_Failure, CPLE_NotSupported,
6196 0 : "PHOTOMETRIC=YCBCR requires INTERLEAVE=PIXEL");
6197 0 : XTIFFClose(hTIFF);
6198 0 : return NULL;
6199 : }
6200 :
6201 : /* YCBCR strictly requires 3 bands. Not less, not more */
6202 : /* Issue an explicit error message as libtiff one is a bit cryptic : */
6203 : /* TIFFVStripSize64:Invalid td_samplesperpixel value */
6204 6 : if ( nBands != 3 )
6205 : {
6206 : CPLError(CE_Failure, CPLE_NotSupported,
6207 0 : "PHOTOMETRIC=YCBCR requires a source raster with only 3 bands (RGB)");
6208 0 : XTIFFClose(hTIFF);
6209 0 : return NULL;
6210 : }
6211 :
6212 6 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR );
6213 6 : nSamplesAccountedFor = 3;
6214 : }
6215 0 : else if( EQUAL( pszValue, "CIELAB" ))
6216 : {
6217 0 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_CIELAB );
6218 0 : nSamplesAccountedFor = 3;
6219 : }
6220 0 : else if( EQUAL( pszValue, "ICCLAB" ))
6221 : {
6222 0 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_ICCLAB );
6223 0 : nSamplesAccountedFor = 3;
6224 : }
6225 0 : else if( EQUAL( pszValue, "ITULAB" ))
6226 : {
6227 0 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_ITULAB );
6228 0 : nSamplesAccountedFor = 3;
6229 : }
6230 : else
6231 : {
6232 : CPLError( CE_Warning, CPLE_IllegalArg,
6233 : "PHOTOMETRIC=%s value not recognised, ignoring.\n"
6234 : "Set the Photometric Interpretation as MINISBLACK.",
6235 0 : pszValue );
6236 0 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK );
6237 : }
6238 :
6239 15 : if ( nBands < nSamplesAccountedFor )
6240 : {
6241 : CPLError( CE_Warning, CPLE_IllegalArg,
6242 : "PHOTOMETRIC=%s value does not correspond to number "
6243 : "of bands (%d), ignoring.\n"
6244 : "Set the Photometric Interpretation as MINISBLACK.",
6245 0 : pszValue, nBands );
6246 0 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK );
6247 : }
6248 : }
6249 : else
6250 : {
6251 : /*
6252 : * If image contains 3 or 4 bands and datatype is Byte then we will
6253 : * assume it is RGB. In all other cases assume it is MINISBLACK.
6254 : */
6255 962 : if( nBands == 3 && eType == GDT_Byte )
6256 : {
6257 41 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB );
6258 41 : nSamplesAccountedFor = 3;
6259 : }
6260 900 : else if( nBands == 4 && eType == GDT_Byte )
6261 : {
6262 : uint16 v[1];
6263 :
6264 20 : v[0] = EXTRASAMPLE_ASSOCALPHA;
6265 20 : TIFFSetField(hTIFF, TIFFTAG_EXTRASAMPLES, 1, v);
6266 20 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB );
6267 20 : nSamplesAccountedFor = 4;
6268 : }
6269 : else
6270 : {
6271 860 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK );
6272 860 : nSamplesAccountedFor = 1;
6273 : }
6274 : }
6275 :
6276 : /* -------------------------------------------------------------------- */
6277 : /* If there are extra samples, we need to mark them with an */
6278 : /* appropriate extrasamples definition here. */
6279 : /* -------------------------------------------------------------------- */
6280 936 : if( nBands > nSamplesAccountedFor )
6281 : {
6282 : uint16 *v;
6283 : int i;
6284 71 : int nExtraSamples = nBands - nSamplesAccountedFor;
6285 :
6286 71 : v = (uint16 *) CPLMalloc( sizeof(uint16) * nExtraSamples );
6287 :
6288 71 : if( CSLFetchBoolean(papszParmList,"ALPHA",FALSE) )
6289 1 : v[0] = EXTRASAMPLE_ASSOCALPHA;
6290 : else
6291 70 : v[0] = EXTRASAMPLE_UNSPECIFIED;
6292 :
6293 131193 : for( i = 1; i < nExtraSamples; i++ )
6294 131122 : v[i] = EXTRASAMPLE_UNSPECIFIED;
6295 :
6296 71 : TIFFSetField(hTIFF, TIFFTAG_EXTRASAMPLES, nExtraSamples, v );
6297 :
6298 71 : CPLFree(v);
6299 : }
6300 :
6301 : /* Set the compression method before asking the default strip size */
6302 : /* This is usefull when translating to a JPEG-In-TIFF file where */
6303 : /* the default strip size is 8 or 16 depending on the photometric value */
6304 936 : TIFFSetField( hTIFF, TIFFTAG_COMPRESSION, nCompression );
6305 :
6306 : /* -------------------------------------------------------------------- */
6307 : /* Setup tiling/stripping flags. */
6308 : /* -------------------------------------------------------------------- */
6309 936 : if( bTiled )
6310 : {
6311 18 : if( nBlockXSize == 0 )
6312 8 : nBlockXSize = 256;
6313 :
6314 18 : if( nBlockYSize == 0 )
6315 8 : nBlockYSize = 256;
6316 :
6317 18 : if (!TIFFSetField( hTIFF, TIFFTAG_TILEWIDTH, nBlockXSize ) ||
6318 : !TIFFSetField( hTIFF, TIFFTAG_TILELENGTH, nBlockYSize ))
6319 : {
6320 0 : XTIFFClose(hTIFF);
6321 0 : return NULL;
6322 : }
6323 : }
6324 : else
6325 : {
6326 : uint32 nRowsPerStrip;
6327 :
6328 918 : if( nBlockYSize == 0 )
6329 914 : nRowsPerStrip = MIN(nYSize, (int)TIFFDefaultStripSize(hTIFF,0));
6330 : else
6331 4 : nRowsPerStrip = nBlockYSize;
6332 :
6333 918 : TIFFSetField( hTIFF, TIFFTAG_ROWSPERSTRIP, nRowsPerStrip );
6334 : }
6335 :
6336 : /* -------------------------------------------------------------------- */
6337 : /* Set compression related tags. */
6338 : /* -------------------------------------------------------------------- */
6339 936 : if ( nCompression == COMPRESSION_LZW ||
6340 : nCompression == COMPRESSION_ADOBE_DEFLATE )
6341 24 : TIFFSetField( hTIFF, TIFFTAG_PREDICTOR, nPredictor );
6342 936 : if (nCompression == COMPRESSION_ADOBE_DEFLATE
6343 : && nZLevel != -1)
6344 0 : TIFFSetField( hTIFF, TIFFTAG_ZIPQUALITY, nZLevel );
6345 936 : if( nCompression == COMPRESSION_JPEG
6346 : && nJpegQuality != -1 )
6347 2 : TIFFSetField( hTIFF, TIFFTAG_JPEGQUALITY, nJpegQuality );
6348 :
6349 : /* -------------------------------------------------------------------- */
6350 : /* If we forced production of a file with photometric=palette, */
6351 : /* we need to push out a default color table. */
6352 : /* -------------------------------------------------------------------- */
6353 936 : if( bForceColorTable )
6354 : {
6355 : int nColors;
6356 :
6357 3 : if( eType == GDT_Byte )
6358 3 : nColors = 256;
6359 : else
6360 0 : nColors = 65536;
6361 :
6362 : unsigned short *panTRed, *panTGreen, *panTBlue;
6363 :
6364 3 : panTRed = (unsigned short *) CPLMalloc(sizeof(unsigned short)*nColors);
6365 3 : panTGreen = (unsigned short *) CPLMalloc(sizeof(unsigned short)*nColors);
6366 3 : panTBlue = (unsigned short *) CPLMalloc(sizeof(unsigned short)*nColors);
6367 :
6368 771 : for( int iColor = 0; iColor < nColors; iColor++ )
6369 : {
6370 768 : if( eType == GDT_Byte )
6371 : {
6372 768 : panTRed[iColor] = (unsigned short) (257 * iColor);
6373 768 : panTGreen[iColor] = (unsigned short) (257 * iColor);
6374 768 : panTBlue[iColor] = (unsigned short) (257 * iColor);
6375 : }
6376 : else
6377 : {
6378 0 : panTRed[iColor] = (unsigned short) iColor;
6379 0 : panTGreen[iColor] = (unsigned short) iColor;
6380 0 : panTBlue[iColor] = (unsigned short) iColor;
6381 : }
6382 : }
6383 :
6384 : TIFFSetField( hTIFF, TIFFTAG_COLORMAP,
6385 3 : panTRed, panTGreen, panTBlue );
6386 :
6387 3 : CPLFree( panTRed );
6388 3 : CPLFree( panTGreen );
6389 3 : CPLFree( panTBlue );
6390 : }
6391 :
6392 936 : return( hTIFF );
6393 : }
6394 :
6395 : /************************************************************************/
6396 : /* Create() */
6397 : /* */
6398 : /* Create a new GeoTIFF or TIFF file. */
6399 : /************************************************************************/
6400 :
6401 : GDALDataset *GTiffDataset::Create( const char * pszFilename,
6402 : int nXSize, int nYSize, int nBands,
6403 : GDALDataType eType,
6404 781 : char **papszParmList )
6405 :
6406 : {
6407 : GTiffDataset * poDS;
6408 : TIFF *hTIFF;
6409 :
6410 : /* -------------------------------------------------------------------- */
6411 : /* Create the underlying TIFF file. */
6412 : /* -------------------------------------------------------------------- */
6413 : hTIFF = CreateLL( pszFilename, nXSize, nYSize, nBands,
6414 781 : eType, papszParmList );
6415 :
6416 781 : if( hTIFF == NULL )
6417 2 : return NULL;
6418 :
6419 : /* -------------------------------------------------------------------- */
6420 : /* Create the new GTiffDataset object. */
6421 : /* -------------------------------------------------------------------- */
6422 779 : poDS = new GTiffDataset();
6423 779 : poDS->hTIFF = hTIFF;
6424 779 : poDS->poActiveDS = poDS;
6425 779 : poDS->ppoActiveDSRef = &(poDS->poActiveDS);
6426 :
6427 779 : poDS->nRasterXSize = nXSize;
6428 779 : poDS->nRasterYSize = nYSize;
6429 779 : poDS->eAccess = GA_Update;
6430 779 : poDS->bCrystalized = FALSE;
6431 779 : poDS->nSamplesPerPixel = (uint16) nBands;
6432 1558 : poDS->osFilename = pszFilename;
6433 :
6434 : /* Avoid premature crystalization that will cause directory re-writting */
6435 : /* if GetProjectionRef() or GetGeoTransform() are called on the newly created GeoTIFF */
6436 779 : poDS->bLookedForProjection = TRUE;
6437 :
6438 779 : TIFFGetField( hTIFF, TIFFTAG_SAMPLEFORMAT, &(poDS->nSampleFormat) );
6439 779 : TIFFGetField( hTIFF, TIFFTAG_PLANARCONFIG, &(poDS->nPlanarConfig) );
6440 779 : TIFFGetField( hTIFF, TIFFTAG_PHOTOMETRIC, &(poDS->nPhotometric) );
6441 779 : TIFFGetField( hTIFF, TIFFTAG_BITSPERSAMPLE, &(poDS->nBitsPerSample) );
6442 779 : TIFFGetField( hTIFF, TIFFTAG_COMPRESSION, &(poDS->nCompression) );
6443 :
6444 779 : if( TIFFIsTiled(hTIFF) )
6445 : {
6446 15 : TIFFGetField( hTIFF, TIFFTAG_TILEWIDTH, &(poDS->nBlockXSize) );
6447 15 : TIFFGetField( hTIFF, TIFFTAG_TILELENGTH, &(poDS->nBlockYSize) );
6448 : }
6449 : else
6450 : {
6451 764 : if( !TIFFGetField( hTIFF, TIFFTAG_ROWSPERSTRIP,
6452 : &(poDS->nRowsPerStrip) ) )
6453 0 : poDS->nRowsPerStrip = 1; /* dummy value */
6454 :
6455 764 : poDS->nBlockXSize = nXSize;
6456 764 : poDS->nBlockYSize = MIN((int)poDS->nRowsPerStrip,nYSize);
6457 : }
6458 :
6459 : poDS->nBlocksPerBand =
6460 : ((nYSize + poDS->nBlockYSize - 1) / poDS->nBlockYSize)
6461 779 : * ((nXSize + poDS->nBlockXSize - 1) / poDS->nBlockXSize);
6462 :
6463 779 : if( CSLFetchNameValue( papszParmList, "PROFILE" ) != NULL )
6464 4 : poDS->osProfile = CSLFetchNameValue( papszParmList, "PROFILE" );
6465 :
6466 : /* -------------------------------------------------------------------- */
6467 : /* YCbCr JPEG compressed images should be translated on the fly */
6468 : /* to RGB by libtiff/libjpeg unless specifically requested */
6469 : /* otherwise. */
6470 : /* -------------------------------------------------------------------- */
6471 779 : if( poDS->nCompression == COMPRESSION_JPEG
6472 : && poDS->nPhotometric == PHOTOMETRIC_YCBCR
6473 : && CSLTestBoolean( CPLGetConfigOption("CONVERT_YCBCR_TO_RGB",
6474 : "YES") ) )
6475 : {
6476 : int nColorMode;
6477 :
6478 1 : poDS->SetMetadataItem( "SOURCE_COLOR_SPACE", "YCbCr", "IMAGE_STRUCTURE" );
6479 1 : if ( !TIFFGetField( hTIFF, TIFFTAG_JPEGCOLORMODE, &nColorMode ) ||
6480 : nColorMode != JPEGCOLORMODE_RGB )
6481 1 : TIFFSetField(hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
6482 : }
6483 :
6484 : /* -------------------------------------------------------------------- */
6485 : /* Read palette back as a color table if it has one. */
6486 : /* -------------------------------------------------------------------- */
6487 : unsigned short *panRed, *panGreen, *panBlue;
6488 :
6489 779 : if( poDS->nPhotometric == PHOTOMETRIC_PALETTE
6490 : && TIFFGetField( hTIFF, TIFFTAG_COLORMAP,
6491 : &panRed, &panGreen, &panBlue) )
6492 : {
6493 : int nColorCount;
6494 : GDALColorEntry oEntry;
6495 :
6496 3 : poDS->poColorTable = new GDALColorTable();
6497 :
6498 3 : nColorCount = 1 << poDS->nBitsPerSample;
6499 :
6500 771 : for( int iColor = nColorCount - 1; iColor >= 0; iColor-- )
6501 : {
6502 768 : oEntry.c1 = panRed[iColor] / 256;
6503 768 : oEntry.c2 = panGreen[iColor] / 256;
6504 768 : oEntry.c3 = panBlue[iColor] / 256;
6505 768 : oEntry.c4 = 255;
6506 :
6507 768 : poDS->poColorTable->SetColorEntry( iColor, &oEntry );
6508 : }
6509 : }
6510 :
6511 : /* -------------------------------------------------------------------- */
6512 : /* Do we want to ensure all blocks get written out on close to */
6513 : /* avoid sparse files? */
6514 : /* -------------------------------------------------------------------- */
6515 779 : if( !CSLFetchBoolean( papszParmList, "SPARSE_OK", FALSE ) )
6516 764 : poDS->bFillEmptyTiles = TRUE;
6517 :
6518 : /* -------------------------------------------------------------------- */
6519 : /* Preserve creation options for consulting later (for instance */
6520 : /* to decide if a TFW file should be written). */
6521 : /* -------------------------------------------------------------------- */
6522 779 : poDS->papszCreationOptions = CSLDuplicate( papszParmList );
6523 :
6524 : /* -------------------------------------------------------------------- */
6525 : /* Create band information objects. */
6526 : /* -------------------------------------------------------------------- */
6527 : int iBand;
6528 :
6529 132821 : for( iBand = 0; iBand < nBands; iBand++ )
6530 : {
6531 264061 : if( poDS->nBitsPerSample == 8 ||
6532 : poDS->nBitsPerSample == 16 ||
6533 : poDS->nBitsPerSample == 32 ||
6534 : poDS->nBitsPerSample == 64 ||
6535 : poDS->nBitsPerSample == 128)
6536 132019 : poDS->SetBand( iBand+1, new GTiffRasterBand( poDS, iBand+1 ) );
6537 : else
6538 : {
6539 23 : poDS->SetBand( iBand+1, new GTiffOddBitsBand( poDS, iBand+1 ) );
6540 : poDS->GetRasterBand( iBand+1 )->
6541 : SetMetadataItem( "NBITS",
6542 : CPLString().Printf("%d",poDS->nBitsPerSample),
6543 46 : "IMAGE_STRUCTURE" );
6544 : }
6545 : }
6546 :
6547 779 : poDS->oOvManager.Initialize( poDS, pszFilename );
6548 :
6549 779 : return( poDS );
6550 : }
6551 :
6552 : /************************************************************************/
6553 : /* CreateCopy() */
6554 : /************************************************************************/
6555 :
6556 : GDALDataset *
6557 : GTiffDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
6558 : int bStrict, char ** papszOptions,
6559 158 : GDALProgressFunc pfnProgress, void * pProgressData )
6560 :
6561 : {
6562 : TIFF *hTIFF;
6563 158 : int nXSize = poSrcDS->GetRasterXSize();
6564 158 : int nYSize = poSrcDS->GetRasterYSize();
6565 158 : int nBands = poSrcDS->GetRasterCount();
6566 : int iBand;
6567 158 : CPLErr eErr = CE_None;
6568 : uint16 nPlanarConfig;
6569 : uint16 nBitsPerSample;
6570 : GDALRasterBand *poPBand;
6571 :
6572 158 : if( poSrcDS->GetRasterCount() == 0 )
6573 : {
6574 : CPLError( CE_Failure, CPLE_AppDefined,
6575 1 : "Unable to export GeoTIFF files with zero bands." );
6576 1 : return NULL;
6577 : }
6578 :
6579 157 : poPBand = poSrcDS->GetRasterBand(1);
6580 157 : GDALDataType eType = poPBand->GetRasterDataType();
6581 :
6582 : /* -------------------------------------------------------------------- */
6583 : /* Check, whether all bands in input dataset has the same type. */
6584 : /* -------------------------------------------------------------------- */
6585 251 : for ( iBand = 2; iBand <= nBands; iBand++ )
6586 : {
6587 94 : if ( eType != poSrcDS->GetRasterBand(iBand)->GetRasterDataType() )
6588 : {
6589 0 : if ( bStrict )
6590 : {
6591 : CPLError( CE_Failure, CPLE_AppDefined,
6592 : "Unable to export GeoTIFF file with different datatypes per\n"
6593 0 : "different bands. All bands should have the same types in TIFF." );
6594 0 : return NULL;
6595 : }
6596 : else
6597 : {
6598 : CPLError( CE_Warning, CPLE_AppDefined,
6599 : "Unable to export GeoTIFF file with different datatypes per\n"
6600 0 : "different bands. All bands should have the same types in TIFF." );
6601 : }
6602 : }
6603 : }
6604 :
6605 157 : if( !pfnProgress( 0.0, NULL, pProgressData ) )
6606 0 : return NULL;
6607 :
6608 : /* -------------------------------------------------------------------- */
6609 : /* Capture the profile. */
6610 : /* -------------------------------------------------------------------- */
6611 : const char *pszProfile;
6612 : int bGeoTIFF;
6613 :
6614 157 : pszProfile = CSLFetchNameValue(papszOptions,"PROFILE");
6615 157 : if( pszProfile == NULL )
6616 149 : pszProfile = "GDALGeoTIFF";
6617 :
6618 157 : if( !EQUAL(pszProfile,"BASELINE")
6619 : && !EQUAL(pszProfile,"GeoTIFF")
6620 : && !EQUAL(pszProfile,"GDALGeoTIFF") )
6621 : {
6622 : CPLError( CE_Failure, CPLE_AppDefined,
6623 : "PROFILE=%s not supported in GTIFF driver.",
6624 0 : pszProfile );
6625 0 : return NULL;
6626 : }
6627 :
6628 157 : if( EQUAL(pszProfile,"BASELINE") )
6629 5 : bGeoTIFF = FALSE;
6630 : else
6631 152 : bGeoTIFF = TRUE;
6632 :
6633 : /* -------------------------------------------------------------------- */
6634 : /* Special handling for NBITS. Copy from band metadata if found. */
6635 : /* -------------------------------------------------------------------- */
6636 157 : char **papszCreateOptions = CSLDuplicate( papszOptions );
6637 :
6638 157 : if( poPBand->GetMetadataItem( "NBITS", "IMAGE_STRUCTURE" ) != NULL
6639 : && atoi(poPBand->GetMetadataItem( "NBITS", "IMAGE_STRUCTURE" )) > 0
6640 : && CSLFetchNameValue( papszCreateOptions, "NBITS") == NULL )
6641 : {
6642 : papszCreateOptions =
6643 : CSLSetNameValue( papszCreateOptions, "NBITS",
6644 : poPBand->GetMetadataItem( "NBITS",
6645 3 : "IMAGE_STRUCTURE" ) );
6646 : }
6647 :
6648 157 : if( CSLFetchNameValue( papszOptions, "PIXELTYPE" ) == NULL
6649 : && eType == GDT_Byte
6650 : && poPBand->GetMetadataItem( "PIXELTYPE", "IMAGE_STRUCTURE" ) )
6651 : {
6652 : papszCreateOptions =
6653 : CSLSetNameValue( papszCreateOptions, "PIXELTYPE",
6654 : poPBand->GetMetadataItem(
6655 0 : "PIXELTYPE", "IMAGE_STRUCTURE" ) );
6656 : }
6657 :
6658 : /* -------------------------------------------------------------------- */
6659 : /* Create the file. */
6660 : /* -------------------------------------------------------------------- */
6661 : hTIFF = CreateLL( pszFilename, nXSize, nYSize, nBands,
6662 157 : eType, papszCreateOptions );
6663 :
6664 157 : CSLDestroy( papszCreateOptions );
6665 :
6666 157 : if( hTIFF == NULL )
6667 0 : return NULL;
6668 :
6669 157 : TIFFGetField( hTIFF, TIFFTAG_PLANARCONFIG, &nPlanarConfig );
6670 157 : TIFFGetField(hTIFF, TIFFTAG_BITSPERSAMPLE, &nBitsPerSample );
6671 :
6672 : /* -------------------------------------------------------------------- */
6673 : /* Are we really producing an RGBA image? If so, set the */
6674 : /* associated alpha information. */
6675 : /* -------------------------------------------------------------------- */
6676 : int bForcePhotometric =
6677 157 : CSLFetchNameValue(papszOptions,"PHOTOMETRIC") != NULL;
6678 :
6679 157 : if( nBands == 4 && !bForcePhotometric
6680 : && poSrcDS->GetRasterBand(4)->GetColorInterpretation()==GCI_AlphaBand)
6681 : {
6682 : uint16 v[1];
6683 :
6684 2 : v[0] = EXTRASAMPLE_ASSOCALPHA;
6685 2 : TIFFSetField(hTIFF, TIFFTAG_EXTRASAMPLES, 1, v);
6686 2 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB );
6687 : }
6688 :
6689 : /* -------------------------------------------------------------------- */
6690 : /* If the output is jpeg compressed, and the input is RGB make */
6691 : /* sure we note that. */
6692 : /* -------------------------------------------------------------------- */
6693 : uint16 nCompression;
6694 :
6695 157 : if( !TIFFGetField( hTIFF, TIFFTAG_COMPRESSION, &(nCompression) ) )
6696 0 : nCompression = COMPRESSION_NONE;
6697 :
6698 157 : if( nCompression == COMPRESSION_JPEG )
6699 : {
6700 5 : if( nBands >= 3
6701 : && (poSrcDS->GetRasterBand(1)->GetColorInterpretation()
6702 : == GCI_YCbCr_YBand)
6703 : && (poSrcDS->GetRasterBand(2)->GetColorInterpretation()
6704 : == GCI_YCbCr_CbBand)
6705 : && (poSrcDS->GetRasterBand(3)->GetColorInterpretation()
6706 : == GCI_YCbCr_CrBand) )
6707 : {
6708 : /* do nothing ... */
6709 : }
6710 : else
6711 : {
6712 : /* we assume RGB if it isn't explicitly YCbCr */
6713 5 : CPLDebug( "GTiff", "Setting JPEGCOLORMODE_RGB" );
6714 5 : TIFFSetField( hTIFF, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB );
6715 : }
6716 : }
6717 :
6718 : /* -------------------------------------------------------------------- */
6719 : /* Does the source image consist of one band, with a palette? */
6720 : /* If so, copy over. */
6721 : /* -------------------------------------------------------------------- */
6722 157 : if( (nBands == 1 || nBands == 2) && poSrcDS->GetRasterBand(1)->GetColorTable() != NULL
6723 : && eType == GDT_Byte )
6724 : {
6725 : unsigned short anTRed[256], anTGreen[256], anTBlue[256];
6726 : GDALColorTable *poCT;
6727 :
6728 4 : poCT = poSrcDS->GetRasterBand(1)->GetColorTable();
6729 :
6730 1028 : for( int iColor = 0; iColor < 256; iColor++ )
6731 : {
6732 1024 : if( iColor < poCT->GetColorEntryCount() )
6733 : {
6734 : GDALColorEntry sRGB;
6735 :
6736 477 : poCT->GetColorEntryAsRGB( iColor, &sRGB );
6737 :
6738 477 : anTRed[iColor] = (unsigned short) (257 * sRGB.c1);
6739 477 : anTGreen[iColor] = (unsigned short) (257 * sRGB.c2);
6740 477 : anTBlue[iColor] = (unsigned short) (257 * sRGB.c3);
6741 : }
6742 : else
6743 : {
6744 547 : anTRed[iColor] = anTGreen[iColor] = anTBlue[iColor] = 0;
6745 : }
6746 : }
6747 :
6748 4 : if( !bForcePhotometric )
6749 4 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE );
6750 4 : TIFFSetField( hTIFF, TIFFTAG_COLORMAP, anTRed, anTGreen, anTBlue );
6751 : }
6752 153 : else if( (nBands == 1 || nBands == 2)
6753 : && poSrcDS->GetRasterBand(1)->GetColorTable() != NULL
6754 : && eType == GDT_UInt16 )
6755 : {
6756 : unsigned short *panTRed, *panTGreen, *panTBlue;
6757 : GDALColorTable *poCT;
6758 :
6759 1 : panTRed = (unsigned short *) CPLMalloc(65536*sizeof(unsigned short));
6760 1 : panTGreen = (unsigned short *) CPLMalloc(65536*sizeof(unsigned short));
6761 1 : panTBlue = (unsigned short *) CPLMalloc(65536*sizeof(unsigned short));
6762 :
6763 1 : poCT = poSrcDS->GetRasterBand(1)->GetColorTable();
6764 :
6765 65537 : for( int iColor = 0; iColor < 65536; iColor++ )
6766 : {
6767 65536 : if( iColor < poCT->GetColorEntryCount() )
6768 : {
6769 : GDALColorEntry sRGB;
6770 :
6771 65536 : poCT->GetColorEntryAsRGB( iColor, &sRGB );
6772 :
6773 65536 : panTRed[iColor] = (unsigned short) (256 * sRGB.c1);
6774 65536 : panTGreen[iColor] = (unsigned short) (256 * sRGB.c2);
6775 65536 : panTBlue[iColor] = (unsigned short) (256 * sRGB.c3);
6776 : }
6777 : else
6778 : {
6779 0 : panTRed[iColor] = panTGreen[iColor] = panTBlue[iColor] = 0;
6780 : }
6781 : }
6782 :
6783 1 : if( !bForcePhotometric )
6784 1 : TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE );
6785 1 : TIFFSetField( hTIFF, TIFFTAG_COLORMAP, panTRed, panTGreen, panTBlue );
6786 :
6787 1 : CPLFree( panTRed );
6788 1 : CPLFree( panTGreen );
6789 1 : CPLFree( panTBlue );
6790 : }
6791 152 : else if( poSrcDS->GetRasterBand(1)->GetColorTable() != NULL )
6792 : CPLError( CE_Warning, CPLE_AppDefined,
6793 : "Unable to export color table to GeoTIFF file. Color tables\n"
6794 0 : "can only be written to 1 band or 2 bands Byte or UInt16 GeoTIFF files." );
6795 :
6796 157 : if( nBands == 2
6797 : && poSrcDS->GetRasterBand(1)->GetColorTable() != NULL
6798 : && (eType == GDT_Byte || eType == GDT_UInt16) )
6799 : {
6800 1 : uint16 v[1] = { EXTRASAMPLE_UNASSALPHA };
6801 :
6802 1 : TIFFSetField(hTIFF, TIFFTAG_EXTRASAMPLES, 1, v );
6803 : }
6804 :
6805 : /* -------------------------------------------------------------------- */
6806 : /* Transfer some TIFF specific metadata, if available. */
6807 : /* The return value will tell us if we need to try again later with*/
6808 : /* PAM because the profile doesn't allow to write some metadata */
6809 : /* as TIFF tag */
6810 : /* -------------------------------------------------------------------- */
6811 : int bHasWrittenMDInGeotiffTAG =
6812 : GTiffDataset::WriteMetadata( poSrcDS, hTIFF, FALSE, pszProfile,
6813 157 : pszFilename, papszOptions );
6814 :
6815 : /* -------------------------------------------------------------------- */
6816 : /* Write NoData value, if exist. */
6817 : /* -------------------------------------------------------------------- */
6818 157 : if( EQUAL(pszProfile,"GDALGeoTIFF") )
6819 : {
6820 : int bSuccess;
6821 : double dfNoData;
6822 :
6823 150 : dfNoData = poSrcDS->GetRasterBand(1)->GetNoDataValue( &bSuccess );
6824 150 : if ( bSuccess )
6825 20 : GTiffDataset::WriteNoDataValue( hTIFF, dfNoData );
6826 : }
6827 :
6828 : /* -------------------------------------------------------------------- */
6829 : /* Write affine transform if it is meaningful. */
6830 : /* -------------------------------------------------------------------- */
6831 157 : const char *pszProjection = NULL;
6832 : double adfGeoTransform[6];
6833 :
6834 157 : if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None
6835 : && (adfGeoTransform[0] != 0.0 || adfGeoTransform[1] != 1.0
6836 : || adfGeoTransform[2] != 0.0 || adfGeoTransform[3] != 0.0
6837 : || adfGeoTransform[4] != 0.0 || ABS(adfGeoTransform[5]) != 1.0 ))
6838 : {
6839 108 : if( bGeoTIFF )
6840 : {
6841 207 : if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0
6842 : && adfGeoTransform[5] < 0.0 )
6843 : {
6844 :
6845 : double adfPixelScale[3], adfTiePoints[6];
6846 :
6847 103 : adfPixelScale[0] = adfGeoTransform[1];
6848 103 : adfPixelScale[1] = fabs(adfGeoTransform[5]);
6849 103 : adfPixelScale[2] = 0.0;
6850 :
6851 103 : TIFFSetField( hTIFF, TIFFTAG_GEOPIXELSCALE, 3, adfPixelScale );
6852 :
6853 103 : adfTiePoints[0] = 0.0;
6854 103 : adfTiePoints[1] = 0.0;
6855 103 : adfTiePoints[2] = 0.0;
6856 103 : adfTiePoints[3] = adfGeoTransform[0];
6857 103 : adfTiePoints[4] = adfGeoTransform[3];
6858 103 : adfTiePoints[5] = 0.0;
6859 :
6860 103 : TIFFSetField( hTIFF, TIFFTAG_GEOTIEPOINTS, 6, adfTiePoints );
6861 : }
6862 : else
6863 : {
6864 : double adfMatrix[16];
6865 :
6866 1 : memset(adfMatrix,0,sizeof(double) * 16);
6867 :
6868 1 : adfMatrix[0] = adfGeoTransform[1];
6869 1 : adfMatrix[1] = adfGeoTransform[2];
6870 1 : adfMatrix[3] = adfGeoTransform[0];
6871 1 : adfMatrix[4] = adfGeoTransform[4];
6872 1 : adfMatrix[5] = adfGeoTransform[5];
6873 1 : adfMatrix[7] = adfGeoTransform[3];
6874 1 : adfMatrix[15] = 1.0;
6875 :
6876 1 : TIFFSetField( hTIFF, TIFFTAG_GEOTRANSMATRIX, 16, adfMatrix );
6877 : }
6878 :
6879 104 : pszProjection = poSrcDS->GetProjectionRef();
6880 : }
6881 :
6882 : /* -------------------------------------------------------------------- */
6883 : /* Do we need a TFW file? */
6884 : /* -------------------------------------------------------------------- */
6885 108 : if( CSLFetchBoolean( papszOptions, "TFW", FALSE ) )
6886 1 : GDALWriteWorldFile( pszFilename, "tfw", adfGeoTransform );
6887 107 : else if( CSLFetchBoolean( papszOptions, "WORLDFILE", FALSE ) )
6888 1 : GDALWriteWorldFile( pszFilename, "wld", adfGeoTransform );
6889 : }
6890 :
6891 : /* -------------------------------------------------------------------- */
6892 : /* Otherwise write tiepoints if they are available. */
6893 : /* -------------------------------------------------------------------- */
6894 49 : else if( poSrcDS->GetGCPCount() > 0 && bGeoTIFF )
6895 : {
6896 3 : const GDAL_GCP *pasGCPs = poSrcDS->GetGCPs();
6897 : double *padfTiePoints;
6898 :
6899 : padfTiePoints = (double *)
6900 3 : CPLMalloc(6*sizeof(double)*poSrcDS->GetGCPCount());
6901 :
6902 15 : for( int iGCP = 0; iGCP < poSrcDS->GetGCPCount(); iGCP++ )
6903 : {
6904 :
6905 12 : padfTiePoints[iGCP*6+0] = pasGCPs[iGCP].dfGCPPixel;
6906 12 : padfTiePoints[iGCP*6+1] = pasGCPs[iGCP].dfGCPLine;
6907 12 : padfTiePoints[iGCP*6+2] = 0;
6908 12 : padfTiePoints[iGCP*6+3] = pasGCPs[iGCP].dfGCPX;
6909 12 : padfTiePoints[iGCP*6+4] = pasGCPs[iGCP].dfGCPY;
6910 12 : padfTiePoints[iGCP*6+5] = pasGCPs[iGCP].dfGCPZ;
6911 : }
6912 :
6913 : TIFFSetField( hTIFF, TIFFTAG_GEOTIEPOINTS,
6914 3 : 6*poSrcDS->GetGCPCount(), padfTiePoints );
6915 3 : CPLFree( padfTiePoints );
6916 :
6917 3 : pszProjection = poSrcDS->GetGCPProjection();
6918 :
6919 3 : if( CSLFetchBoolean( papszOptions, "TFW", FALSE )
6920 : || CSLFetchBoolean( papszOptions, "WORLDFILE", FALSE ) )
6921 : {
6922 : CPLError(CE_Warning, CPLE_AppDefined,
6923 0 : "TFW=ON or WORLDFILE=ON creation options are ignored when GCPs are available");
6924 : }
6925 : }
6926 :
6927 : else
6928 46 : pszProjection = poSrcDS->GetProjectionRef();
6929 :
6930 : /* -------------------------------------------------------------------- */
6931 : /* Write the projection information, if possible. */
6932 : /* -------------------------------------------------------------------- */
6933 157 : if( pszProjection != NULL && strlen(pszProjection) > 0 && bGeoTIFF )
6934 : {
6935 : GTIF *psGTIF;
6936 :
6937 105 : psGTIF = GTIFNew( hTIFF );
6938 105 : GTIFSetFromOGISDefn( psGTIF, pszProjection );
6939 :
6940 105 : if( poSrcDS->GetMetadataItem( GDALMD_AREA_OR_POINT )
6941 : && EQUAL(poSrcDS->GetMetadataItem(GDALMD_AREA_OR_POINT),
6942 : GDALMD_AOP_POINT) )
6943 : {
6944 : GTIFKeySet(psGTIF, GTRasterTypeGeoKey, TYPE_SHORT, 1,
6945 3 : RasterPixelIsPoint);
6946 : }
6947 :
6948 105 : GTIFWriteKeys( psGTIF );
6949 105 : GTIFFree( psGTIF );
6950 : }
6951 :
6952 : /* -------------------------------------------------------------------- */
6953 : /* If we are writing jpeg compression we need to write some */
6954 : /* imagery to force the jpegtables to get created. This is, */
6955 : /* likely only needed with libtiff 3.9.x. */
6956 : /* -------------------------------------------------------------------- */
6957 : if( nCompression == COMPRESSION_JPEG
6958 : && strstr(TIFFLIB_VERSION_STR, "Version 3.9") != NULL )
6959 : {
6960 : CPLDebug( "GDAL",
6961 : "Writing zero block to force creation of JPEG tables." );
6962 : if( TIFFIsTiled( hTIFF ) )
6963 : {
6964 : int cc = TIFFTileSize( hTIFF );
6965 : unsigned char *pabyZeros = (unsigned char *) CPLCalloc(cc,1);
6966 : TIFFWriteEncodedTile(hTIFF, 0, pabyZeros, cc);
6967 : CPLFree( pabyZeros );
6968 : }
6969 : else
6970 : {
6971 : int cc = TIFFStripSize( hTIFF );
6972 : unsigned char *pabyZeros = (unsigned char *) CPLCalloc(cc,1);
6973 : TIFFWriteEncodedStrip(hTIFF, 0, pabyZeros, cc);
6974 : CPLFree( pabyZeros );
6975 : }
6976 : }
6977 :
6978 : /* -------------------------------------------------------------------- */
6979 : /* Cleanup */
6980 : /* -------------------------------------------------------------------- */
6981 :
6982 157 : TIFFWriteCheck( hTIFF, TIFFIsTiled(hTIFF), "GTiffCreateCopy()");
6983 157 : TIFFWriteDirectory( hTIFF );
6984 157 : TIFFFlush( hTIFF );
6985 157 : XTIFFClose( hTIFF );
6986 157 : hTIFF = NULL;
6987 :
6988 157 : if( eErr != CE_None )
6989 : {
6990 0 : VSIUnlink( pszFilename );
6991 0 : return NULL;
6992 : }
6993 :
6994 : /* -------------------------------------------------------------------- */
6995 : /* Re-open as a dataset and copy over missing metadata using */
6996 : /* PAM facilities. */
6997 : /* -------------------------------------------------------------------- */
6998 : GTiffDataset *poDS;
6999 157 : CPLString osFileName("GTIFF_RAW:");
7000 :
7001 157 : osFileName += pszFilename;
7002 :
7003 157 : poDS = (GTiffDataset *) GDALOpen( osFileName, GA_Update );
7004 157 : if( poDS == NULL )
7005 0 : poDS = (GTiffDataset *) GDALOpen( osFileName, GA_ReadOnly );
7006 :
7007 157 : if ( poDS == NULL )
7008 : {
7009 0 : VSIUnlink( pszFilename );
7010 157 : return NULL;
7011 : }
7012 :
7013 157 : poDS->osProfile = pszProfile;
7014 157 : poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
7015 157 : poDS->papszCreationOptions = CSLDuplicate( papszOptions );
7016 :
7017 : /* -------------------------------------------------------------------- */
7018 : /* CloneInfo() doesn't merge metadata, it just replaces it totally */
7019 : /* So we have to merge it */
7020 : /* -------------------------------------------------------------------- */
7021 :
7022 157 : char **papszSRC_MD = poSrcDS->GetMetadata();
7023 157 : char **papszDST_MD = CSLDuplicate(poDS->GetMetadata());
7024 :
7025 157 : papszDST_MD = CSLMerge( papszDST_MD, papszSRC_MD );
7026 :
7027 157 : poDS->SetMetadata( papszDST_MD );
7028 157 : CSLDestroy( papszDST_MD );
7029 :
7030 : /* Depending on the PHOTOMETRIC tag, the TIFF file may not have */
7031 : /* the same band count as the source. Will fail later in GDALDatasetCopyWholeRaster anyway... */
7032 408 : for( int nBand = 1;
7033 : nBand <= MIN(poDS->GetRasterCount(), poSrcDS->GetRasterCount()) ;
7034 : nBand++ )
7035 : {
7036 251 : char **papszSRC_MD = poSrcDS->GetRasterBand(nBand)->GetMetadata();
7037 251 : char **papszDST_MD = CSLDuplicate(poDS->GetRasterBand(nBand)->GetMetadata());
7038 :
7039 251 : papszDST_MD = CSLMerge( papszDST_MD, papszSRC_MD );
7040 :
7041 251 : poDS->GetRasterBand(nBand)->SetMetadata( papszDST_MD );
7042 251 : CSLDestroy( papszDST_MD );
7043 : }
7044 :
7045 157 : hTIFF = (TIFF*) poDS->GetInternalHandle(NULL);
7046 :
7047 : /* -------------------------------------------------------------------- */
7048 : /* Second chance : now that we have a PAM dataset, it is possible */
7049 : /* to write metadata that we couldn't be writen as TIFF tag */
7050 : /* -------------------------------------------------------------------- */
7051 157 : if (!bHasWrittenMDInGeotiffTAG)
7052 : GTiffDataset::WriteMetadata( poDS, hTIFF, TRUE, pszProfile,
7053 4 : pszFilename, papszOptions, TRUE /* don't write RPC and IMD file again */);
7054 :
7055 : /* To avoid unnecessary directory rewriting */
7056 157 : poDS->bMetadataChanged = FALSE;
7057 157 : poDS->bGeoTIFFInfoChanged = FALSE;
7058 :
7059 : /* We must re-set the compression level at this point, since it has */
7060 : /* been lost a few lines above when closing the newly create TIFF file */
7061 : /* The TIFFTAG_ZIPQUALITY & TIFFTAG_JPEGQUALITY are not store in the TIFF file. */
7062 : /* They are just TIFF session parameters */
7063 157 : if (nCompression == COMPRESSION_ADOBE_DEFLATE)
7064 : {
7065 4 : int nZLevel = GTiffGetZLevel(papszOptions);
7066 4 : if (nZLevel != -1)
7067 : {
7068 0 : TIFFSetField( hTIFF, TIFFTAG_ZIPQUALITY, nZLevel );
7069 : }
7070 : }
7071 153 : else if( nCompression == COMPRESSION_JPEG)
7072 : {
7073 5 : int nJpegQuality = GTiffGetJpegQuality(papszOptions);
7074 5 : if (nJpegQuality != -1)
7075 : {
7076 2 : TIFFSetField( hTIFF, TIFFTAG_JPEGQUALITY, nJpegQuality );
7077 : }
7078 : }
7079 :
7080 : /* -------------------------------------------------------------------- */
7081 : /* Copy actual imagery. */
7082 : /* -------------------------------------------------------------------- */
7083 :
7084 160 : if (poDS->bTreatAsSplit || poDS->bTreatAsSplitBitmap)
7085 : {
7086 : /* For split bands, we use TIFFWriteScanline() interface */
7087 3 : CPLAssert(poDS->nBitsPerSample == 8 || poDS->nBitsPerSample == 1);
7088 :
7089 5 : if (poDS->nPlanarConfig == PLANARCONFIG_CONTIG && poDS->nBands > 1)
7090 : {
7091 : int j;
7092 2 : GByte* pabyScanline = (GByte *) CPLMalloc(TIFFScanlineSize(hTIFF));
7093 2 : eErr = CE_None;
7094 7050 : for(j=0;j<nYSize && eErr == CE_None;j++)
7095 : {
7096 : eErr = poSrcDS->RasterIO(GF_Read, 0, j, nXSize, 1,
7097 : pabyScanline, nXSize, 1,
7098 7048 : GDT_Byte, nBands, NULL, poDS->nBands, 0, 1);
7099 7048 : if (eErr == CE_None &&
7100 : TIFFWriteScanline( hTIFF, pabyScanline, j, 0) == -1)
7101 : {
7102 : CPLError( CE_Failure, CPLE_AppDefined,
7103 0 : "TIFFWriteScanline() failed." );
7104 0 : eErr = CE_Failure;
7105 : }
7106 7048 : if( !pfnProgress( (j+1) * 1.0 / nYSize, NULL, pProgressData ) )
7107 0 : eErr = CE_Failure;
7108 : }
7109 2 : CPLFree(pabyScanline);
7110 : }
7111 : else
7112 : {
7113 : int iBand, j;
7114 1 : GByte* pabyScanline = (GByte *) CPLMalloc(TIFFScanlineSize(hTIFF));
7115 1 : eErr = CE_None;
7116 4 : for(iBand=1;iBand<=nBands && eErr == CE_None;iBand++)
7117 : {
7118 15003 : for(j=0;j<nYSize && eErr == CE_None;j++)
7119 : {
7120 : eErr = poSrcDS->GetRasterBand(iBand)->RasterIO(
7121 : GF_Read, 0, j, nXSize, 1,
7122 : pabyScanline, nXSize, 1,
7123 15000 : GDT_Byte, 0, 0);
7124 15000 : if (poDS->bTreatAsSplitBitmap)
7125 : {
7126 0 : for(int i=0;i<nXSize;i++)
7127 : {
7128 0 : GByte byVal = pabyScanline[i];
7129 0 : if ((i & 0x7) == 0)
7130 0 : pabyScanline[i >> 3] = 0;
7131 0 : if (byVal)
7132 0 : pabyScanline[i >> 3] |= (0x80 >> (i & 0x7));
7133 : }
7134 : }
7135 15000 : if (eErr == CE_None &&
7136 : TIFFWriteScanline( hTIFF, pabyScanline, j, iBand - 1) == -1)
7137 : {
7138 : CPLError( CE_Failure, CPLE_AppDefined,
7139 0 : "TIFFWriteScanline() failed." );
7140 0 : eErr = CE_Failure;
7141 : }
7142 15000 : if( !pfnProgress( (j+1 + (iBand - 1) * nYSize) * 1.0 /
7143 : (nBands * nYSize), NULL, pProgressData ) )
7144 0 : eErr = CE_Failure;
7145 : }
7146 : }
7147 1 : CPLFree(pabyScanline);
7148 : }
7149 :
7150 : /* Necessary to be able to read the file without re-opening */
7151 : #if defined(HAVE_TIFFGETSIZEPROC)
7152 3 : TIFFSizeProc pfnSizeProc = TIFFGetSizeProc( hTIFF );
7153 :
7154 3 : TIFFFlushData( hTIFF );
7155 :
7156 3 : toff_t nNewDirOffset = pfnSizeProc( TIFFClientdata( hTIFF ) );
7157 3 : if( (nNewDirOffset % 2) == 1 )
7158 3 : nNewDirOffset++;
7159 : #endif
7160 :
7161 3 : TIFFFlush( hTIFF );
7162 :
7163 : #if defined(HAVE_TIFFGETSIZEPROC)
7164 3 : if( poDS->nDirOffset != TIFFCurrentDirOffset( hTIFF ) )
7165 : {
7166 1 : poDS->nDirOffset = nNewDirOffset;
7167 1 : CPLDebug( "GTiff", "directory moved during flush." );
7168 : }
7169 : #endif
7170 : }
7171 : else
7172 : {
7173 154 : char* papszCopyWholeRasterOptions[2] = { NULL, NULL };
7174 154 : if (nCompression != COMPRESSION_NONE)
7175 13 : papszCopyWholeRasterOptions[0] = (char*) "COMPRESSED=YES";
7176 : eErr = GDALDatasetCopyWholeRaster( (GDALDatasetH) poSrcDS,
7177 : (GDALDatasetH) poDS,
7178 : papszCopyWholeRasterOptions,
7179 154 : pfnProgress, pProgressData );
7180 : }
7181 :
7182 157 : if( eErr == CE_Failure )
7183 : {
7184 0 : delete poDS;
7185 0 : poDS = NULL;
7186 :
7187 0 : VSIUnlink( pszFilename ); // should really delete more carefully.
7188 : }
7189 :
7190 157 : return poDS;
7191 : }
7192 :
7193 : /************************************************************************/
7194 : /* GetProjectionRef() */
7195 : /************************************************************************/
7196 :
7197 3127 : const char *GTiffDataset::GetProjectionRef()
7198 :
7199 : {
7200 3127 : if( nGCPCount == 0 )
7201 : {
7202 3097 : LookForProjection();
7203 :
7204 3097 : if( EQUAL(pszProjection,"") )
7205 70 : return GDALPamDataset::GetProjectionRef();
7206 : else
7207 3027 : return( pszProjection );
7208 : }
7209 : else
7210 30 : return "";
7211 : }
7212 :
7213 : /************************************************************************/
7214 : /* SetProjection() */
7215 : /************************************************************************/
7216 :
7217 589 : CPLErr GTiffDataset::SetProjection( const char * pszNewProjection )
7218 :
7219 : {
7220 589 : LookForProjection();
7221 :
7222 589 : if( !EQUALN(pszNewProjection,"GEOGCS",6)
7223 : && !EQUALN(pszNewProjection,"PROJCS",6)
7224 : && !EQUALN(pszNewProjection,"LOCAL_CS",6)
7225 : && !EQUAL(pszNewProjection,"") )
7226 : {
7227 : CPLError( CE_Failure, CPLE_AppDefined,
7228 : "Only OGC WKT Projections supported for writing to GeoTIFF.\n"
7229 : "%s not supported.",
7230 0 : pszNewProjection );
7231 :
7232 0 : return CE_Failure;
7233 : }
7234 :
7235 589 : CPLFree( pszProjection );
7236 589 : pszProjection = CPLStrdup( pszNewProjection );
7237 :
7238 589 : bGeoTIFFInfoChanged = TRUE;
7239 :
7240 589 : return CE_None;
7241 : }
7242 :
7243 : /************************************************************************/
7244 : /* GetGeoTransform() */
7245 : /************************************************************************/
7246 :
7247 2108 : CPLErr GTiffDataset::GetGeoTransform( double * padfTransform )
7248 :
7249 : {
7250 2108 : memcpy( padfTransform, adfGeoTransform, sizeof(double)*6 );
7251 :
7252 2108 : if( !bGeoTransformValid )
7253 89 : return CE_Failure;
7254 : else
7255 2019 : return CE_None;
7256 : }
7257 :
7258 : /************************************************************************/
7259 : /* SetGeoTransform() */
7260 : /************************************************************************/
7261 :
7262 594 : CPLErr GTiffDataset::SetGeoTransform( double * padfTransform )
7263 :
7264 : {
7265 594 : if( GetAccess() == GA_Update )
7266 : {
7267 594 : memcpy( adfGeoTransform, padfTransform, sizeof(double)*6 );
7268 594 : bGeoTransformValid = TRUE;
7269 594 : bGeoTIFFInfoChanged = TRUE;
7270 :
7271 594 : return( CE_None );
7272 : }
7273 : else
7274 : {
7275 : CPLError( CE_Failure, CPLE_NotSupported,
7276 0 : "Attempt to call SetGeoTransform() on a read-only GeoTIFF file." );
7277 0 : return CE_Failure;
7278 : }
7279 : }
7280 :
7281 : /************************************************************************/
7282 : /* GetGCPCount() */
7283 : /************************************************************************/
7284 :
7285 823 : int GTiffDataset::GetGCPCount()
7286 :
7287 : {
7288 823 : return nGCPCount;
7289 : }
7290 :
7291 : /************************************************************************/
7292 : /* GetGCPProjection() */
7293 : /************************************************************************/
7294 :
7295 79 : const char *GTiffDataset::GetGCPProjection()
7296 :
7297 : {
7298 79 : if( nGCPCount > 0 )
7299 : {
7300 79 : LookForProjection();
7301 : }
7302 79 : if (pszProjection != NULL)
7303 79 : return pszProjection;
7304 : else
7305 0 : return "";
7306 : }
7307 :
7308 : /************************************************************************/
7309 : /* GetGCPs() */
7310 : /************************************************************************/
7311 :
7312 35 : const GDAL_GCP *GTiffDataset::GetGCPs()
7313 :
7314 : {
7315 35 : return pasGCPList;
7316 : }
7317 :
7318 : /************************************************************************/
7319 : /* SetGCPs() */
7320 : /************************************************************************/
7321 :
7322 : CPLErr GTiffDataset::SetGCPs( int nGCPCount, const GDAL_GCP *pasGCPList,
7323 2 : const char *pszGCPProjection )
7324 : {
7325 2 : if( GetAccess() == GA_Update )
7326 : {
7327 2 : bLookedForProjection = TRUE;
7328 :
7329 2 : if( this->nGCPCount > 0 )
7330 : {
7331 0 : GDALDeinitGCPs( this->nGCPCount, this->pasGCPList );
7332 0 : CPLFree( this->pasGCPList );
7333 : }
7334 :
7335 2 : this->nGCPCount = nGCPCount;
7336 2 : this->pasGCPList = GDALDuplicateGCPs(nGCPCount, pasGCPList);
7337 :
7338 2 : CPLFree( this->pszProjection );
7339 2 : this->pszProjection = CPLStrdup( pszGCPProjection );
7340 2 : bGeoTIFFInfoChanged = TRUE;
7341 :
7342 2 : return CE_None;
7343 : }
7344 : else
7345 : {
7346 : CPLError( CE_Failure, CPLE_NotSupported,
7347 0 : "SetGCPs() is only supported on newly created GeoTIFF files." );
7348 0 : return CE_Failure;
7349 : }
7350 : }
7351 :
7352 : /************************************************************************/
7353 : /* GetMetadata() */
7354 : /************************************************************************/
7355 :
7356 4154 : char **GTiffDataset::GetMetadata( const char * pszDomain )
7357 :
7358 : {
7359 4154 : if( pszDomain != NULL && EQUAL(pszDomain,"ProxyOverviewRequest") )
7360 0 : return GDALPamDataset::GetMetadata( pszDomain );
7361 :
7362 : /* FIXME ? Should we call LookForProjection() to load GDALMD_AREA_OR_POINT ? */
7363 : /* This can impact performances */
7364 :
7365 4154 : return oGTiffMDMD.GetMetadata( pszDomain );
7366 : }
7367 :
7368 : /************************************************************************/
7369 : /* SetMetadata() */
7370 : /************************************************************************/
7371 200 : CPLErr GTiffDataset::SetMetadata( char ** papszMD, const char *pszDomain )
7372 :
7373 : {
7374 200 : if( pszDomain == NULL || !EQUAL(pszDomain,"_temporary_") )
7375 200 : bMetadataChanged = TRUE;
7376 :
7377 200 : if( (pszDomain == NULL || EQUAL(pszDomain, "")) &&
7378 : CSLFetchNameValue(papszMD, GDALMD_AREA_OR_POINT) != NULL )
7379 : {
7380 : const char* pszPrevValue =
7381 107 : GetMetadataItem(GDALMD_AREA_OR_POINT);
7382 : const char* pszNewValue =
7383 107 : CSLFetchNameValue(papszMD, GDALMD_AREA_OR_POINT);
7384 107 : if (pszPrevValue == NULL || pszNewValue == NULL ||
7385 : !EQUAL(pszPrevValue, pszNewValue))
7386 : {
7387 7 : LookForProjection();
7388 7 : bGeoTIFFInfoChanged = TRUE;
7389 : }
7390 : }
7391 :
7392 200 : return oGTiffMDMD.SetMetadata( papszMD, pszDomain );
7393 : }
7394 :
7395 : /************************************************************************/
7396 : /* GetMetadataItem() */
7397 : /************************************************************************/
7398 :
7399 : const char *GTiffDataset::GetMetadataItem( const char * pszName,
7400 18536 : const char * pszDomain )
7401 :
7402 : {
7403 18536 : if( pszDomain != NULL && EQUAL(pszDomain,"ProxyOverviewRequest") )
7404 2 : return GDALPamDataset::GetMetadataItem( pszName, pszDomain );
7405 :
7406 18534 : if( (pszDomain == NULL || EQUAL(pszDomain, "")) &&
7407 : pszName != NULL && EQUAL(pszName, GDALMD_AREA_OR_POINT) )
7408 : {
7409 838 : LookForProjection();
7410 : }
7411 :
7412 18534 : return oGTiffMDMD.GetMetadataItem( pszName, pszDomain );
7413 : }
7414 :
7415 : /************************************************************************/
7416 : /* SetMetadataItem() */
7417 : /************************************************************************/
7418 :
7419 : CPLErr GTiffDataset::SetMetadataItem( const char *pszName,
7420 : const char *pszValue,
7421 4800 : const char *pszDomain )
7422 :
7423 : {
7424 4800 : if( pszDomain == NULL || !EQUAL(pszDomain,"_temporary_") )
7425 4800 : bMetadataChanged = TRUE;
7426 :
7427 4800 : if( (pszDomain == NULL || EQUAL(pszDomain, "")) &&
7428 : pszName != NULL && EQUAL(pszName, GDALMD_AREA_OR_POINT) )
7429 : {
7430 8 : LookForProjection();
7431 8 : bGeoTIFFInfoChanged = TRUE;
7432 : }
7433 :
7434 4800 : return oGTiffMDMD.SetMetadataItem( pszName, pszValue, pszDomain );
7435 : }
7436 :
7437 : /************************************************************************/
7438 : /* GetInternalHandle() */
7439 : /************************************************************************/
7440 :
7441 225 : void *GTiffDataset::GetInternalHandle( const char * /* pszHandleName */ )
7442 :
7443 : {
7444 225 : return hTIFF;
7445 : }
7446 :
7447 :
7448 : /************************************************************************/
7449 : /* FindRPBFile() */
7450 : /************************************************************************/
7451 :
7452 3488 : int GTiffDataset::FindRPBFile(char** papszSiblingFiles)
7453 : {
7454 3488 : CPLString osTarget = CPLResetExtension( osFilename, "RPB" );
7455 :
7456 3488 : if( papszSiblingFiles == NULL )
7457 : {
7458 : VSIStatBufL sStatBuf;
7459 :
7460 219 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7461 : {
7462 218 : osTarget = CPLResetExtension( osFilename, "rpb" );
7463 :
7464 218 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7465 218 : return FALSE;
7466 : }
7467 : }
7468 : else
7469 : {
7470 : int iSibling = CSLFindString( papszSiblingFiles,
7471 3269 : CPLGetFilename(osTarget) );
7472 3269 : if( iSibling < 0 )
7473 3267 : return FALSE;
7474 :
7475 2 : osTarget.resize(osTarget.size() - strlen(papszSiblingFiles[iSibling]));
7476 2 : osTarget += papszSiblingFiles[iSibling];
7477 : }
7478 :
7479 3 : osRPBFile = osTarget;
7480 3 : return TRUE;
7481 : }
7482 :
7483 :
7484 : /************************************************************************/
7485 : /* FindRPCFile() */
7486 : /************************************************************************/
7487 :
7488 3485 : int GTiffDataset::FindRPCFile(char** papszSiblingFiles)
7489 : {
7490 3485 : CPLString osSrcPath = osFilename;
7491 3485 : CPLString soPt(".");
7492 3485 : size_t found = osSrcPath.rfind(soPt);
7493 3485 : if (found == CPLString::npos)
7494 109 : return NULL;
7495 3376 : osSrcPath.replace (found, osSrcPath.size() - found, "_rpc.txt");
7496 3376 : CPLString osTarget = osSrcPath;
7497 :
7498 3376 : if( papszSiblingFiles == NULL )
7499 : {
7500 : VSIStatBufL sStatBuf;
7501 :
7502 137 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7503 : {
7504 137 : osSrcPath = osFilename;
7505 137 : osSrcPath.replace (found, osSrcPath.size() - found, "_RPC.TXT");
7506 137 : osTarget = osSrcPath;
7507 :
7508 137 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7509 : {
7510 137 : osSrcPath = osFilename;
7511 137 : osSrcPath.replace (found, osSrcPath.size() - found, "_rpc.TXT");
7512 137 : osTarget = osSrcPath;
7513 :
7514 137 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7515 : {
7516 137 : return FALSE;
7517 : }
7518 : }
7519 : }
7520 : }
7521 : else
7522 : {
7523 : int iSibling = CSLFindString( papszSiblingFiles,
7524 3239 : CPLGetFilename(osTarget) );
7525 3239 : if( iSibling < 0 )
7526 3239 : return FALSE;
7527 :
7528 0 : osTarget.resize(osTarget.size() - strlen(papszSiblingFiles[iSibling]));
7529 0 : osTarget += papszSiblingFiles[iSibling];
7530 : }
7531 :
7532 0 : osRPCFile = osTarget;
7533 0 : return TRUE;
7534 : }
7535 :
7536 : /************************************************************************/
7537 : /* FindIMDFile() */
7538 : /************************************************************************/
7539 :
7540 3488 : int GTiffDataset::FindIMDFile(char** papszSiblingFiles)
7541 : {
7542 3488 : CPLString osTarget = CPLResetExtension( osFilename, "IMD" );
7543 :
7544 3488 : if( papszSiblingFiles == NULL )
7545 : {
7546 : VSIStatBufL sStatBuf;
7547 :
7548 219 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7549 : {
7550 217 : osTarget = CPLResetExtension( osFilename, "imd" );
7551 :
7552 217 : if( VSIStatL( osTarget, &sStatBuf ) != 0 )
7553 217 : return FALSE;
7554 : }
7555 : }
7556 : else
7557 : {
7558 : int iSibling = CSLFindString( papszSiblingFiles,
7559 3269 : CPLGetFilename(osTarget) );
7560 3269 : if( iSibling < 0 )
7561 3265 : return FALSE;
7562 :
7563 4 : osTarget.resize(osTarget.size() - strlen(papszSiblingFiles[iSibling]));
7564 4 : osTarget += papszSiblingFiles[iSibling];
7565 : }
7566 :
7567 6 : osIMDFile = osTarget;
7568 6 : return TRUE;
7569 : }
7570 :
7571 : /************************************************************************/
7572 : /* GetFileList() */
7573 : /************************************************************************/
7574 :
7575 884 : char **GTiffDataset::GetFileList()
7576 :
7577 : {
7578 884 : char **papszFileList = GDALPamDataset::GetFileList();
7579 :
7580 884 : if (osIMDFile.size() != 0)
7581 2 : papszFileList = CSLAddString( papszFileList, osIMDFile );
7582 884 : if (osRPBFile.size() != 0)
7583 1 : papszFileList = CSLAddString( papszFileList, osRPBFile );
7584 884 : if (osRPCFile.size() != 0)
7585 0 : papszFileList = CSLAddString( papszFileList, osRPCFile );
7586 :
7587 884 : return papszFileList;
7588 : }
7589 :
7590 : /************************************************************************/
7591 : /* CreateMaskBand() */
7592 : /************************************************************************/
7593 :
7594 13 : CPLErr GTiffDataset::CreateMaskBand(int nFlags)
7595 : {
7596 13 : if (poMaskDS != NULL)
7597 : {
7598 : CPLError(CE_Failure, CPLE_AppDefined,
7599 0 : "This TIFF dataset has already an internal mask band");
7600 0 : return CE_Failure;
7601 : }
7602 13 : else if (CSLTestBoolean(CPLGetConfigOption("GDAL_TIFF_INTERNAL_MASK", "NO")))
7603 : {
7604 : toff_t nOffset;
7605 : int bIsTiled;
7606 11 : int bIsOverview = FALSE;
7607 : uint32 nSubType;
7608 :
7609 11 : if (nFlags != GMF_PER_DATASET)
7610 : {
7611 : CPLError(CE_Failure, CPLE_AppDefined,
7612 0 : "The only flag value supported for internal mask is GMF_PER_DATASET");
7613 0 : return CE_Failure;
7614 : }
7615 :
7616 : /* -------------------------------------------------------------------- */
7617 : /* If we don't have read access, then create the mask externally. */
7618 : /* -------------------------------------------------------------------- */
7619 11 : if( GetAccess() != GA_Update )
7620 : {
7621 : CPLError( CE_Warning, CPLE_AppDefined,
7622 : "File open for read-only accessing, "
7623 0 : "creating mask externally." );
7624 :
7625 0 : return GDALPamDataset::CreateMaskBand(nFlags);
7626 : }
7627 :
7628 11 : if (poBaseDS)
7629 : {
7630 6 : if (!poBaseDS->SetDirectory())
7631 0 : return CE_Failure;
7632 : }
7633 11 : if (!SetDirectory())
7634 0 : return CE_Failure;
7635 :
7636 11 : if( TIFFGetField(hTIFF, TIFFTAG_SUBFILETYPE, &nSubType))
7637 : {
7638 6 : bIsOverview = (nSubType & FILETYPE_REDUCEDIMAGE) != 0;
7639 :
7640 6 : if ((nSubType & FILETYPE_MASK) != 0)
7641 : {
7642 : CPLError( CE_Failure, CPLE_AppDefined,
7643 0 : "Cannot create a mask on a TIFF mask IFD !" );
7644 0 : return CE_Failure;
7645 : }
7646 : }
7647 :
7648 11 : TIFFFlush( hTIFF );
7649 :
7650 11 : bIsTiled = TIFFIsTiled(hTIFF);
7651 :
7652 : nOffset = GTIFFWriteDirectory(hTIFF,
7653 : (bIsOverview) ? FILETYPE_REDUCEDIMAGE | FILETYPE_MASK : FILETYPE_MASK,
7654 : nRasterXSize, nRasterYSize,
7655 : 1, PLANARCONFIG_CONTIG, 1,
7656 : nBlockXSize, nBlockYSize,
7657 : bIsTiled, COMPRESSION_NONE, PHOTOMETRIC_MASK, PREDICTOR_NONE,
7658 11 : SAMPLEFORMAT_UINT, NULL, NULL, NULL, 0, NULL, "");
7659 11 : if (nOffset == 0)
7660 0 : return CE_Failure;
7661 :
7662 11 : poMaskDS = new GTiffDataset();
7663 11 : if( poMaskDS->OpenOffset( hTIFF, ppoActiveDSRef, nOffset,
7664 : FALSE, GA_Update ) != CE_None)
7665 : {
7666 0 : delete poMaskDS;
7667 0 : poMaskDS = NULL;
7668 0 : return CE_Failure;
7669 : }
7670 :
7671 11 : return CE_None;
7672 : }
7673 : else
7674 : {
7675 2 : return GDALPamDataset::CreateMaskBand(nFlags);
7676 : }
7677 : }
7678 :
7679 : /************************************************************************/
7680 : /* CreateMaskBand() */
7681 : /************************************************************************/
7682 :
7683 6 : CPLErr GTiffRasterBand::CreateMaskBand(int nFlags)
7684 : {
7685 6 : if (poGDS->poMaskDS != NULL)
7686 : {
7687 : CPLError(CE_Failure, CPLE_AppDefined,
7688 0 : "This TIFF dataset has already an internal mask band");
7689 0 : return CE_Failure;
7690 : }
7691 6 : else if (CSLTestBoolean(CPLGetConfigOption("GDAL_TIFF_INTERNAL_MASK", "NO")))
7692 : {
7693 6 : return poGDS->CreateMaskBand(nFlags);
7694 : }
7695 : else
7696 : {
7697 0 : return GDALPamRasterBand::CreateMaskBand(nFlags);
7698 : }
7699 : }
7700 :
7701 : /************************************************************************/
7702 : /* PrepareTIFFErrorFormat() */
7703 : /* */
7704 : /* sometimes the "module" has stuff in it that has special */
7705 : /* meaning in a printf() style format, so we try to escape it. */
7706 : /* For now we hope the only thing we have to escape is %'s. */
7707 : /************************************************************************/
7708 :
7709 0 : static char *PrepareTIFFErrorFormat( const char *module, const char *fmt )
7710 :
7711 : {
7712 : char *pszModFmt;
7713 : int iIn, iOut;
7714 :
7715 0 : pszModFmt = (char *) CPLMalloc( strlen(module)*2 + strlen(fmt) + 2 );
7716 0 : for( iOut = 0, iIn = 0; module[iIn] != '\0'; iIn++ )
7717 : {
7718 0 : if( module[iIn] == '%' )
7719 : {
7720 0 : pszModFmt[iOut++] = '%';
7721 0 : pszModFmt[iOut++] = '%';
7722 : }
7723 : else
7724 0 : pszModFmt[iOut++] = module[iIn];
7725 : }
7726 0 : pszModFmt[iOut] = '\0';
7727 0 : strcat( pszModFmt, ":" );
7728 0 : strcat( pszModFmt, fmt );
7729 :
7730 0 : return pszModFmt;
7731 : }
7732 :
7733 : /************************************************************************/
7734 : /* GTiffWarningHandler() */
7735 : /************************************************************************/
7736 : void
7737 0 : GTiffWarningHandler(const char* module, const char* fmt, va_list ap )
7738 : {
7739 : char *pszModFmt;
7740 :
7741 0 : if( strstr(fmt,"unknown field") != NULL )
7742 0 : return;
7743 :
7744 0 : pszModFmt = PrepareTIFFErrorFormat( module, fmt );
7745 0 : CPLErrorV( CE_Warning, CPLE_AppDefined, pszModFmt, ap );
7746 0 : CPLFree( pszModFmt );
7747 : }
7748 :
7749 : /************************************************************************/
7750 : /* GTiffWarningHandler() */
7751 : /************************************************************************/
7752 : void
7753 0 : GTiffErrorHandler(const char* module, const char* fmt, va_list ap )
7754 : {
7755 : char *pszModFmt;
7756 :
7757 0 : pszModFmt = PrepareTIFFErrorFormat( module, fmt );
7758 0 : CPLErrorV( CE_Failure, CPLE_AppDefined, pszModFmt, ap );
7759 0 : CPLFree( pszModFmt );
7760 0 : }
7761 :
7762 : /************************************************************************/
7763 : /* GTiffTagExtender() */
7764 : /* */
7765 : /* Install tags specially known to GDAL. */
7766 : /************************************************************************/
7767 :
7768 : static TIFFExtendProc _ParentExtender = NULL;
7769 :
7770 8307 : static void GTiffTagExtender(TIFF *tif)
7771 :
7772 : {
7773 : static const TIFFFieldInfo xtiffFieldInfo[] = {
7774 : { TIFFTAG_GDAL_METADATA, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
7775 : TRUE, FALSE, (char*) "GDALMetadata" },
7776 : { TIFFTAG_GDAL_NODATA, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
7777 : TRUE, FALSE, (char*) "GDALNoDataValue" },
7778 : { TIFFTAG_RPCCOEFFICIENT, -1,-1, TIFF_DOUBLE, FIELD_CUSTOM,
7779 : TRUE, TRUE, (char*) "RPCCoefficient" }
7780 : };
7781 :
7782 8307 : if (_ParentExtender)
7783 0 : (*_ParentExtender)(tif);
7784 :
7785 : TIFFMergeFieldInfo( tif, xtiffFieldInfo,
7786 8307 : sizeof(xtiffFieldInfo) / sizeof(xtiffFieldInfo[0]) );
7787 8307 : }
7788 :
7789 : /************************************************************************/
7790 : /* GTiffOneTimeInit() */
7791 : /* */
7792 : /* This is stuff that is initialized for the TIFF library just */
7793 : /* once. We deliberately defer the initialization till the */
7794 : /* first time we are likely to call into libtiff to avoid */
7795 : /* unnecessary paging in of the library for GDAL apps that */
7796 : /* don't use it. */
7797 : /************************************************************************/
7798 :
7799 4500 : void GTiffOneTimeInit()
7800 :
7801 : {
7802 : static int bOneTimeInitDone = FALSE;
7803 :
7804 4500 : if( bOneTimeInitDone )
7805 4141 : return;
7806 :
7807 359 : bOneTimeInitDone = TRUE;
7808 :
7809 359 : _ParentExtender = TIFFSetTagExtender(GTiffTagExtender);
7810 :
7811 359 : TIFFSetWarningHandler( GTiffWarningHandler );
7812 359 : TIFFSetErrorHandler( GTiffErrorHandler );
7813 :
7814 : // This only really needed if we are linked to an external libgeotiff
7815 : // with its own (lame) file searching logic.
7816 359 : SetCSVFilenameHook( GDALDefaultCSVFilename );
7817 : }
7818 :
7819 : /************************************************************************/
7820 : /* GDALDeregister_GTiff() */
7821 : /************************************************************************/
7822 :
7823 380 : void GDALDeregister_GTiff( GDALDriver * )
7824 :
7825 : {
7826 380 : CPLDebug( "GDAL", "GDALDeregister_GTiff() called." );
7827 380 : CSVDeaccess( NULL );
7828 :
7829 : #if defined(LIBGEOTIFF_VERSION) && LIBGEOTIFF_VERSION > 1150
7830 380 : GTIFDeaccessCSV();
7831 : #endif
7832 380 : }
7833 :
7834 : /************************************************************************/
7835 : /* GDALRegister_GTiff() */
7836 : /************************************************************************/
7837 :
7838 409 : void GDALRegister_GTiff()
7839 :
7840 : {
7841 409 : if( GDALGetDriverByName( "GTiff" ) == NULL )
7842 : {
7843 : GDALDriver *poDriver;
7844 : char szCreateOptions[3072];
7845 : char szOptionalCompressItems[500];
7846 392 : int bHasJPEG = FALSE, bHasLZW = FALSE, bHasDEFLATE = FALSE;
7847 :
7848 392 : poDriver = new GDALDriver();
7849 :
7850 : /* -------------------------------------------------------------------- */
7851 : /* Determine which compression codecs are available that we */
7852 : /* want to advertise. If we are using an old libtiff we won't */
7853 : /* be able to find out so we just assume all are available. */
7854 : /* -------------------------------------------------------------------- */
7855 : strcpy( szOptionalCompressItems,
7856 392 : " <Value>NONE</Value>" );
7857 :
7858 : #if TIFFLIB_VERSION <= 20040919
7859 : strcat( szOptionalCompressItems,
7860 : " <Value>PACKBITS</Value>"
7861 : " <Value>JPEG</Value>"
7862 : " <Value>LZW</Value>"
7863 : " <Value>DEFLATE</Value>" );
7864 : bHasLZW = bHasDEFLATE = TRUE;
7865 : #else
7866 392 : TIFFCodec *c, *codecs = TIFFGetConfiguredCODECs();
7867 :
7868 6664 : for( c = codecs; c->name; c++ )
7869 : {
7870 6272 : if( c->scheme == COMPRESSION_PACKBITS )
7871 : strcat( szOptionalCompressItems,
7872 392 : " <Value>PACKBITS</Value>" );
7873 5880 : else if( c->scheme == COMPRESSION_JPEG )
7874 : {
7875 392 : bHasJPEG = TRUE;
7876 : strcat( szOptionalCompressItems,
7877 392 : " <Value>JPEG</Value>" );
7878 : }
7879 5488 : else if( c->scheme == COMPRESSION_LZW )
7880 : {
7881 392 : bHasLZW = TRUE;
7882 : strcat( szOptionalCompressItems,
7883 392 : " <Value>LZW</Value>" );
7884 : }
7885 5096 : else if( c->scheme == COMPRESSION_ADOBE_DEFLATE )
7886 : {
7887 392 : bHasDEFLATE = TRUE;
7888 : strcat( szOptionalCompressItems,
7889 392 : " <Value>DEFLATE</Value>" );
7890 : }
7891 4704 : else if( c->scheme == COMPRESSION_CCITTRLE )
7892 : strcat( szOptionalCompressItems,
7893 392 : " <Value>CCITTRLE</Value>" );
7894 4312 : else if( c->scheme == COMPRESSION_CCITTFAX3 )
7895 : strcat( szOptionalCompressItems,
7896 392 : " <Value>CCITTFAX3</Value>" );
7897 3920 : else if( c->scheme == COMPRESSION_CCITTFAX4 )
7898 : strcat( szOptionalCompressItems,
7899 392 : " <Value>CCITTFAX4</Value>" );
7900 : }
7901 392 : _TIFFfree( codecs );
7902 : #endif
7903 :
7904 : /* -------------------------------------------------------------------- */
7905 : /* Build full creation option list. */
7906 : /* -------------------------------------------------------------------- */
7907 : sprintf( szCreateOptions, "%s%s%s",
7908 : "<CreationOptionList>"
7909 : " <Option name='COMPRESS' type='string-select'>",
7910 : szOptionalCompressItems,
7911 392 : " </Option>");
7912 392 : if (bHasLZW || bHasDEFLATE)
7913 : strcat( szCreateOptions, ""
7914 392 : " <Option name='PREDICTOR' type='int' description='Predictor Type'/>");
7915 392 : if (bHasJPEG)
7916 : strcat( szCreateOptions, ""
7917 392 : " <Option name='JPEG_QUALITY' type='int' description='JPEG quality 1-100' default='75'/>");
7918 392 : if (bHasDEFLATE)
7919 : strcat( szCreateOptions, ""
7920 392 : " <Option name='ZLEVEL' type='int' description='DEFLATE compression level 1-9' default='6'/>");
7921 : strcat( szCreateOptions, ""
7922 : " <Option name='NBITS' type='int' description='BITS for sub-byte files (1-7), sub-uint16 (9-15), sub-uint32 (17-31)'/>"
7923 : " <Option name='INTERLEAVE' type='string-select' default='PIXEL'>"
7924 : " <Value>BAND</Value>"
7925 : " <Value>PIXEL</Value>"
7926 : " </Option>"
7927 : " <Option name='TILED' type='boolean' description='Switch to tiled format'/>"
7928 : " <Option name='TFW' type='boolean' description='Write out world file'/>"
7929 : " <Option name='RPB' type='boolean' description='Write out .RPB (RPC) file'/>"
7930 : " <Option name='BLOCKXSIZE' type='int' description='Tile Width'/>"
7931 : " <Option name='BLOCKYSIZE' type='int' description='Tile/Strip Height'/>"
7932 : " <Option name='PHOTOMETRIC' type='string-select'>"
7933 : " <Value>MINISBLACK</Value>"
7934 : " <Value>MINISWHITE</Value>"
7935 : " <Value>PALETTE</Value>"
7936 : " <Value>RGB</Value>"
7937 : " <Value>CMYK</Value>"
7938 : " <Value>YCBCR</Value>"
7939 : " <Value>CIELAB</Value>"
7940 : " <Value>ICCLAB</Value>"
7941 : " <Value>ITULAB</Value>"
7942 : " </Option>"
7943 : " <Option name='SPARSE_OK' type='boolean' description='Can newly created files have missing blocks?' default='FALSE'/>"
7944 : " <Option name='ALPHA' type='boolean' description='Mark first extrasample as being alpha'/>"
7945 : " <Option name='PROFILE' type='string-select' default='GDALGeoTIFF'>"
7946 : " <Value>GDALGeoTIFF</Value>"
7947 : " <Value>GeoTIFF</Value>"
7948 : " <Value>BASELINE</Value>"
7949 : " </Option>"
7950 : " <Option name='PIXELTYPE' type='string-select'>"
7951 : " <Value>DEFAULT</Value>"
7952 : " <Value>SIGNEDBYTE</Value>"
7953 : " </Option>"
7954 : #ifdef BIGTIFF_SUPPORT
7955 : " <Option name='BIGTIFF' type='string-select' description='Force creation of BigTIFF file'>"
7956 : " <Value>YES</Value>"
7957 : " <Value>NO</Value>"
7958 : " <Value>IF_NEEDED</Value>"
7959 : " <Value>IF_SAFER</Value>"
7960 : " </Option>"
7961 : #endif
7962 : " <Option name='ENDIANNESS' type='string-select' default='NATIVE' description='Force endianness of created file. For DEBUG purpose mostly'>"
7963 : " <Value>NATIVE</Value>"
7964 : " <Value>INVERTED</Value>"
7965 : " <Value>LITTLE</Value>"
7966 : " <Value>BIG</Value>"
7967 : " </Option>"
7968 392 : "</CreationOptionList>" );
7969 :
7970 : /* -------------------------------------------------------------------- */
7971 : /* Set the driver details. */
7972 : /* -------------------------------------------------------------------- */
7973 392 : poDriver->SetDescription( "GTiff" );
7974 392 : poDriver->SetMetadataItem( GDAL_DMD_LONGNAME, "GeoTIFF" );
7975 392 : poDriver->SetMetadataItem( GDAL_DMD_HELPTOPIC, "frmt_gtiff.html" );
7976 392 : poDriver->SetMetadataItem( GDAL_DMD_MIMETYPE, "image/tiff" );
7977 392 : poDriver->SetMetadataItem( GDAL_DMD_EXTENSION, "tif" );
7978 : poDriver->SetMetadataItem( GDAL_DMD_CREATIONDATATYPES,
7979 : "Byte UInt16 Int16 UInt32 Int32 Float32 "
7980 392 : "Float64 CInt16 CInt32 CFloat32 CFloat64" );
7981 : poDriver->SetMetadataItem( GDAL_DMD_CREATIONOPTIONLIST,
7982 392 : szCreateOptions );
7983 :
7984 392 : poDriver->SetMetadataItem( GDAL_DCAP_VIRTUALIO, "YES" );
7985 :
7986 392 : poDriver->pfnOpen = GTiffDataset::Open;
7987 392 : poDriver->pfnCreate = GTiffDataset::Create;
7988 392 : poDriver->pfnCreateCopy = GTiffDataset::CreateCopy;
7989 392 : poDriver->pfnUnloadDriver = GDALDeregister_GTiff;
7990 392 : poDriver->pfnIdentify = GTiffDataset::Identify;
7991 :
7992 392 : GetGDALDriverManager()->RegisterDriver( poDriver );
7993 : }
7994 409 : }
|
