diff options
Diffstat (limited to 'common/quicktime_win32/CMICCProfile.h')
| -rw-r--r-- | common/quicktime_win32/CMICCProfile.h | 1025 |
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__ */ + |