1HEADmaster

1 files changed, 1025 insertions, 0 deletions

diff --git a/common/quicktime_win32/CMICCProfile.h b/common/quicktime_win32/CMICCProfile.h
new file mode 100644
index 0000000..08332dd
--- /dev/null
+++ b/common/quicktime_win32/CMICCProfile.h
@@ -0,0 +1,1025 @@
+/*
+     File:       CMICCProfile.h
+ 
+     Contains:   ICC Profile Format Definitions
+ 
+     Version:    QuickTime 7.3
+ 
+     Copyright:  (c) 2007 (c) 1994-2001 by Apple Computer, Inc., all rights reserved.
+ 
+     Bugs?:      For bug reports, consult the following page on
+                 the World Wide Web:
+ 
+                     http://developer.apple.com/bugreporter/
+ 
+*/
+#ifndef __CMICCPROFILE__
+#define __CMICCPROFILE__
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#if PRAGMA_IMPORT
+#pragma import on
+#endif
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=mac68k
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(push, 2)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack(2)
+#endif
+
+/* ICC Profile version constants  */
+enum {
+  cmICCProfileVersion4          = 0x04000000,
+  cmICCProfileVersion2          = 0x02000000,
+  cmICCProfileVersion21         = 0x02100000,
+  cmCS2ProfileVersion           = cmICCProfileVersion2,
+  cmCS1ProfileVersion           = 0x00000100 /* ColorSync 1.0 profile version */
+};
+
+/* Current Major version number */
+enum {
+  cmProfileMajorVersionMask     = (long)0xFF000000,
+  cmCurrentProfileMajorVersion  = 0x02000000
+};
+
+/* magic cookie number for anonymous file ID */
+enum {
+  cmMagicNumber                 = FOUR_CHAR_CODE('acsp')
+};
+
+
+/************************************************************************/
+/*************** ColorSync 2.0 profile specification ********************/
+/************************************************************************/
+/**** flags field  ****/
+enum {
+  cmICCReservedFlagsMask        = 0x0000FFFF, /* these bits of the flags field are defined and reserved by ICC */
+  cmEmbeddedMask                = 0x00000001, /* if bit 0 is 0 then not embedded profile, if 1 then embedded profile */
+  cmEmbeddedUseMask             = 0x00000002, /* if bit 1 is 0 then ok to use anywhere, if 1 then ok to use as embedded profile only */
+  cmCMSReservedFlagsMask        = (long)0xFFFF0000, /* these bits of the flags field are defined and reserved by CMS vendor */
+  cmQualityMask                 = 0x00030000, /* if bits 16-17 is 0 then normal, if 1 then draft, if 2 then best */
+  cmInterpolationMask           = 0x00040000, /* if bit 18 is 0 then interpolation, if 1 then lookup only */
+  cmGamutCheckingMask           = 0x00080000 /* if bit 19 is 0 then create gamut checking info, if 1 then no gamut checking info */
+};
+
+/* copyright-protection flag options */
+enum {
+  cmEmbeddedProfile             = 0,    /* 0 is not embedded profile, 1 is embedded profile */
+  cmEmbeddedUse                 = 1     /* 0 is to use anywhere, 1 is to use as embedded profile only */
+};
+
+/* speed and quality flag options */
+enum {
+  cmNormalMode                  = 0,    /* it uses the least significent two bits in the high word of flag */
+  cmDraftMode                   = 1,    /* it should be evaulated like this: right shift 16 bits first, mask off the */
+  cmBestMode                    = 2     /* high 14 bits, and then compare with the enum to determine the option value */
+};
+
+
+/**** deviceAttributes fields ****/
+/* deviceAttributes[0] is defined by and reserved for device vendors */
+/* deviceAttributes[1] is defined by and reserved for ICC */
+/* The following bits of deviceAttributes[1] are currently defined */
+enum {
+  cmReflectiveTransparentMask   = 0x00000001, /* if bit 0 is 0 then reflective media, if 1 then transparency media */
+  cmGlossyMatteMask             = 0x00000002 /* if bit 1 is 0 then glossy, if 1 then matte */
+};
+
+/* device/media attributes element values  */
+enum {
+  cmReflective                  = 0,    /* if bit 0 is 0 then reflective media, if 1 then transparency media */
+  cmGlossy                      = 1     /* if bit 1 is 0 then glossy, if 1 then matte */
+};
+
+
+/**** renderingIntent field ****/
+enum {
+  cmPerceptual                  = 0,    /* Photographic images */
+  cmRelativeColorimetric        = 1,    /* Logo Colors */
+  cmSaturation                  = 2,    /* Business graphics */
+  cmAbsoluteColorimetric        = 3     /* Logo Colors */
+};
+
+
+
+/* data type element values */
+enum {
+  cmAsciiData                   = 0,
+  cmBinaryData                  = 1
+};
+
+/* screen encodings  */
+enum {
+  cmPrtrDefaultScreens          = 0,    /* Use printer default screens.  0 is false, 1 is ture */
+  cmLinesPer                    = 1     /* 0 is LinesPerCm, 1 is LinesPerInch */
+};
+
+/* 2.0 tag type information */
+enum {
+  cmNumHeaderElements           = 10
+};
+
+/* public tags */
+enum {
+  cmAToB0Tag                    = FOUR_CHAR_CODE('A2B0'),
+  cmAToB1Tag                    = FOUR_CHAR_CODE('A2B1'),
+  cmAToB2Tag                    = FOUR_CHAR_CODE('A2B2'),
+  cmBlueColorantTag             = FOUR_CHAR_CODE('bXYZ'),
+  cmBlueTRCTag                  = FOUR_CHAR_CODE('bTRC'),
+  cmBToA0Tag                    = FOUR_CHAR_CODE('B2A0'),
+  cmBToA1Tag                    = FOUR_CHAR_CODE('B2A1'),
+  cmBToA2Tag                    = FOUR_CHAR_CODE('B2A2'),
+  cmCalibrationDateTimeTag      = FOUR_CHAR_CODE('calt'),
+  cmChromaticAdaptationTag      = FOUR_CHAR_CODE('chad'),
+  cmCharTargetTag               = FOUR_CHAR_CODE('targ'),
+  cmCopyrightTag                = FOUR_CHAR_CODE('cprt'),
+  cmDeviceMfgDescTag            = FOUR_CHAR_CODE('dmnd'),
+  cmDeviceModelDescTag          = FOUR_CHAR_CODE('dmdd'),
+  cmGamutTag                    = FOUR_CHAR_CODE('gamt'),
+  cmGrayTRCTag                  = FOUR_CHAR_CODE('kTRC'),
+  cmGreenColorantTag            = FOUR_CHAR_CODE('gXYZ'),
+  cmGreenTRCTag                 = FOUR_CHAR_CODE('gTRC'),
+  cmLuminanceTag                = FOUR_CHAR_CODE('lumi'),
+  cmMeasurementTag              = FOUR_CHAR_CODE('meas'),
+  cmMediaBlackPointTag          = FOUR_CHAR_CODE('bkpt'),
+  cmMediaWhitePointTag          = FOUR_CHAR_CODE('wtpt'),
+  cmNamedColorTag               = FOUR_CHAR_CODE('ncol'),
+  cmNamedColor2Tag              = FOUR_CHAR_CODE('ncl2'),
+  cmPreview0Tag                 = FOUR_CHAR_CODE('pre0'),
+  cmPreview1Tag                 = FOUR_CHAR_CODE('pre1'),
+  cmPreview2Tag                 = FOUR_CHAR_CODE('pre2'),
+  cmProfileDescriptionTag       = FOUR_CHAR_CODE('desc'),
+  cmProfileSequenceDescTag      = FOUR_CHAR_CODE('pseq'),
+  cmPS2CRD0Tag                  = FOUR_CHAR_CODE('psd0'),
+  cmPS2CRD1Tag                  = FOUR_CHAR_CODE('psd1'),
+  cmPS2CRD2Tag                  = FOUR_CHAR_CODE('psd2'),
+  cmPS2CRD3Tag                  = FOUR_CHAR_CODE('psd3'),
+  cmPS2CSATag                   = FOUR_CHAR_CODE('ps2s'),
+  cmPS2RenderingIntentTag       = FOUR_CHAR_CODE('ps2i'),
+  cmRedColorantTag              = FOUR_CHAR_CODE('rXYZ'),
+  cmRedTRCTag                   = FOUR_CHAR_CODE('rTRC'),
+  cmScreeningDescTag            = FOUR_CHAR_CODE('scrd'),
+  cmScreeningTag                = FOUR_CHAR_CODE('scrn'),
+  cmTechnologyTag               = FOUR_CHAR_CODE('tech'),
+  cmUcrBgTag                    = FOUR_CHAR_CODE('bfd '),
+  cmViewingConditionsDescTag    = FOUR_CHAR_CODE('vued'),
+  cmViewingConditionsTag        = FOUR_CHAR_CODE('view')
+};
+
+/* custom tags */
+enum {
+  cmPS2CRDVMSizeTag             = FOUR_CHAR_CODE('psvm'),
+  cmVideoCardGammaTag           = FOUR_CHAR_CODE('vcgt'),
+  cmMakeAndModelTag             = FOUR_CHAR_CODE('mmod'),
+  cmProfileDescriptionMLTag     = FOUR_CHAR_CODE('dscm'),
+  cmNativeDisplayInfoTag        = FOUR_CHAR_CODE('ndin')
+};
+
+/* public type signatures */
+enum {
+  cmSigCrdInfoType              = FOUR_CHAR_CODE('crdi'),
+  cmSigCurveType                = FOUR_CHAR_CODE('curv'),
+  cmSigDataType                 = FOUR_CHAR_CODE('data'),
+  cmSigDateTimeType             = FOUR_CHAR_CODE('dtim'),
+  cmSigLut16Type                = FOUR_CHAR_CODE('mft2'),
+  cmSigLut8Type                 = FOUR_CHAR_CODE('mft1'),
+  cmSigMeasurementType          = FOUR_CHAR_CODE('meas'),
+  cmSigMultiFunctA2BType        = FOUR_CHAR_CODE('mAB '),
+  cmSigMultiFunctB2AType        = FOUR_CHAR_CODE('mBA '),
+  cmSigNamedColorType           = FOUR_CHAR_CODE('ncol'),
+  cmSigNamedColor2Type          = FOUR_CHAR_CODE('ncl2'),
+  cmSigParametricCurveType      = FOUR_CHAR_CODE('para'),
+  cmSigProfileDescriptionType   = FOUR_CHAR_CODE('desc'),
+  cmSigProfileSequenceDescType  = FOUR_CHAR_CODE('pseq'),
+  cmSigScreeningType            = FOUR_CHAR_CODE('scrn'),
+  cmSigS15Fixed16Type           = FOUR_CHAR_CODE('sf32'),
+  cmSigSignatureType            = FOUR_CHAR_CODE('sig '),
+  cmSigTextType                 = FOUR_CHAR_CODE('text'),
+  cmSigU16Fixed16Type           = FOUR_CHAR_CODE('uf32'),
+  cmSigU1Fixed15Type            = FOUR_CHAR_CODE('uf16'),
+  cmSigUInt8Type                = FOUR_CHAR_CODE('ui08'),
+  cmSigUInt16Type               = FOUR_CHAR_CODE('ui16'),
+  cmSigUInt32Type               = FOUR_CHAR_CODE('ui32'),
+  cmSigUInt64Type               = FOUR_CHAR_CODE('ui64'),
+  cmSigUcrBgType                = FOUR_CHAR_CODE('bfd '),
+  cmSigUnicodeTextType          = FOUR_CHAR_CODE('utxt'),
+  cmSigViewingConditionsType    = FOUR_CHAR_CODE('view'),
+  cmSigXYZType                  = FOUR_CHAR_CODE('XYZ ')
+};
+
+/* custom type signatures */
+enum {
+  cmSigPS2CRDVMSizeType         = FOUR_CHAR_CODE('psvm'),
+  cmSigVideoCardGammaType       = FOUR_CHAR_CODE('vcgt'),
+  cmSigMakeAndModelType         = FOUR_CHAR_CODE('mmod'),
+  cmSigNativeDisplayInfoType    = FOUR_CHAR_CODE('ndin'),
+  cmSigMultiLocalizedUniCodeType = FOUR_CHAR_CODE('mluc')
+};
+
+
+/* technology tag descriptions */
+enum {
+  cmTechnologyDigitalCamera     = FOUR_CHAR_CODE('dcam'),
+  cmTechnologyFilmScanner       = FOUR_CHAR_CODE('fscn'),
+  cmTechnologyReflectiveScanner = FOUR_CHAR_CODE('rscn'),
+  cmTechnologyInkJetPrinter     = FOUR_CHAR_CODE('ijet'),
+  cmTechnologyThermalWaxPrinter = FOUR_CHAR_CODE('twax'),
+  cmTechnologyElectrophotographicPrinter = FOUR_CHAR_CODE('epho'),
+  cmTechnologyElectrostaticPrinter = FOUR_CHAR_CODE('esta'),
+  cmTechnologyDyeSublimationPrinter = FOUR_CHAR_CODE('dsub'),
+  cmTechnologyPhotographicPaperPrinter = FOUR_CHAR_CODE('rpho'),
+  cmTechnologyFilmWriter        = FOUR_CHAR_CODE('fprn'),
+  cmTechnologyVideoMonitor      = FOUR_CHAR_CODE('vidm'),
+  cmTechnologyVideoCamera       = FOUR_CHAR_CODE('vidc'),
+  cmTechnologyProjectionTelevision = FOUR_CHAR_CODE('pjtv'),
+  cmTechnologyCRTDisplay        = FOUR_CHAR_CODE('CRT '),
+  cmTechnologyPMDisplay         = FOUR_CHAR_CODE('PMD '),
+  cmTechnologyAMDisplay         = FOUR_CHAR_CODE('AMD '),
+  cmTechnologyPhotoCD           = FOUR_CHAR_CODE('KPCD'),
+  cmTechnologyPhotoImageSetter  = FOUR_CHAR_CODE('imgs'),
+  cmTechnologyGravure           = FOUR_CHAR_CODE('grav'),
+  cmTechnologyOffsetLithography = FOUR_CHAR_CODE('offs'),
+  cmTechnologySilkscreen        = FOUR_CHAR_CODE('silk'),
+  cmTechnologyFlexography       = FOUR_CHAR_CODE('flex')
+};
+
+
+/* Measurement type encodings */
+/* Measurement Flare */
+enum {
+  cmFlare0                      = 0x00000000,
+  cmFlare100                    = 0x00000001
+};
+
+/* Measurement Geometry */
+enum {
+  cmGeometryUnknown             = 0x00000000,
+  cmGeometry045or450            = 0x00000001,
+  cmGeometry0dord0              = 0x00000002
+};
+
+/* Standard Observer    */
+enum {
+  cmStdobsUnknown               = 0x00000000,
+  cmStdobs1931TwoDegrees        = 0x00000001,
+  cmStdobs1964TenDegrees        = 0x00000002
+};
+
+/* Standard Illuminant */
+enum {
+  cmIlluminantUnknown           = 0x00000000,
+  cmIlluminantD50               = 0x00000001,
+  cmIlluminantD65               = 0x00000002,
+  cmIlluminantD93               = 0x00000003,
+  cmIlluminantF2                = 0x00000004,
+  cmIlluminantD55               = 0x00000005,
+  cmIlluminantA                 = 0x00000006,
+  cmIlluminantEquiPower         = 0x00000007,
+  cmIlluminantF8                = 0x00000008
+};
+
+/* Spot Function Value */
+enum {
+  cmSpotFunctionUnknown         = 0,
+  cmSpotFunctionDefault         = 1,
+  cmSpotFunctionRound           = 2,
+  cmSpotFunctionDiamond         = 3,
+  cmSpotFunctionEllipse         = 4,
+  cmSpotFunctionLine            = 5,
+  cmSpotFunctionSquare          = 6,
+  cmSpotFunctionCross           = 7
+};
+
+/* Color Space Signatures */
+enum {
+  cmXYZData                     = FOUR_CHAR_CODE('XYZ '),
+  cmLabData                     = FOUR_CHAR_CODE('Lab '),
+  cmLuvData                     = FOUR_CHAR_CODE('Luv '),
+  cmYCbCrData                   = FOUR_CHAR_CODE('YCbr'),
+  cmYxyData                     = FOUR_CHAR_CODE('Yxy '),
+  cmRGBData                     = FOUR_CHAR_CODE('RGB '),
+  cmSRGBData                    = FOUR_CHAR_CODE('sRGB'),
+  cmGrayData                    = FOUR_CHAR_CODE('GRAY'),
+  cmHSVData                     = FOUR_CHAR_CODE('HSV '),
+  cmHLSData                     = FOUR_CHAR_CODE('HLS '),
+  cmCMYKData                    = FOUR_CHAR_CODE('CMYK'),
+  cmCMYData                     = FOUR_CHAR_CODE('CMY '),
+  cmMCH5Data                    = FOUR_CHAR_CODE('MCH5'),
+  cmMCH6Data                    = FOUR_CHAR_CODE('MCH6'),
+  cmMCH7Data                    = FOUR_CHAR_CODE('MCH7'),
+  cmMCH8Data                    = FOUR_CHAR_CODE('MCH8'),
+  cm3CLRData                    = FOUR_CHAR_CODE('3CLR'),
+  cm4CLRData                    = FOUR_CHAR_CODE('4CLR'),
+  cm5CLRData                    = FOUR_CHAR_CODE('5CLR'),
+  cm6CLRData                    = FOUR_CHAR_CODE('6CLR'),
+  cm7CLRData                    = FOUR_CHAR_CODE('7CLR'),
+  cm8CLRData                    = FOUR_CHAR_CODE('8CLR'),
+  cm9CLRData                    = FOUR_CHAR_CODE('9CLR'),
+  cm10CLRData                   = FOUR_CHAR_CODE('ACLR'),
+  cm11CLRData                   = FOUR_CHAR_CODE('BCLR'),
+  cm12CLRData                   = FOUR_CHAR_CODE('CCLR'),
+  cm13CLRData                   = FOUR_CHAR_CODE('DCLR'),
+  cm14CLRData                   = FOUR_CHAR_CODE('ECLR'),
+  cm15CLRData                   = FOUR_CHAR_CODE('FCLR'),
+  cmNamedData                   = FOUR_CHAR_CODE('NAME')
+};
+
+/* profileClass enumerations */
+enum {
+  cmInputClass                  = FOUR_CHAR_CODE('scnr'),
+  cmDisplayClass                = FOUR_CHAR_CODE('mntr'),
+  cmOutputClass                 = FOUR_CHAR_CODE('prtr'),
+  cmLinkClass                   = FOUR_CHAR_CODE('link'),
+  cmAbstractClass               = FOUR_CHAR_CODE('abst'),
+  cmColorSpaceClass             = FOUR_CHAR_CODE('spac'),
+  cmNamedColorClass             = FOUR_CHAR_CODE('nmcl')
+};
+
+/* platform enumerations */
+enum {
+  cmMacintosh                   = FOUR_CHAR_CODE('APPL'),
+  cmMicrosoft                   = FOUR_CHAR_CODE('MSFT'),
+  cmSolaris                     = FOUR_CHAR_CODE('SUNW'),
+  cmSiliconGraphics             = FOUR_CHAR_CODE('SGI '),
+  cmTaligent                    = FOUR_CHAR_CODE('TGNT')
+};
+
+/* parametric curve type enumerations */
+enum {
+  cmParametricType0             = 0,    /* Y = X^gamma */
+  cmParametricType1             = 1,    /* Y = (aX+b)^gamma     [X>=-b/a],  Y = 0    [X<-b/a] */
+  cmParametricType2             = 2,    /* Y = (aX+b)^gamma + c [X>=-b/a],  Y = c    [X<-b/a] */
+  cmParametricType3             = 3,    /* Y = (aX+b)^gamma     [X>=d],     Y = cX   [X<d]    */
+  cmParametricType4             = 4     /* Y = (aX+b)^gamma + e [X>=d],     Y = cX+f [X<d]    */
+};
+
+
+/* ColorSync 1.0 elements */
+enum {
+  cmCS1ChromTag                 = FOUR_CHAR_CODE('chrm'),
+  cmCS1TRCTag                   = FOUR_CHAR_CODE('trc '),
+  cmCS1NameTag                  = FOUR_CHAR_CODE('name'),
+  cmCS1CustTag                  = FOUR_CHAR_CODE('cust')
+};
+
+/* General element data types */
+struct CMDateTime {
+  UInt16              year;
+  UInt16              month;
+  UInt16              dayOfTheMonth;
+  UInt16              hours;
+  UInt16              minutes;
+  UInt16              seconds;
+};
+typedef struct CMDateTime               CMDateTime;
+struct CMFixedXYColor {
+  Fixed               x;
+  Fixed               y;
+};
+typedef struct CMFixedXYColor           CMFixedXYColor;
+struct CMFixedXYZColor {
+  Fixed               X;
+  Fixed               Y;
+  Fixed               Z;
+};
+typedef struct CMFixedXYZColor          CMFixedXYZColor;
+
+typedef UInt16                          CMXYZComponent;
+struct CMXYZColor {
+  CMXYZComponent      X;
+  CMXYZComponent      Y;
+  CMXYZComponent      Z;
+};
+typedef struct CMXYZColor               CMXYZColor;
+/* Typedef for Profile MD5 message digest */
+/* Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm */
+
+typedef unsigned char                   CMProfileMD5[16];
+typedef CMProfileMD5 *                  CMProfileMD5Ptr;
+
+/*
+ *  CMProfileMD5AreEqual()
+ *  
+ *  Availability:       available as macro/inline
+ */
+#ifdef __cplusplus
+  inline Boolean CMProfileMD5AreEqual(CMProfileMD5 a, CMProfileMD5 b)
+  {
+    return  ((long*)a)[0]==((long*)b)[0] && ((long*)a)[1]==((long*)b)[1] &&
+         ((long*)a)[2]==((long*)b)[2] && ((long*)a)[3]==((long*)b)[3];
+  }
+#else
+  #define CMProfileMD5AreEqual(a, b) (\
+    ((long*)a)[0]==((long*)b)[0] && ((long*)a)[1]==((long*)b)[1] && \
+  ((long*)a)[2]==((long*)b)[2] && ((long*)a)[3]==((long*)b)[3])
+#endif
+
+struct CM2Header {
+  UInt32              size;                   /* This is the total size of the Profile */
+  OSType              CMMType;                /* CMM signature,  Registered with CS2 consortium  */
+  UInt32              profileVersion;         /* Version of CMProfile format */
+  OSType              profileClass;           /* input, display, output, devicelink, abstract, or color conversion profile type */
+  OSType              dataColorSpace;         /* color space of data */
+  OSType              profileConnectionSpace; /* profile connection color space */
+  CMDateTime          dateTime;               /* date and time of profile creation */
+  OSType              CS2profileSignature;    /* 'acsp' constant ColorSync 2.0 file ID */
+  OSType              platform;               /* primary profile platform, Registered with CS2 consortium */
+  UInt32              flags;                  /* profile flags */
+  OSType              deviceManufacturer;     /* Registered with ICC consortium */
+  UInt32              deviceModel;            /* Registered with ICC consortium */
+  UInt32              deviceAttributes[2];    /* Attributes[0] is for device vendors, [1] is for ICC */
+  UInt32              renderingIntent;        /* preferred rendering intent of tagged object */
+  CMFixedXYZColor     white;                  /* profile illuminant */
+  OSType              creator;                /* profile creator */
+  char                reserved[44];           /* reserved for future use */
+};
+typedef struct CM2Header                CM2Header;
+struct CM4Header {
+  UInt32              size;                   /* This is the total size of the Profile */
+  OSType              CMMType;                /* CMM signature,  Registered with CS2 consortium  */
+  UInt32              profileVersion;         /* Version of CMProfile format */
+  OSType              profileClass;           /* input, display, output, devicelink, abstract, or color conversion profile type */
+  OSType              dataColorSpace;         /* color space of data */
+  OSType              profileConnectionSpace; /* profile connection color space */
+  CMDateTime          dateTime;               /* date and time of profile creation */
+  OSType              CS2profileSignature;    /* 'acsp' constant ColorSync 2.0 file ID */
+  OSType              platform;               /* primary profile platform, Registered with CS2 consortium */
+  UInt32              flags;                  /* profile flags */
+  OSType              deviceManufacturer;     /* Registered with ICC consortium */
+  UInt32              deviceModel;            /* Registered with ICC consortium */
+  UInt32              deviceAttributes[2];    /* Attributes[0] is for device vendors, [1] is for ICC */
+  UInt32              renderingIntent;        /* preferred rendering intent of tagged object */
+  CMFixedXYZColor     white;                  /* profile illuminant */
+  OSType              creator;                /* profile creator */
+  CMProfileMD5        digest;                 /* Profile message digest */
+  char                reserved[28];           /* reserved for future use */
+};
+typedef struct CM4Header                CM4Header;
+struct CMTagRecord {
+  OSType              tag;                    /* Registered with CS2 consortium */
+  UInt32              elementOffset;          /* Relative to start of CMProfile */
+  UInt32              elementSize;
+};
+typedef struct CMTagRecord              CMTagRecord;
+struct CMTagElemTable {
+  UInt32              count;
+  CMTagRecord         tagList[1];             /* variable size, determined by count */
+};
+typedef struct CMTagElemTable           CMTagElemTable;
+struct CM2Profile {
+  CM2Header           header;
+  CMTagElemTable      tagTable;
+  char                elemData[1];            /* variable size data for tagged element storage */
+};
+typedef struct CM2Profile               CM2Profile;
+typedef CM2Profile *                    CM2ProfilePtr;
+typedef CM2ProfilePtr *                 CM2ProfileHandle;
+/* Tag Type Definitions */
+struct CMAdaptationMatrixType {
+  OSType              typeDescriptor;         /* 'sf32' = cmSigS15Fixed16Type */
+  unsigned long       reserved;               /* fill with 0x00 */
+  Fixed               adaptationMatrix[9];    /* fixed size of nine matrix entries */
+};
+typedef struct CMAdaptationMatrixType   CMAdaptationMatrixType;
+struct CMCurveType {
+  OSType              typeDescriptor;         /* 'curv' = cmSigCurveType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              countValue;             /* number of entries in table that follows */
+  UInt16              data[1];                /* variable size, determined by countValue */
+};
+typedef struct CMCurveType              CMCurveType;
+struct CMDataType {
+  OSType              typeDescriptor;         /* 'data' = cmSigDataType*/
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              dataFlag;               /* 0 = ASCII, 1 = binary */
+  char                data[1];                /* variable size, determined by tag element size */
+};
+typedef struct CMDataType               CMDataType;
+struct CMDateTimeType {
+  OSType              typeDescriptor;         /* 'dtim' = cmSigDateTimeType */
+  UInt32              reserved;               /* fill with 0x00 */
+  CMDateTime          dateTime;               /* */
+};
+typedef struct CMDateTimeType           CMDateTimeType;
+struct CMLut16Type {
+  OSType              typeDescriptor;         /* 'mft2' = cmSigLut16Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt8               inputChannels;          /* Number of input channels */
+  UInt8               outputChannels;         /* Number of output channels */
+  UInt8               gridPoints;             /* Number of clutTable grid points */
+  UInt8               reserved2;              /* fill with 0x00 */
+  Fixed               matrix[3][3];           /* */
+  UInt16              inputTableEntries;      /* Number of entries in 1-D input luts */
+  UInt16              outputTableEntries;     /* Number of entries in 1-D output luts */
+  UInt16              inputTable[1];          /* variable size, determined by inputChannels*inputTableEntries */
+#if 0 /* NOTE: Field offsets are variable from here on. */
+  /* In order to correctly reflect the actual format of this tag, some of the fields in */
+  /* this structure have been removed because they follow an array field of variable size. */
+  /* As a result, the size of this structure has changed from previous versions of this interface. */
+  /* Code that relies on sizeof(CMLut16Type) should be changed. */
+  UInt16              CLUT[];                 /* variable size, determined by (gridPoints^inputChannels)*outputChannels */
+  UInt16              outputTable[];          /* variable size, determined by outputChannels*outputTableEntries */
+#endif
+};
+typedef struct CMLut16Type              CMLut16Type;
+struct CMLut8Type {
+  OSType              typeDescriptor;         /* 'mft1' = cmSigLut8Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt8               inputChannels;          /* Number of input channels */
+  UInt8               outputChannels;         /* Number of output channels */
+  UInt8               gridPoints;             /* Number of clutTable grid points */
+  UInt8               reserved2;              /* fill with 0x00 */
+  Fixed               matrix[3][3];           /* */
+  UInt8               inputTable[1];          /* variable size, determined by inputChannels*256 */
+#if 0 /* NOTE: Field offsets are variable from here on. */
+  /* In order to correctly reflect the actual format of this tag, some of the fields in */
+  /* this structure have been removed because they follow an array field of variable size. */
+  /* As a result, the size of this structure has changed from previous versions of this interface. */
+  /* Code that relies on sizeof(CMLut8Type) should be changed. */
+  UInt8               CLUT[];                 /* variable size, determined by (gridPoints^inputChannels)*outputChannels */
+  UInt8               outputTable[];          /* variable size, determined by outputChannels*256 */
+#endif
+};
+typedef struct CMLut8Type               CMLut8Type;
+struct CMMultiFunctLutType {
+  OSType              typeDescriptor;         /* 'mAB ' = cmSigMultiFunctA2BType or 'mBA ' = cmSigMultiFunctB2AType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt8               inputChannels;          /* Number of input channels */
+  UInt8               outputChannels;         /* Number of output channels */
+  UInt16              reserved2;              /* fill with 0x00 */
+  UInt32              offsetBcurves;          /* offset to first "B" curve */
+  UInt32              offsetMatrix;           /* offset to 3x4 matrix */
+  UInt32              offsetMcurves;          /* offset to first "M" curve */
+  UInt32              offsetCLUT;             /* offset to multi-dimensional LUT of type CMMultiFunctCLUTType */
+  UInt32              offsetAcurves;          /* offset to first "A" curve */
+  UInt8               data[1];                /* variable size */
+};
+typedef struct CMMultiFunctLutType      CMMultiFunctLutType;
+typedef CMMultiFunctLutType             CMMultiFunctLutA2BType;
+typedef CMMultiFunctLutType             CMMultiFunctLutB2AType;
+struct CMMultiFunctCLUTType {
+  UInt8               gridPoints[16];         /* grigpoints for each input channel dimension (remaining are 0) */
+  UInt8               entrySize;              /* bytes per lut enrty (1 or 2) */
+  UInt8               reserved[3];            /* fill with 0x00 */
+  UInt8               data[1];                /* variable size, determined by above */
+};
+typedef struct CMMultiFunctCLUTType     CMMultiFunctCLUTType;
+struct CMMeasurementType {
+  OSType              typeDescriptor;         /* 'meas' = cmSigMeasurementType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              standardObserver;       /* cmStdobsUnknown, cmStdobs1931TwoDegrees, cmStdobs1964TenDegrees */
+  CMFixedXYZColor     backingXYZ;             /* absolute XYZ values of backing */
+  UInt32              geometry;               /* cmGeometryUnknown, cmGeometry045or450 (0/45), cmGeometry0dord0 (0/d or d/0) */
+  UInt32              flare;                  /* cmFlare0, cmFlare100 */
+  UInt32              illuminant;             /* cmIlluminantUnknown, cmIlluminantD50, ... */
+};
+typedef struct CMMeasurementType        CMMeasurementType;
+struct CMNamedColorType {
+  OSType              typeDescriptor;         /* 'ncol' = cmSigNamedColorType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              vendorFlag;             /* */
+  UInt32              count;                  /* count of named colors in array that follows */
+  UInt8               prefixName[1];          /* variable size, max = 32 */
+#if 0 /* NOTE: Field offsets are variable from here on. */
+  /* In order to correctly reflect the actual format of this tag, some of the fields in */
+  /* this structure have been removed because they follow an array field of variable size. */
+  /* As a result, the size of this structure has changed from previous versions of this interface. */
+  /* Code that relies on sizeof(CMNamedColorType) should be changed. */
+  UInt8               suffixName[];           /* variable size, max = 32 */
+  struct {
+    UInt8             rootName[];             /* variable size, max = 32 */
+    UInt8             colorCoords[];          /* variable size */
+  } colorName[];                              /* variable size */
+#endif
+};
+typedef struct CMNamedColorType         CMNamedColorType;
+struct CMNamedColor2EntryType {
+  UInt8               rootName[32];           /* 32 byte field.  7 bit ASCII null terminated */
+  UInt16              PCSColorCoords[3];      /* Lab or XYZ color */
+  UInt16              DeviceColorCoords[1];   /* variable size */
+};
+typedef struct CMNamedColor2EntryType   CMNamedColor2EntryType;
+struct CMNamedColor2Type {
+  OSType              typeDescriptor;         /* 'ncl2' = cmSigNamedColor2Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              vendorFlag;             /* lower 16 bits reserved for ICC use */
+  UInt32              count;                  /* count of named colors in array that follows */
+  UInt32              deviceChannelCount;     /* number of device channels, 0 indicates no device value available */
+  UInt8               prefixName[32];         /* Fixed 32 byte size.  7 bit ASCII null terminated */
+  UInt8               suffixName[32];         /* Fixed 32 byte size.  7 bit ASCII null terminated */
+  char                data[1];                /* variable size data for CMNamedColor2EntryType */
+};
+typedef struct CMNamedColor2Type        CMNamedColor2Type;
+struct CMNativeDisplayInfo {
+  UInt32              dataSize;               /* Size of this structure */
+  CMFixedXYColor      redPhosphor;            /* Phosphors - native cromaticity values of the display  */
+  CMFixedXYColor      greenPhosphor;
+  CMFixedXYColor      bluePhosphor;
+  CMFixedXYColor      whitePoint;
+  Fixed               redGammaValue;          /* Gammas - native gamma values of the display */
+  Fixed               greenGammaValue;
+  Fixed               blueGammaValue;
+                                              /*  Gamma tables - if if gammaChannels is not zero, */
+                                              /*  native gamma tables are preferred over values */
+                                              /*  redGammaValue, greenGammaValue, blueGammaValue */
+  UInt16              gammaChannels;          /* # of gamma channels (1 or 3) */
+  UInt16              gammaEntryCount;        /* 1-based number of entries per channel */
+  UInt16              gammaEntrySize;         /* size in bytes of each entry */
+  char                gammaData[1];           /* variable size, determined by channels*entryCount*entrySize */
+};
+typedef struct CMNativeDisplayInfo      CMNativeDisplayInfo;
+struct CMNativeDisplayInfoType {
+  OSType              typeDescriptor;         /* 'ndin' = cmSigNativeDisplayInfoType */
+  unsigned long       reserved;               /* fill with 0x00 */
+  CMNativeDisplayInfo  nativeDisplayInfo;     /* data of type CMNativeDisplayInfo */
+};
+typedef struct CMNativeDisplayInfoType  CMNativeDisplayInfoType;
+struct CMParametricCurveType {
+  OSType              typeDescriptor;         /* 'para' = cmSigParametricCurveType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt16              functionType;           /* cmParametricType0, cmParametricType1, etc. */
+  UInt16              reserved2;              /* fill with 0x00 */
+  Fixed               value[1];               /* variable size, determined by functionType */
+};
+typedef struct CMParametricCurveType    CMParametricCurveType;
+struct CMTextDescriptionType {
+  OSType              typeDescriptor;         /* 'desc' = cmSigProfileDescriptionType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              ASCIICount;             /* Count of bytes (including null terminator)  */
+  UInt8               ASCIIName[2];           /* variable size, determined by ASCIICount.  7 bit ASCII null terminated */
+#if 0 /* NOTE: Field offsets are variable from here on. */
+  /* In order to correctly reflect the actual format of this tag, some of the fields in */
+  /* this structure have been removed because they follow an array field of variable size. */
+  /* As a result, the size of this structure has changed from previous versions of this interface. */
+  /* Code that relies on sizeof(CMTextDescriptionType) should be changed. */
+  UInt32              UniCodeCode;            /* Unused */
+  UInt32              UniCodeCount;           /* Count of 2-byte characters (including null terminator) */
+  UInt8               UniCodeName[];          /* variable size, determined by UniCodeCount */
+  SInt16              ScriptCodeCode;         /* Mac-defined script code */
+  UInt8               ScriptCodeCount;        /* Count of bytes (including null terminator) */
+  UInt8               ScriptCodeName[];       /* variable size, determined by ScriptCodeCount */
+#endif
+};
+typedef struct CMTextDescriptionType    CMTextDescriptionType;
+struct CMTextType {
+  OSType              typeDescriptor;         /* 'text' = cmSigTextType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt8               text[1];                /* variable size, determined by tag element size */
+};
+typedef struct CMTextType               CMTextType;
+struct CMUnicodeTextType {
+  OSType              typeDescriptor;         /* 'utxt' = cmSigUnicodeTextType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UniChar             text[1];                /* variable size, determined by tag element size  */
+};
+typedef struct CMUnicodeTextType        CMUnicodeTextType;
+struct CMScreeningChannelRec {
+  Fixed               frequency;
+  Fixed               angle;
+  UInt32              spotFunction;
+};
+typedef struct CMScreeningChannelRec    CMScreeningChannelRec;
+struct CMScreeningType {
+  OSType              typeDescriptor;         /* 'scrn' = cmSigScreeningType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              screeningFlag;          /* bit 0 : use printer default screens, bit 1 : inch/cm */
+  UInt32              channelCount;           /* */
+  CMScreeningChannelRec  channelInfo[1];      /* variable size, determined by channelCount */
+};
+typedef struct CMScreeningType          CMScreeningType;
+struct CMSignatureType {
+  OSType              typeDescriptor;         /* 'sig ' = cmSigSignatureType */
+  UInt32              reserved;               /* fill with 0x00 */
+  OSType              signature;
+};
+typedef struct CMSignatureType          CMSignatureType;
+struct CMS15Fixed16ArrayType {
+  OSType              typeDescriptor;         /* 'sf32' = cmSigS15Fixed16Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  Fixed               value[1];               /* variable size, determined by tag element size */
+};
+typedef struct CMS15Fixed16ArrayType    CMS15Fixed16ArrayType;
+struct CMU16Fixed16ArrayType {
+  OSType              typeDescriptor;         /* 'uf32' = cmSigU16Fixed16Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              value[1];               /* variable size, determined by tag element size */
+};
+typedef struct CMU16Fixed16ArrayType    CMU16Fixed16ArrayType;
+struct CMUInt8ArrayType {
+  OSType              typeDescriptor;         /* 'ui08' = cmSigUInt8Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt8               value[1];               /* variable size, determined by tag element size */
+};
+typedef struct CMUInt8ArrayType         CMUInt8ArrayType;
+struct CMUInt16ArrayType {
+  OSType              typeDescriptor;         /* 'ui16' = cmSigUInt16Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt16              value[1];               /* variable size, determined by tag element size */
+};
+typedef struct CMUInt16ArrayType        CMUInt16ArrayType;
+struct CMUInt32ArrayType {
+  OSType              typeDescriptor;         /* 'ui32' = cmSigUInt32Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              value[1];               /* variable size, determined by tag element size */
+};
+typedef struct CMUInt32ArrayType        CMUInt32ArrayType;
+struct CMUInt64ArrayType {
+  OSType              typeDescriptor;         /* 'ui64' = cmSigUInt64Type */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              value[1];               /* variable size, determined by tag element size */
+};
+typedef struct CMUInt64ArrayType        CMUInt64ArrayType;
+struct CMViewingConditionsType {
+  OSType              typeDescriptor;         /* 'view' = cmSigViewingConditionsType */
+  UInt32              reserved;               /* fill with 0x00 */
+  CMFixedXYZColor     illuminant;             /* absolute XYZs of illuminant  in cd/m^2 */
+  CMFixedXYZColor     surround;               /* absolute XYZs of surround in cd/m^2 */
+  UInt32              stdIlluminant;          /* see definitions of std illuminants */
+};
+typedef struct CMViewingConditionsType  CMViewingConditionsType;
+struct CMXYZType {
+  OSType              typeDescriptor;         /* 'XYZ ' = cmSigXYZType */
+  UInt32              reserved;               /* fill with 0x00 */
+  CMFixedXYZColor     XYZ[1];                 /* variable size, determined by tag element size */
+};
+typedef struct CMXYZType                CMXYZType;
+struct CMProfileSequenceDescType {
+  OSType              typeDescriptor;         /* 'pseq' = cmProfileSequenceDescTag */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              count;                  /* Number of descriptions */
+  char                data[1];                /* variable size data explained in ICC spec */
+};
+typedef struct CMProfileSequenceDescType CMProfileSequenceDescType;
+struct CMUcrBgType {
+  OSType              typeDescriptor;         /* 'bfd ' = cmSigUcrBgType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              ucrCount;               /* Number of UCR entries */
+  UInt16              ucrValues[1];           /* variable size, determined by ucrCount */
+#if 0 /* NOTE: Field offsets are variable from here on. */
+  /* In order to correctly reflect the actual format of this tag, some of the fields in */
+  /* this structure have been removed because they follow an array field of variable size. */
+  /* As a result, the size of this structure has changed from previous versions of this interface. */
+  /* Code that relies on sizeof(CMUcrBgType) should be changed. */
+  UInt32              bgCount;                /* Number of BG entries */
+  UInt16              bgValues[];             /* variable size, determined by bgCount */
+  UInt8               ucrbgASCII[];           /* null terminated ASCII string */
+#endif
+};
+typedef struct CMUcrBgType              CMUcrBgType;
+/* Private Tag Type Definitions */
+struct CMIntentCRDVMSize {
+  long                renderingIntent;        /* rendering intent */
+  UInt32              VMSize;                 /* VM size taken up by the CRD */
+};
+typedef struct CMIntentCRDVMSize        CMIntentCRDVMSize;
+struct CMPS2CRDVMSizeType {
+  OSType              typeDescriptor;         /* 'psvm' = cmSigPS2CRDVMSizeType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              count;                  /* number of intent entries */
+  CMIntentCRDVMSize   intentCRD[1];           /* variable size, determined by count */
+};
+typedef struct CMPS2CRDVMSizeType       CMPS2CRDVMSizeType;
+enum {
+  cmVideoCardGammaTableType     = 0,
+  cmVideoCardGammaFormulaType   = 1
+};
+
+struct CMVideoCardGammaTable {
+  UInt16              channels;               /* # of gamma channels (1 or 3) */
+  UInt16              entryCount;             /* 1-based number of entries per channel */
+  UInt16              entrySize;              /* size in bytes of each entry */
+  char                data[1];                /* variable size, determined by channels*entryCount*entrySize */
+};
+typedef struct CMVideoCardGammaTable    CMVideoCardGammaTable;
+struct CMVideoCardGammaFormula {
+  Fixed               redGamma;               /* must be > 0.0 */
+  Fixed               redMin;                 /* must be > 0.0 and < 1.0 */
+  Fixed               redMax;                 /* must be > 0.0 and < 1.0 */
+  Fixed               greenGamma;             /* must be > 0.0 */
+  Fixed               greenMin;               /* must be > 0.0 and < 1.0 */
+  Fixed               greenMax;               /* must be > 0.0 and < 1.0 */
+  Fixed               blueGamma;              /* must be > 0.0 */
+  Fixed               blueMin;                /* must be > 0.0 and < 1.0 */
+  Fixed               blueMax;                /* must be > 0.0 and < 1.0 */
+};
+typedef struct CMVideoCardGammaFormula  CMVideoCardGammaFormula;
+struct CMVideoCardGamma {
+  UInt32              tagType;
+  union {
+    CMVideoCardGammaTable  table;
+    CMVideoCardGammaFormula  formula;
+  }                       u;
+};
+typedef struct CMVideoCardGamma         CMVideoCardGamma;
+struct CMVideoCardGammaType {
+  OSType              typeDescriptor;         /* 'vcgt' = cmSigVideoCardGammaType */
+  UInt32              reserved;               /* fill with 0x00 */
+  CMVideoCardGamma    gamma;
+};
+typedef struct CMVideoCardGammaType     CMVideoCardGammaType;
+struct CMMakeAndModel {
+  OSType              manufacturer;
+  UInt32              model;
+  UInt32              serialNumber;
+  UInt32              manufactureDate;
+  UInt32              reserved1;              /* fill with 0x00 */
+  UInt32              reserved2;              /* fill with 0x00 */
+  UInt32              reserved3;              /* fill with 0x00 */
+  UInt32              reserved4;              /* fill with 0x00 */
+};
+typedef struct CMMakeAndModel           CMMakeAndModel;
+struct CMMakeAndModelType {
+  OSType              typeDescriptor;         /* 'mmod' = cmSigMakeAndModelType */
+  UInt32              reserved;               /* fill with 0x00 */
+  CMMakeAndModel      makeAndModel;
+};
+typedef struct CMMakeAndModelType       CMMakeAndModelType;
+struct CMMultiLocalizedUniCodeEntryRec {
+  char                languageCode[2];        /* language code from ISO-639 */
+  char                regionCode[2];          /* region code from ISO-3166 */
+  UInt32              textLength;             /* the length in bytes of the string */
+  UInt32              textOffset;             /* the offset from the start of tag in bytes */
+};
+typedef struct CMMultiLocalizedUniCodeEntryRec CMMultiLocalizedUniCodeEntryRec;
+struct CMMultiLocalizedUniCodeType {
+  OSType              typeDescriptor;         /* 'mluc' = cmSigMultiLocalizedUniCodeType */
+  UInt32              reserved;               /* fill with 0x00 */
+  UInt32              entryCount;             /* 1-based number of name records that follow */
+  UInt32              entrySize;              /* size in bytes of name records that follow */
+
+                                              /* variable-length data for storage of CMMultiLocalizedUniCodeEntryRec */
+
+                                              /* variable-length data for storage of Unicode strings*/
+};
+typedef struct CMMultiLocalizedUniCodeType CMMultiLocalizedUniCodeType;
+/************************************************************************/
+/*************** ColorSync 1.0 profile specification ********************/
+/************************************************************************/
+enum {
+  cmGrayResponse                = 0,
+  cmRedResponse                 = 1,
+  cmGreenResponse               = 2,
+  cmBlueResponse                = 3,
+  cmCyanResponse                = 4,
+  cmMagentaResponse             = 5,
+  cmYellowResponse              = 6,
+  cmUcrResponse                 = 7,
+  cmBgResponse                  = 8,
+  cmOnePlusLastResponse         = 9
+};
+
+
+/* Device types */
+enum {
+  cmMonitorDevice               = FOUR_CHAR_CODE('mntr'),
+  cmScannerDevice               = FOUR_CHAR_CODE('scnr'),
+  cmPrinterDevice               = FOUR_CHAR_CODE('prtr')
+};
+
+
+struct CMIString {
+  ScriptCode          theScript;
+  Str63               theString;
+};
+typedef struct CMIString                CMIString;
+/* Profile options */
+enum {
+  cmPerceptualMatch             = 0x0000, /* Default. For photographic images */
+  cmColorimetricMatch           = 0x0001, /* Exact matching when possible */
+  cmSaturationMatch             = 0x0002 /* For solid colors */
+};
+
+/* Profile flags */
+enum {
+  cmNativeMatchingPreferred     = 0x00000001, /* Default to native not preferred */
+  cmTurnOffCache                = 0x00000002 /* Default to turn on CMM cache */
+};
+
+
+typedef long                            CMMatchOption;
+typedef long                            CMMatchFlag;
+struct CMHeader {
+  UInt32              size;
+  OSType              CMMType;
+  UInt32              applProfileVersion;
+  OSType              dataType;
+  OSType              deviceType;
+  OSType              deviceManufacturer;
+  UInt32              deviceModel;
+  UInt32              deviceAttributes[2];
+  UInt32              profileNameOffset;
+  UInt32              customDataOffset;
+  CMMatchFlag         flags;
+  CMMatchOption       options;
+  CMXYZColor          white;
+  CMXYZColor          black;
+};
+typedef struct CMHeader                 CMHeader;
+struct CMProfileChromaticities {
+  CMXYZColor          red;
+  CMXYZColor          green;
+  CMXYZColor          blue;
+  CMXYZColor          cyan;
+  CMXYZColor          magenta;
+  CMXYZColor          yellow;
+};
+typedef struct CMProfileChromaticities  CMProfileChromaticities;
+struct CMProfileResponse {
+  UInt16              counts[9];
+  UInt16              data[1];                /* Variable size */
+};
+typedef struct CMProfileResponse        CMProfileResponse;
+struct CMProfile {
+  CMHeader            header;
+  CMProfileChromaticities  profile;
+  CMProfileResponse   response;
+  CMIString           profileName;
+  char                customData[1];          /* Variable size */
+};
+typedef struct CMProfile                CMProfile;
+typedef CMProfile *                     CMProfilePtr;
+typedef CMProfilePtr *                  CMProfileHandle;
+#if OLDROUTINENAMES
+enum {
+  kCMApplProfileVersion         = cmCS1ProfileVersion
+};
+
+enum {
+  grayResponse                  = cmGrayResponse,
+  redResponse                   = cmRedResponse,
+  greenResponse                 = cmGreenResponse,
+  blueResponse                  = cmBlueResponse,
+  cyanResponse                  = cmCyanResponse,
+  magentaResponse               = cmMagentaResponse,
+  yellowResponse                = cmYellowResponse,
+  ucrResponse                   = cmUcrResponse,
+  bgResponse                    = cmBgResponse,
+  onePlusLastResponse           = cmOnePlusLastResponse
+};
+
+enum {
+  rgbData                       = cmRGBData,
+  cmykData                      = cmCMYKData,
+  grayData                      = cmGrayData,
+  xyzData                       = cmXYZData
+};
+
+enum {
+  XYZData                       = cmXYZData
+};
+
+enum {
+  monitorDevice                 = cmMonitorDevice,
+  scannerDevice                 = cmScannerDevice,
+  printerDevice                 = cmPrinterDevice
+};
+
+enum {
+  CMNativeMatchingPreferred     = cmNativeMatchingPreferred, /* Default to native not preferred */
+  CMTurnOffCache                = cmTurnOffCache /* Default to turn on CMM cache */
+};
+
+enum {
+  CMPerceptualMatch             = cmPerceptualMatch, /* Default. For photographic images */
+  CMColorimetricMatch           = cmColorimetricMatch, /* Exact matching when possible */
+  CMSaturationMatch             = cmSaturationMatch /* For solid colors */
+};
+
+typedef UInt16                          XYZComponent;
+typedef CMXYZColor                      XYZColor;
+typedef UInt16                          CMResponseData;
+typedef CMIString                       IString;
+typedef long                            CMResponseColor;
+typedef CMResponseColor                 responseColor;
+#endif  /* OLDROUTINENAMES */
+
+
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack()
+#endif
+
+#ifdef PRAGMA_IMPORT_OFF
+#pragma import off
+#elif PRAGMA_IMPORT
+#pragma import reset
+#endif
+
+
+#endif /* __CMICCPROFILE__ */
+