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
19 #include "wincodecs_private.h"
30 /* Workaround for broken libtiff 4.x headers on some 64-bit hosts which
31 * define TIFF_UINT64_T/toff_t as 32-bit for 32-bit builds, while they
32 * are supposed to be always 64-bit.
33 * TIFF_UINT64_T doesn't exist in libtiff 3.x, it was introduced in 4.x.
37 # define toff_t UINT64
40 static CRITICAL_SECTION init_tiff_cs
;
41 static CRITICAL_SECTION_DEBUG init_tiff_cs_debug
=
44 { &init_tiff_cs_debug
.ProcessLocksList
,
45 &init_tiff_cs_debug
.ProcessLocksList
},
46 0, 0, { (DWORD_PTR
)(__FILE__
": init_tiff_cs") }
48 static CRITICAL_SECTION init_tiff_cs
= { &init_tiff_cs_debug
, -1, 0, 0, 0, 0 };
50 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};
51 static const WCHAR wszCompressionQuality
[] = {'C','o','m','p','r','e','s','s','i','o','n','Q','u','a','l','i','t','y',0};
53 static void *libtiff_handle
;
54 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
55 MAKE_FUNCPTR(TIFFClientOpen
);
56 MAKE_FUNCPTR(TIFFClose
);
57 MAKE_FUNCPTR(TIFFCurrentDirOffset
);
58 MAKE_FUNCPTR(TIFFGetField
);
59 MAKE_FUNCPTR(TIFFIsByteSwapped
);
60 MAKE_FUNCPTR(TIFFNumberOfDirectories
);
61 MAKE_FUNCPTR(TIFFReadDirectory
);
62 MAKE_FUNCPTR(TIFFReadEncodedStrip
);
63 MAKE_FUNCPTR(TIFFReadEncodedTile
);
64 MAKE_FUNCPTR(TIFFSetDirectory
);
65 MAKE_FUNCPTR(TIFFSetField
);
66 MAKE_FUNCPTR(TIFFWriteDirectory
);
67 MAKE_FUNCPTR(TIFFWriteScanline
);
70 static void *load_libtiff(void)
74 EnterCriticalSection(&init_tiff_cs
);
76 if (!libtiff_handle
&&
77 (libtiff_handle
= wine_dlopen(SONAME_LIBTIFF
, RTLD_NOW
, NULL
, 0)) != NULL
)
79 void * (*pTIFFSetWarningHandler
)(void *);
80 void * (*pTIFFSetWarningHandlerExt
)(void *);
82 #define LOAD_FUNCPTR(f) \
83 if((p##f = wine_dlsym(libtiff_handle, #f, NULL, 0)) == NULL) { \
84 ERR("failed to load symbol %s\n", #f); \
85 libtiff_handle = NULL; \
86 LeaveCriticalSection(&init_tiff_cs); \
89 LOAD_FUNCPTR(TIFFClientOpen
);
90 LOAD_FUNCPTR(TIFFClose
);
91 LOAD_FUNCPTR(TIFFCurrentDirOffset
);
92 LOAD_FUNCPTR(TIFFGetField
);
93 LOAD_FUNCPTR(TIFFIsByteSwapped
);
94 LOAD_FUNCPTR(TIFFNumberOfDirectories
);
95 LOAD_FUNCPTR(TIFFReadDirectory
);
96 LOAD_FUNCPTR(TIFFReadEncodedStrip
);
97 LOAD_FUNCPTR(TIFFReadEncodedTile
);
98 LOAD_FUNCPTR(TIFFSetDirectory
);
99 LOAD_FUNCPTR(TIFFSetField
);
100 LOAD_FUNCPTR(TIFFWriteDirectory
);
101 LOAD_FUNCPTR(TIFFWriteScanline
);
104 if ((pTIFFSetWarningHandler
= wine_dlsym(libtiff_handle
, "TIFFSetWarningHandler", NULL
, 0)))
105 pTIFFSetWarningHandler(NULL
);
106 if ((pTIFFSetWarningHandlerExt
= wine_dlsym(libtiff_handle
, "TIFFSetWarningHandlerExt", NULL
, 0)))
107 pTIFFSetWarningHandlerExt(NULL
);
110 result
= libtiff_handle
;
112 LeaveCriticalSection(&init_tiff_cs
);
116 static tsize_t
tiff_stream_read(thandle_t client_data
, tdata_t data
, tsize_t size
)
118 IStream
*stream
= (IStream
*)client_data
;
122 hr
= IStream_Read(stream
, data
, size
, &bytes_read
);
123 if (FAILED(hr
)) bytes_read
= 0;
127 static tsize_t
tiff_stream_write(thandle_t client_data
, tdata_t data
, tsize_t size
)
129 IStream
*stream
= (IStream
*)client_data
;
133 hr
= IStream_Write(stream
, data
, size
, &bytes_written
);
134 if (FAILED(hr
)) bytes_written
= 0;
135 return bytes_written
;
138 static toff_t
tiff_stream_seek(thandle_t client_data
, toff_t offset
, int whence
)
140 IStream
*stream
= (IStream
*)client_data
;
143 ULARGE_INTEGER new_position
;
146 move
.QuadPart
= offset
;
150 origin
= STREAM_SEEK_SET
;
153 origin
= STREAM_SEEK_CUR
;
156 origin
= STREAM_SEEK_END
;
159 ERR("unknown whence value %i\n", whence
);
163 hr
= IStream_Seek(stream
, move
, origin
, &new_position
);
164 if (SUCCEEDED(hr
)) return new_position
.QuadPart
;
168 static int tiff_stream_close(thandle_t client_data
)
170 /* Caller is responsible for releasing the stream object. */
174 static toff_t
tiff_stream_size(thandle_t client_data
)
176 IStream
*stream
= (IStream
*)client_data
;
180 hr
= IStream_Stat(stream
, &statstg
, STATFLAG_NONAME
);
182 if (SUCCEEDED(hr
)) return statstg
.cbSize
.QuadPart
;
186 static int tiff_stream_map(thandle_t client_data
, tdata_t
*addr
, toff_t
*size
)
188 /* Cannot mmap streams */
192 static void tiff_stream_unmap(thandle_t client_data
, tdata_t addr
, toff_t size
)
194 /* No need to ever do this, since we can't map things. */
197 static TIFF
* tiff_open_stream(IStream
*stream
, const char *mode
)
202 IStream_Seek(stream
, zero
, STREAM_SEEK_SET
, NULL
);
204 return pTIFFClientOpen("<IStream object>", mode
, stream
, tiff_stream_read
,
205 tiff_stream_write
, (void *)tiff_stream_seek
, tiff_stream_close
,
206 (void *)tiff_stream_size
, (void *)tiff_stream_map
, (void *)tiff_stream_unmap
);
210 IWICBitmapDecoder IWICBitmapDecoder_iface
;
213 CRITICAL_SECTION lock
; /* Must be held when tiff is used or initiailzed is set */
219 const WICPixelFormatGUID
*format
;
226 int invert_grayscale
;
228 UINT tile_width
, tile_height
;
233 UINT resolution_unit
;
238 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
239 IWICMetadataBlockReader IWICMetadataBlockReader_iface
;
243 tiff_decode_info decode_info
;
244 INT cached_tile_x
, cached_tile_y
;
248 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
;
249 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl
;
251 static inline TiffDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
253 return CONTAINING_RECORD(iface
, TiffDecoder
, IWICBitmapDecoder_iface
);
256 static inline TiffFrameDecode
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
258 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICBitmapFrameDecode_iface
);
261 static inline TiffFrameDecode
*impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader
*iface
)
263 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICMetadataBlockReader_iface
);
266 static HRESULT
tiff_get_decode_info(TIFF
*tiff
, tiff_decode_info
*decode_info
)
268 uint16 photometric
, bps
, samples
, planar
;
269 uint16 extra_sample_count
, extra_sample
, *extra_samples
;
272 decode_info
->indexed
= 0;
273 decode_info
->reverse_bgr
= 0;
274 decode_info
->invert_grayscale
= 0;
275 decode_info
->tiled
= 0;
277 ret
= pTIFFGetField(tiff
, TIFFTAG_PHOTOMETRIC
, &photometric
);
280 WARN("missing PhotometricInterpretation tag\n");
284 ret
= pTIFFGetField(tiff
, TIFFTAG_BITSPERSAMPLE
, &bps
);
286 decode_info
->bps
= bps
;
288 ret
= pTIFFGetField(tiff
, TIFFTAG_SAMPLESPERPIXEL
, &samples
);
289 if (!ret
) samples
= 1;
290 decode_info
->samples
= samples
;
296 ret
= pTIFFGetField(tiff
, TIFFTAG_PLANARCONFIG
, &planar
);
297 if (!ret
) planar
= 1;
300 FIXME("unhandled planar configuration %u\n", planar
);
304 decode_info
->planar
= planar
;
308 case 0: /* WhiteIsZero */
309 decode_info
->invert_grayscale
= 1;
311 case 1: /* BlackIsZero */
314 ret
= pTIFFGetField(tiff
, TIFFTAG_EXTRASAMPLES
, &extra_sample_count
, &extra_samples
);
317 extra_sample_count
= 1;
319 extra_samples
= &extra_sample
;
322 else if (samples
!= 1)
324 FIXME("unhandled %dbpp sample count %u\n", bps
, samples
);
328 decode_info
->bpp
= bps
* samples
;
329 decode_info
->source_bpp
= decode_info
->bpp
;
335 FIXME("unhandled 1bpp sample count %u\n", samples
);
338 decode_info
->format
= &GUID_WICPixelFormatBlackWhite
;
343 FIXME("unhandled 4bpp grayscale sample count %u\n", samples
);
346 decode_info
->format
= &GUID_WICPixelFormat4bppGray
;
350 decode_info
->format
= &GUID_WICPixelFormat8bppGray
;
353 decode_info
->bpp
= 32;
355 switch(extra_samples
[0])
357 case 1: /* Associated (pre-multiplied) alpha data */
358 decode_info
->format
= &GUID_WICPixelFormat32bppPBGRA
;
360 case 0: /* Unspecified data */
361 case 2: /* Unassociated alpha data */
362 decode_info
->format
= &GUID_WICPixelFormat32bppBGRA
;
365 FIXME("unhandled extra sample type %u\n", extra_samples
[0]);
371 FIXME("unhandled greyscale bit count %u\n", bps
);
376 decode_info
->bpp
= bps
* samples
;
380 ret
= pTIFFGetField(tiff
, TIFFTAG_EXTRASAMPLES
, &extra_sample_count
, &extra_samples
);
383 extra_sample_count
= 1;
385 extra_samples
= &extra_sample
;
388 else if (samples
!= 3)
390 FIXME("unhandled RGB sample count %u\n", samples
);
397 decode_info
->reverse_bgr
= 1;
399 decode_info
->format
= &GUID_WICPixelFormat24bppBGR
;
401 switch(extra_samples
[0])
403 case 1: /* Associated (pre-multiplied) alpha data */
404 decode_info
->format
= &GUID_WICPixelFormat32bppPBGRA
;
406 case 0: /* Unspecified data */
407 case 2: /* Unassociated alpha data */
408 decode_info
->format
= &GUID_WICPixelFormat32bppBGRA
;
411 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
417 decode_info
->format
= &GUID_WICPixelFormat48bppRGB
;
419 switch(extra_samples
[0])
421 case 1: /* Associated (pre-multiplied) alpha data */
422 decode_info
->format
= &GUID_WICPixelFormat64bppPRGBA
;
424 case 0: /* Unspecified data */
425 case 2: /* Unassociated alpha data */
426 decode_info
->format
= &GUID_WICPixelFormat64bppRGBA
;
429 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
434 FIXME("unhandled RGB bit count %u\n", bps
);
438 case 3: /* RGB Palette */
441 FIXME("unhandled indexed sample count %u\n", samples
);
445 decode_info
->indexed
= 1;
446 decode_info
->bpp
= bps
;
450 decode_info
->format
= &GUID_WICPixelFormat4bppIndexed
;
453 decode_info
->format
= &GUID_WICPixelFormat8bppIndexed
;
456 FIXME("unhandled indexed bit count %u\n", bps
);
460 case 4: /* Transparency mask */
465 FIXME("unhandled PhotometricInterpretation %u\n", photometric
);
469 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGEWIDTH
, &decode_info
->width
);
472 WARN("missing image width\n");
476 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGELENGTH
, &decode_info
->height
);
479 WARN("missing image length\n");
483 if ((ret
= pTIFFGetField(tiff
, TIFFTAG_TILEWIDTH
, &decode_info
->tile_width
)))
485 decode_info
->tiled
= 1;
487 ret
= pTIFFGetField(tiff
, TIFFTAG_TILELENGTH
, &decode_info
->tile_height
);
490 WARN("missing tile height\n");
494 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
495 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
496 decode_info
->tiles_across
= (decode_info
->width
+ decode_info
->tile_width
- 1) / decode_info
->tile_width
;
498 else if ((ret
= pTIFFGetField(tiff
, TIFFTAG_ROWSPERSTRIP
, &decode_info
->tile_height
)))
500 if (decode_info
->tile_height
> decode_info
->height
)
501 decode_info
->tile_height
= decode_info
->height
;
502 decode_info
->tile_width
= decode_info
->width
;
503 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
504 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
508 /* Some broken TIFF files have a single strip and lack the RowsPerStrip tag */
509 decode_info
->tile_height
= decode_info
->height
;
510 decode_info
->tile_width
= decode_info
->width
;
511 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
512 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
515 decode_info
->resolution_unit
= 0;
516 pTIFFGetField(tiff
, TIFFTAG_RESOLUTIONUNIT
, &decode_info
->resolution_unit
);
517 if (decode_info
->resolution_unit
!= 0)
519 ret
= pTIFFGetField(tiff
, TIFFTAG_XRESOLUTION
, &decode_info
->xres
);
522 WARN("missing X resolution\n");
523 decode_info
->resolution_unit
= 0;
526 ret
= pTIFFGetField(tiff
, TIFFTAG_YRESOLUTION
, &decode_info
->yres
);
529 WARN("missing Y resolution\n");
530 decode_info
->resolution_unit
= 0;
537 static HRESULT WINAPI
TiffDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
540 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
541 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
543 if (!ppv
) return E_INVALIDARG
;
545 if (IsEqualIID(&IID_IUnknown
, iid
) ||
546 IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
548 *ppv
= &This
->IWICBitmapDecoder_iface
;
553 return E_NOINTERFACE
;
556 IUnknown_AddRef((IUnknown
*)*ppv
);
560 static ULONG WINAPI
TiffDecoder_AddRef(IWICBitmapDecoder
*iface
)
562 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
563 ULONG ref
= InterlockedIncrement(&This
->ref
);
565 TRACE("(%p) refcount=%u\n", iface
, ref
);
570 static ULONG WINAPI
TiffDecoder_Release(IWICBitmapDecoder
*iface
)
572 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
573 ULONG ref
= InterlockedDecrement(&This
->ref
);
575 TRACE("(%p) refcount=%u\n", iface
, ref
);
579 if (This
->tiff
) pTIFFClose(This
->tiff
);
580 if (This
->stream
) IStream_Release(This
->stream
);
581 This
->lock
.DebugInfo
->Spare
[0] = 0;
582 DeleteCriticalSection(&This
->lock
);
583 HeapFree(GetProcessHeap(), 0, This
);
589 static HRESULT WINAPI
TiffDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*stream
,
594 TRACE("(%p,%p,%p)\n", iface
, stream
, capability
);
596 if (!stream
|| !capability
) return E_INVALIDARG
;
598 hr
= IWICBitmapDecoder_Initialize(iface
, stream
, WICDecodeMetadataCacheOnDemand
);
599 if (hr
!= S_OK
) return hr
;
601 *capability
= WICBitmapDecoderCapabilityCanDecodeAllImages
|
602 WICBitmapDecoderCapabilityCanDecodeSomeImages
|
603 WICBitmapDecoderCapabilityCanEnumerateMetadata
;
607 static HRESULT WINAPI
TiffDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
608 WICDecodeOptions cacheOptions
)
610 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
614 TRACE("(%p,%p,%x): stub\n", iface
, pIStream
, cacheOptions
);
616 EnterCriticalSection(&This
->lock
);
618 if (This
->initialized
)
620 hr
= WINCODEC_ERR_WRONGSTATE
;
624 tiff
= tiff_open_stream(pIStream
, "r");
633 This
->stream
= pIStream
;
634 IStream_AddRef(pIStream
);
635 This
->initialized
= TRUE
;
638 LeaveCriticalSection(&This
->lock
);
642 static HRESULT WINAPI
TiffDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
643 GUID
*pguidContainerFormat
)
645 if (!pguidContainerFormat
) return E_INVALIDARG
;
647 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
651 static HRESULT WINAPI
TiffDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
652 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
655 IWICComponentInfo
*compinfo
;
657 TRACE("(%p,%p)\n", iface
, ppIDecoderInfo
);
659 hr
= CreateComponentInfo(&CLSID_WICTiffDecoder
, &compinfo
);
660 if (FAILED(hr
)) return hr
;
662 hr
= IWICComponentInfo_QueryInterface(compinfo
, &IID_IWICBitmapDecoderInfo
,
663 (void**)ppIDecoderInfo
);
665 IWICComponentInfo_Release(compinfo
);
670 static HRESULT WINAPI
TiffDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
671 IWICPalette
*pIPalette
)
673 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
677 static HRESULT WINAPI
TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
678 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
680 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
684 static HRESULT WINAPI
TiffDecoder_GetPreview(IWICBitmapDecoder
*iface
,
685 IWICBitmapSource
**ppIBitmapSource
)
687 TRACE("(%p,%p)\n", iface
, ppIBitmapSource
);
689 if (!ppIBitmapSource
) return E_INVALIDARG
;
691 *ppIBitmapSource
= NULL
;
692 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
695 static HRESULT WINAPI
TiffDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
696 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
698 FIXME("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
699 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
702 static HRESULT WINAPI
TiffDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
703 IWICBitmapSource
**ppIThumbnail
)
705 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
707 if (!ppIThumbnail
) return E_INVALIDARG
;
709 *ppIThumbnail
= NULL
;
710 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
713 static HRESULT WINAPI
TiffDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
716 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
718 if (!pCount
) return E_INVALIDARG
;
720 EnterCriticalSection(&This
->lock
);
721 *pCount
= This
->tiff
? pTIFFNumberOfDirectories(This
->tiff
) : 0;
722 LeaveCriticalSection(&This
->lock
);
724 TRACE("(%p) <-- %i\n", iface
, *pCount
);
729 static HRESULT WINAPI
TiffDecoder_GetFrame(IWICBitmapDecoder
*iface
,
730 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
732 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
733 TiffFrameDecode
*result
;
735 tiff_decode_info decode_info
;
738 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
741 return WINCODEC_ERR_FRAMEMISSING
;
743 EnterCriticalSection(&This
->lock
);
744 res
= pTIFFSetDirectory(This
->tiff
, index
);
745 if (!res
) hr
= E_INVALIDARG
;
746 else hr
= tiff_get_decode_info(This
->tiff
, &decode_info
);
747 LeaveCriticalSection(&This
->lock
);
751 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode
));
755 result
->IWICBitmapFrameDecode_iface
.lpVtbl
= &TiffFrameDecode_Vtbl
;
756 result
->IWICMetadataBlockReader_iface
.lpVtbl
= &TiffFrameDecode_BlockVtbl
;
758 result
->parent
= This
;
759 result
->index
= index
;
760 result
->decode_info
= decode_info
;
761 result
->cached_tile_x
= -1;
762 result
->cached_tile
= HeapAlloc(GetProcessHeap(), 0, decode_info
.tile_size
);
764 if (result
->cached_tile
)
765 *ppIBitmapFrame
= &result
->IWICBitmapFrameDecode_iface
;
769 HeapFree(GetProcessHeap(), 0, result
);
772 else hr
= E_OUTOFMEMORY
;
775 if (FAILED(hr
)) *ppIBitmapFrame
= NULL
;
780 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl
= {
781 TiffDecoder_QueryInterface
,
784 TiffDecoder_QueryCapability
,
785 TiffDecoder_Initialize
,
786 TiffDecoder_GetContainerFormat
,
787 TiffDecoder_GetDecoderInfo
,
788 TiffDecoder_CopyPalette
,
789 TiffDecoder_GetMetadataQueryReader
,
790 TiffDecoder_GetPreview
,
791 TiffDecoder_GetColorContexts
,
792 TiffDecoder_GetThumbnail
,
793 TiffDecoder_GetFrameCount
,
797 static HRESULT WINAPI
TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
800 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
801 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
803 if (!ppv
) return E_INVALIDARG
;
805 if (IsEqualIID(&IID_IUnknown
, iid
) ||
806 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
807 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
809 *ppv
= &This
->IWICBitmapFrameDecode_iface
;
811 else if (IsEqualIID(&IID_IWICMetadataBlockReader
, iid
))
813 *ppv
= &This
->IWICMetadataBlockReader_iface
;
818 return E_NOINTERFACE
;
821 IUnknown_AddRef((IUnknown
*)*ppv
);
825 static ULONG WINAPI
TiffFrameDecode_AddRef(IWICBitmapFrameDecode
*iface
)
827 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
828 ULONG ref
= InterlockedIncrement(&This
->ref
);
830 TRACE("(%p) refcount=%u\n", iface
, ref
);
835 static ULONG WINAPI
TiffFrameDecode_Release(IWICBitmapFrameDecode
*iface
)
837 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
838 ULONG ref
= InterlockedDecrement(&This
->ref
);
840 TRACE("(%p) refcount=%u\n", iface
, ref
);
844 HeapFree(GetProcessHeap(), 0, This
->cached_tile
);
845 HeapFree(GetProcessHeap(), 0, This
);
851 static HRESULT WINAPI
TiffFrameDecode_GetSize(IWICBitmapFrameDecode
*iface
,
852 UINT
*puiWidth
, UINT
*puiHeight
)
854 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
856 *puiWidth
= This
->decode_info
.width
;
857 *puiHeight
= This
->decode_info
.height
;
859 TRACE("(%p) <-- %ux%u\n", iface
, *puiWidth
, *puiHeight
);
864 static HRESULT WINAPI
TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
865 WICPixelFormatGUID
*pPixelFormat
)
867 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
869 memcpy(pPixelFormat
, This
->decode_info
.format
, sizeof(GUID
));
871 TRACE("(%p) <-- %s\n", This
, debugstr_guid(This
->decode_info
.format
));
876 static HRESULT WINAPI
TiffFrameDecode_GetResolution(IWICBitmapFrameDecode
*iface
,
877 double *pDpiX
, double *pDpiY
)
879 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
881 switch (This
->decode_info
.resolution_unit
)
884 FIXME("unknown resolution unit %i\n", This
->decode_info
.resolution_unit
);
886 case 0: /* Not set */
887 *pDpiX
= *pDpiY
= 96.0;
889 case 1: /* Relative measurements */
891 *pDpiY
= 96.0 * This
->decode_info
.yres
/ This
->decode_info
.xres
;
894 *pDpiX
= This
->decode_info
.xres
;
895 *pDpiY
= This
->decode_info
.yres
;
897 case 3: /* Centimeter */
898 *pDpiX
= This
->decode_info
.xres
/ 2.54;
899 *pDpiY
= This
->decode_info
.yres
/ 2.54;
903 TRACE("(%p) <-- %f,%f unit=%i\n", iface
, *pDpiX
, *pDpiY
, This
->decode_info
.resolution_unit
);
908 static HRESULT WINAPI
TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode
*iface
,
909 IWICPalette
*pIPalette
)
911 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
912 uint16
*red
, *green
, *blue
;
913 WICColor colors
[256];
914 int color_count
, ret
, i
;
916 TRACE("(%p,%p)\n", iface
, pIPalette
);
918 color_count
= 1<<This
->decode_info
.bps
;
920 EnterCriticalSection(&This
->parent
->lock
);
921 ret
= pTIFFGetField(This
->parent
->tiff
, TIFFTAG_COLORMAP
, &red
, &green
, &blue
);
922 LeaveCriticalSection(&This
->parent
->lock
);
926 WARN("Couldn't read color map\n");
927 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
930 for (i
=0; i
<color_count
; i
++)
932 colors
[i
] = 0xff000000 |
933 ((red
[i
]<<8) & 0xff0000) |
934 (green
[i
] & 0xff00) |
935 ((blue
[i
]>>8) & 0xff);
938 return IWICPalette_InitializeCustom(pIPalette
, colors
, color_count
);
941 static HRESULT
TiffFrameDecode_ReadTile(TiffFrameDecode
*This
, UINT tile_x
, UINT tile_y
)
947 swap_bytes
= pTIFFIsByteSwapped(This
->parent
->tiff
);
949 ret
= pTIFFSetDirectory(This
->parent
->tiff
, This
->index
);
956 if (This
->decode_info
.tiled
)
958 ret
= pTIFFReadEncodedTile(This
->parent
->tiff
, tile_x
+ tile_y
* This
->decode_info
.tiles_across
, This
->cached_tile
, This
->decode_info
.tile_size
);
962 ret
= pTIFFReadEncodedStrip(This
->parent
->tiff
, tile_y
, This
->cached_tile
, This
->decode_info
.tile_size
);
969 /* 8bpp grayscale with extra alpha */
970 if (hr
== S_OK
&& This
->decode_info
.source_bpp
== 16 && This
->decode_info
.samples
== 2 && This
->decode_info
.bpp
== 32)
973 DWORD
*dst
, count
= This
->decode_info
.tile_width
* This
->decode_info
.tile_height
;
975 src
= This
->cached_tile
+ This
->decode_info
.tile_width
* This
->decode_info
.tile_height
* 2 - 2;
976 dst
= (DWORD
*)(This
->cached_tile
+ This
->decode_info
.tile_size
- 4);
980 *dst
-- = src
[0] | (src
[0] << 8) | (src
[0] << 16) | (src
[1] << 24);
985 if (hr
== S_OK
&& This
->decode_info
.reverse_bgr
)
987 if (This
->decode_info
.bps
== 8)
989 UINT sample_count
= This
->decode_info
.samples
;
991 reverse_bgr8(sample_count
, This
->cached_tile
, This
->decode_info
.tile_width
,
992 This
->decode_info
.tile_height
, This
->decode_info
.tile_width
* sample_count
);
996 if (hr
== S_OK
&& swap_bytes
&& This
->decode_info
.bps
> 8)
998 UINT row
, i
, samples_per_row
;
1001 samples_per_row
= This
->decode_info
.tile_width
* This
->decode_info
.samples
;
1003 switch(This
->decode_info
.bps
)
1006 for (row
=0; row
<This
->decode_info
.tile_height
; row
++)
1008 sample
= This
->cached_tile
+ row
* This
->decode_info
.tile_stride
;
1009 for (i
=0; i
<samples_per_row
; i
++)
1012 sample
[1] = sample
[0];
1019 ERR("unhandled bps for byte swap %u\n", This
->decode_info
.bps
);
1024 if (hr
== S_OK
&& This
->decode_info
.invert_grayscale
)
1028 if (This
->decode_info
.samples
!= 1)
1030 ERR("cannot invert grayscale image with %u samples\n", This
->decode_info
.samples
);
1034 end
= This
->cached_tile
+This
->decode_info
.tile_size
;
1036 for (byte
= This
->cached_tile
; byte
!= end
; byte
++)
1042 This
->cached_tile_x
= tile_x
;
1043 This
->cached_tile_y
= tile_y
;
1049 static HRESULT WINAPI
TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode
*iface
,
1050 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
1052 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1053 UINT min_tile_x
, max_tile_x
, min_tile_y
, max_tile_y
;
1054 UINT tile_x
, tile_y
;
1061 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
1067 rect
.Width
= This
->decode_info
.width
;
1068 rect
.Height
= This
->decode_info
.height
;
1073 if (prc
->X
< 0 || prc
->Y
< 0 || prc
->X
+prc
->Width
> This
->decode_info
.width
||
1074 prc
->Y
+prc
->Height
> This
->decode_info
.height
)
1075 return E_INVALIDARG
;
1078 bytesperrow
= ((This
->decode_info
.bpp
* prc
->Width
)+7)/8;
1080 if (cbStride
< bytesperrow
)
1081 return E_INVALIDARG
;
1083 if ((cbStride
* prc
->Height
) > cbBufferSize
)
1084 return E_INVALIDARG
;
1086 min_tile_x
= prc
->X
/ This
->decode_info
.tile_width
;
1087 min_tile_y
= prc
->Y
/ This
->decode_info
.tile_height
;
1088 max_tile_x
= (prc
->X
+prc
->Width
-1) / This
->decode_info
.tile_width
;
1089 max_tile_y
= (prc
->Y
+prc
->Height
-1) / This
->decode_info
.tile_height
;
1091 EnterCriticalSection(&This
->parent
->lock
);
1093 for (tile_x
=min_tile_x
; tile_x
<= max_tile_x
; tile_x
++)
1095 for (tile_y
=min_tile_y
; tile_y
<= max_tile_y
; tile_y
++)
1097 if (tile_x
!= This
->cached_tile_x
|| tile_y
!= This
->cached_tile_y
)
1099 hr
= TiffFrameDecode_ReadTile(This
, tile_x
, tile_y
);
1104 if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1107 rc
.X
= prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1109 if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1112 rc
.Y
= prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1114 if (prc
->X
+prc
->Width
> (tile_x
+1) * This
->decode_info
.tile_width
)
1115 rc
.Width
= This
->decode_info
.tile_width
- rc
.X
;
1116 else if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1117 rc
.Width
= prc
->Width
+ prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1119 rc
.Width
= prc
->Width
;
1121 if (prc
->Y
+prc
->Height
> (tile_y
+1) * This
->decode_info
.tile_height
)
1122 rc
.Height
= This
->decode_info
.tile_height
- rc
.Y
;
1123 else if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1124 rc
.Height
= prc
->Height
+ prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1126 rc
.Height
= prc
->Height
;
1128 dst_tilepos
= pbBuffer
+ (cbStride
* ((rc
.Y
+ tile_y
* This
->decode_info
.tile_height
) - prc
->Y
)) +
1129 ((This
->decode_info
.bpp
* ((rc
.X
+ tile_x
* This
->decode_info
.tile_width
) - prc
->X
) + 7) / 8);
1131 hr
= copy_pixels(This
->decode_info
.bpp
, This
->cached_tile
,
1132 This
->decode_info
.tile_width
, This
->decode_info
.tile_height
, This
->decode_info
.tile_stride
,
1133 &rc
, cbStride
, cbBufferSize
, dst_tilepos
);
1138 LeaveCriticalSection(&This
->parent
->lock
);
1139 TRACE("<-- 0x%x\n", hr
);
1145 LeaveCriticalSection(&This
->parent
->lock
);
1150 static HRESULT WINAPI
TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
1151 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
1153 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
1157 static HRESULT WINAPI
TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode
*iface
,
1158 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
1160 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1161 const BYTE
*profile
;
1165 TRACE("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
1167 EnterCriticalSection(&This
->parent
->lock
);
1169 if (pTIFFGetField(This
->parent
->tiff
, TIFFTAG_ICCPROFILE
, &len
, &profile
))
1171 if (cCount
&& ppIColorContexts
)
1173 hr
= IWICColorContext_InitializeFromMemory(*ppIColorContexts
, profile
, len
);
1176 LeaveCriticalSection(&This
->parent
->lock
);
1185 LeaveCriticalSection(&This
->parent
->lock
);
1190 static HRESULT WINAPI
TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode
*iface
,
1191 IWICBitmapSource
**ppIThumbnail
)
1193 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
1195 if (!ppIThumbnail
) return E_INVALIDARG
;
1197 *ppIThumbnail
= NULL
;
1198 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
1201 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
= {
1202 TiffFrameDecode_QueryInterface
,
1203 TiffFrameDecode_AddRef
,
1204 TiffFrameDecode_Release
,
1205 TiffFrameDecode_GetSize
,
1206 TiffFrameDecode_GetPixelFormat
,
1207 TiffFrameDecode_GetResolution
,
1208 TiffFrameDecode_CopyPalette
,
1209 TiffFrameDecode_CopyPixels
,
1210 TiffFrameDecode_GetMetadataQueryReader
,
1211 TiffFrameDecode_GetColorContexts
,
1212 TiffFrameDecode_GetThumbnail
1215 static HRESULT WINAPI
TiffFrameDecode_Block_QueryInterface(IWICMetadataBlockReader
*iface
,
1216 REFIID iid
, void **ppv
)
1218 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1219 return IWICBitmapFrameDecode_QueryInterface(&This
->IWICBitmapFrameDecode_iface
, iid
, ppv
);
1222 static ULONG WINAPI
TiffFrameDecode_Block_AddRef(IWICMetadataBlockReader
*iface
)
1224 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1225 return IWICBitmapFrameDecode_AddRef(&This
->IWICBitmapFrameDecode_iface
);
1228 static ULONG WINAPI
TiffFrameDecode_Block_Release(IWICMetadataBlockReader
*iface
)
1230 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1231 return IWICBitmapFrameDecode_Release(&This
->IWICBitmapFrameDecode_iface
);
1234 static HRESULT WINAPI
TiffFrameDecode_Block_GetContainerFormat(IWICMetadataBlockReader
*iface
,
1237 TRACE("(%p,%p)\n", iface
, guid
);
1239 if (!guid
) return E_INVALIDARG
;
1241 *guid
= GUID_ContainerFormatTiff
;
1245 static HRESULT WINAPI
TiffFrameDecode_Block_GetCount(IWICMetadataBlockReader
*iface
,
1248 TRACE("%p,%p\n", iface
, count
);
1250 if (!count
) return E_INVALIDARG
;
1256 static HRESULT
create_metadata_reader(TiffFrameDecode
*This
, IWICMetadataReader
**reader
)
1259 LARGE_INTEGER dir_offset
;
1260 IWICMetadataReader
*metadata_reader
;
1261 IWICPersistStream
*persist
;
1263 /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
1265 hr
= IfdMetadataReader_CreateInstance(&IID_IWICMetadataReader
, (void **)&metadata_reader
);
1266 if (FAILED(hr
)) return hr
;
1268 hr
= IWICMetadataReader_QueryInterface(metadata_reader
, &IID_IWICPersistStream
, (void **)&persist
);
1271 IWICMetadataReader_Release(metadata_reader
);
1275 EnterCriticalSection(&This
->parent
->lock
);
1277 dir_offset
.QuadPart
= pTIFFCurrentDirOffset(This
->parent
->tiff
);
1278 hr
= IStream_Seek(This
->parent
->stream
, dir_offset
, STREAM_SEEK_SET
, NULL
);
1281 BOOL byte_swapped
= pTIFFIsByteSwapped(This
->parent
->tiff
);
1282 #ifdef WORDS_BIGENDIAN
1283 DWORD persist_options
= byte_swapped
? WICPersistOptionsLittleEndian
: WICPersistOptionsBigEndian
;
1285 DWORD persist_options
= byte_swapped
? WICPersistOptionsBigEndian
: WICPersistOptionsLittleEndian
;
1287 persist_options
|= WICPersistOptionsNoCacheStream
;
1288 hr
= IWICPersistStream_LoadEx(persist
, This
->parent
->stream
, NULL
, persist_options
);
1290 ERR("IWICPersistStream_LoadEx error %#x\n", hr
);
1293 LeaveCriticalSection(&This
->parent
->lock
);
1295 IWICPersistStream_Release(persist
);
1299 IWICMetadataReader_Release(metadata_reader
);
1303 *reader
= metadata_reader
;
1307 static HRESULT WINAPI
TiffFrameDecode_Block_GetReaderByIndex(IWICMetadataBlockReader
*iface
,
1308 UINT index
, IWICMetadataReader
**reader
)
1310 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1312 TRACE("(%p,%u,%p)\n", iface
, index
, reader
);
1314 if (!reader
|| index
!= 0) return E_INVALIDARG
;
1316 return create_metadata_reader(This
, reader
);
1319 static HRESULT WINAPI
TiffFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader
*iface
,
1320 IEnumUnknown
**enum_metadata
)
1322 FIXME("(%p,%p): stub\n", iface
, enum_metadata
);
1326 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl
=
1328 TiffFrameDecode_Block_QueryInterface
,
1329 TiffFrameDecode_Block_AddRef
,
1330 TiffFrameDecode_Block_Release
,
1331 TiffFrameDecode_Block_GetContainerFormat
,
1332 TiffFrameDecode_Block_GetCount
,
1333 TiffFrameDecode_Block_GetReaderByIndex
,
1334 TiffFrameDecode_Block_GetEnumerator
1337 HRESULT
TiffDecoder_CreateInstance(REFIID iid
, void** ppv
)
1342 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
1346 if (!load_libtiff())
1348 ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF
);
1352 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder
));
1353 if (!This
) return E_OUTOFMEMORY
;
1355 This
->IWICBitmapDecoder_iface
.lpVtbl
= &TiffDecoder_Vtbl
;
1357 This
->stream
= NULL
;
1358 InitializeCriticalSection(&This
->lock
);
1359 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffDecoder.lock");
1361 This
->initialized
= FALSE
;
1363 ret
= IWICBitmapDecoder_QueryInterface(&This
->IWICBitmapDecoder_iface
, iid
, ppv
);
1364 IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
1369 struct tiff_encode_format
{
1370 const WICPixelFormatGUID
*guid
;
1376 int extra_sample_type
;
1380 static const struct tiff_encode_format formats
[] = {
1381 {&GUID_WICPixelFormat24bppBGR
, 2, 8, 3, 24, 0, 0, 1},
1382 {&GUID_WICPixelFormat24bppRGB
, 2, 8, 3, 24, 0, 0, 0},
1383 {&GUID_WICPixelFormatBlackWhite
, 1, 1, 1, 1, 0, 0, 0},
1384 {&GUID_WICPixelFormat4bppGray
, 1, 4, 1, 4, 0, 0, 0},
1385 {&GUID_WICPixelFormat8bppGray
, 1, 8, 1, 8, 0, 0, 0},
1386 {&GUID_WICPixelFormat32bppBGRA
, 2, 8, 4, 32, 1, 2, 1},
1387 {&GUID_WICPixelFormat32bppPBGRA
, 2, 8, 4, 32, 1, 1, 1},
1388 {&GUID_WICPixelFormat48bppRGB
, 2, 16, 3, 48, 0, 0, 0},
1389 {&GUID_WICPixelFormat64bppRGBA
, 2, 16, 4, 64, 1, 2, 0},
1390 {&GUID_WICPixelFormat64bppPRGBA
, 2, 16, 4, 64, 1, 1, 0},
1394 typedef struct TiffEncoder
{
1395 IWICBitmapEncoder IWICBitmapEncoder_iface
;
1398 CRITICAL_SECTION lock
; /* Must be held when tiff is used or fields below are set */
1403 ULONG num_frames_committed
;
1406 static inline TiffEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
1408 return CONTAINING_RECORD(iface
, TiffEncoder
, IWICBitmapEncoder_iface
);
1411 typedef struct TiffFrameEncode
{
1412 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
1414 TiffEncoder
*parent
;
1415 /* fields below are protected by parent->lock */
1419 const struct tiff_encode_format
*format
;
1425 static inline TiffFrameEncode
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
1427 return CONTAINING_RECORD(iface
, TiffFrameEncode
, IWICBitmapFrameEncode_iface
);
1430 static HRESULT WINAPI
TiffFrameEncode_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
1433 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1434 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1436 if (!ppv
) return E_INVALIDARG
;
1438 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1439 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
1441 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
1446 return E_NOINTERFACE
;
1449 IUnknown_AddRef((IUnknown
*)*ppv
);
1453 static ULONG WINAPI
TiffFrameEncode_AddRef(IWICBitmapFrameEncode
*iface
)
1455 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1456 ULONG ref
= InterlockedIncrement(&This
->ref
);
1458 TRACE("(%p) refcount=%u\n", iface
, ref
);
1463 static ULONG WINAPI
TiffFrameEncode_Release(IWICBitmapFrameEncode
*iface
)
1465 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1466 ULONG ref
= InterlockedDecrement(&This
->ref
);
1468 TRACE("(%p) refcount=%u\n", iface
, ref
);
1472 IWICBitmapEncoder_Release(&This
->parent
->IWICBitmapEncoder_iface
);
1473 HeapFree(GetProcessHeap(), 0, This
);
1479 static HRESULT WINAPI
TiffFrameEncode_Initialize(IWICBitmapFrameEncode
*iface
,
1480 IPropertyBag2
*pIEncoderOptions
)
1482 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1483 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
1485 EnterCriticalSection(&This
->parent
->lock
);
1487 if (This
->initialized
)
1489 LeaveCriticalSection(&This
->parent
->lock
);
1490 return WINCODEC_ERR_WRONGSTATE
;
1493 This
->initialized
= TRUE
;
1495 LeaveCriticalSection(&This
->parent
->lock
);
1500 static HRESULT WINAPI
TiffFrameEncode_SetSize(IWICBitmapFrameEncode
*iface
,
1501 UINT uiWidth
, UINT uiHeight
)
1503 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1504 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
1506 EnterCriticalSection(&This
->parent
->lock
);
1508 if (!This
->initialized
|| This
->info_written
)
1510 LeaveCriticalSection(&This
->parent
->lock
);
1511 return WINCODEC_ERR_WRONGSTATE
;
1514 This
->width
= uiWidth
;
1515 This
->height
= uiHeight
;
1517 LeaveCriticalSection(&This
->parent
->lock
);
1522 static HRESULT WINAPI
TiffFrameEncode_SetResolution(IWICBitmapFrameEncode
*iface
,
1523 double dpiX
, double dpiY
)
1525 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1526 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
1528 EnterCriticalSection(&This
->parent
->lock
);
1530 if (!This
->initialized
|| This
->info_written
)
1532 LeaveCriticalSection(&This
->parent
->lock
);
1533 return WINCODEC_ERR_WRONGSTATE
;
1539 LeaveCriticalSection(&This
->parent
->lock
);
1544 static HRESULT WINAPI
TiffFrameEncode_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
1545 WICPixelFormatGUID
*pPixelFormat
)
1547 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1550 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
1552 EnterCriticalSection(&This
->parent
->lock
);
1554 if (!This
->initialized
|| This
->info_written
)
1556 LeaveCriticalSection(&This
->parent
->lock
);
1557 return WINCODEC_ERR_WRONGSTATE
;
1560 for (i
=0; formats
[i
].guid
; i
++)
1562 if (memcmp(formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
1566 if (!formats
[i
].guid
) i
= 0;
1568 This
->format
= &formats
[i
];
1569 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
1571 LeaveCriticalSection(&This
->parent
->lock
);
1576 static HRESULT WINAPI
TiffFrameEncode_SetColorContexts(IWICBitmapFrameEncode
*iface
,
1577 UINT cCount
, IWICColorContext
**ppIColorContext
)
1579 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1583 static HRESULT WINAPI
TiffFrameEncode_SetPalette(IWICBitmapFrameEncode
*iface
,
1584 IWICPalette
*pIPalette
)
1586 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
1587 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1590 static HRESULT WINAPI
TiffFrameEncode_SetThumbnail(IWICBitmapFrameEncode
*iface
,
1591 IWICBitmapSource
*pIThumbnail
)
1593 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
1594 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1597 static HRESULT WINAPI
TiffFrameEncode_WritePixels(IWICBitmapFrameEncode
*iface
,
1598 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
1600 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1601 BYTE
*row_data
, *swapped_data
= NULL
;
1602 UINT i
, j
, line_size
;
1604 TRACE("(%p,%u,%u,%u,%p)\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
1606 EnterCriticalSection(&This
->parent
->lock
);
1608 if (!This
->initialized
|| !This
->width
|| !This
->height
|| !This
->format
)
1610 LeaveCriticalSection(&This
->parent
->lock
);
1611 return WINCODEC_ERR_WRONGSTATE
;
1614 if (lineCount
== 0 || lineCount
+ This
->lines_written
> This
->height
)
1616 LeaveCriticalSection(&This
->parent
->lock
);
1617 return E_INVALIDARG
;
1620 line_size
= ((This
->width
* This
->format
->bpp
)+7)/8;
1622 if (This
->format
->reverse_bgr
)
1624 swapped_data
= HeapAlloc(GetProcessHeap(), 0, line_size
);
1627 LeaveCriticalSection(&This
->parent
->lock
);
1628 return E_OUTOFMEMORY
;
1632 if (!This
->info_written
)
1634 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PHOTOMETRIC
, (uint16
)This
->format
->photometric
);
1635 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PLANARCONFIG
, (uint16
)1);
1636 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_BITSPERSAMPLE
, (uint16
)This
->format
->bps
);
1637 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_SAMPLESPERPIXEL
, (uint16
)This
->format
->samples
);
1639 if (This
->format
->extra_sample
)
1641 uint16 extra_samples
;
1642 extra_samples
= This
->format
->extra_sample_type
;
1644 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_EXTRASAMPLES
, (uint16
)1, &extra_samples
);
1647 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGEWIDTH
, (uint32
)This
->width
);
1648 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGELENGTH
, (uint32
)This
->height
);
1650 if (This
->xres
!= 0.0 && This
->yres
!= 0.0)
1652 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_RESOLUTIONUNIT
, (uint16
)2); /* Inch */
1653 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_XRESOLUTION
, (float)This
->xres
);
1654 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_YRESOLUTION
, (float)This
->yres
);
1657 This
->info_written
= TRUE
;
1660 for (i
=0; i
<lineCount
; i
++)
1662 row_data
= pbPixels
+ i
* cbStride
;
1664 if (This
->format
->reverse_bgr
&& This
->format
->bps
== 8)
1666 memcpy(swapped_data
, row_data
, line_size
);
1667 for (j
=0; j
<line_size
; j
+= This
->format
->samples
)
1670 temp
= swapped_data
[j
];
1671 swapped_data
[j
] = swapped_data
[j
+2];
1672 swapped_data
[j
+2] = temp
;
1674 row_data
= swapped_data
;
1677 pTIFFWriteScanline(This
->parent
->tiff
, (tdata_t
)row_data
, i
+This
->lines_written
, 0);
1680 This
->lines_written
+= lineCount
;
1682 LeaveCriticalSection(&This
->parent
->lock
);
1684 HeapFree(GetProcessHeap(), 0, swapped_data
);
1689 static HRESULT WINAPI
TiffFrameEncode_WriteSource(IWICBitmapFrameEncode
*iface
,
1690 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
1692 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1695 TRACE("(%p,%p,%p)\n", iface
, pIBitmapSource
, prc
);
1697 if (!This
->initialized
)
1698 return WINCODEC_ERR_WRONGSTATE
;
1700 hr
= configure_write_source(iface
, pIBitmapSource
, prc
,
1701 This
->format
? This
->format
->guid
: NULL
, This
->width
, This
->height
,
1702 This
->xres
, This
->yres
);
1706 hr
= write_source(iface
, pIBitmapSource
, prc
,
1707 This
->format
->guid
, This
->format
->bpp
, This
->width
, This
->height
);
1713 static HRESULT WINAPI
TiffFrameEncode_Commit(IWICBitmapFrameEncode
*iface
)
1715 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1717 TRACE("(%p)\n", iface
);
1719 EnterCriticalSection(&This
->parent
->lock
);
1721 if (!This
->info_written
|| This
->lines_written
!= This
->height
|| This
->committed
)
1723 LeaveCriticalSection(&This
->parent
->lock
);
1724 return WINCODEC_ERR_WRONGSTATE
;
1727 /* libtiff will commit the data when creating a new frame or closing the file */
1729 This
->committed
= TRUE
;
1730 This
->parent
->num_frames_committed
++;
1732 LeaveCriticalSection(&This
->parent
->lock
);
1737 static HRESULT WINAPI
TiffFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
1738 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1740 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
1744 static const IWICBitmapFrameEncodeVtbl TiffFrameEncode_Vtbl
= {
1745 TiffFrameEncode_QueryInterface
,
1746 TiffFrameEncode_AddRef
,
1747 TiffFrameEncode_Release
,
1748 TiffFrameEncode_Initialize
,
1749 TiffFrameEncode_SetSize
,
1750 TiffFrameEncode_SetResolution
,
1751 TiffFrameEncode_SetPixelFormat
,
1752 TiffFrameEncode_SetColorContexts
,
1753 TiffFrameEncode_SetPalette
,
1754 TiffFrameEncode_SetThumbnail
,
1755 TiffFrameEncode_WritePixels
,
1756 TiffFrameEncode_WriteSource
,
1757 TiffFrameEncode_Commit
,
1758 TiffFrameEncode_GetMetadataQueryWriter
1761 static HRESULT WINAPI
TiffEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
1764 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1765 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1767 if (!ppv
) return E_INVALIDARG
;
1769 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1770 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1772 *ppv
= &This
->IWICBitmapEncoder_iface
;
1777 return E_NOINTERFACE
;
1780 IUnknown_AddRef((IUnknown
*)*ppv
);
1784 static ULONG WINAPI
TiffEncoder_AddRef(IWICBitmapEncoder
*iface
)
1786 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1787 ULONG ref
= InterlockedIncrement(&This
->ref
);
1789 TRACE("(%p) refcount=%u\n", iface
, ref
);
1794 static ULONG WINAPI
TiffEncoder_Release(IWICBitmapEncoder
*iface
)
1796 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1797 ULONG ref
= InterlockedDecrement(&This
->ref
);
1799 TRACE("(%p) refcount=%u\n", iface
, ref
);
1803 if (This
->tiff
) pTIFFClose(This
->tiff
);
1804 if (This
->stream
) IStream_Release(This
->stream
);
1805 This
->lock
.DebugInfo
->Spare
[0] = 0;
1806 DeleteCriticalSection(&This
->lock
);
1807 HeapFree(GetProcessHeap(), 0, This
);
1813 static HRESULT WINAPI
TiffEncoder_Initialize(IWICBitmapEncoder
*iface
,
1814 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1816 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1820 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1822 EnterCriticalSection(&This
->lock
);
1824 if (This
->initialized
|| This
->committed
)
1826 hr
= WINCODEC_ERR_WRONGSTATE
;
1830 tiff
= tiff_open_stream(pIStream
, "w");
1839 This
->stream
= pIStream
;
1840 IStream_AddRef(pIStream
);
1841 This
->initialized
= TRUE
;
1844 LeaveCriticalSection(&This
->lock
);
1848 static HRESULT WINAPI
TiffEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1849 GUID
*pguidContainerFormat
)
1851 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
1855 static HRESULT WINAPI
TiffEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1856 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1858 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1862 static HRESULT WINAPI
TiffEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1863 UINT cCount
, IWICColorContext
**ppIColorContext
)
1865 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1869 static HRESULT WINAPI
TiffEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*pIPalette
)
1871 TRACE("(%p,%p)\n", iface
, pIPalette
);
1872 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1875 static HRESULT WINAPI
TiffEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1877 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1878 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1881 static HRESULT WINAPI
TiffEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1883 TRACE("(%p,%p)\n", iface
, pIPreview
);
1884 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1887 static HRESULT WINAPI
TiffEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1888 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1890 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1891 TiffFrameEncode
*result
;
1895 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1897 EnterCriticalSection(&This
->lock
);
1899 if (!This
->initialized
|| This
->committed
)
1901 hr
= WINCODEC_ERR_WRONGSTATE
;
1903 else if (This
->num_frames
!= This
->num_frames_committed
)
1905 FIXME("New frame created before previous frame was committed\n");
1911 PROPBAG2 opts
[2]= {{0}};
1912 opts
[0].pstrName
= (LPOLESTR
)wszTiffCompressionMethod
;
1913 opts
[0].vt
= VT_UI1
;
1914 opts
[0].dwType
= PROPBAG2_TYPE_DATA
;
1916 opts
[1].pstrName
= (LPOLESTR
)wszCompressionQuality
;
1918 opts
[1].dwType
= PROPBAG2_TYPE_DATA
;
1920 hr
= CreatePropertyBag2(opts
, 2, ppIEncoderOptions
);
1927 V_UNION(&v
, bVal
) = WICTiffCompressionDontCare
;
1928 hr
= IPropertyBag2_Write(*ppIEncoderOptions
, 1, opts
, &v
);
1932 IPropertyBag2_Release(*ppIEncoderOptions
);
1933 *ppIEncoderOptions
= NULL
;
1940 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(*result
));
1944 result
->IWICBitmapFrameEncode_iface
.lpVtbl
= &TiffFrameEncode_Vtbl
;
1946 result
->parent
= This
;
1947 result
->initialized
= FALSE
;
1948 result
->info_written
= FALSE
;
1949 result
->committed
= FALSE
;
1950 result
->format
= NULL
;
1955 result
->lines_written
= 0;
1957 IWICBitmapEncoder_AddRef(iface
);
1958 *ppIFrameEncode
= &result
->IWICBitmapFrameEncode_iface
;
1960 if (This
->num_frames
!= 0)
1961 pTIFFWriteDirectory(This
->tiff
);
1970 IPropertyBag2_Release(*ppIEncoderOptions
);
1971 *ppIEncoderOptions
= NULL
;
1975 LeaveCriticalSection(&This
->lock
);
1980 static HRESULT WINAPI
TiffEncoder_Commit(IWICBitmapEncoder
*iface
)
1982 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1984 TRACE("(%p)\n", iface
);
1986 EnterCriticalSection(&This
->lock
);
1988 if (!This
->initialized
|| This
->committed
)
1990 LeaveCriticalSection(&This
->lock
);
1991 return WINCODEC_ERR_WRONGSTATE
;
1994 pTIFFClose(This
->tiff
);
1995 IStream_Release(This
->stream
);
1996 This
->stream
= NULL
;
1999 This
->committed
= TRUE
;
2001 LeaveCriticalSection(&This
->lock
);
2006 static HRESULT WINAPI
TiffEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
2007 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
2009 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
2013 static const IWICBitmapEncoderVtbl TiffEncoder_Vtbl
= {
2014 TiffEncoder_QueryInterface
,
2016 TiffEncoder_Release
,
2017 TiffEncoder_Initialize
,
2018 TiffEncoder_GetContainerFormat
,
2019 TiffEncoder_GetEncoderInfo
,
2020 TiffEncoder_SetColorContexts
,
2021 TiffEncoder_SetPalette
,
2022 TiffEncoder_SetThumbnail
,
2023 TiffEncoder_SetPreview
,
2024 TiffEncoder_CreateNewFrame
,
2026 TiffEncoder_GetMetadataQueryWriter
2029 HRESULT
TiffEncoder_CreateInstance(REFIID iid
, void** ppv
)
2034 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
2038 if (!load_libtiff())
2040 ERR("Failed writing TIFF because unable to load %s\n",SONAME_LIBTIFF
);
2044 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffEncoder
));
2045 if (!This
) return E_OUTOFMEMORY
;
2047 This
->IWICBitmapEncoder_iface
.lpVtbl
= &TiffEncoder_Vtbl
;
2049 This
->stream
= NULL
;
2050 InitializeCriticalSection(&This
->lock
);
2051 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffEncoder.lock");
2053 This
->initialized
= FALSE
;
2054 This
->num_frames
= 0;
2055 This
->num_frames_committed
= 0;
2056 This
->committed
= FALSE
;
2058 ret
= IWICBitmapEncoder_QueryInterface(&This
->IWICBitmapEncoder_iface
, iid
, ppv
);
2059 IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
2064 #else /* !SONAME_LIBTIFF */
2066 HRESULT
TiffDecoder_CreateInstance(REFIID iid
, void** ppv
)
2068 ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
2072 HRESULT
TiffEncoder_CreateInstance(REFIID iid
, void** ppv
)
2074 ERR("Trying to save TIFF picture, but Wine was compiled without TIFF support.\n");