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