dlls/windowscodecs/pngformat.c

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