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"
37 #include "wincodecs_private.h"
39 #include "wine/debug.h"
40 #include "wine/library.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
46 static CRITICAL_SECTION init_tiff_cs
;
47 static CRITICAL_SECTION_DEBUG init_tiff_cs_debug
=
50 { &init_tiff_cs_debug
.ProcessLocksList
,
51 &init_tiff_cs_debug
.ProcessLocksList
},
52 0, 0, { (DWORD_PTR
)(__FILE__
": init_tiff_cs") }
54 static CRITICAL_SECTION init_tiff_cs
= { &init_tiff_cs_debug
, -1, 0, 0, 0, 0 };
56 static void *libtiff_handle
;
57 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
58 MAKE_FUNCPTR(TIFFClientOpen
);
59 MAKE_FUNCPTR(TIFFClose
);
60 MAKE_FUNCPTR(TIFFCurrentDirectory
);
61 MAKE_FUNCPTR(TIFFGetField
);
62 MAKE_FUNCPTR(TIFFIsByteSwapped
);
63 MAKE_FUNCPTR(TIFFReadDirectory
);
64 MAKE_FUNCPTR(TIFFReadEncodedStrip
);
65 MAKE_FUNCPTR(TIFFReadEncodedTile
);
66 MAKE_FUNCPTR(TIFFSetDirectory
);
67 MAKE_FUNCPTR(TIFFSetField
);
68 MAKE_FUNCPTR(TIFFWriteDirectory
);
69 MAKE_FUNCPTR(TIFFWriteScanline
);
72 static void *load_libtiff(void)
76 EnterCriticalSection(&init_tiff_cs
);
78 if (!libtiff_handle
&&
79 (libtiff_handle
= wine_dlopen(SONAME_LIBTIFF
, RTLD_NOW
, NULL
, 0)) != NULL
)
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(TIFFCurrentDirectory
);
92 LOAD_FUNCPTR(TIFFGetField
);
93 LOAD_FUNCPTR(TIFFIsByteSwapped
);
94 LOAD_FUNCPTR(TIFFReadDirectory
);
95 LOAD_FUNCPTR(TIFFReadEncodedStrip
);
96 LOAD_FUNCPTR(TIFFReadEncodedTile
);
97 LOAD_FUNCPTR(TIFFSetDirectory
);
98 LOAD_FUNCPTR(TIFFSetField
);
99 LOAD_FUNCPTR(TIFFWriteDirectory
);
100 LOAD_FUNCPTR(TIFFWriteScanline
);
105 result
= libtiff_handle
;
107 LeaveCriticalSection(&init_tiff_cs
);
111 static tsize_t
tiff_stream_read(thandle_t client_data
, tdata_t data
, tsize_t size
)
113 IStream
*stream
= (IStream
*)client_data
;
117 hr
= IStream_Read(stream
, data
, size
, &bytes_read
);
118 if (FAILED(hr
)) bytes_read
= 0;
122 static tsize_t
tiff_stream_write(thandle_t client_data
, tdata_t data
, tsize_t size
)
124 IStream
*stream
= (IStream
*)client_data
;
128 hr
= IStream_Write(stream
, data
, size
, &bytes_written
);
129 if (FAILED(hr
)) bytes_written
= 0;
130 return bytes_written
;
133 static toff_t
tiff_stream_seek(thandle_t client_data
, toff_t offset
, int whence
)
135 IStream
*stream
= (IStream
*)client_data
;
138 ULARGE_INTEGER new_position
;
141 move
.QuadPart
= offset
;
145 origin
= STREAM_SEEK_SET
;
148 origin
= STREAM_SEEK_CUR
;
151 origin
= STREAM_SEEK_END
;
154 ERR("unknown whence value %i\n", whence
);
158 hr
= IStream_Seek(stream
, move
, origin
, &new_position
);
159 if (SUCCEEDED(hr
)) return new_position
.QuadPart
;
163 static int tiff_stream_close(thandle_t client_data
)
165 /* Caller is responsible for releasing the stream object. */
169 static toff_t
tiff_stream_size(thandle_t client_data
)
171 IStream
*stream
= (IStream
*)client_data
;
175 hr
= IStream_Stat(stream
, &statstg
, STATFLAG_NONAME
);
177 if (SUCCEEDED(hr
)) return statstg
.cbSize
.QuadPart
;
181 static int tiff_stream_map(thandle_t client_data
, tdata_t
*addr
, toff_t
*size
)
183 /* Cannot mmap streams */
187 static void tiff_stream_unmap(thandle_t client_data
, tdata_t addr
, toff_t size
)
189 /* No need to ever do this, since we can't map things. */
192 static TIFF
* tiff_open_stream(IStream
*stream
, const char *mode
)
197 IStream_Seek(stream
, zero
, STREAM_SEEK_SET
, NULL
);
199 return pTIFFClientOpen("<IStream object>", mode
, stream
, tiff_stream_read
,
200 tiff_stream_write
, tiff_stream_seek
, tiff_stream_close
,
201 tiff_stream_size
, tiff_stream_map
, tiff_stream_unmap
);
205 IWICBitmapDecoder IWICBitmapDecoder_iface
;
208 CRITICAL_SECTION lock
; /* Must be held when tiff is used or initiailzed is set */
214 const WICPixelFormatGUID
*format
;
221 int invert_grayscale
;
223 UINT tile_width
, tile_height
;
228 UINT resolution_unit
;
233 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
237 tiff_decode_info decode_info
;
238 INT cached_tile_x
, cached_tile_y
;
242 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
;
244 static inline TiffDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
246 return CONTAINING_RECORD(iface
, TiffDecoder
, IWICBitmapDecoder_iface
);
249 static inline TiffFrameDecode
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
251 return CONTAINING_RECORD(iface
, TiffFrameDecode
, IWICBitmapFrameDecode_iface
);
254 static HRESULT
tiff_get_decode_info(TIFF
*tiff
, tiff_decode_info
*decode_info
)
256 uint16 photometric
, bps
, samples
, planar
;
257 uint16 extra_sample_count
, *extra_samples
;
260 decode_info
->indexed
= 0;
261 decode_info
->reverse_bgr
= 0;
262 decode_info
->invert_grayscale
= 0;
263 decode_info
->tiled
= 0;
265 ret
= pTIFFGetField(tiff
, TIFFTAG_PHOTOMETRIC
, &photometric
);
268 WARN("missing PhotometricInterpretation tag\n");
272 ret
= pTIFFGetField(tiff
, TIFFTAG_BITSPERSAMPLE
, &bps
);
274 decode_info
->bps
= bps
;
276 ret
= pTIFFGetField(tiff
, TIFFTAG_SAMPLESPERPIXEL
, &samples
);
277 if (!ret
) samples
= 1;
278 decode_info
->samples
= samples
;
284 ret
= pTIFFGetField(tiff
, TIFFTAG_PLANARCONFIG
, &planar
);
285 if (!ret
) planar
= 1;
288 FIXME("unhandled planar configuration %u\n", planar
);
292 decode_info
->planar
= planar
;
296 case 0: /* WhiteIsZero */
297 decode_info
->invert_grayscale
= 1;
298 case 1: /* BlackIsZero */
301 FIXME("unhandled grayscale sample count %u\n", samples
);
305 decode_info
->bpp
= bps
;
309 decode_info
->format
= &GUID_WICPixelFormatBlackWhite
;
312 decode_info
->format
= &GUID_WICPixelFormat4bppGray
;
315 decode_info
->format
= &GUID_WICPixelFormat8bppGray
;
318 FIXME("unhandled greyscale bit count %u\n", bps
);
323 decode_info
->bpp
= bps
* samples
;
327 ret
= pTIFFGetField(tiff
, TIFFTAG_EXTRASAMPLES
, &extra_sample_count
, &extra_samples
);
330 WARN("Cannot get extra sample type for RGB data, ret=%i count=%i\n", ret
, extra_sample_count
);
334 else if (samples
!= 3)
336 FIXME("unhandled RGB sample count %u\n", samples
);
343 decode_info
->reverse_bgr
= 1;
345 decode_info
->format
= &GUID_WICPixelFormat24bppBGR
;
347 switch(extra_samples
[0])
349 case 0: /* Unspecified data */
350 decode_info
->format
= &GUID_WICPixelFormat32bppBGR
;
352 case 1: /* Associated (pre-multiplied) alpha data */
353 decode_info
->format
= &GUID_WICPixelFormat32bppPBGRA
;
355 case 2: /* Unassociated alpha data */
356 decode_info
->format
= &GUID_WICPixelFormat32bppBGRA
;
359 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
365 decode_info
->format
= &GUID_WICPixelFormat48bppRGB
;
367 switch(extra_samples
[0])
369 case 0: /* Unspecified data */
370 /* decode_info->format = &GUID_WICPixelFormat64bppRGB; */
371 FIXME("64-bit RGB is unsupported\n");
373 case 1: /* Associated (pre-multiplied) alpha data */
374 decode_info
->format
= &GUID_WICPixelFormat64bppPRGBA
;
376 case 2: /* Unassociated alpha data */
377 decode_info
->format
= &GUID_WICPixelFormat64bppRGBA
;
380 FIXME("unhandled extra sample type %i\n", extra_samples
[0]);
385 FIXME("unhandled RGB bit count %u\n", bps
);
389 case 3: /* RGB Palette */
392 FIXME("unhandled indexed sample count %u\n", samples
);
396 decode_info
->indexed
= 1;
397 decode_info
->bpp
= bps
;
401 decode_info
->format
= &GUID_WICPixelFormat4bppIndexed
;
404 decode_info
->format
= &GUID_WICPixelFormat8bppIndexed
;
407 FIXME("unhandled indexed bit count %u\n", bps
);
411 case 4: /* Transparency mask */
416 FIXME("unhandled PhotometricInterpretation %u\n", photometric
);
420 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGEWIDTH
, &decode_info
->width
);
423 WARN("missing image width\n");
427 ret
= pTIFFGetField(tiff
, TIFFTAG_IMAGELENGTH
, &decode_info
->height
);
430 WARN("missing image length\n");
434 if ((ret
= pTIFFGetField(tiff
, TIFFTAG_TILEWIDTH
, &decode_info
->tile_width
)))
436 decode_info
->tiled
= 1;
440 WARN("missing tile width\n");
444 ret
= pTIFFGetField(tiff
, TIFFTAG_TILELENGTH
, &decode_info
->tile_height
);
447 WARN("missing tile height\n");
451 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
452 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
453 decode_info
->tiles_across
= (decode_info
->width
+ decode_info
->tile_width
- 1) / decode_info
->tile_width
;
455 else if ((ret
= pTIFFGetField(tiff
, TIFFTAG_ROWSPERSTRIP
, &decode_info
->tile_height
)))
457 if (decode_info
->tile_height
> decode_info
->height
)
458 decode_info
->tile_height
= decode_info
->height
;
459 decode_info
->tile_width
= decode_info
->width
;
460 decode_info
->tile_stride
= ((decode_info
->bpp
* decode_info
->tile_width
+ 7)/8);
461 decode_info
->tile_size
= decode_info
->tile_height
* decode_info
->tile_stride
;
465 FIXME("missing RowsPerStrip value\n");
469 decode_info
->resolution_unit
= 0;
470 pTIFFGetField(tiff
, TIFFTAG_RESOLUTIONUNIT
, &decode_info
->resolution_unit
);
471 if (decode_info
->resolution_unit
!= 0)
473 ret
= pTIFFGetField(tiff
, TIFFTAG_XRESOLUTION
, &decode_info
->xres
);
476 WARN("missing X resolution\n");
477 decode_info
->resolution_unit
= 0;
480 ret
= pTIFFGetField(tiff
, TIFFTAG_YRESOLUTION
, &decode_info
->yres
);
483 WARN("missing Y resolution\n");
484 decode_info
->resolution_unit
= 0;
491 static HRESULT WINAPI
TiffDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
494 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
495 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
497 if (!ppv
) return E_INVALIDARG
;
499 if (IsEqualIID(&IID_IUnknown
, iid
) || IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
506 return E_NOINTERFACE
;
509 IUnknown_AddRef((IUnknown
*)*ppv
);
513 static ULONG WINAPI
TiffDecoder_AddRef(IWICBitmapDecoder
*iface
)
515 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
516 ULONG ref
= InterlockedIncrement(&This
->ref
);
518 TRACE("(%p) refcount=%u\n", iface
, ref
);
523 static ULONG WINAPI
TiffDecoder_Release(IWICBitmapDecoder
*iface
)
525 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
526 ULONG ref
= InterlockedDecrement(&This
->ref
);
528 TRACE("(%p) refcount=%u\n", iface
, ref
);
532 if (This
->tiff
) pTIFFClose(This
->tiff
);
533 if (This
->stream
) IStream_Release(This
->stream
);
534 This
->lock
.DebugInfo
->Spare
[0] = 0;
535 DeleteCriticalSection(&This
->lock
);
536 HeapFree(GetProcessHeap(), 0, This
);
542 static HRESULT WINAPI
TiffDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
543 DWORD
*pdwCapability
)
545 FIXME("(%p,%p,%p): stub\n", iface
, pIStream
, pdwCapability
);
549 static HRESULT WINAPI
TiffDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
550 WICDecodeOptions cacheOptions
)
552 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
556 TRACE("(%p,%p,%x): stub\n", iface
, pIStream
, cacheOptions
);
558 EnterCriticalSection(&This
->lock
);
560 if (This
->initialized
)
562 hr
= WINCODEC_ERR_WRONGSTATE
;
566 tiff
= tiff_open_stream(pIStream
, "r");
575 This
->stream
= pIStream
;
576 IStream_AddRef(pIStream
);
577 This
->initialized
= TRUE
;
580 LeaveCriticalSection(&This
->lock
);
584 static HRESULT WINAPI
TiffDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
585 GUID
*pguidContainerFormat
)
587 memcpy(pguidContainerFormat
, &GUID_ContainerFormatTiff
, sizeof(GUID
));
591 static HRESULT WINAPI
TiffDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
592 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
594 FIXME("(%p,%p): stub\n", iface
, ppIDecoderInfo
);
598 static HRESULT WINAPI
TiffDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
599 IWICPalette
*pIPalette
)
601 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
605 static HRESULT WINAPI
TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
606 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
608 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
612 static HRESULT WINAPI
TiffDecoder_GetPreview(IWICBitmapDecoder
*iface
,
613 IWICBitmapSource
**ppIBitmapSource
)
615 FIXME("(%p,%p): stub\n", iface
, ppIBitmapSource
);
619 static HRESULT WINAPI
TiffDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
620 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
622 FIXME("(%p,%u,%p,%p)\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
626 static HRESULT WINAPI
TiffDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
627 IWICBitmapSource
**ppIThumbnail
)
629 TRACE("(%p,%p)\n", iface
, ppIThumbnail
);
630 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
633 static HRESULT WINAPI
TiffDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
636 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
640 WARN("(%p) <-- WINCODEC_ERR_WRONGSTATE\n", iface
);
641 return WINCODEC_ERR_WRONGSTATE
;
644 EnterCriticalSection(&This
->lock
);
645 while (pTIFFReadDirectory(This
->tiff
)) { }
646 *pCount
= pTIFFCurrentDirectory(This
->tiff
)+1;
647 LeaveCriticalSection(&This
->lock
);
649 TRACE("(%p) <-- %i\n", iface
, *pCount
);
654 static HRESULT WINAPI
TiffDecoder_GetFrame(IWICBitmapDecoder
*iface
,
655 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
657 TiffDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
658 TiffFrameDecode
*result
;
660 tiff_decode_info decode_info
;
663 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
666 return WINCODEC_ERR_WRONGSTATE
;
668 EnterCriticalSection(&This
->lock
);
669 res
= pTIFFSetDirectory(This
->tiff
, index
);
670 if (!res
) hr
= E_INVALIDARG
;
671 else hr
= tiff_get_decode_info(This
->tiff
, &decode_info
);
672 LeaveCriticalSection(&This
->lock
);
676 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode
));
680 result
->IWICBitmapFrameDecode_iface
.lpVtbl
= &TiffFrameDecode_Vtbl
;
682 result
->parent
= This
;
683 result
->index
= index
;
684 result
->decode_info
= decode_info
;
685 result
->cached_tile_x
= -1;
686 result
->cached_tile
= HeapAlloc(GetProcessHeap(), 0, decode_info
.tile_size
);
688 if (result
->cached_tile
)
689 *ppIBitmapFrame
= (IWICBitmapFrameDecode
*)result
;
693 HeapFree(GetProcessHeap(), 0, result
);
696 else hr
= E_OUTOFMEMORY
;
699 if (FAILED(hr
)) *ppIBitmapFrame
= NULL
;
704 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl
= {
705 TiffDecoder_QueryInterface
,
708 TiffDecoder_QueryCapability
,
709 TiffDecoder_Initialize
,
710 TiffDecoder_GetContainerFormat
,
711 TiffDecoder_GetDecoderInfo
,
712 TiffDecoder_CopyPalette
,
713 TiffDecoder_GetMetadataQueryReader
,
714 TiffDecoder_GetPreview
,
715 TiffDecoder_GetColorContexts
,
716 TiffDecoder_GetThumbnail
,
717 TiffDecoder_GetFrameCount
,
721 static HRESULT WINAPI
TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
724 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
725 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
727 if (!ppv
) return E_INVALIDARG
;
729 if (IsEqualIID(&IID_IUnknown
, iid
) ||
730 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
731 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
738 return E_NOINTERFACE
;
741 IUnknown_AddRef((IUnknown
*)*ppv
);
745 static ULONG WINAPI
TiffFrameDecode_AddRef(IWICBitmapFrameDecode
*iface
)
747 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
748 ULONG ref
= InterlockedIncrement(&This
->ref
);
750 TRACE("(%p) refcount=%u\n", iface
, ref
);
755 static ULONG WINAPI
TiffFrameDecode_Release(IWICBitmapFrameDecode
*iface
)
757 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
758 ULONG ref
= InterlockedDecrement(&This
->ref
);
760 TRACE("(%p) refcount=%u\n", iface
, ref
);
764 HeapFree(GetProcessHeap(), 0, This
->cached_tile
);
765 HeapFree(GetProcessHeap(), 0, This
);
771 static HRESULT WINAPI
TiffFrameDecode_GetSize(IWICBitmapFrameDecode
*iface
,
772 UINT
*puiWidth
, UINT
*puiHeight
)
774 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
776 *puiWidth
= This
->decode_info
.width
;
777 *puiHeight
= This
->decode_info
.height
;
779 TRACE("(%p) <-- %ux%u\n", iface
, *puiWidth
, *puiHeight
);
784 static HRESULT WINAPI
TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
785 WICPixelFormatGUID
*pPixelFormat
)
787 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
789 memcpy(pPixelFormat
, This
->decode_info
.format
, sizeof(GUID
));
791 TRACE("(%p) <-- %s\n", This
, debugstr_guid(This
->decode_info
.format
));
796 static HRESULT WINAPI
TiffFrameDecode_GetResolution(IWICBitmapFrameDecode
*iface
,
797 double *pDpiX
, double *pDpiY
)
799 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
801 switch (This
->decode_info
.resolution_unit
)
804 FIXME("unknown resolution unit %i\n", This
->decode_info
.resolution_unit
);
806 case 0: /* Not set */
807 *pDpiX
= *pDpiY
= 96.0;
809 case 1: /* Relative measurements */
811 *pDpiY
= 96.0 * This
->decode_info
.yres
/ This
->decode_info
.xres
;
814 *pDpiX
= This
->decode_info
.xres
;
815 *pDpiY
= This
->decode_info
.yres
;
817 case 3: /* Centimeter */
818 *pDpiX
= This
->decode_info
.xres
/ 2.54;
819 *pDpiY
= This
->decode_info
.yres
/ 2.54;
823 TRACE("(%p) <-- %f,%f unit=%i\n", iface
, *pDpiX
, *pDpiY
, This
->decode_info
.resolution_unit
);
828 static HRESULT WINAPI
TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode
*iface
,
829 IWICPalette
*pIPalette
)
831 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
832 uint16
*red
, *green
, *blue
;
833 WICColor colors
[256];
834 int color_count
, ret
, i
;
836 TRACE("(%p,%p)\n", iface
, pIPalette
);
838 color_count
= 1<<This
->decode_info
.bps
;
840 EnterCriticalSection(&This
->parent
->lock
);
841 ret
= pTIFFGetField(This
->parent
->tiff
, TIFFTAG_COLORMAP
, &red
, &green
, &blue
);
842 LeaveCriticalSection(&This
->parent
->lock
);
846 WARN("Couldn't read color map\n");
850 for (i
=0; i
<color_count
; i
++)
852 colors
[i
] = 0xff000000 |
853 ((red
[i
]<<8) & 0xff0000) |
854 (green
[i
] & 0xff00) |
855 ((blue
[i
]>>8) & 0xff);
858 return IWICPalette_InitializeCustom(pIPalette
, colors
, color_count
);
861 static HRESULT
TiffFrameDecode_ReadTile(TiffFrameDecode
*This
, UINT tile_x
, UINT tile_y
)
867 swap_bytes
= pTIFFIsByteSwapped(This
->parent
->tiff
);
869 ret
= pTIFFSetDirectory(This
->parent
->tiff
, This
->index
);
876 if (This
->decode_info
.tiled
)
878 ret
= pTIFFReadEncodedTile(This
->parent
->tiff
, tile_x
+ tile_y
* This
->decode_info
.tiles_across
, This
->cached_tile
, This
->decode_info
.tile_size
);
882 ret
= pTIFFReadEncodedStrip(This
->parent
->tiff
, tile_y
, This
->cached_tile
, This
->decode_info
.tile_size
);
889 if (hr
== S_OK
&& This
->decode_info
.reverse_bgr
)
891 if (This
->decode_info
.bps
== 8)
893 UINT sample_count
= This
->decode_info
.samples
;
895 reverse_bgr8(sample_count
, This
->cached_tile
, This
->decode_info
.tile_width
,
896 This
->decode_info
.tile_height
, This
->decode_info
.tile_width
* sample_count
);
900 if (hr
== S_OK
&& swap_bytes
&& This
->decode_info
.bps
> 8)
902 UINT row
, i
, samples_per_row
;
905 samples_per_row
= This
->decode_info
.tile_width
* This
->decode_info
.samples
;
907 switch(This
->decode_info
.bps
)
910 for (row
=0; row
<This
->decode_info
.tile_height
; row
++)
912 sample
= This
->cached_tile
+ row
* This
->decode_info
.tile_stride
;
913 for (i
=0; i
<samples_per_row
; i
++)
916 sample
[1] = sample
[0];
923 ERR("unhandled bps for byte swap %u\n", This
->decode_info
.bps
);
928 if (hr
== S_OK
&& This
->decode_info
.invert_grayscale
)
932 if (This
->decode_info
.samples
!= 1)
934 ERR("cannot invert grayscale image with %u samples\n", This
->decode_info
.samples
);
938 end
= This
->cached_tile
+This
->decode_info
.tile_size
;
940 for (byte
= This
->cached_tile
; byte
!= end
; byte
++)
946 This
->cached_tile_x
= tile_x
;
947 This
->cached_tile_y
= tile_y
;
953 static HRESULT WINAPI
TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode
*iface
,
954 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
956 TiffFrameDecode
*This
= impl_from_IWICBitmapFrameDecode(iface
);
957 UINT min_tile_x
, max_tile_x
, min_tile_y
, max_tile_y
;
965 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
971 rect
.Width
= This
->decode_info
.width
;
972 rect
.Height
= This
->decode_info
.height
;
977 if (prc
->X
< 0 || prc
->Y
< 0 || prc
->X
+prc
->Width
> This
->decode_info
.width
||
978 prc
->Y
+prc
->Height
> This
->decode_info
.height
)
982 bytesperrow
= ((This
->decode_info
.bpp
* prc
->Width
)+7)/8;
984 if (cbStride
< bytesperrow
)
987 if ((cbStride
* prc
->Height
) > cbBufferSize
)
990 min_tile_x
= prc
->X
/ This
->decode_info
.tile_width
;
991 min_tile_y
= prc
->Y
/ This
->decode_info
.tile_height
;
992 max_tile_x
= (prc
->X
+prc
->Width
-1) / This
->decode_info
.tile_width
;
993 max_tile_y
= (prc
->Y
+prc
->Height
-1) / This
->decode_info
.tile_height
;
995 EnterCriticalSection(&This
->parent
->lock
);
997 for (tile_x
=min_tile_x
; tile_x
<= max_tile_x
; tile_x
++)
999 for (tile_y
=min_tile_y
; tile_y
<= max_tile_y
; tile_y
++)
1001 if (tile_x
!= This
->cached_tile_x
|| tile_y
!= This
->cached_tile_y
)
1003 hr
= TiffFrameDecode_ReadTile(This
, tile_x
, tile_y
);
1008 if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1011 rc
.X
= prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1013 if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1016 rc
.Y
= prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1018 if (prc
->X
+prc
->Width
> (tile_x
+1) * This
->decode_info
.tile_width
)
1019 rc
.Width
= This
->decode_info
.tile_width
- rc
.X
;
1020 else if (prc
->X
< tile_x
* This
->decode_info
.tile_width
)
1021 rc
.Width
= prc
->Width
+ prc
->X
- tile_x
* This
->decode_info
.tile_width
;
1023 rc
.Width
= prc
->Width
;
1025 if (prc
->Y
+prc
->Height
> (tile_y
+1) * This
->decode_info
.tile_height
)
1026 rc
.Height
= This
->decode_info
.tile_height
- rc
.Y
;
1027 else if (prc
->Y
< tile_y
* This
->decode_info
.tile_height
)
1028 rc
.Height
= prc
->Height
+ prc
->Y
- tile_y
* This
->decode_info
.tile_height
;
1030 rc
.Height
= prc
->Height
;
1032 dst_tilepos
= pbBuffer
+ (cbStride
* ((rc
.Y
+ tile_y
* This
->decode_info
.tile_height
) - prc
->Y
)) +
1033 ((This
->decode_info
.bpp
* ((rc
.X
+ tile_x
* This
->decode_info
.tile_width
) - prc
->X
) + 7) / 8);
1035 hr
= copy_pixels(This
->decode_info
.bpp
, This
->cached_tile
,
1036 This
->decode_info
.tile_width
, This
->decode_info
.tile_height
, This
->decode_info
.tile_stride
,
1037 &rc
, cbStride
, cbBufferSize
, dst_tilepos
);
1042 LeaveCriticalSection(&This
->parent
->lock
);
1043 TRACE("<-- 0x%x\n", hr
);
1049 LeaveCriticalSection(&This
->parent
->lock
);
1054 static HRESULT WINAPI
TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
1055 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
1057 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
1061 static HRESULT WINAPI
TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode
*iface
,
1062 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
1064 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
1068 static HRESULT WINAPI
TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode
*iface
,
1069 IWICBitmapSource
**ppIThumbnail
)
1071 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
1075 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl
= {
1076 TiffFrameDecode_QueryInterface
,
1077 TiffFrameDecode_AddRef
,
1078 TiffFrameDecode_Release
,
1079 TiffFrameDecode_GetSize
,
1080 TiffFrameDecode_GetPixelFormat
,
1081 TiffFrameDecode_GetResolution
,
1082 TiffFrameDecode_CopyPalette
,
1083 TiffFrameDecode_CopyPixels
,
1084 TiffFrameDecode_GetMetadataQueryReader
,
1085 TiffFrameDecode_GetColorContexts
,
1086 TiffFrameDecode_GetThumbnail
1089 HRESULT
TiffDecoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1094 TRACE("(%p,%s,%p)\n", pUnkOuter
, debugstr_guid(iid
), ppv
);
1098 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
1100 if (!load_libtiff())
1102 ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF
);
1106 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder
));
1107 if (!This
) return E_OUTOFMEMORY
;
1109 This
->IWICBitmapDecoder_iface
.lpVtbl
= &TiffDecoder_Vtbl
;
1111 This
->stream
= NULL
;
1112 InitializeCriticalSection(&This
->lock
);
1113 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffDecoder.lock");
1115 This
->initialized
= FALSE
;
1117 ret
= IUnknown_QueryInterface((IUnknown
*)This
, iid
, ppv
);
1118 IUnknown_Release((IUnknown
*)This
);
1123 struct tiff_encode_format
{
1124 const WICPixelFormatGUID
*guid
;
1130 int extra_sample_type
;
1134 static const struct tiff_encode_format formats
[] = {
1135 {&GUID_WICPixelFormat24bppBGR
, 2, 8, 3, 24, 0, 0, 1},
1136 {&GUID_WICPixelFormatBlackWhite
, 1, 1, 1, 1, 0, 0, 0},
1137 {&GUID_WICPixelFormat4bppGray
, 1, 4, 1, 4, 0, 0, 0},
1138 {&GUID_WICPixelFormat8bppGray
, 1, 8, 1, 8, 0, 0, 0},
1139 {&GUID_WICPixelFormat32bppBGRA
, 2, 8, 4, 32, 1, 2, 1},
1140 {&GUID_WICPixelFormat32bppPBGRA
, 2, 8, 4, 32, 1, 1, 1},
1141 {&GUID_WICPixelFormat48bppRGB
, 2, 16, 3, 48, 0, 0, 0},
1142 {&GUID_WICPixelFormat64bppRGBA
, 2, 16, 4, 64, 1, 2, 0},
1143 {&GUID_WICPixelFormat64bppPRGBA
, 2, 16, 4, 64, 1, 1, 0},
1147 typedef struct TiffEncoder
{
1148 IWICBitmapEncoder IWICBitmapEncoder_iface
;
1151 CRITICAL_SECTION lock
; /* Must be held when tiff is used or fields below are set */
1155 ULONG num_frames_committed
;
1158 static inline TiffEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
1160 return CONTAINING_RECORD(iface
, TiffEncoder
, IWICBitmapEncoder_iface
);
1163 typedef struct TiffFrameEncode
{
1164 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
1166 TiffEncoder
*parent
;
1167 /* fields below are protected by parent->lock */
1170 const struct tiff_encode_format
*format
;
1176 static inline TiffFrameEncode
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
1178 return CONTAINING_RECORD(iface
, TiffFrameEncode
, IWICBitmapFrameEncode_iface
);
1181 static HRESULT WINAPI
TiffFrameEncode_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
1184 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1185 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1187 if (!ppv
) return E_INVALIDARG
;
1189 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1190 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
1192 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
1197 return E_NOINTERFACE
;
1200 IUnknown_AddRef((IUnknown
*)*ppv
);
1204 static ULONG WINAPI
TiffFrameEncode_AddRef(IWICBitmapFrameEncode
*iface
)
1206 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1207 ULONG ref
= InterlockedIncrement(&This
->ref
);
1209 TRACE("(%p) refcount=%u\n", iface
, ref
);
1214 static ULONG WINAPI
TiffFrameEncode_Release(IWICBitmapFrameEncode
*iface
)
1216 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1217 ULONG ref
= InterlockedDecrement(&This
->ref
);
1219 TRACE("(%p) refcount=%u\n", iface
, ref
);
1223 IWICBitmapEncoder_Release(&This
->parent
->IWICBitmapEncoder_iface
);
1224 HeapFree(GetProcessHeap(), 0, This
);
1230 static HRESULT WINAPI
TiffFrameEncode_Initialize(IWICBitmapFrameEncode
*iface
,
1231 IPropertyBag2
*pIEncoderOptions
)
1233 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1234 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
1236 EnterCriticalSection(&This
->parent
->lock
);
1238 if (This
->initialized
)
1240 LeaveCriticalSection(&This
->parent
->lock
);
1241 return WINCODEC_ERR_WRONGSTATE
;
1244 This
->initialized
= TRUE
;
1246 LeaveCriticalSection(&This
->parent
->lock
);
1251 static HRESULT WINAPI
TiffFrameEncode_SetSize(IWICBitmapFrameEncode
*iface
,
1252 UINT uiWidth
, UINT uiHeight
)
1254 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1255 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
1257 EnterCriticalSection(&This
->parent
->lock
);
1259 if (!This
->initialized
|| This
->info_written
)
1261 LeaveCriticalSection(&This
->parent
->lock
);
1262 return WINCODEC_ERR_WRONGSTATE
;
1265 This
->width
= uiWidth
;
1266 This
->height
= uiHeight
;
1268 LeaveCriticalSection(&This
->parent
->lock
);
1273 static HRESULT WINAPI
TiffFrameEncode_SetResolution(IWICBitmapFrameEncode
*iface
,
1274 double dpiX
, double dpiY
)
1276 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1277 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
1279 EnterCriticalSection(&This
->parent
->lock
);
1281 if (!This
->initialized
|| This
->info_written
)
1283 LeaveCriticalSection(&This
->parent
->lock
);
1284 return WINCODEC_ERR_WRONGSTATE
;
1290 LeaveCriticalSection(&This
->parent
->lock
);
1295 static HRESULT WINAPI
TiffFrameEncode_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
1296 WICPixelFormatGUID
*pPixelFormat
)
1298 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1301 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
1303 EnterCriticalSection(&This
->parent
->lock
);
1305 if (!This
->initialized
|| This
->info_written
)
1307 LeaveCriticalSection(&This
->parent
->lock
);
1308 return WINCODEC_ERR_WRONGSTATE
;
1311 for (i
=0; formats
[i
].guid
; i
++)
1313 if (memcmp(formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
1317 if (!formats
[i
].guid
) i
= 0;
1319 This
->format
= &formats
[i
];
1320 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
1322 LeaveCriticalSection(&This
->parent
->lock
);
1327 static HRESULT WINAPI
TiffFrameEncode_SetColorContexts(IWICBitmapFrameEncode
*iface
,
1328 UINT cCount
, IWICColorContext
**ppIColorContext
)
1330 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1334 static HRESULT WINAPI
TiffFrameEncode_SetPalette(IWICBitmapFrameEncode
*iface
,
1335 IWICPalette
*pIPalette
)
1337 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
1338 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1341 static HRESULT WINAPI
TiffFrameEncode_SetThumbnail(IWICBitmapFrameEncode
*iface
,
1342 IWICBitmapSource
*pIThumbnail
)
1344 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
1345 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1348 static HRESULT WINAPI
TiffFrameEncode_WritePixels(IWICBitmapFrameEncode
*iface
,
1349 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
1351 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1352 BYTE
*row_data
, *swapped_data
= NULL
;
1353 UINT i
, j
, line_size
;
1355 TRACE("(%p,%u,%u,%u,%p)\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
1357 EnterCriticalSection(&This
->parent
->lock
);
1359 if (!This
->initialized
|| !This
->width
|| !This
->height
|| !This
->format
)
1361 LeaveCriticalSection(&This
->parent
->lock
);
1362 return WINCODEC_ERR_WRONGSTATE
;
1365 if (lineCount
== 0 || lineCount
+ This
->lines_written
> This
->height
)
1367 LeaveCriticalSection(&This
->parent
->lock
);
1368 return E_INVALIDARG
;
1371 line_size
= ((This
->width
* This
->format
->bpp
)+7)/8;
1373 if (This
->format
->reverse_bgr
)
1375 swapped_data
= HeapAlloc(GetProcessHeap(), 0, line_size
);
1378 LeaveCriticalSection(&This
->parent
->lock
);
1379 return E_OUTOFMEMORY
;
1383 if (!This
->info_written
)
1385 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PHOTOMETRIC
, (uint16
)This
->format
->photometric
);
1386 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_PLANARCONFIG
, (uint16
)1);
1387 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_BITSPERSAMPLE
, (uint16
)This
->format
->bps
);
1388 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_SAMPLESPERPIXEL
, (uint16
)This
->format
->samples
);
1390 if (This
->format
->extra_sample
)
1392 uint16 extra_samples
;
1393 extra_samples
= This
->format
->extra_sample_type
;
1395 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_EXTRASAMPLES
, (uint16
)1, &extra_samples
);
1398 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGEWIDTH
, (uint32
)This
->width
);
1399 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_IMAGELENGTH
, (uint32
)This
->height
);
1401 if (This
->xres
!= 0.0 && This
->yres
!= 0.0)
1403 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_RESOLUTIONUNIT
, (uint16
)2); /* Inch */
1404 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_XRESOLUTION
, (float)This
->xres
);
1405 pTIFFSetField(This
->parent
->tiff
, TIFFTAG_YRESOLUTION
, (float)This
->yres
);
1408 This
->info_written
= TRUE
;
1411 for (i
=0; i
<lineCount
; i
++)
1413 row_data
= pbPixels
+ i
* cbStride
;
1415 if (This
->format
->reverse_bgr
&& This
->format
->bps
== 8)
1417 memcpy(swapped_data
, row_data
, line_size
);
1418 for (j
=0; j
<line_size
; j
+= This
->format
->samples
)
1421 temp
= swapped_data
[j
];
1422 swapped_data
[j
] = swapped_data
[j
+2];
1423 swapped_data
[j
+2] = temp
;
1425 row_data
= swapped_data
;
1428 pTIFFWriteScanline(This
->parent
->tiff
, (tdata_t
)row_data
, i
+This
->lines_written
, 0);
1431 This
->lines_written
+= lineCount
;
1433 LeaveCriticalSection(&This
->parent
->lock
);
1435 HeapFree(GetProcessHeap(), 0, swapped_data
);
1440 static HRESULT WINAPI
TiffFrameEncode_WriteSource(IWICBitmapFrameEncode
*iface
,
1441 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
1443 TiffFrameEncode
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1446 WICPixelFormatGUID guid
;
1450 TRACE("(%p,%p,%p)\n", iface
, pIBitmapSource
, prc
);
1452 if (!This
->initialized
|| !This
->width
|| !This
->height
)
1453 return WINCODEC_ERR_WRONGSTATE
;
1457 hr
= IWICBitmapSource_GetPixelFormat(pIBitmapSource
, &guid
);
1458 if (FAILED(hr
)) return hr
;
1459 hr
= IWICBitmapFrameEncode_SetPixelFormat(iface
, &guid
);
1460 if (FAILED(hr
)) return hr
;
1463 hr
= IWICBitmapSource_GetPixelFormat(pIBitmapSource
, &guid
);
1464 if (FAILED(hr
)) return hr
;
1465 if (memcmp(&guid
, This
->format
->guid
, sizeof(GUID
)) != 0)
1467 /* FIXME: should use WICConvertBitmapSource to convert */
1468 ERR("format %s unsupported\n", debugstr_guid(&guid
));
1472 if (This
->xres
== 0.0 || This
->yres
== 0.0)
1475 hr
= IWICBitmapSource_GetResolution(pIBitmapSource
, &xres
, &yres
);
1476 if (FAILED(hr
)) return hr
;
1477 hr
= IWICBitmapFrameEncode_SetResolution(iface
, xres
, yres
);
1478 if (FAILED(hr
)) return hr
;
1484 hr
= IWICBitmapSource_GetSize(pIBitmapSource
, &width
, &height
);
1485 if (FAILED(hr
)) return hr
;
1493 if (prc
->Width
!= This
->width
) return E_INVALIDARG
;
1495 stride
= (This
->format
->bpp
* This
->width
+ 7)/8;
1497 pixeldata
= HeapAlloc(GetProcessHeap(), 0, stride
* prc
->Height
);
1498 if (!pixeldata
) return E_OUTOFMEMORY
;
1500 hr
= IWICBitmapSource_CopyPixels(pIBitmapSource
, prc
, stride
,
1501 stride
*prc
->Height
, pixeldata
);
1505 hr
= IWICBitmapFrameEncode_WritePixels(iface
, prc
->Height
, stride
,
1506 stride
*prc
->Height
, pixeldata
);
1509 HeapFree(GetProcessHeap(), 0, pixeldata
);
1514 static HRESULT WINAPI
TiffFrameEncode_Commit(IWICBitmapFrameEncode
*iface
)
1516 FIXME("(%p): stub\n", iface
);
1520 static HRESULT WINAPI
TiffFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
1521 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1523 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
1527 static const IWICBitmapFrameEncodeVtbl TiffFrameEncode_Vtbl
= {
1528 TiffFrameEncode_QueryInterface
,
1529 TiffFrameEncode_AddRef
,
1530 TiffFrameEncode_Release
,
1531 TiffFrameEncode_Initialize
,
1532 TiffFrameEncode_SetSize
,
1533 TiffFrameEncode_SetResolution
,
1534 TiffFrameEncode_SetPixelFormat
,
1535 TiffFrameEncode_SetColorContexts
,
1536 TiffFrameEncode_SetPalette
,
1537 TiffFrameEncode_SetThumbnail
,
1538 TiffFrameEncode_WritePixels
,
1539 TiffFrameEncode_WriteSource
,
1540 TiffFrameEncode_Commit
,
1541 TiffFrameEncode_GetMetadataQueryWriter
1544 static HRESULT WINAPI
TiffEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
1547 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1548 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1550 if (!ppv
) return E_INVALIDARG
;
1552 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1553 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1560 return E_NOINTERFACE
;
1563 IUnknown_AddRef((IUnknown
*)*ppv
);
1567 static ULONG WINAPI
TiffEncoder_AddRef(IWICBitmapEncoder
*iface
)
1569 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1570 ULONG ref
= InterlockedIncrement(&This
->ref
);
1572 TRACE("(%p) refcount=%u\n", iface
, ref
);
1577 static ULONG WINAPI
TiffEncoder_Release(IWICBitmapEncoder
*iface
)
1579 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1580 ULONG ref
= InterlockedDecrement(&This
->ref
);
1582 TRACE("(%p) refcount=%u\n", iface
, ref
);
1586 if (This
->tiff
) pTIFFClose(This
->tiff
);
1587 if (This
->stream
) IStream_Release(This
->stream
);
1588 This
->lock
.DebugInfo
->Spare
[0] = 0;
1589 DeleteCriticalSection(&This
->lock
);
1590 HeapFree(GetProcessHeap(), 0, This
);
1596 static HRESULT WINAPI
TiffEncoder_Initialize(IWICBitmapEncoder
*iface
,
1597 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1599 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1603 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1605 EnterCriticalSection(&This
->lock
);
1607 if (This
->initialized
)
1609 hr
= WINCODEC_ERR_WRONGSTATE
;
1613 tiff
= tiff_open_stream(pIStream
, "w");
1622 This
->stream
= pIStream
;
1623 IStream_AddRef(pIStream
);
1624 This
->initialized
= TRUE
;
1627 LeaveCriticalSection(&This
->lock
);
1631 static HRESULT WINAPI
TiffEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1632 GUID
*pguidContainerFormat
)
1634 FIXME("(%p,%s): stub\n", iface
, debugstr_guid(pguidContainerFormat
));
1638 static HRESULT WINAPI
TiffEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1639 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1641 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1645 static HRESULT WINAPI
TiffEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1646 UINT cCount
, IWICColorContext
**ppIColorContext
)
1648 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1652 static HRESULT WINAPI
TiffEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*pIPalette
)
1654 TRACE("(%p,%p)\n", iface
, pIPalette
);
1655 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1658 static HRESULT WINAPI
TiffEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1660 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1661 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1664 static HRESULT WINAPI
TiffEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1666 TRACE("(%p,%p)\n", iface
, pIPreview
);
1667 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1670 static HRESULT WINAPI
TiffEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1671 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1673 TiffEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1674 TiffFrameEncode
*result
;
1678 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1680 EnterCriticalSection(&This
->lock
);
1682 if (This
->num_frames
!= This
->num_frames_committed
)
1684 FIXME("New frame created before previous frame was committed\n");
1690 hr
= CreatePropertyBag2(ppIEncoderOptions
);
1695 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(*result
));
1699 result
->IWICBitmapFrameEncode_iface
.lpVtbl
= &TiffFrameEncode_Vtbl
;
1701 result
->parent
= This
;
1702 result
->initialized
= FALSE
;
1703 result
->info_written
= FALSE
;
1704 result
->format
= NULL
;
1709 result
->lines_written
= 0;
1711 IWICBitmapEncoder_AddRef(iface
);
1712 *ppIFrameEncode
= &result
->IWICBitmapFrameEncode_iface
;
1714 if (This
->num_frames
!= 0)
1715 pTIFFWriteDirectory(This
->tiff
);
1724 IPropertyBag2_Release(*ppIEncoderOptions
);
1725 *ppIEncoderOptions
= NULL
;
1729 LeaveCriticalSection(&This
->lock
);
1734 static HRESULT WINAPI
TiffEncoder_Commit(IWICBitmapEncoder
*iface
)
1736 FIXME("(%p): stub\n", iface
);
1740 static HRESULT WINAPI
TiffEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
1741 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1743 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
1747 static const IWICBitmapEncoderVtbl TiffEncoder_Vtbl
= {
1748 TiffEncoder_QueryInterface
,
1750 TiffEncoder_Release
,
1751 TiffEncoder_Initialize
,
1752 TiffEncoder_GetContainerFormat
,
1753 TiffEncoder_GetEncoderInfo
,
1754 TiffEncoder_SetColorContexts
,
1755 TiffEncoder_SetPalette
,
1756 TiffEncoder_SetThumbnail
,
1757 TiffEncoder_SetPreview
,
1758 TiffEncoder_CreateNewFrame
,
1760 TiffEncoder_GetMetadataQueryWriter
1763 HRESULT
TiffEncoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1768 TRACE("(%p,%s,%p)\n", pUnkOuter
, debugstr_guid(iid
), ppv
);
1772 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
1774 if (!load_libtiff())
1776 ERR("Failed writing TIFF because unable to load %s\n",SONAME_LIBTIFF
);
1780 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(TiffEncoder
));
1781 if (!This
) return E_OUTOFMEMORY
;
1783 This
->IWICBitmapEncoder_iface
.lpVtbl
= &TiffEncoder_Vtbl
;
1785 This
->stream
= NULL
;
1786 InitializeCriticalSection(&This
->lock
);
1787 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": TiffEncoder.lock");
1789 This
->initialized
= FALSE
;
1790 This
->num_frames
= 0;
1791 This
->num_frames_committed
= 0;
1793 ret
= IUnknown_QueryInterface((IUnknown
*)This
, iid
, ppv
);
1794 IUnknown_Release((IUnknown
*)This
);
1799 #else /* !SONAME_LIBTIFF */
1801 HRESULT
TiffDecoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1803 ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
1807 HRESULT
TiffEncoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1809 ERR("Trying to save TIFF picture, but Wine was compiled without TIFF support.\n");