dlls/windowscodecs/libpng.c

   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 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 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 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 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 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 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 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 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