w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

lcms2_internal.h
Go to the documentation of this file.
1 
2 //
3 // Little Color Management System
4 // Copyright (c) 1998-2020 Marti Maria Saguer
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining
7 // a copy of this software and associated documentation files (the "Software"),
8 // to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 // and/or sell copies of the Software, and to permit persons to whom the Software
11 // is furnished to do so, subject to the following conditions:
12 //
13 // The above copyright notice and this permission notice shall be included in
14 // all copies or substantial portions of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
18 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //---------------------------------------------------------------------------------
25 //
26 
27 #ifndef _lcms_internal_H
28 
29 // Include plug-in foundation
30 #ifndef _lcms_plugin_H
31 # include "lcms2_plugin.h"
32 #endif
33 
34 // ctype is part of C99 as per 7.1.2
35 #include <ctype.h>
36 
37 // assert macro is part of C99 as per 7.2
38 #include <assert.h>
39 
40 // Some needed constants
41 #ifndef M_PI
42 # define M_PI 3.14159265358979323846
43 #endif
44 
45 #ifndef M_LOG10E
46 # define M_LOG10E 0.434294481903251827651
47 #endif
48 
49 // BorlandC 5.5, VC2003 are broken on that
50 #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER < 1400)) // 1400 == VC++ 8.0
51 #define sinf(x) (float)sin((float)x)
52 #define sqrtf(x) (float)sqrt((float)x)
53 #endif
54 
55 
56 // Alignment of ICC file format uses 4 bytes (cmsUInt32Number)
57 #define _cmsALIGNLONG(x) (((x)+(sizeof(cmsUInt32Number)-1)) & ~(sizeof(cmsUInt32Number)-1))
58 
59 // Alignment to memory pointer
60 
61 // (Ultra)SPARC with gcc requires ptr alignment of 8 bytes
62 // even though sizeof(void *) is only four: for greatest flexibility
63 // allow the build to specify ptr alignment.
64 #ifndef CMS_PTR_ALIGNMENT
65 # define CMS_PTR_ALIGNMENT sizeof(void *)
66 #endif
67 
68 #define _cmsALIGNMEM(x) (((x)+(CMS_PTR_ALIGNMENT - 1)) & ~(CMS_PTR_ALIGNMENT - 1))
69 
70 // Maximum encodeable values in floating point
71 #define MAX_ENCODEABLE_XYZ (1.0 + 32767.0/32768.0)
72 #define MIN_ENCODEABLE_ab2 (-128.0)
73 #define MAX_ENCODEABLE_ab2 ((65535.0/256.0) - 128.0)
74 #define MIN_ENCODEABLE_ab4 (-128.0)
75 #define MAX_ENCODEABLE_ab4 (127.0)
76 
77 // Maximum of channels for internal pipeline evaluation
78 #define MAX_STAGE_CHANNELS 128
79 
80 // Unused parameter warning suppression
81 #define cmsUNUSED_PARAMETER(x) ((void)x)
82 
83 // The specification for "inline" is section 6.7.4 of the C99 standard (ISO/IEC 9899:1999).
84 // unfortunately VisualC++ does not conform that
85 #if defined(_MSC_VER) || defined(__BORLANDC__)
86 # define cmsINLINE __inline
87 #else
88 # define cmsINLINE static inline
89 #endif
90 
91 // Allow signed overflow, we know this is harmless in this particular context
92 #if defined(__clang__)
93 # define CMS_NO_SANITIZE __attribute__((no_sanitize("signed-integer-overflow")))
94 #else
95 # define CMS_NO_SANITIZE
96 #endif
97 
98 // Other replacement functions
99 #ifdef _MSC_VER
100 # ifndef snprintf
101 # define snprintf _snprintf
102 # endif
103 # ifndef vsnprintf
104 # define vsnprintf _vsnprintf
105 # endif
106 
107 /// Properly define some macros to accommodate
108 /// older MSVC versions.
109 # if defined(_MSC_VER) && _MSC_VER <= 1700
110  #include <float.h>
111  #define isnan _isnan
112  #define isinf(x) (!_finite((x)))
113 # endif
114 
115 #if !defined(_MSC_VER) && (defined(__STDC_VERSION__) && __STDC_VERSION__ < 199901L)
116  #if !defined(isinf)
117  #define isinf(x) (!finite((x)))
118  #endif
119 #endif
120 
121 
122 #endif
123 
124 // A fast way to convert from/to 16 <-> 8 bits
125 #define FROM_8_TO_16(rgb) (cmsUInt16Number) ((((cmsUInt16Number) (rgb)) << 8)|(rgb))
126 #define FROM_16_TO_8(rgb) (cmsUInt8Number) ((((cmsUInt32Number)(rgb) * 65281U + 8388608U) >> 24) & 0xFFU)
127 
128 // Code analysis is broken on asserts
129 #ifdef _MSC_VER
130 # if (_MSC_VER >= 1500)
131 # define _cmsAssert(a) { assert((a)); __analysis_assume((a)); }
132 # else
133 # define _cmsAssert(a) assert((a))
134 # endif
135 #else
136 # define _cmsAssert(a) assert((a))
137 #endif
138 
139 //---------------------------------------------------------------------------------
140 
141 // Determinant lower than that are assumed zero (used on matrix invert)
142 #define MATRIX_DET_TOLERANCE 0.0001
143 
144 //---------------------------------------------------------------------------------
145 
146 // Fixed point
147 #define FIXED_TO_INT(x) ((x)>>16)
148 #define FIXED_REST_TO_INT(x) ((x)&0xFFFFU)
149 #define ROUND_FIXED_TO_INT(x) (((x)+0x8000)>>16)
150 
151 cmsINLINE cmsS15Fixed16Number _cmsToFixedDomain(int a) { return a + ((a + 0x7fff) / 0xffff); }
152 cmsINLINE int _cmsFromFixedDomain(cmsS15Fixed16Number a) { return a - ((a + 0x7fff) >> 16); }
153 
154 // -----------------------------------------------------------------------------------------------------------
155 
156 // Fast floor conversion logic. Thanks to Sree Kotay and Stuart Nixon
157 // note than this only works in the range ..-32767...+32767 because
158 // mantissa is interpreted as 15.16 fixed point.
159 // The union is to avoid pointer aliasing overoptimization.
161 {
162 #ifdef CMS_DONT_USE_FAST_FLOOR
163  return (int) floor(val);
164 #else
165  const cmsFloat64Number _lcms_double2fixmagic = 68719476736.0 * 1.5; // 2^36 * 1.5, (52-16=36) uses limited precision to floor
166  union {
168  int halves[2];
169  } temp;
170 
171  temp.val = val + _lcms_double2fixmagic;
172 
173 #ifdef CMS_USE_BIG_ENDIAN
174  return temp.halves[1] >> 16;
175 #else
176  return temp.halves[0] >> 16;
177 #endif
178 #endif
179 }
180 
181 // Fast floor restricted to 0..65535.0
183 {
184  return (cmsUInt16Number) _cmsQuickFloor(d - 32767.0) + 32767U;
185 }
186 
187 // Floor to word, taking care of saturation
189 {
190  d += 0.5;
191  if (d <= 0) return 0;
192  if (d >= 65535.0) return 0xffff;
193 
194  return _cmsQuickFloorWord(d);
195 }
196 
197 // Test bed entry points---------------------------------------------------------------
198 #define CMSCHECKPOINT CMSAPI
199 
200 // Pthread support --------------------------------------------------------------------
201 #ifndef CMS_NO_PTHREADS
202 
203 // This is the threading support. Unfortunately, it has to be platform-dependent because
204 // windows does not support pthreads.
205 #ifdef CMS_IS_WINDOWS_
206 
207 #define WIN32_LEAN_AND_MEAN 1
208 #include <windows.h>
209 
210 
211 // The locking scheme in LCMS requires a single 'top level' mutex
212 // to work. This is actually implemented on Windows as a
213 // CriticalSection, because they are lighter weight. With
214 // pthreads, this is statically inited. Unfortunately, windows
215 // can't officially statically init critical sections.
216 //
217 // We can work around this in 2 ways.
218 //
219 // 1) We can use a proper mutex purely to protect the init
220 // of the CriticalSection. This in turns requires us to protect
221 // the Mutex creation, which we can do using the snappily
222 // named InterlockedCompareExchangePointer API (present on
223 // windows XP and above).
224 //
225 // 2) In cases where we want to work on pre-Windows XP, we
226 // can use an even more horrible hack described below.
227 //
228 // So why wouldn't we always use 2)? Because not calling
229 // the init function for a critical section means it fails
230 // testing with ApplicationVerifier (and presumably similar
231 // tools).
232 //
233 // We therefore default to 1, and people who want to be able
234 // to run on pre-Windows XP boxes can build with:
235 // CMS_RELY_ON_WINDOWS_STATIC_MUTEX_INIT
236 // defined. This is automatically set for builds using
237 // versions of MSVC that don't have this API available.
238 //
239 // From: http://locklessinc.com/articles/pthreads_on_windows/
240 // The pthreads API has an initialization macro that has no correspondence to anything in
241 // the windows API. By investigating the internal definition of the critical section type,
242 // one may work out how to initialize one without calling InitializeCriticalSection().
243 // The trick here is that InitializeCriticalSection() is not allowed to fail. It tries
244 // to allocate a critical section debug object, but if no memory is available, it sets
245 // the pointer to a specific value. (One would expect that value to be NULL, but it is
246 // actually (void *)-1 for some reason.) Thus we can use this special value for that
247 // pointer, and the critical section code will work.
248 
249 // The other important part of the critical section type to initialize is the number
250 // of waiters. This controls whether or not the mutex is locked. Fortunately, this
251 // part of the critical section is unlikely to change. Apparently, many programs
252 // already test critical sections to see if they are locked using this value, so
253 // Microsoft felt that it was necessary to keep it set at -1 for an unlocked critical
254 // section, even when they changed the underlying algorithm to be more scalable.
255 // The final parts of the critical section object are unimportant, and can be set
256 // to zero for their defaults. This yields to an initialization macro:
257 
258 typedef CRITICAL_SECTION _cmsMutex;
259 
260 #ifdef _MSC_VER
261 # if (_MSC_VER >= 1800)
262 # pragma warning(disable : 26135)
263 # endif
264 #endif
265 
266 #ifndef CMS_RELY_ON_WINDOWS_STATIC_MUTEX_INIT
267 // If we are building with a version of MSVC smaller
268 // than 1400 (i.e. before VS2005) then we don't have
269 // the InterlockedCompareExchangePointer API, so use
270 // the old version.
271 # ifdef _MSC_VER
272 # if _MSC_VER < 1400
273 # define CMS_RELY_ON_WINDOWS_STATIC_MUTEX_INIT
274 # endif
275 # endif
276 #endif
277 
278 #ifdef CMS_RELY_ON_WINDOWS_STATIC_MUTEX_INIT
279 # define CMS_MUTEX_INITIALIZER {(PRTL_CRITICAL_SECTION_DEBUG) -1,-1,0,0,0,0}
280 #else
281 # define CMS_MUTEX_INITIALIZER {(PRTL_CRITICAL_SECTION_DEBUG)NULL,-1,0,0,0,0}
282 #endif
283 
285 {
286  EnterCriticalSection(m);
287  return 0;
288 }
289 
291 {
292  LeaveCriticalSection(m);
293  return 0;
294 }
295 
297 {
298  InitializeCriticalSection(m);
299  return 0;
300 }
301 
303 {
304  DeleteCriticalSection(m);
305  return 0;
306 }
307 
309 {
310  EnterCriticalSection(m);
311  return 0;
312 }
313 
315 {
316  LeaveCriticalSection(m);
317  return 0;
318 }
319 
320 #else
321 
322 // Rest of the wide world
323 #include <pthread.h>
324 
325 #define CMS_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
326 typedef pthread_mutex_t _cmsMutex;
327 
328 
330 {
331  return pthread_mutex_lock(m);
332 }
333 
335 {
336  return pthread_mutex_unlock(m);
337 }
338 
340 {
341  return pthread_mutex_init(m, NULL);
342 }
343 
345 {
346  return pthread_mutex_destroy(m);
347 }
348 
350 {
351  return pthread_mutex_lock(m);
352 }
353 
355 {
356  return pthread_mutex_unlock(m);
357 }
358 
359 #endif
360 #else
361 
362 #define CMS_MUTEX_INITIALIZER 0
363 typedef int _cmsMutex;
364 
365 
367 {
369  return 0;
370 }
371 
373 {
375  return 0;
376 }
377 
379 {
381  return 0;
382 }
383 
385 {
387  return 0;
388 }
389 
391 {
393  return 0;
394 }
395 
397 {
399  return 0;
400 }
401 #endif
402 
403 // Plug-In registration ---------------------------------------------------------------
404 
405 // Specialized function for plug-in memory management. No pairing free() since whole pool is freed at once.
407 
408 // Memory management
410 
411 // Interpolation
413 
414 // Parametric curves
416 
417 // Formatters management
419 
420 // Tag type management
422 
423 // Tag management
425 
426 // Intent management
428 
429 // Multi Process elements
431 
432 // Optimization
434 
435 // Transform
437 
438 // Mutex
440 
441 // ---------------------------------------------------------------------------------------------------------
442 
443 // Suballocators.
445 
449 
451 
453 
454 
455 typedef struct {
456 
459 
461 
462 
467 
468 // ----------------------------------------------------------------------------------
469 
470 // The context clients.
471 typedef enum {
472 
473  UserPtr, // User-defined pointer
488 
489  // Last in list
491 
493 
494 
495 // Container for memory management plug-in.
496 typedef struct {
497 
504 
506 
507 // Copy memory management function pointers from plug-in to chunk, taking care of missing routines
509 
510 // Internal structure for context
512 
513  struct _cmsContext_struct* Next; // Points to next context in the new style
514  _cmsSubAllocator* MemPool; // The memory pool that stores context data
515 
516  void* chunks[MemoryClientMax]; // array of pointers to client chunks. Memory itself is hold in the suballocator.
517  // If NULL, then it reverts to global Context0
518 
519  _cmsMemPluginChunkType DefaultMemoryManager; // The allocators used for creating the context itself. Cannot be overridden
520 };
521 
522 // Returns a pointer to a valid context structure, including the global one if id is zero.
523 // Verifies the magic number.
524 struct _cmsContext_struct* _cmsGetContext(cmsContext ContextID);
525 
526 // Returns the block assigned to the specific zone.
528 
529 
530 // Chunks of context memory by plug-in client -------------------------------------------------------
531 
532 // Those structures encapsulates all variables needed by the several context clients (mostly plug-ins)
533 
534 // Container for error logger -- not a plug-in
535 typedef struct {
536 
537  cmsLogErrorHandlerFunction LogErrorHandler; // Set to NULL for Context0 fallback
538 
540 
541 // The global Context0 storage for error logger
543 
544 // Allocate and init error logger container.
546  const struct _cmsContext_struct* src);
547 
548 // Container for alarm codes -- not a plug-in
549 typedef struct {
550 
552 
554 
555 // The global Context0 storage for alarm codes
557 
558 // Allocate and init alarm codes container.
560  const struct _cmsContext_struct* src);
561 
562 // Container for adaptation state -- not a plug-in
563 typedef struct {
564 
566 
568 
569 // The global Context0 storage for adaptation state
571 
572 // Allocate and init adaptation state container.
574  const struct _cmsContext_struct* src);
575 
576 
577 // The global Context0 storage for memory management
579 
580 // Allocate and init memory management container.
582  const struct _cmsContext_struct* src);
583 
584 // Container for interpolation plug-in
585 typedef struct {
586 
588 
590 
591 // The global Context0 storage for interpolation plug-in
593 
594 // Allocate and init interpolation container.
596  const struct _cmsContext_struct* src);
597 
598 // Container for parametric curves plug-in
599 typedef struct {
600 
602 
604 
605 // The global Context0 storage for tone curves plug-in
607 
608 // Allocate and init parametric curves container.
610  const struct _cmsContext_struct* src);
611 
612 // Container for formatters plug-in
613 typedef struct {
614 
616 
618 
619 // The global Context0 storage for formatters plug-in
621 
622 // Allocate and init formatters container.
624  const struct _cmsContext_struct* src);
625 
626 // This chunk type is shared by TagType plug-in and MPE Plug-in
627 typedef struct {
628 
630 
632 
633 
634 // The global Context0 storage for tag types plug-in
636 
637 
638 // The global Context0 storage for mult process elements plug-in
640 
641 // Allocate and init Tag types container.
643  const struct _cmsContext_struct* src);
644 // Allocate and init MPE container.
646  const struct _cmsContext_struct* src);
647 // Container for tag plug-in
648 typedef struct {
649 
651 
653 
654 
655 // The global Context0 storage for tag plug-in
657 
658 // Allocate and init Tag container.
660  const struct _cmsContext_struct* src);
661 
662 // Container for intents plug-in
663 typedef struct {
664 
666 
668 
669 
670 // The global Context0 storage for intents plug-in
672 
673 // Allocate and init intents container.
675  const struct _cmsContext_struct* src);
676 
677 // Container for optimization plug-in
678 typedef struct {
679 
681 
683 
684 
685 // The global Context0 storage for optimizers plug-in
687 
688 // Allocate and init optimizers container.
690  const struct _cmsContext_struct* src);
691 
692 // Container for transform plug-in
693 typedef struct {
694 
696 
698 
699 // The global Context0 storage for full-transform replacement plug-in
701 
702 // Allocate and init transform container.
704  const struct _cmsContext_struct* src);
705 
706 // Container for mutex plug-in
707 typedef struct {
708 
713 
715 
716 // The global Context0 storage for mutex plug-in
718 
719 // Allocate and init mutex container.
721  const struct _cmsContext_struct* src);
722 
723 // ----------------------------------------------------------------------------------
724 // MLU internal representation
725 typedef struct {
726 
729 
730  cmsUInt32Number StrW; // Offset to current unicode string
731  cmsUInt32Number Len; // Length in bytes
732 
733 } _cmsMLUentry;
734 
736 
738 
739  // The directory
742  _cmsMLUentry* Entries; // Array of pointers to strings allocated in MemPool
743 
744  // The Pool
745  cmsUInt32Number PoolSize; // The maximum allocated size
746  cmsUInt32Number PoolUsed; // The used size
747  void* MemPool; // Pointer to begin of memory pool
748 };
749 
750 // Named color list internal representation
751 typedef struct {
752 
756 
758 
760 
764 
765  char Prefix[33]; // Prefix and suffix are defined to be 32 characters at most
766  char Suffix[33];
767 
769 
771 };
772 
773 
774 // ----------------------------------------------------------------------------------
775 
776 // This is the internal struct holding profile details.
777 
778 // Maximum supported tags in a profile
779 #define MAX_TABLE_TAG 100
780 
781 typedef struct _cms_iccprofile_struct {
782 
783  // I/O handler
785 
786  // The thread ID
788 
789  // Creation time
790  struct tm Created;
791 
792  // Only most important items found in ICC profiles
798 
803 
805 
806  // Dictionary
809  cmsTagSignature TagLinked[MAX_TABLE_TAG]; // The tag to which is linked (0=none)
812  cmsBool TagSaveAsRaw[MAX_TABLE_TAG]; // True to write uncooked
814  cmsTagTypeHandler* TagTypeHandlers[MAX_TABLE_TAG]; // Same structure may be serialized on different types
815  // depending on profile version, so we keep track of the
816  // type handler for each tag in the list.
817  // Special
819 
820  // Keep a mutex for cmsReadTag -- Note that this only works if the user includes a mutex plugin
821  void * UsrMutex;
822 
824 
825 // IO helpers for profiles
828 int _cmsSearchTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, cmsBool lFollowLinks);
829 
830 // Tag types
834 
835 // Error logging ---------------------------------------------------------------------------------------------------------
836 
838 
839 // Interpolation ---------------------------------------------------------------------------------------------------------
840 
842 cmsInterpParams* _cmsComputeInterpParamsEx(cmsContext ContextID, const cmsUInt32Number nSamples[], cmsUInt32Number InputChan, cmsUInt32Number OutputChan, const void* Table, cmsUInt32Number dwFlags);
845 
846 // Curves ----------------------------------------------------------------------------------------------------------------
847 
848 // This struct holds information about a segment, plus a pointer to the function that implements the evaluation.
849 // In the case of table-based, Eval pointer is set to NULL
850 
851 // The gamma function main structure
853 
854  cmsInterpParams* InterpParams; // Private optimizations for interpolation
855 
856  cmsUInt32Number nSegments; // Number of segments in the curve. Zero for a 16-bit based tables
857  cmsCurveSegment* Segments; // The segments
858  cmsInterpParams** SegInterp; // Array of private optimizations for interpolation in table-based segments
859 
860  cmsParametricCurveEvaluator* Evals; // Evaluators (one per segment)
861 
862  // 16 bit Table-based representation follows
863  cmsUInt32Number nEntries; // Number of table elements
864  cmsUInt16Number* Table16; // The table itself.
865 };
866 
867 
868 // Pipelines & Stages ---------------------------------------------------------------------------------------------
869 
870 // A single stage
872 
874 
875  cmsStageSignature Type; // Identifies the stage
876  cmsStageSignature Implements; // Identifies the *function* of the stage (for optimizations)
877 
878  cmsUInt32Number InputChannels; // Input channels -- for optimization purposes
879  cmsUInt32Number OutputChannels; // Output channels -- for optimization purposes
880 
881  _cmsStageEvalFn EvalPtr; // Points to fn that evaluates the stage (always in floating point)
882  _cmsStageDupElemFn DupElemPtr; // Points to a fn that duplicates the *data* of the stage
883  _cmsStageFreeElemFn FreePtr; // Points to a fn that sets the *data* of the stage free
884 
885  // A generic pointer to whatever memory needed by the stage
886  void* Data;
887 
888  // Maintains linked list (used internally)
890 };
891 
892 
893 // Special Stages (cannot be saved)
908 
909 
910 // For curve set only
912 
913 
914 // Pipeline Evaluator (in floating point)
916  cmsFloat32Number Out[],
917  const void* Data);
918 
920 
921  cmsStage* Elements; // Points to elements chain
923 
924  // Data & evaluators
925  void *Data;
926 
931 
932  cmsContext ContextID; // Environment
933 
934  cmsBool SaveAs8Bits; // Implementation-specific: save as 8 bits if possible
935 };
936 
937 // LUT reading & creation -------------------------------------------------------------------------------------------
938 
939 // Read tags using low-level function, provide necessary glue code to adapt versions, etc. All those return a brand new copy
940 // of the LUTS, since ownership of original is up to the profile. The user should free allocated resources.
941 
945 
946 // Special values
948 cmsBool _cmsReadCHAD(cmsMAT3* Dest, cmsHPROFILE hProfile);
949 
950 // Profile linker --------------------------------------------------------------------------------------------------
951 
952 // Link several profiles to obtain a single LUT modelling the whole color transform. Intents, Black point
953 // compensation and Adaptation parameters may vary across profiles. BPC and Adaptation refers to the PCS
954 // after the profile. I.e, BPC[0] refers to connexion between profile(0) and profile(1)
956  cmsUInt32Number nProfiles,
957  cmsUInt32Number TheIntents[],
958  cmsHPROFILE hProfiles[],
959  cmsBool BPC[],
960  cmsFloat64Number AdaptationStates[],
961  cmsUInt32Number dwFlags);
962 
963 // Sequence --------------------------------------------------------------------------------------------------------
964 
966 cmsBool _cmsWriteProfileSequence(cmsHPROFILE hProfile, const cmsSEQ* seq);
967 cmsSEQ* _cmsCompileProfileSequence(cmsContext ContextID, cmsUInt32Number nProfiles, cmsHPROFILE hProfiles[]);
968 
969 
970 // LUT optimization ------------------------------------------------------------------------------------------------
971 
973 
975 
979  cmsUInt32Number *nOutputs);
980 
982  cmsPipeline** Lut,
983  cmsUInt32Number Intent,
984  cmsUInt32Number* InputFormat,
986  cmsUInt32Number* dwFlags );
987 
988 
989 // Hi level LUT building ----------------------------------------------------------------------------------------------
990 
992  cmsHPROFILE hProfiles[],
993  cmsBool BPC[],
994  cmsUInt32Number Intents[],
995  cmsFloat64Number AdaptationStates[],
996  cmsUInt32Number nGamutPCSposition,
997  cmsHPROFILE hGamut);
998 
999 
1000 // Formatters ------------------------------------------------------------------------------------------------------------
1001 
1002 #define cmsFLAGS_CAN_CHANGE_FORMATTER 0x02000000 // Allow change buffer format
1003 
1006 
1008  cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8
1010  cmsUInt32Number dwFlags);
1011 
1012 
1013 #ifndef CMS_NO_HALF_SUPPORT
1014 
1015 // Half float
1018 
1019 #endif
1020 
1021 // Transform logic ------------------------------------------------------------------------------------------------------
1022 
1023 struct _cmstransform_struct;
1024 
1025 typedef struct {
1026 
1027  // 1-pixel cache (16 bits only)
1030 
1031 } _cmsCACHE;
1032 
1033 
1034 
1035 // Transformation
1036 typedef struct _cmstransform_struct {
1037 
1038  cmsUInt32Number InputFormat, OutputFormat; // Keep formats for further reference
1039 
1040  // Points to transform code
1042 
1043  // Formatters, cannot be embedded into LUT because cache
1046 
1049 
1050  // 1-pixel cache seed for zero as input (16 bits, read only)
1052 
1053  // A Pipeline holding the full (optimized) transform
1055 
1056  // A Pipeline holding the gamut check. It goes from the input space to bilevel
1058 
1059  // Colorant tables
1060  cmsNAMEDCOLORLIST* InputColorant; // Input Colorant table
1061  cmsNAMEDCOLORLIST* OutputColorant; // Colorant table (for n chans > CMYK)
1062 
1063  // Informational only
1066 
1067  // White points (informative only)
1070 
1071  // Profiles used to create the transform
1073 
1076 
1077  // The intent of this transform. That is usually the last intent in the profilechain, but may differ
1079 
1080  // An id that uniquely identifies the running context. May be null.
1082 
1083  // A user-defined pointer that can be used to store data for transform plug-ins
1084  void* UserData;
1086 
1087  // A way to provide backwards compatibility with full xform plugins
1089 
1091 
1092 // Copies extra channels from input to output if the original flags in the transform structure
1093 // instructs to do so. This function is called on all standard transform functions.
1094 void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
1095  void* out,
1096  cmsUInt32Number PixelsPerLine,
1097  cmsUInt32Number LineCount,
1098  const cmsStride* Stride);
1099 
1100 // -----------------------------------------------------------------------------------------------------------------------
1101 
1103  cmsUInt32Number nProfiles,
1104  cmsUInt32Number InputFormat,
1106  const cmsUInt32Number Intents[],
1107  const cmsHPROFILE hProfiles[],
1108  const cmsBool BPC[],
1109  const cmsFloat64Number AdaptationStates[],
1110  cmsUInt32Number dwFlags);
1111 
1112 
1114  cmsUInt32Number nPoints,
1115  cmsUInt32Number nProfiles,
1116  const cmsUInt32Number Intents[],
1117  const cmsHPROFILE hProfiles[],
1118  const cmsBool BPC[],
1119  const cmsFloat64Number AdaptationStates[],
1120  cmsUInt32Number dwFlags);
1121 
1122 cmsBool _cmsAdaptationMatrix(cmsMAT3* r, const cmsMAT3* ConeMatrix, const cmsCIEXYZ* FromIll, const cmsCIEXYZ* ToIll);
1123 
1124 cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3* r, const cmsCIExyY* WhitePoint, const cmsCIExyYTRIPLE* Primaries);
1125 
1126 
1127 #define _lcms_internal_H
1128 #endif
int h
Definition: dviconv.c:9
char * temp
Definition: dvidvi.c:137
static void
Definition: fpif.c:118
#define s
Definition: afcover.h:80
#define White
#define Black
#define a(n)
Definition: gpos-common.c:148
#define d(n)
Definition: gpos-common.c:151
FILE * out
Definition: hbf2gf.c:286
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p
Definition: afcover.h:72
small capitals from c petite p scientific i
Definition: afcover.h:80
enum OutputFormat_ OutputFormat
#define floor(x)
Definition: cpascal.h:52
float cmsFloat32Number
Definition: lcms2.h:98
int cmsBool
Definition: lcms2.h:174
unsigned short cmsUInt16Number
Definition: lcms2.h:103
cmsProfileClassSignature
Definition: lcms2.h:490
#define CMSEXPORT
Definition: lcms2.h:252
void * cmsHTRANSFORM
Definition: lcms2.h:662
unsigned int cmsUInt32Number
Definition: lcms2.h:120
#define cmsMAXCHANNELS
Definition: lcms2.h:664
cmsStageSignature
Definition: lcms2.h:523
cmsInt32Number cmsS15Fixed16Number
Definition: lcms2.h:170
#define cmsMAX_PATH
Definition: lcms2.h:266
cmsTagSignature
Definition: lcms2.h:333
cmsColorSpaceSignature
Definition: lcms2.h:442
double cmsFloat64Number
Definition: lcms2.h:99
cmsUInt32Number cmsUInt64Number[2]
Definition: lcms2.h:163
void * cmsHPROFILE
Definition: lcms2.h:661
unsigned char cmsUInt8Number
Definition: lcms2.h:90
void(* cmsLogErrorHandlerFunction)(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text)
Definition: lcms2.h:1084
cmsTagTypeSignature
Definition: lcms2.h:291
_cmsOptimizationPluginChunkType _cmsOptimizationPluginChunk
Definition: cmsopt.c:1808
static int _cmsDestroyMutexPrimitive(_cmsMutex *m)
cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space, cmsUInt16Number **White, cmsUInt16Number **Black, cmsUInt32Number *nOutputs)
Definition: cmspcs.c:707
cmsBool _cmsFormatterIsFloat(cmsUInt32Number Type)
Definition: cmspack.c:3394
cmsStage * _cmsStageNormalizeFromLabFloat(cmsContext ContextID)
Definition: cmslut.c:1053
cmsUInt16Number _cmsQuantizeVal(cmsFloat64Number i, cmsUInt32Number MaxSamples)
Definition: cmslut.c:733
void _cmsAllocLogErrorChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmserr.c:459
cmsSEQ * _cmsReadProfileSequence(cmsHPROFILE hProfile)
Definition: cmsio1.c:882
cmsTagTypeSignature _cmsGetTagTrueType(cmsHPROFILE hProfile, cmsTagSignature sig)
Definition: cmsio0.c:1619
cmsBool _cmsRegisterTagTypePlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmstypes.c:5396
cmsStage * _cmsStageAllocLabV4ToV2(cmsContext ContextID)
Definition: cmslut.c:1033
#define cmsINLINE
cmsStage * _cmsStageAllocIdentityCLut(cmsContext ContextID, cmsUInt32Number nChan)
Definition: cmslut.c:709
cmsStage * _cmsStageAllocLabPrelin(cmsContext ContextID)
Definition: cmslut.c:1186
cmsBool _cmsWriteProfileSequence(cmsHPROFILE hProfile, const cmsSEQ *seq)
Definition: cmsio1.c:917
_cmsAdaptationStateChunkType _cmsAdaptationStateChunk
Definition: cmsxform.c:35
_cmsMutexPluginChunkType _cmsMutexPluginChunk
Definition: cmserr.c:577
cmsStage * _cmsStageNormalizeToLabFloat(cmsContext ContextID)
Definition: cmslut.c:1092
cmsStage * _cmsStageAllocLabV2ToV4curves(cmsContext ContextID)
Definition: cmslut.c:979
_cmsMemoryClient
@ OptimizationPlugin
@ TagPlugin
@ UserPtr
@ TransformPlugin
@ MemoryClientMax
@ Logger
@ AlarmCodesContext
@ IntentPlugin
@ TagTypePlugin
@ CurvesPlugin
@ InterpPlugin
@ AdaptationStateContext
@ MPEPlugin
@ FormattersPlugin
@ MemPlugin
@ MutexPlugin
#define MAX_TABLE_TAG
cmsBool _cmsSetInterpolationRoutine(cmsContext ContextID, cmsInterpParams *p)
Definition: cmsintrp.c:85
cmsBool _cmsRegisterRenderingIntentPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmscnvrt.c:1121
cmsBool _cmsFormatterIs8bit(cmsUInt32Number Type)
Definition: cmspack.c:3400
pthread_mutex_t _cmsMutex
#define cmsUNUSED_PARAMETER(x)
cmsBool _cmsAdaptationMatrix(cmsMAT3 *r, const cmsMAT3 *ConeMatrix, const cmsCIEXYZ *FromIll, const cmsCIEXYZ *ToIll)
Definition: cmswtpnt.c:233
void _cmsAllocTransformPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmsxform.c:662
_cmsTagPluginChunkType _cmsTagPluginChunk
Definition: cmstypes.c:5529
cmsPipeline * _cmsCreateGamutCheckPipeline(cmsContext ContextID, cmsHPROFILE hProfiles[], cmsBool BPC[], cmsUInt32Number Intents[], cmsFloat64Number AdaptationStates[], cmsUInt32Number nGamutPCSposition, cmsHPROFILE hGamut)
Definition: cmsgmt.c:287
static cmsUInt16Number _cmsQuickSaturateWord(cmsFloat64Number d)
cmsStage * _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST *NamedColorList, cmsBool UsePCS)
Definition: cmsnamed.c:729
cmsInterpParams * _cmsComputeInterpParamsEx(cmsContext ContextID, const cmsUInt32Number nSamples[], cmsUInt32Number InputChan, cmsUInt32Number OutputChan, const void *Table, cmsUInt32Number dwFlags)
Definition: cmsintrp.c:110
cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3 *r, const cmsCIExyY *WhitePoint, const cmsCIExyYTRIPLE *Primaries)
Definition: cmswtpnt.c:278
cmsUInt16Number _cmsFloat2Half(cmsFloat32Number flt)
Definition: cmshalf.c:519
void _cmsAllocInterpPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmsintrp.c:46
void _cmsTagSignature2String(char String[5], cmsTagSignature sig)
Definition: cmserr.c:528
void _cmsAllocTagTypePluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmstypes.c:5365
static cmsS15Fixed16Number _cmsToFixedDomain(int a)
cmsBool _cmsReadCHAD(cmsMAT3 *Dest, cmsHPROFILE hProfile)
Definition: cmsio1.c:94
_cmsFormattersPluginChunkType _cmsFormattersPluginChunk
Definition: cmspack.c:3288
cmsBool _cmsWriteHeader(_cmsICCPROFILE *Icc, cmsUInt32Number UsedSpace)
Definition: cmsio0.c:776
cmsInterpParams * _cmsComputeInterpParams(cmsContext ContextID, cmsUInt32Number nSamples, cmsUInt32Number InputChan, cmsUInt32Number OutputChan, const void *Table, cmsUInt32Number dwFlags)
Definition: cmsintrp.c:161
_cmsAlarmCodesChunkType _cmsAlarmCodesChunk
Definition: cmsxform.c:89
cmsStage * _cmsStageAllocIdentityCurves(cmsContext ContextID, cmsUInt32Number nChannels)
Definition: cmslut.c:295
static int _cmsInitMutexPrimitive(_cmsMutex *m)
void _cmsAllocAdaptationStateChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmsxform.c:38
void _cmsAllocOptimizationPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmsopt.c:1848
void * _cmsPluginMalloc(cmsContext ContextID, cmsUInt32Number size)
Definition: cmsplugin.c:524
cmsStage * _cmsStageAllocLabV2ToV4(cmsContext ContextID)
Definition: cmslut.c:1017
void _cmsHandleExtraChannels(_cmsTRANSFORM *p, const void *in, void *out, cmsUInt32Number PixelsPerLine, cmsUInt32Number LineCount, const cmsStride *Stride)
Definition: cmsalpha.c:536
int _cmsSearchTag(_cmsICCPROFILE *Icc, cmsTagSignature sig, cmsBool lFollowLinks)
Definition: cmsio0.c:559
cmsBool _cmsRegisterMutexPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmserr.c:597
_cmsLogErrorChunkType _cmsLogErrorChunk
Definition: cmserr.c:455
_cmsTagTypePluginChunkType _cmsMPETypePluginChunk
Definition: cmstypes.c:4405
cmsStage * _cmsStageNormalizeFromXyzFloat(cmsContext ContextID)
Definition: cmslut.c:1075
void(* _cmsPipelineEvalFloatFn)(const cmsFloat32Number In[], cmsFloat32Number Out[], const void *Data)
cmsBool _cmsRegisterTransformPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmsxform.c:708
cmsStage * _cmsStageAllocXYZ2Lab(cmsContext ContextID)
Definition: cmslut.c:1176
static int _cmsUnlockPrimitive(_cmsMutex *m)
_cmsTagTypePluginChunkType _cmsTagTypePluginChunk
Definition: cmstypes.c:5325
cmsBool _cmsOptimizePipeline(cmsContext ContextID, cmsPipeline **Lut, cmsUInt32Number Intent, cmsUInt32Number *InputFormat, cmsUInt32Number *OutputFormat, cmsUInt32Number *dwFlags)
Definition: cmsopt.c:1896
cmsBool _cmsReadHeader(_cmsICCPROFILE *Icc)
Definition: cmsio0.c:682
cmsBool _cmsRegisterMultiProcessElementPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmstypes.c:5401
void _cmsFreeInterpParams(cmsInterpParams *p)
Definition: cmsintrp.c:177
void * _cmsContextGetClientChunk(cmsContext id, _cmsMemoryClient mc)
Definition: cmsplugin.c:699
cmsStage * _cmsStageAllocLab2XYZ(cmsContext ContextID)
Definition: cmslut.c:966
void _cmsSubAllocDestroy(_cmsSubAllocator *s)
Definition: cmserr.c:365
cmsTagDescriptor * _cmsGetTagDescriptor(cmsContext ContextID, cmsTagSignature sig)
Definition: cmstypes.c:5605
_cmsInterpPluginChunkType _cmsInterpPluginChunk
Definition: cmsintrp.c:43
cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ *Dest, cmsHPROFILE hProfile)
Definition: cmsio1.c:64
cmsStage * _cmsStageNormalizeToXyzFloat(cmsContext ContextID)
Definition: cmslut.c:1112
static int _cmsLockPrimitive(_cmsMutex *m)
_cmsTransformPluginChunkType _cmsTransformPluginChunk
Definition: cmsxform.c:624
struct _cmstransform_struct _cmsTRANSFORM
void _cmsAllocFormattersPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmspack.c:3328
cmsBool _cmsRegisterTagPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmstypes.c:5580
cmsTagTypeHandler * _cmsGetTagTypeHandler(cmsContext ContextID, cmsTagTypeSignature sig)
Definition: cmstypes.c:5408
cmsStage * _cmsStageClipNegatives(cmsContext ContextID, cmsUInt32Number nChannels)
Definition: cmslut.c:1141
static int _cmsQuickFloor(cmsFloat64Number val)
cmsPipeline * _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent)
Definition: cmsio1.c:707
static int _cmsLeaveCriticalSectionPrimitive(_cmsMutex *m)
static cmsUInt16Number _cmsQuickFloorWord(cmsFloat64Number d)
cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmserr.c:230
cmsFloat32Number _cmsHalf2Float(cmsUInt16Number h)
Definition: cmshalf.c:506
static int _cmsEnterCriticalSectionPrimitive(_cmsMutex *m)
void * _cmsSubAlloc(_cmsSubAllocator *s, cmsUInt32Number size)
Definition: cmserr.c:382
cmsFormatter _cmsGetFormatter(cmsContext ContextID, cmsUInt32Number Type, cmsFormatterDirection Dir, cmsUInt32Number dwFlags)
Definition: cmspack.c:3371
cmsHTRANSFORM _cmsChain2Lab(cmsContext ContextID, cmsUInt32Number nProfiles, cmsUInt32Number InputFormat, cmsUInt32Number OutputFormat, const cmsUInt32Number Intents[], const cmsHPROFILE hProfiles[], const cmsBool BPC[], const cmsFloat64Number AdaptationStates[], cmsUInt32Number dwFlags)
Definition: cmsgmt.c:32
_cmsIntentsPluginChunkType _cmsIntentsPluginChunk
Definition: cmscnvrt.c:98
cmsBool _cmsRegisterInterpPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmsintrp.c:67
void _cmsInstallAllocFunctions(cmsPluginMemHandler *Plugin, _cmsMemPluginChunkType *ptr)
Definition: cmserr.c:204
void * _cmsSubAllocDup(_cmsSubAllocator *s, const void *ptr, cmsUInt32Number size)
Definition: cmserr.c:414
void _cmsAllocMemPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmserr.c:187
_cmsSubAllocator * _cmsCreateSubAlloc(cmsContext ContextID, cmsUInt32Number Initial)
Definition: cmserr.c:344
void _cmsAllocTagPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmstypes.c:5566
void _cmsAllocMPETypePluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmstypes.c:5379
cmsSEQ * _cmsCompileProfileSequence(cmsContext ContextID, cmsUInt32Number nProfiles, cmsHPROFILE hProfiles[])
Definition: cmsio1.c:941
struct _cmsSubAllocator_chunk_st _cmsSubAllocator_chunk
struct _cmsContext_struct * _cmsGetContext(cmsContext ContextID)
Definition: cmsplugin.c:667
cmsUInt32Number _cmsReasonableGridpointsByColorspace(cmsColorSpaceSignature Colorspace, cmsUInt32Number dwFlags)
Definition: cmspcs.c:659
cmsPipeline * _cmsLinkProfiles(cmsContext ContextID, cmsUInt32Number nProfiles, cmsUInt32Number TheIntents[], cmsHPROFILE hProfiles[], cmsBool BPC[], cmsFloat64Number AdaptationStates[], cmsUInt32Number dwFlags)
Definition: cmscnvrt.c:1025
cmsBool _cmsRegisterOptimizationPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmsopt.c:1864
static int _cmsFromFixedDomain(cmsS15Fixed16Number a)
#define CMSCHECKPOINT
void _cmsAllocIntentsPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmscnvrt.c:134
cmsToneCurve * _cmsBuildKToneCurve(cmsContext ContextID, cmsUInt32Number nPoints, cmsUInt32Number nProfiles, const cmsUInt32Number Intents[], const cmsHPROFILE hProfiles[], const cmsBool BPC[], const cmsFloat64Number AdaptationStates[], cmsUInt32Number dwFlags)
Definition: cmsgmt.c:139
cmsPipeline * _cmsReadInputLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent)
Definition: cmsio1.c:309
void _cmsAllocAlarmCodesChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmsxform.c:128
struct _cms_iccprofile_struct _cmsICCPROFILE
cmsToneCurve ** _cmsStageGetPtrToCurveSet(const cmsStage *mpe)
Definition: cmslut.c:159
void _cmsAllocMutexPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmserr.c:580
_cmsMemPluginChunkType _cmsMemPluginChunk
Definition: cmserr.c:181
cmsPipeline * _cmsReadOutputLUT(cmsHPROFILE hProfile, cmsUInt32Number Intent)
Definition: cmsio1.c:584
void _cmsAllocCurvesPluginChunk(struct _cmsContext_struct *ctx, const struct _cmsContext_struct *src)
Definition: cmsgamma.c:106
_cmsCurvesPluginChunkType _cmsCurvesPluginChunk
Definition: cmsgamma.c:124
cmsBool _cmsRegisterParametricCurvesPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmsgamma.c:127
cmsBool _cmsRegisterFormattersPlugin(cmsContext ContextID, cmsPluginBase *Plugin)
Definition: cmspack.c:3347
cmsBool(* _cmsLockMutexFnPtrType)(cmsContext ContextID, void *mtx)
Definition: lcms2_plugin.h:645
void *(* _cmsDupFnPtrType)(cmsContext ContextID, const void *Org, cmsUInt32Number size)
Definition: lcms2_plugin.h:235
void(* _cmsTransform2Fn)(struct _cmstransform_struct *CMMcargo, const void *InputBuffer, void *OutputBuffer, cmsUInt32Number PixelsPerLine, cmsUInt32Number LineCount, const cmsStride *Stride)
Definition: lcms2_plugin.h:596
void *(* _cmsDupUserDataFn)(cmsContext ContextID, const void *Data)
Definition: lcms2_plugin.h:194
void *(* _cmsCallocFnPtrType)(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
Definition: lcms2_plugin.h:234
void(* _cmsFreeFnPtrType)(cmsContext ContextID, void *Ptr)
Definition: lcms2_plugin.h:230
void(* _cmsOPTeval16Fn)(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register const void *Data)
Definition: lcms2_plugin.h:550
void(* _cmsFreeUserDataFn)(cmsContext ContextID, void *Data)
Definition: lcms2_plugin.h:193
void(* _cmsUnlockMutexFnPtrType)(cmsContext ContextID, void *mtx)
Definition: lcms2_plugin.h:646
cmsUInt8Number *(* cmsFormatter16)(register struct _cmstransform_struct *CMMcargo, register cmsUInt16Number Values[], register cmsUInt8Number *Buffer, register cmsUInt32Number Stride)
Definition: lcms2_plugin.h:349
cmsInterpFunction(* cmsInterpFnFactory)(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags)
Definition: lcms2_plugin.h:312
void(* _cmsStageFreeElemFn)(cmsStage *mpe)
Definition: lcms2_plugin.h:493
cmsFormatterDirection
Definition: lcms2_plugin.h:369
void(* _cmsDestroyMutexFnPtrType)(cmsContext ContextID, void *mtx)
Definition: lcms2_plugin.h:644
void *(* _cmsMalloZerocFnPtrType)(cmsContext ContextID, cmsUInt32Number size)
Definition: lcms2_plugin.h:233
void *(* _cmsReallocFnPtrType)(cmsContext ContextID, void *Ptr, cmsUInt32Number NewSize)
Definition: lcms2_plugin.h:231
void *(* _cmsMallocFnPtrType)(cmsContext ContextID, cmsUInt32Number size)
Definition: lcms2_plugin.h:229
void *(* _cmsStageDupElemFn)(cmsStage *mpe)
Definition: lcms2_plugin.h:492
cmsFloat64Number(* cmsParametricCurveEvaluator)(cmsInt32Number Type, const cmsFloat64Number Params[10], cmsFloat64Number R)
Definition: lcms2_plugin.h:328
cmsUInt8Number *(* cmsFormatterFloat)(struct _cmstransform_struct *CMMcargo, cmsFloat32Number Values[], cmsUInt8Number *Buffer, cmsUInt32Number Stride)
Definition: lcms2_plugin.h:354
void(* _cmsTransformFn)(struct _cmstransform_struct *CMMcargo, const void *InputBuffer, void *OutputBuffer, cmsUInt32Number Size, cmsUInt32Number Stride)
Definition: lcms2_plugin.h:589
void(* _cmsStageEvalFn)(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
Definition: lcms2_plugin.h:491
void *(* _cmsCreateMutexFnPtrType)(cmsContext ContextID)
Definition: lcms2_plugin.h:643
static struct tm tm
Definition: localtime.c:216
set set set set set set set set set set set set set set set set set set set set *set set set macro pixldst op &r &cond WK op &r &cond WK op &r &cond WK else op &m &cond &ia op &r &cond WK else op &m &cond &ia elseif elseif else error unsupported base if elseif elseif else error unsupported unaligned pixldst unaligned endm macro pixst base base else pixldst base endif endm macro PF ptr
static int size
Definition: ppmlabel.c:24
int r
Definition: ppmqvga.c:68
static FILE * in
Definition: squeeze.c:36
A string of characters.
Definition: t1part.c:49
Definition: lobject.h:497
cmsFloat64Number AdaptationState
void * chunks[MemoryClientMax]
struct _cmsContext_struct * Next
_cmsSubAllocator * MemPool
_cmsMemPluginChunkType DefaultMemoryManager
struct _cmsParametricCurvesCollection_st * ParametricCurves
struct _cms_formatters_factory_list * FactoryList
struct _cms_intents_list * Intents
cmsInterpFnFactory Interpolators
cmsLogErrorHandlerFunction LogErrorHandler
cmsUInt16Number Country
cmsUInt32Number StrW
cmsUInt16Number Language
cmsUInt32Number Len
_cmsMallocFnPtrType MallocPtr
_cmsReallocFnPtrType ReallocPtr
_cmsMalloZerocFnPtrType MallocZeroPtr
_cmsCallocFnPtrType CallocPtr
_cmsFreeFnPtrType FreePtr
_cmsDupFnPtrType DupPtr
_cmsLockMutexFnPtrType LockMutexPtr
_cmsCreateMutexFnPtrType CreateMutexPtr
_cmsUnlockMutexFnPtrType UnlockMutexPtr
_cmsDestroyMutexFnPtrType DestroyMutexPtr
struct _cmsOptimizationCollection_st * OptimizationCollection
cmsUInt32Number InputChannels
_cmsOPTeval16Fn Eval16Fn
cmsUInt32Number OutputChannels
_cmsDupUserDataFn DupDataFn
_cmsFreeUserDataFn FreeDataFn
_cmsPipelineEvalFloatFn EvalFloatFn
cmsStageSignature Implements
_cmsStageEvalFn EvalPtr
_cmsStageFreeElemFn FreePtr
_cmsStageDupElemFn DupElemPtr
cmsContext ContextID
struct _cmsStage_struct * Next
cmsUInt32Number OutputChannels
cmsUInt32Number InputChannels
cmsStageSignature Type
struct _cmsSubAllocator_chunk_st * next
_cmsSubAllocator_chunk * h
cmsContext ContextID
struct _cmsTagLinkedList_st * Tag
struct _cmsTagTypeLinkedList_st * TagTypes
struct _cmsTransformCollection_st * TransformCollection
cmsUInt32Number UsedEntries
_cmsMLUentry * Entries
cmsUInt32Number AllocatedEntries
cmsContext ContextID
cmsUInt32Number PoolSize
cmsUInt32Number PoolUsed
cmsUInt32Number ColorantCount
cmsInterpParams * InterpParams
cmsUInt32Number nEntries
cmsUInt32Number nSegments
cmsInterpParams ** SegInterp
cmsUInt16Number * Table16
cmsCurveSegment * Segments
cmsParametricCurveEvaluator * Evals
cmsTagSignature TagLinked[100]
cmsUInt32Number RenderingIntent
cmsColorSpaceSignature ColorSpace
cmsUInt32Number TagOffsets[100]
cmsColorSpaceSignature PCS
cmsUInt32Number creator
cmsUInt32Number Version
cmsTagSignature TagNames[100]
cmsUInt32Number TagSizes[100]
cmsProfileClassSignature DeviceClass
cmsUInt32Number flags
cmsUInt32Number TagCount
cmsUInt64Number attributes
cmsUInt32Number model
cmsUInt32Number manufacturer
cmsTagTypeHandler * TagTypeHandlers[100]
cmsIOHANDLER * IOhandler
_cmsTransformFn OldXform
cmsFloat64Number AdaptationState
cmsFormatter16 FromInput
cmsUInt32Number InputFormat
cmsPipeline * GamutCheck
cmsFormatterFloat ToOutputFloat
cmsNAMEDCOLORLIST * OutputColorant
cmsColorSpaceSignature EntryColorSpace
cmsUInt32Number RenderingIntent
cmsUInt32Number dwOriginalFlags
cmsFormatter16 ToOutput
cmsFormatterFloat FromInputFloat
_cmsFreeUserDataFn FreeUserData
cmsNAMEDCOLORLIST * InputColorant
cmsColorSpaceSignature ExitColorSpace
cmsUInt32Number OutputFormat
_cmsTransform2Fn xform
Definition: lcms2.h:1404
Definition: strexpr.c:21
val
Definition: tex4ht.c:3227
m
Definition: tex4ht.c:3990