/ray/src/lib/pixmap/format.h

Go to the documentation of this file.

/*
 * lib/pixmap/format.h
 * 
 * Image format description class (channels, bits). 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _PIXMAP_FORMAT_H_
#define _PIXMAP_FORMAT_H_ 1

#include <lib/sconfig.h>    /* MUST be first */


class PixmapFormat
{
    public:
        // Max number of channels an image can have. 
        static const int MaxChannels=6;
        
    public:
        enum Format
        {
            // When adding entries here, do not forget to add an entry to the 
            // _nchannels[] array in format.cc. 
            None=0,     
            Gray,       
            GrayA,      
            RGB,        
            //VUY,      ///< VUY image, 3 channels
            RGBA,       
            RGBFT,      
            _LASTF      
        };
        
        enum CommonID
        {
            // NOTE: The order of the letters represents the order of the 
            //       cannels in the channels[] array which is meant to 
            //       specify the order in the data array. 
            // When adding entries here, do not forget to add an entry to the 
            // commons[] array in format.cc. 
            Gray_1,       
            Gray_8,       
            Gray_16,      
            GrayA_8,      
            GrayA_16,     
            RGB_8,        
            RGB_16,       
            RGBA_8,       
            RGBA_16,      
            RGB_555,      
            RGB_565,      
            RGBFT_f,      
            _LASTID       
        };
        
        static const signed char FloatBits=-1;
        
        static const short int _nchannels[_LASTF];
        
        struct FMT
        {
            Format format;
            signed char bits[MaxChannels];
            
        };
        
    private:
        FMT f;
        
        void _set(CommonID cid);
        void _set(Format fmt,const signed char *bits);
    public:
        inline PixmapFormat(CommonID cid)        // e.g. PixmapFormat::RGB_8
            {  _set(cid);  }
        inline PixmapFormat(Format id,const signed char *bits)
            {  _set(id,bits);  }
        inline PixmapFormat(const PixmapFormat &pf) : f(pf.f) {}
        inline ~PixmapFormat()  {}
        
        inline void set(CommonID cid)  {  _set(cid);  }
        inline void set(Format id,const signed char *bits)
            {  _set(id,bits);  }
        inline PixmapFormat &operator=(CommonID cid)
            {  _set(cid);  return(*this);  }
        inline PixmapFormat &operator=(const PixmapFormat &pf)
            {  f=pf.f;  return(*this);  }
        
        inline Format format() const        {  return(f.format);  }
        inline short int nchannels() const  {  return(_nchannels[f.format]);  }
        inline signed char bits(short int c) const
            {  return(f.bits[c]);  }
        
        signed char SameBitsForAll() const;
        
        bool operator==(const PixmapFormat &pf) const;
        inline bool operator!=(const PixmapFormat &pf) const
            {  return(!operator==(pf));  }
        
        inline bool operator==(Format fmt) const  {  return(f.format==fmt);  }
        inline bool operator!=(Format fmt) const  {  return(f.format!=fmt);  }
};

#endif  /* _PIXMAP_FORMAT_H_ */

---