//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2014 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"),
//
//---------------------------------------------------------------------------------
//
-// Version 2.1
+// Version 2.6
//
#ifndef _lcms2_H
// Uncomment this if your compiler doesn't work with fast floor function
// #define CMS_DONT_USE_FAST_FLOOR 1
-// Uncomment this line if your system does not support multithreading
-#define CMS_DONT_USE_PTHREADS 1
-
// Uncomment this line if you want lcms to use the black point tag in profile,
// if commented, lcms will compute the black point by its own.
// It is safer to leave it commented out
// require "KEYWORD" on undefined identifiers, keep it comented out unless needed
// #define CMS_STRICT_CGATS 1
+// Uncomment to get rid of the tables for "half" float support
+// #define CMS_NO_HALF_SUPPORT 1
+
+// Uncomment to get rid of pthreads/windows dependency
+// #define CMS_NO_PTHREADS 1
+
// ********** End of configuration toggles ******************************
// Needed for streams
#endif
// Version/release
-#define LCMS_VERSION 2010
+#define LCMS_VERSION 2060
// I will give the chance of redefining basic types for compilers that are not fully C99 compliant
#ifndef CMS_BASIC_TYPES_ALREADY_DEFINED
typedef unsigned char cmsUInt8Number; // That is guaranteed by the C99 spec
typedef signed char cmsInt8Number; // That is guaranteed by the C99 spec
+#if CHAR_BIT != 8
+# error "Unable to find 8 bit type, unsupported compiler"
+#endif
+
// IEEE float storage numbers
typedef float cmsFloat32Number;
typedef double cmsFloat64Number;
// Try to detect big endian platforms. This list can be endless, so only some checks are performed over here.
// you can pass this toggle to the compiler by using -DCMS_USE_BIG_ENDIAN or something similar
-#if defined(_HOST_BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(WORDS_BIGENDIAN)
+#if defined(__sgi__) || defined(__sgi) || defined(sparc)
# define CMS_USE_BIG_ENDIAN 1
#endif
-#if defined(__sgi__) || defined(__sgi) || defined(__powerpc__) || defined(sparc)
-# define CMS_USE_BIG_ENDIAN 1
+#if defined(__s390__) || defined(__s390x__)
+# define CMS_USE_BIG_ENDIAN 1
#endif
-#if defined(__ppc__) || defined(__s390__) || defined(__s390x__)
+# ifdef TARGET_CPU_PPC
+# if TARGET_CPU_PPC
+# define CMS_USE_BIG_ENDIAN 1
+# endif
+# endif
+
+#if defined(__powerpc__) || defined(__ppc__) || defined(TARGET_CPU_PPC)
# define CMS_USE_BIG_ENDIAN 1
+# if defined (__GNUC__) && defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN)
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+// // Don't use big endian for PowerPC little endian mode
+# undef CMS_USE_BIG_ENDIAN
+# endif
+# endif
#endif
-#if TARGET_CPU_PPC
-# define CMS_USE_BIG_ENDIAN 1
+// WORDS_BIGENDIAN takes precedence
+#if defined(_HOST_BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(WORDS_BIGENDIAN)
+# define CMS_USE_BIG_ENDIAN 1
#endif
#ifdef macintosh
# ifdef __BIG_ENDIAN__
# define CMS_USE_BIG_ENDIAN 1
# endif
+# ifdef __LITTLE_ENDIAN__
+# undef CMS_USE_BIG_ENDIAN
+# endif
#endif
// Calling convention -- this is hardly platform and compiler dependent
# define CMSAPI
#endif
+#ifdef HasTHREADS
+# if HasTHREADS == 1
+# undef CMS_NO_PTHREADS
+# else
+# define CMS_NO_PTHREADS 1
+# endif
+#endif
+
// Some common definitions
#define cmsMAX_PATH 256
cmsSigCrdInfoType = 0x63726469, // 'crdi'
cmsSigCurveType = 0x63757276, // 'curv'
cmsSigDataType = 0x64617461, // 'data'
+ cmsSigDictType = 0x64696374, // 'dict'
cmsSigDateTimeType = 0x6474696D, // 'dtim'
cmsSigDeviceSettingsType = 0x64657673, // 'devs'
cmsSigLut16Type = 0x6d667432, // 'mft2'
cmsSigUInt32ArrayType = 0x75693332, // 'ui32'
cmsSigUInt64ArrayType = 0x75693634, // 'ui64'
cmsSigUInt8ArrayType = 0x75693038, // 'ui08'
+ cmsSigVcgtType = 0x76636774, // 'vcgt'
cmsSigViewingConditionsType = 0x76696577, // 'view'
- cmsSigXYZType = 0x58595A20, // 'XYZ '
- cmsSigVcgtType = 0x76636774 // 'vcgt'
+ cmsSigXYZType = 0x58595A20 // 'XYZ '
+
} cmsTagTypeSignature;
cmsSigPreview1Tag = 0x70726531, // 'pre1'
cmsSigPreview2Tag = 0x70726532, // 'pre2'
cmsSigProfileDescriptionTag = 0x64657363, // 'desc'
+ cmsSigProfileDescriptionMLTag = 0x6473636d, // 'dscm'
cmsSigProfileSequenceDescTag = 0x70736571, // 'pseq'
cmsSigProfileSequenceIdTag = 0x70736964, // 'psid'
cmsSigPs2CRD0Tag = 0x70736430, // 'psd0'
cmsSigUcrBgTag = 0x62666420, // 'bfd '
cmsSigViewingCondDescTag = 0x76756564, // 'vued'
cmsSigViewingConditionsTag = 0x76696577, // 'view'
- cmsSigVcgtTag = 0x76636774 // 'vcgt'
+ cmsSigVcgtTag = 0x76636774, // 'vcgt'
+ cmsSigMetaTag = 0x6D657461 // 'meta'
} cmsTagSignature;
cmsSigMCH7Data = 0x4D434837, // 'MCH7'
cmsSigMCH8Data = 0x4D434838, // 'MCH8'
cmsSigMCH9Data = 0x4D434839, // 'MCH9'
- cmsSigMCHAData = 0x4D43483A, // 'MCHA'
- cmsSigMCHBData = 0x4D43483B, // 'MCHB'
- cmsSigMCHCData = 0x4D43483C, // 'MCHC'
- cmsSigMCHDData = 0x4D43483D, // 'MCHD'
- cmsSigMCHEData = 0x4D43483E, // 'MCHE'
- cmsSigMCHFData = 0x4D43483F, // 'MCHF'
+ cmsSigMCHAData = 0x4D434841, // 'MCHA'
+ cmsSigMCHBData = 0x4D434842, // 'MCHB'
+ cmsSigMCHCData = 0x4D434843, // 'MCHC'
+ cmsSigMCHDData = 0x4D434844, // 'MCHD'
+ cmsSigMCHEData = 0x4D434845, // 'MCHE'
+ cmsSigMCHFData = 0x4D434846, // 'MCHF'
cmsSigNamedData = 0x6e6d636c, // 'nmcl'
cmsSig1colorData = 0x31434C52, // '1CLR'
cmsSig2colorData = 0x32434C52, // '2CLR'
cmsSigLabV4toV2 = 0x34203220, // '4 2 '
// Identities
- cmsSigIdentityElemType = 0x69646E20 // 'idn '
+ cmsSigIdentityElemType = 0x69646E20, // 'idn '
+
+ // Float to floatPCS
+ cmsSigLab2FloatPCS = 0x64326C20, // 'd2l '
+ cmsSigFloatPCS2Lab = 0x6C326420, // 'l2d '
+ cmsSigXYZ2FloatPCS = 0x64327820, // 'd2x '
+ cmsSigFloatPCS2XYZ = 0x78326420 // 'x2d '
} cmsStageSignature;
// Little CMS specific typedefs
-typedef void* cmsContext; // Context identifier for multithreaded environments
typedef void* cmsHANDLE ; // Generic handle
typedef void* cmsHPROFILE; // Opaque typedefs to hide internals
typedef void* cmsHTRANSFORM;
// Format of pixel is defined by one cmsUInt32Number, using bit fields as follows
//
-// A O TTTTT U Y F P X S EEE CCCC BBB
+// 2 1 0
+// 3 2 10987 6 5 4 3 2 1 098 7654 321
+// A O TTTTT U Y F P X S EEE CCCC BBB
//
// A: Floating point -- With this flag we can differentiate 16 bits as float and as int
// O: Optimized -- previous optimization already returns the final 8-bit value
#define TYPE_RGBA_16_SE (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|ENDIAN16_SH(1))
#define TYPE_ARGB_8 (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(1)|SWAPFIRST_SH(1))
+#define TYPE_ARGB_8_PLANAR (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(1)|SWAPFIRST_SH(1)|PLANAR_SH(1))
#define TYPE_ARGB_16 (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|SWAPFIRST_SH(1))
#define TYPE_ABGR_8 (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1))
+#define TYPE_ABGR_8_PLANAR (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|PLANAR_SH(1))
#define TYPE_ABGR_16 (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1))
#define TYPE_ABGR_16_PLANAR (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1)|PLANAR_SH(1))
#define TYPE_ABGR_16_SE (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1)|ENDIAN16_SH(1))
#define TYPE_BGRA_8 (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1))
+#define TYPE_BGRA_8_PLANAR (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1)|PLANAR_SH(1))
#define TYPE_BGRA_16 (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1))
-#define TYPE_BGRA_16_SE (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|ENDIAN16_SH(1)|SWAPFIRST_SH(1))
+#define TYPE_BGRA_16_SE (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|ENDIAN16_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1))
#define TYPE_CMY_8 (COLORSPACE_SH(PT_CMY)|CHANNELS_SH(3)|BYTES_SH(1))
#define TYPE_CMY_8_PLANAR (COLORSPACE_SH(PT_CMY)|CHANNELS_SH(3)|BYTES_SH(1)|PLANAR_SH(1))
#define TYPE_Lab_8 (COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(1))
#define TYPE_LabV2_8 (COLORSPACE_SH(PT_LabV2)|CHANNELS_SH(3)|BYTES_SH(1))
-#define TYPE_ALab_8 (COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1))
-#define TYPE_ALabV2_8 (COLORSPACE_SH(PT_LabV2)|CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1))
+#define TYPE_ALab_8 (COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1))
+#define TYPE_ALabV2_8 (COLORSPACE_SH(PT_LabV2)|CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1))
#define TYPE_Lab_16 (COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(2))
#define TYPE_LabV2_16 (COLORSPACE_SH(PT_LabV2)|CHANNELS_SH(3)|BYTES_SH(2))
#define TYPE_Yxy_16 (COLORSPACE_SH(PT_Yxy)|CHANNELS_SH(3)|BYTES_SH(2))
// Float formatters.
#define TYPE_XYZ_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_XYZ)|CHANNELS_SH(3)|BYTES_SH(4))
-#define TYPE_XYZA_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_XYZ)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(4))
#define TYPE_Lab_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(4))
#define TYPE_LabA_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_Lab)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(4))
#define TYPE_GRAY_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_GRAY)|CHANNELS_SH(1)|BYTES_SH(4))
#define TYPE_RGB_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(4))
+
#define TYPE_RGBA_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(4))
+#define TYPE_ARGB_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(4)|SWAPFIRST_SH(1))
+#define TYPE_BGR_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(4)|DOSWAP_SH(1))
+#define TYPE_BGRA_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(4)|DOSWAP_SH(1)|SWAPFIRST_SH(1))
+#define TYPE_ABGR_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(4)|DOSWAP_SH(1))
+
#define TYPE_CMYK_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(4))
-// Floating point formatters.
+// Floating point formatters.
// NOTE THAT 'BYTES' FIELD IS SET TO ZERO ON DLB because 8 bytes overflows the bitfield
#define TYPE_XYZ_DBL (FLOAT_SH(1)|COLORSPACE_SH(PT_XYZ)|CHANNELS_SH(3)|BYTES_SH(0))
#define TYPE_Lab_DBL (FLOAT_SH(1)|COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(0))
#define TYPE_GRAY_DBL (FLOAT_SH(1)|COLORSPACE_SH(PT_GRAY)|CHANNELS_SH(1)|BYTES_SH(0))
#define TYPE_RGB_DBL (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(0))
+#define TYPE_BGR_DBL (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(0)|DOSWAP_SH(1))
#define TYPE_CMYK_DBL (FLOAT_SH(1)|COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(0))
+// IEEE 754-2008 "half"
+#define TYPE_GRAY_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_GRAY)|CHANNELS_SH(1)|BYTES_SH(2))
+#define TYPE_RGB_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(2))
+#define TYPE_RGBA_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2))
+#define TYPE_CMYK_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(2))
+
+#define TYPE_RGBA_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2))
+#define TYPE_ARGB_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|SWAPFIRST_SH(1))
+#define TYPE_BGR_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1))
+#define TYPE_BGRA_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1))
+#define TYPE_ABGR_HALF_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_RGB)|CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1))
+
#endif
// Colorspaces
CMSAPI int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2);
CMSAPI long int CMSEXPORT cmsfilelength(FILE* f);
-// Plug-In registering ---------------------------------------------------------------------------------------------------
+
+// Context handling --------------------------------------------------------------------------------------------------------
+
+// Each context holds its owns globals and its own plug-ins. There is a global context with the id = 0 for lecacy compatibility
+// though using the global context is not recomended. Proper context handling makes lcms more thread-safe.
+
+typedef struct _cmsContext_struct* cmsContext;
+
+CMSAPI cmsContext CMSEXPORT cmsCreateContext(void* Plugin, void* UserData);
+CMSAPI void CMSEXPORT cmsDeleteContext(cmsContext ContexID);
+CMSAPI cmsContext CMSEXPORT cmsDupContext(cmsContext ContextID, void* NewUserData);
+CMSAPI void* CMSEXPORT cmsGetContextUserData(cmsContext ContextID);
+
+// Plug-In registering --------------------------------------------------------------------------------------------------
CMSAPI cmsBool CMSEXPORT cmsPlugin(void* Plugin);
+CMSAPI cmsBool CMSEXPORT cmsPluginTHR(cmsContext ContextID, void* Plugin);
CMSAPI void CMSEXPORT cmsUnregisterPlugins(void);
+CMSAPI void CMSEXPORT cmsUnregisterPluginsTHR(cmsContext ContextID);
// Error logging ----------------------------------------------------------------------------------------------------------
// Allows user to set any specific logger
CMSAPI void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn);
+CMSAPI void CMSEXPORT cmsSetLogErrorHandlerTHR(cmsContext ContextID, cmsLogErrorHandlerFunction Fn);
// Conversions --------------------------------------------------------------------------------------------------------------
CMSAPI cmsInt32Number CMSEXPORT cmsGetToneCurveParametricType(const cmsToneCurve* t);
CMSAPI cmsFloat64Number CMSEXPORT cmsEstimateGamma(const cmsToneCurve* t, cmsFloat64Number Precision);
+// Tone curve tabular estimation
+CMSAPI cmsUInt32Number CMSEXPORT cmsGetToneCurveEstimatedTableEntries(const cmsToneCurve* t);
+CMSAPI const cmsUInt16Number* CMSEXPORT cmsGetToneCurveEstimatedTable(const cmsToneCurve* t);
+
// Implements pipelines of multi-processing elements -------------------------------------------------------------
CMSAPI void CMSEXPORT cmsPipelineFree(cmsPipeline* lut);
CMSAPI cmsPipeline* CMSEXPORT cmsPipelineDup(const cmsPipeline* Orig);
+CMSAPI cmsContext CMSEXPORT cmsGetPipelineContextID(const cmsPipeline* lut);
CMSAPI cmsUInt32Number CMSEXPORT cmsPipelineInputChannels(const cmsPipeline* lut);
CMSAPI cmsUInt32Number CMSEXPORT cmsPipelineOutputChannels(const cmsPipeline* lut);
// Where to place/locate the stages in the pipeline chain
typedef enum { cmsAT_BEGIN, cmsAT_END } cmsStageLoc;
-CMSAPI void CMSEXPORT cmsPipelineInsertStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage* mpe);
+CMSAPI int CMSEXPORT cmsPipelineInsertStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage* mpe);
CMSAPI void CMSEXPORT cmsPipelineUnlinkStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage** mpe);
// This function is quite useful to analyze the structure of a Pipeline and retrieve the Stage elements
#define SAMPLER_INSPECT 0x01000000
// For CLUT only
-CMSAPI cmsBool CMSEXPORT cmsStageSampleCLut16bit(cmsStage* mpe, cmsSAMPLER16 Sampler, void* Cargo, cmsUInt32Number dwFlags);
+CMSAPI cmsBool CMSEXPORT cmsStageSampleCLut16bit(cmsStage* mpe, cmsSAMPLER16 Sampler, void* Cargo, cmsUInt32Number dwFlags);
CMSAPI cmsBool CMSEXPORT cmsStageSampleCLutFloat(cmsStage* mpe, cmsSAMPLERFLOAT Sampler, void* Cargo, cmsUInt32Number dwFlags);
-
// Slicers
CMSAPI cmsBool CMSEXPORT cmsSliceSpace16(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[],
cmsSAMPLER16 Sampler, void * Cargo);
const char LanguageCode[3], const char CountryCode[3],
char ObtainedLanguage[3], char ObtainedCountry[3]);
+CMSAPI cmsUInt32Number CMSEXPORT cmsMLUtranslationsCount(const cmsMLU* mlu);
+
+CMSAPI cmsBool CMSEXPORT cmsMLUtranslationsCodes(const cmsMLU* mlu,
+ cmsUInt32Number idx,
+ char LanguageCode[3],
+ char CountryCode[3]);
+
// Undercolorremoval & black generation -------------------------------------------------------------------------------------
typedef struct {
// Profile sequence descriptor. Some fields come from profile sequence descriptor tag, others
// come from Profile Sequence Identifier Tag
typedef struct {
+
cmsSignature deviceMfg;
cmsSignature deviceModel;
cmsUInt64Number attributes;
CMSAPI cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq);
CMSAPI void CMSEXPORT cmsFreeProfileSequenceDescription(cmsSEQ* pseq);
+// Dictionaries --------------------------------------------------------------------------------------------------------
+
+typedef struct _cmsDICTentry_struct {
+
+ struct _cmsDICTentry_struct* Next;
+
+ cmsMLU *DisplayName;
+ cmsMLU *DisplayValue;
+ wchar_t* Name;
+ wchar_t* Value;
+
+} cmsDICTentry;
+
+CMSAPI cmsHANDLE CMSEXPORT cmsDictAlloc(cmsContext ContextID);
+CMSAPI void CMSEXPORT cmsDictFree(cmsHANDLE hDict);
+CMSAPI cmsHANDLE CMSEXPORT cmsDictDup(cmsHANDLE hDict);
+
+CMSAPI cmsBool CMSEXPORT cmsDictAddEntry(cmsHANDLE hDict, const wchar_t* Name, const wchar_t* Value, const cmsMLU *DisplayName, const cmsMLU *DisplayValue);
+CMSAPI const cmsDICTentry* CMSEXPORT cmsDictGetEntryList(cmsHANDLE hDict);
+CMSAPI const cmsDICTentry* CMSEXPORT cmsDictNextEntry(const cmsDICTentry* e);
+
// Access to Profile data ----------------------------------------------------------------------------------------------
CMSAPI cmsHPROFILE CMSEXPORT cmsCreateProfilePlaceholder(cmsContext ContextID);
CMSAPI cmsBool CMSEXPORT cmsWriteRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data, cmsUInt32Number Size);
// Access header data
-#define cmsEmbeddedProfileFalse 0x00000000
-#define cmsEmbeddedProfileTrue 0x00000001
-#define cmsUseAnywhere 0x00000000
+#define cmsEmbeddedProfileFalse 0x00000000
+#define cmsEmbeddedProfileTrue 0x00000001
+#define cmsUseAnywhere 0x00000000
#define cmsUseWithEmbeddedDataOnly 0x00000002
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderFlags(cmsHPROFILE hProfile);
CMSAPI void CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags);
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile);
CMSAPI void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer);
+CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderCreator(cmsHPROFILE hProfile);
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile);
CMSAPI void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model);
CMSAPI void CMSEXPORT cmsSetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number Flags);
CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromMem(const void * MemPtr, cmsUInt32Number dwSize);
CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromMemTHR(cmsContext ContextID, const void * MemPtr, cmsUInt32Number dwSize);
CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandlerTHR(cmsContext ContextID, cmsIOHANDLER* io);
+CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandler2THR(cmsContext ContextID, cmsIOHANDLER* io, cmsBool write);
CMSAPI cmsBool CMSEXPORT cmsCloseProfile(cmsHPROFILE hProfile);
CMSAPI cmsBool CMSEXPORT cmsSaveProfileToFile(cmsHPROFILE hProfile, const char* FileName);
// Call with NULL as parameters to get the intent count
CMSAPI cmsUInt32Number CMSEXPORT cmsGetSupportedIntents(cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions);
+CMSAPI cmsUInt32Number CMSEXPORT cmsGetSupportedIntentsTHR(cmsContext ContextID, cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions);
// Flags
void * OutputBuffer,
cmsUInt32Number Size);
-CMSAPI void CMSEXPORT cmsSetAlarmCodes(cmsUInt16Number NewAlarm[cmsMAXCHANNELS]);
+CMSAPI void CMSEXPORT cmsDoTransformStride(cmsHTRANSFORM Transform,
+ const void * InputBuffer,
+ void * OutputBuffer,
+ cmsUInt32Number Size,
+ cmsUInt32Number Stride);
+
+
+CMSAPI void CMSEXPORT cmsSetAlarmCodes(const cmsUInt16Number NewAlarm[cmsMAXCHANNELS]);
CMSAPI void CMSEXPORT cmsGetAlarmCodes(cmsUInt16Number NewAlarm[cmsMAXCHANNELS]);
+
+CMSAPI void CMSEXPORT cmsSetAlarmCodesTHR(cmsContext ContextID,
+ const cmsUInt16Number AlarmCodes[cmsMAXCHANNELS]);
+CMSAPI void CMSEXPORT cmsGetAlarmCodesTHR(cmsContext ContextID,
+ cmsUInt16Number AlarmCodes[cmsMAXCHANNELS]);
+
+
+
// Adaptation state for absolute colorimetric intent
CMSAPI cmsFloat64Number CMSEXPORT cmsSetAdaptationState(cmsFloat64Number d);
+CMSAPI cmsFloat64Number CMSEXPORT cmsSetAdaptationStateTHR(cmsContext ContextID, cmsFloat64Number d);
+
+
// Grab the ContextID from an open transform. Returns NULL if a NULL transform is passed
CMSAPI cmsContext CMSEXPORT cmsGetTransformContextID(cmsHTRANSFORM hTransform);
+// Grab the input/output formats
+CMSAPI cmsUInt32Number CMSEXPORT cmsGetTransformInputFormat(cmsHTRANSFORM hTransform);
+CMSAPI cmsUInt32Number CMSEXPORT cmsGetTransformOutputFormat(cmsHTRANSFORM hTransform);
+
// For backwards compatibility
-CMSAPI cmsBool CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
- cmsUInt32Number InputFormat,
+CMSAPI cmsBool CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
+ cmsUInt32Number InputFormat,
cmsUInt32Number OutputFormat);
CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyStr(cmsHANDLE hIT8, const char* cProp, const char *Str);
CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyDbl(cmsHANDLE hIT8, const char* cProp, cmsFloat64Number Val);
CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyHex(cmsHANDLE hIT8, const char* cProp, cmsUInt32Number Val);
+CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char* SubKey, const char *Buffer);
CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyUncooked(cmsHANDLE hIT8, const char* Key, const char* Buffer);
CMSAPI const char* CMSEXPORT cmsIT8GetProperty(cmsHANDLE hIT8, const char* cProp);
CMSAPI cmsFloat64Number CMSEXPORT cmsIT8GetPropertyDbl(cmsHANDLE hIT8, const char* cProp);
+CMSAPI const char* CMSEXPORT cmsIT8GetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char *SubKey);
CMSAPI cmsUInt32Number CMSEXPORT cmsIT8EnumProperties(cmsHANDLE hIT8, char ***PropertyNames);
+CMSAPI cmsUInt32Number CMSEXPORT cmsIT8EnumPropertyMulti(cmsHANDLE hIT8, const char* cProp, const char ***SubpropertyNames);
// Datasets
CMSAPI const char* CMSEXPORT cmsIT8GetDataRowCol(cmsHANDLE hIT8, int row, int col);
CMSAPI int CMSEXPORT cmsIT8EnumDataFormat(cmsHANDLE hIT8, char ***SampleNames);
CMSAPI const char* CMSEXPORT cmsIT8GetPatchName(cmsHANDLE hIT8, int nPatch, char* buffer);
+CMSAPI int CMSEXPORT cmsIT8GetPatchByName(cmsHANDLE hIT8, const char *cPatch);
// The LABEL extension
CMSAPI int CMSEXPORT cmsIT8SetTableByLabel(cmsHANDLE hIT8, const char* cSet, const char* cField, const char* ExpectedType);
+CMSAPI cmsBool CMSEXPORT cmsIT8SetIndexColumn(cmsHANDLE hIT8, const char* cSample);
+
// Formatter for double
CMSAPI void CMSEXPORT cmsIT8DefineDblFormat(cmsHANDLE hIT8, const char* Formatter);
// Estimate the black point
CMSAPI cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags);
+CMSAPI cmsBool CMSEXPORT cmsDetectDestinationBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags);
// Estimate total area coverage
CMSAPI cmsFloat64Number CMSEXPORT cmsDetectTAC(cmsHPROFILE hProfile);
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2011 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"),
// Endianess adjust functions
CMSAPI cmsUInt16Number CMSEXPORT _cmsAdjustEndianess16(cmsUInt16Number Word);
CMSAPI cmsUInt32Number CMSEXPORT _cmsAdjustEndianess32(cmsUInt32Number Value);
-CMSAPI void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number QWord);
+CMSAPI void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number* QWord);
// Helper IO functions
CMSAPI cmsBool CMSEXPORT _cmsReadUInt8Number(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 _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);
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);
//----------------------------------------------------------------------------------------------------------
#define cmsPluginRenderingIntentSig 0x696E7448 // 'intH'
#define cmsPluginMultiProcessElementSig 0x6D706548 // 'mpeH'
#define cmsPluginOptimizationSig 0x6F707448 // 'optH'
+#define cmsPluginTransformSig 0x7A666D48 // 'xfmH'
+#define cmsPluginMutexSig 0x6D747A48 // 'mtxH'
typedef struct _cmsPluginBaseStruct {
//----------------------------------------------------------------------------------------------------------
// 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
- void * (* MallocPtr)(cmsContext ContextID, cmsUInt32Number size);
- void (* FreePtr)(cmsContext ContextID, void *Ptr);
- void * (* ReallocPtr)(cmsContext ContextID, void* Ptr, cmsUInt32Number NewSize);
+ _cmsMallocFnPtrType MallocPtr;
+ _cmsFreeFnPtrType FreePtr;
+ _cmsReallocFnPtrType ReallocPtr;
// Optional
- void * (* MallocZeroPtr)(cmsContext ContextID, cmsUInt32Number size);
- void * (* CallocPtr)(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size);
- void * (* DupPtr)(cmsContext ContextID, const void* Org, cmsUInt32Number size);
+ _cmsMalloZerocFnPtrType MallocZeroPtr;
+ _cmsCallocFnPtrType CallocPtr;
+ _cmsDupFnPtrType DupPtr;
} cmsPluginMemHandler;
void *Ptr);
// Additional parameters used by the calling thread
- cmsContext ContextID;
+ cmsContext ContextID;
cmsUInt32Number ICCVersion;
} cmsTagTypeHandler;
} 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
register cmsUInt16Number Out[],
register const void* Data);
-typedef void (* _cmsOPTfreeDataFn)(cmsContext ContextID, void* Data);
-typedef void* (* _cmsOPTdupDataFn)(cmsContext ContextID, const void* Data);
-
typedef cmsBool (* _cmsOPToptimizeFn)(cmsPipeline** Lut,
cmsUInt32Number Intent,
CMSAPI void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut,
_cmsOPTeval16Fn Eval16,
void* PrivateData,
- _cmsOPTfreeDataFn FreePrivateDataFn,
- _cmsOPTdupDataFn DupPrivateDataFn);
+ _cmsFreeUserDataFn FreePrivateDataFn,
+ _cmsDupUserDataFn DupPrivateDataFn);
typedef struct {
cmsPluginBase base;
} cmsPluginOptimization;
//----------------------------------------------------------------------------------------------------------
+// Full xform
+typedef void (* _cmsTransformFn)(struct _cmstransform_struct *CMMcargo,
+ const void* InputBuffer,
+ void* OutputBuffer,
+ cmsUInt32Number Size,
+ cmsUInt32Number Stride);
+
+typedef cmsBool (* _cmsTransformFactory)(_cmsTransformFn* 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
+ _cmsTransformFactory Factory;
+
+} 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
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// ---------- Implementation --------------------------------------------
typedef struct {
-
+
cmsFloat64Number XYZ[3];
cmsFloat64Number RGB[3];
cmsFloat64Number RGBc[3];
cmsFloat64Number abC[2];
cmsFloat64Number abs[2];
cmsFloat64Number abM[2];
-
+
} CAM02COLOR;
typedef struct {
-
+
CAM02COLOR adoptedWhite;
cmsFloat64Number LA, Yb;
cmsFloat64Number F, c, Nc;
cmsUInt32Number surround;
cmsFloat64Number n, Nbb, Ncb, z, FL, D;
-
- cmsContext ContextID;
+
+ cmsContext ContextID;
} cmsCIECAM02;
static
-cmsFloat64Number compute_n(cmsCIECAM02* pMod)
+cmsFloat64Number compute_n(cmsCIECAM02* pMod)
{
return (pMod -> Yb / pMod -> adoptedWhite.XYZ[1]);
}
static
-cmsFloat64Number compute_z(cmsCIECAM02* pMod)
+cmsFloat64Number compute_z(cmsCIECAM02* pMod)
{
return (1.48 + pow(pMod -> n, 0.5));
}
static
-cmsFloat64Number computeNbb(cmsCIECAM02* pMod)
+cmsFloat64Number computeNbb(cmsCIECAM02* pMod)
{
return (0.725 * pow((1.0 / pMod -> n), 0.2));
}
static
-cmsFloat64Number computeFL(cmsCIECAM02* pMod)
+cmsFloat64Number computeFL(cmsCIECAM02* pMod)
{
cmsFloat64Number k, FL;
-
+
k = 1.0 / ((5.0 * pMod->LA) + 1.0);
FL = 0.2 * pow(k, 4.0) * (5.0 * pMod->LA) + 0.1 *
(pow((1.0 - pow(k, 4.0)), 2.0)) *
(pow((5.0 * pMod->LA), (1.0 / 3.0)));
-
+
return FL;
}
-static
-cmsFloat64Number computeD(cmsCIECAM02* pMod)
+static
+cmsFloat64Number computeD(cmsCIECAM02* pMod)
{
cmsFloat64Number D;
static
-CAM02COLOR XYZtoCAT02(CAM02COLOR clr)
+CAM02COLOR XYZtoCAT02(CAM02COLOR clr)
{
clr.RGB[0] = (clr.XYZ[0] * 0.7328) + (clr.XYZ[1] * 0.4296) + (clr.XYZ[2] * -0.1624);
clr.RGB[1] = (clr.XYZ[0] * -0.7036) + (clr.XYZ[1] * 1.6975) + (clr.XYZ[2] * 0.0061);
clr.RGB[2] = (clr.XYZ[0] * 0.0030) + (clr.XYZ[1] * 0.0136) + (clr.XYZ[2] * 0.9834);
-
+
return clr;
}
static
-CAM02COLOR ChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
+CAM02COLOR ChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
{
cmsUInt32Number i;
(1.0 - pMod->D)) * clr.RGB[i];
}
- return clr;
+ return clr;
}
static
-CAM02COLOR CAT02toHPE(CAM02COLOR clr)
+CAM02COLOR CAT02toHPE(CAM02COLOR clr)
{
cmsFloat64Number M[9];
-
+
M[0] =(( 0.38971 * 1.096124) + (0.68898 * 0.454369) + (-0.07868 * -0.009628));
M[1] =(( 0.38971 * -0.278869) + (0.68898 * 0.473533) + (-0.07868 * -0.005698));
M[2] =(( 0.38971 * 0.182745) + (0.68898 * 0.072098) + (-0.07868 * 1.015326));
M[6] =(-0.009628);
M[7] =(-0.005698);
M[8] =( 1.015326);
-
+
clr.RGBp[0] = (clr.RGBc[0] * M[0]) + (clr.RGBc[1] * M[1]) + (clr.RGBc[2] * M[2]);
clr.RGBp[1] = (clr.RGBc[0] * M[3]) + (clr.RGBc[1] * M[4]) + (clr.RGBc[2] * M[5]);
clr.RGBp[2] = (clr.RGBc[0] * M[6]) + (clr.RGBc[1] * M[7]) + (clr.RGBc[2] * M[8]);
-
+
return clr;
}
static
-CAM02COLOR NonlinearCompression(CAM02COLOR clr, cmsCIECAM02* pMod)
+CAM02COLOR NonlinearCompression(CAM02COLOR clr, cmsCIECAM02* pMod)
{
cmsUInt32Number i;
cmsFloat64Number temp;
clr.RGBpa[i] = (400.0 * temp) / (temp + 27.13) + 0.1;
}
}
-
- clr.A = (((2.0 * clr.RGBpa[0]) + clr.RGBpa[1] +
+
+ clr.A = (((2.0 * clr.RGBpa[0]) + clr.RGBpa[1] +
(clr.RGBpa[2] / 20.0)) - 0.305) * pMod->Nbb;
return clr;
}
static
-CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
+CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
{
cmsFloat64Number a, b, temp, e, t, r2d, d2r;
a = clr.RGBpa[0] - (12.0 * clr.RGBpa[1] / 11.0) + (clr.RGBpa[2] / 11.0);
b = (clr.RGBpa[0] + clr.RGBpa[1] - (2.0 * clr.RGBpa[2])) / 9.0;
-
+
r2d = (180.0 / 3.141592654);
if (a == 0) {
if (b == 0) clr.h = 0;
temp = b / a;
clr.h = (r2d * atan(temp)) + 180;
}
-
+
d2r = (3.141592654 / 180.0);
- e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) *
- (cos((clr.h * d2r + 2.0)) + 3.8);
-
+ e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) *
+ (cos((clr.h * d2r + 2.0)) + 3.8);
+
if (clr.h < 20.14) {
temp = ((clr.h + 122.47)/1.2) + ((20.14 - clr.h)/0.8);
clr.H = 300 + (100*((clr.h + 122.47)/1.2)) / temp;
temp = ((clr.h - 237.53)/1.2) + ((360 - clr.h + 20.14)/0.8);
clr.H = 300 + ((100*((clr.h - 237.53)/1.2)) / temp);
}
-
- clr.J = 100.0 * pow((clr.A / pMod->adoptedWhite.A),
+
+ clr.J = 100.0 * pow((clr.A / pMod->adoptedWhite.A),
(pMod->c * pMod->z));
clr.Q = (4.0 / pMod->c) * pow((clr.J / 100.0), 0.5) *
(pMod->adoptedWhite.A + 4.0) * pow(pMod->FL, 0.25);
-
+
t = (e * pow(((a * a) + (b * b)), 0.5)) /
- (clr.RGBpa[0] + clr.RGBpa[1] +
+ (clr.RGBpa[0] + clr.RGBpa[1] +
((21.0 / 20.0) * clr.RGBpa[2]));
clr.C = pow(t, 0.9) * pow((clr.J / 100.0), 0.5) *
clr.M = clr.C * pow(pMod->FL, 0.25);
clr.s = 100.0 * pow((clr.M / clr.Q), 0.5);
-
+
return clr;
}
static
-CAM02COLOR InverseCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
+CAM02COLOR InverseCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
{
-
+
cmsFloat64Number t, e, p1, p2, p3, p4, p5, hr, d2r;
d2r = 3.141592654 / 180.0;
-
+
t = pow( (clr.C / (pow((clr.J / 100.0), 0.5) *
- (pow((1.64 - pow(0.29, pMod->n)), 0.73)))),
+ (pow((1.64 - pow(0.29, pMod->n)), 0.73)))),
(1.0 / 0.9) );
e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) *
(cos((clr.h * d2r + 2.0)) + 3.8);
-
+
clr.A = pMod->adoptedWhite.A * pow(
(clr.J / 100.0),
(1.0 / (pMod->c * pMod->z)));
-
+
p1 = e / t;
p2 = (clr.A / pMod->Nbb) + 0.305;
p3 = 21.0 / 20.0;
-
+
hr = clr.h * d2r;
-
+
if (fabs(sin(hr)) >= fabs(cos(hr))) {
p4 = p1 / sin(hr);
clr.b = (p2 * (2.0 + p3) * (460.0 / 1403.0)) /
(sin(hr) / cos(hr)));
clr.b = clr.a * (sin(hr) / cos(hr));
}
-
- clr.RGBpa[0] = ((460.0 / 1403.0) * p2) +
+
+ clr.RGBpa[0] = ((460.0 / 1403.0) * p2) +
((451.0 / 1403.0) * clr.a) +
((288.0 / 1403.0) * clr.b);
- clr.RGBpa[1] = ((460.0 / 1403.0) * p2) -
+ clr.RGBpa[1] = ((460.0 / 1403.0) * p2) -
((891.0 / 1403.0) * clr.a) -
((261.0 / 1403.0) * clr.b);
clr.RGBpa[2] = ((460.0 / 1403.0) * p2) -
((220.0 / 1403.0) * clr.a) -
((6300.0 / 1403.0) * clr.b);
-
+
return clr;
}
{
cmsUInt32Number i;
cmsFloat64Number c1;
-
+
for (i = 0; i < 3; i++) {
if ((clr.RGBpa[i] - 0.1) < 0) c1 = -1;
else c1 = 1;
(400.0 - fabs(clr.RGBpa[i] - 0.1))),
(1.0 / 0.42));
}
-
+
return clr;
}
static
-CAM02COLOR HPEtoCAT02(CAM02COLOR clr)
+CAM02COLOR HPEtoCAT02(CAM02COLOR clr)
{
cmsFloat64Number M[9];
-
+
M[0] = (( 0.7328 * 1.910197) + (0.4296 * 0.370950));
M[1] = (( 0.7328 * -1.112124) + (0.4296 * 0.629054));
M[2] = (( 0.7328 * 0.201908) + (0.4296 * 0.000008) - 0.1624);
M[6] = (( 0.0030 * 1.910197) + (0.0136 * 0.370950));
M[7] = (( 0.0030 * -1.112124) + (0.0136 * 0.629054));
M[8] = (( 0.0030 * 0.201908) + (0.0136 * 0.000008) + 0.9834);;
-
+
clr.RGBc[0] = (clr.RGBp[0] * M[0]) + (clr.RGBp[1] * M[1]) + (clr.RGBp[2] * M[2]);
clr.RGBc[1] = (clr.RGBp[0] * M[3]) + (clr.RGBp[1] * M[4]) + (clr.RGBp[2] * M[5]);
clr.RGBc[2] = (clr.RGBp[0] * M[6]) + (clr.RGBp[1] * M[7]) + (clr.RGBp[2] * M[8]);
static
-CAM02COLOR InverseChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
+CAM02COLOR InverseChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
{
cmsUInt32Number i;
- for (i = 0; i < 3; i++) {
+ for (i = 0; i < 3; i++) {
clr.RGB[i] = clr.RGBc[i] /
((pMod->adoptedWhite.XYZ[1] * pMod->D / pMod->adoptedWhite.RGB[i]) + 1.0 - pMod->D);
}
static
-CAM02COLOR CAT02toXYZ(CAM02COLOR clr)
+CAM02COLOR CAT02toXYZ(CAM02COLOR clr)
{
clr.XYZ[0] = (clr.RGB[0] * 1.096124) + (clr.RGB[1] * -0.278869) + (clr.RGB[2] * 0.182745);
clr.XYZ[1] = (clr.RGB[0] * 0.454369) + (clr.RGB[1] * 0.473533) + (clr.RGB[2] * 0.072098);
clr.XYZ[2] = (clr.RGB[0] * -0.009628) + (clr.RGB[1] * -0.005698) + (clr.RGB[2] * 1.015326);
-
+
return clr;
}
cmsHANDLE CMSEXPORT cmsCIECAM02Init(cmsContext ContextID, const cmsViewingConditions* pVC)
{
- cmsCIECAM02* lpMod;
+ cmsCIECAM02* lpMod;
- _cmsAssert(pVC != NULL);
+ _cmsAssert(pVC != NULL);
- if((lpMod = (cmsCIECAM02*) _cmsMallocZero(ContextID, sizeof(cmsCIECAM02))) == NULL) {
- return NULL;
- }
+ if((lpMod = (cmsCIECAM02*) _cmsMallocZero(ContextID, sizeof(cmsCIECAM02))) == NULL) {
+ return NULL;
+ }
- lpMod ->ContextID = ContextID;
+ lpMod ->ContextID = ContextID;
- lpMod ->adoptedWhite.XYZ[0] = pVC ->whitePoint.X;
- lpMod ->adoptedWhite.XYZ[1] = pVC ->whitePoint.Y;
- lpMod ->adoptedWhite.XYZ[2] = pVC ->whitePoint.Z;
+ lpMod ->adoptedWhite.XYZ[0] = pVC ->whitePoint.X;
+ lpMod ->adoptedWhite.XYZ[1] = pVC ->whitePoint.Y;
+ lpMod ->adoptedWhite.XYZ[2] = pVC ->whitePoint.Z;
- lpMod -> LA = pVC ->La;
- lpMod -> Yb = pVC ->Yb;
- lpMod -> D = pVC ->D_value;
- lpMod -> surround = pVC ->surround;
+ lpMod -> LA = pVC ->La;
+ lpMod -> Yb = pVC ->Yb;
+ lpMod -> D = pVC ->D_value;
+ lpMod -> surround = pVC ->surround;
- switch (lpMod -> surround) {
+ switch (lpMod -> surround) {
- case CUTSHEET_SURROUND:
- lpMod->F = 0.8;
- lpMod->c = 0.41;
- lpMod->Nc = 0.8;
- break;
+ case CUTSHEET_SURROUND:
+ lpMod->F = 0.8;
+ lpMod->c = 0.41;
+ lpMod->Nc = 0.8;
+ break;
- case DARK_SURROUND:
- lpMod -> F = 0.8;
- lpMod -> c = 0.525;
- lpMod -> Nc = 0.8;
- break;
+ case DARK_SURROUND:
+ lpMod -> F = 0.8;
+ lpMod -> c = 0.525;
+ lpMod -> Nc = 0.8;
+ break;
- case DIM_SURROUND:
- lpMod -> F = 0.9;
- lpMod -> c = 0.59;
- lpMod -> Nc = 0.95;
- break;
+ case DIM_SURROUND:
+ lpMod -> F = 0.9;
+ lpMod -> c = 0.59;
+ lpMod -> Nc = 0.95;
+ break;
- default:
- // Average surround
- lpMod -> F = 1.0;
- lpMod -> c = 0.69;
- lpMod -> Nc = 1.0;
- }
+ default:
+ // Average surround
+ lpMod -> F = 1.0;
+ lpMod -> c = 0.69;
+ lpMod -> Nc = 1.0;
+ }
- lpMod -> n = compute_n(lpMod);
- lpMod -> z = compute_z(lpMod);
- lpMod -> Nbb = computeNbb(lpMod);
- lpMod -> FL = computeFL(lpMod);
+ lpMod -> n = compute_n(lpMod);
+ lpMod -> z = compute_z(lpMod);
+ lpMod -> Nbb = computeNbb(lpMod);
+ lpMod -> FL = computeFL(lpMod);
- if (lpMod -> D == D_CALCULATE) {
- lpMod -> D = computeD(lpMod);
- }
+ if (lpMod -> D == D_CALCULATE) {
+ lpMod -> D = computeD(lpMod);
+ }
- lpMod -> Ncb = lpMod -> Nbb;
+ lpMod -> Ncb = lpMod -> Nbb;
- lpMod -> adoptedWhite = XYZtoCAT02(lpMod -> adoptedWhite);
- lpMod -> adoptedWhite = ChromaticAdaptation(lpMod -> adoptedWhite, lpMod);
- lpMod -> adoptedWhite = CAT02toHPE(lpMod -> adoptedWhite);
- lpMod -> adoptedWhite = NonlinearCompression(lpMod -> adoptedWhite, lpMod);
+ lpMod -> adoptedWhite = XYZtoCAT02(lpMod -> adoptedWhite);
+ lpMod -> adoptedWhite = ChromaticAdaptation(lpMod -> adoptedWhite, lpMod);
+ lpMod -> adoptedWhite = CAT02toHPE(lpMod -> adoptedWhite);
+ lpMod -> adoptedWhite = NonlinearCompression(lpMod -> adoptedWhite, lpMod);
- return (cmsHANDLE) lpMod;
+ return (cmsHANDLE) lpMod;
}
{
cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel;
- if (lpMod) _cmsFree(lpMod ->ContextID, lpMod);
+ if (lpMod) _cmsFree(lpMod ->ContextID, lpMod);
}
void CMSEXPORT cmsCIECAM02Forward(cmsHANDLE hModel, const cmsCIEXYZ* pIn, cmsJCh* pOut)
-{
+{
CAM02COLOR clr;
cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel;
-
- _cmsAssert(lpMod != NULL);
- _cmsAssert(pIn != NULL);
- _cmsAssert(pOut != NULL);
+
+ _cmsAssert(lpMod != NULL);
+ _cmsAssert(pIn != NULL);
+ _cmsAssert(pOut != NULL);
+
+ memset(&clr, 0, sizeof(clr));
clr.XYZ[0] = pIn ->X;
clr.XYZ[1] = pIn ->Y;
clr.XYZ[2] = pIn ->Z;
-
+
clr = XYZtoCAT02(clr);
clr = ChromaticAdaptation(clr, lpMod);
clr = CAT02toHPE(clr);
clr = NonlinearCompression(clr, lpMod);
clr = ComputeCorrelates(clr, lpMod);
-
+
pOut ->J = clr.J;
pOut ->C = clr.C;
- pOut ->h = clr.h;
+ pOut ->h = clr.h;
}
void CMSEXPORT cmsCIECAM02Reverse(cmsHANDLE hModel, const cmsJCh* pIn, cmsCIEXYZ* pOut)
CAM02COLOR clr;
cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel;
- _cmsAssert(lpMod != NULL);
- _cmsAssert(pIn != NULL);
- _cmsAssert(pOut != NULL);
+ _cmsAssert(lpMod != NULL);
+ _cmsAssert(pIn != NULL);
+ _cmsAssert(pOut != NULL);
+
+ memset(&clr, 0, sizeof(clr));
clr.J = pIn -> J;
clr.C = pIn -> C;
clr.h = pIn -> h;
-
+
clr = InverseCorrelates(clr, lpMod);
clr = InverseNonlinearity(clr, lpMod);
clr = HPEtoCAT02(clr);
clr = InverseChromaticAdaptation(clr, lpMod);
clr = CAT02toXYZ(clr);
-
+
pOut ->X = clr.XYZ[0];
pOut ->Y = clr.XYZ[1];
pOut ->Z = clr.XYZ[2];
}
-
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// IT8.7 / CGATS.17-200x handling -----------------------------------------------------------------------------
-#define MAXID 128 // Max lenght of identifier
-#define MAXSTR 1024 // Max lenght of string
+#define MAXID 128 // Max length of identifier
+#define MAXSTR 1024 // Max length of string
#define MAXTABLES 255 // Max Number of tables in a single stream
#define MAXINCLUDE 20 // Max number of nested includes
# define DIR_CHAR '/'
#endif
+
// Symbols
-typedef enum {
+typedef enum {
SNONE,
SINUM, // Integer
// How to write the value
-typedef enum {
+typedef enum {
WRITE_UNCOOKED,
- WRITE_STRINGIFY,
+ WRITE_STRINGIFY,
WRITE_HEXADECIMAL,
WRITE_BINARY,
WRITE_PAIR
cmsUInt8Number* Block;
cmsUInt32Number BlockSize;
cmsUInt32Number Used;
-
+
} SUBALLOCATOR;
// Table. Each individual table can hold properties and rows & cols
typedef struct _Table {
-
+
+ char SheetType[MAXSTR]; // The first row of the IT8 (the type)
+
int nSamples, nPatches; // Cols, Rows
int SampleID; // Pos of ID
-
+
KEYVALUE* HeaderList; // The properties
-
+
char** DataFormat; // The binary stream descriptor
- char** Data; // The binary stream
+ char** Data; // The binary stream
} TABLE;
FILE* Stream; // File stream or NULL if holded in memory
} FILECTX;
-// This struct hold all information about an open IT8 handler.
+// This struct hold all information about an open IT8 handler.
typedef struct {
- char SheetType[MAXSTR]; // The first row of the IT8 (the type)
cmsUInt32Number TablesCount; // How many tables in this stream
cmsUInt32Number nTable; // The actual table
// Parser state machine
SYMBOL sy; // Current symbol
int ch; // Current character
-
+
int inum; // integer value
cmsFloat64Number dnum; // real value
char id[MAXID]; // identifier
// Allowed keywords & datasets. They have visibility on whole stream
KEYVALUE* ValidKeywords;
KEYVALUE* ValidSampleID;
-
+
char* Source; // Points to loc. being parsed
int lineno; // line counter for error reporting
-
+
FILECTX* FileStack[MAXINCLUDE]; // Stack of files being parsed
int IncludeSP; // Include Stack Pointer
// The keyword->symbol translation table. Sorting is required.
static const KEYWORD TabKeys[] = {
-
+
{"$INCLUDE", SINCLUDE}, // This is an extension!
{".INCLUDE", SINCLUDE}, // This is an extension!
// below properties are new in recent specs:
- {"MEASUREMENT_GEOMETRY", WRITE_STRINGIFY}, // The type of measurement, either reflection or transmission, should be indicated
- // along with details of the geometry and the aperture size and shape. For example,
- // for transmission measurements it is important to identify 0/diffuse, diffuse/0,
- // opal or integrating sphere, etc. For reflection it is important to identify 0/45,
+ {"MEASUREMENT_GEOMETRY", WRITE_STRINGIFY}, // The type of measurement, either reflection or transmission, should be indicated
+ // along with details of the geometry and the aperture size and shape. For example,
+ // for transmission measurements it is important to identify 0/diffuse, diffuse/0,
+ // opal or integrating sphere, etc. For reflection it is important to identify 0/45,
// 45/0, sphere (specular included or excluded), etc.
- {"FILTER", WRITE_STRINGIFY}, // Identifies the use of physical filter(s) during measurement. Typically used to
+ {"FILTER", WRITE_STRINGIFY}, // Identifies the use of physical filter(s) during measurement. Typically used to
// denote the use of filters such as none, D65, Red, Green or Blue.
- {"POLARIZATION", WRITE_STRINGIFY}, // Identifies the use of a physical polarization filter during measurement. Allowed
+ {"POLARIZATION", WRITE_STRINGIFY}, // Identifies the use of a physical polarization filter during measurement. Allowed
// values are {"yes\94, \93white\94, \93none\94 or \93na\94.
- {"WEIGHTING_FUNCTION", WRITE_PAIR}, // Indicates such functions as: the CIE standard observer functions used in the
- // calculation of various data parameters (2 degree and 10 degree), CIE standard
+ {"WEIGHTING_FUNCTION", WRITE_PAIR}, // Indicates such functions as: the CIE standard observer functions used in the
+ // calculation of various data parameters (2 degree and 10 degree), CIE standard
// illuminant functions used in the calculation of various data parameters (e.g., D50,
- // D65, etc.), density status response, etc. If used there shall be at least one
- // name-value pair following the WEIGHTING_FUNCTION tag/keyword. The first attribute
+ // D65, etc.), density status response, etc. If used there shall be at least one
+ // name-value pair following the WEIGHTING_FUNCTION tag/keyword. The first attribute
// in the set shall be {"name" and shall identify the particular parameter used.
- // The second shall be {"value" and shall provide the value associated with that name.
- // For ASCII data, a string containing the Name and Value attribute pairs shall follow
- // the weighting function keyword. A semi-colon separates attribute pairs from each
+ // The second shall be {"value" and shall provide the value associated with that name.
+ // For ASCII data, a string containing the Name and Value attribute pairs shall follow
+ // the weighting function keyword. A semi-colon separates attribute pairs from each
// other and within the attribute the name and value are separated by a comma.
- {"COMPUTATIONAL_PARAMETER", WRITE_PAIR}, // Parameter that is used in computing a value from measured data. Name is the name
- // of the calculation, parameter is the name of the parameter used in the calculation
+ {"COMPUTATIONAL_PARAMETER", WRITE_PAIR}, // Parameter that is used in computing a value from measured data. Name is the name
+ // of the calculation, parameter is the name of the parameter used in the calculation
// and value is the value of the parameter.
{"TARGET_TYPE", WRITE_STRINGIFY}, // The type of target being measured, e.g. IT8.7/1, IT8.7/3, user defined, etc.
// Predefined sample types on dataset
static const char* PredefinedSampleID[] = {
"SAMPLE_ID", // Identifies sample that data represents
- "STRING", // Identifies label, or other non-machine readable value.
+ "STRING", // Identifies label, or other non-machine readable value.
// Value must begin and end with a " symbol
"CMYK_C", // Cyan component of CMYK data expressed as a percentage
#define NUMPREDEFINEDSAMPLEID (sizeof(PredefinedSampleID)/sizeof(char *))
-//Forward declaration of some internal functions
+//Forward declaration of some internal functions
static void* AllocChunk(cmsIT8* it8, cmsUInt32Number size);
-// Checks if c is a separator
+// Checks whatever c is a separator
static
cmsBool isseparator(int c)
{
- return (c == ' ') || (c == '\t') || (c == '\r');
+ return (c == ' ') || (c == '\t') ;
}
-// Checks whatever if c is a valid identifier char
-static
+// Checks whatever c is a valid identifier char
+static
cmsBool ismiddle(int c)
{
return (!isseparator(c) && (c != '#') && (c !='\"') && (c != '\'') && (c > 32) && (c < 127));
}
-// Checks whatsever if c is a valid identifier middle char.
+// Checks whatsever c is a valid identifier middle char.
static
cmsBool isidchar(int c)
{
return isalnum(c) || ismiddle(c);
}
-// Checks whatsever if c is a valid identifier first char.
+// Checks whatsever c is a valid identifier first char.
static
cmsBool isfirstidchar(int c)
{
if(path == NULL)
return FALSE;
- if (path[0] == 0)
+ if (path[0] == 0)
return FALSE;
strncpy(ThreeChars, path, 3);
return FALSE;
}
+
// Makes a file path based on a given reference path
// NOTE: this function doesn't check if the path exists or even if it's legal
-static
+static
cmsBool BuildAbsolutePath(const char *relPath, const char *basePath, char *buffer, cmsUInt32Number MaxLen)
{
char *tail;
return TRUE;
}
- // No, search for last
- strncpy(buffer, basePath, MaxLen);
+ // No, search for last
+ strncpy(buffer, basePath, MaxLen);
buffer[MaxLen-1] = 0;
tail = strrchr(buffer, DIR_CHAR);
if (len >= MaxLen) return FALSE;
// No need to assure zero terminator over here
- strncpy(tail + 1, relPath, MaxLen - len);
+ strncpy(tail + 1, relPath, MaxLen - len);
- return TRUE;
+ return TRUE;
}
static
const char* NoMeta(const char* str)
{
- if (strchr(str, '%') != NULL)
+ if (strchr(str, '%') != NULL)
return "**** CORRUPTED FORMAT STRING ***";
return str;
} else
it8 ->ch = 0; // EOF
- }
+ }
}
else {
it8->ch = *it8->Source;
if (it8->ch == '.') { // Decimal point
cmsFloat64Number frac = 0.0; // fraction
- int prec = 0; // precision
+ int prec = 0; // precision
NextCh(it8); // Eats dec. point
}
}
+// Parses a float number
+// This can not call directly atof because it uses locale dependant
+// parsing, while CCMX files always use . as decimal separator
+static
+cmsFloat64Number ParseFloatNumber(const char *Buffer)
+{
+ cmsFloat64Number dnum = 0.0;
+ int sign = 1;
+
+ // keep safe
+ if (Buffer == NULL) return 0.0;
+
+ if (*Buffer == '-' || *Buffer == '+') {
+
+ sign = (*Buffer == '-') ? -1 : 1;
+ Buffer++;
+ }
+
+
+ while (*Buffer && isdigit((int) *Buffer)) {
+
+ dnum = dnum * 10.0 + (*Buffer - '0');
+ if (*Buffer) Buffer++;
+ }
+
+ if (*Buffer == '.') {
+
+ cmsFloat64Number frac = 0.0; // fraction
+ int prec = 0; // precission
+
+ if (*Buffer) Buffer++;
+
+ while (*Buffer && isdigit((int) *Buffer)) {
+
+ frac = frac * 10.0 + (*Buffer - '0');
+ prec++;
+ if (*Buffer) Buffer++;
+ }
+
+ dnum = dnum + (frac / xpow10(prec));
+ }
+
+ // Exponent, example 34.00E+20
+ if (*Buffer && toupper(*Buffer) == 'E') {
+
+ int e;
+ int sgn;
+
+ if (*Buffer) Buffer++;
+ sgn = 1;
+
+ if (*Buffer == '-') {
+
+ sgn = -1;
+ if (*Buffer) Buffer++;
+ }
+ else
+ if (*Buffer == '+') {
+
+ sgn = +1;
+ if (*Buffer) Buffer++;
+ }
+
+ e = 0;
+ while (*Buffer && isdigit((int) *Buffer)) {
+
+ if ((cmsFloat64Number) e * 10L < INT_MAX)
+ e = e * 10 + (*Buffer - '0');
+
+ if (*Buffer) Buffer++;
+ }
+
+ e = sgn*e;
+ dnum = dnum * xpow10(e);
+ }
+
+ return sign * dnum;
+}
// Reads next symbol
int sng;
do {
-
+
while (isseparator(it8->ch))
NextCh(it8);
-
+
if (isfirstidchar(it8->ch)) { // Identifier
-
+
k = 0;
idptr = it8->id;
-
+
do {
-
+
if (++k < MAXID) *idptr++ = (char) it8->ch;
-
+
NextCh(it8);
-
+
} while (isidchar(it8->ch));
-
+
*idptr = '\0';
-
-
+
+
key = BinSrchKey(it8->id);
if (key == SNONE) it8->sy = SIDENT;
else it8->sy = key;
-
+
}
else // Is a number?
if (isdigit(it8->ch) || it8->ch == '.' || it8->ch == '-' || it8->ch == '+')
{
int sign = 1;
-
+
if (it8->ch == '-') {
sign = -1;
NextCh(it8);
}
-
+
it8->inum = 0;
it8->sy = SINUM;
-
+
if (it8->ch == '0') { // 0xnnnn (Hexa) or 0bnnnn (Binary)
-
+
NextCh(it8);
if (toupper(it8->ch) == 'X') {
int j;
-
+
NextCh(it8);
while (isxdigit(it8->ch))
{
it8->ch = toupper(it8->ch);
if (it8->ch >= 'A' && it8->ch <= 'F') j = it8->ch -'A'+10;
else j = it8->ch - '0';
-
+
if ((long) it8->inum * 16L > (long) INT_MAX)
{
SynError(it8, "Invalid hexadecimal number");
return;
}
-
+
it8->inum = it8->inum * 16 + j;
NextCh(it8);
}
return;
}
-
+
if (toupper(it8->ch) == 'B') { // Binary
-
+
int j;
-
+
NextCh(it8);
while (it8->ch == '0' || it8->ch == '1')
{
j = it8->ch - '0';
-
+
if ((long) it8->inum * 2L > (long) INT_MAX)
{
SynError(it8, "Invalid binary number");
return;
}
-
+
it8->inum = it8->inum * 2 + j;
NextCh(it8);
}
return;
}
}
-
+
while (isdigit(it8->ch)) {
it8->dnum *= sign;
return;
}
-
+
it8->inum = it8->inum * 10 + (it8->ch - '0');
NextCh(it8);
}
-
+
if (it8->ch == '.') {
-
+
ReadReal(it8, it8->inum);
it8->sy = SDNUM;
it8->dnum *= sign;
return;
}
-
+
it8 -> inum *= sign;
// Special case. Numbers followed by letters are taken as identifiers
k = (int) strlen(it8 ->id);
idptr = it8 ->id + k;
do {
-
+
if (++k < MAXID) *idptr++ = (char) it8->ch;
-
+
NextCh(it8);
-
+
} while (isidchar(it8->ch));
-
- *idptr = '\0';
+
+ *idptr = '\0';
it8->sy = SIDENT;
}
return;
-
+
}
else
switch ((int) it8->ch) {
case -1:
it8->sy = SEOF;
break;
-
-
- // Next line
+
+
+ // Next line
+ case '\r':
+ NextCh(it8);
+ if (it8 ->ch == '\n')
+ NextCh(it8);
+ it8->sy = SEOLN;
+ it8->lineno++;
+ break;
+
case '\n':
NextCh(it8);
it8->sy = SEOLN;
it8->lineno++;
break;
-
+
// Comment
case '#':
NextCh(it8);
- while (it8->ch && it8->ch != '\n')
+ while (it8->ch && it8->ch != '\n' && it8->ch != '\r')
NextCh(it8);
-
+
it8->sy = SCOMMENT;
break;
-
+
// String.
case '\'':
case '\"':
sng = it8->ch;
k = 0;
NextCh(it8);
-
+
while (k < MAXSTR && it8->ch != sng) {
-
+
if (it8->ch == '\n'|| it8->ch == '\r') k = MAXSTR+1;
- else {
+ else {
*idptr++ = (char) it8->ch;
NextCh(it8);
k++;
}
}
-
+
it8->sy = SSTRING;
*idptr = '\0';
NextCh(it8);
break;
-
-
+
+
default:
- SynError(it8, "Unrecognized character: 0x%x", it8 ->ch);
- return;
+ SynError(it8, "Unrecognized character: 0x%x", it8 ->ch);
+ return;
}
-
+
} while (it8->sy == SCOMMENT);
// Handle the include special token
// TODO: how to manage out-of-memory conditions?
}
- if (BuildAbsolutePath(it8->str,
- it8->FileStack[it8->IncludeSP]->FileName,
+ if (BuildAbsolutePath(it8->str,
+ it8->FileStack[it8->IncludeSP]->FileName,
FileNest->FileName, cmsMAX_PATH-1) == FALSE) {
SynError(it8, "File path too long");
return;
it8->IncludeSP++;
it8 ->ch = ' ';
- InSymbol(it8);
+ InSymbol(it8);
}
-
+
}
// Checks end of line separator
{
switch (it8->sy) {
- case SIDENT: strncpy(Buffer, it8->id, max);
+ case SEOLN: // Empty value
+ Buffer[0]=0;
+ break;
+ case SIDENT: strncpy(Buffer, it8->id, max);
Buffer[max-1]=0;
break;
case SINUM: snprintf(Buffer, max, "%d", it8 -> inum); break;
case SDNUM: snprintf(Buffer, max, it8->DoubleFormatter, it8 -> dnum); break;
- case SSTRING: strncpy(Buffer, it8->str, max);
+ case SSTRING: strncpy(Buffer, it8->str, max);
Buffer[max-1] = 0;
break;
static
TABLE* GetTable(cmsIT8* it8)
-{
+{
if ((it8 -> nTable >= it8 ->TablesCount)) {
SynError(it8, "Table %d out of sequence", it8 -> nTable);
return it8 -> Tab;
- }
+ }
return it8 ->Tab + it8 ->nTable;
}
}
if (it8->MemoryBlock)
- _cmsFree(it8 ->ContextID, it8->MemoryBlock);
+ _cmsFree(it8 ->ContextID, it8->MemoryBlock);
_cmsFree(it8 ->ContextID, it8);
}
cmsUInt32Number Free = it8 ->Allocator.BlockSize - it8 ->Allocator.Used;
cmsUInt8Number* ptr;
- size = _cmsALIGNLONG(size);
+ size = _cmsALIGNMEM(size);
if (size > Free) {
it8 ->Allocator.Used = 0;
it8 ->Allocator.Block = (cmsUInt8Number*) AllocBigBlock(it8, it8 ->Allocator.BlockSize);
}
-
+
ptr = it8 ->Allocator.Block + it8 ->Allocator.Used;
it8 ->Allocator.Used += size;
return (void*) ptr;
-
+
}
if (ptr) strncpy (ptr, str, Size-1);
return ptr;
-}
+}
// Searches through linked list
if (*Key != '#') { // Comments are ignored
if (cmsstrcasecmp(Key, p->Keyword) == 0)
- break;
- }
+ break;
}
+ }
if (p == NULL)
return FALSE;
for (; p != NULL; p = p->NextSubkey) {
+ if (p ->Subkey == NULL) continue;
+
if (LastPtr) *LastPtr = p;
if (cmsstrcasecmp(Subkey, p->Subkey) == 0)
- return TRUE;
- }
+ return TRUE;
+ }
return FALSE;
}
KEYVALUE* last;
- // Check if property is already in list
+ // Check if property is already in list
if (IsAvailableOnList(*Head, Key, Subkey, &p)) {
// This may work for editing properties
- // return SynError(it8, "duplicate key <%s>", Key);
+ // return SynError(it8, "duplicate key <%s>", Key);
}
else {
p = (KEYVALUE*) AllocChunk(it8, sizeof(KEYVALUE));
if (p == NULL)
{
- SynError(it8, "AddToList: out of memory");
+ SynError(it8, "AddToList: out of memory");
return NULL;
}
else
{
if (Subkey != NULL && last != NULL) {
-
+
last->NextSubkey = p;
// If Subkey is not null, then last is the last property with the same key,
// but not necessarily is the last property in the list, so we need to move
// to the actual list end
- while (last->Next != NULL)
+ while (last->Next != NULL)
last = last->Next;
}
t->HeaderList = NULL;
t->DataFormat = NULL;
t->Data = NULL;
-
+
it8 ->TablesCount++;
}
it8 ->nTable = nTable;
- return nTable;
+ return (cmsInt32Number) nTable;
}
cmsHANDLE CMSEXPORT cmsIT8Alloc(cmsContext ContextID)
{
cmsIT8* it8;
- int i;
+ cmsUInt32Number i;
it8 = (cmsIT8*) _cmsMallocZero(ContextID, sizeof(cmsIT8));
if (it8 == NULL) return NULL;
AllocTable(it8);
-
+
it8->MemoryBlock = NULL;
it8->MemorySink = NULL;
-
+
it8 ->nTable = 0;
it8->ContextID = ContextID;
it8->Allocator.Used = 0;
it8->Allocator.Block = NULL;
- it8->Allocator.BlockSize = 0;
+ it8->Allocator.BlockSize = 0;
it8->ValidKeywords = NULL;
it8->ValidSampleID = NULL;
it8 -> lineno = 1;
strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT);
- strcpy(it8->SheetType, "CGATS.17");
+ cmsIT8SetSheetType((cmsHANDLE) it8, "CGATS.17");
// Initialize predefined properties & data
-
+
for (i=0; i < NUMPREDEFINEDPROPS; i++)
AddAvailableProperty(it8, PredefinedProperties[i].id, PredefinedProperties[i].as);
const char* CMSEXPORT cmsIT8GetSheetType(cmsHANDLE hIT8)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
-
- return it8 ->SheetType;
-
+ return GetTable((cmsIT8*) hIT8)->SheetType;
}
cmsBool CMSEXPORT cmsIT8SetSheetType(cmsHANDLE hIT8, const char* Type)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
+ TABLE* t = GetTable((cmsIT8*) hIT8);
- strncpy(it8 ->SheetType, Type, MAXSTR-1);
- it8 ->SheetType[MAXSTR-1] = 0;
+ strncpy(t ->SheetType, Type, MAXSTR-1);
+ t ->SheetType[MAXSTR-1] = 0;
return TRUE;
}
return AddToList(it8, &GetTable(it8)->HeaderList, "# ", NULL, Val, WRITE_UNCOOKED) != NULL;
}
-
-
// Sets a property
cmsBool CMSEXPORT cmsIT8SetPropertyStr(cmsHANDLE hIT8, const char* Key, const char *Val)
{
return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Val, WRITE_STRINGIFY) != NULL;
}
-
cmsBool CMSEXPORT cmsIT8SetPropertyDbl(cmsHANDLE hIT8, const char* cProp, cmsFloat64Number Val)
{
cmsIT8* it8 = (cmsIT8*) hIT8;
char Buffer[1024];
-
+
sprintf(Buffer, it8->DoubleFormatter, Val);
- return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_UNCOOKED) != NULL;
+ return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_UNCOOKED) != NULL;
}
cmsBool CMSEXPORT cmsIT8SetPropertyHex(cmsHANDLE hIT8, const char* cProp, cmsUInt32Number Val)
{
cmsIT8* it8 = (cmsIT8*) hIT8;
char Buffer[1024];
-
- sprintf(Buffer, "%d", Val);
- return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_HEXADECIMAL) != NULL;
+ sprintf(Buffer, "%u", Val);
+
+ return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_HEXADECIMAL) != NULL;
}
cmsBool CMSEXPORT cmsIT8SetPropertyUncooked(cmsHANDLE hIT8, const char* Key, const char* Buffer)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
-
+ cmsIT8* it8 = (cmsIT8*) hIT8;
+
return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Buffer, WRITE_UNCOOKED) != NULL;
}
{
const char *v = cmsIT8GetProperty(hIT8, cProp);
- if (v) return atof(v);
- else return 0.0;
+ if (v == NULL) return 0.0;
+
+ return ParseFloatNumber(v);
}
const char* CMSEXPORT cmsIT8GetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char *SubKey)
t -> nSamples = 10;
}
- t -> DataFormat = (char**) AllocChunk (it8, (t->nSamples + 1) * sizeof(char *));
+ t -> DataFormat = (char**) AllocChunk (it8, ((cmsUInt32Number) t->nSamples + 1) * sizeof(char *));
if (t->DataFormat == NULL) {
SynError(it8, "AllocateDataFormat: Unable to allocate dataFormat array");
SynError(it8, "More than NUMBER_OF_FIELDS fields.");
return FALSE;
}
-
- if (t->DataFormat) {
+
+ if (t->DataFormat) {
t->DataFormat[n] = AllocString(it8, label);
}
t-> nSamples = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_FIELDS"));
t-> nPatches = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_SETS"));
- t-> Data = (char**)AllocChunk (it8, (t->nSamples + 1) * (t->nPatches + 1) *sizeof (char*));
+ t-> Data = (char**)AllocChunk (it8, ((cmsUInt32Number) t->nSamples + 1) * ((cmsUInt32Number) t->nPatches + 1) *sizeof (char*));
if (t->Data == NULL) {
SynError(it8, "AllocateDataSet: Unable to allocate data array");
TABLE* t = GetTable(it8);
int nSamples = t -> nSamples;
int nPatches = t -> nPatches;
-
+
if (nSet >= nPatches || nField >= nSamples)
return NULL;
if (nSet > t -> nPatches || nSet < 0) {
- return SynError(it8, "Patch %d out of range, there are %d patches", nSet, t -> nPatches);
+ return SynError(it8, "Patch %d out of range, there are %d patches", nSet, t -> nPatches);
}
if (nField > t ->nSamples || nField < 0) {
return SynError(it8, "Sample %d out of range, there are %d samples", nField, t ->nSamples);
-
+
}
-
+
t->Data [nSet * t -> nSamples + nField] = AllocString(it8, Val);
return TRUE;
}
{
cmsUInt32Number len;
- if (str == NULL)
+ if (str == NULL)
str = " ";
-
- // Lenghth to write
+
+ // Length to write
len = (cmsUInt32Number) strlen(str);
f ->Used += len;
-
+
if (f ->stream) { // Should I write it to a file?
if (fwrite(str, 1, len, f->stream) != len) {
cmsSignalError(0, cmsERROR_WRITE, "Write to file error in CGATS parser");
return;
- }
-
+ }
+
}
else { // Or to a memory block?
-
+
if (f ->Base) { // Am I just counting the bytes?
-
+
if (f ->Used > f ->Max) {
cmsSignalError(0, cmsERROR_WRITE, "Write to memory overflows in CGATS parser");
return;
}
-
+
memmove(f ->Ptr, str, len);
f->Ptr += len;
}
-
- }
+
+ }
}
KEYVALUE* p;
TABLE* t = GetTable(it8);
-
+ // Writes the type
+ WriteStr(fp, t->SheetType);
+ WriteStr(fp, "\n");
+
for (p = t->HeaderList; (p != NULL); p = p->Next)
{
if (*p ->Keyword == '#') {
char* Pt;
-
+
WriteStr(fp, "#\n# ");
for (Pt = p ->Value; *Pt; Pt++) {
- Writef(fp, "%c", *Pt);
+ Writef(fp, "%c", *Pt);
if (*Pt == '\n') {
WriteStr(fp, "# ");
}
}
-
+
WriteStr(fp, "\n#\n");
continue;
}
switch (p ->WriteAs) {
case WRITE_UNCOOKED:
- Writef(fp, "\t%s", p ->Value);
+ Writef(fp, "\t%s", p ->Value);
break;
case WRITE_STRINGIFY:
// Saves whole file
cmsBool CMSEXPORT cmsIT8SaveToFile(cmsHANDLE hIT8, const char* cFileName)
{
- SAVESTREAM sd;
+ SAVESTREAM sd;
cmsUInt32Number i;
cmsIT8* it8 = (cmsIT8*) hIT8;
sd.stream = fopen(cFileName, "wt");
if (!sd.stream) return FALSE;
-
- WriteStr(&sd, it8->SheetType);
- WriteStr(&sd, "\n");
+
for (i=0; i < it8 ->TablesCount; i++) {
cmsIT8SetTable(hIT8, i);
WriteDataFormat(&sd, it8);
WriteData(&sd, it8);
}
-
+
if (fclose(sd.stream) != 0) return FALSE;
return TRUE;
// Saves to memory
cmsBool CMSEXPORT cmsIT8SaveToMem(cmsHANDLE hIT8, void *MemPtr, cmsUInt32Number* BytesNeeded)
{
- SAVESTREAM sd;
+ SAVESTREAM sd;
cmsUInt32Number i;
cmsIT8* it8 = (cmsIT8*) hIT8;
sd.Used = 0;
- if (sd.Base)
+ if (sd.Base)
sd.Max = *BytesNeeded; // Write to memory?
- else
+ else
sd.Max = 0; // Just counting the needed bytes
-
- WriteStr(&sd, it8->SheetType);
- WriteStr(&sd, "\n");
+
for (i=0; i < it8 ->TablesCount; i++) {
- cmsIT8SetTable(hIT8, i);
- WriteHeader(it8, &sd);
- WriteDataFormat(&sd, it8);
- WriteData(&sd, it8);
+ cmsIT8SetTable(hIT8, i);
+ WriteHeader(it8, &sd);
+ WriteDataFormat(&sd, it8);
+ WriteData(&sd, it8);
}
-
+
sd.Used++; // The \0 at the very end
if (sd.Base)
- sd.Ptr = 0;
+ *sd.Ptr = 0;
*BytesNeeded = sd.Used;
static
cmsBool DataFormatSection(cmsIT8* it8)
{
- int iField = 0;
+ int iField = 0;
TABLE* t = GetTable(it8);
InSymbol(it8); // Eats "BEGIN_DATA_FORMAT"
it8->sy != SEOLN &&
it8->sy != SEOF &&
it8->sy != SSYNERROR) {
-
+
if (it8->sy != SIDENT) {
-
- return SynError(it8, "Sample type expected");
+
+ return SynError(it8, "Sample type expected");
}
-
+
if (!SetDataFormat(it8, iField, it8->id)) return FALSE;
iField++;
-
+
InSymbol(it8);
SkipEOLN(it8);
}
if (iField != t ->nSamples) {
SynError(it8, "Count mismatch. NUMBER_OF_FIELDS was %d, found %d\n", t ->nSamples, iField);
-
+
}
return TRUE;
if (iField >= t -> nSamples) {
iField = 0;
iSet++;
-
+
}
if (it8->sy != SEND_DATA && it8->sy != SEOF) {
return FALSE;
iField++;
-
+
InSymbol(it8);
- SkipEOLN(it8);
+ SkipEOLN(it8);
}
}
SkipEOLN(it8);
Skip(it8, SEND_DATA);
SkipEOLN(it8);
-
+
// Check for data completion.
if ((iSet+1) != t -> nPatches)
case SKEYWORD:
InSymbol(it8);
- if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;
+ if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;
if (!AddAvailableProperty(it8, Buffer, WRITE_UNCOOKED)) return FALSE;
InSymbol(it8);
break;
case SDATA_FORMAT_ID:
InSymbol(it8);
- if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;
+ if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;
if (!AddAvailableSampleID(it8, Buffer)) return FALSE;
InSymbol(it8);
break;
case SIDENT:
strncpy(VarName, it8->id, MAXID-1);
VarName[MAXID-1] = 0;
-
+
if (!IsAvailableOnList(it8-> ValidKeywords, VarName, NULL, &Key)) {
-#ifdef CMS_STRICT_CGATS
+#ifdef CMS_STRICT_CGATS
return SynError(it8, "Undefined keyword '%s'", VarName);
#else
Key = AddAvailableProperty(it8, VarName, WRITE_UNCOOKED);
if (!GetVal(it8, Buffer, MAXSTR-1, "Property data expected")) return FALSE;
if(Key->WriteAs != WRITE_PAIR) {
- AddToList(it8, &GetTable(it8)->HeaderList, VarName, NULL, Buffer,
+ AddToList(it8, &GetTable(it8)->HeaderList, VarName, NULL, Buffer,
(it8->sy == SSTRING) ? WRITE_STRINGIFY : WRITE_UNCOOKED);
}
else {
for (Subkey = Buffer; Subkey != NULL; Subkey = Nextkey)
{
char *Value, *temp;
-
+
// identify token pair boundary
Nextkey = (char*) strchr(Subkey, ';');
if(Nextkey)
// gobble any space at the right
temp = Value + strlen(Value) - 1;
- while(*temp == ' ') *temp-- = '\0';
+ while(*temp == ' ') *temp-- = '\0';
// trim the strings from the left
Subkey += strspn(Subkey, " ");
AddToList(it8, &GetTable(it8)->HeaderList, VarName, Subkey, Value, WRITE_PAIR);
}
}
-
+
InSymbol(it8);
break;
-
+
case SEOLN: break;
default:
static
-cmsBool ParseIT8(cmsIT8* it8, cmsBool nosheet)
+void ReadType(cmsIT8* it8, char* SheetTypePtr)
{
- char* SheetTypePtr = it8 ->SheetType;
-
- if (nosheet == 0) {
-
// First line is a very special case.
while (isseparator(it8->ch))
NextCh(it8);
-
+
while (it8->ch != '\r' && it8 ->ch != '\n' && it8->ch != '\t' && it8 -> ch != -1) {
*SheetTypePtr++= (char) it8 ->ch;
NextCh(it8);
}
- }
*SheetTypePtr = 0;
+}
+
+
+static
+cmsBool ParseIT8(cmsIT8* it8, cmsBool nosheet)
+{
+ char* SheetTypePtr = it8 ->Tab[0].SheetType;
+
+ if (nosheet == 0) {
+ ReadType(it8, SheetTypePtr);
+ }
+
InSymbol(it8);
-
+
SkipEOLN(it8);
while (it8-> sy != SEOF &&
case SBEGIN_DATA:
if (!DataSection(it8)) return FALSE;
-
+
if (it8 -> sy != SEOF) {
AllocTable(it8);
it8 ->nTable = it8 ->TablesCount - 1;
+
+ // Read sheet type if present. We only support identifier and string.
+ // <ident> <eoln> is a type string
+ // anything else, is not a type string
+ if (nosheet == 0) {
+
+ if (it8 ->sy == SIDENT) {
+
+ // May be a type sheet or may be a prop value statement. We cannot use insymbol in
+ // this special case...
+ while (isseparator(it8->ch))
+ NextCh(it8);
+
+ // If a newline is found, then this is a type string
+ if (it8 ->ch == '\n' || it8->ch == '\r') {
+
+ cmsIT8SetSheetType(it8, it8 ->id);
+ InSymbol(it8);
+ }
+ else
+ {
+ // It is not. Just continue
+ cmsIT8SetSheetType(it8, "");
+ }
+ }
+ else
+ // Validate quoted strings
+ if (it8 ->sy == SSTRING) {
+ cmsIT8SetSheetType(it8, it8 ->str);
+ InSymbol(it8);
+ }
+ }
+
}
break;
TABLE* t = it8 ->Tab + j;
t -> SampleID = 0;
- it8 ->nTable = j;
+ it8 ->nTable = j;
for (idField = 0; idField < t -> nSamples; idField++)
{
if (cmsstrcasecmp(Fld, "SAMPLE_ID") == 0) {
- t -> SampleID = idField;
-
- for (i=0; i < t -> nPatches; i++) {
+ t -> SampleID = idField;
+
+ for (i=0; i < t -> nPatches; i++) {
char *Data = GetData(it8, i, idField);
if (Data) {
char Buffer[256];
-
+
strncpy(Buffer, Data, 255);
Buffer[255] = 0;
-
+
if (strlen(Buffer) <= strlen(Data))
strcpy(Data, Buffer);
else
SetData(it8, i, idField, Buffer);
}
- }
-
+ }
+
}
// "LABEL" is an extension. It keeps references to forward tables
-
+
if ((cmsstrcasecmp(Fld, "LABEL") == 0) || Fld[0] == '$' ) {
-
+
// Search for table references...
for (i=0; i < t -> nPatches; i++) {
char *Label = GetData(it8, i, idField);
-
- if (Label) {
-
+
+ if (Label) {
+
cmsUInt32Number k;
- // This is the label, search for a table containing
+ // This is the label, search for a table containing
// this property
for (k=0; k < it8 ->TablesCount; k++) {
char Buffer[256];
char *Type = p ->Value;
- int nTable = k;
+ int nTable = (int) k;
snprintf(Buffer, 255, "%s %d %s", Label, nTable, Type );
-
+
SetData(it8, i, idField, Buffer);
}
}
// Try to infere if the file is a CGATS/IT8 file at all. Read first line
// that should be something like some printable characters plus a \n
-
+// returns 0 if this is not like a CGATS, or an integer otherwise. This integer is the number of words in first line?
static
int IsMyBlock(cmsUInt8Number* Buffer, int n)
{
- int cols = 1, space = 0, quot = 0;
+ int words = 1, space = 0, quot = 0;
int i;
- if (n < 10) return FALSE; // Too small
+ if (n < 10) return 0; // Too small
if (n > 132)
n = 132;
{
case '\n':
case '\r':
- return quot == 1 || cols > 2 ? 0 : cols;
+ return ((quot == 1) || (words > 2)) ? 0 : words;
case '\t':
case ' ':
if(!quot && !space)
default:
if (Buffer[i] < 32) return 0;
if (Buffer[i] > 127) return 0;
- cols += space;
+ words += space;
space = 0;
break;
}
}
- return FALSE;
-
+ return 0;
}
Size = (cmsUInt32Number) fread(Ptr, 1, 132, fp);
- if (fclose(fp) != 0)
- return FALSE;
+ if (fclose(fp) != 0)
+ return FALSE;
Ptr[Size] = '\0';
cmsHANDLE CMSEXPORT cmsIT8LoadFromMem(cmsContext ContextID, void *Ptr, cmsUInt32Number len)
{
- cmsHANDLE hIT8;
+ cmsHANDLE hIT8;
cmsIT8* it8;
- int type;
+ int type;
- _cmsAssert(Ptr != NULL);
- _cmsAssert(len != 0);
+ _cmsAssert(Ptr != NULL);
+ _cmsAssert(len != 0);
type = IsMyBlock((cmsUInt8Number*)Ptr, len);
if (type == 0) return NULL;
-
+
hIT8 = cmsIT8Alloc(ContextID);
if (!hIT8) return NULL;
strncpy(it8->FileStack[0]->FileName, "", cmsMAX_PATH-1);
it8-> Source = it8 -> MemoryBlock;
- if (!ParseIT8(it8, type-1)) {
-
- cmsIT8Free(hIT8);
- return FALSE;
+ if (!ParseIT8(it8, type-1)) {
+
+ cmsIT8Free(hIT8);
+ return FALSE;
}
CookPointers(it8);
cmsHANDLE CMSEXPORT cmsIT8LoadFromFile(cmsContext ContextID, const char* cFileName)
{
- cmsHANDLE hIT8;
+ cmsHANDLE hIT8;
cmsIT8* it8;
- int type;
-
- _cmsAssert(cFileName != NULL);
+ int type;
+
+ _cmsAssert(cFileName != NULL);
- type = IsMyFile(cFileName);
+ type = IsMyFile(cFileName);
if (type == 0) return NULL;
hIT8 = cmsIT8Alloc(ContextID);
- it8 = (cmsIT8*) hIT8;
+ it8 = (cmsIT8*) hIT8;
if (!hIT8) return NULL;
it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
- if (!it8 ->FileStack[0]->Stream) {
+ if (!it8 ->FileStack[0]->Stream) {
cmsIT8Free(hIT8);
return NULL;
}
-
- strncpy(it8->FileStack[0]->FileName, cFileName, cmsMAX_PATH-1);
+
+ strncpy(it8->FileStack[0]->FileName, cFileName, cmsMAX_PATH-1);
it8->FileStack[0]->FileName[cmsMAX_PATH-1] = 0;
- if (!ParseIT8(it8, type-1)) {
-
+ if (!ParseIT8(it8, type-1)) {
+
fclose(it8 ->FileStack[0]->Stream);
- cmsIT8Free(hIT8);
- return NULL;
+ cmsIT8Free(hIT8);
+ return NULL;
}
CookPointers(it8);
it8 ->nTable = 0;
- if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
- cmsIT8Free(hIT8);
- return NULL;
- }
+ if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
+ cmsIT8Free(hIT8);
+ return NULL;
+ }
return hIT8;
int CMSEXPORT cmsIT8EnumDataFormat(cmsHANDLE hIT8, char ***SampleNames)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
- TABLE* t;
+ cmsIT8* it8 = (cmsIT8*) hIT8;
+ TABLE* t;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
- t = GetTable(it8);
+ t = GetTable(it8);
- if (SampleNames)
- *SampleNames = t -> DataFormat;
- return t -> nSamples;
+ if (SampleNames)
+ *SampleNames = t -> DataFormat;
+ return t -> nSamples;
}
cmsUInt32Number n;
char **Props;
TABLE* t;
-
- _cmsAssert(hIT8 != NULL);
- t = GetTable(it8);
+ _cmsAssert(hIT8 != NULL);
+
+ t = GetTable(it8);
// Pass#1 - count properties
cmsUInt32Number n;
const char **Props;
TABLE* t;
-
- _cmsAssert(hIT8 != NULL);
+
+ _cmsAssert(hIT8 != NULL);
- t = GetTable(it8);
+ t = GetTable(it8);
if(!IsAvailableOnList(t->HeaderList, cProp, NULL, &p)) {
*SubpropertyNames = 0;
for (i=0; i < t-> nPatches; i++) {
data = GetData(it8, i, t->SampleID);
-
+
if (data != NULL) {
if (cmsstrcasecmp(data, cPatch) == 0)
}
}
- // SynError(it8, "Couldn't find patch '%s'\n", cPatch);
+ // SynError(it8, "Couldn't find patch '%s'\n", cPatch);
return -1;
}
data = GetData(it8, i, t->SampleID);
- if (data == NULL)
+ if (data == NULL)
return i;
}
if (cmsstrcasecmp(fld, cSample) == 0)
return i;
}
-
+
return -1;
}
{
cmsIT8* it8 = (cmsIT8*) hIT8;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
return LocateSample(it8, cSample);
}
{
cmsIT8* it8 = (cmsIT8*) hIT8;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
return GetData(it8, row, col);
}
const char* Buffer;
Buffer = cmsIT8GetDataRowCol(hIT8, row, col);
-
- if (Buffer) {
- return atof(Buffer);
-
- } else
- return 0;
+ if (Buffer == NULL) return 0.0;
+ return ParseFloatNumber(Buffer);
}
cmsBool CMSEXPORT cmsIT8SetDataRowCol(cmsHANDLE hIT8, int row, int col, const char* Val)
{
cmsIT8* it8 = (cmsIT8*) hIT8;
-
- _cmsAssert(hIT8 != NULL);
- return SetData(it8, row, col, Val);
+ _cmsAssert(hIT8 != NULL);
+
+ return SetData(it8, row, col, Val);
}
cmsIT8* it8 = (cmsIT8*) hIT8;
char Buff[256];
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
sprintf(Buff, it8->DoubleFormatter, Val);
-
- return SetData(it8, row, col, Buff);
+
+ return SetData(it8, row, col, Buff);
}
-const char* CMSEXPORT cmsIT8GetData(cmsHANDLE hIT8, const char* cPatch, const char* cSample)
+const char* CMSEXPORT cmsIT8GetData(cmsHANDLE hIT8, const char* cPatch, const char* cSample)
{
cmsIT8* it8 = (cmsIT8*) hIT8;
int iField, iSet;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
iField = LocateSample(it8, cSample);
- if (iField < 0) {
+ if (iField < 0) {
return NULL;
}
iSet = LocatePatch(it8, cPatch);
- if (iSet < 0) {
+ if (iSet < 0) {
return NULL;
}
const char* Buffer;
Buffer = cmsIT8GetData(it8, cPatch, cSample);
-
- if (Buffer) {
- return atof(Buffer);
-
- } else {
-
- return 0;
- }
+ return ParseFloatNumber(Buffer);
}
cmsIT8* it8 = (cmsIT8*) hIT8;
int iField, iSet;
TABLE* t;
-
- _cmsAssert(hIT8 != NULL);
- t = GetTable(it8);
+ _cmsAssert(hIT8 != NULL);
+
+ t = GetTable(it8);
iField = LocateSample(it8, cSample);
- if (iField < 0)
+ if (iField < 0)
return FALSE;
if (t-> nPatches == 0) {
iSet = LocateEmptyPatch(it8);
if (iSet < 0) {
- return SynError(it8, "Couldn't add more patches '%s'\n", cPatch);
+ return SynError(it8, "Couldn't add more patches '%s'\n", cPatch);
}
iField = t -> SampleID;
cmsBool CMSEXPORT cmsIT8SetDataDbl(cmsHANDLE hIT8, const char* cPatch,
- const char* cSample,
- cmsFloat64Number Val)
+ const char* cSample,
+ cmsFloat64Number Val)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
- char Buff[256];
+ cmsIT8* it8 = (cmsIT8*) hIT8;
+ char Buff[256];
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
- snprintf(Buff, 255, it8->DoubleFormatter, Val);
- return cmsIT8SetData(hIT8, cPatch, cSample, Buff);
+ snprintf(Buff, 255, it8->DoubleFormatter, Val);
+ return cmsIT8SetData(hIT8, cPatch, cSample, Buff);
}
// Buffer should get MAXSTR at least
const char* CMSEXPORT cmsIT8GetPatchName(cmsHANDLE hIT8, int nPatch, char* buffer)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
- TABLE* t;
- char* Data;
+ cmsIT8* it8 = (cmsIT8*) hIT8;
+ TABLE* t;
+ char* Data;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
- t = GetTable(it8);
- Data = GetData(it8, nPatch, t->SampleID);
+ t = GetTable(it8);
+ Data = GetData(it8, nPatch, t->SampleID);
- if (!Data) return NULL;
- if (!buffer) return Data;
+ if (!Data) return NULL;
+ if (!buffer) return Data;
- strncpy(buffer, Data, MAXSTR-1);
- buffer[MAXSTR-1] = 0;
- return buffer;
+ strncpy(buffer, Data, MAXSTR-1);
+ buffer[MAXSTR-1] = 0;
+ return buffer;
}
int CMSEXPORT cmsIT8GetPatchByName(cmsHANDLE hIT8, const char *cPatch)
{
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
return LocatePatch((cmsIT8*)hIT8, cPatch);
}
cmsUInt32Number CMSEXPORT cmsIT8TableCount(cmsHANDLE hIT8)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
+ cmsIT8* it8 = (cmsIT8*) hIT8;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
- return it8 ->TablesCount;
+ return it8 ->TablesCount;
}
-// This handles the "LABEL" extension.
+// This handles the "LABEL" extension.
// Label, nTable, Type
int CMSEXPORT cmsIT8SetTableByLabel(cmsHANDLE hIT8, const char* cSet, const char* cField, const char* ExpectedType)
const char* cLabelFld;
char Type[256], Label[256];
int nTable;
-
+
_cmsAssert(hIT8 != NULL);
if (cField != NULL && *cField == 0)
cField = "LABEL";
- if (cField == NULL)
+ if (cField == NULL)
cField = "LABEL";
- cLabelFld = cmsIT8GetData(hIT8, cSet, cField);
+ cLabelFld = cmsIT8GetData(hIT8, cSet, cField);
if (!cLabelFld) return -1;
-
+
if (sscanf(cLabelFld, "%255s %d %255s", Label, &nTable, Type) != 3)
return -1;
-
+
if (ExpectedType != NULL && *ExpectedType == 0)
ExpectedType = NULL;
if (cmsstrcasecmp(Type, ExpectedType) != 0) return -1;
}
- return cmsIT8SetTable(hIT8, nTable);
+ return cmsIT8SetTable(hIT8, nTable);
}
cmsBool CMSEXPORT cmsIT8SetIndexColumn(cmsHANDLE hIT8, const char* cSample)
{
- cmsIT8* it8 = (cmsIT8*) hIT8;
- int pos;
+ cmsIT8* it8 = (cmsIT8*) hIT8;
+ int pos;
- _cmsAssert(hIT8 != NULL);
+ _cmsAssert(hIT8 != NULL);
- pos = LocateSample(it8, cSample);
- if(pos == -1)
- return FALSE;
+ pos = LocateSample(it8, cSample);
+ if(pos == -1)
+ return FALSE;
- it8->Tab[it8->nTable].SampleID = pos;
- return TRUE;
+ it8->Tab[it8->nTable].SampleID = pos;
+ return TRUE;
}
if (Formatter == NULL)
strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT);
else
- strcpy(it8->DoubleFormatter, Formatter);
+ strncpy(it8->DoubleFormatter, Formatter, sizeof(it8->DoubleFormatter));
+
+ it8 ->DoubleFormatter[sizeof(it8 ->DoubleFormatter)-1] = 0;
}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
#include "lcms2_internal.h"
-// Link several profiles to obtain a single LUT modelling the whole color transform. Intents, Black point
+// Link several profiles to obtain a single LUT modelling the whole color transform. Intents, Black point
// compensation and Adaptation parameters may vary across profiles. BPC and Adaptation refers to the PCS
// after the profile. I.e, BPC[0] refers to connexion between profile(0) and profile(1)
-cmsPipeline* _cmsLinkProfiles(cmsContext ContextID,
+cmsPipeline* _cmsLinkProfiles(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number Intents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number Intents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
-
+
//---------------------------------------------------------------------------------
-// This is the default routine for ICC-style intents. A user may decide to override it by using a plugin.
+// This is the default routine for ICC-style intents. A user may decide to override it by using a plugin.
// Supported intents are perceptual, relative colorimetric, saturation and ICC-absolute colorimetric
-static
-cmsPipeline* DefaultICCintents(cmsContext ContextID,
+static
+cmsPipeline* DefaultICCintents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number Intents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number Intents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
// This is the entry for black-preserving K-only intents, which are non-ICC. Last profile have to be a output profile
// to do the trick (no devicelinks allowed at that position)
static
-cmsPipeline* BlackPreservingKOnlyIntents(cmsContext ContextID,
+cmsPipeline* BlackPreservingKOnlyIntents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number Intents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number Intents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
// This is the entry for black-plane preserving, which are non-ICC. Again, Last profile have to be a output profile
// to do the trick (no devicelinks allowed at that position)
static
-cmsPipeline* BlackPreservingKPlaneIntents(cmsContext ContextID,
+cmsPipeline* BlackPreservingKPlaneIntents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number Intents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number Intents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
// Built-in intents
-static cmsIntentsList DefaultIntents[] = {
+static cmsIntentsList DefaultIntents[] = {
{ INTENT_PERCEPTUAL, "Perceptual", DefaultICCintents, &DefaultIntents[1] },
{ INTENT_RELATIVE_COLORIMETRIC, "Relative colorimetric", DefaultICCintents, &DefaultIntents[2] },
{ INTENT_PRESERVE_K_ONLY_SATURATION, "Saturation preserving black ink", BlackPreservingKOnlyIntents, &DefaultIntents[7] },
{ INTENT_PRESERVE_K_PLANE_PERCEPTUAL, "Perceptual preserving black plane", BlackPreservingKPlaneIntents, &DefaultIntents[8] },
{ INTENT_PRESERVE_K_PLANE_RELATIVE_COLORIMETRIC,"Relative colorimetric preserving black plane", BlackPreservingKPlaneIntents, &DefaultIntents[9] },
- { INTENT_PRESERVE_K_PLANE_SATURATION, "Saturation preserving black plane", BlackPreservingKPlaneIntents, NULL }
+ { INTENT_PRESERVE_K_PLANE_SATURATION, "Saturation preserving black plane", BlackPreservingKPlaneIntents, NULL }
};
// A pointer to the begining of the list
-static cmsIntentsList *Intents = DefaultIntents;
+_cmsIntentsPluginChunkType _cmsIntentsPluginChunk = { NULL };
+
+// Duplicates the zone of memory used by the plug-in in the new context
+static
+void DupPluginIntentsList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ _cmsIntentsPluginChunkType newHead = { NULL };
+ cmsIntentsList* entry;
+ cmsIntentsList* Anterior = NULL;
+ _cmsIntentsPluginChunkType* head = (_cmsIntentsPluginChunkType*) src->chunks[IntentPlugin];
+
+ // Walk the list copying all nodes
+ for (entry = head->Intents;
+ entry != NULL;
+ entry = entry ->Next) {
+
+ cmsIntentsList *newEntry = ( cmsIntentsList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(cmsIntentsList));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.Intents == NULL)
+ newHead.Intents = newEntry;
+ }
+
+ ctx ->chunks[IntentPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsIntentsPluginChunkType));
+}
+
+void _cmsAllocIntentsPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ if (src != NULL) {
+
+ // Copy all linked list
+ DupPluginIntentsList(ctx, src);
+ }
+ else {
+ static _cmsIntentsPluginChunkType IntentsPluginChunkType = { NULL };
+ ctx ->chunks[IntentPlugin] = _cmsSubAllocDup(ctx ->MemPool, &IntentsPluginChunkType, sizeof(_cmsIntentsPluginChunkType));
+ }
+}
+
// Search the list for a suitable intent. Returns NULL if not found
-static
-cmsIntentsList* SearchIntent(cmsUInt32Number Intent)
+static
+cmsIntentsList* SearchIntent(cmsContext ContextID, cmsUInt32Number Intent)
{
+ _cmsIntentsPluginChunkType* ctx = ( _cmsIntentsPluginChunkType*) _cmsContextGetClientChunk(ContextID, IntentPlugin);
cmsIntentsList* pt;
- for (pt = Intents; pt != NULL; pt = pt -> Next)
+ for (pt = ctx -> Intents; pt != NULL; pt = pt -> Next)
+ if (pt ->Intent == Intent) return pt;
+
+ for (pt = DefaultIntents; pt != NULL; pt = pt -> Next)
if (pt ->Intent == Intent) return pt;
return NULL;
}
-// Black point compensation. Implemented as a linear scaling in XYZ. Black points
+// Black point compensation. Implemented as a linear scaling in XYZ. Black points
// should come relative to the white point. Fills an matrix/offset element m
// which is organized as a 4x4 matrix.
static
-void ComputeBlackPointCompensation(const cmsCIEXYZ* BlackPointIn,
+void ComputeBlackPointCompensation(const cmsCIEXYZ* BlackPointIn,
const cmsCIEXYZ* BlackPointOut,
cmsMAT3* m, cmsVEC3* off)
-{
+{
cmsFloat64Number ax, ay, az, bx, by, bz, tx, ty, tz;
-
+
// Now we need to compute a matrix plus an offset m and of such of
// [m]*bpin + off = bpout
// [m]*D50 + off = D50
static
cmsFloat64Number CHAD2Temp(const cmsMAT3* Chad)
{
- // Convert D50 across CHAD to get the absolute white point
- cmsVEC3 d, s;
- cmsCIEXYZ Dest;
- cmsCIExyY DestChromaticity;
- cmsFloat64Number TempK;
+ // Convert D50 across inverse CHAD to get the absolute white point
+ cmsVEC3 d, s;
+ cmsCIEXYZ Dest;
+ cmsCIExyY DestChromaticity;
+ cmsFloat64Number TempK;
+ cmsMAT3 m1, m2;
+
+ m1 = *Chad;
+ if (!_cmsMAT3inverse(&m1, &m2)) return FALSE;
s.n[VX] = cmsD50_XYZ() -> X;
s.n[VY] = cmsD50_XYZ() -> Y;
s.n[VZ] = cmsD50_XYZ() -> Z;
- _cmsMAT3eval(&d, Chad, &s);
+ _cmsMAT3eval(&d, &m2, &s);
Dest.X = d.n[VX];
Dest.Y = d.n[VY];
// Compute a CHAD based on a given temperature
static
-void Temp2CHAD(cmsMAT3* Chad, cmsFloat64Number Temp)
+ void Temp2CHAD(cmsMAT3* Chad, cmsFloat64Number Temp)
{
cmsCIEXYZ White;
cmsCIExyY ChromaticityOfWhite;
-
- cmsWhitePointFromTemp(&ChromaticityOfWhite, Temp);
- cmsxyY2XYZ(&White, &ChromaticityOfWhite);
- _cmsAdaptationMatrix(Chad, NULL, cmsD50_XYZ(), &White);
+ cmsWhitePointFromTemp(&ChromaticityOfWhite, Temp);
+ cmsxyY2XYZ(&White, &ChromaticityOfWhite);
+ _cmsAdaptationMatrix(Chad, NULL, &White, cmsD50_XYZ());
}
// Join scalings to obtain relative input to absolute and then to relative output.
// Result is stored in a 3x3 matrix
static
cmsBool ComputeAbsoluteIntent(cmsFloat64Number AdaptationState,
- const cmsCIEXYZ* WhitePointIn,
+ const cmsCIEXYZ* WhitePointIn,
const cmsMAT3* ChromaticAdaptationMatrixIn,
const cmsCIEXYZ* WhitePointOut,
const cmsMAT3* ChromaticAdaptationMatrixOut,
cmsMAT3* m)
{
- cmsMAT3 Scale, m1, m2, m3;
+ cmsMAT3 Scale, m1, m2, m3, m4;
// Adaptation state
if (AdaptationState == 1.0) {
- // Observer is fully adapted. Keep chromatic adaptation.
+ // Observer is fully adapted. Keep chromatic adaptation.
// That is the standard V4 behaviour
_cmsVEC3init(&m->v[0], WhitePointIn->X / WhitePointOut->X, 0, 0);
_cmsVEC3init(&m->v[1], 0, WhitePointIn->Y / WhitePointOut->Y, 0);
_cmsVEC3init(&Scale.v[1], 0, WhitePointIn->Y / WhitePointOut->Y, 0);
_cmsVEC3init(&Scale.v[2], 0, 0, WhitePointIn->Z / WhitePointOut->Z);
- m1 = *ChromaticAdaptationMatrixIn;
- if (!_cmsMAT3inverse(&m1, &m2)) return FALSE;
- _cmsMAT3per(&m3, &m2, &Scale);
- // m3 holds CHAD from input white to D50 times abs. col. scaling
if (AdaptationState == 0.0) {
+ m1 = *ChromaticAdaptationMatrixOut;
+ _cmsMAT3per(&m2, &m1, &Scale);
+ // m2 holds CHAD from output white to D50 times abs. col. scaling
+
// Observer is not adapted, undo the chromatic adaptation
- _cmsMAT3per(m, &m3, ChromaticAdaptationMatrixOut);
+ _cmsMAT3per(m, &m2, ChromaticAdaptationMatrixOut);
+
+ m3 = *ChromaticAdaptationMatrixIn;
+ if (!_cmsMAT3inverse(&m3, &m4)) return FALSE;
+ _cmsMAT3per(m, &m2, &m4);
} else {
cmsMAT3 MixedCHAD;
cmsFloat64Number TempSrc, TempDest, Temp;
- TempSrc = CHAD2Temp(ChromaticAdaptationMatrixIn); // K for source white
- TempDest = CHAD2Temp(ChromaticAdaptationMatrixOut); // K for dest white
+ m1 = *ChromaticAdaptationMatrixIn;
+ if (!_cmsMAT3inverse(&m1, &m2)) return FALSE;
+ _cmsMAT3per(&m3, &m2, &Scale);
+ // m3 holds CHAD from input white to D50 times abs. col. scaling
+
+ TempSrc = CHAD2Temp(ChromaticAdaptationMatrixIn);
+ TempDest = CHAD2Temp(ChromaticAdaptationMatrixOut);
if (TempSrc < 0.0 || TempDest < 0.0) return FALSE; // Something went wrong
return TRUE;
}
- Temp = AdaptationState * TempSrc + (1.0 - AdaptationState) * TempDest;
+ Temp = (1.0 - AdaptationState) * TempDest + AdaptationState * TempSrc;
- // Get a CHAD from D50 to whatever output temperature. This replaces output CHAD
+ // Get a CHAD from whatever output temperature to D50. This replaces output CHAD
Temp2CHAD(&MixedCHAD, Temp);
_cmsMAT3per(m, &m3, &MixedCHAD);
cmsFloat64Number diff = 0;
cmsMAT3 Ident;
int i;
-
+
if (m == NULL && off == NULL) return TRUE; // NULL is allowed as an empty layer
if (m == NULL && off != NULL) return FALSE; // This is an internal error
_cmsMAT3identity(&Ident);
-
+
for (i=0; i < 3*3; i++)
diff += fabs(((cmsFloat64Number*)m)[i] - ((cmsFloat64Number*)&Ident)[i]);
// Compute the conversion layer
static
-cmsBool ComputeConversion(int i, cmsHPROFILE hProfiles[],
- cmsUInt32Number Intent,
- cmsBool BPC,
- cmsFloat64Number AdaptationState,
+cmsBool ComputeConversion(int i, cmsHPROFILE hProfiles[],
+ cmsUInt32Number Intent,
+ cmsBool BPC,
+ cmsFloat64Number AdaptationState,
cmsMAT3* m, cmsVEC3* off)
{
if (Intent == INTENT_ABSOLUTE_COLORIMETRIC) {
cmsCIEXYZ WhitePointIn, WhitePointOut;
- cmsMAT3 ChromaticAdaptationMatrixIn, ChromaticAdaptationMatrixOut;
+ cmsMAT3 ChromaticAdaptationMatrixIn, ChromaticAdaptationMatrixOut;
_cmsReadMediaWhitePoint(&WhitePointIn, hProfiles[i-1]);
_cmsReadCHAD(&ChromaticAdaptationMatrixIn, hProfiles[i-1]);
_cmsReadMediaWhitePoint(&WhitePointOut, hProfiles[i]);
_cmsReadCHAD(&ChromaticAdaptationMatrixOut, hProfiles[i]);
- if (!ComputeAbsoluteIntent(AdaptationState,
- &WhitePointIn, &ChromaticAdaptationMatrixIn,
+ if (!ComputeAbsoluteIntent(AdaptationState,
+ &WhitePointIn, &ChromaticAdaptationMatrixIn,
&WhitePointOut, &ChromaticAdaptationMatrixOut, m)) return FALSE;
}
cmsCIEXYZ BlackPointIn, BlackPointOut;
cmsDetectBlackPoint(&BlackPointIn, hProfiles[i-1], Intent, 0);
- cmsDetectBlackPoint(&BlackPointOut, hProfiles[i], Intent, 0);
+ cmsDetectDestinationBlackPoint(&BlackPointOut, hProfiles[i], Intent, 0);
// If black points are equal, then do nothing
if (BlackPointIn.X != BlackPointOut.X ||
BlackPointIn.Y != BlackPointOut.Y ||
- BlackPointIn.Z != BlackPointOut.Z)
+ BlackPointIn.Z != BlackPointOut.Z)
ComputeBlackPointCompensation(&BlackPointIn, &BlackPointOut, m, off);
}
}
// Offset should be adjusted because the encoding. We encode XYZ normalized to 0..1.0,
// to do that, we divide by MAX_ENCODEABLE_XZY. The conversion stage goes XYZ -> XYZ so
- // we have first to convert from encoded to XYZ and then convert back to encoded.
+ // we have first to convert from encoded to XYZ and then convert back to encoded.
// y = Mx + Off
// x = x'c
// y = M x'c + Off
// y = y'c; y' = y / c
- // y' = (Mx'c + Off) /c = Mx' + (Off / c)
+ // y' = (Mx'c + Off) /c = Mx' + (Off / c)
for (k=0; k < 3; k++) {
off ->n[k] /= MAX_ENCODEABLE_XYZ;
}
-// Add a conversion stage if needed. If a matrix/offset m is given, it applies to XYZ space
+// Add a conversion stage if needed. If a matrix/offset m is given, it applies to XYZ space
static
cmsBool AddConversion(cmsPipeline* Result, cmsColorSpaceSignature InPCS, cmsColorSpaceSignature OutPCS, cmsMAT3* m, cmsVEC3* off)
{
// Handle PCS mismatches. A specialized stage is added to the LUT in such case
switch (InPCS) {
- case cmsSigXYZData: // Input profile operates in XYZ
+ case cmsSigXYZData: // Input profile operates in XYZ
- switch (OutPCS) {
+ switch (OutPCS) {
- case cmsSigXYZData: // XYZ -> XYZ
- if (!IsEmptyLayer(m, off))
- cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl));
- break;
-
- case cmsSigLabData: // XYZ -> Lab
- if (!IsEmptyLayer(m, off))
- cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl));
- cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocXYZ2Lab(Result ->ContextID));
- break;
-
- default:
- return FALSE; // Colorspace mismatch
- }
- break;
+ case cmsSigXYZData: // XYZ -> XYZ
+ if (!IsEmptyLayer(m, off) &&
+ !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)))
+ return FALSE;
+ break;
+ case cmsSigLabData: // XYZ -> Lab
+ if (!IsEmptyLayer(m, off) &&
+ !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)))
+ return FALSE;
+ if (!cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocXYZ2Lab(Result ->ContextID)))
+ return FALSE;
+ break;
- case cmsSigLabData: // Input profile operates in Lab
+ default:
+ return FALSE; // Colorspace mismatch
+ }
+ break;
- switch (OutPCS) {
+ case cmsSigLabData: // Input profile operates in Lab
- case cmsSigXYZData: // Lab -> XYZ
+ switch (OutPCS) {
- cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocLab2XYZ(Result ->ContextID));
- if (!IsEmptyLayer(m, off))
- cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl));
- break;
+ case cmsSigXYZData: // Lab -> XYZ
- case cmsSigLabData: // Lab -> Lab
+ if (!cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocLab2XYZ(Result ->ContextID)))
+ return FALSE;
+ if (!IsEmptyLayer(m, off) &&
+ !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)))
+ return FALSE;
+ break;
- if (!IsEmptyLayer(m, off)) {
- cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocLab2XYZ(Result ->ContextID));
- cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl));
- cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocXYZ2Lab(Result ->ContextID));
- }
- break;
+ case cmsSigLabData: // Lab -> Lab
- default:
- return FALSE; // Mismatch
+ if (!IsEmptyLayer(m, off)) {
+ if (!cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocLab2XYZ(Result ->ContextID)) ||
+ !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)) ||
+ !cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocXYZ2Lab(Result ->ContextID)))
+ return FALSE;
}
break;
-
- // On colorspaces other than PCS, check for same space
default:
- if (InPCS != OutPCS) return FALSE;
- break;
+ return FALSE; // Mismatch
+ }
+ break;
+
+ // On colorspaces other than PCS, check for same space
+ default:
+ if (InPCS != OutPCS) return FALSE;
+ break;
}
return TRUE;
// If they are same, they are compatible.
if (a == b) return TRUE;
+ // Check for MCH4 substitution of CMYK
+ if ((a == cmsSig4colorData) && (b == cmsSigCmykData)) return TRUE;
+ if ((a == cmsSigCmykData) && (b == cmsSig4colorData)) return TRUE;
+
// Check for XYZ/Lab. Those spaces are interchangeable as they can be computed one from other.
if ((a == cmsSigXYZData) && (b == cmsSigLabData)) return TRUE;
if ((a == cmsSigLabData) && (b == cmsSigXYZData)) return TRUE;
// Default handler for ICC-style intents
static
-cmsPipeline* DefaultICCintents(cmsContext ContextID,
+cmsPipeline* DefaultICCintents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number TheIntents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number TheIntents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags)
{
- cmsPipeline* Lut, *Result;
+ cmsPipeline* Lut = NULL;
+ cmsPipeline* Result;
cmsHPROFILE hProfile;
cmsMAT3 m;
cmsVEC3 off;
- cmsColorSpaceSignature ColorSpaceIn, ColorSpaceOut, CurrentColorSpace;
+ cmsColorSpaceSignature ColorSpaceIn, ColorSpaceOut, CurrentColorSpace;
cmsProfileClassSignature ClassSig;
cmsUInt32Number i, Intent;
- // For safety
- if (nProfiles == 0) return NULL;
+ // For safety
+ if (nProfiles == 0) return NULL;
// Allocate an empty LUT for holding the result. 0 as channel count means 'undefined'
Result = cmsPipelineAlloc(ContextID, 0, 0);
if (Result == NULL) return NULL;
- CurrentColorSpace = cmsGetColorSpace(hProfiles[0]);
+ CurrentColorSpace = cmsGetColorSpace(hProfiles[0]);
for (i=0; i < nProfiles; i++) {
hProfile = hProfiles[i];
ClassSig = cmsGetDeviceClass(hProfile);
lIsDeviceLink = (ClassSig == cmsSigLinkClass || ClassSig == cmsSigAbstractClass );
-
+
// First profile is used as input unless devicelink or abstract
- if ((i == 0) && !lIsDeviceLink) {
- lIsInput = TRUE;
- }
- else {
- // Else use profile in the input direction if current space is not PCS
+ if ((i == 0) && !lIsDeviceLink) {
+ lIsInput = TRUE;
+ }
+ else {
+ // Else use profile in the input direction if current space is not PCS
lIsInput = (CurrentColorSpace != cmsSigXYZData) &&
(CurrentColorSpace != cmsSigLabData);
- }
+ }
Intent = TheIntents[i];
goto Error;
}
- // If devicelink is found, then no custom intent is allowed and we can
- // read the LUT to be applied. Settings don't apply here.
- if (lIsDeviceLink) {
+ // If devicelink is found, then no custom intent is allowed and we can
+ // read the LUT to be applied. Settings don't apply here.
+ if (lIsDeviceLink || ((ClassSig == cmsSigNamedColorClass) && (nProfiles == 1))) {
// Get the involved LUT from the profile
Lut = _cmsReadDevicelinkLUT(hProfile, Intent);
_cmsMAT3identity(&m);
_cmsVEC3init(&off, 0, 0, 0);
}
-
+
if (!AddConversion(Result, CurrentColorSpace, ColorSpaceIn, &m, &off)) goto Error;
if (lIsInput) {
// Input direction means non-pcs connection, so proceed like devicelinks
- Lut = _cmsReadInputLUT(hProfile, Intent);
+ Lut = _cmsReadInputLUT(hProfile, Intent);
if (Lut == NULL) goto Error;
}
else {
// Output direction means PCS connection. Intent may apply here
- Lut = _cmsReadOutputLUT(hProfile, Intent);
+ Lut = _cmsReadOutputLUT(hProfile, Intent);
if (Lut == NULL) goto Error;
}
// Concatenate to the output LUT
- cmsPipelineCat(Result, Lut);
- cmsPipelineFree(Lut);
+ if (!cmsPipelineCat(Result, Lut))
+ goto Error;
+
+ cmsPipelineFree(Lut);
+ Lut = NULL;
// Update current space
- CurrentColorSpace = ColorSpaceOut;
+ CurrentColorSpace = ColorSpaceOut;
}
return Result;
Error:
+ if (Lut != NULL) cmsPipelineFree(Lut);
if (Result != NULL) cmsPipelineFree(Result);
return NULL;
// Wrapper for DLL calling convention
-cmsPipeline* CMSEXPORT _cmsDefaultICCintents(cmsContext ContextID,
+cmsPipeline* CMSEXPORT _cmsDefaultICCintents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number TheIntents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number TheIntents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags)
switch (Intent) {
case INTENT_PRESERVE_K_ONLY_PERCEPTUAL:
case INTENT_PRESERVE_K_PLANE_PERCEPTUAL:
- return INTENT_PERCEPTUAL;
+ return INTENT_PERCEPTUAL;
case INTENT_PRESERVE_K_ONLY_RELATIVE_COLORIMETRIC:
case INTENT_PRESERVE_K_PLANE_RELATIVE_COLORIMETRIC:
// This is the entry for black-preserving K-only intents, which are non-ICC
static
-cmsPipeline* BlackPreservingKOnlyIntents(cmsContext ContextID,
+cmsPipeline* BlackPreservingKOnlyIntents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number TheIntents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number TheIntents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags)
if (nProfiles < 1 || nProfiles > 255) return NULL;
// Translate black-preserving intents to ICC ones
- for (i=0; i < nProfiles; i++)
- ICCIntents[i] = TranslateNonICCIntents(TheIntents[i]);
+ for (i=0; i < nProfiles; i++)
+ ICCIntents[i] = TranslateNonICCIntents(TheIntents[i]);
// Check for non-cmyk profiles
if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||
- cmsGetColorSpace(hProfiles[nProfiles-1]) != cmsSigCmykData)
+ cmsGetColorSpace(hProfiles[nProfiles-1]) != cmsSigCmykData)
return DefaultICCintents(ContextID, nProfiles, ICCIntents, hProfiles, BPC, AdaptationStates, dwFlags);
memset(&bp, 0, sizeof(bp));
if (Result == NULL) return NULL;
// Create a LUT holding normal ICC transform
- bp.cmyk2cmyk = DefaultICCintents(ContextID,
+ bp.cmyk2cmyk = DefaultICCintents(ContextID,
nProfiles,
- ICCIntents,
- hProfiles,
+ ICCIntents,
+ hProfiles,
BPC,
AdaptationStates,
dwFlags);
if (bp.cmyk2cmyk == NULL) goto Error;
-
+
// Now, compute the tone curve
- bp.KTone = _cmsBuildKToneCurve(ContextID,
- 4096,
+ bp.KTone = _cmsBuildKToneCurve(ContextID,
+ 4096,
nProfiles,
- ICCIntents,
- hProfiles,
+ ICCIntents,
+ hProfiles,
BPC,
AdaptationStates,
dwFlags);
-
+
if (bp.KTone == NULL) goto Error;
-
+
// How many gridpoints are we going to use?
nGridPoints = _cmsReasonableGridpointsByColorspace(cmsSigCmykData, dwFlags);
-
+
// Create the CLUT. 16 bits
CLUT = cmsStageAllocCLut16bit(ContextID, nGridPoints, 4, 4, NULL);
if (CLUT == NULL) goto Error;
// This is the one and only MPE in this LUT
- cmsPipelineInsertStage(Result, cmsAT_BEGIN, CLUT);
+ if (!cmsPipelineInsertStage(Result, cmsAT_BEGIN, CLUT))
+ goto Error;
// Sample it. We cannot afford pre/post linearization this time.
- if (!cmsStageSampleCLut16bit(CLUT, BlackPreservingGrayOnlySampler, (void*) &bp, 0))
+ if (!cmsStageSampleCLut16bit(CLUT, BlackPreservingGrayOnlySampler, (void*) &bp, 0))
goto Error;
-
+
// Get rid of xform and tone curve
cmsPipelineFree(bp.cmyk2cmyk);
cmsFreeToneCurve(bp.KTone);
cmsPipeline* LabK2cmyk; // The output profile
cmsFloat64Number MaxError;
- cmsHTRANSFORM hRoundTrip;
+ cmsHTRANSFORM hRoundTrip;
cmsFloat64Number MaxTAC;
-
+
} PreserveKPlaneParams;
{
int i;
cmsFloat32Number Inf[4], Outf[4];
- cmsFloat32Number LabK[4];
+ cmsFloat32Number LabK[4];
cmsFloat64Number SumCMY, SumCMYK, Error, Ratio;
cmsCIELab ColorimetricLab, BlackPreservingLab;
PreserveKPlaneParams* bp = (PreserveKPlaneParams*) Cargo;
-
+
// Convert from 16 bits to floating point
- for (i=0; i < 4; i++)
+ for (i=0; i < 4; i++)
Inf[i] = (cmsFloat32Number) (In[i] / 65535.0);
// Get the K across Tone curve
LabK[3] = cmsEvalToneCurveFloat(bp ->KTone, Inf[3]);
-
+
// If going across black only, keep black only
if (In[0] == 0 && In[1] == 0 && In[2] == 0) {
Out[3] = _cmsQuickSaturateWord(LabK[3] * 65535.0);
return TRUE;
}
-
- // Try the original transform,
- cmsPipelineEvalFloat( Inf, Outf, bp ->cmyk2cmyk);
-
+
+ // Try the original transform,
+ cmsPipelineEvalFloat( Inf, Outf, bp ->cmyk2cmyk);
+
// Store a copy of the floating point result into 16-bit
- for (i=0; i < 4; i++)
+ for (i=0; i < 4; i++)
Out[i] = _cmsQuickSaturateWord(Outf[i] * 65535.0);
// Maybe K is already ok (mostly on K=0)
if ( fabs(Outf[3] - LabK[3]) < (3.0 / 65535.0) ) {
return TRUE;
}
-
+
// K differ, mesure and keep Lab measurement for further usage
// this is done in relative colorimetric intent
cmsDoTransform(bp->hProofOutput, Out, &ColorimetricLab, 1);
-
+
// Is not black only and the transform doesn't keep black.
// Obtain the Lab of output CMYK. After that we have Lab + K
cmsDoTransform(bp ->cmyk2Lab, Outf, LabK, 1);
- // Obtain the corresponding CMY using reverse interpolation
+ // Obtain the corresponding CMY using reverse interpolation
// (K is fixed in LabK[3])
if (!cmsPipelineEvalReverseFloat(LabK, Outf, Outf, bp ->LabK2cmyk)) {
// Make sure to pass thru K (which now is fixed)
Outf[3] = LabK[3];
-
- // Apply TAC if needed
+
+ // Apply TAC if needed
SumCMY = Outf[0] + Outf[1] + Outf[2];
- SumCMYK = SumCMY + Outf[3];
+ SumCMYK = SumCMY + Outf[3];
if (SumCMYK > bp ->MaxTAC) {
Out[3] = _cmsQuickSaturateWord(Outf[3] * 65535.0);
// Estimate the error (this goes 16 bits to Lab DBL)
- cmsDoTransform(bp->hProofOutput, Out, &BlackPreservingLab, 1);
- Error = cmsDeltaE(&ColorimetricLab, &BlackPreservingLab);
- if (Error > bp -> MaxError)
+ cmsDoTransform(bp->hProofOutput, Out, &BlackPreservingLab, 1);
+ Error = cmsDeltaE(&ColorimetricLab, &BlackPreservingLab);
+ if (Error > bp -> MaxError)
bp->MaxError = Error;
return TRUE;
// This is the entry for black-plane preserving, which are non-ICC
static
-cmsPipeline* BlackPreservingKPlaneIntents(cmsContext ContextID,
+cmsPipeline* BlackPreservingKPlaneIntents(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number TheIntents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number TheIntents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags)
cmsPipeline* Result = NULL;
cmsUInt32Number ICCIntents[256];
cmsStage* CLUT;
- cmsUInt32Number i, nGridPoints;
+ cmsUInt32Number i, nGridPoints;
cmsHPROFILE hLab;
// Sanity check
if (nProfiles < 1 || nProfiles > 255) return NULL;
// Translate black-preserving intents to ICC ones
- for (i=0; i < nProfiles; i++)
- ICCIntents[i] = TranslateNonICCIntents(TheIntents[i]);
+ for (i=0; i < nProfiles; i++)
+ ICCIntents[i] = TranslateNonICCIntents(TheIntents[i]);
// Check for non-cmyk profiles
if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||
- cmsGetColorSpace(hProfiles[nProfiles-1]) != cmsSigCmykData)
+ !(cmsGetColorSpace(hProfiles[nProfiles-1]) == cmsSigCmykData ||
+ cmsGetDeviceClass(hProfiles[nProfiles-1]) == cmsSigOutputClass))
return DefaultICCintents(ContextID, nProfiles, ICCIntents, hProfiles, BPC, AdaptationStates, dwFlags);
// Allocate an empty LUT for holding the result
Result = cmsPipelineAlloc(ContextID, 4, 4);
if (Result == NULL) return NULL;
-
+
memset(&bp, 0, sizeof(bp));
// We need the input LUT of the last profile, assuming this one is responsible of
// Get total area coverage (in 0..1 domain)
bp.MaxTAC = cmsDetectTAC(hProfiles[nProfiles-1]) / 100.0;
+ if (bp.MaxTAC <= 0) goto Cleanup;
+
// Create a LUT holding normal ICC transform
bp.cmyk2cmyk = DefaultICCintents(ContextID,
nProfiles,
- ICCIntents,
- hProfiles,
+ ICCIntents,
+ hProfiles,
BPC,
AdaptationStates,
dwFlags);
+ if (bp.cmyk2cmyk == NULL) goto Cleanup;
// Now the tone curve
bp.KTone = _cmsBuildKToneCurve(ContextID, 4096, nProfiles,
- ICCIntents,
- hProfiles,
- BPC,
+ ICCIntents,
+ hProfiles,
+ BPC,
AdaptationStates,
dwFlags);
-
+ if (bp.KTone == NULL) goto Cleanup;
// To measure the output, Last profile to Lab
hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
- bp.hProofOutput = cmsCreateTransformTHR(ContextID, hProfiles[nProfiles-1],
- CHANNELS_SH(4)|BYTES_SH(2), hLab, TYPE_Lab_DBL,
- INTENT_RELATIVE_COLORIMETRIC,
+ bp.hProofOutput = cmsCreateTransformTHR(ContextID, hProfiles[nProfiles-1],
+ CHANNELS_SH(4)|BYTES_SH(2), hLab, TYPE_Lab_DBL,
+ INTENT_RELATIVE_COLORIMETRIC,
cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
+ if ( bp.hProofOutput == NULL) goto Cleanup;
// Same as anterior, but lab in the 0..1 range
- bp.cmyk2Lab = cmsCreateTransformTHR(ContextID, hProfiles[nProfiles-1],
- FLOAT_SH(1)|CHANNELS_SH(4)|BYTES_SH(4), hLab,
- FLOAT_SH(1)|CHANNELS_SH(3)|BYTES_SH(4),
- INTENT_RELATIVE_COLORIMETRIC,
+ bp.cmyk2Lab = cmsCreateTransformTHR(ContextID, hProfiles[nProfiles-1],
+ FLOAT_SH(1)|CHANNELS_SH(4)|BYTES_SH(4), hLab,
+ FLOAT_SH(1)|CHANNELS_SH(3)|BYTES_SH(4),
+ INTENT_RELATIVE_COLORIMETRIC,
cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
+ if (bp.cmyk2Lab == NULL) goto Cleanup;
cmsCloseProfile(hLab);
// Error estimation (for debug only)
// How many gridpoints are we going to use?
nGridPoints = _cmsReasonableGridpointsByColorspace(cmsSigCmykData, dwFlags);
-
+
CLUT = cmsStageAllocCLut16bit(ContextID, nGridPoints, 4, 4, NULL);
if (CLUT == NULL) goto Cleanup;
- cmsPipelineInsertStage(Result, cmsAT_BEGIN, CLUT);
+ if (!cmsPipelineInsertStage(Result, cmsAT_BEGIN, CLUT))
+ goto Cleanup;
cmsStageSampleCLut16bit(CLUT, BlackPreservingSampler, (void*) &bp, 0);
Cleanup:
if (bp.cmyk2cmyk) cmsPipelineFree(bp.cmyk2cmyk);
- if (bp.cmyk2Lab) cmsDeleteTransform(bp.cmyk2Lab);
+ if (bp.cmyk2Lab) cmsDeleteTransform(bp.cmyk2Lab);
if (bp.hProofOutput) cmsDeleteTransform(bp.hProofOutput);
-
- if (bp.KTone) cmsFreeToneCurve(bp.KTone);
+
+ if (bp.KTone) cmsFreeToneCurve(bp.KTone);
if (bp.LabK2cmyk) cmsPipelineFree(bp.LabK2cmyk);
return Result;
// Link routines ------------------------------------------------------------------------------------------------------
// Chain several profiles into a single LUT. It just checks the parameters and then calls the handler
-// for the first intent in chain. The handler may be user-defined. Is up to the handler to deal with the
+// for the first intent in chain. The handler may be user-defined. Is up to the handler to deal with the
// rest of intents in chain. A maximum of 255 profiles at time are supported, which is pretty reasonable.
-cmsPipeline* _cmsLinkProfiles(cmsContext ContextID,
+cmsPipeline* _cmsLinkProfiles(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number TheIntents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number TheIntents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags)
for (i=0; i < nProfiles; i++) {
- // Check if black point is really needed or allowed. Note that
+ // Check if black point is really needed or allowed. Note that
// following Adobe's document:
- // BPC does not apply to devicelink profiles, nor to abs colorimetric,
+ // BPC does not apply to devicelink profiles, nor to abs colorimetric,
// and applies always on V4 perceptual and saturation.
if (TheIntents[i] == INTENT_ABSOLUTE_COLORIMETRIC)
// Force BPC for V4 profiles in perceptual and saturation
if (cmsGetProfileVersion(hProfiles[i]) >= 4.0)
BPC[i] = TRUE;
- }
+ }
}
// Search for a handler. The first intent in the chain defines the handler. That would
// this case would present some issues if the custom intent tries to do things like
// preserve primaries. This solution is not perfect, but works well on most cases.
- Intent = SearchIntent(TheIntents[0]);
- if (Intent == NULL) {
- cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported intent '%d'", TheIntents[0]);
- return NULL;
- }
+ Intent = SearchIntent(ContextID, TheIntents[0]);
+ if (Intent == NULL) {
+ cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported intent '%d'", TheIntents[0]);
+ return NULL;
+ }
// Call the handler
return Intent ->Link(ContextID, nProfiles, TheIntents, hProfiles, BPC, AdaptationStates, dwFlags);
// -------------------------------------------------------------------------------------------------
-// Get information about available intents. nMax is the maximum space for the supplied "Codes"
-// and "Descriptions" the function returns the total number of intents, which may be greater
+// Get information about available intents. nMax is the maximum space for the supplied "Codes"
+// and "Descriptions" the function returns the total number of intents, which may be greater
// than nMax, although the matrices are not populated beyond this level.
-cmsUInt32Number CMSEXPORT cmsGetSupportedIntents(cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions)
+cmsUInt32Number CMSEXPORT cmsGetSupportedIntentsTHR(cmsContext ContextID, cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions)
{
+ _cmsIntentsPluginChunkType* ctx = ( _cmsIntentsPluginChunkType*) _cmsContextGetClientChunk(ContextID, IntentPlugin);
cmsIntentsList* pt;
cmsUInt32Number nIntents;
- for (nIntents=0, pt = Intents; pt != NULL; pt = pt -> Next)
+
+ for (nIntents=0, pt = ctx->Intents; pt != NULL; pt = pt -> Next)
{
if (nIntents < nMax) {
- if (Codes != NULL)
+ if (Codes != NULL)
Codes[nIntents] = pt ->Intent;
- if (Descriptions != NULL)
+ if (Descriptions != NULL)
Descriptions[nIntents] = pt ->Description;
}
nIntents++;
}
+ for (nIntents=0, pt = DefaultIntents; pt != NULL; pt = pt -> Next)
+ {
+ if (nIntents < nMax) {
+ if (Codes != NULL)
+ Codes[nIntents] = pt ->Intent;
+
+ if (Descriptions != NULL)
+ Descriptions[nIntents] = pt ->Description;
+ }
+
+ nIntents++;
+ }
return nIntents;
}
+cmsUInt32Number CMSEXPORT cmsGetSupportedIntents(cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions)
+{
+ return cmsGetSupportedIntentsTHR(NULL, nMax, Codes, Descriptions);
+}
+
// The plug-in registration. User can add new intents or override default routines
-cmsBool _cmsRegisterRenderingIntentPlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterRenderingIntentPlugin(cmsContext id, cmsPluginBase* Data)
{
+ _cmsIntentsPluginChunkType* ctx = ( _cmsIntentsPluginChunkType*) _cmsContextGetClientChunk(id, IntentPlugin);
cmsPluginRenderingIntent* Plugin = (cmsPluginRenderingIntent*) Data;
cmsIntentsList* fl;
- // Do we have to reset the intents?
+ // Do we have to reset the custom intents?
if (Data == NULL) {
-
- Intents = DefaultIntents;
- return TRUE;
+
+ ctx->Intents = NULL;
+ return TRUE;
}
- fl = SearchIntent(Plugin ->Intent);
+ fl = (cmsIntentsList*) _cmsPluginMalloc(id, sizeof(cmsIntentsList));
+ if (fl == NULL) return FALSE;
- if (fl == NULL) {
- fl = (cmsIntentsList*) _cmsPluginMalloc(sizeof(cmsIntentsList));
- if (fl == NULL) return FALSE;
- }
fl ->Intent = Plugin ->Intent;
- strncpy(fl ->Description, Plugin ->Description, 255);
- fl ->Description[255] = 0;
+ strncpy(fl ->Description, Plugin ->Description, sizeof(fl ->Description)-1);
+ fl ->Description[sizeof(fl ->Description)-1] = 0;
fl ->Link = Plugin ->Link;
- fl ->Next = Intents;
- Intents = fl;
+ fl ->Next = ctx ->Intents;
+ ctx ->Intents = fl;
return TRUE;
}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// compare two strings ignoring case
int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2)
{
- register const unsigned char *us1 = (const unsigned char *)s1,
- *us2 = (const unsigned char *)s2;
+ register const unsigned char *us1 = (const unsigned char *)s1,
+ *us2 = (const unsigned char *)s2;
- while (toupper(*us1) == toupper(*us2++))
- if (*us1++ == '\0')
- return (0);
- return (toupper(*us1) - toupper(*--us2));
+ while (toupper(*us1) == toupper(*us2++))
+ if (*us1++ == '\0')
+ return 0;
+
+ return (toupper(*us1) - toupper(*--us2));
}
// long int because C99 specifies ftell in such way (7.19.9.2)
long int CMSEXPORT cmsfilelength(FILE* f)
{
- long int p , n;
+ long int p , n;
- p = ftell(f); // register current file position
+ p = ftell(f); // register current file position
- if (fseek(f, 0, SEEK_END) != 0) {
- return -1;
- }
+ if (fseek(f, 0, SEEK_END) != 0) {
+ return -1;
+ }
n = ftell(f);
- fseek(f, p, SEEK_SET); // file position restored
+ fseek(f, p, SEEK_SET); // file position restored
- return n;
+ return n;
}
//
// This is the interface to low-level memory management routines. By default a simple
// wrapping to malloc/free/realloc is provided, although there is a limit on the max
-// amount of memoy that can be reclaimed. This is mostly as a safety feature to
-// prevent bogus or malintentionated code to allocate huge blocks that otherwise lcms
-// would never need.
+// amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent
+// bogus or evil code to allocate huge blocks that otherwise lcms would never need.
#define MAX_MEMORY_FOR_ALLOC ((cmsUInt32Number)(1024U*1024U*512U))
// User may override this behaviour by using a memory plug-in, which basically replaces
-// the default memory management functions. In this case, no check is performed and it
-// is up to the plug-in writter to keep in the safe side. There are only three functions
-// required to be implemented: malloc, realloc and free, although the user may want to
+// the default memory management functions. In this case, no check is performed and it
+// is up to the plug-in writter to keep in the safe side. There are only three functions
+// required to be implemented: malloc, realloc and free, although the user may want to
// replace the optional mallocZero, calloc and dup as well.
-cmsBool _cmsRegisterMemHandlerPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// *********************************************************************************
-// This is the default memory allocation function. It does a very coarse
+// This is the default memory allocation function. It does a very coarse
// check of amout of memory, just to prevent exploits
static
void* _cmsMallocDefaultFn(cmsContext ContextID, cmsUInt32Number size)
// free(NULL) is defined a no-op by C99, therefore it is safe to
// avoid the check, but it is here just in case...
- if (Ptr) free(Ptr);
+ if (Ptr) free(Ptr);
cmsUNUSED_PARAMETER(ContextID);
}
-// The default realloc function. Again it check for exploits. If Ptr is NULL,
-// realloc behaves the same way as malloc and allocates a new block of size bytes.
+// The default realloc function. Again it checks for exploits. If Ptr is NULL,
+// realloc behaves the same way as malloc and allocates a new block of size bytes.
static
void* _cmsReallocDefaultFn(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
{
if (Total == 0) return NULL;
// Safe check for overflow.
- if (num >= UINT_MAX / size) return NULL;
+ if (num >= UINT_MAX / size) return NULL;
// Check for overflow
if (Total < num || Total < size) {
return NULL;
}
-
+
if (Total > MAX_MEMORY_FOR_ALLOC) return NULL; // Never alloc over 512Mb
return _cmsMallocZero(ContextID, Total);
void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number size)
{
void* mem;
-
+
if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never dup over 512Mb
mem = _cmsMalloc(ContextID, size);
return mem;
}
-// Pointers to malloc and _cmsFree functions in current environment
-static void * (* MallocPtr)(cmsContext ContextID, cmsUInt32Number size) = _cmsMallocDefaultFn;
-static void * (* MallocZeroPtr)(cmsContext ContextID, cmsUInt32Number size) = _cmsMallocZeroDefaultFn;
-static void (* FreePtr)(cmsContext ContextID, void *Ptr) = _cmsFreeDefaultFn;
-static void * (* ReallocPtr)(cmsContext ContextID, void *Ptr, cmsUInt32Number NewSize) = _cmsReallocDefaultFn;
-static void * (* CallocPtr)(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)= _cmsCallocDefaultFn;
-static void * (* DupPtr)(cmsContext ContextID, const void* Org, cmsUInt32Number size) = _cmsDupDefaultFn;
+
+// Pointers to memory manager functions in Context0
+_cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn,
+ _cmsReallocDefaultFn, _cmsCallocDefaultFn, _cmsDupDefaultFn
+ };
+
+
+// Reset and duplicate memory manager
+void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
+{
+ _cmsAssert(ctx != NULL);
+
+ if (src != NULL) {
+
+ // Duplicate
+ ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));
+ }
+ else {
+
+ // To reset it, we use the default allocators, which cannot be overriden
+ ctx ->chunks[MemPlugin] = &ctx ->DefaultMemoryManager;
+ }
+}
+
+// Auxiliar to fill memory management functions from plugin (or context 0 defaults)
+void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr)
+{
+ if (Plugin == NULL) {
+
+ memcpy(ptr, &_cmsMemPluginChunk, sizeof(_cmsMemPluginChunk));
+ }
+ else {
+
+ ptr ->MallocPtr = Plugin -> MallocPtr;
+ ptr ->FreePtr = Plugin -> FreePtr;
+ ptr ->ReallocPtr = Plugin -> ReallocPtr;
+
+ // Make sure we revert to defaults
+ ptr ->MallocZeroPtr= _cmsMallocZeroDefaultFn;
+ ptr ->CallocPtr = _cmsCallocDefaultFn;
+ ptr ->DupPtr = _cmsDupDefaultFn;
+
+ if (Plugin ->MallocZeroPtr != NULL) ptr ->MallocZeroPtr = Plugin -> MallocZeroPtr;
+ if (Plugin ->CallocPtr != NULL) ptr ->CallocPtr = Plugin -> CallocPtr;
+ if (Plugin ->DupPtr != NULL) ptr ->DupPtr = Plugin -> DupPtr;
+
+ }
+}
+
// Plug-in replacement entry
-cmsBool _cmsRegisterMemHandlerPlugin(cmsPluginBase *Data)
+cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase *Data)
{
- cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data;
+ cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data;
+ _cmsMemPluginChunkType* ptr;
- // NULL forces to reset to defaults
+ // NULL forces to reset to defaults. In this special case, the defaults are stored in the context structure.
+ // Remaining plug-ins does NOT have any copy in the context structure, but this is somehow special as the
+ // context internal data should be malloce'd by using those functions.
if (Data == NULL) {
- MallocPtr = _cmsMallocDefaultFn;
- MallocZeroPtr= _cmsMallocZeroDefaultFn;
- FreePtr = _cmsFreeDefaultFn;
- ReallocPtr = _cmsReallocDefaultFn;
- CallocPtr = _cmsCallocDefaultFn;
- DupPtr = _cmsDupDefaultFn;
+ struct _cmsContext_struct* ctx = ( struct _cmsContext_struct*) ContextID;
+
+ // Return to the default allocators
+ if (ContextID != NULL) {
+ ctx->chunks[MemPlugin] = (void*) &ctx->DefaultMemoryManager;
+ }
return TRUE;
}
- // Check for required callbacks
- if (Plugin -> MallocPtr == NULL ||
+ // Check for required callbacks
+ if (Plugin -> MallocPtr == NULL ||
Plugin -> FreePtr == NULL ||
- Plugin -> ReallocPtr == NULL) return FALSE;
+ Plugin -> ReallocPtr == NULL) return FALSE;
// Set replacement functions
- MallocPtr = Plugin -> MallocPtr;
- FreePtr = Plugin -> FreePtr;
- ReallocPtr = Plugin -> ReallocPtr;
-
- if (Plugin ->MallocZeroPtr != NULL) MallocZeroPtr = Plugin ->MallocZeroPtr;
- if (Plugin ->CallocPtr != NULL) CallocPtr = Plugin -> CallocPtr;
- if (Plugin ->DupPtr != NULL) DupPtr = Plugin -> DupPtr;
+ ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ if (ptr == NULL)
+ return FALSE;
+ _cmsInstallAllocFunctions(Plugin, ptr);
return TRUE;
}
// Generic allocate
void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size)
{
- return MallocPtr(ContextID, size);
+ _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ return ptr ->MallocPtr(ContextID, size);
}
// Generic allocate & zero
void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size)
{
- return MallocZeroPtr(ContextID, size);
+ _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ return ptr->MallocZeroPtr(ContextID, size);
}
// Generic calloc
void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
{
- return CallocPtr(ContextID, num, size);
+ _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ return ptr->CallocPtr(ContextID, num, size);
}
// Generic reallocate
void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
{
- return ReallocPtr(ContextID, Ptr, size);
+ _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ return ptr->ReallocPtr(ContextID, Ptr, size);
}
// Generic free memory
void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr)
{
- if (Ptr != NULL) FreePtr(ContextID, Ptr);
+ if (Ptr != NULL) {
+ _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ ptr ->FreePtr(ContextID, Ptr);
+ }
}
// Generic block duplication
void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size)
{
- return DupPtr(ContextID, Org, size);
+ _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
+ return ptr ->DupPtr(ContextID, Org, size);
}
// ********************************************************************************************
// Sub allocation takes care of many pointers of small size. The memory allocated in
// this way have be freed at once. Next function allocates a single chunk for linked list
-// I prefer this method over realloc due to the big inpact on xput realloc may have if
-// memory is being swapped to disk. This approach is safer (although thats not true on any platform)
+// I prefer this method over realloc due to the big inpact on xput realloc may have if
+// memory is being swapped to disk. This approach is safer (although that may not be true on all platforms)
static
_cmsSubAllocator_chunk* _cmsCreateSubAllocChunk(cmsContext ContextID, cmsUInt32Number Initial)
{
_cmsSubAllocator_chunk* chunk;
+ // 20K by default
+ if (Initial == 0)
+ Initial = 20*1024;
+
// Create the container
chunk = (_cmsSubAllocator_chunk*) _cmsMallocZero(ContextID, sizeof(_cmsSubAllocator_chunk));
if (chunk == NULL) return NULL;
return NULL;
}
- // 20K by default
- if (Initial == 0)
- Initial = 20*1024;
-
chunk ->BlockSize = Initial;
chunk ->Used = 0;
chunk ->next = NULL;
cmsUInt32Number Free = sub -> h ->BlockSize - sub -> h -> Used;
cmsUInt8Number* ptr;
- size = _cmsALIGNLONG(size);
+ size = _cmsALIGNMEM(size);
- // Check for memory. If there is no room, allocate a new chunk of double memory size.
+ // Check for memory. If there is no room, allocate a new chunk of double memory size.
if (size > Free) {
_cmsSubAllocator_chunk* chunk;
sub ->h = chunk;
}
-
+
ptr = sub -> h ->Block + sub -> h ->Used;
sub -> h -> Used += size;
return (void*) ptr;
}
+// Duplicate in pool
+void* _cmsSubAllocDup(_cmsSubAllocator* s, const void *ptr, cmsUInt32Number size)
+{
+ void *NewPtr;
+
+ // Dup of null pointer is also NULL
+ if (ptr == NULL)
+ return NULL;
+
+ NewPtr = _cmsSubAlloc(s, size);
+
+ if (ptr != NULL && NewPtr != NULL) {
+ memcpy(NewPtr, ptr, size);
+ }
+
+ return NewPtr;
+}
+
+
+
// Error logging ******************************************************************
// There is no error handling at all. When a funtion fails, it returns proper value.
// For example, all create functions does return NULL on failure. Other return FALSE
// It may be interesting, for the developer, to know why the function is failing.
// for that reason, lcms2 does offer a logging function. This function does recive
-// a ENGLISH string with some clues on what is going wrong. You can show this
+// a ENGLISH string with some clues on what is going wrong. You can show this
// info to the end user, or just create some sort of log.
// The logging function should NOT terminate the program, as this obviously can leave
// resources. It is the programmer's responsability to check each function return code
// This is our default log error
static void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text);
-// The current handler in actual environment
-static cmsLogErrorHandlerFunction LogErrorHandler = DefaultLogErrorHandlerFunction;
+// Context0 storage, which is global
+_cmsLogErrorChunkType _cmsLogErrorChunk = { DefaultLogErrorHandlerFunction };
+
+// Allocates and inits error logger container for a given context. If src is NULL, only initializes the value
+// to the default. Otherwise, it duplicates the value. The interface is standard across all context clients
+void _cmsAllocLogErrorChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ static _cmsLogErrorChunkType LogErrorChunk = { DefaultLogErrorHandlerFunction };
+ void* from;
+
+ if (src != NULL) {
+ from = src ->chunks[Logger];
+ }
+ else {
+ from = &LogErrorChunk;
+ }
+
+ ctx ->chunks[Logger] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsLogErrorChunkType));
+}
// The default error logger does nothing.
static
{
// fprintf(stderr, "[lcms]: %s\n", Text);
// fflush(stderr);
-
+
cmsUNUSED_PARAMETER(ContextID);
cmsUNUSED_PARAMETER(ErrorCode);
- cmsUNUSED_PARAMETER(Text);
+ cmsUNUSED_PARAMETER(Text);
+}
+
+// Change log error, context based
+void CMSEXPORT cmsSetLogErrorHandlerTHR(cmsContext ContextID, cmsLogErrorHandlerFunction Fn)
+{
+ _cmsLogErrorChunkType* lhg = (_cmsLogErrorChunkType*) _cmsContextGetClientChunk(ContextID, Logger);
+
+ if (lhg != NULL) {
+
+ if (Fn == NULL)
+ lhg -> LogErrorHandler = DefaultLogErrorHandlerFunction;
+ else
+ lhg -> LogErrorHandler = Fn;
+ }
}
-// Change log error
+// Change log error, legacy
void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn)
{
- if (Fn == NULL)
- LogErrorHandler = DefaultLogErrorHandlerFunction;
- else
- LogErrorHandler = Fn;
+ cmsSetLogErrorHandlerTHR(NULL, Fn);
}
-// Log an error
+// Log an error
// ErrorText is a text holding an english description of error.
void CMSEXPORT cmsSignalError(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *ErrorText, ...)
{
va_list args;
char Buffer[MAX_ERROR_MESSAGE_LEN];
+ _cmsLogErrorChunkType* lhg;
+
va_start(args, ErrorText);
vsnprintf(Buffer, MAX_ERROR_MESSAGE_LEN-1, ErrorText, args);
- va_end(args);
+ va_end(args);
- // Call handler
- LogErrorHandler(ContextID, ErrorCode, Buffer);
+ // Check for the context, if specified go there. If not, go for the global
+ lhg = (_cmsLogErrorChunkType*) _cmsContextGetClientChunk(ContextID, Logger);
+ if (lhg ->LogErrorHandler) {
+ lhg ->LogErrorHandler(ContextID, ErrorCode, Buffer);
+ }
}
// Utility function to print signatures
// Convert to big endian
be = _cmsAdjustEndianess32((cmsUInt32Number) sig);
- // Move chars
+ // Move chars
memmove(String, &be, 4);
// Make sure of terminator
String[4] = 0;
}
+//--------------------------------------------------------------------------------------------------
+
+
+static
+void* defMtxCreate(cmsContext id)
+{
+ _cmsMutex* ptr_mutex = (_cmsMutex*) _cmsMalloc(id, sizeof(_cmsMutex));
+ _cmsInitMutexPrimitive(ptr_mutex);
+ return (void*) ptr_mutex;
+}
+
+static
+void defMtxDestroy(cmsContext id, void* mtx)
+{
+ _cmsDestroyMutexPrimitive((_cmsMutex *) mtx);
+ _cmsFree(id, mtx);
+}
+
+static
+cmsBool defMtxLock(cmsContext id, void* mtx)
+{
+ cmsUNUSED_PARAMETER(id);
+ return _cmsLockPrimitive((_cmsMutex *) mtx) == 0;
+}
+
+static
+void defMtxUnlock(cmsContext id, void* mtx)
+{
+ cmsUNUSED_PARAMETER(id);
+ _cmsUnlockPrimitive((_cmsMutex *) mtx);
+}
+
+
+
+// Pointers to memory manager functions in Context0
+_cmsMutexPluginChunkType _cmsMutexPluginChunk = { defMtxCreate, defMtxDestroy, defMtxLock, defMtxUnlock };
+
+// Allocate and init mutex container.
+void _cmsAllocMutexPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ static _cmsMutexPluginChunkType MutexChunk = {defMtxCreate, defMtxDestroy, defMtxLock, defMtxUnlock };
+ void* from;
+
+ if (src != NULL) {
+ from = src ->chunks[MutexPlugin];
+ }
+ else {
+ from = &MutexChunk;
+ }
+
+ ctx ->chunks[MutexPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsMutexPluginChunkType));
+}
+
+// Register new ways to transform
+cmsBool _cmsRegisterMutexPlugin(cmsContext ContextID, cmsPluginBase* Data)
+{
+ cmsPluginMutex* Plugin = (cmsPluginMutex*) Data;
+ _cmsMutexPluginChunkType* ctx = ( _cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
+
+ if (Data == NULL) {
+
+ // No lock routines
+ ctx->CreateMutexPtr = NULL;
+ ctx->DestroyMutexPtr = NULL;
+ ctx->LockMutexPtr = NULL;
+ ctx ->UnlockMutexPtr = NULL;
+ return TRUE;
+ }
+
+ // Factory callback is required
+ if (Plugin ->CreateMutexPtr == NULL || Plugin ->DestroyMutexPtr == NULL ||
+ Plugin ->LockMutexPtr == NULL || Plugin ->UnlockMutexPtr == NULL) return FALSE;
+
+
+ ctx->CreateMutexPtr = Plugin->CreateMutexPtr;
+ ctx->DestroyMutexPtr = Plugin ->DestroyMutexPtr;
+ ctx ->LockMutexPtr = Plugin ->LockMutexPtr;
+ ctx ->UnlockMutexPtr = Plugin ->UnlockMutexPtr;
+
+ // All is ok
+ return TRUE;
+}
+
+// Generic Mutex fns
+void* CMSEXPORT _cmsCreateMutex(cmsContext ContextID)
+{
+ _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
+
+ if (ptr ->CreateMutexPtr == NULL) return NULL;
+
+ return ptr ->CreateMutexPtr(ContextID);
+}
+
+void CMSEXPORT _cmsDestroyMutex(cmsContext ContextID, void* mtx)
+{
+ _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
+
+ if (ptr ->DestroyMutexPtr != NULL) {
+
+ ptr ->DestroyMutexPtr(ContextID, mtx);
+ }
+}
+
+cmsBool CMSEXPORT _cmsLockMutex(cmsContext ContextID, void* mtx)
+{
+ _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
+
+ if (ptr ->LockMutexPtr == NULL) return TRUE;
+
+ return ptr ->LockMutexPtr(ContextID, mtx);
+}
+
+void CMSEXPORT _cmsUnlockMutex(cmsContext ContextID, void* mtx)
+{
+ _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
+
+ if (ptr ->UnlockMutexPtr != NULL) {
+
+ ptr ->UnlockMutexPtr(ContextID, mtx);
+ }
+}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2013 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
//
#include "lcms2_internal.h"
-// Tone curves are powerful constructs that can contain curves specified in diverse ways.
+// Tone curves are powerful constructs that can contain curves specified in diverse ways.
// The curve is stored in segments, where each segment can be sampled or specified by parameters.
-// a 16.bit simplification of the *whole* curve is kept for optimization purposes. For float operation,
-// each segment is evaluated separately. Plug-ins may be used to define new parametric schemes,
-// each plug-in may define up to MAX_TYPES_IN_LCMS_PLUGIN functions types. For defining a function,
+// a 16.bit simplification of the *whole* curve is kept for optimization purposes. For float operation,
+// each segment is evaluated separately. Plug-ins may be used to define new parametric schemes,
+// each plug-in may define up to MAX_TYPES_IN_LCMS_PLUGIN functions types. For defining a function,
// the plug-in should provide the type id, how many parameters each type has, and a pointer to
-// a procedure that evaluates the function. In the case of reverse evaluation, the evaluator will
-// be called with the type id as a negative value, and a sampled version of the reversed curve
+// a procedure that evaluates the function. In the case of reverse evaluation, the evaluator will
+// be called with the type id as a negative value, and a sampled version of the reversed curve
// will be built.
// ----------------------------------------------------------------- Implementation
-// Maxim number of nodes
+// Maxim number of nodes
#define MAX_NODES_IN_CURVE 4097
#define MINUS_INF (-1E22F)
#define PLUS_INF (+1E22F)
} _cmsParametricCurvesCollection;
-
-// This is the default (built-in) evaluator
+// This is the default (built-in) evaluator
static cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Number Params[], cmsFloat64Number R);
// The built-in list
-static _cmsParametricCurvesCollection DefaultCurves = {
+static _cmsParametricCurvesCollection DefaultCurves = {
9, // # of curve types
{ 1, 2, 3, 4, 5, 6, 7, 8, 108 }, // Parametric curve ID
{ 1, 3, 4, 5, 7, 4, 5, 5, 1 }, // Parameters by type
NULL // Next in chain
};
+// Duplicates the zone of memory used by the plug-in in the new context
+static
+void DupPluginCurvesList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ _cmsCurvesPluginChunkType newHead = { NULL };
+ _cmsParametricCurvesCollection* entry;
+ _cmsParametricCurvesCollection* Anterior = NULL;
+ _cmsCurvesPluginChunkType* head = (_cmsCurvesPluginChunkType*) src->chunks[CurvesPlugin];
+
+ _cmsAssert(head != NULL);
+
+ // Walk the list copying all nodes
+ for (entry = head->ParametricCurves;
+ entry != NULL;
+ entry = entry ->Next) {
+
+ _cmsParametricCurvesCollection *newEntry = ( _cmsParametricCurvesCollection *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(_cmsParametricCurvesCollection));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.ParametricCurves == NULL)
+ newHead.ParametricCurves = newEntry;
+ }
+
+ ctx ->chunks[CurvesPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsCurvesPluginChunkType));
+}
+
+// The allocator have to follow the chain
+void _cmsAllocCurvesPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ _cmsAssert(ctx != NULL);
+
+ if (src != NULL) {
+
+ // Copy all linked list
+ DupPluginCurvesList(ctx, src);
+ }
+ else {
+ static _cmsCurvesPluginChunkType CurvesPluginChunk = { NULL };
+ ctx ->chunks[CurvesPlugin] = _cmsSubAllocDup(ctx ->MemPool, &CurvesPluginChunk, sizeof(_cmsCurvesPluginChunkType));
+ }
+}
+
+
// The linked list head
-static _cmsParametricCurvesCollection* ParametricCurves = &DefaultCurves;
+_cmsCurvesPluginChunkType _cmsCurvesPluginChunk = { NULL };
// As a way to install new parametric curves
-cmsBool _cmsRegisterParametricCurvesPlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterParametricCurvesPlugin(cmsContext ContextID, cmsPluginBase* Data)
{
+ _cmsCurvesPluginChunkType* ctx = ( _cmsCurvesPluginChunkType*) _cmsContextGetClientChunk(ContextID, CurvesPlugin);
cmsPluginParametricCurves* Plugin = (cmsPluginParametricCurves*) Data;
_cmsParametricCurvesCollection* fl;
-
+
if (Data == NULL) {
-
- ParametricCurves = &DefaultCurves;
+
+ ctx -> ParametricCurves = NULL;
return TRUE;
}
- fl = (_cmsParametricCurvesCollection*) _cmsPluginMalloc(sizeof(_cmsParametricCurvesCollection));
+ fl = (_cmsParametricCurvesCollection*) _cmsPluginMalloc(ContextID, sizeof(_cmsParametricCurvesCollection));
if (fl == NULL) return FALSE;
// Copy the parameters
memmove(fl->ParameterCount, Plugin ->ParameterCount, fl->nFunctions * sizeof(cmsUInt32Number));
// Keep linked list
- fl ->Next = ParametricCurves;
- ParametricCurves = fl;
+ fl ->Next = ctx->ParametricCurves;
+ ctx->ParametricCurves = fl;
// All is ok
return TRUE;
// Search for the collection which contains a specific type
static
-_cmsParametricCurvesCollection *GetParametricCurveByType(int Type, int* index)
+_cmsParametricCurvesCollection *GetParametricCurveByType(cmsContext ContextID, int Type, int* index)
{
_cmsParametricCurvesCollection* c;
int Position;
+ _cmsCurvesPluginChunkType* ctx = ( _cmsCurvesPluginChunkType*) _cmsContextGetClientChunk(ContextID, CurvesPlugin);
+
+ for (c = ctx->ParametricCurves; c != NULL; c = c ->Next) {
- for (c = ParametricCurves; c != NULL; c = c ->Next) {
+ Position = IsInSet(Type, c);
+
+ if (Position != -1) {
+ if (index != NULL)
+ *index = Position;
+ return c;
+ }
+ }
+ // If none found, revert for defaults
+ for (c = &DefaultCurves; c != NULL; c = c ->Next) {
Position = IsInSet(Type, c);
if (Position != -1) {
- if (index != NULL)
+ if (index != NULL)
*index = Position;
return c;
}
return NULL;
}
-// Low level allocate, which takes care of memory details. nEntries may be zero, and in this case
+// Low level allocate, which takes care of memory details. nEntries may be zero, and in this case
// no optimation curve is computed. nSegments may also be zero in the inverse case, where only the
// optimization curve is given. Both features simultaneously is an error
static
-cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntries,
- cmsInt32Number nSegments, const cmsCurveSegment* Segments,
+cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntries,
+ cmsInt32Number nSegments, const cmsCurveSegment* Segments,
const cmsUInt16Number* Values)
{
cmsToneCurve* p;
}
p -> nSegments = nSegments;
-
+
// This 16-bit table contains a limited precision representation of the whole curve and is kept for
// increasing xput on certain operations.
if (nEntries <= 0) {
p ->Table16 = (cmsUInt16Number*) _cmsCalloc(ContextID, nEntries, sizeof(cmsUInt16Number));
if (p ->Table16 == NULL) goto Error;
}
-
+
p -> nEntries = nEntries;
-
+
// Initialize members if requested
if (Values != NULL && (nEntries > 0)) {
- for (i=0; i < nEntries; i++)
+ for (i=0; i < nEntries; i++)
p ->Table16[i] = Values[i];
}
p ->Segments[i].SampledPoints = NULL;
- c = GetParametricCurveByType(Segments[i].Type, NULL);
+ c = GetParametricCurveByType(ContextID, Segments[i].Type, NULL);
if (c != NULL)
p ->Evals[i] = c ->Evaluator;
}
}
-
+
p ->InterpParams = _cmsComputeInterpParams(ContextID, p ->nEntries, 1, 1, p->Table16, CMS_LERP_FLAGS_16BITS);
- return p;
+ if (p->InterpParams != NULL)
+ return p;
Error:
if (p -> Segments) _cmsFree(ContextID, p ->Segments);
switch (Type) {
- // X = Y ^ Gamma
+ // X = Y ^ Gamma
case 1:
- if (R < 0)
- Val = 0;
+ if (R < 0) {
+
+ if (fabs(Params[0] - 1.0) < MATRIX_DET_TOLERANCE)
+ Val = R;
+ else
+ Val = 0;
+ }
else
Val = pow(R, Params[0]);
break;
// Type 1 Reversed: X = Y ^1/gamma
case -1:
- if (R < 0)
- Val = 0;
+ if (R < 0) {
+
+ if (fabs(Params[0] - 1.0) < MATRIX_DET_TOLERANCE)
+ Val = R;
+ else
+ Val = 0;
+ }
else
Val = pow(R, 1/Params[0]);
break;
// Type 2 Reversed
// X = (Y ^1/g - b) / a
- case -2:
+ case -2:
if (R < 0)
Val = 0;
else
Val = (pow(R, 1.0/Params[0]) - Params[2]) / Params[1];
if (Val < 0)
- Val = 0;
+ Val = 0;
break;
if (R >= disc) {
- e = Params[1]*R + Params[2];
+ e = Params[1]*R + Params[2];
if (e > 0)
Val = pow(e, Params[0]) + Params[3];
// Type 3 reversed
// X=((Y-c)^1/g - b)/a | (Y>=c)
- // X=-b/a | (Y<c)
+ // X=-b/a | (Y<c)
case -3:
if (R >= Params[3]) {
-
+
e = R - Params[3];
if (e > 0)
Val = (pow(e, 1/Params[0]) - Params[2]) / Params[1];
- else
+ else
Val = 0;
}
else {
if (e > 0)
Val = pow(e, Params[0]) + Params[5];
else
- Val = 0;
- }
+ Val = Params[5];
+ }
else
Val = R*Params[3] + Params[6];
break;
if (R >= disc) {
e = R - Params[5];
- if (e < 0)
+ if (e < 0)
Val = 0;
else
Val = (pow(e, 1.0/Params[0]) - Params[2]) / Params[1];
// Types 6,7,8 comes from segmented curves as described in ICCSpecRevision_02_11_06_Float.pdf
// Type 6 is basically identical to type 5 without d
-
+
// Y = (a * X + b) ^ Gamma + c
- case 6:
+ case 6:
e = Params[1]*R + Params[2];
- if (e < 0)
- Val = 0;
- else
+ if (e < 0)
+ Val = Params[3];
+ else
Val = pow(e, Params[0]) + Params[3];
break;
- // ((Y - c) ^1/Gamma - b) / a
+ // ((Y - c) ^1/Gamma - b) / a
case -6:
e = R - Params[3];
if (e < 0)
Val = 0;
- else
+ else
Val = (pow(e, 1.0/Params[0]) - Params[2]) / Params[1];
break;
// Y = a * log (b * X^Gamma + c) + d
- case 7:
+ case 7:
e = Params[2] * pow(R, Params[0]) + Params[3];
if (e <= 0)
- Val = 0;
+ Val = Params[4];
else
Val = Params[1]*log10(e) + Params[4];
break;
// (Y - d) / a = log(b * X ^Gamma + c)
// pow(10, (Y-d) / a) = b * X ^Gamma + c
- // pow((pow(10, (Y-d) / a) - c) / b, 1/g) = X
+ // pow((pow(10, (Y-d) / a) - c) / b, 1/g) = X
case -7:
Val = pow((pow(10.0, (R-Params[4]) / Params[1]) - Params[3]) / Params[2], 1.0 / Params[0]);
break;
- //Y = a * b^(c*X+d) + e
+ //Y = a * b^(c*X+d) + e
case 8:
Val = (Params[0] * pow(Params[1], Params[2] * R + Params[3]) + Params[4]);
break;
// Y = (log((y-e) / a) / log(b) - d ) / c
// a=0, b=1, c=2, d=3, e=4,
case -8:
-
+
disc = R - Params[4];
if (disc < 0) Val = 0;
- else
- Val = (log(disc / Params[0]) / log(Params[1]) - Params[3]) / Params[2];
+ else
+ Val = (log(disc / Params[0]) / log(Params[1]) - Params[3]) / Params[2];
break;
- // S-Shaped: (1 - (1-x)^1/g)^1/g
+ // S-Shaped: (1 - (1-x)^1/g)^1/g
case 108:
Val = pow(1.0 - pow(1 - R, 1/Params[0]), 1/Params[0]);
break;
}
// Evaluate a segmented funtion for a single value. Return -1 if no valid segment found .
-// If fn type is 0, perform an interpolation on the table
+// If fn type is 0, perform an interpolation on the table
static
cmsFloat64Number EvalSegmentedFn(const cmsToneCurve *g, cmsFloat64Number R)
{
// Type == 0 means segment is sampled
if (g ->Segments[i].Type == 0) {
- cmsFloat32Number R1 = (cmsFloat32Number) (R - g ->Segments[i].x0);
+ cmsFloat32Number R1 = (cmsFloat32Number) (R - g ->Segments[i].x0) / (g ->Segments[i].x1 - g ->Segments[i].x0);
cmsFloat32Number Out;
// Setup the table (TODO: clean that)
- g ->SegInterp[i]-> Table = g ->Segments[i].SampledPoints;
+ g ->SegInterp[i]-> Table = g ->Segments[i].SampledPoints;
g ->SegInterp[i] -> Interpolation.LerpFloat(&R1, &Out, g ->SegInterp[i]);
-
+
return Out;
}
else
return MINUS_INF;
}
+// Access to estimated low-res table
+cmsUInt32Number CMSEXPORT cmsGetToneCurveEstimatedTableEntries(const cmsToneCurve* t)
+{
+ _cmsAssert(t != NULL);
+ return t ->nEntries;
+}
+
+const cmsUInt16Number* CMSEXPORT cmsGetToneCurveEstimatedTable(const cmsToneCurve* t)
+{
+ _cmsAssert(t != NULL);
+ return t ->Table16;
+}
+
// Create an empty gamma curve, by using tables. This specifies only the limited-precision part, and leaves the
// floating point description empty.
// Create a segmented gamma, fill the table
-cmsToneCurve* CMSEXPORT cmsBuildSegmentedToneCurve(cmsContext ContextID,
+cmsToneCurve* CMSEXPORT cmsBuildSegmentedToneCurve(cmsContext ContextID,
cmsInt32Number nSegments, const cmsCurveSegment Segments[])
{
int i;
cmsFloat64Number R, Val;
cmsToneCurve* g;
int nGridPoints = 4096;
-
+
_cmsAssert(Segments != NULL);
- // Optimizatin for identity curves.
+ // Optimizatin for identity curves.
if (nSegments == 1 && Segments[0].Type == 1) {
nGridPoints = EntriesByGamma(Segments[0].Params[0]);
// Use a segmented curve to store the floating point table
cmsToneCurve* CMSEXPORT cmsBuildTabulatedToneCurveFloat(cmsContext ContextID, cmsUInt32Number nEntries, const cmsFloat32Number values[])
{
- cmsCurveSegment Seg[2];
+ cmsCurveSegment Seg[3];
- // Initialize segmented curve part up to 0
- Seg[0].x0 = -1;
+ // A segmented tone curve should have function segments in the first and last positions
+ // Initialize segmented curve part up to 0 to constant value = samples[0]
+ Seg[0].x0 = MINUS_INF;
Seg[0].x1 = 0;
Seg[0].Type = 6;
Seg[0].Params[0] = 1;
Seg[0].Params[1] = 0;
Seg[0].Params[2] = 0;
- Seg[0].Params[3] = 0;
+ Seg[0].Params[3] = values[0];
Seg[0].Params[4] = 0;
- // From zero to any
+ // From zero to 1
Seg[1].x0 = 0;
- Seg[1].x1 = 1.0;
+ Seg[1].x1 = 1.0;
Seg[1].Type = 0;
Seg[1].nGridPoints = nEntries;
Seg[1].SampledPoints = (cmsFloat32Number*) values;
- return cmsBuildSegmentedToneCurve(ContextID, 2, Seg);
+ // Final segment is constant = lastsample
+ Seg[2].x0 = 1.0;
+ Seg[2].x1 = PLUS_INF;
+ Seg[2].Type = 6;
+
+ Seg[2].Params[0] = 1;
+ Seg[2].Params[1] = 0;
+ Seg[2].Params[2] = 0;
+ Seg[2].Params[3] = values[nEntries-1];
+ Seg[2].Params[4] = 0;
+
+
+ return cmsBuildSegmentedToneCurve(ContextID, 3, Seg);
}
// Parametric curves
cmsCurveSegment Seg0;
int Pos = 0;
cmsUInt32Number size;
- _cmsParametricCurvesCollection* c = GetParametricCurveByType(Type, &Pos);
+ _cmsParametricCurvesCollection* c = GetParametricCurveByType(ContextID, Type, &Pos);
_cmsAssert(Params != NULL);
if (c == NULL) {
- cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Invalid parametric curve type %d", Type);
+ cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Invalid parametric curve type %d", Type);
return NULL;
}
void CMSEXPORT cmsFreeToneCurve(cmsToneCurve* Curve)
{
cmsContext ContextID;
-
+
if (Curve == NULL) return;
ContextID = Curve ->InterpParams->ContextID;
_cmsFreeInterpParams(Curve ->InterpParams);
-
+
if (Curve -> Table16)
_cmsFree(ContextID, Curve ->Table16);
if (Curve ->Segments) {
cmsUInt32Number i;
-
+
for (i=0; i < Curve ->nSegments; i++) {
if (Curve ->Segments[i].SampledPoints) {
_cmsFree(ContextID, Curve ->Segments[i].SampledPoints);
}
- if (Curve ->SegInterp[i] != 0)
+ if (Curve ->SegInterp[i] != 0)
_cmsFreeInterpParams(Curve->SegInterp[i]);
}
// Duplicate a gamma table
cmsToneCurve* CMSEXPORT cmsDupToneCurve(const cmsToneCurve* In)
-{
+{
if (In == NULL) return NULL;
return AllocateToneCurveStruct(In ->InterpParams ->ContextID, In ->nEntries, In ->nSegments, In ->Segments, In ->Table16);
}
// Joins two curves for X and Y. Curves should be monotonic.
-// We want to get
+// We want to get
//
-// y = Y^-1(X(t))
+// y = Y^-1(X(t))
//
-cmsToneCurve* CMSEXPORT cmsJoinToneCurve(cmsContext ContextID,
+cmsToneCurve* CMSEXPORT cmsJoinToneCurve(cmsContext ContextID,
const cmsToneCurve* X,
const cmsToneCurve* Y, cmsUInt32Number nResultingPoints)
{
Res = (cmsFloat32Number*) _cmsCalloc(ContextID, nResultingPoints, sizeof(cmsFloat32Number));
if (Res == NULL) goto Error;
-
+
//Iterate
for (i=0; i < nResultingPoints; i++) {
// Allocate space for output
out = cmsBuildTabulatedToneCurveFloat(ContextID, nResultingPoints, Res);
-
+
Error:
if (Res != NULL) _cmsFree(ContextID, Res);
-// Get the surrounding nodes. This is tricky on non-monotonic tables
+// Get the surrounding nodes. This is tricky on non-monotonic tables
static
int GetInterval(cmsFloat64Number In, const cmsUInt16Number LutTable[], const struct _cms_interp_struc* p)
-{
+{
int i;
int y0, y1;
-
+
// A 1 point table is not allowed
if (p -> Domain[0] < 1) return -1;
- // Let's see if ascending or descending.
+ // Let's see if ascending or descending.
if (LutTable[0] < LutTable[p ->Domain[0]]) {
// Table is overall ascending
for (i=p->Domain[0]-1; i >=0; --i) {
- y0 = LutTable[i];
+ y0 = LutTable[i];
y1 = LutTable[i+1];
-
+
if (y0 <= y1) { // Increasing
if (In >= y0 && In <= y1) return i;
}
// Table is overall descending
for (i=0; i < (int) p -> Domain[0]; i++) {
- y0 = LutTable[i];
+ y0 = LutTable[i];
y1 = LutTable[i+1];
if (y0 <= y1) { // Increasing
cmsFloat64Number a = 0, b = 0, y, x1, y1, x2, y2;
int i, j;
int Ascending;
-
+
_cmsAssert(InCurve != NULL);
// Try to reverse it analytically whatever possible
- if (InCurve ->nSegments == 1 && InCurve ->Segments[0].Type > 0 && InCurve -> Segments[0].Type <= 5) {
+
+ if (InCurve ->nSegments == 1 && InCurve ->Segments[0].Type > 0 &&
+ /* InCurve -> Segments[0].Type <= 5 */
+ GetParametricCurveByType(InCurve ->InterpParams->ContextID, InCurve ->Segments[0].Type, NULL) != NULL) {
- return cmsBuildParametricToneCurve(InCurve ->InterpParams->ContextID,
- -(InCurve -> Segments[0].Type),
+ return cmsBuildParametricToneCurve(InCurve ->InterpParams->ContextID,
+ -(InCurve -> Segments[0].Type),
InCurve -> Segments[0].Params);
}
- // Nope, reverse the table.
+ // Nope, reverse the table.
out = cmsBuildTabulatedToneCurve16(InCurve ->InterpParams->ContextID, nResultSamples, NULL);
if (out == NULL)
return NULL;
y = (cmsFloat64Number) i * 65535.0 / (nResultSamples - 1);
- // Find interval in which y is within.
+ // Find interval in which y is within.
j = GetInterval(y, InCurve->Table16, InCurve->InterpParams);
if (j >= 0) {
// Get limits of interval
- x1 = InCurve ->Table16[j];
+ x1 = InCurve ->Table16[j];
x2 = InCurve ->Table16[j+1];
y1 = (cmsFloat64Number) (j * 65535.0) / (InCurve ->nEntries - 1);
y2 = (cmsFloat64Number) ((j+1) * 65535.0 ) / (InCurve ->nEntries - 1);
-
+
// If collapsed, then use any
if (x1 == x2) {
} else {
- // Interpolate
+ // Interpolate
a = (y2 - y1) / (x2 - x1);
b = y2 - a * x2;
}
}
-
+
out ->Table16[i] = _cmsQuickSaturateWord(a* y + b);
}
c = (cmsFloat32Number*) _cmsCalloc(ContextID, MAX_NODES_IN_CURVE, sizeof(cmsFloat32Number));
d = (cmsFloat32Number*) _cmsCalloc(ContextID, MAX_NODES_IN_CURVE, sizeof(cmsFloat32Number));
e = (cmsFloat32Number*) _cmsCalloc(ContextID, MAX_NODES_IN_CURVE, sizeof(cmsFloat32Number));
-
+
if (c != NULL && d != NULL && e != NULL) {
c[2] = (-4 * lambda - d[1] * c[1] * e[1]) / d[2];
e[2] = lambda / d[2];
z[2] = w[2] * y[2] - c[1] * z[1];
-
+
for (i = 3; i < m - 1; i++) {
i1 = i - 1; i2 = i - 2;
d[i]= w[i] + 6 * lambda - c[i1] * c[i1] * d[i1] - e[i2] * e[i2] * d[i2];
e[i] = lambda / d[i];
z[i] = w[i] * y[i] - c[i1] * z[i1] - e[i2] * z[i2];
}
-
+
i1 = m - 2; i2 = m - 3;
-
+
d[m - 1] = w[m - 1] + 5 * lambda -c[i1] * c[i1] * d[i1] - e[i2] * e[i2] * d[i2];
c[m - 1] = (-2 * lambda - d[i1] * c[i1] * e[i1]) / d[m - 1];
z[m - 1] = w[m - 1] * y[m - 1] - c[i1] * z[i1] - e[i2] * z[i2];
i1 = m - 1; i2 = m - 2;
-
+
d[m] = w[m] + lambda - c[i1] * c[i1] * d[i1] - e[i2] * e[i2] * d[i2];
z[m] = (w[m] * y[m] - c[i1] * z[i1] - e[i2] * z[i2]) / d[m];
z[m - 1] = z[m - 1] / d[m - 1] - c[m - 1] * z[m];
-
+
for (i = m - 2; 1<= i; i--)
z[i] = z[i] / d[i] - c[i] * z[i + 1] - e[i] * z[i + 2];
return st;
}
-// Smooths a curve sampled at regular intervals.
+// Smooths a curve sampled at regular intervals.
cmsBool CMSEXPORT cmsSmoothToneCurve(cmsToneCurve* Tab, cmsFloat64Number lambda)
{
cmsFloat32Number w[MAX_NODES_IN_CURVE], y[MAX_NODES_IN_CURVE], z[MAX_NODES_IN_CURVE];
if (Tab == NULL) return FALSE;
- if (cmsIsToneCurveLinear(Tab)) return FALSE; // Nothing to do
+ if (cmsIsToneCurveLinear(Tab)) return TRUE; // Nothing to do
nItems = Tab -> nEntries;
if (z[i] == 0.) Zeros++;
if (z[i] >= 65535.) Poles++;
- if (z[i] < z[i-1]) return FALSE; // Non-Monotonic
+ if (z[i] < z[i-1]) {
+ cmsSignalError(Tab ->InterpParams->ContextID, cmsERROR_RANGE, "cmsSmoothToneCurve: Non-Monotonic.");
+ return FALSE;
+ }
}
- if (Zeros > (nItems / 3)) return FALSE; // Degenerated, mostly zeros
- if (Poles > (nItems / 3)) return FALSE; // Degenerated, mostly poles
+ if (Zeros > (nItems / 3)) {
+ cmsSignalError(Tab ->InterpParams->ContextID, cmsERROR_RANGE, "cmsSmoothToneCurve: Degenerated, mostly zeros.");
+ return FALSE;
+ }
+ if (Poles > (nItems / 3)) {
+ cmsSignalError(Tab ->InterpParams->ContextID, cmsERROR_RANGE, "cmsSmoothToneCurve: Degenerated, mostly poles.");
+ return FALSE;
+ }
// Seems ok
for (i=0; i < nItems; i++) {
{
int n;
int i, last;
+ cmsBool lDescending;
_cmsAssert(t != NULL);
- n = t ->nEntries;
- last = t ->Table16[n-1];
+ // Degenerated curves are monotonic? Ok, let's pass them
+ n = t ->nEntries;
+ if (n < 2) return TRUE;
- for (i = n-2; i >= 0; --i) {
+ // Curve direction
+ lDescending = cmsIsToneCurveDescending(t);
- if (t ->Table16[i] > last)
+ if (lDescending) {
- return FALSE;
- else
- last = t ->Table16[i];
+ last = t ->Table16[0];
+ for (i = 1; i < n; i++) {
+
+ if (t ->Table16[i] - last > 2) // We allow some ripple
+ return FALSE;
+ else
+ last = t ->Table16[i];
+
+ }
+ }
+ else {
+
+ last = t ->Table16[n-1];
+
+ for (i = n-2; i >= 0; --i) {
+
+ if (t ->Table16[i] - last > 2)
+ return FALSE;
+ else
+ last = t ->Table16[i];
+
+ }
}
return TRUE;
if (Curve ->nSegments == 0) {
cmsUInt16Number In, Out;
-
+
In = (cmsUInt16Number) _cmsQuickSaturateWord(v * 65535.0);
Out = cmsEvalToneCurve16(Curve, In);
-
+
return (cmsFloat32Number) (Out / 65535.0);
}
// Least squares fitting.
-// A mathematical procedure for finding the best-fitting curve to a given set of points by
-// minimizing the sum of the squares of the offsets ("the residuals") of the points from the curve.
-// The sum of the squares of the offsets is used instead of the offset absolute values because
-// this allows the residuals to be treated as a continuous differentiable quantity.
+// A mathematical procedure for finding the best-fitting curve to a given set of points by
+// minimizing the sum of the squares of the offsets ("the residuals") of the points from the curve.
+// The sum of the squares of the offsets is used instead of the offset absolute values because
+// this allows the residuals to be treated as a continuous differentiable quantity.
//
// y = f(x) = x ^ g
//
// R = (yi - (xi^g))
// R2 = (yi - (xi^g))2
// SUM R2 = SUM (yi - (xi^g))2
-//
-// dR2/dg = -2 SUM x^g log(x)(y - x^g)
-// solving for dR2/dg = 0
-//
-// g = 1/n * SUM(log(y) / log(x))
+//
+// dR2/dg = -2 SUM x^g log(x)(y - x^g)
+// solving for dR2/dg = 0
+//
+// g = 1/n * SUM(log(y) / log(x))
cmsFloat64Number CMSEXPORT cmsEstimateGamma(const cmsToneCurve* t, cmsFloat64Number Precision)
{
sum = sum2 = n = 0;
- // Excluding endpoints
+ // Excluding endpoints
for (i=1; i < (MAX_NODES_IN_CURVE-1); i++) {
x = (cmsFloat64Number) i / (MAX_NODES_IN_CURVE-1);
y = (cmsFloat64Number) cmsEvalToneCurveFloat(t, (cmsFloat32Number) x);
- // Avoid 7% on lower part to prevent
+ // Avoid 7% on lower part to prevent
// artifacts due to linear ramps
if (y > 0. && y < 1. && x > 0.07) {
-//---------------------------------------------------------------------------------
-//
-// Little Color Management System
-// Copyright (c) 1998-2010 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.
-//
-//---------------------------------------------------------------------------------
-//
-
-#include "lcms2_internal.h"
-
-
-// Auxiliar: append a Lab identity after the given sequence of profiles
-// and return the transform. Lab profile is closed, rest of profiles are kept open.
-cmsHTRANSFORM _cmsChain2Lab(cmsContext ContextID,
- cmsUInt32Number nProfiles,
- cmsUInt32Number InputFormat,
- cmsUInt32Number OutputFormat,
- const cmsUInt32Number Intents[],
- const cmsHPROFILE hProfiles[],
- const cmsBool BPC[],
- const cmsFloat64Number AdaptationStates[],
- cmsUInt32Number dwFlags)
-{
- cmsHTRANSFORM xform;
- cmsHPROFILE hLab;
- cmsHPROFILE ProfileList[256];
- cmsBool BPCList[256];
- cmsFloat64Number AdaptationList[256];
- cmsUInt32Number IntentList[256];
- cmsUInt32Number i;
-
- // This is a rather big number and there is no need of dynamic memory
- // since we are adding a profile, 254 + 1 = 255 and this is the limit
- if (nProfiles > 254) return NULL;
-
- // The output space
- hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
- if (hLab == NULL) return NULL;
-
- // Create a copy of parameters
- for (i=0; i < nProfiles; i++) {
-
- ProfileList[i] = hProfiles[i];
- BPCList[i] = BPC[i];
- AdaptationList[i] = AdaptationStates[i];
- IntentList[i] = Intents[i];
- }
-
- // Place Lab identity at chain's end.
- ProfileList[nProfiles] = hLab;
- BPCList[nProfiles] = 0;
- AdaptationList[nProfiles] = 1.0;
- IntentList[nProfiles] = INTENT_RELATIVE_COLORIMETRIC;
-
- // Create the transform
- xform = cmsCreateExtendedTransform(ContextID, nProfiles + 1, ProfileList,
- BPCList,
- IntentList,
- AdaptationList,
- NULL, 0,
- InputFormat,
- OutputFormat,
- dwFlags);
-
- cmsCloseProfile(hLab);
-
- return xform;
-}
-
-
-// Compute K -> L* relationship. Flags may include black point compensation. In this case,
-// the relationship is assumed from the profile with BPC to a black point zero.
-static
-cmsToneCurve* ComputeKToLstar(cmsContext ContextID,
- cmsUInt32Number nPoints,
- cmsUInt32Number nProfiles,
- const cmsUInt32Number Intents[],
- const cmsHPROFILE hProfiles[],
- const cmsBool BPC[],
- const cmsFloat64Number AdaptationStates[],
- cmsUInt32Number dwFlags)
-{
- cmsToneCurve* out = NULL;
- cmsUInt32Number i;
- cmsHTRANSFORM xform;
- cmsCIELab Lab;
- cmsFloat32Number cmyk[4];
- cmsFloat32Number* SampledPoints;
-
- xform = _cmsChain2Lab(ContextID, nProfiles, TYPE_CMYK_FLT, TYPE_Lab_DBL, Intents, hProfiles, BPC, AdaptationStates, dwFlags);
- if (xform == NULL) return NULL;
-
- SampledPoints = (cmsFloat32Number*) _cmsCalloc(ContextID, nPoints, sizeof(cmsFloat32Number));
- if (SampledPoints == NULL) goto Error;
-
- for (i=0; i < nPoints; i++) {
-
- cmyk[0] = 0;
- cmyk[1] = 0;
- cmyk[2] = 0;
- cmyk[3] = (cmsFloat32Number) ((i * 100.0) / (nPoints-1));
-
- cmsDoTransform(xform, cmyk, &Lab, 1);
- SampledPoints[i]= (cmsFloat32Number) (1.0 - Lab.L / 100.0); // Negate K for easier operation
- }
-
- out = cmsBuildTabulatedToneCurveFloat(ContextID, nPoints, SampledPoints);
-
-Error:
-
- cmsDeleteTransform(xform);
- if (SampledPoints) _cmsFree(ContextID, SampledPoints);
-
- return out;
-}
-
-
-// Compute Black tone curve on a CMYK -> CMYK transform. This is done by
-// using the proof direction on both profiles to find K->L* relationship
-// then joining both curves. dwFlags may include black point compensation.
-cmsToneCurve* _cmsBuildKToneCurve(cmsContext ContextID,
- cmsUInt32Number nPoints,
- cmsUInt32Number nProfiles,
- const cmsUInt32Number Intents[],
- const cmsHPROFILE hProfiles[],
- const cmsBool BPC[],
- const cmsFloat64Number AdaptationStates[],
- cmsUInt32Number dwFlags)
-{
- cmsToneCurve *in, *out, *KTone;
-
- // Make sure CMYK -> CMYK
- if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||
- cmsGetColorSpace(hProfiles[nProfiles-1])!= cmsSigCmykData) return NULL;
-
-
- // Make sure last is an output profile
- if (cmsGetDeviceClass(hProfiles[nProfiles - 1]) != cmsSigOutputClass) return NULL;
-
- // Create individual curves. BPC works also as each K to L* is
- // computed as a BPC to zero black point in case of L*
- in = ComputeKToLstar(ContextID, nPoints, nProfiles - 1, Intents, hProfiles, BPC, AdaptationStates, dwFlags);
- if (in == NULL) return NULL;
-
- out = ComputeKToLstar(ContextID, nPoints, 1,
- Intents + (nProfiles - 1),
- hProfiles + (nProfiles - 1),
- BPC + (nProfiles - 1),
- AdaptationStates + (nProfiles - 1),
- dwFlags);
- if (out == NULL) {
- cmsFreeToneCurve(in);
- return NULL;
- }
-
- // Build the relationship. This effectively limits the maximum accuracy to 16 bits, but
- // since this is used on black-preserving LUTs, we are not loosing accuracy in any case
- KTone = cmsJoinToneCurve(ContextID, in, out, nPoints);
-
- // Get rid of components
- cmsFreeToneCurve(in); cmsFreeToneCurve(out);
-
- // Something went wrong...
- if (KTone == NULL) return NULL;
-
- // Make sure it is monotonic
- if (!cmsIsToneCurveMonotonic(KTone)) {
-
- cmsFreeToneCurve(KTone);
- return NULL;
- }
-
- return KTone;
-}
-
-
-// Gamut LUT Creation -----------------------------------------------------------------------------------------
-
-// Used by gamut & softproofing
-
-typedef struct {
-
- cmsHTRANSFORM hInput; // From whatever input color space. 16 bits to DBL
- cmsHTRANSFORM hForward, hReverse; // Transforms going from Lab to colorant and back
- cmsFloat64Number Thereshold; // The thereshold after which is considered out of gamut
-
- } GAMUTCHAIN;
-
-// This sampler does compute gamut boundaries by comparing original
-// values with a transform going back and forth. Values above ERR_THERESHOLD
-// of maximum are considered out of gamut.
-
-#define ERR_THERESHOLD 5
-
-
-static
-int GamutSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
-{
- GAMUTCHAIN* t = (GAMUTCHAIN* ) Cargo;
- cmsCIELab LabIn1, LabOut1;
- cmsCIELab LabIn2, LabOut2;
- cmsUInt16Number Proof[cmsMAXCHANNELS], Proof2[cmsMAXCHANNELS];
- cmsFloat64Number dE1, dE2, ErrorRatio;
-
- // Assume in-gamut by default.
- dE1 = 0.;
- dE2 = 0;
- ErrorRatio = 1.0;
-
- // Convert input to Lab
- if (t -> hInput != NULL)
- cmsDoTransform(t -> hInput, In, &LabIn1, 1);
-
- // converts from PCS to colorant. This always
- // does return in-gamut values,
- cmsDoTransform(t -> hForward, &LabIn1, Proof, 1);
-
- // Now, do the inverse, from colorant to PCS.
- cmsDoTransform(t -> hReverse, Proof, &LabOut1, 1);
-
- memmove(&LabIn2, &LabOut1, sizeof(cmsCIELab));
-
- // Try again, but this time taking Check as input
- cmsDoTransform(t -> hForward, &LabOut1, Proof2, 1);
- cmsDoTransform(t -> hReverse, Proof2, &LabOut2, 1);
-
- // Take difference of direct value
- dE1 = cmsDeltaE(&LabIn1, &LabOut1);
-
- // Take difference of converted value
- dE2 = cmsDeltaE(&LabIn2, &LabOut2);
-
-
- // if dE1 is small and dE2 is small, value is likely to be in gamut
- if (dE1 < t->Thereshold && dE2 < t->Thereshold)
- Out[0] = 0;
- else {
-
- // if dE1 is small and dE2 is big, undefined. Assume in gamut
- if (dE1 < t->Thereshold && dE2 > t->Thereshold)
- Out[0] = 0;
- else
- // dE1 is big and dE2 is small, clearly out of gamut
- if (dE1 > t->Thereshold && dE2 < t->Thereshold)
- Out[0] = (cmsUInt16Number) _cmsQuickFloor((dE1 - t->Thereshold) + .5);
- else {
-
- // dE1 is big and dE2 is also big, could be due to perceptual mapping
- // so take error ratio
- if (dE2 == 0.0)
- ErrorRatio = dE1;
- else
- ErrorRatio = dE1 / dE2;
-
- if (ErrorRatio > t->Thereshold)
- Out[0] = (cmsUInt16Number) _cmsQuickFloor((ErrorRatio - t->Thereshold) + .5);
- else
- Out[0] = 0;
- }
- }
-
-
- return TRUE;
-}
-
-// Does compute a gamut LUT going back and forth across pcs -> relativ. colorimetric intent -> pcs
-// the dE obtained is then annotated on the LUT. Values truely out of gamut are clipped to dE = 0xFFFE
-// and values changed are supposed to be handled by any gamut remapping, so, are out of gamut as well.
-//
-// **WARNING: This algorithm does assume that gamut remapping algorithms does NOT move in-gamut colors,
-// of course, many perceptual and saturation intents does not work in such way, but relativ. ones should.
-
-cmsPipeline* _cmsCreateGamutCheckPipeline(cmsContext ContextID,
- cmsHPROFILE hProfiles[],
- cmsBool BPC[],
- cmsUInt32Number Intents[],
- cmsFloat64Number AdaptationStates[],
- cmsUInt32Number nGamutPCSposition,
- cmsHPROFILE hGamut)
-{
- cmsHPROFILE hLab;
- cmsPipeline* Gamut;
- cmsStage* CLUT;
- cmsUInt32Number dwFormat;
- GAMUTCHAIN Chain;
- int nChannels, nGridpoints;
- cmsColorSpaceSignature ColorSpace;
- cmsUInt32Number i;
- cmsHPROFILE ProfileList[256];
- cmsBool BPCList[256];
- cmsFloat64Number AdaptationList[256];
- cmsUInt32Number IntentList[256];
-
- memset(&Chain, 0, sizeof(GAMUTCHAIN));
-
-
- if (nGamutPCSposition <= 0 || nGamutPCSposition > 255) {
- cmsSignalError(ContextID, cmsERROR_RANGE, "Wrong position of PCS. 1..255 expected, %d found.", nGamutPCSposition);
- return NULL;
- }
-
- hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
- if (hLab == NULL) return NULL;
-
-
- // The figure of merit. On matrix-shaper profiles, should be almost zero as
- // the conversion is pretty exact. On LUT based profiles, different resolutions
- // of input and output CLUT may result in differences.
-
- if (cmsIsMatrixShaper(hGamut)) {
-
- Chain.Thereshold = 1.0;
- }
- else {
- Chain.Thereshold = ERR_THERESHOLD;
- }
-
-
- // Create a copy of parameters
- for (i=0; i < nGamutPCSposition; i++) {
- ProfileList[i] = hProfiles[i];
- BPCList[i] = BPC[i];
- AdaptationList[i] = AdaptationStates[i];
- IntentList[i] = Intents[i];
- }
-
- // Fill Lab identity
- ProfileList[nGamutPCSposition] = hLab;
- BPCList[nGamutPCSposition] = 0;
- AdaptationList[nGamutPCSposition] = 1.0;
- Intents[nGamutPCSposition] = INTENT_RELATIVE_COLORIMETRIC;
-
-
- ColorSpace = cmsGetColorSpace(hGamut);
-
- nChannels = cmsChannelsOf(ColorSpace);
- nGridpoints = _cmsReasonableGridpointsByColorspace(ColorSpace, cmsFLAGS_HIGHRESPRECALC);
- dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2));
-
- // 16 bits to Lab double
- Chain.hInput = cmsCreateExtendedTransform(ContextID,
- nGamutPCSposition + 1,
- ProfileList,
- BPCList,
- Intents,
- AdaptationList,
- NULL, 0,
- dwFormat, TYPE_Lab_DBL,
- cmsFLAGS_NOCACHE);
-
-
- // Does create the forward step. Lab double to device
- dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2));
- Chain.hForward = cmsCreateTransformTHR(ContextID,
- hLab, TYPE_Lab_DBL,
- hGamut, dwFormat,
- INTENT_RELATIVE_COLORIMETRIC,
- cmsFLAGS_NOCACHE);
-
- // Does create the backwards step
- Chain.hReverse = cmsCreateTransformTHR(ContextID, hGamut, dwFormat,
- hLab, TYPE_Lab_DBL,
- INTENT_RELATIVE_COLORIMETRIC,
- cmsFLAGS_NOCACHE);
-
-
- // All ok?
- if (Chain.hForward && Chain.hReverse) {
-
- // Go on, try to compute gamut LUT from PCS. This consist on a single channel containing
- // dE when doing a transform back and forth on the colorimetric intent.
-
- Gamut = cmsPipelineAlloc(ContextID, 3, 1);
-
- if (Gamut != NULL) {
-
- CLUT = cmsStageAllocCLut16bit(ContextID, nGridpoints, nChannels, 1, NULL);
- cmsPipelineInsertStage(Gamut, cmsAT_BEGIN, CLUT);
-
- cmsStageSampleCLut16bit(CLUT, GamutSampler, (void*) &Chain, 0);
- }
- }
- else
- Gamut = NULL; // Didn't work...
-
- // Free all needed stuff.
- if (Chain.hInput) cmsDeleteTransform(Chain.hInput);
- if (Chain.hForward) cmsDeleteTransform(Chain.hForward);
- if (Chain.hReverse) cmsDeleteTransform(Chain.hReverse);
- if (hLab) cmsCloseProfile(hLab);
-
- // And return computed hull
- return Gamut;
-}
-
-// Total Area Coverage estimation ----------------------------------------------------------------
-
-typedef struct {
- cmsUInt32Number nOutputChans;
- cmsHTRANSFORM hRoundTrip;
- cmsFloat32Number MaxTAC;
- cmsFloat32Number MaxInput[cmsMAXCHANNELS];
-
-} cmsTACestimator;
-
-
-// This callback just accounts the maximum ink dropped in the given node. It does not populate any
-// memory, as the destination table is NULL. Its only purpose it to know the global maximum.
-static
-int EstimateTAC(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void * Cargo)
-{
- cmsTACestimator* bp = (cmsTACestimator*) Cargo;
- cmsFloat32Number RoundTrip[cmsMAXCHANNELS];
- cmsUInt32Number i;
- cmsFloat32Number Sum;
-
-
- // Evaluate the xform
- cmsDoTransform(bp->hRoundTrip, In, RoundTrip, 1);
-
- // All all amounts of ink
- for (Sum=0, i=0; i < bp ->nOutputChans; i++)
- Sum += RoundTrip[i];
-
- // If above maximum, keep track of input values
- if (Sum > bp ->MaxTAC) {
-
- bp ->MaxTAC = Sum;
-
- for (i=0; i < bp ->nOutputChans; i++) {
- bp ->MaxInput[i] = In[i];
- }
- }
-
- return TRUE;
-
- cmsUNUSED_PARAMETER(Out);
-}
-
-
-// Detect Total area coverage of the profile
-cmsFloat64Number CMSEXPORT cmsDetectTAC(cmsHPROFILE hProfile)
-{
- cmsTACestimator bp;
- cmsUInt32Number dwFormatter;
- cmsUInt32Number GridPoints[MAX_INPUT_DIMENSIONS];
- cmsHPROFILE hLab;
- cmsContext ContextID = cmsGetProfileContextID(hProfile);
-
- // TAC only works on output profiles
- if (cmsGetDeviceClass(hProfile) != cmsSigOutputClass) {
- return 0;
- }
-
- // Create a fake formatter for result
- dwFormatter = cmsFormatterForColorspaceOfProfile(hProfile, 4, TRUE);
-
- bp.nOutputChans = T_CHANNELS(dwFormatter);
- bp.MaxTAC = 0; // Initial TAC is 0
-
- // for safety
- if (bp.nOutputChans >= cmsMAXCHANNELS) return 0;
-
- hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
- if (hLab == NULL) return 0;
- // Setup a roundtrip on perceptual intent in output profile for TAC estimation
- bp.hRoundTrip = cmsCreateTransformTHR(ContextID, hLab, TYPE_Lab_16,
- hProfile, dwFormatter, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
-
- cmsCloseProfile(hLab);
- if (bp.hRoundTrip == NULL) return 0;
-
- // For L* we only need black and white. For C* we need many points
- GridPoints[0] = 6;
- GridPoints[1] = 74;
- GridPoints[2] = 74;
-
-
- if (!cmsSliceSpace16(3, GridPoints, EstimateTAC, &bp)) {
- bp.MaxTAC = 0;
- }
-
- cmsDeleteTransform(bp.hRoundTrip);
-
- // Results in %
- return bp.MaxTAC;
-}
-
-
-// Carefully, clamp on CIELab space.
-
-cmsBool CMSEXPORT cmsDesaturateLab(cmsCIELab* Lab,
- double amax, double amin,
- double bmax, double bmin)
-{
-
- // Whole Luma surface to zero
-
- if (Lab -> L < 0) {
-
- Lab-> L = Lab->a = Lab-> b = 0.0;
- return FALSE;
- }
-
- // Clamp white, DISCARD HIGHLIGHTS. This is done
- // in such way because icc spec doesn't allow the
- // use of L>100 as a highlight means.
-
- if (Lab->L > 100)
- Lab -> L = 100;
-
- // Check out gamut prism, on a, b faces
-
- if (Lab -> a < amin || Lab->a > amax||
- Lab -> b < bmin || Lab->b > bmax) {
-
- cmsCIELCh LCh;
- double h, slope;
-
- // Falls outside a, b limits. Transports to LCh space,
- // and then do the clipping
-
-
- if (Lab -> a == 0.0) { // Is hue exactly 90?
-
- // atan will not work, so clamp here
- Lab -> b = Lab->b < 0 ? bmin : bmax;
- return TRUE;
- }
-
- cmsLab2LCh(&LCh, Lab);
-
- slope = Lab -> b / Lab -> a;
- h = LCh.h;
-
- // There are 4 zones
-
- if ((h >= 0. && h < 45.) ||
- (h >= 315 && h <= 360.)) {
-
- // clip by amax
- Lab -> a = amax;
- Lab -> b = amax * slope;
- }
- else
- if (h >= 45. && h < 135.)
- {
- // clip by bmax
- Lab -> b = bmax;
- Lab -> a = bmax / slope;
- }
- else
- if (h >= 135. && h < 225.) {
- // clip by amin
- Lab -> a = amin;
- Lab -> b = amin * slope;
-
- }
- else
- if (h >= 225. && h < 315.) {
- // clip by bmin
- Lab -> b = bmin;
- Lab -> a = bmin / slope;
- }
- else {
- cmsSignalError(0, cmsERROR_RANGE, "Invalid angle");
- return FALSE;
- }
-
- }
-
- return TRUE;
-}
+//---------------------------------------------------------------------------------\r
+//\r
+// Little Color Management System\r
+// Copyright (c) 1998-2012 Marti Maria Saguer\r
+//\r
+// Permission is hereby granted, free of charge, to any person obtaining\r
+// a copy of this software and associated documentation files (the "Software"),\r
+// to deal in the Software without restriction, including without limitation\r
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
+// and/or sell copies of the Software, and to permit persons to whom the Software\r
+// is furnished to do so, subject to the following conditions:\r
+//\r
+// The above copyright notice and this permission notice shall be included in\r
+// all copies or substantial portions of the Software.\r
+//\r
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO\r
+// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+//\r
+//---------------------------------------------------------------------------------\r
+//\r
+\r
+#include "lcms2_internal.h"\r
+\r
+\r
+// Auxiliar: append a Lab identity after the given sequence of profiles\r
+// and return the transform. Lab profile is closed, rest of profiles are kept open.\r
+cmsHTRANSFORM _cmsChain2Lab(cmsContext ContextID,\r
+ cmsUInt32Number nProfiles,\r
+ cmsUInt32Number InputFormat,\r
+ cmsUInt32Number OutputFormat,\r
+ const cmsUInt32Number Intents[],\r
+ const cmsHPROFILE hProfiles[],\r
+ const cmsBool BPC[],\r
+ const cmsFloat64Number AdaptationStates[],\r
+ cmsUInt32Number dwFlags)\r
+{\r
+ cmsHTRANSFORM xform;\r
+ cmsHPROFILE hLab;\r
+ cmsHPROFILE ProfileList[256];\r
+ cmsBool BPCList[256];\r
+ cmsFloat64Number AdaptationList[256];\r
+ cmsUInt32Number IntentList[256];\r
+ cmsUInt32Number i;\r
+\r
+ // This is a rather big number and there is no need of dynamic memory\r
+ // since we are adding a profile, 254 + 1 = 255 and this is the limit\r
+ if (nProfiles > 254) return NULL;\r
+\r
+ // The output space\r
+ hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);\r
+ if (hLab == NULL) return NULL;\r
+\r
+ // Create a copy of parameters\r
+ for (i=0; i < nProfiles; i++) {\r
+\r
+ ProfileList[i] = hProfiles[i];\r
+ BPCList[i] = BPC[i];\r
+ AdaptationList[i] = AdaptationStates[i];\r
+ IntentList[i] = Intents[i];\r
+ }\r
+\r
+ // Place Lab identity at chain's end.\r
+ ProfileList[nProfiles] = hLab;\r
+ BPCList[nProfiles] = 0;\r
+ AdaptationList[nProfiles] = 1.0;\r
+ IntentList[nProfiles] = INTENT_RELATIVE_COLORIMETRIC;\r
+\r
+ // Create the transform\r
+ xform = cmsCreateExtendedTransform(ContextID, nProfiles + 1, ProfileList,\r
+ BPCList,\r
+ IntentList,\r
+ AdaptationList,\r
+ NULL, 0,\r
+ InputFormat,\r
+ OutputFormat,\r
+ dwFlags);\r
+\r
+ cmsCloseProfile(hLab);\r
+\r
+ return xform;\r
+}\r
+\r
+\r
+// Compute K -> L* relationship. Flags may include black point compensation. In this case,\r
+// the relationship is assumed from the profile with BPC to a black point zero.\r
+static\r
+cmsToneCurve* ComputeKToLstar(cmsContext ContextID,\r
+ cmsUInt32Number nPoints,\r
+ cmsUInt32Number nProfiles,\r
+ const cmsUInt32Number Intents[],\r
+ const cmsHPROFILE hProfiles[],\r
+ const cmsBool BPC[],\r
+ const cmsFloat64Number AdaptationStates[],\r
+ cmsUInt32Number dwFlags)\r
+{\r
+ cmsToneCurve* out = NULL;\r
+ cmsUInt32Number i;\r
+ cmsHTRANSFORM xform;\r
+ cmsCIELab Lab;\r
+ cmsFloat32Number cmyk[4];\r
+ cmsFloat32Number* SampledPoints;\r
+\r
+ xform = _cmsChain2Lab(ContextID, nProfiles, TYPE_CMYK_FLT, TYPE_Lab_DBL, Intents, hProfiles, BPC, AdaptationStates, dwFlags);\r
+ if (xform == NULL) return NULL;\r
+\r
+ SampledPoints = (cmsFloat32Number*) _cmsCalloc(ContextID, nPoints, sizeof(cmsFloat32Number));\r
+ if (SampledPoints == NULL) goto Error;\r
+\r
+ for (i=0; i < nPoints; i++) {\r
+\r
+ cmyk[0] = 0;\r
+ cmyk[1] = 0;\r
+ cmyk[2] = 0;\r
+ cmyk[3] = (cmsFloat32Number) ((i * 100.0) / (nPoints-1));\r
+\r
+ cmsDoTransform(xform, cmyk, &Lab, 1);\r
+ SampledPoints[i]= (cmsFloat32Number) (1.0 - Lab.L / 100.0); // Negate K for easier operation\r
+ }\r
+\r
+ out = cmsBuildTabulatedToneCurveFloat(ContextID, nPoints, SampledPoints);\r
+\r
+Error:\r
+\r
+ cmsDeleteTransform(xform);\r
+ if (SampledPoints) _cmsFree(ContextID, SampledPoints);\r
+\r
+ return out;\r
+}\r
+\r
+\r
+// Compute Black tone curve on a CMYK -> CMYK transform. This is done by\r
+// using the proof direction on both profiles to find K->L* relationship\r
+// then joining both curves. dwFlags may include black point compensation.\r
+cmsToneCurve* _cmsBuildKToneCurve(cmsContext ContextID,\r
+ cmsUInt32Number nPoints,\r
+ cmsUInt32Number nProfiles,\r
+ const cmsUInt32Number Intents[],\r
+ const cmsHPROFILE hProfiles[],\r
+ const cmsBool BPC[],\r
+ const cmsFloat64Number AdaptationStates[],\r
+ cmsUInt32Number dwFlags)\r
+{\r
+ cmsToneCurve *in, *out, *KTone;\r
+\r
+ // Make sure CMYK -> CMYK\r
+ if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||\r
+ cmsGetColorSpace(hProfiles[nProfiles-1])!= cmsSigCmykData) return NULL;\r
+\r
+\r
+ // Make sure last is an output profile\r
+ if (cmsGetDeviceClass(hProfiles[nProfiles - 1]) != cmsSigOutputClass) return NULL;\r
+\r
+ // Create individual curves. BPC works also as each K to L* is\r
+ // computed as a BPC to zero black point in case of L*\r
+ in = ComputeKToLstar(ContextID, nPoints, nProfiles - 1, Intents, hProfiles, BPC, AdaptationStates, dwFlags);\r
+ if (in == NULL) return NULL;\r
+\r
+ out = ComputeKToLstar(ContextID, nPoints, 1,\r
+ Intents + (nProfiles - 1),\r
+ &hProfiles [nProfiles - 1],\r
+ BPC + (nProfiles - 1),\r
+ AdaptationStates + (nProfiles - 1),\r
+ dwFlags);\r
+ if (out == NULL) {\r
+ cmsFreeToneCurve(in);\r
+ return NULL;\r
+ }\r
+\r
+ // Build the relationship. This effectively limits the maximum accuracy to 16 bits, but\r
+ // since this is used on black-preserving LUTs, we are not loosing accuracy in any case\r
+ KTone = cmsJoinToneCurve(ContextID, in, out, nPoints);\r
+\r
+ // Get rid of components\r
+ cmsFreeToneCurve(in); cmsFreeToneCurve(out);\r
+\r
+ // Something went wrong...\r
+ if (KTone == NULL) return NULL;\r
+\r
+ // Make sure it is monotonic\r
+ if (!cmsIsToneCurveMonotonic(KTone)) {\r
+ cmsFreeToneCurve(KTone);\r
+ return NULL;\r
+ }\r
+\r
+ return KTone;\r
+}\r
+\r
+\r
+// Gamut LUT Creation -----------------------------------------------------------------------------------------\r
+\r
+// Used by gamut & softproofing\r
+\r
+typedef struct {\r
+\r
+ cmsHTRANSFORM hInput; // From whatever input color space. 16 bits to DBL\r
+ cmsHTRANSFORM hForward, hReverse; // Transforms going from Lab to colorant and back\r
+ cmsFloat64Number Thereshold; // The thereshold after which is considered out of gamut\r
+\r
+ } GAMUTCHAIN;\r
+\r
+// This sampler does compute gamut boundaries by comparing original\r
+// values with a transform going back and forth. Values above ERR_THERESHOLD\r
+// of maximum are considered out of gamut.\r
+\r
+#define ERR_THERESHOLD 5\r
+\r
+\r
+static\r
+int GamutSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)\r
+{\r
+ GAMUTCHAIN* t = (GAMUTCHAIN* ) Cargo;\r
+ cmsCIELab LabIn1, LabOut1;\r
+ cmsCIELab LabIn2, LabOut2;\r
+ cmsUInt16Number Proof[cmsMAXCHANNELS], Proof2[cmsMAXCHANNELS];\r
+ cmsFloat64Number dE1, dE2, ErrorRatio;\r
+\r
+ // Assume in-gamut by default.\r
+ ErrorRatio = 1.0;\r
+\r
+ // Convert input to Lab\r
+ cmsDoTransform(t -> hInput, In, &LabIn1, 1);\r
+\r
+ // converts from PCS to colorant. This always\r
+ // does return in-gamut values,\r
+ cmsDoTransform(t -> hForward, &LabIn1, Proof, 1);\r
+\r
+ // Now, do the inverse, from colorant to PCS.\r
+ cmsDoTransform(t -> hReverse, Proof, &LabOut1, 1);\r
+\r
+ memmove(&LabIn2, &LabOut1, sizeof(cmsCIELab));\r
+\r
+ // Try again, but this time taking Check as input\r
+ cmsDoTransform(t -> hForward, &LabOut1, Proof2, 1);\r
+ cmsDoTransform(t -> hReverse, Proof2, &LabOut2, 1);\r
+\r
+ // Take difference of direct value\r
+ dE1 = cmsDeltaE(&LabIn1, &LabOut1);\r
+\r
+ // Take difference of converted value\r
+ dE2 = cmsDeltaE(&LabIn2, &LabOut2);\r
+\r
+\r
+ // if dE1 is small and dE2 is small, value is likely to be in gamut\r
+ if (dE1 < t->Thereshold && dE2 < t->Thereshold)\r
+ Out[0] = 0;\r
+ else {\r
+\r
+ // if dE1 is small and dE2 is big, undefined. Assume in gamut\r
+ if (dE1 < t->Thereshold && dE2 > t->Thereshold)\r
+ Out[0] = 0;\r
+ else\r
+ // dE1 is big and dE2 is small, clearly out of gamut\r
+ if (dE1 > t->Thereshold && dE2 < t->Thereshold)\r
+ Out[0] = (cmsUInt16Number) _cmsQuickFloor((dE1 - t->Thereshold) + .5);\r
+ else {\r
+\r
+ // dE1 is big and dE2 is also big, could be due to perceptual mapping\r
+ // so take error ratio\r
+ if (dE2 == 0.0)\r
+ ErrorRatio = dE1;\r
+ else\r
+ ErrorRatio = dE1 / dE2;\r
+\r
+ if (ErrorRatio > t->Thereshold)\r
+ Out[0] = (cmsUInt16Number) _cmsQuickFloor((ErrorRatio - t->Thereshold) + .5);\r
+ else\r
+ Out[0] = 0;\r
+ }\r
+ }\r
+\r
+\r
+ return TRUE;\r
+}\r
+\r
+// Does compute a gamut LUT going back and forth across pcs -> relativ. colorimetric intent -> pcs\r
+// the dE obtained is then annotated on the LUT. Values truely out of gamut are clipped to dE = 0xFFFE\r
+// and values changed are supposed to be handled by any gamut remapping, so, are out of gamut as well.\r
+//\r
+// **WARNING: This algorithm does assume that gamut remapping algorithms does NOT move in-gamut colors,\r
+// of course, many perceptual and saturation intents does not work in such way, but relativ. ones should.\r
+\r
+cmsPipeline* _cmsCreateGamutCheckPipeline(cmsContext ContextID,\r
+ cmsHPROFILE hProfiles[],\r
+ cmsBool BPC[],\r
+ cmsUInt32Number Intents[],\r
+ cmsFloat64Number AdaptationStates[],\r
+ cmsUInt32Number nGamutPCSposition,\r
+ cmsHPROFILE hGamut)\r
+{\r
+ cmsHPROFILE hLab;\r
+ cmsPipeline* Gamut;\r
+ cmsStage* CLUT;\r
+ cmsUInt32Number dwFormat;\r
+ GAMUTCHAIN Chain;\r
+ int nChannels, nGridpoints;\r
+ cmsColorSpaceSignature ColorSpace;\r
+ cmsUInt32Number i;\r
+ cmsHPROFILE ProfileList[256];\r
+ cmsBool BPCList[256];\r
+ cmsFloat64Number AdaptationList[256];\r
+ cmsUInt32Number IntentList[256];\r
+\r
+ memset(&Chain, 0, sizeof(GAMUTCHAIN));\r
+\r
+\r
+ if (nGamutPCSposition <= 0 || nGamutPCSposition > 255) {\r
+ cmsSignalError(ContextID, cmsERROR_RANGE, "Wrong position of PCS. 1..255 expected, %d found.", nGamutPCSposition);\r
+ return NULL;\r
+ }\r
+\r
+ hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);\r
+ if (hLab == NULL) return NULL;\r
+\r
+\r
+ // The figure of merit. On matrix-shaper profiles, should be almost zero as\r
+ // the conversion is pretty exact. On LUT based profiles, different resolutions\r
+ // of input and output CLUT may result in differences.\r
+\r
+ if (cmsIsMatrixShaper(hGamut)) {\r
+\r
+ Chain.Thereshold = 1.0;\r
+ }\r
+ else {\r
+ Chain.Thereshold = ERR_THERESHOLD;\r
+ }\r
+\r
+\r
+ // Create a copy of parameters\r
+ for (i=0; i < nGamutPCSposition; i++) {\r
+ ProfileList[i] = hProfiles[i];\r
+ BPCList[i] = BPC[i];\r
+ AdaptationList[i] = AdaptationStates[i];\r
+ IntentList[i] = Intents[i];\r
+ }\r
+\r
+ // Fill Lab identity\r
+ ProfileList[nGamutPCSposition] = hLab;\r
+ BPCList[nGamutPCSposition] = 0;\r
+ AdaptationList[nGamutPCSposition] = 1.0;\r
+ IntentList[nGamutPCSposition] = INTENT_RELATIVE_COLORIMETRIC;\r
+\r
+\r
+ ColorSpace = cmsGetColorSpace(hGamut);\r
+\r
+ nChannels = cmsChannelsOf(ColorSpace);\r
+ nGridpoints = _cmsReasonableGridpointsByColorspace(ColorSpace, cmsFLAGS_HIGHRESPRECALC);\r
+ dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2));\r
+\r
+ // 16 bits to Lab double\r
+ Chain.hInput = cmsCreateExtendedTransform(ContextID,\r
+ nGamutPCSposition + 1,\r
+ ProfileList,\r
+ BPCList,\r
+ IntentList,\r
+ AdaptationList,\r
+ NULL, 0,\r
+ dwFormat, TYPE_Lab_DBL,\r
+ cmsFLAGS_NOCACHE);\r
+\r
+\r
+ // Does create the forward step. Lab double to device\r
+ dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2));\r
+ Chain.hForward = cmsCreateTransformTHR(ContextID,\r
+ hLab, TYPE_Lab_DBL,\r
+ hGamut, dwFormat,\r
+ INTENT_RELATIVE_COLORIMETRIC,\r
+ cmsFLAGS_NOCACHE);\r
+\r
+ // Does create the backwards step\r
+ Chain.hReverse = cmsCreateTransformTHR(ContextID, hGamut, dwFormat,\r
+ hLab, TYPE_Lab_DBL,\r
+ INTENT_RELATIVE_COLORIMETRIC,\r
+ cmsFLAGS_NOCACHE);\r
+\r
+\r
+ // All ok?\r
+ if (Chain.hInput && Chain.hForward && Chain.hReverse) {\r
+\r
+ // Go on, try to compute gamut LUT from PCS. This consist on a single channel containing\r
+ // dE when doing a transform back and forth on the colorimetric intent.\r
+\r
+ Gamut = cmsPipelineAlloc(ContextID, 3, 1);\r
+ if (Gamut != NULL) {\r
+\r
+ CLUT = cmsStageAllocCLut16bit(ContextID, nGridpoints, nChannels, 1, NULL);\r
+ if (!cmsPipelineInsertStage(Gamut, cmsAT_BEGIN, CLUT)) {\r
+ cmsPipelineFree(Gamut);\r
+ Gamut = NULL;\r
+ } \r
+ else {\r
+ cmsStageSampleCLut16bit(CLUT, GamutSampler, (void*) &Chain, 0);\r
+ }\r
+ }\r
+ }\r
+ else\r
+ Gamut = NULL; // Didn't work...\r
+\r
+ // Free all needed stuff.\r
+ if (Chain.hInput) cmsDeleteTransform(Chain.hInput);\r
+ if (Chain.hForward) cmsDeleteTransform(Chain.hForward);\r
+ if (Chain.hReverse) cmsDeleteTransform(Chain.hReverse);\r
+ if (hLab) cmsCloseProfile(hLab);\r
+\r
+ // And return computed hull\r
+ return Gamut;\r
+}\r
+\r
+// Total Area Coverage estimation ----------------------------------------------------------------\r
+\r
+typedef struct {\r
+ cmsUInt32Number nOutputChans;\r
+ cmsHTRANSFORM hRoundTrip;\r
+ cmsFloat32Number MaxTAC;\r
+ cmsFloat32Number MaxInput[cmsMAXCHANNELS];\r
+\r
+} cmsTACestimator;\r
+\r
+\r
+// This callback just accounts the maximum ink dropped in the given node. It does not populate any\r
+// memory, as the destination table is NULL. Its only purpose it to know the global maximum.\r
+static\r
+int EstimateTAC(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void * Cargo)\r
+{\r
+ cmsTACestimator* bp = (cmsTACestimator*) Cargo;\r
+ cmsFloat32Number RoundTrip[cmsMAXCHANNELS];\r
+ cmsUInt32Number i;\r
+ cmsFloat32Number Sum;\r
+\r
+\r
+ // Evaluate the xform\r
+ cmsDoTransform(bp->hRoundTrip, In, RoundTrip, 1);\r
+\r
+ // All all amounts of ink\r
+ for (Sum=0, i=0; i < bp ->nOutputChans; i++)\r
+ Sum += RoundTrip[i];\r
+\r
+ // If above maximum, keep track of input values\r
+ if (Sum > bp ->MaxTAC) {\r
+\r
+ bp ->MaxTAC = Sum;\r
+\r
+ for (i=0; i < bp ->nOutputChans; i++) {\r
+ bp ->MaxInput[i] = In[i];\r
+ }\r
+ }\r
+\r
+ return TRUE;\r
+\r
+ cmsUNUSED_PARAMETER(Out);\r
+}\r
+\r
+\r
+// Detect Total area coverage of the profile\r
+cmsFloat64Number CMSEXPORT cmsDetectTAC(cmsHPROFILE hProfile)\r
+{\r
+ cmsTACestimator bp;\r
+ cmsUInt32Number dwFormatter;\r
+ cmsUInt32Number GridPoints[MAX_INPUT_DIMENSIONS];\r
+ cmsHPROFILE hLab;\r
+ cmsContext ContextID = cmsGetProfileContextID(hProfile);\r
+\r
+ // TAC only works on output profiles\r
+ if (cmsGetDeviceClass(hProfile) != cmsSigOutputClass) {\r
+ return 0;\r
+ }\r
+\r
+ // Create a fake formatter for result\r
+ dwFormatter = cmsFormatterForColorspaceOfProfile(hProfile, 4, TRUE);\r
+\r
+ bp.nOutputChans = T_CHANNELS(dwFormatter);\r
+ bp.MaxTAC = 0; // Initial TAC is 0\r
+\r
+ // for safety\r
+ if (bp.nOutputChans >= cmsMAXCHANNELS) return 0;\r
+\r
+ hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);\r
+ if (hLab == NULL) return 0;\r
+ // Setup a roundtrip on perceptual intent in output profile for TAC estimation\r
+ bp.hRoundTrip = cmsCreateTransformTHR(ContextID, hLab, TYPE_Lab_16,\r
+ hProfile, dwFormatter, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);\r
+\r
+ cmsCloseProfile(hLab);\r
+ if (bp.hRoundTrip == NULL) return 0;\r
+\r
+ // For L* we only need black and white. For C* we need many points\r
+ GridPoints[0] = 6;\r
+ GridPoints[1] = 74;\r
+ GridPoints[2] = 74;\r
+\r
+\r
+ if (!cmsSliceSpace16(3, GridPoints, EstimateTAC, &bp)) {\r
+ bp.MaxTAC = 0;\r
+ }\r
+\r
+ cmsDeleteTransform(bp.hRoundTrip);\r
+\r
+ // Results in %\r
+ return bp.MaxTAC;\r
+}\r
+\r
+\r
+// Carefully, clamp on CIELab space.\r
+\r
+cmsBool CMSEXPORT cmsDesaturateLab(cmsCIELab* Lab,\r
+ double amax, double amin,\r
+ double bmax, double bmin)\r
+{\r
+\r
+ // Whole Luma surface to zero\r
+\r
+ if (Lab -> L < 0) {\r
+\r
+ Lab-> L = Lab->a = Lab-> b = 0.0;\r
+ return FALSE;\r
+ }\r
+\r
+ // Clamp white, DISCARD HIGHLIGHTS. This is done\r
+ // in such way because icc spec doesn't allow the\r
+ // use of L>100 as a highlight means.\r
+\r
+ if (Lab->L > 100)\r
+ Lab -> L = 100;\r
+\r
+ // Check out gamut prism, on a, b faces\r
+\r
+ if (Lab -> a < amin || Lab->a > amax||\r
+ Lab -> b < bmin || Lab->b > bmax) {\r
+\r
+ cmsCIELCh LCh;\r
+ double h, slope;\r
+\r
+ // Falls outside a, b limits. Transports to LCh space,\r
+ // and then do the clipping\r
+\r
+\r
+ if (Lab -> a == 0.0) { // Is hue exactly 90?\r
+\r
+ // atan will not work, so clamp here\r
+ Lab -> b = Lab->b < 0 ? bmin : bmax;\r
+ return TRUE;\r
+ }\r
+\r
+ cmsLab2LCh(&LCh, Lab);\r
+\r
+ slope = Lab -> b / Lab -> a;\r
+ h = LCh.h;\r
+\r
+ // There are 4 zones\r
+\r
+ if ((h >= 0. && h < 45.) ||\r
+ (h >= 315 && h <= 360.)) {\r
+\r
+ // clip by amax\r
+ Lab -> a = amax;\r
+ Lab -> b = amax * slope;\r
+ }\r
+ else\r
+ if (h >= 45. && h < 135.)\r
+ {\r
+ // clip by bmax\r
+ Lab -> b = bmax;\r
+ Lab -> a = bmax / slope;\r
+ }\r
+ else\r
+ if (h >= 135. && h < 225.) {\r
+ // clip by amin\r
+ Lab -> a = amin;\r
+ Lab -> b = amin * slope;\r
+\r
+ }\r
+ else\r
+ if (h >= 225. && h < 315.) {\r
+ // clip by bmin\r
+ Lab -> b = bmin;\r
+ Lab -> a = bmin / slope;\r
+ }\r
+ else {\r
+ cmsSignalError(0, cmsERROR_RANGE, "Invalid angle");\r
+ return FALSE;\r
+ }\r
+\r
+ }\r
+\r
+ return TRUE;\r
+}\r
--- /dev/null
+//---------------------------------------------------------------------------------
+//
+// Little Color Management System
+// Copyright (c) 1998-2012 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.
+//
+//---------------------------------------------------------------------------------
+//
+//
+#include "lcms2_internal.h"
+
+#ifndef CMS_NO_HALF_SUPPORT
+
+// This code is inspired in the paper "Fast Half Float Conversions"
+// by Jeroen van der Zijp
+
+static cmsUInt32Number Mantissa[2048] = {
+
+0x00000000, 0x33800000, 0x34000000, 0x34400000, 0x34800000, 0x34a00000,
+0x34c00000, 0x34e00000, 0x35000000, 0x35100000, 0x35200000, 0x35300000,
+0x35400000, 0x35500000, 0x35600000, 0x35700000, 0x35800000, 0x35880000,
+0x35900000, 0x35980000, 0x35a00000, 0x35a80000, 0x35b00000, 0x35b80000,
+0x35c00000, 0x35c80000, 0x35d00000, 0x35d80000, 0x35e00000, 0x35e80000,
+0x35f00000, 0x35f80000, 0x36000000, 0x36040000, 0x36080000, 0x360c0000,
+0x36100000, 0x36140000, 0x36180000, 0x361c0000, 0x36200000, 0x36240000,
+0x36280000, 0x362c0000, 0x36300000, 0x36340000, 0x36380000, 0x363c0000,
+0x36400000, 0x36440000, 0x36480000, 0x364c0000, 0x36500000, 0x36540000,
+0x36580000, 0x365c0000, 0x36600000, 0x36640000, 0x36680000, 0x366c0000,
+0x36700000, 0x36740000, 0x36780000, 0x367c0000, 0x36800000, 0x36820000,
+0x36840000, 0x36860000, 0x36880000, 0x368a0000, 0x368c0000, 0x368e0000,
+0x36900000, 0x36920000, 0x36940000, 0x36960000, 0x36980000, 0x369a0000,
+0x369c0000, 0x369e0000, 0x36a00000, 0x36a20000, 0x36a40000, 0x36a60000,
+0x36a80000, 0x36aa0000, 0x36ac0000, 0x36ae0000, 0x36b00000, 0x36b20000,
+0x36b40000, 0x36b60000, 0x36b80000, 0x36ba0000, 0x36bc0000, 0x36be0000,
+0x36c00000, 0x36c20000, 0x36c40000, 0x36c60000, 0x36c80000, 0x36ca0000,
+0x36cc0000, 0x36ce0000, 0x36d00000, 0x36d20000, 0x36d40000, 0x36d60000,
+0x36d80000, 0x36da0000, 0x36dc0000, 0x36de0000, 0x36e00000, 0x36e20000,
+0x36e40000, 0x36e60000, 0x36e80000, 0x36ea0000, 0x36ec0000, 0x36ee0000,
+0x36f00000, 0x36f20000, 0x36f40000, 0x36f60000, 0x36f80000, 0x36fa0000,
+0x36fc0000, 0x36fe0000, 0x37000000, 0x37010000, 0x37020000, 0x37030000,
+0x37040000, 0x37050000, 0x37060000, 0x37070000, 0x37080000, 0x37090000,
+0x370a0000, 0x370b0000, 0x370c0000, 0x370d0000, 0x370e0000, 0x370f0000,
+0x37100000, 0x37110000, 0x37120000, 0x37130000, 0x37140000, 0x37150000,
+0x37160000, 0x37170000, 0x37180000, 0x37190000, 0x371a0000, 0x371b0000,
+0x371c0000, 0x371d0000, 0x371e0000, 0x371f0000, 0x37200000, 0x37210000,
+0x37220000, 0x37230000, 0x37240000, 0x37250000, 0x37260000, 0x37270000,
+0x37280000, 0x37290000, 0x372a0000, 0x372b0000, 0x372c0000, 0x372d0000,
+0x372e0000, 0x372f0000, 0x37300000, 0x37310000, 0x37320000, 0x37330000,
+0x37340000, 0x37350000, 0x37360000, 0x37370000, 0x37380000, 0x37390000,
+0x373a0000, 0x373b0000, 0x373c0000, 0x373d0000, 0x373e0000, 0x373f0000,
+0x37400000, 0x37410000, 0x37420000, 0x37430000, 0x37440000, 0x37450000,
+0x37460000, 0x37470000, 0x37480000, 0x37490000, 0x374a0000, 0x374b0000,
+0x374c0000, 0x374d0000, 0x374e0000, 0x374f0000, 0x37500000, 0x37510000,
+0x37520000, 0x37530000, 0x37540000, 0x37550000, 0x37560000, 0x37570000,
+0x37580000, 0x37590000, 0x375a0000, 0x375b0000, 0x375c0000, 0x375d0000,
+0x375e0000, 0x375f0000, 0x37600000, 0x37610000, 0x37620000, 0x37630000,
+0x37640000, 0x37650000, 0x37660000, 0x37670000, 0x37680000, 0x37690000,
+0x376a0000, 0x376b0000, 0x376c0000, 0x376d0000, 0x376e0000, 0x376f0000,
+0x37700000, 0x37710000, 0x37720000, 0x37730000, 0x37740000, 0x37750000,
+0x37760000, 0x37770000, 0x37780000, 0x37790000, 0x377a0000, 0x377b0000,
+0x377c0000, 0x377d0000, 0x377e0000, 0x377f0000, 0x37800000, 0x37808000,
+0x37810000, 0x37818000, 0x37820000, 0x37828000, 0x37830000, 0x37838000,
+0x37840000, 0x37848000, 0x37850000, 0x37858000, 0x37860000, 0x37868000,
+0x37870000, 0x37878000, 0x37880000, 0x37888000, 0x37890000, 0x37898000,
+0x378a0000, 0x378a8000, 0x378b0000, 0x378b8000, 0x378c0000, 0x378c8000,
+0x378d0000, 0x378d8000, 0x378e0000, 0x378e8000, 0x378f0000, 0x378f8000,
+0x37900000, 0x37908000, 0x37910000, 0x37918000, 0x37920000, 0x37928000,
+0x37930000, 0x37938000, 0x37940000, 0x37948000, 0x37950000, 0x37958000,
+0x37960000, 0x37968000, 0x37970000, 0x37978000, 0x37980000, 0x37988000,
+0x37990000, 0x37998000, 0x379a0000, 0x379a8000, 0x379b0000, 0x379b8000,
+0x379c0000, 0x379c8000, 0x379d0000, 0x379d8000, 0x379e0000, 0x379e8000,
+0x379f0000, 0x379f8000, 0x37a00000, 0x37a08000, 0x37a10000, 0x37a18000,
+0x37a20000, 0x37a28000, 0x37a30000, 0x37a38000, 0x37a40000, 0x37a48000,
+0x37a50000, 0x37a58000, 0x37a60000, 0x37a68000, 0x37a70000, 0x37a78000,
+0x37a80000, 0x37a88000, 0x37a90000, 0x37a98000, 0x37aa0000, 0x37aa8000,
+0x37ab0000, 0x37ab8000, 0x37ac0000, 0x37ac8000, 0x37ad0000, 0x37ad8000,
+0x37ae0000, 0x37ae8000, 0x37af0000, 0x37af8000, 0x37b00000, 0x37b08000,
+0x37b10000, 0x37b18000, 0x37b20000, 0x37b28000, 0x37b30000, 0x37b38000,
+0x37b40000, 0x37b48000, 0x37b50000, 0x37b58000, 0x37b60000, 0x37b68000,
+0x37b70000, 0x37b78000, 0x37b80000, 0x37b88000, 0x37b90000, 0x37b98000,
+0x37ba0000, 0x37ba8000, 0x37bb0000, 0x37bb8000, 0x37bc0000, 0x37bc8000,
+0x37bd0000, 0x37bd8000, 0x37be0000, 0x37be8000, 0x37bf0000, 0x37bf8000,
+0x37c00000, 0x37c08000, 0x37c10000, 0x37c18000, 0x37c20000, 0x37c28000,
+0x37c30000, 0x37c38000, 0x37c40000, 0x37c48000, 0x37c50000, 0x37c58000,
+0x37c60000, 0x37c68000, 0x37c70000, 0x37c78000, 0x37c80000, 0x37c88000,
+0x37c90000, 0x37c98000, 0x37ca0000, 0x37ca8000, 0x37cb0000, 0x37cb8000,
+0x37cc0000, 0x37cc8000, 0x37cd0000, 0x37cd8000, 0x37ce0000, 0x37ce8000,
+0x37cf0000, 0x37cf8000, 0x37d00000, 0x37d08000, 0x37d10000, 0x37d18000,
+0x37d20000, 0x37d28000, 0x37d30000, 0x37d38000, 0x37d40000, 0x37d48000,
+0x37d50000, 0x37d58000, 0x37d60000, 0x37d68000, 0x37d70000, 0x37d78000,
+0x37d80000, 0x37d88000, 0x37d90000, 0x37d98000, 0x37da0000, 0x37da8000,
+0x37db0000, 0x37db8000, 0x37dc0000, 0x37dc8000, 0x37dd0000, 0x37dd8000,
+0x37de0000, 0x37de8000, 0x37df0000, 0x37df8000, 0x37e00000, 0x37e08000,
+0x37e10000, 0x37e18000, 0x37e20000, 0x37e28000, 0x37e30000, 0x37e38000,
+0x37e40000, 0x37e48000, 0x37e50000, 0x37e58000, 0x37e60000, 0x37e68000,
+0x37e70000, 0x37e78000, 0x37e80000, 0x37e88000, 0x37e90000, 0x37e98000,
+0x37ea0000, 0x37ea8000, 0x37eb0000, 0x37eb8000, 0x37ec0000, 0x37ec8000,
+0x37ed0000, 0x37ed8000, 0x37ee0000, 0x37ee8000, 0x37ef0000, 0x37ef8000,
+0x37f00000, 0x37f08000, 0x37f10000, 0x37f18000, 0x37f20000, 0x37f28000,
+0x37f30000, 0x37f38000, 0x37f40000, 0x37f48000, 0x37f50000, 0x37f58000,
+0x37f60000, 0x37f68000, 0x37f70000, 0x37f78000, 0x37f80000, 0x37f88000,
+0x37f90000, 0x37f98000, 0x37fa0000, 0x37fa8000, 0x37fb0000, 0x37fb8000,
+0x37fc0000, 0x37fc8000, 0x37fd0000, 0x37fd8000, 0x37fe0000, 0x37fe8000,
+0x37ff0000, 0x37ff8000, 0x38000000, 0x38004000, 0x38008000, 0x3800c000,
+0x38010000, 0x38014000, 0x38018000, 0x3801c000, 0x38020000, 0x38024000,
+0x38028000, 0x3802c000, 0x38030000, 0x38034000, 0x38038000, 0x3803c000,
+0x38040000, 0x38044000, 0x38048000, 0x3804c000, 0x38050000, 0x38054000,
+0x38058000, 0x3805c000, 0x38060000, 0x38064000, 0x38068000, 0x3806c000,
+0x38070000, 0x38074000, 0x38078000, 0x3807c000, 0x38080000, 0x38084000,
+0x38088000, 0x3808c000, 0x38090000, 0x38094000, 0x38098000, 0x3809c000,
+0x380a0000, 0x380a4000, 0x380a8000, 0x380ac000, 0x380b0000, 0x380b4000,
+0x380b8000, 0x380bc000, 0x380c0000, 0x380c4000, 0x380c8000, 0x380cc000,
+0x380d0000, 0x380d4000, 0x380d8000, 0x380dc000, 0x380e0000, 0x380e4000,
+0x380e8000, 0x380ec000, 0x380f0000, 0x380f4000, 0x380f8000, 0x380fc000,
+0x38100000, 0x38104000, 0x38108000, 0x3810c000, 0x38110000, 0x38114000,
+0x38118000, 0x3811c000, 0x38120000, 0x38124000, 0x38128000, 0x3812c000,
+0x38130000, 0x38134000, 0x38138000, 0x3813c000, 0x38140000, 0x38144000,
+0x38148000, 0x3814c000, 0x38150000, 0x38154000, 0x38158000, 0x3815c000,
+0x38160000, 0x38164000, 0x38168000, 0x3816c000, 0x38170000, 0x38174000,
+0x38178000, 0x3817c000, 0x38180000, 0x38184000, 0x38188000, 0x3818c000,
+0x38190000, 0x38194000, 0x38198000, 0x3819c000, 0x381a0000, 0x381a4000,
+0x381a8000, 0x381ac000, 0x381b0000, 0x381b4000, 0x381b8000, 0x381bc000,
+0x381c0000, 0x381c4000, 0x381c8000, 0x381cc000, 0x381d0000, 0x381d4000,
+0x381d8000, 0x381dc000, 0x381e0000, 0x381e4000, 0x381e8000, 0x381ec000,
+0x381f0000, 0x381f4000, 0x381f8000, 0x381fc000, 0x38200000, 0x38204000,
+0x38208000, 0x3820c000, 0x38210000, 0x38214000, 0x38218000, 0x3821c000,
+0x38220000, 0x38224000, 0x38228000, 0x3822c000, 0x38230000, 0x38234000,
+0x38238000, 0x3823c000, 0x38240000, 0x38244000, 0x38248000, 0x3824c000,
+0x38250000, 0x38254000, 0x38258000, 0x3825c000, 0x38260000, 0x38264000,
+0x38268000, 0x3826c000, 0x38270000, 0x38274000, 0x38278000, 0x3827c000,
+0x38280000, 0x38284000, 0x38288000, 0x3828c000, 0x38290000, 0x38294000,
+0x38298000, 0x3829c000, 0x382a0000, 0x382a4000, 0x382a8000, 0x382ac000,
+0x382b0000, 0x382b4000, 0x382b8000, 0x382bc000, 0x382c0000, 0x382c4000,
+0x382c8000, 0x382cc000, 0x382d0000, 0x382d4000, 0x382d8000, 0x382dc000,
+0x382e0000, 0x382e4000, 0x382e8000, 0x382ec000, 0x382f0000, 0x382f4000,
+0x382f8000, 0x382fc000, 0x38300000, 0x38304000, 0x38308000, 0x3830c000,
+0x38310000, 0x38314000, 0x38318000, 0x3831c000, 0x38320000, 0x38324000,
+0x38328000, 0x3832c000, 0x38330000, 0x38334000, 0x38338000, 0x3833c000,
+0x38340000, 0x38344000, 0x38348000, 0x3834c000, 0x38350000, 0x38354000,
+0x38358000, 0x3835c000, 0x38360000, 0x38364000, 0x38368000, 0x3836c000,
+0x38370000, 0x38374000, 0x38378000, 0x3837c000, 0x38380000, 0x38384000,
+0x38388000, 0x3838c000, 0x38390000, 0x38394000, 0x38398000, 0x3839c000,
+0x383a0000, 0x383a4000, 0x383a8000, 0x383ac000, 0x383b0000, 0x383b4000,
+0x383b8000, 0x383bc000, 0x383c0000, 0x383c4000, 0x383c8000, 0x383cc000,
+0x383d0000, 0x383d4000, 0x383d8000, 0x383dc000, 0x383e0000, 0x383e4000,
+0x383e8000, 0x383ec000, 0x383f0000, 0x383f4000, 0x383f8000, 0x383fc000,
+0x38400000, 0x38404000, 0x38408000, 0x3840c000, 0x38410000, 0x38414000,
+0x38418000, 0x3841c000, 0x38420000, 0x38424000, 0x38428000, 0x3842c000,
+0x38430000, 0x38434000, 0x38438000, 0x3843c000, 0x38440000, 0x38444000,
+0x38448000, 0x3844c000, 0x38450000, 0x38454000, 0x38458000, 0x3845c000,
+0x38460000, 0x38464000, 0x38468000, 0x3846c000, 0x38470000, 0x38474000,
+0x38478000, 0x3847c000, 0x38480000, 0x38484000, 0x38488000, 0x3848c000,
+0x38490000, 0x38494000, 0x38498000, 0x3849c000, 0x384a0000, 0x384a4000,
+0x384a8000, 0x384ac000, 0x384b0000, 0x384b4000, 0x384b8000, 0x384bc000,
+0x384c0000, 0x384c4000, 0x384c8000, 0x384cc000, 0x384d0000, 0x384d4000,
+0x384d8000, 0x384dc000, 0x384e0000, 0x384e4000, 0x384e8000, 0x384ec000,
+0x384f0000, 0x384f4000, 0x384f8000, 0x384fc000, 0x38500000, 0x38504000,
+0x38508000, 0x3850c000, 0x38510000, 0x38514000, 0x38518000, 0x3851c000,
+0x38520000, 0x38524000, 0x38528000, 0x3852c000, 0x38530000, 0x38534000,
+0x38538000, 0x3853c000, 0x38540000, 0x38544000, 0x38548000, 0x3854c000,
+0x38550000, 0x38554000, 0x38558000, 0x3855c000, 0x38560000, 0x38564000,
+0x38568000, 0x3856c000, 0x38570000, 0x38574000, 0x38578000, 0x3857c000,
+0x38580000, 0x38584000, 0x38588000, 0x3858c000, 0x38590000, 0x38594000,
+0x38598000, 0x3859c000, 0x385a0000, 0x385a4000, 0x385a8000, 0x385ac000,
+0x385b0000, 0x385b4000, 0x385b8000, 0x385bc000, 0x385c0000, 0x385c4000,
+0x385c8000, 0x385cc000, 0x385d0000, 0x385d4000, 0x385d8000, 0x385dc000,
+0x385e0000, 0x385e4000, 0x385e8000, 0x385ec000, 0x385f0000, 0x385f4000,
+0x385f8000, 0x385fc000, 0x38600000, 0x38604000, 0x38608000, 0x3860c000,
+0x38610000, 0x38614000, 0x38618000, 0x3861c000, 0x38620000, 0x38624000,
+0x38628000, 0x3862c000, 0x38630000, 0x38634000, 0x38638000, 0x3863c000,
+0x38640000, 0x38644000, 0x38648000, 0x3864c000, 0x38650000, 0x38654000,
+0x38658000, 0x3865c000, 0x38660000, 0x38664000, 0x38668000, 0x3866c000,
+0x38670000, 0x38674000, 0x38678000, 0x3867c000, 0x38680000, 0x38684000,
+0x38688000, 0x3868c000, 0x38690000, 0x38694000, 0x38698000, 0x3869c000,
+0x386a0000, 0x386a4000, 0x386a8000, 0x386ac000, 0x386b0000, 0x386b4000,
+0x386b8000, 0x386bc000, 0x386c0000, 0x386c4000, 0x386c8000, 0x386cc000,
+0x386d0000, 0x386d4000, 0x386d8000, 0x386dc000, 0x386e0000, 0x386e4000,
+0x386e8000, 0x386ec000, 0x386f0000, 0x386f4000, 0x386f8000, 0x386fc000,
+0x38700000, 0x38704000, 0x38708000, 0x3870c000, 0x38710000, 0x38714000,
+0x38718000, 0x3871c000, 0x38720000, 0x38724000, 0x38728000, 0x3872c000,
+0x38730000, 0x38734000, 0x38738000, 0x3873c000, 0x38740000, 0x38744000,
+0x38748000, 0x3874c000, 0x38750000, 0x38754000, 0x38758000, 0x3875c000,
+0x38760000, 0x38764000, 0x38768000, 0x3876c000, 0x38770000, 0x38774000,
+0x38778000, 0x3877c000, 0x38780000, 0x38784000, 0x38788000, 0x3878c000,
+0x38790000, 0x38794000, 0x38798000, 0x3879c000, 0x387a0000, 0x387a4000,
+0x387a8000, 0x387ac000, 0x387b0000, 0x387b4000, 0x387b8000, 0x387bc000,
+0x387c0000, 0x387c4000, 0x387c8000, 0x387cc000, 0x387d0000, 0x387d4000,
+0x387d8000, 0x387dc000, 0x387e0000, 0x387e4000, 0x387e8000, 0x387ec000,
+0x387f0000, 0x387f4000, 0x387f8000, 0x387fc000, 0x38000000, 0x38002000,
+0x38004000, 0x38006000, 0x38008000, 0x3800a000, 0x3800c000, 0x3800e000,
+0x38010000, 0x38012000, 0x38014000, 0x38016000, 0x38018000, 0x3801a000,
+0x3801c000, 0x3801e000, 0x38020000, 0x38022000, 0x38024000, 0x38026000,
+0x38028000, 0x3802a000, 0x3802c000, 0x3802e000, 0x38030000, 0x38032000,
+0x38034000, 0x38036000, 0x38038000, 0x3803a000, 0x3803c000, 0x3803e000,
+0x38040000, 0x38042000, 0x38044000, 0x38046000, 0x38048000, 0x3804a000,
+0x3804c000, 0x3804e000, 0x38050000, 0x38052000, 0x38054000, 0x38056000,
+0x38058000, 0x3805a000, 0x3805c000, 0x3805e000, 0x38060000, 0x38062000,
+0x38064000, 0x38066000, 0x38068000, 0x3806a000, 0x3806c000, 0x3806e000,
+0x38070000, 0x38072000, 0x38074000, 0x38076000, 0x38078000, 0x3807a000,
+0x3807c000, 0x3807e000, 0x38080000, 0x38082000, 0x38084000, 0x38086000,
+0x38088000, 0x3808a000, 0x3808c000, 0x3808e000, 0x38090000, 0x38092000,
+0x38094000, 0x38096000, 0x38098000, 0x3809a000, 0x3809c000, 0x3809e000,
+0x380a0000, 0x380a2000, 0x380a4000, 0x380a6000, 0x380a8000, 0x380aa000,
+0x380ac000, 0x380ae000, 0x380b0000, 0x380b2000, 0x380b4000, 0x380b6000,
+0x380b8000, 0x380ba000, 0x380bc000, 0x380be000, 0x380c0000, 0x380c2000,
+0x380c4000, 0x380c6000, 0x380c8000, 0x380ca000, 0x380cc000, 0x380ce000,
+0x380d0000, 0x380d2000, 0x380d4000, 0x380d6000, 0x380d8000, 0x380da000,
+0x380dc000, 0x380de000, 0x380e0000, 0x380e2000, 0x380e4000, 0x380e6000,
+0x380e8000, 0x380ea000, 0x380ec000, 0x380ee000, 0x380f0000, 0x380f2000,
+0x380f4000, 0x380f6000, 0x380f8000, 0x380fa000, 0x380fc000, 0x380fe000,
+0x38100000, 0x38102000, 0x38104000, 0x38106000, 0x38108000, 0x3810a000,
+0x3810c000, 0x3810e000, 0x38110000, 0x38112000, 0x38114000, 0x38116000,
+0x38118000, 0x3811a000, 0x3811c000, 0x3811e000, 0x38120000, 0x38122000,
+0x38124000, 0x38126000, 0x38128000, 0x3812a000, 0x3812c000, 0x3812e000,
+0x38130000, 0x38132000, 0x38134000, 0x38136000, 0x38138000, 0x3813a000,
+0x3813c000, 0x3813e000, 0x38140000, 0x38142000, 0x38144000, 0x38146000,
+0x38148000, 0x3814a000, 0x3814c000, 0x3814e000, 0x38150000, 0x38152000,
+0x38154000, 0x38156000, 0x38158000, 0x3815a000, 0x3815c000, 0x3815e000,
+0x38160000, 0x38162000, 0x38164000, 0x38166000, 0x38168000, 0x3816a000,
+0x3816c000, 0x3816e000, 0x38170000, 0x38172000, 0x38174000, 0x38176000,
+0x38178000, 0x3817a000, 0x3817c000, 0x3817e000, 0x38180000, 0x38182000,
+0x38184000, 0x38186000, 0x38188000, 0x3818a000, 0x3818c000, 0x3818e000,
+0x38190000, 0x38192000, 0x38194000, 0x38196000, 0x38198000, 0x3819a000,
+0x3819c000, 0x3819e000, 0x381a0000, 0x381a2000, 0x381a4000, 0x381a6000,
+0x381a8000, 0x381aa000, 0x381ac000, 0x381ae000, 0x381b0000, 0x381b2000,
+0x381b4000, 0x381b6000, 0x381b8000, 0x381ba000, 0x381bc000, 0x381be000,
+0x381c0000, 0x381c2000, 0x381c4000, 0x381c6000, 0x381c8000, 0x381ca000,
+0x381cc000, 0x381ce000, 0x381d0000, 0x381d2000, 0x381d4000, 0x381d6000,
+0x381d8000, 0x381da000, 0x381dc000, 0x381de000, 0x381e0000, 0x381e2000,
+0x381e4000, 0x381e6000, 0x381e8000, 0x381ea000, 0x381ec000, 0x381ee000,
+0x381f0000, 0x381f2000, 0x381f4000, 0x381f6000, 0x381f8000, 0x381fa000,
+0x381fc000, 0x381fe000, 0x38200000, 0x38202000, 0x38204000, 0x38206000,
+0x38208000, 0x3820a000, 0x3820c000, 0x3820e000, 0x38210000, 0x38212000,
+0x38214000, 0x38216000, 0x38218000, 0x3821a000, 0x3821c000, 0x3821e000,
+0x38220000, 0x38222000, 0x38224000, 0x38226000, 0x38228000, 0x3822a000,
+0x3822c000, 0x3822e000, 0x38230000, 0x38232000, 0x38234000, 0x38236000,
+0x38238000, 0x3823a000, 0x3823c000, 0x3823e000, 0x38240000, 0x38242000,
+0x38244000, 0x38246000, 0x38248000, 0x3824a000, 0x3824c000, 0x3824e000,
+0x38250000, 0x38252000, 0x38254000, 0x38256000, 0x38258000, 0x3825a000,
+0x3825c000, 0x3825e000, 0x38260000, 0x38262000, 0x38264000, 0x38266000,
+0x38268000, 0x3826a000, 0x3826c000, 0x3826e000, 0x38270000, 0x38272000,
+0x38274000, 0x38276000, 0x38278000, 0x3827a000, 0x3827c000, 0x3827e000,
+0x38280000, 0x38282000, 0x38284000, 0x38286000, 0x38288000, 0x3828a000,
+0x3828c000, 0x3828e000, 0x38290000, 0x38292000, 0x38294000, 0x38296000,
+0x38298000, 0x3829a000, 0x3829c000, 0x3829e000, 0x382a0000, 0x382a2000,
+0x382a4000, 0x382a6000, 0x382a8000, 0x382aa000, 0x382ac000, 0x382ae000,
+0x382b0000, 0x382b2000, 0x382b4000, 0x382b6000, 0x382b8000, 0x382ba000,
+0x382bc000, 0x382be000, 0x382c0000, 0x382c2000, 0x382c4000, 0x382c6000,
+0x382c8000, 0x382ca000, 0x382cc000, 0x382ce000, 0x382d0000, 0x382d2000,
+0x382d4000, 0x382d6000, 0x382d8000, 0x382da000, 0x382dc000, 0x382de000,
+0x382e0000, 0x382e2000, 0x382e4000, 0x382e6000, 0x382e8000, 0x382ea000,
+0x382ec000, 0x382ee000, 0x382f0000, 0x382f2000, 0x382f4000, 0x382f6000,
+0x382f8000, 0x382fa000, 0x382fc000, 0x382fe000, 0x38300000, 0x38302000,
+0x38304000, 0x38306000, 0x38308000, 0x3830a000, 0x3830c000, 0x3830e000,
+0x38310000, 0x38312000, 0x38314000, 0x38316000, 0x38318000, 0x3831a000,
+0x3831c000, 0x3831e000, 0x38320000, 0x38322000, 0x38324000, 0x38326000,
+0x38328000, 0x3832a000, 0x3832c000, 0x3832e000, 0x38330000, 0x38332000,
+0x38334000, 0x38336000, 0x38338000, 0x3833a000, 0x3833c000, 0x3833e000,
+0x38340000, 0x38342000, 0x38344000, 0x38346000, 0x38348000, 0x3834a000,
+0x3834c000, 0x3834e000, 0x38350000, 0x38352000, 0x38354000, 0x38356000,
+0x38358000, 0x3835a000, 0x3835c000, 0x3835e000, 0x38360000, 0x38362000,
+0x38364000, 0x38366000, 0x38368000, 0x3836a000, 0x3836c000, 0x3836e000,
+0x38370000, 0x38372000, 0x38374000, 0x38376000, 0x38378000, 0x3837a000,
+0x3837c000, 0x3837e000, 0x38380000, 0x38382000, 0x38384000, 0x38386000,
+0x38388000, 0x3838a000, 0x3838c000, 0x3838e000, 0x38390000, 0x38392000,
+0x38394000, 0x38396000, 0x38398000, 0x3839a000, 0x3839c000, 0x3839e000,
+0x383a0000, 0x383a2000, 0x383a4000, 0x383a6000, 0x383a8000, 0x383aa000,
+0x383ac000, 0x383ae000, 0x383b0000, 0x383b2000, 0x383b4000, 0x383b6000,
+0x383b8000, 0x383ba000, 0x383bc000, 0x383be000, 0x383c0000, 0x383c2000,
+0x383c4000, 0x383c6000, 0x383c8000, 0x383ca000, 0x383cc000, 0x383ce000,
+0x383d0000, 0x383d2000, 0x383d4000, 0x383d6000, 0x383d8000, 0x383da000,
+0x383dc000, 0x383de000, 0x383e0000, 0x383e2000, 0x383e4000, 0x383e6000,
+0x383e8000, 0x383ea000, 0x383ec000, 0x383ee000, 0x383f0000, 0x383f2000,
+0x383f4000, 0x383f6000, 0x383f8000, 0x383fa000, 0x383fc000, 0x383fe000,
+0x38400000, 0x38402000, 0x38404000, 0x38406000, 0x38408000, 0x3840a000,
+0x3840c000, 0x3840e000, 0x38410000, 0x38412000, 0x38414000, 0x38416000,
+0x38418000, 0x3841a000, 0x3841c000, 0x3841e000, 0x38420000, 0x38422000,
+0x38424000, 0x38426000, 0x38428000, 0x3842a000, 0x3842c000, 0x3842e000,
+0x38430000, 0x38432000, 0x38434000, 0x38436000, 0x38438000, 0x3843a000,
+0x3843c000, 0x3843e000, 0x38440000, 0x38442000, 0x38444000, 0x38446000,
+0x38448000, 0x3844a000, 0x3844c000, 0x3844e000, 0x38450000, 0x38452000,
+0x38454000, 0x38456000, 0x38458000, 0x3845a000, 0x3845c000, 0x3845e000,
+0x38460000, 0x38462000, 0x38464000, 0x38466000, 0x38468000, 0x3846a000,
+0x3846c000, 0x3846e000, 0x38470000, 0x38472000, 0x38474000, 0x38476000,
+0x38478000, 0x3847a000, 0x3847c000, 0x3847e000, 0x38480000, 0x38482000,
+0x38484000, 0x38486000, 0x38488000, 0x3848a000, 0x3848c000, 0x3848e000,
+0x38490000, 0x38492000, 0x38494000, 0x38496000, 0x38498000, 0x3849a000,
+0x3849c000, 0x3849e000, 0x384a0000, 0x384a2000, 0x384a4000, 0x384a6000,
+0x384a8000, 0x384aa000, 0x384ac000, 0x384ae000, 0x384b0000, 0x384b2000,
+0x384b4000, 0x384b6000, 0x384b8000, 0x384ba000, 0x384bc000, 0x384be000,
+0x384c0000, 0x384c2000, 0x384c4000, 0x384c6000, 0x384c8000, 0x384ca000,
+0x384cc000, 0x384ce000, 0x384d0000, 0x384d2000, 0x384d4000, 0x384d6000,
+0x384d8000, 0x384da000, 0x384dc000, 0x384de000, 0x384e0000, 0x384e2000,
+0x384e4000, 0x384e6000, 0x384e8000, 0x384ea000, 0x384ec000, 0x384ee000,
+0x384f0000, 0x384f2000, 0x384f4000, 0x384f6000, 0x384f8000, 0x384fa000,
+0x384fc000, 0x384fe000, 0x38500000, 0x38502000, 0x38504000, 0x38506000,
+0x38508000, 0x3850a000, 0x3850c000, 0x3850e000, 0x38510000, 0x38512000,
+0x38514000, 0x38516000, 0x38518000, 0x3851a000, 0x3851c000, 0x3851e000,
+0x38520000, 0x38522000, 0x38524000, 0x38526000, 0x38528000, 0x3852a000,
+0x3852c000, 0x3852e000, 0x38530000, 0x38532000, 0x38534000, 0x38536000,
+0x38538000, 0x3853a000, 0x3853c000, 0x3853e000, 0x38540000, 0x38542000,
+0x38544000, 0x38546000, 0x38548000, 0x3854a000, 0x3854c000, 0x3854e000,
+0x38550000, 0x38552000, 0x38554000, 0x38556000, 0x38558000, 0x3855a000,
+0x3855c000, 0x3855e000, 0x38560000, 0x38562000, 0x38564000, 0x38566000,
+0x38568000, 0x3856a000, 0x3856c000, 0x3856e000, 0x38570000, 0x38572000,
+0x38574000, 0x38576000, 0x38578000, 0x3857a000, 0x3857c000, 0x3857e000,
+0x38580000, 0x38582000, 0x38584000, 0x38586000, 0x38588000, 0x3858a000,
+0x3858c000, 0x3858e000, 0x38590000, 0x38592000, 0x38594000, 0x38596000,
+0x38598000, 0x3859a000, 0x3859c000, 0x3859e000, 0x385a0000, 0x385a2000,
+0x385a4000, 0x385a6000, 0x385a8000, 0x385aa000, 0x385ac000, 0x385ae000,
+0x385b0000, 0x385b2000, 0x385b4000, 0x385b6000, 0x385b8000, 0x385ba000,
+0x385bc000, 0x385be000, 0x385c0000, 0x385c2000, 0x385c4000, 0x385c6000,
+0x385c8000, 0x385ca000, 0x385cc000, 0x385ce000, 0x385d0000, 0x385d2000,
+0x385d4000, 0x385d6000, 0x385d8000, 0x385da000, 0x385dc000, 0x385de000,
+0x385e0000, 0x385e2000, 0x385e4000, 0x385e6000, 0x385e8000, 0x385ea000,
+0x385ec000, 0x385ee000, 0x385f0000, 0x385f2000, 0x385f4000, 0x385f6000,
+0x385f8000, 0x385fa000, 0x385fc000, 0x385fe000, 0x38600000, 0x38602000,
+0x38604000, 0x38606000, 0x38608000, 0x3860a000, 0x3860c000, 0x3860e000,
+0x38610000, 0x38612000, 0x38614000, 0x38616000, 0x38618000, 0x3861a000,
+0x3861c000, 0x3861e000, 0x38620000, 0x38622000, 0x38624000, 0x38626000,
+0x38628000, 0x3862a000, 0x3862c000, 0x3862e000, 0x38630000, 0x38632000,
+0x38634000, 0x38636000, 0x38638000, 0x3863a000, 0x3863c000, 0x3863e000,
+0x38640000, 0x38642000, 0x38644000, 0x38646000, 0x38648000, 0x3864a000,
+0x3864c000, 0x3864e000, 0x38650000, 0x38652000, 0x38654000, 0x38656000,
+0x38658000, 0x3865a000, 0x3865c000, 0x3865e000, 0x38660000, 0x38662000,
+0x38664000, 0x38666000, 0x38668000, 0x3866a000, 0x3866c000, 0x3866e000,
+0x38670000, 0x38672000, 0x38674000, 0x38676000, 0x38678000, 0x3867a000,
+0x3867c000, 0x3867e000, 0x38680000, 0x38682000, 0x38684000, 0x38686000,
+0x38688000, 0x3868a000, 0x3868c000, 0x3868e000, 0x38690000, 0x38692000,
+0x38694000, 0x38696000, 0x38698000, 0x3869a000, 0x3869c000, 0x3869e000,
+0x386a0000, 0x386a2000, 0x386a4000, 0x386a6000, 0x386a8000, 0x386aa000,
+0x386ac000, 0x386ae000, 0x386b0000, 0x386b2000, 0x386b4000, 0x386b6000,
+0x386b8000, 0x386ba000, 0x386bc000, 0x386be000, 0x386c0000, 0x386c2000,
+0x386c4000, 0x386c6000, 0x386c8000, 0x386ca000, 0x386cc000, 0x386ce000,
+0x386d0000, 0x386d2000, 0x386d4000, 0x386d6000, 0x386d8000, 0x386da000,
+0x386dc000, 0x386de000, 0x386e0000, 0x386e2000, 0x386e4000, 0x386e6000,
+0x386e8000, 0x386ea000, 0x386ec000, 0x386ee000, 0x386f0000, 0x386f2000,
+0x386f4000, 0x386f6000, 0x386f8000, 0x386fa000, 0x386fc000, 0x386fe000,
+0x38700000, 0x38702000, 0x38704000, 0x38706000, 0x38708000, 0x3870a000,
+0x3870c000, 0x3870e000, 0x38710000, 0x38712000, 0x38714000, 0x38716000,
+0x38718000, 0x3871a000, 0x3871c000, 0x3871e000, 0x38720000, 0x38722000,
+0x38724000, 0x38726000, 0x38728000, 0x3872a000, 0x3872c000, 0x3872e000,
+0x38730000, 0x38732000, 0x38734000, 0x38736000, 0x38738000, 0x3873a000,
+0x3873c000, 0x3873e000, 0x38740000, 0x38742000, 0x38744000, 0x38746000,
+0x38748000, 0x3874a000, 0x3874c000, 0x3874e000, 0x38750000, 0x38752000,
+0x38754000, 0x38756000, 0x38758000, 0x3875a000, 0x3875c000, 0x3875e000,
+0x38760000, 0x38762000, 0x38764000, 0x38766000, 0x38768000, 0x3876a000,
+0x3876c000, 0x3876e000, 0x38770000, 0x38772000, 0x38774000, 0x38776000,
+0x38778000, 0x3877a000, 0x3877c000, 0x3877e000, 0x38780000, 0x38782000,
+0x38784000, 0x38786000, 0x38788000, 0x3878a000, 0x3878c000, 0x3878e000,
+0x38790000, 0x38792000, 0x38794000, 0x38796000, 0x38798000, 0x3879a000,
+0x3879c000, 0x3879e000, 0x387a0000, 0x387a2000, 0x387a4000, 0x387a6000,
+0x387a8000, 0x387aa000, 0x387ac000, 0x387ae000, 0x387b0000, 0x387b2000,
+0x387b4000, 0x387b6000, 0x387b8000, 0x387ba000, 0x387bc000, 0x387be000,
+0x387c0000, 0x387c2000, 0x387c4000, 0x387c6000, 0x387c8000, 0x387ca000,
+0x387cc000, 0x387ce000, 0x387d0000, 0x387d2000, 0x387d4000, 0x387d6000,
+0x387d8000, 0x387da000, 0x387dc000, 0x387de000, 0x387e0000, 0x387e2000,
+0x387e4000, 0x387e6000, 0x387e8000, 0x387ea000, 0x387ec000, 0x387ee000,
+0x387f0000, 0x387f2000, 0x387f4000, 0x387f6000, 0x387f8000, 0x387fa000,
+0x387fc000, 0x387fe000
+};
+
+static cmsUInt16Number Offset[64] = {
+0x0000, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0000, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+0x0400, 0x0400, 0x0400, 0x0400
+};
+
+static cmsUInt32Number Exponent[64] = {
+0x00000000, 0x00800000, 0x01000000, 0x01800000, 0x02000000, 0x02800000,
+0x03000000, 0x03800000, 0x04000000, 0x04800000, 0x05000000, 0x05800000,
+0x06000000, 0x06800000, 0x07000000, 0x07800000, 0x08000000, 0x08800000,
+0x09000000, 0x09800000, 0x0a000000, 0x0a800000, 0x0b000000, 0x0b800000,
+0x0c000000, 0x0c800000, 0x0d000000, 0x0d800000, 0x0e000000, 0x0e800000,
+0x0f000000, 0x47800000, 0x80000000, 0x80800000, 0x81000000, 0x81800000,
+0x82000000, 0x82800000, 0x83000000, 0x83800000, 0x84000000, 0x84800000,
+0x85000000, 0x85800000, 0x86000000, 0x86800000, 0x87000000, 0x87800000,
+0x88000000, 0x88800000, 0x89000000, 0x89800000, 0x8a000000, 0x8a800000,
+0x8b000000, 0x8b800000, 0x8c000000, 0x8c800000, 0x8d000000, 0x8d800000,
+0x8e000000, 0x8e800000, 0x8f000000, 0xc7800000
+};
+
+static cmsUInt16Number Base[512] = {
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040,
+0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x0c00, 0x1000, 0x1400, 0x1800, 0x1c00,
+0x2000, 0x2400, 0x2800, 0x2c00, 0x3000, 0x3400, 0x3800, 0x3c00, 0x4000, 0x4400,
+0x4800, 0x4c00, 0x5000, 0x5400, 0x5800, 0x5c00, 0x6000, 0x6400, 0x6800, 0x6c00,
+0x7000, 0x7400, 0x7800, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00,
+0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x7c00, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001,
+0x8002, 0x8004, 0x8008, 0x8010, 0x8020, 0x8040, 0x8080, 0x8100, 0x8200, 0x8400,
+0x8800, 0x8c00, 0x9000, 0x9400, 0x9800, 0x9c00, 0xa000, 0xa400, 0xa800, 0xac00,
+0xb000, 0xb400, 0xb800, 0xbc00, 0xc000, 0xc400, 0xc800, 0xcc00, 0xd000, 0xd400,
+0xd800, 0xdc00, 0xe000, 0xe400, 0xe800, 0xec00, 0xf000, 0xf400, 0xf800, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00, 0xfc00,
+0xfc00, 0xfc00
+};
+
+static cmsUInt8Number Shift[512] = {
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17,
+0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d,
+0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x0d, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13,
+0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x0d
+};
+
+cmsFloat32Number _cmsHalf2Float(cmsUInt16Number h)
+{
+ union {
+ cmsFloat32Number flt;
+ cmsUInt32Number num;
+ } out;
+
+ int n = h >> 10;
+
+ out.num = Mantissa[ (h & 0x3ff) + Offset[ n ] ] + Exponent[ n ];
+ return out.flt;
+}
+
+cmsUInt16Number _cmsFloat2Half(cmsFloat32Number flt)
+{
+ union {
+ cmsFloat32Number flt;
+ cmsUInt32Number num;
+ } in;
+
+ cmsUInt32Number n, j;
+
+ in.flt = flt;
+ n = in.num;
+ j = (n >> 23) & 0x1ff;
+
+ return (cmsUInt16Number) ((cmsUInt32Number) Base[ j ] + (( n & 0x007fffff) >> Shift[ j ]));
+}
+
+#endif
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
static cmsInterpFunction DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags);
// This is the default factory
-static cmsInterpFnFactory Interpolators = DefaultInterpolatorsFactory;
+_cmsInterpPluginChunkType _cmsInterpPluginChunk = { NULL };
+
+// The interpolation plug-in memory chunk allocator/dup
+void _cmsAllocInterpPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
+{
+ void* from;
+
+ _cmsAssert(ctx != NULL);
+
+ if (src != NULL) {
+ from = src ->chunks[InterpPlugin];
+ }
+ else {
+ static _cmsInterpPluginChunkType InterpPluginChunk = { NULL };
+
+ from = &InterpPluginChunk;
+ }
+
+ _cmsAssert(from != NULL);
+ ctx ->chunks[InterpPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsInterpPluginChunkType));
+}
// Main plug-in entry
-cmsBool _cmsRegisterInterpPlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterInterpPlugin(cmsContext ContextID, cmsPluginBase* Data)
{
cmsPluginInterpolation* Plugin = (cmsPluginInterpolation*) Data;
+ _cmsInterpPluginChunkType* ptr = (_cmsInterpPluginChunkType*) _cmsContextGetClientChunk(ContextID, InterpPlugin);
if (Data == NULL) {
-
- Interpolators = DefaultInterpolatorsFactory;
+
+ ptr ->Interpolators = NULL;
return TRUE;
}
// Set replacement functions
- Interpolators = Plugin ->InterpolatorsFactory;
+ ptr ->Interpolators = Plugin ->InterpolatorsFactory;
return TRUE;
}
// Set the interpolation method
+cmsBool _cmsSetInterpolationRoutine(cmsContext ContextID, cmsInterpParams* p)
+{
+ _cmsInterpPluginChunkType* ptr = (_cmsInterpPluginChunkType*) _cmsContextGetClientChunk(ContextID, InterpPlugin);
-cmsBool _cmsSetInterpolationRoutine(cmsInterpParams* p)
-{
- // Invoke factory, possibly in the Plug-in
- p ->Interpolation = Interpolators(p -> nInputs, p ->nOutputs, p ->dwFlags);
+ p ->Interpolation.Lerp16 = NULL;
- // If unsupported by the plug-in, go for the LittleCMS default.
+ // Invoke factory, possibly in the Plug-in
+ if (ptr ->Interpolators != NULL)
+ p ->Interpolation = ptr->Interpolators(p -> nInputs, p ->nOutputs, p ->dwFlags);
+
+ // If unsupported by the plug-in, go for the LittleCMS default.
// If happens only if an extern plug-in is being used
if (p ->Interpolation.Lerp16 == NULL)
p ->Interpolation = DefaultInterpolatorsFactory(p ->nInputs, p ->nOutputs, p ->dwFlags);
// Check for valid interpolator (we just check one member of the union)
- if (p ->Interpolation.Lerp16 == NULL) {
+ if (p ->Interpolation.Lerp16 == NULL) {
return FALSE;
}
+
return TRUE;
}
// This function precalculates as many parameters as possible to speed up the interpolation.
cmsInterpParams* _cmsComputeInterpParamsEx(cmsContext ContextID,
- const cmsUInt32Number nSamples[],
- int InputChan, int OutputChan,
+ const cmsUInt32Number nSamples[],
+ int InputChan, int OutputChan,
const void *Table,
cmsUInt32Number dwFlags)
-{
+{
cmsInterpParams* p;
int i;
-
+
// Check for maximum inputs
if (InputChan > MAX_INPUT_DIMENSIONS) {
- cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", InputChan, MAX_INPUT_DIMENSIONS);
+ cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", InputChan, MAX_INPUT_DIMENSIONS);
return NULL;
}
for (i=0; i < InputChan; i++) {
p -> nSamples[i] = nSamples[i];
- p -> Domain[i] = nSamples[i] - 1;
+ p -> Domain[i] = nSamples[i] - 1;
}
// Compute factors to apply to each component to index the grid array
- p -> opta[0] = p -> nOutputs;
+ p -> opta[0] = p -> nOutputs;
for (i=1; i < InputChan; i++)
p ->opta[i] = p ->opta[i-1] * nSamples[InputChan-i];
- if (!_cmsSetInterpolationRoutine(p)) {
- cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported interpolation (%d->%d channels)", InputChan, OutputChan);
+ if (!_cmsSetInterpolationRoutine(ContextID, p)) {
+ cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported interpolation (%d->%d channels)", InputChan, OutputChan);
_cmsFree(ContextID, p);
return NULL;
}
cmsUInt32Number Samples[MAX_INPUT_DIMENSIONS];
// Fill the auxiliar array
- for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
+ for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
Samples[i] = nSamples;
// Call the extended function
}
-// Inline fixed point interpolation
+// Inline fixed point interpolation
cmsINLINE cmsUInt16Number LinearInterp(cmsS15Fixed16Number a, cmsS15Fixed16Number l, cmsS15Fixed16Number h)
{
- cmsUInt32Number dif = (cmsUInt32Number) (h - l) * a + 0x8000;
- dif = (dif >> 16) + l;
+ cmsUInt32Number dif = (cmsUInt32Number) (h - l) * a + 0x8000;
+ dif = (dif >> 16) + l;
return (cmsUInt16Number) (dif);
}
// Linear interpolation (Fixed-point optimized)
static
-void LinLerp1D(register const cmsUInt16Number Value[],
- register cmsUInt16Number Output[],
+void LinLerp1D(register const cmsUInt16Number Value[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p)
{
- cmsUInt16Number y1, y0;
+ cmsUInt16Number y1, y0;
int cell0, rest;
int val3;
const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
- // if last value...
+ // if last value...
if (Value[0] == 0xffff) {
Output[0] = LutTable[p -> Domain[0]];
y0 = LutTable[cell0];
y1 = LutTable[cell0+1];
-
+
Output[0] = LinearInterp(rest, y0, y1);
}
+// To prevent out of bounds indexing
+cmsINLINE cmsFloat32Number fclamp(cmsFloat32Number v)
+{
+ return v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v);
+}
// Floating-point version of 1D interpolation
static
-void LinLerp1Dfloat(const cmsFloat32Number Value[],
- cmsFloat32Number Output[],
+void LinLerp1Dfloat(const cmsFloat32Number Value[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
{
cmsFloat32Number y1, y0;
int cell0, cell1;
const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
+ val2 = fclamp(Value[0]);
+
// if last value...
- if (Value[0] == 1.0) {
+ if (val2 == 1.0) {
Output[0] = LutTable[p -> Domain[0]];
return;
}
- val2 = p -> Domain[0] * Value[0];
+ val2 *= p -> Domain[0];
cell0 = (int) floor(val2);
cell1 = (int) ceil(val2);
y0 = LutTable[cell0] ;
y1 = LutTable[cell1] ;
- Output[0] = y0 + (y1 - y0) * rest;
+ Output[0] = y0 + (y1 - y0) * rest;
}
-// Eval gray LUT having only one input channel
+// Eval gray LUT having only one input channel
static
-void Eval1Input(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+void Eval1Input(register const cmsUInt16Number Input[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p16)
{
cmsS15Fixed16Number fk;
-// Eval gray LUT having only one input channel
+// Eval gray LUT having only one input channel
static
-void Eval1InputFloat(const cmsFloat32Number Value[],
- cmsFloat32Number Output[],
+void Eval1InputFloat(const cmsFloat32Number Value[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
{
cmsFloat32Number y1, y0;
cmsFloat32Number val2, rest;
int cell0, cell1;
cmsUInt32Number OutChan;
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
+
+ val2 = fclamp(Value[0]);
// if last value...
- if (Value[0] == 1.0) {
+ if (val2 == 1.0) {
Output[0] = LutTable[p -> Domain[0]];
return;
}
- val2 = p -> Domain[0] * Value[0];
+ val2 *= p -> Domain[0];
cell0 = (int) floor(val2);
cell1 = (int) ceil(val2);
// Rest is 16 LSB bits
rest = val2 - cell0;
-
+
cell0 *= p -> opta[0];
cell1 *= p -> opta[0];
y0 = LutTable[cell0 + OutChan] ;
y1 = LutTable[cell1 + OutChan] ;
- Output[OutChan] = y0 + (y1 - y0) * rest;
+ Output[OutChan] = y0 + (y1 - y0) * rest;
}
}
// Bilinear interpolation (16 bits) - cmsFloat32Number version
static
-void BilinearInterpFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void BilinearInterpFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
{
# define LERP(a,l,h) (cmsFloat32Number) ((l)+(((h)-(l))*(a)))
# define DENS(i,j) (LutTable[(i)+(j)+OutChan])
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
cmsFloat32Number px, py;
int x0, y0,
X0, Y0, X1, Y1;
d00, d01, d10, d11,
dx0, dx1,
dxy;
-
+
TotalOut = p -> nOutputs;
- px = Input[0] * p->Domain[0];
- py = Input[1] * p->Domain[1];
+ px = fclamp(Input[0]) * p->Domain[0];
+ py = fclamp(Input[1]) * p->Domain[1];
x0 = (int) _cmsQuickFloor(px); fx = px - (cmsFloat32Number) x0;
y0 = (int) _cmsQuickFloor(py); fy = py - (cmsFloat32Number) y0;
-
+
X0 = p -> opta[1] * x0;
X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[1]);
Y0 = p -> opta[0] * y0;
Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[0]);
-
+
for (OutChan = 0; OutChan < TotalOut; OutChan++) {
-
+
d00 = DENS(X0, Y0);
d01 = DENS(X0, Y1);
d10 = DENS(X1, Y0);
// Bilinear interpolation (16 bits) - optimized version
static
-void BilinearInterp16(register const cmsUInt16Number Input[],
+void BilinearInterp16(register const cmsUInt16Number Input[],
register cmsUInt16Number Output[],
register const cmsInterpParams* p)
#define DENS(i,j) (LutTable[(i)+(j)+OutChan])
#define LERP(a,l,h) (cmsUInt16Number) (l + ROUND_FIXED_TO_INT(((h-l)*a)))
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
+ const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
int OutChan, TotalOut;
cmsS15Fixed16Number fx, fy;
register int rx, ry;
Y0 = p -> opta[0] * y0;
Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[0]);
-
+
for (OutChan = 0; OutChan < TotalOut; OutChan++) {
d00 = DENS(X0, Y0);
// Trilinear interpolation (16 bits) - cmsFloat32Number version
static
-void TrilinearInterpFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void TrilinearInterpFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
{
# define LERP(a,l,h) (cmsFloat32Number) ((l)+(((h)-(l))*(a)))
# define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
cmsFloat32Number px, py, pz;
int x0, y0, z0,
X0, Y0, Z0, X1, Y1, Z1;
d100, d101, d110, d111,
dx00, dx01, dx10, dx11,
dxy0, dxy1, dxyz;
-
- TotalOut = p -> nOutputs;
-
- // We need some clipping here
- px = Input[0];
- py = Input[1];
- pz = Input[2];
- if (px < 0) px = 0;
- if (px > 1) px = 1;
- if (py < 0) py = 0;
- if (py > 1) py = 1;
- if (pz < 0) pz = 0;
- if (pz > 1) pz = 1;
+ TotalOut = p -> nOutputs;
- px *= p->Domain[0];
- py *= p->Domain[1];
- pz *= p->Domain[2];
+ // We need some clipping here
+ px = fclamp(Input[0]) * p->Domain[0];
+ py = fclamp(Input[1]) * p->Domain[1];
+ pz = fclamp(Input[2]) * p->Domain[2];
x0 = (int) _cmsQuickFloor(px); fx = px - (cmsFloat32Number) x0;
y0 = (int) _cmsQuickFloor(py); fy = py - (cmsFloat32Number) y0;
z0 = (int) _cmsQuickFloor(pz); fz = pz - (cmsFloat32Number) z0;
-
+
X0 = p -> opta[2] * x0;
X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[2]);
Y0 = p -> opta[1] * y0;
Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[1]);
-
+
Z0 = p -> opta[0] * z0;
Z1 = Z0 + (Input[2] >= 1.0 ? 0 : p->opta[0]);
-
+
for (OutChan = 0; OutChan < TotalOut; OutChan++) {
d000 = DENS(X0, Y0, Z0);
// Trilinear interpolation (16 bits) - optimized version
static
-void TrilinearInterp16(register const cmsUInt16Number Input[],
+void TrilinearInterp16(register const cmsUInt16Number Input[],
register cmsUInt16Number Output[],
register const cmsInterpParams* p)
#define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
#define LERP(a,l,h) (cmsUInt16Number) (l + ROUND_FIXED_TO_INT(((h-l)*a)))
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
+ const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
int OutChan, TotalOut;
cmsS15Fixed16Number fx, fy, fz;
register int rx, ry, rz;
Y0 = p -> opta[1] * y0;
Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
-
+
Z0 = p -> opta[0] * z0;
Z1 = Z0 + (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
}
-// Tetrahedral interpolation, using Sakamoto algorithm.
+// Tetrahedral interpolation, using Sakamoto algorithm.
#define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
static
-void TetrahedralInterpFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void TetrahedralInterpFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
{
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
cmsFloat32Number px, py, pz;
int x0, y0, z0,
X0, Y0, Z0, X1, Y1, Z1;
TotalOut = p -> nOutputs;
// We need some clipping here
- px = Input[0];
- py = Input[1];
- pz = Input[2];
-
- if (px < 0) px = 0;
- if (px > 1) px = 1;
- if (py < 0) py = 0;
- if (py > 1) py = 1;
- if (pz < 0) pz = 0;
- if (pz > 1) pz = 1;
-
- px *= p->Domain[0];
- py *= p->Domain[1];
- pz *= p->Domain[2];
+ px = fclamp(Input[0]) * p->Domain[0];
+ py = fclamp(Input[1]) * p->Domain[1];
+ pz = fclamp(Input[2]) * p->Domain[2];
x0 = (int) _cmsQuickFloor(px); rx = (px - (cmsFloat32Number) x0);
y0 = (int) _cmsQuickFloor(py); ry = (py - (cmsFloat32Number) y0);
Y0 = p -> opta[1] * y0;
Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[1]);
-
+
Z0 = p -> opta[0] * z0;
Z1 = Z0 + (Input[2] >= 1.0 ? 0 : p->opta[0]);
-
+
for (OutChan=0; OutChan < TotalOut; OutChan++) {
// These are the 6 Tetrahedral
}
else
- if (rx >= rz && rz >= ry) {
+ if (rx >= rz && rz >= ry) {
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
+ c3 = DENS(X0, Y0, Z1) - c0;
}
else
}
else
- if (rz >= ry && ry >= rx) {
+ if (rz >= ry && ry >= rx) {
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
}
else {
- c1 = c2 = c3 = 0;
+ c1 = c2 = c3 = 0;
}
Output[OutChan] = c0 + c1 * rx + c2 * ry + c3 * rz;
-#define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
static
void TetrahedralInterp16(register const cmsUInt16Number Input[],
register const cmsInterpParams* p)
{
const cmsUInt16Number* LutTable = (cmsUInt16Number*) p -> Table;
- cmsS15Fixed16Number fx, fy, fz;
- cmsS15Fixed16Number rx, ry, rz;
- int x0, y0, z0;
- cmsS15Fixed16Number c0, c1, c2, c3, Rest;
- cmsUInt32Number OutChan;
- cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
- cmsUInt32Number TotalOut = p -> nOutputs;
-
+ cmsS15Fixed16Number fx, fy, fz;
+ cmsS15Fixed16Number rx, ry, rz;
+ int x0, y0, z0;
+ cmsS15Fixed16Number c0, c1, c2, c3, Rest;
+ cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
+ cmsUInt32Number TotalOut = p -> nOutputs;
- fx = _cmsToFixedDomain((int) Input[0] * p -> Domain[0]);
- fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
- fz = _cmsToFixedDomain((int) Input[2] * p -> Domain[2]);
+ fx = _cmsToFixedDomain((int) Input[0] * p -> Domain[0]);
+ fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
+ fz = _cmsToFixedDomain((int) Input[2] * p -> Domain[2]);
- x0 = FIXED_TO_INT(fx);
- y0 = FIXED_TO_INT(fy);
- z0 = FIXED_TO_INT(fz);
+ x0 = FIXED_TO_INT(fx);
+ y0 = FIXED_TO_INT(fy);
+ z0 = FIXED_TO_INT(fz);
- rx = FIXED_REST_TO_INT(fx);
- ry = FIXED_REST_TO_INT(fy);
- rz = FIXED_REST_TO_INT(fz);
+ rx = FIXED_REST_TO_INT(fx);
+ ry = FIXED_REST_TO_INT(fy);
+ rz = FIXED_REST_TO_INT(fz);
X0 = p -> opta[2] * x0;
- X1 = X0 + (Input[0] == 0xFFFFU ? 0 : p->opta[2]);
+ X1 = (Input[0] == 0xFFFFU ? 0 : p->opta[2]);
Y0 = p -> opta[1] * y0;
- Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
+ Y1 = (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
Z0 = p -> opta[0] * z0;
- Z1 = Z0 + (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
-
- // These are the 6 Tetrahedral
- for (OutChan=0; OutChan < TotalOut; OutChan++) {
-
- c0 = DENS(X0, Y0, Z0);
-
- if (rx >= ry && ry >= rz) {
-
- c1 = DENS(X1, Y0, Z0) - c0;
- c2 = DENS(X1, Y1, Z0) - DENS(X1, Y0, Z0);
- c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
-
+ Z1 = (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
+
+ LutTable = &LutTable[X0+Y0+Z0];
+
+ // Output should be computed as x = ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest))
+ // which expands as: x = (Rest + ((Rest+0x7fff)/0xFFFF) + 0x8000)>>16
+ // This can be replaced by: t = Rest+0x8001, x = (t + (t>>16))>>16
+ // at the cost of being off by one at 7fff and 17ffe.
+
+ if (rx >= ry) {
+ if (ry >= rz) {
+ Y1 += X1;
+ Z1 += Y1;
+ for (; TotalOut; TotalOut--) {
+ c1 = LutTable[X1];
+ c2 = LutTable[Y1];
+ c3 = LutTable[Z1];
+ c0 = *LutTable++;
+ c3 -= c2;
+ c2 -= c1;
+ c1 -= c0;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
+ }
+ } else if (rz >= rx) {
+ X1 += Z1;
+ Y1 += X1;
+ for (; TotalOut; TotalOut--) {
+ c1 = LutTable[X1];
+ c2 = LutTable[Y1];
+ c3 = LutTable[Z1];
+ c0 = *LutTable++;
+ c2 -= c1;
+ c1 -= c3;
+ c3 -= c0;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
+ }
+ } else {
+ Z1 += X1;
+ Y1 += Z1;
+ for (; TotalOut; TotalOut--) {
+ c1 = LutTable[X1];
+ c2 = LutTable[Y1];
+ c3 = LutTable[Z1];
+ c0 = *LutTable++;
+ c2 -= c3;
+ c3 -= c1;
+ c1 -= c0;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
+ }
}
- else
- if (rx >= rz && rz >= ry) {
-
- c1 = DENS(X1, Y0, Z0) - c0;
- c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
- c3 = DENS(X1, Y0, Z1) - DENS(X1, Y0, Z0);
-
+ } else {
+ if (rx >= rz) {
+ X1 += Y1;
+ Z1 += X1;
+ for (; TotalOut; TotalOut--) {
+ c1 = LutTable[X1];
+ c2 = LutTable[Y1];
+ c3 = LutTable[Z1];
+ c0 = *LutTable++;
+ c3 -= c1;
+ c1 -= c2;
+ c2 -= c0;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
}
- else
- if (rz >= rx && rx >= ry) {
-
- c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
- c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
-
- }
- else
- if (ry >= rx && rx >= rz) {
-
- c1 = DENS(X1, Y1, Z0) - DENS(X0, Y1, Z0);
- c2 = DENS(X0, Y1, Z0) - c0;
- c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
-
- }
- else
- if (ry >= rz && rz >= rx) {
-
- c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
- c2 = DENS(X0, Y1, Z0) - c0;
- c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
-
- }
- else
- if (rz >= ry && ry >= rx) {
-
- c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
- c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
-
- }
- else {
- c1 = c2 = c3 = 0;
- }
-
- Rest = c1 * rx + c2 * ry + c3 * rz;
-
- Output[OutChan] = (cmsUInt16Number) c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
+ } else if (ry >= rz) {
+ Z1 += Y1;
+ X1 += Z1;
+ for (; TotalOut; TotalOut--) {
+ c1 = LutTable[X1];
+ c2 = LutTable[Y1];
+ c3 = LutTable[Z1];
+ c0 = *LutTable++;
+ c1 -= c3;
+ c3 -= c2;
+ c2 -= c0;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
+ }
+ } else {
+ Y1 += Z1;
+ X1 += Y1;
+ for (; TotalOut; TotalOut--) {
+ c1 = LutTable[X1];
+ c2 = LutTable[Y1];
+ c3 = LutTable[Z1];
+ c0 = *LutTable++;
+ c1 -= c2;
+ c2 -= c3;
+ c3 -= c0;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
+ }
+ }
}
-
}
-#undef DENS
#define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
static
-void Eval4Inputs(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+void Eval4Inputs(register const cmsUInt16Number Input[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p16)
-{
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
+{
+ const cmsUInt16Number* LutTable;
cmsS15Fixed16Number fk;
cmsS15Fixed16Number k0, rk;
int K0, K1;
int x0, y0, z0;
cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
cmsUInt32Number i;
- cmsS15Fixed16Number c0, c1, c2, c3, Rest;
+ cmsS15Fixed16Number c0, c1, c2, c3, Rest;
cmsUInt32Number OutChan;
cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
fy = _cmsToFixedDomain((int) Input[2] * p16 -> Domain[2]);
fz = _cmsToFixedDomain((int) Input[3] * p16 -> Domain[3]);
- k0 = FIXED_TO_INT(fk);
+ k0 = FIXED_TO_INT(fk);
x0 = FIXED_TO_INT(fx);
- y0 = FIXED_TO_INT(fy);
+ y0 = FIXED_TO_INT(fy);
z0 = FIXED_TO_INT(fz);
rk = FIXED_REST_TO_INT(fk);
- rx = FIXED_REST_TO_INT(fx);
- ry = FIXED_REST_TO_INT(fy);
+ rx = FIXED_REST_TO_INT(fx);
+ ry = FIXED_REST_TO_INT(fy);
rz = FIXED_REST_TO_INT(fz);
K0 = p16 -> opta[3] * k0;
}
else
- if (rx >= rz && rz >= ry) {
+ if (rx >= rz && rz >= ry) {
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
+ c3 = DENS(X0, Y0, Z1) - c0;
}
else
}
else
- if (rz >= ry && ry >= rx) {
+ if (rz >= ry && ry >= rx) {
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
}
else {
- c1 = c2 = c3 = 0;
+ c1 = c2 = c3 = 0;
}
- Rest = c1 * rx + c2 * ry + c3 * rz;
+ Rest = c1 * rx + c2 * ry + c3 * rz;
Tmp1[OutChan] = (cmsUInt16Number) c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
}
}
else
- if (rx >= rz && rz >= ry) {
+ if (rx >= rz && rz >= ry) {
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
+ c3 = DENS(X0, Y0, Z1) - c0;
}
else
}
else
- if (rz >= ry && ry >= rx) {
+ if (rz >= ry && ry >= rx) {
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
}
else {
- c1 = c2 = c3 = 0;
+ c1 = c2 = c3 = 0;
}
- Rest = c1 * rx + c2 * ry + c3 * rz;
+ Rest = c1 * rx + c2 * ry + c3 * rz;
Tmp2[OutChan] = (cmsUInt16Number) c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
}
for (i=0; i < p16 -> nOutputs; i++) {
- Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
+ Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
}
}
#undef DENS
static
-void Eval4InputsFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void Eval4InputsFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
-{
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
+{
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
cmsFloat32Number rest;
cmsFloat32Number pk;
int k0, K0, K1;
cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
-
- pk = Input[0] * p->Domain[0];
- k0 = _cmsQuickFloor(pk);
+ pk = fclamp(Input[0]) * p->Domain[0];
+ k0 = _cmsQuickFloor(pk);
rest = pk - (cmsFloat32Number) k0;
K0 = p -> opta[3] * k0;
p1 = *p;
memmove(&p1.Domain[0], &p ->Domain[1], 3*sizeof(cmsUInt32Number));
-
+
T = LutTable + K0;
p1.Table = T;
cmsFloat32Number y0 = Tmp1[i];
cmsFloat32Number y1 = Tmp2[i];
- Output[i] = y0 + (y1 - y0) * rest;
+ Output[i] = y0 + (y1 - y0) * rest;
}
}
static
-void Eval5Inputs(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+void Eval5Inputs(register const cmsUInt16Number Input[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p16)
-{
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
+{
+ const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
cmsS15Fixed16Number fk;
cmsS15Fixed16Number k0, rk;
int K0, K1;
cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
-
+
fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
k0 = FIXED_TO_INT(fk);
rk = FIXED_REST_TO_INT(fk);
for (i=0; i < p16 -> nOutputs; i++) {
- Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
+ Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
}
}
static
-void Eval5InputsFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void Eval5InputsFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
-{
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
+{
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
cmsFloat32Number rest;
cmsFloat32Number pk;
int k0, K0, K1;
cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
- pk = Input[0] * p->Domain[0];
- k0 = _cmsQuickFloor(pk);
+ pk = fclamp(Input[0]) * p->Domain[0];
+ k0 = _cmsQuickFloor(pk);
rest = pk - (cmsFloat32Number) k0;
K0 = p -> opta[4] * k0;
T = LutTable + K0;
p1.Table = T;
-
+
Eval4InputsFloat(Input + 1, Tmp1, &p1);
-
+
T = LutTable + K1;
p1.Table = T;
Eval4InputsFloat(Input + 1, Tmp2, &p1);
-
+
for (i=0; i < p -> nOutputs; i++) {
cmsFloat32Number y0 = Tmp1[i];
cmsFloat32Number y1 = Tmp2[i];
- Output[i] = y0 + (y1 - y0) * rest;
+ Output[i] = y0 + (y1 - y0) * rest;
}
}
static
-void Eval6Inputs(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+void Eval6Inputs(register const cmsUInt16Number Input[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p16)
-{
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
+{
+ const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
cmsS15Fixed16Number fk;
cmsS15Fixed16Number k0, rk;
int K0, K1;
cmsUInt32Number i;
cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
-
+
fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
k0 = FIXED_TO_INT(fk);
rk = FIXED_REST_TO_INT(fk);
static
-void Eval6InputsFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void Eval6InputsFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
-{
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
+{
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
cmsFloat32Number rest;
cmsFloat32Number pk;
int k0, K0, K1;
cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
- pk = Input[0] * p->Domain[0];
- k0 = _cmsQuickFloor(pk);
+ pk = fclamp(Input[0]) * p->Domain[0];
+ k0 = _cmsQuickFloor(pk);
rest = pk - (cmsFloat32Number) k0;
K0 = p -> opta[5] * k0;
p1 = *p;
memmove(&p1.Domain[0], &p ->Domain[1], 5*sizeof(cmsUInt32Number));
-
+
T = LutTable + K0;
p1.Table = T;
-
+
Eval5InputsFloat(Input + 1, Tmp1, &p1);
-
+
T = LutTable + K1;
p1.Table = T;
Eval5InputsFloat(Input + 1, Tmp2, &p1);
-
+
for (i=0; i < p -> nOutputs; i++) {
cmsFloat32Number y0 = Tmp1[i];
cmsFloat32Number y1 = Tmp2[i];
- Output[i] = y0 + (y1 - y0) * rest;
+ Output[i] = y0 + (y1 - y0) * rest;
}
}
static
-void Eval7Inputs(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+void Eval7Inputs(register const cmsUInt16Number Input[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p16)
-{
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
+{
+ const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
cmsS15Fixed16Number fk;
cmsS15Fixed16Number k0, rk;
int K0, K1;
cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
-
+
fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
k0 = FIXED_TO_INT(fk);
rk = FIXED_REST_TO_INT(fk);
K1 = p16 -> opta[6] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
p1 = *p16;
- memmove(&p1.Domain[0], &p16 ->Domain[1], 5*sizeof(cmsUInt32Number));
-
+ memmove(&p1.Domain[0], &p16 ->Domain[1], 6*sizeof(cmsUInt32Number));
+
T = LutTable + K0;
p1.Table = T;
static
-void Eval7InputsFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void Eval7InputsFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
-{
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
+{
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
cmsFloat32Number rest;
cmsFloat32Number pk;
int k0, K0, K1;
cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
- pk = Input[0] * p->Domain[0];
- k0 = _cmsQuickFloor(pk);
+ pk = fclamp(Input[0]) * p->Domain[0];
+ k0 = _cmsQuickFloor(pk);
rest = pk - (cmsFloat32Number) k0;
K0 = p -> opta[6] * k0;
p1 = *p;
memmove(&p1.Domain[0], &p ->Domain[1], 6*sizeof(cmsUInt32Number));
-
+
T = LutTable + K0;
p1.Table = T;
Eval6InputsFloat(Input + 1, Tmp1, &p1);
-
+
T = LutTable + K1;
p1.Table = T;
-
+
Eval6InputsFloat(Input + 1, Tmp2, &p1);
-
-
+
+
for (i=0; i < p -> nOutputs; i++) {
cmsFloat32Number y0 = Tmp1[i];
cmsFloat32Number y1 = Tmp2[i];
- Output[i] = y0 + (y1 - y0) * rest;
-
+ Output[i] = y0 + (y1 - y0) * rest;
+
}
}
static
-void Eval8Inputs(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+void Eval8Inputs(register const cmsUInt16Number Input[],
+ register cmsUInt16Number Output[],
register const cmsInterpParams* p16)
-{
- const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
+{
+ const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
cmsS15Fixed16Number fk;
cmsS15Fixed16Number k0, rk;
int K0, K1;
cmsUInt32Number i;
cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
-
+
fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
k0 = FIXED_TO_INT(fk);
rk = FIXED_REST_TO_INT(fk);
p1 = *p16;
memmove(&p1.Domain[0], &p16 ->Domain[1], 7*sizeof(cmsUInt32Number));
-
+
T = LutTable + K0;
p1.Table = T;
static
-void Eval8InputsFloat(const cmsFloat32Number Input[],
- cmsFloat32Number Output[],
+void Eval8InputsFloat(const cmsFloat32Number Input[],
+ cmsFloat32Number Output[],
const cmsInterpParams* p)
-{
- const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
+{
+ const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
cmsFloat32Number rest;
cmsFloat32Number pk;
int k0, K0, K1;
cmsUInt32Number i;
cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
cmsInterpParams p1;
-
- pk = Input[0] * p->Domain[0];
- k0 = _cmsQuickFloor(pk);
+
+ pk = fclamp(Input[0]) * p->Domain[0];
+ k0 = _cmsQuickFloor(pk);
rest = pk - (cmsFloat32Number) k0;
K0 = p -> opta[7] * k0;
p1.Table = T;
Eval7InputsFloat(Input + 1, Tmp1, &p1);
-
+
T = LutTable + K1;
p1.Table = T;
Eval7InputsFloat(Input + 1, Tmp2, &p1);
-
+
for (i=0; i < p -> nOutputs; i++) {
cmsFloat32Number y0 = Tmp1[i];
cmsFloat32Number y1 = Tmp2[i];
- Output[i] = y0 + (y1 - y0) * rest;
+ Output[i] = y0 + (y1 - y0) * rest;
}
}
// The default factory
-static
+static
cmsInterpFunction DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags)
{
memset(&Interpolation, 0, sizeof(Interpolation));
// Safety check
- if (nInputChannels >= 4 && nOutputChannels >= MAX_STAGE_CHANNELS)
+ if (nInputChannels >= 4 && nOutputChannels >= MAX_STAGE_CHANNELS)
return Interpolation;
switch (nInputChannels) {
if (nOutputChannels == 1) {
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = LinLerp1Dfloat;
else
Interpolation.Lerp16 = LinLerp1D;
else {
if (IsFloat)
- Interpolation.LerpFloat = Eval1InputFloat;
+ Interpolation.LerpFloat = Eval1InputFloat;
else
- Interpolation.Lerp16 = Eval1Input;
+ Interpolation.Lerp16 = Eval1Input;
}
break;
case 2: // Duotone
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = BilinearInterpFloat;
else
Interpolation.Lerp16 = BilinearInterp16;
break;
- case 3: // RGB et al
+ case 3: // RGB et al
if (IsTrilinear) {
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = TrilinearInterpFloat;
else
Interpolation.Lerp16 = TrilinearInterp16;
}
else {
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = TetrahedralInterpFloat;
else {
}
break;
- case 4: // CMYK lut
+ case 4: // CMYK lut
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = Eval4InputsFloat;
else
Interpolation.Lerp16 = Eval4Inputs;
break;
case 5: // 5 Inks
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = Eval5InputsFloat;
else
Interpolation.Lerp16 = Eval5Inputs;
- break;
+ break;
case 6: // 6 Inks
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = Eval6InputsFloat;
else
Interpolation.Lerp16 = Eval6Inputs;
break;
case 7: // 7 inks
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = Eval7InputsFloat;
else
Interpolation.Lerp16 = Eval7Inputs;
break;
case 8: // 8 inks
- if (IsFloat)
+ if (IsFloat)
Interpolation.LerpFloat = Eval8InputsFloat;
else
Interpolation.Lerp16 = Eval8Inputs;
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// NULL IOhandler basically does nothing but keep track on how many bytes have been
// written. This is handy when creating profiles, where the file size is needed in the
-// header. Then, whole profile is serialized across NULL IOhandler and a second pass
+// header. Then, whole profile is serialized across NULL IOhandler and a second pass
// writes the bytes to the pertinent IOhandler.
-typedef struct {
+typedef struct {
cmsUInt32Number Pointer; // Points to current location
} FILENULL;
static
cmsUInt32Number NULLRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
-{
+{
FILENULL* ResData = (FILENULL*) iohandler ->stream;
-
+
cmsUInt32Number len = size * count;
ResData -> Pointer += len;
return count;
{
FILENULL* ResData = (FILENULL*) iohandler ->stream;
- ResData ->Pointer = offset;
- return TRUE;
+ ResData ->Pointer = offset;
+ return TRUE;
}
static
cmsUInt32Number NULLTell(cmsIOHANDLER* iohandler)
{
FILENULL* ResData = (FILENULL*) iohandler ->stream;
- return ResData -> Pointer;
+ return ResData -> Pointer;
}
static
static
cmsBool NULLClose(cmsIOHANDLER* iohandler)
-{
+{
FILENULL* ResData = (FILENULL*) iohandler ->stream;
-
+
_cmsFree(iohandler ->ContextID, ResData);
_cmsFree(iohandler ->ContextID, iohandler);
return TRUE;
{
struct _cms_io_handler* iohandler = NULL;
FILENULL* fm = NULL;
-
+
iohandler = (struct _cms_io_handler*) _cmsMallocZero(ContextID, sizeof(struct _cms_io_handler));
if (iohandler == NULL) return NULL;
fm = (FILENULL*) _cmsMallocZero(ContextID, sizeof(FILENULL));
if (fm == NULL) goto Error;
-
+
fm ->Pointer = 0;
iohandler ->ContextID = ContextID;
- iohandler ->stream = (void*) fm;
+ iohandler ->stream = (void*) fm;
iohandler ->UsedSpace = 0;
iohandler ->ReportedSize = 0;
iohandler ->PhysicalFile[0] = 0;
return iohandler;
-Error:
- if (fm) _cmsFree(ContextID, fm);
+Error:
if (iohandler) _cmsFree(ContextID, iohandler);
return NULL;
static
cmsUInt32Number MemoryRead(struct _cms_io_handler* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
-{
+{
FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
cmsUInt8Number* Ptr;
cmsUInt32Number len = size * count;
Ptr = ResData -> Block;
Ptr += ResData -> Pointer;
- memmove(Buffer, Ptr, len);
+ memmove(Buffer, Ptr, len);
ResData -> Pointer += len;
return count;
FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
if (offset > ResData ->Size) {
- cmsSignalError(iohandler ->ContextID, cmsERROR_SEEK, "Too few data; probably corrupted profile");
+ cmsSignalError(iohandler ->ContextID, cmsERROR_SEEK, "Too few data; probably corrupted profile");
return FALSE;
}
- ResData ->Pointer = offset;
- return TRUE;
+ ResData ->Pointer = offset;
+ return TRUE;
}
// Tell for memory
{
FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
- if (ResData == NULL) return 0;
- return ResData -> Pointer;
+ if (ResData == NULL) return 0;
+ return ResData -> Pointer;
}
-// Writes data to memory, also keeps used space for further reference.
+// Writes data to memory, also keeps used space for further reference.
static
-cmsBool MemoryWrite(struct _cms_io_handler* iohandler, cmsUInt32Number size, const void *Ptr)
+cmsBool MemoryWrite(struct _cms_io_handler* iohandler, cmsUInt32Number size, const void *Ptr)
{
FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
- if (ResData == NULL) return FALSE; // Housekeeping
+ if (ResData == NULL) return FALSE; // Housekeeping
+ // Check for available space. Clip.
+ if (ResData->Pointer + size > ResData->Size) {
+ size = ResData ->Size - ResData->Pointer;
+ }
+
if (size == 0) return TRUE; // Write zero bytes is ok, but does nothing
memmove(ResData ->Block + ResData ->Pointer, Ptr, size);
if (ResData ->Pointer > iohandler->UsedSpace)
iohandler->UsedSpace = ResData ->Pointer;
-
- iohandler->UsedSpace += size;
-
return TRUE;
}
static
cmsBool MemoryClose(struct _cms_io_handler* iohandler)
-{
+{
FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
if (ResData ->FreeBlockOnClose) {
if (ResData ->Block) _cmsFree(iohandler ->ContextID, ResData ->Block);
}
-
+
_cmsFree(iohandler ->ContextID, ResData);
_cmsFree(iohandler ->ContextID, iohandler);
}
// Create a iohandler for memory block. AccessMode=='r' assumes the iohandler is going to read, and makes
-// a copy of the memory block for letting user to free the memory after invoking open profile. In write
+// a copy of the memory block for letting user to free the memory after invoking open profile. In write
// mode ("w"), Buffere points to the begin of memory block to be written.
cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromMem(cmsContext ContextID, void *Buffer, cmsUInt32Number size, const char* AccessMode)
{
cmsIOHANDLER* iohandler = NULL;
FILEMEM* fm = NULL;
- _cmsAssert(AccessMode != NULL);
+ _cmsAssert(AccessMode != NULL);
iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
if (iohandler == NULL) return NULL;
iohandler -> ReportedSize = size;
break;
- case 'w':
+ case 'w':
fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));
if (fm == NULL) goto Error;
fm ->Block = (cmsUInt8Number*) Buffer;
fm ->FreeBlockOnClose = FALSE;
fm ->Size = size;
- fm ->Pointer = 0;
+ fm ->Pointer = 0;
iohandler -> ReportedSize = 0;
break;
}
iohandler ->ContextID = ContextID;
- iohandler ->stream = (void*) fm;
+ iohandler ->stream = (void*) fm;
iohandler ->UsedSpace = 0;
iohandler ->PhysicalFile[0] = 0;
// Returns file pointer position
static
cmsUInt32Number FileTell(cmsIOHANDLER* iohandler)
-{
- return ftell((FILE*)iohandler ->stream);
+{
+ return (cmsUInt32Number) ftell((FILE*)iohandler ->stream);
}
// Writes data to stream, also keeps used space for further reference. Returns TRUE on success, FALSE on error
// Closes the file
static
cmsBool FileClose(cmsIOHANDLER* iohandler)
-{
+{
if (fclose((FILE*) iohandler ->stream) != 0) return FALSE;
_cmsFree(iohandler ->ContextID, iohandler);
return TRUE;
}
-// Create a iohandler for disk based files. if FileName is NULL, then 'stream' member is also set
-// to NULL and no real writting is performed. This only happens in writting access mode
+// Create a iohandler for disk based files.
cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const char* FileName, const char* AccessMode)
{
cmsIOHANDLER* iohandler = NULL;
FILE* fm = NULL;
+ _cmsAssert(FileName != NULL);
+ _cmsAssert(AccessMode != NULL);
+
iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
if (iohandler == NULL) return NULL;
cmsSignalError(ContextID, cmsERROR_FILE, "File '%s' not found", FileName);
return NULL;
}
- iohandler -> ReportedSize = cmsfilelength(fm);
+ iohandler -> ReportedSize = (cmsUInt32Number) cmsfilelength(fm);
break;
case 'w':
iohandler ->stream = (void*) fm;
iohandler ->UsedSpace = 0;
- // Keep track of the original file
- if (FileName != NULL) {
-
- strncpy(iohandler -> PhysicalFile, FileName, sizeof(iohandler -> PhysicalFile)-1);
- iohandler -> PhysicalFile[sizeof(iohandler -> PhysicalFile)-1] = 0;
- }
+ // Keep track of the original file
+ strncpy(iohandler -> PhysicalFile, FileName, sizeof(iohandler -> PhysicalFile)-1);
+ iohandler -> PhysicalFile[sizeof(iohandler -> PhysicalFile)-1] = 0;
iohandler ->Read = FileRead;
iohandler ->Seek = FileSeek;
return iohandler;
}
-// Create a iohandler for stream based files
+// Create a iohandler for stream based files
cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* Stream)
{
cmsIOHANDLER* iohandler = NULL;
-
+
iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
if (iohandler == NULL) return NULL;
iohandler -> ContextID = ContextID;
iohandler -> stream = (void*) Stream;
iohandler -> UsedSpace = 0;
- iohandler -> ReportedSize = cmsfilelength(Stream);
+ iohandler -> ReportedSize = (cmsUInt32Number) cmsfilelength(Stream);
iohandler -> PhysicalFile[0] = 0;
-
+
iohandler ->Read = FileRead;
iohandler ->Seek = FileSeek;
iohandler ->Close = FileClose;
// Set it to empty
Icc -> TagCount = 0;
- // Set default version
+ // Set default version
Icc ->Version = 0x02100000;
// Set creation date/time
memmove(&Icc ->Created, gmtime(&now), sizeof(Icc ->Created));
+ // Create a mutex if the user provided proper plugin. NULL otherwise
+ Icc ->UsrMutex = _cmsCreateMutex(ContextID);
+
// Return the handle
return (cmsHPROFILE) Icc;
}
cmsContext CMSEXPORT cmsGetProfileContextID(cmsHPROFILE hProfile)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
if (Icc == NULL) return NULL;
return Icc -> ContextID;
// Return the number of tags
cmsInt32Number CMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- if (Icc == NULL) return -1;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ if (Icc == NULL) return -1;
return Icc->TagCount;
}
// Return the tag signature of a given tag number
cmsTagSignature CMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, cmsUInt32Number n)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- if (n > Icc->TagCount) return (cmsTagSignature) 0; // Mark as not available
+ if (n > Icc->TagCount) return (cmsTagSignature) 0; // Mark as not available
if (n >= MAX_TABLE_TAG) return (cmsTagSignature) 0; // As double check
return Icc ->TagNames[n];
static
int SearchOneTag(_cmsICCPROFILE* Profile, cmsTagSignature sig)
{
- cmsUInt32Number i;
+ cmsUInt32Number i;
- for (i=0; i < Profile -> TagCount; i++) {
+ for (i=0; i < Profile -> TagCount; i++) {
- if (sig == Profile -> TagNames[i])
- return i;
- }
+ if (sig == Profile -> TagNames[i])
+ return i;
+ }
- return -1;
+ return -1;
}
// Search for a specific tag in tag dictionary. Returns position or -1 if tag not found.
// If followlinks is turned on, then the position of the linked tag is returned
int _cmsSearchTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, cmsBool lFollowLinks)
{
- int n;
- cmsTagSignature LinkedSig;
+ int n;
+ cmsTagSignature LinkedSig;
- do {
+ do {
- // Search for given tag in ICC profile directory
- n = SearchOneTag(Icc, sig);
- if (n < 0)
- return -1; // Not found
+ // Search for given tag in ICC profile directory
+ n = SearchOneTag(Icc, sig);
+ if (n < 0)
+ return -1; // Not found
- if (!lFollowLinks)
- return n; // Found, don't follow links
+ if (!lFollowLinks)
+ return n; // Found, don't follow links
- // Is this a linked tag?
- LinkedSig = Icc ->TagLinked[n];
+ // Is this a linked tag?
+ LinkedSig = Icc ->TagLinked[n];
- // Yes, follow link
- if (LinkedSig != (cmsTagSignature) 0) {
- sig = LinkedSig;
- }
+ // Yes, follow link
+ if (LinkedSig != (cmsTagSignature) 0) {
+ sig = LinkedSig;
+ }
- } while (LinkedSig != (cmsTagSignature) 0);
+ } while (LinkedSig != (cmsTagSignature) 0);
- return n;
+ return n;
}
+// Deletes a tag entry
-// Create a new tag entry
+static
+void _cmsDeleteTagByPos(_cmsICCPROFILE* Icc, int i)
+{
+ _cmsAssert(Icc != NULL);
+ _cmsAssert(i >= 0);
+
+ if (Icc -> TagPtrs[i] != NULL) {
+
+ // Free previous version
+ if (Icc ->TagSaveAsRaw[i]) {
+ _cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
+ }
+ else {
+ cmsTagTypeHandler* TypeHandler = Icc ->TagTypeHandlers[i];
+
+ if (TypeHandler != NULL) {
+
+ cmsTagTypeHandler LocalTypeHandler = *TypeHandler;
+ LocalTypeHandler.ContextID = Icc ->ContextID; // As an additional parameter
+ LocalTypeHandler.ICCVersion = Icc ->Version;
+ LocalTypeHandler.FreePtr(&LocalTypeHandler, Icc -> TagPtrs[i]);
+ Icc ->TagPtrs[i] = NULL;
+ }
+ }
+
+ }
+}
+
+
+// Creates a new tag entry
static
cmsBool _cmsNewTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, int* NewPos)
{
- int i;
+ int i;
- // Search for the tag
+ // Search for the tag
i = _cmsSearchTag(Icc, sig, FALSE);
-
- // Now let's do it easy. If the tag has been already written, that's an error
if (i >= 0) {
- cmsSignalError(Icc ->ContextID, cmsERROR_ALREADY_DEFINED, "Tag '%x' already exists", sig);
- return FALSE;
+
+ // Already exists? delete it
+ _cmsDeleteTagByPos(Icc, i);
+ *NewPos = i;
}
else {
- // New one
-
+ // No, make a new one
+
if (Icc -> TagCount >= MAX_TABLE_TAG) {
cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", MAX_TABLE_TAG);
return FALSE;
}
- *NewPos = Icc ->TagCount;
+ *NewPos = Icc ->TagCount;
Icc -> TagCount++;
}
- return TRUE;
+ return TRUE;
}
// Read the header
- if (io -> Read(io, &Header, sizeof(cmsICCHeader), 1) != 1) {
- return FALSE;
+ if (io -> Read(io, &Header, sizeof(cmsICCHeader), 1) != 1) {
+ return FALSE;
}
// Validate file as an ICC profile
if (_cmsAdjustEndianess32(Header.magic) != cmsMagicNumber) {
cmsSignalError(Icc ->ContextID, cmsERROR_BAD_SIGNATURE, "not an ICC profile, invalid signature");
- return FALSE;
+ return FALSE;
}
// Adjust endianess of the used parameters
Icc -> DeviceClass = (cmsProfileClassSignature) _cmsAdjustEndianess32(Header.deviceClass);
Icc -> ColorSpace = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Header.colorSpace);
Icc -> PCS = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Header.pcs);
+
Icc -> RenderingIntent = _cmsAdjustEndianess32(Header.renderingIntent);
Icc -> flags = _cmsAdjustEndianess32(Header.flags);
Icc -> manufacturer = _cmsAdjustEndianess32(Header.manufacturer);
Icc -> model = _cmsAdjustEndianess32(Header.model);
- _cmsAdjustEndianess64(&Icc -> attributes, Header.attributes);
+ Icc -> creator = _cmsAdjustEndianess32(Header.creator);
+
+ _cmsAdjustEndianess64(&Icc -> attributes, &Header.attributes);
Icc -> Version = _cmsAdjustEndianess32(Header.version);
// Get size as reported in header
if (HeaderSize >= Icc ->IOhandler ->ReportedSize)
HeaderSize = Icc ->IOhandler ->ReportedSize;
-
+
// Get creation date/time
_cmsDecodeDateTimeNumber(&Header.date, &Icc ->Created);
// Read tag directory
- if (!_cmsReadUInt32Number(io, &TagCount)) return FALSE;
+ if (!_cmsReadUInt32Number(io, &TagCount)) return FALSE;
if (TagCount > MAX_TABLE_TAG) {
cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", TagCount);
// Perform some sanity check. Offset + size should fall inside file.
if (Tag.offset + Tag.size > HeaderSize ||
- Tag.offset + Tag.size < Tag.offset)
+ Tag.offset + Tag.size < Tag.offset)
continue;
Icc -> TagNames[Icc ->TagCount] = Tag.sig;
if ((Icc ->TagOffsets[j] == Tag.offset) &&
(Icc ->TagSizes[j] == Tag.size)) {
- Icc ->TagLinked[Icc ->TagCount] = Icc ->TagNames[j];
+ Icc ->TagLinked[Icc ->TagCount] = Icc ->TagNames[j];
}
}
Icc ->TagCount++;
}
-
+
return TRUE;
}
// Saves profile header
cmsBool _cmsWriteHeader(_cmsICCPROFILE* Icc, cmsUInt32Number UsedSpace)
{
- cmsICCHeader Header;
+ cmsICCHeader Header;
cmsUInt32Number i;
- cmsTagEntry Tag;
+ cmsTagEntry Tag;
cmsInt32Number Count = 0;
Header.size = _cmsAdjustEndianess32(UsedSpace);
Header.magic = _cmsAdjustEndianess32(cmsMagicNumber);
#ifdef CMS_IS_WINDOWS_
- Header.platform = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMicrosoft);
+ Header.platform = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMicrosoft);
#else
- Header.platform = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMacintosh);
+ Header.platform = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMacintosh);
#endif
Header.flags = _cmsAdjustEndianess32(Icc -> flags);
Header.manufacturer = _cmsAdjustEndianess32(Icc -> manufacturer);
Header.model = _cmsAdjustEndianess32(Icc -> model);
- _cmsAdjustEndianess64(&Header.attributes, Icc -> attributes);
-
+ _cmsAdjustEndianess64(&Header.attributes, &Icc -> attributes);
+
// Rendering intent in the header (for embedded profiles)
Header.renderingIntent = _cmsAdjustEndianess32(Icc -> RenderingIntent);
memset(&Header.reserved, 0, sizeof(Header.reserved));
- // Set profile ID. Endianess is always big endian
+ // Set profile ID. Endianess is always big endian
memmove(&Header.profileID, &Icc ->ProfileID, 16);
// Dump the header
}
// Store number of tags
- if (!_cmsWriteUInt32Number(Icc ->IOhandler, Count)) return FALSE;
+ if (!_cmsWriteUInt32Number(Icc ->IOhandler, Count)) return FALSE;
for (i=0; i < Icc -> TagCount; i++) {
cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile)
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- return (cmsUInt32Number) Icc ->manufacturer;
+ return Icc ->manufacturer;
}
void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer)
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- Icc -> manufacturer = (cmsUInt32Number) manufacturer;
+ Icc -> manufacturer = manufacturer;
+}
+
+cmsUInt32Number CMSEXPORT cmsGetHeaderCreator(cmsHPROFILE hProfile)
+{
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ return Icc ->creator;
}
cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile)
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- return (cmsUInt32Number) Icc ->model;
+ return Icc ->model;
}
void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model)
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- Icc -> manufacturer = (cmsUInt32Number) model;
+ Icc -> model = model;
}
-
void CMSEXPORT cmsGetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number* Flags)
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
void CMSEXPORT cmsGetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- memmove(ProfileID, Icc ->ProfileID.ID8, 16);
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ memmove(ProfileID, Icc ->ProfileID.ID8, 16);
}
void CMSEXPORT cmsSetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)
cmsBool CMSEXPORT cmsGetHeaderCreationDateTime(cmsHPROFILE hProfile, struct tm *Dest)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- memmove(Dest, &Icc ->Created, sizeof(struct tm));
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ memmove(Dest, &Icc ->Created, sizeof(struct tm));
return TRUE;
}
char Buff[100];
int i, len;
cmsUInt32Number out;
-
+
for (len=0; in > 0 && len < 100; len++) {
-
+
Buff[len] = (char) (in % BaseIn);
in /= BaseIn;
}
// 4.2 -> 0x4200000
- Icc -> Version = BaseToBase((cmsUInt32Number) floor(Version * 100.0), 10, 16) << 16;
+ Icc -> Version = BaseToBase((cmsUInt32Number) floor(Version * 100.0 + 0.5), 10, 16) << 16;
}
cmsFloat64Number CMSEXPORT cmsGetProfileVersion(cmsHPROFILE hProfile)
NewIcc = (_cmsICCPROFILE*) hEmpty;
NewIcc ->IOhandler = io;
- if (!_cmsReadHeader(NewIcc)) goto Error;
+ if (!_cmsReadHeader(NewIcc)) goto Error;
+ return hEmpty;
+
+Error:
+ cmsCloseProfile(hEmpty);
+ return NULL;
+}
+
+// Create profile from IOhandler
+cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandler2THR(cmsContext ContextID, cmsIOHANDLER* io, cmsBool write)
+{
+ _cmsICCPROFILE* NewIcc;
+ cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
+
+ if (hEmpty == NULL) return NULL;
+
+ NewIcc = (_cmsICCPROFILE*) hEmpty;
+
+ NewIcc ->IOhandler = io;
+ if (write) {
+
+ NewIcc -> IsWrite = TRUE;
+ return hEmpty;
+ }
+
+ if (!_cmsReadHeader(NewIcc)) goto Error;
return hEmpty;
Error:
return NULL;
}
+
// Create profile from disk file
cmsHPROFILE CMSEXPORT cmsOpenProfileFromFileTHR(cmsContext ContextID, const char *lpFileName, const char *sAccess)
{
if (*sAccess == 'W' || *sAccess == 'w') {
NewIcc -> IsWrite = TRUE;
-
+
return hEmpty;
}
if (*sAccess == 'w') {
- NewIcc -> IsWrite = TRUE;
+ NewIcc -> IsWrite = TRUE;
return hEmpty;
}
- if (!_cmsReadHeader(NewIcc)) goto Error;
+ if (!_cmsReadHeader(NewIcc)) goto Error;
return hEmpty;
Error:
NewIcc = (_cmsICCPROFILE*) hEmpty;
- // Ok, in this case const void* is casted to void* just because open IO handler
- // shares read and writting modes. Don't abuse this feature!
+ // Ok, in this case const void* is casted to void* just because open IO handler
+ // shares read and writting modes. Don't abuse this feature!
NewIcc ->IOhandler = cmsOpenIOhandlerFromMem(ContextID, (void*) MemPtr, dwSize, "r");
if (NewIcc ->IOhandler == NULL) goto Error;
cmsIOHANDLER* io = Icc ->IOhandler;
cmsTagDescriptor* TagDescriptor;
cmsTagTypeSignature TypeBase;
+ cmsTagTypeSignature Type;
cmsTagTypeHandler* TypeHandler;
-
+ cmsFloat64Number Version = cmsGetProfileVersion((cmsHPROFILE) Icc);
+ cmsTagTypeHandler LocalTypeHandler;
for (i=0; i < Icc -> TagCount; i++) {
-
if (Icc ->TagNames[i] == 0) continue;
// Linked tags are not written
if (!Data) {
- // Reach here if we are copying a tag from a disk-based ICC profile which has not been modified by user.
+ // Reach here if we are copying a tag from a disk-based ICC profile which has not been modified by user.
// In this case a blind copy of the block data is performed
if (FileOrig != NULL && Icc -> TagOffsets[i]) {
if (!FileOrig ->IOhandler->Seek(FileOrig ->IOhandler, TagOffset)) return FALSE;
- Mem = _cmsMalloc(Icc ->ContextID, TagSize);
+ Mem = _cmsMalloc(Icc ->ContextID, TagSize);
if (Mem == NULL) return FALSE;
if (FileOrig ->IOhandler->Read(FileOrig->IOhandler, Mem, TagSize, 1) != 1) return FALSE;
_cmsFree(Icc ->ContextID, Mem);
Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
-
+
// Align to 32 bit boundary.
- if (! _cmsWriteAlignment(io))
- return FALSE;
+ if (! _cmsWriteAlignment(io))
+ return FALSE;
}
continue;
else {
// Search for support on this tag
- TagDescriptor = _cmsGetTagDescriptor(Icc -> TagNames[i]);
+ TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, Icc -> TagNames[i]);
if (TagDescriptor == NULL) continue; // Unsupported, ignore it
+
+ if (TagDescriptor ->DecideType != NULL) {
- TypeHandler = Icc ->TagTypeHandlers[i];
+ Type = TagDescriptor ->DecideType(Version, Data);
+ }
+ else {
+
+ Type = TagDescriptor ->SupportedTypes[0];
+ }
+
+ TypeHandler = _cmsGetTagTypeHandler(Icc->ContextID, Type);
if (TypeHandler == NULL) {
cmsSignalError(Icc ->ContextID, cmsERROR_INTERNAL, "(Internal) no handler for tag %x", Icc -> TagNames[i]);
continue;
}
- TypeBase = TypeHandler ->Signature;
- if (!_cmsWriteTypeBase(io, TypeBase))
+ TypeBase = TypeHandler ->Signature;
+ if (!_cmsWriteTypeBase(io, TypeBase))
return FALSE;
- TypeHandler ->ContextID = Icc ->ContextID;
- TypeHandler ->ICCVersion = Icc ->Version;
- if (!TypeHandler ->WritePtr(TypeHandler, io, Data, TagDescriptor ->ElemCount)) {
+ LocalTypeHandler = *TypeHandler;
+ LocalTypeHandler.ContextID = Icc ->ContextID;
+ LocalTypeHandler.ICCVersion = Icc ->Version;
+ if (!LocalTypeHandler.WritePtr(&LocalTypeHandler, io, Data, TagDescriptor ->ElemCount)) {
- char String[5];
+ char String[5];
- _cmsTagSignature2String(String, (cmsTagSignature) TypeBase);
+ _cmsTagSignature2String(String, (cmsTagSignature) TypeBase);
cmsSignalError(Icc ->ContextID, cmsERROR_WRITE, "Couldn't write type '%s'", String);
- return FALSE;
+ return FALSE;
}
}
- Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
+ Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
// Align to 32 bit boundary.
- if (! _cmsWriteAlignment(io))
- return FALSE;
+ if (! _cmsWriteAlignment(io))
+ return FALSE;
}
cmsUInt32Number CMSEXPORT cmsSaveProfileToIOhandler(cmsHPROFILE hProfile, cmsIOHANDLER* io)
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- _cmsICCPROFILE Keep;
- cmsIOHANDLER* PrevIO;
+ _cmsICCPROFILE Keep;
+ cmsIOHANDLER* PrevIO = NULL;
cmsUInt32Number UsedSpace;
cmsContext ContextID;
+ _cmsAssert(hProfile != NULL);
+
memmove(&Keep, Icc, sizeof(_cmsICCPROFILE));
ContextID = cmsGetProfileContextID(hProfile);
// Pass #1 does compute offsets
- if (!_cmsWriteHeader(Icc, 0)) return 0;
- if (!SaveTags(Icc, &Keep)) return 0;
+ if (!_cmsWriteHeader(Icc, 0)) goto Error;
+ if (!SaveTags(Icc, &Keep)) goto Error;
UsedSpace = PrevIO ->UsedSpace;
// Pass #2 does save to iohandler
if (io != NULL) {
- Icc ->IOhandler = io;
- if (!SetLinks(Icc)) goto CleanUp;
- if (!_cmsWriteHeader(Icc, UsedSpace)) goto CleanUp;
- if (!SaveTags(Icc, &Keep)) goto CleanUp;
+
+ Icc ->IOhandler = io;
+ if (!SetLinks(Icc)) goto Error;
+ if (!_cmsWriteHeader(Icc, UsedSpace)) goto Error;
+ if (!SaveTags(Icc, &Keep)) goto Error;
}
memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
return UsedSpace;
-CleanUp:
- cmsCloseIOhandler(PrevIO);
+Error:
+ cmsCloseIOhandler(PrevIO);
memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
return 0;
}
-// Low-level save to disk.
+// Low-level save to disk.
cmsBool CMSEXPORT cmsSaveProfileToFile(cmsHPROFILE hProfile, const char* FileName)
-{
+{
cmsContext ContextID = cmsGetProfileContextID(hProfile);
cmsIOHANDLER* io = cmsOpenIOhandlerFromFile(ContextID, FileName, "w");
cmsBool rc;
-
+
if (io == NULL) return FALSE;
rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
cmsBool rc;
cmsContext ContextID = cmsGetProfileContextID(hProfile);
cmsIOHANDLER* io = cmsOpenIOhandlerFromStream(ContextID, Stream);
-
+
if (io == NULL) return FALSE;
rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
cmsBool rc;
cmsIOHANDLER* io;
cmsContext ContextID = cmsGetProfileContextID(hProfile);
-
+
+ _cmsAssert(BytesNeeded != NULL);
+
// Should we just calculate the needed space?
- if (MemPtr == NULL) {
+ if (MemPtr == NULL) {
*BytesNeeded = cmsSaveProfileToIOhandler(hProfile, NULL);
- return TRUE;
+ return (*BytesNeeded == 0) ? FALSE : TRUE;
}
// That is a real write operation
{
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
cmsBool rc = TRUE;
- cmsUInt32Number i;
+ cmsUInt32Number i;
if (!Icc) return FALSE;
- // Was open in write mode?
+ // Was open in write mode?
if (Icc ->IsWrite) {
Icc ->IsWrite = FALSE; // Assure no further writting
- rc &= cmsSaveProfileToFile(hProfile, Icc ->IOhandler->PhysicalFile);
+ rc &= cmsSaveProfileToFile(hProfile, Icc ->IOhandler->PhysicalFile);
}
for (i=0; i < Icc -> TagCount; i++) {
cmsTagTypeHandler* TypeHandler = Icc ->TagTypeHandlers[i];
if (TypeHandler != NULL) {
+ cmsTagTypeHandler LocalTypeHandler = *TypeHandler;
- TypeHandler ->ContextID = Icc ->ContextID; // As an additional parameters
- TypeHandler ->ICCVersion = Icc ->Version;
- TypeHandler ->FreePtr(TypeHandler, Icc -> TagPtrs[i]);
+ LocalTypeHandler.ContextID = Icc ->ContextID; // As an additional parameters
+ LocalTypeHandler.ICCVersion = Icc ->Version;
+ LocalTypeHandler.FreePtr(&LocalTypeHandler, Icc -> TagPtrs[i]);
}
else
_cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
}
}
- if (Icc ->IOhandler != NULL) {
- rc &= cmsCloseIOhandler(Icc->IOhandler);
- }
+ if (Icc ->IOhandler != NULL) {
+ rc &= cmsCloseIOhandler(Icc->IOhandler);
+ }
+
+ _cmsDestroyMutex(Icc->ContextID, Icc->UsrMutex);
_cmsFree(Icc ->ContextID, Icc); // Free placeholder memory
nMaxTypes = TagDescriptor->nSupportedTypes;
if (nMaxTypes >= MAX_TYPES_IN_LCMS_PLUGIN)
nMaxTypes = MAX_TYPES_IN_LCMS_PLUGIN;
-
+
for (i=0; i < nMaxTypes; i++) {
- if (Type == TagDescriptor ->SupportedTypes[i]) return TRUE;
+ if (Type == TagDescriptor ->SupportedTypes[i]) return TRUE;
}
return FALSE;
// That's the main read function
void* CMSEXPORT cmsReadTag(cmsHPROFILE hProfile, cmsTagSignature sig)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
cmsIOHANDLER* io = Icc ->IOhandler;
cmsTagTypeHandler* TypeHandler;
+ cmsTagTypeHandler LocalTypeHandler;
cmsTagDescriptor* TagDescriptor;
cmsTagTypeSignature BaseType;
cmsUInt32Number Offset, TagSize;
cmsUInt32Number ElemCount;
int n;
- n = _cmsSearchTag(Icc, sig, TRUE);
- if (n < 0) return NULL; // Not found, return NULL
+ if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return NULL;
+ n = _cmsSearchTag(Icc, sig, TRUE);
+ if (n < 0) goto Error; // Not found, return NULL
- // If the element is already in memory, return the pointer
- if (Icc -> TagPtrs[n]) {
+ // If the element is already in memory, return the pointer
+ if (Icc -> TagPtrs[n]) {
- if (Icc ->TagSaveAsRaw[n]) return NULL; // We don't support read raw tags as cooked
- return Icc -> TagPtrs[n];
- }
+ if (Icc ->TagSaveAsRaw[n]) goto Error; // We don't support read raw tags as cooked
+
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return Icc -> TagPtrs[n];
+ }
- // We need to read it. Get the offset and size to the file
+ // We need to read it. Get the offset and size to the file
Offset = Icc -> TagOffsets[n];
- TagSize = Icc -> TagSizes[n];
-
+ TagSize = Icc -> TagSizes[n];
+
// Seek to its location
if (!io -> Seek(io, Offset))
- return NULL;
+ goto Error;
// Search for support on this tag
- TagDescriptor = _cmsGetTagDescriptor(sig);
- if (TagDescriptor == NULL) return NULL; // Unsupported.
+ TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
+ if (TagDescriptor == NULL) {
+
+ char String[5];
+
+ _cmsTagSignature2String(String, sig);
+
+ // An unknown element was found.
+ cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown tag type '%s' found.", String);
+ goto Error; // Unsupported.
+ }
// if supported, get type and check if in list
BaseType = _cmsReadTypeBase(io);
- if (BaseType == 0) return NULL;
+ if (BaseType == 0) goto Error;
- if (!IsTypeSupported(TagDescriptor, BaseType)) return NULL;
+ if (!IsTypeSupported(TagDescriptor, BaseType)) goto Error;
TagSize -= 8; // Alredy read by the type base logic
// Get type handler
- TypeHandler = _cmsGetTagTypeHandler(BaseType);
- if (TypeHandler == NULL) return NULL;
+ TypeHandler = _cmsGetTagTypeHandler(Icc ->ContextID, BaseType);
+ if (TypeHandler == NULL) goto Error;
+ LocalTypeHandler = *TypeHandler;
// Read the tag
Icc -> TagTypeHandlers[n] = TypeHandler;
- TypeHandler ->ContextID = Icc ->ContextID;
- TypeHandler ->ICCVersion = Icc ->Version;
- Icc -> TagPtrs[n] = TypeHandler ->ReadPtr(TypeHandler, io, &ElemCount, TagSize);
+ LocalTypeHandler.ContextID = Icc ->ContextID;
+ LocalTypeHandler.ICCVersion = Icc ->Version;
+ Icc -> TagPtrs[n] = LocalTypeHandler.ReadPtr(&LocalTypeHandler, io, &ElemCount, TagSize);
// The tag type is supported, but something wrong happend and we cannot read the tag.
// let know the user about this (although it is just a warning)
_cmsTagSignature2String(String, sig);
cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "Corrupted tag '%s'", String);
- return NULL;
+ goto Error;
}
// This is a weird error that may be a symptom of something more serious, the number of
- // stored item is actually less than the number of required elements.
+ // stored item is actually less than the number of required elements.
if (ElemCount < TagDescriptor ->ElemCount) {
char String[5];
_cmsTagSignature2String(String, sig);
- cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "'%s' Inconsistent number of items: expected %d, got %d",
- String, TagDescriptor ->ElemCount, ElemCount);
+ cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "'%s' Inconsistent number of items: expected %d, got %d",
+ String, TagDescriptor ->ElemCount, ElemCount);
}
-
+
// Return the data
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return Icc -> TagPtrs[n];
+
+
+ // Return error and unlock tha data
+Error:
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return NULL;
}
// Get true type of data
cmsTagTypeSignature _cmsGetTagTrueType(cmsHPROFILE hProfile, cmsTagSignature sig)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- cmsTagTypeHandler* TypeHandler;
- int n;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ cmsTagTypeHandler* TypeHandler;
+ int n;
- // Search for given tag in ICC profile directory
- n = _cmsSearchTag(Icc, sig, TRUE);
- if (n < 0) return (cmsTagTypeSignature) 0; // Not found, return NULL
+ // Search for given tag in ICC profile directory
+ n = _cmsSearchTag(Icc, sig, TRUE);
+ if (n < 0) return (cmsTagTypeSignature) 0; // Not found, return NULL
- // Get the handler. The true type is there
- TypeHandler = Icc -> TagTypeHandlers[n];
- return TypeHandler ->Signature;
+ // Get the handler. The true type is there
+ TypeHandler = Icc -> TagTypeHandlers[n];
+ return TypeHandler ->Signature;
}
// in that list, the previous version is deleted.
cmsBool CMSEXPORT cmsWriteTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
cmsTagTypeHandler* TypeHandler = NULL;
+ cmsTagTypeHandler LocalTypeHandler;
cmsTagDescriptor* TagDescriptor = NULL;
cmsTagTypeSignature Type;
int i;
cmsFloat64Number Version;
char TypeString[5], SigString[5];
+ if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return FALSE;
+ // To delete tags.
if (data == NULL) {
- cmsSignalError(cmsGetProfileContextID(hProfile), cmsERROR_NULL, "couldn't wite NULL to tag");
- return FALSE;
- }
-
- i = _cmsSearchTag(Icc, sig, FALSE);
- if (i >=0) {
-
- if (Icc -> TagPtrs[i] != NULL) {
-
- // Already exists. Free previous version
- if (Icc ->TagSaveAsRaw[i]) {
- _cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
- }
- else {
- TypeHandler = Icc ->TagTypeHandlers[i];
-
- if (TypeHandler != NULL) {
-
- TypeHandler ->ContextID = Icc ->ContextID; // As an additional parameter
- TypeHandler ->ICCVersion = Icc ->Version;
- TypeHandler->FreePtr(TypeHandler, Icc -> TagPtrs[i]);
- }
- }
- }
+ // Delete the tag
+ i = _cmsSearchTag(Icc, sig, FALSE);
+ if (i >= 0) {
+
+ // Use zero as a mark of deleted
+ _cmsDeleteTagByPos(Icc, i);
+ Icc ->TagNames[i] = (cmsTagSignature) 0;
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return TRUE;
+ }
+ // Didn't find the tag
+ goto Error;
}
- else {
- // New one
- i = Icc -> TagCount;
- if (i >= MAX_TABLE_TAG) {
- cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", MAX_TABLE_TAG);
- return FALSE;
- }
-
- Icc -> TagCount++;
- }
+ if (!_cmsNewTag(Icc, sig, &i)) goto Error;
// This is not raw
Icc ->TagSaveAsRaw[i] = FALSE;
// This is not a link
Icc ->TagLinked[i] = (cmsTagSignature) 0;
- // Get information about the TAG.
- TagDescriptor = _cmsGetTagDescriptor(sig);
+ // Get information about the TAG.
+ TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
if (TagDescriptor == NULL){
cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported tag '%x'", sig);
- return FALSE;
+ goto Error;
}
-
- // Now we need to know which type to use. It depends on the version.
+
+ // Now we need to know which type to use. It depends on the version.
Version = cmsGetProfileVersion(hProfile);
if (TagDescriptor ->DecideType != NULL) {
// Let the tag descriptor to decide the type base on depending on
- // the data. This is useful for example on parametric curves, where
+ // the data. This is useful for example on parametric curves, where
// curves specified by a table cannot be saved as parametric and needs
- // to be revented to single v2-curves, even on v4 profiles.
+ // to be casted to single v2-curves, even on v4 profiles.
Type = TagDescriptor ->DecideType(Version, data);
}
else {
-
Type = TagDescriptor ->SupportedTypes[0];
}
// Does the tag support this type?
if (!IsTypeSupported(TagDescriptor, Type)) {
-
+
_cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
_cmsTagSignature2String(SigString, sig);
cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported type '%s' for tag '%s'", TypeString, SigString);
- return FALSE;
+ goto Error;
}
// Does we have a handler for this type?
- TypeHandler = _cmsGetTagTypeHandler(Type);
+ TypeHandler = _cmsGetTagTypeHandler(Icc->ContextID, Type);
if (TypeHandler == NULL) {
_cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
_cmsTagSignature2String(SigString, sig);
cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported type '%s' for tag '%s'", TypeString, SigString);
- return FALSE; // Should never happen
+ goto Error; // Should never happen
}
Icc ->TagSizes[i] = 0;
Icc ->TagOffsets[i] = 0;
- TypeHandler ->ContextID = Icc ->ContextID;
- TypeHandler ->ICCVersion = Icc ->Version;
- Icc ->TagPtrs[i] = TypeHandler ->DupPtr(TypeHandler, data, TagDescriptor ->ElemCount);
+ LocalTypeHandler = *TypeHandler;
+ LocalTypeHandler.ContextID = Icc ->ContextID;
+ LocalTypeHandler.ICCVersion = Icc ->Version;
+ Icc ->TagPtrs[i] = LocalTypeHandler.DupPtr(&LocalTypeHandler, data, TagDescriptor ->ElemCount);
if (Icc ->TagPtrs[i] == NULL) {
_cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
_cmsTagSignature2String(SigString, sig);
cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "Malformed struct in type '%s' for tag '%s'", TypeString, SigString);
-
- return FALSE;
+
+ goto Error;
}
-
+
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return TRUE;
+
+Error:
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return FALSE;
+
}
-// Read and write raw data. The only way those function would work and keep consistence with normal read and write
+// Read and write raw data. The only way those function would work and keep consistence with normal read and write
// is to do an additional step of serialization. That means, readRaw would issue a normal read and then convert the obtained
// data to raw bytes by using the "write" serialization logic. And vice-versa. I know this may end in situations where
// raw data written does not exactly correspond with the raw data proposed to cmsWriteRaw data, but this approach allows
cmsInt32Number CMSEXPORT cmsReadRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, void* data, cmsUInt32Number BufferSize)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- void *Object;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ void *Object;
int i;
cmsIOHANDLER* MemIO;
cmsTagTypeHandler* TypeHandler = NULL;
+ cmsTagTypeHandler LocalTypeHandler;
cmsTagDescriptor* TagDescriptor = NULL;
cmsUInt32Number rc;
cmsUInt32Number Offset, TagSize;
- // Search for given tag in ICC profile directory
- i = _cmsSearchTag(Icc, sig, TRUE);
- if (i < 0) return 0; // Not found, return 0
+ if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
- // It is already read?
+ // Search for given tag in ICC profile directory
+ i = _cmsSearchTag(Icc, sig, TRUE);
+ if (i < 0) goto Error; // Not found,
+
+ // It is already read?
if (Icc -> TagPtrs[i] == NULL) {
// No yet, get original position
Offset = Icc ->TagOffsets[i];
TagSize = Icc ->TagSizes[i];
-
// read the data directly, don't keep copy
- if (data != NULL) {
+ if (data != NULL) {
+
+ if (BufferSize < TagSize)
+ TagSize = BufferSize;
- if (BufferSize < TagSize)
- TagSize = BufferSize;
+ if (!Icc ->IOhandler ->Seek(Icc ->IOhandler, Offset)) goto Error;
+ if (!Icc ->IOhandler ->Read(Icc ->IOhandler, data, 1, TagSize)) goto Error;
- if (!Icc ->IOhandler ->Seek(Icc ->IOhandler, Offset)) return 0;
- if (!Icc ->IOhandler ->Read(Icc ->IOhandler, data, 1, TagSize)) return 0;
- }
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return TagSize;
+ }
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return Icc ->TagSizes[i];
}
// The data has been already read, or written. But wait!, maybe the user choosed to save as
// raw data. In this case, return the raw data directly
if (Icc ->TagSaveAsRaw[i]) {
-
- if (data != NULL) {
- TagSize = Icc ->TagSizes[i];
- if (BufferSize < TagSize)
- TagSize = BufferSize;
+ if (data != NULL) {
+
+ TagSize = Icc ->TagSizes[i];
+ if (BufferSize < TagSize)
+ TagSize = BufferSize;
memmove(data, Icc ->TagPtrs[i], TagSize);
- }
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return TagSize;
+ }
+
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return Icc ->TagSizes[i];
}
- // Already readed, or previously set by cmsWriteTag(). We need to serialize that
+ // Already readed, or previously set by cmsWriteTag(). We need to serialize that
// data to raw in order to maintain consistency.
+
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
Object = cmsReadTag(hProfile, sig);
- if (Object == NULL) return 0;
+ if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
+
+ if (Object == NULL) goto Error;
// Now we need to serialize to a memory block: just use a memory iohandler
- if (data == NULL) {
- MemIO = cmsOpenIOhandlerFromNULL(cmsGetProfileContextID(hProfile));
- } else{
- MemIO = cmsOpenIOhandlerFromMem(cmsGetProfileContextID(hProfile), data, BufferSize, "w");
- }
- if (MemIO == NULL) return 0;
+ if (data == NULL) {
+ MemIO = cmsOpenIOhandlerFromNULL(cmsGetProfileContextID(hProfile));
+ } else{
+ MemIO = cmsOpenIOhandlerFromMem(cmsGetProfileContextID(hProfile), data, BufferSize, "w");
+ }
+ if (MemIO == NULL) goto Error;
// Obtain type handling for the tag
TypeHandler = Icc ->TagTypeHandlers[i];
- TagDescriptor = _cmsGetTagDescriptor(sig);
+ TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
+ if (TagDescriptor == NULL) {
+ cmsCloseIOhandler(MemIO);
+ goto Error;
+ }
+
+ if (TypeHandler == NULL) goto Error;
// Serialize
- TypeHandler ->ContextID = Icc ->ContextID;
- TypeHandler ->ICCVersion = Icc ->Version;
- if (!TypeHandler ->WritePtr(TypeHandler, MemIO, Object, TagDescriptor ->ElemCount)) return 0;
+ LocalTypeHandler = *TypeHandler;
+ LocalTypeHandler.ContextID = Icc ->ContextID;
+ LocalTypeHandler.ICCVersion = Icc ->Version;
+
+ if (!_cmsWriteTypeBase(MemIO, TypeHandler ->Signature)) {
+ cmsCloseIOhandler(MemIO);
+ goto Error;
+ }
+
+ if (!LocalTypeHandler.WritePtr(&LocalTypeHandler, MemIO, Object, TagDescriptor ->ElemCount)) {
+ cmsCloseIOhandler(MemIO);
+ goto Error;
+ }
// Get Size and close
rc = MemIO ->Tell(MemIO);
cmsCloseIOhandler(MemIO); // Ignore return code this time
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return rc;
+
+Error:
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return 0;
}
// Similar to the anterior. This function allows to write directly to the ICC profile any data, without
-// checking anything. As a rule, mixing Raw with cooked doesn't work, so writting a tag as raw and then reading
+// checking anything. As a rule, mixing Raw with cooked doesn't work, so writting a tag as raw and then reading
// it as cooked without serializing does result into an error. If that is wha you want, you will need to dump
// the profile to memry or disk and then reopen it.
cmsBool CMSEXPORT cmsWriteRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data, cmsUInt32Number Size)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
int i;
- if (!_cmsNewTag(Icc, sig, &i)) return FALSE;
+ if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
+
+ if (!_cmsNewTag(Icc, sig, &i)) {
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return FALSE;
+ }
// Mark the tag as being written as RAW
Icc ->TagSaveAsRaw[i] = TRUE;
Icc ->TagPtrs[i] = _cmsDupMem(Icc ->ContextID, data, Size);
Icc ->TagSizes[i] = Size;
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return TRUE;
}
// Using this function you can collapse several tag entries to the same block in the profile
cmsBool CMSEXPORT cmsLinkTag(cmsHPROFILE hProfile, cmsTagSignature sig, cmsTagSignature dest)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
int i;
- if (!_cmsNewTag(Icc, sig, &i)) return FALSE;
+ if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return FALSE;
+
+ if (!_cmsNewTag(Icc, sig, &i)) {
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
+ return FALSE;
+ }
// Keep necessary information
Icc ->TagSaveAsRaw[i] = FALSE;
Icc ->TagNames[i] = sig;
Icc ->TagLinked[i] = dest;
-
+
Icc ->TagPtrs[i] = NULL;
Icc ->TagSizes[i] = 0;
Icc ->TagOffsets[i] = 0;
+ _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
return TRUE;
}
// Returns the tag linked to sig, in the case two tags are sharing same resource
cmsTagSignature CMSEXPORT cmsTagLinkedTo(cmsHPROFILE hProfile, cmsTagSignature sig)
{
- _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
+ _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
int i;
// Search for given tag in ICC profile directory
- i = _cmsSearchTag(Icc, sig, FALSE);
- if (i < 0) return (cmsTagSignature) 0; // Not found, return 0
+ i = _cmsSearchTag(Icc, sig, FALSE);
+ if (i < 0) return (cmsTagSignature) 0; // Not found, return 0
return Icc -> TagLinked[i];
}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// Several resources for gray conversions.
static const cmsFloat64Number GrayInputMatrix[] = { (InpAdj*cmsD50X), (InpAdj*cmsD50Y), (InpAdj*cmsD50Z) };
-static const cmsFloat64Number OneToThreeInputMatrix[] = { 1, 1, 1 };
-static const cmsFloat64Number PickYMatrix[] = { 0, (OutpAdj*cmsD50Y), 0 };
-static const cmsFloat64Number PickLstarMatrix[] = { 1, 0, 0 };
+static const cmsFloat64Number OneToThreeInputMatrix[] = { 1, 1, 1 };
+static const cmsFloat64Number PickYMatrix[] = { 0, (OutpAdj*cmsD50Y), 0 };
+static const cmsFloat64Number PickLstarMatrix[] = { 1, 0, 0 };
// Get a media white point fixing some issues found in certain old profiles
cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ* Dest, cmsHPROFILE hProfile)
_cmsAssert(Dest != NULL);
- Tag = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag);
+ Tag = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag);
// If no wp, take D50
if (Tag == NULL) {
if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) {
*Dest = *cmsD50_XYZ();
- return TRUE;
+ return TRUE;
}
}
Tag = (cmsMAT3*) cmsReadTag(hProfile, cmsSigChromaticAdaptationTag);
if (Tag != NULL) {
-
*Dest = *Tag;
return TRUE;
}
if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) {
- cmsCIEXYZ* White = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag);
+ cmsCIEXYZ* White = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag);
if (White == NULL) {
return TRUE;
}
- return _cmsAdaptationMatrix(Dest, NULL, cmsD50_XYZ(), White);
+ return _cmsAdaptationMatrix(Dest, NULL, White, cmsD50_XYZ());
}
}
PtrGreen = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigGreenColorantTag);
PtrBlue = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigBlueColorantTag);
- if (PtrRed == NULL || PtrGreen == NULL || PtrBlue == NULL)
+ if (PtrRed == NULL || PtrGreen == NULL || PtrBlue == NULL)
return FALSE;
_cmsVEC3init(&r -> v[0], PtrRed -> X, PtrGreen -> X, PtrBlue -> X);
cmsToneCurve *GrayTRC;
cmsPipeline* Lut;
cmsContext ContextID = cmsGetProfileContextID(hProfile);
-
+
GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag);
if (GrayTRC == NULL) return NULL;
Lut = cmsPipelineAlloc(ContextID, 1, 3);
- if (Lut == NULL) return NULL;
+ if (Lut == NULL)
+ goto Error;
if (cmsGetPCS(hProfile) == cmsSigLabData) {
cmsUInt16Number Zero[2] = { 0x8080, 0x8080 };
cmsToneCurve* EmptyTab;
cmsToneCurve* LabCurves[3];
-
- EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
- if (EmptyTab == NULL) {
+ EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
- cmsPipelineFree(Lut);
- return NULL;
- }
+ if (EmptyTab == NULL)
+ goto Error;
LabCurves[0] = GrayTRC;
LabCurves[1] = EmptyTab;
LabCurves[2] = EmptyTab;
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, OneToThreeInputMatrix, NULL));
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, LabCurves));
-
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, OneToThreeInputMatrix, NULL)) ||
+ !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, LabCurves))) {
+ cmsFreeToneCurve(EmptyTab);
+ goto Error;
+ }
+
cmsFreeToneCurve(EmptyTab);
}
else {
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &GrayTRC));
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, GrayInputMatrix, NULL));
+
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &GrayTRC)) ||
+ !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, GrayInputMatrix, NULL)))
+ goto Error;
}
-
+
return Lut;
+
+Error:
+ cmsFreeToneCurve(GrayTRC);
+ cmsPipelineFree(Lut);
+ return NULL;
}
// RGB Matrix shaper
if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL;
// XYZ PCS in encoded in 1.15 format, and the matrix output comes in 0..0xffff range, so
- // we need to adjust the output by a factor of (0x10000/0xffff) to put data in
+ // we need to adjust the output by a factor of (0x10000/0xffff) to put data in
// a 1.16 range, and then a >> 1 to obtain 1.15. The total factor is (65536.0)/(65535.0*2)
-
+
for (i=0; i < 3; i++)
for (j=0; j < 3; j++)
Mat.v[i].n[j] *= InpAdj;
-
- Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag);
+
+ Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag);
Shapes[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag);
Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag);
Lut = cmsPipelineAlloc(ContextID, 3, 3);
if (Lut != NULL) {
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, Shapes));
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Mat, NULL));
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, Shapes)) ||
+ !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Mat, NULL)))
+ goto Error;
+
+ // Note that it is certainly possible a single profile would have a LUT based
+ // tag for output working in lab and a matrix-shaper for the fallback cases.
+ // This is not allowed by the spec, but this code is tolerant to those cases
+ if (cmsGetPCS(hProfile) == cmsSigLabData) {
+
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocXYZ2Lab(ContextID)))
+ goto Error;
+ }
+
}
return Lut;
+
+Error:
+ cmsPipelineFree(Lut);
+ return NULL;
}
+
+
+// Read the DToAX tag, adjusting the encoding of Lab or XYZ if neded
+static
+cmsPipeline* _cmsReadFloatInputTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat)
+{
+ cmsContext ContextID = cmsGetProfileContextID(hProfile);
+ cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
+ cmsColorSpaceSignature spc = cmsGetColorSpace(hProfile);
+ cmsColorSpaceSignature PCS = cmsGetPCS(hProfile);
+
+ if (Lut == NULL) return NULL;
+
+ // input and output of transform are in lcms 0..1 encoding. If XYZ or Lab spaces are used,
+ // these need to be normalized into the appropriate ranges (Lab = 100,0,0, XYZ=1.0,1.0,1.0)
+ if ( spc == cmsSigLabData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)))
+ goto Error;
+ }
+ else if (spc == cmsSigXYZData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToXyzFloat(ContextID)))
+ goto Error;
+ }
+
+ if ( PCS == cmsSigLabData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)))
+ goto Error;
+ }
+ else if( PCS == cmsSigXYZData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)))
+ goto Error;
+ }
+
+ return Lut;
+
+Error:
+ cmsPipelineFree(Lut);
+ return NULL;
+}
+
+
// Read and create a BRAND NEW MPE LUT from a given profile. All stuff dependent of version, etc
-// is adjusted here in order to create a LUT that takes care of all those details
+// is adjusted here in order to create a LUT that takes care of all those details.
+// We add intent = -1 as a way to read matrix shaper always, no matter of other LUT
cmsPipeline* _cmsReadInputLUT(cmsHPROFILE hProfile, int Intent)
{
cmsTagTypeSignature OriginalType;
cmsTagSignature tagFloat = Device2PCSFloat[Intent];
cmsContext ContextID = cmsGetProfileContextID(hProfile);
- if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
+ // On named color, take the appropiate tag
+ if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
- // Floating point LUT are always V4, so no adjustment is required
- return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
- }
+ cmsPipeline* Lut;
+ cmsNAMEDCOLORLIST* nc = (cmsNAMEDCOLORLIST*) cmsReadTag(hProfile, cmsSigNamedColor2Tag);
+
+ if (nc == NULL) return NULL;
- // Revert to perceptual if no tag is found
- if (!cmsIsTag(hProfile, tag16)) {
- tag16 = Device2PCS16[0];
+ Lut = cmsPipelineAlloc(ContextID, 0, 0);
+ if (Lut == NULL) {
+ cmsFreeNamedColorList(nc);
+ return NULL;
+ }
+
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocNamedColor(nc, TRUE)) ||
+ !cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID))) {
+ cmsPipelineFree(Lut);
+ return NULL;
+ }
+ return Lut;
}
- if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
+ // This is an attempt to reuse this funtion to retrieve the matrix-shaper as pipeline no
+ // matter other LUT are present and have precedence. Intent = -1 means just this.
+ if (Intent != -1) {
- // Check profile version and LUT type. Do the necessary adjustments if needed
+ if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
- // First read the tag
- cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16);
- if (Lut == NULL) return NULL;
+ // Floating point LUT are always V4, but the encoding range is no
+ // longer 0..1.0, so we need to add an stage depending on the color space
+ return _cmsReadFloatInputTag(hProfile, tagFloat);
+ }
- // After reading it, we have now info about the original type
- OriginalType = _cmsGetTagTrueType(hProfile, tag16);
+ // Revert to perceptual if no tag is found
+ if (!cmsIsTag(hProfile, tag16)) {
+ tag16 = Device2PCS16[0];
+ }
- // The profile owns the Lut, so we need to copy it
- Lut = cmsPipelineDup(Lut);
+ if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
- // We need to adjust data only for Lab16 on output
- if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData)
- return Lut;
+ // Check profile version and LUT type. Do the necessary adjustments if needed
- // Add a matrix for conversion V2 to V4 Lab PCS
- cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID));
- return Lut;
- }
+ // First read the tag
+ cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16);
+ if (Lut == NULL) return NULL;
+
+ // After reading it, we have now info about the original type
+ OriginalType = _cmsGetTagTrueType(hProfile, tag16);
+
+ // The profile owns the Lut, so we need to copy it
+ Lut = cmsPipelineDup(Lut);
+
+ // We need to adjust data only for Lab16 on output
+ if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData)
+ return Lut;
+
+ // If the input is Lab, add also a conversion at the begin
+ if (cmsGetColorSpace(hProfile) == cmsSigLabData &&
+ !cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)))
+ goto Error;
+
+ // Add a matrix for conversion V2 to V4 Lab PCS
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)))
+ goto Error;
+
+ return Lut;
+Error:
+ cmsPipelineFree(Lut);
+ return NULL;
+ }
+ }
// Lut was not found, try to create a matrix-shaper
// Check if this is a grayscale profile.
if (cmsGetColorSpace(hProfile) == cmsSigGrayData) {
- // if so, build appropiate conversion tables.
+ // if so, build appropiate conversion tables.
// The tables are the PCS iluminant, scaled across GrayTRC
- return BuildGrayInputMatrixPipeline(hProfile);
+ return BuildGrayInputMatrixPipeline(hProfile);
}
- // Not gray, create a normal matrix-shaper
+ // Not gray, create a normal matrix-shaper
return BuildRGBInputMatrixShaper(hProfile);
}
// ---------------------------------------------------------------------------------------------------------------
-// Gray output pipeline.
+// Gray output pipeline.
// XYZ -> Gray or Lab -> Gray. Since we only know the GrayTRC, we need to do some assumptions. Gray component will be
// given by Y on XYZ PCS and by L* on Lab PCS, Both across inverse TRC curve.
// The complete pipeline on XYZ is Matrix[3:1] -> Tone curve and in Lab Matrix[3:1] -> Tone Curve as well.
cmsPipeline* Lut;
cmsContext ContextID = cmsGetProfileContextID(hProfile);
- GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag);
+ GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag);
if (GrayTRC == NULL) return NULL;
RevGrayTRC = cmsReverseToneCurve(GrayTRC);
if (cmsGetPCS(hProfile) == cmsSigLabData) {
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 1, 3, PickLstarMatrix, NULL));
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 1, 3, PickLstarMatrix, NULL)))
+ goto Error;
}
else {
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 1, 3, PickYMatrix, NULL));
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 1, 3, PickYMatrix, NULL)))
+ goto Error;
}
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &RevGrayTRC));
- cmsFreeToneCurve(RevGrayTRC);
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &RevGrayTRC)))
+ goto Error;
+ cmsFreeToneCurve(RevGrayTRC);
return Lut;
-}
-
+Error:
+ cmsFreeToneCurve(RevGrayTRC);
+ cmsPipelineFree(Lut);
+ return NULL;
+}
static
return NULL;
// XYZ PCS in encoded in 1.15 format, and the matrix input should come in 0..0xffff range, so
- // we need to adjust the input by a << 1 to obtain a 1.16 fixed and then by a factor of
+ // we need to adjust the input by a << 1 to obtain a 1.16 fixed and then by a factor of
// (0xffff/0x10000) to put data in 0..0xffff range. Total factor is (2.0*65535.0)/65536.0;
for (i=0; i < 3; i++)
for (j=0; j < 3; j++)
Inv.v[i].n[j] *= OutpAdj;
- Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag);
+ Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag);
Shapes[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag);
Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag);
InvShapes[1] = cmsReverseToneCurve(Shapes[1]);
InvShapes[2] = cmsReverseToneCurve(Shapes[2]);
- if (!InvShapes[0] || !InvShapes[1] || !InvShapes[2]) {
+ if (!InvShapes[0] || !InvShapes[1] || !InvShapes[2]) {
return NULL;
}
Lut = cmsPipelineAlloc(ContextID, 3, 3);
if (Lut != NULL) {
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Inv, NULL));
- cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, InvShapes));
+ // Note that it is certainly possible a single profile would have a LUT based
+ // tag for output working in lab and a matrix-shaper for the fallback cases.
+ // This is not allowed by the spec, but this code is tolerant to those cases
+ if (cmsGetPCS(hProfile) == cmsSigLabData) {
+
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLab2XYZ(ContextID)))
+ goto Error;
+ }
+
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Inv, NULL)) ||
+ !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, InvShapes)))
+ goto Error;
}
cmsFreeToneCurveTriple(InvShapes);
return Lut;
+Error:
+ cmsFreeToneCurveTriple(InvShapes);
+ cmsPipelineFree(Lut);
+ return NULL;
}
_cmsStageCLutData* CLUT = (_cmsStageCLutData*) Stage ->Data;
CLUT ->Params->dwFlags |= CMS_LERP_FLAGS_TRILINEAR;
- _cmsSetInterpolationRoutine(CLUT ->Params);
+ _cmsSetInterpolationRoutine(Lut->ContextID, CLUT ->Params);
}
}
}
+
+// Read the DToAX tag, adjusting the encoding of Lab or XYZ if neded
+static
+cmsPipeline* _cmsReadFloatOutputTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat)
+{
+ cmsContext ContextID = cmsGetProfileContextID(hProfile);
+ cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
+ cmsColorSpaceSignature PCS = cmsGetPCS(hProfile);
+ cmsColorSpaceSignature dataSpace = cmsGetColorSpace(hProfile);
+
+ if (Lut == NULL) return NULL;
+
+ // If PCS is Lab or XYZ, the floating point tag is accepting data in the space encoding,
+ // and since the formatter has already accomodated to 0..1.0, we should undo this change
+ if ( PCS == cmsSigLabData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)))
+ goto Error;
+ }
+ else
+ if (PCS == cmsSigXYZData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToXyzFloat(ContextID)))
+ goto Error;
+ }
+
+ // the output can be Lab or XYZ, in which case normalisation is needed on the end of the pipeline
+ if ( dataSpace == cmsSigLabData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)))
+ goto Error;
+ }
+ else if (dataSpace == cmsSigXYZData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)))
+ goto Error;
+ }
+
+ return Lut;
+
+Error:
+ cmsPipelineFree(Lut);
+ return NULL;
+}
+
// Create an output MPE LUT from agiven profile. Version mismatches are handled here
cmsPipeline* _cmsReadOutputLUT(cmsHPROFILE hProfile, int Intent)
{
cmsTagSignature tagFloat = PCS2DeviceFloat[Intent];
cmsContext ContextID = cmsGetProfileContextID(hProfile);
- if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
- // Floating point LUT are always V4, so no adjustment is required
- return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
- }
+ if (Intent != -1) {
- // Revert to perceptual if no tag is found
- if (!cmsIsTag(hProfile, tag16)) {
- tag16 = PCS2Device16[0];
- }
+ if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
- if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
+ // Floating point LUT are always V4
+ return _cmsReadFloatOutputTag(hProfile, tagFloat);
+ }
- // Check profile version and LUT type. Do the necessary adjustments if needed
+ // Revert to perceptual if no tag is found
+ if (!cmsIsTag(hProfile, tag16)) {
+ tag16 = PCS2Device16[0];
+ }
- // First read the tag
- cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16);
- if (Lut == NULL) return NULL;
+ if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
- // After reading it, we have info about the original type
- OriginalType = _cmsGetTagTrueType(hProfile, tag16);
+ // Check profile version and LUT type. Do the necessary adjustments if needed
- // The profile owns the Lut, so we need to copy it
- Lut = cmsPipelineDup(Lut);
- if (Lut == NULL) return NULL;
+ // First read the tag
+ cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16);
+ if (Lut == NULL) return NULL;
- // Now it is time for a controversial stuff. I found that for 3D LUTS using
- // Lab used as indexer space, trilinear interpolation should be used
- if (cmsGetPCS(hProfile) == cmsSigLabData)
- ChangeInterpolationToTrilinear(Lut);
+ // After reading it, we have info about the original type
+ OriginalType = _cmsGetTagTrueType(hProfile, tag16);
- // We need to adjust data only for Lab and Lut16 type
- if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData)
- return Lut;
+ // The profile owns the Lut, so we need to copy it
+ Lut = cmsPipelineDup(Lut);
+ if (Lut == NULL) return NULL;
- // Add a matrix for conversion V4 to V2 Lab PCS
- cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID));
- return Lut;
- }
+ // Now it is time for a controversial stuff. I found that for 3D LUTS using
+ // Lab used as indexer space, trilinear interpolation should be used
+ if (cmsGetPCS(hProfile) == cmsSigLabData)
+ ChangeInterpolationToTrilinear(Lut);
+
+ // We need to adjust data only for Lab and Lut16 type
+ if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData)
+ return Lut;
+
+ // Add a matrix for conversion V4 to V2 Lab PCS
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)))
+ goto Error;
+
+ // If the output is Lab, add also a conversion at the end
+ if (cmsGetColorSpace(hProfile) == cmsSigLabData)
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)))
+ goto Error;
+
+ return Lut;
+Error:
+ cmsPipelineFree(Lut);
+ return NULL;
+ }
+ }
// Lut not found, try to create a matrix-shaper
// Check if this is a grayscale profile.
- if (cmsGetColorSpace(hProfile) == cmsSigGrayData) {
+ if (cmsGetColorSpace(hProfile) == cmsSigGrayData) {
- // if so, build appropiate conversion tables.
- // The tables are the PCS iluminant, scaled across GrayTRC
- return BuildGrayOutputPipeline(hProfile);
+ // if so, build appropiate conversion tables.
+ // The tables are the PCS iluminant, scaled across GrayTRC
+ return BuildGrayOutputPipeline(hProfile);
}
- // Not gray, create a normal matrix-shaper
+ // Not gray, create a normal matrix-shaper, which only operates in XYZ space
return BuildRGBOutputMatrixShaper(hProfile);
}
// ---------------------------------------------------------------------------------------------------------------
-// This one includes abstract profiles as well. Matrix-shaper cannot be obtained on that device class. The
+// Read the AToD0 tag, adjusting the encoding of Lab or XYZ if neded
+static
+cmsPipeline* _cmsReadFloatDevicelinkTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat)
+{
+ cmsContext ContextID = cmsGetProfileContextID(hProfile);
+ cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
+ cmsColorSpaceSignature PCS = cmsGetPCS(hProfile);
+ cmsColorSpaceSignature spc = cmsGetColorSpace(hProfile);
+
+ if (Lut == NULL) return NULL;
+
+ if (spc == cmsSigLabData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)))
+ goto Error;
+ }
+ else
+ if (spc == cmsSigXYZData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToXyzFloat(ContextID)))
+ goto Error;
+ }
+
+ if (PCS == cmsSigLabData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)))
+ goto Error;
+ }
+ else
+ if (PCS == cmsSigXYZData)
+ {
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)))
+ goto Error;
+ }
+
+ return Lut;
+Error:
+ cmsPipelineFree(Lut);
+ return NULL;
+}
+
+// This one includes abstract profiles as well. Matrix-shaper cannot be obtained on that device class. The
// tag name here may default to AToB0
cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent)
{
cmsTagSignature tagFloat = Device2PCSFloat[Intent];
cmsContext ContextID = cmsGetProfileContextID(hProfile);
+
+ // On named color, take the appropiate tag
+ if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
+
+ cmsNAMEDCOLORLIST* nc = (cmsNAMEDCOLORLIST*) cmsReadTag(hProfile, cmsSigNamedColor2Tag);
+
+ if (nc == NULL) return NULL;
+
+ Lut = cmsPipelineAlloc(ContextID, 0, 0);
+ if (Lut == NULL)
+ goto Error;
+
+ if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocNamedColor(nc, FALSE)))
+ goto Error;
+
+ if (cmsGetColorSpace(hProfile) == cmsSigLabData)
+ if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)))
+ goto Error;
+
+ return Lut;
+Error:
+ cmsPipelineFree(Lut);
+ cmsFreeNamedColorList(nc);
+ return NULL;
+ }
+
if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
- // Floating point LUT are always V4, no adjustment is required
- return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
+ // Floating point LUT are always V
+ return _cmsReadFloatDevicelinkTag(hProfile, tagFloat);
}
tagFloat = Device2PCSFloat[0];
- if (cmsIsTag(hProfile, tagFloat)) {
-
+ if (cmsIsTag(hProfile, tagFloat)) {
+
return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
}
if (!cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
-
+
tag16 = Device2PCS16[0];
- if (!cmsIsTag(hProfile, tag16)) return NULL;
+ if (!cmsIsTag(hProfile, tag16)) return NULL;
}
// Check profile version and LUT type. Do the necessary adjustments if needed
Lut = cmsPipelineDup(Lut);
if (Lut == NULL) return NULL;
- // Now it is time for a controversial stuff. I found that for 3D LUTS using
- // Lab used as indexer space, trilinear interpolation should be used
- if (cmsGetColorSpace(hProfile) == cmsSigLabData)
- ChangeInterpolationToTrilinear(Lut);
+ // Now it is time for a controversial stuff. I found that for 3D LUTS using
+ // Lab used as indexer space, trilinear interpolation should be used
+ if (cmsGetPCS(hProfile) == cmsSigLabData)
+ ChangeInterpolationToTrilinear(Lut);
// After reading it, we have info about the original type
OriginalType = _cmsGetTagTrueType(hProfile, tag16);
// We need to adjust data for Lab16 on output
if (OriginalType != cmsSigLut16Type) return Lut;
-
+
// Here it is possible to get Lab on both sides
- if (cmsGetPCS(hProfile) == cmsSigLabData) {
- cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID));
+ if (cmsGetColorSpace(hProfile) == cmsSigLabData) {
+ if(!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)))
+ goto Error2;
}
- if (cmsGetColorSpace(hProfile) == cmsSigLabData) {
- cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID));
+ if (cmsGetPCS(hProfile) == cmsSigLabData) {
+ if(!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)))
+ goto Error2;
}
return Lut;
-
+Error2:
+ cmsPipelineFree(Lut);
+ return NULL;
}
// ---------------------------------------------------------------------------------------------------------------
// Returns TRUE if the profile is implemented as matrix-shaper
cmsBool CMSEXPORT cmsIsMatrixShaper(cmsHPROFILE hProfile)
-{
+{
switch (cmsGetColorSpace(hProfile)) {
case cmsSigGrayData:
-
+
return cmsIsTag(hProfile, cmsSigGrayTRCTag);
case cmsSigRgbData:
// Returns TRUE if the intent is implemented as CLUT
cmsBool CMSEXPORT cmsIsCLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number UsedDirection)
-{
+{
const cmsTagSignature* TagTable;
// For devicelinks, the supported intent is that one stated in the header
switch (UsedDirection) {
case LCMS_USED_AS_INPUT: TagTable = Device2PCS16; break;
- case LCMS_USED_AS_OUTPUT:TagTable = PCS2Device16; break;
+ case LCMS_USED_AS_OUTPUT:TagTable = PCS2Device16; break;
// For proofing, we need rel. colorimetric in output. Let's do some recursion
- case LCMS_USED_AS_PROOF:
+ case LCMS_USED_AS_PROOF:
return cmsIsIntentSupported(hProfile, Intent, LCMS_USED_AS_INPUT) &&
cmsIsIntentSupported(hProfile, INTENT_RELATIVE_COLORIMETRIC, LCMS_USED_AS_OUTPUT);
// Read both, profile sequence description and profile sequence id if present. Then combine both to
// create qa unique structure holding both. Shame on ICC to store things in such complicated way.
-
cmsSEQ* _cmsReadProfileSequence(cmsHPROFILE hProfile)
{
cmsSEQ* ProfileSeq;
// Take profile sequence description first
ProfileSeq = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceDescTag);
-
+
// Take profile sequence ID
ProfileId = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceIdTag);
if (ProfileSeq == NULL) return cmsDupProfileSequenceDescription(ProfileId);
if (ProfileId == NULL) return cmsDupProfileSequenceDescription(ProfileSeq);
- // We have to mix both together. For that they must agree
+ // We have to mix both together. For that they must agree
if (ProfileSeq ->n != ProfileId ->n) return cmsDupProfileSequenceDescription(ProfileSeq);
NewSeq = cmsDupProfileSequenceDescription(ProfileSeq);
-
+
// Ok, proceed to the mixing
- for (i=0; i < ProfileSeq ->n; i++) {
-
- memmove(&NewSeq ->seq[i].ProfileID, &ProfileId ->seq[i].ProfileID, sizeof(cmsProfileID));
- NewSeq ->seq[i].Description = cmsMLUdup(ProfileId ->seq[i].Description);
- }
+ if (NewSeq != NULL) {
+ for (i=0; i < ProfileSeq ->n; i++) {
+ memmove(&NewSeq ->seq[i].ProfileID, &ProfileId ->seq[i].ProfileID, sizeof(cmsProfileID));
+ NewSeq ->seq[i].Description = cmsMLUdup(ProfileId ->seq[i].Description);
+ }
+ }
return NewSeq;
}
cmsPSEQDESC* ps = &seq ->seq[i];
cmsHPROFILE h = hProfiles[i];
cmsTechnologySignature* techpt;
-
+
cmsGetHeaderAttributes(h, &ps ->attributes);
- cmsGetHeaderProfileID(h, ps ->ProfileID.ID8);
+ cmsGetHeaderProfileID(h, ps ->ProfileID.ID8);
ps ->deviceMfg = cmsGetHeaderManufacturer(h);
ps ->deviceModel = cmsGetHeaderModel(h);
-
+
techpt = (cmsTechnologySignature*) cmsReadTag(h, cmsSigTechnologyTag);
if (techpt == NULL)
ps ->technology = (cmsTechnologySignature) 0;
else
ps ->technology = *techpt;
-
+
ps ->Manufacturer = GetMLUFromProfile(h, cmsSigDeviceMfgDescTag);
- ps ->Model = GetMLUFromProfile(h, cmsSigDeviceModelDescTag);
+ ps ->Model = GetMLUFromProfile(h, cmsSigDeviceModelDescTag);
ps ->Description = GetMLUFromProfile(h, cmsSigProfileDescriptionTag);
-
+
}
return seq;
switch (Info) {
case cmsInfoDescription:
- sig = cmsSigProfileDescriptionTag;
+ sig = cmsSigProfileDescriptionTag;
break;
case cmsInfoManufacturer:
-cmsUInt32Number CMSEXPORT cmsGetProfileInfo(cmsHPROFILE hProfile, cmsInfoType Info,
- const char LanguageCode[3], const char CountryCode[3],
+cmsUInt32Number CMSEXPORT cmsGetProfileInfo(cmsHPROFILE hProfile, cmsInfoType Info,
+ const char LanguageCode[3], const char CountryCode[3],
wchar_t* Buffer, cmsUInt32Number BufferSize)
{
const cmsMLU* mlu = GetInfo(hProfile, Info);
}
-cmsUInt32Number CMSEXPORT cmsGetProfileInfoASCII(cmsHPROFILE hProfile, cmsInfoType Info,
- const char LanguageCode[3], const char CountryCode[3],
+cmsUInt32Number CMSEXPORT cmsGetProfileInfoASCII(cmsHPROFILE hProfile, cmsInfoType Info,
+ const char LanguageCode[3], const char CountryCode[3],
char* Buffer, cmsUInt32Number BufferSize)
{
const cmsMLU* mlu = GetInfo(hProfile, Info);
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// Allocates an empty multi profile element
-cmsStage* CMSEXPORT _cmsStageAllocPlaceholder(cmsContext ContextID,
+cmsStage* CMSEXPORT _cmsStageAllocPlaceholder(cmsContext ContextID,
cmsStageSignature Type,
- cmsUInt32Number InputChannels,
+ cmsUInt32Number InputChannels,
cmsUInt32Number OutputChannels,
- _cmsStageEvalFn EvalPtr,
- _cmsStageDupElemFn DupElemPtr,
- _cmsStageFreeElemFn FreePtr,
- void* Data)
+ _cmsStageEvalFn EvalPtr,
+ _cmsStageDupElemFn DupElemPtr,
+ _cmsStageFreeElemFn FreePtr,
+ void* Data)
{
cmsStage* ph = (cmsStage*) _cmsMallocZero(ContextID, sizeof(cmsStage));
if (ph == NULL) return NULL;
-
-
+
+
ph ->ContextID = ContextID;
ph ->Type = Type;
ph ->InputChannels = InputChannels;
ph ->OutputChannels = OutputChannels;
- ph ->EvalPtr = EvalPtr;
- ph ->DupElemPtr = DupElemPtr;
- ph ->FreePtr = FreePtr;
+ ph ->EvalPtr = EvalPtr;
+ ph ->DupElemPtr = DupElemPtr;
+ ph ->FreePtr = FreePtr;
ph ->Data = Data;
- return ph;
+ return ph;
}
static
-void EvaluateIdentity(const cmsFloat32Number In[],
- cmsFloat32Number Out[],
+void EvaluateIdentity(const cmsFloat32Number In[],
+ cmsFloat32Number Out[],
const cmsStage *mpe)
{
memmove(Out, In, mpe ->InputChannels * sizeof(cmsFloat32Number));
cmsStage* CMSEXPORT cmsStageAllocIdentity(cmsContext ContextID, cmsUInt32Number nChannels)
{
- return _cmsStageAllocPlaceholder(ContextID,
- cmsSigIdentityElemType,
+ return _cmsStageAllocPlaceholder(ContextID,
+ cmsSigIdentityElemType,
nChannels, nChannels,
- EvaluateIdentity,
+ EvaluateIdentity,
NULL,
NULL,
NULL);
{
cmsUInt32Number i;
- for (i=0; i < n; i++) {
- Out[i] = _cmsQuickSaturateWord(In[i] * 65535.0);
+ for (i=0; i < n; i++) {
+ Out[i] = _cmsQuickSaturateWord(In[i] * 65535.0);
}
}
// that conform the LUT. It should be called with the LUT, the number of expected elements and
// then a list of expected types followed with a list of cmsFloat64Number pointers to MPE elements. If
// the function founds a match with current pipeline, it fills the pointers and returns TRUE
-// if not, returns FALSE without touching anything. Setting pointers to NULL does bypass
+// if not, returns FALSE without touching anything. Setting pointers to NULL does bypass
// the storage process.
cmsBool CMSEXPORT cmsPipelineCheckAndRetreiveStages(const cmsPipeline* Lut, cmsUInt32Number n, ...)
{
for (i=0; i < n; i++) {
// Get asked type
- Type = va_arg(args, cmsStageSignature);
+ Type = (cmsStageSignature)va_arg(args, cmsStageSignature);
if (mpe ->Type != Type) {
va_end(args); // Mismatch. We are done.
- return FALSE;
+ return FALSE;
}
mpe = mpe ->Next;
}
mpe = Lut ->Elements;
for (i=0; i < n; i++) {
- ElemPtr = va_arg(args, void**);
- if (ElemPtr != NULL)
+ ElemPtr = va_arg(args, void**);
+ if (ElemPtr != NULL)
*ElemPtr = mpe;
mpe = mpe ->Next;
}
- va_end(args);
+ va_end(args);
return TRUE;
}
}
static
-void EvaluateCurves(const cmsFloat32Number In[],
- cmsFloat32Number Out[],
+void EvaluateCurves(const cmsFloat32Number In[],
+ cmsFloat32Number Out[],
const cmsStage *mpe)
{
_cmsStageToneCurvesData* Data;
if (Data ->TheCurves != NULL) {
for (i=0; i < Data ->nCurves; i++) {
- if (Data ->TheCurves[i] != NULL)
+ if (Data ->TheCurves[i] != NULL)
cmsFreeToneCurve(Data ->TheCurves[i]);
}
}
Error:
- if (NewElem ->TheCurves != NULL) {
+ if (NewElem ->TheCurves != NULL) {
for (i=0; i < NewElem ->nCurves; i++) {
if (NewElem ->TheCurves[i])
- cmsFreeToneCurve(Data ->TheCurves[i]);
+ cmsFreeToneCurve(NewElem ->TheCurves[i]);
}
}
- _cmsFree(mpe ->ContextID, Data ->TheCurves);
+ _cmsFree(mpe ->ContextID, NewElem ->TheCurves);
_cmsFree(mpe ->ContextID, NewElem);
return NULL;
}
cmsUInt32Number i;
_cmsStageToneCurvesData* NewElem;
cmsStage* NewMPE;
-
-
+
+
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCurveSetElemType, nChannels, nChannels,
EvaluateCurves, CurveSetDup, CurveSetElemTypeFree, NULL );
if (NewMPE == NULL) return NULL;
- NewElem = (_cmsStageToneCurvesData*) _cmsMalloc(ContextID, sizeof(_cmsStageToneCurvesData));
+ NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(ContextID, sizeof(_cmsStageToneCurvesData));
if (NewElem == NULL) {
- cmsStageFree(NewMPE);
+ cmsStageFree(NewMPE);
return NULL;
}
NewElem ->nCurves = nChannels;
NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(ContextID, nChannels, sizeof(cmsToneCurve*));
if (NewElem ->TheCurves == NULL) {
- cmsStageFree(NewMPE);
+ cmsStageFree(NewMPE);
return NULL;
}
}
if (NewElem ->TheCurves[i] == NULL) {
- cmsStageFree(NewMPE);
+ cmsStageFree(NewMPE);
return NULL;
}
+
}
- return NewMPE;
+ return NewMPE;
}
cmsStage* _cmsStageAllocIdentityCurves(cmsContext ContextID, int nChannels)
{
cmsStage* mpe = cmsStageAllocToneCurves(ContextID, nChannels, NULL);
-
+
if (mpe == NULL) return NULL;
mpe ->Implements = cmsSigIdentityElemType;
return mpe;
// Special care should be taken here because precision loss. A temporary cmsFloat64Number buffer is being used
static
-void EvaluateMatrix(const cmsFloat32Number In[],
- cmsFloat32Number Out[],
+void EvaluateMatrix(const cmsFloat32Number In[],
+ cmsFloat32Number Out[],
const cmsStage *mpe)
{
cmsUInt32Number i, j;
Tmp += In[j] * Data->Double[i*mpe->InputChannels + j];
}
- if (Data ->Offset != NULL)
+ if (Data ->Offset != NULL)
Tmp += Data->Offset[i];
- Out[i] = (cmsFloat32Number) Tmp;
+ Out[i] = (cmsFloat32Number) Tmp;
}
_cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
_cmsStageMatrixData* NewElem;
cmsUInt32Number sz;
-
+
NewElem = (_cmsStageMatrixData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageMatrixData));
if (NewElem == NULL) return NULL;
NewElem ->Double = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID, Data ->Double, sz * sizeof(cmsFloat64Number)) ;
if (Data ->Offset)
- NewElem ->Offset = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID,
+ NewElem ->Offset = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID,
Data ->Offset, mpe -> OutputChannels * sizeof(cmsFloat64Number)) ;
return (void*) NewElem;
void MatrixElemTypeFree(cmsStage* mpe)
{
_cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
+ if (Data == NULL)
+ return;
if (Data ->Double)
_cmsFree(mpe ->ContextID, Data ->Double);
-cmsStage* CMSEXPORT cmsStageAllocMatrix(cmsContext ContextID, cmsUInt32Number Rows, cmsUInt32Number Cols,
+cmsStage* CMSEXPORT cmsStageAllocMatrix(cmsContext ContextID, cmsUInt32Number Rows, cmsUInt32Number Cols,
const cmsFloat64Number* Matrix, const cmsFloat64Number* Offset)
{
cmsUInt32Number i, n;
EvaluateMatrix, MatrixElemDup, MatrixElemTypeFree, NULL );
if (NewMPE == NULL) return NULL;
-
+
NewElem = (_cmsStageMatrixData*) _cmsMallocZero(ContextID, sizeof(_cmsStageMatrixData));
if (NewElem == NULL) return NULL;
-
+
NewElem ->Double = (cmsFloat64Number*) _cmsCalloc(ContextID, n, sizeof(cmsFloat64Number));
if (Offset != NULL) {
-
+
NewElem ->Offset = (cmsFloat64Number*) _cmsCalloc(ContextID, Cols, sizeof(cmsFloat64Number));
if (NewElem->Offset == NULL) {
MatrixElemTypeFree(NewMPE);
}
}
-
+
NewMPE ->Data = (void*) NewElem;
return NewMPE;
}
static
void EvaluateCLUTfloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{
- _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
+ _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
Data -> Params ->Interpolation.LerpFloat(In, Out, Data->Params);
}
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
cmsUInt16Number In16[MAX_STAGE_CHANNELS], Out16[MAX_STAGE_CHANNELS];
-
+
_cmsAssert(mpe ->InputChannels <= MAX_STAGE_CHANNELS);
_cmsAssert(mpe ->OutputChannels <= MAX_STAGE_CHANNELS);
- FromFloatTo16(In, In16, mpe ->InputChannels);
+ FromFloatTo16(In, In16, mpe ->InputChannels);
Data -> Params ->Interpolation.Lerp16(In16, Out16, Data->Params);
From16ToFloat(Out16, Out, mpe ->OutputChannels);
}
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
_cmsStageCLutData* NewElem;
-
-
+
+
NewElem = (_cmsStageCLutData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageCLutData));
if (NewElem == NULL) return NULL;
if (Data ->Tab.T) {
- if (Data ->HasFloatValues)
+ if (Data ->HasFloatValues) {
NewElem ->Tab.TFloat = (cmsFloat32Number*) _cmsDupMem(mpe ->ContextID, Data ->Tab.TFloat, Data ->nEntries * sizeof (cmsFloat32Number));
- else
+ if (NewElem ->Tab.TFloat == NULL)
+ goto Error;
+ } else {
NewElem ->Tab.T = (cmsUInt16Number*) _cmsDupMem(mpe ->ContextID, Data ->Tab.T, Data ->nEntries * sizeof (cmsUInt16Number));
+ if (NewElem ->Tab.TFloat == NULL)
+ goto Error;
+ }
}
-
+
NewElem ->Params = _cmsComputeInterpParamsEx(mpe ->ContextID,
- Data ->Params ->nSamples,
+ Data ->Params ->nSamples,
Data ->Params ->nInputs,
- Data ->Params ->nOutputs,
+ Data ->Params ->nOutputs,
NewElem ->Tab.T,
Data ->Params ->dwFlags);
-
- return (void*) NewElem;
+ if (NewElem->Params != NULL)
+ return (void*) NewElem;
+ Error:
+ if (NewElem->Tab.T)
+ // This works for both types
+ _cmsFree(mpe ->ContextID, NewElem -> Tab.T);
+ _cmsFree(mpe ->ContextID, NewElem);
+ return NULL;
}
{
_cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
-
+
// Already empty
if (Data == NULL) return;
if (Data -> Tab.T)
_cmsFree(mpe ->ContextID, Data -> Tab.T);
- _cmsFreeInterpParams(Data ->Params);
+ _cmsFreeInterpParams(Data ->Params);
_cmsFree(mpe ->ContextID, mpe ->Data);
}
// Allocates a 16-bit multidimensional CLUT. This is evaluated at 16-bit precision. Table may have different
// granularity on each dimension.
-cmsStage* CMSEXPORT cmsStageAllocCLut16bitGranular(cmsContext ContextID,
- const cmsUInt32Number clutPoints[],
- cmsUInt32Number inputChan,
- cmsUInt32Number outputChan,
+cmsStage* CMSEXPORT cmsStageAllocCLut16bitGranular(cmsContext ContextID,
+ const cmsUInt32Number clutPoints[],
+ cmsUInt32Number inputChan,
+ cmsUInt32Number outputChan,
const cmsUInt16Number* Table)
{
cmsUInt32Number i, n;
_cmsStageCLutData* NewElem;
cmsStage* NewMPE;
-
+
+ _cmsAssert(clutPoints != NULL);
+
+ if (inputChan > MAX_INPUT_DIMENSIONS) {
+ cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", inputChan, MAX_INPUT_DIMENSIONS);
+ return NULL;
+ }
+
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCLutElemType, inputChan, outputChan,
EvaluateCLUTfloatIn16, CLUTElemDup, CLutElemTypeFree, NULL );
if (NewMPE == NULL) return NULL;
- NewElem = (_cmsStageCLutData*) _cmsMalloc(ContextID, sizeof(_cmsStageCLutData));
+ NewElem = (_cmsStageCLutData*) _cmsMallocZero(ContextID, sizeof(_cmsStageCLutData));
if (NewElem == NULL) {
cmsStageFree(NewMPE);
return NULL;
return NewMPE;
}
-cmsStage* CMSEXPORT cmsStageAllocCLut16bit(cmsContext ContextID,
- cmsUInt32Number nGridPoints,
- cmsUInt32Number inputChan,
- cmsUInt32Number outputChan,
+cmsStage* CMSEXPORT cmsStageAllocCLut16bit(cmsContext ContextID,
+ cmsUInt32Number nGridPoints,
+ cmsUInt32Number inputChan,
+ cmsUInt32Number outputChan,
const cmsUInt16Number* Table)
{
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
Dimensions[i] = nGridPoints;
-
return cmsStageAllocCLut16bitGranular(ContextID, Dimensions, inputChan, outputChan, Table);
}
-cmsStage* CMSEXPORT cmsStageAllocCLutFloat(cmsContext ContextID,
- cmsUInt32Number nGridPoints,
- cmsUInt32Number inputChan,
- cmsUInt32Number outputChan,
+cmsStage* CMSEXPORT cmsStageAllocCLutFloat(cmsContext ContextID,
+ cmsUInt32Number nGridPoints,
+ cmsUInt32Number inputChan,
+ cmsUInt32Number outputChan,
const cmsFloat32Number* Table)
{
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
cmsUInt32Number i, n;
_cmsStageCLutData* NewElem;
cmsStage* NewMPE;
-
+
_cmsAssert(clutPoints != NULL);
+ if (inputChan > MAX_INPUT_DIMENSIONS) {
+ cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", inputChan, MAX_INPUT_DIMENSIONS);
+ return NULL;
+ }
+
NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCLutElemType, inputChan, outputChan,
EvaluateCLUTfloat, CLUTElemDup, CLutElemTypeFree, NULL);
if (NewMPE == NULL) return NULL;
-
- NewElem = (_cmsStageCLutData*) _cmsMalloc(ContextID, sizeof(_cmsStageCLutData));
+
+ NewElem = (_cmsStageCLutData*) _cmsMallocZero(ContextID, sizeof(_cmsStageCLutData));
if (NewElem == NULL) {
cmsStageFree(NewMPE);
return NULL;
NewMPE ->Data = (void*) NewElem;
// There is a potential integer overflow on conputing n and nEntries.
- NewElem -> nEntries = n = outputChan * CubeSize( clutPoints, inputChan);
+ NewElem -> nEntries = n = outputChan * CubeSize(clutPoints, inputChan);
NewElem -> HasFloatValues = TRUE;
if (n == 0) {
}
}
-
-
NewElem ->Params = _cmsComputeInterpParamsEx(ContextID, clutPoints, inputChan, outputChan, NewElem ->Tab.TFloat, CMS_LERP_FLAGS_FLOAT);
if (NewElem ->Params == NULL) {
cmsStageFree(NewMPE);
return NULL;
}
-
-
return NewMPE;
}
int nChan = *(int*) Cargo;
int i;
- for (i=0; i < nChan; i++)
+ for (i=0; i < nChan; i++)
Out[i] = In[i];
return 1;
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
cmsStage* mpe ;
int i;
-
+
for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
Dimensions[i] = 2;
mpe = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, nChan, nChan, NULL);
if (mpe == NULL) return NULL;
-
+
if (!cmsStageSampleCLut16bit(mpe, IdentitySampler, &nChan, 0)) {
cmsStageFree(mpe);
return NULL;
cmsBool CMSEXPORT cmsStageSampleCLut16bit(cmsStage* mpe, cmsSAMPLER16 Sampler, void * Cargo, cmsUInt32Number dwFlags)
{
int i, t, nTotalPoints, index, rest;
- int nInputs, nOutputs;
+ int nInputs, nOutputs;
cmsUInt32Number* nSamples;
- cmsUInt16Number In[cmsMAXCHANNELS], Out[MAX_STAGE_CHANNELS];
- _cmsStageCLutData* clut = (_cmsStageCLutData*) mpe->Data;
+ cmsUInt16Number In[MAX_INPUT_DIMENSIONS+1], Out[MAX_STAGE_CHANNELS];
+ _cmsStageCLutData* clut;
+
+ if (mpe == NULL) return FALSE;
+
+ clut = (_cmsStageCLutData*) mpe->Data;
+ if (clut == NULL) return FALSE;
nSamples = clut->Params ->nSamples;
nInputs = clut->Params ->nInputs;
nOutputs = clut->Params ->nOutputs;
- if (nInputs >= cmsMAXCHANNELS) return FALSE;
+ if (nInputs <= 0) return FALSE;
+ if (nOutputs <= 0) return FALSE;
+ if (nInputs > MAX_INPUT_DIMENSIONS) return FALSE;
if (nOutputs >= MAX_STAGE_CHANNELS) return FALSE;
nTotalPoints = CubeSize(nSamples, nInputs);
rest /= nSamples[t];
- In[t] = _cmsQuantizeVal(Colorant, nSamples[t]);
+ In[t] = _cmsQuantizeVal(Colorant, nSamples[t]);
}
if (clut ->Tab.T != NULL) {
int i, t, nTotalPoints, index, rest;
int nInputs, nOutputs;
cmsUInt32Number* nSamples;
- cmsFloat32Number In[cmsMAXCHANNELS], Out[MAX_STAGE_CHANNELS];
- _cmsStageCLutData* clut = (_cmsStageCLutData*) mpe->Data;
+ cmsFloat32Number In[MAX_INPUT_DIMENSIONS+1], Out[MAX_STAGE_CHANNELS];
+ _cmsStageCLutData* clut = (_cmsStageCLutData*) mpe->Data;
nSamples = clut->Params ->nSamples;
nInputs = clut->Params ->nInputs;
nOutputs = clut->Params ->nOutputs;
- if (nInputs >= cmsMAXCHANNELS) return FALSE;
+ if (nInputs <= 0) return FALSE;
+ if (nOutputs <= 0) return FALSE;
+ if (nInputs > MAX_INPUT_DIMENSIONS) return FALSE;
if (nOutputs >= MAX_STAGE_CHANNELS) return FALSE;
nTotalPoints = CubeSize(nSamples, nInputs);
rest = i;
for (t = nInputs-1; t >=0; --t) {
-
+
cmsUInt32Number Colorant = rest % nSamples[t];
rest /= nSamples[t];
- In[t] = (cmsFloat32Number) (_cmsQuantizeVal(Colorant, nSamples[t]) / 65535.0);
+ In[t] = (cmsFloat32Number) (_cmsQuantizeVal(Colorant, nSamples[t]) / 65535.0);
}
if (clut ->Tab.TFloat != NULL) {
cmsUInt32Number Colorant = rest % clutPoints[t];
rest /= clutPoints[t];
- In[t] = _cmsQuantizeVal(Colorant, clutPoints[t]);
+ In[t] = _cmsQuantizeVal(Colorant, clutPoints[t]);
}
cmsUInt32Number Colorant = rest % clutPoints[t];
rest /= clutPoints[t];
- In[t] = (cmsFloat32Number) (_cmsQuantizeVal(Colorant, clutPoints[t]) / 65535.0);
+ In[t] = (cmsFloat32Number) (_cmsQuantizeVal(Colorant, clutPoints[t]) / 65535.0);
}
static
-void EvaluateLab2XYZ(const cmsFloat32Number In[],
- cmsFloat32Number Out[],
+void EvaluateLab2XYZ(const cmsFloat32Number In[],
+ cmsFloat32Number Out[],
const cmsStage *mpe)
{
cmsCIELab Lab;
const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
// V4 rules
- Lab.L = In[0] * 100.0;
+ Lab.L = In[0] * 100.0;
Lab.a = In[1] * 255.0 - 128.0;
Lab.b = In[2] * 255.0 - 128.0;
cmsLab2XYZ(NULL, &XYZ, &Lab);
- // From XYZ, range 0..19997 to 0..1.0, note that 1.99997 comes from 0xffff
+ // From XYZ, range 0..19997 to 0..1.0, note that 1.99997 comes from 0xffff
// encoded as 1.15 fixed point, so 1 + (32767.0 / 32768.0)
- Out[0] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.X / XYZadj);
- Out[1] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Y / XYZadj);
- Out[2] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Z / XYZadj);
+ Out[0] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.X / XYZadj);
+ Out[1] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Y / XYZadj);
+ Out[2] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Z / XYZadj);
return;
cmsUNUSED_PARAMETER(mpe);
// ********************************************************************************
-// v2 L=100 is supposed to be placed on 0xFF00. There is no reasonable
+// v2 L=100 is supposed to be placed on 0xFF00. There is no reasonable
// number of gridpoints that would make exact match. However, a prelinearization
-// of 258 entries, would map 0xFF00 exactly on entry 257, and this is good to avoid scum dot.
+// of 258 entries, would map 0xFF00 exactly on entry 257, and this is good to avoid scum dot.
// Almost all what we need but unfortunately, the rest of entries should be scaled by
// (255*257/256) and this is not exact.
LabTable[2] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
for (j=0; j < 3; j++) {
-
+
if (LabTable[j] == NULL) {
cmsFreeToneCurveTriple(LabTable);
return NULL;
}
-
- // We need to map * (0xffff / 0xff00), thats same as (257 / 256)
+
+ // We need to map * (0xffff / 0xff00), thats same as (257 / 256)
// So we can use 258-entry tables to do the trick (i / 257) * (255 * 257) * (257 / 256);
for (i=0; i < 257; i++) {
mpe = cmsStageAllocToneCurves(ContextID, 3, LabTable);
cmsFreeToneCurveTriple(LabTable);
+ if (mpe == NULL) return NULL;
mpe ->Implements = cmsSigLabV2toV4;
return mpe;
}
cmsStage* _cmsStageAllocLabV2ToV4(cmsContext ContextID)
{
static const cmsFloat64Number V2ToV4[] = { 65535.0/65280.0, 0, 0,
- 0, 65535.0/65280.0, 0,
- 0, 0, 65535.0/65280.0
+ 0, 65535.0/65280.0, 0,
+ 0, 0, 65535.0/65280.0
};
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, V2ToV4, NULL);
cmsStage* _cmsStageAllocLabV4ToV2(cmsContext ContextID)
{
static const cmsFloat64Number V4ToV2[] = { 65280.0/65535.0, 0, 0,
- 0, 65280.0/65535.0, 0,
- 0, 0, 65280.0/65535.0
+ 0, 65280.0/65535.0, 0,
+ 0, 0, 65280.0/65535.0
};
cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, V4ToV2, NULL);
}
+// To Lab to float. Note that the MPE gives numbers in normal Lab range
+// and we need 0..1.0 range for the formatters
+// L* : 0...100 => 0...1.0 (L* / 100)
+// ab* : -128..+127 to 0..1 ((ab* + 128) / 255)
+
+cmsStage* _cmsStageNormalizeFromLabFloat(cmsContext ContextID)
+{
+ static const cmsFloat64Number a1[] = {
+ 1.0/100.0, 0, 0,
+ 0, 1.0/255.0, 0,
+ 0, 0, 1.0/255.0
+ };
+
+ static const cmsFloat64Number o1[] = {
+ 0,
+ 128.0/255.0,
+ 128.0/255.0
+ };
+
+ cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, o1);
+
+ if (mpe == NULL) return mpe;
+ mpe ->Implements = cmsSigLab2FloatPCS;
+ return mpe;
+}
+
+// Fom XYZ to floating point PCS
+cmsStage* _cmsStageNormalizeFromXyzFloat(cmsContext ContextID)
+{
+#define n (32768.0/65535.0)
+ static const cmsFloat64Number a1[] = {
+ n, 0, 0,
+ 0, n, 0,
+ 0, 0, n
+ };
+#undef n
+
+ cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, NULL);
+
+ if (mpe == NULL) return mpe;
+ mpe ->Implements = cmsSigXYZ2FloatPCS;
+ return mpe;
+}
+
+cmsStage* _cmsStageNormalizeToLabFloat(cmsContext ContextID)
+{
+ static const cmsFloat64Number a1[] = {
+ 100.0, 0, 0,
+ 0, 255.0, 0,
+ 0, 0, 255.0
+ };
+
+ static const cmsFloat64Number o1[] = {
+ 0,
+ -128.0,
+ -128.0
+ };
+
+ cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, o1);
+ if (mpe == NULL) return mpe;
+ mpe ->Implements = cmsSigFloatPCS2Lab;
+ return mpe;
+}
+
+cmsStage* _cmsStageNormalizeToXyzFloat(cmsContext ContextID)
+{
+#define n (65535.0/32768.0)
+
+ static const cmsFloat64Number a1[] = {
+ n, 0, 0,
+ 0, n, 0,
+ 0, 0, n
+ };
+#undef n
+
+ cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, NULL);
+ if (mpe == NULL) return mpe;
+ mpe ->Implements = cmsSigFloatPCS2XYZ;
+ return mpe;
+}
+
+
+
// ********************************************************************************
// Type cmsSigXYZ2LabElemType
// ********************************************************************************
{
cmsCIELab Lab;
cmsCIEXYZ XYZ;
- const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
+ const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
// From 0..1.0 to XYZ
- XYZ.X = In[0] * XYZadj;
- XYZ.Y = In[1] * XYZadj;
+ XYZ.X = In[0] * XYZadj;
+ XYZ.Y = In[1] * XYZadj;
XYZ.Z = In[2] * XYZadj;
cmsXYZ2Lab(NULL, &Lab, &XYZ);
-
+
// From V4 Lab to 0..1.0
- Out[0] = (cmsFloat32Number) (Lab.L / 100.0);
- Out[1] = (cmsFloat32Number) ((Lab.a + 128.0) / 255.0);
+ Out[0] = (cmsFloat32Number) (Lab.L / 100.0);
+ Out[1] = (cmsFloat32Number) ((Lab.a + 128.0) / 255.0);
Out[2] = (cmsFloat32Number) ((Lab.b + 128.0) / 255.0);
return;
}
cmsStage* _cmsStageAllocXYZ2Lab(cmsContext ContextID)
-{
+{
return _cmsStageAllocPlaceholder(ContextID, cmsSigXYZ2LabElemType, 3, 3, EvaluateXYZ2Lab, NULL, NULL, NULL);
-
+
}
// ********************************************************************************
}
-// Free a single MPE
+// Free a single MPE
void CMSEXPORT cmsStageFree(cmsStage* mpe)
{
- if (mpe ->FreePtr)
+ if (mpe ->FreePtr)
mpe ->FreePtr(mpe);
_cmsFree(mpe ->ContextID, mpe);
cmsStage* CMSEXPORT cmsStageDup(cmsStage* mpe)
{
cmsStage* NewMPE;
-
+
if (mpe == NULL) return NULL;
- NewMPE = _cmsStageAllocPlaceholder(mpe ->ContextID,
- mpe ->Type,
- mpe ->InputChannels,
+ NewMPE = _cmsStageAllocPlaceholder(mpe ->ContextID,
+ mpe ->Type,
+ mpe ->InputChannels,
mpe ->OutputChannels,
mpe ->EvalPtr,
mpe ->DupElemPtr,
mpe ->FreePtr,
NULL);
if (NewMPE == NULL) return NULL;
-
- NewMPE ->Implements = mpe ->Implements;
-
- if (mpe ->DupElemPtr)
- NewMPE ->Data = mpe ->DupElemPtr(mpe);
- else
+
+ NewMPE ->Implements = mpe ->Implements;
+
+ if (mpe ->DupElemPtr) {
+
+ NewMPE ->Data = mpe ->DupElemPtr(mpe);
+
+ if (NewMPE->Data == NULL) {
+
+ cmsStageFree(NewMPE);
+ return NULL;
+ }
+
+ } else {
+
NewMPE ->Data = NULL;
+ }
return NewMPE;
}
static
void BlessLUT(cmsPipeline* lut)
{
- // We can set the input/ouput channels only if we have elements.
+ // We can set the input/ouput channels only if we have elements.
if (lut ->Elements != NULL) {
cmsStage *First, *Last;
}
-// Default to evaluate the LUT on 16 bit-basis. Precision is retained.
+// Default to evaluate the LUT on 16 bit-basis. Precision is retained.
static
void _LUTeval16(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register const void* D)
{
cmsPipeline* lut = (cmsPipeline*) D;
- cmsStage *mpe;
+ cmsStage *mpe;
cmsFloat32Number Storage[2][MAX_STAGE_CHANNELS];
int Phase = 0, NextPhase;
-
+
From16ToFloat(In, &Storage[Phase][0], lut ->InputChannels);
- for (mpe = lut ->Elements;
- mpe != NULL;
+ for (mpe = lut ->Elements;
+ mpe != NULL;
mpe = mpe ->Next) {
- NextPhase = Phase ^ 1;
+ NextPhase = Phase ^ 1;
mpe ->EvalPtr(&Storage[Phase][0], &Storage[NextPhase][0], mpe);
Phase = NextPhase;
}
-
+
FromFloatTo16(&Storage[Phase][0], Out, lut ->OutputChannels);
}
-// Does evaluate the LUT on cmsFloat32Number-basis.
+// Does evaluate the LUT on cmsFloat32Number-basis.
static
void _LUTevalFloat(register const cmsFloat32Number In[], register cmsFloat32Number Out[], const void* D)
{
cmsPipeline* lut = (cmsPipeline*) D;
- cmsStage *mpe;
+ cmsStage *mpe;
cmsFloat32Number Storage[2][MAX_STAGE_CHANNELS];
int Phase = 0, NextPhase;
-
+
memmove(&Storage[Phase][0], In, lut ->InputChannels * sizeof(cmsFloat32Number));
- for (mpe = lut ->Elements;
- mpe != NULL;
+ for (mpe = lut ->Elements;
+ mpe != NULL;
mpe = mpe ->Next) {
NextPhase = Phase ^ 1;
mpe ->EvalPtr(&Storage[Phase][0], &Storage[NextPhase][0], mpe);
- Phase = NextPhase;
+ Phase = NextPhase;
}
memmove(Out, &Storage[Phase][0], lut ->OutputChannels * sizeof(cmsFloat32Number));
NewLUT ->EvalFloatFn = _LUTevalFloat;
NewLUT ->DupDataFn = NULL;
NewLUT ->FreeDataFn = NULL;
- NewLUT ->Data = NewLUT;
+ NewLUT ->Data = NewLUT;
NewLUT ->ContextID = ContextID;
BlessLUT(NewLUT);
return NewLUT;
}
+cmsContext CMSEXPORT cmsGetPipelineContextID(const cmsPipeline* lut)
+{
+ _cmsAssert(lut != NULL);
+ return lut ->ContextID;
+}
cmsUInt32Number CMSEXPORT cmsPipelineInputChannels(const cmsPipeline* lut)
{
+ _cmsAssert(lut != NULL);
return lut ->InputChannels;
}
cmsUInt32Number CMSEXPORT cmsPipelineOutputChannels(const cmsPipeline* lut)
{
+ _cmsAssert(lut != NULL);
return lut ->OutputChannels;
}
// Free a profile elements LUT
void CMSEXPORT cmsPipelineFree(cmsPipeline* lut)
{
- cmsStage *mpe, *Next;
+ cmsStage *mpe, *Next;
if (lut == NULL) return;
- for (mpe = lut ->Elements;
- mpe != NULL;
+ for (mpe = lut ->Elements;
+ mpe != NULL;
mpe = Next) {
Next = mpe ->Next;
- cmsStageFree(mpe);
+ cmsStageFree(mpe);
}
if (lut ->FreeDataFn) lut ->FreeDataFn(lut ->ContextID, lut ->Data);
}
-// Default to evaluate the LUT on 16 bit-basis.
+// Default to evaluate the LUT on 16 bit-basis.
void CMSEXPORT cmsPipelineEval16(const cmsUInt16Number In[], cmsUInt16Number Out[], const cmsPipeline* lut)
{
+ _cmsAssert(lut != NULL);
lut ->Eval16Fn(In, Out, lut->Data);
}
-// Does evaluate the LUT on cmsFloat32Number-basis.
+// Does evaluate the LUT on cmsFloat32Number-basis.
void CMSEXPORT cmsPipelineEvalFloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsPipeline* lut)
{
+ _cmsAssert(lut != NULL);
lut ->EvalFloatFn(In, Out, lut);
}
cmsPipeline* CMSEXPORT cmsPipelineDup(const cmsPipeline* lut)
{
cmsPipeline* NewLUT;
- cmsStage *NewMPE, *Anterior = NULL, *mpe;
+ cmsStage *NewMPE, *Anterior = NULL, *mpe;
cmsBool First = TRUE;
if (lut == NULL) return NULL;
- NewLUT = cmsPipelineAlloc(lut ->ContextID, lut ->InputChannels, lut ->OutputChannels);
- for (mpe = lut ->Elements;
- mpe != NULL;
+ NewLUT = cmsPipelineAlloc(lut ->ContextID, lut ->InputChannels, lut ->OutputChannels);
+ if (NewLUT == NULL) return NULL;
+
+ for (mpe = lut ->Elements;
+ mpe != NULL;
mpe = mpe ->Next) {
NewMPE = cmsStageDup(mpe);
cmsPipelineFree(NewLUT);
return NULL;
}
-
+
if (First) {
NewLUT ->Elements = NewMPE;
First = FALSE;
}
else {
- Anterior ->Next = NewMPE;
+ Anterior ->Next = NewMPE;
}
Anterior = NewMPE;
}
- NewLUT ->DupDataFn = lut ->DupDataFn;
- NewLUT ->FreeDataFn = lut ->FreeDataFn;
+ NewLUT ->Eval16Fn = lut ->Eval16Fn;
+ NewLUT ->EvalFloatFn = lut ->EvalFloatFn;
+ NewLUT ->DupDataFn = lut ->DupDataFn;
+ NewLUT ->FreeDataFn = lut ->FreeDataFn;
- if (NewLUT ->DupDataFn != NULL)
+ if (NewLUT ->DupDataFn != NULL)
NewLUT ->Data = NewLUT ->DupDataFn(lut ->ContextID, lut->Data);
}
-void CMSEXPORT cmsPipelineInsertStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage* mpe)
+int CMSEXPORT cmsPipelineInsertStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage* mpe)
{
cmsStage* Anterior = NULL, *pt;
- _cmsAssert(lut != NULL);
- _cmsAssert(mpe != NULL);
+ if (lut == NULL || mpe == NULL)
+ return FALSE;
switch (loc) {
case cmsAT_END:
- if (lut ->Elements == NULL)
+ if (lut ->Elements == NULL)
lut ->Elements = mpe;
else {
-
+
for (pt = lut ->Elements;
pt != NULL;
pt = pt -> Next) Anterior = pt;
}
break;
default:;
+ return FALSE;
}
BlessLUT(lut);
+ return TRUE;
}
// Unlink an element and return the pointer to it
cmsStage *Anterior, *pt, *Last;
cmsStage *Unlinked = NULL;
-
+
// If empty LUT, there is nothing to remove
if (lut ->Elements == NULL) {
if (mpe) *mpe = NULL;
// On depending on the strategy...
switch (loc) {
- case cmsAT_BEGIN:
+ case cmsAT_BEGIN:
{
cmsStage* elem = lut ->Elements;
-
+
lut ->Elements = elem -> Next;
elem ->Next = NULL;
Unlinked = elem;
-
+
}
break;
pt != NULL;
pt = pt -> Next) {
Anterior = Last;
- Last = pt;
+ Last = pt;
}
Unlinked = Last; // Next already points to NULL
// Truncate the chain
- if (Anterior)
+ if (Anterior)
Anterior ->Next = NULL;
- else
+ else
lut ->Elements = NULL;
break;
default:;
}
- if (mpe)
+ if (mpe)
*mpe = Unlinked;
else
cmsStageFree(Unlinked);
// Concatenate two LUT into a new single one
cmsBool CMSEXPORT cmsPipelineCat(cmsPipeline* l1, const cmsPipeline* l2)
{
- cmsStage* mpe, *NewMPE;
+ cmsStage* mpe;
- // If both LUTS does not have elements, we need to inherit
+ // If both LUTS does not have elements, we need to inherit
// the number of channels
if (l1 ->Elements == NULL && l2 ->Elements == NULL) {
l1 ->InputChannels = l2 ->InputChannels;
}
// Cat second
- for (mpe = l2 ->Elements;
- mpe != NULL;
+ for (mpe = l2 ->Elements;
+ mpe != NULL;
mpe = mpe ->Next) {
// We have to dup each element
- NewMPE = cmsStageDup(mpe);
-
- if (NewMPE == NULL) {
- return FALSE;
- }
-
- cmsPipelineInsertStage(l1, cmsAT_END, NewMPE);
+ if (!cmsPipelineInsertStage(l1, cmsAT_END, cmsStageDup(mpe)))
+ return FALSE;
}
- BlessLUT(l1);
- return TRUE;
+ BlessLUT(l1);
+ return TRUE;
}
return n;
}
-// This function may be used to set the optional evalueator and a block of private data. If private data is being used, an optional
+// 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.
-void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut,
- _cmsOPTeval16Fn Eval16,
- void* PrivateData,
- _cmsOPTfreeDataFn FreePrivateDataFn,
- _cmsOPTdupDataFn DupPrivateDataFn)
+void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut,
+ _cmsOPTeval16Fn Eval16,
+ void* PrivateData,
+ _cmsFreeUserDataFn FreePrivateDataFn,
+ _cmsDupUserDataFn DupPrivateDataFn)
{
Lut ->Eval16Fn = Eval16;
Lut ->DupDataFn = DupPrivateDataFn;
- Lut ->FreeDataFn = FreePrivateDataFn;
+ Lut ->FreeDataFn = FreePrivateDataFn;
Lut ->Data = PrivateData;
}
// ----------------------------------------------------------- Reverse interpolation
-// Here's how it goes. The derivative Df(x) of the function f is the linear
-// transformation that best approximates f near the point x. It can be represented
-// by a matrix A whose entries are the partial derivatives of the components of f
+// Here's how it goes. The derivative Df(x) of the function f is the linear
+// transformation that best approximates f near the point x. It can be represented
+// by a matrix A whose entries are the partial derivatives of the components of f
// with respect to all the coordinates. This is know as the Jacobian
//
-// The best linear approximation to f is given by the matrix equation:
-//
-// y-y0 = A (x-x0)
-//
-// So, if x0 is a good "guess" for the zero of f, then solving for the zero of this
-// linear approximation will give a "better guess" for the zero of f. Thus let y=0,
-// and since y0=f(x0) one can solve the above equation for x. This leads to the
-// Newton's method formula:
+// The best linear approximation to f is given by the matrix equation:
+//
+// y-y0 = A (x-x0)
+//
+// So, if x0 is a good "guess" for the zero of f, then solving for the zero of this
+// linear approximation will give a "better guess" for the zero of f. Thus let y=0,
+// and since y0=f(x0) one can solve the above equation for x. This leads to the
+// Newton's method formula:
+//
+// xn+1 = xn - A-1 f(xn)
//
-// xn+1 = xn - A-1 f(xn)
-//
-// where xn+1 denotes the (n+1)-st guess, obtained from the n-th guess xn in the
-// fashion described above. Iterating this will give better and better approximations
-// if you have a "good enough" initial guess.
+// where xn+1 denotes the (n+1)-st guess, obtained from the n-th guess xn in the
+// fashion described above. Iterating this will give better and better approximations
+// if you have a "good enough" initial guess.
#define JACOBIAN_EPSILON 0.001f
#define INVERSION_MAX_ITERATIONS 30
// Increment with reflexion on boundary
-static
+static
void IncDelta(cmsFloat32Number *Val)
{
- if (*Val < (1.0 - JACOBIAN_EPSILON))
+ if (*Val < (1.0 - JACOBIAN_EPSILON))
*Val += JACOBIAN_EPSILON;
-
- else
+
+ else
*Val -= JACOBIAN_EPSILON;
-
+
}
// Evaluate a LUT in reverse direction. It only searches on 3->3 LUT. Uses Newton method
//
// x1 <- x - [J(x)]^-1 * f(x)
-//
+//
// lut: The LUT on where to do the search
// Target: LabK, 3 values of Lab plus destination K which is fixed
// Result: The obtained CMYK
const cmsPipeline* lut)
{
cmsUInt32Number i, j;
- cmsFloat64Number error, LastError = 1E20;
+ cmsFloat64Number error, LastError = 1E20;
cmsFloat32Number fx[4], x[4], xd[4], fxd[4];
cmsVEC3 tmp, tmp2;
- cmsMAT3 Jacobian;
- cmsFloat64Number LastResult[4];
-
-
+ cmsMAT3 Jacobian;
+
// Only 3->3 and 4->3 are supported
if (lut ->InputChannels != 3 && lut ->InputChannels != 4) return FALSE;
if (lut ->OutputChannels != 3) return FALSE;
-
- // Mark result of -1
- LastResult[0] = LastResult[1] = LastResult[2] = -1.0f;
-
+
// Take the hint as starting point if specified
if (Hint == NULL) {
else {
// Only copy 3 channels from hint...
- for (j=0; j < 3; j++)
- x[j] = Hint[j];
+ for (j=0; j < 3; j++)
+ x[j] = Hint[j];
}
-
+
// If Lut is 4-dimensions, then grab target[3], which is fixed
if (lut ->InputChannels == 4) {
x[3] = Target[3];
else x[3] = 0; // To keep lint happy
- // Iterate
+ // Iterate
for (i = 0; i < INVERSION_MAX_ITERATIONS; i++) {
// Get beginning fx
error = EuclideanDistance(fx, Target, 3);
// If not convergent, return last safe value
- if (error >= LastError)
+ if (error >= LastError)
break;
// Keep latest values
LastError = error;
- for (j=0; j < lut ->InputChannels; j++)
- Result[j] = x[j];
+ for (j=0; j < lut ->InputChannels; j++)
+ Result[j] = x[j];
// Found an exact match?
- if (error <= 0)
+ if (error <= 0)
break;
- // Obtain slope (the Jacobian)
+ // Obtain slope (the Jacobian)
for (j = 0; j < 3; j++) {
xd[0] = x[0];
Jacobian.v[0].n[j] = ((fxd[0] - fx[0]) / JACOBIAN_EPSILON);
Jacobian.v[1].n[j] = ((fxd[1] - fx[1]) / JACOBIAN_EPSILON);
- Jacobian.v[2].n[j] = ((fxd[2] - fx[2]) / JACOBIAN_EPSILON);
+ Jacobian.v[2].n[j] = ((fxd[2] - fx[2]) / JACOBIAN_EPSILON);
}
// Solve system
return TRUE;
}
+
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
}
#else
-#define byteReverse(buf, len)
+#define byteReverse(buf, len)
#endif
static
void MD5_Transform(cmsUInt32Number buf[4], cmsUInt32Number in[16])
-
+
{
register cmsUInt32Number a, b, c, d;
{
_cmsMD5* ctx = (_cmsMD5*) Handle;
cmsUInt32Number t;
-
+
t = ctx->bits[0];
if ((ctx->bits[0] = t + (len << 3)) < t)
- ctx->bits[1]++;
+ ctx->bits[1]++;
ctx->bits[1] += len >> 29;
- t = (t >> 3) & 0x3f;
+ t = (t >> 3) & 0x3f;
if (t) {
cmsUInt8Number* Mem = NULL;
cmsHANDLE MD5 = NULL;
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
- _cmsICCPROFILE Keep;
+ _cmsICCPROFILE Keep;
- _cmsAssert(hProfile != NULL);
+ _cmsAssert(hProfile != NULL);
ContextID = cmsGetProfileContextID(hProfile);
// Save a copy of the profile header
memmove(&Keep, Icc, sizeof(_cmsICCPROFILE));
-
+
// Set RI, attributes and ID
memset(&Icc ->attributes, 0, sizeof(Icc ->attributes));
Icc ->RenderingIntent = 0;
// Save to temporary storage
if (!cmsSaveProfileToMem(hProfile, Mem, &BytesNeeded)) goto Error;
-
+
// Create MD5 object
MD5 = MD5alloc(ContextID);
if (MD5 == NULL) goto Error;
// Temp storage is no longer needed
_cmsFree(ContextID, Mem);
-
+
// Restore header
memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
Error:
// Free resources as something went wrong
- if (MD5 != NULL) _cmsFree(ContextID, MD5);
+ // "MD5" cannot be other than NULL here, so no need to free it
if (Mem != NULL) _cmsFree(ContextID, Mem);
memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
return FALSE;
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
#define DSWAP(x, y) {cmsFloat64Number tmp = (x); (x)=(y); (y)=tmp;}
-// Initiate a vector
+// Initiate a vector
void CMSEXPORT _cmsVEC3init(cmsVEC3* r, cmsFloat64Number x, cmsFloat64Number y, cmsFloat64Number z)
{
r -> n[VX] = x;
return u->n[VX] * v->n[VX] + u->n[VY] * v->n[VY] + u->n[VZ] * v->n[VZ];
}
-// Euclidean length
+// Euclidean length
cmsFloat64Number CMSEXPORT _cmsVEC3length(const cmsVEC3* a)
{
return sqrt(a ->n[VX] * a ->n[VX] +
cmsBool CMSEXPORT _cmsMAT3isIdentity(const cmsMAT3* a)
{
- cmsMAT3 Identity;
- int i, j;
+ cmsMAT3 Identity;
+ int i, j;
- _cmsMAT3identity(&Identity);
+ _cmsMAT3identity(&Identity);
- for (i=0; i < 3; i++)
- for (j=0; j < 3; j++)
- if (!CloseEnough(a ->v[i].n[j], Identity.v[i].n[j])) return FALSE;
+ for (i=0; i < 3; i++)
+ for (j=0; j < 3; j++)
+ if (!CloseEnough(a ->v[i].n[j], Identity.v[i].n[j])) return FALSE;
- return TRUE;
+ return TRUE;
}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2012 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// Allocates an empty multi localizad unicode object
cmsMLU* CMSEXPORT cmsMLUalloc(cmsContext ContextID, cmsUInt32Number nItems)
{
- cmsMLU* mlu;
+ cmsMLU* mlu;
- // nItems should be positive if given
- if (nItems <= 0) nItems = 2;
+ // nItems should be positive if given
+ if (nItems <= 0) nItems = 2;
- // Create the container
- mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU));
- if (mlu == NULL) return NULL;
+ // Create the container
+ mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU));
+ if (mlu == NULL) return NULL;
- mlu ->ContextID = ContextID;
+ mlu ->ContextID = ContextID;
- // Create entry array
- mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry));
- if (mlu ->Entries == NULL) {
- _cmsFree(ContextID, mlu);
- return NULL;
- }
+ // Create entry array
+ mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry));
+ if (mlu ->Entries == NULL) {
+ _cmsFree(ContextID, mlu);
+ return NULL;
+ }
- // Ok, keep indexes up to date
- mlu ->AllocatedEntries = nItems;
- mlu ->UsedEntries = 0;
+ // Ok, keep indexes up to date
+ mlu ->AllocatedEntries = nItems;
+ mlu ->UsedEntries = 0;
- return mlu;
+ return mlu;
}
-// Grows a mempool table for a MLU. Each time this function is called, mempool size is multiplied times two.
+// Grows a mempool table for a MLU. Each time this function is called, mempool size is multiplied times two.
static
cmsBool GrowMLUpool(cmsMLU* mlu)
{
- cmsUInt32Number size;
- void *NewPtr;
+ cmsUInt32Number size;
+ void *NewPtr;
- // Sanity check
- if (mlu == NULL) return FALSE;
+ // Sanity check
+ if (mlu == NULL) return FALSE;
- if (mlu ->PoolSize == 0)
- size = 256;
- else
- size = mlu ->PoolSize * 2;
+ if (mlu ->PoolSize == 0)
+ size = 256;
+ else
+ size = mlu ->PoolSize * 2;
- // Check for overflow
- if (size < mlu ->PoolSize) return FALSE;
+ // Check for overflow
+ if (size < mlu ->PoolSize) return FALSE;
- // Reallocate the pool
- NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size);
- if (NewPtr == NULL) return FALSE;
+ // Reallocate the pool
+ NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size);
+ if (NewPtr == NULL) return FALSE;
- mlu ->MemPool = NewPtr;
- mlu ->PoolSize = size;
+ mlu ->MemPool = NewPtr;
+ mlu ->PoolSize = size;
- return TRUE;
+ return TRUE;
}
-// Grows a ntry table for a MLU. Each time this function is called, table size is multiplied times two.
+// Grows a entry table for a MLU. Each time this function is called, table size is multiplied times two.
static
cmsBool GrowMLUtable(cmsMLU* mlu)
{
int AllocatedEntries;
_cmsMLUentry *NewPtr;
-
- // Sanity check
- if (mlu == NULL) return FALSE;
+
+ // Sanity check
+ if (mlu == NULL) return FALSE;
AllocatedEntries = mlu ->AllocatedEntries * 2;
- // Check for overflow
- if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE;
+ // Check for overflow
+ if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE;
- // Reallocate the memory
+ // Reallocate the memory
NewPtr = (_cmsMLUentry*)_cmsRealloc(mlu ->ContextID, mlu ->Entries, AllocatedEntries*sizeof(_cmsMLUentry));
if (NewPtr == NULL) return FALSE;
-
+
mlu ->Entries = NewPtr;
mlu ->AllocatedEntries = AllocatedEntries;
}
-// Search for a specific entry in the structure. Language and Country are used.
+// Search for a specific entry in the structure. Language and Country are used.
static
int SearchMLUEntry(cmsMLU* mlu, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
{
int i;
-
- // Sanity check
- if (mlu == NULL) return -1;
- // Iterate whole table
+ // Sanity check
+ if (mlu == NULL) return -1;
+
+ // Iterate whole table
for (i=0; i < mlu ->UsedEntries; i++) {
- if (mlu ->Entries[i].Country == CountryCode &&
+ if (mlu ->Entries[i].Country == CountryCode &&
mlu ->Entries[i].Language == LanguageCode) return i;
}
- // Not found
+ // Not found
return -1;
}
-// Add a block of characters to the intended MLU. Language and country are specified.
+// Add a block of characters to the intended MLU. Language and country are specified.
// Only one entry for Language/country pair is allowed.
static
-cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,
+cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,
cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
{
cmsUInt32Number Offset;
cmsUInt8Number* Ptr;
- // Sanity check
- if (mlu == NULL) return FALSE;
+ // Sanity check
+ if (mlu == NULL) return FALSE;
// Is there any room available?
if (mlu ->UsedEntries >= mlu ->AllocatedEntries) {
if (SearchMLUEntry(mlu, LanguageCode, CountryCode) >= 0) return FALSE; // Only one is allowed!
// Check for size
- while ((mlu ->PoolSize - mlu ->PoolUsed) < size) {
+ while ((mlu ->PoolSize - mlu ->PoolUsed) < size) {
if (!GrowMLUpool(mlu)) return FALSE;
- }
+ }
Offset = mlu ->PoolUsed;
-
- Ptr = (cmsUInt8Number*) mlu ->MemPool;
- if (Ptr == NULL) return FALSE;
- // Set the entry
+ Ptr = (cmsUInt8Number*) mlu ->MemPool;
+ if (Ptr == NULL) return FALSE;
+
+ // Set the entry
memmove(Ptr + Offset, Block, size);
mlu ->PoolUsed += size;
-
+
mlu ->Entries[mlu ->UsedEntries].StrW = Offset;
mlu ->Entries[mlu ->UsedEntries].Len = size;
mlu ->Entries[mlu ->UsedEntries].Country = CountryCode;
}
-// Add an ASCII entry.
+// Add an ASCII entry.
cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)
{
cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString)+1;
for (i=0; i < len; i++)
WStr[i] = (wchar_t) ASCIIString[i];
-
+
rc = AddMLUBlock(mlu, len * sizeof(wchar_t), WStr, Lang, Cntry);
_cmsFree(mlu ->ContextID, WStr);
return rc;
-
+
}
// We don't need any wcs support library
-static
+static
cmsUInt32Number mywcslen(const wchar_t *s)
{
const wchar_t *p;
- p = s;
+ p = s;
while (*p)
p++;
cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) Language);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) Country);
cmsUInt32Number len;
-
+
if (mlu == NULL) return FALSE;
- if (WideString == NULL) return FALSE;
+ if (WideString == NULL) return FALSE;
len = (cmsUInt32Number) (mywcslen(WideString) + 1) * sizeof(wchar_t);
return AddMLUBlock(mlu, len, WideString, Lang, Cntry);
// Duplicating a MLU is as easy as copying all members
cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu)
{
- cmsMLU* NewMlu = NULL;
+ cmsMLU* NewMlu = NULL;
- // Duplicating a NULL obtains a NULL
- if (mlu == NULL) return NULL;
+ // Duplicating a NULL obtains a NULL
+ if (mlu == NULL) return NULL;
- NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);
- if (NewMlu == NULL) return NULL;
+ NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);
+ if (NewMlu == NULL) return NULL;
- // Should never happen
- if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)
- goto Error;
+ // Should never happen
+ if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)
+ goto Error;
- // Sanitize...
- if (NewMlu ->Entries == NULL || mlu ->Entries == NULL) goto Error;
+ // Sanitize...
+ if (NewMlu ->Entries == NULL || mlu ->Entries == NULL) goto Error;
- memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));
- NewMlu ->UsedEntries = mlu ->UsedEntries;
+ memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));
+ NewMlu ->UsedEntries = mlu ->UsedEntries;
- // The MLU may be empty
- if (mlu ->PoolUsed == 0) {
- NewMlu ->MemPool = NULL;
- }
- else {
- // It is not empty
- NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);
- if (NewMlu ->MemPool == NULL) goto Error;
- }
+ // The MLU may be empty
+ if (mlu ->PoolUsed == 0) {
+ NewMlu ->MemPool = NULL;
+ }
+ else {
+ // It is not empty
+ NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);
+ if (NewMlu ->MemPool == NULL) goto Error;
+ }
- NewMlu ->PoolSize = mlu ->PoolUsed;
+ NewMlu ->PoolSize = mlu ->PoolUsed;
- if (NewMlu ->MemPool == NULL || mlu ->MemPool == NULL) goto Error;
+ if (NewMlu ->MemPool == NULL || mlu ->MemPool == NULL) goto Error;
- memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);
- NewMlu ->PoolUsed = mlu ->PoolUsed;
+ memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);
+ NewMlu ->PoolUsed = mlu ->PoolUsed;
- return NewMlu;
+ return NewMlu;
Error:
- if (NewMlu != NULL) cmsMLUfree(NewMlu);
- return NULL;
+ if (NewMlu != NULL) cmsMLUfree(NewMlu);
+ return NULL;
}
// Free any used memory
void CMSEXPORT cmsMLUfree(cmsMLU* mlu)
{
- if (mlu) {
+ if (mlu) {
- if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
- if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);
+ if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
+ if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);
- _cmsFree(mlu ->ContextID, mlu);
- }
+ _cmsFree(mlu ->ContextID, mlu);
+ }
}
-// The algorithm first searches for an exact match of country and language, if not found it uses
+// The algorithm first searches for an exact match of country and language, if not found it uses
// the Language. If none is found, first entry is used instead.
static
-const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
- cmsUInt32Number *len,
- cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,
- cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)
+const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
+ cmsUInt32Number *len,
+ cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,
+ cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)
{
int i;
int Best = -1;
- _cmsMLUentry* v;
+ _cmsMLUentry* v;
if (mlu == NULL) return NULL;
if (v -> Country == CountryCode) {
- if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
- if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country;
+ if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
+ if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country;
if (len != NULL) *len = v ->Len;
- return (wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v -> StrW); // Found exact match
+ return (wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v -> StrW); // Found exact match
}
}
}
if (Best == -1)
Best = 0;
- v = mlu ->Entries + Best;
+ v = mlu ->Entries + Best;
- if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
- if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country;
+ if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
+ if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country;
if (len != NULL) *len = v ->Len;
- return(wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v ->StrW);
+ return(wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v ->StrW);
}
// Obtain an ASCII representation of the wide string. Setting buffer to NULL returns the len
-cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
- const char LanguageCode[3], const char CountryCode[3],
- char* Buffer, cmsUInt32Number BufferSize)
+cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
+ const char LanguageCode[3], const char CountryCode[3],
+ char* Buffer, cmsUInt32Number BufferSize)
{
const wchar_t *Wide;
cmsUInt32Number StrLen = 0;
cmsUInt32Number ASCIIlen, i;
- cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
+ cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
- // Sanitize
+ // Sanitize
if (mlu == NULL) return 0;
// Get WideChar
ASCIIlen = BufferSize - 1;
// Precess each character
- for (i=0; i < ASCIIlen; i++) {
+ for (i=0; i < ASCIIlen; i++) {
if (Wide[i] == 0)
Buffer[i] = 0;
Buffer[i] = (char) Wide[i];
}
- // We put a termination "\0"
+ // We put a termination "\0"
Buffer[ASCIIlen] = 0;
return ASCIIlen + 1;
}
-// Obtain a wide representation of the MLU, on depending on current locale settings
-cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
- const char LanguageCode[3], const char CountryCode[3],
- wchar_t* Buffer, cmsUInt32Number BufferSize)
+// Obtain a wide representation of the MLU, on depending on current locale settings
+cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
+ const char LanguageCode[3], const char CountryCode[3],
+ wchar_t* Buffer, cmsUInt32Number BufferSize)
{
const wchar_t *Wide;
cmsUInt32Number StrLen = 0;
- cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
+ cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
- // Sanitize
+ // Sanitize
if (mlu == NULL) return 0;
Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
if (Wide == NULL) return 0;
-
+
// Maybe we want only to know the len?
if (Buffer == NULL) return StrLen + sizeof(wchar_t);
StrLen = BufferSize - + sizeof(wchar_t);
memmove(Buffer, Wide, StrLen);
- Buffer[StrLen / sizeof(wchar_t)] = 0;
+ Buffer[StrLen / sizeof(wchar_t)] = 0;
return StrLen + sizeof(wchar_t);
}
// Get also the language and country
-CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
- const char LanguageCode[3], const char CountryCode[3],
- char ObtainedLanguage[3], char ObtainedCountry[3])
+CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
+ const char LanguageCode[3], const char CountryCode[3],
+ char ObtainedLanguage[3], char ObtainedCountry[3])
{
- const wchar_t *Wide;
-
- cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
+ const wchar_t *Wide;
+
+ cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
- cmsUInt16Number ObtLang, ObtCode;
+ cmsUInt16Number ObtLang, ObtCode;
- // Sanitize
+ // Sanitize
if (mlu == NULL) return FALSE;
Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode);
- if (Wide == NULL) return FALSE;
-
- // Get used language and code
+ if (Wide == NULL) return FALSE;
+
+ // Get used language and code
*(cmsUInt16Number *)ObtainedLanguage = _cmsAdjustEndianess16(ObtLang);
- *(cmsUInt16Number *)ObtainedCountry = _cmsAdjustEndianess16(ObtCode);
+ *(cmsUInt16Number *)ObtainedCountry = _cmsAdjustEndianess16(ObtCode);
+
+ ObtainedLanguage[2] = ObtainedCountry[2] = 0;
+ return TRUE;
+}
+
+
+
+// Get the number of translations in the MLU object
+cmsUInt32Number CMSEXPORT cmsMLUtranslationsCount(const cmsMLU* mlu)
+{
+ if (mlu == NULL) return 0;
+ return mlu->UsedEntries;
+}
+
+// Get the language and country codes for a specific MLU index
+cmsBool CMSEXPORT cmsMLUtranslationsCodes(const cmsMLU* mlu,
+ cmsUInt32Number idx,
+ char LanguageCode[3],
+ char CountryCode[3])
+{
+ _cmsMLUentry *entry;
+
+ if (mlu == NULL) return FALSE;
+
+ if (idx >= (cmsUInt32Number) mlu->UsedEntries) return FALSE;
+
+ entry = &mlu->Entries[idx];
+
+ *(cmsUInt16Number *)LanguageCode = _cmsAdjustEndianess16(entry->Language);
+ *(cmsUInt16Number *)CountryCode = _cmsAdjustEndianess16(entry->Country);
- ObtainedLanguage[2] = ObtainedCountry[2] = 0;
- return TRUE;
+ return TRUE;
}
// Grow the list to keep at least NumElements
static
cmsBool GrowNamedColorList(cmsNAMEDCOLORLIST* v)
-{
+{
cmsUInt32Number size;
_cmsNAMEDCOLOR * NewPtr;
if (size > 1024*100) return FALSE;
NewPtr = (_cmsNAMEDCOLOR*) _cmsRealloc(v ->ContextID, v ->List, size * sizeof(_cmsNAMEDCOLOR));
- if (NewPtr == NULL)
+ if (NewPtr == NULL)
return FALSE;
-
+
v ->List = NewPtr;
v ->Allocated = size;
return TRUE;
cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUInt32Number n, cmsUInt32Number ColorantCount, const char* Prefix, const char* Suffix)
{
cmsNAMEDCOLORLIST* v = (cmsNAMEDCOLORLIST*) _cmsMallocZero(ContextID, sizeof(cmsNAMEDCOLORLIST));
-
+
if (v == NULL) return NULL;
-
+
v ->List = NULL;
v ->nColors = 0;
v ->ContextID = ContextID;
while (v -> Allocated < n)
GrowNamedColorList(v);
- strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix));
- strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix));
+ strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix)-1);
+ strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix)-1);
+ v->Prefix[32] = v->Suffix[32] = 0;
+
v -> ColorantCount = ColorantCount;
return v;
// Free a list
void CMSEXPORT cmsFreeNamedColorList(cmsNAMEDCOLORLIST* v)
-{
+{
+ if (v == NULL) return;
if (v ->List) _cmsFree(v ->ContextID, v ->List);
- if (v) _cmsFree(v ->ContextID, v);
-}
+ _cmsFree(v ->ContextID, v);
+}
cmsNAMEDCOLORLIST* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
{
cmsNAMEDCOLORLIST* NewNC;
-
+
if (v == NULL) return NULL;
NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix);
// Append a color to a list. List pointer may change if reallocated
-cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
- const char* Name,
+cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
+ const char* Name,
cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS])
-{
+{
cmsUInt32Number i;
if (NamedColorList == NULL) return FALSE;
for (i=0; i < 3; i++)
NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? 0 : PCS[i];
- if (Name != NULL)
- strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name,
- sizeof(NamedColorList ->List[NamedColorList ->nColors].Name));
+ if (Name != NULL) {
+
+ strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name, cmsMAX_PATH-1);
+ NamedColorList ->List[NamedColorList ->nColors].Name[cmsMAX_PATH-1] = 0;
+
+ }
else
NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0;
return TRUE;
}
-// Returns number of elements
+// Returns number of elements
cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList)
-{
+{
if (NamedColorList == NULL) return 0;
return NamedColorList ->nColors;
}
// Info aboout a given color
-cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
- char* Name,
- char* Prefix,
+cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
+ char* Name,
+ char* Prefix,
char* Suffix,
- cmsUInt16Number* PCS,
+ cmsUInt16Number* PCS,
cmsUInt16Number* Colorant)
-{
+{
if (NamedColorList == NULL) return FALSE;
if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE;
if (Name) strcpy(Name, NamedColorList->List[nColor].Name);
if (Prefix) strcpy(Prefix, NamedColorList->Prefix);
if (Suffix) strcpy(Suffix, NamedColorList->Suffix);
- if (PCS)
+ if (PCS)
memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number));
- if (Colorant)
- memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
+ if (Colorant)
+ memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount);
// Search for a given color name (no prefix or suffix)
cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name)
-{
+{
int i, n;
if (NamedColorList == NULL) return -1;
return cmsDupNamedColorList(List);
}
+static
+void EvalNamedColorPCS(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
+{
+ cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
+ cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
+
+ if (index >= NamedColorList-> nColors) {
+ cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
+ }
+ else {
+
+ // Named color always uses Lab
+ Out[0] = (cmsFloat32Number) (NamedColorList->List[index].PCS[0] / 65535.0);
+ Out[1] = (cmsFloat32Number) (NamedColorList->List[index].PCS[1] / 65535.0);
+ Out[2] = (cmsFloat32Number) (NamedColorList->List[index].PCS[2] / 65535.0);
+ }
+}
+
static
void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{
cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
}
else {
- for (j=0; j < NamedColorList ->ColorantCount; j++)
- Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
+ for (j=0; j < NamedColorList ->ColorantCount; j++)
+ Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
}
}
// Named color lookup element
-cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList)
+cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool UsePCS)
{
- return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
- cmsSigNamedColorElemType,
- 1, 3,
- EvalNamedColor,
- DupNamedColorList,
- FreeNamedColorList,
- cmsDupNamedColorList(NamedColorList));
-
+ return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
+ cmsSigNamedColorElemType,
+ 1, UsePCS ? 3 : NamedColorList ->ColorantCount,
+ UsePCS ? EvalNamedColorPCS : EvalNamedColor,
+ DupNamedColorList,
+ FreeNamedColorList,
+ cmsDupNamedColorList(NamedColorList));
+
}
if (n > 255) return NULL;
Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ));
- if (Seq == NULL) return NULL;
-
+ if (Seq == NULL) return NULL;
+
Seq -> ContextID = ContextID;
Seq -> seq = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC));
Seq -> n = n;
-
+ if (Seq -> seq == NULL) {
+ _cmsFree(ContextID, Seq);
+ return NULL;
+ }
+
for (i=0; i < n; i++) {
Seq -> seq[i].Manufacturer = NULL;
Seq -> seq[i].Model = NULL;
Seq -> seq[i].Description = NULL;
}
-
+
return Seq;
}
NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ));
if (NewSeq == NULL) return NULL;
-
+
NewSeq -> seq = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC));
if (NewSeq ->seq == NULL) goto Error;
-
+
NewSeq -> ContextID = pseq ->ContextID;
NewSeq -> n = pseq ->n;
NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer);
NewSeq ->seq[i].Model = cmsMLUdup(pseq ->seq[i].Model);
NewSeq ->seq[i].Description = cmsMLUdup(pseq ->seq[i].Description);
-
+
}
return NewSeq;
return NULL;
}
+// Dictionaries --------------------------------------------------------------------------------------------------------
+
+// Dictionaries are just very simple linked lists
+
+
+typedef struct _cmsDICT_struct {
+ cmsDICTentry* head;
+ cmsContext ContextID;
+} _cmsDICT;
+
+
+// Allocate an empty dictionary
+cmsHANDLE CMSEXPORT cmsDictAlloc(cmsContext ContextID)
+{
+ _cmsDICT* dict = (_cmsDICT*) _cmsMallocZero(ContextID, sizeof(_cmsDICT));
+ if (dict == NULL) return NULL;
+
+ dict ->ContextID = ContextID;
+ return (cmsHANDLE) dict;
+
+}
+
+// Dispose resources
+void CMSEXPORT cmsDictFree(cmsHANDLE hDict)
+{
+ _cmsDICT* dict = (_cmsDICT*) hDict;
+ cmsDICTentry *entry, *next;
+
+ _cmsAssert(dict != NULL);
+
+ // Walk the list freeing all nodes
+ entry = dict ->head;
+ while (entry != NULL) {
+
+ if (entry ->DisplayName != NULL) cmsMLUfree(entry ->DisplayName);
+ if (entry ->DisplayValue != NULL) cmsMLUfree(entry ->DisplayValue);
+ if (entry ->Name != NULL) _cmsFree(dict ->ContextID, entry -> Name);
+ if (entry ->Value != NULL) _cmsFree(dict ->ContextID, entry -> Value);
+
+ // Don't fall in the habitual trap...
+ next = entry ->Next;
+ _cmsFree(dict ->ContextID, entry);
+
+ entry = next;
+ }
+
+ _cmsFree(dict ->ContextID, dict);
+}
+
+
+// Duplicate a wide char string
+static
+wchar_t* DupWcs(cmsContext ContextID, const wchar_t* ptr)
+{
+ if (ptr == NULL) return NULL;
+ return (wchar_t*) _cmsDupMem(ContextID, ptr, (mywcslen(ptr) + 1) * sizeof(wchar_t));
+}
+
+// Add a new entry to the linked list
+cmsBool CMSEXPORT cmsDictAddEntry(cmsHANDLE hDict, const wchar_t* Name, const wchar_t* Value, const cmsMLU *DisplayName, const cmsMLU *DisplayValue)
+{
+ _cmsDICT* dict = (_cmsDICT*) hDict;
+ cmsDICTentry *entry;
+
+ _cmsAssert(dict != NULL);
+ _cmsAssert(Name != NULL);
+
+ entry = (cmsDICTentry*) _cmsMallocZero(dict ->ContextID, sizeof(cmsDICTentry));
+ if (entry == NULL) return FALSE;
+
+ entry ->DisplayName = cmsMLUdup(DisplayName);
+ entry ->DisplayValue = cmsMLUdup(DisplayValue);
+ entry ->Name = DupWcs(dict ->ContextID, Name);
+ entry ->Value = DupWcs(dict ->ContextID, Value);
+
+ entry ->Next = dict ->head;
+ dict ->head = entry;
+
+ return TRUE;
+}
+
+
+// Duplicates an existing dictionary
+cmsHANDLE CMSEXPORT cmsDictDup(cmsHANDLE hDict)
+{
+ _cmsDICT* old_dict = (_cmsDICT*) hDict;
+ cmsHANDLE hNew;
+ cmsDICTentry *entry;
+
+ _cmsAssert(old_dict != NULL);
+
+ hNew = cmsDictAlloc(old_dict ->ContextID);
+ if (hNew == NULL) return NULL;
+ // Walk the list freeing all nodes
+ entry = old_dict ->head;
+ while (entry != NULL) {
+ if (!cmsDictAddEntry(hNew, entry ->Name, entry ->Value, entry ->DisplayName, entry ->DisplayValue)) {
+ cmsDictFree(hNew);
+ return NULL;
+ }
+
+ entry = entry -> Next;
+ }
+
+ return hNew;
+}
+
+// Get a pointer to the linked list
+const cmsDICTentry* CMSEXPORT cmsDictGetEntryList(cmsHANDLE hDict)
+{
+ _cmsDICT* dict = (_cmsDICT*) hDict;
+
+ if (dict == NULL) return NULL;
+ return dict ->head;
+}
+
+// Helper For external languages
+const cmsDICTentry* CMSEXPORT cmsDictNextEntry(const cmsDICTentry* e)
+{
+ if (e == NULL) return NULL;
+ return e ->Next;
+}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2011 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
cmsUInt16Number rx[256], ry[256], rz[256];
cmsUInt32Number X0[256], Y0[256], Z0[256]; // Precomputed nodes and offsets for 8-bit input data
-
+
} Prelin8Data;
// Number of channels
int nInputs;
int nOutputs;
-
- // Since there is no limitation of the output number of channels, this buffer holding the connexion CLUT-shaper
- // has to be dynamically allocated. This is not the case of first step shaper-CLUT, which is limited to max inputs
- cmsUInt16Number* StageDEF;
-
- _cmsInterpFn16 EvalCurveIn16[MAX_INPUT_DIMENSIONS]; // The maximum number of input channels is known in advance
- cmsInterpParams* ParamsCurveIn16[MAX_INPUT_DIMENSIONS];
-
+
+ _cmsInterpFn16 EvalCurveIn16[MAX_INPUT_DIMENSIONS]; // The maximum number of input channels is known in advance
+ cmsInterpParams* ParamsCurveIn16[MAX_INPUT_DIMENSIONS];
+
_cmsInterpFn16 EvalCLUT; // The evaluator for 3D grid
const cmsInterpParams* CLUTparams; // (not-owned pointer)
-
+
_cmsInterpFn16* EvalCurveOut16; // Points to an array of curve evaluators in 16 bits (not-owned pointer)
cmsInterpParams** ParamsCurveOut16; // Points to an array of references to interpolation params (not-owned pointer)
-
+
} Prelin16Data;
-// Optimization for matrix-shaper in 8 bits. Numbers are operated in n.14 signed, tables are stored in 1.14 fixed
+// Optimization for matrix-shaper in 8 bits. Numbers are operated in n.14 signed, tables are stored in 1.14 fixed
typedef cmsInt32Number cmsS1Fixed14Number; // Note that this may hold more than 16 bits!
#define DOUBLE_TO_1FIXED14(x) ((cmsS1Fixed14Number) floor((x) * 16384.0 + 0.5))
typedef struct {
-
+
cmsContext ContextID;
cmsS1Fixed14Number Shaper1R[256]; // from 0..255 to 1.14 (0.0...1.0)
cmsS1Fixed14Number Mat[3][3]; // n.14 to n.14 (needs a saturation after that)
cmsS1Fixed14Number Off[3];
- cmsUInt16Number Shaper2R[16385]; // 1.14 to 0..255
+ cmsUInt16Number Shaper2R[16385]; // 1.14 to 0..255
cmsUInt16Number Shaper2G[16385];
cmsUInt16Number Shaper2B[16385];
cmsStageFree(mpe);
}
-// Remove all identities in chain. Note that pt actually is a double pointer to the element that holds the pointer.
+// Remove all identities in chain. Note that pt actually is a double pointer to the element that holds the pointer.
static
cmsBool _Remove1Op(cmsPipeline* Lut, cmsStageSignature UnaryOp)
-{
+{
cmsStage** pt = &Lut ->Elements;
cmsBool AnyOpt = FALSE;
_RemoveElement(pt);
AnyOpt = TRUE;
}
- else
+ else
pt = &((*pt) -> Next);
}
// Same, but only if two adjacent elements are found
static
cmsBool _Remove2Op(cmsPipeline* Lut, cmsStageSignature Op1, cmsStageSignature Op2)
-{
+{
cmsStage** pt1;
cmsStage** pt2;
cmsBool AnyOpt = FALSE;
pt1 = &Lut ->Elements;
if (*pt1 == NULL) return AnyOpt;
-
+
while (*pt1 != NULL) {
pt2 = &((*pt1) -> Next);
_RemoveElement(pt1);
AnyOpt = TRUE;
}
- else
- pt1 = &((*pt1) -> Next);
+ else
+ pt1 = &((*pt1) -> Next);
}
return AnyOpt;
}
-// Preoptimize just gets rif of no-ops coming paired. Conversion from v2 to v4 followed
+// Preoptimize just gets rif of no-ops coming paired. Conversion from v2 to v4 followed
// by a v4 to v2 and vice-versa. The elements are then discarded.
static
cmsBool PreOptimize(cmsPipeline* Lut)
-{
+{
cmsBool AnyOpt = FALSE, Opt;
- AnyOpt = FALSE;
-
do {
Opt = FALSE;
// Remove V2 to V4 followed by V4 to V2
Opt |= _Remove2Op(Lut, cmsSigLabV2toV4, cmsSigLabV4toV2);
+ // Remove float pcs Lab conversions
+ Opt |= _Remove2Op(Lut, cmsSigLab2FloatPCS, cmsSigFloatPCS2Lab);
+
+ // Remove float pcs Lab conversions
+ Opt |= _Remove2Op(Lut, cmsSigXYZ2FloatPCS, cmsSigFloatPCS2XYZ);
+
if (Opt) AnyOpt = TRUE;
} while (Opt);
static
void Eval16nop1D(register const cmsUInt16Number Input[],
- register cmsUInt16Number Output[],
+ register cmsUInt16Number Output[],
register const struct _cms_interp_struc* p)
{
Output[0] = Input[0];
- cmsUNUSED_PARAMETER(p);
+ cmsUNUSED_PARAMETER(p);
}
static
{
Prelin16Data* p16 = (Prelin16Data*) D;
cmsUInt16Number StageABC[MAX_INPUT_DIMENSIONS];
+ cmsUInt16Number StageDEF[cmsMAXCHANNELS];
int i;
for (i=0; i < p16 ->nInputs; i++) {
-
+
p16 ->EvalCurveIn16[i](&Input[i], &StageABC[i], p16 ->ParamsCurveIn16[i]);
}
- p16 ->EvalCLUT(StageABC, p16 ->StageDEF, p16 ->CLUTparams);
+ p16 ->EvalCLUT(StageABC, StageDEF, p16 ->CLUTparams);
for (i=0; i < p16 ->nOutputs; i++) {
-
- p16 ->EvalCurveOut16[i](&p16->StageDEF[i], &Output[i], p16 ->ParamsCurveOut16[i]);
+
+ p16 ->EvalCurveOut16[i](&StageDEF[i], &Output[i], p16 ->ParamsCurveOut16[i]);
}
}
{
Prelin16Data* p16 = (Prelin16Data*) ptr;
- _cmsFree(ContextID, p16 ->StageDEF);
_cmsFree(ContextID, p16 ->EvalCurveOut16);
_cmsFree(ContextID, p16 ->ParamsCurveOut16);
static
void* Prelin16dup(cmsContext ContextID, const void* ptr)
-{
+{
Prelin16Data* p16 = (Prelin16Data*) ptr;
Prelin16Data* Duped = _cmsDupMem(ContextID, p16, sizeof(Prelin16Data));
if (Duped == NULL) return NULL;
- Duped ->StageDEF = _cmsCalloc(ContextID, p16 ->nOutputs, sizeof(cmsUInt16Number));
Duped ->EvalCurveOut16 = _cmsDupMem(ContextID, p16 ->EvalCurveOut16, p16 ->nOutputs * sizeof(_cmsInterpFn16));
Duped ->ParamsCurveOut16 = _cmsDupMem(ContextID, p16 ->ParamsCurveOut16, p16 ->nOutputs * sizeof(cmsInterpParams* ));
static
-Prelin16Data* PrelinOpt16alloc(cmsContext ContextID,
- const cmsInterpParams* ColorMap,
- int nInputs, cmsToneCurve** In,
+Prelin16Data* PrelinOpt16alloc(cmsContext ContextID,
+ const cmsInterpParams* ColorMap,
+ int nInputs, cmsToneCurve** In,
int nOutputs, cmsToneCurve** Out )
{
int i;
- Prelin16Data* p16 = (Prelin16Data*) _cmsMallocZero(ContextID, sizeof(Prelin16Data));
+ Prelin16Data* p16 = _cmsMallocZero(ContextID, sizeof(Prelin16Data));
if (p16 == NULL) return NULL;
p16 ->nInputs = nInputs;
p16 -> nOutputs = nOutputs;
-
+
for (i=0; i < nInputs; i++) {
if (In == NULL) {
p16 ->EvalCLUT = ColorMap ->Interpolation.Lerp16;
- p16 -> StageDEF = _cmsCalloc(ContextID, p16 ->nOutputs, sizeof(cmsUInt16Number));
p16 -> EvalCurveOut16 = (_cmsInterpFn16*) _cmsCalloc(ContextID, nOutputs, sizeof(_cmsInterpFn16));
p16 -> ParamsCurveOut16 = (cmsInterpParams**) _cmsCalloc(ContextID, nOutputs, sizeof(cmsInterpParams* ));
#define PRELINEARIZATION_POINTS 4096
-// Sampler implemented by another LUT. This is a clean way to precalculate the devicelink 3D CLUT for
+// Sampler implemented by another LUT. This is a clean way to precalculate the devicelink 3D CLUT for
// almost any transform. We use floating point precision and then convert from floating point to 16 bits.
static
int XFormSampler16(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
_cmsAssert(Lut -> OutputChannels < cmsMAXCHANNELS);
// From 16 bit to floating point
- for (i=0; i < Lut ->InputChannels; i++)
+ for (i=0; i < Lut ->InputChannels; i++)
InFloat[i] = (cmsFloat32Number) (In[i] / 65535.0);
// Evaluate in floating point
cmsPipelineEvalFloat(InFloat, OutFloat, Lut);
// Back to 16 bits representation
- for (i=0; i < Lut ->OutputChannels; i++)
+ for (i=0; i < Lut ->OutputChannels; i++)
Out[i] = _cmsQuickSaturateWord(OutFloat[i] * 65535.0);
// Always succeed
static
cmsBool AllCurvesAreLinear(cmsStage* mpe)
{
- cmsToneCurve** Curves;
+ cmsToneCurve** Curves;
cmsUInt32Number i, n;
Curves = _cmsStageGetPtrToCurveSet(mpe);
- if (Curves == NULL) return FALSE;
+ if (Curves == NULL) return FALSE;
n = cmsStageOutputChannels(mpe);
int i, index;
if (CLUT -> Type != cmsSigCLutElemType) {
- cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) Attempt to PatchLUT on non-lut MPE");
+ cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) Attempt to PatchLUT on non-lut stage");
return FALSE;
}
- px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;
- py = ((cmsFloat64Number) At[1] * (p16->Domain[1])) / 65535.0;
- pz = ((cmsFloat64Number) At[2] * (p16->Domain[2])) / 65535.0;
- pw = ((cmsFloat64Number) At[3] * (p16->Domain[3])) / 65535.0;
+ if (nChannelsIn == 4) {
- x0 = (int) floor(px);
- y0 = (int) floor(py);
- z0 = (int) floor(pz);
- w0 = (int) floor(pw);
+ px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;
+ py = ((cmsFloat64Number) At[1] * (p16->Domain[1])) / 65535.0;
+ pz = ((cmsFloat64Number) At[2] * (p16->Domain[2])) / 65535.0;
+ pw = ((cmsFloat64Number) At[3] * (p16->Domain[3])) / 65535.0;
- if (nChannelsIn == 4) {
+ x0 = (int) floor(px);
+ y0 = (int) floor(py);
+ z0 = (int) floor(pz);
+ w0 = (int) floor(pw);
if (((px - x0) != 0) ||
((py - y0) != 0) ||
((pw - w0) != 0)) return FALSE; // Not on exact node
index = p16 -> opta[3] * x0 +
- p16 -> opta[2] * y0 +
- p16 -> opta[1] * z0 +
- p16 -> opta[0] * w0;
+ p16 -> opta[2] * y0 +
+ p16 -> opta[1] * z0 +
+ p16 -> opta[0] * w0;
}
- else
+ else
if (nChannelsIn == 3) {
+ px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;
+ py = ((cmsFloat64Number) At[1] * (p16->Domain[1])) / 65535.0;
+ pz = ((cmsFloat64Number) At[2] * (p16->Domain[2])) / 65535.0;
+
+ x0 = (int) floor(px);
+ y0 = (int) floor(py);
+ z0 = (int) floor(pz);
+
if (((px - x0) != 0) ||
((py - y0) != 0) ||
((pz - z0) != 0)) return FALSE; // Not on exact node
index = p16 -> opta[2] * x0 +
- p16 -> opta[1] * y0 +
- p16 -> opta[0] * z0;
+ p16 -> opta[1] * y0 +
+ p16 -> opta[0] * z0;
}
- else
+ else
if (nChannelsIn == 1) {
+ px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;
+
+ x0 = (int) floor(px);
+
if (((px - x0) != 0)) return FALSE; // Not on exact node
- index = p16 -> opta[0] * x0;
+ index = p16 -> opta[0] * x0;
}
else {
cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) %d Channels are not supported on PatchLUT", nChannelsIn);
return TRUE;
}
-// Auxiliar, to see if two values are equal.
+// Auxiliar, to see if two values are equal or very different
static
-cmsBool WhitesAreEqual(int n, cmsUInt16Number White1[], cmsUInt16Number White2[] )
+cmsBool WhitesAreEqual(int n, cmsUInt16Number White1[], cmsUInt16Number White2[] )
{
int i;
for (i=0; i < n; i++) {
+
+ if (abs(White1[i] - White2[i]) > 0xf000) return TRUE; // Values are so extremly different that the fixup should be avoided
if (White1[i] != White2[i]) return FALSE;
}
return TRUE;
cmsUInt16Number WhiteIn[cmsMAXCHANNELS], WhiteOut[cmsMAXCHANNELS], ObtainedOut[cmsMAXCHANNELS];
cmsUInt32Number i, nOuts, nIns;
cmsStage *PreLin = NULL, *CLUT = NULL, *PostLin = NULL;
-
+
if (!_cmsEndPointsBySpace(EntryColorSpace,
&WhitePointIn, NULL, &nIns)) return FALSE;
&WhitePointOut, NULL, &nOuts)) return FALSE;
// It needs to be fixed?
+ if (Lut ->InputChannels != nIns) return FALSE;
+ if (Lut ->OutputChannels != nOuts) return FALSE;
cmsPipelineEval16(WhitePointIn, ObtainedOut, Lut);
- if (WhitesAreEqual(nOuts, WhitePointOut, ObtainedOut)) return TRUE; // whites already match
-
+ if (WhitesAreEqual(nOuts, WhitePointOut, ObtainedOut)) return TRUE; // whites already match
+
// Check if the LUT comes as Prelin, CLUT or Postlin. We allow all combinations
if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &PreLin, &CLUT, &PostLin))
if (!cmsPipelineCheckAndRetreiveStages(Lut, 2, cmsSigCurveSetElemType, cmsSigCLutElemType, &PreLin, &CLUT))
cmsToneCurve** Curves = _cmsStageGetPtrToCurveSet(PreLin);
- for (i=0; i < nIns; i++) {
+ for (i=0; i < nIns; i++) {
WhiteIn[i] = cmsEvalToneCurve16(Curves[i], WhitePointIn[i]);
}
}
else {
- for (i=0; i < nIns; i++)
- WhiteIn[i] = WhitePointIn[i];
+ for (i=0; i < nIns; i++)
+ WhiteIn[i] = WhitePointIn[i];
}
// If any post-linearization, we need to find how is represented white before the curve, do
// a reverse interpolation in this case.
if (PostLin) {
-
+
cmsToneCurve** Curves = _cmsStageGetPtrToCurveSet(PostLin);
-
+
for (i=0; i < nOuts; i++) {
-
+
cmsToneCurve* InversePostLin = cmsReverseToneCurve(Curves[i]);
- WhiteOut[i] = cmsEvalToneCurve16(InversePostLin, WhitePointOut[i]);
- cmsFreeToneCurve(InversePostLin);
+ if (InversePostLin == NULL) {
+ WhiteOut[i] = WhitePointOut[i];
+
+ } else {
+
+ WhiteOut[i] = cmsEvalToneCurve16(InversePostLin, WhitePointOut[i]);
+ cmsFreeToneCurve(InversePostLin);
+ }
}
}
else {
- for (i=0; i < nOuts; i++)
- WhiteOut[i] = WhitePointOut[i];
+ for (i=0; i < nOuts; i++)
+ WhiteOut[i] = WhitePointOut[i];
}
// Ok, proceed with patching. May fail and we don't care if it fails
}
// -----------------------------------------------------------------------------------------------------------------------------------------------
-// This function creates simple LUT from complex ones. The generated LUT has an optional set of
-// prelinearization curves, a CLUT of nGridPoints and optional postlinearization tables.
-// These curves have to exist in the original LUT in order to be used in the simplified output.
+// This function creates simple LUT from complex ones. The generated LUT has an optional set of
+// prelinearization curves, a CLUT of nGridPoints and optional postlinearization tables.
+// These curves have to exist in the original LUT in order to be used in the simplified output.
// Caller may also use the flags to allow this feature.
// LUTS with all curves will be simplified to a single curve. Parametric curves are lost.
// This function should be used on 16-bits LUTS only, as floating point losses precision when simplified
// -----------------------------------------------------------------------------------------------------------------------------------------------
static
-cmsBool OptimizeByResampling(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
+cmsBool OptimizeByResampling(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
- cmsPipeline* Src;
- cmsPipeline* Dest;
- cmsStage* CLUT;
+ cmsPipeline* Src = NULL;
+ cmsPipeline* Dest = NULL;
+ cmsStage* mpe;
+ cmsStage* CLUT;
cmsStage *KeepPreLin = NULL, *KeepPostLin = NULL;
- int nGridPoints;
+ int nGridPoints;
cmsColorSpaceSignature ColorSpace, OutputColorSpace;
cmsStage *NewPreLin = NULL;
cmsStage *NewPostLin = NULL;
cmsToneCurve** DataSetOut;
Prelin16Data* p16;
-
// This is a loosy optimization! does not apply in floating-point cases
if (_cmsFormatterIsFloat(*InputFormat) || _cmsFormatterIsFloat(*OutputFormat)) return FALSE;
Src = *Lut;
- // Allocate an empty LUT
+ // Named color pipelines cannot be optimized either
+ for (mpe = cmsPipelineGetPtrToFirstStage(Src);
+ mpe != NULL;
+ mpe = cmsStageNext(mpe)) {
+ if (cmsStageType(mpe) == cmsSigNamedColorElemType) return FALSE;
+ }
+
+ // Allocate an empty LUT
Dest = cmsPipelineAlloc(Src ->ContextID, Src ->InputChannels, Src ->OutputChannels);
if (!Dest) return FALSE;
// Maybe this is a linear tram, so we can avoid the whole stuff
if (!AllCurvesAreLinear(PreLin)) {
- // All seems ok, proceed.
+ // All seems ok, proceed.
NewPreLin = cmsStageDup(PreLin);
- cmsPipelineInsertStage(Dest, cmsAT_BEGIN, NewPreLin);
+ if(!cmsPipelineInsertStage(Dest, cmsAT_BEGIN, NewPreLin))
+ goto Error;
// Remove prelinearization. Since we have duplicated the curve
// in destination LUT, the sampling shoud be applied after this stage.
if (CLUT == NULL) return FALSE;
// Add the CLUT to the destination LUT
- cmsPipelineInsertStage(Dest, cmsAT_END, CLUT);
+ if (!cmsPipelineInsertStage(Dest, cmsAT_END, CLUT)) {
+ goto Error;
+ }
// Postlinearization tables are kept unless indicated by flags
if (*dwFlags & cmsFLAGS_CLUT_POST_LINEARIZATION) {
// Maybe this is a linear tram, so we can avoid the whole stuff
if (!AllCurvesAreLinear(PostLin)) {
- // All seems ok, proceed.
+ // All seems ok, proceed.
NewPostLin = cmsStageDup(PostLin);
- cmsPipelineInsertStage(Dest, cmsAT_END, NewPostLin);
+ if (!cmsPipelineInsertStage(Dest, cmsAT_END, NewPostLin))
+ goto Error;
// In destination LUT, the sampling shoud be applied after this stage.
cmsPipelineUnlinkStage(Src, cmsAT_END, &KeepPostLin);
}
}
- // Now its time to do the sampling. We have to ignore pre/post linearization
+ // Now its time to do the sampling. We have to ignore pre/post linearization
// The source LUT whithout pre/post curves is passed as parameter.
if (!cmsStageSampleCLut16bit(CLUT, XFormSampler16, (void*) Src, 0)) {
-
+Error:
// Ops, something went wrong, Restore stages
- if (KeepPreLin != NULL) cmsPipelineInsertStage(Src, cmsAT_BEGIN, KeepPreLin);
- if (KeepPostLin != NULL) cmsPipelineInsertStage(Src, cmsAT_END, KeepPostLin);
+ if (KeepPreLin != NULL) {
+ if (!cmsPipelineInsertStage(Src, cmsAT_BEGIN, KeepPreLin)) {
+ _cmsAssert(0); // This never happens
+ }
+ }
+ if (KeepPostLin != NULL) {
+ if (!cmsPipelineInsertStage(Src, cmsAT_END, KeepPostLin)) {
+ _cmsAssert(0); // This never happens
+ }
+ }
cmsPipelineFree(Dest);
return FALSE;
- }
+ }
- // Done.
+ // Done.
if (KeepPreLin != NULL) cmsStageFree(KeepPreLin);
if (KeepPostLin != NULL) cmsStageFree(KeepPostLin);
}
else {
- p16 = PrelinOpt16alloc(Dest ->ContextID,
- DataCLUT ->Params,
- Dest ->InputChannels,
- DataSetIn,
- Dest ->OutputChannels,
- DataSetOut);
-
+ p16 = PrelinOpt16alloc(Dest ->ContextID,
+ DataCLUT ->Params,
+ Dest ->InputChannels,
+ DataSetIn,
+ Dest ->OutputChannels,
+ DataSetOut);
_cmsPipelineSetOptimizationParameters(Dest, PrelinEval16, (void*) p16, PrelinOpt16free, Prelin16dup);
}
*Lut = Dest;
return TRUE;
- cmsUNUSED_PARAMETER(Intent);
+ cmsUNUSED_PARAMETER(Intent);
}
// -----------------------------------------------------------------------------------------------------------------------------------------------
-// Fixes the gamma balancing of transform. This is described in my paper "Prelinearization Stages on
-// Color-Management Application-Specific Integrated Circuits (ASICs)" presented at NIP24. It only works
+// Fixes the gamma balancing of transform. This is described in my paper "Prelinearization Stages on
+// Color-Management Application-Specific Integrated Circuits (ASICs)" presented at NIP24. It only works
// for RGB transforms. See the paper for more details
// -----------------------------------------------------------------------------------------------------------------------------------------------
Slope = (EndVal - Val) / AtBegin; // AtBegin holds the X interval, which is same in both cases
beta = Val - Slope * AtEnd;
- for (i = AtEnd; i < (int) g ->nEntries; i++)
+ for (i = AtEnd; i < (int) g ->nEntries; i++)
g ->Table16[i] = _cmsQuickSaturateWord(i * Slope + beta);
}
-// Precomputes tables for 8-bit on input devicelink.
+// Precomputes tables for 8-bit on input devicelink.
static
Prelin8Data* PrelinOpt8alloc(cmsContext ContextID, const cmsInterpParams* p, cmsToneCurve* G[3])
{
p8 = _cmsMallocZero(ContextID, sizeof(Prelin8Data));
if (p8 == NULL) return NULL;
-
- // Since this only works for 8 bit input, values comes always as x * 257,
+
+ // Since this only works for 8 bit input, values comes always as x * 257,
// we can safely take msb byte (x << 8 + x)
for (i=0; i < 256; i++) {
static
void Prelin8free(cmsContext ContextID, void* ptr)
-{
+{
_cmsFree(ContextID, ptr);
}
static
void* Prelin8dup(cmsContext ContextID, const void* ptr)
-{
+{
return _cmsDupMem(ContextID, ptr, sizeof(Prelin8Data));
}
register cmsUInt16Number Output[],
register const void* D)
{
-
+
cmsUInt8Number r, g, b;
- cmsS15Fixed16Number rx, ry, rz;
- cmsS15Fixed16Number c0, c1, c2, c3, Rest;
- int OutChan;
- register cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
+ cmsS15Fixed16Number rx, ry, rz;
+ cmsS15Fixed16Number c0, c1, c2, c3, Rest;
+ int OutChan;
+ register cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
Prelin8Data* p8 = (Prelin8Data*) D;
register const cmsInterpParams* p = p8 ->p;
int TotalOut = p -> nOutputs;
const cmsUInt16Number* LutTable = p -> Table;
-
+
r = Input[0] >> 8;
g = Input[1] >> 8;
b = Input[2] >> 8;
Y1 = Y0 + ((ry == 0) ? 0 : p ->opta[1]);
Z1 = Z0 + ((rz == 0) ? 0 : p ->opta[0]);
-
+
// These are the 6 Tetrahedral
for (OutChan=0; OutChan < TotalOut; OutChan++) {
{
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z0) - DENS(X1, Y0, Z0);
- c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
+ c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
}
else
if (rx >= rz && rz >= ry)
- {
+ {
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
c3 = DENS(X1, Y0, Z1) - DENS(X1, Y0, Z0);
{
c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
+ c3 = DENS(X0, Y0, Z1) - c0;
}
else
if (ry >= rx && rx >= rz)
{
c1 = DENS(X1, Y1, Z0) - DENS(X0, Y1, Z0);
c2 = DENS(X0, Y1, Z0) - c0;
- c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
+ c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
}
else
if (ry >= rz && rz >= rx)
{
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z0) - c0;
- c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
+ c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
}
else
if (rz >= ry && ry >= rx)
- {
+ {
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
- c3 = DENS(X0, Y0, Z1) - c0;
+ c3 = DENS(X0, Y0, Z1) - c0;
}
else {
- c1 = c2 = c3 = 0;
+ c1 = c2 = c3 = 0;
}
- Rest = c1 * rx + c2 * ry + c3 * rz;
+ Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
+ Output[OutChan] = (cmsUInt16Number)c0 + ((Rest + (Rest>>16))>>16);
- Output[OutChan] = (cmsUInt16Number)c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
-
}
}
#undef DENS
+
+// Curves that contain wide empty areas are not optimizeable
+static
+cmsBool IsDegenerated(const cmsToneCurve* g)
+{
+ int i, Zeros = 0, Poles = 0;
+ int nEntries = g ->nEntries;
+
+ for (i=0; i < nEntries; i++) {
+
+ if (g ->Table16[i] == 0x0000) Zeros++;
+ if (g ->Table16[i] == 0xffff) Poles++;
+ }
+
+ if (Zeros == 1 && Poles == 1) return FALSE; // For linear tables
+ if (Zeros > (nEntries / 4)) return TRUE; // Degenerated, mostly zeros
+ if (Poles > (nEntries / 4)) return TRUE; // Degenerated, mostly poles
+
+ return FALSE;
+}
+
// --------------------------------------------------------------------------------------------------------------
// We need xput over here
static
-cmsBool OptimizeByComputingLinearization(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
+cmsBool OptimizeByComputingLinearization(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
cmsPipeline* OriginalLut;
int nGridPoints;
cmsToneCurve *Trans[cmsMAXCHANNELS], *TransReverse[cmsMAXCHANNELS];
- cmsUInt32Number t, i;
+ cmsUInt32Number t, i;
cmsFloat32Number v, In[cmsMAXCHANNELS], Out[cmsMAXCHANNELS];
cmsBool lIsSuitable, lIsLinear;
- cmsPipeline* OptimizedLUT = NULL, *LutPlusCurves = NULL;
+ cmsPipeline* OptimizedLUT = NULL, *LutPlusCurves = NULL;
cmsStage* OptimizedCLUTmpe;
cmsColorSpaceSignature ColorSpace, OutputColorSpace;
cmsStage* OptimizedPrelinMpe;
+ cmsStage* mpe;
cmsToneCurve** OptimizedPrelinCurves;
_cmsStageCLutData* OptimizedPrelinCLUT;
}
OriginalLut = *Lut;
+
+ // Named color pipelines cannot be optimized either
+ for (mpe = cmsPipelineGetPtrToFirstStage(OriginalLut);
+ mpe != NULL;
+ mpe = cmsStageNext(mpe)) {
+ if (cmsStageType(mpe) == cmsSigNamedColorElemType) return FALSE;
+ }
+
ColorSpace = _cmsICCcolorSpace(T_COLORSPACE(*InputFormat));
OutputColorSpace = _cmsICCcolorSpace(T_COLORSPACE(*OutputFormat));
nGridPoints = _cmsReasonableGridpointsByColorspace(ColorSpace, *dwFlags);
}
// Slope-limit the obtained curves
- for (t = 0; t < OriginalLut ->InputChannels; t++)
+ for (t = 0; t < OriginalLut ->InputChannels; t++)
SlopeLimiting(Trans[t]);
// Check for validity
// Exclude if non-monotonic
if (!cmsIsToneCurveMonotonic(Trans[t]))
- lIsSuitable = FALSE;
+ lIsSuitable = FALSE;
+
+ if (IsDegenerated(Trans[t]))
+ lIsSuitable = FALSE;
}
// If it is not suitable, just quit
LutPlusCurves = cmsPipelineDup(OriginalLut);
if (LutPlusCurves == NULL) goto Error;
- cmsPipelineInsertStage(LutPlusCurves, cmsAT_BEGIN, cmsStageAllocToneCurves(OriginalLut ->ContextID, OriginalLut ->InputChannels, TransReverse));
+ if (!cmsPipelineInsertStage(LutPlusCurves, cmsAT_BEGIN, cmsStageAllocToneCurves(OriginalLut ->ContextID, OriginalLut ->InputChannels, TransReverse)))
+ goto Error;
// Create the result LUT
OptimizedLUT = cmsPipelineAlloc(OriginalLut ->ContextID, OriginalLut ->InputChannels, OriginalLut ->OutputChannels);
OptimizedPrelinMpe = cmsStageAllocToneCurves(OriginalLut ->ContextID, OriginalLut ->InputChannels, Trans);
- // Create and insert the curves at the beginning
- cmsPipelineInsertStage(OptimizedLUT, cmsAT_BEGIN, OptimizedPrelinMpe);
+ // Create and insert the curves at the beginning
+ if (!cmsPipelineInsertStage(OptimizedLUT, cmsAT_BEGIN, OptimizedPrelinMpe))
+ goto Error;
// Allocate the CLUT for result
OptimizedCLUTmpe = cmsStageAllocCLut16bit(OriginalLut ->ContextID, nGridPoints, OriginalLut ->InputChannels, OriginalLut ->OutputChannels, NULL);
// Add the CLUT to the destination LUT
- cmsPipelineInsertStage(OptimizedLUT, cmsAT_END, OptimizedCLUTmpe);
+ if (!cmsPipelineInsertStage(OptimizedLUT, cmsAT_END, OptimizedCLUTmpe))
+ goto Error;
// Resample the LUT
if (!cmsStageSampleCLut16bit(OptimizedCLUTmpe, XFormSampler16, (void*) LutPlusCurves, 0)) goto Error;
// Set the evaluator if 8-bit
if (_cmsFormatterIs8bit(*InputFormat)) {
- Prelin8Data* p8 = PrelinOpt8alloc(OptimizedLUT ->ContextID,
- OptimizedPrelinCLUT ->Params,
+ Prelin8Data* p8 = PrelinOpt8alloc(OptimizedLUT ->ContextID,
+ OptimizedPrelinCLUT ->Params,
OptimizedPrelinCurves);
if (p8 == NULL) return FALSE;
_cmsPipelineSetOptimizationParameters(OptimizedLUT, PrelinEval8, (void*) p8, Prelin8free, Prelin8dup);
- }
+ }
else
{
- Prelin16Data* p16 = PrelinOpt16alloc(OptimizedLUT ->ContextID,
- OptimizedPrelinCLUT ->Params,
+ Prelin16Data* p16 = PrelinOpt16alloc(OptimizedLUT ->ContextID,
+ OptimizedPrelinCLUT ->Params,
3, OptimizedPrelinCurves, 3, NULL);
if (p16 == NULL) return FALSE;
if (TransReverse[t]) cmsFreeToneCurve(TransReverse[t]);
}
- if (LutPlusCurves != NULL) cmsPipelineFree(LutPlusCurves);
+ if (LutPlusCurves != NULL) cmsPipelineFree(LutPlusCurves);
if (OptimizedLUT != NULL) cmsPipelineFree(OptimizedLUT);
- return FALSE;
+ return FALSE;
cmsUNUSED_PARAMETER(Intent);
}
static
void CurvesFree(cmsContext ContextID, void* ptr)
-{
+{
Curves16Data* Data = (Curves16Data*) ptr;
int i;
for (i=0; i < Data -> nCurves; i++) {
-
+
_cmsFree(ContextID, Data ->Curves[i]);
}
static
void* CurvesDup(cmsContext ContextID, const void* ptr)
-{
+{
Curves16Data* Data = _cmsDupMem(ContextID, ptr, sizeof(Curves16Data));
int i;
return (void*) Data;
}
-// Precomputes tables for 8-bit on input devicelink.
+// Precomputes tables for 8-bit on input devicelink.
static
Curves16Data* CurvesAlloc(cmsContext ContextID, int nCurves, int nElements, cmsToneCurve** G)
{
c16->Curves[i] = _cmsCalloc(ContextID, nElements, sizeof(cmsUInt16Number));
+ if (c16->Curves[i] == NULL) {
+
+ for (j=0; j < i; j++) {
+ _cmsFree(ContextID, c16->Curves[j]);
+ }
+ _cmsFree(ContextID, c16->Curves);
+ _cmsFree(ContextID, c16);
+ return NULL;
+ }
+
if (nElements == 256) {
for (j=0; j < nElements; j++) {
- c16 ->Curves[i][j] = cmsEvalToneCurve16(G[i], FROM_8_TO_16(j));
+ c16 ->Curves[i][j] = cmsEvalToneCurve16(G[i], FROM_8_TO_16(j));
}
}
else {
for (j=0; j < nElements; j++) {
- c16 ->Curves[i][j] = cmsEvalToneCurve16(G[i], (cmsUInt16Number) j);
+ c16 ->Curves[i][j] = cmsEvalToneCurve16(G[i], (cmsUInt16Number) j);
}
}
}
}
static
-void FastEvaluateCurves8(register const cmsUInt16Number In[],
- register cmsUInt16Number Out[],
+void FastEvaluateCurves8(register const cmsUInt16Number In[],
+ register cmsUInt16Number Out[],
register const void* D)
-{
+{
Curves16Data* Data = (Curves16Data*) D;
cmsUInt8Number x;
int i;
-
+
for (i=0; i < Data ->nCurves; i++) {
x = (In[i] >> 8);
}
}
-
+
static
-void FastEvaluateCurves16(register const cmsUInt16Number In[],
- register cmsUInt16Number Out[],
+void FastEvaluateCurves16(register const cmsUInt16Number In[],
+ register cmsUInt16Number Out[],
register const void* D)
-{
+{
Curves16Data* Data = (Curves16Data*) D;
int i;
-
+
for (i=0; i < Data ->nCurves; i++) {
Out[i] = Data -> Curves[i][In[i]];
}
static
-void FastIdentity16(register const cmsUInt16Number In[],
- register cmsUInt16Number Out[],
+void FastIdentity16(register const cmsUInt16Number In[],
+ register cmsUInt16Number Out[],
register const void* D)
{
cmsPipeline* Lut = (cmsPipeline*) D;
cmsUInt32Number i;
for (i=0; i < Lut ->InputChannels; i++) {
- Out[i] = In[i];
+ Out[i] = In[i];
}
}
static
cmsBool OptimizeByJoiningCurves(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
- cmsToneCurve** GammaTables = NULL;
+ cmsToneCurve** GammaTables = NULL;
cmsFloat32Number InFloat[cmsMAXCHANNELS], OutFloat[cmsMAXCHANNELS];
cmsUInt32Number i, j;
cmsPipeline* Src = *Lut;
if (cmsStageType(mpe) != cmsSigCurveSetElemType) return FALSE;
}
- // Allocate an empty LUT
+ // Allocate an empty LUT
Dest = cmsPipelineAlloc(Src ->ContextID, Src ->InputChannels, Src ->OutputChannels);
if (Dest == NULL) return FALSE;
// Compute 16 bit result by using floating point
for (i=0; i < PRELINEARIZATION_POINTS; i++) {
- for (j=0; j < Src ->InputChannels; j++)
+ for (j=0; j < Src ->InputChannels; j++)
InFloat[j] = (cmsFloat32Number) ((cmsFloat64Number) i / (PRELINEARIZATION_POINTS - 1));
cmsPipelineEvalFloat(InFloat, OutFloat, Src);
// Maybe the curves are linear at the end
if (!AllCurvesAreLinear(ObtainedCurves)) {
- cmsPipelineInsertStage(Dest, cmsAT_BEGIN, ObtainedCurves);
+ if (!cmsPipelineInsertStage(Dest, cmsAT_BEGIN, ObtainedCurves))
+ goto Error;
// If the curves are to be applied in 8 bits, we can save memory
if (_cmsFormatterIs8bit(*InputFormat)) {
_cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) ObtainedCurves ->Data;
Curves16Data* c16 = CurvesAlloc(Dest ->ContextID, Data ->nCurves, 256, Data ->TheCurves);
+ if (c16 == NULL) goto Error;
*dwFlags |= cmsFLAGS_NOCACHE;
_cmsPipelineSetOptimizationParameters(Dest, FastEvaluateCurves8, c16, CurvesFree, CurvesDup);
_cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) cmsStageData(ObtainedCurves);
Curves16Data* c16 = CurvesAlloc(Dest ->ContextID, Data ->nCurves, 65536, Data ->TheCurves);
+ if (c16 == NULL) goto Error;
*dwFlags |= cmsFLAGS_NOCACHE;
- _cmsPipelineSetOptimizationParameters(Dest, FastEvaluateCurves16, c16, CurvesFree, CurvesDup);
+ _cmsPipelineSetOptimizationParameters(Dest, FastEvaluateCurves16, c16, CurvesFree, CurvesDup);
}
}
else {
// LUT optimizes to nothing. Set the identity LUT
cmsStageFree(ObtainedCurves);
- cmsPipelineInsertStage(Dest, cmsAT_BEGIN, cmsStageAllocIdentity(Dest ->ContextID, Src ->InputChannels));
+ if (!cmsPipelineInsertStage(Dest, cmsAT_BEGIN, cmsStageAllocIdentity(Dest ->ContextID, Src ->InputChannels)))
+ goto Error;
*dwFlags |= cmsFLAGS_NOCACHE;
_cmsPipelineSetOptimizationParameters(Dest, FastIdentity16, (void*) Dest, NULL, NULL);
}
-// A fast matrix-shaper evaluator for 8 bits. This is a bit ticky since I'm using 1.14 signed fixed point
-// to accomplish some performance. Actually it takes 256x3 16 bits tables and 16385 x 3 tables of 8 bits,
+// A fast matrix-shaper evaluator for 8 bits. This is a bit ticky since I'm using 1.14 signed fixed point
+// to accomplish some performance. Actually it takes 256x3 16 bits tables and 16385 x 3 tables of 8 bits,
// in total about 50K, and the performance boost is huge!
static
-void MatShaperEval16(register const cmsUInt16Number In[],
- register cmsUInt16Number Out[],
+void MatShaperEval16(register const cmsUInt16Number In[],
+ register cmsUInt16Number Out[],
register const void* D)
-{
+{
MatShaper8Data* p = (MatShaper8Data*) D;
cmsS1Fixed14Number l1, l2, l3, r, g, b;
cmsUInt32Number ri, gi, bi;
- // In this case (and only in this case!) we can use this simplification since
+ // In this case (and only in this case!) we can use this simplification since
// In[] is assured to come from a 8 bit number. (a << 8 | a)
ri = In[0] & 0xFF;
gi = In[1] & 0xFF;
bi = In[2] & 0xFF;
-
+
// Across first shaper, which also converts to 1.14 fixed point
r = p->Shaper1R[ri];
g = p->Shaper1G[gi];
b = p->Shaper1B[bi];
-
+
// Evaluate the matrix in 1.14 fixed point
l1 = (p->Mat[0][0] * r + p->Mat[0][1] * g + p->Mat[0][2] * b + p->Off[0] + 0x2000) >> 14;
l2 = (p->Mat[1][0] * r + p->Mat[1][1] * g + p->Mat[1][2] * b + p->Off[1] + 0x2000) >> 14;
l3 = (p->Mat[2][0] * r + p->Mat[2][1] * g + p->Mat[2][2] * b + p->Off[2] + 0x2000) >> 14;
-
- // Now we have to clip to 0..1.0 range
- ri = (l1 < 0) ? 0 : ((l1 > 16384) ? 16384 : l1);
- gi = (l2 < 0) ? 0 : ((l2 > 16384) ? 16384 : l2);
- bi = (l3 < 0) ? 0 : ((l3 > 16384) ? 16384 : l3);
-
- // And across second shaper,
+
+ // Now we have to clip to 0..1.0 range
+ ri = (l1 < 0) ? 0 : ((l1 > 16384) ? 16384 : l1);
+ gi = (l2 < 0) ? 0 : ((l2 > 16384) ? 16384 : l2);
+ bi = (l3 < 0) ? 0 : ((l3 > 16384) ? 16384 : l3);
+
+ // And across second shaper,
Out[0] = p->Shaper2R[ri];
Out[1] = p->Shaper2G[gi];
Out[2] = p->Shaper2B[bi];
-
+
}
// This table converts from 8 bits to 1.14 after applying the curve
cmsFloat32Number R, y;
for (i=0; i < 256; i++) {
-
+
R = (cmsFloat32Number) (i / 255.0);
- y = cmsEvalToneCurveFloat(Curve, R);
+ y = cmsEvalToneCurveFloat(Curve, R);
Table[i] = DOUBLE_TO_1FIXED14(y);
}
R = (cmsFloat32Number) (i / 16384.0);
Val = cmsEvalToneCurveFloat(Curve, R); // Val comes 0..1.0
-
+
if (Is8BitsOutput) {
// If 8 bits output, we can optimize further by computing the / 257 part.
// first we compute the resulting byte and then we store the byte times
// 257. This quantization allows to round very quick by doing a >> 8, but
// since the low byte is always equal to msb, we can do a & 0xff and this works!
- cmsUInt16Number w = _cmsQuickSaturateWord(Val * 65535.0 + 0.5);
+ cmsUInt16Number w = _cmsQuickSaturateWord(Val * 65535.0);
cmsUInt8Number b = FROM_16_TO_8(w);
Table[i] = FROM_8_TO_16(b);
}
- else Table[i] = _cmsQuickSaturateWord(Val * 65535.0 + 0.5);
+ else Table[i] = _cmsQuickSaturateWord(Val * 65535.0);
}
}
// Convert matrix to nFixed14. Note that those values may take more than 16 bits as
for (i=0; i < 3; i++) {
- for (j=0; j < 3; j++) {
+ for (j=0; j < 3; j++) {
p ->Mat[i][j] = DOUBLE_TO_1FIXED14(Mat->v[i].n[j]);
}
}
-
+
for (i=0; i < 3; i++) {
- if (Off == NULL) {
+ if (Off == NULL) {
p ->Off[i] = 0;
}
- else {
+ else {
p ->Off[i] = DOUBLE_TO_1FIXED14(Off->n[i]);
}
}
if (Is8Bits)
*OutputFormat |= OPTIMIZED_SH(1);
- // Fill function pointers
+ // Fill function pointers
_cmsPipelineSetOptimizationParameters(Dest, MatShaperEval16, (void*) p, FreeMatShaper, DupMatShaper);
return TRUE;
}
cmsMAT3 res;
cmsBool IdentityMat;
cmsPipeline* Dest, *Src;
-
+
// Only works on RGB to RGB
if (T_CHANNELS(*InputFormat) != 3 || T_CHANNELS(*OutputFormat) != 3) return FALSE;
Src = *Lut;
// Check for shaper-matrix-matrix-shaper structure, that is what this optimizer stands for
- if (!cmsPipelineCheckAndRetreiveStages(Src, 4,
- cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType,
+ if (!cmsPipelineCheckAndRetreiveStages(Src, 4,
+ cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType,
&Curve1, &Matrix1, &Matrix2, &Curve2)) return FALSE;
// Get both matrices
IdentityMat = TRUE;
}
- // Allocate an empty LUT
+ // Allocate an empty LUT
Dest = cmsPipelineAlloc(Src ->ContextID, Src ->InputChannels, Src ->OutputChannels);
if (!Dest) return FALSE;
// Assamble the new LUT
- cmsPipelineInsertStage(Dest, cmsAT_BEGIN, cmsStageDup(Curve1));
- if (!IdentityMat)
- cmsPipelineInsertStage(Dest, cmsAT_END, cmsStageAllocMatrix(Dest ->ContextID, 3, 3, (const cmsFloat64Number*) &res, Data2 ->Offset));
- cmsPipelineInsertStage(Dest, cmsAT_END, cmsStageDup(Curve2));
+ if (!cmsPipelineInsertStage(Dest, cmsAT_BEGIN, cmsStageDup(Curve1)))
+ goto Error;
+
+ if (!IdentityMat)
+ if (!cmsPipelineInsertStage(Dest, cmsAT_END, cmsStageAllocMatrix(Dest ->ContextID, 3, 3, (const cmsFloat64Number*) &res, Data2 ->Offset)))
+ goto Error;
+ if (!cmsPipelineInsertStage(Dest, cmsAT_END, cmsStageDup(Curve2)))
+ goto Error;
// If identity on matrix, we can further optimize the curves, so call the join curves routine
if (IdentityMat) {
- OptimizeByJoiningCurves(&Dest, Intent, InputFormat, OutputFormat, dwFlags);
+ OptimizeByJoiningCurves(&Dest, Intent, InputFormat, OutputFormat, dwFlags);
}
else {
_cmsStageToneCurvesData* mpeC1 = (_cmsStageToneCurvesData*) cmsStageData(Curve1);
_cmsStageToneCurvesData* mpeC2 = (_cmsStageToneCurvesData*) cmsStageData(Curve2);
-
- // In this particular optimization, caché does not help as it takes more time to deal with
+
+ // In this particular optimization, caché does not help as it takes more time to deal with
// the caché that with the pixel handling
*dwFlags |= cmsFLAGS_NOCACHE;
cmsPipelineFree(Src);
*Lut = Dest;
return TRUE;
+Error:
+ // Leave Src unchanged
+ cmsPipelineFree(Dest);
+ return FALSE;
}
// List of optimizations
typedef struct _cmsOptimizationCollection_st {
-
+
_cmsOPToptimizeFn OptimizePtr;
-
+
struct _cmsOptimizationCollection_st *Next;
} _cmsOptimizationCollection;
};
// The linked list head
-static _cmsOptimizationCollection* OptimizationCollection = DefaultOptimization;
+_cmsOptimizationPluginChunkType _cmsOptimizationPluginChunk = { NULL };
+
+
+// Duplicates the zone of memory used by the plug-in in the new context
+static
+void DupPluginOptimizationList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ _cmsOptimizationPluginChunkType newHead = { NULL };
+ _cmsOptimizationCollection* entry;
+ _cmsOptimizationCollection* Anterior = NULL;
+ _cmsOptimizationPluginChunkType* head = (_cmsOptimizationPluginChunkType*) src->chunks[OptimizationPlugin];
+
+ _cmsAssert(ctx != NULL);
+ _cmsAssert(head != NULL);
+
+ // Walk the list copying all nodes
+ for (entry = head->OptimizationCollection;
+ entry != NULL;
+ entry = entry ->Next) {
+
+ _cmsOptimizationCollection *newEntry = ( _cmsOptimizationCollection *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(_cmsOptimizationCollection));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.OptimizationCollection == NULL)
+ newHead.OptimizationCollection = newEntry;
+ }
+
+ ctx ->chunks[OptimizationPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsOptimizationPluginChunkType));
+}
+
+void _cmsAllocOptimizationPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ if (src != NULL) {
+
+ // Copy all linked list
+ DupPluginOptimizationList(ctx, src);
+ }
+ else {
+ static _cmsOptimizationPluginChunkType OptimizationPluginChunkType = { NULL };
+ ctx ->chunks[OptimizationPlugin] = _cmsSubAllocDup(ctx ->MemPool, &OptimizationPluginChunkType, sizeof(_cmsOptimizationPluginChunkType));
+ }
+}
+
// Register new ways to optimize
-cmsBool _cmsRegisterOptimizationPlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterOptimizationPlugin(cmsContext ContextID, cmsPluginBase* Data)
{
cmsPluginOptimization* Plugin = (cmsPluginOptimization*) Data;
+ _cmsOptimizationPluginChunkType* ctx = ( _cmsOptimizationPluginChunkType*) _cmsContextGetClientChunk(ContextID, OptimizationPlugin);
_cmsOptimizationCollection* fl;
-
+
if (Data == NULL) {
- OptimizationCollection = DefaultOptimization;
+ ctx->OptimizationCollection = NULL;
return TRUE;
}
-
+
// Optimizer callback is required
if (Plugin ->OptimizePtr == NULL) return FALSE;
- fl = (_cmsOptimizationCollection*) _cmsPluginMalloc(sizeof(_cmsOptimizationCollection));
+ fl = (_cmsOptimizationCollection*) _cmsPluginMalloc(ContextID, sizeof(_cmsOptimizationCollection));
if (fl == NULL) return FALSE;
// Copy the parameters
fl ->OptimizePtr = Plugin ->OptimizePtr;
-
+
// Keep linked list
- fl ->Next = OptimizationCollection;
- OptimizationCollection = fl;
+ fl ->Next = ctx->OptimizationCollection;
+
+ // Set the head
+ ctx ->OptimizationCollection = fl;
// All is ok
return TRUE;
}
// The entry point for LUT optimization
-cmsBool _cmsOptimizePipeline(cmsPipeline** PtrLut,
+cmsBool _cmsOptimizePipeline(cmsContext ContextID,
+ cmsPipeline** PtrLut,
int Intent,
- cmsUInt32Number* InputFormat,
+ cmsUInt32Number* InputFormat,
cmsUInt32Number* OutputFormat,
cmsUInt32Number* dwFlags)
-{
+{
+ _cmsOptimizationPluginChunkType* ctx = ( _cmsOptimizationPluginChunkType*) _cmsContextGetClientChunk(ContextID, OptimizationPlugin);
_cmsOptimizationCollection* Opts;
cmsBool AnySuccess = FALSE;
-
+
// A CLUT is being asked, so force this specific optimization
if (*dwFlags & cmsFLAGS_FORCE_CLUT) {
-
+
PreOptimize(*PtrLut);
return OptimizeByResampling(PtrLut, Intent, InputFormat, OutputFormat, dwFlags);
}
// Anything to optimize?
if ((*PtrLut) ->Elements == NULL) {
_cmsPipelineSetOptimizationParameters(*PtrLut, FastIdentity16, (void*) *PtrLut, NULL, NULL);
- return TRUE;
+ return TRUE;
}
// Try to get rid of identities and trivial conversions.
// Do not optimize, keep all precision
if (*dwFlags & cmsFLAGS_NOOPTIMIZE)
return FALSE;
-
- // Try built-in optimizations and plug-in
- for (Opts = OptimizationCollection;
+
+ // Try plug-in optimizations
+ for (Opts = ctx->OptimizationCollection;
Opts != NULL;
Opts = Opts ->Next) {
-
+
// If one schema succeeded, we are done
if (Opts ->OptimizePtr(PtrLut, Intent, InputFormat, OutputFormat, dwFlags)) {
-
+
return TRUE; // Optimized!
}
}
-
+
+ // Try built-in optimizations
+ for (Opts = DefaultOptimization;
+ Opts != NULL;
+ Opts = Opts ->Next) {
+
+ if (Opts ->OptimizePtr(PtrLut, Intent, InputFormat, OutputFormat, dwFlags)) {
+
+ return TRUE;
+ }
+ }
+
// Only simple optimizations succeeded
return AnySuccess;
}
// Little Color Management System
// Copyright (c) 1998-2010 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
#include "lcms2_internal.h"
-// This module handles all formats supported by lcms. There are two flavors, 16 bits and
+// This module handles all formats supported by lcms. There are two flavors, 16 bits and
// floating point. Floating point is supported only in a subset, those formats holding
-// cmsFloat32Number (4 bytes per component) and double (marked as 0 bytes per component as special
-// case)
+// cmsFloat32Number (4 bytes per component) and double (marked as 0 bytes per component
+// as special case)
// ---------------------------------------------------------------------------
#define REVERSE_FLAVOR_16(x) ((cmsUInt16Number)(0xffff-(x)))
// * 0xffff / 0xff00 = (255 * 257) / (255 * 256) = 257 / 256
-cmsINLINE cmsUInt16Number FomLabV2ToLabV4(cmsUInt16Number x)
+cmsINLINE cmsUInt16Number FomLabV2ToLabV4(cmsUInt16Number x)
{
- int a;
-
- a = (x << 8 | x) >> 8; // * 257 / 256
+ int a = (x << 8 | x) >> 8; // * 257 / 256
if ( a > 0xffff) return 0xffff;
return (cmsUInt16Number) a;
}
// * 0xf00 / 0xffff = * 256 / 257
-cmsINLINE cmsUInt16Number FomLabV4ToLabV2(cmsUInt16Number x)
+cmsINLINE cmsUInt16Number FomLabV4ToLabV2(cmsUInt16Number x)
{
return (cmsUInt16Number) (((x << 8) + 0x80) / 257);
}
typedef struct {
cmsUInt32Number Type;
cmsUInt32Number Mask;
- cmsFormatter16 Frm;
+ cmsFormatter16 Frm;
} cmsFormatters16;
typedef struct {
cmsUInt32Number Type;
cmsUInt32Number Mask;
- cmsFormatterFloat Frm;
+ cmsFormatterFloat Frm;
} cmsFormattersFloat;
+
#define ANYSPACE COLORSPACE_SH(31)
#define ANYCHANNELS CHANNELS_SH(15)
#define ANYEXTRA EXTRA_SH(7)
#define ANYPLANAR PLANAR_SH(1)
#define ANYENDIAN ENDIAN16_SH(1)
#define ANYSWAP DOSWAP_SH(1)
-#define ANYSWAPFIRST SWAPFIRST_SH(1)
+#define ANYSWAPFIRST SWAPFIRST_SH(1)
#define ANYFLAVOR FLAVOR_SH(1)
#pragma warning(disable : 4100)
#endif
-// Unpacking routines (16 bits) ----------------------------------------------------------------------------------------
+// Unpacking routines (16 bits) ----------------------------------------------------------------------------------------
+
// Does almost everything but is slow
static
-cmsUInt8Number* UnrollChunkyBytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollChunkyBytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
int Reverse = T_FLAVOR(info ->InputFormat);
int SwapFirst = T_SWAPFIRST(info -> InputFormat);
int Extra = T_EXTRA(info -> InputFormat);
- int ExtraFirst = DoSwap && !SwapFirst;
+ int ExtraFirst = DoSwap ^ SwapFirst;
cmsUInt16Number v;
int i;
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
- v = FROM_8_TO_16(*accum);
+ v = FROM_8_TO_16(*accum);
v = Reverse ? REVERSE_FLAVOR_16(v) : v;
wIn[index] = v;
- accum++;
+ accum++;
}
if (!ExtraFirst) {
}
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
+
}
// Extra channels are just ignored because come in the next planes
static
-cmsUInt8Number* UnrollPlanarBytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollPlanarBytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
- int nChan = T_CHANNELS(info -> InputFormat);
- int DoSwap= T_DOSWAP(info ->InputFormat);
- int Reverse= T_FLAVOR(info ->InputFormat);
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
int i;
cmsUInt8Number* Init = accum;
- if (DoSwap) {
+ if (DoSwap ^ SwapFirst) {
accum += T_EXTRA(info -> InputFormat) * Stride;
}
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
- cmsUInt16Number v = FROM_8_TO_16(*accum);
+ cmsUInt16Number v = FROM_8_TO_16(*accum);
wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
accum += Stride;
// Special cases, provided for performance
static
-cmsUInt8Number* Unroll4Bytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4Bytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[3] = FROM_8_TO_16(*accum); accum++; // K
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll4BytesReverse(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4BytesReverse(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[3] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // K
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll4BytesSwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4BytesSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// KYMC
static
-cmsUInt8Number* Unroll4BytesSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4BytesSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = FROM_8_TO_16(*accum); accum++; // C
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[3] = FROM_8_TO_16(*accum); accum++; // C
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll3Bytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3Bytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = FROM_8_TO_16(*accum); accum++; // B
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll3BytesSkip1Swap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3BytesSkip1Swap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = FROM_8_TO_16(*accum); accum++; // R
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
+}
+
+static
+cmsUInt8Number* Unroll3BytesSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
+{
+ wIn[2] = FROM_8_TO_16(*accum); accum++; // B
+ wIn[1] = FROM_8_TO_16(*accum); accum++; // G
+ wIn[0] = FROM_8_TO_16(*accum); accum++; // R
+ accum++; // A
+
+ return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
wIn[2] = FROM_8_TO_16(*accum); accum++; // B
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// BRG
static
-cmsUInt8Number* Unroll3BytesSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3BytesSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = FROM_8_TO_16(*accum); accum++; // R
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* UnrollLabV2_8(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollLabV2_8(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* UnrollALabV2_8(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollALabV2_8(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* UnrollLabV2_16(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollLabV2_16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // b
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// for duplex
static
-cmsUInt8Number* Unroll2Bytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
- register cmsUInt8Number* accum,
- register cmsUInt32Number Stride)
+cmsUInt8Number* Unroll2Bytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
{
wIn[0] = FROM_8_TO_16(*accum); accum++; // ch1
wIn[1] = FROM_8_TO_16(*accum); accum++; // ch2
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// Monochrome duplicates L into RGB for null-transforms
static
-cmsUInt8Number* Unroll1Byte(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
- register cmsUInt8Number* accum,
- register cmsUInt32Number Stride)
+cmsUInt8Number* Unroll1Byte(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
{
- wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
+ wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll1ByteSkip1(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
- register cmsUInt8Number* accum,
- register cmsUInt32Number Stride)
+cmsUInt8Number* Unroll1ByteSkip1(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
{
wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
accum += 1;
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll1ByteSkip2(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll1ByteSkip2(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
accum += 2;
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll1ByteReversed(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll1ByteReversed(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(FROM_8_TO_16(*accum)); accum++; // L
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* UnrollAnyWords(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollAnyWords(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
int Reverse = T_FLAVOR(info ->InputFormat);
int SwapFirst = T_SWAPFIRST(info -> InputFormat);
int Extra = T_EXTRA(info -> InputFormat);
- int ExtraFirst = DoSwap && !SwapFirst;
+ int ExtraFirst = DoSwap ^ SwapFirst;
int i;
if (ExtraFirst) {
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
- cmsUInt16Number v = *(cmsUInt16Number*) accum;
+ cmsUInt16Number v = *(cmsUInt16Number*) accum;
if (SwapEndian)
v = CHANGE_ENDIAN(v);
wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
- accum += sizeof(cmsUInt16Number);
+ accum += sizeof(cmsUInt16Number);
}
if (!ExtraFirst) {
}
return accum;
+
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* UnrollPlanarWords(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollPlanarWords(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
- cmsUInt16Number v = *(cmsUInt16Number*) accum;
+ cmsUInt16Number v = *(cmsUInt16Number*) accum;
if (SwapEndian)
v = CHANGE_ENDIAN(v);
wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
- accum += Stride * sizeof(cmsUInt16Number);
+ accum += Stride * sizeof(cmsUInt16Number);
}
return (Init + sizeof(cmsUInt16Number));
static
-cmsUInt8Number* Unroll4Words(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4Words(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll4WordsReverse(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4WordsReverse(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[3] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // K
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll4WordsSwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4WordsSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// KYMC
static
-cmsUInt8Number* Unroll4WordsSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4WordsSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll4WordsSwapSwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll4WordsSwapSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // C
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll3Words(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3Words(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C R
wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G
wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y B
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll3WordsSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3WordsSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // C R
wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G
wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // Y B
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll3WordsSkip1Swap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3WordsSkip1Swap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // B
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll3WordsSkip1SwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll3WordsSkip1SwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // B
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll1Word(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll1Word(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // L
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll1WordReversed(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll1WordReversed(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2;
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll1WordSkip3(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* Unroll1WordSkip3(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
- wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum;
+ wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum;
accum += 8;
+
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Unroll2Words(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
- register cmsUInt8Number* accum,
- register cmsUInt32Number Stride)
+cmsUInt8Number* Unroll2Words(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
{
wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // ch1
wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // ch2
return accum;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// This is a conversion of Lab double to 16 bits
static
-cmsUInt8Number* UnrollLabDoubleTo16(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollLabDoubleTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
-{
+{
if (T_PLANAR(info -> InputFormat)) {
cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
}
}
+
+// This is a conversion of Lab float to 16 bits
+static
+cmsUInt8Number* UnrollLabFloatTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
+{
+ cmsCIELab Lab;
+
+ if (T_PLANAR(info -> InputFormat)) {
+
+ cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
+
+
+ Lab.L = Pt[0];
+ Lab.a = Pt[Stride];
+ Lab.b = Pt[Stride*2];
+
+ cmsFloat2LabEncoded(wIn, &Lab);
+ return accum + sizeof(cmsFloat32Number);
+ }
+ else {
+
+ Lab.L = ((cmsFloat32Number*) accum)[0];
+ Lab.a = ((cmsFloat32Number*) accum)[1];
+ Lab.b = ((cmsFloat32Number*) accum)[2];
+
+ cmsFloat2LabEncoded(wIn, &Lab);
+ accum += (3 + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat32Number);
+ return accum;
+ }
+}
+
// This is a conversion of XYZ double to 16 bits
static
-cmsUInt8Number* UnrollXYZDoubleTo16(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollXYZDoubleTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
-{
+{
if (T_PLANAR(info -> InputFormat)) {
cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
}
}
+// This is a conversion of XYZ float to 16 bits
+static
+cmsUInt8Number* UnrollXYZFloatTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
+{
+ if (T_PLANAR(info -> InputFormat)) {
+
+ cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
+ cmsCIEXYZ XYZ;
+
+ XYZ.X = Pt[0];
+ XYZ.Y = Pt[Stride];
+ XYZ.Z = Pt[Stride*2];
+ cmsFloat2XYZEncoded(wIn, &XYZ);
+
+ return accum + sizeof(cmsFloat32Number);
+
+ }
+
+ else {
+ cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
+ cmsCIEXYZ XYZ;
+
+ XYZ.X = Pt[0];
+ XYZ.Y = Pt[1];
+ XYZ.Z = Pt[2];
+ cmsFloat2XYZEncoded(wIn, &XYZ);
+
+ accum += 3 * sizeof(cmsFloat32Number) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat32Number);
+
+ return accum;
+ }
+}
+
// Check if space is marked as ink
cmsINLINE cmsBool IsInkSpace(cmsUInt32Number Type)
{
switch (T_COLORSPACE(Type)) {
- case PT_CMY:
- case PT_CMYK:
- case PT_MCH5:
+ case PT_CMY:
+ case PT_CMYK:
+ case PT_MCH5:
case PT_MCH6:
- case PT_MCH7:
- case PT_MCH8:
- case PT_MCH9:
- case PT_MCH10:
- case PT_MCH11:
- case PT_MCH12:
- case PT_MCH13:
- case PT_MCH14:
+ case PT_MCH7:
+ case PT_MCH8:
+ case PT_MCH9:
+ case PT_MCH10:
+ case PT_MCH11:
+ case PT_MCH12:
+ case PT_MCH13:
+ case PT_MCH14:
case PT_MCH15: return TRUE;
default: return FALSE;
// Inks does come in percentage, remaining cases are between 0..1.0, again to 16 bits
static
-cmsUInt8Number* UnrollDoubleTo16(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
- register cmsUInt8Number* accum,
- register cmsUInt32Number Stride)
+cmsUInt8Number* UnrollDoubleTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
{
- cmsFloat64Number* Inks = (cmsFloat64Number*) accum;
- int nChan = T_CHANNELS(info -> InputFormat);
- int Planar = T_PLANAR(info -> InputFormat);
- int i;
+
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> InputFormat);
+ int Extra = T_EXTRA(info -> InputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ int Planar = T_PLANAR(info -> InputFormat);
cmsFloat64Number v;
- cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0;
+ cmsUInt16Number vi;
+ int i, start = 0;
+ cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0;
+
+
+ if (ExtraFirst)
+ start = Extra;
for (i=0; i < nChan; i++) {
- if (Planar)
+ int index = DoSwap ? (nChan - i - 1) : i;
- v = Inks[i * Stride];
+ if (Planar)
+ v = (cmsFloat32Number) ((cmsFloat64Number*) accum)[(i + start) * Stride];
else
- v = Inks[i];
+ v = (cmsFloat32Number) ((cmsFloat64Number*) accum)[i + start];
+
+ vi = _cmsQuickSaturateWord(v * maximum);
+
+ if (Reverse)
+ vi = REVERSE_FLAVOR_16(vi);
- wIn[i] = _cmsQuickSaturateWord(v * maximum);
+ wIn[index] = vi;
+ }
+
+
+ if (Extra == 0 && SwapFirst) {
+ cmsUInt16Number tmp = wIn[0];
+
+ memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
+ wIn[nChan-1] = tmp;
}
if (T_PLANAR(info -> InputFormat))
return accum + sizeof(cmsFloat64Number);
else
- return accum + (nChan + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat64Number);
+ return accum + (nChan + Extra) * sizeof(cmsFloat64Number);
}
+
+
static
-cmsUInt8Number* UnrollFloatTo16(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollFloatTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
- cmsFloat32Number* Inks = (cmsFloat32Number*) accum;
- int nChan = T_CHANNELS(info -> InputFormat);
- int Planar = T_PLANAR(info -> InputFormat);
- int i;
+
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> InputFormat);
+ int Extra = T_EXTRA(info -> InputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ int Planar = T_PLANAR(info -> InputFormat);
cmsFloat32Number v;
- cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0;
+ cmsUInt16Number vi;
+ int i, start = 0;
+ cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0;
+
+
+ if (ExtraFirst)
+ start = Extra;
for (i=0; i < nChan; i++) {
- if (Planar)
+ int index = DoSwap ? (nChan - i - 1) : i;
- v = Inks[i * Stride];
+ if (Planar)
+ v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[(i + start) * Stride];
else
- v = Inks[i];
+ v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[i + start];
+
+ vi = _cmsQuickSaturateWord(v * maximum);
+
+ if (Reverse)
+ vi = REVERSE_FLAVOR_16(vi);
+
+ wIn[index] = vi;
+ }
+
- wIn[i] = _cmsQuickSaturateWord(v * maximum);
+ if (Extra == 0 && SwapFirst) {
+ cmsUInt16Number tmp = wIn[0];
+
+ memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
+ wIn[nChan-1] = tmp;
}
if (T_PLANAR(info -> InputFormat))
return accum + sizeof(cmsFloat32Number);
else
- return accum + (nChan + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat32Number);
+ return accum + (nChan + Extra) * sizeof(cmsFloat32Number);
}
+
+
// For 1 channel, we need to duplicate data (it comes in 0..1.0 range)
static
-cmsUInt8Number* UnrollDouble1Chan(register _cmsTRANSFORM* info,
- register cmsUInt16Number wIn[],
+cmsUInt8Number* UnrollDouble1Chan(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
register cmsUInt8Number* accum,
register cmsUInt32Number Stride)
{
wIn[0] = wIn[1] = wIn[2] = _cmsQuickSaturateWord(Inks[0] * 65535.0);
- return accum + sizeof(cmsFloat64Number);
+ return accum + sizeof(cmsFloat64Number);
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
//-------------------------------------------------------------------------------------------------------------------
-// True float transformation.
-
-// For anything going from cmsFloat32Number
+// For anything going from cmsFloat32Number
static
-cmsUInt8Number* UnrollFloatsToFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wIn[],
+cmsUInt8Number* UnrollFloatsToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
cmsUInt8Number* accum,
cmsUInt32Number Stride)
{
- cmsFloat32Number* Inks = (cmsFloat32Number*) accum;
- int nChan = T_CHANNELS(info -> InputFormat);
- int Planar = T_PLANAR(info -> InputFormat);
- int i;
- cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 100.0 : 1.0;
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> InputFormat);
+ int Extra = T_EXTRA(info -> InputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ int Planar = T_PLANAR(info -> InputFormat);
+ cmsFloat32Number v;
+ int i, start = 0;
+ cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 100.0F : 1.0F;
+
+
+ if (ExtraFirst)
+ start = Extra;
+
+ for (i=0; i < nChan; i++) {
- for (i=0; i < nChan; i++) {
+ int index = DoSwap ? (nChan - i - 1) : i;
if (Planar)
- wIn[i] = (cmsFloat32Number) (Inks[i * Stride] / maximum);
+ v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[(i + start) * Stride];
else
- wIn[i] = (cmsFloat32Number) (Inks[i] / maximum);
+ v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[i + start];
+
+ v /= maximum;
+
+ wIn[index] = Reverse ? 1 - v : v;
+ }
+
+
+ if (Extra == 0 && SwapFirst) {
+ cmsFloat32Number tmp = wIn[0];
+
+ memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number));
+ wIn[nChan-1] = tmp;
}
if (T_PLANAR(info -> InputFormat))
return accum + sizeof(cmsFloat32Number);
else
- return accum + (nChan + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat32Number);
+ return accum + (nChan + Extra) * sizeof(cmsFloat32Number);
}
// For anything going from double
+
static
-cmsUInt8Number* UnrollDoublesToFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wIn[],
- cmsUInt8Number* accum,
- cmsUInt32Number Stride)
+cmsUInt8Number* UnrollDoublesToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
+ cmsUInt8Number* accum,
+ cmsUInt32Number Stride)
{
- cmsFloat64Number* Inks = (cmsFloat64Number*) accum;
- int nChan = T_CHANNELS(info -> InputFormat);
- int Planar = T_PLANAR(info -> InputFormat);
- int i;
+
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> InputFormat);
+ int Extra = T_EXTRA(info -> InputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ int Planar = T_PLANAR(info -> InputFormat);
+ cmsFloat64Number v;
+ int i, start = 0;
cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 100.0 : 1.0;
- for (i=0; i < nChan; i++) {
+
+ if (ExtraFirst)
+ start = Extra;
+
+ for (i=0; i < nChan; i++) {
+
+ int index = DoSwap ? (nChan - i - 1) : i;
if (Planar)
- wIn[i] = (cmsFloat32Number) (Inks[i * Stride] / maximum);
+ v = (cmsFloat64Number) ((cmsFloat64Number*) accum)[(i + start) * Stride];
else
- wIn[i] = (cmsFloat32Number) (Inks[i] / maximum);
+ v = (cmsFloat64Number) ((cmsFloat64Number*) accum)[i + start];
+
+ v /= maximum;
+
+ wIn[index] = (cmsFloat32Number) (Reverse ? 1.0 - v : v);
+ }
+
+
+ if (Extra == 0 && SwapFirst) {
+ cmsFloat32Number tmp = wIn[0];
+
+ memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number));
+ wIn[nChan-1] = tmp;
}
if (T_PLANAR(info -> InputFormat))
return accum + sizeof(cmsFloat64Number);
else
- return accum + (nChan + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat64Number);
+ return accum + (nChan + Extra) * sizeof(cmsFloat64Number);
}
+
// From Lab double to cmsFloat32Number
static
-cmsUInt8Number* UnrollLabDoubleToFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wIn[],
+cmsUInt8Number* UnrollLabDoubleToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
cmsUInt8Number* accum,
cmsUInt32Number Stride)
-{
+{
cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
if (T_PLANAR(info -> InputFormat)) {
- wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
+ wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
wIn[1] = (cmsFloat32Number) ((Pt[Stride] + 128) / 255.0); // form -128..+127 to 0..1
wIn[2] = (cmsFloat32Number) ((Pt[Stride*2] + 128) / 255.0);
}
else {
- wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
+ wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
wIn[1] = (cmsFloat32Number) ((Pt[1] + 128) / 255.0); // form -128..+127 to 0..1
wIn[2] = (cmsFloat32Number) ((Pt[2] + 128) / 255.0);
// From Lab double to cmsFloat32Number
static
-cmsUInt8Number* UnrollLabFloatToFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wIn[],
+cmsUInt8Number* UnrollLabFloatToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
cmsUInt8Number* accum,
cmsUInt32Number Stride)
-{
+{
cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
if (T_PLANAR(info -> InputFormat)) {
- wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
+ wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
wIn[1] = (cmsFloat32Number) ((Pt[Stride] + 128) / 255.0); // form -128..+127 to 0..1
wIn[2] = (cmsFloat32Number) ((Pt[Stride*2] + 128) / 255.0);
}
else {
- wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
+ wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
wIn[1] = (cmsFloat32Number) ((Pt[1] + 128) / 255.0); // form -128..+127 to 0..1
wIn[2] = (cmsFloat32Number) ((Pt[2] + 128) / 255.0);
}
+
// 1.15 fixed point, that means maximum value is MAX_ENCODEABLE_XYZ (0xFFFF)
static
-cmsUInt8Number* UnrollXYZDoubleToFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wIn[],
+cmsUInt8Number* UnrollXYZDoubleToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
cmsUInt8Number* accum,
cmsUInt32Number Stride)
-{
+{
cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
if (T_PLANAR(info -> InputFormat)) {
- wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
- wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ);
+ wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
+ wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ);
wIn[2] = (cmsFloat32Number) (Pt[Stride*2] / MAX_ENCODEABLE_XYZ);
return accum + sizeof(cmsFloat64Number);
}
else {
- wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
- wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ);
+ wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
+ wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ);
wIn[2] = (cmsFloat32Number) (Pt[2] / MAX_ENCODEABLE_XYZ);
accum += sizeof(cmsFloat64Number)*(3 + T_EXTRA(info ->InputFormat));
}
static
-cmsUInt8Number* UnrollXYZFloatToFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wIn[],
+cmsUInt8Number* UnrollXYZFloatToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
cmsUInt8Number* accum,
cmsUInt32Number Stride)
-{
+{
cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
if (T_PLANAR(info -> InputFormat)) {
- wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
- wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ);
+ wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
+ wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ);
wIn[2] = (cmsFloat32Number) (Pt[Stride*2] / MAX_ENCODEABLE_XYZ);
return accum + sizeof(cmsFloat32Number);
}
else {
- wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
- wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ);
+ wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
+ wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ);
wIn[2] = (cmsFloat32Number) (Pt[2] / MAX_ENCODEABLE_XYZ);
accum += sizeof(cmsFloat32Number)*(3 + T_EXTRA(info ->InputFormat));
}
}
+
+
// Packing routines -----------------------------------------------------------------------------------------------------------
// Generic chunky for byte
static
-cmsUInt8Number* PackAnyBytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackAnyBytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
int Reverse = T_FLAVOR(info ->OutputFormat);
int Extra = T_EXTRA(info -> OutputFormat);
int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
- int ExtraFirst = DoSwap && !SwapFirst;
+ int ExtraFirst = DoSwap ^ SwapFirst;
cmsUInt8Number* swap1;
cmsUInt8Number v = 0;
int i;
return output;
+
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* PackAnyWords(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackAnyWords(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
int Reverse = T_FLAVOR(info ->OutputFormat);
int Extra = T_EXTRA(info -> OutputFormat);
int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
- int ExtraFirst = DoSwap && !SwapFirst;
+ int ExtraFirst = DoSwap ^ SwapFirst;
cmsUInt16Number* swap1;
cmsUInt16Number v = 0;
int i;
return output;
+
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* PackPlanarBytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackPlanarBytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
- int nChan = T_CHANNELS(info -> OutputFormat);
- int DoSwap = T_DOSWAP(info ->OutputFormat);
- int Reverse= T_FLAVOR(info ->OutputFormat);
+ int nChan = T_CHANNELS(info -> OutputFormat);
+ int DoSwap = T_DOSWAP(info ->OutputFormat);
+ int SwapFirst = T_SWAPFIRST(info ->OutputFormat);
+ int Reverse = T_FLAVOR(info ->OutputFormat);
int i;
cmsUInt8Number* Init = output;
+
+ if (DoSwap ^ SwapFirst) {
+ output += T_EXTRA(info -> OutputFormat) * Stride;
+ }
+
+
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
}
return (Init + 1);
+
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* PackPlanarWords(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackPlanarWords(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
if (SwapEndian)
v = CHANGE_ENDIAN(v);
- if (Reverse)
+ if (Reverse)
v = REVERSE_FLAVOR_16(v);
*(cmsUInt16Number*) output = v;
// CMYKcm (unrolled for speed)
static
-cmsUInt8Number* Pack6Bytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack6Bytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[5]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// KCMYcm
static
-cmsUInt8Number* Pack6BytesSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack6BytesSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// CMYKcm
static
-cmsUInt8Number* Pack6Words(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack6Words(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// KCMYcm
static
-cmsUInt8Number* Pack6WordsSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack6WordsSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack4Bytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4Bytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[3]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack4BytesReverse(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4BytesReverse(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[3]));
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack4BytesSwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4BytesSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[2]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// ABGR
static
-cmsUInt8Number* Pack4BytesSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4BytesSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[3]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack4Words(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4Words(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack4WordsReverse(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4WordsReverse(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// ABGR
static
-cmsUInt8Number* Pack4WordsSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4WordsSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// CMYK
static
-cmsUInt8Number* Pack4WordsBigEndian(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack4WordsBigEndian(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* PackLabV2_8(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackLabV2_8(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* PackALabV2_8(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackALabV2_8(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* PackLabV2_16(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackLabV2_16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output += 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3Bytes(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3Bytes(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[2]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesOptimized(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesOptimized(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = (wOut[2] & 0xFF);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesSwapOptimized(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesSwapOptimized(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = (wOut[0] & 0xFF);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3Words(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3Words(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3WordsSwap(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3WordsSwap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3WordsBigEndian(register _cmsTRANSFORM* info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3WordsBigEndian(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output++;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1Optimized(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1Optimized(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output++;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1SwapFirst(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1SwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[2]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1SwapFirstOptimized(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1SwapFirstOptimized(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = (wOut[2] & 0xFF);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1Swap(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1Swap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1SwapOptimized(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1SwapOptimized(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = (wOut[0] & 0xFF);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirst(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
-{
+{
*output++ = FROM_16_TO_8(wOut[2]);
*output++ = FROM_16_TO_8(wOut[1]);
*output++ = FROM_16_TO_8(wOut[0]);
output++;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirstOptimized(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirstOptimized(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
-{
+{
*output++ = (wOut[2] & 0xFF);
*output++ = (wOut[1] & 0xFF);
*output++ = (wOut[0] & 0xFF);
output++;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3WordsAndSkip1(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3WordsAndSkip1(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3WordsAndSkip1Swap(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3WordsAndSkip1Swap(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3WordsAndSkip1SwapFirst(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3WordsAndSkip1SwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
-{
+{
output+= 2;
*(cmsUInt16Number*) output = wOut[0];
output+= 2;
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack3WordsAndSkip1SwapSwapFirst(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack3WordsAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
-{
+{
*(cmsUInt16Number*) output = wOut[2];
output+= 2;
*(cmsUInt16Number*) output = wOut[1];
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1Byte(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1Byte(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
+
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1ByteReversed(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1ByteReversed(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(REVERSE_FLAVOR_16(wOut[0]));
+
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1ByteSkip1(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1ByteSkip1(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
output++;
+
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1ByteSkip1SwapFirst(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1ByteSkip1SwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
*output++ = FROM_16_TO_8(wOut[0]);
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1Word(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1Word(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1WordReversed(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1WordReversed(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1WordBigEndian(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1WordBigEndian(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1WordSkip1(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1WordSkip1(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
output+= 4;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
static
-cmsUInt8Number* Pack1WordSkip1SwapFirst(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* Pack1WordSkip1SwapFirst(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
- output += 2;
+ output += 2;
*(cmsUInt16Number*) output = wOut[0];
output+= 2;
return output;
+
+ cmsUNUSED_PARAMETER(info);
+ cmsUNUSED_PARAMETER(Stride);
}
// Unencoded Float values -- don't try optimize speed
static
-cmsUInt8Number* PackLabDoubleFrom16(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
- register cmsUInt8Number* output,
+cmsUInt8Number* PackLabDoubleFrom16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
+ register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
- if (T_PLANAR(Info -> OutputFormat)) {
+ if (T_PLANAR(info -> OutputFormat)) {
cmsCIELab Lab;
cmsFloat64Number* Out = (cmsFloat64Number*) output;
else {
cmsLabEncoded2Float((cmsCIELab*) output, wOut);
- return output + (sizeof(cmsCIELab) + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
+ return output + (sizeof(cmsCIELab) + T_EXTRA(info ->OutputFormat) * sizeof(cmsFloat64Number));
}
+}
+
+static
+cmsUInt8Number* PackLabFloatFrom16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
+ register cmsUInt8Number* output,
+ register cmsUInt32Number Stride)
+{
+ cmsCIELab Lab;
+ cmsLabEncoded2Float(&Lab, wOut);
+
+ if (T_PLANAR(info -> OutputFormat)) {
+
+ cmsFloat32Number* Out = (cmsFloat32Number*) output;
+
+ Out[0] = (cmsFloat32Number)Lab.L;
+ Out[Stride] = (cmsFloat32Number)Lab.a;
+ Out[Stride*2] = (cmsFloat32Number)Lab.b;
+
+ return output + sizeof(cmsFloat32Number);
+ }
+ else {
+
+ ((cmsFloat32Number*) output)[0] = (cmsFloat32Number) Lab.L;
+ ((cmsFloat32Number*) output)[1] = (cmsFloat32Number) Lab.a;
+ ((cmsFloat32Number*) output)[2] = (cmsFloat32Number) Lab.b;
+
+ return output + (3 + T_EXTRA(info ->OutputFormat)) * sizeof(cmsFloat32Number);
+ }
}
static
-cmsUInt8Number* PackXYZDoubleFrom16(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackXYZDoubleFrom16(register _cmsTRANSFORM* Info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
cmsFloat64Number* Out = (cmsFloat64Number*) output;
cmsXYZEncoded2Float(&XYZ, wOut);
- Out[0] = XYZ.X;
+ Out[0] = XYZ.X;
Out[Stride] = XYZ.Y;
Out[Stride*2] = XYZ.Z;
}
static
-cmsUInt8Number* PackDoubleFrom16(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
- register cmsUInt8Number* output,
- register cmsUInt32Number Stride)
+cmsUInt8Number* PackXYZFloatFrom16(register _cmsTRANSFORM* Info,
+ register cmsUInt16Number wOut[],
+ register cmsUInt8Number* output,
+ register cmsUInt32Number Stride)
{
- cmsFloat64Number* Inks = (cmsFloat64Number*) output;
- int nChan = T_CHANNELS(Info -> OutputFormat);
- int i;
- cmsFloat64Number maximum = IsInkSpace(Info ->InputFormat) ? 655.35 : 65535.0;
-
if (T_PLANAR(Info -> OutputFormat)) {
- for (i=0; i < nChan; i++) {
+ cmsCIEXYZ XYZ;
+ cmsFloat32Number* Out = (cmsFloat32Number*) output;
+ cmsXYZEncoded2Float(&XYZ, wOut);
- Inks[i*Stride] = wOut[i] / maximum;
- }
+ Out[0] = (cmsFloat32Number) XYZ.X;
+ Out[Stride] = (cmsFloat32Number) XYZ.Y;
+ Out[Stride*2] = (cmsFloat32Number) XYZ.Z;
- return output + sizeof(cmsFloat64Number);
- }
- else {
+ return output + sizeof(cmsFloat32Number);
- for (i=0; i < nChan; i++) {
+ }
+ else {
- Inks[i] = wOut[i] / maximum;
- }
+ cmsCIEXYZ XYZ;
+ cmsFloat32Number* Out = (cmsFloat32Number*) output;
+ cmsXYZEncoded2Float(&XYZ, wOut);
+ Out[0] = (cmsFloat32Number) XYZ.X;
+ Out[1] = (cmsFloat32Number) XYZ.Y;
+ Out[2] = (cmsFloat32Number) XYZ.Z;
- return output + (nChan + T_EXTRA(Info ->OutputFormat)) * sizeof(cmsFloat64Number);
+ return output + (3 * sizeof(cmsFloat32Number) + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
}
-
}
static
-cmsUInt8Number* PackFloatFrom16(register _cmsTRANSFORM* Info,
- register cmsUInt16Number wOut[],
+cmsUInt8Number* PackDoubleFrom16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
register cmsUInt8Number* output,
register cmsUInt32Number Stride)
{
- cmsFloat32Number* Inks = (cmsFloat32Number*) output;
- int nChan = T_CHANNELS(Info -> OutputFormat);
- int i;
- cmsFloat64Number maximum = IsInkSpace(Info ->OutputFormat) ? 655.35 : 65535.0;
+ int nChan = T_CHANNELS(info -> OutputFormat);
+ int DoSwap = T_DOSWAP(info ->OutputFormat);
+ int Reverse = T_FLAVOR(info ->OutputFormat);
+ int Extra = T_EXTRA(info -> OutputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
+ int Planar = T_PLANAR(info -> OutputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35 : 65535.0;
+ cmsFloat64Number v = 0;
+ cmsFloat64Number* swap1 = (cmsFloat64Number*) output;
+ int i, start = 0;
- if (T_PLANAR(Info -> OutputFormat)) {
+ if (ExtraFirst)
+ start = Extra;
- for (i=0; i < nChan; i++) {
+ for (i=0; i < nChan; i++) {
- Inks[i*Stride] = (cmsFloat32Number) (wOut[i] / maximum);
- }
+ int index = DoSwap ? (nChan - i - 1) : i;
- return output + sizeof(cmsFloat32Number);
- }
- else {
+ v = (cmsFloat64Number) wOut[index] / maximum;
- for (i=0; i < nChan; i++) {
+ if (Reverse)
+ v = maximum - v;
- Inks[i] = (cmsFloat32Number) (wOut[i] / maximum);
- }
+ if (Planar)
+ ((cmsFloat64Number*) output)[(i + start) * Stride]= v;
+ else
+ ((cmsFloat64Number*) output)[i + start] = v;
+ }
+ if (!ExtraFirst) {
+ output += Extra * sizeof(cmsFloat64Number);
+ }
+
+ if (Extra == 0 && SwapFirst) {
- return output + (nChan + T_EXTRA(Info ->OutputFormat)) * sizeof(cmsFloat32Number);
+ memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number));
+ *swap1 = v;
}
-}
+ if (T_PLANAR(info -> OutputFormat))
+ return output + sizeof(cmsFloat64Number);
+ else
+ return output + nChan * sizeof(cmsFloat64Number);
+}
-// --------------------------------------------------------------------------------------------------------
static
-cmsUInt8Number* PackChunkyFloatsFromFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wOut[],
- cmsUInt8Number* output,
- cmsUInt32Number Stride)
+cmsUInt8Number* PackFloatFrom16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
+ register cmsUInt8Number* output,
+ register cmsUInt32Number Stride)
{
int nChan = T_CHANNELS(info -> OutputFormat);
int DoSwap = T_DOSWAP(info ->OutputFormat);
int Reverse = T_FLAVOR(info ->OutputFormat);
int Extra = T_EXTRA(info -> OutputFormat);
int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
- int ExtraFirst = DoSwap && !SwapFirst;
- cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0 : 1.0;
- cmsFloat32Number* swap1;
+ int Planar = T_PLANAR(info -> OutputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35 : 65535.0;
cmsFloat64Number v = 0;
- int i;
+ cmsFloat32Number* swap1 = (cmsFloat32Number*) output;
+ int i, start = 0;
- swap1 = (cmsFloat32Number*) output;
-
- if (ExtraFirst) {
- output += Extra * sizeof(cmsFloat32Number);
- }
+ if (ExtraFirst)
+ start = Extra;
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
- v = wOut[index] * maximum;
+ v = (cmsFloat64Number) wOut[index] / maximum;
if (Reverse)
v = maximum - v;
- *(cmsFloat32Number*) output = (cmsFloat32Number) v;
-
- output += sizeof(cmsFloat32Number);
+ if (Planar)
+ ((cmsFloat32Number*) output)[(i + start ) * Stride]= (cmsFloat32Number) v;
+ else
+ ((cmsFloat32Number*) output)[i + start] = (cmsFloat32Number) v;
}
if (!ExtraFirst) {
output += Extra * sizeof(cmsFloat32Number);
}
- if (Extra == 0 && SwapFirst) {
+ if (Extra == 0 && SwapFirst) {
- memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat32Number));
+ memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat32Number));
*swap1 = (cmsFloat32Number) v;
}
-
- return output;
+ if (T_PLANAR(info -> OutputFormat))
+ return output + sizeof(cmsFloat32Number);
+ else
+ return output + nChan * sizeof(cmsFloat32Number);
}
+
+
+// --------------------------------------------------------------------------------------------------------
+
static
-cmsUInt8Number* PackPlanarFloatsFromFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wOut[],
- cmsUInt8Number* output,
- cmsUInt32Number Stride)
+cmsUInt8Number* PackFloatsFromFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wOut[],
+ cmsUInt8Number* output,
+ cmsUInt32Number Stride)
{
- int nChan = T_CHANNELS(info -> OutputFormat);
- int DoSwap = T_DOSWAP(info ->OutputFormat);
- int Reverse= T_FLAVOR(info ->OutputFormat);
- int i;
- cmsUInt8Number* Init = output;
+ int nChan = T_CHANNELS(info -> OutputFormat);
+ int DoSwap = T_DOSWAP(info ->OutputFormat);
+ int Reverse = T_FLAVOR(info ->OutputFormat);
+ int Extra = T_EXTRA(info -> OutputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
+ int Planar = T_PLANAR(info -> OutputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0 : 1.0;
- cmsFloat64Number v;
+ cmsFloat32Number* swap1 = (cmsFloat32Number*) output;
+ cmsFloat64Number v = 0;
+ int i, start = 0;
- if (DoSwap) {
- output += T_EXTRA(info -> OutputFormat) * Stride * sizeof(cmsFloat32Number);
- }
+ if (ExtraFirst)
+ start = Extra;
for (i=0; i < nChan; i++) {
v = wOut[index] * maximum;
- if (Reverse)
- v = maximum - v;
+ if (Reverse)
+ v = maximum - v;
- *(cmsFloat32Number*) output = (cmsFloat32Number) v;
- output += (Stride * sizeof(cmsFloat32Number));
+ if (Planar)
+ ((cmsFloat32Number*) output)[(i + start)* Stride]= (cmsFloat32Number) v;
+ else
+ ((cmsFloat32Number*) output)[i + start] = (cmsFloat32Number) v;
}
- return (Init + sizeof(cmsFloat32Number));
-}
+ if (!ExtraFirst) {
+ output += Extra * sizeof(cmsFloat32Number);
+ }
+
+ if (Extra == 0 && SwapFirst) {
+ memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat32Number));
+ *swap1 = (cmsFloat32Number) v;
+ }
+
+ if (T_PLANAR(info -> OutputFormat))
+ return output + sizeof(cmsFloat32Number);
+ else
+ return output + nChan * sizeof(cmsFloat32Number);
+}
static
-cmsUInt8Number* PackChunkyDoublesFromFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wOut[],
- cmsUInt8Number* output,
- cmsUInt32Number Stride)
+cmsUInt8Number* PackDoublesFromFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wOut[],
+ cmsUInt8Number* output,
+ cmsUInt32Number Stride)
{
int nChan = T_CHANNELS(info -> OutputFormat);
int DoSwap = T_DOSWAP(info ->OutputFormat);
int Reverse = T_FLAVOR(info ->OutputFormat);
int Extra = T_EXTRA(info -> OutputFormat);
int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
- int ExtraFirst = DoSwap && !SwapFirst;
- cmsFloat64Number* swap1;
+ int Planar = T_PLANAR(info -> OutputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0 : 1.0;
cmsFloat64Number v = 0;
- int i;
+ cmsFloat64Number* swap1 = (cmsFloat64Number*) output;
+ int i, start = 0;
- swap1 = (cmsFloat64Number*) output;
-
- if (ExtraFirst) {
- output += Extra * sizeof(cmsFloat64Number);
- }
+ if (ExtraFirst)
+ start = Extra;
for (i=0; i < nChan; i++) {
int index = DoSwap ? (nChan - i - 1) : i;
- v = (cmsFloat64Number) wOut[index] * maximum;
+ v = wOut[index] * maximum;
if (Reverse)
v = maximum - v;
- *(cmsFloat64Number*) output = v;
-
- output += sizeof(cmsFloat64Number);
+ if (Planar)
+ ((cmsFloat64Number*) output)[(i + start) * Stride] = v;
+ else
+ ((cmsFloat64Number*) output)[i + start] = v;
}
if (!ExtraFirst) {
output += Extra * sizeof(cmsFloat64Number);
}
- if (Extra == 0 && SwapFirst) {
+ if (Extra == 0 && SwapFirst) {
- memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number));
+ memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number));
*swap1 = v;
}
- return output;
-}
-
-static
-cmsUInt8Number* PackPlanarDoublesFromFloat(_cmsTRANSFORM* info,
- cmsFloat32Number wOut[],
- cmsUInt8Number* output,
- cmsUInt32Number Stride)
-{
- int nChan = T_CHANNELS(info -> OutputFormat);
- int DoSwap = T_DOSWAP(info ->OutputFormat);
- int Reverse= T_FLAVOR(info ->OutputFormat);
- int i;
- cmsUInt8Number* Init = output;
- cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0 : 1.0;
- cmsFloat64Number v;
-
- if (DoSwap) {
- output += T_EXTRA(info -> OutputFormat) * Stride * sizeof(cmsFloat64Number);
- }
-
- for (i=0; i < nChan; i++) {
-
- int index = DoSwap ? (nChan - i - 1) : i;
-
- v = (cmsFloat64Number) wOut[index] * maximum;
-
- if (Reverse)
- v = maximum - v;
-
- *(cmsFloat64Number*) output = v;
- output += (Stride * sizeof(cmsFloat64Number));
- }
+ if (T_PLANAR(info -> OutputFormat))
+ return output + sizeof(cmsFloat64Number);
+ else
+ return output + nChan * sizeof(cmsFloat64Number);
- return (Init + sizeof(cmsFloat64Number));
}
+
static
-cmsUInt8Number* PackLabFloatFromFloat(_cmsTRANSFORM* Info,
- cmsFloat32Number wOut[],
+cmsUInt8Number* PackLabFloatFromFloat(_cmsTRANSFORM* Info,
+ cmsFloat32Number wOut[],
cmsUInt8Number* output,
cmsUInt32Number Stride)
-{
+{
cmsFloat32Number* Out = (cmsFloat32Number*) output;
if (T_PLANAR(Info -> OutputFormat)) {
Out[1] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0);
Out[2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0);
- return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
+ return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
}
}
+
static
-cmsUInt8Number* PackLabDoubleFromFloat(_cmsTRANSFORM* Info,
- cmsFloat32Number wOut[],
+cmsUInt8Number* PackLabDoubleFromFloat(_cmsTRANSFORM* Info,
+ cmsFloat32Number wOut[],
cmsUInt8Number* output,
cmsUInt32Number Stride)
-{
+{
cmsFloat64Number* Out = (cmsFloat64Number*) output;
if (T_PLANAR(Info -> OutputFormat)) {
Out[1] = (cmsFloat64Number) (wOut[1] * 255.0 - 128.0);
Out[2] = (cmsFloat64Number) (wOut[2] * 255.0 - 128.0);
- return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
+ return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
}
}
// From 0..1 range to 0..MAX_ENCODEABLE_XYZ
static
-cmsUInt8Number* PackXYZFloatFromFloat(_cmsTRANSFORM* Info,
- cmsFloat32Number wOut[],
+cmsUInt8Number* PackXYZFloatFromFloat(_cmsTRANSFORM* Info,
+ cmsFloat32Number wOut[],
cmsUInt8Number* output,
cmsUInt32Number Stride)
-{
+{
cmsFloat32Number* Out = (cmsFloat32Number*) output;
if (T_PLANAR(Info -> OutputFormat)) {
Out[1] = (cmsFloat32Number) (wOut[1] * MAX_ENCODEABLE_XYZ);
Out[2] = (cmsFloat32Number) (wOut[2] * MAX_ENCODEABLE_XYZ);
- return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
+ return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
}
}
-
// Same, but convert to double
static
-cmsUInt8Number* PackXYZDoubleFromFloat(_cmsTRANSFORM* Info,
- cmsFloat32Number wOut[],
+cmsUInt8Number* PackXYZDoubleFromFloat(_cmsTRANSFORM* Info,
+ cmsFloat32Number wOut[],
cmsUInt8Number* output,
cmsUInt32Number Stride)
-{
+{
cmsFloat64Number* Out = (cmsFloat64Number*) output;
if (T_PLANAR(Info -> OutputFormat)) {
Out[1] = (cmsFloat64Number) (wOut[1] * MAX_ENCODEABLE_XYZ);
Out[2] = (cmsFloat64Number) (wOut[2] * MAX_ENCODEABLE_XYZ);
- return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
+ return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
+ }
+
+}
+
+
+// ----------------------------------------------------------------------------------------------------------------
+
+#ifndef CMS_NO_HALF_SUPPORT
+
+// Decodes an stream of half floats to wIn[] described by input format
+
+static
+cmsUInt8Number* UnrollHalfTo16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wIn[],
+ register cmsUInt8Number* accum,
+ register cmsUInt32Number Stride)
+{
+
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> InputFormat);
+ int Extra = T_EXTRA(info -> InputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ int Planar = T_PLANAR(info -> InputFormat);
+ cmsFloat32Number v;
+ int i, start = 0;
+ cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 655.35F : 65535.0F;
+
+
+ if (ExtraFirst)
+ start = Extra;
+
+ for (i=0; i < nChan; i++) {
+
+ int index = DoSwap ? (nChan - i - 1) : i;
+
+ if (Planar)
+ v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[(i + start) * Stride] );
+ else
+ v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[i + start] ) ;
+
+ if (Reverse) v = maximum - v;
+
+ wIn[index] = _cmsQuickSaturateWord(v * maximum);
}
+
+ if (Extra == 0 && SwapFirst) {
+ cmsUInt16Number tmp = wIn[0];
+
+ memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
+ wIn[nChan-1] = tmp;
+ }
+
+ if (T_PLANAR(info -> InputFormat))
+ return accum + sizeof(cmsUInt16Number);
+ else
+ return accum + (nChan + Extra) * sizeof(cmsUInt16Number);
}
+// Decodes an stream of half floats to wIn[] described by input format
+
+static
+cmsUInt8Number* UnrollHalfToFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wIn[],
+ cmsUInt8Number* accum,
+ cmsUInt32Number Stride)
+{
+
+ int nChan = T_CHANNELS(info -> InputFormat);
+ int DoSwap = T_DOSWAP(info ->InputFormat);
+ int Reverse = T_FLAVOR(info ->InputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> InputFormat);
+ int Extra = T_EXTRA(info -> InputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ int Planar = T_PLANAR(info -> InputFormat);
+ cmsFloat32Number v;
+ int i, start = 0;
+ cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 100.0F : 1.0F;
+
+
+ if (ExtraFirst)
+ start = Extra;
+
+ for (i=0; i < nChan; i++) {
+
+ int index = DoSwap ? (nChan - i - 1) : i;
+
+ if (Planar)
+ v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[(i + start) * Stride] );
+ else
+ v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[i + start] ) ;
+
+ v /= maximum;
+
+ wIn[index] = Reverse ? 1 - v : v;
+ }
+
+
+ if (Extra == 0 && SwapFirst) {
+ cmsFloat32Number tmp = wIn[0];
+
+ memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number));
+ wIn[nChan-1] = tmp;
+ }
+
+ if (T_PLANAR(info -> InputFormat))
+ return accum + sizeof(cmsUInt16Number);
+ else
+ return accum + (nChan + Extra) * sizeof(cmsUInt16Number);
+}
+
+
+static
+cmsUInt8Number* PackHalfFrom16(register _cmsTRANSFORM* info,
+ register cmsUInt16Number wOut[],
+ register cmsUInt8Number* output,
+ register cmsUInt32Number Stride)
+{
+ int nChan = T_CHANNELS(info -> OutputFormat);
+ int DoSwap = T_DOSWAP(info ->OutputFormat);
+ int Reverse = T_FLAVOR(info ->OutputFormat);
+ int Extra = T_EXTRA(info -> OutputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
+ int Planar = T_PLANAR(info -> OutputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ cmsFloat32Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35F : 65535.0F;
+ cmsFloat32Number v = 0;
+ cmsUInt16Number* swap1 = (cmsUInt16Number*) output;
+ int i, start = 0;
+
+ if (ExtraFirst)
+ start = Extra;
+
+ for (i=0; i < nChan; i++) {
+
+ int index = DoSwap ? (nChan - i - 1) : i;
+
+ v = (cmsFloat32Number) wOut[index] / maximum;
+
+ if (Reverse)
+ v = maximum - v;
+
+ if (Planar)
+ ((cmsUInt16Number*) output)[(i + start ) * Stride]= _cmsFloat2Half(v);
+ else
+ ((cmsUInt16Number*) output)[i + start] = _cmsFloat2Half(v);
+ }
+
+ if (!ExtraFirst) {
+ output += Extra * sizeof(cmsUInt16Number);
+ }
+
+ if (Extra == 0 && SwapFirst) {
+
+ memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number));
+ *swap1 = _cmsFloat2Half(v);
+ }
+
+ if (T_PLANAR(info -> OutputFormat))
+ return output + sizeof(cmsUInt16Number);
+ else
+ return output + nChan * sizeof(cmsUInt16Number);
+}
+
+
+
+static
+cmsUInt8Number* PackHalfFromFloat(_cmsTRANSFORM* info,
+ cmsFloat32Number wOut[],
+ cmsUInt8Number* output,
+ cmsUInt32Number Stride)
+{
+ int nChan = T_CHANNELS(info -> OutputFormat);
+ int DoSwap = T_DOSWAP(info ->OutputFormat);
+ int Reverse = T_FLAVOR(info ->OutputFormat);
+ int Extra = T_EXTRA(info -> OutputFormat);
+ int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
+ int Planar = T_PLANAR(info -> OutputFormat);
+ int ExtraFirst = DoSwap ^ SwapFirst;
+ cmsFloat32Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0F : 1.0F;
+ cmsUInt16Number* swap1 = (cmsUInt16Number*) output;
+ cmsFloat32Number v = 0;
+ int i, start = 0;
+
+ if (ExtraFirst)
+ start = Extra;
+
+ for (i=0; i < nChan; i++) {
+
+ int index = DoSwap ? (nChan - i - 1) : i;
+
+ v = wOut[index] * maximum;
+
+ if (Reverse)
+ v = maximum - v;
+
+ if (Planar)
+ ((cmsUInt16Number*) output)[(i + start)* Stride]= _cmsFloat2Half( v );
+ else
+ ((cmsUInt16Number*) output)[i + start] = _cmsFloat2Half( v );
+ }
+
+ if (!ExtraFirst) {
+ output += Extra * sizeof(cmsUInt16Number);
+ }
+
+ if (Extra == 0 && SwapFirst) {
+
+ memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number));
+ *swap1 = (cmsUInt16Number) _cmsFloat2Half( v );
+ }
+
+ if (T_PLANAR(info -> OutputFormat))
+ return output + sizeof(cmsUInt16Number);
+ else
+ return output + nChan * sizeof(cmsUInt16Number);
+}
+
+#endif
// ----------------------------------------------------------------------------------------------------------------
// ---------------------------- ------------------------------------ ----------------------------
{ TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleTo16},
{ TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleTo16},
+ { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatTo16},
+ { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatTo16},
{ TYPE_GRAY_DBL, 0, UnrollDouble1Chan},
- { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, UnrollDoubleTo16},
- { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, UnrollFloatTo16},
-
+ { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR|
+ ANYSWAP|ANYEXTRA|ANYSPACE, UnrollDoubleTo16},
+ { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR|
+ ANYSWAP|ANYEXTRA|ANYSPACE, UnrollFloatTo16},
+#ifndef CMS_NO_HALF_SUPPORT
+ { FLOAT_SH(1)|BYTES_SH(2), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR|
+ ANYEXTRA|ANYSWAP|ANYSPACE, UnrollHalfTo16},
+#endif
- { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Unroll1Byte},
+ { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Unroll1Byte},
{ CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Unroll1ByteSkip1},
{ CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(2), ANYSPACE, Unroll1ByteSkip2},
{ CHANNELS_SH(1)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Unroll1ByteReversed},
{ CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3BytesSkip1Swap},
{ CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll3BytesSkip1SwapFirst},
+ { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
+ ANYSPACE, Unroll3BytesSkip1SwapSwapFirst},
+
{ CHANNELS_SH(4)|BYTES_SH(1), ANYSPACE, Unroll4Bytes},
{ CHANNELS_SH(4)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Unroll4BytesReverse},
- { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapFirst},
- { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll4BytesSwap},
- { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapSwapFirst},
+ { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapFirst},
+ { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll4BytesSwap},
+ { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapSwapFirst},
- { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarBytes},
- { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollChunkyBytes},
+ { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAPFIRST|
+ ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarBytes},
+ { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
+ ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollChunkyBytes},
{ CHANNELS_SH(1)|BYTES_SH(2), ANYSPACE, Unroll1Word},
{ CHANNELS_SH(1)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Unroll1WordReversed},
{ CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll3WordsSkip1SwapFirst},
{ CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3WordsSkip1Swap},
{ CHANNELS_SH(4)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Unroll4WordsReverse},
- { CHANNELS_SH(4)|BYTES_SH(2)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapFirst},
- { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Unroll4WordsSwap},
- { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapSwapFirst},
+ { CHANNELS_SH(4)|BYTES_SH(2)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapFirst},
+ { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Unroll4WordsSwap},
+ { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapSwapFirst},
- { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarWords },
- { BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollAnyWords},
+ { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarWords},
+ { BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollAnyWords},
};
// ---------------------------- ------------------------------------ ----------------------------
{ TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleToFloat},
{ TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatToFloat},
+
{ TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleToFloat},
{ TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatToFloat},
- { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollFloatsToFloat},
- { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollDoublesToFloat},
+ { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|
+ ANYCHANNELS|ANYSPACE, UnrollFloatsToFloat},
+
+ { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|
+ ANYCHANNELS|ANYSPACE, UnrollDoublesToFloat},
+#ifndef CMS_NO_HALF_SUPPORT
+ { FLOAT_SH(1)|BYTES_SH(2), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|
+ ANYCHANNELS|ANYSPACE, UnrollHalfToFloat},
+#endif
};
cmsUInt32Number i;
cmsFormatter fr;
+ switch (dwFlags) {
- if (!(dwFlags & CMS_PACK_FLAGS_FLOAT)) {
-
+ case CMS_PACK_FLAGS_16BITS: {
for (i=0; i < sizeof(InputFormatters16) / sizeof(cmsFormatters16); i++) {
cmsFormatters16* f = InputFormatters16 + i;
}
}
}
- else {
+ break;
+
+ case CMS_PACK_FLAGS_FLOAT: {
for (i=0; i < sizeof(InputFormattersFloat) / sizeof(cmsFormattersFloat); i++) {
cmsFormattersFloat* f = InputFormattersFloat + i;
}
}
}
+ break;
+
+ default:;
+
+ }
fr.Fmt16 = NULL;
return fr;
{ TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, PackLabDoubleFrom16},
{ TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, PackXYZDoubleFrom16},
- { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackDoubleFrom16},
- { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackFloatFrom16},
- { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Pack1Byte},
+ { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, PackLabFloatFrom16},
+ { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, PackXYZFloatFrom16},
+
+ { FLOAT_SH(1)|BYTES_SH(0), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
+ ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackDoubleFrom16},
+ { FLOAT_SH(1)|BYTES_SH(4), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
+ ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackFloatFrom16},
+#ifndef CMS_NO_HALF_SUPPORT
+ { FLOAT_SH(1)|BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
+ ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackHalfFrom16},
+#endif
+
+ { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Pack1Byte},
{ CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Pack1ByteSkip1},
{ CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack1ByteSkip1SwapFirst},
{ CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesAndSkip1Optimized},
{ CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1),
ANYSPACE, Pack3BytesAndSkip1SwapFirstOptimized},
- { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1),
+ { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1),
ANYSPACE, Pack3BytesAndSkip1SwapSwapFirstOptimized},
- { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1),
+ { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1),
ANYSPACE, Pack3BytesAndSkip1SwapOptimized},
{ CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesSwapOptimized},
{ CHANNELS_SH(3)|BYTES_SH(1), ANYSPACE, Pack3Bytes},
{ CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Pack3BytesAndSkip1},
{ CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack3BytesAndSkip1SwapFirst},
- { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
+ { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
ANYSPACE, Pack3BytesAndSkip1SwapSwapFirst},
{ CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1), ANYSPACE, Pack3BytesAndSkip1Swap},
{ CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack3BytesSwap},
{ CHANNELS_SH(6)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack6BytesSwap},
{ CHANNELS_SH(4)|BYTES_SH(1), ANYSPACE, Pack4Bytes},
{ CHANNELS_SH(4)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Pack4BytesReverse},
- { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapFirst},
- { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack4BytesSwap},
- { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapSwapFirst},
+ { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapFirst},
+ { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack4BytesSwap},
+ { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapSwapFirst},
- { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyBytes},
- { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarBytes},
+ { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyBytes},
+ { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarBytes},
{ CHANNELS_SH(1)|BYTES_SH(2), ANYSPACE, Pack1Word},
{ CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(1), ANYSPACE, Pack1WordSkip1},
{ CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack3WordsAndSkip1Swap},
{ CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack3WordsAndSkip1SwapFirst},
- { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
+ { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
ANYSPACE, Pack3WordsAndSkip1SwapSwapFirst},
{ CHANNELS_SH(4)|BYTES_SH(2), ANYSPACE, Pack4Words},
{ CHANNELS_SH(4)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Pack4WordsReverse},
- { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack4WordsSwap},
+ { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack4WordsSwap},
{ CHANNELS_SH(4)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack4WordsBigEndian},
{ CHANNELS_SH(6)|BYTES_SH(2), ANYSPACE, Pack6Words},
{ CHANNELS_SH(6)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack6WordsSwap},
- { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYENDIAN|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarWords},
+ { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYENDIAN|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarWords},
{ BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyWords}
};
// ---------------------------- --------------------------------------------------- ----------------------------
{ TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, PackLabFloatFromFloat},
{ TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, PackXYZFloatFromFloat},
+
{ TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, PackLabDoubleFromFloat},
{ TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, PackXYZDoubleFromFloat},
- { FLOAT_SH(1)|BYTES_SH(4),
- ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackChunkyFloatsFromFloat },
- { FLOAT_SH(1)|BYTES_SH(4)|PLANAR_SH(1), ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarFloatsFromFloat},
- { FLOAT_SH(1)|BYTES_SH(0),
- ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackChunkyDoublesFromFloat },
- { FLOAT_SH(1)|BYTES_SH(0)|PLANAR_SH(1), ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarDoublesFromFloat},
+
+ { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR|
+ ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackFloatsFromFloat },
+ { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR|
+ ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackDoublesFromFloat },
+#ifndef CMS_NO_HALF_SUPPORT
+ { FLOAT_SH(1)|BYTES_SH(2),
+ ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackHalfFromFloat },
+#endif
+
};
// Bit fields set to one in the mask are not compared
+static
cmsFormatter _cmsGetStockOutputFormatter(cmsUInt32Number dwInput, cmsUInt32Number dwFlags)
{
cmsUInt32Number i;
cmsFormatter fr;
- if (dwFlags & CMS_PACK_FLAGS_FLOAT) {
+ switch (dwFlags)
+ {
- for (i=0; i < sizeof(OutputFormattersFloat) / sizeof(cmsFormattersFloat); i++) {
- cmsFormattersFloat* f = OutputFormattersFloat + i;
+ case CMS_PACK_FLAGS_16BITS: {
+
+ for (i=0; i < sizeof(OutputFormatters16) / sizeof(cmsFormatters16); i++) {
+ cmsFormatters16* f = OutputFormatters16 + i;
if ((dwInput & ~f ->Mask) == f ->Type) {
- fr.FmtFloat = f ->Frm;
+ fr.Fmt16 = f ->Frm;
return fr;
}
}
+ }
+ break;
- }
- else {
+ case CMS_PACK_FLAGS_FLOAT: {
- for (i=0; i < sizeof(OutputFormatters16) / sizeof(cmsFormatters16); i++) {
- cmsFormatters16* f = OutputFormatters16 + i;
+ for (i=0; i < sizeof(OutputFormattersFloat) / sizeof(cmsFormattersFloat); i++) {
+ cmsFormattersFloat* f = OutputFormattersFloat + i;
if ((dwInput & ~f ->Mask) == f ->Type) {
- fr.Fmt16 = f ->Frm;
+ fr.FmtFloat = f ->Frm;
return fr;
}
}
+ }
+ break;
+
+ default:;
+
}
fr.Fmt16 = NULL;
} cmsFormattersFactoryList;
-static cmsFormattersFactoryList* FactoryList = NULL;
+_cmsFormattersPluginChunkType _cmsFormattersPluginChunk = { NULL };
+
+
+// Duplicates the zone of memory used by the plug-in in the new context
+static
+void DupFormatterFactoryList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ _cmsFormattersPluginChunkType newHead = { NULL };
+ cmsFormattersFactoryList* entry;
+ cmsFormattersFactoryList* Anterior = NULL;
+ _cmsFormattersPluginChunkType* head = (_cmsFormattersPluginChunkType*) src->chunks[FormattersPlugin];
+
+ _cmsAssert(head != NULL);
+
+ // Walk the list copying all nodes
+ for (entry = head->FactoryList;
+ entry != NULL;
+ entry = entry ->Next) {
+
+ cmsFormattersFactoryList *newEntry = ( cmsFormattersFactoryList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(cmsFormattersFactoryList));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.FactoryList == NULL)
+ newHead.FactoryList = newEntry;
+ }
+
+ ctx ->chunks[FormattersPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsFormattersPluginChunkType));
+}
+
+// The interpolation plug-in memory chunk allocator/dup
+void _cmsAllocFormattersPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ _cmsAssert(ctx != NULL);
+
+ if (src != NULL) {
+
+ // Duplicate the LIST
+ DupFormatterFactoryList(ctx, src);
+ }
+ else {
+ static _cmsFormattersPluginChunkType FormattersPluginChunk = { NULL };
+ ctx ->chunks[FormattersPlugin] = _cmsSubAllocDup(ctx ->MemPool, &FormattersPluginChunk, sizeof(_cmsFormattersPluginChunkType));
+ }
+}
+
// Formatters management
-cmsBool _cmsRegisterFormattersPlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterFormattersPlugin(cmsContext ContextID, cmsPluginBase* Data)
{
+ _cmsFormattersPluginChunkType* ctx = ( _cmsFormattersPluginChunkType*) _cmsContextGetClientChunk(ContextID, FormattersPlugin);
cmsPluginFormatters* Plugin = (cmsPluginFormatters*) Data;
cmsFormattersFactoryList* fl ;
- // Reset
+ // Reset to built-in defaults
if (Data == NULL) {
- FactoryList = NULL;
+ ctx ->FactoryList = NULL;
return TRUE;
}
-
- fl = (cmsFormattersFactoryList*) _cmsPluginMalloc(sizeof(cmsFormattersFactoryList));
+
+ fl = (cmsFormattersFactoryList*) _cmsPluginMalloc(ContextID, sizeof(cmsFormattersFactoryList));
if (fl == NULL) return FALSE;
fl ->Factory = Plugin ->FormattersFactory;
- fl ->Next = FactoryList;
- FactoryList = fl;
+ fl ->Next = ctx -> FactoryList;
+ ctx ->FactoryList = fl;
return TRUE;
}
-cmsFormatter _cmsGetFormatter(cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8
- cmsFormatterDirection Dir,
- cmsUInt32Number dwFlags) // Float or 16 bits
+cmsFormatter _cmsGetFormatter(cmsContext ContextID,
+ cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8
+ cmsFormatterDirection Dir,
+ cmsUInt32Number dwFlags)
{
+ _cmsFormattersPluginChunkType* ctx = ( _cmsFormattersPluginChunkType*) _cmsContextGetClientChunk(ContextID, FormattersPlugin);
cmsFormattersFactoryList* f;
- for (f = FactoryList; f != NULL; f = f ->Next) {
+ for (f =ctx->FactoryList; f != NULL; f = f ->Next) {
cmsFormatter fn = f ->Factory(Type, Dir, dwFlags);
if (fn.Fmt16 != NULL) return fn;
}
// Revert to default
- if (Dir == cmsFormatterInput)
+ if (Dir == cmsFormatterInput)
return _cmsGetStockInputFormatter(Type, dwFlags);
- else
+ else
return _cmsGetStockOutputFormatter(Type, dwFlags);
}
// Build a suitable formatter for the colorspace of this profile
cmsUInt32Number CMSEXPORT cmsFormatterForColorspaceOfProfile(cmsHPROFILE hProfile, cmsUInt32Number nBytes, cmsBool lIsFloat)
{
-
+
cmsColorSpaceSignature ColorSpace = cmsGetColorSpace(hProfile);
cmsUInt32Number ColorSpaceBits = _cmsLCMScolorSpace(ColorSpace);
cmsUInt32Number nOutputChans = cmsChannelsOf(ColorSpace);
// Build a suitable formatter for the colorspace of this profile
cmsUInt32Number CMSEXPORT cmsFormatterForPCSOfProfile(cmsHPROFILE hProfile, cmsUInt32Number nBytes, cmsBool lIsFloat)
{
-
+
cmsColorSpaceSignature ColorSpace = cmsGetPCS(hProfile);
int ColorSpaceBits = _cmsLCMScolorSpace(ColorSpace);
cmsUInt32Number nOutputChans = cmsChannelsOf(ColorSpace);
// Little Color Management System
// Copyright (c) 1998-2010 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
if (t <= Limit)
return (841.0/108.0) * t + (16.0/116.0);
else
- return pow(t, 1.0/3.0);
+ return pow(t, 1.0/3.0);
}
static
{
cmsFloat64Number fx, fy, fz;
- if (WhitePoint == NULL)
+ if (WhitePoint == NULL)
WhitePoint = cmsD50_XYZ();
fx = f(xyz->X / WhitePoint->X);
{
cmsFloat64Number x, y, z;
- if (WhitePoint == NULL)
+ if (WhitePoint == NULL)
WhitePoint = cmsD50_XYZ();
y = (Lab-> L + 16.0) / 116.0;
static
cmsFloat64Number L2float2(cmsUInt16Number v)
{
- return (cmsFloat64Number) v / 652.800;
+ return (cmsFloat64Number) v / 652.800;
}
// the a/b part
static
cmsFloat64Number ab2float2(cmsUInt16Number v)
-{
- return ((cmsFloat64Number) v / 256.0) - 128.0;
+{
+ return ((cmsFloat64Number) v / 256.0) - 128.0;
}
static
cmsUInt16Number L2Fix2(cmsFloat64Number L)
{
- return _cmsQuickSaturateWord(L * 652.8);
+ return _cmsQuickSaturateWord(L * 652.8);
}
static
cmsUInt16Number ab2Fix2(cmsFloat64Number ab)
{
- return _cmsQuickSaturateWord((ab + 128.0) * 256.0);
+ return _cmsQuickSaturateWord((ab + 128.0) * 256.0);
}
Lab.L = Clamp_L_doubleV2(fLab ->L);
Lab.a = Clamp_ab_doubleV2(fLab ->a);
Lab.b = Clamp_ab_doubleV2(fLab ->b);
-
+
wLab[0] = L2Fix2(Lab.L);
wLab[1] = ab2Fix2(Lab.a);
wLab[2] = ab2Fix2(Lab.b);
return ab;
}
-static
+static
cmsUInt16Number L2Fix4(cmsFloat64Number L)
{
return _cmsQuickSaturateWord(L * 655.35);
void CMSEXPORT cmsFloat2LabEncoded(cmsUInt16Number wLab[3], const cmsCIELab* fLab)
{
cmsCIELab Lab;
-
+
Lab.L = Clamp_L_doubleV4(fLab ->L);
Lab.a = Clamp_ab_doubleV4(fLab ->a);
Lab.b = Clamp_ab_doubleV4(fLab ->b);
-
+
wLab[0] = L2Fix4(Lab.L);
wLab[1] = ab2Fix4(Lab.a);
wLab[2] = ab2Fix4(Lab.b);
h = 0;
else
h = atan2(a, b);
-
+
h *= (180. / M_PI);
-
- while (h > 360.)
+
+ while (h > 360.)
h -= 360.;
-
+
while ( h < 0)
h += 360.;
-
+
return h;
}
static
cmsFloat64Number Sqr(cmsFloat64Number v)
{
- return v * v;
+ return v * v;
}
// From cylindrical coordinates. No check is performed, then negative values are allowed
void CMSEXPORT cmsLab2LCh(cmsCIELCh* LCh, const cmsCIELab* Lab)
Lab -> L = LCh -> L;
Lab -> a = LCh -> C * cos(h);
- Lab -> b = LCh -> C * sin(h);
+ Lab -> b = LCh -> C * sin(h);
}
// In XYZ All 3 components are encoded using 1.15 fixed point
static
cmsUInt16Number XYZ2Fix(cmsFloat64Number d)
-{
+{
return _cmsQuickSaturateWord(d * 32768.0);
}
xyz.Y = fXYZ -> Y;
xyz.Z = fXYZ -> Z;
- // Clamp to encodeable values.
+ // Clamp to encodeable values.
if (xyz.Y <= 0) {
xyz.X = 0;
xyz.Z = 0;
}
- if (xyz.X > MAX_ENCODEABLE_XYZ)
+ if (xyz.X > MAX_ENCODEABLE_XYZ)
xyz.X = MAX_ENCODEABLE_XYZ;
if (xyz.X < 0)
xyz.X = 0;
- if (xyz.Y > MAX_ENCODEABLE_XYZ)
+ if (xyz.Y > MAX_ENCODEABLE_XYZ)
xyz.Y = MAX_ENCODEABLE_XYZ;
if (xyz.Y < 0)
xyz.Y = 0;
- if (xyz.Z > MAX_ENCODEABLE_XYZ)
+ if (xyz.Z > MAX_ENCODEABLE_XYZ)
xyz.Z = MAX_ENCODEABLE_XYZ;
if (xyz.Z < 0)
XYZ[0] = XYZ2Fix(xyz.X);
XYZ[1] = XYZ2Fix(xyz.Y);
- XYZ[2] = XYZ2Fix(xyz.Z);
+ XYZ[2] = XYZ2Fix(xyz.Z);
}
fXYZ -> X = XYZ2float(XYZ[0]);
fXYZ -> Y = XYZ2float(XYZ[1]);
fXYZ -> Z = XYZ2float(XYZ[2]);
-}
+}
// Returns dE on two Lab values
}
-// Return the CIE94 Delta E
+// Return the CIE94 Delta E
cmsFloat64Number CMSEXPORT cmsCIE94DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2)
{
cmsCIELCh LCh1, LCh2;
dC = fabs(LCh1.C - LCh2.C);
dE = cmsDeltaE(Lab1, Lab2);
-
+
dhsq = Sqr(dE) - Sqr(dL) - Sqr(dC);
if (dhsq < 0)
dh = 0;
sc = 1.0 + (0.048 * c12);
sh = 1.0 + (0.014 * c12);
-
+
return sqrt(Sqr(dL) + Sqr(dC) / Sqr(sc) + Sqr(dh) / Sqr(sh));
}
dc = 0.035 * AveC / (1 + 0.00365 * AveC)+0.521;
g = sqrt(Sqr(Sqr(AveC))/(Sqr(Sqr(AveC))+14000));
- t = 0.627+(0.055*cos((Aveh-254)/(180/M_PI))-
+ t = 0.627+(0.055*cos((Aveh-254)/(180/M_PI))-
0.040*cos((2*Aveh-136)/(180/M_PI))+
0.070*cos((3*Aveh-31)/(180/M_PI))+
0.049*cos((4*Aveh+114)/(180/M_PI))-
cmsLab2LCh(&LCh1, Lab1);
cmsLab2LCh(&LCh2, Lab2);
-
+
dL = Lab2->L-Lab1->L;
dC = LCh2.C-LCh1.C;
dE = cmsDeltaE(Lab1, Lab2);
- if (Sqr(dE)>(Sqr(dL)+Sqr(dC)))
+ if (Sqr(dE)>(Sqr(dL)+Sqr(dC)))
dh = sqrt(Sqr(dE)-Sqr(dL)-Sqr(dC));
else
dh =0;
- if ((LCh1.h > 164) && (LCh1.h < 345))
+ if ((LCh1.h > 164) && (LCh1.h < 345))
t = 0.56 + fabs(0.2 * cos(((LCh1.h + 168)/(180/M_PI))));
- else
+ else
t = 0.36 + fabs(0.4 * cos(((LCh1.h + 35 )/(180/M_PI))));
sc = 0.0638 * LCh1.C / (1 + 0.0131 * LCh1.C) + 0.638;
sl = 0.040975 * Lab1->L /(1 + 0.01765 * Lab1->L);
-
+
if (Lab1->L<16)
- sl = 0.511;
+ sl = 0.511;
f = sqrt((LCh1.C * LCh1.C * LCh1.C * LCh1.C)/((LCh1.C * LCh1.C * LCh1.C * LCh1.C)+1900));
sh = sc*(t*f+1-f);
return cmc;
}
-// dE2000 The weightings KL, KC and KH can be modified to reflect the relative
+// dE2000 The weightings KL, KC and KH can be modified to reflect the relative
// importance of lightness, chroma and hue in different industrial applications
cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2,
cmsFloat64Number Kl, cmsFloat64Number Kc, cmsFloat64Number Kh)
cmsFloat64Number a_p = (1 + G ) * a1;
cmsFloat64Number b_p = b1;
cmsFloat64Number C_p = sqrt( Sqr(a_p) + Sqr(b_p));
- cmsFloat64Number h_p = atan2deg(b_p, a_p);
-
+ cmsFloat64Number h_p = atan2deg(b_p, a_p);
+
cmsFloat64Number a_ps = (1 + G) * as;
cmsFloat64Number b_ps = bs;
cmsFloat64Number C_ps = sqrt(Sqr(a_ps) + Sqr(b_ps));
cmsFloat64Number h_ps = atan2deg(b_ps, a_ps);
-
+
cmsFloat64Number meanC_p =(C_p + C_ps) / 2;
cmsFloat64Number hps_plus_hp = h_ps + h_p;
cmsFloat64Number hps_minus_hp = h_ps - h_p;
- cmsFloat64Number meanh_p = fabs(hps_minus_hp) <= 180.000001 ? (hps_plus_hp)/2 :
- (hps_plus_hp) < 360 ? (hps_plus_hp + 360)/2 :
+ cmsFloat64Number meanh_p = fabs(hps_minus_hp) <= 180.000001 ? (hps_plus_hp)/2 :
+ (hps_plus_hp) < 360 ? (hps_plus_hp + 360)/2 :
(hps_plus_hp - 360)/2;
cmsFloat64Number delta_h = (hps_minus_hp) <= -180.000001 ? (hps_minus_hp + 360) :
- (hps_minus_hp) > 180 ? (hps_minus_hp - 360) :
+ (hps_minus_hp) > 180 ? (hps_minus_hp - 360) :
(hps_minus_hp);
cmsFloat64Number delta_L = (Ls - L1);
cmsFloat64Number delta_C = (C_ps - C_p );
cmsFloat64Number delta_H =2 * sqrt(C_ps*C_p) * sin(RADIANS(delta_h) / 2);
- cmsFloat64Number T = 1 - 0.17 * cos(RADIANS(meanh_p-30))
- + 0.24 * cos(RADIANS(2*meanh_p))
- + 0.32 * cos(RADIANS(3*meanh_p + 6))
+ cmsFloat64Number T = 1 - 0.17 * cos(RADIANS(meanh_p-30))
+ + 0.24 * cos(RADIANS(2*meanh_p))
+ + 0.32 * cos(RADIANS(3*meanh_p + 6))
- 0.2 * cos(RADIANS(4*meanh_p - 63));
cmsFloat64Number Sl = 1 + (0.015 * Sqr((Ls + L1) /2- 50) )/ sqrt(20 + Sqr( (Ls+L1)/2 - 50) );
cmsFloat64Number Rt = -sin(2 * RADIANS(delta_ro)) * Rc;
- cmsFloat64Number deltaE00 = sqrt( Sqr(delta_L /(Sl * Kl)) +
- Sqr(delta_C/(Sc * Kc)) +
- Sqr(delta_H/(Sh * Kh)) +
+ cmsFloat64Number deltaE00 = sqrt( Sqr(delta_L /(Sl * Kl)) +
+ Sqr(delta_C/(Sc * Kc)) +
+ Sqr(delta_H/(Sh * Kh)) +
Rt*(delta_C/(Sc * Kc)) * (delta_H / (Sh * Kh)));
return deltaE00;
// HighResPrecalc is maximum resolution
if (dwFlags & cmsFLAGS_HIGHRESPRECALC) {
- if (nChannels > 4)
+ if (nChannels > 4)
return 7; // 7 for Hifi
if (nChannels == 4) // 23 for CMYK
return 23;
-
- return 49; // 49 for RGB and others
+
+ return 49; // 49 for RGB and others
}
// LowResPrecal is lower resolution
if (dwFlags & cmsFLAGS_LOWRESPRECALC) {
-
- if (nChannels > 4)
+
+ if (nChannels > 4)
return 6; // 6 for more than 4 channels
- if (nChannels == 1)
+ if (nChannels == 1)
return 33; // For monochrome
return 17; // 17 for remaining
}
// Default values
- if (nChannels > 4)
+ if (nChannels > 4)
return 7; // 7 for Hifi
if (nChannels == 4)
return 17; // 17 for CMYK
- return 33; // 33 for RGB
+ return 33; // 33 for RGB
}
-cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
- cmsUInt16Number **White,
+cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
+ cmsUInt16Number **White,
cmsUInt16Number **Black,
cmsUInt32Number *nOutputs)
{
if (Black) *Black = Grayblack;
if (nOutputs) *nOutputs = 1;
return TRUE;
-
+
case cmsSigRgbData: if (White) *White = RGBwhite;
if (Black) *Black = RGBblack;
if (nOutputs) *nOutputs = 3;
return FALSE;
}
-
+
// Several utilities -------------------------------------------------------
int CMSEXPORT _cmsLCMScolorSpace(cmsColorSpaceSignature ProfileSpace)
-{
+{
switch (ProfileSpace) {
-
+
case cmsSigGrayData: return PT_GRAY;
case cmsSigRgbData: return PT_RGB;
case cmsSigCmyData: return PT_CMY;
case cmsSigHsvData: return PT_HSV;
case cmsSigHlsData: return PT_HLS;
case cmsSigYxyData: return PT_Yxy;
-
+
case cmsSig1colorData:
case cmsSigMCH1Data: return PT_MCH1;
-
+
case cmsSig2colorData:
case cmsSigMCH2Data: return PT_MCH2;
-
+
case cmsSig3colorData:
case cmsSigMCH3Data: return PT_MCH3;
-
+
case cmsSig4colorData:
case cmsSigMCH4Data: return PT_MCH4;
-
+
case cmsSig5colorData:
case cmsSigMCH5Data: return PT_MCH5;
-
+
case cmsSig6colorData:
case cmsSigMCH6Data: return PT_MCH6;
-
+
case cmsSigMCH7Data:
case cmsSig7colorData:return PT_MCH7;
-
+
case cmsSigMCH8Data:
case cmsSig8colorData:return PT_MCH8;
-
+
case cmsSigMCH9Data:
case cmsSig9colorData:return PT_MCH9;
-
+
case cmsSigMCHAData:
case cmsSig10colorData:return PT_MCH10;
-
+
case cmsSigMCHBData:
case cmsSig11colorData:return PT_MCH11;
-
+
case cmsSigMCHCData:
case cmsSig12colorData:return PT_MCH12;
-
+
case cmsSigMCHDData:
case cmsSig13colorData:return PT_MCH13;
-
+
case cmsSigMCHEData:
case cmsSig14colorData:return PT_MCH14;
-
+
case cmsSigMCHFData:
case cmsSig15colorData:return PT_MCH15;
-
+
default: return (cmsColorSpaceSignature) (-1);
}
}
{
switch (ColorSpace) {
+ case cmsSigMCH1Data:
+ case cmsSig1colorData:
case cmsSigGrayData: return 1;
+ case cmsSigMCH2Data:
case cmsSig2colorData: return 2;
-
+
case cmsSigXYZData:
case cmsSigLabData:
case cmsSigLuvData:
case cmsSigYCbCrData:
case cmsSigYxyData:
- case cmsSigRgbData:
+ case cmsSigRgbData:
case cmsSigHsvData:
case cmsSigHlsData:
- case cmsSigCmyData:
+ case cmsSigCmyData:
+ case cmsSigMCH3Data:
case cmsSig3colorData: return 3;
-
+
case cmsSigLuvKData:
case cmsSigCmykData:
+ case cmsSigMCH4Data:
case cmsSig4colorData: return 4;
case cmsSigMCH5Data:
- case cmsSig5colorData: return 5;
+ case cmsSig5colorData: return 5;
- case cmsSigMCH6Data:
+ case cmsSigMCH6Data:
case cmsSig6colorData: return 6;
-
+
case cmsSigMCH7Data:
case cmsSig7colorData: return 7;
case cmsSigMCHBData:
case cmsSig11colorData: return 11;
-
+
case cmsSigMCHCData:
case cmsSig12colorData: return 12;
// Little Color Management System
// Copyright (c) 1998-2010 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
tmp = pByte[0];
pByte[0] = pByte[1];
pByte[1] = tmp;
-#endif
+#endif
return Word;
}
// 1 2 3 4 5 6 7 8
// 8 7 6 5 4 3 2 1
-void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number QWord)
+void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number* QWord)
{
-
+
#ifndef CMS_USE_BIG_ENDIAN
-
- cmsUInt8Number* pIn = (cmsUInt8Number*) &QWord;
+
+ cmsUInt8Number* pIn = (cmsUInt8Number*) QWord;
cmsUInt8Number* pOut = (cmsUInt8Number*) Result;
_cmsAssert(Result != NULL);
pOut[5] = pIn[2];
pOut[4] = pIn[3];
pOut[3] = pIn[4];
- pOut[2] = pIn[5];
+ pOut[2] = pIn[5];
pOut[1] = pIn[6];
pOut[0] = pIn[7];
#else
-
_cmsAssert(Result != NULL);
- *Result = QWord;
+# ifdef CMS_DONT_USE_INT64
+ (*Result)[0] = QWord[0];
+ (*Result)[1] = QWord[1];
+# else
+ *Result = *QWord;
+# endif
#endif
}
_cmsAssert(io != NULL);
- if (io -> Read(io, &tmp, sizeof(cmsUInt8Number), 1) != 1)
- return FALSE;
+ if (io -> Read(io, &tmp, sizeof(cmsUInt8Number), 1) != 1)
+ return FALSE;
if (n != NULL) *n = tmp;
return TRUE;
_cmsAssert(io != NULL);
- if (io -> Read(io, &tmp, sizeof(cmsUInt16Number), 1) != 1)
- return FALSE;
+ if (io -> Read(io, &tmp, sizeof(cmsUInt16Number), 1) != 1)
+ return FALSE;
if (n != NULL) *n = _cmsAdjustEndianess16(tmp);
return TRUE;
_cmsAssert(io != NULL);
- if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
- return FALSE;
+ if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
+ return FALSE;
if (n != NULL) *n = _cmsAdjustEndianess32(tmp);
return TRUE;
_cmsAssert(io != NULL);
- if (io -> Read(io, &tmp, sizeof(cmsFloat32Number), 1) != 1)
- return FALSE;
+ if (io -> Read(io, &tmp, sizeof(cmsFloat32Number), 1) != 1)
+ return FALSE;
if (n != NULL) {
_cmsAssert(io != NULL);
- if (io -> Read(io, &tmp, sizeof(cmsUInt64Number), 1) != 1)
- return FALSE;
+ if (io -> Read(io, &tmp, sizeof(cmsUInt64Number), 1) != 1)
+ return FALSE;
- if (n != NULL) _cmsAdjustEndianess64(n, tmp);
+ if (n != NULL) _cmsAdjustEndianess64(n, &tmp);
return TRUE;
}
_cmsAssert(io != NULL);
- if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
- return FALSE;
+ if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
+ return FALSE;
if (n != NULL) {
*n = _cms15Fixed16toDouble(_cmsAdjustEndianess32(tmp));
{
_cmsAssert(io != NULL);
- if (io -> Write(io, sizeof(cmsUInt8Number), &n) != 1)
- return FALSE;
-
+ if (io -> Write(io, sizeof(cmsUInt8Number), &n) != 1)
+ return FALSE;
+
return TRUE;
}
_cmsAssert(io != NULL);
tmp = _cmsAdjustEndianess16(n);
- if (io -> Write(io, sizeof(cmsUInt16Number), &tmp) != 1)
- return FALSE;
-
+ if (io -> Write(io, sizeof(cmsUInt16Number), &tmp) != 1)
+ return FALSE;
+
return TRUE;
}
_cmsAssert(io != NULL);
tmp = _cmsAdjustEndianess32(n);
- if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
- return FALSE;
-
+ if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
+ return FALSE;
+
return TRUE;
}
tmp = *(cmsUInt32Number*) &n;
tmp = _cmsAdjustEndianess32(tmp);
- if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
- return FALSE;
-
+ if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
+ return FALSE;
+
return TRUE;
}
-cmsBool CMSEXPORT _cmsWriteUInt64Number(cmsIOHANDLER* io, cmsUInt64Number n)
+cmsBool CMSEXPORT _cmsWriteUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n)
{
cmsUInt64Number tmp;
_cmsAssert(io != NULL);
_cmsAdjustEndianess64(&tmp, n);
- if (io -> Write(io, sizeof(cmsUInt64Number), &tmp) != 1)
- return FALSE;
-
+ if (io -> Write(io, sizeof(cmsUInt64Number), &tmp) != 1)
+ return FALSE;
+
return TRUE;
}
_cmsAssert(io != NULL);
tmp = _cmsAdjustEndianess32(_cmsDoubleTo15Fixed16(n));
- if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
- return FALSE;
-
+ if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
+ return FALSE;
+
return TRUE;
}
cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ)
{
cmsEncodedXYZNumber xyz;
-
+
_cmsAssert(io != NULL);
_cmsAssert(XYZ != NULL);
cmsUInt16Number CMSEXPORT _cmsDoubleTo8Fixed8(cmsFloat64Number val)
{
cmsS15Fixed16Number GammaFixed32 = _cmsDoubleTo15Fixed16(val);
- return (cmsUInt16Number) ((GammaFixed32 >> 8) & 0xFFFF);
+ return (cmsUInt16Number) ((GammaFixed32 >> 8) & 0xFFFF);
}
// from Fixed point 15.16 to double
return sign * floater;
}
-// from double to Fixed point 15.16
+// from double to Fixed point 15.16
cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsFloat64Number v)
{
return ((cmsS15Fixed16Number) floor((v)*65536.0 + 0.5));
}
-// Date/Time functions
+// Date/Time functions
void CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeNumber *Source, struct tm *Dest)
{
_cmsAssert(io != NULL);
- if (io -> Read(io, &Base, sizeof(_cmsTagBase), 1) != 1)
+ if (io -> Read(io, &Base, sizeof(_cmsTagBase), 1) != 1)
return (cmsTagTypeSignature) 0;
return (cmsTagTypeSignature) _cmsAdjustEndianess32(Base.sig);
cmsUInt8Number Buffer[4];
cmsUInt32Number NextAligned, At;
cmsUInt32Number BytesToNextAlignedPos;
-
+
_cmsAssert(io != NULL);
At = io -> Tell(io);
if (len < 0) return FALSE; // Truncated, which is a fatal error for us
rc = io ->Write(io, len, Buffer);
-
+
va_end(args);
return rc;
// Plugin memory management -------------------------------------------------------------------------------------------------
-static _cmsSubAllocator* PluginPool = NULL;
-
// Specialized malloc for plug-ins, that is freed upon exit.
-void* _cmsPluginMalloc(cmsUInt32Number size)
+void* _cmsPluginMalloc(cmsContext ContextID, cmsUInt32Number size)
{
- if (PluginPool == NULL)
- PluginPool = _cmsCreateSubAlloc(0, 4*1024);
+ struct _cmsContext_struct* ctx = _cmsGetContext(ContextID);
+
+ if (ctx ->MemPool == NULL) {
+
+ if (ContextID == NULL) {
- return _cmsSubAlloc(PluginPool, size);
+ ctx->MemPool = _cmsCreateSubAlloc(0, 2*1024);
+ }
+ else {
+ cmsSignalError(ContextID, cmsERROR_CORRUPTION_DETECTED, "NULL memory pool on context");
+ return NULL;
+ }
+ }
+
+ return _cmsSubAlloc(ctx->MemPool, size);
}
// Main plug-in dispatcher
cmsBool CMSEXPORT cmsPlugin(void* Plug_in)
+{
+ return cmsPluginTHR(NULL, Plug_in);
+}
+
+cmsBool CMSEXPORT cmsPluginTHR(cmsContext id, void* Plug_in)
{
cmsPluginBase* Plugin;
- for (Plugin = (cmsPluginBase*) Plug_in;
- Plugin != NULL;
+ for (Plugin = (cmsPluginBase*) Plug_in;
+ Plugin != NULL;
Plugin = Plugin -> Next) {
if (Plugin -> Magic != cmsPluginMagicNumber) {
- cmsSignalError(0, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin");
+ cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin");
return FALSE;
}
- if (Plugin ->ExpectedVersion > LCMS_VERSION) {
- cmsSignalError(0, cmsERROR_UNKNOWN_EXTENSION, "plugin needs Little CMS %d, current version is %d",
- Plugin ->ExpectedVersion, LCMS_VERSION);
- return FALSE;
- }
+ if (Plugin ->ExpectedVersion > LCMS_VERSION) {
+ cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "plugin needs Little CMS %d, current version is %d",
+ Plugin ->ExpectedVersion, LCMS_VERSION);
+ return FALSE;
+ }
switch (Plugin -> Type) {
case cmsPluginMemHandlerSig:
- if (!_cmsRegisterMemHandlerPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterMemHandlerPlugin(id, Plugin)) return FALSE;
break;
case cmsPluginInterpolationSig:
- if (!_cmsRegisterInterpPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterInterpPlugin(id, Plugin)) return FALSE;
break;
-
+
case cmsPluginTagTypeSig:
- if (!_cmsRegisterTagTypePlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterTagTypePlugin(id, Plugin)) return FALSE;
break;
-
+
case cmsPluginTagSig:
- if (!_cmsRegisterTagPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterTagPlugin(id, Plugin)) return FALSE;
break;
case cmsPluginFormattersSig:
- if (!_cmsRegisterFormattersPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterFormattersPlugin(id, Plugin)) return FALSE;
break;
case cmsPluginRenderingIntentSig:
- if (!_cmsRegisterRenderingIntentPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterRenderingIntentPlugin(id, Plugin)) return FALSE;
break;
case cmsPluginParametricCurveSig:
- if (!_cmsRegisterParametricCurvesPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterParametricCurvesPlugin(id, Plugin)) return FALSE;
break;
case cmsPluginMultiProcessElementSig:
- if (!_cmsRegisterMultiProcessElementPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterMultiProcessElementPlugin(id, Plugin)) return FALSE;
break;
case cmsPluginOptimizationSig:
- if (!_cmsRegisterOptimizationPlugin(Plugin)) return FALSE;
+ if (!_cmsRegisterOptimizationPlugin(id, Plugin)) return FALSE;
+ break;
+
+ case cmsPluginTransformSig:
+ if (!_cmsRegisterTransformPlugin(id, Plugin)) return FALSE;
+ break;
+
+ case cmsPluginMutexSig:
+ if (!_cmsRegisterMutexPlugin(id, Plugin)) return FALSE;
break;
default:
- cmsSignalError(0, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin type '%X'", Plugin -> Type);
+ cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin type '%X'", Plugin -> Type);
return FALSE;
- }
+ }
}
// Keep a reference to the plug-in
// Revert all plug-ins to default
void CMSEXPORT cmsUnregisterPlugins(void)
{
- _cmsRegisterMemHandlerPlugin(NULL);
- _cmsRegisterInterpPlugin(NULL);
- _cmsRegisterTagTypePlugin(NULL);
- _cmsRegisterTagPlugin(NULL);
- _cmsRegisterFormattersPlugin(NULL);
- _cmsRegisterRenderingIntentPlugin(NULL);
- _cmsRegisterParametricCurvesPlugin(NULL);
- _cmsRegisterMultiProcessElementPlugin(NULL);
- _cmsRegisterOptimizationPlugin(NULL);
+ cmsUnregisterPluginsTHR(NULL);
+}
+
+
+// The Global storage for system context. This is the one and only global variable
+// pointers structure. All global vars are referenced here.
+static struct _cmsContext_struct globalContext = {
+
+ NULL, // Not in the linked list
+ NULL, // No suballocator
+ {
+ NULL, // UserPtr,
+ &_cmsLogErrorChunk, // Logger,
+ &_cmsAlarmCodesChunk, // AlarmCodes,
+ &_cmsAdaptationStateChunk, // AdaptationState,
+ &_cmsMemPluginChunk, // MemPlugin,
+ &_cmsInterpPluginChunk, // InterpPlugin,
+ &_cmsCurvesPluginChunk, // CurvesPlugin,
+ &_cmsFormattersPluginChunk, // FormattersPlugin,
+ &_cmsTagTypePluginChunk, // TagTypePlugin,
+ &_cmsTagPluginChunk, // TagPlugin,
+ &_cmsIntentsPluginChunk, // IntentPlugin,
+ &_cmsMPETypePluginChunk, // MPEPlugin,
+ &_cmsOptimizationPluginChunk, // OptimizationPlugin,
+ &_cmsTransformPluginChunk, // TransformPlugin,
+ &_cmsMutexPluginChunk // MutexPlugin
+ },
+
+ { NULL, NULL, NULL, NULL, NULL, NULL } // The default memory allocator is not used for context 0
+};
+
+
+// The context pool (linked list head)
+static _cmsMutex _cmsContextPoolHeadMutex = CMS_MUTEX_INITIALIZER;
+static struct _cmsContext_struct* _cmsContextPoolHead = NULL;
+
+// Internal, get associated pointer, with guessing. Never returns NULL.
+struct _cmsContext_struct* _cmsGetContext(cmsContext ContextID)
+{
+ struct _cmsContext_struct* id = (struct _cmsContext_struct*) ContextID;
+ struct _cmsContext_struct* ctx;
+
+
+ // On 0, use global settings
+ if (id == NULL)
+ return &globalContext;
+
+ // Search
+ for (ctx = _cmsContextPoolHead;
+ ctx != NULL;
+ ctx = ctx ->Next) {
+
+ // Found it?
+ if (id == ctx)
+ return ctx; // New-style context,
+ }
+
+ return &globalContext;
+}
+
+
+// Internal: get the memory area associanted with each context client
+// Returns the block assigned to the specific zone.
+void* _cmsContextGetClientChunk(cmsContext ContextID, _cmsMemoryClient mc)
+{
+ struct _cmsContext_struct* ctx;
+ void *ptr;
- if (PluginPool != NULL)
- _cmsSubAllocDestroy(PluginPool);
+ if (mc < 0 || mc >= MemoryClientMax) {
+ cmsSignalError(ContextID, cmsERROR_RANGE, "Bad context client");
+ return NULL;
+ }
+
+ ctx = _cmsGetContext(ContextID);
+ ptr = ctx ->chunks[mc];
- PluginPool = NULL;
+ if (ptr != NULL)
+ return ptr;
+
+ // A null ptr means no special settings for that context, and this
+ // reverts to Context0 globals
+ return globalContext.chunks[mc];
+}
+
+
+// This function returns the given context its default pristine state,
+// as no plug-ins were declared. There is no way to unregister a single
+// plug-in, as a single call to cmsPluginTHR() function may register
+// many different plug-ins simultaneously, then there is no way to
+// identify which plug-in to unregister.
+void CMSEXPORT cmsUnregisterPluginsTHR(cmsContext ContextID)
+{
+ _cmsRegisterMemHandlerPlugin(ContextID, NULL);
+ _cmsRegisterInterpPlugin(ContextID, NULL);
+ _cmsRegisterTagTypePlugin(ContextID, NULL);
+ _cmsRegisterTagPlugin(ContextID, NULL);
+ _cmsRegisterFormattersPlugin(ContextID, NULL);
+ _cmsRegisterRenderingIntentPlugin(ContextID, NULL);
+ _cmsRegisterParametricCurvesPlugin(ContextID, NULL);
+ _cmsRegisterMultiProcessElementPlugin(ContextID, NULL);
+ _cmsRegisterOptimizationPlugin(ContextID, NULL);
+ _cmsRegisterTransformPlugin(ContextID, NULL);
+ _cmsRegisterMutexPlugin(ContextID, NULL);
}
+
+
+// Returns the memory manager plug-in, if any, from the Plug-in bundle
+static
+cmsPluginMemHandler* _cmsFindMemoryPlugin(void* PluginBundle)
+{
+ cmsPluginBase* Plugin;
+
+ for (Plugin = (cmsPluginBase*) PluginBundle;
+ Plugin != NULL;
+ Plugin = Plugin -> Next) {
+
+ if (Plugin -> Magic == cmsPluginMagicNumber &&
+ Plugin -> ExpectedVersion <= LCMS_VERSION &&
+ Plugin -> Type == cmsPluginMemHandlerSig) {
+
+ // Found!
+ return (cmsPluginMemHandler*) Plugin;
+ }
+ }
+
+ // Nope, revert to defaults
+ return NULL;
+}
+
+
+// Creates a new context with optional associated plug-ins. Caller may also specify an optional pointer to user-defined
+// data that will be forwarded to plug-ins and logger.
+cmsContext CMSEXPORT cmsCreateContext(void* Plugin, void* UserData)
+{
+ struct _cmsContext_struct* ctx;
+ struct _cmsContext_struct fakeContext;
+
+ _cmsInstallAllocFunctions(_cmsFindMemoryPlugin(Plugin), &fakeContext.DefaultMemoryManager);
+
+ fakeContext.chunks[UserPtr] = UserData;
+ fakeContext.chunks[MemPlugin] = &fakeContext.DefaultMemoryManager;
+
+ // Create the context structure.
+ ctx = (struct _cmsContext_struct*) _cmsMalloc(&fakeContext, sizeof(struct _cmsContext_struct));
+ if (ctx == NULL)
+ return NULL; // Something very wrong happened!
+
+ // Init the structure and the memory manager
+ memset(ctx, 0, sizeof(struct _cmsContext_struct));
+
+ // Keep memory manager
+ memcpy(&ctx->DefaultMemoryManager, &fakeContext.DefaultMemoryManager, sizeof(_cmsMemPluginChunk));
+
+ // Maintain the linked list (with proper locking)
+ _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
+ ctx ->Next = _cmsContextPoolHead;
+ _cmsContextPoolHead = ctx;
+ _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
+
+ ctx ->chunks[UserPtr] = UserData;
+ ctx ->chunks[MemPlugin] = &ctx->DefaultMemoryManager;
+
+ // Now we can allocate the pool by using default memory manager
+ ctx ->MemPool = _cmsCreateSubAlloc(ctx, 22 * sizeof(void*)); // default size about 32 pointers
+ if (ctx ->MemPool == NULL) {
+
+ cmsDeleteContext(ctx);
+ return NULL;
+ }
+
+ _cmsAllocLogErrorChunk(ctx, NULL);
+ _cmsAllocAlarmCodesChunk(ctx, NULL);
+ _cmsAllocAdaptationStateChunk(ctx, NULL);
+ _cmsAllocMemPluginChunk(ctx, NULL);
+ _cmsAllocInterpPluginChunk(ctx, NULL);
+ _cmsAllocCurvesPluginChunk(ctx, NULL);
+ _cmsAllocFormattersPluginChunk(ctx, NULL);
+ _cmsAllocTagTypePluginChunk(ctx, NULL);
+ _cmsAllocMPETypePluginChunk(ctx, NULL);
+ _cmsAllocTagPluginChunk(ctx, NULL);
+ _cmsAllocIntentsPluginChunk(ctx, NULL);
+ _cmsAllocOptimizationPluginChunk(ctx, NULL);
+ _cmsAllocTransformPluginChunk(ctx, NULL);
+ _cmsAllocMutexPluginChunk(ctx, NULL);
+
+ // Setup the plug-ins
+ if (!cmsPluginTHR(ctx, Plugin)) {
+
+ cmsDeleteContext(ctx);
+ return NULL;
+ }
+
+ return (cmsContext) ctx;
+}
+
+// Duplicates a context with all associated plug-ins.
+// Caller may specify an optional pointer to user-defined
+// data that will be forwarded to plug-ins and logger.
+cmsContext CMSEXPORT cmsDupContext(cmsContext ContextID, void* NewUserData)
+{
+ int i;
+ struct _cmsContext_struct* ctx;
+ const struct _cmsContext_struct* src = _cmsGetContext(ContextID);
+
+ void* userData = (NewUserData != NULL) ? NewUserData : src -> chunks[UserPtr];
+
+
+ ctx = (struct _cmsContext_struct*) _cmsMalloc(ContextID, sizeof(struct _cmsContext_struct));
+ if (ctx == NULL)
+ return NULL; // Something very wrong happened
+
+ // Setup default memory allocators
+ memcpy(&ctx->DefaultMemoryManager, &src->DefaultMemoryManager, sizeof(ctx->DefaultMemoryManager));
+
+ // Maintain the linked list
+ _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
+ ctx ->Next = _cmsContextPoolHead;
+ _cmsContextPoolHead = ctx;
+ _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
+
+ ctx ->chunks[UserPtr] = userData;
+ ctx ->chunks[MemPlugin] = &ctx->DefaultMemoryManager;
+
+ ctx ->MemPool = _cmsCreateSubAlloc(ctx, 22 * sizeof(void*));
+ if (ctx ->MemPool == NULL) {
+
+ cmsDeleteContext(ctx);
+ return NULL;
+ }
+
+ // Allocate all required chunks.
+ _cmsAllocLogErrorChunk(ctx, src);
+ _cmsAllocAlarmCodesChunk(ctx, src);
+ _cmsAllocAdaptationStateChunk(ctx, src);
+ _cmsAllocMemPluginChunk(ctx, src);
+ _cmsAllocInterpPluginChunk(ctx, src);
+ _cmsAllocCurvesPluginChunk(ctx, src);
+ _cmsAllocFormattersPluginChunk(ctx, src);
+ _cmsAllocTagTypePluginChunk(ctx, src);
+ _cmsAllocMPETypePluginChunk(ctx, src);
+ _cmsAllocTagPluginChunk(ctx, src);
+ _cmsAllocIntentsPluginChunk(ctx, src);
+ _cmsAllocOptimizationPluginChunk(ctx, src);
+ _cmsAllocTransformPluginChunk(ctx, src);
+ _cmsAllocMutexPluginChunk(ctx, src);
+
+ // Make sure no one failed
+ for (i=Logger; i < MemoryClientMax; i++) {
+
+ if (src ->chunks[i] == NULL) {
+ cmsDeleteContext((cmsContext) ctx);
+ return NULL;
+ }
+ }
+
+ return (cmsContext) ctx;
+}
+
+
+
+static
+struct _cmsContext_struct* FindPrev(struct _cmsContext_struct* id)
+{
+ struct _cmsContext_struct* prev;
+
+ // Search for previous
+ for (prev = _cmsContextPoolHead;
+ prev != NULL;
+ prev = prev ->Next)
+ {
+ if (prev ->Next == id)
+ return prev;
+ }
+
+ return NULL; // List is empty or only one element!
+}
+
+// Frees any resources associated with the given context,
+// and destroys the context placeholder.
+// The ContextID can no longer be used in any THR operation.
+void CMSEXPORT cmsDeleteContext(cmsContext ContextID)
+{
+ if (ContextID != NULL) {
+
+ struct _cmsContext_struct* ctx = (struct _cmsContext_struct*) ContextID;
+ struct _cmsContext_struct fakeContext;
+ struct _cmsContext_struct* prev;
+
+ memcpy(&fakeContext.DefaultMemoryManager, &ctx->DefaultMemoryManager, sizeof(ctx->DefaultMemoryManager));
+
+ fakeContext.chunks[UserPtr] = ctx ->chunks[UserPtr];
+ fakeContext.chunks[MemPlugin] = &fakeContext.DefaultMemoryManager;
+
+ // Get rid of plugins
+ cmsUnregisterPluginsTHR(ContextID);
+
+ // Since all memory is allocated in the private pool, all what we need to do is destroy the pool
+ if (ctx -> MemPool != NULL)
+ _cmsSubAllocDestroy(ctx ->MemPool);
+ ctx -> MemPool = NULL;
+
+ // Maintain list
+ _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
+ if (_cmsContextPoolHead == ctx) {
+
+ _cmsContextPoolHead = ctx->Next;
+ }
+ else {
+
+ // Search for previous
+ for (prev = _cmsContextPoolHead;
+ prev != NULL;
+ prev = prev ->Next)
+ {
+ if (prev -> Next == ctx) {
+ prev -> Next = ctx ->Next;
+ break;
+ }
+ }
+ }
+ _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
+
+ // free the memory block itself
+ _cmsFree(&fakeContext, ctx);
+ }
+}
+
+// Returns the user data associated to the given ContextID, or NULL if no user data was attached on context creation
+void* CMSEXPORT cmsGetContextUserData(cmsContext ContextID)
+{
+ return _cmsContextGetClientChunk(ContextID, UserPtr);
+}
+
+
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2008 Marti Maria Saguer
+// Copyright (c) 1998-2011 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
#include "lcms2_internal.h"
-// PostScript ColorRenderingDictionary and ColorSpaceArray
+// PostScript ColorRenderingDictionary and ColorSpaceArray
#define MAXPSCOLS 60 // Columns on tables
Implementation
--------------
- PostScript does use XYZ as its internal PCS. But since PostScript
- interpolation tables are limited to 8 bits, I use Lab as a way to
- improve the accuracy, favoring perceptual results. So, for the creation
- of each CRD, CSA the profiles are converted to Lab via a device
+ PostScript does use XYZ as its internal PCS. But since PostScript
+ interpolation tables are limited to 8 bits, I use Lab as a way to
+ improve the accuracy, favoring perceptual results. So, for the creation
+ of each CRD, CSA the profiles are converted to Lab via a device
link between profile -> Lab or Lab -> profile. The PS code necessary to
convert Lab <-> XYZ is also included.
- Color Space Arrays (CSA)
+ Color Space Arrays (CSA)
==================================================================================
In order to obtain precision, code chooses between three ways to implement
the device -> XYZ transform. These cases identifies monochrome profiles (often
implemented as a set of curves), matrix-shaper and Pipeline-based.
- Monochrome
+ Monochrome
-----------
- This is implemented as /CIEBasedA CSA. The prelinearization curve is
+ This is implemented as /CIEBasedA CSA. The prelinearization curve is
placed into /DecodeA section, and matrix equals to D50. Since here is
no interpolation tables, I do the conversion directly to XYZ
flag is forced on such profiles.
[ /CIEBasedA
- <<
+ <<
/DecodeA { transfer function } bind
- /MatrixA [D50]
+ /MatrixA [D50]
/RangeLMN [ 0.0 cmsD50X 0.0 cmsD50Y 0.0 cmsD50Z ]
/WhitePoint [D50]
/BlackPoint [BP]
/RenderingIntent (intent)
>>
- ]
+ ]
On simpler profiles, the PCS is already XYZ, so no conversion is required.
-
+
Matrix-shaper based
-------------------
This is implemented both with /CIEBasedABC or /CIEBasedDEF on dependig
- of profile implementation. Since here there are no interpolation tables, I do
+ of profile implementation. Since here there are no interpolation tables, I do
the conversion directly to XYZ
/BlackPoint [BP]
/RenderingIntent (intent)
>>
- ]
+ ]
CLUT based
/Table [ p p p [<...>]]
/RangeABC [ 0 1 0 1 0 1]
/DecodeABC[ <postlinearization> ]
- /RangeLMN [ -0.236 1.254 0 1 -0.635 1.640 ]
- % -128/500 1+127/500 0 1 -127/200 1+128/200
+ /RangeLMN [ -0.236 1.254 0 1 -0.635 1.640 ]
+ % -128/500 1+127/500 0 1 -127/200 1+128/200
/MatrixABC [ 1 1 1 1 0 0 0 0 -1]
/WhitePoint [D50]
/BlackPoint [BP]
/RenderingIntent (intent)
- ]
+ ]
Color Rendering Dictionaries (CRD)
/BlackPoint [BP]
/MatrixPQR [ Bradford ]
/RangePQR [-0.125 1.375 -0.125 1.375 -0.125 1.375 ]
- /TransformPQR [
+ /TransformPQR [
{4 index 3 get div 2 index 3 get mul exch pop exch pop exch pop exch pop } bind
{4 index 4 get div 2 index 4 get mul exch pop exch pop exch pop exch pop } bind
{4 index 5 get div 2 index 5 get mul exch pop exch pop exch pop exch pop } bind
/EncodeABC <...>
/RangeABC <.. used for XYZ -> Lab>
/EncodeLMN
- /RenderTable [ p p p [<...>]]
-
+ /RenderTable [ p p p [<...>]]
+
/RenderingIntent (Perceptual)
- >>
+ >>
/Current exch /ColorRendering defineresource pop
The following stages are used to convert from XYZ to Lab
- --------------------------------------------------------
+ --------------------------------------------------------
Input is given at LMN stage on X, Y, Z
{ 0.824900 div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind
]
-
-
+
+
MatrixABC is used to compute f(Y/Yn), f(X/Xn) - f(Y/Yn), f(Y/Yn) - f(Z/Zn)
| 0 1 0|
{ 116 mul 16 sub 100 div } bind
{ 500 mul 128 add 255 div } bind
{ 200 mul 128 add 255 div } bind
- ]
-
+ ]
+
The following stages are used to convert Lab to XYZ
----------------------------------------------------
/RangeABC [ 0 1 0 1 0 1]
/DecodeABC [ { 100 mul 16 add 116 div } bind
{ 255 mul 128 sub 500 div } bind
- { 255 mul 128 sub 200 div } bind
+ { 255 mul 128 sub 200 div } bind
]
-
+
/MatrixABC [ 1 1 1 1 0 0 0 0 -1]
/DecodeLMN [
{dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse 0.964200 mul} bind
PostScript algorithms discussion.
=========================================================================================================
- 1D interpolation algorithm
+ 1D interpolation algorithm
1D interpolation (float)
------------------------
-
+
val2 = Domain * Value;
cell0 = (int) floor(val2);
y = y0 + (y1 - y0) * rest;
-
+
PostScript code Stack
================================================
exch % tab val2 cell0 val2
ceiling cvi % tab val2 cell0 cell1
- 3 index % tab val2 cell0 cell1 tab
+ 3 index % tab val2 cell0 cell1 tab
exch % tab val2 cell0 tab cell1
get % tab val2 cell0 y1
4 -1 roll % val2 cell0 y1 tab
- 3 -1 roll % val2 y1 tab cell0
- get % val2 y1 y0
+ 3 -1 roll % val2 y1 tab cell0
+ get % val2 y1 y0
dup % val2 y1 y0 y0
- 3 1 roll % val2 y0 y1 y0
+ 3 1 roll % val2 y0 y1 y0
sub % val2 y0 (y1-y0)
3 -1 roll % y0 (y1-y0) val2
dup % y0 (y1-y0) val2 val2
- floor cvi % y0 (y1-y0) val2 floor(val2)
+ floor cvi % y0 (y1-y0) val2 floor(val2)
sub % y0 (y1-y0) rest
mul % y0 t1
add % y
// This struct holds the memory block currently being write
typedef struct {
- _cmsStageCLutData* Pipeline;
- cmsIOHANDLER* m;
+ _cmsStageCLutData* Pipeline;
+ cmsIOHANDLER* m;
+
+ int FirstComponent;
+ int SecondComponent;
- int FirstComponent;
- int SecondComponent;
-
- const char* PreMaj;
- const char* PostMaj;
- const char* PreMin;
- const char* PostMin;
+ const char* PreMaj;
+ const char* PostMaj;
+ const char* PreMin;
+ const char* PostMin;
- int FixWhite; // Force mapping of pure white
+ int FixWhite; // Force mapping of pure white
- cmsColorSpaceSignature ColorSpace; // ColorSpace of profile
+ cmsColorSpaceSignature ColorSpace; // ColorSpace of profile
} cmsPsSamplerCargo;
/*
static
cmsUInt8Number L2Byte(cmsUInt16Number w)
-{
- int ww = w + 0x0080;
+{
+ int ww = w + 0x0080;
- if (ww > 0xFFFF) return 0xFF;
+ if (ww > 0xFFFF) return 0xFF;
return (cmsUInt8Number) ((cmsUInt16Number) (ww >> 8) & 0xFF);
}
static
void WriteByte(cmsIOHANDLER* m, cmsUInt8Number b)
{
- _cmsIOPrintf(m, "%02x", b);
- _cmsPSActualColumn += 2;
+ _cmsIOPrintf(m, "%02x", b);
+ _cmsPSActualColumn += 2;
- if (_cmsPSActualColumn > MAXPSCOLS) {
+ if (_cmsPSActualColumn > MAXPSCOLS) {
- _cmsIOPrintf(m, "\n");
- _cmsPSActualColumn = 0;
- }
+ _cmsIOPrintf(m, "\n");
+ _cmsPSActualColumn = 0;
+ }
}
// ----------------------------------------------------------------- PostScript generation
// Removes offending Carriage returns
-static
+static
char* RemoveCR(const char* txt)
{
static char Buffer[2048];
void EmitHeader(cmsIOHANDLER* m, const char* Title, cmsHPROFILE hProfile)
{
time_t timer;
- cmsMLU *Description, *Copyright;
- char DescASCII[256], CopyrightASCII[256];
-
+ cmsMLU *Description, *Copyright;
+ char DescASCII[256], CopyrightASCII[256];
+
time(&timer);
-
- Description = (cmsMLU*) cmsReadTag(hProfile, cmsSigProfileDescriptionTag);
- Copyright = (cmsMLU*) cmsReadTag(hProfile, cmsSigCopyrightTag);
- DescASCII[0] = DescASCII[255] = 0;
+ Description = (cmsMLU*) cmsReadTag(hProfile, cmsSigProfileDescriptionTag);
+ Copyright = (cmsMLU*) cmsReadTag(hProfile, cmsSigCopyrightTag);
+
+ DescASCII[0] = DescASCII[255] = 0;
CopyrightASCII[0] = CopyrightASCII[255] = 0;
- if (Description != NULL) cmsMLUgetASCII(Description, cmsNoLanguage, cmsNoCountry, DescASCII, 255);
- if (Copyright != NULL) cmsMLUgetASCII(Copyright, cmsNoLanguage, cmsNoCountry, CopyrightASCII, 255);
+ if (Description != NULL) cmsMLUgetASCII(Description, cmsNoLanguage, cmsNoCountry, DescASCII, 255);
+ if (Copyright != NULL) cmsMLUgetASCII(Copyright, cmsNoLanguage, cmsNoCountry, CopyrightASCII, 255);
_cmsIOPrintf(m, "%%!PS-Adobe-3.0\n");
_cmsIOPrintf(m, "%%\n");
}
-// Emits White & Black point. White point is always D50, Black point is the device
-// Black point adapted to D50.
+// Emits White & Black point. White point is always D50, Black point is the device
+// Black point adapted to D50.
static
void EmitWhiteBlackD50(cmsIOHANDLER* m, cmsCIEXYZ* BlackPoint)
BlackPoint -> Y,
BlackPoint -> Z);
- _cmsIOPrintf(m, "/WhitePoint [%f %f %f]\n", cmsD50_XYZ()->X,
+ _cmsIOPrintf(m, "/WhitePoint [%f %f %f]\n", cmsD50_XYZ()->X,
cmsD50_XYZ()->Y,
cmsD50_XYZ()->Z);
}
default: intent = "Undefined"; break;
}
- _cmsIOPrintf(m, "/RenderingIntent (%s)\n", intent );
+ _cmsIOPrintf(m, "/RenderingIntent (%s)\n", intent );
}
//
static
void EmitL2Y(cmsIOHANDLER* m)
{
- _cmsIOPrintf(m,
- "{ "
+ _cmsIOPrintf(m,
+ "{ "
"100 mul 16 add 116 div " // (L * 100 + 16) / 116
- "dup 6 29 div ge " // >= 6 / 29 ?
+ "dup 6 29 div ge " // >= 6 / 29 ?
"{ dup dup mul mul } " // yes, ^3 and done
"{ 4 29 div sub 108 841 div mul } " // no, slope limiting
- "ifelse } bind ");
+ "ifelse } bind ");
}
*/
_cmsIOPrintf(m, "{255 mul 128 sub 200 div } bind\n");
_cmsIOPrintf(m, "]\n");
_cmsIOPrintf(m, "/MatrixABC [ 1 1 1 1 0 0 0 0 -1]\n");
- _cmsIOPrintf(m, "/RangeLMN [ -0.236 1.254 0 1 -0.635 1.640 ]\n");
+ _cmsIOPrintf(m, "/RangeLMN [ -0.236 1.254 0 1 -0.635 1.640 ]\n");
_cmsIOPrintf(m, "/DecodeLMN [\n");
_cmsIOPrintf(m, "{dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse 0.964200 mul} bind\n");
_cmsIOPrintf(m, "{dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse } bind\n");
cmsUInt32Number i;
cmsFloat64Number gamma;
+ if (Table == NULL) return; // Error
if (Table ->nEntries <= 0) return; // Empty table
if (cmsIsToneCurveLinear(Table)) return;
// Check if is really an exponential. If so, emit "exp"
- gamma = cmsEstimateGamma(Table, 0.001);
+ gamma = cmsEstimateGamma(Table, 0.001);
if (gamma > 0) {
_cmsIOPrintf(m, "{ %g exp } bind ", gamma);
return;
// Bounds check
EmitRangeCheck(m);
-
+
// Emit intepolation code
// PostScript code Stack
_cmsIOPrintf(m, " [");
for (i=0; i < Table->nEntries; i++) {
- _cmsIOPrintf(m, "%d ", Table->Table16[i]);
+ _cmsIOPrintf(m, "%d ", Table->Table16[i]);
}
_cmsIOPrintf(m, "] "); // v tab
- _cmsIOPrintf(m, "dup "); // v tab tab
+ _cmsIOPrintf(m, "dup "); // v tab tab
_cmsIOPrintf(m, "length 1 sub "); // v tab dom
_cmsIOPrintf(m, "3 -1 roll "); // tab dom v
_cmsIOPrintf(m, "mul "); // tab val2
_cmsIOPrintf(m, "floor cvi "); // tab val2 val2 cell0
_cmsIOPrintf(m, "exch "); // tab val2 cell0 val2
_cmsIOPrintf(m, "ceiling cvi "); // tab val2 cell0 cell1
- _cmsIOPrintf(m, "3 index "); // tab val2 cell0 cell1 tab
+ _cmsIOPrintf(m, "3 index "); // tab val2 cell0 cell1 tab
_cmsIOPrintf(m, "exch "); // tab val2 cell0 tab cell1
_cmsIOPrintf(m, "get "); // tab val2 cell0 y1
_cmsIOPrintf(m, "4 -1 roll "); // val2 cell0 y1 tab
- _cmsIOPrintf(m, "3 -1 roll "); // val2 y1 tab cell0
- _cmsIOPrintf(m, "get "); // val2 y1 y0
+ _cmsIOPrintf(m, "3 -1 roll "); // val2 y1 tab cell0
+ _cmsIOPrintf(m, "get "); // val2 y1 y0
_cmsIOPrintf(m, "dup "); // val2 y1 y0 y0
- _cmsIOPrintf(m, "3 1 roll "); // val2 y0 y1 y0
+ _cmsIOPrintf(m, "3 1 roll "); // val2 y0 y1 y0
_cmsIOPrintf(m, "sub "); // val2 y0 (y1-y0)
_cmsIOPrintf(m, "3 -1 roll "); // y0 (y1-y0) val2
_cmsIOPrintf(m, "dup "); // y0 (y1-y0) val2 val2
- _cmsIOPrintf(m, "floor cvi "); // y0 (y1-y0) val2 floor(val2)
+ _cmsIOPrintf(m, "floor cvi "); // y0 (y1-y0) val2 floor(val2)
_cmsIOPrintf(m, "sub "); // y0 (y1-y0) rest
_cmsIOPrintf(m, "mul "); // y0 t1
_cmsIOPrintf(m, "add "); // y
static
cmsBool GammaTableEquals(cmsUInt16Number* g1, cmsUInt16Number* g2, int nEntries)
-{
+{
return memcmp(g1, g2, nEntries* sizeof(cmsUInt16Number)) == 0;
}
// Does write a set of gamma curves
static
-void EmitNGamma(cmsIOHANDLER* m, int n, cmsToneCurve* g[])
+void EmitNGamma(cmsIOHANDLER* m, int n, cmsToneCurve* g[])
{
int i;
-
+
for( i=0; i < n; i++ )
- {
- if (i > 0 && GammaTableEquals(g[i-1]->Table16, g[i]->Table16, g[i]->nEntries)) {
+ {
+ if (g[i] == NULL) return; // Error
+
+ if (i > 0 && GammaTableEquals(g[i-1]->Table16, g[i]->Table16, g[i]->nEntries)) {
_cmsIOPrintf(m, "dup ");
}
- else {
- Emit1Gamma(m, g[i]);
+ else {
+ Emit1Gamma(m, g[i]);
}
}
-
+
}
// Following code dumps a LUT onto memory stream
-
+
// This is the sampler. Intended to work in SAMPLER_INSPECT mode,
// that is, the callback will be called for each knot with
//
// Returning a value other than 0 does terminate the sampling process
//
-// Each row contains Pipeline values for all but first component. So, I
-// detect row changing by keeping a copy of last value of first
+// Each row contains Pipeline values for all but first component. So, I
+// detect row changing by keeping a copy of last value of first
// component. -1 is used to mark begining of whole block.
static
Out[i] = White[i];
}
-
+
}
}
// Hadle the parenthesis on rows
if (In[0] != sc ->FirstComponent) {
-
+
if (sc ->FirstComponent != -1) {
_cmsIOPrintf(sc ->m, sc ->PostMin);
sc ->SecondComponent = -1;
- _cmsIOPrintf(sc ->m, sc ->PostMaj);
+ _cmsIOPrintf(sc ->m, sc ->PostMaj);
}
- // Begin block
+ // Begin block
_cmsPSActualColumn = 0;
-
- _cmsIOPrintf(sc ->m, sc ->PreMaj);
- sc ->FirstComponent = In[0];
+
+ _cmsIOPrintf(sc ->m, sc ->PreMaj);
+ sc ->FirstComponent = In[0];
}
if (In[1] != sc ->SecondComponent) {
-
+
if (sc ->SecondComponent != -1) {
- _cmsIOPrintf(sc ->m, sc ->PostMin);
+ _cmsIOPrintf(sc ->m, sc ->PostMin);
}
-
- _cmsIOPrintf(sc ->m, sc ->PreMin);
- sc ->SecondComponent = In[1];
+
+ _cmsIOPrintf(sc ->m, sc ->PreMin);
+ sc ->SecondComponent = In[1];
}
- // Dump table.
+ // Dump table.
- for (i=0; i < sc -> Pipeline ->Params->nOutputs; i++) {
+ for (i=0; i < sc -> Pipeline ->Params->nOutputs; i++) {
- cmsUInt16Number wWordOut = Out[i];
+ cmsUInt16Number wWordOut = Out[i];
cmsUInt8Number wByteOut; // Value as byte
-
- // We always deal with Lab4
-
- wByteOut = Word2Byte(wWordOut);
- WriteByte(sc -> m, wByteOut);
- }
- return 1;
+ // We always deal with Lab4
+
+ wByteOut = Word2Byte(wWordOut);
+ WriteByte(sc -> m, wByteOut);
+ }
+
+ return 1;
}
// Writes a Pipeline on memstream. Could be 8 or 16 bits based
static
-void WriteCLUT(cmsIOHANDLER* m, cmsStage* mpe, const char* PreMaj,
+void WriteCLUT(cmsIOHANDLER* m, cmsStage* mpe, const char* PreMaj,
const char* PostMaj,
const char* PreMin,
- const char* PostMin,
+ const char* PostMin,
int FixWhite,
cmsColorSpaceSignature ColorSpace)
{
sc.FirstComponent = -1;
sc.SecondComponent = -1;
- sc.Pipeline = (_cmsStageCLutData *) mpe ->Data;
- sc.m = m;
+ sc.Pipeline = (_cmsStageCLutData *) mpe ->Data;
+ sc.m = m;
sc.PreMaj = PreMaj;
sc.PostMaj= PostMaj;
sc.PreMin = PreMin;
- sc.PostMin = PostMin;
+ sc.PostMin = PostMin;
sc.FixWhite = FixWhite;
sc.ColorSpace = ColorSpace;
_cmsIOPrintf(m, "[");
- for (i=0; i < sc.Pipeline->Params->nInputs; i++)
- _cmsIOPrintf(m, " %d ", sc.Pipeline->Params->nSamples[i]);
+ for (i=0; i < sc.Pipeline->Params->nInputs; i++)
+ _cmsIOPrintf(m, " %d ", sc.Pipeline->Params->nSamples[i]);
_cmsIOPrintf(m, " [\n");
cmsStageSampleCLut16bit(mpe, OutputValueSampler, (void*) &sc, SAMPLER_INSPECT);
-
+
_cmsIOPrintf(m, PostMin);
_cmsIOPrintf(m, PostMaj);
_cmsIOPrintf(m, "] ");
int EmitCIEBasedA(cmsIOHANDLER* m, cmsToneCurve* Curve, cmsCIEXYZ* BlackPoint)
{
- _cmsIOPrintf(m, "[ /CIEBasedA\n");
- _cmsIOPrintf(m, " <<\n");
+ _cmsIOPrintf(m, "[ /CIEBasedA\n");
+ _cmsIOPrintf(m, " <<\n");
- _cmsIOPrintf(m, "/DecodeA ");
+ _cmsIOPrintf(m, "/DecodeA ");
- Emit1Gamma(m, Curve);
+ Emit1Gamma(m, Curve);
- _cmsIOPrintf(m, " \n");
+ _cmsIOPrintf(m, " \n");
- _cmsIOPrintf(m, "/MatrixA [ 0.9642 1.0000 0.8249 ]\n");
- _cmsIOPrintf(m, "/RangeLMN [ 0.0 0.9642 0.0 1.0000 0.0 0.8249 ]\n");
+ _cmsIOPrintf(m, "/MatrixA [ 0.9642 1.0000 0.8249 ]\n");
+ _cmsIOPrintf(m, "/RangeLMN [ 0.0 0.9642 0.0 1.0000 0.0 0.8249 ]\n");
- EmitWhiteBlackD50(m, BlackPoint);
- EmitIntent(m, INTENT_PERCEPTUAL);
+ EmitWhiteBlackD50(m, BlackPoint);
+ EmitIntent(m, INTENT_PERCEPTUAL);
- _cmsIOPrintf(m, ">>\n");
- _cmsIOPrintf(m, "]\n");
+ _cmsIOPrintf(m, ">>\n");
+ _cmsIOPrintf(m, "]\n");
- return 1;
+ return 1;
}
static
int EmitCIEBasedABC(cmsIOHANDLER* m, cmsFloat64Number* Matrix, cmsToneCurve** CurveSet, cmsCIEXYZ* BlackPoint)
{
- int i;
-
- _cmsIOPrintf(m, "[ /CIEBasedABC\n");
- _cmsIOPrintf(m, "<<\n");
- _cmsIOPrintf(m, "/DecodeABC [ ");
+ int i;
+
+ _cmsIOPrintf(m, "[ /CIEBasedABC\n");
+ _cmsIOPrintf(m, "<<\n");
+ _cmsIOPrintf(m, "/DecodeABC [ ");
- EmitNGamma(m, 3, CurveSet);
+ EmitNGamma(m, 3, CurveSet);
- _cmsIOPrintf(m, "]\n");
+ _cmsIOPrintf(m, "]\n");
- _cmsIOPrintf(m, "/MatrixABC [ " );
+ _cmsIOPrintf(m, "/MatrixABC [ " );
- for( i=0; i < 3; i++ ) {
+ for( i=0; i < 3; i++ ) {
_cmsIOPrintf(m, "%.6f %.6f %.6f ", Matrix[i + 3*0],
Matrix[i + 3*1],
- Matrix[i + 3*2]);
- }
+ Matrix[i + 3*2]);
+ }
- _cmsIOPrintf(m, "]\n");
+ _cmsIOPrintf(m, "]\n");
- _cmsIOPrintf(m, "/RangeLMN [ 0.0 0.9642 0.0 1.0000 0.0 0.8249 ]\n");
+ _cmsIOPrintf(m, "/RangeLMN [ 0.0 0.9642 0.0 1.0000 0.0 0.8249 ]\n");
- EmitWhiteBlackD50(m, BlackPoint);
- EmitIntent(m, INTENT_PERCEPTUAL);
+ EmitWhiteBlackD50(m, BlackPoint);
+ EmitIntent(m, INTENT_PERCEPTUAL);
- _cmsIOPrintf(m, ">>\n");
- _cmsIOPrintf(m, "]\n");
+ _cmsIOPrintf(m, ">>\n");
+ _cmsIOPrintf(m, "]\n");
- return 1;
+ return 1;
}
const char* PreMaj;
const char* PostMaj;
const char* PreMin, *PostMin;
- cmsStage* mpe;
-
- mpe = Pipeline ->Elements;
+ cmsStage* mpe;
+ mpe = Pipeline ->Elements;
- switch (cmsStageInputChannels(mpe)) {
+ switch (cmsStageInputChannels(mpe)) {
case 3:
_cmsIOPrintf(m, "[ /CIEBasedDEF\n");
- PreMaj ="<";
+ PreMaj ="<";
PostMaj= ">\n";
PreMin = PostMin = "";
break;
_cmsIOPrintf(m, "<<\n");
- if (cmsStageType(mpe) == cmsSigCurveSetElemType) {
-
+ if (cmsStageType(mpe) == cmsSigCurveSetElemType) {
+
_cmsIOPrintf(m, "/DecodeDEF [ ");
- EmitNGamma(m, cmsStageOutputChannels(mpe), _cmsStageGetPtrToCurveSet(mpe));
+ EmitNGamma(m, cmsStageOutputChannels(mpe), _cmsStageGetPtrToCurveSet(mpe));
_cmsIOPrintf(m, "]\n");
- mpe = mpe ->Next;
+ mpe = mpe ->Next;
}
+ if (cmsStageType(mpe) == cmsSigCLutElemType) {
-
- if (cmsStageType(mpe) == cmsSigCLutElemType) {
-
- _cmsIOPrintf(m, "/Table ");
+ _cmsIOPrintf(m, "/Table ");
WriteCLUT(m, mpe, PreMaj, PostMaj, PreMin, PostMin, FALSE, (cmsColorSpaceSignature) 0);
_cmsIOPrintf(m, "]\n");
}
-
+
EmitLab2XYZ(m);
EmitWhiteBlackD50(m, BlackPoint);
EmitIntent(m, Intent);
- _cmsIOPrintf(m, " >>\n");
+ _cmsIOPrintf(m, " >>\n");
_cmsIOPrintf(m, "]\n");
-
return 1;
}
// Generates a curve from a gray profile
static
-cmsToneCurve* ExtractGray2Y(cmsContext ContextID, cmsHPROFILE hProfile, int Intent)
+ cmsToneCurve* ExtractGray2Y(cmsContext ContextID, cmsHPROFILE hProfile, int Intent)
{
cmsToneCurve* Out = cmsBuildTabulatedToneCurve16(ContextID, 256, NULL);
cmsHPROFILE hXYZ = cmsCreateXYZProfile();
cmsHTRANSFORM xform = cmsCreateTransformTHR(ContextID, hProfile, TYPE_GRAY_8, hXYZ, TYPE_XYZ_DBL, Intent, cmsFLAGS_NOOPTIMIZE);
int i;
- for (i=0; i < 256; i++) {
-
- cmsUInt8Number Gray = (cmsUInt8Number) i;
- cmsCIEXYZ XYZ;
-
- cmsDoTransform(xform, &Gray, &XYZ, 1);
-
- Out ->Table16[i] =_cmsQuickSaturateWord(XYZ.Y * 65535.0);
+ if (Out != NULL) {
+ for (i=0; i < 256; i++) {
+
+ cmsUInt8Number Gray = (cmsUInt8Number) i;
+ cmsCIEXYZ XYZ;
+
+ cmsDoTransform(xform, &Gray, &XYZ, 1);
+
+ Out ->Table16[i] =_cmsQuickSaturateWord(XYZ.Y * 65535.0);
+ }
}
cmsDeleteTransform(xform);
cmsHPROFILE Profiles[2];
cmsCIEXYZ BlackPointAdaptedToD50;
- // Does create a device-link based transform.
+ // Does create a device-link based transform.
// The DeviceLink is next dumped as working CSA.
-
+
InputFormat = cmsFormatterForColorspaceOfProfile(hProfile, 2, FALSE);
nChannels = T_CHANNELS(InputFormat);
-
- cmsDetectBlackPoint(&BlackPointAdaptedToD50, hProfile, Intent, 0);
- // Adjust output to Lab4
+ cmsDetectBlackPoint(&BlackPointAdaptedToD50, hProfile, Intent, 0);
+
+ // Adjust output to Lab4
hLab = cmsCreateLab4ProfileTHR(m ->ContextID, NULL);
- Profiles[0] = hProfile;
- Profiles[1] = hLab;
+ Profiles[0] = hProfile;
+ Profiles[1] = hLab;
+
+ xform = cmsCreateMultiprofileTransform(Profiles, 2, InputFormat, TYPE_Lab_DBL, Intent, 0);
+ cmsCloseProfile(hLab);
+
+ if (xform == NULL) {
- xform = cmsCreateMultiprofileTransform(Profiles, 2, InputFormat, TYPE_Lab_DBL, Intent, 0);
- cmsCloseProfile(hLab);
-
- if (xform == NULL) {
+ cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Cannot create transform Profile -> Lab");
+ return 0;
+ }
- cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Cannot create transform Profile -> Lab");
- return 0;
- }
-
// Only 1, 3 and 4 channels are allowed
switch (nChannels) {
- case 1: {
- cmsToneCurve* Gray2Y = ExtractGray2Y(m ->ContextID, hProfile, Intent);
- EmitCIEBasedA(m, Gray2Y, &BlackPointAdaptedToD50);
- cmsFreeToneCurve(Gray2Y);
+ case 1: {
+ cmsToneCurve* Gray2Y = ExtractGray2Y(m ->ContextID, hProfile, Intent);
+ EmitCIEBasedA(m, Gray2Y, &BlackPointAdaptedToD50);
+ cmsFreeToneCurve(Gray2Y);
}
break;
- case 3:
+ case 3:
case 4: {
- cmsUInt32Number OutFrm = TYPE_Lab_16;
+ cmsUInt32Number OutFrm = TYPE_Lab_16;
cmsPipeline* DeviceLink;
_cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
- DeviceLink = cmsPipelineDup(v ->Lut);
- if (DeviceLink == NULL) return 0;
+ DeviceLink = cmsPipelineDup(v ->Lut);
+ if (DeviceLink == NULL) return 0;
+
+ dwFlags |= cmsFLAGS_FORCE_CLUT;
+ _cmsOptimizePipeline(m->ContextID, &DeviceLink, Intent, &InputFormat, &OutFrm, &dwFlags);
- dwFlags |= cmsFLAGS_FORCE_CLUT;
- _cmsOptimizePipeline(&DeviceLink, Intent, &InputFormat, &OutFrm, &dwFlags);
-
rc = EmitCIEBasedDEF(m, DeviceLink, Intent, &BlackPointAdaptedToD50);
- cmsPipelineFree(DeviceLink);
+ cmsPipelineFree(DeviceLink);
+ if (rc == 0) return 0;
}
break;
default:
- cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Only 3, 4 channels supported for CSA. This profile has %d channels.", nChannels);
+ cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Only 3, 4 channels supported for CSA. This profile has %d channels.", nChannels);
return 0;
}
-
+
cmsDeleteTransform(xform);
-
+
return 1;
}
static
int WriteInputMatrixShaper(cmsIOHANDLER* m, cmsHPROFILE hProfile, cmsStage* Matrix, cmsStage* Shaper)
{
- cmsColorSpaceSignature ColorSpace;
+ cmsColorSpaceSignature ColorSpace;
int rc;
cmsCIEXYZ BlackPointAdaptedToD50;
ColorSpace = cmsGetColorSpace(hProfile);
-
+
cmsDetectBlackPoint(&BlackPointAdaptedToD50, hProfile, INTENT_RELATIVE_COLORIMETRIC, 0);
if (ColorSpace == cmsSigGrayData) {
-
- cmsToneCurve** ShaperCurve = _cmsStageGetPtrToCurveSet(Shaper);
- rc = EmitCIEBasedA(m, ShaperCurve[0], &BlackPointAdaptedToD50);
-
+
+ cmsToneCurve** ShaperCurve = _cmsStageGetPtrToCurveSet(Shaper);
+ rc = EmitCIEBasedA(m, ShaperCurve[0], &BlackPointAdaptedToD50);
+
}
else
if (ColorSpace == cmsSigRgbData) {
-
+
cmsMAT3 Mat;
int i, j;
for (j=0; j < 3; j++)
Mat.v[i].n[j] *= MAX_ENCODEABLE_XYZ;
- rc = EmitCIEBasedABC(m, (cmsFloat64Number *) &Mat,
- _cmsStageGetPtrToCurveSet(Shaper),
- &BlackPointAdaptedToD50);
+ rc = EmitCIEBasedABC(m, (cmsFloat64Number *) &Mat,
+ _cmsStageGetPtrToCurveSet(Shaper),
+ &BlackPointAdaptedToD50);
}
else {
- cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Profile is not suitable for CSA. Unsupported colorspace.");
+ cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Profile is not suitable for CSA. Unsupported colorspace.");
return 0;
}
-
- return rc;
+
+ return rc;
}
-// Creates a PostScript color list from a named profile data.
+// Creates a PostScript color list from a named profile data.
// This is a HP extension, and it works in Lab instead of XYZ
static
char ColorName[32];
cmsNAMEDCOLORLIST* NamedColorList;
- hLab = cmsCreateLab4ProfileTHR(m ->ContextID, NULL);
+ hLab = cmsCreateLab4ProfileTHR(m ->ContextID, NULL);
xform = cmsCreateTransform(hNamedColor, TYPE_NAMED_COLOR_INDEX, hLab, TYPE_Lab_DBL, Intent, 0);
if (xform == NULL) return 0;
- NamedColorList = cmsGetNamedColorList(xform);
+ NamedColorList = cmsGetNamedColorList(xform);
if (NamedColorList == NULL) return 0;
_cmsIOPrintf(m, "<<\n");
for (i=0; i < nColors; i++) {
-
+
cmsUInt16Number In[1];
cmsCIELab Lab;
if (!cmsNamedColorInfo(NamedColorList, i, ColorName, NULL, NULL, NULL, NULL))
continue;
- cmsDoTransform(xform, In, &Lab, 1);
+ cmsDoTransform(xform, In, &Lab, 1);
_cmsIOPrintf(m, " (%s) [ %.3f %.3f %.3f ]\n", ColorName, Lab.L, Lab.a, Lab.b);
}
-
+
_cmsIOPrintf(m, ">>\n");
cmsDeleteTransform(xform);
// Does create a Color Space Array on XYZ colorspace for PostScript usage
static
-cmsUInt32Number GenerateCSA(cmsContext ContextID,
- cmsHPROFILE hProfile,
- cmsUInt32Number Intent,
- cmsUInt32Number dwFlags,
- cmsIOHANDLER* mem)
-{
- cmsUInt32Number dwBytesUsed;
- cmsPipeline* lut = NULL;
- cmsStage* Matrix, *Shaper;
+cmsUInt32Number GenerateCSA(cmsContext ContextID,
+ cmsHPROFILE hProfile,
+ cmsUInt32Number Intent,
+ cmsUInt32Number dwFlags,
+ cmsIOHANDLER* mem)
+{
+ cmsUInt32Number dwBytesUsed;
+ cmsPipeline* lut = NULL;
+ cmsStage* Matrix, *Shaper;
- // Is a named color profile?
- if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
+ // Is a named color profile?
+ if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
- if (!WriteNamedColorCSA(mem, hProfile, Intent)) goto Error;
- }
- else {
+ if (!WriteNamedColorCSA(mem, hProfile, Intent)) goto Error;
+ }
+ else {
- // Any profile class are allowed (including devicelink), but
- // output (PCS) colorspace must be XYZ or Lab
- cmsColorSpaceSignature ColorSpace = cmsGetPCS(hProfile);
+ // Any profile class are allowed (including devicelink), but
+ // output (PCS) colorspace must be XYZ or Lab
+ cmsColorSpaceSignature ColorSpace = cmsGetPCS(hProfile);
- if (ColorSpace != cmsSigXYZData &&
- ColorSpace != cmsSigLabData) {
+ if (ColorSpace != cmsSigXYZData &&
+ ColorSpace != cmsSigLabData) {
- cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "Invalid output color space");
- goto Error;
- }
+ cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "Invalid output color space");
+ goto Error;
+ }
- // Read the lut with all necessary conversion stages
- lut = _cmsReadInputLUT(hProfile, Intent);
- if (lut == NULL) goto Error;
+ // Read the lut with all necessary conversion stages
+ lut = _cmsReadInputLUT(hProfile, Intent);
+ if (lut == NULL) goto Error;
- // Tone curves + matrix can be implemented without any LUT
- if (cmsPipelineCheckAndRetreiveStages(lut, 2, cmsSigCurveSetElemType, cmsSigMatrixElemType, &Shaper, &Matrix)) {
+ // Tone curves + matrix can be implemented without any LUT
+ if (cmsPipelineCheckAndRetreiveStages(lut, 2, cmsSigCurveSetElemType, cmsSigMatrixElemType, &Shaper, &Matrix)) {
- if (!WriteInputMatrixShaper(mem, hProfile, Matrix, Shaper)) goto Error;
+ if (!WriteInputMatrixShaper(mem, hProfile, Matrix, Shaper)) goto Error;
- }
- else {
- // We need a LUT for the rest
- if (!WriteInputLUT(mem, hProfile, Intent, dwFlags)) goto Error;
- }
- }
+ }
+ else {
+ // We need a LUT for the rest
+ if (!WriteInputLUT(mem, hProfile, Intent, dwFlags)) goto Error;
+ }
+ }
- // Done, keep memory usage
- dwBytesUsed = mem ->UsedSpace;
+ // Done, keep memory usage
+ dwBytesUsed = mem ->UsedSpace;
- // Get rid of LUT
- if (lut != NULL) cmsPipelineFree(lut);
+ // Get rid of LUT
+ if (lut != NULL) cmsPipelineFree(lut);
- // Finally, return used byte count
- return dwBytesUsed;
+ // Finally, return used byte count
+ return dwBytesUsed;
Error:
- if (lut != NULL) cmsPipelineFree(lut);
- return 0;
+ if (lut != NULL) cmsPipelineFree(lut);
+ return 0;
}
// ------------------------------------------------------ Color Rendering Dictionary (CRD)
=================================
(WPout - BPout)*X - WPout*(BPin - BPout)
- out = ---------------------------------------
+ out = ---------------------------------------
WPout - BPin
Algorithm discussion
====================
-
+
TransformPQR(WPin, BPin, WPout, BPout, PQR)
Wpin,etc= { Xws Yws Zws Pws Qws Rws }
Algorithm Stack 0...n
===========================================================
PQR BPout WPout BPin WPin
- 4 index 3 get WPin PQR BPout WPout BPin WPin
- div (PQR/WPin) BPout WPout BPin WPin
- 2 index 3 get WPout (PQR/WPin) BPout WPout BPin WPin
- mult WPout*(PQR/WPin) BPout WPout BPin WPin
-
- 2 index 3 get WPout WPout*(PQR/WPin) BPout WPout BPin WPin
- 2 index 3 get BPout WPout WPout*(PQR/WPin) BPout WPout BPin WPin
- sub (WPout-BPout) WPout*(PQR/WPin) BPout WPout BPin WPin
- mult (WPout-BPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
-
- 2 index 3 get WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
- 4 index 3 get BPin WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
+ 4 index 3 get WPin PQR BPout WPout BPin WPin
+ div (PQR/WPin) BPout WPout BPin WPin
+ 2 index 3 get WPout (PQR/WPin) BPout WPout BPin WPin
+ mult WPout*(PQR/WPin) BPout WPout BPin WPin
+
+ 2 index 3 get WPout WPout*(PQR/WPin) BPout WPout BPin WPin
+ 2 index 3 get BPout WPout WPout*(PQR/WPin) BPout WPout BPin WPin
+ sub (WPout-BPout) WPout*(PQR/WPin) BPout WPout BPin WPin
+ mult (WPout-BPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
+
+ 2 index 3 get WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
+ 4 index 3 get BPin WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
3 index 3 get BPout BPin WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
-
- sub (BPin-BPout) WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
- mult (BPin-BPout)*WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
- sub (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
- 3 index 3 get BPin (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
- 3 index 3 get WPout BPin (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
+ sub (BPin-BPout) WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
+ mult (BPin-BPout)*WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
+ sub (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
+
+ 3 index 3 get BPin (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
+ 3 index 3 get WPout BPin (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
exch
- sub (WPout-BPin) (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
- div
-
- exch pop
+ sub (WPout-BPin) (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
+ div
+
+ exch pop
exch pop
exch pop
exch pop
void EmitPQRStage(cmsIOHANDLER* m, cmsHPROFILE hProfile, int DoBPC, int lIsAbsolute)
{
-
+
if (lIsAbsolute) {
- // For absolute colorimetric intent, encode back to relative
- // and generate a relative Pipeline
+ // For absolute colorimetric intent, encode back to relative
+ // and generate a relative Pipeline
- // Relative encoding is obtained across XYZpcs*(D50/WhitePoint)
+ // Relative encoding is obtained across XYZpcs*(D50/WhitePoint)
- cmsCIEXYZ White;
+ cmsCIEXYZ White;
- _cmsReadMediaWhitePoint(&White, hProfile);
+ _cmsReadMediaWhitePoint(&White, hProfile);
- _cmsIOPrintf(m,"/MatrixPQR [1 0 0 0 1 0 0 0 1 ]\n");
+ _cmsIOPrintf(m,"/MatrixPQR [1 0 0 0 1 0 0 0 1 ]\n");
_cmsIOPrintf(m,"/RangePQR [ -0.5 2 -0.5 2 -0.5 2 ]\n");
_cmsIOPrintf(m, "%% Absolute colorimetric -- encode to relative to maximize LUT usage\n"
"/TransformPQR [\n"
"{0.9642 mul %g div exch pop exch pop exch pop exch pop} bind\n"
"{1.0000 mul %g div exch pop exch pop exch pop exch pop} bind\n"
- "{0.8249 mul %g div exch pop exch pop exch pop exch pop} bind\n]\n",
- White.X, White.Y, White.Z);
+ "{0.8249 mul %g div exch pop exch pop exch pop exch pop} bind\n]\n",
+ White.X, White.Y, White.Z);
return;
}
"/TransformPQR [\n"
"{exch pop exch 3 get mul exch pop exch 3 get div} bind\n"
"{exch pop exch 4 get mul exch pop exch 4 get div} bind\n"
- "{exch pop exch 5 get mul exch pop exch 5 get div} bind\n]\n");
+ "{exch pop exch 5 get mul exch pop exch 5 get div} bind\n]\n");
} else {
// BPC
_cmsIOPrintf(m, "%% VonKries-like transform in Bradford Cone Space plus BPC\n"
"/TransformPQR [\n");
-
+
_cmsIOPrintf(m, "{4 index 3 get div 2 index 3 get mul "
- "2 index 3 get 2 index 3 get sub mul "
+ "2 index 3 get 2 index 3 get sub mul "
"2 index 3 get 4 index 3 get 3 index 3 get sub mul sub "
"3 index 3 get 3 index 3 get exch sub div "
"exch pop exch pop exch pop exch pop } bind\n");
"exch pop exch pop exch pop exch pop } bind\n]\n");
}
-
-
+
+
}
static
void EmitXYZ2Lab(cmsIOHANDLER* m)
{
- _cmsIOPrintf(m, "/RangeLMN [ -0.635 2.0 0 2 -0.635 2.0 ]\n");
+ _cmsIOPrintf(m, "/RangeLMN [ -0.635 2.0 0 2 -0.635 2.0 ]\n");
_cmsIOPrintf(m, "/EncodeLMN [\n");
_cmsIOPrintf(m, "{ 0.964200 div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind\n");
_cmsIOPrintf(m, "{ 1.000000 div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind\n");
_cmsIOPrintf(m, "]\n");
_cmsIOPrintf(m, "/MatrixABC [ 0 1 0 1 -1 1 0 0 -1 ]\n");
_cmsIOPrintf(m, "/EncodeABC [\n");
-
-
+
+
_cmsIOPrintf(m, "{ 116 mul 16 sub 100 div } bind\n");
_cmsIOPrintf(m, "{ 500 mul 128 add 256 div } bind\n");
_cmsIOPrintf(m, "{ 200 mul 128 add 256 div } bind\n");
-
-
+
+
_cmsIOPrintf(m, "]\n");
-
+
}
// Due to impedance mismatch between XYZ and almost all RGB and CMYK spaces
// I choose to dump LUTS in Lab instead of XYZ. There is still a lot of wasted
// space on 3D CLUT, but since space seems not to be a problem here, 33 points
-// would give a reasonable accurancy. Note also that CRD tables must operate in
+// would give a reasonable accurancy. Note also that CRD tables must operate in
// 8 bits.
static
cmsCIEXYZ BlackPointAdaptedToD50;
cmsBool lDoBPC = (dwFlags & cmsFLAGS_BLACKPOINTCOMPENSATION);
cmsBool lFixWhite = !(dwFlags & cmsFLAGS_NOWHITEONWHITEFIXUP);
- cmsUInt32Number InFrm = TYPE_Lab_16;
- int RelativeEncodingIntent;
- cmsColorSpaceSignature ColorSpace;
-
-
- hLab = cmsCreateLab4ProfileTHR(m ->ContextID, NULL);
- if (hLab == NULL) return 0;
+ cmsUInt32Number InFrm = TYPE_Lab_16;
+ int RelativeEncodingIntent;
+ cmsColorSpaceSignature ColorSpace;
+
+
+ hLab = cmsCreateLab4ProfileTHR(m ->ContextID, NULL);
+ if (hLab == NULL) return 0;
OutputFormat = cmsFormatterForColorspaceOfProfile(hProfile, 2, FALSE);
- nChannels = T_CHANNELS(OutputFormat);
+ nChannels = T_CHANNELS(OutputFormat);
- ColorSpace = cmsGetColorSpace(hProfile);
+ ColorSpace = cmsGetColorSpace(hProfile);
- // For absolute colorimetric, the LUT is encoded as relative in order to preserve precision.
+ // For absolute colorimetric, the LUT is encoded as relative in order to preserve precision.
RelativeEncodingIntent = Intent;
- if (RelativeEncodingIntent == INTENT_ABSOLUTE_COLORIMETRIC)
- RelativeEncodingIntent = INTENT_RELATIVE_COLORIMETRIC;
+ if (RelativeEncodingIntent == INTENT_ABSOLUTE_COLORIMETRIC)
+ RelativeEncodingIntent = INTENT_RELATIVE_COLORIMETRIC;
- // Use V4 Lab always
- Profiles[0] = hLab;
- Profiles[1] = hProfile;
+ // Use V4 Lab always
+ Profiles[0] = hLab;
+ Profiles[1] = hProfile;
- xform = cmsCreateMultiprofileTransformTHR(m ->ContextID,
- Profiles, 2, TYPE_Lab_DBL,
- OutputFormat, RelativeEncodingIntent, 0);
- cmsCloseProfile(hLab);
+ xform = cmsCreateMultiprofileTransformTHR(m ->ContextID,
+ Profiles, 2, TYPE_Lab_DBL,
+ OutputFormat, RelativeEncodingIntent, 0);
+ cmsCloseProfile(hLab);
if (xform == NULL) {
-
- cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Cannot create transform Lab -> Profile in CRD creation");
+
+ cmsSignalError(m ->ContextID, cmsERROR_COLORSPACE_CHECK, "Cannot create transform Lab -> Profile in CRD creation");
return 0;
}
// Get a copy of the internal devicelink
v = (_cmsTRANSFORM*) xform;
DeviceLink = cmsPipelineDup(v ->Lut);
- if (DeviceLink == NULL) return 0;
-
-
- // We need a CLUT
- dwFlags |= cmsFLAGS_FORCE_CLUT;
- _cmsOptimizePipeline(&DeviceLink, RelativeEncodingIntent, &InFrm, &OutputFormat, &dwFlags);
-
+ if (DeviceLink == NULL) return 0;
+
+
+ // We need a CLUT
+ dwFlags |= cmsFLAGS_FORCE_CLUT;
+ _cmsOptimizePipeline(m->ContextID, &DeviceLink, RelativeEncodingIntent, &InFrm, &OutputFormat, &dwFlags);
+
_cmsIOPrintf(m, "<<\n");
_cmsIOPrintf(m, "/ColorRenderingType 1\n");
EmitWhiteBlackD50(m, &BlackPointAdaptedToD50);
EmitPQRStage(m, hProfile, lDoBPC, Intent == INTENT_ABSOLUTE_COLORIMETRIC);
EmitXYZ2Lab(m);
-
-
- // FIXUP: map Lab (100, 0, 0) to perfect white, because the particular encoding for Lab
- // does map a=b=0 not falling into any specific node. Since range a,b goes -128..127,
+
+
+ // FIXUP: map Lab (100, 0, 0) to perfect white, because the particular encoding for Lab
+ // does map a=b=0 not falling into any specific node. Since range a,b goes -128..127,
// zero is slightly moved towards right, so assure next node (in L=100 slice) is mapped to
// zero. This would sacrifice a bit of highlights, but failure to do so would cause
// scum dot. Ouch.
-
+
if (Intent == INTENT_ABSOLUTE_COLORIMETRIC)
lFixWhite = FALSE;
_cmsIOPrintf(m, "/RenderTable ");
-
-
+
+
WriteCLUT(m, cmsPipelineGetPtrToFirstStage(DeviceLink), "<", ">\n", "", "", lFixWhite, ColorSpace);
-
+
_cmsIOPrintf(m, " %d {} bind ", nChannels);
for (i=1; i < nChannels; i++)
_cmsIOPrintf(m, "]\n");
-
+
EmitIntent(m, Intent);
_cmsIOPrintf(m, ">>\n");
cmsPipelineFree(DeviceLink);
cmsDeleteTransform(xform);
-
- return 1;
+
+ return 1;
}
sprintf(Buff, "%.3f", Out[j] / 65535.0);
strcat(Colorant, Buff);
- if (j < nColorant -1)
+ if (j < nColorant -1)
strcat(Colorant, " ");
- }
+ }
}
-// Creates a PostScript color list from a named profile data.
+// Creates a PostScript color list from a named profile data.
// This is a HP extension.
static
int WriteNamedColorCRD(cmsIOHANDLER* m, cmsHPROFILE hNamedColor, int Intent, cmsUInt32Number dwFlags)
{
- cmsHTRANSFORM xform;
+ cmsHTRANSFORM xform;
int i, nColors, nColorant;
cmsUInt32Number OutputFormat;
char ColorName[32];
char Colorant[128];
- cmsNAMEDCOLORLIST* NamedColorList;
+ cmsNAMEDCOLORLIST* NamedColorList;
+
-
OutputFormat = cmsFormatterForColorspaceOfProfile(hNamedColor, 2, FALSE);
- nColorant = T_CHANNELS(OutputFormat);
+ nColorant = T_CHANNELS(OutputFormat);
+
-
xform = cmsCreateTransform(hNamedColor, TYPE_NAMED_COLOR_INDEX, NULL, OutputFormat, Intent, dwFlags);
if (xform == NULL) return 0;
- NamedColorList = cmsGetNamedColorList(xform);
- if (NamedColorList == NULL) return 0;
+ NamedColorList = cmsGetNamedColorList(xform);
+ if (NamedColorList == NULL) return 0;
_cmsIOPrintf(m, "<<\n");
_cmsIOPrintf(m, "(colorlistcomment) (%s) \n", "Named profile");
_cmsIOPrintf(m, "(Suffix) [ ( CV) ( CVC) ( C) ]\n");
nColors = cmsNamedColorCount(NamedColorList);
-
+
for (i=0; i < nColors; i++) {
-
+
cmsUInt16Number In[1];
cmsUInt16Number Out[cmsMAXCHANNELS];
if (!cmsNamedColorInfo(NamedColorList, i, ColorName, NULL, NULL, NULL, NULL))
continue;
- cmsDoTransform(xform, In, Out, 1);
+ cmsDoTransform(xform, In, Out, 1);
BuildColorantList(Colorant, nColorant, Out);
_cmsIOPrintf(m, " (%s) [ %s ]\n", ColorName, Colorant);
}
_cmsIOPrintf(m, " /Current exch /HPSpotTable defineresource pop\n");
}
- cmsDeleteTransform(xform);
+ cmsDeleteTransform(xform);
return 1;
}
-// This one does create a Color Rendering Dictionary.
+// This one does create a Color Rendering Dictionary.
// CRD are always LUT-Based, no matter if profile is
// implemented as matrix-shaper.
static
cmsUInt32Number GenerateCRD(cmsContext ContextID,
- cmsHPROFILE hProfile,
- cmsUInt32Number Intent, cmsUInt32Number dwFlags,
- cmsIOHANDLER* mem)
-{
- cmsUInt32Number dwBytesUsed;
+ cmsHPROFILE hProfile,
+ cmsUInt32Number Intent, cmsUInt32Number dwFlags,
+ cmsIOHANDLER* mem)
+{
+ cmsUInt32Number dwBytesUsed;
- if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
+ if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
- EmitHeader(mem, "Color Rendering Dictionary (CRD)", hProfile);
- }
+ EmitHeader(mem, "Color Rendering Dictionary (CRD)", hProfile);
+ }
- // Is a named color profile?
- if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
+ // Is a named color profile?
+ if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
- if (!WriteNamedColorCRD(mem, hProfile, Intent, dwFlags)) {
- return 0;
- }
- }
- else {
+ if (!WriteNamedColorCRD(mem, hProfile, Intent, dwFlags)) {
+ return 0;
+ }
+ }
+ else {
- // CRD are always implemented as LUT
+ // CRD are always implemented as LUT
- if (!WriteOutputLUT(mem, hProfile, Intent, dwFlags)) {
- return 0;
- }
- }
+ if (!WriteOutputLUT(mem, hProfile, Intent, dwFlags)) {
+ return 0;
+ }
+ }
- if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
+ if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
- _cmsIOPrintf(mem, "%%%%EndResource\n");
- _cmsIOPrintf(mem, "\n%% CRD End\n");
- }
+ _cmsIOPrintf(mem, "%%%%EndResource\n");
+ _cmsIOPrintf(mem, "\n%% CRD End\n");
+ }
- // Done, keep memory usage
- dwBytesUsed = mem ->UsedSpace;
+ // Done, keep memory usage
+ dwBytesUsed = mem ->UsedSpace;
- // Finally, return used byte count
- return dwBytesUsed;
+ // Finally, return used byte count
+ return dwBytesUsed;
- cmsUNUSED_PARAMETER(ContextID);
+ cmsUNUSED_PARAMETER(ContextID);
}
-cmsUInt32Number CMSEXPORT cmsGetPostScriptColorResource(cmsContext ContextID,
- cmsPSResourceType Type,
- cmsHPROFILE hProfile,
- cmsUInt32Number Intent,
- cmsUInt32Number dwFlags,
- cmsIOHANDLER* io)
+cmsUInt32Number CMSEXPORT cmsGetPostScriptColorResource(cmsContext ContextID,
+ cmsPSResourceType Type,
+ cmsHPROFILE hProfile,
+ cmsUInt32Number Intent,
+ cmsUInt32Number dwFlags,
+ cmsIOHANDLER* io)
{
- cmsUInt32Number rc;
+ cmsUInt32Number rc;
+
+ switch (Type) {
- switch (Type) {
+ case cmsPS_RESOURCE_CSA:
+ rc = GenerateCSA(ContextID, hProfile, Intent, dwFlags, io);
+ break;
- case cmsPS_RESOURCE_CSA:
- rc = GenerateCSA(ContextID, hProfile, Intent, dwFlags, io);
- break;
-
- default:
- case cmsPS_RESOURCE_CRD:
- rc = GenerateCRD(ContextID, hProfile, Intent, dwFlags, io);
- break;
- }
+ default:
+ case cmsPS_RESOURCE_CRD:
+ rc = GenerateCRD(ContextID, hProfile, Intent, dwFlags, io);
+ break;
+ }
- return rc;
+ return rc;
}
cmsUInt32Number CMSEXPORT cmsGetPostScriptCRD(cmsContext ContextID,
- cmsHPROFILE hProfile,
+ cmsHPROFILE hProfile,
cmsUInt32Number Intent, cmsUInt32Number dwFlags,
void* Buffer, cmsUInt32Number dwBufferLen)
{
- cmsIOHANDLER* mem;
+ cmsIOHANDLER* mem;
cmsUInt32Number dwBytesUsed;
// Set up the serialization engine
- if (Buffer == NULL)
- mem = cmsOpenIOhandlerFromNULL(ContextID);
- else
+ if (Buffer == NULL)
+ mem = cmsOpenIOhandlerFromNULL(ContextID);
+ else
mem = cmsOpenIOhandlerFromMem(ContextID, Buffer, dwBufferLen, "w");
if (!mem) return 0;
- dwBytesUsed = cmsGetPostScriptColorResource(ContextID, cmsPS_RESOURCE_CRD, hProfile, Intent, dwFlags, mem);
-
+ dwBytesUsed = cmsGetPostScriptColorResource(ContextID, cmsPS_RESOURCE_CRD, hProfile, Intent, dwFlags, mem);
+
// Get rid of memory stream
- cmsCloseIOhandler(mem);
+ cmsCloseIOhandler(mem);
- return dwBytesUsed;
+ return dwBytesUsed;
}
// Does create a Color Space Array on XYZ colorspace for PostScript usage
-cmsUInt32Number CMSEXPORT cmsGetPostScriptCSA(cmsContext ContextID,
- cmsHPROFILE hProfile,
- cmsUInt32Number Intent,
- cmsUInt32Number dwFlags,
- void* Buffer,
- cmsUInt32Number dwBufferLen)
+cmsUInt32Number CMSEXPORT cmsGetPostScriptCSA(cmsContext ContextID,
+ cmsHPROFILE hProfile,
+ cmsUInt32Number Intent,
+ cmsUInt32Number dwFlags,
+ void* Buffer,
+ cmsUInt32Number dwBufferLen)
{
- cmsIOHANDLER* mem;
+ cmsIOHANDLER* mem;
cmsUInt32Number dwBytesUsed;
-
- if (Buffer == NULL)
- mem = cmsOpenIOhandlerFromNULL(ContextID);
- else
+
+ if (Buffer == NULL)
+ mem = cmsOpenIOhandlerFromNULL(ContextID);
+ else
mem = cmsOpenIOhandlerFromMem(ContextID, Buffer, dwBufferLen, "w");
if (!mem) return 0;
- dwBytesUsed = cmsGetPostScriptColorResource(ContextID, cmsPS_RESOURCE_CSA, hProfile, Intent, dwFlags, mem);
-
+ dwBytesUsed = cmsGetPostScriptColorResource(ContextID, cmsPS_RESOURCE_CSA, hProfile, Intent, dwFlags, mem);
+
// Get rid of memory stream
- cmsCloseIOhandler(mem);
+ cmsCloseIOhandler(mem);
- return dwBytesUsed;
+ return dwBytesUsed;
}
// Little Color Management System
// Copyright (c) 1998-2010 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
#include "lcms2_internal.h"
+#define cmsmin(a, b) (((a) < (b)) ? (a) : (b))
+#define cmsmax(a, b) (((a) > (b)) ? (a) : (b))
// This file contains routines for resampling and LUT optimization, black point detection
-// and black preservation.
+// and black preservation.
// Black point detection -------------------------------------------------------------------------
-// PCS -> PCS round trip transform, always uses relative intent on the device -> pcs
+// PCS -> PCS round trip transform, always uses relative intent on the device -> pcs
static
cmsHTRANSFORM CreateRoundtripXForm(cmsHPROFILE hProfile, cmsUInt32Number nIntent)
{
- cmsHPROFILE hLab = cmsCreateLab4Profile(NULL);
+ cmsContext ContextID = cmsGetProfileContextID(hProfile);
+ cmsHPROFILE hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
cmsHTRANSFORM xform;
cmsBool BPC[4] = { FALSE, FALSE, FALSE, FALSE };
cmsFloat64Number States[4] = { 1.0, 1.0, 1.0, 1.0 };
cmsHPROFILE hProfiles[4];
cmsUInt32Number Intents[4];
- cmsContext ContextID = cmsGetProfileContextID(hProfile);
hProfiles[0] = hLab; hProfiles[1] = hProfile; hProfiles[2] = hProfile; hProfiles[3] = hLab;
Intents[0] = INTENT_RELATIVE_COLORIMETRIC; Intents[1] = nIntent; Intents[2] = INTENT_RELATIVE_COLORIMETRIC; Intents[3] = INTENT_RELATIVE_COLORIMETRIC;
- xform = cmsCreateExtendedTransform(ContextID, 4, hProfiles, BPC, Intents,
+ xform = cmsCreateExtendedTransform(ContextID, 4, hProfiles, BPC, Intents,
States, NULL, 0, TYPE_Lab_DBL, TYPE_Lab_DBL, cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
cmsCloseProfile(hLab);
// Use darker colorants to obtain black point. This works in the relative colorimetric intent and
// assumes more ink results in darker colors. No ink limit is assumed.
static
-cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
+cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
cmsUInt32Number Intent,
cmsCIEXYZ* BlackPoint,
cmsUInt32Number dwFlags)
cmsHTRANSFORM xform;
cmsColorSpaceSignature Space;
cmsUInt32Number nChannels;
- cmsUInt32Number dwFormat;
+ cmsUInt32Number dwFormat;
cmsHPROFILE hLab;
cmsCIELab Lab;
- cmsCIEXYZ BlackXYZ;
+ cmsCIEXYZ BlackXYZ;
cmsContext ContextID = cmsGetProfileContextID(hInput);
-
- // If the profile does not support input direction, assume Black point 0
+
+ // If the profile does not support input direction, assume Black point 0
if (!cmsIsIntentSupported(hInput, Intent, LCMS_USED_AS_INPUT)) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE;
}
-
+
// Create a formatter which has n channels and floating point
dwFormat = cmsFormatterForColorspaceOfProfile(hInput, 2, FALSE);
- // Try to get black by using black colorant
+ // Try to get black by using black colorant
Space = cmsGetColorSpace(hInput);
// This function returns darker colorant in 16 bits for several spaces
if (!_cmsEndPointsBySpace(Space, NULL, &Black, &nChannels)) {
-
+
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE;
}
hLab = cmsCreateLab2ProfileTHR(ContextID, NULL);
if (hLab == NULL) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
- return FALSE;
+ return FALSE;
}
// Create the transform
xform = cmsCreateTransformTHR(ContextID, hInput, dwFormat,
hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
cmsCloseProfile(hLab);
-
+
if (xform == NULL) {
+
// Something went wrong. Get rid of open resources and return zero as black
-
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE;
}
-
+
// Convert black to Lab
cmsDoTransform(xform, Black, &Lab, 1);
Lab.a = Lab.b = 0;
if (Lab.L > 50) Lab.L = 50;
- // Free the resources
+ // Free the resources
cmsDeleteTransform(xform);
-
+
// Convert from Lab (which is now clipped) to XYZ.
cmsLab2XYZ(NULL, &BlackXYZ, &Lab);
-
+
if (BlackPoint != NULL)
*BlackPoint = BlackXYZ;
-
+
return TRUE;
cmsUNUSED_PARAMETER(dwFlags);
}
-// Get a black point of output CMYK profile, discounting any ink-limiting embedded
+// Get a black point of output CMYK profile, discounting any ink-limiting embedded
// in the profile. For doing that, we use perceptual intent in input direction:
// Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab
static
cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile)
-
-{
- cmsHTRANSFORM hRoundTrip;
+{
+ cmsHTRANSFORM hRoundTrip;
cmsCIELab LabIn, LabOut;
- cmsCIEXYZ BlackXYZ;
-
+ cmsCIEXYZ BlackXYZ;
+
// Is the intent supported by the profile?
if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return TRUE;
}
-
+
hRoundTrip = CreateRoundtripXForm(hProfile, INTENT_PERCEPTUAL);
if (hRoundTrip == NULL) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
LabOut.a = LabOut.b = 0;
cmsDeleteTransform(hRoundTrip);
-
+
// Convert it to XYZ
- cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);
-
+ cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);
+
if (BlackPoint != NULL)
*BlackPoint = BlackXYZ;
}
// This function shouldn't exist at all -- there is such quantity of broken
-// profiles on black point tag, that we must somehow fix chromaticity to
+// profiles on black point tag, that we must somehow fix chromaticity to
// avoid huge tint when doing Black point compensation. This function does
-// just that. There is a special flag for using black point tag, but turned
-// off by default because it is bogus on most profiles. The detection algorithm
-// involves to turn BP to neutral and to use only L component.
-
+// just that. There is a special flag for using black point tag, but turned
+// off by default because it is bogus on most profiles. The detection algorithm
+// involves to turn BP to neutral and to use only L component.
cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
-{
-
- // Zero for black point
- if (cmsGetDeviceClass(hProfile) == cmsSigLinkClass) {
+{
+ cmsProfileClassSignature devClass;
+
+ // Make sure the device class is adequate
+ devClass = cmsGetDeviceClass(hProfile);
+ if (devClass == cmsSigLinkClass ||
+ devClass == cmsSigAbstractClass ||
+ devClass == cmsSigNamedColorClass) {
+ BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+ return FALSE;
+ }
- BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
- return FALSE;
+ // Make sure intent is adequate
+ if (Intent != INTENT_PERCEPTUAL &&
+ Intent != INTENT_RELATIVE_COLORIMETRIC &&
+ Intent != INTENT_SATURATION) {
+ BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+ return FALSE;
}
- // v4 + perceptual & saturation intents does have its own black point, and it is
+ // v4 + perceptual & saturation intents does have its own black point, and it is
// well specified enough to use it. Black point tag is deprecated in V4.
-
- if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
+ if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
(Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
// Matrix shaper share MRC & perceptual intents
- if (cmsIsMatrixShaper(hProfile))
+ if (cmsIsMatrixShaper(hProfile))
return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
// Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents
- BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
+ BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
BlackPoint -> Y = cmsPERCEPTUAL_BLACK_Y;
BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
#ifdef CMS_USE_PROFILE_BLACK_POINT_TAG
// v2, v4 rel/abs colorimetric
- if (cmsIsTag(hProfile, cmsSigMediaBlackPointTag) &&
+ if (cmsIsTag(hProfile, cmsSigMediaBlackPointTag) &&
Intent == INTENT_RELATIVE_COLORIMETRIC) {
cmsCIEXYZ *BlackPtr, BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite;
cmsCIELab Lab;
- // If black point is specified, then use it,
+ // If black point is specified, then use it,
BlackPtr = cmsReadTag(hProfile, cmsSigMediaBlackPointTag);
if (BlackPtr != NULL) {
if (BlackPoint != NULL)
*BlackPoint = TrustedBlackPoint;
-
+
return TRUE;
}
}
#endif
- // That is about v2 profiles.
+ // That is about v2 profiles.
// If output profile, discount ink-limiting and that's all
- if (Intent == INTENT_RELATIVE_COLORIMETRIC &&
+ if (Intent == INTENT_RELATIVE_COLORIMETRIC &&
(cmsGetDeviceClass(hProfile) == cmsSigOutputClass) &&
(cmsGetColorSpace(hProfile) == cmsSigCmykData))
return BlackPointUsingPerceptualBlack(BlackPoint, hProfile);
}
+
+// ---------------------------------------------------------------------------------------------------------
+
+// Least Squares Fit of a Quadratic Curve to Data
+// http://www.personal.psu.edu/jhm/f90/lectures/lsq2.html
+
+static
+cmsFloat64Number RootOfLeastSquaresFitQuadraticCurve(int n, cmsFloat64Number x[], cmsFloat64Number y[])
+{
+ double sum_x = 0, sum_x2 = 0, sum_x3 = 0, sum_x4 = 0;
+ double sum_y = 0, sum_yx = 0, sum_yx2 = 0;
+ double d, a, b, c;
+ int i;
+ cmsMAT3 m;
+ cmsVEC3 v, res;
+
+ if (n < 4) return 0;
+
+ for (i=0; i < n; i++) {
+
+ double xn = x[i];
+ double yn = y[i];
+
+ sum_x += xn;
+ sum_x2 += xn*xn;
+ sum_x3 += xn*xn*xn;
+ sum_x4 += xn*xn*xn*xn;
+
+ sum_y += yn;
+ sum_yx += yn*xn;
+ sum_yx2 += yn*xn*xn;
+ }
+
+ _cmsVEC3init(&m.v[0], n, sum_x, sum_x2);
+ _cmsVEC3init(&m.v[1], sum_x, sum_x2, sum_x3);
+ _cmsVEC3init(&m.v[2], sum_x2, sum_x3, sum_x4);
+
+ _cmsVEC3init(&v, sum_y, sum_yx, sum_yx2);
+
+ if (!_cmsMAT3solve(&res, &m, &v)) return 0;
+
+
+ a = res.n[2];
+ b = res.n[1];
+ c = res.n[0];
+
+ if (fabs(a) < 1.0E-10) {
+
+ return cmsmin(0, cmsmax(50, -c/b ));
+ }
+ else {
+
+ d = b*b - 4.0 * a * c;
+ if (d <= 0) {
+ return 0;
+ }
+ else {
+
+ double rt = (-b + sqrt(d)) / (2.0 * a);
+
+ return cmsmax(0, cmsmin(50, rt));
+ }
+ }
+
+}
+
+/*
+static
+cmsBool IsMonotonic(int n, const cmsFloat64Number Table[])
+{
+ int i;
+ cmsFloat64Number last;
+
+ last = Table[n-1];
+
+ for (i = n-2; i >= 0; --i) {
+
+ if (Table[i] > last)
+
+ return FALSE;
+ else
+ last = Table[i];
+
+ }
+
+ return TRUE;
+}
+*/
+
+// Calculates the black point of a destination profile.
+// This algorithm comes from the Adobe paper disclosing its black point compensation method.
+cmsBool CMSEXPORT cmsDetectDestinationBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
+{
+ cmsColorSpaceSignature ColorSpace;
+ cmsHTRANSFORM hRoundTrip = NULL;
+ cmsCIELab InitialLab, destLab, Lab;
+ cmsFloat64Number inRamp[256], outRamp[256];
+ cmsFloat64Number MinL, MaxL;
+ cmsBool NearlyStraightMidrange = TRUE;
+ cmsFloat64Number yRamp[256];
+ cmsFloat64Number x[256], y[256];
+ cmsFloat64Number lo, hi;
+ int n, l;
+ cmsProfileClassSignature devClass;
+
+ // Make sure the device class is adequate
+ devClass = cmsGetDeviceClass(hProfile);
+ if (devClass == cmsSigLinkClass ||
+ devClass == cmsSigAbstractClass ||
+ devClass == cmsSigNamedColorClass) {
+ BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+ return FALSE;
+ }
+
+ // Make sure intent is adequate
+ if (Intent != INTENT_PERCEPTUAL &&
+ Intent != INTENT_RELATIVE_COLORIMETRIC &&
+ Intent != INTENT_SATURATION) {
+ BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+ return FALSE;
+ }
+
+
+ // v4 + perceptual & saturation intents does have its own black point, and it is
+ // well specified enough to use it. Black point tag is deprecated in V4.
+ if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
+ (Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
+
+ // Matrix shaper share MRC & perceptual intents
+ if (cmsIsMatrixShaper(hProfile))
+ return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
+
+ // Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents
+ BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
+ BlackPoint -> Y = cmsPERCEPTUAL_BLACK_Y;
+ BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
+ return TRUE;
+ }
+
+
+ // Check if the profile is lut based and gray, rgb or cmyk (7.2 in Adobe's document)
+ ColorSpace = cmsGetColorSpace(hProfile);
+ if (!cmsIsCLUT(hProfile, Intent, LCMS_USED_AS_OUTPUT ) ||
+ (ColorSpace != cmsSigGrayData &&
+ ColorSpace != cmsSigRgbData &&
+ ColorSpace != cmsSigCmykData)) {
+
+ // In this case, handle as input case
+ return cmsDetectBlackPoint(BlackPoint, hProfile, Intent, dwFlags);
+ }
+
+ // It is one of the valid cases!, use Adobe algorithm
+
+
+ // Set a first guess, that should work on good profiles.
+ if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
+
+ cmsCIEXYZ IniXYZ;
+
+ // calculate initial Lab as source black point
+ if (!cmsDetectBlackPoint(&IniXYZ, hProfile, Intent, dwFlags)) {
+ return FALSE;
+ }
+
+ // convert the XYZ to lab
+ cmsXYZ2Lab(NULL, &InitialLab, &IniXYZ);
+
+ } else {
+
+ // set the initial Lab to zero, that should be the black point for perceptual and saturation
+ InitialLab.L = 0;
+ InitialLab.a = 0;
+ InitialLab.b = 0;
+ }
+
+
+ // Step 2
+ // ======
+
+ // Create a roundtrip. Define a Transform BT for all x in L*a*b*
+ hRoundTrip = CreateRoundtripXForm(hProfile, Intent);
+ if (hRoundTrip == NULL) return FALSE;
+
+ // Compute ramps
+
+ for (l=0; l < 256; l++) {
+
+ Lab.L = (cmsFloat64Number) (l * 100.0) / 255.0;
+ Lab.a = cmsmin(50, cmsmax(-50, InitialLab.a));
+ Lab.b = cmsmin(50, cmsmax(-50, InitialLab.b));
+
+ cmsDoTransform(hRoundTrip, &Lab, &destLab, 1);
+
+ inRamp[l] = Lab.L;
+ outRamp[l] = destLab.L;
+ }
+
+ // Make monotonic
+ for (l = 254; l > 0; --l) {
+ outRamp[l] = cmsmin(outRamp[l], outRamp[l+1]);
+ }
+
+ // Check
+ if (! (outRamp[0] < outRamp[255])) {
+
+ cmsDeleteTransform(hRoundTrip);
+ BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+ return FALSE;
+ }
+
+
+ // Test for mid range straight (only on relative colorimetric)
+
+ NearlyStraightMidrange = TRUE;
+ MinL = outRamp[0]; MaxL = outRamp[255];
+ if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
+
+ for (l=0; l < 256; l++) {
+
+ if (! ((inRamp[l] <= MinL + 0.2 * (MaxL - MinL) ) ||
+ (fabs(inRamp[l] - outRamp[l]) < 4.0 )))
+ NearlyStraightMidrange = FALSE;
+ }
+
+ // If the mid range is straight (as determined above) then the
+ // DestinationBlackPoint shall be the same as initialLab.
+ // Otherwise, the DestinationBlackPoint shall be determined
+ // using curve fitting.
+
+ if (NearlyStraightMidrange) {
+
+ cmsLab2XYZ(NULL, BlackPoint, &InitialLab);
+ cmsDeleteTransform(hRoundTrip);
+ return TRUE;
+ }
+ }
+
+
+ // curve fitting: The round-trip curve normally looks like a nearly constant section at the black point,
+ // with a corner and a nearly straight line to the white point.
+
+ for (l=0; l < 256; l++) {
+
+ yRamp[l] = (outRamp[l] - MinL) / (MaxL - MinL);
+ }
+
+ // find the black point using the least squares error quadratic curve fitting
+
+ if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
+ lo = 0.1;
+ hi = 0.5;
+ }
+ else {
+
+ // Perceptual and saturation
+ lo = 0.03;
+ hi = 0.25;
+ }
+
+ // Capture shadow points for the fitting.
+ n = 0;
+ for (l=0; l < 256; l++) {
+
+ cmsFloat64Number ff = yRamp[l];
+
+ if (ff >= lo && ff < hi) {
+ x[n] = inRamp[l];
+ y[n] = yRamp[l];
+ n++;
+ }
+ }
+
+
+ // No suitable points
+ if (n < 3 ) {
+ cmsDeleteTransform(hRoundTrip);
+ BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+ return FALSE;
+ }
+
+
+ // fit and get the vertex of quadratic curve
+ Lab.L = RootOfLeastSquaresFitQuadraticCurve(n, x, y);
+
+ if (Lab.L < 0.0) { // clip to zero L* if the vertex is negative
+ Lab.L = 0;
+ }
+
+ Lab.a = InitialLab.a;
+ Lab.b = InitialLab.b;
+
+ cmsLab2XYZ(NULL, BlackPoint, &Lab);
+
+ cmsDeleteTransform(hRoundTrip);
+ return TRUE;
+}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2011 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// alpha = Hab
// theta = L*
-#define SECTORS 16 // number of divisions in alpha and theta
+#define SECTORS 16 // number of divisions in alpha and theta
// Spherical coordinates
typedef struct {
} cmsSpherical;
-typedef enum {
+typedef enum {
GP_EMPTY,
GP_SPECIFIED,
GP_MODELED
cmsFloat64Number _cmsAtan2(cmsFloat64Number y, cmsFloat64Number x)
{
cmsFloat64Number a;
-
+
// Deal with undefined case
if (x == 0.0 && y == 0.0) return 0;
{
cmsFloat64Number L, a, b;
-
+
L = v ->n[VX];
a = v ->n[VY];
b = v ->n[VZ];
-
+
sp ->r = sqrt( L*L + a*a + b*b );
if (sp ->r == 0) {
sp ->alpha = sp ->theta = 0;
return;
}
-
- sp ->alpha = _cmsAtan2(a, b);
- sp ->theta = _cmsAtan2(sqrt(a*a + b*b), L);
+
+ sp ->alpha = _cmsAtan2(a, b);
+ sp ->theta = _cmsAtan2(sqrt(a*a + b*b), L);
}
cos_theta = cos((M_PI * sp ->theta) / 180.0);
a = sp ->r * sin_theta * sin_alpha;
- b = sp ->r * sin_theta * cos_alpha;
+ b = sp ->r * sin_theta * cos_alpha;
L = sp ->r * cos_theta;
v ->n[VX] = L;
// The limits are the centers of each sector, so
static
void QuantizeToSector(const cmsSpherical* sp, int* alpha, int* theta)
-{
- *alpha = (int) floor(((sp->alpha * (SECTORS)) / 360.0) );
- *theta = (int) floor(((sp->theta * (SECTORS)) / 180.0) );
-
- if (*alpha >= SECTORS)
- *alpha = SECTORS-1;
- if (*theta >= SECTORS)
- *theta = SECTORS-1;
+{
+ *alpha = (int) floor(((sp->alpha * (SECTORS)) / 360.0) );
+ *theta = (int) floor(((sp->theta * (SECTORS)) / 180.0) );
+
+ if (*alpha >= SECTORS)
+ *alpha = SECTORS-1;
+ if (*theta >= SECTORS)
+ *theta = SECTORS-1;
}
{
_cmsVEC3init(&line ->a, a ->n[VX], a ->n[VY], a ->n[VZ]);
- _cmsVEC3init(&line ->u, b ->n[VX] - a ->n[VX],
- b ->n[VY] - a ->n[VY],
- b ->n[VZ] - a ->n[VZ]);
+ _cmsVEC3init(&line ->u, b ->n[VX] - a ->n[VX],
+ b ->n[VY] - a ->n[VY],
+ b ->n[VZ] - a ->n[VZ]);
}
-// Evaluate parametric line
+// Evaluate parametric line
static
void GetPointOfLine(cmsVEC3* p, const cmsLine* line, cmsFloat64Number t)
{
p ->n[VX] = line ->a.n[VX] + t * line->u.n[VX];
p ->n[VY] = line ->a.n[VY] + t * line->u.n[VY];
- p ->n[VZ] = line ->a.n[VZ] + t * line->u.n[VZ];
+ p ->n[VZ] = line ->a.n[VZ] + t * line->u.n[VZ];
}
cmsBool ClosestLineToLine(cmsVEC3* r, const cmsLine* line1, const cmsLine* line2)
{
cmsFloat64Number a, b, c, d, e, D;
- cmsFloat64Number sc, sN, sD;
+ cmsFloat64Number sc, sN, sD;
cmsFloat64Number tc, tN, tD;
cmsVEC3 w0;
}
}
else if (tN > tD) { // tc > 1 => the t=1 edge is visible
-
+
tN = tD;
-
+
// recompute sc for this edge
if ((-d + b) < 0.0)
sN = 0;
{
cmsGDB* gbd = (cmsGDB*) _cmsMallocZero(ContextID, sizeof(cmsGDB));
if (gbd == NULL) return NULL;
-
+
gbd -> ContextID = ContextID;
return (cmsHANDLE) gbd;
void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD)
-{
+{
cmsGDB* gbd = (cmsGDB*) hGBD;
- if (hGBD != NULL)
+ if (hGBD != NULL)
_cmsFree(gbd->ContextID, (void*) gbd);
}
static
cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
{
- cmsVEC3 v;
+ cmsVEC3 v;
int alpha, theta;
// Housekeeping
_cmsAssert(gbd != NULL);
- _cmsAssert(Lab != NULL);
- _cmsAssert(sp != NULL);
+ _cmsAssert(Lab != NULL);
+ _cmsAssert(sp != NULL);
- // Center L* by substracting half of its domain, that's 50
+ // Center L* by substracting half of its domain, that's 50
_cmsVEC3init(&v, Lab ->L - 50.0, Lab ->a, Lab ->b);
-
+
// Convert to spherical coordinates
ToSpherical(sp, &v);
-
+
if (sp ->r < 0 || sp ->alpha < 0 || sp->theta < 0) {
cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, "spherical value out of range");
return NULL;
// On which sector it falls?
QuantizeToSector(sp, &alpha, &theta);
-
+
if (alpha < 0 || theta < 0 || alpha >= SECTORS || theta >= SECTORS) {
cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, " quadrant out of range");
return NULL;
return &gbd ->Gamut[theta][alpha];
}
-// Add a point to gamut descriptor. Point to add is in Lab color space.
+// Add a point to gamut descriptor. Point to add is in Lab color space.
// GBD is centered on a=b=0 and L*=50
cmsBool CMSEXPORT cmsGDBAddPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
{
// Check if a given point falls inside gamut
cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
{
- cmsGDB* gbd = (cmsGDB*) hGBD;
+ cmsGDB* gbd = (cmsGDB*) hGBD;
cmsGDBPoint* ptr;
cmsSpherical sp;
// -----------------------------------------------------------------------------------------------------------------------
-// Find near sectors. The list of sectors found is returned on Close[].
+// Find near sectors. The list of sectors found is returned on Close[].
// The function returns the number of sectors as well.
// 24 9 10 11 12
// 20 19 18 17 16
//
// Those are the relative movements
-// {-2,-2}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2},
+// {-2,-2}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2},
// {-2,-1}, {-1, -1}, {0, -1}, {+1, -1}, {+2, -1},
// {-2, 0}, {-1, 0}, {0, 0}, {+1, 0}, {+2, 0},
// {-2,+1}, {-1, +1}, {0, +1}, {+1, +1}, {+2, +1},
// {-2,+2}, {-1, +2}, {0, +2}, {+1, +2}, {+2, +2}};
-static
-const struct _spiral {
-
+static
+const struct _spiral {
+
int AdvX, AdvY;
-
- } Spiral[] = { {0, -1}, {+1, -1}, {+1, 0}, {+1, +1}, {0, +1}, {-1, +1},
- {-1, 0}, {-1, -1}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2},
- {+2, -1}, {+2, 0}, {+2, +1}, {+2, +2}, {+1, +2}, {0, +2},
+
+ } Spiral[] = { {0, -1}, {+1, -1}, {+1, 0}, {+1, +1}, {0, +1}, {-1, +1},
+ {-1, 0}, {-1, -1}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2},
+ {+2, -1}, {+2, 0}, {+2, +1}, {+2, +2}, {+1, +2}, {0, +2},
{-1, +2}, {-2, +2}, {-2, +1}, {-2, 0}, {-2, -1}, {-2, -2} };
#define NSTEPS (sizeof(Spiral) / sizeof(struct _spiral))
int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[])
{
int nSectors = 0;
- int i, a, t;
+ int a, t;
+ cmsUInt32Number i;
cmsGDBPoint* pt;
for (i=0; i < NSTEPS; i++) {
// Cycle at the begin
if (a < 0) a = SECTORS + a;
- if (t < 0) t = SECTORS + t;
+ if (t < 0) t = SECTORS + t;
pt = &gbd ->Gamut[t][a];
-
+
if (pt -> Type != GP_EMPTY) {
Close[nSectors++] = pt;
- }
+ }
}
return nSectors;
// Interpolate a missing sector. Method identifies whatever this is top, bottom or mid
static
cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta)
-{
+{
cmsSpherical sp;
cmsVEC3 Lab;
cmsVEC3 Centre;
cmsLine ray;
int nCloseSectors;
- cmsGDBPoint* Close[NSTEPS];
+ cmsGDBPoint* Close[NSTEPS + 1];
cmsSpherical closel, templ;
cmsLine edge;
int k, m;
-
+
// Is that point already specified?
if (gbd ->Gamut[theta][alpha].Type != GP_EMPTY) return TRUE;
nCloseSectors = FindNearSectors(gbd, alpha, theta, Close);
- // Find a central point on the sector
+ // Find a central point on the sector
sp.alpha = (cmsFloat64Number) ((alpha + 0.5) * 360.0) / (SECTORS);
sp.theta = (cmsFloat64Number) ((theta + 0.5) * 180.0) / (SECTORS);
- sp.r = 50.0;
+ sp.r = 50.0;
// Convert to Cartesian
ToCartesian(&Lab, &sp);
for(m = k+1; m < nCloseSectors; m++) {
cmsVEC3 temp, a1, a2;
-
+
// A line from sector to sector
ToCartesian(&a1, &Close[k]->p);
ToCartesian(&a2, &Close[m]->p);
LineOf2Points(&edge, &a1, &a2);
- // Find a line
+ // Find a line
ClosestLineToLine(&temp, &ray, &edge);
// Convert to spherical
ToSpherical(&templ, &temp);
-
- if ( templ.r > closel.r &&
- templ.theta >= (theta*180.0/SECTORS) &&
+
+ if ( templ.r > closel.r &&
+ templ.theta >= (theta*180.0/SECTORS) &&
templ.theta <= ((theta+1)*180.0/SECTORS) &&
templ.alpha >= (alpha*360.0/SECTORS) &&
templ.alpha <= ((alpha+1)*360.0/SECTORS)) {
- closel = templ;
- }
+ closel = templ;
+ }
}
}
_cmsAssert(hGBD != NULL);
// Interpolate black
- for (alpha = 0; alpha <= SECTORS; alpha++) {
+ for (alpha = 0; alpha < SECTORS; alpha++) {
if (!InterpolateMissingSector(gbd, alpha, 0)) return FALSE;
}
// Interpolate white
- for (alpha = 0; alpha <= SECTORS; alpha++) {
+ for (alpha = 0; alpha < SECTORS; alpha++) {
if (!InterpolateMissingSector(gbd, alpha, SECTORS-1)) return FALSE;
}
// Interpolate Mid
for (theta = 1; theta < SECTORS; theta++) {
- for (alpha = 0; alpha <= SECTORS; alpha++) {
+ for (alpha = 0; alpha < SECTORS; alpha++) {
if (!InterpolateMissingSector(gbd, alpha, theta)) return FALSE;
}
fprintf (fp, "#VRML V2.0 utf8\n");
- // set the viewing orientation and distance
+ // set the viewing orientation and distance
fprintf (fp, "DEF CamTest Group {\n");
- fprintf (fp, "\tchildren [\n");
- fprintf (fp, "\t\tDEF Cameras Group {\n");
- fprintf (fp, "\t\t\tchildren [\n");
- fprintf (fp, "\t\t\t\tDEF DefaultView Viewpoint {\n");
- fprintf (fp, "\t\t\t\t\tposition 0 0 340\n");
- fprintf (fp, "\t\t\t\t\torientation 0 0 1 0\n");
- fprintf (fp, "\t\t\t\t\tdescription \"default view\"\n");
- fprintf (fp, "\t\t\t\t}\n");
- fprintf (fp, "\t\t\t]\n");
- fprintf (fp, "\t\t},\n");
- fprintf (fp, "\t]\n");
- fprintf (fp, "}\n");
-
- // Output the background stuff
+ fprintf (fp, "\tchildren [\n");
+ fprintf (fp, "\t\tDEF Cameras Group {\n");
+ fprintf (fp, "\t\t\tchildren [\n");
+ fprintf (fp, "\t\t\t\tDEF DefaultView Viewpoint {\n");
+ fprintf (fp, "\t\t\t\t\tposition 0 0 340\n");
+ fprintf (fp, "\t\t\t\t\torientation 0 0 1 0\n");
+ fprintf (fp, "\t\t\t\t\tdescription \"default view\"\n");
+ fprintf (fp, "\t\t\t\t}\n");
+ fprintf (fp, "\t\t\t]\n");
+ fprintf (fp, "\t\t},\n");
+ fprintf (fp, "\t]\n");
+ fprintf (fp, "}\n");
+
+ // Output the background stuff
fprintf (fp, "Background {\n");
fprintf (fp, "\tskyColor [\n");
fprintf (fp, "\t\t.5 .5 .5\n");
fprintf (fp, "\t]\n");
fprintf (fp, "}\n");
- // Output the shape stuff
+ // Output the shape stuff
fprintf (fp, "Transform {\n");
fprintf (fp, "\tscale .3 .3 .3\n");
fprintf (fp, "\tchildren [\n");
- // Draw the axes as a shape:
+ // Draw the axes as a shape:
fprintf (fp, "\t\tShape {\n");
fprintf (fp, "\t\t\tappearance Appearance {\n");
fprintf (fp, "\t\t\t\tmaterial Material {\n");
fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t}\n");
-
+
fprintf (fp, "\t\tShape {\n");
fprintf (fp, "\t\t\tappearance Appearance {\n");
fprintf (fp, "\t\t\t\tmaterial Material {\n");
fprintf (fp, "\t\t\t\t}\n");
fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t\tgeometry PointSet {\n");
-
- // fill in the points here
+
+ // fill in the points here
fprintf (fp, "\t\t\t\tcoord Coordinate {\n");
fprintf (fp, "\t\t\t\t\tpoint [\n");
fprintf (fp, "\t\t\t\t\t%g %g %g", v.n[0]+50, v.n[1], v.n[2]);
- if ((j == SECTORS - 1) && (i == SECTORS - 1))
+ if ((j == SECTORS - 1) && (i == SECTORS - 1))
fprintf (fp, "]\n");
else
fprintf (fp, ",\n");
- // fill in the face colors
+ // fill in the face colors
fprintf (fp, "\t\t\t\tcolor Color {\n");
fprintf (fp, "\t\t\t\t\tcolor [\n");
for (j=0; j < SECTORS; j++) {
cmsVEC3 v;
-
+
pt = &gbd ->Gamut[i][j];
-
+
ToCartesian(&v, &pt ->p);
- if (pt ->Type == GP_EMPTY)
+ if (pt ->Type == GP_EMPTY)
fprintf (fp, "\t\t\t\t\t%g %g %g", 0.0, 0.0, 0.0);
else
if (pt ->Type == GP_MODELED)
fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, .5, .5);
- else {
+ else {
fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, 1.0, 1.0);
- }
+ }
- if ((j == SECTORS - 1) && (i == SECTORS - 1))
+ if ((j == SECTORS - 1) && (i == SECTORS - 1))
fprintf (fp, "]\n");
else
fprintf (fp, ",\n");
}
fprintf (fp, "\t\t\t}\n");
-
+
fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t}\n");
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2014 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
#include "lcms2_internal.h"
-// Tag Serialization -----------------------------------------------------------------------------
+// Tag Serialization -----------------------------------------------------------------------------
// This file implements every single tag and tag type as described in the ICC spec. Some types
// have been deprecated, like ncl and Data. There is no implementation for those types as there
// are no profiles holding them. The programmer can also extend this list by defining his own types
// by using the appropiate plug-in. There are three types of plug ins regarding that. First type
// allows to define new tags using any existing type. Next plug-in type allows to define new types
-// and the third one is very specific: allows to extend the number of elements in the multiprofile
-// elements special type.
+// and the third one is very specific: allows to extend the number of elements in the multiprocessing
+// elements special type.
//--------------------------------------------------------------------------------------------------
// Some broken types
#define DUP_FN(x) Type_##x##_Dup
// Helper macro to define a handler. Callbacks do have a fixed naming convention.
-#define TYPE_HANDLER(t, x) { (t), READ_FN(x), WRITE_FN(x), DUP_FN(x), FREE_FN(x) }
+#define TYPE_HANDLER(t, x) { (t), READ_FN(x), WRITE_FN(x), DUP_FN(x), FREE_FN(x), NULL, 0 }
// Helper macro to define a MPE handler. Callbacks do have a fixed naming convention
-#define TYPE_MPE_HANDLER(t, x) { (t), READ_FN(x), WRITE_FN(x), GenericMPEdup, GenericMPEfree }
+#define TYPE_MPE_HANDLER(t, x) { (t), READ_FN(x), WRITE_FN(x), GenericMPEdup, GenericMPEfree, NULL, 0 }
-// Register a new type handler. This routine is shared between normal types and MPE
+// Register a new type handler. This routine is shared between normal types and MPE. LinkedList points to the optional list head
static
-cmsBool RegisterTypesPlugin(cmsPluginBase* Data, _cmsTagTypeLinkedList* LinkedList, cmsUInt32Number DefaultListCount)
+cmsBool RegisterTypesPlugin(cmsContext id, cmsPluginBase* Data, _cmsMemoryClient pos)
{
cmsPluginTagType* Plugin = (cmsPluginTagType*) Data;
- _cmsTagTypeLinkedList *pt, *Anterior = NULL;
+ _cmsTagTypePluginChunkType* ctx = ( _cmsTagTypePluginChunkType*) _cmsContextGetClientChunk(id, pos);
+ _cmsTagTypeLinkedList *pt;
// Calling the function with NULL as plug-in would unregister the plug in.
if (Data == NULL) {
- LinkedList[DefaultListCount-1].Next = NULL;
+ // There is no need to set free the memory, as pool is destroyed as a whole.
+ ctx ->TagTypes = NULL;
return TRUE;
}
- pt = Anterior = LinkedList;
- while (pt != NULL) {
-
- if (Plugin->Handler.Signature == pt -> Handler.Signature) {
- pt ->Handler = Plugin ->Handler; // Replace old behaviour.
- // Note that since no memory is allocated, unregister does not
- // reset this action.
- return TRUE;
- }
-
- Anterior = pt;
- pt = pt ->Next;
- }
-
- // Registering happens in plug-in memory pool
- pt = (_cmsTagTypeLinkedList*) _cmsPluginMalloc(sizeof(_cmsTagTypeLinkedList));
+ // Registering happens in plug-in memory pool.
+ pt = (_cmsTagTypeLinkedList*) _cmsPluginMalloc(id, sizeof(_cmsTagTypeLinkedList));
if (pt == NULL) return FALSE;
- pt ->Handler = Plugin ->Handler;
- pt ->Next = NULL;
-
- if (Anterior)
- Anterior -> Next = pt;
+ pt ->Handler = Plugin ->Handler;
+ pt ->Next = ctx ->TagTypes;
+ ctx ->TagTypes = pt;
+
return TRUE;
}
-// Return handler for a given type or NULL if not found. Shared between normal types and MPE
+// Return handler for a given type or NULL if not found. Shared between normal types and MPE. It first tries the additons
+// made by plug-ins and then the built-in defaults.
static
-cmsTagTypeHandler* GetHandler(cmsTagTypeSignature sig, _cmsTagTypeLinkedList* LinkedList)
+cmsTagTypeHandler* GetHandler(cmsTagTypeSignature sig, _cmsTagTypeLinkedList* PluginLinkedList, _cmsTagTypeLinkedList* DefaultLinkedList)
{
_cmsTagTypeLinkedList* pt;
- for (pt = LinkedList;
+ for (pt = PluginLinkedList;
+ pt != NULL;
+ pt = pt ->Next) {
+
+ if (sig == pt -> Handler.Signature) return &pt ->Handler;
+ }
+
+ for (pt = DefaultLinkedList;
pt != NULL;
pt = pt ->Next) {
cmsUInt32Number i;
_cmsAssert(io != NULL);
- _cmsAssert(Array != NULL);
+ _cmsAssert(!(Array == NULL && n > 0));
for (i=0; i < n; i++) {
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) Array[i])) return FALSE;
return TRUE;
}
+// Auxiliar to read an array of wchar_t
static
cmsBool _cmsReadWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, wchar_t* Array)
{
}
// To deal with position tables
-typedef cmsBool (* PositionTableEntryFn)(struct _cms_typehandler_struct* self,
+typedef cmsBool (* PositionTableEntryFn)(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
void* Cargo,
- cmsUInt32Number n,
+ cmsUInt32Number n,
cmsUInt32Number SizeOfTag);
-// Helper function to deal with position tables as decribed in several addendums to ICC spec 4.2
-// A table of n elements is written, where first comes n records containing offsets and sizes and
+// Helper function to deal with position tables as decribed in ICC spec 4.3
+// A table of n elements is readed, where first comes n records containing offsets and sizes and
// then a block containing the data itself. This allows to reuse same data in more than one entry
static
-cmsBool ReadPositionTable(struct _cms_typehandler_struct* self,
- cmsIOHANDLER* io,
- cmsUInt32Number Count,
- cmsUInt32Number BaseOffset,
+cmsBool ReadPositionTable(struct _cms_typehandler_struct* self,
+ cmsIOHANDLER* io,
+ cmsUInt32Number Count,
+ cmsUInt32Number BaseOffset,
void *Cargo,
PositionTableEntryFn ElementFn)
{
cmsUInt32Number *ElementOffsets = NULL, *ElementSizes = NULL;
// Let's take the offsets to each element
- ElementOffsets = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number *));
+ ElementOffsets = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));
if (ElementOffsets == NULL) goto Error;
- ElementSizes = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number *));
+ ElementSizes = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));
if (ElementSizes == NULL) goto Error;
for (i=0; i < Count; i++) {
// Success
if (ElementOffsets != NULL) _cmsFree(io ->ContextID, ElementOffsets);
- if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);
+ if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);
return TRUE;
-Error:
+Error:
if (ElementOffsets != NULL) _cmsFree(io ->ContextID, ElementOffsets);
if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);
return FALSE;
// Same as anterior, but for write position tables
static
-cmsBool WritePositionTable(struct _cms_typehandler_struct* self,
+cmsBool WritePositionTable(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
cmsUInt32Number SizeOfTag,
- cmsUInt32Number Count,
- cmsUInt32Number BaseOffset,
+ cmsUInt32Number Count,
+ cmsUInt32Number BaseOffset,
void *Cargo,
PositionTableEntryFn ElementFn)
{
cmsUInt32Number *ElementOffsets = NULL, *ElementSizes = NULL;
// Create table
- ElementOffsets = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number *));
+ ElementOffsets = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));
if (ElementOffsets == NULL) goto Error;
- ElementSizes = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number *));
+ ElementSizes = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));
if (ElementSizes == NULL) goto Error;
-
+
// Keep starting position of curve offsets
DirectoryPos = io ->Tell(io);
// Write a fake directory to be filled latter on
for (i=0; i < Count; i++) {
- if (!_cmsWriteUInt32Number(io, 0)) goto Error; // Offset
+ if (!_cmsWriteUInt32Number(io, 0)) goto Error; // Offset
if (!_cmsWriteUInt32Number(io, 0)) goto Error; // size
}
for (i=0; i < Count; i++) {
Before = io ->Tell(io);
- ElementOffsets[i] = Before - BaseOffset;
+ ElementOffsets[i] = Before - BaseOffset;
// Callback to write...
if (!ElementFn(self, io, Cargo, i, SizeOfTag)) goto Error;
// Now the size
- ElementSizes[i] = io ->Tell(io) - Before;
+ ElementSizes[i] = io ->Tell(io) - Before;
}
// Write the directory
if (!io ->Seek(io, DirectoryPos)) goto Error;
for (i=0; i < Count; i++) {
- if (!_cmsWriteUInt32Number(io, ElementOffsets[i])) goto Error;
- if (!_cmsWriteUInt32Number(io, ElementSizes[i])) goto Error;
+ if (!_cmsWriteUInt32Number(io, ElementOffsets[i])) goto Error;
+ if (!_cmsWriteUInt32Number(io, ElementSizes[i])) goto Error;
}
if (!io ->Seek(io, CurrentPos)) goto Error;
// ********************************************************************************
//The XYZType contains an array of three encoded values for the XYZ tristimulus
-//values. Tristimulus values must be non-negative. The signed encoding allows for
+//values. Tristimulus values must be non-negative. The signed encoding allows for
//implementation optimizations by minimizing the number of fixed formats.
// ********************************************************************************
// Type chromaticity. Only one value is allowed
// ********************************************************************************
-// The chromaticity tag type provides basic chromaticity data and type of
+// The chromaticity tag type provides basic chromaticity data and type of
// phosphors or colorants of a monitor to applications and utilities.
static
static
cmsBool SaveOneChromaticity(cmsFloat64Number x, cmsFloat64Number y, cmsIOHANDLER* io)
{
- if (!_cmsWriteUInt32Number(io, _cmsDoubleTo15Fixed16(x))) return FALSE;
- if (!_cmsWriteUInt32Number(io, _cmsDoubleTo15Fixed16(y))) return FALSE;
+ if (!_cmsWriteUInt32Number(io, _cmsDoubleTo15Fixed16(x))) return FALSE;
+ if (!_cmsWriteUInt32Number(io, _cmsDoubleTo15Fixed16(y))) return FALSE;
return TRUE;
}
return TRUE;
cmsUNUSED_PARAMETER(nItems);
- cmsUNUSED_PARAMETER(self);
+ cmsUNUSED_PARAMETER(self);
}
static
void* Type_Chromaticity_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n)
{
return _cmsDupMem(self ->ContextID, Ptr, sizeof(cmsCIExyYTRIPLE));
+
cmsUNUSED_PARAMETER(n);
}
// Type cmsSigColorantOrderType
// ********************************************************************************
-// This is an optional tag which specifies the laydown order in which colorants will
-// be printed on an n-colorant device. The laydown order may be the same as the
-// channel generation order listed in the colorantTableTag or the channel order of a
-// colour space such as CMYK, in which case this tag is not needed. When this is not
-// the case (for example, ink-towers sometimes use the order KCMY), this tag may be
-// used to specify the laydown order of the colorants.
+// This is an optional tag which specifies the laydown order in which colorants will
+// be printed on an n-colorant device. The laydown order may be the same as the
+// channel generation order listed in the colorantTableTag or the channel order of a
+// colour space such as CMYK, in which case this tag is not needed. When this is not
+// the case (for example, ink-towers sometimes use the order KCMY), this tag may be
+// used to specify the laydown order of the colorants.
static
static
cmsBool Type_ColorantOrderType_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
- cmsUInt8Number* ColorantOrder = (cmsUInt8Number*) Ptr;
+ cmsUInt8Number* ColorantOrder = (cmsUInt8Number*) Ptr;
cmsUInt32Number i, sz, Count;
// Get the length
if (ColorantOrder[i] != 0xFF) Count++;
}
- if (!_cmsWriteUInt32Number(io, Count)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, Count)) return FALSE;
sz = Count * sizeof(cmsUInt8Number);
- if (!io -> Write(io, sz, ColorantOrder)) return FALSE;
+ if (!io -> Write(io, sz, ColorantOrder)) return FALSE;
return TRUE;
// ********************************************************************************
// Type cmsSigS15Fixed16ArrayType
// ********************************************************************************
-// This type represents an array of generic 4-byte/32-bit fixed point quantity.
+// This type represents an array of generic 4-byte/32-bit fixed point quantity.
// The number of values is determined from the size of the tag.
static
_cmsFree(self ->ContextID, array_double);
return NULL;
- }
+ }
}
*nItems = n;
for (i=0; i < nItems; i++) {
- if (!_cmsWrite15Fixed16Number(io, Value[i])) return FALSE;
+ if (!_cmsWrite15Fixed16Number(io, Value[i])) return FALSE;
}
return TRUE;
// ********************************************************************************
// Type cmsSigU16Fixed16ArrayType
// ********************************************************************************
-// This type represents an array of generic 4-byte/32-bit quantity.
+// This type represents an array of generic 4-byte/32-bit quantity.
// The number of values is determined from the size of the tag.
cmsUInt32Number v = (cmsUInt32Number) floor(Value[i]*65536.0 + 0.5);
- if (!_cmsWriteUInt32Number(io, v)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, v)) return FALSE;
}
return TRUE;
// Type cmsSigSignatureType
// ********************************************************************************
//
-// The signatureType contains a four-byte sequence, Sequences of less than four
-// characters are padded at the end with spaces, 20h.
-// Typically this type is used for registered tags that can be displayed on many
+// The signatureType contains a four-byte sequence, Sequences of less than four
+// characters are padded at the end with spaces, 20h.
+// Typically this type is used for registered tags that can be displayed on many
// development systems as a sequence of four characters.
static
static
cmsBool Type_Signature_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
- cmsSignature* SigPtr = (cmsSignature*) Ptr;
-
+ cmsSignature* SigPtr = (cmsSignature*) Ptr;
+
return _cmsWriteUInt32Number(io, *SigPtr);
cmsUNUSED_PARAMETER(nItems);
// Type cmsSigTextType
// ********************************************************************************
//
-// The textType is a simple text structure that contains a 7-bit ASCII text string.
-// The length of the string is obtained by subtracting 8 from the element size portion
+// The textType is a simple text structure that contains a 7-bit ASCII text string.
+// The length of the string is obtained by subtracting 8 from the element size portion
// of the tag itself. This string must be terminated with a 00h byte.
static
Text = (char*) _cmsMalloc(self ->ContextID, SizeOfTag + 1);
if (Text == NULL) goto Error;
- if (io -> Read(io, Text, sizeof(char), SizeOfTag) != SizeOfTag) goto Error;
+ if (io -> Read(io, Text, sizeof(char), SizeOfTag) != SizeOfTag) goto Error;
// Make sure text is properly ended
Text[SizeOfTag] = 0;
*nItems = 1;
-
+
// Keep the result
if (!cmsMLUsetASCII(mlu, cmsNoLanguage, cmsNoCountry, Text)) goto Error;
return (void*) mlu;
Error:
- if (mlu != NULL)
+ if (mlu != NULL)
cmsMLUfree(mlu);
if (Text != NULL)
_cmsFree(self ->ContextID, Text);
static
cmsBool Type_Text_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
- cmsMLU* mlu = (cmsMLU*) Ptr;
+ cmsMLU* mlu = (cmsMLU*) Ptr;
cmsUInt32Number size;
cmsBool rc;
char* Text;
-
+
// Get the size of the string. Note there is an extra "\0" at the end
size = cmsMLUgetASCII(mlu, cmsNoLanguage, cmsNoCountry, NULL, 0);
if (size == 0) return FALSE; // Cannot be zero!
// Create memory
Text = (char*) _cmsMalloc(self ->ContextID, size);
+ if (Text == NULL) return FALSE;
+
cmsMLUgetASCII(mlu, cmsNoLanguage, cmsNoCountry, Text, size);
// Write it, including separator
static
cmsTagTypeSignature DecideTextType(cmsFloat64Number ICCVersion, const void *Data)
{
- if (ICCVersion >= 4.0)
+ if (ICCVersion >= 4.0)
return cmsSigMultiLocalizedUnicodeType;
-
+
return cmsSigTextType;
-
+
cmsUNUSED_PARAMETER(Data);
}
cmsUInt32Number LenOfData;
*nItems = 0;
-
+
if (SizeOfTag < sizeof(cmsUInt32Number)) return NULL;
LenOfData = SizeOfTag - sizeof(cmsUInt32Number);
}
if (io -> Read(io, BinData ->data, sizeof(cmsUInt8Number), LenOfData) != LenOfData) {
-
+
_cmsFree(self ->ContextID, BinData);
return NULL;
}
*nItems = 1;
-
+
return (void*) BinData;
}
cmsBool Type_Data_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
cmsICCData* BinData = (cmsICCData*) Ptr;
-
+
if (!_cmsWriteUInt32Number(io, BinData ->flag)) return FALSE;
return io ->Write(io, BinData ->len, BinData ->data);
SizeOfTag -= sizeof(cmsUInt32Number);
// Check for size
- if (SizeOfTag < AsciiCount) return NULL;
+ if (SizeOfTag < AsciiCount) return NULL;
// All seems Ok, allocate the container
mlu = cmsMLUalloc(self ->ContextID, 1);
if (!cmsMLUsetASCII(mlu, cmsNoLanguage, cmsNoCountry, Text)) goto Error;
_cmsFree(self ->ContextID, (void*) Text);
Text = NULL;
-
+
// Skip Unicode code
if (SizeOfTag < 2* sizeof(cmsUInt32Number)) goto Done;
- if (!_cmsReadUInt32Number(io, &UnicodeCode)) goto Done;
- if (!_cmsReadUInt32Number(io, &UnicodeCount)) goto Done;
+ if (!_cmsReadUInt32Number(io, &UnicodeCode)) goto Done;
+ if (!_cmsReadUInt32Number(io, &UnicodeCount)) goto Done;
SizeOfTag -= 2* sizeof(cmsUInt32Number);
if (SizeOfTag < UnicodeCount*sizeof(cmsUInt16Number)) goto Done;
SizeOfTag -= UnicodeCount*sizeof(cmsUInt16Number);
// Skip ScriptCode code if present. Some buggy profiles does have less
- // data that stricttly required. We need to skip it as this type may come
+ // data that stricttly required. We need to skip it as this type may come
// embedded in other types.
-
+
if (SizeOfTag >= sizeof(cmsUInt16Number) + sizeof(cmsUInt8Number) + 67) {
if (!_cmsReadUInt16Number(io, &ScriptCodeCode)) goto Done;
- if (!_cmsReadUInt8Number(io, &ScriptCodeCount)) goto Done;
+ if (!_cmsReadUInt8Number(io, &ScriptCodeCount)) goto Done;
// Skip rest of tag
for (i=0; i < 67; i++) {
// Used below for writting zeroes
memset(Filler, 0, sizeof(Filler));
-
+
// Get the len of string
len = cmsMLUgetASCII(mlu, cmsNoLanguage, cmsNoCountry, NULL, 0);
-
+
// From ICC3.4: It has been found that textDescriptionType can contain misaligned data
//(see clause 4.1 for the definition of \93aligned\94). Because the Unicode language
// code and Unicode count immediately follow the ASCII description, their
// alignment is not correct if the ASCII count is not a multiple of four. The
// ScriptCode code is misaligned when the ASCII count is odd. Profile reading and
// writing software must be written carefully in order to handle these alignment
- // problems.
+ // problems.
// Compute an aligned size
len_aligned = _cmsALIGNLONG(len);
Wide = (wchar_t*) _cmsCalloc(self ->ContextID, len, sizeof(wchar_t));
if (Wide == NULL) goto Error;
- // Get both representations.
+ // Get both representations.
cmsMLUgetASCII(mlu, cmsNoLanguage, cmsNoCountry, Text, len * sizeof(char));
cmsMLUgetWide(mlu, cmsNoLanguage, cmsNoCountry, Wide, len * sizeof(wchar_t));
}
-
+
// * cmsUInt32Number count; * Description length
// * cmsInt8Number desc[count] * NULL terminated ascii string
// * cmsUInt32Number ucLangCode; * UniCode language code
// * cmsUInt16Number scCode; * ScriptCode code
// * cmsUInt8Number scCount; * ScriptCode count
// * cmsInt8Number scDesc[67]; * ScriptCode Description
-
- if (!_cmsWriteUInt32Number(io, len_aligned)) goto Error;
- if (!io ->Write(io, len, Text)) goto Error;
- if (!io ->Write(io, len_filler_alignment, Filler)) goto Error;
+
+ if (!_cmsWriteUInt32Number(io, len_aligned)) goto Error;
+ if (!io ->Write(io, len, Text)) goto Error;
+ if (!io ->Write(io, len_filler_alignment, Filler)) goto Error;
if (!_cmsWriteUInt32Number(io, 0)) goto Error; // ucLanguageCode
-
+
// This part is tricky: we need an aligned tag size, and the ScriptCode part
// takes 70 bytes, so we need 2 extra bytes to do the alignment
- if (!_cmsWriteUInt32Number(io, len_aligned+1)) goto Error;
+ if (!_cmsWriteUInt32Number(io, len_aligned+1)) goto Error;
// Note that in some compilers sizeof(cmsUInt16Number) != sizeof(wchar_t)
- if (!_cmsWriteWCharArray(io, len, Wide)) goto Error;
- if (!_cmsWriteUInt16Array(io, len_filler_alignment+1, (cmsUInt16Number*) Filler)) goto Error;
+ if (!_cmsWriteWCharArray(io, len, Wide)) goto Error;
+ if (!_cmsWriteUInt16Array(io, len_filler_alignment+1, (cmsUInt16Number*) Filler)) goto Error;
// ScriptCode Code & count (unused)
- if (!_cmsWriteUInt16Number(io, 0)) goto Error;
- if (!_cmsWriteUInt8Number(io, 0)) goto Error;
-
+ if (!_cmsWriteUInt16Number(io, 0)) goto Error;
+ if (!_cmsWriteUInt8Number(io, 0)) goto Error;
+
if (!io ->Write(io, 67, Filler)) goto Error;
rc = TRUE;
static
cmsTagTypeSignature DecideTextDescType(cmsFloat64Number ICCVersion, const void *Data)
{
- if (ICCVersion >= 4.0)
+ if (ICCVersion >= 4.0)
return cmsSigMultiLocalizedUnicodeType;
-
+
return cmsSigTextDescriptionType;
-
+
cmsUNUSED_PARAMETER(Data);
}
{
cmsUInt32Number Count;
cmsToneCurve* NewGamma;
- cmsUInt16Number Linear[2] = { 0, 0xffff };
-
-
+
*nItems = 0;
if (!_cmsReadUInt32Number(io, &Count)) return NULL;
switch (Count) {
case 0: // Linear.
+ {
+ cmsFloat64Number SingleGamma = 1.0;
- NewGamma = cmsBuildTabulatedToneCurve16(self ->ContextID, 2, Linear);
- if (!NewGamma) return NULL;
- *nItems = 1;
- return NewGamma;
-
+ NewGamma = cmsBuildParametricToneCurve(self ->ContextID, 1, &SingleGamma);
+ if (!NewGamma) return NULL;
+ *nItems = 1;
+ return NewGamma;
+ }
+
case 1: // Specified as the exponent of gamma function
{
cmsUInt16Number SingleGammaFixed;
default: // Curve
+ if (Count > 0x7FFF)
+ return NULL; // This is to prevent bad guys for doing bad things
+
NewGamma = cmsBuildTabulatedToneCurve16(self ->ContextID, Count, NULL);
if (!NewGamma) return NULL;
- if (!_cmsReadUInt16Array(io, Count, NewGamma -> Table16)) return NULL;
+ if (!_cmsReadUInt16Array(io, Count, NewGamma -> Table16)) return NULL;
*nItems = 1;
return NewGamma;
// Single gamma, preserve number
cmsUInt16Number SingleGammaFixed = _cmsDoubleTo8Fixed8(Curve ->Segments[0].Params[0]);
- if (!_cmsWriteUInt32Number(io, 1)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, 1)) return FALSE;
if (!_cmsWriteUInt16Number(io, SingleGammaFixed)) return FALSE;
return TRUE;
-
+
}
- if (!_cmsWriteUInt32Number(io, Curve ->nEntries)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, Curve ->nEntries)) return FALSE;
return _cmsWriteUInt16Array(io, Curve ->nEntries, Curve ->Table16);
cmsUNUSED_PARAMETER(nItems);
if (ICCVersion < 4.0) return cmsSigCurveType;
if (Curve ->nSegments != 1) return cmsSigCurveType; // Only 1-segment curves can be saved as parametric
if (Curve ->Segments[0].Type < 0) return cmsSigCurveType; // Only non-inverted curves
+ if (Curve ->Segments[0].Type > 5) return cmsSigCurveType; // Only ICC parametric curves
return cmsSigParametricCurveType;
}
for (i=0; i < n; i++) {
- if (!_cmsRead15Fixed16Number(io, &Params[i])) return NULL;
+ if (!_cmsRead15Fixed16Number(io, &Params[i])) return NULL;
}
NewGamma = cmsBuildParametricToneCurve(self ->ContextID, Type+1, Params);
cmsUNUSED_PARAMETER(SizeOfTag);
}
-
+
static
cmsBool Type_ParametricCurve_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
cmsToneCurve* Curve = (cmsToneCurve*) Ptr;
- int i, nParams;
+ int i, nParams, typen;
static const int ParamsByType[] = { 0, 1, 3, 4, 5, 7 };
-
- if (Curve ->nSegments > 1 || Curve -> Segments[0].Type < 1) {
+ typen = Curve -> Segments[0].Type;
+
+ if (Curve ->nSegments > 1 || typen < 1) {
- cmsSignalError(self->ContextID, 0, "Multisegment or Inverted parametric curves cannot be written");
+ cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Multisegment or Inverted parametric curves cannot be written");
return FALSE;
}
- nParams = ParamsByType[Curve ->Segments[0].Type];
-
+ if (typen > 5) {
+ cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported parametric curve");
+ return FALSE;
+ }
+
+ nParams = ParamsByType[typen];
+
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) (Curve ->Segments[0].Type - 1))) return FALSE;
if (!_cmsWriteUInt16Number(io, 0)) return FALSE; // Reserved
for (i=0; i < nParams; i++) {
- if (!_cmsWrite15Fixed16Number(io, Curve -> Segments[0].Params[i])) return FALSE;
+ if (!_cmsWrite15Fixed16Number(io, Curve -> Segments[0].Params[i])) return FALSE;
}
-
+
return TRUE;
cmsUNUSED_PARAMETER(nItems);
// Type cmsSigDateTimeType
// ********************************************************************************
-// A 12-byte value representation of the time and date, where the byte usage is assigned
-// as specified in table 1. The actual values are encoded as 16-bit unsigned integers
+// A 12-byte value representation of the time and date, where the byte usage is assigned
+// as specified in table 1. The actual values are encoded as 16-bit unsigned integers
// (uInt16Number - see 5.1.6).
//
-// All the dateTimeNumber values in a profile shall be in Coordinated Universal Time
+// All the dateTimeNumber values in a profile shall be in Coordinated Universal Time
// (UTC, also known as GMT or ZULU Time). Profile writers are required to convert local
-// time to UTC when setting these values. Programmes that display these values may show
-// the dateTimeNumber as UTC, show the equivalent local time (at current locale), or
+// time to UTC when setting these values. Programmes that display these values may show
+// the dateTimeNumber as UTC, show the equivalent local time (at current locale), or
// display both UTC and local versions of the dateTimeNumber.
static
if (NewDateTime == NULL) return NULL;
if (io->Read(io, ×tamp, sizeof(cmsDateTimeNumber), 1) != 1) return NULL;
-
+
_cmsDecodeDateTimeNumber(×tamp, NewDateTime);
*nItems = 1;
/*
The measurementType information refers only to the internal profile data and is
-meant to provide profile makers an alternative to the default measurement
+meant to provide profile makers an alternative to the default measurement
specifications.
*/
{
cmsICCMeasurementConditions mc;
+
+ memset(&mc, 0, sizeof(mc));
+
if (!_cmsReadUInt32Number(io, &mc.Observer)) return NULL;
if (!_cmsReadXYZNumber(io, &mc.Backing)) return NULL;
if (!_cmsReadUInt32Number(io, &mc.Geometry)) return NULL;
cmsBool Type_Measurement_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
cmsICCMeasurementConditions* mc =(cmsICCMeasurementConditions*) Ptr;
-
+
if (!_cmsWriteUInt32Number(io, mc->Observer)) return FALSE;
if (!_cmsWriteXYZNumber(io, &mc->Backing)) return FALSE;
if (!_cmsWriteUInt32Number(io, mc->Geometry)) return FALSE;
// Type cmsSigMultiLocalizedUnicodeType
// ********************************************************************************
//
-// Do NOT trust SizeOfTag as there is an issue on the definition of profileSequenceDescTag. See the TechNote from
+// Do NOT trust SizeOfTag as there is an issue on the definition of profileSequenceDescTag. See the TechNote from
// Max Derhak and Rohit Patil about this: basically the size of the string table should be guessed and cannot be
// taken from the size of tag if this tag is embedded as part of bigger structures (profileSequenceDescTag, for instance)
//
void *Type_MLU_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
{
cmsMLU* mlu;
- cmsUInt32Number Count, RecLen, NumOfWchar;
+ cmsUInt32Number Count, RecLen, NumOfWchar;
cmsUInt32Number SizeOfHeader;
cmsUInt32Number Len, Offset;
cmsUInt32Number i;
cmsUInt32Number BeginOfThisString, EndOfThisString, LargestPosition;
*nItems = 0;
- if (!_cmsReadUInt32Number(io, &Count)) return NULL;
- if (!_cmsReadUInt32Number(io, &RecLen)) return NULL;
+ if (!_cmsReadUInt32Number(io, &Count)) return NULL;
+ if (!_cmsReadUInt32Number(io, &RecLen)) return NULL;
if (RecLen != 12) {
for (i=0; i < Count; i++) {
- if (!_cmsReadUInt16Number(io, &mlu ->Entries[i].Language)) goto Error;
- if (!_cmsReadUInt16Number(io, &mlu ->Entries[i].Country)) goto Error;
+ if (!_cmsReadUInt16Number(io, &mlu ->Entries[i].Language)) goto Error;
+ if (!_cmsReadUInt16Number(io, &mlu ->Entries[i].Country)) goto Error;
// Now deal with Len and offset.
- if (!_cmsReadUInt32Number(io, &Len)) goto Error;
+ if (!_cmsReadUInt32Number(io, &Len)) goto Error;
if (!_cmsReadUInt32Number(io, &Offset)) goto Error;
// Check for overflow
// True begin of the string
BeginOfThisString = Offset - SizeOfHeader - 8;
-
+
// Ajust to wchar_t elements
- mlu ->Entries[i].Len = (Len * sizeof(wchar_t)) / sizeof(cmsUInt16Number);
+ mlu ->Entries[i].Len = (Len * sizeof(wchar_t)) / sizeof(cmsUInt16Number);
mlu ->Entries[i].StrW = (BeginOfThisString * sizeof(wchar_t)) / sizeof(cmsUInt16Number);
// To guess maximum size, add offset + len
// Now read the remaining of tag and fill all strings. Substract the directory
SizeOfTag = (LargestPosition * sizeof(wchar_t)) / sizeof(cmsUInt16Number);
+ if (SizeOfTag == 0)
+ {
+ Block = NULL;
+ NumOfWchar = 0;
- Block = (wchar_t*) _cmsMalloc(self ->ContextID, SizeOfTag);
- if (Block == NULL) goto Error;
-
- NumOfWchar = SizeOfTag / sizeof(wchar_t);
-
- if (!_cmsReadWCharArray(io, NumOfWchar, Block)) goto Error;
+ }
+ else
+ {
+ Block = (wchar_t*) _cmsMalloc(self ->ContextID, SizeOfTag);
+ if (Block == NULL) goto Error;
+ NumOfWchar = SizeOfTag / sizeof(wchar_t);
+ if (!_cmsReadWCharArray(io, NumOfWchar, Block)) goto Error;
+ }
mlu ->MemPool = Block;
mlu ->PoolSize = SizeOfTag;
*nItems = 1;
return (void*) mlu;
-Error:
+Error:
if (mlu) cmsMLUfree(mlu);
- return NULL;
+ return NULL;
}
static
if (Ptr == NULL) {
// Empty placeholder
- if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
- if (!_cmsWriteUInt32Number(io, 12)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, 12)) return FALSE;
return TRUE;
}
-
- if (!_cmsWriteUInt32Number(io, mlu ->UsedEntries)) return FALSE;
- if (!_cmsWriteUInt32Number(io, 12)) return FALSE;
-
+
+ if (!_cmsWriteUInt32Number(io, mlu ->UsedEntries)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, 12)) return FALSE;
+
HeaderSize = 12 * mlu ->UsedEntries + sizeof(_cmsTagBase);
for (i=0; i < mlu ->UsedEntries; i++) {
Len = mlu ->Entries[i].Len;
Offset = mlu ->Entries[i].StrW;
-
+
Len = (Len * sizeof(cmsUInt16Number)) / sizeof(wchar_t);
Offset = (Offset * sizeof(cmsUInt16Number)) / sizeof(wchar_t) + HeaderSize + 8;
- if (!_cmsWriteUInt16Number(io, mlu ->Entries[i].Language)) return FALSE;
- if (!_cmsWriteUInt16Number(io, mlu ->Entries[i].Country)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, mlu ->Entries[i].Language)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, mlu ->Entries[i].Country)) return FALSE;
if (!_cmsWriteUInt32Number(io, Len)) return FALSE;
- if (!_cmsWriteUInt32Number(io, Offset)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, Offset)) return FALSE;
}
if (!_cmsWriteWCharArray(io, mlu ->PoolUsed / sizeof(wchar_t), (wchar_t*) mlu ->MemPool)) return FALSE;
static
void Type_MLU_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsMLUfree((cmsMLU*) Ptr);
return;
}
/*
-This structure represents a colour transform using tables of 8-bit precision.
-This type contains four processing elements: a 3 by 3 matrix (which shall be
-the identity matrix unless the input colour space is XYZ), a set of one dimensional
-input tables, a multidimensional lookup table, and a set of one dimensional output
+This structure represents a colour transform using tables of 8-bit precision.
+This type contains four processing elements: a 3 by 3 matrix (which shall be
+the identity matrix unless the input colour space is XYZ), a set of one dimensional
+input tables, a multidimensional lookup table, and a set of one dimensional output
tables. Data is processed using these elements via the following sequence:
(matrix) -> (1d input tables) -> (multidimensional lookup table - CLUT) -> (1d output tables)
// Read 8 bit tables as gamma functions
-static
+static
cmsBool Read8bitTables(cmsContext ContextID, cmsIOHANDLER* io, cmsPipeline* lut, int nChannels)
{
- cmsStage* mpe;
cmsUInt8Number* Temp = NULL;
int i, j;
cmsToneCurve* Tables[cmsMAXCHANNELS];
if (nChannels > cmsMAXCHANNELS) return FALSE;
-
+ if (nChannels <= 0) return FALSE;
+
memset(Tables, 0, sizeof(Tables));
Temp = (cmsUInt8Number*) _cmsMalloc(ContextID, 256);
}
_cmsFree(ContextID, Temp);
+ Temp = NULL;
+ if (!cmsPipelineInsertStage(lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, nChannels, Tables)))
+ goto Error;
- mpe = cmsStageAllocToneCurves(ContextID, nChannels, Tables);
- if (mpe == NULL) goto Error;
-
- cmsPipelineInsertStage(lut, cmsAT_END, mpe);
-
- for (i=0; i < nChannels; i++)
+ for (i=0; i < nChannels; i++)
cmsFreeToneCurve(Tables[i]);
return TRUE;
}
if (Temp) _cmsFree(ContextID, Temp);
- return FALSE;
+ return FALSE;
}
if (Tables) {
- if (Tables ->TheCurves[i]->nEntries != 256) {
- cmsSignalError(ContextID, cmsERROR_RANGE, "LUT8 needs 256 entries on prelinearization");
- return FALSE;
- }
-
- }
+ // Usual case of identity curves
+ if ((Tables ->TheCurves[i]->nEntries == 2) &&
+ (Tables->TheCurves[i]->Table16[0] == 0) &&
+ (Tables->TheCurves[i]->Table16[1] == 65535)) {
- for (j=0; j < 256; j++) {
+ for (j=0; j < 256; j++) {
+ if (!_cmsWriteUInt8Number(io, (cmsUInt8Number) j)) return FALSE;
+ }
+ }
+ else
+ if (Tables ->TheCurves[i]->nEntries != 256) {
+ cmsSignalError(ContextID, cmsERROR_RANGE, "LUT8 needs 256 entries on prelinearization");
+ return FALSE;
+ }
+ else
+ for (j=0; j < 256; j++) {
- if (Tables != NULL)
- val = (cmsUInt8Number) FROM_16_TO_8(Tables->TheCurves[i]->Table16[j]);
- else
- val = (cmsUInt8Number) j;
+ if (Tables != NULL)
+ val = (cmsUInt8Number) FROM_16_TO_8(Tables->TheCurves[i]->Table16[j]);
+ else
+ val = (cmsUInt8Number) j;
- if (!_cmsWriteUInt8Number(io, val)) return FALSE;
+ if (!_cmsWriteUInt8Number(io, val)) return FALSE;
+ }
}
}
return TRUE;
// Check overflow
static
-unsigned int uipow(cmsUInt32Number n, cmsUInt32Number a, cmsUInt32Number b)
+cmsUInt32Number uipow(cmsUInt32Number n, cmsUInt32Number a, cmsUInt32Number b)
{
cmsUInt32Number rv = 1, rc;
rv *= a;
// Check for overflow
- if (rv > UINT_MAX / a) return 0;
+ if (rv > UINT_MAX / a) return (cmsUInt32Number) -1;
}
-
+
rc = rv * n;
- if (rv != rc / n) return 0;
+ if (rv != rc / n) return (cmsUInt32Number) -1;
return rc;
}
-// That will create a MPE LUT with Matrix, pre tables, CLUT and post tables.
+// That will create a MPE LUT with Matrix, pre tables, CLUT and post tables.
// 8 bit lut may be scaled easely to v4 PCS, but we need also to properly adjust
// PCS on BToAxx tags and AtoB if abstract. We need to fix input direction.
cmsUInt8Number InputChannels, OutputChannels, CLUTpoints;
cmsUInt8Number* Temp = NULL;
cmsPipeline* NewLUT = NULL;
- cmsStage *mpemat, *mpeclut;
- cmsUInt32Number nTabSize, i;
+ cmsUInt32Number nTabSize, i;
cmsFloat64Number Matrix[3*3];
*nItems = 0;
-
+
if (!_cmsReadUInt8Number(io, &InputChannels)) goto Error;
if (!_cmsReadUInt8Number(io, &OutputChannels)) goto Error;
if (!_cmsReadUInt8Number(io, &CLUTpoints)) goto Error;
+ if (CLUTpoints == 1) goto Error; // Impossible value, 0 for no CLUT and then 2 at least
+
// Padding
if (!_cmsReadUInt8Number(io, NULL)) goto Error;
// Do some checking
-
if (InputChannels > cmsMAXCHANNELS) goto Error;
if (OutputChannels > cmsMAXCHANNELS) goto Error;
if (!_cmsRead15Fixed16Number(io, &Matrix[7])) goto Error;
if (!_cmsRead15Fixed16Number(io, &Matrix[8])) goto Error;
-
+
// Only operates if not identity...
if ((InputChannels == 3) && !_cmsMAT3isIdentity((cmsMAT3*) Matrix)) {
- mpemat = cmsStageAllocMatrix(self ->ContextID, 3, 3, Matrix, NULL);
- if (mpemat == NULL) goto Error;
- cmsPipelineInsertStage(NewLUT, cmsAT_BEGIN, mpemat);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_BEGIN, cmsStageAllocMatrix(self ->ContextID, 3, 3, Matrix, NULL)))
+ goto Error;
}
-
+
// Get input tables
if (!Read8bitTables(self ->ContextID, io, NewLUT, InputChannels)) goto Error;
-
+
// Get 3D CLUT. Check the overflow....
nTabSize = uipow(OutputChannels, CLUTpoints, InputChannels);
+ if (nTabSize == (cmsUInt32Number) -1) goto Error;
if (nTabSize > 0) {
cmsUInt16Number *PtrW, *T;
- cmsUInt32Number Tsize;
-
- Tsize = (cmsUInt32Number) nTabSize * sizeof(cmsUInt16Number);
-
+
PtrW = T = (cmsUInt16Number*) _cmsCalloc(self ->ContextID, nTabSize, sizeof(cmsUInt16Number));
if (T == NULL) goto Error;
- Temp = (cmsUInt8Number*) _cmsMalloc(self ->ContextID, nTabSize);
- if (Temp == NULL) goto Error;
+ Temp = (cmsUInt8Number*) _cmsMalloc(self ->ContextID, nTabSize);
+ if (Temp == NULL) {
+ _cmsFree(self ->ContextID, T);
+ goto Error;
+ }
- if (io ->Read(io, Temp, nTabSize, 1) != 1) goto Error;
+ if (io ->Read(io, Temp, nTabSize, 1) != 1) {
+ _cmsFree(self ->ContextID, T);
+ _cmsFree(self ->ContextID, Temp);
+ goto Error;
+ }
for (i = 0; i < nTabSize; i++) {
_cmsFree(self ->ContextID, Temp);
Temp = NULL;
-
- mpeclut = cmsStageAllocCLut16bit(self ->ContextID, CLUTpoints, InputChannels, OutputChannels, T);
- if (mpeclut == NULL) goto Error;
- cmsPipelineInsertStage(NewLUT, cmsAT_END, mpeclut);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, cmsStageAllocCLut16bit(self ->ContextID, CLUTpoints, InputChannels, OutputChannels, T)))
+ goto Error;
_cmsFree(self ->ContextID, T);
}
// Get output tables
if (!Read8bitTables(self ->ContextID, io, NewLUT, OutputChannels)) goto Error;
-
+
*nItems = 1;
return NewLUT;
if (!Write8bitTables(self ->ContextID, io, NewLUT ->InputChannels, PreMPE)) return FALSE;
nTabSize = uipow(NewLUT->OutputChannels, clutPoints, NewLUT ->InputChannels);
+ if (nTabSize == (cmsUInt32Number) -1) return FALSE;
if (nTabSize > 0) {
- // The 3D CLUT.
- if (clut != NULL) {
+ // The 3D CLUT.
+ if (clut != NULL) {
- for (j=0; j < nTabSize; j++) {
+ for (j=0; j < nTabSize; j++) {
- val = (cmsUInt8Number) FROM_16_TO_8(clut ->Tab.T[j]);
- if (!_cmsWriteUInt8Number(io, val)) return FALSE;
+ val = (cmsUInt8Number) FROM_16_TO_8(clut ->Tab.T[j]);
+ if (!_cmsWriteUInt8Number(io, val)) return FALSE;
+ }
}
}
- }
// The postlinearization table
if (!Write8bitTables(self ->ContextID, io, NewLUT ->OutputChannels, PostMPE)) return FALSE;
static
void Type_LUT8_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsPipelineFree((cmsPipeline*) Ptr);
return;
// ********************************************************************************
// Read 16 bit tables as gamma functions
-static
+static
cmsBool Read16bitTables(cmsContext ContextID, cmsIOHANDLER* io, cmsPipeline* lut, int nChannels, int nEntries)
{
- cmsStage* mpe;
int i;
cmsToneCurve* Tables[cmsMAXCHANNELS];
if (nEntries <= 0) return TRUE;
// Check for malicious profiles
+ if (nEntries < 2) return FALSE;
if (nChannels > cmsMAXCHANNELS) return FALSE;
-
+
// Init table to zero
memset(Tables, 0, sizeof(Tables));
// Add the table (which may certainly be an identity, but this is up to the optimizer, not the reading code)
- mpe = cmsStageAllocToneCurves(ContextID, nChannels, Tables);
- if (mpe == NULL) goto Error;
-
- cmsPipelineInsertStage(lut, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, nChannels, Tables)))
+ goto Error;
- for (i=0; i < nChannels; i++)
+ for (i=0; i < nChannels; i++)
cmsFreeToneCurve(Tables[i]);
return TRUE;
if (Tables[i]) cmsFreeToneCurve(Tables[i]);
}
- return FALSE;
+ return FALSE;
}
static
int j;
cmsUInt32Number i;
cmsUInt16Number val;
- int nEntries = 256;
+ int nEntries;
+
+ _cmsAssert(Tables != NULL);
nEntries = Tables->TheCurves[0]->nEntries;
-
+
for (i=0; i < Tables ->nCurves; i++) {
for (j=0; j < nEntries; j++) {
- if (Tables != NULL)
- val = Tables->TheCurves[i]->Table16[j];
- else
- val = _cmsQuantizeVal(j, nEntries);
-
+ val = Tables->TheCurves[i]->Table16[j];
if (!_cmsWriteUInt16Number(io, val)) return FALSE;
}
}
{
cmsUInt8Number InputChannels, OutputChannels, CLUTpoints;
cmsPipeline* NewLUT = NULL;
- cmsStage *mpemat, *mpeclut;
cmsUInt32Number nTabSize;
cmsFloat64Number Matrix[3*3];
cmsUInt16Number InputEntries, OutputEntries;
-
+
*nItems = 0;
if (!_cmsReadUInt8Number(io, &InputChannels)) return NULL;
if (!_cmsReadUInt8Number(io, &OutputChannels)) return NULL;
if (!_cmsReadUInt8Number(io, &CLUTpoints)) return NULL; // 255 maximum
-
+
// Padding
if (!_cmsReadUInt8Number(io, NULL)) return NULL;
// Only operates on 3 channels
-
if ((InputChannels == 3) && !_cmsMAT3isIdentity((cmsMAT3*) Matrix)) {
- mpemat = cmsStageAllocMatrix(self ->ContextID, 3, 3, Matrix, NULL);
- if (mpemat == NULL) goto Error;
- cmsPipelineInsertStage(NewLUT, cmsAT_END, mpemat);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, cmsStageAllocMatrix(self ->ContextID, 3, 3, Matrix, NULL)))
+ goto Error;
}
- if (!_cmsReadUInt16Number(io, &InputEntries)) return NULL;
- if (!_cmsReadUInt16Number(io, &OutputEntries)) return NULL;
+ if (!_cmsReadUInt16Number(io, &InputEntries)) goto Error;
+ if (!_cmsReadUInt16Number(io, &OutputEntries)) goto Error;
+
+ if (InputEntries > 0x7FFF || OutputEntries > 0x7FFF) goto Error;
+ if (CLUTpoints == 1) goto Error; // Impossible value, 0 for no CLUT and then 2 at least
-
// Get input tables
if (!Read16bitTables(self ->ContextID, io, NewLUT, InputChannels, InputEntries)) goto Error;
// Get 3D CLUT
nTabSize = uipow(OutputChannels, CLUTpoints, InputChannels);
+ if (nTabSize == (cmsUInt32Number) -1) goto Error;
if (nTabSize > 0) {
cmsUInt16Number *T;
if (!_cmsReadUInt16Array(io, nTabSize, T)) {
_cmsFree(self ->ContextID, T);
- goto Error;
- }
-
- mpeclut = cmsStageAllocCLut16bit(self ->ContextID, CLUTpoints, InputChannels, OutputChannels, T);
- if (mpeclut == NULL) {
- _cmsFree(self ->ContextID, T);
goto Error;
}
- cmsPipelineInsertStage(NewLUT, cmsAT_END, mpeclut);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, cmsStageAllocCLut16bit(self ->ContextID, CLUTpoints, InputChannels, OutputChannels, T))) {
+ _cmsFree(self ->ContextID, T);
+ goto Error;
+ }
_cmsFree(self ->ContextID, T);
}
cmsUNUSED_PARAMETER(SizeOfTag);
}
-// We only allow some specific MPE structures: Matrix plus prelin, plus clut, plus post-lin.
+// We only allow some specific MPE structures: Matrix plus prelin, plus clut, plus post-lin.
// Some empty defaults are created for missing parts
static
_cmsStageToneCurvesData* PreMPE = NULL, *PostMPE = NULL;
_cmsStageMatrixData* MatMPE = NULL;
_cmsStageCLutData* clut = NULL;
- int InputChannels, OutputChannels, clutPoints;
+ int i, InputChannels, OutputChannels, clutPoints;
// Disassemble the LUT into components.
mpe = NewLUT -> Elements;
MatMPE = (_cmsStageMatrixData*) mpe ->Data;
mpe = mpe -> Next;
}
-
+
if (mpe != NULL && mpe ->Type == cmsSigCurveSetElemType) {
PreMPE = (_cmsStageToneCurvesData*) mpe ->Data;
mpe = mpe -> Next;
}
-
+
if (mpe != NULL && mpe ->Type == cmsSigCLutElemType) {
clut = (_cmsStageCLutData*) mpe -> Data;
mpe = mpe ->Next;
}
-
+
if (mpe != NULL && mpe ->Type == cmsSigCurveSetElemType) {
PostMPE = (_cmsStageToneCurvesData*) mpe ->Data;
mpe = mpe -> Next;
InputChannels = cmsPipelineInputChannels(NewLUT);
OutputChannels = cmsPipelineOutputChannels(NewLUT);
-
+
if (clut == NULL)
clutPoints = 0;
else
if (MatMPE != NULL) {
-
+
if (!_cmsWrite15Fixed16Number(io, MatMPE -> Double[0])) return FALSE;
if (!_cmsWrite15Fixed16Number(io, MatMPE -> Double[1])) return FALSE;
if (!_cmsWrite15Fixed16Number(io, MatMPE -> Double[2])) return FALSE;
if (PreMPE != NULL) {
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) PreMPE ->TheCurves[0]->nEntries)) return FALSE;
} else {
- if (!_cmsWriteUInt16Number(io, 0)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, 2)) return FALSE;
}
if (PostMPE != NULL) {
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) PostMPE ->TheCurves[0]->nEntries)) return FALSE;
} else {
- if (!_cmsWriteUInt16Number(io, 0)) return FALSE;
-
+ if (!_cmsWriteUInt16Number(io, 2)) return FALSE;
+
}
// The prelinearization table
if (PreMPE != NULL) {
if (!Write16bitTables(self ->ContextID, io, PreMPE)) return FALSE;
}
+ else {
+ for (i=0; i < InputChannels; i++) {
+
+ if (!_cmsWriteUInt16Number(io, 0)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, 0xffff)) return FALSE;
+ }
+ }
nTabSize = uipow(OutputChannels, clutPoints, InputChannels);
-
+ if (nTabSize == (cmsUInt32Number) -1) return FALSE;
if (nTabSize > 0) {
- // The 3D CLUT.
- if (clut != NULL) {
- if (!_cmsWriteUInt16Array(io, nTabSize, clut->Tab.T)) return FALSE;
- }
+ // The 3D CLUT.
+ if (clut != NULL) {
+ if (!_cmsWriteUInt16Array(io, nTabSize, clut->Tab.T)) return FALSE;
+ }
}
// The postlinearization table
if (PostMPE != NULL) {
if (!Write16bitTables(self ->ContextID, io, PostMPE)) return FALSE;
}
+ else {
+ for (i=0; i < OutputChannels; i++) {
+ if (!_cmsWriteUInt16Number(io, 0)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, 0xffff)) return FALSE;
+ }
+ }
return TRUE;
static
void Type_LUT16_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsPipelineFree((cmsPipeline*) Ptr);
return;
cmsFloat64Number dOff[3];
cmsStage* Mat;
- // Go to address
+ // Go to address
if (!io -> Seek(io, Offset)) return NULL;
// Read the Matrix
if (!_cmsRead15Fixed16Number(io, &dOff[0])) return NULL;
if (!_cmsRead15Fixed16Number(io, &dOff[1])) return NULL;
if (!_cmsRead15Fixed16Number(io, &dOff[2])) return NULL;
-
+
Mat = cmsStageAllocMatrix(self ->ContextID, 3, 3, dMat, dOff);
return Mat;
static
cmsStage* ReadCLUT(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number Offset, int InputChannels, int OutputChannels)
{
- cmsUInt8Number gridPoints8[cmsMAXCHANNELS]; // Number of grid points in each dimension.
+ cmsUInt8Number gridPoints8[cmsMAXCHANNELS]; // Number of grid points in each dimension.
cmsUInt32Number GridPoints[cmsMAXCHANNELS], i;
cmsUInt8Number Precision;
cmsStage* CLUT;
if (!io -> Seek(io, Offset)) return NULL;
if (io -> Read(io, gridPoints8, cmsMAXCHANNELS, 1) != 1) return NULL;
- for (i=0; i < cmsMAXCHANNELS; i++)
+
+ for (i=0; i < cmsMAXCHANNELS; i++) {
+
+ if (gridPoints8[i] == 1) return NULL; // Impossible value, 0 for no CLUT and then 2 at least
GridPoints[i] = gridPoints8[i];
+ }
if (!_cmsReadUInt8Number(io, &Precision)) return NULL;
// Precision can be 1 or 2 bytes
if (Precision == 1) {
- cmsUInt8Number v;
-
+ cmsUInt8Number v;
+
for (i=0; i < Data ->nEntries; i++) {
- if (io ->Read(io, &v, sizeof(cmsUInt8Number), 1) != 1) return NULL;
- Data ->Tab.T[i] = FROM_8_TO_16(v);
+ if (io ->Read(io, &v, sizeof(cmsUInt8Number), 1) != 1) return NULL;
+ Data ->Tab.T[i] = FROM_8_TO_16(v);
}
-
+
}
- else
+ else
if (Precision == 2) {
-
- if (!_cmsReadUInt16Array(io, Data->nEntries, Data ->Tab.T)) return NULL;
- }
- else {
- cmsSignalError(self ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown precision of '%d'", Precision);
- return NULL;
- }
-
- return CLUT;
+ if (!_cmsReadUInt16Array(io, Data->nEntries, Data ->Tab.T)) {
+ cmsStageFree(CLUT);
+ return NULL;
+ }
+ }
+ else {
+ cmsStageFree(CLUT);
+ cmsSignalError(self ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown precision of '%d'", Precision);
+ return NULL;
+ }
+
+ return CLUT;
}
static
cmsTagTypeSignature BaseType;
cmsUInt32Number nItems;
- BaseType = _cmsReadTypeBase(io);
+ BaseType = _cmsReadTypeBase(io);
switch (BaseType) {
case cmsSigCurveType:
case cmsSigParametricCurveType:
return (cmsToneCurve*) Type_ParametricCurve_Read(self, io, &nItems, 0);
- default:
+ default:
{
char String[5];
// Read a set of curves from specific offset
static
cmsStage* ReadSetOfCurves(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number Offset, cmsUInt32Number nCurves)
-{
+{
cmsToneCurve* Curves[cmsMAXCHANNELS];
cmsUInt32Number i;
cmsStage* Lin = NULL;
if (nCurves > cmsMAXCHANNELS) return FALSE;
if (!io -> Seek(io, Offset)) return FALSE;
-
- for (i=0; i < nCurves; i++)
+
+ for (i=0; i < nCurves; i++)
Curves[i] = NULL;
for (i=0; i < nCurves; i++) {
- Curves[i] = ReadEmbeddedCurve(self, io);
+ Curves[i] = ReadEmbeddedCurve(self, io);
if (Curves[i] == NULL) goto Error;
- if (!_cmsReadAlignment(io)) goto Error;
+ if (!_cmsReadAlignment(io)) goto Error;
+
}
-
+
Lin = cmsStageAllocToneCurves(self ->ContextID, nCurves, Curves);
-
+
Error:
- for (i=0; i < nCurves; i++)
+ for (i=0; i < nCurves; i++)
cmsFreeToneCurve(Curves[i]);
return Lin;
}
-// LutAtoB type
+// LutAtoB type
-// This structure represents a colour transform. The type contains up to five processing
-// elements which are stored in the AtoBTag tag in the following order: a set of one
-// dimensional curves, a 3 by 3 matrix with offset terms, a set of one dimensional curves,
+// This structure represents a colour transform. The type contains up to five processing
+// elements which are stored in the AtoBTag tag in the following order: a set of one
+// dimensional curves, a 3 by 3 matrix with offset terms, a set of one dimensional curves,
// a multidimensional lookup table, and a set of one dimensional output curves.
// Data are processed using these elements via the following sequence:
//
//("A" curves) -> (multidimensional lookup table - CLUT) -> ("M" curves) -> (matrix) -> ("B" curves).
//
/*
-It is possible to use any or all of these processing elements. At least one processing element
+It is possible to use any or all of these processing elements. At least one processing element
must be included.Only the following combinations are allowed:
B
void* Type_LUTA2B_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
{
cmsUInt32Number BaseOffset;
- cmsUInt8Number inputChan; // Number of input channels
- cmsUInt8Number outputChan; // Number of output channels
- cmsUInt32Number offsetB; // Offset to first "B" curve
- cmsUInt32Number offsetMat; // Offset to matrix
- cmsUInt32Number offsetM; // Offset to first "M" curve
- cmsUInt32Number offsetC; // Offset to CLUT
+ cmsUInt8Number inputChan; // Number of input channels
+ cmsUInt8Number outputChan; // Number of output channels
+ cmsUInt32Number offsetB; // Offset to first "B" curve
+ cmsUInt32Number offsetMat; // Offset to matrix
+ cmsUInt32Number offsetM; // Offset to first "M" curve
+ cmsUInt32Number offsetC; // Offset to CLUT
cmsUInt32Number offsetA; // Offset to first "A" curve
- cmsStage* mpe;
cmsPipeline* NewLUT = NULL;
if (!_cmsReadUInt8Number(io, &inputChan)) return NULL;
if (!_cmsReadUInt8Number(io, &outputChan)) return NULL;
-
+
if (!_cmsReadUInt16Number(io, NULL)) return NULL;
-
+
if (!_cmsReadUInt32Number(io, &offsetB)) return NULL;
if (!_cmsReadUInt32Number(io, &offsetMat)) return NULL;
if (!_cmsReadUInt32Number(io, &offsetM)) return NULL;
if (NewLUT == NULL) return NULL;
if (offsetA!= 0) {
- mpe = ReadSetOfCurves(self, io, BaseOffset + offsetA, inputChan);
- cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadSetOfCurves(self, io, BaseOffset + offsetA, inputChan)))
+ goto Error;
}
if (offsetC != 0) {
- mpe = ReadCLUT(self, io, BaseOffset + offsetC, inputChan, outputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadCLUT(self, io, BaseOffset + offsetC, inputChan, outputChan)))
+ goto Error;
}
if (offsetM != 0) {
- mpe = ReadSetOfCurves(self, io, BaseOffset + offsetM, outputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadSetOfCurves(self, io, BaseOffset + offsetM, outputChan)))
+ goto Error;
}
- if (offsetMat != 0) {
- mpe = ReadMatrix(self, io, BaseOffset + offsetMat);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (offsetMat != 0) {
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadMatrix(self, io, BaseOffset + offsetMat)))
+ goto Error;
}
- if (offsetB != 0) {
- mpe = ReadSetOfCurves(self, io, BaseOffset + offsetB, outputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (offsetB != 0) {
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadSetOfCurves(self, io, BaseOffset + offsetB, outputChan)))
+ goto Error;
}
-
+
*nItems = 1;
return NewLUT;
+Error:
+ cmsPipelineFree(NewLUT);
+ return NULL;
cmsUNUSED_PARAMETER(SizeOfTag);
}
// Write a set of curves
static
cmsBool WriteMatrix(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsStage* mpe)
-{
+{
_cmsStageMatrixData* m = (_cmsStageMatrixData*) mpe -> Data;
// Write the Matrix
// Write a set of curves
static
cmsBool WriteSetOfCurves(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsTagTypeSignature Type, cmsStage* mpe)
-{
+{
cmsUInt32Number i, n;
cmsTagTypeSignature CurrentType;
cmsToneCurve** Curves;
// If this is a table-based curve, use curve type even on V4
CurrentType = Type;
- if (Curves[i] ->nSegments == 0)
+ if ((Curves[i] ->nSegments == 0)||
+ ((Curves[i]->nSegments == 2) && (Curves[i] ->Segments[1].Type == 0)) )
CurrentType = cmsSigCurveType;
else
if (Curves[i] ->Segments[0].Type < 0)
if (!Type_ParametricCurve_Write(self, io, Curves[i], 1)) return FALSE;
break;
- default:
+ default:
{
char String[5];
_cmsTagSignature2String(String, (cmsTagSignature) Type);
cmsSignalError(self ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown curve type '%s'", String);
- }
+ }
return FALSE;
}
static
cmsBool WriteCLUT(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt8Number Precision, cmsStage* mpe)
{
- cmsUInt8Number gridPoints[cmsMAXCHANNELS]; // Number of grid points in each dimension.
- cmsUInt32Number i;
+ cmsUInt8Number gridPoints[cmsMAXCHANNELS]; // Number of grid points in each dimension.
+ cmsUInt32Number i;
_cmsStageCLutData* CLUT = ( _cmsStageCLutData*) mpe -> Data;
if (CLUT ->HasFloatValues) {
- cmsSignalError(self ->ContextID, cmsERROR_NOT_SUITABLE, "Cannot save floating point data, CLUT are 8 or 16 bit only");
+ cmsSignalError(self ->ContextID, cmsERROR_NOT_SUITABLE, "Cannot save floating point data, CLUT are 8 or 16 bit only");
return FALSE;
}
memset(gridPoints, 0, sizeof(gridPoints));
- for (i=0; i < (cmsUInt32Number) CLUT ->Params ->nInputs; i++)
+ for (i=0; i < (cmsUInt32Number) CLUT ->Params ->nInputs; i++)
gridPoints[i] = (cmsUInt8Number) CLUT ->Params ->nSamples[i];
if (!io -> Write(io, cmsMAXCHANNELS*sizeof(cmsUInt8Number), gridPoints)) return FALSE;
for (i=0; i < CLUT->nEntries; i++) {
- if (!_cmsWriteUInt8Number(io, FROM_16_TO_8(CLUT->Tab.T[i]))) return FALSE;
+ if (!_cmsWriteUInt8Number(io, FROM_16_TO_8(CLUT->Tab.T[i]))) return FALSE;
}
}
- else
+ else
if (Precision == 2) {
if (!_cmsWriteUInt16Array(io, CLUT->nEntries, CLUT ->Tab.T)) return FALSE;
}
else {
- cmsSignalError(self ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown precision of '%d'", Precision);
+ cmsSignalError(self ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown precision of '%d'", Precision);
return FALSE;
}
if (Lut ->Elements != NULL)
if (!cmsPipelineCheckAndRetreiveStages(Lut, 1, cmsSigCurveSetElemType, &B))
- if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType, &M, &Matrix, &B))
- if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &A, &CLUT, &B))
- if (!cmsPipelineCheckAndRetreiveStages(Lut, 5, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType,
- cmsSigMatrixElemType, cmsSigCurveSetElemType, &A, &CLUT, &M, &Matrix, &B)) {
+ if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType, &M, &Matrix, &B))
+ if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &A, &CLUT, &B))
+ if (!cmsPipelineCheckAndRetreiveStages(Lut, 5, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType,
+ cmsSigMatrixElemType, cmsSigCurveSetElemType, &A, &CLUT, &M, &Matrix, &B)) {
cmsSignalError(self->ContextID, cmsERROR_NOT_SUITABLE, "LUT is not suitable to be saved as LutAToB");
return FALSE;
offsetA = io ->Tell(io) - BaseOffset;
if (!WriteSetOfCurves(self, io, cmsSigParametricCurveType, A)) return FALSE;
}
-
+
if (CLUT != NULL) {
offsetC = io ->Tell(io) - BaseOffset;
if (!WriteCLUT(self, io, Lut ->SaveAs8Bits ? 1 : 2, CLUT)) return FALSE;
offsetM = io ->Tell(io) - BaseOffset;
if (!WriteSetOfCurves(self, io, cmsSigParametricCurveType, M)) return FALSE;
}
-
+
if (Matrix != NULL) {
offsetMat = io ->Tell(io) - BaseOffset;
if (!WriteMatrix(self, io, Matrix)) return FALSE;
offsetB = io ->Tell(io) - BaseOffset;
if (!WriteSetOfCurves(self, io, cmsSigParametricCurveType, B)) return FALSE;
}
-
+
CurrentPos = io ->Tell(io);
if (!io ->Seek(io, DirectoryPos)) return FALSE;
if (!_cmsWriteUInt32Number(io, offsetA)) return FALSE;
if (!io ->Seek(io, CurrentPos)) return FALSE;
-
+
return TRUE;
cmsUNUSED_PARAMETER(nItems);
static
void Type_LUTA2B_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsPipelineFree((cmsPipeline*) Ptr);
return;
}
-// LutBToA type
+// LutBToA type
static
void* Type_LUTB2A_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
{
- cmsUInt8Number inputChan; // Number of input channels
- cmsUInt8Number outputChan; // Number of output channels
+ cmsUInt8Number inputChan; // Number of input channels
+ cmsUInt8Number outputChan; // Number of output channels
cmsUInt32Number BaseOffset; // Actual position in file
- cmsUInt32Number offsetB; // Offset to first "B" curve
- cmsUInt32Number offsetMat; // Offset to matrix
- cmsUInt32Number offsetM; // Offset to first "M" curve
- cmsUInt32Number offsetC; // Offset to CLUT
+ cmsUInt32Number offsetB; // Offset to first "B" curve
+ cmsUInt32Number offsetMat; // Offset to matrix
+ cmsUInt32Number offsetM; // Offset to first "M" curve
+ cmsUInt32Number offsetC; // Offset to CLUT
cmsUInt32Number offsetA; // Offset to first "A" curve
- cmsStage* mpe;
cmsPipeline* NewLUT = NULL;
// Padding
if (!_cmsReadUInt16Number(io, NULL)) return NULL;
-
+
if (!_cmsReadUInt32Number(io, &offsetB)) return NULL;
if (!_cmsReadUInt32Number(io, &offsetMat)) return NULL;
if (!_cmsReadUInt32Number(io, &offsetM)) return NULL;
// Allocates an empty LUT
NewLUT = cmsPipelineAlloc(self ->ContextID, inputChan, outputChan);
if (NewLUT == NULL) return NULL;
-
- if (offsetB != 0) {
- mpe = ReadSetOfCurves(self, io, BaseOffset + offsetB, inputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+
+ if (offsetB != 0) {
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadSetOfCurves(self, io, BaseOffset + offsetB, inputChan)))
+ goto Error;
}
- if (offsetMat != 0) {
- mpe = ReadMatrix(self, io, BaseOffset + offsetMat);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (offsetMat != 0) {
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadMatrix(self, io, BaseOffset + offsetMat)))
+ goto Error;
}
if (offsetM != 0) {
- mpe = ReadSetOfCurves(self, io, BaseOffset + offsetM, inputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadSetOfCurves(self, io, BaseOffset + offsetM, inputChan)))
+ goto Error;
}
if (offsetC != 0) {
- mpe = ReadCLUT(self, io, BaseOffset + offsetC, inputChan, outputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadCLUT(self, io, BaseOffset + offsetC, inputChan, outputChan)))
+ goto Error;
}
if (offsetA!= 0) {
- mpe = ReadSetOfCurves(self, io, BaseOffset + offsetA, outputChan);
- if (mpe != NULL) cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, ReadSetOfCurves(self, io, BaseOffset + offsetA, outputChan)))
+ goto Error;
}
*nItems = 1;
return NewLUT;
+Error:
+ cmsPipelineFree(NewLUT);
+ return NULL;
cmsUNUSED_PARAMETER(SizeOfTag);
}
BaseOffset = io ->Tell(io) - sizeof(_cmsTagBase);
if (!cmsPipelineCheckAndRetreiveStages(Lut, 1, cmsSigCurveSetElemType, &B))
- if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType, &B, &Matrix, &M))
- if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &B, &CLUT, &A))
- if (!cmsPipelineCheckAndRetreiveStages(Lut, 5, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType,
- cmsSigCLutElemType, cmsSigCurveSetElemType, &B, &Matrix, &M, &CLUT, &A)) {
+ if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType, &B, &Matrix, &M))
+ if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &B, &CLUT, &A))
+ if (!cmsPipelineCheckAndRetreiveStages(Lut, 5, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType,
+ cmsSigCLutElemType, cmsSigCurveSetElemType, &B, &Matrix, &M, &CLUT, &A)) {
cmsSignalError(self->ContextID, cmsERROR_NOT_SUITABLE, "LUT is not suitable to be saved as LutBToA");
return FALSE;
}
inputChan = cmsPipelineInputChannels(Lut);
outputChan = cmsPipelineOutputChannels(Lut);
-
+
if (!_cmsWriteUInt8Number(io, (cmsUInt8Number) inputChan)) return FALSE;
if (!_cmsWriteUInt8Number(io, (cmsUInt8Number) outputChan)) return FALSE;
if (!_cmsWriteUInt16Number(io, 0)) return FALSE;
DirectoryPos = io ->Tell(io);
- if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
- if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
if (!_cmsWriteUInt32Number(io, 0)) return FALSE;
offsetA = io ->Tell(io) - BaseOffset;
if (!WriteSetOfCurves(self, io, cmsSigParametricCurveType, A)) return FALSE;
}
-
+
if (CLUT != NULL) {
offsetC = io ->Tell(io) - BaseOffset;
if (!WriteCLUT(self, io, Lut ->SaveAs8Bits ? 1 : 2, CLUT)) return FALSE;
offsetM = io ->Tell(io) - BaseOffset;
if (!WriteSetOfCurves(self, io, cmsSigParametricCurveType, M)) return FALSE;
}
-
+
if (Matrix != NULL) {
offsetMat = io ->Tell(io) - BaseOffset;
- if (!WriteMatrix(self, io, Matrix)) return FALSE;
+ if (!WriteMatrix(self, io, Matrix)) return FALSE;
}
if (B != NULL) {
offsetB = io ->Tell(io) - BaseOffset;
if (!WriteSetOfCurves(self, io, cmsSigParametricCurveType, B)) return FALSE;
}
-
+
CurrentPos = io ->Tell(io);
if (!io ->Seek(io, DirectoryPos)) return FALSE;
if (!_cmsWriteUInt32Number(io, offsetA)) return FALSE;
if (!io ->Seek(io, CurrentPos)) return FALSE;
-
+
return TRUE;
cmsUNUSED_PARAMETER(nItems);
static
void Type_LUTB2A_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsPipelineFree((cmsPipeline*) Ptr);
return;
// Type cmsSigColorantTableType
// ********************************************************************************
/*
-The purpose of this tag is to identify the colorants used in the profile by a
-unique name and set of XYZ or L*a*b* values to give the colorant an unambiguous
+The purpose of this tag is to identify the colorants used in the profile by a
+unique name and set of XYZ or L*a*b* values to give the colorant an unambiguous
value. The first colorant listed is the colorant of the first device channel of
a lut tag. The second colorant listed is the colorant of the second device channel
of a lut tag, and so on.
cmsUInt32Number i, Count;
cmsNAMEDCOLORLIST* List;
char Name[34];
- cmsUInt16Number PCS[3];
+ cmsUInt16Number PCS[3];
if (!_cmsReadUInt32Number(io, &Count)) return NULL;
if (!_cmsReadUInt16Array(io, 3, PCS)) goto Error;
- if (!cmsAppendNamedColor(List, Name, PCS, NULL)) goto Error;
-
+ if (!cmsAppendNamedColor(List, Name, PCS, NULL)) goto Error;
+
}
*nItems = 1;
static
cmsBool Type_ColorantTable_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
- cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) Ptr;
+ cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) Ptr;
int i, nColors;
nColors = cmsNamedColorCount(NamedColorList);
for (i=0; i < nColors; i++) {
char root[33];
- cmsUInt16Number PCS[3];
+ cmsUInt16Number PCS[3];
if (!cmsNamedColorInfo(NamedColorList, i, root, NULL, NULL, PCS, NULL)) return 0;
root[32] = 0;
void* Type_ColorantTable_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n)
{
cmsNAMEDCOLORLIST* nc = (cmsNAMEDCOLORLIST*) Ptr;
- return (void*) cmsDupNamedColorList(nc);
+ return (void*) cmsDupNamedColorList(nc);
cmsUNUSED_PARAMETER(n);
cmsUNUSED_PARAMETER(self);
static
void Type_ColorantTable_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsFreeNamedColorList((cmsNAMEDCOLORLIST*) Ptr);
return;
// Type cmsSigNamedColor2Type
// ********************************************************************************
//
-//The namedColor2Type is a count value and array of structures that provide color
-//coordinates for 7-bit ASCII color names. For each named color, a PCS and optional
-//device representation of the color are given. Both representations are 16-bit values.
-//The device representation corresponds to the header\92s \93color space of data\94 field.
+//The namedColor2Type is a count value and array of structures that provide color
+//coordinates for 7-bit ASCII color names. For each named color, a PCS and optional
+//device representation of the color are given. Both representations are 16-bit values.
+//The device representation corresponds to the header\92s \93color space of data\94 field.
//This representation should be consistent with the \93number of device components\94
//field in the namedColor2Type. If this field is 0, device coordinates are not provided.
-//The PCS representation corresponds to the header\92s PCS field. The PCS representation
-//is always provided. Color names are fixed-length, 32-byte fields including null
-//termination. In order to maintain maximum portability, it is strongly recommended
+//The PCS representation corresponds to the header\92s PCS field. The PCS representation
+//is always provided. Color names are fixed-length, 32-byte fields including null
+//termination. In order to maintain maximum portability, it is strongly recommended
//that special characters of the 7-bit ASCII set not be used.
static
void *Type_NamedColor_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
{
- cmsUInt32Number vendorFlag; // Bottom 16 bits for ICC use
- cmsUInt32Number count; // Count of named colors
- cmsUInt32Number nDeviceCoords; // Num of device coordinates
- char prefix[32]; // Prefix for each color name
- char suffix[32]; // Suffix for each color name
+ cmsUInt32Number vendorFlag; // Bottom 16 bits for ICC use
+ cmsUInt32Number count; // Count of named colors
+ cmsUInt32Number nDeviceCoords; // Num of device coordinates
+ char prefix[32]; // Prefix for each color name
+ char suffix[32]; // Suffix for each color name
cmsNAMEDCOLORLIST* v;
cmsUInt32Number i;
cmsBool Type_NamedColor_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) Ptr;
- char prefix[32]; // Prefix for each color name
- char suffix[32]; // Suffix for each color name
+ char prefix[32]; // Prefix for each color name
+ char suffix[32]; // Suffix for each color name
int i, nColors;
nColors = cmsNamedColorCount(NamedColorList);
if (!cmsNamedColorInfo(NamedColorList, i, Root, NULL, NULL, PCS, Colorant)) return 0;
if (!io ->Write(io, 32 , Root)) return FALSE;
- if (!_cmsWriteUInt16Array(io, 3, PCS)) return FALSE;
+ if (!_cmsWriteUInt16Array(io, 3, PCS)) return FALSE;
if (!_cmsWriteUInt16Array(io, NamedColorList ->ColorantCount, Colorant)) return FALSE;
}
static
void Type_NamedColor_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsFreeNamedColorList((cmsNAMEDCOLORLIST*) Ptr);
return;
// Type cmsSigProfileSequenceDescType
// ********************************************************************************
-// This type is an array of structures, each of which contains information from the
-// header fields and tags from the original profiles which were combined to create
-// the final profile. The order of the structures is the order in which the profiles
-// were combined and includes a structure for the final profile. This provides a
-// description of the profile sequence from source to destination,
+// This type is an array of structures, each of which contains information from the
+// header fields and tags from the original profiles which were combined to create
+// the final profile. The order of the structures is the order in which the profiles
+// were combined and includes a structure for the final profile. This provides a
+// description of the profile sequence from source to destination,
// typically used with the DeviceLink profile.
static
cmsTagTypeSignature BaseType;
cmsUInt32Number nItems;
- BaseType = _cmsReadTypeBase(io);
+ BaseType = _cmsReadTypeBase(io);
switch (BaseType) {
case cmsSigTextType:
if (*mlu) cmsMLUfree(*mlu);
*mlu = (cmsMLU*)Type_Text_Read(self, io, &nItems, SizeOfTag);
- return (*mlu != NULL);
+ return (*mlu != NULL);
case cmsSigTextDescriptionType:
if (*mlu) cmsMLUfree(*mlu);
*mlu = (cmsMLU*) Type_Text_Description_Read(self, io, &nItems, SizeOfTag);
- return (*mlu != NULL);
+ return (*mlu != NULL);
/*
TBD: Size is needed for MLU, and we have no idea on which is the available size
{
cmsSEQ* OutSeq;
cmsUInt32Number i, Count;
-
+
*nItems = 0;
-
- if (!_cmsReadUInt32Number(io, &Count)) return NULL;
+
+ if (!_cmsReadUInt32Number(io, &Count)) return NULL;
if (SizeOfTag < sizeof(cmsUInt32Number)) return NULL;
SizeOfTag -= sizeof(cmsUInt32Number);
-
+
OutSeq = cmsAllocProfileSequenceDescription(self ->ContextID, Count);
if (OutSeq == NULL) return NULL;
OutSeq ->n = Count;
-
+
// Get structures as well
for (i=0; i < Count; i++) {
-
+
cmsPSEQDESC* sec = &OutSeq -> seq[i];
- if (!_cmsReadUInt32Number(io, &sec ->deviceMfg)) return NULL;
- if (SizeOfTag < sizeof(cmsUInt32Number)) return NULL;
+ if (!_cmsReadUInt32Number(io, &sec ->deviceMfg)) goto Error;
+ if (SizeOfTag < sizeof(cmsUInt32Number)) goto Error;
SizeOfTag -= sizeof(cmsUInt32Number);
- if (!_cmsReadUInt32Number(io, &sec ->deviceModel)) return NULL;
- if (SizeOfTag < sizeof(cmsUInt32Number)) return NULL;
+ if (!_cmsReadUInt32Number(io, &sec ->deviceModel)) goto Error;
+ if (SizeOfTag < sizeof(cmsUInt32Number)) goto Error;
SizeOfTag -= sizeof(cmsUInt32Number);
- if (!_cmsReadUInt64Number(io, &sec ->attributes)) return NULL;
- if (SizeOfTag < sizeof(cmsUInt32Number)) return NULL;
+ if (!_cmsReadUInt64Number(io, &sec ->attributes)) goto Error;
+ if (SizeOfTag < sizeof(cmsUInt64Number)) goto Error;
SizeOfTag -= sizeof(cmsUInt64Number);
- if (!_cmsReadUInt32Number(io, (cmsUInt32Number *)&sec ->technology)) return NULL;
- if (SizeOfTag < sizeof(cmsUInt32Number)) return NULL;
+ if (!_cmsReadUInt32Number(io, (cmsUInt32Number *)&sec ->technology)) goto Error;
+ if (SizeOfTag < sizeof(cmsUInt32Number)) goto Error;
SizeOfTag -= sizeof(cmsUInt32Number);
- if (!ReadEmbeddedText(self, io, &sec ->Manufacturer, SizeOfTag)) return NULL;
- if (!ReadEmbeddedText(self, io, &sec ->Model, SizeOfTag)) return NULL;
+ if (!ReadEmbeddedText(self, io, &sec ->Manufacturer, SizeOfTag)) goto Error;
+ if (!ReadEmbeddedText(self, io, &sec ->Model, SizeOfTag)) goto Error;
}
*nItems = 1;
return OutSeq;
+
+Error:
+ cmsFreeProfileSequenceDescription(OutSeq);
+ return NULL;
}
static
cmsBool SaveDescription(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU* Text)
{
- if (self ->ICCVersion < 0x4000000) {
-
+ if (self ->ICCVersion < 0x4000000) {
+
if (!_cmsWriteTypeBase(io, cmsSigTextDescriptionType)) return FALSE;
return Type_Text_Description_Write(self, io, Text, 1);
}
cmsUInt32Number i;
if (!_cmsWriteUInt32Number(io, Seq->n)) return FALSE;
-
+
for (i=0; i < Seq ->n; i++) {
cmsPSEQDESC* sec = &Seq -> seq[i];
if (!_cmsWriteUInt32Number(io, sec ->deviceMfg)) return FALSE;
if (!_cmsWriteUInt32Number(io, sec ->deviceModel)) return FALSE;
- if (!_cmsWriteUInt64Number(io, sec ->attributes)) return FALSE;
+ if (!_cmsWriteUInt64Number(io, &sec ->attributes)) return FALSE;
if (!_cmsWriteUInt32Number(io, sec ->technology)) return FALSE;
-
- if (!SaveDescription(self, io, sec ->Manufacturer)) return FALSE;
- if (!SaveDescription(self, io, sec ->Model)) return FALSE;
+
+ if (!SaveDescription(self, io, sec ->Manufacturer)) return FALSE;
+ if (!SaveDescription(self, io, sec ->Model)) return FALSE;
}
-
- return TRUE;
+
+ return TRUE;
cmsUNUSED_PARAMETER(nItems);
}
static
void* Type_ProfileSequenceDesc_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n)
-{
+{
return (void*) cmsDupProfileSequenceDescription((cmsSEQ*) Ptr);
cmsUNUSED_PARAMETER(n);
static
void Type_ProfileSequenceDesc_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsFreeProfileSequenceDescription((cmsSEQ*) Ptr);
return;
// Type cmsSigProfileSequenceIdType
// ********************************************************************************
/*
-In certain workflows using ICC Device Link Profiles, it is necessary to identify the
+In certain workflows using ICC Device Link Profiles, it is necessary to identify the
original profiles that were combined to create the Device Link Profile.
-This type is an array of structures, each of which contains information for
+This type is an array of structures, each of which contains information for
identification of a profile used in a sequence
*/
static
-cmsBool ReadSeqID(struct _cms_typehandler_struct* self,
+cmsBool ReadSeqID(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
void* Cargo,
- cmsUInt32Number n,
+ cmsUInt32Number n,
cmsUInt32Number SizeOfTag)
{
cmsSEQ* OutSeq = (cmsSEQ*) Cargo;
cmsPSEQDESC* seq = &OutSeq ->seq[n];
-
+
if (io -> Read(io, seq ->ProfileID.ID8, 16, 1) != 1) return FALSE;
if (!ReadEmbeddedText(self, io, &seq ->Description, SizeOfTag)) return FALSE;
BaseOffset = io ->Tell(io) - sizeof(_cmsTagBase);
// Get table count
- if (!_cmsReadUInt32Number(io, &Count)) return NULL;
+ if (!_cmsReadUInt32Number(io, &Count)) return NULL;
SizeOfTag -= sizeof(cmsUInt32Number);
// Allocate an empty structure
static
-cmsBool WriteSeqID(struct _cms_typehandler_struct* self,
+cmsBool WriteSeqID(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
void* Cargo,
- cmsUInt32Number n,
+ cmsUInt32Number n,
cmsUInt32Number SizeOfTag)
{
cmsSEQ* Seq = (cmsSEQ*) Cargo;
-
+
if (!io ->Write(io, 16, Seq ->seq[n].ProfileID.ID8)) return FALSE;
// Store here the MLU
- if (!SaveDescription(self, io, Seq ->seq[n].Description)) return FALSE;
+ if (!SaveDescription(self, io, Seq ->seq[n].Description)) return FALSE;
return TRUE;
// Keep the base offset
BaseOffset = io ->Tell(io) - sizeof(_cmsTagBase);
-
+
// This is the table count
if (!_cmsWriteUInt32Number(io, Seq ->n)) return FALSE;
// This is the position table and content
if (!WritePositionTable(self, io, 0, Seq ->n, BaseOffset, Seq, WriteSeqID)) return FALSE;
-
+
return TRUE;
cmsUNUSED_PARAMETER(nItems);
static
void* Type_ProfileSequenceId_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n)
-{
+{
return (void*) cmsDupProfileSequenceDescription((cmsSEQ*) Ptr);
cmsUNUSED_PARAMETER(n);
static
void Type_ProfileSequenceId_Free(struct _cms_typehandler_struct* self, void* Ptr)
-{
+{
cmsFreeProfileSequenceDescription((cmsSEQ*) Ptr);
return;
if (!_cmsWriteUInt32Number(io, Value ->Ucr ->nEntries)) return FALSE;
if (!_cmsWriteUInt16Array(io, Value ->Ucr ->nEntries, Value ->Ucr ->Table16)) return FALSE;
- // Then black generation
+ // Then black generation
if (!_cmsWriteUInt32Number(io, Value ->Bg ->nEntries)) return FALSE;
if (!_cmsWriteUInt16Array(io, Value ->Bg ->nEntries, Value ->Bg ->Table16)) return FALSE;
Text = (char*) _cmsMalloc(self ->ContextID, TextSize);
if (cmsMLUgetASCII(Value ->Desc, cmsNoLanguage, cmsNoCountry, Text, TextSize) != TextSize) return FALSE;
- if (!io ->Write(io, TextSize, Text)) return FALSE;
+ if (!io ->Write(io, TextSize, Text)) return FALSE;
_cmsFree(self ->ContextID, Text);
return TRUE;
void Type_UcrBg_Free(struct _cms_typehandler_struct* self, void *Ptr)
{
cmsUcrBg* Src = (cmsUcrBg*) Ptr;
-
+
if (Src ->Ucr) cmsFreeToneCurve(Src ->Ucr);
if (Src ->Bg) cmsFreeToneCurve(Src ->Bg);
if (Src ->Desc) cmsMLUfree(Src ->Desc);
-
+
_cmsFree(self ->ContextID, Ptr);
}
cmsUInt32Number Count;
char* Text;
- if (*SizeOfTag < sizeof(cmsUInt32Number)) return FALSE;
-
+ if (*SizeOfTag < sizeof(cmsUInt32Number)) return FALSE;
+
if (!_cmsReadUInt32Number(io, &Count)) return FALSE;
if (Count > UINT_MAX - sizeof(cmsUInt32Number)) return FALSE;
- if (*SizeOfTag < Count + sizeof(cmsUInt32Number)) return FALSE;
+ if (*SizeOfTag < Count + sizeof(cmsUInt32Number)) return FALSE;
Text = (char*) _cmsMalloc(self ->ContextID, Count+1);
if (Text == NULL) return FALSE;
}
Text[Count] = 0;
-
+
cmsMLUsetASCII(mlu, "PS", Section, Text);
_cmsFree(self ->ContextID, Text);
*SizeOfTag -= (Count + sizeof(cmsUInt32Number));
- return TRUE;
+ return TRUE;
}
static
cmsBool WriteCountAndSting(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU* mlu, const char* Section)
{
cmsUInt32Number TextSize;
- char* Text;
-
+ char* Text;
+
TextSize = cmsMLUgetASCII(mlu, "PS", Section, NULL, 0);
Text = (char*) _cmsMalloc(self ->ContextID, TextSize);
- if (!_cmsWriteUInt32Number(io, TextSize)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, TextSize)) return FALSE;
if (cmsMLUgetASCII(mlu, "PS", Section, Text, TextSize) == 0) return FALSE;
- if (!io ->Write(io, TextSize, Text)) return FALSE;
+ if (!io ->Write(io, TextSize, Text)) return FALSE;
_cmsFree(self ->ContextID, Text);
return TRUE;
if (!ReadCountAndSting(self, io, mlu, &SizeOfTag, "#1")) goto Error;
if (!ReadCountAndSting(self, io, mlu, &SizeOfTag, "#2")) goto Error;
if (!ReadCountAndSting(self, io, mlu, &SizeOfTag, "#3")) goto Error;
-
+
*nItems = 1;
return (void*) mlu;
static
void Type_CrdInfo_Free(struct _cms_typehandler_struct* self, void *Ptr)
-{
+{
cmsMLUfree((cmsMLU*) Ptr);
return;
{
cmsScreening* sc = NULL;
cmsUInt32Number i;
-
+
sc = (cmsScreening*) _cmsMallocZero(self ->ContextID, sizeof(cmsScreening));
if (sc == NULL) return NULL;
*nItems = 0;
-
+
if (!_cmsReadUInt32Number(io, &sc ->Flag)) goto Error;
if (!_cmsReadUInt32Number(io, &sc ->nChannels)) goto Error;
for (i=0; i < sc ->nChannels; i++) {
- if (!_cmsRead15Fixed16Number(io, &sc ->Channels[i].Frequency)) goto Error;
- if (!_cmsRead15Fixed16Number(io, &sc ->Channels[i].ScreenAngle)) goto Error;
+ if (!_cmsRead15Fixed16Number(io, &sc ->Channels[i].Frequency)) goto Error;
+ if (!_cmsRead15Fixed16Number(io, &sc ->Channels[i].ScreenAngle)) goto Error;
if (!_cmsReadUInt32Number(io, &sc ->Channels[i].SpotShape)) goto Error;
}
return (void*) sc;
Error:
- if (sc != NULL)
+ if (sc != NULL)
_cmsFree(self ->ContextID, sc);
return NULL;
static
cmsBool Type_Screening_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
- cmsScreening* sc = (cmsScreening* ) Ptr;
+ cmsScreening* sc = (cmsScreening* ) Ptr;
cmsUInt32Number i;
-
+
if (!_cmsWriteUInt32Number(io, sc ->Flag)) return FALSE;
if (!_cmsWriteUInt32Number(io, sc ->nChannels)) return FALSE;
// Type cmsSigViewingConditionsType
// ********************************************************************************
//
-//This type represents a set of viewing condition parameters including:
-//CIE \92absolute\92 illuminant white point tristimulus values and CIE \92absolute\92
+//This type represents a set of viewing condition parameters including:
+//CIE \92absolute\92 illuminant white point tristimulus values and CIE \92absolute\92
//surround tristimulus values.
static
void *Type_ViewingConditions_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
{
cmsICCViewingConditions* vc = NULL;
-
+
vc = (cmsICCViewingConditions*) _cmsMallocZero(self ->ContextID, sizeof(cmsICCViewingConditions));
if (vc == NULL) return NULL;
*nItems = 0;
-
+
if (!_cmsReadXYZNumber(io, &vc ->IlluminantXYZ)) goto Error;
if (!_cmsReadXYZNumber(io, &vc ->SurroundXYZ)) goto Error;
if (!_cmsReadUInt32Number(io, &vc ->IlluminantType)) goto Error;
return (void*) vc;
Error:
- if (vc != NULL)
+ if (vc != NULL)
_cmsFree(self ->ContextID, vc);
return NULL;
static
cmsBool Type_ViewingConditions_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
{
- cmsICCViewingConditions* sc = (cmsICCViewingConditions* ) Ptr;
-
+ cmsICCViewingConditions* sc = (cmsICCViewingConditions* ) Ptr;
+
if (!_cmsWriteXYZNumber(io, &sc ->IlluminantXYZ)) return FALSE;
if (!_cmsWriteXYZNumber(io, &sc ->SurroundXYZ)) return FALSE;
if (!_cmsWriteUInt32Number(io, sc ->IlluminantType)) return FALSE;
static
void GenericMPEfree(struct _cms_typehandler_struct* self, void *Ptr)
-{
+{
cmsStageFree((cmsStage*) Ptr);
return;
// Read an embedded segmented curve
static
cmsToneCurve* ReadSegmentedCurve(struct _cms_typehandler_struct* self, cmsIOHANDLER* io)
-{
+{
cmsCurveSegSignature ElementSig;
cmsUInt32Number i, j;
cmsUInt16Number nSegments;
cmsCurveSegment* Segments;
cmsToneCurve* Curve;
cmsFloat32Number PrevBreak = -1E22F; // - infinite
-
+
// Take signature and channels for each element.
- if (!_cmsReadUInt32Number(io, (cmsUInt32Number*) &ElementSig)) return NULL;
+ if (!_cmsReadUInt32Number(io, (cmsUInt32Number*) &ElementSig)) return NULL;
// That should be a segmented curve
if (ElementSig != cmsSigSegmentedCurve) return NULL;
if (!_cmsReadUInt32Number(io, (cmsUInt32Number*) &ElementSig)) goto Error;
if (!_cmsReadUInt32Number(io, NULL)) goto Error;
-
+
switch (ElementSig) {
case cmsSigFormulaCurveSeg: {
-
+
cmsUInt16Number Type;
cmsUInt32Number ParamsByType[] = {4, 5, 5 };
_cmsTagSignature2String(String, (cmsTagSignature) ElementSig);
cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown curve element type '%s' found.", String);
}
- return NULL;
+ return NULL;
}
}
static
-cmsBool ReadMPECurve(struct _cms_typehandler_struct* self,
+cmsBool ReadMPECurve(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
void* Cargo,
- cmsUInt32Number n,
+ cmsUInt32Number n,
cmsUInt32Number SizeOfTag)
{
cmsToneCurve** GammaTables = ( cmsToneCurve**) Cargo;
cmsCurveSegment* Segments = g ->Segments;
cmsUInt32Number nSegments = g ->nSegments;
- if (!_cmsWriteUInt32Number(io, cmsSigSegmentedCurve)) goto Error;
- if (!_cmsWriteUInt32Number(io, 0)) goto Error;
- if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) nSegments)) goto Error;
- if (!_cmsWriteUInt16Number(io, 0)) goto Error;
+ if (!_cmsWriteUInt32Number(io, cmsSigSegmentedCurve)) goto Error;
+ if (!_cmsWriteUInt32Number(io, 0)) goto Error;
+ if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) nSegments)) goto Error;
+ if (!_cmsWriteUInt16Number(io, 0)) goto Error;
// Write the break-points
for (i=0; i < nSegments - 1; i++) {
for (j=0; j < ParamsByType[Type]; j++) {
if (!_cmsWriteFloat32Number(io, (cmsFloat32Number) ActualSeg ->Params[j])) goto Error;
}
- }
+ }
// It seems there is no need to align. Code is here, and for safety commented out
// if (!_cmsWriteAlignment(io)) goto Error;
static
-cmsBool WriteMPECurve(struct _cms_typehandler_struct* self,
+cmsBool WriteMPECurve(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
void* Cargo,
- cmsUInt32Number n,
+ cmsUInt32Number n,
cmsUInt32Number SizeOfTag)
{
_cmsStageToneCurvesData* Curves = (_cmsStageToneCurvesData*) Cargo;
// Write a curve, checking first for validity
static
cmsBool Type_MPEcurve_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
-{
+{
cmsUInt32Number BaseOffset;
cmsStage* mpe = (cmsStage*) Ptr;
_cmsStageToneCurvesData* Curves = (_cmsStageToneCurvesData*) mpe ->Data;
// Write the header. Since those are curves, input and output channels are same
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) mpe ->InputChannels)) return FALSE;
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) mpe ->InputChannels)) return FALSE;
-
- if (!WritePositionTable(self, io, 0,
+
+ if (!WritePositionTable(self, io, 0,
mpe ->InputChannels, BaseOffset, Curves, WriteMPECurve)) return FALSE;
{
cmsStage* mpe;
cmsUInt16Number InputChans, OutputChans;
- cmsUInt32Number nElems, i;
+ cmsUInt32Number nElems, i;
cmsFloat64Number* Matrix;
cmsFloat64Number* Offsets;
if (!_cmsReadUInt16Number(io, &InputChans)) return NULL;
if (!_cmsReadUInt16Number(io, &OutputChans)) return NULL;
-
+
nElems = InputChans * OutputChans;
// Input and output chans may be ANY (up to 0xffff)
Offsets = (cmsFloat64Number*) _cmsCalloc(self ->ContextID, OutputChans, sizeof(cmsFloat64Number));
if (Offsets == NULL) {
-
+
_cmsFree(self ->ContextID, Matrix);
return NULL;
}
cmsFloat32Number v;
- if (!_cmsReadFloat32Number(io, &v)) return NULL;
+ if (!_cmsReadFloat32Number(io, &v)) return NULL;
Matrix[i] = v;
}
cmsFloat32Number v;
- if (!_cmsReadFloat32Number(io, &v)) return NULL;
+ if (!_cmsReadFloat32Number(io, &v)) return NULL;
Offsets[i] = v;
}
cmsStage* mpe = (cmsStage*) Ptr;
_cmsStageMatrixData* Matrix = (_cmsStageMatrixData*) mpe ->Data;
- if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) mpe ->InputChannels)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) mpe ->InputChannels)) return FALSE;
if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) mpe ->OutputChannels)) return FALSE;
nElems = mpe ->InputChannels * mpe ->OutputChannels;
for (i=0; i < nElems; i++) {
- if (!_cmsWriteFloat32Number(io, (cmsFloat32Number) Matrix->Double[i])) return FALSE;
+ if (!_cmsWriteFloat32Number(io, (cmsFloat32Number) Matrix->Double[i])) return FALSE;
}
if (Matrix ->Offset == NULL) {
- if (!_cmsWriteFloat32Number(io, 0)) return FALSE;
+ if (!_cmsWriteFloat32Number(io, 0)) return FALSE;
}
else {
- if (!_cmsWriteFloat32Number(io, (cmsFloat32Number) Matrix->Offset[i])) return FALSE;
+ if (!_cmsWriteFloat32Number(io, (cmsFloat32Number) Matrix->Offset[i])) return FALSE;
}
}
cmsUInt8Number Dimensions8[16];
cmsUInt32Number i, nMaxGrids, GridPoints[MAX_INPUT_DIMENSIONS];
_cmsStageCLutData* clut;
-
+
if (!_cmsReadUInt16Number(io, &InputChans)) return NULL;
if (!_cmsReadUInt16Number(io, &OutputChans)) return NULL;
-
+
+ if (InputChans == 0) goto Error;
+ if (OutputChans == 0) goto Error;
+
if (io ->Read(io, Dimensions8, sizeof(cmsUInt8Number), 16) != 16)
goto Error;
-
+
// Copy MAX_INPUT_DIMENSIONS at most. Expand to cmsUInt32Number
nMaxGrids = InputChans > MAX_INPUT_DIMENSIONS ? MAX_INPUT_DIMENSIONS : InputChans;
for (i=0; i < nMaxGrids; i++) GridPoints[i] = (cmsUInt32Number) Dimensions8[i];
// Read the data
clut = (_cmsStageCLutData*) mpe ->Data;
for (i=0; i < clut ->nEntries; i++) {
-
+
if (!_cmsReadFloat32Number(io, &clut ->Tab.TFloat[i])) goto Error;
}
- *nItems = 1;
+ *nItems = 1;
return mpe;
Error:
// Write a CLUT in floating point
static
cmsBool Type_MPEclut_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
-{
+{
cmsUInt8Number Dimensions8[16];
cmsUInt32Number i;
cmsStage* mpe = (cmsStage*) Ptr;
// Check for maximum number of channels
if (mpe -> InputChannels > 15) return FALSE;
-
+
// Only floats are supported in MPE
if (clut ->HasFloatValues == FALSE) return FALSE;
memset(Dimensions8, 0, sizeof(Dimensions8));
- for (i=0; i < mpe ->InputChannels; i++)
+ for (i=0; i < mpe ->InputChannels; i++)
Dimensions8[i] = (cmsUInt8Number) clut ->Params ->nSamples[i];
if (!io ->Write(io, 16, Dimensions8)) return FALSE;
for (i=0; i < clut ->nEntries; i++) {
-
+
if (!_cmsWriteFloat32Number(io, clut ->Tab.TFloat[i])) return FALSE;
}
// This is the list of built-in MPE types
static _cmsTagTypeLinkedList SupportedMPEtypes[] = {
-{{ (cmsTagTypeSignature) cmsSigBAcsElemType, NULL, NULL, NULL, NULL }, &SupportedMPEtypes[1] }, // Ignore those elements for now
-{{ (cmsTagTypeSignature) cmsSigEAcsElemType, NULL, NULL, NULL, NULL }, &SupportedMPEtypes[2] }, // (That's what the spec says)
+{{ (cmsTagTypeSignature) cmsSigBAcsElemType, NULL, NULL, NULL, NULL, NULL, 0 }, &SupportedMPEtypes[1] }, // Ignore those elements for now
+{{ (cmsTagTypeSignature) cmsSigEAcsElemType, NULL, NULL, NULL, NULL, NULL, 0 }, &SupportedMPEtypes[2] }, // (That's what the spec says)
{TYPE_MPE_HANDLER((cmsTagTypeSignature) cmsSigCurveSetElemType, MPEcurve), &SupportedMPEtypes[3] },
{TYPE_MPE_HANDLER((cmsTagTypeSignature) cmsSigMatrixElemType, MPEmatrix), &SupportedMPEtypes[4] },
{TYPE_MPE_HANDLER((cmsTagTypeSignature) cmsSigCLutElemType, MPEclut), NULL },
};
-#define DEFAULT_MPE_TYPE_COUNT (sizeof(SupportedMPEtypes) / sizeof(_cmsTagTypeLinkedList))
+_cmsTagTypePluginChunkType _cmsMPETypePluginChunk = { NULL };
static
-cmsBool ReadMPEElem(struct _cms_typehandler_struct* self,
+cmsBool ReadMPEElem(struct _cms_typehandler_struct* self,
cmsIOHANDLER* io,
void* Cargo,
- cmsUInt32Number n,
+ cmsUInt32Number n,
cmsUInt32Number SizeOfTag)
{
cmsStageSignature ElementSig;
cmsTagTypeHandler* TypeHandler;
- cmsStage *mpe = NULL;
cmsUInt32Number nItems;
cmsPipeline *NewLUT = (cmsPipeline *) Cargo;
+ _cmsTagTypePluginChunkType* MPETypePluginChunk = ( _cmsTagTypePluginChunkType*) _cmsContextGetClientChunk(self->ContextID, MPEPlugin);
+
// Take signature and channels for each element.
if (!_cmsReadUInt32Number(io, (cmsUInt32Number*) &ElementSig)) return FALSE;
if (!_cmsReadUInt32Number(io, NULL)) return FALSE;
// Read diverse MPE types
- TypeHandler = GetHandler((cmsTagTypeSignature) ElementSig, SupportedMPEtypes);
+ TypeHandler = GetHandler((cmsTagTypeSignature) ElementSig, MPETypePluginChunk ->TagTypes, SupportedMPEtypes);
if (TypeHandler == NULL) {
char String[5];
_cmsTagSignature2String(String, (cmsTagSignature) ElementSig);
- // An unknown element was found.
+ // An unknown element was found.
cmsSignalError(self ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown MPE type '%s' found.", String);
return FALSE;
}
if (TypeHandler ->ReadPtr != NULL) {
// This is a real element which should be read and processed
- mpe = (cmsStage*) TypeHandler ->ReadPtr(self, io, &nItems, SizeOfTag);
- if (mpe == NULL) return FALSE;
-
- // All seems ok, insert element
- cmsPipelineInsertStage(NewLUT, cmsAT_END, mpe);
+ if (!cmsPipelineInsertStage(NewLUT, cmsAT_END, (cmsStage*) TypeHandler ->ReadPtr(self, io, &nItems, SizeOfTag)))
+ return FALSE;
}
return TRUE;
// This is the main dispatcher for MPE
static
void *Type_MPE_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
-{
+{
cmsUInt16Number InputChans, OutputChans;
cmsUInt32Number ElementCount;
cmsPipeline *NewLUT = NULL;
// Read channels and element count
if (!_cmsReadUInt16Number(io, &InputChans)) return NULL;
- if (!_cmsReadUInt16Number(io, &OutputChans)) return NULL;
-
+ if (!_cmsReadUInt16Number(io, &OutputChans)) return NULL;
+
// Allocates an empty LUT
NewLUT = cmsPipelineAlloc(self ->ContextID, InputChans, OutputChans);
if (NewLUT == NULL) return NULL;
// This one is a liitle bit more complex, so we don't use position tables this time.
static
cmsBool Type_MPE_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
-{
+{
cmsUInt32Number i, BaseOffset, DirectoryPos, CurrentPos;
int inputChan, outputChan;
cmsUInt32Number ElemCount;
cmsPipeline* Lut = (cmsPipeline*) Ptr;
cmsStage* Elem = Lut ->Elements;
cmsTagTypeHandler* TypeHandler;
+ _cmsTagTypePluginChunkType* MPETypePluginChunk = ( _cmsTagTypePluginChunkType*) _cmsContextGetClientChunk(self->ContextID, MPEPlugin);
BaseOffset = io ->Tell(io) - sizeof(_cmsTagBase);
outputChan = cmsPipelineOutputChannels(Lut);
ElemCount = cmsPipelineStageCount(Lut);
- ElementOffsets = (cmsUInt32Number *) _cmsCalloc(self ->ContextID, ElemCount, sizeof(cmsUInt32Number *));
+ ElementOffsets = (cmsUInt32Number *) _cmsCalloc(self ->ContextID, ElemCount, sizeof(cmsUInt32Number));
if (ElementOffsets == NULL) goto Error;
- ElementSizes = (cmsUInt32Number *) _cmsCalloc(self ->ContextID, ElemCount, sizeof(cmsUInt32Number *));
+ ElementSizes = (cmsUInt32Number *) _cmsCalloc(self ->ContextID, ElemCount, sizeof(cmsUInt32Number));
if (ElementSizes == NULL) goto Error;
// Write the head
// Write a fake directory to be filled latter on
for (i=0; i < ElemCount; i++) {
- if (!_cmsWriteUInt32Number(io, 0)) goto Error; // Offset
+ if (!_cmsWriteUInt32Number(io, 0)) goto Error; // Offset
if (!_cmsWriteUInt32Number(io, 0)) goto Error; // size
}
ElementSig = Elem ->Type;
- TypeHandler = GetHandler((cmsTagTypeSignature) ElementSig, SupportedMPEtypes);
+ TypeHandler = GetHandler((cmsTagTypeSignature) ElementSig, MPETypePluginChunk->TagTypes, SupportedMPEtypes);
if (TypeHandler == NULL) {
char String[5];
_cmsTagSignature2String(String, (cmsTagSignature) ElementSig);
- // An unknow element was found.
+ // An unknow element was found.
cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Found unknown MPE type '%s'", String);
goto Error;
}
- if (!_cmsWriteUInt32Number(io, ElementSig)) goto Error;
- if (!_cmsWriteUInt32Number(io, 0)) goto Error;
+ if (!_cmsWriteUInt32Number(io, ElementSig)) goto Error;
+ if (!_cmsWriteUInt32Number(io, 0)) goto Error;
Before = io ->Tell(io);
if (!TypeHandler ->WritePtr(self, io, Elem, 1)) goto Error;
if (!_cmsWriteAlignment(io)) goto Error;
if (!io ->Seek(io, DirectoryPos)) goto Error;
for (i=0; i < ElemCount; i++) {
- if (!_cmsWriteUInt32Number(io, ElementOffsets[i])) goto Error;
- if (!_cmsWriteUInt32Number(io, ElementSizes[i])) goto Error;
+ if (!_cmsWriteUInt32Number(io, ElementOffsets[i])) goto Error;
+ if (!_cmsWriteUInt32Number(io, ElementSizes[i])) goto Error;
}
if (!io ->Seek(io, CurrentPos)) goto Error;
static
void Type_MPE_Free(struct _cms_typehandler_struct* self, void *Ptr)
-{
+{
cmsPipelineFree((cmsPipeline*) Ptr);
return;
static
-void *Type_vcgt_Read(struct _cms_typehandler_struct* self,
- cmsIOHANDLER* io,
- cmsUInt32Number* nItems,
+void *Type_vcgt_Read(struct _cms_typehandler_struct* self,
+ cmsIOHANDLER* io,
+ cmsUInt32Number* nItems,
cmsUInt32Number SizeOfTag)
{
cmsUInt32Number TagType, n, i;
// Read tag type
if (!_cmsReadUInt32Number(io, &TagType)) return NULL;
-
+
// Allocate space for the array
Curves = ( cmsToneCurve**) _cmsCalloc(self ->ContextID, 3, sizeof(cmsToneCurve*));
if (Curves == NULL) return NULL;
switch (TagType) {
// Gamma is stored as a table
- case cmsVideoCardGammaTableType:
+ case cmsVideoCardGammaTableType:
{
cmsUInt16Number nChannels, nElems, nBytes;
if (nChannels != 3) {
cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported number of channels for VCGT '%d'", nChannels);
- goto Error;
+ goto Error;
}
// Get Table element count and bytes per element
if (!_cmsReadUInt16Number(io, &nElems)) goto Error;
if (!_cmsReadUInt16Number(io, &nBytes)) goto Error;
-
- // Adobe's quirk fixup. Fixing broken profiles...
- if (nElems == 256 && nBytes == 1 && SizeOfTag == 1576)
- nBytes = 2;
+
+ // Adobe's quirk fixup. Fixing broken profiles...
+ if (nElems == 256 && nBytes == 1 && SizeOfTag == 1576)
+ nBytes = 2;
// Populate tone curves
// Unsupported
default:
cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported bit depth for VCGT '%d'", nBytes * 8);
- goto Error;
+ goto Error;
}
} // For all 3 channels
}
break;
// In this case, gamma is stored as a formula
- case cmsVideoCardGammaFormulaType:
+ case cmsVideoCardGammaFormulaType:
{
_cmsVCGTGAMMA Colorant[3];
-
+
// Populate tone curves
for (n=0; n < 3; n++) {
if (!_cmsRead15Fixed16Number(io, &Colorant[n].Gamma)) goto Error;
if (!_cmsRead15Fixed16Number(io, &Colorant[n].Min)) goto Error;
if (!_cmsRead15Fixed16Number(io, &Colorant[n].Max)) goto Error;
-
+
// Parametric curve type 5 is:
// Y = (aX + b)^Gamma + e | X >= d
// Y = cX + f | X < d
// vcgt formula is:
// Y = (Max \96 Min) * (X ^ Gamma) + Min
-
+
// So, the translation is
- // a = (Max \96 Min) ^ ( 1 / Gamma)
+ // a = (Max \96 Min) ^ ( 1 / Gamma)
// e = Min
// b=c=d=f=0
Params[4] = 0;
Params[5] = Colorant[n].Min;
Params[6] = 0;
-
+
Curves[n] = cmsBuildParametricToneCurve(self ->ContextID, 5, Params);
if (Curves[n] == NULL) goto Error;
}
break;
// Unsupported
- default:
+ default:
cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported tag type for VCGT '%d'", TagType);
goto Error;
}
cmsGetToneCurveParametricType(Curves[1]) == 5 &&
cmsGetToneCurveParametricType(Curves[2]) == 5) {
- if (!_cmsWriteUInt32Number(io, cmsVideoCardGammaFormulaType)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, cmsVideoCardGammaFormulaType)) return FALSE;
// Save parameters
for (i=0; i < 3; i++) {
else {
// Always store as a table of 256 words
- if (!_cmsWriteUInt32Number(io, cmsVideoCardGammaTableType)) return FALSE;
- if (!_cmsWriteUInt16Number(io, 3)) return FALSE;
- if (!_cmsWriteUInt16Number(io, 256)) return FALSE;
- if (!_cmsWriteUInt16Number(io, 2)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, cmsVideoCardGammaTableType)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, 3)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, 256)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, 2)) return FALSE;
for (i=0; i < 3; i++) {
for (j=0; j < 256; j++) {
cmsFloat32Number v = cmsEvalToneCurveFloat(Curves[i], (cmsFloat32Number) (j / 255.0));
cmsUInt16Number n = _cmsQuickSaturateWord(v * 65535.0);
- if (!_cmsWriteUInt16Number(io, n)) return FALSE;
+ if (!_cmsWriteUInt16Number(io, n)) return FALSE;
}
}
}
_cmsFree(self ->ContextID, Ptr);
}
+
+// ********************************************************************************
+// Type cmsSigDictType
+// ********************************************************************************
+
+// Single column of the table can point to wchar or MLUC elements. Holds arrays of data
+typedef struct {
+ cmsContext ContextID;
+ cmsUInt32Number *Offsets;
+ cmsUInt32Number *Sizes;
+} _cmsDICelem;
+
+typedef struct {
+ _cmsDICelem Name, Value, DisplayName, DisplayValue;
+
+} _cmsDICarray;
+
+// Allocate an empty array element
+static
+cmsBool AllocElem(cmsContext ContextID, _cmsDICelem* e, cmsUInt32Number Count)
+{
+ e->Offsets = (cmsUInt32Number *) _cmsCalloc(ContextID, Count, sizeof(cmsUInt32Number));
+ if (e->Offsets == NULL) return FALSE;
+
+ e->Sizes = (cmsUInt32Number *) _cmsCalloc(ContextID, Count, sizeof(cmsUInt32Number));
+ if (e->Sizes == NULL) {
+
+ _cmsFree(ContextID, e -> Offsets);
+ return FALSE;
+ }
+
+ e ->ContextID = ContextID;
+ return TRUE;
+}
+
+// Free an array element
+static
+void FreeElem(_cmsDICelem* e)
+{
+ if (e ->Offsets != NULL) _cmsFree(e -> ContextID, e -> Offsets);
+ if (e ->Sizes != NULL) _cmsFree(e -> ContextID, e -> Sizes);
+ e->Offsets = e ->Sizes = NULL;
+}
+
+// Get rid of whole array
+static
+void FreeArray( _cmsDICarray* a)
+{
+ if (a ->Name.Offsets != NULL) FreeElem(&a->Name);
+ if (a ->Value.Offsets != NULL) FreeElem(&a ->Value);
+ if (a ->DisplayName.Offsets != NULL) FreeElem(&a->DisplayName);
+ if (a ->DisplayValue.Offsets != NULL) FreeElem(&a ->DisplayValue);
+}
+
+
+// Allocate whole array
+static
+cmsBool AllocArray(cmsContext ContextID, _cmsDICarray* a, cmsUInt32Number Count, cmsUInt32Number Length)
+{
+ // Empty values
+ memset(a, 0, sizeof(_cmsDICarray));
+
+ // On depending on record size, create column arrays
+ if (!AllocElem(ContextID, &a ->Name, Count)) goto Error;
+ if (!AllocElem(ContextID, &a ->Value, Count)) goto Error;
+
+ if (Length > 16) {
+ if (!AllocElem(ContextID, &a -> DisplayName, Count)) goto Error;
+
+ }
+ if (Length > 24) {
+ if (!AllocElem(ContextID, &a ->DisplayValue, Count)) goto Error;
+ }
+ return TRUE;
+
+Error:
+ FreeArray(a);
+ return FALSE;
+}
+
+// Read one element
+static
+cmsBool ReadOneElem(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, cmsUInt32Number BaseOffset)
+{
+ if (!_cmsReadUInt32Number(io, &e->Offsets[i])) return FALSE;
+ if (!_cmsReadUInt32Number(io, &e ->Sizes[i])) return FALSE;
+
+ // An offset of zero has special meaning and shal be preserved
+ if (e ->Offsets[i] > 0)
+ e ->Offsets[i] += BaseOffset;
+ return TRUE;
+}
+
+
+static
+cmsBool ReadOffsetArray(cmsIOHANDLER* io, _cmsDICarray* a, cmsUInt32Number Count, cmsUInt32Number Length, cmsUInt32Number BaseOffset)
+{
+ cmsUInt32Number i;
+
+ // Read column arrays
+ for (i=0; i < Count; i++) {
+
+ if (!ReadOneElem(io, &a -> Name, i, BaseOffset)) return FALSE;
+ if (!ReadOneElem(io, &a -> Value, i, BaseOffset)) return FALSE;
+
+ if (Length > 16) {
+
+ if (!ReadOneElem(io, &a ->DisplayName, i, BaseOffset)) return FALSE;
+
+ }
+
+ if (Length > 24) {
+
+ if (!ReadOneElem(io, & a -> DisplayValue, i, BaseOffset)) return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+
+// Write one element
+static
+cmsBool WriteOneElem(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i)
+{
+ if (!_cmsWriteUInt32Number(io, e->Offsets[i])) return FALSE;
+ if (!_cmsWriteUInt32Number(io, e ->Sizes[i])) return FALSE;
+
+ return TRUE;
+}
+
+static
+cmsBool WriteOffsetArray(cmsIOHANDLER* io, _cmsDICarray* a, cmsUInt32Number Count, cmsUInt32Number Length)
+{
+ cmsUInt32Number i;
+
+ for (i=0; i < Count; i++) {
+
+ if (!WriteOneElem(io, &a -> Name, i)) return FALSE;
+ if (!WriteOneElem(io, &a -> Value, i)) return FALSE;
+
+ if (Length > 16) {
+
+ if (!WriteOneElem(io, &a -> DisplayName, i)) return FALSE;
+ }
+
+ if (Length > 24) {
+
+ if (!WriteOneElem(io, &a -> DisplayValue, i)) return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+static
+cmsBool ReadOneWChar(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, wchar_t ** wcstr)
+{
+
+ cmsUInt32Number nChars;
+
+ // Special case for undefined strings (see ICC Votable
+ // Proposal Submission, Dictionary Type and Metadata TAG Definition)
+ if (e -> Offsets[i] == 0) {
+
+ *wcstr = NULL;
+ return TRUE;
+ }
+
+ if (!io -> Seek(io, e -> Offsets[i])) return FALSE;
+
+ nChars = e ->Sizes[i] / sizeof(cmsUInt16Number);
+
+
+ *wcstr = (wchar_t*) _cmsMallocZero(e ->ContextID, (nChars + 1) * sizeof(wchar_t));
+ if (*wcstr == NULL) return FALSE;
+
+ if (!_cmsReadWCharArray(io, nChars, *wcstr)) {
+ _cmsFree(e ->ContextID, *wcstr);
+ return FALSE;
+ }
+
+ // End of string marker
+ (*wcstr)[nChars] = 0;
+ return TRUE;
+}
+
+static
+cmsUInt32Number mywcslen(const wchar_t *s)
+{
+ const wchar_t *p;
+
+ p = s;
+ while (*p)
+ p++;
+
+ return (cmsUInt32Number)(p - s);
+}
+
+static
+cmsBool WriteOneWChar(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, const wchar_t * wcstr, cmsUInt32Number BaseOffset)
+{
+ cmsUInt32Number Before = io ->Tell(io);
+ cmsUInt32Number n;
+
+ e ->Offsets[i] = Before - BaseOffset;
+
+ if (wcstr == NULL) {
+ e ->Sizes[i] = 0;
+ e ->Offsets[i] = 0;
+ return TRUE;
+ }
+
+ n = mywcslen(wcstr);
+ if (!_cmsWriteWCharArray(io, n, wcstr)) return FALSE;
+
+ e ->Sizes[i] = io ->Tell(io) - Before;
+ return TRUE;
+}
+
+static
+cmsBool ReadOneMLUC(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, cmsMLU** mlu)
+{
+ cmsUInt32Number nItems = 0;
+
+ // A way to get null MLUCs
+ if (e -> Offsets[i] == 0 || e ->Sizes[i] == 0) {
+
+ *mlu = NULL;
+ return TRUE;
+ }
+
+ if (!io -> Seek(io, e -> Offsets[i])) return FALSE;
+
+ *mlu = (cmsMLU*) Type_MLU_Read(self, io, &nItems, e ->Sizes[i]);
+ return *mlu != NULL;
+}
+
+static
+cmsBool WriteOneMLUC(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, const cmsMLU* mlu, cmsUInt32Number BaseOffset)
+{
+ cmsUInt32Number Before;
+
+ // Special case for undefined strings (see ICC Votable
+ // Proposal Submission, Dictionary Type and Metadata TAG Definition)
+ if (mlu == NULL) {
+ e ->Sizes[i] = 0;
+ e ->Offsets[i] = 0;
+ return TRUE;
+ }
+
+ Before = io ->Tell(io);
+ e ->Offsets[i] = Before - BaseOffset;
+
+ if (!Type_MLU_Write(self, io, (void*) mlu, 1)) return FALSE;
+
+ e ->Sizes[i] = io ->Tell(io) - Before;
+ return TRUE;
+}
+
+
+static
+void *Type_Dictionary_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)
+{
+ cmsHANDLE hDict;
+ cmsUInt32Number i, Count, Length;
+ cmsUInt32Number BaseOffset;
+ _cmsDICarray a;
+ wchar_t *NameWCS = NULL, *ValueWCS = NULL;
+ cmsMLU *DisplayNameMLU = NULL, *DisplayValueMLU=NULL;
+ cmsBool rc;
+
+ *nItems = 0;
+
+ // Get actual position as a basis for element offsets
+ BaseOffset = io ->Tell(io) - sizeof(_cmsTagBase);
+
+ // Get name-value record count
+ if (!_cmsReadUInt32Number(io, &Count)) return NULL;
+ SizeOfTag -= sizeof(cmsUInt32Number);
+
+ // Get rec length
+ if (!_cmsReadUInt32Number(io, &Length)) return NULL;
+ SizeOfTag -= sizeof(cmsUInt32Number);
+
+ // Check for valid lengths
+ if (Length != 16 && Length != 24 && Length != 32) {
+ cmsSignalError(self->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown record length in dictionary '%d'", Length);
+ return NULL;
+ }
+
+ // Creates an empty dictionary
+ hDict = cmsDictAlloc(self -> ContextID);
+ if (hDict == NULL) return NULL;
+
+ // On depending on record size, create column arrays
+ if (!AllocArray(self -> ContextID, &a, Count, Length)) goto Error;
+
+ // Read column arrays
+ if (!ReadOffsetArray(io, &a, Count, Length, BaseOffset)) goto Error;
+
+ // Seek to each element and read it
+ for (i=0; i < Count; i++) {
+
+ if (!ReadOneWChar(io, &a.Name, i, &NameWCS)) goto Error;
+ if (!ReadOneWChar(io, &a.Value, i, &ValueWCS)) goto Error;
+
+ if (Length > 16) {
+ if (!ReadOneMLUC(self, io, &a.DisplayName, i, &DisplayNameMLU)) goto Error;
+ }
+
+ if (Length > 24) {
+ if (!ReadOneMLUC(self, io, &a.DisplayValue, i, &DisplayValueMLU)) goto Error;
+ }
+
+ if (NameWCS == NULL || ValueWCS == NULL) {
+
+ cmsSignalError(self->ContextID, cmsERROR_CORRUPTION_DETECTED, "Bad dictionary Name/Value");
+ rc = FALSE;
+ }
+ else {
+
+ rc = cmsDictAddEntry(hDict, NameWCS, ValueWCS, DisplayNameMLU, DisplayValueMLU);
+ }
+
+ if (NameWCS != NULL) _cmsFree(self ->ContextID, NameWCS);
+ if (ValueWCS != NULL) _cmsFree(self ->ContextID, ValueWCS);
+ if (DisplayNameMLU != NULL) cmsMLUfree(DisplayNameMLU);
+ if (DisplayValueMLU != NULL) cmsMLUfree(DisplayValueMLU);
+
+ if (!rc) goto Error;
+ }
+
+ FreeArray(&a);
+ *nItems = 1;
+ return (void*) hDict;
+
+Error:
+ FreeArray(&a);
+ cmsDictFree(hDict);
+ return NULL;
+}
+
+
+static
+cmsBool Type_Dictionary_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
+{
+ cmsHANDLE hDict = (cmsHANDLE) Ptr;
+ const cmsDICTentry* p;
+ cmsBool AnyName, AnyValue;
+ cmsUInt32Number i, Count, Length;
+ cmsUInt32Number DirectoryPos, CurrentPos, BaseOffset;
+ _cmsDICarray a;
+
+ if (hDict == NULL) return FALSE;
+
+ BaseOffset = io ->Tell(io) - sizeof(_cmsTagBase);
+
+ // Let's inspect the dictionary
+ Count = 0; AnyName = FALSE; AnyValue = FALSE;
+ for (p = cmsDictGetEntryList(hDict); p != NULL; p = cmsDictNextEntry(p)) {
+
+ if (p ->DisplayName != NULL) AnyName = TRUE;
+ if (p ->DisplayValue != NULL) AnyValue = TRUE;
+ Count++;
+ }
+
+ Length = 16;
+ if (AnyName) Length += 8;
+ if (AnyValue) Length += 8;
+
+ if (!_cmsWriteUInt32Number(io, Count)) return FALSE;
+ if (!_cmsWriteUInt32Number(io, Length)) return FALSE;
+
+ // Keep starting position of offsets table
+ DirectoryPos = io ->Tell(io);
+
+ // Allocate offsets array
+ if (!AllocArray(self ->ContextID, &a, Count, Length)) goto Error;
+
+ // Write a fake directory to be filled latter on
+ if (!WriteOffsetArray(io, &a, Count, Length)) goto Error;
+
+ // Write each element. Keep track of the size as well.
+ p = cmsDictGetEntryList(hDict);
+ for (i=0; i < Count; i++) {
+
+ if (!WriteOneWChar(io, &a.Name, i, p ->Name, BaseOffset)) goto Error;
+ if (!WriteOneWChar(io, &a.Value, i, p ->Value, BaseOffset)) goto Error;
+
+ if (p ->DisplayName != NULL) {
+ if (!WriteOneMLUC(self, io, &a.DisplayName, i, p ->DisplayName, BaseOffset)) goto Error;
+ }
+
+ if (p ->DisplayValue != NULL) {
+ if (!WriteOneMLUC(self, io, &a.DisplayValue, i, p ->DisplayValue, BaseOffset)) goto Error;
+ }
+
+ p = cmsDictNextEntry(p);
+ }
+
+ // Write the directory
+ CurrentPos = io ->Tell(io);
+ if (!io ->Seek(io, DirectoryPos)) goto Error;
+
+ if (!WriteOffsetArray(io, &a, Count, Length)) goto Error;
+
+ if (!io ->Seek(io, CurrentPos)) goto Error;
+
+ FreeArray(&a);
+ return TRUE;
+
+Error:
+ FreeArray(&a);
+ return FALSE;
+
+ cmsUNUSED_PARAMETER(nItems);
+}
+
+
+static
+void* Type_Dictionary_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n)
+{
+ return (void*) cmsDictDup((cmsHANDLE) Ptr);
+
+ cmsUNUSED_PARAMETER(n);
+ cmsUNUSED_PARAMETER(self);
+}
+
+
+static
+void Type_Dictionary_Free(struct _cms_typehandler_struct* self, void* Ptr)
+{
+ cmsDictFree((cmsHANDLE) Ptr);
+ cmsUNUSED_PARAMETER(self);
+}
+
+
// ********************************************************************************
// Type support main routines
// ********************************************************************************
{TYPE_HANDLER(cmsCorbisBrokenXYZtype, XYZ), &SupportedTagTypes[27] },
{TYPE_HANDLER(cmsMonacoBrokenCurveType, Curve), &SupportedTagTypes[28] },
{TYPE_HANDLER(cmsSigProfileSequenceIdType, ProfileSequenceId), &SupportedTagTypes[29] },
+{TYPE_HANDLER(cmsSigDictType, Dictionary), &SupportedTagTypes[30] },
{TYPE_HANDLER(cmsSigVcgtType, vcgt), NULL }
};
-#define DEFAULT_TAG_TYPE_COUNT (sizeof(SupportedTagTypes) / sizeof(_cmsTagTypeLinkedList))
-
+
+_cmsTagTypePluginChunkType _cmsTagTypePluginChunk = { NULL };
+
+
+
+// Duplicates the zone of memory used by the plug-in in the new context
+static
+void DupTagTypeList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src,
+ int loc)
+{
+ _cmsTagTypePluginChunkType newHead = { NULL };
+ _cmsTagTypeLinkedList* entry;
+ _cmsTagTypeLinkedList* Anterior = NULL;
+ _cmsTagTypePluginChunkType* head = (_cmsTagTypePluginChunkType*) src->chunks[loc];
+
+ // Walk the list copying all nodes
+ for (entry = head->TagTypes;
+ entry != NULL;
+ entry = entry ->Next) {
+
+ _cmsTagTypeLinkedList *newEntry = ( _cmsTagTypeLinkedList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(_cmsTagTypeLinkedList));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.TagTypes == NULL)
+ newHead.TagTypes = newEntry;
+ }
+
+ ctx ->chunks[loc] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsTagTypePluginChunkType));
+}
+
+
+void _cmsAllocTagTypePluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ if (src != NULL) {
+
+ // Duplicate the LIST
+ DupTagTypeList(ctx, src, TagTypePlugin);
+ }
+ else {
+ static _cmsTagTypePluginChunkType TagTypePluginChunk = { NULL };
+ ctx ->chunks[TagTypePlugin] = _cmsSubAllocDup(ctx ->MemPool, &TagTypePluginChunk, sizeof(_cmsTagTypePluginChunkType));
+ }
+}
+
+void _cmsAllocMPETypePluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ if (src != NULL) {
+
+ // Duplicate the LIST
+ DupTagTypeList(ctx, src, MPEPlugin);
+ }
+ else {
+ static _cmsTagTypePluginChunkType TagTypePluginChunk = { NULL };
+ ctx ->chunks[MPEPlugin] = _cmsSubAllocDup(ctx ->MemPool, &TagTypePluginChunk, sizeof(_cmsTagTypePluginChunkType));
+ }
+
+}
+
+
// Both kind of plug-ins share same structure
-cmsBool _cmsRegisterTagTypePlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterTagTypePlugin(cmsContext id, cmsPluginBase* Data)
{
- return RegisterTypesPlugin(Data, SupportedTagTypes, DEFAULT_TAG_TYPE_COUNT);
+ return RegisterTypesPlugin(id, Data, TagTypePlugin);
}
-cmsBool _cmsRegisterMultiProcessElementPlugin(cmsPluginBase* Data)
+cmsBool _cmsRegisterMultiProcessElementPlugin(cmsContext id, cmsPluginBase* Data)
{
- return RegisterTypesPlugin(Data, SupportedMPEtypes, DEFAULT_MPE_TYPE_COUNT);
+ return RegisterTypesPlugin(id, Data,MPEPlugin);
}
// Wrapper for tag types
-cmsTagTypeHandler* _cmsGetTagTypeHandler(cmsTagTypeSignature sig)
+cmsTagTypeHandler* _cmsGetTagTypeHandler(cmsContext ContextID, cmsTagTypeSignature sig)
{
- return GetHandler(sig, SupportedTagTypes);
+ _cmsTagTypePluginChunkType* ctx = ( _cmsTagTypePluginChunkType*) _cmsContextGetClientChunk(ContextID, TagTypePlugin);
+
+ return GetHandler(sig, ctx->TagTypes, SupportedTagTypes);
}
-
+
// ********************************************************************************
// Tag support main routines
// ********************************************************************************
// This is the list of built-in tags
static _cmsTagLinkedList SupportedTags[] = {
- { cmsSigAToB0Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutAtoBType, cmsSigLut8Type}, DecideLUTtypeA2B}, &SupportedTags[1]},
+ { cmsSigAToB0Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutAtoBType, cmsSigLut8Type}, DecideLUTtypeA2B}, &SupportedTags[1]},
{ cmsSigAToB1Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutAtoBType, cmsSigLut8Type}, DecideLUTtypeA2B}, &SupportedTags[2]},
{ cmsSigAToB2Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutAtoBType, cmsSigLut8Type}, DecideLUTtypeA2B}, &SupportedTags[3]},
{ cmsSigBToA0Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutBtoAType, cmsSigLut8Type}, DecideLUTtypeB2A}, &SupportedTags[4]},
{ cmsSigBToA1Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutBtoAType, cmsSigLut8Type}, DecideLUTtypeB2A}, &SupportedTags[5]},
{ cmsSigBToA2Tag, { 1, 3, { cmsSigLut16Type, cmsSigLutBtoAType, cmsSigLut8Type}, DecideLUTtypeB2A}, &SupportedTags[6]},
-
+
// Allow corbis and its broken XYZ type
{ cmsSigRedColorantTag, { 1, 2, { cmsSigXYZType, cmsCorbisBrokenXYZtype }, DecideXYZtype}, &SupportedTags[7]},
{ cmsSigGreenColorantTag, { 1, 2, { cmsSigXYZType, cmsCorbisBrokenXYZtype }, DecideXYZtype}, &SupportedTags[8]},
{ cmsSigBlueColorantTag, { 1, 2, { cmsSigXYZType, cmsCorbisBrokenXYZtype }, DecideXYZtype}, &SupportedTags[9]},
-
+
{ cmsSigRedTRCTag, { 1, 3, { cmsSigCurveType, cmsSigParametricCurveType, cmsMonacoBrokenCurveType }, DecideCurveType}, &SupportedTags[10]},
{ cmsSigGreenTRCTag, { 1, 3, { cmsSigCurveType, cmsSigParametricCurveType, cmsMonacoBrokenCurveType }, DecideCurveType}, &SupportedTags[11]},
- { cmsSigBlueTRCTag, { 1, 3, { cmsSigCurveType, cmsSigParametricCurveType, cmsMonacoBrokenCurveType }, DecideCurveType}, &SupportedTags[12]},
+ { cmsSigBlueTRCTag, { 1, 3, { cmsSigCurveType, cmsSigParametricCurveType, cmsMonacoBrokenCurveType }, DecideCurveType}, &SupportedTags[12]},
{ cmsSigCalibrationDateTimeTag, { 1, 1, { cmsSigDateTimeType }, NULL}, &SupportedTags[13]},
{ cmsSigCharTargetTag, { 1, 1, { cmsSigTextType }, NULL}, &SupportedTags[14]},
{ cmsSigMeasurementTag, { 1, 1, { cmsSigMeasurementType }, NULL}, &SupportedTags[39]},
- { cmsSigPs2CRD0Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[40]},
- { cmsSigPs2CRD1Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[41]},
- { cmsSigPs2CRD2Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[42]},
- { cmsSigPs2CRD3Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[43]},
- { cmsSigPs2CSATag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[44]},
- { cmsSigPs2RenderingIntentTag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[45]},
+ { cmsSigPs2CRD0Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[40]},
+ { cmsSigPs2CRD1Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[41]},
+ { cmsSigPs2CRD2Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[42]},
+ { cmsSigPs2CRD3Tag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[43]},
+ { cmsSigPs2CSATag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[44]},
+ { cmsSigPs2RenderingIntentTag, { 1, 1, { cmsSigDataType }, NULL}, &SupportedTags[45]},
{ cmsSigViewingCondDescTag, { 1, 3, { cmsSigTextDescriptionType, cmsSigMultiLocalizedUnicodeType, cmsSigTextType}, DecideTextDescType}, &SupportedTags[46]},
- { cmsSigUcrBgTag, { 1, 1, { cmsSigUcrBgType}, NULL}, &SupportedTags[47]},
- { cmsSigCrdInfoTag, { 1, 1, { cmsSigCrdInfoType}, NULL}, &SupportedTags[48]},
-
- { cmsSigDToB0Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[49]},
- { cmsSigDToB1Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[50]},
- { cmsSigDToB2Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[51]},
- { cmsSigDToB3Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[52]},
- { cmsSigBToD0Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[53]},
- { cmsSigBToD1Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[54]},
- { cmsSigBToD2Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[55]},
- { cmsSigBToD3Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[56]},
-
- { cmsSigScreeningDescTag, { 1, 1, { cmsSigTextDescriptionType }, NULL}, &SupportedTags[57]},
- { cmsSigViewingConditionsTag, { 1, 1, { cmsSigViewingConditionsType }, NULL}, &SupportedTags[58]},
+ { cmsSigUcrBgTag, { 1, 1, { cmsSigUcrBgType}, NULL}, &SupportedTags[47]},
+ { cmsSigCrdInfoTag, { 1, 1, { cmsSigCrdInfoType}, NULL}, &SupportedTags[48]},
+
+ { cmsSigDToB0Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[49]},
+ { cmsSigDToB1Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[50]},
+ { cmsSigDToB2Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[51]},
+ { cmsSigDToB3Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[52]},
+ { cmsSigBToD0Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[53]},
+ { cmsSigBToD1Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[54]},
+ { cmsSigBToD2Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[55]},
+ { cmsSigBToD3Tag, { 1, 1, { cmsSigMultiProcessElementType}, NULL}, &SupportedTags[56]},
+
+ { cmsSigScreeningDescTag, { 1, 1, { cmsSigTextDescriptionType }, NULL}, &SupportedTags[57]},
+ { cmsSigViewingConditionsTag, { 1, 1, { cmsSigViewingConditionsType }, NULL}, &SupportedTags[58]},
+
+ { cmsSigScreeningTag, { 1, 1, { cmsSigScreeningType}, NULL }, &SupportedTags[59]},
+ { cmsSigVcgtTag, { 1, 1, { cmsSigVcgtType}, NULL }, &SupportedTags[60]},
+ { cmsSigMetaTag, { 1, 1, { cmsSigDictType}, NULL }, &SupportedTags[61]},
+ { cmsSigProfileSequenceIdTag, { 1, 1, { cmsSigProfileSequenceIdType}, NULL }, &SupportedTags[62]},
+ { cmsSigProfileDescriptionMLTag,{ 1, 1, { cmsSigMultiLocalizedUnicodeType}, NULL}, NULL}
- { cmsSigScreeningTag, { 1, 1, { cmsSigScreeningType}, NULL }, &SupportedTags[59]},
- { cmsSigVcgtTag, { 1, 1, { cmsSigVcgtType}, NULL }, &SupportedTags[60]},
- { cmsSigProfileSequenceIdTag, { 1, 1, { cmsSigProfileSequenceIdType}, NULL}, NULL}
};
/*
Not supported Why
- ======================= =========================================
- cmsSigOutputResponseTag ==> WARNING, POSSIBLE PATENT ON THIS SUBJECT!
- cmsSigNamedColorTag ==> Deprecated
- cmsSigDataTag ==> Ancient, unused
- cmsSigDeviceSettingsTag ==> Deprecated, useless
-*/
+ ======================= =========================================
+ cmsSigOutputResponseTag ==> WARNING, POSSIBLE PATENT ON THIS SUBJECT!
+ cmsSigNamedColorTag ==> Deprecated
+ cmsSigDataTag ==> Ancient, unused
+ cmsSigDeviceSettingsTag ==> Deprecated, useless
+*/
+
-#define DEFAULT_TAG_COUNT (sizeof(SupportedTags) / sizeof(_cmsTagLinkedList))
+_cmsTagPluginChunkType _cmsTagPluginChunk = { NULL };
-cmsBool _cmsRegisterTagPlugin(cmsPluginBase* Data)
+
+// Duplicates the zone of memory used by the plug-in in the new context
+static
+void DupTagList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
{
- cmsPluginTag* Plugin = (cmsPluginTag*) Data;
- _cmsTagLinkedList *pt, *Anterior;
+ _cmsTagPluginChunkType newHead = { NULL };
+ _cmsTagLinkedList* entry;
+ _cmsTagLinkedList* Anterior = NULL;
+ _cmsTagPluginChunkType* head = (_cmsTagPluginChunkType*) src->chunks[TagPlugin];
+ // Walk the list copying all nodes
+ for (entry = head->Tag;
+ entry != NULL;
+ entry = entry ->Next) {
- if (Data == NULL) {
-
- SupportedTags[DEFAULT_TAG_COUNT-1].Next = NULL;
- return TRUE;
+ _cmsTagLinkedList *newEntry = ( _cmsTagLinkedList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(_cmsTagLinkedList));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.Tag == NULL)
+ newHead.Tag = newEntry;
+ }
+
+ ctx ->chunks[TagPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsTagPluginChunkType));
+}
+
+void _cmsAllocTagPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ if (src != NULL) {
+
+ DupTagList(ctx, src);
+ }
+ else {
+ static _cmsTagPluginChunkType TagPluginChunk = { NULL };
+ ctx ->chunks[TagPlugin] = _cmsSubAllocDup(ctx ->MemPool, &TagPluginChunk, sizeof(_cmsTagPluginChunkType));
}
- pt = Anterior = SupportedTags;
- while (pt != NULL) {
+}
- if (Plugin->Signature == pt -> Signature) {
- pt ->Descriptor = Plugin ->Descriptor; // Replace old behaviour
- return TRUE;
- }
+cmsBool _cmsRegisterTagPlugin(cmsContext id, cmsPluginBase* Data)
+{
+ cmsPluginTag* Plugin = (cmsPluginTag*) Data;
+ _cmsTagLinkedList *pt;
+ _cmsTagPluginChunkType* TagPluginChunk = ( _cmsTagPluginChunkType*) _cmsContextGetClientChunk(id, TagPlugin);
+
+ if (Data == NULL) {
- Anterior = pt;
- pt = pt ->Next;
+ TagPluginChunk->Tag = NULL;
+ return TRUE;
}
- pt = (_cmsTagLinkedList*) _cmsPluginMalloc(sizeof(_cmsTagLinkedList));
+ pt = (_cmsTagLinkedList*) _cmsPluginMalloc(id, sizeof(_cmsTagLinkedList));
if (pt == NULL) return FALSE;
pt ->Signature = Plugin ->Signature;
- pt ->Descriptor = Plugin ->Descriptor;
- pt ->Next = NULL;
-
- if (Anterior != NULL) Anterior -> Next = pt;
+ pt ->Descriptor = Plugin ->Descriptor;
+ pt ->Next = TagPluginChunk ->Tag;
+ TagPluginChunk ->Tag = pt;
+
return TRUE;
}
// Return a descriptor for a given tag or NULL
-cmsTagDescriptor* _cmsGetTagDescriptor(cmsTagSignature sig)
+cmsTagDescriptor* _cmsGetTagDescriptor(cmsContext ContextID, cmsTagSignature sig)
{
_cmsTagLinkedList* pt;
+ _cmsTagPluginChunkType* TagPluginChunk = ( _cmsTagPluginChunkType*) _cmsContextGetClientChunk(ContextID, TagPlugin);
+
+ for (pt = TagPluginChunk->Tag;
+ pt != NULL;
+ pt = pt ->Next) {
+
+ if (sig == pt -> Signature) return &pt ->Descriptor;
+ }
- for (pt = SupportedTags;
+ for (pt = SupportedTags;
pt != NULL;
pt = pt ->Next) {
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2014 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
cmsMLU *DescriptionMLU, *CopyrightMLU;
cmsBool rc = FALSE;
cmsContext ContextID = cmsGetProfileContextID(hProfile);
-
+
DescriptionMLU = cmsMLUalloc(ContextID, 1);
CopyrightMLU = cmsMLUalloc(ContextID, 1);
if (!cmsMLUsetWide(CopyrightMLU, "en", "US", L"No copyright, use freely")) goto Error;
if (!cmsWriteTag(hProfile, cmsSigProfileDescriptionTag, DescriptionMLU)) goto Error;
- if (!cmsWriteTag(hProfile, cmsSigCopyrightTag, CopyrightMLU)) goto Error;
-
+ if (!cmsWriteTag(hProfile, cmsSigCopyrightTag, CopyrightMLU)) goto Error;
+
rc = TRUE;
Error:
cmsMLUfree(CopyrightMLU);
return rc;
}
-
+
static
cmsBool SetSeqDescTag(cmsHPROFILE hProfile, const char* Model)
Seq->seq[0].deviceModel = (cmsSignature) 0;
#ifdef CMS_DONT_USE_INT64
- Seq->seq[0].attributes[0] = 0;
- Seq->seq[0].attributes[1] = 0;
+ Seq->seq[0].attributes[0] = 0;
+ Seq->seq[0].attributes[1] = 0;
#else
- Seq->seq[0].attributes = 0;
+ Seq->seq[0].attributes = 0;
#endif
Seq->seq[0].technology = (cmsTechnologySignature) 0;
cmsMLUsetASCII( Seq->seq[0].Model, cmsNoLanguage, cmsNoCountry, Model);
if (!_cmsWriteProfileSequence(hProfile, Seq)) goto Error;
-
+
rc = TRUE;
Error:
- if (Seq)
+ if (Seq)
cmsFreeProfileSequenceDescription(Seq);
return rc;
const cmsCIExyYTRIPLE* Primaries,
cmsToneCurve* const TransferFunction[3])
{
- cmsHPROFILE hICC;
+ cmsHPROFILE hICC;
cmsMAT3 MColorants;
cmsCIEXYZTRIPLE Colorants;
cmsCIExyY MaxWhite;
if (!hICC) // can't allocate
return NULL;
- cmsSetProfileVersion(hICC, 4.2);
+ cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigDisplayClass);
cmsSetColorSpace(hICC, cmsSigRgbData);
cmsSetPCS(hICC, cmsSigXYZData);
- cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
+ cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Implement profile using following tags:
// This conforms a standard RGB DisplayProfile as says ICC, and then I add (As per addendum II)
// 10 cmsSigChromaticityTag
-
+
if (!SetTextTags(hICC, L"RGB built-in")) goto Error;
if (WhitePoint) {
if (!cmsWriteTag(hICC, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error;
cmsxyY2XYZ(&WhitePointXYZ, WhitePoint);
- _cmsAdaptationMatrix(&CHAD, NULL, &WhitePointXYZ, cmsD50_XYZ());
+ _cmsAdaptationMatrix(&CHAD, NULL, &WhitePointXYZ, cmsD50_XYZ());
- // This is a V4 tag, but many CMM does read and understand it no matter which version
+ // This is a V4 tag, but many CMM does read and understand it no matter which version
if (!cmsWriteTag(hICC, cmsSigChromaticAdaptationTag, (void*) &CHAD)) goto Error;
}
MaxWhite.y = WhitePoint -> y;
MaxWhite.Y = 1.0;
- if (!_cmsBuildRGB2XYZtransferMatrix(&MColorants, &MaxWhite, Primaries)) goto Error;
-
+ if (!_cmsBuildRGB2XYZtransferMatrix(&MColorants, &MaxWhite, Primaries)) goto Error;
+
Colorants.Red.X = MColorants.v[0].n[0];
Colorants.Red.Y = MColorants.v[1].n[0];
Colorants.Red.Z = MColorants.v[2].n[0];
if (TransferFunction) {
-
+
+ // Tries to minimize space. Thanks to Richard Hughes for this nice idea
if (!cmsWriteTag(hICC, cmsSigRedTRCTag, (void*) TransferFunction[0])) goto Error;
- if (!cmsWriteTag(hICC, cmsSigGreenTRCTag, (void*) TransferFunction[1])) goto Error;
- if (!cmsWriteTag(hICC, cmsSigBlueTRCTag, (void*) TransferFunction[2])) goto Error;
+
+ if (TransferFunction[1] == TransferFunction[0]) {
+
+ if (!cmsLinkTag (hICC, cmsSigGreenTRCTag, cmsSigRedTRCTag)) goto Error;
+
+ } else {
+
+ if (!cmsWriteTag(hICC, cmsSigGreenTRCTag, (void*) TransferFunction[1])) goto Error;
+ }
+
+ if (TransferFunction[2] == TransferFunction[0]) {
+
+ if (!cmsLinkTag (hICC, cmsSigBlueTRCTag, cmsSigRedTRCTag)) goto Error;
+
+ } else {
+
+ if (!cmsWriteTag(hICC, cmsSigBlueTRCTag, (void*) TransferFunction[2])) goto Error;
+ }
}
if (Primaries) {
const cmsToneCurve* TransferFunction)
{
cmsHPROFILE hICC;
- cmsCIEXYZ tmp;
+ cmsCIEXYZ tmp;
hICC = cmsCreateProfilePlaceholder(ContextID);
if (!hICC) // can't allocate
return NULL;
- cmsSetProfileVersion(hICC, 4.2);
+ cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigDisplayClass);
cmsSetColorSpace(hICC, cmsSigGrayData);
cmsSetPCS(hICC, cmsSigXYZData);
- cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
+ cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Implement profile using following tags:
// 2 cmsSigMediaWhitePointTag
// 3 cmsSigGrayTRCTag
- // This conforms a standard Gray DisplayProfile
+ // This conforms a standard Gray DisplayProfile
// Fill-in the tags
{
cmsHPROFILE hICC;
cmsPipeline* Pipeline;
- cmsStage* Lin;
int nChannels;
hICC = cmsCreateProfilePlaceholder(ContextID);
- if (!hICC)
+ if (!hICC)
return NULL;
- cmsSetProfileVersion(hICC, 4.2);
+ cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigLinkClass);
cmsSetColorSpace(hICC, ColorSpace);
cmsSetPCS(hICC, ColorSpace);
- cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
+ cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Set up channels
nChannels = cmsChannelsOf(ColorSpace);
// Copy tables to Pipeline
- Lin = cmsStageAllocToneCurves(ContextID, nChannels, TransferFunctions);
- if (Lin == NULL) goto Error;
-
- cmsPipelineInsertStage(Pipeline, cmsAT_BEGIN, Lin);
+ if (!cmsPipelineInsertStage(Pipeline, cmsAT_BEGIN, cmsStageAllocToneCurves(ContextID, nChannels, TransferFunctions)))
+ goto Error;
- // Create tags
- if (!SetTextTags(hICC, L"Linearization built-in")) goto Error;
- if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline)) goto Error;
+ // Create tags
+ if (!SetTextTags(hICC, L"Linearization built-in")) goto Error;
+ if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline)) goto Error;
if (!SetSeqDescTag(hICC, "Linearization built-in")) goto Error;
// Pipeline is already on virtual profile
return hICC;
Error:
+ cmsPipelineFree(Pipeline);
if (hICC)
cmsCloseProfile(hICC);
// Ink-limiting algorithm
//
-// Sum = C + M + Y + K
-// If Sum > InkLimit
+// Sum = C + M + Y + K
+// If Sum > InkLimit
// Ratio= 1 - (Sum - InkLimit) / (C + M + Y)
-// if Ratio <0
+// if Ratio <0
// Ratio=0
-// endif
-// Else
+// endif
+// Else
// Ratio=1
// endif
//
InkLimit = (InkLimit * 655.35);
SumCMY = In[0] + In[1] + In[2];
- SumCMYK = SumCMY + In[3];
+ SumCMYK = SumCMY + In[3];
if (SumCMYK > InkLimit) {
// This is a devicelink operating in CMYK for ink-limiting
-cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID,
+cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID,
cmsColorSpaceSignature ColorSpace,
cmsFloat64Number Limit)
{
cmsPipeline* LUT;
cmsStage* CLUT;
int nChannels;
-
+
if (ColorSpace != cmsSigCmykData) {
cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "InkLimiting: Only CMYK currently supported");
return NULL;
if (Limit < 0.0 || Limit > 400) {
- cmsSignalError(ContextID, cmsERROR_RANGE, "InkLimiting: Limit should be between 0..400");
+ cmsSignalError(ContextID, cmsERROR_RANGE, "InkLimiting: Limit should be between 0..400");
if (Limit < 0) Limit = 0;
if (Limit > 400) Limit = 400;
if (!hICC) // can't allocate
return NULL;
- cmsSetProfileVersion(hICC, 4.2);
+ cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigLinkClass);
cmsSetColorSpace(hICC, ColorSpace);
cmsSetPCS(hICC, ColorSpace);
- cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
+ cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Creates a Pipeline with 3D grid only
LUT = cmsPipelineAlloc(ContextID, 4, 4);
if (LUT == NULL) goto Error;
-
+
nChannels = cmsChannelsOf(ColorSpace);
-
+
CLUT = cmsStageAllocCLut16bit(ContextID, 17, nChannels, nChannels, NULL);
if (CLUT == NULL) goto Error;
if (!cmsStageSampleCLut16bit(CLUT, InkLimitingSampler, (void*) &Limit, 0)) goto Error;
- cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, nChannels));
- cmsPipelineInsertStage(LUT, cmsAT_END, CLUT);
- cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, nChannels));
+ if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, nChannels)) ||
+ !cmsPipelineInsertStage(LUT, cmsAT_END, CLUT) ||
+ !cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, nChannels)))
+ goto Error;
// Create tags
if (!SetTextTags(hICC, L"ink-limiting built-in")) goto Error;
if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) LUT)) goto Error;
if (!SetSeqDescTag(hICC, "ink-limiting built-in")) goto Error;
-
+
// cmsPipeline is already on virtual profile
cmsPipelineFree(LUT);
// Creates a fake Lab identity.
cmsHPROFILE CMSEXPORT cmsCreateLab2ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint)
{
- cmsHPROFILE hProfile;
+ cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL;
-
+
hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL);
if (hProfile == NULL) return NULL;
LUT = cmsPipelineAlloc(ContextID, 3, 3);
if (LUT == NULL) goto Error;
- cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCLut(ContextID, 3));
+ if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCLut(ContextID, 3)))
+ goto Error;
if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error;
cmsPipelineFree(LUT);
// Creates a fake Lab V4 identity.
cmsHPROFILE CMSEXPORT cmsCreateLab4ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint)
{
- cmsHPROFILE hProfile;
+ cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL;
-
+
hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL);
if (hProfile == NULL) return NULL;
- cmsSetProfileVersion(hProfile, 4.2);
+ cmsSetProfileVersion(hProfile, 4.3);
cmsSetDeviceClass(hProfile, cmsSigAbstractClass);
cmsSetColorSpace(hProfile, cmsSigLabData);
LUT = cmsPipelineAlloc(ContextID, 3, 3);
if (LUT == NULL) goto Error;
- cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3));
+ if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3)))
+ goto Error;
if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error;
cmsPipelineFree(LUT);
// Creates a fake XYZ identity
cmsHPROFILE CMSEXPORT cmsCreateXYZProfileTHR(cmsContext ContextID)
{
- cmsHPROFILE hProfile;
+ cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL;
-
+
hProfile = cmsCreateRGBProfileTHR(ContextID, cmsD50_xyY(), NULL, NULL);
if (hProfile == NULL) return NULL;
- cmsSetProfileVersion(hProfile, 4.2);
+ cmsSetProfileVersion(hProfile, 4.3);
cmsSetDeviceClass(hProfile, cmsSigAbstractClass);
cmsSetColorSpace(hProfile, cmsSigXYZData);
LUT = cmsPipelineAlloc(ContextID, 3, 3);
if (LUT == NULL) goto Error;
- cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3));
+ if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3)))
+ goto Error;
if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error;
cmsPipelineFree(LUT);
Parameters[1] = 1. / 1.055;
Parameters[2] = 0.055 / 1.055;
Parameters[3] = 1. / 12.92;
- Parameters[4] = 0.04045;
+ Parameters[4] = 0.04045;
return cmsBuildParametricToneCurve(ContextID, 4, Parameters);
}
-// Create the ICC virtual profile for sRGB space
+// Create the ICC virtual profile for sRGB space
cmsHPROFILE CMSEXPORT cmsCreate_sRGBProfileTHR(cmsContext ContextID)
{
cmsCIExyY D65;
};
cmsToneCurve* Gamma22[3];
cmsHPROFILE hsRGB;
-
+
cmsWhitePointFromTemp(&D65, 6504);
Gamma22[0] = Gamma22[1] = Gamma22[2] = Build_sRGBGamma(ContextID);
if (Gamma22[0] == NULL) return NULL;
-
+
hsRGB = cmsCreateRGBProfileTHR(ContextID, &D65, &Rec709Primaries, Gamma22);
cmsFreeToneCurve(Gamma22[0]);
if (hsRGB == NULL) return NULL;
cmsCIELCh LChIn, LChOut;
cmsCIEXYZ XYZ;
LPBCHSWADJUSTS bchsw = (LPBCHSWADJUSTS) Cargo;
-
+
cmsLabEncoded2Float(&LabIn, In);
-
+
cmsLab2LCh(&LChIn, &LabIn);
// Do some adjusts on LCh
-
+
LChOut.L = LChIn.L * bchsw ->Contrast + bchsw ->Brightness;
LChOut.C = LChIn.C + bchsw -> Saturation;
LChOut.h = LChIn.h + bchsw -> Hue;
-
-
+
+
cmsLCh2Lab(&LabOut, &LChOut);
// Move white point in Lab
cmsLab2XYZ(&bchsw ->WPsrc, &XYZ, &LabOut);
cmsXYZ2Lab(&bchsw ->WPdest, &LabOut, &XYZ);
-
+
// Back to encoded
cmsFloat2LabEncoded(Out, &LabOut);
-
+
return TRUE;
}
// contrast, Saturation and white point displacement
cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfileTHR(cmsContext ContextID,
- int nLUTPoints,
- cmsFloat64Number Bright,
- cmsFloat64Number Contrast,
- cmsFloat64Number Hue,
- cmsFloat64Number Saturation,
- int TempSrc,
- int TempDest)
+ int nLUTPoints,
+ cmsFloat64Number Bright,
+ cmsFloat64Number Contrast,
+ cmsFloat64Number Hue,
+ cmsFloat64Number Saturation,
+ int TempSrc,
+ int TempDest)
{
- cmsHPROFILE hICC;
- cmsPipeline* Pipeline;
- BCHSWADJUSTS bchsw;
- cmsCIExyY WhitePnt;
- cmsStage* CLUT;
- cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
- int i;
-
-
- bchsw.Brightness = Bright;
- bchsw.Contrast = Contrast;
- bchsw.Hue = Hue;
- bchsw.Saturation = Saturation;
-
- cmsWhitePointFromTemp(&WhitePnt, TempSrc );
- cmsxyY2XYZ(&bchsw.WPsrc, &WhitePnt);
-
- cmsWhitePointFromTemp(&WhitePnt, TempDest);
- cmsxyY2XYZ(&bchsw.WPdest, &WhitePnt);
-
- hICC = cmsCreateProfilePlaceholder(ContextID);
- if (!hICC) // can't allocate
- return NULL;
-
-
- cmsSetDeviceClass(hICC, cmsSigAbstractClass);
- cmsSetColorSpace(hICC, cmsSigLabData);
- cmsSetPCS(hICC, cmsSigLabData);
-
- cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
-
-
- // Creates a Pipeline with 3D grid only
- Pipeline = cmsPipelineAlloc(ContextID, 3, 3);
- if (Pipeline == NULL) {
- cmsCloseProfile(hICC);
- return NULL;
- }
-
- for (i=0; i < MAX_INPUT_DIMENSIONS; i++) Dimensions[i] = nLUTPoints;
- CLUT = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, 3, 3, NULL);
- if (CLUT == NULL) return NULL;
-
-
- if (!cmsStageSampleCLut16bit(CLUT, bchswSampler, (void*) &bchsw, 0)) {
-
- // Shouldn't reach here
- cmsPipelineFree(Pipeline);
- cmsCloseProfile(hICC);
- return NULL;
- }
-
- cmsPipelineInsertStage(Pipeline, cmsAT_END, CLUT);
-
- // Create tags
-
- if (!SetTextTags(hICC, L"BCHS built-in")) return NULL;
-
- cmsWriteTag(hICC, cmsSigMediaWhitePointTag, (void*) cmsD50_XYZ());
-
- cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline);
-
- // Pipeline is already on virtual profile
- cmsPipelineFree(Pipeline);
-
- // Ok, done
- return hICC;
+ cmsHPROFILE hICC;
+ cmsPipeline* Pipeline;
+ BCHSWADJUSTS bchsw;
+ cmsCIExyY WhitePnt;
+ cmsStage* CLUT;
+ cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
+ int i;
+
+ bchsw.Brightness = Bright;
+ bchsw.Contrast = Contrast;
+ bchsw.Hue = Hue;
+ bchsw.Saturation = Saturation;
+
+ cmsWhitePointFromTemp(&WhitePnt, TempSrc );
+ cmsxyY2XYZ(&bchsw.WPsrc, &WhitePnt);
+
+ cmsWhitePointFromTemp(&WhitePnt, TempDest);
+ cmsxyY2XYZ(&bchsw.WPdest, &WhitePnt);
+
+ hICC = cmsCreateProfilePlaceholder(ContextID);
+ if (!hICC) // can't allocate
+ return NULL;
+
+
+ cmsSetDeviceClass(hICC, cmsSigAbstractClass);
+ cmsSetColorSpace(hICC, cmsSigLabData);
+ cmsSetPCS(hICC, cmsSigLabData);
+
+ cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
+
+ // Creates a Pipeline with 3D grid only
+ Pipeline = cmsPipelineAlloc(ContextID, 3, 3);
+ if (Pipeline == NULL) {
+ cmsCloseProfile(hICC);
+ return NULL;
+ }
+
+ for (i=0; i < MAX_INPUT_DIMENSIONS; i++) Dimensions[i] = nLUTPoints;
+ CLUT = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, 3, 3, NULL);
+ if (CLUT == NULL) return NULL;
+
+
+ if (!cmsStageSampleCLut16bit(CLUT, bchswSampler, (void*) &bchsw, 0)) {
+
+ // Shouldn't reach here
+ goto Error;
+ }
+
+ if (!cmsPipelineInsertStage(Pipeline, cmsAT_END, CLUT)) {
+ goto Error;
+ }
+
+ // Create tags
+ if (!SetTextTags(hICC, L"BCHS built-in")) return NULL;
+
+ cmsWriteTag(hICC, cmsSigMediaWhitePointTag, (void*) cmsD50_XYZ());
+
+ cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline);
+
+ // Pipeline is already on virtual profile
+ cmsPipelineFree(Pipeline);
+
+ // Ok, done
+ return hICC;
+
+Error:
+ cmsPipelineFree(Pipeline);
+ cmsCloseProfile(hICC);
+ return NULL;
}
CMSAPI cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfile(int nLUTPoints,
- cmsFloat64Number Bright,
+ cmsFloat64Number Bright,
cmsFloat64Number Contrast,
cmsFloat64Number Hue,
cmsFloat64Number Saturation,
- int TempSrc,
+ int TempSrc,
int TempDest)
{
return cmsCreateBCHSWabstractProfileTHR(NULL, nLUTPoints, Bright, Contrast, Hue, Saturation, TempSrc, TempDest);
}
-// Creates a fake NULL profile. This profile return 1 channel as always 0.
+// Creates a fake NULL profile. This profile return 1 channel as always 0.
// Is useful only for gamut checking tricks
cmsHPROFILE CMSEXPORT cmsCreateNULLProfileTHR(cmsContext ContextID)
{
- cmsHPROFILE hProfile;
+ cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL;
cmsStage* PostLin;
cmsToneCurve* EmptyTab;
if (!hProfile) // can't allocate
return NULL;
- cmsSetProfileVersion(hProfile, 4.2);
+ cmsSetProfileVersion(hProfile, 4.3);
+
+ if (!SetTextTags(hProfile, L"NULL profile built-in")) goto Error;
- if (!SetTextTags(hProfile, L"NULL profile built-in")) goto Error;
-
cmsSetDeviceClass(hProfile, cmsSigOutputClass);
cmsSetColorSpace(hProfile, cmsSigGrayData);
LUT = cmsPipelineAlloc(ContextID, 1, 1);
if (LUT == NULL) goto Error;
- EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
+ EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
PostLin = cmsStageAllocToneCurves(ContextID, 1, &EmptyTab);
cmsFreeToneCurve(EmptyTab);
- cmsPipelineInsertStage(LUT, cmsAT_END, PostLin);
+ if (!cmsPipelineInsertStage(LUT, cmsAT_END, PostLin))
+ goto Error;
if (!cmsWriteTag(hProfile, cmsSigBToA0Tag, (void*) LUT)) goto Error;
if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error;
- cmsPipelineFree(LUT);
+ cmsPipelineFree(LUT);
return hProfile;
Error:
static
-void FixColorSpaces(cmsHPROFILE hProfile,
- cmsColorSpaceSignature ColorSpace,
+void FixColorSpaces(cmsHPROFILE hProfile,
+ cmsColorSpaceSignature ColorSpace,
cmsColorSpaceSignature PCS,
cmsUInt32Number dwFlags)
{
if (dwFlags & cmsFLAGS_GUESSDEVICECLASS) {
- if (IsPCS(ColorSpace) && IsPCS(PCS)) {
+ if (IsPCS(ColorSpace) && IsPCS(PCS)) {
cmsSetDeviceClass(hProfile, cmsSigAbstractClass);
cmsSetColorSpace(hProfile, ColorSpace);
cmsSetDeviceClass(hProfile, cmsSigOutputClass);
cmsSetPCS(hProfile, ColorSpace);
- cmsSetColorSpace(hProfile, PCS);
+ cmsSetColorSpace(hProfile, PCS);
return;
}
cmsHPROFILE CreateNamedColorDevicelink(cmsHTRANSFORM xform)
{
_cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
- cmsHPROFILE hICC = NULL;
+ cmsHPROFILE hICC = NULL;
int i, nColors;
cmsNAMEDCOLORLIST *nc2 = NULL, *Original = NULL;
cmsSetPCS(hICC, cmsSigLabData);
// Tag profile with information
- if (!SetTextTags(hICC, L"Named color devicelink")) goto Error;
+ if (!SetTextTags(hICC, L"Named color devicelink")) goto Error;
Original = cmsGetNamedColorList(xform);
if (Original == NULL) goto Error;
nc2 = cmsDupNamedColorList(Original);
if (nc2 == NULL) goto Error;
- // Colorant count now depends on the output space
+ // Colorant count now depends on the output space
nc2 ->ColorantCount = cmsPipelineOutputChannels(v ->Lut);
+ // Make sure we have proper formatters
+ cmsChangeBuffersFormat(xform, TYPE_NAMED_COLOR_INDEX,
+ FLOAT_SH(0) | COLORSPACE_SH(_cmsLCMScolorSpace(v ->ExitColorSpace))
+ | BYTES_SH(2) | CHANNELS_SH(cmsChannelsOf(v ->ExitColorSpace)));
+
// Apply the transfor to colorants.
for (i=0; i < nColors; i++) {
cmsDoTransform(xform, &i, nc2 ->List[i].DeviceColorant, 1);
static const cmsAllowedLUT AllowedLUTTypes[] = {
- { FALSE, 0, cmsSigLut16Type, 4, { cmsSigMatrixElemType, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType}},
+ { FALSE, 0, cmsSigLut16Type, 4, { cmsSigMatrixElemType, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType}},
{ FALSE, 0, cmsSigLut16Type, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType}},
+ { FALSE, 0, cmsSigLut16Type, 2, { cmsSigCurveSetElemType, cmsSigCLutElemType}},
{ TRUE , 0, cmsSigLutAtoBType, 1, { cmsSigCurveSetElemType }},
{ TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType } },
{ TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType } },
for (n=0, mpe = Lut ->Elements; mpe != NULL; mpe = mpe ->Next, n++) {
if (n > Tab ->nTypes) return FALSE;
- if (cmsStageType(mpe) != Tab ->MpeTypes[n]) return FALSE;
+ if (cmsStageType(mpe) != Tab ->MpeTypes[n]) return FALSE;
}
return (n == Tab ->nTypes);
}
-static
+static
const cmsAllowedLUT* FindCombination(const cmsPipeline* Lut, cmsBool IsV4, cmsTagSignature DestinationTag)
{
- int n;
+ cmsUInt32Number n;
for (n=0; n < SIZE_OF_ALLOWED_LUT; n++) {
return NULL;
}
-
+
// Does convert a transform into a device link profile
cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat64Number Version, cmsUInt32Number dwFlags)
cmsContext ContextID = cmsGetTransformContextID(hTransform);
const cmsAllowedLUT* AllowedLUT;
cmsTagSignature DestinationTag;
+ cmsProfileClassSignature deviceClass;
_cmsAssert(hTransform != NULL);
-
+
// Get the first mpe to check for named color
mpe = cmsPipelineGetPtrToFirstStage(xform ->Lut);
-
+
// Check if is a named color transform
if (mpe != NULL) {
// Time to fix the Lab2/Lab4 issue.
if ((xform ->EntryColorSpace == cmsSigLabData) && (Version < 4.0)) {
- cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocLabV2ToV4curves(ContextID));
+ if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocLabV2ToV4curves(ContextID)))
+ goto Error;
}
// On the output side too
if ((xform ->ExitColorSpace) == cmsSigLabData && (Version < 4.0)) {
- cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocLabV4ToV2(ContextID));
+ if (!cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocLabV4ToV2(ContextID)))
+ goto Error;
}
-
+
hProfile = cmsCreateProfilePlaceholder(ContextID);
- if (!hProfile) goto Error; // can't allocate
-
+ if (!hProfile) goto Error; // can't allocate
+
cmsSetProfileVersion(hProfile, Version);
- FixColorSpaces(hProfile, xform -> EntryColorSpace, xform -> ExitColorSpace, dwFlags);
+ FixColorSpaces(hProfile, xform -> EntryColorSpace, xform -> ExitColorSpace, dwFlags);
// Optimize the LUT and precalculate a devicelink
FrmIn = COLORSPACE_SH(ColorSpaceBitsIn) | CHANNELS_SH(ChansIn)|BYTES_SH(2);
FrmOut = COLORSPACE_SH(ColorSpaceBitsOut) | CHANNELS_SH(ChansOut)|BYTES_SH(2);
+ deviceClass = cmsGetDeviceClass(hProfile);
- if (cmsGetDeviceClass(hProfile) == cmsSigOutputClass)
+ if (deviceClass == cmsSigOutputClass)
DestinationTag = cmsSigBToA0Tag;
else
DestinationTag = cmsSigAToB0Tag;
if (dwFlags & cmsFLAGS_FORCE_CLUT)
AllowedLUT = NULL;
else
- AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
+ AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
if (AllowedLUT == NULL) {
// Try to optimize
- _cmsOptimizePipeline(&LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags);
+ _cmsOptimizePipeline(ContextID, &LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags);
AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
}
if (AllowedLUT == NULL) {
dwFlags |= cmsFLAGS_FORCE_CLUT;
- _cmsOptimizePipeline(&LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags);
+ _cmsOptimizePipeline(ContextID, &LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags);
// Put identity curves if needed
- if (cmsPipelineStageCount(LUT) == 1) {
+ if (cmsPipelineGetPtrToFirstStage(LUT) ->Type != cmsSigCurveSetElemType)
+ if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, ChansIn)))
+ goto Error;
- cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, ChansIn));
- cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, ChansOut));
- }
+ if (cmsPipelineGetPtrToLastStage(LUT) ->Type != cmsSigCurveSetElemType)
+ if (!cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, ChansOut)))
+ goto Error;
AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
}
}
- if (dwFlags & cmsFLAGS_8BITS_DEVICELINK)
+ if (dwFlags & cmsFLAGS_8BITS_DEVICELINK)
cmsPipelineSetSaveAs8bitsFlag(LUT, TRUE);
-
+
// Tag profile with information
- if (!SetTextTags(hProfile, L"devicelink")) goto Error;
-
- // Store result
+ if (!SetTextTags(hProfile, L"devicelink")) goto Error;
+
+ // Store result
if (!cmsWriteTag(hProfile, DestinationTag, LUT)) goto Error;
-
-
+
+
if (xform -> InputColorant != NULL) {
if (!cmsWriteTag(hProfile, cmsSigColorantTableTag, xform->InputColorant)) goto Error;
}
if (xform -> OutputColorant != NULL) {
if (!cmsWriteTag(hProfile, cmsSigColorantTableOutTag, xform->OutputColorant)) goto Error;
}
-
- if (xform ->Sequence != NULL) {
+
+ if ((deviceClass == cmsSigLinkClass) && (xform ->Sequence != NULL)) {
if (!_cmsWriteProfileSequence(hProfile, xform ->Sequence)) goto Error;
}
- cmsPipelineFree(LUT);
+ // Set the white point
+ if (deviceClass == cmsSigInputClass) {
+ if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, &xform ->EntryWhitePoint)) goto Error;
+ }
+ else {
+ if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, &xform ->ExitWhitePoint)) goto Error;
+ }
+
+
+ // Per 7.2.15 in spec 4.3
+ cmsSetHeaderRenderingIntent(hProfile, xform ->RenderingIntent);
+
+ cmsPipelineFree(LUT);
return hProfile;
Error:
- if (LUT != NULL) cmsPipelineFree(LUT);
+ if (LUT != NULL) cmsPipelineFree(LUT);
cmsCloseProfile(hProfile);
return NULL;
}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2014 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// Obtains WhitePoint from Temperature
cmsBool CMSEXPORT cmsWhitePointFromTemp(cmsCIExyY* WhitePoint, cmsFloat64Number TempK)
{
- cmsFloat64Number x, y;
- cmsFloat64Number T, T2, T3;
- // cmsFloat64Number M1, M2;
+ cmsFloat64Number x, y;
+ cmsFloat64Number T, T2, T3;
+ // cmsFloat64Number M1, M2;
- _cmsAssert(WhitePoint != NULL);
+ _cmsAssert(WhitePoint != NULL);
- T = TempK;
- T2 = T*T; // Square
- T3 = T2*T; // Cube
+ T = TempK;
+ T2 = T*T; // Square
+ T3 = T2*T; // Cube
- // For correlated color temperature (T) between 4000K and 7000K:
+ // For correlated color temperature (T) between 4000K and 7000K:
- if (T >= 4000. && T <= 7000.)
- {
- x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
- }
- else
- // or for correlated color temperature (T) between 7000K and 25000K:
+ if (T >= 4000. && T <= 7000.)
+ {
+ x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
+ }
+ else
+ // or for correlated color temperature (T) between 7000K and 25000K:
- if (T > 7000.0 && T <= 25000.0)
- {
- x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
- }
- else {
- cmsSignalError(0, cmsERROR_RANGE, "cmsWhitePointFromTemp: invalid temp");
- return FALSE;
- }
+ if (T > 7000.0 && T <= 25000.0)
+ {
+ x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
+ }
+ else {
+ cmsSignalError(0, cmsERROR_RANGE, "cmsWhitePointFromTemp: invalid temp");
+ return FALSE;
+ }
- // Obtain y(x)
+ // Obtain y(x)
- y = -3.000*(x*x) + 2.870*x - 0.275;
+ y = -3.000*(x*x) + 2.870*x - 0.275;
- // wave factors (not used, but here for futures extensions)
+ // wave factors (not used, but here for futures extensions)
- // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
- // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
+ // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
+ // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
- WhitePoint -> x = x;
- WhitePoint -> y = y;
- WhitePoint -> Y = 1.0;
+ WhitePoint -> x = x;
+ WhitePoint -> y = y;
+ WhitePoint -> Y = 1.0;
- return TRUE;
+ return TRUE;
}
typedef struct {
- cmsFloat64Number mirek; // temp (in microreciprocal kelvin)
- cmsFloat64Number ut; // u coord of intersection w/ blackbody locus
- cmsFloat64Number vt; // v coord of intersection w/ blackbody locus
- cmsFloat64Number tt; // slope of ISOTEMPERATURE. line
+ cmsFloat64Number mirek; // temp (in microreciprocal kelvin)
+ cmsFloat64Number ut; // u coord of intersection w/ blackbody locus
+ cmsFloat64Number vt; // v coord of intersection w/ blackbody locus
+ cmsFloat64Number tt; // slope of ISOTEMPERATURE. line
} ISOTEMPERATURE;
static ISOTEMPERATURE isotempdata[] = {
-// {Mirek, Ut, Vt, Tt }
+// {Mirek, Ut, Vt, Tt }
{0, 0.18006, 0.26352, -0.24341},
{10, 0.18066, 0.26589, -0.25479},
{20, 0.18133, 0.26846, -0.26876},
// Robertson's method
cmsBool CMSEXPORT cmsTempFromWhitePoint(cmsFloat64Number* TempK, const cmsCIExyY* WhitePoint)
{
- int j;
- cmsFloat64Number us,vs;
- cmsFloat64Number uj,vj,tj,di,dj,mi,mj;
- cmsFloat64Number xs, ys;
+ cmsUInt32Number j;
+ cmsFloat64Number us,vs;
+ cmsFloat64Number uj,vj,tj,di,dj,mi,mj;
+ cmsFloat64Number xs, ys;
- _cmsAssert(WhitePoint != NULL);
+ _cmsAssert(WhitePoint != NULL);
_cmsAssert(TempK != NULL);
- di = mi = 0;
- xs = WhitePoint -> x;
- ys = WhitePoint -> y;
+ di = mi = 0;
+ xs = WhitePoint -> x;
+ ys = WhitePoint -> y;
- // convert (x,y) to CIE 1960 (u,WhitePoint)
+ // convert (x,y) to CIE 1960 (u,WhitePoint)
- us = (2*xs) / (-xs + 6*ys + 1.5);
- vs = (3*ys) / (-xs + 6*ys + 1.5);
+ us = (2*xs) / (-xs + 6*ys + 1.5);
+ vs = (3*ys) / (-xs + 6*ys + 1.5);
- for (j=0; j < NISO; j++) {
+ for (j=0; j < NISO; j++) {
- uj = isotempdata[j].ut;
- vj = isotempdata[j].vt;
- tj = isotempdata[j].tt;
- mj = isotempdata[j].mirek;
+ uj = isotempdata[j].ut;
+ vj = isotempdata[j].vt;
+ tj = isotempdata[j].tt;
+ mj = isotempdata[j].mirek;
- dj = ((vs - vj) - tj * (us - uj)) / sqrt(1.0 + tj * tj);
+ dj = ((vs - vj) - tj * (us - uj)) / sqrt(1.0 + tj * tj);
- if ((j != 0) && (di/dj < 0.0)) {
+ if ((j != 0) && (di/dj < 0.0)) {
- // Found a match
- *TempK = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
- return TRUE;
- }
+ // Found a match
+ *TempK = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
+ return TRUE;
+ }
- di = dj;
- mi = mj;
- }
+ di = dj;
+ mi = mj;
+ }
- // Not found
- return FALSE;
+ // Not found
+ return FALSE;
}
-// Compute chromatic adaptation matrix using Chad as cone matrix
+// Compute chromatic adaptation matrix using Chad as cone matrix
static
cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion,
const cmsMAT3* Chad)
{
-
+
cmsMAT3 Chad_Inv;
cmsVEC3 ConeSourceXYZ, ConeSourceRGB;
cmsVEC3 ConeDestXYZ, ConeDestRGB;
_cmsMAT3per(&Tmp, &Cone, Chad);
_cmsMAT3per(Conversion, &Chad_Inv, &Tmp);
- return TRUE;
+ return TRUE;
}
// Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll
// The cone matrix can be specified in ConeMatrix. If NULL, Bradford is assumed
cmsBool _cmsAdaptationMatrix(cmsMAT3* r, const cmsMAT3* ConeMatrix, const cmsCIEXYZ* FromIll, const cmsCIEXYZ* ToIll)
{
- cmsMAT3 LamRigg = {{ // Bradford matrix
- {{ 0.8951, 0.2664, -0.1614 }},
- {{ -0.7502, 1.7135, 0.0367 }},
- {{ 0.0389, -0.0685, 1.0296 }}
- }};
+ cmsMAT3 LamRigg = {{ // Bradford matrix
+ {{ 0.8951, 0.2664, -0.1614 }},
+ {{ -0.7502, 1.7135, 0.0367 }},
+ {{ 0.0389, -0.0685, 1.0296 }}
+ }};
- if (ConeMatrix == NULL)
- ConeMatrix = &LamRigg;
+ if (ConeMatrix == NULL)
+ ConeMatrix = &LamRigg;
- return ComputeChromaticAdaptation(r, FromIll, ToIll, ConeMatrix);
+ return ComputeChromaticAdaptation(r, FromIll, ToIll, ConeMatrix);
}
// Same as anterior, but assuming D50 destination. White point is given in xyY
static
cmsBool _cmsAdaptMatrixToD50(cmsMAT3* r, const cmsCIExyY* SourceWhitePt)
{
- cmsCIEXYZ Dn;
- cmsMAT3 Bradford;
- cmsMAT3 Tmp;
+ cmsCIEXYZ Dn;
+ cmsMAT3 Bradford;
+ cmsMAT3 Tmp;
- cmsxyY2XYZ(&Dn, SourceWhitePt);
+ cmsxyY2XYZ(&Dn, SourceWhitePt);
- if (!_cmsAdaptationMatrix(&Bradford, NULL, &Dn, cmsD50_XYZ())) return FALSE;
+ if (!_cmsAdaptationMatrix(&Bradford, NULL, &Dn, cmsD50_XYZ())) return FALSE;
- Tmp = *r;
- _cmsMAT3per(r, &Bradford, &Tmp);
+ Tmp = *r;
+ _cmsMAT3per(r, &Bradford, &Tmp);
- return TRUE;
+ return TRUE;
}
// Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
//
cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3* r, const cmsCIExyY* WhitePt, const cmsCIExyYTRIPLE* Primrs)
{
- cmsVEC3 WhitePoint, Coef;
- cmsMAT3 Result, Primaries;
- cmsFloat64Number xn, yn;
- cmsFloat64Number xr, yr;
- cmsFloat64Number xg, yg;
- cmsFloat64Number xb, yb;
+ cmsVEC3 WhitePoint, Coef;
+ cmsMAT3 Result, Primaries;
+ cmsFloat64Number xn, yn;
+ cmsFloat64Number xr, yr;
+ cmsFloat64Number xg, yg;
+ cmsFloat64Number xb, yb;
+
+ xn = WhitePt -> x;
+ yn = WhitePt -> y;
+ xr = Primrs -> Red.x;
+ yr = Primrs -> Red.y;
+ xg = Primrs -> Green.x;
+ yg = Primrs -> Green.y;
+ xb = Primrs -> Blue.x;
+ yb = Primrs -> Blue.y;
- xn = WhitePt -> x;
- yn = WhitePt -> y;
- xr = Primrs -> Red.x;
- yr = Primrs -> Red.y;
- xg = Primrs -> Green.x;
- yg = Primrs -> Green.y;
- xb = Primrs -> Blue.x;
- yb = Primrs -> Blue.y;
+ // Build Primaries matrix
+ _cmsVEC3init(&Primaries.v[0], xr, xg, xb);
+ _cmsVEC3init(&Primaries.v[1], yr, yg, yb);
+ _cmsVEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg), (1-xb-yb));
- // Build Primaries matrix
- _cmsVEC3init(&Primaries.v[0], xr, xg, xb);
- _cmsVEC3init(&Primaries.v[1], yr, yg, yb);
- _cmsVEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg), (1-xb-yb));
+ // Result = Primaries ^ (-1) inverse matrix
+ if (!_cmsMAT3inverse(&Primaries, &Result))
+ return FALSE;
- // Result = Primaries ^ (-1) inverse matrix
- if (!_cmsMAT3inverse(&Primaries, &Result))
- return FALSE;
+ _cmsVEC3init(&WhitePoint, xn/yn, 1.0, (1.0-xn-yn)/yn);
- _cmsVEC3init(&WhitePoint, xn/yn, 1.0, (1.0-xn-yn)/yn);
+ // Across inverse primaries ...
+ _cmsMAT3eval(&Coef, &Result, &WhitePoint);
- // Across inverse primaries ...
- _cmsMAT3eval(&Coef, &Result, &WhitePoint);
+ // Give us the Coefs, then I build transformation matrix
+ _cmsVEC3init(&r -> v[0], Coef.n[VX]*xr, Coef.n[VY]*xg, Coef.n[VZ]*xb);
+ _cmsVEC3init(&r -> v[1], Coef.n[VX]*yr, Coef.n[VY]*yg, Coef.n[VZ]*yb);
+ _cmsVEC3init(&r -> v[2], Coef.n[VX]*(1.0-xr-yr), Coef.n[VY]*(1.0-xg-yg), Coef.n[VZ]*(1.0-xb-yb));
- // Give us the Coefs, then I build transformation matrix
- _cmsVEC3init(&r -> v[0], Coef.n[VX]*xr, Coef.n[VY]*xg, Coef.n[VZ]*xb);
- _cmsVEC3init(&r -> v[1], Coef.n[VX]*yr, Coef.n[VY]*yg, Coef.n[VZ]*yb);
- _cmsVEC3init(&r -> v[2], Coef.n[VX]*(1.0-xr-yr), Coef.n[VY]*(1.0-xg-yg), Coef.n[VZ]*(1.0-xb-yb));
+ return _cmsAdaptMatrixToD50(r, WhitePt);
- return _cmsAdaptMatrixToD50(r, WhitePt);
-
}
// Adapts a color to a given illuminant. Original color is expected to have
-// a SourceWhitePt white point.
-cmsBool CMSEXPORT cmsAdaptToIlluminant(cmsCIEXYZ* Result,
- const cmsCIEXYZ* SourceWhitePt,
- const cmsCIEXYZ* Illuminant,
- const cmsCIEXYZ* Value)
+// a SourceWhitePt white point.
+cmsBool CMSEXPORT cmsAdaptToIlluminant(cmsCIEXYZ* Result,
+ const cmsCIEXYZ* SourceWhitePt,
+ const cmsCIEXYZ* Illuminant,
+ const cmsCIEXYZ* Value)
{
- cmsMAT3 Bradford;
- cmsVEC3 In, Out;
+ cmsMAT3 Bradford;
+ cmsVEC3 In, Out;
- _cmsAssert(Result != NULL);
- _cmsAssert(SourceWhitePt != NULL);
- _cmsAssert(Illuminant != NULL);
- _cmsAssert(Value != NULL);
+ _cmsAssert(Result != NULL);
+ _cmsAssert(SourceWhitePt != NULL);
+ _cmsAssert(Illuminant != NULL);
+ _cmsAssert(Value != NULL);
- if (!_cmsAdaptationMatrix(&Bradford, NULL, SourceWhitePt, Illuminant)) return FALSE;
+ if (!_cmsAdaptationMatrix(&Bradford, NULL, SourceWhitePt, Illuminant)) return FALSE;
- _cmsVEC3init(&In, Value -> X, Value -> Y, Value -> Z);
- _cmsMAT3eval(&Out, &Bradford, &In);
+ _cmsVEC3init(&In, Value -> X, Value -> Y, Value -> Z);
+ _cmsMAT3eval(&Out, &Bradford, &In);
- Result -> X = Out.n[0];
- Result -> Y = Out.n[1];
- Result -> Z = Out.n[2];
+ Result -> X = Out.n[0];
+ Result -> Y = Out.n[1];
+ Result -> Z = Out.n[2];
- return TRUE;
+ return TRUE;
}
//---------------------------------------------------------------------------------
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2014 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
// Transformations stuff
// -----------------------------------------------------------------------
-// Alarm codes for 16-bit transformations, because the fixed range of containers there are
-// no values left to mark out of gamut. volatile is C99 per 6.2.5
-static volatile cmsUInt16Number Alarm[cmsMAXCHANNELS];
-static volatile cmsFloat64Number GlobalAdaptationState = 0;
+#define DEFAULT_OBSERVER_ADAPTATION_STATE 1.0
+
+// The Context0 observer adaptation state.
+_cmsAdaptationStateChunkType _cmsAdaptationStateChunk = { DEFAULT_OBSERVER_ADAPTATION_STATE };
+
+// Init and duplicate observer adaptation state
+void _cmsAllocAdaptationStateChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ static _cmsAdaptationStateChunkType AdaptationStateChunk = { DEFAULT_OBSERVER_ADAPTATION_STATE };
+ void* from;
+
+ if (src != NULL) {
+ from = src ->chunks[AdaptationStateContext];
+ }
+ else {
+ from = &AdaptationStateChunk;
+ }
+
+ ctx ->chunks[AdaptationStateContext] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsAdaptationStateChunkType));
+}
+
+
+// Sets adaptation state for absolute colorimetric intent in the given context. Adaptation state applies on all
+// but cmsCreateExtendedTransformTHR(). Little CMS can handle incomplete adaptation states.
+cmsFloat64Number CMSEXPORT cmsSetAdaptationStateTHR(cmsContext ContextID, cmsFloat64Number d)
+{
+ cmsFloat64Number prev;
+ _cmsAdaptationStateChunkType* ptr = (_cmsAdaptationStateChunkType*) _cmsContextGetClientChunk(ContextID, AdaptationStateContext);
+
+ // Get previous value for return
+ prev = ptr ->AdaptationState;
+
+ // Set the value if d is positive or zero
+ if (d >= 0.0) {
+
+ ptr ->AdaptationState = d;
+ }
+
+ // Always return previous value
+ return prev;
+}
+
// The adaptation state may be defaulted by this function. If you don't like it, use the extended transform routine
cmsFloat64Number CMSEXPORT cmsSetAdaptationState(cmsFloat64Number d)
-{
- cmsFloat64Number OldVal = GlobalAdaptationState;
+{
+ return cmsSetAdaptationStateTHR(NULL, d);
+}
- if (d >= 0)
- GlobalAdaptationState = d;
+// -----------------------------------------------------------------------
- return OldVal;
+// Alarm codes for 16-bit transformations, because the fixed range of containers there are
+// no values left to mark out of gamut.
+
+#define DEFAULT_ALARM_CODES_VALUE {0x7F00, 0x7F00, 0x7F00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+_cmsAlarmCodesChunkType _cmsAlarmCodesChunk = { DEFAULT_ALARM_CODES_VALUE };
+
+// Sets the codes used to mark out-out-gamut on Proofing transforms for a given context. Values are meant to be
+// encoded in 16 bits.
+void CMSEXPORT cmsSetAlarmCodesTHR(cmsContext ContextID, const cmsUInt16Number AlarmCodesP[cmsMAXCHANNELS])
+{
+ _cmsAlarmCodesChunkType* ContextAlarmCodes = (_cmsAlarmCodesChunkType*) _cmsContextGetClientChunk(ContextID, AlarmCodesContext);
+
+ _cmsAssert(ContextAlarmCodes != NULL); // Can't happen
+
+ memcpy(ContextAlarmCodes->AlarmCodes, AlarmCodesP, sizeof(ContextAlarmCodes->AlarmCodes));
}
-// Alarm codes are always global
-void CMSEXPORT cmsSetAlarmCodes(cmsUInt16Number NewAlarm[cmsMAXCHANNELS])
+// Gets the current codes used to mark out-out-gamut on Proofing transforms for the given context.
+// Values are meant to be encoded in 16 bits.
+void CMSEXPORT cmsGetAlarmCodesTHR(cmsContext ContextID, cmsUInt16Number AlarmCodesP[cmsMAXCHANNELS])
{
- int i;
+ _cmsAlarmCodesChunkType* ContextAlarmCodes = (_cmsAlarmCodesChunkType*) _cmsContextGetClientChunk(ContextID, AlarmCodesContext);
- _cmsAssert(NewAlarm != NULL);
+ _cmsAssert(ContextAlarmCodes != NULL); // Can't happen
- for (i=0; i < cmsMAXCHANNELS; i++)
- Alarm[i] = NewAlarm[i];
+ memcpy(AlarmCodesP, ContextAlarmCodes->AlarmCodes, sizeof(ContextAlarmCodes->AlarmCodes));
}
-// You can get the codes cas well
-void CMSEXPORT cmsGetAlarmCodes(cmsUInt16Number OldAlarm[cmsMAXCHANNELS])
+void CMSEXPORT cmsSetAlarmCodes(const cmsUInt16Number NewAlarm[cmsMAXCHANNELS])
{
- int i;
+ _cmsAssert(NewAlarm != NULL);
+ cmsSetAlarmCodesTHR(NULL, NewAlarm);
+}
+
+void CMSEXPORT cmsGetAlarmCodes(cmsUInt16Number OldAlarm[cmsMAXCHANNELS])
+{
_cmsAssert(OldAlarm != NULL);
+ cmsGetAlarmCodesTHR(NULL, OldAlarm);
+}
- for (i=0; i < cmsMAXCHANNELS; i++)
- OldAlarm[i] = Alarm[i];
+
+// Init and duplicate alarm codes
+void _cmsAllocAlarmCodesChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ static _cmsAlarmCodesChunkType AlarmCodesChunk = { DEFAULT_ALARM_CODES_VALUE };
+ void* from;
+
+ if (src != NULL) {
+ from = src ->chunks[AlarmCodesContext];
+ }
+ else {
+ from = &AlarmCodesChunk;
+ }
+
+ ctx ->chunks[AlarmCodesContext] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsAlarmCodesChunkType));
}
+// -----------------------------------------------------------------------
+
// Get rid of transform resources
void CMSEXPORT cmsDeleteTransform(cmsHTRANSFORM hTransform)
{
if (p ->Sequence)
cmsFreeProfileSequenceDescription(p ->Sequence);
- LCMS_FREE_LOCK(&p->rwlock);
+ if (p ->UserData)
+ p ->FreeUserData(p ->ContextID, p ->UserData);
+
_cmsFree(p ->ContextID, (void *) p);
}
-// Apply transform
+// Apply transform.
void CMSEXPORT cmsDoTransform(cmsHTRANSFORM Transform,
const void* InputBuffer,
- void* OutputBuffer,
+ void* OutputBuffer,
cmsUInt32Number Size)
{
_cmsTRANSFORM* p = (_cmsTRANSFORM*) Transform;
- p -> xform(p, InputBuffer, OutputBuffer, Size);
+ p -> xform(p, InputBuffer, OutputBuffer, Size, Size);
+}
+
+
+// Apply transform.
+void CMSEXPORT cmsDoTransformStride(cmsHTRANSFORM Transform,
+ const void* InputBuffer,
+ void* OutputBuffer,
+ cmsUInt32Number Size, cmsUInt32Number Stride)
+
+{
+ _cmsTRANSFORM* p = (_cmsTRANSFORM*) Transform;
+
+ p -> xform(p, InputBuffer, OutputBuffer, Size, Stride);
}
static
void FloatXFORM(_cmsTRANSFORM* p,
const void* in,
- void* out, cmsUInt32Number Size)
+ void* out, cmsUInt32Number Size, cmsUInt32Number Stride)
{
cmsUInt8Number* accum;
cmsUInt8Number* output;
for (i=0; i < Size; i++) {
- accum = p -> FromInputFloat(p, fIn, accum, Size);
+ accum = p -> FromInputFloat(p, fIn, accum, Stride);
// Any gamut chack to do?
if (p ->GamutCheck != NULL) {
}
else {
// No, proceed normally
- cmsPipelineEvalFloat(fIn, fOut, p -> Lut);
+ cmsPipelineEvalFloat(fIn, fOut, p -> Lut);
}
}
else {
// No gamut check at all
- cmsPipelineEvalFloat(fIn, fOut, p -> Lut);
+ cmsPipelineEvalFloat(fIn, fOut, p -> Lut);
}
// Back to asked representation
- output = p -> ToOutputFloat(p, fOut, output, Size);
+ output = p -> ToOutputFloat(p, fOut, output, Stride);
+ }
+}
+
+
+static
+void NullFloatXFORM(_cmsTRANSFORM* p,
+ const void* in,
+ void* out,
+ cmsUInt32Number Size,
+ cmsUInt32Number Stride)
+{
+ cmsUInt8Number* accum;
+ cmsUInt8Number* output;
+ cmsFloat32Number fIn[cmsMAXCHANNELS];
+ cmsUInt32Number i, n;
+
+ accum = (cmsUInt8Number*) in;
+ output = (cmsUInt8Number*) out;
+ n = Size;
+
+ for (i=0; i < n; i++) {
+
+ accum = p -> FromInputFloat(p, fIn, accum, Stride);
+ output = p -> ToOutputFloat(p, fIn, output, Stride);
}
}
static
void NullXFORM(_cmsTRANSFORM* p,
const void* in,
- void* out, cmsUInt32Number Size)
+ void* out, cmsUInt32Number Size,
+ cmsUInt32Number Stride)
{
cmsUInt8Number* accum;
cmsUInt8Number* output;
for (i=0; i < n; i++) {
- accum = p -> FromInput(p, wIn, accum, Size);
- output = p -> ToOutput(p, wIn, output, Size);
+ accum = p -> FromInput(p, wIn, accum, Stride);
+ output = p -> ToOutput(p, wIn, output, Stride);
}
}
static
void PrecalculatedXFORM(_cmsTRANSFORM* p,
const void* in,
- void* out, cmsUInt32Number Size)
+ void* out, cmsUInt32Number Size, cmsUInt32Number Stride)
{
register cmsUInt8Number* accum;
register cmsUInt8Number* output;
accum = (cmsUInt8Number*) in;
output = (cmsUInt8Number*) out;
- n = Size;
+ n = Size;
for (i=0; i < n; i++) {
- accum = p -> FromInput(p, wIn, accum, Size);
- p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);
- output = p -> ToOutput(p, wOut, output, Size);
+ accum = p -> FromInput(p, wIn, accum, Stride);
+ p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);
+ output = p -> ToOutput(p, wOut, output, Stride);
}
}
-// Auxiliar: Handle precalculated gamut check
+// Auxiliar: Handle precalculated gamut check. The retrieval of context may be alittle bit slow, but this function is not critical.
static
-void TransformOnePixelWithGamutCheck(_cmsTRANSFORM* p,
- const cmsUInt16Number wIn[],
+void TransformOnePixelWithGamutCheck(_cmsTRANSFORM* p,
+ const cmsUInt16Number wIn[],
cmsUInt16Number wOut[])
{
cmsUInt16Number wOutOfGamut;
- p ->GamutCheck ->Eval16Fn(wIn, &wOutOfGamut, p ->GamutCheck ->Data);
+ p ->GamutCheck ->Eval16Fn(wIn, &wOutOfGamut, p ->GamutCheck ->Data);
if (wOutOfGamut >= 1) {
cmsUInt16Number i;
+ _cmsAlarmCodesChunkType* ContextAlarmCodes = (_cmsAlarmCodesChunkType*) _cmsContextGetClientChunk(p->ContextID, AlarmCodesContext);
+
+ for (i=0; i < p ->Lut->OutputChannels; i++) {
- for (i=0; i < p ->Lut->OutputChannels; i++)
- wOut[i] = Alarm[i];
+ wOut[i] = ContextAlarmCodes ->AlarmCodes[i];
+ }
}
else
- p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);
+ p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);
}
// Gamut check, No caché, 16 bits.
static
void PrecalculatedXFORMGamutCheck(_cmsTRANSFORM* p,
const void* in,
- void* out, cmsUInt32Number Size)
+ void* out, cmsUInt32Number Size, cmsUInt32Number Stride)
{
cmsUInt8Number* accum;
cmsUInt8Number* output;
for (i=0; i < n; i++) {
- accum = p -> FromInput(p, wIn, accum, Size);
+ accum = p -> FromInput(p, wIn, accum, Stride);
TransformOnePixelWithGamutCheck(p, wIn, wOut);
- output = p -> ToOutput(p, wOut, output, Size);
+ output = p -> ToOutput(p, wOut, output, Stride);
}
}
-// No gamut check, Caché, 16 bits,
+// No gamut check, Caché, 16 bits,
static
void CachedXFORM(_cmsTRANSFORM* p,
const void* in,
- void* out, cmsUInt32Number Size)
+ void* out, cmsUInt32Number Size, cmsUInt32Number Stride)
{
cmsUInt8Number* accum;
cmsUInt8Number* output;
cmsUInt16Number wIn[cmsMAXCHANNELS], wOut[cmsMAXCHANNELS];
cmsUInt32Number i, n;
- cmsUInt16Number CacheIn[cmsMAXCHANNELS], CacheOut[cmsMAXCHANNELS];
+ _cmsCACHE Cache;
accum = (cmsUInt8Number*) in;
output = (cmsUInt8Number*) out;
memset(wIn, 0, sizeof(wIn));
memset(wOut, 0, sizeof(wOut));
-
- LCMS_READ_LOCK(&p ->rwlock);
- memmove(CacheIn, p ->CacheIn, sizeof(CacheIn));
- memmove(CacheOut, p ->CacheOut, sizeof(CacheOut));
- LCMS_UNLOCK(&p ->rwlock);
+ // Get copy of zero cache
+ memcpy(&Cache, &p ->Cache, sizeof(Cache));
for (i=0; i < n; i++) {
- accum = p -> FromInput(p, wIn, accum, Size);
+ accum = p -> FromInput(p, wIn, accum, Stride);
- if (memcmp(wIn, CacheIn, sizeof(CacheIn)) == 0) {
+ if (memcmp(wIn, Cache.CacheIn, sizeof(Cache.CacheIn)) == 0) {
- memmove(wOut, CacheOut, sizeof(CacheOut));
+ memcpy(wOut, Cache.CacheOut, sizeof(Cache.CacheOut));
}
- else {
+ else {
- p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);
+ p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);
- memmove(CacheIn, wIn, sizeof(CacheIn));
- memmove(CacheOut, wOut, sizeof(CacheOut));
+ memcpy(Cache.CacheIn, wIn, sizeof(Cache.CacheIn));
+ memcpy(Cache.CacheOut, wOut, sizeof(Cache.CacheOut));
}
- output = p -> ToOutput(p, wOut, output, Size);
+ output = p -> ToOutput(p, wOut, output, Stride);
}
-
- LCMS_WRITE_LOCK(&p ->rwlock);
- memmove(p->CacheIn, CacheIn, sizeof(CacheIn));
- memmove(p->CacheOut, CacheOut, sizeof(CacheOut));
- LCMS_UNLOCK(&p ->rwlock);
}
static
void CachedXFORMGamutCheck(_cmsTRANSFORM* p,
const void* in,
- void* out, cmsUInt32Number Size)
+ void* out, cmsUInt32Number Size, cmsUInt32Number Stride)
{
cmsUInt8Number* accum;
cmsUInt8Number* output;
cmsUInt16Number wIn[cmsMAXCHANNELS], wOut[cmsMAXCHANNELS];
cmsUInt32Number i, n;
- cmsUInt16Number CacheIn[cmsMAXCHANNELS], CacheOut[cmsMAXCHANNELS];
+ _cmsCACHE Cache;
accum = (cmsUInt8Number*) in;
output = (cmsUInt8Number*) out;
memset(wIn, 0, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
memset(wOut, 0, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
- LCMS_READ_LOCK(&p ->rwlock);
- memmove(CacheIn, p ->CacheIn, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
- memmove(CacheOut, p ->CacheOut, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
- LCMS_UNLOCK(&p ->rwlock);
-
+ // Get copy of zero cache
+ memcpy(&Cache, &p ->Cache, sizeof(Cache));
for (i=0; i < n; i++) {
- accum = p -> FromInput(p, wIn, accum, Size);
-
- if (memcmp(wIn, CacheIn, sizeof(cmsUInt16Number) * cmsMAXCHANNELS) == 0) {
- memmove(wOut, CacheOut, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
+ accum = p -> FromInput(p, wIn, accum, Stride);
+
+ if (memcmp(wIn, Cache.CacheIn, sizeof(Cache.CacheIn)) == 0) {
+ memcpy(wOut, Cache.CacheOut, sizeof(Cache.CacheOut));
}
- else {
+ else {
TransformOnePixelWithGamutCheck(p, wIn, wOut);
- memmove(CacheIn, wIn, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
- memmove(CacheOut, wOut, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
+ memcpy(Cache.CacheIn, wIn, sizeof(Cache.CacheIn));
+ memcpy(Cache.CacheOut, wOut, sizeof(Cache.CacheOut));
}
- output = p -> ToOutput(p, wOut, output, Size);
+ output = p -> ToOutput(p, wOut, output, Stride);
}
- LCMS_WRITE_LOCK(&p ->rwlock);
- memmove(p->CacheIn, CacheIn, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
- memmove(p->CacheOut, CacheOut, sizeof(cmsUInt16Number) * cmsMAXCHANNELS);
- LCMS_UNLOCK(&p ->rwlock);
}
+// -------------------------------------------------------------------------------------------------------------
+
+// List of used-defined transform factories
+typedef struct _cmsTransformCollection_st {
+
+ _cmsTransformFactory Factory;
+ struct _cmsTransformCollection_st *Next;
+} _cmsTransformCollection;
+// The linked list head
+_cmsTransformPluginChunkType _cmsTransformPluginChunk = { NULL };
-// Allocate transform struct and set it to defaults
+
+// Duplicates the zone of memory used by the plug-in in the new context
static
-_cmsTRANSFORM* AllocEmptyTransform(cmsContext ContextID, cmsUInt32Number InputFormat, cmsUInt32Number OutputFormat, cmsUInt32Number dwFlags)
+void DupPluginTransformList(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
{
+ _cmsTransformPluginChunkType newHead = { NULL };
+ _cmsTransformCollection* entry;
+ _cmsTransformCollection* Anterior = NULL;
+ _cmsTransformPluginChunkType* head = (_cmsTransformPluginChunkType*) src->chunks[TransformPlugin];
+
+ // Walk the list copying all nodes
+ for (entry = head->TransformCollection;
+ entry != NULL;
+ entry = entry ->Next) {
+
+ _cmsTransformCollection *newEntry = ( _cmsTransformCollection *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(_cmsTransformCollection));
+
+ if (newEntry == NULL)
+ return;
+
+ // We want to keep the linked list order, so this is a little bit tricky
+ newEntry -> Next = NULL;
+ if (Anterior)
+ Anterior -> Next = newEntry;
+
+ Anterior = newEntry;
+
+ if (newHead.TransformCollection == NULL)
+ newHead.TransformCollection = newEntry;
+ }
+
+ ctx ->chunks[TransformPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsTransformPluginChunkType));
+}
+
+void _cmsAllocTransformPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src)
+{
+ if (src != NULL) {
+
+ // Copy all linked list
+ DupPluginTransformList(ctx, src);
+ }
+ else {
+ static _cmsTransformPluginChunkType TransformPluginChunkType = { NULL };
+ ctx ->chunks[TransformPlugin] = _cmsSubAllocDup(ctx ->MemPool, &TransformPluginChunkType, sizeof(_cmsTransformPluginChunkType));
+ }
+}
+
+
+
+// Register new ways to transform
+cmsBool _cmsRegisterTransformPlugin(cmsContext ContextID, cmsPluginBase* Data)
+{
+ cmsPluginTransform* Plugin = (cmsPluginTransform*) Data;
+ _cmsTransformCollection* fl;
+ _cmsTransformPluginChunkType* ctx = ( _cmsTransformPluginChunkType*) _cmsContextGetClientChunk(ContextID,TransformPlugin);
+
+ if (Data == NULL) {
+
+ // Free the chain. Memory is safely freed at exit
+ ctx->TransformCollection = NULL;
+ return TRUE;
+ }
+
+ // Factory callback is required
+ if (Plugin ->Factory == NULL) return FALSE;
+
+
+ fl = (_cmsTransformCollection*) _cmsPluginMalloc(ContextID, sizeof(_cmsTransformCollection));
+ if (fl == NULL) return FALSE;
+
+ // Copy the parameters
+ fl ->Factory = Plugin ->Factory;
+
+ // Keep linked list
+ fl ->Next = ctx->TransformCollection;
+ ctx->TransformCollection = fl;
+
+ // All is ok
+ return TRUE;
+}
+
+
+void CMSEXPORT _cmsSetTransformUserData(struct _cmstransform_struct *CMMcargo, void* ptr, _cmsFreeUserDataFn FreePrivateDataFn)
+{
+ _cmsAssert(CMMcargo != NULL);
+ CMMcargo ->UserData = ptr;
+ CMMcargo ->FreeUserData = FreePrivateDataFn;
+}
+
+// returns the pointer defined by the plug-in to store private data
+void * CMSEXPORT _cmsGetTransformUserData(struct _cmstransform_struct *CMMcargo)
+{
+ _cmsAssert(CMMcargo != NULL);
+ return CMMcargo ->UserData;
+}
+
+// returns the current formatters
+void CMSEXPORT _cmsGetTransformFormatters16(struct _cmstransform_struct *CMMcargo, cmsFormatter16* FromInput, cmsFormatter16* ToOutput)
+{
+ _cmsAssert(CMMcargo != NULL);
+ if (FromInput) *FromInput = CMMcargo ->FromInput;
+ if (ToOutput) *ToOutput = CMMcargo ->ToOutput;
+}
+
+void CMSEXPORT _cmsGetTransformFormattersFloat(struct _cmstransform_struct *CMMcargo, cmsFormatterFloat* FromInput, cmsFormatterFloat* ToOutput)
+{
+ _cmsAssert(CMMcargo != NULL);
+ if (FromInput) *FromInput = CMMcargo ->FromInputFloat;
+ if (ToOutput) *ToOutput = CMMcargo ->ToOutputFloat;
+}
+
+
+// Allocate transform struct and set it to defaults. Ask the optimization plug-in about if those formats are proper
+// for separated transforms. If this is the case,
+static
+_cmsTRANSFORM* AllocEmptyTransform(cmsContext ContextID, cmsPipeline* lut,
+ cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
+{
+ _cmsTransformPluginChunkType* ctx = ( _cmsTransformPluginChunkType*) _cmsContextGetClientChunk(ContextID, TransformPlugin);
+ _cmsTransformCollection* Plugin;
+
// Allocate needed memory
_cmsTRANSFORM* p = (_cmsTRANSFORM*) _cmsMallocZero(ContextID, sizeof(_cmsTRANSFORM));
if (!p) return NULL;
+ // Store the proposed pipeline
+ p ->Lut = lut;
+
+ // Let's see if any plug-in want to do the transform by itself
+ for (Plugin = ctx ->TransformCollection;
+ Plugin != NULL;
+ Plugin = Plugin ->Next) {
+
+ if (Plugin ->Factory(&p->xform, &p->UserData, &p ->FreeUserData, &p ->Lut, InputFormat, OutputFormat, dwFlags)) {
+
+ // Last plugin in the declaration order takes control. We just keep
+ // the original parameters as a logging.
+ // Note that cmsFLAGS_CAN_CHANGE_FORMATTER is not set, so by default
+ // an optimized transform is not reusable. The plug-in can, however, change
+ // the flags and make it suitable.
+
+ p ->ContextID = ContextID;
+ p ->InputFormat = *InputFormat;
+ p ->OutputFormat = *OutputFormat;
+ p ->dwOriginalFlags = *dwFlags;
+
+ // Fill the formatters just in case the optimized routine is interested.
+ // No error is thrown if the formatter doesn't exist. It is up to the optimization
+ // factory to decide what to do in those cases.
+ p ->FromInput = _cmsGetFormatter(ContextID, *InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_16BITS).Fmt16;
+ p ->ToOutput = _cmsGetFormatter(ContextID, *OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_16BITS).Fmt16;
+ p ->FromInputFloat = _cmsGetFormatter(ContextID, *InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_FLOAT).FmtFloat;
+ p ->ToOutputFloat = _cmsGetFormatter(ContextID, *OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_FLOAT).FmtFloat;
+
+ return p;
+ }
+ }
+
+ // Not suitable for the transform plug-in, let's check the pipeline plug-in
+ if (p ->Lut != NULL)
+ _cmsOptimizePipeline(ContextID, &p->Lut, Intent, InputFormat, OutputFormat, dwFlags);
+
// Check whatever this is a true floating point transform
- if (_cmsFormatterIsFloat(InputFormat) && _cmsFormatterIsFloat(OutputFormat)) {
+ if (_cmsFormatterIsFloat(*InputFormat) && _cmsFormatterIsFloat(*OutputFormat)) {
// Get formatter function always return a valid union, but the contents of this union may be NULL.
- p ->FromInputFloat = _cmsGetFormatter(InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_FLOAT).FmtFloat;
- p ->ToOutputFloat = _cmsGetFormatter(OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_FLOAT).FmtFloat;
- dwFlags |= cmsFLAGS_CAN_CHANGE_FORMATTER;
+ p ->FromInputFloat = _cmsGetFormatter(ContextID, *InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_FLOAT).FmtFloat;
+ p ->ToOutputFloat = _cmsGetFormatter(ContextID, *OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_FLOAT).FmtFloat;
+ *dwFlags |= cmsFLAGS_CAN_CHANGE_FORMATTER;
if (p ->FromInputFloat == NULL || p ->ToOutputFloat == NULL) {
-
+
cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported raster format");
_cmsFree(ContextID, p);
return NULL;
}
- // Float transforms don't use caché, always are non-NULL
- p ->xform = FloatXFORM;
+ if (*dwFlags & cmsFLAGS_NULLTRANSFORM) {
+
+ p ->xform = NullFloatXFORM;
+ }
+ else {
+ // Float transforms don't use caché, always are non-NULL
+ p ->xform = FloatXFORM;
+ }
+
}
else {
- if (InputFormat == 0 && OutputFormat == 0) {
+ if (*InputFormat == 0 && *OutputFormat == 0) {
p ->FromInput = p ->ToOutput = NULL;
+ *dwFlags |= cmsFLAGS_CAN_CHANGE_FORMATTER;
}
else {
int BytesPerPixelInput;
- p ->FromInput = _cmsGetFormatter(InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_16BITS).Fmt16;
- p ->ToOutput = _cmsGetFormatter(OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_16BITS).Fmt16;
-
+ p ->FromInput = _cmsGetFormatter(ContextID, *InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_16BITS).Fmt16;
+ p ->ToOutput = _cmsGetFormatter(ContextID, *OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_16BITS).Fmt16;
if (p ->FromInput == NULL || p ->ToOutput == NULL) {
}
BytesPerPixelInput = T_BYTES(p ->InputFormat);
- if (BytesPerPixelInput == 0 || BytesPerPixelInput >= 2)
- dwFlags |= cmsFLAGS_CAN_CHANGE_FORMATTER;
+ if (BytesPerPixelInput == 0 || BytesPerPixelInput >= 2)
+ *dwFlags |= cmsFLAGS_CAN_CHANGE_FORMATTER;
}
- if (dwFlags & cmsFLAGS_NULLTRANSFORM) {
+ if (*dwFlags & cmsFLAGS_NULLTRANSFORM) {
p ->xform = NullXFORM;
}
else {
- if (dwFlags & cmsFLAGS_NOCACHE) {
+ if (*dwFlags & cmsFLAGS_NOCACHE) {
- if (dwFlags & cmsFLAGS_GAMUTCHECK)
+ if (*dwFlags & cmsFLAGS_GAMUTCHECK)
p ->xform = PrecalculatedXFORMGamutCheck; // Gamut check, no caché
else
p ->xform = PrecalculatedXFORM; // No caché, no gamut check
}
else {
- if (dwFlags & cmsFLAGS_GAMUTCHECK)
+ if (*dwFlags & cmsFLAGS_GAMUTCHECK)
p ->xform = CachedXFORMGamutCheck; // Gamut check, caché
else
p ->xform = CachedXFORM; // No gamut check, caché
}
}
-
- // Create a mutex for shared memory
- LCMS_CREATE_LOCK(&p->rwlock);
-
- p ->InputFormat = InputFormat;
- p ->OutputFormat = OutputFormat;
- p ->dwOriginalFlags = dwFlags;
+ p ->InputFormat = *InputFormat;
+ p ->OutputFormat = *OutputFormat;
+ p ->dwOriginalFlags = *dwFlags;
p ->ContextID = ContextID;
+ p ->UserData = NULL;
return p;
}
static
-cmsBool GetXFormColorSpaces(int nProfiles, cmsHPROFILE hProfiles[], cmsColorSpaceSignature* Input, cmsColorSpaceSignature* Output)
-{
- cmsColorSpaceSignature ColorSpaceIn, ColorSpaceOut;
- cmsColorSpaceSignature PostColorSpace;
+cmsBool GetXFormColorSpaces(int nProfiles, cmsHPROFILE hProfiles[], cmsColorSpaceSignature* Input, cmsColorSpaceSignature* Output)
+{
+ cmsColorSpaceSignature ColorSpaceIn, ColorSpaceOut;
+ cmsColorSpaceSignature PostColorSpace;
int i;
- if (hProfiles[0] == NULL) return FALSE;
+ if (nProfiles <= 0) return FALSE;
+ if (hProfiles[0] == NULL) return FALSE;
*Input = PostColorSpace = cmsGetColorSpace(hProfiles[0]);
for (i=0; i < nProfiles; i++) {
+ cmsProfileClassSignature cls;
cmsHPROFILE hProfile = hProfiles[i];
int lIsInput = (PostColorSpace != cmsSigXYZData) &&
(PostColorSpace != cmsSigLabData);
- if (hProfile == NULL) return FALSE;
+ if (hProfile == NULL) return FALSE;
- if (lIsInput) {
+ cls = cmsGetDeviceClass(hProfile);
+
+ if (cls == cmsSigNamedColorClass) {
+
+ ColorSpaceIn = cmsSig1colorData;
+ ColorSpaceOut = (nProfiles > 1) ? cmsGetPCS(hProfile) : cmsGetColorSpace(hProfile);
+ }
+ else
+ if (lIsInput || (cls == cmsSigLinkClass)) {
ColorSpaceIn = cmsGetColorSpace(hProfile);
ColorSpaceOut = cmsGetPCS(hProfile);
}
- else {
-
+ else
+ {
ColorSpaceIn = cmsGetPCS(hProfile);
ColorSpaceOut = cmsGetColorSpace(hProfile);
}
- PostColorSpace = ColorSpaceOut;
- }
+ if (i==0)
+ *Input = ColorSpaceIn;
+
+ PostColorSpace = ColorSpaceOut;
+ }
*Output = PostColorSpace;
- return TRUE;
+ return TRUE;
}
// Check colorspace
// ----------------------------------------------------------------------------------------------------------------
+static
+void SetWhitePoint(cmsCIEXYZ* wtPt, const cmsCIEXYZ* src)
+{
+ if (src == NULL) {
+ wtPt ->X = cmsD50X;
+ wtPt ->Y = cmsD50Y;
+ wtPt ->Z = cmsD50Z;
+ }
+ else {
+ wtPt ->X = src->X;
+ wtPt ->Y = src->Y;
+ wtPt ->Z = src->Z;
+ }
+
+}
+
// New to lcms 2.0 -- have all parameters available.
cmsHTRANSFORM CMSEXPORT cmsCreateExtendedTransform(cmsContext ContextID,
- cmsUInt32Number nProfiles, cmsHPROFILE hProfiles[],
- cmsBool BPC[],
- cmsUInt32Number Intents[],
+ cmsUInt32Number nProfiles, cmsHPROFILE hProfiles[],
+ cmsBool BPC[],
+ cmsUInt32Number Intents[],
cmsFloat64Number AdaptationStates[],
cmsHPROFILE hGamutProfile,
- cmsUInt32Number nGamutPCSposition,
+ cmsUInt32Number nGamutPCSposition,
cmsUInt32Number InputFormat,
cmsUInt32Number OutputFormat,
cmsUInt32Number dwFlags)
{
- _cmsTRANSFORM* xform;
- cmsBool FloatTransform;
+ _cmsTRANSFORM* xform;
cmsColorSpaceSignature EntryColorSpace;
cmsColorSpaceSignature ExitColorSpace;
cmsPipeline* Lut;
cmsUInt32Number LastIntent = Intents[nProfiles-1];
+ // If it is a fake transform
+ if (dwFlags & cmsFLAGS_NULLTRANSFORM)
+ {
+ return AllocEmptyTransform(ContextID, NULL, INTENT_PERCEPTUAL, &InputFormat, &OutputFormat, &dwFlags);
+ }
+
// If gamut check is requested, make sure we have a gamut profile
if (dwFlags & cmsFLAGS_GAMUTCHECK) {
if (hGamutProfile == NULL) dwFlags &= ~cmsFLAGS_GAMUTCHECK;
}
- // On floating point transforms, inhibit optimizations
- FloatTransform = (_cmsFormatterIsFloat(InputFormat) && _cmsFormatterIsFloat(OutputFormat));
-
+ // On floating point transforms, inhibit cache
if (_cmsFormatterIsFloat(InputFormat) || _cmsFormatterIsFloat(OutputFormat))
dwFlags |= cmsFLAGS_NOCACHE;
// Mark entry/exit spaces
- if (!GetXFormColorSpaces(nProfiles, hProfiles, &EntryColorSpace, &ExitColorSpace)) {
- cmsSignalError(ContextID, cmsERROR_NULL, "NULL input profiles on transform");
- return NULL;
- }
+ if (!GetXFormColorSpaces(nProfiles, hProfiles, &EntryColorSpace, &ExitColorSpace)) {
+ cmsSignalError(ContextID, cmsERROR_NULL, "NULL input profiles on transform");
+ return NULL;
+ }
// Check if proper colorspaces
- if (!IsProperColorSpace(EntryColorSpace, InputFormat)) {
- cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "Wrong input color space on transform");
+ if (!IsProperColorSpace(EntryColorSpace, InputFormat)) {
+ cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "Wrong input color space on transform");
return NULL;
}
if (!IsProperColorSpace(ExitColorSpace, OutputFormat)) {
- cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "Wrong output color space on transform");
+ cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "Wrong output color space on transform");
return NULL;
}
// Create a pipeline with all transformations
Lut = _cmsLinkProfiles(ContextID, nProfiles, Intents, hProfiles, BPC, AdaptationStates, dwFlags);
if (Lut == NULL) {
- cmsSignalError(ContextID, cmsERROR_NOT_SUITABLE, "Couldn't link the profiles");
+ cmsSignalError(ContextID, cmsERROR_NOT_SUITABLE, "Couldn't link the profiles");
return NULL;
}
- // Optimize the LUT if possible
- _cmsOptimizePipeline(&Lut, LastIntent, &InputFormat, &OutputFormat, &dwFlags);
+ // Check channel count
+ if ((cmsChannelsOf(EntryColorSpace) != cmsPipelineInputChannels(Lut)) ||
+ (cmsChannelsOf(ExitColorSpace) != cmsPipelineOutputChannels(Lut))) {
+ cmsPipelineFree(Lut);
+ cmsSignalError(ContextID, cmsERROR_NOT_SUITABLE, "Channel count doesn't match. Profile is corrupted");
+ return NULL;
+ }
// All seems ok
- xform = AllocEmptyTransform(ContextID, InputFormat, OutputFormat, dwFlags);
+ xform = AllocEmptyTransform(ContextID, Lut, LastIntent, &InputFormat, &OutputFormat, &dwFlags);
if (xform == NULL) {
- cmsPipelineFree(Lut);
return NULL;
}
// Keep values
xform ->EntryColorSpace = EntryColorSpace;
xform ->ExitColorSpace = ExitColorSpace;
- xform ->Lut = Lut;
+ xform ->RenderingIntent = Intents[nProfiles-1];
+ // Take white points
+ SetWhitePoint(&xform->EntryWhitePoint, (cmsCIEXYZ*) cmsReadTag(hProfiles[0], cmsSigMediaWhitePointTag));
+ SetWhitePoint(&xform->ExitWhitePoint, (cmsCIEXYZ*) cmsReadTag(hProfiles[nProfiles-1], cmsSigMediaWhitePointTag));
+
// Create a gamut check LUT if requested
- if (hGamutProfile != NULL && (dwFlags & cmsFLAGS_GAMUTCHECK))
- xform ->GamutCheck = _cmsCreateGamutCheckPipeline(ContextID, hProfiles,
- BPC, Intents,
- AdaptationStates,
- nGamutPCSposition,
+ if (hGamutProfile != NULL && (dwFlags & cmsFLAGS_GAMUTCHECK))
+ xform ->GamutCheck = _cmsCreateGamutCheckPipeline(ContextID, hProfiles,
+ BPC, Intents,
+ AdaptationStates,
+ nGamutPCSposition,
hGamutProfile);
// Try to read input and output colorant table
if (cmsIsTag(hProfiles[0], cmsSigColorantTableTag)) {
- // Input table can only come in this way.
+ // Input table can only come in this way.
xform ->InputColorant = cmsDupNamedColorList((cmsNAMEDCOLORLIST*) cmsReadTag(hProfiles[0], cmsSigColorantTableTag));
}
- // Output is a little bit more complex.
+ // Output is a little bit more complex.
if (cmsGetDeviceClass(hProfiles[nProfiles-1]) == cmsSigLinkClass) {
- // This tag may exist only on devicelink profiles.
+ // This tag may exist only on devicelink profiles.
if (cmsIsTag(hProfiles[nProfiles-1], cmsSigColorantTableOutTag)) {
// It may be NULL if error
if (cmsIsTag(hProfiles[nProfiles-1], cmsSigColorantTableTag)) {
xform -> OutputColorant = cmsDupNamedColorList((cmsNAMEDCOLORLIST*) cmsReadTag(hProfiles[nProfiles-1], cmsSigColorantTableTag));
- }
+ }
}
// Store the sequence of profiles
if (dwFlags & cmsFLAGS_KEEP_SEQUENCE) {
xform ->Sequence = _cmsCompileProfileSequence(ContextID, nProfiles, hProfiles);
}
- else
+ else
xform ->Sequence = NULL;
// If this is a cached transform, init first value, which is zero (16 bits only)
if (!(dwFlags & cmsFLAGS_NOCACHE)) {
- memset(&xform ->CacheIn, 0, sizeof(xform ->CacheIn));
+ memset(&xform ->Cache.CacheIn, 0, sizeof(xform ->Cache.CacheIn));
if (xform ->GamutCheck != NULL) {
- TransformOnePixelWithGamutCheck(xform, xform ->CacheIn, xform->CacheOut);
+ TransformOnePixelWithGamutCheck(xform, xform ->Cache.CacheIn, xform->Cache.CacheOut);
}
else {
- xform ->Lut ->Eval16Fn(xform ->CacheIn, xform->CacheOut, xform -> Lut->Data);
+ xform ->Lut ->Eval16Fn(xform ->Cache.CacheIn, xform->Cache.CacheOut, xform -> Lut->Data);
}
}
- return (cmsHTRANSFORM) xform;
+ return (cmsHTRANSFORM) xform;
}
// Multiprofile transforms: Gamut check is not available here, as it is unclear from which profile the gamut comes.
-
cmsHTRANSFORM CMSEXPORT cmsCreateMultiprofileTransformTHR(cmsContext ContextID,
cmsHPROFILE hProfiles[],
cmsUInt32Number nProfiles,
for (i=0; i < nProfiles; i++) {
BPC[i] = dwFlags & cmsFLAGS_BLACKPOINTCOMPENSATION ? TRUE : FALSE;
Intents[i] = Intent;
- AdaptationStates[i] = GlobalAdaptationState;
+ AdaptationStates[i] = cmsSetAdaptationStateTHR(ContextID, -1);
}
{
cmsHPROFILE hArray[2];
-
+
hArray[0] = Input;
hArray[1] = Output;
cmsUInt32Number nIntent,
cmsUInt32Number ProofingIntent,
cmsUInt32Number dwFlags)
-{
+{
cmsHPROFILE hArray[4];
cmsUInt32Number Intents[4];
cmsBool BPC[4];
hArray[0] = InputProfile; hArray[1] = ProofingProfile; hArray[2] = ProofingProfile; hArray[3] = OutputProfile;
Intents[0] = nIntent; Intents[1] = nIntent; Intents[2] = INTENT_RELATIVE_COLORIMETRIC; Intents[3] = ProofingIntent;
BPC[0] = DoBPC; BPC[1] = DoBPC; BPC[2] = 0; BPC[3] = 0;
-
- Adaptation[0] = Adaptation[1] = Adaptation[2] = Adaptation[3] = GlobalAdaptationState;
- if (!(dwFlags & (cmsFLAGS_SOFTPROOFING|cmsFLAGS_GAMUTCHECK)))
+ Adaptation[0] = Adaptation[1] = Adaptation[2] = Adaptation[3] = cmsSetAdaptationStateTHR(ContextID, -1);
+
+ if (!(dwFlags & (cmsFLAGS_SOFTPROOFING|cmsFLAGS_GAMUTCHECK)))
return cmsCreateTransformTHR(ContextID, InputProfile, InputFormat, OutputProfile, OutputFormat, nIntent, dwFlags);
-
- return cmsCreateExtendedTransform(ContextID, 4, hArray, BPC, Intents, Adaptation,
+
+ return cmsCreateExtendedTransform(ContextID, 4, hArray, BPC, Intents, Adaptation,
ProofingProfile, 1, InputFormat, OutputFormat, dwFlags);
}
cmsUInt32Number ProofingIntent,
cmsUInt32Number dwFlags)
{
- return cmsCreateProofingTransformTHR(cmsGetProfileContextID(InputProfile),
+ return cmsCreateProofingTransformTHR(cmsGetProfileContextID(InputProfile),
InputProfile,
InputFormat,
OutputProfile,
return xform -> ContextID;
}
+// Grab the input/output formats
+cmsUInt32Number CMSEXPORT cmsGetTransformInputFormat(cmsHTRANSFORM hTransform)
+{
+ _cmsTRANSFORM* xform = (_cmsTRANSFORM*) hTransform;
+ if (xform == NULL) return 0;
+ return xform->InputFormat;
+}
+
+cmsUInt32Number CMSEXPORT cmsGetTransformOutputFormat(cmsHTRANSFORM hTransform)
+{
+ _cmsTRANSFORM* xform = (_cmsTRANSFORM*) hTransform;
+
+ if (xform == NULL) return 0;
+ return xform->OutputFormat;
+}
// For backwards compatibility
-cmsBool CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
- cmsUInt32Number InputFormat,
+cmsBool CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
+ cmsUInt32Number InputFormat,
cmsUInt32Number OutputFormat)
{
_cmsTRANSFORM* xform = (_cmsTRANSFORM*) hTransform;
cmsFormatter16 FromInput, ToOutput;
- cmsUInt32Number BytesPerPixelInput;
+
// We only can afford to change formatters if previous transform is at least 16 bits
- BytesPerPixelInput = T_BYTES(xform ->InputFormat);
if (!(xform ->dwOriginalFlags & cmsFLAGS_CAN_CHANGE_FORMATTER)) {
cmsSignalError(xform ->ContextID, cmsERROR_NOT_SUITABLE, "cmsChangeBuffersFormat works only on transforms created originally with at least 16 bits of precision");
return FALSE;
}
- FromInput = _cmsGetFormatter(InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_16BITS).Fmt16;
- ToOutput = _cmsGetFormatter(OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_16BITS).Fmt16;
+ FromInput = _cmsGetFormatter(xform->ContextID, InputFormat, cmsFormatterInput, CMS_PACK_FLAGS_16BITS).Fmt16;
+ ToOutput = _cmsGetFormatter(xform->ContextID, OutputFormat, cmsFormatterOutput, CMS_PACK_FLAGS_16BITS).Fmt16;
if (FromInput == NULL || ToOutput == NULL) {
xform ->InputFormat = InputFormat;
xform ->OutputFormat = OutputFormat;
- xform ->FromInput = FromInput;
- xform ->ToOutput = ToOutput;
+ xform ->FromInput = FromInput;
+ xform ->ToOutput = ToOutput;
return TRUE;
}
-LIBRARY LCMS2.DLL
-
-EXPORTS
-
-_cms15Fixed16toDouble = _cms15Fixed16toDouble
-_cms8Fixed8toDouble = _cms8Fixed8toDouble
-cmsAdaptToIlluminant = cmsAdaptToIlluminant
-_cmsAdjustEndianess16 = _cmsAdjustEndianess16
-_cmsAdjustEndianess32 = _cmsAdjustEndianess32
-_cmsAdjustEndianess64 = _cmsAdjustEndianess64
-cmsAllocNamedColorList = cmsAllocNamedColorList
-cmsAllocProfileSequenceDescription = cmsAllocProfileSequenceDescription
-cmsAppendNamedColor = cmsAppendNamedColor
-cmsBFDdeltaE = cmsBFDdeltaE
-cmsBuildGamma = cmsBuildGamma
-cmsBuildParametricToneCurve = cmsBuildParametricToneCurve
-cmsBuildSegmentedToneCurve = cmsBuildSegmentedToneCurve
-cmsBuildTabulatedToneCurve16 = cmsBuildTabulatedToneCurve16
-cmsBuildTabulatedToneCurveFloat = cmsBuildTabulatedToneCurveFloat
-_cmsCalloc = _cmsCalloc
-cmsChannelsOf = cmsChannelsOf
-cmsCIE2000DeltaE = cmsCIE2000DeltaE
-cmsCIE94DeltaE = cmsCIE94DeltaE
-cmsCIECAM02Done = cmsCIECAM02Done
-cmsCIECAM02Forward = cmsCIECAM02Forward
-cmsCIECAM02Init = cmsCIECAM02Init
-cmsCIECAM02Reverse = cmsCIECAM02Reverse
-cmsCloseIOhandler = cmsCloseIOhandler
-cmsCloseProfile = cmsCloseProfile
-cmsCMCdeltaE = cmsCMCdeltaE
-cmsCreate_sRGBProfile = cmsCreate_sRGBProfile
-cmsCreate_sRGBProfileTHR = cmsCreate_sRGBProfileTHR
-cmsCreateBCHSWabstractProfile = cmsCreateBCHSWabstractProfile
-cmsCreateBCHSWabstractProfileTHR = cmsCreateBCHSWabstractProfileTHR
-cmsCreateExtendedTransform = cmsCreateExtendedTransform
-cmsCreateGrayProfile = cmsCreateGrayProfile
-cmsCreateGrayProfileTHR = cmsCreateGrayProfileTHR
-cmsCreateInkLimitingDeviceLink = cmsCreateInkLimitingDeviceLink
-cmsCreateInkLimitingDeviceLinkTHR = cmsCreateInkLimitingDeviceLinkTHR
-cmsCreateLab2Profile = cmsCreateLab2Profile
-cmsCreateLab2ProfileTHR = cmsCreateLab2ProfileTHR
-cmsCreateLab4Profile = cmsCreateLab4Profile
-cmsCreateLab4ProfileTHR = cmsCreateLab4ProfileTHR
-cmsCreateLinearizationDeviceLink = cmsCreateLinearizationDeviceLink
-cmsCreateLinearizationDeviceLinkTHR = cmsCreateLinearizationDeviceLinkTHR
-cmsCreateMultiprofileTransform = cmsCreateMultiprofileTransform
-cmsCreateMultiprofileTransformTHR = cmsCreateMultiprofileTransformTHR
-cmsCreateNULLProfile = cmsCreateNULLProfile
-cmsCreateNULLProfileTHR = cmsCreateNULLProfileTHR
-cmsCreateProfilePlaceholder = cmsCreateProfilePlaceholder
-cmsCreateProofingTransform = cmsCreateProofingTransform
-cmsCreateProofingTransformTHR = cmsCreateProofingTransformTHR
-cmsCreateRGBProfile = cmsCreateRGBProfile
-cmsCreateRGBProfileTHR = cmsCreateRGBProfileTHR
-cmsCreateTransform = cmsCreateTransform
-cmsCreateTransformTHR = cmsCreateTransformTHR
-cmsCreateXYZProfile = cmsCreateXYZProfile
-cmsCreateXYZProfileTHR = cmsCreateXYZProfileTHR
-cmsD50_xyY = cmsD50_xyY
-cmsD50_XYZ = cmsD50_XYZ
-_cmsDecodeDateTimeNumber = _cmsDecodeDateTimeNumber
-_cmsDefaultICCintents = _cmsDefaultICCintents
-cmsDeleteTransform = cmsDeleteTransform
-cmsDeltaE = cmsDeltaE
-cmsDetectBlackPoint = cmsDetectBlackPoint
-cmsDetectTAC = cmsDetectTAC
-cmsDesaturateLab = cmsDesaturateLab
-cmsDoTransform = cmsDoTransform
-_cmsDoubleTo15Fixed16 = _cmsDoubleTo15Fixed16
-_cmsDoubleTo8Fixed8 = _cmsDoubleTo8Fixed8
-_cmsDupMem = _cmsDupMem
-cmsDupNamedColorList = cmsDupNamedColorList
-cmsDupProfileSequenceDescription = cmsDupProfileSequenceDescription
-cmsDupToneCurve = cmsDupToneCurve
-_cmsEncodeDateTimeNumber = _cmsEncodeDateTimeNumber
-cmsEstimateGamma = cmsEstimateGamma
-cmsEvalToneCurve16 = cmsEvalToneCurve16
-cmsEvalToneCurveFloat = cmsEvalToneCurveFloat
-cmsfilelength = cmsfilelength
-cmsFloat2LabEncoded = cmsFloat2LabEncoded
-cmsFloat2LabEncodedV2 = cmsFloat2LabEncodedV2
-cmsFloat2XYZEncoded = cmsFloat2XYZEncoded
-cmsFormatterForColorspaceOfProfile = cmsFormatterForColorspaceOfProfile
-cmsFormatterForPCSOfProfile = cmsFormatterForPCSOfProfile
-_cmsFree = _cmsFree
-cmsFreeNamedColorList = cmsFreeNamedColorList
-cmsFreeProfileSequenceDescription = cmsFreeProfileSequenceDescription
-cmsFreeToneCurve = cmsFreeToneCurve
-cmsFreeToneCurveTriple = cmsFreeToneCurveTriple
-cmsGBDAlloc = cmsGBDAlloc
-cmsGBDFree = cmsGBDFree
-cmsGDBAddPoint = cmsGDBAddPoint
-cmsGDBCheckPoint = cmsGDBCheckPoint
-cmsGDBCompute = cmsGDBCompute
-cmsGetAlarmCodes = cmsGetAlarmCodes
-cmsGetColorSpace = cmsGetColorSpace
-cmsGetDeviceClass = cmsGetDeviceClass
-cmsGetEncodedICCversion = cmsGetEncodedICCversion
-cmsGetHeaderAttributes = cmsGetHeaderAttributes
-cmsGetHeaderCreationDateTime = cmsGetHeaderCreationDateTime
-cmsGetHeaderFlags = cmsGetHeaderFlags
-cmsGetHeaderManufacturer = cmsGetHeaderManufacturer
-cmsGetHeaderModel = cmsGetHeaderModel
-cmsGetHeaderProfileID = cmsGetHeaderProfileID
-cmsGetHeaderRenderingIntent = cmsGetHeaderRenderingIntent
-cmsGetNamedColorList = cmsGetNamedColorList
-cmsGetPCS = cmsGetPCS
-cmsGetPostScriptColorResource = cmsGetPostScriptColorResource
-cmsGetPostScriptCRD = cmsGetPostScriptCRD
-cmsGetPostScriptCSA = cmsGetPostScriptCSA
-cmsGetProfileInfo = cmsGetProfileInfo
-cmsGetProfileInfoASCII = cmsGetProfileInfoASCII
-cmsGetProfileContextID = cmsGetProfileContextID
-cmsGetProfileVersion = cmsGetProfileVersion
-cmsGetSupportedIntents = cmsGetSupportedIntents
-cmsGetTagCount = cmsGetTagCount
-cmsGetTagSignature = cmsGetTagSignature
-cmsGetTransformContextID = cmsGetTransformContextID
-_cmsICCcolorSpace = _cmsICCcolorSpace
-_cmsIOPrintf = _cmsIOPrintf
-cmsIsCLUT = cmsIsCLUT
-cmsIsIntentSupported = cmsIsIntentSupported
-cmsIsMatrixShaper = cmsIsMatrixShaper
-cmsIsTag = cmsIsTag
-cmsIsToneCurveDescending = cmsIsToneCurveDescending
-cmsIsToneCurveLinear = cmsIsToneCurveLinear
-cmsIsToneCurveMonotonic = cmsIsToneCurveMonotonic
-cmsIsToneCurveMultisegment = cmsIsToneCurveMultisegment
-cmsGetToneCurveParametricType = cmsGetToneCurveParametricType
-cmsIT8Alloc = cmsIT8Alloc
-cmsIT8DefineDblFormat = cmsIT8DefineDblFormat
-cmsIT8EnumDataFormat = cmsIT8EnumDataFormat
-cmsIT8EnumProperties = cmsIT8EnumProperties
-cmsIT8Free = cmsIT8Free
-cmsIT8GetData = cmsIT8GetData
-cmsIT8GetDataDbl = cmsIT8GetDataDbl
-cmsIT8FindDataFormat = cmsIT8FindDataFormat
-cmsIT8GetDataRowCol = cmsIT8GetDataRowCol
-cmsIT8GetDataRowColDbl = cmsIT8GetDataRowColDbl
-cmsIT8GetPatchName = cmsIT8GetPatchName
-cmsIT8GetProperty = cmsIT8GetProperty
-cmsIT8GetPropertyDbl = cmsIT8GetPropertyDbl
-cmsIT8GetSheetType = cmsIT8GetSheetType
-cmsIT8LoadFromFile = cmsIT8LoadFromFile
-cmsIT8LoadFromMem = cmsIT8LoadFromMem
-cmsIT8SaveToFile = cmsIT8SaveToFile
-cmsIT8SaveToMem = cmsIT8SaveToMem
-cmsIT8SetComment = cmsIT8SetComment
-cmsIT8SetData = cmsIT8SetData
-cmsIT8SetDataDbl = cmsIT8SetDataDbl
-cmsIT8SetDataFormat = cmsIT8SetDataFormat
-cmsIT8SetDataRowCol = cmsIT8SetDataRowCol
-cmsIT8SetDataRowColDbl = cmsIT8SetDataRowColDbl
-cmsIT8SetPropertyDbl = cmsIT8SetPropertyDbl
-cmsIT8SetPropertyHex = cmsIT8SetPropertyHex
-cmsIT8SetPropertyStr = cmsIT8SetPropertyStr
-cmsIT8SetPropertyUncooked = cmsIT8SetPropertyUncooked
-cmsIT8SetSheetType = cmsIT8SetSheetType
-cmsIT8SetTable = cmsIT8SetTable
-cmsIT8SetTableByLabel = cmsIT8SetTableByLabel
-cmsIT8TableCount = cmsIT8TableCount
-cmsJoinToneCurve = cmsJoinToneCurve
-cmsLab2LCh = cmsLab2LCh
-cmsLab2XYZ = cmsLab2XYZ
-cmsLabEncoded2Float = cmsLabEncoded2Float
-cmsLabEncoded2FloatV2 = cmsLabEncoded2FloatV2
-cmsLCh2Lab = cmsLCh2Lab
-_cmsLCMScolorSpace = _cmsLCMScolorSpace
-cmsLinkTag = cmsLinkTag
-cmsPipelineAlloc = cmsPipelineAlloc
-cmsPipelineCat = cmsPipelineCat
-cmsPipelineCheckAndRetreiveStages = cmsPipelineCheckAndRetreiveStages
-cmsPipelineDup = cmsPipelineDup
-cmsPipelineStageCount = cmsPipelineStageCount
-cmsPipelineEval16 = cmsPipelineEval16
-cmsPipelineEvalFloat = cmsPipelineEvalFloat
-cmsPipelineEvalReverseFloat = cmsPipelineEvalReverseFloat
-cmsPipelineFree = cmsPipelineFree
-cmsPipelineGetPtrToFirstStage = cmsPipelineGetPtrToFirstStage
-cmsPipelineGetPtrToLastStage = cmsPipelineGetPtrToLastStage
-cmsPipelineInputChannels = cmsPipelineInputChannels
-cmsPipelineInsertStage = cmsPipelineInsertStage
-cmsPipelineOutputChannels = cmsPipelineOutputChannels
-cmsPipelineSetSaveAs8bitsFlag = cmsPipelineSetSaveAs8bitsFlag
-_cmsPipelineSetOptimizationParameters = _cmsPipelineSetOptimizationParameters
-cmsPipelineUnlinkStage = cmsPipelineUnlinkStage
-_cmsMalloc = _cmsMalloc
-_cmsMallocZero = _cmsMallocZero
-_cmsMAT3eval = _cmsMAT3eval
-_cmsMAT3identity = _cmsMAT3identity
-_cmsMAT3inverse = _cmsMAT3inverse
-_cmsMAT3isIdentity = _cmsMAT3isIdentity
-_cmsMAT3per = _cmsMAT3per
-_cmsMAT3solve = _cmsMAT3solve
-cmsMD5computeID = cmsMD5computeID
-cmsMLUalloc = cmsMLUalloc
-cmsMLUdup = cmsMLUdup
-cmsMLUfree = cmsMLUfree
-cmsMLUgetASCII = cmsMLUgetASCII
-cmsMLUgetTranslation = cmsMLUgetTranslation
-cmsMLUgetWide = cmsMLUgetWide
-cmsMLUsetASCII = cmsMLUsetASCII
-cmsMLUsetWide = cmsMLUsetWide
-cmsStageAllocCLut16bit = cmsStageAllocCLut16bit
-cmsStageAllocCLut16bitGranular = cmsStageAllocCLut16bitGranular
-cmsStageAllocCLutFloat = cmsStageAllocCLutFloat
-cmsStageAllocCLutFloatGranular = cmsStageAllocCLutFloatGranular
-cmsStageAllocToneCurves = cmsStageAllocToneCurves
-cmsStageAllocIdentity = cmsStageAllocIdentity
-cmsStageAllocMatrix = cmsStageAllocMatrix
-_cmsStageAllocPlaceholder = _cmsStageAllocPlaceholder
-cmsStageDup = cmsStageDup
-cmsStageFree = cmsStageFree
-cmsStageNext = cmsStageNext
-cmsStageInputChannels = cmsStageInputChannels
-cmsStageOutputChannels = cmsStageOutputChannels
-cmsStageSampleCLut16bit = cmsStageSampleCLut16bit
-cmsStageSampleCLutFloat = cmsStageSampleCLutFloat
-cmsStageType = cmsStageType
-cmsStageData = cmsStageData
-cmsNamedColorCount = cmsNamedColorCount
-cmsNamedColorIndex = cmsNamedColorIndex
-cmsNamedColorInfo = cmsNamedColorInfo
-cmsOpenIOhandlerFromFile = cmsOpenIOhandlerFromFile
-cmsOpenIOhandlerFromMem = cmsOpenIOhandlerFromMem
-cmsOpenIOhandlerFromNULL = cmsOpenIOhandlerFromNULL
-cmsOpenIOhandlerFromStream = cmsOpenIOhandlerFromStream
-cmsOpenProfileFromFile = cmsOpenProfileFromFile
-cmsOpenProfileFromFileTHR = cmsOpenProfileFromFileTHR
-cmsOpenProfileFromIOhandlerTHR = cmsOpenProfileFromIOhandlerTHR
-cmsOpenProfileFromMem = cmsOpenProfileFromMem
-cmsOpenProfileFromMemTHR = cmsOpenProfileFromMemTHR
-cmsOpenProfileFromStream = cmsOpenProfileFromStream
-cmsOpenProfileFromStreamTHR = cmsOpenProfileFromStreamTHR
-cmsPlugin = cmsPlugin
-_cmsRead15Fixed16Number = _cmsRead15Fixed16Number
-_cmsReadAlignment = _cmsReadAlignment
-_cmsReadFloat32Number = _cmsReadFloat32Number
-cmsReadRawTag = cmsReadRawTag
-cmsReadTag = cmsReadTag
-_cmsReadTypeBase = _cmsReadTypeBase
-_cmsReadUInt16Array = _cmsReadUInt16Array
-_cmsReadUInt16Number = _cmsReadUInt16Number
-_cmsReadUInt32Number = _cmsReadUInt32Number
-_cmsReadUInt64Number = _cmsReadUInt64Number
-_cmsReadUInt8Number = _cmsReadUInt8Number
-_cmsReadXYZNumber = _cmsReadXYZNumber
-_cmsRealloc = _cmsRealloc
-cmsReverseToneCurve = cmsReverseToneCurve
-cmsReverseToneCurveEx = cmsReverseToneCurveEx
-cmsSaveProfileToFile = cmsSaveProfileToFile
-cmsSaveProfileToIOhandler = cmsSaveProfileToIOhandler
-cmsSaveProfileToMem = cmsSaveProfileToMem
-cmsSaveProfileToStream = cmsSaveProfileToStream
-cmsSetAdaptationState = cmsSetAdaptationState
-cmsSetAlarmCodes = cmsSetAlarmCodes
-cmsSetColorSpace = cmsSetColorSpace
-cmsSetDeviceClass = cmsSetDeviceClass
-cmsSetEncodedICCversion = cmsSetEncodedICCversion
-cmsSetHeaderAttributes = cmsSetHeaderAttributes
-cmsSetHeaderFlags = cmsSetHeaderFlags
-cmsSetHeaderManufacturer = cmsSetHeaderManufacturer
-cmsSetHeaderModel = cmsSetHeaderModel
-cmsSetHeaderProfileID = cmsSetHeaderProfileID
-cmsSetHeaderRenderingIntent = cmsSetHeaderRenderingIntent
-cmsSetLogErrorHandler = cmsSetLogErrorHandler
-cmsSetPCS = cmsSetPCS
-cmsSetProfileVersion = cmsSetProfileVersion
-cmsSignalError = cmsSignalError
-cmsSmoothToneCurve = cmsSmoothToneCurve
-cmsstrcasecmp = cmsstrcasecmp
-cmsTempFromWhitePoint = cmsTempFromWhitePoint
-cmsTransform2DeviceLink = cmsTransform2DeviceLink
-cmsUnregisterPlugins = cmsUnregisterPlugins
-_cmsVEC3cross = _cmsVEC3cross
-_cmsVEC3distance = _cmsVEC3distance
-_cmsVEC3dot = _cmsVEC3dot
-_cmsVEC3init = _cmsVEC3init
-_cmsVEC3length = _cmsVEC3length
-_cmsVEC3minus = _cmsVEC3minus
-cmsWhitePointFromTemp = cmsWhitePointFromTemp
-_cmsWrite15Fixed16Number = _cmsWrite15Fixed16Number
-_cmsWriteAlignment = _cmsWriteAlignment
-_cmsWriteFloat32Number = _cmsWriteFloat32Number
-cmsWriteRawTag = cmsWriteRawTag
-cmsWriteTag = cmsWriteTag
-_cmsWriteTypeBase = _cmsWriteTypeBase
-_cmsWriteUInt16Array = _cmsWriteUInt16Array
-_cmsWriteUInt16Number = _cmsWriteUInt16Number
-_cmsWriteUInt32Number = _cmsWriteUInt32Number
-_cmsWriteUInt64Number = _cmsWriteUInt64Number
-_cmsWriteUInt8Number = _cmsWriteUInt8Number
-_cmsWriteXYZNumber = _cmsWriteXYZNumber
-cmsxyY2XYZ = cmsxyY2XYZ
-cmsXYZ2Lab = cmsXYZ2Lab
-cmsXYZ2xyY = cmsXYZ2xyY
-cmsXYZEncoded2Float = cmsXYZEncoded2Float
-cmsSliceSpace16 = cmsSliceSpace16
-cmsSliceSpaceFloat = cmsSliceSpaceFloat
-cmsChangeBuffersFormat = cmsChangeBuffersFormat
+LIBRARY LCMS2.DLL\r
+\r
+EXPORTS\r
+\r
+_cms15Fixed16toDouble = _cms15Fixed16toDouble\r
+_cms8Fixed8toDouble = _cms8Fixed8toDouble\r
+cmsAdaptToIlluminant = cmsAdaptToIlluminant\r
+_cmsAdjustEndianess16 = _cmsAdjustEndianess16\r
+_cmsAdjustEndianess32 = _cmsAdjustEndianess32\r
+_cmsAdjustEndianess64 = _cmsAdjustEndianess64\r
+cmsAllocNamedColorList = cmsAllocNamedColorList\r
+cmsAllocProfileSequenceDescription = cmsAllocProfileSequenceDescription\r
+cmsAppendNamedColor = cmsAppendNamedColor\r
+cmsBFDdeltaE = cmsBFDdeltaE\r
+cmsBuildGamma = cmsBuildGamma\r
+cmsBuildParametricToneCurve = cmsBuildParametricToneCurve\r
+cmsBuildSegmentedToneCurve = cmsBuildSegmentedToneCurve\r
+cmsBuildTabulatedToneCurve16 = cmsBuildTabulatedToneCurve16\r
+cmsBuildTabulatedToneCurveFloat = cmsBuildTabulatedToneCurveFloat\r
+_cmsCalloc = _cmsCalloc\r
+cmsChannelsOf = cmsChannelsOf\r
+cmsCIE2000DeltaE = cmsCIE2000DeltaE\r
+cmsCIE94DeltaE = cmsCIE94DeltaE\r
+cmsCIECAM02Done = cmsCIECAM02Done\r
+cmsCIECAM02Forward = cmsCIECAM02Forward\r
+cmsCIECAM02Init = cmsCIECAM02Init\r
+cmsCIECAM02Reverse = cmsCIECAM02Reverse\r
+cmsCloseIOhandler = cmsCloseIOhandler\r
+cmsCloseProfile = cmsCloseProfile\r
+cmsCMCdeltaE = cmsCMCdeltaE\r
+cmsCreate_sRGBProfile = cmsCreate_sRGBProfile\r
+cmsCreate_sRGBProfileTHR = cmsCreate_sRGBProfileTHR\r
+cmsCreateBCHSWabstractProfile = cmsCreateBCHSWabstractProfile\r
+cmsCreateBCHSWabstractProfileTHR = cmsCreateBCHSWabstractProfileTHR\r
+cmsCreateExtendedTransform = cmsCreateExtendedTransform\r
+cmsCreateGrayProfile = cmsCreateGrayProfile\r
+cmsCreateGrayProfileTHR = cmsCreateGrayProfileTHR\r
+cmsCreateInkLimitingDeviceLink = cmsCreateInkLimitingDeviceLink\r
+cmsCreateInkLimitingDeviceLinkTHR = cmsCreateInkLimitingDeviceLinkTHR\r
+cmsCreateLab2Profile = cmsCreateLab2Profile\r
+cmsCreateLab2ProfileTHR = cmsCreateLab2ProfileTHR\r
+cmsCreateLab4Profile = cmsCreateLab4Profile\r
+cmsCreateLab4ProfileTHR = cmsCreateLab4ProfileTHR\r
+cmsCreateLinearizationDeviceLink = cmsCreateLinearizationDeviceLink\r
+cmsCreateLinearizationDeviceLinkTHR = cmsCreateLinearizationDeviceLinkTHR\r
+cmsCreateMultiprofileTransform = cmsCreateMultiprofileTransform\r
+cmsCreateMultiprofileTransformTHR = cmsCreateMultiprofileTransformTHR\r
+cmsCreateNULLProfile = cmsCreateNULLProfile\r
+cmsCreateNULLProfileTHR = cmsCreateNULLProfileTHR\r
+cmsCreateProfilePlaceholder = cmsCreateProfilePlaceholder\r
+cmsCreateProofingTransform = cmsCreateProofingTransform\r
+cmsCreateProofingTransformTHR = cmsCreateProofingTransformTHR\r
+cmsCreateRGBProfile = cmsCreateRGBProfile\r
+cmsCreateRGBProfileTHR = cmsCreateRGBProfileTHR\r
+cmsCreateTransform = cmsCreateTransform\r
+cmsCreateTransformTHR = cmsCreateTransformTHR\r
+cmsCreateXYZProfile = cmsCreateXYZProfile\r
+cmsCreateXYZProfileTHR = cmsCreateXYZProfileTHR\r
+cmsD50_xyY = cmsD50_xyY\r
+cmsD50_XYZ = cmsD50_XYZ\r
+_cmsDecodeDateTimeNumber = _cmsDecodeDateTimeNumber\r
+_cmsDefaultICCintents = _cmsDefaultICCintents\r
+cmsDeleteTransform = cmsDeleteTransform\r
+cmsDeltaE = cmsDeltaE\r
+cmsDetectBlackPoint = cmsDetectBlackPoint\r
+cmsDetectDestinationBlackPoint = cmsDetectDestinationBlackPoint\r
+cmsDetectTAC = cmsDetectTAC\r
+cmsDesaturateLab = cmsDesaturateLab\r
+cmsDoTransform = cmsDoTransform\r
+cmsDoTransformStride = cmsDoTransformStride\r
+_cmsDoubleTo15Fixed16 = _cmsDoubleTo15Fixed16\r
+_cmsDoubleTo8Fixed8 = _cmsDoubleTo8Fixed8\r
+_cmsDupMem = _cmsDupMem\r
+cmsDupNamedColorList = cmsDupNamedColorList\r
+cmsDupProfileSequenceDescription = cmsDupProfileSequenceDescription\r
+cmsDupToneCurve = cmsDupToneCurve\r
+_cmsEncodeDateTimeNumber = _cmsEncodeDateTimeNumber\r
+cmsEstimateGamma = cmsEstimateGamma\r
+cmsGetToneCurveEstimatedTableEntries = cmsGetToneCurveEstimatedTableEntries\r
+cmsGetToneCurveEstimatedTable = cmsGetToneCurveEstimatedTable\r
+cmsEvalToneCurve16 = cmsEvalToneCurve16\r
+cmsEvalToneCurveFloat = cmsEvalToneCurveFloat\r
+cmsfilelength = cmsfilelength\r
+cmsFloat2LabEncoded = cmsFloat2LabEncoded\r
+cmsFloat2LabEncodedV2 = cmsFloat2LabEncodedV2\r
+cmsFloat2XYZEncoded = cmsFloat2XYZEncoded\r
+cmsFormatterForColorspaceOfProfile = cmsFormatterForColorspaceOfProfile\r
+cmsFormatterForPCSOfProfile = cmsFormatterForPCSOfProfile\r
+_cmsFree = _cmsFree\r
+cmsFreeNamedColorList = cmsFreeNamedColorList\r
+cmsFreeProfileSequenceDescription = cmsFreeProfileSequenceDescription\r
+cmsFreeToneCurve = cmsFreeToneCurve\r
+cmsFreeToneCurveTriple = cmsFreeToneCurveTriple\r
+cmsGBDAlloc = cmsGBDAlloc\r
+cmsGBDFree = cmsGBDFree\r
+cmsGDBAddPoint = cmsGDBAddPoint\r
+cmsGDBCheckPoint = cmsGDBCheckPoint\r
+cmsGDBCompute = cmsGDBCompute\r
+cmsGetAlarmCodes = cmsGetAlarmCodes\r
+cmsGetColorSpace = cmsGetColorSpace\r
+cmsGetDeviceClass = cmsGetDeviceClass\r
+cmsGetEncodedICCversion = cmsGetEncodedICCversion\r
+cmsGetHeaderAttributes = cmsGetHeaderAttributes\r
+cmsGetHeaderCreationDateTime = cmsGetHeaderCreationDateTime\r
+cmsGetHeaderFlags = cmsGetHeaderFlags\r
+cmsGetHeaderManufacturer = cmsGetHeaderManufacturer\r
+cmsGetHeaderModel = cmsGetHeaderModel\r
+cmsGetHeaderProfileID = cmsGetHeaderProfileID\r
+cmsGetHeaderRenderingIntent = cmsGetHeaderRenderingIntent\r
+cmsGetNamedColorList = cmsGetNamedColorList\r
+cmsGetPCS = cmsGetPCS\r
+cmsGetPostScriptColorResource = cmsGetPostScriptColorResource\r
+cmsGetPostScriptCRD = cmsGetPostScriptCRD\r
+cmsGetPostScriptCSA = cmsGetPostScriptCSA\r
+cmsGetProfileInfo = cmsGetProfileInfo\r
+cmsGetProfileInfoASCII = cmsGetProfileInfoASCII\r
+cmsGetProfileContextID = cmsGetProfileContextID\r
+cmsGetProfileVersion = cmsGetProfileVersion\r
+cmsGetSupportedIntents = cmsGetSupportedIntents\r
+cmsGetTagCount = cmsGetTagCount\r
+cmsGetTagSignature = cmsGetTagSignature\r
+cmsGetTransformContextID = cmsGetTransformContextID\r
+_cmsICCcolorSpace = _cmsICCcolorSpace\r
+_cmsIOPrintf = _cmsIOPrintf\r
+cmsIsCLUT = cmsIsCLUT\r
+cmsIsIntentSupported = cmsIsIntentSupported\r
+cmsIsMatrixShaper = cmsIsMatrixShaper\r
+cmsIsTag = cmsIsTag\r
+cmsIsToneCurveDescending = cmsIsToneCurveDescending\r
+cmsIsToneCurveLinear = cmsIsToneCurveLinear\r
+cmsIsToneCurveMonotonic = cmsIsToneCurveMonotonic\r
+cmsIsToneCurveMultisegment = cmsIsToneCurveMultisegment\r
+cmsGetToneCurveParametricType = cmsGetToneCurveParametricType\r
+cmsIT8Alloc = cmsIT8Alloc\r
+cmsIT8DefineDblFormat = cmsIT8DefineDblFormat\r
+cmsIT8EnumDataFormat = cmsIT8EnumDataFormat\r
+cmsIT8EnumProperties = cmsIT8EnumProperties\r
+cmsIT8EnumPropertyMulti = cmsIT8EnumPropertyMulti\r
+cmsIT8Free = cmsIT8Free\r
+cmsIT8GetData = cmsIT8GetData\r
+cmsIT8GetDataDbl = cmsIT8GetDataDbl\r
+cmsIT8FindDataFormat = cmsIT8FindDataFormat\r
+cmsIT8GetDataRowCol = cmsIT8GetDataRowCol\r
+cmsIT8GetDataRowColDbl = cmsIT8GetDataRowColDbl\r
+cmsIT8GetPatchName = cmsIT8GetPatchName\r
+cmsIT8GetPatchByName = cmsIT8GetPatchByName\r
+cmsIT8GetProperty = cmsIT8GetProperty\r
+cmsIT8GetPropertyDbl = cmsIT8GetPropertyDbl\r
+cmsIT8GetPropertyMulti = cmsIT8GetPropertyMulti\r
+cmsIT8GetSheetType = cmsIT8GetSheetType\r
+cmsIT8LoadFromFile = cmsIT8LoadFromFile\r
+cmsIT8LoadFromMem = cmsIT8LoadFromMem\r
+cmsIT8SaveToFile = cmsIT8SaveToFile\r
+cmsIT8SaveToMem = cmsIT8SaveToMem\r
+cmsIT8SetComment = cmsIT8SetComment\r
+cmsIT8SetData = cmsIT8SetData\r
+cmsIT8SetDataDbl = cmsIT8SetDataDbl\r
+cmsIT8SetDataFormat = cmsIT8SetDataFormat\r
+cmsIT8SetDataRowCol = cmsIT8SetDataRowCol\r
+cmsIT8SetDataRowColDbl = cmsIT8SetDataRowColDbl\r
+cmsIT8SetPropertyDbl = cmsIT8SetPropertyDbl\r
+cmsIT8SetPropertyHex = cmsIT8SetPropertyHex\r
+cmsIT8SetPropertyStr = cmsIT8SetPropertyStr\r
+cmsIT8SetPropertyMulti = cmsIT8SetPropertyMulti\r
+cmsIT8SetPropertyUncooked = cmsIT8SetPropertyUncooked\r
+cmsIT8SetSheetType = cmsIT8SetSheetType\r
+cmsIT8SetTable = cmsIT8SetTable\r
+cmsIT8SetTableByLabel = cmsIT8SetTableByLabel\r
+cmsIT8SetIndexColumn = cmsIT8SetIndexColumn\r
+cmsIT8TableCount = cmsIT8TableCount\r
+cmsJoinToneCurve = cmsJoinToneCurve\r
+cmsLab2LCh = cmsLab2LCh\r
+cmsLab2XYZ = cmsLab2XYZ\r
+cmsLabEncoded2Float = cmsLabEncoded2Float\r
+cmsLabEncoded2FloatV2 = cmsLabEncoded2FloatV2\r
+cmsLCh2Lab = cmsLCh2Lab\r
+_cmsLCMScolorSpace = _cmsLCMScolorSpace\r
+cmsLinkTag = cmsLinkTag\r
+cmsTagLinkedTo = cmsTagLinkedTo\r
+cmsPipelineAlloc = cmsPipelineAlloc\r
+cmsPipelineCat = cmsPipelineCat\r
+cmsPipelineCheckAndRetreiveStages = cmsPipelineCheckAndRetreiveStages\r
+cmsPipelineDup = cmsPipelineDup\r
+cmsPipelineStageCount = cmsPipelineStageCount\r
+cmsPipelineEval16 = cmsPipelineEval16\r
+cmsPipelineEvalFloat = cmsPipelineEvalFloat\r
+cmsPipelineEvalReverseFloat = cmsPipelineEvalReverseFloat\r
+cmsPipelineFree = cmsPipelineFree\r
+cmsPipelineGetPtrToFirstStage = cmsPipelineGetPtrToFirstStage\r
+cmsPipelineGetPtrToLastStage = cmsPipelineGetPtrToLastStage\r
+cmsPipelineInputChannels = cmsPipelineInputChannels\r
+cmsPipelineInsertStage = cmsPipelineInsertStage\r
+cmsPipelineOutputChannels = cmsPipelineOutputChannels\r
+cmsPipelineSetSaveAs8bitsFlag = cmsPipelineSetSaveAs8bitsFlag\r
+_cmsPipelineSetOptimizationParameters = _cmsPipelineSetOptimizationParameters\r
+cmsPipelineUnlinkStage = cmsPipelineUnlinkStage\r
+_cmsMalloc = _cmsMalloc\r
+_cmsMallocZero = _cmsMallocZero\r
+_cmsMAT3eval = _cmsMAT3eval\r
+_cmsMAT3identity = _cmsMAT3identity\r
+_cmsMAT3inverse = _cmsMAT3inverse\r
+_cmsMAT3isIdentity = _cmsMAT3isIdentity\r
+_cmsMAT3per = _cmsMAT3per\r
+_cmsMAT3solve = _cmsMAT3solve\r
+cmsMD5computeID = cmsMD5computeID\r
+cmsMLUalloc = cmsMLUalloc\r
+cmsMLUdup = cmsMLUdup\r
+cmsMLUfree = cmsMLUfree\r
+cmsMLUgetASCII = cmsMLUgetASCII\r
+cmsMLUgetTranslation = cmsMLUgetTranslation\r
+cmsMLUgetWide = cmsMLUgetWide\r
+cmsMLUsetASCII = cmsMLUsetASCII\r
+cmsMLUsetWide = cmsMLUsetWide\r
+cmsStageAllocCLut16bit = cmsStageAllocCLut16bit\r
+cmsStageAllocCLut16bitGranular = cmsStageAllocCLut16bitGranular\r
+cmsStageAllocCLutFloat = cmsStageAllocCLutFloat\r
+cmsStageAllocCLutFloatGranular = cmsStageAllocCLutFloatGranular\r
+cmsStageAllocToneCurves = cmsStageAllocToneCurves\r
+cmsStageAllocIdentity = cmsStageAllocIdentity\r
+cmsStageAllocMatrix = cmsStageAllocMatrix\r
+_cmsStageAllocPlaceholder = _cmsStageAllocPlaceholder\r
+cmsStageDup = cmsStageDup\r
+cmsStageFree = cmsStageFree\r
+cmsStageNext = cmsStageNext\r
+cmsStageInputChannels = cmsStageInputChannels\r
+cmsStageOutputChannels = cmsStageOutputChannels\r
+cmsStageSampleCLut16bit = cmsStageSampleCLut16bit\r
+cmsStageSampleCLutFloat = cmsStageSampleCLutFloat\r
+cmsStageType = cmsStageType\r
+cmsStageData = cmsStageData\r
+cmsNamedColorCount = cmsNamedColorCount\r
+cmsNamedColorIndex = cmsNamedColorIndex\r
+cmsNamedColorInfo = cmsNamedColorInfo\r
+cmsOpenIOhandlerFromFile = cmsOpenIOhandlerFromFile\r
+cmsOpenIOhandlerFromMem = cmsOpenIOhandlerFromMem\r
+cmsOpenIOhandlerFromNULL = cmsOpenIOhandlerFromNULL\r
+cmsOpenIOhandlerFromStream = cmsOpenIOhandlerFromStream\r
+cmsOpenProfileFromFile = cmsOpenProfileFromFile\r
+cmsOpenProfileFromFileTHR = cmsOpenProfileFromFileTHR\r
+cmsOpenProfileFromIOhandlerTHR = cmsOpenProfileFromIOhandlerTHR\r
+cmsOpenProfileFromMem = cmsOpenProfileFromMem\r
+cmsOpenProfileFromMemTHR = cmsOpenProfileFromMemTHR\r
+cmsOpenProfileFromStream = cmsOpenProfileFromStream\r
+cmsOpenProfileFromStreamTHR = cmsOpenProfileFromStreamTHR\r
+cmsPlugin = cmsPlugin\r
+_cmsRead15Fixed16Number = _cmsRead15Fixed16Number\r
+_cmsReadAlignment = _cmsReadAlignment\r
+_cmsReadFloat32Number = _cmsReadFloat32Number\r
+cmsReadRawTag = cmsReadRawTag\r
+cmsReadTag = cmsReadTag\r
+_cmsReadTypeBase = _cmsReadTypeBase\r
+_cmsReadUInt16Array = _cmsReadUInt16Array\r
+_cmsReadUInt16Number = _cmsReadUInt16Number\r
+_cmsReadUInt32Number = _cmsReadUInt32Number\r
+_cmsReadUInt64Number = _cmsReadUInt64Number\r
+_cmsReadUInt8Number = _cmsReadUInt8Number\r
+_cmsReadXYZNumber = _cmsReadXYZNumber\r
+_cmsRealloc = _cmsRealloc\r
+cmsReverseToneCurve = cmsReverseToneCurve\r
+cmsReverseToneCurveEx = cmsReverseToneCurveEx\r
+cmsSaveProfileToFile = cmsSaveProfileToFile\r
+cmsSaveProfileToIOhandler = cmsSaveProfileToIOhandler\r
+cmsSaveProfileToMem = cmsSaveProfileToMem\r
+cmsSaveProfileToStream = cmsSaveProfileToStream\r
+cmsSetAdaptationState = cmsSetAdaptationState\r
+cmsSetAlarmCodes = cmsSetAlarmCodes\r
+cmsSetColorSpace = cmsSetColorSpace\r
+cmsSetDeviceClass = cmsSetDeviceClass\r
+cmsSetEncodedICCversion = cmsSetEncodedICCversion\r
+cmsSetHeaderAttributes = cmsSetHeaderAttributes\r
+cmsSetHeaderFlags = cmsSetHeaderFlags\r
+cmsSetHeaderManufacturer = cmsSetHeaderManufacturer\r
+cmsSetHeaderModel = cmsSetHeaderModel\r
+cmsSetHeaderProfileID = cmsSetHeaderProfileID\r
+cmsSetHeaderRenderingIntent = cmsSetHeaderRenderingIntent\r
+cmsSetLogErrorHandler = cmsSetLogErrorHandler\r
+cmsSetPCS = cmsSetPCS\r
+cmsSetProfileVersion = cmsSetProfileVersion\r
+cmsSignalError = cmsSignalError\r
+cmsSmoothToneCurve = cmsSmoothToneCurve\r
+cmsstrcasecmp = cmsstrcasecmp\r
+cmsTempFromWhitePoint = cmsTempFromWhitePoint\r
+cmsTransform2DeviceLink = cmsTransform2DeviceLink\r
+cmsUnregisterPlugins = cmsUnregisterPlugins\r
+_cmsVEC3cross = _cmsVEC3cross\r
+_cmsVEC3distance = _cmsVEC3distance\r
+_cmsVEC3dot = _cmsVEC3dot\r
+_cmsVEC3init = _cmsVEC3init\r
+_cmsVEC3length = _cmsVEC3length\r
+_cmsVEC3minus = _cmsVEC3minus\r
+cmsWhitePointFromTemp = cmsWhitePointFromTemp\r
+_cmsWrite15Fixed16Number = _cmsWrite15Fixed16Number\r
+_cmsWriteAlignment = _cmsWriteAlignment\r
+_cmsWriteFloat32Number = _cmsWriteFloat32Number\r
+cmsWriteRawTag = cmsWriteRawTag\r
+cmsWriteTag = cmsWriteTag\r
+_cmsWriteTypeBase = _cmsWriteTypeBase\r
+_cmsWriteUInt16Array = _cmsWriteUInt16Array\r
+_cmsWriteUInt16Number = _cmsWriteUInt16Number\r
+_cmsWriteUInt32Number = _cmsWriteUInt32Number\r
+_cmsWriteUInt64Number = _cmsWriteUInt64Number\r
+_cmsWriteUInt8Number = _cmsWriteUInt8Number\r
+_cmsWriteXYZNumber = _cmsWriteXYZNumber\r
+cmsxyY2XYZ = cmsxyY2XYZ\r
+cmsXYZ2Lab = cmsXYZ2Lab\r
+cmsXYZ2xyY = cmsXYZ2xyY\r
+cmsXYZEncoded2Float = cmsXYZEncoded2Float\r
+cmsSliceSpace16 = cmsSliceSpace16\r
+cmsSliceSpaceFloat = cmsSliceSpaceFloat\r
+cmsChangeBuffersFormat = cmsChangeBuffersFormat\r
+cmsDictAlloc = cmsDictAlloc\r
+cmsDictFree = cmsDictFree\r
+cmsDictDup = cmsDictDup\r
+cmsDictAddEntry = cmsDictAddEntry\r
+cmsDictGetEntryList = cmsDictGetEntryList\r
+cmsDictNextEntry = cmsDictNextEntry\r
+_cmsGetTransformUserData = _cmsGetTransformUserData\r
+_cmsSetTransformUserData = _cmsSetTransformUserData\r
+_cmsGetTransformFormatters16 = _cmsGetTransformFormatters16\r
+_cmsGetTransformFormattersFloat = _cmsGetTransformFormattersFloat\r
+cmsGetHeaderCreator = cmsGetHeaderCreator\r
+cmsPluginTHR = cmsPluginTHR\r
+cmsGetPipelineContextID = cmsGetPipelineContextID\r
+cmsGetTransformInputFormat = cmsGetTransformInputFormat\r
+cmsGetTransformOutputFormat = cmsGetTransformOutputFormat\r
+cmsCreateContext = cmsCreateContext \r
+cmsDupContext = cmsDupContext \r
+cmsDeleteContext = cmsDeleteContext \r
+cmsGetContextUserData = cmsGetContextUserData \r
+cmsUnregisterPluginsTHR = cmsUnregisterPluginsTHR \r
+cmsSetAlarmCodesTHR = cmsSetAlarmCodesTHR \r
+cmsGetAlarmCodesTHR = cmsGetAlarmCodesTHR\r
+cmsSetAdaptationStateTHR = cmsSetAdaptationStateTHR\r
+cmsSetLogErrorHandlerTHR = cmsSetLogErrorHandlerTHR\r
+cmsGetSupportedIntentsTHR = cmsGetSupportedIntentsTHR\r
+cmsMLUtranslationsCount = cmsMLUtranslationsCount\r
+cmsMLUtranslationsCodes = cmsMLUtranslationsCodes\r
+_cmsCreateMutex = _cmsCreateMutex \r
+_cmsDestroyMutex = _cmsDestroyMutex\r
+_cmsLockMutex = _cmsLockMutex \r
+_cmsUnlockMutex = _cmsUnlockMutex
\ No newline at end of file
//
// Little Color Management System
-// Copyright (c) 1998-2010 Marti Maria Saguer
+// Copyright (c) 1998-2014 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
+// 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
+// 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
+// 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.
//
//---------------------------------------------------------------------------------
# define M_LOG10E 0.434294481903251827651
#endif
-// BorlandC 5.5 & Visual Studio 2003 are broken on that
-#if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1310))
+// BorlandC 5.5, VC2003 are broken on that
+#if defined(__BORLANDC__) || (_MSC_VER < 1400) // 1400 == VC++ 8.0
#define sinf(x) (float)sin((float)x)
#define sqrtf(x) (float)sqrt((float)x)
#endif
+
// Alignment of ICC file format uses 4 bytes (cmsUInt32Number)
-#define _cmsSIZEOFLONGMINUS1 (sizeof(cmsUInt32Number)-1)
-#define _cmsALIGNLONG(x) (((x)+_cmsSIZEOFLONGMINUS1) & ~(_cmsSIZEOFLONGMINUS1))
+#define _cmsALIGNLONG(x) (((x)+(sizeof(cmsUInt32Number)-1)) & ~(sizeof(cmsUInt32Number)-1))
+
+// Alignment to memory pointer
+#define _cmsALIGNMEM(x) (((x)+(sizeof(void *) - 1)) & ~(sizeof(void *) - 1))
// Maximum encodeable values in floating point
#define MAX_ENCODEABLE_XYZ (1.0 + 32767.0/32768.0)
#define MAX_ENCODEABLE_ab4 (127.0)
// Maximum of channels for internal pipeline evaluation
-#define MAX_STAGE_CHANNELS 128
+#define MAX_STAGE_CHANNELS 128
// Unused parameter warning supression
-#define cmsUNUSED_PARAMETER(x) ((void)x)
+#define cmsUNUSED_PARAMETER(x) ((void)x)
// The specification for "inline" is section 6.7.4 of the C99 standard (ISO/IEC 9899:1999).
// unfortunately VisualC++ does not conform that
# endif
#endif
-// Pthreads. In windows we use the native WIN32 API instead
-#ifdef CMS_DONT_USE_PTHREADS
-typedef int LCMS_RWLOCK_T;
-# define LCMS_CREATE_LOCK(x)
-# define LCMS_FREE_LOCK(x)
-# define LCMS_READ_LOCK(x)
-# define LCMS_WRITE_LOCK(x)
-# define LCMS_UNLOCK(x)
-#else
-#ifdef CMS_IS_WINDOWS_
-# ifndef WIN32_LEAN_AND_MEAN
-# define WIN32_LEAN_AND_MEAN
-# endif
-# include <windows.h>
- typedef CRITICAL_SECTION LCMS_RWLOCK_T;
-# define LCMS_CREATE_LOCK(x) InitializeCriticalSection((x))
-# define LCMS_FREE_LOCK(x) DeleteCriticalSection((x))
-# define LCMS_READ_LOCK(x) EnterCriticalSection((x))
-# define LCMS_WRITE_LOCK(x) EnterCriticalSection((x))
-# define LCMS_UNLOCK(x) LeaveCriticalSection((x))
-#else
-# include <pthread.h>
- typedef pthread_rwlock_t LCMS_RWLOCK_T;
-# define LCMS_CREATE_LOCK(x) pthread_rwlock_init((x), NULL)
-# define LCMS_FREE_LOCK(x) pthread_rwlock_destroy((x))
-# define LCMS_READ_LOCK(x) pthread_rwlock_rdlock((x))
-# define LCMS_WRITE_LOCK(x) pthread_rwlock_wrlock((x))
-# define LCMS_UNLOCK(x) pthread_rwlock_unlock((x))
-#endif
-#endif
// A fast way to convert from/to 16 <-> 8 bits
-#define FROM_8_TO_16(rgb) (cmsUInt16Number) ((((cmsUInt16Number) (rgb)) << 8)|(rgb))
+#define FROM_8_TO_16(rgb) (cmsUInt16Number) ((((cmsUInt16Number) (rgb)) << 8)|(rgb))
#define FROM_16_TO_8(rgb) (cmsUInt8Number) ((((rgb) * 65281 + 8388608) >> 24) & 0xFF)
// Code analysis is broken on asserts
#define ROUND_FIXED_TO_INT(x) (((x)+0x8000)>>16)
cmsINLINE cmsS15Fixed16Number _cmsToFixedDomain(int a) { return a + ((a + 0x7fff) / 0xffff); }
-cmsINLINE int _cmsFromFixedDomain(cmsS15Fixed16Number a) { return a - ((a + 0x7fff) >> 16); }
+cmsINLINE int _cmsFromFixedDomain(cmsS15Fixed16Number a) { return a - ((a + 0x7fff) >> 16); }
// -----------------------------------------------------------------------------------------------------------
-// Fast floor conversion logic. Thanks to Sree Kotay and Stuart Nixon
-// note than this only works in the range ..-32767...+32767 because
+// Fast floor conversion logic. Thanks to Sree Kotay and Stuart Nixon
+// note than this only works in the range ..-32767...+32767 because
// mantissa is interpreted as 15.16 fixed point.
// The union is to avoid pointer aliasing overoptimization.
cmsINLINE int _cmsQuickFloor(cmsFloat64Number val)
cmsFloat64Number val;
int halves[2];
} temp;
-
+
temp.val = val + _lcms_double2fixmagic;
-
+
#ifdef CMS_USE_BIG_ENDIAN
return temp.halves[1] >> 16;
#else
}
// Fast floor restricted to 0..65535.0
-cmsINLINE cmsUInt16Number _cmsQuickFloorWord(cmsFloat64Number d)
-{
- return (cmsUInt16Number) _cmsQuickFloor(d - 32767.0) + 32767U;
+cmsINLINE cmsUInt16Number _cmsQuickFloorWord(cmsFloat64Number d)
+{
+ return (cmsUInt16Number) _cmsQuickFloor(d - 32767.0) + 32767U;
}
// Floor to word, taking care of saturation
-cmsINLINE cmsUInt16Number _cmsQuickSaturateWord(cmsFloat64Number d)
+cmsINLINE cmsUInt16Number _cmsQuickSaturateWord(cmsFloat64Number d)
{
d += 0.5;
if (d <= 0) return 0;
return _cmsQuickFloorWord(d);
}
-// Plug-In registering ---------------------------------------------------------------
+
+// Pthread support --------------------------------------------------------------------
+#ifndef CMS_NO_PTHREADS
+
+// This is the threading support. Unfortunately, it has to be platform-dependent because
+// windows does not support pthreads.
+
+#ifdef CMS_IS_WINDOWS_
+
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+
+
+// From: http://locklessinc.com/articles/pthreads_on_windows/
+// The pthreads API has an initialization macro that has no correspondence to anything in
+// the windows API. By investigating the internal definition of the critical section type,
+// one may work out how to initialize one without calling InitializeCriticalSection().
+// The trick here is that InitializeCriticalSection() is not allowed to fail. It tries
+// to allocate a critical section debug object, but if no memory is available, it sets
+// the pointer to a specific value. (One would expect that value to be NULL, but it is
+// actually (void *)-1 for some reason.) Thus we can use this special value for that
+// pointer, and the critical section code will work.
+
+// The other important part of the critical section type to initialize is the number
+// of waiters. This controls whether or not the mutex is locked. Fortunately, this
+// part of the critical section is unlikely to change. Apparently, many programs
+// already test critical sections to see if they are locked using this value, so
+// Microsoft felt that it was necessary to keep it set at -1 for an unlocked critical
+// section, even when they changed the underlying algorithm to be more scalable.
+// The final parts of the critical section object are unimportant, and can be set
+// to zero for their defaults. This yields an initialization macro:
+
+typedef CRITICAL_SECTION _cmsMutex;
+
+#define CMS_MUTEX_INITIALIZER {(void*) -1,-1,0,0,0,0}
+
+cmsINLINE int _cmsLockPrimitive(_cmsMutex *m)
+{
+ EnterCriticalSection(m);
+ return 0;
+}
+
+cmsINLINE int _cmsUnlockPrimitive(_cmsMutex *m)
+{
+ LeaveCriticalSection(m);
+ return 0;
+}
+
+cmsINLINE int _cmsInitMutexPrimitive(_cmsMutex *m)
+{
+ InitializeCriticalSection(m);
+ return 0;
+}
+
+cmsINLINE int _cmsDestroyMutexPrimitive(_cmsMutex *m)
+{
+ DeleteCriticalSection(m);
+ return 0;
+}
+
+cmsINLINE int _cmsEnterCriticalSectionPrimitive(_cmsMutex *m)
+{
+ EnterCriticalSection(m);
+ return 0;
+}
+
+cmsINLINE int _cmsLeaveCriticalSectionPrimitive(_cmsMutex *m)
+{
+ LeaveCriticalSection(m);
+ return 0;
+}
+
+#else
+
+// Rest of the wide world
+#include <pthread.h>
+
+#define CMS_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+typedef pthread_mutex_t _cmsMutex;
+
+
+cmsINLINE int _cmsLockPrimitive(_cmsMutex *m)
+{
+ return pthread_mutex_lock(m);
+}
+
+cmsINLINE int _cmsUnlockPrimitive(_cmsMutex *m)
+{
+ return pthread_mutex_unlock(m);
+}
+
+cmsINLINE int _cmsInitMutexPrimitive(_cmsMutex *m)
+{
+ return pthread_mutex_init(m, NULL);
+}
+
+cmsINLINE int _cmsDestroyMutexPrimitive(_cmsMutex *m)
+{
+ return pthread_mutex_destroy(m);
+}
+
+cmsINLINE int _cmsEnterCriticalSectionPrimitive(_cmsMutex *m)
+{
+ return pthread_mutex_lock(m);
+}
+
+cmsINLINE int _cmsLeaveCriticalSectionPrimitive(_cmsMutex *m)
+{
+ return pthread_mutex_unlock(m);
+}
+
+#endif
+#else
+
+#define CMS_MUTEX_INITIALIZER 0
+typedef int _cmsMutex;
+
+
+cmsINLINE int _cmsLockPrimitive(_cmsMutex *m)
+{
+ return 0;
+ cmsUNUSED_PARAMETER(m);
+}
+
+cmsINLINE int _cmsUnlockPrimitive(_cmsMutex *m)
+{
+ return 0;
+ cmsUNUSED_PARAMETER(m);
+}
+
+cmsINLINE int _cmsInitMutexPrimitive(_cmsMutex *m)
+{
+ return 0;
+ cmsUNUSED_PARAMETER(m);
+}
+
+cmsINLINE int _cmsDestroyMutexPrimitive(_cmsMutex *m)
+{
+ return 0;
+ cmsUNUSED_PARAMETER(m);
+}
+
+cmsINLINE int _cmsEnterCriticalSectionPrimitive(_cmsMutex *m)
+{
+ return 0;
+ cmsUNUSED_PARAMETER(m);
+}
+
+cmsINLINE int _cmsLeaveCriticalSectionPrimitive(_cmsMutex *m)
+{
+ return 0;
+ cmsUNUSED_PARAMETER(m);
+}
+#endif
+
+// Plug-In registration ---------------------------------------------------------------
// Specialized function for plug-in memory management. No pairing free() since whole pool is freed at once.
-void* _cmsPluginMalloc(cmsUInt32Number size);
+void* _cmsPluginMalloc(cmsContext ContextID, cmsUInt32Number size);
// Memory management
-cmsBool _cmsRegisterMemHandlerPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Interpolation
-cmsBool _cmsRegisterInterpPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterInterpPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Parametric curves
-cmsBool _cmsRegisterParametricCurvesPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterParametricCurvesPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Formatters management
-cmsBool _cmsRegisterFormattersPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterFormattersPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Tag type management
-cmsBool _cmsRegisterTagTypePlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterTagTypePlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Tag management
-cmsBool _cmsRegisterTagPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterTagPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Intent management
-cmsBool _cmsRegisterRenderingIntentPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterRenderingIntentPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Multi Process elements
-cmsBool _cmsRegisterMultiProcessElementPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterMultiProcessElementPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// Optimization
-cmsBool _cmsRegisterOptimizationPlugin(cmsPluginBase* Plugin);
+cmsBool _cmsRegisterOptimizationPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
+
+// Transform
+cmsBool _cmsRegisterTransformPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
+// Mutex
+cmsBool _cmsRegisterMutexPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
// ---------------------------------------------------------------------------------------------------------
-// Suballocators. Those are blocks of memory that is freed at the end on whole block.
+// Suballocators.
typedef struct _cmsSubAllocator_chunk_st {
cmsUInt8Number* Block;
_cmsSubAllocator* _cmsCreateSubAlloc(cmsContext ContextID, cmsUInt32Number Initial);
void _cmsSubAllocDestroy(_cmsSubAllocator* s);
void* _cmsSubAlloc(_cmsSubAllocator* s, cmsUInt32Number size);
+void* _cmsSubAllocDup(_cmsSubAllocator* s, const void *ptr, cmsUInt32Number size);
// ----------------------------------------------------------------------------------
+// The context clients.
+typedef enum {
+
+ UserPtr, // User-defined pointer
+ Logger,
+ AlarmCodesContext,
+ AdaptationStateContext,
+ MemPlugin,
+ InterpPlugin,
+ CurvesPlugin,
+ FormattersPlugin,
+ TagTypePlugin,
+ TagPlugin,
+ IntentPlugin,
+ MPEPlugin,
+ OptimizationPlugin,
+ TransformPlugin,
+ MutexPlugin,
+
+ // Last in list
+ MemoryClientMax
+
+} _cmsMemoryClient;
+
+
+// Container for memory management plug-in.
+typedef struct {
+
+ _cmsMallocFnPtrType MallocPtr;
+ _cmsMalloZerocFnPtrType MallocZeroPtr;
+ _cmsFreeFnPtrType FreePtr;
+ _cmsReallocFnPtrType ReallocPtr;
+ _cmsCallocFnPtrType CallocPtr;
+ _cmsDupFnPtrType DupPtr;
+
+} _cmsMemPluginChunkType;
+
+// Copy memory management function pointers from plug-in to chunk, taking care of missing routines
+void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr);
+
+// Internal structure for context
+struct _cmsContext_struct {
+
+ struct _cmsContext_struct* Next; // Points to next context in the new style
+ _cmsSubAllocator* MemPool; // The memory pool that stores context data
+
+ void* chunks[MemoryClientMax]; // array of pointers to client chunks. Memory itself is hold in the suballocator.
+ // If NULL, then it reverts to global Context0
+
+ _cmsMemPluginChunkType DefaultMemoryManager; // The allocators used for creating the context itself. Cannot be overriden
+};
+
+// Returns a pointer to a valid context structure, including the global one if id is zero.
+// Verifies the magic number.
+struct _cmsContext_struct* _cmsGetContext(cmsContext ContextID);
+
+// Returns the block assigned to the specific zone.
+void* _cmsContextGetClientChunk(cmsContext id, _cmsMemoryClient mc);
+
+
+// Chunks of context memory by plug-in client -------------------------------------------------------
+
+// Those structures encapsulates all variables needed by the several context clients (mostly plug-ins)
+
+// Container for error logger -- not a plug-in
+typedef struct {
+
+ cmsLogErrorHandlerFunction LogErrorHandler; // Set to NULL for Context0 fallback
+
+} _cmsLogErrorChunkType;
+
+// The global Context0 storage for error logger
+extern _cmsLogErrorChunkType _cmsLogErrorChunk;
+
+// Allocate and init error logger container.
+void _cmsAllocLogErrorChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for alarm codes -- not a plug-in
+typedef struct {
+
+ cmsUInt16Number AlarmCodes[cmsMAXCHANNELS];
+
+} _cmsAlarmCodesChunkType;
+
+// The global Context0 storage for alarm codes
+extern _cmsAlarmCodesChunkType _cmsAlarmCodesChunk;
+
+// Allocate and init alarm codes container.
+void _cmsAllocAlarmCodesChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for adaptation state -- not a plug-in
+typedef struct {
+
+ cmsFloat64Number AdaptationState;
+
+} _cmsAdaptationStateChunkType;
+
+// The global Context0 storage for adaptation state
+extern _cmsAdaptationStateChunkType _cmsAdaptationStateChunk;
+
+// Allocate and init adaptation state container.
+void _cmsAllocAdaptationStateChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+
+// The global Context0 storage for memory management
+extern _cmsMemPluginChunkType _cmsMemPluginChunk;
+
+// Allocate and init memory management container.
+void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for interpolation plug-in
+typedef struct {
+
+ cmsInterpFnFactory Interpolators;
+
+} _cmsInterpPluginChunkType;
+
+// The global Context0 storage for interpolation plug-in
+extern _cmsInterpPluginChunkType _cmsInterpPluginChunk;
+
+// Allocate and init interpolation container.
+void _cmsAllocInterpPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for parametric curves plug-in
+typedef struct {
+
+ struct _cmsParametricCurvesCollection_st* ParametricCurves;
+
+} _cmsCurvesPluginChunkType;
+
+// The global Context0 storage for tone curves plug-in
+extern _cmsCurvesPluginChunkType _cmsCurvesPluginChunk;
+
+// Allocate and init parametric curves container.
+void _cmsAllocCurvesPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for formatters plug-in
+typedef struct {
+
+ struct _cms_formatters_factory_list* FactoryList;
+
+} _cmsFormattersPluginChunkType;
+
+// The global Context0 storage for formatters plug-in
+extern _cmsFormattersPluginChunkType _cmsFormattersPluginChunk;
+
+// Allocate and init formatters container.
+void _cmsAllocFormattersPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// This chunk type is shared by TagType plug-in and MPE Plug-in
+typedef struct {
+
+ struct _cmsTagTypeLinkedList_st* TagTypes;
+
+} _cmsTagTypePluginChunkType;
+
+
+// The global Context0 storage for tag types plug-in
+extern _cmsTagTypePluginChunkType _cmsTagTypePluginChunk;
+
+
+// The global Context0 storage for mult process elements plug-in
+extern _cmsTagTypePluginChunkType _cmsMPETypePluginChunk;
+
+// Allocate and init Tag types container.
+void _cmsAllocTagTypePluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+// Allocate and init MPE container.
+void _cmsAllocMPETypePluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+// Container for tag plug-in
+typedef struct {
+
+ struct _cmsTagLinkedList_st* Tag;
+
+} _cmsTagPluginChunkType;
+
+
+// The global Context0 storage for tag plug-in
+extern _cmsTagPluginChunkType _cmsTagPluginChunk;
+
+// Allocate and init Tag container.
+void _cmsAllocTagPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for intents plug-in
+typedef struct {
+
+ struct _cms_intents_list* Intents;
+
+} _cmsIntentsPluginChunkType;
+
+
+// The global Context0 storage for intents plug-in
+extern _cmsIntentsPluginChunkType _cmsIntentsPluginChunk;
+
+// Allocate and init intents container.
+void _cmsAllocIntentsPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for optimization plug-in
+typedef struct {
+
+ struct _cmsOptimizationCollection_st* OptimizationCollection;
+
+} _cmsOptimizationPluginChunkType;
+
+
+// The global Context0 storage for optimizers plug-in
+extern _cmsOptimizationPluginChunkType _cmsOptimizationPluginChunk;
+
+// Allocate and init optimizers container.
+void _cmsAllocOptimizationPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for transform plug-in
+typedef struct {
+
+ struct _cmsTransformCollection_st* TransformCollection;
+
+} _cmsTransformPluginChunkType;
+
+// The global Context0 storage for full-transform replacement plug-in
+extern _cmsTransformPluginChunkType _cmsTransformPluginChunk;
+
+// Allocate and init transform container.
+void _cmsAllocTransformPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// Container for mutex plug-in
+typedef struct {
+
+ _cmsCreateMutexFnPtrType CreateMutexPtr;
+ _cmsDestroyMutexFnPtrType DestroyMutexPtr;
+ _cmsLockMutexFnPtrType LockMutexPtr;
+ _cmsUnlockMutexFnPtrType UnlockMutexPtr;
+
+} _cmsMutexPluginChunkType;
+
+// The global Context0 storage for mutex plug-in
+extern _cmsMutexPluginChunkType _cmsMutexPluginChunk;
+
+// Allocate and init mutex container.
+void _cmsAllocMutexPluginChunk(struct _cmsContext_struct* ctx,
+ const struct _cmsContext_struct* src);
+
+// ----------------------------------------------------------------------------------
// MLU internal representation
typedef struct {
cmsUInt16Number Language;
- cmsUInt16Number Country;
+ cmsUInt16Number Country;
cmsUInt32Number StrW; // Offset to current unicode string
- cmsUInt32Number Len; // Lenght in bytes
+ cmsUInt32Number Len; // Length in bytes
} _cmsMLUentry;
struct _cms_MLU_struct {
-
+
cmsContext ContextID;
// The directory
- int AllocatedEntries;
+ int AllocatedEntries;
int UsedEntries;
_cmsMLUentry* Entries; // Array of pointers to strings allocated in MemPool
// The Pool
cmsUInt32Number PoolSize; // The maximum allocated size
cmsUInt32Number PoolUsed; // The used size
- void* MemPool; // Pointer to begin of memory pool
+ void* MemPool; // Pointer to begin of memory pool
};
// Named color list internal representation
-typedef struct {
+typedef struct {
char Name[cmsMAX_PATH];
cmsUInt16Number PCS[3];
struct _cms_NAMEDCOLORLIST_struct {
- cmsUInt32Number nColors;
+ cmsUInt32Number nColors;
cmsUInt32Number Allocated;
- cmsUInt32Number ColorantCount;
+ cmsUInt32Number ColorantCount;
char Prefix[33]; // Prefix and suffix are defined to be 32 characters at most
- char Suffix[33];
+ char Suffix[33];
_cmsNAMEDCOLOR* List;
// Creation time
struct tm Created;
- // Only most important items found in ICC profiles
+ // Only most important items found in ICC profiles
cmsUInt32Number Version;
cmsProfileClassSignature DeviceClass;
cmsColorSpaceSignature ColorSpace;
cmsColorSpaceSignature PCS;
cmsUInt32Number RenderingIntent;
+
cmsUInt32Number flags;
cmsUInt32Number manufacturer, model;
cmsUInt64Number attributes;
+ cmsUInt32Number creator;
cmsProfileID ProfileID;
cmsBool TagSaveAsRaw[MAX_TABLE_TAG]; // True to write uncooked
void * TagPtrs[MAX_TABLE_TAG];
cmsTagTypeHandler* TagTypeHandlers[MAX_TABLE_TAG]; // Same structure may be serialized on different types
- // depending on profile version, so we keep track of the // type handler for each tag in the list.
+ // depending on profile version, so we keep track of the
+ // type handler for each tag in the list.
// Special
cmsBool IsWrite;
-
+
+ // Keep a mutex for cmsReadTag -- Note that this only works if the user includes a mutex plugin
+ void * UsrMutex;
+
} _cmsICCPROFILE;
// IO helpers for profiles
int _cmsSearchTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, cmsBool lFollowLinks);
// Tag types
-cmsTagTypeHandler* _cmsGetTagTypeHandler(cmsTagTypeSignature sig);
+cmsTagTypeHandler* _cmsGetTagTypeHandler(cmsContext ContextID, cmsTagTypeSignature sig);
cmsTagTypeSignature _cmsGetTagTrueType(cmsHPROFILE hProfile, cmsTagSignature sig);
-cmsTagDescriptor* _cmsGetTagDescriptor(cmsTagSignature sig);
+cmsTagDescriptor* _cmsGetTagDescriptor(cmsContext ContextID, cmsTagSignature sig);
// Error logging ---------------------------------------------------------------------------------------------------------
cmsInterpParams* _cmsComputeInterpParams(cmsContext ContextID, int nSamples, int InputChan, int OutputChan, const void* Table, cmsUInt32Number dwFlags);
cmsInterpParams* _cmsComputeInterpParamsEx(cmsContext ContextID, const cmsUInt32Number nSamples[], int InputChan, int OutputChan, const void* Table, cmsUInt32Number dwFlags);
void _cmsFreeInterpParams(cmsInterpParams* p);
-cmsBool _cmsSetInterpolationRoutine(cmsInterpParams* p);
+cmsBool _cmsSetInterpolationRoutine(cmsContext ContextID, cmsInterpParams* p);
// Curves ----------------------------------------------------------------------------------------------------------------
cmsParametricCurveEvaluator* Evals; // Evaluators (one per segment)
- // 16 bit Table-based representation follows
+ // 16 bit Table-based representation follows
cmsUInt32Number nEntries; // Number of table elements
- cmsUInt16Number* Table16; // The table itself.
-};
+ cmsUInt16Number* Table16; // The table itself.
+};
// Pipelines & Stages ---------------------------------------------------------------------------------------------
// A single stage
struct _cmsStage_struct {
-
+
cmsContext ContextID;
-
+
cmsStageSignature Type; // Identifies the stage
cmsStageSignature Implements; // Identifies the *function* of the stage (for optimizations)
struct _cmsStage_struct* Next;
};
-// 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;
-
// Special Stages (cannot be saved)
cmsStage* _cmsStageAllocLab2XYZ(cmsContext ContextID);
cmsStage* _cmsStageAllocLabV2ToV4(cmsContext ContextID);
cmsStage* _cmsStageAllocLabV2ToV4curves(cmsContext ContextID);
cmsStage* _cmsStageAllocLabV4ToV2(cmsContext ContextID);
-cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList);
+cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool UsePCS);
cmsStage* _cmsStageAllocIdentityCurves(cmsContext ContextID, int nChannels);
cmsStage* _cmsStageAllocIdentityCLut(cmsContext ContextID, int nChan);
+cmsStage* _cmsStageNormalizeFromLabFloat(cmsContext ContextID);
+cmsStage* _cmsStageNormalizeFromXyzFloat(cmsContext ContextID);
+cmsStage* _cmsStageNormalizeToLabFloat(cmsContext ContextID);
+cmsStage* _cmsStageNormalizeToXyzFloat(cmsContext ContextID);
-// For curve set only
+// For curve set only
cmsToneCurve** _cmsStageGetPtrToCurveSet(const cmsStage* mpe);
// Pipeline Evaluator (in floating point)
-typedef void (* _cmsPipelineEvalFloatFn)(const cmsFloat32Number In[],
- cmsFloat32Number Out[],
- const void* Data);
+typedef void (* _cmsPipelineEvalFloatFn)(const cmsFloat32Number In[],
+ cmsFloat32Number Out[],
+ const void* Data);
struct _cmsPipeline_struct {
- cmsStage* Elements; // Points to elements chain
- cmsUInt32Number InputChannels, OutputChannels;
-
+ cmsStage* Elements; // Points to elements chain
+ cmsUInt32Number InputChannels, OutputChannels;
+
// Data & evaluators
void *Data;
_cmsOPTeval16Fn Eval16Fn;
_cmsPipelineEvalFloatFn EvalFloatFn;
- _cmsOPTfreeDataFn FreeDataFn;
- _cmsOPTdupDataFn DupDataFn;
-
+ _cmsFreeUserDataFn FreeDataFn;
+ _cmsDupUserDataFn DupDataFn;
+
cmsContext ContextID; // Environment
- cmsBool SaveAs8Bits; // Implemntation-specific: save as 8 bits if possible
+ cmsBool SaveAs8Bits; // Implementation-specific: save as 8 bits if possible
};
// LUT reading & creation -------------------------------------------------------------------------------------------
// Profile linker --------------------------------------------------------------------------------------------------
-cmsPipeline* _cmsLinkProfiles(cmsContext ContextID,
+cmsPipeline* _cmsLinkProfiles(cmsContext ContextID,
cmsUInt32Number nProfiles,
- cmsUInt32Number TheIntents[],
- cmsHPROFILE hProfiles[],
+ cmsUInt32Number TheIntents[],
+ cmsHPROFILE hProfiles[],
cmsBool BPC[],
cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
cmsUInt16Number _cmsQuantizeVal(cmsFloat64Number i, int MaxSamples);
int _cmsReasonableGridpointsByColorspace(cmsColorSpaceSignature Colorspace, cmsUInt32Number dwFlags);
-cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
- cmsUInt16Number **White,
+cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
+ cmsUInt16Number **White,
cmsUInt16Number **Black,
cmsUInt32Number *nOutputs);
-cmsBool _cmsOptimizePipeline(cmsPipeline** Lut,
+cmsBool _cmsOptimizePipeline(cmsContext ContextID,
+ cmsPipeline** Lut,
int Intent,
- cmsUInt32Number* InputFormat,
+ cmsUInt32Number* InputFormat,
cmsUInt32Number* OutputFormat,
cmsUInt32Number* dwFlags );
// Hi level LUT building ----------------------------------------------------------------------------------------------
cmsPipeline* _cmsCreateGamutCheckPipeline(cmsContext ContextID,
- cmsHPROFILE hProfiles[],
- cmsBool BPC[],
- cmsUInt32Number Intents[],
+ cmsHPROFILE hProfiles[],
+ cmsBool BPC[],
+ cmsUInt32Number Intents[],
cmsFloat64Number AdaptationStates[],
- cmsUInt32Number nGamutPCSposition,
+ cmsUInt32Number nGamutPCSposition,
cmsHPROFILE hGamut);
cmsBool _cmsFormatterIsFloat(cmsUInt32Number Type);
cmsBool _cmsFormatterIs8bit(cmsUInt32Number Type);
-cmsFormatter _cmsGetFormatter(cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8
- cmsFormatterDirection Dir,
+cmsFormatter _cmsGetFormatter(cmsContext ContextID,
+ cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8
+ cmsFormatterDirection Dir,
cmsUInt32Number dwFlags);
+#ifndef CMS_NO_HALF_SUPPORT
+
+// Half float
+cmsFloat32Number _cmsHalf2Float(cmsUInt16Number h);
+cmsUInt16Number _cmsFloat2Half(cmsFloat32Number flt);
+
+#endif
+
// Transform logic ------------------------------------------------------------------------------------------------------
struct _cmstransform_struct;
-// Full xform
-typedef void (* _cmsTransformFn)(struct _cmstransform_struct *Transform,
- const void* InputBuffer,
- void* OutputBuffer, cmsUInt32Number Size);
-
typedef struct {
- cmsUInt32Number InputFormat, OutputFormat; // Keep formats for further reference
- cmsUInt32Number StrideIn, StrideOut; // Planar support
+ // 1-pixel cache (16 bits only)
+ cmsUInt16Number CacheIn[cmsMAXCHANNELS];
+ cmsUInt16Number CacheOut[cmsMAXCHANNELS];
+
+} _cmsCACHE;
+
-} cmsFormatterInfo;
// Transformation
typedef struct _cmstransform_struct {
cmsFormatterFloat FromInputFloat;
cmsFormatterFloat ToOutputFloat;
-
- // 1-pixel cache (16 bits only)
- cmsUInt16Number CacheIn[cmsMAXCHANNELS];
- cmsUInt16Number CacheOut[cmsMAXCHANNELS];
- // Semaphor for cache
- LCMS_RWLOCK_T rwlock;
-
- // A MPE LUT holding the full (optimized) transform
+ // 1-pixel cache seed for zero as input (16 bits, read only)
+ _cmsCACHE Cache;
+
+ // A Pipeline holding the full (optimized) transform
cmsPipeline* Lut;
-
- // A MPE LUT holding the gamut check. It goes from the input space to bilevel
+
+ // A Pipeline holding the gamut check. It goes from the input space to bilevel
cmsPipeline* GamutCheck;
// Colorant tables
// Informational only
cmsColorSpaceSignature EntryColorSpace;
cmsColorSpaceSignature ExitColorSpace;
-
+
+ // White points (informative only)
+ cmsCIEXYZ EntryWhitePoint;
+ cmsCIEXYZ ExitWhitePoint;
+
// Profiles used to create the transform
cmsSEQ* Sequence;
- cmsUInt32Number dwOriginalFlags;
- cmsFloat64Number AdaptationState;
+ cmsUInt32Number dwOriginalFlags;
+ cmsFloat64Number AdaptationState;
// The intent of this transform. That is usually the last intent in the profilechain, but may differ
cmsUInt32Number RenderingIntent;
// An id that uniquely identifies the running context. May be null.
cmsContext ContextID;
+ // A user-defined pointer that can be used to store data for transform plug-ins
+ void* UserData;
+ _cmsFreeUserDataFn FreeUserData;
+
} _cmsTRANSFORM;
// --------------------------------------------------------------------------------------------------
cmsUInt32Number nProfiles,
cmsUInt32Number InputFormat,
cmsUInt32Number OutputFormat,
- const cmsUInt32Number Intents[],
- const cmsHPROFILE hProfiles[],
+ const cmsUInt32Number Intents[],
+ const cmsHPROFILE hProfiles[],
const cmsBool BPC[],
const cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
-cmsToneCurve* _cmsBuildKToneCurve(cmsContext ContextID,
+cmsToneCurve* _cmsBuildKToneCurve(cmsContext ContextID,
cmsUInt32Number nPoints,
cmsUInt32Number nProfiles,
- const cmsUInt32Number Intents[],
- const cmsHPROFILE hProfiles[],
+ const cmsUInt32Number Intents[],
+ const cmsHPROFILE hProfiles[],
const cmsBool BPC[],
const cmsFloat64Number AdaptationStates[],
cmsUInt32Number dwFlags);
projects / openjpeg / commitdiff