walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Switch to libcms2-2.6

This commit is contained in:
mayeut 2015-07-21 23:49:11 +02:00
parent 28c6f54798
commit 2fc9d4956a
29 changed files with 11407 additions and 6249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
thirdparty/liblcms2/include/lcms2.h vendored
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
@ -23,7 +23,7 @@
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Version 2.1 // Version 2.6
// //
#ifndef _lcms2_H #ifndef _lcms2_H
@ -40,9 +40,6 @@
// Uncomment this if your compiler doesn't work with fast floor function // Uncomment this if your compiler doesn't work with fast floor function
// #define CMS_DONT_USE_FAST_FLOOR 1 // #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, // 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. // if commented, lcms will compute the black point by its own.
// It is safer to leave it commented out // It is safer to leave it commented out
@ -55,6 +52,12 @@
// require "KEYWORD" on undefined identifiers, keep it comented out unless needed // require "KEYWORD" on undefined identifiers, keep it comented out unless needed
// #define CMS_STRICT_CGATS 1 // #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 ****************************** // ********** End of configuration toggles ******************************
// Needed for streams // Needed for streams
@ -72,7 +75,7 @@ extern "C" {
#endif #endif
// Version/release // 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 // I will give the chance of redefining basic types for compilers that are not fully C99 compliant
#ifndef CMS_BASIC_TYPES_ALREADY_DEFINED #ifndef CMS_BASIC_TYPES_ALREADY_DEFINED
@ -81,6 +84,10 @@ extern "C" {
typedef unsigned char cmsUInt8Number; // That is guaranteed by the C99 spec typedef unsigned char cmsUInt8Number; // That is guaranteed by the C99 spec
typedef signed char cmsInt8Number; // 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 // IEEE float storage numbers
typedef float cmsFloat32Number; typedef float cmsFloat32Number;
typedef double cmsFloat64Number; typedef double cmsFloat64Number;
@ -169,26 +176,42 @@ typedef int cmsBool;
// Try to detect big endian platforms. This list can be endless, so only some checks are performed over here. // 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 // you can pass this toggle to the compiler by using -DCMS_USE_BIG_ENDIAN or something similar
#if defined(__sgi__) || defined(__sgi) || defined(sparc)
# define CMS_USE_BIG_ENDIAN 1
#endif
#if defined(__s390__) || defined(__s390x__)
# define CMS_USE_BIG_ENDIAN 1
#endif
# 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
// WORDS_BIGENDIAN takes precedence
#if defined(_HOST_BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(WORDS_BIGENDIAN) #if defined(_HOST_BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(WORDS_BIGENDIAN)
# define CMS_USE_BIG_ENDIAN 1 # define CMS_USE_BIG_ENDIAN 1
#endif #endif
#if defined(__sgi__) || defined(__sgi) || defined(__powerpc__) || defined(sparc)
# define CMS_USE_BIG_ENDIAN 1
#endif
#if defined(__ppc__) || defined(__s390__) || defined(__s390x__)
# define CMS_USE_BIG_ENDIAN 1
#endif
#if TARGET_CPU_PPC
# define CMS_USE_BIG_ENDIAN 1
#endif
#ifdef macintosh #ifdef macintosh
# ifdef __BIG_ENDIAN__ # ifdef __BIG_ENDIAN__
# define CMS_USE_BIG_ENDIAN 1 # define CMS_USE_BIG_ENDIAN 1
# endif # endif
# ifdef __LITTLE_ENDIAN__
# undef CMS_USE_BIG_ENDIAN
# endif
#endif #endif
// Calling convention -- this is hardly platform and compiler dependent // Calling convention -- this is hardly platform and compiler dependent
@ -214,6 +237,14 @@ typedef int cmsBool;
# define CMSAPI # define CMSAPI
#endif #endif
#ifdef HasTHREADS
# if HasTHREADS == 1
# undef CMS_NO_PTHREADS
# else
# define CMS_NO_PTHREADS 1
# endif
#endif
// Some common definitions // Some common definitions
#define cmsMAX_PATH 256 #define cmsMAX_PATH 256
@ -247,6 +278,7 @@ typedef enum {
cmsSigCrdInfoType = 0x63726469, // 'crdi' cmsSigCrdInfoType = 0x63726469, // 'crdi'
cmsSigCurveType = 0x63757276, // 'curv' cmsSigCurveType = 0x63757276, // 'curv'
cmsSigDataType = 0x64617461, // 'data' cmsSigDataType = 0x64617461, // 'data'
cmsSigDictType = 0x64696374, // 'dict'
cmsSigDateTimeType = 0x6474696D, // 'dtim' cmsSigDateTimeType = 0x6474696D, // 'dtim'
cmsSigDeviceSettingsType = 0x64657673, // 'devs' cmsSigDeviceSettingsType = 0x64657673, // 'devs'
cmsSigLut16Type = 0x6d667432, // 'mft2' cmsSigLut16Type = 0x6d667432, // 'mft2'
@ -273,9 +305,10 @@ typedef enum {
cmsSigUInt32ArrayType = 0x75693332, // 'ui32' cmsSigUInt32ArrayType = 0x75693332, // 'ui32'
cmsSigUInt64ArrayType = 0x75693634, // 'ui64' cmsSigUInt64ArrayType = 0x75693634, // 'ui64'
cmsSigUInt8ArrayType = 0x75693038, // 'ui08' cmsSigUInt8ArrayType = 0x75693038, // 'ui08'
cmsSigVcgtType = 0x76636774, // 'vcgt'
cmsSigViewingConditionsType = 0x76696577, // 'view' cmsSigViewingConditionsType = 0x76696577, // 'view'
cmsSigXYZType = 0x58595A20, // 'XYZ ' cmsSigXYZType = 0x58595A20 // 'XYZ '
cmsSigVcgtType = 0x76636774 // 'vcgt'
} cmsTagTypeSignature; } cmsTagTypeSignature;
@ -330,6 +363,7 @@ typedef enum {
cmsSigPreview1Tag = 0x70726531, // 'pre1' cmsSigPreview1Tag = 0x70726531, // 'pre1'
cmsSigPreview2Tag = 0x70726532, // 'pre2' cmsSigPreview2Tag = 0x70726532, // 'pre2'
cmsSigProfileDescriptionTag = 0x64657363, // 'desc' cmsSigProfileDescriptionTag = 0x64657363, // 'desc'
cmsSigProfileDescriptionMLTag = 0x6473636d, // 'dscm'
cmsSigProfileSequenceDescTag = 0x70736571, // 'pseq' cmsSigProfileSequenceDescTag = 0x70736571, // 'pseq'
cmsSigProfileSequenceIdTag = 0x70736964, // 'psid' cmsSigProfileSequenceIdTag = 0x70736964, // 'psid'
cmsSigPs2CRD0Tag = 0x70736430, // 'psd0' cmsSigPs2CRD0Tag = 0x70736430, // 'psd0'
@ -348,7 +382,8 @@ typedef enum {
cmsSigUcrBgTag = 0x62666420, // 'bfd ' cmsSigUcrBgTag = 0x62666420, // 'bfd '
cmsSigViewingCondDescTag = 0x76756564, // 'vued' cmsSigViewingCondDescTag = 0x76756564, // 'vued'
cmsSigViewingConditionsTag = 0x76696577, // 'view' cmsSigViewingConditionsTag = 0x76696577, // 'view'
cmsSigVcgtTag = 0x76636774 // 'vcgt' cmsSigVcgtTag = 0x76636774, // 'vcgt'
cmsSigMetaTag = 0x6D657461 // 'meta'
} cmsTagSignature; } cmsTagSignature;
@ -407,12 +442,12 @@ typedef enum {
cmsSigMCH7Data = 0x4D434837, // 'MCH7' cmsSigMCH7Data = 0x4D434837, // 'MCH7'
cmsSigMCH8Data = 0x4D434838, // 'MCH8' cmsSigMCH8Data = 0x4D434838, // 'MCH8'
cmsSigMCH9Data = 0x4D434839, // 'MCH9' cmsSigMCH9Data = 0x4D434839, // 'MCH9'
cmsSigMCHAData = 0x4D43483A, // 'MCHA' cmsSigMCHAData = 0x4D434841, // 'MCHA'
cmsSigMCHBData = 0x4D43483B, // 'MCHB' cmsSigMCHBData = 0x4D434842, // 'MCHB'
cmsSigMCHCData = 0x4D43483C, // 'MCHC' cmsSigMCHCData = 0x4D434843, // 'MCHC'
cmsSigMCHDData = 0x4D43483D, // 'MCHD' cmsSigMCHDData = 0x4D434844, // 'MCHD'
cmsSigMCHEData = 0x4D43483E, // 'MCHE' cmsSigMCHEData = 0x4D434845, // 'MCHE'
cmsSigMCHFData = 0x4D43483F, // 'MCHF' cmsSigMCHFData = 0x4D434846, // 'MCHF'
cmsSigNamedData = 0x6e6d636c, // 'nmcl' cmsSigNamedData = 0x6e6d636c, // 'nmcl'
cmsSig1colorData = 0x31434C52, // '1CLR' cmsSig1colorData = 0x31434C52, // '1CLR'
cmsSig2colorData = 0x32434C52, // '2CLR' cmsSig2colorData = 0x32434C52, // '2CLR'
@ -483,7 +518,13 @@ typedef enum {
cmsSigLabV4toV2 = 0x34203220, // '4 2 ' cmsSigLabV4toV2 = 0x34203220, // '4 2 '
// Identities // Identities
cmsSigIdentityElemType = 0x69646E20 // 'idn ' cmsSigIdentityElemType = 0x69646E20, // 'idn '
// Float to floatPCS
cmsSigLab2FloatPCS = 0x64326C20, // 'd2l '
cmsSigFloatPCS2Lab = 0x6C326420, // 'l2d '
cmsSigXYZ2FloatPCS = 0x64327820, // 'd2x '
cmsSigFloatPCS2XYZ = 0x78326420 // 'x2d '
} cmsStageSignature; } cmsStageSignature;
@ -597,7 +638,6 @@ typedef struct {
// Little CMS specific typedefs // Little CMS specific typedefs
typedef void* cmsContext; // Context identifier for multithreaded environments
typedef void* cmsHANDLE ; // Generic handle typedef void* cmsHANDLE ; // Generic handle
typedef void* cmsHPROFILE; // Opaque typedefs to hide internals typedef void* cmsHPROFILE; // Opaque typedefs to hide internals
typedef void* cmsHTRANSFORM; typedef void* cmsHTRANSFORM;
@ -606,7 +646,9 @@ typedef void* cmsHTRANSFORM;
// Format of pixel is defined by one cmsUInt32Number, using bit fields as follows // 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 // 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 // O: Optimized -- previous optimization already returns the final 8-bit value
@ -714,16 +756,19 @@ typedef void* cmsHTRANSFORM;
#define TYPE_RGBA_16_SE (COLORSPACE_SH(PT_RGB)|EXTRA_SH(1)|CHANNELS_SH(3)|BYTES_SH(2)|ENDIAN16_SH(1)) #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 (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_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 (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 (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_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_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 (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 (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 (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_CMY_8_PLANAR (COLORSPACE_SH(PT_CMY)|CHANNELS_SH(3)|BYTES_SH(1)|PLANAR_SH(1))
@ -805,8 +850,8 @@ typedef void* cmsHTRANSFORM;
#define TYPE_Lab_8 (COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_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_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_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)|DOSWAP_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_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_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)) #define TYPE_Yxy_16 (COLORSPACE_SH(PT_Yxy)|CHANNELS_SH(3)|BYTES_SH(2))
@ -844,22 +889,40 @@ typedef void* cmsHTRANSFORM;
// Float formatters. // Float formatters.
#define TYPE_XYZ_FLT (FLOAT_SH(1)|COLORSPACE_SH(PT_XYZ)|CHANNELS_SH(3)|BYTES_SH(4)) #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_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_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_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_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_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)) #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 // 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_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_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_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_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)) #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 #endif
// Colorspaces // Colorspaces
@ -944,10 +1007,25 @@ typedef struct {
CMSAPI int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2); CMSAPI int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2);
CMSAPI long int CMSEXPORT cmsfilelength(FILE* f); 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 cmsPlugin(void* Plugin);
CMSAPI cmsBool CMSEXPORT cmsPluginTHR(cmsContext ContextID, void* Plugin);
CMSAPI void CMSEXPORT cmsUnregisterPlugins(void); CMSAPI void CMSEXPORT cmsUnregisterPlugins(void);
CMSAPI void CMSEXPORT cmsUnregisterPluginsTHR(cmsContext ContextID);
// Error logging ---------------------------------------------------------------------------------------------------------- // Error logging ----------------------------------------------------------------------------------------------------------
@ -984,6 +1062,7 @@ typedef void (* cmsLogErrorHandlerFunction)(cmsContext ContextID, cmsUInt32Numb
// Allows user to set any specific logger // Allows user to set any specific logger
CMSAPI void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn); CMSAPI void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn);
CMSAPI void CMSEXPORT cmsSetLogErrorHandlerTHR(cmsContext ContextID, cmsLogErrorHandlerFunction Fn);
// Conversions -------------------------------------------------------------------------------------------------------------- // Conversions --------------------------------------------------------------------------------------------------------------
@ -1090,6 +1169,10 @@ CMSAPI cmsBool CMSEXPORT cmsIsToneCurveDescending(const cmsToneCurve*
CMSAPI cmsInt32Number CMSEXPORT cmsGetToneCurveParametricType(const cmsToneCurve* t); CMSAPI cmsInt32Number CMSEXPORT cmsGetToneCurveParametricType(const cmsToneCurve* t);
CMSAPI cmsFloat64Number CMSEXPORT cmsEstimateGamma(const cmsToneCurve* t, cmsFloat64Number Precision); 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 ------------------------------------------------------------- // Implements pipelines of multi-processing elements -------------------------------------------------------------
@ -1102,6 +1185,7 @@ CMSAPI cmsPipeline* CMSEXPORT cmsPipelineAlloc(cmsContext ContextID, cmsUIn
CMSAPI void CMSEXPORT cmsPipelineFree(cmsPipeline* lut); CMSAPI void CMSEXPORT cmsPipelineFree(cmsPipeline* lut);
CMSAPI cmsPipeline* CMSEXPORT cmsPipelineDup(const cmsPipeline* Orig); CMSAPI cmsPipeline* CMSEXPORT cmsPipelineDup(const cmsPipeline* Orig);
CMSAPI cmsContext CMSEXPORT cmsGetPipelineContextID(const cmsPipeline* lut);
CMSAPI cmsUInt32Number CMSEXPORT cmsPipelineInputChannels(const cmsPipeline* lut); CMSAPI cmsUInt32Number CMSEXPORT cmsPipelineInputChannels(const cmsPipeline* lut);
CMSAPI cmsUInt32Number CMSEXPORT cmsPipelineOutputChannels(const cmsPipeline* lut); CMSAPI cmsUInt32Number CMSEXPORT cmsPipelineOutputChannels(const cmsPipeline* lut);
@ -1118,7 +1202,7 @@ CMSAPI cmsBool CMSEXPORT cmsPipelineSetSaveAs8bitsFlag(cmsPipeline* lu
// Where to place/locate the stages in the pipeline chain // Where to place/locate the stages in the pipeline chain
typedef enum { cmsAT_BEGIN, cmsAT_END } cmsStageLoc; 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); 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 // This function is quite useful to analyze the structure of a Pipeline and retrieve the Stage elements
@ -1162,10 +1246,9 @@ typedef cmsInt32Number (* cmsSAMPLERFLOAT)(register const cmsFloat32Number In[],
#define SAMPLER_INSPECT 0x01000000 #define SAMPLER_INSPECT 0x01000000
// For CLUT only // 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); CMSAPI cmsBool CMSEXPORT cmsStageSampleCLutFloat(cmsStage* mpe, cmsSAMPLERFLOAT Sampler, void* Cargo, cmsUInt32Number dwFlags);
// Slicers // Slicers
CMSAPI cmsBool CMSEXPORT cmsSliceSpace16(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[], CMSAPI cmsBool CMSEXPORT cmsSliceSpace16(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[],
cmsSAMPLER16 Sampler, void * Cargo); cmsSAMPLER16 Sampler, void * Cargo);
@ -1203,6 +1286,13 @@ CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
const char LanguageCode[3], const char CountryCode[3], const char LanguageCode[3], const char CountryCode[3],
char ObtainedLanguage[3], char ObtainedCountry[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 ------------------------------------------------------------------------------------- // Undercolorremoval & black generation -------------------------------------------------------------------------------------
typedef struct { typedef struct {
@ -1275,6 +1365,7 @@ CMSAPI cmsNAMEDCOLORLIST* CMSEXPORT cmsGetNamedColorList(cmsHTRANSFORM xform);
// Profile sequence descriptor. Some fields come from profile sequence descriptor tag, others // Profile sequence descriptor. Some fields come from profile sequence descriptor tag, others
// come from Profile Sequence Identifier Tag // come from Profile Sequence Identifier Tag
typedef struct { typedef struct {
cmsSignature deviceMfg; cmsSignature deviceMfg;
cmsSignature deviceModel; cmsSignature deviceModel;
cmsUInt64Number attributes; cmsUInt64Number attributes;
@ -1298,6 +1389,27 @@ CMSAPI cmsSEQ* CMSEXPORT cmsAllocProfileSequenceDescription(cmsContext
CMSAPI cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq); CMSAPI cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq);
CMSAPI void CMSEXPORT cmsFreeProfileSequenceDescription(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 ---------------------------------------------------------------------------------------------- // Access to Profile data ----------------------------------------------------------------------------------------------
CMSAPI cmsHPROFILE CMSEXPORT cmsCreateProfilePlaceholder(cmsContext ContextID); CMSAPI cmsHPROFILE CMSEXPORT cmsCreateProfilePlaceholder(cmsContext ContextID);
@ -1317,9 +1429,9 @@ CMSAPI cmsInt32Number CMSEXPORT cmsReadRawTag(cmsHPROFILE hProfile, cmsTagSig
CMSAPI cmsBool CMSEXPORT cmsWriteRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data, cmsUInt32Number Size); CMSAPI cmsBool CMSEXPORT cmsWriteRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data, cmsUInt32Number Size);
// Access header data // Access header data
#define cmsEmbeddedProfileFalse 0x00000000 #define cmsEmbeddedProfileFalse 0x00000000
#define cmsEmbeddedProfileTrue 0x00000001 #define cmsEmbeddedProfileTrue 0x00000001
#define cmsUseAnywhere 0x00000000 #define cmsUseAnywhere 0x00000000
#define cmsUseWithEmbeddedDataOnly 0x00000002 #define cmsUseWithEmbeddedDataOnly 0x00000002
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderFlags(cmsHPROFILE hProfile); CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderFlags(cmsHPROFILE hProfile);
@ -1331,6 +1443,7 @@ CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderRenderingIntent(cmsHPROFILE hProf
CMSAPI void CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags); CMSAPI void CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags);
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile); CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile);
CMSAPI void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer); CMSAPI void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer);
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderCreator(cmsHPROFILE hProfile);
CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile); CMSAPI cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile);
CMSAPI void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model); CMSAPI void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model);
CMSAPI void CMSEXPORT cmsSetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number Flags); CMSAPI void CMSEXPORT cmsSetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number Flags);
@ -1411,6 +1524,7 @@ CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromStreamTHR(cmsContext Context
CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromMem(const void * MemPtr, cmsUInt32Number dwSize); CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromMem(const void * MemPtr, cmsUInt32Number dwSize);
CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromMemTHR(cmsContext ContextID, 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 cmsOpenProfileFromIOhandlerTHR(cmsContext ContextID, cmsIOHANDLER* io);
CMSAPI cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandler2THR(cmsContext ContextID, cmsIOHANDLER* io, cmsBool write);
CMSAPI cmsBool CMSEXPORT cmsCloseProfile(cmsHPROFILE hProfile); CMSAPI cmsBool CMSEXPORT cmsCloseProfile(cmsHPROFILE hProfile);
CMSAPI cmsBool CMSEXPORT cmsSaveProfileToFile(cmsHPROFILE hProfile, const char* FileName); CMSAPI cmsBool CMSEXPORT cmsSaveProfileToFile(cmsHPROFILE hProfile, const char* FileName);
@ -1501,6 +1615,7 @@ CMSAPI cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransfo
// Call with NULL as parameters to get the intent count // Call with NULL as parameters to get the intent count
CMSAPI cmsUInt32Number CMSEXPORT cmsGetSupportedIntents(cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions); CMSAPI cmsUInt32Number CMSEXPORT cmsGetSupportedIntents(cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions);
CMSAPI cmsUInt32Number CMSEXPORT cmsGetSupportedIntentsTHR(cmsContext ContextID, cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions);
// Flags // Flags
@ -1605,18 +1720,40 @@ CMSAPI void CMSEXPORT cmsDoTransform(cmsHTRANSFORM Transform,
void * OutputBuffer, void * OutputBuffer,
cmsUInt32Number Size); 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 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 // Adaptation state for absolute colorimetric intent
CMSAPI cmsFloat64Number CMSEXPORT cmsSetAdaptationState(cmsFloat64Number d); 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 // Grab the ContextID from an open transform. Returns NULL if a NULL transform is passed
CMSAPI cmsContext CMSEXPORT cmsGetTransformContextID(cmsHTRANSFORM hTransform); 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 // For backwards compatibility
CMSAPI cmsBool CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform, CMSAPI cmsBool CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
cmsUInt32Number InputFormat, cmsUInt32Number InputFormat,
cmsUInt32Number OutputFormat); cmsUInt32Number OutputFormat);
@ -1663,12 +1800,15 @@ CMSAPI cmsBool CMSEXPORT cmsIT8SetComment(cmsHANDLE hIT8, const char* c
CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyStr(cmsHANDLE hIT8, const char* cProp, const char *Str); 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 cmsIT8SetPropertyDbl(cmsHANDLE hIT8, const char* cProp, cmsFloat64Number Val);
CMSAPI cmsBool CMSEXPORT cmsIT8SetPropertyHex(cmsHANDLE hIT8, const char* cProp, cmsUInt32Number 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 cmsBool CMSEXPORT cmsIT8SetPropertyUncooked(cmsHANDLE hIT8, const char* Key, const char* Buffer);
CMSAPI const char* CMSEXPORT cmsIT8GetProperty(cmsHANDLE hIT8, const char* cProp); CMSAPI const char* CMSEXPORT cmsIT8GetProperty(cmsHANDLE hIT8, const char* cProp);
CMSAPI cmsFloat64Number CMSEXPORT cmsIT8GetPropertyDbl(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 cmsIT8EnumProperties(cmsHANDLE hIT8, char ***PropertyNames);
CMSAPI cmsUInt32Number CMSEXPORT cmsIT8EnumPropertyMulti(cmsHANDLE hIT8, const char* cProp, const char ***SubpropertyNames);
// Datasets // Datasets
CMSAPI const char* CMSEXPORT cmsIT8GetDataRowCol(cmsHANDLE hIT8, int row, int col); CMSAPI const char* CMSEXPORT cmsIT8GetDataRowCol(cmsHANDLE hIT8, int row, int col);
@ -1698,10 +1838,13 @@ CMSAPI cmsBool CMSEXPORT cmsIT8SetDataFormat(cmsHANDLE hIT8, int n, con
CMSAPI int CMSEXPORT cmsIT8EnumDataFormat(cmsHANDLE hIT8, char ***SampleNames); CMSAPI int CMSEXPORT cmsIT8EnumDataFormat(cmsHANDLE hIT8, char ***SampleNames);
CMSAPI const char* CMSEXPORT cmsIT8GetPatchName(cmsHANDLE hIT8, int nPatch, char* buffer); CMSAPI const char* CMSEXPORT cmsIT8GetPatchName(cmsHANDLE hIT8, int nPatch, char* buffer);
CMSAPI int CMSEXPORT cmsIT8GetPatchByName(cmsHANDLE hIT8, const char *cPatch);
// The LABEL extension // The LABEL extension
CMSAPI int CMSEXPORT cmsIT8SetTableByLabel(cmsHANDLE hIT8, const char* cSet, const char* cField, const char* ExpectedType); 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 // Formatter for double
CMSAPI void CMSEXPORT cmsIT8DefineDblFormat(cmsHANDLE hIT8, const char* Formatter); CMSAPI void CMSEXPORT cmsIT8DefineDblFormat(cmsHANDLE hIT8, const char* Formatter);
@ -1717,6 +1860,7 @@ CMSAPI cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIEL
// Estimate the black point // Estimate the black point
CMSAPI cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags); 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 // Estimate total area coverage
CMSAPI cmsFloat64Number CMSEXPORT cmsDetectTAC(cmsHPROFILE hProfile); CMSAPI cmsFloat64Number CMSEXPORT cmsDetectTAC(cmsHPROFILE hProfile);

132
thirdparty/liblcms2/include/lcms2_plugin.h vendored
View File

@ -1,7 +1,7 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
@ -131,7 +131,7 @@ struct _cms_io_handler {
// Endianess adjust functions // Endianess adjust functions
CMSAPI cmsUInt16Number CMSEXPORT _cmsAdjustEndianess16(cmsUInt16Number Word); CMSAPI cmsUInt16Number CMSEXPORT _cmsAdjustEndianess16(cmsUInt16Number Word);
CMSAPI cmsUInt32Number CMSEXPORT _cmsAdjustEndianess32(cmsUInt32Number Value); 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 // Helper IO functions
CMSAPI cmsBool CMSEXPORT _cmsReadUInt8Number(cmsIOHANDLER* io, cmsUInt8Number* n); CMSAPI cmsBool CMSEXPORT _cmsReadUInt8Number(cmsIOHANDLER* io, cmsUInt8Number* n);
@ -147,7 +147,7 @@ CMSAPI cmsBool CMSEXPORT _cmsWriteUInt8Number(cmsIOHANDLER* io, cmsUI
CMSAPI cmsBool CMSEXPORT _cmsWriteUInt16Number(cmsIOHANDLER* io, cmsUInt16Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt16Number(cmsIOHANDLER* io, cmsUInt16Number n);
CMSAPI cmsBool CMSEXPORT _cmsWriteUInt32Number(cmsIOHANDLER* io, cmsUInt32Number n); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt32Number(cmsIOHANDLER* io, cmsUInt32Number n);
CMSAPI cmsBool CMSEXPORT _cmsWriteFloat32Number(cmsIOHANDLER* io, cmsFloat32Number 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 _cmsWrite15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number n);
CMSAPI cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ); CMSAPI cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ);
CMSAPI cmsBool CMSEXPORT _cmsWriteUInt16Array(cmsIOHANDLER* io, cmsUInt32Number n, const cmsUInt16Number* Array); CMSAPI cmsBool CMSEXPORT _cmsWriteUInt16Array(cmsIOHANDLER* io, cmsUInt32Number n, const cmsUInt16Number* Array);
@ -181,6 +181,11 @@ CMSAPI cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsFloat64Number v);
CMSAPI void CMSEXPORT _cmsEncodeDateTimeNumber(cmsDateTimeNumber *Dest, const struct tm *Source); CMSAPI void CMSEXPORT _cmsEncodeDateTimeNumber(cmsDateTimeNumber *Dest, const struct tm *Source);
CMSAPI void CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeNumber *Source, struct tm *Dest); 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);
//---------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------
@ -196,6 +201,8 @@ CMSAPI void CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeN
#define cmsPluginRenderingIntentSig 0x696E7448 // 'intH' #define cmsPluginRenderingIntentSig 0x696E7448 // 'intH'
#define cmsPluginMultiProcessElementSig 0x6D706548 // 'mpeH' #define cmsPluginMultiProcessElementSig 0x6D706548 // 'mpeH'
#define cmsPluginOptimizationSig 0x6F707448 // 'optH' #define cmsPluginOptimizationSig 0x6F707448 // 'optH'
#define cmsPluginTransformSig 0x7A666D48 // 'xfmH'
#define cmsPluginMutexSig 0x6D747A48 // 'mtxH'
typedef struct _cmsPluginBaseStruct { typedef struct _cmsPluginBaseStruct {
@ -212,19 +219,28 @@ typedef struct _cmsPluginBaseStruct {
//---------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------
// Memory handler. Each new plug-in type replaces current behaviour // 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 { typedef struct {
cmsPluginBase base; cmsPluginBase base;
// Required // Required
void * (* MallocPtr)(cmsContext ContextID, cmsUInt32Number size); _cmsMallocFnPtrType MallocPtr;
void (* FreePtr)(cmsContext ContextID, void *Ptr); _cmsFreeFnPtrType FreePtr;
void * (* ReallocPtr)(cmsContext ContextID, void* Ptr, cmsUInt32Number NewSize); _cmsReallocFnPtrType ReallocPtr;
// Optional // Optional
void * (* MallocZeroPtr)(cmsContext ContextID, cmsUInt32Number size); _cmsMalloZerocFnPtrType MallocZeroPtr;
void * (* CallocPtr)(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size); _cmsCallocFnPtrType CallocPtr;
void * (* DupPtr)(cmsContext ContextID, const void* Org, cmsUInt32Number size); _cmsDupFnPtrType DupPtr;
} cmsPluginMemHandler; } cmsPluginMemHandler;
@ -387,7 +403,7 @@ typedef struct _cms_typehandler_struct {
void *Ptr); void *Ptr);
// Additional parameters used by the calling thread // Additional parameters used by the calling thread
cmsContext ContextID; cmsContext ContextID;
cmsUInt32Number ICCVersion; cmsUInt32Number ICCVersion;
} cmsTagTypeHandler; } cmsTagTypeHandler;
@ -486,6 +502,39 @@ typedef struct {
} cmsPluginMultiProcessElement; } 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. // Optimization. Using this plug-in, additional optimization strategies may be implemented.
// The function should return TRUE if any optimization is done on the LUT, this terminates // The function should return TRUE if any optimization is done on the LUT, this terminates
@ -496,9 +545,6 @@ typedef void (* _cmsOPTeval16Fn)(register const cmsUInt16Number In[],
register cmsUInt16Number Out[], register cmsUInt16Number Out[],
register const void* Data); register const void* Data);
typedef void (* _cmsOPTfreeDataFn)(cmsContext ContextID, void* Data);
typedef void* (* _cmsOPTdupDataFn)(cmsContext ContextID, const void* Data);
typedef cmsBool (* _cmsOPToptimizeFn)(cmsPipeline** Lut, typedef cmsBool (* _cmsOPToptimizeFn)(cmsPipeline** Lut,
cmsUInt32Number Intent, cmsUInt32Number Intent,
@ -512,8 +558,8 @@ typedef cmsBool (* _cmsOPToptimizeFn)(cmsPipeline** Lut,
CMSAPI void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut, CMSAPI void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut,
_cmsOPTeval16Fn Eval16, _cmsOPTeval16Fn Eval16,
void* PrivateData, void* PrivateData,
_cmsOPTfreeDataFn FreePrivateDataFn, _cmsFreeUserDataFn FreePrivateDataFn,
_cmsOPTdupDataFn DupPrivateDataFn); _cmsDupUserDataFn DupPrivateDataFn);
typedef struct { typedef struct {
cmsPluginBase base; cmsPluginBase base;
@ -524,6 +570,62 @@ typedef struct {
} cmsPluginOptimization; } 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 #ifndef CMS_USE_CPP_API
# ifdef __cplusplus # ifdef __cplusplus

267
thirdparty/liblcms2/src/cmscam02.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -31,7 +31,7 @@
// ---------- Implementation -------------------------------------------- // ---------- Implementation --------------------------------------------
typedef struct { typedef struct {
cmsFloat64Number XYZ[3]; cmsFloat64Number XYZ[3];
cmsFloat64Number RGB[3]; cmsFloat64Number RGB[3];
cmsFloat64Number RGBc[3]; cmsFloat64Number RGBc[3];
@ -41,55 +41,55 @@ typedef struct {
cmsFloat64Number abC[2]; cmsFloat64Number abC[2];
cmsFloat64Number abs[2]; cmsFloat64Number abs[2];
cmsFloat64Number abM[2]; cmsFloat64Number abM[2];
} CAM02COLOR; } CAM02COLOR;
typedef struct { typedef struct {
CAM02COLOR adoptedWhite; CAM02COLOR adoptedWhite;
cmsFloat64Number LA, Yb; cmsFloat64Number LA, Yb;
cmsFloat64Number F, c, Nc; cmsFloat64Number F, c, Nc;
cmsUInt32Number surround; cmsUInt32Number surround;
cmsFloat64Number n, Nbb, Ncb, z, FL, D; cmsFloat64Number n, Nbb, Ncb, z, FL, D;
cmsContext ContextID; cmsContext ContextID;
} cmsCIECAM02; } cmsCIECAM02;
static static
cmsFloat64Number compute_n(cmsCIECAM02* pMod) cmsFloat64Number compute_n(cmsCIECAM02* pMod)
{ {
return (pMod -> Yb / pMod -> adoptedWhite.XYZ[1]); return (pMod -> Yb / pMod -> adoptedWhite.XYZ[1]);
} }
static static
cmsFloat64Number compute_z(cmsCIECAM02* pMod) cmsFloat64Number compute_z(cmsCIECAM02* pMod)
{ {
return (1.48 + pow(pMod -> n, 0.5)); return (1.48 + pow(pMod -> n, 0.5));
} }
static static
cmsFloat64Number computeNbb(cmsCIECAM02* pMod) cmsFloat64Number computeNbb(cmsCIECAM02* pMod)
{ {
return (0.725 * pow((1.0 / pMod -> n), 0.2)); return (0.725 * pow((1.0 / pMod -> n), 0.2));
} }
static static
cmsFloat64Number computeFL(cmsCIECAM02* pMod) cmsFloat64Number computeFL(cmsCIECAM02* pMod)
{ {
cmsFloat64Number k, FL; cmsFloat64Number k, FL;
k = 1.0 / ((5.0 * pMod->LA) + 1.0); k = 1.0 / ((5.0 * pMod->LA) + 1.0);
FL = 0.2 * pow(k, 4.0) * (5.0 * pMod->LA) + 0.1 * FL = 0.2 * pow(k, 4.0) * (5.0 * pMod->LA) + 0.1 *
(pow((1.0 - pow(k, 4.0)), 2.0)) * (pow((1.0 - pow(k, 4.0)), 2.0)) *
(pow((5.0 * pMod->LA), (1.0 / 3.0))); (pow((5.0 * pMod->LA), (1.0 / 3.0)));
return FL; return FL;
} }
static static
cmsFloat64Number computeD(cmsCIECAM02* pMod) cmsFloat64Number computeD(cmsCIECAM02* pMod)
{ {
cmsFloat64Number D; cmsFloat64Number D;
@ -100,17 +100,17 @@ cmsFloat64Number computeD(cmsCIECAM02* pMod)
static 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[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[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); clr.RGB[2] = (clr.XYZ[0] * 0.0030) + (clr.XYZ[1] * 0.0136) + (clr.XYZ[2] * 0.9834);
return clr; return clr;
} }
static static
CAM02COLOR ChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod) CAM02COLOR ChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
{ {
cmsUInt32Number i; cmsUInt32Number i;
@ -120,15 +120,15 @@ CAM02COLOR ChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
(1.0 - pMod->D)) * clr.RGB[i]; (1.0 - pMod->D)) * clr.RGB[i];
} }
return clr; return clr;
} }
static static
CAM02COLOR CAT02toHPE(CAM02COLOR clr) CAM02COLOR CAT02toHPE(CAM02COLOR clr)
{ {
cmsFloat64Number M[9]; cmsFloat64Number M[9];
M[0] =(( 0.38971 * 1.096124) + (0.68898 * 0.454369) + (-0.07868 * -0.009628)); 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[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[2] =(( 0.38971 * 0.182745) + (0.68898 * 0.072098) + (-0.07868 * 1.015326));
@ -138,16 +138,16 @@ CAM02COLOR CAT02toHPE(CAM02COLOR clr)
M[6] =(-0.009628); M[6] =(-0.009628);
M[7] =(-0.005698); M[7] =(-0.005698);
M[8] =( 1.015326); M[8] =( 1.015326);
clr.RGBp[0] = (clr.RGBc[0] * M[0]) + (clr.RGBc[1] * M[1]) + (clr.RGBc[2] * M[2]); 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[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]); clr.RGBp[2] = (clr.RGBc[0] * M[6]) + (clr.RGBc[1] * M[7]) + (clr.RGBc[2] * M[8]);
return clr; return clr;
} }
static static
CAM02COLOR NonlinearCompression(CAM02COLOR clr, cmsCIECAM02* pMod) CAM02COLOR NonlinearCompression(CAM02COLOR clr, cmsCIECAM02* pMod)
{ {
cmsUInt32Number i; cmsUInt32Number i;
cmsFloat64Number temp; cmsFloat64Number temp;
@ -163,21 +163,21 @@ CAM02COLOR NonlinearCompression(CAM02COLOR clr, cmsCIECAM02* pMod)
clr.RGBpa[i] = (400.0 * temp) / (temp + 27.13) + 0.1; 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; (clr.RGBpa[2] / 20.0)) - 0.305) * pMod->Nbb;
return clr; return clr;
} }
static static
CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod) CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
{ {
cmsFloat64Number a, b, temp, e, t, r2d, d2r; cmsFloat64Number a, b, temp, e, t, r2d, d2r;
a = clr.RGBpa[0] - (12.0 * clr.RGBpa[1] / 11.0) + (clr.RGBpa[2] / 11.0); 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; b = (clr.RGBpa[0] + clr.RGBpa[1] - (2.0 * clr.RGBpa[2])) / 9.0;
r2d = (180.0 / 3.141592654); r2d = (180.0 / 3.141592654);
if (a == 0) { if (a == 0) {
if (b == 0) clr.h = 0; if (b == 0) clr.h = 0;
@ -194,11 +194,11 @@ CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
temp = b / a; temp = b / a;
clr.h = (r2d * atan(temp)) + 180; clr.h = (r2d * atan(temp)) + 180;
} }
d2r = (3.141592654 / 180.0); d2r = (3.141592654 / 180.0);
e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) * e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) *
(cos((clr.h * d2r + 2.0)) + 3.8); (cos((clr.h * d2r + 2.0)) + 3.8);
if (clr.h < 20.14) { if (clr.h < 20.14) {
temp = ((clr.h + 122.47)/1.2) + ((20.14 - clr.h)/0.8); temp = ((clr.h + 122.47)/1.2) + ((20.14 - clr.h)/0.8);
clr.H = 300 + (100*((clr.h + 122.47)/1.2)) / temp; clr.H = 300 + (100*((clr.h + 122.47)/1.2)) / temp;
@ -219,15 +219,15 @@ CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
temp = ((clr.h - 237.53)/1.2) + ((360 - clr.h + 20.14)/0.8); 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.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)); (pMod->c * pMod->z));
clr.Q = (4.0 / pMod->c) * pow((clr.J / 100.0), 0.5) * clr.Q = (4.0 / pMod->c) * pow((clr.J / 100.0), 0.5) *
(pMod->adoptedWhite.A + 4.0) * pow(pMod->FL, 0.25); (pMod->adoptedWhite.A + 4.0) * pow(pMod->FL, 0.25);
t = (e * pow(((a * a) + (b * b)), 0.5)) / 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])); ((21.0 / 20.0) * clr.RGBpa[2]));
clr.C = pow(t, 0.9) * pow((clr.J / 100.0), 0.5) * clr.C = pow(t, 0.9) * pow((clr.J / 100.0), 0.5) *
@ -235,34 +235,34 @@ CAM02COLOR ComputeCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
clr.M = clr.C * pow(pMod->FL, 0.25); clr.M = clr.C * pow(pMod->FL, 0.25);
clr.s = 100.0 * pow((clr.M / clr.Q), 0.5); clr.s = 100.0 * pow((clr.M / clr.Q), 0.5);
return clr; return clr;
} }
static static
CAM02COLOR InverseCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod) CAM02COLOR InverseCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
{ {
cmsFloat64Number t, e, p1, p2, p3, p4, p5, hr, d2r; cmsFloat64Number t, e, p1, p2, p3, p4, p5, hr, d2r;
d2r = 3.141592654 / 180.0; d2r = 3.141592654 / 180.0;
t = pow( (clr.C / (pow((clr.J / 100.0), 0.5) * 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) ); (1.0 / 0.9) );
e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) * e = ((12500.0 / 13.0) * pMod->Nc * pMod->Ncb) *
(cos((clr.h * d2r + 2.0)) + 3.8); (cos((clr.h * d2r + 2.0)) + 3.8);
clr.A = pMod->adoptedWhite.A * pow( clr.A = pMod->adoptedWhite.A * pow(
(clr.J / 100.0), (clr.J / 100.0),
(1.0 / (pMod->c * pMod->z))); (1.0 / (pMod->c * pMod->z)));
p1 = e / t; p1 = e / t;
p2 = (clr.A / pMod->Nbb) + 0.305; p2 = (clr.A / pMod->Nbb) + 0.305;
p3 = 21.0 / 20.0; p3 = 21.0 / 20.0;
hr = clr.h * d2r; hr = clr.h * d2r;
if (fabs(sin(hr)) >= fabs(cos(hr))) { if (fabs(sin(hr)) >= fabs(cos(hr))) {
p4 = p1 / sin(hr); p4 = p1 / sin(hr);
clr.b = (p2 * (2.0 + p3) * (460.0 / 1403.0)) / clr.b = (p2 * (2.0 + p3) * (460.0 / 1403.0)) /
@ -279,17 +279,17 @@ CAM02COLOR InverseCorrelates(CAM02COLOR clr, cmsCIECAM02* pMod)
(sin(hr) / cos(hr))); (sin(hr) / cos(hr)));
clr.b = clr.a * (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) + ((451.0 / 1403.0) * clr.a) +
((288.0 / 1403.0) * clr.b); ((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) - ((891.0 / 1403.0) * clr.a) -
((261.0 / 1403.0) * clr.b); ((261.0 / 1403.0) * clr.b);
clr.RGBpa[2] = ((460.0 / 1403.0) * p2) - clr.RGBpa[2] = ((460.0 / 1403.0) * p2) -
((220.0 / 1403.0) * clr.a) - ((220.0 / 1403.0) * clr.a) -
((6300.0 / 1403.0) * clr.b); ((6300.0 / 1403.0) * clr.b);
return clr; return clr;
} }
@ -298,7 +298,7 @@ CAM02COLOR InverseNonlinearity(CAM02COLOR clr, cmsCIECAM02* pMod)
{ {
cmsUInt32Number i; cmsUInt32Number i;
cmsFloat64Number c1; cmsFloat64Number c1;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
if ((clr.RGBpa[i] - 0.1) < 0) c1 = -1; if ((clr.RGBpa[i] - 0.1) < 0) c1 = -1;
else c1 = 1; else c1 = 1;
@ -307,15 +307,15 @@ CAM02COLOR InverseNonlinearity(CAM02COLOR clr, cmsCIECAM02* pMod)
(400.0 - fabs(clr.RGBpa[i] - 0.1))), (400.0 - fabs(clr.RGBpa[i] - 0.1))),
(1.0 / 0.42)); (1.0 / 0.42));
} }
return clr; return clr;
} }
static static
CAM02COLOR HPEtoCAT02(CAM02COLOR clr) CAM02COLOR HPEtoCAT02(CAM02COLOR clr)
{ {
cmsFloat64Number M[9]; cmsFloat64Number M[9];
M[0] = (( 0.7328 * 1.910197) + (0.4296 * 0.370950)); M[0] = (( 0.7328 * 1.910197) + (0.4296 * 0.370950));
M[1] = (( 0.7328 * -1.112124) + (0.4296 * 0.629054)); M[1] = (( 0.7328 * -1.112124) + (0.4296 * 0.629054));
M[2] = (( 0.7328 * 0.201908) + (0.4296 * 0.000008) - 0.1624); M[2] = (( 0.7328 * 0.201908) + (0.4296 * 0.000008) - 0.1624);
@ -325,7 +325,7 @@ CAM02COLOR HPEtoCAT02(CAM02COLOR clr)
M[6] = (( 0.0030 * 1.910197) + (0.0136 * 0.370950)); M[6] = (( 0.0030 * 1.910197) + (0.0136 * 0.370950));
M[7] = (( 0.0030 * -1.112124) + (0.0136 * 0.629054)); M[7] = (( 0.0030 * -1.112124) + (0.0136 * 0.629054));
M[8] = (( 0.0030 * 0.201908) + (0.0136 * 0.000008) + 0.9834);; 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[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[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]); clr.RGBc[2] = (clr.RGBp[0] * M[6]) + (clr.RGBp[1] * M[7]) + (clr.RGBp[2] * M[8]);
@ -334,10 +334,10 @@ CAM02COLOR HPEtoCAT02(CAM02COLOR clr)
static static
CAM02COLOR InverseChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod) CAM02COLOR InverseChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
{ {
cmsUInt32Number i; cmsUInt32Number i;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
clr.RGB[i] = clr.RGBc[i] / clr.RGB[i] = clr.RGBc[i] /
((pMod->adoptedWhite.XYZ[1] * pMod->D / pMod->adoptedWhite.RGB[i]) + 1.0 - pMod->D); ((pMod->adoptedWhite.XYZ[1] * pMod->D / pMod->adoptedWhite.RGB[i]) + 1.0 - pMod->D);
} }
@ -346,82 +346,82 @@ CAM02COLOR InverseChromaticAdaptation(CAM02COLOR clr, cmsCIECAM02* pMod)
static 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[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[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); clr.XYZ[2] = (clr.RGB[0] * -0.009628) + (clr.RGB[1] * -0.005698) + (clr.RGB[2] * 1.015326);
return clr; return clr;
} }
cmsHANDLE CMSEXPORT cmsCIECAM02Init(cmsContext ContextID, const cmsViewingConditions* pVC) 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) { if((lpMod = (cmsCIECAM02*) _cmsMallocZero(ContextID, sizeof(cmsCIECAM02))) == NULL) {
return NULL; return NULL;
} }
lpMod ->ContextID = ContextID; lpMod ->ContextID = ContextID;
lpMod ->adoptedWhite.XYZ[0] = pVC ->whitePoint.X; lpMod ->adoptedWhite.XYZ[0] = pVC ->whitePoint.X;
lpMod ->adoptedWhite.XYZ[1] = pVC ->whitePoint.Y; lpMod ->adoptedWhite.XYZ[1] = pVC ->whitePoint.Y;
lpMod ->adoptedWhite.XYZ[2] = pVC ->whitePoint.Z; lpMod ->adoptedWhite.XYZ[2] = pVC ->whitePoint.Z;
lpMod -> LA = pVC ->La; lpMod -> LA = pVC ->La;
lpMod -> Yb = pVC ->Yb; lpMod -> Yb = pVC ->Yb;
lpMod -> D = pVC ->D_value; lpMod -> D = pVC ->D_value;
lpMod -> surround = pVC ->surround; lpMod -> surround = pVC ->surround;
switch (lpMod -> surround) { switch (lpMod -> surround) {
case CUTSHEET_SURROUND: case CUTSHEET_SURROUND:
lpMod->F = 0.8; lpMod->F = 0.8;
lpMod->c = 0.41; lpMod->c = 0.41;
lpMod->Nc = 0.8; lpMod->Nc = 0.8;
break; break;
case DARK_SURROUND: case DARK_SURROUND:
lpMod -> F = 0.8; lpMod -> F = 0.8;
lpMod -> c = 0.525; lpMod -> c = 0.525;
lpMod -> Nc = 0.8; lpMod -> Nc = 0.8;
break; break;
case DIM_SURROUND: case DIM_SURROUND:
lpMod -> F = 0.9; lpMod -> F = 0.9;
lpMod -> c = 0.59; lpMod -> c = 0.59;
lpMod -> Nc = 0.95; lpMod -> Nc = 0.95;
break; break;
default: default:
// Average surround // Average surround
lpMod -> F = 1.0; lpMod -> F = 1.0;
lpMod -> c = 0.69; lpMod -> c = 0.69;
lpMod -> Nc = 1.0; lpMod -> Nc = 1.0;
} }
lpMod -> n = compute_n(lpMod); lpMod -> n = compute_n(lpMod);
lpMod -> z = compute_z(lpMod); lpMod -> z = compute_z(lpMod);
lpMod -> Nbb = computeNbb(lpMod); lpMod -> Nbb = computeNbb(lpMod);
lpMod -> FL = computeFL(lpMod); lpMod -> FL = computeFL(lpMod);
if (lpMod -> D == D_CALCULATE) { if (lpMod -> D == D_CALCULATE) {
lpMod -> D = computeD(lpMod); lpMod -> D = computeD(lpMod);
} }
lpMod -> Ncb = lpMod -> Nbb; lpMod -> Ncb = lpMod -> Nbb;
lpMod -> adoptedWhite = XYZtoCAT02(lpMod -> adoptedWhite); lpMod -> adoptedWhite = XYZtoCAT02(lpMod -> adoptedWhite);
lpMod -> adoptedWhite = ChromaticAdaptation(lpMod -> adoptedWhite, lpMod); lpMod -> adoptedWhite = ChromaticAdaptation(lpMod -> adoptedWhite, lpMod);
lpMod -> adoptedWhite = CAT02toHPE(lpMod -> adoptedWhite); lpMod -> adoptedWhite = CAT02toHPE(lpMod -> adoptedWhite);
lpMod -> adoptedWhite = NonlinearCompression(lpMod -> adoptedWhite, lpMod); lpMod -> adoptedWhite = NonlinearCompression(lpMod -> adoptedWhite, lpMod);
return (cmsHANDLE) lpMod; return (cmsHANDLE) lpMod;
} }
@ -429,32 +429,34 @@ void CMSEXPORT cmsCIECAM02Done(cmsHANDLE hModel)
{ {
cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel; 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) void CMSEXPORT cmsCIECAM02Forward(cmsHANDLE hModel, const cmsCIEXYZ* pIn, cmsJCh* pOut)
{ {
CAM02COLOR clr; CAM02COLOR clr;
cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel; cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel;
_cmsAssert(lpMod != NULL); _cmsAssert(lpMod != NULL);
_cmsAssert(pIn != NULL); _cmsAssert(pIn != NULL);
_cmsAssert(pOut != NULL); _cmsAssert(pOut != NULL);
memset(&clr, 0, sizeof(clr));
clr.XYZ[0] = pIn ->X; clr.XYZ[0] = pIn ->X;
clr.XYZ[1] = pIn ->Y; clr.XYZ[1] = pIn ->Y;
clr.XYZ[2] = pIn ->Z; clr.XYZ[2] = pIn ->Z;
clr = XYZtoCAT02(clr); clr = XYZtoCAT02(clr);
clr = ChromaticAdaptation(clr, lpMod); clr = ChromaticAdaptation(clr, lpMod);
clr = CAT02toHPE(clr); clr = CAT02toHPE(clr);
clr = NonlinearCompression(clr, lpMod); clr = NonlinearCompression(clr, lpMod);
clr = ComputeCorrelates(clr, lpMod); clr = ComputeCorrelates(clr, lpMod);
pOut ->J = clr.J; pOut ->J = clr.J;
pOut ->C = clr.C; pOut ->C = clr.C;
pOut ->h = clr.h; pOut ->h = clr.h;
} }
void CMSEXPORT cmsCIECAM02Reverse(cmsHANDLE hModel, const cmsJCh* pIn, cmsCIEXYZ* pOut) void CMSEXPORT cmsCIECAM02Reverse(cmsHANDLE hModel, const cmsJCh* pIn, cmsCIEXYZ* pOut)
@ -462,22 +464,23 @@ void CMSEXPORT cmsCIECAM02Reverse(cmsHANDLE hModel, const cmsJCh* pIn, cmsCIEXYZ
CAM02COLOR clr; CAM02COLOR clr;
cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel; cmsCIECAM02* lpMod = (cmsCIECAM02*) hModel;
_cmsAssert(lpMod != NULL); _cmsAssert(lpMod != NULL);
_cmsAssert(pIn != NULL); _cmsAssert(pIn != NULL);
_cmsAssert(pOut != NULL); _cmsAssert(pOut != NULL);
memset(&clr, 0, sizeof(clr));
clr.J = pIn -> J; clr.J = pIn -> J;
clr.C = pIn -> C; clr.C = pIn -> C;
clr.h = pIn -> h; clr.h = pIn -> h;
clr = InverseCorrelates(clr, lpMod); clr = InverseCorrelates(clr, lpMod);
clr = InverseNonlinearity(clr, lpMod); clr = InverseNonlinearity(clr, lpMod);
clr = HPEtoCAT02(clr); clr = HPEtoCAT02(clr);
clr = InverseChromaticAdaptation(clr, lpMod); clr = InverseChromaticAdaptation(clr, lpMod);
clr = CAT02toXYZ(clr); clr = CAT02toXYZ(clr);
pOut ->X = clr.XYZ[0]; pOut ->X = clr.XYZ[0];
pOut ->Y = clr.XYZ[1]; pOut ->Y = clr.XYZ[1];
pOut ->Z = clr.XYZ[2]; pOut ->Z = clr.XYZ[2];
} }

852
thirdparty/liblcms2/src/cmscgats.c vendored
View File

File diff suppressed because it is too large Load Diff

583
thirdparty/liblcms2/src/cmscnvrt.c vendored
View File

File diff suppressed because it is too large Load Diff

418
thirdparty/liblcms2/src/cmserr.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -31,30 +31,31 @@
// compare two strings ignoring case // compare two strings ignoring case
int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2) int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2)
{ {
register const unsigned char *us1 = (const unsigned char *)s1, register const unsigned char *us1 = (const unsigned char *)s1,
*us2 = (const unsigned char *)s2; *us2 = (const unsigned char *)s2;
while (toupper(*us1) == toupper(*us2++)) while (toupper(*us1) == toupper(*us2++))
if (*us1++ == '\0') if (*us1++ == '\0')
return (0); return 0;
return (toupper(*us1) - toupper(*--us2));
return (toupper(*us1) - toupper(*--us2));
} }
// long int because C99 specifies ftell in such way (7.19.9.2) // long int because C99 specifies ftell in such way (7.19.9.2)
long int CMSEXPORT cmsfilelength(FILE* f) 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) { if (fseek(f, 0, SEEK_END) != 0) {
return -1; return -1;
} }
n = ftell(f); n = ftell(f);
fseek(f, p, SEEK_SET); // file position restored fseek(f, p, SEEK_SET); // file position restored
return n; return n;
} }
@ -62,23 +63,22 @@ long int CMSEXPORT cmsfilelength(FILE* f)
// //
// This is the interface to low-level memory management routines. By default a simple // 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 // 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 // amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent
// prevent bogus or malintentionated code to allocate huge blocks that otherwise lcms // bogus or evil code to allocate huge blocks that otherwise lcms would never need.
// would never need.
#define MAX_MEMORY_FOR_ALLOC ((cmsUInt32Number)(1024U*1024U*512U)) #define MAX_MEMORY_FOR_ALLOC ((cmsUInt32Number)(1024U*1024U*512U))
// User may override this behaviour by using a memory plug-in, which basically replaces // 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 // 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 // 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 // required to be implemented: malloc, realloc and free, although the user may want to
// replace the optional mallocZero, calloc and dup as well. // 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 // check of amout of memory, just to prevent exploits
static static
void* _cmsMallocDefaultFn(cmsContext ContextID, cmsUInt32Number size) void* _cmsMallocDefaultFn(cmsContext ContextID, cmsUInt32Number size)
@ -109,13 +109,13 @@ void _cmsFreeDefaultFn(cmsContext ContextID, void *Ptr)
// free(NULL) is defined a no-op by C99, therefore it is safe to // free(NULL) is defined a no-op by C99, therefore it is safe to
// avoid the check, but it is here just in case... // avoid the check, but it is here just in case...
if (Ptr) free(Ptr); if (Ptr) free(Ptr);
cmsUNUSED_PARAMETER(ContextID); cmsUNUSED_PARAMETER(ContextID);
} }
// The default realloc function. Again it check for exploits. If Ptr is NULL, // 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. // realloc behaves the same way as malloc and allocates a new block of size bytes.
static static
void* _cmsReallocDefaultFn(cmsContext ContextID, void* Ptr, cmsUInt32Number size) void* _cmsReallocDefaultFn(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
{ {
@ -139,13 +139,13 @@ void* _cmsCallocDefaultFn(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Nu
if (Total == 0) return NULL; if (Total == 0) return NULL;
// Safe check for overflow. // Safe check for overflow.
if (num >= UINT_MAX / size) return NULL; if (num >= UINT_MAX / size) return NULL;
// Check for overflow // Check for overflow
if (Total < num || Total < size) { if (Total < num || Total < size) {
return NULL; return NULL;
} }
if (Total > MAX_MEMORY_FOR_ALLOC) return NULL; // Never alloc over 512Mb if (Total > MAX_MEMORY_FOR_ALLOC) return NULL; // Never alloc over 512Mb
return _cmsMallocZero(ContextID, Total); return _cmsMallocZero(ContextID, Total);
@ -156,7 +156,7 @@ static
void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number size) void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number size)
{ {
void* mem; void* mem;
if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never dup over 512Mb if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never dup over 512Mb
mem = _cmsMalloc(ContextID, size); mem = _cmsMalloc(ContextID, size);
@ -167,95 +167,149 @@ void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number si
return mem; return mem;
} }
// Pointers to malloc and _cmsFree functions in current environment
static void * (* MallocPtr)(cmsContext ContextID, cmsUInt32Number size) = _cmsMallocDefaultFn; // Pointers to memory manager functions in Context0
static void * (* MallocZeroPtr)(cmsContext ContextID, cmsUInt32Number size) = _cmsMallocZeroDefaultFn; _cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn,
static void (* FreePtr)(cmsContext ContextID, void *Ptr) = _cmsFreeDefaultFn; _cmsReallocDefaultFn, _cmsCallocDefaultFn, _cmsDupDefaultFn
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;
// 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 // 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) { if (Data == NULL) {
MallocPtr = _cmsMallocDefaultFn; struct _cmsContext_struct* ctx = ( struct _cmsContext_struct*) ContextID;
MallocZeroPtr= _cmsMallocZeroDefaultFn;
FreePtr = _cmsFreeDefaultFn; // Return to the default allocators
ReallocPtr = _cmsReallocDefaultFn; if (ContextID != NULL) {
CallocPtr = _cmsCallocDefaultFn; ctx->chunks[MemPlugin] = (void*) &ctx->DefaultMemoryManager;
DupPtr = _cmsDupDefaultFn; }
return TRUE; return TRUE;
} }
// Check for required callbacks // Check for required callbacks
if (Plugin -> MallocPtr == NULL || if (Plugin -> MallocPtr == NULL ||
Plugin -> FreePtr == NULL || Plugin -> FreePtr == NULL ||
Plugin -> ReallocPtr == NULL) return FALSE; Plugin -> ReallocPtr == NULL) return FALSE;
// Set replacement functions // Set replacement functions
MallocPtr = Plugin -> MallocPtr; ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
FreePtr = Plugin -> FreePtr; if (ptr == NULL)
ReallocPtr = Plugin -> ReallocPtr; return FALSE;
if (Plugin ->MallocZeroPtr != NULL) MallocZeroPtr = Plugin ->MallocZeroPtr;
if (Plugin ->CallocPtr != NULL) CallocPtr = Plugin -> CallocPtr;
if (Plugin ->DupPtr != NULL) DupPtr = Plugin -> DupPtr;
_cmsInstallAllocFunctions(Plugin, ptr);
return TRUE; return TRUE;
} }
// Generic allocate // Generic allocate
void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size) 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 // Generic allocate & zero
void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size) void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size)
{ {
return MallocZeroPtr(ContextID, size); _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
return ptr->MallocZeroPtr(ContextID, size);
} }
// Generic calloc // Generic calloc
void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size) 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 // Generic reallocate
void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size) 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 // Generic free memory
void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr) 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 // Generic block duplication
void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size) 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 // 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 // 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 // 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) // memory is being swapped to disk. This approach is safer (although that may not be true on all platforms)
static static
_cmsSubAllocator_chunk* _cmsCreateSubAllocChunk(cmsContext ContextID, cmsUInt32Number Initial) _cmsSubAllocator_chunk* _cmsCreateSubAllocChunk(cmsContext ContextID, cmsUInt32Number Initial)
{ {
_cmsSubAllocator_chunk* chunk; _cmsSubAllocator_chunk* chunk;
// 20K by default
if (Initial == 0)
Initial = 20*1024;
// Create the container // Create the container
chunk = (_cmsSubAllocator_chunk*) _cmsMallocZero(ContextID, sizeof(_cmsSubAllocator_chunk)); chunk = (_cmsSubAllocator_chunk*) _cmsMallocZero(ContextID, sizeof(_cmsSubAllocator_chunk));
if (chunk == NULL) return NULL; if (chunk == NULL) return NULL;
@ -269,10 +323,6 @@ _cmsSubAllocator_chunk* _cmsCreateSubAllocChunk(cmsContext ContextID, cmsUInt32N
return NULL; return NULL;
} }
// 20K by default
if (Initial == 0)
Initial = 20*1024;
chunk ->BlockSize = Initial; chunk ->BlockSize = Initial;
chunk ->Used = 0; chunk ->Used = 0;
chunk ->next = NULL; chunk ->next = NULL;
@ -325,9 +375,9 @@ void* _cmsSubAlloc(_cmsSubAllocator* sub, cmsUInt32Number size)
cmsUInt32Number Free = sub -> h ->BlockSize - sub -> h -> Used; cmsUInt32Number Free = sub -> h ->BlockSize - sub -> h -> Used;
cmsUInt8Number* ptr; 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) { if (size > Free) {
_cmsSubAllocator_chunk* chunk; _cmsSubAllocator_chunk* chunk;
@ -344,20 +394,40 @@ void* _cmsSubAlloc(_cmsSubAllocator* sub, cmsUInt32Number size)
sub ->h = chunk; sub ->h = chunk;
} }
ptr = sub -> h ->Block + sub -> h ->Used; ptr = sub -> h ->Block + sub -> h ->Used;
sub -> h -> Used += size; sub -> h -> Used += size;
return (void*) ptr; 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 ****************************************************************** // Error logging ******************************************************************
// There is no error handling at all. When a funtion fails, it returns proper value. // 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 // 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. // 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 // 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. // 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 // 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 // resources. It is the programmer's responsability to check each function return code
@ -372,8 +442,26 @@ void* _cmsSubAlloc(_cmsSubAllocator* sub, cmsUInt32Number size)
// This is our default log error // This is our default log error
static void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text); static void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text);
// The current handler in actual environment // Context0 storage, which is global
static cmsLogErrorHandlerFunction LogErrorHandler = DefaultLogErrorHandlerFunction; _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. // The default error logger does nothing.
static static
@ -381,34 +469,50 @@ void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorC
{ {
// fprintf(stderr, "[lcms]: %s\n", Text); // fprintf(stderr, "[lcms]: %s\n", Text);
// fflush(stderr); // fflush(stderr);
cmsUNUSED_PARAMETER(ContextID); cmsUNUSED_PARAMETER(ContextID);
cmsUNUSED_PARAMETER(ErrorCode); cmsUNUSED_PARAMETER(ErrorCode);
cmsUNUSED_PARAMETER(Text); cmsUNUSED_PARAMETER(Text);
} }
// Change log error // 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, legacy
void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn) void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn)
{ {
if (Fn == NULL) cmsSetLogErrorHandlerTHR(NULL, Fn);
LogErrorHandler = DefaultLogErrorHandlerFunction;
else
LogErrorHandler = Fn;
} }
// Log an error // Log an error
// ErrorText is a text holding an english description of error. // ErrorText is a text holding an english description of error.
void CMSEXPORT cmsSignalError(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *ErrorText, ...) void CMSEXPORT cmsSignalError(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *ErrorText, ...)
{ {
va_list args; va_list args;
char Buffer[MAX_ERROR_MESSAGE_LEN]; char Buffer[MAX_ERROR_MESSAGE_LEN];
_cmsLogErrorChunkType* lhg;
va_start(args, ErrorText); va_start(args, ErrorText);
vsnprintf(Buffer, MAX_ERROR_MESSAGE_LEN-1, ErrorText, args); vsnprintf(Buffer, MAX_ERROR_MESSAGE_LEN-1, ErrorText, args);
va_end(args); va_end(args);
// Call handler // Check for the context, if specified go there. If not, go for the global
LogErrorHandler(ContextID, ErrorCode, Buffer); lhg = (_cmsLogErrorChunkType*) _cmsContextGetClientChunk(ContextID, Logger);
if (lhg ->LogErrorHandler) {
lhg ->LogErrorHandler(ContextID, ErrorCode, Buffer);
}
} }
// Utility function to print signatures // Utility function to print signatures
@ -419,10 +523,132 @@ void _cmsTagSignature2String(char String[5], cmsTagSignature sig)
// Convert to big endian // Convert to big endian
be = _cmsAdjustEndianess32((cmsUInt32Number) sig); be = _cmsAdjustEndianess32((cmsUInt32Number) sig);
// Move chars // Move chars
memmove(String, &be, 4); memmove(String, &be, 4);
// Make sure of terminator // Make sure of terminator
String[4] = 0; 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);
}
}

431
thirdparty/liblcms2/src/cmsgamma.c vendored
View File

@ -1,42 +1,42 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
#include "lcms2_internal.h" #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. // 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, // 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 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, // 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 // 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 // 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 // be called with the type id as a negative value, and a sampled version of the reversed curve
// will be built. // will be built.
// ----------------------------------------------------------------- Implementation // ----------------------------------------------------------------- Implementation
// Maxim number of nodes // Maxim number of nodes
#define MAX_NODES_IN_CURVE 4097 #define MAX_NODES_IN_CURVE 4097
#define MINUS_INF (-1E22F) #define MINUS_INF (-1E22F)
#define PLUS_INF (+1E22F) #define PLUS_INF (+1E22F)
@ -53,12 +53,11 @@ typedef struct _cmsParametricCurvesCollection_st {
} _cmsParametricCurvesCollection; } _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); static cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Number Params[], cmsFloat64Number R);
// The built-in list // The built-in list
static _cmsParametricCurvesCollection DefaultCurves = { static _cmsParametricCurvesCollection DefaultCurves = {
9, // # of curve types 9, // # of curve types
{ 1, 2, 3, 4, 5, 6, 7, 8, 108 }, // Parametric curve ID { 1, 2, 3, 4, 5, 6, 7, 8, 108 }, // Parametric curve ID
{ 1, 3, 4, 5, 7, 4, 5, 5, 1 }, // Parameters by type { 1, 3, 4, 5, 7, 4, 5, 5, 1 }, // Parameters by type
@ -66,22 +65,77 @@ static _cmsParametricCurvesCollection DefaultCurves = {
NULL // Next in chain 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 // The linked list head
static _cmsParametricCurvesCollection* ParametricCurves = &DefaultCurves; _cmsCurvesPluginChunkType _cmsCurvesPluginChunk = { NULL };
// As a way to install new parametric curves // 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; cmsPluginParametricCurves* Plugin = (cmsPluginParametricCurves*) Data;
_cmsParametricCurvesCollection* fl; _cmsParametricCurvesCollection* fl;
if (Data == NULL) { if (Data == NULL) {
ParametricCurves = &DefaultCurves; ctx -> ParametricCurves = NULL;
return TRUE; return TRUE;
} }
fl = (_cmsParametricCurvesCollection*) _cmsPluginMalloc(sizeof(_cmsParametricCurvesCollection)); fl = (_cmsParametricCurvesCollection*) _cmsPluginMalloc(ContextID, sizeof(_cmsParametricCurvesCollection));
if (fl == NULL) return FALSE; if (fl == NULL) return FALSE;
// Copy the parameters // Copy the parameters
@ -97,8 +151,8 @@ cmsBool _cmsRegisterParametricCurvesPlugin(cmsPluginBase* Data)
memmove(fl->ParameterCount, Plugin ->ParameterCount, fl->nFunctions * sizeof(cmsUInt32Number)); memmove(fl->ParameterCount, Plugin ->ParameterCount, fl->nFunctions * sizeof(cmsUInt32Number));
// Keep linked list // Keep linked list
fl ->Next = ParametricCurves; fl ->Next = ctx->ParametricCurves;
ParametricCurves = fl; ctx->ParametricCurves = fl;
// All is ok // All is ok
return TRUE; return TRUE;
@ -120,17 +174,29 @@ int IsInSet(int Type, _cmsParametricCurvesCollection* c)
// Search for the collection which contains a specific type // Search for the collection which contains a specific type
static static
_cmsParametricCurvesCollection *GetParametricCurveByType(int Type, int* index) _cmsParametricCurvesCollection *GetParametricCurveByType(cmsContext ContextID, int Type, int* index)
{ {
_cmsParametricCurvesCollection* c; _cmsParametricCurvesCollection* c;
int Position; int Position;
_cmsCurvesPluginChunkType* ctx = ( _cmsCurvesPluginChunkType*) _cmsContextGetClientChunk(ContextID, CurvesPlugin);
for (c = ParametricCurves; c != NULL; c = c ->Next) { for (c = ctx->ParametricCurves; c != NULL; c = c ->Next) {
Position = IsInSet(Type, c); Position = IsInSet(Type, c);
if (Position != -1) { if (Position != -1) {
if (index != NULL) 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)
*index = Position; *index = Position;
return c; return c;
} }
@ -139,12 +205,12 @@ _cmsParametricCurvesCollection *GetParametricCurveByType(int Type, int* index)
return NULL; 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 // 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 // optimization curve is given. Both features simultaneously is an error
static static
cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntries, cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntries,
cmsInt32Number nSegments, const cmsCurveSegment* Segments, cmsInt32Number nSegments, const cmsCurveSegment* Segments,
const cmsUInt16Number* Values) const cmsUInt16Number* Values)
{ {
cmsToneCurve* p; cmsToneCurve* p;
@ -179,7 +245,7 @@ cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntr
} }
p -> nSegments = nSegments; p -> nSegments = nSegments;
// This 16-bit table contains a limited precision representation of the whole curve and is kept for // This 16-bit table contains a limited precision representation of the whole curve and is kept for
// increasing xput on certain operations. // increasing xput on certain operations.
if (nEntries <= 0) { if (nEntries <= 0) {
@ -189,13 +255,13 @@ cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntr
p ->Table16 = (cmsUInt16Number*) _cmsCalloc(ContextID, nEntries, sizeof(cmsUInt16Number)); p ->Table16 = (cmsUInt16Number*) _cmsCalloc(ContextID, nEntries, sizeof(cmsUInt16Number));
if (p ->Table16 == NULL) goto Error; if (p ->Table16 == NULL) goto Error;
} }
p -> nEntries = nEntries; p -> nEntries = nEntries;
// Initialize members if requested // Initialize members if requested
if (Values != NULL && (nEntries > 0)) { if (Values != NULL && (nEntries > 0)) {
for (i=0; i < nEntries; i++) for (i=0; i < nEntries; i++)
p ->Table16[i] = Values[i]; p ->Table16[i] = Values[i];
} }
@ -222,14 +288,15 @@ cmsToneCurve* AllocateToneCurveStruct(cmsContext ContextID, cmsInt32Number nEntr
p ->Segments[i].SampledPoints = NULL; p ->Segments[i].SampledPoints = NULL;
c = GetParametricCurveByType(Segments[i].Type, NULL); c = GetParametricCurveByType(ContextID, Segments[i].Type, NULL);
if (c != NULL) if (c != NULL)
p ->Evals[i] = c ->Evaluator; p ->Evals[i] = c ->Evaluator;
} }
} }
p ->InterpParams = _cmsComputeInterpParams(ContextID, p ->nEntries, 1, 1, p->Table16, CMS_LERP_FLAGS_16BITS); p ->InterpParams = _cmsComputeInterpParams(ContextID, p ->nEntries, 1, 1, p->Table16, CMS_LERP_FLAGS_16BITS);
return p; if (p->InterpParams != NULL)
return p;
Error: Error:
if (p -> Segments) _cmsFree(ContextID, p ->Segments); if (p -> Segments) _cmsFree(ContextID, p ->Segments);
@ -248,18 +315,28 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
switch (Type) { switch (Type) {
// X = Y ^ Gamma // X = Y ^ Gamma
case 1: case 1:
if (R < 0) if (R < 0) {
Val = 0;
if (fabs(Params[0] - 1.0) < MATRIX_DET_TOLERANCE)
Val = R;
else
Val = 0;
}
else else
Val = pow(R, Params[0]); Val = pow(R, Params[0]);
break; break;
// Type 1 Reversed: X = Y ^1/gamma // Type 1 Reversed: X = Y ^1/gamma
case -1: case -1:
if (R < 0) if (R < 0) {
Val = 0;
if (fabs(Params[0] - 1.0) < MATRIX_DET_TOLERANCE)
Val = R;
else
Val = 0;
}
else else
Val = pow(R, 1/Params[0]); Val = pow(R, 1/Params[0]);
break; break;
@ -285,14 +362,14 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
// Type 2 Reversed // Type 2 Reversed
// X = (Y ^1/g - b) / a // X = (Y ^1/g - b) / a
case -2: case -2:
if (R < 0) if (R < 0)
Val = 0; Val = 0;
else else
Val = (pow(R, 1.0/Params[0]) - Params[2]) / Params[1]; Val = (pow(R, 1.0/Params[0]) - Params[2]) / Params[1];
if (Val < 0) if (Val < 0)
Val = 0; Val = 0;
break; break;
@ -306,7 +383,7 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
if (R >= disc) { if (R >= disc) {
e = Params[1]*R + Params[2]; e = Params[1]*R + Params[2];
if (e > 0) if (e > 0)
Val = pow(e, Params[0]) + Params[3]; Val = pow(e, Params[0]) + Params[3];
@ -320,15 +397,15 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
// Type 3 reversed // Type 3 reversed
// X=((Y-c)^1/g - b)/a | (Y>=c) // X=((Y-c)^1/g - b)/a | (Y>=c)
// X=-b/a | (Y<c) // X=-b/a | (Y<c)
case -3: case -3:
if (R >= Params[3]) { if (R >= Params[3]) {
e = R - Params[3]; e = R - Params[3];
if (e > 0) if (e > 0)
Val = (pow(e, 1/Params[0]) - Params[2]) / Params[1]; Val = (pow(e, 1/Params[0]) - Params[2]) / Params[1];
else else
Val = 0; Val = 0;
} }
else { else {
@ -384,8 +461,8 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
if (e > 0) if (e > 0)
Val = pow(e, Params[0]) + Params[5]; Val = pow(e, Params[0]) + Params[5];
else else
Val = 0; Val = Params[5];
} }
else else
Val = R*Params[3] + Params[6]; Val = R*Params[3] + Params[6];
break; break;
@ -400,7 +477,7 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
if (R >= disc) { if (R >= disc) {
e = R - Params[5]; e = R - Params[5];
if (e < 0) if (e < 0)
Val = 0; Val = 0;
else else
Val = (pow(e, 1.0/Params[0]) - Params[2]) / Params[1]; Val = (pow(e, 1.0/Params[0]) - Params[2]) / Params[1];
@ -413,46 +490,46 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
// Types 6,7,8 comes from segmented curves as described in ICCSpecRevision_02_11_06_Float.pdf // 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 // Type 6 is basically identical to type 5 without d
// Y = (a * X + b) ^ Gamma + c // Y = (a * X + b) ^ Gamma + c
case 6: case 6:
e = Params[1]*R + Params[2]; e = Params[1]*R + Params[2];
if (e < 0) if (e < 0)
Val = 0; Val = Params[3];
else else
Val = pow(e, Params[0]) + Params[3]; Val = pow(e, Params[0]) + Params[3];
break; break;
// ((Y - c) ^1/Gamma - b) / a // ((Y - c) ^1/Gamma - b) / a
case -6: case -6:
e = R - Params[3]; e = R - Params[3];
if (e < 0) if (e < 0)
Val = 0; Val = 0;
else else
Val = (pow(e, 1.0/Params[0]) - Params[2]) / Params[1]; Val = (pow(e, 1.0/Params[0]) - Params[2]) / Params[1];
break; break;
// Y = a * log (b * X^Gamma + c) + d // Y = a * log (b * X^Gamma + c) + d
case 7: case 7:
e = Params[2] * pow(R, Params[0]) + Params[3]; e = Params[2] * pow(R, Params[0]) + Params[3];
if (e <= 0) if (e <= 0)
Val = 0; Val = Params[4];
else else
Val = Params[1]*log10(e) + Params[4]; Val = Params[1]*log10(e) + Params[4];
break; break;
// (Y - d) / a = log(b * X ^Gamma + c) // (Y - d) / a = log(b * X ^Gamma + c)
// pow(10, (Y-d) / a) = 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: case -7:
Val = pow((pow(10.0, (R-Params[4]) / Params[1]) - Params[3]) / Params[2], 1.0 / Params[0]); Val = pow((pow(10.0, (R-Params[4]) / Params[1]) - Params[3]) / Params[2], 1.0 / Params[0]);
break; break;
//Y = a * b^(c*X+d) + e //Y = a * b^(c*X+d) + e
case 8: case 8:
Val = (Params[0] * pow(Params[1], Params[2] * R + Params[3]) + Params[4]); Val = (Params[0] * pow(Params[1], Params[2] * R + Params[3]) + Params[4]);
break; break;
@ -461,14 +538,14 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
// Y = (log((y-e) / a) / log(b) - d ) / c // Y = (log((y-e) / a) / log(b) - d ) / c
// a=0, b=1, c=2, d=3, e=4, // a=0, b=1, c=2, d=3, e=4,
case -8: case -8:
disc = R - Params[4]; disc = R - Params[4];
if (disc < 0) Val = 0; if (disc < 0) Val = 0;
else else
Val = (log(disc / Params[0]) / log(Params[1]) - Params[3]) / Params[2]; Val = (log(disc / Params[0]) / log(Params[1]) - Params[3]) / Params[2];
break; break;
// S-Shaped: (1 - (1-x)^1/g)^1/g // S-Shaped: (1 - (1-x)^1/g)^1/g
case 108: case 108:
Val = pow(1.0 - pow(1 - R, 1/Params[0]), 1/Params[0]); Val = pow(1.0 - pow(1 - R, 1/Params[0]), 1/Params[0]);
break; break;
@ -491,7 +568,7 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
} }
// Evaluate a segmented funtion for a single value. Return -1 if no valid segment found . // 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 static
cmsFloat64Number EvalSegmentedFn(const cmsToneCurve *g, cmsFloat64Number R) cmsFloat64Number EvalSegmentedFn(const cmsToneCurve *g, cmsFloat64Number R)
{ {
@ -505,14 +582,14 @@ cmsFloat64Number EvalSegmentedFn(const cmsToneCurve *g, cmsFloat64Number R)
// Type == 0 means segment is sampled // Type == 0 means segment is sampled
if (g ->Segments[i].Type == 0) { 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; cmsFloat32Number Out;
// Setup the table (TODO: clean that) // 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]); g ->SegInterp[i] -> Interpolation.LerpFloat(&R1, &Out, g ->SegInterp[i]);
return Out; return Out;
} }
else else
@ -523,6 +600,19 @@ cmsFloat64Number EvalSegmentedFn(const cmsToneCurve *g, cmsFloat64Number R)
return MINUS_INF; 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 // Create an empty gamma curve, by using tables. This specifies only the limited-precision part, and leaves the
// floating point description empty. // floating point description empty.
@ -540,17 +630,17 @@ int EntriesByGamma(cmsFloat64Number Gamma)
// Create a segmented gamma, fill the table // Create a segmented gamma, fill the table
cmsToneCurve* CMSEXPORT cmsBuildSegmentedToneCurve(cmsContext ContextID, cmsToneCurve* CMSEXPORT cmsBuildSegmentedToneCurve(cmsContext ContextID,
cmsInt32Number nSegments, const cmsCurveSegment Segments[]) cmsInt32Number nSegments, const cmsCurveSegment Segments[])
{ {
int i; int i;
cmsFloat64Number R, Val; cmsFloat64Number R, Val;
cmsToneCurve* g; cmsToneCurve* g;
int nGridPoints = 4096; int nGridPoints = 4096;
_cmsAssert(Segments != NULL); _cmsAssert(Segments != NULL);
// Optimizatin for identity curves. // Optimizatin for identity curves.
if (nSegments == 1 && Segments[0].Type == 1) { if (nSegments == 1 && Segments[0].Type == 1) {
nGridPoints = EntriesByGamma(Segments[0].Params[0]); nGridPoints = EntriesByGamma(Segments[0].Params[0]);
@ -577,28 +667,41 @@ cmsToneCurve* CMSEXPORT cmsBuildSegmentedToneCurve(cmsContext ContextID,
// Use a segmented curve to store the floating point table // Use a segmented curve to store the floating point table
cmsToneCurve* CMSEXPORT cmsBuildTabulatedToneCurveFloat(cmsContext ContextID, cmsUInt32Number nEntries, const cmsFloat32Number values[]) cmsToneCurve* CMSEXPORT cmsBuildTabulatedToneCurveFloat(cmsContext ContextID, cmsUInt32Number nEntries, const cmsFloat32Number values[])
{ {
cmsCurveSegment Seg[2]; cmsCurveSegment Seg[3];
// Initialize segmented curve part up to 0 // A segmented tone curve should have function segments in the first and last positions
Seg[0].x0 = -1; // Initialize segmented curve part up to 0 to constant value = samples[0]
Seg[0].x0 = MINUS_INF;
Seg[0].x1 = 0; Seg[0].x1 = 0;
Seg[0].Type = 6; Seg[0].Type = 6;
Seg[0].Params[0] = 1; Seg[0].Params[0] = 1;
Seg[0].Params[1] = 0; Seg[0].Params[1] = 0;
Seg[0].Params[2] = 0; Seg[0].Params[2] = 0;
Seg[0].Params[3] = 0; Seg[0].Params[3] = values[0];
Seg[0].Params[4] = 0; Seg[0].Params[4] = 0;
// From zero to any // From zero to 1
Seg[1].x0 = 0; Seg[1].x0 = 0;
Seg[1].x1 = 1.0; Seg[1].x1 = 1.0;
Seg[1].Type = 0; Seg[1].Type = 0;
Seg[1].nGridPoints = nEntries; Seg[1].nGridPoints = nEntries;
Seg[1].SampledPoints = (cmsFloat32Number*) values; 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 // Parametric curves
@ -611,12 +714,12 @@ cmsToneCurve* CMSEXPORT cmsBuildParametricToneCurve(cmsContext ContextID, cmsInt
cmsCurveSegment Seg0; cmsCurveSegment Seg0;
int Pos = 0; int Pos = 0;
cmsUInt32Number size; cmsUInt32Number size;
_cmsParametricCurvesCollection* c = GetParametricCurveByType(Type, &Pos); _cmsParametricCurvesCollection* c = GetParametricCurveByType(ContextID, Type, &Pos);
_cmsAssert(Params != NULL); _cmsAssert(Params != NULL);
if (c == 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; return NULL;
} }
@ -645,27 +748,27 @@ cmsToneCurve* CMSEXPORT cmsBuildGamma(cmsContext ContextID, cmsFloat64Number Gam
void CMSEXPORT cmsFreeToneCurve(cmsToneCurve* Curve) void CMSEXPORT cmsFreeToneCurve(cmsToneCurve* Curve)
{ {
cmsContext ContextID; cmsContext ContextID;
if (Curve == NULL) return; if (Curve == NULL) return;
ContextID = Curve ->InterpParams->ContextID; ContextID = Curve ->InterpParams->ContextID;
_cmsFreeInterpParams(Curve ->InterpParams); _cmsFreeInterpParams(Curve ->InterpParams);
if (Curve -> Table16) if (Curve -> Table16)
_cmsFree(ContextID, Curve ->Table16); _cmsFree(ContextID, Curve ->Table16);
if (Curve ->Segments) { if (Curve ->Segments) {
cmsUInt32Number i; cmsUInt32Number i;
for (i=0; i < Curve ->nSegments; i++) { for (i=0; i < Curve ->nSegments; i++) {
if (Curve ->Segments[i].SampledPoints) { if (Curve ->Segments[i].SampledPoints) {
_cmsFree(ContextID, Curve ->Segments[i].SampledPoints); _cmsFree(ContextID, Curve ->Segments[i].SampledPoints);
} }
if (Curve ->SegInterp[i] != 0) if (Curve ->SegInterp[i] != 0)
_cmsFreeInterpParams(Curve->SegInterp[i]); _cmsFreeInterpParams(Curve->SegInterp[i]);
} }
@ -695,18 +798,18 @@ void CMSEXPORT cmsFreeToneCurveTriple(cmsToneCurve* Curve[3])
// Duplicate a gamma table // Duplicate a gamma table
cmsToneCurve* CMSEXPORT cmsDupToneCurve(const cmsToneCurve* In) cmsToneCurve* CMSEXPORT cmsDupToneCurve(const cmsToneCurve* In)
{ {
if (In == NULL) return NULL; if (In == NULL) return NULL;
return AllocateToneCurveStruct(In ->InterpParams ->ContextID, In ->nEntries, In ->nSegments, In ->Segments, In ->Table16); return AllocateToneCurveStruct(In ->InterpParams ->ContextID, In ->nEntries, In ->nSegments, In ->Segments, In ->Table16);
} }
// Joins two curves for X and Y. Curves should be monotonic. // 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* X,
const cmsToneCurve* Y, cmsUInt32Number nResultingPoints) const cmsToneCurve* Y, cmsUInt32Number nResultingPoints)
{ {
@ -725,7 +828,7 @@ cmsToneCurve* CMSEXPORT cmsJoinToneCurve(cmsContext ContextID,
Res = (cmsFloat32Number*) _cmsCalloc(ContextID, nResultingPoints, sizeof(cmsFloat32Number)); Res = (cmsFloat32Number*) _cmsCalloc(ContextID, nResultingPoints, sizeof(cmsFloat32Number));
if (Res == NULL) goto Error; if (Res == NULL) goto Error;
//Iterate //Iterate
for (i=0; i < nResultingPoints; i++) { for (i=0; i < nResultingPoints; i++) {
@ -736,7 +839,7 @@ cmsToneCurve* CMSEXPORT cmsJoinToneCurve(cmsContext ContextID,
// Allocate space for output // Allocate space for output
out = cmsBuildTabulatedToneCurveFloat(ContextID, nResultingPoints, Res); out = cmsBuildTabulatedToneCurveFloat(ContextID, nResultingPoints, Res);
Error: Error:
if (Res != NULL) _cmsFree(ContextID, Res); if (Res != NULL) _cmsFree(ContextID, Res);
@ -747,25 +850,25 @@ Error:
// Get the surrounding nodes. This is tricky on non-monotonic tables // Get the surrounding nodes. This is tricky on non-monotonic tables
static static
int GetInterval(cmsFloat64Number In, const cmsUInt16Number LutTable[], const struct _cms_interp_struc* p) int GetInterval(cmsFloat64Number In, const cmsUInt16Number LutTable[], const struct _cms_interp_struc* p)
{ {
int i; int i;
int y0, y1; int y0, y1;
// A 1 point table is not allowed // A 1 point table is not allowed
if (p -> Domain[0] < 1) return -1; 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]]) { if (LutTable[0] < LutTable[p ->Domain[0]]) {
// Table is overall ascending // Table is overall ascending
for (i=p->Domain[0]-1; i >=0; --i) { for (i=p->Domain[0]-1; i >=0; --i) {
y0 = LutTable[i]; y0 = LutTable[i];
y1 = LutTable[i+1]; y1 = LutTable[i+1];
if (y0 <= y1) { // Increasing if (y0 <= y1) { // Increasing
if (In >= y0 && In <= y1) return i; if (In >= y0 && In <= y1) return i;
} }
@ -779,7 +882,7 @@ int GetInterval(cmsFloat64Number In, const cmsUInt16Number LutTable[], const str
// Table is overall descending // Table is overall descending
for (i=0; i < (int) p -> Domain[0]; i++) { for (i=0; i < (int) p -> Domain[0]; i++) {
y0 = LutTable[i]; y0 = LutTable[i];
y1 = LutTable[i+1]; y1 = LutTable[i+1];
if (y0 <= y1) { // Increasing if (y0 <= y1) { // Increasing
@ -802,18 +905,21 @@ cmsToneCurve* CMSEXPORT cmsReverseToneCurveEx(cmsInt32Number nResultSamples, con
cmsFloat64Number a = 0, b = 0, y, x1, y1, x2, y2; cmsFloat64Number a = 0, b = 0, y, x1, y1, x2, y2;
int i, j; int i, j;
int Ascending; int Ascending;
_cmsAssert(InCurve != NULL); _cmsAssert(InCurve != NULL);
// Try to reverse it analytically whatever possible // 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, return cmsBuildParametricToneCurve(InCurve ->InterpParams->ContextID,
-(InCurve -> Segments[0].Type), -(InCurve -> Segments[0].Type),
InCurve -> Segments[0].Params); InCurve -> Segments[0].Params);
} }
// Nope, reverse the table. // Nope, reverse the table.
out = cmsBuildTabulatedToneCurve16(InCurve ->InterpParams->ContextID, nResultSamples, NULL); out = cmsBuildTabulatedToneCurve16(InCurve ->InterpParams->ContextID, nResultSamples, NULL);
if (out == NULL) if (out == NULL)
return NULL; return NULL;
@ -826,18 +932,18 @@ cmsToneCurve* CMSEXPORT cmsReverseToneCurveEx(cmsInt32Number nResultSamples, con
y = (cmsFloat64Number) i * 65535.0 / (nResultSamples - 1); 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); j = GetInterval(y, InCurve->Table16, InCurve->InterpParams);
if (j >= 0) { if (j >= 0) {
// Get limits of interval // Get limits of interval
x1 = InCurve ->Table16[j]; x1 = InCurve ->Table16[j];
x2 = InCurve ->Table16[j+1]; x2 = InCurve ->Table16[j+1];
y1 = (cmsFloat64Number) (j * 65535.0) / (InCurve ->nEntries - 1); y1 = (cmsFloat64Number) (j * 65535.0) / (InCurve ->nEntries - 1);
y2 = (cmsFloat64Number) ((j+1) * 65535.0 ) / (InCurve ->nEntries - 1); y2 = (cmsFloat64Number) ((j+1) * 65535.0 ) / (InCurve ->nEntries - 1);
// If collapsed, then use any // If collapsed, then use any
if (x1 == x2) { if (x1 == x2) {
@ -846,12 +952,12 @@ cmsToneCurve* CMSEXPORT cmsReverseToneCurveEx(cmsInt32Number nResultSamples, con
} else { } else {
// Interpolate // Interpolate
a = (y2 - y1) / (x2 - x1); a = (y2 - y1) / (x2 - x1);
b = y2 - a * x2; b = y2 - a * x2;
} }
} }
out ->Table16[i] = _cmsQuickSaturateWord(a* y + b); out ->Table16[i] = _cmsQuickSaturateWord(a* y + b);
} }
@ -887,7 +993,7 @@ cmsBool smooth2(cmsContext ContextID, cmsFloat32Number w[], cmsFloat32Number y[]
c = (cmsFloat32Number*) _cmsCalloc(ContextID, MAX_NODES_IN_CURVE, sizeof(cmsFloat32Number)); c = (cmsFloat32Number*) _cmsCalloc(ContextID, MAX_NODES_IN_CURVE, sizeof(cmsFloat32Number));
d = (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)); e = (cmsFloat32Number*) _cmsCalloc(ContextID, MAX_NODES_IN_CURVE, sizeof(cmsFloat32Number));
if (c != NULL && d != NULL && e != NULL) { if (c != NULL && d != NULL && e != NULL) {
@ -899,7 +1005,7 @@ cmsBool smooth2(cmsContext ContextID, cmsFloat32Number w[], cmsFloat32Number y[]
c[2] = (-4 * lambda - d[1] * c[1] * e[1]) / d[2]; c[2] = (-4 * lambda - d[1] * c[1] * e[1]) / d[2];
e[2] = lambda / d[2]; e[2] = lambda / d[2];
z[2] = w[2] * y[2] - c[1] * z[1]; z[2] = w[2] * y[2] - c[1] * z[1];
for (i = 3; i < m - 1; i++) { for (i = 3; i < m - 1; i++) {
i1 = i - 1; i2 = i - 2; i1 = i - 1; i2 = i - 2;
d[i]= w[i] + 6 * lambda - c[i1] * c[i1] * d[i1] - e[i2] * e[i2] * d[i2]; d[i]= w[i] + 6 * lambda - c[i1] * c[i1] * d[i1] - e[i2] * e[i2] * d[i2];
@ -907,18 +1013,18 @@ cmsBool smooth2(cmsContext ContextID, cmsFloat32Number w[], cmsFloat32Number y[]
e[i] = lambda / d[i]; e[i] = lambda / d[i];
z[i] = w[i] * y[i] - c[i1] * z[i1] - e[i2] * z[i2]; z[i] = w[i] * y[i] - c[i1] * z[i1] - e[i2] * z[i2];
} }
i1 = m - 2; i2 = m - 3; 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]; 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]; 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]; z[m - 1] = w[m - 1] * y[m - 1] - c[i1] * z[i1] - e[i2] * z[i2];
i1 = m - 1; i2 = m - 2; i1 = m - 1; i2 = m - 2;
d[m] = w[m] + lambda - c[i1] * c[i1] * d[i1] - e[i2] * e[i2] * d[i2]; 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] = (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]; z[m - 1] = z[m - 1] / d[m - 1] - c[m - 1] * z[m];
for (i = m - 2; 1<= i; i--) for (i = m - 2; 1<= i; i--)
z[i] = z[i] / d[i] - c[i] * z[i + 1] - e[i] * z[i + 2]; z[i] = z[i] / d[i] - c[i] * z[i + 1] - e[i] * z[i + 2];
@ -933,7 +1039,7 @@ cmsBool smooth2(cmsContext ContextID, cmsFloat32Number w[], cmsFloat32Number y[]
return st; return st;
} }
// Smooths a curve sampled at regular intervals. // Smooths a curve sampled at regular intervals.
cmsBool CMSEXPORT cmsSmoothToneCurve(cmsToneCurve* Tab, cmsFloat64Number lambda) cmsBool CMSEXPORT cmsSmoothToneCurve(cmsToneCurve* Tab, cmsFloat64Number lambda)
{ {
cmsFloat32Number w[MAX_NODES_IN_CURVE], y[MAX_NODES_IN_CURVE], z[MAX_NODES_IN_CURVE]; cmsFloat32Number w[MAX_NODES_IN_CURVE], y[MAX_NODES_IN_CURVE], z[MAX_NODES_IN_CURVE];
@ -941,7 +1047,7 @@ cmsBool CMSEXPORT cmsSmoothToneCurve(cmsToneCurve* Tab, cmsFloat64Number lambda
if (Tab == NULL) return FALSE; if (Tab == NULL) return FALSE;
if (cmsIsToneCurveLinear(Tab)) return FALSE; // Nothing to do if (cmsIsToneCurveLinear(Tab)) return TRUE; // Nothing to do
nItems = Tab -> nEntries; nItems = Tab -> nEntries;
@ -968,11 +1074,20 @@ cmsBool CMSEXPORT cmsSmoothToneCurve(cmsToneCurve* Tab, cmsFloat64Number lambda
if (z[i] == 0.) Zeros++; if (z[i] == 0.) Zeros++;
if (z[i] >= 65535.) Poles++; 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 (Zeros > (nItems / 3)) {
if (Poles > (nItems / 3)) return FALSE; // Degenerated, mostly poles 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 // Seems ok
for (i=0; i < nItems; i++) { for (i=0; i < nItems; i++) {
@ -1008,20 +1123,42 @@ cmsBool CMSEXPORT cmsIsToneCurveMonotonic(const cmsToneCurve* t)
{ {
int n; int n;
int i, last; int i, last;
cmsBool lDescending;
_cmsAssert(t != NULL); _cmsAssert(t != NULL);
n = t ->nEntries; // Degenerated curves are monotonic? Ok, let's pass them
last = t ->Table16[n-1]; 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; last = t ->Table16[0];
else
last = t ->Table16[i];
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; return TRUE;
@ -1061,10 +1198,10 @@ cmsFloat32Number CMSEXPORT cmsEvalToneCurveFloat(const cmsToneCurve* Curve, cmsF
if (Curve ->nSegments == 0) { if (Curve ->nSegments == 0) {
cmsUInt16Number In, Out; cmsUInt16Number In, Out;
In = (cmsUInt16Number) _cmsQuickSaturateWord(v * 65535.0); In = (cmsUInt16Number) _cmsQuickSaturateWord(v * 65535.0);
Out = cmsEvalToneCurve16(Curve, In); Out = cmsEvalToneCurve16(Curve, In);
return (cmsFloat32Number) (Out / 65535.0); return (cmsFloat32Number) (Out / 65535.0);
} }
@ -1084,21 +1221,21 @@ cmsUInt16Number CMSEXPORT cmsEvalToneCurve16(const cmsToneCurve* Curve, cmsUInt1
// Least squares fitting. // Least squares fitting.
// A mathematical procedure for finding the best-fitting curve to a given set of points by // 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. // 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 // 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. // this allows the residuals to be treated as a continuous differentiable quantity.
// //
// y = f(x) = x ^ g // y = f(x) = x ^ g
// //
// R = (yi - (xi^g)) // R = (yi - (xi^g))
// R2 = (yi - (xi^g))2 // R2 = (yi - (xi^g))2
// SUM R2 = SUM (yi - (xi^g))2 // SUM R2 = SUM (yi - (xi^g))2
// //
// dR2/dg = -2 SUM x^g log(x)(y - x^g) // dR2/dg = -2 SUM x^g log(x)(y - x^g)
// solving for dR2/dg = 0 // solving for dR2/dg = 0
// //
// g = 1/n * SUM(log(y) / log(x)) // g = 1/n * SUM(log(y) / log(x))
cmsFloat64Number CMSEXPORT cmsEstimateGamma(const cmsToneCurve* t, cmsFloat64Number Precision) cmsFloat64Number CMSEXPORT cmsEstimateGamma(const cmsToneCurve* t, cmsFloat64Number Precision)
{ {
@ -1110,13 +1247,13 @@ cmsFloat64Number CMSEXPORT cmsEstimateGamma(const cmsToneCurve* t, cmsFloat64Num
sum = sum2 = n = 0; sum = sum2 = n = 0;
// Excluding endpoints // Excluding endpoints
for (i=1; i < (MAX_NODES_IN_CURVE-1); i++) { for (i=1; i < (MAX_NODES_IN_CURVE-1); i++) {
x = (cmsFloat64Number) i / (MAX_NODES_IN_CURVE-1); x = (cmsFloat64Number) i / (MAX_NODES_IN_CURVE-1);
y = (cmsFloat64Number) cmsEvalToneCurveFloat(t, (cmsFloat32Number) x); 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 // artifacts due to linear ramps
if (y > 0. && y < 1. && x > 0.07) { if (y > 0. && y < 1. && x > 0.07) {

1181
thirdparty/liblcms2/src/cmsgmt.c vendored
View File

File diff suppressed because it is too large Load Diff

535
thirdparty/liblcms2/src/cmshalf.c vendored Normal file
View File

@ -0,0 +1,535 @@
//---------------------------------------------------------------------------------
//
// 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

665
thirdparty/liblcms2/src/cmsintrp.c vendored
View File

File diff suppressed because it is too large Load Diff

774
thirdparty/liblcms2/src/cmsio0.c vendored
View File

File diff suppressed because it is too large Load Diff

586
thirdparty/liblcms2/src/cmsio1.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -56,9 +56,9 @@ static const cmsTagSignature PCS2DeviceFloat[] = {cmsSigBToD0Tag, // Percept
// Several resources for gray conversions. // Several resources for gray conversions.
static const cmsFloat64Number GrayInputMatrix[] = { (InpAdj*cmsD50X), (InpAdj*cmsD50Y), (InpAdj*cmsD50Z) }; static const cmsFloat64Number GrayInputMatrix[] = { (InpAdj*cmsD50X), (InpAdj*cmsD50Y), (InpAdj*cmsD50Z) };
static const cmsFloat64Number OneToThreeInputMatrix[] = { 1, 1, 1 }; static const cmsFloat64Number OneToThreeInputMatrix[] = { 1, 1, 1 };
static const cmsFloat64Number PickYMatrix[] = { 0, (OutpAdj*cmsD50Y), 0 }; static const cmsFloat64Number PickYMatrix[] = { 0, (OutpAdj*cmsD50Y), 0 };
static const cmsFloat64Number PickLstarMatrix[] = { 1, 0, 0 }; static const cmsFloat64Number PickLstarMatrix[] = { 1, 0, 0 };
// Get a media white point fixing some issues found in certain old profiles // Get a media white point fixing some issues found in certain old profiles
cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ* Dest, cmsHPROFILE hProfile) cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ* Dest, cmsHPROFILE hProfile)
@ -67,7 +67,7 @@ cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ* Dest, cmsHPROFILE hProfile)
_cmsAssert(Dest != NULL); _cmsAssert(Dest != NULL);
Tag = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag); Tag = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag);
// If no wp, take D50 // If no wp, take D50
if (Tag == NULL) { if (Tag == NULL) {
@ -80,7 +80,7 @@ cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ* Dest, cmsHPROFILE hProfile)
if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) { if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) {
*Dest = *cmsD50_XYZ(); *Dest = *cmsD50_XYZ();
return TRUE; return TRUE;
} }
} }
@ -100,7 +100,6 @@ cmsBool _cmsReadCHAD(cmsMAT3* Dest, cmsHPROFILE hProfile)
Tag = (cmsMAT3*) cmsReadTag(hProfile, cmsSigChromaticAdaptationTag); Tag = (cmsMAT3*) cmsReadTag(hProfile, cmsSigChromaticAdaptationTag);
if (Tag != NULL) { if (Tag != NULL) {
*Dest = *Tag; *Dest = *Tag;
return TRUE; return TRUE;
} }
@ -113,7 +112,7 @@ cmsBool _cmsReadCHAD(cmsMAT3* Dest, cmsHPROFILE hProfile)
if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) { if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) {
cmsCIEXYZ* White = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag); cmsCIEXYZ* White = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag);
if (White == NULL) { if (White == NULL) {
@ -121,7 +120,7 @@ cmsBool _cmsReadCHAD(cmsMAT3* Dest, cmsHPROFILE hProfile)
return TRUE; return TRUE;
} }
return _cmsAdaptationMatrix(Dest, NULL, cmsD50_XYZ(), White); return _cmsAdaptationMatrix(Dest, NULL, White, cmsD50_XYZ());
} }
} }
@ -141,7 +140,7 @@ cmsBool ReadICCMatrixRGB2XYZ(cmsMAT3* r, cmsHPROFILE hProfile)
PtrGreen = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigGreenColorantTag); PtrGreen = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigGreenColorantTag);
PtrBlue = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigBlueColorantTag); PtrBlue = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigBlueColorantTag);
if (PtrRed == NULL || PtrGreen == NULL || PtrBlue == NULL) if (PtrRed == NULL || PtrGreen == NULL || PtrBlue == NULL)
return FALSE; return FALSE;
_cmsVEC3init(&r -> v[0], PtrRed -> X, PtrGreen -> X, PtrBlue -> X); _cmsVEC3init(&r -> v[0], PtrRed -> X, PtrGreen -> X, PtrBlue -> X);
@ -159,12 +158,13 @@ cmsPipeline* BuildGrayInputMatrixPipeline(cmsHPROFILE hProfile)
cmsToneCurve *GrayTRC; cmsToneCurve *GrayTRC;
cmsPipeline* Lut; cmsPipeline* Lut;
cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsContext ContextID = cmsGetProfileContextID(hProfile);
GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag); GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag);
if (GrayTRC == NULL) return NULL; if (GrayTRC == NULL) return NULL;
Lut = cmsPipelineAlloc(ContextID, 1, 3); Lut = cmsPipelineAlloc(ContextID, 1, 3);
if (Lut == NULL) return NULL; if (Lut == NULL)
goto Error;
if (cmsGetPCS(hProfile) == cmsSigLabData) { if (cmsGetPCS(hProfile) == cmsSigLabData) {
@ -172,31 +172,38 @@ cmsPipeline* BuildGrayInputMatrixPipeline(cmsHPROFILE hProfile)
cmsUInt16Number Zero[2] = { 0x8080, 0x8080 }; cmsUInt16Number Zero[2] = { 0x8080, 0x8080 };
cmsToneCurve* EmptyTab; cmsToneCurve* EmptyTab;
cmsToneCurve* LabCurves[3]; cmsToneCurve* LabCurves[3];
EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
if (EmptyTab == NULL) { EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
cmsPipelineFree(Lut); if (EmptyTab == NULL)
return NULL; goto Error;
}
LabCurves[0] = GrayTRC; LabCurves[0] = GrayTRC;
LabCurves[1] = EmptyTab; LabCurves[1] = EmptyTab;
LabCurves[2] = EmptyTab; LabCurves[2] = EmptyTab;
cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, OneToThreeInputMatrix, NULL)); if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, OneToThreeInputMatrix, NULL)) ||
cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, LabCurves)); !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, LabCurves))) {
cmsFreeToneCurve(EmptyTab);
goto Error;
}
cmsFreeToneCurve(EmptyTab); cmsFreeToneCurve(EmptyTab);
} }
else { 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; return Lut;
Error:
cmsFreeToneCurve(GrayTRC);
cmsPipelineFree(Lut);
return NULL;
} }
// RGB Matrix shaper // RGB Matrix shaper
@ -212,15 +219,15 @@ cmsPipeline* BuildRGBInputMatrixShaper(cmsHPROFILE hProfile)
if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL; if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL;
// XYZ PCS in encoded in 1.15 format, and the matrix output comes in 0..0xffff range, so // 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) // 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 (i=0; i < 3; i++)
for (j=0; j < 3; j++) for (j=0; j < 3; j++)
Mat.v[i].n[j] *= InpAdj; 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[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag);
Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag); Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag);
@ -230,15 +237,76 @@ cmsPipeline* BuildRGBInputMatrixShaper(cmsHPROFILE hProfile)
Lut = cmsPipelineAlloc(ContextID, 3, 3); Lut = cmsPipelineAlloc(ContextID, 3, 3);
if (Lut != NULL) { if (Lut != NULL) {
cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, Shapes)); if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, Shapes)) ||
cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Mat, NULL)); !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; 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 // 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) cmsPipeline* _cmsReadInputLUT(cmsHPROFILE hProfile, int Intent)
{ {
cmsTagTypeSignature OriginalType; cmsTagTypeSignature OriginalType;
@ -246,57 +314,95 @@ cmsPipeline* _cmsReadInputLUT(cmsHPROFILE hProfile, int Intent)
cmsTagSignature tagFloat = Device2PCSFloat[Intent]; cmsTagSignature tagFloat = Device2PCSFloat[Intent];
cmsContext ContextID = cmsGetProfileContextID(hProfile); 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 cmsPipeline* Lut;
return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); cmsNAMEDCOLORLIST* nc = (cmsNAMEDCOLORLIST*) cmsReadTag(hProfile, cmsSigNamedColor2Tag);
}
// Revert to perceptual if no tag is found if (nc == NULL) return NULL;
if (!cmsIsTag(hProfile, tag16)) {
tag16 = Device2PCS16[0];
}
if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table? Lut = cmsPipelineAlloc(ContextID, 0, 0);
if (Lut == NULL) {
cmsFreeNamedColorList(nc);
return NULL;
}
// Check profile version and LUT type. Do the necessary adjustments if needed if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocNamedColor(nc, TRUE)) ||
!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID))) {
// First read the tag cmsPipelineFree(Lut);
cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16); return NULL;
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;
// Add a matrix for conversion V2 to V4 Lab PCS
cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID));
return Lut; return Lut;
} }
// 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) {
if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
// 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);
}
// Revert to perceptual if no tag is found
if (!cmsIsTag(hProfile, tag16)) {
tag16 = Device2PCS16[0];
}
if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
// Check profile version and LUT type. Do the necessary adjustments if needed
// 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 // Lut was not found, try to create a matrix-shaper
// Check if this is a grayscale profile. // Check if this is a grayscale profile.
if (cmsGetColorSpace(hProfile) == cmsSigGrayData) { 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 // 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); 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 // 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. // 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. // The complete pipeline on XYZ is Matrix[3:1] -> Tone curve and in Lab Matrix[3:1] -> Tone Curve as well.
@ -308,7 +414,7 @@ cmsPipeline* BuildGrayOutputPipeline(cmsHPROFILE hProfile)
cmsPipeline* Lut; cmsPipeline* Lut;
cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsContext ContextID = cmsGetProfileContextID(hProfile);
GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag); GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag);
if (GrayTRC == NULL) return NULL; if (GrayTRC == NULL) return NULL;
RevGrayTRC = cmsReverseToneCurve(GrayTRC); RevGrayTRC = cmsReverseToneCurve(GrayTRC);
@ -322,21 +428,27 @@ cmsPipeline* BuildGrayOutputPipeline(cmsHPROFILE hProfile)
if (cmsGetPCS(hProfile) == cmsSigLabData) { 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 { 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)); if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &RevGrayTRC)))
goto Error;
cmsFreeToneCurve(RevGrayTRC); cmsFreeToneCurve(RevGrayTRC);
return Lut; return Lut;
Error:
cmsFreeToneCurve(RevGrayTRC);
cmsPipelineFree(Lut);
return NULL;
} }
static static
cmsPipeline* BuildRGBOutputMatrixShaper(cmsHPROFILE hProfile) cmsPipeline* BuildRGBOutputMatrixShaper(cmsHPROFILE hProfile)
{ {
@ -353,14 +465,14 @@ cmsPipeline* BuildRGBOutputMatrixShaper(cmsHPROFILE hProfile)
return NULL; return NULL;
// XYZ PCS in encoded in 1.15 format, and the matrix input should come in 0..0xffff range, so // 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; // (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 (i=0; i < 3; i++)
for (j=0; j < 3; j++) for (j=0; j < 3; j++)
Inv.v[i].n[j] *= OutpAdj; 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[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag);
Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag); Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag);
@ -371,19 +483,33 @@ cmsPipeline* BuildRGBOutputMatrixShaper(cmsHPROFILE hProfile)
InvShapes[1] = cmsReverseToneCurve(Shapes[1]); InvShapes[1] = cmsReverseToneCurve(Shapes[1]);
InvShapes[2] = cmsReverseToneCurve(Shapes[2]); InvShapes[2] = cmsReverseToneCurve(Shapes[2]);
if (!InvShapes[0] || !InvShapes[1] || !InvShapes[2]) { if (!InvShapes[0] || !InvShapes[1] || !InvShapes[2]) {
return NULL; return NULL;
} }
Lut = cmsPipelineAlloc(ContextID, 3, 3); Lut = cmsPipelineAlloc(ContextID, 3, 3);
if (Lut != NULL) { if (Lut != NULL) {
cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Inv, NULL)); // Note that it is certainly possible a single profile would have a LUT based
cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, InvShapes)); // 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); cmsFreeToneCurveTriple(InvShapes);
return Lut; return Lut;
Error:
cmsFreeToneCurveTriple(InvShapes);
cmsPipelineFree(Lut);
return NULL;
} }
@ -402,11 +528,56 @@ void ChangeInterpolationToTrilinear(cmsPipeline* Lut)
_cmsStageCLutData* CLUT = (_cmsStageCLutData*) Stage ->Data; _cmsStageCLutData* CLUT = (_cmsStageCLutData*) Stage ->Data;
CLUT ->Params->dwFlags |= CMS_LERP_FLAGS_TRILINEAR; 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 // Create an output MPE LUT from agiven profile. Version mismatches are handled here
cmsPipeline* _cmsReadOutputLUT(cmsHPROFILE hProfile, int Intent) cmsPipeline* _cmsReadOutputLUT(cmsHPROFILE hProfile, int Intent)
{ {
@ -415,63 +586,118 @@ cmsPipeline* _cmsReadOutputLUT(cmsHPROFILE hProfile, int Intent)
cmsTagSignature tagFloat = PCS2DeviceFloat[Intent]; cmsTagSignature tagFloat = PCS2DeviceFloat[Intent];
cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsContext ContextID = cmsGetProfileContextID(hProfile);
if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
// Floating point LUT are always V4, so no adjustment is required if (Intent != -1) {
return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
}
// Revert to perceptual if no tag is found if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
if (!cmsIsTag(hProfile, tag16)) {
tag16 = PCS2Device16[0];
}
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 if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16);
if (Lut == NULL) return NULL;
// After reading it, we have info about the original type // Check profile version and LUT type. Do the necessary adjustments if needed
OriginalType = _cmsGetTagTrueType(hProfile, tag16);
// The profile owns the Lut, so we need to copy it // First read the tag
Lut = cmsPipelineDup(Lut); cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16);
if (Lut == NULL) return NULL; if (Lut == NULL) return NULL;
// Now it is time for a controversial stuff. I found that for 3D LUTS using // After reading it, we have info about the original type
// Lab used as indexer space, trilinear interpolation should be used OriginalType = _cmsGetTagTrueType(hProfile, tag16);
if (cmsGetPCS(hProfile) == cmsSigLabData)
ChangeInterpolationToTrilinear(Lut); // The profile owns the Lut, so we need to copy it
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 (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;
// We need to adjust data only for Lab and Lut16 type
if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData)
return Lut; return Lut;
Error:
// Add a matrix for conversion V4 to V2 Lab PCS cmsPipelineFree(Lut);
cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)); return NULL;
return Lut; }
} }
// Lut not found, try to create a matrix-shaper // Lut not found, try to create a matrix-shaper
// Check if this is a grayscale profile. // Check if this is a grayscale profile.
if (cmsGetColorSpace(hProfile) == cmsSigGrayData) { 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 // The tables are the PCS iluminant, scaled across GrayTRC
return BuildGrayOutputPipeline(hProfile); 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); 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 // tag name here may default to AToB0
cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent) cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent)
{ {
@ -481,22 +707,48 @@ cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent)
cmsTagSignature tagFloat = Device2PCSFloat[Intent]; cmsTagSignature tagFloat = Device2PCSFloat[Intent];
cmsContext ContextID = cmsGetProfileContextID(hProfile); 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 if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
// Floating point LUT are always V4, no adjustment is required // Floating point LUT are always V
return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); return _cmsReadFloatDevicelinkTag(hProfile, tagFloat);
} }
tagFloat = Device2PCSFloat[0]; tagFloat = Device2PCSFloat[0];
if (cmsIsTag(hProfile, tagFloat)) { if (cmsIsTag(hProfile, tagFloat)) {
return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat));
} }
if (!cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table? if (!cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table?
tag16 = Device2PCS16[0]; 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 // Check profile version and LUT type. Do the necessary adjustments if needed
@ -509,41 +761,45 @@ cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent)
Lut = cmsPipelineDup(Lut); Lut = cmsPipelineDup(Lut);
if (Lut == NULL) return NULL; if (Lut == NULL) return NULL;
// Now it is time for a controversial stuff. I found that for 3D LUTS using // 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 // Lab used as indexer space, trilinear interpolation should be used
if (cmsGetColorSpace(hProfile) == cmsSigLabData) if (cmsGetPCS(hProfile) == cmsSigLabData)
ChangeInterpolationToTrilinear(Lut); ChangeInterpolationToTrilinear(Lut);
// After reading it, we have info about the original type // After reading it, we have info about the original type
OriginalType = _cmsGetTagTrueType(hProfile, tag16); OriginalType = _cmsGetTagTrueType(hProfile, tag16);
// We need to adjust data for Lab16 on output // We need to adjust data for Lab16 on output
if (OriginalType != cmsSigLut16Type) return Lut; if (OriginalType != cmsSigLut16Type) return Lut;
// Here it is possible to get Lab on both sides // Here it is possible to get Lab on both sides
if (cmsGetPCS(hProfile) == cmsSigLabData) { if (cmsGetColorSpace(hProfile) == cmsSigLabData) {
cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)); if(!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)))
goto Error2;
} }
if (cmsGetColorSpace(hProfile) == cmsSigLabData) { if (cmsGetPCS(hProfile) == cmsSigLabData) {
cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)); if(!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)))
goto Error2;
} }
return Lut; return Lut;
Error2:
cmsPipelineFree(Lut);
return NULL;
} }
// --------------------------------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------------------------
// Returns TRUE if the profile is implemented as matrix-shaper // Returns TRUE if the profile is implemented as matrix-shaper
cmsBool CMSEXPORT cmsIsMatrixShaper(cmsHPROFILE hProfile) cmsBool CMSEXPORT cmsIsMatrixShaper(cmsHPROFILE hProfile)
{ {
switch (cmsGetColorSpace(hProfile)) { switch (cmsGetColorSpace(hProfile)) {
case cmsSigGrayData: case cmsSigGrayData:
return cmsIsTag(hProfile, cmsSigGrayTRCTag); return cmsIsTag(hProfile, cmsSigGrayTRCTag);
case cmsSigRgbData: case cmsSigRgbData:
@ -563,7 +819,7 @@ cmsBool CMSEXPORT cmsIsMatrixShaper(cmsHPROFILE hProfile)
// Returns TRUE if the intent is implemented as CLUT // Returns TRUE if the intent is implemented as CLUT
cmsBool CMSEXPORT cmsIsCLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number UsedDirection) cmsBool CMSEXPORT cmsIsCLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number UsedDirection)
{ {
const cmsTagSignature* TagTable; const cmsTagSignature* TagTable;
// For devicelinks, the supported intent is that one stated in the header // For devicelinks, the supported intent is that one stated in the header
@ -574,10 +830,10 @@ cmsBool CMSEXPORT cmsIsCLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUI
switch (UsedDirection) { switch (UsedDirection) {
case LCMS_USED_AS_INPUT: TagTable = Device2PCS16; break; 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 // 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) && return cmsIsIntentSupported(hProfile, Intent, LCMS_USED_AS_INPUT) &&
cmsIsIntentSupported(hProfile, INTENT_RELATIVE_COLORIMETRIC, LCMS_USED_AS_OUTPUT); cmsIsIntentSupported(hProfile, INTENT_RELATIVE_COLORIMETRIC, LCMS_USED_AS_OUTPUT);
@ -611,7 +867,6 @@ cmsBool CMSEXPORT cmsIsIntentSupported(cmsHPROFILE hProfile,
// Read both, profile sequence description and profile sequence id if present. Then combine both to // 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. // create qa unique structure holding both. Shame on ICC to store things in such complicated way.
cmsSEQ* _cmsReadProfileSequence(cmsHPROFILE hProfile) cmsSEQ* _cmsReadProfileSequence(cmsHPROFILE hProfile)
{ {
cmsSEQ* ProfileSeq; cmsSEQ* ProfileSeq;
@ -621,7 +876,7 @@ cmsSEQ* _cmsReadProfileSequence(cmsHPROFILE hProfile)
// Take profile sequence description first // Take profile sequence description first
ProfileSeq = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceDescTag); ProfileSeq = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceDescTag);
// Take profile sequence ID // Take profile sequence ID
ProfileId = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceIdTag); ProfileId = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceIdTag);
@ -630,18 +885,19 @@ cmsSEQ* _cmsReadProfileSequence(cmsHPROFILE hProfile)
if (ProfileSeq == NULL) return cmsDupProfileSequenceDescription(ProfileId); if (ProfileSeq == NULL) return cmsDupProfileSequenceDescription(ProfileId);
if (ProfileId == NULL) return cmsDupProfileSequenceDescription(ProfileSeq); 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); if (ProfileSeq ->n != ProfileId ->n) return cmsDupProfileSequenceDescription(ProfileSeq);
NewSeq = 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);
}
// Ok, proceed to the mixing
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; return NewSeq;
} }
@ -682,22 +938,22 @@ cmsSEQ* _cmsCompileProfileSequence(cmsContext ContextID, cmsUInt32Number nProfil
cmsPSEQDESC* ps = &seq ->seq[i]; cmsPSEQDESC* ps = &seq ->seq[i];
cmsHPROFILE h = hProfiles[i]; cmsHPROFILE h = hProfiles[i];
cmsTechnologySignature* techpt; cmsTechnologySignature* techpt;
cmsGetHeaderAttributes(h, &ps ->attributes); cmsGetHeaderAttributes(h, &ps ->attributes);
cmsGetHeaderProfileID(h, ps ->ProfileID.ID8); cmsGetHeaderProfileID(h, ps ->ProfileID.ID8);
ps ->deviceMfg = cmsGetHeaderManufacturer(h); ps ->deviceMfg = cmsGetHeaderManufacturer(h);
ps ->deviceModel = cmsGetHeaderModel(h); ps ->deviceModel = cmsGetHeaderModel(h);
techpt = (cmsTechnologySignature*) cmsReadTag(h, cmsSigTechnologyTag); techpt = (cmsTechnologySignature*) cmsReadTag(h, cmsSigTechnologyTag);
if (techpt == NULL) if (techpt == NULL)
ps ->technology = (cmsTechnologySignature) 0; ps ->technology = (cmsTechnologySignature) 0;
else else
ps ->technology = *techpt; ps ->technology = *techpt;
ps ->Manufacturer = GetMLUFromProfile(h, cmsSigDeviceMfgDescTag); ps ->Manufacturer = GetMLUFromProfile(h, cmsSigDeviceMfgDescTag);
ps ->Model = GetMLUFromProfile(h, cmsSigDeviceModelDescTag); ps ->Model = GetMLUFromProfile(h, cmsSigDeviceModelDescTag);
ps ->Description = GetMLUFromProfile(h, cmsSigProfileDescriptionTag); ps ->Description = GetMLUFromProfile(h, cmsSigProfileDescriptionTag);
} }
return seq; return seq;
@ -714,7 +970,7 @@ const cmsMLU* GetInfo(cmsHPROFILE hProfile, cmsInfoType Info)
switch (Info) { switch (Info) {
case cmsInfoDescription: case cmsInfoDescription:
sig = cmsSigProfileDescriptionTag; sig = cmsSigProfileDescriptionTag;
break; break;
case cmsInfoManufacturer: case cmsInfoManufacturer:
@ -738,8 +994,8 @@ const cmsMLU* GetInfo(cmsHPROFILE hProfile, cmsInfoType Info)
cmsUInt32Number CMSEXPORT cmsGetProfileInfo(cmsHPROFILE hProfile, cmsInfoType Info, cmsUInt32Number CMSEXPORT cmsGetProfileInfo(cmsHPROFILE hProfile, cmsInfoType Info,
const char LanguageCode[3], const char CountryCode[3], const char LanguageCode[3], const char CountryCode[3],
wchar_t* Buffer, cmsUInt32Number BufferSize) wchar_t* Buffer, cmsUInt32Number BufferSize)
{ {
const cmsMLU* mlu = GetInfo(hProfile, Info); const cmsMLU* mlu = GetInfo(hProfile, Info);
@ -749,8 +1005,8 @@ cmsUInt32Number CMSEXPORT cmsGetProfileInfo(cmsHPROFILE hProfile, cmsInfoType In
} }
cmsUInt32Number CMSEXPORT cmsGetProfileInfoASCII(cmsHPROFILE hProfile, cmsInfoType Info, cmsUInt32Number CMSEXPORT cmsGetProfileInfoASCII(cmsHPROFILE hProfile, cmsInfoType Info,
const char LanguageCode[3], const char CountryCode[3], const char LanguageCode[3], const char CountryCode[3],
char* Buffer, cmsUInt32Number BufferSize) char* Buffer, cmsUInt32Number BufferSize)
{ {
const cmsMLU* mlu = GetInfo(hProfile, Info); const cmsMLU* mlu = GetInfo(hProfile, Info);

640
thirdparty/liblcms2/src/cmslut.c vendored
View File

File diff suppressed because it is too large Load Diff

48
thirdparty/liblcms2/src/cmsmd5.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -42,7 +42,7 @@ void byteReverse(cmsUInt8Number * buf, cmsUInt32Number longs)
} }
#else #else
#define byteReverse(buf, len) #define byteReverse(buf, len)
#endif #endif
@ -66,7 +66,7 @@ typedef struct {
static static
void MD5_Transform(cmsUInt32Number buf[4], cmsUInt32Number in[16]) void MD5_Transform(cmsUInt32Number buf[4], cmsUInt32Number in[16])
{ {
register cmsUInt32Number a, b, c, d; register cmsUInt32Number a, b, c, d;
@ -176,14 +176,14 @@ void MD5add(cmsHANDLE Handle, cmsUInt8Number* buf, cmsUInt32Number len)
{ {
_cmsMD5* ctx = (_cmsMD5*) Handle; _cmsMD5* ctx = (_cmsMD5*) Handle;
cmsUInt32Number t; cmsUInt32Number t;
t = ctx->bits[0]; t = ctx->bits[0];
if ((ctx->bits[0] = t + (len << 3)) < t) if ((ctx->bits[0] = t + (len << 3)) < t)
ctx->bits[1]++; ctx->bits[1]++;
ctx->bits[1] += len >> 29; ctx->bits[1] += len >> 29;
t = (t >> 3) & 0x3f; t = (t >> 3) & 0x3f;
if (t) { if (t) {
@ -265,15 +265,15 @@ cmsBool CMSEXPORT cmsMD5computeID(cmsHPROFILE hProfile)
cmsUInt8Number* Mem = NULL; cmsUInt8Number* Mem = NULL;
cmsHANDLE MD5 = NULL; cmsHANDLE MD5 = NULL;
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile; _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
_cmsICCPROFILE Keep; _cmsICCPROFILE Keep;
_cmsAssert(hProfile != NULL); _cmsAssert(hProfile != NULL);
ContextID = cmsGetProfileContextID(hProfile); ContextID = cmsGetProfileContextID(hProfile);
// Save a copy of the profile header // Save a copy of the profile header
memmove(&Keep, Icc, sizeof(_cmsICCPROFILE)); memmove(&Keep, Icc, sizeof(_cmsICCPROFILE));
// Set RI, attributes and ID // Set RI, attributes and ID
memset(&Icc ->attributes, 0, sizeof(Icc ->attributes)); memset(&Icc ->attributes, 0, sizeof(Icc ->attributes));
Icc ->RenderingIntent = 0; Icc ->RenderingIntent = 0;
@ -288,7 +288,7 @@ cmsBool CMSEXPORT cmsMD5computeID(cmsHPROFILE hProfile)
// Save to temporary storage // Save to temporary storage
if (!cmsSaveProfileToMem(hProfile, Mem, &BytesNeeded)) goto Error; if (!cmsSaveProfileToMem(hProfile, Mem, &BytesNeeded)) goto Error;
// Create MD5 object // Create MD5 object
MD5 = MD5alloc(ContextID); MD5 = MD5alloc(ContextID);
if (MD5 == NULL) goto Error; if (MD5 == NULL) goto Error;
@ -298,7 +298,7 @@ cmsBool CMSEXPORT cmsMD5computeID(cmsHPROFILE hProfile)
// Temp storage is no longer needed // Temp storage is no longer needed
_cmsFree(ContextID, Mem); _cmsFree(ContextID, Mem);
// Restore header // Restore header
memmove(Icc, &Keep, sizeof(_cmsICCPROFILE)); memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
@ -309,7 +309,7 @@ cmsBool CMSEXPORT cmsMD5computeID(cmsHPROFILE hProfile)
Error: Error:
// Free resources as something went wrong // 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); if (Mem != NULL) _cmsFree(ContextID, Mem);
memmove(Icc, &Keep, sizeof(_cmsICCPROFILE)); memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
return FALSE; return FALSE;

44
thirdparty/liblcms2/src/cmsmtrx.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -30,7 +30,7 @@
#define DSWAP(x, y) {cmsFloat64Number tmp = (x); (x)=(y); (y)=tmp;} #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) void CMSEXPORT _cmsVEC3init(cmsVEC3* r, cmsFloat64Number x, cmsFloat64Number y, cmsFloat64Number z)
{ {
r -> n[VX] = x; r -> n[VX] = x;
@ -60,7 +60,7 @@ cmsFloat64Number CMSEXPORT _cmsVEC3dot(const cmsVEC3* u, const cmsVEC3* v)
return u->n[VX] * v->n[VX] + u->n[VY] * v->n[VY] + u->n[VZ] * v->n[VZ]; 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) cmsFloat64Number CMSEXPORT _cmsVEC3length(const cmsVEC3* a)
{ {
return sqrt(a ->n[VX] * a ->n[VX] + return sqrt(a ->n[VX] * a ->n[VX] +
@ -97,16 +97,16 @@ cmsBool CloseEnough(cmsFloat64Number a, cmsFloat64Number b)
cmsBool CMSEXPORT _cmsMAT3isIdentity(const cmsMAT3* a) cmsBool CMSEXPORT _cmsMAT3isIdentity(const cmsMAT3* a)
{ {
cmsMAT3 Identity; cmsMAT3 Identity;
int i, j; int i, j;
_cmsMAT3identity(&Identity); _cmsMAT3identity(&Identity);
for (i=0; i < 3; i++) for (i=0; i < 3; i++)
for (j=0; j < 3; j++) for (j=0; j < 3; j++)
if (!CloseEnough(a ->v[i].n[j], Identity.v[i].n[j])) return FALSE; if (!CloseEnough(a ->v[i].n[j], Identity.v[i].n[j])) return FALSE;
return TRUE; return TRUE;
} }

585
thirdparty/liblcms2/src/cmsnamed.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -32,81 +32,81 @@
// Allocates an empty multi localizad unicode object // Allocates an empty multi localizad unicode object
cmsMLU* CMSEXPORT cmsMLUalloc(cmsContext ContextID, cmsUInt32Number nItems) cmsMLU* CMSEXPORT cmsMLUalloc(cmsContext ContextID, cmsUInt32Number nItems)
{ {
cmsMLU* mlu; cmsMLU* mlu;
// nItems should be positive if given // nItems should be positive if given
if (nItems <= 0) nItems = 2; if (nItems <= 0) nItems = 2;
// Create the container // Create the container
mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU)); mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU));
if (mlu == NULL) return NULL; if (mlu == NULL) return NULL;
mlu ->ContextID = ContextID; mlu ->ContextID = ContextID;
// Create entry array // Create entry array
mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry)); mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry));
if (mlu ->Entries == NULL) { if (mlu ->Entries == NULL) {
_cmsFree(ContextID, mlu); _cmsFree(ContextID, mlu);
return NULL; return NULL;
} }
// Ok, keep indexes up to date // Ok, keep indexes up to date
mlu ->AllocatedEntries = nItems; mlu ->AllocatedEntries = nItems;
mlu ->UsedEntries = 0; 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 static
cmsBool GrowMLUpool(cmsMLU* mlu) cmsBool GrowMLUpool(cmsMLU* mlu)
{ {
cmsUInt32Number size; cmsUInt32Number size;
void *NewPtr; void *NewPtr;
// Sanity check // Sanity check
if (mlu == NULL) return FALSE; if (mlu == NULL) return FALSE;
if (mlu ->PoolSize == 0) if (mlu ->PoolSize == 0)
size = 256; size = 256;
else else
size = mlu ->PoolSize * 2; size = mlu ->PoolSize * 2;
// Check for overflow // Check for overflow
if (size < mlu ->PoolSize) return FALSE; if (size < mlu ->PoolSize) return FALSE;
// Reallocate the pool // Reallocate the pool
NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size); NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size);
if (NewPtr == NULL) return FALSE; if (NewPtr == NULL) return FALSE;
mlu ->MemPool = NewPtr; mlu ->MemPool = NewPtr;
mlu ->PoolSize = size; 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 static
cmsBool GrowMLUtable(cmsMLU* mlu) cmsBool GrowMLUtable(cmsMLU* mlu)
{ {
int AllocatedEntries; int AllocatedEntries;
_cmsMLUentry *NewPtr; _cmsMLUentry *NewPtr;
// Sanity check // Sanity check
if (mlu == NULL) return FALSE; if (mlu == NULL) return FALSE;
AllocatedEntries = mlu ->AllocatedEntries * 2; AllocatedEntries = mlu ->AllocatedEntries * 2;
// Check for overflow // Check for overflow
if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE; if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE;
// Reallocate the memory // Reallocate the memory
NewPtr = (_cmsMLUentry*)_cmsRealloc(mlu ->ContextID, mlu ->Entries, AllocatedEntries*sizeof(_cmsMLUentry)); NewPtr = (_cmsMLUentry*)_cmsRealloc(mlu ->ContextID, mlu ->Entries, AllocatedEntries*sizeof(_cmsMLUentry));
if (NewPtr == NULL) return FALSE; if (NewPtr == NULL) return FALSE;
mlu ->Entries = NewPtr; mlu ->Entries = NewPtr;
mlu ->AllocatedEntries = AllocatedEntries; mlu ->AllocatedEntries = AllocatedEntries;
@ -114,37 +114,37 @@ cmsBool GrowMLUtable(cmsMLU* mlu)
} }
// 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 static
int SearchMLUEntry(cmsMLU* mlu, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode) int SearchMLUEntry(cmsMLU* mlu, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
{ {
int i; 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++) { 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; mlu ->Entries[i].Language == LanguageCode) return i;
} }
// Not found // Not found
return -1; 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. // Only one entry for Language/country pair is allowed.
static 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) cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
{ {
cmsUInt32Number Offset; cmsUInt32Number Offset;
cmsUInt8Number* Ptr; cmsUInt8Number* Ptr;
// Sanity check // Sanity check
if (mlu == NULL) return FALSE; if (mlu == NULL) return FALSE;
// Is there any room available? // Is there any room available?
if (mlu ->UsedEntries >= mlu ->AllocatedEntries) { if (mlu ->UsedEntries >= mlu ->AllocatedEntries) {
@ -155,20 +155,20 @@ cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,
if (SearchMLUEntry(mlu, LanguageCode, CountryCode) >= 0) return FALSE; // Only one is allowed! if (SearchMLUEntry(mlu, LanguageCode, CountryCode) >= 0) return FALSE; // Only one is allowed!
// Check for size // Check for size
while ((mlu ->PoolSize - mlu ->PoolUsed) < size) { while ((mlu ->PoolSize - mlu ->PoolUsed) < size) {
if (!GrowMLUpool(mlu)) return FALSE; if (!GrowMLUpool(mlu)) return FALSE;
} }
Offset = mlu ->PoolUsed; 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); memmove(Ptr + Offset, Block, size);
mlu ->PoolUsed += size; mlu ->PoolUsed += size;
mlu ->Entries[mlu ->UsedEntries].StrW = Offset; mlu ->Entries[mlu ->UsedEntries].StrW = Offset;
mlu ->Entries[mlu ->UsedEntries].Len = size; mlu ->Entries[mlu ->UsedEntries].Len = size;
mlu ->Entries[mlu ->UsedEntries].Country = CountryCode; mlu ->Entries[mlu ->UsedEntries].Country = CountryCode;
@ -179,7 +179,7 @@ cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,
} }
// Add an ASCII entry. // Add an ASCII entry.
cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString) cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)
{ {
cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString)+1; cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString)+1;
@ -195,21 +195,21 @@ cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const
for (i=0; i < len; i++) for (i=0; i < len; i++)
WStr[i] = (wchar_t) ASCIIString[i]; WStr[i] = (wchar_t) ASCIIString[i];
rc = AddMLUBlock(mlu, len * sizeof(wchar_t), WStr, Lang, Cntry); rc = AddMLUBlock(mlu, len * sizeof(wchar_t), WStr, Lang, Cntry);
_cmsFree(mlu ->ContextID, WStr); _cmsFree(mlu ->ContextID, WStr);
return rc; return rc;
} }
// We don't need any wcs support library // We don't need any wcs support library
static static
cmsUInt32Number mywcslen(const wchar_t *s) cmsUInt32Number mywcslen(const wchar_t *s)
{ {
const wchar_t *p; const wchar_t *p;
p = s; p = s;
while (*p) while (*p)
p++; p++;
@ -223,9 +223,9 @@ cmsBool CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char
cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) Language); cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) Language);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) Country); cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) Country);
cmsUInt32Number len; cmsUInt32Number len;
if (mlu == NULL) return FALSE; if (mlu == NULL) return FALSE;
if (WideString == NULL) return FALSE; if (WideString == NULL) return FALSE;
len = (cmsUInt32Number) (mywcslen(WideString) + 1) * sizeof(wchar_t); len = (cmsUInt32Number) (mywcslen(WideString) + 1) * sizeof(wchar_t);
return AddMLUBlock(mlu, len, WideString, Lang, Cntry); return AddMLUBlock(mlu, len, WideString, Lang, Cntry);
@ -234,73 +234,73 @@ cmsBool CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char
// Duplicating a MLU is as easy as copying all members // Duplicating a MLU is as easy as copying all members
cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu) cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu)
{ {
cmsMLU* NewMlu = NULL; cmsMLU* NewMlu = NULL;
// Duplicating a NULL obtains a NULL // Duplicating a NULL obtains a NULL
if (mlu == NULL) return NULL; if (mlu == NULL) return NULL;
NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries); NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);
if (NewMlu == NULL) return NULL; if (NewMlu == NULL) return NULL;
// Should never happen // Should never happen
if (NewMlu ->AllocatedEntries < mlu ->UsedEntries) if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)
goto Error; goto Error;
// Sanitize... // Sanitize...
if (NewMlu ->Entries == NULL || mlu ->Entries == NULL) goto Error; if (NewMlu ->Entries == NULL || mlu ->Entries == NULL) goto Error;
memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry)); memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));
NewMlu ->UsedEntries = mlu ->UsedEntries; NewMlu ->UsedEntries = mlu ->UsedEntries;
// The MLU may be empty // The MLU may be empty
if (mlu ->PoolUsed == 0) { if (mlu ->PoolUsed == 0) {
NewMlu ->MemPool = NULL; NewMlu ->MemPool = NULL;
} }
else { else {
// It is not empty // It is not empty
NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed); NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);
if (NewMlu ->MemPool == NULL) goto Error; 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); memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);
NewMlu ->PoolUsed = mlu ->PoolUsed; NewMlu ->PoolUsed = mlu ->PoolUsed;
return NewMlu; return NewMlu;
Error: Error:
if (NewMlu != NULL) cmsMLUfree(NewMlu); if (NewMlu != NULL) cmsMLUfree(NewMlu);
return NULL; return NULL;
} }
// Free any used memory // Free any used memory
void CMSEXPORT cmsMLUfree(cmsMLU* mlu) void CMSEXPORT cmsMLUfree(cmsMLU* mlu)
{ {
if (mlu) { if (mlu) {
if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries); if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool); 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. // the Language. If none is found, first entry is used instead.
static static
const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu, const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
cmsUInt32Number *len, cmsUInt32Number *len,
cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,
cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode) cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)
{ {
int i; int i;
int Best = -1; int Best = -1;
_cmsMLUentry* v; _cmsMLUentry* v;
if (mlu == NULL) return NULL; if (mlu == NULL) return NULL;
@ -316,12 +316,12 @@ const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
if (v -> Country == CountryCode) { if (v -> Country == CountryCode) {
if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language; if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country; if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country;
if (len != NULL) *len = v ->Len; 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
} }
} }
} }
@ -330,30 +330,30 @@ const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
if (Best == -1) if (Best == -1)
Best = 0; Best = 0;
v = mlu ->Entries + Best; v = mlu ->Entries + Best;
if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language; if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country; if (UsedCountryCode != NULL) *UsedCountryCode = v ->Country;
if (len != NULL) *len = v ->Len; 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 // Obtain an ASCII representation of the wide string. Setting buffer to NULL returns the len
cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu, cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
const char LanguageCode[3], const char CountryCode[3], const char LanguageCode[3], const char CountryCode[3],
char* Buffer, cmsUInt32Number BufferSize) char* Buffer, cmsUInt32Number BufferSize)
{ {
const wchar_t *Wide; const wchar_t *Wide;
cmsUInt32Number StrLen = 0; cmsUInt32Number StrLen = 0;
cmsUInt32Number ASCIIlen, i; cmsUInt32Number ASCIIlen, i;
cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode); cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode); cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
// Sanitize // Sanitize
if (mlu == NULL) return 0; if (mlu == NULL) return 0;
// Get WideChar // Get WideChar
@ -373,7 +373,7 @@ cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
ASCIIlen = BufferSize - 1; ASCIIlen = BufferSize - 1;
// Precess each character // Precess each character
for (i=0; i < ASCIIlen; i++) { for (i=0; i < ASCIIlen; i++) {
if (Wide[i] == 0) if (Wide[i] == 0)
Buffer[i] = 0; Buffer[i] = 0;
@ -381,28 +381,28 @@ cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
Buffer[i] = (char) Wide[i]; Buffer[i] = (char) Wide[i];
} }
// We put a termination "\0" // We put a termination "\0"
Buffer[ASCIIlen] = 0; Buffer[ASCIIlen] = 0;
return ASCIIlen + 1; return ASCIIlen + 1;
} }
// Obtain a wide representation of the MLU, on depending on current locale settings // Obtain a wide representation of the MLU, on depending on current locale settings
cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu, cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
const char LanguageCode[3], const char CountryCode[3], const char LanguageCode[3], const char CountryCode[3],
wchar_t* Buffer, cmsUInt32Number BufferSize) wchar_t* Buffer, cmsUInt32Number BufferSize)
{ {
const wchar_t *Wide; const wchar_t *Wide;
cmsUInt32Number StrLen = 0; cmsUInt32Number StrLen = 0;
cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode); cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode); cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
// Sanitize // Sanitize
if (mlu == NULL) return 0; if (mlu == NULL) return 0;
Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL); Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
if (Wide == NULL) return 0; if (Wide == NULL) return 0;
// Maybe we want only to know the len? // Maybe we want only to know the len?
if (Buffer == NULL) return StrLen + sizeof(wchar_t); if (Buffer == NULL) return StrLen + sizeof(wchar_t);
@ -414,35 +414,64 @@ cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
StrLen = BufferSize - + sizeof(wchar_t); StrLen = BufferSize - + sizeof(wchar_t);
memmove(Buffer, Wide, StrLen); memmove(Buffer, Wide, StrLen);
Buffer[StrLen / sizeof(wchar_t)] = 0; Buffer[StrLen / sizeof(wchar_t)] = 0;
return StrLen + sizeof(wchar_t); return StrLen + sizeof(wchar_t);
} }
// Get also the language and country // Get also the language and country
CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu, CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
const char LanguageCode[3], const char CountryCode[3], const char LanguageCode[3], const char CountryCode[3],
char ObtainedLanguage[3], char ObtainedCountry[3]) char ObtainedLanguage[3], char ObtainedCountry[3])
{ {
const wchar_t *Wide; const wchar_t *Wide;
cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
cmsUInt16Number ObtLang, ObtCode;
// Sanitize cmsUInt16Number Lang = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
cmsUInt16Number ObtLang, ObtCode;
// Sanitize
if (mlu == NULL) return FALSE; if (mlu == NULL) return FALSE;
Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode); Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode);
if (Wide == NULL) return FALSE; if (Wide == NULL) return FALSE;
// Get used language and code
*(cmsUInt16Number *)ObtainedLanguage = _cmsAdjustEndianess16(ObtLang);
*(cmsUInt16Number *)ObtainedCountry = _cmsAdjustEndianess16(ObtCode);
ObtainedLanguage[2] = ObtainedCountry[2] = 0; // Get used language and code
return TRUE; *(cmsUInt16Number *)ObtainedLanguage = _cmsAdjustEndianess16(ObtLang);
*(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);
return TRUE;
} }
@ -451,7 +480,7 @@ CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
// Grow the list to keep at least NumElements // Grow the list to keep at least NumElements
static static
cmsBool GrowNamedColorList(cmsNAMEDCOLORLIST* v) cmsBool GrowNamedColorList(cmsNAMEDCOLORLIST* v)
{ {
cmsUInt32Number size; cmsUInt32Number size;
_cmsNAMEDCOLOR * NewPtr; _cmsNAMEDCOLOR * NewPtr;
@ -466,9 +495,9 @@ cmsBool GrowNamedColorList(cmsNAMEDCOLORLIST* v)
if (size > 1024*100) return FALSE; if (size > 1024*100) return FALSE;
NewPtr = (_cmsNAMEDCOLOR*) _cmsRealloc(v ->ContextID, v ->List, size * sizeof(_cmsNAMEDCOLOR)); NewPtr = (_cmsNAMEDCOLOR*) _cmsRealloc(v ->ContextID, v ->List, size * sizeof(_cmsNAMEDCOLOR));
if (NewPtr == NULL) if (NewPtr == NULL)
return FALSE; return FALSE;
v ->List = NewPtr; v ->List = NewPtr;
v ->Allocated = size; v ->Allocated = size;
return TRUE; return TRUE;
@ -478,9 +507,9 @@ cmsBool GrowNamedColorList(cmsNAMEDCOLORLIST* v)
cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUInt32Number n, cmsUInt32Number ColorantCount, const char* Prefix, const char* Suffix) cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUInt32Number n, cmsUInt32Number ColorantCount, const char* Prefix, const char* Suffix)
{ {
cmsNAMEDCOLORLIST* v = (cmsNAMEDCOLORLIST*) _cmsMallocZero(ContextID, sizeof(cmsNAMEDCOLORLIST)); cmsNAMEDCOLORLIST* v = (cmsNAMEDCOLORLIST*) _cmsMallocZero(ContextID, sizeof(cmsNAMEDCOLORLIST));
if (v == NULL) return NULL; if (v == NULL) return NULL;
v ->List = NULL; v ->List = NULL;
v ->nColors = 0; v ->nColors = 0;
v ->ContextID = ContextID; v ->ContextID = ContextID;
@ -488,8 +517,10 @@ cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUIn
while (v -> Allocated < n) while (v -> Allocated < n)
GrowNamedColorList(v); GrowNamedColorList(v);
strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix)); strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix)-1);
strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix)); strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix)-1);
v->Prefix[32] = v->Suffix[32] = 0;
v -> ColorantCount = ColorantCount; v -> ColorantCount = ColorantCount;
return v; return v;
@ -497,15 +528,16 @@ cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUIn
// Free a list // Free a list
void CMSEXPORT cmsFreeNamedColorList(cmsNAMEDCOLORLIST* v) void CMSEXPORT cmsFreeNamedColorList(cmsNAMEDCOLORLIST* v)
{ {
if (v == NULL) return;
if (v ->List) _cmsFree(v ->ContextID, v ->List); 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* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
{ {
cmsNAMEDCOLORLIST* NewNC; cmsNAMEDCOLORLIST* NewNC;
if (v == NULL) return NULL; if (v == NULL) return NULL;
NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix); NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix);
@ -525,10 +557,10 @@ cmsNAMEDCOLORLIST* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
// Append a color to a list. List pointer may change if reallocated // Append a color to a list. List pointer may change if reallocated
cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
const char* Name, const char* Name,
cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS]) cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS])
{ {
cmsUInt32Number i; cmsUInt32Number i;
if (NamedColorList == NULL) return FALSE; if (NamedColorList == NULL) return FALSE;
@ -543,9 +575,12 @@ cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
for (i=0; i < 3; i++) for (i=0; i < 3; i++)
NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? 0 : PCS[i]; NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? 0 : PCS[i];
if (Name != NULL) if (Name != NULL) {
strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name,
sizeof(NamedColorList ->List[NamedColorList ->nColors].Name)); strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name, cmsMAX_PATH-1);
NamedColorList ->List[NamedColorList ->nColors].Name[cmsMAX_PATH-1] = 0;
}
else else
NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0; NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0;
@ -554,21 +589,21 @@ cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
return TRUE; return TRUE;
} }
// Returns number of elements // Returns number of elements
cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList) cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList)
{ {
if (NamedColorList == NULL) return 0; if (NamedColorList == NULL) return 0;
return NamedColorList ->nColors; return NamedColorList ->nColors;
} }
// Info aboout a given color // Info aboout a given color
cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor, cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
char* Name, char* Name,
char* Prefix, char* Prefix,
char* Suffix, char* Suffix,
cmsUInt16Number* PCS, cmsUInt16Number* PCS,
cmsUInt16Number* Colorant) cmsUInt16Number* Colorant)
{ {
if (NamedColorList == NULL) return FALSE; if (NamedColorList == NULL) return FALSE;
if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE; if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE;
@ -576,11 +611,11 @@ cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cm
if (Name) strcpy(Name, NamedColorList->List[nColor].Name); if (Name) strcpy(Name, NamedColorList->List[nColor].Name);
if (Prefix) strcpy(Prefix, NamedColorList->Prefix); if (Prefix) strcpy(Prefix, NamedColorList->Prefix);
if (Suffix) strcpy(Suffix, NamedColorList->Suffix); if (Suffix) strcpy(Suffix, NamedColorList->Suffix);
if (PCS) if (PCS)
memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number)); memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number));
if (Colorant) if (Colorant)
memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant, memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount); sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount);
@ -589,7 +624,7 @@ cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cm
// Search for a given color name (no prefix or suffix) // Search for a given color name (no prefix or suffix)
cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name) cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name)
{ {
int i, n; int i, n;
if (NamedColorList == NULL) return -1; if (NamedColorList == NULL) return -1;
@ -618,6 +653,24 @@ void* DupNamedColorList(cmsStage* mpe)
return cmsDupNamedColorList(List); 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 static
void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe) void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
{ {
@ -629,23 +682,23 @@ void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const c
cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index); cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
} }
else { else {
for (j=0; j < NamedColorList ->ColorantCount; j++) for (j=0; j < NamedColorList ->ColorantCount; j++)
Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0); Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
} }
} }
// Named color lookup element // Named color lookup element
cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList) cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool UsePCS)
{ {
return _cmsStageAllocPlaceholder(NamedColorList ->ContextID, return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
cmsSigNamedColorElemType, cmsSigNamedColorElemType,
1, 3, 1, UsePCS ? 3 : NamedColorList ->ColorantCount,
EvalNamedColor, UsePCS ? EvalNamedColorPCS : EvalNamedColor,
DupNamedColorList, DupNamedColorList,
FreeNamedColorList, FreeNamedColorList,
cmsDupNamedColorList(NamedColorList)); cmsDupNamedColorList(NamedColorList));
} }
@ -674,19 +727,23 @@ cmsSEQ* CMSEXPORT cmsAllocProfileSequenceDescription(cmsContext ContextID, cmsUI
if (n > 255) return NULL; if (n > 255) return NULL;
Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ)); Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ));
if (Seq == NULL) return NULL; if (Seq == NULL) return NULL;
Seq -> ContextID = ContextID; Seq -> ContextID = ContextID;
Seq -> seq = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC)); Seq -> seq = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC));
Seq -> n = n; Seq -> n = n;
if (Seq -> seq == NULL) {
_cmsFree(ContextID, Seq);
return NULL;
}
for (i=0; i < n; i++) { for (i=0; i < n; i++) {
Seq -> seq[i].Manufacturer = NULL; Seq -> seq[i].Manufacturer = NULL;
Seq -> seq[i].Model = NULL; Seq -> seq[i].Model = NULL;
Seq -> seq[i].Description = NULL; Seq -> seq[i].Description = NULL;
} }
return Seq; return Seq;
} }
@ -715,10 +772,10 @@ cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq)
NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ)); NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ));
if (NewSeq == NULL) return NULL; if (NewSeq == NULL) return NULL;
NewSeq -> seq = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC)); NewSeq -> seq = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC));
if (NewSeq ->seq == NULL) goto Error; if (NewSeq ->seq == NULL) goto Error;
NewSeq -> ContextID = pseq ->ContextID; NewSeq -> ContextID = pseq ->ContextID;
NewSeq -> n = pseq ->n; NewSeq -> n = pseq ->n;
@ -734,7 +791,7 @@ cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq)
NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer); NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer);
NewSeq ->seq[i].Model = cmsMLUdup(pseq ->seq[i].Model); NewSeq ->seq[i].Model = cmsMLUdup(pseq ->seq[i].Model);
NewSeq ->seq[i].Description = cmsMLUdup(pseq ->seq[i].Description); NewSeq ->seq[i].Description = cmsMLUdup(pseq ->seq[i].Description);
} }
return NewSeq; return NewSeq;
@ -745,6 +802,128 @@ Error:
return NULL; 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;
}

656
thirdparty/liblcms2/src/cmsopt.c vendored
View File

File diff suppressed because it is too large Load Diff

1939
thirdparty/liblcms2/src/cmspack.c vendored
View File

File diff suppressed because it is too large Load Diff

203
thirdparty/liblcms2/src/cmspcs.c vendored
View File

@ -3,22 +3,22 @@
// Little Color Management System // Little Color Management System
// Copyright (c) 1998-2010 Marti Maria Saguer // Copyright (c) 1998-2010 Marti Maria Saguer
// //
// Permission is hereby granted, free of charge, to any person obtaining // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -114,7 +114,7 @@ cmsFloat64Number f(cmsFloat64Number t)
if (t <= Limit) if (t <= Limit)
return (841.0/108.0) * t + (16.0/116.0); return (841.0/108.0) * t + (16.0/116.0);
else else
return pow(t, 1.0/3.0); return pow(t, 1.0/3.0);
} }
static static
@ -135,7 +135,7 @@ void CMSEXPORT cmsXYZ2Lab(const cmsCIEXYZ* WhitePoint, cmsCIELab* Lab, const cms
{ {
cmsFloat64Number fx, fy, fz; cmsFloat64Number fx, fy, fz;
if (WhitePoint == NULL) if (WhitePoint == NULL)
WhitePoint = cmsD50_XYZ(); WhitePoint = cmsD50_XYZ();
fx = f(xyz->X / WhitePoint->X); fx = f(xyz->X / WhitePoint->X);
@ -153,7 +153,7 @@ void CMSEXPORT cmsLab2XYZ(const cmsCIEXYZ* WhitePoint, cmsCIEXYZ* xyz, const cm
{ {
cmsFloat64Number x, y, z; cmsFloat64Number x, y, z;
if (WhitePoint == NULL) if (WhitePoint == NULL)
WhitePoint = cmsD50_XYZ(); WhitePoint = cmsD50_XYZ();
y = (Lab-> L + 16.0) / 116.0; y = (Lab-> L + 16.0) / 116.0;
@ -169,26 +169,26 @@ void CMSEXPORT cmsLab2XYZ(const cmsCIEXYZ* WhitePoint, cmsCIEXYZ* xyz, const cm
static static
cmsFloat64Number L2float2(cmsUInt16Number v) cmsFloat64Number L2float2(cmsUInt16Number v)
{ {
return (cmsFloat64Number) v / 652.800; return (cmsFloat64Number) v / 652.800;
} }
// the a/b part // the a/b part
static static
cmsFloat64Number ab2float2(cmsUInt16Number v) cmsFloat64Number ab2float2(cmsUInt16Number v)
{ {
return ((cmsFloat64Number) v / 256.0) - 128.0; return ((cmsFloat64Number) v / 256.0) - 128.0;
} }
static static
cmsUInt16Number L2Fix2(cmsFloat64Number L) cmsUInt16Number L2Fix2(cmsFloat64Number L)
{ {
return _cmsQuickSaturateWord(L * 652.8); return _cmsQuickSaturateWord(L * 652.8);
} }
static static
cmsUInt16Number ab2Fix2(cmsFloat64Number ab) cmsUInt16Number ab2Fix2(cmsFloat64Number ab)
{ {
return _cmsQuickSaturateWord((ab + 128.0) * 256.0); return _cmsQuickSaturateWord((ab + 128.0) * 256.0);
} }
@ -249,7 +249,7 @@ void CMSEXPORT cmsFloat2LabEncodedV2(cmsUInt16Number wLab[3], const cmsCIELab* f
Lab.L = Clamp_L_doubleV2(fLab ->L); Lab.L = Clamp_L_doubleV2(fLab ->L);
Lab.a = Clamp_ab_doubleV2(fLab ->a); Lab.a = Clamp_ab_doubleV2(fLab ->a);
Lab.b = Clamp_ab_doubleV2(fLab ->b); Lab.b = Clamp_ab_doubleV2(fLab ->b);
wLab[0] = L2Fix2(Lab.L); wLab[0] = L2Fix2(Lab.L);
wLab[1] = ab2Fix2(Lab.a); wLab[1] = ab2Fix2(Lab.a);
wLab[2] = ab2Fix2(Lab.b); wLab[2] = ab2Fix2(Lab.b);
@ -274,7 +274,7 @@ cmsFloat64Number Clamp_ab_doubleV4(cmsFloat64Number ab)
return ab; return ab;
} }
static static
cmsUInt16Number L2Fix4(cmsFloat64Number L) cmsUInt16Number L2Fix4(cmsFloat64Number L)
{ {
return _cmsQuickSaturateWord(L * 655.35); return _cmsQuickSaturateWord(L * 655.35);
@ -289,11 +289,11 @@ cmsUInt16Number ab2Fix4(cmsFloat64Number ab)
void CMSEXPORT cmsFloat2LabEncoded(cmsUInt16Number wLab[3], const cmsCIELab* fLab) void CMSEXPORT cmsFloat2LabEncoded(cmsUInt16Number wLab[3], const cmsCIELab* fLab)
{ {
cmsCIELab Lab; cmsCIELab Lab;
Lab.L = Clamp_L_doubleV4(fLab ->L); Lab.L = Clamp_L_doubleV4(fLab ->L);
Lab.a = Clamp_ab_doubleV4(fLab ->a); Lab.a = Clamp_ab_doubleV4(fLab ->a);
Lab.b = Clamp_ab_doubleV4(fLab ->b); Lab.b = Clamp_ab_doubleV4(fLab ->b);
wLab[0] = L2Fix4(Lab.L); wLab[0] = L2Fix4(Lab.L);
wLab[1] = ab2Fix4(Lab.a); wLab[1] = ab2Fix4(Lab.a);
wLab[2] = ab2Fix4(Lab.b); wLab[2] = ab2Fix4(Lab.b);
@ -317,15 +317,15 @@ cmsFloat64Number atan2deg(cmsFloat64Number a, cmsFloat64Number b)
h = 0; h = 0;
else else
h = atan2(a, b); h = atan2(a, b);
h *= (180. / M_PI); h *= (180. / M_PI);
while (h > 360.) while (h > 360.)
h -= 360.; h -= 360.;
while ( h < 0) while ( h < 0)
h += 360.; h += 360.;
return h; return h;
} }
@ -334,7 +334,7 @@ cmsFloat64Number atan2deg(cmsFloat64Number a, cmsFloat64Number b)
static static
cmsFloat64Number Sqr(cmsFloat64Number v) cmsFloat64Number Sqr(cmsFloat64Number v)
{ {
return v * v; return v * v;
} }
// From cylindrical coordinates. No check is performed, then negative values are allowed // From cylindrical coordinates. No check is performed, then negative values are allowed
void CMSEXPORT cmsLab2LCh(cmsCIELCh* LCh, const cmsCIELab* Lab) void CMSEXPORT cmsLab2LCh(cmsCIELCh* LCh, const cmsCIELab* Lab)
@ -352,13 +352,13 @@ void CMSEXPORT cmsLCh2Lab(cmsCIELab* Lab, const cmsCIELCh* LCh)
Lab -> L = LCh -> L; Lab -> L = LCh -> L;
Lab -> a = LCh -> C * cos(h); 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 // In XYZ All 3 components are encoded using 1.15 fixed point
static static
cmsUInt16Number XYZ2Fix(cmsFloat64Number d) cmsUInt16Number XYZ2Fix(cmsFloat64Number d)
{ {
return _cmsQuickSaturateWord(d * 32768.0); return _cmsQuickSaturateWord(d * 32768.0);
} }
@ -370,7 +370,7 @@ void CMSEXPORT cmsFloat2XYZEncoded(cmsUInt16Number XYZ[3], const cmsCIEXYZ* fXYZ
xyz.Y = fXYZ -> Y; xyz.Y = fXYZ -> Y;
xyz.Z = fXYZ -> Z; xyz.Z = fXYZ -> Z;
// Clamp to encodeable values. // Clamp to encodeable values.
if (xyz.Y <= 0) { if (xyz.Y <= 0) {
xyz.X = 0; xyz.X = 0;
@ -378,19 +378,19 @@ void CMSEXPORT cmsFloat2XYZEncoded(cmsUInt16Number XYZ[3], const cmsCIEXYZ* fXYZ
xyz.Z = 0; xyz.Z = 0;
} }
if (xyz.X > MAX_ENCODEABLE_XYZ) if (xyz.X > MAX_ENCODEABLE_XYZ)
xyz.X = MAX_ENCODEABLE_XYZ; xyz.X = MAX_ENCODEABLE_XYZ;
if (xyz.X < 0) if (xyz.X < 0)
xyz.X = 0; xyz.X = 0;
if (xyz.Y > MAX_ENCODEABLE_XYZ) if (xyz.Y > MAX_ENCODEABLE_XYZ)
xyz.Y = MAX_ENCODEABLE_XYZ; xyz.Y = MAX_ENCODEABLE_XYZ;
if (xyz.Y < 0) if (xyz.Y < 0)
xyz.Y = 0; xyz.Y = 0;
if (xyz.Z > MAX_ENCODEABLE_XYZ) if (xyz.Z > MAX_ENCODEABLE_XYZ)
xyz.Z = MAX_ENCODEABLE_XYZ; xyz.Z = MAX_ENCODEABLE_XYZ;
if (xyz.Z < 0) if (xyz.Z < 0)
@ -399,7 +399,7 @@ void CMSEXPORT cmsFloat2XYZEncoded(cmsUInt16Number XYZ[3], const cmsCIEXYZ* fXYZ
XYZ[0] = XYZ2Fix(xyz.X); XYZ[0] = XYZ2Fix(xyz.X);
XYZ[1] = XYZ2Fix(xyz.Y); XYZ[1] = XYZ2Fix(xyz.Y);
XYZ[2] = XYZ2Fix(xyz.Z); XYZ[2] = XYZ2Fix(xyz.Z);
} }
@ -422,7 +422,7 @@ void CMSEXPORT cmsXYZEncoded2Float(cmsCIEXYZ* fXYZ, const cmsUInt16Number XYZ[3]
fXYZ -> X = XYZ2float(XYZ[0]); fXYZ -> X = XYZ2float(XYZ[0]);
fXYZ -> Y = XYZ2float(XYZ[1]); fXYZ -> Y = XYZ2float(XYZ[1]);
fXYZ -> Z = XYZ2float(XYZ[2]); fXYZ -> Z = XYZ2float(XYZ[2]);
} }
// Returns dE on two Lab values // Returns dE on two Lab values
@ -438,7 +438,7 @@ cmsFloat64Number CMSEXPORT cmsDeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab
} }
// Return the CIE94 Delta E // Return the CIE94 Delta E
cmsFloat64Number CMSEXPORT cmsCIE94DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2) cmsFloat64Number CMSEXPORT cmsCIE94DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2)
{ {
cmsCIELCh LCh1, LCh2; cmsCIELCh LCh1, LCh2;
@ -452,7 +452,7 @@ cmsFloat64Number CMSEXPORT cmsCIE94DeltaE(const cmsCIELab* Lab1, const cmsCIELab
dC = fabs(LCh1.C - LCh2.C); dC = fabs(LCh1.C - LCh2.C);
dE = cmsDeltaE(Lab1, Lab2); dE = cmsDeltaE(Lab1, Lab2);
dhsq = Sqr(dE) - Sqr(dL) - Sqr(dC); dhsq = Sqr(dE) - Sqr(dL) - Sqr(dC);
if (dhsq < 0) if (dhsq < 0)
dh = 0; dh = 0;
@ -463,7 +463,7 @@ cmsFloat64Number CMSEXPORT cmsCIE94DeltaE(const cmsCIELab* Lab1, const cmsCIELab
sc = 1.0 + (0.048 * c12); sc = 1.0 + (0.048 * c12);
sh = 1.0 + (0.014 * c12); sh = 1.0 + (0.014 * c12);
return sqrt(Sqr(dL) + Sqr(dC) / Sqr(sc) + Sqr(dh) / Sqr(sh)); return sqrt(Sqr(dL) + Sqr(dC) / Sqr(sc) + Sqr(dh) / Sqr(sh));
} }
@ -513,7 +513,7 @@ cmsFloat64Number CMSEXPORT cmsBFDdeltaE(const cmsCIELab* Lab1, const cmsCIELab*
dc = 0.035 * AveC / (1 + 0.00365 * AveC)+0.521; dc = 0.035 * AveC / (1 + 0.00365 * AveC)+0.521;
g = sqrt(Sqr(Sqr(AveC))/(Sqr(Sqr(AveC))+14000)); 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.040*cos((2*Aveh-136)/(180/M_PI))+
0.070*cos((3*Aveh-31)/(180/M_PI))+ 0.070*cos((3*Aveh-31)/(180/M_PI))+
0.049*cos((4*Aveh+114)/(180/M_PI))- 0.049*cos((4*Aveh+114)/(180/M_PI))-
@ -546,27 +546,27 @@ cmsFloat64Number CMSEXPORT cmsCMCdeltaE(const cmsCIELab* Lab1, const cmsCIELab*
cmsLab2LCh(&LCh1, Lab1); cmsLab2LCh(&LCh1, Lab1);
cmsLab2LCh(&LCh2, Lab2); cmsLab2LCh(&LCh2, Lab2);
dL = Lab2->L-Lab1->L; dL = Lab2->L-Lab1->L;
dC = LCh2.C-LCh1.C; dC = LCh2.C-LCh1.C;
dE = cmsDeltaE(Lab1, Lab2); 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)); dh = sqrt(Sqr(dE)-Sqr(dL)-Sqr(dC));
else else
dh =0; 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)))); 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)))); 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; sc = 0.0638 * LCh1.C / (1 + 0.0131 * LCh1.C) + 0.638;
sl = 0.040975 * Lab1->L /(1 + 0.01765 * Lab1->L); sl = 0.040975 * Lab1->L /(1 + 0.01765 * Lab1->L);
if (Lab1->L<16) 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)); 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); sh = sc*(t*f+1-f);
@ -575,7 +575,7 @@ cmsFloat64Number CMSEXPORT cmsCMCdeltaE(const cmsCIELab* Lab1, const cmsCIELab*
return cmc; 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 // importance of lightness, chroma and hue in different industrial applications
cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2, cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2,
cmsFloat64Number Kl, cmsFloat64Number Kc, cmsFloat64Number Kh) cmsFloat64Number Kl, cmsFloat64Number Kc, cmsFloat64Number Kh)
@ -595,25 +595,25 @@ cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIEL
cmsFloat64Number a_p = (1 + G ) * a1; cmsFloat64Number a_p = (1 + G ) * a1;
cmsFloat64Number b_p = b1; cmsFloat64Number b_p = b1;
cmsFloat64Number C_p = sqrt( Sqr(a_p) + Sqr(b_p)); 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 a_ps = (1 + G) * as;
cmsFloat64Number b_ps = bs; cmsFloat64Number b_ps = bs;
cmsFloat64Number C_ps = sqrt(Sqr(a_ps) + Sqr(b_ps)); cmsFloat64Number C_ps = sqrt(Sqr(a_ps) + Sqr(b_ps));
cmsFloat64Number h_ps = atan2deg(b_ps, a_ps); cmsFloat64Number h_ps = atan2deg(b_ps, a_ps);
cmsFloat64Number meanC_p =(C_p + C_ps) / 2; cmsFloat64Number meanC_p =(C_p + C_ps) / 2;
cmsFloat64Number hps_plus_hp = h_ps + h_p; cmsFloat64Number hps_plus_hp = h_ps + h_p;
cmsFloat64Number hps_minus_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 : 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 ? (hps_plus_hp + 360)/2 :
(hps_plus_hp - 360)/2; (hps_plus_hp - 360)/2;
cmsFloat64Number delta_h = (hps_minus_hp) <= -180.000001 ? (hps_minus_hp + 360) : 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); (hps_minus_hp);
cmsFloat64Number delta_L = (Ls - L1); cmsFloat64Number delta_L = (Ls - L1);
cmsFloat64Number delta_C = (C_ps - C_p ); cmsFloat64Number delta_C = (C_ps - C_p );
@ -621,9 +621,9 @@ cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIEL
cmsFloat64Number delta_H =2 * sqrt(C_ps*C_p) * sin(RADIANS(delta_h) / 2); cmsFloat64Number delta_H =2 * sqrt(C_ps*C_p) * sin(RADIANS(delta_h) / 2);
cmsFloat64Number T = 1 - 0.17 * cos(RADIANS(meanh_p-30)) cmsFloat64Number T = 1 - 0.17 * cos(RADIANS(meanh_p-30))
+ 0.24 * cos(RADIANS(2*meanh_p)) + 0.24 * cos(RADIANS(2*meanh_p))
+ 0.32 * cos(RADIANS(3*meanh_p + 6)) + 0.32 * cos(RADIANS(3*meanh_p + 6))
- 0.2 * cos(RADIANS(4*meanh_p - 63)); - 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 Sl = 1 + (0.015 * Sqr((Ls + L1) /2- 50) )/ sqrt(20 + Sqr( (Ls+L1)/2 - 50) );
@ -637,9 +637,9 @@ cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIEL
cmsFloat64Number Rt = -sin(2 * RADIANS(delta_ro)) * Rc; cmsFloat64Number Rt = -sin(2 * RADIANS(delta_ro)) * Rc;
cmsFloat64Number deltaE00 = sqrt( Sqr(delta_L /(Sl * Kl)) + cmsFloat64Number deltaE00 = sqrt( Sqr(delta_L /(Sl * Kl)) +
Sqr(delta_C/(Sc * Kc)) + Sqr(delta_C/(Sc * Kc)) +
Sqr(delta_H/(Sh * Kh)) + Sqr(delta_H/(Sh * Kh)) +
Rt*(delta_C/(Sc * Kc)) * (delta_H / (Sh * Kh))); Rt*(delta_C/(Sc * Kc)) * (delta_H / (Sh * Kh)));
return deltaE00; return deltaE00;
@ -662,41 +662,41 @@ int _cmsReasonableGridpointsByColorspace(cmsColorSpaceSignature Colorspace, cmsU
// HighResPrecalc is maximum resolution // HighResPrecalc is maximum resolution
if (dwFlags & cmsFLAGS_HIGHRESPRECALC) { if (dwFlags & cmsFLAGS_HIGHRESPRECALC) {
if (nChannels > 4) if (nChannels > 4)
return 7; // 7 for Hifi return 7; // 7 for Hifi
if (nChannels == 4) // 23 for CMYK if (nChannels == 4) // 23 for CMYK
return 23; return 23;
return 49; // 49 for RGB and others return 49; // 49 for RGB and others
} }
// LowResPrecal is lower resolution // LowResPrecal is lower resolution
if (dwFlags & cmsFLAGS_LOWRESPRECALC) { if (dwFlags & cmsFLAGS_LOWRESPRECALC) {
if (nChannels > 4) if (nChannels > 4)
return 6; // 6 for more than 4 channels return 6; // 6 for more than 4 channels
if (nChannels == 1) if (nChannels == 1)
return 33; // For monochrome return 33; // For monochrome
return 17; // 17 for remaining return 17; // 17 for remaining
} }
// Default values // Default values
if (nChannels > 4) if (nChannels > 4)
return 7; // 7 for Hifi return 7; // 7 for Hifi
if (nChannels == 4) if (nChannels == 4)
return 17; // 17 for CMYK return 17; // 17 for CMYK
return 33; // 33 for RGB return 33; // 33 for RGB
} }
cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space, cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
cmsUInt16Number **White, cmsUInt16Number **White,
cmsUInt16Number **Black, cmsUInt16Number **Black,
cmsUInt32Number *nOutputs) cmsUInt32Number *nOutputs)
{ {
@ -719,7 +719,7 @@ cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
if (Black) *Black = Grayblack; if (Black) *Black = Grayblack;
if (nOutputs) *nOutputs = 1; if (nOutputs) *nOutputs = 1;
return TRUE; return TRUE;
case cmsSigRgbData: if (White) *White = RGBwhite; case cmsSigRgbData: if (White) *White = RGBwhite;
if (Black) *Black = RGBblack; if (Black) *Black = RGBblack;
if (nOutputs) *nOutputs = 3; if (nOutputs) *nOutputs = 3;
@ -746,7 +746,7 @@ cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
return FALSE; return FALSE;
} }
// Several utilities ------------------------------------------------------- // Several utilities -------------------------------------------------------
@ -799,9 +799,9 @@ cmsColorSpaceSignature CMSEXPORT _cmsICCcolorSpace(int OurNotation)
int CMSEXPORT _cmsLCMScolorSpace(cmsColorSpaceSignature ProfileSpace) int CMSEXPORT _cmsLCMScolorSpace(cmsColorSpaceSignature ProfileSpace)
{ {
switch (ProfileSpace) { switch (ProfileSpace) {
case cmsSigGrayData: return PT_GRAY; case cmsSigGrayData: return PT_GRAY;
case cmsSigRgbData: return PT_RGB; case cmsSigRgbData: return PT_RGB;
case cmsSigCmyData: return PT_CMY; case cmsSigCmyData: return PT_CMY;
@ -814,52 +814,52 @@ int CMSEXPORT _cmsLCMScolorSpace(cmsColorSpaceSignature ProfileSpace)
case cmsSigHsvData: return PT_HSV; case cmsSigHsvData: return PT_HSV;
case cmsSigHlsData: return PT_HLS; case cmsSigHlsData: return PT_HLS;
case cmsSigYxyData: return PT_Yxy; case cmsSigYxyData: return PT_Yxy;
case cmsSig1colorData: case cmsSig1colorData:
case cmsSigMCH1Data: return PT_MCH1; case cmsSigMCH1Data: return PT_MCH1;
case cmsSig2colorData: case cmsSig2colorData:
case cmsSigMCH2Data: return PT_MCH2; case cmsSigMCH2Data: return PT_MCH2;
case cmsSig3colorData: case cmsSig3colorData:
case cmsSigMCH3Data: return PT_MCH3; case cmsSigMCH3Data: return PT_MCH3;
case cmsSig4colorData: case cmsSig4colorData:
case cmsSigMCH4Data: return PT_MCH4; case cmsSigMCH4Data: return PT_MCH4;
case cmsSig5colorData: case cmsSig5colorData:
case cmsSigMCH5Data: return PT_MCH5; case cmsSigMCH5Data: return PT_MCH5;
case cmsSig6colorData: case cmsSig6colorData:
case cmsSigMCH6Data: return PT_MCH6; case cmsSigMCH6Data: return PT_MCH6;
case cmsSigMCH7Data: case cmsSigMCH7Data:
case cmsSig7colorData:return PT_MCH7; case cmsSig7colorData:return PT_MCH7;
case cmsSigMCH8Data: case cmsSigMCH8Data:
case cmsSig8colorData:return PT_MCH8; case cmsSig8colorData:return PT_MCH8;
case cmsSigMCH9Data: case cmsSigMCH9Data:
case cmsSig9colorData:return PT_MCH9; case cmsSig9colorData:return PT_MCH9;
case cmsSigMCHAData: case cmsSigMCHAData:
case cmsSig10colorData:return PT_MCH10; case cmsSig10colorData:return PT_MCH10;
case cmsSigMCHBData: case cmsSigMCHBData:
case cmsSig11colorData:return PT_MCH11; case cmsSig11colorData:return PT_MCH11;
case cmsSigMCHCData: case cmsSigMCHCData:
case cmsSig12colorData:return PT_MCH12; case cmsSig12colorData:return PT_MCH12;
case cmsSigMCHDData: case cmsSigMCHDData:
case cmsSig13colorData:return PT_MCH13; case cmsSig13colorData:return PT_MCH13;
case cmsSigMCHEData: case cmsSigMCHEData:
case cmsSig14colorData:return PT_MCH14; case cmsSig14colorData:return PT_MCH14;
case cmsSigMCHFData: case cmsSigMCHFData:
case cmsSig15colorData:return PT_MCH15; case cmsSig15colorData:return PT_MCH15;
default: return (cmsColorSpaceSignature) (-1); default: return (cmsColorSpaceSignature) (-1);
} }
} }
@ -869,31 +869,36 @@ cmsUInt32Number CMSEXPORT cmsChannelsOf(cmsColorSpaceSignature ColorSpace)
{ {
switch (ColorSpace) { switch (ColorSpace) {
case cmsSigMCH1Data:
case cmsSig1colorData:
case cmsSigGrayData: return 1; case cmsSigGrayData: return 1;
case cmsSigMCH2Data:
case cmsSig2colorData: return 2; case cmsSig2colorData: return 2;
case cmsSigXYZData: case cmsSigXYZData:
case cmsSigLabData: case cmsSigLabData:
case cmsSigLuvData: case cmsSigLuvData:
case cmsSigYCbCrData: case cmsSigYCbCrData:
case cmsSigYxyData: case cmsSigYxyData:
case cmsSigRgbData: case cmsSigRgbData:
case cmsSigHsvData: case cmsSigHsvData:
case cmsSigHlsData: case cmsSigHlsData:
case cmsSigCmyData: case cmsSigCmyData:
case cmsSigMCH3Data:
case cmsSig3colorData: return 3; case cmsSig3colorData: return 3;
case cmsSigLuvKData: case cmsSigLuvKData:
case cmsSigCmykData: case cmsSigCmykData:
case cmsSigMCH4Data:
case cmsSig4colorData: return 4; case cmsSig4colorData: return 4;
case cmsSigMCH5Data: case cmsSigMCH5Data:
case cmsSig5colorData: return 5; case cmsSig5colorData: return 5;
case cmsSigMCH6Data: case cmsSigMCH6Data:
case cmsSig6colorData: return 6; case cmsSig6colorData: return 6;
case cmsSigMCH7Data: case cmsSigMCH7Data:
case cmsSig7colorData: return 7; case cmsSig7colorData: return 7;
@ -908,7 +913,7 @@ cmsUInt32Number CMSEXPORT cmsChannelsOf(cmsColorSpaceSignature ColorSpace)
case cmsSigMCHBData: case cmsSigMCHBData:
case cmsSig11colorData: return 11; case cmsSig11colorData: return 11;
case cmsSigMCHCData: case cmsSigMCHCData:
case cmsSig12colorData: return 12; case cmsSig12colorData: return 12;

545
thirdparty/liblcms2/src/cmsplugin.c vendored
View File

@ -3,22 +3,22 @@
// Little Color Management System // Little Color Management System
// Copyright (c) 1998-2010 Marti Maria Saguer // Copyright (c) 1998-2010 Marti Maria Saguer
// //
// Permission is hereby granted, free of charge, to any person obtaining // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -44,7 +44,7 @@ cmsUInt16Number CMSEXPORT _cmsAdjustEndianess16(cmsUInt16Number Word)
tmp = pByte[0]; tmp = pByte[0];
pByte[0] = pByte[1]; pByte[0] = pByte[1];
pByte[1] = tmp; pByte[1] = tmp;
#endif #endif
return Word; return Word;
} }
@ -76,12 +76,12 @@ cmsUInt32Number CMSEXPORT _cmsAdjustEndianess32(cmsUInt32Number DWord)
// 1 2 3 4 5 6 7 8 // 1 2 3 4 5 6 7 8
// 8 7 6 5 4 3 2 1 // 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 #ifndef CMS_USE_BIG_ENDIAN
cmsUInt8Number* pIn = (cmsUInt8Number*) &QWord; cmsUInt8Number* pIn = (cmsUInt8Number*) QWord;
cmsUInt8Number* pOut = (cmsUInt8Number*) Result; cmsUInt8Number* pOut = (cmsUInt8Number*) Result;
_cmsAssert(Result != NULL); _cmsAssert(Result != NULL);
@ -91,15 +91,19 @@ void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number Q
pOut[5] = pIn[2]; pOut[5] = pIn[2];
pOut[4] = pIn[3]; pOut[4] = pIn[3];
pOut[3] = pIn[4]; pOut[3] = pIn[4];
pOut[2] = pIn[5]; pOut[2] = pIn[5];
pOut[1] = pIn[6]; pOut[1] = pIn[6];
pOut[0] = pIn[7]; pOut[0] = pIn[7];
#else #else
_cmsAssert(Result != NULL); _cmsAssert(Result != NULL);
*Result = QWord; # ifdef CMS_DONT_USE_INT64
(*Result)[0] = QWord[0];
(*Result)[1] = QWord[1];
# else
*Result = *QWord;
# endif
#endif #endif
} }
@ -110,8 +114,8 @@ cmsBool CMSEXPORT _cmsReadUInt8Number(cmsIOHANDLER* io, cmsUInt8Number* n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Read(io, &tmp, sizeof(cmsUInt8Number), 1) != 1) if (io -> Read(io, &tmp, sizeof(cmsUInt8Number), 1) != 1)
return FALSE; return FALSE;
if (n != NULL) *n = tmp; if (n != NULL) *n = tmp;
return TRUE; return TRUE;
@ -123,8 +127,8 @@ cmsBool CMSEXPORT _cmsReadUInt16Number(cmsIOHANDLER* io, cmsUInt16Number* n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Read(io, &tmp, sizeof(cmsUInt16Number), 1) != 1) if (io -> Read(io, &tmp, sizeof(cmsUInt16Number), 1) != 1)
return FALSE; return FALSE;
if (n != NULL) *n = _cmsAdjustEndianess16(tmp); if (n != NULL) *n = _cmsAdjustEndianess16(tmp);
return TRUE; return TRUE;
@ -155,8 +159,8 @@ cmsBool CMSEXPORT _cmsReadUInt32Number(cmsIOHANDLER* io, cmsUInt32Number* n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1) if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
return FALSE; return FALSE;
if (n != NULL) *n = _cmsAdjustEndianess32(tmp); if (n != NULL) *n = _cmsAdjustEndianess32(tmp);
return TRUE; return TRUE;
@ -168,8 +172,8 @@ cmsBool CMSEXPORT _cmsReadFloat32Number(cmsIOHANDLER* io, cmsFloat32Number* n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Read(io, &tmp, sizeof(cmsFloat32Number), 1) != 1) if (io -> Read(io, &tmp, sizeof(cmsFloat32Number), 1) != 1)
return FALSE; return FALSE;
if (n != NULL) { if (n != NULL) {
@ -186,10 +190,10 @@ cmsBool CMSEXPORT _cmsReadUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Read(io, &tmp, sizeof(cmsUInt64Number), 1) != 1) if (io -> Read(io, &tmp, sizeof(cmsUInt64Number), 1) != 1)
return FALSE; return FALSE;
if (n != NULL) _cmsAdjustEndianess64(n, tmp); if (n != NULL) _cmsAdjustEndianess64(n, &tmp);
return TRUE; return TRUE;
} }
@ -200,8 +204,8 @@ cmsBool CMSEXPORT _cmsRead15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number* n
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1) if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
return FALSE; return FALSE;
if (n != NULL) { if (n != NULL) {
*n = _cms15Fixed16toDouble(_cmsAdjustEndianess32(tmp)); *n = _cms15Fixed16toDouble(_cmsAdjustEndianess32(tmp));
@ -250,9 +254,9 @@ cmsBool CMSEXPORT _cmsWriteUInt8Number(cmsIOHANDLER* io, cmsUInt8Number n)
{ {
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
if (io -> Write(io, sizeof(cmsUInt8Number), &n) != 1) if (io -> Write(io, sizeof(cmsUInt8Number), &n) != 1)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
@ -263,9 +267,9 @@ cmsBool CMSEXPORT _cmsWriteUInt16Number(cmsIOHANDLER* io, cmsUInt16Number n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
tmp = _cmsAdjustEndianess16(n); tmp = _cmsAdjustEndianess16(n);
if (io -> Write(io, sizeof(cmsUInt16Number), &tmp) != 1) if (io -> Write(io, sizeof(cmsUInt16Number), &tmp) != 1)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
@ -290,9 +294,9 @@ cmsBool CMSEXPORT _cmsWriteUInt32Number(cmsIOHANDLER* io, cmsUInt32Number n)
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
tmp = _cmsAdjustEndianess32(n); tmp = _cmsAdjustEndianess32(n);
if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1) if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
@ -305,22 +309,22 @@ cmsBool CMSEXPORT _cmsWriteFloat32Number(cmsIOHANDLER* io, cmsFloat32Number n)
tmp = *(cmsUInt32Number*) &n; tmp = *(cmsUInt32Number*) &n;
tmp = _cmsAdjustEndianess32(tmp); tmp = _cmsAdjustEndianess32(tmp);
if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1) if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
cmsBool CMSEXPORT _cmsWriteUInt64Number(cmsIOHANDLER* io, cmsUInt64Number n) cmsBool CMSEXPORT _cmsWriteUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n)
{ {
cmsUInt64Number tmp; cmsUInt64Number tmp;
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
_cmsAdjustEndianess64(&tmp, n); _cmsAdjustEndianess64(&tmp, n);
if (io -> Write(io, sizeof(cmsUInt64Number), &tmp) != 1) if (io -> Write(io, sizeof(cmsUInt64Number), &tmp) != 1)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
@ -331,16 +335,16 @@ cmsBool CMSEXPORT _cmsWrite15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number n
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
tmp = _cmsAdjustEndianess32(_cmsDoubleTo15Fixed16(n)); tmp = _cmsAdjustEndianess32(_cmsDoubleTo15Fixed16(n));
if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1) if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ) cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ)
{ {
cmsEncodedXYZNumber xyz; cmsEncodedXYZNumber xyz;
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
_cmsAssert(XYZ != NULL); _cmsAssert(XYZ != NULL);
@ -365,7 +369,7 @@ cmsFloat64Number CMSEXPORT _cms8Fixed8toDouble(cmsUInt16Number fixed8)
cmsUInt16Number CMSEXPORT _cmsDoubleTo8Fixed8(cmsFloat64Number val) cmsUInt16Number CMSEXPORT _cmsDoubleTo8Fixed8(cmsFloat64Number val)
{ {
cmsS15Fixed16Number GammaFixed32 = _cmsDoubleTo15Fixed16(val); cmsS15Fixed16Number GammaFixed32 = _cmsDoubleTo15Fixed16(val);
return (cmsUInt16Number) ((GammaFixed32 >> 8) & 0xFFFF); return (cmsUInt16Number) ((GammaFixed32 >> 8) & 0xFFFF);
} }
// from Fixed point 15.16 to double // from Fixed point 15.16 to double
@ -386,13 +390,13 @@ cmsFloat64Number CMSEXPORT _cms15Fixed16toDouble(cmsS15Fixed16Number fix32)
return sign * floater; return sign * floater;
} }
// from double to Fixed point 15.16 // from double to Fixed point 15.16
cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsFloat64Number v) cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsFloat64Number v)
{ {
return ((cmsS15Fixed16Number) floor((v)*65536.0 + 0.5)); return ((cmsS15Fixed16Number) floor((v)*65536.0 + 0.5));
} }
// Date/Time functions // Date/Time functions
void CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeNumber *Source, struct tm *Dest) void CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeNumber *Source, struct tm *Dest)
{ {
@ -431,7 +435,7 @@ cmsTagTypeSignature CMSEXPORT _cmsReadTypeBase(cmsIOHANDLER* io)
_cmsAssert(io != NULL); _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) 0;
return (cmsTagTypeSignature) _cmsAdjustEndianess32(Base.sig); return (cmsTagTypeSignature) _cmsAdjustEndianess32(Base.sig);
@ -454,7 +458,7 @@ cmsBool CMSEXPORT _cmsReadAlignment(cmsIOHANDLER* io)
cmsUInt8Number Buffer[4]; cmsUInt8Number Buffer[4];
cmsUInt32Number NextAligned, At; cmsUInt32Number NextAligned, At;
cmsUInt32Number BytesToNextAlignedPos; cmsUInt32Number BytesToNextAlignedPos;
_cmsAssert(io != NULL); _cmsAssert(io != NULL);
At = io -> Tell(io); At = io -> Tell(io);
@ -502,7 +506,7 @@ cmsBool CMSEXPORT _cmsIOPrintf(cmsIOHANDLER* io, const char* frm, ...)
if (len < 0) return FALSE; // Truncated, which is a fatal error for us if (len < 0) return FALSE; // Truncated, which is a fatal error for us
rc = io ->Write(io, len, Buffer); rc = io ->Write(io, len, Buffer);
va_end(args); va_end(args);
return rc; return rc;
@ -511,80 +515,102 @@ cmsBool CMSEXPORT _cmsIOPrintf(cmsIOHANDLER* io, const char* frm, ...)
// Plugin memory management ------------------------------------------------------------------------------------------------- // Plugin memory management -------------------------------------------------------------------------------------------------
static _cmsSubAllocator* PluginPool = NULL;
// Specialized malloc for plug-ins, that is freed upon exit. // Specialized malloc for plug-ins, that is freed upon exit.
void* _cmsPluginMalloc(cmsUInt32Number size) void* _cmsPluginMalloc(cmsContext ContextID, cmsUInt32Number size)
{ {
if (PluginPool == NULL) struct _cmsContext_struct* ctx = _cmsGetContext(ContextID);
PluginPool = _cmsCreateSubAlloc(0, 4*1024);
return _cmsSubAlloc(PluginPool, size); if (ctx ->MemPool == NULL) {
if (ContextID == NULL) {
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 // Main plug-in dispatcher
cmsBool CMSEXPORT cmsPlugin(void* Plug_in) cmsBool CMSEXPORT cmsPlugin(void* Plug_in)
{
return cmsPluginTHR(NULL, Plug_in);
}
cmsBool CMSEXPORT cmsPluginTHR(cmsContext id, void* Plug_in)
{ {
cmsPluginBase* Plugin; cmsPluginBase* Plugin;
for (Plugin = (cmsPluginBase*) Plug_in; for (Plugin = (cmsPluginBase*) Plug_in;
Plugin != NULL; Plugin != NULL;
Plugin = Plugin -> Next) { Plugin = Plugin -> Next) {
if (Plugin -> Magic != cmsPluginMagicNumber) { if (Plugin -> Magic != cmsPluginMagicNumber) {
cmsSignalError(0, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin"); cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin");
return FALSE; return FALSE;
} }
if (Plugin ->ExpectedVersion > LCMS_VERSION) { if (Plugin ->ExpectedVersion > LCMS_VERSION) {
cmsSignalError(0, cmsERROR_UNKNOWN_EXTENSION, "plugin needs Little CMS %d, current version is %d", cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "plugin needs Little CMS %d, current version is %d",
Plugin ->ExpectedVersion, LCMS_VERSION); Plugin ->ExpectedVersion, LCMS_VERSION);
return FALSE; return FALSE;
} }
switch (Plugin -> Type) { switch (Plugin -> Type) {
case cmsPluginMemHandlerSig: case cmsPluginMemHandlerSig:
if (!_cmsRegisterMemHandlerPlugin(Plugin)) return FALSE; if (!_cmsRegisterMemHandlerPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginInterpolationSig: case cmsPluginInterpolationSig:
if (!_cmsRegisterInterpPlugin(Plugin)) return FALSE; if (!_cmsRegisterInterpPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginTagTypeSig: case cmsPluginTagTypeSig:
if (!_cmsRegisterTagTypePlugin(Plugin)) return FALSE; if (!_cmsRegisterTagTypePlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginTagSig: case cmsPluginTagSig:
if (!_cmsRegisterTagPlugin(Plugin)) return FALSE; if (!_cmsRegisterTagPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginFormattersSig: case cmsPluginFormattersSig:
if (!_cmsRegisterFormattersPlugin(Plugin)) return FALSE; if (!_cmsRegisterFormattersPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginRenderingIntentSig: case cmsPluginRenderingIntentSig:
if (!_cmsRegisterRenderingIntentPlugin(Plugin)) return FALSE; if (!_cmsRegisterRenderingIntentPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginParametricCurveSig: case cmsPluginParametricCurveSig:
if (!_cmsRegisterParametricCurvesPlugin(Plugin)) return FALSE; if (!_cmsRegisterParametricCurvesPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginMultiProcessElementSig: case cmsPluginMultiProcessElementSig:
if (!_cmsRegisterMultiProcessElementPlugin(Plugin)) return FALSE; if (!_cmsRegisterMultiProcessElementPlugin(id, Plugin)) return FALSE;
break; break;
case cmsPluginOptimizationSig: 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; break;
default: 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; return FALSE;
} }
} }
// Keep a reference to the plug-in // Keep a reference to the plug-in
@ -595,18 +621,337 @@ cmsBool CMSEXPORT cmsPlugin(void* Plug_in)
// Revert all plug-ins to default // Revert all plug-ins to default
void CMSEXPORT cmsUnregisterPlugins(void) void CMSEXPORT cmsUnregisterPlugins(void)
{ {
_cmsRegisterMemHandlerPlugin(NULL); cmsUnregisterPluginsTHR(NULL);
_cmsRegisterInterpPlugin(NULL);
_cmsRegisterTagTypePlugin(NULL);
_cmsRegisterTagPlugin(NULL);
_cmsRegisterFormattersPlugin(NULL);
_cmsRegisterRenderingIntentPlugin(NULL);
_cmsRegisterParametricCurvesPlugin(NULL);
_cmsRegisterMultiProcessElementPlugin(NULL);
_cmsRegisterOptimizationPlugin(NULL);
if (PluginPool != NULL)
_cmsSubAllocDestroy(PluginPool);
PluginPool = 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 (mc < 0 || mc >= MemoryClientMax) {
cmsSignalError(ContextID, cmsERROR_RANGE, "Bad context client");
return NULL;
}
ctx = _cmsGetContext(ContextID);
ptr = ctx ->chunks[mc];
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);
}

918
thirdparty/liblcms2/src/cmsps2.c vendored
View File

File diff suppressed because it is too large Load Diff

434
thirdparty/liblcms2/src/cmssamp.c vendored
View File

@ -3,22 +3,22 @@
// Little Color Management System // Little Color Management System
// Copyright (c) 1998-2010 Marti Maria Saguer // Copyright (c) 1998-2010 Marti Maria Saguer
// //
// Permission is hereby granted, free of charge, to any person obtaining // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -27,29 +27,31 @@
#include "lcms2_internal.h" #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 // This file contains routines for resampling and LUT optimization, black point detection
// and black preservation. // and black preservation.
// Black point detection ------------------------------------------------------------------------- // 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 static
cmsHTRANSFORM CreateRoundtripXForm(cmsHPROFILE hProfile, cmsUInt32Number nIntent) cmsHTRANSFORM CreateRoundtripXForm(cmsHPROFILE hProfile, cmsUInt32Number nIntent)
{ {
cmsHPROFILE hLab = cmsCreateLab4Profile(NULL); cmsContext ContextID = cmsGetProfileContextID(hProfile);
cmsHPROFILE hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
cmsHTRANSFORM xform; cmsHTRANSFORM xform;
cmsBool BPC[4] = { FALSE, FALSE, FALSE, FALSE }; cmsBool BPC[4] = { FALSE, FALSE, FALSE, FALSE };
cmsFloat64Number States[4] = { 1.0, 1.0, 1.0, 1.0 }; cmsFloat64Number States[4] = { 1.0, 1.0, 1.0, 1.0 };
cmsHPROFILE hProfiles[4]; cmsHPROFILE hProfiles[4];
cmsUInt32Number Intents[4]; cmsUInt32Number Intents[4];
cmsContext ContextID = cmsGetProfileContextID(hProfile);
hProfiles[0] = hLab; hProfiles[1] = hProfile; hProfiles[2] = hProfile; hProfiles[3] = hLab; 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; 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); States, NULL, 0, TYPE_Lab_DBL, TYPE_Lab_DBL, cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
cmsCloseProfile(hLab); cmsCloseProfile(hLab);
@ -59,7 +61,7 @@ cmsHTRANSFORM CreateRoundtripXForm(cmsHPROFILE hProfile, cmsUInt32Number nIntent
// Use darker colorants to obtain black point. This works in the relative colorimetric intent and // 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. // assumes more ink results in darker colors. No ink limit is assumed.
static static
cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput, cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
cmsUInt32Number Intent, cmsUInt32Number Intent,
cmsCIEXYZ* BlackPoint, cmsCIEXYZ* BlackPoint,
cmsUInt32Number dwFlags) cmsUInt32Number dwFlags)
@ -68,28 +70,28 @@ cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
cmsHTRANSFORM xform; cmsHTRANSFORM xform;
cmsColorSpaceSignature Space; cmsColorSpaceSignature Space;
cmsUInt32Number nChannels; cmsUInt32Number nChannels;
cmsUInt32Number dwFormat; cmsUInt32Number dwFormat;
cmsHPROFILE hLab; cmsHPROFILE hLab;
cmsCIELab Lab; cmsCIELab Lab;
cmsCIEXYZ BlackXYZ; cmsCIEXYZ BlackXYZ;
cmsContext ContextID = cmsGetProfileContextID(hInput); 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)) { if (!cmsIsIntentSupported(hInput, Intent, LCMS_USED_AS_INPUT)) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE; return FALSE;
} }
// Create a formatter which has n channels and floating point // Create a formatter which has n channels and floating point
dwFormat = cmsFormatterForColorspaceOfProfile(hInput, 2, FALSE); dwFormat = cmsFormatterForColorspaceOfProfile(hInput, 2, FALSE);
// Try to get black by using black colorant // Try to get black by using black colorant
Space = cmsGetColorSpace(hInput); Space = cmsGetColorSpace(hInput);
// This function returns darker colorant in 16 bits for several spaces // This function returns darker colorant in 16 bits for several spaces
if (!_cmsEndPointsBySpace(Space, NULL, &Black, &nChannels)) { if (!_cmsEndPointsBySpace(Space, NULL, &Black, &nChannels)) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE; return FALSE;
} }
@ -103,21 +105,21 @@ cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
hLab = cmsCreateLab2ProfileTHR(ContextID, NULL); hLab = cmsCreateLab2ProfileTHR(ContextID, NULL);
if (hLab == NULL) { if (hLab == NULL) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE; return FALSE;
} }
// Create the transform // Create the transform
xform = cmsCreateTransformTHR(ContextID, hInput, dwFormat, xform = cmsCreateTransformTHR(ContextID, hInput, dwFormat,
hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE); hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
cmsCloseProfile(hLab); cmsCloseProfile(hLab);
if (xform == NULL) { if (xform == NULL) {
// Something went wrong. Get rid of open resources and return zero as black // Something went wrong. Get rid of open resources and return zero as black
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE; return FALSE;
} }
// Convert black to Lab // Convert black to Lab
cmsDoTransform(xform, Black, &Lab, 1); cmsDoTransform(xform, Black, &Lab, 1);
@ -125,38 +127,37 @@ cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
Lab.a = Lab.b = 0; Lab.a = Lab.b = 0;
if (Lab.L > 50) Lab.L = 50; if (Lab.L > 50) Lab.L = 50;
// Free the resources // Free the resources
cmsDeleteTransform(xform); cmsDeleteTransform(xform);
// Convert from Lab (which is now clipped) to XYZ. // Convert from Lab (which is now clipped) to XYZ.
cmsLab2XYZ(NULL, &BlackXYZ, &Lab); cmsLab2XYZ(NULL, &BlackXYZ, &Lab);
if (BlackPoint != NULL) if (BlackPoint != NULL)
*BlackPoint = BlackXYZ; *BlackPoint = BlackXYZ;
return TRUE; return TRUE;
cmsUNUSED_PARAMETER(dwFlags); 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: // in the profile. For doing that, we use perceptual intent in input direction:
// Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab // Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab
static static
cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile) cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile)
{
{ cmsHTRANSFORM hRoundTrip;
cmsHTRANSFORM hRoundTrip;
cmsCIELab LabIn, LabOut; cmsCIELab LabIn, LabOut;
cmsCIEXYZ BlackXYZ; cmsCIEXYZ BlackXYZ;
// Is the intent supported by the profile? // Is the intent supported by the profile?
if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) { if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return TRUE; return TRUE;
} }
hRoundTrip = CreateRoundtripXForm(hProfile, INTENT_PERCEPTUAL); hRoundTrip = CreateRoundtripXForm(hProfile, INTENT_PERCEPTUAL);
if (hRoundTrip == NULL) { if (hRoundTrip == NULL) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
@ -171,10 +172,10 @@ cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfi
LabOut.a = LabOut.b = 0; LabOut.a = LabOut.b = 0;
cmsDeleteTransform(hRoundTrip); cmsDeleteTransform(hRoundTrip);
// Convert it to XYZ // Convert it to XYZ
cmsLab2XYZ(NULL, &BlackXYZ, &LabOut); cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);
if (BlackPoint != NULL) if (BlackPoint != NULL)
*BlackPoint = BlackXYZ; *BlackPoint = BlackXYZ;
@ -182,34 +183,43 @@ cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfi
} }
// This function shouldn't exist at all -- there is such quantity of broken // 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 // 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 // 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 // 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. // involves to turn BP to neutral and to use only L component.
cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags) cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
{ {
cmsProfileClassSignature devClass;
// Zero for black point // Make sure the device class is adequate
if (cmsGetDeviceClass(hProfile) == cmsSigLinkClass) { devClass = cmsGetDeviceClass(hProfile);
if (devClass == cmsSigLinkClass ||
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0; devClass == cmsSigAbstractClass ||
return FALSE; devClass == cmsSigNamedColorClass) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE;
} }
// v4 + perceptual & saturation intents does have its own black point, and it is // Make sure intent is adequate
// well specified enough to use it. Black point tag is deprecated in V4. if (Intent != INTENT_PERCEPTUAL &&
Intent != INTENT_RELATIVE_COLORIMETRIC &&
Intent != INTENT_SATURATION) {
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
return FALSE;
}
if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) && // 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)) { (Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
// Matrix shaper share MRC & perceptual intents // Matrix shaper share MRC & perceptual intents
if (cmsIsMatrixShaper(hProfile)) if (cmsIsMatrixShaper(hProfile))
return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0); return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
// Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents // 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 -> Y = cmsPERCEPTUAL_BLACK_Y;
BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z; BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
@ -220,13 +230,13 @@ cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfil
#ifdef CMS_USE_PROFILE_BLACK_POINT_TAG #ifdef CMS_USE_PROFILE_BLACK_POINT_TAG
// v2, v4 rel/abs colorimetric // v2, v4 rel/abs colorimetric
if (cmsIsTag(hProfile, cmsSigMediaBlackPointTag) && if (cmsIsTag(hProfile, cmsSigMediaBlackPointTag) &&
Intent == INTENT_RELATIVE_COLORIMETRIC) { Intent == INTENT_RELATIVE_COLORIMETRIC) {
cmsCIEXYZ *BlackPtr, BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite; cmsCIEXYZ *BlackPtr, BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite;
cmsCIELab Lab; cmsCIELab Lab;
// If black point is specified, then use it, // If black point is specified, then use it,
BlackPtr = cmsReadTag(hProfile, cmsSigMediaBlackPointTag); BlackPtr = cmsReadTag(hProfile, cmsSigMediaBlackPointTag);
if (BlackPtr != NULL) { if (BlackPtr != NULL) {
@ -245,16 +255,16 @@ cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfil
if (BlackPoint != NULL) if (BlackPoint != NULL)
*BlackPoint = TrustedBlackPoint; *BlackPoint = TrustedBlackPoint;
return TRUE; return TRUE;
} }
} }
#endif #endif
// That is about v2 profiles. // That is about v2 profiles.
// If output profile, discount ink-limiting and that's all // If output profile, discount ink-limiting and that's all
if (Intent == INTENT_RELATIVE_COLORIMETRIC && if (Intent == INTENT_RELATIVE_COLORIMETRIC &&
(cmsGetDeviceClass(hProfile) == cmsSigOutputClass) && (cmsGetDeviceClass(hProfile) == cmsSigOutputClass) &&
(cmsGetColorSpace(hProfile) == cmsSigCmykData)) (cmsGetColorSpace(hProfile) == cmsSigCmykData))
return BlackPointUsingPerceptualBlack(BlackPoint, hProfile); return BlackPointUsingPerceptualBlack(BlackPoint, hProfile);
@ -264,3 +274,299 @@ cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfil
} }
// ---------------------------------------------------------------------------------------------------------
// 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;
}

211
thirdparty/liblcms2/src/cmssm.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -36,7 +36,7 @@
// alpha = Hab // alpha = Hab
// theta = L* // theta = L*
#define SECTORS 16 // number of divisions in alpha and theta #define SECTORS 16 // number of divisions in alpha and theta
// Spherical coordinates // Spherical coordinates
typedef struct { typedef struct {
@ -47,7 +47,7 @@ typedef struct {
} cmsSpherical; } cmsSpherical;
typedef enum { typedef enum {
GP_EMPTY, GP_EMPTY,
GP_SPECIFIED, GP_SPECIFIED,
GP_MODELED GP_MODELED
@ -101,7 +101,7 @@ static
cmsFloat64Number _cmsAtan2(cmsFloat64Number y, cmsFloat64Number x) cmsFloat64Number _cmsAtan2(cmsFloat64Number y, cmsFloat64Number x)
{ {
cmsFloat64Number a; cmsFloat64Number a;
// Deal with undefined case // Deal with undefined case
if (x == 0.0 && y == 0.0) return 0; if (x == 0.0 && y == 0.0) return 0;
@ -120,20 +120,20 @@ void ToSpherical(cmsSpherical* sp, const cmsVEC3* v)
{ {
cmsFloat64Number L, a, b; cmsFloat64Number L, a, b;
L = v ->n[VX]; L = v ->n[VX];
a = v ->n[VY]; a = v ->n[VY];
b = v ->n[VZ]; b = v ->n[VZ];
sp ->r = sqrt( L*L + a*a + b*b ); sp ->r = sqrt( L*L + a*a + b*b );
if (sp ->r == 0) { if (sp ->r == 0) {
sp ->alpha = sp ->theta = 0; sp ->alpha = sp ->theta = 0;
return; return;
} }
sp ->alpha = _cmsAtan2(a, b); sp ->alpha = _cmsAtan2(a, b);
sp ->theta = _cmsAtan2(sqrt(a*a + b*b), L); sp ->theta = _cmsAtan2(sqrt(a*a + b*b), L);
} }
@ -153,7 +153,7 @@ void ToCartesian(cmsVEC3* v, const cmsSpherical* sp)
cos_theta = cos((M_PI * sp ->theta) / 180.0); cos_theta = cos((M_PI * sp ->theta) / 180.0);
a = sp ->r * sin_theta * sin_alpha; 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; L = sp ->r * cos_theta;
v ->n[VX] = L; v ->n[VX] = L;
@ -166,14 +166,14 @@ void ToCartesian(cmsVEC3* v, const cmsSpherical* sp)
// The limits are the centers of each sector, so // The limits are the centers of each sector, so
static static
void QuantizeToSector(const cmsSpherical* sp, int* alpha, int* theta) void QuantizeToSector(const cmsSpherical* sp, int* alpha, int* theta)
{ {
*alpha = (int) floor(((sp->alpha * (SECTORS)) / 360.0) ); *alpha = (int) floor(((sp->alpha * (SECTORS)) / 360.0) );
*theta = (int) floor(((sp->theta * (SECTORS)) / 180.0) ); *theta = (int) floor(((sp->theta * (SECTORS)) / 180.0) );
if (*alpha >= SECTORS) if (*alpha >= SECTORS)
*alpha = SECTORS-1; *alpha = SECTORS-1;
if (*theta >= SECTORS) if (*theta >= SECTORS)
*theta = SECTORS-1; *theta = SECTORS-1;
} }
@ -183,19 +183,19 @@ void LineOf2Points(cmsLine* line, cmsVEC3* a, cmsVEC3* b)
{ {
_cmsVEC3init(&line ->a, a ->n[VX], a ->n[VY], a ->n[VZ]); _cmsVEC3init(&line ->a, a ->n[VX], a ->n[VY], a ->n[VZ]);
_cmsVEC3init(&line ->u, b ->n[VX] - a ->n[VX], _cmsVEC3init(&line ->u, b ->n[VX] - a ->n[VX],
b ->n[VY] - a ->n[VY], b ->n[VY] - a ->n[VY],
b ->n[VZ] - a ->n[VZ]); b ->n[VZ] - a ->n[VZ]);
} }
// Evaluate parametric line // Evaluate parametric line
static static
void GetPointOfLine(cmsVEC3* p, const cmsLine* line, cmsFloat64Number t) void GetPointOfLine(cmsVEC3* p, const cmsLine* line, cmsFloat64Number t)
{ {
p ->n[VX] = line ->a.n[VX] + t * line->u.n[VX]; 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[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];
} }
@ -217,7 +217,7 @@ static
cmsBool ClosestLineToLine(cmsVEC3* r, const cmsLine* line1, const cmsLine* line2) cmsBool ClosestLineToLine(cmsVEC3* r, const cmsLine* line1, const cmsLine* line2)
{ {
cmsFloat64Number a, b, c, d, e, D; cmsFloat64Number a, b, c, d, e, D;
cmsFloat64Number sc, sN, sD; cmsFloat64Number sc, sN, sD;
cmsFloat64Number tc, tN, tD; cmsFloat64Number tc, tN, tD;
cmsVEC3 w0; cmsVEC3 w0;
@ -271,9 +271,9 @@ cmsBool ClosestLineToLine(cmsVEC3* r, const cmsLine* line1, const cmsLine* line2
} }
} }
else if (tN > tD) { // tc > 1 => the t=1 edge is visible else if (tN > tD) { // tc > 1 => the t=1 edge is visible
tN = tD; tN = tD;
// recompute sc for this edge // recompute sc for this edge
if ((-d + b) < 0.0) if ((-d + b) < 0.0)
sN = 0; sN = 0;
@ -302,7 +302,7 @@ cmsHANDLE CMSEXPORT cmsGBDAlloc(cmsContext ContextID)
{ {
cmsGDB* gbd = (cmsGDB*) _cmsMallocZero(ContextID, sizeof(cmsGDB)); cmsGDB* gbd = (cmsGDB*) _cmsMallocZero(ContextID, sizeof(cmsGDB));
if (gbd == NULL) return NULL; if (gbd == NULL) return NULL;
gbd -> ContextID = ContextID; gbd -> ContextID = ContextID;
return (cmsHANDLE) gbd; return (cmsHANDLE) gbd;
@ -310,9 +310,9 @@ cmsHANDLE CMSEXPORT cmsGBDAlloc(cmsContext ContextID)
void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD) void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD)
{ {
cmsGDB* gbd = (cmsGDB*) hGBD; cmsGDB* gbd = (cmsGDB*) hGBD;
if (hGBD != NULL) if (hGBD != NULL)
_cmsFree(gbd->ContextID, (void*) gbd); _cmsFree(gbd->ContextID, (void*) gbd);
} }
@ -321,20 +321,20 @@ void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD)
static static
cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp) cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
{ {
cmsVEC3 v; cmsVEC3 v;
int alpha, theta; int alpha, theta;
// Housekeeping // Housekeeping
_cmsAssert(gbd != NULL); _cmsAssert(gbd != NULL);
_cmsAssert(Lab != NULL); _cmsAssert(Lab != NULL);
_cmsAssert(sp != 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); _cmsVEC3init(&v, Lab ->L - 50.0, Lab ->a, Lab ->b);
// Convert to spherical coordinates // Convert to spherical coordinates
ToSpherical(sp, &v); ToSpherical(sp, &v);
if (sp ->r < 0 || sp ->alpha < 0 || sp->theta < 0) { if (sp ->r < 0 || sp ->alpha < 0 || sp->theta < 0) {
cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, "spherical value out of range"); cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, "spherical value out of range");
return NULL; return NULL;
@ -342,7 +342,7 @@ cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
// On which sector it falls? // On which sector it falls?
QuantizeToSector(sp, &alpha, &theta); QuantizeToSector(sp, &alpha, &theta);
if (alpha < 0 || theta < 0 || alpha >= SECTORS || theta >= SECTORS) { if (alpha < 0 || theta < 0 || alpha >= SECTORS || theta >= SECTORS) {
cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, " quadrant out of range"); cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, " quadrant out of range");
return NULL; return NULL;
@ -352,7 +352,7 @@ cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
return &gbd ->Gamut[theta][alpha]; 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 // GBD is centered on a=b=0 and L*=50
cmsBool CMSEXPORT cmsGDBAddPoint(cmsHANDLE hGBD, const cmsCIELab* Lab) cmsBool CMSEXPORT cmsGDBAddPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
{ {
@ -388,7 +388,7 @@ cmsBool CMSEXPORT cmsGDBAddPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
// Check if a given point falls inside gamut // Check if a given point falls inside gamut
cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab) cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
{ {
cmsGDB* gbd = (cmsGDB*) hGBD; cmsGDB* gbd = (cmsGDB*) hGBD;
cmsGDBPoint* ptr; cmsGDBPoint* ptr;
cmsSpherical sp; cmsSpherical sp;
@ -406,7 +406,7 @@ cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
// ----------------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------------
// 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. // The function returns the number of sectors as well.
// 24 9 10 11 12 // 24 9 10 11 12
@ -416,21 +416,21 @@ cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
// 20 19 18 17 16 // 20 19 18 17 16
// //
// Those are the relative movements // 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,-1}, {-1, -1}, {0, -1}, {+1, -1}, {+2, -1},
// {-2, 0}, {-1, 0}, {0, 0}, {+1, 0}, {+2, 0}, // {-2, 0}, {-1, 0}, {0, 0}, {+1, 0}, {+2, 0},
// {-2,+1}, {-1, +1}, {0, +1}, {+1, +1}, {+2, +1}, // {-2,+1}, {-1, +1}, {0, +1}, {+1, +1}, {+2, +1},
// {-2,+2}, {-1, +2}, {0, +2}, {+1, +2}, {+2, +2}}; // {-2,+2}, {-1, +2}, {0, +2}, {+1, +2}, {+2, +2}};
static static
const struct _spiral { const struct _spiral {
int AdvX, AdvY; int AdvX, AdvY;
} Spiral[] = { {0, -1}, {+1, -1}, {+1, 0}, {+1, +1}, {0, +1}, {-1, +1}, } 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}, {-1, 0}, {-1, -1}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2},
{+2, -1}, {+2, 0}, {+2, +1}, {+2, +2}, {+1, +2}, {0, +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} }; {-1, +2}, {-2, +2}, {-2, +1}, {-2, 0}, {-2, -1}, {-2, -2} };
#define NSTEPS (sizeof(Spiral) / sizeof(struct _spiral)) #define NSTEPS (sizeof(Spiral) / sizeof(struct _spiral))
@ -439,7 +439,8 @@ static
int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[]) int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[])
{ {
int nSectors = 0; int nSectors = 0;
int i, a, t; int a, t;
cmsUInt32Number i;
cmsGDBPoint* pt; cmsGDBPoint* pt;
for (i=0; i < NSTEPS; i++) { for (i=0; i < NSTEPS; i++) {
@ -453,14 +454,14 @@ int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[])
// Cycle at the begin // Cycle at the begin
if (a < 0) a = SECTORS + a; if (a < 0) a = SECTORS + a;
if (t < 0) t = SECTORS + t; if (t < 0) t = SECTORS + t;
pt = &gbd ->Gamut[t][a]; pt = &gbd ->Gamut[t][a];
if (pt -> Type != GP_EMPTY) { if (pt -> Type != GP_EMPTY) {
Close[nSectors++] = pt; Close[nSectors++] = pt;
} }
} }
return nSectors; return nSectors;
@ -470,17 +471,17 @@ int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[])
// Interpolate a missing sector. Method identifies whatever this is top, bottom or mid // Interpolate a missing sector. Method identifies whatever this is top, bottom or mid
static static
cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta) cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta)
{ {
cmsSpherical sp; cmsSpherical sp;
cmsVEC3 Lab; cmsVEC3 Lab;
cmsVEC3 Centre; cmsVEC3 Centre;
cmsLine ray; cmsLine ray;
int nCloseSectors; int nCloseSectors;
cmsGDBPoint* Close[NSTEPS]; cmsGDBPoint* Close[NSTEPS + 1];
cmsSpherical closel, templ; cmsSpherical closel, templ;
cmsLine edge; cmsLine edge;
int k, m; int k, m;
// Is that point already specified? // Is that point already specified?
if (gbd ->Gamut[theta][alpha].Type != GP_EMPTY) return TRUE; if (gbd ->Gamut[theta][alpha].Type != GP_EMPTY) return TRUE;
@ -488,10 +489,10 @@ cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta)
nCloseSectors = FindNearSectors(gbd, alpha, theta, Close); 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.alpha = (cmsFloat64Number) ((alpha + 0.5) * 360.0) / (SECTORS);
sp.theta = (cmsFloat64Number) ((theta + 0.5) * 180.0) / (SECTORS); sp.theta = (cmsFloat64Number) ((theta + 0.5) * 180.0) / (SECTORS);
sp.r = 50.0; sp.r = 50.0;
// Convert to Cartesian // Convert to Cartesian
ToCartesian(&Lab, &sp); ToCartesian(&Lab, &sp);
@ -510,28 +511,28 @@ cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta)
for(m = k+1; m < nCloseSectors; m++) { for(m = k+1; m < nCloseSectors; m++) {
cmsVEC3 temp, a1, a2; cmsVEC3 temp, a1, a2;
// A line from sector to sector // A line from sector to sector
ToCartesian(&a1, &Close[k]->p); ToCartesian(&a1, &Close[k]->p);
ToCartesian(&a2, &Close[m]->p); ToCartesian(&a2, &Close[m]->p);
LineOf2Points(&edge, &a1, &a2); LineOf2Points(&edge, &a1, &a2);
// Find a line // Find a line
ClosestLineToLine(&temp, &ray, &edge); ClosestLineToLine(&temp, &ray, &edge);
// Convert to spherical // Convert to spherical
ToSpherical(&templ, &temp); 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.theta <= ((theta+1)*180.0/SECTORS) &&
templ.alpha >= (alpha*360.0/SECTORS) && templ.alpha >= (alpha*360.0/SECTORS) &&
templ.alpha <= ((alpha+1)*360.0/SECTORS)) { templ.alpha <= ((alpha+1)*360.0/SECTORS)) {
closel = templ; closel = templ;
} }
} }
} }
@ -553,13 +554,13 @@ cmsBool CMSEXPORT cmsGDBCompute(cmsHANDLE hGBD, cmsUInt32Number dwFlags)
_cmsAssert(hGBD != NULL); _cmsAssert(hGBD != NULL);
// Interpolate black // Interpolate black
for (alpha = 0; alpha <= SECTORS; alpha++) { for (alpha = 0; alpha < SECTORS; alpha++) {
if (!InterpolateMissingSector(gbd, alpha, 0)) return FALSE; if (!InterpolateMissingSector(gbd, alpha, 0)) return FALSE;
} }
// Interpolate white // Interpolate white
for (alpha = 0; alpha <= SECTORS; alpha++) { for (alpha = 0; alpha < SECTORS; alpha++) {
if (!InterpolateMissingSector(gbd, alpha, SECTORS-1)) return FALSE; if (!InterpolateMissingSector(gbd, alpha, SECTORS-1)) return FALSE;
} }
@ -567,7 +568,7 @@ cmsBool CMSEXPORT cmsGDBCompute(cmsHANDLE hGBD, cmsUInt32Number dwFlags)
// Interpolate Mid // Interpolate Mid
for (theta = 1; theta < SECTORS; theta++) { 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; if (!InterpolateMissingSector(gbd, alpha, theta)) return FALSE;
} }
@ -600,34 +601,34 @@ cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
fprintf (fp, "#VRML V2.0 utf8\n"); 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, "DEF CamTest Group {\n");
fprintf (fp, "\tchildren [\n"); fprintf (fp, "\tchildren [\n");
fprintf (fp, "\t\tDEF Cameras Group {\n"); fprintf (fp, "\t\tDEF Cameras Group {\n");
fprintf (fp, "\t\t\tchildren [\n"); fprintf (fp, "\t\t\tchildren [\n");
fprintf (fp, "\t\t\t\tDEF DefaultView Viewpoint {\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\tposition 0 0 340\n");
fprintf (fp, "\t\t\t\t\torientation 0 0 1 0\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\tdescription \"default view\"\n");
fprintf (fp, "\t\t\t\t}\n"); fprintf (fp, "\t\t\t\t}\n");
fprintf (fp, "\t\t\t]\n"); fprintf (fp, "\t\t\t]\n");
fprintf (fp, "\t\t},\n"); fprintf (fp, "\t\t},\n");
fprintf (fp, "\t]\n"); fprintf (fp, "\t]\n");
fprintf (fp, "}\n"); fprintf (fp, "}\n");
// Output the background stuff // Output the background stuff
fprintf (fp, "Background {\n"); fprintf (fp, "Background {\n");
fprintf (fp, "\tskyColor [\n"); fprintf (fp, "\tskyColor [\n");
fprintf (fp, "\t\t.5 .5 .5\n"); fprintf (fp, "\t\t.5 .5 .5\n");
fprintf (fp, "\t]\n"); fprintf (fp, "\t]\n");
fprintf (fp, "}\n"); fprintf (fp, "}\n");
// Output the shape stuff // Output the shape stuff
fprintf (fp, "Transform {\n"); fprintf (fp, "Transform {\n");
fprintf (fp, "\tscale .3 .3 .3\n"); fprintf (fp, "\tscale .3 .3 .3\n");
fprintf (fp, "\tchildren [\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\tShape {\n");
fprintf (fp, "\t\t\tappearance Appearance {\n"); fprintf (fp, "\t\t\tappearance Appearance {\n");
fprintf (fp, "\t\t\t\tmaterial Material {\n"); fprintf (fp, "\t\t\t\tmaterial Material {\n");
@ -651,7 +652,7 @@ cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t}\n"); fprintf (fp, "\t\t}\n");
fprintf (fp, "\t\tShape {\n"); fprintf (fp, "\t\tShape {\n");
fprintf (fp, "\t\t\tappearance Appearance {\n"); fprintf (fp, "\t\t\tappearance Appearance {\n");
fprintf (fp, "\t\t\t\tmaterial Material {\n"); fprintf (fp, "\t\t\t\tmaterial Material {\n");
@ -661,8 +662,8 @@ cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
fprintf (fp, "\t\t\t\t}\n"); fprintf (fp, "\t\t\t\t}\n");
fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t\tgeometry PointSet {\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\tcoord Coordinate {\n");
fprintf (fp, "\t\t\t\t\tpoint [\n"); fprintf (fp, "\t\t\t\t\tpoint [\n");
@ -677,7 +678,7 @@ cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
fprintf (fp, "\t\t\t\t\t%g %g %g", v.n[0]+50, v.n[1], v.n[2]); 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"); fprintf (fp, "]\n");
else else
fprintf (fp, ",\n"); fprintf (fp, ",\n");
@ -688,7 +689,7 @@ cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
// fill in the face colors // fill in the face colors
fprintf (fp, "\t\t\t\tcolor Color {\n"); fprintf (fp, "\t\t\t\tcolor Color {\n");
fprintf (fp, "\t\t\t\t\tcolor [\n"); fprintf (fp, "\t\t\t\t\tcolor [\n");
@ -696,30 +697,30 @@ cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
for (j=0; j < SECTORS; j++) { for (j=0; j < SECTORS; j++) {
cmsVEC3 v; cmsVEC3 v;
pt = &gbd ->Gamut[i][j]; pt = &gbd ->Gamut[i][j];
ToCartesian(&v, &pt ->p); 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); fprintf (fp, "\t\t\t\t\t%g %g %g", 0.0, 0.0, 0.0);
else else
if (pt ->Type == GP_MODELED) if (pt ->Type == GP_MODELED)
fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, .5, .5); 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); 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"); fprintf (fp, "]\n");
else else
fprintf (fp, ",\n"); fprintf (fp, ",\n");
} }
fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\t}\n");
fprintf (fp, "\t\t}\n"); fprintf (fp, "\t\t}\n");

1958
thirdparty/liblcms2/src/cmstypes.c vendored
View File

File diff suppressed because it is too large Load Diff

442
thirdparty/liblcms2/src/cmsvirt.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -35,7 +35,7 @@ cmsBool SetTextTags(cmsHPROFILE hProfile, const wchar_t* Description)
cmsMLU *DescriptionMLU, *CopyrightMLU; cmsMLU *DescriptionMLU, *CopyrightMLU;
cmsBool rc = FALSE; cmsBool rc = FALSE;
cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsContext ContextID = cmsGetProfileContextID(hProfile);
DescriptionMLU = cmsMLUalloc(ContextID, 1); DescriptionMLU = cmsMLUalloc(ContextID, 1);
CopyrightMLU = cmsMLUalloc(ContextID, 1); CopyrightMLU = cmsMLUalloc(ContextID, 1);
@ -45,8 +45,8 @@ cmsBool SetTextTags(cmsHPROFILE hProfile, const wchar_t* Description)
if (!cmsMLUsetWide(CopyrightMLU, "en", "US", L"No copyright, use freely")) goto Error; if (!cmsMLUsetWide(CopyrightMLU, "en", "US", L"No copyright, use freely")) goto Error;
if (!cmsWriteTag(hProfile, cmsSigProfileDescriptionTag, DescriptionMLU)) 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; rc = TRUE;
Error: Error:
@ -57,7 +57,7 @@ Error:
cmsMLUfree(CopyrightMLU); cmsMLUfree(CopyrightMLU);
return rc; return rc;
} }
static static
cmsBool SetSeqDescTag(cmsHPROFILE hProfile, const char* Model) cmsBool SetSeqDescTag(cmsHPROFILE hProfile, const char* Model)
@ -72,10 +72,10 @@ cmsBool SetSeqDescTag(cmsHPROFILE hProfile, const char* Model)
Seq->seq[0].deviceModel = (cmsSignature) 0; Seq->seq[0].deviceModel = (cmsSignature) 0;
#ifdef CMS_DONT_USE_INT64 #ifdef CMS_DONT_USE_INT64
Seq->seq[0].attributes[0] = 0; Seq->seq[0].attributes[0] = 0;
Seq->seq[0].attributes[1] = 0; Seq->seq[0].attributes[1] = 0;
#else #else
Seq->seq[0].attributes = 0; Seq->seq[0].attributes = 0;
#endif #endif
Seq->seq[0].technology = (cmsTechnologySignature) 0; Seq->seq[0].technology = (cmsTechnologySignature) 0;
@ -84,11 +84,11 @@ cmsBool SetSeqDescTag(cmsHPROFILE hProfile, const char* Model)
cmsMLUsetASCII( Seq->seq[0].Model, cmsNoLanguage, cmsNoCountry, Model); cmsMLUsetASCII( Seq->seq[0].Model, cmsNoLanguage, cmsNoCountry, Model);
if (!_cmsWriteProfileSequence(hProfile, Seq)) goto Error; if (!_cmsWriteProfileSequence(hProfile, Seq)) goto Error;
rc = TRUE; rc = TRUE;
Error: Error:
if (Seq) if (Seq)
cmsFreeProfileSequenceDescription(Seq); cmsFreeProfileSequenceDescription(Seq);
return rc; return rc;
@ -103,7 +103,7 @@ cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID,
const cmsCIExyYTRIPLE* Primaries, const cmsCIExyYTRIPLE* Primaries,
cmsToneCurve* const TransferFunction[3]) cmsToneCurve* const TransferFunction[3])
{ {
cmsHPROFILE hICC; cmsHPROFILE hICC;
cmsMAT3 MColorants; cmsMAT3 MColorants;
cmsCIEXYZTRIPLE Colorants; cmsCIEXYZTRIPLE Colorants;
cmsCIExyY MaxWhite; cmsCIExyY MaxWhite;
@ -114,13 +114,13 @@ cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID,
if (!hICC) // can't allocate if (!hICC) // can't allocate
return NULL; return NULL;
cmsSetProfileVersion(hICC, 4.2); cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigDisplayClass); cmsSetDeviceClass(hICC, cmsSigDisplayClass);
cmsSetColorSpace(hICC, cmsSigRgbData); cmsSetColorSpace(hICC, cmsSigRgbData);
cmsSetPCS(hICC, cmsSigXYZData); cmsSetPCS(hICC, cmsSigXYZData);
cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Implement profile using following tags: // Implement profile using following tags:
@ -137,7 +137,7 @@ cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID,
// This conforms a standard RGB DisplayProfile as says ICC, and then I add (As per addendum II) // This conforms a standard RGB DisplayProfile as says ICC, and then I add (As per addendum II)
// 10 cmsSigChromaticityTag // 10 cmsSigChromaticityTag
if (!SetTextTags(hICC, L"RGB built-in")) goto Error; if (!SetTextTags(hICC, L"RGB built-in")) goto Error;
if (WhitePoint) { if (WhitePoint) {
@ -145,9 +145,9 @@ cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID,
if (!cmsWriteTag(hICC, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error; if (!cmsWriteTag(hICC, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error;
cmsxyY2XYZ(&WhitePointXYZ, WhitePoint); 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; if (!cmsWriteTag(hICC, cmsSigChromaticAdaptationTag, (void*) &CHAD)) goto Error;
} }
@ -157,8 +157,8 @@ cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID,
MaxWhite.y = WhitePoint -> y; MaxWhite.y = WhitePoint -> y;
MaxWhite.Y = 1.0; 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.X = MColorants.v[0].n[0];
Colorants.Red.Y = MColorants.v[1].n[0]; Colorants.Red.Y = MColorants.v[1].n[0];
Colorants.Red.Z = MColorants.v[2].n[0]; Colorants.Red.Z = MColorants.v[2].n[0];
@ -178,10 +178,27 @@ cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID,
if (TransferFunction) { 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, 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) { if (Primaries) {
@ -212,18 +229,18 @@ cmsHPROFILE CMSEXPORT cmsCreateGrayProfileTHR(cmsContext ContextID,
const cmsToneCurve* TransferFunction) const cmsToneCurve* TransferFunction)
{ {
cmsHPROFILE hICC; cmsHPROFILE hICC;
cmsCIEXYZ tmp; cmsCIEXYZ tmp;
hICC = cmsCreateProfilePlaceholder(ContextID); hICC = cmsCreateProfilePlaceholder(ContextID);
if (!hICC) // can't allocate if (!hICC) // can't allocate
return NULL; return NULL;
cmsSetProfileVersion(hICC, 4.2); cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigDisplayClass); cmsSetDeviceClass(hICC, cmsSigDisplayClass);
cmsSetColorSpace(hICC, cmsSigGrayData); cmsSetColorSpace(hICC, cmsSigGrayData);
cmsSetPCS(hICC, cmsSigXYZData); cmsSetPCS(hICC, cmsSigXYZData);
cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Implement profile using following tags: // Implement profile using following tags:
@ -232,7 +249,7 @@ cmsHPROFILE CMSEXPORT cmsCreateGrayProfileTHR(cmsContext ContextID,
// 2 cmsSigMediaWhitePointTag // 2 cmsSigMediaWhitePointTag
// 3 cmsSigGrayTRCTag // 3 cmsSigGrayTRCTag
// This conforms a standard Gray DisplayProfile // This conforms a standard Gray DisplayProfile
// Fill-in the tags // Fill-in the tags
@ -274,20 +291,19 @@ cmsHPROFILE CMSEXPORT cmsCreateLinearizationDeviceLinkTHR(cmsContext ContextID,
{ {
cmsHPROFILE hICC; cmsHPROFILE hICC;
cmsPipeline* Pipeline; cmsPipeline* Pipeline;
cmsStage* Lin;
int nChannels; int nChannels;
hICC = cmsCreateProfilePlaceholder(ContextID); hICC = cmsCreateProfilePlaceholder(ContextID);
if (!hICC) if (!hICC)
return NULL; return NULL;
cmsSetProfileVersion(hICC, 4.2); cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigLinkClass); cmsSetDeviceClass(hICC, cmsSigLinkClass);
cmsSetColorSpace(hICC, ColorSpace); cmsSetColorSpace(hICC, ColorSpace);
cmsSetPCS(hICC, ColorSpace); cmsSetPCS(hICC, ColorSpace);
cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Set up channels // Set up channels
nChannels = cmsChannelsOf(ColorSpace); nChannels = cmsChannelsOf(ColorSpace);
@ -298,14 +314,12 @@ cmsHPROFILE CMSEXPORT cmsCreateLinearizationDeviceLinkTHR(cmsContext ContextID,
// Copy tables to Pipeline // Copy tables to Pipeline
Lin = cmsStageAllocToneCurves(ContextID, nChannels, TransferFunctions); if (!cmsPipelineInsertStage(Pipeline, cmsAT_BEGIN, cmsStageAllocToneCurves(ContextID, nChannels, TransferFunctions)))
if (Lin == NULL) goto Error; goto Error;
cmsPipelineInsertStage(Pipeline, cmsAT_BEGIN, Lin); // Create tags
if (!SetTextTags(hICC, L"Linearization built-in")) goto Error;
// Create tags if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline)) goto Error;
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; if (!SetSeqDescTag(hICC, "Linearization built-in")) goto Error;
// Pipeline is already on virtual profile // Pipeline is already on virtual profile
@ -315,6 +329,7 @@ cmsHPROFILE CMSEXPORT cmsCreateLinearizationDeviceLinkTHR(cmsContext ContextID,
return hICC; return hICC;
Error: Error:
cmsPipelineFree(Pipeline);
if (hICC) if (hICC)
cmsCloseProfile(hICC); cmsCloseProfile(hICC);
@ -330,13 +345,13 @@ cmsHPROFILE CMSEXPORT cmsCreateLinearizationDeviceLink(cmsColorSpaceSignature Co
// Ink-limiting algorithm // Ink-limiting algorithm
// //
// Sum = C + M + Y + K // Sum = C + M + Y + K
// If Sum > InkLimit // If Sum > InkLimit
// Ratio= 1 - (Sum - InkLimit) / (C + M + Y) // Ratio= 1 - (Sum - InkLimit) / (C + M + Y)
// if Ratio <0 // if Ratio <0
// Ratio=0 // Ratio=0
// endif // endif
// Else // Else
// Ratio=1 // Ratio=1
// endif // endif
// //
@ -354,7 +369,7 @@ int InkLimitingSampler(register const cmsUInt16Number In[], register cmsUInt16Nu
InkLimit = (InkLimit * 655.35); InkLimit = (InkLimit * 655.35);
SumCMY = In[0] + In[1] + In[2]; SumCMY = In[0] + In[1] + In[2];
SumCMYK = SumCMY + In[3]; SumCMYK = SumCMY + In[3];
if (SumCMYK > InkLimit) { if (SumCMYK > InkLimit) {
@ -375,7 +390,7 @@ int InkLimitingSampler(register const cmsUInt16Number In[], register cmsUInt16Nu
// This is a devicelink operating in CMYK for ink-limiting // This is a devicelink operating in CMYK for ink-limiting
cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID, cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID,
cmsColorSpaceSignature ColorSpace, cmsColorSpaceSignature ColorSpace,
cmsFloat64Number Limit) cmsFloat64Number Limit)
{ {
@ -383,7 +398,7 @@ cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID,
cmsPipeline* LUT; cmsPipeline* LUT;
cmsStage* CLUT; cmsStage* CLUT;
int nChannels; int nChannels;
if (ColorSpace != cmsSigCmykData) { if (ColorSpace != cmsSigCmykData) {
cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "InkLimiting: Only CMYK currently supported"); cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "InkLimiting: Only CMYK currently supported");
return NULL; return NULL;
@ -391,7 +406,7 @@ cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID,
if (Limit < 0.0 || Limit > 400) { 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 < 0) Limit = 0;
if (Limit > 400) Limit = 400; if (Limit > 400) Limit = 400;
@ -401,37 +416,38 @@ cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID,
if (!hICC) // can't allocate if (!hICC) // can't allocate
return NULL; return NULL;
cmsSetProfileVersion(hICC, 4.2); cmsSetProfileVersion(hICC, 4.3);
cmsSetDeviceClass(hICC, cmsSigLinkClass); cmsSetDeviceClass(hICC, cmsSigLinkClass);
cmsSetColorSpace(hICC, ColorSpace); cmsSetColorSpace(hICC, ColorSpace);
cmsSetPCS(hICC, ColorSpace); cmsSetPCS(hICC, ColorSpace);
cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Creates a Pipeline with 3D grid only // Creates a Pipeline with 3D grid only
LUT = cmsPipelineAlloc(ContextID, 4, 4); LUT = cmsPipelineAlloc(ContextID, 4, 4);
if (LUT == NULL) goto Error; if (LUT == NULL) goto Error;
nChannels = cmsChannelsOf(ColorSpace); nChannels = cmsChannelsOf(ColorSpace);
CLUT = cmsStageAllocCLut16bit(ContextID, 17, nChannels, nChannels, NULL); CLUT = cmsStageAllocCLut16bit(ContextID, 17, nChannels, nChannels, NULL);
if (CLUT == NULL) goto Error; if (CLUT == NULL) goto Error;
if (!cmsStageSampleCLut16bit(CLUT, InkLimitingSampler, (void*) &Limit, 0)) goto Error; if (!cmsStageSampleCLut16bit(CLUT, InkLimitingSampler, (void*) &Limit, 0)) goto Error;
cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, nChannels)); if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, nChannels)) ||
cmsPipelineInsertStage(LUT, cmsAT_END, CLUT); !cmsPipelineInsertStage(LUT, cmsAT_END, CLUT) ||
cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, nChannels)); !cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, nChannels)))
goto Error;
// Create tags // Create tags
if (!SetTextTags(hICC, L"ink-limiting built-in")) goto Error; if (!SetTextTags(hICC, L"ink-limiting built-in")) goto Error;
if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) LUT)) goto Error; if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) LUT)) goto Error;
if (!SetSeqDescTag(hICC, "ink-limiting built-in")) goto Error; if (!SetSeqDescTag(hICC, "ink-limiting built-in")) goto Error;
// cmsPipeline is already on virtual profile // cmsPipeline is already on virtual profile
cmsPipelineFree(LUT); cmsPipelineFree(LUT);
@ -457,9 +473,9 @@ cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLink(cmsColorSpaceSignature Colo
// Creates a fake Lab identity. // Creates a fake Lab identity.
cmsHPROFILE CMSEXPORT cmsCreateLab2ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint) cmsHPROFILE CMSEXPORT cmsCreateLab2ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint)
{ {
cmsHPROFILE hProfile; cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL; cmsPipeline* LUT = NULL;
hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL); hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL);
if (hProfile == NULL) return NULL; if (hProfile == NULL) return NULL;
@ -475,7 +491,8 @@ cmsHPROFILE CMSEXPORT cmsCreateLab2ProfileTHR(cmsContext ContextID, const cmsCIE
LUT = cmsPipelineAlloc(ContextID, 3, 3); LUT = cmsPipelineAlloc(ContextID, 3, 3);
if (LUT == NULL) goto Error; 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; if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error;
cmsPipelineFree(LUT); cmsPipelineFree(LUT);
@ -503,13 +520,13 @@ cmsHPROFILE CMSEXPORT cmsCreateLab2Profile(const cmsCIExyY* WhitePoint)
// Creates a fake Lab V4 identity. // Creates a fake Lab V4 identity.
cmsHPROFILE CMSEXPORT cmsCreateLab4ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint) cmsHPROFILE CMSEXPORT cmsCreateLab4ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint)
{ {
cmsHPROFILE hProfile; cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL; cmsPipeline* LUT = NULL;
hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL); hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL);
if (hProfile == NULL) return NULL; if (hProfile == NULL) return NULL;
cmsSetProfileVersion(hProfile, 4.2); cmsSetProfileVersion(hProfile, 4.3);
cmsSetDeviceClass(hProfile, cmsSigAbstractClass); cmsSetDeviceClass(hProfile, cmsSigAbstractClass);
cmsSetColorSpace(hProfile, cmsSigLabData); cmsSetColorSpace(hProfile, cmsSigLabData);
@ -521,7 +538,8 @@ cmsHPROFILE CMSEXPORT cmsCreateLab4ProfileTHR(cmsContext ContextID, const cmsCIE
LUT = cmsPipelineAlloc(ContextID, 3, 3); LUT = cmsPipelineAlloc(ContextID, 3, 3);
if (LUT == NULL) goto Error; 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; if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error;
cmsPipelineFree(LUT); cmsPipelineFree(LUT);
@ -548,13 +566,13 @@ cmsHPROFILE CMSEXPORT cmsCreateLab4Profile(const cmsCIExyY* WhitePoint)
// Creates a fake XYZ identity // Creates a fake XYZ identity
cmsHPROFILE CMSEXPORT cmsCreateXYZProfileTHR(cmsContext ContextID) cmsHPROFILE CMSEXPORT cmsCreateXYZProfileTHR(cmsContext ContextID)
{ {
cmsHPROFILE hProfile; cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL; cmsPipeline* LUT = NULL;
hProfile = cmsCreateRGBProfileTHR(ContextID, cmsD50_xyY(), NULL, NULL); hProfile = cmsCreateRGBProfileTHR(ContextID, cmsD50_xyY(), NULL, NULL);
if (hProfile == NULL) return NULL; if (hProfile == NULL) return NULL;
cmsSetProfileVersion(hProfile, 4.2); cmsSetProfileVersion(hProfile, 4.3);
cmsSetDeviceClass(hProfile, cmsSigAbstractClass); cmsSetDeviceClass(hProfile, cmsSigAbstractClass);
cmsSetColorSpace(hProfile, cmsSigXYZData); cmsSetColorSpace(hProfile, cmsSigXYZData);
@ -566,7 +584,8 @@ cmsHPROFILE CMSEXPORT cmsCreateXYZProfileTHR(cmsContext ContextID)
LUT = cmsPipelineAlloc(ContextID, 3, 3); LUT = cmsPipelineAlloc(ContextID, 3, 3);
if (LUT == NULL) goto Error; 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; if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error;
cmsPipelineFree(LUT); cmsPipelineFree(LUT);
@ -615,12 +634,12 @@ cmsToneCurve* Build_sRGBGamma(cmsContext ContextID)
Parameters[1] = 1. / 1.055; Parameters[1] = 1. / 1.055;
Parameters[2] = 0.055 / 1.055; Parameters[2] = 0.055 / 1.055;
Parameters[3] = 1. / 12.92; Parameters[3] = 1. / 12.92;
Parameters[4] = 0.04045; Parameters[4] = 0.04045;
return cmsBuildParametricToneCurve(ContextID, 4, Parameters); 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) cmsHPROFILE CMSEXPORT cmsCreate_sRGBProfileTHR(cmsContext ContextID)
{ {
cmsCIExyY D65; cmsCIExyY D65;
@ -631,11 +650,11 @@ cmsHPROFILE CMSEXPORT cmsCreate_sRGBProfileTHR(cmsContext ContextID)
}; };
cmsToneCurve* Gamma22[3]; cmsToneCurve* Gamma22[3];
cmsHPROFILE hsRGB; cmsHPROFILE hsRGB;
cmsWhitePointFromTemp(&D65, 6504); cmsWhitePointFromTemp(&D65, 6504);
Gamma22[0] = Gamma22[1] = Gamma22[2] = Build_sRGBGamma(ContextID); Gamma22[0] = Gamma22[1] = Gamma22[2] = Build_sRGBGamma(ContextID);
if (Gamma22[0] == NULL) return NULL; if (Gamma22[0] == NULL) return NULL;
hsRGB = cmsCreateRGBProfileTHR(ContextID, &D65, &Rec709Primaries, Gamma22); hsRGB = cmsCreateRGBProfileTHR(ContextID, &D65, &Rec709Primaries, Gamma22);
cmsFreeToneCurve(Gamma22[0]); cmsFreeToneCurve(Gamma22[0]);
if (hsRGB == NULL) return NULL; if (hsRGB == NULL) return NULL;
@ -672,31 +691,31 @@ int bchswSampler(register const cmsUInt16Number In[], register cmsUInt16Number O
cmsCIELCh LChIn, LChOut; cmsCIELCh LChIn, LChOut;
cmsCIEXYZ XYZ; cmsCIEXYZ XYZ;
LPBCHSWADJUSTS bchsw = (LPBCHSWADJUSTS) Cargo; LPBCHSWADJUSTS bchsw = (LPBCHSWADJUSTS) Cargo;
cmsLabEncoded2Float(&LabIn, In); cmsLabEncoded2Float(&LabIn, In);
cmsLab2LCh(&LChIn, &LabIn); cmsLab2LCh(&LChIn, &LabIn);
// Do some adjusts on LCh // Do some adjusts on LCh
LChOut.L = LChIn.L * bchsw ->Contrast + bchsw ->Brightness; LChOut.L = LChIn.L * bchsw ->Contrast + bchsw ->Brightness;
LChOut.C = LChIn.C + bchsw -> Saturation; LChOut.C = LChIn.C + bchsw -> Saturation;
LChOut.h = LChIn.h + bchsw -> Hue; LChOut.h = LChIn.h + bchsw -> Hue;
cmsLCh2Lab(&LabOut, &LChOut); cmsLCh2Lab(&LabOut, &LChOut);
// Move white point in Lab // Move white point in Lab
cmsLab2XYZ(&bchsw ->WPsrc, &XYZ, &LabOut); cmsLab2XYZ(&bchsw ->WPsrc, &XYZ, &LabOut);
cmsXYZ2Lab(&bchsw ->WPdest, &LabOut, &XYZ); cmsXYZ2Lab(&bchsw ->WPdest, &LabOut, &XYZ);
// Back to encoded // Back to encoded
cmsFloat2LabEncoded(Out, &LabOut); cmsFloat2LabEncoded(Out, &LabOut);
return TRUE; return TRUE;
} }
@ -705,101 +724,103 @@ int bchswSampler(register const cmsUInt16Number In[], register cmsUInt16Number O
// contrast, Saturation and white point displacement // contrast, Saturation and white point displacement
cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfileTHR(cmsContext ContextID, cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfileTHR(cmsContext ContextID,
int nLUTPoints, int nLUTPoints,
cmsFloat64Number Bright, cmsFloat64Number Bright,
cmsFloat64Number Contrast, cmsFloat64Number Contrast,
cmsFloat64Number Hue, cmsFloat64Number Hue,
cmsFloat64Number Saturation, cmsFloat64Number Saturation,
int TempSrc, int TempSrc,
int TempDest) int TempDest)
{ {
cmsHPROFILE hICC; cmsHPROFILE hICC;
cmsPipeline* Pipeline; cmsPipeline* Pipeline;
BCHSWADJUSTS bchsw; BCHSWADJUSTS bchsw;
cmsCIExyY WhitePnt; cmsCIExyY WhitePnt;
cmsStage* CLUT; cmsStage* CLUT;
cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS]; cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
int i; 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;
bchsw.Brightness = Bright; cmsSetDeviceClass(hICC, cmsSigAbstractClass);
bchsw.Contrast = Contrast; cmsSetColorSpace(hICC, cmsSigLabData);
bchsw.Hue = Hue; cmsSetPCS(hICC, cmsSigLabData);
bchsw.Saturation = Saturation;
cmsWhitePointFromTemp(&WhitePnt, TempSrc );
cmsxyY2XYZ(&bchsw.WPsrc, &WhitePnt);
cmsWhitePointFromTemp(&WhitePnt, TempDest); cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL);
cmsxyY2XYZ(&bchsw.WPdest, &WhitePnt);
hICC = cmsCreateProfilePlaceholder(ContextID);
if (!hICC) // can't allocate
return NULL;
cmsSetDeviceClass(hICC, cmsSigAbstractClass); // Creates a Pipeline with 3D grid only
cmsSetColorSpace(hICC, cmsSigLabData); Pipeline = cmsPipelineAlloc(ContextID, 3, 3);
cmsSetPCS(hICC, cmsSigLabData); if (Pipeline == NULL) {
cmsCloseProfile(hICC);
return NULL;
}
cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); for (i=0; i < MAX_INPUT_DIMENSIONS; i++) Dimensions[i] = nLUTPoints;
CLUT = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, 3, 3, NULL);
if (CLUT == NULL) return NULL;
// 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; if (!cmsStageSampleCLut16bit(CLUT, bchswSampler, (void*) &bchsw, 0)) {
CLUT = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, 3, 3, NULL);
if (CLUT == NULL) return NULL;
if (!cmsStageSampleCLut16bit(CLUT, bchswSampler, (void*) &bchsw, 0)) {
// Shouldn't reach here // Shouldn't reach here
cmsPipelineFree(Pipeline); goto Error;
cmsCloseProfile(hICC); }
return NULL;
}
cmsPipelineInsertStage(Pipeline, cmsAT_END, CLUT); if (!cmsPipelineInsertStage(Pipeline, cmsAT_END, CLUT)) {
goto Error;
}
// Create tags // Create tags
if (!SetTextTags(hICC, L"BCHS built-in")) return NULL;
if (!SetTextTags(hICC, L"BCHS built-in")) return NULL;
cmsWriteTag(hICC, cmsSigMediaWhitePointTag, (void*) cmsD50_XYZ());
cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline); cmsWriteTag(hICC, cmsSigMediaWhitePointTag, (void*) cmsD50_XYZ());
// Pipeline is already on virtual profile
cmsPipelineFree(Pipeline);
// Ok, done cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline);
return hICC;
// 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, CMSAPI cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfile(int nLUTPoints,
cmsFloat64Number Bright, cmsFloat64Number Bright,
cmsFloat64Number Contrast, cmsFloat64Number Contrast,
cmsFloat64Number Hue, cmsFloat64Number Hue,
cmsFloat64Number Saturation, cmsFloat64Number Saturation,
int TempSrc, int TempSrc,
int TempDest) int TempDest)
{ {
return cmsCreateBCHSWabstractProfileTHR(NULL, nLUTPoints, Bright, Contrast, Hue, Saturation, TempSrc, 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 // Is useful only for gamut checking tricks
cmsHPROFILE CMSEXPORT cmsCreateNULLProfileTHR(cmsContext ContextID) cmsHPROFILE CMSEXPORT cmsCreateNULLProfileTHR(cmsContext ContextID)
{ {
cmsHPROFILE hProfile; cmsHPROFILE hProfile;
cmsPipeline* LUT = NULL; cmsPipeline* LUT = NULL;
cmsStage* PostLin; cmsStage* PostLin;
cmsToneCurve* EmptyTab; cmsToneCurve* EmptyTab;
@ -809,11 +830,11 @@ cmsHPROFILE CMSEXPORT cmsCreateNULLProfileTHR(cmsContext ContextID)
if (!hProfile) // can't allocate if (!hProfile) // can't allocate
return NULL; 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); cmsSetDeviceClass(hProfile, cmsSigOutputClass);
cmsSetColorSpace(hProfile, cmsSigGrayData); cmsSetColorSpace(hProfile, cmsSigGrayData);
@ -823,16 +844,17 @@ cmsHPROFILE CMSEXPORT cmsCreateNULLProfileTHR(cmsContext ContextID)
LUT = cmsPipelineAlloc(ContextID, 1, 1); LUT = cmsPipelineAlloc(ContextID, 1, 1);
if (LUT == NULL) goto Error; if (LUT == NULL) goto Error;
EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero); EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero);
PostLin = cmsStageAllocToneCurves(ContextID, 1, &EmptyTab); PostLin = cmsStageAllocToneCurves(ContextID, 1, &EmptyTab);
cmsFreeToneCurve(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, cmsSigBToA0Tag, (void*) LUT)) goto Error;
if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error; if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error;
cmsPipelineFree(LUT); cmsPipelineFree(LUT);
return hProfile; return hProfile;
Error: Error:
@ -861,14 +883,14 @@ int IsPCS(cmsColorSpaceSignature ColorSpace)
static static
void FixColorSpaces(cmsHPROFILE hProfile, void FixColorSpaces(cmsHPROFILE hProfile,
cmsColorSpaceSignature ColorSpace, cmsColorSpaceSignature ColorSpace,
cmsColorSpaceSignature PCS, cmsColorSpaceSignature PCS,
cmsUInt32Number dwFlags) cmsUInt32Number dwFlags)
{ {
if (dwFlags & cmsFLAGS_GUESSDEVICECLASS) { if (dwFlags & cmsFLAGS_GUESSDEVICECLASS) {
if (IsPCS(ColorSpace) && IsPCS(PCS)) { if (IsPCS(ColorSpace) && IsPCS(PCS)) {
cmsSetDeviceClass(hProfile, cmsSigAbstractClass); cmsSetDeviceClass(hProfile, cmsSigAbstractClass);
cmsSetColorSpace(hProfile, ColorSpace); cmsSetColorSpace(hProfile, ColorSpace);
@ -880,7 +902,7 @@ void FixColorSpaces(cmsHPROFILE hProfile,
cmsSetDeviceClass(hProfile, cmsSigOutputClass); cmsSetDeviceClass(hProfile, cmsSigOutputClass);
cmsSetPCS(hProfile, ColorSpace); cmsSetPCS(hProfile, ColorSpace);
cmsSetColorSpace(hProfile, PCS); cmsSetColorSpace(hProfile, PCS);
return; return;
} }
@ -908,7 +930,7 @@ static
cmsHPROFILE CreateNamedColorDevicelink(cmsHTRANSFORM xform) cmsHPROFILE CreateNamedColorDevicelink(cmsHTRANSFORM xform)
{ {
_cmsTRANSFORM* v = (_cmsTRANSFORM*) xform; _cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
cmsHPROFILE hICC = NULL; cmsHPROFILE hICC = NULL;
int i, nColors; int i, nColors;
cmsNAMEDCOLORLIST *nc2 = NULL, *Original = NULL; cmsNAMEDCOLORLIST *nc2 = NULL, *Original = NULL;
@ -922,7 +944,7 @@ cmsHPROFILE CreateNamedColorDevicelink(cmsHTRANSFORM xform)
cmsSetPCS(hICC, cmsSigLabData); cmsSetPCS(hICC, cmsSigLabData);
// Tag profile with information // 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); Original = cmsGetNamedColorList(xform);
if (Original == NULL) goto Error; if (Original == NULL) goto Error;
@ -931,9 +953,14 @@ cmsHPROFILE CreateNamedColorDevicelink(cmsHTRANSFORM xform)
nc2 = cmsDupNamedColorList(Original); nc2 = cmsDupNamedColorList(Original);
if (nc2 == NULL) goto Error; 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); 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. // Apply the transfor to colorants.
for (i=0; i < nColors; i++) { for (i=0; i < nColors; i++) {
cmsDoTransform(xform, &i, nc2 ->List[i].DeviceColorant, 1); cmsDoTransform(xform, &i, nc2 ->List[i].DeviceColorant, 1);
@ -963,8 +990,9 @@ typedef struct {
static const cmsAllowedLUT AllowedLUTTypes[] = { 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, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType}},
{ FALSE, 0, cmsSigLut16Type, 2, { cmsSigCurveSetElemType, cmsSigCLutElemType}},
{ TRUE , 0, cmsSigLutAtoBType, 1, { cmsSigCurveSetElemType }}, { TRUE , 0, cmsSigLutAtoBType, 1, { cmsSigCurveSetElemType }},
{ TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType } }, { TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType } },
{ TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType } }, { TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType } },
@ -987,17 +1015,17 @@ cmsBool CheckOne(const cmsAllowedLUT* Tab, const cmsPipeline* Lut)
for (n=0, mpe = Lut ->Elements; mpe != NULL; mpe = mpe ->Next, n++) { for (n=0, mpe = Lut ->Elements; mpe != NULL; mpe = mpe ->Next, n++) {
if (n > Tab ->nTypes) return FALSE; 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); return (n == Tab ->nTypes);
} }
static static
const cmsAllowedLUT* FindCombination(const cmsPipeline* Lut, cmsBool IsV4, cmsTagSignature DestinationTag) const cmsAllowedLUT* FindCombination(const cmsPipeline* Lut, cmsBool IsV4, cmsTagSignature DestinationTag)
{ {
int n; cmsUInt32Number n;
for (n=0; n < SIZE_OF_ALLOWED_LUT; n++) { for (n=0; n < SIZE_OF_ALLOWED_LUT; n++) {
@ -1011,7 +1039,7 @@ const cmsAllowedLUT* FindCombination(const cmsPipeline* Lut, cmsBool IsV4, cmsTa
return NULL; return NULL;
} }
// Does convert a transform into a device link profile // Does convert a transform into a device link profile
cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat64Number Version, cmsUInt32Number dwFlags) cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat64Number Version, cmsUInt32Number dwFlags)
@ -1025,12 +1053,13 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
cmsContext ContextID = cmsGetTransformContextID(hTransform); cmsContext ContextID = cmsGetTransformContextID(hTransform);
const cmsAllowedLUT* AllowedLUT; const cmsAllowedLUT* AllowedLUT;
cmsTagSignature DestinationTag; cmsTagSignature DestinationTag;
cmsProfileClassSignature deviceClass;
_cmsAssert(hTransform != NULL); _cmsAssert(hTransform != NULL);
// Get the first mpe to check for named color // Get the first mpe to check for named color
mpe = cmsPipelineGetPtrToFirstStage(xform ->Lut); mpe = cmsPipelineGetPtrToFirstStage(xform ->Lut);
// Check if is a named color transform // Check if is a named color transform
if (mpe != NULL) { if (mpe != NULL) {
@ -1046,22 +1075,24 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
// Time to fix the Lab2/Lab4 issue. // Time to fix the Lab2/Lab4 issue.
if ((xform ->EntryColorSpace == cmsSigLabData) && (Version < 4.0)) { 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 // On the output side too
if ((xform ->ExitColorSpace) == cmsSigLabData && (Version < 4.0)) { 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); hProfile = cmsCreateProfilePlaceholder(ContextID);
if (!hProfile) goto Error; // can't allocate if (!hProfile) goto Error; // can't allocate
cmsSetProfileVersion(hProfile, Version); cmsSetProfileVersion(hProfile, Version);
FixColorSpaces(hProfile, xform -> EntryColorSpace, xform -> ExitColorSpace, dwFlags); FixColorSpaces(hProfile, xform -> EntryColorSpace, xform -> ExitColorSpace, dwFlags);
// Optimize the LUT and precalculate a devicelink // Optimize the LUT and precalculate a devicelink
@ -1074,8 +1105,9 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
FrmIn = COLORSPACE_SH(ColorSpaceBitsIn) | CHANNELS_SH(ChansIn)|BYTES_SH(2); FrmIn = COLORSPACE_SH(ColorSpaceBitsIn) | CHANNELS_SH(ChansIn)|BYTES_SH(2);
FrmOut = COLORSPACE_SH(ColorSpaceBitsOut) | CHANNELS_SH(ChansOut)|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; DestinationTag = cmsSigBToA0Tag;
else else
DestinationTag = cmsSigAToB0Tag; DestinationTag = cmsSigAToB0Tag;
@ -1084,12 +1116,12 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
if (dwFlags & cmsFLAGS_FORCE_CLUT) if (dwFlags & cmsFLAGS_FORCE_CLUT)
AllowedLUT = NULL; AllowedLUT = NULL;
else else
AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag); AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
if (AllowedLUT == NULL) { if (AllowedLUT == NULL) {
// Try to optimize // 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); AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
} }
@ -1098,14 +1130,16 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
if (AllowedLUT == NULL) { if (AllowedLUT == NULL) {
dwFlags |= cmsFLAGS_FORCE_CLUT; dwFlags |= cmsFLAGS_FORCE_CLUT;
_cmsOptimizePipeline(&LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags); _cmsOptimizePipeline(ContextID, &LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags);
// Put identity curves if needed // 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)); if (cmsPipelineGetPtrToLastStage(LUT) ->Type != cmsSigCurveSetElemType)
cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, ChansOut)); if (!cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, ChansOut)))
} goto Error;
AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag); AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag);
} }
@ -1116,16 +1150,16 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
} }
if (dwFlags & cmsFLAGS_8BITS_DEVICELINK) if (dwFlags & cmsFLAGS_8BITS_DEVICELINK)
cmsPipelineSetSaveAs8bitsFlag(LUT, TRUE); cmsPipelineSetSaveAs8bitsFlag(LUT, TRUE);
// Tag profile with information // Tag profile with information
if (!SetTextTags(hProfile, L"devicelink")) goto Error; if (!SetTextTags(hProfile, L"devicelink")) goto Error;
// Store result // Store result
if (!cmsWriteTag(hProfile, DestinationTag, LUT)) goto Error; if (!cmsWriteTag(hProfile, DestinationTag, LUT)) goto Error;
if (xform -> InputColorant != NULL) { if (xform -> InputColorant != NULL) {
if (!cmsWriteTag(hProfile, cmsSigColorantTableTag, xform->InputColorant)) goto Error; if (!cmsWriteTag(hProfile, cmsSigColorantTableTag, xform->InputColorant)) goto Error;
} }
@ -1133,16 +1167,28 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
if (xform -> OutputColorant != NULL) { if (xform -> OutputColorant != NULL) {
if (!cmsWriteTag(hProfile, cmsSigColorantTableOutTag, xform->OutputColorant)) goto Error; 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; 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; return hProfile;
Error: Error:
if (LUT != NULL) cmsPipelineFree(LUT); if (LUT != NULL) cmsPipelineFree(LUT);
cmsCloseProfile(hProfile); cmsCloseProfile(hProfile);
return NULL; return NULL;
} }

286
thirdparty/liblcms2/src/cmswtpnt.c vendored
View File

@ -1,24 +1,24 @@
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// //
// Little Color Management System // 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 // Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"), // a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // 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 // 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: // 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. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// //
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
@ -47,63 +47,63 @@ const cmsCIExyY* CMSEXPORT cmsD50_xyY(void)
// Obtains WhitePoint from Temperature // Obtains WhitePoint from Temperature
cmsBool CMSEXPORT cmsWhitePointFromTemp(cmsCIExyY* WhitePoint, cmsFloat64Number TempK) cmsBool CMSEXPORT cmsWhitePointFromTemp(cmsCIExyY* WhitePoint, cmsFloat64Number TempK)
{ {
cmsFloat64Number x, y; cmsFloat64Number x, y;
cmsFloat64Number T, T2, T3; cmsFloat64Number T, T2, T3;
// cmsFloat64Number M1, M2; // cmsFloat64Number M1, M2;
_cmsAssert(WhitePoint != NULL); _cmsAssert(WhitePoint != NULL);
T = TempK; T = TempK;
T2 = T*T; // Square T2 = T*T; // Square
T3 = T2*T; // Cube 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.) if (T >= 4000. && T <= 7000.)
{ {
x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063; x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
} }
else else
// or for correlated color temperature (T) between 7000K and 25000K: // or for correlated color temperature (T) between 7000K and 25000K:
if (T > 7000.0 && T <= 25000.0) if (T > 7000.0 && T <= 25000.0)
{ {
x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040; x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
} }
else { else {
cmsSignalError(0, cmsERROR_RANGE, "cmsWhitePointFromTemp: invalid temp"); cmsSignalError(0, cmsERROR_RANGE, "cmsWhitePointFromTemp: invalid temp");
return FALSE; 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); // 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); // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
WhitePoint -> x = x; WhitePoint -> x = x;
WhitePoint -> y = y; WhitePoint -> y = y;
WhitePoint -> Y = 1.0; WhitePoint -> Y = 1.0;
return TRUE; return TRUE;
} }
typedef struct { typedef struct {
cmsFloat64Number mirek; // temp (in microreciprocal kelvin) cmsFloat64Number mirek; // temp (in microreciprocal kelvin)
cmsFloat64Number ut; // u coord of intersection w/ blackbody locus cmsFloat64Number ut; // u coord of intersection w/ blackbody locus
cmsFloat64Number vt; // v coord of intersection w/ blackbody locus cmsFloat64Number vt; // v coord of intersection w/ blackbody locus
cmsFloat64Number tt; // slope of ISOTEMPERATURE. line cmsFloat64Number tt; // slope of ISOTEMPERATURE. line
} ISOTEMPERATURE; } ISOTEMPERATURE;
static ISOTEMPERATURE isotempdata[] = { static ISOTEMPERATURE isotempdata[] = {
// {Mirek, Ut, Vt, Tt } // {Mirek, Ut, Vt, Tt }
{0, 0.18006, 0.26352, -0.24341}, {0, 0.18006, 0.26352, -0.24341},
{10, 0.18066, 0.26589, -0.25479}, {10, 0.18066, 0.26589, -0.25479},
{20, 0.18133, 0.26846, -0.26876}, {20, 0.18133, 0.26846, -0.26876},
@ -143,50 +143,50 @@ static ISOTEMPERATURE isotempdata[] = {
// Robertson's method // Robertson's method
cmsBool CMSEXPORT cmsTempFromWhitePoint(cmsFloat64Number* TempK, const cmsCIExyY* WhitePoint) cmsBool CMSEXPORT cmsTempFromWhitePoint(cmsFloat64Number* TempK, const cmsCIExyY* WhitePoint)
{ {
int j; cmsUInt32Number j;
cmsFloat64Number us,vs; cmsFloat64Number us,vs;
cmsFloat64Number uj,vj,tj,di,dj,mi,mj; cmsFloat64Number uj,vj,tj,di,dj,mi,mj;
cmsFloat64Number xs, ys; cmsFloat64Number xs, ys;
_cmsAssert(WhitePoint != NULL); _cmsAssert(WhitePoint != NULL);
_cmsAssert(TempK != NULL); _cmsAssert(TempK != NULL);
di = mi = 0; di = mi = 0;
xs = WhitePoint -> x; xs = WhitePoint -> x;
ys = WhitePoint -> y; 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); us = (2*xs) / (-xs + 6*ys + 1.5);
vs = (3*ys) / (-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; uj = isotempdata[j].ut;
vj = isotempdata[j].vt; vj = isotempdata[j].vt;
tj = isotempdata[j].tt; tj = isotempdata[j].tt;
mj = isotempdata[j].mirek; 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 // Found a match
*TempK = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi)); *TempK = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
return TRUE; return TRUE;
} }
di = dj; di = dj;
mi = mj; mi = mj;
} }
// Not found // Not found
return FALSE; return FALSE;
} }
// Compute chromatic adaptation matrix using Chad as cone matrix // Compute chromatic adaptation matrix using Chad as cone matrix
static static
cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion, cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion,
@ -195,7 +195,7 @@ cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion,
const cmsMAT3* Chad) const cmsMAT3* Chad)
{ {
cmsMAT3 Chad_Inv; cmsMAT3 Chad_Inv;
cmsVEC3 ConeSourceXYZ, ConeSourceRGB; cmsVEC3 ConeSourceXYZ, ConeSourceRGB;
cmsVEC3 ConeDestXYZ, ConeDestRGB; cmsVEC3 ConeDestXYZ, ConeDestRGB;
@ -226,41 +226,41 @@ cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion,
_cmsMAT3per(&Tmp, &Cone, Chad); _cmsMAT3per(&Tmp, &Cone, Chad);
_cmsMAT3per(Conversion, &Chad_Inv, &Tmp); _cmsMAT3per(Conversion, &Chad_Inv, &Tmp);
return TRUE; return TRUE;
} }
// Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll // Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll
// The cone matrix can be specified in ConeMatrix. If NULL, Bradford is assumed // 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) cmsBool _cmsAdaptationMatrix(cmsMAT3* r, const cmsMAT3* ConeMatrix, const cmsCIEXYZ* FromIll, const cmsCIEXYZ* ToIll)
{ {
cmsMAT3 LamRigg = {{ // Bradford matrix cmsMAT3 LamRigg = {{ // Bradford matrix
{{ 0.8951, 0.2664, -0.1614 }}, {{ 0.8951, 0.2664, -0.1614 }},
{{ -0.7502, 1.7135, 0.0367 }}, {{ -0.7502, 1.7135, 0.0367 }},
{{ 0.0389, -0.0685, 1.0296 }} {{ 0.0389, -0.0685, 1.0296 }}
}}; }};
if (ConeMatrix == NULL) if (ConeMatrix == NULL)
ConeMatrix = &LamRigg; 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 // Same as anterior, but assuming D50 destination. White point is given in xyY
static static
cmsBool _cmsAdaptMatrixToD50(cmsMAT3* r, const cmsCIExyY* SourceWhitePt) cmsBool _cmsAdaptMatrixToD50(cmsMAT3* r, const cmsCIExyY* SourceWhitePt)
{ {
cmsCIEXYZ Dn; cmsCIEXYZ Dn;
cmsMAT3 Bradford; cmsMAT3 Bradford;
cmsMAT3 Tmp; 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; Tmp = *r;
_cmsMAT3per(r, &Bradford, &Tmp); _cmsMAT3per(r, &Bradford, &Tmp);
return TRUE; return TRUE;
} }
// Build a White point, primary chromas transfer matrix from RGB to CIE XYZ // Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
@ -278,74 +278,74 @@ cmsBool _cmsAdaptMatrixToD50(cmsMAT3* r, const cmsCIExyY* SourceWhitePt)
// //
cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3* r, const cmsCIExyY* WhitePt, const cmsCIExyYTRIPLE* Primrs) cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3* r, const cmsCIExyY* WhitePt, const cmsCIExyYTRIPLE* Primrs)
{ {
cmsVEC3 WhitePoint, Coef; cmsVEC3 WhitePoint, Coef;
cmsMAT3 Result, Primaries; cmsMAT3 Result, Primaries;
cmsFloat64Number xn, yn; cmsFloat64Number xn, yn;
cmsFloat64Number xr, yr; cmsFloat64Number xr, yr;
cmsFloat64Number xg, yg; cmsFloat64Number xg, yg;
cmsFloat64Number xb, yb; cmsFloat64Number xb, yb;
xn = WhitePt -> x; xn = WhitePt -> x;
yn = WhitePt -> y; yn = WhitePt -> y;
xr = Primrs -> Red.x; xr = Primrs -> Red.x;
yr = Primrs -> Red.y; yr = Primrs -> Red.y;
xg = Primrs -> Green.x; xg = Primrs -> Green.x;
yg = Primrs -> Green.y; yg = Primrs -> Green.y;
xb = Primrs -> Blue.x; xb = Primrs -> Blue.x;
yb = Primrs -> Blue.y; yb = Primrs -> Blue.y;
// Build Primaries matrix // Build Primaries matrix
_cmsVEC3init(&Primaries.v[0], xr, xg, xb); _cmsVEC3init(&Primaries.v[0], xr, xg, xb);
_cmsVEC3init(&Primaries.v[1], yr, yg, yb); _cmsVEC3init(&Primaries.v[1], yr, yg, yb);
_cmsVEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg), (1-xb-yb)); _cmsVEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg), (1-xb-yb));
// Result = Primaries ^ (-1) inverse matrix // Result = Primaries ^ (-1) inverse matrix
if (!_cmsMAT3inverse(&Primaries, &Result)) if (!_cmsMAT3inverse(&Primaries, &Result))
return FALSE; 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 ... // Across inverse primaries ...
_cmsMAT3eval(&Coef, &Result, &WhitePoint); _cmsMAT3eval(&Coef, &Result, &WhitePoint);
// Give us the Coefs, then I build transformation matrix // 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[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[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)); _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 // Adapts a color to a given illuminant. Original color is expected to have
// a SourceWhitePt white point. // a SourceWhitePt white point.
cmsBool CMSEXPORT cmsAdaptToIlluminant(cmsCIEXYZ* Result, cmsBool CMSEXPORT cmsAdaptToIlluminant(cmsCIEXYZ* Result,
const cmsCIEXYZ* SourceWhitePt, const cmsCIEXYZ* SourceWhitePt,
const cmsCIEXYZ* Illuminant, const cmsCIEXYZ* Illuminant,
const cmsCIEXYZ* Value) const cmsCIEXYZ* Value)
{ {
cmsMAT3 Bradford; cmsMAT3 Bradford;
cmsVEC3 In, Out; cmsVEC3 In, Out;
_cmsAssert(Result != NULL); _cmsAssert(Result != NULL);
_cmsAssert(SourceWhitePt != NULL); _cmsAssert(SourceWhitePt != NULL);
_cmsAssert(Illuminant != NULL); _cmsAssert(Illuminant != NULL);
_cmsAssert(Value != 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); _cmsVEC3init(&In, Value -> X, Value -> Y, Value -> Z);
_cmsMAT3eval(&Out, &Bradford, &In); _cmsMAT3eval(&Out, &Bradford, &In);
Result -> X = Out.n[0]; Result -> X = Out.n[0];
Result -> Y = Out.n[1]; Result -> Y = Out.n[1];
Result -> Z = Out.n[2]; Result -> Z = Out.n[2];
return TRUE; return TRUE;
} }

723
thirdparty/liblcms2/src/cmsxform.c vendored
View File

File diff suppressed because it is too large Load Diff

641
thirdparty/liblcms2/src/lcms2.def vendored
View File

@ -1,300 +1,341 @@
LIBRARY LCMS2.DLL LIBRARY LCMS2.DLL
EXPORTS EXPORTS
_cms15Fixed16toDouble = _cms15Fixed16toDouble _cms15Fixed16toDouble = _cms15Fixed16toDouble
_cms8Fixed8toDouble = _cms8Fixed8toDouble _cms8Fixed8toDouble = _cms8Fixed8toDouble
cmsAdaptToIlluminant = cmsAdaptToIlluminant cmsAdaptToIlluminant = cmsAdaptToIlluminant
_cmsAdjustEndianess16 = _cmsAdjustEndianess16 _cmsAdjustEndianess16 = _cmsAdjustEndianess16
_cmsAdjustEndianess32 = _cmsAdjustEndianess32 _cmsAdjustEndianess32 = _cmsAdjustEndianess32
_cmsAdjustEndianess64 = _cmsAdjustEndianess64 _cmsAdjustEndianess64 = _cmsAdjustEndianess64
cmsAllocNamedColorList = cmsAllocNamedColorList cmsAllocNamedColorList = cmsAllocNamedColorList
cmsAllocProfileSequenceDescription = cmsAllocProfileSequenceDescription cmsAllocProfileSequenceDescription = cmsAllocProfileSequenceDescription
cmsAppendNamedColor = cmsAppendNamedColor cmsAppendNamedColor = cmsAppendNamedColor
cmsBFDdeltaE = cmsBFDdeltaE cmsBFDdeltaE = cmsBFDdeltaE
cmsBuildGamma = cmsBuildGamma cmsBuildGamma = cmsBuildGamma
cmsBuildParametricToneCurve = cmsBuildParametricToneCurve cmsBuildParametricToneCurve = cmsBuildParametricToneCurve
cmsBuildSegmentedToneCurve = cmsBuildSegmentedToneCurve cmsBuildSegmentedToneCurve = cmsBuildSegmentedToneCurve
cmsBuildTabulatedToneCurve16 = cmsBuildTabulatedToneCurve16 cmsBuildTabulatedToneCurve16 = cmsBuildTabulatedToneCurve16
cmsBuildTabulatedToneCurveFloat = cmsBuildTabulatedToneCurveFloat cmsBuildTabulatedToneCurveFloat = cmsBuildTabulatedToneCurveFloat
_cmsCalloc = _cmsCalloc _cmsCalloc = _cmsCalloc
cmsChannelsOf = cmsChannelsOf cmsChannelsOf = cmsChannelsOf
cmsCIE2000DeltaE = cmsCIE2000DeltaE cmsCIE2000DeltaE = cmsCIE2000DeltaE
cmsCIE94DeltaE = cmsCIE94DeltaE cmsCIE94DeltaE = cmsCIE94DeltaE
cmsCIECAM02Done = cmsCIECAM02Done cmsCIECAM02Done = cmsCIECAM02Done
cmsCIECAM02Forward = cmsCIECAM02Forward cmsCIECAM02Forward = cmsCIECAM02Forward
cmsCIECAM02Init = cmsCIECAM02Init cmsCIECAM02Init = cmsCIECAM02Init
cmsCIECAM02Reverse = cmsCIECAM02Reverse cmsCIECAM02Reverse = cmsCIECAM02Reverse
cmsCloseIOhandler = cmsCloseIOhandler cmsCloseIOhandler = cmsCloseIOhandler
cmsCloseProfile = cmsCloseProfile cmsCloseProfile = cmsCloseProfile
cmsCMCdeltaE = cmsCMCdeltaE cmsCMCdeltaE = cmsCMCdeltaE
cmsCreate_sRGBProfile = cmsCreate_sRGBProfile cmsCreate_sRGBProfile = cmsCreate_sRGBProfile
cmsCreate_sRGBProfileTHR = cmsCreate_sRGBProfileTHR cmsCreate_sRGBProfileTHR = cmsCreate_sRGBProfileTHR
cmsCreateBCHSWabstractProfile = cmsCreateBCHSWabstractProfile cmsCreateBCHSWabstractProfile = cmsCreateBCHSWabstractProfile
cmsCreateBCHSWabstractProfileTHR = cmsCreateBCHSWabstractProfileTHR cmsCreateBCHSWabstractProfileTHR = cmsCreateBCHSWabstractProfileTHR
cmsCreateExtendedTransform = cmsCreateExtendedTransform cmsCreateExtendedTransform = cmsCreateExtendedTransform
cmsCreateGrayProfile = cmsCreateGrayProfile cmsCreateGrayProfile = cmsCreateGrayProfile
cmsCreateGrayProfileTHR = cmsCreateGrayProfileTHR cmsCreateGrayProfileTHR = cmsCreateGrayProfileTHR
cmsCreateInkLimitingDeviceLink = cmsCreateInkLimitingDeviceLink cmsCreateInkLimitingDeviceLink = cmsCreateInkLimitingDeviceLink
cmsCreateInkLimitingDeviceLinkTHR = cmsCreateInkLimitingDeviceLinkTHR cmsCreateInkLimitingDeviceLinkTHR = cmsCreateInkLimitingDeviceLinkTHR
cmsCreateLab2Profile = cmsCreateLab2Profile cmsCreateLab2Profile = cmsCreateLab2Profile
cmsCreateLab2ProfileTHR = cmsCreateLab2ProfileTHR cmsCreateLab2ProfileTHR = cmsCreateLab2ProfileTHR
cmsCreateLab4Profile = cmsCreateLab4Profile cmsCreateLab4Profile = cmsCreateLab4Profile
cmsCreateLab4ProfileTHR = cmsCreateLab4ProfileTHR cmsCreateLab4ProfileTHR = cmsCreateLab4ProfileTHR
cmsCreateLinearizationDeviceLink = cmsCreateLinearizationDeviceLink cmsCreateLinearizationDeviceLink = cmsCreateLinearizationDeviceLink
cmsCreateLinearizationDeviceLinkTHR = cmsCreateLinearizationDeviceLinkTHR cmsCreateLinearizationDeviceLinkTHR = cmsCreateLinearizationDeviceLinkTHR
cmsCreateMultiprofileTransform = cmsCreateMultiprofileTransform cmsCreateMultiprofileTransform = cmsCreateMultiprofileTransform
cmsCreateMultiprofileTransformTHR = cmsCreateMultiprofileTransformTHR cmsCreateMultiprofileTransformTHR = cmsCreateMultiprofileTransformTHR
cmsCreateNULLProfile = cmsCreateNULLProfile cmsCreateNULLProfile = cmsCreateNULLProfile
cmsCreateNULLProfileTHR = cmsCreateNULLProfileTHR cmsCreateNULLProfileTHR = cmsCreateNULLProfileTHR
cmsCreateProfilePlaceholder = cmsCreateProfilePlaceholder cmsCreateProfilePlaceholder = cmsCreateProfilePlaceholder
cmsCreateProofingTransform = cmsCreateProofingTransform cmsCreateProofingTransform = cmsCreateProofingTransform
cmsCreateProofingTransformTHR = cmsCreateProofingTransformTHR cmsCreateProofingTransformTHR = cmsCreateProofingTransformTHR
cmsCreateRGBProfile = cmsCreateRGBProfile cmsCreateRGBProfile = cmsCreateRGBProfile
cmsCreateRGBProfileTHR = cmsCreateRGBProfileTHR cmsCreateRGBProfileTHR = cmsCreateRGBProfileTHR
cmsCreateTransform = cmsCreateTransform cmsCreateTransform = cmsCreateTransform
cmsCreateTransformTHR = cmsCreateTransformTHR cmsCreateTransformTHR = cmsCreateTransformTHR
cmsCreateXYZProfile = cmsCreateXYZProfile cmsCreateXYZProfile = cmsCreateXYZProfile
cmsCreateXYZProfileTHR = cmsCreateXYZProfileTHR cmsCreateXYZProfileTHR = cmsCreateXYZProfileTHR
cmsD50_xyY = cmsD50_xyY cmsD50_xyY = cmsD50_xyY
cmsD50_XYZ = cmsD50_XYZ cmsD50_XYZ = cmsD50_XYZ
_cmsDecodeDateTimeNumber = _cmsDecodeDateTimeNumber _cmsDecodeDateTimeNumber = _cmsDecodeDateTimeNumber
_cmsDefaultICCintents = _cmsDefaultICCintents _cmsDefaultICCintents = _cmsDefaultICCintents
cmsDeleteTransform = cmsDeleteTransform cmsDeleteTransform = cmsDeleteTransform
cmsDeltaE = cmsDeltaE cmsDeltaE = cmsDeltaE
cmsDetectBlackPoint = cmsDetectBlackPoint cmsDetectBlackPoint = cmsDetectBlackPoint
cmsDetectTAC = cmsDetectTAC cmsDetectDestinationBlackPoint = cmsDetectDestinationBlackPoint
cmsDesaturateLab = cmsDesaturateLab cmsDetectTAC = cmsDetectTAC
cmsDoTransform = cmsDoTransform cmsDesaturateLab = cmsDesaturateLab
_cmsDoubleTo15Fixed16 = _cmsDoubleTo15Fixed16 cmsDoTransform = cmsDoTransform
_cmsDoubleTo8Fixed8 = _cmsDoubleTo8Fixed8 cmsDoTransformStride = cmsDoTransformStride
_cmsDupMem = _cmsDupMem _cmsDoubleTo15Fixed16 = _cmsDoubleTo15Fixed16
cmsDupNamedColorList = cmsDupNamedColorList _cmsDoubleTo8Fixed8 = _cmsDoubleTo8Fixed8
cmsDupProfileSequenceDescription = cmsDupProfileSequenceDescription _cmsDupMem = _cmsDupMem
cmsDupToneCurve = cmsDupToneCurve cmsDupNamedColorList = cmsDupNamedColorList
_cmsEncodeDateTimeNumber = _cmsEncodeDateTimeNumber cmsDupProfileSequenceDescription = cmsDupProfileSequenceDescription
cmsEstimateGamma = cmsEstimateGamma cmsDupToneCurve = cmsDupToneCurve
cmsEvalToneCurve16 = cmsEvalToneCurve16 _cmsEncodeDateTimeNumber = _cmsEncodeDateTimeNumber
cmsEvalToneCurveFloat = cmsEvalToneCurveFloat cmsEstimateGamma = cmsEstimateGamma
cmsfilelength = cmsfilelength cmsGetToneCurveEstimatedTableEntries = cmsGetToneCurveEstimatedTableEntries
cmsFloat2LabEncoded = cmsFloat2LabEncoded cmsGetToneCurveEstimatedTable = cmsGetToneCurveEstimatedTable
cmsFloat2LabEncodedV2 = cmsFloat2LabEncodedV2 cmsEvalToneCurve16 = cmsEvalToneCurve16
cmsFloat2XYZEncoded = cmsFloat2XYZEncoded cmsEvalToneCurveFloat = cmsEvalToneCurveFloat
cmsFormatterForColorspaceOfProfile = cmsFormatterForColorspaceOfProfile cmsfilelength = cmsfilelength
cmsFormatterForPCSOfProfile = cmsFormatterForPCSOfProfile cmsFloat2LabEncoded = cmsFloat2LabEncoded
_cmsFree = _cmsFree cmsFloat2LabEncodedV2 = cmsFloat2LabEncodedV2
cmsFreeNamedColorList = cmsFreeNamedColorList cmsFloat2XYZEncoded = cmsFloat2XYZEncoded
cmsFreeProfileSequenceDescription = cmsFreeProfileSequenceDescription cmsFormatterForColorspaceOfProfile = cmsFormatterForColorspaceOfProfile
cmsFreeToneCurve = cmsFreeToneCurve cmsFormatterForPCSOfProfile = cmsFormatterForPCSOfProfile
cmsFreeToneCurveTriple = cmsFreeToneCurveTriple _cmsFree = _cmsFree
cmsGBDAlloc = cmsGBDAlloc cmsFreeNamedColorList = cmsFreeNamedColorList
cmsGBDFree = cmsGBDFree cmsFreeProfileSequenceDescription = cmsFreeProfileSequenceDescription
cmsGDBAddPoint = cmsGDBAddPoint cmsFreeToneCurve = cmsFreeToneCurve
cmsGDBCheckPoint = cmsGDBCheckPoint cmsFreeToneCurveTriple = cmsFreeToneCurveTriple
cmsGDBCompute = cmsGDBCompute cmsGBDAlloc = cmsGBDAlloc
cmsGetAlarmCodes = cmsGetAlarmCodes cmsGBDFree = cmsGBDFree
cmsGetColorSpace = cmsGetColorSpace cmsGDBAddPoint = cmsGDBAddPoint
cmsGetDeviceClass = cmsGetDeviceClass cmsGDBCheckPoint = cmsGDBCheckPoint
cmsGetEncodedICCversion = cmsGetEncodedICCversion cmsGDBCompute = cmsGDBCompute
cmsGetHeaderAttributes = cmsGetHeaderAttributes cmsGetAlarmCodes = cmsGetAlarmCodes
cmsGetHeaderCreationDateTime = cmsGetHeaderCreationDateTime cmsGetColorSpace = cmsGetColorSpace
cmsGetHeaderFlags = cmsGetHeaderFlags cmsGetDeviceClass = cmsGetDeviceClass
cmsGetHeaderManufacturer = cmsGetHeaderManufacturer cmsGetEncodedICCversion = cmsGetEncodedICCversion
cmsGetHeaderModel = cmsGetHeaderModel cmsGetHeaderAttributes = cmsGetHeaderAttributes
cmsGetHeaderProfileID = cmsGetHeaderProfileID cmsGetHeaderCreationDateTime = cmsGetHeaderCreationDateTime
cmsGetHeaderRenderingIntent = cmsGetHeaderRenderingIntent cmsGetHeaderFlags = cmsGetHeaderFlags
cmsGetNamedColorList = cmsGetNamedColorList cmsGetHeaderManufacturer = cmsGetHeaderManufacturer
cmsGetPCS = cmsGetPCS cmsGetHeaderModel = cmsGetHeaderModel
cmsGetPostScriptColorResource = cmsGetPostScriptColorResource cmsGetHeaderProfileID = cmsGetHeaderProfileID
cmsGetPostScriptCRD = cmsGetPostScriptCRD cmsGetHeaderRenderingIntent = cmsGetHeaderRenderingIntent
cmsGetPostScriptCSA = cmsGetPostScriptCSA cmsGetNamedColorList = cmsGetNamedColorList
cmsGetProfileInfo = cmsGetProfileInfo cmsGetPCS = cmsGetPCS
cmsGetProfileInfoASCII = cmsGetProfileInfoASCII cmsGetPostScriptColorResource = cmsGetPostScriptColorResource
cmsGetProfileContextID = cmsGetProfileContextID cmsGetPostScriptCRD = cmsGetPostScriptCRD
cmsGetProfileVersion = cmsGetProfileVersion cmsGetPostScriptCSA = cmsGetPostScriptCSA
cmsGetSupportedIntents = cmsGetSupportedIntents cmsGetProfileInfo = cmsGetProfileInfo
cmsGetTagCount = cmsGetTagCount cmsGetProfileInfoASCII = cmsGetProfileInfoASCII
cmsGetTagSignature = cmsGetTagSignature cmsGetProfileContextID = cmsGetProfileContextID
cmsGetTransformContextID = cmsGetTransformContextID cmsGetProfileVersion = cmsGetProfileVersion
_cmsICCcolorSpace = _cmsICCcolorSpace cmsGetSupportedIntents = cmsGetSupportedIntents
_cmsIOPrintf = _cmsIOPrintf cmsGetTagCount = cmsGetTagCount
cmsIsCLUT = cmsIsCLUT cmsGetTagSignature = cmsGetTagSignature
cmsIsIntentSupported = cmsIsIntentSupported cmsGetTransformContextID = cmsGetTransformContextID
cmsIsMatrixShaper = cmsIsMatrixShaper _cmsICCcolorSpace = _cmsICCcolorSpace
cmsIsTag = cmsIsTag _cmsIOPrintf = _cmsIOPrintf
cmsIsToneCurveDescending = cmsIsToneCurveDescending cmsIsCLUT = cmsIsCLUT
cmsIsToneCurveLinear = cmsIsToneCurveLinear cmsIsIntentSupported = cmsIsIntentSupported
cmsIsToneCurveMonotonic = cmsIsToneCurveMonotonic cmsIsMatrixShaper = cmsIsMatrixShaper
cmsIsToneCurveMultisegment = cmsIsToneCurveMultisegment cmsIsTag = cmsIsTag
cmsGetToneCurveParametricType = cmsGetToneCurveParametricType cmsIsToneCurveDescending = cmsIsToneCurveDescending
cmsIT8Alloc = cmsIT8Alloc cmsIsToneCurveLinear = cmsIsToneCurveLinear
cmsIT8DefineDblFormat = cmsIT8DefineDblFormat cmsIsToneCurveMonotonic = cmsIsToneCurveMonotonic
cmsIT8EnumDataFormat = cmsIT8EnumDataFormat cmsIsToneCurveMultisegment = cmsIsToneCurveMultisegment
cmsIT8EnumProperties = cmsIT8EnumProperties cmsGetToneCurveParametricType = cmsGetToneCurveParametricType
cmsIT8Free = cmsIT8Free cmsIT8Alloc = cmsIT8Alloc
cmsIT8GetData = cmsIT8GetData cmsIT8DefineDblFormat = cmsIT8DefineDblFormat
cmsIT8GetDataDbl = cmsIT8GetDataDbl cmsIT8EnumDataFormat = cmsIT8EnumDataFormat
cmsIT8FindDataFormat = cmsIT8FindDataFormat cmsIT8EnumProperties = cmsIT8EnumProperties
cmsIT8GetDataRowCol = cmsIT8GetDataRowCol cmsIT8EnumPropertyMulti = cmsIT8EnumPropertyMulti
cmsIT8GetDataRowColDbl = cmsIT8GetDataRowColDbl cmsIT8Free = cmsIT8Free
cmsIT8GetPatchName = cmsIT8GetPatchName cmsIT8GetData = cmsIT8GetData
cmsIT8GetProperty = cmsIT8GetProperty cmsIT8GetDataDbl = cmsIT8GetDataDbl
cmsIT8GetPropertyDbl = cmsIT8GetPropertyDbl cmsIT8FindDataFormat = cmsIT8FindDataFormat
cmsIT8GetSheetType = cmsIT8GetSheetType cmsIT8GetDataRowCol = cmsIT8GetDataRowCol
cmsIT8LoadFromFile = cmsIT8LoadFromFile cmsIT8GetDataRowColDbl = cmsIT8GetDataRowColDbl
cmsIT8LoadFromMem = cmsIT8LoadFromMem cmsIT8GetPatchName = cmsIT8GetPatchName
cmsIT8SaveToFile = cmsIT8SaveToFile cmsIT8GetPatchByName = cmsIT8GetPatchByName
cmsIT8SaveToMem = cmsIT8SaveToMem cmsIT8GetProperty = cmsIT8GetProperty
cmsIT8SetComment = cmsIT8SetComment cmsIT8GetPropertyDbl = cmsIT8GetPropertyDbl
cmsIT8SetData = cmsIT8SetData cmsIT8GetPropertyMulti = cmsIT8GetPropertyMulti
cmsIT8SetDataDbl = cmsIT8SetDataDbl cmsIT8GetSheetType = cmsIT8GetSheetType
cmsIT8SetDataFormat = cmsIT8SetDataFormat cmsIT8LoadFromFile = cmsIT8LoadFromFile
cmsIT8SetDataRowCol = cmsIT8SetDataRowCol cmsIT8LoadFromMem = cmsIT8LoadFromMem
cmsIT8SetDataRowColDbl = cmsIT8SetDataRowColDbl cmsIT8SaveToFile = cmsIT8SaveToFile
cmsIT8SetPropertyDbl = cmsIT8SetPropertyDbl cmsIT8SaveToMem = cmsIT8SaveToMem
cmsIT8SetPropertyHex = cmsIT8SetPropertyHex cmsIT8SetComment = cmsIT8SetComment
cmsIT8SetPropertyStr = cmsIT8SetPropertyStr cmsIT8SetData = cmsIT8SetData
cmsIT8SetPropertyUncooked = cmsIT8SetPropertyUncooked cmsIT8SetDataDbl = cmsIT8SetDataDbl
cmsIT8SetSheetType = cmsIT8SetSheetType cmsIT8SetDataFormat = cmsIT8SetDataFormat
cmsIT8SetTable = cmsIT8SetTable cmsIT8SetDataRowCol = cmsIT8SetDataRowCol
cmsIT8SetTableByLabel = cmsIT8SetTableByLabel cmsIT8SetDataRowColDbl = cmsIT8SetDataRowColDbl
cmsIT8TableCount = cmsIT8TableCount cmsIT8SetPropertyDbl = cmsIT8SetPropertyDbl
cmsJoinToneCurve = cmsJoinToneCurve cmsIT8SetPropertyHex = cmsIT8SetPropertyHex
cmsLab2LCh = cmsLab2LCh cmsIT8SetPropertyStr = cmsIT8SetPropertyStr
cmsLab2XYZ = cmsLab2XYZ cmsIT8SetPropertyMulti = cmsIT8SetPropertyMulti
cmsLabEncoded2Float = cmsLabEncoded2Float cmsIT8SetPropertyUncooked = cmsIT8SetPropertyUncooked
cmsLabEncoded2FloatV2 = cmsLabEncoded2FloatV2 cmsIT8SetSheetType = cmsIT8SetSheetType
cmsLCh2Lab = cmsLCh2Lab cmsIT8SetTable = cmsIT8SetTable
_cmsLCMScolorSpace = _cmsLCMScolorSpace cmsIT8SetTableByLabel = cmsIT8SetTableByLabel
cmsLinkTag = cmsLinkTag cmsIT8SetIndexColumn = cmsIT8SetIndexColumn
cmsPipelineAlloc = cmsPipelineAlloc cmsIT8TableCount = cmsIT8TableCount
cmsPipelineCat = cmsPipelineCat cmsJoinToneCurve = cmsJoinToneCurve
cmsPipelineCheckAndRetreiveStages = cmsPipelineCheckAndRetreiveStages cmsLab2LCh = cmsLab2LCh
cmsPipelineDup = cmsPipelineDup cmsLab2XYZ = cmsLab2XYZ
cmsPipelineStageCount = cmsPipelineStageCount cmsLabEncoded2Float = cmsLabEncoded2Float
cmsPipelineEval16 = cmsPipelineEval16 cmsLabEncoded2FloatV2 = cmsLabEncoded2FloatV2
cmsPipelineEvalFloat = cmsPipelineEvalFloat cmsLCh2Lab = cmsLCh2Lab
cmsPipelineEvalReverseFloat = cmsPipelineEvalReverseFloat _cmsLCMScolorSpace = _cmsLCMScolorSpace
cmsPipelineFree = cmsPipelineFree cmsLinkTag = cmsLinkTag
cmsPipelineGetPtrToFirstStage = cmsPipelineGetPtrToFirstStage cmsTagLinkedTo = cmsTagLinkedTo
cmsPipelineGetPtrToLastStage = cmsPipelineGetPtrToLastStage cmsPipelineAlloc = cmsPipelineAlloc
cmsPipelineInputChannels = cmsPipelineInputChannels cmsPipelineCat = cmsPipelineCat
cmsPipelineInsertStage = cmsPipelineInsertStage cmsPipelineCheckAndRetreiveStages = cmsPipelineCheckAndRetreiveStages
cmsPipelineOutputChannels = cmsPipelineOutputChannels cmsPipelineDup = cmsPipelineDup
cmsPipelineSetSaveAs8bitsFlag = cmsPipelineSetSaveAs8bitsFlag cmsPipelineStageCount = cmsPipelineStageCount
_cmsPipelineSetOptimizationParameters = _cmsPipelineSetOptimizationParameters cmsPipelineEval16 = cmsPipelineEval16
cmsPipelineUnlinkStage = cmsPipelineUnlinkStage cmsPipelineEvalFloat = cmsPipelineEvalFloat
_cmsMalloc = _cmsMalloc cmsPipelineEvalReverseFloat = cmsPipelineEvalReverseFloat
_cmsMallocZero = _cmsMallocZero cmsPipelineFree = cmsPipelineFree
_cmsMAT3eval = _cmsMAT3eval cmsPipelineGetPtrToFirstStage = cmsPipelineGetPtrToFirstStage
_cmsMAT3identity = _cmsMAT3identity cmsPipelineGetPtrToLastStage = cmsPipelineGetPtrToLastStage
_cmsMAT3inverse = _cmsMAT3inverse cmsPipelineInputChannels = cmsPipelineInputChannels
_cmsMAT3isIdentity = _cmsMAT3isIdentity cmsPipelineInsertStage = cmsPipelineInsertStage
_cmsMAT3per = _cmsMAT3per cmsPipelineOutputChannels = cmsPipelineOutputChannels
_cmsMAT3solve = _cmsMAT3solve cmsPipelineSetSaveAs8bitsFlag = cmsPipelineSetSaveAs8bitsFlag
cmsMD5computeID = cmsMD5computeID _cmsPipelineSetOptimizationParameters = _cmsPipelineSetOptimizationParameters
cmsMLUalloc = cmsMLUalloc cmsPipelineUnlinkStage = cmsPipelineUnlinkStage
cmsMLUdup = cmsMLUdup _cmsMalloc = _cmsMalloc
cmsMLUfree = cmsMLUfree _cmsMallocZero = _cmsMallocZero
cmsMLUgetASCII = cmsMLUgetASCII _cmsMAT3eval = _cmsMAT3eval
cmsMLUgetTranslation = cmsMLUgetTranslation _cmsMAT3identity = _cmsMAT3identity
cmsMLUgetWide = cmsMLUgetWide _cmsMAT3inverse = _cmsMAT3inverse
cmsMLUsetASCII = cmsMLUsetASCII _cmsMAT3isIdentity = _cmsMAT3isIdentity
cmsMLUsetWide = cmsMLUsetWide _cmsMAT3per = _cmsMAT3per
cmsStageAllocCLut16bit = cmsStageAllocCLut16bit _cmsMAT3solve = _cmsMAT3solve
cmsStageAllocCLut16bitGranular = cmsStageAllocCLut16bitGranular cmsMD5computeID = cmsMD5computeID
cmsStageAllocCLutFloat = cmsStageAllocCLutFloat cmsMLUalloc = cmsMLUalloc
cmsStageAllocCLutFloatGranular = cmsStageAllocCLutFloatGranular cmsMLUdup = cmsMLUdup
cmsStageAllocToneCurves = cmsStageAllocToneCurves cmsMLUfree = cmsMLUfree
cmsStageAllocIdentity = cmsStageAllocIdentity cmsMLUgetASCII = cmsMLUgetASCII
cmsStageAllocMatrix = cmsStageAllocMatrix cmsMLUgetTranslation = cmsMLUgetTranslation
_cmsStageAllocPlaceholder = _cmsStageAllocPlaceholder cmsMLUgetWide = cmsMLUgetWide
cmsStageDup = cmsStageDup cmsMLUsetASCII = cmsMLUsetASCII
cmsStageFree = cmsStageFree cmsMLUsetWide = cmsMLUsetWide
cmsStageNext = cmsStageNext cmsStageAllocCLut16bit = cmsStageAllocCLut16bit
cmsStageInputChannels = cmsStageInputChannels cmsStageAllocCLut16bitGranular = cmsStageAllocCLut16bitGranular
cmsStageOutputChannels = cmsStageOutputChannels cmsStageAllocCLutFloat = cmsStageAllocCLutFloat
cmsStageSampleCLut16bit = cmsStageSampleCLut16bit cmsStageAllocCLutFloatGranular = cmsStageAllocCLutFloatGranular
cmsStageSampleCLutFloat = cmsStageSampleCLutFloat cmsStageAllocToneCurves = cmsStageAllocToneCurves
cmsStageType = cmsStageType cmsStageAllocIdentity = cmsStageAllocIdentity
cmsStageData = cmsStageData cmsStageAllocMatrix = cmsStageAllocMatrix
cmsNamedColorCount = cmsNamedColorCount _cmsStageAllocPlaceholder = _cmsStageAllocPlaceholder
cmsNamedColorIndex = cmsNamedColorIndex cmsStageDup = cmsStageDup
cmsNamedColorInfo = cmsNamedColorInfo cmsStageFree = cmsStageFree
cmsOpenIOhandlerFromFile = cmsOpenIOhandlerFromFile cmsStageNext = cmsStageNext
cmsOpenIOhandlerFromMem = cmsOpenIOhandlerFromMem cmsStageInputChannels = cmsStageInputChannels
cmsOpenIOhandlerFromNULL = cmsOpenIOhandlerFromNULL cmsStageOutputChannels = cmsStageOutputChannels
cmsOpenIOhandlerFromStream = cmsOpenIOhandlerFromStream cmsStageSampleCLut16bit = cmsStageSampleCLut16bit
cmsOpenProfileFromFile = cmsOpenProfileFromFile cmsStageSampleCLutFloat = cmsStageSampleCLutFloat
cmsOpenProfileFromFileTHR = cmsOpenProfileFromFileTHR cmsStageType = cmsStageType
cmsOpenProfileFromIOhandlerTHR = cmsOpenProfileFromIOhandlerTHR cmsStageData = cmsStageData
cmsOpenProfileFromMem = cmsOpenProfileFromMem cmsNamedColorCount = cmsNamedColorCount
cmsOpenProfileFromMemTHR = cmsOpenProfileFromMemTHR cmsNamedColorIndex = cmsNamedColorIndex
cmsOpenProfileFromStream = cmsOpenProfileFromStream cmsNamedColorInfo = cmsNamedColorInfo
cmsOpenProfileFromStreamTHR = cmsOpenProfileFromStreamTHR cmsOpenIOhandlerFromFile = cmsOpenIOhandlerFromFile
cmsPlugin = cmsPlugin cmsOpenIOhandlerFromMem = cmsOpenIOhandlerFromMem
_cmsRead15Fixed16Number = _cmsRead15Fixed16Number cmsOpenIOhandlerFromNULL = cmsOpenIOhandlerFromNULL
_cmsReadAlignment = _cmsReadAlignment cmsOpenIOhandlerFromStream = cmsOpenIOhandlerFromStream
_cmsReadFloat32Number = _cmsReadFloat32Number cmsOpenProfileFromFile = cmsOpenProfileFromFile
cmsReadRawTag = cmsReadRawTag cmsOpenProfileFromFileTHR = cmsOpenProfileFromFileTHR
cmsReadTag = cmsReadTag cmsOpenProfileFromIOhandlerTHR = cmsOpenProfileFromIOhandlerTHR
_cmsReadTypeBase = _cmsReadTypeBase cmsOpenProfileFromMem = cmsOpenProfileFromMem
_cmsReadUInt16Array = _cmsReadUInt16Array cmsOpenProfileFromMemTHR = cmsOpenProfileFromMemTHR
_cmsReadUInt16Number = _cmsReadUInt16Number cmsOpenProfileFromStream = cmsOpenProfileFromStream
_cmsReadUInt32Number = _cmsReadUInt32Number cmsOpenProfileFromStreamTHR = cmsOpenProfileFromStreamTHR
_cmsReadUInt64Number = _cmsReadUInt64Number cmsPlugin = cmsPlugin
_cmsReadUInt8Number = _cmsReadUInt8Number _cmsRead15Fixed16Number = _cmsRead15Fixed16Number
_cmsReadXYZNumber = _cmsReadXYZNumber _cmsReadAlignment = _cmsReadAlignment
_cmsRealloc = _cmsRealloc _cmsReadFloat32Number = _cmsReadFloat32Number
cmsReverseToneCurve = cmsReverseToneCurve cmsReadRawTag = cmsReadRawTag
cmsReverseToneCurveEx = cmsReverseToneCurveEx cmsReadTag = cmsReadTag
cmsSaveProfileToFile = cmsSaveProfileToFile _cmsReadTypeBase = _cmsReadTypeBase
cmsSaveProfileToIOhandler = cmsSaveProfileToIOhandler _cmsReadUInt16Array = _cmsReadUInt16Array
cmsSaveProfileToMem = cmsSaveProfileToMem _cmsReadUInt16Number = _cmsReadUInt16Number
cmsSaveProfileToStream = cmsSaveProfileToStream _cmsReadUInt32Number = _cmsReadUInt32Number
cmsSetAdaptationState = cmsSetAdaptationState _cmsReadUInt64Number = _cmsReadUInt64Number
cmsSetAlarmCodes = cmsSetAlarmCodes _cmsReadUInt8Number = _cmsReadUInt8Number
cmsSetColorSpace = cmsSetColorSpace _cmsReadXYZNumber = _cmsReadXYZNumber
cmsSetDeviceClass = cmsSetDeviceClass _cmsRealloc = _cmsRealloc
cmsSetEncodedICCversion = cmsSetEncodedICCversion cmsReverseToneCurve = cmsReverseToneCurve
cmsSetHeaderAttributes = cmsSetHeaderAttributes cmsReverseToneCurveEx = cmsReverseToneCurveEx
cmsSetHeaderFlags = cmsSetHeaderFlags cmsSaveProfileToFile = cmsSaveProfileToFile
cmsSetHeaderManufacturer = cmsSetHeaderManufacturer cmsSaveProfileToIOhandler = cmsSaveProfileToIOhandler
cmsSetHeaderModel = cmsSetHeaderModel cmsSaveProfileToMem = cmsSaveProfileToMem
cmsSetHeaderProfileID = cmsSetHeaderProfileID cmsSaveProfileToStream = cmsSaveProfileToStream
cmsSetHeaderRenderingIntent = cmsSetHeaderRenderingIntent cmsSetAdaptationState = cmsSetAdaptationState
cmsSetLogErrorHandler = cmsSetLogErrorHandler cmsSetAlarmCodes = cmsSetAlarmCodes
cmsSetPCS = cmsSetPCS cmsSetColorSpace = cmsSetColorSpace
cmsSetProfileVersion = cmsSetProfileVersion cmsSetDeviceClass = cmsSetDeviceClass
cmsSignalError = cmsSignalError cmsSetEncodedICCversion = cmsSetEncodedICCversion
cmsSmoothToneCurve = cmsSmoothToneCurve cmsSetHeaderAttributes = cmsSetHeaderAttributes
cmsstrcasecmp = cmsstrcasecmp cmsSetHeaderFlags = cmsSetHeaderFlags
cmsTempFromWhitePoint = cmsTempFromWhitePoint cmsSetHeaderManufacturer = cmsSetHeaderManufacturer
cmsTransform2DeviceLink = cmsTransform2DeviceLink cmsSetHeaderModel = cmsSetHeaderModel
cmsUnregisterPlugins = cmsUnregisterPlugins cmsSetHeaderProfileID = cmsSetHeaderProfileID
_cmsVEC3cross = _cmsVEC3cross cmsSetHeaderRenderingIntent = cmsSetHeaderRenderingIntent
_cmsVEC3distance = _cmsVEC3distance cmsSetLogErrorHandler = cmsSetLogErrorHandler
_cmsVEC3dot = _cmsVEC3dot cmsSetPCS = cmsSetPCS
_cmsVEC3init = _cmsVEC3init cmsSetProfileVersion = cmsSetProfileVersion
_cmsVEC3length = _cmsVEC3length cmsSignalError = cmsSignalError
_cmsVEC3minus = _cmsVEC3minus cmsSmoothToneCurve = cmsSmoothToneCurve
cmsWhitePointFromTemp = cmsWhitePointFromTemp cmsstrcasecmp = cmsstrcasecmp
_cmsWrite15Fixed16Number = _cmsWrite15Fixed16Number cmsTempFromWhitePoint = cmsTempFromWhitePoint
_cmsWriteAlignment = _cmsWriteAlignment cmsTransform2DeviceLink = cmsTransform2DeviceLink
_cmsWriteFloat32Number = _cmsWriteFloat32Number cmsUnregisterPlugins = cmsUnregisterPlugins
cmsWriteRawTag = cmsWriteRawTag _cmsVEC3cross = _cmsVEC3cross
cmsWriteTag = cmsWriteTag _cmsVEC3distance = _cmsVEC3distance
_cmsWriteTypeBase = _cmsWriteTypeBase _cmsVEC3dot = _cmsVEC3dot
_cmsWriteUInt16Array = _cmsWriteUInt16Array _cmsVEC3init = _cmsVEC3init
_cmsWriteUInt16Number = _cmsWriteUInt16Number _cmsVEC3length = _cmsVEC3length
_cmsWriteUInt32Number = _cmsWriteUInt32Number _cmsVEC3minus = _cmsVEC3minus
_cmsWriteUInt64Number = _cmsWriteUInt64Number cmsWhitePointFromTemp = cmsWhitePointFromTemp
_cmsWriteUInt8Number = _cmsWriteUInt8Number _cmsWrite15Fixed16Number = _cmsWrite15Fixed16Number
_cmsWriteXYZNumber = _cmsWriteXYZNumber _cmsWriteAlignment = _cmsWriteAlignment
cmsxyY2XYZ = cmsxyY2XYZ _cmsWriteFloat32Number = _cmsWriteFloat32Number
cmsXYZ2Lab = cmsXYZ2Lab cmsWriteRawTag = cmsWriteRawTag
cmsXYZ2xyY = cmsXYZ2xyY cmsWriteTag = cmsWriteTag
cmsXYZEncoded2Float = cmsXYZEncoded2Float _cmsWriteTypeBase = _cmsWriteTypeBase
cmsSliceSpace16 = cmsSliceSpace16 _cmsWriteUInt16Array = _cmsWriteUInt16Array
cmsSliceSpaceFloat = cmsSliceSpaceFloat _cmsWriteUInt16Number = _cmsWriteUInt16Number
cmsChangeBuffersFormat = cmsChangeBuffersFormat _cmsWriteUInt32Number = _cmsWriteUInt32Number
_cmsWriteUInt64Number = _cmsWriteUInt64Number
_cmsWriteUInt8Number = _cmsWriteUInt8Number
_cmsWriteXYZNumber = _cmsWriteXYZNumber
cmsxyY2XYZ = cmsxyY2XYZ
cmsXYZ2Lab = cmsXYZ2Lab
cmsXYZ2xyY = cmsXYZ2xyY
cmsXYZEncoded2Float = cmsXYZEncoded2Float
cmsSliceSpace16 = cmsSliceSpace16
cmsSliceSpaceFloat = cmsSliceSpaceFloat
cmsChangeBuffersFormat = cmsChangeBuffersFormat
cmsDictAlloc = cmsDictAlloc
cmsDictFree = cmsDictFree
cmsDictDup = cmsDictDup
cmsDictAddEntry = cmsDictAddEntry
cmsDictGetEntryList = cmsDictGetEntryList
cmsDictNextEntry = cmsDictNextEntry
_cmsGetTransformUserData = _cmsGetTransformUserData
_cmsSetTransformUserData = _cmsSetTransformUserData
_cmsGetTransformFormatters16 = _cmsGetTransformFormatters16
_cmsGetTransformFormattersFloat = _cmsGetTransformFormattersFloat
cmsGetHeaderCreator = cmsGetHeaderCreator
cmsPluginTHR = cmsPluginTHR
cmsGetPipelineContextID = cmsGetPipelineContextID
cmsGetTransformInputFormat = cmsGetTransformInputFormat
cmsGetTransformOutputFormat = cmsGetTransformOutputFormat
cmsCreateContext = cmsCreateContext
cmsDupContext = cmsDupContext
cmsDeleteContext = cmsDeleteContext
cmsGetContextUserData = cmsGetContextUserData
cmsUnregisterPluginsTHR = cmsUnregisterPluginsTHR
cmsSetAlarmCodesTHR = cmsSetAlarmCodesTHR
cmsGetAlarmCodesTHR = cmsGetAlarmCodesTHR
cmsSetAdaptationStateTHR = cmsSetAdaptationStateTHR
cmsSetLogErrorHandlerTHR = cmsSetLogErrorHandlerTHR
cmsGetSupportedIntentsTHR = cmsGetSupportedIntentsTHR
cmsMLUtranslationsCount = cmsMLUtranslationsCount
cmsMLUtranslationsCodes = cmsMLUtranslationsCodes
_cmsCreateMutex = _cmsCreateMutex
_cmsDestroyMutex = _cmsDestroyMutex
_cmsLockMutex = _cmsLockMutex
_cmsUnlockMutex = _cmsUnlockMutex

725
thirdparty/liblcms2/src/lcms2_internal.h vendored
View File

File diff suppressed because it is too large Load Diff