//
//  Little cms DELPHI wrapper
//  Copyright (C) 1998-2005 Marti Maria
//
// Permission is hereby granted, free of charge, to any person obtaining 
// a copy of this software and associated documentation files (the "Software"), 
// to deal in the Software without restriction, including without limitation 
// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
// and/or sell copies of the Software, and to permit persons to whom the Software 
// is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in 
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// ver 1.15

UNIT lcmsdll;

INTERFACE

USES Windows;

 CONST

     // Intents

    INTENT_PERCEPTUAL               =  0;
    INTENT_RELATIVE_COLORIMETRIC    =  1;
    INTENT_SATURATION               =  2;
    INTENT_ABSOLUTE_COLORIMETRIC    =  3;

    // Flags

    cmsFLAGS_MATRIXINPUT            = $0001;
    cmsFLAGS_MATRIXOUTPUT           = $0002;
    cmsFLAGS_MATRIXONLY             = (cmsFLAGS_MATRIXINPUT OR cmsFLAGS_MATRIXOUTPUT);

    cmsFLAGS_NOPRELINEARIZATION     = $0010; // Don't create prelinearization tables
                                             // on precalculated transforms (internal use)                   

    cmsFLAGS_NOTPRECALC             = $0100;
    cmsFLAGS_NULLTRANSFORM          = $0200;  // Don't transform anyway
    cmsFLAGS_HIGHRESPRECALC         = $0400;  // Use more memory to give better accurancy
    cmsFLAGS_LOWRESPRECALC          = $0800;  // Use less memory to minimize resouces

    
    cmsFLAGS_GAMUTCHECK             = $1000;  // Mark Out of Gamut as alarm color (on proofing transform)
    cmsFLAGS_SOFTPROOFING           = $4000;  // Softproof of proofing profile

    cmsFLAGS_WHITEBLACKCOMPENSATION = $2000; 
    cmsFLAGS_BLACKPOINTCOMPENSATION = $2000;

    cmsFLAGS_NODEFAULTRESOURCEDEF   = $10000;   // PostScript

    // Format descriptors


        TYPE_GRAY_8                 = $30009;
        TYPE_GRAY_8_REV             = $32009;
        TYPE_GRAY_16                = $3000A;
        TYPE_GRAY_16_REV            = $3200A;
        TYPE_GRAY_16_SE             = $3080A;
        TYPE_GRAYA_8                = $30089;
        TYPE_GRAYA_16               = $3008A;
        TYPE_GRAYA_16_SE            = $3088A;
        TYPE_GRAYA_8_PLANAR         = $31089;
        TYPE_GRAYA_16_PLANAR        = $3108A;
        TYPE_RGB_8                  = $40019;
        TYPE_RGB_8_PLANAR           = $41019;
        TYPE_BGR_8                  = $40419;
        TYPE_BGR_8_PLANAR           = $41419;
        TYPE_RGB_16                 = $4001A;
        TYPE_RGB_16_PLANAR          = $4101A;
        TYPE_RGB_16_SE              = $4081A;
        TYPE_BGR_16                 = $4041A;
        TYPE_BGR_16_PLANAR          = $4141A;
        TYPE_BGR_16_SE              = $40C1A;
        TYPE_RGBA_8                 = $40099;
        TYPE_RGBA_8_PLANAR          = $41099;
        TYPE_RGBA_16                = $4009A;
        TYPE_RGBA_16_PLANAR         = $4109A;
        TYPE_RGBA_16_SE             = $4089A;
        TYPE_ARGB_8                 = $44099;
        TYPE_ARGB_16                = $4409A;
        TYPE_ABGR_8                 = $40499;
        TYPE_ABGR_16                = $4049A;
        TYPE_ABGR_16_PLANAR         = $4149A;
        TYPE_ABGR_16_SE             = $40C9A;
        TYPE_BGRA_8                 = $44499;
        TYPE_BGRA_16                = $4449A;
        TYPE_BGRA_16_SE             = $4489A;
        TYPE_CMY_8                  = $50019;
        TYPE_CMY_8_PLANAR           = $51019;
        TYPE_CMY_16                 = $5001A;
        TYPE_CMY_16_PLANAR          = $5101A;
        TYPE_CMY_16_SE              = $5081A;
        TYPE_CMYK_8                 = $60021;
        TYPE_CMYK_8_REV             = $62021;
        TYPE_YUVK_8                 = $62021;
        TYPE_CMYK_8_PLANAR          = $61021;
        TYPE_CMYK_16                = $60022;
        TYPE_CMYK_16_REV            = $62022;
        TYPE_YUVK_16                = $62022;
        TYPE_CMYK_16_PLANAR         = $61022;
        TYPE_CMYK_16_SE             = $60822;
        TYPE_KYMC_8                 = $60421;
        TYPE_KYMC_16                = $60422;
        TYPE_KYMC_16_SE             = $60C22;
        TYPE_KCMY_8                 = $64021;
        TYPE_KCMY_8_REV             = $66021;
        TYPE_KCMY_16                = $64022;
        TYPE_KCMY_16_REV            = $66022;
        TYPE_KCMY_16_SE             = $64822;
        TYPE_CMYKcm_8               = $0031;
        TYPE_CMYKcm_8_PLANAR        = $1031;
        TYPE_CMYKcm_16              = $0032;
        TYPE_CMYKcm_16_PLANAR       = $1032;
        TYPE_CMYKcm_16_SE           = $0832;
        TYPE_CMYK7_8                = $0039;
        TYPE_CMYK7_16               = $003A;
        TYPE_CMYK7_16_SE            = $083A;
        TYPE_KYMC7_8                = $0439;
        TYPE_KYMC7_16               = $043A;
        TYPE_KYMC7_16_SE            = $0C3A;
        TYPE_CMYK8_8                = $0041;
        TYPE_CMYK8_16               = $0042;
        TYPE_CMYK8_16_SE            = $0842;
        TYPE_KYMC8_8                = $0441;
        TYPE_KYMC8_16               = $0442;
        TYPE_KYMC8_16_SE            = $0C42;
        TYPE_CMYK9_8                = $0049;
        TYPE_CMYK9_16               = $004A;
        TYPE_CMYK9_16_SE            = $084A;
        TYPE_KYMC9_8                = $0449;
        TYPE_KYMC9_16               = $044A;
        TYPE_KYMC9_16_SE            = $0C4A;
        TYPE_CMYK10_8               = $0051;
        TYPE_CMYK10_16              = $0052;
        TYPE_CMYK10_16_SE           = $0852;
        TYPE_KYMC10_8               = $0451;
        TYPE_KYMC10_16              = $0452;
        TYPE_KYMC10_16_SE           = $0C52;
        TYPE_CMYK11_8               = $0059;
        TYPE_CMYK11_16              = $005A;
        TYPE_CMYK11_16_SE           = $085A;
        TYPE_KYMC11_8               = $0459;
        TYPE_KYMC11_16              = $045A;
        TYPE_KYMC11_16_SE           = $0C5A;
        TYPE_CMYK12_8               = $0061;
        TYPE_CMYK12_16              = $0062;
        TYPE_CMYK12_16_SE           = $0862;
        TYPE_KYMC12_8               = $0461;
        TYPE_KYMC12_16              = $0462;
        TYPE_KYMC12_16_SE           = $0C62;

        TYPE_XYZ_16                 = $9001A;
        TYPE_Lab_8                  = $A0019;
        TYPE_LabA_8                 = $A0099;
        TYPE_Lab_16                 = $A001A;
        TYPE_Yxy_16                 = $E001A;
        TYPE_YCbCr_8                = $70019;
        TYPE_YCbCr_8_PLANAR         = $71019;
        TYPE_YCbCr_16               = $7001A;
        TYPE_YCbCr_16_PLANAR        = $7101A;
        TYPE_YCbCr_16_SE            = $7081A;
        TYPE_YUV_8                  = $80019;
        TYPE_YUV_8_PLANAR           = $81019;
        TYPE_YUV_16                 = $8001A;
        TYPE_YUV_16_PLANAR          = $8101A;
        TYPE_YUV_16_SE              = $8081A;
        TYPE_HLS_8                  = $D0019;
        TYPE_HLS_8_PLANAR           = $D1019;
        TYPE_HLS_16                 = $D001A;
        TYPE_HLS_16_PLANAR          = $D101A;
        TYPE_HLS_16_SE              = $D081A;
        TYPE_HSV_8                  = $C0019;
        TYPE_HSV_8_PLANAR           = $C1019;
        TYPE_HSV_16                 = $C001A;
        TYPE_HSV_16_PLANAR          = $C101A;
        TYPE_HSV_16_SE              = $C081A;
        TYPE_NAMED_COLOR_INDEX      = $000A;

        TYPE_XYZ_DBL                = $90018;
        TYPE_Lab_DBL                = $A0018;
        TYPE_GRAY_DBL               = $30008;
        TYPE_RGB_DBL                = $40018;
        TYPE_CMYK_DBL               = $60020;


    // Some utility functions to compute new descriptors


    FUNCTION COLORSPACE_SH(e: Integer):Integer;
    FUNCTION SWAPFIRST_SH(e: Integer):Integer;
    FUNCTION FLAVOR_SH(e: Integer):Integer;
    FUNCTION PLANAR_SH(e: Integer):Integer;
    FUNCTION ENDIAN16_SH(e: Integer):Integer;
    FUNCTION DOSWAP_SH(e: Integer):Integer;
    FUNCTION EXTRA_SH(e: Integer):Integer;
    FUNCTION CHANNELS_SH(c: Integer):Integer;
    FUNCTION BYTES_SH(b: Integer):Integer;


  TYPE

      DWord                  = Cardinal;

      icTagSignature         = DWord;
      icColorSpaceSignature  = DWord;
      icProfileClassSignature= DWord;

  CONST

    // icc color space signatures

    icSigXYZData              = $58595A20;
    icSigLabData              = $4C616220;
    icSigLuvData              = $4C757620;
    icSigYCbCrData            = $59436272;
    icSigYxyData              = $59787920;
    icSigRgbData              = $52474220;
    icSigGrayData             = $47524159;
    icSigHsvData              = $48535620;
    icSigHlsData              = $484C5320;
    icSigCmykData             = $434D594B;
    icSigCmyData              = $434D5920;

    // icc Profile class signatures

    icSigInputClass           = $73636E72;
    icSigDisplayClass         = $6D6E7472;
    icSigOutputClass          = $70727472;
    icSigLinkClass            = $6C696E6B;
    icSigAbstractClass        = $61627374;
    icSigColorSpaceClass      = $73706163;
    icSigNamedColorClass      = $6e6d636c;


    // Added by lcms

    lcmsSignature                = $6c636d73;
    icSigLuvKData                = $4C75764B;  {'LuvK'}
    icSigChromaticityTag         = $6368726d;  { As per Addendum 2 to Spec. ICC.1:1998-09 }
    icSigChromaticAdaptationTag  = $63686164;
    


  TYPE

    cmsHPROFILE            = Pointer;
    cmsHTRANSFORM          = Pointer;
    LCMSHANDLE             = Pointer;

      LCMSGAMMAPARAMS = PACKED RECORD
                        Crc32      : DWord;         
                        TheType    : Integer;
                        Params     : ARRAY [0..9] OF Double;                        
                        END;

      GAMMATABLE = PACKED RECORD
                        Birth      : LCMSGAMMAPARAMS;
                        nEntries   : DWord;
                        GammaTable : ARRAY [0..1] OF Word;
                     END;

      LPGAMMATABLE = ^GAMMATABLE;


      // Colorimetric spaces

      cmsCIEXYZ = PACKED RECORD
                        X, Y, Z : Double;
                    END;

      LPcmsCIEXYZ = ^cmsCIEXYZ;

      cmsCIEXYZTRIPLE = PACKED RECORD
                        Red, Green, Blue : cmsCIEXYZ
                        END;

      LPcmsCIEXYZTRIPLE = ^cmsCIEXYZTRIPLE;

      cmsCIExyY = PACKED RECORD
                        x, y, YY : Double
                        END;

      LPcmsCIExyY = ^cmsCIExyY;


      cmsCIExyYTRIPLE = PACKED RECORD
                        Red, Green, Blue : cmsCIExyY
                        END;

      LPcmsCIExyYTRIPLE = ^cmsCIExyYTRIPLE;


      cmsCIELab = PACKED RECORD
                  L, a, b: Double
                  END;

      LPcmsCIELab = ^cmsCIELab;

      cmsCIELCh = PACKED RECORD
                  L, C, h : Double
                  END;

      LPcmsCIELCh = ^cmsCIELCh;

      // CIECAM97s

      cmsJCh   = PACKED RECORD
                   J, C, h : Double
                 END;

      LPcmsJCh  = ^cmsJCh;

      LPLUT = Pointer;

  CONST

    AVG_SURROUND_4     = 0;
    AVG_SURROUND       = 1;
    DIM_SURROUND       = 2;
    DARK_SURROUND      = 3;
    CUTSHEET_SURROUND  = 4;

    D_CALCULATE           =  -1;
    D_CALCULATE_DISCOUNT  =  -2;


  TYPE

    cmsViewingConditions = PACKED RECORD

                WhitePoint: cmsCIEXYZ;
                Yb        : Double;
                La        : Double;
                surround  : Integer;
                D_value   : Double
              END;


    LPcmsViewingConditions = ^cmsViewingConditions;
   
    cmsErrorHandler =  FUNCTION (Severity: Integer; Msg:PChar): Integer; cdecl;

    LCMSARRAYOFPCHAR = ARRAY OF PChar;

// Input/Output

FUNCTION  cmsOpenProfileFromFile(ICCProfile: PChar; sAccess: PChar) : cmsHPROFILE; StdCall;
FUNCTION  cmsOpenProfileFromMem(MemPtr: Pointer; dwSize: DWord) : cmsHPROFILE; StdCall;
FUNCTION  cmsCloseProfile(hProfile : cmsHPROFILE) : Boolean; StdCall;

FUNCTION  cmsCreateRGBProfile(WhitePoint : LPcmsCIExyY;
                                           Primaries: LPcmsCIExyYTRIPLE;
                                           TransferFunction: ARRAY OF LPGAMMATABLE) : cmsHPROFILE; StdCall;


FUNCTION cmsCreateGrayProfile(WhitePoint: LPcmsCIExyY;
                                              TransferFunction: LPGAMMATABLE) :  cmsHPROFILE; StdCall;


FUNCTION cmsCreateLinearizationDeviceLink(ColorSpace: icColorSpaceSignature; 
                                              TransferFunction: ARRAY OF LPGAMMATABLE) : cmsHPROFILE; StdCall;

FUNCTION cmsCreateInkLimitingDeviceLink(ColorSpace: icColorSpaceSignature; 
                                              Limit: Double) : cmsHPROFILE; StdCall;


FUNCTION  cmsCreateNULLProfile : cmsHPROFILE; StdCall;
FUNCTION  cmsCreateLabProfile(WhitePoint: LPcmsCIExyY): cmsHPROFILE; StdCall;
FUNCTION  cmsCreateLab4Profile(WhitePoint: LPcmsCIExyY): cmsHPROFILE; StdCall;
FUNCTION  cmsCreateXYZProfile:cmsHPROFILE; StdCall;
FUNCTION  cmsCreate_sRGBProfile:cmsHPROFILE; StdCall;
FUNCTION  cmsCreateBCHSWabstractProfile(nLUTPoints: Integer;
                                        Bright, Contrast, Hue, Saturation: Double;
                                        TempSrc, TempDest: Integer): cmsHPROFILE; StdCall;


// Utils

PROCEDURE cmsXYZ2xyY(Dest: LPcmsCIExyY; Source: LPcmsCIEXYZ); StdCall;
PROCEDURE cmsxyY2XYZ(Dest: LPcmsCIEXYZ; Source: LPcmsCIExyY); StdCall;
PROCEDURE cmsXYZ2Lab(WhitePoint: LPcmsCIEXYZ; xyz: LPcmsCIEXYZ; Lab: LPcmsCIELab); StdCall;
PROCEDURE cmsLab2XYZ(WhitePoint: LPcmsCIEXYZ; Lab: LPcmsCIELab; xyz: LPcmsCIEXYZ); StdCall;
PROCEDURE cmsLab2LCh(LCh: LPcmsCIELCh; Lab: LPcmsCIELab); StdCall;
PROCEDURE cmsLCh2Lab(Lab: LPcmsCIELab; LCh: LPcmsCIELCh); StdCall;

// CIELab handling

FUNCTION cmsDeltaE(Lab1, Lab2: LPcmsCIELab): Double; StdCall;
FUNCTION cmsCIE94DeltaE(Lab1, Lab2: LPcmsCIELab): Double; StdCall;
FUNCTION cmsBFDdeltaE(Lab1, Lab2: LPcmsCIELab): Double; StdCall;
FUNCTION cmsCMCdeltaE(Lab1, Lab2: LPcmsCIELab): Double; StdCall;
FUNCTION cmsCIE2000DeltaE(Lab1, Lab2: LPcmsCIELab; Kl, Kc, Kh: Double): Double; StdCall;

PROCEDURE cmsClampLab(Lab: LPcmsCIELab; amax, amin,  bmax, bmin: Double); StdCall;

// White point

FUNCTION  cmsWhitePointFromTemp(TempK: Integer; WhitePoint: LPcmsCIExyY) : Boolean; StdCall;


// CIECAM97s

FUNCTION    cmsCIECAM97sInit(pVC : LPcmsViewingConditions ) : Pointer; StdCall;
PROCEDURE   cmsCIECAM97sDone(hModel : Pointer); StdCall;

PROCEDURE   cmsCIECAM97sForward(hModel: Pointer; pIn: LPcmsCIEXYZ; pOut: LPcmsJCh ); StdCall;
PROCEDURE   cmsCIECAM97sReverse(hModel: Pointer; pIn: LPcmsJCh;   pOut: LPcmsCIEXYZ ); StdCall;

// CIECAM02

FUNCTION    cmsCIECAM02Init(pVC : LPcmsViewingConditions ) : Pointer; StdCall;
PROCEDURE   cmsCIECAM02Done(hModel : Pointer); StdCall;

PROCEDURE   cmsCIECAM02Forward(hModel: Pointer; pIn: LPcmsCIEXYZ; pOut: LPcmsJCh ); StdCall;
PROCEDURE   cmsCIECAM02Reverse(hModel: Pointer; pIn: LPcmsJCh;   pOut: LPcmsCIEXYZ ); StdCall;


// Gamma curves

FUNCTION  cmsBuildGamma(nEntries : Integer; Gamma: Double) : LPGAMMATABLE; StdCall;
FUNCTION  cmsAllocGamma(nEntries : Integer): LPGAMMATABLE; StdCall;
PROCEDURE cmsFreeGamma(Gamma: LPGAMMATABLE); StdCall;
PROCEDURE cmsFreeGammaTriple(Gamma: ARRAY OF LPGAMMATABLE); StdCall;
FUNCTION  cmsReverseGamma(nResultSamples: Integer; InGamma : LPGAMMATABLE): LPGAMMATABLE; StdCall;
FUNCTION  cmsJoinGamma(InGamma, OutGamma: LPGAMMATABLE): LPGAMMATABLE; StdCall;
FUNCTION  cmsJoinGammaEx(InGamma, OutGamma: LPGAMMATABLE; nPoints: Integer): LPGAMMATABLE; StdCall;
FUNCTION  cmsSmoothGamma(Gamma: LPGAMMATABLE; SmoothingLambda: Double): Boolean; StdCall;
FUNCTION  cmsDupGamma(Src: LPGAMMATABLE): LPGAMMATABLE; StdCall;
FUNCTION  cmsEstimateGamma(Src: LPGAMMATABLE): Double; StdCall;
FUNCTION  cmsEstimateGammaEx(Src: LPGAMMATABLE; Thereshold: Double): Double; StdCall;
FUNCTION  cmsReadICCGamma(hProfile: cmsHPROFILE; Sig: icTagSignature): LPGAMMATABLE; StdCall;
FUNCTION  cmsReadICCGammaReversed(hProfile: cmsHPROFILE; Sig: icTagSignature): LPGAMMATABLE; StdCall;

CONST

    lcmsParametricCurveExp          = 0;
    lcmsParametricCurveCIE_122_1966 = 1;
    lcmsParametricCurveIEC_61966_3  = 2;
    lcmsParametricCurveIEC_61966_2_1= 3;

FUNCTION cmsBuildParametricGamma(nEntries: Integer; TheType: Integer; Params: array of Double) : LPGAMMATABLE; StdCall;


// Access to Profile data.

PROCEDURE cmsSetLanguage(LanguageCode: Integer; CountryCode: Integer); StdCall;

FUNCTION cmsTakeMediaWhitePoint(Dest: LPcmsCIEXYZ; hProfile: cmsHPROFILE): Boolean; StdCall;
FUNCTION cmsTakeMediaBlackPoint(Dest: LPcmsCIEXYZ; hProfile: cmsHPROFILE): Boolean; StdCall;
FUNCTION cmsTakeIluminant(Dest: LPcmsCIEXYZ; hProfile: cmsHPROFILE): Boolean; StdCall;
FUNCTION cmsTakeColorants(Dest: LPcmsCIEXYZTRIPLE; hProfile: cmsHPROFILE): Boolean; StdCall;
FUNCTION cmsTakeHeaderFlags(hProfile: cmsHPROFILE): DWord; StdCall;

FUNCTION cmsTakeProductName(hProfile: cmsHPROFILE): PChar; StdCall;
FUNCTION cmsTakeProductDesc(hProfile: cmsHPROFILE): PChar; StdCall;

FUNCTION cmsTakeManufacturer(hProfile: cmsHPROFILE): PChar; StdCall;
FUNCTION cmsTakeModel(hProfile: cmsHPROFILE): PChar; StdCall;
FUNCTION cmsTakeCopyright(hProfile: cmsHPROFILE): PChar; StdCall;
FUNCTION cmsTakeProfileID(hProfile: cmsHPROFILE): PByte; StdCall;



FUNCTION cmsIsTag(hProfile: cmsHPROFILE; sig: icTagSignature): Boolean; StdCall;
FUNCTION cmsTakeRenderingIntent(hProfile: cmsHPROFILE): Integer; StdCall;
FUNCTION cmsIsIntentSupported(hProfile: cmsHPROFILE; Intent, UsedDirection : Integer): Integer; StdCall;
FUNCTION cmsTakeCharTargetData(hProfile: cmsHPROFILE; var Data : PChar; var len: Cardinal): Boolean; StdCall;

FUNCTION _cmsICCcolorSpace(OurNotation: Integer) : icColorSpaceSignature; StdCall;
FUNCTION _cmsLCMScolorSpace(ProfileSpace: icColorSpaceSignature): Integer; StdCall;
FUNCTION _cmsChannelsOf(ColorSpace: icColorSpaceSignature): Integer; StdCall;


FUNCTION cmsGetPCS(hProfile: cmsHPROFILE): icColorSpaceSignature; StdCall;
FUNCTION cmsGetColorSpace(hProfile: cmsHPROFILE): icColorSpaceSignature; StdCall;
FUNCTION cmsGetDeviceClass( hProfile: cmsHPROFILE): icProfileClassSignature; StdCall;
FUNCTION cmsGetProfileICCversion( hProfile: cmsHPROFILE): DWord; StdCall;

// Profile creation

PROCEDURE cmsSetDeviceClass(hProfile: cmsHPROFILE; sig: icProfileClassSignature ); StdCall;
PROCEDURE cmsSetColorSpace(hProfile: cmsHPROFILE; sig: icProfileClassSignature ); StdCall;
PROCEDURE cmsSetPCS(hProfile: cmsHPROFILE; pcs: icColorSpaceSignature); StdCall;
PROCEDURE cmsSetRenderingIntent(hProfile: cmsHPROFILE; Intent: Integer); StdCall;
PROCEDURE cmsSetHeaderFlags(hProfile: cmsHPROFILE; dwFlags: DWord); StdCall;
PROCEDURE cmsSetProfileID(hProfile: cmsHPROFILE; ProfileID: PByte); StdCall;



FUNCTION  cmsAddTag(hProfile: cmsHPROFILE; Sig: icTagSignature; Data: Pointer): Boolean; StdCall;
FUNCTION  _cmsSaveProfile(hProfile: cmsHPROFILE; FileName: PChar): Boolean; StdCall;
FUNCTION  _cmsSaveProfileToMem(hProfile: cmsHPROFILE; MemPtr: Pointer; 
                                                    var BytesNeeded: DWord): Boolean; StdCall;



CONST
        LCMS_USED_AS_INPUT   =   0;
        LCMS_USED_AS_OUTPUT  =   1;
        LCMS_USED_AS_PROOF   =   2;



// Transforms

FUNCTION cmsCreateTransform(Input: cmsHPROFILE;
                            InputFormat: DWORD;
                            Output: cmsHPROFILE;
                            OutputFormat: DWORD;
                            Intent: Integer;
                            dwFlags: DWord): cmsHTRANSFORM; StdCall;

FUNCTION cmsCreateProofingTransform(Input: cmsHPROFILE;
                            InputFormat: DWORD;
                            Output: cmsHPROFILE;
                            OutputFormat: DWORD;
                            Proofing: cmsHPROFILE;
                            Intent: Integer;
                            ProofingIntent: Integer;
                            dwFlags: DWord): cmsHTRANSFORM; StdCall;


FUNCTION cmsCreateMultiprofileTransform(hProfiles : ARRAY OF cmsHPROFILE;
                                        nProfiles : Integer;
                                        InputFormat: DWord;
                                        OutputFormat: DWord;
                                        Intent: Integer;
                                        dwFlags: DWord): cmsHTRANSFORM; StdCall;


PROCEDURE cmsDeleteTransform( hTransform: cmsHTRANSFORM); StdCall;

PROCEDURE cmsDoTransform( Transform: cmsHTRANSFORM;
                          InputBuffer: Pointer;
                          OutputBuffer: Pointer;
                          Size: LongInt); StdCall;

PROCEDURE cmsChangeBuffersFormat(hTransform: cmsHTRANSFORM;
                                dwInputFormat, dwOutputFormat: DWord); StdCall;

// Devicelink generation

FUNCTION cmsTransform2DeviceLink(hTransform: cmsHTRANSFORM; 
                                dwFlags: DWord): cmsHPROFILE; StdCall;

PROCEDURE _cmsSetLUTdepth(hProfile: cmsHPROFILE; depth: Integer); StdCall;

// Named color support

FUNCTION cmsNamedColorCount(xform: cmsHTRANSFORM): Integer; StdCall;
FUNCTION cmsNamedColorInfo(xform: cmsHTRANSFORM; nColor: Integer;
                             Name, Prefix, Suffix: PChar) : Boolean; StdCall;

FUNCTION cmsNamedColorIndex(xform: cmsHTRANSFORM; Name: PChar): Integer; StdCall;


// PostScript ColorRenderingDictionary and ColorSpaceArray

FUNCTION cmsGetPostScriptCSA(hProfile: cmsHPROFILE ;
                                 Intent: Integer;
                                 Buffer: Pointer;
                                 dwBufferLen: DWord): DWord; StdCall;

FUNCTION cmsGetPostScriptCRD(hProfile: cmsHPROFILE ;
                                 Intent: Integer;
                                 Buffer: Pointer;
                                 dwBufferLen: DWord): DWord; StdCall;

FUNCTION cmsGetPostScriptCRDEx(hProfile: cmsHPROFILE ;
                                 Intent: Integer;
                                 dwFlags: DWord;
                                 Buffer: Pointer;
                                 dwBufferLen: DWord): DWord; StdCall;




// Gamut check

PROCEDURE cmsSetAlarmCodes(r, g, b: Integer); StdCall;
PROCEDURE cmsGetAlarmCodes(VAR r, g, b: Integer); StdCall;

// Error handling
CONST

        LCMS_ERROR_ABORT   =  0;
        LCMS_ERROR_SHOW    =  1;
        LCMS_ERROR_IGNORE  =  2;

PROCEDURE cmsErrorAction(nAction: Integer); StdCall;

PROCEDURE cmsSetErrorHandler(ErrorHandler: cmsErrorHandler); StdCall;


// CGATS.13 parser

FUNCTION  cmsIT8Alloc: LCMSHANDLE; StdCall;
PROCEDURE cmsIT8Free(hIT8: LCMSHANDLE); StdCall;

// Tables

FUNCTION  cmsIT8TableCount(hIT8: LCMSHANDLE): Integer; StdCall;
FUNCTION  cmsIT8SetTable(hIT8: LCMSHANDLE; nTable: Integer): Integer; StdCall;

// Persistence
FUNCTION  cmsIT8LoadFromFile(cFileName: PChar): LCMSHANDLE; StdCall;
FUNCTION  cmsIT8LoadFromMem(Ptr: Pointer; size :DWord): LCMSHANDLE; StdCall;

FUNCTION cmsIT8SaveToFile(hIT8: LCMSHANDLE; cFileName: PChar): Boolean; StdCall;

// Properties

FUNCTION cmsIT8GetSheetType(hIT8: LCMSHANDLE): PChar; StdCall;
FUNCTION cmsIT8SetSheetType(hIT8: LCMSHANDLE; TheType: PChar): Boolean; StdCall;

FUNCTION cmsIT8SetComment(hIT8: LCMSHANDLE; cComment: PChar): Boolean; StdCall;

FUNCTION cmsIT8SetPropertyStr(hIT8: LCMSHANDLE; cProp, Str: PChar): Boolean; StdCall;
FUNCTION cmsIT8SetPropertyDbl(hIT8: LCMSHANDLE; cProp: PChar; Val: Double): Boolean; StdCall;
FUNCTION cmsIT8SetPropertyHex(hIT8: LCMSHANDLE; cProp: PChar; Val: Integer): Boolean; StdCall;
FUNCTION cmsIT8SetPropertyUncooked(hIT8: LCMSHANDLE; Key, Buffer: PChar): Boolean; StdCall;


FUNCTION cmsIT8GetProperty(hIT8: LCMSHANDLE; cProp: PChar): PChar; StdCall;
FUNCTION cmsIT8GetPropertyDbl(hIT8: LCMSHANDLE; cProp: PChar): Double; StdCall;
FUNCTION cmsIT8EnumProperties(hIT8: LCMSHANDLE; var PropertyNames: LCMSARRAYOFPCHAR): Integer; StdCall;

// Datasets

FUNCTION cmsIT8GetDataRowCol(hIT8: LCMSHANDLE; row, col: Integer): PChar; StdCall;                                                
FUNCTION cmsIT8GetDataRowColDbl(hIT8: LCMSHANDLE; row, col: Integer): Double; StdCall;

FUNCTION cmsIT8SetDataRowCol(hIT8: LCMSHANDLE; row, col: Integer; Val: PChar): Boolean; StdCall;
FUNCTION cmsIT8SetDataRowColDbl(hIT8: LCMSHANDLE; row, col: Integer; Val: Double): Boolean; StdCall;

FUNCTION cmsIT8GetData(hIT8: LCMSHANDLE; cPatch, cSample: PChar): PChar; StdCall;                                                

FUNCTION cmsIT8GetDataDbl(hIT8: LCMSHANDLE;cPatch, cSample: PChar): Double; StdCall;

FUNCTION cmsIT8SetData(hIT8: LCMSHANDLE; cPatch, cSample, Val: PChar): Boolean; StdCall;

FUNCTION cmsIT8SetDataDbl(hIT8: LCMSHANDLE; cPatch, cSample: PChar; Val: Double): Boolean; StdCall;                                                

FUNCTION cmsIT8SetDataFormat(hIT8: LCMSHANDLE; n: Integer; Sample: PChar): Boolean; StdCall;
FUNCTION cmsIT8EnumDataFormat(hIT8: LCMSHANDLE; var SampleNames: LCMSARRAYOFPCHAR): Integer; StdCall;
FUNCTION cmsIT8GetPatchName(hIT8: LCMSHANDLE; nPatch: Integer; Buffer: PChar): PChar; StdCall;

// The LABEL extension

FUNCTION cmsIT8SetTableByLabel(hIT8: LCMSHANDLE; cSet, cField, ExpectedType: PChar): Integer; StdCall;








// Provided for compatibility with anterior revisions

PROCEDURE cmsLabEncoded2Float(Lab: LPcmsCIELab; wLab: Pointer); StdCall;
PROCEDURE cmsFloat2LabEncoded(wLab: Pointer; Lab: LPcmsCIELab); StdCall;
PROCEDURE cmsXYZEncoded2Float(fxyz : LPcmsCIEXYZ; XYZ: Pointer); StdCall;
PROCEDURE cmsFloat2XYZEncoded(XYZ: Pointer; fXYZ: LPcmsCIEXYZ); StdCall;

FUNCTION _cmsAddTextTag(hProfile: cmsHPROFILE; sig: icTagSignature; Text: PChar): Boolean; StdCall;
FUNCTION _cmsAddXYZTag(hProfile: cmsHPROFILE;  sig: icTagSignature;  XYZ: LPcmsCIEXYZ): Boolean; StdCall;
FUNCTION _cmsAddLUTTag(hProfile: cmsHPROFILE;  sig: icTagSignature; lut: PByte): Boolean; StdCall;


IMPLEMENTATION


// Helping functions to build format descriptors (C uses them as macros)

FUNCTION COLORSPACE_SH(e: Integer):Integer; BEGIN COLORSPACE_SH := ((e) shl 16) END;
FUNCTION SWAPFIRST_SH(e: Integer):Integer;  BEGIN SWAPFIRST_SH   := ((e) shl 13) END;
FUNCTION FLAVOR_SH(e: Integer):Integer;     BEGIN FLAVOR_SH   := ((e) shl 13) END;
FUNCTION PLANAR_SH(e: Integer):Integer;     BEGIN PLANAR_SH   := ((e) shl 12) END;
FUNCTION ENDIAN16_SH(e: Integer):Integer;   BEGIN ENDIAN16_SH := ((e) shl 11) END;
FUNCTION DOSWAP_SH(e: Integer):Integer;     BEGIN DOSWAP_SH   := ((e) shl 10) END;
FUNCTION EXTRA_SH(e: Integer):Integer;      BEGIN EXTRA_SH    := ((e) shl 7) END;
FUNCTION CHANNELS_SH(c: Integer):Integer;   BEGIN CHANNELS_SH := ((c) shl 3) END;
FUNCTION BYTES_SH(b: Integer):Integer;      BEGIN BYTES_SH    := (b) END;

CONST
   PT_ANY   =   0;   // Don't check colorspace
                     // 1 & 2 are reserved
   PT_GRAY  =   3;
   PT_RGB   =   4;
   PT_CMY   =   5;
   PT_CMYK  =   6;
   PT_YCbCr =   7;
   PT_YUV   =   8;     // Lu'v'
   PT_XYZ   =   9;
   PT_Lab   =   10;
   PT_YUVK  =   11;    // Lu'v'K
   PT_HSV   =   12;
   PT_HLS   =   13;
   PT_Yxy   =   14;


FUNCTION  cmsOpenProfileFromFile(ICCProfile : PChar; sAccess: PChar) : cmsHPROFILE; EXTERNAL 'lcms.dll';
FUNCTION  cmsOpenProfileFromMem(MemPtr: Pointer; dwSize: DWord) : cmsHPROFILE; EXTERNAL 'lcms.dll';
FUNCTION  cmsWhitePointFromTemp(TempK: Integer; WhitePoint: LPcmsCIExyY) : Boolean; EXTERNAL 'lcms.dll';

FUNCTION  cmsBuildGamma(nEntries : Integer;  Gamma: Double) : LPGAMMATABLE; EXTERNAL 'lcms.dll';
FUNCTION  cmsAllocGamma(nEntries : Integer): LPGAMMATABLE; EXTERNAL 'lcms.dll';
PROCEDURE cmsFreeGamma(Gamma: LPGAMMATABLE); EXTERNAL 'lcms.dll';
PROCEDURE cmsFreeGammaTriple(Gamma: ARRAY OF LPGAMMATABLE); EXTERNAL 'lcms.dll';

FUNCTION  cmsReverseGamma(nResultSamples : Integer; InGamma : LPGAMMATABLE): LPGAMMATABLE; EXTERNAL 'lcms.dll';
FUNCTION  cmsBuildParametricGamma(nEntries: Integer; TheType: Integer; Params: array of Double) : LPGAMMATABLE; EXTERNAL 'lcms.dll';

FUNCTION  cmsJoinGamma(InGamma, OutGamma : LPGAMMATABLE): LPGAMMATABLE; EXTERNAL 'lcms.dll';
FUNCTION  cmsJoinGammaEx(InGamma, OutGamma: LPGAMMATABLE; nPoints: Integer): LPGAMMATABLE; EXTERNAL 'lcms.dll';

FUNCTION  cmsSmoothGamma(Gamma: LPGAMMATABLE; SmoothingLambda: Double): Boolean; EXTERNAL 'lcms.dll';

FUNCTION  cmsDupGamma(Src: LPGAMMATABLE): LPGAMMATABLE; EXTERNAL 'lcms.dll';
FUNCTION  cmsEstimateGamma(Src: LPGAMMATABLE): Double; EXTERNAL 'lcms.dll';
FUNCTION  cmsEstimateGammaEx(Src: LPGAMMATABLE; Thereshold: Double): Double; EXTERNAL 'lcms.dll';
FUNCTION  cmsReadICCGamma(hProfile: cmsHPROFILE; Sig: icTagSignature): LPGAMMATABLE; EXTERNAL 'lcms.dll';
FUNCTION  cmsReadICCGammaReversed(hProfile: cmsHPROFILE; Sig: icTagSignature): LPGAMMATABLE; EXTERNAL 'lcms.dll';


FUNCTION  cmsCreateRGBProfile( WhitePoint : LPcmsCIExyY;
                                         Primaries: LPcmsCIExyYTRIPLE;
                                         TransferFunction: ARRAY OF LPGAMMATABLE) : cmsHPROFILE; EXTERNAL 'lcms.dll';

FUNCTION cmsCreateGrayProfile(WhitePoint: LPcmsCIExyY;
                                              TransferFunction: LPGAMMATABLE) : cmsHPROFILE; EXTERNAL 'lcms.dll';

FUNCTION cmsCreateLinearizationDeviceLink(ColorSpace: icColorSpaceSignature; 
                                              TransferFunction: ARRAY OF LPGAMMATABLE) : cmsHPROFILE; EXTERNAL 'lcms.dll';

FUNCTION cmsCreateInkLimitingDeviceLink(ColorSpace: icColorSpaceSignature; 
                                              Limit: Double) : cmsHPROFILE; EXTERNAL 'lcms.dll';


FUNCTION  cmsCreateNULLProfile : cmsHPROFILE; EXTERNAL 'lcms.dll';
FUNCTION  cmsCreateLabProfile(WhitePoint: LPcmsCIExyY): cmsHPROFILE; EXTERNAL 'lcms.dll';
FUNCTION  cmsCreateLab4Profile(WhitePoint: LPcmsCIExyY): cmsHPROFILE; EXTERNAL 'lcms.dll';

FUNCTION  cmsCreateXYZProfile: cmsHPROFILE; EXTERNAL 'lcms.dll';
FUNCTION  cmsCreate_sRGBProfile: cmsHPROFILE; EXTERNAL 'lcms.dll';
FUNCTION  cmsCreateBCHSWabstractProfile(nLUTPoints: Integer;
                                        Bright, Contrast, Hue, Saturation: Double;
                                        TempSrc, TempDest: Integer): cmsHPROFILE; EXTERNAL 'lcms.dll';


FUNCTION  cmsCloseProfile( hProfile : cmsHPROFILE) : Boolean; EXTERNAL 'lcms.dll';


PROCEDURE cmsSetLanguage(LanguageCode: Integer; CountryCode: Integer); EXTERNAL 'lcms.dll';

FUNCTION  cmsTakeMediaWhitePoint(Dest: LPcmsCIEXYZ; hProfile: cmsHPROFILE): Boolean; EXTERNAL 'lcms.dll';
FUNCTION  cmsTakeMediaBlackPoint(Dest: LPcmsCIEXYZ; hProfile: cmsHPROFILE): Boolean; EXTERNAL 'lcms.dll';

FUNCTION  cmsTakeIluminant(Dest: LPcmsCIEXYZ; hProfile: cmsHPROFILE): Boolean; EXTERNAL 'lcms.dll';
FUNCTION  cmsTakeColorants(Dest: LPcmsCIEXYZTRIPLE; hProfile: cmsHPROFILE): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeHeaderFlags(hProfile: cmsHPROFILE): DWord; EXTERNAL 'lcms.dll';

FUNCTION cmsTakeProductName(hProfile: cmsHPROFILE): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeProductDesc(hProfile: cmsHPROFILE): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeManufacturer(hProfile: cmsHPROFILE): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeModel(hProfile: cmsHPROFILE): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeCopyright(hProfile: cmsHPROFILE): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeProfileID(hProfile: cmsHPROFILE): PByte; EXTERNAL 'lcms.dll';


FUNCTION cmsIsTag(hProfile: cmsHPROFILE; sig: icTagSignature): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeRenderingIntent( hProfile: cmsHPROFILE): Integer; EXTERNAL 'lcms.dll';
FUNCTION cmsGetPCS(hProfile: cmsHPROFILE): icColorSpaceSignature; EXTERNAL 'lcms.dll';
FUNCTION cmsGetColorSpace(hProfile: cmsHPROFILE): icColorSpaceSignature; EXTERNAL 'lcms.dll';
FUNCTION cmsGetDeviceClass( hProfile: cmsHPROFILE): icProfileClassSignature; EXTERNAL 'lcms.dll';
FUNCTION cmsGetProfileICCversion( hProfile: cmsHPROFILE): DWord; EXTERNAL 'lcms.dll';
FUNCTION cmsTakeCharTargetData(hProfile: cmsHPROFILE; var Data: PChar; var len: Cardinal): Boolean; EXTERNAL 'lcms.dll';

FUNCTION _cmsICCcolorSpace(OurNotation: Integer) : icColorSpaceSignature; EXTERNAL 'lcms.dll';
FUNCTION _cmsLCMScolorSpace(ProfileSpace: icColorSpaceSignature): Integer; EXTERNAL 'lcms.dll';
FUNCTION _cmsChannelsOf(ColorSpace: icColorSpaceSignature): Integer; EXTERNAL 'lcms.dll';




PROCEDURE cmsSetDeviceClass(hProfile: cmsHPROFILE; sig: icProfileClassSignature ); EXTERNAL 'lcms.dll';
PROCEDURE cmsSetColorSpace(hProfile: cmsHPROFILE; sig: icProfileClassSignature ); EXTERNAL 'lcms.dll';
PROCEDURE cmsSetPCS(hProfile: cmsHPROFILE; pcs: icColorSpaceSignature); EXTERNAL 'lcms.dll';
PROCEDURE cmsSetRenderingIntent(hProfile: cmsHPROFILE; Intent: Integer); EXTERNAL 'lcms.dll';
PROCEDURE cmsSetHeaderFlags(hProfile: cmsHPROFILE; dwFlags: DWord); EXTERNAL 'lcms.dll';
PROCEDURE cmsSetProfileID(hProfile: cmsHPROFILE; ProfileID: PByte); EXTERNAL 'lcms.dll';

FUNCTION  cmsAddTag(hProfile: cmsHPROFILE; Sig: icTagSignature; Data: Pointer): Boolean; EXTERNAL 'lcms.dll';


FUNCTION  _cmsSaveProfile(hProfile: cmsHPROFILE; FileName: PChar): Boolean; EXTERNAL 'lcms.dll';
FUNCTION  _cmsSaveProfileToMem(hProfile: cmsHPROFILE; MemPtr: Pointer; 
                                                    var BytesNeeded: DWord): Boolean; EXTERNAL 'lcms.dll';


FUNCTION  cmsIsIntentSupported(hProfile: cmsHPROFILE; Intent, UsedDirection : Integer): Integer; EXTERNAL 'lcms.dll';

FUNCTION  cmsCreateTransform(Input: cmsHPROFILE;
                            InputFormat: DWORD;
                            Output: cmsHPROFILE;
                            OutputFormat: DWORD;
                            Intent: Integer;
                            dwFlags: DWord): cmsHTRANSFORM; EXTERNAL 'lcms.dll';

FUNCTION  cmsCreateProofingTransform(Input: cmsHPROFILE;
                            InputFormat: DWORD;
                            Output: cmsHPROFILE;
                            OutputFormat: DWORD;
                            Proofing: cmsHPROFILE;
                            Intent: Integer;
                            ProofingIntent: Integer;
                            dwFlags: DWord): cmsHTRANSFORM; EXTERNAL 'lcms.dll';

FUNCTION cmsCreateMultiprofileTransform(hProfiles : ARRAY OF cmsHPROFILE;
                                        nProfiles : Integer;
                                        InputFormat: DWord;
                                        OutputFormat: DWord;
                                        Intent: Integer;
                                        dwFlags: DWord): cmsHTRANSFORM; EXTERNAL 'lcms.dll';


PROCEDURE cmsDeleteTransform( hTransform: cmsHTRANSFORM); EXTERNAL 'lcms.dll';

PROCEDURE cmsDoTransform( Transform: cmsHTRANSFORM;
                          InputBuffer: Pointer;
                          OutputBuffer: Pointer;
                          Size: LongInt); EXTERNAL 'lcms.dll';

PROCEDURE cmsChangeBuffersFormat(hTransform: cmsHTRANSFORM;
                                dwInputFormat, dwOutputFormat: DWord);  EXTERNAL 'lcms.dll';


FUNCTION cmsTransform2DeviceLink(hTransform: cmsHTRANSFORM; dwFlags: DWord): cmsHPROFILE; EXTERNAL 'lcms.dll';

PROCEDURE _cmsSetLUTdepth(hProfile: cmsHPROFILE; depth: Integer);  EXTERNAL 'lcms.dll';

FUNCTION cmsNamedColorCount(xform: cmsHTRANSFORM): Integer; EXTERNAL 'lcms.dll';
FUNCTION cmsNamedColorInfo(xform: cmsHTRANSFORM; nColor: Integer; 
                             Name, Prefix, Suffix: PChar) : Boolean; EXTERNAL 'lcms.dll';

FUNCTION cmsNamedColorIndex(xform: cmsHTRANSFORM; Name: PChar): Integer; EXTERNAL 'lcms.dll';


FUNCTION cmsGetPostScriptCSA(hProfile: cmsHPROFILE ;
                                 Intent: Integer;
                                 Buffer: Pointer;
                                 dwBufferLen: DWord): DWord; EXTERNAL 'lcms.dll';

FUNCTION cmsGetPostScriptCRD(hProfile: cmsHPROFILE ;
                                 Intent: Integer;
                                 Buffer: Pointer;
                                 dwBufferLen: DWord): DWord; EXTERNAL 'lcms.dll';

FUNCTION cmsGetPostScriptCRDEx(hProfile: cmsHPROFILE ;
                                 Intent: Integer;
                                 dwFlags: DWord;
                                 Buffer: Pointer;
                                 dwBufferLen: DWord): DWord; EXTERNAL 'lcms.dll';

FUNCTION    cmsCIECAM97sInit(pVC : LPcmsViewingConditions ) : Pointer; EXTERNAL 'lcms.dll';
PROCEDURE   cmsCIECAM97sDone(hModel : Pointer); EXTERNAL 'lcms.dll';

PROCEDURE   cmsCIECAM97sForward(hModel: Pointer; pIn: LPcmsCIEXYZ; pOut: LPcmsJCh ); EXTERNAL 'lcms.dll';
PROCEDURE   cmsCIECAM97sReverse(hModel: Pointer; pIn: LPcmsJCh;   pOut: LPcmsCIEXYZ ); EXTERNAL 'lcms.dll';

// CIECAM02

FUNCTION    cmsCIECAM02Init(pVC : LPcmsViewingConditions ) : Pointer;  EXTERNAL 'lcms.dll';
PROCEDURE   cmsCIECAM02Done(hModel : Pointer);  EXTERNAL 'lcms.dll';

PROCEDURE   cmsCIECAM02Forward(hModel: Pointer; pIn: LPcmsCIEXYZ; pOut: LPcmsJCh );  EXTERNAL 'lcms.dll';
PROCEDURE   cmsCIECAM02Reverse(hModel: Pointer; pIn: LPcmsJCh;   pOut: LPcmsCIEXYZ );  EXTERNAL 'lcms.dll';

// Utils

PROCEDURE cmsXYZ2xyY(Dest: LPcmsCIExyY; Source: LPcmsCIEXYZ); EXTERNAL 'lcms.dll';
PROCEDURE cmsxyY2XYZ(Dest: LPcmsCIEXYZ; Source: LPcmsCIExyY); EXTERNAL 'lcms.dll';

PROCEDURE cmsXYZ2Lab(WhitePoint: LPcmsCIEXYZ; xyz: LPcmsCIEXYZ; Lab: LPcmsCIELab); EXTERNAL 'lcms.dll';
PROCEDURE cmsLab2XYZ(WhitePoint: LPcmsCIEXYZ; Lab: LPcmsCIELab; xyz: LPcmsCIEXYZ); EXTERNAL 'lcms.dll';
PROCEDURE cmsLab2LCh(LCh: LPcmsCIELCh; Lab: LPcmsCIELab); EXTERNAL 'lcms.dll';
PROCEDURE cmsLCh2Lab(Lab: LPcmsCIELab; LCh: LPcmsCIELCh); EXTERNAL 'lcms.dll';


// CIELab handling

FUNCTION cmsDeltaE(Lab1, Lab2: LPcmsCIELab): Double; EXTERNAL 'lcms.dll';
FUNCTION cmsCIE94DeltaE(Lab1, Lab2: LPcmsCIELab): Double; EXTERNAL 'lcms.dll';
FUNCTION cmsBFDdeltaE(Lab1, Lab2: LPcmsCIELab): Double; EXTERNAL 'lcms.dll';
FUNCTION cmsCMCdeltaE(Lab1, Lab2: LPcmsCIELab): Double; EXTERNAL 'lcms.dll';
FUNCTION cmsCIE2000DeltaE(Lab1, Lab2: LPcmsCIELab; Kl, Kc, Kh: Double): Double; StdCall; EXTERNAL 'lcms.dll';

PROCEDURE cmsClampLab(Lab: LPcmsCIELab; amax, amin,  bmax, bmin: Double); EXTERNAL 'lcms.dll';

PROCEDURE cmsSetAlarmCodes(r, g, b: Integer); EXTERNAL 'lcms.dll';
PROCEDURE cmsGetAlarmCodes(VAR r, g, b: Integer); EXTERNAL 'lcms.dll';

PROCEDURE cmsErrorAction(nAction: Integer); EXTERNAL 'lcms.dll';

PROCEDURE cmsSetErrorHandler(ErrorHandler: cmsErrorHandler); EXTERNAL 'lcms.dll';



FUNCTION  cmsIT8Alloc: LCMSHANDLE; EXTERNAL 'lcms.dll';
PROCEDURE cmsIT8Free(hIT8: LCMSHANDLE); EXTERNAL 'lcms.dll';

// Tables

FUNCTION  cmsIT8TableCount(hIT8: LCMSHANDLE): Integer; EXTERNAL 'lcms.dll';
FUNCTION  cmsIT8SetTable(hIT8: LCMSHANDLE; nTable: Integer): Integer; EXTERNAL 'lcms.dll';

// Persistence
FUNCTION  cmsIT8LoadFromFile(cFileName: PChar): LCMSHANDLE; EXTERNAL 'lcms.dll';
FUNCTION  cmsIT8LoadFromMem(Ptr: Pointer; size :DWord): LCMSHANDLE; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8SaveToFile(hIT8: LCMSHANDLE; cFileName: PChar): Boolean; EXTERNAL 'lcms.dll';

// Properties

FUNCTION cmsIT8GetSheetType(hIT8: LCMSHANDLE): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8SetSheetType(hIT8: LCMSHANDLE; TheType: PChar): Boolean; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8SetComment(hIT8: LCMSHANDLE; cComment: PChar): Boolean; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8SetPropertyStr(hIT8: LCMSHANDLE; cProp, Str: PChar): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8SetPropertyDbl(hIT8: LCMSHANDLE; cProp: PChar; Val: Double): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8SetPropertyHex(hIT8: LCMSHANDLE; cProp: PChar; Val: Integer): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8SetPropertyUncooked(hIT8: LCMSHANDLE; Key, Buffer: PChar): Boolean; EXTERNAL 'lcms.dll';


FUNCTION cmsIT8GetProperty(hIT8: LCMSHANDLE; cProp: PChar): PChar; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8GetPropertyDbl(hIT8: LCMSHANDLE; cProp: PChar): Double; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8EnumProperties(hIT8: LCMSHANDLE; var PropertyNames: LCMSARRAYOFPCHAR): Integer; EXTERNAL 'lcms.dll';

// Datasets

FUNCTION cmsIT8GetDataRowCol(hIT8: LCMSHANDLE; row, col: Integer): PChar; EXTERNAL 'lcms.dll';                                                
FUNCTION cmsIT8GetDataRowColDbl(hIT8: LCMSHANDLE; row, col: Integer): Double; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8SetDataRowCol(hIT8: LCMSHANDLE; row, col: Integer; Val: PChar): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8SetDataRowColDbl(hIT8: LCMSHANDLE; row, col: Integer; Val: Double): Boolean; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8GetData(hIT8: LCMSHANDLE; cPatch, cSample: PChar): PChar; EXTERNAL 'lcms.dll';                                                

FUNCTION cmsIT8GetDataDbl(hIT8: LCMSHANDLE;cPatch, cSample: PChar): Double; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8SetData(hIT8: LCMSHANDLE; cPatch, cSample, Val: PChar): Boolean; EXTERNAL 'lcms.dll';

FUNCTION cmsIT8SetDataDbl(hIT8: LCMSHANDLE; cPatch, cSample: PChar; Val: Double): Boolean; EXTERNAL 'lcms.dll';                                                

FUNCTION cmsIT8SetDataFormat(hIT8: LCMSHANDLE; n: Integer; Sample: PChar): Boolean; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8EnumDataFormat(hIT8: LCMSHANDLE; var SampleNames: LCMSARRAYOFPCHAR): Integer; EXTERNAL 'lcms.dll';
FUNCTION cmsIT8GetPatchName(hIT8: LCMSHANDLE; nPatch: Integer; Buffer: PChar): PChar; EXTERNAL 'lcms.dll';

// The LABEL extension

FUNCTION cmsIT8SetTableByLabel(hIT8: LCMSHANDLE; cSet, cField, ExpectedType: PChar): Integer; EXTERNAL 'lcms.dll';




PROCEDURE cmsLabEncoded2Float(Lab: LPcmsCIELab; wLab: Pointer); EXTERNAL 'lcms.dll';
PROCEDURE cmsFloat2LabEncoded(wLab: Pointer; Lab: LPcmsCIELab); EXTERNAL 'lcms.dll';
PROCEDURE cmsXYZEncoded2Float(fxyz : LPcmsCIEXYZ; XYZ: Pointer); EXTERNAL 'lcms.dll';
PROCEDURE cmsFloat2XYZEncoded(XYZ: Pointer; fXYZ: LPcmsCIEXYZ); EXTERNAL 'lcms.dll';

FUNCTION _cmsAddTextTag(hProfile: cmsHPROFILE; sig: icTagSignature; Text: PChar): Boolean; EXTERNAL 'lcms.dll';
FUNCTION _cmsAddXYZTag(hProfile: cmsHPROFILE;  sig: icTagSignature;  XYZ: LPcmsCIEXYZ): Boolean; EXTERNAL 'lcms.dll';
FUNCTION _cmsAddLUTTag(hProfile: cmsHPROFILE;  sig: icTagSignature; lut: PByte): Boolean; EXTERNAL 'lcms.dll';



END.