1/*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25// This file is available under and governed by the GNU General Public
26// License version 2 only, as published by the Free Software Foundation.
27// However, the following notice accompanied the original version of this
28// file:
29//
30//---------------------------------------------------------------------------------
31//
32// Little Color Management System
33// Copyright (c) 1998-2017 Marti Maria Saguer
34//
35// Permission is hereby granted, free of charge, to any person obtaining
36// a copy of this software and associated documentation files (the "Software"),
37// to deal in the Software without restriction, including without limitation
38// the rights to use, copy, modify, merge, publish, distribute, sublicense,
39// and/or sell copies of the Software, and to permit persons to whom the Software
40// is furnished to do so, subject to the following conditions:
41//
42// The above copyright notice and this permission notice shall be included in
43// all copies or substantial portions of the Software.
44//
45// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
46// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
47// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
48// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
49// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
50// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
51// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
52//
53//---------------------------------------------------------------------------------
54
55#include "lcms2_internal.h"
56
57
58// This function is here to help applications to prevent mixing lcms versions on header and shared objects.
59int CMSEXPORT cmsGetEncodedCMMversion(void)
60{
61 return LCMS_VERSION;
62}
63
64// I am so tired about incompatibilities on those functions that here are some replacements
65// that hopefully would be fully portable.
66
67// compare two strings ignoring case
68int CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2)
69{
70 register const unsigned char *us1 = (const unsigned char *)s1,
71 *us2 = (const unsigned char *)s2;
72
73 while (toupper(*us1) == toupper(*us2++))
74 if (*us1++ == '\0')
75 return 0;
76
77 return (toupper(*us1) - toupper(*--us2));
78}
79
80// long int because C99 specifies ftell in such way (7.19.9.2)
81long int CMSEXPORT cmsfilelength(FILE* f)
82{
83 long int p , n;
84
85 p = ftell(f); // register current file position
86 if (p == -1L)
87 return -1L;
88
89 if (fseek(f, 0, SEEK_END) != 0) {
90 return -1L;
91 }
92
93 n = ftell(f);
94 fseek(f, p, SEEK_SET); // file position restored
95
96 return n;
97}
98
99
100// Memory handling ------------------------------------------------------------------
101//
102// This is the interface to low-level memory management routines. By default a simple
103// wrapping to malloc/free/realloc is provided, although there is a limit on the max
104// amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent
105// bogus or evil code to allocate huge blocks that otherwise lcms would never need.
106
107#define MAX_MEMORY_FOR_ALLOC ((cmsUInt32Number)(1024U*1024U*512U))
108
109// User may override this behaviour by using a memory plug-in, which basically replaces
110// the default memory management functions. In this case, no check is performed and it
111// is up to the plug-in writter to keep in the safe side. There are only three functions
112// required to be implemented: malloc, realloc and free, although the user may want to
113// replace the optional mallocZero, calloc and dup as well.
114
115cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin);
116
117// *********************************************************************************
118
119// This is the default memory allocation function. It does a very coarse
120// check of amount of memory, just to prevent exploits
121static
122void* _cmsMallocDefaultFn(cmsContext ContextID, cmsUInt32Number size)
123{
124 if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never allow over maximum
125
126 return (void*) malloc(size);
127
128 cmsUNUSED_PARAMETER(ContextID);
129}
130
131// Generic allocate & zero
132static
133void* _cmsMallocZeroDefaultFn(cmsContext ContextID, cmsUInt32Number size)
134{
135 void *pt = _cmsMalloc(ContextID, size);
136 if (pt == NULL) return NULL;
137
138 memset(pt, 0, size);
139 return pt;
140}
141
142
143// The default free function. The only check proformed is against NULL pointers
144static
145void _cmsFreeDefaultFn(cmsContext ContextID, void *Ptr)
146{
147 // free(NULL) is defined a no-op by C99, therefore it is safe to
148 // avoid the check, but it is here just in case...
149
150 if (Ptr) free(Ptr);
151
152 cmsUNUSED_PARAMETER(ContextID);
153}
154
155// The default realloc function. Again it checks for exploits. If Ptr is NULL,
156// realloc behaves the same way as malloc and allocates a new block of size bytes.
157static
158void* _cmsReallocDefaultFn(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
159{
160
161 if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never realloc over 512Mb
162
163 return realloc(Ptr, size);
164
165 cmsUNUSED_PARAMETER(ContextID);
166}
167
168
169// The default calloc function. Allocates an array of num elements, each one of size bytes
170// all memory is initialized to zero.
171static
172void* _cmsCallocDefaultFn(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
173{
174 cmsUInt32Number Total = num * size;
175
176 // Preserve calloc behaviour
177 if (Total == 0) return NULL;
178
179 // Safe check for overflow.
180 if (num >= UINT_MAX / size) return NULL;
181
182 // Check for overflow
183 if (Total < num || Total < size) {
184 return NULL;
185 }
186
187 if (Total > MAX_MEMORY_FOR_ALLOC) return NULL; // Never alloc over 512Mb
188
189 return _cmsMallocZero(ContextID, Total);
190}
191
192// Generic block duplication
193static
194void* _cmsDupDefaultFn(cmsContext ContextID, const void* Org, cmsUInt32Number size)
195{
196 void* mem;
197
198 if (size > MAX_MEMORY_FOR_ALLOC) return NULL; // Never dup over 512Mb
199
200 mem = _cmsMalloc(ContextID, size);
201
202 if (mem != NULL && Org != NULL)
203 memmove(mem, Org, size);
204
205 return mem;
206}
207
208
209// Pointers to memory manager functions in Context0
210_cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn,
211 _cmsReallocDefaultFn, _cmsCallocDefaultFn, _cmsDupDefaultFn
212 };
213
214
215// Reset and duplicate memory manager
216void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
217{
218 _cmsAssert(ctx != NULL);
219
220 if (src != NULL) {
221
222 // Duplicate
223 ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));
224 }
225 else {
226
227 // To reset it, we use the default allocators, which cannot be overridden
228 ctx ->chunks[MemPlugin] = &ctx ->DefaultMemoryManager;
229 }
230}
231
232// Auxiliary to fill memory management functions from plugin (or context 0 defaults)
233void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr)
234{
235 if (Plugin == NULL) {
236
237 memcpy(ptr, &_cmsMemPluginChunk, sizeof(_cmsMemPluginChunk));
238 }
239 else {
240
241 ptr ->MallocPtr = Plugin -> MallocPtr;
242 ptr ->FreePtr = Plugin -> FreePtr;
243 ptr ->ReallocPtr = Plugin -> ReallocPtr;
244
245 // Make sure we revert to defaults
246 ptr ->MallocZeroPtr= _cmsMallocZeroDefaultFn;
247 ptr ->CallocPtr = _cmsCallocDefaultFn;
248 ptr ->DupPtr = _cmsDupDefaultFn;
249
250 if (Plugin ->MallocZeroPtr != NULL) ptr ->MallocZeroPtr = Plugin -> MallocZeroPtr;
251 if (Plugin ->CallocPtr != NULL) ptr ->CallocPtr = Plugin -> CallocPtr;
252 if (Plugin ->DupPtr != NULL) ptr ->DupPtr = Plugin -> DupPtr;
253
254 }
255}
256
257
258// Plug-in replacement entry
259cmsBool _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase *Data)
260{
261 cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data;
262 _cmsMemPluginChunkType* ptr;
263
264 // NULL forces to reset to defaults. In this special case, the defaults are stored in the context structure.
265 // Remaining plug-ins does NOT have any copy in the context structure, but this is somehow special as the
266 // context internal data should be malloce'd by using those functions.
267 if (Data == NULL) {
268
269 struct _cmsContext_struct* ctx = ( struct _cmsContext_struct*) ContextID;
270
271 // Return to the default allocators
272 if (ContextID != NULL) {
273 ctx->chunks[MemPlugin] = (void*) &ctx->DefaultMemoryManager;
274 }
275 return TRUE;
276 }
277
278 // Check for required callbacks
279 if (Plugin -> MallocPtr == NULL ||
280 Plugin -> FreePtr == NULL ||
281 Plugin -> ReallocPtr == NULL) return FALSE;
282
283 // Set replacement functions
284 ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
285 if (ptr == NULL)
286 return FALSE;
287
288 _cmsInstallAllocFunctions(Plugin, ptr);
289 return TRUE;
290}
291
292// Generic allocate
293void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size)
294{
295 _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
296 return ptr ->MallocPtr(ContextID, size);
297}
298
299// Generic allocate & zero
300void* CMSEXPORT _cmsMallocZero(cmsContext ContextID, cmsUInt32Number size)
301{
302 _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
303 return ptr->MallocZeroPtr(ContextID, size);
304}
305
306// Generic calloc
307void* CMSEXPORT _cmsCalloc(cmsContext ContextID, cmsUInt32Number num, cmsUInt32Number size)
308{
309 _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
310 return ptr->CallocPtr(ContextID, num, size);
311}
312
313// Generic reallocate
314void* CMSEXPORT _cmsRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number size)
315{
316 _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
317 return ptr->ReallocPtr(ContextID, Ptr, size);
318}
319
320// Generic free memory
321void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr)
322{
323 if (Ptr != NULL) {
324 _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
325 ptr ->FreePtr(ContextID, Ptr);
326 }
327}
328
329// Generic block duplication
330void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size)
331{
332 _cmsMemPluginChunkType* ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
333 return ptr ->DupPtr(ContextID, Org, size);
334}
335
336// ********************************************************************************************
337
338// Sub allocation takes care of many pointers of small size. The memory allocated in
339// this way have be freed at once. Next function allocates a single chunk for linked list
340// I prefer this method over realloc due to the big inpact on xput realloc may have if
341// memory is being swapped to disk. This approach is safer (although that may not be true on all platforms)
342static
343_cmsSubAllocator_chunk* _cmsCreateSubAllocChunk(cmsContext ContextID, cmsUInt32Number Initial)
344{
345 _cmsSubAllocator_chunk* chunk;
346
347 // 20K by default
348 if (Initial == 0)
349 Initial = 20*1024;
350
351 // Create the container
352 chunk = (_cmsSubAllocator_chunk*) _cmsMallocZero(ContextID, sizeof(_cmsSubAllocator_chunk));
353 if (chunk == NULL) return NULL;
354
355 // Initialize values
356 chunk ->Block = (cmsUInt8Number*) _cmsMalloc(ContextID, Initial);
357 if (chunk ->Block == NULL) {
358
359 // Something went wrong
360 _cmsFree(ContextID, chunk);
361 return NULL;
362 }
363
364 chunk ->BlockSize = Initial;
365 chunk ->Used = 0;
366 chunk ->next = NULL;
367
368 return chunk;
369}
370
371// The suballocated is nothing but a pointer to the first element in the list. We also keep
372// the thread ID in this structure.
373_cmsSubAllocator* _cmsCreateSubAlloc(cmsContext ContextID, cmsUInt32Number Initial)
374{
375 _cmsSubAllocator* sub;
376
377 // Create the container
378 sub = (_cmsSubAllocator*) _cmsMallocZero(ContextID, sizeof(_cmsSubAllocator));
379 if (sub == NULL) return NULL;
380
381 sub ->ContextID = ContextID;
382
383 sub ->h = _cmsCreateSubAllocChunk(ContextID, Initial);
384 if (sub ->h == NULL) {
385 _cmsFree(ContextID, sub);
386 return NULL;
387 }
388
389 return sub;
390}
391
392
393// Get rid of whole linked list
394void _cmsSubAllocDestroy(_cmsSubAllocator* sub)
395{
396 _cmsSubAllocator_chunk *chunk, *n;
397
398 for (chunk = sub ->h; chunk != NULL; chunk = n) {
399
400 n = chunk->next;
401 if (chunk->Block != NULL) _cmsFree(sub ->ContextID, chunk->Block);
402 _cmsFree(sub ->ContextID, chunk);
403 }
404
405 // Free the header
406 _cmsFree(sub ->ContextID, sub);
407}
408
409
410// Get a pointer to small memory block.
411void* _cmsSubAlloc(_cmsSubAllocator* sub, cmsUInt32Number size)
412{
413 cmsUInt32Number Free = sub -> h ->BlockSize - sub -> h -> Used;
414 cmsUInt8Number* ptr;
415
416 size = _cmsALIGNMEM(size);
417
418 // Check for memory. If there is no room, allocate a new chunk of double memory size.
419 if (size > Free) {
420
421 _cmsSubAllocator_chunk* chunk;
422 cmsUInt32Number newSize;
423
424 newSize = sub -> h ->BlockSize * 2;
425 if (newSize < size) newSize = size;
426
427 chunk = _cmsCreateSubAllocChunk(sub -> ContextID, newSize);
428 if (chunk == NULL) return NULL;
429
430 // Link list
431 chunk ->next = sub ->h;
432 sub ->h = chunk;
433
434 }
435
436 ptr = sub -> h ->Block + sub -> h ->Used;
437 sub -> h -> Used += size;
438
439 return (void*) ptr;
440}
441
442// Duplicate in pool
443void* _cmsSubAllocDup(_cmsSubAllocator* s, const void *ptr, cmsUInt32Number size)
444{
445 void *NewPtr;
446
447 // Dup of null pointer is also NULL
448 if (ptr == NULL)
449 return NULL;
450
451 NewPtr = _cmsSubAlloc(s, size);
452
453 if (ptr != NULL && NewPtr != NULL) {
454 memcpy(NewPtr, ptr, size);
455 }
456
457 return NewPtr;
458}
459
460
461
462// Error logging ******************************************************************
463
464// There is no error handling at all. When a function fails, it returns proper value.
465// For example, all create functions does return NULL on failure. Other return FALSE
466// It may be interesting, for the developer, to know why the function is failing.
467// for that reason, lcms2 does offer a logging function. This function does recive
468// a ENGLISH string with some clues on what is going wrong. You can show this
469// info to the end user, or just create some sort of log.
470// The logging function should NOT terminate the program, as this obviously can leave
471// resources. It is the programmer's responsibility to check each function return code
472// to make sure it didn't fail.
473
474// Error messages are limited to MAX_ERROR_MESSAGE_LEN
475
476#define MAX_ERROR_MESSAGE_LEN 1024
477
478// ---------------------------------------------------------------------------------------------------------
479
480// This is our default log error
481static void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text);
482
483// Context0 storage, which is global
484_cmsLogErrorChunkType _cmsLogErrorChunk = { DefaultLogErrorHandlerFunction };
485
486// Allocates and inits error logger container for a given context. If src is NULL, only initializes the value
487// to the default. Otherwise, it duplicates the value. The interface is standard across all context clients
488void _cmsAllocLogErrorChunk(struct _cmsContext_struct* ctx,
489 const struct _cmsContext_struct* src)
490{
491 static _cmsLogErrorChunkType LogErrorChunk = { DefaultLogErrorHandlerFunction };
492 void* from;
493
494 if (src != NULL) {
495 from = src ->chunks[Logger];
496 }
497 else {
498 from = &LogErrorChunk;
499 }
500
501 ctx ->chunks[Logger] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsLogErrorChunkType));
502}
503
504// The default error logger does nothing.
505static
506void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text)
507{
508 // fprintf(stderr, "[lcms]: %s\n", Text);
509 // fflush(stderr);
510
511 cmsUNUSED_PARAMETER(ContextID);
512 cmsUNUSED_PARAMETER(ErrorCode);
513 cmsUNUSED_PARAMETER(Text);
514}
515
516// Change log error, context based
517void CMSEXPORT cmsSetLogErrorHandlerTHR(cmsContext ContextID, cmsLogErrorHandlerFunction Fn)
518{
519 _cmsLogErrorChunkType* lhg = (_cmsLogErrorChunkType*) _cmsContextGetClientChunk(ContextID, Logger);
520
521 if (lhg != NULL) {
522
523 if (Fn == NULL)
524 lhg -> LogErrorHandler = DefaultLogErrorHandlerFunction;
525 else
526 lhg -> LogErrorHandler = Fn;
527 }
528}
529
530// Change log error, legacy
531void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn)
532{
533 cmsSetLogErrorHandlerTHR(NULL, Fn);
534}
535
536// Log an error
537// ErrorText is a text holding an english description of error.
538void CMSEXPORT cmsSignalError(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *ErrorText, ...)
539{
540 va_list args;
541 char Buffer[MAX_ERROR_MESSAGE_LEN];
542 _cmsLogErrorChunkType* lhg;
543
544
545 va_start(args, ErrorText);
546 vsnprintf(Buffer, MAX_ERROR_MESSAGE_LEN-1, ErrorText, args);
547 va_end(args);
548
549 // Check for the context, if specified go there. If not, go for the global
550 lhg = (_cmsLogErrorChunkType*) _cmsContextGetClientChunk(ContextID, Logger);
551 if (lhg ->LogErrorHandler) {
552 lhg ->LogErrorHandler(ContextID, ErrorCode, Buffer);
553 }
554}
555
556// Utility function to print signatures
557void _cmsTagSignature2String(char String[5], cmsTagSignature sig)
558{
559 cmsUInt32Number be;
560
561 // Convert to big endian
562 be = _cmsAdjustEndianess32((cmsUInt32Number) sig);
563
564 // Move chars
565 memmove(String, &be, 4);
566
567 // Make sure of terminator
568 String[4] = 0;
569}
570
571//--------------------------------------------------------------------------------------------------
572
573
574static
575void* defMtxCreate(cmsContext id)
576{
577 _cmsMutex* ptr_mutex = (_cmsMutex*) _cmsMalloc(id, sizeof(_cmsMutex));
578 _cmsInitMutexPrimitive(ptr_mutex);
579 return (void*) ptr_mutex;
580}
581
582static
583void defMtxDestroy(cmsContext id, void* mtx)
584{
585 _cmsDestroyMutexPrimitive((_cmsMutex *) mtx);
586 _cmsFree(id, mtx);
587}
588
589static
590cmsBool defMtxLock(cmsContext id, void* mtx)
591{
592 cmsUNUSED_PARAMETER(id);
593 return _cmsLockPrimitive((_cmsMutex *) mtx) == 0;
594}
595
596static
597void defMtxUnlock(cmsContext id, void* mtx)
598{
599 cmsUNUSED_PARAMETER(id);
600 _cmsUnlockPrimitive((_cmsMutex *) mtx);
601}
602
603
604
605// Pointers to memory manager functions in Context0
606_cmsMutexPluginChunkType _cmsMutexPluginChunk = { defMtxCreate, defMtxDestroy, defMtxLock, defMtxUnlock };
607
608// Allocate and init mutex container.
609void _cmsAllocMutexPluginChunk(struct _cmsContext_struct* ctx,
610 const struct _cmsContext_struct* src)
611{
612 static _cmsMutexPluginChunkType MutexChunk = {defMtxCreate, defMtxDestroy, defMtxLock, defMtxUnlock };
613 void* from;
614
615 if (src != NULL) {
616 from = src ->chunks[MutexPlugin];
617 }
618 else {
619 from = &MutexChunk;
620 }
621
622 ctx ->chunks[MutexPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsMutexPluginChunkType));
623}
624
625// Register new ways to transform
626cmsBool _cmsRegisterMutexPlugin(cmsContext ContextID, cmsPluginBase* Data)
627{
628 cmsPluginMutex* Plugin = (cmsPluginMutex*) Data;
629 _cmsMutexPluginChunkType* ctx = ( _cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
630
631 if (Data == NULL) {
632
633 // No lock routines
634 ctx->CreateMutexPtr = NULL;
635 ctx->DestroyMutexPtr = NULL;
636 ctx->LockMutexPtr = NULL;
637 ctx ->UnlockMutexPtr = NULL;
638 return TRUE;
639 }
640
641 // Factory callback is required
642 if (Plugin ->CreateMutexPtr == NULL || Plugin ->DestroyMutexPtr == NULL ||
643 Plugin ->LockMutexPtr == NULL || Plugin ->UnlockMutexPtr == NULL) return FALSE;
644
645
646 ctx->CreateMutexPtr = Plugin->CreateMutexPtr;
647 ctx->DestroyMutexPtr = Plugin ->DestroyMutexPtr;
648 ctx ->LockMutexPtr = Plugin ->LockMutexPtr;
649 ctx ->UnlockMutexPtr = Plugin ->UnlockMutexPtr;
650
651 // All is ok
652 return TRUE;
653}
654
655// Generic Mutex fns
656void* CMSEXPORT _cmsCreateMutex(cmsContext ContextID)
657{
658 _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
659
660 if (ptr ->CreateMutexPtr == NULL) return NULL;
661
662 return ptr ->CreateMutexPtr(ContextID);
663}
664
665void CMSEXPORT _cmsDestroyMutex(cmsContext ContextID, void* mtx)
666{
667 _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
668
669 if (ptr ->DestroyMutexPtr != NULL) {
670
671 ptr ->DestroyMutexPtr(ContextID, mtx);
672 }
673}
674
675cmsBool CMSEXPORT _cmsLockMutex(cmsContext ContextID, void* mtx)
676{
677 _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
678
679 if (ptr ->LockMutexPtr == NULL) return TRUE;
680
681 return ptr ->LockMutexPtr(ContextID, mtx);
682}
683
684void CMSEXPORT _cmsUnlockMutex(cmsContext ContextID, void* mtx)
685{
686 _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
687
688 if (ptr ->UnlockMutexPtr != NULL) {
689
690 ptr ->UnlockMutexPtr(ContextID, mtx);
691 }
692}
693