H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 06:36:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
64a0844256
source-engine/common/quicktime_win32/CMICCProfile.h
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1026 lines
48 KiB
C
Raw Blame History

/*
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__ */
Reference in New Issue View Git Blame Copy Permalink