dlls/windowscodecs/gifformat.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  * Copyright 2012,2016 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28
  29 #include "ungif.h"
  30
  31 #include "wincodecs_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  36
  37 #include "pshpack1.h"
  38
  39 struct logical_screen_descriptor
  40 {
  41     char signature[6];
  42     USHORT width;
  43     USHORT height;
  44     BYTE packed;
  45     /* global_color_table_flag : 1;
  46      * color_resolution : 3;
  47      * sort_flag : 1;
  48      * global_color_table_size : 3;
  49      */
  50     BYTE background_color_index;
  51     BYTE pixel_aspect_ratio;
  52 };
  53
  54 struct image_descriptor
  55 {
  56     USHORT left;
  57     USHORT top;
  58     USHORT width;
  59     USHORT height;
  60     BYTE packed;
  61     /* local_color_table_flag : 1;
  62      * interlace_flag : 1;
  63      * sort_flag : 1;
  64      * reserved : 2;
  65      * local_color_table_size : 3;
  66      */
  67 };
  68
  69 #include "poppack.h"
  70
  71 static LPWSTR strdupAtoW(const char *src)
  72 {
  73     int len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
  74     LPWSTR dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  75     if (dst) MultiByteToWideChar(CP_ACP, 0, src, -1, dst, len);
  76     return dst;
  77 }
  78
  79 static HRESULT load_LSD_metadata(IStream *stream, const GUID *vendor, DWORD options,
  80                                  MetadataItem **items, DWORD *count)
  81 {
  82     struct logical_screen_descriptor lsd_data;
  83     HRESULT hr;
  84     ULONG bytesread, i;
  85     MetadataItem *result;
  86
  87     *items = NULL;
  88     *count = 0;
  89
  90     hr = IStream_Read(stream, &lsd_data, sizeof(lsd_data), &bytesread);
  91     if (FAILED(hr) || bytesread != sizeof(lsd_data)) return S_OK;
  92
  93     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 9);
  94     if (!result) return E_OUTOFMEMORY;
  95
  96     for (i = 0; i < 9; i++)
  97     {
  98         PropVariantInit(&result[i].schema);
  99         PropVariantInit(&result[i].id);
 100         PropVariantInit(&result[i].value);
 101     }
 102
 103     result[0].id.vt = VT_LPWSTR;
 104     result[0].id.pwszVal = strdupAtoW("Signature");
 105     result[0].value.vt = VT_UI1|VT_VECTOR;
 106     result[0].value.caub.cElems = sizeof(lsd_data.signature);
 107     result[0].value.caub.pElems = HeapAlloc(GetProcessHeap(), 0, sizeof(lsd_data.signature));
 108     memcpy(result[0].value.caub.pElems, lsd_data.signature, sizeof(lsd_data.signature));
 109
 110     result[1].id.vt = VT_LPWSTR;
 111     result[1].id.pwszVal = strdupAtoW("Width");
 112     result[1].value.vt = VT_UI2;
 113     result[1].value.uiVal = lsd_data.width;
 114
 115     result[2].id.vt = VT_LPWSTR;
 116     result[2].id.pwszVal = strdupAtoW("Height");
 117     result[2].value.vt = VT_UI2;
 118     result[2].value.uiVal = lsd_data.height;
 119
 120     result[3].id.vt = VT_LPWSTR;
 121     result[3].id.pwszVal = strdupAtoW("GlobalColorTableFlag");
 122     result[3].value.vt = VT_BOOL;
 123     result[3].value.boolVal = (lsd_data.packed >> 7) & 1;
 124
 125     result[4].id.vt = VT_LPWSTR;
 126     result[4].id.pwszVal = strdupAtoW("ColorResolution");
 127     result[4].value.vt = VT_UI1;
 128     result[4].value.bVal = (lsd_data.packed >> 4) & 7;
 129
 130     result[5].id.vt = VT_LPWSTR;
 131     result[5].id.pwszVal = strdupAtoW("SortFlag");
 132     result[5].value.vt = VT_BOOL;
 133     result[5].value.boolVal = (lsd_data.packed >> 3) & 1;
 134
 135     result[6].id.vt = VT_LPWSTR;
 136     result[6].id.pwszVal = strdupAtoW("GlobalColorTableSize");
 137     result[6].value.vt = VT_UI1;
 138     result[6].value.bVal = lsd_data.packed & 7;
 139
 140     result[7].id.vt = VT_LPWSTR;
 141     result[7].id.pwszVal = strdupAtoW("BackgroundColorIndex");
 142     result[7].value.vt = VT_UI1;
 143     result[7].value.bVal = lsd_data.background_color_index;
 144
 145     result[8].id.vt = VT_LPWSTR;
 146     result[8].id.pwszVal = strdupAtoW("PixelAspectRatio");
 147     result[8].value.vt = VT_UI1;
 148     result[8].value.bVal = lsd_data.pixel_aspect_ratio;
 149
 150     *items = result;
 151     *count = 9;
 152
 153     return S_OK;
 154 }
 155
 156 static const MetadataHandlerVtbl LSDReader_Vtbl = {
 157     0,
 158     &CLSID_WICLSDMetadataReader,
 159     load_LSD_metadata
 160 };
 161
 162 HRESULT LSDReader_CreateInstance(REFIID iid, void **ppv)
 163 {
 164     return MetadataReader_Create(&LSDReader_Vtbl, iid, ppv);
 165 }
 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.pwszVal = strdupAtoW("Left");
 193     result[0].value.vt = VT_UI2;
 194     result[0].value.uiVal = imd_data.left;
 195
 196     result[1].id.vt = VT_LPWSTR;
 197     result[1].id.pwszVal = strdupAtoW("Top");
 198     result[1].value.vt = VT_UI2;
 199     result[1].value.uiVal = imd_data.top;
 200
 201     result[2].id.vt = VT_LPWSTR;
 202     result[2].id.pwszVal = strdupAtoW("Width");
 203     result[2].value.vt = VT_UI2;
 204     result[2].value.uiVal = imd_data.width;
 205
 206     result[3].id.vt = VT_LPWSTR;
 207     result[3].id.pwszVal = strdupAtoW("Height");
 208     result[3].value.vt = VT_UI2;
 209     result[3].value.uiVal = imd_data.height;
 210
 211     result[4].id.vt = VT_LPWSTR;
 212     result[4].id.pwszVal = strdupAtoW("LocalColorTableFlag");
 213     result[4].value.vt = VT_BOOL;
 214     result[4].value.boolVal = (imd_data.packed >> 7) & 1;
 215
 216     result[5].id.vt = VT_LPWSTR;
 217     result[5].id.pwszVal = strdupAtoW("InterlaceFlag");
 218     result[5].value.vt = VT_BOOL;
 219     result[5].value.boolVal = (imd_data.packed >> 6) & 1;
 220
 221     result[6].id.vt = VT_LPWSTR;
 222     result[6].id.pwszVal = strdupAtoW("SortFlag");
 223     result[6].value.vt = VT_BOOL;
 224     result[6].value.boolVal = (imd_data.packed >> 5) & 1;
 225
 226     result[7].id.vt = VT_LPWSTR;
 227     result[7].id.pwszVal = strdupAtoW("LocalColorTableSize");
 228     result[7].value.vt = VT_UI1;
 229     result[7].value.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.pwszVal = strdupAtoW("Disposal");
 286     result[0].value.vt = VT_UI1;
 287     result[0].value.bVal = (gce_data.packed >> 2) & 7;
 288
 289     result[1].id.vt = VT_LPWSTR;
 290     result[1].id.pwszVal = strdupAtoW("UserInputFlag");
 291     result[1].value.vt = VT_BOOL;
 292     result[1].value.boolVal = (gce_data.packed >> 1) & 1;
 293
 294     result[2].id.vt = VT_LPWSTR;
 295     result[2].id.pwszVal = strdupAtoW("TransparencyFlag");
 296     result[2].value.vt = VT_BOOL;
 297     result[2].value.boolVal = gce_data.packed & 1;
 298
 299     result[3].id.vt = VT_LPWSTR;
 300     result[3].id.pwszVal = strdupAtoW("Delay");
 301     result[3].value.vt = VT_UI2;
 302     result[3].value.uiVal = gce_data.delay;
 303
 304     result[4].id.vt = VT_LPWSTR;
 305     result[4].id.pwszVal = strdupAtoW("TransparentColorIndex");
 306     result[4].value.vt = VT_UI1;
 307     result[4].value.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.pwszVal = strdupAtoW("Application");
 405     result[0].value.vt = VT_UI1|VT_VECTOR;
 406     result[0].value.caub.cElems = sizeof(ape_data.application);
 407     result[0].value.caub.pElems = HeapAlloc(GetProcessHeap(), 0, sizeof(ape_data.application));
 408     memcpy(result[0].value.caub.pElems, ape_data.application, sizeof(ape_data.application));
 409
 410     result[1].id.vt = VT_LPWSTR;
 411     result[1].id.pwszVal = strdupAtoW("Data");
 412     result[1].value.vt = VT_UI1|VT_VECTOR;
 413     result[1].value.caub.cElems = data_size;
 414     result[1].value.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.pwszVal = strdupAtoW("TextEntry");
 507     result->value.vt = VT_LPSTR;
 508     result->value.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=%lu\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=%lu\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,%s,%u,%u,%p)\n", iface, debug_wic_rect(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     class_constructor constructor;
 951     ExtensionBlock *ext;
 952     const void *data;
 953     int data_size;
 954
 955     TRACE("(%p,%u,%p)\n", iface, index, reader);
 956
 957     if (!reader) return E_INVALIDARG;
 958
 959     if (index == 0)
 960         return create_IMD_metadata_reader(This, reader);
 961
 962     if (index >= This->frame->Extensions.ExtensionBlockCount + 1)
 963         return E_INVALIDARG;
 964
 965     ext = This->frame->Extensions.ExtensionBlocks + index - 1;
 966     if (ext->Function == GRAPHICS_EXT_FUNC_CODE)
 967     {
 968         constructor = GCEReader_CreateInstance;
 969         data = ext->Bytes + 3;
 970         data_size = ext->ByteCount - 4;
 971     }
 972     else if (ext->Function == COMMENT_EXT_FUNC_CODE)
 973     {
 974         constructor = GifCommentReader_CreateInstance;
 975         data = ext->Bytes;
 976         data_size = ext->ByteCount;
 977     }
 978     else
 979     {
 980         constructor = UnknownMetadataReader_CreateInstance;
 981         data = ext->Bytes;
 982         data_size = ext->ByteCount;
 983     }
 984
 985     return create_metadata_reader(data, data_size, constructor, reader);
 986 }
 987
 988 static HRESULT WINAPI GifFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader *iface,
 989     IEnumUnknown **enumerator)
 990 {
 991     FIXME("(%p,%p): stub\n", iface, enumerator);
 992     return E_NOTIMPL;
 993 }
 994
 995 static const IWICMetadataBlockReaderVtbl GifFrameDecode_BlockVtbl =
 996 {
 997     GifFrameDecode_Block_QueryInterface,
 998     GifFrameDecode_Block_AddRef,
 999     GifFrameDecode_Block_Release,
1000     GifFrameDecode_Block_GetContainerFormat,
1001     GifFrameDecode_Block_GetCount,
1002     GifFrameDecode_Block_GetReaderByIndex,
1003     GifFrameDecode_Block_GetEnumerator
1004 };
1005
1006 static HRESULT WINAPI GifDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
1007     void **ppv)
1008 {
1009     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1010     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1011
1012     if (!ppv) return E_INVALIDARG;
1013
1014     if (IsEqualIID(&IID_IUnknown, iid) ||
1015         IsEqualIID(&IID_IWICBitmapDecoder, iid))
1016     {
1017         *ppv = &This->IWICBitmapDecoder_iface;
1018     }
1019     else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
1020     {
1021         *ppv = &This->IWICMetadataBlockReader_iface;
1022     }
1023     else
1024     {
1025         *ppv = NULL;
1026         return E_NOINTERFACE;
1027     }
1028
1029     IUnknown_AddRef((IUnknown*)*ppv);
1030     return S_OK;
1031 }
1032
1033 static ULONG WINAPI GifDecoder_AddRef(IWICBitmapDecoder *iface)
1034 {
1035     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1036     ULONG ref = InterlockedIncrement(&This->ref);
1037
1038     TRACE("(%p) refcount=%lu\n", iface, ref);
1039
1040     return ref;
1041 }
1042
1043 static ULONG WINAPI GifDecoder_Release(IWICBitmapDecoder *iface)
1044 {
1045     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1046     ULONG ref = InterlockedDecrement(&This->ref);
1047
1048     TRACE("(%p) refcount=%lu\n", iface, ref);
1049
1050     if (ref == 0)
1051     {
1052         if (This->stream)
1053         {
1054             IStream_Release(This->stream);
1055             DGifCloseFile(This->gif);
1056         }
1057         This->lock.DebugInfo->Spare[0] = 0;
1058         DeleteCriticalSection(&This->lock);
1059         HeapFree(GetProcessHeap(), 0, This);
1060     }
1061
1062     return ref;
1063 }
1064
1065 static HRESULT WINAPI GifDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
1066     DWORD *capability)
1067 {
1068     HRESULT hr;
1069
1070     TRACE("(%p,%p,%p)\n", iface, stream, capability);
1071
1072     if (!stream || !capability) return E_INVALIDARG;
1073
1074     hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
1075     if (hr != S_OK) return hr;
1076
1077     *capability = WICBitmapDecoderCapabilityCanDecodeAllImages |
1078                   WICBitmapDecoderCapabilityCanDecodeSomeImages |
1079                   WICBitmapDecoderCapabilityCanEnumerateMetadata;
1080     return S_OK;
1081 }
1082
1083 static int _gif_inputfunc(GifFileType *gif, GifByteType *data, int len) {
1084     IStream *stream = gif->UserData;
1085     ULONG bytesread;
1086     HRESULT hr;
1087
1088     if (!stream)
1089     {
1090         ERR("attempting to read file after initialization\n");
1091         return 0;
1092     }
1093
1094     hr = IStream_Read(stream, data, len, &bytesread);
1095     if (FAILED(hr)) bytesread = 0;
1096     return bytesread;
1097 }
1098
1099 static HRESULT WINAPI GifDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
1100     WICDecodeOptions cacheOptions)
1101 {
1102     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1103     LARGE_INTEGER seek;
1104     int ret;
1105
1106     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
1107
1108     EnterCriticalSection(&This->lock);
1109
1110     if (This->initialized || This->gif)
1111     {
1112         WARN("already initialized\n");
1113         LeaveCriticalSection(&This->lock);
1114         return WINCODEC_ERR_WRONGSTATE;
1115     }
1116
1117     /* seek to start of stream */
1118     seek.QuadPart = 0;
1119     IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
1120
1121     /* read all data from the stream */
1122     This->gif = DGifOpen((void*)pIStream, _gif_inputfunc);
1123     if (!This->gif)
1124     {
1125         LeaveCriticalSection(&This->lock);
1126         return E_FAIL;
1127     }
1128
1129     ret = DGifSlurp(This->gif);
1130     if (ret == GIF_ERROR)
1131     {
1132         LeaveCriticalSection(&This->lock);
1133         return E_FAIL;
1134     }
1135
1136     /* make sure we don't use the stream after this method returns */
1137     This->gif->UserData = NULL;
1138
1139     seek.QuadPart = 0;
1140     IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
1141     IStream_Read(pIStream, This->LSD_data, sizeof(This->LSD_data), NULL);
1142
1143     This->stream = pIStream;
1144     IStream_AddRef(This->stream);
1145
1146     This->initialized = TRUE;
1147
1148     LeaveCriticalSection(&This->lock);
1149
1150     return S_OK;
1151 }
1152
1153 static HRESULT WINAPI GifDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
1154     GUID *pguidContainerFormat)
1155 {
1156     memcpy(pguidContainerFormat, &GUID_ContainerFormatGif, sizeof(GUID));
1157     return S_OK;
1158 }
1159
1160 static HRESULT WINAPI GifDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
1161     IWICBitmapDecoderInfo **ppIDecoderInfo)
1162 {
1163     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
1164
1165     return get_decoder_info(&CLSID_WICGifDecoder, ppIDecoderInfo);
1166 }
1167
1168 static HRESULT WINAPI GifDecoder_CopyPalette(IWICBitmapDecoder *iface, IWICPalette *palette)
1169 {
1170     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1171     WICColor colors[256];
1172     ColorMapObject *cm;
1173     int i, trans, count;
1174     ExtensionBlock *eb;
1175
1176     TRACE("(%p,%p)\n", iface, palette);
1177
1178     if (!This->gif)
1179         return WINCODEC_ERR_WRONGSTATE;
1180
1181     cm = This->gif->SColorMap;
1182     if (cm)
1183     {
1184         if (cm->ColorCount > 256)
1185         {
1186             ERR("GIF contains invalid number of colors: %d\n", cm->ColorCount);
1187             return E_FAIL;
1188         }
1189
1190         for (i = 0; i < cm->ColorCount; i++)
1191         {
1192             colors[i] = 0xff000000 | /* alpha */
1193                         cm->Colors[i].Red << 16 |
1194                         cm->Colors[i].Green << 8 |
1195                         cm->Colors[i].Blue;
1196         }
1197
1198         count = cm->ColorCount;
1199     }
1200     else
1201     {
1202         colors[0] = 0xff000000;
1203         colors[1] = 0xffffffff;
1204
1205         for (i = 2; i < 256; i++)
1206             colors[i] = 0xff000000;
1207
1208         count = 256;
1209     }
1210
1211     /* look for the transparent color extension */
1212     for (i = 0; i < This->gif->SavedImages[This->current_frame].Extensions.ExtensionBlockCount; i++)
1213     {
1214         eb = This->gif->SavedImages[This->current_frame].Extensions.ExtensionBlocks + i;
1215         if (eb->Function == GRAPHICS_EXT_FUNC_CODE && eb->ByteCount == 8)
1216         {
1217             if (eb->Bytes[3] & 1)
1218             {
1219                 trans = (unsigned char)eb->Bytes[6];
1220                 colors[trans] &= 0xffffff; /* set alpha to 0 */
1221                 break;
1222             }
1223         }
1224     }
1225
1226     return IWICPalette_InitializeCustom(palette, colors, count);
1227 }
1228
1229 static HRESULT WINAPI GifDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
1230     IWICMetadataQueryReader **ppIMetadataQueryReader)
1231 {
1232     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1233
1234     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
1235
1236     if (!ppIMetadataQueryReader) return E_INVALIDARG;
1237
1238     return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
1239 }
1240
1241 static HRESULT WINAPI GifDecoder_GetPreview(IWICBitmapDecoder *iface,
1242     IWICBitmapSource **ppIBitmapSource)
1243 {
1244     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
1245     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1246 }
1247
1248 static HRESULT WINAPI GifDecoder_GetColorContexts(IWICBitmapDecoder *iface,
1249     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
1250 {
1251     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
1252     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1253 }
1254
1255 static HRESULT WINAPI GifDecoder_GetThumbnail(IWICBitmapDecoder *iface,
1256     IWICBitmapSource **ppIThumbnail)
1257 {
1258     TRACE("(%p,%p)\n", iface, ppIThumbnail);
1259     return WINCODEC_ERR_CODECNOTHUMBNAIL;
1260 }
1261
1262 static HRESULT WINAPI GifDecoder_GetFrameCount(IWICBitmapDecoder *iface,
1263     UINT *pCount)
1264 {
1265     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1266
1267     if (!pCount) return E_INVALIDARG;
1268
1269     EnterCriticalSection(&This->lock);
1270     *pCount = This->gif ? This->gif->ImageCount : 0;
1271     LeaveCriticalSection(&This->lock);
1272
1273     TRACE("(%p) <-- %d\n", iface, *pCount);
1274
1275     return S_OK;
1276 }
1277
1278 static HRESULT WINAPI GifDecoder_GetFrame(IWICBitmapDecoder *iface,
1279     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
1280 {
1281     GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
1282     GifFrameDecode *result;
1283     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
1284
1285     if (!This->initialized) return WINCODEC_ERR_FRAMEMISSING;
1286
1287     if (index >= This->gif->ImageCount) return E_INVALIDARG;
1288
1289     result = HeapAlloc(GetProcessHeap(), 0, sizeof(GifFrameDecode));
1290     if (!result) return E_OUTOFMEMORY;
1291
1292     result->IWICBitmapFrameDecode_iface.lpVtbl = &GifFrameDecode_Vtbl;
1293     result->IWICMetadataBlockReader_iface.lpVtbl = &GifFrameDecode_BlockVtbl;
1294     result->ref = 1;
1295     result->frame = &This->gif->SavedImages[index];
1296     IWICBitmapDecoder_AddRef(iface);
1297     result->parent = This;
1298     This->current_frame = index;
1299
1300     *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
1301
1302     return S_OK;
1303 }
1304
1305 static const IWICBitmapDecoderVtbl GifDecoder_Vtbl = {
1306     GifDecoder_QueryInterface,
1307     GifDecoder_AddRef,
1308     GifDecoder_Release,
1309     GifDecoder_QueryCapability,
1310     GifDecoder_Initialize,
1311     GifDecoder_GetContainerFormat,
1312     GifDecoder_GetDecoderInfo,
1313     GifDecoder_CopyPalette,
1314     GifDecoder_GetMetadataQueryReader,
1315     GifDecoder_GetPreview,
1316     GifDecoder_GetColorContexts,
1317     GifDecoder_GetThumbnail,
1318     GifDecoder_GetFrameCount,
1319     GifDecoder_GetFrame
1320 };
1321
1322 static HRESULT WINAPI GifDecoder_Block_QueryInterface(IWICMetadataBlockReader *iface,
1323     REFIID iid, void **ppv)
1324 {
1325     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1326     return IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1327 }
1328
1329 static ULONG WINAPI GifDecoder_Block_AddRef(IWICMetadataBlockReader *iface)
1330 {
1331     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1332     return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
1333 }
1334
1335 static ULONG WINAPI GifDecoder_Block_Release(IWICMetadataBlockReader *iface)
1336 {
1337     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1338     return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1339 }
1340
1341 static HRESULT WINAPI GifDecoder_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
1342     GUID *guid)
1343 {
1344     TRACE("(%p,%p)\n", iface, guid);
1345
1346     if (!guid) return E_INVALIDARG;
1347
1348     *guid = GUID_ContainerFormatGif;
1349     return S_OK;
1350 }
1351
1352 static HRESULT WINAPI GifDecoder_Block_GetCount(IWICMetadataBlockReader *iface,
1353     UINT *count)
1354 {
1355     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1356
1357     TRACE("%p,%p\n", iface, count);
1358
1359     if (!count) return E_INVALIDARG;
1360
1361     *count = This->gif->Extensions.ExtensionBlockCount + 1;
1362     return S_OK;
1363 }
1364
1365 static HRESULT WINAPI GifDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
1366     UINT index, IWICMetadataReader **reader)
1367 {
1368     GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1369     int i;
1370
1371     TRACE("(%p,%u,%p)\n", iface, index, reader);
1372
1373     if (!reader) return E_INVALIDARG;
1374
1375     if (index == 0)
1376         return create_metadata_reader(This->LSD_data, sizeof(This->LSD_data),
1377                                       LSDReader_CreateInstance, reader);
1378
1379     for (i = 0; i < This->gif->Extensions.ExtensionBlockCount; i++)
1380     {
1381         class_constructor constructor;
1382
1383         if (index != i + 1) continue;
1384
1385         if (This->gif->Extensions.ExtensionBlocks[i].Function == APPLICATION_EXT_FUNC_CODE)
1386             constructor = APEReader_CreateInstance;
1387         else if (This->gif->Extensions.ExtensionBlocks[i].Function == COMMENT_EXT_FUNC_CODE)
1388             constructor = GifCommentReader_CreateInstance;
1389         else
1390             constructor = UnknownMetadataReader_CreateInstance;
1391
1392         return create_metadata_reader(This->gif->Extensions.ExtensionBlocks[i].Bytes,
1393                                       This->gif->Extensions.ExtensionBlocks[i].ByteCount,
1394                                       constructor, reader);
1395     }
1396
1397     return E_INVALIDARG;
1398 }
1399
1400 static HRESULT WINAPI GifDecoder_Block_GetEnumerator(IWICMetadataBlockReader *iface,
1401     IEnumUnknown **enumerator)
1402 {
1403     FIXME("(%p,%p): stub\n", iface, enumerator);
1404     return E_NOTIMPL;
1405 }
1406
1407 static const IWICMetadataBlockReaderVtbl GifDecoder_BlockVtbl =
1408 {
1409     GifDecoder_Block_QueryInterface,
1410     GifDecoder_Block_AddRef,
1411     GifDecoder_Block_Release,
1412     GifDecoder_Block_GetContainerFormat,
1413     GifDecoder_Block_GetCount,
1414     GifDecoder_Block_GetReaderByIndex,
1415     GifDecoder_Block_GetEnumerator
1416 };
1417
1418 HRESULT GifDecoder_CreateInstance(REFIID iid, void** ppv)
1419 {
1420     GifDecoder *This;
1421     HRESULT ret;
1422
1423     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1424
1425     *ppv = NULL;
1426
1427     This = HeapAlloc(GetProcessHeap(), 0, sizeof(GifDecoder));
1428     if (!This) return E_OUTOFMEMORY;
1429
1430     This->IWICBitmapDecoder_iface.lpVtbl = &GifDecoder_Vtbl;
1431     This->IWICMetadataBlockReader_iface.lpVtbl = &GifDecoder_BlockVtbl;
1432     This->stream = NULL;
1433     This->ref = 1;
1434     This->initialized = FALSE;
1435     This->gif = NULL;
1436     This->current_frame = 0;
1437     InitializeCriticalSection(&This->lock);
1438     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifDecoder.lock");
1439
1440     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1441     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1442
1443     return ret;
1444 }
1445
1446 typedef struct GifEncoder
1447 {
1448     IWICBitmapEncoder IWICBitmapEncoder_iface;
1449     LONG ref;
1450     IStream *stream;
1451     CRITICAL_SECTION lock;
1452     BOOL initialized, info_written, committed;
1453     UINT n_frames;
1454     WICColor palette[256];
1455     UINT colors;
1456 } GifEncoder;
1457
1458 static inline GifEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
1459 {
1460     return CONTAINING_RECORD(iface, GifEncoder, IWICBitmapEncoder_iface);
1461 }
1462
1463 typedef struct GifFrameEncode
1464 {
1465     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
1466     IWICMetadataBlockWriter IWICMetadataBlockWriter_iface;
1467     LONG ref;
1468     GifEncoder *encoder;
1469     BOOL initialized, interlace, committed;
1470     UINT width, height, lines;
1471     double xres, yres;
1472     WICColor palette[256];
1473     UINT colors;
1474     BYTE *image_data;
1475 } GifFrameEncode;
1476
1477 static inline GifFrameEncode *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
1478 {
1479     return CONTAINING_RECORD(iface, GifFrameEncode, IWICBitmapFrameEncode_iface);
1480 }
1481
1482 static inline GifFrameEncode *impl_from_IWICMetadataBlockWriter(IWICMetadataBlockWriter *iface)
1483 {
1484     return CONTAINING_RECORD(iface, GifFrameEncode, IWICMetadataBlockWriter_iface);
1485 }
1486
1487 static HRESULT WINAPI GifFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid, void **ppv)
1488 {
1489     GifFrameEncode *encoder = impl_from_IWICBitmapFrameEncode(iface);
1490
1491     TRACE("%p,%s,%p\n", iface, debugstr_guid(iid), ppv);
1492
1493     if (!ppv) return E_INVALIDARG;
1494
1495     if (IsEqualIID(&IID_IUnknown, iid) ||
1496         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
1497     {
1498         *ppv = iface;
1499     }
1500     else if (IsEqualIID(&IID_IWICMetadataBlockWriter, iid))
1501     {
1502         *ppv = &encoder->IWICMetadataBlockWriter_iface;
1503     }
1504     else
1505     {
1506         *ppv = NULL;
1507         return E_NOINTERFACE;
1508     }
1509
1510     IUnknown_AddRef((IUnknown *)*ppv);
1511     return S_OK;
1512 }
1513
1514 static ULONG WINAPI GifFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
1515 {
1516     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1517     ULONG ref = InterlockedIncrement(&This->ref);
1518
1519     TRACE("%p -> %lu\n", iface, ref);
1520     return ref;
1521 }
1522
1523 static ULONG WINAPI GifFrameEncode_Release(IWICBitmapFrameEncode *iface)
1524 {
1525     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1526     ULONG ref = InterlockedDecrement(&This->ref);
1527
1528     TRACE("%p -> %lu\n", iface, ref);
1529
1530     if (!ref)
1531     {
1532         IWICBitmapEncoder_Release(&This->encoder->IWICBitmapEncoder_iface);
1533         HeapFree(GetProcessHeap(), 0, This->image_data);
1534         HeapFree(GetProcessHeap(), 0, This);
1535     }
1536
1537     return ref;
1538 }
1539
1540 static HRESULT WINAPI GifFrameEncode_Initialize(IWICBitmapFrameEncode *iface, IPropertyBag2 *options)
1541 {
1542     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1543     HRESULT hr;
1544
1545     TRACE("%p,%p\n", iface, options);
1546
1547     EnterCriticalSection(&This->encoder->lock);
1548
1549     if (!This->initialized)
1550     {
1551         This->initialized = TRUE;
1552         hr = S_OK;
1553     }
1554     else
1555         hr = WINCODEC_ERR_WRONGSTATE;
1556
1557     LeaveCriticalSection(&This->encoder->lock);
1558
1559     return hr;
1560 }
1561
1562 static HRESULT WINAPI GifFrameEncode_SetSize(IWICBitmapFrameEncode *iface, UINT width, UINT height)
1563 {
1564     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1565     HRESULT hr;
1566
1567     TRACE("%p,%u,%u\n", iface, width, height);
1568
1569     if (!width || !height) return E_INVALIDARG;
1570
1571     EnterCriticalSection(&This->encoder->lock);
1572
1573     if (This->initialized)
1574     {
1575         HeapFree(GetProcessHeap(), 0, This->image_data);
1576
1577         This->image_data = HeapAlloc(GetProcessHeap(), 0, width * height);
1578         if (This->image_data)
1579         {
1580             This->width = width;
1581             This->height = height;
1582             hr = S_OK;
1583         }
1584         else
1585             hr = E_OUTOFMEMORY;
1586     }
1587     else
1588         hr = WINCODEC_ERR_WRONGSTATE;
1589
1590     LeaveCriticalSection(&This->encoder->lock);
1591
1592     return hr;
1593 }
1594
1595 static HRESULT WINAPI GifFrameEncode_SetResolution(IWICBitmapFrameEncode *iface, double xres, double yres)
1596 {
1597     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1598     HRESULT hr;
1599
1600     TRACE("%p,%f,%f\n", iface, xres, yres);
1601
1602     EnterCriticalSection(&This->encoder->lock);
1603
1604     if (This->initialized)
1605     {
1606         This->xres = xres;
1607         This->yres = yres;
1608         hr = S_OK;
1609     }
1610     else
1611         hr = WINCODEC_ERR_WRONGSTATE;
1612
1613     LeaveCriticalSection(&This->encoder->lock);
1614
1615     return hr;
1616 }
1617
1618 static HRESULT WINAPI GifFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface, WICPixelFormatGUID *format)
1619 {
1620     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1621     HRESULT hr;
1622
1623     TRACE("%p,%s\n", iface, debugstr_guid(format));
1624
1625     if (!format) return E_INVALIDARG;
1626
1627     EnterCriticalSection(&This->encoder->lock);
1628
1629     if (This->initialized)
1630     {
1631         *format = GUID_WICPixelFormat8bppIndexed;
1632         hr = S_OK;
1633     }
1634     else
1635         hr = WINCODEC_ERR_WRONGSTATE;
1636
1637     LeaveCriticalSection(&This->encoder->lock);
1638
1639     return hr;
1640 }
1641
1642 static HRESULT WINAPI GifFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface, UINT count, IWICColorContext **context)
1643 {
1644     FIXME("%p,%u,%p: stub\n", iface, count, context);
1645     return E_NOTIMPL;
1646 }
1647
1648 static HRESULT WINAPI GifFrameEncode_SetPalette(IWICBitmapFrameEncode *iface, IWICPalette *palette)
1649 {
1650     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1651     HRESULT hr;
1652
1653     TRACE("%p,%p\n", iface, palette);
1654
1655     if (!palette) return E_INVALIDARG;
1656
1657     EnterCriticalSection(&This->encoder->lock);
1658
1659     if (This->initialized)
1660         hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
1661     else
1662         hr = WINCODEC_ERR_NOTINITIALIZED;
1663
1664     LeaveCriticalSection(&This->encoder->lock);
1665     return hr;
1666 }
1667
1668 static HRESULT WINAPI GifFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface, IWICBitmapSource *thumbnail)
1669 {
1670     FIXME("%p,%p: stub\n", iface, thumbnail);
1671     return E_NOTIMPL;
1672 }
1673
1674 static HRESULT WINAPI GifFrameEncode_WritePixels(IWICBitmapFrameEncode *iface, UINT lines, UINT stride, UINT size, BYTE *pixels)
1675 {
1676     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1677     HRESULT hr;
1678
1679     TRACE("%p,%u,%u,%u,%p\n", iface, lines, stride, size, pixels);
1680
1681     if (!pixels) return E_INVALIDARG;
1682
1683     EnterCriticalSection(&This->encoder->lock);
1684
1685     if (This->initialized && This->image_data)
1686     {
1687         if (This->lines + lines <= This->height)
1688         {
1689             UINT i;
1690             BYTE *src, *dst;
1691
1692             src = pixels;
1693             dst = This->image_data + This->lines * This->width;
1694
1695             for (i = 0; i < lines; i++)
1696             {
1697                 memcpy(dst, src, This->width);
1698                 src += stride;
1699                 dst += This->width;
1700             }
1701
1702             This->lines += lines;
1703             hr = S_OK;
1704         }
1705         else
1706             hr = E_INVALIDARG;
1707     }
1708     else
1709         hr = WINCODEC_ERR_WRONGSTATE;
1710
1711     LeaveCriticalSection(&This->encoder->lock);
1712     return hr;
1713 }
1714
1715 static HRESULT WINAPI GifFrameEncode_WriteSource(IWICBitmapFrameEncode *iface, IWICBitmapSource *source, WICRect *rc)
1716 {
1717     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
1718     HRESULT hr;
1719
1720     TRACE("%p,%p,%p\n", iface, source, rc);
1721
1722     if (!source) return E_INVALIDARG;
1723
1724     EnterCriticalSection(&This->encoder->lock);
1725
1726     if (This->initialized)
1727     {
1728         const GUID *format = &GUID_WICPixelFormat8bppIndexed;
1729
1730         hr = configure_write_source(iface, source, rc, format,
1731                                     This->width, This->height, This->xres, This->yres);
1732         if (hr == S_OK)
1733             hr = write_source(iface, source, rc, format, 8, !This->colors, This->width, This->height);
1734     }
1735     else
1736         hr = WINCODEC_ERR_WRONGSTATE;
1737
1738     LeaveCriticalSection(&This->encoder->lock);
1739     return hr;
1740 }
1741
1742 #define LZW_DICT_SIZE (1 << 12)
1743
1744 struct lzw_dict
1745 {
1746     short prefix[LZW_DICT_SIZE];
1747     unsigned char suffix[LZW_DICT_SIZE];
1748 };
1749
1750 struct lzw_state
1751 {
1752     struct lzw_dict dict;
1753     short init_code_bits, code_bits, next_code, clear_code, eof_code;
1754     unsigned bits_buf;
1755     int bits_count;
1756     int (*user_write_data)(void *user_ptr, void *data, int length);
1757     void *user_ptr;
1758 };
1759
1760 struct input_stream
1761 {
1762     unsigned len;
1763     const BYTE *in;
1764 };
1765
1766 struct output_stream
1767 {
1768     struct
1769     {
1770         unsigned char len;
1771         char data[255];
1772     } gif_block;
1773     IStream *out;
1774 };
1775
1776 static int lzw_output_code(struct lzw_state *state, short code)
1777 {
1778     state->bits_buf |= code << state->bits_count;
1779     state->bits_count += state->code_bits;
1780
1781     while (state->bits_count >= 8)
1782     {
1783         unsigned char byte = (unsigned char)state->bits_buf;
1784         if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
1785             return 0;
1786         state->bits_buf >>= 8;
1787         state->bits_count -= 8;
1788     }
1789
1790     return 1;
1791 }
1792
1793 static inline int lzw_output_clear_code(struct lzw_state *state)
1794 {
1795     return lzw_output_code(state, state->clear_code);
1796 }
1797
1798 static inline int lzw_output_eof_code(struct lzw_state *state)
1799 {
1800     return lzw_output_code(state, state->eof_code);
1801 }
1802
1803 static int lzw_flush_bits(struct lzw_state *state)
1804 {
1805     unsigned char byte;
1806
1807     while (state->bits_count >= 8)
1808     {
1809         byte = (unsigned char)state->bits_buf;
1810         if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
1811             return 0;
1812         state->bits_buf >>= 8;
1813         state->bits_count -= 8;
1814     }
1815
1816     if (state->bits_count)
1817     {
1818         static const char mask[8] = { 0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f };
1819
1820         byte = (unsigned char)state->bits_buf & mask[state->bits_count];
1821         if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
1822             return 0;
1823     }
1824
1825     state->bits_buf = 0;
1826     state->bits_count = 0;
1827
1828     return 1;
1829 }
1830
1831 static void lzw_dict_reset(struct lzw_state *state)
1832 {
1833     int i;
1834
1835     state->code_bits = state->init_code_bits + 1;
1836     state->next_code = (1 << state->init_code_bits) + 2;
1837
1838     for(i = 0; i < LZW_DICT_SIZE; i++)
1839     {
1840         state->dict.prefix[i] = 1 << 12; /* impossible LZW code value */
1841         state->dict.suffix[i] = 0;
1842     }
1843 }
1844
1845 static void lzw_state_init(struct lzw_state *state, short init_code_bits, void *user_write_data, void *user_ptr)
1846 {
1847     state->init_code_bits = init_code_bits;
1848     state->clear_code = 1 << init_code_bits;
1849     state->eof_code = state->clear_code + 1;
1850     state->bits_buf = 0;
1851     state->bits_count = 0;
1852     state->user_write_data = user_write_data;
1853     state->user_ptr = user_ptr;
1854
1855     lzw_dict_reset(state);
1856 }
1857
1858 static int lzw_dict_add(struct lzw_state *state, short prefix, unsigned char suffix)
1859 {
1860     if (state->next_code < LZW_DICT_SIZE)
1861     {
1862         state->dict.prefix[state->next_code] = prefix;
1863         state->dict.suffix[state->next_code] = suffix;
1864
1865         if ((state->next_code & (state->next_code - 1)) == 0)
1866             state->code_bits++;
1867
1868         state->next_code++;
1869         return state->next_code;
1870     }
1871
1872     return -1;
1873 }
1874
1875 static short lzw_dict_lookup(const struct lzw_state *state, short prefix, unsigned char suffix)
1876 {
1877     short i;
1878
1879     for (i = 0; i < state->next_code; i++)
1880     {
1881         if (state->dict.prefix[i] == prefix && state->dict.suffix[i] == suffix)
1882             return i;
1883     }
1884
1885     return -1;
1886 }
1887
1888 static inline int write_byte(struct output_stream *out, char byte)
1889 {
1890     if (out->gif_block.len == 255)
1891     {
1892         if (IStream_Write(out->out, &out->gif_block, sizeof(out->gif_block), NULL) != S_OK)
1893             return 0;
1894
1895         out->gif_block.len = 0;
1896     }
1897
1898     out->gif_block.data[out->gif_block.len++] = byte;
1899
1900     return 1;
1901 }
1902
1903 static int write_data(void *user_ptr, void *user_data, int length)
1904 {
1905     unsigned char *data = user_data;
1906     struct output_stream *out = user_ptr;
1907     int len = length;
1908
1909     while (len-- > 0)
1910     {
1911         if (!write_byte(out, *data++)) return 0;
1912     }
1913
1914     return length;
1915 }
1916
1917 static int flush_output_data(void *user_ptr)
1918 {
1919     struct output_stream *out = user_ptr;
1920
1921     if (out->gif_block.len)
1922     {
1923         if (IStream_Write(out->out, &out->gif_block, out->gif_block.len + sizeof(out->gif_block.len), NULL) != S_OK)
1924             return 0;
1925     }
1926
1927     /* write GIF block terminator */
1928     out->gif_block.len = 0;
1929     return IStream_Write(out->out, &out->gif_block, sizeof(out->gif_block.len), NULL) == S_OK;
1930 }
1931
1932 static inline int read_byte(struct input_stream *in, unsigned char *byte)
1933 {
1934     if (in->len)
1935     {
1936         in->len--;
1937         *byte = *in->in++;
1938         return 1;
1939     }
1940
1941     return 0;
1942 }
1943
1944 static HRESULT gif_compress(IStream *out_stream, const BYTE *in_data, ULONG in_size)
1945 {
1946     struct input_stream in;
1947     struct output_stream out;
1948     struct lzw_state state;
1949     short init_code_bits, prefix, code;
1950     unsigned char suffix;
1951
1952     in.in = in_data;
1953     in.len = in_size;
1954
1955     out.gif_block.len = 0;
1956     out.out = out_stream;
1957
1958     init_code_bits = suffix = 8;
1959     if (IStream_Write(out.out, &suffix, sizeof(suffix), NULL) != S_OK)
1960         return E_FAIL;
1961
1962     lzw_state_init(&state, init_code_bits, write_data, &out);
1963
1964     if (!lzw_output_clear_code(&state))
1965         return E_FAIL;
1966
1967     if (read_byte(&in, &suffix))
1968     {
1969         prefix = suffix;
1970
1971         while (read_byte(&in, &suffix))
1972         {
1973             code = lzw_dict_lookup(&state, prefix, suffix);
1974             if (code == -1)
1975             {
1976                 if (!lzw_output_code(&state, prefix))
1977                     return E_FAIL;
1978
1979                 if (lzw_dict_add(&state, prefix, suffix) == -1)
1980                 {
1981                     if (!lzw_output_clear_code(&state))
1982                         return E_FAIL;
1983                     lzw_dict_reset(&state);
1984                 }
1985
1986                 prefix = suffix;
1987             }
1988             else
1989                 prefix = code;
1990         }
1991
1992         if (!lzw_output_code(&state, prefix))
1993             return E_FAIL;
1994         if (!lzw_output_eof_code(&state))
1995             return E_FAIL;
1996         if (!lzw_flush_bits(&state))
1997             return E_FAIL;
1998     }
1999
2000     return flush_output_data(&out) ? S_OK : E_FAIL;
2001 }
2002
2003 static HRESULT WINAPI GifFrameEncode_Commit(IWICBitmapFrameEncode *iface)
2004 {
2005     GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
2006     HRESULT hr;
2007
2008     TRACE("%p\n", iface);
2009
2010     EnterCriticalSection(&This->encoder->lock);
2011
2012     if (This->image_data && This->lines == This->height && !This->committed)
2013     {
2014         BYTE gif_palette[256][3];
2015
2016         hr = S_OK;
2017
2018         if (!This->encoder->info_written)
2019         {
2020             struct logical_screen_descriptor lsd;
2021
2022             /* Logical Screen Descriptor */
2023             memcpy(lsd.signature, "GIF89a", 6);
2024             lsd.width = This->width;
2025             lsd.height = This->height;
2026             lsd.packed = 0;
2027             if (This->encoder->colors)
2028                 lsd.packed |= 0x80; /* global color table flag */
2029             lsd.packed |= 0x07 << 4; /* color resolution */
2030             lsd.packed |= 0x07; /* global color table size */
2031             lsd.background_color_index = 0; /* FIXME */
2032             lsd.pixel_aspect_ratio = 0;
2033             hr = IStream_Write(This->encoder->stream, &lsd, sizeof(lsd), NULL);
2034             if (hr == S_OK && This->encoder->colors)
2035             {
2036                 UINT i;
2037
2038                 /* Global Color Table */
2039                 memset(gif_palette, 0, sizeof(gif_palette));
2040                 for (i = 0; i < This->encoder->colors; i++)
2041                 {
2042                     gif_palette[i][0] = (This->encoder->palette[i] >> 16) & 0xff;
2043                     gif_palette[i][1] = (This->encoder->palette[i] >> 8) & 0xff;
2044                     gif_palette[i][2] = This->encoder->palette[i] & 0xff;
2045                 }
2046                 hr = IStream_Write(This->encoder->stream, gif_palette, sizeof(gif_palette), NULL);
2047             }
2048
2049             /* FIXME: write GCE, APE, etc. GIF extensions */
2050
2051             if (hr == S_OK)
2052                 This->encoder->info_written = TRUE;
2053         }
2054
2055         if (hr == S_OK)
2056         {
2057             char image_separator = 0x2c;
2058
2059             hr = IStream_Write(This->encoder->stream, &image_separator, sizeof(image_separator), NULL);
2060             if (hr == S_OK)
2061             {
2062                 struct image_descriptor imd;
2063
2064                 /* Image Descriptor */
2065                 imd.left = 0;
2066                 imd.top = 0;
2067                 imd.width = This->width;
2068                 imd.height = This->height;
2069                 imd.packed = 0;
2070                 if (This->colors)
2071                 {
2072                     imd.packed |= 0x80; /* local color table flag */
2073                     imd.packed |= 0x07; /* local color table size */
2074                 }
2075                 /* FIXME: interlace flag */
2076                 hr = IStream_Write(This->encoder->stream, &imd, sizeof(imd), NULL);
2077                 if (hr == S_OK && This->colors)
2078                 {
2079                     UINT i;
2080
2081                     /* Local Color Table */
2082                     memset(gif_palette, 0, sizeof(gif_palette));
2083                     for (i = 0; i < This->colors; i++)
2084                     {
2085                         gif_palette[i][0] = (This->palette[i] >> 16) & 0xff;
2086                         gif_palette[i][1] = (This->palette[i] >> 8) & 0xff;
2087                         gif_palette[i][2] = This->palette[i] & 0xff;
2088                     }
2089                     hr = IStream_Write(This->encoder->stream, gif_palette, sizeof(gif_palette), NULL);
2090                     if (hr == S_OK)
2091                     {
2092                         /* Image Data */
2093                         hr = gif_compress(This->encoder->stream, This->image_data, This->width * This->height);
2094                         if (hr == S_OK)
2095                             This->committed = TRUE;
2096                     }
2097                 }
2098             }
2099         }
2100     }
2101     else
2102         hr = WINCODEC_ERR_WRONGSTATE;
2103
2104     LeaveCriticalSection(&This->encoder->lock);
2105     return hr;
2106 }
2107
2108 static HRESULT WINAPI GifFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface, IWICMetadataQueryWriter **writer)
2109 {
2110     GifFrameEncode *encode = impl_from_IWICBitmapFrameEncode(iface);
2111
2112     TRACE("iface, %p, writer %p.\n", iface, writer);
2113
2114     if (!writer)
2115         return E_INVALIDARG;
2116
2117     if (!encode->initialized)
2118         return WINCODEC_ERR_NOTINITIALIZED;
2119
2120     return MetadataQueryWriter_CreateInstance(&encode->IWICMetadataBlockWriter_iface, NULL, writer);
2121 }
2122
2123 static const IWICBitmapFrameEncodeVtbl GifFrameEncode_Vtbl =
2124 {
2125     GifFrameEncode_QueryInterface,
2126     GifFrameEncode_AddRef,
2127     GifFrameEncode_Release,
2128     GifFrameEncode_Initialize,
2129     GifFrameEncode_SetSize,
2130     GifFrameEncode_SetResolution,
2131     GifFrameEncode_SetPixelFormat,
2132     GifFrameEncode_SetColorContexts,
2133     GifFrameEncode_SetPalette,
2134     GifFrameEncode_SetThumbnail,
2135     GifFrameEncode_WritePixels,
2136     GifFrameEncode_WriteSource,
2137     GifFrameEncode_Commit,
2138     GifFrameEncode_GetMetadataQueryWriter
2139 };
2140
2141 static HRESULT WINAPI GifEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid, void **ppv)
2142 {
2143     TRACE("%p,%s,%p\n", iface, debugstr_guid(iid), ppv);
2144
2145     if (!ppv) return E_INVALIDARG;
2146
2147     if (IsEqualIID(&IID_IUnknown, iid) ||
2148         IsEqualIID(&IID_IWICBitmapEncoder, iid))
2149     {
2150         IWICBitmapEncoder_AddRef(iface);
2151         *ppv = iface;
2152         return S_OK;
2153     }
2154
2155     *ppv = NULL;
2156     return E_NOINTERFACE;
2157 }
2158
2159 static ULONG WINAPI GifEncoder_AddRef(IWICBitmapEncoder *iface)
2160 {
2161     GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
2162     ULONG ref = InterlockedIncrement(&This->ref);
2163
2164     TRACE("%p -> %lu\n", iface, ref);
2165     return ref;
2166 }
2167
2168 static ULONG WINAPI GifEncoder_Release(IWICBitmapEncoder *iface)
2169 {
2170     GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
2171     ULONG ref = InterlockedDecrement(&This->ref);
2172
2173     TRACE("%p -> %lu\n", iface, ref);
2174
2175     if (!ref)
2176     {
2177         if (This->stream) IStream_Release(This->stream);
2178         This->lock.DebugInfo->Spare[0] = 0;
2179         DeleteCriticalSection(&This->lock);
2180         HeapFree(GetProcessHeap(), 0, This);
2181     }
2182
2183     return ref;
2184 }
2185
2186 static HRESULT WINAPI GifEncoder_Initialize(IWICBitmapEncoder *iface, IStream *stream, WICBitmapEncoderCacheOption option)
2187 {
2188     GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
2189     HRESULT hr;
2190
2191     TRACE("%p,%p,%#x\n", iface, stream, option);
2192
2193     if (!stream) return E_INVALIDARG;
2194
2195     EnterCriticalSection(&This->lock);
2196
2197     if (!This->initialized)
2198     {
2199         IStream_AddRef(stream);
2200         This->stream = stream;
2201         This->initialized = TRUE;
2202         hr = S_OK;
2203     }
2204     else
2205         hr = WINCODEC_ERR_WRONGSTATE;
2206
2207     LeaveCriticalSection(&This->lock);
2208
2209     return hr;
2210 }
2211
2212 static HRESULT WINAPI GifEncoder_GetContainerFormat(IWICBitmapEncoder *iface, GUID *format)
2213 {
2214     if (!format) return E_INVALIDARG;
2215
2216     *format = GUID_ContainerFormatGif;
2217     return S_OK;
2218 }
2219
2220 static HRESULT WINAPI GifEncoder_GetEncoderInfo(IWICBitmapEncoder *iface, IWICBitmapEncoderInfo **info)
2221 {
2222     IWICComponentInfo *comp_info;
2223     HRESULT hr;
2224
2225     TRACE("%p,%p\n", iface, info);
2226
2227     if (!info) return E_INVALIDARG;
2228
2229     hr = CreateComponentInfo(&CLSID_WICGifEncoder, &comp_info);
2230     if (hr == S_OK)
2231     {
2232         hr = IWICComponentInfo_QueryInterface(comp_info, &IID_IWICBitmapEncoderInfo, (void **)info);
2233         IWICComponentInfo_Release(comp_info);
2234     }
2235     return hr;
2236 }
2237
2238 static HRESULT WINAPI GifEncoder_SetColorContexts(IWICBitmapEncoder *iface, UINT count, IWICColorContext **context)
2239 {
2240     FIXME("%p,%u,%p: stub\n", iface, count, context);
2241     return E_NOTIMPL;
2242 }
2243
2244 static HRESULT WINAPI GifEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *palette)
2245 {
2246     GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
2247     HRESULT hr;
2248
2249     TRACE("%p,%p\n", iface, palette);
2250
2251     if (!palette) return E_INVALIDARG;
2252
2253     EnterCriticalSection(&This->lock);
2254
2255     if (This->initialized)
2256         hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
2257     else
2258         hr = WINCODEC_ERR_NOTINITIALIZED;
2259
2260     LeaveCriticalSection(&This->lock);
2261     return hr;
2262 }
2263
2264 static HRESULT WINAPI GifEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *thumbnail)
2265 {
2266     TRACE("%p,%p\n", iface, thumbnail);
2267     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
2268 }
2269
2270 static HRESULT WINAPI GifEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *preview)
2271 {
2272     TRACE("%p,%p\n", iface, preview);
2273     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
2274 }
2275
2276 static HRESULT WINAPI GifEncoderFrame_Block_QueryInterface(IWICMetadataBlockWriter *iface, REFIID iid, void **ppv)
2277 {
2278     GifFrameEncode *frame_encoder = impl_from_IWICMetadataBlockWriter(iface);
2279
2280     return IWICBitmapFrameEncode_QueryInterface(&frame_encoder->IWICBitmapFrameEncode_iface, iid, ppv);
2281 }
2282
2283 static ULONG WINAPI GifEncoderFrame_Block_AddRef(IWICMetadataBlockWriter *iface)
2284 {
2285     GifFrameEncode *frame_encoder = impl_from_IWICMetadataBlockWriter(iface);
2286
2287     return IWICBitmapFrameEncode_AddRef(&frame_encoder->IWICBitmapFrameEncode_iface);
2288 }
2289
2290 static ULONG WINAPI GifEncoderFrame_Block_Release(IWICMetadataBlockWriter *iface)
2291 {
2292     GifFrameEncode *frame_encoder = impl_from_IWICMetadataBlockWriter(iface);
2293
2294     return IWICBitmapFrameEncode_Release(&frame_encoder->IWICBitmapFrameEncode_iface);
2295 }
2296
2297 static HRESULT WINAPI GifEncoderFrame_Block_GetContainerFormat(IWICMetadataBlockWriter *iface, GUID *container_format)
2298 {
2299     FIXME("iface %p, container_format %p stub.\n", iface, container_format);
2300
2301     return E_NOTIMPL;
2302 }
2303
2304 static HRESULT WINAPI GifEncoderFrame_Block_GetCount(IWICMetadataBlockWriter *iface, UINT *count)
2305 {
2306     FIXME("iface %p, count %p stub.\n", iface, count);
2307
2308     return E_NOTIMPL;
2309 }
2310
2311 static HRESULT WINAPI GifEncoderFrame_Block_GetReaderByIndex(IWICMetadataBlockWriter *iface,
2312         UINT index, IWICMetadataReader **metadata_reader)
2313 {
2314     FIXME("iface %p, index %d, metadata_reader %p stub.\n", iface, index, metadata_reader);
2315
2316     return E_NOTIMPL;
2317 }
2318
2319 static HRESULT WINAPI GifEncoderFrame_Block_GetEnumerator(IWICMetadataBlockWriter *iface, IEnumUnknown **enum_metadata)
2320 {
2321     FIXME("iface %p, enum_metadata %p stub.\n", iface, enum_metadata);
2322
2323     return E_NOTIMPL;
2324 }
2325
2326 static HRESULT WINAPI GifEncoderFrame_Block_InitializeFromBlockReader(IWICMetadataBlockWriter *iface,
2327         IWICMetadataBlockReader *block_reader)
2328 {
2329     FIXME("iface %p, block_reader %p stub.\n", iface, block_reader);
2330
2331     return E_NOTIMPL;
2332 }
2333
2334 static HRESULT WINAPI GifEncoderFrame_Block_GetWriterByIndex(IWICMetadataBlockWriter *iface, UINT index,
2335         IWICMetadataWriter **metadata_writer)
2336 {
2337     FIXME("iface %p, index %u, metadata_writer %p stub.\n", iface, index, metadata_writer);
2338
2339     return E_NOTIMPL;
2340 }
2341
2342 static HRESULT WINAPI GifEncoderFrame_Block_AddWriter(IWICMetadataBlockWriter *iface, IWICMetadataWriter *metadata_writer)
2343 {
2344     FIXME("iface %p, metadata_writer %p stub.\n", iface, metadata_writer);
2345
2346     return E_NOTIMPL;
2347 }
2348
2349 static HRESULT WINAPI GifEncoderFrame_Block_SetWriterByIndex(IWICMetadataBlockWriter *iface, UINT index,
2350         IWICMetadataWriter *metadata_writer)
2351 {
2352     FIXME("iface %p, index %u, metadata_writer %p stub.\n", iface, index, metadata_writer);
2353
2354     return E_NOTIMPL;
2355 }
2356
2357 static HRESULT WINAPI GifEncoderFrame_Block_RemoveWriterByIndex(IWICMetadataBlockWriter *iface, UINT index)
2358 {
2359     FIXME("iface %p, index %u stub.\n", iface, index);
2360
2361     return E_NOTIMPL;
2362 }
2363
2364 static const IWICMetadataBlockWriterVtbl GifFrameEncode_BlockVtbl = {
2365     GifEncoderFrame_Block_QueryInterface,
2366     GifEncoderFrame_Block_AddRef,
2367     GifEncoderFrame_Block_Release,
2368     GifEncoderFrame_Block_GetContainerFormat,
2369     GifEncoderFrame_Block_GetCount,
2370     GifEncoderFrame_Block_GetReaderByIndex,
2371     GifEncoderFrame_Block_GetEnumerator,
2372     GifEncoderFrame_Block_InitializeFromBlockReader,
2373     GifEncoderFrame_Block_GetWriterByIndex,
2374     GifEncoderFrame_Block_AddWriter,
2375     GifEncoderFrame_Block_SetWriterByIndex,
2376     GifEncoderFrame_Block_RemoveWriterByIndex,
2377 };
2378
2379 static HRESULT WINAPI GifEncoder_CreateNewFrame(IWICBitmapEncoder *iface, IWICBitmapFrameEncode **frame, IPropertyBag2 **options)
2380 {
2381     GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
2382     HRESULT hr;
2383
2384     TRACE("%p,%p,%p\n", iface, frame, options);
2385
2386     if (!frame) return E_INVALIDARG;
2387
2388     EnterCriticalSection(&This->lock);
2389
2390     if (This->initialized && !This->committed)
2391     {
2392         GifFrameEncode *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
2393         if (ret)
2394         {
2395             This->n_frames++;
2396
2397             ret->IWICBitmapFrameEncode_iface.lpVtbl = &GifFrameEncode_Vtbl;
2398             ret->IWICMetadataBlockWriter_iface.lpVtbl = &GifFrameEncode_BlockVtbl;
2399
2400             ret->ref = 1;
2401             ret->encoder = This;
2402             ret->initialized = FALSE;
2403             ret->interlace = FALSE; /* FIXME: read from the properties */
2404             ret->committed = FALSE;
2405             ret->width = 0;
2406             ret->height = 0;
2407             ret->lines = 0;
2408             ret->xres = 0.0;
2409             ret->yres = 0.0;
2410             ret->colors = 0;
2411             ret->image_data = NULL;
2412             IWICBitmapEncoder_AddRef(iface);
2413             *frame = &ret->IWICBitmapFrameEncode_iface;
2414
2415             hr = S_OK;
2416
2417             if (options)
2418             {
2419                 hr = CreatePropertyBag2(NULL, 0, options);
2420                 if (hr != S_OK)
2421                 {
2422                     IWICBitmapFrameEncode_Release(*frame);
2423                     *frame = NULL;
2424                 }
2425             }
2426         }
2427         else
2428             hr = E_OUTOFMEMORY;
2429     }
2430     else
2431         hr = WINCODEC_ERR_WRONGSTATE;
2432
2433     LeaveCriticalSection(&This->lock);
2434
2435     return hr;
2436
2437 }
2438
2439 static HRESULT WINAPI GifEncoder_Commit(IWICBitmapEncoder *iface)
2440 {
2441     GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
2442     HRESULT hr;
2443
2444     TRACE("%p\n", iface);
2445
2446     EnterCriticalSection(&This->lock);
2447
2448     if (This->initialized && !This->committed)
2449     {
2450         char gif_trailer = 0x3b;
2451
2452         /* FIXME: write text, comment GIF extensions */
2453
2454         hr = IStream_Write(This->stream, &gif_trailer, sizeof(gif_trailer), NULL);
2455         if (hr == S_OK)
2456             This->committed = TRUE;
2457     }
2458     else
2459         hr = WINCODEC_ERR_WRONGSTATE;
2460
2461     LeaveCriticalSection(&This->lock);
2462     return hr;
2463 }
2464
2465 static HRESULT WINAPI GifEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface, IWICMetadataQueryWriter **writer)
2466 {
2467     FIXME("%p,%p: stub\n", iface, writer);
2468     return E_NOTIMPL;
2469 }
2470
2471 static const IWICBitmapEncoderVtbl GifEncoder_Vtbl =
2472 {
2473     GifEncoder_QueryInterface,
2474     GifEncoder_AddRef,
2475     GifEncoder_Release,
2476     GifEncoder_Initialize,
2477     GifEncoder_GetContainerFormat,
2478     GifEncoder_GetEncoderInfo,
2479     GifEncoder_SetColorContexts,
2480     GifEncoder_SetPalette,
2481     GifEncoder_SetThumbnail,
2482     GifEncoder_SetPreview,
2483     GifEncoder_CreateNewFrame,
2484     GifEncoder_Commit,
2485     GifEncoder_GetMetadataQueryWriter
2486 };
2487
2488 HRESULT GifEncoder_CreateInstance(REFIID iid, void **ppv)
2489 {
2490     GifEncoder *This;
2491     HRESULT ret;
2492
2493     TRACE("%s,%p\n", debugstr_guid(iid), ppv);
2494
2495     *ppv = NULL;
2496
2497     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2498     if (!This) return E_OUTOFMEMORY;
2499
2500     This->IWICBitmapEncoder_iface.lpVtbl = &GifEncoder_Vtbl;
2501     This->ref = 1;
2502     This->stream = NULL;
2503     InitializeCriticalSection(&This->lock);
2504     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifEncoder.lock");
2505     This->initialized = FALSE;
2506     This->info_written = FALSE;
2507     This->committed = FALSE;
2508     This->n_frames = 0;
2509     This->colors = 0;
2510
2511     ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
2512     IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
2513
2514     return ret;
2515 }