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