dlls/windowscodecs/pngformat.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <stdarg.h>
  23
  24 #ifdef HAVE_PNG_H
  25 #include <png.h>
  26 #endif
  27
  28 #define NONAMELESSUNION
  29 #define COBJMACROS
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "objbase.h"
  34
  35 #include "wincodecs_private.h"
  36
  37 #include "wine/debug.h"
  38 #include "wine/library.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  41
  42 static inline ULONG read_ulong_be(BYTE* data)
  43 {
  44     return data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
  45 }
  46
  47 static HRESULT read_png_chunk(IStream *stream, BYTE *type, BYTE **data, ULONG *data_size)
  48 {
  49     BYTE header[8];
  50     HRESULT hr;
  51     ULONG bytesread;
  52
  53     hr = IStream_Read(stream, header, 8, &bytesread);
  54     if (FAILED(hr) || bytesread < 8)
  55     {
  56         if (SUCCEEDED(hr))
  57             hr = E_FAIL;
  58         return hr;
  59     }
  60
  61     *data_size = read_ulong_be(&header[0]);
  62
  63     memcpy(type, &header[4], 4);
  64
  65     if (data)
  66     {
  67         *data = HeapAlloc(GetProcessHeap(), 0, *data_size);
  68         if (!*data)
  69             return E_OUTOFMEMORY;
  70
  71         hr = IStream_Read(stream, *data, *data_size, &bytesread);
  72
  73         if (FAILED(hr) || bytesread < *data_size)
  74         {
  75             if (SUCCEEDED(hr))
  76                 hr = E_FAIL;
  77             HeapFree(GetProcessHeap(), 0, *data);
  78             *data = NULL;
  79             return hr;
  80         }
  81
  82         /* Windows ignores CRC of the chunk */
  83     }
  84
  85     return S_OK;
  86 }
  87
  88 static HRESULT LoadTextMetadata(IStream *stream, const GUID *preferred_vendor,
  89     DWORD persist_options, MetadataItem **items, DWORD *item_count)
  90 {
  91     HRESULT hr;
  92     BYTE type[4];
  93     BYTE *data;
  94     ULONG data_size;
  95     ULONG name_len, value_len;
  96     BYTE *name_end_ptr;
  97     LPSTR name, value;
  98     MetadataItem *result;
  99
 100     hr = read_png_chunk(stream, type, &data, &data_size);
 101     if (FAILED(hr)) return hr;
 102
 103     name_end_ptr = memchr(data, 0, data_size);
 104
 105     name_len = name_end_ptr - data;
 106
 107     if (!name_end_ptr || name_len > 79)
 108     {
 109         HeapFree(GetProcessHeap(), 0, data);
 110         return E_FAIL;
 111     }
 112
 113     value_len = data_size - name_len - 1;
 114
 115     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
 116     name = HeapAlloc(GetProcessHeap(), 0, name_len + 1);
 117     value = HeapAlloc(GetProcessHeap(), 0, value_len + 1);
 118     if (!result || !name || !value)
 119     {
 120         HeapFree(GetProcessHeap(), 0, data);
 121         HeapFree(GetProcessHeap(), 0, result);
 122         HeapFree(GetProcessHeap(), 0, name);
 123         HeapFree(GetProcessHeap(), 0, value);
 124         return E_OUTOFMEMORY;
 125     }
 126
 127     PropVariantInit(&result[0].schema);
 128     PropVariantInit(&result[0].id);
 129     PropVariantInit(&result[0].value);
 130
 131     memcpy(name, data, name_len + 1);
 132     memcpy(value, name_end_ptr + 1, value_len);
 133     value[value_len] = 0;
 134
 135     result[0].id.vt = VT_LPSTR;
 136     result[0].id.u.pszVal = name;
 137     result[0].value.vt = VT_LPSTR;
 138     result[0].value.u.pszVal = value;
 139
 140     *items = result;
 141     *item_count = 1;
 142
 143     HeapFree(GetProcessHeap(), 0, data);
 144
 145     return S_OK;
 146 }
 147
 148 static const MetadataHandlerVtbl TextReader_Vtbl = {
 149     0,
 150     &CLSID_WICPngTextMetadataReader,
 151     LoadTextMetadata
 152 };
 153
 154 HRESULT PngTextReader_CreateInstance(REFIID iid, void** ppv)
 155 {
 156     return MetadataReader_Create(&TextReader_Vtbl, iid, ppv);
 157 }
 158
 159 static HRESULT LoadGamaMetadata(IStream *stream, const GUID *preferred_vendor,
 160     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 161 {
 162     HRESULT hr;
 163     BYTE type[4];
 164     BYTE *data;
 165     ULONG data_size;
 166     ULONG gamma;
 167     static const WCHAR ImageGamma[] = {'I','m','a','g','e','G','a','m','m','a',0};
 168     LPWSTR name;
 169     MetadataItem *result;
 170
 171     hr = read_png_chunk(stream, type, &data, &data_size);
 172     if (FAILED(hr)) return hr;
 173
 174     if (data_size < 4)
 175     {
 176         HeapFree(GetProcessHeap(), 0, data);
 177         return E_FAIL;
 178     }
 179
 180     gamma = read_ulong_be(data);
 181
 182     HeapFree(GetProcessHeap(), 0, data);
 183
 184     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
 185     name = HeapAlloc(GetProcessHeap(), 0, sizeof(ImageGamma));
 186     if (!result || !name)
 187     {
 188         HeapFree(GetProcessHeap(), 0, result);
 189         HeapFree(GetProcessHeap(), 0, name);
 190         return E_OUTOFMEMORY;
 191     }
 192
 193     PropVariantInit(&result[0].schema);
 194     PropVariantInit(&result[0].id);
 195     PropVariantInit(&result[0].value);
 196
 197     memcpy(name, ImageGamma, sizeof(ImageGamma));
 198
 199     result[0].id.vt = VT_LPWSTR;
 200     result[0].id.u.pwszVal = name;
 201     result[0].value.vt = VT_UI4;
 202     result[0].value.u.ulVal = gamma;
 203
 204     *items = result;
 205     *item_count = 1;
 206
 207     return S_OK;
 208 }
 209
 210 static const MetadataHandlerVtbl GamaReader_Vtbl = {
 211     0,
 212     &CLSID_WICPngGamaMetadataReader,
 213     LoadGamaMetadata
 214 };
 215
 216 HRESULT PngGamaReader_CreateInstance(REFIID iid, void** ppv)
 217 {
 218     return MetadataReader_Create(&GamaReader_Vtbl, iid, ppv);
 219 }
 220
 221 static HRESULT LoadChrmMetadata(IStream *stream, const GUID *preferred_vendor,
 222     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 223 {
 224     HRESULT hr;
 225     BYTE type[4];
 226     BYTE *data;
 227     ULONG data_size;
 228     static const WCHAR names[8][12] = {
 229         {'W','h','i','t','e','P','o','i','n','t','X',0},
 230         {'W','h','i','t','e','P','o','i','n','t','Y',0},
 231         {'R','e','d','X',0},
 232         {'R','e','d','Y',0},
 233         {'G','r','e','e','n','X',0},
 234         {'G','r','e','e','n','Y',0},
 235         {'B','l','u','e','X',0},
 236         {'B','l','u','e','Y',0},
 237     };
 238     LPWSTR dyn_names[8] = {0};
 239     MetadataItem *result;
 240     int i;
 241
 242     hr = read_png_chunk(stream, type, &data, &data_size);
 243     if (FAILED(hr)) return hr;
 244
 245     if (data_size < 32)
 246     {
 247         HeapFree(GetProcessHeap(), 0, data);
 248         return E_FAIL;
 249     }
 250
 251     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem)*8);
 252     for (i=0; i<8; i++)
 253     {
 254         dyn_names[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(lstrlenW(names[i])+1));
 255         if (!dyn_names[i]) break;
 256     }
 257     if (!result || i < 8)
 258     {
 259         HeapFree(GetProcessHeap(), 0, result);
 260         for (i=0; i<8; i++)
 261             HeapFree(GetProcessHeap(), 0, dyn_names[i]);
 262         HeapFree(GetProcessHeap(), 0, data);
 263         return E_OUTOFMEMORY;
 264     }
 265
 266     for (i=0; i<8; i++)
 267     {
 268         PropVariantInit(&result[i].schema);
 269
 270         PropVariantInit(&result[i].id);
 271         result[i].id.vt = VT_LPWSTR;
 272         result[i].id.u.pwszVal = dyn_names[i];
 273         lstrcpyW(dyn_names[i], names[i]);
 274
 275         PropVariantInit(&result[i].value);
 276         result[i].value.vt = VT_UI4;
 277         result[i].value.u.ulVal = read_ulong_be(&data[i*4]);
 278     }
 279
 280     *items = result;
 281     *item_count = 8;
 282
 283     HeapFree(GetProcessHeap(), 0, data);
 284
 285     return S_OK;
 286 }
 287
 288 static const MetadataHandlerVtbl ChrmReader_Vtbl = {
 289     0,
 290     &CLSID_WICPngChrmMetadataReader,
 291     LoadChrmMetadata
 292 };
 293
 294 HRESULT PngChrmReader_CreateInstance(REFIID iid, void** ppv)
 295 {
 296     return MetadataReader_Create(&ChrmReader_Vtbl, iid, ppv);
 297 }
 298
 299 #ifdef SONAME_LIBPNG
 300
 301 static void *libpng_handle;
 302 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
 303 MAKE_FUNCPTR(png_create_read_struct);
 304 MAKE_FUNCPTR(png_create_info_struct);
 305 MAKE_FUNCPTR(png_create_write_struct);
 306 MAKE_FUNCPTR(png_destroy_read_struct);
 307 MAKE_FUNCPTR(png_destroy_write_struct);
 308 MAKE_FUNCPTR(png_error);
 309 MAKE_FUNCPTR(png_get_bit_depth);
 310 MAKE_FUNCPTR(png_get_color_type);
 311 MAKE_FUNCPTR(png_get_error_ptr);
 312 MAKE_FUNCPTR(png_get_iCCP);
 313 MAKE_FUNCPTR(png_get_image_height);
 314 MAKE_FUNCPTR(png_get_image_width);
 315 MAKE_FUNCPTR(png_get_io_ptr);
 316 MAKE_FUNCPTR(png_get_pHYs);
 317 MAKE_FUNCPTR(png_get_PLTE);
 318 MAKE_FUNCPTR(png_get_tRNS);
 319 MAKE_FUNCPTR(png_set_bgr);
 320 MAKE_FUNCPTR(png_set_crc_action);
 321 MAKE_FUNCPTR(png_set_error_fn);
 322 #ifdef HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 323 MAKE_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
 324 #else
 325 MAKE_FUNCPTR(png_set_gray_1_2_4_to_8);
 326 #endif
 327 MAKE_FUNCPTR(png_set_filler);
 328 MAKE_FUNCPTR(png_set_filter);
 329 MAKE_FUNCPTR(png_set_gray_to_rgb);
 330 MAKE_FUNCPTR(png_set_interlace_handling);
 331 MAKE_FUNCPTR(png_set_IHDR);
 332 MAKE_FUNCPTR(png_set_pHYs);
 333 MAKE_FUNCPTR(png_set_read_fn);
 334 MAKE_FUNCPTR(png_set_strip_16);
 335 MAKE_FUNCPTR(png_set_tRNS_to_alpha);
 336 MAKE_FUNCPTR(png_set_write_fn);
 337 MAKE_FUNCPTR(png_read_end);
 338 MAKE_FUNCPTR(png_read_image);
 339 MAKE_FUNCPTR(png_read_info);
 340 MAKE_FUNCPTR(png_write_end);
 341 MAKE_FUNCPTR(png_write_info);
 342 MAKE_FUNCPTR(png_write_rows);
 343 #undef MAKE_FUNCPTR
 344
 345 static CRITICAL_SECTION init_png_cs;
 346 static CRITICAL_SECTION_DEBUG init_png_cs_debug =
 347 {
 348     0, 0, &init_png_cs,
 349     { &init_png_cs_debug.ProcessLocksList,
 350       &init_png_cs_debug.ProcessLocksList },
 351     0, 0, { (DWORD_PTR)(__FILE__ ": init_png_cs") }
 352 };
 353 static CRITICAL_SECTION init_png_cs = { &init_png_cs_debug, -1, 0, 0, 0, 0 };
 354
 355 static const WCHAR wszPngInterlaceOption[] = {'I','n','t','e','r','l','a','c','e','O','p','t','i','o','n',0};
 356 static const WCHAR wszPngFilterOption[] = {'F','i','l','t','e','r','O','p','t','i','o','n',0};
 357
 358 static void *load_libpng(void)
 359 {
 360     void *result;
 361
 362     EnterCriticalSection(&init_png_cs);
 363
 364     if(!libpng_handle && (libpng_handle = wine_dlopen(SONAME_LIBPNG, RTLD_NOW, NULL, 0)) != NULL) {
 365
 366 #define LOAD_FUNCPTR(f) \
 367     if((p##f = wine_dlsym(libpng_handle, #f, NULL, 0)) == NULL) { \
 368         libpng_handle = NULL; \
 369         LeaveCriticalSection(&init_png_cs); \
 370         return NULL; \
 371     }
 372         LOAD_FUNCPTR(png_create_read_struct);
 373         LOAD_FUNCPTR(png_create_info_struct);
 374         LOAD_FUNCPTR(png_create_write_struct);
 375         LOAD_FUNCPTR(png_destroy_read_struct);
 376         LOAD_FUNCPTR(png_destroy_write_struct);
 377         LOAD_FUNCPTR(png_error);
 378         LOAD_FUNCPTR(png_get_bit_depth);
 379         LOAD_FUNCPTR(png_get_color_type);
 380         LOAD_FUNCPTR(png_get_error_ptr);
 381         LOAD_FUNCPTR(png_get_iCCP);
 382         LOAD_FUNCPTR(png_get_image_height);
 383         LOAD_FUNCPTR(png_get_image_width);
 384         LOAD_FUNCPTR(png_get_io_ptr);
 385         LOAD_FUNCPTR(png_get_pHYs);
 386         LOAD_FUNCPTR(png_get_PLTE);
 387         LOAD_FUNCPTR(png_get_tRNS);
 388         LOAD_FUNCPTR(png_set_bgr);
 389         LOAD_FUNCPTR(png_set_crc_action);
 390         LOAD_FUNCPTR(png_set_error_fn);
 391 #ifdef HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 392         LOAD_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
 393 #else
 394         LOAD_FUNCPTR(png_set_gray_1_2_4_to_8);
 395 #endif
 396         LOAD_FUNCPTR(png_set_filler);
 397         LOAD_FUNCPTR(png_set_filter);
 398         LOAD_FUNCPTR(png_set_gray_to_rgb);
 399         LOAD_FUNCPTR(png_set_interlace_handling);
 400         LOAD_FUNCPTR(png_set_IHDR);
 401         LOAD_FUNCPTR(png_set_pHYs);
 402         LOAD_FUNCPTR(png_set_read_fn);
 403         LOAD_FUNCPTR(png_set_strip_16);
 404         LOAD_FUNCPTR(png_set_tRNS_to_alpha);
 405         LOAD_FUNCPTR(png_set_write_fn);
 406         LOAD_FUNCPTR(png_read_end);
 407         LOAD_FUNCPTR(png_read_image);
 408         LOAD_FUNCPTR(png_read_info);
 409         LOAD_FUNCPTR(png_write_end);
 410         LOAD_FUNCPTR(png_write_info);
 411         LOAD_FUNCPTR(png_write_rows);
 412
 413 #undef LOAD_FUNCPTR
 414     }
 415
 416     result = libpng_handle;
 417
 418     LeaveCriticalSection(&init_png_cs);
 419
 420     return result;
 421 }
 422
 423 static void user_error_fn(png_structp png_ptr, png_const_charp error_message)
 424 {
 425     jmp_buf *pjmpbuf;
 426
 427     /* This uses setjmp/longjmp just like the default. We can't use the
 428      * default because there's no way to access the jmp buffer in the png_struct
 429      * that works in 1.2 and 1.4 and allows us to dynamically load libpng. */
 430     WARN("PNG error: %s\n", debugstr_a(error_message));
 431     pjmpbuf = ppng_get_error_ptr(png_ptr);
 432     longjmp(*pjmpbuf, 1);
 433 }
 434
 435 static void user_warning_fn(png_structp png_ptr, png_const_charp warning_message)
 436 {
 437     WARN("PNG warning: %s\n", debugstr_a(warning_message));
 438 }
 439
 440 typedef struct {
 441     ULARGE_INTEGER ofs, len;
 442     IWICMetadataReader* reader;
 443 } metadata_block_info;
 444
 445 typedef struct {
 446     IWICBitmapDecoder IWICBitmapDecoder_iface;
 447     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 448     IWICMetadataBlockReader IWICMetadataBlockReader_iface;
 449     LONG ref;
 450     IStream *stream;
 451     png_structp png_ptr;
 452     png_infop info_ptr;
 453     png_infop end_info;
 454     BOOL initialized;
 455     int bpp;
 456     int width, height;
 457     UINT stride;
 458     const WICPixelFormatGUID *format;
 459     BYTE *image_bits;
 460     CRITICAL_SECTION lock; /* must be held when png structures are accessed or initialized is set */
 461     ULONG metadata_count;
 462     metadata_block_info* metadata_blocks;
 463 } PngDecoder;
 464
 465 static inline PngDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 466 {
 467     return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapDecoder_iface);
 468 }
 469
 470 static inline PngDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 471 {
 472     return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapFrameDecode_iface);
 473 }
 474
 475 static inline PngDecoder *impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
 476 {
 477     return CONTAINING_RECORD(iface, PngDecoder, IWICMetadataBlockReader_iface);
 478 }
 479
 480 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl;
 481
 482 static HRESULT WINAPI PngDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 483     void **ppv)
 484 {
 485     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 486     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 487
 488     if (!ppv) return E_INVALIDARG;
 489
 490     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
 491     {
 492         *ppv = &This->IWICBitmapDecoder_iface;
 493     }
 494     else
 495     {
 496         *ppv = NULL;
 497         return E_NOINTERFACE;
 498     }
 499
 500     IUnknown_AddRef((IUnknown*)*ppv);
 501     return S_OK;
 502 }
 503
 504 static ULONG WINAPI PngDecoder_AddRef(IWICBitmapDecoder *iface)
 505 {
 506     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 507     ULONG ref = InterlockedIncrement(&This->ref);
 508
 509     TRACE("(%p) refcount=%u\n", iface, ref);
 510
 511     return ref;
 512 }
 513
 514 static ULONG WINAPI PngDecoder_Release(IWICBitmapDecoder *iface)
 515 {
 516     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 517     ULONG ref = InterlockedDecrement(&This->ref);
 518     ULONG i;
 519
 520     TRACE("(%p) refcount=%u\n", iface, ref);
 521
 522     if (ref == 0)
 523     {
 524         if (This->stream)
 525             IStream_Release(This->stream);
 526         if (This->png_ptr)
 527             ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, &This->end_info);
 528         This->lock.DebugInfo->Spare[0] = 0;
 529         DeleteCriticalSection(&This->lock);
 530         HeapFree(GetProcessHeap(), 0, This->image_bits);
 531         for (i=0; i<This->metadata_count; i++)
 532         {
 533             if (This->metadata_blocks[i].reader)
 534                 IWICMetadataReader_Release(This->metadata_blocks[i].reader);
 535         }
 536         HeapFree(GetProcessHeap(), 0, This->metadata_blocks);
 537         HeapFree(GetProcessHeap(), 0, This);
 538     }
 539
 540     return ref;
 541 }
 542
 543 static HRESULT WINAPI PngDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
 544     DWORD *capability)
 545 {
 546     HRESULT hr;
 547
 548     TRACE("(%p,%p,%p)\n", iface, stream, capability);
 549
 550     if (!stream || !capability) return E_INVALIDARG;
 551
 552     hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
 553     if (hr != S_OK) return hr;
 554
 555     *capability = WICBitmapDecoderCapabilityCanDecodeAllImages |
 556                   WICBitmapDecoderCapabilityCanDecodeSomeImages;
 557     /* FIXME: WICBitmapDecoderCapabilityCanEnumerateMetadata */
 558     return S_OK;
 559 }
 560
 561 static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 562 {
 563     IStream *stream = ppng_get_io_ptr(png_ptr);
 564     HRESULT hr;
 565     ULONG bytesread;
 566
 567     hr = IStream_Read(stream, data, length, &bytesread);
 568     if (FAILED(hr) || bytesread != length)
 569     {
 570         ppng_error(png_ptr, "failed reading data");
 571     }
 572 }
 573
 574 static HRESULT WINAPI PngDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 575     WICDecodeOptions cacheOptions)
 576 {
 577     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 578     LARGE_INTEGER seek;
 579     HRESULT hr=S_OK;
 580     png_bytep *row_pointers=NULL;
 581     UINT image_size;
 582     UINT i;
 583     int color_type, bit_depth;
 584     png_bytep trans;
 585     int num_trans;
 586     png_uint_32 transparency;
 587     png_color_16p trans_values;
 588     jmp_buf jmpbuf;
 589     BYTE chunk_type[4];
 590     ULONG chunk_size;
 591     ULARGE_INTEGER chunk_start;
 592     ULONG metadata_blocks_size = 0;
 593
 594     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 595
 596     EnterCriticalSection(&This->lock);
 597
 598     /* initialize libpng */
 599     This->png_ptr = ppng_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 600     if (!This->png_ptr)
 601     {
 602         hr = E_FAIL;
 603         goto end;
 604     }
 605
 606     This->info_ptr = ppng_create_info_struct(This->png_ptr);
 607     if (!This->info_ptr)
 608     {
 609         ppng_destroy_read_struct(&This->png_ptr, NULL, NULL);
 610         This->png_ptr = NULL;
 611         hr = E_FAIL;
 612         goto end;
 613     }
 614
 615     This->end_info = ppng_create_info_struct(This->png_ptr);
 616     if (!This->end_info)
 617     {
 618         ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, NULL);
 619         This->png_ptr = NULL;
 620         hr = E_FAIL;
 621         goto end;
 622     }
 623
 624     /* set up setjmp/longjmp error handling */
 625     if (setjmp(jmpbuf))
 626     {
 627         ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, &This->end_info);
 628         HeapFree(GetProcessHeap(), 0, row_pointers);
 629         This->png_ptr = NULL;
 630         hr = E_FAIL;
 631         goto end;
 632     }
 633     ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
 634     ppng_set_crc_action(This->png_ptr, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
 635
 636     /* seek to the start of the stream */
 637     seek.QuadPart = 0;
 638     hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 639     if (FAILED(hr)) goto end;
 640
 641     /* set up custom i/o handling */
 642     ppng_set_read_fn(This->png_ptr, pIStream, user_read_data);
 643
 644     /* read the header */
 645     ppng_read_info(This->png_ptr, This->info_ptr);
 646
 647     /* choose a pixel format */
 648     color_type = ppng_get_color_type(This->png_ptr, This->info_ptr);
 649     bit_depth = ppng_get_bit_depth(This->png_ptr, This->info_ptr);
 650
 651     /* check for color-keyed alpha */
 652     transparency = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans, &num_trans, &trans_values);
 653
 654     if (transparency && color_type != PNG_COLOR_TYPE_PALETTE)
 655     {
 656         /* expand to RGBA */
 657         if (color_type == PNG_COLOR_TYPE_GRAY)
 658         {
 659             if (bit_depth < 8)
 660             {
 661 #ifdef HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 662                 ppng_set_expand_gray_1_2_4_to_8(This->png_ptr);
 663 #else
 664                 ppng_set_gray_1_2_4_to_8(This->png_ptr);
 665 #endif
 666                 bit_depth = 8;
 667             }
 668             ppng_set_gray_to_rgb(This->png_ptr);
 669         }
 670         ppng_set_tRNS_to_alpha(This->png_ptr);
 671         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
 672     }
 673
 674     switch (color_type)
 675     {
 676     case PNG_COLOR_TYPE_GRAY:
 677         This->bpp = bit_depth;
 678         switch (bit_depth)
 679         {
 680         case 1: This->format = &GUID_WICPixelFormatBlackWhite; break;
 681         case 2: This->format = &GUID_WICPixelFormat2bppGray; break;
 682         case 4: This->format = &GUID_WICPixelFormat4bppGray; break;
 683         case 8: This->format = &GUID_WICPixelFormat8bppGray; break;
 684         case 16: This->format = &GUID_WICPixelFormat16bppGray; break;
 685         default:
 686             ERR("invalid grayscale bit depth: %i\n", bit_depth);
 687             hr = E_FAIL;
 688             goto end;
 689         }
 690         break;
 691     case PNG_COLOR_TYPE_GRAY_ALPHA:
 692         /* WIC does not support grayscale alpha formats so use RGBA */
 693         ppng_set_gray_to_rgb(This->png_ptr);
 694         /* fall through */
 695     case PNG_COLOR_TYPE_RGB_ALPHA:
 696         This->bpp = bit_depth * 4;
 697         switch (bit_depth)
 698         {
 699         case 8:
 700             ppng_set_bgr(This->png_ptr);
 701             This->format = &GUID_WICPixelFormat32bppBGRA;
 702             break;
 703         case 16: This->format = &GUID_WICPixelFormat64bppRGBA; break;
 704         default:
 705             ERR("invalid RGBA bit depth: %i\n", bit_depth);
 706             hr = E_FAIL;
 707             goto end;
 708         }
 709         break;
 710     case PNG_COLOR_TYPE_PALETTE:
 711         This->bpp = bit_depth;
 712         switch (bit_depth)
 713         {
 714         case 1: This->format = &GUID_WICPixelFormat1bppIndexed; break;
 715         case 2: This->format = &GUID_WICPixelFormat2bppIndexed; break;
 716         case 4: This->format = &GUID_WICPixelFormat4bppIndexed; break;
 717         case 8: This->format = &GUID_WICPixelFormat8bppIndexed; break;
 718         default:
 719             ERR("invalid indexed color bit depth: %i\n", bit_depth);
 720             hr = E_FAIL;
 721             goto end;
 722         }
 723         break;
 724     case PNG_COLOR_TYPE_RGB:
 725         This->bpp = bit_depth * 3;
 726         switch (bit_depth)
 727         {
 728         case 8:
 729             ppng_set_bgr(This->png_ptr);
 730             This->format = &GUID_WICPixelFormat24bppBGR;
 731             break;
 732         case 16: This->format = &GUID_WICPixelFormat48bppRGB; break;
 733         default:
 734             ERR("invalid RGB color bit depth: %i\n", bit_depth);
 735             hr = E_FAIL;
 736             goto end;
 737         }
 738         break;
 739     default:
 740         ERR("invalid color type %i\n", color_type);
 741         hr = E_FAIL;
 742         goto end;
 743     }
 744
 745     /* read the image data */
 746     This->width = ppng_get_image_width(This->png_ptr, This->info_ptr);
 747     This->height = ppng_get_image_height(This->png_ptr, This->info_ptr);
 748     This->stride = (This->width * This->bpp + 7) / 8;
 749     image_size = This->stride * This->height;
 750
 751     This->image_bits = HeapAlloc(GetProcessHeap(), 0, image_size);
 752     if (!This->image_bits)
 753     {
 754         hr = E_OUTOFMEMORY;
 755         goto end;
 756     }
 757
 758     row_pointers = HeapAlloc(GetProcessHeap(), 0, sizeof(png_bytep)*This->height);
 759     if (!row_pointers)
 760     {
 761         hr = E_OUTOFMEMORY;
 762         goto end;
 763     }
 764
 765     for (i=0; i<This->height; i++)
 766         row_pointers[i] = This->image_bits + i * This->stride;
 767
 768     ppng_read_image(This->png_ptr, row_pointers);
 769
 770     HeapFree(GetProcessHeap(), 0, row_pointers);
 771     row_pointers = NULL;
 772
 773     ppng_read_end(This->png_ptr, This->end_info);
 774
 775     /* Find the metadata chunks in the file. */
 776     seek.QuadPart = 8;
 777     hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, &chunk_start);
 778     if (FAILED(hr)) goto end;
 779
 780     do
 781     {
 782         hr = read_png_chunk(pIStream, chunk_type, NULL, &chunk_size);
 783         if (FAILED(hr)) goto end;
 784
 785         if (chunk_type[0] >= 'a' && chunk_type[0] <= 'z' &&
 786             memcmp(chunk_type, "tRNS", 4) && memcmp(chunk_type, "pHYs", 4))
 787         {
 788             /* This chunk is considered metadata. */
 789             if (This->metadata_count == metadata_blocks_size)
 790             {
 791                 metadata_block_info* new_metadata_blocks;
 792                 ULONG new_metadata_blocks_size;
 793
 794                 new_metadata_blocks_size = 4 + metadata_blocks_size * 2;
 795                 new_metadata_blocks = HeapAlloc(GetProcessHeap(), 0,
 796                     new_metadata_blocks_size * sizeof(*new_metadata_blocks));
 797
 798                 if (!new_metadata_blocks)
 799                 {
 800                     hr = E_OUTOFMEMORY;
 801                     goto end;
 802                 }
 803
 804                 memcpy(new_metadata_blocks, This->metadata_blocks,
 805                     This->metadata_count * sizeof(*new_metadata_blocks));
 806
 807                 HeapFree(GetProcessHeap(), 0, This->metadata_blocks);
 808                 This->metadata_blocks = new_metadata_blocks;
 809                 metadata_blocks_size = new_metadata_blocks_size;
 810             }
 811
 812             This->metadata_blocks[This->metadata_count].ofs = chunk_start;
 813             This->metadata_blocks[This->metadata_count].len.QuadPart = chunk_size + 12;
 814             This->metadata_blocks[This->metadata_count].reader = NULL;
 815             This->metadata_count++;
 816         }
 817
 818         seek.QuadPart = chunk_start.QuadPart + chunk_size + 12; /* skip data and CRC */
 819         hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, &chunk_start);
 820         if (FAILED(hr)) goto end;
 821     } while (memcmp(chunk_type, "IEND", 4));
 822
 823     This->stream = pIStream;
 824     IStream_AddRef(This->stream);
 825
 826     This->initialized = TRUE;
 827
 828 end:
 829     LeaveCriticalSection(&This->lock);
 830
 831     return hr;
 832 }
 833
 834 static HRESULT WINAPI PngDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 835     GUID *pguidContainerFormat)
 836 {
 837     memcpy(pguidContainerFormat, &GUID_ContainerFormatPng, sizeof(GUID));
 838     return S_OK;
 839 }
 840
 841 static HRESULT WINAPI PngDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 842     IWICBitmapDecoderInfo **ppIDecoderInfo)
 843 {
 844     HRESULT hr;
 845     IWICComponentInfo *compinfo;
 846
 847     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 848
 849     hr = CreateComponentInfo(&CLSID_WICPngDecoder, &compinfo);
 850     if (FAILED(hr)) return hr;
 851
 852     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
 853         (void**)ppIDecoderInfo);
 854
 855     IWICComponentInfo_Release(compinfo);
 856
 857     return hr;
 858 }
 859
 860 static HRESULT WINAPI PngDecoder_CopyPalette(IWICBitmapDecoder *iface,
 861     IWICPalette *pIPalette)
 862 {
 863     FIXME("(%p,%p): stub\n", iface, pIPalette);
 864     return E_NOTIMPL;
 865 }
 866
 867 static HRESULT WINAPI PngDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 868     IWICMetadataQueryReader **ppIMetadataQueryReader)
 869 {
 870     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 871     return E_NOTIMPL;
 872 }
 873
 874 static HRESULT WINAPI PngDecoder_GetPreview(IWICBitmapDecoder *iface,
 875     IWICBitmapSource **ppIBitmapSource)
 876 {
 877     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
 878
 879     if (!ppIBitmapSource) return E_INVALIDARG;
 880
 881     *ppIBitmapSource = NULL;
 882     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 883 }
 884
 885 static HRESULT WINAPI PngDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 886     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 887 {
 888     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
 889     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 890 }
 891
 892 static HRESULT WINAPI PngDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 893     IWICBitmapSource **ppIThumbnail)
 894 {
 895     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 896
 897     if (!ppIThumbnail) return E_INVALIDARG;
 898
 899     *ppIThumbnail = NULL;
 900     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 901 }
 902
 903 static HRESULT WINAPI PngDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 904     UINT *pCount)
 905 {
 906     if (!pCount) return E_INVALIDARG;
 907
 908     *pCount = 1;
 909     return S_OK;
 910 }
 911
 912 static HRESULT WINAPI PngDecoder_GetFrame(IWICBitmapDecoder *iface,
 913     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 914 {
 915     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 916     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 917
 918     if (!This->initialized) return WINCODEC_ERR_FRAMEMISSING;
 919
 920     if (index != 0) return E_INVALIDARG;
 921
 922     IWICBitmapDecoder_AddRef(iface);
 923
 924     *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
 925
 926     return S_OK;
 927 }
 928
 929 static const IWICBitmapDecoderVtbl PngDecoder_Vtbl = {
 930     PngDecoder_QueryInterface,
 931     PngDecoder_AddRef,
 932     PngDecoder_Release,
 933     PngDecoder_QueryCapability,
 934     PngDecoder_Initialize,
 935     PngDecoder_GetContainerFormat,
 936     PngDecoder_GetDecoderInfo,
 937     PngDecoder_CopyPalette,
 938     PngDecoder_GetMetadataQueryReader,
 939     PngDecoder_GetPreview,
 940     PngDecoder_GetColorContexts,
 941     PngDecoder_GetThumbnail,
 942     PngDecoder_GetFrameCount,
 943     PngDecoder_GetFrame
 944 };
 945
 946 static HRESULT WINAPI PngDecoder_Frame_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
 947     void **ppv)
 948 {
 949     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 950     if (!ppv) return E_INVALIDARG;
 951
 952     if (IsEqualIID(&IID_IUnknown, iid) ||
 953         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 954         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
 955     {
 956         *ppv = &This->IWICBitmapFrameDecode_iface;
 957     }
 958     else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
 959     {
 960         *ppv = &This->IWICMetadataBlockReader_iface;
 961     }
 962     else
 963     {
 964         *ppv = NULL;
 965         return E_NOINTERFACE;
 966     }
 967
 968     IUnknown_AddRef((IUnknown*)*ppv);
 969     return S_OK;
 970 }
 971
 972 static ULONG WINAPI PngDecoder_Frame_AddRef(IWICBitmapFrameDecode *iface)
 973 {
 974     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 975     return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
 976 }
 977
 978 static ULONG WINAPI PngDecoder_Frame_Release(IWICBitmapFrameDecode *iface)
 979 {
 980     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 981     return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
 982 }
 983
 984 static HRESULT WINAPI PngDecoder_Frame_GetSize(IWICBitmapFrameDecode *iface,
 985     UINT *puiWidth, UINT *puiHeight)
 986 {
 987     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 988     *puiWidth = This->width;
 989     *puiHeight = This->height;
 990     TRACE("(%p)->(%u,%u)\n", iface, *puiWidth, *puiHeight);
 991     return S_OK;
 992 }
 993
 994 static HRESULT WINAPI PngDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode *iface,
 995     WICPixelFormatGUID *pPixelFormat)
 996 {
 997     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 998     TRACE("(%p,%p)\n", iface, pPixelFormat);
 999
1000     memcpy(pPixelFormat, This->format, sizeof(GUID));
1001
1002     return S_OK;
1003 }
1004
1005 static HRESULT WINAPI PngDecoder_Frame_GetResolution(IWICBitmapFrameDecode *iface,
1006     double *pDpiX, double *pDpiY)
1007 {
1008     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
1009     png_uint_32 ret, xres, yres;
1010     int unit_type;
1011
1012     EnterCriticalSection(&This->lock);
1013
1014     ret = ppng_get_pHYs(This->png_ptr, This->info_ptr, &xres, &yres, &unit_type);
1015
1016     if (ret && unit_type == PNG_RESOLUTION_METER)
1017     {
1018         *pDpiX = xres * 0.0254;
1019         *pDpiY = yres * 0.0254;
1020     }
1021     else
1022     {
1023         WARN("no pHYs block present\n");
1024         *pDpiX = *pDpiY = 96.0;
1025     }
1026
1027     LeaveCriticalSection(&This->lock);
1028
1029     TRACE("(%p)->(%0.2f,%0.2f)\n", iface, *pDpiX, *pDpiY);
1030
1031     return S_OK;
1032 }
1033
1034 static HRESULT WINAPI PngDecoder_Frame_CopyPalette(IWICBitmapFrameDecode *iface,
1035     IWICPalette *pIPalette)
1036 {
1037     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
1038     png_uint_32 ret;
1039     png_colorp png_palette;
1040     int num_palette;
1041     WICColor palette[256];
1042     png_bytep trans_alpha;
1043     int num_trans;
1044     png_color_16p trans_values;
1045     int i;
1046     HRESULT hr=S_OK;
1047
1048     TRACE("(%p,%p)\n", iface, pIPalette);
1049
1050     EnterCriticalSection(&This->lock);
1051
1052     ret = ppng_get_PLTE(This->png_ptr, This->info_ptr, &png_palette, &num_palette);
1053     if (!ret)
1054     {
1055         hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
1056         goto end;
1057     }
1058
1059     if (num_palette > 256)
1060     {
1061         ERR("palette has %i colors?!\n", num_palette);
1062         hr = E_FAIL;
1063         goto end;
1064     }
1065
1066     ret = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans_alpha, &num_trans, &trans_values);
1067     if (!ret) num_trans = 0;
1068
1069     for (i=0; i<num_palette; i++)
1070     {
1071         BYTE alpha = (i < num_trans) ? trans_alpha[i] : 0xff;
1072         palette[i] = (alpha << 24 |
1073                       png_palette[i].red << 16|
1074                       png_palette[i].green << 8|
1075                       png_palette[i].blue);
1076     }
1077
1078 end:
1079
1080     LeaveCriticalSection(&This->lock);
1081
1082     if (SUCCEEDED(hr))
1083         hr = IWICPalette_InitializeCustom(pIPalette, palette, num_palette);
1084
1085     return hr;
1086 }
1087
1088 static HRESULT WINAPI PngDecoder_Frame_CopyPixels(IWICBitmapFrameDecode *iface,
1089     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
1090 {
1091     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
1092     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
1093
1094     return copy_pixels(This->bpp, This->image_bits,
1095         This->width, This->height, This->stride,
1096         prc, cbStride, cbBufferSize, pbBuffer);
1097 }
1098
1099 static HRESULT WINAPI PngDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
1100     IWICMetadataQueryReader **ppIMetadataQueryReader)
1101 {
1102     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
1103
1104     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
1105
1106     if (!ppIMetadataQueryReader)
1107         return E_INVALIDARG;
1108
1109     return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, ppIMetadataQueryReader);
1110 }
1111
1112 static HRESULT WINAPI PngDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode *iface,
1113     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
1114 {
1115     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
1116     png_charp name;
1117     BYTE *profile;
1118     png_uint_32 len;
1119     int compression_type;
1120     HRESULT hr;
1121
1122     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
1123
1124     if (!pcActualCount) return E_INVALIDARG;
1125
1126     EnterCriticalSection(&This->lock);
1127
1128     if (ppng_get_iCCP(This->png_ptr, This->info_ptr, &name, &compression_type, (void *)&profile, &len))
1129     {
1130         if (cCount && ppIColorContexts)
1131         {
1132             hr = IWICColorContext_InitializeFromMemory(*ppIColorContexts, profile, len);
1133             if (FAILED(hr))
1134             {
1135                 LeaveCriticalSection(&This->lock);
1136                 return hr;
1137             }
1138         }
1139         *pcActualCount = 1;
1140     }
1141     else
1142         *pcActualCount = 0;
1143
1144     LeaveCriticalSection(&This->lock);
1145
1146     return S_OK;
1147 }
1148
1149 static HRESULT WINAPI PngDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode *iface,
1150     IWICBitmapSource **ppIThumbnail)
1151 {
1152     TRACE("(%p,%p)\n", iface, ppIThumbnail);
1153
1154     if (!ppIThumbnail) return E_INVALIDARG;
1155
1156     *ppIThumbnail = NULL;
1157     return WINCODEC_ERR_CODECNOTHUMBNAIL;
1158 }
1159
1160 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl = {
1161     PngDecoder_Frame_QueryInterface,
1162     PngDecoder_Frame_AddRef,
1163     PngDecoder_Frame_Release,
1164     PngDecoder_Frame_GetSize,
1165     PngDecoder_Frame_GetPixelFormat,
1166     PngDecoder_Frame_GetResolution,
1167     PngDecoder_Frame_CopyPalette,
1168     PngDecoder_Frame_CopyPixels,
1169     PngDecoder_Frame_GetMetadataQueryReader,
1170     PngDecoder_Frame_GetColorContexts,
1171     PngDecoder_Frame_GetThumbnail
1172 };
1173
1174 static HRESULT WINAPI PngDecoder_Block_QueryInterface(IWICMetadataBlockReader *iface, REFIID iid,
1175     void **ppv)
1176 {
1177     PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1178     return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
1179 }
1180
1181 static ULONG WINAPI PngDecoder_Block_AddRef(IWICMetadataBlockReader *iface)
1182 {
1183     PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1184     return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
1185 }
1186
1187 static ULONG WINAPI PngDecoder_Block_Release(IWICMetadataBlockReader *iface)
1188 {
1189     PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1190     return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1191 }
1192
1193 static HRESULT WINAPI PngDecoder_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
1194     GUID *pguidContainerFormat)
1195 {
1196     if (!pguidContainerFormat) return E_INVALIDARG;
1197     memcpy(pguidContainerFormat, &GUID_ContainerFormatPng, sizeof(GUID));
1198     return S_OK;
1199 }
1200
1201 static HRESULT WINAPI PngDecoder_Block_GetCount(IWICMetadataBlockReader *iface,
1202     UINT *pcCount)
1203 {
1204     PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1205
1206     TRACE("%p,%p\n", iface, pcCount);
1207
1208     if (!pcCount) return E_INVALIDARG;
1209
1210     *pcCount = This->metadata_count;
1211
1212     return S_OK;
1213 }
1214
1215 static HRESULT WINAPI PngDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
1216     UINT nIndex, IWICMetadataReader **ppIMetadataReader)
1217 {
1218     PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
1219     HRESULT hr;
1220     IWICComponentFactory* factory;
1221     IWICStream* stream;
1222
1223     TRACE("%p,%d,%p\n", iface, nIndex, ppIMetadataReader);
1224
1225     if (nIndex >= This->metadata_count || !ppIMetadataReader)
1226         return E_INVALIDARG;
1227
1228     if (!This->metadata_blocks[nIndex].reader)
1229     {
1230         hr = StreamImpl_Create(&stream);
1231
1232         if (SUCCEEDED(hr))
1233         {
1234             hr = IWICStream_InitializeFromIStreamRegion(stream, This->stream,
1235                 This->metadata_blocks[nIndex].ofs, This->metadata_blocks[nIndex].len);
1236
1237             if (SUCCEEDED(hr))
1238                 hr = ComponentFactory_CreateInstance(&IID_IWICComponentFactory, (void**)&factory);
1239
1240             if (SUCCEEDED(hr))
1241             {
1242                 hr = IWICComponentFactory_CreateMetadataReaderFromContainer(factory,
1243                     &GUID_ContainerFormatPng, NULL, WICMetadataCreationAllowUnknown,
1244                     (IStream*)stream, &This->metadata_blocks[nIndex].reader);
1245
1246                 IWICComponentFactory_Release(factory);
1247             }
1248
1249             IWICStream_Release(stream);
1250         }
1251
1252         if (FAILED(hr))
1253         {
1254             *ppIMetadataReader = NULL;
1255             return hr;
1256         }
1257     }
1258
1259     *ppIMetadataReader = This->metadata_blocks[nIndex].reader;
1260     IWICMetadataReader_AddRef(*ppIMetadataReader);
1261
1262     return S_OK;
1263 }
1264
1265 static HRESULT WINAPI PngDecoder_Block_GetEnumerator(IWICMetadataBlockReader *iface,
1266     IEnumUnknown **ppIEnumMetadata)
1267 {
1268     FIXME("%p,%p\n", iface, ppIEnumMetadata);
1269     return E_NOTIMPL;
1270 }
1271
1272 static const IWICMetadataBlockReaderVtbl PngDecoder_BlockVtbl = {
1273     PngDecoder_Block_QueryInterface,
1274     PngDecoder_Block_AddRef,
1275     PngDecoder_Block_Release,
1276     PngDecoder_Block_GetContainerFormat,
1277     PngDecoder_Block_GetCount,
1278     PngDecoder_Block_GetReaderByIndex,
1279     PngDecoder_Block_GetEnumerator,
1280 };
1281
1282 HRESULT PngDecoder_CreateInstance(REFIID iid, void** ppv)
1283 {
1284     PngDecoder *This;
1285     HRESULT ret;
1286
1287     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1288
1289     *ppv = NULL;
1290
1291     if (!load_libpng())
1292     {
1293         ERR("Failed reading PNG because unable to find %s\n",SONAME_LIBPNG);
1294         return E_FAIL;
1295     }
1296
1297     This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngDecoder));
1298     if (!This) return E_OUTOFMEMORY;
1299
1300     This->IWICBitmapDecoder_iface.lpVtbl = &PngDecoder_Vtbl;
1301     This->IWICBitmapFrameDecode_iface.lpVtbl = &PngDecoder_FrameVtbl;
1302     This->IWICMetadataBlockReader_iface.lpVtbl = &PngDecoder_BlockVtbl;
1303     This->ref = 1;
1304     This->png_ptr = NULL;
1305     This->info_ptr = NULL;
1306     This->end_info = NULL;
1307     This->stream = NULL;
1308     This->initialized = FALSE;
1309     This->image_bits = NULL;
1310     InitializeCriticalSection(&This->lock);
1311     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngDecoder.lock");
1312     This->metadata_count = 0;
1313     This->metadata_blocks = NULL;
1314
1315     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1316     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1317
1318     return ret;
1319 }
1320
1321 struct png_pixelformat {
1322     const WICPixelFormatGUID *guid;
1323     UINT bpp;
1324     int bit_depth;
1325     int color_type;
1326     BOOL remove_filler;
1327     BOOL swap_rgb;
1328 };
1329
1330 static const struct png_pixelformat formats[] = {
1331     {&GUID_WICPixelFormat24bppBGR, 24, 8, PNG_COLOR_TYPE_RGB, 0, 1},
1332     {&GUID_WICPixelFormatBlackWhite, 1, 1, PNG_COLOR_TYPE_GRAY, 0, 0},
1333     {&GUID_WICPixelFormat2bppGray, 2, 2, PNG_COLOR_TYPE_GRAY, 0, 0},
1334     {&GUID_WICPixelFormat4bppGray, 4, 4, PNG_COLOR_TYPE_GRAY, 0, 0},
1335     {&GUID_WICPixelFormat8bppGray, 8, 8, PNG_COLOR_TYPE_GRAY, 0, 0},
1336     {&GUID_WICPixelFormat16bppGray, 16, 16, PNG_COLOR_TYPE_GRAY, 0, 0},
1337     {&GUID_WICPixelFormat32bppBGR, 32, 8, PNG_COLOR_TYPE_RGB, 1, 1},
1338     {&GUID_WICPixelFormat32bppBGRA, 32, 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 1},
1339     {&GUID_WICPixelFormat48bppRGB, 48, 16, PNG_COLOR_TYPE_RGB, 0, 0},
1340     {&GUID_WICPixelFormat64bppRGBA, 64, 16, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0},
1341     {NULL},
1342 };
1343
1344 typedef struct PngEncoder {
1345     IWICBitmapEncoder IWICBitmapEncoder_iface;
1346     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
1347     LONG ref;
1348     IStream *stream;
1349     png_structp png_ptr;
1350     png_infop info_ptr;
1351     UINT frame_count;
1352     BOOL frame_initialized;
1353     const struct png_pixelformat *format;
1354     BOOL info_written;
1355     UINT width, height;
1356     double xres, yres;
1357     UINT lines_written;
1358     BOOL frame_committed;
1359     BOOL committed;
1360     CRITICAL_SECTION lock;
1361     BOOL interlace;
1362     WICPngFilterOption filter;
1363     BYTE *data;
1364     UINT stride;
1365     UINT passes;
1366     WICColor palette[256];
1367     UINT colors;
1368 } PngEncoder;
1369
1370 static inline PngEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
1371 {
1372     return CONTAINING_RECORD(iface, PngEncoder, IWICBitmapEncoder_iface);
1373 }
1374
1375 static inline PngEncoder *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
1376 {
1377     return CONTAINING_RECORD(iface, PngEncoder, IWICBitmapFrameEncode_iface);
1378 }
1379
1380 static HRESULT WINAPI PngFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
1381     void **ppv)
1382 {
1383     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1384     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1385
1386     if (!ppv) return E_INVALIDARG;
1387
1388     if (IsEqualIID(&IID_IUnknown, iid) ||
1389         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
1390     {
1391         *ppv = &This->IWICBitmapFrameEncode_iface;
1392     }
1393     else
1394     {
1395         *ppv = NULL;
1396         return E_NOINTERFACE;
1397     }
1398
1399     IUnknown_AddRef((IUnknown*)*ppv);
1400     return S_OK;
1401 }
1402
1403 static ULONG WINAPI PngFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
1404 {
1405     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1406     return IWICBitmapEncoder_AddRef(&This->IWICBitmapEncoder_iface);
1407 }
1408
1409 static ULONG WINAPI PngFrameEncode_Release(IWICBitmapFrameEncode *iface)
1410 {
1411     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1412     return IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
1413 }
1414
1415 static HRESULT WINAPI PngFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
1416     IPropertyBag2 *pIEncoderOptions)
1417 {
1418     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1419     WICPngFilterOption filter;
1420     BOOL interlace;
1421     PROPBAG2 opts[2]= {{0}};
1422     VARIANT opt_values[2];
1423     HRESULT opt_hres[2];
1424     HRESULT hr;
1425
1426     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
1427
1428     opts[0].pstrName = (LPOLESTR)wszPngInterlaceOption;
1429     opts[0].vt = VT_BOOL;
1430     opts[1].pstrName = (LPOLESTR)wszPngFilterOption;
1431     opts[1].vt = VT_UI1;
1432
1433     if (pIEncoderOptions)
1434     {
1435         hr = IPropertyBag2_Read(pIEncoderOptions, sizeof(opts)/sizeof(opts[0]), opts, NULL, opt_values, opt_hres);
1436
1437         if (FAILED(hr))
1438             return hr;
1439
1440         if (V_VT(&opt_values[0]) == VT_EMPTY)
1441             interlace = FALSE;
1442         else
1443             interlace = (V_BOOL(&opt_values[0]) != 0);
1444
1445         filter = V_UI1(&opt_values[1]);
1446         if (filter > WICPngFilterAdaptive)
1447         {
1448             WARN("Unrecognized filter option value %u.\n", filter);
1449             filter = WICPngFilterUnspecified;
1450         }
1451     }
1452     else
1453     {
1454         interlace = FALSE;
1455         filter = WICPngFilterUnspecified;
1456     }
1457
1458     EnterCriticalSection(&This->lock);
1459
1460     if (This->frame_initialized)
1461     {
1462         LeaveCriticalSection(&This->lock);
1463         return WINCODEC_ERR_WRONGSTATE;
1464     }
1465
1466     This->interlace = interlace;
1467     This->filter = filter;
1468
1469     This->frame_initialized = TRUE;
1470
1471     LeaveCriticalSection(&This->lock);
1472
1473     return S_OK;
1474 }
1475
1476 static HRESULT WINAPI PngFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
1477     UINT uiWidth, UINT uiHeight)
1478 {
1479     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1480     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
1481
1482     EnterCriticalSection(&This->lock);
1483
1484     if (!This->frame_initialized || This->info_written)
1485     {
1486         LeaveCriticalSection(&This->lock);
1487         return WINCODEC_ERR_WRONGSTATE;
1488     }
1489
1490     This->width = uiWidth;
1491     This->height = uiHeight;
1492
1493     LeaveCriticalSection(&This->lock);
1494
1495     return S_OK;
1496 }
1497
1498 static HRESULT WINAPI PngFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
1499     double dpiX, double dpiY)
1500 {
1501     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1502     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
1503
1504     EnterCriticalSection(&This->lock);
1505
1506     if (!This->frame_initialized || This->info_written)
1507     {
1508         LeaveCriticalSection(&This->lock);
1509         return WINCODEC_ERR_WRONGSTATE;
1510     }
1511
1512     This->xres = dpiX;
1513     This->yres = dpiY;
1514
1515     LeaveCriticalSection(&This->lock);
1516
1517     return S_OK;
1518 }
1519
1520 static HRESULT WINAPI PngFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
1521     WICPixelFormatGUID *pPixelFormat)
1522 {
1523     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1524     int i;
1525     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
1526
1527     EnterCriticalSection(&This->lock);
1528
1529     if (!This->frame_initialized || This->info_written)
1530     {
1531         LeaveCriticalSection(&This->lock);
1532         return WINCODEC_ERR_WRONGSTATE;
1533     }
1534
1535     for (i=0; formats[i].guid; i++)
1536     {
1537         if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
1538             break;
1539     }
1540
1541     if (!formats[i].guid) i = 0;
1542
1543     This->format = &formats[i];
1544     memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
1545
1546     LeaveCriticalSection(&This->lock);
1547
1548     return S_OK;
1549 }
1550
1551 static HRESULT WINAPI PngFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
1552     UINT cCount, IWICColorContext **ppIColorContext)
1553 {
1554     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1555     return E_NOTIMPL;
1556 }
1557
1558 static HRESULT WINAPI PngFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
1559     IWICPalette *palette)
1560 {
1561     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1562     HRESULT hr;
1563
1564     TRACE("(%p,%p)\n", iface, palette);
1565
1566     if (!palette) return E_INVALIDARG;
1567
1568     EnterCriticalSection(&This->lock);
1569
1570     if (This->frame_initialized)
1571         hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
1572     else
1573         hr = WINCODEC_ERR_NOTINITIALIZED;
1574
1575     LeaveCriticalSection(&This->lock);
1576     return hr;
1577 }
1578
1579 static HRESULT WINAPI PngFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
1580     IWICBitmapSource *pIThumbnail)
1581 {
1582     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
1583     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1584 }
1585
1586 static HRESULT WINAPI PngFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
1587     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
1588 {
1589     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1590     png_byte **row_pointers=NULL;
1591     UINT i;
1592     jmp_buf jmpbuf;
1593     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
1594
1595     EnterCriticalSection(&This->lock);
1596
1597     if (!This->frame_initialized || !This->width || !This->height || !This->format)
1598     {
1599         LeaveCriticalSection(&This->lock);
1600         return WINCODEC_ERR_WRONGSTATE;
1601     }
1602
1603     if (lineCount == 0 || lineCount + This->lines_written > This->height)
1604     {
1605         LeaveCriticalSection(&This->lock);
1606         return E_INVALIDARG;
1607     }
1608
1609     /* set up setjmp/longjmp error handling */
1610     if (setjmp(jmpbuf))
1611     {
1612         LeaveCriticalSection(&This->lock);
1613         HeapFree(GetProcessHeap(), 0, row_pointers);
1614         return E_FAIL;
1615     }
1616     ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
1617
1618     if (!This->info_written)
1619     {
1620         if (This->interlace)
1621         {
1622             /* libpng requires us to write all data multiple times in this case. */
1623             This->stride = (This->format->bpp * This->width + 7)/8;
1624             This->data = HeapAlloc(GetProcessHeap(), 0, This->height * This->stride);
1625             if (!This->data)
1626             {
1627                 LeaveCriticalSection(&This->lock);
1628                 return E_OUTOFMEMORY;
1629             }
1630         }
1631
1632         ppng_set_IHDR(This->png_ptr, This->info_ptr, This->width, This->height,
1633             This->format->bit_depth, This->format->color_type,
1634             This->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE,
1635             PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1636
1637         if (This->xres != 0.0 && This->yres != 0.0)
1638         {
1639             ppng_set_pHYs(This->png_ptr, This->info_ptr, (This->xres+0.0127) / 0.0254,
1640                 (This->yres+0.0127) / 0.0254, PNG_RESOLUTION_METER);
1641         }
1642
1643         ppng_write_info(This->png_ptr, This->info_ptr);
1644
1645         if (This->format->remove_filler)
1646             ppng_set_filler(This->png_ptr, 0, PNG_FILLER_AFTER);
1647
1648         if (This->format->swap_rgb)
1649             ppng_set_bgr(This->png_ptr);
1650
1651         if (This->interlace)
1652             This->passes = ppng_set_interlace_handling(This->png_ptr);
1653
1654         if (This->filter != WICPngFilterUnspecified)
1655         {
1656             static const int png_filter_map[] =
1657             {
1658                 /* WICPngFilterUnspecified */ PNG_NO_FILTERS,
1659                 /* WICPngFilterNone */        PNG_FILTER_NONE,
1660                 /* WICPngFilterSub */         PNG_FILTER_SUB,
1661                 /* WICPngFilterUp */          PNG_FILTER_UP,
1662                 /* WICPngFilterAverage */     PNG_FILTER_AVG,
1663                 /* WICPngFilterPaeth */       PNG_FILTER_PAETH,
1664                 /* WICPngFilterAdaptive */    PNG_ALL_FILTERS,
1665             };
1666
1667             ppng_set_filter(This->png_ptr, 0, png_filter_map[This->filter]);
1668         }
1669
1670         This->info_written = TRUE;
1671     }
1672
1673     if (This->interlace)
1674     {
1675         /* Just store the data so we can write it in multiple passes in Commit. */
1676         for (i=0; i<lineCount; i++)
1677             memcpy(This->data + This->stride * (This->lines_written + i),
1678                    pbPixels + cbStride * i,
1679                    This->stride);
1680
1681         This->lines_written += lineCount;
1682
1683         LeaveCriticalSection(&This->lock);
1684         return S_OK;
1685     }
1686
1687     row_pointers = HeapAlloc(GetProcessHeap(), 0, lineCount * sizeof(png_byte*));
1688     if (!row_pointers)
1689     {
1690         LeaveCriticalSection(&This->lock);
1691         return E_OUTOFMEMORY;
1692     }
1693
1694     for (i=0; i<lineCount; i++)
1695         row_pointers[i] = pbPixels + cbStride * i;
1696
1697     ppng_write_rows(This->png_ptr, row_pointers, lineCount);
1698     This->lines_written += lineCount;
1699
1700     LeaveCriticalSection(&This->lock);
1701
1702     HeapFree(GetProcessHeap(), 0, row_pointers);
1703
1704     return S_OK;
1705 }
1706
1707 static HRESULT WINAPI PngFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
1708     IWICBitmapSource *pIBitmapSource, WICRect *prc)
1709 {
1710     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1711     HRESULT hr;
1712     TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
1713
1714     if (!This->frame_initialized)
1715         return WINCODEC_ERR_WRONGSTATE;
1716
1717     hr = configure_write_source(iface, pIBitmapSource, prc,
1718         This->format ? This->format->guid : NULL, This->width, This->height,
1719         This->xres, This->yres);
1720
1721     if (SUCCEEDED(hr))
1722     {
1723         hr = write_source(iface, pIBitmapSource, prc,
1724             This->format->guid, This->format->bpp, This->width, This->height);
1725     }
1726
1727     return hr;
1728 }
1729
1730 static HRESULT WINAPI PngFrameEncode_Commit(IWICBitmapFrameEncode *iface)
1731 {
1732     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1733     png_byte **row_pointers=NULL;
1734     jmp_buf jmpbuf;
1735     TRACE("(%p)\n", iface);
1736
1737     EnterCriticalSection(&This->lock);
1738
1739     if (!This->info_written || This->lines_written != This->height || This->frame_committed)
1740     {
1741         LeaveCriticalSection(&This->lock);
1742         return WINCODEC_ERR_WRONGSTATE;
1743     }
1744
1745     /* set up setjmp/longjmp error handling */
1746     if (setjmp(jmpbuf))
1747     {
1748         LeaveCriticalSection(&This->lock);
1749         HeapFree(GetProcessHeap(), 0, row_pointers);
1750         return E_FAIL;
1751     }
1752     ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
1753
1754     if (This->interlace)
1755     {
1756         int i;
1757
1758         row_pointers = HeapAlloc(GetProcessHeap(), 0, This->height * sizeof(png_byte*));
1759         if (!row_pointers)
1760         {
1761             LeaveCriticalSection(&This->lock);
1762             return E_OUTOFMEMORY;
1763         }
1764
1765         for (i=0; i<This->height; i++)
1766             row_pointers[i] = This->data + This->stride * i;
1767
1768         for (i=0; i<This->passes; i++)
1769             ppng_write_rows(This->png_ptr, row_pointers, This->height);
1770     }
1771
1772     ppng_write_end(This->png_ptr, This->info_ptr);
1773
1774     This->frame_committed = TRUE;
1775
1776     HeapFree(GetProcessHeap(), 0, row_pointers);
1777
1778     LeaveCriticalSection(&This->lock);
1779
1780     return S_OK;
1781 }
1782
1783 static HRESULT WINAPI PngFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
1784     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1785 {
1786     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
1787     return E_NOTIMPL;
1788 }
1789
1790 static const IWICBitmapFrameEncodeVtbl PngEncoder_FrameVtbl = {
1791     PngFrameEncode_QueryInterface,
1792     PngFrameEncode_AddRef,
1793     PngFrameEncode_Release,
1794     PngFrameEncode_Initialize,
1795     PngFrameEncode_SetSize,
1796     PngFrameEncode_SetResolution,
1797     PngFrameEncode_SetPixelFormat,
1798     PngFrameEncode_SetColorContexts,
1799     PngFrameEncode_SetPalette,
1800     PngFrameEncode_SetThumbnail,
1801     PngFrameEncode_WritePixels,
1802     PngFrameEncode_WriteSource,
1803     PngFrameEncode_Commit,
1804     PngFrameEncode_GetMetadataQueryWriter
1805 };
1806
1807 static HRESULT WINAPI PngEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
1808     void **ppv)
1809 {
1810     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1811     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1812
1813     if (!ppv) return E_INVALIDARG;
1814
1815     if (IsEqualIID(&IID_IUnknown, iid) ||
1816         IsEqualIID(&IID_IWICBitmapEncoder, iid))
1817     {
1818         *ppv = &This->IWICBitmapEncoder_iface;
1819     }
1820     else
1821     {
1822         *ppv = NULL;
1823         return E_NOINTERFACE;
1824     }
1825
1826     IUnknown_AddRef((IUnknown*)*ppv);
1827     return S_OK;
1828 }
1829
1830 static ULONG WINAPI PngEncoder_AddRef(IWICBitmapEncoder *iface)
1831 {
1832     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1833     ULONG ref = InterlockedIncrement(&This->ref);
1834
1835     TRACE("(%p) refcount=%u\n", iface, ref);
1836
1837     return ref;
1838 }
1839
1840 static ULONG WINAPI PngEncoder_Release(IWICBitmapEncoder *iface)
1841 {
1842     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1843     ULONG ref = InterlockedDecrement(&This->ref);
1844
1845     TRACE("(%p) refcount=%u\n", iface, ref);
1846
1847     if (ref == 0)
1848     {
1849         This->lock.DebugInfo->Spare[0] = 0;
1850         DeleteCriticalSection(&This->lock);
1851         if (This->png_ptr)
1852             ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1853         if (This->stream)
1854             IStream_Release(This->stream);
1855         HeapFree(GetProcessHeap(), 0, This->data);
1856         HeapFree(GetProcessHeap(), 0, This);
1857     }
1858
1859     return ref;
1860 }
1861
1862 static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1863 {
1864     PngEncoder *This = ppng_get_io_ptr(png_ptr);
1865     HRESULT hr;
1866     ULONG byteswritten;
1867
1868     hr = IStream_Write(This->stream, data, length, &byteswritten);
1869     if (FAILED(hr) || byteswritten != length)
1870     {
1871         ppng_error(png_ptr, "failed writing data");
1872     }
1873 }
1874
1875 static void user_flush(png_structp png_ptr)
1876 {
1877 }
1878
1879 static HRESULT WINAPI PngEncoder_Initialize(IWICBitmapEncoder *iface,
1880     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
1881 {
1882     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1883     jmp_buf jmpbuf;
1884
1885     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
1886
1887     EnterCriticalSection(&This->lock);
1888
1889     if (This->png_ptr)
1890     {
1891         LeaveCriticalSection(&This->lock);
1892         return WINCODEC_ERR_WRONGSTATE;
1893     }
1894
1895     /* initialize libpng */
1896     This->png_ptr = ppng_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1897     if (!This->png_ptr)
1898     {
1899         LeaveCriticalSection(&This->lock);
1900         return E_FAIL;
1901     }
1902
1903     This->info_ptr = ppng_create_info_struct(This->png_ptr);
1904     if (!This->info_ptr)
1905     {
1906         ppng_destroy_write_struct(&This->png_ptr, NULL);
1907         This->png_ptr = NULL;
1908         LeaveCriticalSection(&This->lock);
1909         return E_FAIL;
1910     }
1911
1912     IStream_AddRef(pIStream);
1913     This->stream = pIStream;
1914
1915     /* set up setjmp/longjmp error handling */
1916     if (setjmp(jmpbuf))
1917     {
1918         ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1919         This->png_ptr = NULL;
1920         IStream_Release(This->stream);
1921         This->stream = NULL;
1922         LeaveCriticalSection(&This->lock);
1923         return E_FAIL;
1924     }
1925     ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
1926
1927     /* set up custom i/o handling */
1928     ppng_set_write_fn(This->png_ptr, This, user_write_data, user_flush);
1929
1930     LeaveCriticalSection(&This->lock);
1931
1932     return S_OK;
1933 }
1934
1935 static HRESULT WINAPI PngEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
1936     GUID *pguidContainerFormat)
1937 {
1938     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
1939     return E_NOTIMPL;
1940 }
1941
1942 static HRESULT WINAPI PngEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
1943     IWICBitmapEncoderInfo **ppIEncoderInfo)
1944 {
1945     FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
1946     return E_NOTIMPL;
1947 }
1948
1949 static HRESULT WINAPI PngEncoder_SetColorContexts(IWICBitmapEncoder *iface,
1950     UINT cCount, IWICColorContext **ppIColorContext)
1951 {
1952     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1953     return E_NOTIMPL;
1954 }
1955
1956 static HRESULT WINAPI PngEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
1957 {
1958     TRACE("(%p,%p)\n", iface, pIPalette);
1959     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1960 }
1961
1962 static HRESULT WINAPI PngEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
1963 {
1964     TRACE("(%p,%p)\n", iface, pIThumbnail);
1965     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1966 }
1967
1968 static HRESULT WINAPI PngEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
1969 {
1970     TRACE("(%p,%p)\n", iface, pIPreview);
1971     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1972 }
1973
1974 static HRESULT WINAPI PngEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
1975     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
1976 {
1977     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1978     HRESULT hr;
1979     PROPBAG2 opts[2]= {{0}};
1980
1981     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
1982
1983     EnterCriticalSection(&This->lock);
1984
1985     if (This->frame_count != 0)
1986     {
1987         LeaveCriticalSection(&This->lock);
1988         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1989     }
1990
1991     if (!This->stream)
1992     {
1993         LeaveCriticalSection(&This->lock);
1994         return WINCODEC_ERR_NOTINITIALIZED;
1995     }
1996
1997     opts[0].pstrName = (LPOLESTR)wszPngInterlaceOption;
1998     opts[0].vt = VT_BOOL;
1999     opts[0].dwType = PROPBAG2_TYPE_DATA;
2000     opts[1].pstrName = (LPOLESTR)wszPngFilterOption;
2001     opts[1].vt = VT_UI1;
2002     opts[1].dwType = PROPBAG2_TYPE_DATA;
2003
2004     hr = CreatePropertyBag2(opts, sizeof(opts)/sizeof(opts[0]), ppIEncoderOptions);
2005     if (FAILED(hr))
2006     {
2007         LeaveCriticalSection(&This->lock);
2008         return hr;
2009     }
2010
2011     This->frame_count = 1;
2012
2013     LeaveCriticalSection(&This->lock);
2014
2015     IWICBitmapEncoder_AddRef(iface);
2016     *ppIFrameEncode = &This->IWICBitmapFrameEncode_iface;
2017
2018     return S_OK;
2019 }
2020
2021 static HRESULT WINAPI PngEncoder_Commit(IWICBitmapEncoder *iface)
2022 {
2023     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
2024     TRACE("(%p)\n", iface);
2025
2026     EnterCriticalSection(&This->lock);
2027
2028     if (!This->frame_committed || This->committed)
2029     {
2030         LeaveCriticalSection(&This->lock);
2031         return WINCODEC_ERR_WRONGSTATE;
2032     }
2033
2034     This->committed = TRUE;
2035
2036     LeaveCriticalSection(&This->lock);
2037
2038     return S_OK;
2039 }
2040
2041 static HRESULT WINAPI PngEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
2042     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
2043 {
2044     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
2045     return E_NOTIMPL;
2046 }
2047
2048 static const IWICBitmapEncoderVtbl PngEncoder_Vtbl = {
2049     PngEncoder_QueryInterface,
2050     PngEncoder_AddRef,
2051     PngEncoder_Release,
2052     PngEncoder_Initialize,
2053     PngEncoder_GetContainerFormat,
2054     PngEncoder_GetEncoderInfo,
2055     PngEncoder_SetColorContexts,
2056     PngEncoder_SetPalette,
2057     PngEncoder_SetThumbnail,
2058     PngEncoder_SetPreview,
2059     PngEncoder_CreateNewFrame,
2060     PngEncoder_Commit,
2061     PngEncoder_GetMetadataQueryWriter
2062 };
2063
2064 HRESULT PngEncoder_CreateInstance(REFIID iid, void** ppv)
2065 {
2066     PngEncoder *This;
2067     HRESULT ret;
2068
2069     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
2070
2071     *ppv = NULL;
2072
2073     if (!load_libpng())
2074     {
2075         ERR("Failed writing PNG because unable to find %s\n",SONAME_LIBPNG);
2076         return E_FAIL;
2077     }
2078
2079     This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngEncoder));
2080     if (!This) return E_OUTOFMEMORY;
2081
2082     This->IWICBitmapEncoder_iface.lpVtbl = &PngEncoder_Vtbl;
2083     This->IWICBitmapFrameEncode_iface.lpVtbl = &PngEncoder_FrameVtbl;
2084     This->ref = 1;
2085     This->png_ptr = NULL;
2086     This->info_ptr = NULL;
2087     This->stream = NULL;
2088     This->frame_count = 0;
2089     This->frame_initialized = FALSE;
2090     This->format = NULL;
2091     This->info_written = FALSE;
2092     This->width = 0;
2093     This->height = 0;
2094     This->xres = 0.0;
2095     This->yres = 0.0;
2096     This->lines_written = 0;
2097     This->frame_committed = FALSE;
2098     This->committed = FALSE;
2099     This->data = NULL;
2100     This->colors = 0;
2101     InitializeCriticalSection(&This->lock);
2102     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngEncoder.lock");
2103
2104     ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
2105     IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
2106
2107     return ret;
2108 }
2109
2110 #else /* !HAVE_PNG_H */
2111
2112 HRESULT PngDecoder_CreateInstance(REFIID iid, void** ppv)
2113 {
2114     ERR("Trying to load PNG picture, but PNG support is not compiled in.\n");
2115     return E_FAIL;
2116 }
2117
2118 HRESULT PngEncoder_CreateInstance(REFIID iid, void** ppv)
2119 {
2120     ERR("Trying to save PNG picture, but PNG support is not compiled in.\n");
2121     return E_FAIL;
2122 }
2123
2124 #endif