//--------------------------------------------------------------------------------- // // Little Color Management System // Copyright (c) 1998-2023 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" // Tag Serialization ----------------------------------------------------------------------------- // This file implements every single tag and tag type as described in the ICC spec. Some types // have been deprecated, like ncl and Data. There is no implementation for those types as there // are no profiles holding them. The programmer can also extend this list by defining his own types // by using the appropriate plug-in. There are three types of plug ins regarding that. First type // allows to define new tags using any existing type. Next plug-in type allows to define new types // and the third one is very specific: allows to extend the number of elements in the multiprocessing // elements special type. //-------------------------------------------------------------------------------------------------- // Some broken types #define cmsCorbisBrokenXYZtype … #define cmsMonacoBrokenCurveType … // This is the linked list that keeps track of the defined types _cmsTagTypeLinkedList; // Some macros to define callbacks. #define READ_FN(x) … #define WRITE_FN(x) … #define FREE_FN(x) … #define DUP_FN(x) … // Helper macro to define a handler. Callbacks do have a fixed naming convention. #define TYPE_HANDLER(t, x) … // Helper macro to define a MPE handler. Callbacks do have a fixed naming convention #define TYPE_MPE_HANDLER(t, x) … // Infinites #define MINUS_INF … #define PLUS_INF … // Register a new type handler. This routine is shared between normal types and MPE. LinkedList points to the optional list head static cmsBool RegisterTypesPlugin(cmsContext id, cmsPluginBase* Data, _cmsMemoryClient pos) { … } // Return handler for a given type or NULL if not found. Shared between normal types and MPE. It first tries the additons // made by plug-ins and then the built-in defaults. static cmsTagTypeHandler* GetHandler(cmsTagTypeSignature sig, _cmsTagTypeLinkedList* PluginLinkedList, _cmsTagTypeLinkedList* DefaultLinkedList) { … } // Auxiliary to convert UTF-32 to UTF-16 in some cases static cmsBool _cmsWriteWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, const wchar_t* Array) { … } // Try to promote correctly to wchar_t when 32 bits cmsINLINE cmsBool is_surrogate(cmsUInt32Number uc) { … } cmsINLINE cmsBool is_high_surrogate(cmsUInt32Number uc) { … } cmsINLINE cmsBool is_low_surrogate(cmsUInt32Number uc) { … } cmsINLINE cmsUInt32Number surrogate_to_utf32(cmsUInt32Number high, cmsUInt32Number low) { … } cmsINLINE cmsBool convert_utf16_to_utf32(cmsIOHANDLER* io, cmsInt32Number n, wchar_t* output) { … } // Auxiliary to read an array of wchar_t static cmsBool _cmsReadWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, wchar_t* Array) { … } // To deal with position tables PositionTableEntryFn; // Helper function to deal with position tables as described in ICC spec 4.3 // A table of n elements is read, where first comes n records containing offsets and sizes and // then a block containing the data itself. This allows to reuse same data in more than one entry static cmsBool ReadPositionTable(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number Count, cmsUInt32Number BaseOffset, void *Cargo, PositionTableEntryFn ElementFn) { … } // Same as anterior, but for write position tables static cmsBool WritePositionTable(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number SizeOfTag, cmsUInt32Number Count, cmsUInt32Number BaseOffset, void *Cargo, PositionTableEntryFn ElementFn) { … } // ******************************************************************************** // Type XYZ. Only one value is allowed // ******************************************************************************** //The XYZType contains an array of three encoded values for the XYZ tristimulus //values. Tristimulus values must be non-negative. The signed encoding allows for //implementation optimizations by minimizing the number of fixed formats. static void *Type_XYZ_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_XYZ_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_XYZ_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_XYZ_Free(struct _cms_typehandler_struct* self, void *Ptr) { … } static cmsTagTypeSignature DecideXYZtype(cmsFloat64Number ICCVersion, const void *Data) { … } // ******************************************************************************** // Type chromaticity. Only one value is allowed // ******************************************************************************** // The chromaticity tag type provides basic chromaticity data and type of // phosphors or colorants of a monitor to applications and utilities. static void *Type_Chromaticity_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool SaveOneChromaticity(cmsFloat64Number x, cmsFloat64Number y, cmsIOHANDLER* io) { … } static cmsBool Type_Chromaticity_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Chromaticity_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Chromaticity_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigColorantOrderType // ******************************************************************************** // This is an optional tag which specifies the laydown order in which colorants will // be printed on an n-colorant device. The laydown order may be the same as the // channel generation order listed in the colorantTableTag or the channel order of a // colour space such as CMYK, in which case this tag is not needed. When this is not // the case (for example, ink-towers sometimes use the order KCMY), this tag may be // used to specify the laydown order of the colorants. static void *Type_ColorantOrderType_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_ColorantOrderType_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_ColorantOrderType_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_ColorantOrderType_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigS15Fixed16ArrayType // ******************************************************************************** // This type represents an array of generic 4-byte/32-bit fixed point quantity. // The number of values is determined from the size of the tag. static void *Type_S15Fixed16_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_S15Fixed16_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_S15Fixed16_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_S15Fixed16_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigU16Fixed16ArrayType // ******************************************************************************** // This type represents an array of generic 4-byte/32-bit quantity. // The number of values is determined from the size of the tag. static void *Type_U16Fixed16_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_U16Fixed16_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_U16Fixed16_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_U16Fixed16_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigSignatureType // ******************************************************************************** // // The signatureType contains a four-byte sequence, Sequences of less than four // characters are padded at the end with spaces, 20h. // Typically this type is used for registered tags that can be displayed on many // development systems as a sequence of four characters. static void *Type_Signature_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_Signature_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Signature_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Signature_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigTextType // ******************************************************************************** // // The textType is a simple text structure that contains a 7-bit ASCII text string. // The length of the string is obtained by subtracting 8 from the element size portion // of the tag itself. This string must be terminated with a 00h byte. static void *Type_Text_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // The conversion implies to choose a language. So, we choose the actual language. static cmsBool Type_Text_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Text_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Text_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } static cmsTagTypeSignature DecideTextType(cmsFloat64Number ICCVersion, const void *Data) { … } // ******************************************************************************** // Type cmsSigDataType // ******************************************************************************** // General purpose data type static void *Type_Data_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_Data_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Data_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Data_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigTextDescriptionType // ******************************************************************************** static void *Type_Text_Description_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // This tag can come IN UNALIGNED SIZE. In order to prevent issues, we force zeros on description to align it static cmsBool Type_Text_Description_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Text_Description_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Text_Description_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } static cmsTagTypeSignature DecideTextDescType(cmsFloat64Number ICCVersion, const void *Data) { … } // ******************************************************************************** // Type cmsSigCurveType // ******************************************************************************** static void *Type_Curve_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_Curve_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Curve_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Curve_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigParametricCurveType // ******************************************************************************** // Decide which curve type to use on writing static cmsTagTypeSignature DecideCurveType(cmsFloat64Number ICCVersion, const void *Data) { … } static void *Type_ParametricCurve_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_ParametricCurve_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_ParametricCurve_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_ParametricCurve_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigDateTimeType // ******************************************************************************** // A 12-byte value representation of the time and date, where the byte usage is assigned // as specified in table 1. The actual values are encoded as 16-bit unsigned integers // (uInt16Number - see 5.1.6). // // All the dateTimeNumber values in a profile shall be in Coordinated Universal Time // (UTC, also known as GMT or ZULU Time). Profile writers are required to convert local // time to UTC when setting these values. Programs that display these values may show // the dateTimeNumber as UTC, show the equivalent local time (at current locale), or // display both UTC and local versions of the dateTimeNumber. static void *Type_DateTime_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_DateTime_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_DateTime_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_DateTime_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type icMeasurementType // ******************************************************************************** /* The measurementType information refers only to the internal profile data and is meant to provide profile makers an alternative to the default measurement specifications. */ static void *Type_Measurement_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_Measurement_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Measurement_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Measurement_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigMultiLocalizedUnicodeType // ******************************************************************************** // // Do NOT trust SizeOfTag as there is an issue on the definition of profileSequenceDescTag. See the TechNote from // Max Derhak and Rohit Patil about this: basically the size of the string table should be guessed and cannot be // taken from the size of tag if this tag is embedded as part of bigger structures (profileSequenceDescTag, for instance) // static void *Type_MLU_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_MLU_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_MLU_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_MLU_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigLut8Type // ******************************************************************************** // Decide which LUT type to use on writing static cmsTagTypeSignature DecideLUTtypeA2B(cmsFloat64Number ICCVersion, const void *Data) { … } static cmsTagTypeSignature DecideLUTtypeB2A(cmsFloat64Number ICCVersion, const void *Data) { … } /* This structure represents a colour transform using tables of 8-bit precision. This type contains four processing elements: a 3 by 3 matrix (which shall be the identity matrix unless the input colour space is XYZ), a set of one dimensional input tables, a multidimensional lookup table, and a set of one dimensional output tables. Data is processed using these elements via the following sequence: (matrix) -> (1d input tables) -> (multidimensional lookup table - CLUT) -> (1d output tables) Byte Position Field Length (bytes) Content Encoded as... 8 1 Number of Input Channels (i) uInt8Number 9 1 Number of Output Channels (o) uInt8Number 10 1 Number of CLUT grid points (identical for each side) (g) uInt8Number 11 1 Reserved for padding (fill with 00h) 12..15 4 Encoded e00 parameter s15Fixed16Number */ // Read 8 bit tables as gamma functions static cmsBool Read8bitTables(cmsContext ContextID, cmsIOHANDLER* io, cmsPipeline* lut, cmsUInt32Number nChannels) { … } static cmsBool Write8bitTables(cmsContext ContextID, cmsIOHANDLER* io, cmsUInt32Number n, _cmsStageToneCurvesData* Tables) { … } // Check overflow static cmsUInt32Number uipow(cmsUInt32Number n, cmsUInt32Number a, cmsUInt32Number b) { … } // That will create a MPE LUT with Matrix, pre tables, CLUT and post tables. // 8 bit lut may be scaled easily to v4 PCS, but we need also to properly adjust // PCS on BToAxx tags and AtoB if abstract. We need to fix input direction. static void *Type_LUT8_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // We only allow a specific MPE structure: Matrix plus prelin, plus clut, plus post-lin. static cmsBool Type_LUT8_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_LUT8_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_LUT8_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigLut16Type // ******************************************************************************** // Read 16 bit tables as gamma functions static cmsBool Read16bitTables(cmsContext ContextID, cmsIOHANDLER* io, cmsPipeline* lut, cmsUInt32Number nChannels, cmsUInt32Number nEntries) { … } static cmsBool Write16bitTables(cmsContext ContextID, cmsIOHANDLER* io, _cmsStageToneCurvesData* Tables) { … } static void *Type_LUT16_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // We only allow some specific MPE structures: Matrix plus prelin, plus clut, plus post-lin. // Some empty defaults are created for missing parts static cmsBool Type_LUT16_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_LUT16_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_LUT16_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigLutAToBType // ******************************************************************************** // V4 stuff. Read matrix for LutAtoB and LutBtoA static cmsStage* ReadMatrix(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number Offset) { … } // V4 stuff. Read CLUT part for LutAtoB and LutBtoA static cmsStage* ReadCLUT(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number Offset, cmsUInt32Number InputChannels, cmsUInt32Number OutputChannels) { … } static cmsToneCurve* ReadEmbeddedCurve(struct _cms_typehandler_struct* self, cmsIOHANDLER* io) { … } // Read a set of curves from specific offset static cmsStage* ReadSetOfCurves(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number Offset, cmsUInt32Number nCurves) { … } // LutAtoB type // This structure represents a colour transform. The type contains up to five processing // elements which are stored in the AtoBTag tag in the following order: a set of one // dimensional curves, a 3 by 3 matrix with offset terms, a set of one dimensional curves, // a multidimensional lookup table, and a set of one dimensional output curves. // Data are processed using these elements via the following sequence: // //("A" curves) -> (multidimensional lookup table - CLUT) -> ("M" curves) -> (matrix) -> ("B" curves). // /* It is possible to use any or all of these processing elements. At least one processing element must be included.Only the following combinations are allowed: B M - Matrix - B A - CLUT - B A - CLUT - M - Matrix - B */ static void* Type_LUTA2B_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // Write a set of curves static cmsBool WriteMatrix(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsStage* mpe) { … } // Write a set of curves static cmsBool WriteSetOfCurves(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsTagTypeSignature Type, cmsStage* mpe) { … } static cmsBool WriteCLUT(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt8Number Precision, cmsStage* mpe) { … } static cmsBool Type_LUTA2B_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_LUTA2B_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_LUTA2B_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // LutBToA type static void* Type_LUTB2A_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } /* B B - Matrix - M B - CLUT - A B - Matrix - M - CLUT - A */ static cmsBool Type_LUTB2A_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_LUTB2A_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_LUTB2A_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigColorantTableType // ******************************************************************************** /* The purpose of this tag is to identify the colorants used in the profile by a unique name and set of XYZ or L*a*b* values to give the colorant an unambiguous value. The first colorant listed is the colorant of the first device channel of a lut tag. The second colorant listed is the colorant of the second device channel of a lut tag, and so on. */ static void *Type_ColorantTable_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // Saves a colorant table. It is using the named color structure for simplicity sake static cmsBool Type_ColorantTable_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_ColorantTable_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n) { … } static void Type_ColorantTable_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigNamedColor2Type // ******************************************************************************** // //The namedColor2Type is a count value and array of structures that provide color //coordinates for 7-bit ASCII color names. For each named color, a PCS and optional //device representation of the color are given. Both representations are 16-bit values. //The device representation corresponds to the header's 'color space of data' field. //This representation should be consistent with the 'number of device components' //field in the namedColor2Type. If this field is 0, device coordinates are not provided. //The PCS representation corresponds to the header's PCS field. The PCS representation //is always provided. Color names are fixed-length, 32-byte fields including null //termination. In order to maintain maximum portability, it is strongly recommended //that special characters of the 7-bit ASCII set not be used. static void *Type_NamedColor_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // Saves a named color list into a named color profile static cmsBool Type_NamedColor_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_NamedColor_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n) { … } static void Type_NamedColor_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigProfileSequenceDescType // ******************************************************************************** // This type is an array of structures, each of which contains information from the // header fields and tags from the original profiles which were combined to create // the final profile. The order of the structures is the order in which the profiles // were combined and includes a structure for the final profile. This provides a // description of the profile sequence from source to destination, // typically used with the DeviceLink profile. static cmsBool ReadEmbeddedText(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU** mlu, cmsUInt32Number SizeOfTag) { … } static void *Type_ProfileSequenceDesc_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // Aux--Embed a text description type. It can be of type text description or multilocalized unicode // and it depends of the version number passed on cmsTagDescriptor structure instead of stack static cmsBool SaveDescription(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU* Text) { … } static cmsBool Type_ProfileSequenceDesc_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_ProfileSequenceDesc_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n) { … } static void Type_ProfileSequenceDesc_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigProfileSequenceIdType // ******************************************************************************** /* In certain workflows using ICC Device Link Profiles, it is necessary to identify the original profiles that were combined to create the Device Link Profile. This type is an array of structures, each of which contains information for identification of a profile used in a sequence */ static cmsBool ReadSeqID(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Cargo, cmsUInt32Number n, cmsUInt32Number SizeOfTag) { … } static void *Type_ProfileSequenceId_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool WriteSeqID(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Cargo, cmsUInt32Number n, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_ProfileSequenceId_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_ProfileSequenceId_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n) { … } static void Type_ProfileSequenceId_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigUcrBgType // ******************************************************************************** /* This type contains curves representing the under color removal and black generation and a text string which is a general description of the method used for the ucr/bg. */ static void *Type_UcrBg_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_UcrBg_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_UcrBg_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_UcrBg_Free(struct _cms_typehandler_struct* self, void *Ptr) { … } // ******************************************************************************** // Type cmsSigCrdInfoType // ******************************************************************************** /* This type contains the PostScript product name to which this profile corresponds and the names of the companion CRDs. Recall that a single profile can generate multiple CRDs. It is implemented as a MLU being the language code "PS" and then country varies for each element: nm: PostScript product name #0: Rendering intent 0 CRD name #1: Rendering intent 1 CRD name #2: Rendering intent 2 CRD name #3: Rendering intent 3 CRD name */ // Auxiliary, read an string specified as count + string static cmsBool ReadCountAndString(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU* mlu, cmsUInt32Number* SizeOfTag, const char* Section) { … } static cmsBool WriteCountAndString(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU* mlu, const char* Section) { … } static void *Type_CrdInfo_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_CrdInfo_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_CrdInfo_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_CrdInfo_Free(struct _cms_typehandler_struct* self, void *Ptr) { … } // ******************************************************************************** // Type cmsSigScreeningType // ******************************************************************************** // //The screeningType describes various screening parameters including screen //frequency, screening angle, and spot shape. static void *Type_Screening_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_Screening_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Screening_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Screening_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigViewingConditionsType // ******************************************************************************** // //This type represents a set of viewing condition parameters including: //CIE 'absolute' illuminant white point tristimulus values and CIE 'absolute' //surround tristimulus values. static void *Type_ViewingConditions_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_ViewingConditions_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_ViewingConditions_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_ViewingConditions_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigMultiProcessElementType // ******************************************************************************** static void* GenericMPEdup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void GenericMPEfree(struct _cms_typehandler_struct* self, void *Ptr) { … } // Each curve is stored in one or more curve segments, with break-points specified between curve segments. // The first curve segment always starts at -Infinity, and the last curve segment always ends at +Infinity. The // first and last curve segments shall be specified in terms of a formula, whereas the other segments shall be // specified either in terms of a formula, or by a sampled curve. // Read an embedded segmented curve static cmsToneCurve* ReadSegmentedCurve(struct _cms_typehandler_struct* self, cmsIOHANDLER* io) { … } static cmsBool ReadMPECurve(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Cargo, cmsUInt32Number n, cmsUInt32Number SizeOfTag) { … } static void *Type_MPEcurve_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // Write a single segmented curve. NO CHECK IS PERFORMED ON VALIDITY static cmsBool WriteSegmentedCurve(cmsIOHANDLER* io, cmsToneCurve* g) { … } static cmsBool WriteMPECurve(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Cargo, cmsUInt32Number n, cmsUInt32Number SizeOfTag) { … } // Write a curve, checking first for validity static cmsBool Type_MPEcurve_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } // The matrix is organized as an array of PxQ+Q elements, where P is the number of input channels to the // matrix, and Q is the number of output channels. The matrix elements are each float32Numbers. The array // is organized as follows: // array = [e11, e12, ..., e1P, e21, e22, ..., e2P, ..., eQ1, eQ2, ..., eQP, e1, e2, ..., eQ] static void *Type_MPEmatrix_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_MPEmatrix_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void *Type_MPEclut_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // Write a CLUT in floating point static cmsBool Type_MPEclut_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } // This is the list of built-in MPE types static _cmsTagTypeLinkedList SupportedMPEtypes[] = …; _cmsTagTypePluginChunkType _cmsMPETypePluginChunk = …; static cmsBool ReadMPEElem(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Cargo, cmsUInt32Number n, cmsUInt32Number SizeOfTag) { … } // This is the main dispatcher for MPE static void *Type_MPE_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // This one is a little bit more complex, so we don't use position tables this time. static cmsBool Type_MPE_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_MPE_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_MPE_Free(struct _cms_typehandler_struct* self, void *Ptr) { … } // ******************************************************************************** // Type cmsSigVcgtType // ******************************************************************************** #define cmsVideoCardGammaTableType … #define cmsVideoCardGammaFormulaType … // Used internally _cmsVCGTGAMMA; static void *Type_vcgt_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } // We don't support all flavors, only 16bits tables and formula static cmsBool Type_vcgt_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_vcgt_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_vcgt_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type cmsSigDictType // ******************************************************************************** // Single column of the table can point to wchar or MLUC elements. Holds arrays of data _cmsDICelem; _cmsDICarray; // Allocate an empty array element static cmsBool AllocElem(cmsContext ContextID, _cmsDICelem* e, cmsUInt32Number Count) { … } // Free an array element static void FreeElem(_cmsDICelem* e) { … } // Get rid of whole array static void FreeArray( _cmsDICarray* a) { … } // Allocate whole array static cmsBool AllocArray(cmsContext ContextID, _cmsDICarray* a, cmsUInt32Number Count, cmsUInt32Number Length) { … } // Read one element static cmsBool ReadOneElem(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, cmsUInt32Number BaseOffset) { … } static cmsBool ReadOffsetArray(cmsIOHANDLER* io, _cmsDICarray* a, cmsUInt32Number Count, cmsUInt32Number Length, cmsUInt32Number BaseOffset, cmsInt32Number* SignedSizeOfTagPtr) { … } // Write one element static cmsBool WriteOneElem(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i) { … } static cmsBool WriteOffsetArray(cmsIOHANDLER* io, _cmsDICarray* a, cmsUInt32Number Count, cmsUInt32Number Length) { … } static cmsBool ReadOneWChar(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, wchar_t ** wcstr) { … } static cmsUInt32Number mywcslen(const wchar_t *s) { … } static cmsBool WriteOneWChar(cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, const wchar_t * wcstr, cmsUInt32Number BaseOffset) { … } static cmsBool ReadOneMLUC(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, cmsMLU** mlu) { … } static cmsBool WriteOneMLUC(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, _cmsDICelem* e, cmsUInt32Number i, const cmsMLU* mlu, cmsUInt32Number BaseOffset) { … } static void *Type_Dictionary_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_Dictionary_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } static void* Type_Dictionary_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n) { … } static void Type_Dictionary_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // cicp VideoSignalType static void* Type_VideoSignal_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag) { … } static cmsBool Type_VideoSignal_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems) { … } void* Type_VideoSignal_Dup(struct _cms_typehandler_struct* self, const void* Ptr, cmsUInt32Number n) { … } static void Type_VideoSignal_Free(struct _cms_typehandler_struct* self, void* Ptr) { … } // ******************************************************************************** // Type support main routines // ******************************************************************************** // This is the list of built-in types static const _cmsTagTypeLinkedList SupportedTagTypes[] = …; _cmsTagTypePluginChunkType _cmsTagTypePluginChunk = …; // Duplicates the zone of memory used by the plug-in in the new context static void DupTagTypeList(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src, int loc) { … } void _cmsAllocTagTypePluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src) { … } void _cmsAllocMPETypePluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src) { … } // Both kind of plug-ins share same structure cmsBool _cmsRegisterTagTypePlugin(cmsContext id, cmsPluginBase* Data) { … } cmsBool _cmsRegisterMultiProcessElementPlugin(cmsContext id, cmsPluginBase* Data) { … } // Wrapper for tag types cmsTagTypeHandler* _cmsGetTagTypeHandler(cmsContext ContextID, cmsTagTypeSignature sig) { … } // ******************************************************************************** // Tag support main routines // ******************************************************************************** _cmsTagLinkedList; // This is the list of built-in tags. The data of this list can be modified by plug-ins static _cmsTagLinkedList SupportedTags[] = …; /* Not supported Why ======================= ========================================= cmsSigOutputResponseTag ==> WARNING, POSSIBLE PATENT ON THIS SUBJECT! cmsSigNamedColorTag ==> Deprecated cmsSigDataTag ==> Ancient, unused cmsSigDeviceSettingsTag ==> Deprecated, useless */ _cmsTagPluginChunkType _cmsTagPluginChunk = …; // Duplicates the zone of memory used by the plug-in in the new context static void DupTagList(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src) { … } void _cmsAllocTagPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src) { … } cmsBool _cmsRegisterTagPlugin(cmsContext id, cmsPluginBase* Data) { … } // Return a descriptor for a given tag or NULL cmsTagDescriptor* _cmsGetTagDescriptor(cmsContext ContextID, cmsTagSignature sig) { … }
Codebase Browser
chromium