1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagtiff.cpp
3 // Purpose: wxImage TIFF handler
4 // Author: Robert Roebling
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 // For compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
25 #if wxUSE_IMAGE && wxUSE_LIBTIFF
27 #include "wx/imagtiff.h"
28 #include "wx/versioninfo.h"
34 #include "wx/bitmap.h"
35 #include "wx/module.h"
36 #include "wx/wxcrtvararg.h"
42 #include "tif_config.h"
47 #include "wx/filefn.h"
48 #include "wx/wfstream.h"
50 #ifndef TIFFLINKAGEMODE
51 #if defined(__WATCOMC__) && defined(__WXMGL__)
52 #define TIFFLINKAGEMODE cdecl
54 #define TIFFLINKAGEMODE LINKAGEMODE
58 // ============================================================================
60 // ============================================================================
62 // ----------------------------------------------------------------------------
63 // TIFF library error/warning handlers
64 // ----------------------------------------------------------------------------
67 FormatTiffMessage(const char *module
, const char *fmt
, va_list ap
)
70 if ( wxCRT_VsnprintfA(buf
, WXSIZEOF(buf
), fmt
, ap
) <= 0 )
72 // this isn't supposed to happen, but if it does, it's better
74 strcpy(buf
, "Incorrectly formatted TIFF message");
76 buf
[WXSIZEOF(buf
)-1] = 0; // make sure it is always NULL-terminated
80 msg
+= wxString
::Format(_(" (in module \"%s\")"), module
);
89 TIFFwxWarningHandler(const char* module
, const char *fmt
, va_list ap
)
91 wxLogWarning("%s", FormatTiffMessage(module
, fmt
, ap
));
95 TIFFwxErrorHandler(const char* module
, const char *fmt
, va_list ap
)
97 wxLogError("%s", FormatTiffMessage(module
, fmt
, ap
));
102 //-----------------------------------------------------------------------------
104 //-----------------------------------------------------------------------------
106 IMPLEMENT_DYNAMIC_CLASS(wxTIFFHandler
,wxImageHandler
)
108 wxTIFFHandler
::wxTIFFHandler()
110 m_name
= wxT("TIFF file");
111 m_extension
= wxT("tif");
112 m_altExtensions
.Add(wxT("tiff"));
113 m_type
= wxBITMAP_TYPE_TIFF
;
114 m_mime
= wxT("image/tiff");
115 TIFFSetWarningHandler((TIFFErrorHandler
) TIFFwxWarningHandler
);
116 TIFFSetErrorHandler((TIFFErrorHandler
) TIFFwxErrorHandler
);
121 // helper to translate our, possibly 64 bit, wxFileOffset to TIFF, always 32
123 static toff_t
wxFileOffsetToTIFF(wxFileOffset ofs
)
125 if ( ofs
== wxInvalidOffset
)
128 toff_t tofs
= wx_truncate_cast(toff_t
, ofs
);
129 wxCHECK_MSG( (wxFileOffset
)tofs
== ofs
, (toff_t
)-1,
130 wxT("TIFF library doesn't support large files") );
135 // another helper to convert standard seek mode to our
136 static wxSeekMode
wxSeekModeFromTIFF(int whence
)
144 return wxFromCurrent
;
150 return wxFromCurrent
;
157 tsize_t TIFFLINKAGEMODE
158 wxTIFFNullProc(thandle_t
WXUNUSED(handle
),
159 tdata_t
WXUNUSED(buf
),
160 tsize_t
WXUNUSED(size
))
165 tsize_t TIFFLINKAGEMODE
166 wxTIFFReadProc(thandle_t handle
, tdata_t buf
, tsize_t size
)
168 wxInputStream
*stream
= (wxInputStream
*) handle
;
169 stream
->Read( (void*) buf
, (size_t) size
);
170 return wx_truncate_cast(tsize_t
, stream
->LastRead());
173 tsize_t TIFFLINKAGEMODE
174 wxTIFFWriteProc(thandle_t handle
, tdata_t buf
, tsize_t size
)
176 wxOutputStream
*stream
= (wxOutputStream
*) handle
;
177 stream
->Write( (void*) buf
, (size_t) size
);
178 return wx_truncate_cast(tsize_t
, stream
->LastWrite());
181 toff_t TIFFLINKAGEMODE
182 wxTIFFSeekIProc(thandle_t handle
, toff_t off
, int whence
)
184 wxInputStream
*stream
= (wxInputStream
*) handle
;
186 return wxFileOffsetToTIFF(stream
->SeekI((wxFileOffset
)off
,
187 wxSeekModeFromTIFF(whence
)));
190 toff_t TIFFLINKAGEMODE
191 wxTIFFSeekOProc(thandle_t handle
, toff_t off
, int whence
)
193 wxOutputStream
*stream
= (wxOutputStream
*) handle
;
195 toff_t offset
= wxFileOffsetToTIFF(
196 stream
->SeekO((wxFileOffset
)off
, wxSeekModeFromTIFF(whence
)) );
198 if (offset
!= (toff_t
) -1 || whence
!= SEEK_SET
)
205 Try to workaround problems with libtiff seeking past the end of streams.
207 This occurs when libtiff is writing tag entries past the end of a
208 stream but hasn't written the directory yet (which will be placed
209 before the tags and contain offsets to the just written tags).
210 The behaviour for seeking past the end of a stream is not consistent
211 and doesn't work with for example wxMemoryOutputStream. When this type
212 of seeking fails (with SEEK_SET), fill in the gap with zeroes and try
216 wxFileOffset streamLength
= stream
->GetLength();
217 if (streamLength
!= wxInvalidOffset
&& (wxFileOffset
) off
> streamLength
)
219 if (stream
->SeekO(streamLength
, wxFromStart
) == wxInvalidOffset
)
224 for (wxFileOffset i
= 0; i
< (wxFileOffset
) off
- streamLength
; ++i
)
230 return wxFileOffsetToTIFF( stream
->TellO() );
234 wxTIFFCloseIProc(thandle_t
WXUNUSED(handle
))
236 // there is no need to close the input stream
241 wxTIFFCloseOProc(thandle_t handle
)
243 wxOutputStream
*stream
= (wxOutputStream
*) handle
;
245 return stream
->Close() ?
0 : -1;
248 toff_t TIFFLINKAGEMODE
249 wxTIFFSizeProc(thandle_t handle
)
251 wxStreamBase
*stream
= (wxStreamBase
*) handle
;
252 return (toff_t
) stream
->GetSize();
256 wxTIFFMapProc(thandle_t
WXUNUSED(handle
),
257 tdata_t
* WXUNUSED(pbase
),
258 toff_t
* WXUNUSED(psize
))
264 wxTIFFUnmapProc(thandle_t
WXUNUSED(handle
),
265 tdata_t
WXUNUSED(base
),
266 toff_t
WXUNUSED(size
))
273 TIFFwxOpen(wxInputStream
&stream
, const char* name
, const char* mode
)
275 TIFF
* tif
= TIFFClientOpen(name
, mode
,
277 wxTIFFReadProc
, wxTIFFNullProc
,
278 wxTIFFSeekIProc
, wxTIFFCloseIProc
, wxTIFFSizeProc
,
279 wxTIFFMapProc
, wxTIFFUnmapProc
);
285 TIFFwxOpen(wxOutputStream
&stream
, const char* name
, const char* mode
)
287 TIFF
* tif
= TIFFClientOpen(name
, mode
,
289 wxTIFFNullProc
, wxTIFFWriteProc
,
290 wxTIFFSeekOProc
, wxTIFFCloseOProc
, wxTIFFSizeProc
,
291 wxTIFFMapProc
, wxTIFFUnmapProc
);
296 bool wxTIFFHandler
::LoadFile( wxImage
*image
, wxInputStream
& stream
, bool verbose
, int index
)
303 TIFF
*tif
= TIFFwxOpen( stream
, "image", "r" );
309 wxLogError( _("TIFF: Error loading image.") );
315 if (!TIFFSetDirectory( tif
, (tdir_t
)index
))
319 wxLogError( _("Invalid TIFF image index.") );
330 TIFFGetField( tif
, TIFFTAG_IMAGEWIDTH
, &w
);
331 TIFFGetField( tif
, TIFFTAG_IMAGELENGTH
, &h
);
334 uint16 samplesPerPixel
;
337 TIFFGetFieldDefaulted(tif
, TIFFTAG_SAMPLESPERPIXEL
, &samplesPerPixel
);
338 TIFFGetFieldDefaulted(tif
, TIFFTAG_EXTRASAMPLES
,
339 &extraSamples
, &samplesInfo
);
340 if (!TIFFGetField(tif
, TIFFTAG_PHOTOMETRIC
, &photometric
))
342 photometric
= PHOTOMETRIC_MINISWHITE
;
344 const bool hasAlpha
= (extraSamples
>= 1
345 && ((samplesInfo
[0] == EXTRASAMPLE_UNSPECIFIED
&& samplesPerPixel
> 3)
346 || samplesInfo
[0] == EXTRASAMPLE_ASSOCALPHA
347 || samplesInfo
[0] == EXTRASAMPLE_UNASSALPHA
))
348 || (extraSamples
== 0 && samplesPerPixel
== 4
349 && photometric
== PHOTOMETRIC_RGB
);
351 // guard against integer overflow during multiplication which could result
352 // in allocating a too small buffer and then overflowing it
353 const double bytesNeeded
= (double)w
* (double)h
* sizeof(uint32
);
354 if ( bytesNeeded
>= wxUINT32_MAX
)
358 wxLogError( _("TIFF: Image size is abnormally big.") );
366 raster
= (uint32
*) _TIFFmalloc( (uint32
)bytesNeeded
);
372 wxLogError( _("TIFF: Couldn't allocate memory.") );
380 image
->Create( (int)w
, (int)h
);
385 wxLogError( _("TIFF: Couldn't allocate memory.") );
397 if (!TIFFReadRGBAImageOriented( tif
, w
, h
, raster
, ORIENTATION_TOPLEFT
, 0 ))
401 wxLogError( _("TIFF: Error reading image.") );
411 unsigned char *ptr
= image
->GetData();
413 unsigned char *alpha
= image
->GetAlpha();
417 for (uint32 i
= 0; i
< h
; i
++)
419 for (uint32 j
= 0; j
< w
; j
++)
421 *(ptr
++) = (unsigned char)TIFFGetR(raster
[pos
]);
422 *(ptr
++) = (unsigned char)TIFFGetG(raster
[pos
]);
423 *(ptr
++) = (unsigned char)TIFFGetB(raster
[pos
]);
425 *(alpha
++) = (unsigned char)TIFFGetA(raster
[pos
]);
432 image
->SetOption(wxIMAGE_OPTION_TIFF_PHOTOMETRIC
, photometric
);
434 uint16 spp
, bps
, compression
;
436 Read some baseline TIFF tags which helps when re-saving a TIFF
437 to be similar to the original image.
439 if ( TIFFGetFieldDefaulted(tif
, TIFFTAG_SAMPLESPERPIXEL
, &spp
) )
441 image
->SetOption(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL
, spp
);
444 if ( TIFFGetFieldDefaulted(tif
, TIFFTAG_BITSPERSAMPLE
, &bps
) )
446 image
->SetOption(wxIMAGE_OPTION_TIFF_BITSPERSAMPLE
, bps
);
449 if ( TIFFGetFieldDefaulted(tif
, TIFFTAG_COMPRESSION
, &compression
) )
451 image
->SetOption(wxIMAGE_OPTION_TIFF_COMPRESSION
, compression
);
454 // Set the resolution unit.
455 wxImageResolution resUnit
= wxIMAGE_RESOLUTION_NONE
;
457 if ( TIFFGetFieldDefaulted(tif
, TIFFTAG_RESOLUTIONUNIT
, &tiffRes
) )
462 wxLogWarning(_("Unknown TIFF resolution unit %d ignored"),
467 resUnit
= wxIMAGE_RESOLUTION_NONE
;
471 resUnit
= wxIMAGE_RESOLUTION_INCHES
;
474 case RESUNIT_CENTIMETER
:
475 resUnit
= wxIMAGE_RESOLUTION_CM
;
480 image
->SetOption(wxIMAGE_OPTION_RESOLUTIONUNIT
, resUnit
);
483 Set the image resolution if it's available. Resolution tag is not
484 dependant on RESOLUTIONUNIT != RESUNIT_NONE (according to TIFF spec).
488 if ( TIFFGetField(tif
, TIFFTAG_XRESOLUTION
, &resX
) )
491 Use a string value to not lose precision.
492 rounding to int as cm and then converting to inch may
493 result in whole integer rounding error, eg. 201 instead of 200 dpi.
494 If an app wants an int, GetOptionInt will convert and round down.
496 image
->SetOption(wxIMAGE_OPTION_RESOLUTIONX
,
497 wxString
::FromCDouble((double) resX
));
500 if ( TIFFGetField(tif
, TIFFTAG_YRESOLUTION
, &resY
) )
502 image
->SetOption(wxIMAGE_OPTION_RESOLUTIONY
,
503 wxString
::FromCDouble((double) resY
));
513 int wxTIFFHandler
::DoGetImageCount( wxInputStream
& stream
)
515 TIFF
*tif
= TIFFwxOpen( stream
, "image", "r" );
520 int dircount
= 0; // according to the libtiff docs, dircount should be set to 1 here???
523 } while (TIFFReadDirectory(tif
));
527 // NOTE: this function modifies the current stream position but it's ok
528 // (see wxImageHandler::GetImageCount)
533 bool wxTIFFHandler
::SaveFile( wxImage
*image
, wxOutputStream
& stream
, bool verbose
)
535 TIFF
*tif
= TIFFwxOpen( stream
, "image", "w" );
541 wxLogError( _("TIFF: Error saving image.") );
547 TIFFSetField(tif
, TIFFTAG_IMAGEWIDTH
, (uint32
)image
->GetWidth());
548 TIFFSetField(tif
, TIFFTAG_IMAGELENGTH
, (uint32
)image
->GetHeight());
549 TIFFSetField(tif
, TIFFTAG_ORIENTATION
, ORIENTATION_TOPLEFT
);
550 TIFFSetField(tif
, TIFFTAG_PLANARCONFIG
, PLANARCONFIG_CONTIG
);
552 // save the image resolution if we have it
554 const wxImageResolution res
= GetResolutionFromOptions(*image
, &xres
, &yres
);
559 wxFAIL_MSG( wxT("unknown image resolution units") );
562 case wxIMAGE_RESOLUTION_NONE
:
563 tiffRes
= RESUNIT_NONE
;
566 case wxIMAGE_RESOLUTION_INCHES
:
567 tiffRes
= RESUNIT_INCH
;
570 case wxIMAGE_RESOLUTION_CM
:
571 tiffRes
= RESUNIT_CENTIMETER
;
575 if ( tiffRes
!= RESUNIT_NONE
)
577 TIFFSetField(tif
, TIFFTAG_RESOLUTIONUNIT
, tiffRes
);
578 TIFFSetField(tif
, TIFFTAG_XRESOLUTION
, (float)xres
);
579 TIFFSetField(tif
, TIFFTAG_YRESOLUTION
, (float)yres
);
583 int spp
= image
->GetOptionInt(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL
);
587 int bps
= image
->GetOptionInt(wxIMAGE_OPTION_TIFF_BITSPERSAMPLE
);
594 // One bit per sample combined with 3 samples per pixel is
595 // not allowed and crashes libtiff.
599 int photometric
= PHOTOMETRIC_RGB
;
601 if ( image
->HasOption(wxIMAGE_OPTION_TIFF_PHOTOMETRIC
) )
603 photometric
= image
->GetOptionInt(wxIMAGE_OPTION_TIFF_PHOTOMETRIC
);
604 if (photometric
== PHOTOMETRIC_MINISWHITE
605 || photometric
== PHOTOMETRIC_MINISBLACK
)
607 // either b/w or greyscale
613 photometric
= PHOTOMETRIC_MINISWHITE
;
616 const bool isColouredImage
= (spp
> 1)
617 && (photometric
!= PHOTOMETRIC_MINISWHITE
)
618 && (photometric
!= PHOTOMETRIC_MINISBLACK
);
620 int compression
= image
->GetOptionInt(wxIMAGE_OPTION_TIFF_COMPRESSION
);
623 // we can't use COMPRESSION_LZW because current version of libtiff
624 // doesn't implement it ("no longer implemented due to Unisys patent
625 // enforcement") and other compression methods are lossy so we
626 // shouldn't use them by default -- and the only remaining one is none
627 compression
= COMPRESSION_NONE
;
630 TIFFSetField(tif
, TIFFTAG_SAMPLESPERPIXEL
, spp
);
631 TIFFSetField(tif
, TIFFTAG_BITSPERSAMPLE
, bps
);
632 TIFFSetField(tif
, TIFFTAG_PHOTOMETRIC
, photometric
);
633 TIFFSetField(tif
, TIFFTAG_COMPRESSION
, compression
);
635 // scanlinesize is determined by spp and bps
636 const tsize_t linebytes
=
637 (tsize_t
)((image
->GetWidth() * spp
* bps
+ 7) / 8);
641 if (TIFFScanlineSize(tif
) > linebytes
|| !isColouredImage
)
643 buf
= (unsigned char *)_TIFFmalloc(TIFFScanlineSize(tif
));
648 wxLogError( _("TIFF: Couldn't allocate memory.") );
661 TIFFSetField(tif
, TIFFTAG_ROWSPERSTRIP
,TIFFDefaultStripSize(tif
, (uint32
) -1));
663 const int bitsPerPixel
= spp
* bps
;
664 const int pixelsPerByte
= 8 / bitsPerPixel
;
665 int remainingPixelCount
= 0;
669 // How many pixels to write in the last byte column?
670 remainingPixelCount
= image
->GetWidth() % pixelsPerByte
;
671 if (!remainingPixelCount
) remainingPixelCount
= 8;
674 const bool minIsWhite
= (photometric
== PHOTOMETRIC_MINISWHITE
);
675 unsigned char *ptr
= image
->GetData();
676 for ( int row
= 0; row
< image
->GetHeight(); row
++ )
683 memcpy(buf
, ptr
, image
->GetWidth());
685 else if (spp
* bps
== 8) // greyscale image
687 for ( int column
= 0; column
< linebytes
; column
++ )
689 uint8 value
= ptr
[column
*3 + 1];
698 else // black and white image
700 for ( int column
= 0; column
< linebytes
; column
++ )
703 int pixelsPerByteCount
= (column
+ 1 != linebytes
)
705 : remainingPixelCount
;
706 for ( int bp
= 0; bp
< pixelsPerByteCount
; bp
++ )
708 if ( (ptr
[column
*24 + bp
*3 + 1] <=127) == minIsWhite
)
710 // check only green as this is sufficient
711 reverse
= (uint8
)(reverse
| 128 >> bp
);
715 buf
[column
] = reverse
;
720 if ( TIFFWriteScanline(tif
, buf ? buf
: ptr
, (uint32
)row
, 0) < 0 )
724 wxLogError( _("TIFF: Error writing image.") );
734 ptr
+= image
->GetWidth()*3;
737 (void) TIFFClose(tif
);
745 bool wxTIFFHandler
::DoCanRead( wxInputStream
& stream
)
747 unsigned char hdr
[2];
749 if ( !stream
.Read(&hdr
[0], WXSIZEOF(hdr
)) ) // it's ok to modify the stream position here
752 return (hdr
[0] == 'I' && hdr
[1] == 'I') ||
753 (hdr
[0] == 'M' && hdr
[1] == 'M');
756 #endif // wxUSE_STREAMS
758 /*static*/ wxVersionInfo wxTIFFHandler
::GetLibraryVersionInfo()
764 const wxString
ver(::TIFFGetVersion());
765 if ( wxSscanf(ver
, "LIBTIFF, Version %d.%d.%d", &major
, &minor
, µ
) != 3 )
767 wxLogDebug("Unrecognized libtiff version string \"%s\"", ver
);
775 const wxString desc
= ver
.BeforeFirst('\n', ©right
);
776 copyright
.Replace("\n", "");
778 return wxVersionInfo("libtiff", major
, minor
, micro
, desc
, copyright
);
781 #endif // wxUSE_LIBTIFF