//--------------------------------------------------------------------------------- // // Little Color Management System // Copyright (c) 1998-2017 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 _lcms2mt_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 _lcms2mt_H #include "lcms2mt.h" #endif // We need some standard C functions. #include #include #include #include #include #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(cmsContext ContextID, cmsVEC3* r, cmsFloat64Number x, cmsFloat64Number y, cmsFloat64Number z); CMSAPI void CMSEXPORT _cmsVEC3minus(cmsContext ContextID, cmsVEC3* r, const cmsVEC3* a, const cmsVEC3* b); CMSAPI void CMSEXPORT _cmsVEC3cross(cmsContext ContextID, cmsVEC3* r, const cmsVEC3* u, const cmsVEC3* v); CMSAPI cmsFloat64Number CMSEXPORT _cmsVEC3dot(cmsContext ContextID, const cmsVEC3* u, const cmsVEC3* v); CMSAPI cmsFloat64Number CMSEXPORT _cmsVEC3length(cmsContext ContextID, const cmsVEC3* a); CMSAPI cmsFloat64Number CMSEXPORT _cmsVEC3distance(cmsContext ContextID, const cmsVEC3* a, const cmsVEC3* b); CMSAPI void CMSEXPORT _cmsMAT3identity(cmsContext ContextID, cmsMAT3* a); CMSAPI cmsBool CMSEXPORT _cmsMAT3isIdentity(cmsContext ContextID, const cmsMAT3* a); CMSAPI void CMSEXPORT _cmsMAT3per(cmsContext ContextID, cmsMAT3* r, const cmsMAT3* a, const cmsMAT3* b); CMSAPI cmsBool CMSEXPORT _cmsMAT3inverse(cmsContext ContextID, const cmsMAT3* a, cmsMAT3* b); CMSAPI cmsBool CMSEXPORT _cmsMAT3solve(cmsContext ContextID, cmsVEC3* x, cmsMAT3* a, cmsVEC3* b); CMSAPI void CMSEXPORT _cmsMAT3eval(cmsContext ContextID, 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. cmsUInt32Number UsedSpace; cmsUInt32Number ReportedSize; char PhysicalFile[cmsMAX_PATH]; cmsUInt32Number (* Read)(cmsContext ContextID, struct _cms_io_handler* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count); cmsBool (* Seek)(cmsContext ContextID, struct _cms_io_handler* iohandler, cmsUInt32Number offset); cmsBool (* Close)(cmsContext ContextID, struct _cms_io_handler* iohandler); cmsUInt32Number (* Tell)(cmsContext ContextID, struct _cms_io_handler* iohandler); cmsBool (* Write)(cmsContext ContextID, 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(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt8Number* n); CMSAPI cmsBool CMSEXPORT _cmsReadUInt16Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt16Number* n); CMSAPI cmsBool CMSEXPORT _cmsReadUInt32Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt32Number* n); CMSAPI cmsBool CMSEXPORT _cmsReadFloat32Number(cmsContext ContextID, cmsIOHANDLER* io, cmsFloat32Number* n); CMSAPI cmsBool CMSEXPORT _cmsReadUInt64Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt64Number* n); CMSAPI cmsBool CMSEXPORT _cmsRead15Fixed16Number(cmsContext ContextID, cmsIOHANDLER* io, cmsFloat64Number* n); CMSAPI cmsBool CMSEXPORT _cmsReadXYZNumber(cmsContext ContextID, cmsIOHANDLER* io, cmsCIEXYZ* XYZ); CMSAPI cmsBool CMSEXPORT _cmsReadUInt16Array(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt32Number n, cmsUInt16Number* Array); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt8Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt8Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt16Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt16Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt32Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt32Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteFloat32Number(cmsContext ContextID, cmsIOHANDLER* io, cmsFloat32Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt64Number(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt64Number* n); CMSAPI cmsBool CMSEXPORT _cmsWrite15Fixed16Number(cmsContext ContextID, cmsIOHANDLER* io, cmsFloat64Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsContext ContextID, cmsIOHANDLER* io, const cmsCIEXYZ* XYZ); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt16Array(cmsContext ContextID, 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(cmsContext ContextID, cmsIOHANDLER* io); CMSAPI cmsBool CMSEXPORT _cmsWriteTypeBase(cmsContext ContextID, cmsIOHANDLER* io, cmsTagTypeSignature sig); // Alignment functions CMSAPI cmsBool CMSEXPORT _cmsReadAlignment(cmsContext ContextID, cmsIOHANDLER* io); CMSAPI cmsBool CMSEXPORT _cmsWriteAlignment(cmsContext ContextID, cmsIOHANDLER* io); // To deal with text streams. 2K at most CMSAPI cmsBool CMSEXPORT _cmsIOPrintf(cmsContext ContextID, cmsIOHANDLER* io, const char* frm, ...); // Fixed point helper functions CMSAPI cmsFloat64Number CMSEXPORT _cms8Fixed8toDouble(cmsContext ContextID, cmsUInt16Number fixed8); CMSAPI cmsUInt16Number CMSEXPORT _cmsDoubleTo8Fixed8(cmsContext ContextID, cmsFloat64Number val); CMSAPI cmsFloat64Number CMSEXPORT _cms15Fixed16toDouble(cmsContext ContextID, cmsS15Fixed16Number fix32); CMSAPI cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsContext ContextID, cmsFloat64Number v); // Date/time helper functions CMSAPI void CMSEXPORT _cmsEncodeDateTimeNumber(cmsContext ContextID, cmsDateTimeNumber *Dest, const struct tm *Source); CMSAPI void CMSEXPORT _cmsDecodeDateTimeNumber(cmsContext ContextID, 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)(cmsContext ContextID, 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)(cmsContext ContextID, 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 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)(cmsContext ContextID, 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-supplied parametric curves. May implement more than one type typedef cmsFloat64Number (* cmsParametricCurveEvaluator)(cmsContext ContextID, 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)(cmsContext ContextID, register struct _cmstransform_struct* CMMcargo, register cmsUInt16Number Values[], register cmsUInt8Number* Buffer, register cmsUInt32Number Stride); typedef cmsUInt8Number* (* cmsFormatterFloat)(cmsContext ContextID, 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)(cmsContext ContextID, 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)(cmsContext ContextID, struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag); // Writes n Items cmsBool (* WritePtr)(cmsContext ContextID, struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems); // Duplicate an item or array of items void* (* DupPtr)(cmsContext ContextID, struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n); // Free all resources void (* FreePtr)(cmsContext ContextID, struct _cms_typehandler_struct* self, void *Ptr); // Additional parameters used by the calling thread 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 writing cmsTagTypeSignature (* DecideType)(cmsContext ContextID, 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) (cmsContext ContextID, const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage* mpe); typedef void*(* _cmsStageDupElemFn) (cmsContext ContextID, cmsStage* mpe); typedef void (* _cmsStageFreeElemFn) (cmsContext ContextID, 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 _cmsStageFreeElemFn FreePtr, // Points to a fn that sets the element free void* Data); // A generic pointer to whatever memory needed by the element typedef struct { cmsPluginBase base; cmsTagTypeHandler Handler; } cmsPluginMultiProcessElement; // Data kept in "Element" member of cmsStage // Curves typedef struct { cmsUInt32Number nCurves; cmsToneCurve** TheCurves; } _cmsStageToneCurvesData; // Matrix typedef struct { cmsFloat64Number* Double; // floating point for the matrix cmsFloat64Number* Offset; // The offset } _cmsStageMatrixData; // CLUT typedef struct { union { // Can have only one of both representations at same time cmsUInt16Number* T; // Points to the table 16 bits table cmsFloat32Number* TFloat; // Points to the cmsFloat32Number table } Tab; cmsInterpParams* Params; cmsUInt32Number nEntries; cmsBool HasFloatValues; } _cmsStageCLutData; //---------------------------------------------------------------------------------------------------------- // Optimization. Using this plug-in, additional optimization strategies may be implemented. // The function should return TRUE if any optimization is done on the LUT, this terminates // the optimization search. Or FALSE if it is unable to optimize and want to give a chance // to the rest of optimizers. typedef void (* _cmsOPTeval16Fn)(cmsContext ContextID, register const cmsUInt16Number In[], register cmsUInt16Number Out[], register const void* Data); typedef cmsBool (* _cmsOPToptimizeFn)(cmsContext ContextID, cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags); // This function may be used to set the optional evaluator and a block of private data. If private data is being used, an optional // duplicator and free functions should also be specified in order to duplicate the LUT construct. Use NULL to inhibit such functionality. CMSAPI void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsContext ContextID, cmsPipeline* Lut, _cmsOPTeval16Fn Eval16, void* PrivateData, _cmsFreeUserDataFn FreePrivateDataFn, _cmsDupUserDataFn DupPrivateDataFn); typedef struct { cmsPluginBase base; // Optimize entry point _cmsOPToptimizeFn OptimizePtr; } cmsPluginOptimization; //---------------------------------------------------------------------------------------------------------- // Full xform typedef struct { cmsUInt32Number BytesPerLineIn; cmsUInt32Number BytesPerLineOut; cmsUInt32Number BytesPerPlaneIn; cmsUInt32Number BytesPerPlaneOut; } cmsStride; typedef void (* _cmsTransformFn)(cmsContext ContextID, struct _cmstransform_struct *CMMcargo, // Legacy function, handles just ONE scanline. const void* InputBuffer, void* OutputBuffer, cmsUInt32Number Size, cmsUInt32Number Stride); // Stride in bytes to the next plana in planar formats typedef void (*_cmsTransform2Fn)(cmsContext ContextID, struct _cmstransform_struct *CMMcargo, const void* InputBuffer, void* OutputBuffer, cmsUInt32Number PixelsPerLine, cmsUInt32Number LineCount, const cmsStride* Stride); typedef cmsBool (* _cmsTransformFactory)(cmsContext ContextID, _cmsTransformFn* xform, void** UserData, _cmsFreeUserDataFn* FreePrivateDataFn, cmsPipeline** Lut, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags); typedef cmsBool (* _cmsTransform2Factory)(cmsContext ContextID, _cmsTransform2Fn* xform, void** UserData, _cmsFreeUserDataFn* FreePrivateDataFn, cmsPipeline** Lut, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags); // Retrieve user data as specified by the factory CMSAPI void CMSEXPORT _cmsSetTransformUserData(struct _cmstransform_struct *CMMcargo, void* ptr, _cmsFreeUserDataFn FreePrivateDataFn); CMSAPI void * CMSEXPORT _cmsGetTransformUserData(struct _cmstransform_struct *CMMcargo); // Retrieve formatters CMSAPI void CMSEXPORT _cmsGetTransformFormatters16 (struct _cmstransform_struct *CMMcargo, cmsFormatter16* FromInput, cmsFormatter16* ToOutput); CMSAPI void CMSEXPORT _cmsGetTransformFormattersFloat(struct _cmstransform_struct *CMMcargo, cmsFormatterFloat* FromInput, cmsFormatterFloat* ToOutput); typedef struct { cmsPluginBase base; // Transform entry point union { _cmsTransformFactory legacy_xform; _cmsTransform2Factory xform; } factories; } cmsPluginTransform; //---------------------------------------------------------------------------------------------------------- // Mutex typedef void* (* _cmsCreateMutexFnPtrType)(cmsContext ContextID); typedef void (* _cmsDestroyMutexFnPtrType)(cmsContext ContextID, void* mtx); typedef cmsBool (* _cmsLockMutexFnPtrType)(cmsContext ContextID, void* mtx); typedef void (* _cmsUnlockMutexFnPtrType)(cmsContext ContextID, void* mtx); typedef struct { cmsPluginBase base; _cmsCreateMutexFnPtrType CreateMutexPtr; _cmsDestroyMutexFnPtrType DestroyMutexPtr; _cmsLockMutexFnPtrType LockMutexPtr; _cmsUnlockMutexFnPtrType UnlockMutexPtr; } cmsPluginMutex; CMSAPI void* CMSEXPORT _cmsCreateMutex(cmsContext ContextID); CMSAPI void CMSEXPORT _cmsDestroyMutex(cmsContext ContextID, void* mtx); CMSAPI cmsBool CMSEXPORT _cmsLockMutex(cmsContext ContextID, void* mtx); CMSAPI void CMSEXPORT _cmsUnlockMutex(cmsContext ContextID, void* mtx); #ifndef CMS_USE_CPP_API # ifdef __cplusplus } # endif #endif #define _lcms2mt_plugin_H #endif