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 "wincodecsdk.h"
38 #include "wincodecs_private.h"
40 #include "wine/debug.h"
41 #include "wine/library.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
47 static CRITICAL_SECTION init_tiff_cs
;
48 static CRITICAL_SECTION_DEBUG init_tiff_cs_debug
=
51 { &init_tiff_cs_debug
.ProcessLocksList
,
52 &init_tiff_cs_debug
.ProcessLocksList
},
53 0, 0, { (DWORD_PTR
)(__FILE__
": init_tiff_cs") }
55 static CRITICAL_SECTION init_tiff_cs
= { &init_tiff_cs_debug
, -1, 0, 0, 0, 0 };
57 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};
58 static const WCHAR wszCompressionQuality
[] = {'C','o','m','p','r','e','s','s','i','o','n','Q','u','a','l','i','t','y',0};
60 static void *libtiff_handle
;
61 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
62 MAKE_FUNCPTR(TIFFClientOpen
);
63 MAKE_FUNCPTR(TIFFClose
);
64 MAKE_FUNCPTR(TIFFCurrentDirOffset
);
65 MAKE_FUNCPTR(TIFFGetField
);
66 MAKE_FUNCPTR(TIFFIsByteSwapped
);
67 MAKE_FUNCPTR(TIFFNumberOfDirectories
);
68 MAKE_FUNCPTR(TIFFReadDirectory
);
69 MAKE_FUNCPTR(TIFFReadEncodedStrip
);
70 MAKE_FUNCPTR(TIFFReadEncodedTile
);
71 MAKE_FUNCPTR(TIFFSetDirectory
);
72 MAKE_FUNCPTR(TIFFSetField
);
73 MAKE_FUNCPTR(TIFFWriteDirectory
);
74 MAKE_FUNCPTR(TIFFWriteScanline
);
77 static void *load_libtiff(void)
81 EnterCriticalSection(&init_tiff_cs
);
83 if (!libtiff_handle
&&
84 (libtiff_handle
= wine_dlopen(SONAME_LIBTIFF
, RTLD_NOW
, NULL
, 0)) != NULL
)
86 void * (*pTIFFSetWarningHandler
)(void *);
87 void * (*pTIFFSetWarningHandlerExt
)(void *);
89 #define LOAD_FUNCPTR(f) \
90 if((p##f = wine_dlsym(libtiff_handle, #f, NULL, 0)) == NULL) { \
91 ERR("failed to load symbol %s\n", #f); \
92 libtiff_handle = NULL; \
93 LeaveCriticalSection(&init_tiff_cs); \
96 LOAD_FUNCPTR(TIFFClientOpen
);
97 LOAD_FUNCPTR(TIFFClose
);
98 LOAD_FUNCPTR(TIFFCurrentDirOffset
);
99 LOAD_FUNCPTR(TIFFGetField
);
100 LOAD_FUNCPTR(TIFFIsByteSwapped
);
101 LOAD_FUNCPTR(TIFFNumberOfDirectories
);
102 LOAD_FUNCPTR(TIFFReadDirectory
);
103 LOAD_FUNCPTR(TIFFReadEncodedStrip
);
104 LOAD_FUNCPTR(TIFFReadEncodedTile
);
105 LOAD_FUNCPTR(TIFFSetDirectory
);
106 LOAD_FUNCPTR(TIFFSetField
);
107 LOAD_FUNCPTR(TIFFWriteDirectory
);
108 LOAD_FUNCPTR(TIFFWriteScanline
);
111 if ((pTIFFSetWarningHandler
= wine_dlsym(libtiff_handle
, "TIFFSetWarningHandler", NULL
, 0)))
112 pTIFFSetWarningHandler(NULL
);
113 if ((pTIFFSetWarningHandlerExt
= wine_dlsym(libtiff_handle
, "TIFFSetWarningHandlerExt", NULL
, 0)))
114 pTIFFSetWarningHandlerExt(NULL
);
117 result
= libtiff_handle
;
119 LeaveCriticalSection(&init_tiff_cs
);
123 static tsize_t
tiff_stream_read(thandle_t client_data
, tdata_t data
, tsize_t size
)
125 IStream
*stream
= (IStream
*)client_data
;
129 hr
= IStream_Read(stream
, data
, size
, &bytes_read
);
130 if (FAILED(hr
)) bytes_read
= 0;
134 static tsize_t
tiff_stream_write(thandle_t client_data
, tdata_t data
, tsize_t size
)
136 IStream
*stream
= (IStream
*)client_data
;
140 hr
= IStream_Write(stream
, data
, size
, &bytes_written
);
141 if (FAILED(hr
)) bytes_written
= 0;
142 return bytes_written
;
145 static toff_t
tiff_stream_seek(thandle_t client_data
, toff_t offset
, int whence
)
147 IStream
*stream
= (IStream
*)client_data
;
150 ULARGE_INTEGER new_position
;
153 move
.QuadPart
= offset
;
157 origin
= STREAM_SEEK_SET
;
160 origin
= STREAM_SEEK_CUR
;
163 origin
= STREAM_SEEK_END
;
166 ERR("unknown whence value %i\n", whence
);
170 hr
= IStream_Seek(stream
, move
, origin
, &new_position
);
171 if (SUCCEEDED(hr
)) return new_position
.QuadPart
;
175 static int tiff_stream_close(thandle_t client_data
)
177 /* Caller is responsible for releasing the stream object. */
181 static toff_t
tiff_stream_size(thandle_t client_data
)
183 IStream
*stream
= (IStream
*)client_data
;
187 hr
= IStream_Stat(stream
, &statstg
, STATFLAG_NONAME
);
189 if (SUCCEEDED(hr
)) return statstg
.cbSize
.QuadPart
;
193 static int tiff_stream_map(thandle_t client_data
, tdata_t
*addr
, toff_t
*size
)
195 /* Cannot mmap streams */
199 static void tiff_stream_unmap(thandle_t client_data
, tdata_t addr
, toff_t size
)
201 /* No need to ever do this, since we can't map things. */
204 static TIFF
* tiff_open_stream(IStream
*stream
, const char *mode
)
209 IStream_Seek(stream
, zero
, STREAM_SEEK_SET
, NULL
);
211 return pTIFFClientOpen("<IStream object>", mode
, stream
, tiff_stream_read
,
212 tiff_stream_write
, tiff_stream_seek
, tiff_stream_close
,
213 tiff_stream_size
, tiff_stream_map
, tiff_stream_unmap
);
217 IWICBitmapDecoder IWICBitmapDecoder_iface
;
220 CRITICAL_SECTION lock
; /* Must be held when tiff is used or initiailzed is set */
226 const WICPixelFormatGUID
*format
;
233 int invert_grayscale
;
235 UINT tile_width
, tile_height
;
240 UINT resolution_unit
;
245 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
246 IWICMetadataBlockReader IWICMetadataBlockReader_iface
;
250 tiff_decode_info decode_info
;
251 INT cached_tile_x
, cached_tile_y
;
255 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
;
256 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl
;
258 static inline TiffDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
260 return CONTAINING_RECORD(iface
, TiffDecoder
, IWICBitmapDecoder_iface
);
263 static inline TiffFrameDecode
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
265 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICBitmapFrameDecode_iface
);
268 static inline TiffFrameDecode
*impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader
*iface
)
270 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICMetadataBlockReader_iface
);
273 static HRESULT
tiff_get_decode_info(TIFF
*tiff
, tiff_decode_info
*decode_info
)
275 uint16 photometric
, bps
, samples
, planar
;
276 uint16 extra_sample_count
, extra_sample
, *extra_samples
;
279 decode_info
->indexed
= 0;
280 decode_info
->reverse_bgr
= 0;
281 decode_info
->invert_grayscale
= 0;
282 decode_info
->tiled
= 0;
284 ret
= pTIFFGetField(tiff
, TIFFTAG_PHOTOMETRIC
, &photometric
);
287 WARN("missing PhotometricInterpretation tag\n");
291 ret
= pTIFFGetField(tiff
, TIFFTAG_BITSPERSAMPLE
, &bps
);
293 decode_info
->bps
= bps
;
295 ret
= pTIFFGetField(tiff
, TIFFTAG_SAMPLESPERPIXEL
, &samples
);
296 if (!ret
) samples
= 1;
297 decode_info
->samples
= samples
;
303 ret
= pTIFFGetField(tiff
, TIFFTAG_PLANARCONFIG
, &planar
);
304 if (!ret
) planar
= 1;
307 FIXME("unhandled planar configuration %u\n", planar
);
311 decode_info
->planar
= planar
;
315 case 0: /* WhiteIsZero */
316 decode_info
->invert_grayscale
= 1;
318 case 1: /* BlackIsZero */
321 FIXME("unhandled grayscale sample count %u\n", samples
);
325 decode_info
->bpp
= bps
;
329 decode_info
->format
= &GUID_WICPixelFormatBlackWhite
;
332 decode_info
->format
= &GUID_WICPixelFormat4bppGray
;
335 decode_info
->format
= &GUID_WICPixelFormat8bppGray
;
338 FIXME("unhandled greyscale bit count %u\n", bps
);
343 decode_info
->bpp
= bps
* samples
;
347 ret
= pTIFFGetField(tiff
, TIFFTAG_EXTRASAMPLES
, &extra_sample_count
, &extra_samples
);
350 extra_sample_count
= 1;
352 extra_samples
= &extra_sample
;
355 else if (samples
!= 3)
357 FIXME("unhandled RGB sample count %u\n", samples
);
364 decode_info
->reverse_bgr
= 1;
366 decode_info
->format
= &GUID_WICPixelFormat24bppBGR
;
368 switch(extra_samples
[0])
370 case 1: /* Associated (pre-multiplied) alpha data */
371 decode_info
->format
= &GUID_WICPixelFormat32bppPBGRA
;
373 case 0: /* Unspecified data */
374 case 2: /* Unassociated alpha data */
375 decode_info
->format
= &GUID_WICPixelFormat32bppBGRA
;
378 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
384 decode_info
->format
= &GUID_WICPixelFormat48bppRGB
;
386 switch(extra_samples
[0])
388 case 1: /* Associated (pre-multiplied) alpha data */
389 decode_info
->format
= &GUID_WICPixelFormat64bppPRGBA
;
391 case 0: /* Unspecified data */
392 case 2: /* Unassociated alpha data */
393 decode_info
->format
= &GUID_WICPixelFormat64bppRGBA
;
396 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
401 FIXME("unhandled RGB bit count %u\n", bps
);
405 case 3: /* RGB Palette */
408 FIXME("unhandled indexed sample count %u\n", samples
);
412 decode_info
->indexed
= 1;
413 decode_info
->bpp
= bps
;
417 decode_info
->format
= &GUID_WICPixelFormat4bppIndexed
;
420 decode_info
->format
= &GUID_WICPixelFormat8bppIndexed
;
423 FIXME("unhandled indexed bit count %u\n", bps
);
427 case 4: /* Transparency mask */
432 FIXME("unhandled PhotometricInterpretation %u\n", photometric
);
436 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGEWIDTH
, &decode_info
->width
);
439 WARN("missing image width\n");
443 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGELENGTH
, &decode_info
->height
);
446 WARN("missing image length\n");
450 if ((ret
= pTIFFGetField(tiff
, TIFFTAG_TILEWIDTH
, &decode_info
->tile_width
)))
452 decode_info
->tiled
= 1;
454 ret
= pTIFFGetField(tiff
, TIFFTAG_TILELENGTH
, &decode_info
->tile_height
);
457 WARN("missing tile height\n");
461 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
462 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
463 decode_info
->tiles_across
= (decode_info
->width
+ decode_info
->tile_width
- 1) / decode_info
->tile_width
;
465 else if ((ret
= pTIFFGetField(tiff
, TIFFTAG_ROWSPERSTRIP
, &decode_info
->tile_height
)))
467 if (decode_info
->tile_height
> decode_info
->height
)
468 decode_info
->tile_height
= decode_info
->height
;
469 decode_info
->tile_width
= decode_info
->width
;
470 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
471 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
475 /* Some broken TIFF files have a single strip and lack the RowsPerStrip tag */
476 decode_info
->tile_height
= decode_info
->height
;
477 decode_info
->tile_width
= decode_info
->width
;
478 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
479 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
482 decode_info
->resolution_unit
= 0;
483 pTIFFGetField(tiff
, TIFFTAG_RESOLUTIONUNIT
, &decode_info
->resolution_unit
);
484 if (decode_info
->resolution_unit
!= 0)
486 ret
= pTIFFGetField(tiff
, TIFFTAG_XRESOLUTION
, &decode_info
->xres
);
489 WARN("missing X resolution\n");
490 decode_info
->resolution_unit
= 0;
493 ret
= pTIFFGetField(tiff
, TIFFTAG_YRESOLUTION
, &decode_info
->yres
);
496 WARN("missing Y resolution\n");
497 decode_info
->resolution_unit
= 0;
504 static HRESULT WINAPI
TiffDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
507 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
508 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
510 if (!ppv
) return E_INVALIDARG
;
512 if (IsEqualIID(&IID_IUnknown
, iid
) ||
513 IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
515 *ppv
= &This
->IWICBitmapDecoder_iface
;
520 return E_NOINTERFACE
;
523 IUnknown_AddRef((IUnknown
*)*ppv
);
527 static ULONG WINAPI
TiffDecoder_AddRef(IWICBitmapDecoder
*iface
)
529 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
530 ULONG ref
= InterlockedIncrement(&This
->ref
);
532 TRACE("(%p) refcount=%u\n", iface
, ref
);
537 static ULONG WINAPI
TiffDecoder_Release(IWICBitmapDecoder
*iface
)
539 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
540 ULONG ref
= InterlockedDecrement(&This
->ref
);
542 TRACE("(%p) refcount=%u\n", iface
, ref
);
546 if (This
->tiff
) pTIFFClose(This
->tiff
);
547 if (This
->stream
) IStream_Release(This
->stream
);
548 This
->lock
.DebugInfo
->Spare
[0] = 0;
549 DeleteCriticalSection(&This
->lock
);
550 HeapFree(GetProcessHeap(), 0, This
);
556 static HRESULT WINAPI
TiffDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*stream
,
561 TRACE("(%p,%p,%p)\n", iface
, stream
, capability
);
563 if (!stream
|| !capability
) return E_INVALIDARG
;
565 hr
= IWICBitmapDecoder_Initialize(iface
, stream
, WICDecodeMetadataCacheOnDemand
);
566 if (hr
!= S_OK
) return hr
;
568 *capability
= WICBitmapDecoderCapabilityCanDecodeAllImages
|
569 WICBitmapDecoderCapabilityCanDecodeSomeImages
|
570 WICBitmapDecoderCapabilityCanEnumerateMetadata
;
574 static HRESULT WINAPI
TiffDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
575 WICDecodeOptions cacheOptions
)
577 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
581 TRACE("(%p,%p,%x): stub\n", iface
, pIStream
, cacheOptions
);
583 EnterCriticalSection(&This
->lock
);
585 if (This
->initialized
)
587 hr
= WINCODEC_ERR_WRONGSTATE
;
591 tiff
= tiff_open_stream(pIStream
, "r");
600 This
->stream
= pIStream
;
601 IStream_AddRef(pIStream
);
602 This
->initialized
= TRUE
;
605 LeaveCriticalSection(&This
->lock
);
609 static HRESULT WINAPI
TiffDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
610 GUID
*pguidContainerFormat
)
612 if (!pguidContainerFormat
) return E_INVALIDARG
;
614 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
618 static HRESULT WINAPI
TiffDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
619 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
622 IWICComponentInfo
*compinfo
;
624 TRACE("(%p,%p)\n", iface
, ppIDecoderInfo
);
626 hr
= CreateComponentInfo(&CLSID_WICTiffDecoder
, &compinfo
);
627 if (FAILED(hr
)) return hr
;
629 hr
= IWICComponentInfo_QueryInterface(compinfo
, &IID_IWICBitmapDecoderInfo
,
630 (void**)ppIDecoderInfo
);
632 IWICComponentInfo_Release(compinfo
);
637 static HRESULT WINAPI
TiffDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
638 IWICPalette
*pIPalette
)
640 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
644 static HRESULT WINAPI
TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
645 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
647 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
651 static HRESULT WINAPI
TiffDecoder_GetPreview(IWICBitmapDecoder
*iface
,
652 IWICBitmapSource
**ppIBitmapSource
)
654 TRACE("(%p,%p)\n", iface
, ppIBitmapSource
);
656 if (!ppIBitmapSource
) return E_INVALIDARG
;
658 *ppIBitmapSource
= NULL
;
659 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
662 static HRESULT WINAPI
TiffDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
663 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
665 FIXME("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
666 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
669 static HRESULT WINAPI
TiffDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
670 IWICBitmapSource
**ppIThumbnail
)
672 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
674 if (!ppIThumbnail
) return E_INVALIDARG
;
676 *ppIThumbnail
= NULL
;
677 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
680 static HRESULT WINAPI
TiffDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
683 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
685 if (!pCount
) return E_INVALIDARG
;
687 EnterCriticalSection(&This
->lock
);
688 *pCount
= This
->tiff
? pTIFFNumberOfDirectories(This
->tiff
) : 0;
689 LeaveCriticalSection(&This
->lock
);
691 TRACE("(%p) <-- %i\n", iface
, *pCount
);
696 static HRESULT WINAPI
TiffDecoder_GetFrame(IWICBitmapDecoder
*iface
,
697 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
699 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
700 TiffFrameDecode
*result
;
702 tiff_decode_info decode_info
;
705 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
708 return WINCODEC_ERR_FRAMEMISSING
;
710 EnterCriticalSection(&This
->lock
);
711 res
= pTIFFSetDirectory(This
->tiff
, index
);
712 if (!res
) hr
= E_INVALIDARG
;
713 else hr
= tiff_get_decode_info(This
->tiff
, &decode_info
);
714 LeaveCriticalSection(&This
->lock
);
718 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode
));
722 result
->IWICBitmapFrameDecode_iface
.lpVtbl
= &TiffFrameDecode_Vtbl
;
723 result
->IWICMetadataBlockReader_iface
.lpVtbl
= &TiffFrameDecode_BlockVtbl
;
725 result
->parent
= This
;
726 result
->index
= index
;
727 result
->decode_info
= decode_info
;
728 result
->cached_tile_x
= -1;
729 result
->cached_tile
= HeapAlloc(GetProcessHeap(), 0, decode_info
.tile_size
);
731 if (result
->cached_tile
)
732 *ppIBitmapFrame
= &result
->IWICBitmapFrameDecode_iface
;
736 HeapFree(GetProcessHeap(), 0, result
);
739 else hr
= E_OUTOFMEMORY
;
742 if (FAILED(hr
)) *ppIBitmapFrame
= NULL
;
747 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl
= {
748 TiffDecoder_QueryInterface
,
751 TiffDecoder_QueryCapability
,
752 TiffDecoder_Initialize
,
753 TiffDecoder_GetContainerFormat
,
754 TiffDecoder_GetDecoderInfo
,
755 TiffDecoder_CopyPalette
,
756 TiffDecoder_GetMetadataQueryReader
,
757 TiffDecoder_GetPreview
,
758 TiffDecoder_GetColorContexts
,
759 TiffDecoder_GetThumbnail
,
760 TiffDecoder_GetFrameCount
,
764 static HRESULT WINAPI
TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
767 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
768 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
770 if (!ppv
) return E_INVALIDARG
;
772 if (IsEqualIID(&IID_IUnknown
, iid
) ||
773 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
774 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
776 *ppv
= &This
->IWICBitmapFrameDecode_iface
;
778 else if (IsEqualIID(&IID_IWICMetadataBlockReader
, iid
))
780 *ppv
= &This
->IWICMetadataBlockReader_iface
;
785 return E_NOINTERFACE
;
788 IUnknown_AddRef((IUnknown
*)*ppv
);
792 static ULONG WINAPI
TiffFrameDecode_AddRef(IWICBitmapFrameDecode
*iface
)
794 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
795 ULONG ref
= InterlockedIncrement(&This
->ref
);
797 TRACE("(%p) refcount=%u\n", iface
, ref
);
802 static ULONG WINAPI
TiffFrameDecode_Release(IWICBitmapFrameDecode
*iface
)
804 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
805 ULONG ref
= InterlockedDecrement(&This
->ref
);
807 TRACE("(%p) refcount=%u\n", iface
, ref
);
811 HeapFree(GetProcessHeap(), 0, This
->cached_tile
);
812 HeapFree(GetProcessHeap(), 0, This
);
818 static HRESULT WINAPI
TiffFrameDecode_GetSize(IWICBitmapFrameDecode
*iface
,
819 UINT
*puiWidth
, UINT
*puiHeight
)
821 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
823 *puiWidth
= This
->decode_info
.width
;
824 *puiHeight
= This
->decode_info
.height
;
826 TRACE("(%p) <-- %ux%u\n", iface
, *puiWidth
, *puiHeight
);
831 static HRESULT WINAPI
TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
832 WICPixelFormatGUID
*pPixelFormat
)
834 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
836 memcpy(pPixelFormat
, This
->decode_info
.format
, sizeof(GUID
));
838 TRACE("(%p) <-- %s\n", This
, debugstr_guid(This
->decode_info
.format
));
843 static HRESULT WINAPI
TiffFrameDecode_GetResolution(IWICBitmapFrameDecode
*iface
,
844 double *pDpiX
, double *pDpiY
)
846 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
848 switch (This
->decode_info
.resolution_unit
)
851 FIXME("unknown resolution unit %i\n", This
->decode_info
.resolution_unit
);
853 case 0: /* Not set */
854 *pDpiX
= *pDpiY
= 96.0;
856 case 1: /* Relative measurements */
858 *pDpiY
= 96.0 * This
->decode_info
.yres
/ This
->decode_info
.xres
;
861 *pDpiX
= This
->decode_info
.xres
;
862 *pDpiY
= This
->decode_info
.yres
;
864 case 3: /* Centimeter */
865 *pDpiX
= This
->decode_info
.xres
/ 2.54;
866 *pDpiY
= This
->decode_info
.yres
/ 2.54;
870 TRACE("(%p) <-- %f,%f unit=%i\n", iface
, *pDpiX
, *pDpiY
, This
->decode_info
.resolution_unit
);
875 static HRESULT WINAPI
TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode
*iface
,
876 IWICPalette
*pIPalette
)
878 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
879 uint16
*red
, *green
, *blue
;
880 WICColor colors
[256];
881 int color_count
, ret
, i
;
883 TRACE("(%p,%p)\n", iface
, pIPalette
);
885 color_count
= 1<<This
->decode_info
.bps
;
887 EnterCriticalSection(&This
->parent
->lock
);
888 ret
= pTIFFGetField(This
->parent
->tiff
, TIFFTAG_COLORMAP
, &red
, &green
, &blue
);
889 LeaveCriticalSection(&This
->parent
->lock
);
893 WARN("Couldn't read color map\n");
894 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
897 for (i
=0; i
<color_count
; i
++)
899 colors
[i
] = 0xff000000 |
900 ((red
[i
]<<8) & 0xff0000) |
901 (green
[i
] & 0xff00) |
902 ((blue
[i
]>>8) & 0xff);
905 return IWICPalette_InitializeCustom(pIPalette
, colors
, color_count
);
908 static HRESULT
TiffFrameDecode_ReadTile(TiffFrameDecode
*This
, UINT tile_x
, UINT tile_y
)
914 swap_bytes
= pTIFFIsByteSwapped(This
->parent
->tiff
);
916 ret
= pTIFFSetDirectory(This
->parent
->tiff
, This
->index
);
923 if (This
->decode_info
.tiled
)
925 ret
= pTIFFReadEncodedTile(This
->parent
->tiff
, tile_x
+ tile_y
* This
->decode_info
.tiles_across
, This
->cached_tile
, This
->decode_info
.tile_size
);
929 ret
= pTIFFReadEncodedStrip(This
->parent
->tiff
, tile_y
, This
->cached_tile
, This
->decode_info
.tile_size
);
936 if (hr
== S_OK
&& This
->decode_info
.reverse_bgr
)
938 if (This
->decode_info
.bps
== 8)
940 UINT sample_count
= This
->decode_info
.samples
;
942 reverse_bgr8(sample_count
, This
->cached_tile
, This
->decode_info
.tile_width
,
943 This
->decode_info
.tile_height
, This
->decode_info
.tile_width
* sample_count
);
947 if (hr
== S_OK
&& swap_bytes
&& This
->decode_info
.bps
> 8)
949 UINT row
, i
, samples_per_row
;
952 samples_per_row
= This
->decode_info
.tile_width
* This
->decode_info
.samples
;
954 switch(This
->decode_info
.bps
)
957 for (row
=0; row
<This
->decode_info
.tile_height
; row
++)
959 sample
= This
->cached_tile
+ row
* This
->decode_info
.tile_stride
;
960 for (i
=0; i
<samples_per_row
; i
++)
963 sample
[1] = sample
[0];
970 ERR("unhandled bps for byte swap %u\n", This
->decode_info
.bps
);
975 if (hr
== S_OK
&& This
->decode_info
.invert_grayscale
)
979 if (This
->decode_info
.samples
!= 1)
981 ERR("cannot invert grayscale image with %u samples\n", This
->decode_info
.samples
);
985 end
= This
->cached_tile
+This
->decode_info
.tile_size
;
987 for (byte
= This
->cached_tile
; byte
!= end
; byte
++)
993 This
->cached_tile_x
= tile_x
;
994 This
->cached_tile_y
= tile_y
;
1000 static HRESULT WINAPI
TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode
*iface
,
1001 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
1003 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1004 UINT min_tile_x
, max_tile_x
, min_tile_y
, max_tile_y
;
1005 UINT tile_x
, tile_y
;
1012 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
1018 rect
.Width
= This
->decode_info
.width
;
1019 rect
.Height
= This
->decode_info
.height
;
1024 if (prc
->X
< 0 || prc
->Y
< 0 || prc
->X
+prc
->Width
> This
->decode_info
.width
||
1025 prc
->Y
+prc
->Height
> This
->decode_info
.height
)
1026 return E_INVALIDARG
;
1029 bytesperrow
= ((This
->decode_info
.bpp
* prc
->Width
)+7)/8;
1031 if (cbStride
< bytesperrow
)
1032 return E_INVALIDARG
;
1034 if ((cbStride
* prc
->Height
) > cbBufferSize
)
1035 return E_INVALIDARG
;
1037 min_tile_x
= prc
->X
/ This
->decode_info
.tile_width
;
1038 min_tile_y
= prc
->Y
/ This
->decode_info
.tile_height
;
1039 max_tile_x
= (prc
->X
+prc
->Width
-1) / This
->decode_info
.tile_width
;
1040 max_tile_y
= (prc
->Y
+prc
->Height
-1) / This
->decode_info
.tile_height
;
1042 EnterCriticalSection(&This
->parent
->lock
);
1044 for (tile_x
=min_tile_x
; tile_x
<= max_tile_x
; tile_x
++)
1046 for (tile_y
=min_tile_y
; tile_y
<= max_tile_y
; tile_y
++)
1048 if (tile_x
!= This
->cached_tile_x
|| tile_y
!= This
->cached_tile_y
)
1050 hr
= TiffFrameDecode_ReadTile(This
, tile_x
, tile_y
);
1055 if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1058 rc
.X
= prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1060 if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1063 rc
.Y
= prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1065 if (prc
->X
+prc
->Width
> (tile_x
+1) * This
->decode_info
.tile_width
)
1066 rc
.Width
= This
->decode_info
.tile_width
- rc
.X
;
1067 else if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1068 rc
.Width
= prc
->Width
+ prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1070 rc
.Width
= prc
->Width
;
1072 if (prc
->Y
+prc
->Height
> (tile_y
+1) * This
->decode_info
.tile_height
)
1073 rc
.Height
= This
->decode_info
.tile_height
- rc
.Y
;
1074 else if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1075 rc
.Height
= prc
->Height
+ prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1077 rc
.Height
= prc
->Height
;
1079 dst_tilepos
= pbBuffer
+ (cbStride
* ((rc
.Y
+ tile_y
* This
->decode_info
.tile_height
) - prc
->Y
)) +
1080 ((This
->decode_info
.bpp
* ((rc
.X
+ tile_x
* This
->decode_info
.tile_width
) - prc
->X
) + 7) / 8);
1082 hr
= copy_pixels(This
->decode_info
.bpp
, This
->cached_tile
,
1083 This
->decode_info
.tile_width
, This
->decode_info
.tile_height
, This
->decode_info
.tile_stride
,
1084 &rc
, cbStride
, cbBufferSize
, dst_tilepos
);
1089 LeaveCriticalSection(&This
->parent
->lock
);
1090 TRACE("<-- 0x%x\n", hr
);
1096 LeaveCriticalSection(&This
->parent
->lock
);
1101 static HRESULT WINAPI
TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
1102 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
1104 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
1108 static HRESULT WINAPI
TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode
*iface
,
1109 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
1111 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
1112 const BYTE
*profile
;
1116 TRACE("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
1118 EnterCriticalSection(&This
->parent
->lock
);
1120 if (pTIFFGetField(This
->parent
->tiff
, TIFFTAG_ICCPROFILE
, &len
, &profile
))
1122 if (cCount
&& ppIColorContexts
)
1124 hr
= IWICColorContext_InitializeFromMemory(*ppIColorContexts
, profile
, len
);
1127 LeaveCriticalSection(&This
->parent
->lock
);
1136 LeaveCriticalSection(&This
->parent
->lock
);
1141 static HRESULT WINAPI
TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode
*iface
,
1142 IWICBitmapSource
**ppIThumbnail
)
1144 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
1146 if (!ppIThumbnail
) return E_INVALIDARG
;
1148 *ppIThumbnail
= NULL
;
1149 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
1152 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
= {
1153 TiffFrameDecode_QueryInterface
,
1154 TiffFrameDecode_AddRef
,
1155 TiffFrameDecode_Release
,
1156 TiffFrameDecode_GetSize
,
1157 TiffFrameDecode_GetPixelFormat
,
1158 TiffFrameDecode_GetResolution
,
1159 TiffFrameDecode_CopyPalette
,
1160 TiffFrameDecode_CopyPixels
,
1161 TiffFrameDecode_GetMetadataQueryReader
,
1162 TiffFrameDecode_GetColorContexts
,
1163 TiffFrameDecode_GetThumbnail
1166 static HRESULT WINAPI
TiffFrameDecode_Block_QueryInterface(IWICMetadataBlockReader
*iface
,
1167 REFIID iid
, void **ppv
)
1169 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1170 return IWICBitmapFrameDecode_QueryInterface(&This
->IWICBitmapFrameDecode_iface
, iid
, ppv
);
1173 static ULONG WINAPI
TiffFrameDecode_Block_AddRef(IWICMetadataBlockReader
*iface
)
1175 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1176 return IWICBitmapFrameDecode_AddRef(&This
->IWICBitmapFrameDecode_iface
);
1179 static ULONG WINAPI
TiffFrameDecode_Block_Release(IWICMetadataBlockReader
*iface
)
1181 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1182 return IWICBitmapFrameDecode_Release(&This
->IWICBitmapFrameDecode_iface
);
1185 static HRESULT WINAPI
TiffFrameDecode_Block_GetContainerFormat(IWICMetadataBlockReader
*iface
,
1188 TRACE("(%p,%p)\n", iface
, guid
);
1190 if (!guid
) return E_INVALIDARG
;
1192 *guid
= GUID_ContainerFormatTiff
;
1196 static HRESULT WINAPI
TiffFrameDecode_Block_GetCount(IWICMetadataBlockReader
*iface
,
1199 TRACE("%p,%p\n", iface
, count
);
1201 if (!count
) return E_INVALIDARG
;
1207 static HRESULT
create_metadata_reader(TiffFrameDecode
*This
, IWICMetadataReader
**reader
)
1210 LARGE_INTEGER dir_offset
;
1211 IWICMetadataReader
*metadata_reader
;
1212 IWICPersistStream
*persist
;
1214 /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
1216 hr
= CoCreateInstance(&CLSID_WICIfdMetadataReader
, NULL
, CLSCTX_INPROC_SERVER
,
1217 &IID_IWICMetadataReader
, (void **)&metadata_reader
);
1218 if (FAILED(hr
)) return hr
;
1220 hr
= IWICMetadataReader_QueryInterface(metadata_reader
, &IID_IWICPersistStream
, (void **)&persist
);
1223 IWICMetadataReader_Release(metadata_reader
);
1227 EnterCriticalSection(&This
->parent
->lock
);
1229 dir_offset
.QuadPart
= pTIFFCurrentDirOffset(This
->parent
->tiff
);
1230 hr
= IStream_Seek(This
->parent
->stream
, dir_offset
, STREAM_SEEK_SET
, NULL
);
1233 BOOL byte_swapped
= pTIFFIsByteSwapped(This
->parent
->tiff
);
1234 #ifdef WORDS_BIGENDIAN
1235 DWORD persist_options
= byte_swapped
? WICPersistOptionsLittleEndian
: WICPersistOptionsBigEndian
;
1237 DWORD persist_options
= byte_swapped
? WICPersistOptionsBigEndian
: WICPersistOptionsLittleEndian
;
1239 persist_options
|= WICPersistOptionsNoCacheStream
;
1240 hr
= IWICPersistStream_LoadEx(persist
, This
->parent
->stream
, NULL
, persist_options
);
1242 ERR("IWICPersistStream_LoadEx error %#x\n", hr
);
1245 LeaveCriticalSection(&This
->parent
->lock
);
1247 IWICPersistStream_Release(persist
);
1251 IWICMetadataReader_Release(metadata_reader
);
1255 *reader
= metadata_reader
;
1259 static HRESULT WINAPI
TiffFrameDecode_Block_GetReaderByIndex(IWICMetadataBlockReader
*iface
,
1260 UINT index
, IWICMetadataReader
**reader
)
1262 TiffFrameDecode
*This
= impl_from_IWICMetadataBlockReader(iface
);
1264 TRACE("(%p,%u,%p)\n", iface
, index
, reader
);
1266 if (!reader
|| index
!= 0) return E_INVALIDARG
;
1268 return create_metadata_reader(This
, reader
);
1271 static HRESULT WINAPI
TiffFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader
*iface
,
1272 IEnumUnknown
**enum_metadata
)
1274 FIXME("(%p,%p): stub\n", iface
, enum_metadata
);
1278 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl
=
1280 TiffFrameDecode_Block_QueryInterface
,
1281 TiffFrameDecode_Block_AddRef
,
1282 TiffFrameDecode_Block_Release
,
1283 TiffFrameDecode_Block_GetContainerFormat
,
1284 TiffFrameDecode_Block_GetCount
,
1285 TiffFrameDecode_Block_GetReaderByIndex
,
1286 TiffFrameDecode_Block_GetEnumerator
1289 HRESULT
TiffDecoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1294 TRACE("(%p,%s,%p)\n", pUnkOuter
, debugstr_guid(iid
), ppv
);
1298 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
1300 if (!load_libtiff())
1302 ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF
);
1306 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder
));
1307 if (!This
) return E_OUTOFMEMORY
;
1309 This
->IWICBitmapDecoder_iface
.lpVtbl
= &TiffDecoder_Vtbl
;
1311 This
->stream
= NULL
;
1312 InitializeCriticalSection(&This
->lock
);
1313 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffDecoder.lock");
1315 This
->initialized
= FALSE
;
1317 ret
= IWICBitmapDecoder_QueryInterface(&This
->IWICBitmapDecoder_iface
, iid
, ppv
);
1318 IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
1323 struct tiff_encode_format
{
1324 const WICPixelFormatGUID
*guid
;
1330 int extra_sample_type
;
1334 static const struct tiff_encode_format formats
[] = {
1335 {&GUID_WICPixelFormat24bppBGR
, 2, 8, 3, 24, 0, 0, 1},
1336 {&GUID_WICPixelFormat24bppRGB
, 2, 8, 3, 24, 0, 0, 0},
1337 {&GUID_WICPixelFormatBlackWhite
, 1, 1, 1, 1, 0, 0, 0},
1338 {&GUID_WICPixelFormat4bppGray
, 1, 4, 1, 4, 0, 0, 0},
1339 {&GUID_WICPixelFormat8bppGray
, 1, 8, 1, 8, 0, 0, 0},
1340 {&GUID_WICPixelFormat32bppBGRA
, 2, 8, 4, 32, 1, 2, 1},
1341 {&GUID_WICPixelFormat32bppPBGRA
, 2, 8, 4, 32, 1, 1, 1},
1342 {&GUID_WICPixelFormat48bppRGB
, 2, 16, 3, 48, 0, 0, 0},
1343 {&GUID_WICPixelFormat64bppRGBA
, 2, 16, 4, 64, 1, 2, 0},
1344 {&GUID_WICPixelFormat64bppPRGBA
, 2, 16, 4, 64, 1, 1, 0},
1348 typedef struct TiffEncoder
{
1349 IWICBitmapEncoder IWICBitmapEncoder_iface
;
1352 CRITICAL_SECTION lock
; /* Must be held when tiff is used or fields below are set */
1357 ULONG num_frames_committed
;
1360 static inline TiffEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
1362 return CONTAINING_RECORD(iface
, TiffEncoder
, IWICBitmapEncoder_iface
);
1365 typedef struct TiffFrameEncode
{
1366 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
1368 TiffEncoder
*parent
;
1369 /* fields below are protected by parent->lock */
1373 const struct tiff_encode_format
*format
;
1379 static inline TiffFrameEncode
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
1381 return CONTAINING_RECORD(iface
, TiffFrameEncode
, IWICBitmapFrameEncode_iface
);
1384 static HRESULT WINAPI
TiffFrameEncode_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
1387 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1388 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1390 if (!ppv
) return E_INVALIDARG
;
1392 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1393 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
1395 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
1400 return E_NOINTERFACE
;
1403 IUnknown_AddRef((IUnknown
*)*ppv
);
1407 static ULONG WINAPI
TiffFrameEncode_AddRef(IWICBitmapFrameEncode
*iface
)
1409 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1410 ULONG ref
= InterlockedIncrement(&This
->ref
);
1412 TRACE("(%p) refcount=%u\n", iface
, ref
);
1417 static ULONG WINAPI
TiffFrameEncode_Release(IWICBitmapFrameEncode
*iface
)
1419 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1420 ULONG ref
= InterlockedDecrement(&This
->ref
);
1422 TRACE("(%p) refcount=%u\n", iface
, ref
);
1426 IWICBitmapEncoder_Release(&This
->parent
->IWICBitmapEncoder_iface
);
1427 HeapFree(GetProcessHeap(), 0, This
);
1433 static HRESULT WINAPI
TiffFrameEncode_Initialize(IWICBitmapFrameEncode
*iface
,
1434 IPropertyBag2
*pIEncoderOptions
)
1436 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1437 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
1439 EnterCriticalSection(&This
->parent
->lock
);
1441 if (This
->initialized
)
1443 LeaveCriticalSection(&This
->parent
->lock
);
1444 return WINCODEC_ERR_WRONGSTATE
;
1447 This
->initialized
= TRUE
;
1449 LeaveCriticalSection(&This
->parent
->lock
);
1454 static HRESULT WINAPI
TiffFrameEncode_SetSize(IWICBitmapFrameEncode
*iface
,
1455 UINT uiWidth
, UINT uiHeight
)
1457 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1458 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
1460 EnterCriticalSection(&This
->parent
->lock
);
1462 if (!This
->initialized
|| This
->info_written
)
1464 LeaveCriticalSection(&This
->parent
->lock
);
1465 return WINCODEC_ERR_WRONGSTATE
;
1468 This
->width
= uiWidth
;
1469 This
->height
= uiHeight
;
1471 LeaveCriticalSection(&This
->parent
->lock
);
1476 static HRESULT WINAPI
TiffFrameEncode_SetResolution(IWICBitmapFrameEncode
*iface
,
1477 double dpiX
, double dpiY
)
1479 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1480 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
1482 EnterCriticalSection(&This
->parent
->lock
);
1484 if (!This
->initialized
|| This
->info_written
)
1486 LeaveCriticalSection(&This
->parent
->lock
);
1487 return WINCODEC_ERR_WRONGSTATE
;
1493 LeaveCriticalSection(&This
->parent
->lock
);
1498 static HRESULT WINAPI
TiffFrameEncode_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
1499 WICPixelFormatGUID
*pPixelFormat
)
1501 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1504 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
1506 EnterCriticalSection(&This
->parent
->lock
);
1508 if (!This
->initialized
|| This
->info_written
)
1510 LeaveCriticalSection(&This
->parent
->lock
);
1511 return WINCODEC_ERR_WRONGSTATE
;
1514 for (i
=0; formats
[i
].guid
; i
++)
1516 if (memcmp(formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
1520 if (!formats
[i
].guid
) i
= 0;
1522 This
->format
= &formats
[i
];
1523 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
1525 LeaveCriticalSection(&This
->parent
->lock
);
1530 static HRESULT WINAPI
TiffFrameEncode_SetColorContexts(IWICBitmapFrameEncode
*iface
,
1531 UINT cCount
, IWICColorContext
**ppIColorContext
)
1533 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1537 static HRESULT WINAPI
TiffFrameEncode_SetPalette(IWICBitmapFrameEncode
*iface
,
1538 IWICPalette
*pIPalette
)
1540 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
1541 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1544 static HRESULT WINAPI
TiffFrameEncode_SetThumbnail(IWICBitmapFrameEncode
*iface
,
1545 IWICBitmapSource
*pIThumbnail
)
1547 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
1548 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1551 static HRESULT WINAPI
TiffFrameEncode_WritePixels(IWICBitmapFrameEncode
*iface
,
1552 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
1554 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1555 BYTE
*row_data
, *swapped_data
= NULL
;
1556 UINT i
, j
, line_size
;
1558 TRACE("(%p,%u,%u,%u,%p)\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
1560 EnterCriticalSection(&This
->parent
->lock
);
1562 if (!This
->initialized
|| !This
->width
|| !This
->height
|| !This
->format
)
1564 LeaveCriticalSection(&This
->parent
->lock
);
1565 return WINCODEC_ERR_WRONGSTATE
;
1568 if (lineCount
== 0 || lineCount
+ This
->lines_written
> This
->height
)
1570 LeaveCriticalSection(&This
->parent
->lock
);
1571 return E_INVALIDARG
;
1574 line_size
= ((This
->width
* This
->format
->bpp
)+7)/8;
1576 if (This
->format
->reverse_bgr
)
1578 swapped_data
= HeapAlloc(GetProcessHeap(), 0, line_size
);
1581 LeaveCriticalSection(&This
->parent
->lock
);
1582 return E_OUTOFMEMORY
;
1586 if (!This
->info_written
)
1588 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PHOTOMETRIC
, (uint16
)This
->format
->photometric
);
1589 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PLANARCONFIG
, (uint16
)1);
1590 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_BITSPERSAMPLE
, (uint16
)This
->format
->bps
);
1591 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_SAMPLESPERPIXEL
, (uint16
)This
->format
->samples
);
1593 if (This
->format
->extra_sample
)
1595 uint16 extra_samples
;
1596 extra_samples
= This
->format
->extra_sample_type
;
1598 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_EXTRASAMPLES
, (uint16
)1, &extra_samples
);
1601 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGEWIDTH
, (uint32
)This
->width
);
1602 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGELENGTH
, (uint32
)This
->height
);
1604 if (This
->xres
!= 0.0 && This
->yres
!= 0.0)
1606 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_RESOLUTIONUNIT
, (uint16
)2); /* Inch */
1607 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_XRESOLUTION
, (float)This
->xres
);
1608 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_YRESOLUTION
, (float)This
->yres
);
1611 This
->info_written
= TRUE
;
1614 for (i
=0; i
<lineCount
; i
++)
1616 row_data
= pbPixels
+ i
* cbStride
;
1618 if (This
->format
->reverse_bgr
&& This
->format
->bps
== 8)
1620 memcpy(swapped_data
, row_data
, line_size
);
1621 for (j
=0; j
<line_size
; j
+= This
->format
->samples
)
1624 temp
= swapped_data
[j
];
1625 swapped_data
[j
] = swapped_data
[j
+2];
1626 swapped_data
[j
+2] = temp
;
1628 row_data
= swapped_data
;
1631 pTIFFWriteScanline(This
->parent
->tiff
, (tdata_t
)row_data
, i
+This
->lines_written
, 0);
1634 This
->lines_written
+= lineCount
;
1636 LeaveCriticalSection(&This
->parent
->lock
);
1638 HeapFree(GetProcessHeap(), 0, swapped_data
);
1643 static HRESULT WINAPI
TiffFrameEncode_WriteSource(IWICBitmapFrameEncode
*iface
,
1644 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
1646 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1649 WICPixelFormatGUID guid
;
1653 TRACE("(%p,%p,%p)\n", iface
, pIBitmapSource
, prc
);
1655 if (!This
->initialized
|| !This
->width
|| !This
->height
)
1656 return WINCODEC_ERR_WRONGSTATE
;
1660 hr
= IWICBitmapSource_GetPixelFormat(pIBitmapSource
, &guid
);
1661 if (FAILED(hr
)) return hr
;
1662 hr
= IWICBitmapFrameEncode_SetPixelFormat(iface
, &guid
);
1663 if (FAILED(hr
)) return hr
;
1666 hr
= IWICBitmapSource_GetPixelFormat(pIBitmapSource
, &guid
);
1667 if (FAILED(hr
)) return hr
;
1668 if (memcmp(&guid
, This
->format
->guid
, sizeof(GUID
)) != 0)
1670 /* FIXME: should use WICConvertBitmapSource to convert */
1671 ERR("format %s unsupported\n", debugstr_guid(&guid
));
1675 if (This
->xres
== 0.0 || This
->yres
== 0.0)
1678 hr
= IWICBitmapSource_GetResolution(pIBitmapSource
, &xres
, &yres
);
1679 if (FAILED(hr
)) return hr
;
1680 hr
= IWICBitmapFrameEncode_SetResolution(iface
, xres
, yres
);
1681 if (FAILED(hr
)) return hr
;
1687 hr
= IWICBitmapSource_GetSize(pIBitmapSource
, &width
, &height
);
1688 if (FAILED(hr
)) return hr
;
1696 if (prc
->Width
!= This
->width
) return E_INVALIDARG
;
1698 stride
= (This
->format
->bpp
* This
->width
+ 7)/8;
1700 pixeldata
= HeapAlloc(GetProcessHeap(), 0, stride
* prc
->Height
);
1701 if (!pixeldata
) return E_OUTOFMEMORY
;
1703 hr
= IWICBitmapSource_CopyPixels(pIBitmapSource
, prc
, stride
,
1704 stride
*prc
->Height
, pixeldata
);
1708 hr
= IWICBitmapFrameEncode_WritePixels(iface
, prc
->Height
, stride
,
1709 stride
*prc
->Height
, pixeldata
);
1712 HeapFree(GetProcessHeap(), 0, pixeldata
);
1717 static HRESULT WINAPI
TiffFrameEncode_Commit(IWICBitmapFrameEncode
*iface
)
1719 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1721 TRACE("(%p)\n", iface
);
1723 EnterCriticalSection(&This
->parent
->lock
);
1725 if (!This
->info_written
|| This
->lines_written
!= This
->height
|| This
->committed
)
1727 LeaveCriticalSection(&This
->parent
->lock
);
1728 return WINCODEC_ERR_WRONGSTATE
;
1731 /* libtiff will commit the data when creating a new frame or closing the file */
1733 This
->committed
= TRUE
;
1734 This
->parent
->num_frames_committed
++;
1736 LeaveCriticalSection(&This
->parent
->lock
);
1741 static HRESULT WINAPI
TiffFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
1742 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1744 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
1748 static const IWICBitmapFrameEncodeVtbl TiffFrameEncode_Vtbl
= {
1749 TiffFrameEncode_QueryInterface
,
1750 TiffFrameEncode_AddRef
,
1751 TiffFrameEncode_Release
,
1752 TiffFrameEncode_Initialize
,
1753 TiffFrameEncode_SetSize
,
1754 TiffFrameEncode_SetResolution
,
1755 TiffFrameEncode_SetPixelFormat
,
1756 TiffFrameEncode_SetColorContexts
,
1757 TiffFrameEncode_SetPalette
,
1758 TiffFrameEncode_SetThumbnail
,
1759 TiffFrameEncode_WritePixels
,
1760 TiffFrameEncode_WriteSource
,
1761 TiffFrameEncode_Commit
,
1762 TiffFrameEncode_GetMetadataQueryWriter
1765 static HRESULT WINAPI
TiffEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
1768 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1769 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1771 if (!ppv
) return E_INVALIDARG
;
1773 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1774 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1776 *ppv
= &This
->IWICBitmapEncoder_iface
;
1781 return E_NOINTERFACE
;
1784 IUnknown_AddRef((IUnknown
*)*ppv
);
1788 static ULONG WINAPI
TiffEncoder_AddRef(IWICBitmapEncoder
*iface
)
1790 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1791 ULONG ref
= InterlockedIncrement(&This
->ref
);
1793 TRACE("(%p) refcount=%u\n", iface
, ref
);
1798 static ULONG WINAPI
TiffEncoder_Release(IWICBitmapEncoder
*iface
)
1800 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1801 ULONG ref
= InterlockedDecrement(&This
->ref
);
1803 TRACE("(%p) refcount=%u\n", iface
, ref
);
1807 if (This
->tiff
) pTIFFClose(This
->tiff
);
1808 if (This
->stream
) IStream_Release(This
->stream
);
1809 This
->lock
.DebugInfo
->Spare
[0] = 0;
1810 DeleteCriticalSection(&This
->lock
);
1811 HeapFree(GetProcessHeap(), 0, This
);
1817 static HRESULT WINAPI
TiffEncoder_Initialize(IWICBitmapEncoder
*iface
,
1818 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1820 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1824 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1826 EnterCriticalSection(&This
->lock
);
1828 if (This
->initialized
|| This
->committed
)
1830 hr
= WINCODEC_ERR_WRONGSTATE
;
1834 tiff
= tiff_open_stream(pIStream
, "w");
1843 This
->stream
= pIStream
;
1844 IStream_AddRef(pIStream
);
1845 This
->initialized
= TRUE
;
1848 LeaveCriticalSection(&This
->lock
);
1852 static HRESULT WINAPI
TiffEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1853 GUID
*pguidContainerFormat
)
1855 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
1859 static HRESULT WINAPI
TiffEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1860 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1862 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1866 static HRESULT WINAPI
TiffEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1867 UINT cCount
, IWICColorContext
**ppIColorContext
)
1869 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1873 static HRESULT WINAPI
TiffEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*pIPalette
)
1875 TRACE("(%p,%p)\n", iface
, pIPalette
);
1876 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1879 static HRESULT WINAPI
TiffEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1881 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1882 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1885 static HRESULT WINAPI
TiffEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1887 TRACE("(%p,%p)\n", iface
, pIPreview
);
1888 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1891 static HRESULT WINAPI
TiffEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1892 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1894 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1895 TiffFrameEncode
*result
;
1899 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1901 EnterCriticalSection(&This
->lock
);
1903 if (!This
->initialized
|| This
->committed
)
1905 hr
= WINCODEC_ERR_WRONGSTATE
;
1907 else if (This
->num_frames
!= This
->num_frames_committed
)
1909 FIXME("New frame created before previous frame was committed\n");
1915 PROPBAG2 opts
[2]= {{0}};
1916 opts
[0].pstrName
= (LPOLESTR
)wszTiffCompressionMethod
;
1917 opts
[0].vt
= VT_UI1
;
1918 opts
[0].dwType
= PROPBAG2_TYPE_DATA
;
1920 opts
[1].pstrName
= (LPOLESTR
)wszCompressionQuality
;
1922 opts
[1].dwType
= PROPBAG2_TYPE_DATA
;
1924 hr
= CreatePropertyBag2(opts
, 2, ppIEncoderOptions
);
1931 V_UNION(&v
, bVal
) = WICTiffCompressionDontCare
;
1932 hr
= IPropertyBag2_Write(*ppIEncoderOptions
, 1, opts
, &v
);
1936 IPropertyBag2_Release(*ppIEncoderOptions
);
1937 *ppIEncoderOptions
= NULL
;
1944 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(*result
));
1948 result
->IWICBitmapFrameEncode_iface
.lpVtbl
= &TiffFrameEncode_Vtbl
;
1950 result
->parent
= This
;
1951 result
->initialized
= FALSE
;
1952 result
->info_written
= FALSE
;
1953 result
->committed
= FALSE
;
1954 result
->format
= NULL
;
1959 result
->lines_written
= 0;
1961 IWICBitmapEncoder_AddRef(iface
);
1962 *ppIFrameEncode
= &result
->IWICBitmapFrameEncode_iface
;
1964 if (This
->num_frames
!= 0)
1965 pTIFFWriteDirectory(This
->tiff
);
1974 IPropertyBag2_Release(*ppIEncoderOptions
);
1975 *ppIEncoderOptions
= NULL
;
1979 LeaveCriticalSection(&This
->lock
);
1984 static HRESULT WINAPI
TiffEncoder_Commit(IWICBitmapEncoder
*iface
)
1986 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1988 TRACE("(%p)\n", iface
);
1990 EnterCriticalSection(&This
->lock
);
1992 if (!This
->initialized
|| This
->committed
)
1994 LeaveCriticalSection(&This
->lock
);
1995 return WINCODEC_ERR_WRONGSTATE
;
1998 pTIFFClose(This
->tiff
);
1999 IStream_Release(This
->stream
);
2000 This
->stream
= NULL
;
2003 This
->committed
= TRUE
;
2005 LeaveCriticalSection(&This
->lock
);
2010 static HRESULT WINAPI
TiffEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
2011 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
2013 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
2017 static const IWICBitmapEncoderVtbl TiffEncoder_Vtbl
= {
2018 TiffEncoder_QueryInterface
,
2020 TiffEncoder_Release
,
2021 TiffEncoder_Initialize
,
2022 TiffEncoder_GetContainerFormat
,
2023 TiffEncoder_GetEncoderInfo
,
2024 TiffEncoder_SetColorContexts
,
2025 TiffEncoder_SetPalette
,
2026 TiffEncoder_SetThumbnail
,
2027 TiffEncoder_SetPreview
,
2028 TiffEncoder_CreateNewFrame
,
2030 TiffEncoder_GetMetadataQueryWriter
2033 HRESULT
TiffEncoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
2038 TRACE("(%p,%s,%p)\n", pUnkOuter
, debugstr_guid(iid
), ppv
);
2042 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
2044 if (!load_libtiff())
2046 ERR("Failed writing TIFF because unable to load %s\n",SONAME_LIBTIFF
);
2050 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffEncoder
));
2051 if (!This
) return E_OUTOFMEMORY
;
2053 This
->IWICBitmapEncoder_iface
.lpVtbl
= &TiffEncoder_Vtbl
;
2055 This
->stream
= NULL
;
2056 InitializeCriticalSection(&This
->lock
);
2057 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffEncoder.lock");
2059 This
->initialized
= FALSE
;
2060 This
->num_frames
= 0;
2061 This
->num_frames_committed
= 0;
2062 This
->committed
= FALSE
;
2064 ret
= IWICBitmapEncoder_QueryInterface(&This
->IWICBitmapEncoder_iface
, iid
, ppv
);
2065 IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
2070 #else /* !SONAME_LIBTIFF */
2072 HRESULT
TiffDecoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
2074 ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
2078 HRESULT
TiffEncoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
2080 ERR("Trying to save TIFF picture, but Wine was compiled without TIFF support.\n");