png.hpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful
 
  CLAW is a free library without any particular aim but being useful to
  anyone.
 
  Copyright (C) 2005-2011 Julien Jorge
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  contact: julien.jorge@stuff-o-matic.com
*/
#ifndef __CLAW_PNG_HPP__
#define __CLAW_PNG_HPP__
 
#include <claw/graphic/image.hpp>
 
#include <iostream>
#include <png.h>
#include <setjmp.h>
#include <string>
#include <zlib.h>
 
namespace claw
{
  namespace graphic
  {
    class png : public image
    {
    public:
      class reader
      {
        // classes that need to be accessible from png callbacks.
      public:
        struct source_manager
        {
        public:
          source_manager(std::istream& is);
 
          void read(png_bytep data, png_size_t length);
 
        private:
          std::istream& m_input;
 
        }; // struct source_manager
 
      public:
        reader(image& img);
        reader(image& img, std::istream& f);
 
        void load(std::istream& f);
 
      private:
        void read_from_file(std::istream& f);
        void check_if_png(png_structp png_ptr, std::istream& f) const;
 
        void read_image(png_structp png_ptr, png_infop info_ptr);
        void read_sequential_image(png_structp png_ptr, png_infop info_ptr);
        void read_interlaced_image(png_structp png_ptr, png_infop info_ptr,
                                   unsigned int passes);
 
        void copy_pixel_line(png_byte color_type, png_bytep data,
                             unsigned int y);
 
        void create_read_structures(png_structp& png_ptr,
                                    png_infop& info_ptr) const;
 
      private:
        image& m_image;

        static const unsigned int s_rgba_pixel_size;
 
      }; // class reader

      class writer
      {
      public:
        struct options
        {
        public:
          enum compression_level
          {
            no_compression = Z_NO_COMPRESSION,
            best_speed = Z_BEST_SPEED,
            best_compression = Z_BEST_COMPRESSION,
            default_compression = Z_DEFAULT_COMPRESSION
          }; // enum compression_level

          enum interlace_type
          {
            none = PNG_INTERLACE_NONE,

            adam7 = PNG_INTERLACE_ADAM7
          }; // enum interlace_type
 
        public:
          options();
          options(compression_level compression_level_,
                  interlace_type interlace_);
 
        public:
          compression_level compression;

          interlace_type interlace;
 
        }; // struct options
 
        // classes that need to be accessible from png callbacks.

        struct target_manager
        {
        public:
          target_manager(std::ostream& os);
 
          void write(png_bytep data, png_size_t length);
          void flush();
 
        private:
          std::ostream& m_output;
 
        }; // struct target_manager
 
      public:
        writer(const image& img);
        writer(const image& img, std::ostream& f,
               const options& opt = options());
 
        void save(std::ostream& f, const options& opt = options()) const;
 
      private:
        void set_options(png_structp png_ptr, png_infop info_ptr,
                         const options& opt) const;
        void save_image(png_structp png_ptr, png_infop info_ptr) const;
 
        void copy_pixel_line(png_bytep data, unsigned int y) const;
 
        void create_write_structures(png_structp& png_ptr,
                                     png_infop& info_ptr) const;
 
      private:
        const image& m_image;

        static const unsigned int s_rgba_pixel_size;
 
      }; // class writer
 
    public:
      png(unsigned int w, unsigned int h);
      png(const image& that);
      png(std::istream& f);
 
      void save(std::ostream& os,
                const writer::options& opt = writer::options()) const;
 
    }; // class png
  }
}
 
#endif // __CLAW_PNG_HPP__