bitmap.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_BITMAP_HPP__
#define __CLAW_BITMAP_HPP__
 
#include <claw/graphic/color_palette.hpp>
#include <claw/graphic/image.hpp>
 
#include <claw/buffered_istream.hpp>
#include <claw/rle_decoder.hpp>
 
#include <iostream>
#include <vector>
 
namespace claw
{
  namespace graphic
  {
    class bitmap : public image
    {
    private:
      class file_structure
      {
      public:
        typedef color_palette<rgba_pixel_8> color_palette_type;

        enum compression
        {
          BMP_COMPRESSION_RGB = 0,
          BMP_COMPRESSION_RLE8 = 1,
          BMP_COMPRESSION_RLE4 = 2,
          BMP_COMPRESSION_BITFIELDS = 3
        };
 
#pragma pack(push, 2)

        struct header
        {
          char id[2];

          unsigned int file_size;

          unsigned int nop;

          unsigned int data_offset;

          unsigned int header_size;

          unsigned int width;

          unsigned int height;

          unsigned short layers;

          unsigned short bpp;

          unsigned int compression;

          unsigned int image_size;

          unsigned int ppm_x;

          unsigned int ppm_y;

          unsigned int colors_count;

          unsigned int importants_colors;
        };
#pragma pack(pop)
 
      }; // class file_structure
 
    public:
      class reader : private file_structure
      {
      private:
        typedef buffered_istream<std::istream> file_input_buffer;

        template <bool Coded4bits>
        class rle_bitmap_output_buffer
        {
        public:
          rle_bitmap_output_buffer(const color_palette_type& palette,
                                   image& image);
 
          void fill(unsigned int n, unsigned char pattern);
          void copy(unsigned int n, file_input_buffer& buffer);
 
          void next_line();
          void delta_move(unsigned char x, unsigned char y);
 
        private:
          const color_palette_type& m_palette;

          image& m_image;

          unsigned int m_x;

          unsigned int m_y;
 
        }; // class rle_bitmap_output_buffer

        template <typename OutputBuffer>
        class rle_bitmap_decoder
          : public rle_decoder<char, file_input_buffer, OutputBuffer>
        {
        public:
          typedef OutputBuffer output_buffer_type;
 
        private:
          virtual void read_mode(file_input_buffer& input,
                                 output_buffer_type& output);
        }; // class rle_bitmap_decoder

        typedef rle_bitmap_decoder<rle_bitmap_output_buffer<true> >
            rle4_decoder;

        typedef rle_bitmap_decoder<rle_bitmap_output_buffer<false> >
            rle8_decoder;

        class pixel1_to_pixel32
        {
        public:
          void operator()(scanline& dest, const char* src,
                          const color_palette_type& palette) const;
        }; // class pixel1_to_pixel32

        class pixel4_to_pixel32
        {
        public:
          void operator()(scanline& dest, const char* src,
                          const color_palette_type& palette) const;
        }; // class pixel4_to_pixel32

        class pixel8_to_pixel32
        {
        public:
          void operator()(scanline& dest, const char* src,
                          const color_palette_type& palette) const;
        }; // class pixel8_to_pixel32

        class pixel24_to_pixel32
        {
        public:
          void operator()(scanline& dest, const char* src,
                          const color_palette_type& palette) const;
        }; // class pixel24_to_pixel32
 
      public:
        reader(image& img);
        reader(image& img, std::istream& f);
 
        void load(std::istream& f);
 
      private:
        void load_palette(const header& h, std::istream& f,
                          color_palette_type& palette) const;
 
        void load_1bpp(const header& h, std::istream& f);
        void load_4bpp(const header& h, std::istream& f);
        void load_8bpp(const header& h, std::istream& f);
        void load_24bpp(const header& h, std::istream& f);
 
        void load_4bpp_rle(const header& h, std::istream& f,
                           const color_palette_type& palette);
        void load_4bpp_rgb(const header& h, std::istream& f,
                           const color_palette_type& palette);
        void load_8bpp_rle(const header& h, std::istream& f,
                           const color_palette_type& palette);
        void load_8bpp_rgb(const header& h, std::istream& f,
                           const color_palette_type& palette);
 
        template <typename Convert>
        void load_rgb_data(std::istream& f, unsigned int buffer_size,
                           const color_palette_type& palette,
                           const Convert& pixel_convert);
 
      private:
        image& m_image;
 
      }; // class reader

      class writer : private file_structure
      {
      public:
        writer(const image& img);
        writer(const image& img, std::ostream& f);
 
        void save(std::ostream& f) const;
 
      private:
        void save_data(std::ostream& f) const;
 
        void pixel32_to_pixel24(char* dest, const scanline& src) const;
 
        void init_header(header& h) const;
 
      private:
        const image& m_image;
 
      }; // class writer
 
    public:
      bitmap(unsigned int w, unsigned int h);
      bitmap(const image& that);
      bitmap(std::istream& f);
 
      void save(std::ostream& f) const;
    }; // class bitmap
 
  }
}
 
#include <claw/graphic/bitmap_reader.tpp>
 
#endif // __CLAW_BITMAP_HPP__