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