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
871
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.