Source/System/Image/FileIO/OSGPNGImageFileType.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //-------------------------------
  40 // Includes
  41 //-------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #ifdef   OSG_SGI_LIB
  49 #include <limits>
  50 #endif
  51 #ifdef OSG_WITH_PNG
  52 #include <png.h>
  53 #endif
  54
  55 #include "OSGPNGImageFileType.h"
  56 #include "OSGLog.h"
  57
  58 #ifndef OSG_DO_DOC
  59 #    ifdef OSG_WITH_PNG
  60 #        define OSG_PNG_ARG(ARG) ARG
  61 #    else
  62 #        define OSG_PNG_ARG(ARG)
  63 #    endif
  64 #else
  65 #    define OSG_PNG_ARG(ARG) ARG
  66 #endif
  67
  68 static const OSG::Char8 *suffixArray[] =
  69 {
  70     "png"
  71 };
  72
  73 OSG_BEGIN_NAMESPACE
  74
  75 /*! \class PNGImageFileType
  76
  77   Image File Type to read/write and store/restore Image objects as
  78   PNG data.
  79
  80   To be able to load PNG images you need the PNG library,
  81   (check the Prerequisites page on www.opensg.org).
  82   The lib comes with all Linux distributions.
  83
  84   You have to --enable-png in the configure line to enable
  85   the singleton object.
  86
  87 */
  88
  89 #ifdef OSG_WITH_PNG
  90
  91 static void isReadFunc(png_structp png_ptr, png_bytep data, png_size_t length)
  92 {
  93     std::istream *is =
  94         reinterpret_cast<std::istream*>(png_get_io_ptr(png_ptr));
  95
  96     is->read(reinterpret_cast<char*>(data), length);
  97
  98     if(png_size_t(is->gcount()) != length)
  99         png_error(png_ptr, "Cannot read from input stream");
 100 }
 101
 102 static void osWriteFunc(png_structp png_ptr, png_bytep data, png_size_t length)
 103 {
 104     std::ostream *os =
 105         reinterpret_cast<std::ostream*>(png_get_io_ptr(png_ptr));
 106
 107     os->write(reinterpret_cast<char*>(data), length);
 108
 109     if(os->good() == false)
 110         png_error(png_ptr, "Cannot write to output stream");
 111 }
 112
 113 static void osFlushFunc(png_structp png_ptr)
 114 {
 115     std::ostream *os =
 116         reinterpret_cast<std::ostream*>(png_get_io_ptr(png_ptr));
 117
 118     os->flush();
 119
 120     if(os->good() == false)
 121         png_error(png_ptr, "Cannot flush output stream");
 122 }
 123
 124 static void errorOutput (png_structp png_ptr, const char *message)
 125 {
 126     FFATAL   (("PNG: %s\n", message ));
 127
 128     longjmp(png_jmpbuf(png_ptr), 1);
 129 }
 130
 131 static void warningOutput (png_structp OSG_CHECK_ARG(png_ptr),
 132                            const char *message)
 133 {
 134     FWARNING (("PNG: %s\n", message ));
 135 }
 136
 137 #endif
 138
 139 PNGImageFileType PNGImageFileType:: _the("image/png",
 140                                          suffixArray, sizeof(suffixArray),
 141                                          (OSG_READ_SUPPORTED |
 142                                           OSG_WRITE_SUPPORTED));
 143
 144 //-------------------------------------------------------------------------
 145 /*! Tries to fill the image object with the data read from
 146     the given stream. Returns true on success.
 147  */
 148
 149 bool PNGImageFileType::read(      Image        *OSG_PNG_ARG(pImage  ),
 150                                   std::istream &OSG_PNG_ARG(is      ),
 151                             const std::string  &OSG_PNG_ARG(mimetype))
 152 {
 153 #ifdef OSG_WITH_PNG
 154
 155     bool                retCode;
 156     Image::PixelFormat  pixelFormat = OSG::Image::OSG_INVALID_PF;
 157     png_structp         png_ptr;
 158     png_infop           info_ptr;
 159     png_uint_32         width, wc, height, h, i, res_x, res_y;
 160     png_byte            bit_depth, channels, color_type;
 161     png_bytep           *row_pointers, base;
 162
 163     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
 164
 165     if(!png_ptr)
 166         return false;
 167
 168     png_set_error_fn(png_ptr, 0, &errorOutput, &warningOutput);
 169
 170     info_ptr = png_create_info_struct(png_ptr);
 171
 172     if(!info_ptr)
 173     {
 174         png_destroy_read_struct(&png_ptr, 0, 0);
 175         return false;
 176     }
 177
 178     if(setjmp(png_jmpbuf(png_ptr)))
 179     {
 180         png_destroy_read_struct(&png_ptr, &info_ptr, 0);
 181         return false;
 182     }
 183
 184     png_set_read_fn(png_ptr, &is, &isReadFunc);
 185
 186     png_read_info(png_ptr, info_ptr);
 187
 188     width = png_get_image_width(png_ptr, info_ptr);
 189     height = png_get_image_height(png_ptr, info_ptr);
 190     bit_depth = png_get_bit_depth(png_ptr, info_ptr);
 191     res_x = png_get_x_pixels_per_meter(png_ptr, info_ptr);
 192     res_y = png_get_y_pixels_per_meter(png_ptr, info_ptr);
 193     channels = png_get_channels(png_ptr, info_ptr);
 194     color_type = png_get_color_type(png_ptr, info_ptr);
 195
 196     // Convert paletted images to RGB
 197     if (color_type == PNG_COLOR_TYPE_PALETTE)
 198     {
 199         png_set_palette_to_rgb(png_ptr);
 200         channels = 3;
 201         bit_depth = 8;
 202     }
 203
 204     // Convert < 8 bit to 8 bit
 205     if(color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 206     {
 207         png_set_expand_gray_1_2_4_to_8(png_ptr);
 208         bit_depth = 8;
 209     }
 210
 211 #if BYTE_ORDER == LITTLE_ENDIAN
 212     if (bit_depth == 16)
 213         png_set_swap(png_ptr);
 214 #endif
 215
 216     // Add a full alpha channel if there is transparency
 217     // information in a tRNS chunk
 218     if(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 219     {
 220         png_set_tRNS_to_alpha(png_ptr);
 221         ++channels;
 222     }
 223
 224     Int32 dataType;
 225
 226     switch (bit_depth)
 227     {
 228         case 8:
 229             dataType = Image::OSG_UINT8_IMAGEDATA;
 230             break;
 231         case 16:
 232             dataType = Image::OSG_UINT16_IMAGEDATA;
 233             break;
 234         default:
 235             FWARNING (( "Invalid bit_depth: %d, can not read png-data\n",
 236                         bit_depth ));
 237             return false;
 238     }
 239
 240     switch(channels)
 241     {
 242         case 1:
 243             pixelFormat = Image::OSG_L_PF;
 244             break;
 245         case 2:
 246             pixelFormat = Image::OSG_LA_PF;
 247             break;
 248         case 3:
 249             pixelFormat = Image::OSG_RGB_PF;
 250             break;
 251         case 4:
 252             pixelFormat = Image::OSG_RGBA_PF;
 253         break;
 254     };
 255
 256     if(pImage->set(pixelFormat, width, height,
 257                    1, 1, 1, 0.0, 0,
 258                    dataType))
 259     {
 260         // set resolution png supports only pixel per meter,
 261         // so we do a conversion to dpi with some rounding.
 262         res_x = png_uint_32((Real32(res_x) / 39.37007874f) < 0.0f ?
 263                             (Real32(res_x) / 39.37007874f) - 0.5f :
 264                             (Real32(res_x) / 39.37007874f) + 0.5f);
 265         res_y = png_uint_32((Real32(res_y) / 39.37007874f) < 0.0f ?
 266                             (Real32(res_y) / 39.37007874f) - 0.5f :
 267                             (Real32(res_y) / 39.37007874f) + 0.5f);
 268
 269         pImage->setResX(Real32(res_x));
 270         pImage->setResY(Real32(res_y));
 271         pImage->setResUnit(Image::OSG_RESUNIT_INCH);
 272
 273         // Calculate the row pointers
 274         row_pointers = new png_bytep[height];
 275         wc = width * channels * (bit_depth / 8);
 276         h = height - 1;
 277         base = pImage->editData();
 278
 279         for(i = 0; i < height; ++i)
 280             row_pointers[i] = base + (h - i) * wc;
 281
 282         // Read the image data
 283         png_read_image(png_ptr, row_pointers);
 284
 285         delete[] row_pointers;
 286
 287         retCode = true;
 288     }
 289     else
 290     {
 291         retCode = false;
 292     }
 293
 294     png_destroy_read_struct(&png_ptr, &info_ptr, 0);
 295
 296     return retCode;
 297
 298 #else
 299
 300     SWARNING << getMimeType()
 301              << " read is not compiled into the current binary "
 302              << std::endl;
 303
 304     return false;
 305
 306 #endif
 307
 308 }
 309
 310 //-------------------------------------------------------------------------
 311 /*! Tries to write the image object to the given fileName.
 312     Returns true on success. Based on the public domain example.c
 313     from the PNG dist.
 314  */
 315
 316 bool PNGImageFileType::write(const Image        *OSG_PNG_ARG(pImage  ),
 317                                    std::ostream &OSG_PNG_ARG(os      ),
 318                              const std::string  &OSG_PNG_ARG(mimetype))
 319 {
 320 #ifdef OSG_WITH_PNG
 321
 322     png_structp png_ptr;
 323     png_infop info_ptr;
 324
 325     if(pImage->getDimension() < 1 || pImage->getDimension() > 2)
 326     {
 327         FWARNING(("PNGImageFileType::write: invalid dimension %d!\n",
 328                   pImage->getDimension()));
 329
 330         return false;
 331     }
 332
 333     /* Create and initialize the png_struct with the desired error handler
 334     * functions.  If you want to use the default stderr and longjump method,
 335     * you can supply NULL for the last three parameters.  We also check that
 336     * the library version is compatible with the one used at compile time,
 337     * in case we are using dynamically linked libraries.  REQUIRED.
 338      */
 339     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
 340                                       0, &errorOutput, &warningOutput);
 341
 342     if(png_ptr == NULL)
 343         return false;
 344
 345     /* Allocate/initialize the image information data.  REQUIRED */
 346     info_ptr = png_create_info_struct(png_ptr);
 347
 348     if(info_ptr == NULL)
 349     {
 350         png_destroy_write_struct(&png_ptr,  NULL);
 351         return false;
 352     }
 353
 354     /* set up the output handlers */
 355     png_set_write_fn(png_ptr, &os, &osWriteFunc, &osFlushFunc);
 356
 357     /* This is the hard way */
 358
 359     /* Set the image information here.  Width and height are up to 2^31,
 360     * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
 361     * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
 362     * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
 363     * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
 364     * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
 365     * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
 366     */
 367
 368     Int32 ctype;
 369     switch(pImage->getPixelFormat())
 370     {
 371         case Image::OSG_L_PF:
 372             ctype = PNG_COLOR_TYPE_GRAY;
 373             break;
 374
 375         case Image::OSG_LA_PF:
 376             ctype = PNG_COLOR_TYPE_GRAY_ALPHA;
 377             break;
 378
 379 #if defined(GL_BGR) || defined(GL_BGR_EXT)
 380         case Image::OSG_BGR_PF:
 381 #endif
 382         case Image::OSG_RGB_PF:
 383             ctype = PNG_COLOR_TYPE_RGB;
 384             break;
 385
 386 #if defined(GL_BGRA) || defined(GL_BGRA_EXT)
 387         case Image::OSG_BGRA_PF:
 388 #endif
 389         case Image::OSG_RGBA_PF:
 390             ctype = PNG_COLOR_TYPE_RGB_ALPHA;
 391             break;
 392
 393         default:
 394             FWARNING(("PNGImageFileType::write: unknown pixel format %d!\n",
 395                       pImage->getPixelFormat()));
 396             png_destroy_write_struct(&png_ptr,  NULL);
 397             return false;
 398
 399     }
 400
 401     Int32 bit_depth;
 402     switch(pImage->getDataType())
 403     {
 404         case Image::OSG_UINT8_IMAGEDATA:
 405             bit_depth = 8;
 406             break;
 407         case Image::OSG_UINT16_IMAGEDATA:
 408             bit_depth = 16;
 409             break;
 410         default:
 411             FWARNING (("Invalid pixeldepth, cannot store data\n"));
 412             return false;
 413     };
 414
 415     png_set_IHDR(png_ptr, info_ptr, pImage->getWidth(), pImage->getHeight(),
 416                  bit_depth,ctype,
 417                  PNG_INTERLACE_NONE,
 418                  PNG_COMPRESSION_TYPE_BASE,
 419                  PNG_FILTER_TYPE_BASE);
 420
 421     // set resolution png supports only meter per pixel,
 422     // so we do a conversion from dpi with some rounding.
 423     png_uint_32 res_x = png_uint_32(pImage->getResX());
 424     png_uint_32 res_y = png_uint_32(pImage->getResY());
 425     if(pImage->getResUnit() == Image::OSG_RESUNIT_INCH)
 426     {
 427         res_x = png_uint_32((pImage->getResX() * 39.37007874f) < 0.0f ?
 428                             (pImage->getResX() * 39.37007874f) - 0.5f :
 429                             (pImage->getResX() * 39.37007874f) + 0.5f);
 430         res_y = png_uint_32((pImage->getResY() * 39.37007874f) < 0.0f ?
 431                             (pImage->getResY() * 39.37007874f) - 0.5f :
 432                             (pImage->getResY() * 39.37007874f) + 0.5f);
 433     }
 434
 435     png_set_pHYs(png_ptr, info_ptr, res_x, res_y,
 436                  PNG_RESOLUTION_METER);
 437
 438 #if 0
 439     /* optional significant bit chunk */
 440     /* if we are dealing with a grayscale image then */
 441     sig_bit.gray = true_bit_depth;
 442     /* otherwise, if we are dealing with a color image then */
 443     sig_bit.red = true_red_bit_depth;
 444     sig_bit.green = true_green_bit_depth;
 445     sig_bit.blue = true_blue_bit_depth;
 446     /* if the image has an alpha channel then */
 447     sig_bit.alpha = true_alpha_bit_depth;
 448     png_set_sBIT(png_ptr, info_ptr, sig_bit);
 449
 450
 451     /* Optional gamma chunk is strongly suggested if you have any guess
 452     * as to the correct gamma of the image.
 453     */
 454     png_set_gAMA(png_ptr, info_ptr, gamma);
 455
 456     /* Optionally write comments into the image */
 457     text_ptr[0].key = "Title";
 458     text_ptr[0].text = "Mona Lisa";
 459     text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
 460     text_ptr[1].key = "Author";
 461     text_ptr[1].text = "Leonardo DaVinci";
 462     text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
 463     text_ptr[2].key = "Description";
 464     text_ptr[2].text = "<long text>";
 465     text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
 466 #ifdef PNG_iTXt_SUPPORTED
 467     text_ptr[0].lang = NULL;
 468     text_ptr[1].lang = NULL;
 469     text_ptr[2].lang = NULL;
 470 #endif
 471     png_set_text(png_ptr, info_ptr, text_ptr, 3);
 472 #endif
 473     /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
 474     /* note that if sRGB is present the gAMA and cHRM chunks must be ignored
 475     * on read and must be written in accordance with the sRGB profile */
 476
 477     /* Write the file header information.  REQUIRED */
 478     png_write_info(png_ptr, info_ptr);
 479
 480 #if BYTE_ORDER == LITTLE_ENDIAN
 481     if (bit_depth == 16)
 482       png_set_swap(png_ptr);
 483 #endif
 484
 485 #if 0
 486     /* invert monochrome pixels */
 487     png_set_invert_mono(png_ptr);
 488
 489     /* Shift the pixels up to a legal bit depth and fill in
 490     * as appropriate to correctly scale the image.
 491     */
 492     png_set_shift(png_ptr, &sig_bit);
 493
 494     /* pack pixels into bytes */
 495     png_set_packing(png_ptr);
 496
 497     /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
 498     * RGB (4 channels -> 3 channels). The second parameter is not used.
 499     */
 500     png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
 501
 502     /* swap bytes of 16-bit files to most significant byte first */
 503     png_set_swap(png_ptr);
 504
 505     /* swap bits of 1, 2, 4 bit packed pixel formats */
 506     png_set_packswap(png_ptr);
 507 #endif
 508
 509     if(pImage->getPixelFormat() == Image::OSG_BGR_PF ||
 510        pImage->getPixelFormat() == Image::OSG_BGRA_PF )
 511     {
 512         /* flip BGR pixels to RGB */
 513         png_set_bgr(png_ptr);
 514
 515         /* swap location of alpha bytes from ARGB to RGBA */
 516         png_set_swap_alpha(png_ptr);
 517     }
 518
 519     /* The easiest way to write the image (you may have a different memory
 520      * layout, however, so choose what fits your needs best).  You need to
 521      * use the first method if you aren't handling interlacing yourself.
 522      */
 523     png_bytep *row_pointers = new png_bytep [pImage->getHeight()];
 524
 525     for(Int32 k = 0; k < pImage->getHeight(); k++)
 526     {
 527         row_pointers[k] =
 528             (const_cast<UInt8 *>(pImage->getData())) +
 529             (pImage->getHeight() - 1 - k) *
 530             pImage->getWidth() * pImage->getBpp();
 531     }
 532
 533     /* write out the entire image data in one call */
 534     png_write_image(png_ptr, row_pointers);
 535
 536     /* It is REQUIRED to call this to finish writing the rest of the file */
 537     png_write_end(png_ptr, info_ptr);
 538
 539     /* clean up after the write, and free any memory allocated */
 540     png_destroy_write_struct(&png_ptr, &info_ptr);
 541
 542     delete [] row_pointers;
 543
 544     /* that's it */
 545     return true;
 546
 547 #else
 548     SWARNING << getMimeType()
 549              << " write is not compiled into the current binary "
 550              << endLog;
 551
 552     return false;
 553 #endif
 554 }
 555
 556
 557 //-------------------------------------------------------------------------
 558 /*!
 559   Tries to determine the mime type of the data provided by an input stream
 560   by searching for magic bytes. Returns the mime type or an empty string
 561   when the function could not determine the mime type.
 562 */
 563 std::string PNGImageFileType::determineMimetypeFromStream(std::istream &is)
 564 {
 565     char filecode[4];
 566     is.read(filecode, 4);
 567     is.seekg(-4, std::ios::cur);
 568
 569     return strncmp(filecode, "\x89PNG", 4) == 0 ?
 570         std::string(getMimeType()) : std::string();
 571 }
 572
 573
 574
 575 bool PNGImageFileType::validateHeader(const Char8 *fileName, bool &implemented)
 576 {
 577     implemented = true;
 578
 579     if(fileName == NULL)
 580         return false;
 581
 582     FILE *file = fopen(fileName, "rb");
 583
 584     if(file == NULL)
 585         return false;
 586
 587     std::string magic;
 588
 589     magic.resize(4);
 590
 591     fread(static_cast<void *>(&magic[0]), 4, 1, file);
 592
 593     fclose(file);
 594
 595     if(magic == "\x89PNG")
 596     {
 597         return true;
 598     }
 599
 600     return false;
 601 }
 602
 603 #ifdef OSG_WITH_PNG
 604 typedef struct
 605 {
 606     UChar8 *buffer;
 607     UInt64 length;
 608 } BufferInfo;
 609
 610 static void user_read_data(png_structp png_ptr,
 611                            png_bytep data, png_size_t length)
 612 {
 613     BufferInfo *bufferInfo = static_cast<BufferInfo *>(png_get_io_ptr(png_ptr));
 614     memcpy(static_cast<void *>(data),
 615            static_cast<void *>(bufferInfo->buffer),
 616            length);
 617     bufferInfo->buffer += length;
 618     bufferInfo->length += length;
 619 }
 620 #endif
 621
 622 /* */
 623 UInt64 PNGImageFileType::restoreData(      Image  *OSG_PNG_ARG  (pImage ),
 624                                      const UChar8 *OSG_PNG_ARG  (buffer ),
 625                                            Int32   OSG_CHECK_ARG(memSize)) const
 626 {
 627 #ifdef OSG_WITH_PNG
 628
 629     UInt64              retCode;
 630     Image::PixelFormat  pixelFormat = Image::OSG_INVALID_PF;
 631     png_structp         png_ptr;
 632     png_infop           info_ptr;
 633     png_uint_32         width, wc, height, h, i;
 634     png_byte            bit_depth, channels, color_type;
 635     png_bytep           *row_pointers, base;
 636
 637     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
 638
 639     if(!png_ptr)
 640     {
 641         return 0;
 642     }
 643
 644     png_set_error_fn(png_ptr, 0, &errorOutput, &warningOutput);
 645
 646     info_ptr = png_create_info_struct(png_ptr);
 647
 648     if(!info_ptr)
 649     {
 650         png_destroy_read_struct(&png_ptr, 0, 0);
 651         return 0;
 652     }
 653
 654     if(setjmp(png_jmpbuf(png_ptr)))
 655     {
 656         png_destroy_read_struct(&png_ptr, &info_ptr, 0);
 657         return 0;
 658     }
 659
 660     BufferInfo bufferInfo;
 661     bufferInfo.buffer = const_cast<UChar8 *>(buffer);
 662     bufferInfo.length = 0;
 663     png_set_read_fn(png_ptr, static_cast<void *>(&bufferInfo), user_read_data);
 664
 665     png_read_info(png_ptr, info_ptr);
 666
 667     width = png_get_image_width(png_ptr, info_ptr);
 668     height = png_get_image_height(png_ptr, info_ptr);
 669     bit_depth = png_get_bit_depth(png_ptr, info_ptr);
 670     channels = png_get_channels(png_ptr, info_ptr);
 671     color_type = png_get_color_type(png_ptr, info_ptr);
 672
 673     // Convert paletted images to RGB
 674     if(color_type == PNG_COLOR_TYPE_PALETTE)
 675     {
 676         png_set_palette_to_rgb(png_ptr);
 677         channels = 3;
 678         bit_depth = 8;
 679     }
 680
 681     // Convert < 8 bit to 8 bit
 682     if(color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 683     {
 684         png_set_expand_gray_1_2_4_to_8(png_ptr);
 685         bit_depth = 8;
 686     }
 687
 688 #if BYTE_ORDER == LITTLE_ENDIAN
 689     if (bit_depth == 16)
 690         png_set_swap(png_ptr);
 691 #endif
 692
 693     // Add a full alpha channel if there is transparency
 694     // information in a tRNS chunk
 695     if(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 696     {
 697         png_set_tRNS_to_alpha(png_ptr);
 698         ++channels;
 699     }
 700
 701     Int32 dataType;
 702
 703     switch (bit_depth)
 704     {
 705         case 8:
 706             dataType = Image::OSG_UINT8_IMAGEDATA;
 707             break;
 708         case 16:
 709             dataType = Image::OSG_UINT16_IMAGEDATA;
 710             break;
 711         default:
 712             FWARNING (( "Invalid bit_depth: %d, can not read png-data\n",
 713                         bit_depth ));
 714             return false;
 715     }
 716
 717     switch(channels)
 718     {
 719         case 1:
 720             pixelFormat = Image::OSG_L_PF;
 721             break;
 722         case 2:
 723             pixelFormat = Image::OSG_LA_PF;
 724             break;
 725         case 3:
 726             pixelFormat = Image::OSG_RGB_PF;
 727             break;
 728         case 4:
 729             pixelFormat = Image::OSG_RGBA_PF;
 730             break;
 731     };
 732
 733     if(pImage->set(pixelFormat, width, height,
 734                    1, 1, 1, 0.0, 0,
 735                    dataType))
 736     {
 737         // Calculate the row pointers
 738         row_pointers = new png_bytep[height];
 739         wc = width * channels * (bit_depth / 8);
 740         h = height - 1;
 741         base = pImage->editData();
 742
 743         for(i = 0; i < height; ++i)
 744             row_pointers[i] = base + (h - i) * wc;
 745
 746         // Read the image data
 747         png_read_image(png_ptr, row_pointers);
 748
 749         delete[] row_pointers;
 750
 751         retCode = bufferInfo.length;
 752     }
 753     else
 754     {
 755         retCode = 0;
 756     }
 757
 758     png_destroy_read_struct(&png_ptr, &info_ptr, 0);
 759
 760     return retCode;
 761
 762 #else
 763     SWARNING << getMimeType()
 764              << " restoreData is not compiled into the current binary "
 765              << std::endl;
 766
 767     return 0;
 768 #endif
 769 }
 770
 771 #ifdef OSG_WITH_PNG
 772
 773 static void user_write_data(png_structp png_ptr,
 774                             png_bytep data, png_size_t length)
 775 {
 776     BufferInfo *bufferInfo = static_cast<BufferInfo *>(png_get_io_ptr(png_ptr));
 777     memcpy(static_cast<void *>(bufferInfo->buffer),
 778            static_cast<void *>(data),
 779            length);
 780     bufferInfo->buffer += length;
 781     bufferInfo->length += length;
 782 }
 783
 784 static void user_flush_data(png_structp OSG_CHECK_ARG(png_ptr))
 785 {
 786 }
 787
 788 #endif
 789
 790 //-------------------------------------------------------------------------
 791 /*! Tries to restore the image data from the given memblock.
 792     Returns the amount of data read.
 793  */
 794
 795 UInt64 PNGImageFileType::storeData(const Image  *OSG_PNG_ARG  (pImage  ),
 796                                          UChar8 *OSG_PNG_ARG  (buffer ),
 797                                          Int32   OSG_CHECK_ARG(memSize)) const
 798 {
 799 #ifdef OSG_WITH_PNG
 800
 801     png_structp png_ptr;
 802     png_infop info_ptr;
 803
 804     if(pImage->getDimension() < 1 || pImage->getDimension() > 2)
 805     {
 806         FWARNING(("PNGImageFileType::write: invalid dimension %d!\n",
 807                   pImage->getDimension()));
 808         return 0;
 809     }
 810
 811     /* Create and initialize the png_struct with the desired error handler
 812     * functions.  If you want to use the default stderr and longjump method,
 813     * you can supply NULL for the last three parameters.  We also check that
 814     * the library version is compatible with the one used at compile time,
 815     * in case we are using dynamically linked libraries.  REQUIRED.
 816     */
 817
 818     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
 819                                       0, &errorOutput, &warningOutput);
 820
 821     if (png_ptr == NULL)
 822     {
 823         return 0;
 824     }
 825
 826     /* Allocate/initialize the image information data.  REQUIRED */
 827     info_ptr = png_create_info_struct(png_ptr);
 828
 829     if(info_ptr == NULL)
 830     {
 831         png_destroy_write_struct(&png_ptr,  NULL);
 832         return 0;
 833     }
 834
 835     BufferInfo bufferInfo;
 836     bufferInfo.buffer = buffer;
 837     bufferInfo.length = 0;
 838
 839     png_set_write_fn(png_ptr,
 840                      static_cast<void *>(&bufferInfo),
 841                      user_write_data,
 842                      user_flush_data);
 843
 844     /* This is the hard way */
 845
 846     /* Set the image information here.  Width and height are up to 2^31,
 847     * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
 848     * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
 849     * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
 850     * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
 851     * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
 852     * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
 853     */
 854
 855     Int32 ctype;
 856     switch(pImage->getPixelFormat())
 857     {
 858         case Image::OSG_L_PF:
 859             ctype = PNG_COLOR_TYPE_GRAY;
 860             break;
 861
 862         case Image::OSG_LA_PF:
 863             ctype = PNG_COLOR_TYPE_GRAY_ALPHA;
 864             break;
 865
 866 #if defined(GL_BGR) || defined(GL_BGR_EXT)
 867         case Image::OSG_BGR_PF:
 868 #endif
 869         case Image::OSG_RGB_PF:
 870             ctype = PNG_COLOR_TYPE_RGB;
 871             break;
 872
 873 #if defined(GL_BGRA) || defined(GL_BGRA_EXT)
 874         case Image::OSG_BGRA_PF:
 875 #endif
 876         case Image::OSG_RGBA_PF:
 877             ctype = PNG_COLOR_TYPE_RGB_ALPHA;
 878             break;
 879
 880         default:
 881             FWARNING(("PNGImageFileType::write: unknown pixel format %d!\n",
 882                       pImage->getPixelFormat()));
 883             png_destroy_write_struct(&png_ptr,  NULL);
 884
 885             return 0;
 886     }
 887
 888     Int32 bit_depth;
 889
 890     switch (pImage->getDataType())
 891     {
 892         case Image::OSG_UINT8_IMAGEDATA:
 893             bit_depth = 8;
 894             break;
 895         case Image::OSG_UINT16_IMAGEDATA:
 896             bit_depth = 16;
 897             break;
 898         default:
 899             FWARNING (("Invalid pixeldepth, cannot store data\n"));
 900             return 0;
 901     };
 902
 903     png_set_IHDR(png_ptr,
 904                  info_ptr,
 905                  pImage->getWidth(),
 906                  pImage->getHeight(),
 907                  bit_depth,
 908                  ctype,
 909                  PNG_INTERLACE_NONE,
 910                  PNG_COMPRESSION_TYPE_BASE,
 911                  PNG_FILTER_TYPE_BASE);
 912
 913     /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
 914     /* note that if sRGB is present the gAMA and cHRM chunks must be ignored
 915     * on read and must be written in accordance with the sRGB profile */
 916
 917     /* Write the file header information.  REQUIRED */
 918
 919     png_write_info(png_ptr, info_ptr);
 920
 921 #if BYTE_ORDER == LITTLE_ENDIAN
 922     if (bit_depth == 16)
 923         png_set_swap(png_ptr);
 924 #endif
 925
 926     if(pImage->getPixelFormat() == Image::OSG_BGR_PF ||
 927        pImage->getPixelFormat() == Image::OSG_BGRA_PF)
 928     {
 929         /* flip BGR pixels to RGB */
 930         png_set_bgr(png_ptr);
 931
 932         /* swap location of alpha bytes from ARGB to RGBA */
 933         png_set_swap_alpha(png_ptr);
 934     }
 935
 936     /* The easiest way to write the image (you may have a different memory
 937      * layout, however, so choose what fits your needs best).  You need to
 938      * use the first method if you aren't handling interlacing yourself.
 939      */
 940
 941     png_bytep *row_pointers = new png_bytep [pImage->getHeight()];
 942
 943     for(Int32 k = 0; k < pImage->getHeight(); k++)
 944     {
 945         row_pointers[k] =
 946             (const_cast<UInt8 *>(pImage->getData())) +
 947             (pImage->getHeight() - 1 - k) *
 948             pImage->getWidth() * pImage->getBpp();
 949     }
 950
 951     /* write out the entire image data in one call */
 952     png_write_image(png_ptr, row_pointers);
 953
 954     /* It is REQUIRED to call this to finish writing the rest of the file */
 955     png_write_end(png_ptr, info_ptr);
 956
 957     /* clean up after the write, and free any memory allocated */
 958     png_destroy_write_struct(&png_ptr, &info_ptr);
 959
 960     delete [] row_pointers;
 961
 962     /* that's it */
 963     return bufferInfo.length;
 964 #else
 965     SWARNING << getMimeType()
 966              << " storeData is not compiled into the current binary "
 967              << std::endl;
 968
 969     return 0;
 970 #endif
 971 }
 972
 973 const PNGImageFileType &PNGImageFileType::the(void)
 974 {
 975     return _the;
 976 }
 977
 978 //-------------------------------------------------------------------------
 979 /*! Constructor used for the singleton object
 980  */
 981
 982 PNGImageFileType::PNGImageFileType(const Char8  *mimeType,
 983                                    const Char8  *suffixArray[],
 984                                          UInt16  suffixByteCount,
 985                                          UInt32  flags          ) :
 986
 987     Inherited(mimeType, suffixArray, suffixByteCount, flags)
 988 {
 989 }
 990
 991
 992 //-------------------------------------------------------------------------
 993 /*! Destructor
 994  */
 995
 996 PNGImageFileType::~PNGImageFileType(void)
 997 {
 998 }
 999
1000 OSG_END_NAMESPACE
1001