2 * Copyright 2010 Vincent Povirk for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #include "wine/port.h"
36 #include "wincodecs_private.h"
38 #include "wine/debug.h"
39 #include "wine/library.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
45 /* Workaround for broken libtiff 4.x headers on some 64-bit hosts which
46 * define TIFF_UINT64_T/toff_t as 32-bit for 32-bit builds, while they
47 * are supposed to be always 64-bit.
48 * TIFF_UINT64_T doesn't exist in libtiff 3.x, it was introduced in 4.x.
52 # define toff_t UINT64
55 static CRITICAL_SECTION init_tiff_cs
;
56 static CRITICAL_SECTION_DEBUG init_tiff_cs_debug
=
59 { &init_tiff_cs_debug
.ProcessLocksList
,
60 &init_tiff_cs_debug
.ProcessLocksList
},
61 0, 0, { (DWORD_PTR
)(__FILE__
": init_tiff_cs") }
63 static CRITICAL_SECTION init_tiff_cs
= { &init_tiff_cs_debug
, -1, 0, 0, 0, 0 };
65 static const WCHAR wszTiffCompressionMethod
[] = {'T','i','f','f','C','o','m','p','r','e','s','s','i','o','n','M','e','t','h','o','d',0};
66 static const WCHAR wszCompressionQuality
[] = {'C','o','m','p','r','e','s','s','i','o','n','Q','u','a','l','i','t','y',0};
68 static void *libtiff_handle
;
69 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
70 MAKE_FUNCPTR(TIFFClientOpen
);
71 MAKE_FUNCPTR(TIFFClose
);
72 MAKE_FUNCPTR(TIFFCurrentDirOffset
);
73 MAKE_FUNCPTR(TIFFGetField
);
74 MAKE_FUNCPTR(TIFFIsByteSwapped
);
75 MAKE_FUNCPTR(TIFFNumberOfDirectories
);
76 MAKE_FUNCPTR(TIFFReadDirectory
);
77 MAKE_FUNCPTR(TIFFReadEncodedStrip
);
78 MAKE_FUNCPTR(TIFFReadEncodedTile
);
79 MAKE_FUNCPTR(TIFFSetDirectory
);
80 MAKE_FUNCPTR(TIFFSetField
);
81 MAKE_FUNCPTR(TIFFWriteDirectory
);
82 MAKE_FUNCPTR(TIFFWriteScanline
);
85 static void *load_libtiff(void)
89 EnterCriticalSection(&init_tiff_cs
);
91 if (!libtiff_handle
&&
92 (libtiff_handle
= wine_dlopen(SONAME_LIBTIFF
, RTLD_NOW
, NULL
, 0)) != NULL
)
94 void * (*pTIFFSetWarningHandler
)(void *);
95 void * (*pTIFFSetWarningHandlerExt
)(void *);
97 #define LOAD_FUNCPTR(f) \
98 if((p##f = wine_dlsym(libtiff_handle, #f, NULL, 0)) == NULL) { \
99 ERR("failed to load symbol %s\n", #f); \
100 libtiff_handle = NULL; \
101 LeaveCriticalSection(&init_tiff_cs); \
104 LOAD_FUNCPTR(TIFFClientOpen
);
105 LOAD_FUNCPTR(TIFFClose
);
106 LOAD_FUNCPTR(TIFFCurrentDirOffset
);
107 LOAD_FUNCPTR(TIFFGetField
);
108 LOAD_FUNCPTR(TIFFIsByteSwapped
);
109 LOAD_FUNCPTR(TIFFNumberOfDirectories
);
110 LOAD_FUNCPTR(TIFFReadDirectory
);
111 LOAD_FUNCPTR(TIFFReadEncodedStrip
);
112 LOAD_FUNCPTR(TIFFReadEncodedTile
);
113 LOAD_FUNCPTR(TIFFSetDirectory
);
114 LOAD_FUNCPTR(TIFFSetField
);
115 LOAD_FUNCPTR(TIFFWriteDirectory
);
116 LOAD_FUNCPTR(TIFFWriteScanline
);
119 if ((pTIFFSetWarningHandler
= wine_dlsym(libtiff_handle
, "TIFFSetWarningHandler", NULL
, 0)))
120 pTIFFSetWarningHandler(NULL
);
121 if ((pTIFFSetWarningHandlerExt
= wine_dlsym(libtiff_handle
, "TIFFSetWarningHandlerExt", NULL
, 0)))
122 pTIFFSetWarningHandlerExt(NULL
);
125 result
= libtiff_handle
;
127 LeaveCriticalSection(&init_tiff_cs
);
131 static tsize_t
tiff_stream_read(thandle_t client_data
, tdata_t data
, tsize_t size
)
133 IStream
*stream
= (IStream
*)client_data
;
137 hr
= IStream_Read(stream
, data
, size
, &bytes_read
);
138 if (FAILED(hr
)) bytes_read
= 0;
142 static tsize_t
tiff_stream_write(thandle_t client_data
, tdata_t data
, tsize_t size
)
144 IStream
*stream
= (IStream
*)client_data
;
148 hr
= IStream_Write(stream
, data
, size
, &bytes_written
);
149 if (FAILED(hr
)) bytes_written
= 0;
150 return bytes_written
;
153 static toff_t
tiff_stream_seek(thandle_t client_data
, toff_t offset
, int whence
)
155 IStream
*stream
= (IStream
*)client_data
;
158 ULARGE_INTEGER new_position
;
161 move
.QuadPart
= offset
;
165 origin
= STREAM_SEEK_SET
;
168 origin
= STREAM_SEEK_CUR
;
171 origin
= STREAM_SEEK_END
;
174 ERR("unknown whence value %i\n", whence
);
178 hr
= IStream_Seek(stream
, move
, origin
, &new_position
);
179 if (SUCCEEDED(hr
)) return new_position
.QuadPart
;
183 static int tiff_stream_close(thandle_t client_data
)
185 /* Caller is responsible for releasing the stream object. */
189 static toff_t
tiff_stream_size(thandle_t client_data
)
191 IStream
*stream
= (IStream
*)client_data
;
195 hr
= IStream_Stat(stream
, &statstg
, STATFLAG_NONAME
);
197 if (SUCCEEDED(hr
)) return statstg
.cbSize
.QuadPart
;
201 static int tiff_stream_map(thandle_t client_data
, tdata_t
*addr
, toff_t
*size
)
203 /* Cannot mmap streams */
207 static void tiff_stream_unmap(thandle_t client_data
, tdata_t addr
, toff_t size
)
209 /* No need to ever do this, since we can't map things. */
212 static TIFF
* tiff_open_stream(IStream
*stream
, const char *mode
)
217 IStream_Seek(stream
, zero
, STREAM_SEEK_SET
, NULL
);
219 return pTIFFClientOpen("<IStream object>", mode
, stream
, tiff_stream_read
,
220 tiff_stream_write
, (void *)tiff_stream_seek
, tiff_stream_close
,
221 (void *)tiff_stream_size
, (void *)tiff_stream_map
, (void *)tiff_stream_unmap
);
225 IWICBitmapDecoder IWICBitmapDecoder_iface
;
228 CRITICAL_SECTION lock
; /* Must be held when tiff is used or initialized is set */
234 const WICPixelFormatGUID
*format
;
241 int invert_grayscale
;
243 UINT tile_width
, tile_height
;
248 UINT resolution_unit
;
253 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
254 IWICMetadataBlockReader IWICMetadataBlockReader_iface
;
258 tiff_decode_info decode_info
;
259 INT cached_tile_x
, cached_tile_y
;
263 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
;
264 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl
;
266 static inline TiffDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
268 return CONTAINING_RECORD(iface
, TiffDecoder
, IWICBitmapDecoder_iface
);
271 static inline TiffFrameDecode
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
273 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICBitmapFrameDecode_iface
);
276 static inline TiffFrameDecode
*impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader
*iface
)
278 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICMetadataBlockReader_iface
);
281 static HRESULT
tiff_get_decode_info(TIFF
*tiff
, tiff_decode_info
*decode_info
)
283 uint16 photometric
, bps
, samples
, planar
;
284 uint16 extra_sample_count
, extra_sample
, *extra_samples
;
287 decode_info
->indexed
= 0;
288 decode_info
->reverse_bgr
= 0;
289 decode_info
->invert_grayscale
= 0;
290 decode_info
->tiled
= 0;
292 ret
= pTIFFGetField(tiff
, TIFFTAG_PHOTOMETRIC
, &photometric
);
295 WARN("missing PhotometricInterpretation tag\n");
299 ret
= pTIFFGetField(tiff
, TIFFTAG_BITSPERSAMPLE
, &bps
);
301 decode_info
->bps
= bps
;
303 ret
= pTIFFGetField(tiff
, TIFFTAG_SAMPLESPERPIXEL
, &samples
);
304 if (!ret
) samples
= 1;
305 decode_info
->samples
= samples
;
311 ret
= pTIFFGetField(tiff
, TIFFTAG_PLANARCONFIG
, &planar
);
312 if (!ret
) planar
= 1;
315 FIXME("unhandled planar configuration %u\n", planar
);
319 decode_info
->planar
= planar
;
323 case 0: /* WhiteIsZero */
324 decode_info
->invert_grayscale
= 1;
326 case 1: /* BlackIsZero */
329 ret
= pTIFFGetField(tiff
, TIFFTAG_EXTRASAMPLES
, &extra_sample_count
, &extra_samples
);
332 extra_sample_count
= 1;
334 extra_samples
= &extra_sample
;
337 else if (samples
!= 1)
339 FIXME("unhandled %dbpp sample count %u\n", bps
, samples
);
343 decode_info
->bpp
= bps
* samples
;
344 decode_info
->source_bpp
= decode_info
->bpp
;
350 FIXME("unhandled 1bpp sample count %u\n", samples
);
353 decode_info
->format
= &GUID_WICPixelFormatBlackWhite
;
358 FIXME("unhandled 4bpp grayscale sample count %u\n", samples
);
361 decode_info
->format
= &GUID_WICPixelFormat4bppGray
;
365 decode_info
->format
= &GUID_WICPixelFormat8bppGray
;
368 decode_info
->bpp
= 32;
370 switch(extra_samples
[0])
372 case 1: /* Associated (pre-multiplied) alpha data */
373 decode_info
->format
= &GUID_WICPixelFormat32bppPBGRA
;
375 case 0: /* Unspecified data */
376 case 2: /* Unassociated alpha data */
377 decode_info
->format
= &GUID_WICPixelFormat32bppBGRA
;
380 FIXME("unhandled extra sample type %u\n", extra_samples
[0]);
386 FIXME("unhandled greyscale bit count %u\n", bps
);
391 decode_info
->bpp
= bps
* samples
;
395 ret
= pTIFFGetField(tiff
, TIFFTAG_EXTRASAMPLES
, &extra_sample_count
, &extra_samples
);
398 extra_sample_count
= 1;
400 extra_samples
= &extra_sample
;
403 else if (samples
!= 3)
405 FIXME("unhandled RGB sample count %u\n", samples
);
412 decode_info
->reverse_bgr
= 1;
414 decode_info
->format
= &GUID_WICPixelFormat24bppBGR
;
416 switch(extra_samples
[0])
418 case 1: /* Associated (pre-multiplied) alpha data */
419 decode_info
->format
= &GUID_WICPixelFormat32bppPBGRA
;
421 case 0: /* Unspecified data */
422 case 2: /* Unassociated alpha data */
423 decode_info
->format
= &GUID_WICPixelFormat32bppBGRA
;
426 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
432 decode_info
->format
= &GUID_WICPixelFormat48bppRGB
;
434 switch(extra_samples
[0])
436 case 1: /* Associated (pre-multiplied) alpha data */
437 decode_info
->format
= &GUID_WICPixelFormat64bppPRGBA
;
439 case 0: /* Unspecified data */
440 case 2: /* Unassociated alpha data */
441 decode_info
->format
= &GUID_WICPixelFormat64bppRGBA
;
444 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
449 FIXME("unhandled RGB bit count %u\n", bps
);
453 case 3: /* RGB Palette */
456 FIXME("unhandled indexed sample count %u\n", samples
);
460 decode_info
->indexed
= 1;
461 decode_info
->bpp
= bps
;
465 decode_info
->format
= &GUID_WICPixelFormat4bppIndexed
;
468 decode_info
->format
= &GUID_WICPixelFormat8bppIndexed
;
471 FIXME("unhandled indexed bit count %u\n", bps
);
475 case 4: /* Transparency mask */
480 FIXME("unhandled PhotometricInterpretation %u\n", photometric
);
484 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGEWIDTH
, &decode_info
->width
);
487 WARN("missing image width\n");
491 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGELENGTH
, &decode_info
->height
);
494 WARN("missing image length\n");
498 if ((ret
= pTIFFGetField(tiff
, TIFFTAG_TILEWIDTH
, &decode_info
->tile_width
)))
500 decode_info
->tiled
= 1;
502 ret
= pTIFFGetField(tiff
, TIFFTAG_TILELENGTH
, &decode_info
->tile_height
);
505 WARN("missing tile height\n");
509 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
510 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
511 decode_info
->tiles_across
= (decode_info
->width
+ decode_info
->tile_width
- 1) / decode_info
->tile_width
;
513 else if ((ret
= pTIFFGetField(tiff
, TIFFTAG_ROWSPERSTRIP
, &decode_info
->tile_height
)))
515 if (decode_info
->tile_height
> decode_info
->height
)
516 decode_info
->tile_height
= decode_info
->height
;
517 decode_info
->tile_width
= decode_info
->width
;
518 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
519 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
523 /* Some broken TIFF files have a single strip and lack the RowsPerStrip tag */
524 decode_info
->tile_height
= decode_info
->height
;
525 decode_info
->tile_width
= decode_info
->width
;
526 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
527 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
530 decode_info
->resolution_unit
= 0;
531 pTIFFGetField(tiff
, TIFFTAG_RESOLUTIONUNIT
, &decode_info
->resolution_unit
);
533 ret
= pTIFFGetField(tiff
, TIFFTAG_XRESOLUTION
, &decode_info
->xres
);
536 WARN("missing X resolution\n");
538 /* Emulate the behavior of current libtiff versions (libtiff commit a39f6131)
539 * yielding 0 instead of INFINITY for IFD_RATIONAL fields with denominator 0. */
540 if (!isfinite(decode_info
->xres
))
542 decode_info
->xres
= 0.0;
545 ret
= pTIFFGetField(tiff
, TIFFTAG_YRESOLUTION
, &decode_info
->yres
);
548 WARN("missing Y resolution\n");
550 if (!isfinite(decode_info
->yres
))
552 decode_info
->yres
= 0.0;
558 static HRESULT WINAPI
TiffDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
561 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
562 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
564 if (!ppv
) return E_INVALIDARG
;
566 if (IsEqualIID(&IID_IUnknown
, iid
) ||
567 IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
569 *ppv
= &This
->IWICBitmapDecoder_iface
;
574 return E_NOINTERFACE
;
577 IUnknown_AddRef((IUnknown
*)*ppv
);
581 static ULONG WINAPI
TiffDecoder_AddRef(IWICBitmapDecoder
*iface
)
583 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
584 ULONG ref
= InterlockedIncrement(&This
->ref
);
586 TRACE("(%p) refcount=%u\n", iface
, ref
);
591 static ULONG WINAPI
TiffDecoder_Release(IWICBitmapDecoder
*iface
)
593 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
594 ULONG ref
= InterlockedDecrement(&This
->ref
);
596 TRACE("(%p) refcount=%u\n", iface
, ref
);
600 if (This
->tiff
) pTIFFClose(This
->tiff
);
601 if (This
->stream
) IStream_Release(This
->stream
);
602 This
->lock
.DebugInfo
->Spare
[0] = 0;
603 DeleteCriticalSection(&This
->lock
);
604 HeapFree(GetProcessHeap(), 0, This
);
610 static HRESULT WINAPI
TiffDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*stream
,
615 TRACE("(%p,%p,%p)\n", iface
, stream
, capability
);
617 if (!stream
|| !capability
) return E_INVALIDARG
;
619 hr
= IWICBitmapDecoder_Initialize(iface
, stream
, WICDecodeMetadataCacheOnDemand
);
620 if (hr
!= S_OK
) return hr
;
622 *capability
= WICBitmapDecoderCapabilityCanDecodeAllImages
|
623 WICBitmapDecoderCapabilityCanDecodeSomeImages
|
624 WICBitmapDecoderCapabilityCanEnumerateMetadata
;
628 static HRESULT WINAPI
TiffDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
629 WICDecodeOptions cacheOptions
)
631 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
635 TRACE("(%p,%p,%x)\n", iface
, pIStream
, cacheOptions
);
637 EnterCriticalSection(&This
->lock
);
639 if (This
->initialized
)
641 hr
= WINCODEC_ERR_WRONGSTATE
;
645 tiff
= tiff_open_stream(pIStream
, "r");
654 This
->stream
= pIStream
;
655 IStream_AddRef(pIStream
);
656 This
->initialized
= TRUE
;
659 LeaveCriticalSection(&This
->lock
);
663 static HRESULT WINAPI
TiffDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
664 GUID
*pguidContainerFormat
)
666 if (!pguidContainerFormat
) return E_INVALIDARG
;
668 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
672 static HRESULT WINAPI
TiffDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
673 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
675 TRACE("(%p,%p)\n", iface
, ppIDecoderInfo
);
677 return get_decoder_info(&CLSID_WICTiffDecoder
, ppIDecoderInfo
);
680 static HRESULT WINAPI
TiffDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
681 IWICPalette
*palette
)
683 TRACE("(%p,%p)\n", iface
, palette
);
684 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
687 static HRESULT WINAPI
TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
688 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
690 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
694 static HRESULT WINAPI
TiffDecoder_GetPreview(IWICBitmapDecoder
*iface
,
695 IWICBitmapSource
**ppIBitmapSource
)
697 TRACE("(%p,%p)\n", iface
, ppIBitmapSource
);
699 if (!ppIBitmapSource
) return E_INVALIDARG
;
701 *ppIBitmapSource
= NULL
;
702 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
705 static HRESULT WINAPI
TiffDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
706 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
708 FIXME("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
709 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
712 static HRESULT WINAPI
TiffDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
713 IWICBitmapSource
**ppIThumbnail
)
715 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
717 if (!ppIThumbnail
) return E_INVALIDARG
;
719 *ppIThumbnail
= NULL
;
720 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
723 static HRESULT WINAPI
TiffDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
726 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
728 if (!pCount
) return E_INVALIDARG
;
730 EnterCriticalSection(&This
->lock
);
731 *pCount
= This
->tiff
? pTIFFNumberOfDirectories(This
->tiff
) : 0;
732 LeaveCriticalSection(&This
->lock
);
734 TRACE("(%p) <-- %i\n", iface
, *pCount
);
739 static HRESULT WINAPI
TiffDecoder_GetFrame(IWICBitmapDecoder
*iface
,
740 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
742 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
743 TiffFrameDecode
*result
;
745 tiff_decode_info decode_info
;
748 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
751 return WINCODEC_ERR_FRAMEMISSING
;
753 EnterCriticalSection(&This
->lock
);
754 res
= pTIFFSetDirectory(This
->tiff
, index
);
755 if (!res
) hr
= E_INVALIDARG
;
756 else hr
= tiff_get_decode_info(This
->tiff
, &decode_info
);
757 LeaveCriticalSection(&This
->lock
);
761 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode
));
765 result
->IWICBitmapFrameDecode_iface
.lpVtbl
= &TiffFrameDecode_Vtbl
;
766 result
->IWICMetadataBlockReader_iface
.lpVtbl
= &TiffFrameDecode_BlockVtbl
;
768 result
->parent
= This
;
769 result
->index
= index
;
770 result
->decode_info
= decode_info
;
771 result
->cached_tile_x
= -1;
772 result
->cached_tile
= HeapAlloc(GetProcessHeap(), 0, decode_info
.tile_size
);
774 if (result
->cached_tile
)
775 *ppIBitmapFrame
= &result
->IWICBitmapFrameDecode_iface
;
779 HeapFree(GetProcessHeap(), 0, result
);
782 else hr
= E_OUTOFMEMORY
;
785 if (FAILED(hr
)) *ppIBitmapFrame
= NULL
;
790 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl
= {
791 TiffDecoder_QueryInterface
,
794 TiffDecoder_QueryCapability
,
795 TiffDecoder_Initialize
,
796 TiffDecoder_GetContainerFormat
,
797 TiffDecoder_GetDecoderInfo
,
798 TiffDecoder_CopyPalette
,
799 TiffDecoder_GetMetadataQueryReader
,
800 TiffDecoder_GetPreview
,
801 TiffDecoder_GetColorContexts
,
802 TiffDecoder_GetThumbnail
,
803 TiffDecoder_GetFrameCount
,
807 static HRESULT WINAPI
TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
810 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
811 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
813 if (!ppv
) return E_INVALIDARG
;
815 if (IsEqualIID(&IID_IUnknown
, iid
) ||
816 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
817 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
819 *ppv
= &This
->IWICBitmapFrameDecode_iface
;
821 else if (IsEqualIID(&IID_IWICMetadataBlockReader
, iid
))
823 *ppv
= &This
->IWICMetadataBlockReader_iface
;
828 return E_NOINTERFACE
;
831 IUnknown_AddRef((IUnknown
*)*ppv
);
835 static ULONG WINAPI
TiffFrameDecode_AddRef(IWICBitmapFrameDecode
*iface
)
837 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
838 ULONG ref
= InterlockedIncrement(&This
->ref
);
840 TRACE("(%p) refcount=%u\n", iface
, ref
);
845 static ULONG WINAPI
TiffFrameDecode_Release(IWICBitmapFrameDecode
*iface
)
847 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
848 ULONG ref
= InterlockedDecrement(&This
->ref
);
850 TRACE("(%p) refcount=%u\n", iface
, ref
);
854 HeapFree(GetProcessHeap(), 0, This
->cached_tile
);
855 HeapFree(GetProcessHeap(), 0, This
);
861 static HRESULT WINAPI
TiffFrameDecode_GetSize(IWICBitmapFrameDecode
*iface
,
862 UINT
*puiWidth
, UINT
*puiHeight
)
864 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
866 *puiWidth
= This
->decode_info
.width
;
867 *puiHeight
= This
->decode_info
.height
;
869 TRACE("(%p) <-- %ux%u\n", iface
, *puiWidth
, *puiHeight
);
874 static HRESULT WINAPI
TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
875 WICPixelFormatGUID
*pPixelFormat
)
877 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
879 memcpy(pPixelFormat
, This
->decode_info
.format
, sizeof(GUID
));
881 TRACE("(%p) <-- %s\n", This
, debugstr_guid(This
->decode_info
.format
));
886 static HRESULT WINAPI
TiffFrameDecode_GetResolution(IWICBitmapFrameDecode
*iface
,
887 double *pDpiX
, double *pDpiY
)
889 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
891 if (This
->decode_info
.xres
== 0 || This
->decode_info
.yres
== 0)
893 *pDpiX
= *pDpiY
= 96.0;
897 switch (This
->decode_info
.resolution_unit
)
900 FIXME("unknown resolution unit %i\n", This
->decode_info
.resolution_unit
);
902 case 0: /* Not set */
903 case 1: /* Relative measurements */
905 *pDpiX
= This
->decode_info
.xres
;
906 *pDpiY
= This
->decode_info
.yres
;
908 case 3: /* Centimeter */
909 *pDpiX
= This
->decode_info
.xres
* 2.54;
910 *pDpiY
= This
->decode_info
.yres
* 2.54;
915 TRACE("(%p) <-- %f,%f unit=%i\n", iface
, *pDpiX
, *pDpiY
, This
->decode_info
.resolution_unit
);
920 static HRESULT WINAPI
TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode
*iface
,
921 IWICPalette
*pIPalette
)
923 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
924 uint16
*red
, *green
, *blue
;
925 WICColor colors
[256];
926 int color_count
, ret
, i
;
928 TRACE("(%p,%p)\n", iface
, pIPalette
);
930 color_count
= 1<<This
->decode_info
.bps
;
932 EnterCriticalSection(&This
->parent
->lock
);
933 ret
= pTIFFGetField(This
->parent
->tiff
, TIFFTAG_COLORMAP
, &red
, &green
, &blue
);
934 LeaveCriticalSection(&This
->parent
->lock
);
938 WARN("Couldn't read color map\n");
939 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
942 for (i
=0; i
<color_count
; i
++)
944 colors
[i
] = 0xff000000 |
945 ((red
[i
]<<8) & 0xff0000) |
946 (green
[i
] & 0xff00) |
947 ((blue
[i
]>>8) & 0xff);
950 return IWICPalette_InitializeCustom(pIPalette
, colors
, color_count
);
953 static HRESULT
TiffFrameDecode_ReadTile(TiffFrameDecode
*This
, UINT tile_x
, UINT tile_y
)
959 swap_bytes
= pTIFFIsByteSwapped(This
->parent
->tiff
);
961 ret
= pTIFFSetDirectory(This
->parent
->tiff
, This
->index
);
968 if (This
->decode_info
.tiled
)
970 ret
= pTIFFReadEncodedTile(This
->parent
->tiff
, tile_x
+ tile_y
* This
->decode_info
.tiles_across
, This
->cached_tile
, This
->decode_info
.tile_size
);
974 ret
= pTIFFReadEncodedStrip(This
->parent
->tiff
, tile_y
, This
->cached_tile
, This
->decode_info
.tile_size
);
981 /* 8bpp grayscale with extra alpha */
982 if (hr
== S_OK
&& This
->decode_info
.source_bpp
== 16 && This
->decode_info
.samples
== 2 && This
->decode_info
.bpp
== 32)
985 DWORD
*dst
, count
= This
->decode_info
.tile_width
* This
->decode_info
.tile_height
;
987 src
= This
->cached_tile
+ This
->decode_info
.tile_width
* This
->decode_info
.tile_height
* 2 - 2;
988 dst
= (DWORD
*)(This
->cached_tile
+ This
->decode_info
.tile_size
- 4);
992 *dst
-- = src
[0] | (src
[0] << 8) | (src
[0] << 16) | (src
[1] << 24);
997 if (hr
== S_OK
&& This
->decode_info
.reverse_bgr
)
999 if (This
->decode_info
.bps
== 8)
1001 UINT sample_count
= This
->decode_info
.samples
;
1003 reverse_bgr8(sample_count
, This
->cached_tile
, This
->decode_info
.tile_width
,
1004 This
->decode_info
.tile_height
, This
->decode_info
.tile_width
* sample_count
);
1008 if (hr
== S_OK
&& swap_bytes
&& This
->decode_info
.bps
> 8)
1010 UINT row
, i
, samples_per_row
;
1013 samples_per_row
= This
->decode_info
.tile_width
* This
->decode_info
.samples
;
1015 switch(This
->decode_info
.bps
)
1018 for (row
=0; row
<This
->decode_info
.tile_height
; row
++)
1020 sample
= This
->cached_tile
+ row
* This
->decode_info
.tile_stride
;
1021 for (i
=0; i
<samples_per_row
; i
++)
1024 sample
[1] = sample
[0];
1031 ERR("unhandled bps for byte swap %u\n", This
->decode_info
.bps
);
1036 if (hr
== S_OK
&& This
->decode_info
.invert_grayscale
)
1040 if (This
->decode_info
.samples
!= 1)
1042 ERR("cannot invert grayscale image with %u samples\n", This
->decode_info
.samples
);
1046 end
= This
->cached_tile
+This
->decode_info
.tile_size
;
1048 for (byte
= This
->cached_tile
; byte
!= end
; byte
++)
1054 This
->cached_tile_x
= tile_x
;
1055 This
->cached_tile_y
= tile_y
;
1061 static HRESULT WINAPI
TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode
*iface
,
1062 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
1064 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1065 UINT min_tile_x
, max_tile_x
, min_tile_y
, max_tile_y
;
1066 UINT tile_x
, tile_y
;
1073 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
1079 rect
.Width
= This
->decode_info
.width
;
1080 rect
.Height
= This
->decode_info
.height
;
1085 if (prc
->X
< 0 || prc
->Y
< 0 || prc
->X
+prc
->Width
> This
->decode_info
.width
||
1086 prc
->Y
+prc
->Height
> This
->decode_info
.height
)
1087 return E_INVALIDARG
;
1090 bytesperrow
= ((This
->decode_info
.bpp
* prc
->Width
)+7)/8;
1092 if (cbStride
< bytesperrow
)
1093 return E_INVALIDARG
;
1095 if ((cbStride
* prc
->Height
) > cbBufferSize
)
1096 return E_INVALIDARG
;
1098 min_tile_x
= prc
->X
/ This
->decode_info
.tile_width
;
1099 min_tile_y
= prc
->Y
/ This
->decode_info
.tile_height
;
1100 max_tile_x
= (prc
->X
+prc
->Width
-1) / This
->decode_info
.tile_width
;
1101 max_tile_y
= (prc
->Y
+prc
->Height
-1) / This
->decode_info
.tile_height
;
1103 EnterCriticalSection(&This
->parent
->lock
);
1105 for (tile_x
=min_tile_x
; tile_x
<= max_tile_x
; tile_x
++)
1107 for (tile_y
=min_tile_y
; tile_y
<= max_tile_y
; tile_y
++)
1109 if (tile_x
!= This
->cached_tile_x
|| tile_y
!= This
->cached_tile_y
)
1111 hr
= TiffFrameDecode_ReadTile(This
, tile_x
, tile_y
);
1116 if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1119 rc
.X
= prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1121 if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1124 rc
.Y
= prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1126 if (prc
->X
+prc
->Width
> (tile_x
+1) * This
->decode_info
.tile_width
)
1127 rc
.Width
= This
->decode_info
.tile_width
- rc
.X
;
1128 else if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1129 rc
.Width
= prc
->Width
+ prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1131 rc
.Width
= prc
->Width
;
1133 if (prc
->Y
+prc
->Height
> (tile_y
+1) * This
->decode_info
.tile_height
)
1134 rc
.Height
= This
->decode_info
.tile_height
- rc
.Y
;
1135 else if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1136 rc
.Height
= prc
->Height
+ prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1138 rc
.Height
= prc
->Height
;
1140 dst_tilepos
= pbBuffer
+ (cbStride
* ((rc
.Y
+ tile_y
* This
->decode_info
.tile_height
) - prc
->Y
)) +
1141 ((This
->decode_info
.bpp
* ((rc
.X
+ tile_x
* This
->decode_info
.tile_width
) - prc
->X
) + 7) / 8);
1143 hr
= copy_pixels(This
->decode_info
.bpp
, This
->cached_tile
,
1144 This
->decode_info
.tile_width
, This
->decode_info
.tile_height
, This
->decode_info
.tile_stride
,
1145 &rc
, cbStride
, cbBufferSize
, dst_tilepos
);
1150 LeaveCriticalSection(&This
->parent
->lock
);
1151 TRACE("<-- 0x%x\n", hr
);
1157 LeaveCriticalSection(&This
->parent
->lock
);
1162 static HRESULT WINAPI
TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
1163 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
1165 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1167 TRACE("(%p,%p)\n", iface
, ppIMetadataQueryReader
);
1169 if (!ppIMetadataQueryReader
)
1170 return E_INVALIDARG
;
1172 return MetadataQueryReader_CreateInstance(&This
->IWICMetadataBlockReader_iface
, NULL
, ppIMetadataQueryReader
);
1175 static HRESULT WINAPI
TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode
*iface
,
1176 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
1178 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1179 const BYTE
*profile
;
1183 TRACE("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
1185 EnterCriticalSection(&This
->parent
->lock
);
1187 if (pTIFFGetField(This
->parent
->tiff
, TIFFTAG_ICCPROFILE
, &len
, &profile
))
1189 if (cCount
&& ppIColorContexts
)
1191 hr
= IWICColorContext_InitializeFromMemory(*ppIColorContexts
, profile
, len
);
1194 LeaveCriticalSection(&This
->parent
->lock
);
1203 LeaveCriticalSection(&This
->parent
->lock
);
1208 static HRESULT WINAPI
TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode
*iface
,
1209 IWICBitmapSource
**ppIThumbnail
)
1211 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
1213 if (!ppIThumbnail
) return E_INVALIDARG
;
1215 *ppIThumbnail
= NULL
;
1216 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
1219 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
= {
1220 TiffFrameDecode_QueryInterface
,
1221 TiffFrameDecode_AddRef
,
1222 TiffFrameDecode_Release
,
1223 TiffFrameDecode_GetSize
,
1224 TiffFrameDecode_GetPixelFormat
,
1225 TiffFrameDecode_GetResolution
,
1226 TiffFrameDecode_CopyPalette
,
1227 TiffFrameDecode_CopyPixels
,
1228 TiffFrameDecode_GetMetadataQueryReader
,
1229 TiffFrameDecode_GetColorContexts
,
1230 TiffFrameDecode_GetThumbnail
1233 static HRESULT WINAPI
TiffFrameDecode_Block_QueryInterface(IWICMetadataBlockReader
*iface
,
1234 REFIID iid
, void **ppv
)
1236 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1237 return IWICBitmapFrameDecode_QueryInterface(&This
->IWICBitmapFrameDecode_iface
, iid
, ppv
);
1240 static ULONG WINAPI
TiffFrameDecode_Block_AddRef(IWICMetadataBlockReader
*iface
)
1242 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1243 return IWICBitmapFrameDecode_AddRef(&This
->IWICBitmapFrameDecode_iface
);
1246 static ULONG WINAPI
TiffFrameDecode_Block_Release(IWICMetadataBlockReader
*iface
)
1248 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1249 return IWICBitmapFrameDecode_Release(&This
->IWICBitmapFrameDecode_iface
);
1252 static HRESULT WINAPI
TiffFrameDecode_Block_GetContainerFormat(IWICMetadataBlockReader
*iface
,
1255 TRACE("(%p,%p)\n", iface
, guid
);
1257 if (!guid
) return E_INVALIDARG
;
1259 *guid
= GUID_ContainerFormatTiff
;
1263 static HRESULT WINAPI
TiffFrameDecode_Block_GetCount(IWICMetadataBlockReader
*iface
,
1266 TRACE("%p,%p\n", iface
, count
);
1268 if (!count
) return E_INVALIDARG
;
1274 static HRESULT
create_metadata_reader(TiffFrameDecode
*This
, IWICMetadataReader
**reader
)
1277 LARGE_INTEGER dir_offset
;
1278 IWICMetadataReader
*metadata_reader
;
1279 IWICPersistStream
*persist
;
1281 /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
1283 hr
= IfdMetadataReader_CreateInstance(&IID_IWICMetadataReader
, (void **)&metadata_reader
);
1284 if (FAILED(hr
)) return hr
;
1286 hr
= IWICMetadataReader_QueryInterface(metadata_reader
, &IID_IWICPersistStream
, (void **)&persist
);
1289 IWICMetadataReader_Release(metadata_reader
);
1293 EnterCriticalSection(&This
->parent
->lock
);
1295 dir_offset
.QuadPart
= pTIFFCurrentDirOffset(This
->parent
->tiff
);
1296 hr
= IStream_Seek(This
->parent
->stream
, dir_offset
, STREAM_SEEK_SET
, NULL
);
1299 BOOL byte_swapped
= pTIFFIsByteSwapped(This
->parent
->tiff
);
1300 #ifdef WORDS_BIGENDIAN
1301 DWORD persist_options
= byte_swapped
? WICPersistOptionLittleEndian
: WICPersistOptionBigEndian
;
1303 DWORD persist_options
= byte_swapped
? WICPersistOptionBigEndian
: WICPersistOptionLittleEndian
;
1305 persist_options
|= WICPersistOptionNoCacheStream
;
1306 hr
= IWICPersistStream_LoadEx(persist
, This
->parent
->stream
, NULL
, persist_options
);
1308 ERR("IWICPersistStream_LoadEx error %#x\n", hr
);
1311 LeaveCriticalSection(&This
->parent
->lock
);
1313 IWICPersistStream_Release(persist
);
1317 IWICMetadataReader_Release(metadata_reader
);
1321 *reader
= metadata_reader
;
1325 static HRESULT WINAPI
TiffFrameDecode_Block_GetReaderByIndex(IWICMetadataBlockReader
*iface
,
1326 UINT index
, IWICMetadataReader
**reader
)
1328 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1330 TRACE("(%p,%u,%p)\n", iface
, index
, reader
);
1332 if (!reader
|| index
!= 0) return E_INVALIDARG
;
1334 return create_metadata_reader(This
, reader
);
1337 static HRESULT WINAPI
TiffFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader
*iface
,
1338 IEnumUnknown
**enum_metadata
)
1340 FIXME("(%p,%p): stub\n", iface
, enum_metadata
);
1344 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl
=
1346 TiffFrameDecode_Block_QueryInterface
,
1347 TiffFrameDecode_Block_AddRef
,
1348 TiffFrameDecode_Block_Release
,
1349 TiffFrameDecode_Block_GetContainerFormat
,
1350 TiffFrameDecode_Block_GetCount
,
1351 TiffFrameDecode_Block_GetReaderByIndex
,
1352 TiffFrameDecode_Block_GetEnumerator
1355 HRESULT
TiffDecoder_CreateInstance(REFIID iid
, void** ppv
)
1360 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
1364 if (!load_libtiff())
1366 ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF
);
1370 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder
));
1371 if (!This
) return E_OUTOFMEMORY
;
1373 This
->IWICBitmapDecoder_iface
.lpVtbl
= &TiffDecoder_Vtbl
;
1375 This
->stream
= NULL
;
1376 InitializeCriticalSection(&This
->lock
);
1377 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffDecoder.lock");
1379 This
->initialized
= FALSE
;
1381 ret
= IWICBitmapDecoder_QueryInterface(&This
->IWICBitmapDecoder_iface
, iid
, ppv
);
1382 IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
1387 struct tiff_encode_format
{
1388 const WICPixelFormatGUID
*guid
;
1394 int extra_sample_type
;
1398 static const struct tiff_encode_format formats
[] = {
1399 {&GUID_WICPixelFormat24bppBGR
, 2, 8, 3, 24, 0, 0, 1},
1400 {&GUID_WICPixelFormat24bppRGB
, 2, 8, 3, 24, 0, 0, 0},
1401 {&GUID_WICPixelFormatBlackWhite
, 1, 1, 1, 1, 0, 0, 0},
1402 {&GUID_WICPixelFormat4bppGray
, 1, 4, 1, 4, 0, 0, 0},
1403 {&GUID_WICPixelFormat8bppGray
, 1, 8, 1, 8, 0, 0, 0},
1404 {&GUID_WICPixelFormat32bppBGRA
, 2, 8, 4, 32, 1, 2, 1},
1405 {&GUID_WICPixelFormat32bppPBGRA
, 2, 8, 4, 32, 1, 1, 1},
1406 {&GUID_WICPixelFormat48bppRGB
, 2, 16, 3, 48, 0, 0, 0},
1407 {&GUID_WICPixelFormat64bppRGBA
, 2, 16, 4, 64, 1, 2, 0},
1408 {&GUID_WICPixelFormat64bppPRGBA
, 2, 16, 4, 64, 1, 1, 0},
1412 typedef struct TiffEncoder
{
1413 IWICBitmapEncoder IWICBitmapEncoder_iface
;
1416 CRITICAL_SECTION lock
; /* Must be held when tiff is used or fields below are set */
1421 ULONG num_frames_committed
;
1424 static inline TiffEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
1426 return CONTAINING_RECORD(iface
, TiffEncoder
, IWICBitmapEncoder_iface
);
1429 typedef struct TiffFrameEncode
{
1430 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
1432 TiffEncoder
*parent
;
1433 /* fields below are protected by parent->lock */
1437 const struct tiff_encode_format
*format
;
1441 WICColor palette
[256];
1445 static inline TiffFrameEncode
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
1447 return CONTAINING_RECORD(iface
, TiffFrameEncode
, IWICBitmapFrameEncode_iface
);
1450 static HRESULT WINAPI
TiffFrameEncode_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
1453 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1454 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1456 if (!ppv
) return E_INVALIDARG
;
1458 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1459 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
1461 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
1466 return E_NOINTERFACE
;
1469 IUnknown_AddRef((IUnknown
*)*ppv
);
1473 static ULONG WINAPI
TiffFrameEncode_AddRef(IWICBitmapFrameEncode
*iface
)
1475 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1476 ULONG ref
= InterlockedIncrement(&This
->ref
);
1478 TRACE("(%p) refcount=%u\n", iface
, ref
);
1483 static ULONG WINAPI
TiffFrameEncode_Release(IWICBitmapFrameEncode
*iface
)
1485 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1486 ULONG ref
= InterlockedDecrement(&This
->ref
);
1488 TRACE("(%p) refcount=%u\n", iface
, ref
);
1492 IWICBitmapEncoder_Release(&This
->parent
->IWICBitmapEncoder_iface
);
1493 HeapFree(GetProcessHeap(), 0, This
);
1499 static HRESULT WINAPI
TiffFrameEncode_Initialize(IWICBitmapFrameEncode
*iface
,
1500 IPropertyBag2
*pIEncoderOptions
)
1502 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1503 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
1505 EnterCriticalSection(&This
->parent
->lock
);
1507 if (This
->initialized
)
1509 LeaveCriticalSection(&This
->parent
->lock
);
1510 return WINCODEC_ERR_WRONGSTATE
;
1513 This
->initialized
= TRUE
;
1515 LeaveCriticalSection(&This
->parent
->lock
);
1520 static HRESULT WINAPI
TiffFrameEncode_SetSize(IWICBitmapFrameEncode
*iface
,
1521 UINT uiWidth
, UINT uiHeight
)
1523 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1524 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
1526 EnterCriticalSection(&This
->parent
->lock
);
1528 if (!This
->initialized
|| This
->info_written
)
1530 LeaveCriticalSection(&This
->parent
->lock
);
1531 return WINCODEC_ERR_WRONGSTATE
;
1534 This
->width
= uiWidth
;
1535 This
->height
= uiHeight
;
1537 LeaveCriticalSection(&This
->parent
->lock
);
1542 static HRESULT WINAPI
TiffFrameEncode_SetResolution(IWICBitmapFrameEncode
*iface
,
1543 double dpiX
, double dpiY
)
1545 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1546 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
1548 EnterCriticalSection(&This
->parent
->lock
);
1550 if (!This
->initialized
|| This
->info_written
)
1552 LeaveCriticalSection(&This
->parent
->lock
);
1553 return WINCODEC_ERR_WRONGSTATE
;
1559 LeaveCriticalSection(&This
->parent
->lock
);
1564 static HRESULT WINAPI
TiffFrameEncode_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
1565 WICPixelFormatGUID
*pPixelFormat
)
1567 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1570 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
1572 EnterCriticalSection(&This
->parent
->lock
);
1574 if (!This
->initialized
|| This
->info_written
)
1576 LeaveCriticalSection(&This
->parent
->lock
);
1577 return WINCODEC_ERR_WRONGSTATE
;
1580 for (i
=0; formats
[i
].guid
; i
++)
1582 if (memcmp(formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
1586 if (!formats
[i
].guid
) i
= 0;
1588 This
->format
= &formats
[i
];
1589 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
1591 LeaveCriticalSection(&This
->parent
->lock
);
1596 static HRESULT WINAPI
TiffFrameEncode_SetColorContexts(IWICBitmapFrameEncode
*iface
,
1597 UINT cCount
, IWICColorContext
**ppIColorContext
)
1599 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1603 static HRESULT WINAPI
TiffFrameEncode_SetPalette(IWICBitmapFrameEncode
*iface
,
1604 IWICPalette
*palette
)
1606 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1609 TRACE("(%p,%p)\n", iface
, palette
);
1611 if (!palette
) return E_INVALIDARG
;
1613 EnterCriticalSection(&This
->parent
->lock
);
1615 if (This
->initialized
)
1616 hr
= IWICPalette_GetColors(palette
, 256, This
->palette
, &This
->colors
);
1618 hr
= WINCODEC_ERR_NOTINITIALIZED
;
1620 LeaveCriticalSection(&This
->parent
->lock
);
1624 static HRESULT WINAPI
TiffFrameEncode_SetThumbnail(IWICBitmapFrameEncode
*iface
,
1625 IWICBitmapSource
*pIThumbnail
)
1627 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
1628 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1631 static HRESULT WINAPI
TiffFrameEncode_WritePixels(IWICBitmapFrameEncode
*iface
,
1632 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
1634 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1635 BYTE
*row_data
, *swapped_data
= NULL
;
1636 UINT i
, j
, line_size
;
1638 TRACE("(%p,%u,%u,%u,%p)\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
1640 EnterCriticalSection(&This
->parent
->lock
);
1642 if (!This
->initialized
|| !This
->width
|| !This
->height
|| !This
->format
)
1644 LeaveCriticalSection(&This
->parent
->lock
);
1645 return WINCODEC_ERR_WRONGSTATE
;
1648 if (lineCount
== 0 || lineCount
+ This
->lines_written
> This
->height
)
1650 LeaveCriticalSection(&This
->parent
->lock
);
1651 return E_INVALIDARG
;
1654 line_size
= ((This
->width
* This
->format
->bpp
)+7)/8;
1656 if (This
->format
->reverse_bgr
)
1658 swapped_data
= HeapAlloc(GetProcessHeap(), 0, line_size
);
1661 LeaveCriticalSection(&This
->parent
->lock
);
1662 return E_OUTOFMEMORY
;
1666 if (!This
->info_written
)
1668 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PHOTOMETRIC
, (uint16
)This
->format
->photometric
);
1669 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PLANARCONFIG
, (uint16
)1);
1670 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_BITSPERSAMPLE
, (uint16
)This
->format
->bps
);
1671 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_SAMPLESPERPIXEL
, (uint16
)This
->format
->samples
);
1673 if (This
->format
->extra_sample
)
1675 uint16 extra_samples
;
1676 extra_samples
= This
->format
->extra_sample_type
;
1678 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_EXTRASAMPLES
, (uint16
)1, &extra_samples
);
1681 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGEWIDTH
, (uint32
)This
->width
);
1682 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGELENGTH
, (uint32
)This
->height
);
1684 if (This
->xres
!= 0.0 && This
->yres
!= 0.0)
1686 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_RESOLUTIONUNIT
, (uint16
)2); /* Inch */
1687 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_XRESOLUTION
, (float)This
->xres
);
1688 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_YRESOLUTION
, (float)This
->yres
);
1691 This
->info_written
= TRUE
;
1694 for (i
=0; i
<lineCount
; i
++)
1696 row_data
= pbPixels
+ i
* cbStride
;
1698 if (This
->format
->reverse_bgr
&& This
->format
->bps
== 8)
1700 memcpy(swapped_data
, row_data
, line_size
);
1701 for (j
=0; j
<line_size
; j
+= This
->format
->samples
)
1704 temp
= swapped_data
[j
];
1705 swapped_data
[j
] = swapped_data
[j
+2];
1706 swapped_data
[j
+2] = temp
;
1708 row_data
= swapped_data
;
1711 pTIFFWriteScanline(This
->parent
->tiff
, (tdata_t
)row_data
, i
+This
->lines_written
, 0);
1714 This
->lines_written
+= lineCount
;
1716 LeaveCriticalSection(&This
->parent
->lock
);
1718 HeapFree(GetProcessHeap(), 0, swapped_data
);
1723 static HRESULT WINAPI
TiffFrameEncode_WriteSource(IWICBitmapFrameEncode
*iface
,
1724 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
1726 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1729 TRACE("(%p,%p,%p)\n", iface
, pIBitmapSource
, prc
);
1731 if (!This
->initialized
)
1732 return WINCODEC_ERR_WRONGSTATE
;
1734 hr
= configure_write_source(iface
, pIBitmapSource
, prc
,
1735 This
->format
? This
->format
->guid
: NULL
, This
->width
, This
->height
,
1736 This
->xres
, This
->yres
);
1740 hr
= write_source(iface
, pIBitmapSource
, prc
,
1741 This
->format
->guid
, This
->format
->bpp
, This
->width
, This
->height
);
1747 static HRESULT WINAPI
TiffFrameEncode_Commit(IWICBitmapFrameEncode
*iface
)
1749 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1751 TRACE("(%p)\n", iface
);
1753 EnterCriticalSection(&This
->parent
->lock
);
1755 if (!This
->info_written
|| This
->lines_written
!= This
->height
|| This
->committed
)
1757 LeaveCriticalSection(&This
->parent
->lock
);
1758 return WINCODEC_ERR_WRONGSTATE
;
1761 /* libtiff will commit the data when creating a new frame or closing the file */
1763 This
->committed
= TRUE
;
1764 This
->parent
->num_frames_committed
++;
1766 LeaveCriticalSection(&This
->parent
->lock
);
1771 static HRESULT WINAPI
TiffFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
1772 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1774 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
1778 static const IWICBitmapFrameEncodeVtbl TiffFrameEncode_Vtbl
= {
1779 TiffFrameEncode_QueryInterface
,
1780 TiffFrameEncode_AddRef
,
1781 TiffFrameEncode_Release
,
1782 TiffFrameEncode_Initialize
,
1783 TiffFrameEncode_SetSize
,
1784 TiffFrameEncode_SetResolution
,
1785 TiffFrameEncode_SetPixelFormat
,
1786 TiffFrameEncode_SetColorContexts
,
1787 TiffFrameEncode_SetPalette
,
1788 TiffFrameEncode_SetThumbnail
,
1789 TiffFrameEncode_WritePixels
,
1790 TiffFrameEncode_WriteSource
,
1791 TiffFrameEncode_Commit
,
1792 TiffFrameEncode_GetMetadataQueryWriter
1795 static HRESULT WINAPI
TiffEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
1798 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1799 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1801 if (!ppv
) return E_INVALIDARG
;
1803 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1804 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1806 *ppv
= &This
->IWICBitmapEncoder_iface
;
1811 return E_NOINTERFACE
;
1814 IUnknown_AddRef((IUnknown
*)*ppv
);
1818 static ULONG WINAPI
TiffEncoder_AddRef(IWICBitmapEncoder
*iface
)
1820 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1821 ULONG ref
= InterlockedIncrement(&This
->ref
);
1823 TRACE("(%p) refcount=%u\n", iface
, ref
);
1828 static ULONG WINAPI
TiffEncoder_Release(IWICBitmapEncoder
*iface
)
1830 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1831 ULONG ref
= InterlockedDecrement(&This
->ref
);
1833 TRACE("(%p) refcount=%u\n", iface
, ref
);
1837 if (This
->tiff
) pTIFFClose(This
->tiff
);
1838 if (This
->stream
) IStream_Release(This
->stream
);
1839 This
->lock
.DebugInfo
->Spare
[0] = 0;
1840 DeleteCriticalSection(&This
->lock
);
1841 HeapFree(GetProcessHeap(), 0, This
);
1847 static HRESULT WINAPI
TiffEncoder_Initialize(IWICBitmapEncoder
*iface
,
1848 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1850 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1854 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1856 EnterCriticalSection(&This
->lock
);
1858 if (This
->initialized
|| This
->committed
)
1860 hr
= WINCODEC_ERR_WRONGSTATE
;
1864 tiff
= tiff_open_stream(pIStream
, "w");
1873 This
->stream
= pIStream
;
1874 IStream_AddRef(pIStream
);
1875 This
->initialized
= TRUE
;
1878 LeaveCriticalSection(&This
->lock
);
1882 static HRESULT WINAPI
TiffEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1883 GUID
*pguidContainerFormat
)
1885 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
1889 static HRESULT WINAPI
TiffEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1890 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1892 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1896 static HRESULT WINAPI
TiffEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1897 UINT cCount
, IWICColorContext
**ppIColorContext
)
1899 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1903 static HRESULT WINAPI
TiffEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*palette
)
1905 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1908 TRACE("(%p,%p)\n", iface
, palette
);
1910 EnterCriticalSection(&This
->lock
);
1912 hr
= This
->stream
? WINCODEC_ERR_UNSUPPORTEDOPERATION
: WINCODEC_ERR_NOTINITIALIZED
;
1914 LeaveCriticalSection(&This
->lock
);
1919 static HRESULT WINAPI
TiffEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1921 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1922 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1925 static HRESULT WINAPI
TiffEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1927 TRACE("(%p,%p)\n", iface
, pIPreview
);
1928 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1931 static HRESULT WINAPI
TiffEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1932 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1934 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1935 TiffFrameEncode
*result
;
1936 static const PROPBAG2 opts
[2] =
1938 { PROPBAG2_TYPE_DATA
, VT_UI1
, 0, 0, (LPOLESTR
)wszTiffCompressionMethod
},
1939 { PROPBAG2_TYPE_DATA
, VT_R4
, 0, 0, (LPOLESTR
)wszCompressionQuality
},
1943 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1945 EnterCriticalSection(&This
->lock
);
1947 if (!This
->initialized
|| This
->committed
)
1949 hr
= WINCODEC_ERR_WRONGSTATE
;
1951 else if (This
->num_frames
!= This
->num_frames_committed
)
1953 FIXME("New frame created before previous frame was committed\n");
1957 if (ppIEncoderOptions
&& SUCCEEDED(hr
))
1959 hr
= CreatePropertyBag2(opts
, sizeof(opts
)/sizeof(opts
[0]), ppIEncoderOptions
);
1965 V_UNION(&v
, bVal
) = WICTiffCompressionDontCare
;
1966 hr
= IPropertyBag2_Write(*ppIEncoderOptions
, 1, (PROPBAG2
*)opts
, &v
);
1970 IPropertyBag2_Release(*ppIEncoderOptions
);
1971 *ppIEncoderOptions
= NULL
;
1978 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(*result
));
1982 result
->IWICBitmapFrameEncode_iface
.lpVtbl
= &TiffFrameEncode_Vtbl
;
1984 result
->parent
= This
;
1985 result
->initialized
= FALSE
;
1986 result
->info_written
= FALSE
;
1987 result
->committed
= FALSE
;
1988 result
->format
= NULL
;
1993 result
->lines_written
= 0;
1996 IWICBitmapEncoder_AddRef(iface
);
1997 *ppIFrameEncode
= &result
->IWICBitmapFrameEncode_iface
;
1999 if (This
->num_frames
!= 0)
2000 pTIFFWriteDirectory(This
->tiff
);
2009 IPropertyBag2_Release(*ppIEncoderOptions
);
2010 *ppIEncoderOptions
= NULL
;
2014 LeaveCriticalSection(&This
->lock
);
2019 static HRESULT WINAPI
TiffEncoder_Commit(IWICBitmapEncoder
*iface
)
2021 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
2023 TRACE("(%p)\n", iface
);
2025 EnterCriticalSection(&This
->lock
);
2027 if (!This
->initialized
|| This
->committed
)
2029 LeaveCriticalSection(&This
->lock
);
2030 return WINCODEC_ERR_WRONGSTATE
;
2033 pTIFFClose(This
->tiff
);
2034 IStream_Release(This
->stream
);
2035 This
->stream
= NULL
;
2038 This
->committed
= TRUE
;
2040 LeaveCriticalSection(&This
->lock
);
2045 static HRESULT WINAPI
TiffEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
2046 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
2048 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
2052 static const IWICBitmapEncoderVtbl TiffEncoder_Vtbl
= {
2053 TiffEncoder_QueryInterface
,
2055 TiffEncoder_Release
,
2056 TiffEncoder_Initialize
,
2057 TiffEncoder_GetContainerFormat
,
2058 TiffEncoder_GetEncoderInfo
,
2059 TiffEncoder_SetColorContexts
,
2060 TiffEncoder_SetPalette
,
2061 TiffEncoder_SetThumbnail
,
2062 TiffEncoder_SetPreview
,
2063 TiffEncoder_CreateNewFrame
,
2065 TiffEncoder_GetMetadataQueryWriter
2068 HRESULT
TiffEncoder_CreateInstance(REFIID iid
, void** ppv
)
2073 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
2077 if (!load_libtiff())
2079 ERR("Failed writing TIFF because unable to load %s\n",SONAME_LIBTIFF
);
2083 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffEncoder
));
2084 if (!This
) return E_OUTOFMEMORY
;
2086 This
->IWICBitmapEncoder_iface
.lpVtbl
= &TiffEncoder_Vtbl
;
2088 This
->stream
= NULL
;
2089 InitializeCriticalSection(&This
->lock
);
2090 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffEncoder.lock");
2092 This
->initialized
= FALSE
;
2093 This
->num_frames
= 0;
2094 This
->num_frames_committed
= 0;
2095 This
->committed
= FALSE
;
2097 ret
= IWICBitmapEncoder_QueryInterface(&This
->IWICBitmapEncoder_iface
, iid
, ppv
);
2098 IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
2103 #else /* !SONAME_LIBTIFF */
2105 HRESULT
TiffDecoder_CreateInstance(REFIID iid
, void** ppv
)
2107 ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
2111 HRESULT
TiffEncoder_CreateInstance(REFIID iid
, void** ppv
)
2113 ERR("Trying to save TIFF picture, but Wine was compiled without TIFF support.\n");