gif.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_GIF_HPP__
#define __CLAW_GIF_HPP__
 
#include <claw/graphic/color_palette.hpp>
#include <claw/graphic/image.hpp>
 
#include <claw/functional.hpp>
#include <claw/iterator.hpp>
#include <claw/lzw_decoder.hpp>
#include <claw/types.hpp>
 
#include <list>
 
namespace claw
{
  namespace graphic
  {
    class gif : public image
    {
    public:
      class frame : public image
      {
      public:
        typedef image super;
 
      public:
        frame();
        frame(std::size_t w, std::size_t h);
 
        void set_delay(unsigned int d);
        unsigned int get_delay() const;
 
      private:
        unsigned int m_delay;
 
      }; // class frame
 
    private:
      typedef std::list<frame*> frame_list;

      typedef image super;
 
    public:
      typedef wrapped_iterator<frame, frame_list::iterator,
                               claw::dereference<frame> >::iterator_type
          frame_iterator;

      typedef wrapped_iterator<const frame, frame_list::const_iterator,
                               claw::const_dereference<frame> >::iterator_type
          const_frame_iterator;
 
    private:
#pragma pack(push, 1)

      struct header
      {
        u_int_8 signature[3];

        u_int_8 version[3];
 
      }; // struct header

      struct screen_descriptor
      {
      public:
        bool has_global_color_table() const;
        unsigned int color_palette_size() const;
 
      public:
        u_int_16 screen_width;

        u_int_16 screen_height;

        u_int_8 packed;

        u_int_8 background_color;

        u_int_8 aspect_ratio;
 
      }; // struct screen_descriptor

      struct image_descriptor
      {
      public:
        static const u_int_8 block_id = 0x2C;
 
      public:
        bool has_color_table() const;
        bool is_interlaced() const;
        unsigned int color_palette_size() const;
 
      public:
        u_int_16 left;

        u_int_16 top;

        u_int_16 width;

        u_int_16 height;

        u_int_8 packed;
 
      }; // struct image_descriptor

      struct extension
      {
        static const u_int_8 block_id = 0x21;
 
        // no field
      }; // struct extension

      struct trailer
      {
        static const u_int_8 block_id = 0x3B;
 
        // no field
      }; // trailer

      struct graphic_control_extension
      {
      public:
        static const u_int_8 block_label = 0xF9;

        enum disposal_method
        {
          dispose_none,

          dispose_do_not_dispose,

          dispose_background,

          dispose_previous
 
        }; // enum disposal_method
 
      public:
        disposal_method get_disposal_method() const;
        bool has_transparent_color() const;
 
      public:
        u_int_8 block_size;

        u_int_8 packed;

        u_int_16 delay;

        u_int_8 transparent_color;

        u_int_8 terminator;
 
      }; // struct graphic_control_extension

      struct comment_extension
      {
      public:
        static const u_int_8 block_label = 0xFE;
 
      public:
        // this block is ignored.
 
      }; // struct comment_extension

      struct plain_text_extension
      {
      public:
        static const u_int_8 block_label = 0x01;
 
      public:
        // this block is ignored.
 
      }; // struct plain_text_extension

      struct application_extension
      {
      public:
        static const u_int_8 block_label = 0xFF;
 
      public:
        // this block is ignored.
 
      }; // struct application_extension
#pragma pack(pop)
 
    public:
      class reader
      {
      private:
        typedef color_palette<rgb_pixel> palette_type;

        struct reader_info
        {
          screen_descriptor sd;

          palette_type* palette;

          int transparent_color_index;

          std::vector<graphic_control_extension::disposal_method>
              disposal_method;
 
        }; // struct reader_info

        class input_buffer
        {
        public:
          input_buffer(std::istream& is, u_int_8 code_size);
 
          bool end_of_data() const;
          bool end_of_information() const;
          unsigned int symbols_count() const;
          unsigned int get_next();
 
          void reset();
          void new_code(unsigned int code);
 
        private:
          void fill_buffer();
 
        private:
          unsigned int m_val;

          std::istream& m_input;

          char m_buffer[257];

          std::size_t m_pending;

          unsigned char m_pending_bits;

          std::size_t m_pending_end;

          u_int_8 m_next_data_length;

          const unsigned int m_initial_code_size;

          unsigned int m_code_size;

          unsigned int m_code_limit;
 
        }; // class input_buffer

        class output_buffer
        {
        public:
          output_buffer(const palette_type& p, const image_descriptor& id,
                        int transparent_color_index, image& output);
 
          void write(unsigned int code);
 
        private:
          const palette_type& m_palette;

          const image_descriptor& m_id;

          const int m_transparent_color_index;

          image& m_output;

          std::size_t m_x;

          std::size_t m_y;

          int m_interlace_pass;

          int m_interlace_step;
 
        }; // class output_buffer

        typedef claw::lzw_decoder<input_buffer, output_buffer> gif_lzw_decoder;
 
      public:
        reader(image& img);
        reader(image& img, std::istream& f);
        reader(frame_list& frames, std::istream& f);
        reader(image& img, frame_list& frames, std::istream& f);
        ~reader();
 
        void load(std::istream& f);
 
      private:
        void clear();
        void inside_load(std::istream& f);
        void make_frames(const reader_info& info);
        void fill_background(image& img, const reader_info& info) const;
 
        void check_if_gif(std::istream& f) const;
        void read_screen_descriptor(std::istream& f, reader_info& info);
 
        void read_palette(std::istream& f, palette_type& p) const;
        void read_data(std::istream& f, reader_info& info);
        void read_frame(std::istream& f, reader_info& info);
        void read_frame_with_gce(std::istream& f, reader_info& info);
 
        void skip_extension(std::istream& f) const;
        void read_frame_data(std::istream& f, const reader_info& info,
                             frame& the_frame) const;
 
        void decode_data(std::istream& f, const palette_type& palette,
                         const image_descriptor& id,
                         int transparent_color_index, frame& the_frame) const;
 
      private:
        image* m_image;

        frame_list m_frame;
 
      }; // class reader
 
    public:
      gif();
      gif(const gif& that);
      gif(std::istream& f);
      ~gif();
 
      gif& operator=(const gif& that);
      void swap(gif& that);
 
      frame_iterator frame_begin();
      frame_iterator frame_end();
      const_frame_iterator frame_begin() const;
      const_frame_iterator frame_end() const;
 
    private:
      frame_list m_frame;
 
    }; // class gif
  }
}
 
namespace std
{
  void swap(claw::graphic::gif& a, claw::graphic::gif& b);
}
 
#endif // __CLAW_GIF_HPP__