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_PLTE);
  60 MAKE_FUNCPTR(png_get_tRNS);
  61 MAKE_FUNCPTR(png_set_bgr);
  62 MAKE_FUNCPTR(png_set_error_fn);
  63 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
  64 MAKE_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
  65 #else
  66 MAKE_FUNCPTR(png_set_gray_1_2_4_to_8);
  67 #endif
  68 MAKE_FUNCPTR(png_set_filler);
  69 MAKE_FUNCPTR(png_set_gray_to_rgb);
  70 MAKE_FUNCPTR(png_set_IHDR);
  71 MAKE_FUNCPTR(png_set_pHYs);
  72 MAKE_FUNCPTR(png_set_read_fn);
  73 MAKE_FUNCPTR(png_set_strip_16);
  74 MAKE_FUNCPTR(png_set_tRNS_to_alpha);
  75 MAKE_FUNCPTR(png_set_write_fn);
  76 MAKE_FUNCPTR(png_read_end);
  77 MAKE_FUNCPTR(png_read_image);
  78 MAKE_FUNCPTR(png_read_info);
  79 MAKE_FUNCPTR(png_write_end);
  80 MAKE_FUNCPTR(png_write_info);
  81 MAKE_FUNCPTR(png_write_rows);
  82 #undef MAKE_FUNCPTR
  83
  84 static void *load_libpng(void)
  85 {
  86     if((libpng_handle = wine_dlopen(SONAME_LIBPNG, RTLD_NOW, NULL, 0)) != NULL) {
  87
  88 #define LOAD_FUNCPTR(f) \
  89     if((p##f = wine_dlsym(libpng_handle, #f, NULL, 0)) == NULL) { \
  90         libpng_handle = NULL; \
  91         return NULL; \
  92     }
  93         LOAD_FUNCPTR(png_create_read_struct);
  94         LOAD_FUNCPTR(png_create_info_struct);
  95         LOAD_FUNCPTR(png_create_write_struct);
  96         LOAD_FUNCPTR(png_destroy_read_struct);
  97         LOAD_FUNCPTR(png_destroy_write_struct);
  98         LOAD_FUNCPTR(png_error);
  99         LOAD_FUNCPTR(png_get_bit_depth);
 100         LOAD_FUNCPTR(png_get_color_type);
 101         LOAD_FUNCPTR(png_get_error_ptr);
 102         LOAD_FUNCPTR(png_get_image_height);
 103         LOAD_FUNCPTR(png_get_image_width);
 104         LOAD_FUNCPTR(png_get_io_ptr);
 105         LOAD_FUNCPTR(png_get_pHYs);
 106         LOAD_FUNCPTR(png_get_PLTE);
 107         LOAD_FUNCPTR(png_get_tRNS);
 108         LOAD_FUNCPTR(png_set_bgr);
 109         LOAD_FUNCPTR(png_set_error_fn);
 110 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 111         LOAD_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
 112 #else
 113         LOAD_FUNCPTR(png_set_gray_1_2_4_to_8);
 114 #endif
 115         LOAD_FUNCPTR(png_set_filler);
 116         LOAD_FUNCPTR(png_set_gray_to_rgb);
 117         LOAD_FUNCPTR(png_set_IHDR);
 118         LOAD_FUNCPTR(png_set_pHYs);
 119         LOAD_FUNCPTR(png_set_read_fn);
 120         LOAD_FUNCPTR(png_set_strip_16);
 121         LOAD_FUNCPTR(png_set_tRNS_to_alpha);
 122         LOAD_FUNCPTR(png_set_write_fn);
 123         LOAD_FUNCPTR(png_read_end);
 124         LOAD_FUNCPTR(png_read_image);
 125         LOAD_FUNCPTR(png_read_info);
 126         LOAD_FUNCPTR(png_write_end);
 127         LOAD_FUNCPTR(png_write_info);
 128         LOAD_FUNCPTR(png_write_rows);
 129
 130 #undef LOAD_FUNCPTR
 131     }
 132     return libpng_handle;
 133 }
 134
 135 static void user_error_fn(png_structp png_ptr, png_const_charp error_message)
 136 {
 137     jmp_buf *pjmpbuf;
 138
 139     /* This uses setjmp/longjmp just like the default. We can't use the
 140      * default because there's no way to access the jmp buffer in the png_struct
 141      * that works in 1.2 and 1.4 and allows us to dynamically load libpng. */
 142     WARN("PNG error: %s\n", debugstr_a(error_message));
 143     pjmpbuf = ppng_get_error_ptr(png_ptr);
 144     longjmp(*pjmpbuf, 1);
 145 }
 146
 147 static void user_warning_fn(png_structp png_ptr, png_const_charp warning_message)
 148 {
 149     WARN("PNG warning: %s\n", debugstr_a(warning_message));
 150 }
 151
 152 typedef struct {
 153     IWICBitmapDecoder IWICBitmapDecoder_iface;
 154     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 155     LONG ref;
 156     png_structp png_ptr;
 157     png_infop info_ptr;
 158     png_infop end_info;
 159     BOOL initialized;
 160     int bpp;
 161     int width, height;
 162     UINT stride;
 163     const WICPixelFormatGUID *format;
 164     BYTE *image_bits;
 165     CRITICAL_SECTION lock; /* must be held when png structures are accessed or initialized is set */
 166 } PngDecoder;
 167
 168 static inline PngDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 169 {
 170     return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapDecoder_iface);
 171 }
 172
 173 static inline PngDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 174 {
 175     return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapFrameDecode_iface);
 176 }
 177
 178 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl;
 179
 180 static HRESULT WINAPI PngDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 181     void **ppv)
 182 {
 183     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 184     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 185
 186     if (!ppv) return E_INVALIDARG;
 187
 188     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
 189     {
 190         *ppv = This;
 191     }
 192     else
 193     {
 194         *ppv = NULL;
 195         return E_NOINTERFACE;
 196     }
 197
 198     IUnknown_AddRef((IUnknown*)*ppv);
 199     return S_OK;
 200 }
 201
 202 static ULONG WINAPI PngDecoder_AddRef(IWICBitmapDecoder *iface)
 203 {
 204     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 205     ULONG ref = InterlockedIncrement(&This->ref);
 206
 207     TRACE("(%p) refcount=%u\n", iface, ref);
 208
 209     return ref;
 210 }
 211
 212 static ULONG WINAPI PngDecoder_Release(IWICBitmapDecoder *iface)
 213 {
 214     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 215     ULONG ref = InterlockedDecrement(&This->ref);
 216
 217     TRACE("(%p) refcount=%u\n", iface, ref);
 218
 219     if (ref == 0)
 220     {
 221         if (This->png_ptr)
 222             ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, &This->end_info);
 223         This->lock.DebugInfo->Spare[0] = 0;
 224         DeleteCriticalSection(&This->lock);
 225         HeapFree(GetProcessHeap(), 0, This->image_bits);
 226         HeapFree(GetProcessHeap(), 0, This);
 227     }
 228
 229     return ref;
 230 }
 231
 232 static HRESULT WINAPI PngDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
 233     DWORD *pdwCapability)
 234 {
 235     FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
 236     return E_NOTIMPL;
 237 }
 238
 239 static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 240 {
 241     IStream *stream = ppng_get_io_ptr(png_ptr);
 242     HRESULT hr;
 243     ULONG bytesread;
 244
 245     hr = IStream_Read(stream, data, length, &bytesread);
 246     if (FAILED(hr) || bytesread != length)
 247     {
 248         ppng_error(png_ptr, "failed reading data");
 249     }
 250 }
 251
 252 static HRESULT WINAPI PngDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 253     WICDecodeOptions cacheOptions)
 254 {
 255     PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
 256     LARGE_INTEGER seek;
 257     HRESULT hr=S_OK;
 258     png_bytep *row_pointers=NULL;
 259     UINT image_size;
 260     UINT i;
 261     int color_type, bit_depth;
 262     png_bytep trans;
 263     int num_trans;
 264     png_uint_32 transparency;
 265     png_color_16p trans_values;
 266     jmp_buf jmpbuf;
 267
 268     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 269
 270     EnterCriticalSection(&This->lock);
 271
 272     /* initialize libpng */
 273     This->png_ptr = ppng_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 274     if (!This->png_ptr)
 275     {
 276         hr = E_FAIL;
 277         goto end;
 278     }
 279
 280     This->info_ptr = ppng_create_info_struct(This->png_ptr);
 281     if (!This->info_ptr)
 282     {
 283         ppng_destroy_read_struct(&This->png_ptr, NULL, NULL);
 284         This->png_ptr = NULL;
 285         hr = E_FAIL;
 286         goto end;
 287     }
 288
 289     This->end_info = ppng_create_info_struct(This->png_ptr);
 290     if (!This->info_ptr)
 291     {
 292         ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, NULL);
 293         This->png_ptr = NULL;
 294         hr = E_FAIL;
 295         goto end;
 296     }
 297
 298     /* set up setjmp/longjmp error handling */
 299     if (setjmp(jmpbuf))
 300     {
 301         ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, &This->end_info);
 302         HeapFree(GetProcessHeap(), 0, row_pointers);
 303         This->png_ptr = NULL;
 304         hr = E_FAIL;
 305         goto end;
 306     }
 307     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
 308
 309     /* seek to the start of the stream */
 310     seek.QuadPart = 0;
 311     hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 312     if (FAILED(hr)) goto end;
 313
 314     /* set up custom i/o handling */
 315     ppng_set_read_fn(This->png_ptr, pIStream, user_read_data);
 316
 317     /* read the header */
 318     ppng_read_info(This->png_ptr, This->info_ptr);
 319
 320     /* choose a pixel format */
 321     color_type = ppng_get_color_type(This->png_ptr, This->info_ptr);
 322     bit_depth = ppng_get_bit_depth(This->png_ptr, This->info_ptr);
 323
 324     /* check for color-keyed alpha */
 325     transparency = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans, &num_trans, &trans_values);
 326
 327     if (transparency && color_type != PNG_COLOR_TYPE_PALETTE)
 328     {
 329         /* expand to RGBA */
 330         if (color_type == PNG_COLOR_TYPE_GRAY)
 331         {
 332             if (bit_depth < 8)
 333             {
 334 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
 335                 ppng_set_expand_gray_1_2_4_to_8(This->png_ptr);
 336 #else
 337                 ppng_set_gray_1_2_4_to_8(This->png_ptr);
 338 #endif
 339                 bit_depth = 8;
 340             }
 341             ppng_set_gray_to_rgb(This->png_ptr);
 342         }
 343         ppng_set_tRNS_to_alpha(This->png_ptr);
 344         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
 345     }
 346
 347     switch (color_type)
 348     {
 349     case PNG_COLOR_TYPE_GRAY:
 350         This->bpp = bit_depth;
 351         switch (bit_depth)
 352         {
 353         case 1: This->format = &GUID_WICPixelFormatBlackWhite; break;
 354         case 2: This->format = &GUID_WICPixelFormat2bppGray; break;
 355         case 4: This->format = &GUID_WICPixelFormat4bppGray; break;
 356         case 8: This->format = &GUID_WICPixelFormat8bppGray; break;
 357         case 16: This->format = &GUID_WICPixelFormat16bppGray; break;
 358         default:
 359             ERR("invalid grayscale bit depth: %i\n", bit_depth);
 360             hr = E_FAIL;
 361             goto end;
 362         }
 363         break;
 364     case PNG_COLOR_TYPE_GRAY_ALPHA:
 365         /* WIC does not support grayscale alpha formats so use RGBA */
 366         ppng_set_gray_to_rgb(This->png_ptr);
 367     case PNG_COLOR_TYPE_RGB_ALPHA:
 368         This->bpp = bit_depth * 4;
 369         switch (bit_depth)
 370         {
 371         case 8:
 372             ppng_set_bgr(This->png_ptr);
 373             This->format = &GUID_WICPixelFormat32bppBGRA;
 374             break;
 375         case 16: This->format = &GUID_WICPixelFormat64bppRGBA; break;
 376         default:
 377             ERR("invalid RGBA bit depth: %i\n", bit_depth);
 378             hr = E_FAIL;
 379             goto end;
 380         }
 381         break;
 382     case PNG_COLOR_TYPE_PALETTE:
 383         This->bpp = bit_depth;
 384         switch (bit_depth)
 385         {
 386         case 1: This->format = &GUID_WICPixelFormat1bppIndexed; break;
 387         case 2: This->format = &GUID_WICPixelFormat2bppIndexed; break;
 388         case 4: This->format = &GUID_WICPixelFormat4bppIndexed; break;
 389         case 8: This->format = &GUID_WICPixelFormat8bppIndexed; break;
 390         default:
 391             ERR("invalid indexed color bit depth: %i\n", bit_depth);
 392             hr = E_FAIL;
 393             goto end;
 394         }
 395         break;
 396     case PNG_COLOR_TYPE_RGB:
 397         This->bpp = bit_depth * 3;
 398         switch (bit_depth)
 399         {
 400         case 8:
 401             ppng_set_bgr(This->png_ptr);
 402             This->format = &GUID_WICPixelFormat24bppBGR;
 403             break;
 404         case 16: This->format = &GUID_WICPixelFormat48bppRGB; break;
 405         default:
 406             ERR("invalid RGB color bit depth: %i\n", bit_depth);
 407             hr = E_FAIL;
 408             goto end;
 409         }
 410         break;
 411     default:
 412         ERR("invalid color type %i\n", color_type);
 413         hr = E_FAIL;
 414         goto end;
 415     }
 416
 417     /* read the image data */
 418     This->width = ppng_get_image_width(This->png_ptr, This->info_ptr);
 419     This->height = ppng_get_image_height(This->png_ptr, This->info_ptr);
 420     This->stride = This->width * This->bpp;
 421     image_size = This->stride * This->height;
 422
 423     This->image_bits = HeapAlloc(GetProcessHeap(), 0, image_size);
 424     if (!This->image_bits)
 425     {
 426         hr = E_OUTOFMEMORY;
 427         goto end;
 428     }
 429
 430     row_pointers = HeapAlloc(GetProcessHeap(), 0, sizeof(png_bytep)*This->height);
 431     if (!row_pointers)
 432     {
 433         hr = E_OUTOFMEMORY;
 434         goto end;
 435     }
 436
 437     for (i=0; i<This->height; i++)
 438         row_pointers[i] = This->image_bits + i * This->stride;
 439
 440     ppng_read_image(This->png_ptr, row_pointers);
 441
 442     HeapFree(GetProcessHeap(), 0, row_pointers);
 443     row_pointers = NULL;
 444
 445     ppng_read_end(This->png_ptr, This->end_info);
 446
 447     This->initialized = TRUE;
 448
 449 end:
 450
 451     LeaveCriticalSection(&This->lock);
 452
 453     return hr;
 454 }
 455
 456 static HRESULT WINAPI PngDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 457     GUID *pguidContainerFormat)
 458 {
 459     memcpy(pguidContainerFormat, &GUID_ContainerFormatPng, sizeof(GUID));
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI PngDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 464     IWICBitmapDecoderInfo **ppIDecoderInfo)
 465 {
 466     HRESULT hr;
 467     IWICComponentInfo *compinfo;
 468
 469     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 470
 471     hr = CreateComponentInfo(&CLSID_WICPngDecoder, &compinfo);
 472     if (FAILED(hr)) return hr;
 473
 474     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
 475         (void**)ppIDecoderInfo);
 476
 477     IWICComponentInfo_Release(compinfo);
 478
 479     return hr;
 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->end_info = NULL;
 772     This->initialized = FALSE;
 773     This->image_bits = NULL;
 774     InitializeCriticalSection(&This->lock);
 775     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngDecoder.lock");
 776
 777     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
 778     IUnknown_Release((IUnknown*)This);
 779
 780     return ret;
 781 }
 782
 783 struct png_pixelformat {
 784     const WICPixelFormatGUID *guid;
 785     UINT bpp;
 786     int bit_depth;
 787     int color_type;
 788     BOOL remove_filler;
 789     BOOL swap_rgb;
 790 };
 791
 792 static const struct png_pixelformat formats[] = {
 793     {&GUID_WICPixelFormat24bppBGR, 24, 8, PNG_COLOR_TYPE_RGB, 0, 1},
 794     {&GUID_WICPixelFormatBlackWhite, 1, 1, PNG_COLOR_TYPE_GRAY, 0, 0},
 795     {&GUID_WICPixelFormat2bppGray, 2, 2, PNG_COLOR_TYPE_GRAY, 0, 0},
 796     {&GUID_WICPixelFormat4bppGray, 4, 4, PNG_COLOR_TYPE_GRAY, 0, 0},
 797     {&GUID_WICPixelFormat8bppGray, 8, 8, PNG_COLOR_TYPE_GRAY, 0, 0},
 798     {&GUID_WICPixelFormat16bppGray, 16, 16, PNG_COLOR_TYPE_GRAY, 0, 0},
 799     {&GUID_WICPixelFormat32bppBGR, 32, 8, PNG_COLOR_TYPE_RGB, 1, 1},
 800     {&GUID_WICPixelFormat32bppBGRA, 32, 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 1},
 801     {&GUID_WICPixelFormat48bppRGB, 48, 16, PNG_COLOR_TYPE_RGB, 0, 0},
 802     {&GUID_WICPixelFormat64bppRGBA, 64, 16, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0},
 803     {NULL},
 804 };
 805
 806 typedef struct PngEncoder {
 807     IWICBitmapEncoder IWICBitmapEncoder_iface;
 808     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
 809     LONG ref;
 810     IStream *stream;
 811     png_structp png_ptr;
 812     png_infop info_ptr;
 813     UINT frame_count;
 814     BOOL frame_initialized;
 815     const struct png_pixelformat *format;
 816     BOOL info_written;
 817     UINT width, height;
 818     double xres, yres;
 819     UINT lines_written;
 820     BOOL frame_committed;
 821     BOOL committed;
 822     CRITICAL_SECTION lock;
 823 } PngEncoder;
 824
 825 static inline PngEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
 826 {
 827     return CONTAINING_RECORD(iface, PngEncoder, IWICBitmapEncoder_iface);
 828 }
 829
 830 static inline PngEncoder *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
 831 {
 832     return CONTAINING_RECORD(iface, PngEncoder, IWICBitmapFrameEncode_iface);
 833 }
 834
 835 static HRESULT WINAPI PngFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
 836     void **ppv)
 837 {
 838     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 839     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 840
 841     if (!ppv) return E_INVALIDARG;
 842
 843     if (IsEqualIID(&IID_IUnknown, iid) ||
 844         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
 845     {
 846         *ppv = &This->IWICBitmapFrameEncode_iface;
 847     }
 848     else
 849     {
 850         *ppv = NULL;
 851         return E_NOINTERFACE;
 852     }
 853
 854     IUnknown_AddRef((IUnknown*)*ppv);
 855     return S_OK;
 856 }
 857
 858 static ULONG WINAPI PngFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
 859 {
 860     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 861     return IUnknown_AddRef((IUnknown*)This);
 862 }
 863
 864 static ULONG WINAPI PngFrameEncode_Release(IWICBitmapFrameEncode *iface)
 865 {
 866     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 867     return IUnknown_Release((IUnknown*)This);
 868 }
 869
 870 static HRESULT WINAPI PngFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
 871     IPropertyBag2 *pIEncoderOptions)
 872 {
 873     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 874     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
 875
 876     EnterCriticalSection(&This->lock);
 877
 878     if (This->frame_initialized)
 879     {
 880         LeaveCriticalSection(&This->lock);
 881         return WINCODEC_ERR_WRONGSTATE;
 882     }
 883
 884     This->frame_initialized = TRUE;
 885
 886     LeaveCriticalSection(&This->lock);
 887
 888     return S_OK;
 889 }
 890
 891 static HRESULT WINAPI PngFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
 892     UINT uiWidth, UINT uiHeight)
 893 {
 894     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 895     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
 896
 897     EnterCriticalSection(&This->lock);
 898
 899     if (!This->frame_initialized || This->info_written)
 900     {
 901         LeaveCriticalSection(&This->lock);
 902         return WINCODEC_ERR_WRONGSTATE;
 903     }
 904
 905     This->width = uiWidth;
 906     This->height = uiHeight;
 907
 908     LeaveCriticalSection(&This->lock);
 909
 910     return S_OK;
 911 }
 912
 913 static HRESULT WINAPI PngFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
 914     double dpiX, double dpiY)
 915 {
 916     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 917     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
 918
 919     EnterCriticalSection(&This->lock);
 920
 921     if (!This->frame_initialized || This->info_written)
 922     {
 923         LeaveCriticalSection(&This->lock);
 924         return WINCODEC_ERR_WRONGSTATE;
 925     }
 926
 927     This->xres = dpiX;
 928     This->yres = dpiY;
 929
 930     LeaveCriticalSection(&This->lock);
 931
 932     return S_OK;
 933 }
 934
 935 static HRESULT WINAPI PngFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
 936     WICPixelFormatGUID *pPixelFormat)
 937 {
 938     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 939     int i;
 940     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
 941
 942     EnterCriticalSection(&This->lock);
 943
 944     if (!This->frame_initialized || This->info_written)
 945     {
 946         LeaveCriticalSection(&This->lock);
 947         return WINCODEC_ERR_WRONGSTATE;
 948     }
 949
 950     for (i=0; formats[i].guid; i++)
 951     {
 952         if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
 953             break;
 954     }
 955
 956     if (!formats[i].guid) i = 0;
 957
 958     This->format = &formats[i];
 959     memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
 960
 961     LeaveCriticalSection(&This->lock);
 962
 963     return S_OK;
 964 }
 965
 966 static HRESULT WINAPI PngFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
 967     UINT cCount, IWICColorContext **ppIColorContext)
 968 {
 969     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 970     return E_NOTIMPL;
 971 }
 972
 973 static HRESULT WINAPI PngFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
 974     IWICPalette *pIPalette)
 975 {
 976     FIXME("(%p,%p): stub\n", iface, pIPalette);
 977     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 978 }
 979
 980 static HRESULT WINAPI PngFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
 981     IWICBitmapSource *pIThumbnail)
 982 {
 983     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
 984     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 985 }
 986
 987 static HRESULT WINAPI PngFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
 988     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
 989 {
 990     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 991     png_byte **row_pointers=NULL;
 992     UINT i;
 993     jmp_buf jmpbuf;
 994     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
 995
 996     EnterCriticalSection(&This->lock);
 997
 998     if (!This->frame_initialized || !This->width || !This->height || !This->format)
 999     {
1000         LeaveCriticalSection(&This->lock);
1001         return WINCODEC_ERR_WRONGSTATE;
1002     }
1003
1004     if (lineCount == 0 || lineCount + This->lines_written > This->height)
1005     {
1006         LeaveCriticalSection(&This->lock);
1007         return E_INVALIDARG;
1008     }
1009
1010     /* set up setjmp/longjmp error handling */
1011     if (setjmp(jmpbuf))
1012     {
1013         LeaveCriticalSection(&This->lock);
1014         HeapFree(GetProcessHeap(), 0, row_pointers);
1015         return E_FAIL;
1016     }
1017     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
1018
1019     if (!This->info_written)
1020     {
1021         ppng_set_IHDR(This->png_ptr, This->info_ptr, This->width, This->height,
1022             This->format->bit_depth, This->format->color_type, PNG_INTERLACE_NONE,
1023             PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1024
1025         if (This->xres != 0.0 && This->yres != 0.0)
1026         {
1027             ppng_set_pHYs(This->png_ptr, This->info_ptr, (This->xres+0.0127) / 0.0254,
1028                 (This->yres+0.0127) / 0.0254, PNG_RESOLUTION_METER);
1029         }
1030
1031         ppng_write_info(This->png_ptr, This->info_ptr);
1032
1033         if (This->format->remove_filler)
1034             ppng_set_filler(This->png_ptr, 0, PNG_FILLER_AFTER);
1035
1036         if (This->format->swap_rgb)
1037             ppng_set_bgr(This->png_ptr);
1038
1039         This->info_written = TRUE;
1040     }
1041
1042     row_pointers = HeapAlloc(GetProcessHeap(), 0, lineCount * sizeof(png_byte*));
1043     if (!row_pointers)
1044     {
1045         LeaveCriticalSection(&This->lock);
1046         return E_OUTOFMEMORY;
1047     }
1048
1049     for (i=0; i<lineCount; i++)
1050         row_pointers[i] = pbPixels + cbStride * i;
1051
1052     ppng_write_rows(This->png_ptr, row_pointers, lineCount);
1053     This->lines_written += lineCount;
1054
1055     LeaveCriticalSection(&This->lock);
1056
1057     HeapFree(GetProcessHeap(), 0, row_pointers);
1058
1059     return S_OK;
1060 }
1061
1062 static HRESULT WINAPI PngFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
1063     IWICBitmapSource *pIBitmapSource, WICRect *prc)
1064 {
1065     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1066     HRESULT hr;
1067     WICRect rc;
1068     WICPixelFormatGUID guid;
1069     UINT stride;
1070     BYTE *pixeldata;
1071     TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
1072
1073     if (!This->frame_initialized || !This->width || !This->height)
1074         return WINCODEC_ERR_WRONGSTATE;
1075
1076     if (!This->format)
1077     {
1078         hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1079         if (FAILED(hr)) return hr;
1080         hr = IWICBitmapFrameEncode_SetPixelFormat(iface, &guid);
1081         if (FAILED(hr)) return hr;
1082     }
1083
1084     hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1085     if (FAILED(hr)) return hr;
1086     if (memcmp(&guid, This->format->guid, sizeof(GUID)) != 0)
1087     {
1088         /* FIXME: should use WICConvertBitmapSource to convert */
1089         ERR("format %s unsupported\n", debugstr_guid(&guid));
1090         return E_FAIL;
1091     }
1092
1093     if (This->xres == 0.0 || This->yres == 0.0)
1094     {
1095         double xres, yres;
1096         hr = IWICBitmapSource_GetResolution(pIBitmapSource, &xres, &yres);
1097         if (FAILED(hr)) return hr;
1098         hr = IWICBitmapFrameEncode_SetResolution(iface, xres, yres);
1099         if (FAILED(hr)) return hr;
1100     }
1101
1102     if (!prc)
1103     {
1104         UINT width, height;
1105         hr = IWICBitmapSource_GetSize(pIBitmapSource, &width, &height);
1106         if (FAILED(hr)) return hr;
1107         rc.X = 0;
1108         rc.Y = 0;
1109         rc.Width = width;
1110         rc.Height = height;
1111         prc = &rc;
1112     }
1113
1114     if (prc->Width != This->width) return E_INVALIDARG;
1115
1116     stride = (This->format->bpp * This->width + 7)/8;
1117
1118     pixeldata = HeapAlloc(GetProcessHeap(), 0, stride * prc->Height);
1119     if (!pixeldata) return E_OUTOFMEMORY;
1120
1121     hr = IWICBitmapSource_CopyPixels(pIBitmapSource, prc, stride,
1122         stride*prc->Height, pixeldata);
1123
1124     if (SUCCEEDED(hr))
1125     {
1126         hr = IWICBitmapFrameEncode_WritePixels(iface, prc->Height, stride,
1127             stride*prc->Height, pixeldata);
1128     }
1129
1130     HeapFree(GetProcessHeap(), 0, pixeldata);
1131
1132     return hr;
1133 }
1134
1135 static HRESULT WINAPI PngFrameEncode_Commit(IWICBitmapFrameEncode *iface)
1136 {
1137     PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1138     jmp_buf jmpbuf;
1139     TRACE("(%p)\n", iface);
1140
1141     EnterCriticalSection(&This->lock);
1142
1143     if (!This->info_written || This->lines_written != This->height || This->frame_committed)
1144     {
1145         LeaveCriticalSection(&This->lock);
1146         return WINCODEC_ERR_WRONGSTATE;
1147     }
1148
1149     /* set up setjmp/longjmp error handling */
1150     if (setjmp(jmpbuf))
1151     {
1152         LeaveCriticalSection(&This->lock);
1153         return E_FAIL;
1154     }
1155     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
1156
1157     ppng_write_end(This->png_ptr, This->info_ptr);
1158
1159     This->frame_committed = TRUE;
1160
1161     LeaveCriticalSection(&This->lock);
1162
1163     return S_OK;
1164 }
1165
1166 static HRESULT WINAPI PngFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
1167     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1168 {
1169     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
1170     return E_NOTIMPL;
1171 }
1172
1173 static const IWICBitmapFrameEncodeVtbl PngEncoder_FrameVtbl = {
1174     PngFrameEncode_QueryInterface,
1175     PngFrameEncode_AddRef,
1176     PngFrameEncode_Release,
1177     PngFrameEncode_Initialize,
1178     PngFrameEncode_SetSize,
1179     PngFrameEncode_SetResolution,
1180     PngFrameEncode_SetPixelFormat,
1181     PngFrameEncode_SetColorContexts,
1182     PngFrameEncode_SetPalette,
1183     PngFrameEncode_SetThumbnail,
1184     PngFrameEncode_WritePixels,
1185     PngFrameEncode_WriteSource,
1186     PngFrameEncode_Commit,
1187     PngFrameEncode_GetMetadataQueryWriter
1188 };
1189
1190 static HRESULT WINAPI PngEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
1191     void **ppv)
1192 {
1193     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1194     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1195
1196     if (!ppv) return E_INVALIDARG;
1197
1198     if (IsEqualIID(&IID_IUnknown, iid) ||
1199         IsEqualIID(&IID_IWICBitmapEncoder, iid))
1200     {
1201         *ppv = This;
1202     }
1203     else
1204     {
1205         *ppv = NULL;
1206         return E_NOINTERFACE;
1207     }
1208
1209     IUnknown_AddRef((IUnknown*)*ppv);
1210     return S_OK;
1211 }
1212
1213 static ULONG WINAPI PngEncoder_AddRef(IWICBitmapEncoder *iface)
1214 {
1215     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1216     ULONG ref = InterlockedIncrement(&This->ref);
1217
1218     TRACE("(%p) refcount=%u\n", iface, ref);
1219
1220     return ref;
1221 }
1222
1223 static ULONG WINAPI PngEncoder_Release(IWICBitmapEncoder *iface)
1224 {
1225     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1226     ULONG ref = InterlockedDecrement(&This->ref);
1227
1228     TRACE("(%p) refcount=%u\n", iface, ref);
1229
1230     if (ref == 0)
1231     {
1232         This->lock.DebugInfo->Spare[0] = 0;
1233         DeleteCriticalSection(&This->lock);
1234         if (This->png_ptr)
1235             ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1236         if (This->stream)
1237             IStream_Release(This->stream);
1238         HeapFree(GetProcessHeap(), 0, This);
1239     }
1240
1241     return ref;
1242 }
1243
1244 static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1245 {
1246     PngEncoder *This = ppng_get_io_ptr(png_ptr);
1247     HRESULT hr;
1248     ULONG byteswritten;
1249
1250     hr = IStream_Write(This->stream, data, length, &byteswritten);
1251     if (FAILED(hr) || byteswritten != length)
1252     {
1253         ppng_error(png_ptr, "failed writing data");
1254     }
1255 }
1256
1257 static void user_flush(png_structp png_ptr)
1258 {
1259 }
1260
1261 static HRESULT WINAPI PngEncoder_Initialize(IWICBitmapEncoder *iface,
1262     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
1263 {
1264     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1265     jmp_buf jmpbuf;
1266
1267     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
1268
1269     EnterCriticalSection(&This->lock);
1270
1271     if (This->png_ptr)
1272     {
1273         LeaveCriticalSection(&This->lock);
1274         return WINCODEC_ERR_WRONGSTATE;
1275     }
1276
1277     /* initialize libpng */
1278     This->png_ptr = ppng_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1279     if (!This->png_ptr)
1280     {
1281         LeaveCriticalSection(&This->lock);
1282         return E_FAIL;
1283     }
1284
1285     This->info_ptr = ppng_create_info_struct(This->png_ptr);
1286     if (!This->info_ptr)
1287     {
1288         ppng_destroy_write_struct(&This->png_ptr, NULL);
1289         This->png_ptr = NULL;
1290         LeaveCriticalSection(&This->lock);
1291         return E_FAIL;
1292     }
1293
1294     IStream_AddRef(pIStream);
1295     This->stream = pIStream;
1296
1297     /* set up setjmp/longjmp error handling */
1298     if (setjmp(jmpbuf))
1299     {
1300         ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1301         This->png_ptr = NULL;
1302         IStream_Release(This->stream);
1303         This->stream = NULL;
1304         LeaveCriticalSection(&This->lock);
1305         return E_FAIL;
1306     }
1307     ppng_set_error_fn(This->png_ptr, &jmpbuf, user_error_fn, user_warning_fn);
1308
1309     /* set up custom i/o handling */
1310     ppng_set_write_fn(This->png_ptr, This, user_write_data, user_flush);
1311
1312     LeaveCriticalSection(&This->lock);
1313
1314     return S_OK;
1315 }
1316
1317 static HRESULT WINAPI PngEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
1318     GUID *pguidContainerFormat)
1319 {
1320     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
1321     return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI PngEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
1325     IWICBitmapEncoderInfo **ppIEncoderInfo)
1326 {
1327     FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
1328     return E_NOTIMPL;
1329 }
1330
1331 static HRESULT WINAPI PngEncoder_SetColorContexts(IWICBitmapEncoder *iface,
1332     UINT cCount, IWICColorContext **ppIColorContext)
1333 {
1334     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1335     return E_NOTIMPL;
1336 }
1337
1338 static HRESULT WINAPI PngEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
1339 {
1340     TRACE("(%p,%p)\n", iface, pIPalette);
1341     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1342 }
1343
1344 static HRESULT WINAPI PngEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
1345 {
1346     TRACE("(%p,%p)\n", iface, pIThumbnail);
1347     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1348 }
1349
1350 static HRESULT WINAPI PngEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
1351 {
1352     TRACE("(%p,%p)\n", iface, pIPreview);
1353     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1354 }
1355
1356 static HRESULT WINAPI PngEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
1357     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
1358 {
1359     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1360     HRESULT hr;
1361     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
1362
1363     EnterCriticalSection(&This->lock);
1364
1365     if (This->frame_count != 0)
1366     {
1367         LeaveCriticalSection(&This->lock);
1368         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1369     }
1370
1371     if (!This->stream)
1372     {
1373         LeaveCriticalSection(&This->lock);
1374         return WINCODEC_ERR_NOTINITIALIZED;
1375     }
1376
1377     hr = CreatePropertyBag2(ppIEncoderOptions);
1378     if (FAILED(hr))
1379     {
1380         LeaveCriticalSection(&This->lock);
1381         return hr;
1382     }
1383
1384     This->frame_count = 1;
1385
1386     LeaveCriticalSection(&This->lock);
1387
1388     IWICBitmapEncoder_AddRef(iface);
1389     *ppIFrameEncode = &This->IWICBitmapFrameEncode_iface;
1390
1391     return S_OK;
1392 }
1393
1394 static HRESULT WINAPI PngEncoder_Commit(IWICBitmapEncoder *iface)
1395 {
1396     PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1397     TRACE("(%p)\n", iface);
1398
1399     EnterCriticalSection(&This->lock);
1400
1401     if (!This->frame_committed || This->committed)
1402     {
1403         LeaveCriticalSection(&This->lock);
1404         return WINCODEC_ERR_WRONGSTATE;
1405     }
1406
1407     This->committed = TRUE;
1408
1409     LeaveCriticalSection(&This->lock);
1410
1411     return S_OK;
1412 }
1413
1414 static HRESULT WINAPI PngEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
1415     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1416 {
1417     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
1418     return E_NOTIMPL;
1419 }
1420
1421 static const IWICBitmapEncoderVtbl PngEncoder_Vtbl = {
1422     PngEncoder_QueryInterface,
1423     PngEncoder_AddRef,
1424     PngEncoder_Release,
1425     PngEncoder_Initialize,
1426     PngEncoder_GetContainerFormat,
1427     PngEncoder_GetEncoderInfo,
1428     PngEncoder_SetColorContexts,
1429     PngEncoder_SetPalette,
1430     PngEncoder_SetThumbnail,
1431     PngEncoder_SetPreview,
1432     PngEncoder_CreateNewFrame,
1433     PngEncoder_Commit,
1434     PngEncoder_GetMetadataQueryWriter
1435 };
1436
1437 HRESULT PngEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1438 {
1439     PngEncoder *This;
1440     HRESULT ret;
1441
1442     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1443
1444     *ppv = NULL;
1445
1446     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1447
1448     if (!libpng_handle && !load_libpng())
1449     {
1450         ERR("Failed writing PNG because unable to find %s\n",SONAME_LIBPNG);
1451         return E_FAIL;
1452     }
1453
1454     This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngEncoder));
1455     if (!This) return E_OUTOFMEMORY;
1456
1457     This->IWICBitmapEncoder_iface.lpVtbl = &PngEncoder_Vtbl;
1458     This->IWICBitmapFrameEncode_iface.lpVtbl = &PngEncoder_FrameVtbl;
1459     This->ref = 1;
1460     This->png_ptr = NULL;
1461     This->info_ptr = NULL;
1462     This->stream = NULL;
1463     This->frame_count = 0;
1464     This->frame_initialized = FALSE;
1465     This->format = NULL;
1466     This->info_written = FALSE;
1467     This->width = 0;
1468     This->height = 0;
1469     This->xres = 0.0;
1470     This->yres = 0.0;
1471     This->lines_written = 0;
1472     This->frame_committed = FALSE;
1473     This->committed = FALSE;
1474     InitializeCriticalSection(&This->lock);
1475     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngEncoder.lock");
1476
1477     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1478     IUnknown_Release((IUnknown*)This);
1479
1480     return ret;
1481 }
1482
1483 #else /* !HAVE_PNG_H */
1484
1485 HRESULT PngDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1486 {
1487     ERR("Trying to load PNG picture, but PNG support is not compiled in.\n");
1488     return E_FAIL;
1489 }
1490
1491 HRESULT PngEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1492 {
1493     ERR("Trying to save PNG picture, but PNG support is not compiled in.\n");
1494     return E_FAIL;
1495 }
1496
1497 #endif