dlls/windowscodecs/icoformat.c

   1 /*
   2  * Copyright 2009 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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "objbase.h"
  27
  28 #include "wincodecs_private.h"
  29
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  33
  34 #include "pshpack1.h"
  35
  36 typedef struct {
  37     BYTE bWidth;
  38     BYTE bHeight;
  39     BYTE bColorCount;
  40     BYTE bReserved;
  41     WORD wPlanes;
  42     WORD wBitCount;
  43     DWORD dwDIBSize;
  44     DWORD dwDIBOffset;
  45 } ICONDIRENTRY;
  46
  47 typedef struct
  48 {
  49     WORD idReserved;
  50     WORD idType;
  51     WORD idCount;
  52 } ICONHEADER;
  53
  54 #include "poppack.h"
  55
  56 typedef struct {
  57     IWICBitmapDecoder IWICBitmapDecoder_iface;
  58     LONG ref;
  59     BOOL initialized;
  60     IStream *stream;
  61     ICONHEADER header;
  62     CRITICAL_SECTION lock; /* must be held when accessing stream */
  63 } IcoDecoder;
  64
  65 typedef struct {
  66     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
  67     LONG ref;
  68     UINT width, height;
  69     double dpiX, dpiY;
  70     BYTE *bits;
  71 } IcoFrameDecode;
  72
  73 static inline IcoDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
  74 {
  75     return CONTAINING_RECORD(iface, IcoDecoder, IWICBitmapDecoder_iface);
  76 }
  77
  78 static inline IcoFrameDecode *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
  79 {
  80     return CONTAINING_RECORD(iface, IcoFrameDecode, IWICBitmapFrameDecode_iface);
  81 }
  82
  83 static HRESULT WINAPI IcoFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
  84     void **ppv)
  85 {
  86     IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
  87     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  88
  89     if (!ppv) return E_INVALIDARG;
  90
  91     if (IsEqualIID(&IID_IUnknown, iid) ||
  92         IsEqualIID(&IID_IWICBitmapSource, iid) ||
  93         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
  94     {
  95         *ppv = &This->IWICBitmapFrameDecode_iface;
  96     }
  97     else
  98     {
  99         *ppv = NULL;
 100         return E_NOINTERFACE;
 101     }
 102
 103     IUnknown_AddRef((IUnknown*)*ppv);
 104     return S_OK;
 105 }
 106
 107 static ULONG WINAPI IcoFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
 108 {
 109     IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 110     ULONG ref = InterlockedIncrement(&This->ref);
 111
 112     TRACE("(%p) refcount=%lu\n", iface, ref);
 113
 114     return ref;
 115 }
 116
 117 static ULONG WINAPI IcoFrameDecode_Release(IWICBitmapFrameDecode *iface)
 118 {
 119     IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 120     ULONG ref = InterlockedDecrement(&This->ref);
 121
 122     TRACE("(%p) refcount=%lu\n", iface, ref);
 123
 124     if (ref == 0)
 125     {
 126         HeapFree(GetProcessHeap(), 0, This->bits);
 127         HeapFree(GetProcessHeap(), 0, This);
 128     }
 129
 130     return ref;
 131 }
 132
 133 static HRESULT WINAPI IcoFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
 134     UINT *puiWidth, UINT *puiHeight)
 135 {
 136     IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 137
 138     *puiWidth = This->width;
 139     *puiHeight = This->height;
 140
 141     TRACE("(%p) -> (%i,%i)\n", iface, *puiWidth, *puiHeight);
 142
 143     return S_OK;
 144 }
 145
 146 static HRESULT WINAPI IcoFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
 147     WICPixelFormatGUID *pPixelFormat)
 148 {
 149     memcpy(pPixelFormat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
 150     return S_OK;
 151 }
 152
 153 static HRESULT WINAPI IcoFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
 154     double *pDpiX, double *pDpiY)
 155 {
 156     IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 157
 158     *pDpiX = This->dpiX;
 159     *pDpiY = This->dpiY;
 160
 161     TRACE("(%p) -> (%f,%f)\n", iface, *pDpiX, *pDpiY);
 162
 163     return S_OK;
 164 }
 165
 166 static HRESULT WINAPI IcoFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
 167     IWICPalette *pIPalette)
 168 {
 169     TRACE("(%p,%p)\n", iface, pIPalette);
 170     return WINCODEC_ERR_PALETTEUNAVAILABLE;
 171 }
 172
 173 static HRESULT WINAPI IcoFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
 174     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 175 {
 176     IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 177     TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 178
 179     return copy_pixels(32, This->bits, This->width, This->height, This->width * 4,
 180         prc, cbStride, cbBufferSize, pbBuffer);
 181 }
 182
 183 static HRESULT WINAPI IcoFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
 184     IWICMetadataQueryReader **ppIMetadataQueryReader)
 185 {
 186     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
 187     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 188 }
 189
 190 static HRESULT WINAPI IcoFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
 191     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 192 {
 193     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
 194     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 195 }
 196
 197 static HRESULT WINAPI IcoFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
 198     IWICBitmapSource **ppIThumbnail)
 199 {
 200     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 201     return IWICBitmapFrameDecode_QueryInterface(iface, &IID_IWICBitmapSource, (void **)ppIThumbnail);
 202 }
 203
 204 static const IWICBitmapFrameDecodeVtbl IcoFrameDecode_Vtbl = {
 205     IcoFrameDecode_QueryInterface,
 206     IcoFrameDecode_AddRef,
 207     IcoFrameDecode_Release,
 208     IcoFrameDecode_GetSize,
 209     IcoFrameDecode_GetPixelFormat,
 210     IcoFrameDecode_GetResolution,
 211     IcoFrameDecode_CopyPalette,
 212     IcoFrameDecode_CopyPixels,
 213     IcoFrameDecode_GetMetadataQueryReader,
 214     IcoFrameDecode_GetColorContexts,
 215     IcoFrameDecode_GetThumbnail
 216 };
 217
 218 static inline void pixel_set_trans(DWORD* pixel, BOOL transparent)
 219 {
 220     if (transparent) *pixel = 0;
 221     else *pixel |= 0xff000000;
 222 }
 223
 224 static HRESULT ReadIcoDib(IStream *stream, IcoFrameDecode *result)
 225 {
 226     HRESULT hr;
 227     BmpDecoder *bmp_decoder;
 228     IWICBitmapDecoder *decoder;
 229     IWICBitmapFrameDecode *framedecode;
 230     WICPixelFormatGUID pixelformat;
 231     IWICBitmapSource *source;
 232     BOOL has_alpha=FALSE; /* if TRUE, alpha data might be in the image data */
 233     WICRect rc;
 234
 235     hr = IcoDibDecoder_CreateInstance(&bmp_decoder);
 236     if (SUCCEEDED(hr))
 237     {
 238         BmpDecoder_GetWICDecoder(bmp_decoder, &decoder);
 239         hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
 240
 241         if (SUCCEEDED(hr))
 242             hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 243
 244         if (SUCCEEDED(hr))
 245         {
 246             hr = IWICBitmapFrameDecode_GetSize(framedecode, &result->width, &result->height);
 247
 248             if (SUCCEEDED(hr))
 249             {
 250                 result->bits = HeapAlloc(GetProcessHeap(), 0, result->width * result->height * 4);
 251                 if (!result->bits) hr = E_OUTOFMEMORY;
 252             }
 253
 254             if (SUCCEEDED(hr))
 255                 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &pixelformat);
 256
 257             if (IsEqualGUID(&pixelformat, &GUID_WICPixelFormat32bppBGR) ||
 258                 IsEqualGUID(&pixelformat, &GUID_WICPixelFormat32bppBGRA))
 259             {
 260                 source = (IWICBitmapSource*)framedecode;
 261                 IWICBitmapSource_AddRef(source);
 262                 has_alpha = TRUE;
 263             }
 264             else
 265             {
 266                 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA,
 267                     (IWICBitmapSource*)framedecode, &source);
 268                 has_alpha = FALSE;
 269             }
 270
 271             if (SUCCEEDED(hr))
 272             {
 273                 rc.X = 0;
 274                 rc.Y = 0;
 275                 rc.Width = result->width;
 276                 rc.Height = result->height;
 277                 hr = IWICBitmapSource_CopyPixels(source, &rc, result->width * 4,
 278                     result->width * result->height * 4, result->bits);
 279
 280                 IWICBitmapSource_Release(source);
 281             }
 282
 283             if (SUCCEEDED(hr))
 284                 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &result->dpiX, &result->dpiY);
 285
 286             IWICBitmapFrameDecode_Release(framedecode);
 287         }
 288
 289         if (SUCCEEDED(hr) && has_alpha)
 290         {
 291             /* If the alpha channel is fully transparent, we should ignore it. */
 292             int nonzero_alpha = 0;
 293             UINT i;
 294
 295             for (i=0; i<(result->height*result->width); i++)
 296             {
 297                 if (result->bits[i*4+3] != 0)
 298                 {
 299                     nonzero_alpha = 1;
 300                     break;
 301                 }
 302             }
 303
 304             if (!nonzero_alpha)
 305             {
 306                 for (i=0; i<(result->height*result->width); i++)
 307                     result->bits[i*4+3] = 0xff;
 308
 309                 has_alpha = FALSE;
 310             }
 311         }
 312
 313         if (SUCCEEDED(hr) && !has_alpha)
 314         {
 315             /* set alpha data based on the AND mask */
 316             UINT andBytesPerRow = (result->width+31)/32*4;
 317             UINT andBytes = andBytesPerRow * result->height;
 318             INT andStride;
 319             BYTE *tempdata=NULL;
 320             BYTE *andRow;
 321             BYTE *bitsRow;
 322             UINT bitsStride = result->width * 4;
 323             UINT x, y;
 324             ULONG offset;
 325             ULONG bytesread;
 326             LARGE_INTEGER seek;
 327             int topdown;
 328
 329             BmpDecoder_FindIconMask(bmp_decoder, &offset, &topdown);
 330
 331             if (offset)
 332             {
 333                 seek.QuadPart = offset;
 334
 335                 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, 0);
 336
 337                 if (SUCCEEDED(hr))
 338                 {
 339                     tempdata = HeapAlloc(GetProcessHeap(), 0, andBytes);
 340                     if (!tempdata) hr = E_OUTOFMEMORY;
 341                 }
 342
 343                 if (SUCCEEDED(hr))
 344                     hr = IStream_Read(stream, tempdata, andBytes, &bytesread);
 345
 346                 if (SUCCEEDED(hr) && bytesread == andBytes)
 347                 {
 348                     if (topdown)
 349                     {
 350                         andStride = andBytesPerRow;
 351                         andRow = tempdata;
 352                     }
 353                     else
 354                     {
 355                         andStride = -andBytesPerRow;
 356                         andRow = tempdata + (result->height-1)*andBytesPerRow;
 357                     }
 358
 359                     bitsRow = result->bits;
 360                     for (y=0; y<result->height; y++) {
 361                         BYTE *andByte=andRow;
 362                         DWORD *bitsPixel=(DWORD*)bitsRow;
 363                         for (x=0; x<result->width; x+=8) {
 364                             BYTE andVal=*andByte++;
 365                             pixel_set_trans(bitsPixel++, andVal>>7&1);
 366                             if (x+1 < result->width) pixel_set_trans(bitsPixel++, andVal>>6&1);
 367                             if (x+2 < result->width) pixel_set_trans(bitsPixel++, andVal>>5&1);
 368                             if (x+3 < result->width) pixel_set_trans(bitsPixel++, andVal>>4&1);
 369                             if (x+4 < result->width) pixel_set_trans(bitsPixel++, andVal>>3&1);
 370                             if (x+5 < result->width) pixel_set_trans(bitsPixel++, andVal>>2&1);
 371                             if (x+6 < result->width) pixel_set_trans(bitsPixel++, andVal>>1&1);
 372                             if (x+7 < result->width) pixel_set_trans(bitsPixel++, andVal&1);
 373                         }
 374                         andRow += andStride;
 375                         bitsRow += bitsStride;
 376                     }
 377                 }
 378
 379                 HeapFree(GetProcessHeap(), 0, tempdata);
 380             }
 381         }
 382
 383         IWICBitmapDecoder_Release(decoder);
 384     }
 385
 386     return hr;
 387 }
 388
 389 static HRESULT ReadIcoPng(IStream *stream, IcoFrameDecode *result)
 390 {
 391     IWICBitmapDecoder *decoder = NULL;
 392     IWICBitmapFrameDecode *sourceFrame = NULL;
 393     IWICBitmapSource *sourceBitmap = NULL;
 394     WICRect rect;
 395     HRESULT hr;
 396
 397     hr = PngDecoder_CreateInstance(&IID_IWICBitmapDecoder, (void**)&decoder);
 398     if (FAILED(hr))
 399         goto end;
 400     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
 401     if (FAILED(hr))
 402         goto end;
 403     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &sourceFrame);
 404     if (FAILED(hr))
 405         goto end;
 406     hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)sourceFrame, &sourceBitmap);
 407     if (FAILED(hr))
 408         goto end;
 409     hr = IWICBitmapFrameDecode_GetSize(sourceFrame, &result->width, &result->height);
 410     if (FAILED(hr))
 411         goto end;
 412     hr = IWICBitmapFrameDecode_GetResolution(sourceFrame, &result->dpiX, &result->dpiY);
 413     if (FAILED(hr))
 414         goto end;
 415     result->bits = HeapAlloc(GetProcessHeap(), 0, 4 * result->width * result->height);
 416     if (result->bits == NULL)
 417     {
 418         hr = E_OUTOFMEMORY;
 419         goto end;
 420     }
 421     rect.X = 0;
 422     rect.Y = 0;
 423     rect.Width = result->width;
 424     rect.Height = result->height;
 425     hr = IWICBitmapSource_CopyPixels(sourceBitmap, &rect, 4*result->width,
 426                                      4*result->width*result->height, result->bits);
 427
 428 end:
 429     if (decoder != NULL)
 430         IWICBitmapDecoder_Release(decoder);
 431     if (sourceFrame != NULL)
 432         IWICBitmapFrameDecode_Release(sourceFrame);
 433     if (sourceBitmap != NULL)
 434         IWICBitmapSource_Release(sourceBitmap);
 435     return hr;
 436 }
 437
 438 static HRESULT WINAPI IcoDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 439     void **ppv)
 440 {
 441     IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
 442     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 443
 444     if (!ppv) return E_INVALIDARG;
 445
 446     if (IsEqualIID(&IID_IUnknown, iid) ||
 447         IsEqualIID(&IID_IWICBitmapDecoder, iid))
 448     {
 449         *ppv = &This->IWICBitmapDecoder_iface;
 450     }
 451     else
 452     {
 453         *ppv = NULL;
 454         return E_NOINTERFACE;
 455     }
 456
 457     IUnknown_AddRef((IUnknown*)*ppv);
 458     return S_OK;
 459 }
 460
 461 static ULONG WINAPI IcoDecoder_AddRef(IWICBitmapDecoder *iface)
 462 {
 463     IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
 464     ULONG ref = InterlockedIncrement(&This->ref);
 465
 466     TRACE("(%p) refcount=%lu\n", iface, ref);
 467
 468     return ref;
 469 }
 470
 471 static ULONG WINAPI IcoDecoder_Release(IWICBitmapDecoder *iface)
 472 {
 473     IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
 474     ULONG ref = InterlockedDecrement(&This->ref);
 475
 476     TRACE("(%p) refcount=%lu\n", iface, ref);
 477
 478     if (ref == 0)
 479     {
 480         This->lock.DebugInfo->Spare[0] = 0;
 481         DeleteCriticalSection(&This->lock);
 482         if (This->stream) IStream_Release(This->stream);
 483         HeapFree(GetProcessHeap(), 0, This);
 484     }
 485
 486     return ref;
 487 }
 488
 489 static HRESULT WINAPI IcoDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
 490     DWORD *capability)
 491 {
 492     HRESULT hr;
 493
 494     TRACE("(%p,%p,%p)\n", iface, stream, capability);
 495
 496     if (!stream || !capability) return E_INVALIDARG;
 497
 498     hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
 499     if (hr != S_OK) return hr;
 500
 501     *capability = WICBitmapDecoderCapabilityCanDecodeAllImages;
 502     return S_OK;
 503 }
 504
 505 static HRESULT WINAPI IcoDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 506     WICDecodeOptions cacheOptions)
 507 {
 508     IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
 509     LARGE_INTEGER seek;
 510     HRESULT hr;
 511     ULONG bytesread;
 512     STATSTG statstg;
 513     unsigned int i;
 514
 515     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 516
 517     EnterCriticalSection(&This->lock);
 518
 519     if (This->initialized)
 520     {
 521         hr = WINCODEC_ERR_WRONGSTATE;
 522         goto end;
 523     }
 524
 525     seek.QuadPart = 0;
 526     hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 527     if (FAILED(hr)) goto end;
 528
 529     hr = IStream_Read(pIStream, &This->header, sizeof(ICONHEADER), &bytesread);
 530     if (FAILED(hr)) goto end;
 531
 532     if (bytesread != sizeof(ICONHEADER))
 533     {
 534         hr = WINCODEC_ERR_STREAMREAD;
 535         goto end;
 536     }
 537
 538     if (This->header.idReserved != 0 ||
 539         This->header.idType != 1)
 540     {
 541         hr = E_FAIL;
 542         goto end;
 543     }
 544
 545     hr = IStream_Stat(pIStream, &statstg, STATFLAG_NONAME);
 546     if (FAILED(hr))
 547     {
 548         WARN("Stat() failed, hr %#lx.\n", hr);
 549         goto end;
 550     }
 551
 552     for (i = 0; i < This->header.idCount; i++)
 553     {
 554         ICONDIRENTRY direntry;
 555
 556         hr = IStream_Read(pIStream, &direntry, sizeof(direntry), &bytesread);
 557         if (FAILED(hr)) goto end;
 558
 559         if (bytesread != sizeof(direntry) || (direntry.dwDIBSize + direntry.dwDIBOffset > statstg.cbSize.QuadPart))
 560         {
 561             hr = WINCODEC_ERR_BADIMAGE;
 562             goto end;
 563         }
 564     }
 565
 566     This->initialized = TRUE;
 567     This->stream = pIStream;
 568     IStream_AddRef(pIStream);
 569
 570 end:
 571
 572     LeaveCriticalSection(&This->lock);
 573
 574     return hr;
 575 }
 576
 577 static HRESULT WINAPI IcoDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 578     GUID *pguidContainerFormat)
 579 {
 580     memcpy(pguidContainerFormat, &GUID_ContainerFormatIco, sizeof(GUID));
 581     return S_OK;
 582 }
 583
 584 static HRESULT WINAPI IcoDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 585     IWICBitmapDecoderInfo **ppIDecoderInfo)
 586 {
 587     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 588
 589     return get_decoder_info(&CLSID_WICIcoDecoder, ppIDecoderInfo);
 590 }
 591
 592 static HRESULT WINAPI IcoDecoder_CopyPalette(IWICBitmapDecoder *iface,
 593     IWICPalette *pIPalette)
 594 {
 595     TRACE("(%p,%p)\n", iface, pIPalette);
 596     return WINCODEC_ERR_PALETTEUNAVAILABLE;
 597 }
 598
 599 static HRESULT WINAPI IcoDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 600     IWICMetadataQueryReader **ppIMetadataQueryReader)
 601 {
 602     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
 603     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 604 }
 605
 606 static HRESULT WINAPI IcoDecoder_GetPreview(IWICBitmapDecoder *iface,
 607     IWICBitmapSource **ppIBitmapSource)
 608 {
 609     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
 610     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 611 }
 612
 613 static HRESULT WINAPI IcoDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 614     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 615 {
 616     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
 617     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 618 }
 619
 620 static HRESULT WINAPI IcoDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 621     IWICBitmapSource **ppIThumbnail)
 622 {
 623     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 624     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 625 }
 626
 627 static HRESULT WINAPI IcoDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 628     UINT *pCount)
 629 {
 630     IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
 631
 632     if (!pCount) return E_INVALIDARG;
 633
 634     EnterCriticalSection(&This->lock);
 635     *pCount = This->initialized ? This->header.idCount : 0;
 636     LeaveCriticalSection(&This->lock);
 637
 638     TRACE("(%p) <-- %d\n", iface, *pCount);
 639
 640     return S_OK;
 641 }
 642
 643 static HRESULT WINAPI IcoDecoder_GetFrame(IWICBitmapDecoder *iface,
 644     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 645 {
 646     IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
 647     IcoFrameDecode *result=NULL;
 648     LARGE_INTEGER seek;
 649     ULARGE_INTEGER offset, length;
 650     HRESULT hr;
 651     ULONG bytesread;
 652     ICONDIRENTRY entry;
 653     IWICStream *substream=NULL;
 654     DWORD magic;
 655     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 656
 657     EnterCriticalSection(&This->lock);
 658
 659     if (!This->initialized)
 660     {
 661         hr = WINCODEC_ERR_FRAMEMISSING;
 662         goto fail;
 663     }
 664
 665     if (This->header.idCount < index)
 666     {
 667         hr = E_INVALIDARG;
 668         goto fail;
 669     }
 670
 671     result = HeapAlloc(GetProcessHeap(), 0, sizeof(IcoFrameDecode));
 672     if (!result)
 673     {
 674         hr = E_OUTOFMEMORY;
 675         goto fail;
 676     }
 677
 678     result->IWICBitmapFrameDecode_iface.lpVtbl = &IcoFrameDecode_Vtbl;
 679     result->ref = 1;
 680     result->bits = NULL;
 681
 682     /* read the icon entry */
 683     seek.QuadPart = sizeof(ICONHEADER) + sizeof(ICONDIRENTRY) * index;
 684     hr = IStream_Seek(This->stream, seek, STREAM_SEEK_SET, 0);
 685     if (FAILED(hr)) goto fail;
 686
 687     hr = IStream_Read(This->stream, &entry, sizeof(ICONDIRENTRY), &bytesread);
 688     if (FAILED(hr) || bytesread != sizeof(ICONDIRENTRY)) goto fail;
 689
 690     /* create a stream object for this icon */
 691     hr = StreamImpl_Create(&substream);
 692     if (FAILED(hr)) goto fail;
 693
 694     offset.QuadPart = entry.dwDIBOffset;
 695     length.QuadPart = entry.dwDIBSize;
 696     hr = IWICStream_InitializeFromIStreamRegion(substream, This->stream, offset, length);
 697     if (FAILED(hr)) goto fail;
 698
 699     /* read the bitmapinfo size or magic number */
 700     hr = IWICStream_Read(substream, &magic, sizeof(magic), &bytesread);
 701     if (FAILED(hr) || bytesread != sizeof(magic)) goto fail;
 702
 703     /* forward to the appropriate decoding function based on the magic number */
 704     switch (magic)
 705     {
 706     case sizeof(BITMAPCOREHEADER):
 707     case 64: /* sizeof(BITMAPCOREHEADER2) */
 708     case sizeof(BITMAPINFOHEADER):
 709     case sizeof(BITMAPV4HEADER):
 710     case sizeof(BITMAPV5HEADER):
 711         hr = ReadIcoDib((IStream*)substream, result);
 712         break;
 713     case 0x474e5089:
 714         hr = ReadIcoPng((IStream*)substream, result);
 715         break;
 716     default:
 717         FIXME("Unrecognized ICO frame magic: %lx\n", magic);
 718         hr = E_FAIL;
 719         break;
 720     }
 721     if (FAILED(hr)) goto fail;
 722
 723     *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
 724
 725     LeaveCriticalSection(&This->lock);
 726
 727     IWICStream_Release(substream);
 728
 729     return S_OK;
 730
 731 fail:
 732     LeaveCriticalSection(&This->lock);
 733     HeapFree(GetProcessHeap(), 0, result);
 734     if (substream) IWICStream_Release(substream);
 735     if (SUCCEEDED(hr)) hr = E_FAIL;
 736     TRACE("<-- %lx\n", hr);
 737     return hr;
 738 }
 739
 740 static const IWICBitmapDecoderVtbl IcoDecoder_Vtbl = {
 741     IcoDecoder_QueryInterface,
 742     IcoDecoder_AddRef,
 743     IcoDecoder_Release,
 744     IcoDecoder_QueryCapability,
 745     IcoDecoder_Initialize,
 746     IcoDecoder_GetContainerFormat,
 747     IcoDecoder_GetDecoderInfo,
 748     IcoDecoder_CopyPalette,
 749     IcoDecoder_GetMetadataQueryReader,
 750     IcoDecoder_GetPreview,
 751     IcoDecoder_GetColorContexts,
 752     IcoDecoder_GetThumbnail,
 753     IcoDecoder_GetFrameCount,
 754     IcoDecoder_GetFrame
 755 };
 756
 757 HRESULT IcoDecoder_CreateInstance(REFIID iid, void** ppv)
 758 {
 759     IcoDecoder *This;
 760     HRESULT ret;
 761
 762     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 763
 764     *ppv = NULL;
 765
 766     This = HeapAlloc(GetProcessHeap(), 0, sizeof(IcoDecoder));
 767     if (!This) return E_OUTOFMEMORY;
 768
 769     This->IWICBitmapDecoder_iface.lpVtbl = &IcoDecoder_Vtbl;
 770     This->ref = 1;
 771     This->stream = NULL;
 772     This->initialized = FALSE;
 773     InitializeCriticalSection(&This->lock);
 774     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IcoDecoder.lock");
 775
 776     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
 777     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
 778
 779     return ret;
 780 }