workbench/libs/png/contrib/visupng/PngFile.c

   1 /*-------------------------------------
   2  *  PNGFILE.C -- Image File Functions
   3  *-------------------------------------
   4  *
   5  * Copyright 2000,2017 Willem van Schaik.
   6  *
   7  * This code is released under the libpng license.
   8  * For conditions of distribution and use, see the disclaimer
   9  * and license in png.h
  10  */
  11
  12 #include <windows.h>
  13 #include <commdlg.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <zlib.h>
  17
  18 #include "png.h"
  19 #include "pngfile.h"
  20 #include "cexcept.h"
  21
  22 define_exception_type(const char *);
  23 extern struct exception_context the_exception_context[1];
  24 struct exception_context the_exception_context[1];
  25 png_const_charp msg;
  26
  27 static OPENFILENAME ofn;
  28
  29 static png_structp png_ptr = NULL;
  30 static png_infop info_ptr = NULL;
  31
  32
  33 /* cexcept interface */
  34
  35 static void
  36 png_cexcept_error(png_structp png_ptr, png_const_charp msg)
  37 {
  38    if(png_ptr)
  39      ;
  40 #ifdef PNG_CONSOLE_IO_SUPPORTED
  41    fprintf(stderr, "libpng error: %s\n", msg);
  42 #endif
  43    {
  44       Throw msg;
  45    }
  46 }
  47
  48 /* Windows open-file functions */
  49
  50 void PngFileInitialize (HWND hwnd)
  51 {
  52     static TCHAR szFilter[] = TEXT ("PNG Files (*.PNG)\0*.png\0")
  53         TEXT ("All Files (*.*)\0*.*\0\0");
  54
  55     ofn.lStructSize       = sizeof (OPENFILENAME);
  56     ofn.hwndOwner         = hwnd;
  57     ofn.hInstance         = NULL;
  58     ofn.lpstrFilter       = szFilter;
  59     ofn.lpstrCustomFilter = NULL;
  60     ofn.nMaxCustFilter    = 0;
  61     ofn.nFilterIndex      = 0;
  62     ofn.lpstrFile         = NULL;          /* Set in Open and Close functions */
  63     ofn.nMaxFile          = MAX_PATH;
  64     ofn.lpstrFileTitle    = NULL;          /* Set in Open and Close functions */
  65     ofn.nMaxFileTitle     = MAX_PATH;
  66     ofn.lpstrInitialDir   = NULL;
  67     ofn.lpstrTitle        = NULL;
  68     ofn.Flags             = 0;             /* Set in Open and Close functions */
  69     ofn.nFileOffset       = 0;
  70     ofn.nFileExtension    = 0;
  71     ofn.lpstrDefExt       = TEXT ("png");
  72     ofn.lCustData         = 0;
  73     ofn.lpfnHook          = NULL;
  74     ofn.lpTemplateName    = NULL;
  75 }
  76
  77 BOOL PngFileOpenDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName)
  78 {
  79     ofn.hwndOwner         = hwnd;
  80     ofn.lpstrFile         = pstrFileName;
  81     ofn.lpstrFileTitle    = pstrTitleName;
  82     ofn.Flags             = OFN_HIDEREADONLY;
  83
  84     return GetOpenFileName (&ofn);
  85 }
  86
  87 BOOL PngFileSaveDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName)
  88 {
  89     ofn.hwndOwner         = hwnd;
  90     ofn.lpstrFile         = pstrFileName;
  91     ofn.lpstrFileTitle    = pstrTitleName;
  92     ofn.Flags             = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
  93
  94     return GetSaveFileName (&ofn);
  95 }
  96
  97 /* PNG image handler functions */
  98
  99 BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
 100                    int *piWidth, int *piHeight, int *piChannels, png_color *pBkgColor)
 101 {
 102     static FILE        *pfFile;
 103     png_byte            pbSig[8];
 104     int                 iBitDepth;
 105     int                 iColorType;
 106     double              dGamma;
 107     png_color_16       *pBackground;
 108     png_uint_32         ulChannels;
 109     png_uint_32         ulRowBytes;
 110     png_byte           *pbImageData = *ppbImageData;
 111     static png_byte   **ppbRowPointers = NULL;
 112     int                 i;
 113
 114     /* open the PNG input file */
 115
 116     if (!pstrFileName)
 117     {
 118         *ppbImageData = pbImageData = NULL;
 119         return FALSE;
 120     }
 121
 122     if (!(pfFile = fopen(pstrFileName, "rb")))
 123     {
 124         *ppbImageData = pbImageData = NULL;
 125         return FALSE;
 126     }
 127
 128     /* first check the eight byte PNG signature */
 129
 130     fread(pbSig, 1, 8, pfFile);
 131     if (png_sig_cmp(pbSig, 0, 8))
 132     {
 133         *ppbImageData = pbImageData = NULL;
 134         return FALSE;
 135     }
 136
 137     /* create the two png(-info) structures */
 138
 139     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
 140       (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
 141     if (!png_ptr)
 142     {
 143         *ppbImageData = pbImageData = NULL;
 144         return FALSE;
 145     }
 146
 147     info_ptr = png_create_info_struct(png_ptr);
 148     if (!info_ptr)
 149     {
 150         png_destroy_read_struct(&png_ptr, NULL, NULL);
 151         *ppbImageData = pbImageData = NULL;
 152         return FALSE;
 153     }
 154
 155     Try
 156     {
 157
 158         /* initialize the png structure */
 159
 160 #ifdef PNG_STDIO_SUPPORTED
 161         png_init_io(png_ptr, pfFile);
 162 #else
 163         png_set_read_fn(png_ptr, (png_voidp)pfFile, png_read_data);
 164 #endif
 165
 166         png_set_sig_bytes(png_ptr, 8);
 167
 168         /* read all PNG info up to image data */
 169
 170         png_read_info(png_ptr, info_ptr);
 171
 172         /* get width, height, bit-depth and color-type */
 173
 174         png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
 175             &iColorType, NULL, NULL, NULL);
 176
 177         /* expand images of all color-type and bit-depth to 3x8-bit RGB */
 178         /* let the library process alpha, transparency, background, etc. */
 179
 180 #ifdef PNG_READ_16_TO_8_SUPPORTED
 181     if (iBitDepth == 16)
 182 #  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
 183         png_set_scale_16(png_ptr);
 184 #  else
 185         png_set_strip_16(png_ptr);
 186 #  endif
 187 #endif
 188         if (iColorType == PNG_COLOR_TYPE_PALETTE)
 189             png_set_expand(png_ptr);
 190         if (iBitDepth < 8)
 191             png_set_expand(png_ptr);
 192         if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 193             png_set_expand(png_ptr);
 194         if (iColorType == PNG_COLOR_TYPE_GRAY ||
 195             iColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
 196             png_set_gray_to_rgb(png_ptr);
 197
 198         /* set the background color to draw transparent and alpha images over */
 199         if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
 200         {
 201             png_set_background(png_ptr, pBackground, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 202             pBkgColor->red   = (byte) pBackground->red;
 203             pBkgColor->green = (byte) pBackground->green;
 204             pBkgColor->blue  = (byte) pBackground->blue;
 205         }
 206         else
 207         {
 208             pBkgColor = NULL;
 209         }
 210
 211         /* if required set gamma conversion */
 212         if (png_get_gAMA(png_ptr, info_ptr, &dGamma))
 213             png_set_gamma(png_ptr, (double) 2.2, dGamma);
 214
 215         /* after the transformations are registered, update info_ptr data */
 216
 217         png_read_update_info(png_ptr, info_ptr);
 218
 219         /* get again width, height and the new bit-depth and color-type */
 220
 221         png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
 222             &iColorType, NULL, NULL, NULL);
 223
 224
 225         /* row_bytes is the width x number of channels */
 226
 227         ulRowBytes = png_get_rowbytes(png_ptr, info_ptr);
 228         ulChannels = png_get_channels(png_ptr, info_ptr);
 229
 230         *piChannels = ulChannels;
 231
 232         /* now we can allocate memory to store the image */
 233
 234         if (pbImageData)
 235         {
 236             free (pbImageData);
 237             pbImageData = NULL;
 238         }
 239         if ((*piHeight) > ((size_t)(-1))/ulRowBytes) {
 240         {
 241             png_error(png_ptr, "Visual PNG: image is too big");
 242         }
 243         if ((pbImageData = (png_byte *) malloc(ulRowBytes * (*piHeight)
 244                             * sizeof(png_byte))) == NULL)
 245         {
 246             png_error(png_ptr, "Visual PNG: out of memory");
 247         }
 248         *ppbImageData = pbImageData;
 249
 250         /* and allocate memory for an array of row-pointers */
 251
 252         if ((ppbRowPointers = (png_bytepp) malloc((*piHeight)
 253                             * sizeof(png_bytep))) == NULL)
 254         {
 255             png_error(png_ptr, "Visual PNG: out of memory");
 256         }
 257
 258         /* set the individual row-pointers to point at the correct offsets */
 259
 260         for (i = 0; i < (*piHeight); i++)
 261             ppbRowPointers[i] = pbImageData + i * ulRowBytes;
 262
 263         /* now we can go ahead and just read the whole image */
 264
 265         png_read_image(png_ptr, ppbRowPointers);
 266
 267         /* read the additional chunks in the PNG file (not really needed) */
 268
 269         png_read_end(png_ptr, NULL);
 270
 271         /* and we're done */
 272
 273         free (ppbRowPointers);
 274         ppbRowPointers = NULL;
 275
 276         /* yepp, done */
 277     }
 278
 279     Catch (msg)
 280     {
 281         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 282
 283         *ppbImageData = pbImageData = NULL;
 284
 285         if(ppbRowPointers)
 286             free (ppbRowPointers);
 287
 288         fclose(pfFile);
 289
 290         return FALSE;
 291     }
 292
 293     fclose (pfFile);
 294
 295     return TRUE;
 296 }
 297
 298
 299 BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
 300                    int iWidth, int iHeight, png_color bkgColor)
 301 {
 302     const int           ciBitDepth = 8;
 303     const int           ciChannels = 3;
 304
 305     static FILE        *pfFile;
 306     png_uint_32         ulRowBytes;
 307     static png_byte   **ppbRowPointers = NULL;
 308     int                 i;
 309
 310     /* open the PNG output file */
 311
 312     if (!pstrFileName)
 313         return FALSE;
 314
 315     if (!(pfFile = fopen(pstrFileName, "wb")))
 316         return FALSE;
 317
 318     /* prepare the standard PNG structures */
 319
 320     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
 321       (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
 322     if (!png_ptr)
 323     {
 324         fclose(pfFile);
 325         return FALSE;
 326     }
 327
 328     info_ptr = png_create_info_struct(png_ptr);
 329     if (!info_ptr) {
 330         fclose(pfFile);
 331         png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
 332         return FALSE;
 333     }
 334
 335     Try
 336     {
 337         /* initialize the png structure */
 338
 339 #ifdef PNG_STDIO_SUPPORTED
 340         png_init_io(png_ptr, pfFile);
 341 #else
 342         png_set_write_fn(png_ptr, (png_voidp)pfFile, png_write_data, png_flush);
 343 #endif
 344
 345         /* we're going to write a very simple 3x8-bit RGB image */
 346
 347         png_set_IHDR(png_ptr, info_ptr, iWidth, iHeight, ciBitDepth,
 348             PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
 349             PNG_FILTER_TYPE_BASE);
 350
 351         /* write the file header information */
 352
 353         png_write_info(png_ptr, info_ptr);
 354
 355         /* swap the BGR pixels in the DiData structure to RGB */
 356
 357         png_set_bgr(png_ptr);
 358
 359         /* row_bytes is the width x number of channels */
 360
 361         ulRowBytes = iWidth * ciChannels;
 362
 363         /* we can allocate memory for an array of row-pointers */
 364
 365         if ((ppbRowPointers = (png_bytepp) malloc(iHeight * sizeof(png_bytep))) == NULL)
 366             Throw "Visualpng: Out of memory";
 367
 368         /* set the individual row-pointers to point at the correct offsets */
 369
 370         for (i = 0; i < iHeight; i++)
 371             ppbRowPointers[i] = pDiData + i * (((ulRowBytes + 3) >> 2) << 2);
 372
 373         /* write out the entire image data in one call */
 374
 375         png_write_image (png_ptr, ppbRowPointers);
 376
 377         /* write the additional chunks to the PNG file (not really needed) */
 378
 379         png_write_end(png_ptr, info_ptr);
 380
 381         /* and we're done */
 382
 383         free (ppbRowPointers);
 384         ppbRowPointers = NULL;
 385
 386         /* clean up after the write, and free any memory allocated */
 387
 388         png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
 389
 390         /* yepp, done */
 391     }
 392
 393     Catch (msg)
 394     {
 395         png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
 396
 397         if(ppbRowPointers)
 398             free (ppbRowPointers);
 399
 400         fclose(pfFile);
 401
 402         return FALSE;
 403     }
 404
 405     fclose (pfFile);
 406
 407     return TRUE;
 408 }
 409
 410 #ifndef PNG_STDIO_SUPPORTED
 411
 412 static void
 413 png_read_data(png_structp png_ptr, png_bytep data, size_t length)
 414 {
 415    size_t check;
 416
 417    /* fread() returns 0 on error, so it is OK to store this in a size_t
 418     * instead of an int, which is what fread() actually returns.
 419     */
 420    check = fread(data, 1, length, (FILE *)png_ptr->io_ptr);
 421
 422    if (check != length)
 423    {
 424       png_error(png_ptr, "Read Error");
 425    }
 426 }
 427
 428 static void
 429 png_write_data(png_structp png_ptr, png_bytep data, size_t length)
 430 {
 431    png_uint_32 check;
 432
 433    check = fwrite(data, 1, length, (FILE *)(png_ptr->io_ptr));
 434    if (check != length)
 435    {
 436       png_error(png_ptr, "Write Error");
 437    }
 438 }
 439
 440 static void
 441 png_flush(png_structp png_ptr)
 442 {
 443    FILE *io_ptr;
 444    io_ptr = (FILE *)CVT_PTR((png_ptr->io_ptr));
 445    if (io_ptr != NULL)
 446       fflush(io_ptr);
 447 }
 448
 449 #endif
 450
 451 /*-----------------
 452  *  end of source
 453  *-----------------
 454  */