?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winevulkan: Update to VK spec version 1.2.195.
[wine.git] / dlls / windowscodecs / libpng.c
blob6496fa364362372b137bdd8281bea6a776782801
1 /*
2 * Copyright 2016 Dmitry Timoshkov
3 * Copyright 2020 Esme Povirk
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #if 0
21 #pragma makedep unix
22 #endif
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #ifdef SONAME_LIBPNG
29 #include <png.h>
30 #endif
31
32 #define NONAMELESSUNION
33
34 #include "ntstatus.h"
35 #define WIN32_NO_STATUS
36 #include "windef.h"
37 #include "winternl.h"
38 #include "winbase.h"
39 #include "objbase.h"
40
41 #include "wincodecs_private.h"
42
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
46
47 #ifdef SONAME_LIBPNG
48
49 static void *libpng_handle;
50 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
51 MAKE_FUNCPTR(png_create_info_struct);
52 MAKE_FUNCPTR(png_create_read_struct);
53 MAKE_FUNCPTR(png_create_write_struct);
54 MAKE_FUNCPTR(png_destroy_read_struct);
55 MAKE_FUNCPTR(png_destroy_write_struct);
56 MAKE_FUNCPTR(png_error);
57 MAKE_FUNCPTR(png_get_bit_depth);
58 MAKE_FUNCPTR(png_get_color_type);
59 MAKE_FUNCPTR(png_get_error_ptr);
60 MAKE_FUNCPTR(png_get_iCCP);
61 MAKE_FUNCPTR(png_get_image_height);
62 MAKE_FUNCPTR(png_get_image_width);
63 MAKE_FUNCPTR(png_get_io_ptr);
64 MAKE_FUNCPTR(png_get_pHYs);
65 MAKE_FUNCPTR(png_get_PLTE);
66 MAKE_FUNCPTR(png_get_tRNS);
67 MAKE_FUNCPTR(png_read_image);
68 MAKE_FUNCPTR(png_read_info);
69 MAKE_FUNCPTR(png_set_bgr);
70 MAKE_FUNCPTR(png_set_crc_action);
71 MAKE_FUNCPTR(png_set_error_fn);
72 MAKE_FUNCPTR(png_set_filler);
73 MAKE_FUNCPTR(png_set_filter);
74 MAKE_FUNCPTR(png_set_gray_to_rgb);
75 MAKE_FUNCPTR(png_set_IHDR);
76 MAKE_FUNCPTR(png_set_interlace_handling);
77 MAKE_FUNCPTR(png_set_pHYs);
78 MAKE_FUNCPTR(png_set_PLTE);
79 MAKE_FUNCPTR(png_set_read_fn);
80 MAKE_FUNCPTR(png_set_swap);
81 MAKE_FUNCPTR(png_set_tRNS);
82 MAKE_FUNCPTR(png_set_tRNS_to_alpha);
83 MAKE_FUNCPTR(png_set_write_fn);
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 CRITICAL_SECTION init_png_cs;
90 static CRITICAL_SECTION_DEBUG init_png_cs_debug =
91 {
92 0, 0, &init_png_cs,
93 { &init_png_cs_debug.ProcessLocksList,
94 &init_png_cs_debug.ProcessLocksList },
95 0, 0, { (DWORD_PTR)(__FILE__ ": init_png_cs") }
96 };
97 static CRITICAL_SECTION init_png_cs = { &init_png_cs_debug, -1, 0, 0, 0, 0 };
98
99 static void *load_libpng(void)
100 {
101 void *result;
102
103 RtlEnterCriticalSection(&init_png_cs);
104
105 if(!libpng_handle && (libpng_handle = dlopen(SONAME_LIBPNG, RTLD_NOW)) != NULL) {
106
107 #define LOAD_FUNCPTR(f) \
108 if((p##f = dlsym(libpng_handle, #f)) == NULL) { \
109 libpng_handle = NULL; \
110 RtlLeaveCriticalSection(&init_png_cs); \
111 return NULL; \
112 }
113 LOAD_FUNCPTR(png_create_info_struct);
114 LOAD_FUNCPTR(png_create_read_struct);
115 LOAD_FUNCPTR(png_create_write_struct);
116 LOAD_FUNCPTR(png_destroy_read_struct);
117 LOAD_FUNCPTR(png_destroy_write_struct);
118 LOAD_FUNCPTR(png_error);
119 LOAD_FUNCPTR(png_get_bit_depth);
120 LOAD_FUNCPTR(png_get_color_type);
121 LOAD_FUNCPTR(png_get_error_ptr);
122 LOAD_FUNCPTR(png_get_image_height);
123 LOAD_FUNCPTR(png_get_image_width);
124 LOAD_FUNCPTR(png_get_iCCP);
125 LOAD_FUNCPTR(png_get_io_ptr);
126 LOAD_FUNCPTR(png_get_pHYs);
127 LOAD_FUNCPTR(png_get_PLTE);
128 LOAD_FUNCPTR(png_get_tRNS);
129 LOAD_FUNCPTR(png_read_image);
130 LOAD_FUNCPTR(png_read_info);
131 LOAD_FUNCPTR(png_set_bgr);
132 LOAD_FUNCPTR(png_set_crc_action);
133 LOAD_FUNCPTR(png_set_error_fn);
134 LOAD_FUNCPTR(png_set_filler);
135 LOAD_FUNCPTR(png_set_filter);
136 LOAD_FUNCPTR(png_set_gray_to_rgb);
137 LOAD_FUNCPTR(png_set_IHDR);
138 LOAD_FUNCPTR(png_set_interlace_handling);
139 LOAD_FUNCPTR(png_set_pHYs);
140 LOAD_FUNCPTR(png_set_PLTE);
141 LOAD_FUNCPTR(png_set_read_fn);
142 LOAD_FUNCPTR(png_set_swap);
143 LOAD_FUNCPTR(png_set_tRNS);
144 LOAD_FUNCPTR(png_set_tRNS_to_alpha);
145 LOAD_FUNCPTR(png_set_write_fn);
146 LOAD_FUNCPTR(png_write_end);
147 LOAD_FUNCPTR(png_write_info);
148 LOAD_FUNCPTR(png_write_rows);
149
150 #undef LOAD_FUNCPTR
151 }
152
153 result = libpng_handle;
154
155 RtlLeaveCriticalSection(&init_png_cs);
156
157 return result;
158 }
159
160 struct png_decoder
161 {
162 struct decoder decoder;
163 IStream *stream;
164 struct decoder_frame decoder_frame;
165 UINT stride;
166 BYTE *image_bits;
167 BYTE *color_profile;
168 DWORD color_profile_len;
169 };
170
171 static inline struct png_decoder *impl_from_decoder(struct decoder* iface)
172 {
173 return CONTAINING_RECORD(iface, struct png_decoder, decoder);
174 }
175
176 static void user_error_fn(png_structp png_ptr, png_const_charp error_message)
177 {
178 jmp_buf *pjmpbuf;
179
180 /* This uses setjmp/longjmp just like the default. We can't use the
181 * default because there's no way to access the jmp buffer in the png_struct
182 * that works in 1.2 and 1.4 and allows us to dynamically load libpng. */
183 WARN("PNG error: %s\n", debugstr_a(error_message));
184 pjmpbuf = ppng_get_error_ptr(png_ptr);
185 longjmp(*pjmpbuf, 1);
186 }
187
188 static void user_warning_fn(png_structp png_ptr, png_const_charp warning_message)
189 {
190 WARN("PNG warning: %s\n", debugstr_a(warning_message));
191 }
192
193 static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
194 {
195 IStream *stream = ppng_get_io_ptr(png_ptr);
196 HRESULT hr;
197 ULONG bytesread;
198
199 hr = stream_read(stream, data, length, &bytesread);
200 if (FAILED(hr) || bytesread != length)
201 {
202 ppng_error(png_ptr, "failed reading data");
203 }
204 }
205
206 static HRESULT CDECL png_decoder_initialize(struct decoder *iface, IStream *stream, struct decoder_stat *st)
207 {
208 struct png_decoder *This = impl_from_decoder(iface);
209 png_structp png_ptr;
210 png_infop info_ptr;
211 jmp_buf jmpbuf;
212 HRESULT hr = E_FAIL;
213 int color_type, bit_depth;
214 png_bytep trans;
215 int num_trans;
216 png_uint_32 transparency;
217 png_color_16p trans_values;
218 png_uint_32 ret, xres, yres;
219 int unit_type;
220 png_colorp png_palette;
221 int num_palette;
222 int i;
223 UINT image_size;
224 png_bytep *row_pointers=NULL;
225 png_charp cp_name;
226 png_bytep cp_profile;
227 png_uint_32 cp_len;
228 int cp_compression;
229
230 png_ptr = ppng_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
231 if (!png_ptr)
232 {
233 return E_FAIL;
234 }
235
236 info_ptr = ppng_create_info_struct(png_ptr);
237 if (!info_ptr)
238 {
239 ppng_destroy_read_struct(&png_ptr, NULL, NULL);
240 return E_FAIL;
241 }
242
243 /* set up setjmp/longjmp error handling */
244 if (setjmp(jmpbuf))
245 {
246 hr = WINCODEC_ERR_UNKNOWNIMAGEFORMAT;
247 goto end;
248 }
249 ppng_set_error_fn(png_ptr, jmpbuf, user_error_fn, user_warning_fn);
250 ppng_set_crc_action(png_ptr, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
251
252 /* seek to the start of the stream */
253 hr = stream_seek(stream, 0, STREAM_SEEK_SET, NULL);
254 if (FAILED(hr))
255 {
256 goto end;
257 }
258
259 /* set up custom i/o handling */
260 ppng_set_read_fn(png_ptr, stream, user_read_data);
261
262 /* read the header */
263 ppng_read_info(png_ptr, info_ptr);
264
265 /* choose a pixel format */
266 color_type = ppng_get_color_type(png_ptr, info_ptr);
267 bit_depth = ppng_get_bit_depth(png_ptr, info_ptr);
268
269 /* PNGs with bit-depth greater than 8 are network byte order. Windows does not expect this. */
270 if (bit_depth > 8)
271 ppng_set_swap(png_ptr);
272
273 /* check for color-keyed alpha */
274 transparency = ppng_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, &trans_values);
275 if (!transparency)
276 num_trans = 0;
277
278 if (transparency && (color_type == PNG_COLOR_TYPE_RGB ||
279 (color_type == PNG_COLOR_TYPE_GRAY && bit_depth == 16)))
280 {
281 /* expand to RGBA */
282 if (color_type == PNG_COLOR_TYPE_GRAY)
283 ppng_set_gray_to_rgb(png_ptr);
284 ppng_set_tRNS_to_alpha(png_ptr);
285 color_type = PNG_COLOR_TYPE_RGB_ALPHA;
286 }
287
288 switch (color_type)
289 {
290 case PNG_COLOR_TYPE_GRAY_ALPHA:
291 /* WIC does not support grayscale alpha formats so use RGBA */
292 ppng_set_gray_to_rgb(png_ptr);
293 /* fall through */
294 case PNG_COLOR_TYPE_RGB_ALPHA:
295 This->decoder_frame.bpp = bit_depth * 4;
296 switch (bit_depth)
297 {
298 case 8:
299 ppng_set_bgr(png_ptr);
300 This->decoder_frame.pixel_format = GUID_WICPixelFormat32bppBGRA;
301 break;
302 case 16: This->decoder_frame.pixel_format = GUID_WICPixelFormat64bppRGBA; break;
303 default:
304 ERR("invalid RGBA bit depth: %i\n", bit_depth);
305 hr = E_FAIL;
306 goto end;
307 }
308 break;
309 case PNG_COLOR_TYPE_GRAY:
310 This->decoder_frame.bpp = bit_depth;
311 if (!transparency)
312 {
313 switch (bit_depth)
314 {
315 case 1: This->decoder_frame.pixel_format = GUID_WICPixelFormatBlackWhite; break;
316 case 2: This->decoder_frame.pixel_format = GUID_WICPixelFormat2bppGray; break;
317 case 4: This->decoder_frame.pixel_format = GUID_WICPixelFormat4bppGray; break;
318 case 8: This->decoder_frame.pixel_format = GUID_WICPixelFormat8bppGray; break;
319 case 16: This->decoder_frame.pixel_format = GUID_WICPixelFormat16bppGray; break;
320 default:
321 ERR("invalid grayscale bit depth: %i\n", bit_depth);
322 hr = E_FAIL;
323 goto end;
324 }
325 break;
326 }
327 /* else fall through */
328 case PNG_COLOR_TYPE_PALETTE:
329 This->decoder_frame.bpp = bit_depth;
330 switch (bit_depth)
331 {
332 case 1: This->decoder_frame.pixel_format = GUID_WICPixelFormat1bppIndexed; break;
333 case 2: This->decoder_frame.pixel_format = GUID_WICPixelFormat2bppIndexed; break;
334 case 4: This->decoder_frame.pixel_format = GUID_WICPixelFormat4bppIndexed; break;
335 case 8: This->decoder_frame.pixel_format = GUID_WICPixelFormat8bppIndexed; break;
336 default:
337 ERR("invalid indexed color bit depth: %i\n", bit_depth);
338 hr = E_FAIL;
339 goto end;
340 }
341 break;
342 case PNG_COLOR_TYPE_RGB:
343 This->decoder_frame.bpp = bit_depth * 3;
344 switch (bit_depth)
345 {
346 case 8:
347 ppng_set_bgr(png_ptr);
348 This->decoder_frame.pixel_format = GUID_WICPixelFormat24bppBGR;
349 break;
350 case 16: This->decoder_frame.pixel_format = GUID_WICPixelFormat48bppRGB; break;
351 default:
352 ERR("invalid RGB color bit depth: %i\n", bit_depth);
353 hr = E_FAIL;
354 goto end;
355 }
356 break;
357 default:
358 ERR("invalid color type %i\n", color_type);
359 hr = E_FAIL;
360 goto end;
361 }
362
363 This->decoder_frame.width = ppng_get_image_width(png_ptr, info_ptr);
364 This->decoder_frame.height = ppng_get_image_height(png_ptr, info_ptr);
365
366 ret = ppng_get_pHYs(png_ptr, info_ptr, &xres, &yres, &unit_type);
367
368 if (ret && unit_type == PNG_RESOLUTION_METER)
369 {
370 This->decoder_frame.dpix = xres * 0.0254;
371 This->decoder_frame.dpiy = yres * 0.0254;
372 }
373 else
374 {
375 WARN("no pHYs block present\n");
376 This->decoder_frame.dpix = This->decoder_frame.dpiy = 96.0;
377 }
378
379 ret = ppng_get_iCCP(png_ptr, info_ptr, &cp_name, &cp_compression, &cp_profile, &cp_len);
380 if (ret)
381 {
382 This->decoder_frame.num_color_contexts = 1;
383 This->color_profile_len = cp_len;
384 This->color_profile = malloc(cp_len);
385 if (!This->color_profile)
386 {
387 hr = E_OUTOFMEMORY;
388 goto end;
389 }
390 memcpy(This->color_profile, cp_profile, cp_len);
391 }
392 else
393 This->decoder_frame.num_color_contexts = 0;
394
395 if (color_type == PNG_COLOR_TYPE_PALETTE)
396 {
397 ret = ppng_get_PLTE(png_ptr, info_ptr, &png_palette, &num_palette);
398 if (!ret)
399 {
400 ERR("paletted image with no PLTE chunk\n");
401 hr = E_FAIL;
402 goto end;
403 }
404
405 if (num_palette > 256)
406 {
407 ERR("palette has %i colors?!\n", num_palette);
408 hr = E_FAIL;
409 goto end;
410 }
411
412 This->decoder_frame.num_colors = num_palette;
413 for (i=0; i<num_palette; i++)
414 {
415 BYTE alpha = (i < num_trans) ? trans[i] : 0xff;
416 This->decoder_frame.palette[i] = (alpha << 24 |
417 png_palette[i].red << 16|
418 png_palette[i].green << 8|
419 png_palette[i].blue);
420 }
421 }
422 else if (color_type == PNG_COLOR_TYPE_GRAY && transparency && bit_depth <= 8) {
423 num_palette = 1 << bit_depth;
424
425 This->decoder_frame.num_colors = num_palette;
426 for (i=0; i<num_palette; i++)
427 {
428 BYTE alpha = (i == trans_values[0].gray) ? 0 : 0xff;
429 BYTE val = i * 255 / (num_palette - 1);
430 This->decoder_frame.palette[i] = (alpha << 24 | val << 16 | val << 8 | val);
431 }
432 }
433 else
434 {
435 This->decoder_frame.num_colors = 0;
436 }
437
438 This->stride = (This->decoder_frame.width * This->decoder_frame.bpp + 7) / 8;
439 image_size = This->stride * This->decoder_frame.height;
440
441 This->image_bits = malloc(image_size);
442 if (!This->image_bits)
443 {
444 hr = E_OUTOFMEMORY;
445 goto end;
446 }
447
448 row_pointers = malloc(sizeof(png_bytep)*This->decoder_frame.height);
449 if (!row_pointers)
450 {
451 hr = E_OUTOFMEMORY;
452 goto end;
453 }
454
455 for (i=0; i<This->decoder_frame.height; i++)
456 row_pointers[i] = This->image_bits + i * This->stride;
457
458 ppng_read_image(png_ptr, row_pointers);
459
460 free(row_pointers);
461 row_pointers = NULL;
462
463 /* png_read_end intentionally not called to not seek to the end of the file */
464
465 st->flags = WICBitmapDecoderCapabilityCanDecodeAllImages |
466 WICBitmapDecoderCapabilityCanDecodeSomeImages |
467 WICBitmapDecoderCapabilityCanEnumerateMetadata;
468 st->frame_count = 1;
469
470 This->stream = stream;
471
472 hr = S_OK;
473
474 end:
475 ppng_destroy_read_struct(&png_ptr, &info_ptr, NULL);
476 free(row_pointers);
477 if (FAILED(hr))
478 {
479 free(This->image_bits);
480 This->image_bits = NULL;
481 free(This->color_profile);
482 This->color_profile = NULL;
483 }
484 return hr;
485 }
486
487 static HRESULT CDECL png_decoder_get_frame_info(struct decoder *iface, UINT frame, struct decoder_frame *info)
488 {
489 struct png_decoder *This = impl_from_decoder(iface);
490 *info = This->decoder_frame;
491 return S_OK;
492 }
493
494 static HRESULT CDECL png_decoder_copy_pixels(struct decoder *iface, UINT frame,
495 const WICRect *prc, UINT stride, UINT buffersize, BYTE *buffer)
496 {
497 struct png_decoder *This = impl_from_decoder(iface);
498
499 return copy_pixels(This->decoder_frame.bpp, This->image_bits,
500 This->decoder_frame.width, This->decoder_frame.height, This->stride,
501 prc, stride, buffersize, buffer);
502 }
503
504 static HRESULT CDECL png_decoder_get_metadata_blocks(struct decoder* iface,
505 UINT frame, UINT *count, struct decoder_block **blocks)
506 {
507 struct png_decoder *This = impl_from_decoder(iface);
508 HRESULT hr;
509 struct decoder_block *result = NULL;
510 ULONGLONG seek;
511 BYTE chunk_type[4];
512 ULONG chunk_size;
513 ULONGLONG chunk_start;
514 ULONG metadata_blocks_size = 0;
515
516 seek = 8;
517 *count = 0;
518
519 do
520 {
521 hr = stream_seek(This->stream, seek, STREAM_SEEK_SET, &chunk_start);
522 if (FAILED(hr)) goto end;
523
524 hr = read_png_chunk(This->stream, chunk_type, NULL, &chunk_size);
525 if (FAILED(hr)) goto end;
526
527 if (chunk_type[0] >= 'a' && chunk_type[0] <= 'z' &&
528 memcmp(chunk_type, "tRNS", 4) && memcmp(chunk_type, "pHYs", 4))
529 {
530 /* This chunk is considered metadata. */
531 if (*count == metadata_blocks_size)
532 {
533 struct decoder_block *new_metadata_blocks;
534 ULONG new_metadata_blocks_size;
535
536 new_metadata_blocks_size = 4 + metadata_blocks_size * 2;
537 new_metadata_blocks = RtlAllocateHeap(GetProcessHeap(), 0,
538 new_metadata_blocks_size * sizeof(*new_metadata_blocks));
539
540 if (!new_metadata_blocks)
541 {
542 hr = E_OUTOFMEMORY;
543 goto end;
544 }
545
546 memcpy(new_metadata_blocks, result,
547 *count * sizeof(*new_metadata_blocks));
548
549 RtlFreeHeap(GetProcessHeap(), 0, result);
550 result = new_metadata_blocks;
551 metadata_blocks_size = new_metadata_blocks_size;
552 }
553
554 result[*count].offset = chunk_start;
555 result[*count].length = chunk_size + 12;
556 result[*count].options = WICMetadataCreationAllowUnknown;
557 (*count)++;
558 }
559
560 seek = chunk_start + chunk_size + 12; /* skip data and CRC */
561 } while (memcmp(chunk_type, "IEND", 4));
562
563 end:
564 if (SUCCEEDED(hr))
565 {
566 *blocks = result;
567 }
568 else
569 {
570 *count = 0;
571 *blocks = NULL;
572 RtlFreeHeap(GetProcessHeap(), 0, result);
573 }
574 return hr;
575 }
576
577 static HRESULT CDECL png_decoder_get_color_context(struct decoder* iface, UINT frame, UINT num,
578 BYTE **data, DWORD *datasize)
579 {
580 struct png_decoder *This = impl_from_decoder(iface);
581
582 *data = RtlAllocateHeap(GetProcessHeap(), 0, This->color_profile_len);
583 *datasize = This->color_profile_len;
584
585 if (!*data)
586 return E_OUTOFMEMORY;
587
588 memcpy(*data, This->color_profile, This->color_profile_len);
589
590 return S_OK;
591 }
592
593 static void CDECL png_decoder_destroy(struct decoder* iface)
594 {
595 struct png_decoder *This = impl_from_decoder(iface);
596
597 free(This->image_bits);
598 free(This->color_profile);
599 RtlFreeHeap(GetProcessHeap(), 0, This);
600 }
601
602 static const struct decoder_funcs png_decoder_vtable = {
603 png_decoder_initialize,
604 png_decoder_get_frame_info,
605 png_decoder_copy_pixels,
606 png_decoder_get_metadata_blocks,
607 png_decoder_get_color_context,
608 png_decoder_destroy
609 };
610
611 HRESULT CDECL png_decoder_create(struct decoder_info *info, struct decoder **result)
612 {
613 struct png_decoder *This;
614
615 if (!load_libpng())
616 {
617 ERR("Failed reading PNG because unable to find %s\n",SONAME_LIBPNG);
618 return E_FAIL;
619 }
620
621 This = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*This));
622
623 if (!This)
624 {
625 return E_OUTOFMEMORY;
626 }
627
628 This->decoder.vtable = &png_decoder_vtable;
629 This->image_bits = NULL;
630 This->color_profile = NULL;
631 *result = &This->decoder;
632
633 info->container_format = GUID_ContainerFormatPng;
634 info->block_format = GUID_ContainerFormatPng;
635 info->clsid = CLSID_WICPngDecoder;
636
637 return S_OK;
638 }
639
640 struct png_pixelformat {
641 const WICPixelFormatGUID *guid;
642 UINT bpp;
643 int bit_depth;
644 int color_type;
645 BOOL remove_filler;
646 BOOL swap_rgb;
647 };
648
649 static const struct png_pixelformat formats[] = {
650 {&GUID_WICPixelFormat32bppBGRA, 32, 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 1},
651 {&GUID_WICPixelFormat24bppBGR, 24, 8, PNG_COLOR_TYPE_RGB, 0, 1},
652 {&GUID_WICPixelFormatBlackWhite, 1, 1, PNG_COLOR_TYPE_GRAY, 0, 0},
653 {&GUID_WICPixelFormat2bppGray, 2, 2, PNG_COLOR_TYPE_GRAY, 0, 0},
654 {&GUID_WICPixelFormat4bppGray, 4, 4, PNG_COLOR_TYPE_GRAY, 0, 0},
655 {&GUID_WICPixelFormat8bppGray, 8, 8, PNG_COLOR_TYPE_GRAY, 0, 0},
656 {&GUID_WICPixelFormat16bppGray, 16, 16, PNG_COLOR_TYPE_GRAY, 0, 0},
657 {&GUID_WICPixelFormat32bppBGR, 32, 8, PNG_COLOR_TYPE_RGB, 1, 1},
658 {&GUID_WICPixelFormat48bppRGB, 48, 16, PNG_COLOR_TYPE_RGB, 0, 0},
659 {&GUID_WICPixelFormat64bppRGBA, 64, 16, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0},
660 {&GUID_WICPixelFormat1bppIndexed, 1, 1, PNG_COLOR_TYPE_PALETTE, 0, 0},
661 {&GUID_WICPixelFormat2bppIndexed, 2, 2, PNG_COLOR_TYPE_PALETTE, 0, 0},
662 {&GUID_WICPixelFormat4bppIndexed, 4, 4, PNG_COLOR_TYPE_PALETTE, 0, 0},
663 {&GUID_WICPixelFormat8bppIndexed, 8, 8, PNG_COLOR_TYPE_PALETTE, 0, 0},
664 {NULL},
665 };
666
667 struct png_encoder
668 {
669 struct encoder encoder;
670 IStream *stream;
671 png_structp png_ptr;
672 png_infop info_ptr;
673 struct encoder_frame encoder_frame;
674 const struct png_pixelformat *format;
675 BYTE *data;
676 UINT stride;
677 UINT passes;
678 UINT lines_written;
679 };
680
681 static inline struct png_encoder *impl_from_encoder(struct encoder* iface)
682 {
683 return CONTAINING_RECORD(iface, struct png_encoder, encoder);
684 }
685
686 static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
687 {
688 struct png_encoder *This = ppng_get_io_ptr(png_ptr);
689 HRESULT hr;
690 ULONG byteswritten;
691
692 hr = stream_write(This->stream, data, length, &byteswritten);
693 if (FAILED(hr) || byteswritten != length)
694 {
695 ppng_error(png_ptr, "failed writing data");
696 }
697 }
698
699 static void user_flush(png_structp png_ptr)
700 {
701 }
702
703 static HRESULT CDECL png_encoder_initialize(struct encoder *encoder, IStream *stream)
704 {
705 struct png_encoder *This = impl_from_encoder(encoder);
706 jmp_buf jmpbuf;
707
708 TRACE("(%p,%p)\n", encoder, stream);
709
710 /* initialize libpng */
711 This->png_ptr = ppng_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
712 if (!This->png_ptr)
713 return E_FAIL;
714
715 This->info_ptr = ppng_create_info_struct(This->png_ptr);
716 if (!This->info_ptr)
717 {
718 ppng_destroy_write_struct(&This->png_ptr, NULL);
719 This->png_ptr = NULL;
720 return E_FAIL;
721 }
722
723 This->stream = stream;
724
725 /* set up setjmp/longjmp error handling */
726 if (setjmp(jmpbuf))
727 {
728 ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
729 This->png_ptr = NULL;
730 This->stream = NULL;
731 return E_FAIL;
732 }
733 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
734
735 /* set up custom i/o handling */
736 ppng_set_write_fn(This->png_ptr, This, user_write_data, user_flush);
737
738 return S_OK;
739 }
740
741 static HRESULT CDECL png_encoder_get_supported_format(struct encoder* iface, GUID *pixel_format, DWORD *bpp, BOOL *indexed)
742 {
743 int i;
744
745 for (i=0; formats[i].guid; i++)
746 {
747 if (memcmp(formats[i].guid, pixel_format, sizeof(GUID)) == 0)
748 break;
749 }
750
751 if (!formats[i].guid)
752 i = 0;
753
754 *pixel_format = *formats[i].guid;
755 *bpp = formats[i].bpp;
756 *indexed = (formats[i].color_type == PNG_COLOR_TYPE_PALETTE);
757
758 return S_OK;
759 }
760
761 static HRESULT CDECL png_encoder_create_frame(struct encoder *encoder, const struct encoder_frame *encoder_frame)
762 {
763 struct png_encoder *This = impl_from_encoder(encoder);
764 jmp_buf jmpbuf;
765 int i;
766
767 for (i=0; formats[i].guid; i++)
768 {
769 if (memcmp(formats[i].guid, &encoder_frame->pixel_format, sizeof(GUID)) == 0)
770 {
771 This->format = &formats[i];
772 break;
773 }
774 }
775
776 if (!formats[i].guid)
777 {
778 ERR("invalid pixel format %s\n", wine_dbgstr_guid(&encoder_frame->pixel_format));
779 return E_FAIL;
780 }
781
782 /* set up setjmp/longjmp error handling */
783 if (setjmp(jmpbuf))
784 return E_FAIL;
785
786 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
787
788 This->encoder_frame = *encoder_frame;
789 This->lines_written = 0;
790
791 if (encoder_frame->interlace)
792 {
793 /* libpng requires us to write all data multiple times in this case. */
794 This->stride = (This->format->bpp * encoder_frame->width + 7)/8;
795 This->data = malloc(encoder_frame->height * This->stride);
796 if (!This->data)
797 return E_OUTOFMEMORY;
798 }
799
800 /* Tell PNG we need to byte swap if writing a >8-bpp image */
801 if (This->format->bit_depth > 8)
802 ppng_set_swap(This->png_ptr);
803
804 ppng_set_IHDR(This->png_ptr, This->info_ptr, encoder_frame->width, encoder_frame->height,
805 This->format->bit_depth, This->format->color_type,
806 encoder_frame->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE,
807 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
808
809 if (encoder_frame->dpix != 0.0 && encoder_frame->dpiy != 0.0)
810 {
811 ppng_set_pHYs(This->png_ptr, This->info_ptr, (encoder_frame->dpix+0.0127) / 0.0254,
812 (encoder_frame->dpiy+0.0127) / 0.0254, PNG_RESOLUTION_METER);
813 }
814
815 if (This->format->color_type == PNG_COLOR_TYPE_PALETTE && encoder_frame->num_colors)
816 {
817 png_color png_palette[256];
818 png_byte trans[256];
819 UINT i, num_trans = 0, colors;
820
821 /* Newer libpng versions don't accept larger palettes than the declared
822 * bit depth, so we need to generate the palette of the correct length.
823 */
824 colors = min(encoder_frame->num_colors, 1 << This->format->bit_depth);
825
826 for (i = 0; i < colors; i++)
827 {
828 png_palette[i].red = (encoder_frame->palette[i] >> 16) & 0xff;
829 png_palette[i].green = (encoder_frame->palette[i] >> 8) & 0xff;
830 png_palette[i].blue = encoder_frame->palette[i] & 0xff;
831 trans[i] = (encoder_frame->palette[i] >> 24) & 0xff;
832 if (trans[i] != 0xff)
833 num_trans = i+1;
834 }
835
836 ppng_set_PLTE(This->png_ptr, This->info_ptr, png_palette, colors);
837
838 if (num_trans)
839 ppng_set_tRNS(This->png_ptr, This->info_ptr, trans, num_trans, NULL);
840 }
841
842 ppng_write_info(This->png_ptr, This->info_ptr);
843
844 if (This->format->remove_filler)
845 ppng_set_filler(This->png_ptr, 0, PNG_FILLER_AFTER);
846
847 if (This->format->swap_rgb)
848 ppng_set_bgr(This->png_ptr);
849
850 if (encoder_frame->interlace)
851 This->passes = ppng_set_interlace_handling(This->png_ptr);
852
853 if (encoder_frame->filter != WICPngFilterUnspecified)
854 {
855 static const int png_filter_map[] =
856 {
857 /* WICPngFilterUnspecified */ PNG_NO_FILTERS,
858 /* WICPngFilterNone */ PNG_FILTER_NONE,
859 /* WICPngFilterSub */ PNG_FILTER_SUB,
860 /* WICPngFilterUp */ PNG_FILTER_UP,
861 /* WICPngFilterAverage */ PNG_FILTER_AVG,
862 /* WICPngFilterPaeth */ PNG_FILTER_PAETH,
863 /* WICPngFilterAdaptive */ PNG_ALL_FILTERS,
864 };
865
866 ppng_set_filter(This->png_ptr, 0, png_filter_map[encoder_frame->filter]);
867 }
868
869 return S_OK;
870 }
871
872 static HRESULT CDECL png_encoder_write_lines(struct encoder* encoder, BYTE *data, DWORD line_count, DWORD stride)
873 {
874 struct png_encoder *This = impl_from_encoder(encoder);
875 jmp_buf jmpbuf;
876 png_byte **row_pointers=NULL;
877 UINT i;
878
879 if (This->encoder_frame.interlace)
880 {
881 /* Just store the data so we can write it in multiple passes in Commit. */
882 for (i=0; i<line_count; i++)
883 memcpy(This->data + This->stride * (This->lines_written + i),
884 data + stride * i,
885 This->stride);
886
887 This->lines_written += line_count;
888
889 return S_OK;
890 }
891
892 /* set up setjmp/longjmp error handling */
893 if (setjmp(jmpbuf))
894 {
895 free(row_pointers);
896 return E_FAIL;
897 }
898
899 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
900
901 row_pointers = malloc(line_count * sizeof(png_byte*));
902 if (!row_pointers)
903 return E_OUTOFMEMORY;
904
905 for (i=0; i<line_count; i++)
906 row_pointers[i] = data + stride * i;
907
908 ppng_write_rows(This->png_ptr, row_pointers, line_count);
909 This->lines_written += line_count;
910
911 free(row_pointers);
912
913 return S_OK;
914 }
915
916 static HRESULT CDECL png_encoder_commit_frame(struct encoder *encoder)
917 {
918 struct png_encoder *This = impl_from_encoder(encoder);
919 jmp_buf jmpbuf;
920 png_byte **row_pointers=NULL;
921
922 /* set up setjmp/longjmp error handling */
923 if (setjmp(jmpbuf))
924 {
925 free(row_pointers);
926 return E_FAIL;
927 }
928
929 ppng_set_error_fn(This->png_ptr, jmpbuf, user_error_fn, user_warning_fn);
930
931 if (This->encoder_frame.interlace)
932 {
933 int i;
934
935 row_pointers = malloc(This->encoder_frame.height * sizeof(png_byte*));
936 if (!row_pointers)
937 return E_OUTOFMEMORY;
938
939 for (i=0; i<This->encoder_frame.height; i++)
940 row_pointers[i] = This->data + This->stride * i;
941
942 for (i=0; i<This->passes; i++)
943 ppng_write_rows(This->png_ptr, row_pointers, This->encoder_frame.height);
944 }
945
946 ppng_write_end(This->png_ptr, This->info_ptr);
947
948 free(row_pointers);
949
950 return S_OK;
951 }
952
953 static HRESULT CDECL png_encoder_commit_file(struct encoder *encoder)
954 {
955 return S_OK;
956 }
957
958 static void CDECL png_encoder_destroy(struct encoder *encoder)
959 {
960 struct png_encoder *This = impl_from_encoder(encoder);
961 if (This->png_ptr)
962 ppng_destroy_write_struct(&This->png_ptr, &This->info_ptr);
963 free(This->data);
964 RtlFreeHeap(GetProcessHeap(), 0, This);
965 }
966
967 static const struct encoder_funcs png_encoder_vtable = {
968 png_encoder_initialize,
969 png_encoder_get_supported_format,
970 png_encoder_create_frame,
971 png_encoder_write_lines,
972 png_encoder_commit_frame,
973 png_encoder_commit_file,
974 png_encoder_destroy
975 };
976
977 HRESULT CDECL png_encoder_create(struct encoder_info *info, struct encoder **result)
978 {
979 struct png_encoder *This;
980
981 if (!load_libpng())
982 {
983 ERR("Failed reading PNG because unable to find %s\n",SONAME_LIBPNG);
984 return E_FAIL;
985 }
986
987 This = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*This));
988
989 if (!This)
990 {
991 return E_OUTOFMEMORY;
992 }
993
994 This->encoder.vtable = &png_encoder_vtable;
995 This->png_ptr = NULL;
996 This->info_ptr = NULL;
997 This->data = NULL;
998 *result = &This->encoder;
999
1000 info->flags = ENCODER_FLAGS_SUPPORTS_METADATA;
1001 info->container_format = GUID_ContainerFormatPng;
1002 info->clsid = CLSID_WICPngEncoder;
1003 info->encoder_options[0] = ENCODER_OPTION_INTERLACE;
1004 info->encoder_options[1] = ENCODER_OPTION_FILTER;
1005 info->encoder_options[2] = ENCODER_OPTION_END;
1006
1007 return S_OK;
1008 }
1009
1010 #else
1011
1012 HRESULT CDECL png_decoder_create(struct decoder_info *info, struct decoder **result)
1013 {
1014 ERR("Trying to load PNG picture, but PNG support is not compiled in.\n");
1015 return E_FAIL;
1016 }
1017
1018 HRESULT CDECL png_encoder_create(struct encoder_info *info, struct encoder **result)
1019 {
1020 ERR("Trying to save PNG picture, but PNG support is not compiled in.\n");
1021 return E_FAIL;
1022 }
1023
1024 #endif
Windows API implementation