pixel_format.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2006 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_PIXEL_FORMAT_H
#define ARCHON_UTILITIES_PIXEL_FORMAT_H

#include <inttypes.h>

#include <vector>

#include <archon/util/exception.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct PixelFormat
    {
      struct UnsupportedWordTypeException: virtual Exception
      {
        UnsupportedWordTypeException(string l): Exception(l) {}
      };

      struct InconsistencyException: virtual Exception
      {
        InconsistencyException(string l): Exception(l) {}
        InconsistencyException(string l, string m): Exception(l, m) {}
      };


      typedef uintmax_t MaxInt;


      enum FormatType
      {
        direct,

        packed,

        tight
      };

      FormatType formatType;

      int pixelSize;


      enum WordType
      {
        std_char,        
        std_short,       
        std_int,         
        std_long,        
        std_max_int,     
        std_float,       
        std_double,      
        std_long_double, 
        custom_int,      
        custom_float     
      };

      WordType wordType;

      int bitsPerWord;

      bool mostSignificantBitsFirst;




      struct Channel
      {
        int offset;

        int width;

        bool operator==(const Channel &c) const
        {
          return offset == c.offset && width == c.width;
        }
      };

      vector<Channel> channelLayout;

      enum ColorScheme
      {
        implied,   
        custom,    
        luminance, 
        rgb,       
        hsv        
      };

      ColorScheme colorScheme;

      bool hasAlphaChannel;


      PixelFormat getExpandedFormat() const throw(UnsupportedWordTypeException, InconsistencyException);

      PixelFormat getReducedFormat() const throw(UnsupportedWordTypeException, InconsistencyException);

      string toString() const;

      bool operator==(const PixelFormat &f) const
      {
        return
          formatType               == f.formatType               &&
          pixelSize                == f.pixelSize                &&
          wordType                 == f.wordType                 &&
          bitsPerWord              == f.bitsPerWord              &&
          mostSignificantBitsFirst == f.mostSignificantBitsFirst &&
          channelLayout            == f.channelLayout            &&
          colorScheme              == f.colorScheme              &&
          hasAlphaChannel          == f.hasAlphaChannel;
      }

      PixelFormat():
        formatType(direct),
        pixelSize(0),
        wordType(std_char),
        bitsPerWord(0),
        mostSignificantBitsFirst(false),
        colorScheme(implied),
        hasAlphaChannel(false) {}
    };
  }
}

#endif // ARCHON_UTILITIES_PIXEL_FORMAT_H

---