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