dll/win32/windowscodecs/pngformat.c

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