git.oblomov.eu Git - wine/blob - 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 COBJMACROS
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "objbase.h"
  33 #include "wincodec.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 #ifdef SONAME_LIBPNG
  43
  44 static void *libpng_handle;
  45 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
  46 MAKE_FUNCPTR(png_create_read_struct);
  47 MAKE_FUNCPTR(png_create_info_struct);
  48 MAKE_FUNCPTR(png_create_write_struct);
  49 MAKE_FUNCPTR(png_destroy_read_struct);
  50 MAKE_FUNCPTR(png_destroy_write_struct);
  51 MAKE_FUNCPTR(png_error);
  52 MAKE_FUNCPTR(png_get_bit_depth);
  53 MAKE_FUNCPTR(png_get_color_type);
  54 MAKE_FUNCPTR(png_get_error_ptr);
  55 MAKE_FUNCPTR(png_get_image_height);
  56 MAKE_FUNCPTR(png_get_image_width);
  57 MAKE_FUNCPTR(png_get_io_ptr);
  58 MAKE_FUNCPTR(png_get_pHYs);
  59 MAKE_FUNCPTR(png_get_progressive_ptr);
  60 MAKE_FUNCPTR(png_get_PLTE);
  61 MAKE_FUNCPTR(png_get_tRNS);
  62 MAKE_FUNCPTR(png_process_data);
  63 MAKE_FUNCPTR(png_progressive_combine_row);
  64 MAKE_FUNCPTR(png_set_bgr);
  65 MAKE_FUNCPTR(png_set_error_fn);
  66 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
  67 MAKE_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
  68 #else
  69 MAKE_FUNCPTR(png_set_gray_1_2_4_to_8);
  70 #endif
  71 MAKE_FUNCPTR(png_set_filler);
  72 MAKE_FUNCPTR(png_set_gray_to_rgb);
  73 MAKE_FUNCPTR(png_set_IHDR);
  74 MAKE_FUNCPTR(png_set_pHYs);
  75 MAKE_FUNCPTR(png_set_progressive_read_fn);
  76 MAKE_FUNCPTR(png_set_read_fn);
  77 MAKE_FUNCPTR(png_set_strip_16);
  78 MAKE_FUNCPTR(png_set_tRNS_to_alpha);
  79 MAKE_FUNCPTR(png_set_write_fn);
  80 MAKE_FUNCPTR(png_read_end);
  81 MAKE_FUNCPTR(png_read_image);
  82 MAKE_FUNCPTR(png_read_info);
  83 MAKE_FUNCPTR(png_read_update_info);
  84 MAKE_FUNCPTR(png_write_end);
  85 MAKE_FUNCPTR(png_write_info);
  86 MAKE_FUNCPTR(png_write_rows);
  87 #undef MAKE_FUNCPTR
  88
  89 static void *load_libpng(void)
  90 {
  91     if((libpng_handle = wine_dlopen(SONAME_LIBPNG, RTLD_NOW, NULL, 0)) != NULL) {
  92
  93 #define LOAD_FUNCPTR(f) \
  94     if((p##f = wine_dlsym(libpng_handle, #f, NULL, 0)) == NULL) { \
  95         libpng_handle = NULL; \
  96         return NULL; \
  97     }
  98         LOAD_FUNCPTR(png_create_read_struct);
  99         LOAD_FUNCPTR(png_create_info_struct);
 100         LOAD_FUNCPTR(png_create_write_struct);
 101         LOAD_FUNCPTR(png_destroy_read_struct);
 102         LOAD_FUNCPTR(png_destroy_write_struct);
 103         LOAD_FUNCPTR(png_error);
 104         LOAD_FUNCPTR(png_get_bit_depth);
 105         LOAD_FUNCPTR(png_get_color_type);
 106         LOAD_FUNCPTR(png_get_error_ptr);
 107         LOAD_FUNCPTR(png_get_image_height);
 108         LOAD_FUNCPTR(png_get_image_width);
 109         LOAD_FUNCPTR(png_get_io_ptr);
 110         LOAD_FUNCPTR(png_get_pHYs);
 111         LOAD_FUNCPTR(png_get_progressive_ptr);
 112         LOAD_FUNCPTR(png_get_PLTE);
 113         LOAD_FUNCPTR(png_get_tRNS);
 114         LOAD_FUNCPTR(png_process_data);
 115         LOAD_FUNCPTR(png_progressive_combine_row);
 116         LOAD_FUNCPTR(png_set_bgr);
 117         LOAD_FUNCPTR(png_set_error_fn);
 118 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 119         LOAD_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
 120 #else
 121         LOAD_FUNCPTR(png_set_gray_1_2_4_to_8);
 122 #endif
 123         LOAD_FUNCPTR(png_set_filler);
 124         LOAD_FUNCPTR(png_set_gray_to_rgb);
 125         LOAD_FUNCPTR(png_set_IHDR);
 126         LOAD_FUNCPTR(png_set_pHYs);
 127         LOAD_FUNCPTR(png_set_progressive_read_fn);
 128         LOAD_FUNCPTR(png_set_read_fn);
 129         LOAD_FUNCPTR(png_set_strip_16);
 130         LOAD_FUNCPTR(png_set_tRNS_to_alpha);
 131         LOAD_FUNCPTR(png_set_write_fn);
 132         LOAD_FUNCPTR(png_read_end);
 133         LOAD_FUNCPTR(png_read_image);
 134         LOAD_FUNCPTR(png_read_info);
 135         LOAD_FUNCPTR(png_read_update_info);
 136         LOAD_FUNCPTR(png_write_end);
 137         LOAD_FUNCPTR(png_write_info);
 138         LOAD_FUNCPTR(png_write_rows);
 139
 140 #undef LOAD_FUNCPTR
 141     }
 142     return libpng_handle;
 143 }
 144
 145 static void user_error_fn(png_structp png_ptr, png_const_charp error_message)
 146 {
 147     jmp_buf *pjmpbuf;
 148
 149     /* This uses setjmp/longjmp just like the default. We can't use the
 150      * default because there's no way to access the jmp buffer in the png_struct
 151      * that works in 1.2 and 1.4 and allows us to dynamically load libpng. */
 152     WARN("PNG error: %s\n", debugstr_a(error_message));
 153     pjmpbuf = ppng_get_error_ptr(png_ptr);
 154     longjmp(*pjmpbuf, 1);
 155 }
 156
 157 static void user_warning_fn(png_structp png_ptr, png_const_charp warning_message)
 158 {
 159     WARN("PNG warning: %s\n", debugstr_a(warning_message));
 160 }
 161
 162 typedef struct {
 163     IWICBitmapDecoder IWICBitmapDecoder_iface;
 164     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 165     LONG ref;
 166     png_structp png_ptr;
 167     png_infop info_ptr;
 168     BOOL initialized;
 169     int bpp;
 170     int width, height;
 171     UINT stride;
 172     const WICPixelFormatGUID *format;
 173     BYTE *image_bits;
 174     CRITICAL_SECTION lock; /* must be held when png structures are accessed or initialized is set */
 175 } PngDecoder;
 176
 177 static inline PngDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 178 {
 179     return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapDecoder_iface);
 180 }
 181
 182 static inline PngDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 183 {
 184     return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapFrameDecode_iface);
 185 }
 186
 187 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl;
 188
 189 static HRESULT WINAPI PngDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 190     void **ppv)
 191 {
 192     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 193     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 194
 195     if (!ppv) return E_INVALIDARG;
 196
 197     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
 198     {
 199         *ppv = This;
 200     }
 201     else
 202     {
 203         *ppv = NULL;
 204         return E_NOINTERFACE;
 205     }
 206
 207     IUnknown_AddRef((IUnknown*)*ppv);
 208     return S_OK;
 209 }
 210
 211 static ULONG WINAPI PngDecoder_AddRef(IWICBitmapDecoder *iface)
 212 {
 213     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 214     ULONG ref = InterlockedIncrement(&This->ref);
 215
 216     TRACE("(%p) refcount=%u\n", iface, ref);
 217
 218     return ref;
 219 }
 220
 221 static ULONG WINAPI PngDecoder_Release(IWICBitmapDecoder *iface)
 222 {
 223     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 224     ULONG ref = InterlockedDecrement(&This->ref);
 225
 226     TRACE("(%p) refcount=%u\n", iface, ref);
 227
 228     if (ref == 0)
 229     {
 230         if (This->png_ptr)
 231             ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, NULL);
 232         This->lock.DebugInfo->Spare[0] = 0;
 233         DeleteCriticalSection(&This->lock);
 234         HeapFree(GetProcessHeap(), 0, This->image_bits);
 235         HeapFree(GetProcessHeap(), 0, This);
 236     }
 237
 238     return ref;
 239 }
 240
 241 static HRESULT WINAPI PngDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
 242     DWORD *pdwCapability)
 243 {
 244     FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
 245     return E_NOTIMPL;
 246 }
 247
 248 static void info_callback(png_structp png_ptr, png_infop info)
 249 {
 250     int color_type, bit_depth;
 251     png_bytep trans;
 252     int num_trans;
 253     png_uint_32 transparency;
 254     png_color_16p trans_values;
 255     UINT image_size;
 256     HRESULT hr = S_OK;
 257     PngDecoder *This;
 258
 259     This = (PngDecoder*) ppng_get_progressive_ptr(png_ptr);
 260
 261     /* choose a pixel format */
 262     color_type = ppng_get_color_type(This->png_ptr, This->info_ptr);
 263     bit_depth = ppng_get_bit_depth(This->png_ptr, This->info_ptr);
 264
 265     /* check for color-keyed alpha */
 266     transparency = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans, &num_trans, &trans_values);
 267
 268     if (transparency && color_type != PNG_COLOR_TYPE_PALETTE)
 269     {
 270         /* expand to RGBA */
 271         if (color_type == PNG_COLOR_TYPE_GRAY)
 272         {
 273             if (bit_depth < 8)
 274             {
 275 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 276                 ppng_set_expand_gray_1_2_4_to_8(This->png_ptr);
 277 #else
 278                 ppng_set_gray_1_2_4_to_8(This->png_ptr);
 279 #endif
 280                 bit_depth = 8;
 281             }
 282             ppng_set_gray_to_rgb(This->png_ptr);
 283         }
 284         ppng_set_tRNS_to_alpha(This->png_ptr);
 285         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
 286     }
 287
 288     switch (color_type)
 289     {
 290     case PNG_COLOR_TYPE_GRAY:
 291         This->bpp = bit_depth;
 292         switch (bit_depth)
 293         {
 294         case 1: This->format = &GUID_WICPixelFormatBlackWhite; break;
 295         case 2: This->format = &GUID_WICPixelFormat2bppGray; break;
 296         case 4: This->format = &GUID_WICPixelFormat4bppGray; break;
 297         case 8: This->format = &GUID_WICPixelFormat8bppGray; break;
 298         case 16: This->format = &GUID_WICPixelFormat16bppGray; break;
 299         default:
 300             ERR("invalid grayscale bit depth: %i\n", bit_depth);
 301             hr = E_FAIL;
 302             goto end;
 303         }
 304         break;
 305     case PNG_COLOR_TYPE_GRAY_ALPHA:
 306         /* WIC does not support grayscale alpha formats so use RGBA */
 307         ppng_set_gray_to_rgb(This->png_ptr);
 308     case PNG_COLOR_TYPE_RGB_ALPHA:
 309         This->bpp = bit_depth * 4;
 310         switch (bit_depth)
 311         {
 312         case 8:
 313             ppng_set_bgr(This->png_ptr);
 314             This->format = &GUID_WICPixelFormat32bppBGRA;
 315             break;
 316         case 16: This->format = &GUID_WICPixelFormat64bppRGBA; break;
 317         default:
 318             ERR("invalid RGBA bit depth: %i\n", bit_depth);
 319             hr = E_FAIL;
 320             goto end;
 321         }
 322         break;
 323     case PNG_COLOR_TYPE_PALETTE:
 324         This->bpp = bit_depth;
 325         switch (bit_depth)
 326         {
 327         case 1: This->format = &GUID_WICPixelFormat1bppIndexed; break;
 328         case 2: This->format = &GUID_WICPixelFormat2bppIndexed; break;
 329         case 4: This->format = &GUID_WICPixelFormat4bppIndexed; break;
 330         case 8: This->format = &GUID_WICPixelFormat8bppIndexed; break;
 331         default:
 332             ERR("invalid indexed color bit depth: %i\n", bit_depth);
 333             hr = E_FAIL;
 334             goto end;
 335         }
 336         break;
 337     case PNG_COLOR_TYPE_RGB:
 338         This->bpp = bit_depth * 3;
 339         switch (bit_depth)
 340         {
 341         case 8:
 342             ppng_set_bgr(This->png_ptr);
 343             This->format = &GUID_WICPixelFormat24bppBGR;
 344             break;
 345         case 16: This->format = &GUID_WICPixelFormat48bppRGB; break;
 346         default:
 347             ERR("invalid RGB color bit depth: %i\n", bit_depth);
 348             hr = E_FAIL;
 349             goto end;
 350         }
 351         break;
 352     default:
 353         ERR("invalid color type %i\n", color_type);
 354         hr = E_FAIL;
 355         goto end;
 356     }
 357
 358     This->width = ppng_get_image_width(This->png_ptr, This->info_ptr);
 359     This->height = ppng_get_image_height(This->png_ptr, This->info_ptr);
 360     This->stride = This->width * This->bpp;
 361     image_size = This->stride * This->height;
 362
 363     This->image_bits = HeapAlloc(GetProcessHeap(), 0, image_size);
 364     if (!This->image_bits)
 365     {
 366         hr = E_OUTOFMEMORY;
 367         goto end;
 368     }
 369
 370     ppng_read_update_info(This->png_ptr, This->info_ptr);
 371     This->initialized = TRUE;
 372
 373 end:
 374     if (FAILED(hr))
 375         ERR("PNG info parsing failed, hr=0x%08X\n", hr);
 376 }
 377
 378 static void row_callback(png_structp png_ptr, png_bytep new_row,
 379                          png_uint_32 row_num, int pass)
 380 {
 381     png_bytep old_row;
 382     PngDecoder *This;
 383
 384     This = (PngDecoder*) ppng_get_progressive_ptr(png_ptr);
 385     if (!This->initialized)
 386         return;
 387
 388     old_row = ((png_bytep)This->image_bits) + row_num*This->stride;
 389     ppng_progressive_combine_row(png_ptr, old_row, new_row);
 390 }
 391
 392 static void end_callback(png_structp png_ptr, png_infop info)
 393 {
 394 }
 395
 396 static HRESULT WINAPI PngDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 397     WICDecodeOptions cacheOptions)
 398 {
 399     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 400     LARGE_INTEGER seek;
 401     HRESULT hr=S_OK;
 402     png_bytep *row_pointers=NULL;
 403     jmp_buf jmpbuf;
 404     BYTE buffer[8096];
 405     ULONG bytesRead = 0;
 406
 407     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 408
 409     EnterCriticalSection(&This->lock);
 410
 411     /* initialize libpng */
 412     This->png_ptr = ppng_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 413     if (!This->png_ptr)
 414     {
 415         hr = E_FAIL;
 416         goto end;
 417     }
 418
 419     This->info_ptr = ppng_create_info_struct(This->png_ptr);
 420     if (!This->info_ptr)
 421     {
 422         ppng_destroy_read_struct(&This->png_ptr, NULL, NULL);
 423         This->png_ptr = NULL;
 424         hr = E_FAIL;
 425         goto end;
 426     }
 427
 428     /* set up setjmp/longjmp error handling */
 429     if (setjmp(jmpbuf))
 430     {
 431         ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, NULL);
 432         HeapFree(GetProcessHeap(), 0, row_pointers);
 433         This->png_ptr = NULL;
 434         hr = E_FAIL;
 435         goto end;
 436     }
 437     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
 438
 439     /* seek to the start of the stream */
 440     seek.QuadPart = 0;
 441     hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 442     if (FAILED(hr)) goto end;
 443
 444     /* set up progressive loading */
 445     ppng_set_progressive_read_fn(This->png_ptr, (void*)This,
 446         info_callback, row_callback, end_callback);
 447
 448     do
 449     {
 450         hr = IStream_Read(pIStream, buffer, sizeof(buffer), &bytesRead);
 451         if (SUCCEEDED(hr))
 452             ppng_process_data(This->png_ptr, This->info_ptr, buffer, bytesRead);
 453     } while (bytesRead == sizeof(buffer));
 454     if (hr == S_FALSE)
 455         hr = S_OK;
 456     if (FAILED(hr))
 457         ERR("reading PNG file failed, error 0x%08X\n", hr);
 458     if (!This->initialized)
 459         hr = E_FAIL;
 460
 461 end:
 462
 463     LeaveCriticalSection(&This->lock);
 464
 465     return hr;
 466 }
 467
 468 static HRESULT WINAPI PngDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 469     GUID *pguidContainerFormat)
 470 {
 471     memcpy(pguidContainerFormat, &GUID_ContainerFormatPng, sizeof(GUID));
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI PngDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 476     IWICBitmapDecoderInfo **ppIDecoderInfo)
 477 {
 478     FIXME("(%p,%p): stub\n", iface, ppIDecoderInfo);
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI PngDecoder_CopyPalette(IWICBitmapDecoder *iface,
 483     IWICPalette *pIPalette)
 484 {
 485     FIXME("(%p,%p): stub\n", iface, pIPalette);
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT WINAPI PngDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 490     IWICMetadataQueryReader **ppIMetadataQueryReader)
 491 {
 492     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI PngDecoder_GetPreview(IWICBitmapDecoder *iface,
 497     IWICBitmapSource **ppIBitmapSource)
 498 {
 499     FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI PngDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 504     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 505 {
 506     FIXME("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI PngDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 511     IWICBitmapSource **ppIThumbnail)
 512 {
 513     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 514     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 515 }
 516
 517 static HRESULT WINAPI PngDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 518     UINT *pCount)
 519 {
 520     *pCount = 1;
 521     return S_OK;
 522 }
 523
 524 static HRESULT WINAPI PngDecoder_GetFrame(IWICBitmapDecoder *iface,
 525     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 526 {
 527     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 528     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 529
 530     if (!This->initialized) return WINCODEC_ERR_NOTINITIALIZED;
 531
 532     if (index != 0) return E_INVALIDARG;
 533
 534     IWICBitmapDecoder_AddRef(iface);
 535
 536     *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
 537
 538     return S_OK;
 539 }
 540
 541 static const IWICBitmapDecoderVtbl PngDecoder_Vtbl = {
 542     PngDecoder_QueryInterface,
 543     PngDecoder_AddRef,
 544     PngDecoder_Release,
 545     PngDecoder_QueryCapability,
 546     PngDecoder_Initialize,
 547     PngDecoder_GetContainerFormat,
 548     PngDecoder_GetDecoderInfo,
 549     PngDecoder_CopyPalette,
 550     PngDecoder_GetMetadataQueryReader,
 551     PngDecoder_GetPreview,
 552     PngDecoder_GetColorContexts,
 553     PngDecoder_GetThumbnail,
 554     PngDecoder_GetFrameCount,
 555     PngDecoder_GetFrame
 556 };
 557
 558 static HRESULT WINAPI PngDecoder_Frame_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
 559     void **ppv)
 560 {
 561     if (!ppv) return E_INVALIDARG;
 562
 563     if (IsEqualIID(&IID_IUnknown, iid) ||
 564         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 565         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
 566     {
 567         *ppv = iface;
 568     }
 569     else
 570     {
 571         *ppv = NULL;
 572         return E_NOINTERFACE;
 573     }
 574
 575     IUnknown_AddRef((IUnknown*)*ppv);
 576     return S_OK;
 577 }
 578
 579 static ULONG WINAPI PngDecoder_Frame_AddRef(IWICBitmapFrameDecode *iface)
 580 {
 581     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 582     return IUnknown_AddRef((IUnknown*)This);
 583 }
 584
 585 static ULONG WINAPI PngDecoder_Frame_Release(IWICBitmapFrameDecode *iface)
 586 {
 587     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 588     return IUnknown_Release((IUnknown*)This);
 589 }
 590
 591 static HRESULT WINAPI PngDecoder_Frame_GetSize(IWICBitmapFrameDecode *iface,
 592     UINT *puiWidth, UINT *puiHeight)
 593 {
 594     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 595     *puiWidth = This->width;
 596     *puiHeight = This->height;
 597     TRACE("(%p)->(%u,%u)\n", iface, *puiWidth, *puiHeight);
 598     return S_OK;
 599 }
 600
 601 static HRESULT WINAPI PngDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode *iface,
 602     WICPixelFormatGUID *pPixelFormat)
 603 {
 604     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 605     TRACE("(%p,%p)\n", iface, pPixelFormat);
 606
 607     memcpy(pPixelFormat, This->format, sizeof(GUID));
 608
 609     return S_OK;
 610 }
 611
 612 static HRESULT WINAPI PngDecoder_Frame_GetResolution(IWICBitmapFrameDecode *iface,
 613     double *pDpiX, double *pDpiY)
 614 {
 615     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 616     png_uint_32 ret, xres, yres;
 617     int unit_type;
 618
 619     EnterCriticalSection(&This->lock);
 620
 621     ret = ppng_get_pHYs(This->png_ptr, This->info_ptr, &xres, &yres, &unit_type);
 622
 623     if (ret && unit_type == PNG_RESOLUTION_METER)
 624     {
 625         *pDpiX = xres * 0.0254;
 626         *pDpiY = yres * 0.0254;
 627     }
 628     else
 629     {
 630         WARN("no pHYs block present\n");
 631         *pDpiX = *pDpiY = 96.0;
 632     }
 633
 634     LeaveCriticalSection(&This->lock);
 635
 636     TRACE("(%p)->(%0.2f,%0.2f)\n", iface, *pDpiX, *pDpiY);
 637
 638     return S_OK;
 639 }
 640
 641 static HRESULT WINAPI PngDecoder_Frame_CopyPalette(IWICBitmapFrameDecode *iface,
 642     IWICPalette *pIPalette)
 643 {
 644     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 645     png_uint_32 ret;
 646     png_colorp png_palette;
 647     int num_palette;
 648     WICColor palette[256];
 649     png_bytep trans;
 650     int num_trans;
 651     png_color_16p trans_values;
 652     int i;
 653     HRESULT hr=S_OK;
 654
 655     TRACE("(%p,%p)\n", iface, pIPalette);
 656
 657     EnterCriticalSection(&This->lock);
 658
 659     ret = ppng_get_PLTE(This->png_ptr, This->info_ptr, &png_palette, &num_palette);
 660     if (!ret)
 661     {
 662         hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
 663         goto end;
 664     }
 665
 666     if (num_palette > 256)
 667     {
 668         ERR("palette has %i colors?!\n", num_palette);
 669         hr = E_FAIL;
 670         goto end;
 671     }
 672
 673     for (i=0; i<num_palette; i++)
 674     {
 675         palette[i] = (0xff000000|
 676                       png_palette[i].red << 16|
 677                       png_palette[i].green << 8|
 678                       png_palette[i].blue);
 679     }
 680
 681     ret = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans, &num_trans, &trans_values);
 682     if (ret)
 683     {
 684         for (i=0; i<num_trans; i++)
 685         {
 686             palette[trans[i]] = 0x00000000;
 687         }
 688     }
 689
 690 end:
 691
 692     LeaveCriticalSection(&This->lock);
 693
 694     if (SUCCEEDED(hr))
 695         hr = IWICPalette_InitializeCustom(pIPalette, palette, num_palette);
 696
 697     return hr;
 698 }
 699
 700 static HRESULT WINAPI PngDecoder_Frame_CopyPixels(IWICBitmapFrameDecode *iface,
 701     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 702 {
 703     PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 704     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
 705
 706     return copy_pixels(This->bpp, This->image_bits,
 707         This->width, This->height, This->stride,
 708         prc, cbStride, cbBufferSize, pbBuffer);
 709 }
 710
 711 static HRESULT WINAPI PngDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
 712     IWICMetadataQueryReader **ppIMetadataQueryReader)
 713 {
 714     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 715     return E_NOTIMPL;
 716 }
 717
 718 static HRESULT WINAPI PngDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode *iface,
 719     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 720 {
 721     FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT WINAPI PngDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode *iface,
 726     IWICBitmapSource **ppIThumbnail)
 727 {
 728     FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
 729     return E_NOTIMPL;
 730 }
 731
 732 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl = {
 733     PngDecoder_Frame_QueryInterface,
 734     PngDecoder_Frame_AddRef,
 735     PngDecoder_Frame_Release,
 736     PngDecoder_Frame_GetSize,
 737     PngDecoder_Frame_GetPixelFormat,
 738     PngDecoder_Frame_GetResolution,
 739     PngDecoder_Frame_CopyPalette,
 740     PngDecoder_Frame_CopyPixels,
 741     PngDecoder_Frame_GetMetadataQueryReader,
 742     PngDecoder_Frame_GetColorContexts,
 743     PngDecoder_Frame_GetThumbnail
 744 };
 745
 746 HRESULT PngDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
 747 {
 748     PngDecoder *This;
 749     HRESULT ret;
 750
 751     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
 752
 753     *ppv = NULL;
 754
 755     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 756
 757     if (!libpng_handle && !load_libpng())
 758     {
 759         ERR("Failed reading PNG because unable to find %s\n",SONAME_LIBPNG);
 760         return E_FAIL;
 761     }
 762
 763     This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngDecoder));
 764     if (!This) return E_OUTOFMEMORY;
 765
 766     This->IWICBitmapDecoder_iface.lpVtbl = &PngDecoder_Vtbl;
 767     This->IWICBitmapFrameDecode_iface.lpVtbl = &PngDecoder_FrameVtbl;
 768     This->ref = 1;
 769     This->png_ptr = NULL;
 770     This->info_ptr = NULL;
 771     This->initialized = FALSE;
 772     This->image_bits = NULL;
 773     InitializeCriticalSection(&This->lock);
 774     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngDecoder.lock");
 775
 776     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
 777     IUnknown_Release((IUnknown*)This);
 778
 779     return ret;
 780 }
 781
 782 struct png_pixelformat {
 783     const WICPixelFormatGUID *guid;
 784     UINT bpp;
 785     int bit_depth;
 786     int color_type;
 787     BOOL remove_filler;
 788     BOOL swap_rgb;
 789 };
 790
 791 static const struct png_pixelformat formats[] = {
 792     {&GUID_WICPixelFormat24bppBGR, 24, 8, PNG_COLOR_TYPE_RGB, 0, 1},
 793     {&GUID_WICPixelFormatBlackWhite, 1, 1, PNG_COLOR_TYPE_GRAY, 0, 0},
 794     {&GUID_WICPixelFormat2bppGray, 2, 2, PNG_COLOR_TYPE_GRAY, 0, 0},
 795     {&GUID_WICPixelFormat4bppGray, 4, 4, PNG_COLOR_TYPE_GRAY, 0, 0},
 796     {&GUID_WICPixelFormat8bppGray, 8, 8, PNG_COLOR_TYPE_GRAY, 0, 0},
 797     {&GUID_WICPixelFormat16bppGray, 16, 16, PNG_COLOR_TYPE_GRAY, 0, 0},
 798     {&GUID_WICPixelFormat32bppBGR, 32, 8, PNG_COLOR_TYPE_RGB, 1, 1},
 799     {&GUID_WICPixelFormat32bppBGRA, 32, 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 1},
 800     {&GUID_WICPixelFormat48bppRGB, 48, 16, PNG_COLOR_TYPE_RGB, 0, 0},
 801     {&GUID_WICPixelFormat64bppRGBA, 64, 16, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0},
 802     {NULL},
 803 };
 804
 805 typedef struct PngEncoder {
 806     const IWICBitmapEncoderVtbl *lpVtbl;
 807     const IWICBitmapFrameEncodeVtbl *lpFrameVtbl;
 808     LONG ref;
 809     IStream *stream;
 810     png_structp png_ptr;
 811     png_infop info_ptr;
 812     UINT frame_count;
 813     BOOL frame_initialized;
 814     const struct png_pixelformat *format;
 815     BOOL info_written;
 816     UINT width, height;
 817     double xres, yres;
 818     UINT lines_written;
 819     BOOL frame_committed;
 820     BOOL committed;
 821     CRITICAL_SECTION lock;
 822 } PngEncoder;
 823
 824 static inline PngEncoder *encoder_from_frame(IWICBitmapFrameEncode *iface)
 825 {
 826     return CONTAINING_RECORD(iface, PngEncoder, lpFrameVtbl);
 827 }
 828
 829 static HRESULT WINAPI PngFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
 830     void **ppv)
 831 {
 832     PngEncoder *This = encoder_from_frame(iface);
 833     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 834
 835     if (!ppv) return E_INVALIDARG;
 836
 837     if (IsEqualIID(&IID_IUnknown, iid) ||
 838         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
 839     {
 840         *ppv = &This->lpFrameVtbl;
 841     }
 842     else
 843     {
 844         *ppv = NULL;
 845         return E_NOINTERFACE;
 846     }
 847
 848     IUnknown_AddRef((IUnknown*)*ppv);
 849     return S_OK;
 850 }
 851
 852 static ULONG WINAPI PngFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
 853 {
 854     PngEncoder *This = encoder_from_frame(iface);
 855     return IUnknown_AddRef((IUnknown*)This);
 856 }
 857
 858 static ULONG WINAPI PngFrameEncode_Release(IWICBitmapFrameEncode *iface)
 859 {
 860     PngEncoder *This = encoder_from_frame(iface);
 861     return IUnknown_Release((IUnknown*)This);
 862 }
 863
 864 static HRESULT WINAPI PngFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
 865     IPropertyBag2 *pIEncoderOptions)
 866 {
 867     PngEncoder *This = encoder_from_frame(iface);
 868     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
 869
 870     EnterCriticalSection(&This->lock);
 871
 872     if (This->frame_initialized)
 873     {
 874         LeaveCriticalSection(&This->lock);
 875         return WINCODEC_ERR_WRONGSTATE;
 876     }
 877
 878     This->frame_initialized = TRUE;
 879
 880     LeaveCriticalSection(&This->lock);
 881
 882     return S_OK;
 883 }
 884
 885 static HRESULT WINAPI PngFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
 886     UINT uiWidth, UINT uiHeight)
 887 {
 888     PngEncoder *This = encoder_from_frame(iface);
 889     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
 890
 891     EnterCriticalSection(&This->lock);
 892
 893     if (!This->frame_initialized || This->info_written)
 894     {
 895         LeaveCriticalSection(&This->lock);
 896         return WINCODEC_ERR_WRONGSTATE;
 897     }
 898
 899     This->width = uiWidth;
 900     This->height = uiHeight;
 901
 902     LeaveCriticalSection(&This->lock);
 903
 904     return S_OK;
 905 }
 906
 907 static HRESULT WINAPI PngFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
 908     double dpiX, double dpiY)
 909 {
 910     PngEncoder *This = encoder_from_frame(iface);
 911     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
 912
 913     EnterCriticalSection(&This->lock);
 914
 915     if (!This->frame_initialized || This->info_written)
 916     {
 917         LeaveCriticalSection(&This->lock);
 918         return WINCODEC_ERR_WRONGSTATE;
 919     }
 920
 921     This->xres = dpiX;
 922     This->yres = dpiY;
 923
 924     LeaveCriticalSection(&This->lock);
 925
 926     return S_OK;
 927 }
 928
 929 static HRESULT WINAPI PngFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
 930     WICPixelFormatGUID *pPixelFormat)
 931 {
 932     PngEncoder *This = encoder_from_frame(iface);
 933     int i;
 934     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
 935
 936     EnterCriticalSection(&This->lock);
 937
 938     if (!This->frame_initialized || This->info_written)
 939     {
 940         LeaveCriticalSection(&This->lock);
 941         return WINCODEC_ERR_WRONGSTATE;
 942     }
 943
 944     for (i=0; formats[i].guid; i++)
 945     {
 946         if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
 947             break;
 948     }
 949
 950     if (!formats[i].guid) i = 0;
 951
 952     This->format = &formats[i];
 953     memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
 954
 955     LeaveCriticalSection(&This->lock);
 956
 957     return S_OK;
 958 }
 959
 960 static HRESULT WINAPI PngFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
 961     UINT cCount, IWICColorContext **ppIColorContext)
 962 {
 963     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI PngFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
 968     IWICPalette *pIPalette)
 969 {
 970     FIXME("(%p,%p): stub\n", iface, pIPalette);
 971     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 972 }
 973
 974 static HRESULT WINAPI PngFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
 975     IWICBitmapSource *pIThumbnail)
 976 {
 977     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
 978     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 979 }
 980
 981 static HRESULT WINAPI PngFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
 982     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
 983 {
 984     PngEncoder *This = encoder_from_frame(iface);
 985     png_byte **row_pointers=NULL;
 986     UINT i;
 987     jmp_buf jmpbuf;
 988     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
 989
 990     EnterCriticalSection(&This->lock);
 991
 992     if (!This->frame_initialized || !This->width || !This->height || !This->format)
 993     {
 994         LeaveCriticalSection(&This->lock);
 995         return WINCODEC_ERR_WRONGSTATE;
 996     }
 997
 998     if (lineCount == 0 || lineCount + This->lines_written > This->height)
 999     {
1000         LeaveCriticalSection(&This->lock);
1001         return E_INVALIDARG;
1002     }
1003
1004     /* set up setjmp/longjmp error handling */
1005     if (setjmp(jmpbuf))
1006     {
1007         LeaveCriticalSection(&This->lock);
1008         HeapFree(GetProcessHeap(), 0, row_pointers);
1009         return E_FAIL;
1010     }
1011     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
1012
1013     if (!This->info_written)
1014     {
1015         ppng_set_IHDR(This->png_ptr, This->info_ptr, This->width, This->height,
1016             This->format->bit_depth, This->format->color_type, PNG_INTERLACE_NONE,
1017             PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1018
1019         if (This->xres != 0.0 && This->yres != 0.0)
1020         {
1021             ppng_set_pHYs(This->png_ptr, This->info_ptr, (This->xres+0.0127) / 0.0254,
1022                 (This->yres+0.0127) / 0.0254, PNG_RESOLUTION_METER);
1023         }
1024
1025         ppng_write_info(This->png_ptr, This->info_ptr);
1026
1027         if (This->format->remove_filler)
1028             ppng_set_filler(This->png_ptr, 0, PNG_FILLER_AFTER);
1029
1030         if (This->format->swap_rgb)
1031             ppng_set_bgr(This->png_ptr);
1032
1033         This->info_written = TRUE;
1034     }
1035
1036     row_pointers = HeapAlloc(GetProcessHeap(), 0, lineCount * sizeof(png_byte*));
1037     if (!row_pointers)
1038     {
1039         LeaveCriticalSection(&This->lock);
1040         return E_OUTOFMEMORY;
1041     }
1042
1043     for (i=0; i<lineCount; i++)
1044         row_pointers[i] = pbPixels + cbStride * i;
1045
1046     ppng_write_rows(This->png_ptr, row_pointers, lineCount);
1047     This->lines_written += lineCount;
1048
1049     LeaveCriticalSection(&This->lock);
1050
1051     HeapFree(GetProcessHeap(), 0, row_pointers);
1052
1053     return S_OK;
1054 }
1055
1056 static HRESULT WINAPI PngFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
1057     IWICBitmapSource *pIBitmapSource, WICRect *prc)
1058 {
1059     PngEncoder *This = encoder_from_frame(iface);
1060     HRESULT hr;
1061     WICRect rc;
1062     WICPixelFormatGUID guid;
1063     UINT stride;
1064     BYTE *pixeldata;
1065     TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
1066
1067     if (!This->frame_initialized || !This->width || !This->height)
1068         return WINCODEC_ERR_WRONGSTATE;
1069
1070     if (!This->format)
1071     {
1072         hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1073         if (FAILED(hr)) return hr;
1074         hr = IWICBitmapFrameEncode_SetPixelFormat(iface, &guid);
1075         if (FAILED(hr)) return hr;
1076     }
1077
1078     hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1079     if (FAILED(hr)) return hr;
1080     if (memcmp(&guid, This->format->guid, sizeof(GUID)) != 0)
1081     {
1082         /* FIXME: should use WICConvertBitmapSource to convert */
1083         ERR("format %s unsupported\n", debugstr_guid(&guid));
1084         return E_FAIL;
1085     }
1086
1087     if (This->xres == 0.0 || This->yres == 0.0)
1088     {
1089         double xres, yres;
1090         hr = IWICBitmapSource_GetResolution(pIBitmapSource, &xres, &yres);
1091         if (FAILED(hr)) return hr;
1092         hr = IWICBitmapFrameEncode_SetResolution(iface, xres, yres);
1093         if (FAILED(hr)) return hr;
1094     }
1095
1096     if (!prc)
1097     {
1098         UINT width, height;
1099         hr = IWICBitmapSource_GetSize(pIBitmapSource, &width, &height);
1100         if (FAILED(hr)) return hr;
1101         rc.X = 0;
1102         rc.Y = 0;
1103         rc.Width = width;
1104         rc.Height = height;
1105         prc = &rc;
1106     }
1107
1108     if (prc->Width != This->width) return E_INVALIDARG;
1109
1110     stride = (This->format->bpp * This->width + 7)/8;
1111
1112     pixeldata = HeapAlloc(GetProcessHeap(), 0, stride * prc->Height);
1113     if (!pixeldata) return E_OUTOFMEMORY;
1114
1115     hr = IWICBitmapSource_CopyPixels(pIBitmapSource, prc, stride,
1116         stride*prc->Height, pixeldata);
1117
1118     if (SUCCEEDED(hr))
1119     {
1120         hr = IWICBitmapFrameEncode_WritePixels(iface, prc->Height, stride,
1121             stride*prc->Height, pixeldata);
1122     }
1123
1124     HeapFree(GetProcessHeap(), 0, pixeldata);
1125
1126     return hr;
1127 }
1128
1129 static HRESULT WINAPI PngFrameEncode_Commit(IWICBitmapFrameEncode *iface)
1130 {
1131     PngEncoder *This = encoder_from_frame(iface);
1132     jmp_buf jmpbuf;
1133     TRACE("(%p)\n", iface);
1134
1135     EnterCriticalSection(&This->lock);
1136
1137     if (!This->info_written || This->lines_written != This->height || This->frame_committed)
1138     {
1139         LeaveCriticalSection(&This->lock);
1140         return WINCODEC_ERR_WRONGSTATE;
1141     }
1142
1143     /* set up setjmp/longjmp error handling */
1144     if (setjmp(jmpbuf))
1145     {
1146         LeaveCriticalSection(&This->lock);
1147         return E_FAIL;
1148     }
1149     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
1150
1151     ppng_write_end(This->png_ptr, This->info_ptr);
1152
1153     This->frame_committed = TRUE;
1154
1155     LeaveCriticalSection(&This->lock);
1156
1157     return S_OK;
1158 }
1159
1160 static HRESULT WINAPI PngFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
1161     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1162 {
1163     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
1164     return E_NOTIMPL;
1165 }
1166
1167 static const IWICBitmapFrameEncodeVtbl PngEncoder_FrameVtbl = {
1168     PngFrameEncode_QueryInterface,
1169     PngFrameEncode_AddRef,
1170     PngFrameEncode_Release,
1171     PngFrameEncode_Initialize,
1172     PngFrameEncode_SetSize,
1173     PngFrameEncode_SetResolution,
1174     PngFrameEncode_SetPixelFormat,
1175     PngFrameEncode_SetColorContexts,
1176     PngFrameEncode_SetPalette,
1177     PngFrameEncode_SetThumbnail,
1178     PngFrameEncode_WritePixels,
1179     PngFrameEncode_WriteSource,
1180     PngFrameEncode_Commit,
1181     PngFrameEncode_GetMetadataQueryWriter
1182 };
1183
1184 static HRESULT WINAPI PngEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
1185     void **ppv)
1186 {
1187     PngEncoder *This = (PngEncoder*)iface;
1188     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1189
1190     if (!ppv) return E_INVALIDARG;
1191
1192     if (IsEqualIID(&IID_IUnknown, iid) ||
1193         IsEqualIID(&IID_IWICBitmapEncoder, iid))
1194     {
1195         *ppv = This;
1196     }
1197     else
1198     {
1199         *ppv = NULL;
1200         return E_NOINTERFACE;
1201     }
1202
1203     IUnknown_AddRef((IUnknown*)*ppv);
1204     return S_OK;
1205 }
1206
1207 static ULONG WINAPI PngEncoder_AddRef(IWICBitmapEncoder *iface)
1208 {
1209     PngEncoder *This = (PngEncoder*)iface;
1210     ULONG ref = InterlockedIncrement(&This->ref);
1211
1212     TRACE("(%p) refcount=%u\n", iface, ref);
1213
1214     return ref;
1215 }
1216
1217 static ULONG WINAPI PngEncoder_Release(IWICBitmapEncoder *iface)
1218 {
1219     PngEncoder *This = (PngEncoder*)iface;
1220     ULONG ref = InterlockedDecrement(&This->ref);
1221
1222     TRACE("(%p) refcount=%u\n", iface, ref);
1223
1224     if (ref == 0)
1225     {
1226         This->lock.DebugInfo->Spare[0] = 0;
1227         DeleteCriticalSection(&This->lock);
1228         if (This->png_ptr)
1229             ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1230         if (This->stream)
1231             IStream_Release(This->stream);
1232         HeapFree(GetProcessHeap(), 0, This);
1233     }
1234
1235     return ref;
1236 }
1237
1238 static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1239 {
1240     PngEncoder *This = ppng_get_io_ptr(png_ptr);
1241     HRESULT hr;
1242     ULONG byteswritten;
1243
1244     hr = IStream_Write(This->stream, data, length, &byteswritten);
1245     if (FAILED(hr) || byteswritten != length)
1246     {
1247         ppng_error(png_ptr, "failed writing data");
1248     }
1249 }
1250
1251 static void user_flush(png_structp png_ptr)
1252 {
1253 }
1254
1255 static HRESULT WINAPI PngEncoder_Initialize(IWICBitmapEncoder *iface,
1256     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
1257 {
1258     PngEncoder *This = (PngEncoder*)iface;
1259     jmp_buf jmpbuf;
1260
1261     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
1262
1263     EnterCriticalSection(&This->lock);
1264
1265     if (This->png_ptr)
1266     {
1267         LeaveCriticalSection(&This->lock);
1268         return WINCODEC_ERR_WRONGSTATE;
1269     }
1270
1271     /* initialize libpng */
1272     This->png_ptr = ppng_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1273     if (!This->png_ptr)
1274     {
1275         LeaveCriticalSection(&This->lock);
1276         return E_FAIL;
1277     }
1278
1279     This->info_ptr = ppng_create_info_struct(This->png_ptr);
1280     if (!This->info_ptr)
1281     {
1282         ppng_destroy_write_struct(&This->png_ptr, NULL);
1283         This->png_ptr = NULL;
1284         LeaveCriticalSection(&This->lock);
1285         return E_FAIL;
1286     }
1287
1288     IStream_AddRef(pIStream);
1289     This->stream = pIStream;
1290
1291     /* set up setjmp/longjmp error handling */
1292     if (setjmp(jmpbuf))
1293     {
1294         ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1295         This->png_ptr = NULL;
1296         IStream_Release(This->stream);
1297         This->stream = NULL;
1298         LeaveCriticalSection(&This->lock);
1299         return E_FAIL;
1300     }
1301     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
1302
1303     /* set up custom i/o handling */
1304     ppng_set_write_fn(This->png_ptr, This, user_write_data, user_flush);
1305
1306     LeaveCriticalSection(&This->lock);
1307
1308     return S_OK;
1309 }
1310
1311 static HRESULT WINAPI PngEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
1312     GUID *pguidContainerFormat)
1313 {
1314     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
1315     return E_NOTIMPL;
1316 }
1317
1318 static HRESULT WINAPI PngEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
1319     IWICBitmapEncoderInfo **ppIEncoderInfo)
1320 {
1321     FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
1322     return E_NOTIMPL;
1323 }
1324
1325 static HRESULT WINAPI PngEncoder_SetColorContexts(IWICBitmapEncoder *iface,
1326     UINT cCount, IWICColorContext **ppIColorContext)
1327 {
1328     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT WINAPI PngEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
1333 {
1334     TRACE("(%p,%p)\n", iface, pIPalette);
1335     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1336 }
1337
1338 static HRESULT WINAPI PngEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
1339 {
1340     TRACE("(%p,%p)\n", iface, pIThumbnail);
1341     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1342 }
1343
1344 static HRESULT WINAPI PngEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
1345 {
1346     TRACE("(%p,%p)\n", iface, pIPreview);
1347     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1348 }
1349
1350 static HRESULT WINAPI PngEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
1351     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
1352 {
1353     PngEncoder *This = (PngEncoder*)iface;
1354     HRESULT hr;
1355     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
1356
1357     EnterCriticalSection(&This->lock);
1358
1359     if (This->frame_count != 0)
1360     {
1361         LeaveCriticalSection(&This->lock);
1362         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1363     }
1364
1365     if (!This->stream)
1366     {
1367         LeaveCriticalSection(&This->lock);
1368         return WINCODEC_ERR_NOTINITIALIZED;
1369     }
1370
1371     hr = CreatePropertyBag2(ppIEncoderOptions);
1372     if (FAILED(hr))
1373     {
1374         LeaveCriticalSection(&This->lock);
1375         return hr;
1376     }
1377
1378     This->frame_count = 1;
1379
1380     LeaveCriticalSection(&This->lock);
1381
1382     IWICBitmapEncoder_AddRef(iface);
1383     *ppIFrameEncode = (IWICBitmapFrameEncode*)&This->lpFrameVtbl;
1384
1385     return S_OK;
1386 }
1387
1388 static HRESULT WINAPI PngEncoder_Commit(IWICBitmapEncoder *iface)
1389 {
1390     PngEncoder *This = (PngEncoder*)iface;
1391     TRACE("(%p)\n", iface);
1392
1393     EnterCriticalSection(&This->lock);
1394
1395     if (!This->frame_committed || This->committed)
1396     {
1397         LeaveCriticalSection(&This->lock);
1398         return WINCODEC_ERR_WRONGSTATE;
1399     }
1400
1401     This->committed = TRUE;
1402
1403     LeaveCriticalSection(&This->lock);
1404
1405     return S_OK;
1406 }
1407
1408 static HRESULT WINAPI PngEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
1409     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1410 {
1411     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
1412     return E_NOTIMPL;
1413 }
1414
1415 static const IWICBitmapEncoderVtbl PngEncoder_Vtbl = {
1416     PngEncoder_QueryInterface,
1417     PngEncoder_AddRef,
1418     PngEncoder_Release,
1419     PngEncoder_Initialize,
1420     PngEncoder_GetContainerFormat,
1421     PngEncoder_GetEncoderInfo,
1422     PngEncoder_SetColorContexts,
1423     PngEncoder_SetPalette,
1424     PngEncoder_SetThumbnail,
1425     PngEncoder_SetPreview,
1426     PngEncoder_CreateNewFrame,
1427     PngEncoder_Commit,
1428     PngEncoder_GetMetadataQueryWriter
1429 };
1430
1431 HRESULT PngEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1432 {
1433     PngEncoder *This;
1434     HRESULT ret;
1435
1436     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1437
1438     *ppv = NULL;
1439
1440     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1441
1442     if (!libpng_handle && !load_libpng())
1443     {
1444         ERR("Failed writing PNG because unable to find %s\n",SONAME_LIBPNG);
1445         return E_FAIL;
1446     }
1447
1448     This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngEncoder));
1449     if (!This) return E_OUTOFMEMORY;
1450
1451     This->lpVtbl = &PngEncoder_Vtbl;
1452     This->lpFrameVtbl = &PngEncoder_FrameVtbl;
1453     This->ref = 1;
1454     This->png_ptr = NULL;
1455     This->info_ptr = NULL;
1456     This->stream = NULL;
1457     This->frame_count = 0;
1458     This->frame_initialized = FALSE;
1459     This->format = NULL;
1460     This->info_written = FALSE;
1461     This->width = 0;
1462     This->height = 0;
1463     This->xres = 0.0;
1464     This->yres = 0.0;
1465     This->lines_written = 0;
1466     This->frame_committed = FALSE;
1467     This->committed = FALSE;
1468     InitializeCriticalSection(&This->lock);
1469     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngEncoder.lock");
1470
1471     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1472     IUnknown_Release((IUnknown*)This);
1473
1474     return ret;
1475 }
1476
1477 #else /* !HAVE_PNG_H */
1478
1479 HRESULT PngDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1480 {
1481     ERR("Trying to load PNG picture, but PNG support is not compiled in.\n");
1482     return E_FAIL;
1483 }
1484
1485 HRESULT PngEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1486 {
1487     ERR("Trying to save PNG picture, but PNG support is not compiled in.\n");
1488     return E_FAIL;
1489 }
1490
1491 #endif