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