targa.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_TARGA_HPP__
#define __CLAW_TARGA_HPP__

#include <iostream>
#include <claw/image.hpp>
#include <claw/rle_decoder.hpp>
#include <claw/rle_encoder.hpp>
#include <claw/color_palette.hpp>
#include <claw/buffered_istream.hpp>

namespace claw
{
  namespace graphic
  {
    class targa : public image
    {
    private:
      /*----------------------------------------------------------------------*/
      class file_structure
      {
      public:
        enum image_coding
          {
            color_mapped        = 1,
            true_color          = 2,
            black_and_white     = 3,
            rle_color_mapped    = 9,
            rle_true_color      = 10,
            rle_black_and_white = 11
          }; // enum image_coding

#       pragma pack (push,1)

        /*--------------------------------------------------------------------*/
        class header
        {
        public:
          header();
          header( unsigned int w, unsigned int h );

        public:
          char id_length;
          char color_map;
          char image_type;

          struct
          {
            unsigned short first_entry_index;
            unsigned short length;
            unsigned char entry_size;
          } color_map_specification;

          struct specification
          {
            unsigned short x_origin;
            unsigned short y_origin;
            unsigned short width;
            unsigned short height;
            unsigned char bpp;
            unsigned char descriptor;

            bool up_down_oriented() const ;
            bool left_right_oriented() const ;
            unsigned char alpha() const;
          }; // struct specification

          specification image_specification;
        }; // struct header

        /*--------------------------------------------------------------------*/
        struct developer_item
        {
          unsigned short tag;
          unsigned int offset;
          unsigned int size;
        }; // struct developer_item

        /*--------------------------------------------------------------------*/
        struct extension
        {
           
        }; // struct extension

        /*--------------------------------------------------------------------*/
        class footer
        {
        public:
          footer();

          bool is_valid() const;

        public:
          unsigned int extension_offset;

          unsigned int developer_offset;

          char signature[18];

        private:
          static const std::string s_signature;

        }; // struct footer
#       pragma pack (pop)

      }; // class file_structure

      /*----------------------------------------------------------------------*/
      struct pixel16
      {
      }; // struct pixel16

      /*----------------------------------------------------------------------*/
      struct pixel8
      {
      }; // struct pixel8

      /*----------------------------------------------------------------------*/
      typedef color_palette<rgba_pixel_8> color_palette32;

    public:
      /*----------------------------------------------------------------------*/
      class reader : private file_structure
      {
      private:
        /*--------------------------------------------------------------------*/
        template<typename Pixel>
        class file_input_buffer : public buffered_istream<std::istream>
        {
        private:
          typedef Pixel pixel_type;

        public:
          file_input_buffer( std::istream& f );
          rgba_pixel_8 get_pixel();

        }; // class file_input_buffer

        /*--------------------------------------------------------------------*/
        template<typename Pixel>
        class mapped_file_input_buffer:
          public buffered_istream<std::istream>
        {
        private:
          typedef Pixel pixel_type;

        public:
          mapped_file_input_buffer( std::istream& f, const color_palette32& p );
          rgba_pixel_8 get_pixel();

        private:
          const color_palette32& m_palette;

        }; // class mapped_file_input_buffer

        /*--------------------------------------------------------------------*/
        template< typename InputBuffer >
        class rle_targa_output_buffer
        {
        private:
          typedef rgba_pixel_8 pixel_type;

          typedef InputBuffer input_buffer_type;

        public:
          rle_targa_output_buffer( image& img, bool up_down, bool left_right );
        
          void fill( unsigned int n, rgba_pixel_8 pattern );
          void copy( unsigned int n, input_buffer_type& buffer );
        
          bool completed() const;

        private:
          void adjust_position(int x);

        private:
          image& m_image;

          unsigned int m_x;

          unsigned int m_y;

          const int m_x_inc;

          const int m_y_inc;

        }; // class rle_targa_output_buffer

        /*--------------------------------------------------------------------*/
        template< typename InputBuffer,
                  typename OutputBuffer = rle_targa_output_buffer<InputBuffer> >
        class rle_targa_decoder
          : public rle_decoder< rgba_pixel_8, InputBuffer, OutputBuffer >
        {
        public:
          typedef InputBuffer input_buffer_type;

          typedef OutputBuffer output_buffer_type;

        private:
          virtual void
          read_mode( input_buffer_type& input, output_buffer_type& output );

        }; // class rle_targa_decoder

        /*--------------------------------------------------------------------*/
        typedef
        rle_targa_decoder< file_input_buffer<rgba_pixel_8> > rle32_decoder;

        /*--------------------------------------------------------------------*/
        typedef
        rle_targa_decoder< file_input_buffer<rgb_pixel_8> > rle24_decoder;
      
        /*--------------------------------------------------------------------*/
        typedef rle_targa_decoder< file_input_buffer<pixel16> > rle16_decoder;

        /*--------------------------------------------------------------------*/
        typedef rle_targa_decoder< mapped_file_input_buffer<pixel8> >
        rle8_decoder;

      public:
        reader( image& img );
        reader( image& img, std::istream& f );

        void load( std::istream& f );

      private:
        void check_if_targa( std::istream& f ) const;

        void load_palette
        ( const header& h, std::istream& f, color_palette32& palette ) const;

        void load_color_mapped( const header& h, std::istream& f );
        void load_rle_color_mapped( const header& h, std::istream& f );
        void load_true_color( const header& h, std::istream& f );
        void load_rle_true_color( const header& h, std::istream& f );
        
        template<typename Pixel>
        void load_color_mapped_raw
        ( const header& h, std::istream& f, const color_palette32& palette );

        template<typename Decoder>
        void decompress_rle_color_mapped
        ( const header& h, std::istream& f, const color_palette32& palette );

        template<typename Pixel>
        void load_true_color_raw( const header& h, std::istream& f );

        template<typename Decoder>
        void decompress_rle_true_color( const header& h, std::istream& f );

        template<typename Pixel>
        void
        load_palette_content( std::istream& f, color_palette32& palette ) const;

     private:
        image& m_image;

      }; // class reader

      /*----------------------------------------------------------------------*/
      class writer : private file_structure
      {
      public:
        /*--------------------------------------------------------------------*/
        template<typename Pixel>
        class file_output_buffer
        {
        public:
          typedef Pixel pixel_type;

          typedef pixel_type pattern_type;

        public:
          file_output_buffer( std::ostream& os );
          void encode( unsigned int n, pattern_type pattern );

          template<typename Iterator>
          void raw( Iterator first, Iterator last );

          unsigned int min_interesting() const;
          unsigned int max_encodable() const;

          void order_pixel_bytes( const pixel_type& p );

        private:
          std::ostream& m_stream;

        }; // class file_output_buffer

        /*--------------------------------------------------------------------*/
        template<typename Pixel>
        class rle_targa_encoder
          : public rle_encoder< file_output_buffer<Pixel> >
        {
        public:
          typedef file_output_buffer<Pixel> output_buffer_type;

        }; // class rle_targa_encoder

        /*--------------------------------------------------------------------*/
        typedef rle_targa_encoder<rgba_pixel_8> rle32_encoder;

      public:
        writer( const image& img );
        writer( const image& img, std::ostream& f, bool rle );

        void save( std::ostream& f, bool rle ) const;

      private:
        void save_true_color( std::ostream& os ) const;
        void save_rle_true_color( std::ostream& os ) const;

      private:
        const image& m_image;

      }; // class writer

    public:
      targa( unsigned int w, unsigned int h );
      targa( const image& that );
      targa( std::istream& f );

      void save( std::ostream& os, bool rle ) const;

    }; // class targa
  } // namespace graphic
} // namespace claw

#include <claw/impl/targa_writer.tpp>
#include <claw/impl/targa_reader.tpp>

#endif // __CLAW_TARGA_HPP__