image_libpng.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <errno.h>

#include <cstdio>

#include <iostream>
#include <string>

#include <png.h>

// There is a bug in libpng which forces us to put this include below png.h
#include <setjmp.h>

#include <archon/util/mutex.H>
#include <archon/util/text.H>
#include <archon/util/charenc.H>

#include <archon/util/image_png.H>

using namespace std;

namespace Archon
{
  namespace Utilities
  {

    struct FormatLibpng: Image::Format
    {
      string getSpecifier() const
      {
        return "png";
      }

      bool checkSignature(Ref<Stream::Reader> r) const
      {
        char header[8];
        return r->readAll(header, 8)==8 &&
          !png_sig_cmp(reinterpret_cast<png_bytep>(header), 0, 8);
      }

      bool checkSuffix(string s) const
      {
        return s == "png";
      }

      Image load(Ref<Stream::Reader> reader, Image::ProgressTracker *tracker,
                 Logger *logger) const
        throw(Image::InvalidFormatException,
              IOException, UnexpectedException)
      {
        char header[8];
        if(reader->readAll(header, 8) != 8 ||
           png_sig_cmp(reinterpret_cast<png_bytep>(header), 0, 8))
          ARCHON_THROW1(Image::InvalidFormatException, "Not a PNG header");

        LoadContext c(reader, tracker, logger);
        LoadWrapper w;

        w.png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, &c,
                                           errorCallback, warningCallback);
        if(!w.png_ptr)
          ARCHON_THROW1(ResourceException,
                        "PNG library was unable to allocate "
                        "a 'png_struct' structure");

        w.info_ptr = png_create_info_struct(w.png_ptr);
        if(!w.info_ptr)
          ARCHON_THROW1(ResourceException,
                        "PNG library was unable to allocate "
                        "first 'png_info' structure");

        w.end_info_ptr = png_create_info_struct(w.png_ptr);
        if(!w.end_info_ptr)
          ARCHON_THROW1(ResourceException,
                        "PNG library was unable to allocate "
                        "second 'png_info' structure");

        png_set_read_fn(w.png_ptr, 0, readCallback);
        png_set_read_status_fn(w.png_ptr, progressCallback);

        string comment;
        Image image;
        Array<png_byte *> rowPointers;

        /*
         * Handle termination and catch errors occuring in any of the
         * following PNG-functions.
         */
        if(!setjmp(png_jmpbuf(w.png_ptr))) // try
        {
          png_set_sig_bytes(w.png_ptr, 8);
          png_read_info(w.png_ptr, w.info_ptr);

          // Set up PNG read transformations
          unsigned bitsPerComponent = png_get_bit_depth(w.png_ptr, w.info_ptr);
          const png_byte colorType = png_get_color_type(w.png_ptr, w.info_ptr);
          if(bitsPerComponent > 8) png_set_swap(w.png_ptr);
          if(bitsPerComponent < 8) png_set_packing(w.png_ptr);
          if(colorType == PNG_COLOR_TYPE_PALETTE)
            png_set_palette_to_rgb(w.png_ptr);
          /* Should we do this transformation?
             if(png_get_valid(w.png_ptr, w.info_ptr, PNG_INFO_tRNS))
             png_set_tRNS_to_alpha(w.png_ptr);
          */


          // Fetch the image geometry
          png_read_update_info(w.png_ptr, w.info_ptr); // Updated header information
          unsigned height = png_get_image_height(w.png_ptr, w.info_ptr);
          unsigned width  = png_get_image_width (w.png_ptr, w.info_ptr);
          Image::ComponentSpecifier components =
            static_cast<Image::ComponentSpecifier>(png_get_channels(w.png_ptr,
                                                           w.info_ptr));
          unsigned charsPerPixel = (bitsPerComponent*components+7)/8;
          unsigned charsPerRow   = charsPerPixel*width;

          if(png_get_rowbytes(w.png_ptr, w.info_ptr) != charsPerRow)
            ARCHON_THROW1(InternalException,
                          "Unexpected number of bytes per row "
                          "reported by the PNG library");

          comment = "N/Y/A";

          // Construct an image with an uninitialized pixel buffer
          image = Image(width, height, components, bitsPerComponent, comment);

          // Make row array
          png_byte *pixelBuffer =
            reinterpret_cast<png_byte *>(getPixelBufferNoLeak(image));
          rowPointers.reset(height);
          for(unsigned i=0; i<height; ++i)
            rowPointers[i] = pixelBuffer + (height-i-1)*charsPerRow;

          c.totalRows = height; // For the progress tracker

          png_read_image(w.png_ptr, rowPointers.get());
          png_read_end(w.png_ptr, w.end_info_ptr);
        }
        else // catch
        {
          switch(c.errorType)
          {
          case 1: throw ThreadTerminatedException(c.errorLocation);
          case 2: throw Stream::ReadException(c.errorLocation, c.errorMessage);
          case 3: throw UnexpectedException(c.errorLocation, c.errorMessage);
          }
          ARCHON_THROW1(Image::InvalidFormatException, c.errorMessage);
        }

        return image;
      }


      void save(Image image, Ref<Stream::Writer> writer,
                Image::ProgressTracker *tracker, Logger *logger) const
      throw(IOException, UnexpectedException)
      {
        SaveContext c(writer, tracker, logger);
        SaveWrapper w;

        w.png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, &c,
                                            errorCallback, warningCallback);
        if(!w.png_ptr)
          ARCHON_THROW1(ResourceException,
                        "PNG library was unable to allocate "
                        "a 'png_struct' structure");

        w.info_ptr = png_create_info_struct(w.png_ptr);
        if(!w.info_ptr)
          ARCHON_THROW1(ResourceException,
                        "PNG library was unable to allocate "
                        "first 'png_info' structure");

        png_set_write_fn(w.png_ptr, 0, writeCallback, flushCallback);
        png_set_write_status_fn(w.png_ptr, progressCallback);

        string comment = image.getComment();
        Array<png_byte *> rowPointers;

        /*
         * Handle termination and catch errors occuring in any of the
         * following PNG-functions.
         */
        if(!setjmp(png_jmpbuf(w.png_ptr))) // try
        {
          int colorType;
          switch(image.getComponentSpecifier())
          {
          case Image::components_l:    colorType = PNG_COLOR_TYPE_GRAY;       break;
          case Image::components_la:   colorType = PNG_COLOR_TYPE_GRAY_ALPHA; break;
          case Image::components_rgb:  colorType = PNG_COLOR_TYPE_RGB;        break;
          case Image::components_rgba: colorType = PNG_COLOR_TYPE_RGB_ALPHA;  break;
          default:
            ARCHON_THROW1(InternalException,
                          "Unexpected channel specifier " +
                          Text::toString(image.getComponentSpecifier()));
          };

          unsigned height = image.getHeight();
          unsigned bitsPerComponent = image.getBitsPerComponent();
          png_set_IHDR(w.png_ptr, w.info_ptr, image.getWidth(), height,
                       bitsPerComponent, colorType, PNG_INTERLACE_NONE,
                       PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

          png_write_info(w.png_ptr, w.info_ptr);

          // Set PNG read transformations
          if(bitsPerComponent < 8) png_set_packing(w.png_ptr);
          if(bitsPerComponent > 8) png_set_swap(w.png_ptr);

          png_byte *pixelBuffer =
            reinterpret_cast<png_byte *>(getPixelBufferNoLeak(image));
          rowPointers.reset(height);
          for(unsigned i=0; i<height; i++)
            rowPointers[i] = pixelBuffer + (height-i-1)*image.getCharsPerRow();

          c.totalRows = height; // For the progress tracker

          png_write_image(w.png_ptr, rowPointers.get());

          // Add the comment after the pixel data
          if(!comment.empty())
          {
            // Get rid of NUL characters in the comment. The PNG spec does
            // not allow them.
            string::size_type i = 0;
            for(;;)
            {
              string::size_type p = comment.find('\0');
              if(p == string::npos) break;
              comment.replace(i, 1, "\xEF\xBF\xBD"); // Unicode replacement character
            }

            png_text text;

#ifdef PNG_iTXt_SUPPORTED

            text.text_length = 0;
            text.itxt_length = comment.size();
            text.lang        = 0;
            text.lang_key    = 0;
            text.compression = comment.size() < 1000 ?
              PNG_ITXT_COMPRESSION_NONE : PNG_ITXT_COMPRESSION_zTXt;

#else

            comment = CharEnc::transcode(comment, CharEnc::UTF_8,
                                         CharEnc::ISO_8859_1);
            text.text_length = comment.size();
            text.compression = comment.size() < 1000 ?
              PNG_TEXT_COMPRESSION_NONE : PNG_TEXT_COMPRESSION_zTXt;

#endif

            text.key         = "Comment";
            text.text        = const_cast<char *>(comment.data());

            png_set_text(w.png_ptr, w.info_ptr, &text, 1);
          }

          png_write_end(w.png_ptr, 0);
        }
        else // catch
        {
          switch(c.errorType)
          {
          case 1: throw ThreadTerminatedException(c.errorLocation);
          case 2: throw Stream::ReadException(c.errorLocation, c.errorMessage);
          case 3: throw UnexpectedException(c.errorLocation, c.errorMessage);
          }
          ARCHON_THROW1(Image::InvalidFormatException, c.errorMessage);
        }
      }

    private:

      struct Context
      {
        double totalRows;
        Image::ProgressTracker *tracker;
        Logger *logger;       // For warnings
        int errorType;        // 0 for none, 1 for ThreadTerminatedException,
                              // 2 for IOException, 3 for UnexpectedException
                              // from the stream, 4 for libpng initiated
                              // error or invalid format detected.
        string errorMessage;  // For fatal errors
        string errorLocation; // Source file location from exception
        Context(Image::ProgressTracker *tracker, Logger *logger):
          totalRows(0), tracker(tracker), logger(logger), errorType(0)  {}
      };

      struct LoadContext: Context
      {
        Ref<Stream::Reader> reader;
        LoadContext(Ref<Stream::Reader> reader, Image::ProgressTracker *tracker,
                    Logger *logger): Context(tracker, logger), reader(reader) {}
      };

      struct SaveContext: Context
      {
        Ref<Stream::Writer> writer;
        SaveContext(Ref<Stream::Writer> writer, Image::ProgressTracker *tracker,
                    Logger *logger): Context(tracker, logger), writer(writer) {}
      };

      struct LoadWrapper
      {
        png_structp png_ptr;
        png_infop info_ptr;
        png_infop end_info_ptr;
        LoadWrapper():png_ptr(0), info_ptr(0), end_info_ptr(0) {}
        ~LoadWrapper()
        {
          if(png_ptr) png_destroy_read_struct(&png_ptr, info_ptr ? &info_ptr : 0,
                                              end_info_ptr ? &end_info_ptr : 0);
        }
      };

      struct SaveWrapper
      {
        png_structp png_ptr;
        png_infop info_ptr;
        SaveWrapper():png_ptr(0), info_ptr(0) {}
        ~SaveWrapper()
        {
          if(png_ptr) png_destroy_write_struct(&png_ptr, info_ptr ? &info_ptr : 0);
        }
      };

      static void errorCallback(png_structp png_ptr, png_const_charp message) throw()
      {
        {
          Context *c = static_cast<Context *>(png_get_error_ptr(png_ptr));
          c->errorType    = 4;
          c->errorMessage = message;
        }
        longjmp(png_jmpbuf(png_ptr), 1);
      }

      static void warningCallback(png_structp png_ptr, png_const_charp message) throw()
      {
        Context *c = static_cast<Context *>(png_get_error_ptr(png_ptr));
        if(c->logger) c->logger->log(message);
      }

      static void progressCallback(png_structp png_ptr, png_uint_32 row, int pass) throw()
      {
        Context *c = static_cast<Context *>(png_get_error_ptr(png_ptr));
        // if(c->logger) c->logger->log("Progress " + Text::toString(row) + "/" + Text::toString(c->totalRows) + " (" + Text::toString(pass) + ")");
        if(c->tracker && c->totalRows) c->tracker->progress(row/c->totalRows);
      }

      static void readCallback(png_structp png_ptr, png_bytep data,
                        png_size_t length) throw()
      {
        LoadContext *c = static_cast<LoadContext *>(png_get_error_ptr(png_ptr));
        try
        {
          const int n = c->reader->readAll(reinterpret_cast<char *>(data),
                                           static_cast<int>(length));
          if(n == static_cast<int>(length)) return;

          c->errorType    = 4;
          c->errorMessage = "Premature end of PNG data";
        }
        catch(ThreadTerminatedException &e)
        {
          c->errorType     = 1;
          c->errorLocation = e.getLocation();
        }
        catch(IOException &e)
        {
          c->errorType     = 2;
          c->errorLocation = e.getLocation();
          c->errorMessage  = e.getMessage();
        }
        catch(UnexpectedException &e)
        {
          c->errorType     = 3;
          c->errorLocation = e.getLocation();
          c->errorMessage  = e.getMessage();
        }

        longjmp(png_jmpbuf(png_ptr), 1);
      }

      static void writeCallback(png_structp png_ptr, png_bytep data,
                                png_size_t length) throw()
      {
        SaveContext *c = static_cast<SaveContext *>(png_get_error_ptr(png_ptr));
        try
        {
          c->writer->writeAll(reinterpret_cast<const char *>(data),
                              static_cast<int>(length));
          return;
        }
        catch(ThreadTerminatedException &e)
        {
          c->errorType     = 1;
          c->errorLocation = e.getLocation();
        }
        catch(IOException &e)
        {
          c->errorType     = 2;
          c->errorLocation = e.getLocation();
          c->errorMessage  = e.getMessage();
        }
        catch(UnexpectedException &e)
        {
          c->errorType     = 3;
          c->errorLocation = e.getLocation();
          c->errorMessage  = e.getMessage();
        }

        longjmp(png_jmpbuf(png_ptr), 1);
      }

      static void flushCallback(png_structp png_ptr)
      {
      }
    };

    Image::Format *getDefaultPngFormat()
    {
      static FormatLibpng f;
      return &f;
    }
  }
}

---