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