/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

// This file is available under and governed by the GNU General Public

// License version 2 only, as published by the Free Software Foundation.

// However, the following notice accompanied the original version of this

// file:

//

//---------------------------------------------------------------------------------

//

//  Little Color Management System

//  Copyright (c) 1998-2016 Marti Maria Saguer

//

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

//

//---------------------------------------------------------------------------------

//

// This is the plug-in header file. Normal LittleCMS clients should not use it.

// It is provided for plug-in writters that may want to access the support

// functions to do low level operations. All plug-in related structures

// are defined here. Including this file forces to include the standard API too.

#ifndef _lcms_plugin_H

// Deal with Microsoft's attempt at deprecating C standard runtime functions

#ifdef _MSC_VER

#    if (_MSC_VER >= 1400)

#      ifndef _CRT_SECURE_NO_DEPRECATE

#        define _CRT_SECURE_NO_DEPRECATE

#      endif

#      ifndef _CRT_SECURE_NO_WARNINGS

#        define _CRT_SECURE_NO_WARNINGS

#      endif

#    endif

#endif

#ifndef _lcms2_H

#include "lcms2.h"

#endif

// We need some standard C functions.

#include <stdlib.h>

#include <math.h>

#include <stdarg.h>

#include <memory.h>

#include <string.h>

#ifndef CMS_USE_CPP_API

#   ifdef __cplusplus

extern "C" {

#   endif

#endif

// Vector & Matrix operations -----------------------------------------------------------------------

// Axis of the matrix/array. No specific meaning at all.

#define VX      0

#define VY      1

#define VZ      2

// Vectors

typedef struct {

    cmsFloat64Number n[3];

    } cmsVEC3;

// 3x3 Matrix

typedef struct {

    cmsVEC3 v[3];

    } cmsMAT3;

CMSAPI void               CMSEXPORT _cmsVEC3init(cmsVEC3* r, cmsFloat64Number x, cmsFloat64Number y, cmsFloat64Number z);

CMSAPI void               CMSEXPORT _cmsVEC3minus(cmsVEC3* r, const cmsVEC3* a, const cmsVEC3* b);

CMSAPI void               CMSEXPORT _cmsVEC3cross(cmsVEC3* r, const cmsVEC3* u, const cmsVEC3* v);

CMSAPI cmsFloat64Number   CMSEXPORT _cmsVEC3dot(const cmsVEC3* u, const cmsVEC3* v);

CMSAPI cmsFloat64Number   CMSEXPORT _cmsVEC3length(const cmsVEC3* a);

CMSAPI cmsFloat64Number   CMSEXPORT _cmsVEC3distance(const cmsVEC3* a, const cmsVEC3* b);

CMSAPI void               CMSEXPORT _cmsMAT3identity(cmsMAT3* a);

CMSAPI cmsBool            CMSEXPORT _cmsMAT3isIdentity(const cmsMAT3* a);

CMSAPI void               CMSEXPORT _cmsMAT3per(cmsMAT3* r, const cmsMAT3* a, const cmsMAT3* b);

CMSAPI cmsBool            CMSEXPORT _cmsMAT3inverse(const cmsMAT3* a, cmsMAT3* b);

CMSAPI cmsBool            CMSEXPORT _cmsMAT3solve(cmsVEC3* x, cmsMAT3* a, cmsVEC3* b);

CMSAPI void               CMSEXPORT _cmsMAT3eval(cmsVEC3* r, const cmsMAT3* a, const cmsVEC3* v);

// Error logging  -------------------------------------------------------------------------------------

CMSAPI void               CMSEXPORT  cmsSignalError(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *ErrorText, ...);

// Memory management ----------------------------------------------------------------------------------

CMSAPI void*              CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size);

CMSAPI void*              CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size);

CMSAPI void*              CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size);

CMSAPI void*              CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number NewSize);

CMSAPI void               CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr);

CMSAPI void*              CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size);

// I/O handler ----------------------------------------------------------------------------------

struct _cms_io_handler {

    void* stream;   // Associated stream, which is implemented differently depending on media.

    cmsContext        ContextID;

    cmsUInt32Number   UsedSpace;

    cmsUInt32Number   ReportedSize;

    char              PhysicalFile[cmsMAX_PATH];

    cmsUInt32Number   (* Read)(struct _cms_io_handler* iohandler, void *Buffer,

                                                                  cmsUInt32Number size,

                                                                  cmsUInt32Number count);

    cmsBool           (* Seek)(struct _cms_io_handler* iohandler, cmsUInt32Number offset);

    cmsBool           (* Close)(struct _cms_io_handler* iohandler);

    cmsUInt32Number   (* Tell)(struct _cms_io_handler* iohandler);

    cmsBool           (* Write)(struct _cms_io_handler* iohandler, cmsUInt32Number size,

                                                                   const void* Buffer);

};

// Endianness adjust functions

CMSAPI cmsUInt16Number   CMSEXPORT  _cmsAdjustEndianess16(cmsUInt16Number Word);

CMSAPI cmsUInt32Number   CMSEXPORT  _cmsAdjustEndianess32(cmsUInt32Number Value);

CMSAPI void              CMSEXPORT  _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number* QWord);

// Helper IO functions

CMSAPI cmsBool           CMSEXPORT  _cmsReadUInt8Number(cmsIOHANDLER* io,  cmsUInt8Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsReadUInt16Number(cmsIOHANDLER* io, cmsUInt16Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsReadUInt32Number(cmsIOHANDLER* io, cmsUInt32Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsReadFloat32Number(cmsIOHANDLER* io, cmsFloat32Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsReadUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsRead15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsReadXYZNumber(cmsIOHANDLER* io, cmsCIEXYZ* XYZ);

CMSAPI cmsBool           CMSEXPORT  _cmsReadUInt16Array(cmsIOHANDLER* io, cmsUInt32Number n, cmsUInt16Number* Array);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteUInt8Number(cmsIOHANDLER* io, cmsUInt8Number n);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteUInt16Number(cmsIOHANDLER* io, cmsUInt16Number n);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteUInt32Number(cmsIOHANDLER* io, cmsUInt32Number n);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteFloat32Number(cmsIOHANDLER* io, cmsFloat32Number n);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n);

CMSAPI cmsBool           CMSEXPORT  _cmsWrite15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number n);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ);

CMSAPI cmsBool           CMSEXPORT  _cmsWriteUInt16Array(cmsIOHANDLER* io, cmsUInt32Number n, const cmsUInt16Number* Array);

// ICC base tag

typedef struct {

    cmsTagTypeSignature  sig;

    cmsInt8Number        reserved[4];

} _cmsTagBase;

// Type base helper functions

CMSAPI cmsTagTypeSignature  CMSEXPORT _cmsReadTypeBase(cmsIOHANDLER* io);

CMSAPI cmsBool              CMSEXPORT _cmsWriteTypeBase(cmsIOHANDLER* io, cmsTagTypeSignature sig);

// Alignment functions

CMSAPI cmsBool             CMSEXPORT _cmsReadAlignment(cmsIOHANDLER* io);

CMSAPI cmsBool             CMSEXPORT _cmsWriteAlignment(cmsIOHANDLER* io);

// To deal with text streams. 2K at most

CMSAPI cmsBool             CMSEXPORT _cmsIOPrintf(cmsIOHANDLER* io, const char* frm, ...);

// Fixed point helper functions

CMSAPI cmsFloat64Number    CMSEXPORT _cms8Fixed8toDouble(cmsUInt16Number fixed8);

CMSAPI cmsUInt16Number     CMSEXPORT _cmsDoubleTo8Fixed8(cmsFloat64Number val);

CMSAPI cmsFloat64Number    CMSEXPORT _cms15Fixed16toDouble(cmsS15Fixed16Number fix32);

CMSAPI cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsFloat64Number v);

// Date/time helper functions

CMSAPI void                CMSEXPORT _cmsEncodeDateTimeNumber(cmsDateTimeNumber *Dest, const struct tm *Source);

CMSAPI void                CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeNumber *Source, struct tm *Dest);

//----------------------------------------------------------------------------------------------------------

// Shared callbacks for user data

typedef void     (* _cmsFreeUserDataFn)(cmsContext ContextID, void* Data);

typedef void*    (* _cmsDupUserDataFn)(cmsContext ContextID, const void* Data);

//----------------------------------------------------------------------------------------------------------

// Plug-in foundation

#define cmsPluginMagicNumber                 0x61637070     // 'acpp'

#define cmsPluginMemHandlerSig               0x6D656D48     // 'memH'

#define cmsPluginInterpolationSig            0x696E7048     // 'inpH'

#define cmsPluginParametricCurveSig          0x70617248     // 'parH'

#define cmsPluginFormattersSig               0x66726D48     // 'frmH

#define cmsPluginTagTypeSig                  0x74797048     // 'typH'

#define cmsPluginTagSig                      0x74616748     // 'tagH'

#define cmsPluginRenderingIntentSig          0x696E7448     // 'intH'

#define cmsPluginMultiProcessElementSig      0x6D706548     // 'mpeH'

#define cmsPluginOptimizationSig             0x6F707448     // 'optH'

#define cmsPluginTransformSig                0x7A666D48     // 'xfmH'

#define cmsPluginMutexSig                    0x6D747A48     // 'mtxH'

typedef struct _cmsPluginBaseStruct {

        cmsUInt32Number                Magic;               // 'acpp' signature

        cmsUInt32Number                ExpectedVersion;     // Expected version of LittleCMS

        cmsUInt32Number                Type;                // Type of plug-in

        struct _cmsPluginBaseStruct*   Next;                // For multiple plugin definition. NULL for end of list.

} cmsPluginBase;

// Maximum number of types in a plugin array

#define MAX_TYPES_IN_LCMS_PLUGIN    20

//----------------------------------------------------------------------------------------------------------

// Memory handler. Each new plug-in type replaces current behaviour

typedef void* (* _cmsMallocFnPtrType)(cmsContext ContextID, cmsUInt32Number size);

typedef void  (* _cmsFreeFnPtrType)(cmsContext ContextID, void *Ptr);

typedef void* (* _cmsReallocFnPtrType)(cmsContext ContextID, void* Ptr, cmsUInt32Number NewSize);

typedef void* (* _cmsMalloZerocFnPtrType)(cmsContext ContextID, cmsUInt32Number size);

typedef void* (* _cmsCallocFnPtrType)(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size);

typedef void* (* _cmsDupFnPtrType)(cmsContext ContextID, const void* Org, cmsUInt32Number size);

typedef struct {

        cmsPluginBase base;

        // Required

        _cmsMallocFnPtrType  MallocPtr;

        _cmsFreeFnPtrType    FreePtr;

        _cmsReallocFnPtrType ReallocPtr;

        // Optional

       _cmsMalloZerocFnPtrType MallocZeroPtr;

       _cmsCallocFnPtrType     CallocPtr;

       _cmsDupFnPtrType        DupPtr;

} cmsPluginMemHandler;

// ------------------------------------------------------------------------------------------------------------------

// Interpolation. 16 bits and floating point versions.

struct _cms_interp_struc;

// Interpolation callbacks

// 16 bits forward interpolation. This function performs precision-limited linear interpolation

// and is supposed to be quite fast. Implementation may be tetrahedral or trilinear, and plug-ins may

// choose to implement any other interpolation algorithm.

typedef void (* _cmsInterpFn16)(register const cmsUInt16Number Input[],

                                register cmsUInt16Number Output[],

                                register const struct _cms_interp_struc* p);

// Floating point forward interpolation. Full precision interpolation using floats. This is not a

// time critical function. Implementation may be tetrahedral or trilinear, and plug-ins may

// choose to implement any other interpolation algorithm.

typedef void (* _cmsInterpFnFloat)(cmsFloat32Number const Input[],

                                   cmsFloat32Number Output[],

                                   const struct _cms_interp_struc* p);

// This type holds a pointer to an interpolator that can be either 16 bits or float

typedef union {

    _cmsInterpFn16       Lerp16;            // Forward interpolation in 16 bits

    _cmsInterpFnFloat    LerpFloat;         // Forward interpolation in floating point

} cmsInterpFunction;

// Flags for interpolator selection

#define CMS_LERP_FLAGS_16BITS             0x0000        // The default

#define CMS_LERP_FLAGS_FLOAT              0x0001        // Requires different implementation

#define CMS_LERP_FLAGS_TRILINEAR          0x0100        // Hint only

#define MAX_INPUT_DIMENSIONS 8

typedef struct _cms_interp_struc {  // Used on all interpolations. Supplied by lcms2 when calling the interpolation function

    cmsContext ContextID;     // The calling thread

    cmsUInt32Number dwFlags;  // Keep original flags

    cmsUInt32Number nInputs;  // != 1 only in 3D interpolation

    cmsUInt32Number nOutputs; // != 1 only in 3D interpolation

    cmsUInt32Number nSamples[MAX_INPUT_DIMENSIONS];  // Valid on all kinds of tables

    cmsUInt32Number Domain[MAX_INPUT_DIMENSIONS];    // Domain = nSamples - 1

    cmsUInt32Number opta[MAX_INPUT_DIMENSIONS];     // Optimization for 3D CLUT. This is the number of nodes premultiplied for each

                                                    // dimension. For example, in 7 nodes, 7, 7^2 , 7^3, 7^4, etc. On non-regular

                                                    // Samplings may vary according of the number of nodes for each dimension.

    const void *Table;                // Points to the actual interpolation table

    cmsInterpFunction Interpolation;  // Points to the function to do the interpolation

 } cmsInterpParams;

// Interpolators factory

typedef cmsInterpFunction (* cmsInterpFnFactory)(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags);

// The plug-in

typedef struct {

    cmsPluginBase base;

    // Points to a user-supplied function which implements the factory

    cmsInterpFnFactory InterpolatorsFactory;

} cmsPluginInterpolation;

//----------------------------------------------------------------------------------------------------------

// Parametric curves. A negative type means same function but analytically inverted. Max. number of params is 10

// Evaluator callback for user-suplied parametric curves. May implement more than one type

typedef  cmsFloat64Number (* cmsParametricCurveEvaluator)(cmsInt32Number Type, const cmsFloat64Number Params[10], cmsFloat64Number R);

// Plug-in may implement an arbitrary number of parametric curves

typedef struct {

    cmsPluginBase base;

    cmsUInt32Number nFunctions;                                     // Number of supported functions

    cmsUInt32Number FunctionTypes[MAX_TYPES_IN_LCMS_PLUGIN];        // The identification types

    cmsUInt32Number ParameterCount[MAX_TYPES_IN_LCMS_PLUGIN];       // Number of parameters for each function

    cmsParametricCurveEvaluator    Evaluator;                       // The evaluator

} cmsPluginParametricCurves;

//----------------------------------------------------------------------------------------------------------

// Formatters. This plug-in adds new handlers, replacing them if they already exist. Formatters dealing with

// cmsFloat32Number (bps = 4) or double (bps = 0) types are requested via FormatterFloat callback. Others come across

// Formatter16 callback

struct _cmstransform_struct;

typedef cmsUInt8Number* (* cmsFormatter16)(register struct _cmstransform_struct* CMMcargo,

                                           register cmsUInt16Number Values[],

                                           register cmsUInt8Number* Buffer,

                                           register cmsUInt32Number Stride);

typedef cmsUInt8Number* (* cmsFormatterFloat)(struct _cmstransform_struct* CMMcargo,

                                              cmsFloat32Number Values[],

                                              cmsUInt8Number*  Buffer,

                                              cmsUInt32Number  Stride);

// This type holds a pointer to a formatter that can be either 16 bits or cmsFloat32Number

typedef union {

    cmsFormatter16    Fmt16;

    cmsFormatterFloat FmtFloat;

} cmsFormatter;

#define CMS_PACK_FLAGS_16BITS       0x0000

#define CMS_PACK_FLAGS_FLOAT        0x0001

typedef enum { cmsFormatterInput=0, cmsFormatterOutput=1 } cmsFormatterDirection;

typedef cmsFormatter (* cmsFormatterFactory)(cmsUInt32Number Type,           // Specific type, i.e. TYPE_RGB_8

                                             cmsFormatterDirection Dir,

                                             cmsUInt32Number dwFlags);      // precision

// Plug-in may implement an arbitrary number of formatters

typedef struct {

    cmsPluginBase          base;

    cmsFormatterFactory    FormattersFactory;

} cmsPluginFormatters;

//----------------------------------------------------------------------------------------------------------

// Tag type handler. Each type is free to return anything it wants, and it is up to the caller to

// know in advance what is the type contained in the tag.

typedef struct _cms_typehandler_struct {

        cmsTagTypeSignature Signature;     // The signature of the type

        // Allocates and reads items

        void *   (* ReadPtr)(struct _cms_typehandler_struct* self,

                             cmsIOHANDLER*      io,

                             cmsUInt32Number*   nItems,

                             cmsUInt32Number    SizeOfTag);

        // Writes n Items

        cmsBool  (* WritePtr)(struct _cms_typehandler_struct* self,

                              cmsIOHANDLER*     io,

                              void*             Ptr,

                              cmsUInt32Number   nItems);

        // Duplicate an item or array of items

        void*   (* DupPtr)(struct _cms_typehandler_struct* self,

                           const void *Ptr,

                           cmsUInt32Number n);

        // Free all resources

        void    (* FreePtr)(struct _cms_typehandler_struct* self,

                            void *Ptr);

        // Additional parameters used by the calling thread

        cmsContext       ContextID;

        cmsUInt32Number  ICCVersion;

} cmsTagTypeHandler;

// Each plug-in implements a single type

typedef struct {

        cmsPluginBase      base;

        cmsTagTypeHandler  Handler;

} cmsPluginTagType;

//----------------------------------------------------------------------------------------------------------

// This is the tag plugin, which identifies tags. For writing, a pointer to function is provided.

// This function should return the desired type for this tag, given the version of profile

// and the data being serialized.

typedef struct {

    cmsUInt32Number     ElemCount;          // If this tag needs an array, how many elements should keep

    // For reading.

    cmsUInt32Number     nSupportedTypes;    // In how many types this tag can come (MAX_TYPES_IN_LCMS_PLUGIN maximum)

    cmsTagTypeSignature SupportedTypes[MAX_TYPES_IN_LCMS_PLUGIN];

    // For writting

    cmsTagTypeSignature (* DecideType)(cmsFloat64Number ICCVersion, const void *Data);

} cmsTagDescriptor;

// Plug-in implements a single tag

typedef struct {

    cmsPluginBase    base;

    cmsTagSignature  Signature;

    cmsTagDescriptor Descriptor;

} cmsPluginTag;

//----------------------------------------------------------------------------------------------------------

// Custom intents. This function should join all profiles specified in the array in

// a single LUT. Any custom intent in the chain redirects to custom function. If more than

// one custom intent is found, the one located first is invoked. Usually users should use only one

// custom intent, so mixing custom intents in same multiprofile transform is not supported.

typedef cmsPipeline* (* cmsIntentFn)( cmsContext       ContextID,

                                      cmsUInt32Number  nProfiles,

                                      cmsUInt32Number  Intents[],

                                      cmsHPROFILE      hProfiles[],

                                      cmsBool          BPC[],

                                      cmsFloat64Number AdaptationStates[],

                                      cmsUInt32Number  dwFlags);

// Each plug-in defines a single intent number.

typedef struct {

    cmsPluginBase     base;

    cmsUInt32Number   Intent;

    cmsIntentFn       Link;

    char              Description[256];

} cmsPluginRenderingIntent;

// The default ICC intents (perceptual, saturation, rel.col and abs.col)

CMSAPI cmsPipeline*  CMSEXPORT _cmsDefaultICCintents(cmsContext       ContextID,

                                                     cmsUInt32Number  nProfiles,

                                                     cmsUInt32Number  Intents[],

                                                     cmsHPROFILE      hProfiles[],

                                                     cmsBool          BPC[],

                                                     cmsFloat64Number AdaptationStates[],

                                                     cmsUInt32Number  dwFlags);

//----------------------------------------------------------------------------------------------------------

// Pipelines, Multi Process Elements.

typedef void (* _cmsStageEvalFn)     (const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage* mpe);

typedef void*(* _cmsStageDupElemFn)  (cmsStage* mpe);

typedef void (* _cmsStageFreeElemFn) (cmsStage* mpe);

// This function allocates a generic MPE

CMSAPI cmsStage* CMSEXPORT _cmsStageAllocPlaceholder(cmsContext ContextID,

                                cmsStageSignature     Type,

                                cmsUInt32Number       InputChannels,

                                cmsUInt32Number       OutputChannels,

                                _cmsStageEvalFn       EvalPtr,            // Points to fn that evaluates the element (always in floating point)

                                _cmsStageDupElemFn    DupElemPtr,         // Points to a fn that duplicates the stage