1 /*
2 * Copyright 2010 Vincent Povirk for CodeWeavers
3 *
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.
8 *
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.
13 *
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
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21
22 #include <stdarg.h>
23 #ifdef HAVE_UNISTD_H
24 #include <unistd.h>
25 #endif
26 #ifdef HAVE_TIFFIO_H
27 #include <tiffio.h>
28 #endif
29
30 #define COBJMACROS
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "objbase.h"
35 #include "wincodec.h"
36
37 #include "wincodecs_private.h"
38
39 #include "wine/debug.h"
40 #include "wine/library.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
43
44 #ifdef SONAME_LIBTIFF
45
46 static CRITICAL_SECTION init_tiff_cs;
47 static CRITICAL_SECTION_DEBUG init_tiff_cs_debug =
48 {
49 0, 0, &init_tiff_cs,
50 { &init_tiff_cs_debug.ProcessLocksList,
51 &init_tiff_cs_debug.ProcessLocksList },
52 0, 0, { (DWORD_PTR)(__FILE__ ": init_tiff_cs") }
53 };
54 static CRITICAL_SECTION init_tiff_cs = { &init_tiff_cs_debug, -1, 0, 0, 0, 0 };
55
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);
70 #undef MAKE_FUNCPTR
71
72 static void *load_libtiff(void)
73 {
74 void *result;
75
76 EnterCriticalSection(&init_tiff_cs);
77
78 if (!libtiff_handle &&
79 (libtiff_handle = wine_dlopen(SONAME_LIBTIFF, RTLD_NOW, NULL, 0)) != NULL)
80 {
81
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); \
87 return NULL; \
88 }
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);
101 #undef LOAD_FUNCPTR
102
103 }
104
105 result = libtiff_handle;
106
107 LeaveCriticalSection(&init_tiff_cs);
108 return result;
109 }
110
111 static tsize_t tiff_stream_read(thandle_t client_data, tdata_t data, tsize_t size)
112 {
113 IStream *stream = (IStream*)client_data;
114 ULONG bytes_read;
115 HRESULT hr;
116
117 hr = IStream_Read(stream, data, size, &bytes_read);
118 if (FAILED(hr)) bytes_read = 0;
119 return bytes_read;
120 }
121
122 static tsize_t tiff_stream_write(thandle_t client_data, tdata_t data, tsize_t size)
123 {
124 IStream *stream = (IStream*)client_data;
125 ULONG bytes_written;
126 HRESULT hr;
127
128 hr = IStream_Write(stream, data, size, &bytes_written);
129 if (FAILED(hr)) bytes_written = 0;
130 return bytes_written;
131 }
132
133 static toff_t tiff_stream_seek(thandle_t client_data, toff_t offset, int whence)
134 {
135 IStream *stream = (IStream*)client_data;
136 LARGE_INTEGER move;
137 DWORD origin;
138 ULARGE_INTEGER new_position;
139 HRESULT hr;
140
141 move.QuadPart = offset;
142 switch (whence)
143 {
144 case SEEK_SET:
145 origin = STREAM_SEEK_SET;
146 break;
147 case SEEK_CUR:
148 origin = STREAM_SEEK_CUR;
149 break;
150 case SEEK_END:
151 origin = STREAM_SEEK_END;
152 break;
153 default:
154 ERR("unknown whence value %i\n", whence);
155 return -1;
156 }
157
158 hr = IStream_Seek(stream, move, origin, &new_position);
159 if (SUCCEEDED(hr)) return new_position.QuadPart;
160 else return -1;
161 }
162
163 static int tiff_stream_close(thandle_t client_data)
164 {
165 /* Caller is responsible for releasing the stream object. */
166 return 0;
167 }
168
169 static toff_t tiff_stream_size(thandle_t client_data)
170 {
171 IStream *stream = (IStream*)client_data;
172 STATSTG statstg;
173 HRESULT hr;
174
175 hr = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
176
177 if (SUCCEEDED(hr)) return statstg.cbSize.QuadPart;
178 else return -1;
179 }
180
181 static int tiff_stream_map(thandle_t client_data, tdata_t *addr, toff_t *size)
182 {
183 /* Cannot mmap streams */
184 return 0;
185 }
186
187 static void tiff_stream_unmap(thandle_t client_data, tdata_t addr, toff_t size)
188 {
189 /* No need to ever do this, since we can't map things. */
190 }
191
192 static TIFF* tiff_open_stream(IStream *stream, const char *mode)
193 {
194 LARGE_INTEGER zero;
195
196 zero.QuadPart = 0;
197 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
198
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);
202 }
203
204 typedef struct {
205 IWICBitmapDecoder IWICBitmapDecoder_iface;
206 LONG ref;
207 IStream *stream;
208 CRITICAL_SECTION lock; /* Must be held when tiff is used or initiailzed is set */
209 TIFF *tiff;
210 BOOL initialized;
211 } TiffDecoder;
212
213 typedef struct {
214 const WICPixelFormatGUID *format;
215 int bps;
216 int samples;
217 int bpp;
218 int planar;
219 int indexed;
220 int reverse_bgr;
221 int invert_grayscale;
222 UINT width, height;
223 UINT tile_width, tile_height;
224 UINT tile_stride;
225 UINT tile_size;
226 int tiled;
227 UINT tiles_across;
228 UINT resolution_unit;
229 float xres, yres;
230 } tiff_decode_info;
231
232 typedef struct {
233 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
234 LONG ref;
235 TiffDecoder *parent;
236 UINT index;
237 tiff_decode_info decode_info;
238 INT cached_tile_x, cached_tile_y;
239 BYTE *cached_tile;
240 } TiffFrameDecode;
241
242 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl;
243
244 static inline TiffDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
245 {
246 return CONTAINING_RECORD(iface, TiffDecoder, IWICBitmapDecoder_iface);
247 }
248
249 static inline TiffFrameDecode *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
250 {
251 return CONTAINING_RECORD(iface, TiffFrameDecode, IWICBitmapFrameDecode_iface);
252 }
253
254 static HRESULT tiff_get_decode_info(TIFF *tiff, tiff_decode_info *decode_info)
255 {
256 uint16 photometric, bps, samples, planar;
257 uint16 extra_sample_count, extra_sample, *extra_samples;
258 int ret;
259
260 decode_info->indexed = 0;
261 decode_info->reverse_bgr = 0;
262 decode_info->invert_grayscale = 0;
263 decode_info->tiled = 0;
264
265 ret = pTIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
266 if (!ret)
267 {
268 WARN("missing PhotometricInterpretation tag\n");
269 return E_FAIL;
270 }
271
272 ret = pTIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bps);
273 if (!ret) bps = 1;
274 decode_info->bps = bps;
275
276 ret = pTIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samples);
277 if (!ret) samples = 1;
278 decode_info->samples = samples;
279
280 if (samples == 1)
281 planar = 1;
282 else
283 {
284 ret = pTIFFGetField(tiff, TIFFTAG_PLANARCONFIG, &planar);
285 if (!ret) planar = 1;
286 if (planar != 1)
287 {
288 FIXME("unhandled planar configuration %u\n", planar);
289 return E_FAIL;
290 }
291 }
292 decode_info->planar = planar;
293
294 switch(photometric)
295 {
296 case 0: /* WhiteIsZero */
297 decode_info->invert_grayscale = 1;
298 /* fall through */
299 case 1: /* BlackIsZero */
300 if (samples != 1)
301 {
302 FIXME("unhandled grayscale sample count %u\n", samples);
303 return E_FAIL;
304 }
305
306 decode_info->bpp = bps;
307 switch (bps)
308 {
309 case 1:
310 decode_info->format = &GUID_WICPixelFormatBlackWhite;
311 break;
312 case 4:
313 decode_info->format = &GUID_WICPixelFormat4bppGray;
314 break;
315 case 8:
316 decode_info->format = &GUID_WICPixelFormat8bppGray;
317 break;
318 default:
319 FIXME("unhandled greyscale bit count %u\n", bps);
320 return E_FAIL;
321 }
322 break;
323 case 2: /* RGB */
324 decode_info->bpp = bps * samples;
325
326 if (samples == 4)
327 {
328 ret = pTIFFGetField(tiff, TIFFTAG_EXTRASAMPLES, &extra_sample_count, &extra_samples);
329 if (!ret)
330 {
331 extra_sample_count = 1;
332 extra_sample = 0;
333 extra_samples = &extra_sample;
334 }
335 }
336 else if (samples != 3)
337 {
338 FIXME("unhandled RGB sample count %u\n", samples);
339 return E_FAIL;
340 }
341
342 switch(bps)
343 {
344 case 8:
345 decode_info->reverse_bgr = 1;
346 if (samples == 3)
347 decode_info->format = &GUID_WICPixelFormat24bppBGR;
348 else
349 switch(extra_samples[0])
350 {
351 case 1: /* Associated (pre-multiplied) alpha data */
352 decode_info->format = &GUID_WICPixelFormat32bppPBGRA;
353 break;
354 case 0: /* Unspecified data */
355 case 2: /* Unassociated alpha data */
356 decode_info->format = &GUID_WICPixelFormat32bppBGRA;
357 break;
358 default:
359 FIXME("unhandled extra sample type %i\n", extra_samples[0]);
360 return E_FAIL;
361 }
362 break;
363 case 16:
364 if (samples == 3)
365 decode_info->format = &GUID_WICPixelFormat48bppRGB;
366 else
367 switch(extra_samples[0])
368 {
369 case 1: /* Associated (pre-multiplied) alpha data */
370 decode_info->format = &GUID_WICPixelFormat64bppPRGBA;
371 break;
372 case 0: /* Unspecified data */
373 case 2: /* Unassociated alpha data */
374 decode_info->format = &GUID_WICPixelFormat64bppRGBA;
375 break;
376 default:
377 FIXME("unhandled extra sample type %i\n", extra_samples[0]);
378 return E_FAIL;
379 }
380 break;
381 default:
382 FIXME("unhandled RGB bit count %u\n", bps);
383 return E_FAIL;
384 }
385 break;
386 case 3: /* RGB Palette */
387 if (samples != 1)
388 {
389 FIXME("unhandled indexed sample count %u\n", samples);
390 return E_FAIL;
391 }
392
393 decode_info->indexed = 1;
394 decode_info->bpp = bps;
395 switch (bps)
396 {
397 case 4:
398 decode_info->format = &GUID_WICPixelFormat4bppIndexed;
399 break;
400 case 8:
401 decode_info->format = &GUID_WICPixelFormat8bppIndexed;
402 break;
403 default:
404 FIXME("unhandled indexed bit count %u\n", bps);
405 return E_FAIL;
406 }
407 break;
408 case 4: /* Transparency mask */
409 case 5: /* CMYK */
410 case 6: /* YCbCr */
411 case 8: /* CIELab */
412 default:
413 FIXME("unhandled PhotometricInterpretation %u\n", photometric);
414 return E_FAIL;
415 }
416
417 ret = pTIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &decode_info->width);
418 if (!ret)
419 {
420 WARN("missing image width\n");
421 return E_FAIL;
422 }
423
424 ret = pTIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &decode_info->height);
425 if (!ret)
426 {
427 WARN("missing image length\n");
428 return E_FAIL;
429 }
430
431 if ((ret = pTIFFGetField(tiff, TIFFTAG_TILEWIDTH, &decode_info->tile_width)))
432 {
433 decode_info->tiled = 1;
434
435 if (!ret)
436 {
437 WARN("missing tile width\n");
438 return E_FAIL;
439 }
440
441 ret = pTIFFGetField(tiff, TIFFTAG_TILELENGTH, &decode_info->tile_height);
442 if (!ret)
443 {
444 WARN("missing tile height\n");
445 return E_FAIL;
446 }
447
448 decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
449 decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
450 decode_info->tiles_across = (decode_info->width + decode_info->tile_width - 1) / decode_info->tile_width;
451 }
452 else if ((ret = pTIFFGetField(tiff, TIFFTAG_ROWSPERSTRIP, &decode_info->tile_height)))
453 {
454 if (decode_info->tile_height > decode_info->height)
455 decode_info->tile_height = decode_info->height;
456 decode_info->tile_width = decode_info->width;
457 decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
458 decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
459 }
460 else
461 {
462 /* Some broken TIFF files have a single strip and lack the RowsPerStrip tag */
463 decode_info->tile_height = decode_info->height;
464 decode_info->tile_width = decode_info->width;
465 decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
466 decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
467 }
468
469 decode_info->resolution_unit = 0;
470 pTIFFGetField(tiff, TIFFTAG_RESOLUTIONUNIT, &decode_info->resolution_unit);
471 if (decode_info->resolution_unit != 0)
472 {
473 ret = pTIFFGetField(tiff, TIFFTAG_XRESOLUTION, &decode_info->xres);
474 if (!ret)
475 {
476 WARN("missing X resolution\n");
477 decode_info->resolution_unit = 0;
478 }
479
480 ret = pTIFFGetField(tiff, TIFFTAG_YRESOLUTION, &decode_info->yres);
481 if (!ret)
482 {
483 WARN("missing Y resolution\n");
484 decode_info->resolution_unit = 0;
485 }
486 }
487
488 return S_OK;
489 }
490
491 static HRESULT WINAPI TiffDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
492 void **ppv)
493 {
494 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
495 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
496
497 if (!ppv) return E_INVALIDARG;
498
499 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
500 {
501 *ppv = This;
502 }
503 else
504 {
505 *ppv = NULL;
506 return E_NOINTERFACE;
507 }
508
509 IUnknown_AddRef((IUnknown*)*ppv);
510 return S_OK;
511 }
512
513 static ULONG WINAPI TiffDecoder_AddRef(IWICBitmapDecoder *iface)
514 {
515 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
516 ULONG ref = InterlockedIncrement(&This->ref);
517
518 TRACE("(%p) refcount=%u\n", iface, ref);
519
520 return ref;
521 }
522
523 static ULONG WINAPI TiffDecoder_Release(IWICBitmapDecoder *iface)
524 {
525 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
526 ULONG ref = InterlockedDecrement(&This->ref);
527
528 TRACE("(%p) refcount=%u\n", iface, ref);
529
530 if (ref == 0)
531 {
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);
537 }
538
539 return ref;
540 }
541
542 static HRESULT WINAPI TiffDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
543 DWORD *pdwCapability)
544 {
545 FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
546 return E_NOTIMPL;
547 }
548
549 static HRESULT WINAPI TiffDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
550 WICDecodeOptions cacheOptions)
551 {
552 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
553 TIFF *tiff;
554 HRESULT hr=S_OK;
555
556 TRACE("(%p,%p,%x): stub\n", iface, pIStream, cacheOptions);
557
558 EnterCriticalSection(&This->lock);
559
560 if (This->initialized)
561 {
562 hr = WINCODEC_ERR_WRONGSTATE;
563 goto exit;
564 }
565
566 tiff = tiff_open_stream(pIStream, "r");
567
568 if (!tiff)
569 {
570 hr = E_FAIL;
571 goto exit;
572 }
573
574 This->tiff = tiff;
575 This->stream = pIStream;
576 IStream_AddRef(pIStream);
577 This->initialized = TRUE;
578
579 exit:
580 LeaveCriticalSection(&This->lock);
581 return hr;
582 }
583
584 static HRESULT WINAPI TiffDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
585 GUID *pguidContainerFormat)
586 {
587 memcpy(pguidContainerFormat, &GUID_ContainerFormatTiff, sizeof(GUID));
588 return S_OK;
589 }
590
591 static HRESULT WINAPI TiffDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
592 IWICBitmapDecoderInfo **ppIDecoderInfo)
593 {
594 HRESULT hr;
595 IWICComponentInfo *compinfo;
596
597 TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
598
599 hr = CreateComponentInfo(&CLSID_WICTiffDecoder, &compinfo);
600 if (FAILED(hr)) return hr;
601
602 hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
603 (void**)ppIDecoderInfo);
604
605 IWICComponentInfo_Release(compinfo);
606
607 return hr;
608 }
609
610 static HRESULT WINAPI TiffDecoder_CopyPalette(IWICBitmapDecoder *iface,
611 IWICPalette *pIPalette)
612 {
613 FIXME("(%p,%p): stub\n", iface, pIPalette);
614 return E_NOTIMPL;
615 }
616
617 static HRESULT WINAPI TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
618 IWICMetadataQueryReader **ppIMetadataQueryReader)
619 {
620 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
621 return E_NOTIMPL;
622 }
623
624 static HRESULT WINAPI TiffDecoder_GetPreview(IWICBitmapDecoder *iface,
625 IWICBitmapSource **ppIBitmapSource)
626 {
627 FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
628 return E_NOTIMPL;
629 }
630
631 static HRESULT WINAPI TiffDecoder_GetColorContexts(IWICBitmapDecoder *iface,
632 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
633 {
634 FIXME("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
635 return E_NOTIMPL;
636 }
637
638 static HRESULT WINAPI TiffDecoder_GetThumbnail(IWICBitmapDecoder *iface,
639 IWICBitmapSource **ppIThumbnail)
640 {
641 TRACE("(%p,%p)\n", iface, ppIThumbnail);
642 return WINCODEC_ERR_CODECNOTHUMBNAIL;
643 }
644
645 static HRESULT WINAPI TiffDecoder_GetFrameCount(IWICBitmapDecoder *iface,
646 UINT *pCount)
647 {
648 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
649
650 if (!This->tiff)
651 {
652 WARN("(%p) <-- WINCODEC_ERR_WRONGSTATE\n", iface);
653 return WINCODEC_ERR_WRONGSTATE;
654 }
655
656 EnterCriticalSection(&This->lock);
657 while (pTIFFReadDirectory(This->tiff)) { }
658 *pCount = pTIFFCurrentDirectory(This->tiff)+1;
659 LeaveCriticalSection(&This->lock);
660
661 TRACE("(%p) <-- %i\n", iface, *pCount);
662
663 return S_OK;
664 }
665
666 static HRESULT WINAPI TiffDecoder_GetFrame(IWICBitmapDecoder *iface,
667 UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
668 {
669 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
670 TiffFrameDecode *result;
671 int res;
672 tiff_decode_info decode_info;
673 HRESULT hr;
674
675 TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
676
677 if (!This->tiff)
678 return WINCODEC_ERR_WRONGSTATE;
679
680 EnterCriticalSection(&This->lock);
681 res = pTIFFSetDirectory(This->tiff, index);
682 if (!res) hr = E_INVALIDARG;
683 else hr = tiff_get_decode_info(This->tiff, &decode_info);
684 LeaveCriticalSection(&This->lock);
685
686 if (SUCCEEDED(hr))
687 {
688 result = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode));
689
690 if (result)
691 {
692 result->IWICBitmapFrameDecode_iface.lpVtbl = &TiffFrameDecode_Vtbl;
693 result->ref = 1;
694 result->parent = This;
695 result->index = index;
696 result->decode_info = decode_info;
697 result->cached_tile_x = -1;
698 result->cached_tile = HeapAlloc(GetProcessHeap(), 0, decode_info.tile_size);
699
700 if (result->cached_tile)
701 *ppIBitmapFrame = (IWICBitmapFrameDecode*)result;
702 else
703 {
704 hr = E_OUTOFMEMORY;
705 HeapFree(GetProcessHeap(), 0, result);
706 }
707 }
708 else hr = E_OUTOFMEMORY;
709 }
710
711 if (FAILED(hr)) *ppIBitmapFrame = NULL;
712
713 return hr;
714 }
715
716 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl = {
717 TiffDecoder_QueryInterface,
718 TiffDecoder_AddRef,
719 TiffDecoder_Release,
720 TiffDecoder_QueryCapability,
721 TiffDecoder_Initialize,
722 TiffDecoder_GetContainerFormat,
723 TiffDecoder_GetDecoderInfo,
724 TiffDecoder_CopyPalette,
725 TiffDecoder_GetMetadataQueryReader,
726 TiffDecoder_GetPreview,
727 TiffDecoder_GetColorContexts,
728 TiffDecoder_GetThumbnail,
729 TiffDecoder_GetFrameCount,
730 TiffDecoder_GetFrame
731 };
732
733 static HRESULT WINAPI TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
734 void **ppv)
735 {
736 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
737 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
738
739 if (!ppv) return E_INVALIDARG;
740
741 if (IsEqualIID(&IID_IUnknown, iid) ||
742 IsEqualIID(&IID_IWICBitmapSource, iid) ||
743 IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
744 {
745 *ppv = This;
746 }
747 else
748 {
749 *ppv = NULL;
750 return E_NOINTERFACE;
751 }
752
753 IUnknown_AddRef((IUnknown*)*ppv);
754 return S_OK;
755 }
756
757 static ULONG WINAPI TiffFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
758 {
759 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
760 ULONG ref = InterlockedIncrement(&This->ref);
761
762 TRACE("(%p) refcount=%u\n", iface, ref);
763
764 return ref;
765 }
766
767 static ULONG WINAPI TiffFrameDecode_Release(IWICBitmapFrameDecode *iface)
768 {
769 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
770 ULONG ref = InterlockedDecrement(&This->ref);
771
772 TRACE("(%p) refcount=%u\n", iface, ref);
773
774 if (ref == 0)
775 {
776 HeapFree(GetProcessHeap(), 0, This->cached_tile);
777 HeapFree(GetProcessHeap(), 0, This);
778 }
779
780 return ref;
781 }
782
783 static HRESULT WINAPI TiffFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
784 UINT *puiWidth, UINT *puiHeight)
785 {
786 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
787
788 *puiWidth = This->decode_info.width;
789 *puiHeight = This->decode_info.height;
790
791 TRACE("(%p) <-- %ux%u\n", iface, *puiWidth, *puiHeight);
792
793 return S_OK;
794 }
795
796 static HRESULT WINAPI TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
797 WICPixelFormatGUID *pPixelFormat)
798 {
799 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
800
801 memcpy(pPixelFormat, This->decode_info.format, sizeof(GUID));
802
803 TRACE("(%p) <-- %s\n", This, debugstr_guid(This->decode_info.format));
804
805 return S_OK;
806 }
807
808 static HRESULT WINAPI TiffFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
809 double *pDpiX, double *pDpiY)
810 {
811 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
812
813 switch (This->decode_info.resolution_unit)
814 {
815 default:
816 FIXME("unknown resolution unit %i\n", This->decode_info.resolution_unit);
817 /* fall through */
818 case 0: /* Not set */
819 *pDpiX = *pDpiY = 96.0;
820 break;
821 case 1: /* Relative measurements */
822 *pDpiX = 96.0;
823 *pDpiY = 96.0 * This->decode_info.yres / This->decode_info.xres;
824 break;
825 case 2: /* Inch */
826 *pDpiX = This->decode_info.xres;
827 *pDpiY = This->decode_info.yres;
828 break;
829 case 3: /* Centimeter */
830 *pDpiX = This->decode_info.xres / 2.54;
831 *pDpiY = This->decode_info.yres / 2.54;
832 break;
833 }
834
835 TRACE("(%p) <-- %f,%f unit=%i\n", iface, *pDpiX, *pDpiY, This->decode_info.resolution_unit);
836
837 return S_OK;
838 }
839
840 static HRESULT WINAPI TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
841 IWICPalette *pIPalette)
842 {
843 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
844 uint16 *red, *green, *blue;
845 WICColor colors[256];
846 int color_count, ret, i;
847
848 TRACE("(%p,%p)\n", iface, pIPalette);
849
850 color_count = 1<<This->decode_info.bps;
851
852 EnterCriticalSection(&This->parent->lock);
853 ret = pTIFFGetField(This->parent->tiff, TIFFTAG_COLORMAP, &red, &green, &blue);
854 LeaveCriticalSection(&This->parent->lock);
855
856 if (!ret)
857 {
858 WARN("Couldn't read color map\n");
859 return E_FAIL;
860 }
861
862 for (i=0; i<color_count; i++)
863 {
864 colors[i] = 0xff000000 |
865 ((red[i]<<8) & 0xff0000) |
866 (green[i] & 0xff00) |
867 ((blue[i]>>8) & 0xff);
868 }
869
870 return IWICPalette_InitializeCustom(pIPalette, colors, color_count);
871 }
872
873 static HRESULT TiffFrameDecode_ReadTile(TiffFrameDecode *This, UINT tile_x, UINT tile_y)
874 {
875 HRESULT hr=S_OK;
876 tsize_t ret;
877 int swap_bytes;
878
879 swap_bytes = pTIFFIsByteSwapped(This->parent->tiff);
880
881 ret = pTIFFSetDirectory(This->parent->tiff, This->index);
882
883 if (ret == -1)
884 hr = E_FAIL;
885
886 if (hr == S_OK)
887 {
888 if (This->decode_info.tiled)
889 {
890 ret = pTIFFReadEncodedTile(This->parent->tiff, tile_x + tile_y * This->decode_info.tiles_across, This->cached_tile, This->decode_info.tile_size);
891 }
892 else
893 {
894 ret = pTIFFReadEncodedStrip(This->parent->tiff, tile_y, This->cached_tile, This->decode_info.tile_size);
895 }
896
897 if (ret == -1)
898 hr = E_FAIL;
899 }
900
901 if (hr == S_OK && This->decode_info.reverse_bgr)
902 {
903 if (This->decode_info.bps == 8)
904 {
905 UINT sample_count = This->decode_info.samples;
906
907 reverse_bgr8(sample_count, This->cached_tile, This->decode_info.tile_width,
908 This->decode_info.tile_height, This->decode_info.tile_width * sample_count);
909 }
910 }
911
912 if (hr == S_OK && swap_bytes && This->decode_info.bps > 8)
913 {
914 UINT row, i, samples_per_row;
915 BYTE *sample, temp;
916
917 samples_per_row = This->decode_info.tile_width * This->decode_info.samples;
918
919 switch(This->decode_info.bps)
920 {
921 case 16:
922 for (row=0; row<This->decode_info.tile_height; row++)
923 {
924 sample = This->cached_tile + row * This->decode_info.tile_stride;
925 for (i=0; i<samples_per_row; i++)
926 {
927 temp = sample[1];
928 sample[1] = sample[0];
929 sample[0] = temp;
930 sample += 2;
931 }
932 }
933 break;
934 default:
935 ERR("unhandled bps for byte swap %u\n", This->decode_info.bps);
936 return E_FAIL;
937 }
938 }
939
940 if (hr == S_OK && This->decode_info.invert_grayscale)
941 {
942 BYTE *byte, *end;
943
944 if (This->decode_info.samples != 1)
945 {
946 ERR("cannot invert grayscale image with %u samples\n", This->decode_info.samples);
947 return E_FAIL;
948 }
949
950 end = This->cached_tile+This->decode_info.tile_size;
951
952 for (byte = This->cached_tile; byte != end; byte++)
953 *byte = ~(*byte);
954 }
955
956 if (hr == S_OK)
957 {
958 This->cached_tile_x = tile_x;
959 This->cached_tile_y = tile_y;
960 }
961
962 return hr;
963 }
964
965 static HRESULT WINAPI TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
966 const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
967 {
968 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
969 UINT min_tile_x, max_tile_x, min_tile_y, max_tile_y;
970 UINT tile_x, tile_y;
971 WICRect rc;
972 HRESULT hr=S_OK;
973 BYTE *dst_tilepos;
974 UINT bytesperrow;
975 WICRect rect;
976
977 TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
978
979 if (!prc)
980 {
981 rect.X = 0;
982 rect.Y = 0;
983 rect.Width = This->decode_info.width;
984 rect.Height = This->decode_info.height;
985 prc = ▭
986 }
987 else
988 {
989 if (prc->X < 0 || prc->Y < 0 || prc->X+prc->Width > This->decode_info.width ||
990 prc->Y+prc->Height > This->decode_info.height)
991 return E_INVALIDARG;
992 }
993
994 bytesperrow = ((This->decode_info.bpp * prc->Width)+7)/8;
995
996 if (cbStride < bytesperrow)
997 return E_INVALIDARG;
998
999 if ((cbStride * prc->Height) > cbBufferSize)
1000 return E_INVALIDARG;
1001
1002 min_tile_x = prc->X / This->decode_info.tile_width;
1003 min_tile_y = prc->Y / This->decode_info.tile_height;
1004 max_tile_x = (prc->X+prc->Width-1) / This->decode_info.tile_width;
1005 max_tile_y = (prc->Y+prc->Height-1) / This->decode_info.tile_height;
1006
1007 EnterCriticalSection(&This->parent->lock);
1008
1009 for (tile_x=min_tile_x; tile_x <= max_tile_x; tile_x++)
1010 {
1011 for (tile_y=min_tile_y; tile_y <= max_tile_y; tile_y++)
1012 {
1013 if (tile_x != This->cached_tile_x || tile_y != This->cached_tile_y)
1014 {
1015 hr = TiffFrameDecode_ReadTile(This, tile_x, tile_y);
1016 }
1017
1018 if (SUCCEEDED(hr))
1019 {
1020 if (prc->X < tile_x * This->decode_info.tile_width)
1021 rc.X = 0;
1022 else
1023 rc.X = prc->X - tile_x * This->decode_info.tile_width;
1024
1025 if (prc->Y < tile_y * This->decode_info.tile_height)
1026 rc.Y = 0;
1027 else
1028 rc.Y = prc->Y - tile_y * This->decode_info.tile_height;
1029
1030 if (prc->X+prc->Width > (tile_x+1) * This->decode_info.tile_width)
1031 rc.Width = This->decode_info.tile_width - rc.X;
1032 else if (prc->X < tile_x * This->decode_info.tile_width)
1033 rc.Width = prc->Width + prc->X - tile_x * This->decode_info.tile_width;
1034 else
1035 rc.Width = prc->Width;
1036
1037 if (prc->Y+prc->Height > (tile_y+1) * This->decode_info.tile_height)
1038 rc.Height = This->decode_info.tile_height - rc.Y;
1039 else if (prc->Y < tile_y * This->decode_info.tile_height)
1040 rc.Height = prc->Height + prc->Y - tile_y * This->decode_info.tile_height;
1041 else
1042 rc.Height = prc->Height;
1043
1044 dst_tilepos = pbBuffer + (cbStride * ((rc.Y + tile_y * This->decode_info.tile_height) - prc->Y)) +
1045 ((This->decode_info.bpp * ((rc.X + tile_x * This->decode_info.tile_width) - prc->X) + 7) / 8);
1046
1047 hr = copy_pixels(This->decode_info.bpp, This->cached_tile,
1048 This->decode_info.tile_width, This->decode_info.tile_height, This->decode_info.tile_stride,
1049 &rc, cbStride, cbBufferSize, dst_tilepos);
1050 }
1051
1052 if (FAILED(hr))
1053 {
1054 LeaveCriticalSection(&This->parent->lock);
1055 TRACE("<-- 0x%x\n", hr);
1056 return hr;
1057 }
1058 }
1059 }
1060
1061 LeaveCriticalSection(&This->parent->lock);
1062
1063 return S_OK;
1064 }
1065
1066 static HRESULT WINAPI TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
1067 IWICMetadataQueryReader **ppIMetadataQueryReader)
1068 {
1069 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
1070 return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
1074 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
1075 {
1076 FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
1077 return E_NOTIMPL;
1078 }
1079
1080 static HRESULT WINAPI TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
1081 IWICBitmapSource **ppIThumbnail)
1082 {
1083 FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
1084 return E_NOTIMPL;
1085 }
1086
1087 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl = {
1088 TiffFrameDecode_QueryInterface,
1089 TiffFrameDecode_AddRef,
1090 TiffFrameDecode_Release,
1091 TiffFrameDecode_GetSize,
1092 TiffFrameDecode_GetPixelFormat,
1093 TiffFrameDecode_GetResolution,
1094 TiffFrameDecode_CopyPalette,
1095 TiffFrameDecode_CopyPixels,
1096 TiffFrameDecode_GetMetadataQueryReader,
1097 TiffFrameDecode_GetColorContexts,
1098 TiffFrameDecode_GetThumbnail
1099 };
1100
1101 HRESULT TiffDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1102 {
1103 HRESULT ret;
1104 TiffDecoder *This;
1105
1106 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1107
1108 *ppv = NULL;
1109
1110 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1111
1112 if (!load_libtiff())
1113 {
1114 ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF);
1115 return E_FAIL;
1116 }
1117
1118 This = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder));
1119 if (!This) return E_OUTOFMEMORY;
1120
1121 This->IWICBitmapDecoder_iface.lpVtbl = &TiffDecoder_Vtbl;
1122 This->ref = 1;
1123 This->stream = NULL;
1124 InitializeCriticalSection(&This->lock);
1125 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TiffDecoder.lock");
1126 This->tiff = NULL;
1127 This->initialized = FALSE;
1128
1129 ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1130 IUnknown_Release((IUnknown*)This);
1131
1132 return ret;
1133 }
1134
1135 struct tiff_encode_format {
1136 const WICPixelFormatGUID *guid;
1137 int photometric;
1138 int bps;
1139 int samples;
1140 int bpp;
1141 int extra_sample;
1142 int extra_sample_type;
1143 int reverse_bgr;
1144 };
1145
1146 static const struct tiff_encode_format formats[] = {
1147 {&GUID_WICPixelFormat24bppBGR, 2, 8, 3, 24, 0, 0, 1},
1148 {&GUID_WICPixelFormatBlackWhite, 1, 1, 1, 1, 0, 0, 0},
1149 {&GUID_WICPixelFormat4bppGray, 1, 4, 1, 4, 0, 0, 0},
1150 {&GUID_WICPixelFormat8bppGray, 1, 8, 1, 8, 0, 0, 0},
1151 {&GUID_WICPixelFormat32bppBGRA, 2, 8, 4, 32, 1, 2, 1},
1152 {&GUID_WICPixelFormat32bppPBGRA, 2, 8, 4, 32, 1, 1, 1},
1153 {&GUID_WICPixelFormat48bppRGB, 2, 16, 3, 48, 0, 0, 0},
1154 {&GUID_WICPixelFormat64bppRGBA, 2, 16, 4, 64, 1, 2, 0},
1155 {&GUID_WICPixelFormat64bppPRGBA, 2, 16, 4, 64, 1, 1, 0},
1156 {0}
1157 };
1158
1159 typedef struct TiffEncoder {
1160 IWICBitmapEncoder IWICBitmapEncoder_iface;
1161 LONG ref;
1162 IStream *stream;
1163 CRITICAL_SECTION lock; /* Must be held when tiff is used or fields below are set */
1164 TIFF *tiff;
1165 BOOL initialized;
1166 BOOL committed;
1167 ULONG num_frames;
1168 ULONG num_frames_committed;
1169 } TiffEncoder;
1170
1171 static inline TiffEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
1172 {
1173 return CONTAINING_RECORD(iface, TiffEncoder, IWICBitmapEncoder_iface);
1174 }
1175
1176 typedef struct TiffFrameEncode {
1177 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
1178 LONG ref;
1179 TiffEncoder *parent;
1180 /* fields below are protected by parent->lock */
1181 BOOL initialized;
1182 BOOL info_written;
1183 BOOL committed;
1184 const struct tiff_encode_format *format;
1185 UINT width, height;
1186 double xres, yres;
1187 UINT lines_written;
1188 } TiffFrameEncode;
1189
1190 static inline TiffFrameEncode *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
1191 {
1192 return CONTAINING_RECORD(iface, TiffFrameEncode, IWICBitmapFrameEncode_iface);
1193 }
1194
1195 static HRESULT WINAPI TiffFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
1196 void **ppv)
1197 {
1198 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1199 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1200
1201 if (!ppv) return E_INVALIDARG;
1202
1203 if (IsEqualIID(&IID_IUnknown, iid) ||
1204 IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
1205 {
1206 *ppv = &This->IWICBitmapFrameEncode_iface;
1207 }
1208 else
1209 {
1210 *ppv = NULL;
1211 return E_NOINTERFACE;
1212 }
1213
1214 IUnknown_AddRef((IUnknown*)*ppv);
1215 return S_OK;
1216 }
1217
1218 static ULONG WINAPI TiffFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
1219 {
1220 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1221 ULONG ref = InterlockedIncrement(&This->ref);
1222
1223 TRACE("(%p) refcount=%u\n", iface, ref);
1224
1225 return ref;
1226 }
1227
1228 static ULONG WINAPI TiffFrameEncode_Release(IWICBitmapFrameEncode *iface)
1229 {
1230 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1231 ULONG ref = InterlockedDecrement(&This->ref);
1232
1233 TRACE("(%p) refcount=%u\n", iface, ref);
1234
1235 if (ref == 0)
1236 {
1237 IWICBitmapEncoder_Release(&This->parent->IWICBitmapEncoder_iface);
1238 HeapFree(GetProcessHeap(), 0, This);
1239 }
1240
1241 return ref;
1242 }
1243
1244 static HRESULT WINAPI TiffFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
1245 IPropertyBag2 *pIEncoderOptions)
1246 {
1247 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1248 TRACE("(%p,%p)\n", iface, pIEncoderOptions);
1249
1250 EnterCriticalSection(&This->parent->lock);
1251
1252 if (This->initialized)
1253 {
1254 LeaveCriticalSection(&This->parent->lock);
1255 return WINCODEC_ERR_WRONGSTATE;
1256 }
1257
1258 This->initialized = TRUE;
1259
1260 LeaveCriticalSection(&This->parent->lock);
1261
1262 return S_OK;
1263 }
1264
1265 static HRESULT WINAPI TiffFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
1266 UINT uiWidth, UINT uiHeight)
1267 {
1268 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1269 TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
1270
1271 EnterCriticalSection(&This->parent->lock);
1272
1273 if (!This->initialized || This->info_written)
1274 {
1275 LeaveCriticalSection(&This->parent->lock);
1276 return WINCODEC_ERR_WRONGSTATE;
1277 }
1278
1279 This->width = uiWidth;
1280 This->height = uiHeight;
1281
1282 LeaveCriticalSection(&This->parent->lock);
1283
1284 return S_OK;
1285 }
1286
1287 static HRESULT WINAPI TiffFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
1288 double dpiX, double dpiY)
1289 {
1290 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1291 TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
1292
1293 EnterCriticalSection(&This->parent->lock);
1294
1295 if (!This->initialized || This->info_written)
1296 {
1297 LeaveCriticalSection(&This->parent->lock);
1298 return WINCODEC_ERR_WRONGSTATE;
1299 }
1300
1301 This->xres = dpiX;
1302 This->yres = dpiY;
1303
1304 LeaveCriticalSection(&This->parent->lock);
1305
1306 return S_OK;
1307 }
1308
1309 static HRESULT WINAPI TiffFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
1310 WICPixelFormatGUID *pPixelFormat)
1311 {
1312 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1313 int i;
1314
1315 TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
1316
1317 EnterCriticalSection(&This->parent->lock);
1318
1319 if (!This->initialized || This->info_written)
1320 {
1321 LeaveCriticalSection(&This->parent->lock);
1322 return WINCODEC_ERR_WRONGSTATE;
1323 }
1324
1325 for (i=0; formats[i].guid; i++)
1326 {
1327 if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
1328 break;
1329 }
1330
1331 if (!formats[i].guid) i = 0;
1332
1333 This->format = &formats[i];
1334 memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
1335
1336 LeaveCriticalSection(&This->parent->lock);
1337
1338 return S_OK;
1339 }
1340
1341 static HRESULT WINAPI TiffFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
1342 UINT cCount, IWICColorContext **ppIColorContext)
1343 {
1344 FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1345 return E_NOTIMPL;
1346 }
1347
1348 static HRESULT WINAPI TiffFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
1349 IWICPalette *pIPalette)
1350 {
1351 FIXME("(%p,%p): stub\n", iface, pIPalette);
1352 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1353 }
1354
1355 static HRESULT WINAPI TiffFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
1356 IWICBitmapSource *pIThumbnail)
1357 {
1358 FIXME("(%p,%p): stub\n", iface, pIThumbnail);
1359 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1360 }
1361
1362 static HRESULT WINAPI TiffFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
1363 UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
1364 {
1365 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1366 BYTE *row_data, *swapped_data = NULL;
1367 UINT i, j, line_size;
1368
1369 TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
1370
1371 EnterCriticalSection(&This->parent->lock);
1372
1373 if (!This->initialized || !This->width || !This->height || !This->format)
1374 {
1375 LeaveCriticalSection(&This->parent->lock);
1376 return WINCODEC_ERR_WRONGSTATE;
1377 }
1378
1379 if (lineCount == 0 || lineCount + This->lines_written > This->height)
1380 {
1381 LeaveCriticalSection(&This->parent->lock);
1382 return E_INVALIDARG;
1383 }
1384
1385 line_size = ((This->width * This->format->bpp)+7)/8;
1386
1387 if (This->format->reverse_bgr)
1388 {
1389 swapped_data = HeapAlloc(GetProcessHeap(), 0, line_size);
1390 if (!swapped_data)
1391 {
1392 LeaveCriticalSection(&This->parent->lock);
1393 return E_OUTOFMEMORY;
1394 }
1395 }
1396
1397 if (!This->info_written)
1398 {
1399 pTIFFSetField(This->parent->tiff, TIFFTAG_PHOTOMETRIC, (uint16)This->format->photometric);
1400 pTIFFSetField(This->parent->tiff, TIFFTAG_PLANARCONFIG, (uint16)1);
1401 pTIFFSetField(This->parent->tiff, TIFFTAG_BITSPERSAMPLE, (uint16)This->format->bps);
1402 pTIFFSetField(This->parent->tiff, TIFFTAG_SAMPLESPERPIXEL, (uint16)This->format->samples);
1403
1404 if (This->format->extra_sample)
1405 {
1406 uint16 extra_samples;
1407 extra_samples = This->format->extra_sample_type;
1408
1409 pTIFFSetField(This->parent->tiff, TIFFTAG_EXTRASAMPLES, (uint16)1, &extra_samples);
1410 }
1411
1412 pTIFFSetField(This->parent->tiff, TIFFTAG_IMAGEWIDTH, (uint32)This->width);
1413 pTIFFSetField(This->parent->tiff, TIFFTAG_IMAGELENGTH, (uint32)This->height);
1414
1415 if (This->xres != 0.0 && This->yres != 0.0)
1416 {
1417 pTIFFSetField(This->parent->tiff, TIFFTAG_RESOLUTIONUNIT, (uint16)2); /* Inch */
1418 pTIFFSetField(This->parent->tiff, TIFFTAG_XRESOLUTION, (float)This->xres);
1419 pTIFFSetField(This->parent->tiff, TIFFTAG_YRESOLUTION, (float)This->yres);
1420 }
1421
1422 This->info_written = TRUE;
1423 }
1424
1425 for (i=0; i<lineCount; i++)
1426 {
1427 row_data = pbPixels + i * cbStride;
1428
1429 if (This->format->reverse_bgr && This->format->bps == 8)
1430 {
1431 memcpy(swapped_data, row_data, line_size);
1432 for (j=0; j<line_size; j += This->format->samples)
1433 {
1434 BYTE temp;
1435 temp = swapped_data[j];
1436 swapped_data[j] = swapped_data[j+2];
1437 swapped_data[j+2] = temp;
1438 }
1439 row_data = swapped_data;
1440 }
1441
1442 pTIFFWriteScanline(This->parent->tiff, (tdata_t)row_data, i+This->lines_written, 0);
1443 }
1444
1445 This->lines_written += lineCount;
1446
1447 LeaveCriticalSection(&This->parent->lock);
1448
1449 HeapFree(GetProcessHeap(), 0, swapped_data);
1450
1451 return S_OK;
1452 }
1453
1454 static HRESULT WINAPI TiffFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
1455 IWICBitmapSource *pIBitmapSource, WICRect *prc)
1456 {
1457 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1458 HRESULT hr;
1459 WICRect rc;
1460 WICPixelFormatGUID guid;
1461 UINT stride;
1462 BYTE *pixeldata;
1463
1464 TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
1465
1466 if (!This->initialized || !This->width || !This->height)
1467 return WINCODEC_ERR_WRONGSTATE;
1468
1469 if (!This->format)
1470 {
1471 hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1472 if (FAILED(hr)) return hr;
1473 hr = IWICBitmapFrameEncode_SetPixelFormat(iface, &guid);
1474 if (FAILED(hr)) return hr;
1475 }
1476
1477 hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1478 if (FAILED(hr)) return hr;
1479 if (memcmp(&guid, This->format->guid, sizeof(GUID)) != 0)
1480 {
1481 /* FIXME: should use WICConvertBitmapSource to convert */
1482 ERR("format %s unsupported\n", debugstr_guid(&guid));
1483 return E_FAIL;
1484 }
1485
1486 if (This->xres == 0.0 || This->yres == 0.0)
1487 {
1488 double xres, yres;
1489 hr = IWICBitmapSource_GetResolution(pIBitmapSource, &xres, &yres);
1490 if (FAILED(hr)) return hr;
1491 hr = IWICBitmapFrameEncode_SetResolution(iface, xres, yres);
1492 if (FAILED(hr)) return hr;
1493 }
1494
1495 if (!prc)
1496 {
1497 UINT width, height;
1498 hr = IWICBitmapSource_GetSize(pIBitmapSource, &width, &height);
1499 if (FAILED(hr)) return hr;
1500 rc.X = 0;
1501 rc.Y = 0;
1502 rc.Width = width;
1503 rc.Height = height;
1504 prc = &rc;
1505 }
1506
1507 if (prc->Width != This->width) return E_INVALIDARG;
1508
1509 stride = (This->format->bpp * This->width + 7)/8;
1510
1511 pixeldata = HeapAlloc(GetProcessHeap(), 0, stride * prc->Height);
1512 if (!pixeldata) return E_OUTOFMEMORY;
1513
1514 hr = IWICBitmapSource_CopyPixels(pIBitmapSource, prc, stride,
1515 stride*prc->Height, pixeldata);
1516
1517 if (SUCCEEDED(hr))
1518 {
1519 hr = IWICBitmapFrameEncode_WritePixels(iface, prc->Height, stride,
1520 stride*prc->Height, pixeldata);
1521 }
1522
1523 HeapFree(GetProcessHeap(), 0, pixeldata);
1524
1525 return S_OK;
1526 }
1527
1528 static HRESULT WINAPI TiffFrameEncode_Commit(IWICBitmapFrameEncode *iface)
1529 {
1530 TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1531
1532 TRACE("(%p)\n", iface);
1533
1534 EnterCriticalSection(&This->parent->lock);
1535
1536 if (!This->info_written || This->lines_written != This->height || This->committed)
1537 {
1538 LeaveCriticalSection(&This->parent->lock);
1539 return WINCODEC_ERR_WRONGSTATE;
1540 }
1541
1542 /* libtiff will commit the data when creating a new frame or closing the file */
1543
1544 This->committed = TRUE;
1545 This->parent->num_frames_committed++;
1546
1547 LeaveCriticalSection(&This->parent->lock);
1548
1549 return S_OK;
1550 }
1551
1552 static HRESULT WINAPI TiffFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
1553 IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1554 {
1555 FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
1556 return E_NOTIMPL;
1557 }
1558
1559 static const IWICBitmapFrameEncodeVtbl TiffFrameEncode_Vtbl = {
1560 TiffFrameEncode_QueryInterface,
1561 TiffFrameEncode_AddRef,
1562 TiffFrameEncode_Release,
1563 TiffFrameEncode_Initialize,
1564 TiffFrameEncode_SetSize,
1565 TiffFrameEncode_SetResolution,
1566 TiffFrameEncode_SetPixelFormat,
1567 TiffFrameEncode_SetColorContexts,
1568 TiffFrameEncode_SetPalette,
1569 TiffFrameEncode_SetThumbnail,
1570 TiffFrameEncode_WritePixels,
1571 TiffFrameEncode_WriteSource,
1572 TiffFrameEncode_Commit,
1573 TiffFrameEncode_GetMetadataQueryWriter
1574 };
1575
1576 static HRESULT WINAPI TiffEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
1577 void **ppv)
1578 {
1579 TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
1580 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1581
1582 if (!ppv) return E_INVALIDARG;
1583
1584 if (IsEqualIID(&IID_IUnknown, iid) ||
1585 IsEqualIID(&IID_IWICBitmapEncoder, iid))
1586 {
1587 *ppv = This;
1588 }
1589 else
1590 {
1591 *ppv = NULL;
1592 return E_NOINTERFACE;
1593 }
1594
1595 IUnknown_AddRef((IUnknown*)*ppv);
1596 return S_OK;
1597 }
1598
1599 static ULONG WINAPI TiffEncoder_AddRef(IWICBitmapEncoder *iface)
1600 {
1601 TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
1602 ULONG ref = InterlockedIncrement(&This->ref);
1603
1604 TRACE("(%p) refcount=%u\n", iface, ref);
1605
1606 return ref;
1607 }
1608
1609 static ULONG WINAPI TiffEncoder_Release(IWICBitmapEncoder *iface)
1610 {
1611 TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
1612 ULONG ref = InterlockedDecrement(&This->ref);
1613
1614 TRACE("(%p) refcount=%u\n", iface, ref);
1615
1616 if (ref == 0)
1617 {
1618 if (This->tiff) pTIFFClose(This->tiff);
1619 if (This->stream) IStream_Release(This->stream);
1620 This->lock.DebugInfo->Spare[0] = 0;
1621 DeleteCriticalSection(&This->lock);
1622 HeapFree(GetProcessHeap(), 0, This);
1623 }
1624
1625 return ref;
1626 }
1627
1628 static HRESULT WINAPI TiffEncoder_Initialize(IWICBitmapEncoder *iface,
1629 IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
1630 {
1631 TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
1632 TIFF *tiff;
1633 HRESULT hr=S_OK;
1634
1635 TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
1636
1637 EnterCriticalSection(&This->lock);
1638
1639 if (This->initialized || This->committed)
1640 {
1641 hr = WINCODEC_ERR_WRONGSTATE;
1642 goto exit;
1643 }
1644
1645 tiff = tiff_open_stream(pIStream, "w");
1646
1647 if (!tiff)
1648 {
1649 hr = E_FAIL;
1650 goto exit;
1651 }
1652
1653 This->tiff = tiff;
1654 This->stream = pIStream;
1655 IStream_AddRef(pIStream);
1656 This->initialized = TRUE;
1657
1658 exit:
1659 LeaveCriticalSection(&This->lock);
1660 return hr;
1661 }
1662
1663 static HRESULT WINAPI TiffEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
1664 GUID *pguidContainerFormat)
1665 {
1666 memcpy(pguidContainerFormat, &GUID_ContainerFormatTiff, sizeof(GUID));
1667 return S_OK;
1668 }
1669
1670 static HRESULT WINAPI TiffEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
1671 IWICBitmapEncoderInfo **ppIEncoderInfo)
1672 {
1673 FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
1674 return E_NOTIMPL;
1675 }
1676
1677 static HRESULT WINAPI TiffEncoder_SetColorContexts(IWICBitmapEncoder *iface,
1678 UINT cCount, IWICColorContext **ppIColorContext)
1679 {
1680 FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1681 return E_NOTIMPL;
1682 }
1683
1684 static HRESULT WINAPI TiffEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
1685 {
1686 TRACE("(%p,%p)\n", iface, pIPalette);
1687 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1688 }
1689
1690 static HRESULT WINAPI TiffEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
1691 {
1692 TRACE("(%p,%p)\n", iface, pIThumbnail);
1693 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1694 }
1695
1696 static HRESULT WINAPI TiffEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
1697 {
1698 TRACE("(%p,%p)\n", iface, pIPreview);
1699 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1700 }
1701
1702 static HRESULT WINAPI TiffEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
1703 IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
1704 {
1705 TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
1706 TiffFrameEncode *result;
1707
1708 HRESULT hr=S_OK;
1709
1710 TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
1711
1712 EnterCriticalSection(&This->lock);
1713
1714 if (!This->initialized || This->committed)
1715 {
1716 hr = WINCODEC_ERR_WRONGSTATE;
1717 }
1718 else if (This->num_frames != This->num_frames_committed)
1719 {
1720 FIXME("New frame created before previous frame was committed\n");
1721 hr = E_FAIL;
1722 }
1723
1724 if (SUCCEEDED(hr))
1725 {
1726 hr = CreatePropertyBag2(ppIEncoderOptions);
1727 }
1728
1729 if (SUCCEEDED(hr))
1730 {
1731 result = HeapAlloc(GetProcessHeap(), 0, sizeof(*result));
1732
1733 if (result)
1734 {
1735 result->IWICBitmapFrameEncode_iface.lpVtbl = &TiffFrameEncode_Vtbl;
1736 result->ref = 1;
1737 result->parent = This;
1738 result->initialized = FALSE;
1739 result->info_written = FALSE;
1740 result->committed = FALSE;
1741 result->format = NULL;
1742 result->width = 0;
1743 result->height = 0;
1744 result->xres = 0.0;
1745 result->yres = 0.0;
1746 result->lines_written = 0;
1747
1748 IWICBitmapEncoder_AddRef(iface);
1749 *ppIFrameEncode = &result->IWICBitmapFrameEncode_iface;
1750
1751 if (This->num_frames != 0)
1752 pTIFFWriteDirectory(This->tiff);
1753
1754 This->num_frames++;
1755 }
1756 else
1757 hr = E_OUTOFMEMORY;
1758
1759 if (FAILED(hr))
1760 {
1761 IPropertyBag2_Release(*ppIEncoderOptions);
1762 *ppIEncoderOptions = NULL;
1763 }
1764 }
1765
1766 LeaveCriticalSection(&This->lock);
1767
1768 return hr;
1769 }
1770
1771 static HRESULT WINAPI TiffEncoder_Commit(IWICBitmapEncoder *iface)
1772 {
1773 TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
1774
1775 TRACE("(%p)\n", iface);
1776
1777 EnterCriticalSection(&This->lock);
1778
1779 if (!This->initialized || This->committed)
1780 {
1781 LeaveCriticalSection(&This->lock);
1782 return WINCODEC_ERR_WRONGSTATE;
1783 }
1784
1785 pTIFFClose(This->tiff);
1786 IStream_Release(This->stream);
1787 This->stream = NULL;
1788 This->tiff = NULL;
1789
1790 This->committed = TRUE;
1791
1792 LeaveCriticalSection(&This->lock);
1793
1794 return S_OK;
1795 }
1796
1797 static HRESULT WINAPI TiffEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
1798 IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1799 {
1800 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
1801 return E_NOTIMPL;
1802 }
1803
1804 static const IWICBitmapEncoderVtbl TiffEncoder_Vtbl = {
1805 TiffEncoder_QueryInterface,
1806 TiffEncoder_AddRef,
1807 TiffEncoder_Release,
1808 TiffEncoder_Initialize,
1809 TiffEncoder_GetContainerFormat,
1810 TiffEncoder_GetEncoderInfo,
1811 TiffEncoder_SetColorContexts,
1812 TiffEncoder_SetPalette,
1813 TiffEncoder_SetThumbnail,
1814 TiffEncoder_SetPreview,
1815 TiffEncoder_CreateNewFrame,
1816 TiffEncoder_Commit,
1817 TiffEncoder_GetMetadataQueryWriter
1818 };
1819
1820 HRESULT TiffEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1821 {
1822 TiffEncoder *This;
1823 HRESULT ret;
1824
1825 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1826
1827 *ppv = NULL;
1828
1829 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1830
1831 if (!load_libtiff())
1832 {
1833 ERR("Failed writing TIFF because unable to load %s\n",SONAME_LIBTIFF);
1834 return E_FAIL;
1835 }
1836
1837 This = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffEncoder));
1838 if (!This) return E_OUTOFMEMORY;
1839
1840 This->IWICBitmapEncoder_iface.lpVtbl = &TiffEncoder_Vtbl;
1841 This->ref = 1;
1842 This->stream = NULL;
1843 InitializeCriticalSection(&This->lock);
1844 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TiffEncoder.lock");
1845 This->tiff = NULL;
1846 This->initialized = FALSE;
1847 This->num_frames = 0;
1848 This->num_frames_committed = 0;
1849 This->committed = FALSE;
1850
1851 ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1852 IUnknown_Release((IUnknown*)This);
1853
1854 return ret;
1855 }
1856
1857 #else /* !SONAME_LIBTIFF */
1858
1859 HRESULT TiffDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1860 {
1861 ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
1862 return E_FAIL;
1863 }
1864
1865 HRESULT TiffEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1866 {
1867 ERR("Trying to save TIFF picture, but Wine was compiled without TIFF support.\n");
1868 return E_FAIL;
1869 }
1870
1871 #endif
1872
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.