dlls/windowscodecs/tiffformat.c

   1 /*
   2  * Copyright 2010 Vincent Povirk for CodeWeavers
   3  * Copyright 2016 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include <stdarg.h>
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #ifdef HAVE_TIFFIO_H
  28 #include <tiffio.h>
  29 #endif
  30
  31 #define COBJMACROS
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "objbase.h"
  36
  37 #include "wincodecs_private.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  42
  43 #ifdef SONAME_LIBTIFF
  44
  45 /* Workaround for broken libtiff 4.x headers on some 64-bit hosts which
  46  * define TIFF_UINT64_T/toff_t as 32-bit for 32-bit builds, while they
  47  * are supposed to be always 64-bit.
  48  * TIFF_UINT64_T doesn't exist in libtiff 3.x, it was introduced in 4.x.
  49  */
  50 #ifdef TIFF_UINT64_T
  51 # undef toff_t
  52 # define toff_t UINT64
  53 #endif
  54
  55 static CRITICAL_SECTION init_tiff_cs;
  56 static CRITICAL_SECTION_DEBUG init_tiff_cs_debug =
  57 {
  58     0, 0, &init_tiff_cs,
  59     { &init_tiff_cs_debug.ProcessLocksList,
  60       &init_tiff_cs_debug.ProcessLocksList },
  61     0, 0, { (DWORD_PTR)(__FILE__ ": init_tiff_cs") }
  62 };
  63 static CRITICAL_SECTION init_tiff_cs = { &init_tiff_cs_debug, -1, 0, 0, 0, 0 };
  64
  65 static const WCHAR wszTiffCompressionMethod[] = {'T','i','f','f','C','o','m','p','r','e','s','s','i','o','n','M','e','t','h','o','d',0};
  66 static const WCHAR wszCompressionQuality[] = {'C','o','m','p','r','e','s','s','i','o','n','Q','u','a','l','i','t','y',0};
  67
  68 static void *libtiff_handle;
  69 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
  70 MAKE_FUNCPTR(TIFFClientOpen);
  71 MAKE_FUNCPTR(TIFFClose);
  72 MAKE_FUNCPTR(TIFFCurrentDirOffset);
  73 MAKE_FUNCPTR(TIFFGetField);
  74 MAKE_FUNCPTR(TIFFIsByteSwapped);
  75 MAKE_FUNCPTR(TIFFNumberOfDirectories);
  76 MAKE_FUNCPTR(TIFFReadDirectory);
  77 MAKE_FUNCPTR(TIFFReadEncodedStrip);
  78 MAKE_FUNCPTR(TIFFReadEncodedTile);
  79 MAKE_FUNCPTR(TIFFSetDirectory);
  80 MAKE_FUNCPTR(TIFFSetField);
  81 MAKE_FUNCPTR(TIFFWriteDirectory);
  82 MAKE_FUNCPTR(TIFFWriteScanline);
  83 #undef MAKE_FUNCPTR
  84
  85 static void *load_libtiff(void)
  86 {
  87     void *result;
  88
  89     EnterCriticalSection(&init_tiff_cs);
  90
  91     if (!libtiff_handle &&
  92         (libtiff_handle = dlopen(SONAME_LIBTIFF, RTLD_NOW)) != NULL)
  93     {
  94         void * (*pTIFFSetWarningHandler)(void *);
  95         void * (*pTIFFSetWarningHandlerExt)(void *);
  96
  97 #define LOAD_FUNCPTR(f) \
  98     if((p##f = dlsym(libtiff_handle, #f)) == NULL) { \
  99         ERR("failed to load symbol %s\n", #f); \
 100         libtiff_handle = NULL; \
 101         LeaveCriticalSection(&init_tiff_cs); \
 102         return NULL; \
 103     }
 104         LOAD_FUNCPTR(TIFFClientOpen);
 105         LOAD_FUNCPTR(TIFFClose);
 106         LOAD_FUNCPTR(TIFFCurrentDirOffset);
 107         LOAD_FUNCPTR(TIFFGetField);
 108         LOAD_FUNCPTR(TIFFIsByteSwapped);
 109         LOAD_FUNCPTR(TIFFNumberOfDirectories);
 110         LOAD_FUNCPTR(TIFFReadDirectory);
 111         LOAD_FUNCPTR(TIFFReadEncodedStrip);
 112         LOAD_FUNCPTR(TIFFReadEncodedTile);
 113         LOAD_FUNCPTR(TIFFSetDirectory);
 114         LOAD_FUNCPTR(TIFFSetField);
 115         LOAD_FUNCPTR(TIFFWriteDirectory);
 116         LOAD_FUNCPTR(TIFFWriteScanline);
 117 #undef LOAD_FUNCPTR
 118
 119         if ((pTIFFSetWarningHandler = dlsym(libtiff_handle, "TIFFSetWarningHandler")))
 120             pTIFFSetWarningHandler(NULL);
 121         if ((pTIFFSetWarningHandlerExt = dlsym(libtiff_handle, "TIFFSetWarningHandlerExt")))
 122             pTIFFSetWarningHandlerExt(NULL);
 123     }
 124
 125     result = libtiff_handle;
 126
 127     LeaveCriticalSection(&init_tiff_cs);
 128     return result;
 129 }
 130
 131 static tsize_t tiff_stream_read(thandle_t client_data, tdata_t data, tsize_t size)
 132 {
 133     IStream *stream = (IStream*)client_data;
 134     ULONG bytes_read;
 135     HRESULT hr;
 136
 137     hr = IStream_Read(stream, data, size, &bytes_read);
 138     if (FAILED(hr)) bytes_read = 0;
 139     return bytes_read;
 140 }
 141
 142 static tsize_t tiff_stream_write(thandle_t client_data, tdata_t data, tsize_t size)
 143 {
 144     IStream *stream = (IStream*)client_data;
 145     ULONG bytes_written;
 146     HRESULT hr;
 147
 148     hr = IStream_Write(stream, data, size, &bytes_written);
 149     if (FAILED(hr)) bytes_written = 0;
 150     return bytes_written;
 151 }
 152
 153 static toff_t tiff_stream_seek(thandle_t client_data, toff_t offset, int whence)
 154 {
 155     IStream *stream = (IStream*)client_data;
 156     LARGE_INTEGER move;
 157     DWORD origin;
 158     ULARGE_INTEGER new_position;
 159     HRESULT hr;
 160
 161     move.QuadPart = offset;
 162     switch (whence)
 163     {
 164         case SEEK_SET:
 165             origin = STREAM_SEEK_SET;
 166             break;
 167         case SEEK_CUR:
 168             origin = STREAM_SEEK_CUR;
 169             break;
 170         case SEEK_END:
 171             origin = STREAM_SEEK_END;
 172             break;
 173         default:
 174             ERR("unknown whence value %i\n", whence);
 175             return -1;
 176     }
 177
 178     hr = IStream_Seek(stream, move, origin, &new_position);
 179     if (SUCCEEDED(hr)) return new_position.QuadPart;
 180     else return -1;
 181 }
 182
 183 static int tiff_stream_close(thandle_t client_data)
 184 {
 185     /* Caller is responsible for releasing the stream object. */
 186     return 0;
 187 }
 188
 189 static toff_t tiff_stream_size(thandle_t client_data)
 190 {
 191     IStream *stream = (IStream*)client_data;
 192     STATSTG statstg;
 193     HRESULT hr;
 194
 195     hr = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
 196
 197     if (SUCCEEDED(hr)) return statstg.cbSize.QuadPart;
 198     else return -1;
 199 }
 200
 201 static int tiff_stream_map(thandle_t client_data, tdata_t *addr, toff_t *size)
 202 {
 203     /* Cannot mmap streams */
 204     return 0;
 205 }
 206
 207 static void tiff_stream_unmap(thandle_t client_data, tdata_t addr, toff_t size)
 208 {
 209     /* No need to ever do this, since we can't map things. */
 210 }
 211
 212 static TIFF* tiff_open_stream(IStream *stream, const char *mode)
 213 {
 214     LARGE_INTEGER zero;
 215
 216     zero.QuadPart = 0;
 217     IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
 218
 219     return pTIFFClientOpen("<IStream object>", mode, stream, tiff_stream_read,
 220         tiff_stream_write, (void *)tiff_stream_seek, tiff_stream_close,
 221         (void *)tiff_stream_size, (void *)tiff_stream_map, (void *)tiff_stream_unmap);
 222 }
 223
 224 typedef struct {
 225     IWICBitmapDecoder IWICBitmapDecoder_iface;
 226     LONG ref;
 227     IStream *stream;
 228     CRITICAL_SECTION lock; /* Must be held when tiff is used or initialized is set */
 229     TIFF *tiff;
 230     BOOL initialized;
 231 } TiffDecoder;
 232
 233 typedef struct {
 234     const WICPixelFormatGUID *format;
 235     int bps;
 236     int samples;
 237     int bpp, source_bpp;
 238     int planar;
 239     int indexed;
 240     int reverse_bgr;
 241     int invert_grayscale;
 242     UINT width, height;
 243     UINT tile_width, tile_height;
 244     UINT tile_stride;
 245     UINT tile_size;
 246     int tiled;
 247     UINT tiles_across;
 248     UINT resolution_unit;
 249     float xres, yres;
 250 } tiff_decode_info;
 251
 252 typedef struct {
 253     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 254     IWICMetadataBlockReader IWICMetadataBlockReader_iface;
 255     LONG ref;
 256     TiffDecoder *parent;
 257     UINT index;
 258     tiff_decode_info decode_info;
 259     INT cached_tile_x, cached_tile_y;
 260     BYTE *cached_tile;
 261 } TiffFrameDecode;
 262
 263 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl;
 264 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl;
 265
 266 static inline TiffDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 267 {
 268     return CONTAINING_RECORD(iface, TiffDecoder, IWICBitmapDecoder_iface);
 269 }
 270
 271 static inline TiffFrameDecode *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 272 {
 273     return CONTAINING_RECORD(iface, TiffFrameDecode, IWICBitmapFrameDecode_iface);
 274 }
 275
 276 static inline TiffFrameDecode *impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
 277 {
 278     return CONTAINING_RECORD(iface, TiffFrameDecode, IWICMetadataBlockReader_iface);
 279 }
 280
 281 static HRESULT tiff_get_decode_info(TIFF *tiff, tiff_decode_info *decode_info)
 282 {
 283     uint16 photometric, bps, samples, planar;
 284     uint16 extra_sample_count, extra_sample, *extra_samples;
 285     int ret;
 286
 287     decode_info->indexed = 0;
 288     decode_info->reverse_bgr = 0;
 289     decode_info->invert_grayscale = 0;
 290     decode_info->tiled = 0;
 291     decode_info->source_bpp = 0;
 292
 293     ret = pTIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric);
 294     if (!ret)
 295     {
 296         WARN("missing PhotometricInterpretation tag\n");
 297         return E_FAIL;
 298     }
 299
 300     ret = pTIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bps);
 301     if (!ret) bps = 1;
 302     decode_info->bps = bps;
 303
 304     ret = pTIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samples);
 305     if (!ret) samples = 1;
 306     decode_info->samples = samples;
 307
 308     if (samples == 1)
 309         planar = 1;
 310     else
 311     {
 312         ret = pTIFFGetField(tiff, TIFFTAG_PLANARCONFIG, &planar);
 313         if (!ret) planar = 1;
 314         if (planar != 1)
 315         {
 316             FIXME("unhandled planar configuration %u\n", planar);
 317             return E_FAIL;
 318         }
 319     }
 320     decode_info->planar = planar;
 321
 322     TRACE("planar %u, photometric %u, samples %u, bps %u\n", planar, photometric, samples, bps);
 323
 324     switch(photometric)
 325     {
 326     case 0: /* WhiteIsZero */
 327         decode_info->invert_grayscale = 1;
 328         /* fall through */
 329     case 1: /* BlackIsZero */
 330         if (samples == 2)
 331         {
 332             ret = pTIFFGetField(tiff, TIFFTAG_EXTRASAMPLES, &extra_sample_count, &extra_samples);
 333             if (!ret)
 334             {
 335                 extra_sample_count = 1;
 336                 extra_sample = 0;
 337                 extra_samples = &extra_sample;
 338             }
 339         }
 340         else if (samples != 1)
 341         {
 342             FIXME("unhandled %dbpp sample count %u\n", bps, samples);
 343             return E_FAIL;
 344         }
 345
 346         decode_info->bpp = bps * samples;
 347         decode_info->source_bpp = decode_info->bpp;
 348         switch (bps)
 349         {
 350         case 1:
 351             if (samples != 1)
 352             {
 353                 FIXME("unhandled 1bpp sample count %u\n", samples);
 354                 return E_FAIL;
 355             }
 356             decode_info->format = &GUID_WICPixelFormatBlackWhite;
 357             break;
 358         case 4:
 359             if (samples != 1)
 360             {
 361                 FIXME("unhandled 4bpp grayscale sample count %u\n", samples);
 362                 return E_FAIL;
 363             }
 364             decode_info->format = &GUID_WICPixelFormat4bppGray;
 365             break;
 366         case 8:
 367             if (samples == 1)
 368                 decode_info->format = &GUID_WICPixelFormat8bppGray;
 369             else
 370             {
 371                 decode_info->bpp = 32;
 372
 373                 switch(extra_samples[0])
 374                 {
 375                 case 1: /* Associated (pre-multiplied) alpha data */
 376                     decode_info->format = &GUID_WICPixelFormat32bppPBGRA;
 377                     break;
 378                 case 0: /* Unspecified data */
 379                 case 2: /* Unassociated alpha data */
 380                     decode_info->format = &GUID_WICPixelFormat32bppBGRA;
 381                     break;
 382                 default:
 383                     FIXME("unhandled extra sample type %u\n", extra_samples[0]);
 384                     return E_FAIL;
 385                 }
 386             }
 387             break;
 388         case 16:
 389             if (samples != 1)
 390             {
 391                 FIXME("unhandled 16bpp grayscale sample count %u\n", samples);
 392                 return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
 393             }
 394             decode_info->format = &GUID_WICPixelFormat16bppGray;
 395             break;
 396         case 32:
 397             if (samples != 1)
 398             {
 399                 FIXME("unhandled 32bpp grayscale sample count %u\n", samples);
 400                 return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
 401             }
 402             decode_info->format = &GUID_WICPixelFormat32bppGrayFloat;
 403             break;
 404         default:
 405             WARN("unhandled greyscale bit count %u\n", bps);
 406             return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
 407         }
 408         break;
 409     case 2: /* RGB */
 410         if (samples == 4)
 411         {
 412             ret = pTIFFGetField(tiff, TIFFTAG_EXTRASAMPLES, &extra_sample_count, &extra_samples);
 413             if (!ret)
 414             {
 415                 extra_sample_count = 1;
 416                 extra_sample = 0;
 417                 extra_samples = &extra_sample;
 418             }
 419         }
 420         else if (samples != 3)
 421         {
 422             FIXME("unhandled RGB sample count %u\n", samples);
 423             return E_FAIL;
 424         }
 425
 426         decode_info->bpp = max(bps, 8) * samples;
 427         decode_info->source_bpp = bps * samples;
 428         switch(bps)
 429         {
 430         case 1:
 431         case 4:
 432         case 8:
 433             decode_info->reverse_bgr = 1;
 434             if (samples == 3)
 435                 decode_info->format = &GUID_WICPixelFormat24bppBGR;
 436             else
 437                 switch(extra_samples[0])
 438                 {
 439                 case 1: /* Associated (pre-multiplied) alpha data */
 440                     decode_info->format = &GUID_WICPixelFormat32bppPBGRA;
 441                     break;
 442                 case 0: /* Unspecified data */
 443                 case 2: /* Unassociated alpha data */
 444                     decode_info->format = &GUID_WICPixelFormat32bppBGRA;
 445                     break;
 446                 default:
 447                     FIXME("unhandled extra sample type %i\n", extra_samples[0]);
 448                     return E_FAIL;
 449                 }
 450             break;
 451         case 16:
 452             if (samples == 3)
 453                 decode_info->format = &GUID_WICPixelFormat48bppRGB;
 454             else
 455                 switch(extra_samples[0])
 456                 {
 457                 case 1: /* Associated (pre-multiplied) alpha data */
 458                     decode_info->format = &GUID_WICPixelFormat64bppPRGBA;
 459                     break;
 460                 case 0: /* Unspecified data */
 461                 case 2: /* Unassociated alpha data */
 462                     decode_info->format = &GUID_WICPixelFormat64bppRGBA;
 463                     break;
 464                 default:
 465                     FIXME("unhandled extra sample type %i\n", extra_samples[0]);
 466                     return E_FAIL;
 467                 }
 468             break;
 469         case 32:
 470             if (samples == 3)
 471                 decode_info->format = &GUID_WICPixelFormat96bppRGBFloat;
 472             else
 473                 switch(extra_samples[0])
 474                 {
 475                 case 1: /* Associated (pre-multiplied) alpha data */
 476                     decode_info->format = &GUID_WICPixelFormat128bppPRGBAFloat;
 477                     break;
 478                 case 0: /* Unspecified data */
 479                 case 2: /* Unassociated alpha data */
 480                     decode_info->format = &GUID_WICPixelFormat128bppRGBAFloat;
 481                     break;
 482                 default:
 483                     FIXME("unhandled extra sample type %i\n", extra_samples[0]);
 484                     return E_FAIL;
 485                 }
 486             break;
 487         default:
 488             WARN("unhandled RGB bit count %u\n", bps);
 489             return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
 490         }
 491         break;
 492     case 3: /* RGB Palette */
 493         if (samples != 1)
 494         {
 495             FIXME("unhandled indexed sample count %u\n", samples);
 496             return E_FAIL;
 497         }
 498
 499         decode_info->indexed = 1;
 500         decode_info->bpp = bps;
 501         switch (bps)
 502         {
 503         case 1:
 504             decode_info->format = &GUID_WICPixelFormat1bppIndexed;
 505             break;
 506         case 2:
 507             decode_info->format = &GUID_WICPixelFormat2bppIndexed;
 508             break;
 509         case 4:
 510             decode_info->format = &GUID_WICPixelFormat4bppIndexed;
 511             break;
 512         case 8:
 513             decode_info->format = &GUID_WICPixelFormat8bppIndexed;
 514             break;
 515         default:
 516             FIXME("unhandled indexed bit count %u\n", bps);
 517             return E_NOTIMPL;
 518         }
 519         break;
 520
 521     case 5: /* Separated */
 522         if (samples != 4)
 523         {
 524             FIXME("unhandled Separated sample count %u\n", samples);
 525             return E_FAIL;
 526         }
 527
 528         decode_info->bpp = bps * samples;
 529         switch(bps)
 530         {
 531         case 8:
 532             decode_info->format = &GUID_WICPixelFormat32bppCMYK;
 533             break;
 534         case 16:
 535             decode_info->format = &GUID_WICPixelFormat64bppCMYK;
 536             break;
 537
 538         default:
 539             WARN("unhandled Separated bit count %u\n", bps);
 540             return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
 541         }
 542         break;
 543
 544     case 4: /* Transparency mask */
 545     case 6: /* YCbCr */
 546     case 8: /* CIELab */
 547     default:
 548         FIXME("unhandled PhotometricInterpretation %u\n", photometric);
 549         return E_FAIL;
 550     }
 551
 552     ret = pTIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &decode_info->width);
 553     if (!ret)
 554     {
 555         WARN("missing image width\n");
 556         return E_FAIL;
 557     }
 558
 559     ret = pTIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &decode_info->height);
 560     if (!ret)
 561     {
 562         WARN("missing image length\n");
 563         return E_FAIL;
 564     }
 565
 566     if ((ret = pTIFFGetField(tiff, TIFFTAG_TILEWIDTH, &decode_info->tile_width)))
 567     {
 568         decode_info->tiled = 1;
 569
 570         ret = pTIFFGetField(tiff, TIFFTAG_TILELENGTH, &decode_info->tile_height);
 571         if (!ret)
 572         {
 573             WARN("missing tile height\n");
 574             return E_FAIL;
 575         }
 576
 577         decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
 578         decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
 579         decode_info->tiles_across = (decode_info->width + decode_info->tile_width - 1) / decode_info->tile_width;
 580     }
 581     else if ((ret = pTIFFGetField(tiff, TIFFTAG_ROWSPERSTRIP, &decode_info->tile_height)))
 582     {
 583         if (decode_info->tile_height > decode_info->height)
 584             decode_info->tile_height = decode_info->height;
 585         decode_info->tile_width = decode_info->width;
 586         decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
 587         decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
 588     }
 589     else
 590     {
 591         /* Some broken TIFF files have a single strip and lack the RowsPerStrip tag */
 592         decode_info->tile_height = decode_info->height;
 593         decode_info->tile_width = decode_info->width;
 594         decode_info->tile_stride = ((decode_info->bpp * decode_info->tile_width + 7)/8);
 595         decode_info->tile_size = decode_info->tile_height * decode_info->tile_stride;
 596     }
 597
 598     decode_info->resolution_unit = 0;
 599     pTIFFGetField(tiff, TIFFTAG_RESOLUTIONUNIT, &decode_info->resolution_unit);
 600
 601     ret = pTIFFGetField(tiff, TIFFTAG_XRESOLUTION, &decode_info->xres);
 602     if (!ret)
 603     {
 604         WARN("missing X resolution\n");
 605     }
 606     /* Emulate the behavior of current libtiff versions (libtiff commit a39f6131)
 607      * yielding 0 instead of INFINITY for IFD_RATIONAL fields with denominator 0. */
 608     if (!isfinite(decode_info->xres))
 609     {
 610         decode_info->xres = 0.0;
 611     }
 612
 613     ret = pTIFFGetField(tiff, TIFFTAG_YRESOLUTION, &decode_info->yres);
 614     if (!ret)
 615     {
 616         WARN("missing Y resolution\n");
 617     }
 618     if (!isfinite(decode_info->yres))
 619     {
 620         decode_info->yres = 0.0;
 621     }
 622
 623     return S_OK;
 624 }
 625
 626 static HRESULT WINAPI TiffDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 627     void **ppv)
 628 {
 629     TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
 630     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 631
 632     if (!ppv) return E_INVALIDARG;
 633
 634     if (IsEqualIID(&IID_IUnknown, iid) ||
 635         IsEqualIID(&IID_IWICBitmapDecoder, iid))
 636     {
 637         *ppv = &This->IWICBitmapDecoder_iface;
 638     }
 639     else
 640     {
 641         *ppv = NULL;
 642         return E_NOINTERFACE;
 643     }
 644
 645     IUnknown_AddRef((IUnknown*)*ppv);
 646     return S_OK;
 647 }
 648
 649 static ULONG WINAPI TiffDecoder_AddRef(IWICBitmapDecoder *iface)
 650 {
 651     TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
 652     ULONG ref = InterlockedIncrement(&This->ref);
 653
 654     TRACE("(%p) refcount=%u\n", iface, ref);
 655
 656     return ref;
 657 }
 658
 659 static ULONG WINAPI TiffDecoder_Release(IWICBitmapDecoder *iface)
 660 {
 661     TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
 662     ULONG ref = InterlockedDecrement(&This->ref);
 663
 664     TRACE("(%p) refcount=%u\n", iface, ref);
 665
 666     if (ref == 0)
 667     {
 668         if (This->tiff) pTIFFClose(This->tiff);
 669         if (This->stream) IStream_Release(This->stream);
 670         This->lock.DebugInfo->Spare[0] = 0;
 671         DeleteCriticalSection(&This->lock);
 672         HeapFree(GetProcessHeap(), 0, This);
 673     }
 674
 675     return ref;
 676 }
 677
 678 static HRESULT WINAPI TiffDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
 679     DWORD *capability)
 680 {
 681     HRESULT hr;
 682
 683     TRACE("(%p,%p,%p)\n", iface, stream, capability);
 684
 685     if (!stream || !capability) return E_INVALIDARG;
 686
 687     hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
 688     if (hr != S_OK) return hr;
 689
 690     *capability = WICBitmapDecoderCapabilityCanDecodeAllImages |
 691                   WICBitmapDecoderCapabilityCanDecodeSomeImages |
 692                   WICBitmapDecoderCapabilityCanEnumerateMetadata;
 693     return S_OK;
 694 }
 695
 696 static HRESULT WINAPI TiffDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 697     WICDecodeOptions cacheOptions)
 698 {
 699     TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
 700     TIFF *tiff;
 701     tiff_decode_info decode_info;
 702     HRESULT hr=S_OK;
 703
 704     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 705
 706     EnterCriticalSection(&This->lock);
 707
 708     if (This->initialized)
 709     {
 710         hr = WINCODEC_ERR_WRONGSTATE;
 711         goto exit;
 712     }
 713
 714     tiff = tiff_open_stream(pIStream, "r");
 715     if (!tiff)
 716     {
 717         hr = E_FAIL;
 718         goto exit;
 719     }
 720
 721     /* make sure that TIFF format is supported */
 722     hr = tiff_get_decode_info(tiff, &decode_info);
 723     if (hr != S_OK)
 724     {
 725         pTIFFClose(tiff);
 726         goto exit;
 727     }
 728
 729     This->tiff = tiff;
 730     This->stream = pIStream;
 731     IStream_AddRef(pIStream);
 732     This->initialized = TRUE;
 733
 734 exit:
 735     LeaveCriticalSection(&This->lock);
 736     return hr;
 737 }
 738
 739 static HRESULT WINAPI TiffDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 740     GUID *pguidContainerFormat)
 741 {
 742     if (!pguidContainerFormat) return E_INVALIDARG;
 743
 744     memcpy(pguidContainerFormat, &GUID_ContainerFormatTiff, sizeof(GUID));
 745     return S_OK;
 746 }
 747
 748 static HRESULT WINAPI TiffDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 749     IWICBitmapDecoderInfo **ppIDecoderInfo)
 750 {
 751     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 752
 753     return get_decoder_info(&CLSID_WICTiffDecoder, ppIDecoderInfo);
 754 }
 755
 756 static HRESULT WINAPI TiffDecoder_CopyPalette(IWICBitmapDecoder *iface,
 757     IWICPalette *palette)
 758 {
 759     TRACE("(%p,%p)\n", iface, palette);
 760     return WINCODEC_ERR_PALETTEUNAVAILABLE;
 761 }
 762
 763 static HRESULT WINAPI TiffDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 764     IWICMetadataQueryReader **ppIMetadataQueryReader)
 765 {
 766     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
 767
 768     if (!ppIMetadataQueryReader) return E_INVALIDARG;
 769
 770     *ppIMetadataQueryReader = NULL;
 771     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 772 }
 773
 774 static HRESULT WINAPI TiffDecoder_GetPreview(IWICBitmapDecoder *iface,
 775     IWICBitmapSource **ppIBitmapSource)
 776 {
 777     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
 778
 779     if (!ppIBitmapSource) return E_INVALIDARG;
 780
 781     *ppIBitmapSource = NULL;
 782     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 783 }
 784
 785 static HRESULT WINAPI TiffDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 786     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 787 {
 788     FIXME("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
 789     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 790 }
 791
 792 static HRESULT WINAPI TiffDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 793     IWICBitmapSource **ppIThumbnail)
 794 {
 795     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 796
 797     if (!ppIThumbnail) return E_INVALIDARG;
 798
 799     *ppIThumbnail = NULL;
 800     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 801 }
 802
 803 static HRESULT WINAPI TiffDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 804     UINT *pCount)
 805 {
 806     TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
 807
 808     if (!pCount) return E_INVALIDARG;
 809
 810     EnterCriticalSection(&This->lock);
 811     *pCount = This->tiff ? pTIFFNumberOfDirectories(This->tiff) : 0;
 812     LeaveCriticalSection(&This->lock);
 813
 814     TRACE("(%p) <-- %i\n", iface, *pCount);
 815
 816     return S_OK;
 817 }
 818
 819 static HRESULT WINAPI TiffDecoder_GetFrame(IWICBitmapDecoder *iface,
 820     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 821 {
 822     TiffDecoder *This = impl_from_IWICBitmapDecoder(iface);
 823     TiffFrameDecode *result;
 824     int res;
 825     tiff_decode_info decode_info;
 826     HRESULT hr;
 827
 828     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 829
 830     if (!This->tiff)
 831         return WINCODEC_ERR_FRAMEMISSING;
 832
 833     EnterCriticalSection(&This->lock);
 834     res = pTIFFSetDirectory(This->tiff, index);
 835     if (!res) hr = E_INVALIDARG;
 836     else hr = tiff_get_decode_info(This->tiff, &decode_info);
 837     LeaveCriticalSection(&This->lock);
 838
 839     if (SUCCEEDED(hr))
 840     {
 841         result = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffFrameDecode));
 842
 843         if (result)
 844         {
 845             result->IWICBitmapFrameDecode_iface.lpVtbl = &TiffFrameDecode_Vtbl;
 846             result->IWICMetadataBlockReader_iface.lpVtbl = &TiffFrameDecode_BlockVtbl;
 847             result->ref = 1;
 848             result->parent = This;
 849             IWICBitmapDecoder_AddRef(iface);
 850             result->index = index;
 851             result->decode_info = decode_info;
 852             result->cached_tile_x = -1;
 853             result->cached_tile = HeapAlloc(GetProcessHeap(), 0, decode_info.tile_size);
 854
 855             if (result->cached_tile)
 856                 *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
 857             else
 858             {
 859                 hr = E_OUTOFMEMORY;
 860                 IWICBitmapFrameDecode_Release(&result->IWICBitmapFrameDecode_iface);
 861             }
 862         }
 863         else hr = E_OUTOFMEMORY;
 864     }
 865
 866     if (FAILED(hr)) *ppIBitmapFrame = NULL;
 867
 868     return hr;
 869 }
 870
 871 static const IWICBitmapDecoderVtbl TiffDecoder_Vtbl = {
 872     TiffDecoder_QueryInterface,
 873     TiffDecoder_AddRef,
 874     TiffDecoder_Release,
 875     TiffDecoder_QueryCapability,
 876     TiffDecoder_Initialize,
 877     TiffDecoder_GetContainerFormat,
 878     TiffDecoder_GetDecoderInfo,
 879     TiffDecoder_CopyPalette,
 880     TiffDecoder_GetMetadataQueryReader,
 881     TiffDecoder_GetPreview,
 882     TiffDecoder_GetColorContexts,
 883     TiffDecoder_GetThumbnail,
 884     TiffDecoder_GetFrameCount,
 885     TiffDecoder_GetFrame
 886 };
 887
 888 static HRESULT WINAPI TiffFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
 889     void **ppv)
 890 {
 891     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 892     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 893
 894     if (!ppv) return E_INVALIDARG;
 895
 896     if (IsEqualIID(&IID_IUnknown, iid) ||
 897         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 898         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
 899     {
 900         *ppv = &This->IWICBitmapFrameDecode_iface;
 901     }
 902     else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
 903     {
 904         *ppv = &This->IWICMetadataBlockReader_iface;
 905     }
 906     else
 907     {
 908         *ppv = NULL;
 909         return E_NOINTERFACE;
 910     }
 911
 912     IUnknown_AddRef((IUnknown*)*ppv);
 913     return S_OK;
 914 }
 915
 916 static ULONG WINAPI TiffFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
 917 {
 918     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 919     ULONG ref = InterlockedIncrement(&This->ref);
 920
 921     TRACE("(%p) refcount=%u\n", iface, ref);
 922
 923     return ref;
 924 }
 925
 926 static ULONG WINAPI TiffFrameDecode_Release(IWICBitmapFrameDecode *iface)
 927 {
 928     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 929     ULONG ref = InterlockedDecrement(&This->ref);
 930
 931     TRACE("(%p) refcount=%u\n", iface, ref);
 932
 933     if (ref == 0)
 934     {
 935         IWICBitmapDecoder_Release(&This->parent->IWICBitmapDecoder_iface);
 936         HeapFree(GetProcessHeap(), 0, This->cached_tile);
 937         HeapFree(GetProcessHeap(), 0, This);
 938     }
 939
 940     return ref;
 941 }
 942
 943 static HRESULT WINAPI TiffFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
 944     UINT *puiWidth, UINT *puiHeight)
 945 {
 946     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 947
 948     *puiWidth = This->decode_info.width;
 949     *puiHeight = This->decode_info.height;
 950
 951     TRACE("(%p) <-- %ux%u\n", iface, *puiWidth, *puiHeight);
 952
 953     return S_OK;
 954 }
 955
 956 static HRESULT WINAPI TiffFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
 957     WICPixelFormatGUID *pPixelFormat)
 958 {
 959     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 960
 961     memcpy(pPixelFormat, This->decode_info.format, sizeof(GUID));
 962
 963     TRACE("(%p) <-- %s\n", This, debugstr_guid(This->decode_info.format));
 964
 965     return S_OK;
 966 }
 967
 968 static HRESULT WINAPI TiffFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
 969     double *pDpiX, double *pDpiY)
 970 {
 971     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 972
 973     if (This->decode_info.xres == 0 || This->decode_info.yres == 0)
 974     {
 975         *pDpiX = *pDpiY = 96.0;
 976     }
 977     else
 978     {
 979         switch (This->decode_info.resolution_unit)
 980         {
 981         default:
 982             FIXME("unknown resolution unit %i\n", This->decode_info.resolution_unit);
 983             /* fall through */
 984         case 0: /* Not set */
 985         case 1: /* Relative measurements */
 986         case 2: /* Inch */
 987             *pDpiX = This->decode_info.xres;
 988             *pDpiY = This->decode_info.yres;
 989             break;
 990         case 3: /* Centimeter */
 991             *pDpiX = This->decode_info.xres * 2.54;
 992             *pDpiY = This->decode_info.yres * 2.54;
 993             break;
 994         }
 995     }
 996
 997     TRACE("(%p) <-- %f,%f unit=%i\n", iface, *pDpiX, *pDpiY, This->decode_info.resolution_unit);
 998
 999     return S_OK;
1000 }
1001
1002 static HRESULT WINAPI TiffFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
1003     IWICPalette *pIPalette)
1004 {
1005     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
1006     uint16 *red, *green, *blue;
1007     WICColor colors[256];
1008     int color_count, ret, i;
1009
1010     TRACE("(%p,%p)\n", iface, pIPalette);
1011
1012     color_count = 1<<This->decode_info.bps;
1013
1014     EnterCriticalSection(&This->parent->lock);
1015     ret = pTIFFGetField(This->parent->tiff, TIFFTAG_COLORMAP, &red, &green, &blue);
1016     LeaveCriticalSection(&This->parent->lock);
1017
1018     if (!ret)
1019     {
1020         WARN("Couldn't read color map\n");
1021         return WINCODEC_ERR_PALETTEUNAVAILABLE;
1022     }
1023
1024     for (i=0; i<color_count; i++)
1025     {
1026         colors[i] = 0xff000000 |
1027             ((red[i]<<8) & 0xff0000) |
1028             (green[i] & 0xff00) |
1029             ((blue[i]>>8) & 0xff);
1030     }
1031
1032     return IWICPalette_InitializeCustom(pIPalette, colors, color_count);
1033 }
1034
1035 static HRESULT TiffFrameDecode_ReadTile(TiffFrameDecode *This, UINT tile_x, UINT tile_y)
1036 {
1037     tsize_t ret;
1038     int swap_bytes;
1039
1040     swap_bytes = pTIFFIsByteSwapped(This->parent->tiff);
1041
1042     ret = pTIFFSetDirectory(This->parent->tiff, This->index);
1043     if (ret == -1)
1044         return E_FAIL;
1045
1046     if (This->decode_info.tiled)
1047         ret = pTIFFReadEncodedTile(This->parent->tiff, tile_x + tile_y * This->decode_info.tiles_across, This->cached_tile, This->decode_info.tile_size);
1048     else
1049         ret = pTIFFReadEncodedStrip(This->parent->tiff, tile_y, This->cached_tile, This->decode_info.tile_size);
1050
1051     if (ret == -1)
1052         return E_FAIL;
1053
1054     /* 3bps RGB */
1055     if (This->decode_info.source_bpp == 3 && This->decode_info.samples == 3 && This->decode_info.bpp == 24)
1056     {
1057         BYTE *srcdata, *src, *dst;
1058         DWORD x, y, count, width_bytes = (This->decode_info.tile_width * 3 + 7) / 8;
1059
1060         count = width_bytes * This->decode_info.tile_height;
1061
1062         srcdata = HeapAlloc(GetProcessHeap(), 0, count);
1063         if (!srcdata) return E_OUTOFMEMORY;
1064         memcpy(srcdata, This->cached_tile, count);
1065
1066         for (y = 0; y < This->decode_info.tile_height; y++)
1067         {
1068             src = srcdata + y * width_bytes;
1069             dst = This->cached_tile + y * This->decode_info.tile_width * 3;
1070
1071             for (x = 0; x < This->decode_info.tile_width; x += 8)
1072             {
1073                 dst[2] = (src[0] & 0x80) ? 0xff : 0; /* R */
1074                 dst[1] = (src[0] & 0x40) ? 0xff : 0; /* G */
1075                 dst[0] = (src[0] & 0x20) ? 0xff : 0; /* B */
1076                 if (x + 1 < This->decode_info.tile_width)
1077                 {
1078                     dst[5] = (src[0] & 0x10) ? 0xff : 0; /* R */
1079                     dst[4] = (src[0] & 0x08) ? 0xff : 0; /* G */
1080                     dst[3] = (src[0] & 0x04) ? 0xff : 0; /* B */
1081                 }
1082                 if (x + 2 < This->decode_info.tile_width)
1083                 {
1084                     dst[8] = (src[0] & 0x02) ? 0xff : 0; /* R */
1085                     dst[7] = (src[0] & 0x01) ? 0xff : 0; /* G */
1086                     dst[6]  = (src[1] & 0x80) ? 0xff : 0; /* B */
1087                 }
1088                 if (x + 3 < This->decode_info.tile_width)
1089                 {
1090                     dst[11] = (src[1] & 0x40) ? 0xff : 0; /* R */
1091                     dst[10] = (src[1] & 0x20) ? 0xff : 0; /* G */
1092                     dst[9]  = (src[1] & 0x10) ? 0xff : 0; /* B */
1093                 }
1094                 if (x + 4 < This->decode_info.tile_width)
1095                 {
1096                     dst[14] = (src[1] & 0x08) ? 0xff : 0; /* R */
1097                     dst[13] = (src[1] & 0x04) ? 0xff : 0; /* G */
1098                     dst[12] = (src[1] & 0x02) ? 0xff : 0; /* B */
1099                 }
1100                 if (x + 5 < This->decode_info.tile_width)
1101                 {
1102                     dst[17] = (src[1] & 0x01) ? 0xff : 0; /* R */
1103                     dst[16] = (src[2] & 0x80) ? 0xff : 0; /* G */
1104                     dst[15] = (src[2] & 0x40) ? 0xff : 0; /* B */
1105                 }
1106                 if (x + 6 < This->decode_info.tile_width)
1107                 {
1108                     dst[20] = (src[2] & 0x20) ? 0xff : 0; /* R */
1109                     dst[19] = (src[2] & 0x10) ? 0xff : 0; /* G */
1110                     dst[18] = (src[2] & 0x08) ? 0xff : 0; /* B */
1111                 }
1112                 if (x + 7 < This->decode_info.tile_width)
1113                 {
1114                     dst[23] = (src[2] & 0x04) ? 0xff : 0; /* R */
1115                     dst[22] = (src[2] & 0x02) ? 0xff : 0; /* G */
1116                     dst[21] = (src[2] & 0x01) ? 0xff : 0; /* B */
1117                 }
1118                 src += 3;
1119                 dst += 24;
1120             }
1121         }
1122
1123         HeapFree(GetProcessHeap(), 0, srcdata);
1124     }
1125     /* 12bps RGB */
1126     else if (This->decode_info.source_bpp == 12 && This->decode_info.samples == 3 && This->decode_info.bpp == 24)
1127     {
1128         BYTE *srcdata, *src, *dst;
1129         DWORD x, y, count, width_bytes = (This->decode_info.tile_width * 12 + 7) / 8;
1130
1131         count = width_bytes * This->decode_info.tile_height;
1132
1133         srcdata = HeapAlloc(GetProcessHeap(), 0, count);
1134         if (!srcdata) return E_OUTOFMEMORY;
1135         memcpy(srcdata, This->cached_tile, count);
1136
1137         for (y = 0; y < This->decode_info.tile_height; y++)
1138         {
1139             src = srcdata + y * width_bytes;
1140             dst = This->cached_tile + y * This->decode_info.tile_width * 3;
1141
1142             for (x = 0; x < This->decode_info.tile_width; x += 2)
1143             {
1144                 dst[0] = ((src[1] & 0xf0) >> 4) * 17; /* B */
1145                 dst[1] = (src[0] & 0x0f) * 17; /* G */
1146                 dst[2] = ((src[0] & 0xf0) >> 4) * 17; /* R */
1147                 if (x + 1 < This->decode_info.tile_width)
1148                 {
1149                     dst[5] = (src[1] & 0x0f) * 17; /* B */
1150                     dst[4] = ((src[2] & 0xf0) >> 4) * 17; /* G */
1151                     dst[3] = (src[2] & 0x0f) * 17; /* R */
1152                 }
1153                 src += 3;
1154                 dst += 6;
1155             }
1156         }
1157
1158         HeapFree(GetProcessHeap(), 0, srcdata);
1159     }
1160     /* 4bps RGBA */
1161     else if (This->decode_info.source_bpp == 4 && This->decode_info.samples == 4 && This->decode_info.bpp == 32)
1162     {
1163         BYTE *srcdata, *src, *dst;
1164         DWORD x, y, count, width_bytes = (This->decode_info.tile_width * 3 + 7) / 8;
1165
1166         count = width_bytes * This->decode_info.tile_height;
1167
1168         srcdata = HeapAlloc(GetProcessHeap(), 0, count);
1169         if (!srcdata) return E_OUTOFMEMORY;
1170         memcpy(srcdata, This->cached_tile, count);
1171
1172         for (y = 0; y < This->decode_info.tile_height; y++)
1173         {
1174             src = srcdata + y * width_bytes;
1175             dst = This->cached_tile + y * This->decode_info.tile_width * 4;
1176
1177             /* 1 source byte expands to 2 BGRA samples */
1178
1179             for (x = 0; x < This->decode_info.tile_width; x += 2)
1180             {
1181                 dst[0] = (src[0] & 0x20) ? 0xff : 0; /* B */
1182                 dst[1] = (src[0] & 0x40) ? 0xff : 0; /* G */
1183                 dst[2] = (src[0] & 0x80) ? 0xff : 0; /* R */
1184                 dst[3] = (src[0] & 0x10) ? 0xff : 0; /* A */
1185                 if (x + 1 < This->decode_info.tile_width)
1186                 {
1187                     dst[4] = (src[0] & 0x02) ? 0xff : 0; /* B */
1188                     dst[5] = (src[0] & 0x04) ? 0xff : 0; /* G */
1189                     dst[6] = (src[0] & 0x08) ? 0xff : 0; /* R */
1190                     dst[7] = (src[0] & 0x01) ? 0xff : 0; /* A */
1191                 }
1192                 src++;
1193                 dst += 8;
1194             }
1195         }
1196
1197         HeapFree(GetProcessHeap(), 0, srcdata);
1198     }
1199     /* 16bps RGBA */
1200     else if (This->decode_info.source_bpp == 16 && This->decode_info.samples == 4 && This->decode_info.bpp == 32)
1201     {
1202         BYTE *srcdata, *src, *dst;
1203         DWORD x, y, count, width_bytes = (This->decode_info.tile_width * 12 + 7) / 8;
1204
1205         count = width_bytes * This->decode_info.tile_height;
1206
1207         srcdata = HeapAlloc(GetProcessHeap(), 0, count);
1208         if (!srcdata) return E_OUTOFMEMORY;
1209         memcpy(srcdata, This->cached_tile, count);
1210
1211         for (y = 0; y < This->decode_info.tile_height; y++)
1212         {
1213             src = srcdata + y * width_bytes;
1214             dst = This->cached_tile + y * This->decode_info.tile_width * 4;
1215
1216             for (x = 0; x < This->decode_info.tile_width; x++)
1217             {
1218                 dst[0] = ((src[1] & 0xf0) >> 4) * 17; /* B */
1219                 dst[1] = (src[0] & 0x0f) * 17; /* G */
1220                 dst[2] = ((src[0] & 0xf0) >> 4) * 17; /* R */
1221                 dst[3] = (src[1] & 0x0f) * 17; /* A */
1222                 src += 2;
1223                 dst += 4;
1224             }
1225         }
1226
1227         HeapFree(GetProcessHeap(), 0, srcdata);
1228     }
1229     /* 8bpp grayscale with extra alpha */
1230     else if (This->decode_info.source_bpp == 16 && This->decode_info.samples == 2 && This->decode_info.bpp == 32)
1231     {
1232         BYTE *src;
1233         DWORD *dst, count = This->decode_info.tile_width * This->decode_info.tile_height;
1234
1235         src = This->cached_tile + This->decode_info.tile_width * This->decode_info.tile_height * 2 - 2;
1236         dst = (DWORD *)(This->cached_tile + This->decode_info.tile_size - 4);
1237
1238         while (count--)
1239         {
1240             *dst-- = src[0] | (src[0] << 8) | (src[0] << 16) | (src[1] << 24);
1241             src -= 2;
1242         }
1243     }
1244
1245     if (This->decode_info.reverse_bgr)
1246     {
1247         if (This->decode_info.bps == 8)
1248         {
1249             UINT sample_count = This->decode_info.samples;
1250
1251             reverse_bgr8(sample_count, This->cached_tile, This->decode_info.tile_width,
1252                 This->decode_info.tile_height, This->decode_info.tile_width * sample_count);
1253         }
1254     }
1255
1256     if (swap_bytes && This->decode_info.bps > 8)
1257     {
1258         UINT row, i, samples_per_row;
1259         BYTE *sample, temp;
1260
1261         samples_per_row = This->decode_info.tile_width * This->decode_info.samples;
1262
1263         switch(This->decode_info.bps)
1264         {
1265         case 16:
1266             for (row=0; row<This->decode_info.tile_height; row++)
1267             {
1268                 sample = This->cached_tile + row * This->decode_info.tile_stride;
1269                 for (i=0; i<samples_per_row; i++)
1270                 {
1271                     temp = sample[1];
1272                     sample[1] = sample[0];
1273                     sample[0] = temp;
1274                     sample += 2;
1275                 }
1276             }
1277             break;
1278         default:
1279             ERR("unhandled bps for byte swap %u\n", This->decode_info.bps);
1280             return E_FAIL;
1281         }
1282     }
1283
1284     if (This->decode_info.invert_grayscale)
1285     {
1286         BYTE *byte, *end;
1287
1288         if (This->decode_info.samples != 1)
1289         {
1290             ERR("cannot invert grayscale image with %u samples\n", This->decode_info.samples);
1291             return E_FAIL;
1292         }
1293
1294         end = This->cached_tile+This->decode_info.tile_size;
1295
1296         for (byte = This->cached_tile; byte != end; byte++)
1297             *byte = ~(*byte);
1298     }
1299
1300     This->cached_tile_x = tile_x;
1301     This->cached_tile_y = tile_y;
1302
1303     return S_OK;
1304 }
1305
1306 static HRESULT WINAPI TiffFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
1307     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
1308 {
1309     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
1310     UINT min_tile_x, max_tile_x, min_tile_y, max_tile_y;
1311     UINT tile_x, tile_y;
1312     WICRect rc;
1313     HRESULT hr=S_OK;
1314     BYTE *dst_tilepos;
1315     UINT bytesperrow;
1316     WICRect rect;
1317
1318     TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
1319
1320     if (!prc)
1321     {
1322         rect.X = 0;
1323         rect.Y = 0;
1324         rect.Width = This->decode_info.width;
1325         rect.Height = This->decode_info.height;
1326         prc = &rect;
1327     }
1328     else
1329     {
1330         if (prc->X < 0 || prc->Y < 0 || prc->X+prc->Width > This->decode_info.width ||
1331             prc->Y+prc->Height > This->decode_info.height)
1332             return E_INVALIDARG;
1333     }
1334
1335     bytesperrow = ((This->decode_info.bpp * prc->Width)+7)/8;
1336
1337     if (cbStride < bytesperrow)
1338         return E_INVALIDARG;
1339
1340     if ((cbStride * (prc->Height-1)) + bytesperrow > cbBufferSize)
1341         return E_INVALIDARG;
1342
1343     min_tile_x = prc->X / This->decode_info.tile_width;
1344     min_tile_y = prc->Y / This->decode_info.tile_height;
1345     max_tile_x = (prc->X+prc->Width-1) / This->decode_info.tile_width;
1346     max_tile_y = (prc->Y+prc->Height-1) / This->decode_info.tile_height;
1347
1348     EnterCriticalSection(&This->parent->lock);
1349
1350     for (tile_x=min_tile_x; tile_x <= max_tile_x; tile_x++)
1351     {
1352         for (tile_y=min_tile_y; tile_y <= max_tile_y; tile_y++)
1353         {
1354             if (tile_x != This->cached_tile_x || tile_y != This->cached_tile_y)
1355             {
1356                 hr = TiffFrameDecode_ReadTile(This, tile_x, tile_y);
1357             }
1358
1359             if (SUCCEEDED(hr))
1360             {
1361                 if (prc->X < tile_x * This->decode_info.tile_width)
1362                     rc.X = 0;
1363                 else
1364                     rc.X = prc->X - tile_x * This->decode_info.tile_width;
1365
1366                 if (prc->Y < tile_y * This->decode_info.tile_height)
1367                     rc.Y = 0;
1368                 else
1369                     rc.Y = prc->Y - tile_y * This->decode_info.tile_height;
1370
1371                 if (prc->X+prc->Width > (tile_x+1) * This->decode_info.tile_width)
1372                     rc.Width = This->decode_info.tile_width - rc.X;
1373                 else if (prc->X < tile_x * This->decode_info.tile_width)
1374                     rc.Width = prc->Width + prc->X - tile_x * This->decode_info.tile_width;
1375                 else
1376                     rc.Width = prc->Width;
1377
1378                 if (prc->Y+prc->Height > (tile_y+1) * This->decode_info.tile_height)
1379                     rc.Height = This->decode_info.tile_height - rc.Y;
1380                 else if (prc->Y < tile_y * This->decode_info.tile_height)
1381                     rc.Height = prc->Height + prc->Y - tile_y * This->decode_info.tile_height;
1382                 else
1383                     rc.Height = prc->Height;
1384
1385                 dst_tilepos = pbBuffer + (cbStride * ((rc.Y + tile_y * This->decode_info.tile_height) - prc->Y)) +
1386                     ((This->decode_info.bpp * ((rc.X + tile_x * This->decode_info.tile_width) - prc->X) + 7) / 8);
1387
1388                 hr = copy_pixels(This->decode_info.bpp, This->cached_tile,
1389                     This->decode_info.tile_width, This->decode_info.tile_height, This->decode_info.tile_stride,
1390                     &rc, cbStride, cbBufferSize, dst_tilepos);
1391             }
1392
1393             if (FAILED(hr))
1394             {
1395                 LeaveCriticalSection(&This->parent->lock);
1396                 TRACE("<-- 0x%x\n", hr);
1397                 return hr;
1398             }
1399         }
1400     }
1401
1402     LeaveCriticalSection(&This->parent->lock);
1403
1404     return S_OK;
1405 }
1406
1407 static HRESULT WINAPI TiffFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
1408     IWICMetadataQueryReader **ppIMetadataQueryReader)
1409 {
1410     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
1411
1412     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
1413
1414     if (!ppIMetadataQueryReader)
1415         return E_INVALIDARG;
1416
1417     return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
1418 }
1419
1420 static HRESULT WINAPI TiffFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
1421     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
1422 {
1423     TiffFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
1424     const BYTE *profile;
1425     UINT len;
1426     HRESULT hr;
1427
1428     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
1429
1430     EnterCriticalSection(&This->parent->lock);
1431
1432     if (pTIFFGetField(This->parent->tiff, TIFFTAG_ICCPROFILE, &len, &profile))
1433     {
1434         if (cCount && ppIColorContexts)
1435         {
1436             hr = IWICColorContext_InitializeFromMemory(*ppIColorContexts, profile, len);
1437             if (FAILED(hr))
1438             {
1439                 LeaveCriticalSection(&This->parent->lock);
1440                 return hr;
1441             }
1442         }
1443         *pcActualCount = 1;
1444     }
1445     else
1446         *pcActualCount = 0;
1447
1448     LeaveCriticalSection(&This->parent->lock);
1449
1450     return S_OK;
1451 }
1452
1453 static HRESULT WINAPI TiffFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
1454     IWICBitmapSource **ppIThumbnail)
1455 {
1456     TRACE("(%p,%p)\n", iface, ppIThumbnail);
1457
1458     if (!ppIThumbnail) return E_INVALIDARG;
1459
1460     *ppIThumbnail = NULL;
1461     return WINCODEC_ERR_CODECNOTHUMBNAIL;
1462 }
1463
1464 static const IWICBitmapFrameDecodeVtbl TiffFrameDecode_Vtbl = {
1465     TiffFrameDecode_QueryInterface,
1466     TiffFrameDecode_AddRef,
1467     TiffFrameDecode_Release,
1468     TiffFrameDecode_GetSize,
1469     TiffFrameDecode_GetPixelFormat,
1470     TiffFrameDecode_GetResolution,
1471     TiffFrameDecode_CopyPalette,
1472     TiffFrameDecode_CopyPixels,
1473     TiffFrameDecode_GetMetadataQueryReader,
1474     TiffFrameDecode_GetColorContexts,
1475     TiffFrameDecode_GetThumbnail
1476 };
1477
1478 static HRESULT WINAPI TiffFrameDecode_Block_QueryInterface(IWICMetadataBlockReader *iface,
1479     REFIID iid, void **ppv)
1480 {
1481     TiffFrameDecode *This = impl_from_IWICMetadataBlockReader(iface);
1482     return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
1483 }
1484
1485 static ULONG WINAPI TiffFrameDecode_Block_AddRef(IWICMetadataBlockReader *iface)
1486 {
1487     TiffFrameDecode *This = impl_from_IWICMetadataBlockReader(iface);
1488     return IWICBitmapFrameDecode_AddRef(&This->IWICBitmapFrameDecode_iface);
1489 }
1490
1491 static ULONG WINAPI TiffFrameDecode_Block_Release(IWICMetadataBlockReader *iface)
1492 {
1493     TiffFrameDecode *This = impl_from_IWICMetadataBlockReader(iface);
1494     return IWICBitmapFrameDecode_Release(&This->IWICBitmapFrameDecode_iface);
1495 }
1496
1497 static HRESULT WINAPI TiffFrameDecode_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
1498     GUID *guid)
1499 {
1500     TRACE("(%p,%p)\n", iface, guid);
1501
1502     if (!guid) return E_INVALIDARG;
1503
1504     *guid = GUID_ContainerFormatTiff;
1505     return S_OK;
1506 }
1507
1508 static HRESULT WINAPI TiffFrameDecode_Block_GetCount(IWICMetadataBlockReader *iface,
1509     UINT *count)
1510 {
1511     TRACE("%p,%p\n", iface, count);
1512
1513     if (!count) return E_INVALIDARG;
1514
1515     *count = 1;
1516     return S_OK;
1517 }
1518
1519 static HRESULT create_metadata_reader(TiffFrameDecode *This, IWICMetadataReader **reader)
1520 {
1521     HRESULT hr;
1522     LARGE_INTEGER dir_offset;
1523     IWICMetadataReader *metadata_reader;
1524     IWICPersistStream *persist;
1525
1526     /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
1527
1528     hr = IfdMetadataReader_CreateInstance(&IID_IWICMetadataReader, (void **)&metadata_reader);
1529     if (FAILED(hr)) return hr;
1530
1531     hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
1532     if (FAILED(hr))
1533     {
1534         IWICMetadataReader_Release(metadata_reader);
1535         return hr;
1536     }
1537
1538     EnterCriticalSection(&This->parent->lock);
1539
1540     dir_offset.QuadPart = pTIFFCurrentDirOffset(This->parent->tiff);
1541     hr = IStream_Seek(This->parent->stream, dir_offset, STREAM_SEEK_SET, NULL);
1542     if (SUCCEEDED(hr))
1543     {
1544         BOOL byte_swapped = pTIFFIsByteSwapped(This->parent->tiff);
1545 #ifdef WORDS_BIGENDIAN
1546         DWORD persist_options = byte_swapped ? WICPersistOptionLittleEndian : WICPersistOptionBigEndian;
1547 #else
1548         DWORD persist_options = byte_swapped ? WICPersistOptionBigEndian : WICPersistOptionLittleEndian;
1549 #endif
1550         persist_options |= WICPersistOptionNoCacheStream;
1551         hr = IWICPersistStream_LoadEx(persist, This->parent->stream, NULL, persist_options);
1552         if (FAILED(hr))
1553             ERR("IWICPersistStream_LoadEx error %#x\n", hr);
1554     }
1555
1556     LeaveCriticalSection(&This->parent->lock);
1557
1558     IWICPersistStream_Release(persist);
1559
1560     if (FAILED(hr))
1561     {
1562         IWICMetadataReader_Release(metadata_reader);
1563         return hr;
1564     }
1565
1566     *reader = metadata_reader;
1567     return S_OK;
1568 }
1569
1570 static HRESULT WINAPI TiffFrameDecode_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
1571     UINT index, IWICMetadataReader **reader)
1572 {
1573     TiffFrameDecode *This = impl_from_IWICMetadataBlockReader(iface);
1574
1575     TRACE("(%p,%u,%p)\n", iface, index, reader);
1576
1577     if (!reader || index != 0) return E_INVALIDARG;
1578
1579     return create_metadata_reader(This, reader);
1580 }
1581
1582 static HRESULT WINAPI TiffFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader *iface,
1583     IEnumUnknown **enum_metadata)
1584 {
1585     FIXME("(%p,%p): stub\n", iface, enum_metadata);
1586     return E_NOTIMPL;
1587 }
1588
1589 static const IWICMetadataBlockReaderVtbl TiffFrameDecode_BlockVtbl =
1590 {
1591     TiffFrameDecode_Block_QueryInterface,
1592     TiffFrameDecode_Block_AddRef,
1593     TiffFrameDecode_Block_Release,
1594     TiffFrameDecode_Block_GetContainerFormat,
1595     TiffFrameDecode_Block_GetCount,
1596     TiffFrameDecode_Block_GetReaderByIndex,
1597     TiffFrameDecode_Block_GetEnumerator
1598 };
1599
1600 HRESULT TiffDecoder_CreateInstance(REFIID iid, void** ppv)
1601 {
1602     HRESULT ret;
1603     TiffDecoder *This;
1604
1605     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1606
1607     *ppv = NULL;
1608
1609     if (!load_libtiff())
1610     {
1611         ERR("Failed reading TIFF because unable to load %s\n",SONAME_LIBTIFF);
1612         return E_FAIL;
1613     }
1614
1615     This = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffDecoder));
1616     if (!This) return E_OUTOFMEMORY;
1617
1618     This->IWICBitmapDecoder_iface.lpVtbl = &TiffDecoder_Vtbl;
1619     This->ref = 1;
1620     This->stream = NULL;
1621     InitializeCriticalSection(&This->lock);
1622     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TiffDecoder.lock");
1623     This->tiff = NULL;
1624     This->initialized = FALSE;
1625
1626     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1627     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1628
1629     return ret;
1630 }
1631
1632 struct tiff_encode_format {
1633     const WICPixelFormatGUID *guid;
1634     int photometric;
1635     int bps;
1636     int samples;
1637     int bpp;
1638     int extra_sample;
1639     int extra_sample_type;
1640     int reverse_bgr;
1641 };
1642
1643 static const struct tiff_encode_format formats[] = {
1644     {&GUID_WICPixelFormat24bppBGR, 2, 8, 3, 24, 0, 0, 1},
1645     {&GUID_WICPixelFormat24bppRGB, 2, 8, 3, 24, 0, 0, 0},
1646     {&GUID_WICPixelFormatBlackWhite, 1, 1, 1, 1, 0, 0, 0},
1647     {&GUID_WICPixelFormat4bppGray, 1, 4, 1, 4, 0, 0, 0},
1648     {&GUID_WICPixelFormat8bppGray, 1, 8, 1, 8, 0, 0, 0},
1649     {&GUID_WICPixelFormat32bppBGRA, 2, 8, 4, 32, 1, 2, 1},
1650     {&GUID_WICPixelFormat32bppPBGRA, 2, 8, 4, 32, 1, 1, 1},
1651     {&GUID_WICPixelFormat48bppRGB, 2, 16, 3, 48, 0, 0, 0},
1652     {&GUID_WICPixelFormat64bppRGBA, 2, 16, 4, 64, 1, 2, 0},
1653     {&GUID_WICPixelFormat64bppPRGBA, 2, 16, 4, 64, 1, 1, 0},
1654     {&GUID_WICPixelFormat1bppIndexed, 3, 1, 1, 1, 0, 0, 0},
1655     {&GUID_WICPixelFormat4bppIndexed, 3, 4, 1, 4, 0, 0, 0},
1656     {&GUID_WICPixelFormat8bppIndexed, 3, 8, 1, 8, 0, 0, 0},
1657     {0}
1658 };
1659
1660 typedef struct TiffEncoder {
1661     IWICBitmapEncoder IWICBitmapEncoder_iface;
1662     LONG ref;
1663     IStream *stream;
1664     CRITICAL_SECTION lock; /* Must be held when tiff is used or fields below are set */
1665     TIFF *tiff;
1666     BOOL initialized;
1667     BOOL committed;
1668     ULONG num_frames;
1669     ULONG num_frames_committed;
1670 } TiffEncoder;
1671
1672 static inline TiffEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
1673 {
1674     return CONTAINING_RECORD(iface, TiffEncoder, IWICBitmapEncoder_iface);
1675 }
1676
1677 typedef struct TiffFrameEncode {
1678     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
1679     LONG ref;
1680     TiffEncoder *parent;
1681     /* fields below are protected by parent->lock */
1682     BOOL initialized;
1683     BOOL info_written;
1684     BOOL committed;
1685     const struct tiff_encode_format *format;
1686     UINT width, height;
1687     double xres, yres;
1688     UINT lines_written;
1689     WICColor palette[256];
1690     UINT colors;
1691 } TiffFrameEncode;
1692
1693 static inline TiffFrameEncode *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
1694 {
1695     return CONTAINING_RECORD(iface, TiffFrameEncode, IWICBitmapFrameEncode_iface);
1696 }
1697
1698 static HRESULT WINAPI TiffFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
1699     void **ppv)
1700 {
1701     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1702     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1703
1704     if (!ppv) return E_INVALIDARG;
1705
1706     if (IsEqualIID(&IID_IUnknown, iid) ||
1707         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
1708     {
1709         *ppv = &This->IWICBitmapFrameEncode_iface;
1710     }
1711     else
1712     {
1713         *ppv = NULL;
1714         return E_NOINTERFACE;
1715     }
1716
1717     IUnknown_AddRef((IUnknown*)*ppv);
1718     return S_OK;
1719 }
1720
1721 static ULONG WINAPI TiffFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
1722 {
1723     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1724     ULONG ref = InterlockedIncrement(&This->ref);
1725
1726     TRACE("(%p) refcount=%u\n", iface, ref);
1727
1728     return ref;
1729 }
1730
1731 static ULONG WINAPI TiffFrameEncode_Release(IWICBitmapFrameEncode *iface)
1732 {
1733     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1734     ULONG ref = InterlockedDecrement(&This->ref);
1735
1736     TRACE("(%p) refcount=%u\n", iface, ref);
1737
1738     if (ref == 0)
1739     {
1740         IWICBitmapEncoder_Release(&This->parent->IWICBitmapEncoder_iface);
1741         HeapFree(GetProcessHeap(), 0, This);
1742     }
1743
1744     return ref;
1745 }
1746
1747 static HRESULT WINAPI TiffFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
1748     IPropertyBag2 *pIEncoderOptions)
1749 {
1750     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1751     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
1752
1753     EnterCriticalSection(&This->parent->lock);
1754
1755     if (This->initialized)
1756     {
1757         LeaveCriticalSection(&This->parent->lock);
1758         return WINCODEC_ERR_WRONGSTATE;
1759     }
1760
1761     This->initialized = TRUE;
1762
1763     LeaveCriticalSection(&This->parent->lock);
1764
1765     return S_OK;
1766 }
1767
1768 static HRESULT WINAPI TiffFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
1769     UINT uiWidth, UINT uiHeight)
1770 {
1771     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1772     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
1773
1774     EnterCriticalSection(&This->parent->lock);
1775
1776     if (!This->initialized || This->info_written)
1777     {
1778         LeaveCriticalSection(&This->parent->lock);
1779         return WINCODEC_ERR_WRONGSTATE;
1780     }
1781
1782     This->width = uiWidth;
1783     This->height = uiHeight;
1784
1785     LeaveCriticalSection(&This->parent->lock);
1786
1787     return S_OK;
1788 }
1789
1790 static HRESULT WINAPI TiffFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
1791     double dpiX, double dpiY)
1792 {
1793     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1794     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
1795
1796     EnterCriticalSection(&This->parent->lock);
1797
1798     if (!This->initialized || This->info_written)
1799     {
1800         LeaveCriticalSection(&This->parent->lock);
1801         return WINCODEC_ERR_WRONGSTATE;
1802     }
1803
1804     This->xres = dpiX;
1805     This->yres = dpiY;
1806
1807     LeaveCriticalSection(&This->parent->lock);
1808
1809     return S_OK;
1810 }
1811
1812 static HRESULT WINAPI TiffFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
1813     WICPixelFormatGUID *pPixelFormat)
1814 {
1815     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1816     int i;
1817
1818     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
1819
1820     EnterCriticalSection(&This->parent->lock);
1821
1822     if (!This->initialized || This->info_written)
1823     {
1824         LeaveCriticalSection(&This->parent->lock);
1825         return WINCODEC_ERR_WRONGSTATE;
1826     }
1827
1828     if (IsEqualGUID(pPixelFormat, &GUID_WICPixelFormat2bppIndexed))
1829         *pPixelFormat = GUID_WICPixelFormat4bppIndexed;
1830
1831     for (i=0; formats[i].guid; i++)
1832     {
1833         if (IsEqualGUID(formats[i].guid, pPixelFormat))
1834             break;
1835     }
1836
1837     if (!formats[i].guid) i = 0;
1838
1839     This->format = &formats[i];
1840     memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
1841
1842     LeaveCriticalSection(&This->parent->lock);
1843
1844     return S_OK;
1845 }
1846
1847 static HRESULT WINAPI TiffFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
1848     UINT cCount, IWICColorContext **ppIColorContext)
1849 {
1850     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1851     return E_NOTIMPL;
1852 }
1853
1854 static HRESULT WINAPI TiffFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
1855     IWICPalette *palette)
1856 {
1857     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1858     HRESULT hr;
1859
1860     TRACE("(%p,%p)\n", iface, palette);
1861
1862     if (!palette) return E_INVALIDARG;
1863
1864     EnterCriticalSection(&This->parent->lock);
1865
1866     if (This->initialized)
1867         hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
1868     else
1869         hr = WINCODEC_ERR_NOTINITIALIZED;
1870
1871     LeaveCriticalSection(&This->parent->lock);
1872     return hr;
1873 }
1874
1875 static HRESULT WINAPI TiffFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
1876     IWICBitmapSource *pIThumbnail)
1877 {
1878     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
1879     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1880 }
1881
1882 static HRESULT WINAPI TiffFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
1883     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
1884 {
1885     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1886     BYTE *row_data, *swapped_data = NULL;
1887     UINT i, j, line_size;
1888
1889     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
1890
1891     EnterCriticalSection(&This->parent->lock);
1892
1893     if (!This->initialized || !This->width || !This->height || !This->format)
1894     {
1895         LeaveCriticalSection(&This->parent->lock);
1896         return WINCODEC_ERR_WRONGSTATE;
1897     }
1898
1899     if (lineCount == 0 || lineCount + This->lines_written > This->height)
1900     {
1901         LeaveCriticalSection(&This->parent->lock);
1902         return E_INVALIDARG;
1903     }
1904
1905     line_size = ((This->width * This->format->bpp)+7)/8;
1906
1907     if (This->format->reverse_bgr)
1908     {
1909         swapped_data = HeapAlloc(GetProcessHeap(), 0, line_size);
1910         if (!swapped_data)
1911         {
1912             LeaveCriticalSection(&This->parent->lock);
1913             return E_OUTOFMEMORY;
1914         }
1915     }
1916
1917     if (!This->info_written)
1918     {
1919         pTIFFSetField(This->parent->tiff, TIFFTAG_PHOTOMETRIC, (uint16)This->format->photometric);
1920         pTIFFSetField(This->parent->tiff, TIFFTAG_PLANARCONFIG, (uint16)1);
1921         pTIFFSetField(This->parent->tiff, TIFFTAG_BITSPERSAMPLE, (uint16)This->format->bps);
1922         pTIFFSetField(This->parent->tiff, TIFFTAG_SAMPLESPERPIXEL, (uint16)This->format->samples);
1923
1924         if (This->format->extra_sample)
1925         {
1926             uint16 extra_samples;
1927             extra_samples = This->format->extra_sample_type;
1928
1929             pTIFFSetField(This->parent->tiff, TIFFTAG_EXTRASAMPLES, (uint16)1, &extra_samples);
1930         }
1931
1932         pTIFFSetField(This->parent->tiff, TIFFTAG_IMAGEWIDTH, (uint32)This->width);
1933         pTIFFSetField(This->parent->tiff, TIFFTAG_IMAGELENGTH, (uint32)This->height);
1934
1935         if (This->xres != 0.0 && This->yres != 0.0)
1936         {
1937             pTIFFSetField(This->parent->tiff, TIFFTAG_RESOLUTIONUNIT, (uint16)2); /* Inch */
1938             pTIFFSetField(This->parent->tiff, TIFFTAG_XRESOLUTION, (float)This->xres);
1939             pTIFFSetField(This->parent->tiff, TIFFTAG_YRESOLUTION, (float)This->yres);
1940         }
1941
1942         if (This->format->bpp <= 8 && This->colors && !IsEqualGUID(This->format->guid, &GUID_WICPixelFormatBlackWhite))
1943         {
1944             uint16 red[256], green[256], blue[256];
1945             UINT i;
1946
1947             for (i = 0; i < This->colors; i++)
1948             {
1949                 red[i] = (This->palette[i] >> 8) & 0xff00;
1950                 green[i] = This->palette[i] & 0xff00;
1951                 blue[i] = (This->palette[i] << 8) & 0xff00;
1952             }
1953
1954             pTIFFSetField(This->parent->tiff, TIFFTAG_COLORMAP, red, green, blue);
1955         }
1956
1957         This->info_written = TRUE;
1958     }
1959
1960     for (i=0; i<lineCount; i++)
1961     {
1962         row_data = pbPixels + i * cbStride;
1963
1964         if (This->format->reverse_bgr && This->format->bps == 8)
1965         {
1966             memcpy(swapped_data, row_data, line_size);
1967             for (j=0; j<line_size; j += This->format->samples)
1968             {
1969                 BYTE temp;
1970                 temp = swapped_data[j];
1971                 swapped_data[j] = swapped_data[j+2];
1972                 swapped_data[j+2] = temp;
1973             }
1974             row_data = swapped_data;
1975         }
1976
1977         pTIFFWriteScanline(This->parent->tiff, (tdata_t)row_data, i+This->lines_written, 0);
1978     }
1979
1980     This->lines_written += lineCount;
1981
1982     LeaveCriticalSection(&This->parent->lock);
1983
1984     HeapFree(GetProcessHeap(), 0, swapped_data);
1985
1986     return S_OK;
1987 }
1988
1989 static HRESULT WINAPI TiffFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
1990     IWICBitmapSource *pIBitmapSource, WICRect *prc)
1991 {
1992     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1993     HRESULT hr;
1994
1995     TRACE("(%p,%p,%s)\n", iface, pIBitmapSource, debug_wic_rect(prc));
1996
1997     if (!This->initialized)
1998         return WINCODEC_ERR_WRONGSTATE;
1999
2000     hr = configure_write_source(iface, pIBitmapSource, prc,
2001         This->format ? This->format->guid : NULL, This->width, This->height,
2002         This->xres, This->yres);
2003
2004     if (SUCCEEDED(hr))
2005     {
2006         hr = write_source(iface, pIBitmapSource, prc,
2007             This->format->guid, This->format->bpp,
2008             !This->colors && This->format->bpp <= 8 && !IsEqualGUID(This->format->guid, &GUID_WICPixelFormatBlackWhite),
2009             This->width, This->height);
2010     }
2011
2012     return hr;
2013 }
2014
2015 static HRESULT WINAPI TiffFrameEncode_Commit(IWICBitmapFrameEncode *iface)
2016 {
2017     TiffFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
2018
2019     TRACE("(%p)\n", iface);
2020
2021     EnterCriticalSection(&This->parent->lock);
2022
2023     if (!This->info_written || This->lines_written != This->height || This->committed)
2024     {
2025         LeaveCriticalSection(&This->parent->lock);
2026         return WINCODEC_ERR_WRONGSTATE;
2027     }
2028
2029     /* libtiff will commit the data when creating a new frame or closing the file */
2030
2031     This->committed = TRUE;
2032     This->parent->num_frames_committed++;
2033
2034     LeaveCriticalSection(&This->parent->lock);
2035
2036     return S_OK;
2037 }
2038
2039 static HRESULT WINAPI TiffFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
2040     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
2041 {
2042     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
2043     return E_NOTIMPL;
2044 }
2045
2046 static const IWICBitmapFrameEncodeVtbl TiffFrameEncode_Vtbl = {
2047     TiffFrameEncode_QueryInterface,
2048     TiffFrameEncode_AddRef,
2049     TiffFrameEncode_Release,
2050     TiffFrameEncode_Initialize,
2051     TiffFrameEncode_SetSize,
2052     TiffFrameEncode_SetResolution,
2053     TiffFrameEncode_SetPixelFormat,
2054     TiffFrameEncode_SetColorContexts,
2055     TiffFrameEncode_SetPalette,
2056     TiffFrameEncode_SetThumbnail,
2057     TiffFrameEncode_WritePixels,
2058     TiffFrameEncode_WriteSource,
2059     TiffFrameEncode_Commit,
2060     TiffFrameEncode_GetMetadataQueryWriter
2061 };
2062
2063 static HRESULT WINAPI TiffEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
2064     void **ppv)
2065 {
2066     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2067     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
2068
2069     if (!ppv) return E_INVALIDARG;
2070
2071     if (IsEqualIID(&IID_IUnknown, iid) ||
2072         IsEqualIID(&IID_IWICBitmapEncoder, iid))
2073     {
2074         *ppv = &This->IWICBitmapEncoder_iface;
2075     }
2076     else
2077     {
2078         *ppv = NULL;
2079         return E_NOINTERFACE;
2080     }
2081
2082     IUnknown_AddRef((IUnknown*)*ppv);
2083     return S_OK;
2084 }
2085
2086 static ULONG WINAPI TiffEncoder_AddRef(IWICBitmapEncoder *iface)
2087 {
2088     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2089     ULONG ref = InterlockedIncrement(&This->ref);
2090
2091     TRACE("(%p) refcount=%u\n", iface, ref);
2092
2093     return ref;
2094 }
2095
2096 static ULONG WINAPI TiffEncoder_Release(IWICBitmapEncoder *iface)
2097 {
2098     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2099     ULONG ref = InterlockedDecrement(&This->ref);
2100
2101     TRACE("(%p) refcount=%u\n", iface, ref);
2102
2103     if (ref == 0)
2104     {
2105         if (This->tiff) pTIFFClose(This->tiff);
2106         if (This->stream) IStream_Release(This->stream);
2107         This->lock.DebugInfo->Spare[0] = 0;
2108         DeleteCriticalSection(&This->lock);
2109         HeapFree(GetProcessHeap(), 0, This);
2110     }
2111
2112     return ref;
2113 }
2114
2115 static HRESULT WINAPI TiffEncoder_Initialize(IWICBitmapEncoder *iface,
2116     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
2117 {
2118     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2119     TIFF *tiff;
2120     HRESULT hr=S_OK;
2121
2122     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
2123
2124     EnterCriticalSection(&This->lock);
2125
2126     if (This->initialized || This->committed)
2127     {
2128         hr = WINCODEC_ERR_WRONGSTATE;
2129         goto exit;
2130     }
2131
2132     tiff = tiff_open_stream(pIStream, "w");
2133
2134     if (!tiff)
2135     {
2136         hr = E_FAIL;
2137         goto exit;
2138     }
2139
2140     This->tiff = tiff;
2141     This->stream = pIStream;
2142     IStream_AddRef(pIStream);
2143     This->initialized = TRUE;
2144
2145 exit:
2146     LeaveCriticalSection(&This->lock);
2147     return hr;
2148 }
2149
2150 static HRESULT WINAPI TiffEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
2151     GUID *pguidContainerFormat)
2152 {
2153     TRACE("(%p,%p)\n", iface, pguidContainerFormat);
2154
2155     if (!pguidContainerFormat)
2156         return E_INVALIDARG;
2157
2158     memcpy(pguidContainerFormat, &GUID_ContainerFormatTiff, sizeof(GUID));
2159     return S_OK;
2160 }
2161
2162 static HRESULT WINAPI TiffEncoder_GetEncoderInfo(IWICBitmapEncoder *iface, IWICBitmapEncoderInfo **info)
2163 {
2164     IWICComponentInfo *comp_info;
2165     HRESULT hr;
2166
2167     TRACE("%p,%p\n", iface, info);
2168
2169     if (!info) return E_INVALIDARG;
2170
2171     hr = CreateComponentInfo(&CLSID_WICTiffEncoder, &comp_info);
2172     if (hr == S_OK)
2173     {
2174         hr = IWICComponentInfo_QueryInterface(comp_info, &IID_IWICBitmapEncoderInfo, (void **)info);
2175         IWICComponentInfo_Release(comp_info);
2176     }
2177     return hr;
2178 }
2179
2180 static HRESULT WINAPI TiffEncoder_SetColorContexts(IWICBitmapEncoder *iface,
2181     UINT cCount, IWICColorContext **ppIColorContext)
2182 {
2183     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
2184     return E_NOTIMPL;
2185 }
2186
2187 static HRESULT WINAPI TiffEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *palette)
2188 {
2189     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2190     HRESULT hr;
2191
2192     TRACE("(%p,%p)\n", iface, palette);
2193
2194     EnterCriticalSection(&This->lock);
2195
2196     hr = This->stream ? WINCODEC_ERR_UNSUPPORTEDOPERATION : WINCODEC_ERR_NOTINITIALIZED;
2197
2198     LeaveCriticalSection(&This->lock);
2199
2200     return hr;
2201 }
2202
2203 static HRESULT WINAPI TiffEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
2204 {
2205     TRACE("(%p,%p)\n", iface, pIThumbnail);
2206     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
2207 }
2208
2209 static HRESULT WINAPI TiffEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
2210 {
2211     TRACE("(%p,%p)\n", iface, pIPreview);
2212     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
2213 }
2214
2215 static HRESULT WINAPI TiffEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
2216     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
2217 {
2218     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2219     TiffFrameEncode *result;
2220     static const PROPBAG2 opts[2] =
2221     {
2222         { PROPBAG2_TYPE_DATA, VT_UI1, 0, 0, (LPOLESTR)wszTiffCompressionMethod },
2223         { PROPBAG2_TYPE_DATA, VT_R4,  0, 0, (LPOLESTR)wszCompressionQuality },
2224     };
2225     HRESULT hr=S_OK;
2226
2227     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
2228
2229     EnterCriticalSection(&This->lock);
2230
2231     if (!This->initialized || This->committed)
2232     {
2233         hr = WINCODEC_ERR_WRONGSTATE;
2234     }
2235     else if (This->num_frames != This->num_frames_committed)
2236     {
2237         FIXME("New frame created before previous frame was committed\n");
2238         hr = E_FAIL;
2239     }
2240
2241     if (ppIEncoderOptions && SUCCEEDED(hr))
2242     {
2243         hr = CreatePropertyBag2(opts, ARRAY_SIZE(opts), ppIEncoderOptions);
2244         if (SUCCEEDED(hr))
2245         {
2246             VARIANT v;
2247             VariantInit(&v);
2248             V_VT(&v) = VT_UI1;
2249             V_UI1(&v) = WICTiffCompressionDontCare;
2250             hr = IPropertyBag2_Write(*ppIEncoderOptions, 1, (PROPBAG2 *)opts, &v);
2251             VariantClear(&v);
2252             if (FAILED(hr))
2253             {
2254                 IPropertyBag2_Release(*ppIEncoderOptions);
2255                 *ppIEncoderOptions = NULL;
2256             }
2257         }
2258     }
2259
2260     if (SUCCEEDED(hr))
2261     {
2262         result = HeapAlloc(GetProcessHeap(), 0, sizeof(*result));
2263
2264         if (result)
2265         {
2266             result->IWICBitmapFrameEncode_iface.lpVtbl = &TiffFrameEncode_Vtbl;
2267             result->ref = 1;
2268             result->parent = This;
2269             result->initialized = FALSE;
2270             result->info_written = FALSE;
2271             result->committed = FALSE;
2272             result->format = NULL;
2273             result->width = 0;
2274             result->height = 0;
2275             result->xres = 0.0;
2276             result->yres = 0.0;
2277             result->lines_written = 0;
2278             result->colors = 0;
2279
2280             IWICBitmapEncoder_AddRef(iface);
2281             *ppIFrameEncode = &result->IWICBitmapFrameEncode_iface;
2282
2283             if (This->num_frames != 0)
2284                 pTIFFWriteDirectory(This->tiff);
2285
2286             This->num_frames++;
2287         }
2288         else
2289             hr = E_OUTOFMEMORY;
2290
2291         if (FAILED(hr))
2292         {
2293             IPropertyBag2_Release(*ppIEncoderOptions);
2294             *ppIEncoderOptions = NULL;
2295         }
2296     }
2297
2298     LeaveCriticalSection(&This->lock);
2299
2300     return hr;
2301 }
2302
2303 static HRESULT WINAPI TiffEncoder_Commit(IWICBitmapEncoder *iface)
2304 {
2305     TiffEncoder *This = impl_from_IWICBitmapEncoder(iface);
2306
2307     TRACE("(%p)\n", iface);
2308
2309     EnterCriticalSection(&This->lock);
2310
2311     if (!This->initialized || This->committed)
2312     {
2313         LeaveCriticalSection(&This->lock);
2314         return WINCODEC_ERR_WRONGSTATE;
2315     }
2316
2317     pTIFFClose(This->tiff);
2318     IStream_Release(This->stream);
2319     This->stream = NULL;
2320     This->tiff = NULL;
2321
2322     This->committed = TRUE;
2323
2324     LeaveCriticalSection(&This->lock);
2325
2326     return S_OK;
2327 }
2328
2329 static HRESULT WINAPI TiffEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
2330     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
2331 {
2332     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
2333     return E_NOTIMPL;
2334 }
2335
2336 static const IWICBitmapEncoderVtbl TiffEncoder_Vtbl = {
2337     TiffEncoder_QueryInterface,
2338     TiffEncoder_AddRef,
2339     TiffEncoder_Release,
2340     TiffEncoder_Initialize,
2341     TiffEncoder_GetContainerFormat,
2342     TiffEncoder_GetEncoderInfo,
2343     TiffEncoder_SetColorContexts,
2344     TiffEncoder_SetPalette,
2345     TiffEncoder_SetThumbnail,
2346     TiffEncoder_SetPreview,
2347     TiffEncoder_CreateNewFrame,
2348     TiffEncoder_Commit,
2349     TiffEncoder_GetMetadataQueryWriter
2350 };
2351
2352 HRESULT TiffEncoder_CreateInstance(REFIID iid, void** ppv)
2353 {
2354     TiffEncoder *This;
2355     HRESULT ret;
2356
2357     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
2358
2359     *ppv = NULL;
2360
2361     if (!load_libtiff())
2362     {
2363         ERR("Failed writing TIFF because unable to load %s\n",SONAME_LIBTIFF);
2364         return E_FAIL;
2365     }
2366
2367     This = HeapAlloc(GetProcessHeap(), 0, sizeof(TiffEncoder));
2368     if (!This) return E_OUTOFMEMORY;
2369
2370     This->IWICBitmapEncoder_iface.lpVtbl = &TiffEncoder_Vtbl;
2371     This->ref = 1;
2372     This->stream = NULL;
2373     InitializeCriticalSection(&This->lock);
2374     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TiffEncoder.lock");
2375     This->tiff = NULL;
2376     This->initialized = FALSE;
2377     This->num_frames = 0;
2378     This->num_frames_committed = 0;
2379     This->committed = FALSE;
2380
2381     ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
2382     IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
2383
2384     return ret;
2385 }
2386
2387 #else /* !SONAME_LIBTIFF */
2388
2389 HRESULT TiffDecoder_CreateInstance(REFIID iid, void** ppv)
2390 {
2391     ERR("Trying to load TIFF picture, but Wine was compiled without TIFF support.\n");
2392     return E_FAIL;
2393 }
2394
2395 HRESULT TiffEncoder_CreateInstance(REFIID iid, void** ppv)
2396 {
2397     ERR("Trying to save TIFF picture, but Wine was compiled without TIFF support.\n");
2398     return E_FAIL;
2399 }
2400
2401 #endif