2 * Copyright 2009 Vincent Povirk for CodeWeavers
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.
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.
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
20 #include "wine/port.h"
28 #define NONAMELESSUNION
35 #include "wincodecsdk.h"
37 #include "wincodecs_private.h"
39 #include "wine/debug.h"
40 #include "wine/library.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
44 static HRESULT read_png_chunk(IStream *stream, BYTE *type, BYTE **data, ULONG *data_size)
50 hr = IStream_Read(stream, header, 8, &bytesread);
51 if (FAILED(hr) || bytesread < 8)
58 *data_size = header[0] << 24 | header[1] << 16 | header[2] << 8 | header[3];
60 memcpy(type, &header[4], 4);
64 *data = HeapAlloc(GetProcessHeap(), 0, *data_size);
68 hr = IStream_Read(stream, *data, *data_size, &bytesread);
70 if (FAILED(hr) || bytesread < *data_size)
74 HeapFree(GetProcessHeap(), 0, *data);
79 /* FIXME: Verify the CRC? */
85 static HRESULT LoadTextMetadata(IStream *stream, const GUID *preferred_vendor,
86 DWORD persist_options, MetadataItem **items, DWORD *item_count)
92 ULONG name_len, value_len;
97 hr = read_png_chunk(stream, type, &data, &data_size);
98 if (FAILED(hr)) return hr;
100 name_end_ptr = memchr(data, 0, data_size);
102 name_len = name_end_ptr - data;
104 if (!name_end_ptr || name_len > 79)
106 HeapFree(GetProcessHeap(), 0, data);
110 value_len = data_size - name_len - 1;
112 result = HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataItem));
113 name = HeapAlloc(GetProcessHeap(), 0, name_len + 1);
114 value = HeapAlloc(GetProcessHeap(), 0, value_len + 1);
115 if (!result || !name || !value)
117 HeapFree(GetProcessHeap(), 0, data);
118 HeapFree(GetProcessHeap(), 0, result);
119 HeapFree(GetProcessHeap(), 0, name);
120 HeapFree(GetProcessHeap(), 0, value);
121 return E_OUTOFMEMORY;
124 PropVariantInit(&result[0].schema);
125 PropVariantInit(&result[0].id);
126 PropVariantInit(&result[0].value);
128 memcpy(name, data, name_len + 1);
129 memcpy(value, name_end_ptr + 1, value_len);
130 value[value_len] = 0;
132 result[0].id.vt = VT_LPSTR;
133 result[0].id.u.pszVal = name;
134 result[0].value.vt = VT_LPSTR;
135 result[0].value.u.pszVal = value;
140 HeapFree(GetProcessHeap(), 0, data);
145 static const MetadataHandlerVtbl TextReader_Vtbl = {
147 &CLSID_WICPngTextMetadataReader,
151 HRESULT PngTextReader_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
153 return MetadataReader_Create(&TextReader_Vtbl, pUnkOuter, iid, ppv);
158 static void *libpng_handle;
159 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
160 MAKE_FUNCPTR(png_create_read_struct);
161 MAKE_FUNCPTR(png_create_info_struct);
162 MAKE_FUNCPTR(png_create_write_struct);
163 MAKE_FUNCPTR(png_destroy_read_struct);
164 MAKE_FUNCPTR(png_destroy_write_struct);
165 MAKE_FUNCPTR(png_error);
166 MAKE_FUNCPTR(png_get_bit_depth);
167 MAKE_FUNCPTR(png_get_color_type);
168 MAKE_FUNCPTR(png_get_error_ptr);
169 MAKE_FUNCPTR(png_get_iCCP);
170 MAKE_FUNCPTR(png_get_image_height);
171 MAKE_FUNCPTR(png_get_image_width);
172 MAKE_FUNCPTR(png_get_io_ptr);
173 MAKE_FUNCPTR(png_get_pHYs);
174 MAKE_FUNCPTR(png_get_PLTE);
175 MAKE_FUNCPTR(png_get_tRNS);
176 MAKE_FUNCPTR(png_set_bgr);
177 MAKE_FUNCPTR(png_set_error_fn);
178 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
179 MAKE_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
181 MAKE_FUNCPTR(png_set_gray_1_2_4_to_8);
183 MAKE_FUNCPTR(png_set_filler);
184 MAKE_FUNCPTR(png_set_gray_to_rgb);
185 MAKE_FUNCPTR(png_set_IHDR);
186 MAKE_FUNCPTR(png_set_pHYs);
187 MAKE_FUNCPTR(png_set_read_fn);
188 MAKE_FUNCPTR(png_set_strip_16);
189 MAKE_FUNCPTR(png_set_tRNS_to_alpha);
190 MAKE_FUNCPTR(png_set_write_fn);
191 MAKE_FUNCPTR(png_read_end);
192 MAKE_FUNCPTR(png_read_image);
193 MAKE_FUNCPTR(png_read_info);
194 MAKE_FUNCPTR(png_write_end);
195 MAKE_FUNCPTR(png_write_info);
196 MAKE_FUNCPTR(png_write_rows);
199 static void *load_libpng(void)
201 if((libpng_handle = wine_dlopen(SONAME_LIBPNG, RTLD_NOW, NULL, 0)) != NULL) {
203 #define LOAD_FUNCPTR(f) \
204 if((p##f = wine_dlsym(libpng_handle, #f, NULL, 0)) == NULL) { \
205 libpng_handle = NULL; \
208 LOAD_FUNCPTR(png_create_read_struct);
209 LOAD_FUNCPTR(png_create_info_struct);
210 LOAD_FUNCPTR(png_create_write_struct);
211 LOAD_FUNCPTR(png_destroy_read_struct);
212 LOAD_FUNCPTR(png_destroy_write_struct);
213 LOAD_FUNCPTR(png_error);
214 LOAD_FUNCPTR(png_get_bit_depth);
215 LOAD_FUNCPTR(png_get_color_type);
216 LOAD_FUNCPTR(png_get_error_ptr);
217 LOAD_FUNCPTR(png_get_iCCP);
218 LOAD_FUNCPTR(png_get_image_height);
219 LOAD_FUNCPTR(png_get_image_width);
220 LOAD_FUNCPTR(png_get_io_ptr);
221 LOAD_FUNCPTR(png_get_pHYs);
222 LOAD_FUNCPTR(png_get_PLTE);
223 LOAD_FUNCPTR(png_get_tRNS);
224 LOAD_FUNCPTR(png_set_bgr);
225 LOAD_FUNCPTR(png_set_error_fn);
226 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
227 LOAD_FUNCPTR(png_set_expand_gray_1_2_4_to_8);
229 LOAD_FUNCPTR(png_set_gray_1_2_4_to_8);
231 LOAD_FUNCPTR(png_set_filler);
232 LOAD_FUNCPTR(png_set_gray_to_rgb);
233 LOAD_FUNCPTR(png_set_IHDR);
234 LOAD_FUNCPTR(png_set_pHYs);
235 LOAD_FUNCPTR(png_set_read_fn);
236 LOAD_FUNCPTR(png_set_strip_16);
237 LOAD_FUNCPTR(png_set_tRNS_to_alpha);
238 LOAD_FUNCPTR(png_set_write_fn);
239 LOAD_FUNCPTR(png_read_end);
240 LOAD_FUNCPTR(png_read_image);
241 LOAD_FUNCPTR(png_read_info);
242 LOAD_FUNCPTR(png_write_end);
243 LOAD_FUNCPTR(png_write_info);
244 LOAD_FUNCPTR(png_write_rows);
248 return libpng_handle;
251 static void user_error_fn(png_structp png_ptr, png_const_charp error_message)
255 /* This uses setjmp/longjmp just like the default. We can't use the
256 * default because there's no way to access the jmp buffer in the png_struct
257 * that works in 1.2 and 1.4 and allows us to dynamically load libpng. */
258 WARN("PNG error: %s\n", debugstr_a(error_message));
259 pjmpbuf = ppng_get_error_ptr(png_ptr);
260 longjmp(*pjmpbuf, 1);
263 static void user_warning_fn(png_structp png_ptr, png_const_charp warning_message)
265 WARN("PNG warning: %s\n", debugstr_a(warning_message));
269 IWICBitmapDecoder IWICBitmapDecoder_iface;
270 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
271 IWICMetadataBlockReader IWICMetadataBlockReader_iface;
280 const WICPixelFormatGUID *format;
282 CRITICAL_SECTION lock; /* must be held when png structures are accessed or initialized is set */
285 static inline PngDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
287 return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapDecoder_iface);
290 static inline PngDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
292 return CONTAINING_RECORD(iface, PngDecoder, IWICBitmapFrameDecode_iface);
295 static inline PngDecoder *impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
297 return CONTAINING_RECORD(iface, PngDecoder, IWICMetadataBlockReader_iface);
300 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl;
302 static HRESULT WINAPI PngDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
305 PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
306 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
308 if (!ppv) return E_INVALIDARG;
310 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
312 *ppv = &This->IWICBitmapDecoder_iface;
317 return E_NOINTERFACE;
320 IUnknown_AddRef((IUnknown*)*ppv);
324 static ULONG WINAPI PngDecoder_AddRef(IWICBitmapDecoder *iface)
326 PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
327 ULONG ref = InterlockedIncrement(&This->ref);
329 TRACE("(%p) refcount=%u\n", iface, ref);
334 static ULONG WINAPI PngDecoder_Release(IWICBitmapDecoder *iface)
336 PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
337 ULONG ref = InterlockedDecrement(&This->ref);
339 TRACE("(%p) refcount=%u\n", iface, ref);
344 ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, &This->end_info);
345 This->lock.DebugInfo->Spare[0] = 0;
346 DeleteCriticalSection(&This->lock);
347 HeapFree(GetProcessHeap(), 0, This->image_bits);
348 HeapFree(GetProcessHeap(), 0, This);
354 static HRESULT WINAPI PngDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
355 DWORD *pdwCapability)
357 FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
361 static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
363 IStream *stream = ppng_get_io_ptr(png_ptr);
367 hr = IStream_Read(stream, data, length, &bytesread);
368 if (FAILED(hr) || bytesread != length)
370 ppng_error(png_ptr, "failed reading data");
374 static HRESULT WINAPI PngDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
375 WICDecodeOptions cacheOptions)
377 PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
380 png_bytep *row_pointers=NULL;
383 int color_type, bit_depth;
386 png_uint_32 transparency;
387 png_color_16p trans_values;
390 TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
392 EnterCriticalSection(&This->lock);
394 /* initialize libpng */
395 This->png_ptr = ppng_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
402 This->info_ptr = ppng_create_info_struct(This->png_ptr);
405 ppng_destroy_read_struct(&This->png_ptr, NULL, NULL);
406 This->png_ptr = NULL;
411 This->end_info = ppng_create_info_struct(This->png_ptr);
414 ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, NULL);
415 This->png_ptr = NULL;
420 /* set up setjmp/longjmp error handling */
423 ppng_destroy_read_struct(&This->png_ptr, &This->info_ptr, &This->end_info);
424 HeapFree(GetProcessHeap(), 0, row_pointers);
425 This->png_ptr = NULL;
429 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
431 /* seek to the start of the stream */
433 hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
434 if (FAILED(hr)) goto end;
436 /* set up custom i/o handling */
437 ppng_set_read_fn(This->png_ptr, pIStream, user_read_data);
439 /* read the header */
440 ppng_read_info(This->png_ptr, This->info_ptr);
442 /* choose a pixel format */
443 color_type = ppng_get_color_type(This->png_ptr, This->info_ptr);
444 bit_depth = ppng_get_bit_depth(This->png_ptr, This->info_ptr);
446 /* check for color-keyed alpha */
447 transparency = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans, &num_trans, &trans_values);
449 if (transparency && color_type != PNG_COLOR_TYPE_PALETTE)
452 if (color_type == PNG_COLOR_TYPE_GRAY)
456 #if HAVE_PNG_SET_EXPAND_GRAY_1_2_4_TO_8
457 ppng_set_expand_gray_1_2_4_to_8(This->png_ptr);
459 ppng_set_gray_1_2_4_to_8(This->png_ptr);
463 ppng_set_gray_to_rgb(This->png_ptr);
465 ppng_set_tRNS_to_alpha(This->png_ptr);
466 color_type = PNG_COLOR_TYPE_RGB_ALPHA;
471 case PNG_COLOR_TYPE_GRAY:
472 This->bpp = bit_depth;
475 case 1: This->format = &GUID_WICPixelFormatBlackWhite; break;
476 case 2: This->format = &GUID_WICPixelFormat2bppGray; break;
477 case 4: This->format = &GUID_WICPixelFormat4bppGray; break;
478 case 8: This->format = &GUID_WICPixelFormat8bppGray; break;
479 case 16: This->format = &GUID_WICPixelFormat16bppGray; break;
481 ERR("invalid grayscale bit depth: %i\n", bit_depth);
486 case PNG_COLOR_TYPE_GRAY_ALPHA:
487 /* WIC does not support grayscale alpha formats so use RGBA */
488 ppng_set_gray_to_rgb(This->png_ptr);
490 case PNG_COLOR_TYPE_RGB_ALPHA:
491 This->bpp = bit_depth * 4;
495 ppng_set_bgr(This->png_ptr);
496 This->format = &GUID_WICPixelFormat32bppBGRA;
498 case 16: This->format = &GUID_WICPixelFormat64bppRGBA; break;
500 ERR("invalid RGBA bit depth: %i\n", bit_depth);
505 case PNG_COLOR_TYPE_PALETTE:
506 This->bpp = bit_depth;
509 case 1: This->format = &GUID_WICPixelFormat1bppIndexed; break;
510 case 2: This->format = &GUID_WICPixelFormat2bppIndexed; break;
511 case 4: This->format = &GUID_WICPixelFormat4bppIndexed; break;
512 case 8: This->format = &GUID_WICPixelFormat8bppIndexed; break;
514 ERR("invalid indexed color bit depth: %i\n", bit_depth);
519 case PNG_COLOR_TYPE_RGB:
520 This->bpp = bit_depth * 3;
524 ppng_set_bgr(This->png_ptr);
525 This->format = &GUID_WICPixelFormat24bppBGR;
527 case 16: This->format = &GUID_WICPixelFormat48bppRGB; break;
529 ERR("invalid RGB color bit depth: %i\n", bit_depth);
535 ERR("invalid color type %i\n", color_type);
540 /* read the image data */
541 This->width = ppng_get_image_width(This->png_ptr, This->info_ptr);
542 This->height = ppng_get_image_height(This->png_ptr, This->info_ptr);
543 This->stride = This->width * This->bpp;
544 image_size = This->stride * This->height;
546 This->image_bits = HeapAlloc(GetProcessHeap(), 0, image_size);
547 if (!This->image_bits)
553 row_pointers = HeapAlloc(GetProcessHeap(), 0, sizeof(png_bytep)*This->height);
560 for (i=0; i<This->height; i++)
561 row_pointers[i] = This->image_bits + i * This->stride;
563 ppng_read_image(This->png_ptr, row_pointers);
565 HeapFree(GetProcessHeap(), 0, row_pointers);
568 ppng_read_end(This->png_ptr, This->end_info);
570 This->initialized = TRUE;
574 LeaveCriticalSection(&This->lock);
579 static HRESULT WINAPI PngDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
580 GUID *pguidContainerFormat)
582 memcpy(pguidContainerFormat, &GUID_ContainerFormatPng, sizeof(GUID));
586 static HRESULT WINAPI PngDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
587 IWICBitmapDecoderInfo **ppIDecoderInfo)
590 IWICComponentInfo *compinfo;
592 TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
594 hr = CreateComponentInfo(&CLSID_WICPngDecoder, &compinfo);
595 if (FAILED(hr)) return hr;
597 hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
598 (void**)ppIDecoderInfo);
600 IWICComponentInfo_Release(compinfo);
605 static HRESULT WINAPI PngDecoder_CopyPalette(IWICBitmapDecoder *iface,
606 IWICPalette *pIPalette)
608 FIXME("(%p,%p): stub\n", iface, pIPalette);
612 static HRESULT WINAPI PngDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
613 IWICMetadataQueryReader **ppIMetadataQueryReader)
615 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
619 static HRESULT WINAPI PngDecoder_GetPreview(IWICBitmapDecoder *iface,
620 IWICBitmapSource **ppIBitmapSource)
622 FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
626 static HRESULT WINAPI PngDecoder_GetColorContexts(IWICBitmapDecoder *iface,
627 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
629 TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
630 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
633 static HRESULT WINAPI PngDecoder_GetThumbnail(IWICBitmapDecoder *iface,
634 IWICBitmapSource **ppIThumbnail)
636 TRACE("(%p,%p)\n", iface, ppIThumbnail);
637 return WINCODEC_ERR_CODECNOTHUMBNAIL;
640 static HRESULT WINAPI PngDecoder_GetFrameCount(IWICBitmapDecoder *iface,
647 static HRESULT WINAPI PngDecoder_GetFrame(IWICBitmapDecoder *iface,
648 UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
650 PngDecoder *This = impl_from_IWICBitmapDecoder(iface);
651 TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
653 if (!This->initialized) return WINCODEC_ERR_NOTINITIALIZED;
655 if (index != 0) return E_INVALIDARG;
657 IWICBitmapDecoder_AddRef(iface);
659 *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
664 static const IWICBitmapDecoderVtbl PngDecoder_Vtbl = {
665 PngDecoder_QueryInterface,
668 PngDecoder_QueryCapability,
669 PngDecoder_Initialize,
670 PngDecoder_GetContainerFormat,
671 PngDecoder_GetDecoderInfo,
672 PngDecoder_CopyPalette,
673 PngDecoder_GetMetadataQueryReader,
674 PngDecoder_GetPreview,
675 PngDecoder_GetColorContexts,
676 PngDecoder_GetThumbnail,
677 PngDecoder_GetFrameCount,
681 static HRESULT WINAPI PngDecoder_Frame_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
684 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
685 if (!ppv) return E_INVALIDARG;
687 if (IsEqualIID(&IID_IUnknown, iid) ||
688 IsEqualIID(&IID_IWICBitmapSource, iid) ||
689 IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
691 *ppv = &This->IWICBitmapFrameDecode_iface;
693 else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
695 *ppv = &This->IWICMetadataBlockReader_iface;
700 return E_NOINTERFACE;
703 IUnknown_AddRef((IUnknown*)*ppv);
707 static ULONG WINAPI PngDecoder_Frame_AddRef(IWICBitmapFrameDecode *iface)
709 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
710 return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
713 static ULONG WINAPI PngDecoder_Frame_Release(IWICBitmapFrameDecode *iface)
715 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
716 return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
719 static HRESULT WINAPI PngDecoder_Frame_GetSize(IWICBitmapFrameDecode *iface,
720 UINT *puiWidth, UINT *puiHeight)
722 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
723 *puiWidth = This->width;
724 *puiHeight = This->height;
725 TRACE("(%p)->(%u,%u)\n", iface, *puiWidth, *puiHeight);
729 static HRESULT WINAPI PngDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode *iface,
730 WICPixelFormatGUID *pPixelFormat)
732 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
733 TRACE("(%p,%p)\n", iface, pPixelFormat);
735 memcpy(pPixelFormat, This->format, sizeof(GUID));
740 static HRESULT WINAPI PngDecoder_Frame_GetResolution(IWICBitmapFrameDecode *iface,
741 double *pDpiX, double *pDpiY)
743 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
744 png_uint_32 ret, xres, yres;
747 EnterCriticalSection(&This->lock);
749 ret = ppng_get_pHYs(This->png_ptr, This->info_ptr, &xres, &yres, &unit_type);
751 if (ret && unit_type == PNG_RESOLUTION_METER)
753 *pDpiX = xres * 0.0254;
754 *pDpiY = yres * 0.0254;
758 WARN("no pHYs block present\n");
759 *pDpiX = *pDpiY = 96.0;
762 LeaveCriticalSection(&This->lock);
764 TRACE("(%p)->(%0.2f,%0.2f)\n", iface, *pDpiX, *pDpiY);
769 static HRESULT WINAPI PngDecoder_Frame_CopyPalette(IWICBitmapFrameDecode *iface,
770 IWICPalette *pIPalette)
772 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
774 png_colorp png_palette;
776 WICColor palette[256];
779 png_color_16p trans_values;
783 TRACE("(%p,%p)\n", iface, pIPalette);
785 EnterCriticalSection(&This->lock);
787 ret = ppng_get_PLTE(This->png_ptr, This->info_ptr, &png_palette, &num_palette);
790 hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
794 if (num_palette > 256)
796 ERR("palette has %i colors?!\n", num_palette);
801 for (i=0; i<num_palette; i++)
803 palette[i] = (0xff000000|
804 png_palette[i].red << 16|
805 png_palette[i].green << 8|
806 png_palette[i].blue);
809 ret = ppng_get_tRNS(This->png_ptr, This->info_ptr, &trans, &num_trans, &trans_values);
812 for (i=0; i<num_trans; i++)
814 palette[trans[i]] = 0x00000000;
820 LeaveCriticalSection(&This->lock);
823 hr = IWICPalette_InitializeCustom(pIPalette, palette, num_palette);
828 static HRESULT WINAPI PngDecoder_Frame_CopyPixels(IWICBitmapFrameDecode *iface,
829 const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
831 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
832 TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
834 return copy_pixels(This->bpp, This->image_bits,
835 This->width, This->height, This->stride,
836 prc, cbStride, cbBufferSize, pbBuffer);
839 static HRESULT WINAPI PngDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
840 IWICMetadataQueryReader **ppIMetadataQueryReader)
842 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
846 static HRESULT WINAPI PngDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode *iface,
847 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
849 PngDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
850 png_charp name, profile;
852 int compression_type;
855 TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
857 EnterCriticalSection(&This->lock);
859 if (ppng_get_iCCP(This->png_ptr, This->info_ptr, &name, &compression_type, &profile, &len))
861 if (cCount && ppIColorContexts)
863 hr = IWICColorContext_InitializeFromMemory(*ppIColorContexts, (const BYTE *)profile, len);
866 LeaveCriticalSection(&This->lock);
875 LeaveCriticalSection(&This->lock);
880 static HRESULT WINAPI PngDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode *iface,
881 IWICBitmapSource **ppIThumbnail)
883 FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
887 static const IWICBitmapFrameDecodeVtbl PngDecoder_FrameVtbl = {
888 PngDecoder_Frame_QueryInterface,
889 PngDecoder_Frame_AddRef,
890 PngDecoder_Frame_Release,
891 PngDecoder_Frame_GetSize,
892 PngDecoder_Frame_GetPixelFormat,
893 PngDecoder_Frame_GetResolution,
894 PngDecoder_Frame_CopyPalette,
895 PngDecoder_Frame_CopyPixels,
896 PngDecoder_Frame_GetMetadataQueryReader,
897 PngDecoder_Frame_GetColorContexts,
898 PngDecoder_Frame_GetThumbnail
901 static HRESULT WINAPI PngDecoder_Block_QueryInterface(IWICMetadataBlockReader *iface, REFIID iid,
904 PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
905 return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
908 static ULONG WINAPI PngDecoder_Block_AddRef(IWICMetadataBlockReader *iface)
910 PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
911 return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
914 static ULONG WINAPI PngDecoder_Block_Release(IWICMetadataBlockReader *iface)
916 PngDecoder *This = impl_from_IWICMetadataBlockReader(iface);
917 return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
920 static HRESULT WINAPI PngDecoder_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
921 GUID *pguidContainerFormat)
923 if (!pguidContainerFormat) return E_INVALIDARG;
924 memcpy(pguidContainerFormat, &GUID_ContainerFormatPng, sizeof(GUID));
928 static HRESULT WINAPI PngDecoder_Block_GetCount(IWICMetadataBlockReader *iface,
931 FIXME("%p,%p: stub\n", iface, pcCount);
935 static HRESULT WINAPI PngDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
936 UINT nIndex, IWICMetadataReader **ppIMetadataReader)
938 FIXME("%p,%d,%p\n", iface, nIndex, ppIMetadataReader);
942 static HRESULT WINAPI PngDecoder_Block_GetEnumerator(IWICMetadataBlockReader *iface,
943 IEnumUnknown **ppIEnumMetadata)
945 FIXME("%p,%p\n", iface, ppIEnumMetadata);
949 static const IWICMetadataBlockReaderVtbl PngDecoder_BlockVtbl = {
950 PngDecoder_Block_QueryInterface,
951 PngDecoder_Block_AddRef,
952 PngDecoder_Block_Release,
953 PngDecoder_Block_GetContainerFormat,
954 PngDecoder_Block_GetCount,
955 PngDecoder_Block_GetReaderByIndex,
956 PngDecoder_Block_GetEnumerator,
959 HRESULT PngDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
964 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
968 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
970 if (!libpng_handle && !load_libpng())
972 ERR("Failed reading PNG because unable to find %s\n",SONAME_LIBPNG);
976 This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngDecoder));
977 if (!This) return E_OUTOFMEMORY;
979 This->IWICBitmapDecoder_iface.lpVtbl = &PngDecoder_Vtbl;
980 This->IWICBitmapFrameDecode_iface.lpVtbl = &PngDecoder_FrameVtbl;
981 This->IWICMetadataBlockReader_iface.lpVtbl = &PngDecoder_BlockVtbl;
983 This->png_ptr = NULL;
984 This->info_ptr = NULL;
985 This->end_info = NULL;
986 This->initialized = FALSE;
987 This->image_bits = NULL;
988 InitializeCriticalSection(&This->lock);
989 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngDecoder.lock");
991 ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
992 IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
997 struct png_pixelformat {
998 const WICPixelFormatGUID *guid;
1006 static const struct png_pixelformat formats[] = {
1007 {&GUID_WICPixelFormat24bppBGR, 24, 8, PNG_COLOR_TYPE_RGB, 0, 1},
1008 {&GUID_WICPixelFormatBlackWhite, 1, 1, PNG_COLOR_TYPE_GRAY, 0, 0},
1009 {&GUID_WICPixelFormat2bppGray, 2, 2, PNG_COLOR_TYPE_GRAY, 0, 0},
1010 {&GUID_WICPixelFormat4bppGray, 4, 4, PNG_COLOR_TYPE_GRAY, 0, 0},
1011 {&GUID_WICPixelFormat8bppGray, 8, 8, PNG_COLOR_TYPE_GRAY, 0, 0},
1012 {&GUID_WICPixelFormat16bppGray, 16, 16, PNG_COLOR_TYPE_GRAY, 0, 0},
1013 {&GUID_WICPixelFormat32bppBGR, 32, 8, PNG_COLOR_TYPE_RGB, 1, 1},
1014 {&GUID_WICPixelFormat32bppBGRA, 32, 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 1},
1015 {&GUID_WICPixelFormat48bppRGB, 48, 16, PNG_COLOR_TYPE_RGB, 0, 0},
1016 {&GUID_WICPixelFormat64bppRGBA, 64, 16, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0},
1020 typedef struct PngEncoder {
1021 IWICBitmapEncoder IWICBitmapEncoder_iface;
1022 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
1025 png_structp png_ptr;
1028 BOOL frame_initialized;
1029 const struct png_pixelformat *format;
1034 BOOL frame_committed;
1036 CRITICAL_SECTION lock;
1039 static inline PngEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
1041 return CONTAINING_RECORD(iface, PngEncoder, IWICBitmapEncoder_iface);
1044 static inline PngEncoder *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
1046 return CONTAINING_RECORD(iface, PngEncoder, IWICBitmapFrameEncode_iface);
1049 static HRESULT WINAPI PngFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
1052 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1053 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1055 if (!ppv) return E_INVALIDARG;
1057 if (IsEqualIID(&IID_IUnknown, iid) ||
1058 IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
1060 *ppv = &This->IWICBitmapFrameEncode_iface;
1065 return E_NOINTERFACE;
1068 IUnknown_AddRef((IUnknown*)*ppv);
1072 static ULONG WINAPI PngFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
1074 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1075 return IWICBitmapEncoder_AddRef(&This->IWICBitmapEncoder_iface);
1078 static ULONG WINAPI PngFrameEncode_Release(IWICBitmapFrameEncode *iface)
1080 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1081 return IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
1084 static HRESULT WINAPI PngFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
1085 IPropertyBag2 *pIEncoderOptions)
1087 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1088 TRACE("(%p,%p)\n", iface, pIEncoderOptions);
1090 EnterCriticalSection(&This->lock);
1092 if (This->frame_initialized)
1094 LeaveCriticalSection(&This->lock);
1095 return WINCODEC_ERR_WRONGSTATE;
1098 This->frame_initialized = TRUE;
1100 LeaveCriticalSection(&This->lock);
1105 static HRESULT WINAPI PngFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
1106 UINT uiWidth, UINT uiHeight)
1108 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1109 TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
1111 EnterCriticalSection(&This->lock);
1113 if (!This->frame_initialized || This->info_written)
1115 LeaveCriticalSection(&This->lock);
1116 return WINCODEC_ERR_WRONGSTATE;
1119 This->width = uiWidth;
1120 This->height = uiHeight;
1122 LeaveCriticalSection(&This->lock);
1127 static HRESULT WINAPI PngFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
1128 double dpiX, double dpiY)
1130 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1131 TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
1133 EnterCriticalSection(&This->lock);
1135 if (!This->frame_initialized || This->info_written)
1137 LeaveCriticalSection(&This->lock);
1138 return WINCODEC_ERR_WRONGSTATE;
1144 LeaveCriticalSection(&This->lock);
1149 static HRESULT WINAPI PngFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
1150 WICPixelFormatGUID *pPixelFormat)
1152 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1154 TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
1156 EnterCriticalSection(&This->lock);
1158 if (!This->frame_initialized || This->info_written)
1160 LeaveCriticalSection(&This->lock);
1161 return WINCODEC_ERR_WRONGSTATE;
1164 for (i=0; formats[i].guid; i++)
1166 if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
1170 if (!formats[i].guid) i = 0;
1172 This->format = &formats[i];
1173 memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
1175 LeaveCriticalSection(&This->lock);
1180 static HRESULT WINAPI PngFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
1181 UINT cCount, IWICColorContext **ppIColorContext)
1183 FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1187 static HRESULT WINAPI PngFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
1188 IWICPalette *pIPalette)
1190 FIXME("(%p,%p): stub\n", iface, pIPalette);
1191 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1194 static HRESULT WINAPI PngFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
1195 IWICBitmapSource *pIThumbnail)
1197 FIXME("(%p,%p): stub\n", iface, pIThumbnail);
1198 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1201 static HRESULT WINAPI PngFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
1202 UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
1204 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1205 png_byte **row_pointers=NULL;
1208 TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
1210 EnterCriticalSection(&This->lock);
1212 if (!This->frame_initialized || !This->width || !This->height || !This->format)
1214 LeaveCriticalSection(&This->lock);
1215 return WINCODEC_ERR_WRONGSTATE;
1218 if (lineCount == 0 || lineCount + This->lines_written > This->height)
1220 LeaveCriticalSection(&This->lock);
1221 return E_INVALIDARG;
1224 /* set up setjmp/longjmp error handling */
1227 LeaveCriticalSection(&This->lock);
1228 HeapFree(GetProcessHeap(), 0, row_pointers);
1231 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
1233 if (!This->info_written)
1235 ppng_set_IHDR(This->png_ptr, This->info_ptr, This->width, This->height,
1236 This->format->bit_depth, This->format->color_type, PNG_INTERLACE_NONE,
1237 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1239 if (This->xres != 0.0 && This->yres != 0.0)
1241 ppng_set_pHYs(This->png_ptr, This->info_ptr, (This->xres+0.0127) / 0.0254,
1242 (This->yres+0.0127) / 0.0254, PNG_RESOLUTION_METER);
1245 ppng_write_info(This->png_ptr, This->info_ptr);
1247 if (This->format->remove_filler)
1248 ppng_set_filler(This->png_ptr, 0, PNG_FILLER_AFTER);
1250 if (This->format->swap_rgb)
1251 ppng_set_bgr(This->png_ptr);
1253 This->info_written = TRUE;
1256 row_pointers = HeapAlloc(GetProcessHeap(), 0, lineCount * sizeof(png_byte*));
1259 LeaveCriticalSection(&This->lock);
1260 return E_OUTOFMEMORY;
1263 for (i=0; i<lineCount; i++)
1264 row_pointers[i] = pbPixels + cbStride * i;
1266 ppng_write_rows(This->png_ptr, row_pointers, lineCount);
1267 This->lines_written += lineCount;
1269 LeaveCriticalSection(&This->lock);
1271 HeapFree(GetProcessHeap(), 0, row_pointers);
1276 static HRESULT WINAPI PngFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
1277 IWICBitmapSource *pIBitmapSource, WICRect *prc)
1279 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1282 WICPixelFormatGUID guid;
1285 TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
1287 if (!This->frame_initialized || !This->width || !This->height)
1288 return WINCODEC_ERR_WRONGSTATE;
1292 hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1293 if (FAILED(hr)) return hr;
1294 hr = IWICBitmapFrameEncode_SetPixelFormat(iface, &guid);
1295 if (FAILED(hr)) return hr;
1298 hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
1299 if (FAILED(hr)) return hr;
1300 if (memcmp(&guid, This->format->guid, sizeof(GUID)) != 0)
1302 /* FIXME: should use WICConvertBitmapSource to convert */
1303 ERR("format %s unsupported\n", debugstr_guid(&guid));
1307 if (This->xres == 0.0 || This->yres == 0.0)
1310 hr = IWICBitmapSource_GetResolution(pIBitmapSource, &xres, &yres);
1311 if (FAILED(hr)) return hr;
1312 hr = IWICBitmapFrameEncode_SetResolution(iface, xres, yres);
1313 if (FAILED(hr)) return hr;
1319 hr = IWICBitmapSource_GetSize(pIBitmapSource, &width, &height);
1320 if (FAILED(hr)) return hr;
1328 if (prc->Width != This->width) return E_INVALIDARG;
1330 stride = (This->format->bpp * This->width + 7)/8;
1332 pixeldata = HeapAlloc(GetProcessHeap(), 0, stride * prc->Height);
1333 if (!pixeldata) return E_OUTOFMEMORY;
1335 hr = IWICBitmapSource_CopyPixels(pIBitmapSource, prc, stride,
1336 stride*prc->Height, pixeldata);
1340 hr = IWICBitmapFrameEncode_WritePixels(iface, prc->Height, stride,
1341 stride*prc->Height, pixeldata);
1344 HeapFree(GetProcessHeap(), 0, pixeldata);
1349 static HRESULT WINAPI PngFrameEncode_Commit(IWICBitmapFrameEncode *iface)
1351 PngEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
1353 TRACE("(%p)\n", iface);
1355 EnterCriticalSection(&This->lock);
1357 if (!This->info_written || This->lines_written != This->height || This->frame_committed)
1359 LeaveCriticalSection(&This->lock);
1360 return WINCODEC_ERR_WRONGSTATE;
1363 /* set up setjmp/longjmp error handling */
1366 LeaveCriticalSection(&This->lock);
1369 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
1371 ppng_write_end(This->png_ptr, This->info_ptr);
1373 This->frame_committed = TRUE;
1375 LeaveCriticalSection(&This->lock);
1380 static HRESULT WINAPI PngFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
1381 IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1383 FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
1387 static const IWICBitmapFrameEncodeVtbl PngEncoder_FrameVtbl = {
1388 PngFrameEncode_QueryInterface,
1389 PngFrameEncode_AddRef,
1390 PngFrameEncode_Release,
1391 PngFrameEncode_Initialize,
1392 PngFrameEncode_SetSize,
1393 PngFrameEncode_SetResolution,
1394 PngFrameEncode_SetPixelFormat,
1395 PngFrameEncode_SetColorContexts,
1396 PngFrameEncode_SetPalette,
1397 PngFrameEncode_SetThumbnail,
1398 PngFrameEncode_WritePixels,
1399 PngFrameEncode_WriteSource,
1400 PngFrameEncode_Commit,
1401 PngFrameEncode_GetMetadataQueryWriter
1404 static HRESULT WINAPI PngEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
1407 PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1408 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1410 if (!ppv) return E_INVALIDARG;
1412 if (IsEqualIID(&IID_IUnknown, iid) ||
1413 IsEqualIID(&IID_IWICBitmapEncoder, iid))
1415 *ppv = &This->IWICBitmapEncoder_iface;
1420 return E_NOINTERFACE;
1423 IUnknown_AddRef((IUnknown*)*ppv);
1427 static ULONG WINAPI PngEncoder_AddRef(IWICBitmapEncoder *iface)
1429 PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1430 ULONG ref = InterlockedIncrement(&This->ref);
1432 TRACE("(%p) refcount=%u\n", iface, ref);
1437 static ULONG WINAPI PngEncoder_Release(IWICBitmapEncoder *iface)
1439 PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1440 ULONG ref = InterlockedDecrement(&This->ref);
1442 TRACE("(%p) refcount=%u\n", iface, ref);
1446 This->lock.DebugInfo->Spare[0] = 0;
1447 DeleteCriticalSection(&This->lock);
1449 ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1451 IStream_Release(This->stream);
1452 HeapFree(GetProcessHeap(), 0, This);
1458 static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1460 PngEncoder *This = ppng_get_io_ptr(png_ptr);
1464 hr = IStream_Write(This->stream, data, length, &byteswritten);
1465 if (FAILED(hr) || byteswritten != length)
1467 ppng_error(png_ptr, "failed writing data");
1471 static void user_flush(png_structp png_ptr)
1475 static HRESULT WINAPI PngEncoder_Initialize(IWICBitmapEncoder *iface,
1476 IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
1478 PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1481 TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
1483 EnterCriticalSection(&This->lock);
1487 LeaveCriticalSection(&This->lock);
1488 return WINCODEC_ERR_WRONGSTATE;
1491 /* initialize libpng */
1492 This->png_ptr = ppng_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1495 LeaveCriticalSection(&This->lock);
1499 This->info_ptr = ppng_create_info_struct(This->png_ptr);
1500 if (!This->info_ptr)
1502 ppng_destroy_write_struct(&This->png_ptr, NULL);
1503 This->png_ptr = NULL;
1504 LeaveCriticalSection(&This->lock);
1508 IStream_AddRef(pIStream);
1509 This->stream = pIStream;
1511 /* set up setjmp/longjmp error handling */
1514 ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
1515 This->png_ptr = NULL;
1516 IStream_Release(This->stream);
1517 This->stream = NULL;
1518 LeaveCriticalSection(&This->lock);
1521 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
1523 /* set up custom i/o handling */
1524 ppng_set_write_fn(This->png_ptr, This, user_write_data, user_flush);
1526 LeaveCriticalSection(&This->lock);
1531 static HRESULT WINAPI PngEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
1532 GUID *pguidContainerFormat)
1534 FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
1538 static HRESULT WINAPI PngEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
1539 IWICBitmapEncoderInfo **ppIEncoderInfo)
1541 FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
1545 static HRESULT WINAPI PngEncoder_SetColorContexts(IWICBitmapEncoder *iface,
1546 UINT cCount, IWICColorContext **ppIColorContext)
1548 FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1552 static HRESULT WINAPI PngEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
1554 TRACE("(%p,%p)\n", iface, pIPalette);
1555 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1558 static HRESULT WINAPI PngEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
1560 TRACE("(%p,%p)\n", iface, pIThumbnail);
1561 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1564 static HRESULT WINAPI PngEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
1566 TRACE("(%p,%p)\n", iface, pIPreview);
1567 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1570 static HRESULT WINAPI PngEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
1571 IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
1573 PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1575 TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
1577 EnterCriticalSection(&This->lock);
1579 if (This->frame_count != 0)
1581 LeaveCriticalSection(&This->lock);
1582 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1587 LeaveCriticalSection(&This->lock);
1588 return WINCODEC_ERR_NOTINITIALIZED;
1591 hr = CreatePropertyBag2(ppIEncoderOptions);
1594 LeaveCriticalSection(&This->lock);
1598 This->frame_count = 1;
1600 LeaveCriticalSection(&This->lock);
1602 IWICBitmapEncoder_AddRef(iface);
1603 *ppIFrameEncode = &This->IWICBitmapFrameEncode_iface;
1608 static HRESULT WINAPI PngEncoder_Commit(IWICBitmapEncoder *iface)
1610 PngEncoder *This = impl_from_IWICBitmapEncoder(iface);
1611 TRACE("(%p)\n", iface);
1613 EnterCriticalSection(&This->lock);
1615 if (!This->frame_committed || This->committed)
1617 LeaveCriticalSection(&This->lock);
1618 return WINCODEC_ERR_WRONGSTATE;
1621 This->committed = TRUE;
1623 LeaveCriticalSection(&This->lock);
1628 static HRESULT WINAPI PngEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
1629 IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1631 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
1635 static const IWICBitmapEncoderVtbl PngEncoder_Vtbl = {
1636 PngEncoder_QueryInterface,
1639 PngEncoder_Initialize,
1640 PngEncoder_GetContainerFormat,
1641 PngEncoder_GetEncoderInfo,
1642 PngEncoder_SetColorContexts,
1643 PngEncoder_SetPalette,
1644 PngEncoder_SetThumbnail,
1645 PngEncoder_SetPreview,
1646 PngEncoder_CreateNewFrame,
1648 PngEncoder_GetMetadataQueryWriter
1651 HRESULT PngEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1656 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1660 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1662 if (!libpng_handle && !load_libpng())
1664 ERR("Failed writing PNG because unable to find %s\n",SONAME_LIBPNG);
1668 This = HeapAlloc(GetProcessHeap(), 0, sizeof(PngEncoder));
1669 if (!This) return E_OUTOFMEMORY;
1671 This->IWICBitmapEncoder_iface.lpVtbl = &PngEncoder_Vtbl;
1672 This->IWICBitmapFrameEncode_iface.lpVtbl = &PngEncoder_FrameVtbl;
1674 This->png_ptr = NULL;
1675 This->info_ptr = NULL;
1676 This->stream = NULL;
1677 This->frame_count = 0;
1678 This->frame_initialized = FALSE;
1679 This->format = NULL;
1680 This->info_written = FALSE;
1685 This->lines_written = 0;
1686 This->frame_committed = FALSE;
1687 This->committed = FALSE;
1688 InitializeCriticalSection(&This->lock);
1689 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PngEncoder.lock");
1691 ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
1692 IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
1697 #else /* !HAVE_PNG_H */
1699 HRESULT PngDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1701 ERR("Trying to load PNG picture, but PNG support is not compiled in.\n");
1705 HRESULT PngEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1707 ERR("Trying to save PNG picture, but PNG support is not compiled in.\n");