/*
 	File:		CMICCProfile.h
 
 	Contains:	ICC Profile Format Definitions
 
 	Version:	Technology:	ColorSync 2.5
 				Release:	QuickTime 4.0
 
 	Copyright:	(c) 1994-1998 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

#ifdef __cplusplus
extern "C" {
#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

/* Current CMProfile.header.profileVersion Major: 2, Minor: 0, Stage: Developement (x20), Prerelease:0x01 */

enum {
	cmCS2ProfileVersion			= 0x02000000
};

/* Current Major version number */

enum {
	cmCurrentProfileMajorVersion = 0x02000000
};

/* magic cookie number for anonymous file ID */

enum {
	cmMagicNumber				= FOUR_CHAR_CODE('acsp')
};

/* ColorSync profile version 1.0 */

enum {
	cmCS1ProfileVersion			= 0x00000100
};


/************************************************************************/
/*************** 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 ****/

enum {
	cmICCReservedAttr0Mask		= 0x0000FFFF,					/* these bits of the deviceAttributes[0] field are defined and reserved by ICC */
	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 */
	cmVendorReservedAttr0Mask	= (long)0xFFFF0000,				/* these bits of the deviceAttributes[0] field are defined and reserved by device vendor */
	cmVendorReservedAttr1Mask	= (long)0xFFFFFFFF				/* these bits of the deviceAttributes[1] field are defined and reserved by device vendor */
};

/* 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'),
	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')
};

/* technology tag descriptions */

enum {
	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')
};

/* public type signatures */

enum {
	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'),
	cmSigNamedColorType			= FOUR_CHAR_CODE('ncol'),
	cmSigNamedColor2Type		= FOUR_CHAR_CODE('ncl2'),
	cmSigProfileDescriptionType	= FOUR_CHAR_CODE('desc'),
	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'),
	cmSigUInt32Type				= FOUR_CHAR_CODE('ui32'),
	cmSigUInt64Type				= FOUR_CHAR_CODE('ui64'),
	cmSigUInt8Type				= FOUR_CHAR_CODE('ui08'),
	cmSigViewingConditionsType	= FOUR_CHAR_CODE('view'),
	cmSigXYZType				= FOUR_CHAR_CODE('XYZ ')
};

/* custom type signatures */

enum {
	cmSigVideoCardGammaType		= FOUR_CHAR_CODE('vcgt')
};


/* 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 '),
	cmYxyData					= FOUR_CHAR_CODE('Yxy '),
	cmRGBData					= FOUR_CHAR_CODE('RGB '),
	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'),
	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')
};

/* 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 {
	unsigned short 					year;
	unsigned short 					month;
	unsigned short 					dayOfTheMonth;
	unsigned short 					hours;
	unsigned short 					minutes;
	unsigned short 					seconds;
};
typedef struct CMDateTime				CMDateTime;

struct CMFixedXYZColor {
	Fixed 							X;
	Fixed 							Y;
	Fixed 							Z;
};
typedef struct CMFixedXYZColor			CMFixedXYZColor;

typedef unsigned short 					CMXYZComponent;

struct CMXYZColor {
	CMXYZComponent 					X;
	CMXYZComponent 					Y;
	CMXYZComponent 					Z;
};
typedef struct CMXYZColor				CMXYZColor;

struct CM2Header {
	unsigned long 					size;						/* This is the total size of the Profile */
	OSType 							CMMType;					/* CMM signature,  Registered with CS2 consortium  */
	unsigned long 					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 */
	unsigned long 					flags;						/* profile flags */
	OSType 							deviceManufacturer;			/* Registered with ICC consortium */
	unsigned long 					deviceModel;				/* Registered with ICC consortium */
	unsigned long 					deviceAttributes[2];		/* Attributes like paper type */
	unsigned long 					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 CMTagRecord {
	OSType 							tag;						/* Registered with CS2 consortium */
	unsigned long 					elementOffset;				/* Relative to start of CMProfile */
	unsigned long 					elementSize;
};
typedef struct CMTagRecord				CMTagRecord;

struct CMTagElemTable {
	unsigned long 					count;
	CMTagRecord 					tagList[1];					/* Variable size */
};
typedef struct CMTagElemTable			CMTagElemTable;
/* External 0x02002001 CMProfile */

struct CM2Profile {
	CM2Header 						header;
	CMTagElemTable 					tagTable;
	char 							elemData[1];				/* Tagged element storage. Variable size */
};
typedef struct CM2Profile				CM2Profile;
typedef CM2Profile *					CM2ProfilePtr;
typedef CM2ProfilePtr *					CM2ProfileHandle;
/* Tag Type Definitions */

struct CMCurveType {
	OSType 							typeDescriptor;				/* 'curv' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					countValue;					/* number of entries in table that follows */
	unsigned short 					data[1];					/* Tagged element storage. Variable size */
};
typedef struct CMCurveType				CMCurveType;

struct CMDataType {
	OSType 							typeDescriptor;				/* 'data' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					dataFlag;					/* 0 = ASCII, 1 = binary */
	char 							data[1];					/* Tagged element storage. Variable size */
};
typedef struct CMDataType				CMDataType;

struct CMDateTimeType {
	OSType 							typeDescriptor;				/* 'dtim' */
	unsigned long 					reserved;
	CMDateTime 						dateTime;
};
typedef struct CMDateTimeType			CMDateTimeType;

struct CMLut16Type {
	OSType 							typeDescriptor;				/* 'mft2' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned char 					inputChannels;				/* Number of input channels */
	unsigned char 					outputChannels;				/* Number of output channels */
	unsigned char 					gridPoints;					/* Number of clutTable grid points */
	unsigned char 					reserved2;					/* fill with 0x00 */
	Fixed 							matrix[3][3];				/* */
	unsigned short 					inputTableEntries;			/* */
	unsigned short 					outputTableEntries;			/* */
	unsigned short 					inputTable[1];				/* Variable size */
	unsigned short 					CLUT[1];					/* Variable size */
	unsigned short 					outputTable[1];				/* Variable size */
};
typedef struct CMLut16Type				CMLut16Type;

struct CMLut8Type {
	OSType 							typeDescriptor;				/* 'mft1' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned char 					inputChannels;				/* */
	unsigned char 					outputChannels;				/* */
	unsigned char 					gridPoints;					/* */
	unsigned char 					reserved2;					/* fill with 0x00 */
	Fixed 							matrix[3][3];				/* */
	unsigned char 					inputTable[256];			/* fixed size of 256 */
	unsigned char 					CLUT[2];					/* Variable size */
	unsigned char 					outputTable[256];			/* fixed size of 256 */
};
typedef struct CMLut8Type				CMLut8Type;

struct CMMeasurementType {
	OSType 							typeDescriptor;				/* 'meas' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					standardObserver;			/* 0 : unknown, 1 : CIE 1931, 2 : CIE 1964 */
	CMFixedXYZColor 				backingXYZ;					/* absolute XYZ values of backing */
	unsigned long 					geometry;					/* 0 : unknown, 1 : 0/45 or 45/0, 2 :0/d or d/0 */
	unsigned long 					flare;						/* 0 : 0%, 1 : 100% flare */
	unsigned long 					illuminant;					/* standard illuminant */
};
typedef struct CMMeasurementType		CMMeasurementType;

struct CMNamedColorType {
	OSType 							typeDescriptor;				/* 'ncol' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					vendorFlag;					/* */
	unsigned long 					count;						/* count of named colors in array that follows */
	unsigned char 					prefixName[1];				/* Variable size, max = 32, to access fields after this one, have to count bytes */
	unsigned char 					suffixName[1];				/* Variable size, max = 32 */
	char 							data[1];					/* varaible size data as explained below */
};
typedef struct CMNamedColorType			CMNamedColorType;
/*	
	A variable size array of structs appears as the last block of data
	in the above struct, CMNamedColorType.  The data structure
	is as follows: (example in C)
	
	struct {											 
		unsigned char	rootName[1];				 * Variable size, max = 32 
		unsigned char	colorCoords[1];				 * Variable size  
	} colorName[1];									 * Variable size  
*/

struct CMNamedColor2Type {
	OSType 							typeDescriptor;				/* 'ncl2' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					vendorFlag;					/* lower 16 bits reserved for ICC use */
	unsigned long 					count;						/* count of named colors in array that follows */
	unsigned long 					deviceChannelCount;			/* number of device channels, 0 indicates no device value available */
	unsigned char 					prefixName[32];				/* 32 byte field.  7 bit ASCII null terminated */
	unsigned char 					suffixName[32];				/* 32 byte field.  7 bit ASCII null terminated */
	char 							data[1];					/* varaible size data as explained below */
};
typedef struct CMNamedColor2Type		CMNamedColor2Type;
/*	
	A variable size array of structs appears as the last block of data
	in the above struct, CMNamedColor2Type.  The data structure
	is as follows: (example in C)
	
	struct {											 
		unsigned char	rootName[1];				 * 32 byte field.  7 bit ASCII null terminated
		unsigned char	PCSColorCoords[1];			 * Variable size  
		unsigned char	DeviceColorCoords[1];		 * Variable size  
	} colorName2[1];								 * Variable size  
*/


struct CMTextDescriptionType {
	OSType 							typeDescriptor;				/* 'desc' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					ASCIICount;					/* the count of "bytes" */
	unsigned char 					ASCIIName[2];				/* Variable size, to access fields after this one, have to count bytes */
	unsigned long 					UniCodeCode;
	unsigned long 					UniCodeCount;				/* the count of characters, each character has two bytes */
	unsigned char 					UniCodeName[2];				/* Variable size */
	short 							ScriptCodeCode;
	unsigned char 					ScriptCodeCount;			/* the count of "bytes" */
	unsigned char 					ScriptCodeName[2];			/* Variable size */
};
typedef struct CMTextDescriptionType	CMTextDescriptionType;

struct CMTextType {
	OSType 							typeDescriptor;				/* 'text' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned char 					text[1];					/* count of text is obtained from tag size element */
};
typedef struct CMTextType				CMTextType;

struct CMScreeningType {
	OSType 							typeDescriptor;				/* 'scrn' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					screeningFlag;				/* bit 0 : use printer default screens, bit 1 : inch/cm */
	unsigned long 					channelCount;
	char 							data[1];					/* varaible size data as explained below */
};
typedef struct CMScreeningType			CMScreeningType;
/*
	A variable size array of structs appears as the last block of data
	in the above struct, CMScreeningType.  The data structure
	is as follows: (example in C)
	
	struct {
		Fixed			frequency;
		Fixed			angle;
		unsigned long	sportFunction;
	 }	channelScreening[1];						* Variable size 
*/

struct CMSignatureType {
	OSType 							typeDescriptor;				/* 'sig ' */
	unsigned long 					reserved;					/* fill with 0x00 */
	OSType 							signature;
};
typedef struct CMSignatureType			CMSignatureType;

struct CMS15Fixed16ArrayType {
	OSType 							typeDescriptor;				/* 'sf32' */
	unsigned long 					reserved;					/* fill with 0x00 */
	Fixed 							value[1];					/* Variable size */
};
typedef struct CMS15Fixed16ArrayType	CMS15Fixed16ArrayType;

struct CMU16Fixed16ArrayType {
	OSType 							typeDescriptor;				/* 'uf32' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					value[1];					/* Variable size */
};
typedef struct CMU16Fixed16ArrayType	CMU16Fixed16ArrayType;

struct CMUInt16ArrayType {
	OSType 							typeDescriptor;				/* 'ui16' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned short 					value[1];					/* Variable size */
};
typedef struct CMUInt16ArrayType		CMUInt16ArrayType;

struct CMUInt32ArrayType {
	OSType 							typeDescriptor;				/* 'ui32' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					value[1];					/* Variable size */
};
typedef struct CMUInt32ArrayType		CMUInt32ArrayType;

struct CMUInt64ArrayType {
	OSType 							typeDescriptor;				/* 'ui64' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					value[1];					/* Variable size (x2) */
};
typedef struct CMUInt64ArrayType		CMUInt64ArrayType;

struct CMUInt8ArrayType {
	OSType 							typeDescriptor;				/* 'ui08' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned char 					value[1];					/* Variable size */
};
typedef struct CMUInt8ArrayType			CMUInt8ArrayType;

struct CMViewingConditionsType {
	OSType 							typeDescriptor;				/* 'view' */
	unsigned long 					reserved;					/* fill with 0x00 */
	CMFixedXYZColor 				illuminant;					/* absolute XYZs of illuminant  in cd/m^2 */
	CMFixedXYZColor 				surround;					/* absolute XYZs of surround in cd/m^2 */
	unsigned long 					stdIlluminant;				/* see definitions of std illuminants */
};
typedef struct CMViewingConditionsType	CMViewingConditionsType;

struct CMXYZType {
	OSType 							typeDescriptor;				/* 'XYZ ' */
	unsigned long 					reserved;					/* fill with 0x00 */
	CMFixedXYZColor 				XYZ[1];						/* variable size XYZ tristimulus values */
};
typedef struct CMXYZType				CMXYZType;
/* Profile sequence description type */

struct CMProfileSequenceDescType {
	OSType 							typeDescriptor;				/* 'pseq ' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					count;						/* Number of descriptions */
	char 							data[1];					/* varaible size data as explained below */
};
typedef struct CMProfileSequenceDescType CMProfileSequenceDescType;
/*
	A variable size array of structs appears as the last block of data
	in the above struct, CMProfileSequenceDescType.  The data structure
	is as follows: (example in C)
	
	struct {											 
		OSType			deviceMfg;					 * Device Manufacturer 
		OSType			deviceModel;				 * Decvice Model 
		unsigned long	attributes[2];				 * Device attributes 
		OSType			technology;					 * Technology signature 
		unsigned long	mfgDescASCIICount;			 * the count of "bytes" 
		unsigned char	mfgDescASCIIName[2];		 * Variable size 
		unsigned long	mfgDescUniCodeCode;			 
		unsigned long	mfgDescUniCodeCount;		 * the count of characters, each character has two bytes 
		unsigned char	mfgDescUniCodeName[2];		 * Variable size 
		unsigned long	mfgDescScriptCodeCode;		 
		unsigned long	mfgDescScriptCodeCount;		 * the count of "bytes" 
		unsigned char	mfgDescScriptCodeName[2];	 * Variable size 
		unsigned long	modelDescASCIICount;		 * the count of "bytes" 
		unsigned char	modelDescASCIIName[2];		 * Variable size 
		unsigned long	modelDescUniCodeCode;		 
		unsigned long	modelDescUniCodeCount;		 * the count of characters, each character has two bytes 
		unsigned char	modelDescUniCodeName[2];	 * Variable size 
		short			modelDescScriptCodeCode;	 
		unsigned char	modelDescScriptCodeCount;	 * the count of "bytes" 
		SInt8			filler;						 * For proper alignment across languages 
		unsigned char	modelDescScriptCodeName[2];	 * Variable size 
	}	profileDescription[1];						 
*/

/* Under color removal, black generation type */

struct CMUcrBgType {
	OSType 							typeDescriptor;				/* 'bfd  ' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					ucrCount;					/* Number of UCR entries */
	unsigned short 					ucrValues[1];				/* variable size */
	unsigned long 					bgCount;					/* Number of BG entries */
	unsigned short 					bgValues[1];				/* variable size */
	unsigned char 					ucrbgASCII[1];				/* null terminated ASCII string */
};
typedef struct CMUcrBgType				CMUcrBgType;

struct CMIntentCRDVMSize {
	long 							renderingIntent;			/* rendering intent */
	unsigned long 					VMSize;						/* VM size taken up by the CRD */
};
typedef struct CMIntentCRDVMSize		CMIntentCRDVMSize;

struct CMPS2CRDVMSizeType {
	OSType 							typeDescriptor;				/* 'psvm' */
	unsigned long 					reserved;					/* fill with 0x00 */
	unsigned long 					count;						/* number of intent entries */
	CMIntentCRDVMSize 				intentCRD[1];				/* variable size */
};
typedef struct CMPS2CRDVMSizeType		CMPS2CRDVMSizeType;
/* Video Card Gamma type */

enum {
	cmVideoCardGammaTableType	= 0,
	cmVideoCardGammaFormulaType	= 1
};



struct CMVideoCardGammaTable {
	unsigned short 					channels;					/* # of gamma channels (1 or 3) */
	unsigned short 					entryCount;					/* 1-based number of entries per channel */
	unsigned short 					entrySize;					/* size on bytes of each entry */
	char 							data[1];					/* variable size data follows */
};
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 {
	unsigned long 					tagType;
	union {
		CMVideoCardGammaTable 			table;
		CMVideoCardGammaFormula 		formula;
	} 								u;
};
typedef struct CMVideoCardGamma			CMVideoCardGamma;

struct CMVideoCardGammaType {
	OSType 							typeDescriptor;				/* 'vcgt' */
	unsigned long 					reserved;					/* fill with 0x00 */
	CMVideoCardGamma 				gamma;
};
typedef struct CMVideoCardGammaType		CMVideoCardGammaType;
/************************************************************************/
/*************** 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 {
	unsigned long 					size;
	OSType 							CMMType;
	unsigned long 					applProfileVersion;
	OSType 							dataType;
	OSType 							deviceType;
	OSType 							deviceManufacturer;
	unsigned long 					deviceModel;
	unsigned long 					deviceAttributes[2];
	unsigned long 					profileNameOffset;
	unsigned long 					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 {
	unsigned short 					counts[9];
	unsigned short 					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 unsigned short 					XYZComponent;
typedef CMXYZColor 						XYZColor;
typedef unsigned short 					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

#ifdef __cplusplus
}
#endif

#endif /* __CMICCPROFILE__ */

