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(TIFFSetDirectory);
66 #undef MAKE_FUNCPTR
67
68 static void *load_libtiff(void)
69 {
70 void *result;
71
72 EnterCriticalSection(&init_tiff_cs);
73
74 if (!libtiff_handle &&
75 (libtiff_handle = wine_dlopen(SONAME_LIBTIFF, RTLD_NOW, NULL, 0)) != NULL)
76 {
77
78 #define LOAD_FUNCPTR(f) \
79 if((p##f = wine_dlsym(libtiff_handle, #f, NULL, 0)) == NULL) { \
80 ERR("failed to load symbol %s\n", #f); \
81 libtiff_handle = NULL; \
82 LeaveCriticalSection(&init_tiff_cs); \
83 return NULL; \
84 }
85 LOAD_FUNCPTR(TIFFClientOpen);
86 LOAD_FUNCPTR(TIFFClose);
87 LOAD_FUNCPTR(TIFFCurrentDirectory);
88 LOAD_FUNCPTR(TIFFGetField);
89 LOAD_FUNCPTR(TIFFIsByteSwapped);
90 LOAD_FUNCPTR(TIFFReadDirectory);
91 LOAD_FUNCPTR(TIFFReadEncodedStrip);
92 LOAD_FUNCPTR(TIFFSetDirectory);
93 #undef LOAD_FUNCPTR
94
95 }
96
97 result = libtiff_handle;
98
99 LeaveCriticalSection(&init_tiff_cs);
100 return result;
101 }
102
103 static tsize_t tiff_stream_read(thandle_t client_data, tdata_t data, tsize_t size)
104 {
105 IStream *stream = (IStream*)client_data;
106 ULONG bytes_read;
107 HRESULT hr;
108
109 hr = IStream_Read(stream, data, size, &bytes_read);
110 if (FAILED(hr)) bytes_read = 0;
111 return bytes_read;
112 }
113
114 static tsize_t tiff_stream_write(thandle_t client_data, tdata_t data, tsize_t size)
115 {
116 IStream *stream = (IStream*)client_data;
117 ULONG bytes_written;
118 HRESULT hr;
119
120 hr = IStream_Write(stream, data, size, &bytes_written);
121 if (FAILED(hr)) bytes_written = 0;
122 return bytes_written;
123 }
124
125 static toff_t tiff_stream_seek(thandle_t client_data, toff_t offset, int whence)
126 {
127 IStream *stream = (IStream*)client_data;
128 LARGE_INTEGER move;
129 DWORD origin;
130 ULARGE_INTEGER new_position;
131 HRESULT hr;
132
133 move.QuadPart = offset;
134 switch (whence)
135 {
136 case SEEK_SET:
137 origin = STREAM_SEEK_SET;
138 break;
139 case SEEK_CUR:
140 origin = STREAM_SEEK_CUR;
141 break;
142 case SEEK_END:
143 origin = STREAM_SEEK_END;
144 break;
145 default:
146 ERR("unknown whence value %i\n", whence);
147 return -1;
148 }
149
150 hr = IStream_Seek(stream, move, origin, &new_position);
151 if (SUCCEEDED(hr)) return new_position.QuadPart;
152 else return -1;
153 }
154
155 static int tiff_stream_close(thandle_t client_data)
156 {
157 /* Caller is responsible for releasing the stream object. */
158 return 0;
159 }
160
161 static toff_t tiff_stream_size(thandle_t client_data)
162 {
163 IStream *stream = (IStream*)client_data;
164 STATSTG statstg;
165 HRESULT hr;
166
167 hr = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
168
169 if (SUCCEEDED(hr)) return statstg.cbSize.QuadPart;
170 else return -1;
171 }
172
173 static int tiff_stream_map(thandle_t client_data, tdata_t *addr, toff_t *size)
174 {
175 /* Cannot mmap streams */
176 return 0;
177 }
178
179 static void tiff_stream_unmap(thandle_t client_data, tdata_t addr, toff_t size)
180 {
181 /* No need to ever do this, since we can't map things. */
182 }
183
184 static TIFF* tiff_open_stream(IStream *stream, const char *mode)
185 {
186 LARGE_INTEGER zero;
187
188 zero.QuadPart = 0;
189 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
190
191 return pTIFFClientOpen("<IStream object>", mode, stream, tiff_stream_read,
192 tiff_stream_write, tiff_stream_seek, tiff_stream_close,
193 tiff_stream_size, tiff_stream_map, tiff_stream_unmap);
194 }
195
196 typedef struct {
197 IWICBitmapDecoder IWICBitmapDecoder_iface;
198 LONG ref;
199 IStream *stream;
200 CRITICAL_SECTION lock; /* Must be held when tiff is used or initiailzed is set */
201 TIFF *tiff;
202 BOOL initialized;
203 } TiffDecoder;
204
205 typedef struct {
206 const WICPixelFormatGUID *format;
207 int bps;
208 int samples;
209 int bpp;
210 int planar;
211 int indexed;
212 int reverse_bgr;
213 int invert_grayscale;
214 UINT width, height;
215 UINT tile_width, tile_height;
216 UINT tile_stride;
217 UINT tile_size;
218 } tiff_decode_info;
219
220 typedef struct {
221 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
222 LONG ref;
223 TiffDecoder *parent;
224 UINT index;
225 tiff_decode_info decode_info;
226 INT cached_tile_x, cached_tile_y;
227 BYTE *cached_tile;
228 } TiffFrameDecode;
229
230 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl;
231
232 static inline TiffDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
233 {
234 return CONTAINING_RECORD(iface, TiffDecoder, IWICBitmapDecoder_iface);
235 }
236
237 static inline TiffFrameDecode *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
238 {
239 return CONTAINING_RECORD(iface, TiffFrameDecode, IWICBitmapFrameDecode_iface);
240 }
241
242 static HRESULT tiff_get_decode_info(TIFF *tiff, tiff_decode_info *decode_info)
243 {
244 uint16 photometric, bps, samples, planar;
245 uint16 extra_sample_count, *extra_samples;
246 int ret;
247
248 decode_info->indexed = 0;
249 decode_info->reverse_bgr = 0;
250 decode_info->invert_grayscale = 0;
251
252 ret = pTIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
253 if (!ret)
254 {
255 WARN("missing PhotometricInterpretation tag\n");
256 return E_FAIL;
257 }
258
259 ret = pTIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bps);
260 if (!ret) bps = 1;
261 decode_info->bps = bps;
262
263 ret = pTIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samples);
264 if (!ret) samples = 1;
265 decode_info->samples = samples;
266
267 if (samples == 1)
268 planar = 1;
269 else
270 {
271 ret = pTIFFGetField(tiff, TIFFTAG_PLANARCONFIG, &planar);
272 if (!ret) planar = 1;
273 if (planar != 1)
274 {
275 FIXME("unhandled planar configuration %u\n", planar);
276 return E_FAIL;
277 }
278 }
279 decode_info->planar = planar;
280
281 switch(photometric)
282 {
283 case 0: /* WhiteIsZero */
284 decode_info->invert_grayscale = 1;
285 case 1: /* BlackIsZero */
286 if (samples != 1)
287 {
288 FIXME("unhandled grayscale sample count %u\n", samples);
289 return E_FAIL;
290 }
291
292 decode_info->bpp = bps;
293 switch (bps)
294 {
295 case 1:
296 decode_info->format = &GUID_WICPixelFormatBlackWhite;
297 break;
298 case 4:
299 decode_info->format = &GUID_WICPixelFormat4bppGray;
300 break;
301 case 8:
302 decode_info->format = &GUID_WICPixelFormat8bppGray;
303 break;
304 default:
305 FIXME("unhandled greyscale bit count %u\n", bps);
306 return E_FAIL;
307 }
308 break;
309 case 2: /* RGB */
310 decode_info->bpp = bps * samples;
311
312 if (samples == 4)
313 {
314 ret = pTIFFGetField(tiff, TIFFTAG_EXTRASAMPLES, &extra_sample_count, &extra_samples);
315 if (!ret)
316 {
317 WARN("Cannot get extra sample type for RGB data, ret=%i count=%i\n", ret, extra_sample_count);
318 return E_FAIL;
319 }
320 }
321 else if (samples != 3)
322 {
323 FIXME("unhandled RGB sample count %u\n", samples);
324 return E_FAIL;
325 }
326
327 switch(bps)
328 {
329 case 8:
330 decode_info->reverse_bgr = 1;
331 if (samples == 3)
332 decode_info->format = &GUID_WICPixelFormat24bppBGR;
333 else
334 switch(extra_samples[0])
335 {
336 case 0: /* Unspecified data */
337 decode_info->format = &GUID_WICPixelFormat32bppBGR;
338 break;
339 case 1: /* Associated (pre-multiplied) alpha data */
340 decode_info->format = &GUID_WICPixelFormat32bppPBGRA;
341 break;
342 case 2: /* Unassociated alpha data */
343 decode_info->format = &GUID_WICPixelFormat32bppBGRA;
344 break;
345 default:
346 FIXME("unhandled extra sample type %i\n", extra_samples[0]);
347 return E_FAIL;
348 }
349 break;
350 case 16:
351 if (samples == 3)
352 decode_info->format = &GUID_WICPixelFormat48bppRGB;
353 else
354 switch(extra_samples[0])
355 {
356 case 0: /* Unspecified data */
357 /* decode_info->format = &GUID_WICPixelFormat64bppRGB; */
358 FIXME("64-bit RGB is unsupported\n");
359 return E_FAIL;
360 case 1: /* Associated (pre-multiplied) alpha data */
361 decode_info->format = &GUID_WICPixelFormat64bppPRGBA;
362 break;
363 case 2: /* Unassociated alpha data */
364 decode_info->format = &GUID_WICPixelFormat64bppRGBA;
365 break;
366 default:
367 FIXME("unhandled extra sample type %i\n", extra_samples[0]);
368 return E_FAIL;
369 }
370 break;
371 default:
372 FIXME("unhandled RGB bit count %u\n", bps);
373 return E_FAIL;
374 }
375 break;
376 case 3: /* RGB Palette */
377 if (samples != 1)
378 {
379 FIXME("unhandled indexed sample count %u\n", samples);
380 return E_FAIL;
381 }
382
383 decode_info->indexed = 1;
384 decode_info->bpp = bps;
385 switch (bps)
386 {
387 case 4:
388 decode_info->format = &GUID_WICPixelFormat4bppIndexed;
389 break;
390 case 8:
391 decode_info->format = &GUID_WICPixelFormat8bppIndexed;
392 break;
393 default:
394 FIXME("unhandled indexed bit count %u\n", bps);
395 return E_FAIL;
396 }
397 break;
398 case 4: /* Transparency mask */
399 case 5: /* CMYK */
400 case 6: /* YCbCr */
401 case 8: /* CIELab */
402 default:
403 FIXME("unhandled PhotometricInterpretation %u\n", photometric);
404 return E_FAIL;
405 }
406
407 ret = pTIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &decode_info->width);
408 if (!ret)
409 {
410 WARN("missing image width\n");
411 return E_FAIL;
412 }
413
414 ret = pTIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &decode_info->height);
415 if (!ret)
416 {
417 WARN("missing image length\n");
418 return E_FAIL;
419 }
420
421 ret = pTIFFGetField(tiff, TIFFTAG_ROWSPERSTRIP, &decode_info->tile_height);
422 if (ret)
423 {
424 if (decode_info->tile_height > decode_info->height)
425 decode_info->tile_height = decode_info->height;
426 decode_info->tile_width = decode_info->width;
427 decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
428 decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
429 }
430 else
431 {
432 /* Probably a tiled image */
433 FIXME("missing RowsPerStrip value\n");
434 return E_FAIL;
435 }
436
437 return S_OK;
438 }
439
440 static HRESULT WINAPI TiffDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
441 void **ppv)
442 {
443 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
444 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
445
446 if (!ppv) return E_INVALIDARG;
447
448 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
449 {
450 *ppv = This;
451 }
452 else
453 {
454 *ppv = NULL;
455 return E_NOINTERFACE;
456 }
457
458 IUnknown_AddRef((IUnknown*)*ppv);
459 return S_OK;
460 }
461
462 static ULONG WINAPI TiffDecoder_AddRef(IWICBitmapDecoder *iface)
463 {
464 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
465 ULONG ref = InterlockedIncrement(&This->ref);
466
467 TRACE("(%p) refcount=%u\n", iface, ref);
468
469 return ref;
470 }
471
472 static ULONG WINAPI TiffDecoder_Release(IWICBitmapDecoder *iface)
473 {
474 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
475 ULONG ref = InterlockedDecrement(&This->ref);
476
477 TRACE("(%p) refcount=%u\n", iface, ref);
478
479 if (ref == 0)
480 {
481 if (This->tiff) pTIFFClose(This->tiff);
482 if (This->stream) IStream_Release(This->stream);
483 This->lock.DebugInfo->Spare[0] = 0;
484 DeleteCriticalSection(&This->lock);
485 HeapFree(GetProcessHeap(), 0, This);
486 }
487
488 return ref;
489 }
490
491 static HRESULT WINAPI TiffDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
492 DWORD *pdwCapability)
493 {
494 FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
495 return E_NOTIMPL;
496 }
497
498 static HRESULT WINAPI TiffDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
499 WICDecodeOptions cacheOptions)
500 {
501 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
502 TIFF *tiff;
503 HRESULT hr=S_OK;
504
505 TRACE("(%p,%p,%x): stub\n", iface, pIStream, cacheOptions);
506
507 EnterCriticalSection(&This->lock);
508
509 if (This->initialized)
510 {
511 hr = WINCODEC_ERR_WRONGSTATE;
512 goto exit;
513 }
514
515 tiff = tiff_open_stream(pIStream, "r");
516
517 if (!tiff)
518 {
519 hr = E_FAIL;
520 goto exit;
521 }
522
523 This->tiff = tiff;
524 This->stream = pIStream;
525 IStream_AddRef(pIStream);
526 This->initialized = TRUE;
527
528 exit:
529 LeaveCriticalSection(&This->lock);
530 return hr;
531 }
532
533 static HRESULT WINAPI TiffDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
534 GUID *pguidContainerFormat)
535 {
536 memcpy(pguidContainerFormat, &GUID_ContainerFormatTiff, sizeof(GUID));
537 return S_OK;
538 }
539
540 static HRESULT WINAPI TiffDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
541 IWICBitmapDecoderInfo **ppIDecoderInfo)
542 {
543 FIXME("(%p,%p): stub\n", iface, ppIDecoderInfo);
544 return E_NOTIMPL;
545 }
546
547 static HRESULT WINAPI TiffDecoder_CopyPalette(IWICBitmapDecoder *iface,
548 IWICPalette *pIPalette)
549 {
550 FIXME("(%p,%p): stub\n", iface, pIPalette);
551 return E_NOTIMPL;
552 }
553
554 static HRESULT WINAPI TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
555 IWICMetadataQueryReader **ppIMetadataQueryReader)
556 {
557 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
558 return E_NOTIMPL;
559 }
560
561 static HRESULT WINAPI TiffDecoder_GetPreview(IWICBitmapDecoder *iface,
562 IWICBitmapSource **ppIBitmapSource)
563 {
564 FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
565 return E_NOTIMPL;
566 }
567
568 static HRESULT WINAPI TiffDecoder_GetColorContexts(IWICBitmapDecoder *iface,
569 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
570 {
571 FIXME("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
572 return E_NOTIMPL;
573 }
574
575 static HRESULT WINAPI TiffDecoder_GetThumbnail(IWICBitmapDecoder *iface,
576 IWICBitmapSource **ppIThumbnail)
577 {
578 TRACE("(%p,%p)\n", iface, ppIThumbnail);
579 return WINCODEC_ERR_CODECNOTHUMBNAIL;
580 }
581
582 static HRESULT WINAPI TiffDecoder_GetFrameCount(IWICBitmapDecoder *iface,
583 UINT *pCount)
584 {
585 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
586
587 if (!This->tiff)
588 {
589 WARN("(%p) <-- WINCODEC_ERR_WRONGSTATE\n", iface);
590 return WINCODEC_ERR_WRONGSTATE;
591 }
592
593 EnterCriticalSection(&This->lock);
594 while (pTIFFReadDirectory(This->tiff)) { }
595 *pCount = pTIFFCurrentDirectory(This->tiff)+1;
596 LeaveCriticalSection(&This->lock);
597
598 TRACE("(%p) <-- %i\n", iface, *pCount);
599
600 return S_OK;
601 }
602
603 static HRESULT WINAPI TiffDecoder_GetFrame(IWICBitmapDecoder *iface,
604 UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
605 {
606 TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
607 TiffFrameDecode *result;
608 int res;
609 tiff_decode_info decode_info;
610 HRESULT hr;
611
612 TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
613
614 if (!This->tiff)
615 return WINCODEC_ERR_WRONGSTATE;
616
617 EnterCriticalSection(&This->lock);
618 res = pTIFFSetDirectory(This->tiff, index);
619 if (!res) hr = E_INVALIDARG;
620 else hr = tiff_get_decode_info(This->tiff, &decode_info);
621 LeaveCriticalSection(&This->lock);
622
623 if (SUCCEEDED(hr))
624 {
625 result = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode));
626
627 if (result)
628 {
629 result->IWICBitmapFrameDecode_iface.lpVtbl = &TiffFrameDecode_Vtbl;
630 result->ref = 1;
631 result->parent = This;
632 result->index = index;
633 result->decode_info = decode_info;
634 result->cached_tile_x = -1;
635 result->cached_tile = HeapAlloc(GetProcessHeap(), 0, decode_info.tile_size);
636
637 if (result->cached_tile)
638 *ppIBitmapFrame = (IWICBitmapFrameDecode*)result;
639 else
640 {
641 hr = E_OUTOFMEMORY;
642 HeapFree(GetProcessHeap(), 0, result);
643 }
644 }
645 else hr = E_OUTOFMEMORY;
646 }
647
648 if (FAILED(hr)) *ppIBitmapFrame = NULL;
649
650 return hr;
651 }
652
653 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl = {
654 TiffDecoder_QueryInterface,
655 TiffDecoder_AddRef,
656 TiffDecoder_Release,
657 TiffDecoder_QueryCapability,
658 TiffDecoder_Initialize,
659 TiffDecoder_GetContainerFormat,
660 TiffDecoder_GetDecoderInfo,
661 TiffDecoder_CopyPalette,
662 TiffDecoder_GetMetadataQueryReader,
663 TiffDecoder_GetPreview,
664 TiffDecoder_GetColorContexts,
665 TiffDecoder_GetThumbnail,
666 TiffDecoder_GetFrameCount,
667 TiffDecoder_GetFrame
668 };
669
670 static HRESULT WINAPI TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
671 void **ppv)
672 {
673 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
674 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
675
676 if (!ppv) return E_INVALIDARG;
677
678 if (IsEqualIID(&IID_IUnknown, iid) ||
679 IsEqualIID(&IID_IWICBitmapSource, iid) ||
680 IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
681 {
682 *ppv = This;
683 }
684 else
685 {
686 *ppv = NULL;
687 return E_NOINTERFACE;
688 }
689
690 IUnknown_AddRef((IUnknown*)*ppv);
691 return S_OK;
692 }
693
694 static ULONG WINAPI TiffFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
695 {
696 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
697 ULONG ref = InterlockedIncrement(&This->ref);
698
699 TRACE("(%p) refcount=%u\n", iface, ref);
700
701 return ref;
702 }
703
704 static ULONG WINAPI TiffFrameDecode_Release(IWICBitmapFrameDecode *iface)
705 {
706 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
707 ULONG ref = InterlockedDecrement(&This->ref);
708
709 TRACE("(%p) refcount=%u\n", iface, ref);
710
711 if (ref == 0)
712 {
713 HeapFree(GetProcessHeap(), 0, This->cached_tile);
714 HeapFree(GetProcessHeap(), 0, This);
715 }
716
717 return ref;
718 }
719
720 static HRESULT WINAPI TiffFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
721 UINT *puiWidth, UINT *puiHeight)
722 {
723 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
724
725 *puiWidth = This->decode_info.width;
726 *puiHeight = This->decode_info.height;
727
728 TRACE("(%p) <-- %ux%u\n", iface, *puiWidth, *puiHeight);
729
730 return S_OK;
731 }
732
733 static HRESULT WINAPI TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
734 WICPixelFormatGUID *pPixelFormat)
735 {
736 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
737
738 memcpy(pPixelFormat, This->decode_info.format, sizeof(GUID));
739
740 TRACE("(%p) <-- %s\n", This, debugstr_guid(This->decode_info.format));
741
742 return S_OK;
743 }
744
745 static HRESULT WINAPI TiffFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
746 double *pDpiX, double *pDpiY)
747 {
748 FIXME("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
749 return E_NOTIMPL;
750 }
751
752 static HRESULT WINAPI TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
753 IWICPalette *pIPalette)
754 {
755 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
756 uint16 *red, *green, *blue;
757 WICColor colors[256];
758 int color_count, ret, i;
759
760 TRACE("(%p,%p)\n", iface, pIPalette);
761
762 color_count = 1<<This->decode_info.bps;
763
764 EnterCriticalSection(&This->parent->lock);
765 ret = pTIFFGetField(This->parent->tiff, TIFFTAG_COLORMAP, &red, &green, &blue);
766 LeaveCriticalSection(&This->parent->lock);
767
768 if (!ret)
769 {
770 WARN("Couldn't read color map\n");
771 return E_FAIL;
772 }
773
774 for (i=0; i<color_count; i++)
775 {
776 colors[i] = 0xff000000 |
777 ((red[i]<<8) & 0xff0000) |
778 (green[i] & 0xff00) |
779 ((blue[i]>>8) & 0xff);
780 }
781
782 return IWICPalette_InitializeCustom(pIPalette, colors, color_count);
783 }
784
785 static HRESULT TiffFrameDecode_ReadTile(TiffFrameDecode *This, UINT tile_x, UINT tile_y)
786 {
787 HRESULT hr=S_OK;
788 tsize_t ret;
789 int swap_bytes;
790
791 swap_bytes = pTIFFIsByteSwapped(This->parent->tiff);
792
793 ret = pTIFFSetDirectory(This->parent->tiff, This->index);
794
795 if (ret == -1)
796 hr = E_FAIL;
797
798 if (hr == S_OK)
799 {
800 ret = pTIFFReadEncodedStrip(This->parent->tiff, tile_y, This->cached_tile, This->decode_info.tile_size);
801
802 if (ret == -1)
803 hr = E_FAIL;
804 }
805
806 if (hr == S_OK && This->decode_info.reverse_bgr)
807 {
808 if (This->decode_info.bps == 8)
809 {
810 UINT sample_count = This->decode_info.samples;
811
812 reverse_bgr8(sample_count, This->cached_tile, This->decode_info.tile_width,
813 This->decode_info.tile_height, This->decode_info.tile_width * sample_count);
814 }
815 }
816
817 if (hr == S_OK && swap_bytes && This->decode_info.bps > 8)
818 {
819 UINT row, i, samples_per_row;
820 BYTE *sample, temp;
821
822 samples_per_row = This->decode_info.tile_width * This->decode_info.samples;
823
824 switch(This->decode_info.bps)
825 {
826 case 16:
827 for (row=0; row<This->decode_info.tile_height; row++)
828 {
829 sample = This->cached_tile + row * This->decode_info.tile_stride;
830 for (i=0; i<samples_per_row; i++)
831 {
832 temp = sample[1];
833 sample[1] = sample[0];
834 sample[0] = temp;
835 sample += 2;
836 }
837 }
838 break;
839 default:
840 ERR("unhandled bps for byte swap %u\n", This->decode_info.bps);
841 return E_FAIL;
842 }
843 }
844
845 if (hr == S_OK && This->decode_info.invert_grayscale)
846 {
847 BYTE *byte, *end;
848
849 if (This->decode_info.samples != 1)
850 {
851 ERR("cannot invert grayscale image with %u samples\n", This->decode_info.samples);
852 return E_FAIL;
853 }
854
855 end = This->cached_tile+This->decode_info.tile_size;
856
857 for (byte = This->cached_tile; byte != end; byte++)
858 *byte = ~(*byte);
859 }
860
861 if (hr == S_OK)
862 {
863 This->cached_tile_x = tile_x;
864 This->cached_tile_y = tile_y;
865 }
866
867 return hr;
868 }
869
870 static HRESULT WINAPI TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
871 const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
872 {
873 TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
874 UINT min_tile_x, max_tile_x, min_tile_y, max_tile_y;
875 UINT tile_x, tile_y;
876 WICRect rc;
877 HRESULT hr=S_OK;
878 BYTE *dst_tilepos;
879 UINT bytesperrow;
880 WICRect rect;
881
882 TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
883
884 if (!prc)
885 {
886 rect.X = 0;
887 rect.Y = 0;
888 rect.Width = This->decode_info.width;
889 rect.Height = This->decode_info.height;
890 prc = ▭
891 }
892 else
893 {
894 if (prc->X < 0 || prc->Y < 0 || prc->X+prc->Width > This->decode_info.width ||
895 prc->Y+prc->Height > This->decode_info.height)
896 return E_INVALIDARG;
897 }
898
899 bytesperrow = ((This->decode_info.bpp * prc->Width)+7)/8;
900
901 if (cbStride < bytesperrow)
902 return E_INVALIDARG;
903
904 if ((cbStride * prc->Height) > cbBufferSize)
905 return E_INVALIDARG;
906
907 min_tile_x = prc->X / This->decode_info.tile_width;
908 min_tile_y = prc->Y / This->decode_info.tile_height;
909 max_tile_x = (prc->X+prc->Width-1) / This->decode_info.tile_width;
910 max_tile_y = (prc->Y+prc->Height-1) / This->decode_info.tile_height;
911
912 EnterCriticalSection(&This->parent->lock);
913
914 for (tile_x=min_tile_x; tile_x <= max_tile_x; tile_x++)
915 {
916 for (tile_y=min_tile_y; tile_y <= max_tile_y; tile_y++)
917 {
918 if (tile_x != This->cached_tile_x || tile_y != This->cached_tile_y)
919 {
920 hr = TiffFrameDecode_ReadTile(This, tile_x, tile_y);
921 }
922
923 if (SUCCEEDED(hr))
924 {
925 if (prc->X < tile_x * This->decode_info.tile_width)
926 rc.X = 0;
927 else
928 rc.X = prc->X - tile_x * This->decode_info.tile_width;
929
930 if (prc->Y < tile_y * This->decode_info.tile_height)
931 rc.Y = 0;
932 else
933 rc.Y = prc->Y - tile_y * This->decode_info.tile_height;
934
935 if (prc->X+prc->Width > (tile_x+1) * This->decode_info.tile_width)
936 rc.Width = This->decode_info.tile_width - rc.X;
937 else if (prc->X < tile_x * This->decode_info.tile_width)
938 rc.Width = prc->Width + prc->X - tile_x * This->decode_info.tile_width;
939 else
940 rc.Width = prc->Width;
941
942 if (prc->Y+prc->Height > (tile_y+1) * This->decode_info.tile_height)
943 rc.Height = This->decode_info.tile_height - rc.Y;
944 else if (prc->Y < tile_y * This->decode_info.tile_height)
945 rc.Height = prc->Height + prc->Y - tile_y * This->decode_info.tile_height;
946 else
947 rc.Height = prc->Height;
948
949 dst_tilepos = pbBuffer + (cbStride * ((rc.Y + tile_y * This->decode_info.tile_height) - prc->Y)) +
950 ((This->decode_info.bpp * ((rc.X + tile_x * This->decode_info.tile_width) - prc->X) + 7) / 8);
951
952 hr = copy_pixels(This->decode_info.bpp, This->cached_tile,
953 This->decode_info.tile_width, This->decode_info.tile_height, This->decode_info.tile_stride,
954 &rc, cbStride, cbBufferSize, dst_tilepos);
955 }
956
957 if (FAILED(hr))
958 {
959 LeaveCriticalSection(&This->parent->lock);
960 TRACE("<-- 0x%x\n", hr);
961 return hr;
962 }
963 }
964 }
965
966 LeaveCriticalSection(&This->parent->lock);
967
968 return S_OK;
969 }
970
971 static HRESULT WINAPI TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
972 IWICMetadataQueryReader **ppIMetadataQueryReader)
973 {
974 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
975 return E_NOTIMPL;
976 }
977
978 static HRESULT WINAPI TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
979 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
980 {
981 FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
982 return E_NOTIMPL;
983 }
984
985 static HRESULT WINAPI TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
986 IWICBitmapSource **ppIThumbnail)
987 {
988 FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
989 return E_NOTIMPL;
990 }
991
992 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl = {
993 TiffFrameDecode_QueryInterface,
994 TiffFrameDecode_AddRef,
995 TiffFrameDecode_Release,
996 TiffFrameDecode_GetSize,
997 TiffFrameDecode_GetPixelFormat,
998 TiffFrameDecode_GetResolution,
999 TiffFrameDecode_CopyPalette,
1000 TiffFrameDecode_CopyPixels,
1001 TiffFrameDecode_GetMetadataQueryReader,
1002 TiffFrameDecode_GetColorContexts,
1003 TiffFrameDecode_GetThumbnail
1004 };
1005
1006 HRESULT TiffDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1007 {
1008 HRESULT ret;
1009 TiffDecoder *This;
1010
1011 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1012
1013 *ppv = NULL;
1014
1015 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1016
1017 if (!load_libtiff())
1018 {
1019 ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF);
1020 return E_FAIL;
1021 }
1022
1023 This = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder));
1024 if (!This) return E_OUTOFMEMORY;
1025
1026 This->IWICBitmapDecoder_iface.lpVtbl = &TiffDecoder_Vtbl;
1027 This->ref = 1;
1028 This->stream = NULL;
1029 InitializeCriticalSection(&This->lock);
1030 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TiffDecoder.lock");
1031 This->tiff = NULL;
1032 This->initialized = FALSE;
1033
1034 ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1035 IUnknown_Release((IUnknown*)This);
1036
1037 return ret;
1038 }
1039
1040 #else /* !SONAME_LIBTIFF */
1041
1042 HRESULT TiffDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1043 {
1044 ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
1045 return E_FAIL;
1046 }
1047
1048 #endif
1049
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.