mi32/mg2cms.h

Go to the documentation of this file.

#ifndef INC_MI32_MG2CMS_H
#define INC_MI32_MG2CMS_H

#ifndef INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

#ifndef INC_MI32_MILIST_H
#include <mi32/milist.h>
#endif

#ifndef INC_MI32_COLOR_H
#include <mi32/color.h>
#endif

#ifndef INC_MI32_MICALLBACKLIST_H
#include <mi32/micallbacklist.h>
#endif

#ifndef INC_MI32_SERIALIZERBASE_H
#include <mi32/serializerbase.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
struct COLOR;
class MISTRING;
class XMLNODE;
namespace MGUI {
   class XMLFORM_DATA;
   }
// Forward decl of things defined in lcms/lcms.h, which we can't include here.
typedef void* cmsHPROFILE;
typedef void* cmsHTRANSFORM;
#endif

//=====================================================================================================================

#ifndef GENERATING_DOXYGEN_OUTPUT
// Warning! This is evil!
// Several methods need to take a COLORXYZ or COLORxyY, which consists of three
// doubles and won't fit in our COLOR structure.  I'd like to just pass the
// cmsCIEXYZ and cmsCIExyY structures, but they're defined in an include file
// that our rules say I can't include here. 
// I can define my own versions of them, but then I'd have to cast them a lot
// inside the implementation module.  The solution is to define them as being
// derived from the real cms classes if lcms/lcms.h has been included and 
// define the same thing myself if not.
#ifdef __cms_H
#define COLORXYZ_BASE   cmsCIEXYZ
#define COLORxyY_BASE   cmsCIExyY
#else
struct CIECOLORXYZ { double X, Y, Z; }; 
struct CIECOLORxyY { double x, y, Y; }; 
#define COLORXYZ_BASE   CIECOLORXYZ
#define COLORxyY_BASE   CIECOLORxyY
#endif
#endif // GENERATING_DOXYGEN_OUTPUT

//=====================================================================================================================
class COLORXYZ : public COLORXYZ_BASE {
   public:
      COLORXYZ();
      COLORXYZ(double X, double Y, double Z);
      COLORXYZ(const COLORXYZ&);
      explicit COLORXYZ(const COLOR&);
      COLORXYZ& operator=(const COLORXYZ& rhs);
      COLORXYZ& operator=(const COLOR& rhs);

      static const SERIALIZERITEM* GetSerialItemDef();

      bool GetColor_sRGB(COLOR&) const;
   };

//=====================================================================================================================
class COLORxyY : public COLORxyY_BASE {
   public:
      COLORxyY();
      COLORxyY(double x, double y, double Y);
      COLORxyY(const COLORxyY&);
      COLORxyY(const COLOR&);
      COLORxyY& operator=(const COLORxyY& rhs);
      COLORxyY& operator=(const COLOR& rhs);

      static const SERIALIZERITEM* GetSerialItemDef();

      bool SetTemperature (
         int DegreesKelvin
         );

      bool GetColor_sRGB(COLOR&) const;

   };

//=====================================================================================================================

namespace MGD {

class TRANSFORM;
class DEVICE;
class PROFILEPARMS_RGB;
class PROFILEPARMS_PRINTER;

//=====================================================================================================================

class GAMMA {
   public:
      GAMMA (
         int entries,
         double gamma
         );

      ~GAMMA();

      bool Smooth (
         double lambda
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef __cms_H
      GAMMATABLE* GetTable (
         ) const {
         return m_table;
         }
#endif
      #endif // GENERATING_DOXYGEN_OUTPUT

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef __cms_H
      GAMMATABLE* m_table;
#else
      void* m_table; 
#endif
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

//=====================================================================================================================
class PROFILE {
   public:
      enum BUILTIN_PROFILE {
         PROFILE_NONE      = -1,    
         PROFILE_sRGB      = 0,
         PROFILE_XYZ,
         PROFILE_LAB,
         PROFILE_AdobeRGB_1998,
         PROFILE_AppleRGB
         };

      enum INTENT {
         INTENT_Perceptual             = 0,     
         INTENT_RelativeColorimetric   = 1,
         INTENT_Saturation             = 2,
         INTENT_AbsoluteColorimetric   = 3
         };

      enum USAGE {
         USAGE_Input    = 0,
         USAGE_Output   = 1,
         USAGE_Proof    = 2
         };

      enum TAG {
         TAG_AToB0                       = 0x41324230L,  
         TAG_AToB1                       = 0x41324231L,  
         TAG_AToB2                       = 0x41324232L,  
         TAG_BlueColorant                = 0x6258595AL,  
         TAG_BlueTRC                     = 0x62545243L,  
         TAG_BToA0                       = 0x42324130L,  
         TAG_BToA1                       = 0x42324131L,  
         TAG_BToA2                       = 0x42324132L,  
         TAG_CalibrationDateTime         = 0x63616C74L,  
         TAG_CharTarget                  = 0x74617267L,  
         TAG_Copyright                   = 0x63707274L,  
         TAG_CrdInfo                     = 0x63726469L,  
         TAG_DeviceMfgDesc               = 0x646D6E64L,  
         TAG_DeviceModelDesc             = 0x646D6464L,  
         TAG_Gamut                       = 0x67616D74L,  
         TAG_GrayTRC                     = 0x6b545243L,  
         TAG_GreenColorant               = 0x6758595AL,  
         TAG_GreenTRC                    = 0x67545243L,  
         TAG_Luminance                   = 0x6C756d69L,  
         TAG_Measurement                 = 0x6D656173L,  
         TAG_MediaBlackPoint             = 0x626B7074L,  
         TAG_MediaWhitePoint             = 0x77747074L,  
         TAG_NamedColor                  = 0x6E636f6CL,  /* 'ncol' 
                                                               * OBSOLETE, use ncl2 */
         TAG_NamedColor2                 = 0x6E636C32L,  
         TAG_Preview0                    = 0x70726530L,  
         TAG_Preview1                    = 0x70726531L,  
         TAG_Preview2                    = 0x70726532L,  
         TAG_ProfileDescription          = 0x64657363L,  
         TAG_ProfileSequenceDesc         = 0x70736571L,  
         TAG_Ps2CRD0                     = 0x70736430L,  
         TAG_Ps2CRD1                     = 0x70736431L,  
         TAG_Ps2CRD2                     = 0x70736432L,  
         TAG_Ps2CRD3                     = 0x70736433L,  
         TAG_Ps2CSA                      = 0x70733273L,  
         TAG_RenderingIntent             = 0x70733269L,  
         TAG_RedColorant                 = 0x7258595AL,  
         TAG_RedTRC                      = 0x72545243L,  
         TAG_ScreeningDesc               = 0x73637264L,  
         TAG_Screening                   = 0x7363726EL,  
         TAG_Technology                  = 0x74656368L,  
         TAG_UcrBg                       = 0x62666420L,  
         TAG_ViewingCondDesc             = 0x76756564L,  
         TAG_ViewingConditions           = 0x76696577L  
      };

      /* 
       * Color Space Signatures
       * Note that only icSigXYZData and icSigLabData are valid
       * Profile Connection Spaces (PCSs)
       *
       * These are NOT the same as our COLORSPACE enum, which really should
       * have been called FORMAT or something.
       */ 
      enum ICMCOLORSPACE {
         ICMCOLORSPACE_XYZ                 = 0x58595A20L,  
         ICMCOLORSPACE_Lab                 = 0x4C616220L,  
         ICMCOLORSPACE_Luv                 = 0x4C757620L,  
         ICMCOLORSPACE_YCbCr               = 0x59436272L,  
         ICMCOLORSPACE_Yxy                 = 0x59787920L,  
         ICMCOLORSPACE_RGB                 = 0x52474220L,  
         ICMCOLORSPACE_Gray                = 0x47524159L,  
         ICMCOLORSPACE_HSV                 = 0x48535620L,  
         ICMCOLORSPACE_HLS                 = 0x484C5320L,  
         ICMCOLORSPACE_CMYK                = 0x434D594BL,  
         ICMCOLORSPACE_CMY                 = 0x434D5920L,  
         ICMCOLORSPACE_2Color              = 0x32434C52L,  
         ICMCOLORSPACE_3Color              = 0x33434C52L,  
         ICMCOLORSPACE_4Color              = 0x34434C52L,  
         ICMCOLORSPACE_5Color              = 0x35434C52L,  
         ICMCOLORSPACE_6Color              = 0x36434C52L,  
         ICMCOLORSPACE_7Color              = 0x37434C52L,  
         ICMCOLORSPACE_8Color              = 0x38434C52L   
         };

      enum CLASS {
         CLASS_Unspecified               = 0,
         CLASS_Input                     = 0x73636E72L,  
         CLASS_Display                   = 0x6D6E7472L,  
         CLASS_Output                    = 0x70727472L,  
         CLASS_Link                      = 0x6C696E6BL,  
         CLASS_Abstract                  = 0x61627374L,  
         CLASS_ColorSpace                = 0x73706163L,  
         CLASS_NamedColor                = 0x6e6d636cL   
         };

      struct PRIMARIES {
         PRIMARIES( 
            ) :
            id(0)
            { 
            }

         ~PRIMARIES() {}
         int id;              
         MISTRING name;    
         COLORxyY red;
         COLORxyY green;
         COLORxyY blue;
      
         static const SERIALIZERITEM* GetSerialItemDef();
         };

      struct WHITEPOINT {
         ~WHITEPOINT() {}
         int id;              
         MISTRING name;
         COLORxyY color;
         };

      class LISTENTRY;

      PROFILE (
         ) :
         m_priv(0)
         {
         }

      PROFILE (
         BUILTIN_PROFILE builtin
         ) :
         m_priv(0)
         {
            CreateBuiltInProfile(builtin);
         }
      
      PROFILE (
         const PROFILE& rhs
         );

      ~PROFILE (
         );

      PROFILE& operator= (
         const PROFILE& rhs
         );

      bool operator== (
         const PROFILE& rhs
         ) const;

      bool operator!= (
         const PROFILE& rhs
         ) const {
         return (!(*this == rhs));
         }

      static ERRVALUE EnumerateProfiles (
         CLASS ProfileClass,
         MILIST<LISTENTRY>& List
         );

      static ERRVALUE EnumeratePrimaries (
         MILIST<PRIMARIES>& List
         );

      static ERRVALUE EnumerateWhitePoints (
         MILIST<WHITEPOINT>& List
         );

      static bool WhitePointFromTemp (
         int tempK,              
         COLORxyY& WhitePoint 
         );

      bool GetColorants (
         COLORXYZ& red,
         COLORXYZ& green,
         COLORXYZ& blue
         ) const;

      bool GetIluminant (
         COLORXYZ& illuminant 
         ) const;

      bool GetMediaBlackPoint (
         COLORXYZ& blackpoint
         ) const;

      bool GetMediaWhitePoint (
         COLORXYZ& whitepoint 
         ) const;

      void GetName (
         MISTRING&
         ) const;

      void GetDesc (
         MISTRING&
         ) const;

      INTENT GetRenderingIntent (
         ) const;

      ICMCOLORSPACE GetPCS (
         ) const;

      ICMCOLORSPACE GetColorSpace (
         ) const;

      CLASS GetDeviceClass (
         ) const;

      bool SupportsIntent (
         INTENT intent,    
         USAGE use         
         ) const;

      void Free (
         );

      bool HasTag (
         TAG sig
         ) const;

      bool IsEmpty (
         ) const {
         return (m_priv == 0);
         }

      ERRVALUE Read (
         const FILEPATH& path
         );
      ERRVALUE ReadFromMemory (
         const void* buf,  
         int size
         );

      ERRVALUE Create (
         const PROFILEPARMS_RGB& parms
         );

      ERRVALUE Create (
         const PROFILEPARMS_PRINTER& parms
         );

      ERRVALUE CreateDeviceLinkProfile (
         TRANSFORM& transform,
         UINT32 flags   
         );

      ERRVALUE CreateInkLimitingProfile (
         double limit,     
         COLORSPACE ColorSpace  
         );

      ERRVALUE CreateBuiltInProfile (
         BUILTIN_PROFILE profile
         );

      ERRVALUE CreateRGBProfile (
         const COLORxyY& WhitePoint,
         const PRIMARIES& Primaries,
         const GAMMA& TransferFunctionRed,
         const GAMMA& TransferFunctionGreen,
         const GAMMA& TransferFunctionBlue
         );

      ERRVALUE CreateGrayProfile (
         const COLORxyY& WhitePoint,
         const GAMMA& TransferFunction 
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      friend class TRANSFORM;

      class PRIVDATA;

      PRIVDATA* m_priv;
      cmsHPROFILE GetProfile() const;

      ERRVALUE CreateSimpleRGBProfile (
         int WhitePoint,
         double gamma,
         double rx,
         double ry,
         double gx,
         double gy,
         double bx,
         double by
         );
      #endif 
   };

//=====================================================================================================================

class PROFILEPARMS {
   public:
      enum MODE {
         MODE_None = 0,
         MODE_sRGB = 1,
         MODE_ICMFile = 2,
         MODE_UserDefined = 3
         };

      PROFILEPARMS();
      virtual ~PROFILEPARMS() {}

      static const SERIALIZERITEM* GetSerialItemDef();

      ERRVALUE IniRead(const char*inikey = 0, INIHANDLE handle = 0);
      ERRVALUE IniWrite(const char*inikey = 0, INIHANDLE handle = 0) const;
      void XMLRead (const MGUI::XMLFORM_DATA&);
      void XMLWrite (MGUI::XMLFORM_DATA&) const;

      MODE m_mode;
      PROFILE::INTENT m_intent;
      PROFILE::BUILTIN_PROFILE m_BuiltInProfile;
      FILEPATH m_filepath;
      int m_WhitePoint;    
      double m_wx, m_wy;   

   private:
      virtual const char* v_GetDefaultINIKey() const = 0;
      virtual ERRVALUE v_IniRead(const char*inikey, INIHANDLE handle = 0) = 0;
      virtual ERRVALUE v_IniWrite(const char*inikey, INIHANDLE handle = 0)  const = 0;
      virtual void v_XMLRead(const MGUI::XMLFORM_DATA&) = 0;
      virtual void v_XMLWrite(MGUI::XMLFORM_DATA&) const = 0;

      virtual void v_NotifyObservers() const {}
   };

class PROFILEPARMS_RGB : public PROFILEPARMS {
   public:
      PROFILEPARMS_RGB ();
      ~PROFILEPARMS_RGB() {};

      static const SERIALIZERITEM* GetSerialItemDef();

      double m_RedGamma, m_GreenGamma, m_BlueGamma;
      PROFILE::PRIMARIES m_primary;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual const char* v_GetDefaultINIKey() const { return "ICMScreen"; }
      virtual ERRVALUE v_IniRead(const char*inikey, INIHANDLE handle = 0);
      virtual ERRVALUE v_IniWrite(const char*inikey, INIHANDLE handle = 0) const;
      virtual void v_XMLRead(const MGUI::XMLFORM_DATA&);
      virtual void v_XMLWrite(MGUI::XMLFORM_DATA&) const;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
class PROFILEPARMS_SCREEN : public PROFILEPARMS_RGB {
   public:
      PROFILEPARMS_SCREEN ();
      ~PROFILEPARMS_SCREEN() {}

      static void AddChangeCallback (
         MICALLBACKLIST::CALLBACKFUNC func,
         void* cbdata
         );

      static void RemoveChangeCallback (
         MICALLBACKLIST::CALLBACKFUNC func,
         void* cbdata
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void v_NotifyObservers() const ;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
      
//=====================================================================================================================
class PROFILEPARMS_PRINTER : public PROFILEPARMS {
   public:
      PROFILEPARMS_PRINTER ();
      ~PROFILEPARMS_PRINTER() {};

      static const SERIALIZERITEM* GetSerialItemDef();

      bool m_bProofToScreen;
      bool m_bOutOfGamutAlarm;
      COLOR m_AlarmColor;
      bool m_bUseProfileForProofingOnly;
      double m_InkLimit;
      double m_BlackInkLimit;
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual const char* v_GetDefaultINIKey() const { return "PrinterICM"; }
      virtual ERRVALUE v_IniRead(const char*inikey, INIHANDLE handle = 0);
      virtual ERRVALUE v_IniWrite(const char*inikey, INIHANDLE handle = 0) const;
      virtual void v_XMLRead(const MGUI::XMLFORM_DATA&);
      virtual void v_XMLWrite(MGUI::XMLFORM_DATA&) const;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

//=====================================================================================================================
class PROFILE::LISTENTRY {
   public:
      LISTENTRY () { }

      LISTENTRY (
         const LISTENTRY& rhs
         ) :
         m_filepath(rhs.m_filepath),
         m_desc(rhs.m_desc),
         m_bIsBuiltIn(rhs.m_bIsBuiltIn),
         m_BuiltInID(rhs.m_BuiltInID)
         {}


      ~LISTENTRY () {}
      
      LISTENTRY& operator= (
         const LISTENTRY& rhs
         ) {
         if (&rhs != this) {
            m_filepath = rhs.m_filepath;
            m_desc = rhs.m_desc;
            m_bIsBuiltIn = rhs.m_bIsBuiltIn;
            m_BuiltInID = rhs.m_BuiltInID;
            }
         return (*this);
         }

      const MISTRING& GetDescription (
         ) const {
         return (m_desc);
         }

      const FILEPATH& GetFilePath (
         ) const {
         return (m_filepath);
         }

      bool IsBuiltIn (
         ) const {
         return (m_bIsBuiltIn);
         }

      BUILTIN_PROFILE GetBuiltInID (
         ) const {
         return (m_BuiltInID);
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FILEPATH m_filepath;
      MISTRING m_desc;
      bool m_bIsBuiltIn;
      BUILTIN_PROFILE m_BuiltInID;

      LISTENTRY (
         const FILEPATH& fp, 
         const MISTRING& desc
         ) :
         m_desc(desc),
         m_filepath(fp),
         m_bIsBuiltIn(false),
         m_BuiltInID(PROFILE::PROFILE_NONE)
         {
         }

      LISTENTRY (
         PROFILE::BUILTIN_PROFILE id,
         const MISTRING& desc
         ) :
         m_desc(desc),
         m_bIsBuiltIn(true),
         m_BuiltInID(id)
         {
         }

      friend class PROFILE;   // PROFILE can use private constructor
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================
class TRANSFORM {
   public:

      TRANSFORM (
         ) :
         m_priv(0)
         { }

      TRANSFORM (
         const PROFILE& InputProfile,
         COLORSPACE InputColorSpace,
         const PROFILE& OutputProfile,
         COLORSPACE OutputColorSpace,  
         PROFILE::INTENT RenderingIntent = PROFILE::INTENT_Perceptual, 
         UINT32 flags = 0  // XXX Define an enum
         );




      TRANSFORM (
         const TRANSFORM& rhs
         );

      ~TRANSFORM (
         );

      TRANSFORM& operator= (
         const TRANSFORM& rhs
         );

      static void SetOutOfGamutAlarmColor (
         const COLOR& color
         );

      ERRVALUE Create (
         const PROFILE& InputProfile,
         COLORSPACE InputColorSpace,
         const PROFILE& OutputProfile,
         COLORSPACE OutputColorSpace,  
         PROFILE::INTENT RenderingIntent = PROFILE::INTENT_Perceptual, 
         UINT32 flags = 0  // XXX Define an enum
         );

      ERRVALUE Create (
         const PROFILE& InputProfile,
         COLORSPACE InputColorSpace,
         const PROFILEPARMS_PRINTER& ProofParms,
         const PROFILE& OutputProfile,
         COLORSPACE OutputColorSpace,  
         PROFILE::INTENT RenderingIntent = PROFILE::INTENT_Perceptual, 
         UINT32 flags = 0  // XXX Define an enum
         );

      COLORSPACE GetOutputColorSpace (
         ) const {
         return (m_DestColorSpace);
         }

      const PROFILE& GetInputProfile (
         ) const;

      const PROFILE& GetOutputProfile (
         ) const;

      bool IsEmpty (
         ) const {
         return (m_priv == 0);
         }

      void DoTransform (
         const void* src,
         void* dest,
         int size       
         ) const;

      void DoTransform (
         const COLOR& src,
         COLOR& dest
         ) const;

      void Free();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIVDATA;

      PRIVDATA* m_priv;
      COLORSPACE m_SrcColorSpace;
      COLORSPACE m_DestColorSpace;

      cmsHTRANSFORM GetTrans() const;
      #endif // GENERATING_DOXYGEN_OUTPUT

   }; 

//=====================================================================================================================

}     

#endif // INC_MI32_MG2CMS_H

---