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@gamned.org
*/
#ifndef __CLAW_GIF_HPP__
#define __CLAW_GIF_HPP__
 
#include <claw/color_palette.hpp>
#include <claw/functional.hpp>
#include <claw/image.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 graphic
} // namespace claw
 
namespace std
{
  void swap( claw::graphic::gif& a, claw::graphic::gif& b );
} // namespace std
 
#endif // __CLAW_GIF_HPP__