dlls/windowscodecs/gifformat.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  * Copyright 2012 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
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "objbase.h"
  30
  31 #include "ungif.h"
  32
  33 #include "wincodecs_private.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  38
  39 static LPWSTR strdupAtoW(const char *src)
  40 {
  41     int len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
  42     LPWSTR dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  43     if (dst) MultiByteToWideChar(CP_ACP, 0, src, -1, dst, len);
  44     return dst;
  45 }
  46
  47 static HRESULT load_LSD_metadata(IStream *stream, const GUID *vendor, DWORD options,
  48                                  MetadataItem **items, DWORD *count)
  49 {
  50 #include "pshpack1.h"
  51     struct logical_screen_descriptor
  52     {
  53         char signature[6];
  54         USHORT width;
  55         USHORT height;
  56         BYTE packed;
  57         /* global_color_table_flag : 1;
  58          * color_resolution : 3;
  59          * sort_flag : 1;
  60          * global_color_table_size : 3;
  61          */
  62         BYTE background_color_index;
  63         BYTE pixel_aspect_ratio;
  64     } lsd_data;
  65 #include "poppack.h"
  66     HRESULT hr;
  67     ULONG bytesread, i;
  68     MetadataItem *result;
  69
  70     *items = NULL;
  71     *count = 0;
  72
  73     hr = IStream_Read(stream, &lsd_data, sizeof(lsd_data), &bytesread);
  74     if (FAILED(hr) || bytesread != sizeof(lsd_data)) return S_OK;
  75
  76     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 9);
  77     if (!result) return E_OUTOFMEMORY;
  78
  79     for (i = 0; i < 9; i++)
  80     {
  81         PropVariantInit(&result[i].schema);
  82         PropVariantInit(&result[i].id);
  83         PropVariantInit(&result[i].value);
  84     }
  85
  86     result[0].id.vt = VT_LPWSTR;
  87     result[0].id.u.pwszVal = strdupAtoW("Signature");
  88     result[0].value.vt = VT_UI1|VT_VECTOR;
  89     result[0].value.u.caub.cElems = sizeof(lsd_data.signature);
  90     result[0].value.u.caub.pElems = HeapAlloc(GetProcessHeap(), 0, sizeof(lsd_data.signature));
  91     memcpy(result[0].value.u.caub.pElems, lsd_data.signature, sizeof(lsd_data.signature));
  92
  93     result[1].id.vt = VT_LPWSTR;
  94     result[1].id.u.pwszVal = strdupAtoW("Width");
  95     result[1].value.vt = VT_UI2;
  96     result[1].value.u.uiVal = lsd_data.width;
  97
  98     result[2].id.vt = VT_LPWSTR;
  99     result[2].id.u.pwszVal = strdupAtoW("Height");
 100     result[2].value.vt = VT_UI2;
 101     result[2].value.u.uiVal = lsd_data.height;
 102
 103     result[3].id.vt = VT_LPWSTR;
 104     result[3].id.u.pwszVal = strdupAtoW("GlobalColorTableFlag");
 105     result[3].value.vt = VT_BOOL;
 106     result[3].value.u.boolVal = (lsd_data.packed >> 7) & 1;
 107
 108     result[4].id.vt = VT_LPWSTR;
 109     result[4].id.u.pwszVal = strdupAtoW("ColorResolution");
 110     result[4].value.vt = VT_UI1;
 111     result[4].value.u.bVal = (lsd_data.packed >> 4) & 7;
 112
 113     result[5].id.vt = VT_LPWSTR;
 114     result[5].id.u.pwszVal = strdupAtoW("SortFlag");
 115     result[5].value.vt = VT_BOOL;
 116     result[5].value.u.boolVal = (lsd_data.packed >> 3) & 1;
 117
 118     result[6].id.vt = VT_LPWSTR;
 119     result[6].id.u.pwszVal = strdupAtoW("GlobalColorTableSize");
 120     result[6].value.vt = VT_UI1;
 121     result[6].value.u.bVal = lsd_data.packed & 7;
 122
 123     result[7].id.vt = VT_LPWSTR;
 124     result[7].id.u.pwszVal = strdupAtoW("BackgroundColorIndex");
 125     result[7].value.vt = VT_UI1;
 126     result[7].value.u.bVal = lsd_data.background_color_index;
 127
 128     result[8].id.vt = VT_LPWSTR;
 129     result[8].id.u.pwszVal = strdupAtoW("PixelAspectRatio");
 130     result[8].value.vt = VT_UI1;
 131     result[8].value.u.bVal = lsd_data.pixel_aspect_ratio;
 132
 133     *items = result;
 134     *count = 9;
 135
 136     return S_OK;
 137 }
 138
 139 static const MetadataHandlerVtbl LSDReader_Vtbl = {
 140     0,
 141     &CLSID_WICLSDMetadataReader,
 142     load_LSD_metadata
 143 };
 144
 145 HRESULT LSDReader_CreateInstance(REFIID iid, void **ppv)
 146 {
 147     return MetadataReader_Create(&LSDReader_Vtbl, iid, ppv);
 148 }
 149
 150 #include "pshpack1.h"
 151 struct image_descriptor
 152 {
 153     USHORT left;
 154     USHORT top;
 155     USHORT width;
 156     USHORT height;
 157     BYTE packed;
 158     /* local_color_table_flag : 1;
 159      * interlace_flag : 1;
 160      * sort_flag : 1;
 161      * reserved : 2;
 162      * local_color_table_size : 3;
 163      */
 164 };
 165 #include "poppack.h"
 166
 167 static HRESULT load_IMD_metadata(IStream *stream, const GUID *vendor, DWORD options,
 168                                  MetadataItem **items, DWORD *count)
 169 {
 170     struct image_descriptor imd_data;
 171     HRESULT hr;
 172     ULONG bytesread, i;
 173     MetadataItem *result;
 174
 175     *items = NULL;
 176     *count = 0;
 177
 178     hr = IStream_Read(stream, &imd_data, sizeof(imd_data), &bytesread);
 179     if (FAILED(hr) || bytesread != sizeof(imd_data)) return S_OK;
 180
 181     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 8);
 182     if (!result) return E_OUTOFMEMORY;
 183
 184     for (i = 0; i < 8; i++)
 185     {
 186         PropVariantInit(&result[i].schema);
 187         PropVariantInit(&result[i].id);
 188         PropVariantInit(&result[i].value);
 189     }
 190
 191     result[0].id.vt = VT_LPWSTR;
 192     result[0].id.u.pwszVal = strdupAtoW("Left");
 193     result[0].value.vt = VT_UI2;
 194     result[0].value.u.uiVal = imd_data.left;
 195
 196     result[1].id.vt = VT_LPWSTR;
 197     result[1].id.u.pwszVal = strdupAtoW("Top");
 198     result[1].value.vt = VT_UI2;
 199     result[1].value.u.uiVal = imd_data.top;
 200
 201     result[2].id.vt = VT_LPWSTR;
 202     result[2].id.u.pwszVal = strdupAtoW("Width");
 203     result[2].value.vt = VT_UI2;
 204     result[2].value.u.uiVal = imd_data.width;
 205
 206     result[3].id.vt = VT_LPWSTR;
 207     result[3].id.u.pwszVal = strdupAtoW("Height");
 208     result[3].value.vt = VT_UI2;
 209     result[3].value.u.uiVal = imd_data.height;
 210
 211     result[4].id.vt = VT_LPWSTR;
 212     result[4].id.u.pwszVal = strdupAtoW("LocalColorTableFlag");
 213     result[4].value.vt = VT_BOOL;
 214     result[4].value.u.boolVal = (imd_data.packed >> 7) & 1;
 215
 216     result[5].id.vt = VT_LPWSTR;
 217     result[5].id.u.pwszVal = strdupAtoW("InterlaceFlag");
 218     result[5].value.vt = VT_BOOL;
 219     result[5].value.u.boolVal = (imd_data.packed >> 6) & 1;
 220
 221     result[6].id.vt = VT_LPWSTR;
 222     result[6].id.u.pwszVal = strdupAtoW("SortFlag");
 223     result[6].value.vt = VT_BOOL;
 224     result[6].value.u.boolVal = (imd_data.packed >> 5) & 1;
 225
 226     result[7].id.vt = VT_LPWSTR;
 227     result[7].id.u.pwszVal = strdupAtoW("LocalColorTableSize");
 228     result[7].value.vt = VT_UI1;
 229     result[7].value.u.bVal = imd_data.packed & 7;
 230
 231     *items = result;
 232     *count = 8;
 233
 234     return S_OK;
 235 }
 236
 237 static const MetadataHandlerVtbl IMDReader_Vtbl = {
 238     0,
 239     &CLSID_WICIMDMetadataReader,
 240     load_IMD_metadata
 241 };
 242
 243 HRESULT IMDReader_CreateInstance(REFIID iid, void **ppv)
 244 {
 245     return MetadataReader_Create(&IMDReader_Vtbl, iid, ppv);
 246 }
 247
 248 static HRESULT load_GCE_metadata(IStream *stream, const GUID *vendor, DWORD options,
 249                                  MetadataItem **items, DWORD *count)
 250 {
 251 #include "pshpack1.h"
 252     struct graphic_control_extension
 253     {
 254         BYTE packed;
 255         /* reservred: 3;
 256          * disposal : 3;
 257          * user_input_flag : 1;
 258          * transparency_flag : 1;
 259          */
 260          USHORT delay;
 261          BYTE transparent_color_index;
 262     } gce_data;
 263 #include "poppack.h"
 264     HRESULT hr;
 265     ULONG bytesread, i;
 266     MetadataItem *result;
 267
 268     *items = NULL;
 269     *count = 0;
 270
 271     hr = IStream_Read(stream, &gce_data, sizeof(gce_data), &bytesread);
 272     if (FAILED(hr) || bytesread != sizeof(gce_data)) return S_OK;
 273
 274     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 5);
 275     if (!result) return E_OUTOFMEMORY;
 276
 277     for (i = 0; i < 5; i++)
 278     {
 279         PropVariantInit(&result[i].schema);
 280         PropVariantInit(&result[i].id);
 281         PropVariantInit(&result[i].value);
 282     }
 283
 284     result[0].id.vt = VT_LPWSTR;
 285     result[0].id.u.pwszVal = strdupAtoW("Disposal");
 286     result[0].value.vt = VT_UI1;
 287     result[0].value.u.bVal = (gce_data.packed >> 2) & 7;
 288
 289     result[1].id.vt = VT_LPWSTR;
 290     result[1].id.u.pwszVal = strdupAtoW("UserInputFlag");
 291     result[1].value.vt = VT_BOOL;
 292     result[1].value.u.boolVal = (gce_data.packed >> 1) & 1;
 293
 294     result[2].id.vt = VT_LPWSTR;
 295     result[2].id.u.pwszVal = strdupAtoW("TransparencyFlag");
 296     result[2].value.vt = VT_BOOL;
 297     result[2].value.u.boolVal = gce_data.packed & 1;
 298
 299     result[3].id.vt = VT_LPWSTR;
 300     result[3].id.u.pwszVal = strdupAtoW("Delay");
 301     result[3].value.vt = VT_UI2;
 302     result[3].value.u.uiVal = gce_data.delay;
 303
 304     result[4].id.vt = VT_LPWSTR;
 305     result[4].id.u.pwszVal = strdupAtoW("TransparentColorIndex");
 306     result[4].value.vt = VT_UI1;
 307     result[4].value.u.bVal = gce_data.transparent_color_index;
 308
 309     *items = result;
 310     *count = 5;
 311
 312     return S_OK;
 313 }
 314
 315 static const MetadataHandlerVtbl GCEReader_Vtbl = {
 316     0,
 317     &CLSID_WICGCEMetadataReader,
 318     load_GCE_metadata
 319 };
 320
 321 HRESULT GCEReader_CreateInstance(REFIID iid, void **ppv)
 322 {
 323     return MetadataReader_Create(&GCEReader_Vtbl, iid, ppv);
 324 }
 325
 326 static HRESULT load_APE_metadata(IStream *stream, const GUID *vendor, DWORD options,
 327                                  MetadataItem **items, DWORD *count)
 328 {
 329 #include "pshpack1.h"
 330     struct application_extension
 331     {
 332         BYTE extension_introducer;
 333         BYTE extension_label;
 334         BYTE block_size;
 335         BYTE application[11];
 336     } ape_data;
 337 #include "poppack.h"
 338     HRESULT hr;
 339     ULONG bytesread, data_size, i;
 340     MetadataItem *result;
 341     BYTE subblock_size;
 342     BYTE *data;
 343
 344     *items = NULL;
 345     *count = 0;
 346
 347     hr = IStream_Read(stream, &ape_data, sizeof(ape_data), &bytesread);
 348     if (FAILED(hr) || bytesread != sizeof(ape_data)) return S_OK;
 349     if (ape_data.extension_introducer != 0x21 ||
 350         ape_data.extension_label != APPLICATION_EXT_FUNC_CODE ||
 351         ape_data.block_size != 11)
 352         return S_OK;
 353
 354     data = NULL;
 355     data_size = 0;
 356
 357     for (;;)
 358     {
 359         hr = IStream_Read(stream, &subblock_size, sizeof(subblock_size), &bytesread);
 360         if (FAILED(hr) || bytesread != sizeof(subblock_size))
 361         {
 362             HeapFree(GetProcessHeap(), 0, data);
 363             return S_OK;
 364         }
 365         if (!subblock_size) break;
 366
 367         if (!data)
 368             data = HeapAlloc(GetProcessHeap(), 0, subblock_size + 1);
 369         else
 370         {
 371             BYTE *new_data = HeapReAlloc(GetProcessHeap(), 0, data, data_size + subblock_size + 1);
 372             if (!new_data)
 373             {
 374                 HeapFree(GetProcessHeap(), 0, data);
 375                 return S_OK;
 376             }
 377             data = new_data;
 378         }
 379         data[data_size] = subblock_size;
 380         hr = IStream_Read(stream, data + data_size + 1, subblock_size, &bytesread);
 381         if (FAILED(hr) || bytesread != subblock_size)
 382         {
 383             HeapFree(GetProcessHeap(), 0, data);
 384             return S_OK;
 385         }
 386         data_size += subblock_size + 1;
 387     }
 388
 389     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 2);
 390     if (!result)
 391     {
 392         HeapFree(GetProcessHeap(), 0, data);
 393         return E_OUTOFMEMORY;
 394     }
 395
 396     for (i = 0; i < 2; i++)
 397     {
 398         PropVariantInit(&result[i].schema);
 399         PropVariantInit(&result[i].id);
 400         PropVariantInit(&result[i].value);
 401     }
 402
 403     result[0].id.vt = VT_LPWSTR;
 404     result[0].id.u.pwszVal = strdupAtoW("Application");
 405     result[0].value.vt = VT_UI1|VT_VECTOR;
 406     result[0].value.u.caub.cElems = sizeof(ape_data.application);
 407     result[0].value.u.caub.pElems = HeapAlloc(GetProcessHeap(), 0, sizeof(ape_data.application));
 408     memcpy(result[0].value.u.caub.pElems, ape_data.application, sizeof(ape_data.application));
 409
 410     result[1].id.vt = VT_LPWSTR;
 411     result[1].id.u.pwszVal = strdupAtoW("Data");
 412     result[1].value.vt = VT_UI1|VT_VECTOR;
 413     result[1].value.u.caub.cElems = data_size;
 414     result[1].value.u.caub.pElems = data;
 415
 416     *items = result;
 417     *count = 2;
 418
 419     return S_OK;
 420 }
 421
 422 static const MetadataHandlerVtbl APEReader_Vtbl = {
 423     0,
 424     &CLSID_WICAPEMetadataReader,
 425     load_APE_metadata
 426 };
 427
 428 HRESULT APEReader_CreateInstance(REFIID iid, void **ppv)
 429 {
 430     return MetadataReader_Create(&APEReader_Vtbl, iid, ppv);
 431 }
 432
 433 static HRESULT load_GifComment_metadata(IStream *stream, const GUID *vendor, DWORD options,
 434                                         MetadataItem **items, DWORD *count)
 435 {
 436 #include "pshpack1.h"
 437     struct gif_extension
 438     {
 439         BYTE extension_introducer;
 440         BYTE extension_label;
 441     } ext_data;
 442 #include "poppack.h"
 443     HRESULT hr;
 444     ULONG bytesread, data_size;
 445     MetadataItem *result;
 446     BYTE subblock_size;
 447     char *data;
 448
 449     *items = NULL;
 450     *count = 0;
 451
 452     hr = IStream_Read(stream, &ext_data, sizeof(ext_data), &bytesread);
 453     if (FAILED(hr) || bytesread != sizeof(ext_data)) return S_OK;
 454     if (ext_data.extension_introducer != 0x21 ||
 455         ext_data.extension_label != COMMENT_EXT_FUNC_CODE)
 456         return S_OK;
 457
 458     data = NULL;
 459     data_size = 0;
 460
 461     for (;;)
 462     {
 463         hr = IStream_Read(stream, &subblock_size, sizeof(subblock_size), &bytesread);
 464         if (FAILED(hr) || bytesread != sizeof(subblock_size))
 465         {
 466             HeapFree(GetProcessHeap(), 0, data);
 467             return S_OK;
 468         }
 469         if (!subblock_size) break;
 470
 471         if (!data)
 472             data = HeapAlloc(GetProcessHeap(), 0, subblock_size + 1);
 473         else
 474         {
 475             char *new_data = HeapReAlloc(GetProcessHeap(), 0, data, data_size + subblock_size + 1);
 476             if (!new_data)
 477             {
 478                 HeapFree(GetProcessHeap(), 0, data);
 479                 return S_OK;
 480             }
 481             data = new_data;
 482         }
 483         hr = IStream_Read(stream, data + data_size, subblock_size, &bytesread);
 484         if (FAILED(hr) || bytesread != subblock_size)
 485         {
 486             HeapFree(GetProcessHeap(), 0, data);
 487             return S_OK;
 488         }
 489         data_size += subblock_size;
 490     }
 491
 492     data[data_size] = 0;
 493
 494     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
 495     if (!result)
 496     {
 497         HeapFree(GetProcessHeap(), 0, data);
 498         return E_OUTOFMEMORY;
 499     }
 500
 501     PropVariantInit(&result->schema);
 502     PropVariantInit(&result->id);
 503     PropVariantInit(&result->value);
 504
 505     result->id.vt = VT_LPWSTR;
 506     result->id.u.pwszVal = strdupAtoW("TextEntry");
 507     result->value.vt = VT_LPSTR;
 508     result->value.u.pszVal = data;
 509
 510     *items = result;
 511     *count = 1;
 512
 513     return S_OK;
 514 }
 515
 516 static const MetadataHandlerVtbl GifCommentReader_Vtbl = {
 517     0,
 518     &CLSID_WICGifCommentMetadataReader,
 519     load_GifComment_metadata
 520 };
 521
 522 HRESULT GifCommentReader_CreateInstance(REFIID iid, void **ppv)
 523 {
 524     return MetadataReader_Create(&GifCommentReader_Vtbl, iid, ppv);
 525 }
 526
 527 static IStream *create_stream(const void *data, int data_size)
 528 {
 529     HRESULT hr;
 530     IStream *stream;
 531     HGLOBAL hdata;
 532     void *locked_data;
 533
 534     hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
 535     if (!hdata) return NULL;
 536
 537     locked_data = GlobalLock(hdata);
 538     memcpy(locked_data, data, data_size);
 539     GlobalUnlock(hdata);
 540
 541     hr = CreateStreamOnHGlobal(hdata, TRUE, &stream);
 542     return FAILED(hr) ? NULL : stream;
 543 }
 544
 545 static HRESULT create_metadata_reader(const void *data, int data_size,
 546                                       class_constructor constructor,
 547                                       IWICMetadataReader **reader)
 548 {
 549     HRESULT hr;
 550     IWICMetadataReader *metadata_reader;
 551     IWICPersistStream *persist;
 552     IStream *stream;
 553
 554     /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
 555
 556     hr = constructor(&IID_IWICMetadataReader, (void**)&metadata_reader);
 557     if (FAILED(hr)) return hr;
 558
 559     hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
 560     if (FAILED(hr))
 561     {
 562         IWICMetadataReader_Release(metadata_reader);
 563         return hr;
 564     }
 565
 566     stream = create_stream(data, data_size);
 567     IWICPersistStream_LoadEx(persist, stream, NULL, WICPersistOptionDefault);
 568     IStream_Release(stream);
 569
 570     IWICPersistStream_Release(persist);
 571
 572     *reader = metadata_reader;
 573     return S_OK;
 574 }
 575
 576 typedef struct {
 577     IWICBitmapDecoder IWICBitmapDecoder_iface;
 578     IWICMetadataBlockReader IWICMetadataBlockReader_iface;
 579     IStream *stream;
 580     BYTE LSD_data[13]; /* Logical Screen Descriptor */
 581     LONG ref;
 582     BOOL initialized;
 583     GifFileType *gif;
 584     UINT current_frame;
 585     CRITICAL_SECTION lock;
 586 } GifDecoder;
 587
 588 typedef struct {
 589     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 590     IWICMetadataBlockReader IWICMetadataBlockReader_iface;
 591     LONG ref;
 592     SavedImage *frame;
 593     GifDecoder *parent;
 594 } GifFrameDecode;
 595
 596 static inline GifDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 597 {
 598     return CONTAINING_RECORD(iface, GifDecoder, IWICBitmapDecoder_iface);
 599 }
 600
 601 static inline GifDecoder *impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
 602 {
 603     return CONTAINING_RECORD(iface, GifDecoder, IWICMetadataBlockReader_iface);
 604 }
 605
 606 static inline GifFrameDecode *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 607 {
 608     return CONTAINING_RECORD(iface, GifFrameDecode, IWICBitmapFrameDecode_iface);
 609 }
 610
 611 static inline GifFrameDecode *frame_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
 612 {
 613     return CONTAINING_RECORD(iface, GifFrameDecode, IWICMetadataBlockReader_iface);
 614 }
 615
 616 static HRESULT WINAPI GifFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
 617     void **ppv)
 618 {
 619     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 620     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 621
 622     if (!ppv) return E_INVALIDARG;
 623
 624     if (IsEqualIID(&IID_IUnknown, iid) ||
 625         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 626         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
 627     {
 628         *ppv = &This->IWICBitmapFrameDecode_iface;
 629     }
 630     else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
 631     {
 632         *ppv = &This->IWICMetadataBlockReader_iface;
 633     }
 634     else
 635     {
 636         *ppv = NULL;
 637         return E_NOINTERFACE;
 638     }
 639
 640     IUnknown_AddRef((IUnknown*)*ppv);
 641     return S_OK;
 642 }
 643
 644 static ULONG WINAPI GifFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
 645 {
 646     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 647     ULONG ref = InterlockedIncrement(&This->ref);
 648
 649     TRACE("(%p) refcount=%u\n", iface, ref);
 650
 651     return ref;
 652 }
 653
 654 static ULONG WINAPI GifFrameDecode_Release(IWICBitmapFrameDecode *iface)
 655 {
 656     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 657     ULONG ref = InterlockedDecrement(&This->ref);
 658
 659     TRACE("(%p) refcount=%u\n", iface, ref);
 660
 661     if (ref == 0)
 662     {
 663         IWICBitmapDecoder_Release(&This->parent->IWICBitmapDecoder_iface);
 664         HeapFree(GetProcessHeap(), 0, This);
 665     }
 666
 667     return ref;
 668 }
 669
 670 static HRESULT WINAPI GifFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
 671     UINT *puiWidth, UINT *puiHeight)
 672 {
 673     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 674     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 675
 676     *puiWidth = This->frame->ImageDesc.Width;
 677     *puiHeight = This->frame->ImageDesc.Height;
 678
 679     return S_OK;
 680 }
 681
 682 static HRESULT WINAPI GifFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
 683     WICPixelFormatGUID *pPixelFormat)
 684 {
 685     memcpy(pPixelFormat, &GUID_WICPixelFormat8bppIndexed, sizeof(GUID));
 686
 687     return S_OK;
 688 }
 689
 690 static HRESULT WINAPI GifFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
 691     double *pDpiX, double *pDpiY)
 692 {
 693     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 694     const GifWord aspect_word = This->parent->gif->SAspectRatio;
 695     const double aspect = (aspect_word > 0) ? ((aspect_word + 15.0) / 64.0) : 1.0;
 696     TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 697
 698     *pDpiX = 96.0 / aspect;
 699     *pDpiY = 96.0;
 700
 701     return S_OK;
 702 }
 703
 704 static HRESULT WINAPI GifFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
 705     IWICPalette *pIPalette)
 706 {
 707     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 708     WICColor colors[256];
 709     ColorMapObject *cm = This->frame->ImageDesc.ColorMap;
 710     int i, trans;
 711     ExtensionBlock *eb;
 712     TRACE("(%p,%p)\n", iface, pIPalette);
 713
 714     if (!cm) cm = This->parent->gif->SColorMap;
 715
 716     if (cm->ColorCount > 256)
 717     {
 718         ERR("GIF contains %i colors???\n", cm->ColorCount);
 719         return E_FAIL;
 720     }
 721
 722     for (i = 0; i < cm->ColorCount; i++) {
 723         colors[i] = 0xff000000| /* alpha */
 724                     cm->Colors[i].Red << 16|
 725                     cm->Colors[i].Green << 8|
 726                     cm->Colors[i].Blue;
 727     }
 728
 729     /* look for the transparent color extension */
 730     for (i = 0; i < This->frame->Extensions.ExtensionBlockCount; ++i) {
 731         eb = This->frame->Extensions.ExtensionBlocks + i;
 732         if (eb->Function == GRAPHICS_EXT_FUNC_CODE && eb->ByteCount == 8) {
 733             if (eb->Bytes[3] & 1) {
 734                 trans = (unsigned char)eb->Bytes[6];
 735                 colors[trans] &= 0xffffff; /* set alpha to 0 */
 736                 break;
 737             }
 738         }
 739     }
 740
 741     return IWICPalette_InitializeCustom(pIPalette, colors, cm->ColorCount);
 742 }
 743
 744 static HRESULT copy_interlaced_pixels(const BYTE *srcbuffer,
 745     UINT srcwidth, UINT srcheight, INT srcstride, const WICRect *rc,
 746     UINT dststride, UINT dstbuffersize, BYTE *dstbuffer)
 747 {
 748     UINT row_offset; /* number of bytes into the source rows where the data starts */
 749     const BYTE *src;
 750     BYTE *dst;
 751     UINT y;
 752     WICRect rect;
 753
 754     if (!rc)
 755     {
 756         rect.X = 0;
 757         rect.Y = 0;
 758         rect.Width = srcwidth;
 759         rect.Height = srcheight;
 760         rc = &rect;
 761     }
 762     else
 763     {
 764         if (rc->X < 0 || rc->Y < 0 || rc->X+rc->Width > srcwidth || rc->Y+rc->Height > srcheight)
 765             return E_INVALIDARG;
 766     }
 767
 768     if (dststride < rc->Width)
 769         return E_INVALIDARG;
 770
 771     if ((dststride * rc->Height) > dstbuffersize)
 772         return E_INVALIDARG;
 773
 774     row_offset = rc->X;
 775
 776     dst = dstbuffer;
 777     for (y=rc->Y; y-rc->Y < rc->Height; y++)
 778     {
 779         if (y%8 == 0)
 780             src = srcbuffer + srcstride * (y/8);
 781         else if (y%4 == 0)
 782             src = srcbuffer + srcstride * ((srcheight+7)/8 + y/8);
 783         else if (y%2 == 0)
 784             src = srcbuffer + srcstride * ((srcheight+3)/4 + y/4);
 785         else /* y%2 == 1 */
 786             src = srcbuffer + srcstride * ((srcheight+1)/2 + y/2);
 787         src += row_offset;
 788         memcpy(dst, src, rc->Width);
 789         dst += dststride;
 790     }
 791     return S_OK;
 792 }
 793
 794 static HRESULT WINAPI GifFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
 795     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 796 {
 797     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 798     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
 799
 800     if (This->frame->ImageDesc.Interlace)
 801     {
 802         return copy_interlaced_pixels(This->frame->RasterBits, This->frame->ImageDesc.Width,
 803             This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
 804             prc, cbStride, cbBufferSize, pbBuffer);
 805     }
 806     else
 807     {
 808         return copy_pixels(8, This->frame->RasterBits, This->frame->ImageDesc.Width,
 809             This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
 810             prc, cbStride, cbBufferSize, pbBuffer);
 811     }
 812 }
 813
 814 static HRESULT WINAPI GifFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
 815     IWICMetadataQueryReader **ppIMetadataQueryReader)
 816 {
 817     GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 818
 819     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
 820
 821     if (!ppIMetadataQueryReader)
 822         return E_INVALIDARG;
 823
 824     return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
 825 }
 826
 827 static HRESULT WINAPI GifFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
 828     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 829 {
 830     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
 831     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 832 }
 833
 834 static HRESULT WINAPI GifFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
 835     IWICBitmapSource **ppIThumbnail)
 836 {
 837     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 838     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 839 }
 840
 841 static const IWICBitmapFrameDecodeVtbl GifFrameDecode_Vtbl = {
 842     GifFrameDecode_QueryInterface,
 843     GifFrameDecode_AddRef,
 844     GifFrameDecode_Release,
 845     GifFrameDecode_GetSize,
 846     GifFrameDecode_GetPixelFormat,
 847     GifFrameDecode_GetResolution,
 848     GifFrameDecode_CopyPalette,
 849     GifFrameDecode_CopyPixels,
 850     GifFrameDecode_GetMetadataQueryReader,
 851     GifFrameDecode_GetColorContexts,
 852     GifFrameDecode_GetThumbnail
 853 };
 854
 855 static HRESULT WINAPI GifFrameDecode_Block_QueryInterface(IWICMetadataBlockReader *iface,
 856     REFIID iid, void **ppv)
 857 {
 858     GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
 859     return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
 860 }
 861
 862 static ULONG WINAPI GifFrameDecode_Block_AddRef(IWICMetadataBlockReader *iface)
 863 {
 864     GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
 865     return IWICBitmapFrameDecode_AddRef(&This->IWICBitmapFrameDecode_iface);
 866 }
 867
 868 static ULONG WINAPI GifFrameDecode_Block_Release(IWICMetadataBlockReader *iface)
 869 {
 870     GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
 871     return IWICBitmapFrameDecode_Release(&This->IWICBitmapFrameDecode_iface);
 872 }
 873
 874 static HRESULT WINAPI GifFrameDecode_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
 875     GUID *guid)
 876 {
 877     TRACE("(%p,%p)\n", iface, guid);
 878
 879     if (!guid) return E_INVALIDARG;
 880
 881     *guid = GUID_ContainerFormatGif;
 882     return S_OK;
 883 }
 884
 885 static HRESULT WINAPI GifFrameDecode_Block_GetCount(IWICMetadataBlockReader *iface,
 886     UINT *count)
 887 {
 888     GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
 889
 890     TRACE("%p,%p\n", iface, count);
 891
 892     if (!count) return E_INVALIDARG;
 893
 894     *count = This->frame->Extensions.ExtensionBlockCount + 1;
 895     return S_OK;
 896 }
 897
 898 static HRESULT create_IMD_metadata_reader(GifFrameDecode *This, IWICMetadataReader **reader)
 899 {
 900     HRESULT hr;
 901     IWICMetadataReader *metadata_reader;
 902     IWICPersistStream *persist;
 903     IStream *stream;
 904     struct image_descriptor IMD_data;
 905
 906     /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
 907
 908     hr = IMDReader_CreateInstance(&IID_IWICMetadataReader, (void **)&metadata_reader);
 909     if (FAILED(hr)) return hr;
 910
 911     hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
 912     if (FAILED(hr))
 913     {
 914         IWICMetadataReader_Release(metadata_reader);
 915         return hr;
 916     }
 917
 918     /* recreate IMD structure from GIF decoder data */
 919     IMD_data.left = This->frame->ImageDesc.Left;
 920     IMD_data.top = This->frame->ImageDesc.Top;
 921     IMD_data.width = This->frame->ImageDesc.Width;
 922     IMD_data.height = This->frame->ImageDesc.Height;
 923     IMD_data.packed = 0;
 924     /* interlace_flag */
 925     IMD_data.packed |= This->frame->ImageDesc.Interlace ? (1 << 6) : 0;
 926     if (This->frame->ImageDesc.ColorMap)
 927     {
 928         /* local_color_table_flag */
 929         IMD_data.packed |= 1 << 7;
 930         /* local_color_table_size */
 931         IMD_data.packed |= This->frame->ImageDesc.ColorMap->BitsPerPixel - 1;
 932         /* sort_flag */
 933         IMD_data.packed |= This->frame->ImageDesc.ColorMap->SortFlag ? 0x20 : 0;
 934     }
 935
 936     stream = create_stream(&IMD_data, sizeof(IMD_data));
 937     IWICPersistStream_LoadEx(persist, stream, NULL, WICPersistOptionDefault);
 938     IStream_Release(stream);
 939
 940     IWICPersistStream_Release(persist);
 941
 942     *reader = metadata_reader;
 943     return S_OK;
 944 }
 945
 946 static HRESULT WINAPI GifFrameDecode_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
 947     UINT index, IWICMetadataReader **reader)
 948 {
 949     GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
 950     int i, gce_index = -1, gce_skipped = 0;
 951
 952     TRACE("(%p,%u,%p)\n", iface, index, reader);
 953
 954     if (!reader) return E_INVALIDARG;
 955
 956     if (index == 0)
 957         return create_IMD_metadata_reader(This, reader);
 958
 959     if (index >= This->frame->Extensions.ExtensionBlockCount + 1)
 960         return E_INVALIDARG;
 961
 962     for (i = 0; i < This->frame->Extensions.ExtensionBlockCount; i++)
 963     {
 964         class_constructor constructor;
 965         const void *data;
 966         int data_size;
 967
 968         if (index != i + 1 - gce_skipped) continue;
 969
 970         if (This->frame->Extensions.ExtensionBlocks[i].Function == GRAPHICS_EXT_FUNC_CODE)
 971         {
 972             gce_index = i;
 973             gce_skipped = 1;
 974             continue;
 975         }
 976         else if (This->frame->Extensions.ExtensionBlocks[i].Function == COMMENT_EXT_FUNC_CODE)
 977         {
 978             constructor = GifCommentReader_CreateInstance;
 979             data = This->frame->Extensions.ExtensionBlocks[i].Bytes;
 980             data_size = This->frame->Extensions.ExtensionBlocks[i].ByteCount;
 981         }
 982         else
 983         {
 984             constructor = UnknownMetadataReader_CreateInstance;
 985             data = This->frame->Extensions.ExtensionBlocks[i].Bytes;
 986             data_size = This->frame->Extensions.ExtensionBlocks[i].ByteCount;
 987         }
 988         return create_metadata_reader(data, data_size, constructor, reader);
 989     }
 990
 991     if (gce_index == -1) return E_INVALIDARG;
 992
 993     return create_metadata_reader(This->frame->Extensions.ExtensionBlocks[gce_index].Bytes + 3,
 994                                   This->frame->Extensions.ExtensionBlocks[gce_index].ByteCount - 4,
 995                                   GCEReader_CreateInstance, reader);
 996 }
 997
 998 static HRESULT WINAPI GifFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader *iface,
 999     IEnumUnknown **enumerator)
1000 {
1001     FIXME("(%p,%p): stub\n", iface, enumerator);
1002     return E_NOTIMPL;
1003 }
1004
1005 static const IWICMetadataBlockReaderVtbl GifFrameDecode_BlockVtbl =
1006 {
1007     GifFrameDecode_Block_QueryInterface,
1008     GifFrameDecode_Block_AddRef,
1009     GifFrameDecode_Block_Release,
1010     GifFrameDecode_Block_GetContainerFormat,
1011     GifFrameDecode_Block_GetCount,
1012     GifFrameDecode_Block_GetReaderByIndex,
1013     GifFrameDecode_Block_GetEnumerator
1014 };
1015
1016 static HRESULT WINAPI GifDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
1017     void **ppv)
1018 {
1019     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1020     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1021
1022     if (!ppv) return E_INVALIDARG;
1023
1024     if (IsEqualIID(&IID_IUnknown, iid) ||
1025         IsEqualIID(&IID_IWICBitmapDecoder, iid))
1026     {
1027         *ppv = &This->IWICBitmapDecoder_iface;
1028     }
1029     else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
1030     {
1031         *ppv = &This->IWICMetadataBlockReader_iface;
1032     }
1033     else
1034     {
1035         *ppv = NULL;
1036         return E_NOINTERFACE;
1037     }
1038
1039     IUnknown_AddRef((IUnknown*)*ppv);
1040     return S_OK;
1041 }
1042
1043 static ULONG WINAPI GifDecoder_AddRef(IWICBitmapDecoder *iface)
1044 {
1045     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1046     ULONG ref = InterlockedIncrement(&This->ref);
1047
1048     TRACE("(%p) refcount=%u\n", iface, ref);
1049
1050     return ref;
1051 }
1052
1053 static ULONG WINAPI GifDecoder_Release(IWICBitmapDecoder *iface)
1054 {
1055     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1056     ULONG ref = InterlockedDecrement(&This->ref);
1057
1058     TRACE("(%p) refcount=%u\n", iface, ref);
1059
1060     if (ref == 0)
1061     {
1062         if (This->stream)
1063         {
1064             IStream_Release(This->stream);
1065             DGifCloseFile(This->gif);
1066         }
1067         This->lock.DebugInfo->Spare[0] = 0;
1068         DeleteCriticalSection(&This->lock);
1069         HeapFree(GetProcessHeap(), 0, This);
1070     }
1071
1072     return ref;
1073 }
1074
1075 static HRESULT WINAPI GifDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
1076     DWORD *capability)
1077 {
1078     HRESULT hr;
1079
1080     TRACE("(%p,%p,%p)\n", iface, stream, capability);
1081
1082     if (!stream || !capability) return E_INVALIDARG;
1083
1084     hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
1085     if (hr != S_OK) return hr;
1086
1087     *capability = WICBitmapDecoderCapabilityCanDecodeAllImages |
1088                   WICBitmapDecoderCapabilityCanDecodeSomeImages |
1089                   WICBitmapDecoderCapabilityCanEnumerateMetadata;
1090     return S_OK;
1091 }
1092
1093 static int _gif_inputfunc(GifFileType *gif, GifByteType *data, int len) {
1094     IStream *stream = gif->UserData;
1095     ULONG bytesread;
1096     HRESULT hr;
1097
1098     if (!stream)
1099     {
1100         ERR("attempting to read file after initialization\n");
1101         return 0;
1102     }
1103
1104     hr = IStream_Read(stream, data, len, &bytesread);
1105     if (FAILED(hr)) bytesread = 0;
1106     return bytesread;
1107 }
1108
1109 static HRESULT WINAPI GifDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
1110     WICDecodeOptions cacheOptions)
1111 {
1112     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1113     LARGE_INTEGER seek;
1114     int ret;
1115
1116     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
1117
1118     EnterCriticalSection(&This->lock);
1119
1120     if (This->initialized || This->gif)
1121     {
1122         WARN("already initialized\n");
1123         LeaveCriticalSection(&This->lock);
1124         return WINCODEC_ERR_WRONGSTATE;
1125     }
1126
1127     /* seek to start of stream */
1128     seek.QuadPart = 0;
1129     IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
1130
1131     /* read all data from the stream */
1132     This->gif = DGifOpen((void*)pIStream, _gif_inputfunc);
1133     if (!This->gif)
1134     {
1135         LeaveCriticalSection(&This->lock);
1136         return E_FAIL;
1137     }
1138
1139     ret = DGifSlurp(This->gif);
1140     if (ret == GIF_ERROR)
1141     {
1142         LeaveCriticalSection(&This->lock);
1143         return E_FAIL;
1144     }
1145
1146     /* make sure we don't use the stream after this method returns */
1147     This->gif->UserData = NULL;
1148
1149     seek.QuadPart = 0;
1150     IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
1151     IStream_Read(pIStream, This->LSD_data, sizeof(This->LSD_data), NULL);
1152
1153     This->stream = pIStream;
1154     IStream_AddRef(This->stream);
1155
1156     This->initialized = TRUE;
1157
1158     LeaveCriticalSection(&This->lock);
1159
1160     return S_OK;
1161 }
1162
1163 static HRESULT WINAPI GifDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
1164     GUID *pguidContainerFormat)
1165 {
1166     memcpy(pguidContainerFormat, &GUID_ContainerFormatGif, sizeof(GUID));
1167     return S_OK;
1168 }
1169
1170 static HRESULT WINAPI GifDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
1171     IWICBitmapDecoderInfo **ppIDecoderInfo)
1172 {
1173     HRESULT hr;
1174     IWICComponentInfo *compinfo;
1175
1176     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
1177
1178     hr = CreateComponentInfo(&CLSID_WICGifDecoder, &compinfo);
1179     if (FAILED(hr)) return hr;
1180
1181     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
1182         (void**)ppIDecoderInfo);
1183
1184     IWICComponentInfo_Release(compinfo);
1185
1186     return hr;
1187 }
1188
1189 static HRESULT WINAPI GifDecoder_CopyPalette(IWICBitmapDecoder *iface, IWICPalette *palette)
1190 {
1191     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1192     WICColor colors[256];
1193     ColorMapObject *cm;
1194     int i, trans, count;
1195     ExtensionBlock *eb;
1196
1197     TRACE("(%p,%p)\n", iface, palette);
1198
1199     cm = This->gif->SColorMap;
1200     if (cm)
1201     {
1202         if (cm->ColorCount > 256)
1203         {
1204             ERR("GIF contains invalid number of colors: %d\n", cm->ColorCount);
1205             return E_FAIL;
1206         }
1207
1208         for (i = 0; i < cm->ColorCount; i++)
1209         {
1210             colors[i] = 0xff000000 | /* alpha */
1211                         cm->Colors[i].Red << 16 |
1212                         cm->Colors[i].Green << 8 |
1213                         cm->Colors[i].Blue;
1214         }
1215
1216         count = cm->ColorCount;
1217     }
1218     else
1219     {
1220         colors[0] = 0xff000000;
1221         colors[1] = 0xffffffff;
1222
1223         for (i = 2; i < 256; i++)
1224             colors[i] = 0xff000000;
1225
1226         count = 256;
1227     }
1228
1229     /* look for the transparent color extension */
1230     for (i = 0; i < This->gif->SavedImages[This->current_frame].Extensions.ExtensionBlockCount; i++)
1231     {
1232         eb = This->gif->SavedImages[This->current_frame].Extensions.ExtensionBlocks + i;
1233         if (eb->Function == GRAPHICS_EXT_FUNC_CODE && eb->ByteCount == 8)
1234         {
1235             if (eb->Bytes[3] & 1)
1236             {
1237                 trans = (unsigned char)eb->Bytes[6];
1238                 colors[trans] &= 0xffffff; /* set alpha to 0 */
1239                 break;
1240             }
1241         }
1242     }
1243
1244     return IWICPalette_InitializeCustom(palette, colors, count);
1245 }
1246
1247 static HRESULT WINAPI GifDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
1248     IWICMetadataQueryReader **ppIMetadataQueryReader)
1249 {
1250     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1251
1252     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
1253
1254     if (!ppIMetadataQueryReader) return E_INVALIDARG;
1255
1256     return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
1257 }
1258
1259 static HRESULT WINAPI GifDecoder_GetPreview(IWICBitmapDecoder *iface,
1260     IWICBitmapSource **ppIBitmapSource)
1261 {
1262     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
1263     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1264 }
1265
1266 static HRESULT WINAPI GifDecoder_GetColorContexts(IWICBitmapDecoder *iface,
1267     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
1268 {
1269     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
1270     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1271 }
1272
1273 static HRESULT WINAPI GifDecoder_GetThumbnail(IWICBitmapDecoder *iface,
1274     IWICBitmapSource **ppIThumbnail)
1275 {
1276     TRACE("(%p,%p)\n", iface, ppIThumbnail);
1277     return WINCODEC_ERR_CODECNOTHUMBNAIL;
1278 }
1279
1280 static HRESULT WINAPI GifDecoder_GetFrameCount(IWICBitmapDecoder *iface,
1281     UINT *pCount)
1282 {
1283     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1284
1285     if (!pCount) return E_INVALIDARG;
1286
1287     EnterCriticalSection(&This->lock);
1288     *pCount = This->gif ? This->gif->ImageCount : 0;
1289     LeaveCriticalSection(&This->lock);
1290
1291     TRACE("(%p) <-- %d\n", iface, *pCount);
1292
1293     return S_OK;
1294 }
1295
1296 static HRESULT WINAPI GifDecoder_GetFrame(IWICBitmapDecoder *iface,
1297     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
1298 {
1299     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1300     GifFrameDecode *result;
1301     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
1302
1303     if (!This->initialized) return WINCODEC_ERR_FRAMEMISSING;
1304
1305     if (index >= This->gif->ImageCount) return E_INVALIDARG;
1306
1307     result = HeapAlloc(GetProcessHeap(), 0, sizeof(GifFrameDecode));
1308     if (!result) return E_OUTOFMEMORY;
1309
1310     result->IWICBitmapFrameDecode_iface.lpVtbl = &GifFrameDecode_Vtbl;
1311     result->IWICMetadataBlockReader_iface.lpVtbl = &GifFrameDecode_BlockVtbl;
1312     result->ref = 1;
1313     result->frame = &This->gif->SavedImages[index];
1314     IWICBitmapDecoder_AddRef(iface);
1315     result->parent = This;
1316     This->current_frame = index;
1317
1318     *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
1319
1320     return S_OK;
1321 }
1322
1323 static const IWICBitmapDecoderVtbl GifDecoder_Vtbl = {
1324     GifDecoder_QueryInterface,
1325     GifDecoder_AddRef,
1326     GifDecoder_Release,
1327     GifDecoder_QueryCapability,
1328     GifDecoder_Initialize,
1329     GifDecoder_GetContainerFormat,
1330     GifDecoder_GetDecoderInfo,
1331     GifDecoder_CopyPalette,
1332     GifDecoder_GetMetadataQueryReader,
1333     GifDecoder_GetPreview,
1334     GifDecoder_GetColorContexts,
1335     GifDecoder_GetThumbnail,
1336     GifDecoder_GetFrameCount,
1337     GifDecoder_GetFrame
1338 };
1339
1340 static HRESULT WINAPI GifDecoder_Block_QueryInterface(IWICMetadataBlockReader *iface,
1341     REFIID iid, void **ppv)
1342 {
1343     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1344     return IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1345 }
1346
1347 static ULONG WINAPI GifDecoder_Block_AddRef(IWICMetadataBlockReader *iface)
1348 {
1349     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1350     return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
1351 }
1352
1353 static ULONG WINAPI GifDecoder_Block_Release(IWICMetadataBlockReader *iface)
1354 {
1355     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1356     return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1357 }
1358
1359 static HRESULT WINAPI GifDecoder_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
1360     GUID *guid)
1361 {
1362     TRACE("(%p,%p)\n", iface, guid);
1363
1364     if (!guid) return E_INVALIDARG;
1365
1366     *guid = GUID_ContainerFormatGif;
1367     return S_OK;
1368 }
1369
1370 static HRESULT WINAPI GifDecoder_Block_GetCount(IWICMetadataBlockReader *iface,
1371     UINT *count)
1372 {
1373     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1374
1375     TRACE("%p,%p\n", iface, count);
1376
1377     if (!count) return E_INVALIDARG;
1378
1379     *count = This->gif->Extensions.ExtensionBlockCount + 1;
1380     return S_OK;
1381 }
1382
1383 static HRESULT WINAPI GifDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
1384     UINT index, IWICMetadataReader **reader)
1385 {
1386     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1387     int i;
1388
1389     TRACE("(%p,%u,%p)\n", iface, index, reader);
1390
1391     if (!reader) return E_INVALIDARG;
1392
1393     if (index == 0)
1394         return create_metadata_reader(This->LSD_data, sizeof(This->LSD_data),
1395                                       LSDReader_CreateInstance, reader);
1396
1397     for (i = 0; i < This->gif->Extensions.ExtensionBlockCount; i++)
1398     {
1399         class_constructor constructor;
1400
1401         if (index != i + 1) continue;
1402
1403         if (This->gif->Extensions.ExtensionBlocks[i].Function == APPLICATION_EXT_FUNC_CODE)
1404             constructor = APEReader_CreateInstance;
1405         else if (This->gif->Extensions.ExtensionBlocks[i].Function == COMMENT_EXT_FUNC_CODE)
1406             constructor = GifCommentReader_CreateInstance;
1407         else
1408             constructor = UnknownMetadataReader_CreateInstance;
1409
1410         return create_metadata_reader(This->gif->Extensions.ExtensionBlocks[i].Bytes,
1411                                       This->gif->Extensions.ExtensionBlocks[i].ByteCount,
1412                                       constructor, reader);
1413     }
1414
1415     return E_INVALIDARG;
1416 }
1417
1418 static HRESULT WINAPI GifDecoder_Block_GetEnumerator(IWICMetadataBlockReader *iface,
1419     IEnumUnknown **enumerator)
1420 {
1421     FIXME("(%p,%p): stub\n", iface, enumerator);
1422     return E_NOTIMPL;
1423 }
1424
1425 static const IWICMetadataBlockReaderVtbl GifDecoder_BlockVtbl =
1426 {
1427     GifDecoder_Block_QueryInterface,
1428     GifDecoder_Block_AddRef,
1429     GifDecoder_Block_Release,
1430     GifDecoder_Block_GetContainerFormat,
1431     GifDecoder_Block_GetCount,
1432     GifDecoder_Block_GetReaderByIndex,
1433     GifDecoder_Block_GetEnumerator
1434 };
1435
1436 HRESULT GifDecoder_CreateInstance(REFIID iid, void** ppv)
1437 {
1438     GifDecoder *This;
1439     HRESULT ret;
1440
1441     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1442
1443     *ppv = NULL;
1444
1445     This = HeapAlloc(GetProcessHeap(), 0, sizeof(GifDecoder));
1446     if (!This) return E_OUTOFMEMORY;
1447
1448     This->IWICBitmapDecoder_iface.lpVtbl = &GifDecoder_Vtbl;
1449     This->IWICMetadataBlockReader_iface.lpVtbl = &GifDecoder_BlockVtbl;
1450     This->stream = NULL;
1451     This->ref = 1;
1452     This->initialized = FALSE;
1453     This->gif = NULL;
1454     This->current_frame = 0;
1455     InitializeCriticalSection(&This->lock);
1456     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifDecoder.lock");
1457
1458     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1459     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1460
1461     return ret;
1462 }