dlls/windowscodecs/tiffformat.c

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