test: lh_open/pi_app.h File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# pi_app.h File Reference

`#include "App.h"`

Go to the source code of this file.

## Classes

struct | PI_NAMEDCOLOR
struct | PI_GRAYCOLOR
struct | PI_RGBCOLOR
struct | PI_CMYKCOLOR
struct | PI_XYZCOLOR
struct | PI_YxyCOLOR
struct | PI_LabCOLOR
struct | PI_GENERIC3CHANNEL
struct | PI_HiFiCOLOR
union | CMColor
struct | CMConcatProfileSet
struct | CMUniqueIdentification
struct | CMBitmap
struct | tagCMNamedProfileInfo

## Defines

#define | CM_MAX_COLOR_CHANNELS 8
#define | CallCMBitmapCallBackProc(f, a, b, c) ((*f)((a)-(b),c))
#define | kQualityMask 0x00030000 /* see Modes obove ( e.g. cmBestMode<<16 ) */
#define | kLookupOnlyMask 0x00040000
#define | kCreateGamutLutMask 0x00080000 /* Set Bit disables gamut lut creation */
#define | kUseRelColorimetric 0x00100000
#define | kStartWithXyzPCS 0x00200000
#define | kStartWithLabPCS 0x00400000
#define | kEndWithXyzPCS 0x00800000
#define | kEndWithLabPCS 0x01000000

## Typedefs

typedef unsigned long | CMBitmapColorSpace
typedef long | CMError
typedef unsigned int | PI_OSType
typedef CMPrivateProfileRecord * | CMProfileRef
typedef CMColor | CMColor
typedef icHeader | CMCoreProfileHeader
typedef CMConcatProfileSet | CMConcatProfileSet
typedef icDateTimeNumber | CMDateTime
typedef CMUniqueIdentification | CMUniqueIdentification
typedef CMBitmap | CMBitmap
typedef char | CMColorName [32]
typedef CMColorName * | pCMColorName
typedef const CMColorName * | pcCMColorName
typedef tagCMNamedProfileInfo | CMNamedProfileInfo
typedef CMNamedProfileInfo * | pCMNamedProfileInfo
typedef unsigned char | PI_Boolean
typedef PI_Boolean(* | CMBitmapCallBackProcPtr )(long progress, void *refCon)
typedef CMBitmapCallBackProcPtr | CMBitmapCallBackUPP
typedef CMPrivateColorWorldRecord * | CMWorldRef

## Enumerations

enum

cmErrorCodes {
cmopenErr = -200, cmparamErr = 86, cmProfileError = 2301, cmMethodError = -203,
cmCantConcatenateError = -208, cmInvalidColorSpace = -209, cmInvalidSrcMap = -210, cmInvalidDstMap = -211,
cmNamedColorNotFound = -216, cmElementTagNotFound = 2302, userCanceledErr = -128, badProfileError = -228,
memFullErr = 8
}

enum

{
cmNoColorPacking = 0x0000, cmAlphaSpace = 0x0080, cmWord5ColorPacking = 0x0500, cmWord565ColorPacking = 0x0600,
cmLong8ColorPacking = 0x0800, cmLong10ColorPacking = 0x0A00, cmAlphaFirstPacking = 0x1000, cmOneBitDirectPacking = 0x0B00,
cmAlphaLastPacking = 0x0000, cm8PerChannelPacking = 0x2000, cm10PerChannelPacking = 0x0A00, cm16PerChannelPacking = 0x4000,
cm32_32ColorPacking = 0x2700
}

enum

{
cmNoSpace = 0, cmRGBSpace = 1, cmCMYKSpace = 2, cmHSVSpace = 3,
cmHLSSpace = 4, cmYXYSpace = 5, cmXYZSpace = 6, cmLUVSpace = 7,
cmLABSpace = 8, cmCMYSpace = 9, cmGraySpace = 10, cmReservedSpace2 = 11,
cmGamutResultSpace = 12, cmGenericSpace = 13, cmBGRSpace = 14, cmYCCSpace = 15,
cmNamedIndexedSpace = 16, cmMCFiveSpace = 17, cmMCSixSpace = 18, cmMCSevenSpace = 19,
cmMCEightSpace = 20, cmKYMCSpace = 29, cmRGBASpace = cmRGBSpace + cmAlphaSpace, cmGrayASpace = cmGraySpace + cmAlphaSpace,
cmRGB16Space = cmWord5ColorPacking + cmRGBSpace, cmRGB16_565Space = cmWord565ColorPacking + cmRGBSpace, cmRGB32Space = cmLong8ColorPacking + cmRGBSpace, cmARGB32Space = cmLong8ColorPacking + cmAlphaFirstPacking + cmRGBASpace,
cmCMYK32Space = cmLong8ColorPacking + cmCMYKSpace, cmKYMC32Space = cmLong8ColorPacking + cmKYMCSpace, cmHSV32Space = cmLong10ColorPacking + cmHSVSpace, cmHLS32Space = cmLong10ColorPacking + cmHLSSpace,
cmYXY32Space = cmLong10ColorPacking + cmYXYSpace, cmXYZ32Space = cmLong10ColorPacking + cmXYZSpace, cmLUV32Space = cmLong10ColorPacking + cmLUVSpace, cmLAB32Space = cmLong10ColorPacking + cmLABSpace,
cmGamutResult1Space = cmOneBitDirectPacking + cmGamutResultSpace, cmRGB24Space = cm8PerChannelPacking + cmRGBSpace, cmRGBA32Space = cm8PerChannelPacking + cmAlphaLastPacking + cmRGBASpace, cmCMY24Space = cm8PerChannelPacking + cmCMYSpace,
cmLAB24Space = cm8PerChannelPacking + cmLABSpace, cmGraySpace8Bit = cmGraySpace + cm8PerChannelPacking, cmYCC24Space = cm8PerChannelPacking + cmYCCSpace, cmYCC32Space = cmLong8ColorPacking + cmYCCSpace,
cmYCCASpace = cmYCCSpace + cmAlphaSpace, cmYCCA32Space = cm8PerChannelPacking + cmAlphaLastPacking + cmYCCASpace, cmAYCC32Space = cmLong8ColorPacking + cmAlphaFirstPacking + cmYCCASpace, cmBGR24Space = cm8PerChannelPacking + cmBGRSpace,
cmBGR32Space = cmLong8ColorPacking + cmBGRSpace + cmAlphaSpace, cmNamedIndexed24Space = cmNamedIndexedSpace, cmNamedIndexed32Space = cm32_32ColorPacking + cmNamedIndexedSpace, cmMCFive8Space = cmMCFiveSpace + cm8PerChannelPacking,
cmMCSix8Space = cmMCSixSpace + cm8PerChannelPacking, cmMCSeven8Space = cmMCSevenSpace + cm8PerChannelPacking, cmMCEight8Space = cmMCEightSpace + cm8PerChannelPacking
}

enum | { cmPerceptual = 0, cmRelativeColorimetric = 1, cmSaturation = 2, cmAbsoluteColorimetric = 3 }
enum | { cmNormalMode = 0, cmDraftMode = 1, cmBestMode = 2, cmBestMode16Bit = 3 }

## Functions

PI_Boolean | CMProfileElementExists (CMProfileRef prof, PI_OSType tag)
CMError | CMGetProfileElement (CMProfileRef prof, PI_OSType tag, unsigned long *elementSize, void *elementData)
CMError | CMGetProfileHeader (CMProfileRef prof, CMCoreProfileHeader *header)
CMError | CMGetPartialProfileElement (CMProfileRef prof, PI_OSType tag, unsigned long offset, unsigned long *byteCount, void *elementData)
CMError | CMSetProfileElementSize (CMProfileRef prof, PI_OSType tag, unsigned long elementSize)
CMError | CMSetPartialProfileElement (CMProfileRef prof, PI_OSType tag, unsigned long offset, unsigned long byteCount, void *elementData)
CMError | CMSetProfileElement (CMProfileRef prof, PI_OSType tag, unsigned long elementSize, void *elementData)
CMError | CMSetProfileHeader (CMProfileRef prof, const CMCoreProfileHeader *header)
CMError | CWNewColorWorld (CMWorldRef *cw, CMProfileRef src, CMProfileRef dst)
CMError | CWConcatColorWorld (CMWorldRef *cw, CMConcatProfileSet *profileSet)
CMError | CWConcatColorWorld4MS (CMWorldRef *storage, CMConcatProfileSet *profileSet, UINT32 *aIntentArr, UINT32 nIntents, UINT32 dwFlags)
CMError | CWCreateLink4MS (CMWorldRef storage, CMConcatProfileSet *profileSet, UINT32 aIntentArr, icProfile **theLinkProfile)
CMError | CWLinkColorWorld (CMWorldRef *cw, CMConcatProfileSet *profileSet)
void | CWDisposeColorWorld (CMWorldRef cw)
CMError | CWMatchColors (CMWorldRef cw, CMColor *myColors, unsigned long count)
CMError | CWCheckColors (CMWorldRef cw, CMColor *myColors, unsigned long count, unsigned char *result)
CMError | CWCheckColorsMS (CMWorldRef cw, CMColor *myColors, unsigned long count, unsigned char *result)
CMError | CWGetColorSpaces (CMWorldRef cw, CMBitmapColorSpace *In, CMBitmapColorSpace *Out)
CMError | CWMatchBitmap (CMWorldRef cw, CMBitmap *bitmap, CMBitmapCallBackUPP progressProc, void *refCon, CMBitmap *matchedBitmap)
CMError | CWCheckBitmap (CMWorldRef cw, const CMBitmap *bitmap, CMBitmapCallBackUPP progressProc, void *refCon, CMBitmap *resultBitmap)
CMError | CWMatchBitmapPlane (CMWorldRef cw, LH_CMBitmapPlane *bitmap, CMBitmapCallBackUPP progressProc, void *refCon, LH_CMBitmapPlane *matchedBitmap)
CMError | CWCheckBitmapPlane (CMWorldRef cw, LH_CMBitmapPlane *bitmap, CMBitmapCallBackUPP progressProc, void *refCon, LH_CMBitmapPlane *matchedBitmap)
void | CMFullColorRemains (CMWorldRef Storage, long ColorMask)
void | CMSetLookupOnlyMode (CMWorldRef Storage, PI_Boolean Mode)
CMError | CMValidateProfile (CMProfileRef prof, PI_Boolean *valid)
CMError | CMConvNameToIndexProfile (CMProfileRef prof, pcCMColorName, unsigned long *, unsigned long)
CMError | CMConvNameToIndexCW (CMWorldRef *Storage, pcCMColorName, unsigned long *, unsigned long)
CMError | CMConvIndexToNameProfile (CMProfileRef prof, unsigned long *, pCMColorName, unsigned long)
CMError | CMConvIndexToNameCW (CMWorldRef *Storage, unsigned long *, pCMColorName, unsigned long)
CMError | CMGetNamedProfileInfoProfile (CMProfileRef prof, pCMNamedProfileInfo)
CMError | CMGetNamedProfileInfoCW (CMWorldRef *Storage, pCMNamedProfileInfo)

## Define Documentation

#define CallCMBitmapCallBackProc | ( | f,
|  | a,
|  | b,
|  | c |  | ) | ((*f)((a)-(b),c))

| Definition at line 152 of file lh_open/pi_app.h. Referenced by LHCheckBitMapPrivate(), LHMatchBitMapPlanePrivate(), and LHMatchBitMapPrivate().

#define CM_MAX_COLOR_CHANNELS 8

| Definition at line 21 of file lh_open/pi_app.h.

#define kCreateGamutLutMask 0x00080000 /* Set Bit disables gamut lut creation */

| Definition at line 333 of file lh_open/pi_app.h. Referenced by CMCreateMultiProfileTransformInternal(), and PrepareCombiLUTs().

#define kEndWithLabPCS 0x01000000

| Definition at line 338 of file lh_open/pi_app.h.

#define kEndWithXyzPCS 0x00800000

| Definition at line 337 of file lh_open/pi_app.h.

#define kLookupOnlyMask 0x00040000

| Definition at line 332 of file lh_open/pi_app.h. Referenced by CMCreateMultiProfileTransformInternal(), CMMConcatInitPrivate(), and CMMInitPrivate().

#define kQualityMask 0x00030000 /* see Modes obove ( e.g. cmBestMode<<16 ) */

| Definition at line 331 of file lh_open/pi_app.h. Referenced by CreateCombi().

#define kStartWithLabPCS 0x00400000

| Definition at line 336 of file lh_open/pi_app.h.

#define kStartWithXyzPCS 0x00200000

| Definition at line 335 of file lh_open/pi_app.h.

#define kUseRelColorimetric 0x00100000

| Definition at line 334 of file lh_open/pi_app.h. Referenced by CMCreateMultiProfileTransformInternal().

## Typedef Documentation

typedef struct CMBitmap CMBitmap

| Definition at line 299 of file lh_open/pi_app.h.

typedef PI_Boolean(* CMBitmapCallBackProcPtr)(long progress, void *refCon)

| Definition at line 345 of file lh_open/pi_app.h.

typedef CMBitmapCallBackProcPtr CMBitmapCallBackUPP

| Definition at line 347 of file lh_open/pi_app.h. Referenced by CMCheckColorsInGamut(), CMCheckRGBs(), CMTranslateRGB(), CMTranslateRGBs(), and CMTranslateRGBsExt().

typedef unsigned long CMBitmapColorSpace

| Definition at line 22 of file lh_open/pi_app.h. Referenced by CheckInputColorSpace(), CheckOutputColorSpace(), CMCheckRGBs(), CMGetDataColorSpace(), CMTranslateRGB(), CMTranslateRGBs(), and CMTranslateRGBsExt().

typedef union CMColor CMColor

typedef char CMColorName[32]

| Definition at line 301 of file lh_open/pi_app.h.

typedef struct CMConcatProfileSet CMConcatProfileSet

| Definition at line 176 of file lh_open/pi_app.h. Referenced by CMCreateDeviceLinkProfile(), CMCreateMultiProfileTransformInternal(), and CMMInitPrivate().

typedef icHeader CMCoreProfileHeader

| Definition at line 167 of file lh_open/pi_app.h. Referenced by CMGetProfileHeader().

typedef icDateTimeNumber CMDateTime

| Definition at line 178 of file lh_open/pi_app.h.

typedef long CMError

| Definition at line 23 of file lh_open/pi_app.h. Referenced by AllocBufferCheckCM(), Calc323Dim_Data8To8_Lut16(), Calc324Dim_Data8To8_Lut16(), Calc423Dim_Data8To8_Lut16(), Calc424Dim_Data8To8_Lut16(), CalcNDim_Data16To16_Lut16(), CalcNDim_Data16To16_Lut8(), CalcNDim_Data16To8_Lut16(), CalcNDim_Data16To8_Lut8(), CalcNDim_Data8To16_Lut16(), CalcNDim_Data8To16_Lut8(), CalcNDim_Data8To8_Lut16(), CalcNDim_Data8To8_Lut8(), CheckInputColorSpace(), CheckOutputColorSpace(), CheckOutputColorSpaceChk(), CMConvertColorNameToIndex(), CMConvertNamedIndexToColors(), CMConvertNamedIndexToPCS(), CMConvIndexToName(), CMConvIndexToNameCW(), CMConvIndexToNameProfile(), CMConvNameToIndex(), CMConvNameToIndexCW(), CMConvNameToIndexProfile(), CMGetNamedProfileInfoCW(), CMGetNamedProfileInfoProfile(), CMGetPartialProfileElement(), CMGetProfileElement(), CMGetProfileHeader(), CMMConcatInitPrivate(), CMMInitPrivate(), CMValidateProfile(), CombiMatrix(), ConvertIndexToLabBitmap(), ConvertLabToIndexBitmap(), CopyIndexData(), Create_LH_ProfileSet(), CreateCombi(), CreateLinearAlut(), CreateLinearAlut16(), CreateLinearElut(), CreateLinearElut16(), CWCheckBitmap(), CWCheckBitmapPlane(), CWCheckColors(), CWCheckColorsMS(), CWConcatColorWorld(), CWConcatColorWorld4MS(), CWCreateLink4MS(), CWGetColorSpaces(), CWLinkColorWorld(), CWMatchBitmap(), CWMatchBitmapPlane(), CWMatchColors(), CWNewColorWorld(), DeviceLinkFill(), Do555To8Setup(), Do8To555Setup(), DoAbsoluteShiftForPCS_Cube16(), DoMakeGamutForMonitor(), doubMatrixInvert(), Extract_Gray_Luts(), Extract_MFT_Alut(), Extract_MFT_Elut(), Extract_MFT_Xlut(), Extract_TRC_Alut(), Extract_TRC_Elut(), Extract_TRC_Matrix(), ExtractAll_MFT_Luts(), ExtractAll_TRC_Luts(), ExtractAllLuts(), Fill_inverse_byte_ALUT_from_CurveTag(), Fill_inverseGamma_byte_ALUT(), Fill_mft1_InputTable(), Fill_mft1_OutputTable(), Fill_mft2_ColorTable(), Fill_mft2_InputTable(), Fill_mft2_OutputTable(), Fill_ushort_ELUT_from_CurveTag(), Fill_ushort_ELUT_Gamma(), Fill_ushort_ELUT_identical(), FillCalcParam(), FillCalcParamCM(), FillLutParam(), FillLutParamChk(), FillProfileFromLog(), FillProfileFromLogW(), FindCalcRoutine(), FindLookupRoutine(), GetMatrixFromProfile(), InitNamedColorProfileData(), InvLut1dExceptions(), LHCheckBitMapPrivate(), LHCheckColorsPrivate(), LHCheckColorsPrivateMS(), LHColorWorldClose(), LHColorWorldOpen(), LHMatchBitMapPlanePrivate(), LHMatchBitMapPrivate(), LHMatchColorsPrivate(), MakeGamut16or32ForMonitor(), MakeSessionFromLink(), MyAdd_NL_AToB0Tag_mft1(), MyAdd_NL_AToB0Tag_mft2(), MyAdd_NL_ColorantTag(), MyAdd_NL_CopyrightTag(), MyAdd_NL_CurveTag(), MyAdd_NL_DescriptionTag(), MyAdd_NL_Header(), MyAdd_NL_HeaderMS(), MyAdd_NL_SequenceDescTag(), MyGetColorSpaces(), MyNewDeviceLink(), MyNewDeviceLinkFill(), MyNewDeviceLinkW(), PrepareCombiLUTs(), SetMem16(), and SetOutputColorSpaceInplace().

typedef struct tagCMNamedProfileInfo CMNamedProfileInfo

typedef struct CMPrivateProfileRecord* CMProfileRef

| Definition at line 25 of file lh_open/pi_app.h. Referenced by CMCreateDeviceLinkProfile(), CMCreateMultiProfileTransformInternal(), CMGetProfileHeader(), CMIsProfileValid(), CMMConcatInitPrivate(), CMMInitPrivate(), CMValAToB(), CMValBToA(), CMValColorSpace(), CMValGray(), CMValidateProfile(), CMValLink(), CMValMftOutput(), CMValNamed(), CMValRGB(), and Create_LH_ProfileSet().

typedef struct CMUniqueIdentification CMUniqueIdentification

| Definition at line 185 of file lh_open/pi_app.h.

typedef struct CMPrivateColorWorldRecord* CMWorldRef

| Definition at line 350 of file lh_open/pi_app.h. Referenced by CMCreateDeviceLinkProfile(), CMCreateMultiProfileTransform(), CMCreateProfile(), CMCreateProfileW(), CMCreateTransformExt(), CMCreateTransformExtInternal(), CMCreateTransformExtW(), CMDeleteTransform(), CMTranslateRGB(), CMTranslateRGBs(), CWConcatColorWorld(), CWConcatColorWorld4MS(), CWLinkColorWorld(), CWNewColorWorld(), and StoreTransform().

typedef const CMColorName* pcCMColorName

| Definition at line 303 of file lh_open/pi_app.h.

typedef CMColorName* pCMColorName

| Definition at line 302 of file lh_open/pi_app.h.

typedef CMNamedProfileInfo* pCMNamedProfileInfo

| Definition at line 311 of file lh_open/pi_app.h. Referenced by CMGetNamedProfileInfo().

typedef unsigned char PI_Boolean

| Definition at line 340 of file lh_open/pi_app.h. Referenced by CMValAbstract(), CMValAToB(), CMValBToA(), CMValColorSpace(), CMValDisplay(), CMValGray(), CMValInput(), CMValLink(), CMValMftOutput(), CMValNamed(), CMValOutput(), and CMValRGB().

typedef unsigned int PI_OSType

| Definition at line 24 of file lh_open/pi_app.h.

## Enumeration Type Documentation

anonymous enum

Enumeration values:

  cmNoColorPacking |
  cmAlphaSpace |
  cmWord5ColorPacking |
  cmWord565ColorPacking |
  cmLong8ColorPacking |
  cmLong10ColorPacking |
  cmAlphaFirstPacking |
  cmOneBitDirectPacking |
  cmAlphaLastPacking |
  cm8PerChannelPacking |
  cm10PerChannelPacking |
  cm16PerChannelPacking |
  cm32_32ColorPacking |

Definition at line 188 of file lh_open/pi_app.h.

    00188      {
    00189         cmNoColorPacking                        = 0x0000,
    00190         cmAlphaSpace                            = 0x0080,
    00191         cmWord5ColorPacking                     = 0x0500,
    00192         cmWord565ColorPacking           = 0x0600,
    00193         cmLong8ColorPacking                     = 0x0800,
    00194         cmLong10ColorPacking            = 0x0A00,
    00195         cmAlphaFirstPacking                     = 0x1000,
    00196         cmOneBitDirectPacking           = 0x0B00,  /* for gamut check. highest bit first */
    00197         cmAlphaLastPacking                      = 0x0000,
    00198         cm8PerChannelPacking            = 0x2000,
    00199         cm10PerChannelPacking           = 0x0A00,
    00200         cm16PerChannelPacking           = 0x4000,
    00201
    00202         cm32_32ColorPacking                     = 0x2700
    00203 };

anonymous enum

Enumeration values:

  cmNoSpace |
  cmRGBSpace |
  cmCMYKSpace |
  cmHSVSpace |
  cmHLSSpace |
  cmYXYSpace |
  cmXYZSpace |
  cmLUVSpace |
  cmLABSpace |
  cmCMYSpace |
  cmGraySpace |
  cmReservedSpace2 |
  cmGamutResultSpace |
  cmGenericSpace |
  cmBGRSpace |
  cmYCCSpace |
  cmNamedIndexedSpace |
  cmMCFiveSpace |
  cmMCSixSpace |
  cmMCSevenSpace |
  cmMCEightSpace |
  cmKYMCSpace |
  cmRGBASpace |
  cmGrayASpace |
  cmRGB16Space |
  cmRGB16_565Space |
  cmRGB32Space |
  cmARGB32Space |
  cmCMYK32Space |
  cmKYMC32Space |
  cmHSV32Space |
  cmHLS32Space |
  cmYXY32Space |
  cmXYZ32Space |
  cmLUV32Space |
  cmLAB32Space |
  cmGamutResult1Space |
  cmRGB24Space |
  cmRGBA32Space |
  cmCMY24Space |
  cmLAB24Space |
  cmGraySpace8Bit |
  cmYCC24Space |
  cmYCC32Space |
  cmYCCASpace |
  cmYCCA32Space |
  cmAYCC32Space |
  cmBGR24Space |
  cmBGR32Space |
  cmNamedIndexed24Space |
  cmNamedIndexed32Space |
  cmMCFive8Space |
  cmMCSix8Space |
  cmMCSeven8Space |
  cmMCEight8Space |

Definition at line 206 of file lh_open/pi_app.h.

    00206      {
    00207         cmNoSpace                                       = 0,
    00208         cmRGBSpace                                      = 1,
    00209         cmCMYKSpace                                     = 2,
    00210         cmHSVSpace                                      = 3,
    00211         cmHLSSpace                                      = 4,
    00212         cmYXYSpace                                      = 5,
    00213         cmXYZSpace                                      = 6,
    00214         cmLUVSpace                                      = 7,
    00215         cmLABSpace                                      = 8,
    00216         cmCMYSpace                                      = 9,
    00217         cmGraySpace                                     = 10,
    00218         cmReservedSpace2                        = 11,
    00219         cmGamutResultSpace                      = 12,
    00220
    00221         cmGenericSpace                          = 13,                   /*UWE: GenericDataFormat  */
    00222         cmBGRSpace                                      = 14,                   /*UWE: BGR  */
    00223         cmYCCSpace                                      = 15,                   /*UWE: YCC  */
    00224         cmNamedIndexedSpace                     = 16,                   /* */
    00225
    00226         cmMCFiveSpace                           = 17,
    00227         cmMCSixSpace                            = 18,
    00228         cmMCSevenSpace                          = 19,
    00229         cmMCEightSpace                          = 20,
    00230
    00231         cmKYMCSpace                                     = 29,
    00232         cmRGBASpace                                     = cmRGBSpace + cmAlphaSpace,
    00233         cmGrayASpace                            = cmGraySpace + cmAlphaSpace,
    00234         cmRGB16Space                            = cmWord5ColorPacking + cmRGBSpace,
    00235         cmRGB16_565Space                        = cmWord565ColorPacking + cmRGBSpace,
    00236         cmRGB32Space                            = cmLong8ColorPacking + cmRGBSpace,
    00237         cmARGB32Space                           = cmLong8ColorPacking + cmAlphaFirstPacking + cmRGBASpace,
    00238         cmCMYK32Space                           = cmLong8ColorPacking + cmCMYKSpace,
    00239         cmKYMC32Space                           = cmLong8ColorPacking + cmKYMCSpace,
    00240         cmHSV32Space                            = cmLong10ColorPacking + cmHSVSpace,
    00241         cmHLS32Space                            = cmLong10ColorPacking + cmHLSSpace,
    00242         cmYXY32Space                            = cmLong10ColorPacking + cmYXYSpace,
    00243         cmXYZ32Space                            = cmLong10ColorPacking + cmXYZSpace,
    00244         cmLUV32Space                            = cmLong10ColorPacking + cmLUVSpace,
    00245         cmLAB32Space                            = cmLong10ColorPacking + cmLABSpace,
    00246         cmGamutResult1Space                     = cmOneBitDirectPacking + cmGamutResultSpace,
    00247         cmRGB24Space                            = cm8PerChannelPacking + cmRGBSpace,
    00248         cmRGBA32Space                           = cm8PerChannelPacking + cmAlphaLastPacking + cmRGBASpace,
    00249         cmCMY24Space                            = cm8PerChannelPacking + cmCMYSpace,
    00250         cmLAB24Space                            = cm8PerChannelPacking + cmLABSpace,
    00251
    00252         cmGraySpace8Bit                         = cmGraySpace + cm8PerChannelPacking,
    00253         cmYCC24Space                            = cm8PerChannelPacking + cmYCCSpace,
    00254         cmYCC32Space                            = cmLong8ColorPacking + cmYCCSpace,
    00255         cmYCCASpace                                     = cmYCCSpace + cmAlphaSpace,
    00256         cmYCCA32Space                           = cm8PerChannelPacking + cmAlphaLastPacking + cmYCCASpace,
    00257         cmAYCC32Space                           = cmLong8ColorPacking + cmAlphaFirstPacking + cmYCCASpace,
    00258         cmBGR24Space                            = cm8PerChannelPacking + cmBGRSpace,
    00259         cmBGR32Space                            = cmLong8ColorPacking + cmBGRSpace + cmAlphaSpace,
    00260
    00261         cmNamedIndexed24Space           = cmNamedIndexedSpace,
    00262         cmNamedIndexed32Space           = cm32_32ColorPacking + cmNamedIndexedSpace,
    00263
    00264         cmMCFive8Space                          = cmMCFiveSpace + cm8PerChannelPacking,
    00265         cmMCSix8Space                           = cmMCSixSpace + cm8PerChannelPacking,
    00266         cmMCSeven8Space                         = cmMCSevenSpace + cm8PerChannelPacking,
    00267         cmMCEight8Space                         = cmMCEightSpace + cm8PerChannelPacking
    00268 #if ( CM_MAX_COLOR_CHANNELS == 16 )
    00269         ,
    00270         cmMC9Space                              = cmMCEight8Space + 1,
    00271         cmMCaSpace                              = cmMCEight8Space + 2,
    00272         cmMCbSpace                              = cmMCEight8Space + 3,
    00273         cmMCcSpace                              = cmMCEight8Space + 4,
    00274         cmMCdSpace                              = cmMCEight8Space + 5,
    00275         cmMCeSpace                              = cmMCEight8Space + 6,
    00276         cmMCfSpace                              = cmMCEight8Space + 7,
    00277         cmMC2Space                              = cmMCEight8Space + 8,
    00278         cmMC98Space                             = cmMC9Space + cm8PerChannelPacking,
    00279         cmMCa8Space                             = cmMCaSpace + cm8PerChannelPacking,
    00280         cmMCb8Space                             = cmMCbSpace + cm8PerChannelPacking,
    00281         cmMCc8Space                             = cmMCcSpace + cm8PerChannelPacking,
    00282         cmMCd8Space                             = cmMCdSpace + cm8PerChannelPacking,
    00283         cmMCe8Space                             = cmMCeSpace + cm8PerChannelPacking,
    00284         cmMCf8Space                             = cmMCfSpace + cm8PerChannelPacking,
    00285         cmMC28Space                             = cmMC2Space + cm8PerChannelPacking
    00286 #endif
    00287 };

anonymous enum

Enumeration values:

  cmPerceptual |
  cmRelativeColorimetric |
  cmSaturation |
  cmAbsoluteColorimetric |

Definition at line 315 of file lh_open/pi_app.h.

    00315      {
    00316         cmPerceptual                            = 0,                                                    /* Photographic images */
    00317         cmRelativeColorimetric          = 1,                                                    /* Logo Colors */
    00318         cmSaturation                            = 2,                                                    /* Business graphics */
    00319         cmAbsoluteColorimetric          = 3                                                             /* Logo Colors */
    00320 };

anonymous enum

Enumeration values:

  cmNormalMode |
  cmDraftMode |
  cmBestMode |
  cmBestMode16Bit |

Definition at line 323 of file lh_open/pi_app.h.

    00323      {
    00324     cmNormalMode                                = 0,                                                    /* it uses the least significent two bits in the high word of flag */
    00325     cmDraftMode                                 = 1,                                                    /* it should be evaulated like this: right shift 16 bits first, mask off the */
    00326     cmBestMode                                  = 2,                                                    /* high 14 bits, and then compare with the enum to determine the option value. Do NOT shift if CWConcatColorWorld4MS is used */
    00327     cmBestMode16Bit                             = 3                                                             /* calculate 16 bit combi LUT */
    00328 };

enum cmErrorCodes

Enumeration values:

  cmopenErr |
  cmparamErr |
  cmProfileError |
  cmMethodError |
  cmCantConcatenateError |
  cmInvalidColorSpace |
  cmInvalidSrcMap |
  cmInvalidDstMap |
  cmNamedColorNotFound |
  cmElementTagNotFound |
  userCanceledErr |
  badProfileError |
  memFullErr |

Definition at line 126 of file lh_open/pi_app.h.

    00126                  {
    00127 /* General Errors */
    00128         cmopenErr                       = -200,         /* I/O Error used in ProfileAccess.c only                                               */
    00129         cmparamErr                      = 86,
    00130
    00131         cmProfileError                          = 2301,
    00132         cmMethodError                           = -203,         /* This is an internal error, no CalcFunction found                             */
    00133         cmCantConcatenateError          = -208,         /* No concatenation possible                                                                    */
    00134
    00135         cmInvalidColorSpace                     = -209,         /* no match between Profile colorspace bitmap type                              */
    00136         cmInvalidSrcMap                         = -210,         /* Source bitmap color space is invalid                                                 */
    00137         cmInvalidDstMap                         = -211,         /* Destination bitmap color space is invalid                                    */
    00138
    00139         cmNamedColorNotFound            = -216,         /* index > count of named colors                                                                */
    00140
    00141         cmElementTagNotFound            = 2302,
    00142
    00143     userCanceledErr                             = -128,         /* callback proc returned to cancel calculation                                 */
    00144         badProfileError                 = -228,         /* header->magic != icMagicNumber used in ProfileAccess.c only  */
    00145     memFullErr                                  = 8
    00146 };

## Function Documentation

CMError CMConvIndexToNameCW | ( | CMWorldRef * | Storage,
|  | unsigned long * | ,
|  | pCMColorName | ,
|  | unsigned | long
| ) |

CMError CMConvIndexToNameProfile | ( | CMProfileRef | prof,
|  | unsigned long * | ,
|  | pCMColorName | ,
|  | unsigned | long
| ) |

CMError CMConvNameToIndexCW | ( | CMWorldRef * | Storage,
|  | pcCMColorName | ,
|  | unsigned long * | ,
|  | unsigned | long
| ) |

CMError CMConvNameToIndexProfile | ( | CMProfileRef | prof,
|  | pcCMColorName | ,
|  | unsigned long * | ,
|  | unsigned | long
| ) |

void CMFullColorRemains | ( | CMWorldRef | Storage,
|  | long | ColorMask
| ) |

Definition at line 393 of file lh_open/pi_color.c.

    00395 {
    00396         CMMModelPtr             aPtr;
    00397         CMLutParamPtr   lutParamPtr;
    00398         long Address,Size,i,j;
    00399
    00400         if( Storage == 0 )return;
    00401         LOCK_DATA( Storage );
    00402         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00403         lutParamPtr = &aPtr->lutParam;
    00404
    00405         Size = lutParamPtr->colorLutWordSize / 8;
    00406         if( !(lutParamPtr->colorLutInDim == 4 && lutParamPtr->colorLutOutDim == 4 ))return;
    00407
    00408         for( i=0; i<4; i++ ){
    00409                 if( (ColorMask & (1<<i)) == 0 ) continue;
    00410                 Address = lutParamPtr->colorLutGridPoints - 1;
    00411                 for( j=3-i+1; j<4; j++ )Address *= lutParamPtr->colorLutGridPoints;
    00412                 Address = Address * lutParamPtr->colorLutOutDim;
    00413                 for( j=0; j<4; j++){
    00414                         if( i == j ){
    00415                                 if( Size == 1 ){
    00416                                         *( ((unsigned char*)lutParamPtr->colorLut)+Address+3-j ) = (unsigned char)255;
    00417                                 }
    00418                                 else{
    00419                                         *( ((unsigned short*)lutParamPtr->colorLut)+Address+3-j ) = (unsigned short)65535;
    00420                                 }
    00421                         }
    00422                         else{
    00423                                 if( Size == 1 ){
    00424                                         *( ((unsigned char*)lutParamPtr->colorLut)+Address+3-j ) = (unsigned char)0;
    00425                                 }
    00426                                 else{
    00427                                         *( ((unsigned short*)lutParamPtr->colorLut)+Address+3-j ) = (unsigned short)0;
    00428                                 }
    00429                         }
    00430                 }
    00431         }
    00432         UNLOCK_DATA( Storage );
    00433         return;
    00434 }

CMError CMGetNamedProfileInfoCW | ( | CMWorldRef * | Storage,
|  | pCMNamedProfileInfo |
| ) |

CMError CMGetNamedProfileInfoProfile | ( | CMProfileRef | prof,
|  | pCMNamedProfileInfo |
| ) |

CMError CMGetPartialProfileElement | ( | CMProfileRef | prof,
|  | PI_OSType | tag,
|  | unsigned long | offset,
|  | unsigned long * | byteCount,
|  | void * | elementData
| ) |

CMError CMGetProfileElement | ( | CMProfileRef | prof,
|  | PI_OSType | tag,
|  | unsigned long * | elementSize,
|  | void * | elementData
| ) |

CMError CMGetProfileHeader | ( | CMProfileRef | prof,
|  | CMCoreProfileHeader * | header
| ) |

Definition at line 30 of file ntgdi/icm/mscmm/mscmm/access.c.

    00032 {
    00033         BOOL bool;
    00034         CMError ret = badProfileError;
    00035
    00036         bool = GetColorProfileHeader( (HPROFILE)prof, (PPROFILEHEADER) header );
    00037         if (header->magic == icMagicNumber && bool )
    00038                 ret = noErr;
    00039
    00040         return (ret);
    00041 }

PI_Boolean CMProfileElementExists | ( | CMProfileRef | prof,
|  | PI_OSType | tag
| ) |

void CMSetLookupOnlyMode | ( | CMWorldRef | Storage,
|  | PI_Boolean | Mode
| ) |

Definition at line 380 of file lh_open/pi_color.c.

    00382 {
    00383         CMMModelPtr             aPtr;
    00384
    00385         if( Storage == 0 )return;
    00386         LOCK_DATA( Storage );
    00387         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00388         aPtr->lookup = Mode;
    00389         UNLOCK_DATA( Storage );
    00390         return;
    00391 }

CMError CMSetPartialProfileElement | ( | CMProfileRef | prof,
|  | PI_OSType | tag,
|  | unsigned long | offset,
|  | unsigned long | byteCount,
|  | void * | elementData
| ) |

CMError CMSetProfileElement | ( | CMProfileRef | prof,
|  | PI_OSType | tag,
|  | unsigned long | elementSize,
|  | void * | elementData
| ) |

CMError CMSetProfileElementSize | ( | CMProfileRef | prof,
|  | PI_OSType | tag,
|  | unsigned long | elementSize
| ) |

CMError CMSetProfileHeader | ( | CMProfileRef | prof,
|  | const CMCoreProfileHeader * | header
| ) |

CMError CMValidateProfile | ( | CMProfileRef | prof,
|  | PI_Boolean * | valid
| ) |

Definition at line 302 of file lh_open/pi_valid.c.

    00304 {
    00305         CMError err = noErr;
    00306         icHeader aHeader;
    00307
    00308         *valid = FALSE;
    00309         err = CMGetProfileHeader((CMProfileRef)prof, &aHeader);
    00310
    00311         if (!err)
    00312         {
    00313                 if ((aHeader.version & 0xff000000) >= icVersionNumber ){
    00314                         switch (aHeader.deviceClass)
    00315                           {
    00316                                 case icSigInputClass:
    00317                                 *valid = CMValInput(prof, &aHeader );
    00318                                 break;
    00319
    00320                                 case icSigDisplayClass:
    00321                                 *valid = CMValDisplay(prof, &aHeader );
    00322                                 break;
    00323
    00324                                 case icSigOutputClass:
    00325                                 *valid = CMValOutput(prof, &aHeader );
    00326                                 break;
    00327
    00328                                 case icSigLinkClass:
    00329                                 *valid = CMValLink(prof);
    00330                                 break;
    00331
    00332                                 case icSigColorSpaceClass:
    00333                                 *valid = CMValColorSpace(prof, &aHeader );
    00334                                 break;
    00335
    00336                                 case icSigAbstractClass:
    00337                                 *valid = CMValAbstract(prof, &aHeader );
    00338                                 break;
    00339
    00340                                 case icSigNamedColorClass:
    00341                                 *valid = CMValNamed(prof, &aHeader );
    00342                                 break;
    00343
    00344                                 default:
    00345                                 *valid = FALSE;
    00346                           }
    00347
    00348                 }
    00349                 else
    00350                 {                                                                               /* unknown profile */
    00351                         *valid = FALSE;
    00352                         return (cmProfileError);
    00353                 }
    00354         }
    00355
    00356         return (err);
    00357 }

CMError CWCheckBitmap | ( | CMWorldRef | cw,
|  | const CMBitmap * | bitmap,
|  | CMBitmapCallBackUPP | progressProc,
|  | void * | refCon,
|  | CMBitmap * | resultBitmap
| ) |

Definition at line 113 of file lh_open/pi_run.c.

    00119 {
    00120         CMError         err = noErr;
    00121         CMMModelPtr aPtr;
    00122
    00123         if( Storage == 0 )return cmparamErr;
    00124         LOCK_DATA( Storage );
    00125         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00126     err = LHCheckBitMapPrivate(  aPtr,
    00127                                   (const CMBitmap*)bitMap,
    00128                                   progressProc,
    00129                                   refCon,
    00130                                   resultBitMap );
    00131         UNLOCK_DATA( Storage );
    00132         return err;
    00133 }

CMError CWCheckBitmapPlane | ( | CMWorldRef | cw,
|  | LH_CMBitmapPlane * | bitmap,
|  | CMBitmapCallBackUPP | progressProc,
|  | void * | refCon,
|  | LH_CMBitmapPlane * | matchedBitmap
| ) |

Definition at line 224 of file lh_open/pi_run.c.

    00230 {
    00231         Storage=Storage;
    00232         bitMap=bitMap;
    00233         progressProc=progressProc;
    00234         refCon=refCon;
    00235         CheckedBitMap=CheckedBitMap;
    00236         return cmparamErr;
    00237         /*CMError                       err = noErr;
    00238         CMMModelPtr aPtr;
    00239
    00240         if( Storage == 0 )return cmparamErr;
    00241         LOCK_DATA( Storage );
    00242         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00243         err = LHMatchBitMapPlanePrivate( aPtr,
    00244                                         (const LH_CMBitmapPlane*)bitMap,
    00245                                         progressProc,
    00246                                         refCon,
    00247                                         CheckedBitMap );
    00248         UNLOCK_DATA( Storage );
    00249                 return err;*/
    00250 }

CMError CWCheckColors | ( | CMWorldRef | cw,
|  | CMColor * | myColors,
|  | unsigned long | count,
|  | unsigned char * | result
| ) |

Definition at line 359 of file lh_open/pi_run.c.

    00364 {
    00365         CMError                 err = noErr;
    00366         CMMModelPtr aPtr;
    00367
    00368         if( Storage == 0 )return cmparamErr;
    00369         LOCK_DATA( Storage );
    00370         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00371         err = LHCheckColorsPrivate( aPtr, myColors, count, result );
    00372         UNLOCK_DATA( Storage );
    00373         return err;
    00374 }

CMError CWCheckColorsMS | ( | CMWorldRef | cw,
|  | CMColor * | myColors,
|  | unsigned long | count,
|  | unsigned char * | result
| ) |

CMError CWConcatColorWorld | ( | CMWorldRef * | cw,
|  | CMConcatProfileSet * | profileSet
| ) |

Definition at line 209 of file lh_open/pi_color.c.

    00211 {
    00212     Ptr                 myStorage;
    00213     CMError     err;
    00214
    00215     err = LHColorWorldOpen(&myStorage);
    00216
    00217     if ( !err )
    00218     {
    00219         ((CMMModelPtr)myStorage)->aIntentArr    = 0;
    00220                 ((CMMModelPtr)myStorage)->dwFlags               = 0xffffffff;
    00221         err = CMMConcatInitPrivate  ((CMMModelPtr)myStorage, profileSet );
    00222     }
    00223
    00224
    00225     if ( !err )
    00226     {
    00227                 *storage = (CMWorldRef)myStorage;
    00228     }
    00229         else{
    00230                 *storage = (CMWorldRef)0;
    00231                 LHColorWorldClose( myStorage );
    00232         }
    00233
    00234     return err;
    00235 }

CMError CWConcatColorWorld4MS | ( | CMWorldRef * | storage,
|  | CMConcatProfileSet * | profileSet,
|  | UINT32 * | aIntentArr,
|  | UINT32 | nIntents,
|  | UINT32 | dwFlags
| ) |

Definition at line 283 of file lh_open/pi_color.c.

    00289 {
    00290     Ptr                 myStorage;
    00291     CMError     err;
    00292 #if WRITE_PROFILE
    00293         icProfile *theLinkProfile;
    00294         long l;
    00295 #endif
    00296
    00297     err = LHColorWorldOpen(&myStorage);
    00298
    00299     if ( !err )
    00300     {
    00301                 ((CMMModelPtr)myStorage)->aIntentArr    = aIntentArr;
    00302         ((CMMModelPtr)myStorage)->nIntents              = nIntents;
    00303         ((CMMModelPtr)myStorage)->dwFlags               = dwFlags;
    00304                 err = CMMConcatInitPrivate  ((CMMModelPtr)myStorage, profileSet );
    00305     }
    00306
    00307
    00308     if ( !err )
    00309     {
    00310                 *storage = (CMWorldRef)myStorage;
    00311     }
    00312         else{
    00313                 *storage = (CMWorldRef)0;
    00314                 LHColorWorldClose( myStorage );
    00315         }
    00316
    00317 #if WRITE_PROFILE
    00318         err = DeviceLinkFill( (CMMModelPtr)myStorage, profileSet, &theLinkProfile, 0 );
    00319         if( !err ){
    00320                 l = *(unsigned long *)theLinkProfile;
    00321                 SwapLong(&l);
    00322                 WriteProf( "test", theLinkProfile, l );
    00323         }
    00324 #endif
    00325     return err;
    00326 }

CMError CWCreateLink4MS | ( | CMWorldRef | storage,
|  | CMConcatProfileSet * | profileSet,
|  | UINT32 | aIntentArr,
|  | icProfile ** | theLinkProfile
| ) |

Definition at line 436 of file lh_open/pi_color.c.

    00440 {
    00441     CMError     err;
    00442
    00443         *theLinkProfile = 0;
    00444
    00445         err = DeviceLinkFill( (CMMModelPtr)storage, profileSet, theLinkProfile, aIntent );
    00446
    00447         return err;
    00448 }

void CWDisposeColorWorld | ( | CMWorldRef | cw | ) |

Definition at line 375 of file lh_open/pi_color.c.

    00376 {
    00377     LHColorWorldClose ( (Ptr)storage );
    00378 }

CMError CWGetColorSpaces | ( | CMWorldRef | cw,
|  | CMBitmapColorSpace * | In,
|  | CMBitmapColorSpace * | Out
| ) |

Definition at line 395 of file lh_open/pi_run.c.

    00399 {
    00400         CMError                 err = noErr;
    00401         CMMModelPtr aPtr;
    00402
    00403         if( cw == 0 )return cmparamErr;
    00404         LOCK_DATA( cw );
    00405         aPtr = (CMMModelPtr)(DATA_2_PTR( cw ));
    00406         *In = aPtr->firstColorSpace;
    00407         *Out = aPtr->lastColorSpace;
    00408         UNLOCK_DATA( cw );
    00409         return err;
    00410 }

CMError CWLinkColorWorld | ( | CMWorldRef * | cw,
|  | CMConcatProfileSet * | profileSet
| ) |

Definition at line 329 of file lh_open/pi_color.c.

    00331 {
    00332     Ptr                 myStorage;
    00333     CMError     err;
    00334
    00335     err = LHColorWorldOpen(&myStorage);
    00336
    00337         if ( !err )
    00338     {
    00339                 ((CMMModelPtr)myStorage)->currentCall   = kCMMNewLinkProfile;
    00340                 ((CMMModelPtr)myStorage)->aIntentArr    = 0;
    00341                 ((CMMModelPtr)myStorage)->dwFlags               = 0xffffffff;
    00342                 err = CMMConcatInitPrivate  ((CMMModelPtr)myStorage, profileSet );
    00343     }
    00344
    00345
    00346     if ( !err )
    00347     {
    00348                 *storage = (CMWorldRef)myStorage;
    00349     }
    00350         else{
    00351                 *storage = (CMWorldRef)0;
    00352                 LHColorWorldClose( myStorage );
    00353         }
    00354
    00355     return err;
    00356 }

CMError CWMatchBitmap | ( | CMWorldRef | cw,
|  | CMBitmap * | bitmap,
|  | CMBitmapCallBackUPP | progressProc,
|  | void * | refCon,
|  | CMBitmap * | matchedBitmap
| ) |

Definition at line 56 of file lh_open/pi_run.c.

    00063 {
    00064         CMError                 err = noErr;
    00065         CMMModelPtr aPtr;
    00066
    00067         if( Storage == 0 )return cmparamErr;
    00068         LOCK_DATA( Storage );
    00069         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00070         err = LHMatchBitMapPrivate(     aPtr,
    00071                                                                 (const CMBitmap*)bitMap,
    00072                                                                 progressProc,
    00073                                                                 refCon,
    00074                                                                 matchedBitMap );
    00075         UNLOCK_DATA( Storage );
    00076         return err;
    00077 }

CMError CWMatchBitmapPlane | ( | CMWorldRef | cw,
|  | LH_CMBitmapPlane * | bitmap,
|  | CMBitmapCallBackUPP | progressProc,
|  | void * | refCon,
|  | LH_CMBitmapPlane * | matchedBitmap
| ) |

Definition at line 168 of file lh_open/pi_run.c.

    00174 {
    00175         CMError                 err = noErr;
    00176         CMMModelPtr aPtr;
    00177
    00178         if( Storage == 0 )return cmparamErr;
    00179         LOCK_DATA( Storage );
    00180         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00181         err = LHMatchBitMapPlanePrivate(        aPtr,
    00182                                                 (const LH_CMBitmapPlane*)bitMap,
    00183                                                 progressProc,
    00184                                                 refCon,
    00185                                                 matchedBitMap );
    00186         UNLOCK_DATA( Storage );
    00187         return err;
    00188 }

CMError CWMatchColors | ( | CMWorldRef | cw,
|  | CMColor * | myColors,
|  | unsigned long | count
| ) |

Definition at line 273 of file lh_open/pi_run.c.

    00277 {
    00278         CMError                 err = noErr;
    00279         CMMModelPtr aPtr;
    00280
    00281         if( Storage == 0 )return cmparamErr;
    00282         LOCK_DATA( Storage );
    00283         aPtr = (CMMModelPtr)(DATA_2_PTR(        Storage ));
    00284         err = LHMatchColorsPrivate( aPtr, myColors, count );
    00285         UNLOCK_DATA( Storage );
    00286         return err;
    00287 }

CMError CWNewColorWorld | ( | CMWorldRef * | cw,
|  | CMProfileRef | src,
|  | CMProfileRef | dst
| ) |

Definition at line 141 of file lh_open/pi_color.c.

    00144 {
    00145     Ptr                 myStorage;
    00146     CMError     err;
    00147
    00148 #ifdef DEBUG_OUTPUT
    00149     /*printf("vor LHColorWorldOpen\n");*/
    00150 #endif
    00151     err = LHColorWorldOpen(&myStorage);
    00152 #ifdef DEBUG_OUTPUT
    00153     /*printf("nach LHColorWorldOpen: err = %d\n", err);*/
    00154 #endif
    00155     if ( !err )
    00156     {
    00157         ((CMMModelPtr)myStorage)->aIntentArr    = 0;
    00158                 ((CMMModelPtr)myStorage)->dwFlags               = 0xffffffff;
    00159         err =  CMMInitPrivate((CMMModelPtr)myStorage,
    00160                                srcProfile,
    00161                                dstProfile);
    00162 #ifdef DEBUG_OUTPUT
    00163     /*printf("nach NCMMInitPrivate: err = %d\n", err);*/
    00164 #endif
    00165     }
    00166
    00167
    00168     if ( !err )
    00169     {
    00170                 *storage = (CMWorldRef)myStorage;
    00171     }
    00172         else{
    00173                 *storage = (CMWorldRef)0;
    00174                 LHColorWorldClose( myStorage );
    00175         }
    00176
    00177     return err;
    00178 }